Changeset 108434 in vbox

Timestamp:

Mar 4, 2025 11:24:21 AM (2 months ago)

Author:

vboxsync

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

167808

Message:

VMM/NEM/Hyper-V: Started implementing a NEM/Hyper-V specific APIC emulation utilizing the LocalApicEmulation feature of Hyper-V, bugref:9993

Location:

trunk

Files:

• include/VBox/vmm/pdmdev.h (modified) (1 diff)
• src/VBox/VMM/Makefile.kmk (modified) (1 diff)
• src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h (modified) (6 diffs)
• src/VBox/VMM/VMMR3/APICR3Nem-win.cpp (added)
• src/VBox/VMM/VMMR3/NEMR3Native-win.cpp (modified) (8 diffs)
• src/VBox/VMM/VMMR3/PDMDevice.cpp (modified) (1 diff)
• src/VBox/VMM/include/APICInternal.h (modified) (1 diff)
• src/VBox/VMM/include/NEMInternal.h (modified) (3 diffs)

trunk/include/VBox/vmm/pdmdev.h

@@ -755 +755 @@
 /** The PDM APIC device registration structure. */
 extern const PDMDEVREG g_DeviceAPIC;
+# if defined(RT_OS_WINDOWS)
+/** The PDM APIC device registration structure for the Hyper-V NEM. */
+extern const PDMDEVREG g_DeviceAPICNem;
+# endif
 #elif defined(VBOX_VMM_TARGET_ARMV8)
 /** The PDM GIC device registration structure. */

trunk/src/VBox/VMM/Makefile.kmk

@@ -311 +311 @@
  VBoxVMM_SOURCES.linux.amd64 += VMMR3/NEMR3Native-linux.cpp
 
- VBoxVMM_SOURCES.win.amd64 += VMMR3/NEMR3Native-win.cpp
+ VBoxVMM_SOURCES.win.amd64 += \
+        VMMR3/NEMR3Native-win.cpp \
+        VMMR3/APICR3Nem-win.cpp
+
  VBoxVMM_DEFS.win.amd64   += VBOX_WITH_NATIVE_NEM
  VBoxVMM_SDKS.win         += VBoxNtDll

trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h

@@ -365 +365 @@
         ADD_REG64(WHvRegisterPendingInterruption, 0);
 
-    /* Interruptibility state.  This can get a little complicated since we get
-       half of the state via HV_X64_VP_EXECUTION_STATE. */
-    if (   (fWhat & (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI))
-        ==          (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI) )
-    {
-        ADD_REG64(WHvRegisterInterruptState, 0);
-        if (CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx))
-            aValues[iReg - 1].InterruptState.InterruptShadow = 1;
-        aValues[iReg - 1].InterruptState.NmiMasked = CPUMAreInterruptsInhibitedByNmi(&pVCpu->cpum.GstCtx);
-    }
-    else if (fWhat & CPUMCTX_EXTRN_INHIBIT_INT)
-    {
-        if (   pVCpu->nem.s.fLastInterruptShadow
-            || CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx))
+    if (!pVM->nem.s.fLocalApicEmulation)
+    {
+        /* Interruptibility state.  This can get a little complicated since we get
+           half of the state via HV_X64_VP_EXECUTION_STATE. */
+        if (   (fWhat & (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI))
+            ==          (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI) )
         {
             ADD_REG64(WHvRegisterInterruptState, 0);
             if (CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx))
                 aValues[iReg - 1].InterruptState.InterruptShadow = 1;
-            /** @todo Retrieve NMI state, currently assuming it's zero. (yes this may happen on I/O) */
-            //if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
-            //    aValues[iReg - 1].InterruptState.NmiMasked = 1;
-        }
-    }
-    else
-        Assert(!(fWhat & CPUMCTX_EXTRN_INHIBIT_NMI));
-
-    /* Interrupt windows. Always set if active as Hyper-V seems to be forgetful. */
-    uint8_t const fDesiredIntWin = pVCpu->nem.s.fDesiredInterruptWindows;
-    if (   fDesiredIntWin
-        || pVCpu->nem.s.fCurrentInterruptWindows != fDesiredIntWin)
-    {
-        pVCpu->nem.s.fCurrentInterruptWindows = pVCpu->nem.s.fDesiredInterruptWindows;
-        Log8(("Setting WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin=%X\n", fDesiredIntWin));
-        ADD_REG64(WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin);
-        Assert(aValues[iReg - 1].DeliverabilityNotifications.NmiNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_NMI));
-        Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_REGULAR));
-        Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptPriority == (unsigned)((fDesiredIntWin & NEM_WIN_INTW_F_PRIO_MASK) >> NEM_WIN_INTW_F_PRIO_SHIFT));
-    }
-
-    /// @todo WHvRegisterPendingEvent
+            aValues[iReg - 1].InterruptState.NmiMasked = CPUMAreInterruptsInhibitedByNmi(&pVCpu->cpum.GstCtx);
+        }
+        else if (fWhat & CPUMCTX_EXTRN_INHIBIT_INT)
+        {
+            if (   pVCpu->nem.s.fLastInterruptShadow
+                || CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx))
+            {
+                ADD_REG64(WHvRegisterInterruptState, 0);
+                if (CPUMIsInInterruptShadow(&pVCpu->cpum.GstCtx))
+                    aValues[iReg - 1].InterruptState.InterruptShadow = 1;
+                /** @todo Retrieve NMI state, currently assuming it's zero. (yes this may happen on I/O) */
+                //if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
+                //    aValues[iReg - 1].InterruptState.NmiMasked = 1;
+            }
+        }
+        else
+            Assert(!(fWhat & CPUMCTX_EXTRN_INHIBIT_NMI));
+
+        /* Interrupt windows. Always set if active as Hyper-V seems to be forgetful. */
+        uint8_t const fDesiredIntWin = pVCpu->nem.s.fDesiredInterruptWindows;
+        if (   fDesiredIntWin
+            || pVCpu->nem.s.fCurrentInterruptWindows != fDesiredIntWin)
+        {
+            pVCpu->nem.s.fCurrentInterruptWindows = pVCpu->nem.s.fDesiredInterruptWindows;
+            Log8(("Setting WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin=%X\n", fDesiredIntWin));
+            ADD_REG64(WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin);
+            Assert(aValues[iReg - 1].DeliverabilityNotifications.NmiNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_NMI));
+            Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_REGULAR));
+            Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptPriority == (unsigned)((fDesiredIntWin & NEM_WIN_INTW_F_PRIO_MASK) >> NEM_WIN_INTW_F_PRIO_SHIFT));
+        }
+    }
+    else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_PIC))
+    {
+        Log8(("Setting WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin=%X fPicReadyForInterrupt=%RTbool\n",
+              pVCpu->nem.s.fDesiredInterruptWindows, pVCpu->nem.s.fPicReadyForInterrupt));
+
+        if (   pVCpu->nem.s.fDesiredInterruptWindows
+            && pVCpu->nem.s.fPicReadyForInterrupt)
+        {
+            ADD_REG64(WHvRegisterPendingEvent, 0);
+
+            uint8_t bInterrupt;
+            int rc = PDMGetInterrupt(pVCpu, &bInterrupt);
+            AssertRC(rc);
+
+            aValues[iReg - 1].Reg64                    = 0;
+            aValues[iReg - 1].ExtIntEvent.EventPending = 1;
+            aValues[iReg - 1].ExtIntEvent.EventType    = WHvX64PendingEventExtInt;
+            aValues[iReg - 1].ExtIntEvent.Vector       = bInterrupt;
+        }
+
+        if (!pVCpu->nem.s.fIrqWindowRegistered)
+        {
+            ADD_REG64(WHvX64RegisterDeliverabilityNotifications, 0);
+            aValues[iReg - 1].DeliverabilityNotifications.InterruptNotification = 1;
+            pVCpu->nem.s.fIrqWindowRegistered = true;
+        }
+    }
 
 #undef ADD_REG64
@@ -419 +447 @@
            pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues));
 #endif
+
+    pVCpu->nem.s.fPicReadyForInterrupt = false;
+
+    if (!iReg)
+        return VINF_SUCCESS;
+
     HRESULT hrc = WHvSetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues);
     if (SUCCEEDED(hrc))
@@ -1761 +1795 @@
           pExit->InterruptWindow.DeliverableType, RT_BOOL(pExit->VpContext.Rflags & X86_EFL_IF),
           pExit->VpContext.ExecutionState.InterruptShadow, pExit->VpContext.Cr8));
+
+    pVCpu->nem.s.fIrqWindowRegistered  = false;
+    pVCpu->nem.s.fPicReadyForInterrupt = true;
 
     /** @todo call nemHCWinHandleInterruptFF   */
@@ -2366 +2403 @@
             return nemR3WinHandleExitUnrecoverableException(pVM, pVCpu, pExit);
 
+        case WHvRunVpExitReasonX64ApicEoi:
+            Assert(pVM->nem.s.fLocalApicEmulation);
+            PDMIoApicBroadcastEoi(pVCpu->CTX_SUFF(pVM), pExit->ApicEoi.InterruptVector);
+            return VINF_SUCCESS;
+
         case WHvRunVpExitReasonUnsupportedFeature:
         case WHvRunVpExitReasonInvalidVpRegisterValue:
@@ -2391 +2433 @@
 NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleInterruptFF(PVMCC pVM, PVMCPUCC pVCpu, uint8_t *pfInterruptWindows)
 {
-    Assert(!TRPMHasTrap(pVCpu));
+    Assert(!TRPMHasTrap(pVCpu) && !pVM->nem.s.fLocalApicEmulation);
     RT_NOREF_PV(pVM);
 
@@ -2548 +2590 @@
          */
         pVCpu->nem.s.fDesiredInterruptWindows = 0;
-        if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_UPDATE_APIC | VMCPU_FF_INTERRUPT_PIC
-                                     | VMCPU_FF_INTERRUPT_NMI  | VMCPU_FF_INTERRUPT_SMI))
-        {
-            /* Try inject interrupt. */
-            rcStrict = nemHCWinHandleInterruptFF(pVM, pVCpu, &pVCpu->nem.s.fDesiredInterruptWindows);
-            if (rcStrict == VINF_SUCCESS)
-            { /* likely */ }
-            else
+        if (!pVM->nem.s.fLocalApicEmulation)
+        {
+            if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_UPDATE_APIC | VMCPU_FF_INTERRUPT_PIC
+                                         | VMCPU_FF_INTERRUPT_NMI  | VMCPU_FF_INTERRUPT_SMI))
             {
-                LogFlow(("NEM/%u: breaking: nemHCWinHandleInterruptFF -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
-                STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
-                break;
+                /* Try inject interrupt. */
+                rcStrict = nemHCWinHandleInterruptFF(pVM, pVCpu, &pVCpu->nem.s.fDesiredInterruptWindows);
+                if (rcStrict == VINF_SUCCESS)
+                { /* likely */ }
+                else
+                {
+                    LogFlow(("NEM/%u: breaking: nemHCWinHandleInterruptFF -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
+                    STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
+                    break;
+                }
             }
+        }
+        else
+        {
+            /* We only need to handle the PIC usign ExtInt here, the APIC is handled through the NEM APIC backend. */
+            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC));
+
+            if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_PIC))
+                pVCpu->nem.s.fDesiredInterruptWindows |= NEM_WIN_INTW_F_REGULAR;
         }
 

trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

@@ -163 +163 @@
 static decltype(WHvGetVirtualProcessorRegisters) *  g_pfnWHvGetVirtualProcessorRegisters;
 static decltype(WHvSetVirtualProcessorRegisters) *  g_pfnWHvSetVirtualProcessorRegisters;
+static decltype(WHvSuspendPartitionTime) *          g_pfnWHvSuspendPartitionTime;
+static decltype(WHvResumePartitionTime) *           g_pfnWHvResumePartitionTime;
+decltype(WHvGetVirtualProcessorState) *             g_pfnWHvGetVirtualProcessorState = NULL;
+decltype(WHvSetVirtualProcessorState) *             g_pfnWHvSetVirtualProcessorState = NULL;
+decltype(WHvGetVirtualProcessorInterruptControllerState)  *g_pfnWHvGetVirtualProcessorInterruptControllerState = NULL;
+decltype(WHvSetVirtualProcessorInterruptControllerState)  *g_pfnWHvSetVirtualProcessorInterruptControllerState = NULL;
+decltype(WHvGetVirtualProcessorInterruptControllerState2) *g_pfnWHvGetVirtualProcessorInterruptControllerState2 = NULL;
+decltype(WHvSetVirtualProcessorInterruptControllerState2) *g_pfnWHvSetVirtualProcessorInterruptControllerState2 = NULL;
+decltype(WHvRequestInterrupt) *                     g_pfnWHvRequestInterrupt;
 /** @} */
 
