VirtualBox

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

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

This is where I meant.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 41.1 KB
Line 
1/* $Id: PDMDriver.cpp 6182 2007-12-23 13:30:42Z vboxsync $ */
2/** @file
3 * PDM - Pluggable Device and Driver Manager, Driver parts.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.215389.xyz. 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/thread.h>
36#include <iprt/string.h>
37#include <iprt/asm.h>
38#include <iprt/alloc.h>
39#include <iprt/path.h>
40
41
42/*******************************************************************************
43* Structures and Typedefs *
44*******************************************************************************/
45/**
46 * Internal callback structure pointer.
47 *
48 * The main purpose is to define the extra data we associate
49 * with PDMDRVREGCB so we can find the VM instance and so on.
50 */
51typedef struct PDMDRVREGCBINT
52{
53 /** The callback structure. */
54 PDMDRVREGCB Core;
55 /** A bit of padding. */
56 uint32_t u32[4];
57 /** VM Handle. */
58 PVM pVM;
59} PDMDRVREGCBINT, *PPDMDRVREGCBINT;
60typedef const PDMDRVREGCBINT *PCPDMDRVREGCBINT;
61
62
63/*******************************************************************************
64* Internal Functions *
65*******************************************************************************/
66/** @name Driver Helpers
67 * @{
68 */
69static DECLCALLBACK(int) pdmR3DrvHlp_Attach(PPDMDRVINS pDrvIns, PPDMIBASE *ppBaseInterface);
70static DECLCALLBACK(int) pdmR3DrvHlp_Detach(PPDMDRVINS pDrvIns);
71static DECLCALLBACK(int) pdmR3DrvHlp_DetachSelf(PPDMDRVINS pDrvIns);
72static DECLCALLBACK(int) pdmR3DrvHlp_MountPrepare(PPDMDRVINS pDrvIns, const char *pszFilename, const char *pszCoreDriver);
73static DECLCALLBACK(int) pdmR3DrvHlp_VMSetError(PPDMDRVINS pDrvIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...);
74static DECLCALLBACK(int) pdmR3DrvHlp_VMSetErrorV(PPDMDRVINS pDrvIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va);
75static DECLCALLBACK(int) pdmR3DrvHlp_VMSetRuntimeError(PPDMDRVINS pDrvIns, bool fFatal, const char *pszErrorID, const char *pszFormat, ...);
76static DECLCALLBACK(int) pdmR3DrvHlp_VMSetRuntimeErrorV(PPDMDRVINS pDrvIns, bool fFatal, const char *pszErrorID, const char *pszFormat, va_list va);
77static DECLCALLBACK(bool) pdmR3DrvHlp_AssertEMT(PPDMDRVINS pDrvIns, const char *pszFile, unsigned iLine, const char *pszFunction);
78static DECLCALLBACK(bool) pdmR3DrvHlp_AssertOther(PPDMDRVINS pDrvIns, const char *pszFile, unsigned iLine, const char *pszFunction);
79static DECLCALLBACK(int) pdmR3DrvHlp_PDMQueueCreate(PPDMDRVINS pDrvIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval, PFNPDMQUEUEDRV pfnCallback, PPDMQUEUE *ppQueue);
80static DECLCALLBACK(int) pdmR3DrvHlp_PDMPollerRegister(PPDMDRVINS pDrvIns, PFNPDMDRVPOLLER pfnPoller);
81static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualFreq(PPDMDRVINS pDrvIns);
82static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualTime(PPDMDRVINS pDrvIns);
83static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer);
84static DECLCALLBACK(int) pdmR3DrvHlp_SSMRegister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
85 PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
86 PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone);
87static DECLCALLBACK(int) pdmR3DrvHlp_SSMDeregister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance);
88static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegister(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, const char *pszName, STAMUNIT enmUnit, const char *pszDesc);
89static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegisterF(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit, const char *pszDesc, const char *pszName, ...);
90static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegisterV(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args);
91static DECLCALLBACK(int) pdmR3DrvHlp_SUPCallVMMR0Ex(PPDMDRVINS pDrvIns, unsigned uOperation, void *pvArg, unsigned cbArg);
92static DECLCALLBACK(int) pdmR3DrvHlp_USBRegisterHub(PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp);
93static DECLCALLBACK(int) pdmR3DrvHlp_PDMThreadCreate(PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
94 PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
95
96/** @def PDMDRV_ASSERT_DRVINS
97 * Asserts the validity of the driver instance.
98 */
99#ifdef VBOX_STRICT
100# define PDMDRV_ASSERT_DRVINS(pDrvIns) do { Assert(pDrvIns); Assert(pDrvIns->u32Version == PDM_DRVINS_VERSION); Assert(pDrvIns->pvInstanceData == (void *)&pDrvIns->achInstanceData[0]); } while (0)
101#else
102# define PDMDRV_ASSERT_DRVINS(pDrvIns) do { } while (0)
103#endif
104/** @} */
105
106static DECLCALLBACK(int) pdmR3DrvRegister(PCPDMDRVREGCB pCallbacks, PCPDMDRVREG pDrvReg);
107static int pdmR3DrvLoad(PVM pVM, PPDMDRVREGCBINT pRegCB, const char *pszFilename, const char *pszName);
108
109
110/*******************************************************************************
111* Global Variables *
112*******************************************************************************/
113/**
114 * The driver helper structure.
115 */
116const PDMDRVHLP g_pdmR3DrvHlp =
117{
118 PDM_DRVHLP_VERSION,
119 pdmR3DrvHlp_Attach,
120 pdmR3DrvHlp_Detach,
121 pdmR3DrvHlp_DetachSelf,
122 pdmR3DrvHlp_MountPrepare,
123 pdmR3DrvHlp_AssertEMT,
124 pdmR3DrvHlp_AssertOther,
125 pdmR3DrvHlp_VMSetError,
126 pdmR3DrvHlp_VMSetErrorV,
127 pdmR3DrvHlp_VMSetRuntimeError,
128 pdmR3DrvHlp_VMSetRuntimeErrorV,
129 pdmR3DrvHlp_PDMQueueCreate,
130 pdmR3DrvHlp_PDMPollerRegister,
131 pdmR3DrvHlp_TMGetVirtualFreq,
132 pdmR3DrvHlp_TMGetVirtualTime,
133 pdmR3DrvHlp_TMTimerCreate,
134 pdmR3DrvHlp_SSMRegister,
135 pdmR3DrvHlp_SSMDeregister,
136 pdmR3DrvHlp_STAMRegister,
137 pdmR3DrvHlp_STAMRegisterF,
138 pdmR3DrvHlp_STAMRegisterV,
139 pdmR3DrvHlp_SUPCallVMMR0Ex,
140 pdmR3DrvHlp_USBRegisterHub,
141 pdmR3DrvHlp_PDMThreadCreate,
142 /** @todo add PDMAsyncCompletionTemplateCreate wrapper here. */
143 0 /* the end */
144};
145
146
147/**
148 * Register external drivers
149 *
150 * @returns VBox status code.
151 * @param pVM The VM to operate on.
152 * @param pfnCallback Driver registration callback
153 */
154PDMR3DECL(int) PDMR3RegisterDrivers(PVM pVM, FNPDMVBOXDRIVERSREGISTER pfnCallback)
155{
156 /*
157 * The registration callbacks.
158 */
159 PDMDRVREGCBINT RegCB;
160 RegCB.Core.u32Version = PDM_DRVREG_CB_VERSION;
161 RegCB.Core.pfnRegister = pdmR3DrvRegister;
162 RegCB.pVM = pVM;
163
164 int rc = pfnCallback(&RegCB.Core, VBOX_VERSION);
165 if (VBOX_FAILURE(rc))
166 AssertMsgFailed(("VBoxDriversRegister failed with rc=%Vrc\n"));
167
168 return rc;
169}
170
171/**
172 * This function will initialize the drivers for this VM instance.
173 *
174 * First of all this mean loading the builtin drivers and letting them
175 * register themselves. Beyond that any additional driver modules are
176 * loaded and called for registration.
177 *
178 * @returns VBox status code.
179 * @param pVM VM Handle.
180 */
181int pdmR3DrvInit(PVM pVM)
182{
183 LogFlow(("pdmR3DrvInit:\n"));
184
185 AssertRelease(!(RT_OFFSETOF(PDMDRVINS, achInstanceData) & 15));
186 PPDMDRVINS pDrvInsAssert;
187 AssertRelease(sizeof(pDrvInsAssert->Internal.s) <= sizeof(pDrvInsAssert->Internal.padding));
188
189 /*
190 * The registration callbacks.
191 */
192 PDMDRVREGCBINT RegCB;
193 RegCB.Core.u32Version = PDM_DRVREG_CB_VERSION;
194 RegCB.Core.pfnRegister = pdmR3DrvRegister;
195 RegCB.pVM = pVM;
196
197 /*
198 * Load the builtin module
199 */
200 PCFGMNODE pDriversNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM/Drivers");
201 bool fLoadBuiltin;
202 int rc = CFGMR3QueryBool(pDriversNode, "LoadBuiltin", &fLoadBuiltin);
203 if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
204 fLoadBuiltin = true;
205 else if (VBOX_FAILURE(rc))
206 {
207 AssertMsgFailed(("Configuration error: Querying boolean \"LoadBuiltin\" failed with %Vrc\n", rc));
208 return rc;
209 }
210 if (fLoadBuiltin)
211 {
212 /* make filename */
213 char *pszFilename = pdmR3FileR3("VBoxDD", /*fShared=*/true);
214 if (!pszFilename)
215 return VERR_NO_TMP_MEMORY;
216 rc = pdmR3DrvLoad(pVM, &RegCB, pszFilename, "VBoxDD");
217 RTMemTmpFree(pszFilename);
218 if (VBOX_FAILURE(rc))
219 return rc;
220 }
221
222 /*
223 * Load additional driver modules.
224 */
225 for (PCFGMNODE pCur = CFGMR3GetFirstChild(pDriversNode); pCur; pCur = CFGMR3GetNextChild(pCur))
226 {
227 /*
228 * Get the name and path.
229 */
230 char szName[PDMMOD_NAME_LEN];
231 rc = CFGMR3GetName(pCur, &szName[0], sizeof(szName));
232 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
233 {
234 AssertMsgFailed(("configuration error: The module name is too long, cchName=%d.\n", CFGMR3GetNameLen(pCur)));
235 return VERR_PDM_MODULE_NAME_TOO_LONG;
236 }
237 else if (VBOX_FAILURE(rc))
238 {
239 AssertMsgFailed(("CFGMR3GetName -> %Vrc.\n", rc));
240 return rc;
241 }
242
243 /* the path is optional, if no path the module name + path is used. */
244 char szFilename[RTPATH_MAX];
245 rc = CFGMR3QueryString(pCur, "Path", &szFilename[0], sizeof(szFilename));
246 if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
247 strcpy(szFilename, szName);
248 else if (VBOX_FAILURE(rc))
249 {
250 AssertMsgFailed(("configuration error: Failure to query the module path, rc=%Vrc.\n", rc));
251 return rc;
252 }
253
254 /* prepend path? */
255 if (!RTPathHavePath(szFilename))
256 {
257 char *psz = pdmR3FileR3(szFilename);
258 if (!psz)
259 return VERR_NO_TMP_MEMORY;
260 size_t cch = strlen(psz) + 1;
261 if (cch > sizeof(szFilename))
262 {
263 RTMemTmpFree(psz);
264 AssertMsgFailed(("Filename too long! cch=%d '%s'\n", cch, psz));
265 return VERR_FILENAME_TOO_LONG;
266 }
267 memcpy(szFilename, psz, cch);
268 RTMemTmpFree(psz);
269 }
270
271 /*
272 * Load the module and register it's drivers.
273 */
274 rc = pdmR3DrvLoad(pVM, &RegCB, szFilename, szName);
275 if (VBOX_FAILURE(rc))
276 return rc;
277 }
278
279 LogFlow(("pdmR3DrvInit: returns VINF_SUCCESS\n"));
280 return VINF_SUCCESS;
281}
282
283
284/**
285 * Loads one driver module and call the registration entry point.
286 *
287 * @returns VBox status code.
288 * @param pVM VM handle.
289 * @param pRegCB The registration callback stuff.
290 * @param pszFilename Module filename.
291 * @param pszName Module name.
292 */
293static int pdmR3DrvLoad(PVM pVM, PPDMDRVREGCBINT pRegCB, const char *pszFilename, const char *pszName)
294{
295 /*
296 * Load it.
297 */
298 int rc = pdmR3LoadR3(pVM, pszFilename, pszName);
299 if (VBOX_SUCCESS(rc))
300 {
301 /*
302 * Get the registration export and call it.
303 */
304 FNPDMVBOXDRIVERSREGISTER *pfnVBoxDriversRegister;
305 rc = PDMR3GetSymbolR3(pVM, pszName, "VBoxDriversRegister", (void **)&pfnVBoxDriversRegister);
306 if (VBOX_SUCCESS(rc))
307 {
308 Log(("PDM: Calling VBoxDriversRegister (%p) of %s (%s)\n", pfnVBoxDriversRegister, pszName, pszFilename));
309 rc = pfnVBoxDriversRegister(&pRegCB->Core, VBOX_VERSION);
310 if (VBOX_SUCCESS(rc))
311 Log(("PDM: Successfully loaded driver module %s (%s).\n", pszName, pszFilename));
312 else
313 AssertMsgFailed(("VBoxDriversRegister failed with rc=%Vrc\n"));
314 }
315 else
316 {
317 AssertMsgFailed(("Failed to locate 'VBoxDriversRegister' in %s (%s) rc=%Vrc\n", pszName, pszFilename, rc));
318 if (rc == VERR_SYMBOL_NOT_FOUND)
319 rc = VERR_PDM_NO_REGISTRATION_EXPORT;
320 }
321 }
322 else
323 AssertMsgFailed(("Failed to load %s (%s) rc=%Vrc!\n", pszName, pszFilename, rc));
324 return rc;
325}
326
327
328/** @copydoc PDMDRVREGCB::pfnRegister */
329static DECLCALLBACK(int) pdmR3DrvRegister(PCPDMDRVREGCB pCallbacks, PCPDMDRVREG pDrvReg)
330{
331 /*
332 * Validate the registration structure.
333 */
334 Assert(pDrvReg);
335 if (pDrvReg->u32Version != PDM_DRVREG_VERSION)
336 {
337 AssertMsgFailed(("Unknown struct version %#x!\n", pDrvReg->u32Version));
338 return VERR_PDM_UNKNOWN_DRVREG_VERSION;
339 }
340 if ( !pDrvReg->szDriverName[0]
341 || strlen(pDrvReg->szDriverName) >= sizeof(pDrvReg->szDriverName))
342 {
343 AssertMsgFailed(("Invalid name '%s'\n", pDrvReg->szDriverName));
344 return VERR_PDM_INVALID_DRIVER_REGISTRATION;
345 }
346 if ((pDrvReg->fFlags & PDM_DRVREG_FLAGS_HOST_BITS_MASK) != PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT)
347 {
348 AssertMsgFailed(("Invalid host bits flags! fFlags=%#x (Driver %s)\n", pDrvReg->fFlags, pDrvReg->szDriverName));
349 return VERR_PDM_INVALID_DRIVER_HOST_BITS;
350 }
351 if (pDrvReg->cMaxInstances <= 0)
352 {
353 AssertMsgFailed(("Max instances %u! (Driver %s)\n", pDrvReg->cMaxInstances, pDrvReg->szDriverName));
354 return VERR_PDM_INVALID_DRIVER_REGISTRATION;
355 }
356 if (pDrvReg->cbInstance > _1M)
357 {
358 AssertMsgFailed(("Instance size above 1MB, %d bytes! (Driver %s)\n", pDrvReg->cbInstance, pDrvReg->szDriverName));
359 return VERR_PDM_INVALID_DRIVER_REGISTRATION;
360 }
361 if (!pDrvReg->pfnConstruct)
362 {
363 AssertMsgFailed(("No constructore! (Driver %s)\n", pDrvReg->szDriverName));
364 return VERR_PDM_INVALID_DRIVER_REGISTRATION;
365 }
366
367 /*
368 * Check for duplicate and find FIFO entry at the same time.
369 */
370 PCPDMDRVREGCBINT pRegCB = (PCPDMDRVREGCBINT)pCallbacks;
371 PPDMDRV pDrvPrev = NULL;
372 PPDMDRV pDrv = pRegCB->pVM->pdm.s.pDrvs;
373 for (; pDrv; pDrvPrev = pDrv, pDrv = pDrv->pNext)
374 {
375 if (!strcmp(pDrv->pDrvReg->szDriverName, pDrvReg->szDriverName))
376 {
377 AssertMsgFailed(("Driver '%s' already exists\n", pDrvReg->szDriverName));
378 return VERR_PDM_DRIVER_NAME_CLASH;
379 }
380 }
381
382 /*
383 * Allocate new driver structure and insert it into the list.
384 */
385 pDrv = (PPDMDRV)MMR3HeapAlloc(pRegCB->pVM, MM_TAG_PDM_DRIVER, sizeof(*pDrv));
386 if (pDrv)
387 {
388 pDrv->pNext = NULL;
389 pDrv->cInstances = 0;
390 pDrv->pDrvReg = pDrvReg;
391
392 if (pDrvPrev)
393 pDrvPrev->pNext = pDrv;
394 else
395 pRegCB->pVM->pdm.s.pDrvs = pDrv;
396 Log(("PDM: Registered driver '%s'\n", pDrvReg->szDriverName));
397 return VINF_SUCCESS;
398 }
399 return VERR_NO_MEMORY;
400}
401
402
403/**
404 * Lookups a driver structure by name.
405 * @internal
406 */
407PPDMDRV pdmR3DrvLookup(PVM pVM, const char *pszName)
408{
409 for (PPDMDRV pDrv = pVM->pdm.s.pDrvs; pDrv; pDrv = pDrv->pNext)
410 if (!strcmp(pDrv->pDrvReg->szDriverName, pszName))
411 return pDrv;
412 return NULL;
413}
414
415
416/**
417 * Detaches a driver from whatever it's attached to.
418 * This will of course lead to the destruction of the driver and all drivers below it in the chain.
419 *
420 * @returns VINF_SUCCESS
421 * @param pDrvIns The driver instance to detach.
422 */
423int pdmR3DrvDetach(PPDMDRVINS pDrvIns)
424{
425 PDMDRV_ASSERT_DRVINS(pDrvIns);
426 LogFlow(("pdmR3DrvDetach: pDrvIns=%p '%s'/%d\n", pDrvIns, pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance));
427 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
428
429 /*
430 * Check that we're not doing this recursively, that could have unwanted sideeffects!
431 */
432 if (pDrvIns->Internal.s.fDetaching)
433 {
434 AssertMsgFailed(("Recursive detach! '%s'/%d\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance));
435 return VINF_SUCCESS;
436 }
437
438 /*
439 * Check that we actually can detach this instance.
440 * The requirement is that the driver/device above has a detach method.
441 */
442 if (pDrvIns->Internal.s.pUp
443 ? !pDrvIns->Internal.s.pUp->pDrvReg->pfnDetach
444 : !pDrvIns->Internal.s.pLun->pDevIns->pDevReg->pfnDetach)
445 {
446 AssertMsgFailed(("Cannot detach driver instance because the driver/device above doesn't support it!\n"));
447 return VERR_PDM_DRIVER_DETACH_NOT_POSSIBLE;
448 }
449
450 /*
451 * Join paths with pdmR3DrvDestroyChain.
452 */
453 pdmR3DrvDestroyChain(pDrvIns);
454 return VINF_SUCCESS;
455}
456
457
458/**
459 * Destroys a driver chain starting with the specified driver.
460 *
461 * This is used when unplugging a device at run time.
462 *
463 * @param pDrvIns Pointer to the driver instance to start with.
464 */
465void pdmR3DrvDestroyChain(PPDMDRVINS pDrvIns)
466{
467 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
468
469 /*
470 * Detach the bottommost driver until we've detached pDrvIns.
471 */
472 pDrvIns->Internal.s.fDetaching = true;
473 PPDMDRVINS pCur;
474 do
475 {
476 /* find the driver to detach. */
477 pCur = pDrvIns;
478 while (pCur->Internal.s.pDown)
479 pCur = pCur->Internal.s.pDown;
480 LogFlow(("pdmR3DrvDetach: pCur=%p '%s'/%d\n", pCur, pCur->pDrvReg->szDriverName, pCur->iInstance));
481
482 /*
483 * Unlink it and notify parent.
484 */
485 pCur->Internal.s.fDetaching = true;
486
487 PPDMLUN pLun = pCur->Internal.s.pLun;
488 Assert(pLun->pBottom == pCur);
489 pLun->pBottom = pCur->Internal.s.pUp;
490
491 if (pCur->Internal.s.pUp)
492 {
493 /* driver parent */
494 PPDMDRVINS pParent = pCur->Internal.s.pUp;
495 pCur->Internal.s.pUp = NULL;
496 pParent->Internal.s.pDown = NULL;
497
498 if (pParent->pDrvReg->pfnDetach)
499 pParent->pDrvReg->pfnDetach(pParent);
500
501 pParent->pDownBase = NULL;
502 }
503 else
504 {
505 /* device parent */
506 Assert(pLun->pTop == pCur);
507 pLun->pTop = NULL;
508 if (pLun->pDevIns->pDevReg->pfnDetach)
509 pLun->pDevIns->pDevReg->pfnDetach(pLun->pDevIns, pLun->iLun);
510 }
511
512 /*
513 * Call destructor.
514 */
515 pCur->pUpBase = NULL;
516 if (pCur->pDrvReg->pfnDestruct)
517 pCur->pDrvReg->pfnDestruct(pCur);
518
519 /*
520 * Free all resources allocated by the driver.
521 */
522 /* Queues. */
523 int rc = PDMR3QueueDestroyDriver(pCur->Internal.s.pVM, pCur);
524 AssertRC(rc);
525 /* Timers. */
526 rc = TMR3TimerDestroyDriver(pCur->Internal.s.pVM, pCur);
527 AssertRC(rc);
528 /* SSM data units. */
529 rc = SSMR3DeregisterDriver(pCur->Internal.s.pVM, pCur, NULL, 0);
530 AssertRC(rc);
531 /* PDM threads. */
532 rc = pdmR3ThreadDestroyDriver(pCur->Internal.s.pVM, pCur);
533 AssertRC(rc);
534 /* Finally, the driver it self. */
535 ASMMemFill32(pCur, RT_OFFSETOF(PDMDRVINS, achInstanceData[pCur->pDrvReg->cbInstance]), 0xdeadd0d0);
536 MMR3HeapFree(pCur);
537
538 } while (pCur != pDrvIns);
539}
540
541
542/** @copydoc PDMDRVHLP::pfnAttach */
543static DECLCALLBACK(int) pdmR3DrvHlp_Attach(PPDMDRVINS pDrvIns, PPDMIBASE *ppBaseInterface)
544{
545 PDMDRV_ASSERT_DRVINS(pDrvIns);
546 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
547 LogFlow(("pdmR3DrvHlp_Attach: caller='%s'/%d:\n",
548 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance));
549
550 /*
551 * Check that there isn't anything attached already.
552 */
553 int rc;
554 if (!pDrvIns->Internal.s.pDown)
555 {
556 Assert(pDrvIns->Internal.s.pLun->pBottom == pDrvIns);
557
558 /*
559 * Get the attached driver configuration.
560 */
561 PCFGMNODE pNode = CFGMR3GetChild(pDrvIns->Internal.s.pCfgHandle, "AttachedDriver");
562 if (pNode)
563 {
564 char *pszName;
565 rc = CFGMR3QueryStringAlloc(pNode, "Driver", &pszName);
566 if (VBOX_SUCCESS(rc))
567 {
568 /*
569 * Find the driver and allocate instance data.
570 */
571 PVM pVM = pDrvIns->Internal.s.pVM;
572 PPDMDRV pDrv = pdmR3DrvLookup(pVM, pszName);
573 if (pDrv)
574 {
575 /* config node */
576 PCFGMNODE pConfigNode = CFGMR3GetChild(pNode, "Config");
577 if (!pConfigNode)
578 rc = CFGMR3InsertNode(pNode, "Config", &pConfigNode);
579 if (VBOX_SUCCESS(rc))
580 {
581 CFGMR3SetRestrictedRoot(pConfigNode);
582
583 size_t cb = RT_OFFSETOF(PDMDRVINS, achInstanceData[pDrv->pDrvReg->cbInstance]);
584 cb = RT_ALIGN_Z(cb, 16);
585 PPDMDRVINS pNew = (PPDMDRVINS)MMR3HeapAllocZ(pVM, MM_TAG_PDM_DRIVER, cb);
586 if (pNew)
587 {
588 /*
589 * Initialize the instance structure (declaration order).
590 */
591 pNew->u32Version = PDM_DRVINS_VERSION;
592 pNew->Internal.s.pUp = pDrvIns;
593 pNew->Internal.s.pDown = NULL;
594 pNew->Internal.s.pLun = pDrvIns->Internal.s.pLun;
595 pNew->Internal.s.pDrv = pDrv;
596 pNew->Internal.s.pVM = pVM;
597 pNew->Internal.s.fDetaching = false;
598 pNew->Internal.s.pCfgHandle = pNode;
599 pNew->pDrvHlp = &g_pdmR3DrvHlp;
600 pNew->pDrvReg = pDrv->pDrvReg;
601 pNew->pCfgHandle = pConfigNode;
602 pNew->iInstance = pDrv->cInstances++;
603 pNew->pUpBase = &pDrvIns->IBase; /* This ain't safe, you can calc the pDrvIns of the up/down driver! */
604 pNew->pDownBase = NULL;
605 pNew->IBase.pfnQueryInterface = NULL;
606 pNew->pvInstanceData = &pNew->achInstanceData[0];
607
608 /*
609 * Hook it onto the chain and call the constructor.
610 */
611 pDrvIns->Internal.s.pDown = pNew;
612 pDrvIns->Internal.s.pLun->pBottom = pNew;
613
614 Log(("PDM: Constructing driver '%s' instance %d...\n", pNew->pDrvReg->szDriverName, pNew->iInstance));
615 rc = pDrv->pDrvReg->pfnConstruct(pNew, pNew->pCfgHandle);
616 if (VBOX_SUCCESS(rc))
617 {
618 *ppBaseInterface = &pNew->IBase;
619 rc = VINF_SUCCESS;
620 }
621 else
622 {
623 /*
624 * Unlink and free the data.
625 */
626 Assert(pDrvIns->Internal.s.pLun->pBottom == pNew);
627 pDrvIns->Internal.s.pLun->pBottom = pDrvIns;
628 pDrvIns->Internal.s.pDown = NULL;
629 ASMMemFill32(pNew, cb, 0xdeadd0d0);
630 MMR3HeapFree(pNew);
631 pDrv->cInstances--;
632 }
633 }
634 else
635 {
636 AssertMsgFailed(("Failed to allocate %d bytes for instantiating driver '%s'\n", cb, pszName));
637 rc = VERR_NO_MEMORY;
638 }
639 }
640 else
641 AssertMsgFailed(("Failed to create Config node! rc=%Vrc\n", rc));
642 }
643 else
644 {
645 AssertMsgFailed(("Driver '%s' wasn't found!\n", pszName));
646 rc = VERR_PDM_DRIVER_NOT_FOUND;
647 }
648 MMR3HeapFree(pszName);
649 }
650 else
651 {
652 AssertMsgFailed(("Query for string value of \"Driver\" -> %Vrc\n", rc));
653 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
654 rc = VERR_PDM_CFG_MISSING_DRIVER_NAME;
655 }
656 }
657 else
658 rc = VERR_PDM_NO_ATTACHED_DRIVER;
659 }
660 else
661 {
662 AssertMsgFailed(("Already got a driver attached. The driver should keep track of such things!\n"));
663 rc = VERR_PDM_DRIVER_ALREADY_ATTACHED;
664 }
665
666 LogFlow(("pdmR3DrvHlp_Attach: caller='%s'/%d: return %Vrc\n",
667 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
668 return rc;
669}
670
671
672/** @copydoc PDMDRVHLP::pfnDetach */
673static DECLCALLBACK(int) pdmR3DrvHlp_Detach(PPDMDRVINS pDrvIns)
674{
675 PDMDRV_ASSERT_DRVINS(pDrvIns);
676 LogFlow(("pdmR3DrvHlp_Detach: caller='%s'/%d:\n",
677 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance));
678 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
679
680 /*
681 * Anything attached?
682 */
683 int rc;
684 if (pDrvIns->Internal.s.pDown)
685 {
686 rc = pdmR3DrvDetach(pDrvIns->Internal.s.pDown);
687 }
688 else
689 {
690 AssertMsgFailed(("Nothing attached!\n"));
691 rc = VERR_PDM_NO_DRIVER_ATTACHED;
692 }
693
694 LogFlow(("pdmR3DrvHlp_Detach: caller='%s'/%d: returns %Vrc\n",
695 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
696 return rc;
697}
698
699
700/** @copydoc PDMDRVHLP::pfnDetachSelf */
701static DECLCALLBACK(int) pdmR3DrvHlp_DetachSelf(PPDMDRVINS pDrvIns)
702{
703 PDMDRV_ASSERT_DRVINS(pDrvIns);
704 LogFlow(("pdmR3DrvHlp_DetachSelf: caller='%s'/%d:\n",
705 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance));
706 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
707
708 int rc = pdmR3DrvDetach(pDrvIns);
709
710 LogFlow(("pdmR3DrvHlp_Detach: returns %Vrc\n", rc)); /* pDrvIns is freed by now. */
711 return rc;
712}
713
714
715/** @copydoc PDMDRVHLP::pfnMountPrepare */
716static DECLCALLBACK(int) pdmR3DrvHlp_MountPrepare(PPDMDRVINS pDrvIns, const char *pszFilename, const char *pszCoreDriver)
717{
718 PDMDRV_ASSERT_DRVINS(pDrvIns);
719 LogFlow(("pdmR3DrvHlp_MountPrepare: caller='%s'/%d: pszFilename=%p:{%s} pszCoreDriver=%p:{%s}\n",
720 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pszFilename, pszFilename, pszCoreDriver, pszCoreDriver));
721 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
722
723 /*
724 * Do the caller have anything attached below itself?
725 */
726 if (pDrvIns->Internal.s.pDown)
727 {
728 AssertMsgFailed(("Cannot prepare a mount when something's attached to you!\n"));
729 return VERR_PDM_DRIVER_ALREADY_ATTACHED;
730 }
731
732 /*
733 * We're asked to prepare, so we'll start off by nuking the
734 * attached configuration tree.
735 */
736 PCFGMNODE pNode = CFGMR3GetChild(pDrvIns->Internal.s.pCfgHandle, "AttachedDriver");
737 if (pNode)
738 CFGMR3RemoveNode(pNode);
739
740 /*
741 * If there is no core driver, we'll have to probe for it.
742 */
743 if (!pszCoreDriver)
744 {
745 /** @todo implement image probing. */
746 AssertReleaseMsgFailed(("Not implemented!\n"));
747 return VERR_NOT_IMPLEMENTED;
748 }
749
750 /*
751 * Construct the basic attached driver configuration.
752 */
753 int rc = CFGMR3InsertNode(pDrvIns->Internal.s.pCfgHandle, "AttachedDriver", &pNode);
754 if (VBOX_SUCCESS(rc))
755 {
756 rc = CFGMR3InsertString(pNode, "Driver", pszCoreDriver);
757 if (VBOX_SUCCESS(rc))
758 {
759 PCFGMNODE pCfg;
760 rc = CFGMR3InsertNode(pNode, "Config", &pCfg);
761 if (VBOX_SUCCESS(rc))
762 {
763 rc = CFGMR3InsertString(pCfg, "Path", pszFilename);
764 if (VBOX_SUCCESS(rc))
765 {
766 LogFlow(("pdmR3DrvHlp_MountPrepare: caller='%s'/%d: returns %Vrc (Driver=%s)\n",
767 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc, pszCoreDriver));
768 return rc;
769 }
770 else
771 AssertMsgFailed(("Path string insert failed, rc=%Vrc\n", rc));
772 }
773 else
774 AssertMsgFailed(("Config node failed, rc=%Vrc\n", rc));
775 }
776 else
777 AssertMsgFailed(("Driver string insert failed, rc=%Vrc\n", rc));
778 CFGMR3RemoveNode(pNode);
779 }
780 else
781 AssertMsgFailed(("AttachedDriver node insert failed, rc=%Vrc\n", rc));
782
783 LogFlow(("pdmR3DrvHlp_MountPrepare: caller='%s'/%d: returns %Vrc\n",
784 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
785 return rc;
786}
787
788
789/** @copydoc PDMDRVHLP::pfnAssertEMT */
790static DECLCALLBACK(bool) pdmR3DrvHlp_AssertEMT(PPDMDRVINS pDrvIns, const char *pszFile, unsigned iLine, const char *pszFunction)
791{
792 PDMDRV_ASSERT_DRVINS(pDrvIns);
793 if (VM_IS_EMT(pDrvIns->Internal.s.pVM))
794 return true;
795
796 char szMsg[100];
797 RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance);
798 AssertMsg1(szMsg, iLine, pszFile, pszFunction);
799 AssertBreakpoint();
800 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
801 return false;
802}
803
804
805/** @copydoc PDMDRVHLP::pfnAssertOther */
806static DECLCALLBACK(bool) pdmR3DrvHlp_AssertOther(PPDMDRVINS pDrvIns, const char *pszFile, unsigned iLine, const char *pszFunction)
807{
808 PDMDRV_ASSERT_DRVINS(pDrvIns);
809 if (!VM_IS_EMT(pDrvIns->Internal.s.pVM))
810 return true;
811
812 char szMsg[100];
813 RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance);
814 AssertMsg1(szMsg, iLine, pszFile, pszFunction);
815 AssertBreakpoint();
816 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
817 return false;
818}
819
820
821/** @copydoc PDMDRVHLP::pfnVMSetError */
822static DECLCALLBACK(int) pdmR3DrvHlp_VMSetError(PPDMDRVINS pDrvIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
823{
824 PDMDRV_ASSERT_DRVINS(pDrvIns);
825 va_list args;
826 va_start(args, pszFormat);
827 int rc2 = VMSetErrorV(pDrvIns->Internal.s.pVM, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
828 va_end(args);
829 return rc;
830}
831
832
833/** @copydoc PDMDRVHLP::pfnVMSetErrorV */
834static DECLCALLBACK(int) pdmR3DrvHlp_VMSetErrorV(PPDMDRVINS pDrvIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
835{
836 PDMDRV_ASSERT_DRVINS(pDrvIns);
837 int rc2 = VMSetErrorV(pDrvIns->Internal.s.pVM, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
838 return rc;
839}
840
841
842/** @copydoc PDMDRVHLP::pfnVMSetRuntimeError */
843static DECLCALLBACK(int) pdmR3DrvHlp_VMSetRuntimeError(PPDMDRVINS pDrvIns, bool fFatal, const char *pszErrorID, const char *pszFormat, ...)
844{
845 PDMDRV_ASSERT_DRVINS(pDrvIns);
846 va_list args;
847 va_start(args, pszFormat);
848 int rc = VMSetRuntimeErrorV(pDrvIns->Internal.s.pVM, fFatal, pszErrorID, pszFormat, args);
849 va_end(args);
850 return rc;
851}
852
853
854/** @copydoc PDMDRVHLP::pfnVMSetRuntimeErrorV */
855static DECLCALLBACK(int) pdmR3DrvHlp_VMSetRuntimeErrorV(PPDMDRVINS pDrvIns, bool fFatal, const char *pszErrorID, const char *pszFormat, va_list va)
856{
857 PDMDRV_ASSERT_DRVINS(pDrvIns);
858 int rc = VMSetRuntimeErrorV(pDrvIns->Internal.s.pVM, fFatal, pszErrorID, pszFormat, va);
859 return rc;
860}
861
862
863/** @copydoc PDMDRVHLP::pfnPDMQueueCreate */
864static DECLCALLBACK(int) pdmR3DrvHlp_PDMQueueCreate(PPDMDRVINS pDrvIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval, PFNPDMQUEUEDRV pfnCallback, PPDMQUEUE *ppQueue)
865{
866 PDMDRV_ASSERT_DRVINS(pDrvIns);
867 LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p ppQueue=%p\n",
868 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, ppQueue, ppQueue));
869 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
870
871 int rc = PDMR3QueueCreateDriver(pDrvIns->Internal.s.pVM, pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, ppQueue);
872
873 LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: returns %Vrc *ppQueue=%p\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc, *ppQueue));
874 return rc;
875}
876
877
878
879/** @copydoc PDMDRVHLP::pfnPDMPollerRegister */
880static DECLCALLBACK(int) pdmR3DrvHlp_PDMPollerRegister(PPDMDRVINS pDrvIns, PFNPDMDRVPOLLER pfnPoller)
881{
882 PDMDRV_ASSERT_DRVINS(pDrvIns);
883 LogFlow(("pdmR3DrvHlp_PDMPollerRegister: caller='%s'/%d: pfnPoller=%p\n",
884 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pfnPoller));
885 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
886
887 int rc = VINF_SUCCESS;
888 PVM pVM = pDrvIns->Internal.s.pVM;
889 if (pVM->pdm.s.cPollers < ELEMENTS(pVM->pdm.s.apfnPollers))
890 {
891 pVM->pdm.s.apfnPollers[pVM->pdm.s.cPollers] = pfnPoller;
892 pVM->pdm.s.aDrvInsPollers[pVM->pdm.s.cPollers] = pDrvIns;
893 pVM->pdm.s.cPollers++;
894 if (pVM->pdm.s.cPollers == 1)
895 TMTimerSetMillies(pVM->pdm.s.pTimerPollers, 5);
896 }
897 else
898 {
899 AssertMsgFailed(("Too many pollers!\n"));
900 rc = VERR_INTERNAL_ERROR;
901 }
902
903 LogFlow(("pdmR3DrvHlp_PDMPollerRegister: caller='%s'/%d: returns %Vrc\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
904 return rc;
905}
906
907
908/** @copydoc PDMDRVHLP::pfnTMGetVirtualFreq */
909static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualFreq(PPDMDRVINS pDrvIns)
910{
911 PDMDRV_ASSERT_DRVINS(pDrvIns);
912
913 return TMVirtualGetFreq(pDrvIns->Internal.s.pVM);
914}
915
916
917/** @copydoc PDMDRVHLP::pfnTMGetVirtualTime */
918static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualTime(PPDMDRVINS pDrvIns)
919{
920 PDMDRV_ASSERT_DRVINS(pDrvIns);
921
922 return TMVirtualGet(pDrvIns->Internal.s.pVM);
923}
924
925/** @copydoc PDMDRVHLP::pfnTMTimerCreate */
926static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
927{
928 PDMDRV_ASSERT_DRVINS(pDrvIns);
929 LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pszDesc=%p:{%s} ppTimer=%p\n",
930 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, enmClock, pfnCallback, pszDesc, pszDesc, ppTimer));
931
932 int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVM, pDrvIns, enmClock, pfnCallback, pszDesc, ppTimer);
933
934 LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: returns %Vrc *ppTimer=%p\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc, *ppTimer));
935 return rc;
936}
937
938
939
940/** @copydoc PDMDRVHLP::pfnSSMRegister */
941static DECLCALLBACK(int) pdmR3DrvHlp_SSMRegister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
942 PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
943 PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone)
944{
945 PDMDRV_ASSERT_DRVINS(pDrvIns);
946 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
947 LogFlow(("pdmR3DrvHlp_SSMRegister: caller='%s'/%d: pszName=%p:{%s} u32Instance=%#x u32Version=#x cbGuess=%#x pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoaddone=%p\n",
948 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pszName, pszName, u32Instance, u32Version, cbGuess, pfnSavePrep, pfnSaveExec, pfnSaveDone, pfnLoadPrep, pfnLoadExec, pfnLoadDone));
949
950 int rc = SSMR3RegisterDriver(pDrvIns->Internal.s.pVM, pDrvIns, pszName, u32Instance, u32Version, cbGuess,
951 pfnSavePrep, pfnSaveExec, pfnSaveDone,
952 pfnLoadPrep, pfnLoadExec, pfnLoadDone);
953
954 LogFlow(("pdmR3DrvHlp_SSMRegister: caller='%s'/%d: returns %Vrc\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
955 return rc;
956}
957
958
959/** @copydoc PDMDRVHLP::pfnSSMDeregister */
960static DECLCALLBACK(int) pdmR3DrvHlp_SSMDeregister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance)
961{
962 PDMDRV_ASSERT_DRVINS(pDrvIns);
963 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
964 LogFlow(("pdmR3DrvHlp_SSMDeregister: caller='%s'/%d: pszName=%p:{%s} u32Instance=%#x\n",
965 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pszName, pszName, u32Instance));
966
967 int rc = SSMR3DeregisterDriver(pDrvIns->Internal.s.pVM, pDrvIns, pszName, u32Instance);
968
969 LogFlow(("pdmR3DrvHlp_SSMDeregister: caller='%s'/%d: returns %Vrc\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
970 return rc;
971}
972
973
974/** @copydoc PDMDRVHLP::pfnSTAMRegister */
975static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegister(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, const char *pszName, STAMUNIT enmUnit, const char *pszDesc)
976{
977 PDMDRV_ASSERT_DRVINS(pDrvIns);
978 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
979
980 STAM_REG(pDrvIns->Internal.s.pVM, pvSample, enmType, pszName, enmUnit, pszDesc);
981 /** @todo track the samples so they can be dumped & deregistered when the driver instance is destroyed.
982 * For now we just have to be careful not to use this call for drivers which can be unloaded. */
983}
984
985
986/** @copydoc PDMDRVHLP::pfnSTAMRegisterF */
987static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegisterF(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
988 STAMUNIT enmUnit, const char *pszDesc, const char *pszName, ...)
989{
990 PDMDRV_ASSERT_DRVINS(pDrvIns);
991 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
992
993 va_list args;
994 va_start(args, pszName);
995 int rc = STAMR3RegisterV(pDrvIns->Internal.s.pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
996 va_end(args);
997 AssertRC(rc);
998}
999
1000
1001/** @copydoc PDMDRVHLP::pfnSTAMRegisterV */
1002static DECLCALLBACK(void) pdmR3DrvHlp_STAMRegisterV(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
1003 STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args)
1004{
1005 PDMDRV_ASSERT_DRVINS(pDrvIns);
1006 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
1007
1008 int rc = STAMR3RegisterV(pDrvIns->Internal.s.pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
1009 AssertRC(rc);
1010}
1011
1012
1013/** @copydoc PDMDRVHLP::pfnSUPCallVMMR0Ex */
1014static DECLCALLBACK(int) pdmR3DrvHlp_SUPCallVMMR0Ex(PPDMDRVINS pDrvIns, unsigned uOperation, void *pvArg, unsigned cbArg)
1015{
1016 PDMDRV_ASSERT_DRVINS(pDrvIns);
1017 LogFlow(("pdmR3DrvHlp_SSMCallVMMR0Ex: caller='%s'/%d: uOperation=%u pvArg=%p cbArg=%d\n",
1018 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, uOperation, pvArg, cbArg));
1019 int rc;
1020 if ( uOperation >= VMMR0_DO_SRV_START
1021 && uOperation < VMMR0_DO_SRV_END)
1022 rc = SUPCallVMMR0Ex(pDrvIns->Internal.s.pVM->pVMR0, uOperation, 0, (PSUPVMMR0REQHDR)pvArg);
1023 else
1024 {
1025 AssertMsgFailed(("Invalid uOperation=%u\n", uOperation));
1026 rc = VERR_INVALID_PARAMETER;
1027 }
1028
1029 LogFlow(("pdmR3DrvHlp_SUPCallVMMR0Ex: caller='%s'/%d: returns %Vrc\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
1030 return rc;
1031}
1032
1033
1034/** @copydoc PDMDRVHLP::pfnUSBRegisterHub */
1035static DECLCALLBACK(int) pdmR3DrvHlp_USBRegisterHub(PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp)
1036{
1037 PDMDRV_ASSERT_DRVINS(pDrvIns);
1038 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
1039 LogFlow(("pdmR3DrvHlp_USBRegisterHub: caller='%s'/%d: fVersions=%#x cPorts=%#x pUsbHubReg=%p ppUsbHubHlp=%p\n",
1040 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, fVersions, cPorts, pUsbHubReg, ppUsbHubHlp));
1041
1042#ifdef VBOX_WITH_USB
1043 int rc = pdmR3UsbRegisterHub(pDrvIns->Internal.s.pVM, pDrvIns, fVersions, cPorts, pUsbHubReg, ppUsbHubHlp);
1044#else
1045 int rc = VERR_NOT_SUPPORTED;
1046#endif
1047
1048 LogFlow(("pdmR3DrvHlp_USBRegisterHub: caller='%s'/%d: returns %Vrc\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, rc));
1049 return rc;
1050}
1051
1052
1053/** @copydoc PDMDRVHLP::pfnPDMThreadCreate */
1054static DECLCALLBACK(int) pdmR3DrvHlp_PDMThreadCreate(PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
1055 PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
1056{
1057 PDMDRV_ASSERT_DRVINS(pDrvIns);
1058 VM_ASSERT_EMT(pDrvIns->Internal.s.pVM);
1059 LogFlow(("pdmR3DrvHlp_PDMThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
1060 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
1061
1062 int rc = pdmR3ThreadCreateDriver(pDrvIns->Internal.s.pVM, pDrvIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
1063
1064 LogFlow(("pdmR3DrvHlp_PDMThreadCreate: caller='%s'/%d: returns %Vrc *ppThread=%RTthrd\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance,
1065 rc, *ppThread));
1066 return rc;
1067}
1068
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette