VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMDevice.cpp@ 74795

Last change on this file since 74795 was 73097, checked in by vboxsync, 6 years ago

*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 40.4 KB
Line 
1/* $Id: PDMDevice.cpp 73097 2018-07-12 21:06:33Z vboxsync $ */
2/** @file
3 * PDM - Pluggable Device and Driver Manager, Device parts.
4 */
5
6/*
7 * Copyright (C) 2006-2017 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_DEVICE
23#include "PDMInternal.h"
24#include <VBox/vmm/pdm.h>
25#include <VBox/vmm/mm.h>
26#include <VBox/vmm/pgm.h>
27#include <VBox/vmm/iom.h>
28#include <VBox/vmm/hm.h>
29#include <VBox/vmm/cfgm.h>
30#include <VBox/vmm/apic.h>
31#ifdef VBOX_WITH_REM
32# include <VBox/vmm/rem.h>
33#endif
34#include <VBox/vmm/dbgf.h>
35#include <VBox/vmm/vm.h>
36#include <VBox/vmm/uvm.h>
37#include <VBox/vmm/vmm.h>
38
39#include <VBox/version.h>
40#include <VBox/log.h>
41#include <VBox/err.h>
42#include <iprt/alloc.h>
43#include <iprt/alloca.h>
44#include <iprt/asm.h>
45#include <iprt/assert.h>
46#include <iprt/path.h>
47#include <iprt/semaphore.h>
48#include <iprt/string.h>
49#include <iprt/thread.h>
50
51
52/*********************************************************************************************************************************
53* Structures and Typedefs *
54*********************************************************************************************************************************/
55/**
56 * Internal callback structure pointer.
57 * The main purpose is to define the extra data we associate
58 * with PDMDEVREGCB so we can find the VM instance and so on.
59 */
60typedef struct PDMDEVREGCBINT
61{
62 /** The callback structure. */
63 PDMDEVREGCB Core;
64 /** A bit of padding. */
65 uint32_t u32[4];
66 /** VM Handle. */
67 PVM pVM;
68 /** Pointer to the configuration node the registrations should be
69 * associated with. Can be NULL. */
70 PCFGMNODE pCfgNode;
71} PDMDEVREGCBINT;
72/** Pointer to a PDMDEVREGCBINT structure. */
73typedef PDMDEVREGCBINT *PPDMDEVREGCBINT;
74/** Pointer to a const PDMDEVREGCBINT structure. */
75typedef const PDMDEVREGCBINT *PCPDMDEVREGCBINT;
76
77
78/*********************************************************************************************************************************
79* Internal Functions *
80*********************************************************************************************************************************/
81static DECLCALLBACK(int) pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg);
82static int pdmR3DevLoadModules(PVM pVM);
83static int pdmR3DevLoad(PVM pVM, PPDMDEVREGCBINT pRegCB, const char *pszFilename, const char *pszName);
84
85
86
87
88/**
89 * This function will initialize the devices for this VM instance.
90 *
91 *
92 * First of all this mean loading the builtin device and letting them
93 * register themselves. Beyond that any additional device modules are
94 * loaded and called for registration.
95 *
96 * Then the device configuration is enumerated, the instantiation order
97 * is determined, and finally they are instantiated.
98 *
99 * After all devices have been successfully instantiated the primary
100 * PCI Bus device is called to emulate the PCI BIOS, i.e. making the
101 * resource assignments. If there is no PCI device, this step is of course
102 * skipped.
103 *
104 * Finally the init completion routines of the instantiated devices
105 * are called.
106 *
107 * @returns VBox status code.
108 * @param pVM The cross context VM structure.
109 */
110int pdmR3DevInit(PVM pVM)
111{
112 LogFlow(("pdmR3DevInit:\n"));
113
114 AssertRelease(!(RT_UOFFSETOF(PDMDEVINS, achInstanceData) & 15));
115 AssertRelease(sizeof(pVM->pdm.s.pDevInstances->Internal.s) <= sizeof(pVM->pdm.s.pDevInstances->Internal.padding));
116
117 /*
118 * Load device modules.
119 */
120 int rc = pdmR3DevLoadModules(pVM);
121 if (RT_FAILURE(rc))
122 return rc;
123
124#ifdef VBOX_WITH_USB
125 /* ditto for USB Devices. */
126 rc = pdmR3UsbLoadModules(pVM);
127 if (RT_FAILURE(rc))
128 return rc;
129#endif
130
131 /*
132 * Get the RC & R0 devhlps and create the devhlp R3 task queue.
133 */
134 PCPDMDEVHLPRC pHlpRC = NIL_RTRCPTR;
135 if (VM_IS_RAW_MODE_ENABLED(pVM))
136 {
137 rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDevHlp", &pHlpRC);
138 AssertReleaseRCReturn(rc, rc);
139 }
140
141 PCPDMDEVHLPR0 pHlpR0;
142 rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0DevHlp", &pHlpR0);
143 AssertReleaseRCReturn(rc, rc);
144
145 rc = PDMR3QueueCreateInternal(pVM, sizeof(PDMDEVHLPTASK), 8, 0, pdmR3DevHlpQueueConsumer, true, "DevHlp",
146 &pVM->pdm.s.pDevHlpQueueR3);
147 AssertRCReturn(rc, rc);
148 pVM->pdm.s.pDevHlpQueueR0 = PDMQueueR0Ptr(pVM->pdm.s.pDevHlpQueueR3);
149 pVM->pdm.s.pDevHlpQueueRC = PDMQueueRCPtr(pVM->pdm.s.pDevHlpQueueR3);
150
151
152 /*
153 *
154 * Enumerate the device instance configurations
155 * and come up with a instantiation order.
156 *
157 */
158 /* Switch to /Devices, which contains the device instantiations. */
159 PCFGMNODE pDevicesNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "Devices");
160
161 /*
162 * Count the device instances.
163 */
164 PCFGMNODE pCur;
165 PCFGMNODE pInstanceNode;
166 unsigned cDevs = 0;
167 for (pCur = CFGMR3GetFirstChild(pDevicesNode); pCur; pCur = CFGMR3GetNextChild(pCur))
168 for (pInstanceNode = CFGMR3GetFirstChild(pCur); pInstanceNode; pInstanceNode = CFGMR3GetNextChild(pInstanceNode))
169 cDevs++;
170 if (!cDevs)
171 {
172 Log(("PDM: No devices were configured!\n"));
173 return VINF_SUCCESS;
174 }
175 Log2(("PDM: cDevs=%u\n", cDevs));
176
177 /*
178 * Collect info on each device instance.
179 */
180 struct DEVORDER
181 {
182 /** Configuration node. */
183 PCFGMNODE pNode;
184 /** Pointer to device. */
185 PPDMDEV pDev;
186 /** Init order. */
187 uint32_t u32Order;
188 /** VBox instance number. */
189 uint32_t iInstance;
190 } *paDevs = (struct DEVORDER *)alloca(sizeof(paDevs[0]) * (cDevs + 1)); /* (One extra for swapping) */
191 Assert(paDevs);
192 unsigned i = 0;
193 for (pCur = CFGMR3GetFirstChild(pDevicesNode); pCur; pCur = CFGMR3GetNextChild(pCur))
194 {
195 /* Get the device name. */
196 char szName[sizeof(paDevs[0].pDev->pReg->szName)];
197 rc = CFGMR3GetName(pCur, szName, sizeof(szName));
198 AssertMsgRCReturn(rc, ("Configuration error: device name is too long (or something)! rc=%Rrc\n", rc), rc);
199
200 /* Find the device. */
201 PPDMDEV pDev = pdmR3DevLookup(pVM, szName);
202 AssertLogRelMsgReturn(pDev, ("Configuration error: device '%s' not found!\n", szName), VERR_PDM_DEVICE_NOT_FOUND);
203
204 /* Configured priority or use default based on device class? */
205 uint32_t u32Order;
206 rc = CFGMR3QueryU32(pCur, "Priority", &u32Order);
207 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
208 {
209 uint32_t u32 = pDev->pReg->fClass;
210 for (u32Order = 1; !(u32 & u32Order); u32Order <<= 1)
211 /* nop */;
212 }
213 else
214 AssertMsgRCReturn(rc, ("Configuration error: reading \"Priority\" for the '%s' device failed rc=%Rrc!\n", szName, rc), rc);
215
216 /* Enumerate the device instances. */
217 uint32_t const iStart = i;
218 for (pInstanceNode = CFGMR3GetFirstChild(pCur); pInstanceNode; pInstanceNode = CFGMR3GetNextChild(pInstanceNode))
219 {
220 paDevs[i].pNode = pInstanceNode;
221 paDevs[i].pDev = pDev;
222 paDevs[i].u32Order = u32Order;
223
224 /* Get the instance number. */
225 char szInstance[32];
226 rc = CFGMR3GetName(pInstanceNode, szInstance, sizeof(szInstance));
227 AssertMsgRCReturn(rc, ("Configuration error: instance name is too long (or something)! rc=%Rrc\n", rc), rc);
228 char *pszNext = NULL;
229 rc = RTStrToUInt32Ex(szInstance, &pszNext, 0, &paDevs[i].iInstance);
230 AssertMsgRCReturn(rc, ("Configuration error: RTStrToInt32Ex failed on the instance name '%s'! rc=%Rrc\n", szInstance, rc), rc);
231 AssertMsgReturn(!*pszNext, ("Configuration error: the instance name '%s' isn't all digits. (%s)\n", szInstance, pszNext), VERR_INVALID_PARAMETER);
232
233 /* next instance */
234 i++;
235 }
236
237 /* check the number of instances */
238 if (i - iStart > pDev->pReg->cMaxInstances)
239 AssertLogRelMsgFailedReturn(("Configuration error: Too many instances of %s was configured: %u, max %u\n",
240 szName, i - iStart, pDev->pReg->cMaxInstances),
241 VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
242 } /* devices */
243 Assert(i == cDevs);
244
245 /*
246 * Sort (bubble) the device array ascending on u32Order and instance number
247 * for a device.
248 */
249 unsigned c = cDevs - 1;
250 while (c)
251 {
252 unsigned j = 0;
253 for (i = 0; i < c; i++)
254 if ( paDevs[i].u32Order > paDevs[i + 1].u32Order
255 || ( paDevs[i].u32Order == paDevs[i + 1].u32Order
256 && paDevs[i].iInstance > paDevs[i + 1].iInstance
257 && paDevs[i].pDev == paDevs[i + 1].pDev) )
258 {
259 paDevs[cDevs] = paDevs[i + 1];
260 paDevs[i + 1] = paDevs[i];
261 paDevs[i] = paDevs[cDevs];
262 j = i;
263 }
264 c = j;
265 }
266
267
268 /*
269 *
270 * Instantiate the devices.
271 *
272 */
273 for (i = 0; i < cDevs; i++)
274 {
275 /*
276 * Gather a bit of config.
277 */
278 /* trusted */
279 bool fTrusted;
280 rc = CFGMR3QueryBool(paDevs[i].pNode, "Trusted", &fTrusted);
281 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
282 fTrusted = false;
283 else if (RT_FAILURE(rc))
284 {
285 AssertMsgFailed(("configuration error: failed to query boolean \"Trusted\", rc=%Rrc\n", rc));
286 return rc;
287 }
288 /* config node */
289 PCFGMNODE pConfigNode = CFGMR3GetChild(paDevs[i].pNode, "Config");
290 if (!pConfigNode)
291 {
292 rc = CFGMR3InsertNode(paDevs[i].pNode, "Config", &pConfigNode);
293 if (RT_FAILURE(rc))
294 {
295 AssertMsgFailed(("Failed to create Config node! rc=%Rrc\n", rc));
296 return rc;
297 }
298 }
299 CFGMR3SetRestrictedRoot(pConfigNode);
300
301 /*
302 * Allocate the device instance and critical section.
303 */
304 AssertReturn(paDevs[i].pDev->cInstances < paDevs[i].pDev->pReg->cMaxInstances, VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
305 size_t cb = RT_UOFFSETOF_DYN(PDMDEVINS, achInstanceData[paDevs[i].pDev->pReg->cbInstance]);
306 cb = RT_ALIGN_Z(cb, 16);
307 PPDMDEVINS pDevIns;
308 if (paDevs[i].pDev->pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0))
309 rc = MMR3HyperAllocOnceNoRel(pVM, cb, 0, MM_TAG_PDM_DEVICE, (void **)&pDevIns);
310 else
311 rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_DEVICE, cb, (void **)&pDevIns);
312 AssertLogRelMsgRCReturn(rc,
313 ("Failed to allocate %d bytes of instance data for device '%s'. rc=%Rrc\n",
314 cb, paDevs[i].pDev->pReg->szName, rc),
315 rc);
316 PPDMCRITSECT pCritSect;
317 if (paDevs[i].pDev->pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0))
318 rc = MMHyperAlloc(pVM, sizeof(*pCritSect), 0, MM_TAG_PDM_DEVICE, (void **)&pCritSect);
319 else
320 rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_DEVICE, sizeof(*pCritSect), (void **)&pCritSect);
321 AssertLogRelMsgRCReturn(rc, ("Failed to allocate a critical section for the device (%Rrc)\n", rc), rc);
322
323 /*
324 * Initialize it.
325 */
326 pDevIns->u32Version = PDM_DEVINS_VERSION;
327 pDevIns->iInstance = paDevs[i].iInstance;
328 //pDevIns->Internal.s.pNextR3 = NULL;
329 //pDevIns->Internal.s.pPerDeviceNextR3 = NULL;
330 pDevIns->Internal.s.pDevR3 = paDevs[i].pDev;
331 pDevIns->Internal.s.pVMR3 = pVM;
332 pDevIns->Internal.s.pVMR0 = pVM->pVMR0;
333 pDevIns->Internal.s.pVMRC = pVM->pVMRC;
334 //pDevIns->Internal.s.pLunsR3 = NULL;
335 pDevIns->Internal.s.pCfgHandle = paDevs[i].pNode;
336 //pDevIns->Internal.s.pHeadPciDevR3 = NULL;
337 //pDevIns->Internal.s.pHeadPciDevR0 = 0;
338 //pDevIns->Internal.s.pHeadPciDevRC = 0;
339 pDevIns->Internal.s.fIntFlags = PDMDEVINSINT_FLAGS_SUSPENDED;
340 //pDevIns->Internal.s.uLastIrqTag = 0;
341 pDevIns->pHlpR3 = fTrusted ? &g_pdmR3DevHlpTrusted : &g_pdmR3DevHlpUnTrusted;
342 pDevIns->pHlpRC = pHlpRC;
343 pDevIns->pHlpR0 = pHlpR0;
344 pDevIns->pReg = paDevs[i].pDev->pReg;
345 pDevIns->pCfg = pConfigNode;
346 //pDevIns->IBase.pfnQueryInterface = NULL;
347 //pDevIns->fTracing = 0;
348 pDevIns->idTracing = ++pVM->pdm.s.idTracingDev;
349 pDevIns->pvInstanceDataR3 = &pDevIns->achInstanceData[0];
350 pDevIns->pvInstanceDataRC = pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC
351 ? MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3) : NIL_RTRCPTR;
352 pDevIns->pvInstanceDataR0 = pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0
353 ? MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3) : NIL_RTR0PTR;
354
355 pDevIns->pCritSectRoR3 = pCritSect;
356 pDevIns->pCritSectRoRC = pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC
357 ? MMHyperR3ToRC(pVM, pCritSect) : NIL_RTRCPTR;
358 pDevIns->pCritSectRoR0 = pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0
359 ? MMHyperR3ToR0(pVM, pCritSect) : NIL_RTR0PTR;
360
361 rc = pdmR3CritSectInitDeviceAuto(pVM, pDevIns, pCritSect, RT_SRC_POS,
362 "%s#%uAuto", pDevIns->pReg->szName, pDevIns->iInstance);
363 AssertLogRelRCReturn(rc, rc);
364
365 /*
366 * Link it into all the lists.
367 */
368 /* The global instance FIFO. */
369 PPDMDEVINS pPrev1 = pVM->pdm.s.pDevInstances;
370 if (!pPrev1)
371 pVM->pdm.s.pDevInstances = pDevIns;
372 else
373 {
374 while (pPrev1->Internal.s.pNextR3)
375 pPrev1 = pPrev1->Internal.s.pNextR3;
376 pPrev1->Internal.s.pNextR3 = pDevIns;
377 }
378
379 /* The per device instance FIFO. */
380 PPDMDEVINS pPrev2 = paDevs[i].pDev->pInstances;
381 if (!pPrev2)
382 paDevs[i].pDev->pInstances = pDevIns;
383 else
384 {
385 while (pPrev2->Internal.s.pPerDeviceNextR3)
386 pPrev2 = pPrev2->Internal.s.pPerDeviceNextR3;
387 pPrev2->Internal.s.pPerDeviceNextR3 = pDevIns;
388 }
389
390 /*
391 * Call the constructor.
392 */
393 paDevs[i].pDev->cInstances++;
394 Log(("PDM: Constructing device '%s' instance %d...\n", pDevIns->pReg->szName, pDevIns->iInstance));
395 rc = pDevIns->pReg->pfnConstruct(pDevIns, pDevIns->iInstance, pDevIns->pCfg);
396 if (RT_FAILURE(rc))
397 {
398 LogRel(("PDM: Failed to construct '%s'/%d! %Rra\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
399 paDevs[i].pDev->cInstances--;
400 /* Because we're damn lazy, the destructor will be called even if
401 the constructor fails. So, no unlinking. */
402 return rc == VERR_VERSION_MISMATCH ? VERR_PDM_DEVICE_VERSION_MISMATCH : rc;
403 }
404 } /* for device instances */
405
406#ifdef VBOX_WITH_USB
407 /* ditto for USB Devices. */
408 rc = pdmR3UsbInstantiateDevices(pVM);
409 if (RT_FAILURE(rc))
410 return rc;
411#endif
412
413 LogFlow(("pdmR3DevInit: returns %Rrc\n", VINF_SUCCESS));
414 return VINF_SUCCESS;
415}
416
417
418/**
419 * Performs the init complete callback after ring-0 and raw-mode has been
420 * initialized.
421 *
422 * @returns VBox status code.
423 * @param pVM The cross context VM structure.
424 */
425int pdmR3DevInitComplete(PVM pVM)
426{
427 int rc;
428
429 /*
430 * Iterate thru the device instances and work the callback.
431 */
432 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
433 {
434 if (pDevIns->pReg->pfnInitComplete)
435 {
436 PDMCritSectEnter(pDevIns->pCritSectRoR3, VERR_IGNORED);
437 rc = pDevIns->pReg->pfnInitComplete(pDevIns);
438 PDMCritSectLeave(pDevIns->pCritSectRoR3);
439 if (RT_FAILURE(rc))
440 {
441 AssertMsgFailed(("InitComplete on device '%s'/%d failed with rc=%Rrc\n",
442 pDevIns->pReg->szName, pDevIns->iInstance, rc));
443 return rc;
444 }
445 }
446 }
447
448#ifdef VBOX_WITH_USB
449 rc = pdmR3UsbVMInitComplete(pVM);
450 if (RT_FAILURE(rc))
451 {
452 Log(("pdmR3DevInit: returns %Rrc\n", rc));
453 return rc;
454 }
455#endif
456
457 LogFlow(("pdmR3DevInit: returns %Rrc\n", VINF_SUCCESS));
458 return VINF_SUCCESS;
459}
460
461
462/**
463 * Lookups a device structure by name.
464 * @internal
465 */
466PPDMDEV pdmR3DevLookup(PVM pVM, const char *pszName)
467{
468 size_t cchName = strlen(pszName);
469 for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
470 if ( pDev->cchName == cchName
471 && !strcmp(pDev->pReg->szName, pszName))
472 return pDev;
473 return NULL;
474}
475
476
477/**
478 * Loads the device modules.
479 *
480 * @returns VBox status code.
481 * @param pVM The cross context VM structure.
482 */
483static int pdmR3DevLoadModules(PVM pVM)
484{
485 /*
486 * Initialize the callback structure.
487 */
488 PDMDEVREGCBINT RegCB;
489 RegCB.Core.u32Version = PDM_DEVREG_CB_VERSION;
490 RegCB.Core.pfnRegister = pdmR3DevReg_Register;
491 RegCB.pVM = pVM;
492 RegCB.pCfgNode = NULL;
493
494 /*
495 * Load the internal VMM APIC device.
496 */
497 int rc2 = pdmR3DevReg_Register(&RegCB.Core, &g_DeviceAPIC);
498 AssertRCReturn(rc2, rc2);
499
500 /*
501 * Load the builtin module.
502 */
503 PCFGMNODE pDevicesNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM/Devices");
504 bool fLoadBuiltin;
505 int rc = CFGMR3QueryBool(pDevicesNode, "LoadBuiltin", &fLoadBuiltin);
506 if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
507 fLoadBuiltin = true;
508 else if (RT_FAILURE(rc))
509 {
510 AssertMsgFailed(("Configuration error: Querying boolean \"LoadBuiltin\" failed with %Rrc\n", rc));
511 return rc;
512 }
513 if (fLoadBuiltin)
514 {
515 /* make filename */
516 char *pszFilename = pdmR3FileR3("VBoxDD", true /*fShared*/);
517 if (!pszFilename)
518 return VERR_NO_TMP_MEMORY;
519 rc = pdmR3DevLoad(pVM, &RegCB, pszFilename, "VBoxDD");
520 RTMemTmpFree(pszFilename);
521 if (RT_FAILURE(rc))
522 return rc;
523
524 /* make filename */
525 pszFilename = pdmR3FileR3("VBoxDD2", true /*fShared*/);
526 if (!pszFilename)
527 return VERR_NO_TMP_MEMORY;
528 rc = pdmR3DevLoad(pVM, &RegCB, pszFilename, "VBoxDD2");
529 RTMemTmpFree(pszFilename);
530 if (RT_FAILURE(rc))
531 return rc;
532 }
533
534 /*
535 * Load additional device modules.
536 */
537 PCFGMNODE pCur;
538 for (pCur = CFGMR3GetFirstChild(pDevicesNode); pCur; pCur = CFGMR3GetNextChild(pCur))
539 {
540 /*
541 * Get the name and path.
542 */
543 char szName[PDMMOD_NAME_LEN];
544 rc = CFGMR3GetName(pCur, &szName[0], sizeof(szName));
545 if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
546 {
547 AssertMsgFailed(("configuration error: The module name is too long, cchName=%zu.\n", CFGMR3GetNameLen(pCur)));
548 return VERR_PDM_MODULE_NAME_TOO_LONG;
549 }
550 else if (RT_FAILURE(rc))
551 {
552 AssertMsgFailed(("CFGMR3GetName -> %Rrc.\n", rc));
553 return rc;
554 }
555
556 /* the path is optional, if no path the module name + path is used. */
557 char szFilename[RTPATH_MAX];
558 rc = CFGMR3QueryString(pCur, "Path", &szFilename[0], sizeof(szFilename));
559 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
560 strcpy(szFilename, szName);
561 else if (RT_FAILURE(rc))
562 {
563 AssertMsgFailed(("configuration error: Failure to query the module path, rc=%Rrc.\n", rc));
564 return rc;
565 }
566
567 /* prepend path? */
568 if (!RTPathHavePath(szFilename))
569 {
570 char *psz = pdmR3FileR3(szFilename, false /*fShared*/);
571 if (!psz)
572 return VERR_NO_TMP_MEMORY;
573 size_t cch = strlen(psz) + 1;
574 if (cch > sizeof(szFilename))
575 {
576 RTMemTmpFree(psz);
577 AssertMsgFailed(("Filename too long! cch=%d '%s'\n", cch, psz));
578 return VERR_FILENAME_TOO_LONG;
579 }
580 memcpy(szFilename, psz, cch);
581 RTMemTmpFree(psz);
582 }
583
584 /*
585 * Load the module and register it's devices.
586 */
587 RegCB.pCfgNode = pCur;
588 rc = pdmR3DevLoad(pVM, &RegCB, szFilename, szName);
589 if (RT_FAILURE(rc))
590 return rc;
591 }
592
593 return VINF_SUCCESS;
594}
595
596
597/**
598 * Loads one device module and call the registration entry point.
599 *
600 * @returns VBox status code.
601 * @param pVM The cross context VM structure.
602 * @param pRegCB The registration callback stuff.
603 * @param pszFilename Module filename.
604 * @param pszName Module name.
605 */
606static int pdmR3DevLoad(PVM pVM, PPDMDEVREGCBINT pRegCB, const char *pszFilename, const char *pszName)
607{
608 /*
609 * Load it.
610 */
611 int rc = pdmR3LoadR3U(pVM->pUVM, pszFilename, pszName);
612 if (RT_SUCCESS(rc))
613 {
614 /*
615 * Get the registration export and call it.
616 */
617 FNPDMVBOXDEVICESREGISTER *pfnVBoxDevicesRegister;
618 rc = PDMR3LdrGetSymbolR3(pVM, pszName, "VBoxDevicesRegister", (void **)&pfnVBoxDevicesRegister);
619 if (RT_SUCCESS(rc))
620 {
621 Log(("PDM: Calling VBoxDevicesRegister (%p) of %s (%s)\n", pfnVBoxDevicesRegister, pszName, pszFilename));
622 rc = pfnVBoxDevicesRegister(&pRegCB->Core, VBOX_VERSION);
623 if (RT_SUCCESS(rc))
624 Log(("PDM: Successfully loaded device module %s (%s).\n", pszName, pszFilename));
625 else
626 AssertMsgFailed(("VBoxDevicesRegister failed with rc=%Rrc for module %s (%s)\n", rc, pszName, pszFilename));
627 }
628 else
629 {
630 AssertMsgFailed(("Failed to locate 'VBoxDevicesRegister' in %s (%s) rc=%Rrc\n", pszName, pszFilename, rc));
631 if (rc == VERR_SYMBOL_NOT_FOUND)
632 rc = VERR_PDM_NO_REGISTRATION_EXPORT;
633 }
634 }
635 else
636 AssertMsgFailed(("Failed to load %s %s!\n", pszFilename, pszName));
637 return rc;
638}
639
640
641/**
642 * @interface_method_impl{PDMDEVREGCB,pfnRegister}
643 */
644static DECLCALLBACK(int) pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg)
645{
646 /*
647 * Validate the registration structure.
648 */
649 Assert(pReg);
650 AssertMsgReturn(pReg->u32Version == PDM_DEVREG_VERSION,
651 ("Unknown struct version %#x!\n", pReg->u32Version),
652 VERR_PDM_UNKNOWN_DEVREG_VERSION);
653
654 AssertMsgReturn( pReg->szName[0]
655 && strlen(pReg->szName) < sizeof(pReg->szName)
656 && pdmR3IsValidName(pReg->szName),
657 ("Invalid name '%.*s'\n", sizeof(pReg->szName), pReg->szName),
658 VERR_PDM_INVALID_DEVICE_REGISTRATION);
659 AssertMsgReturn( !(pReg->fFlags & PDM_DEVREG_FLAGS_RC)
660 || ( pReg->szRCMod[0]
661 && strlen(pReg->szRCMod) < sizeof(pReg->szRCMod)),
662 ("Invalid GC module name '%s' - (Device %s)\n", pReg->szRCMod, pReg->szName),
663 VERR_PDM_INVALID_DEVICE_REGISTRATION);
664 AssertMsgReturn( !(pReg->fFlags & PDM_DEVREG_FLAGS_R0)
665 || ( pReg->szR0Mod[0]
666 && strlen(pReg->szR0Mod) < sizeof(pReg->szR0Mod)),
667 ("Invalid R0 module name '%s' - (Device %s)\n", pReg->szR0Mod, pReg->szName),
668 VERR_PDM_INVALID_DEVICE_REGISTRATION);
669 AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) == PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT,
670 ("Invalid host bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
671 VERR_PDM_INVALID_DEVICE_HOST_BITS);
672 AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK),
673 ("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
674 VERR_PDM_INVALID_DEVICE_REGISTRATION);
675 AssertMsgReturn(pReg->fClass,
676 ("No class! (Device %s)\n", pReg->szName),
677 VERR_PDM_INVALID_DEVICE_REGISTRATION);
678 AssertMsgReturn(pReg->cMaxInstances > 0,
679 ("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szName),
680 VERR_PDM_INVALID_DEVICE_REGISTRATION);
681 AssertMsgReturn(pReg->cbInstance <= (uint32_t)(pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0) ? 96 * _1K : _1M),
682 ("Instance size %d bytes! (Device %s)\n", pReg->cbInstance, pReg->szName),
683 VERR_PDM_INVALID_DEVICE_REGISTRATION);
684 AssertMsgReturn(pReg->pfnConstruct,
685 ("No constructor! (Device %s)\n", pReg->szName),
686 VERR_PDM_INVALID_DEVICE_REGISTRATION);
687 AssertLogRelMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK) == PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT,
688 ("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pReg->szName),
689 VERR_PDM_INVALID_DEVICE_GUEST_BITS);
690 AssertLogRelMsg(pReg->u32VersionEnd == PDM_DEVREG_VERSION,
691 ("u32VersionEnd=%#x, expected %#x. (szName=%s)\n",
692 pReg->u32VersionEnd, PDM_DEVREG_VERSION, pReg->szName));
693
694 /*
695 * Check for duplicate and find FIFO entry at the same time.
696 */
697 PCPDMDEVREGCBINT pRegCB = (PCPDMDEVREGCBINT)pCallbacks;
698 PPDMDEV pDevPrev = NULL;
699 PPDMDEV pDev = pRegCB->pVM->pdm.s.pDevs;
700 for (; pDev; pDevPrev = pDev, pDev = pDev->pNext)
701 AssertMsgReturn(strcmp(pDev->pReg->szName, pReg->szName),
702 ("Device '%s' already exists\n", pReg->szName),
703 VERR_PDM_DEVICE_NAME_CLASH);
704
705 /*
706 * Allocate new device structure, initialize and insert it into the list.
707 */
708 int rc;
709 pDev = (PPDMDEV)MMR3HeapAlloc(pRegCB->pVM, MM_TAG_PDM_DEVICE, sizeof(*pDev));
710 if (pDev)
711 {
712 pDev->pNext = NULL;
713 pDev->cInstances = 0;
714 pDev->pInstances = NULL;
715 pDev->pReg = pReg;
716 pDev->cchName = (uint32_t)strlen(pReg->szName);
717 rc = CFGMR3QueryStringAllocDef( pRegCB->pCfgNode, "RCSearchPath", &pDev->pszRCSearchPath, NULL);
718 if (RT_SUCCESS(rc))
719 rc = CFGMR3QueryStringAllocDef(pRegCB->pCfgNode, "R0SearchPath", &pDev->pszR0SearchPath, NULL);
720 if (RT_SUCCESS(rc))
721 {
722 if (pDevPrev)
723 pDevPrev->pNext = pDev;
724 else
725 pRegCB->pVM->pdm.s.pDevs = pDev;
726 Log(("PDM: Registered device '%s'\n", pReg->szName));
727 return VINF_SUCCESS;
728 }
729
730 MMR3HeapFree(pDev);
731 }
732 else
733 rc = VERR_NO_MEMORY;
734 return rc;
735}
736
737
738/**
739 * Locates a LUN.
740 *
741 * @returns VBox status code.
742 * @param pVM The cross context VM structure.
743 * @param pszDevice Device name.
744 * @param iInstance Device instance.
745 * @param iLun The Logical Unit to obtain the interface of.
746 * @param ppLun Where to store the pointer to the LUN if found.
747 * @thread Try only do this in EMT...
748 */
749int pdmR3DevFindLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPPDMLUN ppLun)
750{
751 /*
752 * Iterate registered devices looking for the device.
753 */
754 size_t cchDevice = strlen(pszDevice);
755 for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
756 {
757 if ( pDev->cchName == cchDevice
758 && !memcmp(pDev->pReg->szName, pszDevice, cchDevice))
759 {
760 /*
761 * Iterate device instances.
762 */
763 for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextR3)
764 {
765 if (pDevIns->iInstance == iInstance)
766 {
767 /*
768 * Iterate luns.
769 */
770 for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
771 {
772 if (pLun->iLun == iLun)
773 {
774 *ppLun = pLun;
775 return VINF_SUCCESS;
776 }
777 }
778 return VERR_PDM_LUN_NOT_FOUND;
779 }
780 }
781 return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
782 }
783 }
784 return VERR_PDM_DEVICE_NOT_FOUND;
785}
786
787
788/**
789 * Attaches a preconfigured driver to an existing device instance.
790 *
791 * This is used to change drivers and suchlike at runtime.
792 *
793 * @returns VBox status code.
794 * @param pUVM The user mode VM handle.
795 * @param pszDevice Device name.
796 * @param iInstance Device instance.
797 * @param iLun The Logical Unit to obtain the interface of.
798 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
799 * @param ppBase Where to store the base interface pointer. Optional.
800 * @thread EMT
801 */
802VMMR3DECL(int) PDMR3DeviceAttach(PUVM pUVM, const char *pszDevice, unsigned iInstance, unsigned iLun, uint32_t fFlags, PPPDMIBASE ppBase)
803{
804 UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
805 PVM pVM = pUVM->pVM;
806 VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
807 VM_ASSERT_EMT(pVM);
808 LogFlow(("PDMR3DeviceAttach: pszDevice=%p:{%s} iInstance=%d iLun=%d fFlags=%#x ppBase=%p\n",
809 pszDevice, pszDevice, iInstance, iLun, fFlags, ppBase));
810
811 /*
812 * Find the LUN in question.
813 */
814 PPDMLUN pLun;
815 int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
816 if (RT_SUCCESS(rc))
817 {
818 /*
819 * Can we attach anything at runtime?
820 */
821 PPDMDEVINS pDevIns = pLun->pDevIns;
822 if (pDevIns->pReg->pfnAttach)
823 {
824 if (!pLun->pTop)
825 {
826 PDMCritSectEnter(pDevIns->pCritSectRoR3, VERR_IGNORED);
827 rc = pDevIns->pReg->pfnAttach(pDevIns, iLun, fFlags);
828 PDMCritSectLeave(pDevIns->pCritSectRoR3);
829 }
830 else
831 rc = VERR_PDM_DRIVER_ALREADY_ATTACHED;
832 }
833 else
834 rc = VERR_PDM_DEVICE_NO_RT_ATTACH;
835
836 if (ppBase)
837 *ppBase = pLun->pTop ? &pLun->pTop->IBase : NULL;
838 }
839 else if (ppBase)
840 *ppBase = NULL;
841
842 if (ppBase)
843 LogFlow(("PDMR3DeviceAttach: returns %Rrc *ppBase=%p\n", rc, *ppBase));
844 else
845 LogFlow(("PDMR3DeviceAttach: returns %Rrc\n", rc));
846 return rc;
847}
848
849
850/**
851 * Detaches a driver chain from an existing device instance.
852 *
853 * This is used to change drivers and suchlike at runtime.
854 *
855 * @returns VBox status code.
856 * @param pUVM The user mode VM handle.
857 * @param pszDevice Device name.
858 * @param iInstance Device instance.
859 * @param iLun The Logical Unit to obtain the interface of.
860 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
861 * @thread EMT
862 */
863VMMR3DECL(int) PDMR3DeviceDetach(PUVM pUVM, const char *pszDevice, unsigned iInstance, unsigned iLun, uint32_t fFlags)
864{
865 return PDMR3DriverDetach(pUVM, pszDevice, iInstance, iLun, NULL, 0, fFlags);
866}
867
868
869/**
870 * References the critical section associated with a device for the use by a
871 * timer or similar created by the device.
872 *
873 * @returns Pointer to the critical section.
874 * @param pVM The cross context VM structure.
875 * @param pDevIns The device instance in question.
876 *
877 * @internal
878 */
879VMMR3_INT_DECL(PPDMCRITSECT) PDMR3DevGetCritSect(PVM pVM, PPDMDEVINS pDevIns)
880{
881 VM_ASSERT_EMT(pVM); RT_NOREF_PV(pVM);
882 VM_ASSERT_STATE(pVM, VMSTATE_CREATING);
883 AssertPtr(pDevIns);
884
885 PPDMCRITSECT pCritSect = pDevIns->pCritSectRoR3;
886 AssertPtr(pCritSect);
887 pCritSect->s.fUsedByTimerOrSimilar = true;
888
889 return pCritSect;
890}
891
892
893/**
894 * Attaches a preconfigured driver to an existing device or driver instance.
895 *
896 * This is used to change drivers and suchlike at runtime. The driver or device
897 * at the end of the chain will be told to attach to whatever is configured
898 * below it.
899 *
900 * @returns VBox status code.
901 * @param pUVM The user mode VM handle.
902 * @param pszDevice Device name.
903 * @param iInstance Device instance.
904 * @param iLun The Logical Unit to obtain the interface of.
905 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
906 * @param ppBase Where to store the base interface pointer. Optional.
907 *
908 * @thread EMT
909 */
910VMMR3DECL(int) PDMR3DriverAttach(PUVM pUVM, const char *pszDevice, unsigned iInstance, unsigned iLun, uint32_t fFlags, PPPDMIBASE ppBase)
911{
912 LogFlow(("PDMR3DriverAttach: pszDevice=%p:{%s} iInstance=%d iLun=%d fFlags=%#x ppBase=%p\n",
913 pszDevice, pszDevice, iInstance, iLun, fFlags, ppBase));
914 UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
915 PVM pVM = pUVM->pVM;
916 VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
917 VM_ASSERT_EMT(pVM);
918
919 if (ppBase)
920 *ppBase = NULL;
921
922 /*
923 * Find the LUN in question.
924 */
925 PPDMLUN pLun;
926 int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
927 if (RT_SUCCESS(rc))
928 {
929 /*
930 * Anything attached to the LUN?
931 */
932 PPDMDRVINS pDrvIns = pLun->pTop;
933 if (!pDrvIns)
934 {
935 /* No, ask the device to attach to the new stuff. */
936 PPDMDEVINS pDevIns = pLun->pDevIns;
937 if (pDevIns->pReg->pfnAttach)
938 {
939 PDMCritSectEnter(pDevIns->pCritSectRoR3, VERR_IGNORED);
940 rc = pDevIns->pReg->pfnAttach(pDevIns, iLun, fFlags);
941 if (RT_SUCCESS(rc) && ppBase)
942 *ppBase = pLun->pTop ? &pLun->pTop->IBase : NULL;
943 PDMCritSectLeave(pDevIns->pCritSectRoR3);
944 }
945 else
946 rc = VERR_PDM_DEVICE_NO_RT_ATTACH;
947 }
948 else
949 {
950 /* Yes, find the bottom most driver and ask it to attach to the new stuff. */
951 while (pDrvIns->Internal.s.pDown)
952 pDrvIns = pDrvIns->Internal.s.pDown;
953 if (pDrvIns->pReg->pfnAttach)
954 {
955 rc = pDrvIns->pReg->pfnAttach(pDrvIns, fFlags);
956 if (RT_SUCCESS(rc) && ppBase)
957 *ppBase = pDrvIns->Internal.s.pDown
958 ? &pDrvIns->Internal.s.pDown->IBase
959 : NULL;
960 }
961 else
962 rc = VERR_PDM_DRIVER_NO_RT_ATTACH;
963 }
964 }
965
966 if (ppBase)
967 LogFlow(("PDMR3DriverAttach: returns %Rrc *ppBase=%p\n", rc, *ppBase));
968 else
969 LogFlow(("PDMR3DriverAttach: returns %Rrc\n", rc));
970 return rc;
971}
972
973
974/**
975 * Detaches the specified driver instance.
976 *
977 * This is used to replumb drivers at runtime for simulating hot plugging and
978 * media changes.
979 *
980 * This is a superset of PDMR3DeviceDetach. It allows detaching drivers from
981 * any driver or device by specifying the driver to start detaching at. The
982 * only prerequisite is that the driver or device above implements the
983 * pfnDetach callback (PDMDRVREG / PDMDEVREG).
984 *
985 * @returns VBox status code.
986 * @param pUVM The user mode VM handle.
987 * @param pszDevice Device name.
988 * @param iDevIns Device instance.
989 * @param iLun The Logical Unit in which to look for the driver.
990 * @param pszDriver The name of the driver which to detach. If NULL
991 * then the entire driver chain is detatched.
992 * @param iOccurrence The occurrence of that driver in the chain. This is
993 * usually 0.
994 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
995 * @thread EMT
996 */
997VMMR3DECL(int) PDMR3DriverDetach(PUVM pUVM, const char *pszDevice, unsigned iDevIns, unsigned iLun,
998 const char *pszDriver, unsigned iOccurrence, uint32_t fFlags)
999{
1000 LogFlow(("PDMR3DriverDetach: pszDevice=%p:{%s} iDevIns=%u iLun=%u pszDriver=%p:{%s} iOccurrence=%u fFlags=%#x\n",
1001 pszDevice, pszDevice, iDevIns, iLun, pszDriver, pszDriver, iOccurrence, fFlags));
1002 UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1003 PVM pVM = pUVM->pVM;
1004 VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1005 VM_ASSERT_EMT(pVM);
1006 AssertPtr(pszDevice);
1007 AssertPtrNull(pszDriver);
1008 Assert(iOccurrence == 0 || pszDriver);
1009 Assert(!(fFlags & ~(PDM_TACH_FLAGS_NOT_HOT_PLUG)));
1010
1011 /*
1012 * Find the LUN in question.
1013 */
1014 PPDMLUN pLun;
1015 int rc = pdmR3DevFindLun(pVM, pszDevice, iDevIns, iLun, &pLun);
1016 if (RT_SUCCESS(rc))
1017 {
1018 /*
1019 * Locate the driver.
1020 */
1021 PPDMDRVINS pDrvIns = pLun->pTop;
1022 if (pDrvIns)
1023 {
1024 if (pszDriver)
1025 {
1026 while (pDrvIns)
1027 {
1028 if (!strcmp(pDrvIns->pReg->szName, pszDriver))
1029 {
1030 if (iOccurrence == 0)
1031 break;
1032 iOccurrence--;
1033 }
1034 pDrvIns = pDrvIns->Internal.s.pDown;
1035 }
1036 }
1037 if (pDrvIns)
1038 rc = pdmR3DrvDetach(pDrvIns, fFlags);
1039 else
1040 rc = VERR_PDM_DRIVER_INSTANCE_NOT_FOUND;
1041 }
1042 else
1043 rc = VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN;
1044 }
1045
1046 LogFlow(("PDMR3DriverDetach: returns %Rrc\n", rc));
1047 return rc;
1048}
1049
1050
1051/**
1052 * Runtime detach and reattach of a new driver chain or sub chain.
1053 *
1054 * This is intended to be called on a non-EMT thread, this will instantiate the
1055 * new driver (sub-)chain, and then the EMTs will do the actual replumbing. The
1056 * destruction of the old driver chain will be taken care of on the calling
1057 * thread.
1058 *
1059 * @returns VBox status code.
1060 * @param pUVM The user mode VM handle.
1061 * @param pszDevice Device name.
1062 * @param iDevIns Device instance.
1063 * @param iLun The Logical Unit in which to look for the driver.
1064 * @param pszDriver The name of the driver which to detach and replace.
1065 * If NULL then the entire driver chain is to be
1066 * reattached.
1067 * @param iOccurrence The occurrence of that driver in the chain. This is
1068 * usually 0.
1069 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1070 * @param pCfg The configuration of the new driver chain that is
1071 * going to be attached. The subtree starts with the
1072 * node containing a Driver key, a Config subtree and
1073 * optionally an AttachedDriver subtree.
1074 * If this parameter is NULL, then this call will work
1075 * like at a non-pause version of PDMR3DriverDetach.
1076 * @param ppBase Where to store the base interface pointer to the new
1077 * driver. Optional.
1078 *
1079 * @thread Any thread. The EMTs will be involved at some point though.
1080 */
1081VMMR3DECL(int) PDMR3DriverReattach(PUVM pUVM, const char *pszDevice, unsigned iDevIns, unsigned iLun,
1082 const char *pszDriver, unsigned iOccurrence, uint32_t fFlags,
1083 PCFGMNODE pCfg, PPPDMIBASE ppBase)
1084{
1085 NOREF(pUVM); NOREF(pszDevice); NOREF(iDevIns); NOREF(iLun); NOREF(pszDriver); NOREF(iOccurrence);
1086 NOREF(fFlags); NOREF(pCfg); NOREF(ppBase);
1087 return VERR_NOT_IMPLEMENTED;
1088}
1089
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use