VirtualBox

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

Last change on this file since 7016 was 5999, checked in by vboxsync, 17 years ago

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