VirtualBox

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


Ignore:
Timestamp:
Feb 14, 2022 10:36:21 AM (3 years ago)
Author:
vboxsync
Message:

VMM/PGM: Moved the physical handler allocation off the hyper heap and into its own slab, changing the it to the 'hardened' avl tree code. bugref:10093

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

Legend:

Unmodified
Added
Removed

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

    r93650 r93716  
    606606#include <VBox/vmm/hm.h>
    607607#include "PGMInternal.h"
    608 #include <VBox/vmm/vm.h>
     608#include <VBox/vmm/vmcc.h>
    609609#include <VBox/vmm/uvm.h>
    610610#include "PGMInline.h"
    … …  
    933933
    934934    /*
    935      * Trees
    936      */
    937     rc = MMHyperAlloc(pVM, sizeof(PGMTREES), 0, MM_TAG_PGM, (void **)&pVM->pgm.s.pTreesR3);
    938     if (RT_SUCCESS(rc))
    939         pVM->pgm.s.pTreesR0 = MMHyperR3ToR0(pVM, pVM->pgm.s.pTreesR3);
    940 
    941     /*
    942935     * Setup the zero page (HCPHysZeroPg is set by ring-0).
    943936     */
    … …  
    958951    AssertRelease(pVM->pgm.s.HCPhysMmioPg != 0);
    959952    pVM->pgm.s.HCPhysInvMmioPg = pVM->pgm.s.HCPhysMmioPg;
     953
     954    /*
     955     * Initialize physical access handlers.
     956     */
     957    /** @cfgm{/PGM/MaxPhysicalAccessHandlers, uint32_t, 32, 65536, 6144}
     958     * Number of physical access handlers allowed (subject to rounding).  This is
     959     * managed as one time allocation during initializations.  The default is
     960     * lower for a driverless setup. */
     961    /** @todo can lower it for nested paging too, at least when there is no
     962     *        nested guest involved. */
     963    uint32_t cAccessHandlers = 0;
     964    rc = CFGMR3QueryU32Def(pCfgPGM, "MaxPhysicalAccessHandlers", &cAccessHandlers, !fDriverless ? 6144 : 640);
     965    AssertLogRelRCReturn(rc, rc);
     966    AssertLogRelMsgStmt(cAccessHandlers >= 32, ("cAccessHandlers=%#x, min 32\n", cAccessHandlers), cAccessHandlers = 32);
     967    AssertLogRelMsgStmt(cAccessHandlers <= _64K, ("cAccessHandlers=%#x, max 65536\n", cAccessHandlers), cAccessHandlers = _64K);
     968    if (!fDriverless)
     969    {
     970        rc = VMMR3CallR0(pVM, VMMR0_DO_PGM_PHYS_HANDLER_INIT, cAccessHandlers, NULL);
     971        AssertRCReturn(rc, rc);
     972        AssertPtr(pVM->pgm.s.pPhysHandlerTree);
     973        AssertPtr(pVM->pgm.s.PhysHandlerAllocator.m_paNodes);
     974        AssertPtr(pVM->pgm.s.PhysHandlerAllocator.m_pbmAlloc);
     975    }
     976    else
     977    {
     978        uint32_t       cbTreeAndBitmap = 0;
     979        uint32_t const cbTotalAligned  = pgmHandlerPhysicalCalcTableSizes(&cAccessHandlers, &cbTreeAndBitmap);
     980        uint8_t       *pb = NULL;
     981        rc = SUPR3PageAlloc(cbTotalAligned >> HOST_PAGE_SHIFT, 0, (void **)&pb);
     982        AssertLogRelRCReturn(rc, rc);
     983
     984        pVM->pgm.s.PhysHandlerAllocator.initSlabAllocator(cAccessHandlers, (PPGMPHYSHANDLER)&pb[cbTreeAndBitmap],
     985                                                          (uint64_t *)&pb[sizeof(PGMPHYSHANDLERTREE)]);
     986        pVM->pgm.s.pPhysHandlerTree = (PPGMPHYSHANDLERTREE)pb;
     987        pVM->pgm.s.pPhysHandlerTree->initWithAllocator(&pVM->pgm.s.PhysHandlerAllocator);
     988    }
    960989
    961990    /*
    … …  
    12191248        AssertRC(rc);
    12201249
     1250#define PGM_REG_U64(a, b, c) \
     1251        rc = STAMR3RegisterF(pVM, a, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, c, b); \
     1252        AssertRC(rc);
     1253
     1254#define PGM_REG_U64_RESET(a, b, c) \
     1255        rc = STAMR3RegisterF(pVM, a, STAMTYPE_U64_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, c, b); \
     1256        AssertRC(rc);
     1257
     1258#define PGM_REG_U32(a, b, c) \
     1259        rc = STAMR3RegisterF(pVM, a, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, c, b); \
     1260        AssertRC(rc);
     1261
    12211262#define PGM_REG_COUNTER_BYTES(a, b, c) \
    12221263        rc = STAMR3RegisterF(pVM, a, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, c, b); \
    … …  
    12831324    PGM_REG_COUNTER(&pStats->StatRZPhysHandlerLookupMisses,     "/PGM/RZ/PhysHandlerLookupMisses",    "The number of cache misses when looking up physical handlers.");
    12841325    PGM_REG_COUNTER(&pStats->StatR3PhysHandlerLookupMisses,     "/PGM/R3/PhysHandlerLookupMisses",    "The number of cache misses when looking up physical handlers.");
    1285 
     1326#endif /* VBOX_WITH_STATISTICS */
     1327    PPGMPHYSHANDLERTREE pPhysHndlTree = pVM->pgm.s.pPhysHandlerTree;
     1328    PGM_REG_U32(&pPhysHndlTree->m_cErrors,                      "/PGM/PhysHandlerTree/ErrorsTree",    "Physical access handler tree errors.");
     1329    PGM_REG_U32(&pVM->pgm.s.PhysHandlerAllocator.m_cErrors,     "/PGM/PhysHandlerTree/ErrorsAllocatorR3", "Physical access handler tree allocator errors (ring-3 only).");
     1330    PGM_REG_U64_RESET(&pPhysHndlTree->m_cInserts,               "/PGM/PhysHandlerTree/Inserts",       "Physical access handler tree inserts.");
     1331    PGM_REG_U32(&pVM->pgm.s.PhysHandlerAllocator.m_cNodes,      "/PGM/PhysHandlerTree/MaxHandlers",   "Max physical access handlers.");
     1332    PGM_REG_U64_RESET(&pPhysHndlTree->m_cRemovals,              "/PGM/PhysHandlerTree/Removals",      "Physical access handler tree removals.");
     1333    PGM_REG_U64_RESET(&pPhysHndlTree->m_cRebalancingOperations, "/PGM/PhysHandlerTree/RebalancingOperations", "Physical access handler tree rebalancing transformations.");
     1334
     1335#ifdef VBOX_WITH_STATISTICS
    12861336    PGM_REG_COUNTER(&pStats->StatRZPageReplaceShared,           "/PGM/RZ/Page/ReplacedShared",        "Times a shared page was replaced.");
    12871337    PGM_REG_COUNTER(&pStats->StatRZPageReplaceZero,             "/PGM/RZ/Page/ReplacedZero",          "Times the zero page was replaced.");
    … …  
    13231373
    13241374#undef PGM_REG_COUNTER
     1375#undef PGM_REG_U64
     1376#undef PGM_REG_U64_RESET
     1377#undef PGM_REG_U32
    13251378#undef PGM_REG_PROFILE
    13261379#undef PGM_REG_PROFILE_NS
    … …  
    21042157                        pszType = "MMIO";
    21052158                        PGM_LOCK_VOID(pVM);
    2106                         PPGMPHYSHANDLER pHandler = pgmHandlerPhysicalLookup(pVM, iFirstPage * X86_PAGE_SIZE);
    2107                         if (pHandler)
     2159                        PPGMPHYSHANDLER pHandler;
     2160                        int rc = pgmHandlerPhysicalLookup(pVM, iFirstPage * X86_PAGE_SIZE, &pHandler);
     2161                        if (RT_SUCCESS(rc))
    21082162                            pszMore = pHandler->pszDesc;
    21092163                        PGM_UNLOCK(pVM);
    … …  
    25372591{
    25382592    bool                    fLeftToRight;    /**< true: left-to-right; false: right-to-left. */
     2593    uint32_t                cErrors;
    25392594    PPGMPHYSHANDLER         pPrevPhys;
    25402595    PVM                     pVM;
    … …  
    25482603 * @param   pvUser      pVM.
    25492604 */
    2550 static DECLCALLBACK(int) pgmR3CheckIntegrityPhysHandlerNode(PAVLROGCPHYSNODECORE pNode, void *pvUser)
     2605static DECLCALLBACK(int) pgmR3CheckIntegrityPhysHandlerNode(PPGMPHYSHANDLER pNode, void *pvUser)
    25512606{
    25522607    PPGMCHECKINTARGS pArgs = (PPGMCHECKINTARGS)pvUser;
    2553     PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)pNode;
    2554     AssertReleaseReturn(!((uintptr_t)pCur & 7), 1);
    2555     AssertReleaseMsg(pCur->Core.Key <= pCur->Core.KeyLast,
    2556                      ("pCur=%p %RGp-%RGp %s\n", pCur, pCur->Core.Key, pCur->Core.KeyLast, pCur->pszDesc));
    2557     AssertReleaseMsg(   !pArgs->pPrevPhys
    2558                      || (  pArgs->fLeftToRight
    2559                          ? pArgs->pPrevPhys->Core.KeyLast < pCur->Core.Key
    2560                          : pArgs->pPrevPhys->Core.KeyLast > pCur->Core.Key),
    2561                      ("pPrevPhys=%p %RGp-%RGp %s\n"
    2562                       "     pCur=%p %RGp-%RGp %s\n",
    2563                       pArgs->pPrevPhys, pArgs->pPrevPhys->Core.Key, pArgs->pPrevPhys->Core.KeyLast, pArgs->pPrevPhys->pszDesc,
    2564                       pCur, pCur->Core.Key, pCur->Core.KeyLast, pCur->pszDesc));
    2565     pArgs->pPrevPhys = pCur;
     2608
     2609    AssertLogRelMsgReturnStmt(!((uintptr_t)pNode & 7), ("pNode=%p\n", pNode), pArgs->cErrors++, VERR_INVALID_POINTER);
     2610
     2611    AssertLogRelMsgStmt(pNode->Key <= pNode->KeyLast,
     2612                        ("pNode=%p %RGp-%RGp %s\n", pNode, pNode->Key, pNode->KeyLast, pNode->pszDesc),
     2613                        pArgs->cErrors++);
     2614
     2615    AssertLogRelMsgStmt(   !pArgs->pPrevPhys
     2616                        || (  pArgs->fLeftToRight
     2617                            ? pArgs->pPrevPhys->KeyLast < pNode->Key
     2618                            : pArgs->pPrevPhys->KeyLast > pNode->Key),
     2619                        ("pPrevPhys=%p %RGp-%RGp %s\n"
     2620                         "    pNode=%p %RGp-%RGp %s\n",
     2621                         pArgs->pPrevPhys, pArgs->pPrevPhys->Key, pArgs->pPrevPhys->KeyLast, pArgs->pPrevPhys->pszDesc,
     2622                         pNode, pNode->Key, pNode->KeyLast, pNode->pszDesc),
     2623                        pArgs->cErrors++);
     2624
     2625    pArgs->pPrevPhys = pNode;
    25662626    return 0;
    25672627}
    … …  
    25802640     * Check the trees.
    25812641     */
    2582     int cErrors = 0;
    2583     const PGMCHECKINTARGS LeftToRight = {  true, NULL, pVM };
    2584     const PGMCHECKINTARGS RightToLeft = { false, NULL, pVM };
    2585     PGMCHECKINTARGS Args = LeftToRight;
    2586     cErrors += RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers,       true,  pgmR3CheckIntegrityPhysHandlerNode, &Args);
    2587     Args = RightToLeft;
    2588     cErrors += RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers,       false, pgmR3CheckIntegrityPhysHandlerNode, &Args);
    2589 
    2590     return !cErrors ? VINF_SUCCESS : VERR_INTERNAL_ERROR;
    2591 }
    2592 
     2642    PGMCHECKINTARGS Args = { true, 0, NULL, pVM };
     2643    int rc = pVM->pgm.s.pPhysHandlerTree->doWithAllFromLeft(&pVM->pgm.s.PhysHandlerAllocator,
     2644                                                            pgmR3CheckIntegrityPhysHandlerNode, &Args);
     2645    AssertLogRelRCReturn(rc, rc);
     2646
     2647    Args.fLeftToRight = false;
     2648    Args.pPrevPhys    = NULL;
     2649    rc = pVM->pgm.s.pPhysHandlerTree->doWithAllFromRight(&pVM->pgm.s.PhysHandlerAllocator,
     2650                                                         pgmR3CheckIntegrityPhysHandlerNode, &Args);
     2651    AssertLogRelMsgReturn(pVM->pgm.s.pPhysHandlerTree->m_cErrors == 0,
     2652                          ("m_cErrors=%#x\n", pVM->pgm.s.pPhysHandlerTree->m_cErrors == 0),
     2653                          VERR_INTERNAL_ERROR);
     2654
     2655    return Args.cErrors == 0 ? VINF_SUCCESS : VERR_INTERNAL_ERROR;
     2656}
     2657

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

    r93554 r93716  
    2525#include <VBox/vmm/stam.h>
    2626#include "PGMInternal.h"
    27 #include <VBox/vmm/vm.h>
     27#include <VBox/vmm/vmcc.h>
    2828#include <VBox/vmm/uvm.h>
    2929#include "PGMInline.h"

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

    r93667 r93716  
    3434#include <VBox/vmm/ssm.h>
    3535#include "PGMInternal.h"
    36 #include <VBox/vmm/vm.h>
     36#include <VBox/vmm/vmcc.h>
    3737#include "PGMInline.h"
    3838#include <VBox/dbg.h>
    … …  
    5252*   Internal Functions                                                                                                           *
    5353*********************************************************************************************************************************/
    54 static DECLCALLBACK(int) pgmR3HandlerPhysicalOneClear(PAVLROGCPHYSNODECORE pNode, void *pvUser);
    55 static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PAVLROGCPHYSNODECORE pNode, void *pvUser);
    56 static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PAVLROGCPHYSNODECORE pNode, void *pvUser);
     54static DECLCALLBACK(int) pgmR3HandlerPhysicalOneClear(PPGMPHYSHANDLER pHandler, void *pvUser);
     55static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PPGMPHYSHANDLER pHandler, void *pvUser);
     56static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PPGMPHYSHANDLER pHandler, void *pvUser);
    5757
    5858
    … …  
    143143     */
    144144    PGM_LOCK_VOID(pVM);
    145     RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers,  true, pgmR3HandlerPhysicalOneClear, pVM);
    146     RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, false, pgmR3HandlerPhysicalOneSet, pVM);
     145
     146    int rc = pVM->pgm.s.pPhysHandlerTree->doWithAllFromLeft(&pVM->pgm.s.PhysHandlerAllocator, pgmR3HandlerPhysicalOneClear, pVM);
     147    AssertRC(rc);
     148    rc = pVM->pgm.s.pPhysHandlerTree->doWithAllFromRight(&pVM->pgm.s.PhysHandlerAllocator, pgmR3HandlerPhysicalOneSet, pVM);
     149    AssertRC(rc);
     150
    147151    PGM_UNLOCK(pVM);
    148152}
    … …  
    153157 *
    154158 * @returns 0
    155  * @param   pNode   Pointer to a PGMPHYSHANDLER.
    156  * @param   pvUser  Pointer to the VM.
    157  */
    158 static DECLCALLBACK(int) pgmR3HandlerPhysicalOneClear(PAVLROGCPHYSNODECORE pNode, void *pvUser)
    159 {
    160     PPGMPHYSHANDLER pCur     = (PPGMPHYSHANDLER)pNode;
     159 * @param   pHandler    The physical access handler entry.
     160 * @param   pvUser      Pointer to the VM.
     161 */
     162static DECLCALLBACK(int) pgmR3HandlerPhysicalOneClear(PPGMPHYSHANDLER pHandler, void *pvUser)
     163{
    161164    PPGMRAMRANGE    pRamHint = NULL;
    162     RTGCPHYS        GCPhys   = pCur->Core.Key;
    163     RTUINT          cPages   = pCur->cPages;
     165    RTGCPHYS        GCPhys   = pHandler->Key;
     166    RTUINT          cPages   = pHandler->cPages;
    164167    PVM             pVM      = (PVM)pvUser;
    165168    for (;;)
    … …  
    198201 *
    199202 * @returns 0
    200  * @param   pNode   Pointer to a PGMPHYSHANDLER.
    201  * @param   pvUser  Pointer to the VM.
    202  */
    203 static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PAVLROGCPHYSNODECORE pNode, void *pvUser)
     203 * @param   pHandler    The physical access handler entry.
     204 * @param   pvUser      Pointer to the VM.
     205 */
     206static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PPGMPHYSHANDLER pHandler, void *pvUser)
    204207{
    205208    PVM                     pVM       = (PVM)pvUser;
    206     PPGMPHYSHANDLER         pCur      = (PPGMPHYSHANDLER)pNode;
    207     PCPGMPHYSHANDLERTYPEINT pCurType  = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
    208     unsigned                uState    = pCurType->uState;
     209    PCPGMPHYSHANDLERTYPEINT pType     = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pHandler);
     210    unsigned                uState    = pType->uState;
    209211    PPGMRAMRANGE            pRamHint  = NULL;
    210     RTGCPHYS                GCPhys    = pCur->Core.Key;
    211     RTUINT                  cPages    = pCur->cPages;
     212    RTGCPHYS                GCPhys    = pHandler->Key;
     213    RTUINT                  cPages    = pHandler->cPages;
    212214    for (;;)
    213215    {
    … …  
    275277     */
    276278    pHlp->pfnPrintf(pHlp,
    277                     "Physical handlers: (PhysHandlers=%d (%#x))\n"
     279                    "Physical handlers: max %#x, %u allocator error%s, %u tree error%s\n"
    278280                    "%*s %*s %*s uUser             Type     Description\n",
    279                     pVM->pgm.s.pTreesR3->PhysHandlers, pVM->pgm.s.pTreesR3->PhysHandlers,
     281                    pVM->pgm.s.PhysHandlerAllocator.m_cNodes,
     282                    pVM->pgm.s.PhysHandlerAllocator.m_cErrors, pVM->pgm.s.PhysHandlerAllocator.m_cErrors != 0 ? "s" : "",
     283                    pVM->pgm.s.pPhysHandlerTree->m_cErrors, pVM->pgm.s.pPhysHandlerTree->m_cErrors != 0 ? "s" : "",
    280284                    - (int)sizeof(RTGCPHYS) * 2,     "From",
    281285                    - (int)sizeof(RTGCPHYS) * 2 - 3, "- To (incl)",
    282286                    - (int)sizeof(RTHCPTR)  * 2 - 1, "Handler (R3)");
    283     RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers, true, pgmR3InfoHandlersPhysicalOne, &Args);
     287    pVM->pgm.s.pPhysHandlerTree->doWithAllFromLeft(&pVM->pgm.s.PhysHandlerAllocator, pgmR3InfoHandlersPhysicalOne, &Args);
    284288}
    285289
    … …  
    289293 *
    290294 * @returns 0
    291  * @param   pNode   Pointer to a PGMPHYSHANDLER.
    292  * @param   pvUser  Pointer to command helper functions.
    293  */
    294 static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PAVLROGCPHYSNODECORE pNode, void *pvUser)
    295 {
    296     PPGMPHYSHANDLER         pCur     = (PPGMPHYSHANDLER)pNode;
    297     PPGMHANDLERINFOARG      pArgs    = (PPGMHANDLERINFOARG)pvUser;
    298     PCDBGFINFOHLP           pHlp     = pArgs->pHlp;
    299     PCPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pArgs->pVM, pCur);
     295 * @param   pHandler    The physical access handler entry.
     296 * @param   pvUser      Pointer to command helper functions.
     297 */
     298static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PPGMPHYSHANDLER pHandler, void *pvUser)
     299{
     300    PPGMHANDLERINFOARG      pArgs = (PPGMHANDLERINFOARG)pvUser;
     301    PCDBGFINFOHLP           pHlp  = pArgs->pHlp;
     302    PCPGMPHYSHANDLERTYPEINT pType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pArgs->pVM, pHandler);
    300303    const char *pszType;
    301     switch (pCurType->enmKind)
     304    switch (pType->enmKind)
    302305    {
    303306        case PGMPHYSHANDLERKIND_MMIO:   pszType = "MMIO   "; break;
    … …  
    309312    char   szFlags[80];
    310313    size_t cchFlags = 0;
    311     if (pCurType->fKeepPgmLock)
     314    if (pType->fKeepPgmLock)
    312315        cchFlags = RTStrPrintf(szFlags, sizeof(szFlags), "(keep-pgm-lock");
    313     if (pCurType->fRing0DevInsIdx)
     316    if (pType->fRing0DevInsIdx)
    314317        cchFlags += RTStrPrintf(&szFlags[cchFlags], sizeof(szFlags) - cchFlags, cchFlags ? ", keep-pgm-lock" : "(keep-pgm-lock");
    315     if (pCurType->fRing0Enabled)
     318    if (pType->fRing0Enabled)
    316319        cchFlags += RTStrPrintf(&szFlags[cchFlags], sizeof(szFlags) - cchFlags, cchFlags ? ", r0-enabled)" : "(r0-enabled)");
    317320    else
    … …  
    320323    pHlp->pfnPrintf(pHlp,
    321324                    "%RGp - %RGp  %p  %016RX64  %s  %s  %s\n",
    322                     pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandler, pCur->uUser, pszType, pCur->pszDesc, szFlags);
     325                    pHandler->Key, pHandler->KeyLast, pType->pfnHandler, pHandler->uUser, pszType, pHandler->pszDesc, szFlags);
    323326#ifdef VBOX_WITH_STATISTICS
    324327    if (pArgs->fStats)
    325328        pHlp->pfnPrintf(pHlp, "   cPeriods: %9RU64  cTicks: %11RU64  Min: %11RU64  Avg: %11RU64 Max: %11RU64\n",
    326                         pCur->Stat.cPeriods, pCur->Stat.cTicks, pCur->Stat.cTicksMin,
    327                         pCur->Stat.cPeriods ? pCur->Stat.cTicks / pCur->Stat.cPeriods : 0, pCur->Stat.cTicksMax);
     329                        pHandler->Stat.cPeriods, pHandler->Stat.cTicks, pHandler->Stat.cTicksMin,
     330                        pHandler->Stat.cPeriods ? pHandler->Stat.cTicks / pHandler->Stat.cPeriods : 0, pHandler->Stat.cTicksMax);
    328331#endif
    329332    return 0;

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

    r93650 r93716  
    101101#include <VBox/vmm/mm.h>
    102102#include "PGMInternal.h"
    103 #include <VBox/vmm/vm.h>
     103#include <VBox/vmm/vmcc.h>
    104104#include <VBox/vmm/uvm.h>
    105105#include "PGMInline.h"

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

    r93554 r93716  
    2828#include <VBox/vmm/pdmdev.h>
    2929#include "PGMInternal.h"
    30 #include <VBox/vmm/vm.h>
     30#include <VBox/vmm/vmcc.h>
    3131#include "PGMInline.h"
    3232

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

    r93554 r93716  
    2626#include <VBox/vmm/uvm.h>
    2727#include "PGMInternal.h"
    28 #include <VBox/vmm/vm.h>
     28#include <VBox/vmm/vmcc.h>
    2929#include <VBox/sup.h>
    3030#include <VBox/param.h>
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