VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/ldr/ldrkStuff.cpp@ 42599

Last change on this file since 42599 was 39436, checked in by vboxsync, 13 years ago

Runtime/ldrkStuff: fixed wrong buffer size
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 29.3 KB
Line 
1/* $Id: ldrkStuff.cpp 39436 2011-11-28 13:17:04Z vboxsync $ */
2/** @file
3 * IPRT - Binary Image Loader, kLdr Interface.
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 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#define LOG_GROUP RTLOGGROUP_LDR
32#include <iprt/ldr.h>
33#include "internal/iprt.h"
34
35#include <iprt/file.h>
36#include <iprt/alloc.h>
37#include <iprt/alloca.h>
38#include <iprt/assert.h>
39#include <iprt/string.h>
40#include <iprt/path.h>
41#include <iprt/log.h>
42#include <iprt/param.h>
43#include <iprt/err.h>
44#include "internal/ldr.h"
45#define KLDR_ALREADY_INCLUDE_STD_TYPES
46#define KLDR_NO_KLDR_H_INCLUDES
47#include <k/kLdr.h>
48#include <k/kRdrAll.h>
49#include <k/kErr.h>
50#include <k/kErrors.h>
51#include <k/kMagics.h>
52
53
54/*******************************************************************************
55* Structures and Typedefs *
56*******************************************************************************/
57/**
58 * kLdr file provider.
59 */
60typedef struct RTKLDRRDR
61{
62 /** The core. */
63 KRDR Core;
64 /** The IPRT bit reader. */
65 PRTLDRREADER pReader;
66} RTKLDRRDR, *PRTKLDRRDR;
67
68/**
69 * IPRT module.
70 */
71typedef struct RTLDRMODKLDR
72{
73 /** The Core module structure. */
74 RTLDRMODINTERNAL Core;
75 /** The kLdr module. */
76 PKLDRMOD pMod;
77} RTLDRMODKLDR, *PRTLDRMODKLDR;
78
79
80/**
81 * Arguments for a RTLDRMODKLDR callback wrapper.
82 */
83typedef struct RTLDRMODKLDRARGS
84{
85 union
86 {
87 PFNRT pfn;
88 PFNRTLDRENUMDBG pfnEnumDbgInfo;
89 PFNRTLDRENUMSYMS pfnEnumSyms;
90 PFNRTLDRIMPORT pfnGetImport;
91 } u;
92 void *pvUser;
93 const void *pvBits;
94 PRTLDRMODKLDR pMod;
95 int rc;
96} RTLDRMODKLDRARGS, *PRTLDRMODKLDRARGS;
97
98
99/**
100 * Converts a kLdr error code to an IPRT one.
101 */
102static int rtkldrConvertError(int krc)
103{
104 if (!krc)
105 return VINF_SUCCESS;
106 switch (krc)
107 {
108 case KERR_INVALID_PARAMETER: return VERR_INVALID_PARAMETER;
109 case KERR_INVALID_HANDLE: return VERR_INVALID_HANDLE;
110 case KERR_NO_MEMORY: return VERR_NO_MEMORY;
111
112
113 case KLDR_ERR_UNKNOWN_FORMAT:
114 case KLDR_ERR_MZ_NOT_SUPPORTED: return VERR_MZ_EXE_NOT_SUPPORTED;
115 case KLDR_ERR_NE_NOT_SUPPORTED: return VERR_NE_EXE_NOT_SUPPORTED;
116 case KLDR_ERR_LX_NOT_SUPPORTED: return VERR_LX_EXE_NOT_SUPPORTED;
117 case KLDR_ERR_LE_NOT_SUPPORTED: return VERR_LE_EXE_NOT_SUPPORTED;
118 case KLDR_ERR_PE_NOT_SUPPORTED: return VERR_PE_EXE_NOT_SUPPORTED;
119 case KLDR_ERR_ELF_NOT_SUPPORTED: return VERR_ELF_EXE_NOT_SUPPORTED;
120 case KLDR_ERR_MACHO_NOT_SUPPORTED: return VERR_INVALID_EXE_SIGNATURE;
121 case KLDR_ERR_AOUT_NOT_SUPPORTED: return VERR_AOUT_EXE_NOT_SUPPORTED;
122
123 case KLDR_ERR_MODULE_NOT_FOUND: return VERR_MODULE_NOT_FOUND;
124 case KLDR_ERR_PREREQUISITE_MODULE_NOT_FOUND: return VERR_MODULE_NOT_FOUND;
125 case KLDR_ERR_MAIN_STACK_ALLOC_FAILED: return VERR_NO_MEMORY;
126 case KERR_BUFFER_OVERFLOW: return VERR_BUFFER_OVERFLOW;
127 case KLDR_ERR_SYMBOL_NOT_FOUND: return VERR_SYMBOL_NOT_FOUND;
128 case KLDR_ERR_FORWARDER_SYMBOL: return VERR_BAD_EXE_FORMAT;
129 case KLDR_ERR_BAD_FIXUP: AssertMsgFailedReturn(("KLDR_ERR_BAD_FIXUP\n"), VERR_BAD_EXE_FORMAT);
130 case KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS: return VERR_BAD_EXE_FORMAT;
131 case KLDR_ERR_NO_DEBUG_INFO: return VERR_FILE_NOT_FOUND;
132 case KLDR_ERR_ALREADY_MAPPED: return VERR_WRONG_ORDER;
133 case KLDR_ERR_NOT_MAPPED: return VERR_WRONG_ORDER;
134 case KLDR_ERR_ADDRESS_OVERFLOW: return VERR_NUMBER_TOO_BIG;
135 case KLDR_ERR_TODO: return VERR_NOT_IMPLEMENTED;
136
137 case KLDR_ERR_NOT_LOADED_DYNAMICALLY:
138 case KCPU_ERR_ARCH_CPU_NOT_COMPATIBLE:
139 case KLDR_ERR_TOO_LONG_FORWARDER_CHAIN:
140 case KLDR_ERR_MODULE_TERMINATING:
141 case KLDR_ERR_PREREQUISITE_MODULE_TERMINATING:
142 case KLDR_ERR_MODULE_INIT_FAILED:
143 case KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED:
144 case KLDR_ERR_MODULE_INIT_FAILED_ALREADY:
145 case KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED_ALREADY:
146 case KLDR_ERR_PREREQUISITE_RECURSED_TOO_DEEPLY:
147 case KLDR_ERR_THREAD_ATTACH_FAILED:
148 case KRDR_ERR_TOO_MANY_MAPPINGS:
149 case KLDR_ERR_NOT_DLL:
150 case KLDR_ERR_NOT_EXE:
151 AssertMsgFailedReturn(("krc=%d (%#x): %s\n", krc, krc, kErrName(krc)), VERR_GENERAL_FAILURE);
152
153
154 case KLDR_ERR_PE_UNSUPPORTED_MACHINE:
155 case KLDR_ERR_PE_BAD_FILE_HEADER:
156 case KLDR_ERR_PE_BAD_OPTIONAL_HEADER:
157 case KLDR_ERR_PE_BAD_SECTION_HEADER:
158 case KLDR_ERR_PE_BAD_FORWARDER:
159 case KLDR_ERR_PE_FORWARDER_IMPORT_NOT_FOUND:
160 case KLDR_ERR_PE_BAD_FIXUP:
161 case KLDR_ERR_PE_BAD_IMPORT:
162 AssertMsgFailedReturn(("krc=%d (%#x): %s\n", krc, krc, kErrName(krc)), VERR_GENERAL_FAILURE);
163
164 case KLDR_ERR_LX_BAD_HEADER:
165 case KLDR_ERR_LX_BAD_LOADER_SECTION:
166 case KLDR_ERR_LX_BAD_FIXUP_SECTION:
167 case KLDR_ERR_LX_BAD_OBJECT_TABLE:
168 case KLDR_ERR_LX_BAD_PAGE_MAP:
169 case KLDR_ERR_LX_BAD_ITERDATA:
170 case KLDR_ERR_LX_BAD_ITERDATA2:
171 case KLDR_ERR_LX_BAD_BUNDLE:
172 case KLDR_ERR_LX_NO_SONAME:
173 case KLDR_ERR_LX_BAD_SONAME:
174 case KLDR_ERR_LX_BAD_FORWARDER:
175 case KLDR_ERR_LX_NRICHAIN_NOT_SUPPORTED:
176 AssertMsgFailedReturn(("krc=%d (%#x): %s\n", krc, krc, kErrName(krc)), VERR_GENERAL_FAILURE);
177
178 case KLDR_ERR_MACHO_OTHER_ENDIAN_NOT_SUPPORTED:
179 case KLDR_ERR_MACHO_BAD_HEADER:
180 case KLDR_ERR_MACHO_UNSUPPORTED_FILE_TYPE:
181 case KLDR_ERR_MACHO_UNSUPPORTED_MACHINE:
182 case KLDR_ERR_MACHO_BAD_LOAD_COMMAND:
183 case KLDR_ERR_MACHO_UNKNOWN_LOAD_COMMAND:
184 case KLDR_ERR_MACHO_UNSUPPORTED_LOAD_COMMAND:
185 case KLDR_ERR_MACHO_BAD_SECTION:
186 case KLDR_ERR_MACHO_UNSUPPORTED_SECTION:
187#ifdef KLDR_ERR_MACHO_UNSUPPORTED_INIT_SECTION
188 case KLDR_ERR_MACHO_UNSUPPORTED_INIT_SECTION:
189 case KLDR_ERR_MACHO_UNSUPPORTED_TERM_SECTION:
190#endif
191 case KLDR_ERR_MACHO_UNKNOWN_SECTION:
192 case KLDR_ERR_MACHO_BAD_SECTION_ORDER:
193 case KLDR_ERR_MACHO_BIT_MIX:
194 case KLDR_ERR_MACHO_BAD_OBJECT_FILE:
195 case KLDR_ERR_MACHO_BAD_SYMBOL:
196 case KLDR_ERR_MACHO_UNSUPPORTED_FIXUP_TYPE:
197 AssertMsgFailedReturn(("krc=%d (%#x): %s\n", krc, krc, kErrName(krc)), VERR_GENERAL_FAILURE);
198
199 default:
200 if (RT_FAILURE(krc))
201 return krc;
202 AssertMsgFailedReturn(("krc=%d (%#x): %s\n", krc, krc, kErrName(krc)), VERR_NO_TRANSLATION);
203 }
204}
205
206
207/**
208 * Converts a IPRT error code to an kLdr one.
209 */
210static int rtkldrConvertErrorFromIPRT(int rc)
211{
212 if (RT_SUCCESS(rc))
213 return 0;
214 switch (rc)
215 {
216 case VERR_NO_MEMORY: return KERR_NO_MEMORY;
217 case VERR_INVALID_PARAMETER: return KERR_INVALID_PARAMETER;
218 case VERR_INVALID_HANDLE: return KERR_INVALID_HANDLE;
219 case VERR_BUFFER_OVERFLOW: return KERR_BUFFER_OVERFLOW;
220 default:
221 return rc;
222 }
223}
224
225
226
227
228
229
230/** @copydoc KLDRRDROPS::pfnCreate
231 * @remark This is a dummy which isn't used. */
232static int rtkldrRdr_Create( PPKRDR ppRdr, const char *pszFilename)
233{
234 NOREF(ppRdr); NOREF(pszFilename);
235 AssertReleaseFailed();
236 return -1;
237}
238
239
240/** @copydoc KLDRRDROPS::pfnDestroy */
241static int rtkldrRdr_Destroy( PKRDR pRdr)
242{
243 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
244 int rc = pReader->pfnDestroy(pReader);
245 return rtkldrConvertErrorFromIPRT(rc);
246}
247
248
249/** @copydoc KLDRRDROPS::pfnRead */
250static int rtkldrRdr_Read( PKRDR pRdr, void *pvBuf, KSIZE cb, KFOFF off)
251{
252 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
253 int rc = pReader->pfnRead(pReader, pvBuf, cb, off);
254 return rtkldrConvertErrorFromIPRT(rc);
255}
256
257
258/** @copydoc KLDRRDROPS::pfnAllMap */
259static int rtkldrRdr_AllMap( PKRDR pRdr, const void **ppvBits)
260{
261 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
262 int rc = pReader->pfnMap(pReader, ppvBits);
263 return rtkldrConvertErrorFromIPRT(rc);
264}
265
266
267/** @copydoc KLDRRDROPS::pfnAllUnmap */
268static int rtkldrRdr_AllUnmap(PKRDR pRdr, const void *pvBits)
269{
270 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
271 int rc = pReader->pfnUnmap(pReader, pvBits);
272 return rtkldrConvertErrorFromIPRT(rc);
273}
274
275
276/** @copydoc KLDRRDROPS::pfnSize */
277static KFOFF rtkldrRdr_Size( PKRDR pRdr)
278{
279 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
280 return (KFOFF)pReader->pfnSize(pReader);
281}
282
283
284/** @copydoc KLDRRDROPS::pfnTell */
285static KFOFF rtkldrRdr_Tell( PKRDR pRdr)
286{
287 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
288 return (KFOFF)pReader->pfnTell(pReader);
289}
290
291
292/** @copydoc KLDRRDROPS::pfnName */
293static const char * rtkldrRdr_Name(PKRDR pRdr)
294{
295 PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
296 return pReader->pfnLogName(pReader);
297}
298
299
300/** @copydoc KLDRRDROPS::pfnNativeFH */
301static KIPTR rtkldrRdr_NativeFH(PKRDR pRdr)
302{
303 NOREF(pRdr);
304 AssertFailed();
305 return -1;
306}
307
308
309/** @copydoc KLDRRDROPS::pfnPageSize */
310static KSIZE rtkldrRdr_PageSize(PKRDR pRdr)
311{
312 NOREF(pRdr);
313 return PAGE_SIZE;
314}
315
316
317/** @copydoc KLDRRDROPS::pfnMap */
318static int rtkldrRdr_Map( PKRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, KBOOL fFixed)
319{
320 //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
321 NOREF(pRdr); NOREF(ppvBase); NOREF(cSegments); NOREF(paSegments); NOREF(fFixed);
322 AssertFailed();
323 return -1;
324}
325
326
327/** @copydoc KLDRRDROPS::pfnRefresh */
328static int rtkldrRdr_Refresh( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
329{
330 //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
331 NOREF(pRdr); NOREF(pvBase); NOREF(cSegments); NOREF(paSegments);
332 AssertFailed();
333 return -1;
334}
335
336
337/** @copydoc KLDRRDROPS::pfnProtect */
338static int rtkldrRdr_Protect( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, KBOOL fUnprotectOrProtect)
339{
340 //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
341 NOREF(pRdr); NOREF(pvBase); NOREF(cSegments); NOREF(paSegments); NOREF(fUnprotectOrProtect);
342 AssertFailed();
343 return -1;
344}
345
346
347/** @copydoc KLDRRDROPS::pfnUnmap */
348static int rtkldrRdr_Unmap( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
349{
350 //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
351 NOREF(pRdr); NOREF(pvBase); NOREF(cSegments); NOREF(paSegments);
352 AssertFailed();
353 return -1;
354}
355
356/** @copydoc KLDRRDROPS::pfnDone */
357static void rtkldrRdr_Done( PKRDR pRdr)
358{
359 NOREF(pRdr);
360 //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
361}
362
363
364/**
365 * The file reader operations.
366 * We provide our own based on IPRT instead of using the kLdr ones.
367 */
368extern "C" const KRDROPS g_kLdrRdrFileOps;
369extern "C" const KRDROPS g_kLdrRdrFileOps =
370{
371 /* .pszName = */ "IPRT",
372 /* .pNext = */ NULL,
373 /* .pfnCreate = */ rtkldrRdr_Create,
374 /* .pfnDestroy = */ rtkldrRdr_Destroy,
375 /* .pfnRead = */ rtkldrRdr_Read,
376 /* .pfnAllMap = */ rtkldrRdr_AllMap,
377 /* .pfnAllUnmap = */ rtkldrRdr_AllUnmap,
378 /* .pfnSize = */ rtkldrRdr_Size,
379 /* .pfnTell = */ rtkldrRdr_Tell,
380 /* .pfnName = */ rtkldrRdr_Name,
381 /* .pfnNativeFH = */ rtkldrRdr_NativeFH,
382 /* .pfnPageSize = */ rtkldrRdr_PageSize,
383 /* .pfnMap = */ rtkldrRdr_Map,
384 /* .pfnRefresh = */ rtkldrRdr_Refresh,
385 /* .pfnProtect = */ rtkldrRdr_Protect,
386 /* .pfnUnmap = */ rtkldrRdr_Unmap,
387 /* .pfnDone = */ rtkldrRdr_Done,
388 /* .u32Dummy = */ 42
389};
390
391
392
393
394
395/** @copydoc RTLDROPS::pfnClose */
396static DECLCALLBACK(int) rtkldr_Close(PRTLDRMODINTERNAL pMod)
397{
398 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
399 int rc = kLdrModClose(pModkLdr);
400 return rtkldrConvertError(rc);
401}
402
403
404/** @copydoc RTLDROPS::pfnDone */
405static DECLCALLBACK(int) rtkldr_Done(PRTLDRMODINTERNAL pMod)
406{
407 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
408 int rc = kLdrModMostlyDone(pModkLdr);
409 return rtkldrConvertError(rc);
410}
411
412
413/** @copydoc FNKLDRMODENUMSYMS */
414static int rtkldrEnumSymbolsWrapper(PKLDRMOD pMod, uint32_t iSymbol,
415 const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
416 KLDRADDR uValue, uint32_t fKind, void *pvUser)
417{
418 PRTLDRMODKLDRARGS pArgs = (PRTLDRMODKLDRARGS)pvUser;
419 NOREF(pMod); NOREF(pszVersion); NOREF(fKind);
420
421 /* If not zero terminated we'll have to use a temporary buffer. */
422 const char *pszSymbol = pchSymbol;
423 if (pchSymbol && pchSymbol[cchSymbol])
424 {
425 char *psz = (char *)alloca(cchSymbol + 1);
426 memcpy(psz, pchSymbol, cchSymbol);
427 psz[cchSymbol] = '\0';
428 pszSymbol = psz;
429 }
430
431#if defined(RT_OS_OS2) || defined(RT_OS_DARWIN)
432 /* skip the underscore prefix. */
433 if (*pszSymbol == '_')
434 pszSymbol++;
435#endif
436
437 int rc = pArgs->u.pfnEnumSyms(&pArgs->pMod->Core, pszSymbol, iSymbol, uValue, pArgs->pvUser);
438 if (RT_FAILURE(rc))
439 return rc; /* don't bother converting. */
440 return 0;
441}
442
443
444/** @copydoc RTLDROPS::pfnEnumSymbols */
445static DECLCALLBACK(int) rtkldr_EnumSymbols(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress,
446 PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
447{
448 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
449 RTLDRMODKLDRARGS Args;
450 Args.pvUser = pvUser;
451 Args.u.pfnEnumSyms = pfnCallback;
452 Args.pMod = (PRTLDRMODKLDR)pMod;
453 Args.pvBits = pvBits;
454 Args.rc = VINF_SUCCESS;
455 int rc = kLdrModEnumSymbols(pModkLdr, pvBits, BaseAddress,
456 fFlags & RTLDR_ENUM_SYMBOL_FLAGS_ALL ? KLDRMOD_ENUM_SYMS_FLAGS_ALL : 0,
457 rtkldrEnumSymbolsWrapper, &Args);
458 if (Args.rc != VINF_SUCCESS)
459 rc = Args.rc;
460 else
461 rc = rtkldrConvertError(rc);
462 return rc;
463}
464
465
466/** @copydoc RTLDROPS::pfnGetImageSize */
467static DECLCALLBACK(size_t) rtkldr_GetImageSize(PRTLDRMODINTERNAL pMod)
468{
469 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
470 return kLdrModSize(pModkLdr);
471}
472
473
474/** @copydoc FNKLDRMODGETIMPORT */
475static int rtkldrGetImportWrapper(PKLDRMOD pMod, uint32_t iImport, uint32_t iSymbol, const char *pchSymbol, KSIZE cchSymbol,
476 const char *pszVersion, PKLDRADDR puValue, uint32_t *pfKind, void *pvUser)
477{
478 PRTLDRMODKLDRARGS pArgs = (PRTLDRMODKLDRARGS)pvUser;
479 NOREF(pMod); NOREF(pszVersion); NOREF(pfKind);
480
481 /* If not zero terminated we'll have to use a temporary buffer. */
482 const char *pszSymbol = pchSymbol;
483 if (pchSymbol && pchSymbol[cchSymbol])
484 {
485 char *psz = (char *)alloca(cchSymbol + 1);
486 memcpy(psz, pchSymbol, cchSymbol);
487 psz[cchSymbol] = '\0';
488 pszSymbol = psz;
489 }
490
491#if defined(RT_OS_OS2) || defined(RT_OS_DARWIN)
492 /* skip the underscore prefix. */
493 if (*pszSymbol == '_')
494 pszSymbol++;
495#endif
496
497 /* get the import module name - TODO: cache this */
498 const char *pszModule = NULL;
499 if (iImport != NIL_KLDRMOD_IMPORT)
500 {
501 char *pszBuf = (char *)alloca(64);
502 int rc = kLdrModGetImport(pMod, pArgs->pvBits, iImport, pszBuf, 64);
503 if (rc)
504 return rc;
505 pszModule = pszBuf;
506 }
507
508 /* do the query */
509 RTUINTPTR Value;
510 int rc = pArgs->u.pfnGetImport(&pArgs->pMod->Core, pszModule, pszSymbol, pszSymbol ? ~0 : iSymbol, &Value, pArgs->pvUser);
511 if (RT_SUCCESS(rc))
512 {
513 *puValue = Value;
514 return 0;
515 }
516 return rtkldrConvertErrorFromIPRT(rc);
517}
518
519
520/** @copydoc RTLDROPS::pfnGetBits */
521static DECLCALLBACK(int) rtkldr_GetBits(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR BaseAddress,
522 PFNRTLDRIMPORT pfnGetImport, void *pvUser)
523{
524 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
525 RTLDRMODKLDRARGS Args;
526 Args.pvUser = pvUser;
527 Args.u.pfnGetImport = pfnGetImport;
528 Args.pMod = (PRTLDRMODKLDR)pMod;
529 Args.pvBits = pvBits;
530 Args.rc = VINF_SUCCESS;
531 int rc = kLdrModGetBits(pModkLdr, pvBits, BaseAddress, rtkldrGetImportWrapper, &Args);
532 if (Args.rc != VINF_SUCCESS)
533 rc = Args.rc;
534 else
535 rc = rtkldrConvertError(rc);
536 return rc;
537}
538
539
540/** @copydoc RTLDROPS::pfnRelocate */
541static DECLCALLBACK(int) rtkldr_Relocate(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR NewBaseAddress,
542 RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
543{
544 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
545 RTLDRMODKLDRARGS Args;
546 Args.pvUser = pvUser;
547 Args.u.pfnGetImport = pfnGetImport;
548 Args.pMod = (PRTLDRMODKLDR)pMod;
549 Args.pvBits = pvBits;
550 Args.rc = VINF_SUCCESS;
551 int rc = kLdrModRelocateBits(pModkLdr, pvBits, NewBaseAddress, OldBaseAddress, rtkldrGetImportWrapper, &Args);
552 if (Args.rc != VINF_SUCCESS)
553 rc = Args.rc;
554 else
555 rc = rtkldrConvertError(rc);
556 return rc;
557}
558
559
560/** @copydoc RTLDROPS::pfnGetSymbolEx */
561static DECLCALLBACK(int) rtkldr_GetSymbolEx(PRTLDRMODINTERNAL pMod, const void *pvBits, RTUINTPTR BaseAddress,
562 const char *pszSymbol, RTUINTPTR *pValue)
563{
564 PKLDRMOD pModkLdr = ((PRTLDRMODKLDR)pMod)->pMod;
565 KLDRADDR uValue;
566
567#if defined(RT_OS_OS2) || defined(RT_OS_DARWIN)
568 /*
569 * Add underscore prefix.
570 */
571 if (pszSymbol)
572 {
573 size_t cch = strlen(pszSymbol);
574 char *psz = (char *)alloca(cch + 2);
575 memcpy(psz + 1, pszSymbol, cch + 1);
576 *psz = '_';
577 pszSymbol = psz;
578 }
579#endif
580
581 int rc = kLdrModQuerySymbol(pModkLdr, pvBits, BaseAddress,
582 NIL_KLDRMOD_SYM_ORDINAL, pszSymbol, strlen(pszSymbol), NULL,
583 NULL, NULL, &uValue, NULL);
584 if (!rc)
585 {
586 *pValue = uValue;
587 return VINF_SUCCESS;
588 }
589 return rtkldrConvertError(rc);
590}
591
592
593/** @copydoc FNKLDRENUMDBG */
594static int rtkldrEnumDbgInfoWrapper(PKLDRMOD pMod, KU32 iDbgInfo, KLDRDBGINFOTYPE enmType, KI16 iMajorVer, KI16 iMinorVer,
595 const char *pszPartNm, KLDRFOFF offFile, KLDRADDR LinkAddress, KLDRSIZE cb,
596 const char *pszExtFile, void *pvUser)
597{
598 PRTLDRMODKLDRARGS pArgs = (PRTLDRMODKLDRARGS)pvUser;
599 NOREF(pMod);
600
601 RTLDRDBGINFOTYPE enmMyType;
602 switch (enmType)
603 {
604 case KLDRDBGINFOTYPE_UNKNOWN: enmMyType = RTLDRDBGINFOTYPE_UNKNOWN; break;
605 case KLDRDBGINFOTYPE_STABS: enmMyType = RTLDRDBGINFOTYPE_STABS; break;
606 case KLDRDBGINFOTYPE_DWARF: enmMyType = RTLDRDBGINFOTYPE_DWARF; break;
607 case KLDRDBGINFOTYPE_CODEVIEW: enmMyType = RTLDRDBGINFOTYPE_CODEVIEW; break;
608 case KLDRDBGINFOTYPE_WATCOM: enmMyType = RTLDRDBGINFOTYPE_WATCOM; break;
609 case KLDRDBGINFOTYPE_HLL: enmMyType = RTLDRDBGINFOTYPE_HLL; break;
610 default:
611 AssertFailed();
612 enmMyType = RTLDRDBGINFOTYPE_UNKNOWN;
613 break;
614 }
615
616 int rc = pArgs->u.pfnEnumDbgInfo(&pArgs->pMod->Core, iDbgInfo, enmMyType, iMajorVer, iMinorVer, pszPartNm,
617 offFile, LinkAddress, cb, pszExtFile, pArgs->pvUser);
618 if (RT_FAILURE(rc))
619 return rc; /* don't bother converting. */
620 return 0;
621}
622
623
624/** @copydoc RTLDROPS::pfnEnumDbgInfo */
625static DECLCALLBACK(int) rtkldr_EnumDbgInfo(PRTLDRMODINTERNAL pMod, const void *pvBits,
626 PFNRTLDRENUMDBG pfnCallback, void *pvUser)
627{
628 PRTLDRMODKLDR pThis = (PRTLDRMODKLDR)pMod;
629 RTLDRMODKLDRARGS Args;
630 Args.pvUser = pvUser;
631 Args.u.pfnEnumDbgInfo = pfnCallback;
632 Args.pvBits = pvBits;
633 Args.pMod = pThis;
634 Args.rc = VINF_SUCCESS;
635 int rc = kLdrModEnumDbgInfo(pThis->pMod, pvBits, rtkldrEnumDbgInfoWrapper, &Args);
636 if (Args.rc != VINF_SUCCESS)
637 rc = Args.rc;
638 return rc;
639}
640
641
642/** @copydoc RTLDROPS::pfnEnumSegments. */
643static DECLCALLBACK(int) rtkldr_EnumSegments(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
644{
645 PRTLDRMODKLDR pThis = (PRTLDRMODKLDR)pMod;
646 uint32_t const cSegments = pThis->pMod->cSegments;
647 PCKLDRSEG paSegments = &pThis->pMod->aSegments[0];
648
649 for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
650 {
651 RTLDRSEG Seg;
652
653 Seg.pchName = paSegments[iSeg].pchName;
654 Seg.cchName = paSegments[iSeg].cchName;
655 Seg.SelFlat = paSegments[iSeg].SelFlat;
656 Seg.Sel16bit = paSegments[iSeg].Sel16bit;
657 Seg.fFlags = paSegments[iSeg].fFlags;
658 AssertCompile(KLDRSEG_FLAG_16BIT == RTLDRSEG_FLAG_16BIT );
659 AssertCompile(KLDRSEG_FLAG_OS2_ALIAS16 == RTLDRSEG_FLAG_OS2_ALIAS16);
660 AssertCompile(KLDRSEG_FLAG_OS2_CONFORM == RTLDRSEG_FLAG_OS2_CONFORM);
661 AssertCompile(KLDRSEG_FLAG_OS2_IOPL == RTLDRSEG_FLAG_OS2_IOPL );
662
663 switch (paSegments[iSeg].enmProt)
664 {
665 default:
666 AssertMsgFailed(("%d\n", paSegments[iSeg].enmProt));
667 case KPROT_NOACCESS:
668 Seg.fProt = 0;
669 break;
670
671 case KPROT_READONLY: Seg.fProt = RTMEM_PROT_READ; break;
672 case KPROT_READWRITE: Seg.fProt = RTMEM_PROT_READ | RTMEM_PROT_WRITE; break;
673 case KPROT_WRITECOPY: Seg.fProt = RTMEM_PROT_WRITE; break;
674 case KPROT_EXECUTE: Seg.fProt = RTMEM_PROT_EXEC; break;
675 case KPROT_EXECUTE_READ: Seg.fProt = RTMEM_PROT_EXEC | RTMEM_PROT_READ; break;
676 case KPROT_EXECUTE_READWRITE: Seg.fProt = RTMEM_PROT_EXEC | RTMEM_PROT_READ | RTMEM_PROT_WRITE; break;
677 case KPROT_EXECUTE_WRITECOPY: Seg.fProt = RTMEM_PROT_EXEC | RTMEM_PROT_WRITE; break;
678 }
679 Seg.cb = paSegments[iSeg].cb;
680 Seg.Alignment = paSegments[iSeg].Alignment;
681 Seg.LinkAddress = paSegments[iSeg].LinkAddress;
682 Seg.offFile = paSegments[iSeg].offFile;
683 Seg.cbFile = paSegments[iSeg].cbFile;
684 Seg.RVA = paSegments[iSeg].RVA;
685 Seg.cbMapped = paSegments[iSeg].cbMapped;
686
687 int rc = pfnCallback(pMod, &Seg, pvUser);
688 if (rc != VINF_SUCCESS)
689 return rc;
690 }
691
692 return VINF_SUCCESS;
693}
694
695
696/** @copydoc RTLDROPS::pfnLinkAddressToSegOffset. */
697static DECLCALLBACK(int) rtkldr_LinkAddressToSegOffset(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress,
698 uint32_t *piSeg, PRTLDRADDR poffSeg)
699{
700 PRTLDRMODKLDR pThis = (PRTLDRMODKLDR)pMod;
701 uint32_t const cSegments = pThis->pMod->cSegments;
702 PCKLDRSEG paSegments = &pThis->pMod->aSegments[0];
703
704 for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
705 {
706 KLDRADDR offSeg = LinkAddress - paSegments[iSeg].LinkAddress;
707 if ( offSeg < paSegments[iSeg].cbMapped
708 || offSeg < paSegments[iSeg].cb)
709 {
710 *piSeg = iSeg;
711 *poffSeg = offSeg;
712 return VINF_SUCCESS;
713 }
714 }
715
716 return VERR_LDR_INVALID_LINK_ADDRESS;
717}
718
719
720/** @copydoc RTLDROPS::pfnLinkAddressToRva. */
721static DECLCALLBACK(int) rtkldr_LinkAddressToRva(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
722{
723 PRTLDRMODKLDR pThis = (PRTLDRMODKLDR)pMod;
724 uint32_t const cSegments = pThis->pMod->cSegments;
725 PCKLDRSEG paSegments = &pThis->pMod->aSegments[0];
726
727 for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
728 {
729 KLDRADDR offSeg = LinkAddress - paSegments[iSeg].LinkAddress;
730 if ( offSeg < paSegments[iSeg].cbMapped
731 || offSeg < paSegments[iSeg].cb)
732 {
733 *pRva = paSegments[iSeg].RVA + offSeg;
734 return VINF_SUCCESS;
735 }
736 }
737
738 return VERR_LDR_INVALID_RVA;
739}
740
741
742/** @copydoc RTLDROPS::pfnSegOffsetToRva. */
743static DECLCALLBACK(int) rtkldr_SegOffsetToRva(PRTLDRMODINTERNAL pMod, uint32_t iSeg, RTLDRADDR offSeg,
744 PRTLDRADDR pRva)
745{
746 PRTLDRMODKLDR pThis = (PRTLDRMODKLDR)pMod;
747
748 if (iSeg >= pThis->pMod->cSegments)
749 return VERR_LDR_INVALID_SEG_OFFSET;
750 PCKLDRSEG const pSegment = &pThis->pMod->aSegments[iSeg];
751
752 if ( offSeg > pSegment->cbMapped
753 && offSeg > pSegment->cb
754 && ( pSegment->cbFile < 0
755 || offSeg > (uint64_t)pSegment->cbFile))
756 return VERR_LDR_INVALID_SEG_OFFSET;
757
758 *pRva = pSegment->RVA + offSeg;
759 return VINF_SUCCESS;
760}
761
762
763/** @copydoc RTLDROPS::pfnRvaToSegOffset. */
764static DECLCALLBACK(int) rtkldr_RvaToSegOffset(PRTLDRMODINTERNAL pMod, RTLDRADDR Rva,
765 uint32_t *piSeg, PRTLDRADDR poffSeg)
766{
767 PRTLDRMODKLDR pThis = (PRTLDRMODKLDR)pMod;
768 uint32_t const cSegments = pThis->pMod->cSegments;
769 PCKLDRSEG paSegments = &pThis->pMod->aSegments[0];
770
771 for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
772 {
773 KLDRADDR offSeg = Rva - paSegments[iSeg].RVA;
774 if ( offSeg < paSegments[iSeg].cbMapped
775 || offSeg < paSegments[iSeg].cb)
776 {
777 *piSeg = iSeg;
778 *poffSeg = offSeg;
779 return VINF_SUCCESS;
780 }
781 }
782
783 return VERR_LDR_INVALID_RVA;
784}
785
786
787/**
788 * Operations for a kLdr module.
789 */
790static const RTLDROPS g_rtkldrOps =
791{
792 "kLdr",
793 rtkldr_Close,
794 NULL,
795 rtkldr_Done,
796 rtkldr_EnumSymbols,
797 /* ext */
798 rtkldr_GetImageSize,
799 rtkldr_GetBits,
800 rtkldr_Relocate,
801 rtkldr_GetSymbolEx,
802 rtkldr_EnumDbgInfo,
803 rtkldr_EnumSegments,
804 rtkldr_LinkAddressToSegOffset,
805 rtkldr_LinkAddressToRva,
806 rtkldr_SegOffsetToRva,
807 rtkldr_RvaToSegOffset,
808 42
809};
810
811
812/**
813 * Open a image using kLdr.
814 *
815 * @returns iprt status code.
816 * @param pReader The loader reader instance which will provide the raw image bits.
817 * @param fFlags Reserved, MBZ.
818 * @param enmArch CPU architecture specifier for the image to be loaded.
819 * @param phLdrMod Where to store the handle.
820 */
821int rtldrkLdrOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod)
822{
823 /* Convert enmArch to k-speak. */
824 KCPUARCH enmCpuArch;
825 switch (enmArch)
826 {
827 case RTLDRARCH_WHATEVER:
828 enmCpuArch = KCPUARCH_UNKNOWN;
829 break;
830 case RTLDRARCH_X86_32:
831 enmCpuArch = KCPUARCH_X86_32;
832 break;
833 case RTLDRARCH_AMD64:
834 enmCpuArch = KCPUARCH_AMD64;
835 break;
836 default:
837 return VERR_INVALID_PARAMETER;
838 }
839
840 /* Create a rtkldrRdr_ instance. */
841 PRTKLDRRDR pRdr = (PRTKLDRRDR)RTMemAllocZ(sizeof(*pRdr));
842 if (!pRdr)
843 return VERR_NO_MEMORY;
844 pRdr->Core.u32Magic = KRDR_MAGIC;
845 pRdr->Core.pOps = &g_kLdrRdrFileOps;
846 pRdr->pReader = pReader;
847
848 /* Try open it. */
849 PKLDRMOD pMod;
850 int krc = kLdrModOpenFromRdr(&pRdr->Core, fFlags, enmCpuArch, &pMod);
851 if (!krc)
852 {
853 /* Create a module wrapper for it. */
854 PRTLDRMODKLDR pNewMod = (PRTLDRMODKLDR)RTMemAllocZ(sizeof(*pNewMod));
855 if (pNewMod)
856 {
857 pNewMod->Core.u32Magic = RTLDRMOD_MAGIC;
858 pNewMod->Core.eState = LDR_STATE_OPENED;
859 pNewMod->Core.pOps = &g_rtkldrOps;
860 pNewMod->pMod = pMod;
861 *phLdrMod = &pNewMod->Core;
862
863#ifdef LOG_ENABLED
864 Log(("rtldrkLdrOpen: '%s' (%s) %u segments\n",
865 pMod->pszName, pMod->pszFilename, pMod->cSegments));
866 for (unsigned iSeg = 0; iSeg < pMod->cSegments; iSeg++)
867 {
868 Log(("Segment #%-2u: RVA=%08llx cb=%08llx '%.*s'\n", iSeg,
869 pMod->aSegments[iSeg].RVA,
870 pMod->aSegments[iSeg].cb,
871 pMod->aSegments[iSeg].cchName,
872 pMod->aSegments[iSeg].pchName));
873 }
874#endif
875 return VINF_SUCCESS;
876 }
877 kLdrModClose(pMod);
878 krc = KERR_NO_MEMORY;
879 }
880 return rtkldrConvertError(krc);
881}
882
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette