VirtualBox

Changeset 13067 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Oct 8, 2008 10:11:24 AM (16 years ago)
Author:
vboxsync
Message:

#1865: More PGM changes.

Location:
trunk/src/VBox/VMM/VMMAll
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r13060 r13067  
    337337#undef PGM_SHW_NAME
    338338
    339 #endif
    340 
     339#endif /* !IN_GC */
     340
     341
     342#ifndef IN_RING3
    341343/**
    342344 * #PF Handler.
    … …  
    352354    LogFlow(("PGMTrap0eHandler: uErr=%RGu pvFault=%VGv eip=%VGv\n", uErr, pvFault, pRegFrame->rip));
    353355    STAM_PROFILE_START(&pVM->pgm.s.StatGCTrap0e, a);
    354     STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = NULL; } );
     356    STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = NULL; } );
    355357
    356358
    … …  
    401403    if (rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
    402404        rc = VINF_SUCCESS;
    403     STAM_STATS({ if (!pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution))
    404                     pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eMisc; });
    405     STAM_PROFILE_STOP_EX(&pVM->pgm.s.StatGCTrap0e, pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution), a);
     405    STAM_STATS({ if (!pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
     406                    pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eMisc; });
     407    STAM_PROFILE_STOP_EX(&pVM->pgm.s.StatGCTrap0e, pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
    406408    return rc;
    407409}
     410#endif /* !IN_RING3 */
     411
    408412
    409413/**
    … …  
    446450            break;
    447451        if ((uintptr_t)GCPtr - (uintptr_t)pMapping->GCPtr < pMapping->cb)
    448         {
    449             STAM_COUNTER_INC(&pVM->pgm.s.StatGCSyncPTConflict);
    450452            return pMapping;
    451         }
    452453        pMapping = pMapping->CTX_SUFF(pNext);
    453454    }
    … …  
    646647#endif
    647648
    648     STAM_PROFILE_START(&CTXMID(pVM->pgm.s.Stat,InvalidatePage), a);
     649    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
    649650    rc = PGM_BTH_PFN(InvalidatePage, pVM)(pVM, GCPtrPage);
    650     STAM_PROFILE_STOP(&CTXMID(pVM->pgm.s.Stat,InvalidatePage), a);
     651    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
    651652
    652653#ifndef IN_RING0
    … …  
    15411542     * Let the 'Bth' function do the work and we'll just keep track of the flags.
    15421543     */
    1543     STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncCR3), a);
     1544    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    15441545    int rc = PGM_BTH_PFN(SyncCR3, pVM)(pVM, cr0, cr3, cr4, fGlobal);
    1545     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncCR3), a);
     1546    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    15461547    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || VBOX_FAILURE(rc), ("rc=%VRc\n", rc));
    15471548    if (rc == VINF_SUCCESS)
    … …  
    19721973VMMDECL(unsigned) PGMAssertCR3(PVM pVM, uint64_t cr3, uint64_t cr4)
    19731974{
    1974     STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncCR3), a);
     1975    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    19751976    unsigned cErrors = PGM_BTH_PFN(AssertCR3, pVM)(pVM, cr3, cr4, 0, ~(RTGCUINTPTR)0);
    1976     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncCR3), a);
     1977    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    19771978    return cErrors;
    19781979    return 0;

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

    r13063 r13067  
    6767#endif
    6868
     69
     70#ifndef IN_RING3
    6971/**
    7072 * #PF Handler for raw-mode guest execution.
    … …  
    7880PGM_BTH_DECL(int, Trap0eHandler)(PVM pVM, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
    7981{
    80 #if   (PGM_GST_TYPE == PGM_TYPE_32BIT || PGM_GST_TYPE == PGM_TYPE_REAL || PGM_GST_TYPE == PGM_TYPE_PROT || PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64) \
     82# if  (PGM_GST_TYPE == PGM_TYPE_32BIT || PGM_GST_TYPE == PGM_TYPE_REAL || PGM_GST_TYPE == PGM_TYPE_PROT || PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64) \
    8183    && PGM_SHW_TYPE != PGM_TYPE_NESTED    \
    8284    && (PGM_SHW_TYPE != PGM_TYPE_EPT || PGM_GST_TYPE == PGM_TYPE_PROT)
    8385
    84 # if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE != PGM_TYPE_PAE
     86#  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE != PGM_TYPE_PAE
    8587    /*
    8688     * Hide the instruction fetch trap indicator for now.
    … …  
    9294        TRPMSetErrorCode(pVM, uErr);
    9395    }
    94 # endif
     96#  endif
    9597
    9698    /*
    … …  
    98100     */
    99101    int       rc;
    100 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    101 #  if PGM_GST_TYPE == PGM_TYPE_32BIT
     102#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     103#   if PGM_GST_TYPE == PGM_TYPE_32BIT
    102104    const unsigned  iPDSrc = (RTGCUINTPTR)pvFault >> GST_PD_SHIFT;
    103105    PGSTPD          pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
    104106
    105 #  elif PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
    106 
    107 #   if PGM_GST_TYPE == PGM_TYPE_PAE
     107#   elif PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     108
     109#    if PGM_GST_TYPE == PGM_TYPE_PAE
    108110    unsigned        iPDSrc;
    109111    PGSTPD          pPDSrc = pgmGstGetPaePDPtr(&pVM->pgm.s, (RTGCUINTPTR)pvFault, &iPDSrc);
    110112
    111 #   elif PGM_GST_TYPE == PGM_TYPE_AMD64
     113#    elif PGM_GST_TYPE == PGM_TYPE_AMD64
    112114    unsigned     iPDSrc;
    113115    PX86PML4E    pPml4eSrc;
    … …  
    117119    pPDSrc = pgmGstGetLongModePDPtr(&pVM->pgm.s, pvFault, &pPml4eSrc, &PdpeSrc, &iPDSrc);
    118120    Assert(pPml4eSrc);
    119 #   endif
     121#    endif
    120122    /* Quick check for a valid guest trap. */
    121123    if (!pPDSrc)
    122124    {
    123 #   if PGM_GST_TYPE == PGM_TYPE_AMD64 && GC_ARCH_BITS == 64
     125#    if PGM_GST_TYPE == PGM_TYPE_AMD64 && GC_ARCH_BITS == 64
    124126        LogFlow(("Trap0eHandler: guest PML4 %d not present CR3=%VGp\n", (int)(((RTGCUINTPTR)pvFault >> X86_PML4_SHIFT) & X86_PML4_MASK), CPUMGetGuestCR3(pVM) & X86_CR3_PAGE_MASK));
    125 #   else
     127#    else
    126128        LogFlow(("Trap0eHandler: guest iPDSrc=%u not present CR3=%VGp\n", iPDSrc, CPUMGetGuestCR3(pVM) & X86_CR3_PAGE_MASK));
    127 #   endif
    128         STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eGuestTrap; });
     129#    endif
     130        STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eGuestTrap; });
    129131        TRPMSetErrorCode(pVM, uErr);
    130132        return VINF_EM_RAW_GUEST_TRAP;
    131133    }
    132 #  endif
    133 # else
     134#   endif
     135#  else
    134136    PGSTPD          pPDSrc = NULL;
    135137    const unsigned  iPDSrc = 0;
    136 # endif
    137 
    138 # if PGM_SHW_TYPE == PGM_TYPE_32BIT
     138#  endif
     139
     140#  if PGM_SHW_TYPE == PGM_TYPE_32BIT
    139141    const unsigned  iPDDst = (RTGCUINTPTR)pvFault >> SHW_PD_SHIFT;
    140142    PX86PD          pPDDst = pVM->pgm.s.CTXMID(p,32BitPD);
    141 # elif PGM_SHW_TYPE == PGM_TYPE_PAE
     143#  elif PGM_SHW_TYPE == PGM_TYPE_PAE
    142144    const unsigned  iPDDst = (RTGCUINTPTR)pvFault >> SHW_PD_SHIFT;
    143145    PX86PDPAE       pPDDst = pVM->pgm.s.CTXMID(ap,PaePDs)[0];       /* We treat this as a PD with 2048 entries, so no need to and with SHW_PD_MASK to get iPDDst */
    144146
    145 #  if PGM_GST_TYPE == PGM_TYPE_PAE
     147#   if PGM_GST_TYPE == PGM_TYPE_PAE
    146148    /* Did we mark the PDPT as not present in SyncCR3? */
    147149    unsigned iPdpte = ((RTGCUINTPTR)pvFault >> SHW_PDPT_SHIFT) & SHW_PDPT_MASK;
    … …  
    149151        pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPdpte].n.u1Present = 1;
    150152
    151 #  endif
    152 
    153 # elif PGM_SHW_TYPE == PGM_TYPE_AMD64
     153#   endif
     154
     155#  elif PGM_SHW_TYPE == PGM_TYPE_AMD64
    154156    const unsigned  iPDDst = (((RTGCUINTPTR)pvFault >> SHW_PD_SHIFT) & SHW_PD_MASK);
    155157    PX86PDPAE       pPDDst;
    156 #  if PGM_GST_TYPE == PGM_TYPE_PROT
     158#   if PGM_GST_TYPE == PGM_TYPE_PROT
    157159    /* AMD-V nested paging */
    158160    X86PML4E     Pml4eSrc;
    … …  
    163165    Pml4eSrc.u = X86_PML4E_P | X86_PML4E_RW | X86_PML4E_US | X86_PML4E_A;
    164166    PdpeSrc.u  = X86_PDPE_P | X86_PDPE_RW | X86_PDPE_US | X86_PDPE_A;
    165 #  endif
     167#   endif
    166168
    167169    rc = PGMShwSyncLongModePDPtr(pVM, (RTGCUINTPTR)pvFault, pPml4eSrc, &PdpeSrc, &pPDDst);
    … …  
    172174    }
    173175    Assert(pPDDst);
    174 # elif PGM_SHW_TYPE == PGM_TYPE_EPT
     176#  elif PGM_SHW_TYPE == PGM_TYPE_EPT
    175177    const unsigned  iPDDst = (((RTGCUINTPTR)pvFault >> SHW_PD_SHIFT) & SHW_PD_MASK);
    176178    PEPTPD          pPDDst;
    … …  
    179181    AssertReturn(rc == VINF_SUCCESS /* *must* test for VINF_SUCCESS!! */, rc);
    180182    Assert(pPDDst);
    181 # endif
    182 
    183 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     183#  endif
     184
     185#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    184186    /*
    185187     * If we successfully correct the write protection fault due to dirty bit
    … …  
    192194        ||  rc == VINF_EM_RAW_GUEST_TRAP)
    193195    {
    194         STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution)
     196        STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution)
    195197                     = rc == VINF_PGM_HANDLED_DIRTY_BIT_FAULT ? &pVM->pgm.s.StatTrap0eDirtyAndAccessedBits : &pVM->pgm.s.StatTrap0eGuestTrap; });
    196198        LogBird(("Trap0eHandler: returns %s\n", rc == VINF_PGM_HANDLED_DIRTY_BIT_FAULT ? "VINF_SUCCESS" : "VINF_EM_RAW_GUEST_TRAP"));
    … …  
    199201
    200202    STAM_COUNTER_INC(&pVM->pgm.s.StatGCTrap0ePD[iPDSrc]);
    201 # endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     203#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    202204
    203205    /*
    … …  
    212214     *
    213215     */
    214 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     216#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    215217    GSTPDE PdeSrc = pPDSrc->a[iPDSrc];
    216 # else
     218#  else
    217219    GSTPDE PdeSrc;
    218220    PdeSrc.au32[0]      = 0; /* faked so we don't have to #ifdef everything */
    … …  
    221223    PdeSrc.n.u1Accessed = 1;
    222224    PdeSrc.n.u1User     = 1;
    223 # endif
     225#  endif
    224226    if (    !(uErr & X86_TRAP_PF_P) /* not set means page not present instead of page protection violation */
    225227        &&  !pPDDst->a[iPDDst].n.u1Present
    … …  
    228230
    229231    {
    230         STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eSyncPT; });
     232        STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eSyncPT; });
    231233        STAM_PROFILE_START(&pVM->pgm.s.StatLazySyncPT, f);
    232234        LogFlow(("=>SyncPT %04x = %08x\n", iPDSrc, PdeSrc.au32[0]));
    … …  
    243245    }
    244246
    245 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     247#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    246248    /*
    247249     * Check if this address is within any of our mappings.
    … …  
    286288                    &&  uErr & X86_TRAP_PF_RW)
    287289                {
    288 #  ifdef IN_GC
     290#   ifdef IN_GC
    289291                    STAM_PROFILE_START(&pCur->Stat, h);
    290292                    rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->Core.Key);
    291293                    STAM_PROFILE_STOP(&pCur->Stat, h);
    292 #  else
     294#   else
    293295                    AssertFailed();
    294296                    rc = VINF_EM_RAW_EMULATE_INSTR; /* can't happen with VMX */
    295 #  endif
     297#   endif
    296298                    STAM_COUNTER_INC(&pVM->pgm.s.StatTrap0eMapHandler);
    297299                    STAM_PROFILE_STOP(&pVM->pgm.s.StatMapping, a);
    … …  
    311313        STAM_PROFILE_STOP(&pVM->pgm.s.StatMapping, a);
    312314    } /* pgmAreMappingsEnabled(&pVM->pgm.s) */
    313 # endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     315#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    314316
    315317    /*
    … …  
    325327        RTGCPHYS    GCPhys = NIL_RTGCPHYS;
    326328
    327 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    328 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
     329#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     330#   if PGM_GST_TYPE == PGM_TYPE_AMD64
    329331        bool fBigPagesSupported = true;
    330 #  else
     332#   else
    331333        bool fBigPagesSupported = !!(CPUMGetGuestCR4(pVM) & X86_CR4_PSE);
    332 #  endif
     334#   endif
    333335        if (    PdeSrc.b.u1Size
    334336            &&  fBigPagesSupported)
    … …  
    346348            }
    347349        }
    348 # else
     350#  else
    349351        /* No paging so the fault address is the physical address */
    350352        GCPhys = (RTGCPHYS)((RTGCUINTPTR)pvFault & ~PAGE_OFFSET_MASK);
    351 # endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     353#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    352354
    353355        /*
    … …  
    373375                        if (pCur)
    374376                        {
    375 # ifdef PGM_SYNC_N_PAGES
     377#  ifdef PGM_SYNC_N_PAGES
    376378                            /*
    377379                             * If the region is write protected and we got a page not present fault, then sync
    … …  
    392394                                    STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersOutOfSync);
    393395                                    STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    394                                     STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncHndPhys; });
     396                                    STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncHndPhys; });
    395397                                    return rc;
    396398                                }
    397399                            }
    398 # endif
     400#  endif
    399401
    400402                            AssertMsg(   pCur->enmType != PGMPHYSHANDLERTYPE_PHYSICAL_WRITE
    … …  
    402404                                      ("Unexpected trap for physical handler: %08X (phys=%08x) HCPhys=%X uErr=%X, enum=%d\n", pvFault, GCPhys, pPage->HCPhys, uErr, pCur->enmType));
    403405
    404 #if defined(IN_GC) || defined(IN_RING0)
     406# if defined(IN_GC) || defined(IN_RING0)
    405407                            if (pCur->CTX_SUFF(pfnHandler))
    406408                            {
    … …  
    410412                            }
    411413                            else
    412 #endif
     414# endif
    413415                                rc = VINF_EM_RAW_EMULATE_INSTR;
    414416                            STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersPhysical);
    415417                            STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    416                             STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndPhys; });
     418                            STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndPhys; });
    417419                            return rc;
    418420                        }
    419421                    }
    420 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     422#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    421423                    else
    422424                    {
    423 # ifdef PGM_SYNC_N_PAGES
     425#  ifdef PGM_SYNC_N_PAGES
    424426                        /*
    425427                         * If the region is write protected and we got a page not present fault, then sync
    … …  
    438440                                STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersOutOfSync);
    439441                                STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    440                                 STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncHndVirt; });
     442                                STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncHndVirt; });
    441443                                return rc;
    442444                            }
    443445                        }
    444 # endif
     446#  endif
    445447                        /*
    446448                         * Ok, it's an virtual page access handler.
    … …  
    466468                                     ||  pCur->enmType != PGMVIRTHANDLERTYPE_WRITE ) )
    467469                            {
    468 #  ifdef IN_GC
     470#   ifdef IN_GC
    469471                                STAM_PROFILE_START(&pCur->Stat, h);
    470472                                rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->Core.Key);
    471473                                STAM_PROFILE_STOP(&pCur->Stat, h);
    472 #  else
     474#   else
    473475                                rc = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
    474 #  endif
     476#   endif
    475477                                STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersVirtual);
    476478                                STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    477                                 STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndVirt; });
     479                                STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndVirt; });
    478480                                return rc;
    479481                            }
    … …  
    493495                            {
    494496                                Assert((pCur->aPhysToVirt[iPage].Core.Key & X86_PTE_PAE_PG_MASK) == GCPhys);
    495 #  ifdef IN_GC
     497#   ifdef IN_GC
    496498                                RTGCUINTPTR off = (iPage << PAGE_SHIFT) + ((RTGCUINTPTR)pvFault & PAGE_OFFSET_MASK) - ((RTGCUINTPTR)pCur->Core.Key & PAGE_OFFSET_MASK);
    497499                                Assert(off < pCur->cb);
    … …  
    499501                                rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, off);
    500502                                STAM_PROFILE_STOP(&pCur->Stat, h);
    501 #  else
     503#   else
    502504                                rc = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
    503 #  endif
     505#   endif
    504506                                STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersVirtualByPhys);
    505507                                STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    506                                 STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndVirt; });
     508                                STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndVirt; });
    507509                                return rc;
    508510                            }
    509511                        }
    510512                    }
    511 # endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     513#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    512514
    513515                    /*
    … …  
    532534                            STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersOutOfSync);
    533535                            STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    534                             STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncHndPhys; });
     536                            STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncHndPhys; });
    535537                            return rc;
    536538                        }
    … …  
    546548                             PGM_PAGE_HAS_ANY_VIRTUAL_HANDLERS(pPage)  ? " virt" : ""));
    547549                    STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    548                     STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndUnhandled; });
     550                    STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndUnhandled; });
    549551                    return rc;
    550552                } /* if any kind of handler */
    551553
    552 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     554#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    553555                if (uErr & X86_TRAP_PF_P)
    554556                {
    … …  
    573575                                 ||  pCur->enmType != PGMVIRTHANDLERTYPE_WRITE ) )
    574576                        {
    575 #  ifdef IN_GC
     577#   ifdef IN_GC
    576578                            STAM_PROFILE_START(&pCur->Stat, h);
    577579                            rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->Core.Key);
    578580                            STAM_PROFILE_STOP(&pCur->Stat, h);
    579 #  else
     581#   else
    580582                            rc = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
    581 #  endif
     583#   endif
    582584                            STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersVirtualUnmarked);
    583585                            STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    584                             STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndVirt; });
     586                            STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eHndVirt; });
    585587                            return rc;
    586588                        }
    587589                    }
    588590                }
    589 # endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     591#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    590592            }
    591593            else
    … …  
    602604            STAM_PROFILE_STOP(&pVM->pgm.s.StatHandlers, b);
    603605
    604 # ifdef PGM_OUT_OF_SYNC_IN_GC
     606#  ifdef PGM_OUT_OF_SYNC_IN_GC
    605607            /*
    606608             * We are here only if page is present in Guest page tables and trap is not handled
    … …  
    622624                    STAM_COUNTER_INC(&pVM->pgm.s.StatGCPageOutOfSyncSupervisor);
    623625
    624 #  if defined(LOG_ENABLED) && !defined(IN_RING0)
     626#   if defined(LOG_ENABLED) && !defined(IN_RING0)
    625627                RTGCPHYS   GCPhys;
    626628                uint64_t   fPageGst;
    … …  
    628630                Log(("Page out of sync: %VGv eip=%08x PdeSrc.n.u1User=%d fPageGst=%08llx GCPhys=%VGp scan=%d\n",
    629631                     pvFault, pRegFrame->eip, PdeSrc.n.u1User, fPageGst, GCPhys, CSAMDoesPageNeedScanning(pVM, (RTRCPTR)pRegFrame->eip)));
    630 #  endif /* LOG_ENABLED */
    631 
    632 #  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) && !defined(IN_RING0)
     632#   endif /* LOG_ENABLED */
     633
     634#   if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) && !defined(IN_RING0)
    633635                if (CPUMGetGuestCPL(pVM, pRegFrame) == 0)
    634636                {
    … …  
    641643                        if (    pvFault == (RTGCPTR)pRegFrame->eip
    642644                            ||  (RTGCUINTPTR)pvFault - pRegFrame->eip < 8    /* instruction crossing a page boundary */
    643 #   ifdef CSAM_DETECT_NEW_CODE_PAGES
     645#    ifdef CSAM_DETECT_NEW_CODE_PAGES
    644646                            ||  (   !PATMIsPatchGCAddr(pVM, (RTGCPTR)pRegFrame->eip)
    645647                                 && CSAMDoesPageNeedScanning(pVM, (RTRCPTR)pRegFrame->eip))   /* any new code we encounter here */
    646 #   endif /* CSAM_DETECT_NEW_CODE_PAGES */
     648#    endif /* CSAM_DETECT_NEW_CODE_PAGES */
    647649                           )
    648650                        {
    … …  
    662664
    663665                                STAM_PROFILE_STOP(&pVM->pgm.s.StatOutOfSync, c);
    664                                 STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eCSAM; });
     666                                STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eCSAM; });
    665667                                return rc;
    666668                            }
    667669                        }
    668 #   ifdef CSAM_DETECT_NEW_CODE_PAGES
     670#    ifdef CSAM_DETECT_NEW_CODE_PAGES
    669671                        else
    670672                        if (    uErr == X86_TRAP_PF_RW
    … …  
    697699                            }
    698700                        }
    699 #   endif  /* CSAM_DETECT_NEW_CODE_PAGES */
     701#    endif  /* CSAM_DETECT_NEW_CODE_PAGES */
    700702
    701703                        /*
    … …  
    707709                    }
    708710                }
    709 #  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) && !defined(IN_RING0) */
     711#   endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) && !defined(IN_RING0) */
    710712                rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)pvFault, PGM_SYNC_NR_PAGES, uErr);
    711713                if (VBOX_SUCCESS(rc))
    … …  
    713715                    /* The page was successfully synced, return to the guest. */
    714716                    STAM_PROFILE_STOP(&pVM->pgm.s.StatOutOfSync, c);
    715                     STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSync; });
     717                    STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSync; });
    716718                    return VINF_SUCCESS;
    717719                }
    … …  
    741743                        * Page was successfully synced, return to guest.
    742744                        */
    743 #  ifdef VBOX_STRICT
     745#   ifdef VBOX_STRICT
    744746                        RTGCPHYS GCPhys;
    745747                        uint64_t fPageGst;
    … …  
    751753                        rc = PGMShwGetPage(pVM, pvFault, &fPageShw, NULL);
    752754                        AssertMsg(VBOX_SUCCESS(rc) && fPageShw & X86_PTE_RW, ("rc=%Vrc fPageShw=%VX64\n", rc, fPageShw));
    753 #  endif /* VBOX_STRICT */
     755#   endif /* VBOX_STRICT */
    754756                        STAM_PROFILE_STOP(&pVM->pgm.s.StatOutOfSync, c);
    755                         STAM_STATS({ pVM->pgm.s.CTXSUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncObsHnd; });
     757                        STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatTrap0eOutOfSyncObsHnd; });
    756758                        return VINF_SUCCESS;
    757759                    }
    … …  
    780782                }
    781783
    782 #  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    783 #   ifdef VBOX_STRICT
     784#   if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     785#    ifdef VBOX_STRICT
    784786                /*
    785787                 * Check for VMM page flags vs. Guest page flags consistency.
    … …  
    808810                else
    809811                    AssertMsgFailed(("PGMGCGetPage rc=%Vrc\n", rc));
    810 #   endif /* VBOX_STRICT */
    811 #  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     812#    endif /* VBOX_STRICT */
     813#   endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    812814            }
    813815            STAM_PROFILE_STOP(&pVM->pgm.s.StatOutOfSync, c);
    814 # endif /* PGM_OUT_OF_SYNC_IN_GC */
     816#  endif /* PGM_OUT_OF_SYNC_IN_GC */
    815817        }
    816818        else
    … …  
    834836
    835837
    836 # if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
     838#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    837839    /*
    838840     * Conclusion, this is a guest trap.
    … …  
    841843    STAM_COUNTER_INC(&pVM->pgm.s.StatGCTrap0eUnhandled);
    842844    return VINF_EM_RAW_GUEST_TRAP;
    843 # else
     845#  else
    844846    /* present, but not a monitored page; perhaps the guest is probing physical memory */
    845847    return VINF_EM_RAW_EMULATE_INSTR;
    846 # endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    847 
    848 
    849 #else /* PGM_GST_TYPE != PGM_TYPE_32BIT */
     848#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
     849
     850
     851# else /* PGM_GST_TYPE != PGM_TYPE_32BIT */
    850852
    851853    AssertReleaseMsgFailed(("Shw=%d Gst=%d is not implemented!\n", PGM_GST_TYPE, PGM_SHW_TYPE));
    852854    return VERR_INTERNAL_ERROR;
    853 #endif /* PGM_GST_TYPE != PGM_TYPE_32BIT */
     855# endif /* PGM_GST_TYPE != PGM_TYPE_32BIT */
    854856}
     857#endif /* !IN_RING3 */
    855858
    856859
    … …  
    896899    {
    897900        Assert(!(pPdptDst->a[iPdpte].u & PGM_PLXFLAGS_MAPPING));
    898         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePageSkipped));
     901        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    899902        return VINF_SUCCESS;
    900903    }
    … …  
    914917    {
    915918        AssertMsg(rc == VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT || rc == VERR_PAGE_MAP_LEVEL4_NOT_PRESENT, ("Unexpected rc=%Vrc\n", rc));
    916         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePageSkipped));
     919        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    917920        if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
    918921            PGM_INVL_GUEST_TLBS();
    … …  
    926929    if (!pPdpeDst->n.u1Present)
    927930    {
    928         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePageSkipped));
     931        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    929932        if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
    930933            PGM_INVL_GUEST_TLBS();
    … …  
    937940    if (!PdeDst.n.u1Present)
    938941    {
    939         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePageSkipped));
     942        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    940943        return VINF_SUCCESS;
    941944    }
    … …  
    989992#  endif
    990993    {
    991         STAM_COUNTER_INC(&pVM->pgm.s.StatHCInvalidatePageSkipped);
     994        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    992995        return VINF_SUCCESS;
    993996    }
    … …  
    10151018        pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pHCShwAmd64CR3->idx, iPml4e);
    10161019        pPml4eDst->u = 0;
    1017         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
     1020        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    10181021        PGM_INVL_GUEST_TLBS();
    10191022        return VINF_SUCCESS;
    … …  
    10291032        pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pHCShwAmd64CR3->idx, iPml4e);
    10301033        pPml4eDst->u = 0;
    1031         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
     1034        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    10321035        PGM_INVL_GUEST_TLBS();
    10331036    }
    … …  
    10411044        pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pHCShwAmd64CR3->idx, iPml4e);
    10421045        pPml4eDst->u = 0;
    1043         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
     1046        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNAs));
    10441047        PGM_INVL_GUEST_TLBS();
    10451048    }
    … …  
    10551058        pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdpte);
    10561059        pPdpeDst->u = 0;
    1057         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
     1060        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    10581061        PGM_INVL_GUEST_TLBS();
    10591062        return VINF_SUCCESS;
    … …  
    10691072        pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdpte);
    10701073        pPdpeDst->u = 0;
    1071         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
     1074        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    10721075        PGM_INVL_GUEST_TLBS();
    10731076    }
    … …  
    10811084        pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdpte);
    10821085        pPdpeDst->u = 0;
    1083         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
     1086        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNAs));
    10841087        PGM_INVL_GUEST_TLBS();
    10851088    }
    … …  
    11441147# endif
    11451148            pPdeDst->u = 0;
    1146             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
     1149            STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    11471150            PGM_INVL_GUEST_TLBS();
    11481151        }
    … …  
    11601163# endif
    11611164            pPdeDst->u = 0;
    1162             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
     1165            STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNAs));
    11631166            PGM_INVL_GUEST_TLBS();
    11641167        }
    … …  
    11921195                    rc = VINF_SUCCESS;
    11931196# endif
    1194                 STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePage4KBPages));
     1197                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage4KBPages));
    11951198                PGM_INVL_PG(GCPtrPage);
    11961199            }
    … …  
    12081211# endif
    12091212                pPdeDst->u = 0;
    1210                 STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
     1213                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    12111214                PGM_INVL_GUEST_TLBS();
    12121215            }
    … …  
    12351238                {
    12361239                    LogFlow(("Skipping flush for big page containing %VGv (PD=%X .u=%VX64)-> nothing has changed!\n", GCPtrPage, iPDSrc, PdeSrc.u));
    1237                     STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePage4MBPagesSkip));
     1240                    STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage4MBPagesSkip));
    12381241                    return VINF_SUCCESS;
    12391242                }
    … …  
    12541257# endif
    12551258            pPdeDst->u = 0;
    1256             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePage4MBPages));
     1259            STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage4MBPages));
    12571260            PGM_INVL_BIG_PG(GCPtrPage);
    12581261        }
    … …  
    12711274# endif
    12721275            pPdeDst->u = 0;
    1273             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
     1276            STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    12741277            PGM_INVL_PG(GCPtrPage);
    12751278        }
    … …  
    12771280        {
    12781281            Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
    1279             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDMappings));
     1282            STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDMappings));
    12801283        }
    12811284    }
    … …  
    14491452                {
    14501453                    LogFlow(("SyncPageWorker: page and or page directory not accessed -> mark not present\n"));
    1451                     STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,AccessedPage));
     1454                    STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,AccessedPage));
    14521455                    PteDst.u = 0;
    14531456                }
    … …  
    14591462                if (!PteSrc.n.u1Dirty && (PdeSrc.n.u1Write & PteSrc.n.u1Write))
    14601463                {
    1461                     STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPage));
     1464                    STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPage));
    14621465                    PteDst.u = (PteSrc.u & ~(X86_PTE_PAE_PG_MASK | X86_PTE_AVL_MASK | X86_PTE_PAT | X86_PTE_PCD | X86_PTE_PWT | X86_PTE_RW))
    14631466                             | (HCPhys & X86_PTE_PAE_PG_MASK)
    … …  
    14671470#endif
    14681471                {
    1469                     STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPageSkipped));
     1472                    STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPageSkipped));
    14701473#if PGM_SHW_TYPE == PGM_TYPE_EPT
    14711474                    PteDst.u           = (HCPhys & EPT_PTE_PG_MASK);
    … …  
    17751778                    if (!PdeSrc.b.u1Dirty && PdeSrc.b.u1Write)
    17761779                    {
    1777                         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPageBig));
     1780                        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPageBig));
    17781781                        PdeDst.u |= PGM_PDFLAGS_TRACK_DIRTY;
    17791782                        PdeDst.n.u1Write = 0;
    … …  
    18001803            return VINF_SUCCESS;
    18011804        }
    1802         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncPagePDNAs));
     1805        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPagePDNAs));
    18031806    }
    18041807    else
    18051808    {
    1806         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncPagePDOutOfSync));
     1809        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPagePDOutOfSync));
    18071810        Log2(("SyncPage: Out-Of-Sync PDE at %VGp PdeSrc=%RX64 PdeDst=%RX64\n",
    18081811              GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u));
    … …  
    19781981    int rc;
    19791982
    1980     STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat, DirtyBitTracking), a);
     1983    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    19811984    LogFlow(("CheckPageFault: GCPtrPage=%VGv uErr=%#x PdeSrc=%08x\n", GCPtrPage, uErr, pPdeSrc->u));
    19821985
    … …  
    20652068            if (pPdeDst->n.u1Present && (pPdeDst->u & PGM_PDFLAGS_TRACK_DIRTY))
    20662069            {
    2067                 STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPageTrap));
     2070                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPageTrap));
    20682071
    20692072                Assert(pPdeSrc->b.u1Write);
    … …  
    20732076                pPdeDst->au32[0]       &= ~PGM_PDFLAGS_TRACK_DIRTY;
    20742077                PGM_INVL_BIG_PG(GCPtrPage);
    2075                 STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2078                STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    20762079                return VINF_PGM_HANDLED_DIRTY_BIT_FAULT;
    20772080            }
    20782081        }
    2079         STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2082        STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    20802083        return VINF_PGM_NO_DIRTY_BIT_TRACKING;
    20812084    }
    … …  
    21022105           )
    21032106        {
    2104 #  ifdef IN_GC
    2105             STAM_COUNTER_INC(&pVM->pgm.s.StatGCDirtyTrackRealPF);
    2106 #  endif
    2107             STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2107            STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyTrackRealPF));
     2108            STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    21082109            LogFlow(("CheckPageFault: real page fault at %VGv PteSrc.u=%08x (2)\n", GCPtrPage, PteSrc.u));
    21092110
    … …  
    21142115                TRPMSetErrorCode(pVM, uErr | X86_TRAP_PF_P); /* page-level protection violation */
    21152116
    2116             STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2117            STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    21172118            return VINF_EM_RAW_GUEST_TRAP;
    21182119        }
    … …  
    21352136        {
    21362137            /* Write access, so mark guest entry as dirty. */
    2137 #  if defined(IN_GC) && defined(VBOX_WITH_STATISTICS)
     2138#  ifdef VBOX_WITH_STATISTICS
    21382139            if (!pPteSrc->n.u1Dirty)
    2139                 STAM_COUNTER_INC(&pVM->pgm.s.StatGCDirtiedPage);
     2140                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtiedPage));
    21402141            else
    2141                 STAM_COUNTER_INC(&pVM->pgm.s.StatGCPageAlreadyDirty);
     2142                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PageAlreadyDirty));
    21422143#  endif
    21432144
    … …  
    21532154                {
    21542155                    LogRel(("CheckPageFault: write to hypervisor region %VGv\n", GCPtrPage));
    2155                     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2156                    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    21562157                    return VINF_SUCCESS;
    21572158                }
    … …  
    21752176                                      ("Unexpected dirty bit tracking on monitored page %VGv (phys %VGp)!!!!!!\n", GCPtrPage, pPteSrc->u & X86_PTE_PAE_PG_MASK));
    21762177#  endif
    2177                         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPageTrap));
     2178                        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPageTrap));
    21782179
    21792180                        Assert(pPteSrc->n.u1Write);
    … …  
    21852186                        PGM_INVL_PG(GCPtrPage);
    21862187
    2187                         STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2188                        STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    21882189                        return VINF_PGM_HANDLED_DIRTY_BIT_FAULT;
    21892190                    }
    … …  
    22102211        }
    22112212#  endif /* VBOX_STRICT */
    2212         STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2213        STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    22132214        return VINF_PGM_NO_DIRTY_BIT_TRACKING;
    22142215    }
    22152216    AssertRC(rc);
    2216     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,DirtyBitTracking), a);
     2217    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    22172218    return rc;
    22182219
    … …  
    22222223     * Single exit handler to get rid of duplicate code paths.
    22232224     */
    2224 #  ifdef IN_GC
    2225     STAM_COUNTER_INC(&pVM->pgm.s.StatGCDirtyTrackRealPF);
    2226 #  endif
    2227     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat, DirtyBitTracking), a);
     2225    STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyTrackRealPF));
     2226    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    22282227    Log(("CheckPageFault: real page fault at %VGv (%d)\n", GCPtrPage, uPageFaultLevel));
    22292228
    … …  
    22802279PGM_BTH_DECL(int, SyncPT)(PVM pVM, unsigned iPDSrc, PGSTPD pPDSrc, RTGCUINTPTR GCPtrPage)
    22812280{
    2282     STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
     2281    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    22832282    STAM_COUNTER_INC(&pVM->pgm.s.StatGCSyncPtPD[iPDSrc]);
    22842283    LogFlow(("SyncPT: GCPtrPage=%VGv\n", GCPtrPage));
    … …  
    23342333#  ifndef IN_RING3
    23352334        Log(("SyncPT: Conflict at %VGv\n", GCPtrPage));
    2336         STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
     2335        STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    23372336        return VERR_ADDRESS_CONFLICT;
    23382337#  else
    … …  
    23482347        if (VBOX_FAILURE(rc))
    23492348        {
    2350             STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
     2349            STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    23512350            return rc;
    23522351        }
    … …  
    24192418                if (!PdeSrc.b.u1Dirty && PdeSrc.b.u1Write)
    24202419                {
    2421                     STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPageBig));
     2420                    STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPageBig));
    24222421                    PdeDst.u |= PGM_PDFLAGS_TRACK_DIRTY;
    24232422                    PdeDst.b.u1Write = 0;
    … …  
    25582557            if (!PdeSrc.b.u1Dirty && PdeSrc.b.u1Write)
    25592558            {
    2560                 STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,DirtyPageBig));
     2559                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,DirtyPageBig));
    25612560                PdeDst.u |= PGM_PDFLAGS_TRACK_DIRTY;
    25622561                PdeDst.b.u1Write = 0;
    … …  
    26692668        AssertRelease(!PdeDst.n.u1Present);
    26702669
    2671     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
    2672 # ifdef IN_GC
     2670    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    26732671    if (VBOX_FAILURE(rc))
    2674       STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncPTFailed));
    2675 # endif
     2672        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPTFailed));
    26762673    return rc;
    26772674
    … …  
    27622759
    27632760    rc = PGM_BTH_NAME(SyncPage)(pVM, PdeSrc, (RTGCUINTPTR)GCPtrPage, PGM_SYNC_NR_PAGES, 0 /* page not present */);
    2764     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
     2761    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    27652762    return rc;
    27662763
    27672764#else
    27682765    AssertReleaseMsgFailed(("Shw=%d Gst=%d is not implemented!\n", PGM_GST_TYPE, PGM_SHW_TYPE));
    2769     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
     2766    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
    27702767    return VERR_INTERNAL_ERROR;
    27712768#endif
    … …  
    31003097     */
    31013098    /** @todo this MUST go away. See #1557. */
    3102     STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncCR3Handlers), h);
     3099    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3Handlers), h);
    31033100    PGM_GST_NAME(HandlerVirtualUpdate)(pVM, cr4);
    3104     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncCR3Handlers), h);
     3101    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3Handlers), h);
    31053102#endif
    31063103
    … …  
    31223119
    31233120    Assert(fGlobal || (cr4 & X86_CR4_PGE));
    3124     MY_STAM_COUNTER_INC(fGlobal ? &pVM->pgm.s.CTXMID(Stat,SyncCR3Global) : &pVM->pgm.s.CTXMID(Stat,SyncCR3NotGlobal));
     3121    MY_STAM_COUNTER_INC(fGlobal ? &pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3Global) : &pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3NotGlobal));
    31253122
    31263123# if PGM_GST_TYPE == PGM_TYPE_32BIT || PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
    … …  
    34233420                                    && (cr4 & (X86_CR4_PGE | X86_CR4_PSE)) == (X86_CR4_PGE | X86_CR4_PSE))
    34243421#   endif
    3425                                     MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstSkippedGlobalPD));
     3422                                    MY_STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3DstSkippedGlobalPD));
    34263423                                else if (!fGlobal && !pShwPage->fSeenNonGlobal && (cr4 & X86_CR4_PGE))
    3427                                     MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstSkippedGlobalPT));
     3424                                    MY_STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3DstSkippedGlobalPT));
    34283425                                else
    3429                                     MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstCacheHit));
     3426                                    MY_STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3DstCacheHit));
    34303427#  endif /* VBOX_WITH_STATISTICS */
    34313428        /** @todo a replacement strategy isn't really needed unless we're using a very small pool < 512 pages.
    … …  
    34433440#  endif
    34443441                                pPDEDst->u = 0;
    3445                                 MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstFreed));
     3442                                MY_STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3DstFreed));
    34463443                            }
    34473444                        }
    34483445                        else
    3449                             MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstNotPresent));
     3446                            MY_STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3DstNotPresent));
    34503447                        pPDEDst++;
    34513448                    }
    … …  
    34763473#  endif
    34773474                            pPDEDst->u = 0;
    3478                             MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstFreedSrcNP));
     3475                            MY_STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3DstFreedSrcNP));
    34793476                        }
    34803477                        pPDEDst++;

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

    r13062 r13067  
    611611                                              pVM->pgm.s.pfnR3GstWriteHandlerCR3, 0,
    612612                                              pVM->pgm.s.pfnR0GstWriteHandlerCR3, 0,
    613                                               pVM->pgm.s.pfnGCGstWriteHandlerCR3, 0,
     613                                              pVM->pgm.s.pfnRCGstWriteHandlerCR3, 0,
    614614                                              pVM->pgm.s.pszR3GstWriteHandlerCR3);
    615615# else  /* PGMPOOL_WITH_MIXED_PT_CR3 */
    … …  
    936936
    937937    pgmLock(pVM);
    938     STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncCR3HandlerVirtualUpdate), a);
     938    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3HandlerVirtualUpdate), a);
    939939    State.pVM   = pVM;
    940940    State.fTodo = pVM->pgm.s.fSyncFlags;
    941941    State.cr4   = cr4;
    942942    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, PGM_GST_NAME(VirtHandlerUpdateOne), &State);
    943     STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncCR3HandlerVirtualUpdate), a);
     943    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3HandlerVirtualUpdate), a);
    944944
    945945
    … …  
    949949    if (State.fTodo & PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL)
    950950    {
    951         STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncCR3HandlerVirtualReset), b);
     951        STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3HandlerVirtualReset), b);
    952952        Log(("pgmR3VirtualHandlersUpdate: resets bits\n"));
    953953        RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, pgmHandlerVirtualResetOne, pVM);
    954954        pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL;
    955         STAM_PROFILE_STOP(&pVM->pgm.s.CTXMID(Stat,SyncCR3HandlerVirtualReset), b);
     955        STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3HandlerVirtualReset), b);
    956956    }
    957957    pgmUnlock(pVM);
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