DBGFSym.cpp@ 39078

Last change on this file since 39078 was 39078, checked in by vboxsync, 13 years ago
VMM: -Wunused-parameter
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 33.6 KB

Line
1	/* $Id: DBGFSym.cpp 39078 2011-10-21 14:18:22Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Symbol Management.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGF
23	#if defined(RT_OS_WINDOWS) && 0 //defined(DEBUG_bird) // enabled this is you want to debug win32 guests, the hypervisor of EFI.
24	# include <Windows.h>
25	# define _IMAGEHLP64
26	# include <DbgHelp.h>
27	# define HAVE_DBGHELP /* if doing guest stuff, this can be nice. */
28	#endif
29	/** @todo Only use DBGHELP for reading modules since it doesn't do all we want (relocations), or is way to slow in some cases (add symbol)! */
30	#include <VBox/vmm/dbgf.h>
31	#include <VBox/vmm/mm.h>
32	#include <VBox/vmm/pdmapi.h>
33	#include "DBGFInternal.h"
34	#include <VBox/vmm/vm.h>
35	#include <VBox/err.h>
36	#include <VBox/log.h>
37
38	#include <iprt/assert.h>
39	#include <iprt/path.h>
40	#include <iprt/ctype.h>
41	#include <iprt/env.h>
42	#include <iprt/param.h>
43	#ifndef HAVE_DBGHELP
44	# include <iprt/avl.h>
45	# include <iprt/string.h>
46	#endif
47
48	#include <stdio.h> /* for fopen(). / /* @todo use iprt/stream.h! */
49	#include <stdlib.h>
50
51
52	/*******************************************************************************
53	* Internal Functions *
54	*******************************************************************************/
55	#ifdef HAVE_DBGHELP
56	static DECLCALLBACK(int) dbgfR3EnumModules(PVM pVM, const char pszFilename, const char pszName,
57	RTUINTPTR ImageBase, size_t cbImage, bool fRC, void *pvArg);
58	static int win32Error(PVM pVM);
59	#endif
60
61
62	/*******************************************************************************
63	* Structures and Typedefs *
64	*******************************************************************************/
65	#ifndef HAVE_DBGHELP
66	/* later */
67	typedef struct DBGFMOD *PDBGFMOD;
68
69	/**
70	* Internal representation of a symbol.
71	*/
72	typedef struct DBGFSYM
73	{
74	/** Node core with the symbol address range. */
75	AVLRGCPTRNODECORE Core;
76	/** Pointer to the module this symbol is associated with. */
77	PDBGFMOD pModule;
78	/** Pointer to the next symbol in with this name. */
79	struct DBGFSYM *pNext;
80	/** Symbol name. */
81	char szName[1];
82	} DBGFSYM, *PDBGFSYM;
83
84	/**
85	* Symbol name space node.
86	*/
87	typedef struct DBGFSYMSPACE
88	{
89	/** Node core with the symbol name.
90	* (it's allocated in the same block as this struct) */
91	RTSTRSPACECORE Core;
92	/** Pointer to the first symbol with this name (LIFO). */
93	PDBGFSYM pSym;
94	} DBGFSYMSPACE, *PDBGFSYMSPACE;
95
96	#endif
97
98
99
100	/*******************************************************************************
101	* Internal Functions *
102	*******************************************************************************/
103	#ifndef HAVE_DBGHELP
104
105	/**
106	* Initializes the symbol tree.
107	*/
108	static int dbgfR3SymbolInit(PVM pVM)
109	{
110	PDBGFSYM pSym = (PDBGFSYM)MMR3HeapAlloc(pVM, MM_TAG_DBGF_SYMBOL, sizeof(*pSym));
111	if (pSym)
112	{
113	pSym->Core.Key = 0;
114	pSym->Core.KeyLast = ~0;
115	pSym->pModule = NULL;
116	pSym->szName[0] = '\0';
117	if (RTAvlrGCPtrInsert(&pVM->dbgf.s.SymbolTree, &pSym->Core))
118	return VINF_SUCCESS;
119	AssertReleaseMsgFailed(("Failed to insert %RGv-%RGv!\n", pSym->Core.Key, pSym->Core.KeyLast));
120	return VERR_INTERNAL_ERROR;
121	}
122	return VERR_NO_MEMORY;
123	}
124
125
126	/**
127	* Insert a record into the symbol tree.
128	*/
129	static int dbgfR3SymbolInsert(PVM pVM, const char *pszName, RTGCPTR Address, size_t cb, PDBGFMOD pModule)
130	{
131	/*
132	* Make the address space node.
133	*/
134	size_t cchName = strlen(pszName) + 1;
135	PDBGFSYM pSym = (PDBGFSYM)MMR3HeapAlloc(pVM, MM_TAG_DBGF_SYMBOL, RT_OFFSETOF(DBGFSYM, szName[cchName]));
136	if (pSym)
137	{
138	pSym->Core.Key = Address;
139	pSym->Core.KeyLast = Address + cb;
140	pSym->pModule = pModule;
141	memcpy(pSym->szName, pszName, cchName);
142
143	PDBGFSYM pOld = (PDBGFSYM)RTAvlrGCPtrRangeGet(&pVM->dbgf.s.SymbolTree, (RTGCPTR)Address);
144	if (pOld)
145	{
146	pSym->Core.KeyLast = pOld->Core.KeyLast;
147	if (pOld->Core.Key == pSym->Core.Key)
148	{
149	pOld = (PDBGFSYM)RTAvlrGCPtrRemove(&pVM->dbgf.s.SymbolTree, (RTGCPTR)Address);
150	AssertRelease(pOld);
151	MMR3HeapFree(pOld);
152	}
153	else
154	pOld->Core.KeyLast = Address - 1;
155	if (RTAvlrGCPtrInsert(&pVM->dbgf.s.SymbolTree, &pSym->Core))
156	{
157	/*
158	* Make the name space node.
159	*/
160	PDBGFSYMSPACE pName = (PDBGFSYMSPACE)RTStrSpaceGet(pVM->dbgf.s.pSymbolSpace, pszName);
161	if (!pName)
162	{
163	/* make new symbol space node. */
164	pName = (PDBGFSYMSPACE)MMR3HeapAlloc(pVM, MM_TAG_DBGF_SYMBOL, sizeof(*pName) + cchName);
165	if (pName)
166	{
167	pName->Core.pszString = (char *)memcpy(pName + 1, pszName, cchName);
168	pName->pSym = pSym;
169	if (RTStrSpaceInsert(pVM->dbgf.s.pSymbolSpace, &pName->Core))
170	return VINF_SUCCESS;
171	}
172	else
173	return VINF_SUCCESS;
174	}
175	else
176	{
177	/* Add to existing symbol name. */
178	pSym->pNext = pName->pSym;
179	pName->pSym = pSym;
180	return VINF_SUCCESS;
181	}
182	}
183	AssertReleaseMsgFailed(("Failed to insert %RGv-%RGv!\n", pSym->Core.Key, pSym->Core.KeyLast));
184	}
185	else
186	AssertMsgFailed(("pOld! %RGv %s\n", pSym->Core.Key, pszName));
187	return VERR_INTERNAL_ERROR;
188
189	}
190	return VERR_NO_MEMORY;
191	}
192
193
194	/**
195	* Get nearest symbol.
196	* @returns NULL if no symbol was the for that address.
197	*/
198	static PDBGFSYM dbgfR3SymbolGetAddr(PVM pVM, RTGCPTR Address)
199	{
200	PDBGFSYM pSym = (PDBGFSYM)RTAvlrGCPtrRangeGet(&pVM->dbgf.s.SymbolTree, Address);
201	Assert(pSym);
202	if (pSym && pSym->szName[0])
203	return pSym;
204	return NULL;
205	}
206
207
208	/**
209	* Get first symbol.
210	* @returns NULL if no symbol by that name.
211	*/
212	static PDBGFSYM dbgfR3SymbolGetName(PVM pVM, const char *pszSymbol)
213	{
214	PDBGFSYMSPACE pName = (PDBGFSYMSPACE)RTStrSpaceGet(pVM->dbgf.s.pSymbolSpace, pszSymbol);
215	if (pName)
216	return pName->pSym;
217	return NULL;
218	}
219
220	#endif
221
222
223	/**
224	* Strips all kind of spaces from head and tail of a string.
225	*/
226	static char dbgfR3Strip(char psz)
227	{
228	while (psz && RT_C_IS_SPACE(psz))
229	psz++;
230	char *psz2 = strchr(psz, '\0') - 1;
231	while (psz2 >= psz && RT_C_IS_SPACE(*psz2))
232	*psz2-- = '\0';
233	return psz;
234	}
235
236
237	/**
238	* Initialize the debug info for a VM.
239	*
240	* This will check the CFGM for any symbols or symbol files
241	* which needs loading.
242	*
243	* @returns VBox status code.
244	* @param pVM The VM handle.
245	*/
246	int dbgfR3SymInit(PVM pVM)
247	{
248	int rc;
249
250	/*
251	* Initialize the symbol table.
252	*/
253	pVM->dbgf.s.pSymbolSpace = (PRTSTRSPACE)MMR3HeapAllocZ(pVM, MM_TAG_DBGF_SYMBOL, sizeof(*pVM->dbgf.s.pSymbolSpace));
254	AssertReturn(pVM->dbgf.s.pSymbolSpace, VERR_NO_MEMORY);
255
256	#ifndef HAVE_DBGHELP
257	/* modules & lines later */
258	rc = dbgfR3SymbolInit(pVM);
259	if (RT_FAILURE(rc))
260	return rc;
261	pVM->dbgf.s.fSymInited = true;
262	#endif
263
264	/*
265	* Check if there are 'loadsyms' commands in the configuration.
266	*/
267	PCFGMNODE pNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/DBGF/loadsyms/");
268	if (pNode)
269	{
270	/*
271	* Enumerate the commands.
272	*/
273	for (PCFGMNODE pCmdNode = CFGMR3GetFirstChild(pNode);
274	pCmdNode;
275	pCmdNode = CFGMR3GetNextChild(pCmdNode))
276	{
277	char szCmdName[128];
278	CFGMR3GetName(pCmdNode, &szCmdName[0], sizeof(szCmdName));
279
280	/* File */
281	char *pszFilename;
282	rc = CFGMR3QueryStringAlloc(pCmdNode, "Filename", &pszFilename);
283	AssertMsgRCReturn(rc, ("rc=%Rrc querying the 'File' attribute of '/DBGF/loadsyms/%s'!\n", rc, szCmdName), rc);
284
285	/* Delta (optional) */
286	RTGCINTPTR offDelta;
287	rc = CFGMR3QueryGCPtrS(pNode, "Delta", &offDelta);
288	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
289	offDelta = 0;
290	else
291	AssertMsgRCReturn(rc, ("rc=%Rrc querying the 'Delta' attribute of '/DBGF/loadsyms/%s'!\n", rc, szCmdName), rc);
292
293	/* Module (optional) */
294	char *pszModule;
295	rc = CFGMR3QueryStringAlloc(pCmdNode, "Module", &pszModule);
296	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
297	pszModule = NULL;
298	else
299	AssertMsgRCReturn(rc, ("rc=%Rrc querying the 'Module' attribute of '/DBGF/loadsyms/%s'!\n", rc, szCmdName), rc);
300
301	/* Module (optional) */
302	RTGCUINTPTR ModuleAddress;
303	rc = CFGMR3QueryGCPtrU(pNode, "ModuleAddress", &ModuleAddress);
304	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
305	ModuleAddress = 0;
306	else
307	AssertMsgRCReturn(rc, ("rc=%Rrc querying the 'ModuleAddress' attribute of '/DBGF/loadsyms/%s'!\n", rc, szCmdName), rc);
308
309	/* Image size (optional) */
310	RTGCUINTPTR cbModule;
311	rc = CFGMR3QueryGCPtrU(pNode, "ModuleSize", &cbModule);
312	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
313	cbModule = 0;
314	else
315	AssertMsgRCReturn(rc, ("rc=%Rrc querying the 'ModuleAddress' attribute of '/DBGF/loadsyms/%s'!\n", rc, szCmdName), rc);
316
317
318	/*
319	* Execute the command.
320	*/
321	rc = DBGFR3ModuleLoad(pVM, pszFilename, offDelta, pszModule, ModuleAddress, cbModule);
322	AssertMsgRCReturn(rc, ("pszFilename=%s offDelta=%RGv pszModule=%s ModuleAddress=%RGv cbModule=%RGv\n",
323	pszFilename, offDelta, pszModule, ModuleAddress, cbModule), rc);
324
325	MMR3HeapFree(pszModule);
326	MMR3HeapFree(pszFilename);
327	}
328	}
329
330	/*
331	* Check if there are any 'symadd' commands in the configuration.
332	*/
333
334	return VINF_SUCCESS;
335	}
336
337
338	/**
339	* We delay certain
340	* Initialize the debug info for a VM.
341	*/
342	int dbgfR3SymLazyInit(PVM pVM)
343	{
344	if (pVM->dbgf.s.fSymInited)
345	return VINF_SUCCESS;
346	#ifdef HAVE_DBGHELP
347	if (SymInitialize(pVM, NULL, FALSE))
348	{
349	pVM->dbgf.s.fSymInited = true;
350	SymSetOptions(SYMOPT_LOAD_LINES \| SYMOPT_AUTO_PUBLICS \| SYMOPT_ALLOW_ABSOLUTE_SYMBOLS);
351
352	/*
353	* Enumerate all modules loaded by PDM and add them to the symbol database.
354	*/
355	PDMR3LdrEnumModules(pVM, dbgfR3EnumModules, NULL);
356	return VINF_SUCCESS;
357	}
358	return win32Error(pVM);
359	#else
360	return VINF_SUCCESS;
361	#endif
362	}
363
364
365	#ifdef HAVE_DBGHELP
366	/**
367	* Module enumeration callback function.
368	*
369	* @returns VBox status.
370	* Failure will stop the search and return the return code.
371	* Warnings will be ignored and not returned.
372	* @param pVM VM Handle.
373	* @param pszFilename Module filename.
374	* @param pszName Module name. (short and unique)
375	* @param ImageBase Address where to executable image is loaded.
376	* @param cbImage Size of the executable image.
377	* @param fRC Set if guest context, clear if host context.
378	* @param pvArg User argument.
379	*/
380	static DECLCALLBACK(int) dbgfR3EnumModules(PVM pVM, const char pszFilename, const char pszName,
381	RTUINTPTR ImageBase, size_t cbImage, bool fRC, void *pvArg)
382	{
383	DWORD64 LoadedImageBase = SymLoadModule64(pVM, NULL, (char )(void )pszFilename,
384	(char )(void )pszName, ImageBase, (DWORD)cbImage);
385	if (!LoadedImageBase)
386	Log(("SymLoadModule64(,,%s,,) -> lasterr=%d\n", pszFilename, GetLastError()));
387	else
388	Log(("Loaded debuginfo for %s - %s %llx\n", pszName, pszFilename, LoadedImageBase));
389
390	return VINF_SUCCESS;
391	}
392	#endif
393
394
395	/**
396	* Terminate the debug info repository for the specified VM.
397	*
398	* @returns VBox status.
399	* @param pVM VM Handle.
400	*/
401	int dbgfR3SymTerm(PVM pVM)
402	{
403	#ifdef HAVE_DBGHELP
404	if (pVM->dbgf.s.fSymInited)
405	SymCleanup(pVM);
406	pVM->dbgf.s.fSymInited = false;
407	return VINF_SUCCESS;
408	#else
409	pVM->dbgf.s.SymbolTree = 0; /* MM cleans up allocations */
410	pVM->dbgf.s.fSymInited = false;
411	return VINF_SUCCESS;
412	#endif
413	}
414
415
416	/** Symbol file type.. */
417	typedef enum SYMFILETYPE
418	{
419	SYMFILETYPE_UNKNOWN,
420	SYMFILETYPE_LD_MAP,
421	SYMFILETYPE_MS_MAP,
422	SYMFILETYPE_OBJDUMP,
423	SYMFILETYPE_LINUX_SYSTEM_MAP,
424	SYMFILETYPE_PDB,
425	SYMFILETYPE_DBG,
426	SYMFILETYPE_MZ,
427	SYMFILETYPE_ELF
428	} SYMFILETYPE, *PSYMFILETYPE;
429
430
431
432	/**
433	* Probe the type of a symbol information file.
434	*
435	* @returns The file type.
436	* @param pFile File handle.
437	*/
438	SYMFILETYPE dbgfR3ModuleProbe(FILE *pFile)
439	{
440	char szHead[4096];
441	size_t cchHead = fread(szHead, 1, sizeof(szHead) - 1, pFile);
442	if (cchHead > 0)
443	{
444	szHead[cchHead] = '\0';
445	if (strstr(szHead, "Preferred load address is"))
446	return SYMFILETYPE_MS_MAP;
447
448	if ( strstr(szHead, "Archive member included because of")
449	\|\| strstr(szHead, "Memory Configuration")
450	\|\| strstr(szHead, "Linker script and memory map"))
451	return SYMFILETYPE_LD_MAP;
452
453	if ( RT_C_IS_XDIGIT(szHead[0])
454	&& RT_C_IS_XDIGIT(szHead[1])
455	&& RT_C_IS_XDIGIT(szHead[2])
456	&& RT_C_IS_XDIGIT(szHead[3])
457	&& RT_C_IS_XDIGIT(szHead[4])
458	&& RT_C_IS_XDIGIT(szHead[5])
459	&& RT_C_IS_XDIGIT(szHead[6])
460	&& RT_C_IS_XDIGIT(szHead[7])
461	&& szHead[8] == ' '
462	&& RT_C_IS_ALPHA(szHead[9])
463	&& szHead[10] == ' '
464	&& (RT_C_IS_ALPHA(szHead[11]) \|\| szHead[11] == '_' \|\| szHead[11] == '$')
465	)
466	return SYMFILETYPE_LINUX_SYSTEM_MAP;
467
468	if ( RT_C_IS_XDIGIT(szHead[0])
469	&& RT_C_IS_XDIGIT(szHead[1])
470	&& RT_C_IS_XDIGIT(szHead[2])
471	&& RT_C_IS_XDIGIT(szHead[3])
472	&& RT_C_IS_XDIGIT(szHead[4])
473	&& RT_C_IS_XDIGIT(szHead[5])
474	&& RT_C_IS_XDIGIT(szHead[6])
475	&& RT_C_IS_XDIGIT(szHead[7])
476	&& RT_C_IS_XDIGIT(szHead[8])
477	&& RT_C_IS_XDIGIT(szHead[9])
478	&& RT_C_IS_XDIGIT(szHead[10])
479	&& RT_C_IS_XDIGIT(szHead[11])
480	&& RT_C_IS_XDIGIT(szHead[12])
481	&& RT_C_IS_XDIGIT(szHead[13])
482	&& RT_C_IS_XDIGIT(szHead[14])
483	&& RT_C_IS_XDIGIT(szHead[15])
484	&& szHead[16] == ' '
485	&& RT_C_IS_ALPHA(szHead[17])
486	&& szHead[18] == ' '
487	&& (RT_C_IS_ALPHA(szHead[19]) \|\| szHead[19] == '_' \|\| szHead[19] == '$')
488	)
489	return SYMFILETYPE_LINUX_SYSTEM_MAP;
490
491	if (strstr(szHead, "Microsoft C/C++ MSF") == szHead)
492	return SYMFILETYPE_PDB;
493
494	if (strstr(szHead, "ELF") == szHead + 1)
495	return SYMFILETYPE_ELF;
496
497	if ( strstr(szHead, "MZ") == szHead
498	\|\| strstr(szHead, "PE") == szHead
499	\|\| strstr(szHead, "LE") == szHead
500	\|\| strstr(szHead, "LX") == szHead
501	\|\| strstr(szHead, "NE") == szHead)
502	return SYMFILETYPE_MZ;
503
504
505	if (strstr(szHead, "file format"))
506	return SYMFILETYPE_OBJDUMP;
507	}
508
509	return SYMFILETYPE_UNKNOWN;
510	}
511
512
513	static int dbgfR3LoadLinuxSystemMap(PVM pVM, FILE *pFile, RTGCUINTPTR ModuleAddress, RTGCUINTPTR AddressDelta)
514	{
515	char szLine[4096];
516	while (fgets(szLine, sizeof(szLine), pFile))
517	{
518	/* parse the line: <address> <type> <name> */
519	const char *psz = dbgfR3Strip(szLine);
520	char *pszEnd = NULL;
521	uint64_t u64Address;
522	int rc = RTStrToUInt64Ex(psz, &pszEnd, 16, &u64Address);
523	RTGCUINTPTR Address = u64Address;
524	if ( RT_SUCCESS(rc)
525	&& (pszEnd == ' ' \|\| pszEnd == '\t')
526	&& Address == u64Address
527	&& u64Address != 0
528	&& u64Address != (RTGCUINTPTR)~0)
529	{
530	pszEnd++;
531	if ( RT_C_IS_ALPHA(*pszEnd)
532	&& (pszEnd[1] == ' ' \|\| pszEnd[1] == '\t'))
533	{
534	psz = dbgfR3Strip(pszEnd + 2);
535	if (*psz)
536	{
537	int rc2 = DBGFR3SymbolAdd(pVM, ModuleAddress, Address + AddressDelta, 0, psz);
538	if (RT_FAILURE(rc2))
539	Log2(("DBGFR3SymbolAdd(,, %RGv, 0, '%s') -> %Rrc\n", Address, psz, rc2));
540	}
541	}
542	}
543	}
544	return VINF_SUCCESS;
545	}
546
547	/**
548	* Tries to open the file using the image search paths.
549	*
550	* This is currently a quick hack and the only way to specifying the path is by setting
551	* VBOXDBG_IMAGE_PATH in the environment. It uses semicolon as separator everywhere.
552	*
553	* @returns VBox status code.
554	* @param pVM The VM handle.
555	* @param pszFilename The name of the file to locate and open.
556	* @param pszFound Where to return the actual filename.
557	* @param cchFound The buffer size.
558	* @param ppFile Where to return the opened file.
559	*/
560	int dbgfR3ModuleLocateAndOpen(PVM pVM, const char pszFilename, char pszFound, size_t cchFound, FILE **ppFile)
561	{
562	NOREF(pVM);
563
564	/* Check the filename length. */
565	size_t const cchFilename = strlen(pszFilename);
566	if (cchFilename >= cchFound)
567	return VERR_FILENAME_TOO_LONG;
568	const char *pszName = RTPathFilename(pszFilename);
569	if (!pszName)
570	return VERR_IS_A_DIRECTORY;
571	size_t const cchName = strlen(pszName);
572
573	/*
574	* Try default location first.
575	*/
576	memcpy(pszFound, pszFilename, cchFilename + 1);
577	FILE pFile = ppFile = fopen(pszFound, "rb");
578	if (pFile)
579	return VINF_SUCCESS;
580
581	/*
582	* Walk the search path.
583	*/
584	char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, "VBOXDBG_IMAGE_PATH");
585	const char *psz = pszFreeMe ? pszFreeMe : ".";
586	while (*psz)
587	{
588	/* Skip leading blanks - no directories with leading spaces, thank you. */
589	while (RT_C_IS_BLANK(*psz))
590	psz++;
591
592	/* Fine the end of this element. */
593	const char *pszNext;
594	const char *pszEnd = strchr(psz, ';');
595	if (!pszEnd)
596	pszEnd = pszNext = strchr(psz, '\0');
597	else
598	pszNext = pszEnd + 1;
599	if (pszEnd != psz)
600	{
601	size_t const cch = pszEnd - psz;
602	if (cch + 1 + cchName < cchFound)
603	{
604	/** @todo RTPathCompose, RTPathComposeN(). This code isn't right
605	* for 'E:' on DOS systems. It may also create unwanted double slashes. */
606	memcpy(pszFound, psz, cch);
607	pszFound[cch] = '/';
608	memcpy(pszFound + cch + 1, pszName, cchName + 1);
609	*ppFile = pFile = fopen(pszFound, "rb");
610	if (pFile)
611	{
612	RTStrFree(pszFreeMe);
613	return VINF_SUCCESS;
614	}
615	}
616
617	/** @todo do a depth search using the specified path. */
618	}
619
620	/* advance */
621	psz = pszNext;
622	}
623
624	/* not found */
625	RTStrFree(pszFreeMe);
626	return VERR_OPEN_FAILED;
627	}
628
629
630	/**
631	* Load debug info, optionally related to a specific module.
632	*
633	* @returns VBox status.
634	* @param pVM VM Handle.
635	* @param pszFilename Path to the file containing the symbol information.
636	* This can be the executable image, a flat symbol file of some kind or stripped debug info.
637	* @param AddressDelta The value to add to the loaded symbols.
638	* @param pszName Short hand name for the module. If not related to a module specify NULL.
639	* @param ModuleAddress Address which the image is loaded at. This will be used to reference the module other places in the api.
640	* Ignored when pszName is NULL.
641	* @param cbImage Size of the image.
642	* Ignored when pszName is NULL.
643	*/
644	VMMR3DECL(int) DBGFR3ModuleLoad(PVM pVM, const char pszFilename, RTGCUINTPTR AddressDelta, const char pszName,
645	RTGCUINTPTR ModuleAddress, unsigned cbImage)
646	{
647	NOREF(cbImage);
648
649	/*
650	* Lazy init.
651	*/
652	if (!pVM->dbgf.s.fSymInited)
653	{
654	int rc = dbgfR3SymLazyInit(pVM);
655	if (RT_FAILURE(rc))
656	return rc;
657	}
658
659	/*
660	* Open the load file.
661	*/
662	FILE *pFile = NULL;
663	char szFoundFile[RTPATH_MAX];
664	int rc = dbgfR3ModuleLocateAndOpen(pVM, pszFilename, szFoundFile, sizeof(szFoundFile), &pFile);
665	if (pFile)
666	{
667	/*
668	* Probe the file type.
669	*/
670	SYMFILETYPE enmType = dbgfR3ModuleProbe(pFile);
671	if (enmType != SYMFILETYPE_UNKNOWN)
672	{
673	/*
674	* Add the module.
675	*/
676	if (pszName)
677	{
678	#ifdef HAVE_DBGHELP
679	/** @todo arg! checkout the inserting of modules and then loading them again.... Or just the module representation.... */
680	DWORD64 ImageBase = SymLoadModule64(pVM, NULL, (char )(void )szFoundFile, (char )(void )pszName, ModuleAddress, cbImage);
681	if (!ImageBase)
682	ImageBase = SymLoadModule64(pVM, NULL, (char )(void )pszName, (char )(void )pszName, ModuleAddress, cbImage);
683	if (ImageBase)
684	{
685	AssertMsg(ModuleAddress == 0 \|\| ModuleAddress == ImageBase, ("ModuleAddres=%RGv ImageBase=%llx\n", ModuleAddress, ImageBase));
686	ModuleAddress = ImageBase;
687	}
688	else
689	rc = win32Error(pVM);
690	#else
691	rc = VERR_NOT_IMPLEMENTED;
692	#endif
693	}
694	if (RT_SUCCESS(rc))
695	{
696	/*
697	* Seek to the start of the file.
698	*/
699	rc = fseek(pFile, 0, SEEK_SET);
700	Assert(!rc);
701
702	/*
703	* Process the specific.
704	*/
705	switch (enmType)
706	{
707	case SYMFILETYPE_LINUX_SYSTEM_MAP:
708	rc = dbgfR3LoadLinuxSystemMap(pVM, pFile, ModuleAddress, AddressDelta);
709	break;
710
711	case SYMFILETYPE_PDB:
712	case SYMFILETYPE_DBG:
713	case SYMFILETYPE_MZ:
714	#ifdef HAVE_DBGHELP
715	/* done it all above! */
716	break;
717	#endif
718	case SYMFILETYPE_LD_MAP:
719	case SYMFILETYPE_MS_MAP:
720	case SYMFILETYPE_OBJDUMP:
721	case SYMFILETYPE_ELF:
722	rc = VERR_NOT_SUPPORTED;
723	break;
724
725	default:
726	AssertFailed();
727	rc = VERR_INTERNAL_ERROR;
728	break;
729	} /* file switch. */
730	} /* module added successfully. */
731	} /* format identified */
732	else
733	rc = VERR_NOT_SUPPORTED;
734	/** @todo check for read errors */
735	fclose(pFile);
736	}
737	return rc;
738	}
739
740
741	/**
742	* Interface used by PDMR3LdrRelocate for telling us that a GC module has been relocated.
743	*
744	* @param pVM The VM handle.
745	* @param OldImageBase The old image base.
746	* @param NewImageBase The new image base.
747	* @param cbImage The image size.
748	* @param pszFilename The image filename.
749	* @param pszName The module name.
750	*/
751	VMMR3DECL(void) DBGFR3ModuleRelocate(PVM pVM, RTGCUINTPTR OldImageBase, RTGCUINTPTR NewImageBase, RTGCUINTPTR cbImage,
752	const char pszFilename, const char pszName)
753	{
754	#ifdef HAVE_DBGHELP
755	if (pVM->dbgf.s.fSymInited)
756	{
757	if (!SymUnloadModule64(pVM, OldImageBase))
758	Log(("SymUnloadModule64(,%RGv) failed, lasterr=%d\n", OldImageBase, GetLastError()));
759
760	DWORD ImageSize = (DWORD)cbImage; Assert(ImageSize == cbImage);
761	DWORD64 LoadedImageBase = SymLoadModule64(pVM, NULL, (char )(void )pszFilename, (char )(void )pszName, NewImageBase, ImageSize);
762	if (!LoadedImageBase)
763	Log(("SymLoadModule64(,,%s,,) -> lasterr=%d (relocate)\n", pszFilename, GetLastError()));
764	else
765	Log(("Reloaded debuginfo for %s - %s %llx\n", pszName, pszFilename, LoadedImageBase));
766	}
767	#else
768	NOREF(pVM); NOREF(OldImageBase); NOREF(NewImageBase); NOREF(cbImage); NOREF(pszFilename); NOREF(pszName);
769	#endif
770	}
771
772
773	/**
774	* Adds a symbol to the debug info manager.
775	*
776	* @returns VBox status.
777	* @param pVM VM Handle.
778	* @param ModuleAddress Module address. Use 0 if no module.
779	* @param SymbolAddress Symbol address
780	* @param cbSymbol Size of the symbol. Use 0 if info not available.
781	* @param pszSymbol Symbol name.
782	*/
783	VMMR3DECL(int) DBGFR3SymbolAdd(PVM pVM, RTGCUINTPTR ModuleAddress, RTGCUINTPTR SymbolAddress, RTUINT cbSymbol,
784	const char *pszSymbol)
785	{
786	/*
787	* Validate.
788	*/
789	if (!pszSymbol \|\| !*pszSymbol)
790	{
791	AssertMsgFailed(("No symbol name!\n"));
792	return VERR_INVALID_PARAMETER;
793	}
794
795	/*
796	* Lazy init.
797	*/
798	if (!pVM->dbgf.s.fSymInited)
799	{
800	int rc = dbgfR3SymLazyInit(pVM);
801	if (RT_FAILURE(rc))
802	return rc;
803	}
804
805	#ifdef HAVE_DBGHELP
806	if (SymAddSymbol(pVM, ModuleAddress, (char )(void )pszSymbol, SymbolAddress, cbSymbol, 0))
807	return VINF_SUCCESS;
808	return win32Error(pVM);
809	#else
810	NOREF(ModuleAddress); /** @todo module lookup. */
811	return dbgfR3SymbolInsert(pVM, pszSymbol, SymbolAddress, cbSymbol, NULL);
812	#endif
813	}
814
815
816	/**
817	* Find symbol by address (nearest).
818	*
819	* @returns VBox status.
820	* @param pVM VM handle.
821	* @param Address Address.
822	* @param poffDisplacement Where to store the symbol displacement from Address.
823	* @param pSymbol Where to store the symbol info.
824	*/
825	VMMR3DECL(int) DBGFR3SymbolByAddr(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement, PDBGFSYMBOL pSymbol)
826	{
827	/*
828	* Lazy init.
829	*/
830	if (!pVM->dbgf.s.fSymInited)
831	{
832	int rc = dbgfR3SymLazyInit(pVM);
833	if (RT_FAILURE(rc))
834	return rc;
835	}
836
837	/*
838	* Look it up.
839	*/
840	#ifdef HAVE_DBGHELP
841	char achBuffer[sizeof(IMAGEHLP_SYMBOL64) + DBGF_SYMBOL_NAME_LENGTH * sizeof(TCHAR) + sizeof(ULONG64)];
842	PIMAGEHLP_SYMBOL64 pSym = (PIMAGEHLP_SYMBOL64)&achBuffer[0];
843	pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
844	pSym->MaxNameLength = DBGF_SYMBOL_NAME_LENGTH;
845
846	if (SymGetSymFromAddr64(pVM, Address, (PDWORD64)poffDisplacement, pSym))
847	{
848	pSymbol->Value = (RTGCUINTPTR)pSym->Address;
849	pSymbol->cb = pSym->Size;
850	pSymbol->fFlags = pSym->Flags;
851	strcpy(pSymbol->szName, pSym->Name);
852	return VINF_SUCCESS;
853	}
854	//return win32Error(pVM);
855
856	#else
857
858	PDBGFSYM pSym = dbgfR3SymbolGetAddr(pVM, Address);
859	if (pSym)
860	{
861	pSymbol->Value = pSym->Core.Key;
862	pSymbol->cb = pSym->Core.KeyLast - pSym->Core.Key + 1;
863	pSymbol->fFlags = 0;
864	pSymbol->szName[0] = '\0';
865	strncat(pSymbol->szName, pSym->szName, sizeof(pSymbol->szName) - 1);
866	if (poffDisplacement)
867	*poffDisplacement = Address - pSymbol->Value;
868	return VINF_SUCCESS;
869	}
870
871	#endif
872
873	/*
874	* Try PDM.
875	*/
876	if (MMHyperIsInsideArea(pVM, Address))
877	{
878	char szModName[64];
879	RTRCPTR RCPtrMod;
880	char szNearSym1[260];
881	RTRCPTR RCPtrNearSym1;
882	char szNearSym2[260];
883	RTRCPTR RCPtrNearSym2;
884	int rc = PDMR3LdrQueryRCModFromPC(pVM, Address,
885	&szModName[0], sizeof(szModName), &RCPtrMod,
886	&szNearSym1[0], sizeof(szNearSym1), &RCPtrNearSym1,
887	&szNearSym2[0], sizeof(szNearSym2), &RCPtrNearSym2);
888	if (RT_SUCCESS(rc) && szNearSym1[0])
889	{
890	pSymbol->Value = RCPtrNearSym1;
891	pSymbol->cb = RCPtrNearSym2 > RCPtrNearSym1 ? RCPtrNearSym2 - RCPtrNearSym1 : 0;
892	pSymbol->fFlags = 0;
893	pSymbol->szName[0] = '\0';
894	strncat(pSymbol->szName, szNearSym1, sizeof(pSymbol->szName) - 1);
895	if (poffDisplacement)
896	*poffDisplacement = Address - pSymbol->Value;
897	return VINF_SUCCESS;
898	}
899	}
900
901	return VERR_SYMBOL_NOT_FOUND;
902	}
903
904
905	/**
906	* Find symbol by name (first).
907	*
908	* @returns VBox status.
909	* @param pVM VM handle.
910	* @param pszSymbol Symbol name.
911	* @param pSymbol Where to store the symbol info.
912	*/
913	VMMR3DECL(int) DBGFR3SymbolByName(PVM pVM, const char *pszSymbol, PDBGFSYMBOL pSymbol)
914	{
915	/*
916	* Lazy init.
917	*/
918	if (!pVM->dbgf.s.fSymInited)
919	{
920	int rc = dbgfR3SymLazyInit(pVM);
921	if (RT_FAILURE(rc))
922	return rc;
923	}
924
925	/*
926	* Look it up.
927	*/
928	#ifdef HAVE_DBGHELP
929	char achBuffer[sizeof(IMAGEHLP_SYMBOL64) + DBGF_SYMBOL_NAME_LENGTH * sizeof(TCHAR) + sizeof(ULONG64)];
930	PIMAGEHLP_SYMBOL64 pSym = (PIMAGEHLP_SYMBOL64)&achBuffer[0];
931	pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
932	pSym->MaxNameLength = DBGF_SYMBOL_NAME_LENGTH;
933
934	if (SymGetSymFromName64(pVM, (char )(void )pszSymbol, pSym))
935	{
936	pSymbol->Value = (RTGCUINTPTR)pSym->Address;
937	pSymbol->cb = pSym->Size;
938	pSymbol->fFlags = pSym->Flags;
939	strcpy(pSymbol->szName, pSym->Name);
940	return VINF_SUCCESS;
941	}
942	return win32Error(pVM);
943	#else
944
945	PDBGFSYM pSym = dbgfR3SymbolGetName(pVM, pszSymbol);
946	if (pSym)
947	{
948	pSymbol->Value = pSym->Core.Key;
949	pSymbol->cb = pSym->Core.KeyLast - pSym->Core.Key + 1;
950	pSymbol->fFlags = 0;
951	pSymbol->szName[0] = '\0';
952	strncat(pSymbol->szName, pSym->szName, sizeof(pSymbol->szName) - 1);
953	return VINF_SUCCESS;
954	}
955
956	return VERR_SYMBOL_NOT_FOUND;
957	#endif
958	}
959
960
961	/**
962	* Find line by address (nearest).
963	*
964	* @returns VBox status.
965	* @param pVM VM handle.
966	* @param Address Address.
967	* @param poffDisplacement Where to store the line displacement from Address.
968	* @param pLine Where to store the line info.
969	*/
970	VMMR3DECL(int) DBGFR3LineByAddr(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement, PDBGFLINE pLine)
971	{
972	/*
973	* Lazy init.
974	*/
975	if (!pVM->dbgf.s.fSymInited)
976	{
977	int rc = dbgfR3SymLazyInit(pVM);
978	if (RT_FAILURE(rc))
979	return rc;
980	}
981
982	/*
983	* Look it up.
984	*/
985	#ifdef HAVE_DBGHELP
986	IMAGEHLP_LINE64 Line = {0};
987	DWORD off = 0;
988	Line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
989	if (SymGetLineFromAddr64(pVM, Address, &off, &Line))
990	{
991	if (poffDisplacement)
992	*poffDisplacement = (long)off;
993	pLine->Address = (RTGCUINTPTR)Line.Address;
994	pLine->uLineNo = Line.LineNumber;
995	pLine->szFilename[0] = '\0';
996	strncat(pLine->szFilename, Line.FileName, sizeof(pLine->szFilename));
997	return VINF_SUCCESS;
998	}
999	return win32Error(pVM);
1000	#else
1001	NOREF(pVM); NOREF(Address); NOREF(poffDisplacement); NOREF(pLine);
1002	return VERR_NOT_IMPLEMENTED;
1003	#endif
1004	}
1005
1006
1007	/**
1008	* Duplicates a line.
1009	*
1010	* @returns VBox status code.
1011	* @param pVM The VM handle.
1012	* @param pLine The line to duplicate.
1013	*/
1014	static PDBGFLINE dbgfR3LineDup(PVM pVM, PCDBGFLINE pLine)
1015	{
1016	size_t cb = strlen(pLine->szFilename) + RT_OFFSETOF(DBGFLINE, szFilename[1]);
1017	PDBGFLINE pDup = (PDBGFLINE)MMR3HeapAlloc(pVM, MM_TAG_DBGF_LINE_DUP, cb);
1018	if (pDup)
1019	memcpy(pDup, pLine, cb);
1020	return pDup;
1021	}
1022
1023
1024	/**
1025	* Find line by address (nearest), allocate return buffer.
1026	*
1027	* @returns Pointer to the line. Must be freed using DBGFR3LineFree().
1028	* @returns NULL if the line was not found or if we're out of memory.
1029	* @param pVM VM handle.
1030	* @param Address Address.
1031	* @param poffDisplacement Where to store the line displacement from Address.
1032	*/
1033	VMMR3DECL(PDBGFLINE) DBGFR3LineByAddrAlloc(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement)
1034	{
1035	DBGFLINE Line;
1036	int rc = DBGFR3LineByAddr(pVM, Address, poffDisplacement, &Line);
1037	if (RT_FAILURE(rc))
1038	return NULL;
1039	return dbgfR3LineDup(pVM, &Line);
1040	}
1041
1042
1043	/**
1044	* Frees a line returned by DBGFR3LineByAddressAlloc().
1045	*
1046	* @param pLine Pointer to the line.
1047	*/
1048	VMMR3DECL(void) DBGFR3LineFree(PDBGFLINE pLine)
1049	{
1050	if (pLine)
1051	MMR3HeapFree(pLine);
1052	}
1053
1054
1055	#ifdef HAVE_DBGHELP
1056
1057	//static BOOL CALLBACK win32EnumModulesCallback(PSTR ModuleName, DWORD64 BaseOfDll, PVOID UserContext)
1058	//{
1059	// Log(("dbg: module: %08llx %s\n", ModuleName, BaseOfDll));
1060	// return TRUE;
1061	//}
1062
1063	static int win32Error(PVM pVM)
1064	{
1065	int rc = GetLastError();
1066	Log(("Lasterror=%d\n", rc));
1067
1068	//SymEnumerateModules64(pVM, win32EnumModulesCallback, NULL);
1069
1070	return VERR_GENERAL_FAILURE;
1071	}
1072	#endif
1073

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFSym.cpp@ 39078

Download in other formats: