tstDevice.cpp@ 105381

Last change on this file since 105381 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.7 KB

Line
1	/* $Id: tstDevice.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* tstDevice - Test framework for PDM devices/drivers
4	*/
5
6	/*
7	* Copyright (C) 2017-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
33	#include <VBox/types.h>
34	#include <VBox/sup.h>
35	#include <VBox/version.h>
36	#include <iprt/assert.h>
37	#include <iprt/ctype.h>
38	#include <iprt/getopt.h>
39	#include <iprt/initterm.h>
40	#include <iprt/ldr.h>
41	#include <iprt/log.h>
42	#include <iprt/list.h>
43	#include <iprt/mem.h>
44	#include <iprt/once.h>
45	#include <iprt/path.h>
46	#include <iprt/string.h>
47	#include <iprt/stream.h>
48	#include <iprt/trace.h>
49
50	#include "tstDeviceInternal.h"
51	#include "tstDeviceCfg.h"
52	#include "tstDeviceBuiltin.h"
53
54
55	/*********************************************************************************************************************************
56	* Defined Constants And Macros *
57	*********************************************************************************************************************************/
58
59	#define PDM_MAX_DEVICE_INSTANCE_SIZE _4M
60
61
62	/*********************************************************************************************************************************
63	* Structures and Typedefs *
64	*********************************************************************************************************************************/
65
66
67	/**
68	* Testcase plugin descriptor.
69	*/
70	typedef struct TSTDEVPLUGIN
71	{
72	/** Node for the plugin list. */
73	RTLISTNODE NdPlugins;
74	/** Copy of the filename. */
75	char *pszFilename;
76	/** Loader handle. */
77	RTLDRMOD hMod;
78	/** Number of references to this plugin. */
79	volatile uint32_t cRefs;
80	} TSTDEVPLUGIN;
81	/** Pointer to a device plugin descriptor. */
82	typedef TSTDEVPLUGIN *PTSTDEVPLUGIN;
83	/** Pointer to a const plugin descriptor. */
84	typedef const TSTDEVPLUGIN *PCTSTDEVPLUGIN;
85
86
87	/**
88	* Testcase descriptor.
89	*/
90	typedef struct TSTDEVTESTCASE
91	{
92	/** Node for the list of registered testcases. */
93	RTLISTNODE NdTestcases;
94	/** Pointer to the plugin the testcase belongs to. */
95	PCTSTDEVPLUGIN pPlugin;
96	/** Pointer to the testcase descriptor. */
97	PCTSTDEVTESTCASEREG pTestcaseReg;
98	} TSTDEVTESTCASE;
99	/** Pointer to a testcase descriptor. */
100	typedef TSTDEVTESTCASE *PTSTDEVTESTCASE;
101	/** Pointer to a constant testcase descriptor. */
102	typedef const TSTDEVTESTCASE *PCTSTDEVTESTCASE;
103
104
105	/**
106	* PDM R0/RC module trampoline descriptor.
107	*/
108	#pragma pack(1)
109	typedef struct TSTDEVPDMMODTRAMPOLINE
110	{
111	/** Jump instruction. */
112	uint8_t abJmp[6];
113	/** Address to jump to. */
114	uintptr_t AddrTarget;
115	/** Padding to get a 16byte aligned structure. */
116	uint8_t abPadding[HC_ARCH_BITS == 64 ? 2 : 5];
117	} TSTDEVPDMMODTRAMPOLINE;
118	#pragma pack()
119	AssertCompileSize(TSTDEVPDMMODTRAMPOLINE, 16);
120	/** Pointer to a trampoline descriptor. */
121	typedef TSTDEVPDMMODTRAMPOLINE *PTSTDEVPDMMODTRAMPOLINE;
122
123	/**
124	* PDM module descriptor.
125	*/
126	typedef struct TSTDEVPDMMOD
127	{
128	/** Node for the module list. */
129	RTLISTNODE NdPdmMods;
130	/** Type of module (R3/R0/RC). */
131	TSTDEVPDMMODTYPE enmType;
132	/** Copy of the filename. */
133	char *pszFilename;
134	/** Loader handle. */
135	RTLDRMOD hLdrMod;
136	/** Number of references to this plugin. */
137	volatile uint32_t cRefs;
138	/** R0/RC Module type dependent data. */
139	struct
140	{
141	/** The exectuable image bits. */
142	void *pvBits;
143	/** Size of the memory buffer. */
144	size_t cbBits;
145	/** Pointer to the executable memory containing the trampoline code. */
146	uint8_t *pbTrampoline;
147	/** Number of trampoline entries supported. */
148	uint32_t cTrampolinesMax;
149	/** Number of trampoline entries used. */
150	uint32_t cTrampolines;
151	/** Pointer to the next unused trampoline entry. */
152	PTSTDEVPDMMODTRAMPOLINE pTrampolineNext;
153	} R0Rc;
154	} TSTDEVPDMMOD;
155	/** Pointer to a PDM module descriptor. */
156	typedef TSTDEVPDMMOD *PTSTDEVPDMMOD;
157
158
159	/**
160	* Internal callback structure pointer.
161	* The main purpose is to define the extra data we associate
162	* with PDMDEVREGCB so we can find the plugin the device is associated with etc.
163	*/
164	typedef struct TSTDEVPDMDEVREGCBINT
165	{
166	/** The callback structure. */
167	PDMDEVREGCB Core;
168	/** A bit of padding. */
169	uint32_t u32[4];
170	/** Pointer to plugin. */
171	PTSTDEVPDMMOD pMod;
172	} TSTDEVPDMDEVREGCBINT;
173	/** Pointer to a PDMDEVREGCBINT structure. */
174	typedef TSTDEVPDMDEVREGCBINT *PTSTDEVPDMDEVREGCBINT;
175	/** Pointer to a const PDMDEVREGCBINT structure. */
176	typedef const TSTDEVPDMDEVREGCBINT *PCTSTDEVPDMDEVREGCBINT;
177
178
179	typedef struct TSTDEVPDMR0IMPORTS
180	{
181	/** The symbol name. */
182	const char *pszSymbol;
183	/** The pointer. */
184	PFNRT pfn;
185	} TSTDEVPDMR0IMPORTS;
186	typedef const TSTDEVPDMR0IMPORTS *PCTSTDEVPDMR0IMPORTS;
187
188	typedef DECLCALLBACKTYPE(int, FNR0MODULEINIT,(void *hMod));
189	typedef FNR0MODULEINIT *PFNR0MODULEINIT;
190
191
192	/*********************************************************************************************************************************
193	* Global Variables *
194	*********************************************************************************************************************************/
195	/** List of registered testcase plugins. */
196	RTLISTANCHOR g_LstPlugins;
197	/** List of registered testcases. */
198	RTLISTANCHOR g_LstTestcases;
199	/** List of registered PDM modules. */
200	RTLISTANCHOR g_LstPdmMods;
201	/** List of registered PDM R0 modules. */
202	RTLISTANCHOR g_LstPdmR0Mods;
203	/** List of registered PDM devices. */
204	RTLISTANCHOR g_LstPdmDevs;
205
206	static int tstDevPdmR0RegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg);
207
208	/**
209	* PDM R0 imports we implement.
210	*/
211	static const TSTDEVPDMR0IMPORTS g_aPdmR0Imports[] =
212	{
213	{"SUPR0TracerFireProbe", (PFNRT)NULL},
214	{"SUPSemEventSignal", (PFNRT)NULL},
215	{"PDMR0DeviceRegisterModule", (PFNRT)tstDevPdmR0RegisterModule},
216	{"PDMR0DeviceDeregisterModule", (PFNRT)NULL},
217	{"PGMShwMakePageWritable", (PFNRT)NULL},
218	{"IntNetR0IfSend", (PFNRT)/IntNetR0IfSend/NULL},
219	{"IntNetR0IfSetPromiscuousMode", (PFNRT)/IntNetR0IfSetPromiscuousMode/NULL},
220	{"RTAssertMsg1Weak", (PFNRT)RTAssertMsg1Weak},
221	{"RTAssertMsg2Weak", (PFNRT)RTAssertMsg2Weak},
222	{"RTAssertShouldPanic", (PFNRT)RTAssertShouldPanic},
223	{"RTLogDefaultInstanceEx", (PFNRT)RTLogDefaultInstanceEx},
224	{"RTLogLoggerEx", (PFNRT)RTLogLoggerEx},
225	{"RTLogRelGetDefaultInstanceEx", (PFNRT)RTLogRelGetDefaultInstanceEx},
226	{"RTOnceSlow", (PFNRT)RTOnceSlow},
227	{"RTR0AssertPanicSystem", (PFNRT)0x10101010},
228	{"RTThreadSleep", (PFNRT)RTThreadSleep},
229	{"RTTimeMilliTS", (PFNRT)RTTimeMilliTS},
230	{"RTTimeNanoTS", (PFNRT)RTTimeNanoTS},
231	{"RTTraceBufAddMsgF", (PFNRT)RTTraceBufAddMsgF},
232	{"RTMemAllocZTag", (PFNRT)RTMemAllocZTag},
233	{"RTMemFree", (PFNRT)RTMemFree},
234	{"RTStrPrintf", (PFNRT)RTStrPrintf},
235	{"nocrt_memcmp", (PFNRT)memcmp},
236	{"nocrt_memcpy", (PFNRT)memcpy},
237	{"nocrt_memmove", (PFNRT)memmove},
238	{"nocrt_memset", (PFNRT)memset},
239	{"nocrt_strlen", (PFNRT)strlen},
240	};
241
242
243	/*********************************************************************************************************************************
244	* Internal Functions *
245	*********************************************************************************************************************************/
246
247	#if 0
248	/**
249	* Parses the options given to the testcase.
250	*
251	* @returns Process status code.
252	* @param cArgs Number of arguments given.
253	* @param paszArgs Pointer to the argument vector.
254	*/
255	static RTEXITCODE tstDevParseOptions(int cArgs, char *paszArgs[])
256	{
257	static RTGETOPTDEF const s_aOptions[] =
258	{
259	};
260
261
262	int ch;
263	RTGETOPTUNION Value;
264	RTGETOPTSTATE GetState;
265	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
266	while ((ch = RTGetOpt(&GetState, &Value)))
267	{
268	switch (ch)
269	{
270	default:
271	return RTGetOptPrintError(ch, &Value);
272	}
273	}
274	}
275	#endif
276
277
278	/**
279	* Checks whether the given testcase name is already existing.
280	*
281	* @returns Pointer to existing testcase, NULL if not found.
282	* @param pszFilename The filename to check.
283	*/
284	static PCTSTDEVTESTCASE tstDevTestcaseFind(const char *pszName)
285	{
286	PCTSTDEVTESTCASE pIt;
287	RTListForEach(&g_LstTestcases, pIt, TSTDEVTESTCASE, NdTestcases)
288	{
289	if (!RTStrCmp(pIt->pTestcaseReg->szName, pszName))
290	return pIt;
291	}
292
293	return NULL;
294	}
295
296
297	/**
298	* @interface_method_impl{TSTDEVPLUGINREGISTER,pfnRegisterTestcase}
299	*/
300	static DECLCALLBACK(int) tstDevRegisterTestcase(void *pvUser, PCTSTDEVTESTCASEREG pTestcaseReg)
301	{
302	int rc = VINF_SUCCESS;
303	PTSTDEVPLUGIN pPlugin = (PTSTDEVPLUGIN)pvUser;
304
305	/* Try to find a testcase with the name first. */
306	if (!tstDevTestcaseFind(pTestcaseReg->szName))
307	{
308	PTSTDEVTESTCASE pTestcase = (PTSTDEVTESTCASE)RTMemAllocZ(sizeof(TSTDEVPLUGIN));
309	if (RT_LIKELY(pTestcase))
310	{
311	pTestcase->pPlugin = pPlugin;
312	if (pPlugin)
313	pPlugin->cRefs++;
314	pTestcase->pTestcaseReg = pTestcaseReg;
315	RTListAppend(&g_LstTestcases, &pTestcase->NdTestcases);
316	return VINF_SUCCESS;
317	}
318	else
319	rc = VERR_NO_MEMORY;
320	}
321	else
322	rc = VERR_ALREADY_EXISTS;
323
324	return rc;
325	}
326
327
328	/**
329	* Checks whether the given plugin filename was already loaded.
330	*
331	* @returns Pointer to already loaded plugin, NULL if not found.
332	* @param pszFilename The filename to check.
333	*/
334	static PCTSTDEVPLUGIN tstDevPluginFind(const char *pszFilename)
335	{
336	PCTSTDEVPLUGIN pIt;
337	RTListForEach(&g_LstPlugins, pIt, TSTDEVPLUGIN, NdPlugins)
338	{
339	if (!RTStrCmp(pIt->pszFilename, pszFilename))
340	return pIt;
341	}
342
343	return NULL;
344	}
345
346
347	/**
348	* Tries to loads the given plugin.
349	*
350	* @returns VBox status code.
351	* @param pszFilename The filename to load.
352	*/
353	static int tstDevLoadPlugin(const char *pszFilename)
354	{
355	int rc = VINF_SUCCESS;
356
357	/* Check whether the plugin is loaded first. */
358	if (!tstDevPluginFind(pszFilename))
359	{
360	PTSTDEVPLUGIN pPlugin = (PTSTDEVPLUGIN)RTMemAllocZ(sizeof(TSTDEVPLUGIN));
361	if (RT_LIKELY(pPlugin))
362	{
363	pPlugin->pszFilename = RTStrDup(pszFilename);
364	pPlugin->cRefs = 1;
365	rc = RTLdrLoad(pszFilename, &pPlugin->hMod);
366	if (RT_SUCCESS(rc))
367	{
368	TSTDEVPLUGINREGISTER TestcaseRegister;
369	PFNTSTDEVPLUGINLOAD pfnPluginLoad = NULL;
370
371	TestcaseRegister.pfnRegisterTestcase = tstDevRegisterTestcase;
372
373	rc = RTLdrGetSymbol(pPlugin->hMod, TSTDEV_PLUGIN_LOAD_NAME, (void**)&pfnPluginLoad);
374	if (RT_FAILURE(rc) \|\| !pfnPluginLoad)
375	{
376	LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnPluginLoad=%#p\n",
377	TSTDEV_PLUGIN_LOAD_NAME, pszFilename, rc, pfnPluginLoad));
378	if (RT_SUCCESS(rc))
379	rc = VERR_SYMBOL_NOT_FOUND;
380	}
381
382	if (RT_SUCCESS(rc))
383	{
384	/* Get the function table. */
385	rc = pfnPluginLoad(pPlugin, &TestcaseRegister);
386	}
387	else
388	LogFunc(("ignored plugin '%s': rc=%Rrc\n", pszFilename, rc));
389
390	/* Create a plugin entry on success. */
391	if (RT_SUCCESS(rc))
392	{
393	RTListAppend(&g_LstPlugins, &pPlugin->NdPlugins);
394	return VINF_SUCCESS;
395	}
396	else
397	RTLdrClose(pPlugin->hMod);
398	}
399
400	RTMemFree(pPlugin);
401	}
402	else
403	rc = VERR_NO_MEMORY;
404	}
405
406	return rc;
407	}
408
409
410	/**
411	* Checks whether the given testcase name is already existing.
412	*
413	* @returns Pointer to already loaded plugin, NULL if not found.
414	* @param pszFilename The filename to check.
415	* @param ppR0Reg Where to store the pointer to the R0 registration record
416	* if existing, optional.
417	*/
418	DECLHIDDEN(PCTSTDEVPDMDEV) tstDevPdmDeviceFind(const char pszName, PCPDMDEVREGR0 ppR0Reg)
419	{
420	PCTSTDEVPDMDEV pIt;
421	RTListForEach(&g_LstPdmDevs, pIt, TSTDEVPDMDEV, NdPdmDevs)
422	{
423	if (!RTStrCmp(pIt->pReg->szName, pszName))
424	{
425	if (ppR0Reg)
426	{
427	*ppR0Reg = NULL;
428
429	PPDMDEVMODREGR0 pItR0;
430	RTListForEach(&g_LstPdmR0Mods, pItR0, PDMDEVMODREGR0, ListEntry)
431	{
432	for (uint32_t i = 0; i < pItR0->cDevRegs; i++)
433	{
434	PCPDMDEVREGR0 pReg = pItR0->papDevRegs[i];
435	if (!RTStrCmp(pReg->szName, pszName))
436	{
437	*ppR0Reg = pReg;
438	return pIt;
439	}
440	}
441	}
442	}
443
444	return pIt;
445	}
446	}
447
448	return NULL;
449	}
450
451
452	/**
453	* Checks that a PDMDRVREG::szName, PDMDEVREG::szName or PDMUSBREG::szName
454	* field contains only a limited set of ASCII characters.
455	*
456	* @returns true / false.
457	* @param pszName The name to validate.
458	*/
459	bool tstDevPdmR3IsValidName(const char *pszName)
460	{
461	char ch;
462	while ( (ch = *pszName) != '\0'
463	&& ( RT_C_IS_ALNUM(ch)
464	\|\| ch == '-'
465	\|\| ch == ' ' /** @todo disallow this! */
466	\|\| ch == '_') )
467	pszName++;
468	return ch == '\0';
469	}
470
471
472	/**
473	* @interface_method_impl{PDMDEVREGCB,pfnRegister}
474	*/
475	static DECLCALLBACK(int) tstDevPdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg)
476	{
477	/*
478	* Validate the registration structure (mostly copy and paste from PDMDevice.cpp).
479	*/
480	Assert(pReg);
481	AssertMsgReturn(pReg->u32Version == PDM_DEVREG_VERSION,
482	("Unknown struct version %#x!\n", pReg->u32Version),
483	VERR_PDM_UNKNOWN_DEVREG_VERSION);
484
485	AssertMsgReturn( pReg->szName[0]
486	&& strlen(pReg->szName) < sizeof(pReg->szName)
487	&& tstDevPdmR3IsValidName(pReg->szName),
488	("Invalid name '%.*s'\n", sizeof(pReg->szName), pReg->szName),
489	VERR_PDM_INVALID_DEVICE_REGISTRATION);
490	AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) == PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT,
491	("Invalid host bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
492	VERR_PDM_INVALID_DEVICE_HOST_BITS);
493	AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK),
494	("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
495	VERR_PDM_INVALID_DEVICE_REGISTRATION);
496	AssertMsgReturn(pReg->fClass,
497	("No class! (Device %s)\n", pReg->szName),
498	VERR_PDM_INVALID_DEVICE_REGISTRATION);
499	AssertMsgReturn(pReg->cMaxInstances > 0,
500	("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szName),
501	VERR_PDM_INVALID_DEVICE_REGISTRATION);
502	AssertMsgReturn(pReg->cbInstanceCC <= (uint32_t)(pReg->fFlags & (PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0) ? 96 * _1K : _1M),
503	("Instance size %d bytes! (Device %s)\n", pReg->cbInstanceCC, pReg->szName),
504	VERR_PDM_INVALID_DEVICE_REGISTRATION);
505	AssertMsgReturn(pReg->pfnConstruct,
506	("No constructor! (Device %s)\n", pReg->szName),
507	VERR_PDM_INVALID_DEVICE_REGISTRATION);
508	AssertLogRelMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK) == PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT,
509	("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pReg->szName),
510	VERR_PDM_INVALID_DEVICE_GUEST_BITS);
511	AssertLogRelMsg(pReg->u32VersionEnd == PDM_DEVREG_VERSION,
512	("u32VersionEnd=%#x, expected %#x. (szName=%s)\n",
513	pReg->u32VersionEnd, PDM_DEVREG_VERSION, pReg->szName));
514
515	/*
516	* Check for duplicates.
517	*/
518	int rc = VINF_SUCCESS;
519	PCTSTDEVPDMDEVREGCBINT pRegCB = (PCTSTDEVPDMDEVREGCBINT)pCallbacks;
520	if (!tstDevPdmDeviceFind(pReg->szName, NULL /ppR0Reg/))
521	{
522	PTSTDEVPDMDEV pPdmDev = (PTSTDEVPDMDEV)RTMemAllocZ(sizeof(TSTDEVPDMDEV));
523	if (RT_LIKELY(pPdmDev))
524	{
525	pPdmDev->pPdmMod = pRegCB->pMod;
526	pRegCB->pMod->cRefs++;
527	pPdmDev->pReg = pReg;
528	RTListAppend(&g_LstPdmDevs, &pPdmDev->NdPdmDevs);
529	return VINF_SUCCESS;
530	}
531	else
532	rc = VERR_NO_MEMORY;
533	}
534	else
535	rc = VERR_PDM_DEVICE_NAME_CLASH;
536
537	return rc;
538	}
539
540
541	/**
542	* Checks whether the given PDM module filename was already loaded.
543	*
544	* @returns Pointer to already loaded plugin, NULL if not found.
545	* @param pszFilename The filename to check.
546	*/
547	static PCTSTDEVPDMMOD tstDevPdmModFind(const char *pszFilename)
548	{
549	PCTSTDEVPDMMOD pIt;
550	RTListForEach(&g_LstPdmMods, pIt, TSTDEVPDMMOD, NdPdmMods)
551	{
552	if (!RTStrCmp(pIt->pszFilename, pszFilename))
553	return pIt;
554	}
555
556	return NULL;
557	}
558
559
560	/**
561	* Resolve an external symbol during RTLdrGetBits().
562	*
563	* @returns iprt status code.
564	* @param hLdrMod The loader module handle.
565	* @param pszModule Module name.
566	* @param pszSymbol Symbol name, NULL if uSymbol should be used.
567	* @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
568	* @param pValue Where to store the symbol value (address).
569	* @param pvUser User argument.
570	*/
571	static DECLCALLBACK(int) tstDevPdmLoadR0RcModGetImport(RTLDRMOD hLdrMod, const char pszModule, const char pszSymbol,
572	unsigned uSymbol, RTUINTPTR pValue, void pvUser)
573	{
574	RT_NOREF(hLdrMod, uSymbol, pszModule);
575	PTSTDEVPDMMOD pMod = (PTSTDEVPDMMOD)pvUser;
576
577	RTPrintf("Looking for %s\n", pszSymbol);
578
579	/* Resolve the import. */
580	PCTSTDEVPDMR0IMPORTS pImpDesc = NULL;
581	bool fFound = false;
582	for (uint32_t i = 0; i < RT_ELEMENTS(g_aPdmR0Imports); i++)
583	{
584	pImpDesc = &g_aPdmR0Imports[i];
585	if (!strcmp(pszSymbol, pImpDesc->pszSymbol))
586	{
587	fFound = true;
588	break;
589	}
590	}
591
592	int rc = VERR_SYMBOL_NOT_FOUND;
593	if (fFound)
594	{
595	/* Check whether the symbol has a trampoline already. */
596	PTSTDEVPDMMODTRAMPOLINE pTrampoline = (PTSTDEVPDMMODTRAMPOLINE)pMod->R0Rc.pbTrampoline;
597	for (uint32_t i = 0; i < pMod->R0Rc.cTrampolines; i++)
598	{
599	if (pTrampoline->AddrTarget == (uintptr_t)pImpDesc->pfn)
600	break;
601	pTrampoline++;
602	}
603
604	/* Create new trampoline if not found. */
605	if (pTrampoline->AddrTarget != (uintptr_t)pImpDesc->pfn)
606	{
607	if (pMod->R0Rc.cTrampolines < pMod->R0Rc.cTrampolinesMax)
608	{
609	pTrampoline = pMod->R0Rc.pTrampolineNext;
610	pMod->R0Rc.pTrampolineNext++;
611	pMod->R0Rc.cTrampolines++;
612	pTrampoline->abJmp[0] = 0xff; /* jmp */
613	pTrampoline->abJmp[1] = 0x25; /* rip */
614	pTrampoline->abJmp[2] = 0x00; /* offset */
615	pTrampoline->abJmp[3] = 0x00;
616	pTrampoline->abJmp[4] = 0x00;
617	pTrampoline->abJmp[5] = 0x00;
618	pTrampoline->AddrTarget = (uintptr_t)pImpDesc->pfn;
619	rc = VINF_SUCCESS;
620	}
621	else
622	{
623	rc = VERR_SYMBOL_NOT_FOUND;
624	AssertFailed();
625	}
626	}
627	else
628	rc = VINF_SUCCESS;
629
630	if (RT_SUCCESS(rc))
631	*pValue = (RTUINTPTR)pTrampoline;
632	}
633	else
634	AssertFailed();
635
636	return rc;
637	}
638
639
640	/**
641	* The PDMR0RegisterModule() export called by loaded R0 modules.
642	*
643	* @returns VBox status code.
644	* @param hMod The module handle.
645	* @param pModReg The module registration structure.
646	*/
647	static int tstDevPdmR0RegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg)
648	{
649	RT_NOREF(hMod);
650	RTListAppend(&g_LstPdmR0Mods, &pModReg->ListEntry);
651	return VINF_SUCCESS;
652	}
653
654
655
656	/**
657	* Loads a new R0 modules given by the filename.
658	*
659	* @returns VBox status code.
660	* @param pMod Pointer to module structure.
661	*/
662	static int tstDevPdmLoadR0RcMod(PTSTDEVPDMMOD pMod)
663	{
664	int rc = VINF_SUCCESS;
665	const char *pszFile = RTPathFilename(pMod->pszFilename);
666
667	/* Check whether the plugin is loaded first. */
668	if (!tstDevPdmModFind(pszFile))
669	{
670	/*
671	* R0 modules need special treatment as these are relocatable images
672	* which are supposed to run in ring 0.
673	*/
674	rc = RTLdrOpen(pMod->pszFilename, 0, RTLDRARCH_HOST, &pMod->hLdrMod);
675	if (RT_SUCCESS(rc))
676	{
677	size_t cb = RTLdrSize(pMod->hLdrMod) + 1024 * sizeof(TSTDEVPDMMODTRAMPOLINE);
678
679	/* Allocate bits. */
680	uint32_t fFlags = RTMEMALLOCEX_FLAGS_EXEC;
681	#ifdef RT_OS_LINUX
682	/*
683	* amd64 ELF binaries support only a 2GB code segment everything must be in
684	* (X86_64_PC32 relocation) so we have to use a trampoline to the final destination
685	* which is kept close to the imported module.
686	*/
687	fFlags \|= RTMEMALLOCEX_FLAGS_32BIT_REACH;
688	#endif
689	rc = RTMemAllocEx(cb, 0, fFlags, (void **)&pMod->R0Rc.pbTrampoline);
690	pMod->R0Rc.cbBits = cb;
691	if (RT_SUCCESS(rc))
692	{
693	pMod->R0Rc.pvBits = pMod->R0Rc.pbTrampoline + 1024 * sizeof(TSTDEVPDMMODTRAMPOLINE);
694	pMod->R0Rc.cTrampolinesMax = 1024;
695	pMod->R0Rc.cTrampolines = 0;
696	pMod->R0Rc.pTrampolineNext = (PTSTDEVPDMMODTRAMPOLINE)pMod->R0Rc.pbTrampoline;
697	/* Get the bits. */
698	rc = RTLdrGetBits(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
699	tstDevPdmLoadR0RcModGetImport, pMod);
700	if (RT_SUCCESS(rc))
701	{
702	/* Resolve module init entry and call it. */
703	PFNR0MODULEINIT pfnR0ModuleInit;
704	rc = RTLdrGetSymbolEx(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
705	UINT32_MAX, "ModuleInit", (PRTLDRADDR)&pfnR0ModuleInit);
706	if (RT_SUCCESS(rc))
707	rc = pfnR0ModuleInit(pMod);
708	}
709	else
710	RTMemFreeEx(pMod->R0Rc.pbTrampoline, pMod->R0Rc.cbBits);
711	}
712
713	if (RT_FAILURE(rc))
714	RTLdrClose(pMod->hLdrMod);
715	}
716	}
717
718	return rc;
719	}
720
721
722	/**
723	* Loads the given
724	*/
725	static int tstDevPdmLoadR3Mod(PTSTDEVPDMMOD pMod)
726	{
727	int rc = RTLdrLoad(pMod->pszFilename, &pMod->hLdrMod);
728	if (RT_SUCCESS(rc))
729	{
730	FNPDMVBOXDEVICESREGISTER *pfnVBoxDevicesRegister;
731	rc = RTLdrGetSymbol(pMod->hLdrMod, "VBoxDevicesRegister", (void**)&pfnVBoxDevicesRegister);
732	if (RT_FAILURE(rc) \|\| !pfnVBoxDevicesRegister)
733	{
734	LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnPluginLoad=%#p\n",
735	"VBoxDevicesRegister", pMod->pszFilename, rc, pfnVBoxDevicesRegister));
736	if (RT_SUCCESS(rc))
737	rc = VERR_SYMBOL_NOT_FOUND;
738	}
739
740	if (RT_SUCCESS(rc))
741	{
742	TSTDEVPDMDEVREGCBINT RegCB;
743	RegCB.Core.u32Version = PDM_DEVREG_CB_VERSION;
744	RegCB.Core.pfnRegister = tstDevPdmR3DevReg_Register;
745	RegCB.pMod = pMod;
746	rc = pfnVBoxDevicesRegister(&RegCB.Core, VBOX_VERSION);
747	}
748	else
749	LogFunc(("ignored plugin '%s': rc=%Rrc\n", pMod->pszFilename, rc));
750
751	if (RT_FAILURE(rc))
752	RTLdrClose(pMod->hLdrMod);
753	}
754
755	return rc;
756	}
757
758
759	/**
760	* Tries to loads the given PDM module.
761	*
762	* @returns VBox status code.
763	* @param pszFilename The filename to load.
764	* @param enmModType The module type.
765	*/
766	static int tstDevPdmLoadMod(const char *pszFilename, TSTDEVPDMMODTYPE enmModType)
767	{
768	int rc = VINF_SUCCESS;
769
770	/* Check whether the plugin is loaded first. */
771	if (!tstDevPdmModFind(pszFilename))
772	{
773	PTSTDEVPDMMOD pMod = (PTSTDEVPDMMOD)RTMemAllocZ(sizeof(TSTDEVPDMMOD));
774	if (RT_LIKELY(pMod))
775	{
776	pMod->pszFilename = RTStrDup(pszFilename);
777	pMod->cRefs = 1;
778	pMod->enmType = enmModType;
779
780	if (enmModType == TSTDEVPDMMODTYPE_R3)
781	rc = tstDevPdmLoadR3Mod(pMod);
782	else if (enmModType == TSTDEVPDMMODTYPE_RC \|\| enmModType == TSTDEVPDMMODTYPE_R0)
783	rc = tstDevPdmLoadR0RcMod(pMod);
784
785	if (RT_SUCCESS(rc))
786	RTListAppend(&g_LstPdmMods, &pMod->NdPdmMods);
787	else
788	RTMemFree(pMod);
789	}
790	else
791	rc = VERR_NO_MEMORY;
792	}
793
794	return rc;
795	}
796
797
798	/**
799	* Tries to resolve the given symbol from the module given.
800	*
801	* @returns VBox status code.
802	* @param pThis The device under test instance.
803	* @param pszMod The module name.
804	* @param enmModType The module type if the module needs to be loaded.
805	* @param pszSymbol The symbol to resolve.
806	* @param ppfn Where to store the value on success.
807	*/
808	DECLHIDDEN(int) tstDevPdmLdrGetSymbol(PTSTDEVDUTINT pThis, const char *pszMod, TSTDEVPDMMODTYPE enmModType,
809	const char pszSymbol, PFNRT ppfn)
810	{
811	RT_NOREF(pThis);
812
813	int rc = VINF_SUCCESS;
814	PCTSTDEVPDMMOD pMod = tstDevPdmModFind(pszMod);
815	if (!pMod)
816	{
817	/* Try to load the module. */
818	rc = tstDevPdmLoadMod(pszMod, enmModType);
819	if (RT_SUCCESS(rc))
820	{
821	pMod = tstDevPdmModFind(pszMod);
822	AssertPtr(pMod);
823	}
824	}
825
826	if (RT_SUCCESS(rc))
827	{
828	if (pMod->enmType == TSTDEVPDMMODTYPE_R0 \|\| pMod->enmType == TSTDEVPDMMODTYPE_RC)
829	rc = RTLdrGetSymbolEx(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
830	UINT32_MAX, pszSymbol, (PRTLDRADDR)ppfn);
831	else
832	rc = RTLdrGetSymbol(pMod->hLdrMod, pszSymbol, (void **)ppfn);
833	}
834
835	return rc;
836	}
837
838
839	/**
840	* Create a new PDM device with default config.
841	*
842	* @returns VBox status code.
843	* @param pszName Name of the device to create.
844	* @param pDut The device under test structure the created PDM device instance is exercised under.
845	*/
846	static int tstDevPdmDevR3Create(const char *pszName, PTSTDEVDUTINT pDut)
847	{
848	int rc = VINF_SUCCESS;
849	PCTSTDEVPDMDEV pPdmDev = tstDevPdmDeviceFind(pszName, NULL);
850	if (RT_LIKELY(pPdmDev))
851	{
852	PPDMCRITSECT pCritSect;
853	/* Figure out how much we need. */
854	uint32_t cb = RT_UOFFSETOF_DYN(PDMDEVINS, achInstanceData[pPdmDev->pReg->cbInstanceCC]);
855	cb = RT_ALIGN_32(cb, 64);
856	uint32_t const offShared = cb;
857	cb += RT_ALIGN_32(pPdmDev->pReg->cbInstanceShared, 64);
858	uint32_t const cbCritSect = RT_ALIGN_32(sizeof(*pCritSect), 64);
859	cb += cbCritSect;
860	uint32_t const cbMsixState = RT_ALIGN_32(pPdmDev->pReg->cMaxMsixVectors * 16 + (pPdmDev->pReg->cMaxMsixVectors + 7) / 8, _4K);
861	uint32_t const cbPciDev = RT_ALIGN_32(RT_UOFFSETOF_DYN(PDMPCIDEV, abMsixState[cbMsixState]), 64);
862	uint32_t const cPciDevs = RT_MIN(pPdmDev->pReg->cMaxPciDevices, 1024);
863	uint32_t const cbPciDevs = cbPciDev * cPciDevs;
864	cb += cbPciDevs;
865
866	PPDMDEVINS pDevIns = (PPDMDEVINS)RTMemAllocZ(cb);
867	pDevIns->u32Version = PDM_DEVINS_VERSION;
868	pDevIns->iInstance = 0;
869	pDevIns->pReg = pPdmDev->pReg;
870	pDevIns->pvInstanceDataR3 = &pDevIns->achInstanceData[0];
871	pDevIns->pHlpR3 = &g_tstDevPdmDevHlpR3;
872	pDevIns->pCfg = &pDut->Cfg;
873	pDevIns->Internal.s.pDut = pDut;
874	pDevIns->cbRing3 = cb;
875	pDevIns->fR0Enabled = false;
876	pDevIns->fRCEnabled = false;
877	pDevIns->pvInstanceDataR3 = (uint8_t *)pDevIns + offShared;
878	pDevIns->pvInstanceDataForR3 = &pDevIns->achInstanceData[0];
879	pCritSect = (PPDMCRITSECT)((uint8_t *)pDevIns + offShared + RT_ALIGN_32(pPdmDev->pReg->cbInstanceShared, 64));
880	pDevIns->pCritSectRoR3 = pCritSect;
881	pDevIns->cbPciDev = cbPciDev;
882	pDevIns->cPciDevs = cPciDevs;
883	for (uint32_t iPciDev = 0; iPciDev < cPciDevs; iPciDev++)
884	{
885	PPDMPCIDEV pPciDev = (PPDMPCIDEV)((uint8_t )pDevIns->pCritSectRoR3 + cbCritSect + cbPciDev iPciDev);
886	if (iPciDev < RT_ELEMENTS(pDevIns->apPciDevs))
887	pDevIns->apPciDevs[iPciDev] = pPciDev;
888	pPciDev->cbConfig = _4K;
889	pPciDev->cbMsixState = cbMsixState;
890	pPciDev->idxSubDev = (uint16_t)iPciDev;
891	pPciDev->u32Magic = PDMPCIDEV_MAGIC;
892	}
893
894	RTCritSectInit(&pCritSect->s.CritSect);
895	rc = pPdmDev->pReg->pfnConstruct(pDevIns, 0, pDevIns->pCfg);
896	if (RT_SUCCESS(rc))
897	pDut->pDevIns = pDevIns;
898	else
899	{
900	rc = pPdmDev->pReg->pfnDestruct(pDevIns);
901	RTMemFree(pDevIns);
902	}
903	}
904	else
905	rc = VERR_NOT_FOUND;
906
907	return rc;
908	}
909
910
911	DECLHIDDEN(int) tstDevPdmDeviceR3Construct(PTSTDEVDUTINT pDut)
912	{
913	PPDMDEVINS pDevInsR3 = pDut->pDevIns;
914
915	pDevInsR3->pReg = pDut->pPdmDev->pReg;
916	pDevInsR3->pHlpR3 = &g_tstDevPdmDevHlpR3;
917	pDevInsR3->pCfg = &pDut->Cfg;
918	pDevInsR3->Internal.s.pDut = pDut;
919
920	return pDevInsR3->pReg->pfnConstruct(pDevInsR3, 0, &pDut->Cfg);
921	}
922
923
924	DECLCALLBACK(void ) tstDevTestsRun_QueryInterface(PPDMIBASE pInterface, const char pszIID)
925	{
926	RT_NOREF(pInterface, pszIID);
927	#if 0
928	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
929	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDCONNECTORS, &pThis->ILedConnectors);
930	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIANOTIFY, &pThis->IMediaNotify);
931	#endif
932	return NULL;
933	}
934
935	/**
936	* Run a given test config.
937	*
938	* @returns VBox status code.
939	* @param pDevTstCfg The test config to run.
940	*/
941	static int tstDevTestsRun(PCTSTDEVCFG pDevTstCfg)
942	{
943	int rc = VINF_SUCCESS;
944
945	for (uint32_t i = 0; i < pDevTstCfg->cTests; i++)
946	{
947	PCTSTDEVTEST pTest = &pDevTstCfg->aTests[i];
948
949	TSTDEVDUTINT Dut;
950	Dut.pTest = pTest;
951	Dut.enmCtx = TSTDEVDUTCTX_R3;
952	Dut.pVm = (PVM)0x1000;
953	Dut.SupSession.pDut = &Dut;
954	Dut.Cfg.pDut = &Dut;
955	Dut.pPdmDev = tstDevPdmDeviceFind(pDevTstCfg->pszDevName, NULL /ppPdmDevR0/);
956
957	Dut.IBaseSts.pfnQueryInterface = tstDevTestsRun_QueryInterface;
958
959	RTListInit(&Dut.LstIoPorts);
960	RTListInit(&Dut.LstMmio);
961	RTListInit(&Dut.LstTimers);
962	RTListInit(&Dut.LstMmHeap);
963	RTListInit(&Dut.LstPdmThreads);
964	RTListInit(&Dut.LstSsmHandlers);
965	RTListInit(&Dut.SupSession.LstSupSem);
966
967	rc = RTCritSectRwInit(&Dut.CritSectLists);
968	AssertRC(rc);
969
970	rc = RTCritSectInitEx(&Dut.CritSectNop.s.CritSect, RTCRITSECT_FLAGS_NOP, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "DutNop");
971	AssertRC(rc);
972
973	if (!pTest->fR0Enabled)
974	rc = tstDevPdmDevR3Create(pDevTstCfg->pszDevName, &Dut);
975	else
976	rc = tstDevPdmDevR0R3Create(pDevTstCfg->pszDevName, pTest->fRCEnabled, &Dut);
977	if (RT_SUCCESS(rc))
978	{
979	PCTSTDEVTESTCASE pTestcase = tstDevTestcaseFind(pTest->papszTestcaseIds[i]);
980	if (pTestcase)
981	rc = pTestcase->pTestcaseReg->pfnTestEntry(&Dut, pTest->papTestcaseCfg[i], pTest->pacTestcaseCfgItems[i]);
982	else
983	rc = VERR_NOT_FOUND;
984	}
985	}
986
987	return rc;
988	}
989
990
991	int main(int argc, char *argv[])
992	{
993	/*
994	* Init the runtime and parse the arguments.
995	*/
996	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
997	int rc = RTR3InitExe(argc, &argv, 0);
998	if (RT_SUCCESS(rc))
999	{
1000	RTListInit(&g_LstPlugins);
1001	RTListInit(&g_LstTestcases);
1002	RTListInit(&g_LstPdmMods);
1003	RTListInit(&g_LstPdmR0Mods);
1004	RTListInit(&g_LstPdmDevs);
1005
1006	/* Register builtin tests. */
1007	tstDevRegisterTestcase(NULL, &g_TestcaseSsmFuzz);
1008	tstDevRegisterTestcase(NULL, &g_TestcaseSsmLoadDbg);
1009	tstDevRegisterTestcase(NULL, &g_TestcaseIoFuzz);
1010
1011	PCTSTDEVCFG pDevTstCfg = NULL;
1012	rc = tstDevCfgLoad(argv[1], NULL, &pDevTstCfg);
1013	if (RT_SUCCESS(rc))
1014	{
1015	if (pDevTstCfg->pszTstDevMod)
1016	rc = tstDevLoadPlugin(pDevTstCfg->pszTstDevMod);
1017	if (RT_SUCCESS(rc))
1018	{
1019	rc = tstDevPdmLoadMod(pDevTstCfg->pszPdmR3Mod, TSTDEVPDMMODTYPE_R3);
1020	if ( RT_SUCCESS(rc)
1021	&& pDevTstCfg->pszPdmR0Mod)
1022	rc = tstDevPdmLoadMod(pDevTstCfg->pszPdmR0Mod, TSTDEVPDMMODTYPE_R0);
1023	if ( RT_SUCCESS(rc)
1024	&& pDevTstCfg->pszPdmRCMod)
1025	rc = tstDevPdmLoadMod(pDevTstCfg->pszPdmRCMod, TSTDEVPDMMODTYPE_RC);
1026
1027	if (RT_SUCCESS(rc))
1028	rc = tstDevTestsRun(pDevTstCfg);
1029	else
1030	rcExit = RTEXITCODE_FAILURE;
1031	}
1032	else
1033	rcExit = RTEXITCODE_FAILURE;
1034	}
1035
1036	tstDevCfgDestroy(pDevTstCfg);
1037	}
1038	else
1039	rcExit = RTEXITCODE_FAILURE;
1040
1041	return rcExit;
1042	}
1043

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/testcase/tstDevice.cpp@ 105381

Download in other formats: