Changeset 35357 in vbox for trunk/src/VBox

Timestamp:

Dec 27, 2010 10:38:34 PM (14 years ago)

Author:

vboxsync

Message:

VMM, Main: PCI passthrough work

Location:

trunk/src/VBox

Files:

• Devices/Bus/DevPciIch9.cpp (modified) (10 diffs)
• Devices/Bus/DevPciRaw.cpp (modified) (12 diffs)
• Devices/Bus/PCIInternal.h (modified) (1 diff)
• Devices/Makefile.kmk (modified) (1 diff)
• Main/ConsoleImpl.cpp (modified) (2 diffs)
• Main/ConsoleImpl2.cpp (modified) (4 diffs)
• Main/GuestCtrlImpl.cpp (modified) (1 diff)
• Main/MachineImpl.cpp (modified) (4 diffs)
• Main/Makefile.kmk (modified) (1 diff)
• Main/PciDeviceAttachmentImpl.cpp (modified) (2 diffs)
• Main/VBoxDriversRegister.cpp (modified) (2 diffs)
• Main/idl/VirtualBox.xidl (modified) (4 diffs)
• Main/include/MachineImpl.h (modified) (3 diffs)
• VMM/VMMR0/PDMR0Device.cpp (modified) (2 diffs)
• VMM/VMMR3/PDMDevHlp.cpp (modified) (4 diffs)
• VMM/VMMR3/PDMDevMiscHlp.cpp (modified) (1 diff)
• VMM/include/PDMInternal.h (modified) (1 diff)

trunk/src/VBox/Devices/Bus/DevPciIch9.cpp

@@ -296 +296 @@
 {
     int rc = VINF_SUCCESS;
-
-    if (pAddr->iRegister > 0xff)
-    {
-        LogRel(("PCI: attempt to write extended register: %x (%d) <- val\n", pAddr->iRegister, cb, val));
-        goto out;
-    }
 
     if (pAddr->iBus != 0)
@@ -933 +927 @@
 static DECLCALLBACK(int) ich9pciGenericSaveExec(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSM)
 {
+    Assert(!PCIIsPassthrough(pPciDev));
     return SSMR3PutMem(pSSM, &pPciDev->config[0], sizeof(pPciDev->config));
 }
@@ -1185 +1180 @@
      */
     uint8_t const fBridge = fIsBridge ? 2 : 1;
+    Assert(!PCIIsPassthrough(pDev));
     uint8_t *pbDstConfig = &pDev->config[0];
+
     for (uint32_t i = 0; i < RT_ELEMENTS(s_aFields); i++)
         if (s_aFields[i].fBridge & fBridge)
@@ -1379 +1376 @@
 
         /* commit the loaded device config. */
+        Assert(!PCIIsPassthrough(pDev));
         pciR3CommonRestoreConfig(pDev, &DevTmp.config[0], false ); /** @todo fix bridge fun! */
 
@@ -1410 +1408 @@
 static DECLCALLBACK(int) ich9pciGenericLoadExec(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSM)
 {
+    Assert(!PCIIsPassthrough(pPciDev));
     return SSMR3GetMem(pSSM, &pPciDev->config[0], sizeof(pPciDev->config));
 }
@@ -1625 +1624 @@
 
             AssertMsg(pGlobals->uBus < 255, ("Too many bridges on the bus\n"));
+#if 0
+            /* We assign bridges starting from 16, to allow real PCI
+               device assignment into lower slots */
+            if (pGlobals->uBus == 0)
+                pGlobals->uBus = 16;
+            else
+                pGlobals->uBus++;
+#else
             pGlobals->uBus++;
+#endif
             ich9pciBiosInitBridge(pGlobals, uBus, uDevFn, cBridgeDepth, paBridgePositions);
             break;
@@ -1735 +1743 @@
     }
 
+    AssertMsgReturn(u32Address + len <= 256, ("Read after end of PCI config space\n"),
+                    0);
+
+
     if (   PCIIsMsiCapable(aDev)
         && (u32Address >= aDev->Int.s.u8MsiCapOffset)
@@ -1751 +1763 @@
     }
 
