PDMDriver.cpp@ 35333

Last change on this file since 35333 was 35333, checked in by vboxsync, 14 years ago
VMM source reorg.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 57.2 KB

Line
1	/* $Id: PDMDriver.cpp 35333 2010-12-27 12:10:56Z vboxsync $ */
2	/** @file
3	* PDM - Pluggable Device and Driver Manager, Driver parts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PDM_DRIVER
23	#include "PDMInternal.h"
24	#include <VBox/pdm.h>
25	#include <VBox/mm.h>
26	#include <VBox/cfgm.h>
27	#include <VBox/vmm.h>
28	#include <VBox/sup.h>
29	#include <VBox/vm.h>
30	#include <VBox/version.h>
31	#include <VBox/err.h>
32
33	#include <VBox/log.h>
34	#include <iprt/assert.h>
35	#include <iprt/asm.h>
36	#include <iprt/ctype.h>
37	#include <iprt/mem.h>
38	#include <iprt/thread.h>
39	#include <iprt/path.h>
40	#include <iprt/string.h>
41
42
43	/*******************************************************************************
44	* Structures and Typedefs *
45	*******************************************************************************/
46	/**
47	* Internal callback structure pointer.
48	*
49	* The main purpose is to define the extra data we associate
50	* with PDMDRVREGCB so we can find the VM instance and so on.
51	*/
52	typedef struct PDMDRVREGCBINT
53	{
54	/** The callback structure. */
55	PDMDRVREGCB Core;
56	/** A bit of padding. */
57	uint32_t u32[4];
58	/** VM Handle. */
59	PVM pVM;
60	/** Pointer to the configuration node the registrations should be
61	* associated with. Can be NULL. */
62	PCFGMNODE pCfgNode;
63	} PDMDRVREGCBINT, *PPDMDRVREGCBINT;
64	typedef const PDMDRVREGCBINT *PCPDMDRVREGCBINT;
65
66
67	/*******************************************************************************
68	* Internal Functions *
69	*******************************************************************************/
70	static DECLCALLBACK(int) pdmR3DrvRegister(PCPDMDRVREGCB pCallbacks, PCPDMDRVREG pReg);
71	static int pdmR3DrvLoad(PVM pVM, PPDMDRVREGCBINT pRegCB, const char pszFilename, const char pszName);
72
73
74
75	/**
76	* Register external drivers
77	*
78	* @returns VBox status code.
79	* @param pVM The VM to operate on.
80	* @param pfnCallback Driver registration callback
81	*/
82	VMMR3DECL(int) PDMR3RegisterDrivers(PVM pVM, FNPDMVBOXDRIVERSREGISTER pfnCallback)
83	{
84	/*
85	* The registration callbacks.
86	*/
87	PDMDRVREGCBINT RegCB;
88	RegCB.Core.u32Version = PDM_DRVREG_CB_VERSION;
89	RegCB.Core.pfnRegister = pdmR3DrvRegister;
90	RegCB.pVM = pVM;
91
92	int rc = pfnCallback(&RegCB.Core, VBOX_VERSION);
93	if (RT_FAILURE(rc))
94	AssertMsgFailed(("VBoxDriversRegister failed with rc=%Rrc\n"));
95
96	return rc;
97	}
98
99	/**
100	* This function will initialize the drivers for this VM instance.
101	*
102	* First of all this mean loading the builtin drivers and letting them
103	* register themselves. Beyond that any additional driver modules are
104	* loaded and called for registration.
105	*
106	* @returns VBox status code.
107	* @param pVM VM Handle.
108	*/
109	int pdmR3DrvInit(PVM pVM)
110	{
111	LogFlow(("pdmR3DrvInit:\n"));
112
113	AssertRelease(!(RT_OFFSETOF(PDMDRVINS, achInstanceData) & 15));
114	PPDMDRVINS pDrvInsAssert; NOREF(pDrvInsAssert);
115	AssertCompile(sizeof(pDrvInsAssert->Internal.s) <= sizeof(pDrvInsAssert->Internal.padding));
116	AssertRelease(sizeof(pDrvInsAssert->Internal.s) <= sizeof(pDrvInsAssert->Internal.padding));
117
118	/*
119	* The registration callbacks.
120	*/
121	PDMDRVREGCBINT RegCB;
122	RegCB.Core.u32Version = PDM_DRVREG_CB_VERSION;
123	RegCB.Core.pfnRegister = pdmR3DrvRegister;
124	RegCB.pVM = pVM;
125	RegCB.pCfgNode = NULL;
126
127	/*
128	* Load the builtin module
129	*/
130	PCFGMNODE pDriversNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM/Drivers");
131	bool fLoadBuiltin;
132	int rc = CFGMR3QueryBool(pDriversNode, "LoadBuiltin", &fLoadBuiltin);
133	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
134	fLoadBuiltin = true;
135	else if (RT_FAILURE(rc))
136	{
137	AssertMsgFailed(("Configuration error: Querying boolean \"LoadBuiltin\" failed with %Rrc\n", rc));
138	return rc;
139	}
140	if (fLoadBuiltin)
141	{
142	/* make filename */
143	char pszFilename = pdmR3FileR3("VBoxDD", true /fShared*/);
144	if (!pszFilename)
145	return VERR_NO_TMP_MEMORY;
146	rc = pdmR3DrvLoad(pVM, &RegCB, pszFilename, "VBoxDD");
147	RTMemTmpFree(pszFilename);
148	if (RT_FAILURE(rc))
149	return rc;
150	}
151
152	/*
153	* Load additional driver modules.
154	*/
155	for (PCFGMNODE pCur = CFGMR3GetFirstChild(pDriversNode); pCur; pCur = CFGMR3GetNextChild(pCur))
156	{
157	/*
158	* Get the name and path.
159	*/
160	char szName[PDMMOD_NAME_LEN];
161	rc = CFGMR3GetName(pCur, &szName[0], sizeof(szName));
162	if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
163	{
164	AssertMsgFailed(("configuration error: The module name is too long, cchName=%zu.\n", CFGMR3GetNameLen(pCur)));
165	return VERR_PDM_MODULE_NAME_TOO_LONG;
166	}
167	else if (RT_FAILURE(rc))
168	{
169	AssertMsgFailed(("CFGMR3GetName -> %Rrc.\n", rc));
170	return rc;
171	}
172
173	/* the path is optional, if no path the module name + path is used. */
174	char szFilename[RTPATH_MAX];
175	rc = CFGMR3QueryString(pCur, "Path", &szFilename[0], sizeof(szFilename));
176	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
177	strcpy(szFilename, szName);
178	else if (RT_FAILURE(rc))
179	{
180	AssertMsgFailed(("configuration error: Failure to query the module path, rc=%Rrc.\n", rc));
181	return rc;
182	}
183
184	/* prepend path? */
185	if (!RTPathHavePath(szFilename))
186	{
187	char psz = pdmR3FileR3(szFilename, false /fShared*/);
188	if (!psz)
189	return VERR_NO_TMP_MEMORY;
190	size_t cch = strlen(psz) + 1;
191	if (cch > sizeof(szFilename))
192	{
193	RTMemTmpFree(psz);
194	AssertMsgFailed(("Filename too long! cch=%d '%s'\n", cch, psz));
195	return VERR_FILENAME_TOO_LONG;
196	}
197	memcpy(szFilename, psz, cch);
198	RTMemTmpFree(psz);
199	}
200
201	/*
202	* Load the module and register it's drivers.
203	*/
204	RegCB.pCfgNode = pCur;
205	rc = pdmR3DrvLoad(pVM, &RegCB, szFilename, szName);
206	if (RT_FAILURE(rc))
207	return rc;
208	}
209
210	LogFlow(("pdmR3DrvInit: returns VINF_SUCCESS\n"));
211	return VINF_SUCCESS;
212	}
213
214
215	/**
216	* Loads one driver module and call the registration entry point.
217	*
218	* @returns VBox status code.
219	* @param pVM VM handle.
220	* @param pRegCB The registration callback stuff.
221	* @param pszFilename Module filename.
222	* @param pszName Module name.
223	*/
224	static int pdmR3DrvLoad(PVM pVM, PPDMDRVREGCBINT pRegCB, const char pszFilename, const char pszName)
225	{
226	/*
227	* Load it.
228	*/
229	int rc = pdmR3LoadR3U(pVM->pUVM, pszFilename, pszName);
230	if (RT_SUCCESS(rc))
231	{
232	/*
233	* Get the registration export and call it.
234	*/
235	FNPDMVBOXDRIVERSREGISTER *pfnVBoxDriversRegister;
236	rc = PDMR3LdrGetSymbolR3(pVM, pszName, "VBoxDriversRegister", (void **)&pfnVBoxDriversRegister);
237	if (RT_SUCCESS(rc))
238	{
239	Log(("PDM: Calling VBoxDriversRegister (%p) of %s (%s)\n", pfnVBoxDriversRegister, pszName, pszFilename));
240	rc = pfnVBoxDriversRegister(&pRegCB->Core, VBOX_VERSION);
241	if (RT_SUCCESS(rc))
242	Log(("PDM: Successfully loaded driver module %s (%s).\n", pszName, pszFilename));
243	else
244	AssertMsgFailed(("VBoxDriversRegister failed with rc=%Rrc\n"));
245	}
246	else
247	{
248	AssertMsgFailed(("Failed to locate 'VBoxDriversRegister' in %s (%s) rc=%Rrc\n", pszName, pszFilename, rc));
249	if (rc == VERR_SYMBOL_NOT_FOUND)
250	rc = VERR_PDM_NO_REGISTRATION_EXPORT;
251	}
252	}
253	else
254	AssertMsgFailed(("Failed to load %s (%s) rc=%Rrc!\n", pszName, pszFilename, rc));
255	return rc;
256	}
257
258
259	/** @interface_method_impl{PDMDRVREGCB,pfnRegister} */
260	static DECLCALLBACK(int) pdmR3DrvRegister(PCPDMDRVREGCB pCallbacks, PCPDMDRVREG pReg)
261	{
262	/*
263	* Validate the registration structure.
264	*/
265	AssertPtrReturn(pReg, VERR_INVALID_POINTER);
266	AssertMsgReturn(pReg->u32Version == PDM_DRVREG_VERSION,
267	("%#x\n", pReg->u32Version),
268	VERR_PDM_UNKNOWN_DRVREG_VERSION);
269	AssertReturn(pReg->szName[0], VERR_PDM_INVALID_DRIVER_REGISTRATION);
270	AssertMsgReturn(RTStrEnd(pReg->szName, sizeof(pReg->szName)),
271	(".*s\n", sizeof(pReg->szName), pReg->szName),
272	VERR_PDM_INVALID_DRIVER_REGISTRATION);
273	AssertMsgReturn( !(pReg->fFlags & PDM_DRVREG_FLAGS_R0)
274	\|\| ( pReg->szR0Mod[0]
275	&& RTStrEnd(pReg->szR0Mod, sizeof(pReg->szR0Mod))),
276	("%s: %.*s\n", pReg->szName, sizeof(pReg->szR0Mod), pReg->szR0Mod),
277	VERR_PDM_INVALID_DRIVER_REGISTRATION);
278	AssertMsgReturn( !(pReg->fFlags & PDM_DRVREG_FLAGS_RC)
279	\|\| ( pReg->szRCMod[0]
280	&& RTStrEnd(pReg->szRCMod, sizeof(pReg->szRCMod))),
281	("%s: %.*s\n", pReg->szName, sizeof(pReg->szRCMod), pReg->szRCMod),
282	VERR_PDM_INVALID_DRIVER_REGISTRATION);
283	AssertMsgReturn(VALID_PTR(pReg->pszDescription),
284	("%s: %p\n", pReg->szName, pReg->pszDescription),
285	VERR_PDM_INVALID_DRIVER_REGISTRATION);
286	AssertMsgReturn(!(pReg->fFlags & ~(PDM_DRVREG_FLAGS_HOST_BITS_MASK \| PDM_DRVREG_FLAGS_R0 \| PDM_DRVREG_FLAGS_RC)),
287	("%s: %#x\n", pReg->szName, pReg->fFlags),
288	VERR_PDM_INVALID_DRIVER_REGISTRATION);
289	AssertMsgReturn((pReg->fFlags & PDM_DRVREG_FLAGS_HOST_BITS_MASK) == PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
290	("%s: %#x\n", pReg->szName, pReg->fFlags),
291	VERR_PDM_INVALID_DRIVER_HOST_BITS);
292	AssertMsgReturn(pReg->cMaxInstances > 0,
293	("%s: %#x\n", pReg->szName, pReg->cMaxInstances),
294	VERR_PDM_INVALID_DRIVER_REGISTRATION);
295	AssertMsgReturn(pReg->cbInstance <= _1M,
296	("%s: %#x\n", pReg->szName, pReg->cbInstance),
297	VERR_PDM_INVALID_DRIVER_REGISTRATION);
298	AssertMsgReturn(VALID_PTR(pReg->pfnConstruct),
299	("%s: %p\n", pReg->szName, pReg->pfnConstruct),
300	VERR_PDM_INVALID_DRIVER_REGISTRATION);
301	AssertMsgReturn(VALID_PTR(pReg->pfnRelocate) \|\| !(pReg->fFlags & PDM_DRVREG_FLAGS_RC),
302	("%s: %#x\n", pReg->szName, pReg->cbInstance),
303	VERR_PDM_INVALID_DRIVER_REGISTRATION);
304	AssertMsgReturn(pReg->pfnSoftReset == NULL,
305	("%s: %p\n", pReg->szName, pReg->pfnSoftReset),
306	VERR_PDM_INVALID_DRIVER_REGISTRATION);
307	AssertMsgReturn(pReg->u32VersionEnd == PDM_DRVREG_VERSION,
308	("%s: #x\n", pReg->szName, pReg->u32VersionEnd),
309	VERR_PDM_INVALID_DRIVER_REGISTRATION);
310
311	/*
312	* Check for duplicate and find FIFO entry at the same time.
313	*/
314	PCPDMDRVREGCBINT pRegCB = (PCPDMDRVREGCBINT)pCallbacks;
315	PPDMDRV pDrvPrev = NULL;
316	PPDMDRV pDrv = pRegCB->pVM->pdm.s.pDrvs;
317	for (; pDrv; pDrvPrev = pDrv, pDrv = pDrv->pNext)
318	{
319	if (!strcmp(pDrv->pReg->szName, pReg->szName))
320	{
321	AssertMsgFailed(("Driver '%s' already exists\n", pReg->szName));
322	return VERR_PDM_DRIVER_NAME_CLASH;
323	}
324	}
325
326	/*
327	* Allocate new driver structure and insert it into the list.
328	*/
329	int rc;
330	pDrv = (PPDMDRV)MMR3HeapAlloc(pRegCB->pVM, MM_TAG_PDM_DRIVER, sizeof(*pDrv));
331	if (pDrv)
332	{
333	pDrv->pNext = NULL;
334	pDrv->cInstances = 0;
335	pDrv->iNextInstance = 0;
336	pDrv->pReg = pReg;
337	rc = CFGMR3QueryStringAllocDef( pRegCB->pCfgNode, "RCSearchPath", &pDrv->pszRCSearchPath, NULL);
338	if (RT_SUCCESS(rc))
339	rc = CFGMR3QueryStringAllocDef(pRegCB->pCfgNode, "R0SearchPath", &pDrv->pszR0SearchPath, NULL);
340	if (RT_SUCCESS(rc))
341	{
342	if (pDrvPrev)
343	pDrvPrev->pNext = pDrv;
344	else
345	pRegCB->pVM->pdm.s.pDrvs = pDrv;
346	Log(("PDM: Registered driver '%s'\n", pReg->szName));
347	return VINF_SUCCESS;
348	}
349	MMR3HeapFree(pDrv);
350	}
351	else
352	rc = VERR_NO_MEMORY;
353	return rc;
354	}
355
356
357	/**
358	* Lookups a driver structure by name.
359	* @internal
360	*/
361	PPDMDRV pdmR3DrvLookup(PVM pVM, const char *pszName)
362	{
363	for (PPDMDRV pDrv = pVM->pdm.s.pDrvs; pDrv; pDrv = pDrv->pNext)
364	if (!strcmp(pDrv->pReg->szName, pszName))
365	return pDrv;
366	return NULL;
367	}
368
369
370	/**
371	* Instantiate a driver.
372	*
373	* @returns VBox status code, including informational statuses.
374	*
375	* @param pVM The VM handle.
376	* @param pNode The CFGM node for the driver.
377	* @param pBaseInterface The base interface.
378	* @param pDrvAbove The driver above it. NULL if it's the top-most
379	* driver.
380	* @param pLun The LUN the driver is being attached to. NULL
381	* if we're instantiating a driver chain before
382	* attaching it - untested.
383	* @param ppBaseInterface Where to return the pointer to the base
384	* interface of the newly created driver.
385	*
386	* @remarks Recursive calls to this function is normal as the drivers will
387	* attach to anything below them during the pfnContruct call.
388	*/
389	int pdmR3DrvInstantiate(PVM pVM, PCFGMNODE pNode, PPDMIBASE pBaseInterface, PPDMDRVINS pDrvAbove,
390	PPDMLUN pLun, PPDMIBASE *ppBaseInterface)
391	{
392	Assert(!pDrvAbove \|\| !pDrvAbove->Internal.s.pDown);
393	Assert(!pDrvAbove \|\| !pDrvAbove->pDownBase);
394
395	Assert(pBaseInterface->pfnQueryInterface(pBaseInterface, PDMIBASE_IID) == pBaseInterface);
396
397	/*
398	* Find the driver.
399	*/
400	char *pszName;
401	int rc = CFGMR3QueryStringAlloc(pNode, "Driver", &pszName);
402	if (RT_SUCCESS(rc))
403	{
404	PPDMDRV pDrv = pdmR3DrvLookup(pVM, pszName);
405	MMR3HeapFree(pszName);
406	if ( pDrv
407	&& pDrv->cInstances < pDrv->pReg->cMaxInstances)
408	{
409	/* config node */
410	PCFGMNODE pConfigNode = CFGMR3GetChild(pNode, "Config");
411	if (!pConfigNode)
412	rc = CFGMR3InsertNode(pNode, "Config", &pConfigNode);
413	if (RT_SUCCESS(rc))
414	{
415	CFGMR3SetRestrictedRoot(pConfigNode);
416
417	/*
418	* Allocate the driver instance.
419	*/
420	size_t cb = RT_OFFSETOF(PDMDRVINS, achInstanceData[pDrv->pReg->cbInstance]);
421	cb = RT_ALIGN_Z(cb, 16);
422	bool const fHyperHeap = !!(pDrv->pReg->fFlags & (PDM_DRVREG_FLAGS_R0 \| PDM_DRVREG_FLAGS_RC));
423	PPDMDRVINS pNew;
424	if (fHyperHeap)
425	rc = MMHyperAlloc(pVM, cb, 64, MM_TAG_PDM_DRIVER, (void **)&pNew);
426	else
427	rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_DRIVER, cb, (void **)&pNew);
428	if (pNew)
429	{
430	/*
431	* Initialize the instance structure (declaration order).
432	*/
433	pNew->u32Version = PDM_DRVINS_VERSION;
434	pNew->Internal.s.pUp = pDrvAbove ? pDrvAbove : NULL;
435	//pNew->Internal.s.pDown = NULL;
436	pNew->Internal.s.pLun = pLun;
437	pNew->Internal.s.pDrv = pDrv;
438	pNew->Internal.s.pVMR3 = pVM;
439	pNew->Internal.s.pVMR0 = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0 ? pVM->pVMR0 : NIL_RTR0PTR;
440	pNew->Internal.s.pVMRC = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_RC ? pVM->pVMRC : NIL_RTRCPTR;
441	//pNew->Internal.s.fDetaching = false;
442	pNew->Internal.s.fVMSuspended = true;
443	//pNew->Internal.s.fVMReset = false;
444	pNew->Internal.s.fHyperHeap = fHyperHeap;
445	//pNew->Internal.s.pfnAsyncNotify = NULL;
446	pNew->Internal.s.pCfgHandle = pNode;
447	pNew->pReg = pDrv->pReg;
448	pNew->pCfg = pConfigNode;
449	pNew->iInstance = pDrv->iNextInstance;
450	pNew->pUpBase = pBaseInterface;
451	Assert(!pDrvAbove \|\| pBaseInterface == &pDrvAbove->IBase);
452	//pNew->pDownBase = NULL;
453	//pNew->IBase.pfnQueryInterface = NULL;
454	pNew->pHlpR3 = &g_pdmR3DrvHlp;
455	pNew->pvInstanceDataR3 = &pNew->achInstanceData[0];
456	if (pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0)
457	{
458	pNew->pvInstanceDataR0 = MMHyperR3ToR0(pVM, &pNew->achInstanceData[0]);
459	rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0DrvHlp", &pNew->pHlpR0);
460	AssertReleaseRCReturn(rc, rc);
461
462	}
463	if (pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_RC)
464	{
465	pNew->pvInstanceDataR0 = MMHyperR3ToRC(pVM, &pNew->achInstanceData[0]);
466	rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDrvHlp", &pNew->pHlpRC);
467	AssertReleaseRCReturn(rc, rc);
468	}
469
470	pDrv->iNextInstance++;
471	pDrv->cInstances++;
472
473	/*
474	* Link with it with the driver above / LUN.
475	*/
476	if (pDrvAbove)
477	{
478	pDrvAbove->pDownBase = &pNew->IBase;
479	pDrvAbove->Internal.s.pDown = pNew;
480	}
481	else if (pLun)
482	pLun->pTop = pNew;
483	if (pLun)
484	pLun->pBottom = pNew;
485
486	/*
487	* Invoke the constructor.
488	*/
489	rc = pDrv->pReg->pfnConstruct(pNew, pNew->pCfg, 0 /fFlags/);
490	if (RT_SUCCESS(rc))
491	{
492	AssertPtr(pNew->IBase.pfnQueryInterface);
493	Assert(pNew->IBase.pfnQueryInterface(&pNew->IBase, PDMIBASE_IID) == &pNew->IBase);
494
495	/* Success! */
496	*ppBaseInterface = &pNew->IBase;
497	if (pLun)
498	Log(("PDM: Attached driver %p:'%s'/%d to LUN#%d on device '%s'/%d, pDrvAbove=%p:'%s'/%d\n",
499	pNew, pDrv->pReg->szName, pNew->iInstance,
500	pLun->iLun,
501	pLun->pDevIns ? pLun->pDevIns->pReg->szName : pLun->pUsbIns->pReg->szName,
502	pLun->pDevIns ? pLun->pDevIns->iInstance : pLun->pUsbIns->iInstance,
503	pDrvAbove, pDrvAbove ? pDrvAbove->pReg->szName : "", pDrvAbove ? pDrvAbove->iInstance : UINT32_MAX));
504	else
505	Log(("PDM: Attached driver %p:'%s'/%d, pDrvAbove=%p:'%s'/%d\n",
506	pNew, pDrv->pReg->szName, pNew->iInstance,
507	pDrvAbove, pDrvAbove ? pDrvAbove->pReg->szName : "", pDrvAbove ? pDrvAbove->iInstance : UINT32_MAX));
508	}
509	else
510	pdmR3DrvDestroyChain(pNew, PDM_TACH_FLAGS_NO_CALLBACKS);
511	}
512	else
513	{
514	AssertMsgFailed(("Failed to allocate %d bytes for instantiating driver '%s'\n", cb, pszName));
515	rc = VERR_NO_MEMORY;
516	}
517	}
518	else
519	AssertMsgFailed(("Failed to create Config node! rc=%Rrc\n", rc));
520	}
521	else if (pDrv)
522	{
523	AssertMsgFailed(("Too many instances of driver '%s', max is %u\n", pszName, pDrv->pReg->cMaxInstances));
524	rc = VERR_PDM_TOO_MANY_DRIVER_INSTANCES;
525	}
526	else
527	{
528	AssertMsgFailed(("Driver '%s' wasn't found!\n", pszName));
529	rc = VERR_PDM_DRIVER_NOT_FOUND;
530	}
531	}
532	else
533	{
534	AssertMsgFailed(("Query for string value of \"Driver\" -> %Rrc\n", rc));
535	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
536	rc = VERR_PDM_CFG_MISSING_DRIVER_NAME;
537	}
538	return rc;
539	}
540
541
542	/**
543	* Detaches a driver from whatever it's attached to.
544	* This will of course lead to the destruction of the driver and all drivers below it in the chain.
545	*
546	* @returns VINF_SUCCESS
547	* @param pDrvIns The driver instance to detach.
548	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
549	*/
550	int pdmR3DrvDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
551	{
552	PDMDRV_ASSERT_DRVINS(pDrvIns);
553	LogFlow(("pdmR3DrvDetach: pDrvIns=%p '%s'/%d\n", pDrvIns, pDrvIns->pReg->szName, pDrvIns->iInstance));
554	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
555
556	/*
557	* Check that we're not doing this recursively, that could have unwanted sideeffects!
558	*/
559	if (pDrvIns->Internal.s.fDetaching)
560	{
561	AssertMsgFailed(("Recursive detach! '%s'/%d\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
562	return VINF_SUCCESS; }
563
564	/*
565	* Check that we actually can detach this instance.
566	* The requirement is that the driver/device above has a detach method.
567	*/
568	if (pDrvIns->Internal.s.pUp
569	? !pDrvIns->Internal.s.pUp->pReg->pfnDetach
570	: !pDrvIns->Internal.s.pLun->pDevIns->pReg->pfnDetach)
571	{
572	AssertMsgFailed(("Cannot detach driver instance because the driver/device above doesn't support it!\n"));
573	return VERR_PDM_DRIVER_DETACH_NOT_POSSIBLE;
574	}
575
576	/*
577	* Join paths with pdmR3DrvDestroyChain.
578	*/
579	pdmR3DrvDestroyChain(pDrvIns, fFlags);
580	return VINF_SUCCESS;
581	}
582
583
584	/**
585	* Destroys a driver chain starting with the specified driver.
586	*
587	* This is used when unplugging a device at run time.
588	*
589	* @param pDrvIns Pointer to the driver instance to start with.
590	* @param fFlags PDM_TACH_FLAGS_NOT_HOT_PLUG, PDM_TACH_FLAGS_NO_CALLBACKS
591	* or 0.
592	*/
593	void pdmR3DrvDestroyChain(PPDMDRVINS pDrvIns, uint32_t fFlags)
594	{
595	PVM pVM = pDrvIns->Internal.s.pVMR3;
596	VM_ASSERT_EMT(pVM);
597
598	/*
599	* Detach the bottommost driver until we've detached pDrvIns.
600	*/
601	pDrvIns->Internal.s.fDetaching = true;
602	PPDMDRVINS pCur;
603	do
604	{
605	/* find the driver to detach. */
606	pCur = pDrvIns;
607	while (pCur->Internal.s.pDown)
608	pCur = pCur->Internal.s.pDown;
609	LogFlow(("pdmR3DrvDestroyChain: pCur=%p '%s'/%d\n", pCur, pCur->pReg->szName, pCur->iInstance));
610
611	/*
612	* Unlink it and notify parent.
613	*/
614	pCur->Internal.s.fDetaching = true;
615
616	PPDMLUN pLun = pCur->Internal.s.pLun;
617	Assert(pLun->pBottom == pCur);
618	pLun->pBottom = pCur->Internal.s.pUp;
619
620	if (pCur->Internal.s.pUp)
621	{
622	/* driver parent */
623	PPDMDRVINS pParent = pCur->Internal.s.pUp;
624	pCur->Internal.s.pUp = NULL;
625	pParent->Internal.s.pDown = NULL;
626
627	if (!(fFlags & PDM_TACH_FLAGS_NO_CALLBACKS) && pParent->pReg->pfnDetach)
628	pParent->pReg->pfnDetach(pParent, fFlags);
629
630	pParent->pDownBase = NULL;
631	}
632	else
633	{
634	/* device parent */
635	Assert(pLun->pTop == pCur);
636	pLun->pTop = NULL;
637	if (!(fFlags & PDM_TACH_FLAGS_NO_CALLBACKS) && pLun->pDevIns->pReg->pfnDetach)
638	pLun->pDevIns->pReg->pfnDetach(pLun->pDevIns, pLun->iLun, fFlags);
639	}
640
641	/*
642	* Call destructor.
643	*/
644	pCur->pUpBase = NULL;
645	if (pCur->pReg->pfnDestruct)
646	pCur->pReg->pfnDestruct(pCur);
647	pCur->Internal.s.pDrv->cInstances--;
648
649	/*
650	* Free all resources allocated by the driver.
651	*/
652	/* Queues. */
653	int rc = PDMR3QueueDestroyDriver(pVM, pCur);
654	AssertRC(rc);
655
656	/* Timers. */
657	rc = TMR3TimerDestroyDriver(pVM, pCur);
658	AssertRC(rc);
659
660	/* SSM data units. */
661	rc = SSMR3DeregisterDriver(pVM, pCur, NULL, 0);
662	AssertRC(rc);
663
664	/* PDM threads. */
665	rc = pdmR3ThreadDestroyDriver(pVM, pCur);
666	AssertRC(rc);
667
668	/* Info handlers. */
669	rc = DBGFR3InfoDeregisterDriver(pVM, pCur, NULL);
670	AssertRC(rc);
671
672	/* PDM critsects. */
673	rc = pdmR3CritSectDeleteDriver(pVM, pCur);
674	AssertRC(rc);
675
676	/* Block caches. */
677	PDMR3BlkCacheReleaseDriver(pVM, pCur);
678
679	/* Finally, the driver it self. */
680	bool fHyperHeap = pCur->Internal.s.fHyperHeap;
681	ASMMemFill32(pCur, RT_OFFSETOF(PDMDRVINS, achInstanceData[pCur->pReg->cbInstance]), 0xdeadd0d0);
682	if (fHyperHeap)
683	MMHyperFree(pVM, pCur);
684	else
685	MMR3HeapFree(pCur);
686
687	} while (pCur != pDrvIns);
688	}
689
690
691
692
693	/** @name Driver Helpers
694	* @{
695	*/
696
697	/** @interface_method_impl{PDMDRVHLP,pfnAttach} */
698	static DECLCALLBACK(int) pdmR3DrvHlp_Attach(PPDMDRVINS pDrvIns, uint32_t fFlags, PPDMIBASE *ppBaseInterface)
699	{
700	PDMDRV_ASSERT_DRVINS(pDrvIns);
701	PVM pVM = pDrvIns->Internal.s.pVMR3;
702	VM_ASSERT_EMT(pVM);
703	LogFlow(("pdmR3DrvHlp_Attach: caller='%s'/%d: fFlags=%#x\n", pDrvIns->pReg->szName, pDrvIns->iInstance, fFlags));
704	Assert(!(fFlags & ~(PDM_TACH_FLAGS_NOT_HOT_PLUG)));
705
706	/*
707	* Check that there isn't anything attached already.
708	*/
709	int rc;
710	if (!pDrvIns->Internal.s.pDown)
711	{
712	Assert(pDrvIns->Internal.s.pLun->pBottom == pDrvIns);
713
714	/*
715	* Get the attached driver configuration.
716	*/
717	PCFGMNODE pNode = CFGMR3GetChild(pDrvIns->Internal.s.pCfgHandle, "AttachedDriver");
718	if (pNode)
719	rc = pdmR3DrvInstantiate(pVM, pNode, &pDrvIns->IBase, pDrvIns, pDrvIns->Internal.s.pLun, ppBaseInterface);
720	else
721	rc = VERR_PDM_NO_ATTACHED_DRIVER;
722	}
723	else
724	{
725	AssertMsgFailed(("Already got a driver attached. The driver should keep track of such things!\n"));
726	rc = VERR_PDM_DRIVER_ALREADY_ATTACHED;
727	}
728
729	LogFlow(("pdmR3DrvHlp_Attach: caller='%s'/%d: return %Rrc\n",
730	pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
731	return rc;
732	}
733
734
735	/** @interface_method_impl{PDMDRVHLP,pfnDetach} */
736	static DECLCALLBACK(int) pdmR3DrvHlp_Detach(PPDMDRVINS pDrvIns, uint32_t fFlags)
737	{
738	PDMDRV_ASSERT_DRVINS(pDrvIns);
739	LogFlow(("pdmR3DrvHlp_Detach: caller='%s'/%d: fFlags=%#x\n",
740	pDrvIns->pReg->szName, pDrvIns->iInstance, fFlags));
741	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
742
743	/*
744	* Anything attached?
745	*/
746	int rc;
747	if (pDrvIns->Internal.s.pDown)
748	rc = pdmR3DrvDetach(pDrvIns->Internal.s.pDown, fFlags);
749	else
750	{
751	AssertMsgFailed(("Nothing attached!\n"));
752	rc = VERR_PDM_NO_DRIVER_ATTACHED;
753	}
754
755	LogFlow(("pdmR3DrvHlp_Detach: caller='%s'/%d: returns %Rrc\n",
756	pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
757	return rc;
758	}
759
760
761	/** @interface_method_impl{PDMDRVHLP,pfnDetachSelf} */
762	static DECLCALLBACK(int) pdmR3DrvHlp_DetachSelf(PPDMDRVINS pDrvIns, uint32_t fFlags)
763	{
764	PDMDRV_ASSERT_DRVINS(pDrvIns);
765	LogFlow(("pdmR3DrvHlp_DetachSelf: caller='%s'/%d: fFlags=%#x\n",
766	pDrvIns->pReg->szName, pDrvIns->iInstance, fFlags));
767	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
768
769	int rc = pdmR3DrvDetach(pDrvIns, fFlags);
770
771	LogFlow(("pdmR3DrvHlp_Detach: returns %Rrc\n", rc)); /* pDrvIns is freed by now. */
772	return rc;
773	}
774
775
776	/** @interface_method_impl{PDMDRVHLP,pfnMountPrepare} */
777	static DECLCALLBACK(int) pdmR3DrvHlp_MountPrepare(PPDMDRVINS pDrvIns, const char pszFilename, const char pszCoreDriver)
778	{
779	PDMDRV_ASSERT_DRVINS(pDrvIns);
780	LogFlow(("pdmR3DrvHlp_MountPrepare: caller='%s'/%d: pszFilename=%p:{%s} pszCoreDriver=%p:{%s}\n",
781	pDrvIns->pReg->szName, pDrvIns->iInstance, pszFilename, pszFilename, pszCoreDriver, pszCoreDriver));
782	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
783
784	/*
785	* Do the caller have anything attached below itself?
786	*/
787	if (pDrvIns->Internal.s.pDown)
788	{
789	AssertMsgFailed(("Cannot prepare a mount when something's attached to you!\n"));
790	return VERR_PDM_DRIVER_ALREADY_ATTACHED;
791	}
792
793	/*
794	* We're asked to prepare, so we'll start off by nuking the
795	* attached configuration tree.
796	*/
797	PCFGMNODE pNode = CFGMR3GetChild(pDrvIns->Internal.s.pCfgHandle, "AttachedDriver");
798	if (pNode)
799	CFGMR3RemoveNode(pNode);
800
801	/*
802	* If there is no core driver, we'll have to probe for it.
803	*/
804	if (!pszCoreDriver)
805	{
806	/** @todo implement image probing. */
807	AssertReleaseMsgFailed(("Not implemented!\n"));
808	return VERR_NOT_IMPLEMENTED;
809	}
810
811	/*
812	* Construct the basic attached driver configuration.
813	*/
814	int rc = CFGMR3InsertNode(pDrvIns->Internal.s.pCfgHandle, "AttachedDriver", &pNode);
815	if (RT_SUCCESS(rc))
816	{
817	rc = CFGMR3InsertString(pNode, "Driver", pszCoreDriver);
818	if (RT_SUCCESS(rc))
819	{
820	PCFGMNODE pCfg;
821	rc = CFGMR3InsertNode(pNode, "Config", &pCfg);
822	if (RT_SUCCESS(rc))
823	{
824	rc = CFGMR3InsertString(pCfg, "Path", pszFilename);
825	if (RT_SUCCESS(rc))
826	{
827	LogFlow(("pdmR3DrvHlp_MountPrepare: caller='%s'/%d: returns %Rrc (Driver=%s)\n",
828	pDrvIns->pReg->szName, pDrvIns->iInstance, rc, pszCoreDriver));
829	return rc;
830	}
831	else
832	AssertMsgFailed(("Path string insert failed, rc=%Rrc\n", rc));
833	}
834	else
835	AssertMsgFailed(("Config node failed, rc=%Rrc\n", rc));
836	}
837	else
838	AssertMsgFailed(("Driver string insert failed, rc=%Rrc\n", rc));
839	CFGMR3RemoveNode(pNode);
840	}
841	else
842	AssertMsgFailed(("AttachedDriver node insert failed, rc=%Rrc\n", rc));
843
844	LogFlow(("pdmR3DrvHlp_MountPrepare: caller='%s'/%d: returns %Rrc\n",
845	pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
846	return rc;
847	}
848
849
850	/** @interface_method_impl{PDMDRVHLP,pfnAssertEMT} */
851	static DECLCALLBACK(bool) pdmR3DrvHlp_AssertEMT(PPDMDRVINS pDrvIns, const char pszFile, unsigned iLine, const char pszFunction)
852	{
853	PDMDRV_ASSERT_DRVINS(pDrvIns);
854	if (VM_IS_EMT(pDrvIns->Internal.s.pVMR3))
855	return true;
856
857	char szMsg[100];
858	RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDrvIns->pReg->szName, pDrvIns->iInstance);
859	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
860	AssertBreakpoint();
861	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
862	return false;
863	}
864
865
866	/** @interface_method_impl{PDMDRVHLP,pfnAssertOther} */
867	static DECLCALLBACK(bool) pdmR3DrvHlp_AssertOther(PPDMDRVINS pDrvIns, const char pszFile, unsigned iLine, const char pszFunction)
868	{
869	PDMDRV_ASSERT_DRVINS(pDrvIns);
870	if (!VM_IS_EMT(pDrvIns->Internal.s.pVMR3))
871	return true;
872
873	char szMsg[100];
874	RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDrvIns->pReg->szName, pDrvIns->iInstance);
875	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
876	AssertBreakpoint();
877	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
878	return false;
879	}
880
881
882	/** @interface_method_impl{PDMDRVHLP,pfnVMSetError} */
883	static DECLCALLBACK(int) pdmR3DrvHlp_VMSetError(PPDMDRVINS pDrvIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
884	{
885	PDMDRV_ASSERT_DRVINS(pDrvIns);
886	va_list args;
887	va_start(args, pszFormat);
888	int rc2 = VMSetErrorV(pDrvIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
889	va_end(args);
890	return rc;
891	}
892
893
894	/** @interface_method_impl{PDMDRVHLP,pfnVMSetErrorV} */
895	static DECLCALLBACK(int) pdmR3DrvHlp_VMSetErrorV(PPDMDRVINS pDrvIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
896	{
897	PDMDRV_ASSERT_DRVINS(pDrvIns);
898	int rc2 = VMSetErrorV(pDrvIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
899	return rc;
900	}
901
902
903	/** @interface_method_impl{PDMDRVHLP,pfnVMSetRuntimeError} */
904	static DECLCALLBACK(int) pdmR3DrvHlp_VMSetRuntimeError(PPDMDRVINS pDrvIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
905	{
906	PDMDRV_ASSERT_DRVINS(pDrvIns);
907	va_list args;
908	va_start(args, pszFormat);
909	int rc = VMSetRuntimeErrorV(pDrvIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, args);
910	va_end(args);
911	return rc;
912	}
913
914
915	/** @interface_method_impl{PDMDRVHLP,pfnVMSetRuntimeErrorV} */
916	static DECLCALLBACK(int) pdmR3DrvHlp_VMSetRuntimeErrorV(PPDMDRVINS pDrvIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
917	{
918	PDMDRV_ASSERT_DRVINS(pDrvIns);
919	int rc = VMSetRuntimeErrorV(pDrvIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, va);
920	return rc;
921	}
922
923
924	/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
925	static DECLCALLBACK(VMSTATE) pdmR3DrvHlp_VMState(PPDMDRVINS pDrvIns)
926	{
927	PDMDRV_ASSERT_DRVINS(pDrvIns);
928
929	VMSTATE enmVMState = VMR3GetState(pDrvIns->Internal.s.pVMR3);
930
931	LogFlow(("pdmR3DrvHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDrvIns->pReg->szName, pDrvIns->iInstance,
932	enmVMState, VMR3GetStateName(enmVMState)));
933	return enmVMState;
934	}
935
936
937	/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
938	static DECLCALLBACK(bool) pdmR3DrvHlp_VMTeleportedAndNotFullyResumedYet(PPDMDRVINS pDrvIns)
939	{
940	PDMDRV_ASSERT_DRVINS(pDrvIns);
941
942	bool fRc = VMR3TeleportedAndNotFullyResumedYet(pDrvIns->Internal.s.pVMR3);
943
944	LogFlow(("pdmR3DrvHlp_VMState: caller='%s'/%d: returns %RTbool)\n", pDrvIns->pReg->szName, pDrvIns->iInstance,
945	fRc));
946	return fRc;
947	}
948
949
950	/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
951	static DECLCALLBACK(PSUPDRVSESSION) pdmR3DrvHlp_GetSupDrvSession(PPDMDRVINS pDrvIns)
952	{
953	PDMDRV_ASSERT_DRVINS(pDrvIns);
954
955	PSUPDRVSESSION pSession = pDrvIns->Internal.s.pVMR3->pSession;
956	LogFlow(("pdmR3DrvHlp_GetSupDrvSession: caller='%s'/%d: returns %p)\n", pDrvIns->pReg->szName, pDrvIns->iInstance,
957	pSession));
958	return pSession;
959	}
960
961
962	/** @interface_method_impl{PDMDRVHLP,pfnQueueCreate} */
963	static DECLCALLBACK(int) pdmR3DrvHlp_QueueCreate(PPDMDRVINS pDrvIns, uint32_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
964	PFNPDMQUEUEDRV pfnCallback, const char pszName, PPDMQUEUE ppQueue)
965	{
966	PDMDRV_ASSERT_DRVINS(pDrvIns);
967	LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%p:{%s} ppQueue=%p\n",
968	pDrvIns->pReg->szName, pDrvIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, pszName, ppQueue, ppQueue));
969	PVM pVM = pDrvIns->Internal.s.pVMR3;
970	VM_ASSERT_EMT(pVM);
971
972	if (pDrvIns->iInstance > 0)
973	{
974	pszName = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DRIVER_DESC, "%s_%u", pszName, pDrvIns->iInstance);
975	AssertLogRelReturn(pszName, VERR_NO_MEMORY);
976	}
977
978	int rc = PDMR3QueueCreateDriver(pVM, pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, ppQueue);
979
980	LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc, ppQueue));
981	return rc;
982	}
983
984
985	/** @interface_method_impl{PDMDRVHLP,pfnTMGetVirtualFreq} */
986	static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualFreq(PPDMDRVINS pDrvIns)
987	{
988	PDMDRV_ASSERT_DRVINS(pDrvIns);
989
990	return TMVirtualGetFreq(pDrvIns->Internal.s.pVMR3);
991	}
992
993
994	/** @interface_method_impl{PDMDRVHLP,pfnTMGetVirtualTime} */
995	static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualTime(PPDMDRVINS pDrvIns)
996	{
997	PDMDRV_ASSERT_DRVINS(pDrvIns);
998
999	return TMVirtualGet(pDrvIns->Internal.s.pVMR3);
1000	}
1001
1002
1003	/** @interface_method_impl{PDMDRVHLP,pfnTMTimerCreate} */
1004	static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void pvUser, uint32_t fFlags, const char pszDesc, PPTMTIMERR3 ppTimer)
1005	{
1006	PDMDRV_ASSERT_DRVINS(pDrvIns);
1007	LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
1008	pDrvIns->pReg->szName, pDrvIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
1009
1010	int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
1011
1012	LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc ppTimer=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc, ppTimer));
1013	return rc;
1014	}
1015
1016
1017
1018	/** @interface_method_impl{PDMDRVHLP,pfnSSMRegister} */
1019	static DECLCALLBACK(int) pdmR3DrvHlp_SSMRegister(PPDMDRVINS pDrvIns, uint32_t uVersion, size_t cbGuess,
1020	PFNSSMDRVLIVEPREP pfnLivePrep, PFNSSMDRVLIVEEXEC pfnLiveExec, PFNSSMDRVLIVEVOTE pfnLiveVote,
1021	PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
1022	PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone)
1023	{
1024	PDMDRV_ASSERT_DRVINS(pDrvIns);
1025	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1026	LogFlow(("pdmR3DrvHlp_SSMRegister: caller='%s'/%d: uVersion=#x cbGuess=%#x \n"
1027	" pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoaddone=%p\n",
1028	pDrvIns->pReg->szName, pDrvIns->iInstance, uVersion, cbGuess,
1029	pfnLivePrep, pfnLiveExec, pfnLiveVote,
1030	pfnSavePrep, pfnSaveExec, pfnSaveDone, pfnLoadPrep, pfnLoadExec, pfnLoadDone));
1031
1032	int rc = SSMR3RegisterDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, pDrvIns->pReg->szName, pDrvIns->iInstance,
1033	uVersion, cbGuess,
1034	pfnLivePrep, pfnLiveExec, pfnLiveVote,
1035	pfnSavePrep, pfnSaveExec, pfnSaveDone,
1036	pfnLoadPrep, pfnLoadExec, pfnLoadDone);
1037
1038	LogFlow(("pdmR3DrvHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1039	return rc;
1040	}
1041
1042
1043	/** @interface_method_impl{PDMDRVHLP,pfnSSMDeregister} */
1044	static DECLCALLBACK(int) pdmR3DrvHlp_SSMDeregister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance)
1045	{
1046	PDMDRV_ASSERT_DRVINS(pDrvIns);
1047	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1048	LogFlow(("pdmR3DrvHlp_SSMDeregister: caller='%s'/%d: pszName=%p:{%s} u32Instance=%#x\n",
1049	pDrvIns->pReg->szName, pDrvIns->iInstance, pszName, pszName, u32Instance));
1050
1051	int rc = SSMR3DeregisterDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, pszName, u32Instance);
1052
1053	LogFlow(("pdmR3DrvHlp_SSMDeregister: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1054	return rc;
1055	}
1056
1057
1058	/** @interface_method_impl{PDMDEVHLP,pfnDBGFInfoRegister} */
1059	static DECLCALLBACK(int) pdmR3DrvHlp_DBGFInfoRegister(PPDMDRVINS pDrvIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDRV pfnHandler)
1060	{
1061	PDMDRV_ASSERT_DRVINS(pDrvIns);
1062	LogFlow(("pdmR3DrvHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
1063	pDrvIns->pReg->szName, pDrvIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
1064
1065	int rc = DBGFR3InfoRegisterDriver(pDrvIns->Internal.s.pVMR3, pszName, pszDesc, pfnHandler, pDrvIns);
1066
1067	LogFlow(("pdmR3DrvHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1068	return rc;
1069	}
1070
1071
1072	/** @interface_method_impl{PDMDEVHLP,pfnDBGFInfoDeregister} */
1073	static DECLCALLBACK(int) pdmR3DrvHlp_DBGFInfoDeregister(PPDMDRVINS pDrvIns, const char *pszName)
1074	{
1075	PDMDRV_ASSERT_DRVINS(pDrvIns);
1076	LogFlow(("pdmR3DrvHlp_DBGFInfoDeregister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
1077	pDrvIns->pReg->szName, pDrvIns->iInstance, pszName));
1078
1079	int rc = DBGFR3InfoDeregisterDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, pszName);
1080
1081	LogFlow(("pdmR3DrvHlp_DBGFInfoDeregister: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1082
1083	return rc;
1084	}
1085
1086
1087	/** @interface_method_impl{PDMDRVHLP,pfnSTAMRegister} */
1088	static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegister(PPDMDRVINS pDrvIns, void pvSample, STAMTYPE enmType, const char pszName, STAMUNIT enmUnit, const char *pszDesc)
1089	{
1090	PDMDRV_ASSERT_DRVINS(pDrvIns);
1091	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1092
1093	STAM_REG(pDrvIns->Internal.s.pVMR3, pvSample, enmType, pszName, enmUnit, pszDesc);
1094	/** @todo track the samples so they can be dumped & deregistered when the driver instance is destroyed.
1095	* For now we just have to be careful not to use this call for drivers which can be unloaded. */
1096	}
1097
1098
1099	/** @interface_method_impl{PDMDRVHLP,pfnSTAMRegisterF} */
1100	static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegisterF(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
1101	STAMUNIT enmUnit, const char pszDesc, const char pszName, ...)
1102	{
1103	PDMDRV_ASSERT_DRVINS(pDrvIns);
1104	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1105
1106	va_list args;
1107	va_start(args, pszName);
1108	int rc = STAMR3RegisterV(pDrvIns->Internal.s.pVMR3, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
1109	va_end(args);
1110	AssertRC(rc);
1111	}
1112
1113
1114	/** @interface_method_impl{PDMDRVHLP,pfnSTAMRegisterV} */
1115	static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegisterV(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
1116	STAMUNIT enmUnit, const char pszDesc, const char pszName, va_list args)
1117	{
1118	PDMDRV_ASSERT_DRVINS(pDrvIns);
1119	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1120
1121	int rc = STAMR3RegisterV(pDrvIns->Internal.s.pVMR3, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
1122	AssertRC(rc);
1123	}
1124
1125
1126	/** @interface_method_impl{PDMDRVHLP,pfnSTAMDeregister} */
1127	static DECLCALLBACK(int) pdmR3DrvHlp_STAMDeregister(PPDMDRVINS pDrvIns, void *pvSample)
1128	{
1129	PDMDRV_ASSERT_DRVINS(pDrvIns);
1130	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1131
1132	int rc = STAMR3DeregisterU(pDrvIns->Internal.s.pVMR3->pUVM, pvSample);
1133	AssertRC(rc);
1134	return rc;
1135	}
1136
1137
1138	/** @interface_method_impl{PDMDRVHLP,pfnSUPCallVMMR0Ex} */
1139	static DECLCALLBACK(int) pdmR3DrvHlp_SUPCallVMMR0Ex(PPDMDRVINS pDrvIns, unsigned uOperation, void *pvArg, unsigned cbArg)
1140	{
1141	PDMDRV_ASSERT_DRVINS(pDrvIns);
1142	LogFlow(("pdmR3DrvHlp_SSMCallVMMR0Ex: caller='%s'/%d: uOperation=%u pvArg=%p cbArg=%d\n",
1143	pDrvIns->pReg->szName, pDrvIns->iInstance, uOperation, pvArg, cbArg));
1144	int rc;
1145	if ( uOperation >= VMMR0_DO_SRV_START
1146	&& uOperation < VMMR0_DO_SRV_END)
1147	rc = SUPR3CallVMMR0Ex(pDrvIns->Internal.s.pVMR3->pVMR0, NIL_VMCPUID, uOperation, 0, (PSUPVMMR0REQHDR)pvArg);
1148	else
1149	{
1150	AssertMsgFailed(("Invalid uOperation=%u\n", uOperation));
1151	rc = VERR_INVALID_PARAMETER;
1152	}
1153
1154	LogFlow(("pdmR3DrvHlp_SUPCallVMMR0Ex: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1155	return rc;
1156	}
1157
1158
1159	/** @interface_method_impl{PDMDRVHLP,pfnUSBRegisterHub} */
1160	static DECLCALLBACK(int) pdmR3DrvHlp_USBRegisterHub(PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp)
1161	{
1162	PDMDRV_ASSERT_DRVINS(pDrvIns);
1163	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1164	LogFlow(("pdmR3DrvHlp_USBRegisterHub: caller='%s'/%d: fVersions=%#x cPorts=%#x pUsbHubReg=%p ppUsbHubHlp=%p\n",
1165	pDrvIns->pReg->szName, pDrvIns->iInstance, fVersions, cPorts, pUsbHubReg, ppUsbHubHlp));
1166
1167	#ifdef VBOX_WITH_USB
1168	int rc = pdmR3UsbRegisterHub(pDrvIns->Internal.s.pVMR3, pDrvIns, fVersions, cPorts, pUsbHubReg, ppUsbHubHlp);
1169	#else
1170	int rc = VERR_NOT_SUPPORTED;
1171	#endif
1172
1173	LogFlow(("pdmR3DrvHlp_USBRegisterHub: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1174	return rc;
1175	}
1176
1177
1178	/** @interface_method_impl{PDMDRVHLP,pfnSetAsyncNotification} */
1179	static DECLCALLBACK(int) pdmR3DrvHlp_SetAsyncNotification(PPDMDRVINS pDrvIns, PFNPDMDRVASYNCNOTIFY pfnAsyncNotify)
1180	{
1181	PDMDRV_ASSERT_DRVINS(pDrvIns);
1182	VM_ASSERT_EMT0(pDrvIns->Internal.s.pVMR3);
1183	LogFlow(("pdmR3DrvHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, pfnAsyncNotify));
1184
1185	int rc = VINF_SUCCESS;
1186	AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
1187	AssertStmt(!pDrvIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
1188	AssertStmt(pDrvIns->Internal.s.fVMSuspended \|\| pDrvIns->Internal.s.fVMReset, rc = VERR_WRONG_ORDER);
1189	VMSTATE enmVMState = VMR3GetState(pDrvIns->Internal.s.pVMR3);
1190	AssertStmt( enmVMState == VMSTATE_SUSPENDING
1191	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS
1192	\|\| enmVMState == VMSTATE_SUSPENDING_LS
1193	\|\| enmVMState == VMSTATE_RESETTING
1194	\|\| enmVMState == VMSTATE_RESETTING_LS
1195	\|\| enmVMState == VMSTATE_POWERING_OFF
1196	\|\| enmVMState == VMSTATE_POWERING_OFF_LS,
1197	rc = VERR_INVALID_STATE);
1198
1199	if (RT_SUCCESS(rc))
1200	pDrvIns->Internal.s.pfnAsyncNotify = pfnAsyncNotify;
1201
1202	LogFlow(("pdmR3DrvHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
1203	return rc;
1204	}
1205
1206
1207	/** @interface_method_impl{PDMDRVHLP,pfnAsyncNotificationCompleted} */
1208	static DECLCALLBACK(void) pdmR3DrvHlp_AsyncNotificationCompleted(PPDMDRVINS pDrvIns)
1209	{
1210	PDMDRV_ASSERT_DRVINS(pDrvIns);
1211	PVM pVM = pDrvIns->Internal.s.pVMR3;
1212
1213	VMSTATE enmVMState = VMR3GetState(pVM);
1214	if ( enmVMState == VMSTATE_SUSPENDING
1215	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS
1216	\|\| enmVMState == VMSTATE_SUSPENDING_LS
1217	\|\| enmVMState == VMSTATE_RESETTING
1218	\|\| enmVMState == VMSTATE_RESETTING_LS
1219	\|\| enmVMState == VMSTATE_POWERING_OFF
1220	\|\| enmVMState == VMSTATE_POWERING_OFF_LS)
1221	{
1222	LogFlow(("pdmR3DrvHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
1223	VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
1224	}
1225	else
1226	LogFlow(("pdmR3DrvHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDrvIns->pReg->szName, pDrvIns->iInstance, enmVMState));
1227	}
1228
1229
1230	/** @interface_method_impl{PDMDRVHLP,pfnThreadCreate} */
1231	static DECLCALLBACK(int) pdmR3DrvHlp_ThreadCreate(PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
1232	PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
1233	{
1234	PDMDRV_ASSERT_DRVINS(pDrvIns);
1235	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1236	LogFlow(("pdmR3DrvHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
1237	pDrvIns->pReg->szName, pDrvIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
1238
1239	int rc = pdmR3ThreadCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
1240
1241	LogFlow(("pdmR3DrvHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDrvIns->pReg->szName, pDrvIns->iInstance,
1242	rc, *ppThread));
1243	return rc;
1244	}
1245
1246
1247	/** @interface_method_impl{PDMDRVHLP,pfnAsyncCompletionTemplateCreate} */
1248	static DECLCALLBACK(int) pdmR3DrvHlp_AsyncCompletionTemplateCreate(PPDMDRVINS pDrvIns, PPPDMASYNCCOMPLETIONTEMPLATE ppTemplate,
1249	PFNPDMASYNCCOMPLETEDRV pfnCompleted, void *pvTemplateUser,
1250	const char *pszDesc)
1251	{
1252	PDMDRV_ASSERT_DRVINS(pDrvIns);
1253	LogFlow(("pdmR3DrvHlp_AsyncCompletionTemplateCreate: caller='%s'/%d: ppTemplate=%p pfnCompleted=%p pszDesc=%p:{%s}\n",
1254	pDrvIns->pReg->szName, pDrvIns->iInstance, ppTemplate, pfnCompleted, pszDesc, pszDesc));
1255
1256	int rc = PDMR3AsyncCompletionTemplateCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, ppTemplate, pfnCompleted, pvTemplateUser, pszDesc);
1257
1258	LogFlow(("pdmR3DrvHlp_AsyncCompletionTemplateCreate: caller='%s'/%d: returns %Rrc *ppThread=%p\n", pDrvIns->pReg->szName,
1259	pDrvIns->iInstance, rc, *ppTemplate));
1260	return rc;
1261	}
1262
1263
1264	/** @interface_method_impl{PDMDRVHLP,pfnLdrGetRCInterfaceSymbols} */
1265	static DECLCALLBACK(int) pdmR3DrvHlp_LdrGetRCInterfaceSymbols(PPDMDRVINS pDrvIns, void *pvInterface, size_t cbInterface,
1266	const char pszSymPrefix, const char pszSymList)
1267	{
1268	PDMDRV_ASSERT_DRVINS(pDrvIns);
1269	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1270	LogFlow(("pdmR3DrvHlp_LdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
1271	pDrvIns->pReg->szName, pDrvIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
1272
1273	int rc;
1274	if ( strncmp(pszSymPrefix, "drv", 3) == 0
1275	&& RTStrIStr(pszSymPrefix + 3, pDrvIns->pReg->szName) != NULL)
1276	{
1277	if (pDrvIns->pReg->fFlags & PDM_DRVREG_FLAGS_RC)
1278	rc = PDMR3LdrGetInterfaceSymbols(pDrvIns->Internal.s.pVMR3,
1279	pvInterface, cbInterface,
1280	pDrvIns->pReg->szRCMod, pDrvIns->Internal.s.pDrv->pszRCSearchPath,
1281	pszSymPrefix, pszSymList,
1282	false /fRing0OrRC/);
1283	else
1284	{
1285	AssertMsgFailed(("Not a raw-mode enabled driver\n"));
1286	rc = VERR_PERMISSION_DENIED;
1287	}
1288	}
1289	else
1290	{
1291	AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'drv' and contain the driver name!\n",
1292	pszSymPrefix, pDrvIns->pReg->szName));
1293	rc = VERR_INVALID_NAME;
1294	}
1295
1296	LogFlow(("pdmR3DrvHlp_LdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName,
1297	pDrvIns->iInstance, rc));
1298	return rc;
1299	}
1300
1301
1302	/** @interface_method_impl{PDMDRVHLP,pfnLdrGetR0InterfaceSymbols} */
1303	static DECLCALLBACK(int) pdmR3DrvHlp_LdrGetR0InterfaceSymbols(PPDMDRVINS pDrvIns, void *pvInterface, size_t cbInterface,
1304	const char pszSymPrefix, const char pszSymList)
1305	{
1306	PDMDRV_ASSERT_DRVINS(pDrvIns);
1307	VM_ASSERT_EMT(pDrvIns->Internal.s.pVMR3);
1308	LogFlow(("pdmR3DrvHlp_LdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
1309	pDrvIns->pReg->szName, pDrvIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
1310
1311	int rc;
1312	if ( strncmp(pszSymPrefix, "drv", 3) == 0
1313	&& RTStrIStr(pszSymPrefix + 3, pDrvIns->pReg->szName) != NULL)
1314	{
1315	if (pDrvIns->pReg->fFlags & PDM_DRVREG_FLAGS_R0)
1316	rc = PDMR3LdrGetInterfaceSymbols(pDrvIns->Internal.s.pVMR3,
1317	pvInterface, cbInterface,
1318	pDrvIns->pReg->szR0Mod, pDrvIns->Internal.s.pDrv->pszR0SearchPath,
1319	pszSymPrefix, pszSymList,
1320	true /fRing0OrRC/);
1321	else
1322	{
1323	AssertMsgFailed(("Not a ring-0 enabled driver\n"));
1324	rc = VERR_PERMISSION_DENIED;
1325	}
1326	}
1327	else
1328	{
1329	AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'drv' and contain the driver name!\n",
1330	pszSymPrefix, pDrvIns->pReg->szName));
1331	rc = VERR_INVALID_NAME;
1332	}
1333
1334	LogFlow(("pdmR3DrvHlp_LdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName,
1335	pDrvIns->iInstance, rc));
1336	return rc;
1337	}
1338
1339
1340	/** @interface_method_impl{PDMDRVHLP,pfnCritSectInit} */
1341	static DECLCALLBACK(int) pdmR3DrvHlp_CritSectInit(PPDMDRVINS pDrvIns, PPDMCRITSECT pCritSect,
1342	RT_SRC_POS_DECL, const char *pszName)
1343	{
1344	PDMDRV_ASSERT_DRVINS(pDrvIns);
1345	PVM pVM = pDrvIns->Internal.s.pVMR3;
1346	VM_ASSERT_EMT(pVM);
1347	LogFlow(("pdmR3DrvHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszName=%s\n",
1348	pDrvIns->pReg->szName, pDrvIns->iInstance, pCritSect, pszName));
1349
1350	int rc = pdmR3CritSectInitDriver(pVM, pDrvIns, pCritSect, RT_SRC_POS_ARGS, "%s_%u", pszName, pDrvIns->iInstance);
1351
1352	LogFlow(("pdmR3DrvHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName,
1353	pDrvIns->iInstance, rc));
1354	return rc;
1355	}
1356
1357
1358	/** @interface_method_impl{PDMDRVHLP,pfnCallR0} */
1359	static DECLCALLBACK(int) pdmR3DrvHlp_CallR0(PPDMDRVINS pDrvIns, uint32_t uOperation, uint64_t u64Arg)
1360	{
1361	PDMDRV_ASSERT_DRVINS(pDrvIns);
1362	PVM pVM = pDrvIns->Internal.s.pVMR3;
1363	LogFlow(("pdmR3DrvHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
1364	pDrvIns->pReg->szName, pDrvIns->iInstance, uOperation, u64Arg));
1365
1366	/*
1367	* Lazy resolve the ring-0 entry point.
1368	*/
1369	int rc = VINF_SUCCESS;
1370	PFNPDMDRVREQHANDLERR0 pfnReqHandlerR0 = pDrvIns->Internal.s.pfnReqHandlerR0;
1371	if (RT_UNLIKELY(pfnReqHandlerR0 == NIL_RTR0PTR))
1372	{
1373	if (pDrvIns->pReg->fFlags & PDM_DRVREG_FLAGS_R0)
1374	{
1375	char szSymbol[ sizeof("drvR0") + sizeof(pDrvIns->pReg->szName) + sizeof("ReqHandler")];
1376	strcat(strcat(strcpy(szSymbol, "drvR0"), pDrvIns->pReg->szName), "ReqHandler");
1377	szSymbol[sizeof("drvR0") - 1] = RT_C_TO_UPPER(szSymbol[sizeof("drvR0") - 1]);
1378
1379	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDrvIns->pReg->szR0Mod, pDrvIns->Internal.s.pDrv->pszR0SearchPath, szSymbol,
1380	&pfnReqHandlerR0);
1381	if (RT_SUCCESS(rc))
1382	pDrvIns->Internal.s.pfnReqHandlerR0 = pfnReqHandlerR0;
1383	else
1384	pfnReqHandlerR0 = NIL_RTR0PTR;
1385	}
1386	else
1387	rc = VERR_ACCESS_DENIED;
1388	}
1389	if (RT_LIKELY(pfnReqHandlerR0 != NIL_RTR0PTR))
1390	{
1391	/*
1392	* Make the ring-0 call.
1393	*/
1394	PDMDRIVERCALLREQHANDLERREQ Req;
1395	Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1396	Req.Hdr.cbReq = sizeof(Req);
1397	Req.pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
1398	Req.uOperation = uOperation;
1399	Req.u32Alignment = 0;
1400	Req.u64Arg = u64Arg;
1401	rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER, 0, &Req.Hdr);
1402	}
1403
1404	LogFlow(("pdmR3DrvHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName,
1405	pDrvIns->iInstance, rc));
1406	return rc;
1407	}
1408
1409
1410	/** @interface_method_impl{PDMDRVHLP,pfnFTSetCheckpoint} */
1411	static DECLCALLBACK(int) pdmR3DrvHlp_FTSetCheckpoint(PPDMDRVINS pDrvIns, FTMCHECKPOINTTYPE enmType)
1412	{
1413	PDMDRV_ASSERT_DRVINS(pDrvIns);
1414	return FTMSetCheckpoint(pDrvIns->Internal.s.pVMR3, enmType);
1415	}
1416
1417
1418	/** @interface_method_impl{PDMDRVHLP,pfnBlkCacheRetain} */
1419	static DECLCALLBACK(int) pdmR3DrvHlp_BlkCacheRetain(PPDMDRVINS pDrvIns, PPPDMBLKCACHE ppBlkCache,
1420	PFNPDMBLKCACHEXFERCOMPLETEDRV pfnXferComplete,
1421	PFNPDMBLKCACHEXFERENQUEUEDRV pfnXferEnqueue,
1422	const char *pcszId)
1423	{
1424	PDMDRV_ASSERT_DRVINS(pDrvIns);
1425	return PDMR3BlkCacheRetainDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, ppBlkCache,
1426	pfnXferComplete, pfnXferEnqueue, pcszId);
1427	}
1428
1429
1430	/**
1431	* The driver helper structure.
1432	*/
1433	const PDMDRVHLPR3 g_pdmR3DrvHlp =
1434	{
1435	PDM_DRVHLPR3_VERSION,
1436	pdmR3DrvHlp_Attach,
1437	pdmR3DrvHlp_Detach,
1438	pdmR3DrvHlp_DetachSelf,
1439	pdmR3DrvHlp_MountPrepare,
1440	pdmR3DrvHlp_AssertEMT,
1441	pdmR3DrvHlp_AssertOther,
1442	pdmR3DrvHlp_VMSetError,
1443	pdmR3DrvHlp_VMSetErrorV,
1444	pdmR3DrvHlp_VMSetRuntimeError,
1445	pdmR3DrvHlp_VMSetRuntimeErrorV,
1446	pdmR3DrvHlp_VMState,
1447	pdmR3DrvHlp_VMTeleportedAndNotFullyResumedYet,
1448	pdmR3DrvHlp_GetSupDrvSession,
1449	pdmR3DrvHlp_QueueCreate,
1450	pdmR3DrvHlp_TMGetVirtualFreq,
1451	pdmR3DrvHlp_TMGetVirtualTime,
1452	pdmR3DrvHlp_TMTimerCreate,
1453	pdmR3DrvHlp_SSMRegister,
1454	pdmR3DrvHlp_SSMDeregister,
1455	pdmR3DrvHlp_DBGFInfoRegister,
1456	pdmR3DrvHlp_DBGFInfoDeregister,
1457	pdmR3DrvHlp_STAMRegister,
1458	pdmR3DrvHlp_STAMRegisterF,
1459	pdmR3DrvHlp_STAMRegisterV,
1460	pdmR3DrvHlp_STAMDeregister,
1461	pdmR3DrvHlp_SUPCallVMMR0Ex,
1462	pdmR3DrvHlp_USBRegisterHub,
1463	pdmR3DrvHlp_SetAsyncNotification,
1464	pdmR3DrvHlp_AsyncNotificationCompleted,
1465	pdmR3DrvHlp_ThreadCreate,
1466	pdmR3DrvHlp_AsyncCompletionTemplateCreate,
1467	pdmR3DrvHlp_LdrGetRCInterfaceSymbols,
1468	pdmR3DrvHlp_LdrGetR0InterfaceSymbols,
1469	pdmR3DrvHlp_CritSectInit,
1470	pdmR3DrvHlp_CallR0,
1471	pdmR3DrvHlp_FTSetCheckpoint,
1472	pdmR3DrvHlp_BlkCacheRetain,
1473	PDM_DRVHLPR3_VERSION /* u32TheEnd */
1474	};
1475
1476	/** @} */

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

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMDriver.cpp@ 35333

Download in other formats: