VirtualBox

Changeset 2124 in vbox


Ignore:
Timestamp:
Apr 17, 2007 12:25:17 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
20445
Message:

TRPM changes to assert and report trap/interrupt types accurately.

Location:
trunk/src/VBox/VMM
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/EM.cpp

    r2063 r2124  
    15321532     */
    15331533    uint8_t         u8TrapNo;
    1534     bool            fSoftwareInterrupt;
     1534    TRPMEVENT       enmType;;
    15351535    RTGCUINT        uErrorCode;
    15361536    RTGCUINTPTR     uCR2;
    1537     int rc = TRPMQueryTrapAll(pVM, &u8TrapNo, &fSoftwareInterrupt, &uErrorCode, &uCR2);
     1537    int rc = TRPMQueryTrapAll(pVM, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
    15381538    if (VBOX_FAILURE(rc))
    15391539    {
    … …  
    16141614    int rc2 = PGMGstGetPage(pVM, uCR2, &fFlags, &GCPhys);
    16151615    Log(("emR3RawGuestTrap: cs:eip=%04x:%08x: trap=%02x err=%08x cr2=%08x cr0=%08x%s: Phys=%VGp fFlags=%08llx %s %s %s%s rc2=%d\n",
    1616          pCtx->cs, pCtx->eip, u8TrapNo, uErrorCode, uCR2, pCtx->cr0, fSoftwareInterrupt ? " software" : "",  GCPhys, fFlags,
     1616         pCtx->cs, pCtx->eip, u8TrapNo, uErrorCode, uCR2, pCtx->cr0, (enmType == TRPM_SOFTWARE_INT) ? " software" : "",  GCPhys, fFlags,
    16171617         fFlags & X86_PTE_P  ? "P " : "NP", fFlags & X86_PTE_US ? "U"  : "S",
    16181618         fFlags & X86_PTE_RW ? "RW" : "R0", fFlags & X86_PTE_G  ? " G" : "", rc2));
    … …  
    17001700    uint8_t         u8TrapNo;
    17011701    int             rc;
    1702     bool            fSoftwareInterrupt;
     1702    TRPMEVENT       enmType;
    17031703    RTGCUINT        uErrorCode;
    17041704    RTGCUINTPTR     uCR2;
    … …  
    17221722    else
    17231723    {
    1724         rc = TRPMQueryTrapAll(pVM, &u8TrapNo, &fSoftwareInterrupt, &uErrorCode, &uCR2);
     1724        rc = TRPMQueryTrapAll(pVM, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
    17251725        if (VBOX_FAILURE(rc))
    17261726        {

  • trunk/src/VBox/VMM/HWACCM.cpp

    r1890 r2124  
    453453    Assert(pVM->fHWACCMEnabled);
    454454
     455#if 0
     456    /* AMD SVM supports real & protected mode with or without paging. */
     457    if (pVM->hwaccm.s.svm.fEnabled)
     458    {
     459        pVM->hwaccm.s.fActive = true;
     460        return true;
     461    }
     462#endif
     463
    455464    /* @todo we can support real-mode by using v86 and protected mode without paging with identity mapped pages.
    456465     * (but do we really care?)

  • trunk/src/VBox/VMM/TRPM.cpp

    r1998 r2124  
    411411
    412412/** TRPM saved state version. */
    413 #define TRPM_SAVED_STATE_VERSION    7
     413#define TRPM_SAVED_STATE_VERSION    8
    414414
    415415
    … …  
    713713    PTRPM pTrpm = &pVM->trpm.s;
    714714    SSMR3PutUInt(pSSM,      pTrpm->uActiveVector);
    715     SSMR3PutUInt(pSSM,      pTrpm->fActiveSoftwareInterrupt);
     715    SSMR3PutUInt(pSSM,      pTrpm->enmActiveType);
    716716    SSMR3PutGCUInt(pSSM,    pTrpm->uActiveErrorCode);
    717717    SSMR3PutGCUIntPtr(pSSM, pTrpm->uActiveCR2);
    718718    SSMR3PutGCUInt(pSSM,    pTrpm->uSavedVector);
    719     SSMR3PutUInt(pSSM,      pTrpm->fSavedSoftwareInterrupt);
     719    SSMR3PutUInt(pSSM,      pTrpm->enmSavedType);
    720720    SSMR3PutGCUInt(pSSM,    pTrpm->uSavedErrorCode);
    721721    SSMR3PutGCUIntPtr(pSSM, pTrpm->uSavedCR2);
    … …  
    774774    PTRPM pTrpm = &pVM->trpm.s;
    775775    SSMR3GetUInt(pSSM,      &pTrpm->uActiveVector);
    776     SSMR3GetUInt(pSSM,      &pTrpm->fActiveSoftwareInterrupt);
     776    SSMR3GetUInt(pSSM,      (uint32_t *)&pTrpm->enmActiveType);
    777777    SSMR3GetGCUInt(pSSM,    &pTrpm->uActiveErrorCode);
    778778    SSMR3GetGCUIntPtr(pSSM, &pTrpm->uActiveCR2);
    779779    SSMR3GetGCUInt(pSSM,    &pTrpm->uSavedVector);
    780     SSMR3GetUInt(pSSM,      &pTrpm->fSavedSoftwareInterrupt);
     780    SSMR3GetUInt(pSSM,      (uint32_t *)&pTrpm->enmSavedType);
    781781    SSMR3GetGCUInt(pSSM,    &pTrpm->uSavedErrorCode);
    782782    SSMR3GetGCUIntPtr(pSSM, &pTrpm->uSavedCR2);
    … …  
    13191319            if (HWACCMR3IsActive(pVM))
    13201320            {
    1321                 rc = TRPMAssertTrap(pVM, u8Interrupt, false);
     1321                rc = TRPMAssertTrap(pVM, u8Interrupt, enmEvent);
    13221322                AssertRC(rc);
    13231323                STAM_COUNTER_INC(&pVM->trpm.s.paStatForwardedIRQR3[u8Interrupt]);

  • trunk/src/VBox/VMM/TRPMInternal.h

    r1328 r2124  
    9797    RTUINT          uActiveVector;
    9898
    99     /** If set the active trap is a software interrupt. */
    100     RTUINT          fActiveSoftwareInterrupt;
     99    /** Active trap type. */
     100    TRPMEVENT       enmActiveType;
    101101
    102102    /** Errorcode for the active interrupt/trap. */
    … …  
    109109    RTGCUINT        uSavedVector;
    110110
    111     /** Saved software interrupt indicator. */
    112     RTUINT          fSavedSoftwareInterrupt;
     111    /** Saved trap type. */
     112    TRPMEVENT       enmSavedType;
    113113
    114114    /** Saved errorcode. */

  • trunk/src/VBox/VMM/TRPMInternal.mac

    r1580 r2124  
    3535    .offVM              resd 1
    3636    .uActiveVector      resd 1
    37     .fActiveSoftwareInterrupt resd 1
     37    .enmActiveType      resd 1
    3838    .uActiveErrorCode   resd 1
    3939    .uActiveCR2         resd 1
    4040    .uSavedVector       resd 1
    41     .fSavedSoftwareInterrupt resd 1
     41    .enmSavedType      resd 1
    4242    .uSavedErrorCode    resd 1
    4343    .uSavedCR2          resd 1

  • trunk/src/VBox/VMM/VMM.cpp

    r1890 r2124  
    23712371            /* Trap? */
    23722372            uint32_t        uEIP = CPUMGetHyperEIP(pVM);
    2373             bool            fSoftwareInterrupt = false;
     2373            TRPMEVENT       enmType;
    23742374            uint8_t         u8TrapNo   =       0xce;
    23752375            RTGCUINT        uErrorCode = 0xdeadface;
    23762376            RTGCUINTPTR     uCR2       = 0xdeadface;
    2377             int rc2 = TRPMQueryTrapAll(pVM, &u8TrapNo, &fSoftwareInterrupt, &uErrorCode, &uCR2);
     2377            int rc2 = TRPMQueryTrapAll(pVM, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
    23782378            if (VBOX_SUCCESS(rc2))
    23792379                pHlp->pfnPrintf(pHlp,
    2380                                 "!! TRAP=%02x ERRCD=%VGv CR2=%VGv EIP=%VGv fSoft=%d\n",
    2381                                 u8TrapNo, uErrorCode, uCR2, uEIP, fSoftwareInterrupt);
     2380                                "!! TRAP=%02x ERRCD=%VGv CR2=%VGv EIP=%VGv Type=%d\n",
     2381                                u8TrapNo, uErrorCode, uCR2, uEIP, enmType);
    23822382            else
    23832383                pHlp->pfnPrintf(pHlp,

  • trunk/src/VBox/VMM/VMMAll/TRPMAll.cpp

    r2117 r2124  
    5050 * @param   pVM                     The virtual machine.
    5151 * @param   pu8TrapNo               Where to store the trap number.
    52  * @param   pfSoftwareInterrupt     Where to store the software interrupt indicator.
    53  */
    54 TRPMDECL(int)  TRPMQueryTrap(PVM pVM, uint8_t *pu8TrapNo, bool *pfSoftwareInterrupt)
     52 * @param   pEnmType                Where to store the trap type
     53 */
     54TRPMDECL(int)  TRPMQueryTrap(PVM pVM, uint8_t *pu8TrapNo, TRPMEVENT *pEnmType)
    5555{
    5656    /*
    … …  
    6161        if (pu8TrapNo)
    6262            *pu8TrapNo = (uint8_t)pVM->trpm.s.uActiveVector;
    63         if (pfSoftwareInterrupt)
    64             *pfSoftwareInterrupt = !!pVM->trpm.s.fActiveSoftwareInterrupt;
     63        if (pEnmType)
     64            *pEnmType = pVM->trpm.s.enmActiveType;
    6565        return VINF_SUCCESS;
    6666    }
    … …  
    172172 * @param   pVM                 The virtual machine.
    173173 * @param   u8TrapNo            The trap vector to assert.
    174  * @param   fSoftwareInterrupt  Indicate if it's a software interrupt or not.
    175  */
    176 TRPMDECL(int)  TRPMAssertTrap(PVM pVM, uint8_t u8TrapNo, bool fSoftwareInterrupt)
    177 {
    178     Log2(("TRPMAssertTrap: u8TrapNo=%02x fSoftwareInterrupt=%d\n", u8TrapNo, fSoftwareInterrupt));
     174 * @param   enmType             Trap type.
     175 */
     176TRPMDECL(int)  TRPMAssertTrap(PVM pVM, uint8_t u8TrapNo, TRPMEVENT enmType)
     177{
     178    Log2(("TRPMAssertTrap: u8TrapNo=%02x type=%d\n", u8TrapNo, enmType));
    179179
    180180    /*
    … …  
    188188
    189189    pVM->trpm.s.uActiveVector               = u8TrapNo;
    190     pVM->trpm.s.fActiveSoftwareInterrupt    = fSoftwareInterrupt;
     190    pVM->trpm.s.enmActiveType               = enmType;
    191191    pVM->trpm.s.uActiveErrorCode            = ~0;
    192192    pVM->trpm.s.uActiveCR2                  = 0xdeadface;
    … …  
    260260{
    261261    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
    262     return !!pVM->trpm.s.fActiveSoftwareInterrupt;
     262    return (pVM->trpm.s.enmActiveType == TRPM_SOFTWARE_INT);
    263263}
    264264
    … …  
    283283 * @param   pVM                     The virtual machine.
    284284 * @param   pu8TrapNo               Where to store the trap number.
    285  * @param   pfSoftwareInterrupt     Where to store the software interrupt indicator.
     285 * @param   pEnmType                Where to store the trap type
    286286 * @param   puErrorCode             Where to store the error code associated with some traps.
    287287 *                                  ~0U is stored if the trap has no error code.
    288288 * @param   puCR2                   Where to store the CR2 associated with a trap 0E.
    289289 */
    290 TRPMDECL(int)  TRPMQueryTrapAll(PVM pVM, uint8_t *pu8TrapNo, bool *pfSoftwareInterrupt, PRTGCUINT puErrorCode, PRTGCUINTPTR puCR2)
     290TRPMDECL(int)  TRPMQueryTrapAll(PVM pVM, uint8_t *pu8TrapNo, TRPMEVENT *pEnmType, PRTGCUINT puErrorCode, PRTGCUINTPTR puCR2)
    291291{
    292292    /*
    … …  
    297297
    298298    if (pu8TrapNo)
    299         *pu8TrapNo              = (uint8_t)pVM->trpm.s.uActiveVector;
    300     if (pfSoftwareInterrupt)
    301         *pfSoftwareInterrupt    = !!pVM->trpm.s.fActiveSoftwareInterrupt;
     299        *pu8TrapNo      = (uint8_t)pVM->trpm.s.uActiveVector;
     300    if (pEnmType)
     301        *pEnmType       = pVM->trpm.s.enmActiveType;
    302302    if (puErrorCode)
    303         *puErrorCode            = pVM->trpm.s.uActiveErrorCode;
     303        *puErrorCode    = pVM->trpm.s.uActiveErrorCode;
    304304    if (puCR2)
    305         *puCR2                  = pVM->trpm.s.uActiveCR2;
     305        *puCR2          = pVM->trpm.s.uActiveCR2;
    306306
    307307    return VINF_SUCCESS;
    … …  
    320320TRPMDECL(void) TRPMSaveTrap(PVM pVM)
    321321{
    322     pVM->trpm.s.uSavedVector            = pVM->trpm.s.uActiveVector;
    323     pVM->trpm.s.fSavedSoftwareInterrupt = pVM->trpm.s.fActiveSoftwareInterrupt;
    324     pVM->trpm.s.uSavedErrorCode         = pVM->trpm.s.uActiveErrorCode;
    325     pVM->trpm.s.uSavedCR2               = pVM->trpm.s.uActiveCR2;
     322    pVM->trpm.s.uSavedVector        = pVM->trpm.s.uActiveVector;
     323    pVM->trpm.s.enmSavedType        = pVM->trpm.s.enmActiveType;
     324    pVM->trpm.s.uSavedErrorCode     = pVM->trpm.s.uActiveErrorCode;
     325    pVM->trpm.s.uSavedCR2           = pVM->trpm.s.uActiveCR2;
    326326}
    327327
    … …  
    336336TRPMDECL(void) TRPMRestoreTrap(PVM pVM)
    337337{
    338     pVM->trpm.s.uActiveVector            = pVM->trpm.s.uSavedVector;
    339     pVM->trpm.s.fActiveSoftwareInterrupt = pVM->trpm.s.fSavedSoftwareInterrupt;
    340     pVM->trpm.s.uActiveErrorCode         = pVM->trpm.s.uSavedErrorCode;
    341     pVM->trpm.s.uActiveCR2               = pVM->trpm.s.uSavedCR2;
     338    pVM->trpm.s.uActiveVector       = pVM->trpm.s.uSavedVector;
     339    pVM->trpm.s.enmActiveType       = pVM->trpm.s.enmSavedType;
     340    pVM->trpm.s.uActiveErrorCode    = pVM->trpm.s.uSavedErrorCode;
     341    pVM->trpm.s.uActiveCR2          = pVM->trpm.s.uSavedCR2;
    342342}
    343343
    … …  
    761761/** @todo dispatch the trap. */
    762762    pVM->trpm.s.uActiveVector            = enmXcpt;
    763     pVM->trpm.s.fActiveSoftwareInterrupt = false;
     763    pVM->trpm.s.enmActiveType            = TRPM_TRAP;
    764764    pVM->trpm.s.uActiveErrorCode         = 0xdeadbeef;
    765765    pVM->trpm.s.uActiveCR2               = 0xdeadface;
    … …  
    788788/** @todo dispatch the trap. */
    789789    pVM->trpm.s.uActiveVector            = enmXcpt;
    790     pVM->trpm.s.fActiveSoftwareInterrupt = false;
     790    pVM->trpm.s.enmActiveType            = TRPM_TRAP;
    791791    pVM->trpm.s.uActiveErrorCode         = uErr;
    792792    pVM->trpm.s.uActiveCR2               = 0xdeadface;
    … …  
    816816/** @todo dispatch the trap. */
    817817    pVM->trpm.s.uActiveVector            = enmXcpt;
    818     pVM->trpm.s.fActiveSoftwareInterrupt = false;
     818    pVM->trpm.s.enmActiveType            = TRPM_TRAP;
    819819    pVM->trpm.s.uActiveErrorCode         = uErr;
    820820    pVM->trpm.s.uActiveCR2               = uCR2;

  • trunk/src/VBox/VMM/VMMGC/TRPMGCHandlers.cpp

    r2066 r2124  
    202202
    203203            /* Assert the trap and go to the recompiler to dispatch it. */
    204             TRPMAssertTrap(pVM, u8Interrupt, false);
     204            TRPMAssertTrap(pVM, u8Interrupt, TRPM_HARDWARE_INT);
    205205
    206206            STAM_PROFILE_ADV_START(&pVM->trpm.s.aStatGCTraps[uOldActiveVector], a);
    … …  
    558558
    559559            pVM->trpm.s.uActiveVector = (pVM->trpm.s.uActiveErrorCode & X86_TRAP_ERR_SEL_MASK) >> X86_TRAP_ERR_SEL_SHIFT;
    560             pVM->trpm.s.fActiveSoftwareInterrupt = true;
     560            pVM->trpm.s.enmActiveType = TRPM_SOFTWARE_INT;
    561561            return trpmGCExitTrap(pVM, VINF_EM_RAW_RING_SWITCH_INT, pRegFrame);
    562562        }
    … …  
    664664
    665665            pVM->trpm.s.uActiveVector = (pVM->trpm.s.uActiveErrorCode & X86_TRAP_ERR_SEL_MASK) >> X86_TRAP_ERR_SEL_SHIFT;
    666             pVM->trpm.s.fActiveSoftwareInterrupt = true;
     666            pVM->trpm.s.enmActiveType = TRPM_SOFTWARE_INT;
    667667            return trpmGCExitTrap(pVM, VINF_EM_RAW_RING_SWITCH_INT, pRegFrame);
    668668        }

  • trunk/src/VBox/VMM/VMMGC/TRPMGCHandlersA.asm

    r1645 r2124  
    2828%include "TRPMInternal.mac"
    2929%include "VBox/err.mac"
     30%include "VBox/trpm.mac"
    3031
    3132
    … …  
    334335    mov     edx, [esp + 4h + ESPOFF]       ; error code
    335336    mov     [eax + TRPM.uActiveErrorCode], edx
    336     mov     dword [eax + TRPM.fActiveSoftwareInterrupt], 0
     337    mov     dword [eax + TRPM.enmActiveType], TRPM_TRAP
    337338    mov     edx, cr2                       ;; @todo Check how expensive cr2 reads are!
    338339    mov     dword [eax + TRPM.uActiveCR2], edx
    … …  
    804805    mov     [eax + TRPM.uActiveVector], edx
    805806    xor     edx, edx
    806     mov     [eax + TRPM.fActiveSoftwareInterrupt], edx
     807    mov     dword [eax + TRPM.enmActiveType], TRPM_HARDWARE_INT
    807808    dec     edx
    808809    mov     [eax + TRPM.uActiveErrorCode], edx

  • trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp

    r2097 r2124  
    212212            if (VBOX_SUCCESS(rc))
    213213            {
    214                 rc = TRPMAssertTrap(pVM, u8Interrupt, false);
     214                rc = TRPMAssertTrap(pVM, u8Interrupt, TRPM_HARDWARE_INT);
    215215                AssertRC(rc);
    216216            }
    … …  
    233233        rc = TRPMQueryTrapAll(pVM, &u8Vector, 0, 0, 0);
    234234        AssertRC(rc);
    235         Assert(u8Vector >= 0x20);
    236235    }
    237236#endif
    … …  
    244243        uint8_t     u8Vector;
    245244        int         rc;
    246         bool        fSoftwareInt;
     245        TRPMEVENT   enmType;
    247246        SVM_EVENT   Event;
    248247        uint32_t    u32ErrorCode;
    … …  
    251250
    252251        /* If a new event is pending, then dispatch it now. */
    253         rc = TRPMQueryTrapAll(pVM, &u8Vector, &fSoftwareInt, &u32ErrorCode, 0);
     252        rc = TRPMQueryTrapAll(pVM, &u8Vector, &enmType, &u32ErrorCode, 0);
    254253        AssertRC(rc);
    255         Assert(pCtx->eflags.Bits.u1IF == 1 || u8Vector < 0x20);
    256         Assert(fSoftwareInt == false);
     254        Assert(pCtx->eflags.Bits.u1IF == 1 || enmType == TRPM_TRAP);
     255        Assert(enmType != TRPM_SOFTWARE_INT);
    257256
    258257        /* Clear the pending trap. */
    … …  
    264263        Event.n.u32ErrorCode = u32ErrorCode;
    265264
    266         switch (u8Vector) {
    267         case 8:
    268         case 10:
    269         case 11:
    270         case 12:
    271         case 13:
    272         case 14:
    273         case 17:
    274             /* Valid error codes. */
    275             Event.n.u1ErrorCodeValid = 1;
    276             break;
    277         default:
    278             break;
    279         }
    280 
    281         if (u8Vector == X86_XCPT_NMI)
    282             Event.n.u3Type = SVM_EVENT_NMI;
    283         else
    284         if (u8Vector < 0x20)
    285             Event.n.u3Type = SVM_EVENT_EXCEPTION;
     265        if (enmType == TRPM_TRAP)
     266        {
     267            switch (u8Vector) {
     268            case 8:
     269            case 10:
     270            case 11:
     271            case 12:
     272            case 13:
     273            case 14:
     274            case 17:
     275                /* Valid error codes. */
     276                Event.n.u1ErrorCodeValid = 1;
     277                break;
     278            default:
     279                break;
     280            }
     281            if (u8Vector == X86_XCPT_NMI)
     282                Event.n.u3Type = SVM_EVENT_NMI;
     283            else
     284                Event.n.u3Type = SVM_EVENT_EXCEPTION;
     285        }
    286286        else
    287287            Event.n.u3Type = SVM_EVENT_EXTERNAL_IRQ;
    … …  
    321321    {
    322322        SVM_WRITE_SELREG(CS, cs);
    323         Assert(pVMCB->guest.CS.u16Sel || !pVMCB->guest.CS.u16Attr);
     323        Assert(pVMCB->guest.CS.u16Sel || !pVMCB->guest.CS.u16Attr || !(pCtx->cr0 & X86_CR0_PE));
    324324
    325325        SVM_WRITE_SELREG(SS, ss);
    326         Assert(pVMCB->guest.SS.u16Sel || !pVMCB->guest.SS.u16Attr);
     326        Assert(pVMCB->guest.SS.u16Sel || !pVMCB->guest.SS.u16Attr || !(pCtx->cr0 & X86_CR0_PE));
    327327
    328328        SVM_WRITE_SELREG(DS, ds);
    329         Assert(pVMCB->guest.DS.u16Sel || !pVMCB->guest.DS.u16Attr);
     329        Assert(pVMCB->guest.DS.u16Sel || !pVMCB->guest.DS.u16Attr || !(pCtx->cr0 & X86_CR0_PE));
    330330
    331331        SVM_WRITE_SELREG(ES, es);
    332         Assert(pVMCB->guest.ES.u16Sel || !pVMCB->guest.ES.u16Attr);
     332        Assert(pVMCB->guest.ES.u16Sel || !pVMCB->guest.ES.u16Attr || !(pCtx->cr0 & X86_CR0_PE));
    333333
    334334        SVM_WRITE_SELREG(FS, fs);
    335         Assert(pVMCB->guest.FS.u16Sel || !pVMCB->guest.FS.u16Attr);
     335        Assert(pVMCB->guest.FS.u16Sel || !pVMCB->guest.FS.u16Attr || !(pCtx->cr0 & X86_CR0_PE));
    336336
    337337        SVM_WRITE_SELREG(GS, gs);
    338         Assert(pVMCB->guest.GS.u16Sel || !pVMCB->guest.GS.u16Attr);
     338        Assert(pVMCB->guest.GS.u16Sel || !pVMCB->guest.GS.u16Attr || !(pCtx->cr0 & X86_CR0_PE));
    339339    }
    340340
    … …  
    889889            Log2(("Page fault at %VGv cr2=%VGv error code %x\n", pCtx->eip, uFaultAddress, errCode));
    890890            /* Exit qualification contains the linear address of the page fault. */
    891             TRPMAssertTrap(pVM, X86_XCPT_PF, false);
     891            TRPMAssertTrap(pVM, X86_XCPT_PF, TRPM_TRAP);
    892892            TRPMSetErrorCode(pVM, errCode);
    893893            TRPMSetFaultAddress(pVM, uFaultAddress);
    … …  
    10011001                break;
    10021002            }
    1003 
    10041003            Log(("Trap %x at %VGv\n", vector, pCtx->eip));
    10051004            SVMR0InjectEvent(pVM, pVMCB, pCtx, &Event);

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r2076 r2124  
    328328            if (VBOX_SUCCESS(rc))
    329329            {
    330                 rc = TRPMAssertTrap(pVM, u8Interrupt, false);
     330                rc = TRPMAssertTrap(pVM, u8Interrupt, TRPM_HARDWARE_INT);
    331331                AssertRC(rc);
    332332            }
    … …  
    349349        rc = TRPMQueryTrapAll(pVM, &u8Vector, 0, 0, 0);
    350350        AssertRC(rc);
    351         Assert(u8Vector >= 0x20);
    352351    }
    353352#endif
    … …  
    360359        uint8_t     u8Vector;
    361360        int         rc;
    362         bool        fSoftwareInt;
     361        TRPMEVENT   enmType;
    363362        RTGCUINTPTR intInfo, errCode;
    364363
    365364        /* If a new event is pending, then dispatch it now. */
    366         rc = TRPMQueryTrapAll(pVM, &u8Vector, &fSoftwareInt, &errCode, 0);
    367         AssertRC(rc);
    368         Assert(pCtx->eflags.Bits.u1IF == 1 || u8Vector < 0x20);
    369         Assert(fSoftwareInt == false);
     365        rc = TRPMQueryTrapAll(pVM, &u8Vector, &enmType, &errCode, 0);
     366        AssertRC(rc);
     367        Assert(pCtx->eflags.Bits.u1IF == 1 || enmType == TRPM_TRAP);
     368        Assert(enmType != TRPM_SOFTWARE_INT);
    370369
    371370        /* Clear the pending trap. */
    … …  
    376375        intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
    377376
    378         switch (u8Vector) {
    379         case 8:
    380         case 10:
    381         case 11:
    382         case 12:
    383         case 13:
    384         case 14:
    385         case 17:
    386             /* Valid error codes. */
    387             intInfo |= VMX_EXIT_INTERRUPTION_INFO_ERROR_CODE_VALID;
    388             break;
    389         default:
    390             break;
    391         }
    392 
    393         if (u8Vector == X86_XCPT_BP || u8Vector == X86_XCPT_OF)
    394             intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
    395         else
    396         if (u8Vector < 0x20)
    397             intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_HWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
     377        if (enmType == TRPM_TRAP)
     378        {
     379            switch (u8Vector) {
     380            case 8:
     381            case 10:
     382            case 11:
     383            case 12:
     384            case 13:
     385            case 14:
     386            case 17:
     387                /* Valid error codes. */
     388                intInfo |= VMX_EXIT_INTERRUPTION_INFO_ERROR_CODE_VALID;
     389                break;
     390            default:
     391                break;
     392            }
     393            if (u8Vector == X86_XCPT_BP || u8Vector == X86_XCPT_OF)
     394                intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
     395            else
     396                intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_HWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
     397        }
    398398        else
    399399            intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_EXT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
    … …  
    756756#endif
    757757    AssertRC(rc);
    758 
    759758
    760759    /* Done. */
    … …  
    12711270                Log2(("Page fault at %VGv error code %x\n", exitQualification ,errCode));
    12721271                /* Exit qualification contains the linear address of the page fault. */
    1273                 TRPMAssertTrap(pVM, X86_XCPT_PF, false);
     1272                TRPMAssertTrap(pVM, X86_XCPT_PF, TRPM_TRAP);
    12741273                TRPMSetErrorCode(pVM, errCode);
    12751274                TRPMSetFaultAddress(pVM, exitQualification);

  • trunk/src/VBox/VMM/testcase/tstAsmStructs.cpp

    r23 r2124  
    2525#include <VBox/cpum.h>
    2626#include "CPUMInternal.h"
     27#include <VBox/trpm.h>
    2728#include "TRPMInternal.h"
    2829#include "../VMMSwitcher/VMMSwitcher.h"
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette