Changeset 83058 in vbox for trunk/src/VBox/Devices

Timestamp:

Feb 12, 2020 12:10:49 PM (5 years ago)

Author:

vboxsync

Message:

Network/DevVirtioNet_1_0.cpp: Starting to receive Rx packets from now. Continuing to test and debug. See BugRef(8651) Comment #60

Location:

trunk/src/VBox/Devices

Files:

• Network/DevVirtioNet_1_0.cpp (modified) (6 diffs)
• VirtIO/Virtio_1_0.cpp (modified) (5 diffs)

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

@@ -1056 +1056 @@
 static int virtioNetR3IsRxQueuePrimed(PPDMDEVINS pDevIns, PVIRTIONET pThis, uint16_t idxQueue)
 {
-    int rc;
-
-    LogFunc(("%s %s\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
+#define LOGPARAMS INSTANCE(pThis), VIRTQNAME(idxQueue)
 
     if (!pThis->fVirtioReady)
-        rc = VERR_NET_NO_BUFFER_SPACE;
-
+    {
+        LogFunc(("%s %s VirtIO not ready (rc = VERR_NET_NO_BUFFER_SPACE)\n", LOGPARAMS));
+    }
     else if (!virtioCoreIsQueueEnabled(&pThis->Virtio, RXQIDX_QPAIR(idxQueue)))
-        rc = VERR_NET_NO_BUFFER_SPACE;
-
+    {
+        LogFunc(("%s %s queue not enabled (rc = VERR_NET_NO_BUFFER_SPACE)\n", LOGPARAMS));
+    }
     else if (virtioCoreQueueIsEmpty(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(idxQueue)))
     {
+        LogFunc(("%s %s queue is empty (rc = VERR_NET_NO_BUFFER_SPACE)\n", LOGPARAMS));
         virtioCoreQueueSetNotify(&pThis->Virtio, RXQIDX_QPAIR(idxQueue), true);
-        rc = VERR_NET_NO_BUFFER_SPACE;
     }
     else
     {
+        LogFunc(("%s %s ready with available buffers\n", LOGPARAMS));
         virtioCoreQueueSetNotify(&pThis->Virtio, RXQIDX_QPAIR(idxQueue), false);
-        rc = VINF_SUCCESS;
-    }
-
-    LogFlowFunc(("%s idxQueue = %d -> %Rrc\n", INSTANCE(pThis), idxQueue, rc));
-    return rc;
-}
-
+        return VINF_SUCCESS;
+    }
+    return VERR_NET_NO_BUFFER_SPACE;
+}
+
+
+static bool virtioNetR3AreRxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis)
+{
+    /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
+              selection algorithm feasible or even necessary to prevent starvation? */
+    for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue += 2) /* Skip odd queue #'s because Rx queues only! */
+    {
+        if (!IS_RX_QUEUE(idxQueue))
+            continue;
+
+        if (RT_SUCCESS(virtioNetR3IsRxQueuePrimed(pDevIns, pThis, idxQueue)))
+            return true;
+    }
+    return false;
+}
 /*
  * Returns true if VirtIO core and device are in a running and operational state
@@ -1108 +1122 @@
     PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
 
-    if (!virtioNetAllSystemsGo(pThis, pDevIns))
-    {
-        LogFunc(("%s VirtIO not ready\n", INSTANCE(pThis)));
-        return VERR_NET_NO_BUFFER_SPACE;
-    }
-
+    if (virtioNetR3AreRxBufsAvail(pDevIns, pThis))
+    {
+            LogFunc(("%s Rx bufs now available, releasing waiter...\n", INSTANCE(pThis)));
+            return VINF_SUCCESS;
+    }
     if (!timeoutMs)
         return VERR_NET_NO_BUFFER_SPACE;
@@ -1121 +1134 @@
     ASMAtomicXchgBool(&pThis->fLeafWantsRxBuffers, true);
 
-    /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
-              selection algorithm feasible or even necessary to prevent starvation? */
     do {
-        for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue += 2) /* Skip odd queue #'s because Rx queues only! */
+        if (virtioNetR3AreRxBufsAvail(pDevIns, pThis))
         {
-            if (!IS_RX_QUEUE(idxQueue))
-                continue;
-
-            if (RT_SUCCESS(virtioNetR3IsRxQueuePrimed(pDevIns, pThis, idxQueue)))
-            {
-                LogFunc(("%s Rx bufs now available, releasing waiter...", INSTANCE(pThis)));
+                LogFunc(("%s Rx bufs now available, releasing waiter...\n", INSTANCE(pThis)));
                 return VINF_SUCCESS;
-            }
         }
         LogFunc(("%s Starved for guest Rx bufs, waiting %u ms ...\n",
                  INSTANCE(pThis), timeoutMs));
 
-        int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns,
-                        pThis->hEventRxDescAvail, timeoutMs);
+        int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hEventRxDescAvail, timeoutMs);
 
         if (rc == VERR_TIMEOUT || rc == VERR_INTERRUPTED)
@@ -1455 +1459 @@
                                                size_t cb, PCPDMNETWORKGSO pGso)
 {
+LogFunc(("\n"));
     PVIRTIONETCC    pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
     PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-
-    LogFunc(("%s\n", pThis));
 
     if (!pThis->fVirtioReady)
@@ -2068 +2071 @@
     /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
           selection algorithm feasible or even necessary */
-
+    LogFunc(("\n"));
     virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX_QPAIR(0), false /*fOnWorkerThread*/);
 }
@@ -2625 +2628 @@
     /* Initialize the generic Virtio core: */
     pThisCC->Virtio.pfnStatusChanged        = virtioNetR3StatusChanged;
-    pThisCC->Virtio.pfnQueueNotified        = virtioNetR3QueueNotified
-    ;
+    pThisCC->Virtio.pfnQueueNotified        = virtioNetR3QueueNotified;
     pThisCC->Virtio.pfnDevCapRead           = virtioNetR3DevCapRead;
     pThisCC->Virtio.pfnDevCapWrite          = virtioNetR3DevCapWrite;

trunk/src/VBox/Devices/VirtIO/Virtio_1_0.cpp

@@ -226 +226 @@
 }
 
-DECLINLINE(void) virtioWriteUsedFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint16_t fFlags)
+DECLINLINE(void) virtioWriteUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint16_t fFlags)
 {
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
@@ -256 +256 @@
 #endif
 
-DECLINLINE(uint16_t) virtioReadUsedFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
 {
     uint16_t fFlags = 0;
@@ -681 +681 @@
     if (pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
     {
-        uint16_t fFlags = virtioReadUsedFlags(pVirtio->pDevIns, pVirtio, idxQueue);
+        uint16_t fFlags = virtioReadUsedRingFlags(pVirtio->pDevIns, pVirtio, idxQueue);
 
         if (fEnabled)
@@ -688 +688 @@
             fFlags |= VIRTQ_USED_F_NO_NOTIFY;
 
-        virtioWriteUsedFlags(pVirtio->pDevIns, pVirtio, idxQueue, fFlags);
+        virtioWriteUsedRingFlags(pVirtio->pDevIns, pVirtio, idxQueue, fFlags);
     }
 }
@@ -1014 +1014 @@
     {
         /** If guest driver hasn't suppressed interrupts, interrupt  */
-        if (fForce || !(virtioReadUsedFlags(pDevIns, pVirtio, idxQueue) & VIRTQ_AVAIL_F_NO_INTERRUPT))
+        if (fForce || !(virtioReadUsedRingFlags(pDevIns, pVirtio, idxQueue) & VIRTQ_AVAIL_F_NO_INTERRUPT))
         {
             virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue], fForce);