PDM.cpp revision 06dc6eb95cf33b2b83f0d07c602d1ca20a575663
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * PDM - Pluggable Device Manager.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Copyright (C) 2006-2007 Sun Microsystems, Inc.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * available from http://www.virtualbox.org. This file is free software;
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * you can redistribute it and/or modify it under the terms of the GNU
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * General Public License (GPL) as published by the Free Software
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * additional information or have any questions.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/** @page pg_pdm PDM - The Pluggable Device & Driver Manager
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * VirtualBox is designed to be very configurable, i.e. the ability to select
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * virtual devices and configure them uniquely for a VM. For this reason
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * virtual devices are not statically linked with the VMM but loaded, linked and
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * instantiated at runtime by PDM using the information found in the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Configuration Manager (CFGM).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * While the chief purpose of PDM is to manager of devices their drivers, it
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * also serves as somewhere to put usful things like cross context queues, cross
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * context synchronization (like critsect), VM centric thread management,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * asynchronous I/O framework, and so on.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @section sec_pdm_dev The Pluggable Devices
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Devices register themselves when the module containing them is loaded. PDM
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * will call the entry point 'VBoxDevicesRegister' when loading a device module.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The device module will then use the supplied callback table to check the VMM
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * version and to register its devices. Each device have an unique (for the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * configured VM) name. The name is not only used in PDM but also in CFGM (to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * organize device and device instance settings) and by anyone who wants to talk
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * to a specific device instance.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * When all device modules have been successfully loaded PDM will instantiate
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * those devices which are configured for the VM. Note that a device may have
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * more than one instance, see network adaptors for instance. When
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * instantiating a device PDM provides device instance memory and a callback
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * table (aka Device Helpers / DevHlp) with the VM APIs which the device
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * instance is trusted with.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Some devices are trusted devices, most are not. The trusted devices are an
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * integrated part of the VM and can obtain the VM handle from their device
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * instance handles, thus enabling them to call any VM api. Untrusted devices
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * can only use the callbacks provided during device instantiation.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The main purpose in having DevHlps rather than just giving all the devices
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the VM handle and let them call the internal VM APIs directly, is both to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * create a binary interface that can be supported accross releases and to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * create a barrier between devices and the VM. (The trusted / untrusted bit
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * hasn't turned out to be of much use btw., but it's easy to maintain so there
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * isn't any point in removing it.)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * A device can provide a ring-0 and/or a raw-mode context extension to improve
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the VM performance by handling exits and traps (respectively) without
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * requiring context switches (to ring-3). Callbacks for MMIO and I/O ports can
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * needs to be registered specifically for the additional contexts for this to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * make sense. Also, the device has to be trusted to be loaded into R0/RC
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * because of the extra privilege it entails. Note that raw-mode code and data
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * will be subject to relocation.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @section sec_pdm_special_devs Special Devices
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Several kinds of devices interacts with the VMM and/or other device and PDM
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * will work like a mediator for these. The typical pattern is that the device
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * calls a special registration device helper with a set of callbacks, PDM
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * responds by copying this and providing a pointer to a set helper callbacks
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * for that particular kind of device. Unlike interfaces where the callback
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * table pointer is used a 'this' pointer, these arrangements will use the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * device instance pointer (PPDMDEVINS) as a kind of 'this' pointer.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * For an example of this kind of setup, see the PIC. The PIC registers itself
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * by calling PDMDEVHLPR3::pfnPICRegister. PDM saves the device instance,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * copies the callback tables (PDMPICREG), resolving the ring-0 and raw-mode
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * addresses in the process, and hands back the pointer to a set of helper
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * methods (PDMPICHLPR3). The PCI device then queries the ring-0 and raw-mode
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * helpers using PDMPICHLPR3::pfnGetR0Helpers and PDMPICHLPR3::pfnGetRCHelpers.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The PCI device repeates ths pfnGetRCHelpers call in it's relocation method
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * since the address changes when RC is relocated.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_device
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @section sec_pdm_usbdev The Pluggable USB Devices
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * USB devices are handled a little bit differently than other devices. The
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * general concepts wrt. pluggability are mostly the same, but the details
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * varies. The registration entry point is 'VBoxUsbRegister', the device
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * instance is PDMUSBINS and the callbacks helpers are different. Also, USB
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * device are restricted to ring-3 and cannot have any ring-0 or raw-mode
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * extensions (at least not yet).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The way USB devices work differs greatly from other devices though since they
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * aren't attaches directly to the PCI/ISA/whatever system buses but via a
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * USB host control (OHCI, UHCI or EHCI). USB devices handles USB requests
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * (URBs) and does not register I/O ports, MMIO ranges or PCI bus
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_usbdev
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @section sec_pdm_drv The Pluggable Drivers
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The VM devices are often accessing host hardware or OS facilities. For most
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * devices these facilities can be abstracted in one or more levels. These
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * abstractions are called drivers.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * For instance take a DVD/CD drive. This can be connected to a SCSI
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * controller, an ATA controller or a SATA controller. The basics of the DVD/CD
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * drive implementation remains the same - eject, insert, read, seek, and such.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * (For the scsi case, you might wanna speak SCSI directly to, but that can of
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * course be fixed - see SCSI passthru.) So, it
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * makes much sense to have a generic CD/DVD driver which implements this.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Then the media 'inserted' into the DVD/CD drive can be a ISO image, or it can
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * be read from a real CD or DVD drive (there are probably other custom formats
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * someone could desire to read or construct too). So, it would make sense to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * have abstracted interfaces for dealing with this in a generic way so the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * cdrom unit doesn't have to implement it all. Thus we have created the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * CDROM/DVD media driver family.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * So, for this example the IDE controller #1 (i.e. secondary) will have
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the DVD/CD Driver attached to it's LUN #0 (master). When a media is mounted
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the DVD/CD Driver will have a ISO, HostDVD or RAW (media) Driver attached.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * It is possible to configure many levels of drivers inserting filters, loggers,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * or whatever you desire into the chain. We're using this for network sniffing
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * for instance.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The drivers are loaded in a similar manner to that of the device, namely by
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * iterating a keyspace in CFGM, load the modules listed there and call
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * 'VBoxDriversRegister' with a callback table.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_driver
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @section sec_pdm_ifs Interfaces
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The pluggable drivers and devices exposes one standard interface (callback
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * table) which is used to construct, destruct, attach, detach,( ++,) and query
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * other interfaces. A device will query the interfaces required for it's
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * operation during init and hot-plug. PDM may query some interfaces during
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * runtime mounting too.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * An interface here means a function table contained within the device or
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * driver instance data. Its method are invoked with the function table pointer
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * as the first argument and they will calculate the address of the device or
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * driver instance data from it. (This is one of the aspects which *might* have
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * been better done in C++.)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_interfaces
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @section sec_pdm_utils Utilities
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * As mentioned earlier, PDM is the location of any usful constrcts that doesn't
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * quite fit into IPRT. The next subsections will discuss these.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * One thing these APIs all have in common is that resources will be associated
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * with a device / driver and automatically freed after it has been destroyed if
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the destructor didn't do this.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @subsection sec_pdm_async_completion Async I/O
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The PDM Async I/O API provides a somewhat platform agnostic interface for
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * asynchronous I/O. For reasons of performance and complexcity this does not
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * build upon any IPRT API.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @todo more details.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_async_completion
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @subsection sec_pdm_async_task Async Task - not implemented
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @todo implement and describe
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_async_task
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @subsection sec_pdm_critsect Critical Section
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The PDM Critical Section API is currently building on the IPRT API with the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * same name. It adds the posibility to use critical sections in ring-0 and
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * raw-mode as well as in ring-3. There are certain restrictions on the RC and
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * R0 usage though since we're not able to wait on it, nor wake up anyone that
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * is waiting on it. These restrictions origins with the use of a ring-3 event
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * semaphore. In a later incarnation we plan to replace the ring-3 event
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * semaphore with a ring-0 one, thus enabling us to wake up waiters while
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * exectuing in ring-0 and making the hardware assisted execution mode more
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * efficient. (Raw-mode won't benefit much from this, naturally.)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_critsect
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @subsection sec_pdm_queue Queue
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The PDM Queue API is for queuing one or more tasks for later consumption in
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * ring-3 by EMT, and optinally forcing a delayed or ASAP return to ring-3. The
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * queues can also be run on a timer basis as an alternative to the ASAP thing.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The queue will be flushed at forced action time.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * A queue can also be used by another thread (a I/O worker for instance) to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * send work / events over to the EMT.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_queue
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @subsection sec_pdm_task Task - not implemented yet
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The PDM Task API is for flagging a task for execution at a later point when
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * we're back in ring-3, optionally forcing the ring-3 return to happen ASAP.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * As you can see the concept is similar to queues only simpler.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * A task can also be scheduled by another thread (a I/O worker for instance) as
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * a mean of getting something done in EMT.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_task
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @subsection sec_pdm_thread Thread
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The PDM Thread API is there to help devices and drivers manage their threads
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * correctly wrt. power on, suspend, resume, power off and destruction.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The general usage pattern for threads in the employ of devices and drivers is
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * that they shuffle data or requests while the VM is running and stop doing
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * this when the VM is paused or powered down. Rogue threads running while the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * VM is paused can cause the state to change during saving or have other
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * unwanted side effects. The PDM Threads API ensures that this won't happen.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @see grp_pdm_thread
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/*******************************************************************************
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync* Header Files *
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync*******************************************************************************/
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/*******************************************************************************
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync* Defined Constants And Macros *
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync*******************************************************************************/
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/** The PDM saved state version. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/*******************************************************************************
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync* Internal Functions *
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync*******************************************************************************/
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3LiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3SaveExec(PVM pVM, PSSMHANDLE pSSM);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3LoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Initializes the PDM part of the UVM.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This doesn't really do much right now but has to be here for the sake
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * of completeness.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pUVM Pointer to the user mode VM structure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertCompile(sizeof(pUVM->pdm.s) <= sizeof(pUVM->pdm.padding));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertRelease(sizeof(pUVM->pdm.s) <= sizeof(pUVM->pdm.padding));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Initializes the PDM.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM The VM to operate on.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Assert alignment and sizes.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertRelease(sizeof(pVM->pdm.s) <= sizeof(pVM->pdm.padding));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertCompileMemberAlignment(PDM, CritSect, sizeof(uintptr_t));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Init the structure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Initialize sub compontents.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rc = PDMR3CritSectInit(pVM, &pVM->pdm.s.CritSect, RT_SRC_POS, "PDM");
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Register the saved state data unit.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rc = SSMR3RegisterInternal(pVM, "pdm", 1, PDM_SAVED_STATE_VERSION, 128,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Cleanup and return failure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Applies relocations to data and code managed by this
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * component. This function will be called at init and
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * whenever the VMM need to relocate it self inside the GC.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM VM handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param offDelta Relocation delta relative to old location.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @remark The loader subcomponent is relocated by PDMR3LdrRelocate() very
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * early in the relocation phase.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncVMMR3DECL(void) PDMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pVM->pdm.s.pDevHlpQueueRC = PDMQueueRCPtr(pVM->pdm.s.pDevHlpQueueR3);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Critical sections.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The registered PIC.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The registered APIC.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The registered I/O APIC.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The register PCI Buses.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (unsigned i = 0; i < RT_ELEMENTS(pVM->pdm.s.aPciBuses); i++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Devices & Drivers.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync int rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDevHlp", &pDevHlpRC);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertReleaseMsgRC(rc, ("rc=%Rrc when resolving g_pdmRCDevHlp\n", rc));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDevHlp", &pDrvHlpRC);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertReleaseMsgRC(rc, ("rc=%Rrc when resolving g_pdmRCDevHlp\n", rc));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDevIns->pvInstanceDataRC = MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDevIns->Internal.s.pPciBusRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusR3);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDevIns->Internal.s.pPciDeviceRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciDeviceR3);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDrvIns->pvInstanceDataRC = MMHyperR3ToRC(pVM, pDrvIns->pvInstanceDataR3);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync LogFlow(("PDMR3Relocate: Relocating driver '%s'/%u attached to '%s'/%d/%u\n",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDevIns->pReg->szName, pDevIns->iInstance, pLun->iLun));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Worker for pdmR3Term that terminates a LUN chain.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM Pointer to the shared VM structure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pLun The head of the chain.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pszDevice The name of the device (for logging).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param iInstance The device instance number (for logging).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic void pdmR3TermLuns(PVM pVM, PPDMLUN pLun, const char *pszDevice, unsigned iInstance)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Destroy them one at a time from the bottom up.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * (The serial device/drivers depends on this - bad.)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync LogFlow(("pdmR3DevTerm: Destroying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDrvIns->pReg->szName, pDrvIns->iInstance, pLun->iLun, pszDevice, iInstance));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //PDMR3QueueDestroyDriver(pVM, pDrvIns);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //pdmR3ThreadDestroyDriver(pVM, pDrvIns);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Terminates the PDM.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Termination means cleaning up and freeing all resources,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the VM it self is at this point powered off or suspended.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM The VM to operate on.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsg(pVM->pdm.s.offVM, ("bad init order!\n"));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Iterate the device instances and attach drivers, doing
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * relevant destruction processing.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * N.B. There is no need to mess around freeing memory allocated
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * from any MM heap since MM will do that in its Term function.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* usb ones first. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pdmR3TermLuns(pVM, pUsbIns->Internal.s.pLuns, pUsbIns->pReg->szName, pUsbIns->iInstance);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //TMR3TimerDestroyUsb(pVM, pUsbIns);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //SSMR3DeregisterUsb(pVM, pUsbIns, NULL, 0);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* then the 'normal' ones. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pReg->szName, pDevIns->iInstance);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //SSMR3DeregisterDriver(pVM, pDevIns, NULL, 0);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //pdmR3ThreadDestroyDevice(pVM, pDevIns);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync //PDMR3QueueDestroyDevice(pVM, pDevIns);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync PGMR3PhysMMIO2Deregister(pVM, pDevIns, UINT32_MAX);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Destroy all threads.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Free async completion managers.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Free modules.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Destroy the PDM lock.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* The MiscCritSect is deleted by PDMR3CritSectTerm. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync LogFlow(("PDMR3Term: returns %Rrc\n", VINF_SUCCESS));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Terminates the PDM part of the UVM.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This will unload any modules left behind.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pUVM Pointer to the user mode VM structure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * In the normal cause of events we will now call pdmR3LdrTermU for
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the second time. In the case of init failure however, this might
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * the first time, which is why we do it.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Bits that are saved in pass 0 and in the final pass.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM The VM handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pSSM The saved state handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Save the list of device instances so we can check that they're all still
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * there when we load the state and that nothing new has been added.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3, i++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Live save.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM The VM handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pSSM The saved state handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param uPass The pass.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3LiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Execute state save operation.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM The VM handle.
67c73271505adae0686ddbc74eaeef778ef16792vboxsync * @param pSSM The saved state handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3SaveExec(PVM pVM, PSSMHANDLE pSSM)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Save interrupt and DMA states.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync SSMR3PutU32(pSSM, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync SSMR3PutU32(pSSM, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync SSMR3PutU32(pSSM, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_NMI));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync SSMR3PutU32(pSSM, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_SMI));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync SSMR3PutU32(pSSM, VM_FF_ISSET(pVM, VM_FF_PDM_DMA));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Prepare state load operation.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This will dispatch pending operations and clear the FFs governed by PDM and its devices.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM The VM handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pSSM The SSM handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES) ? " VM_FF_PDM_QUEUES" : "",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync VM_FF_ISSET(pVM, VM_FF_PDM_DMA) ? " VM_FF_PDM_DMA" : ""));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC) ? " VMCPU_FF_INTERRUPT_APIC" : "",
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC) ? " VMCPU_FF_INTERRUPT_PIC" : ""));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * In case there is work pending that will raise an interrupt,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * start a DMA transfer, or release a lock. (unlikely)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* Clear the FFs. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Execute state load operation.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns VBox status code.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pVM VM Handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pSSM SSM operation handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param uVersion Data layout version.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param uPass The data pass.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(int) pdmR3LoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Validate version.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailed(("Invalid version uVersion=%d!\n", uVersion));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Load the interrupt and DMA states.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* APIC interrupt */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailed(("fInterruptPending=%#x (APIC)\n", fInterruptPending));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertRelease(!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* PIC interrupt */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailed(("fInterruptPending=%#x (PIC)\n", fInterruptPending));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertRelease(!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* NMI interrupt */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailed(("fInterruptPending=%#x (NMI)\n", fInterruptPending));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertRelease(!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_NMI));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* SMI interrupt */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailed(("fInterruptPending=%#x (SMI)\n", fInterruptPending));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertRelease(!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_SMI));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* DMA pending */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailed(("fDMAPending=%#x\n", fDMAPending));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync Log(("pdmR3LoadExec: VM_FF_PDM_DMA=%RTbool\n", VM_FF_ISSET(pVM, VM_FF_PDM_DMA)));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Load the list of devices and verify that they are all there.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync pDevIns->Internal.s.fIntFlags &= ~PDMDEVINSINT_FLAGS_FOUND;
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync for (uint32_t i = 0; ; i++)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* Get the sequence number / terminator. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync AssertMsgFailedReturn(("Out of seqence. u32Sep=%#x i=%#x\n", u32Sep, i), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* Get the name and instance number. */
return rc;
return rc;
if (!pDevIns)
return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in current config"), szName, iInstance);
LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pReg->szName, pDevIns->iInstance));
return VINF_SUCCESS;
DECLINLINE(int) pdmR3PowerOnDrv(PPDMDRVINS pDrvIns, const char *pszDeviceName, uint32_t iDevInstance, uint32_t iLun)
return rc;
return VINF_SUCCESS;
return rc;
return VINF_SUCCESS;
return rc;
return VINF_SUCCESS;
for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns && RT_SUCCESS(rc); pDevIns = pDevIns->Internal.s.pNextR3)
for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns && RT_SUCCESS(rc); pDrvIns = pDrvIns->Internal.s.pDown)
#ifdef VBOX_WITH_USB
for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns && RT_SUCCESS(rc); pUsbIns = pUsbIns->Internal.s.pNext)
for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns && RT_SUCCESS(rc); pDrvIns = pDrvIns->Internal.s.pDown)
(*pcAsync)++;
LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
(*pcAsync)++;
LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
(*pcAsync)++;
#ifdef VBOX_WITH_USB
unsigned cAsync;
cAsync = 0;
#ifdef VBOX_WITH_USB
if (!cAsync)
LogFlow(("PDMR3Suspend: Async notification completed - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
(*pcAsync)++;
LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
(*pcAsync)++;
LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
(*pcAsync)++;
unsigned cAsync;
cAsync = 0;
#ifdef VBOX_WITH_USB
if (!cAsync)
DECLINLINE(int) pdmR3ResumeDrv(PPDMDRVINS pDrvIns, const char *pszDeviceName, uint32_t iDevInstance, uint32_t iLun)
return rc;
return VINF_SUCCESS;
return rc;
return VINF_SUCCESS;
return rc;
return VINF_SUCCESS;
for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns && RT_SUCCESS(rc); pDevIns = pDevIns->Internal.s.pNextR3)
for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns && RT_SUCCESS(rc); pDrvIns = pDrvIns->Internal.s.pDown)
#ifdef VBOX_WITH_USB
for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns && RT_SUCCESS(rc); pUsbIns = pUsbIns->Internal.s.pNext)
for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns && RT_SUCCESS(rc); pDrvIns = pDrvIns->Internal.s.pDown)
LogFlow(("PDMR3PowerOff: Async notification started - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
LogFlow(("PDMR3PowerOff: Async notification completed - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
(*pcAsync)++;
LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
(*pcAsync)++;
LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
(*pcAsync)++;
unsigned cAsync;
cAsync = 0;
#ifdef VBOX_WITH_USB
if (!cAsync)
VMMR3DECL(int) PDMR3QueryDevice(PVM pVM, const char *pszDevice, unsigned iInstance, PPDMIBASE *ppBase)
LogFlow(("PDMR3DeviceQuery: pszDevice=%p:{%s} iInstance=%u ppBase=%p\n", pszDevice, pszDevice, iInstance, ppBase));
for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextR3)
return VINF_SUCCESS;
return VERR_PDM_DEVICE_NOT_FOUND;
VMMR3DECL(int) PDMR3QueryDeviceLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
return VINF_SUCCESS;
return rc;
VMMR3DECL(int) PDMR3QueryLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
return VINF_SUCCESS;
return rc;
if (fMore)
return VINF_SUCCESS;
return VINF_SUCCESS;
#ifdef DEBUG_bird
return VERR_NO_MEMORY;
return VINF_SUCCESS;
return VINF_SUCCESS;