DBGFSym.cpp@ 20007

Last change on this file since 20007 was 19773, checked in by vboxsync, 16 years ago
Fixed accidental commits
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 35.1 KB

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

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

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

Download in other formats: