VirtualBox

Changeset 6913 in vbox


Ignore:
Timestamp:
Feb 11, 2008 11:02:51 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
28064
Message:

Separated the PGMVIRTHANDLERTYPE_HYPERVISOR kind of handlers from the others since to simplify the code a bit.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/pgm.h

    r6912 r6913  
    186186     * system structure which the brain dead intel guys let unprivilegde code find. */
    187187    PGMVIRTHANDLERTYPE_HYPERVISOR
    188 
    189188} PGMVIRTHANDLERTYPE;
    190189

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

    r6902 r6913  
    521521static DECLCALLBACK(int) pgmR3RelocatePhysHandler(PAVLROGCPHYSNODECORE pNode, void *pvUser);
    522522static DECLCALLBACK(int) pgmR3RelocateVirtHandler(PAVLROGCPTRNODECORE pNode, void *pvUser);
     523static DECLCALLBACK(int) pgmR3RelocateHyperVirtHandler(PAVLROGCPTRNODECORE pNode, void *pvUser);
    523524#ifdef VBOX_STRICT
    524525static DECLCALLBACK(void) pgmR3ResetNoMorePhysWritesFlag(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
    … …  
    939940                                   pgmR3PhysInfo);
    940941        DBGFR3InfoRegisterInternal(pVM, "handlers",
    941                                    "Dumps physical and virtual handlers. "
    942                                    "Pass 'phys' or 'virt' as argument if only one kind is wanted.",
     942                                   "Dumps physical, virtual and hyper virtual handlers. "
     943                                   "Pass 'phys', 'virt', 'hyper' as argument if only one kind is wanted. "
     944                                   "Add 'nost' if the statistics are unwanted.",
    943945                                   pgmR3InfoHandlers);
    944946
    … …  
    15991601    RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesHC->PhysHandlers, true, pgmR3RelocatePhysHandler, &offDelta);
    16001602    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesHC->VirtHandlers, true, pgmR3RelocateVirtHandler, &offDelta);
     1603    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesHC->HyperVirtHandlers, true, pgmR3RelocateHyperVirtHandler, &offDelta);
    16011604
    16021605    /*
    … …  
    16391642    PPGMVIRTHANDLER pHandler = (PPGMVIRTHANDLER)pNode;
    16401643    RTGCINTPTR      offDelta = *(PRTGCINTPTR)pvUser;
     1644    Assert(     pHandler->enmType == PGMVIRTHANDLERTYPE_ALL
     1645           ||   pHandler->enmType == PGMVIRTHANDLERTYPE_WRITE);
     1646    Assert(pHandler->pfnHandlerGC);
     1647    pHandler->pfnHandlerGC  += offDelta;
     1648    return 0;
     1649}
     1650
     1651
     1652/**
     1653 * Callback function for relocating a virtual access handler for the hypervisor mapping.
     1654 *
     1655 * @returns 0 (continue enum)
     1656 * @param   pNode       Pointer to a PGMVIRTHANDLER node.
     1657 * @param   pvUser      Pointer to the offDelta. This is a pointer to the delta since we're
     1658 *                      not certain the delta will fit in a void pointer for all possible configs.
     1659 */
     1660static DECLCALLBACK(int) pgmR3RelocateHyperVirtHandler(PAVLROGCPTRNODECORE pNode, void *pvUser)
     1661{
     1662    PPGMVIRTHANDLER pHandler = (PPGMVIRTHANDLER)pNode;
     1663    RTGCINTPTR      offDelta = *(PRTGCINTPTR)pvUser;
     1664    Assert(pHandler->enmType == PGMVIRTHANDLERTYPE_HYPERVISOR);
    16411665    Assert(pHandler->pfnHandlerGC);
    16421666    pHandler->pfnHandlerGC  += offDelta;
    … …  
    38343858    cErrors += RTAvlroGCPtrDoWithAll( &pVM->pgm.s.pTreesHC->VirtHandlers,       false, pgmR3CheckIntegrityVirtHandlerNode, &Args);
    38353859    Args.fLeftToRight = true;
     3860    cErrors += RTAvlroGCPtrDoWithAll( &pVM->pgm.s.pTreesHC->HyperVirtHandlers,  true,  pgmR3CheckIntegrityVirtHandlerNode, &Args);
     3861    Args.fLeftToRight = false;
     3862    cErrors += RTAvlroGCPtrDoWithAll( &pVM->pgm.s.pTreesHC->HyperVirtHandlers,  false, pgmR3CheckIntegrityVirtHandlerNode, &Args);
     3863    Args.fLeftToRight = true;
    38363864    cErrors += RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesHC->PhysToVirtHandlers, true,  pgmR3CheckIntegrityPhysToVirtHandlerNode, &Args);
    38373865    Args.fLeftToRight = false;

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

    r6912 r6913  
    268268 * @param   pfnHandlerGC    The GC handler.
    269269 * @param   pszDesc         Pointer to description string. This must not be freed.
     270 * @thread  EMT
    270271 */
    271272/** @todo rename this to PGMR3HandlerVirtualRegisterEx. */
     273/** @todo create a template for virtual handlers (see async i/o), we're wasting space
     274 * duplicating the function pointers now. (Or we will once we add the missing callbacks.) */
    272275PGMDECL(int) PGMHandlerVirtualRegisterEx(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
    273276                                         PFNPGMHCVIRTINVALIDATE pfnInvalidateHC,
    … …  
    349352     * the same range this makes everything much simpler and faster.
    350353     */
     354    AVLROGCPTRTREE *pRoot = enmType != PGMVIRTHANDLERTYPE_HYPERVISOR
     355                          ? &pVM->pgm.s.CTXSUFF(pTrees)->VirtHandlers
     356                          : &pVM->pgm.s.CTXSUFF(pTrees)->HyperVirtHandlers;
    351357    pgmLock(pVM);
    352     if (pVM->pgm.s.pTreesHC->VirtHandlers != 0)
    353     {
    354         PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGetBestFit(&pVM->pgm.s.CTXSUFF(pTrees)->VirtHandlers, pNew->Core.Key, true);
    355         if (!pCur || GCPtr > pCur->GCPtrLast || GCPtrLast < pCur->GCPtr)
    356             pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGetBestFit(&pVM->pgm.s.CTXSUFF(pTrees)->VirtHandlers, pNew->Core.Key, false);
    357         if (pCur && GCPtr <= pCur->GCPtrLast && GCPtrLast >= pCur->GCPtr)
     358    if (*pRoot != 0)
     359    {
     360        PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGetBestFit(pRoot, pNew->Core.Key, true);
     361        if (    !pCur
     362            ||  GCPtr     > pCur->GCPtrLast
     363            ||  GCPtrLast < pCur->GCPtr)
     364            pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGetBestFit(pRoot, pNew->Core.Key, false);
     365        if (    pCur
     366            &&  GCPtr     <= pCur->GCPtrLast
     367            &&  GCPtrLast >= pCur->GCPtr)
    358368        {
    359369            /*
    … …  
    368378        }
    369379    }
    370     if (RTAvlroGCPtrInsert(&pVM->pgm.s.CTXSUFF(pTrees)->VirtHandlers, &pNew->Core))
     380    if (RTAvlroGCPtrInsert(pRoot, &pNew->Core))
    371381    {
    372382        if (enmType != PGMVIRTHANDLERTYPE_HYPERVISOR)
    … …  
    386396        return VINF_SUCCESS;
    387397    }
     398
    388399    pgmUnlock(pVM);
    389400    AssertFailed();
    … …  
    394405
    395406/**
    396  * Modify the page invalidation callback handler for a registered virtual range
     407 * Modify the page invalidation callback handler for a registered virtual range.
    397408 * (add more when needed)
    398409 *
    … …  
    401412 * @param   GCPtr           Start address.
    402413 * @param   pfnInvalidateHC The HC invalidate callback (can be 0)
     414 * @remarks Doesn't work with the hypervisor access handler type.
    403415 */
    404416PGMDECL(int) PGMHandlerVirtualChangeInvalidateCallback(PVM pVM, RTGCPTR GCPtr, PFNPGMHCVIRTINVALIDATE pfnInvalidateHC)
    … …  
    424436 * @param   pVM         VM handle.
    425437 * @param   GCPtr       Start address.
     438 * @thread  EMT
    426439 */
    427440PGMDECL(int) PGMHandlerVirtualDeregister(PVM pVM, RTGCPTR GCPtr)
    428441{
     442    pgmLock(pVM);
     443
    429444    /*
    430445     * Find the handler.
    431446     * We naturally assume GCPtr is a unique specification.
    432447     */
    433     pgmLock(pVM);
    434448    PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRemove(&pVM->pgm.s.CTXSUFF(pTrees)->VirtHandlers, GCPtr);
    435     if (pCur)
    436     {
    437         Log(("PGMR3HandlerVirtualDeregister: Removing Virtual (%d) Range %#x-%#x %s\n", pCur->enmType,
     449    if (RT_LIKELY(pCur))
     450    {
     451        Log(("PGMHandlerVirtualDeregister: Removing Virtual (%d) Range %#x-%#x %s\n", pCur->enmType,
    438452             pCur->GCPtr, pCur->GCPtrLast, pCur->pszDesc));
     453        Assert(pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR);
    439454
    440455        /*
    … …  
    447462
    448463        /*
    449          * Schedule CR3 sync (if required) and the memory.
     464         * Schedule CR3 sync.
    450465         */
    451         STAM_DEREG(pVM, &pCur->Stat);
    452         if (pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR)
     466        pVM->pgm.s.fSyncFlags |= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL | PGM_SYNC_CLEAR_PGM_POOL;
     467        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
     468    }
     469    else
     470    {
     471        /* must be a hypervisor one then. */
     472        pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRemove(&pVM->pgm.s.CTXSUFF(pTrees)->HyperVirtHandlers, GCPtr);
     473        if (RT_UNLIKELY(!pCur))
    453474        {
    454             pVM->pgm.s.fSyncFlags |= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL | PGM_SYNC_CLEAR_PGM_POOL;
    455             VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
     475            pgmUnlock(pVM);
     476            AssertMsgFailed(("Range %#x not found!\n", GCPtr));
     477            return VERR_INVALID_PARAMETER;
    456478        }
    457         MMHyperFree(pVM, pCur);
    458         pgmUnlock(pVM);
    459         return VINF_SUCCESS;
    460     }
     479
     480        Log(("PGMHandlerVirtualDeregister: Removing Hyper Virtual (%d) Range %#x-%#x %s\n", pCur->enmType,
     481             pCur->GCPtr, pCur->GCPtrLast, pCur->pszDesc));
     482        Assert(pCur->enmType == PGMVIRTHANDLERTYPE_HYPERVISOR);
     483    }
     484
    461485    pgmUnlock(pVM);
    462     AssertMsgFailed(("Range %#x not found!\n", GCPtr));
    463     return VERR_INVALID_PARAMETER;
     486   
     487    STAM_DEREG(pVM, &pCur->Stat);
     488    MMHyperFree(pVM, pCur);
     489
     490    return VINF_SUCCESS;
    464491}
    465492
    … …  
    491518    bool fPhysical = !pszArgs  || !*pszArgs;
    492519    bool fVirtual = fPhysical;
     520    bool fHyper = fPhysical;
    493521    if (!fPhysical)
    494522    {
    495523        fPhysical = strstr(pszArgs, "phys") != NULL;
    496524        fVirtual = strstr(pszArgs, "virt") != NULL;
     525        fHyper = strstr(pszArgs, "hyper") != NULL;
    497526        Args.fStats = strstr(pszArgs, "nost") == NULL;
    498527    }
    … …  
    516545            "From     - To (excl) HandlerHC HandlerGC Type     Description\n");
    517546        RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesHC->VirtHandlers, true, pgmR3InfoHandlersVirtualOne, &Args);
     547    }
     548
     549    if (fHyper)
     550    {
     551        pHlp->pfnPrintf(pHlp,
     552            "Hypervisor Virtual handlers:\n"
     553            "From     - To (excl) HandlerHC HandlerGC Type     Description\n");
     554        RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesHC->HyperVirtHandlers, true, pgmR3InfoHandlersVirtualOne, &Args);
    518555    }
    519556}
    … …  
    568605    switch (pCur->enmType)
    569606    {
    570         case PGMVIRTHANDLERTYPE_WRITE:  pszType = "Write  "; break;
    571         case PGMVIRTHANDLERTYPE_ALL:    pszType = "All    "; break;
     607        case PGMVIRTHANDLERTYPE_WRITE:      pszType = "Write  "; break;
     608        case PGMVIRTHANDLERTYPE_ALL:        pszType = "All    "; break;
    572609        case PGMVIRTHANDLERTYPE_HYPERVISOR: pszType = "WriteHyp "; break;
    573         default:                        pszType = "????"; break;
     610        default:                            pszType = "????"; break;
    574611    }
    575612    pHlp->pfnPrintf(pHlp, "%08x - %08x  %08x  %08x  %s  %s\n",

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

    r6906 r6913  
    15621562    /** Virtual access handlers (Phys range AVL range + offsetptr tree). */
    15631563    AVLROGCPHYSTREE                 PhysToVirtHandlers;
    1564     uint32_t auPadding[1];
     1564    /** Virtual access handlers for the hypervisor (AVL range + GC ptr tree). */
     1565    AVLROGCPTRTREE                  HyperVirtHandlers;
    15651566} PGMTREES;
    15661567/** Pointer to PGM trees. */

  • trunk/src/VBox/VMM/PGMMap.cpp

    r6912 r6913  
    10931093            RTLogPrintf("WRITE    %RGv-%RGv size %RGv %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->cb, pCur->pszDesc);
    10941094            break;
     1095        case PGMVIRTHANDLERTYPE_ALL:
     1096            RTLogPrintf("ALL      %RGv-%RGv size %RGv %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->cb, pCur->pszDesc);
     1097            break;
    10951098        case PGMVIRTHANDLERTYPE_HYPERVISOR:
    10961099            RTLogPrintf("WRITEHYP %RGv-%RGv size %RGv %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->cb, pCur->pszDesc);
    1097             break;
    1098         case PGMVIRTHANDLERTYPE_ALL:
    1099             RTLogPrintf("ALL      %RGv-%RGv size %RGv %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->cb, pCur->pszDesc);
    11001100            break;
    11011101    }
    … …  
    11241124        RTLogPrintf("%VGv - %VGv  %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->pszDesc);
    11251125
    1126 /** @todo The handler stuff is totally alien here. This should be converted into a 'info' function. */
     1126/** @todo The handler stuff is totally alien here. This should be converted into a 'info' function.
     1127 * There are now, just kill this. */
    11271128    RTLogPrintf("\nVirtual handlers:\n");
    11281129    RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesHC->VirtHandlers, true, pgmVirtHandlerDump, pVM);

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

    r6911 r6913  
    197197                 * Check if the fault address is in a virtual page access handler range.
    198198                 */
    199                 PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRangeGet(&CTXSUFF(pVM->pgm.s.pTrees)->VirtHandlers, pvFault);
     199                PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRangeGet(&CTXSUFF(pVM->pgm.s.pTrees)->HyperVirtHandlers, pvFault);
    200200                if (    pCur
    201201                    &&  (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr < pCur->cb
    202                     &&  (    uErr & X86_TRAP_PF_RW
    203                          ||  (   pCur->enmType != PGMVIRTHANDLERTYPE_WRITE
    204                               && pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR) ) ) /** r=bird: <- this is probably wrong. */
     202                    &&  uErr & X86_TRAP_PF_RW)
    205203                {
    206204#  ifdef IN_GC
    … …  
    384382                            if (    (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr < pCur->cb
    385383                                &&  (    uErr & X86_TRAP_PF_RW
    386                                      ||  (   pCur->enmType != PGMVIRTHANDLERTYPE_WRITE
    387                                           && pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR) ) ) /** @todo r=bird: _HYPERVISOR is impossible here because of mapping check. */
     384                                     ||  pCur->enmType != PGMVIRTHANDLERTYPE_WRITE ) )
    388385                            {
    389386#  ifdef IN_GC
    … …  
    411408                            if (    pCur
    412409                                &&  (   uErr & X86_TRAP_PF_RW
    413                                     ||  (   pCur->enmType != PGMVIRTHANDLERTYPE_WRITE
    414                                         &&  pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR) ) )
     410                                     || pCur->enmType != PGMVIRTHANDLERTYPE_WRITE ) )
    415411                            {
    416412                                Assert((pCur->aPhysToVirt[iPage].Core.Key & X86_PTE_PAE_PG_MASK) == GCPhys);
    … …  
    494490                        if (    (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr < pCur->cb
    495491                            &&  (    uErr & X86_TRAP_PF_RW
    496                                  ||  (   pCur->enmType != PGMVIRTHANDLERTYPE_WRITE
    497                                       && pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR) ) ) /** @todo r=bird: _HYPERVISOR is impossible here because of mapping check. */
     492                                 ||  pCur->enmType != PGMVIRTHANDLERTYPE_WRITE ) )
    498493                        {
    499494#  ifdef IN_GC

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

    r6912 r6913  
    644644    PPGMVIRTHANDLER pCur  = (PPGMVIRTHANDLER)pNode;
    645645    PPGMHVUSTATE    pState = (PPGMHVUSTATE)pvUser;
     646    Assert(pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR);
    646647
    647648#if PGM_GST_TYPE == PGM_TYPE_32BIT

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

    r6912 r6913  
    11001100     * Calc flags.
    11011101     */
     1102    Assert(pCur->enmType != PGMVIRTHANDLERTYPE_HYPERVISOR);
    11021103    unsigned        fFlags;
    11031104    switch (pCur->enmType)

  • trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

    r6854 r6913  
    566566    GEN_CHECK_OFF(PGMTREES, VirtHandlers);
    567567    GEN_CHECK_OFF(PGMTREES, PhysToVirtHandlers);
    568     GEN_CHECK_OFF(PGMTREES, auPadding);
     568    GEN_CHECK_OFF(PGMTREES, HyperVirtHandlers);
    569569    GEN_CHECK_SIZE(PGMPOOLPAGE);
    570570    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