PDM.cpp revision a0352d06ef77cf45a08eb08b4d65d570b7b294cb
/* $Id$ */
/** @file
* PDM - Pluggable Device Manager.
*/
/*
* Copyright (C) 2006-2013 Oracle Corporation
*
* 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.
*/
/** @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 across 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 repeats 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 hot-plug. 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 constructs 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 complexity 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 possibility 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 optionally 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
/** The number of nanoseconds a suspend callback needs to take before
* PDMR3Suspend warns about it taking too long. */
/** The number of nanoseconds a suspend callback needs to take before
* PDMR3PowerOff warns about it taking too long. */
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* Statistics of asynchronous notification tasks - used by reset, suspend and
* power off.
*/
typedef struct PDMNOTIFYASYNCSTATS
{
/** The start timestamp. */
/** When to log the next time. */
/** The loop counter. */
/** The number of pending asynchronous notification tasks. */
/** The name of the operation (log prefix). */
const char *pszOp;
/** The current list buffer position. */
/** String containing a list of the pending tasks. */
char szList[1024];
/** Pointer to the stats of pending asynchronous notification tasks. */
typedef PDMNOTIFYASYNCSTATS *PPDMNOTIFYASYNCSTATS;
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
static DECLCALLBACK(int) pdmR3LoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
static FNDBGFHANDLERINT pdmR3InfoTracingIds;
/**
* 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.
*/
{
}
/**
* Initializes the PDM.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
*/
{
LogFlow(("PDMR3Init\n"));
/*
* Assert alignment and sizes.
*/
/*
* Init the structure.
*/
//pVM->pdm.s.idTracingDev = 0;
/*
* Initialize critical sections first.
*/
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
}
/*
* Initialize sub components.
*/
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
#endif
#ifdef VBOX_WITH_NETSHAPER
if (RT_SUCCESS(rc))
#endif
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
{
/*
* Register the saved state data unit.
*/
if (RT_SUCCESS(rc))
{
/*
* Register the info handlers.
*/
"Displays the tracing IDs assigned by PDM to devices, USB device, drivers and more.",
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 Pointer to the VM.
* @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 & Drivers.
*/
{
{
if (pDevIns->pCritSectRoR3)
{
LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
}
}
{
{
{
{
LogFlow(("PDMR3Relocate: Relocating driver '%s'/%u attached to '%s'/%d/%u\n",
}
}
}
}
}
}
/**
* Worker for pdmR3Term that terminates a LUN chain.
*
* @param pVM Pointer to the VM.
* @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 Pointer to the VM.
*/
{
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. */
{
{
LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
}
#endif
}
/*
* Destroy all threads.
*/
/*
* Destroy the block cache.
*/
#ifdef VBOX_WITH_NETSHAPER
/*
* Destroy network bandwidth groups.
*/
#endif
/*
* Free async completion managers.
*/
#endif
/*
* Free modules.
*/
/*
* Destroy the PDM lock.
*/
/* The MiscCritSect is deleted by PDMR3CritSectBothTerm later. */
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.
*/
}
/**
* Bits that are saved in pass 0 and in the final pass.
*
* @param pVM Pointer to the VM.
* @param pSSM The saved state handle.
*/
{
/*
* 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 has been added.
*/
uint32_t i = 0;
for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3, i++)
{
SSMR3PutU32(pSSM, i);
}
}
/**
* Live save.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param pSSM The saved state handle.
* @param uPass The pass.
*/
{
LogFlow(("pdmR3LiveExec:\n"));
return VINF_SSM_DONT_CALL_AGAIN;
}
/**
* Execute state save operation.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param pSSM The saved state handle.
*/
{
LogFlow(("pdmR3SaveExec:\n"));
/*
* Save interrupt and DMA states.
*/
{
}
return VINF_SUCCESS;
}
/**
* 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 Pointer to the VM.
* @param pSSM The SSM handle.
*/
{
LogFlow(("pdmR3LoadPrep: %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 Pointer to the VM.
* @param pSSM SSM operation handle.
* @param uVersion Data layout version.
* @param uPass The data pass.
*/
{
int rc;
/*
* Validate version.
*/
if ( uVersion != PDM_SAVED_STATE_VERSION
{
}
if (uPass == SSM_PASS_FINAL)
{
/*
* Load the interrupt and DMA states.
*/
{
/* APIC interrupt */
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 */
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 */
uint32_t 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.
*/
for (uint32_t i = 0; ; i++)
{
/* Get the sequence number / terminator. */
if (RT_FAILURE(rc))
return rc;
if (u32Sep == UINT32_MAX)
break;
if (u32Sep != i)
AssertMsgFailedReturn(("Out of sequence. 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;
/* Try locate it. */
{
break;
}
if (!pDevIns)
{
return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in current config"), szName, iInstance);
}
}
/*
* Check that no additional devices were configured.
*/
{
LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pReg->szName, pDevIns->iInstance));
}
return VINF_SUCCESS;
}
/**
* Worker for PDMR3PowerOn that deals with one driver.
*
* @param pDrvIns The driver instance.
* @param pszDevName The parent device name.
* @param iDevInstance The parent device instance number.
* @param iLun The parent LUN number.
*/
DECLINLINE(int) pdmR3PowerOnDrv(PPDMDRVINS pDrvIns, const char *pszDevName, uint32_t iDevInstance, uint32_t iLun)
{
{
LogFlow(("PDMR3PowerOn: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
if (RT_FAILURE(rc))
{
LogRel(("PDMR3PowerOn: driver '%s'/%d on LUN#%d of device '%s'/%d -> %Rrc\n",
return rc;
}
}
return VINF_SUCCESS;
}
/**
* Worker for PDMR3PowerOn that deals with one USB device instance.
*
* @returns VBox status code.
* @param pUsbIns The USB device instance.
*/
{
{
if (RT_FAILURE(rc))
{
return rc;
}
}
return VINF_SUCCESS;
}
/**
* Worker for PDMR3PowerOn that deals with one device instance.
*
* @returns VBox status code.
* @param pDevIns The device instance.
*/
{
{
if (RT_FAILURE(rc))
{
return rc;
}
}
return VINF_SUCCESS;
}
/**
* This function will notify all the devices and their
* attached drivers about the VM now being powered on.
*
* @param pVM Pointer to the VM.
*/
{
LogFlow(("PDMR3PowerOn:\n"));
/*
* Iterate thru the device instances and USB device instances,
* processing the drivers associated with those.
*/
int rc = 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)
if (RT_SUCCESS(rc))
}
#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)
if (RT_SUCCESS(rc))
}
#endif
#endif
/*
* Resume all threads.
*/
if (RT_SUCCESS(rc))
/*
* On failure, clean up via PDMR3Suspend.
*/
if (RT_FAILURE(rc))
return /*rc*/;
}
/**
* Initializes the asynchronous notifi stats structure.
*
* @param pThis The asynchronous notifification stats.
* @param pszOp The name of the operation.
*/
{
pThis->cNsElapsedNextLog = 0;
}
/**
* Begin a new loop, prepares to gather new stats.
*
* @param pThis The asynchronous notifification stats.
*/
{
}
/**
* Records a device or USB device with a pending asynchronous notification.
*
* @param pThis The asynchronous notifification stats.
* @param pszName The name of the thing.
* @param iInstance The instance number.
*/
static void pdmR3NotifyAsyncAdd(PPDMNOTIFYASYNCSTATS pThis, const char *pszName, uint32_t iInstance)
{
pThis->offList += RTStrPrintf(&pThis->szList[pThis->offList], sizeof(pThis->szList) - pThis->offList,
}
/**
* Records the asynchronous completition of a reset, suspend or power off.
*
* @param pThis The asynchronous notifification stats.
* @param pszDrvName The driver name.
* @param iDrvInstance The driver instance number.
* @param pszDevName The device or USB device name.
* @param iDevInstance The device or USB device instance number.
* @param iLun The LUN.
*/
static void pdmR3NotifyAsyncAddDrv(PPDMNOTIFYASYNCSTATS pThis, const char *pszDrvName, uint32_t iDrvInstance,
{
pThis->offList += RTStrPrintf(&pThis->szList[pThis->offList], sizeof(pThis->szList) - pThis->offList,
}
/**
* Log the stats.
*
* @param pThis The asynchronous notifification stats.
*/
{
/*
* Return if we shouldn't log at this point.
* We log with an internval increasing from 0 sec to 60 sec.
*/
return;
return;
if (pThis->cNsElapsedNextLog == 0)
else
/*
* Do the logging.
*/
LogRel(("%s: after %5llu ms, %u loops: %u async tasks - %s\n",
}
/**
* Wait for events and process pending requests.
*
* @param pThis The asynchronous notifification stats.
* @param pVM Pointer to the VM.
*/
{
}
/**
* Worker for PDMR3Reset that deals with one driver.
*
* @param pDrvIns The driver instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
* @param pszDevName The parent device name.
* @param iDevInstance The parent device instance number.
* @param iLun The parent LUN number.
*/
{
{
{
{
LogFlow(("PDMR3Reset: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
LogFlow(("PDMR3Reset: Async notification started - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
}
{
LogFlow(("PDMR3Reset: Async notification completed - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
}
{
return false;
}
}
}
return true;
}
/**
* Worker for PDMR3Reset that deals with one USB device instance.
*
* @param pUsbIns The USB device instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
*/
{
{
{
{
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));
}
{
}
}
}
}
/**
* Worker for PDMR3Reset that deals with one device instance.
*
* @param pDevIns The device instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
*/
{
{
{
{
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));
}
{
}
if (cNsElapsed >= PDMSUSPEND_WARN_AT_NS)
LogRel(("PDMR3Reset: device '%s'/%d took %'llu ns to reset\n",
}
}
}
/**
* Resets a virtual CPU.
*
* Used by PDMR3Reset and CPU hot plugging.
*
* @param pVCpu Pointer to the VMCPU.
*/
{
}
/**
* This function will notify all the devices and their attached drivers about
* the VM now being reset.
*
* @param pVM Pointer to the VM.
*/
{
LogFlow(("PDMR3Reset:\n"));
/*
* Clear all the reset flags.
*/
{
}
#ifdef VBOX_WITH_USB
{
}
#endif
/*
* The outer loop repeats until there are no more async requests.
*/
for (;;)
{
/*
* Iterate thru the device instances and USB device instances,
* processing the drivers associated with those.
*/
{
break;
}
#ifdef VBOX_WITH_USB
{
break;
}
#endif
break;
}
/*
* Clear all pending interrupts and DMA operations.
*/
LogFlow(("PDMR3Reset: returns void\n"));
}
/**
* This function will tell all the devices to setup up their memory structures
* after VM construction and after VM reset.
*
* @param pVM Pointer to the VM.
* @param fAtReset Indicates the context, after reset if @c true or after
* construction if @c false.
*/
{
PDMDEVMEMSETUPCTX const enmCtx = fAtReset ? PDMDEVMEMSETUPCTX_AFTER_RESET : PDMDEVMEMSETUPCTX_AFTER_CONSTRUCTION;
/*
* Iterate thru the device instances and work the callback.
*/
{
}
LogFlow(("PDMR3MemSetup: returns void\n"));
}
/**
* Worker for PDMR3Suspend that deals with one driver.
*
* @param pDrvIns The driver instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
* @param pszDevName The parent device name.
* @param iDevInstance The parent device instance number.
* @param iLun The parent LUN number.
*/
{
{
{
{
LogFlow(("PDMR3Suspend: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
LogFlow(("PDMR3Suspend: Async notification started - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
}
{
LogFlow(("PDMR3Suspend: Async notification completed - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
}
if (cNsElapsed >= PDMSUSPEND_WARN_AT_NS)
LogRel(("PDMR3Suspend: Driver '%s'/%d on LUN#%d of device '%s'/%d took %'llu ns to suspend\n",
{
pdmR3NotifyAsyncAddDrv(pAsync, pDrvIns->Internal.s.pDrv->pReg->szName, pDrvIns->iInstance, pszDevName, iDevInstance, iLun);
return false;
}
}
}
return true;
}
/**
* Worker for PDMR3Suspend that deals with one USB device instance.
*
* @param pUsbIns The USB device instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
*/
{
{
{
{
LogFlow(("PDMR3Suspend: Notifying - USB device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
LogFlow(("PDMR3Suspend: Async notification started - USB device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3Suspend: Async notification completed - USB device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
}
{
}
if (cNsElapsed >= PDMSUSPEND_WARN_AT_NS)
LogRel(("PDMR3Suspend: USB device '%s'/%d took %'llu ns to suspend\n",
}
}
}
/**
* Worker for PDMR3Suspend that deals with one device instance.
*
* @param pDevIns The device instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
*/
{
{
{
{
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));
}
{
}
if (cNsElapsed >= PDMSUSPEND_WARN_AT_NS)
LogRel(("PDMR3Suspend: device '%s'/%d took %'llu ns to suspend\n",
}
}
}
/**
* This function will notify all the devices and their attached drivers about
* the VM now being suspended.
*
* @param pVM Pointer to the VM.
* @thread EMT(0)
*/
{
LogFlow(("PDMR3Suspend:\n"));
/*
* The outer loop repeats until there are no more async requests.
*
* Note! We depend on the suspended indicators to be in the desired state
* and we do not reset them before starting because this allows
* PDMR3PowerOn and PDMR3Resume to use PDMR3Suspend for cleaning up
* on failure.
*/
for (;;)
{
/*
* Iterate thru the device instances and USB device instances,
* processing the drivers associated with those.
*
* The attached drivers are normally processed first. Some devices
* (like DevAHCI) though needs to be notified before the drivers so
* that it doesn't kick off any new requests after the drivers stopped
* taking any. (DrvVD changes to read-only in this particular case.)
*/
{
break;
}
#ifdef VBOX_WITH_USB
{
break;
}
#endif
break;
}
/*
* Suspend all threads.
*/
}
/**
* Worker for PDMR3Resume that deals with one driver.
*
* @param pDrvIns The driver instance.
* @param pszDevName The parent device name.
* @param iDevInstance The parent device instance number.
* @param iLun The parent LUN number.
*/
DECLINLINE(int) pdmR3ResumeDrv(PPDMDRVINS pDrvIns, const char *pszDevName, uint32_t iDevInstance, uint32_t iLun)
{
{
LogFlow(("PDMR3Resume: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
if (RT_FAILURE(rc))
{
LogRel(("PDMR3Resume: driver '%s'/%d on LUN#%d of device '%s'/%d -> %Rrc\n",
return rc;
}
}
return VINF_SUCCESS;
}
/**
* Worker for PDMR3Resume that deals with one USB device instance.
*
* @returns VBox status code.
* @param pUsbIns The USB device instance.
*/
{
{
if (RT_FAILURE(rc))
{
return rc;
}
}
return VINF_SUCCESS;
}
/**
* Worker for PDMR3Resume that deals with one device instance.
*
* @returns VBox status code.
* @param pDevIns The device instance.
*/
{
{
if (RT_FAILURE(rc))
{
return rc;
}
}
return VINF_SUCCESS;
}
/**
* This function will notify all the devices and their
* attached drivers about the VM now being resumed.
*
* @param pVM Pointer to the VM.
*/
{
LogFlow(("PDMR3Resume:\n"));
/*
* Iterate thru the device instances and USB device instances,
* processing the drivers associated with those.
*/
int rc = 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)
if (RT_SUCCESS(rc))
}
#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)
if (RT_SUCCESS(rc))
}
#endif
/*
* Resume all threads.
*/
if (RT_SUCCESS(rc))
/*
* Resume the block cache.
*/
if (RT_SUCCESS(rc))
/*
* On failure, clean up via PDMR3Suspend.
*/
if (RT_FAILURE(rc))
return /*rc*/;
}
/**
* Worker for PDMR3PowerOff that deals with one driver.
*
* @param pDrvIns The driver instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
* @param pszDevName The parent device name.
* @param iDevInstance The parent device instance number.
* @param iLun The parent LUN number.
*/
{
{
{
{
LogFlow(("PDMR3PowerOff: Notifying - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
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",
}
if (cNsElapsed >= PDMPOWEROFF_WARN_AT_NS)
LogRel(("PDMR3PowerOff: Driver '%s'/%d on LUN#%d of device '%s'/%d took %'llu ns to power off\n",
{
return false;
}
}
}
return true;
}
/**
* Worker for PDMR3PowerOff that deals with one USB device instance.
*
* @param pUsbIns The USB device instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
*/
{
{
{
{
LogFlow(("PDMR3PowerOff: Notifying - USB device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
LogFlow(("PDMR3PowerOff: Async notification started - USB device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
}
{
LogFlow(("PDMR3PowerOff: Async notification completed - USB device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
}
{
}
if (cNsElapsed >= PDMPOWEROFF_WARN_AT_NS)
LogRel(("PDMR3PowerOff: USB device '%s'/%d took %'llu ns to power off\n",
}
}
}
/**
* Worker for PDMR3PowerOff that deals with one device instance.
*
* @param pDevIns The device instance.
* @param pAsync The structure for recording asynchronous
* notification tasks.
*/
{
{
{
{
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));
}
{
}
if (cNsElapsed >= PDMPOWEROFF_WARN_AT_NS)
LogFlow(("PDMR3PowerOff: Device '%s'/%d took %'llu ns to power off\n",
}
}
}
/**
* This function will notify all the devices and their
* attached drivers about the VM being powered off.
*
* @param pVM Pointer to the VM.
*/
{
LogFlow(("PDMR3PowerOff:\n"));
/*
* The outer loop repeats until there are no more async requests.
*/
for (;;)
{
/*
* Iterate thru the device instances and USB device instances,
* processing the drivers associated with those.
*
* The attached drivers are normally processed first. Some devices
* (like DevAHCI) though needs to be notified before the drivers so
* that it doesn't kick off any new requests after the drivers stopped
* taking any. (DrvVD changes to read-only in this particular case.)
*/
{
break;
}
#ifdef VBOX_WITH_USB
{
break;
}
#endif
break;
}
/*
* Suspend all threads.
*/
}
/**
* Queries the base interface 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 pUVM The user mode 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(PUVM pUVM, 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 pUVM The user mode 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(PUVM pUVM, 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 pUVM The user mode 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(PUVM pUVM, 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 a named driver on a LUN.
*
* If the driver appears more than once in the driver chain, the first instance
* is returned.
*
* @returns VBox status code.
* @param pUVM The user mode VM handle.
* @param pszDevice Device name.
* @param iInstance Device instance.
* @param iLun The Logical Unit to obtain the interface of.
* @param pszDriver The driver name.
* @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) PDMR3QueryDriverOnLun(PUVM pUVM, const char *pszDevice, unsigned iInstance, unsigned iLun, const char *pszDriver, PPPDMIBASE ppBase)
{
LogFlow(("PDMR3QueryDriverOnLun: pszDevice=%p:{%s} iInstance=%u iLun=%u pszDriver=%p:{%s} ppBase=%p\n",
/*
* Find the LUN.
*/
if (RT_SUCCESS(rc))
{
{
{
return VINF_SUCCESS;
}
}
else
}
return rc;
}
/**
* Executes pending DMA transfers.
* Forced Action handler.
*
* @param pVM Pointer to the VM.
*/
{
/* 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 Pointer to the VM.
*/
{
}
/**
* Registers the VMM device heap
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param GCPhys The physical address.
* @param pvHeap Ring-3 pointer.
* @param cbSize Size of the heap.
*/
VMMR3_INT_DECL(int) PDMR3VmmDevHeapRegister(PVM pVM, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
{
return VINF_SUCCESS;
}
/**
* Unregisters the VMM device heap
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param GCPhys The physical address.
*/
{
return VINF_SUCCESS;
}
/**
* Allocates memory from the VMM device heap
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @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 Pointer to the VM.
* @param pv Ring-3 pointer.
*/
{
/** @todo not a real heap as there's currently only one user. */
return VINF_SUCCESS;
}
/**
* Worker for DBGFR3TraceConfig that checks if the given tracing group name
* matches a device or driver name and applies the tracing config change.
*
* @returns VINF_SUCCESS or VERR_NOT_FOUND.
* @param pVM Pointer to the VM.
* @param pszName The tracing config group name. This is NULL if
* the operation applies to every device and
* driver.
* @param cchName The length to match.
* @param fEnable Whether to enable or disable the corresponding
* trace points.
* @param fApply Whether to actually apply the changes or just do
* existence checks.
*/
VMMR3_INT_DECL(int) PDMR3TracingConfig(PVM pVM, const char *pszName, size_t cchName, bool fEnable, bool fApply)
{
/** @todo This code is potentially racing driver attaching and detaching. */
/*
* Applies to all.
*/
{
{
}
#ifdef VBOX_WITH_USB
{
}
#endif
return VINF_SUCCESS;
}
/*
* Specific devices, USB devices or drivers.
* Decode prefix to figure which of these it applies to.
*/
if (cchName <= 3)
return VERR_NOT_FOUND;
{
{
if ( ( cchDevName == cchName
{
cMatches++;
if (fApply)
}
}
}
{
{
if ( ( cchUsbName == cchName
{
cMatches++;
if (fApply)
}
}
}
{
{
if ( ( cchDrvName == cchName
{
cMatches++;
if (fApply)
}
}
#ifdef VBOX_WITH_USB
{
if ( ( cchDrvName == cchName
{
cMatches++;
if (fApply)
}
}
#endif
}
else
return VERR_NOT_FOUND;
}
/**
* Worker for DBGFR3TraceQueryConfig that checks whether all drivers, devices,
* and USB device have the same tracing settings.
*
* @returns true / false.
* @param pVM Pointer to the VM.
* @param fEnabled The tracing setting to check for.
*/
{
{
return false;
return false;
}
#ifdef VBOX_WITH_USB
{
return false;
return false;
}
#endif
return true;
}
/**
* Worker for PDMR3TracingQueryConfig that adds a prefixed name to the output
* string.
*
* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW
* @param ppszDst The pointer to the output buffer pointer.
* @param pcbDst The pointer to the output buffer size.
* @param fSpace Whether to add a space before the name.
* @param pszPrefix The name prefix.
* @param pszName The name.
*/
static int pdmR3TracingAdd(char **ppszDst, size_t *pcbDst, bool fSpace, const char *pszPrefix, const char *pszName)
{
return VERR_BUFFER_OVERFLOW;
if (fSpace)
{
**ppszDst = ' ';
}
else
{
}
return VINF_SUCCESS;
}
/**
* Worker for DBGFR3TraceQueryConfig use when not everything is either enabled
* or disabled.
*
* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW
* @param pVM Pointer to the VM.
* @param pszConfig Where to store the config spec.
* @param cbConfig The size of the output buffer.
*/
{
int rc;
{
{
rc = pdmR3TracingAdd(&pszDst, &cbDst, pszDst != pszConfig, "dev", pDevIns->Internal.s.pDevR3->pReg->szName);
if (RT_FAILURE(rc))
return rc;
}
{
rc = pdmR3TracingAdd(&pszDst, &cbDst, pszDst != pszConfig, "drv", pDrvIns->Internal.s.pDrv->pReg->szName);
if (RT_FAILURE(rc))
return rc;
}
}
#ifdef VBOX_WITH_USB
{
{
rc = pdmR3TracingAdd(&pszDst, &cbDst, pszDst != pszConfig, "usb", pUsbIns->Internal.s.pUsbDev->pReg->szName);
if (RT_FAILURE(rc))
return rc;
}
{
rc = pdmR3TracingAdd(&pszDst, &cbDst, pszDst != pszConfig, "drv", pDrvIns->Internal.s.pDrv->pReg->szName);
if (RT_FAILURE(rc))
return rc;
}
}
#endif
return VINF_SUCCESS;
}
/**
* Checks that a PDMDRVREG::szName, PDMDEVREG::szName or PDMUSBREG::szName
* field contains only a limited set of ASCII characters.
*
* @returns true / false.
* @param pszName The name to validate.
*/
bool pdmR3IsValidName(const char *pszName)
{
char ch;
&& ( RT_C_IS_ALNUM(ch)
|| ch == '-'
|| ch == '_') )
pszName++;
return ch == '\0';
}
/**
* Info handler for 'pdmtracingids'.
*
* @param pVM Pointer to the VM.
* @param pHlp The output helpers.
* @param pszArgs The optional user arguments.
*
* @remarks Can be called on most threads.
*/
{
/*
* Parse the argument (optional).
*/
if ( pszArgs
&& *pszArgs
{
return;
}
/*
* Produce the requested output.
*/
/** @todo lock PDM lists! */
/* devices */
if (fDevices)
{
}
/* USB devices */
if (fUsbDevs)
{
}
/* Drivers */
if (fDrivers)
{
{
{
}
}
{
{
}
}
}
}