Changeset 81333 in vbox for trunk/src/VBox/VMM/include

Timestamp:

Oct 17, 2019 11:49:39 PM (5 years ago)

Author:

vboxsync

Message:

IOM: More MMIO stuff, almost there now... bugref:9218

Location:

trunk/src/VBox/VMM/include

Files:

• IOMInline.h (modified) (4 diffs)
• IOMInternal.h (modified) (9 diffs)

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

@@ -37 +37 @@
  *
  * @param   pVM             The cross context VM structure.
- * @param   uPort           The I/O port lookup.
- * @param   poffPort        Where to the port offset relative to the start of
- *                          the I/O port range.
+ * @param   uPort           The I/O port to lookup.
+ * @param   poffPort        Where to return the port offset relative to the
+ *                          start of the I/O port range.
  * @param   pidxLastHint    Pointer to IOMCPU::idxIoPortLastRead or
  *                          IOMCPU::idxIoPortLastWrite.
@@ -47 +47 @@
  *          for the entry.  Use IOMIOPORTENTRYR0::idxSelf to get the ring-3
  *          entry.
+ *
+ * @note    This code is almost identical to iomMmioGetEntry, so keep in sync.
  */
 DECLINLINE(CTX_SUFF(PIOMIOPORTENTRY)) iomIoPortGetEntry(PVMCC pVM, RTIOPORT uPort, PRTIOPORT poffPort, uint16_t *pidxLastHint)
@@ -117 +119 @@
 #ifdef VBOX_WITH_STATISTICS
 /**
- * Gets the I/O port statistics entry .
+ * Gets the statistics entry for an I/O port.
  *
  * @returns Pointer to stats.  Instead of NULL, a pointer to IoPortDummyStats is
@@ -139 +141 @@
 # endif
     return &pVM->iom.s.IoPortDummyStats;
+}
+#endif
+
+
+/**
+ * Gets the MMIO region entry for the specified address in the current context.
+ *
+ * @returns Pointer to MMIO region entry.
+ * @returns NULL if no MMIO region registered for the given address.
+ *
+ * @param   pVM             The cross context VM structure.
+ * @param   GCPhys          The address to lookup.
+ * @param   poffRegion      Where to return the byte offset into the MMIO
+ *                          region that corresponds to @a GCPhys.
+ * @param   pidxLastHint    Pointer to IOMCPU::idxMmioLastRead,
+ *                          IOMCPU::idxMmioLastWrite, or similar.
+ *
+ * @note    In ring-0 it is possible to get an uninitialized entry (pDevIns is
+ *          NULL, cbRegion is 0), in which case there should be ring-3 handlers
+ *          for the entry.  Use IOMMMIOENTRYR0::idxSelf to get the ring-3 entry.
+ *
+ * @note    This code is almost identical to iomIoPortGetEntry, so keep in sync.
+ */
+DECLINLINE(CTX_SUFF(PIOMMMIOENTRY)) iomMmioGetEntry(PVMCC pVM, RTGCPHYS GCPhys, PRTGCPHYS poffRegion, uint16_t *pidxLastHint)
+{
+    Assert(IOM_IS_SHARED_LOCK_OWNER(pVM));
+
+#ifdef IN_RING0
+    uint32_t               iEnd      = RT_MIN(pVM->iom.s.cMmioLookupEntries, pVM->iomr0.s.cMmioAlloc);
+    PCIOMMMIOLOOKUPENTRY   paLookup  = pVM->iomr0.s.paMmioLookup;
+#else
+    uint32_t               iEnd      = pVM->iom.s.cMmioLookupEntries;
+    PCIOMMMIOLOOKUPENTRY   paLookup  = pVM->iom.s.paMmioLookup;
+#endif
+    if (iEnd > 0)
+    {
+        uint32_t iFirst = 0;
+        uint32_t i      = *pidxLastHint;
+        if (i < iEnd)
+        { /* likely */ }
+        else
+            i = iEnd / 2;
+        for (;;)
+        {
+            PCIOMMMIOLOOKUPENTRY pCur = &paLookup[i];
+            if (pCur->GCPhysFirst > GCPhys)
+            {
+                if (i > iFirst)
+                    iEnd = i;
+                else
+                    break;
+            }
+            else if (pCur->GCPhysLast < GCPhys)
+            {
+                i += 1;
+                if (i < iEnd)
+                    iFirst = i;
+                else
+                    break;
+            }
+            else
+            {
+                *pidxLastHint = (uint16_t)i;
+                *poffRegion   = GCPhys - pCur->GCPhysFirst;
+
+                /*
+                 * Translate the 'idx' member into a pointer.
+                 */
+                size_t const idx = pCur->idx;
+#ifdef IN_RING0
+                AssertMsg(idx < pVM->iom.s.cMmioRegs && idx < pVM->iomr0.s.cMmioAlloc,
+                          ("%#zx vs %#x/%x (GCPhys=%RGp)\n", idx, pVM->iom.s.cMmioRegs, pVM->iomr0.s.cMmioMax, GCPhys));
+                if (idx < pVM->iomr0.s.cMmioAlloc)
+                    return &pVM->iomr0.s.paMmioRegs[idx];
+#else
+                if (idx < pVM->iom.s.cMmioRegs)
+                    return &pVM->iom.s.paMmioRegs[idx];
+                AssertMsgFailed(("%#zx vs %#x (GCPhys=%RGp)\n", idx, pVM->iom.s.cMmioRegs, GCPhys));
+#endif
+                break;
+            }
+
+            i = iFirst + (iEnd - iFirst) / 2;
+        }
+    }
+    *poffRegion = 0;
+    return NULL;
+}
+
+
+#ifdef VBOX_WITH_STATISTICS
+/**
+ * Gets the statistics entry for an MMIO region.
+ *
+ * @returns Pointer to stats.  Instead of NULL, a pointer to MmioDummyStats is
+ *          returned, so the caller does not need to check for NULL.
+ *
+ * @param   pVM         The cross context VM structure.
+ * @param   pRegEntry   The I/O port entry to get stats for.
+ */
+DECLINLINE(PIOMMMIOSTATSENTRY) iomMmioGetStats(PVMCC pVM, CTX_SUFF(PIOMMMIOENTRY) pRegEntry)
+{
+    size_t idxStats = pRegEntry->idxStats;
+# ifdef IN_RING0
+    if (idxStats < pVM->iomr0.s.cMmioStatsAllocation)
+        return &pVM->iomr0.s.paMmioStats[idxStats];
+# else
+    if (idxStats < pVM->iom.s.cMmioStats)
+        return &pVM->iom.s.paMmioStats[idxStats];
+# endif
+    return &pVM->iom.s.MmioDummyStats;
 }
 #endif

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

