VirtualBox

Changeset 13816 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Nov 4, 2008 10:52:12 PM (16 years ago)
Author:
vboxsync
Message:

VMM: VBOX_SUCCESS -> RT_SUCCESS, VBOX_FAILURE -> RT_FAILURE.

Location:
trunk/src/VBox/VMM/VMMAll
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r13566 r13816  
    115115        {
    116116            uint8_t opcode;
    117             if (VBOX_SUCCESS(PATMR3QueryOpcode(pVM, (RTGCPTR)pSrc + i, &opcode)))
     117            if (RT_SUCCESS(PATMR3QueryOpcode(pVM, (RTGCPTR)pSrc + i, &opcode)))
    118118            {
    119119                *(pDest+i) = opcode;
    … …  
    152152    RTGCPTR GCPtrInstr;
    153153    int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pCtxCore, pCtxCore->rip, 0, &GCPtrInstr);
    154     if (VBOX_FAILURE(rc))
     154    if (RT_FAILURE(rc))
    155155    {
    156156        Log(("EMInterpretDisasOne: Failed to convert %RTsel:%VGv (cpl=%d) - rc=%Vrc !!\n",
    … …  
    182182#endif
    183183                          pCpu, pcbInstr);
    184     if (VBOX_SUCCESS(rc))
     184    if (RT_SUCCESS(rc))
    185185        return VINF_SUCCESS;
    186186    AssertMsgFailed(("DISCoreOne failed to GCPtrInstr=%VGv rc=%Vrc\n", GCPtrInstr, rc));
    … …  
    213213    LogFlow(("EMInterpretInstruction %VGv fault %VGv\n", pRegFrame->rip, pvFault));
    214214    int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
    215     if (VBOX_SUCCESS(rc))
     215    if (RT_SUCCESS(rc))
    216216    {
    217217        uint32_t    cbOp;
    … …  
    219219        Cpu.mode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    220220        rc = emDisCoreOne(pVM, &Cpu, (RTGCUINTPTR)pbCode, &cbOp);
    221         if (VBOX_SUCCESS(rc))
     221        if (RT_SUCCESS(rc))
    222222        {
    223223            Assert(cbOp == Cpu.opsize);
    224224            rc = EMInterpretInstructionCPU(pVM, &Cpu, pRegFrame, pvFault, pcbSize);
    225             if (VBOX_SUCCESS(rc))
     225            if (RT_SUCCESS(rc))
    226226            {
    227227                pRegFrame->rip += cbOp; /* Move on to the next instruction. */
    … …  
    264264    int rc = emInterpretInstructionCPU(pVM, pCpu, pRegFrame, pvFault, pcbSize);
    265265    STAM_PROFILE_STOP(&pVM->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
    266     if (VBOX_SUCCESS(rc))
     266    if (RT_SUCCESS(rc))
    267267        STAM_COUNTER_INC(&pVM->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretSucceeded));
    268268    else
    … …  
    427427    /* Source to make DISQueryParamVal read the register value - ugly hack */
    428428    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    429     if(VBOX_FAILURE(rc))
     429    if(RT_FAILURE(rc))
    430430        return VERR_EM_INTERPRETER;
    431431
    432432    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    433     if(VBOX_FAILURE(rc))
     433    if(RT_FAILURE(rc))
    434434        return VERR_EM_INTERPRETER;
    435435
    … …  
    455455                EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
    456456                rc = emRamRead(pVM, &valpar1, pParam1, param1.size);
    457                 if (VBOX_FAILURE(rc))
     457                if (RT_FAILURE(rc))
    458458                {
    459459                    AssertMsgFailed(("MMGCRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    474474                EM_ASSERT_FAULT_RETURN(pParam2 == pvFault, VERR_EM_INTERPRETER);
    475475                rc = emRamRead(pVM,  &valpar2, pParam2, param2.size);
    476                 if (VBOX_FAILURE(rc))
     476                if (RT_FAILURE(rc))
    477477                {
    478478                    AssertMsgFailed(("MMGCRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    502502                default: AssertFailedReturn(VERR_EM_INTERPRETER);
    503503                }
    504                 if (VBOX_FAILURE(rc))
     504                if (RT_FAILURE(rc))
    505505                    return VERR_EM_INTERPRETER;
    506506            }
    … …  
    508508            {
    509509                rc = emRamWrite(pVM, pParam1, &valpar2, param1.size);
    510                 if (VBOX_FAILURE(rc))
     510                if (RT_FAILURE(rc))
    511511                {
    512512                    AssertMsgFailed(("emRamWrite %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    528528                default: AssertFailedReturn(VERR_EM_INTERPRETER);
    529529                }
    530                 if (VBOX_FAILURE(rc))
     530                if (RT_FAILURE(rc))
    531531                    return VERR_EM_INTERPRETER;
    532532            }
    … …  
    534534            {
    535535                rc = emRamWrite(pVM, pParam2, &valpar1, param2.size);
    536                 if (VBOX_FAILURE(rc))
     536                if (RT_FAILURE(rc))
    537537                {
    538538                    AssertMsgFailed(("emRamWrite %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    560560
    561561    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    562     if(VBOX_FAILURE(rc))
     562    if(RT_FAILURE(rc))
    563563        return VERR_EM_INTERPRETER;
    564564
    … …  
    581581#endif
    582582                rc = emRamRead(pVM,  &valpar1, pParam1, param1.size);
    583                 if (VBOX_FAILURE(rc))
     583                if (RT_FAILURE(rc))
    584584                {
    585585                    AssertMsgFailed(("emRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    599599            /* Write result back */
    600600            rc = emRamWrite(pVM, pParam1, &valpar1, param1.size);
    601             if (VBOX_FAILURE(rc))
     601            if (RT_FAILURE(rc))
    602602            {
    603603                AssertMsgFailed(("emRamWrite %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    628628    OP_PARAMVAL param1;
    629629    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    630     if(VBOX_FAILURE(rc))
     630    if(RT_FAILURE(rc))
    631631        return VERR_EM_INTERPRETER;
    632632
    … …  
    651651
    652652            rc = emRamRead(pVM,  &valpar1, pStackVal, param1.size);
    653             if (VBOX_FAILURE(rc))
     653            if (RT_FAILURE(rc))
    654654            {
    655655                AssertMsgFailed(("emRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    672672                EM_ASSERT_FAULT_RETURN(pParam1 == pvFault || (RTGCPTR)pRegFrame->esp == pvFault, VERR_EM_INTERPRETER);
    673673                rc = emRamWrite(pVM, pParam1, &valpar1, param1.size);
    674                 if (VBOX_FAILURE(rc))
     674                if (RT_FAILURE(rc))
    675675                {
    676676                    AssertMsgFailed(("emRamWrite %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    708708    OP_PARAMVAL param1, param2;
    709709    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    710     if(VBOX_FAILURE(rc))
     710    if(RT_FAILURE(rc))
    711711        return VERR_EM_INTERPRETER;
    712712
    713713    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    714     if(VBOX_FAILURE(rc))
     714    if(RT_FAILURE(rc))
    715715        return VERR_EM_INTERPRETER;
    716716
    … …  
    743743                EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
    744744                rc = emRamRead(pVM,  &valpar1, pParam1, param1.size);
    745                 if (VBOX_FAILURE(rc))
     745                if (RT_FAILURE(rc))
    746746                {
    747747                    AssertMsgFailed(("emRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    780780            /* And write it back */
    781781            rc = emRamWrite(pVM, pParam1, &valpar1, param1.size);
    782             if (VBOX_SUCCESS(rc))
     782            if (RT_SUCCESS(rc))
    783783            {
    784784                /* All done! */
    … …  
    804804    OP_PARAMVAL param1, param2;
    805805    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    806     if(VBOX_FAILURE(rc))
     806    if(RT_FAILURE(rc))
    807807        return VERR_EM_INTERPRETER;
    808808
    809809    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    810     if(VBOX_FAILURE(rc))
     810    if(RT_FAILURE(rc))
    811811        return VERR_EM_INTERPRETER;
    812812
    … …  
    831831#else
    832832    rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    833     if (VBOX_FAILURE(rc))
     833    if (RT_FAILURE(rc))
    834834    {
    835835        AssertRC(rc);
    … …  
    883883    OP_PARAMVAL param1, param2;
    884884    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    885     if(VBOX_FAILURE(rc))
     885    if(RT_FAILURE(rc))
    886886        return VERR_EM_INTERPRETER;
    887887
    888888    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    889     if(VBOX_FAILURE(rc))
     889    if(RT_FAILURE(rc))
    890890        return VERR_EM_INTERPRETER;
    891891
    … …  
    918918                EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
    919919                rc = emRamRead(pVM,  &valpar1, pParam1, param1.size);
    920                 if (VBOX_FAILURE(rc))
     920                if (RT_FAILURE(rc))
    921921                {
    922922                    AssertMsgFailed(("emRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    953953            /* And write it back */
    954954            rc = emRamWrite(pVM, pParam1, &valpar1, param1.size);
    955             if (VBOX_SUCCESS(rc))
     955            if (RT_SUCCESS(rc))
    956956            {
    957957                /* All done! */
    … …  
    987987    OP_PARAMVAL param1, param2;
    988988    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    989     if(VBOX_FAILURE(rc))
     989    if(RT_FAILURE(rc))
    990990        return VERR_EM_INTERPRETER;
    991991
    992992    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    993     if(VBOX_FAILURE(rc))
     993    if(RT_FAILURE(rc))
    994994        return VERR_EM_INTERPRETER;
    995995
    … …  
    10271027            EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)pParam1 & ~3) == pvFault, VERR_EM_INTERPRETER);
    10281028            rc = emRamRead(pVM, &valpar1, pParam1, 1);
    1029             if (VBOX_FAILURE(rc))
     1029            if (RT_FAILURE(rc))
    10301030            {
    10311031                AssertMsgFailed(("emRamRead %VGv size=%d failed with %Vrc\n", pParam1, param1.size, rc));
    … …  
    10451045            /* And write it back */
    10461046            rc = emRamWrite(pVM, pParam1, &valpar1, 1);
    1047             if (VBOX_SUCCESS(rc))
     1047            if (RT_SUCCESS(rc))
    10481048            {
    10491049                /* All done! */
    … …  
    10691069    OP_PARAMVAL param1, param2;
    10701070    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    1071     if(VBOX_FAILURE(rc))
     1071    if(RT_FAILURE(rc))
    10721072        return VERR_EM_INTERPRETER;
    10731073
    10741074    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    1075     if(VBOX_FAILURE(rc))
     1075    if(RT_FAILURE(rc))
    10761076        return VERR_EM_INTERPRETER;
    10771077
    … …  
    10951095    GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
    10961096    rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    1097     if (VBOX_FAILURE(rc))
     1097    if (RT_FAILURE(rc))
    10981098    {
    10991099        AssertRC(rc);
    … …  
    11431143    OP_PARAMVAL param1, param2;
    11441144    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    1145     if(VBOX_FAILURE(rc))
     1145    if(RT_FAILURE(rc))
    11461146        return VERR_EM_INTERPRETER;
    11471147
    11481148    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    1149     if(VBOX_FAILURE(rc))
     1149    if(RT_FAILURE(rc))
    11501150        return VERR_EM_INTERPRETER;
    11511151
    … …  
    12001200            EM_ASSERT_FAULT_RETURN(pDest == pvFault, VERR_EM_INTERPRETER);
    12011201            rc = emRamWrite(pVM, pDest, &val64, param2.size);
    1202             if (VBOX_FAILURE(rc))
     1202            if (RT_FAILURE(rc))
    12031203                return VERR_EM_INTERPRETER;
    12041204
    … …  
    12301230            EM_ASSERT_FAULT_RETURN(pSrc == pvFault, VERR_EM_INTERPRETER);
    12311231            rc = emRamRead(pVM, &val64, pSrc, param1.size);
    1232             if (VBOX_FAILURE(rc))
     1232            if (RT_FAILURE(rc))
    12331233                return VERR_EM_INTERPRETER;
    12341234
    … …  
    12461246                    return VERR_EM_INTERPRETER;
    12471247                }
    1248                 if (VBOX_FAILURE(rc))
     1248                if (RT_FAILURE(rc))
    12491249                    return rc;
    12501250                break;
    … …  
    13271327
    13281328        rc = PGMPhysWriteGCPtr(pVM, GCDest, &pRegFrame->rax, cbSize);
    1329         if (VBOX_FAILURE(rc))
     1329        if (RT_FAILURE(rc))
    13301330            return VERR_EM_INTERPRETER;
    13311331        Assert(rc == VINF_SUCCESS);
    … …  
    13681368        {
    13691369            rc = PGMPhysWriteGCPtr(pVM, GCDest, &pRegFrame->rax, cbSize);
    1370             if (VBOX_FAILURE(rc))
     1370            if (RT_FAILURE(rc))
    13711371            {
    13721372                rc = VERR_EM_INTERPRETER;
    … …  
    14171417    /* Source to make DISQueryParamVal read the register value - ugly hack */
    14181418    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    1419     if(VBOX_FAILURE(rc))
     1419    if(RT_FAILURE(rc))
    14201420        return VERR_EM_INTERPRETER;
    14211421
    14221422    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    1423     if(VBOX_FAILURE(rc))
     1423    if(RT_FAILURE(rc))
    14241424        return VERR_EM_INTERPRETER;
    14251425
    … …  
    14361436
    14371437        rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    1438         if (VBOX_FAILURE(rc))
     1438        if (RT_FAILURE(rc))
    14391439        {
    14401440            AssertRC(rc);
    … …  
    14851485    /* Source to make DISQueryParamVal read the register value - ugly hack */
    14861486    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    1487     if(VBOX_FAILURE(rc))
     1487    if(RT_FAILURE(rc))
    14881488        return VERR_EM_INTERPRETER;
    14891489
    … …  
    15001500
    15011501        rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    1502         if (VBOX_FAILURE(rc))
     1502        if (RT_FAILURE(rc))
    15031503        {
    15041504            AssertRC(rc);
    … …  
    15401540    /* Source to make DISQueryParamVal read the register value - ugly hack */
    15411541    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    1542     if(VBOX_FAILURE(rc))
     1542    if(RT_FAILURE(rc))
    15431543        return VERR_EM_INTERPRETER;
    15441544
    15451545    rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param2, &param2, PARAM_SOURCE);
    1546     if(VBOX_FAILURE(rc))
     1546    if(RT_FAILURE(rc))
    15471547        return VERR_EM_INTERPRETER;
    15481548
    … …  
    15861586            MMGCRamDeregisterTrapHandler(pVM);
    15871587
    1588             if (VBOX_FAILURE(rc))
     1588            if (RT_FAILURE(rc))
    15891589            {
    15901590                Log(("%s %VGv eax=%08x %08x -> emulation failed due to page fault!\n", emGetMnemonic(pCpu), pParam1, pRegFrame->eax, valpar));
    … …  
    16161616    /* Source to make DISQueryParamVal read the register value - ugly hack */
    16171617    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    1618     if(VBOX_FAILURE(rc))
     1618    if(RT_FAILURE(rc))
    16191619        return VERR_EM_INTERPRETER;
    16201620
    … …  
    16481648            MMGCRamDeregisterTrapHandler(pVM);
    16491649
    1650             if (VBOX_FAILURE(rc))
     1650            if (RT_FAILURE(rc))
    16511651            {
    16521652                Log(("%s %VGv=%08x eax=%08x -> emulation failed due to page fault!\n", emGetMnemonic(pCpu), pParam1, pRegFrame->eax));
    … …  
    16821682    /* Source to make DISQueryParamVal read the register value - ugly hack */
    16831683    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    1684     if(VBOX_FAILURE(rc))
     1684    if(RT_FAILURE(rc))
    16851685        return VERR_EM_INTERPRETER;
    16861686
    16871687    rc = DISQueryParamRegPtr(pRegFrame, pCpu, &pCpu->param2, (void **)&pParamReg2, &cbSizeParamReg2);
    16881688    Assert(cbSizeParamReg2 <= 4);
    1689     if(VBOX_FAILURE(rc))
     1689    if(RT_FAILURE(rc))
    16901690        return VERR_EM_INTERPRETER;
    16911691
    … …  
    17191719            MMGCRamDeregisterTrapHandler(pVM);
    17201720
    1721             if (VBOX_FAILURE(rc))
     1721            if (RT_FAILURE(rc))
    17221722            {
    17231723                Log(("XAdd %VGv reg=%08x -> emulation failed due to page fault!\n", pParam1, *pParamReg2));
    … …  
    18541854
    18551855    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    1856     if(VBOX_FAILURE(rc))
     1856    if(RT_FAILURE(rc))
    18571857        return VERR_EM_INTERPRETER;
    18581858
    … …  
    19491949        rc = DISWriteReg32(pRegFrame, DestRegGen, val64);
    19501950
    1951     if(VBOX_SUCCESS(rc))
     1951    if(RT_SUCCESS(rc))
    19521952    {
    19531953        LogFlow(("MOV_CR: gen32=%d CR=%d val=%VX64\n", DestRegGen, SrcRegCrx, val64));
    … …  
    21382138    }
    21392139
    2140     if (VBOX_SUCCESS(rc))
     2140    if (RT_SUCCESS(rc))
    21412141        return EMUpdateCRx(pVM, pRegFrame, DestRegCrx, val);
    21422142
    … …  
    21732173
    21742174    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    2175     if(VBOX_FAILURE(rc))
     2175    if(RT_FAILURE(rc))
    21762176        return VERR_EM_INTERPRETER;
    21772177
    … …  
    22702270        rc = DISWriteReg32(pRegFrame, DestRegGen, (uint32_t)val64);
    22712271
    2272     if (VBOX_SUCCESS(rc))
     2272    if (RT_SUCCESS(rc))
    22732273        return VINF_SUCCESS;
    22742274
    … …  
    23092309
    23102310    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    2311     if(VBOX_FAILURE(rc))
     2311    if(RT_FAILURE(rc))
    23122312        return VERR_EM_INTERPRETER;
    23132313
    … …  
    23562356
    23572357    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
    2358     if(VBOX_FAILURE(rc))
     2358    if(RT_FAILURE(rc))
    23592359        return VERR_EM_INTERPRETER;
    23602360
    … …  
    29002900            else \
    29012901                rc = emInterpret##InstrFn(pVM, pCpu, pRegFrame, pvFault, pcbSize, pfnEmulate); \
    2902             if (VBOX_SUCCESS(rc)) \
     2902            if (RT_SUCCESS(rc)) \
    29032903                STAM_COUNTER_INC(&pVM->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
    29042904            else \
    … …  
    29082908        case opcode:\
    29092909            rc = emInterpret##InstrFn(pVM, pCpu, pRegFrame, pvFault, pcbSize, pfnEmulate); \
    2910             if (VBOX_SUCCESS(rc)) \
     2910            if (RT_SUCCESS(rc)) \
    29112911                STAM_COUNTER_INC(&pVM->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
    29122912            else \
    … …  
    29222922        case opcode:\
    29232923            rc = emInterpret##Instr(pVM, pCpu, pRegFrame, pvFault, pcbSize); \
    2924             if (VBOX_SUCCESS(rc)) \
     2924            if (RT_SUCCESS(rc)) \
    29252925                STAM_COUNTER_INC(&pVM->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
    29262926            else \
    … …  
    29312931        case opcode:\
    29322932            rc = emInterpret##InstrFn(pVM, pCpu, pRegFrame, pvFault, pcbSize); \
    2933             if (VBOX_SUCCESS(rc)) \
     2933            if (RT_SUCCESS(rc)) \
    29342934                STAM_COUNTER_INC(&pVM->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
    29352935            else \

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

    r12989 r13816  
    835835#ifdef VBOX_WITH_STATISTICS
    836836    pStat->cFrees++;
    837     if (VBOX_SUCCESS(rc))
     837    if (RT_SUCCESS(rc))
    838838    {
    839839        pStat->cbFreed        += cbChunk;

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

    r13418 r13816  
    437437    int rc = PGM_BTH_PFN(PrefetchPage, pVM)(pVM, (RTGCUINTPTR)GCPtrPage);
    438438    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
    439     AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || VBOX_FAILURE(rc), ("rc=%Vrc\n", rc));
     439    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Vrc\n", rc));
    440440    return rc;
    441441}
    … …  
    491491    uint64_t fPage;
    492492    int rc = PGMGstGetPage(pVM, (RTGCPTR)Addr, &fPage, NULL);
    493     if (VBOX_FAILURE(rc))
     493    if (RT_FAILURE(rc))
    494494    {
    495495        Log(("PGMIsValidAccess: access violation for %VGv rc=%d\n", Addr, rc));
    … …  
    512512        return VINF_EM_RAW_GUEST_TRAP;
    513513    }
    514     if (    VBOX_SUCCESS(rc)
     514    if (    RT_SUCCESS(rc)
    515515        &&  PAGE_ADDRESS(Addr) != PAGE_ADDRESS(Addr + cbSize))
    516516        return PGMIsValidAccess(pVM, Addr + PAGE_SIZE, (cbSize > PAGE_SIZE) ? cbSize - PAGE_SIZE : 1, fAccess);
    … …  
    539539    uint64_t fPageGst;
    540540    int rc = PGMGstGetPage(pVM, (RTGCPTR)Addr, &fPageGst, NULL);
    541     if (VBOX_FAILURE(rc))
     541    if (RT_FAILURE(rc))
    542542    {
    543543        Log(("PGMVerifyAccess: access violation for %VGv rc=%d\n", Addr, rc));
    … …  
    591591    uint64_t fPageShw;
    592592    rc = PGMShwGetPage(pVM, (RTGCPTR)Addr, &fPageShw, NULL);
    593     if (    (rc == VERR_PAGE_NOT_PRESENT || VBOX_FAILURE(rc))
     593    if (    (rc == VERR_PAGE_NOT_PRESENT || RT_FAILURE(rc))
    594594        || (fWrite && !(fPageShw & X86_PTE_RW))
    595595        || (fUser  && !(fPageShw & X86_PTE_US)) )
    … …  
    601601#endif
    602602
    603     if (    VBOX_SUCCESS(rc)
     603    if (    RT_SUCCESS(rc)
    604604        &&  (   PAGE_ADDRESS(Addr) != PAGE_ADDRESS(Addr + cbSize - 1)
    605605             || Addr + cbSize < Addr))
    … …  
    691691     * Check if we have a pending update of the CR3 monitoring.
    692692     */
    693     if (    VBOX_SUCCESS(rc)
     693    if (    RT_SUCCESS(rc)
    694694        &&  (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3))
    695695    {
    … …  
    11591159{
    11601160    int rc = PGMGstGetPage(pVM, GCPtr, NULL, NULL);
    1161     return VBOX_SUCCESS(rc);
     1161    return RT_SUCCESS(rc);
    11621162}
    11631163
    … …  
    14751475        pVM->pgm.s.GCPhysCR3 = GCPhysCR3;
    14761476        rc = PGM_GST_PFN(MapCR3, pVM)(pVM, GCPhysCR3);
    1477         if (VBOX_SUCCESS(rc) && !pVM->pgm.s.fMappingsFixed)
     1477        if (RT_SUCCESS(rc) && !pVM->pgm.s.fMappingsFixed)
    14781478        {
    14791479            pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
    … …  
    15971597    int rc = PGM_BTH_PFN(SyncCR3, pVM)(pVM, cr0, cr3, cr4, fGlobal);
    15981598    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    1599     AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || VBOX_FAILURE(rc), ("rc=%VRc\n", rc));
     1599    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%VRc\n", rc));
    16001600    if (rc == VINF_SUCCESS)
    16011601    {

  • trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r13398 r13816  
    242242        LogFlow(("=>SyncPT %04x = %08x\n", iPDSrc, PdeSrc.au32[0]));
    243243        rc = PGM_BTH_NAME(SyncPT)(pVM, iPDSrc, pPDSrc, (RTGCUINTPTR)pvFault);
    244         if (VBOX_SUCCESS(rc))
     244        if (RT_SUCCESS(rc))
    245245        {
    246246            STAM_PROFILE_STOP(&pVM->pgm.s.StatRZTrap0eTimeSyncPT, f);
    … …  
    349349            PGSTPT pPTSrc;
    350350            rc = PGM_GCPHYS_2_PTR(pVM, PdeSrc.u & GST_PDE_PG_MASK, &pPTSrc);
    351             if (VBOX_SUCCESS(rc))
     351            if (RT_SUCCESS(rc))
    352352            {
    353353                unsigned iPTESrc = ((RTGCUINTPTR)pvFault >> GST_PT_SHIFT) & GST_PT_MASK;
    … …  
    370370            PPGMPAGE pPage;
    371371            rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
    372             if (VBOX_SUCCESS(rc))
     372            if (RT_SUCCESS(rc))
    373373            {
    374374                if (   PGM_PAGE_HAS_ACTIVE_PHYSICAL_HANDLERS(pPage)
    … …  
    396396                            {
    397397                                rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)pvFault, PGM_SYNC_NR_PAGES, uErr);
    398                                 if (    VBOX_FAILURE(rc)
     398                                if (    RT_FAILURE(rc)
    399399                                    || !(uErr & X86_TRAP_PF_RW)
    400400                                    || rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
    … …  
    442442                        {
    443443                            rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)pvFault, PGM_SYNC_NR_PAGES, uErr);
    444                             if (    VBOX_FAILURE(rc)
     444                            if (    RT_FAILURE(rc)
    445445                                ||  rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE
    446446                                ||  !(uErr & X86_TRAP_PF_RW))
    … …  
    498498                            rc = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys + ((RTGCUINTPTR)pvFault & PAGE_OFFSET_MASK),
    499499                                                                 &pCur, &iPage);
    500                             Assert(VBOX_SUCCESS(rc) || !pCur);
     500                            Assert(RT_SUCCESS(rc) || !pCur);
    501501                            if (    pCur
    502502                                &&  (   uErr & X86_TRAP_PF_RW
    … …  
    536536                    {
    537537                        rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)pvFault, PGM_SYNC_NR_PAGES, uErr);
    538                         if (    VBOX_FAILURE(rc)
     538                        if (    RT_FAILURE(rc)
    539539                            ||  rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE
    540540                            ||  !(uErr & X86_TRAP_PF_RW))
    … …  
    646646                    uint64_t fPageGst;
    647647                    rc = PGMGstGetPage(pVM, pvFault, &fPageGst, NULL);
    648                     if (    VBOX_SUCCESS(rc)
     648                    if (    RT_SUCCESS(rc)
    649649                        && !(fPageGst & X86_PTE_US))
    650650                    {
    … …  
    718718#   endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) && !defined(IN_RING0) */
    719719                rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)pvFault, PGM_SYNC_NR_PAGES, uErr);
    720                 if (VBOX_SUCCESS(rc))
     720                if (RT_SUCCESS(rc))
    721721                {
    722722                    /* The page was successfully synced, return to the guest. */
    … …  
    733733                 * Assume for now it only applies to the read/write flag
    734734                 */
    735                 if (VBOX_SUCCESS(rc) && (uErr & X86_TRAP_PF_RW))
     735                if (RT_SUCCESS(rc) && (uErr & X86_TRAP_PF_RW))
    736736                {
    737737                    if (uErr & X86_TRAP_PF_US)
    … …  
    745745                     */
    746746                    rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)pvFault, 1, uErr);
    747                     if (VBOX_SUCCESS(rc))
     747                    if (RT_SUCCESS(rc))
    748748                    {
    749749                       /*
    … …  
    754754                        uint64_t fPageGst;
    755755                        rc = PGMGstGetPage(pVM, pvFault, &fPageGst, &GCPhys);
    756                         Assert(VBOX_SUCCESS(rc) && fPageGst & X86_PTE_RW);
     756                        Assert(RT_SUCCESS(rc) && fPageGst & X86_PTE_RW);
    757757                        LogFlow(("Obsolete physical monitor page out of sync %VGv - phys %VGp flags=%08llx\n", pvFault, GCPhys, (uint64_t)fPageGst));
    758758
    759759                        uint64_t fPageShw;
    760760                        rc = PGMShwGetPage(pVM, pvFault, &fPageShw, NULL);
    761                         AssertMsg(VBOX_SUCCESS(rc) && fPageShw & X86_PTE_RW, ("rc=%Vrc fPageShw=%VX64\n", rc, fPageShw));
     761                        AssertMsg(RT_SUCCESS(rc) && fPageShw & X86_PTE_RW, ("rc=%Vrc fPageShw=%VX64\n", rc, fPageShw));
    762762#   endif /* VBOX_STRICT */
    763763                        STAM_PROFILE_STOP(&pVM->pgm.s.StatRZTrap0eTimeOutOfSync, c);
    … …  
    773773                        uint64_t fPageGst;
    774774                        rc = PGMGstGetPage(pVM, pvFault, &fPageGst, NULL);
    775                         if (    VBOX_SUCCESS(rc)
     775                        if (    RT_SUCCESS(rc)
    776776                            && !(fPageGst & X86_PTE_RW))
    777777                        {
    778778                            rc = PGMInterpretInstruction(pVM, pRegFrame, pvFault);
    779                             if (VBOX_SUCCESS(rc))
     779                            if (RT_SUCCESS(rc))
    780780                                STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eWPEmulInRZ);
    781781                            else
    … …  
    793793                 * Currently only for debug purposes.
    794794                 */
    795                 if (VBOX_SUCCESS(rc))
     795                if (RT_SUCCESS(rc))
    796796                {
    797797                    /* Get guest page flags. */
    798798                    uint64_t fPageGst;
    799799                    rc = PGMGstGetPage(pVM, pvFault, &fPageGst, NULL);
    800                     if (VBOX_SUCCESS(rc))
     800                    if (RT_SUCCESS(rc))
    801801                    {
    802802                        uint64_t fPageShw;
    … …  
    11971197# else /* Syncing it here isn't 100% safe and it's probably not worth spending time syncing it. */
    11981198                rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, GCPtrPage, 1, 0);
    1199                 if (VBOX_SUCCESS(rc))
     1199                if (RT_SUCCESS(rc))
    12001200                    rc = VINF_SUCCESS;
    12011201# endif
    … …  
    14171417        PPGMPAGE pPage;
    14181418        int rc = pgmPhysGetPageEx(&pVM->pgm.s, PteSrc.u & GST_PTE_PG_MASK, &pPage);
    1419         if (VBOX_SUCCESS(rc))
     1419        if (RT_SUCCESS(rc))
    14201420        {
    14211421            /** @todo investiage PWT, PCD and PAT. */
    … …  
    16611661                PGSTPT pPTSrc;
    16621662                int rc = PGM_GCPHYS_2_PTR(pVM, PdeSrc.u & GST_PDE_PG_MASK, &pPTSrc);
    1663                 if (VBOX_SUCCESS(rc))
     1663                if (RT_SUCCESS(rc))
    16641664                {
    16651665# ifdef PGM_SYNC_N_PAGES
    … …  
    17501750                PPGMPAGE pPage;
    17511751                int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
    1752                 if (VBOX_SUCCESS(rc))
     1752                if (RT_SUCCESS(rc))
    17531753                {
    17541754                    /*
    … …  
    21012101    PGSTPT pPTSrc;
    21022102    rc = PGM_GCPHYS_2_PTR(pVM, pPdeSrc->u & GST_PDE_PG_MASK, &pPTSrc);
    2103     if (VBOX_SUCCESS(rc))
     2103    if (RT_SUCCESS(rc))
    21042104    {
    21052105        /*
    … …  
    22602260            PGSTPT pPTSrc;
    22612261            rc = PGM_GCPHYS_2_PTR(pVM, pPdeSrc->u & GST_PDE_PG_MASK, &pPTSrc);
    2262             if (VBOX_SUCCESS(rc))
     2262            if (RT_SUCCESS(rc))
    22632263            {
    22642264                PGSTPTE         pPteSrc = &pPTSrc->a[(GCPtrPage >> GST_PT_SHIFT) & GST_PT_MASK];
    … …  
    23562356        AssertFailed();     /* can't happen for amd64 */
    23572357#   endif
    2358         if (VBOX_FAILURE(rc))
     2358        if (RT_FAILURE(rc))
    23592359        {
    23602360            STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    … …  
    24622462            PGSTPT pPTSrc;
    24632463            rc = PGM_GCPHYS_2_PTR(pVM, PdeSrc.u & GST_PDE_PG_MASK, &pPTSrc);
    2464             if (VBOX_SUCCESS(rc))
     2464            if (RT_SUCCESS(rc))
    24652465            {
    24662466                /*
    … …  
    26802680
    26812681    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    2682     if (VBOX_FAILURE(rc))
     2682    if (RT_FAILURE(rc))
    26832683        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPTFailed));
    26842684    return rc;
    … …  
    28802880                 */
    28812881                rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, GCPtrPage, 1, 0);
    2882                 if (VBOX_SUCCESS(rc))
     2882                if (RT_SUCCESS(rc))
    28832883                    rc = VINF_SUCCESS;
    28842884            }
    … …  
    30213021
    30223022        rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, GCPtrPage, 1, 0);
    3023         if (VBOX_SUCCESS(rc))
     3023        if (RT_SUCCESS(rc))
    30243024        {
    30253025            /* Page was successfully synced */
    … …  
    33493349                        int rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, (iPdpte << GST_PDPT_SHIFT) + (iPD << GST_PD_SHIFT));
    33503350#    endif
    3351                         if (VBOX_FAILURE(rc))
     3351                        if (RT_FAILURE(rc))
    33523352                            return rc;
    33533353
    … …  
    35313531                                int rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, (iPdpte << GST_PDPT_SHIFT) + (iPD << GST_PD_SHIFT));
    35323532#    endif
    3533                                 if (VBOX_FAILURE(rc))
     3533                                if (RT_FAILURE(rc))
    35343534                                    return rc;
    35353535
    … …  
    39573957                        const GSTPT *pPTSrc;
    39583958                        rc = PGM_GCPHYS_2_PTR(pVM, GCPhysGst & ~(RTGCPHYS)(PAGE_SIZE - 1), &pPTSrc);
    3959                         if (VBOX_FAILURE(rc))
     3959                        if (RT_FAILURE(rc))
    39603960                        {
    39613961                            AssertMsgFailed(("Cannot map/convert guest physical address %VGp in the PDE at %VGv! PdeSrc=%#RX64\n",
    … …  
    40254025# ifdef IN_RING3
    40264026                            rc = PGMPhysGCPhys2HCPhys(pVM, GCPhysGst, &HCPhys);
    4027                             if (VBOX_FAILURE(rc))
     4027                            if (RT_FAILURE(rc))
    40284028                            {
    40294029                                if (HCPhysShw != MMR3PageDummyHCPhys(pVM))
    … …  
    42554255# ifdef IN_RING3
    42564256                            rc = PGMPhysGCPhys2HCPhys(pVM, GCPhysGst, &HCPhys);
    4257                             if (VBOX_FAILURE(rc))
     4257                            if (RT_FAILURE(rc))
    42584258                            {
    42594259                                if (HCPhysShw != MMR3PageDummyHCPhys(pVM))

  • trunk/src/VBox/VMM/VMMAll/PGMAllGst.h

    r13582 r13816  
    220220        PGSTPT pPT;
    221221        int rc = PGM_GCPHYS_2_PTR(pVM, Pde.u & GST_PDE_PG_MASK, &pPT);
    222         if (VBOX_FAILURE(rc))
     222        if (RT_FAILURE(rc))
    223223            return rc;
    224224
    … …  
    333333            PGSTPT pPT;
    334334            int rc = PGM_GCPHYS_2_PTR(pVM, Pde.u & GST_PDE_PG_MASK, &pPT);
    335             if (VBOX_FAILURE(rc))
     335            if (RT_FAILURE(rc))
    336336                return rc;
    337337
    … …  
    441441    RTHCPTR     HCPtrGuestCR3;
    442442    int rc = pgmRamGCPhys2HCPtrAndHCPhysWithFlags(&pVM->pgm.s, GCPhysCR3 & GST_CR3_PAGE_MASK, &HCPtrGuestCR3, &HCPhysGuestCR3);
    443     if (VBOX_SUCCESS(rc))
     443    if (RT_SUCCESS(rc))
    444444    {
    445445        rc = PGMMap(pVM, (RTGCUINTPTR)pVM->pgm.s.GCPtrCR3Mapping, HCPhysGuestCR3, PAGE_SIZE, 0);
    446         if (VBOX_SUCCESS(rc))
     446        if (RT_SUCCESS(rc))
    447447        {
    448448            PGM_INVL_PG(pVM->pgm.s.GCPtrCR3Mapping);
    … …  
    469469                    RTGCPHYS    GCPhys = pVM->pgm.s.CTXSUFF(pGstPaePDPT)->a[i].u & X86_PDPE_PG_MASK;
    470470                    int rc2 = pgmRamGCPhys2HCPtrAndHCPhysWithFlags(&pVM->pgm.s, GCPhys, &HCPtr, &HCPhys);
    471                     if (VBOX_SUCCESS(rc2))
     471                    if (RT_SUCCESS(rc2))
    472472                    {
    473473                        rc = PGMMap(pVM, GCPtr, HCPhys & X86_PTE_PAE_PG_MASK, PAGE_SIZE, 0);
    … …  
    624624                                      GCPhysCR3);
    625625# endif /* PGMPOOL_WITH_MIXED_PT_CR3 */
    626         if (VBOX_FAILURE(rc))
     626        if (RT_FAILURE(rc))
    627627        {
    628628            AssertMsgFailed(("PGMHandlerPhysicalModify/PGMR3HandlerPhysicalRegister failed, rc=%Rrc GCPhysGstCR3Monitored=%RGp GCPhysCR3=%RGp\n",
    … …  
    644644    {
    645645        rc = pgmPoolMonitorMonitorCR3(pVM->pgm.s.CTX_SUFF(pPool), PGMPOOL_IDX_PDPT, GCPhysCR3);
    646         if (VBOX_FAILURE(rc))
     646        if (RT_FAILURE(rc))
    647647        {
    648648            AssertMsgFailed(("PGMHandlerPhysicalModify/PGMR3HandlerPhysicalRegister failed, rc=%Rrc GCPhysGstCR3Monitored=%RGp GCPhysCR3=%RGp\n",
    … …  
    668668            }
    669669
    670             if (VBOX_FAILURE(rc))
     670            if (RT_FAILURE(rc))
    671671            {
    672672                AssertMsgFailed(("PGMHandlerPhysicalModify/PGMR3HandlerPhysicalRegister failed, rc=%Rrc GCPhysGstCR3Monitored=%RGp GCPhysCR3=%RGp\n",
    … …  
    744744            int rc2 = pgmPoolMonitorUnmonitorCR3(pVM->pgm.s.CTX_SUFF(pPool), PGMPOOL_IDX_PAE_PD_0 + i);
    745745            AssertRC(rc2);
    746             if (VBOX_FAILURE(rc2))
     746            if (RT_FAILURE(rc2))
    747747                rc = rc2;
    748748            pVM->pgm.s.aGCPhysGstPaePDsMonitored[i] = NIL_RTGCPHYS;
    … …  
    813813                PGSTPT pPT;
    814814                int rc = PGM_GCPHYS_2_PTR(pState->pVM, Pde.u & GST_PDE_PG_MASK, &pPT);
    815                 if (VBOX_SUCCESS(rc))
     815                if (RT_SUCCESS(rc))
    816816                {
    817817                    for (unsigned iPTE = (GCPtr >> GST_PT_SHIFT) & GST_PT_MASK;
    … …  
    995995    uint32_t cb;
    996996    int rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
    997     if (VBOX_SUCCESS(rc) && cb)
     997    if (RT_SUCCESS(rc) && cb)
    998998    {
    999999        /*
    … …  
    10371037    else
    10381038    {
    1039         Assert(VBOX_FAILURE(rc));
     1039        Assert(RT_FAILURE(rc));
    10401040        if (rc == VERR_EM_INTERPRETER)
    10411041            rc = VINF_EM_RAW_EMULATE_INSTR_PD_FAULT;
    … …  
    10731073    uint32_t cb;
    10741074    int rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
    1075     if (VBOX_SUCCESS(rc) && cb)
     1075    if (RT_SUCCESS(rc) && cb)
    10761076    {
    10771077        /*
    … …  
    11051105    else
    11061106    {
    1107         Assert(VBOX_FAILURE(rc));
     1107        Assert(RT_FAILURE(rc));
    11081108        STAM_COUNTER_INC(&pVM->pgm.s.StatRZGuestCR3WriteUnhandled);
    11091109        if (rc == VERR_EM_INTERPRETER)
    … …  
    11391139    uint32_t cb;
    11401140    int rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
    1141     if (VBOX_SUCCESS(rc) && cb)
     1141    if (RT_SUCCESS(rc) && cb)
    11421142    {
    11431143        /*
    … …  
    11881188    else
    11891189    {
    1190         Assert(VBOX_FAILURE(rc));
     1190        Assert(RT_FAILURE(rc));
    11911191        if (rc == VERR_EM_INTERPRETER)
    11921192            rc = VINF_EM_RAW_EMULATE_INSTR_PD_FAULT;

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

    r13415 r13816  
    132132    PPGMPHYSHANDLER pNew;
    133133    int rc = MMHyperAlloc(pVM, sizeof(*pNew), 0, MM_TAG_PGM_HANDLERS, (void **)&pNew);
    134     if (VBOX_FAILURE(rc))
     134    if (RT_FAILURE(rc))
    135135        return rc;
    136136
    … …  
    645645    PPGMPHYSHANDLER pNew;
    646646    int rc = MMHyperAlloc(pVM, sizeof(*pNew), 0, MM_TAG_PGM_HANDLERS, (void **)&pNew);
    647     if (VBOX_FAILURE(rc))
     647    if (RT_FAILURE(rc))
    648648        return rc;
    649649

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

    r13565 r13816  
    195195    PPGMPAGE pPage;
    196196    int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
    197     if (VBOX_FAILURE(rc))
     197    if (RT_FAILURE(rc))
    198198        return rc;
    199199
    … …  
    377377     */
    378378    int rc = pgmPhysEnsureHandyPage(pVM);
    379     if (VBOX_FAILURE(rc))
     379    if (RT_FAILURE(rc))
    380380    {
    381381        Assert(rc == VERR_EM_NO_MEMORY);
    … …  
    532532#else
    533533            int rc = pgmR3PhysChunkMap(pVM, idChunk, &pMap);
    534             if (VBOX_FAILURE(rc))
     534            if (RT_FAILURE(rc))
    535535                return rc;
    536536#endif
    … …  
    601601        PPGMPAGEMAP pMap;
    602602        int rc = pgmPhysPageMap(PGM2VM(pPGM), pPage, GCPhys, &pMap, &pv);
    603         if (VBOX_FAILURE(rc))
     603        if (RT_FAILURE(rc))
    604604            return rc;
    605605        pTlbe->pMap = pMap;
    … …  
    770770    RTGCPHYS GCPhys;
    771771    int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
    772     if (VBOX_SUCCESS(rc))
     772    if (RT_SUCCESS(rc))
    773773        rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys, ppv, pLock);
    774774    return rc;
    … …  
    803803    RTGCPHYS GCPhys;
    804804    int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
    805     if (VBOX_SUCCESS(rc))
     805    if (RT_SUCCESS(rc))
    806806        rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, ppv, pLock);
    807807    return rc;
    … …  
    880880    PPGMPAGE pPage;
    881881    int rc = pgmPhysGetPageAndRangeEx(&pVM->pgm.s, GCPhys, &pPage, &pRam);
    882     if (VBOX_FAILURE(rc))
     882    if (RT_FAILURE(rc))
    883883        return rc;
    884884
    … …  
    925925    RTHCPTR HCPtr;
    926926    int rc = PGMPhysGCPhys2HCPtr(pVM, GCPhys, cbRange, &HCPtr);
    927     if (VBOX_SUCCESS(rc))
     927    if (RT_SUCCESS(rc))
    928928        return HCPtr;
    929929    return NIL_RTHCPTR;
    … …  
    944944{
    945945    int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, pGCPhys);
    946     if (pGCPhys && VBOX_SUCCESS(rc))
     946    if (pGCPhys && RT_SUCCESS(rc))
    947947        *pGCPhys |= (RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK;
    948948    return rc;
    … …  
    964964    RTGCPHYS GCPhys;
    965965    int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
    966     if (VBOX_SUCCESS(rc))
     966    if (RT_SUCCESS(rc))
    967967        rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), pHCPhys);
    968968    return rc;
    … …  
    988988    RTGCPHYS GCPhys;
    989989    int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
    990     if (VBOX_SUCCESS(rc))
     990    if (RT_SUCCESS(rc))
    991991        rc = PGMPhysGCPhys2HCPtr(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
    992992    return rc;
    … …  
    10231023        PX86PD pPD;
    10241024        rc = PGM_GCPHYS_2_PTR(pVM, cr3 & X86_CR3_PAGE_MASK, &pPD);
    1025         if (VBOX_SUCCESS(rc))
     1025        if (RT_SUCCESS(rc))
    10261026        {
    10271027            X86PDE Pde = pPD->a[(RTGCUINTPTR)GCPtr >> X86_PD_SHIFT];
    … …  
    10361036                    PX86PT pPT;
    10371037                    rc = PGM_GCPHYS_2_PTR(pVM, Pde.u & X86_PDE_PG_MASK, &pPT);
    1038                     if (VBOX_SUCCESS(rc))
     1038                    if (RT_SUCCESS(rc))
    10391039                    {
    10401040                        X86PTE Pte = pPT->a[((RTGCUINTPTR)GCPtr >> X86_PT_SHIFT) & X86_PT_MASK];
    … …  
    10561056        PX86PDPT pPdpt;
    10571057        rc = PGM_GCPHYS_2_PTR(pVM, cr3 & X86_CR3_PAE_PAGE_MASK, &pPdpt);
    1058         if (VBOX_SUCCESS(rc))
     1058        if (RT_SUCCESS(rc))
    10591059        {
    10601060            X86PDPE Pdpe = pPdpt->a[((RTGCUINTPTR)GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE];
    … …  
    10631063                PX86PDPAE pPD;
    10641064                rc = PGM_GCPHYS_2_PTR(pVM, Pdpe.u & X86_PDPE_PG_MASK, &pPD);
    1065                 if (VBOX_SUCCESS(rc))
     1065                if (RT_SUCCESS(rc))
    10661066                {
    10671067                    X86PDEPAE Pde = pPD->a[((RTGCUINTPTR)GCPtr >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK];
    … …  
    10761076                            PX86PTPAE pPT;
    10771077                            rc = PGM_GCPHYS_2_PTR(pVM, (Pde.u & X86_PDE_PAE_PG_MASK), &pPT);
    1078                             if (VBOX_SUCCESS(rc))
     1078                            if (RT_SUCCESS(rc))
    10791079                            {
    10801080                                X86PTEPAE Pte = pPT->a[((RTGCUINTPTR)GCPtr >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK];
    … …  
    12541254                    unsigned iPage;
    12551255                    int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
    1256                     if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerR3)
     1256                    if (RT_SUCCESS(rc2) && pNode->pfnHandlerR3)
    12571257                    {
    12581258                        size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
    … …  
    15021502                        unsigned iPage;
    15031503                        int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirtNode, &iPage);
    1504                         if (VBOX_SUCCESS(rc2) && pVirtNode->pfnHandlerR3)
     1504                        if (RT_SUCCESS(rc2) && pVirtNode->pfnHandlerR3)
    15051505                        {
    15061506                            size_t cbRange = pVirtNode->Core.KeyLast - GCPhys + 1;
    … …  
    15181518                            if (    (   rc2 != VINF_PGM_HANDLER_DO_DEFAULT
    15191519                                     && rc == VINF_PGM_HANDLER_DO_DEFAULT)
    1520                                 ||  (   VBOX_FAILURE(rc2)
    1521                                      && VBOX_SUCCESS(rc)))
     1520                                ||  (   RT_FAILURE(rc2)
     1521                                     && RT_SUCCESS(rc)))
    15221522                                rc = rc2;
    15231523                        }
    … …  
    15511551                        unsigned iPage;
    15521552                        int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
    1553                         if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerR3)
     1553                        if (RT_SUCCESS(rc2) && pNode->pfnHandlerR3)
    15541554                        {
    15551555                            size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
    … …  
    22842284        uint64_t fFlags;
    22852285        rc = PGM_GST_PFN(GetPage,pVM)(pVM, GCPtrSrc, &fFlags, &GCPhys);
    2286         if (VBOX_SUCCESS(rc))
     2286        if (RT_SUCCESS(rc))
    22872287        {
    22882288            /** @todo we should check reserved bits ... */
    … …  
    23232323        RTGCPHYS GCPhys2;
    23242324        rc = PGM_GST_PFN(GetPage,pVM)(pVM, GCPtrSrc, &fFlags1, &GCPhys1);
    2325         if (VBOX_SUCCESS(rc))
     2325        if (RT_SUCCESS(rc))
    23262326            rc = PGM_GST_PFN(GetPage,pVM)(pVM, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
    2327         if (VBOX_SUCCESS(rc))
     2327        if (RT_SUCCESS(rc))
    23282328        {
    23292329            /** @todo we should check reserved bits ... */

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

    r13585 r13816  
    834834    uint32_t cbWritten;
    835835    int rc2 = EMInterpretInstructionCPU(pVM, pCpu, pRegFrame, pvFault, &cbWritten);
    836     if (VBOX_SUCCESS(rc2))
     836    if (RT_SUCCESS(rc2))
    837837        pRegFrame->rip += pCpu->opsize;
    838838    else if (rc2 == VERR_EM_INTERPRETER)
    … …  
    951951    uint32_t cb;
    952952    int rc = EMInterpretInstructionCPU(pVM, pCpu, pRegFrame, pvFault, &cb);
    953     if (VBOX_SUCCESS(rc))
     953    if (RT_SUCCESS(rc))
    954954        pRegFrame->rip += pCpu->opsize;
    955955    else if (rc == VERR_EM_INTERPRETER)
    … …  
    13191319                {
    13201320                    int rc = pgmPoolTrackAddUser(pPool, pPage, iUser, iUserTable);
    1321                     if (VBOX_SUCCESS(rc))
     1321                    if (RT_SUCCESS(rc))
    13221322                    {
    13231323                        *ppPage = pPage;
    … …  
    20942094    {
    20952095        int rc2 = pgmPoolCacheFreeOne(pPool, iUser);
    2096         if (VBOX_FAILURE(rc2) && rc == VINF_SUCCESS)
     2096        if (RT_FAILURE(rc2) && rc == VINF_SUCCESS)
    20972097            rc = rc2;
    20982098    } while (pPool->iUserFreeHead == NIL_PGMPOOL_USER_INDEX);
    … …  
    21402140    {
    21412141        int rc = pgmPoolTrackFreeOneUser(pPool, iUser);
    2142         if (VBOX_FAILURE(rc))
     2142        if (RT_FAILURE(rc))
    21432143            return rc;
    21442144        i = pPool->iUserFreeHead;
    … …  
    22442244    {
    22452245        int rc = pgmPoolTrackFreeOneUser(pPool, iUser);
    2246         if (VBOX_FAILURE(rc))
     2246        if (RT_FAILURE(rc))
    22472247            return rc;
    22482248        i = pPool->iUserFreeHead;
    … …  
    39203920        int rc = CTXALLMID(VMM, CallHost)(pPool->CTX_SUFF(pVM), VMMCALLHOST_PGM_POOL_GROW, 0);
    39213921#endif
    3922         if (VBOX_FAILURE(rc))
     3922        if (RT_FAILURE(rc))
    39233923            return rc;
    39243924        STAM_PROFILE_ADV_RESUME(&pPool->StatAlloc, a);
    … …  
    39763976    {
    39773977        int rc2 = pgmPoolCacheAlloc(pPool, GCPhys, enmKind, iUser, iUserTable, ppPage);
    3978         if (VBOX_SUCCESS(rc2))
     3978        if (RT_SUCCESS(rc2))
    39793979        {
    39803980            STAM_PROFILE_ADV_STOP(&pPool->StatAlloc, a);
    … …  
    39933993    {
    39943994        rc = pgmPoolMakeMoreFreePages(pPool, iUser);
    3995         if (VBOX_FAILURE(rc))
     3995        if (RT_FAILURE(rc))
    39963996        {
    39973997            if (rc != VERR_PGM_POOL_CLEARED)
    … …  
    40374037     */
    40384038    int rc3 = pgmPoolTrackInsert(pPool, pPage, GCPhys, iUser, iUserTable);
    4039     if (VBOX_FAILURE(rc3))
     4039    if (RT_FAILURE(rc3))
    40404040    {
    40414041        if (rc3 != VERR_PGM_POOL_CLEARED)

  • trunk/src/VBox/VMM/VMMAll/PGMAllShw.h

    r13415 r13816  
    157157    PX86PDPT        pPDPT;
    158158    int rc = PGM_HCPHYS_2_PTR(pVM, Pml4e.u & X86_PML4E_PG_MASK, &pPDPT);
    159     if (VBOX_FAILURE(rc))
     159    if (RT_FAILURE(rc))
    160160        return rc;
    161161    const unsigned  iPDPT = (GCPtr >> SHW_PDPT_SHIFT) & SHW_PDPT_MASK;
    … …  
    167167    PX86PDPAE       pPd;
    168168    rc = PGM_HCPHYS_2_PTR(pVM, Pdpe.u & X86_PDPE_PG_MASK, &pPd);
    169     if (VBOX_FAILURE(rc))
     169    if (RT_FAILURE(rc))
    170170        return rc;
    171171    const unsigned  iPd = (GCPtr >> SHW_PD_SHIFT) & SHW_PD_MASK;
    … …  
    214214    {
    215215        int rc = PGM_HCPHYS_2_PTR(pVM, Pde.u & SHW_PDE_PG_MASK, &pPT);
    216         if (VBOX_FAILURE(rc))
     216        if (RT_FAILURE(rc))
    217217            return rc;
    218218    }
    … …  
    304304        PX86PDPT        pPDPT;
    305305        rc = PGM_HCPHYS_2_PTR(pVM, Pml4e.u & X86_PML4E_PG_MASK, &pPDPT);
    306         if (VBOX_FAILURE(rc))
     306        if (RT_FAILURE(rc))
    307307            return rc;
    308308        const unsigned  iPDPT = (GCPtr >> SHW_PDPT_SHIFT) & SHW_PDPT_MASK;
    … …  
    314314        PX86PDPAE       pPd;
    315315        rc = PGM_HCPHYS_2_PTR(pVM, Pdpe.u & X86_PDPE_PG_MASK, &pPd);
    316         if (VBOX_FAILURE(rc))
     316        if (RT_FAILURE(rc))
    317317            return rc;
    318318        const unsigned iPd = (GCPtr >> SHW_PD_SHIFT) & SHW_PD_MASK;
    … …  
    350350        PSHWPT          pPT;
    351351        rc = PGM_HCPHYS_2_PTR(pVM, Pde.u & SHW_PDE_PG_MASK, &pPT);
    352         if (VBOX_FAILURE(rc))
     352        if (RT_FAILURE(rc))
    353353            return rc;
    354354

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

    r13577 r13816  
    10031003#  endif
    10041004
    1005         if (VBOX_FAILURE(rc))
     1005        if (RT_FAILURE(rc))
    10061006        {
    10071007            if (!fTriedAlready)
    … …  
    10221022        /* Reading too much. Could be cheaper than two seperate calls though. */
    10231023        rc = PGMPhysSimpleReadGCPtr(pVM, &tss, GCPtrTss, sizeof(VBOXTSS));
    1024         if (VBOX_FAILURE(rc))
     1024        if (RT_FAILURE(rc))
    10251025        {
    10261026            AssertReleaseMsgFailed(("Unable to read TSS structure at %08X\n", GCPtrTss));

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

    r13782 r13816  
    638638    PVMREQ pReq;
    639639    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)tmVirtualSetWarpDrive, 2, pVM, u32Percent);
    640     if (VBOX_SUCCESS(rc))
     640    if (RT_SUCCESS(rc))
    641641        rc = pReq->iStatus;
    642642    VMR3ReqFree(pReq);

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

    r13635 r13816  
    385385            rc = PGMPhysSimpleReadGCPtr(pVM, &pCallerGC, (RTGCPTR)pRegFrame->esp, sizeof(pCallerGC));
    386386#endif
    387             if (VBOX_SUCCESS(rc))
     387            if (RT_SUCCESS(rc))
    388388            {
    389389                Log(("TRPMForwardTrap: caller=%VGv\n", pCallerGC));
    … …  
    454454        rc = PGMPhysSimpleReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
    455455#endif
    456         if (VBOX_FAILURE(rc))
     456        if (RT_FAILURE(rc))
    457457        {
    458458            /* The page might be out of sync. */ /** @todo might cross a page boundary) */
    … …  
    470470#endif
    471471        }
    472         if (    VBOX_SUCCESS(rc)
     472        if (    RT_SUCCESS(rc)
    473473            &&  GuestIdte.Gen.u1Present
    474474            &&  (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_TRAP_32 || GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
    … …  
    514514                rc = PGMPhysSimpleReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
    515515#endif
    516                 if (VBOX_FAILURE(rc))
     516                if (RT_FAILURE(rc))
    517517                {
    518518                    /* The page might be out of sync. */ /** @todo might cross a page boundary) */
    … …  
    529529                    rc = PGMPhysSimpleReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
    530530#endif
    531                     if (VBOX_FAILURE(rc))
     531                    if (RT_FAILURE(rc))
    532532                    {
    533533                        Log(("MMGCRamRead failed with %Vrc\n", rc));
    … …  
    548548                {
    549549                    rc = SELMGetRing1Stack(pVM, &ss_r0, &esp_r0);
    550                     if (VBOX_FAILURE(rc))
     550                    if (RT_FAILURE(rc))
    551551                        goto failure;
    552552
    … …  
    597597                PGMPAGEMAPLOCK PageMappingLock;
    598598                rc = PGMPhysGCPtr2CCPtr(pVM, pTrapStackGC, (void **)&pTrapStack, &PageMappingLock);
    599                 if (VBOX_FAILURE(rc))
     599                if (RT_FAILURE(rc))
    600600                {
    601601                    AssertRC(rc);

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

    r13782 r13816  
    140140    void *pv;
    141141    int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
    142     if (VBOX_SUCCESS(rc2))
     142    if (RT_SUCCESS(rc2))
    143143    {
    144144        /* initialize it. */
    … …  
    317317    void *pv;
    318318    int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
    319     if (VBOX_SUCCESS(rc2))
     319    if (RT_SUCCESS(rc2))
    320320    {
    321321        /* initialize it. */
Note: See TracChangeset for help on using the changeset viewer.

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