VirtualBox

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

Last change on this file since 9212 was 9212, checked in by vboxsync, 16 years ago

Major changes for sizeof(RTGCPTR) == uint64_t.
Introduced RCPTRTYPE for pointers valid in raw mode only (RTGCPTR32).

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