1 | /* $Id: ntBldSymDb.cpp 62592 2016-07-27 13:24:48Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - RTDirCreateUniqueNumbered, generic implementation.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2013-2016 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | *
|
---|
17 | * The contents of this file may alternatively be used under the terms
|
---|
18 | * of the Common Development and Distribution License Version 1.0
|
---|
19 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
20 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
21 | * CDDL are applicable instead of those of the GPL.
|
---|
22 | *
|
---|
23 | * You may elect to license modified versions of this file under the
|
---|
24 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
25 | */
|
---|
26 |
|
---|
27 |
|
---|
28 | /*********************************************************************************************************************************
|
---|
29 | * Header Files *
|
---|
30 | *********************************************************************************************************************************/
|
---|
31 | #include <iprt/win/windows.h>
|
---|
32 | #include <Dbghelp.h>
|
---|
33 |
|
---|
34 | #include <iprt/alloca.h>
|
---|
35 | #include <iprt/dir.h>
|
---|
36 | #include <iprt/file.h>
|
---|
37 | #include <iprt/getopt.h>
|
---|
38 | #include <iprt/initterm.h>
|
---|
39 | #include <iprt/list.h>
|
---|
40 | #include <iprt/mem.h>
|
---|
41 | #include <iprt/message.h>
|
---|
42 | #include <iprt/path.h>
|
---|
43 | #include <iprt/stream.h>
|
---|
44 | #include <iprt/string.h>
|
---|
45 | #include <iprt/err.h>
|
---|
46 |
|
---|
47 | #include "r0drv/nt/symdb.h"
|
---|
48 |
|
---|
49 |
|
---|
50 | /*********************************************************************************************************************************
|
---|
51 | * Structures and Typedefs *
|
---|
52 | *********************************************************************************************************************************/
|
---|
53 | /** A structure member we're interested in. */
|
---|
54 | typedef struct MYMEMBER
|
---|
55 | {
|
---|
56 | /** The member name. */
|
---|
57 | const char * const pszName;
|
---|
58 | /** Reserved. */
|
---|
59 | uint32_t const fFlags;
|
---|
60 | /** The offset of the member. UINT32_MAX if not found. */
|
---|
61 | uint32_t off;
|
---|
62 | /** The size of the member. */
|
---|
63 | uint32_t cb;
|
---|
64 | /** Alternative names, optional.
|
---|
65 | * This is a string of zero terminated strings, ending with an zero length
|
---|
66 | * string (or double '\\0' if you like). */
|
---|
67 | const char * const pszzAltNames;
|
---|
68 | } MYMEMBER;
|
---|
69 | /** Pointer to a member we're interested. */
|
---|
70 | typedef MYMEMBER *PMYMEMBER;
|
---|
71 |
|
---|
72 | /** Members we're interested in. */
|
---|
73 | typedef struct MYSTRUCT
|
---|
74 | {
|
---|
75 | /** The structure name. */
|
---|
76 | const char * const pszName;
|
---|
77 | /** Array of members we're interested in. */
|
---|
78 | MYMEMBER *paMembers;
|
---|
79 | /** The number of members we're interested in. */
|
---|
80 | uint32_t const cMembers;
|
---|
81 | /** Reserved. */
|
---|
82 | uint32_t const fFlags;
|
---|
83 | } MYSTRUCT;
|
---|
84 |
|
---|
85 | /** Architecture. */
|
---|
86 | typedef enum MYARCH
|
---|
87 | {
|
---|
88 | MYARCH_X86,
|
---|
89 | MYARCH_AMD64,
|
---|
90 | MYARCH_DETECT
|
---|
91 | } MYARCH;
|
---|
92 |
|
---|
93 | /** Set of structures for one kernel. */
|
---|
94 | typedef struct MYSET
|
---|
95 | {
|
---|
96 | /** The list entry. */
|
---|
97 | RTLISTNODE ListEntry;
|
---|
98 | /** The source PDB. */
|
---|
99 | char *pszPdb;
|
---|
100 | /** The OS version we've harvested structs for */
|
---|
101 | RTNTSDBOSVER OsVerInfo;
|
---|
102 | /** The architecture. */
|
---|
103 | MYARCH enmArch;
|
---|
104 | /** The structures and their member. */
|
---|
105 | MYSTRUCT aStructs[1];
|
---|
106 | } MYSET;
|
---|
107 | /** Pointer a set of structures for one kernel. */
|
---|
108 | typedef MYSET *PMYSET;
|
---|
109 |
|
---|
110 |
|
---|
111 | /*********************************************************************************************************************************
|
---|
112 | * Global Variables *
|
---|
113 | *********************************************************************************************************************************/
|
---|
114 | /** Verbosity level (-v, --verbose). */
|
---|
115 | static uint32_t g_iOptVerbose = 1;
|
---|
116 | /** Set if we should force ahead despite errors. */
|
---|
117 | static bool g_fOptForce = false;
|
---|
118 |
|
---|
119 | /** The members of the KPRCB structure that we're interested in. */
|
---|
120 | static MYMEMBER g_aKprcbMembers[] =
|
---|
121 | {
|
---|
122 | { "QuantumEnd", 0, UINT32_MAX, UINT32_MAX, NULL },
|
---|
123 | { "DpcQueueDepth", 0, UINT32_MAX, UINT32_MAX, "DpcData[0].DpcQueueDepth\0" },
|
---|
124 | { "VendorString", 0, UINT32_MAX, UINT32_MAX, NULL },
|
---|
125 | };
|
---|
126 |
|
---|
127 | /** The structures we're interested in. */
|
---|
128 | static MYSTRUCT g_aStructs[] =
|
---|
129 | {
|
---|
130 | { "_KPRCB", &g_aKprcbMembers[0], RT_ELEMENTS(g_aKprcbMembers), 0 },
|
---|
131 | };
|
---|
132 |
|
---|
133 | /** List of data we've found. This is sorted by version info. */
|
---|
134 | static RTLISTANCHOR g_SetList;
|
---|
135 |
|
---|
136 |
|
---|
137 |
|
---|
138 |
|
---|
139 |
|
---|
140 | /**
|
---|
141 | * For debug/verbose output.
|
---|
142 | *
|
---|
143 | * @param pszFormat The format string.
|
---|
144 | * @param ... The arguments referenced in the format string.
|
---|
145 | */
|
---|
146 | static void MyDbgPrintf(const char *pszFormat, ...)
|
---|
147 | {
|
---|
148 | if (g_iOptVerbose > 1)
|
---|
149 | {
|
---|
150 | va_list va;
|
---|
151 | va_start(va, pszFormat);
|
---|
152 | RTPrintf("debug: ");
|
---|
153 | RTPrintfV(pszFormat, va);
|
---|
154 | va_end(va);
|
---|
155 | }
|
---|
156 | }
|
---|
157 |
|
---|
158 |
|
---|
159 | /**
|
---|
160 | * Returns the name we wish to use in the C code.
|
---|
161 | * @returns Structure name.
|
---|
162 | * @param pStruct The structure descriptor.
|
---|
163 | */
|
---|
164 | static const char *figureCStructName(MYSTRUCT const *pStruct)
|
---|
165 | {
|
---|
166 | const char *psz = pStruct->pszName;
|
---|
167 | while (*psz == '_')
|
---|
168 | psz++;
|
---|
169 | return psz;
|
---|
170 | }
|
---|
171 |
|
---|
172 |
|
---|
173 | /**
|
---|
174 | * Returns the name we wish to use in the C code.
|
---|
175 | * @returns Member name.
|
---|
176 | * @param pMember The member descriptor.
|
---|
177 | */
|
---|
178 | static const char *figureCMemberName(MYMEMBER const *pMember)
|
---|
179 | {
|
---|
180 | return pMember->pszName;
|
---|
181 | }
|
---|
182 |
|
---|
183 |
|
---|
184 | /**
|
---|
185 | * Creates a MYSET with copies of all the data and inserts it into the
|
---|
186 | * g_SetList in a orderly fashion.
|
---|
187 | *
|
---|
188 | * @param pOut The output stream.
|
---|
189 | */
|
---|
190 | static void generateHeader(PRTSTREAM pOut)
|
---|
191 | {
|
---|
192 | RTStrmPrintf(pOut,
|
---|
193 | "/* $" "I" "d" ": $ */\n" /* avoid it being expanded */
|
---|
194 | "/** @file\n"
|
---|
195 | " * IPRT - NT kernel type helpers - Autogenerated, do NOT edit.\n"
|
---|
196 | " */\n"
|
---|
197 | "\n"
|
---|
198 | "/*\n"
|
---|
199 | " * Copyright (C) 2013-2016 Oracle Corporation \n"
|
---|
200 | " *\n"
|
---|
201 | " * This file is part of VirtualBox Open Source Edition (OSE), as\n"
|
---|
202 | " * available from http://www.virtualbox.org. This file is free software;\n"
|
---|
203 | " * you can redistribute it and/or modify it under the terms of the GNU\n"
|
---|
204 | " * General Public License (GPL) as published by the Free Software\n"
|
---|
205 | " * Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
|
---|
206 | " * VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
|
---|
207 | " * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
|
---|
208 | " *\n"
|
---|
209 | " * The contents of this file may alternatively be used under the terms\n"
|
---|
210 | " * of the Common Development and Distribution License Version 1.0\n"
|
---|
211 | " * (CDDL) only, as it comes in the \"COPYING.CDDL\" file of the\n"
|
---|
212 | " * VirtualBox OSE distribution, in which case the provisions of the\n"
|
---|
213 | " * CDDL are applicable instead of those of the GPL.\n"
|
---|
214 | " *\n"
|
---|
215 | " * You may elect to license modified versions of this file under the\n"
|
---|
216 | " * terms and conditions of either the GPL or the CDDL or both.\n"
|
---|
217 | " */\n"
|
---|
218 | "\n"
|
---|
219 | "\n"
|
---|
220 | "#ifndef ___r0drv_nt_symdbdata_h\n"
|
---|
221 | "#define ___r0drv_nt_symdbdata_h\n"
|
---|
222 | "\n"
|
---|
223 | "#include \"r0drv/nt/symdb.h\"\n"
|
---|
224 | "\n"
|
---|
225 | );
|
---|
226 |
|
---|
227 | /*
|
---|
228 | * Generate types.
|
---|
229 | */
|
---|
230 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
|
---|
231 | {
|
---|
232 | const char *pszStructName = figureCStructName(&g_aStructs[i]);
|
---|
233 |
|
---|
234 | RTStrmPrintf(pOut,
|
---|
235 | "typedef struct RTNTSDBTYPE_%s\n"
|
---|
236 | "{\n",
|
---|
237 | pszStructName);
|
---|
238 | PMYMEMBER paMembers = g_aStructs[i].paMembers;
|
---|
239 | for (uint32_t j = 0; j < g_aStructs->cMembers; j++)
|
---|
240 | {
|
---|
241 | const char *pszMemName = figureCMemberName(&paMembers[j]);
|
---|
242 | RTStrmPrintf(pOut,
|
---|
243 | " uint32_t off%s;\n"
|
---|
244 | " uint32_t cb%s;\n",
|
---|
245 | pszMemName, pszMemName);
|
---|
246 | }
|
---|
247 |
|
---|
248 | RTStrmPrintf(pOut,
|
---|
249 | "} RTNTSDBTYPE_%s;\n"
|
---|
250 | "\n",
|
---|
251 | pszStructName);
|
---|
252 | }
|
---|
253 |
|
---|
254 | RTStrmPrintf(pOut,
|
---|
255 | "\n"
|
---|
256 | "typedef struct RTNTSDBSET\n"
|
---|
257 | "{\n"
|
---|
258 | " RTNTSDBOSVER%-20s OsVerInfo;\n", "");
|
---|
259 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
|
---|
260 | {
|
---|
261 | const char *pszStructName = figureCStructName(&g_aStructs[i]);
|
---|
262 | RTStrmPrintf(pOut, " RTNTSDBTYPE_%-20s %s;\n", pszStructName, pszStructName);
|
---|
263 | }
|
---|
264 | RTStrmPrintf(pOut,
|
---|
265 | "} RTNTSDBSET;\n"
|
---|
266 | "typedef RTNTSDBSET const *PCRTNTSDBSET;\n"
|
---|
267 | "\n");
|
---|
268 |
|
---|
269 | /*
|
---|
270 | * Output the data.
|
---|
271 | */
|
---|
272 | RTStrmPrintf(pOut,
|
---|
273 | "\n"
|
---|
274 | "#ifndef RTNTSDB_NO_DATA\n"
|
---|
275 | "const RTNTSDBSET g_artNtSdbSets[] = \n"
|
---|
276 | "{\n");
|
---|
277 | PMYSET pSet;
|
---|
278 | RTListForEach(&g_SetList, pSet, MYSET, ListEntry)
|
---|
279 | {
|
---|
280 | const char *pszArch = pSet->enmArch == MYARCH_AMD64 ? "AMD64" : "X86";
|
---|
281 | RTStrmPrintf(pOut,
|
---|
282 | "# ifdef RT_ARCH_%s\n"
|
---|
283 | " { /* Source: %s */\n"
|
---|
284 | " /*.OsVerInfo = */\n"
|
---|
285 | " {\n"
|
---|
286 | " /* .uMajorVer = */ %u,\n"
|
---|
287 | " /* .uMinorVer = */ %u,\n"
|
---|
288 | " /* .fChecked = */ %s,\n"
|
---|
289 | " /* .fSmp = */ %s,\n"
|
---|
290 | " /* .uCsdNo = */ %u,\n"
|
---|
291 | " /* .uBuildNo = */ %u,\n"
|
---|
292 | " },\n",
|
---|
293 | pszArch,
|
---|
294 | pSet->pszPdb,
|
---|
295 | pSet->OsVerInfo.uMajorVer,
|
---|
296 | pSet->OsVerInfo.uMinorVer,
|
---|
297 | pSet->OsVerInfo.fChecked ? "true" : "false",
|
---|
298 | pSet->OsVerInfo.fSmp ? "true" : "false",
|
---|
299 | pSet->OsVerInfo.uCsdNo,
|
---|
300 | pSet->OsVerInfo.uBuildNo);
|
---|
301 | for (uint32_t i = 0; i < RT_ELEMENTS(pSet->aStructs); i++)
|
---|
302 | {
|
---|
303 | const char *pszStructName = figureCStructName(&pSet->aStructs[i]);
|
---|
304 | RTStrmPrintf(pOut,
|
---|
305 | " /* .%s = */\n"
|
---|
306 | " {\n", pszStructName);
|
---|
307 | PMYMEMBER paMembers = pSet->aStructs[i].paMembers;
|
---|
308 | for (uint32_t j = 0; j < pSet->aStructs[i].cMembers; j++)
|
---|
309 | {
|
---|
310 | const char *pszMemName = figureCMemberName(&paMembers[j]);
|
---|
311 | RTStrmPrintf(pOut,
|
---|
312 | " /* .off%-25s = */ %#06x,\n"
|
---|
313 | " /* .cb%-26s = */ %#06x,\n",
|
---|
314 | pszMemName, paMembers[j].off,
|
---|
315 | pszMemName, paMembers[j].cb);
|
---|
316 | }
|
---|
317 | RTStrmPrintf(pOut,
|
---|
318 | " },\n");
|
---|
319 | }
|
---|
320 | RTStrmPrintf(pOut,
|
---|
321 | " },\n"
|
---|
322 | "# endif\n"
|
---|
323 | );
|
---|
324 | }
|
---|
325 |
|
---|
326 | RTStrmPrintf(pOut,
|
---|
327 | "};\n"
|
---|
328 | "#endif /* !RTNTSDB_NO_DATA */\n"
|
---|
329 | "\n");
|
---|
330 |
|
---|
331 | RTStrmPrintf(pOut, "\n#endif\n\n");
|
---|
332 | }
|
---|
333 |
|
---|
334 |
|
---|
335 | /**
|
---|
336 | * Creates a MYSET with copies of all the data and inserts it into the
|
---|
337 | * g_SetList in a orderly fashion.
|
---|
338 | *
|
---|
339 | * @returns Fully complained exit code.
|
---|
340 | * @param pOsVerInfo The OS version info.
|
---|
341 | * @param enmArch The NT architecture of the incoming PDB.
|
---|
342 | * @param pszPdb The PDB file name.
|
---|
343 | */
|
---|
344 | static RTEXITCODE saveStructures(PRTNTSDBOSVER pOsVerInfo, MYARCH enmArch, const char *pszPdb)
|
---|
345 | {
|
---|
346 | /*
|
---|
347 | * Allocate one big chunk, figure it's size once.
|
---|
348 | */
|
---|
349 | static size_t s_cbNeeded = 0;
|
---|
350 | if (s_cbNeeded == 0)
|
---|
351 | {
|
---|
352 | s_cbNeeded = RT_OFFSETOF(MYSET, aStructs[RT_ELEMENTS(g_aStructs)]);
|
---|
353 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
|
---|
354 | s_cbNeeded += sizeof(MYMEMBER) * g_aStructs[i].cMembers;
|
---|
355 | }
|
---|
356 |
|
---|
357 | size_t cbPdb = strlen(pszPdb) + 1;
|
---|
358 | PMYSET pSet = (PMYSET)RTMemAlloc(s_cbNeeded + cbPdb);
|
---|
359 | if (!pSet)
|
---|
360 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory!\n");
|
---|
361 |
|
---|
362 | /*
|
---|
363 | * Copy over the data.
|
---|
364 | */
|
---|
365 | pSet->enmArch = enmArch;
|
---|
366 | memcpy(&pSet->OsVerInfo, pOsVerInfo, sizeof(pSet->OsVerInfo));
|
---|
367 | memcpy(&pSet->aStructs[0], g_aStructs, sizeof(g_aStructs));
|
---|
368 |
|
---|
369 | PMYMEMBER pDst = (PMYMEMBER)&pSet->aStructs[RT_ELEMENTS(g_aStructs)];
|
---|
370 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
|
---|
371 | {
|
---|
372 | pSet->aStructs[i].paMembers = pDst;
|
---|
373 | memcpy(pDst, g_aStructs[i].paMembers, g_aStructs[i].cMembers * sizeof(*pDst));
|
---|
374 | pDst += g_aStructs[i].cMembers;
|
---|
375 | }
|
---|
376 |
|
---|
377 | pSet->pszPdb = (char *)pDst;
|
---|
378 | memcpy(pDst, pszPdb, cbPdb);
|
---|
379 |
|
---|
380 | /*
|
---|
381 | * Link it.
|
---|
382 | */
|
---|
383 | PMYSET pInsertBefore;
|
---|
384 | RTListForEach(&g_SetList, pInsertBefore, MYSET, ListEntry)
|
---|
385 | {
|
---|
386 | int iDiff = rtNtOsVerInfoCompare(&pInsertBefore->OsVerInfo, &pSet->OsVerInfo);
|
---|
387 | if (iDiff >= 0)
|
---|
388 | {
|
---|
389 | if (iDiff > 0 || pInsertBefore->enmArch > pSet->enmArch)
|
---|
390 | {
|
---|
391 | RTListNodeInsertBefore(&pInsertBefore->ListEntry, &pSet->ListEntry);
|
---|
392 | return RTEXITCODE_SUCCESS;
|
---|
393 | }
|
---|
394 | }
|
---|
395 | }
|
---|
396 |
|
---|
397 | RTListAppend(&g_SetList, &pSet->ListEntry);
|
---|
398 | return RTEXITCODE_SUCCESS;
|
---|
399 | }
|
---|
400 |
|
---|
401 |
|
---|
402 | /**
|
---|
403 | * Checks that we found everything.
|
---|
404 | *
|
---|
405 | * @returns Fully complained exit code.
|
---|
406 | */
|
---|
407 | static RTEXITCODE checkThatWeFoundEverything(void)
|
---|
408 | {
|
---|
409 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
410 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
|
---|
411 | {
|
---|
412 | PMYMEMBER paMembers = g_aStructs[i].paMembers;
|
---|
413 | uint32_t j = g_aStructs[i].cMembers;
|
---|
414 | while (j-- > 0)
|
---|
415 | {
|
---|
416 | if (paMembers[j].off == UINT32_MAX)
|
---|
417 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, " Missing %s::%s\n", g_aStructs[i].pszName, paMembers[j].pszName);
|
---|
418 | }
|
---|
419 | }
|
---|
420 | return rcExit;
|
---|
421 | }
|
---|
422 |
|
---|
423 |
|
---|
424 | /**
|
---|
425 | * Matches the member against what we're looking for.
|
---|
426 | *
|
---|
427 | * @returns Number of hits.
|
---|
428 | * @param cWantedMembers The number members in paWantedMembers.
|
---|
429 | * @param paWantedMembers The members we're looking for.
|
---|
430 | * @param pszPrefix The member name prefix.
|
---|
431 | * @param pszMember The member name.
|
---|
432 | * @param offMember The member offset.
|
---|
433 | * @param cbMember The member size.
|
---|
434 | */
|
---|
435 | static uint32_t matchUpStructMembers(unsigned cWantedMembers, PMYMEMBER paWantedMembers,
|
---|
436 | const char *pszPrefix, const char *pszMember,
|
---|
437 | uint32_t offMember, uint32_t cbMember)
|
---|
438 | {
|
---|
439 | size_t cchPrefix = strlen(pszPrefix);
|
---|
440 | uint32_t cHits = 0;
|
---|
441 | uint32_t iMember = cWantedMembers;
|
---|
442 | while (iMember-- > 0)
|
---|
443 | {
|
---|
444 | if ( !strncmp(pszPrefix, paWantedMembers[iMember].pszName, cchPrefix)
|
---|
445 | && !strcmp(pszMember, paWantedMembers[iMember].pszName + cchPrefix))
|
---|
446 | {
|
---|
447 | paWantedMembers[iMember].off = offMember;
|
---|
448 | paWantedMembers[iMember].cb = cbMember;
|
---|
449 | cHits++;
|
---|
450 | }
|
---|
451 | else if (paWantedMembers[iMember].pszzAltNames)
|
---|
452 | {
|
---|
453 | char const *pszCur = paWantedMembers[iMember].pszzAltNames;
|
---|
454 | while (*pszCur)
|
---|
455 | {
|
---|
456 | size_t cchCur = strlen(pszCur);
|
---|
457 | if ( !strncmp(pszPrefix, pszCur, cchPrefix)
|
---|
458 | && !strcmp(pszMember, pszCur + cchPrefix))
|
---|
459 | {
|
---|
460 | paWantedMembers[iMember].off = offMember;
|
---|
461 | paWantedMembers[iMember].cb = cbMember;
|
---|
462 | cHits++;
|
---|
463 | break;
|
---|
464 | }
|
---|
465 | pszCur += cchCur + 1;
|
---|
466 | }
|
---|
467 | }
|
---|
468 | }
|
---|
469 | return cHits;
|
---|
470 | }
|
---|
471 |
|
---|
472 |
|
---|
473 | #if 0
|
---|
474 | /**
|
---|
475 | * Resets the writable structure members prior to processing a PDB.
|
---|
476 | *
|
---|
477 | * While processing the PDB, will fill in the sizes and offsets of what we find.
|
---|
478 | * Afterwards we'll use look for reset values to see that every structure and
|
---|
479 | * member was located successfully.
|
---|
480 | */
|
---|
481 | static void resetMyStructs(void)
|
---|
482 | {
|
---|
483 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
|
---|
484 | {
|
---|
485 | PMYMEMBER paMembers = g_aStructs[i].paMembers;
|
---|
486 | uint32_t j = g_aStructs[i].cMembers;
|
---|
487 | while (j-- > 0)
|
---|
488 | {
|
---|
489 | paMembers[j].off = UINT32_MAX;
|
---|
490 | paMembers[j].cb = UINT32_MAX;
|
---|
491 | }
|
---|
492 | }
|
---|
493 | }
|
---|
494 | #endif
|
---|
495 |
|
---|
496 |
|
---|
497 | /**
|
---|
498 | * Find members in the specified structure type (@a idxType).
|
---|
499 | *
|
---|
500 | * @returns Fully bitched exit code.
|
---|
501 | * @param hFake Fake process handle.
|
---|
502 | * @param uModAddr The module address.
|
---|
503 | * @param idxType The type index of the structure which members we're
|
---|
504 | * going to process.
|
---|
505 | * @param cWantedMembers The number of wanted members.
|
---|
506 | * @param paWantedMembers The wanted members. This will be modified.
|
---|
507 | * @param offDisp Displacement when calculating member offsets.
|
---|
508 | * @param pszStructNm The top level structure name.
|
---|
509 | * @param pszPrefix The member name prefix.
|
---|
510 | * @param pszLogTag The log tag.
|
---|
511 | */
|
---|
512 | static RTEXITCODE findMembers(HANDLE hFake, uint64_t uModAddr, uint32_t idxType,
|
---|
513 | uint32_t cWantedMembers, PMYMEMBER paWantedMembers,
|
---|
514 | uint32_t offDisp, const char *pszStructNm, const char *pszPrefix, const char *pszLogTag)
|
---|
515 | {
|
---|
516 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
517 |
|
---|
518 | DWORD cChildren = 0;
|
---|
519 | if (!SymGetTypeInfo(hFake, uModAddr, idxType, TI_GET_CHILDRENCOUNT, &cChildren))
|
---|
520 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: TI_GET_CHILDRENCOUNT failed on _KPRCB: %u\n", pszLogTag, GetLastError());
|
---|
521 |
|
---|
522 | MyDbgPrintf(" %s: cChildren=%u (%#x)\n", pszStructNm, cChildren);
|
---|
523 | TI_FINDCHILDREN_PARAMS *pChildren;
|
---|
524 | pChildren = (TI_FINDCHILDREN_PARAMS *)alloca(RT_OFFSETOF(TI_FINDCHILDREN_PARAMS, ChildId[cChildren]));
|
---|
525 | pChildren->Start = 0;
|
---|
526 | pChildren->Count = cChildren;
|
---|
527 | if (!SymGetTypeInfo(hFake, uModAddr, idxType, TI_FINDCHILDREN, pChildren))
|
---|
528 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: TI_FINDCHILDREN failed on _KPRCB: %u\n", pszLogTag, GetLastError());
|
---|
529 |
|
---|
530 | for (uint32_t i = 0; i < cChildren; i++)
|
---|
531 | {
|
---|
532 | //MyDbgPrintf(" %s: child#%u: TypeIndex=%u\n", pszStructNm, i, pChildren->ChildId[i]);
|
---|
533 | IMAGEHLP_SYMBOL_TYPE_INFO enmErr;
|
---|
534 | PWCHAR pwszMember = NULL;
|
---|
535 | uint32_t idxRefType = 0;
|
---|
536 | uint32_t offMember = 0;
|
---|
537 | uint64_t cbMember = 0;
|
---|
538 | uint32_t cMemberChildren = 0;
|
---|
539 | if ( SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], enmErr = TI_GET_SYMNAME, &pwszMember)
|
---|
540 | && SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], enmErr = TI_GET_OFFSET, &offMember)
|
---|
541 | && SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], enmErr = TI_GET_TYPE, &idxRefType)
|
---|
542 | && SymGetTypeInfo(hFake, uModAddr, idxRefType, enmErr = TI_GET_LENGTH, &cbMember)
|
---|
543 | && SymGetTypeInfo(hFake, uModAddr, idxRefType, enmErr = TI_GET_CHILDRENCOUNT, &cMemberChildren)
|
---|
544 | )
|
---|
545 | {
|
---|
546 | offMember += offDisp;
|
---|
547 |
|
---|
548 | char *pszMember;
|
---|
549 | int rc = RTUtf16ToUtf8(pwszMember, &pszMember);
|
---|
550 | if (RT_SUCCESS(rc))
|
---|
551 | {
|
---|
552 | matchUpStructMembers(cWantedMembers, paWantedMembers, pszPrefix, pszMember, offMember, cbMember);
|
---|
553 |
|
---|
554 | /*
|
---|
555 | * Gather more info and do some debug printing. We'll use some
|
---|
556 | * of this info below when recursing into sub-structures
|
---|
557 | * and arrays.
|
---|
558 | */
|
---|
559 | uint32_t fNested = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_NESTED, &fNested);
|
---|
560 | uint32_t uDataKind = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_DATAKIND, &uDataKind);
|
---|
561 | uint32_t uBaseType = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_BASETYPE, &uBaseType);
|
---|
562 | uint32_t uMembTag = 0; SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], TI_GET_SYMTAG, &uMembTag);
|
---|
563 | uint32_t uBaseTag = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_SYMTAG, &uBaseTag);
|
---|
564 | uint32_t cElements = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_COUNT, &cElements);
|
---|
565 | uint32_t idxArrayType = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_ARRAYINDEXTYPEID, &idxArrayType);
|
---|
566 | MyDbgPrintf(" %#06x LB %#06llx %c%c %2d %2d %2d %2d %2d %4d %s::%s%s\n",
|
---|
567 | offMember, cbMember,
|
---|
568 | cMemberChildren > 0 ? 'c' : '-',
|
---|
569 | fNested != 0 ? 'n' : '-',
|
---|
570 | uDataKind,
|
---|
571 | uBaseType,
|
---|
572 | uMembTag,
|
---|
573 | uBaseTag,
|
---|
574 | cElements,
|
---|
575 | idxArrayType,
|
---|
576 | pszStructNm,
|
---|
577 | pszPrefix,
|
---|
578 | pszMember);
|
---|
579 |
|
---|
580 | /*
|
---|
581 | * Recurse into children.
|
---|
582 | */
|
---|
583 | if (cMemberChildren > 0)
|
---|
584 | {
|
---|
585 | size_t cbNeeded = strlen(pszMember) + strlen(pszPrefix) + sizeof(".");
|
---|
586 | char *pszSubPrefix = (char *)RTMemTmpAlloc(cbNeeded);
|
---|
587 | if (pszSubPrefix)
|
---|
588 | {
|
---|
589 | strcat(strcat(strcpy(pszSubPrefix, pszPrefix), pszMember), ".");
|
---|
590 | RTEXITCODE rcExit2 = findMembers(hFake, uModAddr, idxRefType, cWantedMembers,
|
---|
591 | paWantedMembers, offMember,
|
---|
592 | pszStructNm,
|
---|
593 | pszSubPrefix,
|
---|
594 | pszLogTag);
|
---|
595 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
596 | rcExit = rcExit2;
|
---|
597 | RTMemTmpFree(pszSubPrefix);
|
---|
598 | }
|
---|
599 | else
|
---|
600 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory\n");
|
---|
601 | }
|
---|
602 | /*
|
---|
603 | * Recurse into arrays too.
|
---|
604 | */
|
---|
605 | else if (cElements > 0 && idxArrayType > 0)
|
---|
606 | {
|
---|
607 | BOOL fRc;
|
---|
608 | uint32_t idxElementRefType = 0;
|
---|
609 | fRc = SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_TYPE, &idxElementRefType); Assert(fRc);
|
---|
610 | uint64_t cbElement = cbMember / cElements;
|
---|
611 | fRc = SymGetTypeInfo(hFake, uModAddr, idxElementRefType, TI_GET_LENGTH, &cbElement); Assert(fRc);
|
---|
612 | MyDbgPrintf("idxArrayType=%u idxElementRefType=%u cbElement=%u\n", idxArrayType, idxElementRefType, cbElement);
|
---|
613 |
|
---|
614 | size_t cbNeeded = strlen(pszMember) + strlen(pszPrefix) + sizeof("[xxxxxxxxxxxxxxxx].");
|
---|
615 | char *pszSubPrefix = (char *)RTMemTmpAlloc(cbNeeded);
|
---|
616 | if (pszSubPrefix)
|
---|
617 | {
|
---|
618 | for (uint32_t iElement = 0; iElement < cElements; iElement++)
|
---|
619 | {
|
---|
620 | RTStrPrintf(pszSubPrefix, cbNeeded, "%s%s[%u].", pszPrefix, pszMember, iElement);
|
---|
621 | RTEXITCODE rcExit2 = findMembers(hFake, uModAddr, idxElementRefType, cWantedMembers,
|
---|
622 | paWantedMembers,
|
---|
623 | offMember + iElement * cbElement,
|
---|
624 | pszStructNm,
|
---|
625 | pszSubPrefix,
|
---|
626 | pszLogTag);
|
---|
627 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
628 | rcExit = rcExit2;
|
---|
629 | }
|
---|
630 | RTMemTmpFree(pszSubPrefix);
|
---|
631 | }
|
---|
632 | else
|
---|
633 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory\n");
|
---|
634 | }
|
---|
635 |
|
---|
636 | RTStrFree(pszMember);
|
---|
637 | }
|
---|
638 | else
|
---|
639 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: RTUtf16ToUtf8 failed on %s child#%u: %Rrc\n",
|
---|
640 | pszLogTag, pszStructNm, i, rc);
|
---|
641 | }
|
---|
642 | /* TI_GET_OFFSET fails on bitfields, so just ignore+skip those. */
|
---|
643 | else if (enmErr != TI_GET_OFFSET || GetLastError() != ERROR_INVALID_FUNCTION)
|
---|
644 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: SymGetTypeInfo(,,,%d,) failed on %s child#%u: %u\n",
|
---|
645 | pszLogTag, enmErr, pszStructNm, i, GetLastError());
|
---|
646 | LocalFree(pwszMember);
|
---|
647 | } /* For each child. */
|
---|
648 |
|
---|
649 | return rcExit;
|
---|
650 | }
|
---|
651 |
|
---|
652 |
|
---|
653 | /**
|
---|
654 | * Lookup up structures and members in the given module.
|
---|
655 | *
|
---|
656 | * @returns Fully bitched exit code.
|
---|
657 | * @param hFake Fake process handle.
|
---|
658 | * @param uModAddr The module address.
|
---|
659 | * @param pszLogTag The log tag.
|
---|
660 | * @param pszPdb The full PDB path.
|
---|
661 | * @param pOsVerInfo The OS version info for altering the error handling
|
---|
662 | * for older OSes.
|
---|
663 | */
|
---|
664 | static RTEXITCODE findStructures(HANDLE hFake, uint64_t uModAddr, const char *pszLogTag, const char *pszPdb,
|
---|
665 | PCRTNTSDBOSVER pOsVerInfo)
|
---|
666 | {
|
---|
667 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
668 | PSYMBOL_INFO pSymInfo = (PSYMBOL_INFO)alloca(sizeof(*pSymInfo));
|
---|
669 | for (uint32_t iStruct = 0; iStruct < RT_ELEMENTS(g_aStructs); iStruct++)
|
---|
670 | {
|
---|
671 | pSymInfo->SizeOfStruct = sizeof(*pSymInfo);
|
---|
672 | pSymInfo->MaxNameLen = 0;
|
---|
673 | if (!SymGetTypeFromName(hFake, uModAddr, g_aStructs[iStruct].pszName, pSymInfo))
|
---|
674 | {
|
---|
675 | if (!(pOsVerInfo->uMajorVer == 5 && pOsVerInfo->uMinorVer == 0) /* w2k */)
|
---|
676 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Failed to find _KPRCB: %u\n", pszPdb, GetLastError());
|
---|
677 | RTMsgInfo("%s: Skipping - failed to find _KPRCB: %u\n", pszPdb, GetLastError());
|
---|
678 | return RTEXITCODE_SKIPPED;
|
---|
679 | }
|
---|
680 |
|
---|
681 | MyDbgPrintf(" %s: TypeIndex=%u\n", g_aStructs[iStruct].pszName, pSymInfo->TypeIndex);
|
---|
682 | MyDbgPrintf(" %s: Size=%u (%#x)\n", g_aStructs[iStruct].pszName, pSymInfo->Size, pSymInfo->Size);
|
---|
683 |
|
---|
684 | rcExit = findMembers(hFake, uModAddr, pSymInfo->TypeIndex,
|
---|
685 | g_aStructs[iStruct].cMembers, g_aStructs[iStruct].paMembers, 0 /* offDisp */,
|
---|
686 | g_aStructs[iStruct].pszName, "", pszLogTag);
|
---|
687 | if (rcExit != RTEXITCODE_SUCCESS)
|
---|
688 | return rcExit;
|
---|
689 | } /* for each struct we want */
|
---|
690 | return rcExit;
|
---|
691 | }
|
---|
692 |
|
---|
693 |
|
---|
694 | #if 0 /* unused */
|
---|
695 | static bool strIEndsWith(const char *pszString, const char *pszSuffix)
|
---|
696 | {
|
---|
697 | size_t cchString = strlen(pszString);
|
---|
698 | size_t cchSuffix = strlen(pszSuffix);
|
---|
699 | if (cchString < cchSuffix)
|
---|
700 | return false;
|
---|
701 | return RTStrICmp(pszString + cchString - cchSuffix, pszSuffix) == 0;
|
---|
702 | }
|
---|
703 | #endif
|
---|
704 |
|
---|
705 |
|
---|
706 | /**
|
---|
707 | * Use various hysterics to figure out the OS version details from the PDB path.
|
---|
708 | *
|
---|
709 | * This ASSUMES quite a bunch of things:
|
---|
710 | * -# Working on unpacked symbol packages. This does not work for
|
---|
711 | * windbg symbol stores/caches.
|
---|
712 | * -# The symbol package has been unpacked into a directory with the same
|
---|
713 | * name as the symbol package (sans suffixes).
|
---|
714 | *
|
---|
715 | * @returns Fully complained exit code.
|
---|
716 | * @param pszPdb The path to the PDB.
|
---|
717 | * @param pVerInfo Where to return the version info.
|
---|
718 | * @param penmArch Where to return the architecture.
|
---|
719 | */
|
---|
720 | static RTEXITCODE FigurePdbVersionInfo(const char *pszPdb, PRTNTSDBOSVER pVerInfo, MYARCH *penmArch)
|
---|
721 | {
|
---|
722 | /*
|
---|
723 | * Split the path.
|
---|
724 | */
|
---|
725 | union
|
---|
726 | {
|
---|
727 | RTPATHSPLIT Split;
|
---|
728 | uint8_t abPad[RTPATH_MAX + 1024];
|
---|
729 | } u;
|
---|
730 | int rc = RTPathSplit(pszPdb, &u.Split, sizeof(u), 0);
|
---|
731 | if (RT_FAILURE(rc))
|
---|
732 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathSplit failed on '%s': %Rrc", pszPdb, rc);
|
---|
733 | if (!(u.Split.fProps & RTPATH_PROP_FILENAME))
|
---|
734 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPATH_PROP_FILENAME not set for: '%s'", pszPdb);
|
---|
735 | const char *pszFilename = u.Split.apszComps[u.Split.cComps - 1];
|
---|
736 |
|
---|
737 | /*
|
---|
738 | * SMP or UNI kernel?
|
---|
739 | */
|
---|
740 | if ( !RTStrICmp(pszFilename, "ntkrnlmp.pdb")
|
---|
741 | || !RTStrICmp(pszFilename, "ntkrpamp.pdb")
|
---|
742 | )
|
---|
743 | pVerInfo->fSmp = true;
|
---|
744 | else if ( !RTStrICmp(pszFilename, "ntoskrnl.pdb")
|
---|
745 | || !RTStrICmp(pszFilename, "ntkrnlpa.pdb")
|
---|
746 | )
|
---|
747 | pVerInfo->fSmp = false;
|
---|
748 | else
|
---|
749 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Doesn't recognize the filename '%s'...", pszFilename);
|
---|
750 |
|
---|
751 | /*
|
---|
752 | * Look for symbol pack names in the path. This is stuff like:
|
---|
753 | * - WindowsVista.6002.090410-1830.x86fre
|
---|
754 | * - WindowsVista.6002.090410-1830.amd64chk
|
---|
755 | * - Windows_Win7.7600.16385.090713-1255.X64CHK
|
---|
756 | * - Windows_Win7SP1.7601.17514.101119-1850.AMD64FRE
|
---|
757 | * - Windows_Win8.9200.16384.120725-1247.X86CHK
|
---|
758 | * - en_windows_8_1_symbols_debug_checked_x64_2712568
|
---|
759 | */
|
---|
760 | uint32_t i = u.Split.cComps - 1;
|
---|
761 | while (i-- > 0)
|
---|
762 | {
|
---|
763 | static struct
|
---|
764 | {
|
---|
765 | const char *pszPrefix;
|
---|
766 | size_t cchPrefix;
|
---|
767 | uint8_t uMajorVer;
|
---|
768 | uint8_t uMinorVer;
|
---|
769 | uint8_t uCsdNo;
|
---|
770 | uint32_t uBuildNo; /**< UINT32_MAX means the number immediately after the prefix. */
|
---|
771 | } const s_aSymPacks[] =
|
---|
772 | {
|
---|
773 | { RT_STR_TUPLE("w2kSP1SYM"), 5, 0, 1, 2195 },
|
---|
774 | { RT_STR_TUPLE("w2ksp2srp1"), 5, 0, 2, 2195 },
|
---|
775 | { RT_STR_TUPLE("w2ksp2sym"), 5, 0, 2, 2195 },
|
---|
776 | { RT_STR_TUPLE("w2ksp3sym"), 5, 0, 3, 2195 },
|
---|
777 | { RT_STR_TUPLE("w2ksp4sym"), 5, 0, 4, 2195 },
|
---|
778 | { RT_STR_TUPLE("Windows2000-KB891861"), 5, 0, 4, 2195 },
|
---|
779 | { RT_STR_TUPLE("windowsxp"), 5, 1, 0, 2600 },
|
---|
780 | { RT_STR_TUPLE("xpsp1sym"), 5, 1, 1, 2600 },
|
---|
781 | { RT_STR_TUPLE("WindowsXP-KB835935-SP2-"), 5, 1, 2, 2600 },
|
---|
782 | { RT_STR_TUPLE("WindowsXP-KB936929-SP3-"), 5, 1, 3, 2600 },
|
---|
783 | { RT_STR_TUPLE("Windows2003."), 5, 2, 0, 3790 },
|
---|
784 | { RT_STR_TUPLE("Windows2003_sp1."), 5, 2, 1, 3790 },
|
---|
785 | { RT_STR_TUPLE("WindowsServer2003-KB933548-v1"), 5, 2, 1, 3790 },
|
---|
786 | { RT_STR_TUPLE("WindowsVista.6000."), 6, 0, 0, 6000 },
|
---|
787 | { RT_STR_TUPLE("Windows_Longhorn.6001."), 6, 0, 1, 6001 }, /* incl w2k8 */
|
---|
788 | { RT_STR_TUPLE("WindowsVista.6002."), 6, 0, 2, 6002 }, /* incl w2k8 */
|
---|
789 | { RT_STR_TUPLE("Windows_Winmain.7000"), 6, 1, 0, 7000 }, /* Beta */
|
---|
790 | { RT_STR_TUPLE("Windows_Winmain.7100"), 6, 1, 0, 7100 }, /* RC */
|
---|
791 | { RT_STR_TUPLE("Windows_Win7.7600"), 6, 1, 0, 7600 }, /* RC */
|
---|
792 | { RT_STR_TUPLE("Windows_Win7SP1.7601"), 6, 1, 1, 7601 }, /* RC */
|
---|
793 | { RT_STR_TUPLE("Windows_Winmain.8102"), 6, 2, 0, 8102 }, /* preview */
|
---|
794 | { RT_STR_TUPLE("Windows_Winmain.8250"), 6, 2, 0, 8250 }, /* beta */
|
---|
795 | { RT_STR_TUPLE("Windows_Winmain.8400"), 6, 2, 0, 8400 }, /* RC */
|
---|
796 | { RT_STR_TUPLE("Windows_Win8.9200"), 6, 2, 0, 9200 }, /* RTM */
|
---|
797 | { RT_STR_TUPLE("en_windows_8_1"), 6, 3, 0, 9600 }, /* RTM */
|
---|
798 | { RT_STR_TUPLE("en_windows_10_symbols_"), 10, 0, 0,10240 }, /* RTM */
|
---|
799 | };
|
---|
800 |
|
---|
801 | const char *pszComp = u.Split.apszComps[i];
|
---|
802 | uint32_t iSymPack = RT_ELEMENTS(s_aSymPacks);
|
---|
803 | while (iSymPack-- > 0)
|
---|
804 | if (!RTStrNICmp(pszComp, s_aSymPacks[iSymPack].pszPrefix, s_aSymPacks[iSymPack].cchPrefix))
|
---|
805 | break;
|
---|
806 | if (iSymPack >= RT_ELEMENTS(s_aSymPacks))
|
---|
807 | continue;
|
---|
808 |
|
---|
809 | pVerInfo->uMajorVer = s_aSymPacks[iSymPack].uMajorVer;
|
---|
810 | pVerInfo->uMinorVer = s_aSymPacks[iSymPack].uMinorVer;
|
---|
811 | pVerInfo->uCsdNo = s_aSymPacks[iSymPack].uCsdNo;
|
---|
812 | pVerInfo->fChecked = false;
|
---|
813 | pVerInfo->uBuildNo = s_aSymPacks[iSymPack].uBuildNo;
|
---|
814 |
|
---|
815 | /* Parse build number if necessary. */
|
---|
816 | if (s_aSymPacks[iSymPack].uBuildNo == UINT32_MAX)
|
---|
817 | {
|
---|
818 | char *pszNext;
|
---|
819 | rc = RTStrToUInt32Ex(pszComp + s_aSymPacks[iSymPack].cchPrefix, &pszNext, 10, &pVerInfo->uBuildNo);
|
---|
820 | if (RT_FAILURE(rc))
|
---|
821 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to decode build number in '%s': %Rrc", pszComp, rc);
|
---|
822 | if (*pszNext != '.' && *pszNext != '_' && *pszNext != '-')
|
---|
823 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to decode build number in '%s': '%c'", pszComp, *pszNext);
|
---|
824 | }
|
---|
825 |
|
---|
826 | /* Look for build arch and checked/free. */
|
---|
827 | if ( RTStrIStr(pszComp, ".x86.chk.")
|
---|
828 | || RTStrIStr(pszComp, ".x86chk.")
|
---|
829 | || RTStrIStr(pszComp, "_x86_chk_")
|
---|
830 | || RTStrIStr(pszComp, "_x86chk_")
|
---|
831 | || RTStrIStr(pszComp, "-x86-DEBUG")
|
---|
832 | || (RTStrIStr(pszComp, "-x86-") && RTStrIStr(pszComp, "-DEBUG"))
|
---|
833 | || RTStrIStr(pszComp, "_debug_checked_x86")
|
---|
834 | )
|
---|
835 | {
|
---|
836 | pVerInfo->fChecked = true;
|
---|
837 | *penmArch = MYARCH_X86;
|
---|
838 | }
|
---|
839 | else if ( RTStrIStr(pszComp, ".amd64.chk.")
|
---|
840 | || RTStrIStr(pszComp, ".amd64chk.")
|
---|
841 | || RTStrIStr(pszComp, ".x64.chk.")
|
---|
842 | || RTStrIStr(pszComp, ".x64chk.")
|
---|
843 | || RTStrIStr(pszComp, "_debug_checked_x64")
|
---|
844 | )
|
---|
845 | {
|
---|
846 | pVerInfo->fChecked = true;
|
---|
847 | *penmArch = MYARCH_AMD64;
|
---|
848 | }
|
---|
849 | else if ( RTStrIStr(pszComp, ".amd64.fre.")
|
---|
850 | || RTStrIStr(pszComp, ".amd64fre.")
|
---|
851 | || RTStrIStr(pszComp, ".x64.fre.")
|
---|
852 | || RTStrIStr(pszComp, ".x64fre.")
|
---|
853 | )
|
---|
854 | {
|
---|
855 | pVerInfo->fChecked = false;
|
---|
856 | *penmArch = MYARCH_AMD64;
|
---|
857 | }
|
---|
858 | else if ( RTStrIStr(pszComp, "DEBUG")
|
---|
859 | || RTStrIStr(pszComp, "_chk")
|
---|
860 | )
|
---|
861 | {
|
---|
862 | pVerInfo->fChecked = true;
|
---|
863 | *penmArch = MYARCH_X86;
|
---|
864 | }
|
---|
865 | else if (RTStrIStr(pszComp, "_x64"))
|
---|
866 | {
|
---|
867 | pVerInfo->fChecked = false;
|
---|
868 | *penmArch = MYARCH_AMD64;
|
---|
869 | }
|
---|
870 | else
|
---|
871 | {
|
---|
872 | pVerInfo->fChecked = false;
|
---|
873 | *penmArch = MYARCH_X86;
|
---|
874 | }
|
---|
875 | return RTEXITCODE_SUCCESS;
|
---|
876 | }
|
---|
877 |
|
---|
878 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Giving up on '%s'...\n", pszPdb);
|
---|
879 | }
|
---|
880 |
|
---|
881 |
|
---|
882 | /**
|
---|
883 | * Process one PDB.
|
---|
884 | *
|
---|
885 | * @returns Fully bitched exit code.
|
---|
886 | * @param pszPdb The path to the PDB.
|
---|
887 | */
|
---|
888 | static RTEXITCODE processPdb(const char *pszPdb)
|
---|
889 | {
|
---|
890 | /*
|
---|
891 | * We need the size later on, so get that now and present proper IPRT error
|
---|
892 | * info if the file is missing or inaccessible.
|
---|
893 | */
|
---|
894 | RTFSOBJINFO ObjInfo;
|
---|
895 | int rc = RTPathQueryInfoEx(pszPdb, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK);
|
---|
896 | if (RT_FAILURE(rc))
|
---|
897 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathQueryInfo fail on '%s': %Rrc\n", pszPdb, rc);
|
---|
898 |
|
---|
899 | /*
|
---|
900 | * Figure the windows version details for the given PDB.
|
---|
901 | */
|
---|
902 | MYARCH enmArch;
|
---|
903 | RTNTSDBOSVER OsVerInfo;
|
---|
904 | RTEXITCODE rcExit = FigurePdbVersionInfo(pszPdb, &OsVerInfo, &enmArch);
|
---|
905 | if (rcExit != RTEXITCODE_SUCCESS)
|
---|
906 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to figure the OS version info for '%s'.\n'", pszPdb);
|
---|
907 |
|
---|
908 | /*
|
---|
909 | * Create a fake handle and open the PDB.
|
---|
910 | */
|
---|
911 | static uintptr_t s_iHandle = 0;
|
---|
912 | HANDLE hFake = (HANDLE)++s_iHandle;
|
---|
913 | if (!SymInitialize(hFake, NULL, FALSE))
|
---|
914 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "SymInitialied failed: %u\n", GetLastError());
|
---|
915 |
|
---|
916 | uint64_t uModAddr = UINT64_C(0x1000000);
|
---|
917 | uModAddr = SymLoadModuleEx(hFake, NULL /*hFile*/, pszPdb, NULL /*pszModuleName*/,
|
---|
918 | uModAddr, ObjInfo.cbObject, NULL /*pData*/, 0 /*fFlags*/);
|
---|
919 | if (uModAddr != 0)
|
---|
920 | {
|
---|
921 | MyDbgPrintf("*** uModAddr=%#llx \"%s\" ***\n", uModAddr, pszPdb);
|
---|
922 |
|
---|
923 | char szLogTag[32];
|
---|
924 | RTStrCopy(szLogTag, sizeof(szLogTag), RTPathFilename(pszPdb));
|
---|
925 |
|
---|
926 | /*
|
---|
927 | * Find the structures.
|
---|
928 | */
|
---|
929 | rcExit = findStructures(hFake, uModAddr, szLogTag, pszPdb, &OsVerInfo);
|
---|
930 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
931 | rcExit = checkThatWeFoundEverything();
|
---|
932 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
933 | {
|
---|
934 | /*
|
---|
935 | * Save the details for later when we produce the header.
|
---|
936 | */
|
---|
937 | rcExit = saveStructures(&OsVerInfo, enmArch, pszPdb);
|
---|
938 | }
|
---|
939 | }
|
---|
940 | else
|
---|
941 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "SymLoadModuleEx failed: %u\n", GetLastError());
|
---|
942 |
|
---|
943 | if (!SymCleanup(hFake))
|
---|
944 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "SymCleanup failed: %u\n", GetLastError());
|
---|
945 |
|
---|
946 | if (rcExit == RTEXITCODE_SKIPPED)
|
---|
947 | rcExit = RTEXITCODE_SUCCESS;
|
---|
948 | return rcExit;
|
---|
949 | }
|
---|
950 |
|
---|
951 |
|
---|
952 | /** The size of the directory entry buffer we're using. */
|
---|
953 | #define MY_DIRENTRY_BUF_SIZE (sizeof(RTDIRENTRYEX) + RTPATH_MAX)
|
---|
954 |
|
---|
955 | /**
|
---|
956 | * Checks if the name is of interest to us.
|
---|
957 | *
|
---|
958 | * @returns true/false.
|
---|
959 | * @param pszName The name.
|
---|
960 | * @param cchName The length of the name.
|
---|
961 | */
|
---|
962 | static bool isInterestingName(const char *pszName, size_t cchName)
|
---|
963 | {
|
---|
964 | static struct { const char *psz; size_t cch; } const s_aNames[] =
|
---|
965 | {
|
---|
966 | RT_STR_TUPLE("ntoskrnl.pdb"),
|
---|
967 | RT_STR_TUPLE("ntkrnlmp.pdb"),
|
---|
968 | RT_STR_TUPLE("ntkrnlpa.pdb"),
|
---|
969 | RT_STR_TUPLE("ntkrpamp.pdb"),
|
---|
970 | };
|
---|
971 |
|
---|
972 | if ( cchName == s_aNames[0].cch
|
---|
973 | && (pszName[0] == 'n' || pszName[0] == 'N')
|
---|
974 | && (pszName[1] == 't' || pszName[1] == 'T')
|
---|
975 | )
|
---|
976 | {
|
---|
977 | int i = RT_ELEMENTS(s_aNames);
|
---|
978 | while (i-- > 0)
|
---|
979 | if ( s_aNames[i].cch == cchName
|
---|
980 | && !RTStrICmp(s_aNames[i].psz, pszName))
|
---|
981 | return true;
|
---|
982 | }
|
---|
983 | return false;
|
---|
984 | }
|
---|
985 |
|
---|
986 |
|
---|
987 | /**
|
---|
988 | * Recursively processes relevant files in the specified directory.
|
---|
989 | *
|
---|
990 | * @returns Fully complained exit code.
|
---|
991 | * @param pszDir Pointer to the directory buffer.
|
---|
992 | * @param cchDir The length of pszDir in pszDir.
|
---|
993 | * @param pDirEntry Pointer to the directory buffer.
|
---|
994 | * @param iLogDepth The logging depth.
|
---|
995 | */
|
---|
996 | static RTEXITCODE processDirSub(char *pszDir, size_t cchDir, PRTDIRENTRYEX pDirEntry, int iLogDepth)
|
---|
997 | {
|
---|
998 | Assert(cchDir > 0); Assert(pszDir[cchDir] == '\0');
|
---|
999 |
|
---|
1000 | /* Make sure we've got some room in the path, to save us extra work further down. */
|
---|
1001 | if (cchDir + 3 >= RTPATH_MAX)
|
---|
1002 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Path too long: '%s'\n", pszDir);
|
---|
1003 |
|
---|
1004 | /* Open directory. */
|
---|
1005 | PRTDIR pDir;
|
---|
1006 | int rc = RTDirOpen(&pDir, pszDir);
|
---|
1007 | if (RT_FAILURE(rc))
|
---|
1008 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDirOpen failed on '%s': %Rrc\n", pszDir, rc);
|
---|
1009 |
|
---|
1010 | /* Ensure we've got a trailing slash (there is space for it see above). */
|
---|
1011 | if (!RTPATH_IS_SEP(pszDir[cchDir - 1]))
|
---|
1012 | {
|
---|
1013 | pszDir[cchDir++] = RTPATH_SLASH;
|
---|
1014 | pszDir[cchDir] = '\0';
|
---|
1015 | }
|
---|
1016 |
|
---|
1017 | /*
|
---|
1018 | * Process the files and subdirs.
|
---|
1019 | */
|
---|
1020 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
1021 | for (;;)
|
---|
1022 | {
|
---|
1023 | /* Get the next directory. */
|
---|
1024 | size_t cbDirEntry = MY_DIRENTRY_BUF_SIZE;
|
---|
1025 | rc = RTDirReadEx(pDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
|
---|
1026 | if (RT_FAILURE(rc))
|
---|
1027 | break;
|
---|
1028 |
|
---|
1029 | /* Skip the dot and dot-dot links. */
|
---|
1030 | if ( (pDirEntry->cbName == 1 && pDirEntry->szName[0] == '.')
|
---|
1031 | || (pDirEntry->cbName == 2 && pDirEntry->szName[0] == '.' && pDirEntry->szName[1] == '.'))
|
---|
1032 | continue;
|
---|
1033 |
|
---|
1034 | /* Check length. */
|
---|
1035 | if (pDirEntry->cbName + cchDir + 3 >= RTPATH_MAX)
|
---|
1036 | {
|
---|
1037 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Path too long: '%s' in '%.*s'\n", pDirEntry->szName, cchDir, pszDir);
|
---|
1038 | break;
|
---|
1039 | }
|
---|
1040 |
|
---|
1041 | if (RTFS_IS_FILE(pDirEntry->Info.Attr.fMode))
|
---|
1042 | {
|
---|
1043 | /*
|
---|
1044 | * Process debug info files of interest.
|
---|
1045 | */
|
---|
1046 | if (isInterestingName(pDirEntry->szName, pDirEntry->cbName))
|
---|
1047 | {
|
---|
1048 | memcpy(&pszDir[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1049 | RTEXITCODE rcExit2 = processPdb(pszDir);
|
---|
1050 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
1051 | rcExit = rcExit2;
|
---|
1052 | }
|
---|
1053 | }
|
---|
1054 | else if (RTFS_IS_DIRECTORY(pDirEntry->Info.Attr.fMode))
|
---|
1055 | {
|
---|
1056 | /*
|
---|
1057 | * Recurse into the subdirectory. In order to speed up Win7+
|
---|
1058 | * symbol pack traversals, we skip directories with ".pdb" suffixes
|
---|
1059 | * unless they match any of the .pdb files we're looking for.
|
---|
1060 | *
|
---|
1061 | * Note! When we get back pDirEntry will be invalid.
|
---|
1062 | */
|
---|
1063 | if ( pDirEntry->cbName <= 4
|
---|
1064 | || RTStrICmp(&pDirEntry->szName[pDirEntry->cbName - 4], ".pdb")
|
---|
1065 | || isInterestingName(pDirEntry->szName, pDirEntry->cbName))
|
---|
1066 | {
|
---|
1067 | memcpy(&pszDir[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1068 | if (iLogDepth > 0)
|
---|
1069 | RTMsgInfo("%s%s ...\n", pszDir, RTPATH_SLASH_STR);
|
---|
1070 | RTEXITCODE rcExit2 = processDirSub(pszDir, cchDir + pDirEntry->cbName, pDirEntry, iLogDepth - 1);
|
---|
1071 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
1072 | rcExit = rcExit2;
|
---|
1073 | }
|
---|
1074 | }
|
---|
1075 | }
|
---|
1076 | if (rc != VERR_NO_MORE_FILES)
|
---|
1077 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDirReadEx failed: %Rrc\npszDir=%.*s", rc, cchDir, pszDir);
|
---|
1078 |
|
---|
1079 | rc = RTDirClose(pDir);
|
---|
1080 | if (RT_FAILURE(rc))
|
---|
1081 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDirClose failed: %Rrc\npszDir=%.*s", rc, cchDir, pszDir);
|
---|
1082 | return rcExit;
|
---|
1083 | }
|
---|
1084 |
|
---|
1085 |
|
---|
1086 | /**
|
---|
1087 | * Recursively processes relevant files in the specified directory.
|
---|
1088 | *
|
---|
1089 | * @returns Fully complained exit code.
|
---|
1090 | * @param pszDir The directory to search.
|
---|
1091 | */
|
---|
1092 | static RTEXITCODE processDir(const char *pszDir)
|
---|
1093 | {
|
---|
1094 | char szPath[RTPATH_MAX];
|
---|
1095 | int rc = RTPathAbs(pszDir, szPath, sizeof(szPath));
|
---|
1096 | if (RT_FAILURE(rc))
|
---|
1097 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed on '%s': %Rrc\n", pszDir, rc);
|
---|
1098 |
|
---|
1099 | union
|
---|
1100 | {
|
---|
1101 | uint8_t abPadding[MY_DIRENTRY_BUF_SIZE];
|
---|
1102 | RTDIRENTRYEX DirEntry;
|
---|
1103 | } uBuf;
|
---|
1104 | return processDirSub(szPath, strlen(szPath), &uBuf.DirEntry, g_iOptVerbose);
|
---|
1105 | }
|
---|
1106 |
|
---|
1107 |
|
---|
1108 | int main(int argc, char **argv)
|
---|
1109 | {
|
---|
1110 | int rc = RTR3InitExe(argc, &argv, 0 /*fFlags*/);
|
---|
1111 | if (RT_FAILURE(rc))
|
---|
1112 | return RTMsgInitFailure(rc);
|
---|
1113 |
|
---|
1114 | RTListInit(&g_SetList);
|
---|
1115 |
|
---|
1116 | /*
|
---|
1117 | * Parse options.
|
---|
1118 | */
|
---|
1119 | static const RTGETOPTDEF s_aOptions[] =
|
---|
1120 | {
|
---|
1121 | { "--force", 'f', RTGETOPT_REQ_NOTHING },
|
---|
1122 | { "--output", 'o', RTGETOPT_REQ_STRING },
|
---|
1123 | { "--verbose", 'v', RTGETOPT_REQ_NOTHING },
|
---|
1124 | { "--quiet", 'q', RTGETOPT_REQ_NOTHING },
|
---|
1125 | };
|
---|
1126 |
|
---|
1127 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
1128 | const char *pszOutput = "-";
|
---|
1129 |
|
---|
1130 | int ch;
|
---|
1131 | RTGETOPTUNION ValueUnion;
|
---|
1132 | RTGETOPTSTATE GetState;
|
---|
1133 | RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
|
---|
1134 | RTGETOPTINIT_FLAGS_OPTS_FIRST);
|
---|
1135 | while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
|
---|
1136 | {
|
---|
1137 | switch (ch)
|
---|
1138 | {
|
---|
1139 | case 'f':
|
---|
1140 | g_fOptForce = true;
|
---|
1141 | break;
|
---|
1142 |
|
---|
1143 | case 'v':
|
---|
1144 | g_iOptVerbose++;
|
---|
1145 | break;
|
---|
1146 |
|
---|
1147 | case 'q':
|
---|
1148 | g_iOptVerbose++;
|
---|
1149 | break;
|
---|
1150 |
|
---|
1151 | case 'o':
|
---|
1152 | pszOutput = ValueUnion.psz;
|
---|
1153 | break;
|
---|
1154 |
|
---|
1155 | case 'V':
|
---|
1156 | RTPrintf("$Revision: 62592 $");
|
---|
1157 | break;
|
---|
1158 |
|
---|
1159 | case 'h':
|
---|
1160 | RTPrintf("usage: %s [-v|--verbose] [-q|--quiet] [-f|--force] [-o|--output <file.h>] <dir1|pdb1> [...]\n"
|
---|
1161 | " or: %s [-V|--version]\n"
|
---|
1162 | " or: %s [-h|--help]\n",
|
---|
1163 | argv[0], argv[0], argv[0]);
|
---|
1164 | return RTEXITCODE_SUCCESS;
|
---|
1165 |
|
---|
1166 | case VINF_GETOPT_NOT_OPTION:
|
---|
1167 | {
|
---|
1168 | RTEXITCODE rcExit2;
|
---|
1169 | if (RTFileExists(ValueUnion.psz))
|
---|
1170 | rcExit2 = processPdb(ValueUnion.psz);
|
---|
1171 | else
|
---|
1172 | rcExit2 = processDir(ValueUnion.psz);
|
---|
1173 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
1174 | {
|
---|
1175 | if (!g_fOptForce)
|
---|
1176 | return rcExit2;
|
---|
1177 | rcExit = rcExit2;
|
---|
1178 | }
|
---|
1179 | break;
|
---|
1180 | }
|
---|
1181 |
|
---|
1182 | default:
|
---|
1183 | return RTGetOptPrintError(ch, &ValueUnion);
|
---|
1184 | }
|
---|
1185 | }
|
---|
1186 | if (RTListIsEmpty(&g_SetList))
|
---|
1187 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "No usable debug files found.\n");
|
---|
1188 |
|
---|
1189 | /*
|
---|
1190 | * Generate the output.
|
---|
1191 | */
|
---|
1192 | PRTSTREAM pOut = g_pStdOut;
|
---|
1193 | if (strcmp(pszOutput, "-"))
|
---|
1194 | {
|
---|
1195 | rc = RTStrmOpen(pszOutput, "w", &pOut);
|
---|
1196 | if (RT_FAILURE(rc))
|
---|
1197 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening '%s' for writing: %Rrc\n", pszOutput, rc);
|
---|
1198 | }
|
---|
1199 |
|
---|
1200 | generateHeader(pOut);
|
---|
1201 |
|
---|
1202 | if (pOut != g_pStdOut)
|
---|
1203 | rc = RTStrmClose(pOut);
|
---|
1204 | else
|
---|
1205 | rc = RTStrmFlush(pOut);
|
---|
1206 | if (RT_FAILURE(rc))
|
---|
1207 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error %s '%s': %Rrc\n", pszOutput,
|
---|
1208 | pOut != g_pStdOut ? "closing" : "flushing", rc);
|
---|
1209 | return rcExit;
|
---|
1210 | }
|
---|