@@ -307 +307 @@
     /** Pointer to the fill callback function. */
     R0PTRTYPE(PFNIOMMMIONEWFILL)        pfnFillCallback;
-    /** The entry of the first statistics entry, UINT16_MAX if no stats. */
+    /** The entry of the first statistics entry, UINT16_MAX if no stats.
+     * @note For simplicity, this is always copied from ring-3 for all entries at
+     *       the end of VM creation. */
     uint16_t                            idxStats;
     /** Same as the handle index. */
@@ -371 +373 @@
 typedef struct IOMMMIOSTATSENTRY
 {
-    /** Number of accesses (subtract ReadRZToR3 and WriteRZToR3 to get the right
-     *  number). */
-    STAMCOUNTER                 Accesses;
-
+    /** Counting and profiling reads in R0/RC. */
+    STAMPROFILE                 ProfReadRZ;
+    /** Number of successful read accesses. */
+    STAMCOUNTER                 Reads;
+    /** Number of reads to this address from R0/RC which was serviced in R3. */
+    STAMCOUNTER                 ReadRZToR3;
+    /** Number of complicated reads. */
+    STAMCOUNTER                 ComplicatedReads;
+    /** Number of reads of 0xff or 0x00. */
+    STAMCOUNTER                 FFor00Reads;
     /** Profiling read handler overhead in R3. */
     STAMPROFILE                 ProfReadR3;
+
+    /** Counting and profiling writes in R0/RC. */
+    STAMPROFILE                 ProfWriteRZ;
+    /** Number of successful read accesses. */
+    STAMCOUNTER                 Writes;
+    /** Number of writes to this address from R0/RC which was serviced in R3. */
+    STAMCOUNTER                 WriteRZToR3;
+    /** Number of writes to this address from R0/RC which was committed in R3. */
+    STAMCOUNTER                 CommitRZToR3;
+    /** Number of complicated writes. */
+    STAMCOUNTER                 ComplicatedWrites;
     /** Profiling write handler overhead in R3. */
     STAMPROFILE                 ProfWriteR3;
-    /** Counting and profiling reads in R0/RC. */
-    STAMPROFILE                 ProfReadRZ;
-    /** Counting and profiling writes in R0/RC. */
-    STAMPROFILE                 ProfWriteRZ;
-
-    /** Number of reads to this address from R0/RC which was serviced in R3. */
-    STAMCOUNTER                 ReadRZToR3;
-    /** Number of writes to this address from R0/RC which was serviced in R3. */
-    STAMCOUNTER                 WriteRZToR3;
 } IOMMMIOSTATSENTRY;
 /** Pointer to MMIO statistics entry. */
@@ -602 +612 @@
         /** Guest physical MMIO address. */
         RTGCPHYS                        GCPhys;
+        /** The number of bytes to write (0 if nothing pending). */
+        uint32_t                        cbValue;
+        /** Hint. */
+        uint32_t                        idxMmioRegionHint;
         /** The value to write. */
         uint8_t                         abValue[128];