-    AssertMsgReturn(u32Address + len <= 256, ("Read after end of PCI config space\n"),
-                    0);
     switch (len)
     {
@@ -1808 +1818 @@
 {
     Assert(len <= 4);
+    Assert(!PCIIsPassthrough(aDev));
 
     if ((u32Address + len) > 256 && (u32Address + len) < 4096)
     {
-        AssertMsgReturnVoid(false, ("Write to extended registers falled back to generic code\n"));
+        LogRel(("Write to extended registers falled back to the generic code: %s register %d len=%d\n",
+                aDev->name, u32Address, len));
+        return;
     }
 
@@ -2130 +2143 @@
         if (pPciDev != NULL)
         {
+            if (PCIIsPassthrough(pPciDev))
+            {
+                printIndent(pHlp, iIndent);
+                /**
+                 * For passthrough devices MSI/MSI-X mostly reflects the way interrupts delivered to the guest,
+                 * as host driver handles real devices interrupts.
+                 */
+                pHlp->pfnPrintf(pHlp, "%02x:%02x:%02x %s: %s%s - PASSTHROUGH\n",
+                                pBus->iBus, (iDev >> 3) & 0xff, iDev & 0x7,
+                                pPciDev->name,
+                                PCIIsMsiCapable(pPciDev)  ? " MSI" : "",
+                                PCIIsMsixCapable(pPciDev) ? " MSI-X" : ""
+                                );
+                continue;
+            }
+
             printIndent(pHlp, iIndent);
             pHlp->pfnPrintf(pHlp, "%02x:%02x:%02x %s: %04x-%04x%s%s",

trunk/src/VBox/Devices/Bus/DevPciRaw.cpp

@@ -20 +20 @@
 *******************************************************************************/
 #define LOG_GROUP LOG_GROUP_DEV_PCI
+#include <VBox/log.h>
+#define PCI_INCLUDE_PRIVATE
+#include <VBox/pci.h>
 #include <VBox/vmm/pdmdev.h>
-#include <VBox/log.h>
 #include <VBox/vmm/stam.h>
+#include <VBox/vmm/pdmpci.h>
 #include <iprt/assert.h>
 #include <iprt/string.h>
+#include <iprt/uuid.h>
+
 
 #include "VBoxDD.h"
@@ -38 +43 @@
  *******************************************************************************/
 
-/* Temporary PDM stubs */
-typedef struct PDMPCIRAWREG
-{
-    /** Struct version+magic number (PDM_PCIRAWREG_VERSION). */
-    uint32_t            u32Version;
-
-} PDMPCIRAWREG;
-/** Pointer to a raw PCI registration structure. */
-typedef PDMPCIRAWREG *PPDMPCIRAWREG;
-
-/** Current PDMPCIRAWREG version number. */
-#define PDM_PCIRAWREG_VERSION                     PDM_VERSION_MAKE(0xffe3, 1, 0)
-
-struct PDMPCIRAWHLPRC
-{
-    uint32_t u32Version;
-};
-typedef RCPTRTYPE(PDMPCIRAWHLPRC *) PPDMPCIRAWHLPRC;
-typedef RCPTRTYPE(const PDMPCIRAWHLPRC *) PCPDMPCIRAWHLPRC;
-
-struct PDMPCIRAWHLPR0
-{
-    uint32_t u32Version;
-};
-typedef R0PTRTYPE(PDMPCIRAWHLPR0 *) PPDMPCIRAWHLPR0;
-typedef R0PTRTYPE(const PDMPCIRAWHLPR0 *) PCPDMPCIRAWHLPR0;
-
-struct PDMPCIRAWHLPR3
-{
-    uint32_t u32Version;
-    /**
-     * Gets the address of the RC PCI raw helpers.
-     *
-     * This should be called at both construction and relocation time
-     * to obtain the correct address of the RC helpers.
-     *
-     * @returns RC pointer to the PCI raw helpers.
-     * @param   pDevIns         Device instance of the raw PCI device.
-     */
-    DECLR3CALLBACKMEMBER(PCPDMPCIRAWHLPRC, pfnGetRCHelpers,(PPDMDEVINS pDevIns));
-
-    /**
-     * Gets the address of the R0 PCI raw helpers.
-     *
-     * This should be called at both construction and relocation time
-     * to obtain the correct address of the R0 helpers.
-     *
-     * @returns R0 pointer to the PCI raw helpers.
-     * @param   pDevIns         Device instance of the raw PCI device.
-     */
-    DECLR3CALLBACKMEMBER(PCPDMPCIRAWHLPR0, pfnGetR0Helpers,(PPDMDEVINS pDevIns));
-
-    /** Just a safety precaution. */
-    uint32_t                u32TheEnd;
-};
-/** Pointer to raw PCI R3 helpers. */
-typedef R3PTRTYPE(PDMPCIRAWHLPR3 *) PPDMPCIRAWHLPR3;
-/** Pointer to const raw PCI R3 helpers. */
-typedef R3PTRTYPE(const PDMPCIRAWHLPR3 *) PCPDMPCIRAWHLPR3;
-
-/**
- * @copydoc PDMDEVHLPR3::pfnPciRawRegister
- */
-DECLINLINE(int) PDMDevHlpPciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
-{
-    //return pDevIns->pHlpR3->pfnPciRawRegister(pDevIns, pPciRawReg, ppPciRawHlpR3);
-    return VINF_SUCCESS;
-}
-
-/* End of PDM stubs */
-
 typedef struct PciRawState
 {
@@ -129 +63 @@
     PCIDEVICE            aPciDevice;
 
+    /* Device name, as provided by Main */
+    char                 szDeviceName[64];
     /* Address of device on the host */
-    PciBusAddress        aHostDeviceAddress;
+    int32_t              i32HostDeviceAddress;
     /* Address of device in the guest */
-    PciBusAddress        aGuestDeviceAddress;
-
-    /* Global device lock */
+    int32_t              i32GuestDeviceAddress;
+
+     /* Global device lock */
     PDMCRITSECT          csLock;
+
+    /**
+     * Device port - LUN#0.
+     *
+     * @implements  PDMIBASE
+     * @implements  PDMIPCIRAW
+     */
+    struct
+    {
+        /** The base interface for the PCI device port. */
+        PDMIBASE                            IBase;
+        /** The device port base interface. */
+        PDMIPCIRAW                          IDevice;
+
+        /** The base interface of the attached raw PCI driver. */
+        R3PTRTYPE(PPDMIBASE)                pDrvBase;
+        /** The device interface of the attached raw PCI driver. */
+        R3PTRTYPE(PPDMIPCIRAWCONNECTOR)     pDrv;
+    } Lun0;
 } PciRawState;
 
+/** Pointer to the raw PCI instance data. */
+typedef PciRawState *PPciRawState;
 
 #ifndef VBOX_DEVICE_STRUCT_TESTCASE
@@ -150 +107 @@
 RT_C_DECLS_END
 
-/*
- * Temporary control to disable locking if problems found
- */
 DECLINLINE(int) pcirawLock(PciRawState* pThis, int rcBusy)
 {
@@ -162 +116 @@
     PDMCritSectLeave(&pThis->csLock);
 }
-
 
 PDMBOTHCBDECL(int)  pcirawMMIORead(PPDMDEVINS pDevIns,
@@ -212 +165 @@
 
     rc = pcirawLock(pThis, VINF_IOM_HC_MMIO_WRITE);
-    if (RT_UNLIKELY(rc != VINF_SUCCESS))
         return rc;
 
@@ -331 +283 @@
 }
 
+static DECLCALLBACK(int) pcirawAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
+{
+    PciRawState *pThis = PDMINS_2_DATA(pDevIns, PciRawState *);
+
+    LogFlow(("pcirawAttach: LUN%d\n", iLUN));
+    /* Not yet used */
+    return 0;
+}
+
+static DECLCALLBACK(void) pcirawDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
+{
+    PciRawState *pThis = PDMINS_2_DATA(pDevIns, PciRawState *);
+
+    LogFlow(("pcirawDetach: LUN%d\n", iLUN));
+    /* Not yet used */
+}
+
+
 /**
  * Initialization routine.
@@ -337 +307 @@
  * @param   pDevIns     The device instance data.
  */
-static int pcirawInit(PPDMDEVINS pDevIns, PciBusAddress hostAddress)
+static int pcirawInit(PPDMDEVINS pDevIns, PciBusAddress hostAddress, PciBusAddress guestAddress)
 {
     unsigned   i;
@@ -349 +319 @@
     pThis->pDevInsRC  = PDMDEVINS_2_RCPTR(pDevIns);
 
-    pThis->aHostDeviceAddress.init(hostAddress);
+    pThis->i32HostDeviceAddress = hostAddress.asLong();
+    pThis->i32GuestDeviceAddress = guestAddress.asLong();
 
     pcirawReset(pDevIns);
 
     return VINF_SUCCESS;
+}
+
+
+static uint32_t pcirawConfigRead(PPCIDEVICE pPciDev, uint32_t Address, unsigned cb)
+{
+    PPDMDEVINS pDevIns = pPciDev->pDevIns;
+    PciRawState*  pThis = PDMINS_2_DATA(pDevIns, PciRawState *);
+
+    Log2(("rawpci: PCI config read: 0x%x (%d)\n", Address, cb));
+
+    return 0;
+}
+
+static void pcirawConfigWrite(PPCIDEVICE pPciDev, uint32_t Address, uint32_t u32Value, unsigned cb)
+{
+    PPDMDEVINS  pDevIns = pPciDev->pDevIns;
+    PciRawState  *pThis = PDMINS_2_DATA(pDevIns, PciRawState *);
+
+    Log2(("rawpci: PCI config write: 0x%x -> 0x%x (%d)\n", u32Value, Address, cb));
+}
+
+
+/**
+ * @interface_method_impl{PDMIBASE,pfnQueryInterface}
+ */
+static DECLCALLBACK(void *) pcirawQueryInterface(PPDMIBASE pInterface, const char *pszIID)
+{
+    PciRawState* pThis = RT_FROM_CPP_MEMBER(pInterface, PciRawState, Lun0.IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE,   &pThis->Lun0.IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIPCIRAW, &pThis->Lun0.IDevice);
+    return NULL;
+}
+
+static DECLCALLBACK(int) pcirawFoo(PPDMIPCIRAW pInterface)
+{
+    return 0;
 }
 
@@ -373 +380 @@
                               "GCEnabled\0"
                               "R0Enabled\0"
+                              "DeviceName\0"
+                              "GuestPCIBusNo\0"
+                              "GuestPCIDeviceNo\0"
+                              "GuestPCIFunctionNo\0"
                               "HostPCIBusNo\0"
                               "HostPCIDeviceNo\0"
@@ -390 +401 @@
                                 N_("Configuration error: failed to read R0Enabled as boolean"));
 
-    /* Obtain host device address */
-    uint32_t u32Bus, u32Device, u32Fn;
-    rc = CFGMR3QueryU32(pCfg, "HostPCIBusNo", &u32Bus);
+    rc = CFGMR3QueryString(pCfg, "DeviceName", pThis->szDeviceName, sizeof(pThis->szDeviceName));
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
-                                N_("Configuration error: Querying \"HostPCIBusNo\" as a int failed"));
-    rc = CFGMR3QueryU32(pCfg, "HostPCIDeviceNo", &u32Device);
-    if (RT_FAILURE(rc))
-        return PDMDEV_SET_ERROR(pDevIns, rc,
-                                N_("Configuration error: Querying \"HostPCIDeviceNo\" as a int failed"));
-    rc = CFGMR3QueryU32(pCfg, "HostPCIFunctionNo", &u32Fn);
-    if (RT_FAILURE(rc))
-        return PDMDEV_SET_ERROR(pDevIns, rc,
-                                N_("Configuration error: Querying \"HostPCIFunctionNo\" as a int failed"));
-
-
-    /* Initialize the device state */
-    rc = pcirawInit(pDevIns, PciBusAddress(u32Bus, u32Device, u32Fn));
-    if (RT_FAILURE(rc))
-        return rc;
-
-    pThis->pDevInsR3 = pDevIns;
-    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-
-    /*
-     * Register the raw device and get helpers.
-     */
-    PciRawReg.u32Version  = PDM_PCIRAWREG_VERSION;
-    rc = PDMDevHlpPciRawRegister(pDevIns, &PciRawReg, &pThis->pPciRawHlpR3);
-    if (RT_FAILURE(rc))
-    {
-        AssertMsgRC(rc, ("Cannot PciRawRegister: %Rrc\n", rc));
-        return rc;
-    }
-
-    /*
-     * Initialize critical section.
-     */
-    rc = PDMDevHlpCritSectInit(pDevIns, &pThis->csLock, RT_SRC_POS, "PCIRAW");
-    if (RT_FAILURE(rc))
-        return PDMDEV_SET_ERROR(pDevIns, rc, N_("Raw PCI device cannot initialize critical section"));
-
-#if 0
-    /*
-     * Register IO/MMIO ranges for guest, basing on real device ranges.
-     */
-    for (int iRegion = 0; iRegion < VBOX_PCI_NUM_REGIONS; iRegion++)
-    {
-
-    }
+                                N_("Configuration error: failed to read DeviceName as string"));
+
+    PciBusAddress hostAddress, guestAddress;
+
+    /* Obtain device address info */
+    uint32_t u32Bus, u32Device, u32Fn;
+
+    do {
+        rc = CFGMR3QueryU32(pCfg, "HostPCIBusNo", &u32Bus);
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc,
+                             N_("Configuration error: Querying \"HostPCIBusNo\" as a int failed"));
+            break;
+        }
+        rc = CFGMR3QueryU32(pCfg, "HostPCIDeviceNo", &u32Device);
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc,
+                             N_("Configuration error: Querying \"HostPCIDeviceNo\" as a int failed"));
+            break;
+        }
+        rc = CFGMR3QueryU32(pCfg, "HostPCIFunctionNo", &u32Fn);
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc,
+                             N_("Configuration error: Querying \"HostPCIFunctionNo\" as a int failed"));
+            break;
+        }
+        hostAddress = PciBusAddress(u32Bus, u32Device, u32Fn);
+
+        rc = CFGMR3QueryU32(pCfg, "GuestPCIBusNo", &u32Bus);
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc,
+                             N_("Configuration error: Querying \"GuestPCIBusNo\" as a int failed"));
+            break;
+        }
+        rc = CFGMR3QueryU32(pCfg, "GuestPCIDeviceNo", &u32Device);
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc,
+                             N_("Configuration error: Querying \"GuestPCIDeviceNo\" as a int failed"));
+            break;
+        }
+        rc = CFGMR3QueryU32(pCfg, "GuestPCIFunctionNo", &u32Fn);
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc,
+                             N_("Configuration error: Querying \"GuestPCIFunctionNo\" as a int failed"));
+            break;
+        }
+        guestAddress = PciBusAddress(u32Bus, u32Device, u32Fn);
+
+        /* Initialize the device state */
+        rc = pcirawInit(pDevIns, hostAddress, guestAddress);
+        if (RT_FAILURE(rc))
+            break;
+
+        pThis->pDevInsR3 = pDevIns;
+        pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+        pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+
+        /*
+         * Register the raw device and get helpers.
+         */
+        PciRawReg.u32Version  = PDM_PCIRAWREG_VERSION;
+        rc = PDMDevHlpPciRawRegister(pDevIns, &PciRawReg, &pThis->pPciRawHlpR3);
+        if (RT_FAILURE(rc))
+        {
+            AssertMsgRC(rc, ("Cannot PciRawRegister: %Rrc\n", rc));
+            break;
+        }
+
+        /*
+         * Initialize critical section.
+         */
+        rc = PDMDevHlpCritSectInit(pDevIns, &pThis->csLock, RT_SRC_POS, "PCIRAW");
+        if (RT_FAILURE(rc))
+        {
+            PDMDEV_SET_ERROR(pDevIns, rc, N_("Raw PCI device cannot initialize critical section"));
+            break;
+        }
+
+        /* Mark device as passthrough */
+        PCISetPassthrough(&pThis->aPciDevice);
+
+        /* IBase */
+        pThis->Lun0.IBase.pfnQueryInterface = pcirawQueryInterface;
+        pThis->Lun0.IDevice.pfnFoo          = pcirawFoo;
+
+        /*
+         * Attach to the Main driver.
+         */
+        rc = pDevIns->pHlpR3->pfnDriverAttach(pDevIns, 0 /*iLun*/, &pThis->Lun0.IBase, &pThis->Lun0.pDrvBase, "Device Port");
+        if (RT_FAILURE(rc))
+        {
+            rc = PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("Raw PCI failed to attach Main driver"));
+            break;
+        }
+
+        pThis->Lun0.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Lun0.pDrvBase, PDMIPCIRAWCONNECTOR);
+        if (!pThis->Lun0.pDrv)
+        {
+            rc = PDMDevHlpVMSetError(pDevIns, VERR_PDM_MISSING_INTERFACE, RT_SRC_POS, N_("Raw PCI failed to query interface"));
+            break;
+        }
+
+        /* Just a safety measure, this data shall never be reached */
+        PCIDevSetVendorId(&pThis->aPciDevice, 0xdead);
+        PCIDevSetDeviceId(&pThis->aPciDevice, 0xbeef);
+
+        rc = PDMDevHlpPCIRegister(pDevIns, &pThis->aPciDevice);
+        if (RT_FAILURE(rc))
+            break;
+
+        PDMDevHlpPCISetConfigCallbacks(pDevIns, &pThis->aPciDevice,
+                                       pcirawConfigRead,  NULL /* we don't care about old ones */,
+                                       pcirawConfigWrite, NULL /* we don't care about old ones */);
+
+#if 1
+        /*
+         * Register IO/MMIO ranges for the guest, basing on real device ranges.
+         */
+        for (int iRegion = 0; iRegion < VBOX_PCI_NUM_REGIONS; iRegion++)
+        {
+            RTHCPHYS RegStart;
+            uint64_t iRegSize;
+            bool     fMmio;
+
+            if (pThis->Lun0.pDrv->pfnGetRegionInfo(pThis->Lun0.pDrv, hostAddress.asLong(), iRegion,
+                                                   &RegStart, &iRegSize, &fMmio))
+            {
+                /* If region is present, register callbacks in guest.
+                   @todo: replace it with direct region access with remap */
+                // @todo: check if host's PA make sense for the guest
+                if (fMmio)
+                {
+                    rc = PDMDevHlpMMIORegister(pDevIns, RegStart, iRegSize, NULL,
+                                               pcirawMMIOWrite, pcirawMMIORead, NULL,
+                                               "Raw PCI MMIO regions");
+                    if (RT_FAILURE(rc))
+                    {
+                        AssertMsgRC(rc, ("Cannot register MMIO: %Rrc\n", rc));
+                        break;
+                    }
+                }
+                else
+                {
+                    rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)RegStart, iRegSize, NULL,
+                                                 pcirawIOPortWrite, pcirawIOPortRead, NULL, NULL,
+                                                 "Raw PCI IO regions");
+                    if (RT_FAILURE(rc))
+                    {
+                        AssertMsgRC(rc, ("Cannot register IO: %Rrc\n", rc));
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (RT_FAILURE(rc))
+            break;
 #endif
 
-    if (fRCEnabled)
-    {
-        pThis->pPciRawHlpRC = pThis->pPciRawHlpR3->pfnGetRCHelpers(pDevIns);
-        if (!pThis->pPciRawHlpRC)
-        {
-            AssertReleaseMsgFailed(("cannot get RC helper\n"));
-            return VERR_INTERNAL_ERROR;
-        }
-    }
-    if (fR0Enabled)
-    {
-        pThis->pPciRawHlpR0 = pThis->pPciRawHlpR3->pfnGetR0Helpers(pDevIns);
-        if (!pThis->pPciRawHlpR0)
-        {
-            AssertReleaseMsgFailed(("cannot get R0 helper\n"));
-            return VERR_INTERNAL_ERROR;
-        }
-    }
-
-    /* Register SSM callbacks */
-    rc = PDMDevHlpSSMRegister3(pDevIns, PCIRAW_SAVED_STATE_VERSION, sizeof(*pThis), pcirawLiveExec, pcirawSaveExec, pcirawLoadExec);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    return VINF_SUCCESS;
+        if (fRCEnabled)
+        {
+            pThis->pPciRawHlpRC = pThis->pPciRawHlpR3->pfnGetRCHelpers(pDevIns);
+            if (!pThis->pPciRawHlpRC)
+            {
+                AssertReleaseMsgFailed(("cannot get RC helper\n"));
+                rc = VERR_INTERNAL_ERROR;
+                break;
+                }
+        }
+        if (fR0Enabled)
+        {
+            pThis->pPciRawHlpR0 = pThis->pPciRawHlpR3->pfnGetR0Helpers(pDevIns);
+            if (!pThis->pPciRawHlpR0)
+                {
+                    AssertReleaseMsgFailed(("cannot get R0 helper\n"));
+                    rc = VERR_INTERNAL_ERROR;
+                    break;
+                }
+        }
+
+        /* Register SSM callbacks */
+        rc = PDMDevHlpSSMRegister3(pDevIns, PCIRAW_SAVED_STATE_VERSION, sizeof(*pThis), pcirawLiveExec, pcirawSaveExec, pcirawLoadExec);
+        if (RT_FAILURE(rc))
+            break;
+    } while (0);
+    /* Notify Main about result of PCI device  attach attempt */
+    if (pThis->Lun0.pDrv != NULL)
+        pThis->Lun0.pDrv->pfnPciDeviceConstructComplete(pThis->Lun0.pDrv, hostAddress.asLong(), guestAddress.asLong(),
+                                                        rc, pThis->szDeviceName);
+
+    return rc;
 }
 
@@ -511 +644 @@
     NULL,
     /* pfnAttach */
-    NULL,
+    NULL , //pcirawAttach,
     /* pfnDetach */
-    NULL,
+    NULL, //pcirawDetach,
     /* pfnQueryInterface. */
     NULL,

trunk/src/VBox/Devices/Bus/PCIInternal.h

@@ -87 +87 @@
     /** Flag whether the device is capable of MSI-X.
      * This one is set by MsixInit().  */
-    PCIDEV_FLAG_MSIX_CAPABLE       = 1<<4
+    PCIDEV_FLAG_MSIX_CAPABLE       = 1<<4,
+    /** Flag if device represents real physical device in passthrough mode. */
+    PCIDEV_FLAG_PASSTHROUGH        = 1<<5
 };
 

trunk/src/VBox/Devices/Makefile.kmk

@@ -512 +512 @@
  Bus/DevPCI.cpp_INCS      = Bus
  Bus/DevPciIch9.cpp_INCS  = Bus
- Bus/MsiCommon.cpp_INCS  = Bus
+ Bus/MsiCommon.cpp_INCS   = Bus
  Bus/MsixCommon.cpp_INCS  = Bus
+ Bus/DevPciRaw.cpp_INCS   = Bus
+
 
  # For finding and generating vbetables.h (see Graphics/BIOS/Makefile.kmk).

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -307 +307 @@
                     break;
                 mConsole->onNATRedirectRuleChange(ulSlot, fRemove, proto, hostIp.raw(), hostPort, guestIp.raw(), guestPort);
