VirtualBox

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

Last change on this file since 28267 was 18454, checked in by vboxsync, 16 years ago

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