Changeset 80194 in vbox for trunk/src

Timestamp:

Aug 8, 2019 7:26:33 AM (5 years ago)

Author:

vboxsync

Message:

Some more re-structuring and encapsulation of library implementation. Starting to flesh out more of the negotiation with the driver and spec-defined behaviors (See #9440, Comment #43)

Location:

trunk/src/VBox/Devices

Files:

• Storage/DevVirtioSCSI.cpp (modified) (11 diffs)
• VirtIO/Virtio_1_0.cpp (modified) (39 diffs)
• VirtIO/Virtio_1_0.h (modified) (7 diffs)
• VirtIO/Virtio_1_0_impl.h (modified) (2 diffs)

trunk/src/VBox/Devices/Storage/DevVirtioSCSI.cpp

@@ -60 +60 @@
 #define VIRTIOSCSI_REGION_PCI_CAP                   2
 
-
-
 /**
  * This macro resolves to boolean true if uOffset matches a field offset and size exactly,
  * (or if it is a 64-bit field, if it accesses either 32-bit part as a 32-bit access)
  * ASSUMED this critereon is mandated by section 4.1.3.1 of the VirtIO 1.0 specification)
+ * This MACRO can be re-written to allow unaligned access to a field (within bounds).
  *
  * @param   member   - Member of VIRTIO_PCI_COMMON_CFG_T
@@ -72 +71 @@
  * @result           - true or false
  */
-#define VIRTIO_1_0__SECT_4_1_3_1__COMPLIANT
-#ifdef VIRTIO_1_0__SECT_4_1_3_1__COMPLIANT
-#   define MATCH_SCSI_CONFIG(member) \
+#define MATCH_SCSI_CONFIG(member) \
             (RT_SIZEOFMEMB(VIRTIO_SCSI_CONFIG_T, member) == 64 \
              && (   uOffset == RT_OFFSETOF(VIRTIO_SCSI_CONFIG_T, member) \
@@ -81 +78 @@
          || (uOffset == RT_OFFSETOF(VIRTIO_SCSI_CONFIG_T, member) \
                && cb == RT_SIZEOFMEMB(VIRTIO_SCSI_CONFIG_T, member))
-#else
-#   define MATCH_SCSI_CONFIG(member) \
-        ((int)uOffset >= RT_OFFSETOF(VIRTIO_SCSI_CONFIG_T, member) \
-            &&  uOffset < (uint32_t)(RT_OFFSETOF(VIRTIO_SCSI_CONFIG_T, member) \
-                                   + RT_SIZEOFMEMB(VIRTIO_SCSI_CONFIG_T, member)) \
-            &&   cb <= RT_SIZEOFMEMB(VIRTIO_SCSI_CONFIG_T, member) \
-                      - (uOffset - RT_OFFSETOF(VIRTIO_SCSI_CONFIG_T, member)))
-#endif
 
 #define LOG_ACCESSOR(member) \
@@ -97 +86 @@
         uint32_t uMemberOffset = uOffset - RT_OFFSETOF(VIRTIO_SCSI_CONFIG_T, member); \
         if (fWrite) \
-            memcpy(((char *)&pThis->virtioScsiConfig.member) + uMemberOffset, (const char *)pv, cb); \
+            memcpy(((char *)&pVirtioScsi->virtioScsiConfig.member) + uMemberOffset, (const char *)pv, cb); \
         else \
-            memcpy((char *)pv, (const char *)(((char *)&pThis->virtioScsiConfig.member) + uMemberOffset), cb); \
+            memcpy((char *)pv, (const char *)(((char *)&pVirtioScsi->virtioScsiConfig.member) + uMemberOffset), cb); \
         LOG_ACCESSOR(member); \
     }
@@ -110 +99 @@
         else \
         { \
-            memcpy((char *)pv, (const char *)(((char *)&pThis->virtioScsiConfig.member) + uMemberOffset), cb); \
+            memcpy((char *)pv, (const char *)(((char *)&pVirtioScsi->virtioScsiConfig.member) + uMemberOffset), cb); \
             LOG_ACCESSOR(member); \
         } \
@@ -346 +335 @@
 typedef struct VIRTIOSCSI
 {
-    /* virtioState must be first member */
-    VIRTIOSTATE                     virtioState;
+    /* Opaque handle to Virtio common framework */
+    VIRTIOHANDLE                    hVirtio;
 
     /* SCSI target instances data */
@@ -783 +772 @@
 }
 
-static int virtioScsiR3CfgAccessed(PVIRTIOSCSI pThis, uint32_t uOffset,
+static int virtioScsiR3CfgAccessed(PVIRTIOSCSI pVirtioScsi, uint32_t uOffset,
                                     const void *pv, size_t cb, uint8_t fWrite)
 {
@@ -856 +845 @@
 {
     int rc = VINF_SUCCESS;
-    PVIRTIOSCSI  pThis = PDMINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI  pVirtioScsi = PDMINS_2_DATA(pDevIns, PVIRTIOSCSI);
 
 //    LogFunc(("Read from Device-Specific capabilities: uOffset: 0x%x, cb: 0x%x\n",
 //              uOffset, cb));
 
-    rc = virtioScsiR3CfgAccessed(pThis, uOffset, pv, cb, false);
+    rc = virtioScsiR3CfgAccessed(pVirtioScsi, uOffset, pv, cb, false);
 
     return rc;
@@ -878 +867 @@
 {
     int rc = VINF_SUCCESS;
-    PVIRTIOSCSI  pThis = PDMINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI  pVirtioScsi = PDMINS_2_DATA(pDevIns, PVIRTIOSCSI);
 
 //    LogFunc(("Write to Device-Specific capabilities: uOffset: 0x%x, cb: 0x%x\n",
 //              uOffset, cb));
 
-    rc = virtioScsiR3CfgAccessed(pThis, uOffset, pv, cb, true);
+    rc = virtioScsiR3CfgAccessed(pVirtioScsi, uOffset, pv, cb, true);
 
     return rc;
@@ -1102 +1091 @@
     pVirtioPciParams->uInterruptPin  = 0x01;
 
-    PVIRTIOSTATE pVirtio = &(pThis->virtioState);
-
-    virtioSetHostFeatures(pVirtio, VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED);
-
     pThis->IBase.pfnQueryInterface = virtioScsiR3DeviceQueryInterface;
 
@@ -1120 +1105 @@
     pThis->virtioScsiConfig.uMaxLun         = 16383; /* from VirtIO 1.0 spec */
 
-    rc = virtioConstruct(pDevIns, pVirtio, iInstance, pVirtioPciParams,
+    rc = virtioConstruct(pDevIns, &pThis->hVirtio, iInstance, pVirtioPciParams,
                          VIRTIOSCSI_NAME_FMT, VIRTIOSCSI_N_QUEUES, VIRTIOSCSI_REGION_PCI_CAP,
+                         VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED,
                          virtioScsiR3DevCapRead, virtioScsiR3DevCapWrite,
                          sizeof(VIRTIO_SCSI_CONFIG_T) /* cbDevSpecificCap */,
-                         true /* fHaveDevSpecificCap */,
+                         (void *)&pThis->virtioScsiConfig /* pDevSpecificCap */,
                          0 /* uNotifyOffMultiplier */);
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * Virtio_1_0 - Virtio Common Functions (VirtQueue, VQueue, Virtio PCI)
+ * Virtio_1_0 - Virtio Common Functions (VirtQ, VQueue, Virtio PCI)
  */
 
@@ -26 +26 @@
 #include <iprt/assert.h>
 #include <iprt/uuid.h>
+#include <iprt/mem.h>
 #include <VBox/vmm/pdmdev.h>
+#include "Virtio_1_0_impl.h"
 #include "Virtio_1_0.h"
-#include "Virtio_1_0_impl.h"
 
 #define INSTANCE(pState) pState->szInstance
 #define IFACE_TO_STATE(pIface, ifaceName) ((VIRTIOSTATE *)((char*)(pIface) - RT_UOFFSETOF(VIRTIOSTATE, ifaceName)))
+
+#define H2P(hVirtio) ((PVIRTIOSTATE)(hVirtio))
 
 #ifdef LOG_ENABLED
@@ -37 +40 @@
 #endif
 
-void virtQueueReadDesc(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue, uint32_t idx, PVIRTQUEUEDESC pDesc)
-{
-    //Log(("%s virtQueueReadDesc: ring=%p idx=%u\n", INSTANCE(pState), pVirtQueue, idx));
+/**
+ * Formats the logging of a memory-mapped I/O input or output value
+ *
+ * @param   pszFunc     - To avoid displaying this function's name via __FUNCTION__ or LogFunc()
+ * @param   pszMember   - Name of struct member
+ * @param   pv          - pointer to value
+ * @param   cb          - size of value
+ * @param   uOffset     - offset into member where value starts
+ * @param   fWrite      - True if write I/O
+ * @param   fHasIndex   - True if the member is indexed
+ * @param   idx         - The index if fHasIndex
+ */
+void virtioLogMappedIoValue(const char *pszFunc, const char *pszMember, const void *pv, uint32_t cb,
+                        uint32_t uOffset, bool fWrite, bool fHasIndex, uint32_t idx)
+{
+
+#define FMTHEX(fmtout, val, cNybs) \
+    fmtout[cNybs] = '\0'; \
+    for (uint8_t i = 0; i < cNybs; i++) \
+        fmtout[(cNybs - i) -1] = "0123456789abcdef"[(val >> (i * 4)) & 0xf];
+
+#define MAX_STRING   64
+    char pszIdx[MAX_STRING] = { 0 };
+    char pszDepiction[MAX_STRING] = { 0 };
+    char pszFormattedVal[MAX_STRING] = { 0 };
+    if (fHasIndex)
+        RTStrPrintf(pszIdx, sizeof(pszIdx), "[%d]", idx);
+    if (cb == 1 || cb == 2 || cb == 4 || cb == 8)
+    {
+        /* manually padding with 0's instead of \b due to different impl of %x precision than printf() */
+        uint64_t val = 0;
+        memcpy((char *)&val, pv, cb);
+        FMTHEX(pszFormattedVal, val, cb * 2);
+        if (uOffset != 0) /* display bounds if partial member access */
+            RTStrPrintf(pszDepiction, sizeof(pszDepiction), "%s%s[%d:%d]",
+                        pszMember, pszIdx, uOffset, uOffset + cb - 1);
+        else
+            RTStrPrintf(pszDepiction, sizeof(pszDepiction), "%s%s", pszMember, pszIdx);
+        RTStrPrintf(pszDepiction, sizeof(pszDepiction), "%-30s", pszDepiction);
+        uint32_t first = 0;
+        for (uint8_t i = 0; i < sizeof(pszDepiction); i++)
+            if (pszDepiction[i] == ' ' && first++ != 0)
+                pszDepiction[i] = '.';
+        Log(("%s: Guest %s %s 0x%s\n", \
+                  pszFunc, fWrite ? "wrote" : "read ", pszDepiction, pszFormattedVal));
+    }
+    else /* odd number or oversized access, ... log inline hex-dump style */
+    {
+        Log(("%s: Guest %s %s%s[%d:%d]: %.*Rhxs\n", \
+              pszFunc, fWrite ? "wrote" : "read ", pszMember,
+              pszIdx, uOffset, uOffset + cb, cb, pv));
+    }
+}
+
+
+void virtQueueReadDesc(PVIRTIOSTATE pState, PVIRTQ pVirtQ, uint32_t idx, PVIRTQ_DESC_T pDesc)
+{
+    //Log(("%s virtQueueReadDesc: ring=%p idx=%u\n", INSTANCE(pState), pVirtQ, idx));
     PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVirtQueue->pGcPhysVirtqDescriptors + sizeof(VIRTQUEUEDESC) * (idx % pVirtQueue->cbQueue),
-                      pDesc, sizeof(VIRTQUEUEDESC));
-}
-
-uint16_t virtQueueReadAvail(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue, uint32_t idx)
+                      pVirtQ->pGcPhysVirtqDescriptors + sizeof(VIRTQ_DESC_T) * (idx % pVirtQ->cbQueue),
+                      pDesc, sizeof(VIRTQ_DESC_T));
+}
+
+uint16_t virtQueueReadAvail(PVIRTIOSTATE pState, PVIRTQ pVirtQ, uint32_t idx)
 {
     uint16_t tmp;
     PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVirtQueue->pGcPhysVirtqAvail + RT_UOFFSETOF_DYN(VIRTQUEUEAVAIL, auRing[idx % pVirtQueue->cbQueue]),
+                      pVirtQ->pGcPhysVirtqAvail + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[idx % pVirtQ->cbQueue]),
                       &tmp, sizeof(tmp));
     return tmp;
 }
 
-uint16_t virtQueueReadAvailFlags(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue)
+uint16_t virtQueueReadAvailFlags(PVIRTIOSTATE pState, PVIRTQ pVirtQ)
 {
     uint16_t tmp;
     PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVirtQueue->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUEAVAIL, fFlags),
+                      pVirtQ->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQ_AVAIL_T, fFlags),
                       &tmp, sizeof(tmp));
     return tmp;
 }
 
