VirtualBox

Changeset 56384 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Jun 12, 2015 12:34:31 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
100983
Message:

PGM: Disabled the virtual handler code for !VBOX_WITH_RAW_MODE.

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

Legend:

Unmodified
Added
Removed

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

    r55889 r56384  
    450450
    451451
    452 #if PGM_GST_TYPE == PGM_TYPE_32BIT \
    453  || PGM_GST_TYPE == PGM_TYPE_PAE \
    454  || PGM_GST_TYPE == PGM_TYPE_AMD64
     452#if (   PGM_GST_TYPE == PGM_TYPE_32BIT \
     453     || PGM_GST_TYPE == PGM_TYPE_PAE \
     454     || PGM_GST_TYPE == PGM_TYPE_AMD64) \
     455 && defined(VBOX_WITH_RAW_MODE)
    455456/**
    456457 * Updates one virtual handler range.
    … …  
    608609    return 0;
    609610}
    610 #endif /* 32BIT, PAE and AMD64 */
     611#endif /* 32BIT, PAE and AMD64 + VBOX_WITH_RAW_MODE */
    611612
    612613
    … …  
    622623PGM_GST_DECL(bool, HandlerVirtualUpdate)(PVM pVM, uint32_t cr4)
    623624{
    624 #if PGM_GST_TYPE == PGM_TYPE_32BIT \
    625  || PGM_GST_TYPE == PGM_TYPE_PAE \
    626  || PGM_GST_TYPE == PGM_TYPE_AMD64
     625#if (   PGM_GST_TYPE == PGM_TYPE_32BIT \
     626     || PGM_GST_TYPE == PGM_TYPE_PAE \
     627     || PGM_GST_TYPE == PGM_TYPE_AMD64) \
     628 && defined(VBOX_WITH_RAW_MODE)
    627629
    628630    /** @todo

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

    r55966 r56384  
    13661366
    13671367
     1368#ifdef VBOX_WITH_RAW_MODE
     1369
    13681370/**
    13691371 * Internal worker for releasing a virtual handler type registration reference.
    … …  
    16111613}
    16121614
    1613 #if defined(VBOX_STRICT) || defined(LOG_ENABLED)
     1615# if defined(VBOX_STRICT) || defined(LOG_ENABLED)
    16141616
    16151617/**
    … …  
    16431645}
    16441646
    1645 #endif /* VBOX_STRICT || LOG_ENABLED */
     1647# endif /* VBOX_STRICT || LOG_ENABLED */
     1648#endif /* VBOX_WITH_RAW_MODE */
    16461649#ifdef VBOX_STRICT
    16471650
    … …  
    16641667} PGMAHAFIS, *PPGMAHAFIS;
    16651668
    1666 
    1667 #if 0 /* unused */
     1669# ifdef VBOX_WITH_RAW_MODE
     1670
     1671#  if 0 /* unused */
    16681672/**
    16691673 * Verify virtual handler by matching physical address.
    … …  
    16941698    return 0;
    16951699}
    1696 #endif /* unused */
     1700#  endif /* unused */
    16971701
    16981702
    … …  
    18041808}
    18051809
     1810# endif /* VBOX_WITH_RAW_MODE */
    18061811
    18071812/**
    … …  
    18801885                        }
    18811886
    1882 #ifdef VBOX_WITH_REM
    1883 # ifdef IN_RING3
     1887# ifdef VBOX_WITH_REM
     1888#  ifdef IN_RING3
    18841889                        /* validate that REM is handling it. */
    18851890                        if (    !REMR3IsPageAccessHandled(pVM, State.GCPhys)
    … …  
    18911896                            State.cErrors++;
    18921897                        }
     1898#  endif
    18931899# endif
    1894 #endif
    18951900                    }
    18961901                    else
    … …  
    19071912                {
    19081913                    State.uVirtState = PGM_PAGE_GET_HNDL_VIRT_STATE(pPage);
    1909 #if 1
     1914
    19101915                    /* locate all the matching physical ranges. */
    19111916                    State.uVirtStateFound = PGM_PAGE_HNDL_VIRT_STATE_NONE;
     1917# ifdef VBOX_WITH_RAW_MODE
    19121918                    RTGCPHYS GCPhysKey = State.GCPhys;
    19131919                    for (;;)
    … …  
    19381944                            break;
    19391945                    }
    1940 #else
    1941                     /* very slow */
    1942                     RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, pgmHandlerVirtualVerifyOneByPhysAddr, &State);
    1943 #endif
     1946# endif /* VBOX_WITH_RAW_MODE */
    19441947                    if (State.uVirtState != State.uVirtStateFound)
    19451948                    {
    … …  
    19531956    } /* foreach ram range. */
    19541957
     1958# ifdef VBOX_WITH_RAW_MODE
    19551959    /*
    19561960     * Check that the physical addresses of the virtual handlers matches up
    … …  
    19581962     */
    19591963    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, pgmHandlerVirtualVerifyOne, &State);
     1964# endif
    19601965
    19611966    /*

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

    r56252 r56384  
    673673static DECLCALLBACK(void) pgmR3InfoCr3(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    674674static DECLCALLBACK(int)  pgmR3RelocatePhysHandler(PAVLROGCPHYSNODECORE pNode, void *pvUser);
     675#ifdef VBOX_WITH_RAW_MODE
    675676static DECLCALLBACK(int)  pgmR3RelocateVirtHandler(PAVLROGCPTRNODECORE pNode, void *pvUser);
    676677static DECLCALLBACK(int)  pgmR3RelocateHyperVirtHandler(PAVLROGCPTRNODECORE pNode, void *pvUser);
     678#endif /* VBOX_WITH_RAW_MODE */
    677679#ifdef VBOX_STRICT
    678680static FNVMATSTATE        pgmR3ResetNoMorePhysWritesFlag;
    … …  
    24392441    }
    24402442
     2443#ifdef VBOX_WITH_RAW_MODE
    24412444    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesR3->VirtHandlers,      true, pgmR3RelocateVirtHandler,      &Args);
    24422445    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesR3->HyperVirtHandlers, true, pgmR3RelocateHyperVirtHandler, &Args);
    … …  
    24502453            pCurVirtType->pfnPfHandlerRC += offDelta;
    24512454    }
     2455#endif
    24522456
    24532457    /*
    … …  
    24832487}
    24842488
     2489#ifdef VBOX_WITH_RAW_MODE
    24852490
    24862491/**
    … …  
    25232528}
    25242529
     2530#endif /* VBOX_WITH_RAW_MODE */
    25252531
    25262532/**
    … …  
    40444050    bool                    fLeftToRight;    /**< true: left-to-right; false: right-to-left. */
    40454051    PPGMPHYSHANDLER         pPrevPhys;
     4052#ifdef VBOX_WITH_RAW_MODE
    40464053    PPGMVIRTHANDLER         pPrevVirt;
    40474054    PPGMPHYS2VIRTHANDLER    pPrevPhys2Virt;
     4055#else
     4056    void                   *pvFiller1, *pvFiller2;
     4057#endif
    40484058    PVM                     pVM;
    40494059} PGMCHECKINTARGS, *PPGMCHECKINTARGS;
    … …  
    40754085}
    40764086
     4087#ifdef VBOX_WITH_RAW_MODE
    40774088
    40784089/**
    … …  
    41704181}
    41714182
     4183#endif /* VBOX_WITH_RAW_MODE */
    41724184
    41734185/**
    … …  
    41924204    Args = s_RightToLeft;
    41934205    cErrors += RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers,       false, pgmR3CheckIntegrityPhysHandlerNode, &Args);
     4206#ifdef VBOX_WITH_RAW_MODE
    41944207    Args = s_LeftToRight;
    41954208    cErrors += RTAvlroGCPtrDoWithAll( &pVM->pgm.s.pTreesR3->VirtHandlers,       true,  pgmR3CheckIntegrityVirtHandlerNode, &Args);
    … …  
    42044217    Args = s_RightToLeft;
    42054218    cErrors += RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysToVirtHandlers, false, pgmR3CheckIntegrityPhysToVirtHandlerNode, &Args);
     4219#endif /* VBOX_WITH_RAW_MODE */
    42064220
    42074221    return !cErrors ? VINF_SUCCESS : VERR_INTERNAL_ERROR;

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

    r56054 r56384  
    6161static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PAVLROGCPHYSNODECORE pNode, void *pvUser);
    6262static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PAVLROGCPHYSNODECORE pNode, void *pvUser);
     63#ifdef VBOX_WITH_RAW_MODE
    6364static DECLCALLBACK(int) pgmR3InfoHandlersVirtualOne(PAVLROGCPTRNODECORE pNode, void *pvUser);
     65#endif
    6466
    6567
    … …  
    304306}
    305307
     308#ifdef VBOX_WITH_RAW_MODE
    306309
    307310/**
    … …  
    673676}
    674677
     678#endif /* VBOX_WITH_RAW_MODE */
     679
    675680
    676681/**
    … …  
    728733    }
    729734
     735#ifdef VBOX_WITH_RAW_MODE
    730736    if (fVirtual)
    731737    {
    … …  
    751757        RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesR3->HyperVirtHandlers, true, pgmR3InfoHandlersVirtualOne, &Args);
    752758    }
     759#endif
    753760}
    754761
    … …  
    789796
    790797
     798#ifdef VBOX_WITH_RAW_MODE
    791799/**
    792800 * Displays one virtual handler range.
    … …  
    812820    pHlp->pfnPrintf(pHlp, "%RGv - %RGv  %RHv  %RRv  %s  %s\n",
    813821        pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCurType->pfnPfHandlerRC, pszType, pCur->pszDesc);
    814 #ifdef VBOX_WITH_STATISTICS
     822# ifdef VBOX_WITH_STATISTICS
    815823    if (pArgs->fStats)
    816824        pHlp->pfnPrintf(pHlp, "   cPeriods: %9RU64  cTicks: %11RU64  Min: %11RU64  Avg: %11RU64 Max: %11RU64\n",
    817825                        pCur->Stat.cPeriods, pCur->Stat.cTicks, pCur->Stat.cTicksMin,
    818826                        pCur->Stat.cPeriods ? pCur->Stat.cTicks / pCur->Stat.cPeriods : 0, pCur->Stat.cTicksMax);
    819 #endif
     827# endif
    820828    return 0;
    821829}
    822 
     830#endif /* VBOX_WITH_RAW_MODE */
     831

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

    r55889 r56384  
    11991199
    12001200
     1201#ifdef VBOX_WITH_RAW_MODE
    12011202/**
    12021203 * Clears one physical page of a virtual handler.
    … …  
    12161217     * Remove the node from the tree (it's supposed to be in the tree if we get here!).
    12171218     */
    1218 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
     1219# ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
    12191220    AssertReleaseMsg(pPhys2Virt->offNextAlias & PGMPHYS2VIRTHANDLER_IN_TREE,
    12201221                     ("pPhys2Virt=%p:{.Core.Key=%RGp, .Core.KeyLast=%RGp, .offVirtHandler=%#RX32, .offNextAlias=%#RX32}\n",
    12211222                      pPhys2Virt, pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler, pPhys2Virt->offNextAlias));
    1222 #endif
     1223# endif
    12231224    if (pPhys2Virt->offNextAlias & PGMPHYS2VIRTHANDLER_IS_HEAD)
    12241225    {
    12251226        /* We're the head of the alias chain. */
    12261227        PPGMPHYS2VIRTHANDLER pRemove = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key); NOREF(pRemove);
    1227 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
     1228# ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
    12281229        AssertReleaseMsg(pRemove != NULL,
    12291230                         ("pPhys2Virt=%p:{.Core.Key=%RGp, .Core.KeyLast=%RGp, .offVirtHandler=%#RX32, .offNextAlias=%#RX32}\n",
    … …  
    12341235                          pPhys2Virt, pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler, pPhys2Virt->offNextAlias,
    12351236                          pRemove, pRemove->Core.Key, pRemove->Core.KeyLast, pRemove->offVirtHandler, pRemove->offNextAlias));
    1236 #endif
     1237# endif
    12371238        if (pPhys2Virt->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK)
    12381239        {
    12391240            /* Insert the next list in the alias chain into the tree. */
    12401241            PPGMPHYS2VIRTHANDLER pNext = (PPGMPHYS2VIRTHANDLER)((intptr_t)pPhys2Virt + (pPhys2Virt->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK));
    1241 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
     1242# ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
    12421243            AssertReleaseMsg(pNext->offNextAlias & PGMPHYS2VIRTHANDLER_IN_TREE,
    12431244                             ("pNext=%p:{.Core.Key=%RGp, .Core.KeyLast=%RGp, .offVirtHandler=%#RX32, .offNextAlias=%#RX32}\n",
    12441245                             pNext, pNext->Core.Key, pNext->Core.KeyLast, pNext->offVirtHandler, pNext->offNextAlias));
    1245 #endif
     1246# endif
    12461247            pNext->offNextAlias |= PGMPHYS2VIRTHANDLER_IS_HEAD;
    12471248            bool fRc = RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, &pNext->Core);
    … …  
    12531254        /* Locate the previous node in the alias chain. */
    12541255        PPGMPHYS2VIRTHANDLER pPrev = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key);
    1255 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
     1256# ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
    12561257        AssertReleaseMsg(pPrev != pPhys2Virt,
    12571258                         ("pPhys2Virt=%p:{.Core.Key=%RGp, .Core.KeyLast=%RGp, .offVirtHandler=%#RX32, .offNextAlias=%#RX32} pPrev=%p\n",
    12581259                          pPhys2Virt, pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler, pPhys2Virt->offNextAlias, pPrev));
    1259 #endif
     1260# endif
    12601261        for (;;)
    12611262        {
    … …  
    12801281            if (pNext == pPrev)
    12811282            {
    1282 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
     1283# ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
    12831284                AssertReleaseMsg(pNext != pPrev,
    12841285                                 ("pPhys2Virt=%p:{.Core.Key=%RGp, .Core.KeyLast=%RGp, .offVirtHandler=%#RX32, .offNextAlias=%#RX32} pPrev=%p\n",
    12851286                                  pPhys2Virt, pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler, pPhys2Virt->offNextAlias, pPrev));
    1286 #endif
     1287# endif
    12871288                break;
    12881289            }
    … …  
    13021303    PGM_PAGE_SET_HNDL_VIRT_STATE(pPage, PGM_PAGE_HNDL_VIRT_STATE_NONE);
    13031304}
     1305#endif /* VBOX_WITH_RAW_MODE */
    13041306
    13051307

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

    r56252 r56384  
    665665
    666666
     667#ifdef VBOX_WITH_RAW_MODE
     668
    667669/**
    668670 * Cache node for the physical addresses covered by a virtual handler.
    … …  
    685687/** The bit in PGMPHYS2VIRTHANDLER::offNextAlias used to indicate that the
    686688 * node is in the tree. */
    687 #define PGMPHYS2VIRTHANDLER_IN_TREE     RT_BIT(0)
     689# define PGMPHYS2VIRTHANDLER_IN_TREE     RT_BIT(0)
    688690/** The bit in PGMPHYS2VIRTHANDLER::offNextAlias used to indicate that the
    689691 * node is in the head of an alias chain.
    690692 * The PGMPHYS2VIRTHANDLER_IN_TREE is always set if this bit is set. */
    691 #define PGMPHYS2VIRTHANDLER_IS_HEAD     RT_BIT(1)
     693# define PGMPHYS2VIRTHANDLER_IS_HEAD     RT_BIT(1)
    692694/** The mask to apply to PGMPHYS2VIRTHANDLER::offNextAlias to get the offset. */
    693 #define PGMPHYS2VIRTHANDLER_OFF_MASK    (~(int32_t)3)
     695# define PGMPHYS2VIRTHANDLER_OFF_MASK    (~(int32_t)3)
    694696
    695697
    … …  
    726728typedef PGMVIRTHANDLERTYPEINT *PPGMVIRTHANDLERTYPEINT;
    727729/** Magic value for the virtual handler callbacks (Sir Arthur Charles Clarke). */
    728 #define PGMVIRTHANDLERTYPEINT_MAGIC        UINT32_C(0x19171216)
     730# define PGMVIRTHANDLERTYPEINT_MAGIC       UINT32_C(0x19171216)
    729731/** Magic value for the virtual handler callbacks. */
    730 #define PGMVIRTHANDLERTYPEINT_MAGIC_DEAD   UINT32_C(0x20080319)
     732# define PGMVIRTHANDLERTYPEINT_MAGIC_DEAD  UINT32_C(0x20080319)
    731733
    732734/**
    … …  
    736738 * @param   a_hType         Vitual access handler type handle.
    737739 */
    738 #define PGMVIRTHANDLERTYPEINT_FROM_HANDLE(a_pVM, a_hType) ((PPGMVIRTHANDLERTYPEINT)MMHyperHeapOffsetToPtr(a_pVM, a_hType))
     740# define PGMVIRTHANDLERTYPEINT_FROM_HANDLE(a_pVM, a_hType) ((PPGMVIRTHANDLERTYPEINT)MMHyperHeapOffsetToPtr(a_pVM, a_hType))
    739741
    740742
    … …  
    761763    /** Description / Name. For easing debugging. */
    762764    R3PTRTYPE(const char *)             pszDesc;
    763 #ifdef VBOX_WITH_STATISTICS
     765# ifdef VBOX_WITH_STATISTICS
    764766    /** Profiling of this handler. */
    765767    STAMPROFILE                         Stat;
    766 #endif
     768# endif
    767769    /** Array of cached physical addresses for the monitored ranged. */
    768770    PGMPHYS2VIRTHANDLER                 aPhysToVirt[HC_ARCH_BITS == 32 ? 1 : 2];
    … …  
    778780 *                          (PGMVIRTHANDLER).
    779781 */
    780 #define PGMVIRTANDLER_GET_TYPE(a_pVM, a_pVirtHandler) PGMVIRTHANDLERTYPEINT_FROM_HANDLE(a_pVM, (a_pVirtHandler)->hType)
     782# define PGMVIRTANDLER_GET_TYPE(a_pVM, a_pVirtHandler) PGMVIRTHANDLERTYPEINT_FROM_HANDLE(a_pVM, (a_pVirtHandler)->hType)
     783
     784#endif /* VBOX_WITH_RAW_MODE */
    781785
    782786
    … …  
    27102714typedef struct PGMTREES
    27112715{
     2716    /** List of physical access handler types (offset pointers) of type
     2717     * PGMPHYSHANDLERTYPEINT.  This is needed for relocations. */
     2718    RTLISTOFF32ANCHOR               HeadPhysHandlerTypes;
    27122719    /** Physical access handlers (AVL range+offsetptr tree). */
    27132720    AVLROGCPHYSTREE                 PhysHandlers;
     2721#ifdef VBOX_WITH_RAW_MODE
    27142722    /** Virtual access handlers (AVL range + GC ptr tree). */
    27152723    AVLROGCPTRTREE                  VirtHandlers;
    … …  
    27192727    /** Virtual access handlers for the hypervisor (AVL range + GC ptr tree). */
    27202728    AVLROGCPTRTREE                  HyperVirtHandlers;
    2721     /** List of physical access handler types (offset pointers) of type
    2722      * PGMPHYSHANDLERTYPEINT.  This is needed for relocations. */
    2723     RTLISTOFF32ANCHOR               HeadPhysHandlerTypes;
    27242729    /** List of virtual access handler types (offset pointers) of type
    27252730     * PGMVIRTHANDLERTYPEINT.  This is needed for relocations. */
    27262731    RTLISTOFF32ANCHOR               HeadVirtHandlerTypes;
     2732#endif
    27272733} PGMTREES;
    27282734/** Pointer to PGM trees. */
    … …  
    41284134bool            pgmHandlerPhysicalIsAll(PVM pVM, RTGCPHYS GCPhys);
    41294135void            pgmHandlerPhysicalResetAliasedPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhysPage, bool fDoAccounting);
     4136#ifdef VBOX_WITH_RAW_MODE
    41304137PPGMVIRTHANDLER pgmHandlerVirtualFindByPhysAddr(PVM pVM, RTGCPHYS GCPhys, unsigned *piPage);
    41314138DECLCALLBACK(int) pgmHandlerVirtualResetOne(PAVLROGCPTRNODECORE pNode, void *pvUser);
    4132 #if defined(VBOX_STRICT) || defined(LOG_ENABLED)
     4139# if defined(VBOX_STRICT) || defined(LOG_ENABLED)
    41334140void            pgmHandlerVirtualDumpPhysPages(PVM pVM);
    4134 #else
    4135 # define pgmHandlerVirtualDumpPhysPages(a) do { } while (0)
    4136 #endif
     4141# else
     4142#  define pgmHandlerVirtualDumpPhysPages(a) do { } while (0)
     4143# endif
     4144#endif /* VBOX_WITH_RAW_MODE */
    41374145DECLCALLBACK(void) pgmR3InfoHandlers(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    41384146int             pgmR3InitSavedState(PVM pVM, uint64_t cbRam);

  • trunk/src/VBox/VMM/testcase/tstVMStruct.h

    r56052 r56384  
    860860    GEN_CHECK_SIZE(PGMTREES);
    861861    GEN_CHECK_OFF(PGMTREES, PhysHandlers);
     862    GEN_CHECK_OFF(PGMTREES, HeadPhysHandlerTypes);
     863#ifdef VBOX_WITH_RAW_MODE
    862864    GEN_CHECK_OFF(PGMTREES, VirtHandlers);
    863865    GEN_CHECK_OFF(PGMTREES, PhysToVirtHandlers);
    864866    GEN_CHECK_OFF(PGMTREES, HyperVirtHandlers);
     867    GEN_CHECK_OFF(PGMTREES, HeadVirtHandlerTypes);
     868#endif
    865869    GEN_CHECK_SIZE(PGMPOOLPAGE);
    866870    GEN_CHECK_OFF(PGMPOOLPAGE, Core);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette