Changeset 105465 in vbox

Timestamp:

Jul 24, 2024 9:05:40 AM (6 months ago)

Author:

vboxsync

Message:

VMM/IEM: Some more TLB tracing related changes. bugref:10727

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/IEMAll.cpp (modified) (2 diffs)
• VMMAll/IEMAllCImpl.cpp (modified) (4 diffs)
• VMMR3/IEMR3.cpp (modified) (5 diffs)
• include/IEMInline.h (modified) (2 diffs)
• include/IEMInternal.h (modified) (3 diffs)

trunk/src/VBox/VMM/VMMAll/IEMAll.cpp

@@ -4438 +4438 @@
                          : EMEXIT_MAKE_FT(EMEXIT_F_KIND_IEM, u8Vector | 0x100),
                          pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base, uTimestamp);
+        IEMTLBTRACE_IRQ(pVCpu, u8Vector, fFlags, pVCpu->cpum.GstCtx.rflags.uBoth);
     }
     else
@@ -4449 +4450 @@
         if (fFlags & IEM_XCPT_FLAGS_CR2)
             EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_XCPT, u8Vector | EMEXIT_F_XCPT_CR2), uCr2, uTimestamp);
+        IEMTLBTRACE_XCPT(pVCpu, u8Vector, fFlags & IEM_XCPT_FLAGS_ERR ? uErr : 0, fFlags & IEM_XCPT_FLAGS_CR2 ? uCr2 : 0, fFlags);
     }
 

trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp

@@ -2912 +2912 @@
      * Commit the operation.
      */
+    IEMTLBTRACE_IRET(pVCpu, uNewCs, uNewEip, uNewFlags);
 #ifdef DBGFTRACE_ENABLED
     RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/rm %04x:%04x -> %04x:%04x %x %04llx",
@@ -3329 +3330 @@
         fEFlagsNew         &= ~fEFlagsMask;
         fEFlagsNew         |= uNewFlags & fEFlagsMask;
+        IEMTLBTRACE_IRET(pVCpu, uNewCs, uNewEip, fEFlagsNew);
 #ifdef DBGFTRACE_ENABLED
         RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/%up%u %04x:%08x -> %04x:%04x %x %04x:%04x",
@@ -3403 +3405 @@
         NewEfl.u           &= ~fEFlagsMask;
         NewEfl.u           |= fEFlagsMask & uNewFlags;
+        IEMTLBTRACE_IRET(pVCpu, uNewCs, uNewEip, NewEfl.u);
 #ifdef DBGFTRACE_ENABLED
         RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/%up %04x:%08x -> %04x:%04x %x %04x:%04llx",
@@ -3692 +3695 @@
     fEFlagsNew         &= ~fEFlagsMask;
     fEFlagsNew         |= uNewFlags & fEFlagsMask;
+    IEMTLBTRACE_IRET(pVCpu, uNewCs, uNewRip, fEFlagsNew);
 #ifdef DBGFTRACE_ENABLED
     RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/64/%ul%u %08llx -> %04x:%04llx %llx %04x:%04llx",

trunk/src/VBox/VMM/VMMR3/IEMR3.cpp

@@ -189 +189 @@
 
     /** @cfgm{/IEM/NativeRecompileAtUsedCount, uint32_t, 16}
-     * The translation block use count value to do native recompilation at. */
+     * The translation block use count value to do native recompilation at.
+     * Set to zero to disable native recompilation. */
     uint32_t uTbNativeRecompileAtUsedCount = 16;
     rc = CFGMR3QueryU32Def(pIem, "NativeRecompileAtUsedCount", &uTbNativeRecompileAtUsedCount, 16);
@@ -1455 +1456 @@
         { "--limit",                    'l', RTGETOPT_REQ_UINT32  },
         { "--stop-at-global-flush",     'g', RTGETOPT_REQ_NOTHING },
+        { "--resolve-rip",              'r', RTGETOPT_REQ_NOTHING },
     };
 
@@ -1463 +1465 @@
     uint32_t        cLimit             = UINT32_MAX;
     bool            fStopAtGlobalFlush = false;
+    bool            fResolveRip        = false;
     PVMCPU const    pVCpuCall          = VMMGetCpu(pVM);
     PVMCPU          pVCpu              = pVCpuCall;