+                break;
             }
-            break;
+            case VBoxEventType_OnHostPciDevicePlug:
+            {
+                // handle if needed
+                break;
+            }
             default:
                 AssertFailed();
@@ -484 +489 @@
         com::SafeArray<VBoxEventType_T> eventTypes;
         eventTypes.push_back(VBoxEventType_OnNATRedirect);
+        eventTypes.push_back(VBoxEventType_OnHostPciDevicePlug);
         rc = pES->RegisterListener(mVmListner, ComSafeArrayAsInParam(eventTypes), true);
         AssertComRC(rc);

trunk/src/VBox/Main/ConsoleImpl2.cpp

@@ -34 +34 @@
 #include "VMMDev.h"
 #include "Global.h"
+#include "PciRawDevImpl.h"
 
 // generated header
@@ -455 +456 @@
 
 
+static HRESULT attachRawPciDevices(BusAssignmentManager* BusMgr,
+                                   PCFGMNODE             pDevices,
+                                   Console*              pConsole)
+{
+    HRESULT hrc = S_OK;
+    PCFGMNODE pDev, pInst, pCfg, pLunL0;
+
+    SafeIfaceArray<IPciDeviceAttachment> assignments;
+    ComPtr<IMachine> aMachine =  pConsole->machine();
+
+    hrc = aMachine->COMGETTER(PciDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
+    if (hrc != S_OK)
+        return hrc;
+
+    for (size_t iDev = 0; iDev < assignments.size(); iDev++)
+    {
+        PciBusAddress HostPciAddress, GuestPciAddress;
+        ComPtr<IPciDeviceAttachment> assignment = assignments[iDev];
+        LONG host, guest;
+        Bstr aDevName;
+
+        assignment->COMGETTER(HostAddress)(&host);
+        assignment->COMGETTER(GuestAddress)(&guest);
+        assignment->COMGETTER(Name)(aDevName.asOutParam());
+
+        InsertConfigNode(pDevices,     "pciraw",  &pDev);
+        InsertConfigNode(pDev,          Utf8StrFmt("%d", iDev).c_str(), &pInst);
+        InsertConfigInteger(pInst,     "Trusted", 1);
+
+        HostPciAddress.fromLong(host);
+        Assert(HostPciAddress.valid());
+        InsertConfigNode(pInst,        "Config",  &pCfg);
+        InsertConfigString(pCfg,       "DeviceName",  aDevName);
+
+        InsertConfigInteger(pCfg,      "HostPCIBusNo",      HostPciAddress.iBus);
+        InsertConfigInteger(pCfg,      "HostPCIDeviceNo",   HostPciAddress.iDevice);
+        InsertConfigInteger(pCfg,      "HostPCIFunctionNo", HostPciAddress.iFn);
+
+        GuestPciAddress.fromLong(guest);
+        Assert(GuestPciAddress.valid());
+        hrc = BusMgr->assignPciDevice("pciraw", pInst, GuestPciAddress, true);
+        if (hrc != S_OK)
+            return hrc;
+        InsertConfigInteger(pCfg,      "GuestPCIBusNo",      GuestPciAddress.iBus);
+        InsertConfigInteger(pCfg,      "GuestPCIDeviceNo",   GuestPciAddress.iDevice);
+        InsertConfigInteger(pCfg,      "GuestPCIFunctionNo", GuestPciAddress.iFn);
+
+        /* the Main driver */
+        PciRawDev* pMainDev = new PciRawDev(pConsole);
+        InsertConfigNode(pInst,        "LUN#0",   &pLunL0);
+        InsertConfigString(pLunL0,     "Driver",  "PciRawMain");
+        InsertConfigNode(pLunL0,       "Config" , &pCfg);
+        InsertConfigInteger(pCfg,      "Object", (uintptr_t)pMainDev);
+    }
+
+    return hrc;
+}
+
 /**
  *  Construct the VM configuration tree (CFGM).
@@ -911 +970 @@
             InsertConfigInteger(pCfg,  "McfgLength", u32McfgLength);
 
-
             /* And register 2 bridges */
             InsertConfigNode(pDevices, "ich9pcibridge", &pDev);
@@ -921 +979 @@
             InsertConfigInteger(pInst, "Trusted",              1); /* boolean */
             hrc = BusMgr->assignPciDevice("ich9pcibridge", pInst);                               H();
+
+            /* Add PCI passthrough devices */
+            hrc = attachRawPciDevices(BusMgr, pDevices, pConsole);                               H();
         }
 
         /*
-         * Enable 3 following devices: HPET, SMC, LPC on MacOS X guests
+         * Enable 3 following devices: HPET, SMC, LPC on MacOS X guests or on ICH9
          */
         /*

trunk/src/VBox/Main/GuestCtrlImpl.cpp

@@ -206 +206 @@
         {
             rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
-                                                 Guest::tr("Source file \"%s\" does not exist"),
+                                                 Guest::tr("Source file \"%s\" does not exist, or is not a file"),
                                                  aTask->strSource.c_str());
         }

trunk/src/VBox/Main/MachineImpl.cpp

@@ -50 +50 @@
 #include "DisplayUtils.h"
 #include "BandwidthControlImpl.h"
+#include "VBoxEvents.h"
 
 #ifdef VBOX_WITH_USB
@@ -5810 +5811 @@
 }
 
-
-STDMETHODIMP Machine::AttachHostPciDevice(LONG hostAddress, LONG desiredGuestAddress, IEventContext * /*eventContext*/, BOOL /*tryToUnbind*/)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<PciDeviceAttachment> pda;
-    char name[32];
-
-    pda.createObject();
-    RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (hostAddress>>8) & 0xff, (hostAddress & 0xf8) >> 3, hostAddress & 7);
-    Bstr bname(name);
-    pda.createObject();
-    pda->init(this, bname,  hostAddress, desiredGuestAddress, TRUE);
-
-    mPciDeviceAssignments.push_back(pda);
-    return S_OK;
-}
-
-STDMETHODIMP Machine::DetachHostPciDevice(LONG /*hostAddress*/)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    return E_NOTIMPL;
+/**
+ * Currently this method doesn't attach device to the running VM,
+ * just makes sure it's plugged on next VM start.
+ */
+STDMETHODIMP Machine::AttachHostPciDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL /*tryToUnbind*/)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    // lock scope
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        //HRESULT rc = checkStateDependency(MutableStateDep);
+        //if (FAILED(rc)) return rc;
+
+        ComObjPtr<PciDeviceAttachment> pda;
+        char name[32];
+
+        RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (hostAddress>>8) & 0xff, (hostAddress & 0xf8) >> 3, hostAddress & 7);
+        Bstr bname(name);
+        pda.createObject();
+        pda->init(this, bname,  hostAddress, desiredGuestAddress, TRUE);
+        setModified(IsModified_MachineData);
+        mHWData.backup();
+        mHWData->mPciDeviceAssignments.push_back(pda);
+    }
+
+    // do we need it?
+    //saveSettings(NULL);
+    mHWData.commit();
+
+    return S_OK;
+}
+
+/**
+ * Currently this method doesn't detach device from the running VM,
+ * just makes sure it's not plugged on next VM start.
+ */
+STDMETHODIMP Machine::DetachHostPciDevice(LONG hostAddress)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    ComObjPtr<PciDeviceAttachment> pAttach;
+    bool fRemoved = false;
+    HRESULT rc;
+
+    // lock scope
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        rc = checkStateDependency(MutableStateDep);
+        if (FAILED(rc)) return rc;
+
+        for (HWData::PciDeviceAssignmentList::iterator it =  mHWData->mPciDeviceAssignments.begin();
+             it !=  mHWData->mPciDeviceAssignments.end();
+             ++it)
+        {
+            LONG iHostAddress = -1;
+            pAttach = *it;            
+            pAttach->COMGETTER(HostAddress)(&iHostAddress);
+            if (iHostAddress  != -1  && iHostAddress == hostAddress)
+            {
+                setModified(IsModified_MachineData);
+                mHWData.backup();
+                mHWData->mPciDeviceAssignments.remove(pAttach);
+                fRemoved = true;
+                break;
+            }
+        }
+        // Indeed under lock?
+        mHWData.commit();
+
+        // do we need it?
+        // saveSettings(NULL);
+    }
+
+
+    /* Fire event outside of the lock */
+    if (fRemoved)
+    {
+        Assert(!pAttach.isNull());
+        ComPtr<IEventSource> es;
+        rc = mParent->COMGETTER(EventSource)(es.asOutParam());
+        Assert(SUCCEEDED(rc));
+        Bstr mid;
+        rc = this->COMGETTER(Id)(mid.asOutParam());
+        Assert(SUCCEEDED(rc));
+        fireHostPciDevicePlugEvent(es, mid.raw(), false /* unplugged */, true /* success */, pAttach, NULL);
+    }
+
+    return S_OK;
 }
 
