VirtualBox

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

Last change on this file since 84044 was 82968, checked in by vboxsync, 4 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use