@@ -1488 +1491 @@
                 break;
 
+            case 'r':
+                fResolveRip = true;
+                break;
+
             case 'h':
                 pHlp->pfnPrintf(pHlp,
-                                "Usage: info tlbtrace [options]\n"
+                                "Usage: info tlbtrace [options] [n]\n"
                                 "\n"
                                 "Options:\n"
                                 "  -c<n>, --cpu=<n>, --vcpu=<n>\n"
                                 "    Selects the CPU which TLB trace we're looking at. Default: Caller / 0\n"
-                                "  -l<n>, --last=<n>\n"
+                                "  [n], -l<n>, --last=<n>\n"
                                 "    Limit display to the last N entries. Default: all\n"
-                                "  -g,--stop-at-global-flush\n"
+                                "  -g, --stop-at-global-flush\n"
                                 "    Stop after the first global flush entry.\n"
+                                "  -r, --resolve-rip\n"
+                                "    Resolve symbols for the flattened RIP addresses.\n"
                                 );
+                return;
+
+            case VINF_GETOPT_NOT_OPTION:
+                rc = RTStrToUInt32Full(ValueUnion.psz, 0, &cLimit);
+                if (RT_SUCCESS(rc))
+                    break;
+                pHlp->pfnPrintf(pHlp, "error: failed to convert '%s' to a number: %Rrc\n", ValueUnion.psz, rc);
                 return;
 
@@ -1526 +1542 @@
         while (cLeft-- > 0)
         {
-            PCIEMTLBTRACEENTRY const pCur = &paEntries[--idx & fMask];
+            PCIEMTLBTRACEENTRY const pCur      = &paEntries[--idx & fMask];
+            const char              *pszSymbol = "";
+            union
+            {
+                RTDBGSYMBOL Symbol;
+                char        ach[sizeof(RTDBGSYMBOL) + 32];
+            } uBuf;
+            if (fResolveRip)
+            {
+                RTGCINTPTR  offDisp = 0;
+                DBGFADDRESS Addr;
+                rc = DBGFR3AsSymbolByAddr(pVM->pUVM, DBGF_AS_GLOBAL, DBGFR3AddrFromFlat(pVM->pUVM, &Addr, pCur->rip),
+                                            RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL
+                                          | RTDBGSYMADDR_FLAGS_SKIP_ABS
+                                          | RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
+                                          &offDisp, &uBuf.Symbol, NULL);
+                if (RT_SUCCESS(rc))
+                {
+                    if (offDisp)
+                    {
+                        size_t const cchName    = strlen(uBuf.Symbol.szName);
+                        char * const pszEndName = &uBuf.Symbol.szName[cchName];
+                        size_t const cbLeft     = sizeof(uBuf) - sizeof(uBuf.Symbol) + sizeof(uBuf.Symbol.szName) - cchName;
+                        if (offDisp > 0)
+                            RTStrPrintf(pszEndName, cbLeft, "+%#1RGv", offDisp);
+                        else
+                            RTStrPrintf(pszEndName, cbLeft, "-%#1RGv", -offDisp);
+                        char *pszName = uBuf.Symbol.szName;
+                        *--pszName = ' ';   /* padding */
+                        pszSymbol = pszName;
+                    }
+                }
+            }
             switch (pCur->enmType)
             {
                 case kIemTlbTraceType_InvlPg:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 invlpg %RGv slot=" IEMTLB_SLOT_FMT "\n",
-                                    idx, pCur->rip, pCur->u64Param, (uint32_t)IEMTLB_ADDR_TO_EVEN_INDEX(pCur->u64Param));
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 invlpg %RGv slot=" IEMTLB_SLOT_FMT "%s\n", idx, pCur->rip,
+                                    pCur->u64Param, (uint32_t)IEMTLB_ADDR_TO_EVEN_INDEX(pCur->u64Param), pszSymbol);
                     break;
                 case kIemTlbTraceType_Flush:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 flush %s rev=%#RX64\n", idx, pCur->rip,
