ntBldSymDb.cpp@ 62448

Last change on this file since 62448 was 62448, checked in by vboxsync, 8 years ago
IPRT: More MSC level 4 warning fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 45.6 KB

Line
1	/* $Id: ntBldSymDb.cpp 62448 2016-07-22 14:51:49Z vboxsync $ */
2	/** @file
3	* IPRT - RTDirCreateUniqueNumbered, generic implementation.
4	*/
5
6	/*
7	* Copyright (C) 2013-2015 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 <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-2015 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: 62448 $");
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	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r0drv/nt/ntBldSymDb.cpp@ 62448

Download in other formats: