Changeset 36054 in vbox

Timestamp:

Feb 22, 2011 3:04:28 PM (14 years ago)

Author:

vboxsync

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

70165

Message:

VMM/REM: Made .remstep work to some degree (might skip interrupts/traps).

Location:

trunk

Files:

• include/VBox/vmm/vm.h (modified) (2 diffs)
• src/VBox/VMM/VMMR3/EM.cpp (modified) (2 diffs)
• src/VBox/VMM/VMMR3/VMM.cpp (modified) (2 diffs)
• src/recompiler/VBoxRecompiler.c (modified) (5 diffs)
• src/recompiler/cpu-exec.c (modified) (1 diff)

trunk/include/VBox/vmm/vm.h ¶

@@ -334 +334 @@
  * (NON-GLOBAL FLUSH) */
 #define VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL    RT_BIT_32(17)
-/** Check for pending TLB shootdown actions. */
+/** Check for pending TLB shootdown actions.
+ * Consumer: HWACCM
+ * @todo rename to VMCPU_FF_HWACCM_TLB_SHOOTDOWN  */
 #define VMCPU_FF_TLB_SHOOTDOWN              RT_BIT_32(18)
-/** Check for pending TLB flush action. */
+/** Check for pending TLB flush action.
+ * Consumer: HWACCM
+ * @todo rename to VMCPU_FF_HWACCM_TLB_FLUSH  */
 #define VMCPU_FF_TLB_FLUSH                  RT_BIT_32(VMCPU_FF_TLB_FLUSH_BIT)
 /** The bit number for VMCPU_FF_TLB_FLUSH. */
@@ -411 +415 @@
 #define VMCPU_FF_ALL_MASK                       (~0U)
 
-/** All the forced VM flags. */
-#define VM_FF_ALL_BUT_RAW_MASK                  (~(VM_FF_HIGH_PRIORITY_PRE_RAW_MASK) | VM_FF_PGM_NO_MEMORY)
-/** All the forced VMCPU flags. */
-#define VMCPU_FF_ALL_BUT_RAW_MASK               (~(VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK | VMCPU_FF_CSAM_PENDING_ACTION | VMCPU_FF_PDM_CRITSECT))
+/** All the forced VM flags except those related to raw-mode and hardware
+ * assisted execution. */
+#define VM_FF_ALL_REM_MASK                      (~(VM_FF_HIGH_PRIORITY_PRE_RAW_MASK) | VM_FF_PGM_NO_MEMORY)
+/** All the forced VMCPU flags except those related to raw-mode and hardware
+ * assisted execution. */
+#define VMCPU_FF_ALL_REM_MASK                   (~(VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK | VMCPU_FF_CSAM_PENDING_ACTION | VMCPU_FF_PDM_CRITSECT | VMCPU_FF_TLB_FLUSH | VMCPU_FF_TLB_SHOOTDOWN))
 
 /** @} */

trunk/src/VBox/VMM/VMMR3/EM.cpp ¶

@@ -989 +989 @@
         TMTimerPollVoid(pVM, pVCpu);
 #endif
-        AssertCompile((VMCPU_FF_ALL_BUT_RAW_MASK & ~(VMCPU_FF_CSAM_PENDING_ACTION | VMCPU_FF_CSAM_SCAN_PAGE)) & VMCPU_FF_TIMER);
-        if (    VM_FF_ISPENDING(pVM, VM_FF_ALL_BUT_RAW_MASK)
-            ||  VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_ALL_BUT_RAW_MASK & ~(VMCPU_FF_CSAM_PENDING_ACTION | VMCPU_FF_CSAM_SCAN_PAGE)))
+        AssertCompile((VMCPU_FF_ALL_REM_MASK & ~(VMCPU_FF_CSAM_PENDING_ACTION | VMCPU_FF_CSAM_SCAN_PAGE)) & VMCPU_FF_TIMER);
+        if (    VM_FF_ISPENDING(pVM, VM_FF_ALL_REM_MASK)
+            ||  VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_ALL_REM_MASK & ~(VMCPU_FF_CSAM_PENDING_ACTION | VMCPU_FF_CSAM_SCAN_PAGE)))
         {
 l_REMDoForcedActions:
@@ -1755 +1755 @@
                 && rc != VINF_EM_TERMINATE
                 && rc != VINF_EM_OFF
-                && (   VM_FF_ISPENDING(pVM, VM_FF_ALL_BUT_RAW_MASK)
-                    || VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_ALL_BUT_RAW_MASK)))
+                && (   VM_FF_ISPENDING(pVM, VM_FF_ALL_REM_MASK)
+                    || VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_ALL_REM_MASK)))
             {
                 rc = emR3ForcedActions(pVM, pVCpu, rc);

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

@@ -2258 +2258 @@
     PRINT_GROUP(VM_FF_,NORMAL_PRIORITY_POST,_MASK);
     PRINT_GROUP(VM_FF_,NORMAL_PRIORITY,_MASK);
-    PRINT_GROUP(VM_FF_,ALL_BUT_RAW,_MASK);
+    PRINT_GROUP(VM_FF_,ALL_REM,_MASK);
     if (c)
         pHlp->pfnPrintf(pHlp, "\n");
@@ -2305 +2305 @@
         PRINT_GROUP(VMCPU_FF_,RESUME_GUEST,_MASK);
         PRINT_GROUP(VMCPU_FF_,HWACCM_TO_R3,_MASK);
-        PRINT_GROUP(VMCPU_FF_,ALL_BUT_RAW,_MASK);
+        PRINT_GROUP(VMCPU_FF_,ALL_REM,_MASK);
         if (c)
             pHlp->pfnPrintf(pHlp, "\n");

trunk/src/recompiler/VBoxRecompiler.c ¶

@@ -1064 +1064 @@
 
 /**
+ * Used by REMR3Run to handle the case where CPU_EMULATE_SINGLE_STEP is set.
+ *
+ * @returns VBox status code.
+ *
+ * @param   pVM                 The VM handle.
+ * @param   pVCpu               The Virtual CPU handle.
+ */
+static int remR3RunLoggingStep(PVM pVM, PVMCPU pVCpu)
+{
+    int rc;
+    Assert(!pVM->rem.s.Env.singlestep_enabled);
+    Assert(pVM->rem.s.fInREM);
+/* #define REM_USE_QEMU_SINGLE_STEP_FOR_LOGGING - slow (tb flushing?) */
+#ifdef REM_USE_QEMU_SINGLE_STEP_FOR_LOGGING
+    cpu_single_step(&pVM->rem.s.Env, 1);
+#endif
+
+    /*
+     * Now we set the execute single instruction flag and enter the cpu_exec loop.
+     */
+    for (;;)
+    {
+        char szBuf[256];
+
+        /*
+         * Log the current registers state and instruction.
+         */
+        remR3StateUpdate(pVM, pVCpu);
+        DBGFR3Info(pVM, "cpumguest", NULL, NULL);
+        szBuf[0] = '\0';
+        rc = DBGFR3DisasInstrEx(pVM,
+                                pVCpu->idCpu,
+                                0, /* Sel */
+                                0, /* GCPtr */
+                                DBGF_DISAS_FLAGS_CURRENT_GUEST
+                                | DBGF_DISAS_FLAGS_DEFAULT_MODE
+                                | DBGF_DISAS_FLAGS_HID_SEL_REGS_VALID,
+                                szBuf,
+                                sizeof(szBuf),
+                                NULL);
+        if (RT_FAILURE(rc))
+            RTStrPrintf(szBuf, sizeof(szBuf), "DBGFR3DisasInstrEx failed with rc=%Rrc\n", rc);
+        RTLogPrintf("CPU%d: %s\n", pVCpu->idCpu, szBuf);
+
+        /*
+         * Execute the instruction.
+         */
+        TMNotifyStartOfExecution(pVCpu);
+
+        if (   pVM->rem.s.Env.exception_index < 0
+            || pVM->rem.s.Env.exception_index > 256)
+            pVM->rem.s.Env.exception_index = -1; /** @todo We need to do similar stuff elsewhere, I think. */
+
+#ifdef REM_USE_QEMU_SINGLE_STEP_FOR_LOGGING
+        pVM->rem.s.Env.interrupt_request = 0;
+#else
+        pVM->rem.s.Env.interrupt_request = CPU_INTERRUPT_SINGLE_INSTR;
+#endif
+        if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC))
+            pVM->rem.s.Env.interrupt_request |= CPU_INTERRUPT_HARD;
+        RTLogPrintf("remR3RunLoggingStep: interrupt_request=%#x halted=%d exception_index=%#x\n", rc,
+                    pVM->rem.s.Env.interrupt_request,
+                    pVM->rem.s.Env.halted,
+                    pVM->rem.s.Env.exception_index
+                    );
+
+        rc = cpu_exec(&pVM->rem.s.Env);
+
+        RTLogPrintf("remR3RunLoggingStep: cpu_exec -> %#x interrupt_request=%#x halted=%d exception_index=%#x\n", rc,
+                    pVM->rem.s.Env.interrupt_request,
+                    pVM->rem.s.Env.halted,
+                    pVM->rem.s.Env.exception_index
+                    );
+
+        TMNotifyEndOfExecution(pVCpu);
+
+        switch (rc)
+        {
+#ifndef REM_USE_QEMU_SINGLE_STEP_FOR_LOGGING
+            /*
+             * The normal exit.
+             */
+            case EXCP_SINGLE_INSTR:
+                if (   !VM_FF_ISPENDING(pVM, VM_FF_ALL_REM_MASK)
+                    && !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_ALL_REM_MASK))
+                    continue;
+                RTLogPrintf("remR3RunLoggingStep: rc=VINF_SUCCESS w/ FFs (%#x/%#x)\n",
+                            pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions);
+                rc = VINF_SUCCESS;
+                break;
+
+#else
+            /*
+             * The normal exit, check for breakpoints at PC just to be sure.
+             */
+#endif
+            case EXCP_DEBUG:
+                rc = VINF_EM_DBG_STEPPED;
+                if (pVM->rem.s.Env.nb_breakpoints > 0)
+                {
+                    RTGCPTR     GCPtrPC = pVM->rem.s.Env.eip + pVM->rem.s.Env.segs[R_CS].base;
+                    int         iBP;
+                    for (iBP = 0; iBP < pVM->rem.s.Env.nb_breakpoints; iBP++)
+                        if (pVM->rem.s.Env.breakpoints[iBP] == GCPtrPC)
+                        {
+                            rc = VINF_EM_DBG_BREAKPOINT;
+                            RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_DEBUG rc=%Rrc iBP=%d GCPtrPC=%RGv\n", rc, iBP, GCPtrPC);
+                            break;
+                        }
+                }
+#ifdef REM_USE_QEMU_SINGLE_STEP_FOR_LOGGING
+                if (rc == VINF_EM_DBG_STEPPED)
+                {
+                    if (   !VM_FF_ISPENDING(pVM, VM_FF_ALL_REM_MASK)
+                        && !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_ALL_REM_MASK))
+                        continue;
+
+                    RTLogPrintf("remR3RunLoggingStep: rc=VINF_SUCCESS w/ FFs (%#x/%#x)\n",
+                                pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions);
+                    rc = VINF_SUCCESS;
+                }
+#endif
+                break;
+
+            /*
+             * If we take a trap or start servicing a pending interrupt, we might end up here.
+             * (Timer thread or some other thread wishing EMT's attention.)
+             */
+            case EXCP_INTERRUPT:
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_INTERRUPT rc=VINF_SUCCESS\n");
+                rc = VINF_SUCCESS;
+                break;
+
+            /*
+             * hlt instruction.
+             */
+            case EXCP_HLT:
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_HLT rc=VINF_EM_HALT\n");
+                rc = VINF_EM_HALT;
+                break;
+
+            /*
+             * The VM has halted.
+             */
+            case EXCP_HALTED:
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_HALTED rc=VINF_EM_HALT\n");
+                rc = VINF_EM_HALT;
+                break;
+
+            /*
+             * Switch to RAW-mode.
+             */
+            case EXCP_EXECUTE_RAW:
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_EXECUTE_RAW rc=VINF_EM_RESCHEDULE_RAW\n");
+                rc = VINF_EM_RESCHEDULE_RAW;
+                break;
+
+            /*
+             * Switch to hardware accelerated RAW-mode.
+             */
+            case EXCP_EXECUTE_HWACC:
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_EXECUTE_HWACC rc=VINF_EM_RESCHEDULE_HWACC\n");
+                rc = VINF_EM_RESCHEDULE_HWACC;
+                break;
+
+            /*
+             * An EM RC was raised (VMR3Reset/Suspend/PowerOff/some-fatal-error).
+             */
+            case EXCP_RC:
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_RC rc=%Rrc\n", pVM->rem.s.rc);
+                rc = pVM->rem.s.rc;
+                pVM->rem.s.rc = VERR_INTERNAL_ERROR;
+                break;
+
+            /*
+             * Figure out the rest when they arrive....
+             */
+            default:
+                AssertMsgFailed(("rc=%d\n", rc));
+                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> %d rc=VINF_EM_RESCHEDULE\n", rc);
+                rc = VINF_EM_RESCHEDULE;
+                break;
+        }
+        break;
+    }
+
+#ifdef REM_USE_QEMU_SINGLE_STEP_FOR_LOGGING
+    cpu_single_step(&pVM->rem.s.Env, 0);
+#else
+    pVM->rem.s.Env.interrupt_request &= ~(CPU_INTERRUPT_SINGLE_INSTR | CPU_INTERRUPT_SINGLE_INSTR_IN_FLIGHT);
+#endif
+    return rc;
+}
+
+
+/**
  * Runs code in recompiled mode.
  *
@@ -1079 +1275 @@
 {
     int rc;
+
+    if (RT_UNLIKELY(pVM->rem.s.Env.state & CPU_EMULATE_SINGLE_STEP))
+        return remR3RunLoggingStep(pVM, pVCpu);
+
+    Assert(pVM->rem.s.fInREM);
     Log2(("REMR3Run: (cs:eip=%04x:%RGv)\n", pVM->rem.s.Env.segs[R_CS].selector, (RTGCPTR)pVM->rem.s.Env.eip));
-    Assert(pVM->rem.s.fInREM);
 
     TMNotifyStartOfExecution(pVCpu);
@@ -1195 +1395 @@
  * Check if the cpu state is suitable for Raw execution.
  *
- * @returns boolean
+ * @returns true if RAW/HWACC mode is ok, false if we should stay in REM.
+ *
  * @param   env         The CPU env struct.
  * @param   eip         The EIP to check this for (might differ from env->eip).
@@ -1212 +1413 @@
     /* Update counter. */
     env->pVM->rem.s.cCanExecuteRaw++;
+
+    /* Never when single stepping+logging guest code. */
+    if (env->state & CPU_EMULATE_SINGLE_STEP)
+        return false;
 
     if (HWACCMIsEnabled(env->pVM))
@@ -3739 +3944 @@
      * Log registers if requested.
      */
-    if (!fLog2)
+    if (fLog2)
         DBGFR3InfoLog(pVM, "cpumguest", pszPrefix);
 

trunk/src/recompiler/cpu-exec.c ¶

@@ -372 +372 @@
                                 || !(env->eflags & IF_MASK)
                                 ||  (env->hflags & HF_INHIBIT_IRQ_MASK)
-                                ||  (env->state & CPU_RAW_HWACC)
+                                ||  (env->state & (CPU_RAW_HWACC | CPU_EMULATE_SINGLE_STEP))
                                )
                             {