VirtualBox

Ignore:
Timestamp:
Jul 26, 2019 4:12:06 PM (6 years ago)
Author:
vboxsync
Message:

VMM: Kicking out raw-mode (work in progress). bugref:9517

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r76553 r80014  
    6363    if (!VALID_PTR(pHitAddress))
    6464        return VERR_INVALID_POINTER;
    65     if (DBGFADDRESS_IS_HMA(pAddress))
    66         return VERR_INVALID_POINTER;
    6765
    6866    /*
    … …  
    161159
    162160    /*
    163      * HMA is special.
     161     * Select PGM worker by addressing mode.
    164162     */
    165163    int rc;
    166     if (DBGFADDRESS_IS_HMA(pAddress))
    167     {
    168         if (DBGFADDRESS_IS_PHYS(pAddress))
    169             rc = VERR_INVALID_POINTER;
    170         else
    171             rc = MMR3HyperReadGCVirt(pVM, pvBuf, pAddress->FlatPtr, cbRead);
    172     }
     164    PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
     165    PGMMODE enmMode = PGMGetGuestMode(pVCpu);
     166    if (    enmMode == PGMMODE_REAL
     167        ||  enmMode == PGMMODE_PROTECTED
     168        ||  DBGFADDRESS_IS_PHYS(pAddress) )
     169        rc = PGMPhysSimpleReadGCPhys(pVM, pvBuf, pAddress->FlatPtr, cbRead);
    173170    else
    174171    {
    175         /*
    176          * Select PGM worker by addressing mode.
    177          */
    178         PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
    179         PGMMODE enmMode = PGMGetGuestMode(pVCpu);
    180         if (    enmMode == PGMMODE_REAL
    181             ||  enmMode == PGMMODE_PROTECTED
    182             ||  DBGFADDRESS_IS_PHYS(pAddress) )
    183             rc = PGMPhysSimpleReadGCPhys(pVM, pvBuf, pAddress->FlatPtr, cbRead);
    184         else
    185         {
    186172#if GC_ARCH_BITS > 32
    187             if (    (   pAddress->FlatPtr >= _4G
    188                      || pAddress->FlatPtr + cbRead > _4G)
    189                 &&  enmMode != PGMMODE_AMD64
    190                 &&  enmMode != PGMMODE_AMD64_NX)
    191                 return VERR_PAGE_TABLE_NOT_PRESENT;
     173        if (    (   pAddress->FlatPtr >= _4G
     174                 || pAddress->FlatPtr + cbRead > _4G)
     175            &&  enmMode != PGMMODE_AMD64
     176            &&  enmMode != PGMMODE_AMD64_NX)
     177            return VERR_PAGE_TABLE_NOT_PRESENT;
    192178#endif
    193             rc = PGMPhysSimpleReadGCPtr(pVCpu, pvBuf, pAddress->FlatPtr, cbRead);
    194         }
     179        rc = PGMPhysSimpleReadGCPtr(pVCpu, pvBuf, pAddress->FlatPtr, cbRead);
    195180    }
    196181    return rc;
    … …  
    327312
    328313    /*
    329      * HMA is always special.
     314     * Select PGM function by addressing mode.
    330315     */
    331316    int rc;
    332     if (DBGFADDRESS_IS_HMA(pAddress))
    333     {
    334         /** @todo write to HMA. */
    335         rc = VERR_ACCESS_DENIED;
    336     }
     317    PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
     318    PGMMODE enmMode = PGMGetGuestMode(pVCpu);
     319    if (    enmMode == PGMMODE_REAL
     320        ||  enmMode == PGMMODE_PROTECTED
     321        ||  DBGFADDRESS_IS_PHYS(pAddress) )
     322        rc = PGMPhysSimpleWriteGCPhys(pVM, pAddress->FlatPtr, pvBuf, cbWrite);
    337323    else
    338324    {
    339         /*
    340          * Select PGM function by addressing mode.
    341          */
    342         PVMCPU  pVCpu   = VMMGetCpuById(pVM, idCpu);
    343         PGMMODE enmMode = PGMGetGuestMode(pVCpu);
    344         if (    enmMode == PGMMODE_REAL
    345             ||  enmMode == PGMMODE_PROTECTED
    346             ||  DBGFADDRESS_IS_PHYS(pAddress) )
    347             rc = PGMPhysSimpleWriteGCPhys(pVM, pAddress->FlatPtr, pvBuf, cbWrite);
    348         else
    349         {
    350325#if GC_ARCH_BITS > 32
    351             if (    (   pAddress->FlatPtr >= _4G
    352                      || pAddress->FlatPtr + cbWrite > _4G)
    353                 &&  enmMode != PGMMODE_AMD64
    354                 &&  enmMode != PGMMODE_AMD64_NX)
    355                 return VERR_PAGE_TABLE_NOT_PRESENT;
     326        if (    (   pAddress->FlatPtr >= _4G
     327                 || pAddress->FlatPtr + cbWrite > _4G)
     328            &&  enmMode != PGMMODE_AMD64
     329            &&  enmMode != PGMMODE_AMD64_NX)
     330            return VERR_PAGE_TABLE_NOT_PRESENT;
    356331#endif
    357             rc = PGMPhysSimpleWriteGCPtr(pVCpu, pAddress->FlatPtr, pvBuf, cbWrite);
    358         }
     332        rc = PGMPhysSimpleWriteGCPtr(pVCpu, pAddress->FlatPtr, pvBuf, cbWrite);
    359333    }
    360334    return rc;
    … …  
    392366     * Make the query.
    393367     */
    394     int rc;
    395     if (!(fFlags & DBGFSELQI_FLAGS_DT_SHADOW))
    396     {
    397         PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
    398         VMCPU_ASSERT_EMT(pVCpu);
    399         rc = SELMR3GetSelectorInfo(pVM, pVCpu, Sel, pSelInfo);
    400 
    401         /*
    402          * 64-bit mode HACKS for making data and stack selectors wide open when
    403          * queried. This is voodoo magic.
    404          */
    405         if (fFlags & DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)
     368    PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
     369    VMCPU_ASSERT_EMT(pVCpu);
     370    int rc = SELMR3GetSelectorInfo(pVCpu, Sel, pSelInfo);
     371
     372    /*
     373     * 64-bit mode HACKS for making data and stack selectors wide open when
     374     * queried. This is voodoo magic.
     375     */
     376    if (fFlags & DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)
     377    {
     378        /* Expand 64-bit data and stack selectors. The check is a bit bogus... */
     379        if (    RT_SUCCESS(rc)
     380            &&  (pSelInfo->fFlags & (  DBGFSELINFO_FLAGS_LONG_MODE | DBGFSELINFO_FLAGS_REAL_MODE | DBGFSELINFO_FLAGS_PROT_MODE
     381                                     | DBGFSELINFO_FLAGS_GATE      | DBGFSELINFO_FLAGS_HYPER
     382                                     | DBGFSELINFO_FLAGS_INVALID   | DBGFSELINFO_FLAGS_NOT_PRESENT))
     383                 == DBGFSELINFO_FLAGS_LONG_MODE
     384            &&  pSelInfo->cbLimit != ~(RTGCPTR)0
     385            &&  CPUMIsGuestIn64BitCode(pVCpu) )
    406386        {
    407             /* Expand 64-bit data and stack selectors. The check is a bit bogus... */
    408             if (    RT_SUCCESS(rc)
    409                 &&  (pSelInfo->fFlags & (  DBGFSELINFO_FLAGS_LONG_MODE | DBGFSELINFO_FLAGS_REAL_MODE | DBGFSELINFO_FLAGS_PROT_MODE
    410                                          | DBGFSELINFO_FLAGS_GATE      | DBGFSELINFO_FLAGS_HYPER
    411                                          | DBGFSELINFO_FLAGS_INVALID   | DBGFSELINFO_FLAGS_NOT_PRESENT))
    412                      == DBGFSELINFO_FLAGS_LONG_MODE
    413                 &&  pSelInfo->cbLimit != ~(RTGCPTR)0
    414                 &&  CPUMIsGuestIn64BitCode(pVCpu) )
    415             {
    416                 pSelInfo->GCPtrBase = 0;
    417                 pSelInfo->cbLimit   = ~(RTGCPTR)0;
    418             }
    419             else if (   Sel == 0
    420                      && CPUMIsGuestIn64BitCode(pVCpu))
    421             {
    422                 pSelInfo->GCPtrBase = 0;
    423                 pSelInfo->cbLimit   = ~(RTGCPTR)0;
    424                 pSelInfo->Sel       = 0;
    425                 pSelInfo->SelGate   = 0;
    426                 pSelInfo->fFlags    = DBGFSELINFO_FLAGS_LONG_MODE;
    427                 pSelInfo->u.Raw64.Gen.u1Present  = 1;
    428                 pSelInfo->u.Raw64.Gen.u1Long     = 1;
    429                 pSelInfo->u.Raw64.Gen.u1DescType = 1;
    430                 rc = VINF_SUCCESS;
    431             }
     387            pSelInfo->GCPtrBase = 0;
     388            pSelInfo->cbLimit   = ~(RTGCPTR)0;
    432389        }
    433     }
    434     else
    435     {
    436         if (!VM_IS_RAW_MODE_ENABLED(pVM))
    437             rc = VERR_INVALID_STATE;
    438         else
    439             rc = SELMR3GetShadowSelectorInfo(pVM, Sel, pSelInfo);
     390        else if (   Sel == 0
     391                 && CPUMIsGuestIn64BitCode(pVCpu))
     392        {
     393            pSelInfo->GCPtrBase = 0;
     394            pSelInfo->cbLimit   = ~(RTGCPTR)0;
     395            pSelInfo->Sel       = 0;
     396            pSelInfo->SelGate   = 0;
     397            pSelInfo->fFlags    = DBGFSELINFO_FLAGS_LONG_MODE;
     398            pSelInfo->u.Raw64.Gen.u1Present  = 1;
     399            pSelInfo->u.Raw64.Gen.u1Long     = 1;
     400            pSelInfo->u.Raw64.Gen.u1DescType = 1;
     401            rc = VINF_SUCCESS;
     402        }
    440403    }
    441404    return rc;
    … …  
    473436    UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
    474437    AssertReturn(idCpu < pUVM->cCpus, VERR_INVALID_CPU_ID);
    475     AssertReturn(!(fFlags & ~(DBGFSELQI_FLAGS_DT_GUEST | DBGFSELQI_FLAGS_DT_SHADOW | DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)), VERR_INVALID_PARAMETER);
    476     AssertReturn(    (fFlags & (DBGFSELQI_FLAGS_DT_SHADOW | DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE))
    477                   !=           (DBGFSELQI_FLAGS_DT_SHADOW | DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE), VERR_INVALID_PARAMETER);
     438    AssertReturn(!(fFlags & ~(DBGFSELQI_FLAGS_DT_GUEST | DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)), VERR_INVALID_PARAMETER);
    478439
    479440    /* Clear the return data here on this thread. */
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