@@ -5848 +5915 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    SafeIfaceArray<IPciDeviceAttachment> assignments(mPciDeviceAssignments);
+    SafeIfaceArray<IPciDeviceAttachment> assignments(mHWData->mPciDeviceAssignments);
     assignments.detachTo(ComSafeArrayOutArg(aAssignments));
 
@@ -6462 +6529 @@
 
     HRESULT rc = S_OK;
-
     // Ensure the settings are saved. If we are going to be registered and
     // no config file exists yet, create it by calling saveSettings() too.

trunk/src/VBox/Main/Makefile.kmk

@@ -653 +653 @@
         BusAssignmentManager.cpp \
         PciDeviceAttachmentImpl.cpp \
+        PciRawDevImpl.cpp \
         $(VBOX_AUTOGEN_EVENT_CPP) \
         $(VBOX_XML_SCHEMADEFS_CPP) \

trunk/src/VBox/Main/PciDeviceAttachmentImpl.cpp

@@ -25 +25 @@
 struct PciDeviceAttachment::Data
 {
-    Data(Machine      *aParent,
-         const Bstr   &aDevName,
-         LONG          aHostAddress,
-         LONG          aGuestAddress,
-         BOOL          afPhysical)
+    Data(Machine        *aParent,
+         const Bstr     &aDevName,
+         LONG           aHostAddress,
+         LONG           aGuestAddress,
+         BOOL           afPhysical)
         : pMachine(aParent),
           HostAddress(aHostAddress), GuestAddress(aGuestAddress),
@@ -61 +61 @@
 // public initializer/uninitializer for internal purposes only
 /////////////////////////////////////////////////////////////////////////////
-HRESULT PciDeviceAttachment::init(Machine      *aParent,
-                                  const Bstr   &aDevName,
-                                  LONG          aHostAddress,
-                                  LONG          aGuestAddress,
-                                  BOOL          fPhysical)
+HRESULT PciDeviceAttachment::init(Machine       *aParent,
+                                  const Bstr    &aDevName,
+                                  LONG           aHostAddress,
+                                  LONG           aGuestAddress,
+                                  BOOL           fPhysical)
 {
     m = new Data(aParent, aDevName, aHostAddress, aGuestAddress, fPhysical);

trunk/src/VBox/Main/VBoxDriversRegister.cpp

@@ -26 +26 @@
 #include "AudioSnifferInterface.h"
 #include "ConsoleImpl.h"
+#include "PciRawDevImpl.h"
 
 #include "Logging.h"
@@ -67 +68 @@
     if (RT_FAILURE(rc))
         return rc;
+
+    rc = pCallbacks->pfnRegister(pCallbacks, &PciRawDev::DrvReg);
+    if (RT_FAILURE(rc))
+        return rc;
+
     return VINF_SUCCESS;
 }

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -4705 +4705 @@
         <desc>Desired position of this device on guest PCI bus.</desc>
       </param>
-      <param name="eventContext" type="IEventContext" dir="in">
-        <desc>Context passed into IHostPciDevicePlugEvent event.</desc>
-      </param>
       <param name="tryToUnbind" type="boolean" dir="in">
         <desc>If VMM shall try to unbind existing drivers from the
@@ -4718 +4715 @@
         Detach host PCI device from the virtual machine.
         Also HostPciDevicePlugEvent on IVirtualBox event source
-        will be delivered.
-
-        <note>
-          Not yet implemented.
-        </note>
+        will be delivered. As currently we don't support hot device
+        unplug, IHostPciDevicePlugEvent event is delivered immediately.
 
         <see>IHostPciDevicePlugEvent</see>
@@ -16597 +16591 @@
     >
     <desc>
-      Notification when host PCI device is plugged/unplugged.
+      Notification when host PCI device is plugged/unplugged. Plugging
+      usually takes place on VM startup, unplug - when
+      IMachine::DetachHostPciDevice is called.
+      <see>
+        IMachine::DetachHostPciDevice
+      </see>
     </desc>
 
@@ -16616 +16615 @@
       <desc>
         Attachment info for this device.
-      </desc>
-    </attribute>
-
-    <attribute name="eventContext" type="IEventContext" readonly="yes">
-      <desc>
-        Context object, passed into attachHostPciDevice() and
-        attachHostPciDevice().
       </desc>
     </attribute>

trunk/src/VBox/Main/include/MachineImpl.h

@@ -291 +291 @@
         BOOL                 mIoCacheEnabled;
         ULONG                mIoCacheSize;
+
+        typedef std::list< ComObjPtr<PciDeviceAttachment> > PciDeviceAssignmentList;
+        PciDeviceAssignmentList mPciDeviceAssignments;
     };
 
