VirtualBox

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

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

whole bunch: avoid runtime.h, include individual headers indead.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.8 KB
Line 
1/* $Id: tstLdr.cpp 14831 2008-11-30 10:31:16Z 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
50/**
51 * Resolve an external symbol during RTLdrGetBits().
52 *
53 * @returns iprt status code.
54 * @param hLdrMod The loader module handle.
55 * @param pszModule Module name.
56 * @param pszSymbol Symbol name, NULL if uSymbol should be used.
57 * @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
58 * @param pValue Where to store the symbol value (address).
59 * @param pvUser User argument.
60 */
61static DECLCALLBACK(int) testGetImport(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol, unsigned uSymbol, RTUINTPTR *pValue, void *pvUser)
62{
63 /* check the name format and only permit certain names */
64 *pValue = 0xabcdef0f;
65 return VINF_SUCCESS;
66}
67
68
69/**
70 * One test iteration with one file.
71 *
72 * The test is very simple, we load the file three times
73 * into two different regions. The first two into each of the
74 * regions the for compare usage. The third is loaded into one
75 * and then relocated between the two and other locations a few times.
76 *
77 * @returns number of errors.
78 * @param pszFilename The file to load the mess with.
79 */
80static int testLdrOne(const char *pszFilename)
81{
82 int rcRet = 0;
83 size_t cbImage = 0;
84 struct Load
85 {
86 RTLDRMOD hLdrMod;
87 void *pvBits;
88 RTUINTPTR Addr;
89 const char *pszName;
90 } aLoads[6] =
91 {
92 { NULL, NULL, 0xefefef00, "foo" },
93 { NULL, NULL, 0x40404040, "bar" },
94 { NULL, NULL, 0xefefef00, "foobar" },
95 { NULL, NULL, 0xefefef00, "kLdr-foo" },
96 { NULL, NULL, 0x40404040, "kLdr-bar" },
97 { NULL, NULL, 0xefefef00, "kLdr-foobar" }
98 };
99 unsigned i;
100
101 /*
102 * Load them.
103 */
104 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
105 {
106 int rc;
107 if (!strncmp(aLoads[i].pszName, "kLdr-", sizeof("kLdr-") - 1))
108 rc = RTLdrOpenkLdr(pszFilename, &aLoads[i].hLdrMod);
109 else
110 rc = RTLdrOpen(pszFilename, &aLoads[i].hLdrMod);
111 if (RT_FAILURE(rc))
112 {
113 RTPrintf("tstLdr: Failed to open '%s'/%d, rc=%Rrc. aborting test.\n", pszFilename, i, rc);
114 Assert(aLoads[i].hLdrMod == NIL_RTLDRMOD);
115 rcRet++;
116 break;
117 }
118
119 /* size it */
120 size_t cb = RTLdrSize(aLoads[i].hLdrMod);
121 if (cbImage && cb != cbImage)
122 {
123 RTPrintf("tstLdr: Size mismatch '%s'/%d. aborting test.\n", pszFilename, i);
124 rcRet++;
125 break;
126 }
127 cbImage = cb;
128
129 /* Allocate bits. */
130 aLoads[i].pvBits = RTMemAlloc(cb);
131 if (!aLoads[i].pvBits)
132 {
133 RTPrintf("tstLdr: Out of memory '%s'/%d cbImage=%d. aborting test.\n", pszFilename, i, cbImage);
134 rcRet++;
135 break;
136 }
137
138 /* Get the bits. */
139 rc = RTLdrGetBits(aLoads[i].hLdrMod, aLoads[i].pvBits, aLoads[i].Addr, testGetImport, NULL);
140 if (RT_FAILURE(rc))
141 {
142 RTPrintf("tstLdr: Failed to get bits for '%s'/%d, rc=%Rrc. aborting test\n", pszFilename, i, rc);
143 rcRet++;
144 break;
145 }
146 }
147
148 /*
149 * Continue with the relocations and symbol resolving.
150 */
151 if (!rcRet)
152 {
153 static RTUINTPTR aRels[] =
154 {
155 0xefefef00, /* same. */
156 0x40404040, /* the other. */
157 0xefefef00, /* back. */
158 0x40404040, /* the other. */
159 0xefefef00, /* back again. */
160 0x77773420, /* somewhere entirely else. */
161 0xf0000000, /* somewhere entirely else. */
162 0x40404040, /* the other. */
163 0xefefef00 /* back again. */
164 };
165 struct Symbols
166 {
167 /** The symbol offset. -1 indicates the first time. */
168 unsigned off;
169 /** The symbol name. */
170 const char *pszName;
171 } aSyms[] =
172 {
173 { ~0, "Entrypoint" },
174 { ~0, "SomeExportFunction1" },
175 { ~0, "SomeExportFunction2" },
176 { ~0, "SomeExportFunction3" },
177 { ~0, "SomeExportFunction4" },
178 { ~0, "SomeExportFunction5" },
179 { ~0, "SomeExportFunction5" },
180 { ~0, "DISCoreOne" }
181 };
182
183 unsigned iRel = 0;
184 for (;;)
185 {
186 /* Compare all which are at the same address. */
187 for (i = 0; i < RT_ELEMENTS(aLoads) - 1; i++)
188 {
189 for (unsigned j = i + 1; j < RT_ELEMENTS(aLoads); j++)
190 {
191 if (aLoads[j].Addr == aLoads[i].Addr)
192 {
193 if (memcmp(aLoads[j].pvBits, aLoads[i].pvBits, cbImage))
194 {
195 RTPrintf("tstLdr: Mismatch between load %d and %d. ('%s')\n", j, i, pszFilename);
196 const uint8_t *pu8J = (const uint8_t *)aLoads[j].pvBits;
197 const uint8_t *pu8I = (const uint8_t *)aLoads[i].pvBits;
198 for (uint32_t off = 0; off < cbImage; off++, pu8J++, pu8I++)
199 if (*pu8J != *pu8I)
200 RTPrintf(" %08x %02x != %02x\n", off, *pu8J, *pu8I);
201 rcRet++;
202 }
203 }
204 }
205 }
206
207 /* compare symbols. */
208 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
209 {
210 for (unsigned iSym = 0; iSym < RT_ELEMENTS(aSyms); iSym++)
211 {
212 RTUINTPTR Value;
213 int rc = RTLdrGetSymbolEx(aLoads[i].hLdrMod, aLoads[i].pvBits, aLoads[i].Addr, aSyms[iSym].pszName, &Value);
214 if (RT_SUCCESS(rc))
215 {
216 unsigned off = Value - aLoads[i].Addr;
217 if (off < cbImage)
218 {
219 if (aSyms[iSym].off == ~0U)
220 aSyms[iSym].off = off;
221 else if (off != aSyms[iSym].off)
222 {
223 RTPrintf("tstLdr: Mismatching symbol '%s' in '%s'/%d. expected off=%d got %d\n",
224 aSyms[iSym].pszName, pszFilename, i, aSyms[iSym].off, off);
225 rcRet++;
226 }
227 }
228 else
229 {
230 RTPrintf("tstLdr: Invalid value for symbol '%s' in '%s'/%d. off=%#x Value=%#x\n",
231 aSyms[iSym].pszName, pszFilename, i, off, Value);
232 rcRet++;
233 }
234 }
235 else if (!g_fDontBitchOnResolveFailure)
236 {
237 RTPrintf("tstLdr: Failed to resolve symbol '%s' in '%s'/%d.\n", aSyms[iSym].pszName, pszFilename, i);
238 rcRet++;
239 }
240 }
241 }
242
243 if (iRel >= RT_ELEMENTS(aRels))
244 break;
245
246 /* relocate it stuff. */
247 int rc = RTLdrRelocate(aLoads[2].hLdrMod, aLoads[2].pvBits, aRels[iRel], aLoads[2].Addr, testGetImport, NULL);
248 if (RT_FAILURE(rc))
249 {
250 RTPrintf("tstLdr: Relocate of '%s' from %#x to %#x failed, rc=%Rrc. Aborting test.\n",
251 pszFilename, aRels[iRel], aLoads[2].Addr, rc);
252 rcRet++;
253 break;
254 }
255 aLoads[2].Addr = aRels[iRel];
256
257 /* next */
258 iRel++;
259 }
260 }
261
262 /*
263 * Clean up.
264 */
265 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
266 {
267 if (aLoads[i].pvBits)
268 RTMemFree(aLoads[i].pvBits);
269 if (aLoads[i].hLdrMod)
270 {
271 int rc = RTLdrClose(aLoads[i].hLdrMod);
272 if (RT_FAILURE(rc))
273 {
274 RTPrintf("tstLdr: Failed to close '%s' i=%d, rc=%Rrc.\n", pszFilename, i, rc);
275 rcRet++;
276 }
277 }
278 }
279
280 return rcRet;
281}
282
283
284
285int main(int argc, char **argv)
286{
287 RTR3Init();
288
289 int rcRet = 0;
290 if (argc <= 1)
291 {
292 RTPrintf("usage: %s <module> [more modules]\n", argv[0]);
293 return 1;
294 }
295
296 /*
297 * Iterate the files.
298 */
299 for (int argi = 1; argi < argc; argi++)
300 {
301 if (argv[argi][0] == '-' && argv[argi][1] == 'n')
302 g_fDontBitchOnResolveFailure = true;
303 else
304 {
305 RTPrintf("tstLdr: TESTING '%s'...\n", argv[argi]);
306 rcRet += testLdrOne(argv[argi]);
307 }
308 }
309
310 /*
311 * Test result summary.
312 */
313 if (!rcRet)
314 RTPrintf("tstLdr: SUCCESS\n");
315 else
316 RTPrintf("tstLdr: FAILURE - %d errors\n", rcRet);
317 return !!rcRet;
318}
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