VirtualBox

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

Last change on this file since 24912 was 24009, checked in by vboxsync, 15 years ago

don't use <ctype.h> on UTF-8.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 33.4 KB
Line 
1/* $Id: DBGFSym.cpp 24009 2009-10-23 08:25:56Z 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
60static DECLCALLBACK(int) dbgfR3EnumModules(PVM pVM, const char *pszFilename, const char *pszName,
61 RTUINTPTR ImageBase, size_t cbImage, bool fRC, void *pvArg);
62static int win32Error(PVM pVM);
63#endif
64
65
66/*******************************************************************************
67* Structures and Typedefs *
68*******************************************************************************/
69#ifndef HAVE_DBGHELP
70/* later */
71typedef struct DBGFMOD *PDBGFMOD;
72
73/**
74 * Internal represenation of a symbol.
75 */
76typedef 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 */
91typedef 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 */
112static 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 */
133static 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 */
202static 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 */
216static 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 */
230static char *dbgfR3Strip(char *psz)
231{
232 while (*psz && RT_C_IS_SPACE(*psz))
233 psz++;
234 char *psz2 = strchr(psz, '\0') - 1;
235 while (psz2 >= psz && RT_C_IS_SPACE(*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 */
250int 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 */
346int 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 */
384static 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 */
405int 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.. */
421typedef 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 */
442SYMFILETYPE 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 ( RT_C_IS_XDIGIT(szHead[0])
458 && RT_C_IS_XDIGIT(szHead[1])
459 && RT_C_IS_XDIGIT(szHead[2])
460 && RT_C_IS_XDIGIT(szHead[3])
461 && RT_C_IS_XDIGIT(szHead[4])
462 && RT_C_IS_XDIGIT(szHead[5])
463 && RT_C_IS_XDIGIT(szHead[6])
464 && RT_C_IS_XDIGIT(szHead[7])
465 && szHead[8] == ' '
466 && RT_C_IS_ALPHA(szHead[9])
467 && szHead[10] == ' '
468 && (RT_C_IS_ALPHA(szHead[11]) || szHead[11] == '_' || szHead[11] == '$')
469 )
470 return SYMFILETYPE_LINUX_SYSTEM_MAP;
471
472 if ( RT_C_IS_XDIGIT(szHead[0])
473 && RT_C_IS_XDIGIT(szHead[1])
474 && RT_C_IS_XDIGIT(szHead[2])
475 && RT_C_IS_XDIGIT(szHead[3])
476 && RT_C_IS_XDIGIT(szHead[4])
477 && RT_C_IS_XDIGIT(szHead[5])
478 && RT_C_IS_XDIGIT(szHead[6])
479 && RT_C_IS_XDIGIT(szHead[7])
480 && RT_C_IS_XDIGIT(szHead[8])
481 && RT_C_IS_XDIGIT(szHead[9])
482 && RT_C_IS_XDIGIT(szHead[10])
483 && RT_C_IS_XDIGIT(szHead[11])
484 && RT_C_IS_XDIGIT(szHead[12])
485 && RT_C_IS_XDIGIT(szHead[13])
486 && RT_C_IS_XDIGIT(szHead[14])
487 && RT_C_IS_XDIGIT(szHead[15])
488 && szHead[16] == ' '
489 && RT_C_IS_ALPHA(szHead[17])
490 && szHead[18] == ' '
491 && (RT_C_IS_ALPHA(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
517static 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 ( RT_C_IS_ALPHA(*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 */
564int 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 */
643VMMR3DECL(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 */
747VMMR3DECL(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 */
779VMMR3DECL(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 */
820VMMR3DECL(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 */
908VMMR3DECL(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 * Find line by address (nearest).
958 *
959 * @returns VBox status.
960 * @param pVM VM handle.
961 * @param Address Address.
962 * @param poffDisplacement Where to store the line displacement from Address.
963 * @param pLine Where to store the line info.
964 */
965VMMR3DECL(int) DBGFR3LineByAddr(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement, PDBGFLINE pLine)
966{
967 /*
968 * Lazy init.
969 */
970 if (!pVM->dbgf.s.fSymInited)
971 {
972 int rc = dbgfR3SymLazyInit(pVM);
973 if (RT_FAILURE(rc))
974 return rc;
975 }
976
977 /*
978 * Look it up.
979 */
980#ifdef HAVE_DBGHELP
981 IMAGEHLP_LINE64 Line = {0};
982 DWORD off = 0;
983 Line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
984 if (SymGetLineFromAddr64(pVM, Address, &off, &Line))
985 {
986 if (poffDisplacement)
987 *poffDisplacement = (long)off;
988 pLine->Address = (RTGCUINTPTR)Line.Address;
989 pLine->uLineNo = Line.LineNumber;
990 pLine->szFilename[0] = '\0';
991 strncat(pLine->szFilename, Line.FileName, sizeof(pLine->szFilename));
992 return VINF_SUCCESS;
993 }
994 return win32Error(pVM);
995#else
996 return VERR_NOT_IMPLEMENTED;
997#endif
998}
999
1000
1001/**
1002 * Duplicates a line.
1003 *
1004 * @returns VBox status code.
1005 * @param pVM The VM handle.
1006 * @param pLine The line to duplicate.
1007 */
1008static PDBGFLINE dbgfR3LineDup(PVM pVM, PCDBGFLINE pLine)
1009{
1010 size_t cb = strlen(pLine->szFilename) + RT_OFFSETOF(DBGFLINE, szFilename[1]);
1011 PDBGFLINE pDup = (PDBGFLINE)MMR3HeapAlloc(pVM, MM_TAG_DBGF_LINE_DUP, cb);
1012 if (pDup)
1013 memcpy(pDup, pLine, cb);
1014 return pDup;
1015}
1016
1017
1018/**
1019 * Find line by address (nearest), allocate return buffer.
1020 *
1021 * @returns Pointer to the line. Must be freed using DBGFR3LineFree().
1022 * @returns NULL if the line was not found or if we're out of memory.
1023 * @param pVM VM handle.
1024 * @param Address Address.
1025 * @param poffDisplacement Where to store the line displacement from Address.
1026 */
1027VMMR3DECL(PDBGFLINE) DBGFR3LineByAddrAlloc(PVM pVM, RTGCUINTPTR Address, PRTGCINTPTR poffDisplacement)
1028{
1029 DBGFLINE Line;
1030 int rc = DBGFR3LineByAddr(pVM, Address, poffDisplacement, &Line);
1031 if (RT_FAILURE(rc))
1032 return NULL;
1033 return dbgfR3LineDup(pVM, &Line);
1034}
1035
1036
1037/**
1038 * Frees a line returned by DBGFR3LineByAddressAlloc().
1039 *
1040 * @param pLine Pointer to the line.
1041 */
1042VMMR3DECL(void) DBGFR3LineFree(PDBGFLINE pLine)
1043{
1044 if (pLine)
1045 MMR3HeapFree(pLine);
1046}
1047
1048
1049#ifdef HAVE_DBGHELP
1050
1051//static BOOL CALLBACK win32EnumModulesCallback(PSTR ModuleName, DWORD64 BaseOfDll, PVOID UserContext)
1052//{
1053// Log(("dbg: module: %08llx %s\n", ModuleName, BaseOfDll));
1054// return TRUE;
1055//}
1056
1057static int win32Error(PVM pVM)
1058{
1059 int rc = GetLastError();
1060 Log(("Lasterror=%d\n", rc));
1061
1062 //SymEnumerateModules64(pVM, win32EnumModulesCallback, NULL);
1063
1064 return VERR_GENERAL_FAILURE;
1065}
1066#endif
1067
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use