-        /** The number of bytes to write (0 if nothing pending). */
-        uint32_t                        cbValue;
-        /** Alignment padding. */
-        uint32_t                        uAlignmentPadding;
     } PendingMmioWrite;
 
@@ -654 +664 @@
     /** MMIO physical access handler type.   */
     PGMPHYSHANDLERTYPE              hMmioHandlerType;
-    uint32_t                        u32Padding;
+    /** MMIO physical access handler type, new style.   */
+    PGMPHYSHANDLERTYPE              hNewMmioHandlerType;
 
     /** @name I/O ports
@@ -729 +740 @@
      * @{ */
     STAMPROFILE                     StatRZMMIOHandler;
-    STAMCOUNTER                     StatRZMMIOFailures;
-
-    STAMPROFILE                     StatRZInstMov;
-    STAMPROFILE                     StatRZInstCmp;
-    STAMPROFILE                     StatRZInstAnd;
-    STAMPROFILE                     StatRZInstOr;
-    STAMPROFILE                     StatRZInstXor;
-    STAMPROFILE                     StatRZInstBt;
-    STAMPROFILE                     StatRZInstTest;
-    STAMPROFILE                     StatRZInstXchg;
-    STAMPROFILE                     StatRZInstStos;
-    STAMPROFILE                     StatRZInstLods;
-#ifdef IOM_WITH_MOVS_SUPPORT
-    STAMPROFILEADV                  StatRZInstMovs;
-    STAMPROFILE                     StatRZInstMovsToMMIO;
-    STAMPROFILE                     StatRZInstMovsFromMMIO;
-    STAMPROFILE                     StatRZInstMovsMMIO;
-#endif
-    STAMCOUNTER                     StatRZInstOther;
-
+    STAMCOUNTER                     StatRZMMIOReadsToR3;
+    STAMCOUNTER                     StatRZMMIOWritesToR3;
+    STAMCOUNTER                     StatRZMMIOCommitsToR3;
+    STAMCOUNTER                     StatRZMMIODevLockContention;
+#if 0
     STAMCOUNTER                     StatRZMMIO1Byte;
     STAMCOUNTER                     StatRZMMIO2Bytes;
     STAMCOUNTER                     StatRZMMIO4Bytes;
     STAMCOUNTER                     StatRZMMIO8Bytes;
-
+#endif
     STAMCOUNTER                     StatR3MMIOHandler;
+
+    STAMCOUNTER                     StatMmioHandlerR3;
+    STAMCOUNTER                     StatMmioHandlerR0;
 
     RTUINT                          cMovsMaxBytes;
@@ -791 +790 @@
     /** The size of the paIoPortStats allocation (in entries). */
     uint32_t                        cIoPortStatsAllocation;
+    /** Prevents paIoPortStats from growing, set by IOMR0IoPortSyncStatisticsIndices(). */
+    bool                            fIoPortStatsFrozen;
     /** I/O port lookup table.   */
     R0PTRTYPE(PIOMIOPORTSTATSENTRY) paIoPortStats;
@@ -822 +823 @@
     /** The size of the paMmioStats allocation (in entries). */
     uint32_t                        cMmioStatsAllocation;
+    /* Prevents paMmioStats from growing, set by IOMR0MmioSyncStatisticsIndices(). */
+    bool                            fMmioStatsFrozen;
     /** MMIO lookup table.   */
     R0PTRTYPE(PIOMMMIOSTATSENTRY)   paMmioStats;
@@ -841 +844 @@
 DECLCALLBACK(void)  iomR3IoPortInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 void                iomR3IoPortRegStats(PVM pVM, PIOMIOPORTENTRYR3 pRegEntry);
+DECLCALLBACK(void)  iomR3MmioInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
+void                iomR3MmioRegStats(PVM pVM, PIOMMMIOENTRYR3 pRegEntry);
 #endif /* IN_RING3 */
 #ifdef IN_RING0
@@ -848 +853 @@
 void                iomR0MmioInitPerVMData(PGVM pGVM);
 #endif
+VBOXSTRICTRC        iomMmioCommonPfHandlerOld(PVMCC pVM, PVMCPUCC pVCpu, uint32_t uErrorCode, PCPUMCTXCORE pCtxCore,
+                                              RTGCPHYS GCPhysFault, void *pvUser);
 
 #ifndef IN_RING3
 DECLEXPORT(FNPGMRZPHYSPFHANDLER)    iomMmioPfHandler;
+DECLEXPORT(FNPGMRZPHYSPFHANDLER)    iomMmioPfHandlerNew;
 #endif
 PGM_ALL_CB2_PROTO(FNPGMPHYSHANDLER) iomMmioHandler;
+PGM_ALL_CB2_PROTO(FNPGMPHYSHANDLER) iomMmioHandlerNew;
 
 /* IOM locking helpers. */