@@ -523 +526 @@
     STDMETHOD(QueryLogFilename(ULONG aIdx, BSTR *aName));
     STDMETHOD(ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData)));
-    STDMETHOD(AttachHostPciDevice(LONG hostAddress, LONG desiredGuestAddress, IEventContext *eventContext, BOOL tryToUnbind));
+    STDMETHOD(AttachHostPciDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL tryToUnbind));
     STDMETHOD(DetachHostPciDevice(LONG hostAddress));
     STDMETHOD(COMGETTER(PciDeviceAssignments))(ComSafeArrayOut(IPciDeviceAttachment *, aAssignments));
@@ -870 +873 @@
     typedef std::list< ComObjPtr<StorageController> > StorageControllerList;
     Backupable<StorageControllerList> mStorageControllers;
-
-    typedef std::list< ComObjPtr<PciDeviceAttachment> > PciDeviceAssignmentList;
-    PciDeviceAssignmentList mPciDeviceAssignments;
 
     friend class SessionMachine;

trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

@@ -48 +48 @@
 extern DECLEXPORT(const PDMPCIHLPR0)    g_pdmR0PciHlp;
 extern DECLEXPORT(const PDMHPETHLPR0)   g_pdmR0HpetHlp;
+extern DECLEXPORT(const PDMPCIRAWHLPR0) g_pdmR0PciRawHlp;
 extern DECLEXPORT(const PDMDRVHLPR0)    g_pdmR0DrvHlp;
 RT_C_DECLS_END
