VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstLdr-4.cpp@ 86715

Last change on this file since 86715 was 85541, checked in by vboxsync, 4 years ago

tstLdr-4: Check do some segment sanity checking so we'll catch bad cbMapped values next time. bugref:9801
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 13.5 KB
Line 
1/* $Id: tstLdr-4.cpp 85541 2020-07-30 09:05:37Z vboxsync $ */
2/** @file
3 * IPRT - Testcase for RTLdrOpen using ldrLdrObjR0.r0.
4 */
5
6/*
7 * Copyright (C) 2006-2020 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/log.h>
34#include <iprt/stream.h>
35#include <iprt/assert.h>
36#include <iprt/param.h>
37#include <iprt/path.h>
38#include <iprt/err.h>
39#include <iprt/string.h>
40#include <iprt/test.h>
41
42#include <VBox/sup.h>
43
44
45/*********************************************************************************************************************************
46* Global Variables *
47*********************************************************************************************************************************/
48static RTTEST g_hTest;
49static SUPGLOBALINFOPAGE g_MyGip = { SUPGLOBALINFOPAGE_MAGIC, SUPGLOBALINFOPAGE_VERSION, SUPGIPMODE_INVARIANT_TSC, 42 };
50static PSUPGLOBALINFOPAGE g_pMyGip = &g_MyGip;
51
52extern "C" DECLEXPORT(int) DisasmTest1(void);
53
54
55static DECLCALLBACK(int) testEnumSegment(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser)
56{
57 uint32_t *piSeg = (uint32_t *)pvUser;
58 RTPrintf(" Seg#%02u: %RTptr LB %RTptr %s\n"
59 " link=%RTptr LB %RTptr align=%RTptr fProt=%#x offFile=%RTfoff\n"
60 , *piSeg, pSeg->RVA, pSeg->cbMapped, pSeg->pszName,
61 pSeg->LinkAddress, pSeg->cb, pSeg->Alignment, pSeg->fProt, pSeg->offFile);
62
63 if (pSeg->RVA != NIL_RTLDRADDR)
64 {
65 RTTESTI_CHECK(pSeg->cbMapped != NIL_RTLDRADDR);
66 RTTESTI_CHECK(pSeg->cbMapped >= pSeg->cb);
67 }
68 else
69 {
70 RTTESTI_CHECK(pSeg->cbMapped == NIL_RTLDRADDR);
71 }
72
73 /*
74 * Do some address conversion tests:
75 */
76 if (pSeg->cbMapped != NIL_RTLDRADDR)
77 {
78 /* RTLdrRvaToSegOffset: */
79 uint32_t iSegConv = ~(uint32_t)42;
80 RTLDRADDR offSegConv = ~(RTLDRADDR)22;
81 int rc = RTLdrRvaToSegOffset(hLdrMod, pSeg->RVA, &iSegConv, &offSegConv);
82 if (RT_FAILURE(rc))
83 RTTestIFailed("RTLdrRvaToSegOffset failed on Seg #%u / RVA %#RTptr: %Rrc", *piSeg, pSeg->RVA, rc);
84 else if (iSegConv != *piSeg || offSegConv != 0)
85 RTTestIFailed("RTLdrRvaToSegOffset on Seg #%u / RVA %#RTptr returned: iSegConv=%#x offSegConv=%RTptr, expected %#x and 0",
86 *piSeg, pSeg->RVA, iSegConv, offSegConv, *piSeg);
87
88 /* RTLdrSegOffsetToRva: */
89 RTLDRADDR uRvaConv = ~(RTLDRADDR)22;
90 rc = RTLdrSegOffsetToRva(hLdrMod, *piSeg, 0, &uRvaConv);
91 if (RT_FAILURE(rc))
92 RTTestIFailed("RTLdrSegOffsetToRva failed on Seg #%u / off 0: %Rrc", *piSeg, rc);
93 else if (uRvaConv != pSeg->RVA)
94 RTTestIFailed("RTLdrSegOffsetToRva on Seg #%u / off 0 returned: %RTptr, expected %RTptr", *piSeg, uRvaConv, pSeg->RVA);
95
96 /* RTLdrLinkAddressToRva: */
97 uRvaConv = ~(RTLDRADDR)22;
98 rc = RTLdrLinkAddressToRva(hLdrMod, pSeg->LinkAddress, &uRvaConv);
99 if (RT_FAILURE(rc))
100 RTTestIFailed("RTLdrLinkAddressToRva failed on Seg #%u / %RTptr: %Rrc", *piSeg, pSeg->LinkAddress, rc);
101 else if (uRvaConv != pSeg->RVA)
102 RTTestIFailed("RTLdrLinkAddressToRva on Seg #%u / %RTptr returned: %RTptr, expected %RTptr",
103 *piSeg, pSeg->LinkAddress, uRvaConv, pSeg->RVA);
104
105 /* RTLdrLinkAddressToSegOffset: */
106 iSegConv = ~(uint32_t)42;
107 offSegConv = ~(RTLDRADDR)22;
108 rc = RTLdrLinkAddressToSegOffset(hLdrMod, pSeg->LinkAddress, &iSegConv, &offSegConv);
109 if (RT_FAILURE(rc))
110 RTTestIFailed("RTLdrLinkAddressToSegOffset failed on Seg #%u / %#RTptr: %Rrc", *piSeg, pSeg->LinkAddress, rc);
111 else if (iSegConv != *piSeg || offSegConv != 0)
112 RTTestIFailed("RTLdrLinkAddressToSegOffset on Seg #%u / %#RTptr returned: iSegConv=%#x offSegConv=%RTptr, expected %#x and 0",
113 *piSeg, pSeg->LinkAddress, iSegConv, offSegConv, *piSeg);
114 }
115
116 *piSeg += 1;
117 RT_NOREF(hLdrMod);
118 return VINF_SUCCESS;
119}
120
121
122/**
123 * Resolve an external symbol during RTLdrGetBits().
124 *
125 * @returns iprt status code.
126 * @param hLdrMod The loader module handle.
127 * @param pszModule Module name.
128 * @param pszSymbol Symbol name, NULL if uSymbol should be used.
129 * @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
130 * @param pValue Where to store the symbol value (address).
131 * @param pvUser User argument.
132 */
133static DECLCALLBACK(int) testGetImport(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol, unsigned uSymbol, RTUINTPTR *pValue, void *pvUser)
134{
135 RT_NOREF4(hLdrMod, pszModule, uSymbol, pvUser);
136 if ( !strcmp(pszSymbol, "RTAssertMsg1Weak") || !strcmp(pszSymbol, "_RTAssertMsg1Weak"))
137 *pValue = (uintptr_t)RTAssertMsg1Weak;
138 else if (!strcmp(pszSymbol, "RTAssertMsg2Weak") || !strcmp(pszSymbol, "_RTAssertMsg2Weak"))
139 *pValue = (uintptr_t)RTAssertMsg1Weak;
140 else if (!strcmp(pszSymbol, "RTAssertMsg1") || !strcmp(pszSymbol, "_RTAssertMsg1"))
141 *pValue = (uintptr_t)RTAssertMsg1;
142 else if (!strcmp(pszSymbol, "RTAssertMsg2") || !strcmp(pszSymbol, "_RTAssertMsg2"))
143 *pValue = (uintptr_t)RTAssertMsg2;
144 else if (!strcmp(pszSymbol, "RTAssertMsg2V") || !strcmp(pszSymbol, "_RTAssertMsg2V"))
145 *pValue = (uintptr_t)RTAssertMsg2V;
146 else if (!strcmp(pszSymbol, "RTAssertMayPanic") || !strcmp(pszSymbol, "_RTAssertMayPanic"))
147 *pValue = (uintptr_t)RTAssertMayPanic;
148 else if (!strcmp(pszSymbol, "RTLogDefaultInstanceEx") || !strcmp(pszSymbol, "RTLogDefaultInstanceEx"))
149 *pValue = (uintptr_t)RTLogDefaultInstanceEx;
150 else if (!strcmp(pszSymbol, "RTLogLoggerExV") || !strcmp(pszSymbol, "_RTLogLoggerExV"))
151 *pValue = (uintptr_t)RTLogLoggerExV;
152 else if (!strcmp(pszSymbol, "RTLogPrintfV") || !strcmp(pszSymbol, "_RTLogPrintfV"))
153 *pValue = (uintptr_t)RTLogPrintfV;
154 else if (!strcmp(pszSymbol, "RTR0AssertPanicSystem")|| !strcmp(pszSymbol, "_RTR0AssertPanicSystem"))
155 *pValue = (uintptr_t)0;
156 else if (!strcmp(pszSymbol, "MyPrintf") || !strcmp(pszSymbol, "_MyPrintf"))
157 *pValue = (uintptr_t)RTPrintf;
158 else if (!strcmp(pszSymbol, "SUPR0Printf") || !strcmp(pszSymbol, "_SUPR0Printf"))
159 *pValue = (uintptr_t)RTPrintf;
160 else if (!strcmp(pszSymbol, "SomeImportFunction") || !strcmp(pszSymbol, "_SomeImportFunction"))
161 *pValue = (uintptr_t)0;
162 else if (!strcmp(pszSymbol, "g_pSUPGlobalInfoPage") || !strcmp(pszSymbol, "_g_pSUPGlobalInfoPage"))
163 *pValue = (uintptr_t)&g_pMyGip;
164 else if (!strcmp(pszSymbol, "g_SUPGlobalInfoPage") || !strcmp(pszSymbol, "_g_SUPGlobalInfoPage"))
165 *pValue = (uintptr_t)&g_MyGip;
166 else
167 {
168 RTPrintf("tstLdr-4: Unexpected import '%s'!\n", pszSymbol);
169 return VERR_SYMBOL_NOT_FOUND;
170 }
171 return VINF_SUCCESS;
172}
173
174
175/**
176 * One test iteration with one file.
177 *
178 * The test is very simple, we load the file three times
179 * into two different regions. The first two into each of the
180 * regions the for compare usage. The third is loaded into one
181 * and then relocated between the two and other locations a few times.
182 *
183 * @param pszFilename The file to load the mess with.
184 */
185static void testLdrOne(const char *pszFilename)
186{
187 RTTestSub(g_hTest, RTPathFilename(pszFilename));
188
189 size_t cbImage = 0;
190 struct Load
191 {
192 RTLDRMOD hLdrMod;
193 void *pvBits;
194 size_t cbBits;
195 const char *pszName;
196 } aLoads[6] =
197 {
198 { NULL, NULL, 0, "foo" },
199 { NULL, NULL, 0, "bar" },
200 { NULL, NULL, 0, "foobar" },
201 };
202 unsigned i;
203 int rc;
204
205 /*
206 * Load them.
207 */
208 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
209 {
210 rc = RTLdrOpen(pszFilename, 0, RTLDRARCH_WHATEVER, &aLoads[i].hLdrMod);
211 if (RT_FAILURE(rc))
212 {
213 RTTestIFailed("tstLdr-4: Failed to open '%s'/%d, rc=%Rrc. aborting test.", pszFilename, i, rc);
214 Assert(aLoads[i].hLdrMod == NIL_RTLDRMOD);
215 break;
216 }
217
218 /* size it */
219 size_t cb = RTLdrSize(aLoads[i].hLdrMod);
220 if (cbImage && cb != cbImage)
221 {
222 RTTestIFailed("tstLdr-4: Size mismatch '%s'/%d. aborting test.", pszFilename, i);
223 break;
224 }
225 aLoads[i].cbBits = cbImage = cb;
226
227 /* Allocate bits. */
228 aLoads[i].pvBits = RTMemExecAlloc(cb);
229 if (!aLoads[i].pvBits)
230 {
231 RTTestIFailed("Out of memory '%s'/%d cbImage=%d. aborting test.", pszFilename, i, cbImage);
232 break;
233 }
234
235 /* Get the bits. */
236 rc = RTLdrGetBits(aLoads[i].hLdrMod, aLoads[i].pvBits, (uintptr_t)aLoads[i].pvBits, testGetImport, NULL);
237 if (RT_FAILURE(rc))
238 {
239 RTTestIFailed("Failed to get bits for '%s'/%d, rc=%Rrc. aborting test", pszFilename, i, rc);
240 break;
241 }
242 }
243
244 /*
245 * Execute the code.
246 */
247 if (!RTTestSubErrorCount(g_hTest))
248 {
249 for (i = 0; i < RT_ELEMENTS(aLoads); i += 1)
250 {
251 /* VERR_ELF_EXE_NOT_SUPPORTED in the previous loop? */
252 if (!aLoads[i].hLdrMod)
253 continue;
254 /* get the pointer. */
255 RTUINTPTR Value;
256 rc = RTLdrGetSymbolEx(aLoads[i].hLdrMod, aLoads[i].pvBits, (uintptr_t)aLoads[i].pvBits,
257 UINT32_MAX, "DisasmTest1", &Value);
258 if (rc == VERR_SYMBOL_NOT_FOUND)
259 rc = RTLdrGetSymbolEx(aLoads[i].hLdrMod, aLoads[i].pvBits, (uintptr_t)aLoads[i].pvBits,
260 UINT32_MAX, "_DisasmTest1", &Value);
261 if (RT_FAILURE(rc))
262 {
263 RTTestIFailed("Failed to get symbol \"DisasmTest1\" from load #%d: %Rrc", i, rc);
264 break;
265 }
266 typedef DECLCALLBACKPTR(int, PFNDISASMTEST1,(void));
267 PFNDISASMTEST1 pfnDisasmTest1 = (PFNDISASMTEST1)(uintptr_t)Value;
268 RTPrintf("tstLdr-4: pfnDisasmTest1=%p / add-symbol-file %s %#p\n", pfnDisasmTest1, pszFilename, aLoads[i].pvBits);
269 uint32_t iSeg = 0;
270 RTLdrEnumSegments(aLoads[i].hLdrMod, testEnumSegment, &iSeg);
271
272 /* call the test function. */
273 rc = pfnDisasmTest1();
274 if (rc)
275 RTTestIFailed("load #%d Test1 -> %#x", i, rc);
276
277 /* While we're here, check a couple of RTLdrQueryProp calls too */
278 void *pvBits = aLoads[i].pvBits;
279 for (unsigned iBits = 0; iBits < 2; iBits++, pvBits = NULL)
280 {
281 union
282 {
283 char szName[127];
284 } uBuf;
285 rc = RTLdrQueryPropEx(aLoads[i].hLdrMod, RTLDRPROP_INTERNAL_NAME, aLoads[i].pvBits,
286 uBuf.szName, sizeof(uBuf.szName), NULL);
287 if (RT_SUCCESS(rc))
288 RTPrintf("tstLdr-4: internal name #%d: '%s'\n", i, uBuf.szName);
289 else if (rc != VERR_NOT_FOUND && rc != VERR_NOT_SUPPORTED)
290 RTPrintf("tstLdr-4: internal name #%d failed: %Rrc\n", i, rc);
291 }
292 }
293 }
294
295 /*
296 * Clean up.
297 */
298 for (i = 0; i < RT_ELEMENTS(aLoads); i++)
299 {
300 if (aLoads[i].pvBits)
301 RTMemExecFree(aLoads[i].pvBits, aLoads[i].cbBits);
302 if (aLoads[i].hLdrMod)
303 {
304 rc = RTLdrClose(aLoads[i].hLdrMod);
305 if (RT_FAILURE(rc))
306 RTTestIFailed("Failed to close '%s' i=%d, rc=%Rrc.", pszFilename, i, rc);
307 }
308 }
309
310}
311
312
313
314int main()
315{
316 RTEXITCODE rcExit = RTTestInitAndCreate("tstLdr-4", &g_hTest);
317 if (rcExit != RTEXITCODE_SUCCESS)
318 return rcExit;
319
320 /*
321 * Sanity check.
322 */
323 int rc = DisasmTest1();
324 if (rc == 0)
325 {
326 /*
327 * Execute the test.
328 */
329 char szPath[RTPATH_MAX];
330 rc = RTPathExecDir(szPath, sizeof(szPath) - sizeof("/tstLdrObjR0.r0"));
331 if (RT_SUCCESS(rc))
332 {
333 strcat(szPath, "/tstLdrObjR0.r0");
334
335 testLdrOne(szPath);
336 }
337 else
338 RTTestIFailed("RTPathExecDir -> %Rrc", rc);
339 }
340 else
341 RTTestIFailed("FATAL ERROR - DisasmTest1 is buggy: rc=%#x", rc);
342
343 return RTTestSummaryAndDestroy(g_hTest);
344}
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