VirtualBox

source: vbox/trunk/src/VBox/VMM/PDM.cpp@ 5734

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

Added a bottom pointer to the PDMLUN structure. Added plugge/unplugged notifications to PDMUSBREG. Fixed destroy/reset problem. Fixed failure path issue, where a static string was passed to RTStrFree.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 38.4 KB
Line 
1/* $Id: PDM.cpp 5722 2007-11-13 16:13:43Z vboxsync $ */
2/** @file
3 * PDM - Pluggable Device Manager.
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.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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/** @page pg_pdm PDM - The Pluggable Device Manager
20 *
21 * VBox is designed to be very configurable, i.e. the ability to select
22 * virtual devices and configure them uniquely for a VM. For this reason
23 * virtual devices are not statically linked with the VMM but loaded and
24 * linked at runtime thru the Configuration Manager (CFGM). PDM will use
25 * CFGM to enumerate devices which needs loading and instantiation.
26 *
27 *
28 * @section sec_pdm_dev The Pluggable Device
29 *
30 * Devices register themselves when the module containing them is loaded.
31 * PDM will call an entry point 'VBoxDevicesRegister' when loading a device
32 * module. The device module will then use the supplied callback table to
33 * check the VMM version and to register its devices. Each device have an
34 * unique (for the configured VM) name (string). The name is not only used
35 * in PDM but in CFGM - to organize device and device instance settings - and
36 * by anyone who wants to do ioctls to the device.
37 *
38 * When all device modules have been successfully loaded PDM will instantiate
39 * those devices which are configured for the VM. Mark that this might mean
40 * creating several instances of some devices. When instantiating a device
41 * PDM provides device instance memory and a callback table with the VM APIs
42 * which the device instance is trusted with.
43 *
44 * Some devices are trusted devices, most are not. The trusted devices are
45 * an integrated part of the VM and can obtain the VM handle from their
46 * device instance handles, thus enabling them to call any VM api. Untrusted
47 * devices are can only use the callbacks provided during device
48 * instantiation.
49 *
50 * The guest context extention (optional) of a device is initialized as part
51 * of the GC init. A device marks in it's registration structure that it have
52 * a GC part, in which module and which name the entry point have. PDM will
53 * use its loader facilities to load this module into GC and to find the
54 * specified entry point.
55 *
56 * When writing a GC extention the programmer must keep in mind that this
57 * code will be relocated, so that using global/static pointer variables
58 * won't work.
59 *
60 *
61 * @section sec_pdm_drv The Pluggable Drivers
62 *
63 * The VM devices are often accessing host hardware or OS facilities. For
64 * most devices these facilities can be abstracted in one or more levels.
65 * These abstractions are called drivers.
66 *
67 * For instance take a DVD/CD drive. This can be connected to a SCSI
68 * controller, EIDE controller or SATA controller. The basics of the
69 * DVD/CD drive implementation remains the same - eject, insert,
70 * read, seek, and such. (For the scsi case, you might wanna speak SCSI
71 * directly to, but that can of course be fixed.) So, it makes much sense to
72 * have a generic CD/DVD driver which implements this.
73 *
74 * Then the media 'inserted' into the DVD/CD drive can be a ISO image, or
75 * it can be read from a real CD or DVD drive (there are probably other
76 * custom formats someone could desire to read or construct too). So, it
77 * would make sense to have abstracted interfaces for dealing with this
78 * in a generic way so the cdrom unit doesn't have to implement it all.
79 * Thus we have created the CDROM/DVD media driver family.
80 *
81 * So, for this example the IDE controller #1 (i.e. secondary) will have
82 * the DVD/CD Driver attached to it's LUN #0 (master). When a media is mounted
83 * the DVD/CD Driver will have a ISO, NativeCD, NativeDVD or RAW (media) Driver
84 * attached.
85 *
86 * It is possible to configure many levels of drivers inserting filters, loggers,
87 * or whatever you desire into the chain.
88 *
89 *
90 * @subsection sec_pdm_drv_interfaces Interfaces
91 *
92 * The pluggable drivers exposes one standard interface (callback table) which
93 * is used to construct, destruct, attach, detach, and query other interfaces.
94 * A device will query the interfaces required for it's operation during init
95 * and hotplug. PDM will query some interfaces during runtime mounting too.
96 *
97 * ... list interfaces ...
98 *
99 */
100
101
102/*******************************************************************************
103* Header Files *
104*******************************************************************************/
105#define LOG_GROUP LOG_GROUP_PDM
106#include "PDMInternal.h"
107#include <VBox/pdm.h>
108#include <VBox/mm.h>
109#include <VBox/ssm.h>
110#include <VBox/vm.h>
111#include <VBox/vmm.h>
112#include <VBox/param.h>
113#include <VBox/err.h>
114#include <VBox/sup.h>
115
116#include <VBox/log.h>
117#include <iprt/asm.h>
118#include <iprt/assert.h>
119#include <iprt/alloc.h>
120#include <iprt/ldr.h>
121#include <iprt/path.h>
122#include <iprt/string.h>
123
124
125/*******************************************************************************
126* Defined Constants And Macros *
127*******************************************************************************/
128/** The PDM saved state version. */
129#define PDM_SAVED_STATE_VERSION 3
130
131
132/*******************************************************************************
133* Internal Functions *
134*******************************************************************************/
135static DECLCALLBACK(int) pdmR3Save(PVM pVM, PSSMHANDLE pSSM);
136static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
137static DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM);
138static DECLCALLBACK(void) pdmR3PollerTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
139
140
141
142/**
143 * Initializes the PDM.
144 *
145 * @returns VBox status code.
146 * @param pVM The VM to operate on.
147 */
148PDMR3DECL(int) PDMR3Init(PVM pVM)
149{
150 LogFlow(("PDMR3Init\n"));
151
152 /*
153 * Assert alignment and sizes.
154 */
155 AssertRelease(!(RT_OFFSETOF(VM, pdm.s) & 31));
156 AssertRelease(sizeof(pVM->pdm.s) <= sizeof(pVM->pdm.padding));
157
158 /*
159 * Init the structure.
160 */
161 pVM->pdm.s.offVM = RT_OFFSETOF(VM, pdm.s);
162
163 int rc = TMR3TimerCreateInternal(pVM, TMCLOCK_VIRTUAL, pdmR3PollerTimer, NULL, "PDM Poller", &pVM->pdm.s.pTimerPollers);
164 AssertRC(rc);
165
166 /*
167 * Initialize sub compontents.
168 */
169 rc = pdmR3CritSectInit(pVM);
170 if (VBOX_SUCCESS(rc))
171 {
172#ifdef VBOX_WITH_PDM_LOCK
173 rc = PDMR3CritSectInit(pVM, &pVM->pdm.s.CritSect, "PDM");
174 if (VBOX_SUCCESS(rc))
175#endif
176 rc = pdmR3LdrInit(pVM);
177 if (VBOX_SUCCESS(rc))
178 {
179 rc = pdmR3DrvInit(pVM);
180 if (VBOX_SUCCESS(rc))
181 {
182 rc = pdmR3DevInit(pVM);
183 if (VBOX_SUCCESS(rc))
184 {
185 /*
186 * Register the saved state data unit.
187 */
188 rc = SSMR3RegisterInternal(pVM, "pdm", 1, PDM_SAVED_STATE_VERSION, 128,
189 NULL, pdmR3Save, NULL,
190 pdmR3LoadPrep, pdmR3Load, NULL);
191 if (VBOX_SUCCESS(rc))
192 {
193 LogFlow(("PDM: Successfully initialized\n"));
194 return rc;
195 }
196
197 }
198 }
199 }
200 }
201
202 /*
203 * Cleanup and return failure.
204 */
205 PDMR3Term(pVM);
206 LogFlow(("PDMR3Init: returns %Vrc\n", rc));
207 return rc;
208}
209
210
211/**
212 * Applies relocations to data and code managed by this
213 * component. This function will be called at init and
214 * whenever the VMM need to relocate it self inside the GC.
215 *
216 * @param pVM VM handle.
217 * @param offDelta Relocation delta relative to old location.
218 * @remark The loader subcomponent is relocated by PDMR3LdrRelocate() very
219 * early in the relocation phase.
220 */
221PDMR3DECL(void) PDMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
222{
223 LogFlow(("PDMR3Relocate\n"));
224
225 /*
226 * Queues.
227 */
228 pdmR3QueueRelocate(pVM, offDelta);
229 pVM->pdm.s.pDevHlpQueueGC = PDMQueueGCPtr(pVM->pdm.s.pDevHlpQueueHC);
230
231 /*
232 * Critical sections.
233 */
234 pdmR3CritSectRelocate(pVM);
235
236 /*
237 * The registered PIC.
238 */
239 if (pVM->pdm.s.Pic.pDevInsGC)
240 {
241 pVM->pdm.s.Pic.pDevInsGC += offDelta;
242 pVM->pdm.s.Pic.pfnSetIrqGC += offDelta;
243 pVM->pdm.s.Pic.pfnGetInterruptGC += offDelta;
244 }
245
246 /*
247 * The registered APIC.
248 */
249 if (pVM->pdm.s.Apic.pDevInsGC)
250 {
251 pVM->pdm.s.Apic.pDevInsGC += offDelta;
252 pVM->pdm.s.Apic.pfnGetInterruptGC += offDelta;
253 pVM->pdm.s.Apic.pfnSetBaseGC += offDelta;
254 pVM->pdm.s.Apic.pfnGetBaseGC += offDelta;
255 pVM->pdm.s.Apic.pfnSetTPRGC += offDelta;
256 pVM->pdm.s.Apic.pfnGetTPRGC += offDelta;
257 pVM->pdm.s.Apic.pfnBusDeliverGC += offDelta;
258 }
259
260 /*
261 * The registered I/O APIC.
262 */
263 if (pVM->pdm.s.IoApic.pDevInsGC)
264 {
265 pVM->pdm.s.IoApic.pDevInsGC += offDelta;
266 pVM->pdm.s.IoApic.pfnSetIrqGC += offDelta;
267 }
268
269 /*
270 * The register PCI Buses.
271 */
272 for (unsigned i = 0; i < ELEMENTS(pVM->pdm.s.aPciBuses); i++)
273 {
274 if (pVM->pdm.s.aPciBuses[i].pDevInsGC)
275 {
276 pVM->pdm.s.aPciBuses[i].pDevInsGC += offDelta;
277 pVM->pdm.s.aPciBuses[i].pfnSetIrqGC += offDelta;
278 }
279 }
280
281 /*
282 * Devices.
283 */
284 GCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
285 int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmGCDevHlp", &pDevHlpGC);
286 AssertReleaseMsgRC(rc, ("rc=%Vrc when resolving g_pdmGCDevHlp\n", rc));
287 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
288 {
289 if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC)
290 {
291 pDevIns->pDevHlpGC = pDevHlpGC;
292 pDevIns->pvInstanceDataGC = MMHyperR3ToGC(pVM, pDevIns->pvInstanceDataR3);
293 pDevIns->pvInstanceDataR0 = MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3);
294 pDevIns->Internal.s.pVMGC = pVM->pVMGC;
295 if (pDevIns->Internal.s.pPciBusHC)
296 pDevIns->Internal.s.pPciBusGC = MMHyperR3ToGC(pVM, pDevIns->Internal.s.pPciBusHC);
297 if (pDevIns->Internal.s.pPciDeviceHC)
298 pDevIns->Internal.s.pPciDeviceGC = MMHyperR3ToGC(pVM, pDevIns->Internal.s.pPciDeviceHC);
299 if (pDevIns->pDevReg->pfnRelocate)
300 {
301 LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
302 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
303 pDevIns->pDevReg->pfnRelocate(pDevIns, offDelta);
304 }
305 }
306 }
307}
308
309
310/**
311 * Worker for pdmR3Term that terminates a LUN chain.
312 *
313 * @param pVM Pointer to the shared VM structure.
314 * @param pLun The head of the chain.
315 * @param pszDevice The name of the device (for logging).
316 * @param iInstance The device instance number (for logging).
317 */
318static void pdmR3TermLuns(PVM pVM, PPDMLUN pLun, const char *pszDevice, unsigned iInstance)
319{
320 for (; pLun; pLun = pLun->pNext)
321 {
322 /*
323 * Destroy them one at a time from the bottom up.
324 * (The serial device/drivers depends on this - bad.)
325 */
326 PPDMDRVINS pDrvIns = pLun->pBottom;
327 pLun->pBottom = pLun->pTop = NULL;
328 while (pDrvIns)
329 {
330 PPDMDRVINS pDrvNext = pDrvIns->Internal.s.pUp;
331
332 if (pDrvIns->pDrvReg->pfnDestruct)
333 {
334 LogFlow(("pdmR3DevTerm: Destroying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
335 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pszDevice, iInstance));
336 pDrvIns->pDrvReg->pfnDestruct(pDrvIns);
337 }
338
339 TMR3TimerDestroyDriver(pVM, pDrvIns);
340 //PDMR3QueueDestroyDriver(pVM, pDrvIns);
341 //pdmR3ThreadDestroyDriver(pVM, pDrvIns);
342 SSMR3DeregisterDriver(pVM, pDrvIns, NULL, 0);
343
344 pDrvIns = pDrvNext;
345 }
346 }
347}
348
349
350/**
351 * Terminates the PDM.
352 *
353 * Termination means cleaning up and freeing all resources,
354 * the VM it self is at this point powered off or suspended.
355 *
356 * @returns VBox status code.
357 * @param pVM The VM to operate on.
358 */
359PDMR3DECL(int) PDMR3Term(PVM pVM)
360{
361 LogFlow(("PDMR3Term:\n"));
362 AssertMsg(pVM->pdm.s.offVM, ("bad init order!\n"));
363
364 /*
365 * Iterate the device instances and attach drivers, doing
366 * relevant destruction processing.
367 *
368 * N.B. There is no need to mess around freeing memory allocated
369 * from any MM heap since MM will do that in its Term function.
370 */
371 /* usb ones first. */
372 for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
373 {
374 pdmR3TermLuns(pVM, pUsbIns->Internal.s.pLuns, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance);
375
376 if (pUsbIns->pUsbReg->pfnDestruct)
377 {
378 LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
379 pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
380 pUsbIns->pUsbReg->pfnDestruct(pUsbIns);
381 }
382
383 //TMR3TimerDestroyUsb(pVM, pUsbIns);
384 //SSMR3DeregisterUsb(pVM, pUsbIns, NULL, 0);
385 pdmR3ThreadDestroyUsb(pVM, pUsbIns);
386 }
387
388 /* then the 'normal' ones. */
389 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
390 {
391 pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsHC, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
392
393 if (pDevIns->pDevReg->pfnDestruct)
394 {
395 LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
396 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
397 pDevIns->pDevReg->pfnDestruct(pDevIns);
398 }
399
400 TMR3TimerDestroyDevice(pVM, pDevIns);
401 //SSMR3DeregisterDriver(pVM, pDevIns, NULL, 0);
402 pdmR3CritSectDeleteDevice(pVM, pDevIns);
403 //pdmR3ThreadDestroyDevice(pVM, pDevIns);
404 //PDMR3QueueDestroyDevice(pVM, pDevIns);
405 }
406
407 /*
408 * Destroy all threads.
409 */
410 pdmR3ThreadDestroyAll(pVM);
411
412 /*
413 * Free modules.
414 */
415 pdmR3LdrTerm(pVM);
416
417#ifdef VBOX_WITH_PDM_LOCK
418 /*
419 * Destroy the PDM lock.
420 */
421 PDMR3CritSectDelete(&pVM->pdm.s.CritSect);
422#endif
423
424 LogFlow(("PDMR3Term: returns %Vrc\n", VINF_SUCCESS));
425 return VINF_SUCCESS;
426}
427
428
429/**
430 * Execute state save operation.
431 *
432 * @returns VBox status code.
433 * @param pVM VM Handle.
434 * @param pSSM SSM operation handle.
435 */
436static DECLCALLBACK(int) pdmR3Save(PVM pVM, PSSMHANDLE pSSM)
437{
438 LogFlow(("pdmR3Save:\n"));
439
440 /*
441 * Save interrupt and DMA states.
442 */
443 SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC));
444 SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC));
445 SSMR3PutUInt(pSSM, VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
446
447 /*
448 * Save the list of device instances so we can check that
449 * they're all still there when we load the state and that
450 * nothing new have been added.
451 */
452 /** @todo We might have to filter out some device classes, like USB attached devices. */
453 uint32_t i = 0;
454 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC, i++)
455 {
456 SSMR3PutU32(pSSM, i);
457 SSMR3PutStrZ(pSSM, pDevIns->pDevReg->szDeviceName);
458 SSMR3PutU32(pSSM, pDevIns->iInstance);
459 }
460 return SSMR3PutU32(pSSM, ~0); /* terminator */
461}
462
463
464/**
465 * Prepare state load operation.
466 *
467 * This will dispatch pending operations and clear the FFs governed by PDM and its devices.
468 *
469 * @returns VBox status code.
470 * @param pVM The VM handle.
471 * @param pSSM The SSM handle.
472 */
473static DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM)
474{
475 LogFlow(("pdmR3LoadPrep: %s%s%s%s\n",
476 VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES) ? " VM_FF_PDM_QUEUES" : "",
477 VM_FF_ISSET(pVM, VM_FF_PDM_DMA) ? " VM_FF_PDM_DMA" : "",
478 VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC) ? " VM_FF_INTERRUPT_APIC" : "",
479 VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC) ? " VM_FF_INTERRUPT_PIC" : ""
480 ));
481
482 /*
483 * In case there is work pending that will raise an interrupt,
484 * start a DMA transfer, or release a lock. (unlikely)
485 */
486 if (VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES))
487 PDMR3QueueFlushAll(pVM);
488
489 /* Clear the FFs. */
490 VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
491 VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
492 VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
493
494 return VINF_SUCCESS;
495}
496
497
498/**
499 * Execute state load operation.
500 *
501 * @returns VBox status code.
502 * @param pVM VM Handle.
503 * @param pSSM SSM operation handle.
504 * @param u32Version Data layout version.
505 */
506static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version)
507{
508 LogFlow(("pdmR3Load:\n"));
509
510 /*
511 * Validate version.
512 */
513 if (u32Version != PDM_SAVED_STATE_VERSION)
514 {
515 Log(("pdmR3Load: Invalid version u32Version=%d!\n", u32Version));
516 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
517 }
518
519 /*
520 * Load the interrupt and DMA states.
521 */
522 /* APIC interrupt */
523 RTUINT fInterruptPending = 0;
524 int rc = SSMR3GetUInt(pSSM, &fInterruptPending);
525 if (VBOX_FAILURE(rc))
526 return rc;
527 if (fInterruptPending & ~1)
528 {
529 AssertMsgFailed(("fInterruptPending=%#x (APIC)\n", fInterruptPending));
530 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
531 }
532 AssertRelease(!VM_FF_ISSET(pVM, VM_FF_INTERRUPT_APIC));
533 if (fInterruptPending)
534 VM_FF_SET(pVM, VM_FF_INTERRUPT_APIC);
535
536 /* PIC interrupt */
537 fInterruptPending = 0;
538 rc = SSMR3GetUInt(pSSM, &fInterruptPending);
539 if (VBOX_FAILURE(rc))
540 return rc;
541 if (fInterruptPending & ~1)
542 {
543 AssertMsgFailed(("fInterruptPending=%#x (PIC)\n", fInterruptPending));
544 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
545 }
546 AssertRelease(!VM_FF_ISSET(pVM, VM_FF_INTERRUPT_PIC));
547 if (fInterruptPending)
548 VM_FF_SET(pVM, VM_FF_INTERRUPT_PIC);
549
550 /* DMA pending */
551 RTUINT fDMAPending = 0;
552 rc = SSMR3GetUInt(pSSM, &fDMAPending);
553 if (VBOX_FAILURE(rc))
554 return rc;
555 if (fDMAPending & ~1)
556 {
557 AssertMsgFailed(("fDMAPending=%#x\n", fDMAPending));
558 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
559 }
560 AssertRelease(!VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
561 if (fDMAPending)
562 VM_FF_SET(pVM, VM_FF_PDM_DMA);
563
564 /*
565 * Load the list of devices and verify that they are all there.
566 *
567 * We boldly ASSUME that the order is fixed and that it's a good, this
568 * makes it way easier to validate...
569 */
570 uint32_t i = 0;
571 PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances;
572 for (;;pDevIns = pDevIns->Internal.s.pNextHC, i++)
573 {
574 /* Get the separator / terminator. */
575 uint32_t u32Sep;
576 int rc = SSMR3GetU32(pSSM, &u32Sep);
577 if (VBOX_FAILURE(rc))
578 return rc;
579 if (u32Sep == (uint32_t)~0)
580 break;
581 if (u32Sep != i)
582 AssertMsgFailedReturn(("Out of seqence. u32Sep=%#x i=%#x\n", u32Sep, i), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
583
584 /* get the name and instance number. */
585 char szDeviceName[sizeof(pDevIns->pDevReg->szDeviceName)];
586 rc = SSMR3GetStrZ(pSSM, szDeviceName, sizeof(szDeviceName));
587 if (VBOX_FAILURE(rc))
588 return rc;
589 RTUINT iInstance;
590 rc = SSMR3GetUInt(pSSM, &iInstance);
591 if (VBOX_FAILURE(rc))
592 return rc;
593
594 /* compare */
595 if (!pDevIns)
596 {
597 LogRel(("Device '%s'/%d not found in current config\n", szDeviceName, iInstance));
598 if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
599 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
600 break;
601 }
602 if ( strcmp(szDeviceName, pDevIns->pDevReg->szDeviceName)
603 || pDevIns->iInstance != iInstance)
604 {
605 LogRel(("u32Sep=%d loaded '%s'/%d configured '%s'/%d\n",
606 u32Sep, szDeviceName, iInstance, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
607 if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
608 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
609 }
610 }
611
612 /*
613 * Too many devices?
614 */
615 if (pDevIns)
616 {
617 LogRel(("Device '%s'/%d not found in saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
618 if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
619 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
620 }
621
622 return VINF_SUCCESS;
623}
624
625
626/**
627 * This function will notify all the devices and their
628 * attached drivers about the VM now being powered on.
629 *
630 * @param pVM VM Handle.
631 */
632PDMR3DECL(void) PDMR3PowerOn(PVM pVM)
633{
634 LogFlow(("PDMR3PowerOn:\n"));
635
636 /*
637 * Iterate the device instances.
638 * The attached drivers are processed first.
639 */
640 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
641 {
642 for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
643 /** @todo Inverse the order here? */
644 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
645 if (pDrvIns->pDrvReg->pfnPowerOn)
646 {
647 LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
648 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
649 pDrvIns->pDrvReg->pfnPowerOn(pDrvIns);
650 }
651
652 if (pDevIns->pDevReg->pfnPowerOn)
653 {
654 LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
655 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
656 pDevIns->pDevReg->pfnPowerOn(pDevIns);
657 }
658 }
659
660#ifdef VBOX_WITH_USB
661 for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
662 {
663 for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
664 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
665 if (pDrvIns->pDrvReg->pfnPowerOn)
666 {
667 LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
668 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
669 pDrvIns->pDrvReg->pfnPowerOn(pDrvIns);
670 }
671
672 if (pUsbIns->pUsbReg->pfnVMPowerOn)
673 {
674 LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
675 pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
676 pUsbIns->pUsbReg->pfnVMPowerOn(pUsbIns);
677 }
678 }
679#endif
680
681 /*
682 * Resume all threads.
683 */
684 pdmR3ThreadResumeAll(pVM);
685
686 LogFlow(("PDMR3PowerOn: returns void\n"));
687}
688
689
690
691
692/**
693 * This function will notify all the devices and their
694 * attached drivers about the VM now being reset.
695 *
696 * @param pVM VM Handle.
697 */
698PDMR3DECL(void) PDMR3Reset(PVM pVM)
699{
700 LogFlow(("PDMR3Reset:\n"));
701
702 /*
703 * Clear all pending interrupts and DMA operations.
704 */
705 VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
706 VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_PIC);
707 VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
708
709 /*
710 * Iterate the device instances.
711 * The attached drivers are processed first.
712 */
713 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
714 {
715 for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
716 /** @todo Inverse the order here? */
717 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
718 if (pDrvIns->pDrvReg->pfnReset)
719 {
720 LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
721 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
722 pDrvIns->pDrvReg->pfnReset(pDrvIns);
723 }
724
725 if (pDevIns->pDevReg->pfnReset)
726 {
727 LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
728 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
729 pDevIns->pDevReg->pfnReset(pDevIns);
730 }
731 }
732
733#ifdef VBOX_WITH_USB
734 for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
735 {
736 for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
737 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
738 if (pDrvIns->pDrvReg->pfnReset)
739 {
740 LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
741 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
742 pDrvIns->pDrvReg->pfnReset(pDrvIns);
743 }
744
745 if (pUsbIns->pUsbReg->pfnVMReset)
746 {
747 LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
748 pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
749 pUsbIns->pUsbReg->pfnVMReset(pUsbIns);
750 }
751 }
752#endif
753
754 LogFlow(("PDMR3Reset: returns void\n"));
755}
756
757
758/**
759 * This function will notify all the devices and their
760 * attached drivers about the VM now being reset.
761 *
762 * @param pVM VM Handle.
763 */
764PDMR3DECL(void) PDMR3Suspend(PVM pVM)
765{
766 LogFlow(("PDMR3Suspend:\n"));
767
768 /*
769 * Iterate the device instances.
770 * The attached drivers are processed first.
771 */
772 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
773 {
774 for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
775 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
776 if (pDrvIns->pDrvReg->pfnSuspend)
777 {
778 LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
779 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
780 pDrvIns->pDrvReg->pfnSuspend(pDrvIns);
781 }
782
783 if (pDevIns->pDevReg->pfnSuspend)
784 {
785 LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
786 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
787 pDevIns->pDevReg->pfnSuspend(pDevIns);
788 }
789 }
790
791#ifdef VBOX_WITH_USB
792 for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
793 {
794 for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
795 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
796 if (pDrvIns->pDrvReg->pfnSuspend)
797 {
798 LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
799 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
800 pDrvIns->pDrvReg->pfnSuspend(pDrvIns);
801 }
802
803 if (pUsbIns->pUsbReg->pfnVMSuspend)
804 {
805 LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
806 pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
807 pUsbIns->pUsbReg->pfnVMSuspend(pUsbIns);
808 }
809 }
810#endif
811
812 /*
813 * Suspend all threads.
814 */
815 pdmR3ThreadSuspendAll(pVM);
816
817 LogFlow(("PDMR3Suspend: returns void\n"));
818}
819
820
821/**
822 * This function will notify all the devices and their
823 * attached drivers about the VM now being resumed.
824 *
825 * @param pVM VM Handle.
826 */
827PDMR3DECL(void) PDMR3Resume(PVM pVM)
828{
829 LogFlow(("PDMR3Resume:\n"));
830
831 /*
832 * Iterate the device instances.
833 * The attached drivers are processed first.
834 */
835 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
836 {
837 for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
838 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
839 if (pDrvIns->pDrvReg->pfnResume)
840 {
841 LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
842 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
843 pDrvIns->pDrvReg->pfnResume(pDrvIns);
844 }
845
846 if (pDevIns->pDevReg->pfnResume)
847 {
848 LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
849 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
850 pDevIns->pDevReg->pfnResume(pDevIns);
851 }
852 }
853
854#ifdef VBOX_WITH_USB
855 for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
856 {
857 for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
858 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
859 if (pDrvIns->pDrvReg->pfnResume)
860 {
861 LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
862 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
863 pDrvIns->pDrvReg->pfnResume(pDrvIns);
864 }
865
866 if (pUsbIns->pUsbReg->pfnVMResume)
867 {
868 LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
869 pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
870 pUsbIns->pUsbReg->pfnVMResume(pUsbIns);
871 }
872 }
873#endif
874
875 /*
876 * Resume all threads.
877 */
878 pdmR3ThreadResumeAll(pVM);
879
880 LogFlow(("PDMR3Resume: returns void\n"));
881}
882
883
884/**
885 * This function will notify all the devices and their
886 * attached drivers about the VM being powered off.
887 *
888 * @param pVM VM Handle.
889 */
890PDMR3DECL(void) PDMR3PowerOff(PVM pVM)
891{
892 LogFlow(("PDMR3PowerOff:\n"));
893
894 /*
895 * Iterate the device instances.
896 * The attached drivers are processed first.
897 */
898 for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
899 {
900 for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
901 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
902 if (pDrvIns->pDrvReg->pfnPowerOff)
903 {
904 LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
905 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
906 pDrvIns->pDrvReg->pfnPowerOff(pDrvIns);
907 }
908
909 if (pDevIns->pDevReg->pfnPowerOff)
910 {
911 LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
912 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
913 pDevIns->pDevReg->pfnPowerOff(pDevIns);
914 }
915 }
916
917#ifdef VBOX_WITH_USB
918 for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
919 {
920 for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
921 for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
922 if (pDrvIns->pDrvReg->pfnPowerOff)
923 {
924 LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
925 pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
926 pDrvIns->pDrvReg->pfnPowerOff(pDrvIns);
927 }
928
929 if (pUsbIns->pUsbReg->pfnVMPowerOff)
930 {
931 LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
932 pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
933 pUsbIns->pUsbReg->pfnVMPowerOff(pUsbIns);
934 }
935 }
936#endif
937
938 /*
939 * Suspend all threads.
940 */
941 pdmR3ThreadSuspendAll(pVM);
942
943 LogFlow(("PDMR3PowerOff: returns void\n"));
944}
945
946
947/**
948 * Queries the base interace of a device instance.
949 *
950 * The caller can use this to query other interfaces the device implements
951 * and use them to talk to the device.
952 *
953 * @returns VBox status code.
954 * @param pVM VM handle.
955 * @param pszDevice Device name.
956 * @param iInstance Device instance.
957 * @param ppBase Where to store the pointer to the base device interface on success.
958 * @remark We're not doing any locking ATM, so don't try call this at times when the
959 * device chain is known to be updated.
960 */
961PDMR3DECL(int) PDMR3QueryDevice(PVM pVM, const char *pszDevice, unsigned iInstance, PPDMIBASE *ppBase)
962{
963 LogFlow(("PDMR3DeviceQuery: pszDevice=%p:{%s} iInstance=%u ppBase=%p\n", pszDevice, pszDevice, iInstance, ppBase));
964
965 /*
966 * Iterate registered devices looking for the device.
967 */
968 RTUINT cchDevice = strlen(pszDevice);
969 for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
970 {
971 if ( pDev->cchName == cchDevice
972 && !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
973 {
974 /*
975 * Iterate device instances.
976 */
977 for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextHC)
978 {
979 if (pDevIns->iInstance == iInstance)
980 {
981 if (pDevIns->IBase.pfnQueryInterface)
982 {
983 *ppBase = &pDevIns->IBase;
984 LogFlow(("PDMR3DeviceQuery: return VINF_SUCCESS and *ppBase=%p\n", *ppBase));
985 return VINF_SUCCESS;
986 }
987
988 LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NO_IBASE\n"));
989 return VERR_PDM_DEVICE_INSTANCE_NO_IBASE;
990 }
991 }
992
993 LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NOT_FOUND\n"));
994 return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
995 }
996 }
997
998 LogFlow(("PDMR3QueryDevice: returns VERR_PDM_DEVICE_NOT_FOUND\n"));
999 return VERR_PDM_DEVICE_NOT_FOUND;
1000}
1001
1002
1003/**
1004 * Queries the base interface of a device LUN.
1005 *
1006 * This differs from PDMR3QueryLun by that it returns the interface on the
1007 * device and not the top level driver.
1008 *
1009 * @returns VBox status code.
1010 * @param pVM VM Handle.
1011 * @param pszDevice Device name.
1012 * @param iInstance Device instance.
1013 * @param iLun The Logical Unit to obtain the interface of.
1014 * @param ppBase Where to store the base interface pointer.
1015 * @remark We're not doing any locking ATM, so don't try call this at times when the
1016 * device chain is known to be updated.
1017 */
1018PDMR3DECL(int) PDMR3QueryDeviceLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
1019{
1020 LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
1021 pszDevice, pszDevice, iInstance, iLun, ppBase));
1022
1023 /*
1024 * Find the LUN.
1025 */
1026 PPDMLUN pLun;
1027 int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
1028 if (VBOX_SUCCESS(rc))
1029 {
1030 *ppBase = pLun->pBase;
1031 LogFlow(("PDMR3QueryDeviceLun: return VINF_SUCCESS and *ppBase=%p\n", *ppBase));
1032 return VINF_SUCCESS;
1033 }
1034 LogFlow(("PDMR3QueryDeviceLun: returns %Vrc\n", rc));
1035 return rc;
1036}
1037
1038
1039/**
1040 * Query the interface of the top level driver on a LUN.
1041 *
1042 * @returns VBox status code.
1043 * @param pVM VM Handle.
1044 * @param pszDevice Device name.
1045 * @param iInstance Device instance.
1046 * @param iLun The Logical Unit to obtain the interface of.
1047 * @param ppBase Where to store the base interface pointer.
1048 * @remark We're not doing any locking ATM, so don't try call this at times when the
1049 * device chain is known to be updated.
1050 */
1051PDMR3DECL(int) PDMR3QueryLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
1052{
1053 LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
1054 pszDevice, pszDevice, iInstance, iLun, ppBase));
1055
1056 /*
1057 * Find the LUN.
1058 */
1059 PPDMLUN pLun;
1060 int rc = pdmR3DevFindLun(pVM, pszDevice, iInstance, iLun, &pLun);
1061 if (VBOX_SUCCESS(rc))
1062 {
1063 if (pLun->pTop)
1064 {
1065 *ppBase = &pLun->pTop->IBase;
1066 LogFlow(("PDMR3QueryLun: return %Vrc and *ppBase=%p\n", VINF_SUCCESS, *ppBase));
1067 return VINF_SUCCESS;
1068 }
1069 rc = VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN;
1070 }
1071 LogFlow(("PDMR3QueryLun: returns %Vrc\n", rc));
1072 return rc;
1073}
1074
1075/**
1076 * Executes pending DMA transfers.
1077 * Forced Action handler.
1078 *
1079 * @param pVM VM handle.
1080 */
1081PDMR3DECL(void) PDMR3DmaRun(PVM pVM)
1082{
1083 VM_FF_CLEAR(pVM, VM_FF_PDM_DMA);
1084 if (pVM->pdm.s.pDmac)
1085 {
1086 bool fMore = pVM->pdm.s.pDmac->Reg.pfnRun(pVM->pdm.s.pDmac->pDevIns);
1087 if (fMore)
1088 VM_FF_SET(pVM, VM_FF_PDM_DMA);
1089 }
1090}
1091
1092
1093/**
1094 * Call polling function.
1095 *
1096 * @param pVM VM handle.
1097 */
1098PDMR3DECL(void) PDMR3Poll(PVM pVM)
1099{
1100 /* This is temporary hack and shall be removed ASAP! */
1101 unsigned iPoller = pVM->pdm.s.cPollers;
1102 if (iPoller)
1103 {
1104 while (iPoller-- > 0)
1105 pVM->pdm.s.apfnPollers[iPoller](pVM->pdm.s.aDrvInsPollers[iPoller]);
1106 TMTimerSetMillies(pVM->pdm.s.pTimerPollers, 3);
1107 }
1108}
1109
1110
1111/**
1112 * Internal timer callback function.
1113 *
1114 * @param pVM The VM.
1115 * @param pTimer The timer handle.
1116 * @param pvUser User argument specified upon timer creation.
1117 */
1118static DECLCALLBACK(void) pdmR3PollerTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
1119{
1120 PDMR3Poll(pVM);
1121}
1122
1123
1124/**
1125 * Serivce a VMMCALLHOST_PDM_LOCK call.
1126 *
1127 * @returns VBox status code.
1128 * @param pVM The VM handle.
1129 */
1130PDMR3DECL(int) PDMR3LockCall(PVM pVM)
1131{
1132 return pdmLockEx(pVM, VERR_INTERNAL_ERROR);
1133}
1134
Note: See TracBrowser for help on using the repository browser.

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