-uint16_t virtQueueReadUsedIndex(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue)
+uint16_t virtQueueReadUsedIndex(PVIRTIOSTATE pState, PVIRTQ pVirtQ)
 {
     uint16_t tmp;
     PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVirtQueue->pGcPhysVirtqUsed + RT_UOFFSETOF(VIRTQUEUEUSED, uIdx),
+                      pVirtQ->pGcPhysVirtqUsed + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
                       &tmp, sizeof(tmp));
     return tmp;
 }
 
-void virtQueueWriteUsedIndex(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue, uint16_t u16Value)
+void virtQueueWriteUsedIndex(PVIRTIOSTATE pState, PVIRTQ pVirtQ, uint16_t u16Value)
 {
     PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
-                          pVirtQueue->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUEUSED, uIdx),
+                          pVirtQ->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
                           &u16Value, sizeof(u16Value));
 }
 
-void virtQueueWriteUsedElem(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue, uint32_t idx, uint32_t id, uint32_t uLen)
-{
-
-    RT_NOREF5(pState, pVirtQueue, idx, id, uLen);
+void virtQueueWriteUsedElem(PVIRTIOSTATE pState, PVIRTQ pVirtQ, uint32_t idx, uint32_t id, uint32_t uLen)
+{
+
+    RT_NOREF5(pState, pVirtQ, idx, id, uLen);
     /* PK TODO: Adapt to VirtIO 1.0
-    VIRTQUEUEUSEDELEM elem;
+    VIRTQ_USED_ELEM_T elem;
 
     elem.id = id;
     elem.uLen = uLen;
     PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
-                          pVirtQueue->pGcPhysVirtqUsed + RT_UOFFSETOF_DYN(VIRTQUEUEUSED, ring[idx % pVirtQueue->cbQueue]),
+                          pVirtQ->pGcPhysVirtqUsed + RT_UOFFSETOF_DYN(VIRTQ_USED_T, ring[idx % pVirtQ->cbQueue]),
                           &elem, sizeof(elem));
     */
 }
 
-void virtQueueSetNotification(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue, bool fEnabled)
-{
-    RT_NOREF3(pState, pVirtQueue, fEnabled);
+void virtQueueSetNotification(PVIRTIOSTATE pState, PVIRTQ pVirtQ, bool fEnabled)
+{
+    RT_NOREF3(pState, pVirtQ, fEnabled);
 
 /* PK TODO: Adapt to VirtIO 1.0
@@ -102 +160 @@
 
     PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVirtQueue->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUEUSED, uFlags),
+                      pVirtQ->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQ_USED_T, uFlags),
                       &tmp, sizeof(tmp));
 
     if (fEnabled)
-        tmp &= ~ VIRTQUEUEUSED_F_NO_NOTIFY;
+        tmp &= ~ VIRTQ_USED_T_F_NO_NOTIFY;
     else
-        tmp |= VIRTQUEUEUSED_F_NO_NOTIFY;
+        tmp |= VIRTQ_USED_T_F_NO_NOTIFY;
 
     PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
-                          pVirtQueue->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUEUSED, uFlags),
+                          pVirtQ->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQ_USED_T, uFlags),
                           &tmp, sizeof(tmp));
 */
@@ -145 +203 @@
           QUEUENAME(pState, pQueue), pQueue->uNextAvailIndex));
 
-    VIRTQUEUEDESC desc;
-    uint16_t  idx = virtQueueReadAvail(pState, &pQueue->VirtQueue, pQueue->uNextAvailIndex);
+    VIRTQ_DESC_T desc;
+    uint16_t  idx = virtQueueReadAvail(pState, &pQueue->VirtQ, pQueue->uNextAvailIndex);
     if (fRemove)
         pQueue->uNextAvailIndex++;
@@ -160 +218 @@
         // total number of descriptors in the ring (see @bugref{8620}).
         ///
-        if (pElem->nIn + pElem->nOut >= VIRTQUEUE_MAX_SIZE)
+        if (pElem->nIn + pElem->nOut >= VIRTQ_MAX_SIZE)
         {
             static volatile uint32_t s_cMessages  = 0;
@@ -177 +235 @@
         RT_UNTRUSTED_VALIDATED_FENCE();
 
-        virtQueueReadDesc(pState, &pQueue->VirtQueue, idx, &desc);
-        if (desc.u16Flags & VIRTQUEUEDESC_F_WRITE)
+        virtQueueReadDesc(pState, &pQueue->VirtQ, idx, &desc);
+        if (desc.u16Flags & VIRTQ_DESC_T_F_WRITE)
         {
             Log2(("%s virtQueueGet: %s IN  seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pState),
@@ -196 +254 @@
 
         idx = desc.next;
-    } while (desc.u16Flags & VIRTQUEUEDESC_F_NEXT);
+    } while (desc.u16Flags & VIRTQ_DESC_T_F_NEXT);
 
     Log2(("%s virtQueueGet: %s head_desc_idx=%u nIn=%u nOut=%u\n", INSTANCE(pState),
@@ -261 +319 @@
           " used_idx=%u guest_used_idx=%u id=%u len=%u\n",
           INSTANCE(pState), QUEUENAME(pState, pQueue),
-          pQueue->uNextUsedIndex, virtQueueReadUsedIndex(pState, &pQueue->VirtQueue),
+          pQueue->uNextUsedIndex, virtQueueReadUsedIndex(pState, &pQueue->VirtQ),
           pElem->idx, uTotalLen));
 
-    virtQueueWriteUsedElem(pState, &pQueue->VirtQueue,
+    virtQueueWriteUsedElem(pState, &pQueue->VirtQ,
                        pQueue->uNextUsedIndex++,
                        pElem->idx, uTotalLen);
@@ -279 +337 @@
     LogFlow(("%s virtQueueNotify: %s availFlags=%x guestFeatures=%x virtQueue is %sempty\n",
              INSTANCE(pState), QUEUENAME(pState, pQueue),
-             virtQueueReadAvailFlags(pState, &pQueue->VirtQueue),
+             virtQueueReadAvailFlags(pState, &pQueue->VirtQ),
              pState->uGuestFeatures, virtQueueIsEmpty(pState, pQueue)?"":"not "));
-    if (!(virtQueueReadAvailFlags(pState, &pQueue->VirtQueue) & VIRTQUEUEAVAIL_F_NO_INTERRUPT)
+    if (!(virtQueueReadAvailFlags(pState, &pQueue->VirtQ) & VIRTQ_AVAIL_T_F_NO_INTERRUPT)
         || ((pState->uGuestFeatures & VIRTIO_F_NOTIFY_ON_EMPTY) && virtQueueIsEmpty(pState, pQueue)))
     {
@@ -296 +354 @@
 /* PK TODO Adapt to VirtIO 1.0
     Log2(("%s virtQueueSync: %s old_used_idx=%u new_used_idx=%u\n", INSTANCE(pState),
-          QUEUENAME(pState, pQueue), virtQueueReadUsedIndex(pState, &pQueue->VirtQueue), pQueue->uNextUsedIndex));
-    virtQueueWriteUsedIndex(pState, &pQueue->VirtQueue, pQueue->uNextUsedIndex);
+          QUEUENAME(pState, pQueue), virtQueueReadUsedIndex(pState, &pQueue->VirtQ), pQueue->uNextUsedIndex));
+    virtQueueWriteUsedIndex(pState, &pQueue->VirtQ, pQueue->uNextUsedIndex);
     virtQueueNotify(pState, pQueue);
 */
 }
 
-int virtioReset(PVIRTIOSTATE pVirtio)
-{
-    RT_NOREF(pVirtio);
-/* PK TODO Adapt to VirtIO 1.09
-    pState->uGuestFeatures = 0;
-    pState->uQueueSelector = 0;
-    pState->uStatus        = 0;
-    pState->uISR           = 0;
-
-    for (unsigned i = 0; i < pState->nQueues; i++)
-        virtQueueReset(&pState->Queues[i]);
-*/
-    virtioNotify(pVirtio);
-    return VINF_SUCCESS;
-}
+
 
 /**
@@ -383 +427 @@
  * @param   uPass       The data pass.
  */
-int virtioLoadExec(PVIRTIOSTATE pVirtio, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t nQueues)
-{
-    RT_NOREF5(pVirtio, pSSM, uVersion, uPass, nQueues);
+int virtioLoadExec(PVIRTIOSTATE pVirtio, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t uNumQueues)
+{
+    RT_NOREF5(pVirtio, pSSM, uVersion, uPass, uNumQueues);
     int rc = VINF_SUCCESS;
     virtioDumpState(pVirtio, "virtioLoadExec");
@@ -419 +463 @@
 {
     RT_NOREF(offDelta);
-    VIRTIOSTATE *pState = PDMINS_2_DATA(pDevIns, VIRTIOSTATE*);
-    pState->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    PVIRTIOSTATE pVirtio = *PDMINS_2_DATA(pDevIns, PVIRTIOSTATE *);
+
+    pVirtio->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     // TBD
 }
 
-PVQUEUE virtioAddQueue(VIRTIOSTATE* pState, unsigned cbQueue, PFNVIRTIOQUEUECALLBACK pfnCallback, const char *pcszName)
-{
-
-    RT_NOREF4(pState, cbQueue, pfnCallback, pcszName);
+PVQUEUE virtioAddQueue(VIRTIOSTATE* pState, unsigned cbQueue, const char *pcszName)
+{
+
+    RT_NOREF3(pState, cbQueue, pcszName);
 /* PK TODO Adapt to VirtIO 1.0
 
     PVQUEUE pQueue = NULL;
     // Find an empty queue slot
-    for (unsigned i = 0; i < pState->nQueues; i++)
-    {
-        if (pState->Queues[i].VirtQueue.cbQueue == 0)
+    for (unsigned i = 0; i < pState->uNumQueues; i++)
+    {
+        if (pState->Queues[i].VirtQ.cbQueue == 0)
         {
             pQueue = &pState->Queues[i];
@@ -447 +492 @@
     else
     {
-        pQueue->VirtQueue.cbQueue = cbQueue;
-        pQueue->VirtQueue.addrDescriptors = 0;
+        pQueue->VirtQ.cbQueue = cbQueue;
+        pQueue->VirtQ.addrDescriptors = 0;
         pQueue->uPageNumber = 0;
         pQueue->pfnCallback = pfnCallback;
@@ -459 +504 @@
 
 
+
+__attribute__((unused))
+static void virtQueueInit(PVQUEUE pQueue, uint32_t uPageNumber)
+{
+    RT_NOREF2(pQueue, uPageNumber);
+
+/* PK TODO, re-work this for VirtIO 1.0
+    pQueue->VirtQ.addrDescriptors = (uint64_t)uPageNumber << PAGE_SHIFT;
+
+    pQueue->VirtQ.addrAvail = pQueue->VirtQ.addrDescriptors
+                                + sizeof(VIRTQ_DESC_T) * pQueue->VirtQ.cbQueue;
+
+    pQueue->VirtQ.addrUsed  = RT_ALIGN(pQueue->VirtQ.addrAvail
+            + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, ring[pQueue->VirtQ.cbQueue])
+            + sizeof(uint16_t), // virtio 1.0 adds a 16-bit field following ring data
+              PAGE_SIZE); // The used ring must start from the next page.
+
+    pQueue->uNextAvailIndex       = 0;
+    pQueue->uNextUsedIndex        = 0;
+*/
+
+}
+
+
 __attribute__((unused))
 static void virtQueueReset(PVQUEUE pQueue)
@@ -464 +533 @@
     RT_NOREF(pQueue);
 /* PK TODO Adapt to VirtIO 1.0
-    pQueue->VirtQueue.addrDescriptors = 0;
-    pQueue->VirtQueue.addrAvail       = 0;
-    pQueue->VirtQueue.addrUsed        = 0;
+    pQueue->VirtQ.addrDescriptors = 0;
+    pQueue->VirtQ.addrAvail       = 0;
+    pQueue->VirtQ.addrUsed        = 0;
     pQueue->uNextAvailIndex           = 0;
     pQueue->uNextUsedIndex            = 0;
@@ -473 +542 @@
 }
 
+/**
+ * Notify driver of a configuration or queue event
+ *
+ * @param   pVirtio             - Pointer to instance state
+ * @param   fConfigChange       - True if cfg change notification else, queue notification
+ */
+static void virtioNotifyDriver(VIRTIOHANDLE hVirtio, bool fConfigChange)
+{
+   RT_NOREF(hVirtio);
+   LogFunc(("fConfigChange = %d\n", fConfigChange));
+}
+
+
+int virtioReset(VIRTIOHANDLE hVirtio)  /* Part of our "custom API" */
+{
+    PVIRTIOSTATE pVirtio = H2P(hVirtio);
+
+    RT_NOREF(pVirtio);
+/* PK TODO Adapt to VirtIO 1.09
+    pState->uGuestFeatures = 0;
+    pState->uQueueSelector = 0;
+    pState->uStatus        = 0;
+    pState->uISR           = 0;
+
+    for (unsigned i = 0; i < pState->uNumQueues; i++)
+        virtQueueReset(&pState->Queues[i]);
+    virtioNotify(pVirtio);
+*/
+    return VINF_SUCCESS;
+}
+
 __attribute__((unused))
-static void virtQueueInit(PVQUEUE pQueue, uint32_t uPageNumber)
-{
-    RT_NOREF2(pQueue, uPageNumber);
-
-/* PK TODO, re-work this for VirtIO 1.0
-    pQueue->VirtQueue.addrDescriptors = (uint64_t)uPageNumber << PAGE_SHIFT;
-
-    pQueue->VirtQueue.addrAvail = pQueue->VirtQueue.addrDescriptors
-                                + sizeof(VIRTQUEUEDESC) * pQueue->VirtQueue.cbQueue;
-
-    pQueue->VirtQueue.addrUsed  = RT_ALIGN(pQueue->VirtQueue.addrAvail
-            + RT_UOFFSETOF_DYN(VIRTQUEUEAVAIL, ring[pQueue->VirtQueue.cbQueue])
-            + sizeof(uint16_t), // virtio 1.0 adds a 16-bit field following ring data
-              PAGE_SIZE); // The used ring must start from the next page.
-
-    pQueue->uNextAvailIndex       = 0;
-    pQueue->uNextUsedIndex        = 0;
-*/
-
-}
-
-void virtioNotify(PVIRTIOSTATE pVirtio)
-{
-    RT_NOREF(pVirtio);
+static void virtioSetNeedsReset(PVIRTIOSTATE pVirtio)
+{
+    pVirtio->uDeviceStatus |= VIRTIO_STATUS_DEVICE_NEEDS_RESET;
+    if (pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
+    {
+        pVirtio->fGenUpdatePending = true;
+        virtioNotifyDriver(pVirtio, true);
+    }
 }
 
 static void virtioResetDevice(PVIRTIOSTATE pVirtio)
 {
-    RT_NOREF(pVirtio);
+
     LogFunc(("\n"));
-    pVirtio->uDeviceStatus = 0;
+    pVirtio->uDeviceStatus          = 0;
+    pVirtio->uDeviceFeaturesSelect  = 0;
+    pVirtio->uDriverFeaturesSelect  = 0;
+    pVirtio->uConfigGeneration      = 0;
+    pVirtio->uNumQueues             = VIRTIO_MAX_QUEUES;
+
+    for (uint32_t i = 0; i < pVirtio->uNumQueues; i++)
+    {
+        pVirtio->uQueueSize[i]      = VIRTQ_MAX_SIZE;
+        pVirtio->uQueueNotifyOff[i] = i;
+//      virtqNotify();
+    }
 }
 
@@ -603 +698 @@
         {
             uint32_t uIntraOff = 0;
-            *(uint16_t *)pv = MAX_QUEUES;
+            *(uint16_t *)pv = VIRTIO_MAX_QUEUES;
             LOG_ACCESSOR(uNumQueues);
         }
@@ -696 +791 @@
 {
     RT_NOREF(pvUser);
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE pVirtio = *PDMINS_2_DATA(pDevIns, PVIRTIOSTATE *);
     int rc = VINF_SUCCESS;
 
@@ -710 +805 @@
     {
         uint32_t uDevSpecificDataOffset = GCPhysAddr - pVirtio->pGcPhysDeviceCap;
+        /**
+         * Callback to client to manage device-specific configuration and changes to it.
+         */
         rc = pVirtio->virtioCallbacks.pfnVirtioDevCapRead(pDevIns, uDevSpecificDataOffset, pv, cb);
+        /**
+         * Anytime any part of the device-specific configuration (which our client maintains) is read
+         * it needs to be checked to see if it changed since the last time any part was read, in
+         * order to maintain the config generation (see VirtIO 1.0 spec, section 4.1.4.3.1)
+         */
+        uint32_t fDevSpecificFieldChanged = false;
+
+        if (memcmp((char *)pv + uDevSpecificDataOffset, (char *)pVirtio->pPrevDevSpecificCap + uDevSpecificDataOffset, cb))
+            fDevSpecificFieldChanged = true;
+
+        memcpy(pVirtio->pPrevDevSpecificCap, pv, pVirtio->cbDevSpecificCap);
+        if (pVirtio->fGenUpdatePending || fDevSpecificFieldChanged)
+        {
+            if (fDevSpecificFieldChanged)
+                LogFunc(("Dev specific config field changed since last read, gen++ = %d\n",
+                     pVirtio->uConfigGeneration));
+            else
+                LogFunc(("Config generation pending flag set, gen++ = %d\n",
+                     pVirtio->uConfigGeneration));
+            ++pVirtio->uConfigGeneration;
+            pVirtio->fGenUpdatePending = false;
+        }
     }
     else
@@ -745 +865 @@
 {
     RT_NOREF(pvUser);
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE pVirtio = *PDMINS_2_DATA(pDevIns, PVIRTIOSTATE *);
     int rc = VINF_SUCCESS;
 
@@ -790 +910 @@
 {
     RT_NOREF3(pPciDev, iRegion, enmType);
-    PVIRTIOSTATE  pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE pVirtio = *PDMINS_2_DATA(pDevIns, PVIRTIOSTATE *);
     int rc = VINF_SUCCESS;
 
     Assert(cb >= 32);
 
-    if (iRegion == pVirtio->uVirtioCapRegion)
+    if (iRegion == pVirtio->uVirtioCapBar)
     {
         /* We use the assigned size here, because we currently only support page aligned MMIO ranges. */
@@ -815 +935 @@
         pVirtio->pGcPhysNotifyCap = GCPhysAddress + pVirtio->pNotifyCap->pciCap.uOffset;
         pVirtio->pGcPhysIsrCap    = GCPhysAddress + pVirtio->pIsrCap->uOffset;
-        if (pVirtio->fHaveDevSpecificCap)
+        if (pVirtio->pDevSpecificCap)
             pVirtio->pGcPhysDeviceCap = GCPhysAddress + pVirtio->pDeviceCap->uOffset;
     }
@@ -837 +957 @@
                                        uint32_t uAddress, unsigned cb)
 {
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+//    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE pVirtio = *PDMINS_2_DATA(pDevIns, PVIRTIOSTATE *);
 
     if (uAddress == (uint64_t)&pVirtio->pPciCfgCap->uPciCfgData)
@@ -848 +969 @@
         uint8_t  uBar    = pVirtio->pPciCfgCap->pciCap.uBar;
         uint32_t pv = 0;
-        if (uBar == pVirtio->uVirtioCapRegion)
+        if (uBar == pVirtio->uVirtioCapBar)
             (void)virtioR3MmioRead(pDevIns, NULL, (RTGCPHYS)((uint32_t)pVirtio->GCPhysPciCapBase + uOffset),
                                     &pv, uLength);
@@ -882 +1003 @@
                                         uint32_t uAddress, uint32_t u32Value, unsigned cb)
 {
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE pVirtio = *PDMINS_2_DATA(pDevIns, PVIRTIOSTATE *);
 
     if (uAddress == pVirtio->uPciCfgDataOff)
@@ -892 +1013 @@
         uint32_t uOffset = pVirtio->pPciCfgCap->pciCap.uOffset;
         uint8_t  uBar    = pVirtio->pPciCfgCap->pciCap.uBar;
-        if (uBar == pVirtio->uVirtioCapRegion)
+        if (uBar == pVirtio->uVirtioCapBar)
             (void)virtioR3MmioWrite(pDevIns, NULL, (RTGCPHYS)((uint32_t)pVirtio->GCPhysPciCapBase + uOffset),
                                     (void *)&u32Value, uLength);
@@ -944 +1065 @@
  */
 
-void virtioSetHostFeatures(PVIRTIOSTATE pVirtio, uint64_t uDeviceFeatures)
-{
-    pVirtio->uDeviceFeatures = VIRTIO_F_VERSION_1 | uDeviceFeatures;
+
+void virtioSetHostFeatures(VIRTIOHANDLE hVirtio, uint64_t uDeviceFeatures)
+{
+    H2P(hVirtio)->uDeviceFeatures = VIRTIO_F_VERSION_1 | uDeviceFeatures;
 }
 
@@ -988 +1110 @@
  * @param   pPciParams            Values to populate industry standard PCI Configuration Space data structure
  * @param   pcszNameFmt           Device instance name (format-specifier)
- * @param   nQueues               Number of Virtio Queues created by consumer (driver)
+ * @param   uNumQueues               Number of Virtio Queues created by consumer (driver)
  * @param   uVirtioRegion         Region number to map for PCi Capabilities structs
  * @param   devCapReadCallback    Client function to call back to handle device specific capabilities
@@ -996 +1118 @@
  */
 
-int   virtioConstruct(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, int iInstance, PVIRTIOPCIPARAMS pPciParams,
-                    const char *pcszNameFmt, uint32_t nQueues, uint32_t uVirtioCapRegion,
+int   virtioConstruct(PPDMDEVINS pDevIns, PVIRTIOHANDLE phVirtio, int iInstance, PVIRTIOPCIPARAMS pPciParams,
+                    const char *pcszNameFmt, uint32_t uNumQueues, uint32_t uVirtioCapBar, uint64_t uDeviceFeatures,
                     PFNVIRTIODEVCAPREAD devCapReadCallback, PFNVIRTIODEVCAPWRITE devCapWriteCallback,
-                    uint16_t cbDevSpecificCap, bool fHaveDevSpecificCap,  uint32_t uNotifyOffMultiplier)
-{
-    pVirtio->nQueues = nQueues;
+                    uint16_t cbDevSpecificCap, void *pDevSpecificCap,  uint32_t uNotifyOffMultiplier)
+{
+
+    int rc = VINF_SUCCESS;
+
+    PVIRTIOSTATE pVirtio = (PVIRTIOSTATE)RTMemAlloc(sizeof(VIRTIOSTATE));
+    if (!pVirtio)
+    {
+        PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY, N_("virtio: out of memory"));
+        return VERR_NO_MEMORY;
+    }
+
+
+    pVirtio->uNumQueues = uNumQueues;
     pVirtio->uNotifyOffMultiplier = uNotifyOffMultiplier;
+    pVirtio->uDeviceFeatures = VIRTIO_F_VERSION_1 | uDeviceFeatures;
 
     /* Init handles and log related stuff. */
@@ -1012 +1146 @@
     pVirtio->uDeviceStatus = 0;
     pVirtio->cbDevSpecificCap = cbDevSpecificCap;
-    pVirtio->uVirtioCapRegion = uVirtioCapRegion;
-    pVirtio->fHaveDevSpecificCap = fHaveDevSpecificCap;
+    pVirtio->pDevSpecificCap = pDevSpecificCap;
+    /**
+     * Need to keep a history of this relatively small virtio device-specific
+     * configuration buffer, which is opaque to this encapsulation of the generic
+     * part virtio operations, to track config changes to fields, in order to
+     * update the configuration generation each change. (See VirtIO 1.0 section 4.1.4.3.1)
+     */
+    pVirtio->pPrevDevSpecificCap = RTMemAlloc(cbDevSpecificCap);
+    if (!pVirtio->pPrevDevSpecificCap)
+    {
+        RTMemFree(pVirtio);
+        PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY, N_("virtio: out of memory"));
+        return VERR_NO_MEMORY;
+    }
+    memcpy(pVirtio->pPrevDevSpecificCap, pVirtio->pDevSpecificCap, cbDevSpecificCap);
+    pVirtio->uVirtioCapBar = uVirtioCapBar;
     pVirtio->virtioCallbacks.pfnVirtioDevCapRead = devCapReadCallback;
     pVirtio->virtioCallbacks.pfnVirtioDevCapWrite = devCapWriteCallback;
@@ -1029 +1177 @@
     PCIDevSetInterruptPin      (&pVirtio->dev, pPciParams->uInterruptPin);
 
-    int rc = VINF_SUCCESS;
     /* Register PCI device */
     rc = PDMDevHlpPCIRegister(pDevIns, &pVirtio->dev);
     if (RT_FAILURE(rc))
+    {
+        RTMemFree(pVirtio);
         return PDMDEV_SET_ERROR(pDevIns, rc,
             N_("virtio: cannot register PCI Device")); /* can we put params in this error? */
+    }
 
     pVirtio->IBase = pDevIns->IBase;
-
 
     PDMDevHlpPCISetConfigCallbacks(pDevIns, &pVirtio->dev,
@@ -1050 +1199 @@
     uint8_t fMsiSupport = false;
 #endif
-
 
     /* The following capability mapped via VirtIO 1.0: struct virtio_pci_cfg_cap (VIRTIO_PCI_CFG_CAP_T)
@@ -1068 +1216 @@
     pCfg->uCapLen  = sizeof(VIRTIO_PCI_CAP_T);
     pCfg->uCapNext = CFGADDR2IDX(pCfg) + pCfg->uCapLen;
-    pCfg->uBar     = uVirtioCapRegion;
+    pCfg->uBar     = uVirtioCapBar;
     pCfg->uOffset  = 0;
     pCfg->uLength  = sizeof(VIRTIO_PCI_COMMON_CFG_T);
@@ -1079 +1227 @@
     pCfg->uCapLen  = sizeof(VIRTIO_PCI_NOTIFY_CAP_T);
     pCfg->uCapNext = CFGADDR2IDX(pCfg) + pCfg->uCapLen;
-    pCfg->uBar     = uVirtioCapRegion;
+    pCfg->uBar     = uVirtioCapBar;
     pCfg->uOffset  = pVirtio->pCommonCfgCap->uOffset + pVirtio->pCommonCfgCap->uLength;
     pCfg->uLength  = 4; /* This needs to be calculated differently */
@@ -1091 +1239 @@
     pCfg->uCapLen  = sizeof(VIRTIO_PCI_CAP_T);
     pCfg->uCapNext = CFGADDR2IDX(pCfg) + pCfg->uCapLen;
-    pCfg->uBar     = uVirtioCapRegion;
+    pCfg->uBar     = uVirtioCapBar;
     pCfg->uOffset  = pVirtio->pNotifyCap->pciCap.uOffset + pVirtio->pNotifyCap->pciCap.uLength;
     pCfg->uLength  = sizeof(uint32_t);
@@ -1101 +1249 @@
     pCfg->uCapVndr = VIRTIO_PCI_CAP_ID_VENDOR;
     pCfg->uCapLen  = sizeof(VIRTIO_PCI_CFG_CAP_T);
-    pCfg->uCapNext = (fMsiSupport || pVirtio->fHaveDevSpecificCap) ? CFGADDR2IDX(pCfg) + pCfg->uCapLen : 0;
-    pCfg->uBar     = uVirtioCapRegion;
+    pCfg->uCapNext = (fMsiSupport || pVirtio->pDevSpecificCap) ? CFGADDR2IDX(pCfg) + pCfg->uCapLen : 0;
+    pCfg->uBar     = uVirtioCapBar;
     pCfg->uOffset  = pVirtio->pIsrCap->uOffset + pVirtio->pIsrCap->uLength;
     pCfg->uLength  = 4;  /* Initialize a non-zero 4-byte aligned so Linux virtio_pci module recognizes this cap */
     pVirtio->pPciCfgCap = (PVIRTIO_PCI_CFG_CAP_T)pCfg;
 
-    if (pVirtio->fHaveDevSpecificCap)
+    if (pVirtio->pDevSpecificCap)
     {
         /* Following capability mapped via VirtIO 1.0: struct virtio_pci_dev_cap (VIRTIODEVCAP)*/
@@ -1115 +1263 @@
         pCfg->uCapLen  = sizeof(VIRTIO_PCI_CAP_T);
         pCfg->uCapNext = fMsiSupport ? CFGADDR2IDX(pCfg) + pCfg->uCapLen : 0;
-        pCfg->uBar     = uVirtioCapRegion;
+        pCfg->uBar     = uVirtioCapBar;
         pCfg->uOffset  = pVirtio->pIsrCap->uOffset + pVirtio->pIsrCap->uLength;
         pCfg->uLength  = cbDevSpecificCap;
@@ -1139 +1287 @@
     }
 
-    rc = PDMDevHlpPCIIORegionRegister(pDevIns, uVirtioCapRegion, 4096,
+    rc = PDMDevHlpPCIIORegionRegister(pDevIns, uVirtioCapBar, 4096,
                                       PCI_ADDRESS_SPACE_MEM, virtioR3Map);
     if (RT_FAILURE(rc))
+    {
+        RTMemFree(pVirtio->pPrevDevSpecificCap);
+        RTMemFree(pVirtio);
         return PDMDEV_SET_ERROR(pDevIns, rc,
             N_("virtio: cannot register PCI Capabilities address space"));
-
+    }
+    *phVirtio = (PVIRTIOHANDLE)pVirtio;
     return rc;
 }
-
 #endif /* IN_RING3 */
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * Virtio_1_0p .h - Virtio Declarations
+ * Virtio_1_0.h - Virtio Declarations
  */
 
@@ -24 +24 @@
 #include <iprt/ctype.h>
 
-/** @name Saved state versions.
- * The saved state version is changed if either common or any of specific
- * parts are changed. That is, it is perfectly possible that the version
- * of saved vnet state will increase as a result of change in vblk structure
- * for example.
- */
-#define VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1 1
-#define VIRTIO_SAVEDSTATE_VERSION           2
-/** @} */
+#define VIRTQ_MAX_SIZE                      1024
+#define VIRTIO_MAX_QUEUES                   256     /** Max queues we allow guest to create      */
+#define VIRTQ_DESC_MAX_SIZE                 (2 * 1024 * 1024)
+
+typedef void * VIRTIOHANDLE;                        /** opaque handle to the VirtIO framework */
+typedef VIRTIOHANDLE *PVIRTIOHANDLE;
 
 /** Reserved Feature Bits */
@@ -39 +36 @@
 #define VIRTIO_F_VERSION_1                  RT_BIT_64(32)
 
-#define MAX_QUEUES                          5       /** Maximum number of queues we support     */
-
-/** Mandatory for Virtio PCI device identification, per spec */
-#define DEVICE_PCI_VENDOR_ID_VIRTIO         0x1AF4
-
-/** Virtio spec suggests >= 1 for non-transitional drivers */
-#define DEVICE_PCI_REVISION_ID_VIRTIO       1
-
-/* Virtio Device PCI Capabilities type codes */
-#define VIRTIO_PCI_CAP_COMMON_CFG           1
-#define VIRTIO_PCI_CAP_NOTIFY_CFG           2
-#define VIRTIO_PCI_CAP_ISR_CFG              3
-#define VIRTIO_PCI_CAP_DEVICE_CFG           4
-#define VIRTIO_PCI_CAP_PCI_CFG              5
+#define VIRTIO_MSI_NO_VECTOR                0xffff  /* Vector value used to disable MSI for queue */
 
 /** Device Status field constants (from Virtio 1.0 spec) */
@@ -62 +46 @@
 #define VIRTIO_STATUS_DEVICE_NEEDS_RESET    0x40    /** Device experienced unrecoverable error   */
 
-#define VIRTIO_MAX_NQUEUES                  256     /** Max queues we allow guest to create      */
-#define VIRTQUEUEDESC_MAX_SIZE              (2 * 1024 * 1024)   /** Legacy only? */
-#define VIRTQUEUE_MAX_SIZE                  1024    /** According to? Legacy only? */
-#define VIRTIO_ISR_QUEUE                    0x1     /* Legacy only? Now derived from feature negotiation? */
-#define VIRTIO_ISR_CONFIG                   0x3     /* Legacy only? Now derived from feature negotiation? */
-
-#define VIRTIO_PCI_CAP_ID_VENDOR            0x09
-
-/* Vector value used to disable MSI for queue */
-#define VIRTIO_MSI_NO_VECTOR                0xffff
-
-/** Most of the following definitions attempt to adhere to the names and
- *  and forms used by the VirtIO 1.0 specification to increase the maintainability
- *  and speed of ramp-up, in other words, to as unambiguously as possible
- *  map the spec to the VirtualBox implementation of it */
-
-/** Indicates that this descriptor chains to another */
-#define VIRTQ_DESC_F_NEXT                   1
-
-/** Marks buffer as write-only (default ro) */
-#define VIRTQ_DESC_F_WRITE                  2
-
-/** This means the buffer contains a list of buffer descriptors. */
-#define VIRTQ_DESC_F_INDIRECT               4
-
-/** Optimization: Device advises driver (unreliably):  Don't kick me when adding buffer */
-#define VIRTQ_USED_F_NO_NOTIFY              1
-
-/** Optimization: Driver advises device (unreliably): Don't interrupt when buffer consumed */
-#define VIRTQ_AVAIL_F_NO_INTERRUPT          1
-
-/** Using indirect descriptors */
-#define VIRTIO_F_INDIRECT_DESC              28
-
-/** Indicates either avail_event, or used_event fields are in play */
-#define VIRTIO_F_EVENT_IDX                  29
-
-/** Allow aribtary descriptor layouts */
-#define VIRTIO_F_ANY_LAYOUT                 27
-
+/** virtq related flags */
+#define VIRTQ_DESC_F_NEXT                   1       /** Indicates this descriptor chains to next */
+#define VIRTQ_DESC_F_WRITE                  2       /** Marks buffer as write-only (default ro)  */
+#define VIRTQ_DESC_F_INDIRECT               4       /** Buffer is list of buffer descriptors     */
+#define VIRTIO_F_INDIRECT_DESC              28      /** Using indirect descriptors               */
+#define VIRTIO_F_EVENT_IDX                  29      /** avail_event, used_event in play          */
+
+#define VIRTQ_USED_F_NO_NOTIFY              1       /** Optimization: Device advises driver (unreliably):
+                                                        Don't kick me when adding buffer */
+
+#define VIRTQ_AVAIL_F_NO_INTERRUPT          1       /** Optimization: Driver advises device (unreliably):
+                                                        Don't interrupt when buffer consumed */
+/**
+ * virtq related structs
+ *  (struct names follow VirtIO 1.0 spec, typedef use VBox style)
+ */
+typedef struct virtq_desc
+{
+    uint64_t  pGcPhysBuf;                   /** addr        GC physical address of buffer   */
+    uint32_t  cbBuf;                        /** len         Buffer length                   */
+    uint16_t  fFlags;                       /** flags       Buffer specific flags           */
+    uint16_t  uNext;                        /** next        Chain idx if VIRTIO_DESC_F_NEXT */
+} VIRTQ_DESC_T, *PVIRTQ_DESC_T;
+
+typedef struct virtq_avail  /* VirtIO 1.0 specification formal name of this struct    */
+{
+    uint16_t  fFlags;                       /** flags       avail ring guest-to-host flags */
+    uint16_t  uIdx;                         /** idx         Index of next free ring slot    */
+    uint16_t  auRing[1];                    /** ring        Ring: avail guest-to-host bufs  */
+    uint16_t  uUsedEventIdx;                /** used_event  (if VIRTQ_USED_F_NO_NOTIFY)     */
+} VIRTQ_AVAIL_T, *PVIRTQ_AVAIL_T;
+
+typedef struct virtq_used_elem /* VirtIO 1.0 specification formal name of this struct */
+{
+    uint32_t  uIdx;                         /** idx         Start of used descriptor chain  */
+    uint32_t  cbElem;                       /** len         Total len of used desc chain    */
+} VIRTQ_USED_ELEM_T;
+
+typedef struct virt_used  /* VirtIO 1.0 specification formal name of this struct */
+{
+    uint16_t  fFlags;                       /** flags       used ring host-to-guest flags  */
+    uint16_t  uIdx;                         /** idx         Index of next ring slot        */
+    VIRTQ_USED_ELEM_T aRing[1];             /** ring        Ring: used host-to-guest bufs  */
+    uint16_t  uAvailEventIdx;               /** avail_event if (VIRTQ_USED_F_NO_NOTIFY)    */
+} VIRTQ_USED_T, *PVIRTQ_USED_T;
+
+
+typedef struct virtq
+{
+    uint16_t cbQueue;                       /** virtq size                                 */
+    uint16_t padding[3];                    /** 64-bit-align phys ptrs to start of struct  */
+    RTGCPHYS pGcPhysVirtqDescriptors;       /** (struct virtq_desc  *)                     */
+    RTGCPHYS pGcPhysVirtqAvail;             /** (struct virtq_avail *)                     */
+    RTGCPHYS pGcPhysVirtqUsed;              /** (struct virtq_used  *)                     */
+} VIRTQ, *PVIRTQ;
+
+typedef struct VQueue
+{
+    VIRTQ VirtQ;
+    uint16_t  uNextAvailIndex;
+    uint16_t  uNextUsedIndex;
+    uint32_t  uPageNumber;
+    R3PTRTYPE(const char *) pcszName;
+} VQUEUE;
+
+
+typedef VQUEUE *PVQUEUE;
+
+typedef struct VQueueElemSeg
+{
+    RTGCPHYS addr;
+    void    *pv;
+    uint32_t cb;
+} VQUEUESEG;
+
+typedef struct VQueueElem
+{
+    uint32_t  idx;
+    uint32_t  cSegsIn;
+    uint32_t  cSegsOut;
+    VQUEUESEG aSegsIn[VIRTQ_MAX_SIZE];
+    VQUEUESEG aSegsOut[VIRTQ_MAX_SIZE];
+} VQUEUEELEM;
+typedef VQUEUEELEM *PVQUEUEELEM;
+
+/**
+ * The following structure is used to pass the PCI parameters from the consumer
+ * to this generic VirtIO framework
+ */
 typedef struct VIRTIOPCIPARAMS
 {
@@ -115 +148 @@
 } VIRTIOPCIPARAMS, *PVIRTIOPCIPARAMS;
 
-typedef struct virtio_pci_cap
-{
-    /* All little-endian */
-    uint8_t   uCapVndr;               /** Generic PCI field: PCI_CAP_ID_VNDR          */
-    uint8_t   uCapNext;               /** Generic PCI field: next ptr.                */
-    uint8_t   uCapLen;                /** Generic PCI field: capability length        */
-    uint8_t   uCfgType;               /** Identifies the structure.                   */
-    uint8_t   uBar;                   /** Where to find it.                           */
-    uint8_t   uPadding[3];            /** Pad to full dword.                          */
-    uint32_t  uOffset;                /** Offset within bar.  (L.E.)                  */
-    uint32_t  uLength;                /** Length of struct, in bytes. (L.E.)          */
-}  VIRTIO_PCI_CAP_T, *PVIRTIO_PCI_CAP_T;
-
-typedef struct virtio_pci_common_cfg /* VirtIO 1.0 specification name of this struct  */
-{
-    /**
-     *
-     * RW = driver (guest) writes value into this field.
-     * RO = device (host)  writes value into this field.
-     */
-
-    /* Per device fields */
-    uint32_t  uDeviceFeaturesSelect;   /** RW (driver selects device features)         */
-    uint32_t  uDeviceFeatures;         /** RO (device reports features to driver)      */
-    uint32_t  uDriverFeaturesSelect;   /** RW (driver selects driver features)         */
-    uint32_t  uDriverFeatures;         /** RW (driver accepts device features)         */
-    uint16_t  uMsixConfig;            /** RW (driver sets MSI-X config vector)        */
-    uint16_t  uNumQueues;             /** RO (device specifies max queues)            */
-    uint8_t   uDeviceStatus;          /** RW (driver writes device status, 0 resets)  */
-    uint8_t   uConfigGeneration;      /** RO (device changes when changing configs)   */
-
-    /* Per virtqueue fields (as determined by uQueueSelect) */
-    uint16_t  uQueueSelect;           /** RW (selects queue focus for these fields)   */
-    uint16_t  uQueueSize;             /** RW (queue size, 0 - 2^n)                    */
-    uint16_t  uQueueMsixVector;       /** RW (driver selects MSI-X queue vector)      */
-    uint16_t  uQueueEnable;           /** RW (driver controls usability of queue)     */
-    uint16_t  uQueueNotifyOff;        /** RO (offset uto virtqueue; see spec)         */
-    uint64_t  uQueueDesc;             /** RW (driver writes desc table phys addr)     */
-    uint64_t  uQueueAvail;            /** RW (driver writes avail ring phys addr)     */
-    uint64_t  uQueueUsed;             /** RW (driver writes used ring  phys addr)     */
-} VIRTIO_PCI_COMMON_CFG_T, *PVIRTIO_PCI_COMMON_CFG_T;
-
-/* The following two types are opaque here. The device-specific capabilities are handled
- * through a callback to the consumer host device driver, where the corresponding
- * struct is declared, since it cannot be defined in the host-generic section of
- * the VirtIO specification. */
-
-typedef void * PVIRTIO_PCI_DEVICE_CAP_T;
-typedef struct virtio_pci_device_cap
-{
-} VIRTIO_PCI_DEVICE_CAP_T;
-
-typedef struct virtio_pci_notify_cap
-{
-        struct virtio_pci_cap pciCap;
-        uint32_t uNotifyOffMultiplier; /* notify_off_multiplier                        */
-} VIRTIO_PCI_NOTIFY_CAP_T, *PVIRTIO_PCI_NOTIFY_CAP_T;
-
-/*
- * If the client of this library has any device-specific capabilities, it must define
- * and implement this struct and the macro
- */
-typedef struct virtio_pci_cfg_cap {
-        struct virtio_pci_cap pciCap;
-        uint8_t uPciCfgData[4]; /* Data for BAR access. */
-} VIRTIO_PCI_CFG_CAP_T, *PVIRTIO_PCI_CFG_CAP_T;
-
-typedef struct virtq_desc  /* VirtIO 1.0 specification formal name of this struct     */
-{
-    uint64_t  pGcPhysBuf;             /** addr        GC physical address of buffer   */
-    uint32_t  cbBuf;                  /** len         Buffer length                   */
-    uint16_t  fFlags;                 /** flags       Buffer specific flags           */
-    uint16_t  uNext;                  /** next        Chain idx if VIRTIO_DESC_F_NEXT */
-} VIRTQUEUEDESC, *PVIRTQUEUEDESC;
-
-typedef struct virtq_avail  /* VirtIO 1.0 specification formal name of this struct    */
-{
-    uint16_t  fFlags;                 /** flags       avail ring guest-to-host flags */
-    uint16_t  uIdx;                   /** idx         Index of next free ring slot    */
-    uint16_t  auRing[1];              /** ring        Ring: avail guest-to-host bufs  */
-    uint16_t  uUsedEventIdx;          /** used_event  (if VIRTQ_USED_F_NO_NOTIFY)     */
-} VIRTQUEUEAVAIL, *PVIRTQUEUEAVAIL;
-
-typedef struct virtq_used_elem /* VirtIO 1.0 specification formal name of this struct */
-{
-    uint32_t  uIdx;                   /** idx         Start of used descriptor chain  */
-    uint32_t  cbElem;                 /** len         Total len of used desc chain    */
-} VIRTQUEUEUSEDELEM;
-
-typedef struct virt_used  /* VirtIO 1.0 specification formal name of this struct */
-{
-    uint16_t  fFlags;                 /** flags       used ring host-to-guest flags  */
-    uint16_t  uIdx;                   /** idx         Index of next ring slot        */
-    VIRTQUEUEUSEDELEM aRing[1];       /** ring        Ring: used host-to-guest bufs  */
-    uint16_t  uAvailEventIdx;         /** avail_event if (VIRTQ_USED_F_NO_NOTIFY)    */
-} VIRTQUEUEUSED, *PVIRTQUEUEUSED;
-
-
-typedef struct virtq
-{
-    uint16_t cbQueue;                 /** virtq size                                 */
-    uint16_t padding[3];              /** 64-bit-align phys ptrs to start of struct  */
-    RTGCPHYS pGcPhysVirtqDescriptors; /** (struct virtq_desc  *)                     */
-    RTGCPHYS pGcPhysVirtqAvail;       /** (struct virtq_avail *)                     */
-    RTGCPHYS pGcPhysVirtqUsed;        /** (struct virtq_used  *)                     */
-} VIRTQUEUE, *PVIRTQUEUE;
-
-/**
- * Queue callback (consumer?).
- *
- * @param   pvState         Pointer to the VirtIO PCI core state, VIRTIOSTATE.
- * @param   pQueue          Pointer to the queue structure.
- */
-typedef DECLCALLBACK(void) FNVIRTIOQUEUECALLBACK(void *pvState, struct VQueue *pQueue);
-/** Pointer to a VQUEUE callback function. */
-typedef FNVIRTIOQUEUECALLBACK *PFNVIRTIOQUEUECALLBACK;
-
-//PCIDevGetCapabilityList
-//PCIDevSetCapabilityList
-//DECLINLINE(void) PDMPciDevSetCapabilityList(PPDMPCIDEV pPciDev, uint8_t u8Offset)
-//    PDMPciDevSetByte(pPciDev, VBOX_PCI_CAPABILITY_LIST, u8Offset);
-//DECLINLINE(uint8_t) PDMPciDevGetCapabilityList(PPDMPCIDEV pPciDev)
-//    return PDMPciDevGetByte(pPciDev, VBOX_PCI_CAPABILITY_LIST);
-
-typedef struct VQueue
-{
-    VIRTQUEUE    VirtQueue;
-    uint16_t uNextAvailIndex;
-    uint16_t uNextUsedIndex;
-    uint32_t uPageNumber;
-    R3PTRTYPE(PFNVIRTIOQUEUECALLBACK) pfnCallback;
-    R3PTRTYPE(const char *)           pcszName;
-} VQUEUE;
-typedef VQUEUE *PVQUEUE;
-
-typedef struct VQueueElemSeg
-{
-    RTGCPHYS addr;
-    void    *pv;
-    uint32_t cb;
-} VQUEUESEG;
-
-typedef struct VQueueElem
-{
-    uint32_t  idx;
-    uint32_t  nIn;
-    uint32_t  nOut;
-    VQUEUESEG aSegsIn[VIRTQUEUE_MAX_SIZE];
-    VQUEUESEG aSegsOut[VIRTQUEUE_MAX_SIZE];
-} VQUEUEELEM;
-typedef VQUEUEELEM *PVQUEUEELEM;
-
-
-/**
- * Interface this library uses to let the client handle VirtioIO device-specific capabilities I/O
- */
-
  /**
  * VirtIO Device-specific capabilities read callback
@@ -304 +180 @@
      DECLCALLBACKMEMBER(int,      pfnVirtioDevCapWrite)
                                       (PPDMDEVINS pDevIns, uint32_t uOffset, const void *pvBuf, size_t cbWrite);
-} VIRTIOCALLBACKS, *PVIRTALCALLBACKS;
+} VIRTIOCALLBACKS, *PVIRTIOCALLBACKS;
 /** @} */
 
-/**
- * The core (/common) state of the VirtIO PCI device
- *
- * @implements  PDMILEDPORTS
- */
-typedef struct VIRTIOSTATE
-{
-    PDMPCIDEV                    dev;
-    PDMCRITSECT                  cs;                     /**< Critical section - what is it protecting? */
-    /* Read-only part, never changes after initialization. */
-    char                         szInstance[8];          /**< Instance name, e.g. VNet#1. */
-
-#if HC_ARCH_BITS != 64
-    uint32_t                     padding1;
-#endif
-
-    /** Status LUN: Base interface. */
-    PDMIBASE                     IBase;
-
-    /** Status LUN: LED port interface. */
-    PDMILEDPORTS                 ILed;
-
-    /* Read/write part, protected with critical section. */
-    /** Status LED. */
-    PDMLED                       led;
-
-    VIRTIOCALLBACKS              virtioCallbacks;
-
-    /** Status LUN: LED connector (peer). */
-    R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
-
-    PPDMDEVINSR3                 pDevInsR3;              /**< Device instance - R3. */
-    PPDMDEVINSR0                 pDevInsR0;              /**< Device instance - R0. */
-    PPDMDEVINSRC                 pDevInsRC;              /**< Device instance - RC. */
-
-
-    uint8_t                      uPciCfgDataOff;
-#if HC_ARCH_BITS == 64
-    uint32_t                     padding2;
-#endif
-
-    /** Base port of I/O space region. */
-    RTIOPORT                     IOPortBase;
-
-    uint32_t                     uGuestFeatures;
-    uint16_t                     uQueueSelector;             /** An index in aQueues array. */
-    uint8_t                      uStatus;                    /** Device Status (bits are device-specific). */
-    uint8_t                      uISR;                       /** Interrupt Status Register. */
-
-#if HC_ARCH_BITS != 64
-    uint32_t                     padding3;
-#endif
-
-    uint32_t                     nQueues;                    /** Actual number of queues used. */
-    VQUEUE                       Queues[VIRTIO_MAX_NQUEUES];
-
-    uint32_t                     uDeviceFeaturesSelect;     /** Select hi/lo 32-bit uDeviceFeatures to r/w */
-    uint64_t                     uDeviceFeatures;           /** Host features offered */
-    uint32_t                     uDriverFeaturesSelect;     /** Selects hi/lo 32-bit uDriverFeatures to r/w*/
-    uint64_t                     uDriverFeatures;           /** Host features accepted by guest */
-
-    uint32_t                     uMsixConfig;
-    uint8_t                      uDeviceStatus;
-    uint8_t                      uConfigGeneration;
-    uint32_t                     uNotifyOffMultiplier;       /* Multiplier for uQueueNotifyOff[idx] */
-
-    uint16_t                     uQueueSelect;
-    uint16_t                     uQueueSize[MAX_QUEUES];
-    uint16_t                     uQueueMsixVector[MAX_QUEUES];
-    uint16_t                     uQueueEnable[MAX_QUEUES];
-    uint16_t                     uQueueNotifyOff[MAX_QUEUES];
-    uint64_t                     uQueueDesc[MAX_QUEUES];
-    uint64_t                     uQueueAvail[MAX_QUEUES];
-    uint64_t                     uQueueUsed[MAX_QUEUES];
-
-
-    uint8_t                      uVirtioCapRegion;      /* Client assigned  Virtio dedicated capabilities region*/
-
-    /** Callbacks when guest driver reads or writes VirtIO device-specific capabilities(s) */
-    PFNPCICONFIGREAD             pfnPciConfigReadOld;
-    PFNPCICONFIGWRITE            pfnPciConfigWriteOld;
-
-    bool                         fHaveDevSpecificCap;
-    uint32_t                     cbDevSpecificCap;
-
-    PVIRTIO_PCI_CFG_CAP_T        pPciCfgCap;            /** Pointer to struct in configuration area */
-    PVIRTIO_PCI_NOTIFY_CAP_T     pNotifyCap;            /** Pointer to struct in configuration area */
-    PVIRTIO_PCI_CAP_T            pCommonCfgCap;         /** Pointer to struct in configuration area */
-    PVIRTIO_PCI_CAP_T            pIsrCap;               /** Pointer to struct in configuration area */
-    PVIRTIO_PCI_CAP_T            pDeviceCap;            /** Pointer to struct in configuration area */
-
-    /** Base address of PCI capabilities */
-    RTGCPHYS                     GCPhysPciCapBase;
-    RTGCPHYS                     pGcPhysCommonCfg;      /** Pointer to MMIO mapped capability data */
-    RTGCPHYS                     pGcPhysNotifyCap;      /** Pointer to MMIO mapped capability data */
-    RTGCPHYS                     pGcPhysIsrCap;         /** Pointer to MMIO mapped capability data */
-    RTGCPHYS                     pGcPhysDeviceCap;      /** Pointer to MMIO mapped capability data */
-
-    bool fDeviceConfigInterrupt;
-    bool fQueueInterrupt;
-
-} VIRTIOSTATE, *PVIRTIOSTATE;
-
-void    virtioRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta);
-void   *virtioQueryInterface(struct PDMIBASE *pInterface, const char *pszIID);
-
-int     virtioConstruct(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, int iInstance, PVIRTIOPCIPARAMS pPciParams,
-                    const char *pcszNameFmt, uint32_t nQueues, uint32_t uVirtioCapRegion,
-                    PFNVIRTIODEVCAPREAD devCapReadCallback, PFNVIRTIODEVCAPWRITE devCapWriteCallback,
-                    uint16_t cbDevSpecificCap, bool fHaveDevSpecificCap, uint32_t uNotifyOffMultiplier);
-
-int     virtioDestruct(PVIRTIOSTATE pVirtio);
-int     virtioReset(PVIRTIOSTATE pVirtio);
-int     virtioSaveExec(PVIRTIOSTATE pVirtio, PSSMHANDLE pSSM);
-int     virtioLoadExec(PVIRTIOSTATE pVirtio, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t nQueues);
-void    virtioSetReadLed(PVIRTIOSTATE pVirtio, bool fOn);
-void    virtioSetWriteLed(PVIRTIOSTATE pVirtio, bool fOn);
-int     virtioRaiseInterrupt(PVIRTIOSTATE pVirtio, int rcBusy, uint8_t uint8_tIntCause);
-void    virtioNotify(PVIRTIOSTATE pVirtio);
-void    virtioSetHostFeatures(PVIRTIOSTATE pVirtio, uint64_t uDeviceFeatures);
-
-PVQUEUE virtioAddQueue(PVIRTIOSTATE pVirtio, unsigned uSize, PFNVIRTIOQUEUECALLBACK pfnCallback, const char *pcszName);
-bool    virtQueueSkip(PVIRTIOSTATE pVirtio, PVQUEUE pQueue);
-bool    virtQueueGet(PVIRTIOSTATE pVirtio, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove = true);
-void    virtQueuePut(PVIRTIOSTATE pVirtio, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t len, uint32_t uReserved = 0);
-void    virtQueueNotify(PVIRTIOSTATE pVirtio, PVQUEUE pQueue);
-void    virtQueueSync(PVIRTIOSTATE pVirtio, PVQUEUE pQueue);
-void    vringSetNotification( PVIRTIOSTATE pVirtio, PVIRTQUEUE pVirtQueue, bool fEnabled);
-
-
-/*  FROM Virtio 1.0 SPEC, NYI
-      static inline int virtq_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old_idx)
-            return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old_idx);
-      }
-      // Get location of event indices (only with VIRTIO_F_EVENT_IDX)
-      static inline le16 *virtq_used_event(struct virtq *vq)
-      {
-              // For backwards compat, used event index is at *end* of avail ring.
-              return &vq->avail->ring[vq->num];
-}
-      static inline le16 *virtq_avail_event(struct virtq *vq)
-      {
-              // For backwards compat, avail event index is at *end* of used ring.
-              return (le16 *)&vq->used->ring[vq->num];
-      }
-}
-*/
-
-
+PVQUEUE virtioAddQueue(         VIRTIOHANDLE hVirtio, uint32_t uSize, const char *pcszName);
+int     virtioDestruct(         VIRTIOHANDLE hVirtio);
+int     virtioReset(            VIRTIOHANDLE hVirtio);
+void    virtioSetReadLed(       VIRTIOHANDLE hVirtio, bool fOn);
+void    virtioSetWriteLed(      VIRTIOHANDLE hVirtio, bool fOn);
+int     virtioRaiseInterrupt(   VIRTIOHANDLE hVirtio, int rcBusy, uint8_t uint8_tIntCause);
+//void    virtioNotifyDriver(     VIRTIOHANDLE hVirtio);
+void    virtioSetHostFeatures(  VIRTIOHANDLE hVirtio, uint64_t uDeviceFeatures);
+
+bool    virtQueueSkip(          VIRTIOHANDLE hVirtio, PVQUEUE pQueue);
+bool    virtQueueGet(           VIRTIOHANDLE hVirtio, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove = true);
+void    virtQueuePut(           VIRTIOHANDLE hVirtio, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t len, uint32_t uReserved = 0);
+void    virtQueueNotify(        VIRTIOHANDLE hVirtio, PVQUEUE pQueue);
+void    virtQueueSync(          VIRTIOHANDLE hVirtio, PVQUEUE pQueue);
+void    vringSetNotification(   VIRTIOHANDLE hVirtio, PVIRTQ pVirtQ, bool fEnabled);
 
 /**
@@ -469 +211 @@
  * @param   idx         - The index if fHasIndex
  */
-DECLINLINE(void) virtioLogMappedIoValue(const char *pszFunc, const char *pszMember, const void *pv, uint32_t cb,
-                        uint32_t uOffset, bool fWrite, bool fHasIndex, uint32_t idx)
-{
-
-#define FMTHEX(fmtout, v, cNybs) \
-    fmtout[cNybs] = '\0'; \
-    for (uint8_t i = 0; i < cNybs; i++) \
-        fmtout[(cNybs - i) -1] = "0123456789abcdef"[(val >> (i * 4)) & 0xf];
-
-#define MAX_STRING   64
-    char pszIdx[MAX_STRING] = { 0 };
-    char pszDepiction[MAX_STRING] = { 0 };
-    char pszFormattedVal[MAX_STRING] = { 0 };
-    if (fHasIndex)
-        RTStrPrintf(pszIdx, sizeof(pszIdx), "[%d]", idx);
-    if (cb == 1 || cb == 2 || cb == 4 || cb == 8)
-    {
-        /* manually padding with 0's instead of \b due to different impl of %x precision than printf() */
-        uint64_t val = 0;
-        memcpy((char *)&val, pv, cb);
-        FMTHEX(pszFormattedVal, val, cb * 2);
-        if (uOffset != 0) /* display bounds if partial member access */
-            RTStrPrintf(pszDepiction, sizeof(pszDepiction), "%s%s[%d:%d]", pszMember, pszIdx, uOffset, uOffset + cb - 1);
-        else
-            RTStrPrintf(pszDepiction, sizeof(pszDepiction), "%s%s", pszMember, pszIdx);
-        RTStrPrintf(pszDepiction, sizeof(pszDepiction), "%-30s", pszDepiction);
-        int first = 0;
-        for (uint8_t i = 0; i < sizeof(pszDepiction); i++)
-            if (pszDepiction[i] == ' ' && first++ != 0)
-                pszDepiction[i] = '.';
-        Log(("%s: Guest %s %s 0x%s\n", \
-                  pszFunc, fWrite ? "wrote" : "read ", pszDepiction, pszFormattedVal));
-    }
-    else /* odd number or oversized access, ... log inline hex-dump style */
-    {
-        Log(("%s: Guest %s %s%s[%d:%d]: %.*Rhxs\n", \
-              pszFunc, fWrite ? "wrote" : "read ", pszMember,
-              pszIdx, uOffset, uOffset + cb, cb, pv));
-    }
-}
-
-typedef DECLCALLBACK(uint32_t) FNGETHOSTFEATURES(void *pvState);
-typedef FNGETHOSTFEATURES *PFNGETHOSTFEATURES;
-
-DECLINLINE(uint16_t) vringReadAvail(PVIRTIOSTATE pState, PVIRTQUEUE pVirtQueue)
-{
-    uint16_t dataWord;
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVirtQueue->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUEAVAIL, uIdx),
-                      &dataWord, sizeof(dataWord));
-    return dataWord;
-}
-
-DECLINLINE(bool) virtQueuePeek(PVIRTIOSTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem)
-{
-    return virtQueueGet(pState, pQueue, pElem, /* fRemove */ false);
-}
-
-DECLINLINE(bool) virtQueueIsReady(PVIRTIOSTATE pState, PVQUEUE pQueue)
-{
-    NOREF(pState);
-    return !!pQueue->VirtQueue.pGcPhysVirtqAvail;
-}
-
-DECLINLINE(bool) virtQueueIsEmpty(PVIRTIOSTATE pState, PVQUEUE pQueue)
-{
-    return (vringReadAvail(pState, &pQueue->VirtQueue) == pQueue->uNextAvailIndex);
-}
+void virtioLogMappedIoValue(const char *pszFunc, const char *pszMember,
+                            const void *pv, uint32_t cb, uint32_t uOffset,
+                            bool fWrite, bool fHasIndex, uint32_t idx);
+
+int     virtioConstruct(
+            PPDMDEVINS           pDevIns,
+            PVIRTIOHANDLE        phVirtio,
+            int                  iInstance,
+            PVIRTIOPCIPARAMS     pPciParams,
+            const char           *pcszNameFmt,
+            uint32_t             nQueues,
+            uint32_t             uVirtioCapBar,
+            uint64_t             uDeviceFeatures,
+            PFNVIRTIODEVCAPREAD  devCapReadCallback,
+            PFNVIRTIODEVCAPWRITE devCapWriteCallback,
+            uint16_t             cbDevSpecificCap,
+            void                 *pDevSpecificCap,
+            uint32_t             uNotifyOffMultiplier);
+
+//PCIDevGetCapabilityList
+//PCIDevSetCapabilityList
+//DECLINLINE(void) PDMPciDevSetCapabilityList(PPDMPCIDEV pPciDev, uint8_t u8Offset)
+//    PDMPciDevSetByte(pPciDev, VBOX_PCI_CAPABILITY_LIST, u8Offset);
+//DECLINLINE(uint8_t) PDMPciDevGetCapabilityList(PPDMPCIDEV pPciDev)
+//    return PDMPciDevGetByte(pPciDev, VBOX_PCI_CAPABILITY_LIST);
 
 #endif /* !VBOX_INCLUDED_SRC_VirtIO_Virtio_1_0_h */

trunk/src/VBox/Devices/VirtIO/Virtio_1_0_impl.h

@@ -22 +22 @@
 #endif
 
+#include "Virtio_1_0.h"
+
+
+
+/** @name Saved state versions.
+ * The saved state version is changed if either common or any of specific
+ * parts are changed. That is, it is perfectly possible that the version
+ * of saved vnet state will increase as a result of change in vblk structure
+ * for example.
+ */
+#define VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1 1
+#define VIRTIO_SAVEDSTATE_VERSION           2
+/** @} */
+
+#define DEVICE_PCI_VENDOR_ID_VIRTIO         0x1AF4  /** Mandatory, so VirtIO driver can find this device */
+#define DEVICE_PCI_REVISION_ID_VIRTIO       1       /** Virtio spec suggests >= 1 for non-transitional drivers */
+
+
+/**
+ * The following is the PCI capability struct common to all VirtIO capability types
+ */
+#define VIRTIO_PCI_CAP_ID_VENDOR       0x09 /** Vendor-specific PCI CFG Device Capability ID */
+
+typedef struct virtio_pci_cap
+{
+    /* All little-endian */
+    uint8_t   uCapVndr;                     /** Generic PCI field: PCI_CAP_ID_VNDR          */
+    uint8_t   uCapNext;                     /** Generic PCI field: next ptr.                */
+    uint8_t   uCapLen;                      /** Generic PCI field: capability length        */
+    uint8_t   uCfgType;                     /** Identifies the structure.                   */
+    uint8_t   uBar;                         /** Where to find it.                           */
+    uint8_t   uPadding[3];                  /** Pad to full dword.                          */
+    uint32_t  uOffset;                      /** Offset within bar.  (L.E.)                  */
+    uint32_t  uLength;                      /** Length of struct, in bytes. (L.E.)          */
+}  VIRTIO_PCI_CAP_T, *PVIRTIO_PCI_CAP_T;
+
+/**
+ * The following structs correspond to the VirtIO capability types and describe
+ * fields accessed by MMIO via the relevant BAR. virtio_pci_dev_cap is not listed
+ * here because it is device specific, thus the device specific implementation
+ * consumer of this framework passes a ref/size in the constructor
+ *
+ */
+
+/* Virtio Device PCI Capabilities type codes */
+#define VIRTIO_PCI_CAP_COMMON_CFG      1    /** Common configuration PCI capability ID */
+#define VIRTIO_PCI_CAP_NOTIFY_CFG      2    /** Notification area PCI capability ID */
+#define VIRTIO_PCI_CAP_ISR_CFG         3    /** ISR PCI capability id */
+#define VIRTIO_PCI_CAP_DEVICE_CFG      4    /** Device specific configuration PCI capability ID */
+#define VIRTIO_PCI_CAP_PCI_CFG         5    /** PCI CFG capability ID */
+
+typedef struct virtio_pci_common_cfg /* VirtIO 1.0 specification name of this struct  */
+{
+    /* Per device fields */
+    uint32_t  uDeviceFeaturesSelect;        /** RW (driver selects device features)         */
+    uint32_t  uDeviceFeatures;              /** RO (device reports features to driver)      */
+    uint32_t  uDriverFeaturesSelect;        /** RW (driver selects driver features)         */
+    uint32_t  uDriverFeatures;              /** RW (driver accepts device features)         */
+    uint16_t  uMsixConfig;                  /** RW (driver sets MSI-X config vector)        */
+    uint16_t  uNumQueues;                   /** RO (device specifies max queues)            */
+    uint8_t   uDeviceStatus;                /** RW (driver writes device status, 0 resets)  */
+    uint8_t   uConfigGeneration;            /** RO (device changes when changing configs)   */
+
+    /* Per virtqueue fields (as determined by uQueueSelect) */
+    uint16_t  uQueueSelect;                 /** RW (selects queue focus for these fields)   */
+    uint16_t  uQueueSize;                   /** RW (queue size, 0 - 2^n)                    */
+    uint16_t  uQueueMsixVector;             /** RW (driver selects MSI-X queue vector)      */
+    uint16_t  uQueueEnable;                 /** RW (driver controls usability of queue)     */
+    uint16_t  uQueueNotifyOff;              /** RO (offset uto virtqueue; see spec)         */
+    uint64_t  uQueueDesc;                   /** RW (driver writes desc table phys addr)     */
+    uint64_t  uQueueAvail;                  /** RW (driver writes avail ring phys addr)     */
+    uint64_t  uQueueUsed;                   /** RW (driver writes used ring  phys addr)     */
+} VIRTIO_PCI_COMMON_CFG_T, *PVIRTIO_PCI_COMMON_CFG_T;
+
+typedef struct virtio_pci_notify_cap
+{
+    struct virtio_pci_cap pciCap;
+    uint32_t uNotifyOffMultiplier;          /* notify_off_multiplier                       */
+} VIRTIO_PCI_NOTIFY_CAP_T, *PVIRTIO_PCI_NOTIFY_CAP_T;
+
+typedef struct virtio_pci_cfg_cap
+{
+    struct virtio_pci_cap pciCap;
+    uint8_t uPciCfgData[4]; /* Data for BAR access. */
+} VIRTIO_PCI_CFG_CAP_T, *PVIRTIO_PCI_CFG_CAP_T;
+
+/**
+ * The core (/common) state of the VirtIO PCI device
+ *
+ * @implements  PDMILEDPORTS
+ */
+typedef struct VIRTIOSTATE
+{
+    PDMPCIDEV                    dev;
+    PDMCRITSECT                  cs;                                    /**< Critical section - what is it protecting? */
+    /* Read-only part, never changes after initialization. */
+    char                         szInstance[8];                         /**< Instance name, e.g. VNet#1. */
+
+#if HC_ARCH_BITS != 64
+    uint32_t                     padding1;
+#endif
+
+    /** Status LUN: Base interface. */
+    PDMIBASE                     IBase;
+
+    /** Status LUN: LED port interface. */
+    PDMILEDPORTS                 ILed;
+
+    /* Read/write part, protected with critical section. */
+    /** Status LED. */
+    PDMLED                       led;
+
+    VIRTIOCALLBACKS              virtioCallbacks;
+
+    /** Status LUN: LED connector (peer). */
+    R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
+
+    PPDMDEVINSR3                 pDevInsR3;                           /**< Device instance - R3. */
+    PPDMDEVINSR0                 pDevInsR0;                           /**< Device instance - R0. */
+    PPDMDEVINSRC                 pDevInsRC;                           /**< Device instance - RC. */
+
+
+    uint8_t                      uPciCfgDataOff;
+#if HC_ARCH_BITS == 64
+    uint32_t                     padding2;
+#endif
+
+    /** Base port of I/O space region. */
+    RTIOPORT                     IOPortBase;
+
+    uint32_t                     uGuestFeatures;
+    uint16_t                     uQueueSelector;                      /** An index in aQueues array. */
+    uint8_t                      uStatus;                             /** Device Status (bits are device-specific). */
+    uint8_t                      uISR;                                /** Interrupt Status Register. */
+
+#if HC_ARCH_BITS != 64
+    uint32_t                     padding3;
+#endif
+
+    VQUEUE                       Queues[VIRTIO_MAX_QUEUES];
+    uint32_t                     uNotifyOffMultiplier;                /* Multiplier for uQueueNotifyOff[idx] */
+
+    /** Whole virtio device */
+    uint32_t                     uDeviceFeaturesSelect;               /** Select hi/lo 32-bit uDeviceFeatures to r/w */
+    uint64_t                     uDeviceFeatures;                     /** Host features offered */
+    uint32_t                     uDriverFeaturesSelect;               /** Selects hi/lo 32-bit uDriverFeatures to r/w*/
+    uint64_t                     uDriverFeatures;                     /** Host features accepted by guest */
+    uint32_t                     uMsixConfig;
+    uint32_t                     uNumQueues;                          /** Actual number of queues used. */
+    uint8_t                      uDeviceStatus;
+    uint8_t                      uConfigGeneration;
+
+    /** Specific virtqueue */
+    uint16_t                     uQueueSelect;
+    uint16_t                     uQueueSize[VIRTIO_MAX_QUEUES];       /** Device sets on reset, driver can modify */
+    uint16_t                     uQueueNotifyOff[VIRTIO_MAX_QUEUES];  /** Device sets this */
+    uint16_t                     uQueueMsixVector[VIRTIO_MAX_QUEUES]; /** Driver specifies queue vector for MSI-X */
+    uint16_t                     uQueueEnable[VIRTIO_MAX_QUEUES];     /** Driver controls device access to queue */
+    uint64_t                     uQueueDesc[VIRTIO_MAX_QUEUES];       /** Driver provides this */
+    uint64_t                     uQueueAvail[VIRTIO_MAX_QUEUES];      /** Driver provides this */
+    uint64_t                     uQueueUsed[VIRTIO_MAX_QUEUES];       /** Driver provides this */
+
+
+    uint8_t                      uVirtioCapBar;                       /* Capabilities BAR (region) assigned by client */
+
+    /** Callbacks when guest driver reads or writes VirtIO device-specific capabilities(s) */
+    PFNPCICONFIGREAD             pfnPciConfigReadOld;
+    PFNPCICONFIGWRITE            pfnPciConfigWriteOld;
+
+    uint32_t                     cbDevSpecificCap;                    /* Size of client's dev-specific config data  */
+    void                        *pDevSpecificCap;                     /* Pointer to client's struct                 */
+    void                        *pPrevDevSpecificCap;                 /* Previous read dev-specific cfg of client */
+    bool                         fGenUpdatePending;                   /* If set, update cfg gen. after driver reads */
+
+    PVIRTIO_PCI_CFG_CAP_T        pPciCfgCap;                          /** Pointer to struct in configuration area */
+    PVIRTIO_PCI_NOTIFY_CAP_T     pNotifyCap;                          /** Pointer to struct in configuration area */
+    PVIRTIO_PCI_CAP_T            pCommonCfgCap;                       /** Pointer to struct in configuration area */
+    PVIRTIO_PCI_CAP_T            pIsrCap;                             /** Pointer to struct in configuration area */
+    PVIRTIO_PCI_CAP_T            pDeviceCap;                          /** Pointer to struct in configuration area */
+
+    /** Base address of PCI capabilities */
+    RTGCPHYS                     GCPhysPciCapBase;
+    RTGCPHYS                     pGcPhysCommonCfg;                    /** Pointer to MMIO mapped capability data */
+    RTGCPHYS                     pGcPhysNotifyCap;                    /** Pointer to MMIO mapped capability data */
+    RTGCPHYS                     pGcPhysIsrCap;                       /** Pointer to MMIO mapped capability data */
+    RTGCPHYS                     pGcPhysDeviceCap;                    /** Pointer to MMIO mapped capability data */
+
+    bool fDeviceConfigInterrupt;
+    bool fQueueInterrupt;
+
+} VIRTIOSTATE, *PVIRTIOSTATE;
+
+DECLINLINE(uint16_t) vringReadAvail(PVIRTIOSTATE pVirtio, PVIRTQ pVirtQ)
+{
+    uint16_t dataWord;
+    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+                      pVirtQ->pGcPhysVirtqAvail + RT_UOFFSETOF(VIRTQ_AVAIL_T, uIdx),
+                      &dataWord, sizeof(dataWord));
+    return dataWord;
+}
+
+DECLINLINE(bool) virtQueuePeek(PVIRTIOSTATE pVirtio, PVQUEUE pQueue, PVQUEUEELEM pElem)
+{
+    return virtQueueGet(pVirtio, pQueue, pElem, /* fRemove */ false);
+}
+
+DECLINLINE(bool) virtQueueIsReady(PVIRTIOSTATE pVirtio, PVQUEUE pQueue)
+{
+    NOREF(pVirtio);
+    return !!pQueue->VirtQ.pGcPhysVirtqAvail;
+}
+
+DECLINLINE(bool) virtQueueIsEmpty(PVIRTIOSTATE pVirtio, PVQUEUE pQueue)
+{
+    return (vringReadAvail(pVirtio, &pQueue->VirtQ) == pQueue->uNextAvailIndex);
+}
 /**
 * This macro returns true if physical address and access length are within the mapped capability struct.
@@ -146 +362 @@
 }
 
+/*  FROM Virtio 1.0 SPEC, NYI
+      static inline int virtq_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old_idx)
+            return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old_idx);
+      }
+      // Get location of event indices (only with VIRTIO_F_EVENT_IDX)
+      static inline le16 *virtq_used_event(struct virtq *vq)
+      {
+              // For backwards compat, used event index is at *end* of avail ring.
+              return &vq->avail->ring[vq->num];
+}
+      static inline le16 *virtq_avail_event(struct virtq *vq)
+      {
+              // For backwards compat, avail event index is at *end* of used ring.
+              return (le16 *)&vq->used->ring[vq->num];
+      }
+}
+*/
+void    virtioRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta);
+void   *virtioQueryInterface(struct PDMIBASE *pInterface, const char *pszIID);
+int     virtioSaveExec(PVIRTIOSTATE pVirtio, PSSMHANDLE pSSM);
+int     virtioLoadExec(PVIRTIOSTATE pVirtio, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t uNumQueues);
+
 #endif /* !VBOX_INCLUDED_SRC_VirtIO_Virtio_1_0_impl_h */