Changeset 7688 in vbox

Timestamp:

Apr 1, 2008 4:04:55 PM (17 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

29214

Message:

PCnet: some cleanup, use host-provided RX buffers but don't access them directly yet

Location:

trunk

Files:

• include/VBox/DevPCNet.h (modified) (3 diffs)
• src/VBox/Devices/Network/DevPCNet.cpp (modified) (11 diffs)

trunk/include/VBox/DevPCNet.h

@@ -34 +34 @@
 
 #define PCNET_GUEST_INTERFACE_VERSION         (1)
-#define PCNET_GUEST_SHARED_MEMORY_SIZE        _1M
+#define PCNET_GUEST_SHARED_MEMORY_SIZE        _512K
 #define PCNET_GUEST_TX_DESCRIPTOR_SIZE        16
 #define PCNET_GUEST_RX_DESCRIPTOR_SIZE        16
@@ -49 +49 @@
 typedef struct
 {
-    /** The size of the shared memory.
-     * This is sizeof(PCNETGUESTSHAREDMEMORY) not PCNET_GUEST_SHARED_MEMORY_SIZE as one would expect.
-     * @todo r=bird: why not rename to cbHdr or something more descriptive? */
-    uint32_t u32Size;
+    /** The size of the shared memory. */
+    uint32_t cbSize;
     /** Version (PCNET_GUEST_INTERFACE_VERSION). */
     uint32_t u32Version;
     /** Flags (See PCNET_GUEST_FLAGS_*). */
     uint32_t fFlags;
+    /** align the following members to 64 bit */
+    uint32_t u32Alignment;
 
-    /** @todo r=bird: You might consider aligning this on a 8(/16) byte boundrary to
-     * avoid future uint64_t issues. */
     union
     {
@@ -68 +66 @@
             /** The size (in bytes) of the receive descriptor array. */
             uint32_t    cbRxDescriptors;
-            /** Offset of the transmit descriptors relative to this header.
-             * @todo r=bird: offTxDescriptors is IMO a better name. */
-            uint32_t    u32OffTxDescriptors;
+            /** Offset of the transmit descriptors relative to this header. */
+            uint32_t    offTxDescriptors;
             /** Offset of the receive descriptors relative to this header. */
-            uint32_t    u32OffRxDescriptors;
+            uint32_t    offRxDescriptors;
             /** Offset of the transmit buffers relative to this header. */
-            uint32_t    u32OffTxBuffers;
+            uint32_t    offTxBuffers;
             /** Offset of the receive buffers relative to this header. */
-            uint32_t    u32OffRxBuffers;
+            uint32_t    offRxBuffers;
         } V1;
     } V;

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

@@ -610 +610 @@
         uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
                     + (addr - pData->GCTDRA)
-                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffTxDescriptors;
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.offTxDescriptors;
         if (!(pv[7] & 0x80) && fRetIfNotOwn)
             return false;
@@ -672 +672 @@
         uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
                     + (addr - pData->GCTDRA)
-                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffTxDescriptors;
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.offTxDescriptors;
         memcpy(pv, tmd, 16);
         pv[7] &= ~0x80;
@@ -729 +729 @@
         uint8_t *pb = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
                     + (addr - pData->GCRDRA)
-                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffRxDescriptors;
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
         if (!(pb[7] & 0x80) && fRetIfNotOwn)
             return false;
@@ -789 +789 @@
         uint8_t *pv = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
                     + (addr - pData->GCRDRA)
-                    + pData->CTXSUFF(pSharedMMIO)->V.V1.u32OffRxDescriptors;
+                    + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
         memcpy(pv, rmd, 16);
         pv[7] &= ~0x80;
@@ -873 +873 @@
     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;
+    pData->pSharedMMIOHC->V.V1.offTxDescriptors = u32Off;
     u32Off = RT_ALIGN(u32Off + PCNET_GUEST_TX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
-    pData->pSharedMMIOHC->V.V1.u32OffRxDescriptors = u32Off;
+    pData->pSharedMMIOHC->V.V1.offRxDescriptors = 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;
+#if 0
+    /* Don't allocate TX buffers since Windows guests cannot use it */
+    pData->pSharedMMIOHC->V.V1.offTxBuffers = u32Off;
     u32Off = RT_ALIGN(u32Off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
-    pData->pSharedMMIOHC->V.V1.u32OffRxBuffers = u32Off;
+#endif
+    pData->pSharedMMIOHC->V.V1.offRxBuffers = 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);
+    pData->pSharedMMIOHC->cbSize = u32Off;
 }
 
@@ -1805 +1808 @@
             int count = RT_MIN(4096 - (int)rmd.rmd1.bcnt, size);
             RTGCPHYS32 rbadr = PHYSADDR(pData, rmd.rmd0.rbadr);
-            PDMDevHlpPhysWrite(pDevIns, rbadr, src, count);
+#if 0
+            if (pData->fPrivIfEnabled)
+            {
+                uint8_t *pb = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
+                            + rbadr - pData->GCRDRA + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
+                memcpy(pb, src, count);
+            }
+            else
+#endif
+                PDMDevHlpPhysWrite(pDevIns, rbadr, src, count);
             src  += count;
             size -= count;
@@ -1834 +1846 @@
 
                 count = RT_MIN(4096 - (int)rmd.rmd1.bcnt, size);
-                rbadr = PHYSADDR(pData, rmd.rmd0.rbadr);
-                PDMDevHlpPhysWrite(pDevIns, rbadr, src, count);
+                RTGCPHYS32 rbadr = PHYSADDR(pData, rmd.rmd0.rbadr);
+#if 0
+                if (pData->fPrivIfEnabled)
+                {
+                    uint8_t *pb = (uint8_t*)pData->CTXSUFF(pSharedMMIO)
+                                + rbadr - pData->GCRDRA + pData->CTXSUFF(pSharedMMIO)->V.V1.offRxDescriptors;
+                    memcpy(pb, src, count);
+                }
+                else
+#endif
+                    PDMDevHlpPhysWrite(pDevIns, rbadr, src, count);
                 src  += count;
                 size -= count;
@@ -2387 +2408 @@
 static DECLCALLBACK(int) pcnetAsyncSendThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    PCNetState *pThis = PDMINS2DATA(pDevIns, PCNetState *);
+    PCNetState *pData = PDMINS2DATA(pDevIns, PCNetState *);
 
     /*
@@ -2412 +2433 @@
          * to leave the running state.
          */
-        int rc = RTSemEventWait(pThis->hSendEventSem, RT_INDEFINITE_WAIT);
+        int rc = RTSemEventWait(pData->hSendEventSem, RT_INDEFINITE_WAIT);
         AssertRCReturn(rc, rc);
         if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
@@ -2421 +2442 @@
          * suspended while waiting for the critical section.
          */
-        rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
+        rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
         AssertReleaseRCReturn(rc, rc);
 
         if (pThread->enmState == PDMTHREADSTATE_RUNNING)
         {
-            rc = pcnetAsyncTransmit(pThis);
+            rc = pcnetAsyncTransmit(pData);
             AssertReleaseRC(rc);
         }
 
-        PDMCritSectLeave(&pThis->CritSect);
+        PDMCritSectLeave(&pData->CritSect);
     }
 
@@ -2447 +2468 @@
 static DECLCALLBACK(int) pcnetAsyncSendThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    PCNetState *pThis = PDMINS2DATA(pDevIns, PCNetState *);
-    return RTSemEventSignal(pThis->hSendEventSem);
+    PCNetState *pData = PDMINS2DATA(pDevIns, PCNetState *);
+    return RTSemEventSignal(pData->hSendEventSem);
 }