@@ -213 +222 @@
     NEM_WIN_IMPORT(0, false, WHvGetVirtualProcessorRegisters),
     NEM_WIN_IMPORT(0, false, WHvSetVirtualProcessorRegisters),
+    NEM_WIN_IMPORT(0, true,  WHvSuspendPartitionTime),
+    NEM_WIN_IMPORT(0, true,  WHvResumePartitionTime),
+    NEM_WIN_IMPORT(0, true,  WHvRequestInterrupt),
+    NEM_WIN_IMPORT(0, true,  WHvGetVirtualProcessorState),
+    NEM_WIN_IMPORT(0, true,  WHvSetVirtualProcessorState),
+    NEM_WIN_IMPORT(0, true,  WHvGetVirtualProcessorInterruptControllerState),
+    NEM_WIN_IMPORT(0, true,  WHvSetVirtualProcessorInterruptControllerState),
+    NEM_WIN_IMPORT(0, true,  WHvGetVirtualProcessorInterruptControllerState2),
+    NEM_WIN_IMPORT(0, true,  WHvSetVirtualProcessorInterruptControllerState2),
 
     NEM_WIN_IMPORT(1, true,  VidGetHvPartitionId),
@@ -285 +303 @@
 # define WHvGetVirtualProcessorRegisters            g_pfnWHvGetVirtualProcessorRegisters
 # define WHvSetVirtualProcessorRegisters            g_pfnWHvSetVirtualProcessorRegisters
+# define WHvSuspendPartitionTime                    g_pfnWHvSuspendPartitionTime
+# define WHvResumePartitionTime                     g_pfnWHvResumePartitionTime
+# define WHvRequestInterrupt                        g_pfnWHvRequestInterrupt
+# define WHvGetVirtualProcessorState                g_pfnWHvGetVirtualProcessorState
+# define WHvSetVirtualProcessorState                g_pfnWHvSetVirtualProcessorState
+# define WHvGetVirtualProcessorInterruptControllerState     g_pfnWHvGetVirtualProcessorInterruptControllerState
+# define WHvGetVirtualProcessorInterruptControllerState2    g_pfnWHvGetVirtualProcessorInterruptControllerState2
 
 # define VidMessageSlotHandleAndGetNext             g_pfnVidMessageSlotHandleAndGetNext
@@ -585 +610 @@
                 *g_aImports[i].ppfn = NULL;
 
-                LogRel(("NEM:  %s: Failed to import %s!%s: %Rrc",
+                LogRel(("NEM:  %s: Failed to import %s!%s: %Rrc\n",
                         g_aImports[i].fOptional ? "info" : fForced ? "fatal" : "error",
                         s_apszDllNames[g_aImports[i].idxDll], g_aImports[i].pszName, rc2));
@@ -740 +765 @@
         NEM_LOG_REL_CAP_SUB_EX("Unknown features", "%#RX64", Caps.ExtendedVmExits.AsUINT64 & ~fKnownVmExits);
     pVM->nem.s.fSpeculationControl = RT_BOOL(Caps.Features.SpeculationControl);
+    pVM->nem.s.fLocalApicEmulation = RT_BOOL(Caps.Features.LocalApicEmulation);
     /** @todo RECHECK: WHV_CAPABILITY_FEATURES typedef. */
 
@@ -1255 +1281 @@
                              hrc, RTNtLastStatusValue(), RTNtLastErrorValue());
 
-    int rc;
+    int rc = VINF_SUCCESS;
 
     /*
@@ -1281 +1307 @@
         if (SUCCEEDED(hrc))
         {
+            RT_ZERO(Property);
             /*
-             * We'll continue setup in nemR3NativeInitAfterCPUM.
+             * If the APIC is enabled and LocalApicEmulation is supported we'll use Hyper-V's APIC emulation
+             * for best performance.
              */
-            pVM->nem.s.fCreatedEmts     = false;
-            pVM->nem.s.hPartition       = hPartition;
-            LogRel(("NEM: Created partition %p.\n", hPartition));
-            return VINF_SUCCESS;
+            PCFGMNODE pCfgmApic = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/Devices/apic");
+            if (   pCfgmApic
+                && pVM->nem.s.fLocalApicEmulation
+                && 0) /** @todo Finish */
+            {
+                /* If setting this fails log an error but continue. */
+                Property.LocalApicEmulationMode = WHvX64LocalApicEmulationModeXApic;
+                hrc = WHvSetPartitionProperty(hPartition, WHvPartitionPropertyCodeLocalApicEmulationMode  , &Property, sizeof(Property));
+                if (FAILED(hrc))
+                {
+                    LogRel(("NEM: Failed setting WHvPartitionPropertyCodeLocalApicEmulationMode to WHvX64LocalApicEmulationModeXApic: %Rhrc (Last=%#x/%u)",
+                            hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+                    pVM->nem.s.fLocalApicEmulation = false;
+                }
+                else
+                {
+                    /* Rewrite the configuration tree to point to our APIC emulation. */
+                    PCFGMNODE pCfgmDev = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/Devices");
+                    Assert(pCfgmDev);
+
+                    PCFGMNODE pCfgmApicHv = NULL;
+                    rc = CFGMR3InsertNode(pCfgmDev, "apic-nem", &pCfgmApicHv);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = CFGMR3CopyTree(pCfgmApicHv, pCfgmApic, CFGM_COPY_FLAGS_IGNORE_EXISTING_KEYS | CFGM_COPY_FLAGS_IGNORE_EXISTING_VALUES);
+                        if (RT_SUCCESS(rc))
+                            CFGMR3RemoveNode(pCfgmApic);
+                    }
+
+                    if (RT_FAILURE(rc))
+                        rc = RTErrInfoSetF(pErrInfo, rc, "Failed replace APIC device config with Hyper-V one");
+                }
+            }
+            else
+                pVM->nem.s.fLocalApicEmulation = false;
+
+
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * We'll continue setup in nemR3NativeInitAfterCPUM.
+                 */
+                pVM->nem.s.fCreatedEmts     = false;
+                pVM->nem.s.hPartition       = hPartition;
+                LogRel(("NEM: Created partition %p.\n", hPartition));
+                return VINF_SUCCESS;
+            }
         }
 
