VirtualBox

Changeset 14755 in vbox for trunk/src


Ignore:
Timestamp:
Nov 28, 2008 2:58:01 AM (16 years ago)
Author:
vboxsync
Message:

#1865: Converted 4 PGM*2HC* conversion functions to RTR3PTR.

Location:
trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r14075 r14755  
    578578    }
    579579
    580     rc = PGMPhysGCPtr2HCPtr(pVM, pGCPtr, &pHCPtr);
     580    rc = PGMPhysGCPtr2R3Ptr(pVM, pGCPtr, &pHCPtr);
    581581    if (rc != VINF_SUCCESS)
    582582    {
    … …  
    12791279            Log(("Jump through jump table\n"));
    12801280
    1281             rc2 = PGMPhysGCPtr2HCPtr(pVM, pJumpTableGC, (PRTHCPTR)&pJumpTableHC);
     1281            rc2 = PGMPhysGCPtr2R3Ptr(pVM, pJumpTableGC, (PRTHCPTR)&pJumpTableHC);
    12821282            if (rc2 == VINF_SUCCESS)
    12831283            {
    … …  
    23282328    if (PAGE_ADDRESS(GCPtrIDT) == PAGE_ADDRESS(GCPtrIDT+cGates*sizeof(VBOXIDTE)))
    23292329    {
    2330         /* Just convert the IDT address to a HC pointer. The whole IDT fits in one page. */
    2331         rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrIDT, (PRTHCPTR)&pGuestIdte);
     2330        /* Just convert the IDT address to a R3 pointer. The whole IDT fits in one page. */
     2331        rc = PGMPhysGCPtr2R3Ptr(pVM, GCPtrIDT, (PRTR3PTR)&pGuestIdte);
    23322332        if (RT_FAILURE(rc))
    23332333        {

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

    r13960 r14755  
    604604    {
    605605        /** @note pPrivInstrHC is probably not valid anymore */
    606         rc = PGMPhysGCPtr2HCPtr(pVM, pPatch->patch.pPrivInstrGC, (PRTHCPTR)&pPatch->patch.pPrivInstrHC);
     606        rc = PGMPhysGCPtr2R3Ptr(pVM, pPatch->patch.pPrivInstrGC, (PRTR3PTR)&pPatch->patch.pPrivInstrHC);
    607607        if (rc == VINF_SUCCESS)
    608608        {
    … …  
    790790    {
    791791        /** @note pPrivInstrHC is probably not valid anymore */
    792         rc = PGMPhysGCPtr2HCPtr(pVM, pPatch->patch.pPrivInstrGC, (PRTHCPTR)&pPatch->patch.pPrivInstrHC);
     792        rc = PGMPhysGCPtr2R3Ptr(pVM, pPatch->patch.pPrivInstrGC, (PRTR3PTR)&pPatch->patch.pPrivInstrHC);
    793793        if (rc == VINF_SUCCESS)
    794794        {
    … …  
    995995    }
    996996
    997     rc = PGMPhysGCPtr2HCPtr(pVM, pGCPtr, (void **)&pHCPtr);
     997    rc = PGMPhysGCPtr2R3Ptr(pVM, pGCPtr, (void **)&pHCPtr);
    998998    if (rc != VINF_SUCCESS)
    999999    {
    … …  
    41214121    }
    41224122    GCPhys = GCPhys + (pInstrGC & PAGE_OFFSET_MASK);
    4123     rc = PGMPhysGCPhys2HCPtr(pVM, GCPhys, MAX_INSTR_SIZE, (void **)&pInstrHC);
     4123    rc = PGMPhysGCPhys2R3Ptr(pVM, GCPhys, MAX_INSTR_SIZE, (void **)&pInstrHC);
    41244124    AssertRCReturn(rc, rc);
    41254125
    … …  
    44024402    uint8_t *pInstrHC;
    44034403
    4404     int rc = PGMPhysGCPtr2HCPtr(pVM, pInstrGC, (RTHCPTR *)&pInstrHC);
     4404    int rc = PGMPhysGCPtr2R3Ptr(pVM, pInstrGC, (PRTR3PTR)&pInstrHC);
    44054405    if (rc == VINF_SUCCESS)
    44064406    {
    … …  
    49994999
    50005000                /** pPrivInstrHC is probably not valid anymore */
    5001                 rc = PGMPhysGCPtr2HCPtr(pVM, pPatchRec->patch.pPrivInstrGC, (PRTHCPTR)&pPatchRec->patch.pPrivInstrHC);
     5001                rc = PGMPhysGCPtr2R3Ptr(pVM, pPatchRec->patch.pPrivInstrGC, (PRTR3PTR)&pPatchRec->patch.pPrivInstrHC);
    50025002                if (rc == VINF_SUCCESS)
    50035003                {
    … …  
    52185218                Assert(!(pPatch->flags & PATMFL_PATCHED_GUEST_CODE));
    52195219                /** @todo -> pPrivInstrHC is probably not valid anymore */
    5220                 rc = PGMPhysGCPtr2HCPtr(pVM, pPatchRec->patch.pPrivInstrGC, (PRTHCPTR)&pPatchRec->patch.pPrivInstrHC);
     5220                rc = PGMPhysGCPtr2R3Ptr(pVM, pPatchRec->patch.pPrivInstrGC, (PRTR3PTR)&pPatchRec->patch.pPrivInstrHC);
    52215221                if (rc == VINF_SUCCESS)
    52225222                {

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

    r13830 r14755  
    582582        pPatchRec->patch.pPrivInstrHC   = 0;
    583583        /* The GC virtual ptr is fixed, but we must convert it manually again to HC. */
    584         rc = PGMPhysGCPtr2HCPtr(pVM, pPatchRec->patch.pPrivInstrGC, (PRTHCPTR)&pPatchRec->patch.pPrivInstrHC);
     584        rc = PGMPhysGCPtr2R3Ptr(pVM, pPatchRec->patch.pPrivInstrGC, (PRTR3PTR)&pPatchRec->patch.pPrivInstrHC);
    585585        /* Can fail due to page or page table not present. */
    586586

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

    r14301 r14755  
    15331533                pVM->pgm.s.HCPhysShwPaePdpt,
    15341534                pVM->pgm.s.HCPhysShwPaePml4));
    1535 # endif 
     1535# endif
    15361536        LogRel(("Debug: HCPhysInterPD=%RHp HCPhysInterPaePDPT=%RHp HCPhysInterPaePML4=%RHp\n",
    15371537                pVM->pgm.s.HCPhysInterPD, pVM->pgm.s.HCPhysInterPaePDPT, pVM->pgm.s.HCPhysInterPaePML4));
    … …  
    26432643    PX86PD     pPDSrc = pVM->pgm.s.pGst32BitPdR3;
    26442644    Assert(pPDSrc);
    2645     Assert(PGMPhysGCPhys2HCPtrAssert(pVM, (RTGCPHYS)(CPUMGetGuestCR3(pVM) & X86_CR3_PAGE_MASK), sizeof(*pPDSrc)) == pPDSrc);
     2645    Assert(PGMPhysGCPhys2R3PtrAssert(pVM, (RTGCPHYS)(CPUMGetGuestCR3(pVM) & X86_CR3_PAGE_MASK), sizeof(*pPDSrc)) == pPDSrc);
    26462646
    26472647    /*

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

    r14750 r14755  
    251251#else
    252252# define PGM_GCPHYS_2_PTR(pVM, GCPhys, ppv) \
    253      PGMPhysGCPhys2HCPtr(pVM, GCPhys, 1 /* one page only */, (void **)(ppv)) /** @todo this isn't asserting, use PGMRamGCPhys2HCPtr! */
     253     PGMPhysGCPhys2R3Ptr(pVM, GCPhys, 1 /* one page only */, (PRTR3PTR)(ppv)) /** @todo this isn't asserting, use PGMRamGCPhys2HCPtr! */
    254254#endif
    255255
    … …  
    271271#else
    272272# define PGM_GCPHYS_2_PTR_EX(pVM, GCPhys, ppv) \
    273      PGMPhysGCPhys2HCPtr(pVM, GCPhys, 1 /* one page only */, (void **)(ppv)) /** @todo this isn't asserting, use PGMRamGCPhys2HCPtr! */
     273     PGMPhysGCPhys2R3Ptr(pVM, GCPhys, 1 /* one page only */, (PRTR3PTR)(ppv)) /** @todo this isn't asserting, use PGMRamGCPhys2HCPtr! */
    274274#endif
    275275
    … …  
    31823182 * @param   pHCPtr      Where to store the corresponding HC virtual address.
    31833183 *
    3184  * @deprecated  This will be eliminated by PGMPhysGCPhys2CCPtr.
     3184 * @deprecated  This will be eliminated by PGMPhysGCPhys2CCPtr. Only user is
     3185 *              pgmPoolMonitorGCPtr2CCPtr.
    31853186 */
    31863187DECLINLINE(int) pgmRamGCPhys2HCPtr(PPGM pPGM, RTGCPHYS GCPhys, PRTHCPTR pHCPtr)
    … …  
    32043205    if (pRam->pvR3)
    32053206    {
    3206         *pHCPtr = (RTHCPTR)((RTHCUINTPTR)pRam->pvR3 + off); /** @todo @bugref{1865,3202}: Code is converting R3 pointer and maybe using it in R0! */
     3207        *pHCPtr = (RTHCPTR)((RTHCUINTPTR)pRam->pvR3 + off);
    32073208        return VINF_SUCCESS;
    32083209    }
    … …  
    32113212}
    32123213# endif /* !VBOX_WITH_NEW_PHYS_CODE */
    3213 
    3214 
    3215 /**
    3216  * Convert GC Phys to HC Virt.
    3217  *
    3218  * @returns VBox status.
    3219  * @param   PVM         VM handle.
    3220  * @param   pRam        Ram range
    3221  * @param   GCPhys      The GC physical address.
    3222  * @param   pHCPtr      Where to store the corresponding HC virtual address.
    3223  *
    3224  * @deprecated  This will be eliminated. Don't use it.
    3225  */
    3226 DECLINLINE(int) pgmRamGCPhys2HCPtrWithRange(PVM pVM, PPGMRAMRANGE pRam, RTGCPHYS GCPhys, PRTHCPTR pHCPtr)
    3227 {
    3228     RTGCPHYS off = GCPhys - pRam->GCPhys;
    3229     Assert(off < pRam->cb);
    3230 
    3231     if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
    3232     {
    3233         unsigned idx = (off >> PGM_DYNAMIC_CHUNK_SHIFT);
    3234         /* Physical chunk in dynamically allocated range not present? */
    3235         if (RT_UNLIKELY(!pRam->paChunkR3Ptrs[idx]))
    3236         {
    3237 #ifdef IN_RING3
    3238             int rc = pgmr3PhysGrowRange(pVM, GCPhys);
    3239 #else
    3240             int rc = CTXALLMID(VMM, CallHost)(pVM, VMMCALLHOST_PGM_RAM_GROW_RANGE, GCPhys);
    3241 #endif
    3242             if (rc != VINF_SUCCESS)
    3243             {
    3244                 *pHCPtr = 0; /* GCC crap */
    3245                 return rc;
    3246             }
    3247         }
    3248         *pHCPtr = (RTHCPTR)(pRam->paChunkR3Ptrs[idx] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
    3249         return VINF_SUCCESS;
    3250     }
    3251     if (pRam->pvR3)
    3252     {
    3253         *pHCPtr = (RTHCPTR)((RTHCUINTPTR)pRam->pvR3 + off); /** @todo @bugref{1865,3202}: Code is converting R3 pointer and maybe using it in R0! */
    3254         return VINF_SUCCESS;
    3255     }
    3256     *pHCPtr = 0; /* GCC crap */
    3257     return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
    3258 }
    3259 
    32603214#endif /* !IN_RC && !defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0) */
    32613215
    … …  
    32993253    if (pRam->pvR3)
    33003254    {
    3301         *pHCPtr = (RTHCPTR)((RTHCUINTPTR)pRam->pvR3 + off); /** @todo @bugref{1865,3202}: Code is converting R3 pointer and maybe using it in R0! */
     3255        *pHCPtr = (RTHCPTR)((RTHCUINTPTR)pRam->pvR3 + off);
    33023256        return VINF_SUCCESS;
    33033257    }

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

    r14716 r14755  
    10971097        PX86PD pPD = pVM->pgm.s.pGst32BitPdR3;
    10981098        Assert(pPD);
    1099         Assert(pPD == (PX86PD)PGMPhysGCPhys2HCPtrAssert(pVM, cr3 & X86_CR3_PAGE_MASK, sizeof(*pPD)));
     1099        Assert(pPD == (PX86PD)PGMPhysGCPhys2R3PtrAssert(pVM, cr3 & X86_CR3_PAGE_MASK, sizeof(*pPD)));
    11001100
    11011101        for (PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3; pCur; pCur = pCur->pNextR3)

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

    r14351 r14755  
    13191319         */
    13201320        PVBOXIDTE   pIDTE;
    1321         int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrIDTE, (void **)&pIDTE);
     1321        int rc = PGMPhysGCPtr2R3Ptr(pVM, GCPtrIDTE, (void **)&pIDTE);
    13221322        if (RT_SUCCESS(rc))
    13231323        {

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

    r14562 r14755  
    352352
    353353
    354 /* Convert sel:addr to a flat GC address */
    355 static RTGCPTR emConvertToFlatAddr(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, POP_PARAMETER pParam, RTGCPTR pvAddr)
     354/** Convert sel:addr to a flat GC address. */
     355DECLINLINE(RTGCPTR) emConvertToFlatAddr(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, POP_PARAMETER pParam, RTGCPTR pvAddr)
    356356{
    357357    DIS_SELREG enmPrefixSeg = DISDetectSegReg(pCpu, pParam);
    … …  
    822822    }
    823823
    824     /* The destination is always a virtual address */
    825     AssertReturn(param1.type == PARMTYPE_ADDRESS, VERR_EM_INTERPRETER);
    826 
    827     RTGCPTR GCPtrPar1 = param1.val.val64;
    828     GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
    829 #ifdef IN_RC
    830     pvParam1  = (void *)GCPtrPar1;
    831 #else
    832     rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    833     if (RT_FAILURE(rc))
    834     {
    835         AssertRC(rc);
    836         return VERR_EM_INTERPRETER;
    837     }
    838 #endif
    839 
    840824#ifdef IN_RC
    841825    /* Safety check (in theory it could cross a page boundary and fault there though) */
    … …  
    849833    RTGCUINTREG ValPar2 = param2.val.val64;
    850834
    851     /* Try emulate it with a one-shot #PF handler in place. */
     835    /* The destination is always a virtual address */
     836    AssertReturn(param1.type == PARMTYPE_ADDRESS, VERR_EM_INTERPRETER);
     837
     838    RTGCPTR GCPtrPar1 = param1.val.val64;
     839    GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
     840#ifdef IN_RC
     841    pvParam1  = (void *)GCPtrPar1;
     842#else
     843    PGMPAGEMAPLOCK Lock;
     844    rc = PGMPhysGCPtr2CCPtr(pVM, GCPtrPar1, &pvParam1, &Lock);
     845    AssertRCReturn(rc, VERR_EM_INTERPRETER);
     846#endif
     847
     848    /* Try emulate it with a one-shot #PF handler in place. (RC) */
    852849    Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pCpu), GCPtrPar1, pCpu->param2.size*8, ValPar2));
    853850
    … …  
    859856#ifdef IN_RC
    860857    MMGCRamDeregisterTrapHandler(pVM);
     858#else
     859    PGMPhysReleasePageMappingLock(pVM, &Lock);
    861860#endif
    862861    if (RT_FAILURE(rc))
    … …  
    10891088    ValPar2 &= 7;
    10901089
    1091 #ifdef IN_RC
    10921090    GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
     1091#ifdef IN_RC
     1092    Assert(TRPMHasTrap(pVM));
     1093    EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)GCPtrPar1 & ~(RTGCUINTPTR)3) == pvFault, VERR_EM_INTERPRETER);
     1094#endif
     1095
     1096#ifdef IN_RC
    10931097    pvParam1  = (void *)GCPtrPar1;
    10941098#else
    1095     GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
    1096     rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    1097     if (RT_FAILURE(rc))
    1098     {
    1099         AssertRC(rc);
    1100         return VERR_EM_INTERPRETER;
    1101     }
     1099    PGMPAGEMAPLOCK Lock;
     1100    rc = PGMPhysGCPtr2CCPtr(pVM, GCPtrPar1, &pvParam1, &Lock);
     1101    AssertRCReturn(rc, VERR_EM_INTERPRETER);
    11021102#endif
    11031103
    11041104    Log2(("emInterpretLockBitTest %s: pvFault=%RGv GCPtrPar1=%RGv imm=%RX64\n", emGetMnemonic(pCpu), pvFault, GCPtrPar1, ValPar2));
    11051105
    1106 #ifdef IN_RC
    1107     Assert(TRPMHasTrap(pVM));
    1108     EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)GCPtrPar1 & ~(RTGCUINTPTR)3) == pvFault, VERR_EM_INTERPRETER);
    1109 #endif
    1110 
    1111     /* Try emulate it with a one-shot #PF handler in place. */
     1106    /* Try emulate it with a one-shot #PF handler in place. (RC) */
    11121107    RTGCUINTREG32 eflags = 0;
    11131108#ifdef IN_RC
    … …  
    11171112#ifdef IN_RC
    11181113    MMGCRamDeregisterTrapHandler(pVM);
     1114#else
     1115    PGMPhysReleasePageMappingLock(pVM, &Lock);
    11191116#endif
    11201117    if (RT_FAILURE(rc))
    … …  
    14231420        return VERR_EM_INTERPRETER;
    14241421
     1422    uint64_t valpar;
     1423    switch(param2.type)
     1424    {
     1425    case PARMTYPE_IMMEDIATE: /* register actually */
     1426        valpar = param2.val.val64;
     1427        break;
     1428
     1429    default:
     1430        return VERR_EM_INTERPRETER;
     1431    }
     1432
     1433    PGMPAGEMAPLOCK Lock;
    14251434    RTGCPTR  GCPtrPar1;
    14261435    void    *pvParam1;
    1427     uint64_t valpar, eflags;
     1436    uint64_t eflags;
    14281437
    14291438    AssertReturn(pCpu->param1.size == pCpu->param2.size, VERR_EM_INTERPRETER);
    … …  
    14341443        GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
    14351444
    1436         rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    1437         if (RT_FAILURE(rc))
    1438         {
    1439             AssertRC(rc);
    1440             return VERR_EM_INTERPRETER;
    1441         }
    1442         break;
    1443 
    1444     default:
    1445         return VERR_EM_INTERPRETER;
    1446     }
    1447 
    1448     switch(param2.type)
    1449     {
    1450     case PARMTYPE_IMMEDIATE: /* register actually */
    1451         valpar = param2.val.val64;
     1445        rc = PGMPhysGCPtr2CCPtr(pVM, GCPtrPar1, &pvParam1, &Lock);
     1446        AssertRCReturn(rc, VERR_EM_INTERPRETER);
    14521447        break;
    14531448
    … …  
    14701465
    14711466    *pcbSize = param2.size;
     1467    PGMPhysReleasePageMappingLock(pVM, &Lock);
    14721468    return VINF_SUCCESS;
    14731469}
    … …  
    14901486    void    *pvParam1;
    14911487    uint64_t eflags;
     1488    PGMPAGEMAPLOCK Lock;
    14921489
    14931490    AssertReturn(pCpu->param1.size == 8, VERR_EM_INTERPRETER);
    … …  
    14981495        GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
    14991496
    1500         rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrPar1, &pvParam1);
    1501         if (RT_FAILURE(rc))
    1502         {
    1503             AssertRC(rc);
    1504             return VERR_EM_INTERPRETER;
    1505         }
     1497        rc = PGMPhysGCPtr2CCPtr(pVM, GCPtrPar1, &pvParam1, &Lock);
     1498        AssertRCReturn(rc, VERR_EM_INTERPRETER);
    15061499        break;
    15071500
    … …  
    15241517
    15251518    *pcbSize = 8;
     1519    PGMPhysReleasePageMappingLock(pVM, &Lock);
    15261520    return VINF_SUCCESS;
    15271521}

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

    r14681 r14755  
    31673167    Assert(pPDSrc);
    31683168#   if !defined(IN_RC) && !defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    3169     Assert(PGMPhysGCPhys2HCPtrAssert(pVM, (RTGCPHYS)(cr3 & GST_CR3_PAGE_MASK), sizeof(*pPDSrc)) == pPDSrc);
     3169    Assert(PGMPhysGCPhys2R3PtrAssert(pVM, (RTGCPHYS)(cr3 & GST_CR3_PAGE_MASK), sizeof(*pPDSrc)) == (RTR3PTR)pPDSrc);
    31703170#   endif
    31713171#  endif /* PGM_GST_TYPE == PGM_TYPE_32BIT */

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

    r14560 r14755  
    705705    return PGMDynMapGCPageOff(pVM, GCPhys, ppv);
    706706# else
    707     return PGMPhysGCPhys2HCPtr(pVM, GCPhys, 1, ppv);
     707    return PGMPhysGCPhys2R3Ptr(pVM, GCPhys, 1, (PRTR3PTR)ppv);
    708708# endif
    709709#endif
    … …  
    850850
    851851/**
    852  * Converts a GC physical address to a HC pointer.
     852 * Converts a GC physical address to a HC ring-3 pointer.
    853853 *
    854854 * @returns VINF_SUCCESS on success.
    … …  
    859859 * @returns VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY if the range crosses
    860860 *          a dynamic ram chunk boundary
    861  * @param   pVM     The VM handle.
    862  * @param   GCPhys  The GC physical address to convert.
    863  * @param   cbRange Physical range
    864  * @param   pHCPtr  Where to store the HC pointer on success.
    865  */
    866 VMMDECL(int) PGMPhysGCPhys2HCPtr(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, PRTHCPTR pHCPtr) /** @todo @bugref{1865}: HCPtr -> R3Ptr */
     861 *
     862 * @param   pVM         The VM handle.
     863 * @param   GCPhys      The GC physical address to convert.
     864 * @param   cbRange     Physical range
     865 * @param   pR3Ptr      Where to store the R3 pointer on success.
     866 */
     867VMMDECL(int) PGMPhysGCPhys2R3Ptr(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, PRTR3PTR pR3Ptr)
    867868{
    868869#ifdef VBOX_WITH_NEW_PHYS_CODE
    … …  
    900901#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0) /* ASSUMES this is a rare occurence */
    901902        PRTR3UINTPTR paChunkR3Ptrs = (PRTR3UINTPTR)MMHyperR3ToCC(pVM, pRam->paChunkR3Ptrs);
    902         *pHCPtr = (RTHCPTR)(paChunkR3Ptrs[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
     903        *pR3Ptr = (RTR3PTR)(paChunkR3Ptrs[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
    903904#else
    904         *pHCPtr = (RTHCPTR)(pRam->paChunkR3Ptrs[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
     905        *pR3Ptr = (RTR3PTR)(pRam->paChunkR3Ptrs[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
    905906#endif
    906907    }
    907908    else if (RT_LIKELY(pRam->pvR3))
    908         *pHCPtr = (RTHCPTR)((RTR3UINTPTR)pRam->pvR3 + off);
     909        *pR3Ptr = (RTR3PTR)((RTR3UINTPTR)pRam->pvR3 + off);
    909910    else
    910911        return VERR_PGM_PHYS_PAGE_RESERVED;
    … …  
    914915
    915916/**
    916  * PGMPhysGCPhys2HCPtr convenience for use with assertions.
    917  *
    918  * @returns The HCPtr, NIL_RTHCPTR on failure.
     917 * PGMPhysGCPhys2R3Ptr convenience for use with assertions.
     918 *
     919 * @returns The R3Ptr, NIL_RTR3PTR on failure.
    919920 * @param   pVM         The VM handle.
    920921 * @param   GCPhys      The GC Physical addresss.
    921922 * @param   cbRange     Physical range.
    922923 */
    923 VMMDECL(RTHCPTR) PGMPhysGCPhys2HCPtrAssert(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange) /** @todo @bugref{1865}: HCPtr -> R3Ptr */
    924 {
    925     RTHCPTR HCPtr;
    926     int rc = PGMPhysGCPhys2HCPtr(pVM, GCPhys, cbRange, &HCPtr);
     924VMMDECL(RTR3PTR) PGMPhysGCPhys2R3PtrAssert(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange)
     925{
     926    RTR3PTR R3Ptr;
     927    int rc = PGMPhysGCPhys2R3Ptr(pVM, GCPhys, cbRange, &R3Ptr);
    927928    if (RT_SUCCESS(rc))
    928         return HCPtr;
    929     return NIL_RTHCPTR;
     929        return R3Ptr;
     930    return NIL_RTR3PTR;
    930931}
    931932
    … …  
    971972
    972973/**
    973  * Converts a guest pointer to a HC pointer.
     974 * Converts a guest pointer to a R3 pointer.
    974975 *
    975976 * This uses the current CR3/CR0/CR4 of the guest.
    … …  
    978979 * @param   pVM         The VM Handle
    979980 * @param   GCPtr       The guest pointer to convert.
    980  * @param   pHCPtr      Where to store the HC virtual address.
    981  */
    982 VMMDECL(int) PGMPhysGCPtr2HCPtr(PVM pVM, RTGCPTR GCPtr, PRTHCPTR pHCPtr) /** @todo @bugref{1865}: HCPtr -> R3Ptr */
     981 * @param   pR3Ptr      Where to store the R3 virtual address.
     982 */
     983VMMDECL(int) PGMPhysGCPtr2R3Ptr(PVM pVM, RTGCPTR GCPtr, PRTR3PTR pR3Ptr)
    983984{
    984985#ifdef VBOX_WITH_NEW_PHYS_CODE
    … …  
    989990    int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
    990991    if (RT_SUCCESS(rc))
    991         rc = PGMPhysGCPhys2HCPtr(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
     992        rc = PGMPhysGCPhys2R3Ptr(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pR3Ptr);
    992993    return rc;
    993994}
    … …  
    995996
    996997/**
    997  * Converts a guest virtual address to a HC pointer by specfied CR3 and flags.
     998 * Converts a guest virtual address to a HC ring-3 pointer by specfied CR3 and
     999 * flags.
    9981000 *
    9991001 * @returns VBox status code.
    … …  
    10021004 * @param   cr3         The guest CR3.
    10031005 * @param   fFlags      Flags used for interpreting the PD correctly: X86_CR4_PSE and X86_CR4_PAE
    1004  * @param   pHCPtr      Where to store the HC pointer.
     1006 * @param   pR3Ptr      Where to store the R3 pointer.
    10051007 *
    10061008 * @remark  This function is used by the REM at a time where PGM could
    … …  
    10081010 *          future DBGF API to cpu state independent conversions.
    10091011 */
    1010 VMMDECL(int) PGMPhysGCPtr2HCPtrByGstCR3(PVM pVM, RTGCPTR GCPtr, uint64_t cr3, unsigned fFlags, PRTHCPTR pHCPtr) /** @todo @bugref{1865}: HCPtr -> R3Ptr */
     1012VMMDECL(int) PGMPhysGCPtr2R3PtrByGstCR3(PVM pVM, RTGCPTR GCPtr, uint64_t cr3, unsigned fFlags, PRTR3PTR pR3Ptr)
    10111013{
    10121014#ifdef VBOX_WITH_NEW_PHYS_CODE
    … …  
    10301032                if ((fFlags & X86_CR4_PSE) && Pde.b.u1Size)
    10311033                {   /* (big page) */
    1032                     rc = PGMPhysGCPhys2HCPtr(pVM, pgmGstGet4MBPhysPage(&pVM->pgm.s, Pde) | ((RTGCUINTPTR)GCPtr & X86_PAGE_4M_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
     1034                    rc = PGMPhysGCPhys2R3Ptr(pVM, pgmGstGet4MBPhysPage(&pVM->pgm.s, Pde) | ((RTGCUINTPTR)GCPtr & X86_PAGE_4M_OFFSET_MASK),
     1035                                             1 /* we always stay within one page */, pR3Ptr);
    10331036                }
    10341037                else
    … …  
    10401043                        X86PTE Pte = pPT->a[((RTGCUINTPTR)GCPtr >> X86_PT_SHIFT) & X86_PT_MASK];
    10411044                        if (Pte.n.u1Present)
    1042                             return PGMPhysGCPhys2HCPtr(pVM, (Pte.u & X86_PTE_PG_MASK) | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
     1045                            return PGMPhysGCPhys2R3Ptr(pVM, (Pte.u & X86_PTE_PG_MASK) | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK),
     1046                                                       1 /* we always stay within one page */, pR3Ptr);
    10431047                        rc = VERR_PAGE_NOT_PRESENT;
    10441048                    }
    … …  
    10701074                        if ((fFlags & X86_CR4_PSE) && Pde.b.u1Size)
    10711075                        {   /* (big page) */
    1072                             rc = PGMPhysGCPhys2HCPtr(pVM, (Pde.u & X86_PDE2M_PAE_PG_MASK) | ((RTGCUINTPTR)GCPtr & X86_PAGE_2M_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
     1076                            rc = PGMPhysGCPhys2R3Ptr(pVM, (Pde.u & X86_PDE2M_PAE_PG_MASK) | ((RTGCUINTPTR)GCPtr & X86_PAGE_2M_OFFSET_MASK),
     1077                                                     1 /* we always stay within one page */, pR3Ptr);
    10731078                        }
    10741079                        else
    … …  
    10801085                                X86PTEPAE Pte = pPT->a[((RTGCUINTPTR)GCPtr >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK];
    10811086                                if (Pte.n.u1Present)
    1082                                     return PGMPhysGCPhys2HCPtr(pVM, (Pte.u & X86_PTE_PAE_PG_MASK) | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
     1087                                    return PGMPhysGCPhys2R3Ptr(pVM, (Pte.u & X86_PTE_PAE_PG_MASK) | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK),
     1088                                                               1 /* we always stay within one page */, pR3Ptr);
    10831089                                rc = VERR_PAGE_NOT_PRESENT;
    10841090                            }

  • trunk/src/recompiler/VBoxREMWrapper.cpp

    r14411 r14755  
    711711    { REMPARMDESC_FLAGS_GCPTR,      sizeof(RTGCPTR), NULL }
    712712};
    713 static const REMPARMDESC g_aArgsPGMPhysGCPhys2HCPtr[] =
     713static const REMPARMDESC g_aArgsPGMPhysGCPhys2R3Ptr[] =
    714714{
    715715    { REMPARMDESC_FLAGS_INT,        sizeof(PVM), NULL },
    716716    { REMPARMDESC_FLAGS_GCPHYS,     sizeof(RTGCPHYS), NULL },
    717717    { REMPARMDESC_FLAGS_INT,        sizeof(RTUINT), NULL },
    718     { REMPARMDESC_FLAGS_INT,        sizeof(PRTHCPTR), NULL }
    719 };
    720 static const REMPARMDESC g_aArgsPGMPhysGCPtr2HCPtrByGstCR3[] =
     718    { REMPARMDESC_FLAGS_INT,        sizeof(PRTR3PTR), NULL }
     719};
     720static const REMPARMDESC g_aArgsPGMPhysGCPtr2R3PtrByGstCR3[] =
    721721{
    722722    { REMPARMDESC_FLAGS_INT,        sizeof(PVM), NULL },
    … …  
    724724    { REMPARMDESC_FLAGS_INT,        sizeof(uint64_t), NULL },
    725725    { REMPARMDESC_FLAGS_INT,        sizeof(unsigned), NULL },
    726     { REMPARMDESC_FLAGS_INT,        sizeof(PRTHCPTR), NULL }
     726    { REMPARMDESC_FLAGS_INT,        sizeof(PRTR3PTR), NULL }
    727727};
    728728static const REMPARMDESC g_aArgsPGM3PhysGrowRange[] =
    … …  
    11121112    { "PGMGstGetPage",                          (void *)(uintptr_t)&PGMGstGetPage,                  &g_aArgsPGMGstGetPage[0],                   RT_ELEMENTS(g_aArgsPGMGstGetPage),                     REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11131113    { "PGMInvalidatePage",                      (void *)(uintptr_t)&PGMInvalidatePage,              &g_aArgsPGMInvalidatePage[0],               RT_ELEMENTS(g_aArgsPGMInvalidatePage),                 REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1114     { "PGMPhysGCPhys2HCPtr",                    (void *)(uintptr_t)&PGMPhysGCPhys2HCPtr,            &g_aArgsPGMPhysGCPhys2HCPtr[0],             RT_ELEMENTS(g_aArgsPGMPhysGCPhys2HCPtr),               REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1115     { "PGMPhysGCPtr2HCPtrByGstCR3",             (void *)(uintptr_t)&PGMPhysGCPtr2HCPtrByGstCR3,     &g_aArgsPGMPhysGCPtr2HCPtrByGstCR3[0],      RT_ELEMENTS(g_aArgsPGMPhysGCPtr2HCPtrByGstCR3),        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1114    { "PGMPhysGCPhys2R3Ptr",                    (void *)(uintptr_t)&PGMPhysGCPhys2R3Ptr,            &g_aArgsPGMPhysGCPhys2R3Ptr[0],             RT_ELEMENTS(g_aArgsPGMPhysGCPhys2R3Ptr),               REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1115    { "PGMPhysGCPtr2R3PtrByGstCR3",             (void *)(uintptr_t)&PGMPhysGCPtr2R3PtrByGstCR3,     &g_aArgsPGMPhysGCPtr2R3PtrByGstCR3[0],      RT_ELEMENTS(g_aArgsPGMPhysGCPtr2R3PtrByGstCR3),        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11161116#ifndef VBOX_WITH_NEW_PHYS_CODE
    11171117    { "PGM3PhysGrowRange",                      (void *)(uintptr_t)&PGM3PhysGrowRange,              &g_aArgsPGM3PhysGrowRange[0],               RT_ELEMENTS(g_aArgsPGM3PhysGrowRange),                 REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },

  • trunk/src/recompiler/VBoxRecompiler.c

    r14411 r14755  
    34773477
    34783478        /* convert eip to physical address. */
    3479         int rc = PGMPhysGCPtr2HCPtrByGstCR3(env->pVM,
     3479        int rc = PGMPhysGCPtr2R3PtrByGstCR3(env->pVM,
    34803480                                            GCPtrPC,
    34813481                                            env->cr[3],
    … …  
    34933493    {
    34943494        /* physical address */
    3495         int rc = PGMPhysGCPhys2HCPtr(env->pVM, (RTGCPHYS)GCPtrPC, nrInstructions * 16, &pvPC);
     3495        int rc = PGMPhysGCPhys2R3Ptr(env->pVM, (RTGCPHYS)GCPtrPC, nrInstructions * 16, &pvPC);
    34963496        if (RT_FAILURE(rc))
    34973497            return false;
    … …  
    35723572    {
    35733573        /* convert eip to physical address. */
    3574         int rc = PGMPhysGCPtr2HCPtrByGstCR3(pVM,
     3574        int rc = PGMPhysGCPtr2R3PtrByGstCR3(pVM,
    35753575                                            GCPtrPC,
    35763576                                            env->cr[3],
    … …  
    35893589
    35903590        /* physical address */
    3591         int rc = PGMPhysGCPhys2HCPtr(pVM, (RTGCPHYS)GCPtrPC, 16, &pvPC);
     3591        int rc = PGMPhysGCPhys2R3Ptr(pVM, (RTGCPHYS)GCPtrPC, 16, &pvPC);
    35923592        if (RT_FAILURE(rc))
    35933593            return false;

  • trunk/src/recompiler_new/VBoxREMWrapper.cpp

    r14475 r14755  
    711711    { REMPARMDESC_FLAGS_GCPTR,      sizeof(RTGCPTR), NULL }
    712712};
    713 static const REMPARMDESC g_aArgsPGMPhysGCPhys2HCPtr[] =
     713static const REMPARMDESC g_aArgsPGMPhysGCPhys2R3Ptr[] =
    714714{
    715715    { REMPARMDESC_FLAGS_INT,        sizeof(PVM), NULL },
    716716    { REMPARMDESC_FLAGS_GCPHYS,     sizeof(RTGCPHYS), NULL },
    717717    { REMPARMDESC_FLAGS_INT,        sizeof(RTUINT), NULL },
    718     { REMPARMDESC_FLAGS_INT,        sizeof(PRTHCPTR), NULL }
    719 };
    720 static const REMPARMDESC g_aArgsPGMPhysGCPtr2HCPtrByGstCR3[] =
     718    { REMPARMDESC_FLAGS_INT,        sizeof(PRTR3PTR), NULL }
     719};
     720static const REMPARMDESC g_aArgsPGMPhysGCPtr2R3PtrByGstCR3[] =
    721721{
    722722    { REMPARMDESC_FLAGS_INT,        sizeof(PVM), NULL },
    … …  
    724724    { REMPARMDESC_FLAGS_INT,        sizeof(uint64_t), NULL },
    725725    { REMPARMDESC_FLAGS_INT,        sizeof(unsigned), NULL },
    726     { REMPARMDESC_FLAGS_INT,        sizeof(PRTHCPTR), NULL }
     726    { REMPARMDESC_FLAGS_INT,        sizeof(PRTR3PTR), NULL }
    727727};
    728728static const REMPARMDESC g_aArgsPGM3PhysGrowRange[] =
    … …  
    803803    { REMPARMDESC_FLAGS_INT,        sizeof(PVM), NULL },
    804804    { REMPARMDESC_FLAGS_INT,        sizeof(void*), NULL },
    805     { REMPARMDESC_FLAGS_INT,        sizeof(PRTGCPHYS), NULL }   
     805    { REMPARMDESC_FLAGS_INT,        sizeof(PRTGCPHYS), NULL }
    806806};
    807807static const REMPARMDESC g_aArgsPGMHandlerIsAddressMonitored[] =
    … …  
    11281128    { "PGMGstGetPage",                          (void *)(uintptr_t)&PGMGstGetPage,                  &g_aArgsPGMGstGetPage[0],                   RT_ELEMENTS(g_aArgsPGMGstGetPage),                     REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11291129    { "PGMInvalidatePage",                      (void *)(uintptr_t)&PGMInvalidatePage,              &g_aArgsPGMInvalidatePage[0],               RT_ELEMENTS(g_aArgsPGMInvalidatePage),                 REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1130     { "PGMPhysGCPhys2HCPtr",                    (void *)(uintptr_t)&PGMPhysGCPhys2HCPtr,            &g_aArgsPGMPhysGCPhys2HCPtr[0],             RT_ELEMENTS(g_aArgsPGMPhysGCPhys2HCPtr),               REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1131     { "PGMPhysGCPtr2HCPtrByGstCR3",             (void *)(uintptr_t)&PGMPhysGCPtr2HCPtrByGstCR3,     &g_aArgsPGMPhysGCPtr2HCPtrByGstCR3[0],      RT_ELEMENTS(g_aArgsPGMPhysGCPtr2HCPtrByGstCR3),        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1130    { "PGMPhysGCPhys2R3Ptr",                    (void *)(uintptr_t)&PGMPhysGCPhys2R3Ptr,            &g_aArgsPGMPhysGCPhys2R3Ptr[0],             RT_ELEMENTS(g_aArgsPGMPhysGCPhys2R3Ptr),               REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1131    { "PGMPhysGCPtr2R3PtrByGstCR3",             (void *)(uintptr_t)&PGMPhysGCPtr2R3PtrByGstCR3,     &g_aArgsPGMPhysGCPtr2R3PtrByGstCR3[0],      RT_ELEMENTS(g_aArgsPGMPhysGCPtr2R3PtrByGstCR3),        REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11321132#ifndef VBOX_WITH_NEW_PHYS_CODE
    11331133    { "PGM3PhysGrowRange",                      (void *)(uintptr_t)&PGM3PhysGrowRange,              &g_aArgsPGM3PhysGrowRange[0],               RT_ELEMENTS(g_aArgsPGM3PhysGrowRange),                 REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    … …  
    11801180    { "VMR3ReqCall",                            (void *)(uintptr_t)&VMR3ReqCall,                    &g_aArgsVMR3ReqCall[0],                     RT_ELEMENTS(g_aArgsVMR3ReqCall),                       REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11811181    { "VMR3ReqFree",                            (void *)(uintptr_t)&VMR3ReqFree,                    &g_aArgsVMR3ReqFree[0],                     RT_ELEMENTS(g_aArgsVMR3ReqFree),                       REMFNDESC_FLAGS_RET_INT | REMFNDESC_FLAGS_ELLIPSIS, sizeof(int), NULL },
    1182     { "VMR3GetVMCPUId",                         (void *)(uintptr_t)&VMR3GetVMCPUId,                 &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },   
     1182    { "VMR3GetVMCPUId",                         (void *)(uintptr_t)&VMR3GetVMCPUId,                 &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    11831183    { "VMR3GetVMCPUNativeThread",               (void *)(uintptr_t)&VMR3GetVMCPUNativeThread,       &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(void *),     NULL },
    11841184//    { "",                        (void *)(uintptr_t)&,                &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(int),   NULL },

  • trunk/src/recompiler_new/VBoxRecompiler.c

    r14742 r14755  
    13951395    int rc;
    13961396
    1397     rc = PGMPhysGCPhys2HCPtr(env1->pVM, (RTGCPHYS)physAddr, 1, &rv);
     1397    rc = PGMPhysGCPhys2R3Ptr(env1->pVM, (RTGCPHYS)physAddr, 1, &rv);
    13981398    Assert (RT_SUCCESS(rc));
    13991399
    … …  
    35713571
    35723572        /* convert eip to physical address. */
    3573         rc = PGMPhysGCPtr2HCPtrByGstCR3(env->pVM,
     3573        rc = PGMPhysGCPtr2R3PtrByGstCR3(env->pVM,
    35743574                                        GCPtrPC,
    35753575                                        env->cr[3],
    … …  
    35873587    {
    35883588        /* physical address */
    3589         rc = PGMPhysGCPhys2HCPtr(env->pVM, (RTGCPHYS)GCPtrPC, nrInstructions * 16,
     3589        rc = PGMPhysGCPhys2R3Ptr(env->pVM, (RTGCPHYS)GCPtrPC, nrInstructions * 16,
    35903590                                 (void**)&pvPC);
    35913591        if (RT_FAILURE(rc))
    … …  
    36723672    {
    36733673        /* convert eip to physical address. */
    3674         int rc = PGMPhysGCPtr2HCPtrByGstCR3(pVM,
     3674        int rc = PGMPhysGCPtr2R3PtrByGstCR3(pVM,
    36753675                                            GCPtrPC,
    36763676                                            env->cr[3],
    … …  
    36893689
    36903690        /* physical address */
    3691         int rc = PGMPhysGCPhys2HCPtr(pVM, (RTGCPHYS)GCPtrPC, 16, (void**)&pvPC);
     3691        int rc = PGMPhysGCPhys2R3Ptr(pVM, (RTGCPHYS)GCPtrPC, 16, (void**)&pvPC);
    36923692        if (RT_FAILURE(rc))
    36933693            return false;
    … …  
    42224222}
    42234223
    4224 uint64_t cpu_rdmsr(CPUX86State *env, uint32_t msr) 
    4225 { 
    4226     return CPUMGetGuestMsr(env->pVM, msr); 
    4227 } 
    4228 
    4229 void cpu_wrmsr(CPUX86State *env, uint32_t msr, uint64_t val) 
    4230 { 
    4231     CPUMSetGuestMsr(env->pVM, msr, val); 
    4232 } 
     4224uint64_t cpu_rdmsr(CPUX86State *env, uint32_t msr)
     4225{
     4226    return CPUMGetGuestMsr(env->pVM, msr);
     4227}
     4228
     4229void cpu_wrmsr(CPUX86State *env, uint32_t msr, uint64_t val)
     4230{
     4231    CPUMSetGuestMsr(env->pVM, msr, val);
     4232}
    42334233/* -+- I/O Ports -+- */
    42344234
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