-                                    pCur->bParam ? "data" : "code", pCur->u64Param);
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 flush %s rev=%#RX64%s\n", idx, pCur->rip,
+                                    pCur->bParam ? "data" : "code", pCur->u64Param, pszSymbol);
                     break;
                 case kIemTlbTraceType_FlushGlobal:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 flush %s rev=%#RX64 grev=%#RX64\n", idx, pCur->rip,
-                                    pCur->bParam ? "data" : "code", pCur->u64Param, pCur->u64Param2);
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 flush %s rev=%#RX64 grev=%#RX64%s\n", idx, pCur->rip,
+                                    pCur->bParam ? "data" : "code", pCur->u64Param, pCur->u64Param2, pszSymbol);
                     if (fStopAtGlobalFlush)
                         return;
                     break;
                 case kIemTlbTraceType_Load:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load %s %RGv slot=" IEMTLB_SLOT_FMT "\n",
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load %s %RGv slot=" IEMTLB_SLOT_FMT "%s\n",
                                     idx, pCur->rip, pCur->bParam ? "data" : "code",
-                                    pCur->u64Param, (uint32_t)IEMTLB_ADDR_TO_EVEN_INDEX(pCur->u64Param));
+                                    pCur->u64Param, (uint32_t)IEMTLB_ADDR_TO_EVEN_INDEX(pCur->u64Param), pszSymbol);
                     break;
                 case kIemTlbTraceType_LoadGlobal:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load %s %RGv slot=" IEMTLB_SLOT_FMT " (global)\n",
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load %s %RGv slot=" IEMTLB_SLOT_FMT " (global)%s\n",
                                     idx, pCur->rip, pCur->bParam ? "data" : "code",
-                                    pCur->u64Param, (uint32_t)IEMTLB_ADDR_TO_EVEN_INDEX(pCur->u64Param));
+                                    pCur->u64Param, (uint32_t)IEMTLB_ADDR_TO_EVEN_INDEX(pCur->u64Param), pszSymbol);
                     break;
                 case kIemTlbTraceType_Load_Cr0:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load cr0 %08RX64 (was %08RX64)\n",
-                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2);
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load cr0 %08RX64 (was %08RX64)%s\n",
+                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2, pszSymbol);
                     break;
                 case kIemTlbTraceType_Load_Cr3:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load cr3 %016RX64 (was %016RX64)\n",
-                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2);
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load cr3 %016RX64 (was %016RX64)%s\n",
+                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2, pszSymbol);
                     break;
                 case kIemTlbTraceType_Load_Cr4:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load cr4 %08RX64 (was %08RX64)\n",
-                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2);
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load cr4 %08RX64 (was %08RX64)%s\n",
+                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2, pszSymbol);
                     break;
                 case kIemTlbTraceType_Load_Efer:
-                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load efer %016RX64 (was %016RX64)\n",
-                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2);
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 load efer %016RX64 (was %016RX64)%s\n",
+                                    idx, pCur->rip, pCur->u64Param, pCur->u64Param2, pszSymbol);
+                    break;
+                case kIemTlbTraceType_Irq:
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 irq %#04x flags=%#x eflboth=%#RX64%s\n",
+                                    idx, pCur->rip, pCur->bParam, pCur->u32Param,
+                                    pCur->u64Param & ((RT_BIT_64(CPUMX86EFLAGS_HW_BITS) - 1) | CPUMX86EFLAGS_INT_MASK_64),
+                                    pszSymbol);
+                    break;
+                case kIemTlbTraceType_Xcpt:
+                    if (pCur->u32Param & IEM_XCPT_FLAGS_CR2)
+                        pHlp->pfnPrintf(pHlp, "%u: %016RX64 xcpt %#04x flags=%#x errcd=%#x cr2=%RX64%s\n",
+                                        idx, pCur->rip, pCur->bParam, pCur->u32Param, pCur->u64Param, pCur->u64Param2, pszSymbol);
+                    else if (pCur->u32Param & IEM_XCPT_FLAGS_ERR)
+                        pHlp->pfnPrintf(pHlp, "%u: %016RX64 xcpt %#04x flags=%#x errcd=%#x%s\n",
+                                        idx, pCur->rip, pCur->bParam, pCur->u32Param, pCur->u64Param, pszSymbol);
+                    else
+                        pHlp->pfnPrintf(pHlp, "%u: %016RX64 xcpt %#04x flags=%#x%s\n",
+                                        idx, pCur->rip, pCur->bParam, pCur->u32Param, pszSymbol);
+                    break;
+                case kIemTlbTraceType_IRet:
+                    pHlp->pfnPrintf(pHlp, "%u: %016RX64 iret cs:rip=%04x:%016RX64 efl=%08RX32%s\n",
+                                    idx, pCur->rip, pCur->u32Param, pCur->u64Param, (uint32_t)pCur->u64Param2, pszSymbol);
                     break;
                 case kIemTlbTraceType_Invalid:

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

