VirtualBox

Changeset 45620 in vbox for trunk/src/VBox/VMM/VMMR3


Ignore:
Timestamp:
Apr 18, 2013 8:07:14 PM (12 years ago)
Author:
vboxsync
Message:

CSAM,PATM: Don't bother initializing anything if HMIsEnabled(). Also, don't allow the components to be enabled.

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

Legend:

Unmodified
Added
Removed

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

    r45485 r45620  
    2727#include <VBox/vmm/pgm.h>
    2828#include <VBox/vmm/iom.h>
    29 #include <VBox/sup.h>
    3029#include <VBox/vmm/mm.h>
    3130#include <VBox/vmm/em.h>
     31#include <VBox/vmm/hm.h>
    3232#ifdef VBOX_WITH_REM
    3333# include <VBox/vmm/rem.h>
    … …  
    4444#include <VBox/vmm/vm.h>
    4545#include <VBox/vmm/uvm.h>
     46
    4647#include <VBox/dbg.h>
     48#include <VBox/sup.h>
    4749#include <VBox/err.h>
    4850#include <VBox/log.h>
     51
     52#include <VBox/dis.h>
     53#include <VBox/disopcode.h>
    4954#include <iprt/assert.h>
    5055#include <iprt/string.h>
    51 #include <VBox/dis.h>
    52 #include <VBox/disopcode.h>
    5356#include "internal/pgm.h"
    5457
    … …  
    6972static DECLCALLBACK(int) csamr3Save(PVM pVM, PSSMHANDLE pSSM);
    7073static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
     74static DECLCALLBACK(int) csamR3LoadDummy(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    7175static DECLCALLBACK(int) CSAMCodePageWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
    7276static DECLCALLBACK(int) CSAMCodePageInvalidate(PVM pVM, RTGCPTR GCPtr);
    … …  
    222226    int rc;
    223227
     228    /*
     229     * We only need a saved state dummy loader if HM is enabled.
     230     */
     231    if (HMIsEnabled(pVM))
     232    {
     233        pVM->fCSAMEnabled = false;
     234        return SSMR3RegisterInternal(pVM, "CSAM", 0, CSAM_SSM_VERSION, 0,
     235                                     NULL, NULL, NULL,
     236                                     NULL, NULL, NULL,
     237                                     NULL, csamR3LoadDummy, NULL);
     238    }
     239
     240    /*
     241     * Raw-mode.
     242     */
    224243    LogFlow(("CSAMR3Init\n"));
    225244
    … …  
    329348    AssertRelease(!(RT_OFFSETOF(VM, csam.s) & 31));
    330349    AssertRelease(sizeof(pVM->csam.s) <= sizeof(pVM->csam.padding));
     350    AssertRelease(!HMIsEnabled(pVM));
    331351
    332352    /*
    … …  
    368388VMMR3_INT_DECL(void) CSAMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
    369389{
    370     if (offDelta)
     390    if (offDelta && !HMIsEnabled(pVM))
    371391    {
    372392        /* Adjust pgdir and page bitmap pointers. */
    … …  
    396416VMMR3_INT_DECL(int) CSAMR3Term(PVM pVM)
    397417{
     418    if (HMIsEnabled(pVM))
     419        return VINF_SUCCESS;
     420
    398421    int rc;
    399422
    … …  
    421444VMMR3_INT_DECL(int) CSAMR3Reset(PVM pVM)
    422445{
     446    if (HMIsEnabled(pVM))
     447        return VINF_SUCCESS;
     448
    423449    /* Clear page bitmaps. */
    424     for(int i=0;i<CSAM_PGDIRBMP_CHUNKS;i++)
     450    for (int i = 0; i < CSAM_PGDIRBMP_CHUNKS; i++)
    425451    {
    426452        if (pVM->csam.s.pPDBitmapHC[i])
    … …  
    432458
    433459    /* Remove all CSAM page records. */
    434     while(true)
     460    for (;;)
    435461    {
    436462        PCSAMPAGEREC pPageRec = (PCSAMPAGEREC)RTAvlPVGetBestFit(&pVM->csam.s.pPageTree, 0, true);
    437         if (pPageRec)
    438         {
    439             csamRemovePageRecord(pVM, pPageRec->page.pPageGC);
    440         }
    441         else
     463        if (!pPageRec)
    442464            break;
     465        csamRemovePageRecord(pVM, pPageRec->page.pPageGC);
    443466    }
    444467    Assert(!pVM->csam.s.pPageTree);
    … …  
    544567    return VINF_SUCCESS;
    545568}
     569
     570
     571/**
     572 * @callback_method_impl{FNSSMINTLOADEXEC, Dummy load function for HM mode.}
     573 */
     574DECLCALLBACK(int) csamR3LoadDummy(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     575{
     576    return SSMR3SkipToEndOfUnit(pSSM);
     577}
     578
    546579
    547580/**
    … …  
    16211654    if (!CSAMIsEnabled(pVM))
    16221655        return VINF_SUCCESS;
     1656    Assert(!HMIsEnabled(pVM));
    16231657
    16241658    PVMCPU pVCpu = VMMGetCpu0(pVM);
    … …  
    17371771    PCSAMPAGEREC pPageRec;
    17381772    int          rc;
     1773
     1774    AssertReturn(!HMIsEnabled(pVM), VERR_CSAM_HM_IPE);
    17391775
    17401776    addr = addr & PAGE_BASE_GC_MASK;
    … …  
    19141950    bool         fMonitorInvalidation;
    19151951    Assert(pVM->cCpus == 1);
    1916     PVMCPU pVCpu = VMMGetCpu0(pVM);
     1952    PVMCPU       pVCpu = VMMGetCpu0(pVM);
     1953    Assert(!HMIsEnabled(pVM));
    19171954
    19181955    /* Dirty pages must be handled before calling this function!. */
    … …  
    20342071VMMR3DECL(int) CSAMR3UnmonitorPage(PVM pVM, RTRCPTR pPageAddrGC, CSAMTAG enmTag)
    20352072{
     2073    Assert(!HMIsEnabled(pVM));
     2074
    20362075    pPageAddrGC &= PAGE_BASE_GC_MASK;
    20372076
    … …  
    22952334    Assert(!fScanned);   /* other case not implemented. */
    22962335    Assert(!PATMIsPatchGCAddr(pVM, pInstr));
     2336    Assert(!HMIsEnabled(pVM));
    22972337
    22982338    if (csamIsCodeScanned(pVM, pInstr, &pPage) == false)
    … …  
    23182358VMMR3_INT_DECL(int) CSAMR3CheckCodeEx(PVM pVM, PCPUMCTXCORE pCtxCore, RTRCPTR pInstrGC)
    23192359{
     2360    Assert(!HMIsEnabled(pVM));
    23202361    if (EMIsRawRing0Enabled(pVM) == false || PATMIsPatchGCAddr(pVM, pInstrGC) == true)
    23212362    {
    … …  
    23462387    int rc;
    23472388    PCSAMPAGE pPage = NULL;
     2389    Assert(!HMIsEnabled(pVM));
    23482390
    23492391    if (    EMIsRawRing0Enabled(pVM) == false
    … …  
    24632505VMMR3_INT_DECL(int) CSAMR3DoPendingAction(PVM pVM, PVMCPU pVCpu)
    24642506{
     2507    AssertReturn(!HMIsEnabled(pVM), VERR_CSAM_HM_IPE);
     2508
    24652509    csamR3FlushDirtyPages(pVM);
    24662510    csamR3FlushCodePages(pVM);
    … …  
    24912535    int         rc;
    24922536
     2537    AssertReturn(!HMIsEnabled(pVM), VERR_CSAM_HM_IPE);
    24932538    if (EMIsRawRing0Enabled(pVM) == false)
    24942539    {
    … …  
    26982743VMMR3DECL(int) CSAMR3RecordCallAddress(PVM pVM, RTRCPTR GCPtrCall)
    26992744{
     2745    Assert(!HMIsEnabled(pVM));
    27002746    for (unsigned i=0;i<RT_ELEMENTS(pVM->csam.s.pvCallInstruction);i++)
    27012747    {
    … …  
    27412787    PVM pVM = pUVM->pVM;
    27422788    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
     2789
     2790    if (HMIsEnabled(pVM))
     2791    {
     2792        Assert(!pVM->fCSAMEnabled);
     2793        return VINF_SUCCESS;
     2794    }
    27432795
    27442796    int rc;
    … …  
    27612813    NOREF(cArgs); NOREF(paArgs);
    27622814
     2815    if (HMR3IsEnabled(pUVM))
     2816        return DBGCCmdHlpPrintf(pCmdHlp, "CSAM is permanently disabled by HM.\n");
     2817
    27632818    int rc = CSAMR3SetScanningEnabled(pUVM, false);
    27642819    if (RT_FAILURE(rc))
    … …  
    27752830    NOREF(cArgs); NOREF(paArgs);
    27762831
     2832    if (HMR3IsEnabled(pUVM))
     2833        return DBGCCmdHlpPrintf(pCmdHlp, "CSAM is permanently disabled by HM.\n");
     2834
    27772835    int rc = CSAMR3SetScanningEnabled(pUVM, true);
    27782836    if (RT_FAILURE(rc))

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

    r45533 r45620  
    164164        pVCpu->em.s.pCtx         = CPUMQueryGuestCtxPtr(pVCpu);
    165165#ifdef VBOX_WITH_RAW_MODE
    166         pVCpu->em.s.pPatmGCState = PATMR3QueryGCStateHC(pVM);
    167         AssertMsg(pVCpu->em.s.pPatmGCState, ("PATMR3QueryGCStateHC failed!\n"));
     166        if (!HMIsEnabled(pVM))
     167        {
     168            pVCpu->em.s.pPatmGCState = PATMR3QueryGCStateHC(pVM);
     169            AssertMsg(pVCpu->em.s.pPatmGCState, ("PATMR3QueryGCStateHC failed!\n"));
     170        }
    168171#endif
    169172

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

    r45485 r45620  
    3030#include <VBox/vmm/mm.h>
    3131#include <VBox/vmm/em.h>
     32#include <VBox/vmm/hm.h>
    3233#include <VBox/vmm/ssm.h>
    3334#include <VBox/vmm/trpm.h>
    … …  
    139140    int rc;
    140141
     142    /*
     143     * We only need a saved state dummy loader if HM is enabled.
     144     */
     145    if (HMIsEnabled(pVM))
     146    {
     147        pVM->fPATMEnabled = false;
     148        return SSMR3RegisterInternal(pVM, "PATM", 0, PATM_SSM_VERSION, 0,
     149                                     NULL, NULL, NULL,
     150                                     NULL, NULL, NULL,
     151                                     NULL, patmR3LoadDummy, NULL);
     152    }
     153
     154    /*
     155     * Raw-mode.
     156     */
    141157    Log(("PATMR3Init: Patch record size %d\n", sizeof(PATCHINFO)));
    142158
    … …  
    313329VMMR3_INT_DECL(int) PATMR3InitFinalize(PVM pVM)
    314330{
     331    if (HMIsEnabled(pVM))
     332        return VINF_SUCCESS;
     333
    315334    /* The GC state, stack and statistics must be read/write for the guest (supervisor only of course). */
    316335    int rc = PGMMapSetPage(pVM, pVM->patm.s.pGCStateGC, PAGE_SIZE, X86_PTE_P | X86_PTE_A | X86_PTE_D | X86_PTE_RW);
    … …  
    443462VMMR3_INT_DECL(void) PATMR3Relocate(PVM pVM)
    444463{
     464    if (HMIsEnabled(pVM))
     465        return;
     466
    445467    RTRCPTR     GCPtrNew = MMHyperR3ToRC(pVM, pVM->patm.s.pGCStateHC);
    446468    RTRCINTPTR  delta = GCPtrNew - pVM->patm.s.pGCStateGC;
    … …  
    498520VMMR3_INT_DECL(int) PATMR3Term(PVM pVM)
    499521{
     522    if (HMIsEnabled(pVM))
     523        return VINF_SUCCESS;
     524
    500525    /* Memory was all allocated from the two MM heaps and requires no freeing. */
    501     NOREF(pVM);
    502526    return VINF_SUCCESS;
    503527}
    … …  
    513537{
    514538    Log(("PATMR3Reset\n"));
     539    if (HMIsEnabled(pVM))
     540        return VINF_SUCCESS;
    515541
    516542    /* Free all patches. */
    517     while (true)
     543    for (;;)
    518544    {
    519545        PPATMPATCHREC pPatchRec = (PPATMPATCHREC)RTAvloU32RemoveBestFit(&pVM->patm.s.PatchLookupTreeHC->PatchTree, 0, true);
    … …  
    972998VMMR3_INT_DECL(void *) PATMR3QueryPatchMemHC(PVM pVM, uint32_t *pcb)
    973999{
     1000    AssertReturn(!HMIsEnabled(pVM), NULL);
    9741001    if (pcb)
    9751002        *pcb = pVM->patm.s.cbPatchMem;
    976 
    9771003    return pVM->patm.s.pPatchMemHC;
    9781004}
    … …  
    9881014VMMR3_INT_DECL(RTRCPTR) PATMR3QueryPatchMemGC(PVM pVM, uint32_t *pcb)
    9891015{
     1016    AssertReturn(!HMIsEnabled(pVM), NIL_RTRCPTR);
    9901017    if (pcb)
    9911018        *pcb = pVM->patm.s.cbPatchMem;
    992 
    9931019    return pVM->patm.s.pPatchMemGC;
    9941020}
    … …  
    10041030VMMR3_INT_DECL(PPATMGCSTATE) PATMR3QueryGCStateHC(PVM pVM)
    10051031{
     1032    AssertReturn(!HMIsEnabled(pVM), NULL);
    10061033    return pVM->patm.s.pGCStateHC;
    10071034}
    … …  
    10371064    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    10381065
    1039     pVM->fPATMEnabled = fAllowPatching;
     1066    if (!HMIsEnabled(pVM))
     1067        pVM->fPATMEnabled = fAllowPatching;
     1068    else
     1069        Assert(!pVM->fPATMEnabled);
    10401070    return VINF_SUCCESS;
    10411071}
    … …  
    10661096VMMR3_INT_DECL(void *) PATMR3GCPtrToHCPtr(PVM pVM, RTRCPTR pAddrGC)
    10671097{
     1098    AssertReturn(!HMIsEnabled(pVM), NULL);
    10681099    if (pVM->patm.s.pPatchMemGC <= pAddrGC && pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem > pAddrGC)
    10691100        return pVM->patm.s.pPatchMemHC + (pAddrGC - pVM->patm.s.pPatchMemGC);
    … …  
    11191150
    11201151
    1121 /* Calculates and fills in all branch targets
     1152/**
     1153 * Calculates and fills in all branch targets
    11221154 *
    11231155 * @returns VBox status code.
    … …  
    12151247}
    12161248
    1217 /* Add an illegal instruction record
     1249/**
     1250 * Add an illegal instruction record
    12181251 *
    12191252 * @param   pVM             Pointer to the VM.
    … …  
    12561289 * @param   fDirty          Dirty flag
    12571290 *
    1258  */
    1259  /** @note Be extremely careful with this function. Make absolutely sure the guest address is correct! (to avoid executing instructions twice!) */
     1291 * @note Be extremely careful with this function. Make absolutely sure the guest
     1292 *       address is correct! (to avoid executing instructions twice!)
     1293 */
    12601294void patmR3AddP2GLookupRecord(PVM pVM, PPATCHINFO pPatch, uint8_t *pPatchInstrHC, RTRCPTR pInstrGC, PATM_LOOKUP_TYPE enmType, bool fDirty)
    12611295{
    … …  
    21182152#ifdef LOG_ENABLED
    21192153
    2120 /* Add a disasm jump record (temporary for prevent duplicate analysis)
     2154/**
     2155 * Add a disasm jump record (temporary for prevent duplicate analysis)
    21212156 *
    21222157 * @param   pVM             Pointer to the VM.
    … …  
    23752410VMMR3_INT_DECL(int) PATMR3DetectConflict(PVM pVM, RTRCPTR pInstrGC, RTRCPTR pConflictGC)
    23762411{
     2412    AssertReturn(!HMIsEnabled(pVM), VERR_PATCH_NO_CONFLICT);
    23772413    PPATCHINFO pTargetPatch = patmFindActivePatchByEntrypoint(pVM, pConflictGC, true /* include patch hints */);
    23782414    if (pTargetPatch)
    2379     {
    23802415        return patmDisableUnusablePatch(pVM, pInstrGC, pConflictGC, pTargetPatch);
    2381     }
    23822416    return VERR_PATCH_NO_CONFLICT;
    23832417}
    … …  
    35313565    int         rc;
    35323566    RTRCPTR     pPatchTargetGC = 0;
     3567    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    35333568
    35343569    pBranchTarget = pCtx->edx;
    … …  
    40794114    PVMCPU pVCpu = VMMGetCpu0(pVM);
    40804115    LogFlow(("PATMR3InstallPatch: %08x (%#llx)\n", pInstrGC, flags));
     4116
     4117    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    40814118
    40824119    if (    !pVM
    … …  
    48494886
    48504887    Assert(VM_IS_EMT(pVM));
     4888    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    48514889
    48524890    /* Quick boundary check */
    … …  
    50135051 * @param   pVM         Pointer to the VM.
    50145052 * @param   addr        GC address of the page to flush
    5015  */
    5016 /** @note Currently only called by CSAMR3FlushPage; optimization to avoid having to double check if the physical address has changed
     5053 * @note    Currently only called by CSAMR3FlushPage; optimization to avoid
     5054 *          having to double check if the physical address has changed
    50175055 */
    50185056VMMR3_INT_DECL(int) PATMR3FlushPage(PVM pVM, RTRCPTR addr)
    50195057{
     5058    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
     5059
    50205060    addr &= PAGE_BASE_GC_MASK;
    50215061
    … …  
    50505090VMMR3_INT_DECL(bool) PATMR3HasBeenPatched(PVM pVM, RTRCPTR pInstrGC)
    50515091{
     5092    Assert(!HMIsEnabled(pVM));
    50525093    PPATMPATCHREC pPatchRec;
    50535094    pPatchRec = (PPATMPATCHREC)RTAvloU32Get(&pVM->patm.s.PatchLookupTreeHC->PatchTree, pInstrGC);
    … …  
    50735114
    50745115    /* Shortcut. */
    5075     if (   !PATMIsEnabled(pVM)
    5076         ||  pInstrGC < pVM->patm.s.pPatchedInstrGCLowest
    5077         ||  pInstrGC > pVM->patm.s.pPatchedInstrGCHighest)
    5078     {
     5116    if (!PATMIsEnabled(pVM))
    50795117        return VERR_PATCH_NOT_FOUND;
    5080     }
     5118    Assert(!HMIsEnabled(pVM));
     5119    if (   pInstrGC < pVM->patm.s.pPatchedInstrGCLowest
     5120        || pInstrGC > pVM->patm.s.pPatchedInstrGCHighest)
     5121        return VERR_PATCH_NOT_FOUND;
    50815122
    50825123    pPatchRec = (PPATMPATCHREC)RTAvloU32GetBestFit(&pVM->patm.s.PatchLookupTreeHC->PatchTree, pInstrGC, false);
    … …  
    51145155{
    51155156    /* Shortcut. */
    5116     if (  !PATMIsEnabled(pVM)
    5117         || GCPtrInstr < pVM->patm.s.pPatchedInstrGCLowest
     5157    if (!PATMIsEnabled(pVM))
     5158        return VERR_PATCH_NOT_FOUND;
     5159    Assert(!HMIsEnabled(pVM));
     5160    if (   GCPtrInstr < pVM->patm.s.pPatchedInstrGCLowest
    51185161        || GCPtrInstr > pVM->patm.s.pPatchedInstrGCHighest)
    51195162        return VERR_PATCH_NOT_FOUND;
    … …  
    51745217
    51755218    Log(("PATMR3DisablePatch: %RRv\n", pInstrGC));
     5219    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    51765220    pPatchRec = (PPATMPATCHREC)RTAvloU32Get(&pVM->patm.s.PatchLookupTreeHC->PatchTree, pInstrGC);
    51775221    if (pPatchRec)
    … …  
    54205464
    54215465    Log(("PATMR3EnablePatch %RRv\n", pInstrGC));
     5466    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    54225467    pPatchRec = (PPATMPATCHREC)RTAvloU32Get(&pVM->patm.s.PatchLookupTreeHC->PatchTree, pInstrGC);
    54235468    if (pPatchRec)
    … …  
    58635908    PPATCHINFO pPatch;
    58645909
     5910    Assert(!HMIsEnabled(pVM));
    58655911    if (PATMIsEnabled(pVM) == false)
    58665912        return false;
    … …  
    58925938    PPATMPATCHREC pPatchRec;
    58935939
     5940    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    58945941    pPatchRec = (PPATMPATCHREC)RTAvloU32Get(&pVM->patm.s.PatchLookupTreeHC->PatchTree, pInstrGC);
    58955942    if (pPatchRec)
    … …  
    59666013}
    59676014
    5968 /* Converts Guest code GC ptr to Patch code GC ptr (if found)
     6015/**
     6016 * Converts Guest code GC ptr to Patch code GC ptr (if found)
    59696017 *
    59706018 * @returns corresponding GC pointer in patch block
    … …  
    60356083
    60366084    Assert(PATMIsPatchGCAddr(pVM, pPatchGC));
     6085    Assert(!HMIsEnabled(pVM));
    60376086    pvPatchCoreOffset = RTAvloU32GetBestFit(&pVM->patm.s.PatchLookupTreeHC->PatchTreeByPatchAddr, pPatchGC - pVM->patm.s.pPatchMemGC, false);
    60386087    if (pvPatchCoreOffset == 0)
    … …  
    60976146{
    60986147    PPATMPATCHREC pPatchRec;
     6148
     6149    Assert(!HMIsEnabled(pVM));
    60996150
    61006151    /* Find the patch record. */
    … …  
    63526403    PVMCPU           pVCpu = VMMGetCpu0(pVM);
    63536404
     6405    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    63546406    Assert(pVM->cCpus == 1);
    63556407
    … …  
    66366688VMMR3_INT_DECL(int) PATMR3HandleMonitoredPage(PVM pVM)
    66376689{
     6690    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
     6691
    66386692    RTRCPTR addr = pVM->patm.s.pvFaultMonitor;
    6639 
    66406693    addr &= PAGE_BASE_GC_MASK;
    66416694
    … …  
    68086861    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    68096862
     6863    if (HMIsEnabled(pVM))
     6864        return DBGCCmdHlpPrintf(pCmdHlp, "PATM is permanently disabled by HM.\n");
     6865
    68106866    RTAvloU32DoWithAll(&pVM->patm.s.PatchLookupTreeHC->PatchTree, true, DisableAllPatches, pVM);
    68116867    PATMR3AllowPatching(pVM->pUVM, false);
    … …  
    68336889    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    68346890
     6891    if (HMIsEnabled(pVM))
     6892        return DBGCCmdHlpPrintf(pCmdHlp, "PATM is permanently disabled by HM.\n");
     6893
    68356894    PATMR3AllowPatching(pVM->pUVM, true);
    68366895    RTAvloU32DoWithAll(&pVM->patm.s.PatchLookupTreeHC->PatchTree, true, EnableAllPatches, pVM);

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

    r45276 r45620  
    693693}
    694694
     695
     696/**
     697 * @callback_method_impl{FNSSMINTLOADEXEC, Dummy load function for HM mode.}
     698 */
     699DECLCALLBACK(int) patmR3LoadDummy(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     700{
     701    return SSMR3SkipToEndOfUnit(pSSM);
     702}
     703
     704
    695705/**
    696706 * Execute state load operation.
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