VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstLdr.cpp@ 38963

Last change on this file since 38963 was 38636, checked in by vboxsync, 13 years ago

*,IPRT: Redid the ring-3 init to always convert the arguments to UTF-8.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 12.3 KB
Line 
1/* $Id: tstLdr.cpp 38636 2011-09-05 13:49:45Z vboxsync $ */
2/** @file
3 * IPRT - Testcase for parts of RTLdr*.
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#include <iprt/ldr.h>
32#include <iprt/alloc.h>
33#include <iprt/stream.h>
34#include <iprt/assert.h>
35#include <iprt/initterm.h>
36#include <iprt/err.h>
37#include <iprt/string.h>
38
39
40/*******************************************************************************
41* Global Variables *
42*******************************************************************************/
43/** If set, don't bitch when failing to resolve symbols. */
44static bool g_fDontBitchOnResolveFailure = false;
45/** Whether it's kernel model code or not.. */
46static bool g_fKernel = true;
47/** Module architecture bit count. */
48static uint32_t g_cBits = HC_ARCH_BITS;
49
50
51/**
52 * Resolve an external symbol during RTLdrGetBits().
53 *
54 * @returns iprt status code.
55 * @param hLdrMod The loader module handle.
56 * @param pszModule Module name.
57 * @param pszSymbol Symbol name, NULL if uSymbol should be used.
58 * @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
59 * @param pValue Where to store the symbol value (address).
60 * @param pvUser User argument.
61 */
62static DECLCALLBACK(int) testGetImport(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol, unsigned uSymbol, RTUINTPTR *pValue, void *pvUser)
63{
64 /* check the name format and only permit certain names... later, right? */
65
66 if (g_cBits == 32)
67 *pValue = 0xabcdef0f;
68 else
69 {
70 RTUINTPTR BaseAddr = *(PCRTUINTPTR)pvUser;
71 if (g_fKernel)
72 *pValue = BaseAddr & RT_BIT(31) ? -(int32_t)0x76634935 : 0x7f304938;
73 else
74 *pValue = (int32_t)0x76634935 * ((BaseAddr >> 8) & 7);
75 }
76 return VINF_SUCCESS;
77}
78
79
80/**
81 * One test iteration with one file.
82 *
83 * The test is very simple, we load the file three times
84 * into two different regions. The first two into each of the
85 * regions the for compare usage. The third is loaded into one
86 * and then relocated between the two and other locations a few times.
87 *
88 * @returns number of errors.
89 * @param pszFilename The file to load the mess with.
90 */
91static int testLdrOne(const char *pszFilename)
92{
93 int rcRet = 0;
94 size_t cbImage = 0;
95 struct Load
96 {
97 RTLDRMOD hLdrMod;
98 void *pvBits;
99 RTUINTPTR Addr;
100 const char *pszName;
101 } aLoads[6] =
102 {
103 { NULL, NULL, (int32_t)0xefefef00, "foo" },
104 { NULL, NULL, (int32_t)0x40404040, "bar" },
105 { NULL, NULL, (int32_t)0xefefef00, "foobar" },
106 { NULL, NULL, (int32_t)0xefefef00, "kLdr-foo" },
107 { NULL, NULL, (int32_t)0x40404040, "kLdr-bar" },
108 { NULL, NULL, (int32_t)0xefefef00, "kLdr-foobar" }
109 };
110 unsigned i;
111
112 /*
113 * Load them.
114 */
115 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
116 {
117 /* adjust load address and announce our intentions */
118 if (g_cBits == 32)
119 aLoads[i].Addr &= UINT32_C(0xffffffff);
120 RTPrintf("tstLdr: Loading image at %RTptr\n", aLoads[i].Addr);
121
122 /* open it */
123 int rc;
124 if (!strncmp(aLoads[i].pszName, "kLdr-", sizeof("kLdr-") - 1))
125 rc = RTLdrOpenkLdr(pszFilename, 0, RTLDRARCH_WHATEVER, &aLoads[i].hLdrMod);
126 else
127 rc = RTLdrOpen(pszFilename, 0, RTLDRARCH_WHATEVER, &aLoads[i].hLdrMod);
128 if (RT_FAILURE(rc))
129 {
130 RTPrintf("tstLdr: Failed to open '%s'/%d, rc=%Rrc. aborting test.\n", pszFilename, i, rc);
131 Assert(aLoads[i].hLdrMod == NIL_RTLDRMOD);
132 rcRet++;
133 break;
134 }
135
136 /* size it */
137 size_t cb = RTLdrSize(aLoads[i].hLdrMod);
138 if (cbImage && cb != cbImage)
139 {
140 RTPrintf("tstLdr: Size mismatch '%s'/%d. aborting test.\n", pszFilename, i);
141 rcRet++;
142 break;
143 }
144 cbImage = cb;
145
146 /* Allocate bits. */
147 aLoads[i].pvBits = RTMemAlloc(cb);
148 if (!aLoads[i].pvBits)
149 {
150 RTPrintf("tstLdr: Out of memory '%s'/%d cbImage=%d. aborting test.\n", pszFilename, i, cbImage);
151 rcRet++;
152 break;
153 }
154
155 /* Get the bits. */
156 rc = RTLdrGetBits(aLoads[i].hLdrMod, aLoads[i].pvBits, aLoads[i].Addr, testGetImport, &aLoads[i].Addr);
157 if (RT_FAILURE(rc))
158 {
159 RTPrintf("tstLdr: Failed to get bits for '%s'/%d, rc=%Rrc. aborting test\n", pszFilename, i, rc);
160 rcRet++;
161 break;
162 }
163 }
164
165 /*
166 * Continue with the relocations and symbol resolving.
167 */
168 if (!rcRet)
169 {
170 static RTUINTPTR aRels[] =
171 {
172 (int32_t)0xefefef00, /* same. */
173 (int32_t)0x40404040, /* the other. */
174 (int32_t)0xefefef00, /* back. */
175 (int32_t)0x40404040, /* the other. */
176 (int32_t)0xefefef00, /* back again. */
177 (int32_t)0x77773420, /* somewhere entirely else. */
178 (int32_t)0xf0000000, /* somewhere entirely else. */
179 (int32_t)0x40404040, /* the other. */
180 (int32_t)0xefefef00 /* back again. */
181 };
182 struct Symbols
183 {
184 /** The symbol offset. -1 indicates the first time. */
185 unsigned off;
186 /** The symbol name. */
187 const char *pszName;
188 } aSyms[] =
189 {
190 { ~0, "Entrypoint" },
191 { ~0, "SomeExportFunction1" },
192 { ~0, "SomeExportFunction2" },
193 { ~0, "SomeExportFunction3" },
194 { ~0, "SomeExportFunction4" },
195 { ~0, "SomeExportFunction5" },
196 { ~0, "SomeExportFunction5" },
197 { ~0, "DISCoreOne" }
198 };
199
200 unsigned iRel = 0;
201 for (;;)
202 {
203 /* adjust load address and announce our intentions */
204 if (g_cBits == 32)
205 aRels[iRel] &= UINT32_C(0xffffffff);
206
207 /* Compare all which are at the same address. */
208 for (i = 0; i < RT_ELEMENTS(aLoads) - 1; i++)
209 {
210 for (unsigned j = i + 1; j < RT_ELEMENTS(aLoads); j++)
211 {
212 if (aLoads[j].Addr == aLoads[i].Addr)
213 {
214 if (memcmp(aLoads[j].pvBits, aLoads[i].pvBits, cbImage))
215 {
216 RTPrintf("tstLdr: Mismatch between load %d and %d. ('%s')\n", j, i, pszFilename);
217#if 1
218 const uint8_t *pu8J = (const uint8_t *)aLoads[j].pvBits;
219 const uint8_t *pu8I = (const uint8_t *)aLoads[i].pvBits;
220 for (uint32_t off = 0; off < cbImage; off++, pu8J++, pu8I++)
221 if (*pu8J != *pu8I)
222 RTPrintf(" %08x %02x != %02x\n", off, *pu8J, *pu8I);
223#else
224 const uint32_t *pu32J = (const uint32_t *)aLoads[j].pvBits;
225 const uint32_t *pu32I = (const uint32_t *)aLoads[i].pvBits;
226 for (uint32_t off = 0; off < cbImage; off += 4, pu32J++, pu32I++)
227 if (*pu32J != *pu32I)
228 RTPrintf(" %08x %08x != %08x\n", off, *pu32J, *pu32I);
229#endif
230 rcRet++;
231 break;
232 }
233 }
234 }
235 }
236
237 /* compare symbols. */
238 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
239 {
240 for (unsigned iSym = 0; iSym < RT_ELEMENTS(aSyms); iSym++)
241 {
242 RTUINTPTR Value;
243 int rc = RTLdrGetSymbolEx(aLoads[i].hLdrMod, aLoads[i].pvBits, aLoads[i].Addr, aSyms[iSym].pszName, &Value);
244 if (RT_SUCCESS(rc))
245 {
246 unsigned off = Value - aLoads[i].Addr;
247 if (off < cbImage)
248 {
249 if (aSyms[iSym].off == ~0U)
250 aSyms[iSym].off = off;
251 else if (off != aSyms[iSym].off)
252 {
253 RTPrintf("tstLdr: Mismatching symbol '%s' in '%s'/%d. expected off=%d got %d\n",
254 aSyms[iSym].pszName, pszFilename, i, aSyms[iSym].off, off);
255 rcRet++;
256 }
257 }
258 else
259 {
260 RTPrintf("tstLdr: Invalid value for symbol '%s' in '%s'/%d. off=%#x Value=%#x\n",
261 aSyms[iSym].pszName, pszFilename, i, off, Value);
262 rcRet++;
263 }
264 }
265 else if (!g_fDontBitchOnResolveFailure)
266 {
267 RTPrintf("tstLdr: Failed to resolve symbol '%s' in '%s'/%d.\n", aSyms[iSym].pszName, pszFilename, i);
268 rcRet++;
269 }
270 }
271 }
272
273 if (iRel >= RT_ELEMENTS(aRels))
274 break;
275
276 /* relocate it stuff. */
277 RTPrintf("tstLdr: Relocating image 2 from %RTptr to %RTptr\n", aLoads[2].Addr, aRels[iRel]);
278 int rc = RTLdrRelocate(aLoads[2].hLdrMod, aLoads[2].pvBits, aRels[iRel], aLoads[2].Addr, testGetImport, &aRels[iRel]);
279 if (RT_FAILURE(rc))
280 {
281 RTPrintf("tstLdr: Relocate of '%s' from %#x to %#x failed, rc=%Rrc. Aborting test.\n",
282 pszFilename, aRels[iRel], aLoads[2].Addr, rc);
283 rcRet++;
284 break;
285 }
286 aLoads[2].Addr = aRels[iRel];
287
288 /* next */
289 iRel++;
290 }
291 }
292
293 /*
294 * Clean up.
295 */
296 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
297 {
298 if (aLoads[i].pvBits)
299 RTMemFree(aLoads[i].pvBits);
300 if (aLoads[i].hLdrMod)
301 {
302 int rc = RTLdrClose(aLoads[i].hLdrMod);
303 if (RT_FAILURE(rc))
304 {
305 RTPrintf("tstLdr: Failed to close '%s' i=%d, rc=%Rrc.\n", pszFilename, i, rc);
306 rcRet++;
307 }
308 }
309 }
310
311 return rcRet;
312}
313
314
315
316int main(int argc, char **argv)
317{
318 RTR3InitExe(argc, &argv, 0);
319
320 int rcRet = 0;
321 if (argc <= 1)
322 {
323 RTPrintf("usage: %s [-32|-64] [-kernel] <module> [more options/modules]\n", argv[0]);
324 return 1;
325 }
326
327 /*
328 * Iterate the files.
329 */
330 for (int argi = 1; argi < argc; argi++)
331 {
332 if (!strcmp(argv[argi], "-n"))
333 g_fDontBitchOnResolveFailure = true;
334 else if (!strcmp(argv[argi], "-32"))
335 g_cBits = 32;
336 else if (!strcmp(argv[argi], "-64"))
337 g_cBits = 64;
338 else if (!strcmp(argv[argi], "-kernel"))
339 g_fKernel = true;
340 else
341 {
342 RTPrintf("tstLdr: TESTING '%s'...\n", argv[argi]);
343 rcRet += testLdrOne(argv[argi]);
344 }
345 }
346
347 /*
348 * Test result summary.
349 */
350 if (!rcRet)
351 RTPrintf("tstLdr: SUCCESS\n");
352 else
353 RTPrintf("tstLdr: FAILURE - %d errors\n", rcRet);
354 return !!rcRet;
355}
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