@@ -678 +679 @@
 };
 
+/**
+ * The Ring-0 PCI raw Helper Callbacks.
+ */
+extern DECLEXPORT(const PDMPCIRAWHLPR0) g_pdmR0PciRawHlp =
+{
+    PDM_PCIRAWHLPR0_VERSION,
+    PDM_PCIRAWHLPR0_VERSION, /* the end */
+};
+
 /** @} */
 

trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp

@@ -2809 +2809 @@
     *ppHpetHlpR3 = &g_pdmR3DevHpetHlp;
     LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+    LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n"));
+
+    /*
+     * Validate input.
+     */
+    if (pPciRawReg->u32Version != PDM_PCIRAWREG_VERSION)
+    {
+        AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciRawReg->u32Version, PDM_PCIRAWREG_VERSION));
+        LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (!ppPciRawHlpR3)
+    {
+        Assert(ppPciRawHlpR3);
+        LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    /* set the helper pointer and return. */
+    *ppPciRawHlpR3 = &g_pdmR3DevPciRawHlp;
+    LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
     return VINF_SUCCESS;
 }
@@ -3182 +3212 @@
     pdmR3DevHlp_IOAPICRegister,
     pdmR3DevHlp_HPETRegister,
+    pdmR3DevHlp_PciRawRegister,
     pdmR3DevHlp_DMACRegister,
     pdmR3DevHlp_DMARegister,
