Changeset 7671 in vbox

Timestamp:

Apr 1, 2008 7:56:35 AM (17 years ago)

Author:

vboxsync

Message:

PCNet: Create private PCI memory for shared RX/TX descriptors and buffers.

File:

• trunk/src/VBox/Devices/Network/DevPCNet.cpp (modified) (15 diffs)

trunk/src/VBox/Devices/Network/DevPCNet.cpp

@@ -53 +53 @@
 #include <VBox/pgm.h>
 #include <VBox/vm.h> /* for VM_IS_EMT */
+#include <VBox/DevPCNet.h>
 #include <iprt/asm.h>
 #include <iprt/assert.h>
@@ -229 +230 @@
 #endif
 
+    /** The host context of the shared memory used for the private interface. */
+    PPCNETGUESTSHAREDMEMORY             pSharedMMIOHC;
+    /** The hypervisor/guest context of the shared memory used for the private interface. */
+    GCPTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIOGC;
+
+    /** True if host and guest admitted to use the private interface. */
+    bool                                fPrivIfEnabled;
     bool                                fGCEnabled;
     bool                                fR0Enabled;
     bool                                fAm79C973;
-    bool                                afAlignment[1];
     uint32_t                            u32LinkSpeed;
 
@@ -594 +601 @@
     uint8_t    ownbyte;
 
-    if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    if (pData->fPrivIfEnabled)
+    {
+        /* RX/TX descriptors shared between host and guest => direct copy */
+        uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
+                    + (addr - pData->GCTDRA)
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffTxDescriptors;
+        if (!(pv[7] & 0x80) && fRetIfNotOwn)
+            return false;
+        memcpy(tmd, pv, 16);
+        return true;
+    }
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
     {
         uint16_t xda[4];
@@ -645 +663 @@
     STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatTmdStore), a);
     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
