VirtualBox

Changeset 13714 in vbox


Ignore:
Timestamp:
Oct 31, 2008 2:01:43 PM (16 years ago)
Author:
vboxsync
Message:

VMM: More renaming and cleanup, caught another R3/R0 pointer - the ring-0 logger.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm.h

    r13701 r13714  
    129129VMMR3DECL(const char *) VMMR3GetGCAssertMsg1(PVM pVM);
    130130VMMR3DECL(const char *) VMMR3GetGCAssertMsg2(PVM pVM);
    131 VMMR3DECL(int)      VMMR3GetImportGC(PVM pVM, const char *pszSymbol, PRTGCPTR pGCPtrValue);
     131VMMR3DECL(int)      VMMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue);
    132132VMMR3DECL(int)      VMMR3SelectSwitcher(PVM pVM, VMMSWITCHER enmSwitcher);
    133133VMMR3DECL(int)      VMMR3DisableSwitcher(PVM pVM);

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

    r13633 r13714  
    340340                 || !strcmp(pszSymbol, "g_RelLogger"))
    341341        {
    342             RTGCPTR GCPtr = 0;
    343             rc = VMMR3GetImportGC(pVM, pszSymbol, &GCPtr);
     342            RTRCPTR RCPtr = 0;
     343            rc = VMMR3GetImportRC(pVM, pszSymbol, &RCPtr);
    344344            if (VBOX_SUCCESS(rc))
    345                 *pValue = GCPtr;
     345                *pValue = RCPtr;
    346346        }
    347347        else if (   !strncmp(pszSymbol, "TM", 2)

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

    r13703 r13714  
    137137*******************************************************************************/
    138138static int                  vmmR3InitCoreCode(PVM pVM);
     139static int                  vmmR3InitStacks(PVM pVM);
     140static int                  vmmR3InitLoggers(PVM pVM);
    139141static void                 vmmR3InitRegisterStats(PVM pVM);
    140142static DECLCALLBACK(int)    vmmR3Save(PVM pVM, PSSMHANDLE pSSM);
    … …  
    209211
    210212    /*
    211      * Init core code.
     213     * Init various sub-components.
    212214     */
    213215    rc = vmmR3InitCoreCode(pVM);
    214     if (VBOX_SUCCESS(rc))
    215     {
    216         /*
    217          * Allocate & init VMM RC stack.
    218          * The stack pages are also used by the VMM R0 when VMMR0CallHost is invoked.
    219          * (The page protection is modifed during R3 init completion.)
    220          */
    221         /** @todo SMP: Per vCPU, split up into functions. */
    222 #ifdef VBOX_STRICT_VMM_STACK
    223         rc = MMHyperAlloc(pVM, VMM_STACK_SIZE + PAGE_SIZE + PAGE_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbHCStack);
    224 #else
    225         rc = MMHyperAlloc(pVM, VMM_STACK_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbEMTStackR3);
    226 #endif
    227         if (VBOX_SUCCESS(rc))
    228         {
    229             /* Set HC and GC stack pointers to top of stack. */
    230             pVM->vmm.s.CallHostR0JmpBuf.pvSavedStack = MMHyperR3ToR0(pVM, pVM->vmm.s.pbEMTStackR3);
    231             pVM->vmm.s.pbEMTStackRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pbEMTStackR3);
    232             pVM->vmm.s.pbEMTStackBottomRC = pVM->vmm.s.pbEMTStackRC + VMM_STACK_SIZE;
    233             AssertRelease(pVM->vmm.s.pbEMTStackRC);
    234 
    235             /* Set hypervisor esp. */
    236             CPUMSetHyperESP(pVM, pVM->vmm.s.pbEMTStackBottomRC);
    237 
    238             /*
    239              * Allocate GC & R0 Logger instances (they are finalized in the relocator).
    240              */
    241 #ifdef LOG_ENABLED
    242             PRTLOGGER pLogger = RTLogDefaultInstance();
    243             if (pLogger)
    244             {
    245                 pVM->vmm.s.cbLoggerGC = RT_OFFSETOF(RTLOGGERRC, afGroups[pLogger->cGroups]);
    246                 rc = MMHyperAlloc(pVM, pVM->vmm.s.cbLoggerGC, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pLoggerHC);
    247                 if (VBOX_SUCCESS(rc))
    248                 {
    249                     pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
    250 
    251 # ifdef VBOX_WITH_R0_LOGGING
    252                     rc = MMHyperAlloc(pVM, RT_OFFSETOF(VMMR0LOGGER, Logger.afGroups[pLogger->cGroups]),
    253                                       0, MM_TAG_VMM, (void **)&pVM->vmm.s.pR0Logger);
    254                     if (VBOX_SUCCESS(rc))
    255                     {
    256                         pVM->vmm.s.pR0Logger->pVM = pVM->pVMR0;
    257                         //pVM->vmm.s.pR0Logger->fCreated = false;
    258                         pVM->vmm.s.pR0Logger->cbLogger = RT_OFFSETOF(RTLOGGER, afGroups[pLogger->cGroups]);
    259                     }
    260 # endif
    261                 }
    262             }
    263 #endif /* LOG_ENABLED */
    264 
    265 #ifdef VBOX_WITH_RC_RELEASE_LOGGING
    266             /*
    267              * Allocate RC release logger instances (finalized in the relocator).
    268              */
    269             if (VBOX_SUCCESS(rc))
    270             {
    271                 PRTLOGGER pRelLogger = RTLogRelDefaultInstance();
    272                 if (pRelLogger)
    273                 {
    274                     pVM->vmm.s.cbRelLoggerGC = RT_OFFSETOF(RTLOGGERRC, afGroups[pRelLogger->cGroups]);
    275                     rc = MMHyperAlloc(pVM, pVM->vmm.s.cbRelLoggerGC, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pRelLoggerHC);
    276                     if (VBOX_SUCCESS(rc))
    277                         pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
    278                 }
    279             }
    280 #endif /* VBOX_WITH_RC_RELEASE_LOGGING */
     216    if (RT_SUCCESS(rc))
     217    {
     218        rc = vmmR3InitStacks(pVM);
     219        if (RT_SUCCESS(rc))
     220        {
     221            rc = vmmR3InitLoggers(pVM);
    281222
    282223#ifdef VBOX_WITH_NMI
    … …  
    284225             * Allocate mapping for the host APIC.
    285226             */
    286             if (VBOX_SUCCESS(rc))
     227            if (RT_SUCCESS(rc))
    287228            {
    288229                rc = MMR3HyperReserve(pVM, PAGE_SIZE, "Host APIC", &pVM->vmm.s.GCPtrApicBase);
    … …  
    290231            }
    291232#endif
    292             if (VBOX_SUCCESS(rc))
     233            if (RT_SUCCESS(rc))
    293234            {
    294235                rc = RTCritSectInit(&pVM->vmm.s.CritSectVMLock);
    … …  
    303244                    return VINF_SUCCESS;
    304245                }
    305                 AssertRC(rc);
    306246            }
    307247        }
    … …  
    351291     */
    352292    pVM->vmm.s.cbCoreCode = RT_ALIGN_32(cbCoreCode, PAGE_SIZE);
    353     pVM->vmm.s.pvHCCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvHCCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
     293    pVM->vmm.s.pvCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
    354294    int rc = VERR_NO_MEMORY;
    355     if (pVM->vmm.s.pvHCCoreCodeR3)
    356     {
    357         rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
     295    if (pVM->vmm.s.pvCoreCodeR3)
     296    {
     297        rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
    358298        if (rc == VERR_PGM_INTERMEDIATE_PAGING_CONFLICT)
    359299        {
    … …  
    371311            do
    372312            {
    373                 paBadTries[i].pvR3 = pVM->vmm.s.pvHCCoreCodeR3;
    374                 paBadTries[i].pvR0 = pVM->vmm.s.pvHCCoreCodeR0;
     313                paBadTries[i].pvR3 = pVM->vmm.s.pvCoreCodeR3;
     314                paBadTries[i].pvR0 = pVM->vmm.s.pvCoreCodeR0;
    375315                paBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
    376316                i++;
    377                 pVM->vmm.s.pvHCCoreCodeR0 = NIL_RTR0PTR;
     317                pVM->vmm.s.pvCoreCodeR0 = NIL_RTR0PTR;
    378318                pVM->vmm.s.HCPhysCoreCode = NIL_RTHCPHYS;
    379                 pVM->vmm.s.pvHCCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvHCCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
    380                 if (!pVM->vmm.s.pvHCCoreCodeR3)
     319                pVM->vmm.s.pvCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
     320                if (!pVM->vmm.s.pvCoreCodeR3)
    381321                    break;
    382                 rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
     322                rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
    383323            } while (   rc == VERR_PGM_INTERMEDIATE_PAGING_CONFLICT
    384324                     && i < cTries - 1);
    … …  
    387327            if (VBOX_FAILURE(rc))
    388328            {
    389                 paBadTries[i].pvR3   = pVM->vmm.s.pvHCCoreCodeR3;
    390                 paBadTries[i].pvR0   = pVM->vmm.s.pvHCCoreCodeR0;
     329                paBadTries[i].pvR3   = pVM->vmm.s.pvCoreCodeR3;
     330                paBadTries[i].pvR0   = pVM->vmm.s.pvCoreCodeR0;
    391331                paBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
    392332                paBadTries[i].cb     = pVM->vmm.s.cbCoreCode;
    … …  
    412352            PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
    413353            if (pSwitcher)
    414                 memcpy((uint8_t *)pVM->vmm.s.pvHCCoreCodeR3 + pVM->vmm.s.aoffSwitchers[iSwitcher],
     354                memcpy((uint8_t *)pVM->vmm.s.pvCoreCodeR3 + pVM->vmm.s.aoffSwitchers[iSwitcher],
    415355                       pSwitcher->pvCode, pSwitcher->cbCode);
    416356        }
    … …  
    420360         */
    421361        RTGCPTR GCPtr;
    422         rc = MMR3HyperMapHCPhys(pVM, pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, "Core Code", &GCPtr);
     362        rc = MMR3HyperMapHCPhys(pVM, pVM->vmm.s.pvCoreCodeR3, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, "Core Code", &GCPtr);
    423363        if (VBOX_SUCCESS(rc))
    424364        {
    425             pVM->vmm.s.pvGCCoreCode = GCPtr;
     365            pVM->vmm.s.pvCoreCodeRC = GCPtr;
    426366            MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
    427367            LogRel(("CoreCode: R3=%VHv R0=%VHv GC=%VRv Phys=%VHp cb=%#x\n",
    428                     pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.pvGCCoreCode, pVM->vmm.s.HCPhysCoreCode, pVM->vmm.s.cbCoreCode));
     368                    pVM->vmm.s.pvCoreCodeR3, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.pvCoreCodeRC, pVM->vmm.s.HCPhysCoreCode, pVM->vmm.s.cbCoreCode));
    429369
    430370            /*
    … …  
    438378
    439379        /* shit */
    440         AssertMsgFailed(("PGMR3Map(,%VRv, %VGp, %#x, 0) failed with rc=%Vrc\n", pVM->vmm.s.pvGCCoreCode, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, rc));
    441         SUPContFree(pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.cbCoreCode >> PAGE_SHIFT);
     380        AssertMsgFailed(("PGMR3Map(,%VRv, %VGp, %#x, 0) failed with rc=%Vrc\n", pVM->vmm.s.pvCoreCodeRC, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, rc));
     381        SUPContFree(pVM->vmm.s.pvCoreCodeR3, pVM->vmm.s.cbCoreCode >> PAGE_SHIFT);
    442382    }
    443383    else
    … …  
    446386                   cbCoreCode);
    447387
    448     pVM->vmm.s.pvHCCoreCodeR3 = NULL;
    449     pVM->vmm.s.pvHCCoreCodeR0 = NIL_RTR0PTR;
    450     pVM->vmm.s.pvGCCoreCode = 0;
     388    pVM->vmm.s.pvCoreCodeR3 = NULL;
     389    pVM->vmm.s.pvCoreCodeR0 = NIL_RTR0PTR;
     390    pVM->vmm.s.pvCoreCodeRC = 0;
    451391    return rc;
     392}
     393
     394
     395/**
     396 * Allocate & setup the VMM RC stack(s) (for EMTs).
     397 *
     398 * The stacks are also used for long jumps in Ring-0.
     399 *
     400 * @returns VBox status code.
     401 * @param   pVM     Pointer to the shared VM structure.
     402 *
     403 * @remarks The optional guard page gets it protection setup up during R3 init
     404 *          completion because of init order issues.
     405 */
     406static int vmmR3InitStacks(PVM pVM)
     407{
     408    /** @todo SMP: On stack per vCPU. */
     409#ifdef VBOX_STRICT_VMM_STACK
     410    int rc = MMHyperAlloc(pVM, VMM_STACK_SIZE + PAGE_SIZE + PAGE_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbEMTStackR3);
     411#else
     412    int rc = MMHyperAlloc(pVM, VMM_STACK_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbEMTStackR3);
     413#endif
     414    if (VBOX_SUCCESS(rc))
     415    {
     416        pVM->vmm.s.CallHostR0JmpBuf.pvSavedStack = MMHyperR3ToR0(pVM, pVM->vmm.s.pbEMTStackR3);
     417        pVM->vmm.s.pbEMTStackRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pbEMTStackR3);
     418        pVM->vmm.s.pbEMTStackBottomRC = pVM->vmm.s.pbEMTStackRC + VMM_STACK_SIZE;
     419        AssertRelease(pVM->vmm.s.pbEMTStackRC);
     420
     421        CPUMSetHyperESP(pVM, pVM->vmm.s.pbEMTStackBottomRC);
     422    }
     423
     424    return rc;
     425}
     426
     427
     428/**
     429 * Initialize the loggers.
     430 *
     431 * @returns VBox status code.
     432 * @param   pVM         Pointer to the shared VM structure.
     433 */
     434static int vmmR3InitLoggers(PVM pVM)
     435{
     436    int rc;
     437
     438    /*
     439     * Allocate RC & R0 Logger instances (they are finalized in the relocator).
     440     */
     441#ifdef LOG_ENABLED
     442    PRTLOGGER pLogger = RTLogDefaultInstance();
     443    if (pLogger)
     444    {
     445        pVM->vmm.s.cbRCLogger = RT_OFFSETOF(RTLOGGERRC, afGroups[pLogger->cGroups]);
     446        rc = MMHyperAlloc(pVM, pVM->vmm.s.cbRCLogger, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pRCLoggerR3);
     447        if (RT_FAILURE(rc))
     448            return rc;
     449        pVM->vmm.s.pRCLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCLoggerR3);
     450
     451# ifdef VBOX_WITH_R0_LOGGING
     452        rc = MMHyperAlloc(pVM, RT_OFFSETOF(VMMR0LOGGER, Logger.afGroups[pLogger->cGroups]),
     453                          0, MM_TAG_VMM, (void **)&pVM->vmm.s.pR0LoggerR3);
     454        if (RT_FAILURE(rc))
     455            return rc;
     456        pVM->vmm.s.pR0LoggerR3->pVM = pVM->pVMR0;
     457        //pVM->vmm.s.pR0LoggerR3->fCreated = false;
     458        pVM->vmm.s.pR0LoggerR3->cbLogger = RT_OFFSETOF(RTLOGGER, afGroups[pLogger->cGroups]);
     459        pVM->vmm.s.pR0LoggerR0 = MMHyperR3ToR0(pVM, pVM->vmm.s.pR0LoggerR3);
     460# endif
     461    }
     462#endif /* LOG_ENABLED */
     463
     464#ifdef VBOX_WITH_RC_RELEASE_LOGGING
     465    /*
     466     * Allocate RC release logger instances (finalized in the relocator).
     467     */
     468    PRTLOGGER pRelLogger = RTLogRelDefaultInstance();
     469    if (pRelLogger)
     470    {
     471        pVM->vmm.s.cbRCRelLogger = RT_OFFSETOF(RTLOGGERRC, afGroups[pRelLogger->cGroups]);
     472        rc = MMHyperAlloc(pVM, pVM->vmm.s.cbRCRelLogger, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pRCRelLoggerR3);
     473        if (RT_FAILURE(rc))
     474            return rc;
     475        pVM->vmm.s.pRCRelLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCRelLoggerR3);
     476    }
     477#endif /* VBOX_WITH_RC_RELEASE_LOGGING */
     478    return VINF_SUCCESS;
    452479}
    453480
    … …  
    533560     * Two inaccessible pages at each sides of the stack to catch over/under-flows.
    534561     */
    535     memset(pVM->vmm.s.pbHCStack - PAGE_SIZE, 0xcc, PAGE_SIZE);
    536     PGMMapSetPage(pVM, MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack - PAGE_SIZE), PAGE_SIZE, 0);
    537     RTMemProtect(pVM->vmm.s.pbHCStack - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
    538 
    539     memset(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, 0xcc, PAGE_SIZE);
    540     PGMMapSetPage(pVM, MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack + VMM_STACK_SIZE), PAGE_SIZE, 0);
    541     RTMemProtect(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
     562    memset(pVM->vmm.s.pbEMTStackR3 - PAGE_SIZE, 0xcc, PAGE_SIZE);
     563    PGMMapSetPage(pVM, MMHyperR3ToRC(pVM, pVM->vmm.s.pbEMTStackR3 - PAGE_SIZE), PAGE_SIZE, 0);
     564    RTMemProtect(pVM->vmm.s.pbEMTStackR3 - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
     565
     566    memset(pVM->vmm.s.pbEMTStackR3 + VMM_STACK_SIZE, 0xcc, PAGE_SIZE);
     567    PGMMapSetPage(pVM, MMHyperR3ToRC(pVM, pVM->vmm.s.pbEMTStackR3 + VMM_STACK_SIZE), PAGE_SIZE, 0);
     568    RTMemProtect(pVM->vmm.s.pbEMTStackR3 + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
    542569#endif
    543570
    … …  
    582609     * Initialize the ring-0 logger if we haven't done so yet.
    583610     */
    584     if (    pVM->vmm.s.pR0Logger
    585         &&  !pVM->vmm.s.pR0Logger->fCreated)
     611    if (    pVM->vmm.s.pR0LoggerR3
     612        &&  !pVM->vmm.s.pR0LoggerR3->fCreated)
    586613    {
    587614        rc = VMMR3UpdateLoggers(pVM);
    … …  
    601628        rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_VMMR0_INIT, VMMGetSvnRev(), NULL);
    602629#endif
    603         if (    pVM->vmm.s.pR0Logger
    604             &&  pVM->vmm.s.pR0Logger->Logger.offScratch > 0)
    605             RTLogFlushToLogger(&pVM->vmm.s.pR0Logger->Logger, NULL);
     630        if (    pVM->vmm.s.pR0LoggerR3
     631            &&  pVM->vmm.s.pR0LoggerR3->Logger.offScratch > 0)
     632            RTLogFlushToLogger(&pVM->vmm.s.pR0LoggerR3->Logger, NULL);
    606633        if (rc != VINF_VMM_CALL_HOST)
    607634            break;
    … …  
    654681        CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32));      /* trampoline param: stacksize.  */
    655682        CPUMPushHyper(pVM, GCPtrEP);                    /* Call EIP. */
    656         CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
     683        CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
    657684
    658685        for (;;)
    … …  
    665692#endif
    666693#ifdef LOG_ENABLED
    667             PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
     694            PRTLOGGERRC pLogger = pVM->vmm.s.pRCLoggerR3;
    668695            if (    pLogger
    669696                &&  pLogger->offScratch > 0)
    … …  
    671698#endif
    672699#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    673             PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
     700            PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    674701            if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    675702                RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
    … …  
    714741        rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_VMMR0_TERM, 0, NULL);
    715742#endif
    716         if (    pVM->vmm.s.pR0Logger
    717             &&  pVM->vmm.s.pR0Logger->Logger.offScratch > 0)
    718             RTLogFlushToLogger(&pVM->vmm.s.pR0Logger->Logger, NULL);
     743        if (    pVM->vmm.s.pR0LoggerR3
     744            &&  pVM->vmm.s.pR0LoggerR3->Logger.offScratch > 0)
     745            RTLogFlushToLogger(&pVM->vmm.s.pR0LoggerR3->Logger, NULL);
    719746        if (rc != VINF_VMM_CALL_HOST)
    720747            break;
    … …  
    735762     * Make the two stack guard pages present again.
    736763     */
    737     RTMemProtect(pVM->vmm.s.pbHCStack - PAGE_SIZE,      PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
    738     RTMemProtect(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
     764    RTMemProtect(pVM->vmm.s.pbEMTStackR3 - PAGE_SIZE,      PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
     765    RTMemProtect(pVM->vmm.s.pbEMTStackR3 + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
    739766#endif
    740767    return rc;
    … …  
    759786     * Recalc the GC address.
    760787     */
    761     pVM->vmm.s.pvGCCoreCode = MMHyperHC2GC(pVM, pVM->vmm.s.pvHCCoreCodeR3);
     788    pVM->vmm.s.pvCoreCodeRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pvCoreCodeR3);
    762789
    763790    /*
    … …  
    779806            pSwitcher->pfnRelocate(pVM,
    780807                                   pSwitcher,
    781                                    (uint8_t *)pVM->vmm.s.pvHCCoreCodeR0 + off,
    782                                    (uint8_t *)pVM->vmm.s.pvHCCoreCodeR3 + off,
    783                                    pVM->vmm.s.pvGCCoreCode + off,
     808                                   (uint8_t *)pVM->vmm.s.pvCoreCodeR0 + off,
     809                                   (uint8_t *)pVM->vmm.s.pvCoreCodeR3 + off,
     810                                   pVM->vmm.s.pvCoreCodeRC + off,
    784811                                   pVM->vmm.s.HCPhysCoreCode + off);
    785812        }
    … …  
    790817     */
    791818    PVMMSWITCHERDEF pSwitcher   = s_apSwitchers[pVM->vmm.s.enmSwitcher];
    792     RTGCPTR         GCPtr       = pVM->vmm.s.pvGCCoreCode + pVM->vmm.s.aoffSwitchers[pVM->vmm.s.enmSwitcher];
    793     pVM->vmm.s.pfnGCGuestToHost         = GCPtr + pSwitcher->offGCGuestToHost;
    794     pVM->vmm.s.pfnGCCallTrampoline      = GCPtr + pSwitcher->offGCCallTrampoline;
     819    RTGCPTR         GCPtr       = pVM->vmm.s.pvCoreCodeRC + pVM->vmm.s.aoffSwitchers[pVM->vmm.s.enmSwitcher];
     820    pVM->vmm.s.pfnGuestToHostRC         = GCPtr + pSwitcher->offGCGuestToHost;
     821    pVM->vmm.s.pfnCallTrampolineRC      = GCPtr + pSwitcher->offGCCallTrampoline;
    795822    pVM->pfnVMMGCGuestToHostAsm         = GCPtr + pSwitcher->offGCGuestToHostAsm;
    796823    pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
    … …  
    800827     * Get other GC entry points.
    801828     */
    802     int rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuest", &pVM->vmm.s.pfnCPUMGCResumeGuest);
     829    int rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuest", &pVM->vmm.s.pfnCPUMRCResumeGuest);
    803830    AssertReleaseMsgRC(rc, ("CPUMGCResumeGuest not found! rc=%Vra\n", rc));
    804831
    805     rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuestV86", &pVM->vmm.s.pfnCPUMGCResumeGuestV86);
     832    rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuestV86", &pVM->vmm.s.pfnCPUMRCResumeGuestV86);
    806833    AssertReleaseMsgRC(rc, ("CPUMGCResumeGuestV86 not found! rc=%Vra\n", rc));
    807834
    … …  
    825852     */
    826853    int rc = VINF_SUCCESS;
    827     RTGCPTR32 GCPtrLoggerFlush = 0;
    828 
    829     if (pVM->vmm.s.pLoggerHC
     854    RTRCPTR RCPtrLoggerFlush = 0;
     855
     856    if (pVM->vmm.s.pRCLoggerR3
    830857#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    831         || pVM->vmm.s.pRelLoggerHC
     858        || pVM->vmm.s.pRCRelLoggerR3
    832859#endif
    833860       )
    834861    {
    835         rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerFlush", &GCPtrLoggerFlush);
     862        rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerFlush", &RCPtrLoggerFlush);
    836863        AssertReleaseMsgRC(rc, ("vmmGCLoggerFlush not found! rc=%Vra\n", rc));
    837864    }
    838865
    839     if (pVM->vmm.s.pLoggerHC)
    840     {
    841         RTGCPTR32 GCPtrLoggerWrapper = 0;
    842         rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerWrapper", &GCPtrLoggerWrapper);
     866    if (pVM->vmm.s.pRCLoggerR3)
     867    {
     868        RTRCPTR RCPtrLoggerWrapper = 0;
     869        rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerWrapper", &RCPtrLoggerWrapper);
    843870        AssertReleaseMsgRC(rc, ("vmmGCLoggerWrapper not found! rc=%Vra\n", rc));
    844         pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
    845         rc = RTLogCloneRC(NULL /* default */, pVM->vmm.s.pLoggerHC, pVM->vmm.s.cbLoggerGC,
    846                           GCPtrLoggerWrapper,  GCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
     871        pVM->vmm.s.pRCLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCLoggerR3);
     872        rc = RTLogCloneRC(NULL /* default */, pVM->vmm.s.pRCLoggerR3, pVM->vmm.s.cbRCLogger,
     873                          RCPtrLoggerWrapper,  RCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
    847874        AssertReleaseMsgRC(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc));
    848875    }
    849876
    850877#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    851     if (pVM->vmm.s.pRelLoggerHC)
    852     {
    853         RTGCPTR32 GCPtrLoggerWrapper = 0;
    854         rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCRelLoggerWrapper", &GCPtrLoggerWrapper);
     878    if (pVM->vmm.s.pRCRelLoggerR3)
     879    {
     880        RTRCPTR RCPtrLoggerWrapper = 0;
     881        rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCRelLoggerWrapper", &RCPtrLoggerWrapper);
    855882        AssertReleaseMsgRC(rc, ("vmmGCRelLoggerWrapper not found! rc=%Vra\n", rc));
    856         pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
    857         rc = RTLogCloneRC(RTLogRelDefaultInstance(), pVM->vmm.s.pRelLoggerHC, pVM->vmm.s.cbRelLoggerGC,
    858                           GCPtrLoggerWrapper,  GCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
     883        pVM->vmm.s.pRCRelLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCRelLoggerR3);
     884        rc = RTLogCloneRC(RTLogRelDefaultInstance(), pVM->vmm.s.pRCRelLoggerR3, pVM->vmm.s.cbRCRelLogger,
     885                          RCPtrLoggerWrapper,  RCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
    859886        AssertReleaseMsgRC(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc));
    860887    }
    … …  
    862889
    863890    /*
    864      * For the ring-0 EMT logger, we use a per-thread logger
    865      * instance in ring-0. Only initialize it once.
    866      */
    867     PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
    868     if (pR0Logger)
    869     {
    870         if (!pR0Logger->fCreated)
     891     * For the ring-0 EMT logger, we use a per-thread logger instance
     892     * in ring-0. Only initialize it once.
     893     */
     894    PVMMR0LOGGER pR0LoggerR3 = pVM->vmm.s.pR0LoggerR3;
     895    if (pR0LoggerR3)
     896    {
     897        if (!pR0LoggerR3->fCreated)
    871898        {
    872899            RTR0PTR pfnLoggerWrapper = NIL_RTR0PTR;
    … …  
    878905            AssertReleaseMsgRCReturn(rc, ("VMMLoggerFlush not found! rc=%Vra\n", rc), rc);
    879906
    880             rc = RTLogCreateForR0(&pR0Logger->Logger, pR0Logger->cbLogger,
     907            rc = RTLogCreateForR0(&pR0LoggerR3->Logger, pR0LoggerR3->cbLogger,
    881908                                  *(PFNRTLOGGER *)&pfnLoggerWrapper, *(PFNRTLOGFLUSH *)&pfnLoggerFlush,
    882909                                  RTLOGFLAGS_BUFFERED, RTLOGDEST_DUMMY);
    883910            AssertReleaseMsgRCReturn(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc), rc);
    884             pR0Logger->fCreated = true;
     911            pR0LoggerR3->fCreated = true;
    885912        }
    886913
    887         rc = RTLogCopyGroupsAndFlags(&pR0Logger->Logger, NULL /* default */, pVM->vmm.s.pLoggerHC->fFlags, RTLOGFLAGS_BUFFERED);
     914        rc = RTLogCopyGroupsAndFlags(&pR0LoggerR3->Logger, NULL /* default */, pVM->vmm.s.pRCLoggerR3->fFlags, RTLOGFLAGS_BUFFERED);
    888915        AssertRC(rc);
    889916    }
    … …  
    16591686        pVM->vmm.s.enmSwitcher = enmSwitcher;
    16601687
    1661         RTR0PTR     pbCodeR0 = (RTR0PTR)pVM->vmm.s.pvHCCoreCodeR0 + pVM->vmm.s.aoffSwitchers[enmSwitcher]; /** @todo fix the pvHCCoreCodeR0 type */
    1662         pVM->vmm.s.pfnR0HostToGuest = pbCodeR0 + pSwitcher->offR0HostToGuest;
    1663 
    1664         RTGCPTR     GCPtr = pVM->vmm.s.pvGCCoreCode + pVM->vmm.s.aoffSwitchers[enmSwitcher];
    1665         pVM->vmm.s.pfnGCGuestToHost         = GCPtr + pSwitcher->offGCGuestToHost;
    1666         pVM->vmm.s.pfnGCCallTrampoline      = GCPtr + pSwitcher->offGCCallTrampoline;
     1688        RTR0PTR     pbCodeR0 = (RTR0PTR)pVM->vmm.s.pvCoreCodeR0 + pVM->vmm.s.aoffSwitchers[enmSwitcher]; /** @todo fix the pvCoreCodeR0 type */
     1689        pVM->vmm.s.pfnHostToGuestR0 = pbCodeR0 + pSwitcher->offR0HostToGuest;
     1690
     1691        RTGCPTR     GCPtr = pVM->vmm.s.pvCoreCodeRC + pVM->vmm.s.aoffSwitchers[enmSwitcher];
     1692        pVM->vmm.s.pfnGuestToHostRC         = GCPtr + pSwitcher->offGCGuestToHost;
     1693        pVM->vmm.s.pfnCallTrampolineRC      = GCPtr + pSwitcher->offGCCallTrampoline;
    16671694        pVM->pfnVMMGCGuestToHostAsm         = GCPtr + pSwitcher->offGCGuestToHostAsm;
    16681695        pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
    … …  
    16941721
    16951722/**
    1696  * Resolve a builtin GC symbol.
    1697  * Called by PDM when loading or relocating GC modules.
     1723 * Resolve a builtin RC symbol.
     1724 *
     1725 * Called by PDM when loading or relocating RC modules.
    16981726 *
    16991727 * @returns VBox status
    1700  * @param   pVM         VM Handle.
    1701  * @param   pszSymbol   Symbol to resolv
    1702  * @param   pGCPtrValue Where to store the symbol value.
     1728 * @param   pVM             VM Handle.
     1729 * @param   pszSymbol       Symbol to resolv
     1730 * @param   pRCPtrValue     Where to store the symbol value.
     1731 *
    17031732 * @remark  This has to work before VMMR3Relocate() is called.
    17041733 */
    1705 VMMR3DECL(int) VMMR3GetImportGC(PVM pVM, const char *pszSymbol, PRTGCPTR pGCPtrValue)
     1734VMMR3DECL(int) VMMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue)
    17061735{
    17071736    if (!strcmp(pszSymbol, "g_Logger"))
    17081737    {
    1709         if (pVM->vmm.s.pLoggerHC)
    1710             pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
    1711         *pGCPtrValue = pVM->vmm.s.pLoggerGC;
     1738        if (pVM->vmm.s.pRCLoggerR3)
     1739            pVM->vmm.s.pRCLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCLoggerR3);
     1740        *pRCPtrValue = pVM->vmm.s.pRCLoggerRC;
    17121741    }
    17131742    else if (!strcmp(pszSymbol, "g_RelLogger"))
    17141743    {
    17151744#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    1716         if (pVM->vmm.s.pRelLoggerHC)
    1717             pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
    1718         *pGCPtrValue = pVM->vmm.s.pRelLoggerGC;
     1745        if (pVM->vmm.s.pRCRelLoggerR3)
     1746            pVM->vmm.s.pRCRelLoggerRC = MMHyperR3ToRC(pVM, pVM->vmm.s.pRCRelLoggerR3);
     1747        *pRCPtrValue = pVM->vmm.s.pRCRelLoggerRC;
    17191748#else
    1720         *pGCPtrValue = NIL_RTGCPTR;
     1749        *pRCPtrValue = NIL_RTRCPTR;
    17211750#endif
    17221751    }
    … …  
    18801909     */
    18811910    CPUMSetHyperEIP(pVM, CPUMGetGuestEFlags(pVM) & X86_EFL_VM
    1882                     ? pVM->vmm.s.pfnCPUMGCResumeGuestV86
    1883                     : pVM->vmm.s.pfnCPUMGCResumeGuest);
     1911                    ? pVM->vmm.s.pfnCPUMRCResumeGuestV86
     1912                    : pVM->vmm.s.pfnCPUMRCResumeGuest);
    18841913    CPUMSetHyperESP(pVM, pVM->vmm.s.pbEMTStackBottomRC);
    18851914
    … …  
    18971926            rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    18981927            if (RT_LIKELY(rc == VINF_SUCCESS))
    1899                 rc = pVM->vmm.s.iLastGCRc;
     1928                rc = pVM->vmm.s.iLastGZRc;
    19001929#endif
    19011930        } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
    … …  
    19051934         */
    19061935#ifdef LOG_ENABLED
    1907         PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
     1936        PRTLOGGERRC pLogger = pVM->vmm.s.pRCLoggerR3;
    19081937        if (    pLogger
    19091938            &&  pLogger->offScratch > 0)
    … …  
    19111940#endif
    19121941#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    1913         PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
     1942        PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    19141943        if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    19151944            RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
    … …  
    19471976            rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HWACC_RUN);
    19481977            if (RT_LIKELY(rc == VINF_SUCCESS))
    1949                 rc = pVM->vmm.s.iLastGCRc;
     1978                rc = pVM->vmm.s.iLastGZRc;
    19501979#endif
    19511980        } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
    … …  
    19551984         * Flush the log
    19561985         */
    1957         PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
    1958         if (    pR0Logger
    1959             &&  pR0Logger->Logger.offScratch > 0)
    1960             RTLogFlushToLogger(&pR0Logger->Logger, NULL);
     1986        PVMMR0LOGGER pR0LoggerR3 = pVM->vmm.s.pR0LoggerR3;
     1987        if (    pR0LoggerR3
     1988            &&  pR0LoggerR3->Logger.offScratch > 0)
     1989            RTLogFlushToLogger(&pR0LoggerR3->Logger, NULL);
    19611990#endif /* !LOG_ENABLED */
    19621991        if (rc != VINF_VMM_CALL_HOST)
    … …  
    20152044    CPUMPushHyper(pVM, cArgs * sizeof(RTGCUINTPTR32));                          /* stack frame size */
    20162045    CPUMPushHyper(pVM, GCPtrEntry);                                             /* what to call */
    2017     CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
     2046    CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
    20182047
    20192048    /*
    … …  
    20302059            rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    20312060            if (RT_LIKELY(rc == VINF_SUCCESS))
    2032                 rc = pVM->vmm.s.iLastGCRc;
     2061                rc = pVM->vmm.s.iLastGZRc;
    20332062#endif
    20342063        } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
    … …  
    20382067         */
    20392068#ifdef LOG_ENABLED
    2040         PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
     2069        PRTLOGGERRC pLogger = pVM->vmm.s.pRCLoggerR3;
    20412070        if (    pLogger
    20422071            &&  pLogger->offScratch > 0)
    … …  
    20442073#endif
    20452074#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    2046         PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
     2075        PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    20472076        if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    20482077            RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
    … …  
    20632092
    20642093/**
    2065  * Resumes executing hypervisor code when interrupted
    2066  * by a queue flush or a debug event.
     2094 * Resumes executing hypervisor code when interrupted by a queue flush or a
     2095 * debug event.
    20672096 *
    20682097 * @returns VBox status code.
    … …  
    20862115            rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    20872116            if (RT_LIKELY(rc == VINF_SUCCESS))
    2088                 rc = pVM->vmm.s.iLastGCRc;
     2117                rc = pVM->vmm.s.iLastGZRc;
    20892118#endif
    20902119        } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
    … …  
    20942123         */
    20952124#ifdef LOG_ENABLED
    2096         PRTLOGGERRC pLogger = pVM->vmm.s.pLoggerHC;
     2125        PRTLOGGERRC pLogger = pVM->vmm.s.pRCLoggerR3;
    20972126        if (    pLogger
    20982127            &&  pLogger->offScratch > 0)
    … …  
    21002129#endif
    21012130#ifdef VBOX_WITH_RC_RELEASE_LOGGING
    2102         PRTLOGGERRC pRelLogger = pVM->vmm.s.pRelLoggerHC;
     2131        PRTLOGGERRC pRelLogger = pVM->vmm.s.pRCRelLoggerR3;
    21032132        if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
    21042133            RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);

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

    r12989 r13714  
    184184VMMRCDECL(void) VMMGCGuestToHost(PVM pVM, int rc)
    185185{
    186     pVM->vmm.s.pfnGCGuestToHost(rc);
     186    pVM->vmm.s.pfnGuestToHostRC(rc);
    187187}
    188188
    … …  
    202202    pVM->vmm.s.u64CallHostArg = uArg;
    203203    pVM->vmm.s.rcCallHost = VERR_INTERNAL_ERROR;
    204     pVM->vmm.s.pfnGCGuestToHost(VINF_VMM_CALL_HOST);
     204    pVM->vmm.s.pfnGuestToHostRC(VINF_VMM_CALL_HOST);
    205205    return pVM->vmm.s.rcCallHost;
    206206}

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

    r13703 r13714  
    293293                 */
    294294                /* core code? */
    295                 if (uEIP - (RTGCUINTPTR)pVM->vmm.s.pvGCCoreCode < pVM->vmm.s.cbCoreCode)
     295                if (uEIP - (RTGCUINTPTR)pVM->vmm.s.pvCoreCodeRC < pVM->vmm.s.cbCoreCode)
    296296                    pHlp->pfnPrintf(pHlp,
    297297                                "!! EIP is in CoreCode, offset %#x\n",
    298                                 uEIP - (RTGCUINTPTR)pVM->vmm.s.pvGCCoreCode);
     298                                uEIP - (RTGCUINTPTR)pVM->vmm.s.pvCoreCodeRC);
    299299                else
    300300                {   /* ask PDM */  /** @todo ask DBGFR3Sym later? */

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

    r13701 r13714  
    165165    RTINT                       offVM;
    166166
     167    /** @name World Switcher and Related
     168     * @{
     169     */
    167170    /** Size of the core code. */
    168171    RTUINT                      cbCoreCode;
    169172    /** Physical address of core code. */
    170173    RTHCPHYS                    HCPhysCoreCode;
    171 /** @todo pvHCCoreCodeR3 -> pvCoreCodeR3, pvHCCoreCodeR0 -> pvCoreCodeR0 */
    172174    /** Pointer to core code ring-3 mapping - contiguous memory.
    173175     * At present this only means the context switcher code. */
    174     RTR3PTR                     pvHCCoreCodeR3;
     176    RTR3PTR                     pvCoreCodeR3;
    175177    /** Pointer to core code ring-0 mapping - contiguous memory.
    176178     * At present this only means the context switcher code. */
    177     RTR0PTR                     pvHCCoreCodeR0;
     179    RTR0PTR                     pvCoreCodeR0;
    178180    /** Pointer to core code guest context mapping. */
    179     RTGCPTR32                   pvGCCoreCode;
     181    RTRCPTR                     pvCoreCodeRC;
    180182#ifdef VBOX_WITH_NMI
    181183    /** The guest context address of the APIC (host) mapping. */
    182     RTGCPTR32                   GCPtrApicBase;
    183     RTGCPTR32                   pGCPadding0; /**< Alignment padding */
     184    RTRCPTR                     GCPtrApicBase;
     185    RTRCPTR                     pGCPadding0; /**< Alignment padding */
    184186#endif
    185187    /** The current switcher.
    … …  
    192194
    193195    /** Host to guest switcher entry point. */
    194     R0PTRTYPE(PFNVMMSWITCHERHC) pfnR0HostToGuest;
     196    R0PTRTYPE(PFNVMMSWITCHERHC) pfnHostToGuestR0;
    195197    /** Guest to host switcher entry point. */
    196     RCPTRTYPE(PFNVMMSWITCHERRC) pfnGCGuestToHost;
     198    RCPTRTYPE(PFNVMMSWITCHERRC) pfnGuestToHostRC;
    197199    /** Call Trampoline. See vmmGCCallTrampoline(). */
    198     RTGCPTR32                   pfnGCCallTrampoline;
     200    RTRCPTR                     pfnCallTrampolineRC;
    199201
    200202    /** Resume Guest Execution. See CPUMGCResumeGuest(). */
    201     RTGCPTR32                   pfnCPUMGCResumeGuest;
     203    RTRCPTR                     pfnCPUMRCResumeGuest;
    202204    /** Resume Guest Execution in V86 mode. See CPUMGCResumeGuestV86(). */
    203     RTGCPTR32                   pfnCPUMGCResumeGuestV86;
    204     /** The last GC return code. */
    205     RTINT                       iLastGCRc;
     205    RTRCPTR                     pfnCPUMRCResumeGuestV86;
     206    /** The last RC/R0 return code. */
     207    RTINT                       iLastGZRc;
    206208#if HC_ARCH_BITS == 64
    207209    uint32_t                    u32Padding0; /**< Alignment padding. */
    208210#endif
     211    /** @}  */
    209212
    210213    /** VMM stack, pointer to the top of the stack in R3.
    … …  
    217220    RCPTRTYPE(uint8_t *)        pbEMTStackBottomRC;
    218221
    219     /** Pointer to the GC logger instance - GC Ptr.
     222    /** @name Logging
     223     * @{
     224     */
     225    /** Size of the allocated logger instance (pRCLoggerRC/pRCLoggerR3). */
     226    uint32_t                    cbRCLogger;
     227    /** Pointer to the RC logger instance - RC Ptr.
    220228     * This is NULL if logging is disabled. */
    221     RCPTRTYPE(PRTLOGGERRC)      pLoggerGC;
    222     /** Size of the allocated logger instance (pLoggerGC/pLoggerHC). */
    223     RTUINT                      cbLoggerGC;
    224     /** Pointer to the GC logger instance - HC Ptr.
     229    RCPTRTYPE(PRTLOGGERRC)      pRCLoggerRC;
     230    /** Pointer to the GC logger instance - R3 Ptr.
    225231     * This is NULL if logging is disabled. */
    226     R3PTRTYPE(PRTLOGGERRC)      pLoggerHC;
    227 
    228     /** Pointer to the R0 logger instance.
     232    R3PTRTYPE(PRTLOGGERRC)      pRCLoggerR3;
     233#ifdef VBOX_WITH_RC_RELEASE_LOGGING
     234    /** Size of the allocated release logger instance (pRCRelLoggerRC/pRCRelLoggerR3).
     235     * This may differ from cbRCLogger. */
     236    uint32_t                    cbRCRelLogger;
     237    /** Pointer to the GC release logger instance - RC Ptr. */
     238    RCPTRTYPE(PRTLOGGERRC)      pRCRelLoggerRC;
     239    /** Pointer to the GC release logger instance - R3 Ptr. */
     240    R3PTRTYPE(PRTLOGGERRC)      pRCRelLoggerR3;
     241#endif /* VBOX_WITH_RC_RELEASE_LOGGING */
     242    /** Pointer to the R0 logger instance - R3 Ptr.
    229243     * This is NULL if logging is disabled. */
    230     R3R0PTRTYPE(PVMMR0LOGGER)   pR0Logger;
    231 
    232 #ifdef VBOX_WITH_RC_RELEASE_LOGGING
    233     /** Pointer to the GC release logger instance - GC Ptr. */
    234     RCPTRTYPE(PRTLOGGERRC)      pRelLoggerGC;
    235     /** Size of the allocated release logger instance (pRelLoggerGC/pRelLoggerHC).
    236      * This may differ from cbLoggerGC. */
    237     RTUINT                      cbRelLoggerGC;
    238     /** Pointer to the GC release logger instance - HC Ptr. */
    239     R3PTRTYPE(PRTLOGGERRC)      pRelLoggerHC;
    240 #endif /* VBOX_WITH_RC_RELEASE_LOGGING */
     244    R3PTRTYPE(PVMMR0LOGGER)     pR0LoggerR3;
     245    /** Pointer to the R0 logger instance - R0 Ptr.
     246     * This is NULL if logging is disabled. */
     247    R0PTRTYPE(PVMMR0LOGGER)     pR0LoggerR0;
     248    /** @} */
    241249
    242250    /** Global VM critical section. */

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

    r13701 r13714  
    175175     * Register the EMT R0 logger instance.
    176176     */
    177     PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
     177    PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0LoggerR0;
    178178    if (pR0Logger)
    179179    {
    … …  
    489489            STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
    490490            register int rc;
    491             pVM->vmm.s.iLastGCRc = rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
     491            pVM->vmm.s.iLastGZRc = rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
    492492
    493493#ifdef VBOX_WITH_STATISTICS
    … …  
    548548
    549549            RTCCUINTREG fFlags = ASMIntDisableFlags();
    550             int rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
     550            int rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
    551551            /** @todo dispatch interrupts? */
    552552            ASMSetFlags(fFlags);
    … …  
    576576 *
    577577 * @param   pVM             The VM to operate on.
    578  *                          The return code is stored in pVM->vmm.s.iLastGCRc.
     578 *                          The return code is stored in pVM->vmm.s.iLastGZRc.
    579579 * @param   enmOperation    Which operation to execute.
    580580 * @remarks Assume called with interrupts _enabled_.
    … …  
    596596
    597597                TMNotifyStartOfExecution(pVM);
    598                 int rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
    599                 pVM->vmm.s.iLastGCRc = rc;
     598                int rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
     599                pVM->vmm.s.iLastGZRc = rc;
    600600                TMNotifyEndOfExecution(pVM);
    601601
    … …  
    614614            {
    615615                Assert(!pVM->vmm.s.fSwitcherDisabled);
    616                 pVM->vmm.s.iLastGCRc = VERR_NOT_SUPPORTED;
     616                pVM->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
    617617            }
    618618            break;
    … …  
    650650                rc = VINF_EM_RAW_INTERRUPT;
    651651            }
    652             pVM->vmm.s.iLastGCRc = rc;
     652            pVM->vmm.s.iLastGZRc = rc;
    653653#ifndef RT_OS_WINDOWS /** @todo check other hosts */
    654654            ASMSetFlags(uFlags);
    … …  
    666666         */
    667667        case VMMR0_DO_NOP:
    668             pVM->vmm.s.iLastGCRc = VINF_SUCCESS;
     668            pVM->vmm.s.iLastGZRc = VINF_SUCCESS;
    669669            break;
    670670
    … …  
    674674        default:
    675675            AssertMsgFailed(("%#x\n", enmOperation));
    676             pVM->vmm.s.iLastGCRc = VERR_NOT_SUPPORTED;
     676            pVM->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
    677677            break;
    678678    }
    … …  
    819819
    820820            RTCCUINTREG fFlags = ASMIntDisableFlags();
    821             int rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
     821            int rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
    822822            /** @todo dispatch interrupts? */
    823823            ASMSetFlags(fFlags);

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

    r13698 r13714  
    6969    CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32));  /* stack frame size */
    7070    CPUMPushHyper(pVM, GCPtrEP);                /* what to call */
    71     CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
     71    CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
    7272    rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    7373    if (RT_LIKELY(rc == VINF_SUCCESS))
    74         rc = pVM->vmm.s.iLastGCRc;
     74        rc = pVM->vmm.s.iLastGZRc;
    7575    return rc;
    7676}
    … …  
    106106    CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32));  /* stack frame size */
    107107    CPUMPushHyper(pVM, GCPtrEP);                /* what to call */
    108     CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
     108    CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
    109109    rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    110110    if (RT_LIKELY(rc == VINF_SUCCESS))
    111         rc = pVM->vmm.s.iLastGCRc;
     111        rc = pVM->vmm.s.iLastGZRc;
    112112    bool fDump = false;
    113113    if (rc != rcExpect)
    … …  
    340340        CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32));  /* stack frame size */
    341341        CPUMPushHyper(pVM, GCPtrEP);                /* what to call */
    342         CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
    343         Log(("trampoline=%x\n", pVM->vmm.s.pfnGCCallTrampoline));
     342        CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
     343        Log(("trampoline=%x\n", pVM->vmm.s.pfnCallTrampolineRC));
    344344
    345345        /*
    … …  
    354354            rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    355355            if (RT_LIKELY(rc == VINF_SUCCESS))
    356                 rc = pVM->vmm.s.iLastGCRc;
     356                rc = pVM->vmm.s.iLastGZRc;
    357357            if (VBOX_FAILURE(rc))
    358358            {
    … …  
    402402            CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32));    /* stack frame size */
    403403            CPUMPushHyper(pVM, GCPtrEP);                /* what to call */
    404             CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
     404            CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
    405405
    406406            uint64_t TickThisStart = ASMReadTSC();
    407407            rc = SUPCallVMMR0Fast(pVM->pVMR0, VMMR0_DO_RAW_RUN);
    408408            if (RT_LIKELY(rc == VINF_SUCCESS))
    409                 rc = pVM->vmm.s.iLastGCRc;
     409                rc = pVM->vmm.s.iLastGZRc;
    410410            uint64_t TickThisElapsed = ASMReadTSC() - TickThisStart;
    411411            if (VBOX_FAILURE(rc))
    … …  
    529529            CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR32));    /* stack frame size */
    530530            CPUMPushHyper(pVM, GCPtrEP);                /* what to call */
    531             CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
     531            CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnCallTrampolineRC);
    532532
    533533            CPUMQueryHyperCtxPtr(pVM, &pHyperCtx);

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

    r13701 r13714  
    826826    GEN_CHECK_OFF(VMM, cbCoreCode);
    827827    GEN_CHECK_OFF(VMM, HCPhysCoreCode);
    828     GEN_CHECK_OFF(VMM, pvHCCoreCodeR3);
    829     GEN_CHECK_OFF(VMM, pvHCCoreCodeR0);
    830     GEN_CHECK_OFF(VMM, pvGCCoreCode);
     828    GEN_CHECK_OFF(VMM, pvCoreCodeR3);
     829    GEN_CHECK_OFF(VMM, pvCoreCodeR0);
     830    GEN_CHECK_OFF(VMM, pvCoreCodeRC);
    831831    GEN_CHECK_OFF(VMM, enmSwitcher);
    832832    GEN_CHECK_OFF(VMM, aoffSwitchers);
    833833    GEN_CHECK_OFF(VMM, aoffSwitchers[1]);
    834     GEN_CHECK_OFF(VMM, pfnR0HostToGuest);
    835     GEN_CHECK_OFF(VMM, pfnGCGuestToHost);
    836     GEN_CHECK_OFF(VMM, pfnGCCallTrampoline);
    837     GEN_CHECK_OFF(VMM, pfnCPUMGCResumeGuest);
    838     GEN_CHECK_OFF(VMM, pfnCPUMGCResumeGuestV86);
    839     GEN_CHECK_OFF(VMM, iLastGCRc);
     834    GEN_CHECK_OFF(VMM, pfnHostToGuestR0);
     835    GEN_CHECK_OFF(VMM, pfnGuestToHostRC);
     836    GEN_CHECK_OFF(VMM, pfnCallTrampolineRC);
     837    GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuest);
     838    GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuestV86);
     839    GEN_CHECK_OFF(VMM, iLastGZRc);
    840840    GEN_CHECK_OFF(VMM, pbEMTStackR3);
    841841    GEN_CHECK_OFF(VMM, pbEMTStackRC);
    842842    GEN_CHECK_OFF(VMM, pbEMTStackBottomRC);
    843     GEN_CHECK_OFF(VMM, pLoggerGC);
    844     GEN_CHECK_OFF(VMM, pLoggerHC);
    845     GEN_CHECK_OFF(VMM, cbLoggerGC);
     843    GEN_CHECK_OFF(VMM, pRCLoggerRC);
     844    GEN_CHECK_OFF(VMM, pRCLoggerR3);
     845    GEN_CHECK_OFF(VMM, pR0LoggerR0);
     846    GEN_CHECK_OFF(VMM, pR0LoggerR3);
     847    GEN_CHECK_OFF(VMM, cbRCLogger);
    846848    GEN_CHECK_OFF(VMM, CritSectVMLock);
    847849    GEN_CHECK_OFF(VMM, pYieldTimer);
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