VirtualBox

Changeset 77481 in vbox


Ignore:
Timestamp:
Feb 27, 2019 12:59:58 PM (6 years ago)
Author:
vboxsync
Message:

VMM/IEM: Nested VMX: bugref:9180 Renamed VMCSCACHE to VMXVMCSBATCHCACHE to better reflects its nature and use. This is a generic cache that uses array/linear-lookup for VMCS fields and is solely used atm for 64-on-32 bit host.

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMR0/HMR0A.asm

    r76678 r77481  
    867867; load the guest ones when necessary.
    868868;
    869 ; @cproto       DECLASM(int) HMR0VMXStartVMhmR0DumpDescriptorM(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM,
    870 ;                                                              PVMCPU pVCpu, PFNHMVMXSTARTVM pfnStartVM);
     869; @cproto       DECLASM(int) HMR0VMXStartVMhmR0DumpDescriptorM(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pCache,
     870;                                                              PVM pVM, PVMCPU pVCpu, PFNHMVMXSTARTVM pfnStartVM);
    871871;
    872872; @returns      eax
    … …  
    874874; @param        fResumeVM       msc:rcx
    875875; @param        pCtx            msc:rdx
    876 ; @param        pVMCSCache      msc:r8
     876; @param        pVmcsCache      msc:r8
    877877; @param        pVM             msc:r9
    878878; @param        pVCpu           msc:[rbp+30h]   The cross context virtual CPU structure of the calling EMT.
    … …  
    898898        mov     [xBP + 010h], rcx       ; fResumeVM
    899899        mov     [xBP + 018h], rdx       ; pCtx
    900         mov     [xBP + 020h], r8        ; pVMCSCache
     900        mov     [xBP + 020h], r8        ; pVmcsCache
    901901        mov     [xBP + 028h], r9        ; pVM
    902902
    … …  
    913913        mov     rcx, [xBP + 010h]       ; fResumeVM
    914914        mov     rdx, [xBP + 018h]       ; pCtx
    915         mov     r8,  [xBP + 020h]       ; pVMCSCache
     915        mov     r8,  [xBP + 020h]       ; pVmcsCache
    916916        mov     r9,  [xBP + 028h]       ; pVM
    917917        call    r11
    … …  
    954954        mov     rcx, [xBP + 010h]       ; fResumeVM
    955955        mov     rdx, [xBP + 018h]       ; pCtx
    956         mov     r8,  [xBP + 020h]       ; pVMCSCache
     956        mov     r8,  [xBP + 020h]       ; pVmcsCache
    957957        mov     r9,  [xBP + 028h]       ; pVM
    958958        call    r11
    … …  
    10161016        mov     rcx, [xBP + 010h]       ; fResumeVM
    10171017        mov     rdx, [xBP + 018h]       ; pCtx
    1018         mov     r8,  [xBP + 020h]       ; pVMCSCache
     1018        mov     r8,  [xBP + 020h]       ; pVmcsCache
    10191019        mov     r9,  [xBP + 028h]       ; pVM
    10201020        call    r11
    … …  
    12971297
    12981298 %ifdef VMX_USE_CACHED_VMCS_ACCESSES
    1299     pop     xDX         ; Saved pCache
     1299    pop     xDX         ; Saved pVmcsCache
    13001300
    13011301    ; Note! If we get here as a result of invalid VMCS pointer, all the following
    13021302    ; vmread's will fail (only eflags.cf=1 will be set) but that shouldn't cause any
    13031303    ; trouble only just less efficient.
    1304     mov     ecx, [ss:xDX + VMCSCACHE.Read.cValidEntries]
     1304    mov     ecx, [ss:xDX + VMXVMCSBATCHCACHE.Read.cValidEntries]
    13051305    cmp     ecx, 0      ; Can't happen
    13061306    je      %%no_cached_read32
    … …  
    13101310%%cached_read32:
    13111311    dec     xCX
    1312     mov     eax, [ss:xDX + VMCSCACHE.Read.aField + xCX * 4]
     1312    mov     eax, [ss:xDX + VMXVMCSBATCHCACHE.Read.aField + xCX * 4]
    13131313    ; Note! This leaves the high 32 bits of the cache entry unmodified!!
    1314     vmread  [ss:xDX + VMCSCACHE.Read.aFieldVal + xCX * 8], xAX
     1314    vmread  [ss:xDX + VMXVMCSBATCHCACHE.Read.aFieldVal + xCX * 8], xAX
    13151315    cmp     xCX, 0
    13161316    jnz     %%cached_read32
    … …  
    13411341; @param    fResume    x86:[ebp+8], msc:rcx,gcc:rdi     Whether to use vmlauch/vmresume.
    13421342; @param    pCtx       x86:[ebp+c], msc:rdx,gcc:rsi     Pointer to the guest-CPU context.
    1343 ; @param    pCache    x86:[ebp+10],msc:r8, gcc:rdx     Pointer to the VMCS cache.
     1343; @param    pVmcsCache x86:[ebp+10],msc:r8, gcc:rdx     Pointer to the VMCS cache.
    13441344; @param    pVM        x86:[ebp+14],msc:r9, gcc:rcx     The cross context VM structure.
    13451345; @param    pVCpu      x86:[ebp+18],msc:[ebp+30],gcc:r8 The cross context virtual CPU structure of the calling EMT.
    … …  
    13781378    ; fResume already in rdi
    13791379    ; pCtx    already in rsi
    1380     mov     rbx, rdx        ; pCache
     1380    mov     rbx, rdx        ; pVmcsCache
    13811381 %else
    13821382    mov     rdi, rcx        ; fResume
    13831383    mov     rsi, rdx        ; pCtx
    1384     mov     rbx, r8         ; pCache
     1384    mov     rbx, r8         ; pVmcsCache
    13851385 %endif
    13861386%else
    13871387    mov     edi, [ebp + 8]  ; fResume
    13881388    mov     esi, [ebp + 12] ; pCtx
    1389     mov     ebx, [ebp + 16] ; pCache
     1389    mov     ebx, [ebp + 16] ; pVmcsCache
    13901390%endif
    13911391
    … …  
    14281428
    14291429%ifdef VMX_USE_CACHED_VMCS_ACCESSES
    1430     mov     ecx, [xBX + VMCSCACHE.Write.cValidEntries]
     1430    mov     ecx, [xBX + VMXVMCSBATCHCACHE.Write.cValidEntries]
    14311431    cmp     ecx, 0
    14321432    je      .no_cached_writes
    … …  
    14371437ALIGN(16)
    14381438.cached_write:
    1439     mov     eax, [xBX + VMCSCACHE.Write.aField + xCX * 4]
    1440     vmwrite xAX, [xBX + VMCSCACHE.Write.aFieldVal + xCX * 8]
     1439    mov     eax, [xBX + VMXVMCSBATCHCACHE.Write.aField + xCX * 4]
     1440    vmwrite xAX, [xBX + VMXVMCSBATCHCACHE.Write.aFieldVal + xCX * 8]
    14411441    inc     xCX
    14421442    cmp     xCX, xDX
    14431443    jl     .cached_write
    14441444
    1445     mov     dword [xBX + VMCSCACHE.Write.cValidEntries], 0
     1445    mov     dword [xBX + VMXVMCSBATCHCACHE.Write.cValidEntries], 0
    14461446.no_cached_writes:
    14471447
    1448     ; Save the pCache pointer.
     1448    ; Save the pVmcsCache pointer.
    14491449    push    xBX
    14501450%endif
    … …  
    16241624
    16251625 %ifdef VMX_USE_CACHED_VMCS_ACCESSES
    1626     pop     xDX         ; Saved pCache
     1626    pop     xDX         ; Saved pVmcsCache
    16271627
    16281628    ; Note! If we get here as a result of invalid VMCS pointer, all the following
    16291629    ; vmread's will fail (only eflags.cf=1 will be set) but that shouldn't cause any
    16301630    ; trouble only just less efficient.
    1631     mov     ecx, [xDX + VMCSCACHE.Read.cValidEntries]
     1631    mov     ecx, [xDX + VMXVMCSBATCHCACHE.Read.cValidEntries]
    16321632    cmp     ecx, 0      ; Can't happen
    16331633    je      %%no_cached_read64
    … …  
    16371637%%cached_read64:
    16381638    dec     xCX
    1639     mov     eax, [xDX + VMCSCACHE.Read.aField + xCX * 4]
    1640     vmread  [xDX + VMCSCACHE.Read.aFieldVal + xCX * 8], xAX
     1639    mov     eax, [xDX + VMXVMCSBATCHCACHE.Read.aField + xCX * 4]
     1640    vmread  [xDX + VMXVMCSBATCHCACHE.Read.aFieldVal + xCX * 8], xAX
    16411641    cmp     xCX, 0
    16421642    jnz     %%cached_read64
    … …  
    16671667; @param    fResume    msc:rcx, gcc:rdi     Whether to use vmlauch/vmresume.
    16681668; @param    pCtx       msc:rdx, gcc:rsi     Pointer to the guest-CPU context.
    1669 ; @param    pCache    msc:r8,  gcc:rdx     Pointer to the VMCS cache.
     1669; @param    pVmcsCache msc:r8,  gcc:rdx     Pointer to the VMCS cache.
    16701670; @param    pVM        msc:r9,  gcc:rcx     The cross context VM structure.
    16711671; @param    pVCpu      msc:[ebp+30], gcc:r8 The cross context virtual CPU structure of the calling EMT.
    … …  
    16941694    ; fResume already in rdi
    16951695    ; pCtx    already in rsi
    1696     mov     rbx, rdx        ; pCache
     1696    mov     rbx, rdx        ; pVmcsCache
    16971697%else
    16981698    mov     rdi, rcx        ; fResume
    16991699    mov     rsi, rdx        ; pCtx
    1700     mov     rbx, r8         ; pCache
     1700    mov     rbx, r8         ; pVmcsCache
    17011701%endif
    17021702
    … …  
    17371737
    17381738%ifdef VMX_USE_CACHED_VMCS_ACCESSES
    1739     mov     ecx, [xBX + VMCSCACHE.Write.cValidEntries]
     1739    mov     ecx, [xBX + VMXVMCSBATCHCACHE.Write.cValidEntries]
    17401740    cmp     ecx, 0
    17411741    je      .no_cached_writes
    … …  
    17461746ALIGN(16)
    17471747.cached_write:
    1748     mov     eax, [xBX + VMCSCACHE.Write.aField + xCX * 4]
    1749     vmwrite xAX, [xBX + VMCSCACHE.Write.aFieldVal + xCX * 8]
     1748    mov     eax, [xBX + VMXVMCSBATCHCACHE.Write.aField + xCX * 4]
     1749    vmwrite xAX, [xBX + VMXVMCSBATCHCACHE.Write.aFieldVal + xCX * 8]
    17501750    inc     xCX
    17511751    cmp     xCX, xDX
    17521752    jl     .cached_write
    17531753
    1754     mov     dword [xBX + VMCSCACHE.Write.cValidEntries], 0
     1754    mov     dword [xBX + VMXVMCSBATCHCACHE.Write.cValidEntries], 0
    17551755.no_cached_writes:
    17561756
    1757     ; Save the pCache pointer.
     1757    ; Save the pVmcsCache pointer.
    17581758    push    xBX
    17591759%endif

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

    r77463 r77481  
    49884988    PVM pVM = pVCpu->CTX_SUFF(pVM);
    49894989#ifdef VBOX_WITH_KERNEL_USING_XMM
    4990     int rc = hmR0VMXStartVMWrapXMM(fResumeVM, pCtx, &pVCpu->hm.s.vmx.VMCSCache, pVM, pVCpu, pVCpu->hm.s.vmx.pfnStartVM);
     4990    int rc = hmR0VMXStartVMWrapXMM(fResumeVM, pCtx, &pVCpu->hm.s.vmx.VmcsBatchCache, pVM, pVCpu, pVCpu->hm.s.vmx.pfnStartVM);
    49914991#else
    4992     int rc = pVCpu->hm.s.vmx.pfnStartVM(fResumeVM, pCtx, &pVCpu->hm.s.vmx.VMCSCache, pVM, pVCpu);
     4992    int rc = pVCpu->hm.s.vmx.pfnStartVM(fResumeVM, pCtx, &pVCpu->hm.s.vmx.VmcsBatchCache, pVM, pVCpu);
    49934993#endif
    49944994    AssertMsg(rc <= VINF_SUCCESS, ("%Rrc\n", rc));
    … …  
    52675267    AssertReturn(pVM->hm.s.pfnHost32ToGuest64R0, VERR_HM_NO_32_TO_64_SWITCHER);
    52685268    Assert(enmOp > HM64ON32OP_INVALID && enmOp < HM64ON32OP_END);
    5269     Assert(pVCpu->hm.s.vmx.VMCSCache.Write.cValidEntries <= RT_ELEMENTS(pVCpu->hm.s.vmx.VMCSCache.Write.aField));
    5270     Assert(pVCpu->hm.s.vmx.VMCSCache.Read.cValidEntries <= RT_ELEMENTS(pVCpu->hm.s.vmx.VMCSCache.Read.aField));
     5269    Assert(pVCpu->hm.s.vmx.VmcsBatchCache.Write.cValidEntries <= RT_ELEMENTS(pVCpu->hm.s.vmx.VmcsBatchCache.Write.aField));
     5270    Assert(pVCpu->hm.s.vmx.VmcsBatchCache.Read.cValidEntries <= RT_ELEMENTS(pVCpu->hm.s.vmx.VmcsBatchCache.Read.aField));
    52715271
    52725272#ifdef VBOX_STRICT
    5273     for (uint32_t i = 0; i < pVCpu->hm.s.vmx.VMCSCache.Write.cValidEntries; i++)
    5274         Assert(hmR0VmxIsValidWriteField(pVCpu->hm.s.vmx.VMCSCache.Write.aField[i]));
    5275 
    5276     for (uint32_t i = 0; i <pVCpu->hm.s.vmx.VMCSCache.Read.cValidEntries; i++)
    5277         Assert(hmR0VmxIsValidReadField(pVCpu->hm.s.vmx.VMCSCache.Read.aField[i]));
     5273    for (uint32_t i = 0; i < pVCpu->hm.s.vmx.VmcsBatchCache.Write.cValidEntries; i++)
     5274        Assert(hmR0VmxIsValidWriteField(pVCpu->hm.s.vmx.VmcsBatchCache.Write.aField[i]));
     5275
     5276    for (uint32_t i = 0; i <pVCpu->hm.s.vmx.VmcsBatchCache.Read.cValidEntries; i++)
     5277        Assert(hmR0VmxIsValidReadField(pVCpu->hm.s.vmx.VmcsBatchCache.Read.aField[i]));
    52785278#endif
    52795279
    … …  
    53435343 * @param   pVCpu       The cross context virtual CPU structure.
    53445344 */
    5345 DECLASM(int) VMXR0SwitcherStartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu)
     5345DECLASM(int) VMXR0SwitcherStartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pCache, PVM pVM, PVMCPU pVCpu)
    53465346{
    53475347    NOREF(fResume);
    … …  
    53735373    aParam[2] = RT_LO_U32(pVCpu->hm.s.vmx.HCPhysVmcs);                  /* Param 2: VMCS physical address - Lo. */
    53745374    aParam[3] = RT_HI_U32(pVCpu->hm.s.vmx.HCPhysVmcs);                  /* Param 2: VMCS physical address - Hi. */
    5375     aParam[4] = VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hm.s.vmx.VMCSCache);
     5375    aParam[4] = VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hm.s.vmx.VmcsBatchCache);
    53765376    aParam[5] = 0;
    53775377    aParam[6] = VM_RC_ADDR(pVM, pVM);
    … …  
    54005400    AssertMsg(pCache->TestIn.pCache        == pCache->TestOut.pCache, ("%RGv vs %RGv\n", pCache->TestIn.pCache,
    54015401                                                                       pCache->TestOut.pCache));
    5402     AssertMsg(pCache->TestIn.pCache        == VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hm.s.vmx.VMCSCache),
    5403               ("%RGv vs %RGv\n", pCache->TestIn.pCache, VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hm.s.vmx.VMCSCache)));
     5402    AssertMsg(pCache->TestIn.pCache        == VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hm.s.vmx.VmcsBatchCache),
     5403              ("%RGv vs %RGv\n", pCache->TestIn.pCache, VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hm.s.vmx.VmcsBatchCache)));
    54045404    AssertMsg(pCache->TestIn.pCtx          == pCache->TestOut.pCtx, ("%RGv vs %RGv\n", pCache->TestIn.pCtx,
    54055405                                                                     pCache->TestOut.pCtx));
    … …  
    54325432    } while (0)
    54335433
    5434     PVMCSCACHE pCache = &pVCpu->hm.s.vmx.VMCSCache;
     5434    PVMXVMCSBATCHCACHE pCache = &pVCpu->hm.s.vmx.VmcsBatchCache;
    54355435    uint32_t cReadFields = 0;
    54365436
    … …  
    56125612{
    56135613    AssertPtr(pVCpu);
    5614     PVMCSCACHE pCache = &pVCpu->hm.s.vmx.VMCSCache;
    5615 
    5616     AssertMsgReturn(pCache->Write.cValidEntries < VMCSCACHE_MAX_ENTRY - 1,
     5614    PVMXVMCSBATCHCACHE pCache = &pVCpu->hm.s.vmx.VmcsBatchCache;
     5615
     5616    AssertMsgReturn(pCache->Write.cValidEntries < VMX_VMCS_BATCH_CACHE_MAX_ENTRY - 1,
    56175617                    ("entries=%u\n", pCache->Write.cValidEntries), VERR_ACCESS_DENIED);
    56185618

  • trunk/src/VBox/VMM/VMMR0/HMVMXR0.h

    r76585 r77481  
    4646VMMR0DECL(int)          VMXR0ImportStateOnDemand(PVMCPU pVCpu, uint64_t fWhat);
    4747VMMR0DECL(VBOXSTRICTRC) VMXR0RunGuestCode(PVMCPU pVCpu);
    48 DECLASM(int)            VMXR0StartVM32(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu);
    49 DECLASM(int)            VMXR0StartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu);
     48DECLASM(int)            VMXR0StartVM32(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pVmcsCache, PVM pVM, PVMCPU pVCpu);
     49DECLASM(int)            VMXR0StartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pVmcsCache, PVM pVM, PVMCPU pVCpu);
    5050
    5151# if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    52 DECLASM(int)            VMXR0SwitcherStartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu);
     52DECLASM(int)            VMXR0SwitcherStartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pVmcsCache, PVM pVM, PVMCPU pVCpu);
    5353VMMR0DECL(int)          VMXR0Execute64BitsHandler(PVMCPU pVCpu, HM64ON32OP enmOp, uint32_t cbParam, uint32_t *paParam);
    5454# endif
    … …  
    6161{
    6262    Assert(idxCache <= VMX_VMCS_MAX_NESTED_PAGING_CACHE_IDX);
    63     *pVal = pVCpu->hm.s.vmx.VMCSCache.Read.aFieldVal[idxCache];
     63    *pVal = pVCpu->hm.s.vmx.VmcsBatchCache.Read.aFieldVal[idxCache];
    6464    return VINF_SUCCESS;
    6565}

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

    r77325 r77481  
    961961        PVMCPU pVCpu = &pVM->aCpus[i];
    962962
    963         PVMCSCACHE pCache = &pVCpu->hm.s.vmx.VMCSCache;
    964         strcpy((char *)pCache->aMagic, "VMCSCACHE Magic");
    965         pCache->uMagic = UINT64_C(0xdeadbeefdeadbeef);
     963        PVMXVMCSBATCHCACHE pVmcsCache = &pVCpu->hm.s.vmx.VmcsBatchCache;
     964        strcpy((char *)pVmcsCache->aMagic, "VMCSCACHE Magic");
     965        pVmcsCache->uMagic = UINT64_C(0xdeadbeefdeadbeef);
    966966    }
    967967#endif
    … …  
    19771977
    19781978#ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1979         memset(pVCpu->hm.s.vmx.VMCSCache.aMagic, 0, sizeof(pVCpu->hm.s.vmx.VMCSCache.aMagic));
    1980         pVCpu->hm.s.vmx.VMCSCache.uMagic = 0;
    1981         pVCpu->hm.s.vmx.VMCSCache.uPos = 0xffffffff;
     1979        memset(pVCpu->hm.s.vmx.VmcsBatchCache.aMagic, 0, sizeof(pVCpu->hm.s.vmx.VmcsBatchCache.aMagic));
     1980        pVCpu->hm.s.vmx.VmcsBatchCache.uMagic = 0;
     1981        pVCpu->hm.s.vmx.VmcsBatchCache.uPos = 0xffffffff;
    19821982#endif
    19831983    }
    … …  
    20062006
    20072007    /* Reset the contents of the read cache. */
    2008     PVMCSCACHE pCache = &pVCpu->hm.s.vmx.VMCSCache;
    2009     for (unsigned j = 0; j < pCache->Read.cValidEntries; j++)
    2010         pCache->Read.aFieldVal[j] = 0;
     2008    PVMXVMCSBATCHCACHE pVmcsCache = &pVCpu->hm.s.vmx.VmcsBatchCache;
     2009    for (unsigned j = 0; j < pVmcsCache->Read.cValidEntries; j++)
     2010        pVmcsCache->Read.aFieldVal[j] = 0;
    20112011
    20122012#ifdef VBOX_WITH_CRASHDUMP_MAGIC
    20132013    /* Magic marker for searching in crash dumps. */
    2014     strcpy((char *)pCache->aMagic, "VMCSCACHE Magic");
    2015     pCache->uMagic = UINT64_C(0xdeadbeefdeadbeef);
     2014    strcpy((char *)pVmcsCache->aMagic, "VMCSCACHE Magic");
     2015    pVmcsCache->uMagic = UINT64_C(0xdeadbeefdeadbeef);
    20162016#endif
    20172017}

  • trunk/src/VBox/VMM/VMMSwitcher/LegacyandAMD64.mac

    r76553 r77481  
    863863
    864864 %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    865     mov     qword [rbx + VMCSCACHE.uPos], 2
     865    mov     qword [rbx + VMXVMCSBATCHCACHE.uPos], 2
    866866 %endif
    867867
    868868 %ifdef DEBUG
    869869    mov     rax, [rbp + 8 + 8]                              ; HCPhysCpuPage
    870     mov     [rbx + VMCSCACHE.TestIn.HCPhysCpuPage], rax
     870    mov     [rbx + VMXVMCSBATCHCACHE.TestIn.HCPhysCpuPage], rax
    871871    mov     rax, [rbp + 16 + 8]                             ; HCPhysVmcs
    872     mov     [rbx + VMCSCACHE.TestIn.HCPhysVmcs], rax
    873     mov     [rbx + VMCSCACHE.TestIn.pCache], rbx
    874     mov     [rbx + VMCSCACHE.TestIn.pCtx], rsi
     872    mov     [rbx + VMXVMCSBATCHCACHE.TestIn.HCPhysVmcs], rax
     873    mov     [rbx + VMXVMCSBATCHCACHE.TestIn.pCache], rbx
     874    mov     [rbx + VMXVMCSBATCHCACHE.TestIn.pCtx], rsi
    875875 %endif
    876876
    877     mov     ecx, [rbx + VMCSCACHE.Write.cValidEntries]
     877    mov     ecx, [rbx + VMXVMCSBATCHCACHE.Write.cValidEntries]
    878878    cmp     ecx, 0
    879879    je      .no_cached_writes
    … …  
    884884ALIGN(16)
    885885.cached_write:
    886     mov     eax, [rbx + VMCSCACHE.Write.aField + rcx*4]
    887     vmwrite rax, qword [rbx + VMCSCACHE.Write.aFieldVal + rcx*8]
     886    mov     eax, [rbx + VMXVMCSBATCHCACHE.Write.aField + rcx*4]
     887    vmwrite rax, qword [rbx + VMXVMCSBATCHCACHE.Write.aFieldVal + rcx*8]
    888888    inc     rcx
    889889    cmp     rcx, rdx
    890890    jl     .cached_write
    891891
    892     mov     dword [rbx + VMCSCACHE.Write.cValidEntries], 0
     892    mov     dword [rbx + VMXVMCSBATCHCACHE.Write.cValidEntries], 0
    893893.no_cached_writes:
    894894
    895895 %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    896     mov     qword [rbx + VMCSCACHE.uPos], 3
     896    mov     qword [rbx + VMXVMCSBATCHCACHE.uPos], 3
    897897 %endif
    898898    ; Save the pCache pointer.
    … …  
    946946
    947947%ifdef VBOX_WITH_CRASHDUMP_MAGIC
    948     mov     qword [rbx + VMCSCACHE.uPos], 4
     948    mov     qword [rbx + VMXVMCSBATCHCACHE.uPos], 4
    949949%endif
    950950
    … …  
    969969
    970970%ifdef VBOX_WITH_CRASHDUMP_MAGIC
    971     mov     qword [rbx + VMCSCACHE.uPos], 5
     971    mov     qword [rbx + VMXVMCSBATCHCACHE.uPos], 5
    972972%endif
    973973
    … …  
    10841084
    10851085 %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1086     mov     dword [rdi + VMCSCACHE.uPos], 7
     1086    mov     dword [rdi + VMXVMCSBATCHCACHE.uPos], 7
    10871087 %endif
    10881088 %ifdef DEBUG
    1089     mov     [rdi + VMCSCACHE.TestOut.pCache], rdi
    1090     mov     [rdi + VMCSCACHE.TestOut.pCtx], rsi
     1089    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.pCache], rdi
     1090    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.pCtx], rsi
    10911091    mov     rax, cr8
    1092     mov     [rdi + VMCSCACHE.TestOut.cr8], rax
     1092    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.cr8], rax
    10931093 %endif
    10941094
    1095     mov     ecx, [rdi + VMCSCACHE.Read.cValidEntries]
     1095    mov     ecx, [rdi + VMXVMCSBATCHCACHE.Read.cValidEntries]
    10961096    cmp     ecx, 0  ; Can't happen
    10971097    je      .no_cached_reads
    … …  
    11011101.cached_read:
    11021102    dec     rcx
    1103     mov     eax, [rdi + VMCSCACHE.Read.aField + rcx*4]
    1104     vmread  qword [rdi + VMCSCACHE.Read.aFieldVal + rcx*8], rax
     1103    mov     eax, [rdi + VMXVMCSBATCHCACHE.Read.aField + rcx*4]
     1104    vmread  qword [rdi + VMXVMCSBATCHCACHE.Read.aFieldVal + rcx*8], rax
    11051105    cmp     rcx, 0
    11061106    jnz     .cached_read
    11071107.no_cached_reads:
    11081108 %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1109     mov     dword [rdi + VMCSCACHE.uPos], 8
     1109    mov     dword [rdi + VMXVMCSBATCHCACHE.uPos], 8
    11101110 %endif
    11111111%endif
    … …  
    11171117
    11181118%ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1119     mov     dword [rdi + VMCSCACHE.uPos], 9
     1119    mov     dword [rdi + VMXVMCSBATCHCACHE.uPos], 9
    11201120%endif
    11211121.vmstart64_end:
    … …  
    11241124 %ifdef DEBUG
    11251125    mov     rdx, [rsp]                             ; HCPhysVmcs
    1126     mov     [rdi + VMCSCACHE.TestOut.HCPhysVmcs], rdx
     1126    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.HCPhysVmcs], rdx
    11271127 %endif
    11281128%endif
    … …  
    11431143    pushf
    11441144    pop     rdx
    1145     mov     [rdi + VMCSCACHE.TestOut.eflags], rdx
     1145    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.eflags], rdx
    11461146  %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1147     mov     dword [rdi + VMCSCACHE.uPos], 12
     1147    mov     dword [rdi + VMXVMCSBATCHCACHE.uPos], 12
    11481148  %endif
    11491149.skip_flags_save:
    … …  
    11691169    pop     rdi         ; pCache
    11701170 %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1171     mov     dword [rdi + VMCSCACHE.uPos], 10
     1171    mov     dword [rdi + VMXVMCSBATCHCACHE.uPos], 10
    11721172 %endif
    11731173
    11741174 %ifdef DEBUG
    1175     mov     [rdi + VMCSCACHE.TestOut.pCache], rdi
    1176     mov     [rdi + VMCSCACHE.TestOut.pCtx], rsi
     1175    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.pCache], rdi
     1176    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.pCtx], rsi
    11771177 %endif
    11781178%endif
    … …  
    12011201
    12021202 %ifdef DEBUG
    1203     mov     [rdi + VMCSCACHE.TestOut.pCache], rdi
    1204     mov     [rdi + VMCSCACHE.TestOut.pCtx], rsi
     1203    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.pCache], rdi
     1204    mov     [rdi + VMXVMCSBATCHCACHE.TestOut.pCtx], rsi
    12051205 %endif
    12061206 %ifdef VBOX_WITH_CRASHDUMP_MAGIC
    1207     mov     dword [rdi + VMCSCACHE.uPos], 11
     1207    mov     dword [rdi + VMXVMCSBATCHCACHE.uPos], 11
    12081208 %endif
    12091209%endif

  • trunk/src/VBox/VMM/include/HMInternal.h

    r77325 r77481  
    600600
    601601/* Maximum number of cached entries. */
    602 #define VMCSCACHE_MAX_ENTRY                             128
     602#define VMX_VMCS_BATCH_CACHE_MAX_ENTRY              128
    603603
    604604/**
    605  * Structure for storing read and write VMCS actions.
    606  */
    607 typedef struct VMCSCACHE
     605 * Cache of a VMCS for batch reads or writes.
     606 */
     607typedef struct VMXVMCSBATCHCACHE
    608608{
    609609#ifdef VBOX_WITH_CRASHDUMP_MAGIC
    … …  
    625625        uint32_t    cValidEntries;
    626626        uint32_t    uAlignment;
    627         uint32_t    aField[VMCSCACHE_MAX_ENTRY];
    628         uint64_t    aFieldVal[VMCSCACHE_MAX_ENTRY];
     627        uint32_t    aField[VMX_VMCS_BATCH_CACHE_MAX_ENTRY];
     628        uint64_t    aFieldVal[VMX_VMCS_BATCH_CACHE_MAX_ENTRY];
    629629    } Write;
    630630    struct
    … …  
    632632        uint32_t    cValidEntries;
    633633        uint32_t    uAlignment;
    634         uint32_t    aField[VMCSCACHE_MAX_ENTRY];
    635         uint64_t    aFieldVal[VMCSCACHE_MAX_ENTRY];
     634        uint32_t    aField[VMX_VMCS_BATCH_CACHE_MAX_ENTRY];
     635        uint64_t    aFieldVal[VMX_VMCS_BATCH_CACHE_MAX_ENTRY];
    636636    } Read;
    637637#ifdef VBOX_STRICT
    … …  
    659659    } ScratchPad;
    660660#endif
    661 } VMCSCACHE;
    662 /** Pointer to VMCSCACHE. */
    663 typedef VMCSCACHE *PVMCSCACHE;
    664 AssertCompileSizeAlignment(VMCSCACHE, 8);
     661} VMXVMCSBATCHCACHE;
     662/** Pointer to VMXVMCSBATCHCACHE. */
     663typedef VMXVMCSBATCHCACHE *PVMXVMCSBATCHCACHE;
     664AssertCompileSizeAlignment(VMXVMCSBATCHCACHE, 8);
    665665
    666666/**
    … …  
    670670 * @param   fResume     Whether to use VMRESUME (true) or VMLAUNCH (false).
    671671 * @param   pCtx        The CPU register context.
    672  * @param   pCache      The VMCS cache.
     672 * @param   pVmcsCache  The VMCS batch cache.
    673673 * @param   pVM         Pointer to the cross context VM structure.
    674674 * @param   pVCpu       Pointer to the cross context per-CPU structure.
    675675 */
    676 typedef DECLCALLBACK(int) FNHMVMXSTARTVM(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu);
     676typedef DECLCALLBACK(int) FNHMVMXSTARTVM(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pVmcsCache, PVM pVM, PVMCPU pVCpu);
    677677/** Pointer to a VMX StartVM function. */
    678678typedef R0PTRTYPE(FNHMVMXSTARTVM *) PFNHMVMXSTARTVM;
    … …  
    835835            uint64_t                    u64TscOffset;
    836836
    837             /** VMCS cache. */
    838             VMCSCACHE                   VMCSCache;
     837            /** VMCS cache for batched vmread/vmwrites. */
     838            VMXVMCSBATCHCACHE           VmcsBatchCache;
    839839
    840840            /** Real-mode emulation state. */
    … …  
    11101110
    11111111# ifdef VBOX_WITH_KERNEL_USING_XMM
    1112 DECLASM(int) hmR0VMXStartVMWrapXMM(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu,
     1112DECLASM(int) hmR0VMXStartVMWrapXMM(RTHCUINT fResume, PCPUMCTX pCtx, PVMXVMCSBATCHCACHE pVmcsCache, PVM pVM, PVMCPU pVCpu,
    11131113                                   PFNHMVMXSTARTVM pfnStartVM);
    11141114DECLASM(int) hmR0SVMRunWrapXMM(RTHCPHYS pVmcbHostPhys, RTHCPHYS pVmcbPhys, PCPUMCTX pCtx, PVM pVM, PVMCPU pVCpu,

  • trunk/src/VBox/VMM/include/HMInternal.mac

    r76553 r77481  
    2121
    2222;Maximum number of cached entries.
    23 %define VMCSCACHE_MAX_ENTRY                             128
     23%define VMX_VMCS_BATCH_CACHE_MAX_ENTRY                             128
    2424
    2525; Structure for storing read and write VMCS actions.
    26 struc VMCSCACHE
     26struc VMXVMCSBATCHCACHE
    2727%ifdef VBOX_WITH_CRASHDUMP_MAGIC
    2828    .aMagic                   resb    16
    … …  
    3939    .Write.cValidEntries      resd    1
    4040    .Write.uAlignment         resd    1
    41     .Write.aField             resd    VMCSCACHE_MAX_ENTRY
    42     .Write.aFieldVal          resq    VMCSCACHE_MAX_ENTRY
     41    .Write.aField             resd    VMX_VMCS_BATCH_CACHE_MAX_ENTRY
     42    .Write.aFieldVal          resq    VMX_VMCS_BATCH_CACHE_MAX_ENTRY
    4343    .Read.cValidEntries       resd    1
    4444    .Read.uAlignment          resd    1
    45     .Read.aField              resd    VMCSCACHE_MAX_ENTRY
    46     .Read.aFieldVal           resq    VMCSCACHE_MAX_ENTRY
     45    .Read.aField              resd    VMX_VMCS_BATCH_CACHE_MAX_ENTRY
     46    .Read.aFieldVal           resq    VMX_VMCS_BATCH_CACHE_MAX_ENTRY
    4747%ifdef VBOX_STRICT
    4848    .TestIn.HCPhysCpuPage     resq    1
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