@@ -3392 +3423 @@
     pdmR3DevHlp_IOAPICRegister,
     pdmR3DevHlp_HPETRegister,
+    pdmR3DevHlp_PciRawRegister,
     pdmR3DevHlp_DMACRegister,
     pdmR3DevHlp_DMARegister,
@@ -3469 +3501 @@
 
 /** @} */
-

trunk/src/VBox/VMM/VMMR3/PDMDevMiscHlp.cpp

@@ -652 +652 @@
 
 
+/** @interface_method_impl{PDMPCIRAWHLPR3,pfnGetRCHelpers} */
+static DECLCALLBACK(PCPDMPCIRAWHLPRC) pdmR3PciRawHlp_GetRCHelpers(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+    RTRCPTR pRCHelpers = 0;
+    int rc = PDMR3LdrGetSymbolRC(pDevIns->Internal.s.pVMR3, NULL, "g_pdmRCPciRawHlp", &pRCHelpers);
+    AssertReleaseRC(rc);
+    AssertRelease(pRCHelpers);
+    LogFlow(("pdmR3PciRawHlp_GetGCHelpers: caller='%s'/%d: returns %RRv\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
+    return pRCHelpers;
+}
+
+
+/** @interface_method_impl{PDMPCIRAWHLPR3,pfnGetR0Helpers} */
+static DECLCALLBACK(PCPDMPCIRAWHLPR0) pdmR3PciRawHlp_GetR0Helpers(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+    PCPDMHPETHLPR0 pR0Helpers = 0;
+    int rc = PDMR3LdrGetSymbolR0(pDevIns->Internal.s.pVMR3, NULL, "g_pdmR0PciRawHlp", &pR0Helpers);
+    AssertReleaseRC(rc);
+    AssertRelease(pR0Helpers);
+    LogFlow(("pdmR3PciRawHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
+    return pR0Helpers;
+}
+
+/**
+ * Raw PCI Device Helpers.
+ */
+const PDMPCIRAWHLPR3 g_pdmR3DevPciRawHlp =
+{
+    PDM_PCIRAWHLPR3_VERSION,
+    pdmR3PciRawHlp_GetRCHelpers,
+    pdmR3PciRawHlp_GetR0Helpers,
+    PDM_PCIRAWHLPR3_VERSION, /* the end */
+};
 
 /* none yet */

trunk/src/VBox/VMM/include/PDMInternal.h

@@ -1085 +1085 @@
 extern const PDMRTCHLP      g_pdmR3DevRtcHlp;
 extern const PDMHPETHLPR3   g_pdmR3DevHpetHlp;
+extern const PDMPCIRAWHLPR3 g_pdmR3DevPciRawHlp;
 #endif