VirtualBox

Changeset 20874 in vbox for trunk


Ignore:
Timestamp:
Jun 24, 2009 2:19:29 AM (16 years ago)
Author:
vboxsync
Message:

VMMR0CallHost -> VMMRZCallRing3[NoCpu]; VMMCALLHOST -> VMMCALLRING3.

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/pdmcritsect.h

    r20753 r20874  
    5858VMMDECL(int)        PDMCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy);
    5959VMMDECL(int)        PDMCritSectTryEnter(PPDMCRITSECT pCritSect);
    60 VMMR3DECL(int)      PDMR3CritSectEnterEx(PPDMCRITSECT pCritSect, bool fCallHost);
     60VMMR3DECL(int)      PDMR3CritSectEnterEx(PPDMCRITSECT pCritSect, bool fCallRing3);
    6161VMMDECL(void)       PDMCritSectLeave(PPDMCRITSECT pCritSect);
    6262VMMDECL(bool)       PDMCritSectIsOwner(PCPDMCRITSECT pCritSect);

  • trunk/include/VBox/vmm.h

    r20873 r20874  
    7777
    7878/**
    79  * VMMGCCallHost operations.
    80  */
    81 typedef enum VMMCALLHOST
     79 * VMMRZCallRing3 operations.
     80 */
     81typedef enum VMMCALLRING3
    8282{
    8383    /** Invalid operation.  */
    84     VMMCALLHOST_INVALID = 0,
     84    VMMCALLRING3_INVALID = 0,
    8585    /** Acquire the PDM lock. */
    86     VMMCALLHOST_PDM_LOCK,
     86    VMMCALLRING3_PDM_LOCK,
    8787    /** Call PDMR3QueueFlushWorker. */
    88     VMMCALLHOST_PDM_QUEUE_FLUSH,
     88    VMMCALLRING3_PDM_QUEUE_FLUSH,
    8989    /** Acquire the PGM lock. */
    90     VMMCALLHOST_PGM_LOCK,
     90    VMMCALLRING3_PGM_LOCK,
    9191    /** Grow the PGM shadow page pool. */
    92     VMMCALLHOST_PGM_POOL_GROW,
     92    VMMCALLRING3_PGM_POOL_GROW,
    9393    /** Maps a chunk into ring-3. */
    94     VMMCALLHOST_PGM_MAP_CHUNK,
     94    VMMCALLRING3_PGM_MAP_CHUNK,
    9595    /** Allocates more handy pages. */
    96     VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES,
     96    VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES,
    9797    /** Acquire the MM hypervisor heap lock. */
    98     VMMCALLHOST_MMHYPER_LOCK,
     98    VMMCALLRING3_MMHYPER_LOCK,
    9999    /** Replay the REM handler notifications. */
    100     VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS,
     100    VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS,
    101101    /** Flush the GC/R0 logger. */
    102     VMMCALLHOST_VMM_LOGGER_FLUSH,
     102    VMMCALLRING3_VMM_LOGGER_FLUSH,
    103103    /** Set the VM error message. */
    104     VMMCALLHOST_VM_SET_ERROR,
     104    VMMCALLRING3_VM_SET_ERROR,
    105105    /** Set the VM runtime error message. */
    106     VMMCALLHOST_VM_SET_RUNTIME_ERROR,
     106    VMMCALLRING3_VM_SET_RUNTIME_ERROR,
    107107    /** Signal a ring 0 assertion. */
    108     VMMCALLHOST_VM_R0_ASSERTION,
     108    VMMCALLRING3_VM_R0_ASSERTION,
    109109    /** Ring switch to force preemption. */
    110     VMMCALLHOST_VM_R0_PREEMPT,
     110    VMMCALLRING3_VM_R0_PREEMPT,
    111111    /** The usual 32-bit hack. */
    112     VMMCALLHOST_32BIT_HACK = 0x7fffffff
    113 } VMMCALLHOST;
     112    VMMCALLRING3_32BIT_HACK = 0x7fffffff
     113} VMMCALLRING3;
    114114
    115115/**
    … …  
    351351VMMR0DECL(int)      VMMR0EntryEx(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION);
    352352VMMR0DECL(int)      VMMR0TermVM(PVM pVM, PGVM pGVM);
    353 VMMR0DECL(int)      VMMR0CallHost(PVM pVM, VMMCALLHOST enmOperation, uint64_t uArg);
    354353
    355354#ifdef LOG_ENABLED
    … …  
    380379 * @{
    381380 */
    382 VMMRZDECL(int)      VMMRZCallRing3(PVM pVM, PVMCPU pVCpu, VMMCALLHOST enmOperation, uint64_t uArg);
    383 VMMRZDECL(int)      VMMRZCallRing3NoCpu(PVM pVM, VMMCALLHOST enmOperation, uint64_t uArg);
     381VMMRZDECL(int)      VMMRZCallRing3(PVM pVM, PVMCPU pVCpu, VMMCALLRING3 enmOperation, uint64_t uArg);
     382VMMRZDECL(int)      VMMRZCallRing3NoCpu(PVM pVM, VMMCALLRING3 enmOperation, uint64_t uArg);
    384383VMMRZDECL(void)     VMMRZCallRing3Disable(PVMCPU pVCpu);
    385384VMMRZDECL(void)     VMMRZCallRing3Enable(PVMCPU pVCpu);

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

    r20868 r20874  
    344344
    345345/**
    346  * Service a VMMCALLHOST_MMHYPER_LOCK call.
     346 * Service a VMMCALLRING3_MMHYPER_LOCK call.
    347347 *
    348348 * @returns VBox status code.

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

    r20838 r20874  
    13801380
    13811381/**
    1382  * Service a VMMCALLHOST_PDM_LOCK call.
     1382 * Service a VMMCALLRING3_PDM_LOCK call.
    13831383 *
    13841384 * @returns VBox status code.

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

    r20864 r20874  
    31973197
    31983198/**
    3199  * Service a VMMCALLHOST_PGM_LOCK call.
     3199 * Service a VMMCALLRING3_PGM_LOCK call.
    32003200 *
    32013201 * @returns VBox status code.

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

    r20864 r20874  
    29842984
    29852985/**
    2986  * For VMMCALLHOST_PGM_MAP_CHUNK, considered internal.
     2986 * For VMMCALLRING3_PGM_MAP_CHUNK, considered internal.
    29872987 *
    29882988 * @returns see pgmR3PhysChunkMap.
    … …  
    30203020
    30213021/**
    3022  * Response to VM_FF_PGM_NEED_HANDY_PAGES and VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES.
     3022 * Response to VM_FF_PGM_NEED_HANDY_PAGES and VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES.
    30233023 *
    30243024 * This function will also work the VM_FF_PGM_NO_MEMORY force action flag, to

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

    r20869 r20874  
    386386
    387387    STAM_REG(pVM, &pVM->vmm.s.StatRZRetCallHost,            STAMTYPE_COUNTER, "/VMM/RZCallR3/Misc",             STAMUNIT_OCCURENCES, "Number of Other ring-3 calls.");
    388     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPDMLock,            STAMTYPE_COUNTER, "/VMM/RZCallR3/PDMLock",          STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_PDM_LOCK calls.");
    389     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPDMQueueFlush,      STAMTYPE_COUNTER, "/VMM/RZCallR3/PDMQueueFlush",    STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_PDM_QUEUE_FLUSH calls.");
    390     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMLock,            STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMLock",          STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_PGM_LOCK calls.");
    391     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMPoolGrow,        STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMPoolGrow",      STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_PGM_POOL_GROW calls.");
    392     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMMapChunk,        STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMMapChunk",      STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_PGM_MAP_CHUNK calls.");
    393     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMAllocHandy,      STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMAllocHandy",    STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES calls.");
    394     STAM_REG(pVM, &pVM->vmm.s.StatRZCallRemReplay,          STAMTYPE_COUNTER, "/VMM/RZCallR3/REMReplay",        STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS calls.");
    395     STAM_REG(pVM, &pVM->vmm.s.StatRZCallLogFlush,           STAMTYPE_COUNTER, "/VMM/RZCallR3/VMMLogFlush",      STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_VMM_LOGGER_FLUSH calls.");
    396     STAM_REG(pVM, &pVM->vmm.s.StatRZCallVMSetError,         STAMTYPE_COUNTER, "/VMM/RZCallR3/VMSetError",       STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_VM_SET_ERROR calls.");
    397     STAM_REG(pVM, &pVM->vmm.s.StatRZCallVMSetRuntimeError,  STAMTYPE_COUNTER, "/VMM/RZCallR3/VMRuntimeError",   STAMUNIT_OCCURENCES, "Number of VMMCALLHOST_VM_SET_RUNTIME_ERROR calls.");
     388    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPDMLock,            STAMTYPE_COUNTER, "/VMM/RZCallR3/PDMLock",          STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PDM_LOCK calls.");
     389    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPDMQueueFlush,      STAMTYPE_COUNTER, "/VMM/RZCallR3/PDMQueueFlush",    STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PDM_QUEUE_FLUSH calls.");
     390    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMLock,            STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMLock",          STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PGM_LOCK calls.");
     391    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMPoolGrow,        STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMPoolGrow",      STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PGM_POOL_GROW calls.");
     392    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMMapChunk,        STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMMapChunk",      STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PGM_MAP_CHUNK calls.");
     393    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMAllocHandy,      STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMAllocHandy",    STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES calls.");
     394    STAM_REG(pVM, &pVM->vmm.s.StatRZCallRemReplay,          STAMTYPE_COUNTER, "/VMM/RZCallR3/REMReplay",        STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS calls.");
     395    STAM_REG(pVM, &pVM->vmm.s.StatRZCallLogFlush,           STAMTYPE_COUNTER, "/VMM/RZCallR3/VMMLogFlush",      STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_VMM_LOGGER_FLUSH calls.");
     396    STAM_REG(pVM, &pVM->vmm.s.StatRZCallVMSetError,         STAMTYPE_COUNTER, "/VMM/RZCallR3/VMSetError",       STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_VM_SET_ERROR calls.");
     397    STAM_REG(pVM, &pVM->vmm.s.StatRZCallVMSetRuntimeError,  STAMTYPE_COUNTER, "/VMM/RZCallR3/VMRuntimeError",   STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_VM_SET_RUNTIME_ERROR calls.");
    398398
    399399#ifdef VBOX_WITH_STATISTICS
    … …  
    18621862         * Acquire the PDM lock.
    18631863         */
    1864         case VMMCALLHOST_PDM_LOCK:
     1864        case VMMCALLRING3_PDM_LOCK:
    18651865        {
    18661866            pVCpu->vmm.s.rcCallHost = PDMR3LockCall(pVM);
    … …  
    18711871         * Flush a PDM queue.
    18721872         */
    1873         case VMMCALLHOST_PDM_QUEUE_FLUSH:
     1873        case VMMCALLRING3_PDM_QUEUE_FLUSH:
    18741874        {
    18751875            PDMR3QueueFlushWorker(pVM, NULL);
    … …  
    18811881         * Grow the PGM pool.
    18821882         */
    1883         case VMMCALLHOST_PGM_POOL_GROW:
     1883        case VMMCALLRING3_PGM_POOL_GROW:
    18841884        {
    18851885            pVCpu->vmm.s.rcCallHost = PGMR3PoolGrow(pVM);
    … …  
    18901890         * Maps an page allocation chunk into ring-3 so ring-0 can use it.
    18911891         */
    1892         case VMMCALLHOST_PGM_MAP_CHUNK:
     1892        case VMMCALLRING3_PGM_MAP_CHUNK:
    18931893        {
    18941894            pVCpu->vmm.s.rcCallHost = PGMR3PhysChunkMap(pVM, pVCpu->vmm.s.u64CallHostArg);
    … …  
    18991899         * Allocates more handy pages.
    19001900         */
    1901         case VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES:
     1901        case VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES:
    19021902        {
    19031903            pVCpu->vmm.s.rcCallHost = PGMR3PhysAllocateHandyPages(pVM);
    … …  
    19081908         * Acquire the PGM lock.
    19091909         */
    1910         case VMMCALLHOST_PGM_LOCK:
     1910        case VMMCALLRING3_PGM_LOCK:
    19111911        {
    19121912            pVCpu->vmm.s.rcCallHost = PGMR3LockCall(pVM);
    … …  
    19171917         * Acquire the MM hypervisor heap lock.
    19181918         */
    1919         case VMMCALLHOST_MMHYPER_LOCK:
     1919        case VMMCALLRING3_MMHYPER_LOCK:
    19201920        {
    19211921            pVCpu->vmm.s.rcCallHost = MMR3LockCall(pVM);
    … …  
    19261926         * Flush REM handler notifications.
    19271927         */
    1928         case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
     1928        case VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS:
    19291929        {
    19301930            REMR3ReplayHandlerNotifications(pVM);
    … …  
    19371937         * tests in the loops.
    19381938         */
    1939         case VMMCALLHOST_VMM_LOGGER_FLUSH:
     1939        case VMMCALLRING3_VMM_LOGGER_FLUSH:
    19401940            pVCpu->vmm.s.rcCallHost = VINF_SUCCESS;
    19411941            LogAlways(("*FLUSH*\n"));
    … …  
    19451945         * Set the VM error message.
    19461946         */
    1947         case VMMCALLHOST_VM_SET_ERROR:
     1947        case VMMCALLRING3_VM_SET_ERROR:
    19481948            VMR3SetErrorWorker(pVM);
    19491949            pVCpu->vmm.s.rcCallHost = VINF_SUCCESS;
    … …  
    19531953         * Set the VM runtime error message.
    19541954         */
    1955         case VMMCALLHOST_VM_SET_RUNTIME_ERROR:
     1955        case VMMCALLRING3_VM_SET_RUNTIME_ERROR:
    19561956            pVCpu->vmm.s.rcCallHost = VMR3SetRuntimeErrorWorker(pVM);
    19571957            break;
    … …  
    19611961         * Cancel the longjmp operation that's in progress.
    19621962         */
    1963         case VMMCALLHOST_VM_R0_ASSERTION:
    1964             pVCpu->vmm.s.enmCallHostOperation = VMMCALLHOST_INVALID;
     1963        case VMMCALLRING3_VM_R0_ASSERTION:
     1964            pVCpu->vmm.s.enmCallHostOperation = VMMCALLRING3_INVALID;
    19651965            pVCpu->vmm.s.CallHostR0JmpBuf.fInRing3Call = false;
    19661966#ifdef RT_ARCH_X86
    … …  
    19761976         * A forced switch to ring 0 for preemption purposes.
    19771977         */
    1978         case VMMCALLHOST_VM_R0_PREEMPT:
     1978        case VMMCALLRING3_VM_R0_PREEMPT:
    19791979            pVCpu->vmm.s.rcCallHost = VINF_SUCCESS;
    19801980            break;
    … …  
    19851985    }
    19861986
    1987     pVCpu->vmm.s.enmCallHostOperation = VMMCALLHOST_INVALID;
     1987    pVCpu->vmm.s.enmCallHostOperation = VMMCALLRING3_INVALID;
    19881988    return VINF_SUCCESS;
    19891989}

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

    r20873 r20874  
    171171#if defined(IN_RC) || defined(IN_RING0)
    172172    if (rc == VERR_SEM_BUSY)
    173         rc = VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_MMHYPER_LOCK, 0);
     173        rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_MMHYPER_LOCK, 0);
    174174#endif
    175175    AssertRC(rc);

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

    r20873 r20874  
    328328    int rc = PDMCritSectEnter(&pVM->pdm.s.CritSect, VERR_GENERAL_FAILURE);
    329329    if (rc == VERR_GENERAL_FAILURE)
    330         rc = VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_PDM_LOCK, 0);
     330        rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PDM_LOCK, 0);
    331331#endif
    332332    AssertRC(rc);

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

    r20755 r20874  
    284284 *
    285285 * @param   pCritSect           The PDM critical section to enter.
    286  * @param   fCallHost           Whether this is a VMMGCCallHost() or VMMR0CallHost() request.
    287  */
    288 VMMR3DECL(int) PDMR3CritSectEnterEx(PPDMCRITSECT pCritSect, bool fCallHost)
     286 * @param   fCallRing3          Whether this is a VMMRZCallRing3()request.
     287 */
     288VMMR3DECL(int) PDMR3CritSectEnterEx(PPDMCRITSECT pCritSect, bool fCallRing3)
    289289{
    290290    int rc = PDMCritSectEnter(pCritSect, VERR_INTERNAL_ERROR);
    291291    if (    rc == VINF_SUCCESS
    292         &&  fCallHost
     292        &&  fCallRing3
    293293        &&  pCritSect->s.Core.Strict.ThreadOwner != NIL_RTTHREAD)
    294294    {

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

    r20873 r20874  
    183183    Assert(pQueue->CTX_SUFF(pVM));
    184184    pVM->pdm.s.CTX_SUFF(pQueueFlush) = pQueue;
    185     VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_PDM_QUEUE_FLUSH, (uintptr_t)pQueue);
     185    VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PDM_QUEUE_FLUSH, (uintptr_t)pQueue);
    186186
    187187#else /* IN_RING3: */

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

    r20873 r20874  
    20792079#if defined(IN_RC) || defined(IN_RING0)
    20802080    if (rc == VERR_SEM_BUSY)
    2081         rc = VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_PGM_LOCK, 0);
     2081        rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_LOCK, 0);
    20822082#endif
    20832083    AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));

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

    r20873 r20874  
    272272            int rc = PGMR3PhysAllocateHandyPages(pVM);
    273273#else
    274             int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES, 0);
     274            int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES, 0);
    275275#endif
    276276            if (RT_UNLIKELY(rc != VINF_SUCCESS))
    … …  
    550550        {
    551551# ifdef IN_RING0
    552             int rc = VMMR0CallHost(pVM, VMMCALLHOST_PGM_MAP_CHUNK, idChunk);
     552            int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_MAP_CHUNK, idChunk);
    553553            AssertRCReturn(rc, rc);
    554554            pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
    … …  
    668668        {
    669669#ifdef IN_RING0
    670             int rc = VMMR0CallHost(pVM, VMMCALLHOST_PGM_MAP_CHUNK, idChunk);
     670            int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_MAP_CHUNK, idChunk);
    671671            AssertRCReturn(rc, rc);
    672672            pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);

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

    r20873 r20874  
    40094009        int rc = PGMR3PoolGrow(pVM);
    40104010#else
    4011         int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_PGM_POOL_GROW, 0);
     4011        int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_POOL_GROW, 0);
    40124012#endif
    40134013        if (RT_FAILURE(rc))

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

    r20871 r20874  
    102102                Assert(cFlushes++ != 128);
    103103                AssertFatal(cFlushes < _1M);
    104                 VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS, 0);
     104                VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS, 0);
    105105                idxFree = ASMAtomicUoReadU32(&pVM->rem.s.idxFreeList);
    106106            } while (idxFree == (uint32_t)-1);
    … …  
    227227
    228228    /* Ok, we gotta flush them. */
    229     VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS, 0);
     229    VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS, 0);
    230230}
    231231#endif /* IN_RC */

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

    r20873 r20874  
    9696     */
    9797    vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args);
    98     VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_VM_SET_ERROR, 0);
     98    VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_SET_ERROR, 0);
    9999#endif
    100100    return rc;
    … …  
    281281    vmSetRuntimeErrorCopy(pVM, fFlags, pszErrorId, pszFormat, va);
    282282
    283     int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_VM_SET_RUNTIME_ERROR, 0);
     283    int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_SET_RUNTIME_ERROR, 0);
    284284#endif
    285285

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

    r20873 r20874  
    178178    if (pVM->vmm.s.fRCLoggerFlushingDisabled)
    179179        return VINF_SUCCESS; /* fail quietly. */
    180     return VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_VMM_LOGGER_FLUSH, 0);
     180    return VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
    181181}
    182182
    … …  
    194194        if (pVM->vmm.s.fRCLoggerFlushingDisabled)
    195195            return; /* fail quietly. */
    196         VMMRZCallRing3NoCpu(pVM, VMMCALLHOST_VMM_LOGGER_FLUSH, 0);
     196        VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
    197197    }
    198198}

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

    r20871 r20874  
    406406    uint32_t                    cCallRing3Disabled;
    407407    /** The pending operation. */
    408     VMMCALLHOST                 enmCallHostOperation;
     408    VMMCALLRING3                 enmCallHostOperation;
    409409    /** The result of the last operation. */
    410410    int32_t                     rcCallHost;
    … …  
    511511 * The setjmp variant used for calling Ring-3.
    512512 *
    513  * This differs from the normal setjmp in that it will resume VMMR0CallHost if we're
     513 * This differs from the normal setjmp in that it will resume VMMRZCallRing3 if we're
    514514 * in the middle of a ring-3 call. Another differences is the function pointer and
    515515 * argument. This has to do with resuming code and the stack frame of the caller.
    … …  
    544544
    545545/**
    546  * Worker for VMMR0CallHost.
     546 * Worker for VMMRZCallRing3.
    547547 * This will save the stack and registers.
    548548 *

  • trunk/src/VBox/VMM/VMMR0/PGMR0DynMap.cpp

    r19403 r20874  
    18311831                   g_pPGMR0DynMap->cLoad, g_pPGMR0DynMap->cMaxLoad, g_pPGMR0DynMap->cPages, g_pPGMR0DynMap->cGuardPages);
    18321832        if (!g_fPGMR0DynMapTestRunning)
    1833             VMMR0CallHost(pVM, VMMCALLHOST_VM_R0_ASSERTION, 0);
     1833            VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_R0_ASSERTION, 0);
    18341834        *ppv = NULL;
    18351835        return VERR_PGM_DYNMAP_FAILED;
    … …  
    19271927                AssertMsg2("PGMDynMapHCPage: set is full!\n");
    19281928                if (!g_fPGMR0DynMapTestRunning)
    1929                     VMMR0CallHost(pVM, VMMCALLHOST_VM_R0_ASSERTION, 0);
     1929                    VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_R0_ASSERTION, 0);
    19301930                *ppv = NULL;
    19311931                return VERR_PGM_DYNMAP_FULL_SET;

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

    r20871 r20874  
    307307
    308308
    309 /**
    310  * Calls the ring-3 host code.
    311  *
    312  * @returns VBox status code of the ring-3 call.
    313  * @param   pVM             The VM handle.
    314  * @param   enmOperation    The operation.
    315  * @param   uArg            The argument to the operation.
    316  *
    317  * @deprecated Use VMMRZCallRing3.
    318  */
    319 VMMR0DECL(int) VMMR0CallHost(PVM pVM, VMMCALLHOST enmOperation, uint64_t uArg)
    320 {
    321     return VMMRZCallRing3(pVM, VMMGetCpu(pVM), enmOperation, uArg);
    322 }
    323 
    324 
    325309#ifdef VBOX_WITH_STATISTICS
    326310/**
    … …  
    442426            switch (pVCpu->vmm.s.enmCallHostOperation)
    443427            {
    444                 case VMMCALLHOST_PDM_LOCK:
     428                case VMMCALLRING3_PDM_LOCK:
    445429                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMLock);
    446430                    break;
    447                 case VMMCALLHOST_PDM_QUEUE_FLUSH:
     431                case VMMCALLRING3_PDM_QUEUE_FLUSH:
    448432                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMQueueFlush);
    449433                    break;
    450                 case VMMCALLHOST_PGM_POOL_GROW:
     434                case VMMCALLRING3_PGM_POOL_GROW:
    451435                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMPoolGrow);
    452436                    break;
    453                 case VMMCALLHOST_PGM_LOCK:
     437                case VMMCALLRING3_PGM_LOCK:
    454438                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMLock);
    455439                    break;
    456                 case VMMCALLHOST_PGM_MAP_CHUNK:
     440                case VMMCALLRING3_PGM_MAP_CHUNK:
    457441                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMMapChunk);
    458442                    break;
    459                 case VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES:
     443                case VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES:
    460444                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMAllocHandy);
    461445                    break;
    462                 case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
     446                case VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS:
    463447                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallRemReplay);
    464448                    break;
    465                 case VMMCALLHOST_VMM_LOGGER_FLUSH:
     449                case VMMCALLRING3_VMM_LOGGER_FLUSH:
    466450                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallLogFlush);
    467451                    break;
    468                 case VMMCALLHOST_VM_SET_ERROR:
     452                case VMMCALLRING3_VM_SET_ERROR:
    469453                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetError);
    470454                    break;
    471                 case VMMCALLHOST_VM_SET_RUNTIME_ERROR:
     455                case VMMCALLRING3_VM_SET_RUNTIME_ERROR:
    472456                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetRuntimeError);
    473457                    break;
    474                 case VMMCALLHOST_VM_R0_ASSERTION:
     458                case VMMCALLRING3_VM_R0_ASSERTION:
    475459                default:
    476460                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCallHost);
    … …  
    12011185        return;
    12021186    }
    1203     VMMR0CallHost(pVM, VMMCALLHOST_VMM_LOGGER_FLUSH, 0);
     1187    VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
    12041188#endif
    12051189}
    … …  
    12881272#endif
    12891273        {
    1290             int rc = VMMR0CallHost(pVM, VMMCALLHOST_VM_R0_ASSERTION, 0);
     1274            int rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_ASSERTION, 0);
    12911275            return RT_FAILURE_NP(rc);
    12921276        }

  • trunk/src/VBox/VMM/VMMR0/VMMR0JmpA-amd64.asm

    r20545 r20874  
    4646; The setjmp variant used for calling Ring-3.
    4747;
    48 ; This differs from the normal setjmp in that it will resume VMMR0CallHost if we're
     48; This differs from the normal setjmp in that it will resume VMMRZCallRing3 if we're
    4949; in the middle of a ring-3 call. Another differences is the function pointer and
    5050; argument. This has to do with resuming code and the stack frame of the caller.
    … …  
    177177
    178178    ;
    179     ; Resume VMMR0CallHost the call.
     179    ; Resume VMMRZCallRing3 the call.
    180180    ;
    181181.resume:
    … …  
    240240
    241241;;
    242 ; Worker for VMMR0CallHost.
     242; Worker for VMMRZCallRing3.
    243243; This will save the stack and registers.
    244244;

  • trunk/src/VBox/VMM/VMMR0/VMMR0JmpA-x86.asm

    r20548 r20874  
    4646; The setjmp variant used for calling Ring-3.
    4747;
    48 ; This differs from the normal setjmp in that it will resume VMMR0CallHost if we're
     48; This differs from the normal setjmp in that it will resume VMMRZCallRing3 if we're
    4949; in the middle of a ring-3 call. Another differences is the function pointer and
    5050; argument. This has to do with resuming code and the stack frame of the caller.
    … …  
    203203
    204204    ;
    205     ; Resume VMMR0CallHost the call.
     205    ; Resume VMMRZCallRing3 the call.
    206206    ;
    207207.resume:
    … …  
    274274
    275275;;
    276 ; Worker for VMMR0CallHost.
     276; Worker for VMMRZCallRing3.
    277277; This will save the stack and registers.
    278278;

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

    r20872 r20874  
    4747 * @param   uArg            The argument to the operation.
    4848 */
    49 VMMRZDECL(int) VMMRZCallRing3(PVM pVM, PVMCPU pVCpu, VMMCALLHOST enmOperation, uint64_t uArg)
     49VMMRZDECL(int) VMMRZCallRing3(PVM pVM, PVMCPU pVCpu, VMMCALLRING3 enmOperation, uint64_t uArg)
    5050{
    5151    VMCPU_ASSERT_EMT(pVCpu);
    … …  
    5555     */
    5656    if (RT_UNLIKELY(    pVCpu->vmm.s.cCallRing3Disabled != 0
    57                     &&  enmOperation != VMMCALLHOST_VM_R0_ASSERTION))
     57                    &&  enmOperation != VMMCALLRING3_VM_R0_ASSERTION))
    5858    {
    5959        /*
    … …  
    6767         * assertion host call.
    6868         */
    69         if (enmOperation != VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS)
     69        if (enmOperation != VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS)
    7070            return VERR_VMM_RING3_CALL_DISABLED;
    7171#ifdef IN_RC
    7272        RTStrPrintf(g_szRTAssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
    73                     "VMMR0CallHost: enmOperation=%d uArg=%#llx idCpu=%#x\n", enmOperation, uArg, pVCpu->idCpu);
     73                    "VMMRZCallRing3: enmOperation=%d uArg=%#llx idCpu=%#x\n", enmOperation, uArg, pVCpu->idCpu);
    7474#endif
    7575        RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
    76                     "VMMR0CallHost: enmOperation=%d uArg=%#llx idCpu=%#x\n", enmOperation, uArg, pVCpu->idCpu);
    77         enmOperation = VMMCALLHOST_VM_R0_ASSERTION;
     76                    "VMMRZCallRing3: enmOperation=%d uArg=%#llx idCpu=%#x\n", enmOperation, uArg, pVCpu->idCpu);
     77        enmOperation = VMMCALLRING3_VM_R0_ASSERTION;
    7878    }
    7979
    … …  
    109109 * @param   uArg            The argument to the operation.
    110110 */
    111 VMMRZDECL(int) VMMRZCallRing3NoCpu(PVM pVM, VMMCALLHOST enmOperation, uint64_t uArg)
     111VMMRZDECL(int) VMMRZCallRing3NoCpu(PVM pVM, VMMCALLRING3 enmOperation, uint64_t uArg)
    112112{
    113113    return VMMRZCallRing3(pVM, VMMGetCpu(pVM), enmOperation, uArg);
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