@@ -1321 +1392 @@
      */
     PCFGMNODE pCfg = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/Devices/apic/0/Config");
+    if (!pCfg)
+        pCfg = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/Devices/apic-nem/0/Config");
     if (pCfg)
     {

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

@@ -721 +721 @@
     int rc = pdmR3DevReg_Register(&RegCB.Core, &g_DeviceAPIC);
     AssertRCReturn(rc, rc);
+
+# if defined(RT_OS_WINDOWS)
+    /* Register the internal VMM APIC device for NEM mode. */
+    rc = pdmR3DevReg_Register(&RegCB.Core, &g_DeviceAPICNem);
+    AssertRCReturn(rc, rc);
+# endif
 #endif
 

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

@@ -46 +46 @@
 /** The VirtualBox APIC backend table. */
 extern const PDMAPICBACKEND g_ApicBackend;
+#if defined(RT_OS_WINDOWS)
+/** The Hyper-V APIC backend. */
+extern const PDMAPICBACKEND g_ApicNemBackend;
+# endif
 #endif
 

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

@@ -267 +267 @@
     /** Whether to export/import IA32_SPEC_CTRL. */
     bool                        fDoIa32SpecCtrl : 1;
+    /** WHvX64LocalApicEmulationModeXApic is used. */
+    bool                        fLocalApicEmulation : 1;
 #  ifdef NEM_WIN_WITH_A20
     /** Set if we've started more than one CPU and cannot mess with A20. */
@@ -284 +286 @@
         uint64_t                u64;
 # ifdef _WINHVAPIDEFS_H_
-        /** Interpreed features. */
+        /** Interpreted features. */
         WHV_PROCESSOR_FEATURES  u;
 # endif
@@ -513 +515 @@
     /** The desired state of the interrupt windows (NEM_WIN_INTW_F_XXX). */
     uint8_t                     fDesiredInterruptWindows;
+    /** Cached TPR value. */
+    uint8_t                     bTpr;
     /** Last copy of HV_X64_VP_EXECUTION_STATE::InterruptShadow. */
     bool                        fLastInterruptShadow : 1;
+    /** Flag whether the IRQ window notification was registered (for injecting PIC interrupts). */
+    bool                        fIrqWindowRegistered: 1;
+    /** Flag whether it is possible inject a PIC interrupt. */
+    bool                        fPicReadyForInterrupt: 1;
     uint32_t                    uPadding;
     /** The VID_MSHAGN_F_XXX flags.