@@ -4805 +4805 @@
  */
 DECLINLINE(void) iemTlbTrace(PVMCPU pVCpu, IEMTLBTRACETYPE enmType, uint64_t u64Param, uint64_t u64Param2 = 0,
-                             uint8_t bParam = 0 /*, uint32_t u32Param = 0, uint16_t u16Param = 0 */)
+                             uint8_t bParam = 0, uint32_t u32Param = 0/*, uint16_t u16Param = 0 */)
 {
     uint32_t const          fMask  = RT_BIT_32(pVCpu->iem.s.cTlbTraceEntriesShift) - 1;
@@ -4812 +4812 @@
     pEntry->u64Param2 = u64Param2;
     pEntry->u16Param  = 0; //u16Param;
-    pEntry->u32Param  = 0; //u32Param;
+    pEntry->u32Param  = u32Param;
     pEntry->bParam    = bParam;
     pEntry->enmType   = enmType;

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

@@ -739 +739 @@
     kIemTlbTraceType_Load_Cr3,
     kIemTlbTraceType_Load_Cr4,
-    kIemTlbTraceType_Load_Efer
+    kIemTlbTraceType_Load_Efer,
+    kIemTlbTraceType_Irq,
+    kIemTlbTraceType_Xcpt,
+    kIemTlbTraceType_IRet
 } IEMTLBTRACETYPE;
 
@@ -779 +782 @@
 # define IEMTLBTRACE_LOAD_CR4(a_pVCpu, a_uNew, a_uOld)      iemTlbTrace(a_pVCpu, kIemTlbTraceType_Load_Cr4, a_uNew, a_uOld)
 # define IEMTLBTRACE_LOAD_EFER(a_pVCpu, a_uNew, a_uOld)     iemTlbTrace(a_pVCpu, kIemTlbTraceType_Load_Efer, a_uNew, a_uOld)
+# define IEMTLBTRACE_IRQ(a_pVCpu, a_uVector, a_fFlags, a_fEFlags) \
+    iemTlbTrace(a_pVCpu, kIemTlbTraceType_Irq, a_fEFlags, 0, a_uVector, a_fFlags)
+# define IEMTLBTRACE_XCPT(a_pVCpu, a_uVector, a_uErr, a_uCr2, a_fFlags) \
+    iemTlbTrace(a_pVCpu, kIemTlbTraceType_Xcpt, a_uErr, a_uCr2, a_uVector, a_fFlags)
+# define IEMTLBTRACE_IRET(a_pVCpu, a_uRetCs, a_uRetRip, a_fEFlags) \
+    iemTlbTrace(a_pVCpu, kIemTlbTraceType_IRet, a_uRetRip, a_fEFlags, 0, a_uRetCs)
 #else
 # define IEMTLBTRACE_INVLPG(a_pVCpu, a_GCPtr)                           do { } while (0)
@@ -789 +798 @@
 # define IEMTLBTRACE_LOAD_CR4(a_pVCpu, a_uNew, a_uOld)                  do { } while (0)
 # define IEMTLBTRACE_LOAD_EFER(a_pVCpu, a_uNew, a_uOld)                 do { } while (0)
+# define IEMTLBTRACE_IRQ(a_pVCpu, a_uVector, a_fFlags)                  do { } while (0)
+# define IEMTLBTRACE_XCPT(a_pVCpu, a_uVector, a_uErr, a_uCr2, a_fFlags) do { } while (0)
+# define IEMTLBTRACE_IRET(a_pVCpu, a_uRetCs, a_uRetRip, a_fEFlags)      do { } while (0)
 #endif