-    if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    if (pData->fPrivIfEnabled)
+    {
+        /* RX/TX descriptors shared between host and guest => direct copy */
+        uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
+                    + (addr - pData->GCTDRA)
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffTxDescriptors;
+        memcpy(pv, tmd, 16);
+        pv[7] &= ~0x80;
+    }
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
     {
         uint16_t xda[4];
@@ -693 +720 @@
     uint8_t    ownbyte;
 
-    if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    if (pData->fPrivIfEnabled)
+    {
+        /* RX/TX descriptors shared between host and guest => direct copy */
+        uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
+                    + (addr - pData->GCRDRA)
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffRxDescriptors;
+        if (!(pv[7] & 0x80) && fRetIfNotOwn)
+            return false;
+        memcpy(rmd, pv, 16);
+        return true;
+    }
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
     {
         uint16_t rda[4];
@@ -742 +780 @@
 {
     PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
-    if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    if (pData->fPrivIfEnabled)
+    {
+        /* RX/TX descriptors shared between host and guest => direct copy */
+        uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
+                    + (addr - pData->GCRDRA)
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffRxDescriptors;
+        memcpy(pv, rmd, 16);
+        pv[7] &= ~0x80;
+    }
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
     {
         uint16_t rda[4];
@@ -814 +861 @@
 
 #ifdef IN_RING3
+
+/**
+ * Initialize the shared memory for the private guest interface.
+ */
+static void pcnetInitSharedMemory(PCNetState *pData)
+{
+    uint32_t u32Off = 0;
+    memset(pData->pSharedMMIOHC, 0, sizeof(PCNETGUESTSHAREDMEMORY));
+    pData->pSharedMMIOHC->u32Size = sizeof(PCNETGUESTSHAREDMEMORY);
+    pData->pSharedMMIOHC->u32Version = PCNET_GUEST_INTERFACE_VERSION;
+    u32Off = 2048; /* Leave some space for more fields within the header */
+    pData->pSharedMMIOHC->V.V1.u32OffTxDescriptors = u32Off;
+    u32Off = RT_ALIGN(u32Off + PCNET_GUEST_TX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
+    pData->pSharedMMIOHC->V.V1.u32OffRxDescriptors = u32Off;
+    u32Off = RT_ALIGN(u32Off + PCNET_GUEST_RX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_RX_DESCRIPTORS, 32);
+    /* Map the RX/TX descriptors into the hypervisor. Make sure we don't need too much space. */
+    AssertRelease(u32Off <= 8192);
+    pData->pSharedMMIOHC->V.V1.u32OffTxBuffers = u32Off;
+    u32Off = RT_ALIGN(u32Off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
+    pData->pSharedMMIOHC->V.V1.u32OffRxBuffers = u32Off;
+    pData->pSharedMMIOHC->fFlags = PCNET_GUEST_FLAGS_ADMIT_HOST;
+    u32Off = RT_ALIGN(u32Off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_RX_DESCRIPTORS, 32);
+    AssertRelease(u32Off <= PCNET_GUEST_SHARED_MEMORY_SIZE);
+}
 
 #define MULTICAST_FILTER_LEN 8
@@ -1384 +1455 @@
 } while (0)
 
+    bool fPrivIfEnabled =       pData->pSharedMMIOHC
+                          && !!(pData->pSharedMMIOHC->fFlags & PCNET_GUEST_FLAGS_ADMIT_GUEST);
+    if (fPrivIfEnabled != pData->fPrivIfEnabled)
+    {
+        pData->fPrivIfEnabled = fPrivIfEnabled;
+        LogRel(("PCNet#%d: %s private interface\n", PCNET_INST_NR, fPrivIfEnabled ? "Enabling" : "Disabling"));
+    }
     if (BCR_SSIZE32(pData))
     {
@@ -2223 +2301 @@
                 {
                     AssertMsg(fDropFrame, ("pcnetTransmit: Frame is too big!!! %d bytes\n",
-                                           pData->cbSendFrame + cb));
+                                pData->cbSendFrame + cb));
                     fDropFrame = true;
                 }
@@ -2229 +2307 @@
                 {
                     Log(("#%d pcnetTransmit: stp: cb=%d xmtrc=%#x-%#x\n", PCNET_INST_NR,
-                         pData->cbSendFrame, iStart, CSR_XMTRC(pData)));
+                                pData->cbSendFrame, iStart, CSR_XMTRC(pData)));
                     if (pcnetIsLinkUp(pData) && !fDropFrame)
                     {
@@ -3698 +3776 @@
 
 /**
+ * Callback function for mapping the MMIO region.
+ *
+ * @return VBox status code.
+ * @param   pPciDev         Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
+ * @param   iRegion         The region number.
+ * @param   GCPhysAddress   Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
+ *                          I/O port, else it's a physical address.
+ *                          This address is *NOT* relative to pci_mem_base like earlier!
+ * @param   cb              Region size.
+ * @param   enmType         One of the PCI_ADDRESS_SPACE_* values.
+ */
+static DECLCALLBACK(int) pcnetMMIOSharedMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion,
+                                            RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
+{
+    if (GCPhysAddress != NIL_RTGCPHYS)
+        return PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
+
+    /* nothing to clean up */
+    return VINF_SUCCESS;
+}
+
+
+/**
  * PCNET status info callback.
  *
@@ -4284 +4385 @@
         pcnetTimerRestore(pDevIns, pData->pTimerRestore);
     }
+    if (pData->pSharedMMIOHC)
+        pcnetInitSharedMemory(pData);
 
     /** @todo How to flush the queues? */
@@ -4299 +4402 @@
     pData->pXmitQueueGC  = PDMQueueGCPtr(pData->pXmitQueueHC);
     pData->pCanRxQueueGC = PDMQueueGCPtr(pData->pCanRxQueueHC);
+    pData->pSharedMMIOGC += offDelta;
 #ifdef PCNET_NO_POLLING
     *(RTHCUINTPTR *)&pData->pfnEMInterpretInstructionGC += offDelta;
@@ -4371 +4475 @@
      * Validate configuration.
      */
-    if (!CFGMR3AreValuesValid(pCfgHandle, "MAC\0CableConnected\0Am79C973\0LineSpeed\0GCEnabled\0R0Enabled\0"))
+    if (!CFGMR3AreValuesValid(pCfgHandle, "MAC\0CableConnected\0Am79C973\0LineSpeed\0GCEnabled\0R0Enabled\0PrivIfEnabled\0"))
         return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
                                 N_("Invalid configuraton for pcnet device"));
@@ -4487 +4591 @@
     if (VBOX_FAILURE(rc))
         return rc;
+
+    bool fPrivIfEnabled;
+    rc = CFGMR3QueryBool(pCfgHandle, "PrivIfEnabled", &fPrivIfEnabled);
+    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
+        fPrivIfEnabled = true;
+    else if (VBOX_FAILURE(rc))
+        return PDMDEV_SET_ERROR(pDevIns, rc,
+                                N_("Configuration error: Failed to get the \"PrivIfEnabled\" value"));
+
+    if (fPrivIfEnabled)
+    {
+        /*
+         * Initialize shared memory between host and guest for descriptors and RX buffers. Most guests
+         * should not care if there is an additional PCI ressource but just in case we made this configurable.
+         */
+        rc = PDMDevHlpMMIO2Register(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE, (void**)&pData->pSharedMMIOHC, "PCNetShMem");
+        if (VBOX_FAILURE(rc))
+            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
+                                       N_("Failed to allocate %u bytes of memory for the PCNet device"), PCNET_GUEST_SHARED_MEMORY_SIZE);
+        rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pData->pSharedMMIOGC);
+        if (VBOX_FAILURE(rc))
+            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
+                                       N_("Failed to map 8192 bytes of memory for the PCNet device into the hyper memory"));
+        pcnetInitSharedMemory(pData);
+        rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE,
+                                          PCI_ADDRESS_SPACE_MEM, pcnetMMIOSharedMap);
+        if (VBOX_FAILURE(rc))
+            return rc;
+    }
 
 #ifdef PCNET_NO_POLLING