PDM.cpp revision 6dea6d87ed79bc0994d314fed1c90431091e8820
/* $Id$ */
/** @file
* PDM - Pluggable Device Manager.
*/
/*
* Copyright (C) 2006-2007 Sun Microsystems, Inc.
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/** @page pg_pdm PDM - The Pluggable Device & Driver Manager
*
* VirtualBox is designed to be very configurable, i.e. the ability to select
* virtual devices and configure them uniquely for a VM. For this reason
* virtual devices are not statically linked with the VMM but loaded, linked and
* instantiated at runtime by PDM using the information found in the
* Configuration Manager (CFGM).
*
* While the chief purpose of PDM is to manager of devices their drivers, it
* also serves as somewhere to put usful things like cross context queues, cross
* context synchronization (like critsect), VM centric thread management,
* asynchronous I/O framework, and so on.
*
* @see grp_pdm
*
*
* @section sec_pdm_dev The Pluggable Devices
*
* Devices register themselves when the module containing them is loaded. PDM
* will call the entry point 'VBoxDevicesRegister' when loading a device module.
* The device module will then use the supplied callback table to check the VMM
* version and to register its devices. Each device have an unique (for the
* configured VM) name. The name is not only used in PDM but also in CFGM (to
* organize device and device instance settings) and by anyone who wants to talk
* to a specific device instance.
*
* When all device modules have been successfully loaded PDM will instantiate
* those devices which are configured for the VM. Note that a device may have
* more than one instance, see network adaptors for instance. When
* instantiating a device PDM provides device instance memory and a callback
* table (aka Device Helpers / DevHlp) with the VM APIs which the device
* instance is trusted with.
*
* Some devices are trusted devices, most are not. The trusted devices are an
* integrated part of the VM and can obtain the VM handle from their device
* instance handles, thus enabling them to call any VM api. Untrusted devices
* can only use the callbacks provided during device instantiation.
*
* The main purpose in having DevHlps rather than just giving all the devices
* the VM handle and let them call the internal VM APIs directly, is both to
* create a binary interface that can be supported accross releases and to
* create a barrier between devices and the VM. (The trusted / untrusted bit
* hasn't turned out to be of much use btw., but it's easy to maintain so there
* isn't any point in removing it.)
*
* the VM performance by handling exits and traps (respectively) without
* requiring context switches (to ring-3). Callbacks for MMIO and I/O ports can
* needs to be registered specifically for the additional contexts for this to
* because of the extra privilege it entails. Note that raw-mode code and data
* will be subject to relocation.
*
*
* @section sec_pdm_special_devs Special Devices
*
* will work like a mediator for these. The typical pattern is that the device
* calls a special registration device helper with a set of callbacks, PDM
* responds by copying this and providing a pointer to a set helper callbacks
* for that particular kind of device. Unlike interfaces where the callback
* table pointer is used a 'this' pointer, these arrangements will use the
* device instance pointer (PPDMDEVINS) as a kind of 'this' pointer.
*
* For an example of this kind of setup, see the PIC. The PIC registers itself
* by calling PDMDEVHLPR3::pfnPICRegister. PDM saves the device instance,
* copies the callback tables (PDMPICREG), resolving the ring-0 and raw-mode
* addresses in the process, and hands back the pointer to a set of helper
* methods (PDMPICHLPR3). The PCI device then queries the ring-0 and raw-mode
* helpers using PDMPICHLPR3::pfnGetR0Helpers and PDMPICHLPR3::pfnGetRCHelpers.
* The PCI device repeates ths pfnGetRCHelpers call in it's relocation method
* since the address changes when RC is relocated.
*
* @see grp_pdm_device
*
*
* @section sec_pdm_usbdev The Pluggable USB Devices
*
* USB devices are handled a little bit differently than other devices. The
* general concepts wrt. pluggability are mostly the same, but the details
* varies. The registration entry point is 'VBoxUsbRegister', the device
* instance is PDMUSBINS and the callbacks helpers are different. Also, USB
* device are restricted to ring-3 and cannot have any ring-0 or raw-mode
* extensions (at least not yet).
*
* The way USB devices work differs greatly from other devices though since they
* USB host control (OHCI, UHCI or EHCI). USB devices handles USB requests
* (URBs) and does not register I/O ports, MMIO ranges or PCI bus
*
* @see grp_pdm_usbdev
*
*
* @section sec_pdm_drv The Pluggable Drivers
*
* The VM devices are often accessing host hardware or OS facilities. For most
* devices these facilities can be abstracted in one or more levels. These
* abstractions are called drivers.
*
* drive implementation remains the same - eject, insert, read, seek, and such.
* (For the scsi case, you might wanna speak SCSI directly to, but that can of
* course be fixed - see SCSI passthru.) So, it
*
* be read from a real CD or DVD drive (there are probably other custom formats
* someone could desire to read or construct too). So, it would make sense to
* have abstracted interfaces for dealing with this in a generic way so the
* cdrom unit doesn't have to implement it all. Thus we have created the
*
* So, for this example the IDE controller #1 (i.e. secondary) will have
*
* It is possible to configure many levels of drivers inserting filters, loggers,
* or whatever you desire into the chain. We're using this for network sniffing
* for instance.
*
* The drivers are loaded in a similar manner to that of the device, namely by
* iterating a keyspace in CFGM, load the modules listed there and call
* 'VBoxDriversRegister' with a callback table.
*
* @see grp_pdm_driver
*
*
* @section sec_pdm_ifs Interfaces
*
* The pluggable drivers and devices exposes one standard interface (callback
* table) which is used to construct, destruct, attach, detach,( ++,) and query
* other interfaces. A device will query the interfaces required for it's
* operation during init and hotplug. PDM may query some interfaces during
* runtime mounting too.
*
* An interface here means a function table contained within the device or
* driver instance data. Its method are invoked with the function table pointer
* as the first argument and they will calculate the address of the device or
* driver instance data from it. (This is one of the aspects which *might* have
* been better done in C++.)
*
* @see grp_pdm_interfaces
*
*
* @section sec_pdm_utils Utilities
*
* As mentioned earlier, PDM is the location of any usful constrcts that doesn't
* quite fit into IPRT. The next subsections will discuss these.
*
* One thing these APIs all have in common is that resources will be associated
* with a device / driver and automatically freed after it has been destroyed if
* the destructor didn't do this.
*
*
* @subsection sec_pdm_async_completion Async I/O
*
* The PDM Async I/O API provides a somewhat platform agnostic interface for
* asynchronous I/O. For reasons of performance and complexcity this does not
* build upon any IPRT API.
*
* @todo more details.
*
* @see grp_pdm_async_completion
*
*
* @subsection sec_pdm_async_task Async Task - not implemented
*
* @todo implement and describe
*
* @see grp_pdm_async_task
*
*
* @subsection sec_pdm_critsect Critical Section
*
* The PDM Critical Section API is currently building on the IPRT API with the
* same name. It adds the posibility to use critical sections in ring-0 and
* raw-mode as well as in ring-3. There are certain restrictions on the RC and
* R0 usage though since we're not able to wait on it, nor wake up anyone that
* is waiting on it. These restrictions origins with the use of a ring-3 event
* semaphore. In a later incarnation we plan to replace the ring-3 event
* semaphore with a ring-0 one, thus enabling us to wake up waiters while
* exectuing in ring-0 and making the hardware assisted execution mode more
* efficient. (Raw-mode won't benefit much from this, naturally.)
*
* @see grp_pdm_critsect
*
*
* @subsection sec_pdm_queue Queue
*
* The PDM Queue API is for queuing one or more tasks for later consumption in
* ring-3 by EMT, and optinally forcing a delayed or ASAP return to ring-3. The
* queues can also be run on a timer basis as an alternative to the ASAP thing.
* The queue will be flushed at forced action time.
*
* A queue can also be used by another thread (a I/O worker for instance) to
* send work / events over to the EMT.
*
* @see grp_pdm_queue
*
*
* @subsection sec_pdm_task Task - not implemented yet
*
* The PDM Task API is for flagging a task for execution at a later point when
* we're back in ring-3, optionally forcing the ring-3 return to happen ASAP.
* As you can see the concept is similar to queues only simpler.
*
* A task can also be scheduled by another thread (a I/O worker for instance) as
* a mean of getting something done in EMT.
*
* @see grp_pdm_task
*
*
* @subsection sec_pdm_thread Thread
*
* The PDM Thread API is there to help devices and drivers manage their threads
* correctly wrt. power on, suspend, resume, power off and destruction.
*
* The general usage pattern for threads in the employ of devices and drivers is
* that they shuffle data or requests while the VM is running and stop doing
* this when the VM is paused or powered down. Rogue threads running while the
* VM is paused can cause the state to change during saving or have other
* unwanted side effects. The PDM Threads API ensures that this won't happen.
*
* @see grp_pdm_thread
*
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_PDM
#include "PDMInternal.h"
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
/** The PDM saved state version. */
#define PDM_SAVED_STATE_VERSION 4
#define PDM_SAVED_STATE_VERSION_PRE_NMI_FF 3
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
/**
* Initializes the PDM part of the UVM.
*
* This doesn't really do much right now but has to be here for the sake
* of completeness.
*
* @returns VBox status code.
* @param pUVM Pointer to the user mode VM structure.
*/
{
return VINF_SUCCESS;
}
/**
* Initializes the PDM.
*
* @returns VBox status code.
* @param pVM The VM to operate on.
*/
{
LogFlow(("PDMR3Init\n"));
/*
* Assert alignment and sizes.
*/
/*
* Init the structure.
*/
/*
* Initialize sub compontents.
*/
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
#endif
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
{
/*
* Register the saved state data unit.
*/
if (RT_SUCCESS(rc))
{
LogFlow(("PDM: Successfully initialized\n"));
return rc;
}
}
/*
* Cleanup and return failure.
*/
return rc;
}
/**
* Applies relocations to data and code managed by this
* component. This function will be called at init and
* whenever the VMM need to relocate it self inside the GC.
*
* @param pVM VM handle.
* @param offDelta Relocation delta relative to old location.
* @remark The loader subcomponent is relocated by PDMR3LdrRelocate() very
* early in the relocation phase.
*/
{
LogFlow(("PDMR3Relocate\n"));
/*
* Queues.
*/
/*
* Critical sections.
*/
/*
* The registered PIC.
*/
{
}
/*
* The registered APIC.
*/
{
}
/*
* The registered I/O APIC.
*/
{
}
/*
* The register PCI Buses.
*/
{
{
}
}
/*
* Devices.
*/
{
{
{
LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
}
}
}
}
/**
* Worker for pdmR3Term that terminates a LUN chain.
*
* @param pVM Pointer to the shared VM structure.
* @param pLun The head of the chain.
* @param pszDevice The name of the device (for logging).
* @param iInstance The device instance number (for logging).
*/
{
{
/*
* Destroy them one at a time from the bottom up.
*/
while (pDrvIns)
{
{
LogFlow(("pdmR3DevTerm: Destroying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
}
//PDMR3QueueDestroyDriver(pVM, pDrvIns);
//pdmR3ThreadDestroyDriver(pVM, pDrvIns);
}
}
}
/**
* Terminates the PDM.
*
* Termination means cleaning up and freeing all resources,
* the VM it self is at this point powered off or suspended.
*
* @returns VBox status code.
* @param pVM The VM to operate on.
*/
{
LogFlow(("PDMR3Term:\n"));
/*
* Iterate the device instances and attach drivers, doing
* relevant destruction processing.
*
* N.B. There is no need to mess around freeing memory allocated
* from any MM heap since MM will do that in its Term function.
*/
/* usb ones first. */
{
{
LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
}
//TMR3TimerDestroyUsb(pVM, pUsbIns);
//SSMR3DeregisterUsb(pVM, pUsbIns, NULL, 0);
}
/* then the 'normal' ones. */
{
pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
{
LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
}
//SSMR3DeregisterDriver(pVM, pDevIns, NULL, 0);
//pdmR3ThreadDestroyDevice(pVM, pDevIns);
//PDMR3QueueDestroyDevice(pVM, pDevIns);
}
/*
* Destroy all threads.
*/
/*
* Free async completion managers.
*/
#endif
/*
* Free modules.
*/
/*
* Destroy the PDM lock.
*/
/* The MiscCritSect is deleted by PDMR3CritSectTerm. */
return VINF_SUCCESS;
}
/**
* Terminates the PDM part of the UVM.
*
* This will unload any modules left behind.
*
* @param pUVM Pointer to the user mode VM structure.
*/
{
/*
* In the normal cause of events we will now call pdmR3LdrTermU for
* the second time. In the case of init failure however, this might
* the first time, which is why we do it.
*/
}
/**
* Execute state save operation.
*
* @returns VBox status code.
* @param pVM VM Handle.
* @param pSSM SSM operation handle.
*/
{
LogFlow(("pdmR3Save:\n"));
/*
* Save interrupt and DMA states.
*/
{
}
/*
* Save the list of device instances so we can check that
* they're all still there when we load the state and that
* nothing new have been added.
*/
/** @todo We might have to filter out some device classes, like USB attached devices. */
uint32_t i = 0;
for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3, i++)
{
SSMR3PutU32(pSSM, i);
}
}
/**
* Prepare state load operation.
*
* This will dispatch pending operations and clear the FFs governed by PDM and its devices.
*
* @returns VBox status code.
* @param pVM The VM handle.
* @param pSSM The SSM handle.
*/
{
LogFlow(("pdmR3LoadPrep: %s%s%s%s\n",
));
#ifdef LOG_ENABLED
{
));
}
#endif
/*
* In case there is work pending that will raise an interrupt,
* start a DMA transfer, or release a lock. (unlikely)
*/
/* Clear the FFs. */
{
}
return VINF_SUCCESS;
}
/**
* Execute state load operation.
*
* @returns VBox status code.
* @param pVM VM Handle.
* @param pSSM SSM operation handle.
* @param uVersion Data layout version.
* @param uPass The data pass.
*/
{
int rc;
LogFlow(("pdmR3Load:\n"));
/*
* Validate version.
*/
if ( uVersion != PDM_SAVED_STATE_VERSION
{
}
/*
* Load the interrupt and DMA states.
*/
{
/* APIC interrupt */
RTUINT fInterruptPending = 0;
if (RT_FAILURE(rc))
return rc;
if (fInterruptPending & ~1)
{
}
if (fInterruptPending)
/* PIC interrupt */
fInterruptPending = 0;
if (RT_FAILURE(rc))
return rc;
if (fInterruptPending & ~1)
{
}
if (fInterruptPending)
{
/* NMI interrupt */
RTUINT fInterruptPending = 0;
if (RT_FAILURE(rc))
return rc;
if (fInterruptPending & ~1)
{
}
if (fInterruptPending)
/* SMI interrupt */
fInterruptPending = 0;
if (RT_FAILURE(rc))
return rc;
if (fInterruptPending & ~1)
{
}
if (fInterruptPending)
}
}
/* DMA pending */
RTUINT fDMAPending = 0;
if (RT_FAILURE(rc))
return rc;
if (fDMAPending & ~1)
{
}
if (fDMAPending)
/*
* Load the list of devices and verify that they are all there.
*
* We boldly ASSUME that the order is fixed and that it's a good, this
* makes it way easier to validate...
*/
uint32_t i = 0;
{
/* Get the separator / terminator. */
if (RT_FAILURE(rc))
return rc;
break;
if (u32Sep != i)
AssertMsgFailedReturn(("Out of seqence. u32Sep=%#x i=%#x\n", u32Sep, i), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
/* get the name and instance number. */
if (RT_FAILURE(rc))
return rc;
if (RT_FAILURE(rc))
return rc;
/* compare */
if (!pDevIns)
{
break;
}
{
LogRel(("u32Sep=%d loaded '%s'/%d configured '%s'/%d\n",
}
}
/*
* Too many devices?
*/
if (pDevIns)
{
LogRel(("Device '%s'/%d not found in saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
}
return VINF_SUCCESS;
}
/**
* This function will notify all the devices and their
* attached drivers about the VM now being powered on.
*
* @param pVM VM Handle.
*/
{
LogFlow(("PDMR3PowerOn:\n"));
/*
* Iterate the device instances.
* The attached drivers are processed first.
*/
{
/** @todo Inverse the order here? */
{
LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
}
{
LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
}
}
#ifdef VBOX_WITH_USB
{
{
LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n",
}
}
#endif
/*
* Resume all threads.
*/
LogFlow(("PDMR3PowerOn: returns void\n"));
}
/**
* This function will notify all the devices and their
* attached drivers about the VM now being reset.
*
* @param pVM VM Handle.
*/
{
LogFlow(("PDMR3Reset:\n"));
/*
* Clear all pending interrupts and DMA operations.
*/
{
}
/*
* Iterate the device instances.
* The attached drivers are processed first.
*/
{
/** @todo Inverse the order here? */
{
LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
}
{
LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
}
}
#ifdef VBOX_WITH_USB
{
{
LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n",
}
}
#endif
LogFlow(("PDMR3Reset: returns void\n"));
}
/**
* This function will notify all the devices and their
* attached drivers about the VM now being reset.
*
* @param pVM VM Handle.
*/
{
LogFlow(("PDMR3Suspend:\n"));
/*
* Iterate the device instances.
* The attached drivers are processed first.
*/
{
/*
* Some devices need to be notified first that the VM is suspended to ensure that that there are no pending
* requests from the guest which are still processed. Calling the drivers before these requests are finished
* might lead to errors otherwise. One example is the SATA controller which might still have I/O requests
* pending. But DrvVD sets the files into readonly mode and every request will fail then.
*/
if (pDevIns->pDevReg->pfnSuspend && (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION))
{
LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
}
{
LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
}
/* Don't call the suspend notification again if it was already called. */
if (pDevIns->pDevReg->pfnSuspend && !(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION))
{
LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
}
}
#ifdef VBOX_WITH_USB
{
{
LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n",
}
}
#endif
/*
* Suspend all threads.
*/
LogFlow(("PDMR3Suspend: returns void\n"));
}
/**
* This function will notify all the devices and their
* attached drivers about the VM now being resumed.
*
* @param pVM VM Handle.
*/
{
LogFlow(("PDMR3Resume:\n"));
/*
* Iterate the device instances.
* The attached drivers are processed first.
*/
{
{
LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
}
{
LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
}
}
#ifdef VBOX_WITH_USB
{
{
LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n",
}
}
#endif
/*
* Resume all threads.
*/
LogFlow(("PDMR3Resume: returns void\n"));
}
/**
* This function will notify all the devices and their
* attached drivers about the VM being powered off.
*
* @param pVM VM Handle.
*/
{
LogFlow(("PDMR3PowerOff:\n"));
/*
* Iterate the device instances.
* The attached drivers are processed first.
*/
{
if (pDevIns->pDevReg->pfnPowerOff && (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION))
{
LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
}
{
LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
}
if (pDevIns->pDevReg->pfnPowerOff && !(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION))
{
LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
}
}
#ifdef VBOX_WITH_USB
{
{
LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of usb device '%s'/%d\n",
pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, pLun->iLun, pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n",
}
}
#endif
/*
* Suspend all threads.
*/
LogFlow(("PDMR3PowerOff: returns void\n"));
}
/**
* Queries the base interace of a device instance.
*
* The caller can use this to query other interfaces the device implements
* and use them to talk to the device.
*
* @returns VBox status code.
* @param pVM VM handle.
* @param pszDevice Device name.
* @param iInstance Device instance.
* @param ppBase Where to store the pointer to the base device interface on success.
* @remark We're not doing any locking ATM, so don't try call this at times when the
* device chain is known to be updated.
*/
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));
/*
* Iterate registered devices looking for the device.
*/
{
{
/*
* Iterate device instances.
*/
for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextR3)
{
{
{
return VINF_SUCCESS;
}
LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NO_IBASE\n"));
}
}
LogFlow(("PDMR3DeviceQuery: returns VERR_PDM_DEVICE_INSTANCE_NOT_FOUND\n"));
}
}
LogFlow(("PDMR3QueryDevice: returns VERR_PDM_DEVICE_NOT_FOUND\n"));
return VERR_PDM_DEVICE_NOT_FOUND;
}
/**
* Queries the base interface of a device LUN.
*
* This differs from PDMR3QueryLun by that it returns the interface on the
* device and not the top level driver.
*
* @returns VBox status code.
* @param pVM VM Handle.
* @param pszDevice Device name.
* @param iInstance Device instance.
* @param iLun The Logical Unit to obtain the interface of.
* @param ppBase Where to store the base interface pointer.
* @remark We're not doing any locking ATM, so don't try call this at times when the
* device chain is known to be updated.
*/
VMMR3DECL(int) PDMR3QueryDeviceLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
{
LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
/*
* Find the LUN.
*/
if (RT_SUCCESS(rc))
{
return VINF_SUCCESS;
}
return rc;
}
/**
* Query the interface of the top level driver on a LUN.
*
* @returns VBox status code.
* @param pVM VM Handle.
* @param pszDevice Device name.
* @param iInstance Device instance.
* @param iLun The Logical Unit to obtain the interface of.
* @param ppBase Where to store the base interface pointer.
* @remark We're not doing any locking ATM, so don't try call this at times when the
* device chain is known to be updated.
*/
VMMR3DECL(int) PDMR3QueryLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
{
LogFlow(("PDMR3QueryLun: pszDevice=%p:{%s} iInstance=%u iLun=%u ppBase=%p\n",
/*
* Find the LUN.
*/
if (RT_SUCCESS(rc))
{
{
return VINF_SUCCESS;
}
}
return rc;
}
/**
* Executes pending DMA transfers.
* Forced Action handler.
*
* @param pVM VM handle.
*/
{
/* Note! Not really SMP safe; restrict it to VCPU 0. */
if (VMMGetCpuId(pVM) != 0)
return;
{
{
if (fMore)
}
}
}
/**
* Service a VMMCALLRING3_PDM_LOCK call.
*
* @returns VBox status code.
* @param pVM The VM handle.
*/
{
}
/**
* Registers the VMM device heap
*
* @returns VBox status code.
* @param pVM VM handle.
* @param GCPhys The physical address.
* @param pvHeap Ring-3 pointer.
* @param cbSize Size of the heap.
*/
{
return VINF_SUCCESS;
}
/**
* Unregisters the VMM device heap
*
* @returns VBox status code.
* @param pVM VM handle.
* @param GCPhys The physical address.
*/
{
return VINF_SUCCESS;
}
/**
* Allocates memory from the VMM device heap
*
* @returns VBox status code.
* @param pVM VM handle.
* @param cbSize Allocation size.
* @param pv Ring-3 pointer. (out)
*/
{
#ifdef DEBUG_bird
return VERR_NO_MEMORY;
#else
#endif
/** @todo not a real heap as there's currently only one user. */
return VINF_SUCCESS;
}
/**
* Frees memory from the VMM device heap
*
* @returns VBox status code.
* @param pVM VM handle.
* @param pv Ring-3 pointer.
*/
{
/** @todo not a real heap as there's currently only one user. */
return VINF_SUCCESS;
}
/**
* Release the PDM lock if owned by the current VCPU
*
* @param pVM The VM to operate on.
*/
{
}