VirtualBox

Changeset 105745 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Aug 21, 2024 7:16:50 AM (5 months ago)
Author:
vboxsync
Message:

VMM/PGM: Some preparations for ARMv8 page table walking, introduce dedicated PGMMODE enumerations for ARMv8 and hide all accesses behind PGMMODE_XXX macros, bugref:10388

Location:
trunk/src/VBox/VMM/VMMR3
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r105724 r105745  
    6868    /** The address space for resolving symbol. */
    6969    RTDBGAS         hDbgAs;
     70#if !defined(VBOX_VMM_TARGET_ARMV8)
    7071    /** Pointer to the first byte in the segment. */
    7172    RTGCUINTPTR     GCPtrSegBase;
    … …  
    7475    /** The size of the segment minus 1. */
    7576    RTGCUINTPTR     cbSegLimit;
     77#endif
    7678    /** The guest paging mode. */
    7779    PGMMODE         enmMode;
    … …  
    9496*   Internal Functions                                                                                                           *
    9597*********************************************************************************************************************************/
    96 #if !defined(VBOX_VMM_TARGET_ARMV8)
    9798static FNDISREADBYTES dbgfR3DisasInstrRead;
    9899
    … …  
    114115                                 RTGCPTR GCPtr, uint32_t fFlags, PDBGFDISASSTATE pState)
    115116{
     117#if !defined(VBOX_VMM_TARGET_ARMV8)
    116118    pState->GCPtrSegBase    = pSelInfo->GCPtrBase;
    117119    pState->GCPtrSegEnd     = pSelInfo->cbLimit + 1 + (RTGCUINTPTR)pSelInfo->GCPtrBase;
    118120    pState->cbSegLimit      = pSelInfo->cbLimit;
     121    pState->f64Bits         = enmMode >= PGMMODE_AMD64 && pSelInfo->u.Raw.Gen.u1Long;
     122#else
     123    RT_NOREF(pSelInfo);
     124
     125    pState->f64Bits         = CPUMGetGuestCodeBits(pVCpu) == 64;
     126#endif
    119127    pState->enmMode         = enmMode;
    120128    pState->GCPtrPage       = 0;
    … …  
    124132    pState->pVCpu           = pVCpu;
    125133    pState->fLocked         = false;
    126     pState->f64Bits         = enmMode >= PGMMODE_AMD64 && pSelInfo->u.Raw.Gen.u1Long;
    127134
    128135    DISCPUMODE enmCpuMode;
    … …  
    133140            RT_FALL_THRU();
    134141        case DBGF_DISAS_FLAGS_DEFAULT_MODE:
    135             enmCpuMode   = pState->f64Bits
    136                          ? DISCPUMODE_64BIT
    137                          : pSelInfo->u.Raw.Gen.u1DefBig
    138                          ? DISCPUMODE_32BIT
    139                          : DISCPUMODE_16BIT;
     142            enmCpuMode = CPUMGetGuestDisMode(pVCpu);
    140143            break;
     144#if !defined(VBOX_VMM_TARGET_ARMV8)
    141145        case DBGF_DISAS_FLAGS_16BIT_MODE:
    142146        case DBGF_DISAS_FLAGS_16BIT_REAL_MODE:
    … …  
    149153            enmCpuMode = DISCPUMODE_64BIT;
    150154            break;
     155#else
     156        case DBGF_DISAS_FLAGS_16BIT_MODE: /** @todo r=aeichner This is a bit abusive... */
     157        case DBGF_DISAS_FLAGS_16BIT_REAL_MODE:
     158            enmCpuMode = DISCPUMODE_ARMV8_T32;
     159            break;
     160        case DBGF_DISAS_FLAGS_32BIT_MODE:
     161            enmCpuMode = DISCPUMODE_ARMV8_A32;
     162            break;
     163        case DBGF_DISAS_FLAGS_64BIT_MODE:
     164            enmCpuMode = DISCPUMODE_ARMV8_A64;
     165            break;
     166#endif
    151167    }
    152168
    … …  
    221237    for (;;)
    222238    {
     239#if !defined(VBOX_VMM_TARGET_ARMV8)
    223240        RTGCUINTPTR GCPtr = pDis->uInstrAddr + offInstr + pState->GCPtrSegBase;
     241#else
     242        RTGCUINTPTR GCPtr = pDis->uInstrAddr + offInstr;
     243#endif
    224244
    225245        /*
    … …  
    235255            if (pState->fLocked)
    236256                PGMPhysReleasePageMappingLock(pState->pVM, &pState->PageMapLock);
    237             if (pState->enmMode <= PGMMODE_PROTECTED)
     257            if (PGMMODE_WITH_PAGING(pState->enmMode))
     258                rc = PGMPhysGCPtr2CCPtrReadOnly(pState->pVCpu, pState->GCPtrPage, &pState->pvPageR3, &pState->PageMapLock);
     259            else
    238260                rc = PGMPhysGCPhys2CCPtrReadOnly(pState->pVM, pState->GCPtrPage, &pState->pvPageR3, &pState->PageMapLock);
    239             else
    240                 rc = PGMPhysGCPtr2CCPtrReadOnly(pState->pVCpu, pState->GCPtrPage, &pState->pvPageR3, &pState->PageMapLock);
    241261            if (RT_SUCCESS(rc))
    242262                pState->fLocked = true;
    … …  
    249269        }
    250270
     271        uint32_t cb = GUEST_PAGE_SIZE - (GCPtr & GUEST_PAGE_OFFSET_MASK);
     272#if !defined(VBOX_VMM_TARGET_ARMV8)
    251273        /*
    252274         * Check the segment limit.
    … …  
    258280         * Calc how much we can read, maxing out the read.
    259281         */
    260         uint32_t cb = GUEST_PAGE_SIZE - (GCPtr & GUEST_PAGE_OFFSET_MASK);
    261282        if (!pState->f64Bits)
    262283        {
    … …  
    265286                cb = cbSeg;
    266287        }
     288#endif
    267289        if (cb > cbMaxRead)
    268290            cb = cbMaxRead;
    … …  
    298320    DBGFADDRESS     Addr;
    299321    int             rc;
     322#if !defined(VBOX_VMM_TARGET_ARMV8)
    300323    /* Start with CS. */
    301324    if (   DIS_FMT_SEL_IS_REG(u32Sel)
    … …  
    326349        rc = VERR_SYMBOL_NOT_FOUND;
    327350    }
     351#else
     352    RT_NOREF(pSelInfo, u32Sel);
     353
     354    DBGFR3AddrFromFlat(pState->pVM->pUVM, &Addr, uAddress);
     355    rc = VINF_SUCCESS;
     356#endif
    328357
    329358    /*
    … …  
    353382    return rc;
    354383}
    355 #endif /* VBOX_VMM_TARGET_ARMV8 */
    356384
    357385
    … …  
    383411
    384412#if defined(VBOX_VMM_TARGET_ARMV8)
    385     RT_NOREF(pVM, pVCpu, Sel, GCPtr, rc, fFlags, pszOutput, cbOutput, pcbInstr, pDisState);
    386     //AssertFailed(); /** @todo */
    387     return VERR_NOT_IMPLEMENTED;
     413    DBGFSELINFO     SelInfo; RT_ZERO(SelInfo);
     414    const PGMMODE   enmMode = PGMGetGuestMode(pVCpu);
     415    const bool      fRealModeAddress = false;
     416    if (fFlags & DBGF_DISAS_FLAGS_CURRENT_GUEST)
     417        GCPtr = CPUMGetGuestFlatPC(pVCpu);
    388418#else
    389419    /*
    … …  
    428458        SelInfo.GCPtrBase               = pSRegCS->u64Base;
    429459        SelInfo.cbLimit                 = pSRegCS->u32Limit;
    430         SelInfo.fFlags                  = PGMMODE_IS_LONG_MODE(enmMode)
     460        SelInfo.fFlags                  = PGMMODE_IS_64BIT_MODE(enmMode)
    431461                                        ? DBGFSELINFO_FLAGS_LONG_MODE
    432462                                        : enmMode != PGMMODE_REAL && !pCtx->eflags.Bits.u1VM
    … …  
    452482        SelInfo.GCPtrBase               = 0;
    453483        SelInfo.cbLimit                 = ~(RTGCUINTPTR)0;
    454         SelInfo.fFlags                  = PGMMODE_IS_LONG_MODE(enmMode)
     484        SelInfo.fFlags                  = PGMMODE_IS_64BIT_MODE(enmMode)
    455485                                        ? DBGFSELINFO_FLAGS_LONG_MODE
    456486                                        : enmMode != PGMMODE_REAL
    … …  
    512542        }
    513543    }
     544#endif
    514545
    515546    /*
    … …  
    531562     */
    532563    char szBuf[512];
     564#if defined(VBOX_VMM_TARGET_ARMV8)
     565    DISFormatArmV8Ex(&State.Dis, szBuf, sizeof(szBuf),
     566                     DIS_FMT_FLAGS_RELATIVE_BRANCH,
     567                     fFlags & DBGF_DISAS_FLAGS_NO_SYMBOLS ? NULL : dbgfR3DisasGetSymbol,
     568                     NULL);
     569#else
    533570    DISFormatYasmEx(&State.Dis, szBuf, sizeof(szBuf),
    534571                    DIS_FMT_FLAGS_RELATIVE_BRANCH,
    535572                    fFlags & DBGF_DISAS_FLAGS_NO_SYMBOLS ? NULL : dbgfR3DisasGetSymbol,
    536573                    &SelInfo);
     574#endif
    537575
    538576    /*
    … …  
    548586        else if (Sel == DBGF_SEL_FLAT)
    549587        {
    550             if (enmMode >= PGMMODE_AMD64)
     588            if (PGMMODE_IS_64BIT_MODE(enmMode))
    551589                cch = RTStrPrintf(pszOutput, cbOutput, "%RGv  %s", GCPtr, szBuf);
    552590            else
    … …  
    555593        else
    556594        {
    557             if (enmMode >= PGMMODE_AMD64)
     595            if (PGMMODE_IS_64BIT_MODE(enmMode))
    558596                cch = RTStrPrintf(pszOutput, cbOutput, "%04x:%RGv  %s", Sel, GCPtr, szBuf);
    559597            else
    … …  
    576614        else if (Sel == DBGF_SEL_FLAT)
    577615        {
    578             if (enmMode >= PGMMODE_AMD64)
     616            if (PGMMODE_IS_64BIT_MODE(enmMode))
    579617                cch = RTStrPrintf(pszOutput, cbOutput, "%RGv %.*Rhxs%*s %s",
    580618                                  GCPtr,
    … …  
    589627        else
    590628        {
    591             if (enmMode >= PGMMODE_AMD64)
     629            if (PGMMODE_IS_64BIT_MODE(enmMode))
    592630                cch = RTStrPrintf(pszOutput, cbOutput, "%04x:%RGv %.*Rhxs%*s %s",
    593631                                  Sel, GCPtr,
    … …  
    617655    dbgfR3DisasInstrDone(&State);
    618656    return VINF_SUCCESS;
    619 #endif /* !VBOX_VMM_TARGET_ARMV8*/
    620657}
    621658

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

    r105352 r105745  
    8080    PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
    8181    PGMMODE enmMode = PGMGetGuestMode(pVCpu);
    82     if (    enmMode == PGMMODE_REAL
    83         ||  enmMode == PGMMODE_PROTECTED
     82    if (    !PGMMODE_WITH_PAGING(enmMode)
    8483        ||  DBGFADDRESS_IS_PHYS(pAddress)
    8584        )
    … …  
    9897        if (    (   pAddress->FlatPtr >= _4G
    9998                 || pAddress->FlatPtr + cbRange > _4G)
    100             &&  enmMode != PGMMODE_AMD64
    101             &&  enmMode != PGMMODE_AMD64_NX)
     99            &&  !PGMMODE_IS_64BIT_MODE(enmMode))
    102100            return VERR_DBGF_MEM_NOT_FOUND;
    103101#endif
    … …  
    174172    PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
    175173    PGMMODE enmMode = PGMGetGuestMode(pVCpu);
    176     if (    enmMode == PGMMODE_REAL
    177         ||  enmMode == PGMMODE_PROTECTED
    178         ||  DBGFADDRESS_IS_PHYS(pAddress) )
     174    if (    !PGMMODE_WITH_PAGING(enmMode)
     175        ||  DBGFADDRESS_IS_PHYS(pAddress))
    179176        rc = PGMPhysSimpleReadGCPhys(pVM, pvBuf, pAddress->FlatPtr, cbRead);
    180177    else
    … …  
    183180        if (    (   pAddress->FlatPtr >= _4G
    184181                 || pAddress->FlatPtr + cbRead > _4G)
    185             &&  enmMode != PGMMODE_AMD64
    186             &&  enmMode != PGMMODE_AMD64_NX)
     182            &&  !PGMMODE_IS_64BIT_MODE(enmMode))
    187183            return VERR_PAGE_TABLE_NOT_PRESENT;
    188184#endif
    … …  
    327323    PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
    328324    PGMMODE enmMode = PGMGetGuestMode(pVCpu);
    329     if (    enmMode == PGMMODE_REAL
    330         ||  enmMode == PGMMODE_PROTECTED
    331         ||  DBGFADDRESS_IS_PHYS(pAddress) )
     325    if (   !PGMMODE_WITH_PAGING(enmMode)
     326        || DBGFADDRESS_IS_PHYS(pAddress))
    332327        rc = PGMPhysSimpleWriteGCPhys(pVM, pAddress->FlatPtr, pvBuf, cbWrite);
    333328    else
    … …  
    336331        if (    (   pAddress->FlatPtr >= _4G
    337332                 || pAddress->FlatPtr + cbWrite > _4G)
    338             &&  enmMode != PGMMODE_AMD64
    339             &&  enmMode != PGMMODE_AMD64_NX)
     333            &&  !PGMMODE_IS_64BIT_MODE(enmMode))
    340334            return VERR_PAGE_TABLE_NOT_PRESENT;
    341335#endif
    … …  
    512506    switch (enmMode)
    513507    {
     508#if !defined(VBOX_VMM_TARGET_ARMV8)
    514509        case PGMMODE_32_BIT:
    515510            return DBGFPGDMP_FLAGS_PSE;
    … …  
    534529        default:
    535530            AssertFailedReturn(UINT32_MAX);
     531#else
     532        case PGMMODE_NONE:
     533            return 0;
     534        default:
     535            AssertFailedReturn(UINT32_MAX);
     536#endif
    536537    }
    537538}

  • trunk/src/VBox/VMM/VMMR3/PGM-armv8.cpp

    r104885 r105745  
    4343#include <VBox/vmm/pgm.h>
    4444#include <VBox/vmm/cpum.h>
     45#include <VBox/vmm/cpum-armv8.h>
    4546#include <VBox/vmm/iom.h>
    4647#include <VBox/sup.h>
    … …  
    722723VMMDECL(PGMMODE) PGMGetGuestMode(PVMCPU pVCpu)
    723724{
    724     return pVCpu->pgm.s.enmGuestMode;
     725    VMCPU_ASSERT_EMT(pVCpu);
     726
     727    bool fMmuEnabled = CPUMGetGuestMmuEnabled(pVCpu);
     728    if (!fMmuEnabled)
     729        return PGMMODE_NONE;
     730
     731    CPUMMODE enmCpuMode = CPUMGetGuestMode(pVCpu);
     732    return   enmCpuMode == CPUMMODE_ARMV8_AARCH64
     733           ? PGMMODE_VMSA_V8_64
     734           : PGMMODE_VMSA_V8_32;
    725735}
    726736
    … …  
    728738VMMDECL(PGMMODE) PGMGetShadowMode(PVMCPU pVCpu)
    729739{
    730     return pVCpu->pgm.s.enmShadowMode;
     740    RT_NOREF(pVCpu);
     741    return PGMMODE_NONE; /* NEM doesn't need any shadow paging. */
    731742}
    732743
    … …  
    736747    VMCPU_ASSERT_EMT(pVCpu);
    737748    Assert(pWalk);
    738     AssertReleaseFailed();
     749    //AssertReleaseFailed();
    739750    RT_NOREF(pVCpu, GCPtr, pWalk);
    740751    return VERR_NOT_IMPLEMENTED;

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

    r104840 r105745  
    10001000     */
    10011001    const bool      fAllZero  = ASMMemIsZero(pabNeedle, cbNeedle);
    1002     RTGCPTR         GCPtrMask = PGMMODE_IS_LONG_MODE(enmMode) ? UINT64_MAX : UINT32_MAX;
     1002    RTGCPTR         GCPtrMask = PGMMODE_IS_64BIT_MODE(enmMode) ? UINT64_MAX : UINT32_MAX;
    10031003    uint8_t         abPrev[MAX_NEEDLE_SIZE];
    10041004    size_t          cbPrev    = 0;
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