VirtualBox

Changeset 22890 in vbox


Ignore:
Timestamp:
Sep 9, 2009 11:11:31 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
52146
Message:

VM::cCPUs -> VM::cCpus so it matches all the other cCpus and aCpus members.

Location:
trunk
Files:
53 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/gvm.h

    r21217 r22890  
    4242typedef struct GVMCPU
    4343{
    44     /** VCPU id (0 - (pVM->cCPUs - 1). */
     44    /** VCPU id (0 - (pVM->cCpus - 1). */
    4545    VMCPUID         idCpu;
    4646
    … …  
    8484    PVM             pVM;
    8585    /** Number of Virtual CPUs, i.e. how many entries there are in aCpus.
    86      * Same same as PVM::cCPUs. */
     86     * Same same as VM::cCpus. */
    8787    uint32_t        cCpus;
    8888    uint32_t        padding;

  • trunk/include/VBox/vm.h

    r22889 r22890  
    698698    uint32_t                    hSelf;
    699699    /** Number of virtual CPUs. */
    700     uint32_t                    cCPUs;
     700    uint32_t                    cCpus;
    701701
    702702    /** Size of the VM structure including the VMCPU array. */

  • trunk/include/VBox/vm.mac

    r22888 r22890  
    5656    .pVMRC                  RTRCPTR_RES 1
    5757    .hSelf                  resd 1
    58     .cCPUs                  resd 1
     58    .cCpus                  resd 1
    5959    .cbSelf                 resd 1
    6060    .offVMCPU               resd 1

  • trunk/include/VBox/vmapi.h

    r22784 r22890  
    349349
    350350
    351 VMMR3DECL(int)  VMR3Create(uint32_t cCPUs, PFNVMATERROR pfnVMAtError, void *pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM, PVM *ppVM);
     351VMMR3DECL(int)  VMR3Create(uint32_t cCpus, PFNVMATERROR pfnVMAtError, void *pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM, PVM *ppVM);
    352352VMMR3DECL(int)  VMR3PowerOn(PVM pVM);
    353353VMMR3DECL(int)  VMR3Suspend(PVM pVM);

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

    r22793 r22890  
    137137
    138138    /* Calculate the offset from CPUMCPU to CPUM. */
    139     for (unsigned i=0;i<pVM->cCPUs;i++)
     139    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    140140    {
    141141        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    320320                                       | X86_CPUID_FEATURE_ECX_SSE3
    321321                                       /* Can't properly emulate monitor & mwait with guest SMP; force the guest to use hlt for idling VCPUs. */
    322                                        | ((pVM->cCPUs == 1) ? X86_CPUID_FEATURE_ECX_MONITOR : 0)
     322                                       | ((pVM->cCpus == 1) ? X86_CPUID_FEATURE_ECX_MONITOR : 0)
    323323                                       //| X86_CPUID_FEATURE_ECX_CPLDS - no CPL qualified debug store.
    324324                                       //| X86_CPUID_FEATURE_ECX_VMX   - not virtualized.
    … …  
    388388    pCPUM->aGuestCpuIdStd[1].ebx &= 0x0000ffff;
    389389#ifdef VBOX_WITH_MULTI_CORE
    390     if (pVM->cCPUs > 1)
     390    if (pVM->cCpus > 1)
    391391    {
    392392        /* If CPUID Fn0000_0001_EDX[HTT] = 1 then LogicalProcessorCount is the number of threads per CPU core times the number of CPU cores per processor */
    393         pCPUM->aGuestCpuIdStd[1].ebx |= (pVM->cCPUs << 16);
     393        pCPUM->aGuestCpuIdStd[1].ebx |= (pVM->cCpus << 16);
    394394        pCPUM->aGuestCpuIdStd[1].edx |= X86_CPUID_FEATURE_EDX_HTT;  /* necessary for hyper-threading *or* multi-core CPUs */
    395395    }
    … …  
    423423    pCPUM->aGuestCpuIdStd[4].eax = pCPUM->aGuestCpuIdStd[4].ebx = 0;
    424424#ifdef VBOX_WITH_MULTI_CORE
    425     if (    pVM->cCPUs > 1
     425    if (    pVM->cCpus > 1
    426426        &&  pVM->cpum.s.enmCPUVendor == CPUMCPUVENDOR_INTEL)
    427427    {
    428         AssertReturn(pVM->cCPUs <= 64, VERR_TOO_MANY_CPUS);
     428        AssertReturn(pVM->cCpus <= 64, VERR_TOO_MANY_CPUS);
    429429        /* One logical processor with possibly multiple cores. */
    430430        /* See  http://www.intel.com/Assets/PDF/appnote/241618.pdf p. 29 */
    431         pCPUM->aGuestCpuIdStd[4].eax |= ((pVM->cCPUs - 1) << 26);   /* 6 bits only -> 64 cores! */
     431        pCPUM->aGuestCpuIdStd[4].eax |= ((pVM->cCpus - 1) << 26);   /* 6 bits only -> 64 cores! */
    432432    }
    433433#endif
    … …  
    517517        pCPUM->aGuestCpuIdExt[8].ecx = 0;
    518518#ifdef VBOX_WITH_MULTI_CORE
    519         if (    pVM->cCPUs > 1
     519        if (    pVM->cCpus > 1
    520520            &&  pVM->cpum.s.enmCPUVendor == CPUMCPUVENDOR_AMD)
    521521        {
    522522            /* Legacy method to determine the number of cores. */
    523523            pCPUM->aGuestCpuIdExt[1].ecx |= X86_CPUID_AMD_FEATURE_ECX_CMPL;
    524             pCPUM->aGuestCpuIdExt[8].ecx |= (pVM->cCPUs - 1); /* NC: Number of CPU cores - 1; 8 bits */
     524            pCPUM->aGuestCpuIdExt[8].ecx |= (pVM->cCpus - 1); /* NC: Number of CPU cores - 1; 8 bits */
    525525
    526526        }
    … …  
    565565     * of processors from (cpuid(4).eax >> 26) + 1.
    566566     */
    567     if (pVM->cCPUs == 1)
     567    if (pVM->cCpus == 1)
    568568        pCPUM->aGuestCpuIdStd[4].eax = 0;
    569569
    … …  
    686686{
    687687    LogFlow(("CPUMR3Relocate\n"));
    688     for (unsigned i=0;i<pVM->cCPUs;i++)
    689     {
    690         PVMCPU pVCpu  = &pVM->aCpus[i];
     688    for (VMCPUID i = 0; i < pVM->cCpus; i++)
     689    {
    691690        /*
    692691         * Switcher pointers.
    693692         */
     693        PVMCPU pVCpu = &pVM->aCpus[i];
    694694        pVCpu->cpum.s.pHyperCoreRC = MMHyperCCToRC(pVM, pVCpu->cpum.s.pHyperCoreR3);
    695695        Assert(pVCpu->cpum.s.pHyperCoreRC != NIL_RTRCPTR);
    … …  
    726726{
    727727#ifdef VBOX_WITH_CRASHDUMP_MAGIC
    728     for (unsigned i=0;i<pVM->cCPUs;i++)
    729     {
    730         PVMCPU pVCpu = &pVM->aCpus[i];
    731         PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
     728    for (VMCPUID i = 0; i < pVM->cCpus; i++)
     729    {
     730        PVMCPU   pVCpu = &pVM->aCpus[i];
     731        PCPUMCTX pCtx  = CPUMQueryGuestCtxPtr(pVCpu);
    732732
    733733        memset(pVCpu->cpum.s.aMagic, 0, sizeof(pVCpu->cpum.s.aMagic));
    … …  
    825825VMMR3DECL(void) CPUMR3Reset(PVM pVM)
    826826{
    827     for (unsigned i=0;i<pVM->cCPUs;i++)
     827    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    828828    {
    829829        CPUMR3ResetCpu(&pVM->aCpus[i]);
    … …  
    853853     * Save.
    854854     */
    855     for (unsigned i=0;i<pVM->cCPUs;i++)
     855    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    856856    {
    857857        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    860860    }
    861861
    862     SSMR3PutU32(pSSM, pVM->cCPUs);
    863     for (unsigned i=0;i<pVM->cCPUs;i++)
     862    SSMR3PutU32(pSSM, pVM->cCpus);
     863    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    864864    {
    865865        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    10191019     * Restore.
    10201020     */
    1021     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     1021    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    10221022    {
    10231023        PVMCPU   pVCpu = &pVM->aCpus[i];
    … …  
    10461046        if (uVersion >= CPUM_SAVED_STATE_VERSION_VER2_1_NOMSR)
    10471047        {
    1048             int rc = SSMR3GetU32(pSSM, &pVM->cCPUs);
     1048            /** @todo r=bird: cCPUs: Why are we doing this?!? cCpus is a config value that
     1049             *        cannot be changed by a saved state. If the saved one differs we
     1050             *        fail. */
     1051            int rc = SSMR3GetU32(pSSM, &pVM->cCpus);
    10491052            AssertRCReturn(rc, rc);
    10501053        }
    10511054
    1052         if (    !pVM->cCPUs
    1053             ||  pVM->cCPUs > VMM_MAX_CPU_COUNT
     1055        if (    !pVM->cCpus
     1056            ||  pVM->cCpus > VMM_MAX_CPU_COUNT
    10541057            ||  (   uVersion == CPUM_SAVED_STATE_VERSION_VER2_0
    1055                  && pVM->cCPUs != 1))
     1058                 && pVM->cCpus != 1))
    10561059        {
    1057             AssertMsgFailed(("Unexpected number of VMCPUs (%d)\n", pVM->cCPUs));
     1060            AssertMsgFailed(("Unexpected number of VMCPUs (%u)\n", pVM->cCpus));
    10581061            return VERR_SSM_UNEXPECTED_DATA;
    10591062        }
    10601063
    1061         for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     1064        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    10621065        {
    10631066            SSMR3GetMem(pSSM, &pVM->aCpus[i].cpum.s.Guest, sizeof(pVM->aCpus[i].cpum.s.Guest));

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

    r21144 r22890  
    10751075    AssertReturn(pVM->dbgf.s.fAttached, VERR_DBGF_NOT_ATTACHED);
    10761076    AssertReturn(RTSemPongIsSpeaker(&pVM->dbgf.s.PingPong), VERR_SEM_OUT_OF_TURN);
    1077     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     1077    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    10781078
    10791079    /*

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

    r22112 r22890  
    103103VMMR3DECL(int) DBGFR3AddrFromSelOff(PVM pVM, VMCPUID idCpu, PDBGFADDRESS pAddress, RTSEL Sel, RTUINTPTR off)
    104104{
    105     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     105    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    106106
    107107    pAddress->Sel = Sel;
    … …  
    258258    AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
    259259    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_STATE);
    260     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     260    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    261261
    262262    /*
    … …  
    324324    AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
    325325    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_STATE);
    326     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     326    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    327327
    328328    /*
    … …  
    438438    AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
    439439    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_STATE);
    440     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     440    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    441441
    442442    /*

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

    r22112 r22890  
    551551{
    552552    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    553     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_CPU_ID);
     553    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    554554
    555555    /*

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

    r22105 r22890  
    122122VMMR3DECL(int) DBGFR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
    123123{
    124     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     124    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    125125
    126126    PVMREQ pReq;
    … …  
    207207VMMR3DECL(int) DBGFR3MemRead(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void *pvBuf, size_t cbRead)
    208208{
    209     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     209    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    210210    if ((pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK) == DBGFADDRESS_FLAGS_RING0)
    211211    {
    … …  
    295295        return VERR_INVALID_PARAMETER;
    296296    memset(pszBuf, 0, cchBuf);
    297     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     297    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    298298
    299299    /*
    … …  
    381381VMMR3DECL(int) DBGFR3MemWrite(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void const *pvBuf, size_t cbWrite)
    382382{
    383     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     383    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    384384
    385385    PVMREQ pReq;
    … …  
    481481VMMR3DECL(int) DBGFR3SelQueryInfo(PVM pVM, VMCPUID idCpu, RTSEL Sel, uint32_t fFlags, PDBGFSELINFO pSelInfo)
    482482{
    483     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_PARAMETER);
     483    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    484484    AssertReturn(!(fFlags & ~(DBGFSELQI_FLAGS_DT_GUEST | DBGFSELQI_FLAGS_DT_SHADOW | DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)), VERR_INVALID_PARAMETER);
    485485    AssertReturn(    (fFlags & (DBGFSELQI_FLAGS_DT_SHADOW | DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE))

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

    r22112 r22890  
    433433    *ppFirstFrame = NULL;
    434434    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    435     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_CPU_ID);
     435    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    436436    if (pAddrFrame)
    437437        AssertReturn(DBGFR3AddrIsValid(pVM, pAddrFrame), VERR_INVALID_PARAMETER);

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

    r22793 r22890  
    137137        return rc;
    138138
    139     for (unsigned i=0;i<pVM->cCPUs;i++)
     139    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    140140    {
    141141        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    428428{
    429429    LogFlow(("EMR3Relocate\n"));
    430     for (unsigned i=0;i<pVM->cCPUs;i++)
     430    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    431431    {
    432432        PVMCPU pVCpu = &pVM->aCpus[i];
    433 
    434433        if (pVCpu->em.s.pStatsR3)
    435434            pVCpu->em.s.pStatsRC = MMHyperR3ToRC(pVM, pVCpu->em.s.pStatsR3);
    … …  
    446445{
    447446    LogFlow(("EMR3Reset: \n"));
    448     for (unsigned i=0;i<pVM->cCPUs;i++)
     447    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    449448    {
    450449        PVMCPU pVCpu = &pVM->aCpus[i];
    451 
    452450        pVCpu->em.s.fForceRAW = false;
    453451    }
    … …  
    495493static DECLCALLBACK(int) emR3Save(PVM pVM, PSSMHANDLE pSSM)
    496494{
    497     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     495    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    498496    {
    499497        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    536534     * Load the saved state.
    537535     */
    538     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     536    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    539537    {
    540538        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    13651363        {
    13661364            /* Try not to cause deadlocks. */
    1367             if (    pVM->cCPUs == 1
     1365            if (    pVM->cCpus == 1
    13681366                ||  (   !PGMIsLockOwner(pVM)
    13691367                     && !IOMIsLockOwner(pVM))

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

    r22493 r22890  
    518518        uint32_t cpl = CPUMGetGuestCPL(pVCpu, CPUMCTX2CORE(pCtx));
    519519
    520         if (pVM->cCPUs == 1)
     520        if (pVM->cCpus == 1)
    521521        {
    522522            if (pCtx->eflags.Bits.u1VM)

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

    r22793 r22890  
    398398    LogFlow(("HWACCMR3InitCPU\n"));
    399399
    400     for (unsigned i=0;i<pVM->cCPUs;i++)
     400    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    401401    {
    402402        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    414414     * Statistics.
    415415     */
    416     for (unsigned i=0;i<pVM->cCPUs;i++)
     416    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    417417    {
    418418        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    573573#ifdef VBOX_WITH_CRASHDUMP_MAGIC
    574574    /* Magic marker for searching in crash dumps. */
    575     for (unsigned i=0;i<pVM->cCPUs;i++)
     575    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    576576    {
    577577        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    610610
    611611    /* Reinit the paging mode to force the new shadow mode. */
    612     for (unsigned i=0;i<pVM->cCPUs;i++)
     612    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    613613    {
    614614        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    648648            LogRel(("HWACCM: The host kernel does not support VT-x!\n"));
    649649#endif
    650             if (   pVM->cCPUs > 1
     650            if (   pVM->cCpus > 1
    651651                || VMMIsHwVirtExtForced(pVM))
    652652                return rc;
    … …  
    981981            AssertRelease(MSR_IA32_VMX_MISC_MAX_MSR(pVM->hwaccm.s.vmx.msr.vmx_misc) >= 512);
    982982
    983             for (unsigned i=0;i<pVM->cCPUs;i++)
     983            for (VMCPUID i = 0; i < pVM->cCpus; i++)
    984984            {
    985985                LogRel(("HWACCM: VCPU%d: MSR bitmap physaddr      = %RHp\n", i, pVM->aCpus[i].hwaccm.s.vmx.pMSRBitmapPhys));
    … …  
    12031203    if (VMR3GetState(pVM) == VMSTATE_LOADING)
    12041204    {
    1205         for (unsigned i=0;i<pVM->cCPUs;i++)
     1205        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    12061206        {
    12071207            PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    13511351VMMR3DECL(int) HWACCMR3TermCPU(PVM pVM)
    13521352{
    1353     for (unsigned i=0;i<pVM->cCPUs;i++)
     1353    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    13541354    {
    13551355        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    13941394        hwaccmR3DisableRawMode(pVM);
    13951395
    1396     for (unsigned i=0;i<pVM->cCPUs;i++)
     1396    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    13971397    {
    13981398        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    15351535        return VERR_NOT_SUPPORTED;
    15361536
    1537     if (pVM->cCPUs > 1)
     1537    if (pVM->cCpus > 1)
    15381538    {
    15391539        /* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */
    … …  
    23182318VMMR3DECL(void) HWACCMR3CheckError(PVM pVM, int iStatusCode)
    23192319{
    2320     for (unsigned i=0;i<pVM->cCPUs;i++)
     2320    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    23212321    {
    23222322        switch(iStatusCode)
    … …  
    23672367    Log(("hwaccmR3Save:\n"));
    23682368
    2369     for (unsigned i=0;i<pVM->cCPUs;i++)
     2369    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    23702370    {
    23712371        /*
    … …  
    24632463        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    24642464    }
    2465     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     2465    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    24662466    {
    24672467        rc = SSMR3GetU32(pSSM, &pVM->aCpus[i].hwaccm.s.Event.fPending);

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

    r21992 r22890  
    8080    if (rc == VERR_CFGM_NO_PARENT || rc == VERR_CFGM_VALUE_NOT_FOUND)
    8181    {
    82         if (pVM->cCPUs > 1)
    83             cbHyperHeap = _2M + pVM->cCPUs * _64K;
     82        if (pVM->cCpus > 1)
     83            cbHyperHeap = _2M + pVM->cCpus * _64K;
    8484        else
    8585            cbHyperHeap = VMMIsHwVirtExtForced(pVM)
    … …  
    109109         * Map the VM structure into the hypervisor space.
    110110         */
    111         AssertRelease(pVM->cbSelf == RT_UOFFSETOF(VM, aCpus[pVM->cCPUs]));
     111        AssertRelease(pVM->cbSelf == RT_UOFFSETOF(VM, aCpus[pVM->cCpus]));
    112112        RTGCPTR GCPtr;
    113113        rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0, RT_ALIGN_Z(pVM->cbSelf, PAGE_SIZE) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM", &GCPtr);
    … …  
    115115        {
    116116            pVM->pVMRC = (RTRCPTR)GCPtr;
    117             for (uint32_t i = 0; i < pVM->cCPUs; i++)
     117            for (VMCPUID i = 0; i < pVM->cCpus; i++)
    118118                pVM->aCpus[i].pVMRC = pVM->pVMRC;
    119119
    … …  
    320320            RTGCINTPTR offDelta = GCPtrNew - GCPtrOld;
    321321            pVM->pVMRC                          += offDelta;
    322             for (uint32_t i = 0; i < pVM->cCPUs; i++)
     322            for (VMCPUID i = 0; i < pVM->cCpus; i++)
    323323                pVM->aCpus[i].pVMRC              = pVM->pVMRC;
    324324

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

    r22793 r22890  
    563563    int rc;
    564564    R3PTRTYPE(void *) pHCPtr;
    565     Assert(pVM->cCPUs == 1);
     565    Assert(pVM->cCpus == 1);
    566566    PVMCPU pVCpu = VMMGetCpu0(pVM);
    567567
    … …  
    612612    RTGCUINTPTR32 pInstrGC = (uintptr_t)pCpu->apvUserData[2];
    613613    int           orgsize  = size;
    614     Assert(pVM->cCPUs == 1);
     614    Assert(pVM->cCpus == 1);
    615615    PVMCPU        pVCpu = VMMGetCpu0(pVM);
    616616
    … …  
    10871087    R3PTRTYPE(uint8_t *) pCurInstrHC = 0;
    10881088    int rc2;
    1089     Assert(pVM->cCPUs == 1);
     1089    Assert(pVM->cCpus == 1);
    10901090    PVMCPU pVCpu = VMMGetCpu0(pVM);
    10911091
    … …  
    13631363    uint32_t val[5];
    13641364    int      rc;
    1365     Assert(pVM->cCPUs == 1);
     1365    Assert(pVM->cCpus == 1);
    13661366    PVMCPU pVCpu = VMMGetCpu0(pVM);
    13671367
    … …  
    14311431    RTGCPHYS GCPhys = 0;
    14321432    uint64_t fFlags = 0;
    1433     Assert(pVM->cCPUs == 1 || !CSAMIsEnabled(pVM));
     1433    Assert(pVM->cCpus == 1 || !CSAMIsEnabled(pVM));
    14341434
    14351435    if (!CSAMIsEnabled(pVM))
    … …  
    16241624    int          rc;
    16251625    bool         ret;
    1626     Assert(pVM->cCPUs == 1);
     1626    Assert(pVM->cCpus == 1);
    16271627    PVMCPU pVCpu = VMMGetCpu0(pVM);
    16281628
    … …  
    17271727    int          rc;
    17281728    bool         fMonitorInvalidation;
    1729     Assert(pVM->cCPUs == 1);
     1729    Assert(pVM->cCpus == 1);
    17301730    PVMCPU pVCpu = VMMGetCpu0(pVM);
    17311731
    … …  
    18731873{
    18741874    PCSAMPAGEREC pPageRec;
    1875     Assert(pVM->cCPUs == 1);
     1875    Assert(pVM->cCpus == 1);
    18761876    PVMCPU pVCpu = VMMGetCpu0(pVM);
    18771877
    … …  
    21942194static int csamR3FlushDirtyPages(PVM pVM)
    21952195{
    2196     Assert(pVM->cCPUs == 1);
     2196    Assert(pVM->cCpus == 1);
    21972197    PVMCPU pVCpu = VMMGetCpu0(pVM);
    21982198
    … …  
    22452245static int csamR3FlushCodePages(PVM pVM)
    22462246{
    2247     Assert(pVM->cCPUs == 1);
     2247    Assert(pVM->cCpus == 1);
    22482248    PVMCPU pVCpu = VMMGetCpu0(pVM);
    22492249
    … …  
    22892289VMMR3DECL(int) CSAMR3CheckGates(PVM pVM, uint32_t iGate, uint32_t cGates)
    22902290{
    2291     Assert(pVM->cCPUs == 1);
     2291    Assert(pVM->cCpus == 1);
    22922292    PVMCPU      pVCpu = VMMGetCpu0(pVM);
    22932293    uint16_t    cbIDT;

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

    r22480 r22890  
    60056005    PVMCPU           pVCpu = VMMGetCpu0(pVM);
    60066006
    6007     Assert(pVM->cCPUs == 1);
     6007    Assert(pVM->cCpus == 1);
    60086008
    60096009    pNewEip   = 0;

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

    r22793 r22890  
    637637     * Save interrupt and DMA states.
    638638     */
    639     for (unsigned idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     639    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    640640    {
    641641        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    680680             ));
    681681#ifdef LOG_ENABLED
    682     for (unsigned idCpu=0;idCpu<pVM->cCPUs;idCpu++)
     682    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    683683    {
    684684        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    698698
    699699    /* Clear the FFs. */
    700     for (unsigned idCpu=0;idCpu<pVM->cCPUs;idCpu++)
     700    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    701701    {
    702702        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    741741     * Load the interrupt and DMA states.
    742742     */
    743     for (VMCPUID idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     743    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    744744    {
    745745        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    960960     * Clear all pending interrupts and DMA operations.
    961961     */
    962     for (unsigned idCpu=0;idCpu<pVM->cCPUs;idCpu++)
     962    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    963963    {
    964964        PVMCPU pVCpu = &pVM->aCpus[idCpu];

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

    r22723 r22890  
    23552355             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    23562356
    2357     if (pVM->cCPUs > 1)
     2357    if (pVM->cCpus > 1)
    23582358    {
    23592359        /* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */
    … …  
    23822382             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    23832383
    2384     if (pVM->cCPUs > 1)
     2384    if (pVM->cCpus > 1)
    23852385    {
    23862386        /* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */

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

    r20902 r22890  
    151151    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    152152
    153     AssertReturnVoid(idCpu < pVM->cCPUs);
     153    AssertReturnVoid(idCpu < pVM->cCpus);
    154154
    155155    LogFlow(("pdmR3ApicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT(%d) %d -> 1\n",
    … …  
    183183    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    184184
    185     AssertReturnVoid(idCpu < pVM->cCPUs);
     185    AssertReturnVoid(idCpu < pVM->cCpus);
    186186
    187187    LogFlow(("pdmR3ApicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT(%d) %d -> 0\n",

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

    r22793 r22890  
    11981198
    11991199    /* Init the per-CPU part. */
    1200     for (unsigned i=0;i<pVM->cCPUs;i++)
     1200    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    12011201    {
    12021202        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    13401340    if (RT_SUCCESS(rc))
    13411341    {
    1342         for (unsigned i=0;i<pVM->cCPUs;i++)
     1342        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    13431343        {
    13441344            PVMCPU pVCpu = &pVM->aCpus[i];
    1345 
    13461345            rc = PGMR3ChangeMode(pVM, pVCpu, PGMMODE_REAL);
    13471346            if (RT_FAILURE(rc))
    … …  
    14261425     * Force a recalculation of modes and switcher so everyone gets notified.
    14271426     */
    1428     for (unsigned i=0;i<pVM->cCPUs;i++)
     1427    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    14291428    {
    14301429        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    16741673     * Common - stats
    16751674     */
    1676     for (unsigned i=0;i<pVM->cCPUs;i++)
     1675    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    16771676    {
    16781677        PVMCPU  pVCpu = &pVM->aCpus[i];
    1679         PPGMCPU pPGM = &pVCpu->pgm.s;
     1678        PPGMCPU pPGM  = &pVCpu->pgm.s;
    16801679
    16811680#define PGM_REG_COUNTER(a, b, c) \
    … …  
    20092008
    20102009    /* Shadow, guest and both mode switch & relocation for each VCPU. */
    2011     for (unsigned i=0;i<pVM->cCPUs;i++)
     2010    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    20122011    {
    20132012        PVMCPU  pVCpu = &pVM->aCpus[i];
    … …  
    21802179     * Important to clean up the amd64 case.
    21812180     */
    2182     for (unsigned i=0;i<pVM->cCPUs;i++)
     2181    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    21832182    {
    21842183        PVMCPU  pVCpu = &pVM->aCpus[i];
    2185 
    21862184        rc = PGM_GST_PFN(Exit, pVCpu)(pVCpu);
    21872185        AssertRC(rc);
    … …  
    21962194     * Switch mode back to real mode. (before resetting the pgm pool!)
    21972195     */
    2198     for (unsigned i=0;i<pVM->cCPUs;i++)
     2196    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    21992197    {
    22002198        PVMCPU  pVCpu = &pVM->aCpus[i];
    … …  
    22112209    pgmR3PoolReset(pVM);
    22122210
    2213     for (unsigned i=0;i<pVM->cCPUs;i++)
     2211    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    22142212    {
    22152213        PVMCPU  pVCpu = &pVM->aCpus[i];
    … …  
    24392437    SSMR3PutStruct(pSSM, pPGM, &s_aPGMFields[0]);
    24402438
    2441     for (i=0;i<pVM->cCPUs;i++)
    2442     {
    2443         PVMCPU pVCpu = &pVM->aCpus[i];
    2444 
     2439    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
     2440    {
     2441        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    24452442        SSMR3PutStruct(pSSM, &pVCpu->pgm.s, &s_aPGMCpuFields[0]);
    24462443    }
    … …  
    26902687        AssertLogRelRCReturn(rc, rc);
    26912688
    2692         for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     2689        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    26932690        {
    26942691            rc = SSMR3GetStruct(pSSM, &pVM->aCpus[i].pgm.s, &s_aPGMCpuFields[0]);
    … …  
    26982695    else if (uVersion >= PGM_SAVED_STATE_VERSION_RR_DESC)
    26992696    {
    2700         AssertRelease(pVM->cCPUs == 1);
     2697        AssertRelease(pVM->cCpus == 1);
    27012698
    27022699        PGMOLD pgmOld;
    … …  
    27142711    else
    27152712    {
    2716         AssertRelease(pVM->cCPUs == 1);
     2713        AssertRelease(pVM->cCpus == 1);
    27172714
    27182715        SSMR3GetBool(pSSM,      &pPGM->fMappingsFixed);
    … …  
    30663063         * We require a full resync now.
    30673064         */
    3068         for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     3065        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    30693066        {
    30703067            PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    30773074        pgmR3HandlerPhysicalUpdateAll(pVM);
    30783075
    3079         for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     3076        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    30803077        {
    30813078            PVMCPU pVCpu = &pVM->aCpus[i];

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

    r20796 r22890  
    214214    }
    215215
    216     for (unsigned i=0;i<pVM->cCPUs;i++)
     216    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    217217    {
    218218        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    271271            MMHyperFree(pVM, pCur);
    272272
    273             for (unsigned i=0;i<pVM->cCPUs;i++)
     273            for (VMCPUID i = 0; i < pVM->cCpus; i++)
    274274            {
    275275                PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    521521
    522522    /* Only applies to VCPU 0 as we don't support SMP guests with raw mode. */
    523     Assert(pVM->cCPUs == 1);
     523    Assert(pVM->cCpus == 1);
    524524
    525525    PVMCPU pVCpu = &pVM->aCpus[0];
    … …  
    653653    pVM->pgm.s.cbMappingFixed    = cb;
    654654
    655     for (unsigned i=0;i<pVM->cCPUs;i++)
     655    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    656656    {
    657657        PVMCPU pVCpu = &pVM->aCpus[i];
    658         pVCpu->pgm.s.fSyncFlags       &= ~PGM_SYNC_MONITOR_CR3;
     658        pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
    659659        VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
    660660    }
    … …  
    689689    pVM->pgm.s.GCPtrMappingFixed = MM_HYPER_AREA_ADDRESS;
    690690    pVM->pgm.s.cbMappingFixed    = cb;
    691     for (unsigned i=0;i<pVM->cCPUs;i++)
     691    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    692692    {
    693693        PVMCPU pVCpu = &pVM->aCpus[i];
    694 
    695         pVCpu->pgm.s.fSyncFlags       &= ~PGM_SYNC_MONITOR_CR3;
     694        pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
    696695        VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
    697696    }
    … …  
    718717    pVM->pgm.s.GCPtrMappingFixed = 0;
    719718    pVM->pgm.s.cbMappingFixed    = 0;
    720     for (unsigned i=0;i<pVM->cCPUs;i++)
     719    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    721720    {
    722721        PVMCPU pVCpu = &pVM->aCpus[i];
    723 
    724722        VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
    725723    }
    … …  
    11611159
    11621160    /* Raw mode only which implies one VCPU. */
    1163     Assert(pVM->cCPUs == 1);
     1161    Assert(pVM->cCpus == 1);
    11641162
    11651163    pMapping->aGCPtrConflicts[pMapping->cConflicts & (PGMMAPPING_CONFLICT_MAX-1)] = GCPtrOldMapping;
    … …  
    12371235
    12381236    /* Raw mode only which implies one VCPU. */
    1239     Assert(pVM->cCPUs == 1);
     1237    Assert(pVM->cCpus == 1);
    12401238    PVMCPU pVCpu = VMMGetCpu(pVM);
    12411239

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

    r22793 r22890  
    398398    LogFlow(("SELMR3Relocate\n"));
    399399
    400     for (unsigned i=0;i<pVM->cCPUs;i++)
     400    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    401401    {
    402402        PVMCPU pVCpu = &pVM->aCpus[i];

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

    r22808 r22890  
    201201
    202202    pVM->tm.s.offVM = RT_OFFSETOF(VM, tm.s);
    203     pVM->tm.s.idTimerCpu = pVM->cCPUs - 1; /* The last CPU. */
     203    pVM->tm.s.idTimerCpu = pVM->cCpus - 1; /* The last CPU. */
    204204    pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL].enmClock        = TMCLOCK_VIRTUAL;
    205205    pVM->tm.s.paTimerQueuesR3[TMCLOCK_VIRTUAL].u64Expire       = INT64_MAX;
    … …  
    627627#endif /* VBOX_WITH_STATISTICS */
    628628
    629     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     629    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    630630        STAMR3RegisterF(pVM, &pVM->aCpus[i].tm.s.offTSCRawSrc, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS, "TSC offset relative the raw source", "/TM/TSC/offCPU%u", i);
    631631
    … …  
    10461046    LogFlow(("tmR3Save:\n"));
    10471047#ifdef VBOX_STRICT
    1048     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     1048    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    10491049    {
    10501050        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    10721072    SSMR3PutU64(pSSM, TMCLOCK_FREQ_REAL);
    10731073
    1074     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     1074    /* the cpu tick clock. */
     1075    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    10751076    {
    10761077        PVMCPU pVCpu = &pVM->aCpus[i];
    1077 
    1078         /* the cpu tick clock. */
    10791078        SSMR3PutU64(pSSM, TMCpuTickGet(pVCpu));
    10801079    }
    … …  
    10981097    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    10991098#ifdef VBOX_STRICT
    1100     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     1099    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    11011100    {
    11021101        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    11611160
    11621161    /* the cpu tick clock. */
    1163     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     1162    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    11641163    {
    11651164        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    17481747     * (fRunningQueues is only used as an indicator.)
    17491748     */
    1750     Assert(pVM->tm.s.idTimerCpu < pVM->cCPUs);
     1749    Assert(pVM->tm.s.idTimerCpu < pVM->cCpus);
    17511750    PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
    17521751    if (VMMGetCpu(pVM) != pVCpuDst)
    17531752    {
    1754         Assert(pVM->cCPUs > 1);
     1753        Assert(pVM->cCpus > 1);
    17551754        return;
    17561755    }
    … …  
    26862685    const uint64_t u64Real        = TMRealGet(pVM);
    26872686
    2688     for (unsigned i = 0; i < pVM->cCPUs; i++)
     2687    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    26892688    {
    26902689        PVMCPU   pVCpu  = &pVM->aCpus[i];

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

    r22793 r22890  
    467467    pVM->trpm.s.offTRPMCPU         = RT_OFFSETOF(VM, aCpus[0].trpm) - RT_OFFSETOF(VM, trpm);
    468468
    469     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     469    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    470470    {
    471471        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    744744     * Reinitialize other members calling the relocator to get things right.
    745745     */
    746     for (unsigned i=0;i<pVM->cCPUs;i++)
     746    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    747747    {
    748748        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    776776     * Active and saved traps.
    777777     */
    778     for (unsigned i=0;i<pVM->cCPUs;i++)
     778    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    779779    {
    780780        PTRPMCPU pTrpmCpu = &pVM->aCpus[i].trpm.s;
    781 
    782781        SSMR3PutUInt(pSSM,      pTrpmCpu->uActiveVector);
    783782        SSMR3PutUInt(pSSM,      pTrpmCpu->enmActiveType);
    … …  
    849848    if (uVersion == TRPM_SAVED_STATE_VERSION)
    850849    {
    851         for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     850        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    852851        {
    853852            PTRPMCPU pTrpmCpu = &pVM->aCpus[i].trpm.s;
    … …  
    12371236{
    12381237    /* Only valid in raw mode which implies 1 VCPU */
    1239     Assert(PATMIsEnabled(pVM) && pVM->cCPUs == 1);
     1238    Assert(PATMIsEnabled(pVM) && pVM->cCpus == 1);
    12401239    PVMCPU pVCpu = &pVM->aCpus[0];
    12411240
    … …  
    13601359{
    13611360    /* Only valid in raw mode which implies 1 VCPU */
    1362     Assert(PATMIsEnabled(pVM) && pVM->cCPUs == 1);
     1361    Assert(PATMIsEnabled(pVM) && pVM->cCpus == 1);
    13631362    PVMCPU pVCpu = &pVM->aCpus[0];
    13641363

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

    r22885 r22890  
    124124*   Internal Functions                                                         *
    125125*******************************************************************************/
    126 static int               vmR3CreateUVM(uint32_t cCPUs, PUVM *ppUVM);
    127 static int               vmR3CreateU(PUVM pUVM, uint32_t cCPUs, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM);
     126static int               vmR3CreateUVM(uint32_t cCpus, PUVM *ppUVM);
     127static int               vmR3CreateU(PUVM pUVM, uint32_t cCpus, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM);
    128128static int               vmR3InitRing3(PVM pVM, PUVM pUVM);
    129129static int               vmR3InitVMCpu(PVM pVM);
    … …  
    182182 * @returns 0 on success.
    183183 * @returns VBox error code on failure.
    184  * @param   cCPUs               Number of virtual CPUs for the new VM.
     184 * @param   cCpus               Number of virtual CPUs for the new VM.
    185185 * @param   pfnVMAtError        Pointer to callback function for setting VM
    186186 *                              errors. This was added as an implicit call to
    … …  
    195195 * @param   ppVM                Where to store the 'handle' of the created VM.
    196196 */
    197 VMMR3DECL(int)   VMR3Create(uint32_t cCPUs, PFNVMATERROR pfnVMAtError, void *pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM, PVM *ppVM)
    198 {
    199     LogFlow(("VMR3Create: cCPUs=%RU32 pfnVMAtError=%p pvUserVM=%p  pfnCFGMConstructor=%p pvUserCFGM=%p ppVM=%p\n", cCPUs, pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM, ppVM));
     197VMMR3DECL(int)   VMR3Create(uint32_t cCpus, PFNVMATERROR pfnVMAtError, void *pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM, PVM *ppVM)
     198{
     199    LogFlow(("VMR3Create: cCpus=%RU32 pfnVMAtError=%p pvUserVM=%p  pfnCFGMConstructor=%p pvUserCFGM=%p ppVM=%p\n",
     200             cCpus, pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM, ppVM));
    200201
    201202    /*
    … …  
    216217     * Validate input.
    217218     */
    218     AssertLogRelMsgReturn(cCPUs > 0 && cCPUs <= VMM_MAX_CPU_COUNT, ("%RU32\n", cCPUs), VERR_TOO_MANY_CPUS);
     219    AssertLogRelMsgReturn(cCpus > 0 && cCpus <= VMM_MAX_CPU_COUNT, ("%RU32\n", cCpus), VERR_TOO_MANY_CPUS);
    219220
    220221    /*
    … …  
    223224     */
    224225    PUVM pUVM = NULL;                   /* shuts up gcc */
    225     int rc = vmR3CreateUVM(cCPUs, &pUVM);
     226    int rc = vmR3CreateUVM(cCpus, &pUVM);
    226227    if (RT_FAILURE(rc))
    227228        return rc;
    … …  
    246247            PVMREQ pReq;
    247248            rc = VMR3ReqCallU(pUVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3CreateU, 4,
    248                               pUVM, cCPUs, pfnCFGMConstructor, pvUserCFGM);
     249                              pUVM, cCpus, pfnCFGMConstructor, pvUserCFGM);
    249250            if (RT_SUCCESS(rc))
    250251            {
    … …  
    555556        AssertRelease(pVM->pVMR0 == CreateVMReq.pVMR0);
    556557        AssertRelease(pVM->pSession == pUVM->vm.s.pSession);
    557         AssertRelease(pVM->cCPUs == cCpus);
     558        AssertRelease(pVM->cCpus == cCpus);
    558559        AssertRelease(pVM->offVMCPU == RT_UOFFSETOF(VM, aCpus));
    559560
    560         Log(("VMR3Create: Created pUVM=%p pVM=%p pVMR0=%p hSelf=%#x cCPUs=%RU32\n",
    561              pUVM, pVM, pVM->pVMR0, pVM->hSelf, pVM->cCPUs));
     561        Log(("VMR3Create: Created pUVM=%p pVM=%p pVMR0=%p hSelf=%#x cCpus=%RU32\n",
     562             pUVM, pVM, pVM->pVMR0, pVM->hSelf, pVM->cCpus));
    562563
    563564        /*
    … …  
    566567        pVM->pUVM = pUVM;
    567568
    568         for (uint32_t i = 0; i < pVM->cCPUs; i++)
     569        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    569570        {
    570571            pVM->aCpus[i].pUVCpu        = &pUVM->aCpus[i];
    … …  
    610611                if (RT_SUCCESS(rc) && cCPUsCfg != cCpus)
    611612                {
    612                     AssertLogRelMsgFailed(("Configuration error: \"NumCPUs\"=%RU32 and VMR3CreateVM::cCPUs=%RU32 does not match!\n",
     613                    AssertLogRelMsgFailed(("Configuration error: \"NumCPUs\"=%RU32 and VMR3CreateVM::cCpus=%RU32 does not match!\n",
    613614                                           cCPUsCfg, cCpus));
    614615                    rc = VERR_INVALID_PARAMETER;
    … …  
    756757     * Register the other EMTs with GVM.
    757758     */
    758     for (VMCPUID idCpu = 1; idCpu < pVM->cCPUs; idCpu++)
     759    for (VMCPUID idCpu = 1; idCpu < pVM->cCpus; idCpu++)
    759760    {
    760761        PVMREQ pReq;
    … …  
    789790        STAM_REG(pVM, &pVM->StatSwitcherRstrRegs,   STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/RstrRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
    790791
    791         for (unsigned iCpu=0;iCpu<pVM->cCPUs;iCpu++)
     792        for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    792793        {
    793             rc = STAMR3RegisterF(pVM, &pUVM->aCpus[iCpu].vm.s.StatHaltYield,  STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling halted state yielding.", "/PROF/VM/CPU%d/Halt/Yield", iCpu);
     794            rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltYield,  STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling halted state yielding.", "/PROF/VM/CPU%d/Halt/Yield", idCpu);
    794795            AssertRC(rc);
    795             rc = STAMR3RegisterF(pVM, &pUVM->aCpus[iCpu].vm.s.StatHaltBlock,  STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling halted state blocking.", "/PROF/VM/CPU%d/Halt/Block", iCpu);
     796            rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltBlock,  STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling halted state blocking.", "/PROF/VM/CPU%d/Halt/Block", idCpu);
    796797            AssertRC(rc);
    797             rc = STAMR3RegisterF(pVM, &pUVM->aCpus[iCpu].vm.s.StatHaltTimers, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling halted state timer tasks.", "/PROF/VM/CPU%d/Halt/Timers", iCpu);
     798            rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltTimers, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling halted state timer tasks.", "/PROF/VM/CPU%d/Halt/Timers", idCpu);
    798799            AssertRC(rc);
    799800        }
    … …  
    17881789
    17891790        /* Inform all other VCPUs too. */
    1790         for (VMCPUID idCpu = 1; idCpu < pVM->cCPUs; idCpu++)
     1791        for (VMCPUID idCpu = 1; idCpu < pVM->cCpus; idCpu++)
    17911792        {
    17921793            /*

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

    r22793 r22890  
    248248#endif
    249249
    250     for (VMCPUID idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     250    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    251251    {
    252252        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    306306
    307307# ifdef VBOX_WITH_R0_LOGGING
    308         for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     308        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    309309        {
    310310            PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    404404
    405405#ifdef VBOX_WITH_STATISTICS
    406     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     406    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    407407    {
    408408        STAMR3RegisterF(pVM, &pVM->aCpus[i].vmm.s.CallRing3JmpBufR0.cbUsedMax,  STAMTYPE_U32_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,      "Max amount of stack used.", "/VMM/Stack/CPU%u/Max", i);
    … …  
    437437    int rc = VINF_SUCCESS;
    438438
    439     for (VMCPUID idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     439    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    440440    {
    441441        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    559559        return VINF_SUCCESS;
    560560
    561     AssertReturn(pVM->cCPUs == 1, VERR_RAW_MODE_INVALID_SMP);
     561    AssertReturn(pVM->cCpus == 1, VERR_RAW_MODE_INVALID_SMP);
    562562
    563563    /*
    … …  
    681681     * Make the two stack guard pages present again.
    682682     */
    683     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     683    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    684684    {
    685685        MMR3HyperSetGuard(pVM, pVM->aCpus[i].vmm.s.pbEMTStackR3 - PAGE_SIZE,      PAGE_SIZE, false /*fSet*/);
    … …  
    728728     * The stack.
    729729     */
    730     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     730    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    731731    {
    732732        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    814814     * in ring-0. Only initialize it once.
    815815     */
    816     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     816    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    817817    {
    818818        PVMCPU       pVCpu = &pVM->aCpus[i];
    … …  
    922922     * be running. This avoids breaking the saved state version. :-)
    923923     */
    924     for (VMCPUID i = 1; i < pVM->cCPUs; i++)
     924    for (VMCPUID i = 1; i < pVM->cCpus; i++)
    925925        SSMR3PutBool(pSSM, VMCPUSTATE_IS_STARTED(VMCPU_GET_STATE(&pVM->aCpus[i])));
    926926
    … …  
    969969    /* Restore the VMCPU states. VCPU 0 is always started. */
    970970    VMCPU_SET_STATE(&pVM->aCpus[0], VMCPUSTATE_STARTED);
    971     for (VMCPUID i = 1; i < pVM->cCPUs; i++)
     971    for (VMCPUID i = 1; i < pVM->cCpus; i++)
    972972    {
    973973        bool fStarted;
    … …  
    11291129    Log2(("VMMR3RawRunGC: (cs:eip=%04x:%08x)\n", CPUMGetGuestCS(pVCpu), CPUMGetGuestEIP(pVCpu)));
    11301130
    1131     AssertReturn(pVM->cCPUs == 1, VERR_RAW_MODE_INVALID_SMP);
     1131    AssertReturn(pVM->cCpus == 1, VERR_RAW_MODE_INVALID_SMP);
    11321132
    11331133    /*
    … …  
    12891289VMMR3DECL(void) VMMR3SendSipi(PVM pVM, VMCPUID idCpu,  uint32_t uVector)
    12901290{
    1291     AssertReturnVoid(idCpu < pVM->cCPUs);
     1291    AssertReturnVoid(idCpu < pVM->cCpus);
    12921292
    12931293    PVMREQ pReq;
    … …  
    13051305VMMR3DECL(void) VMMR3SendInitIpi(PVM pVM, VMCPUID idCpu)
    13061306{
    1307     AssertReturnVoid(idCpu < pVM->cCPUs);
     1307    AssertReturnVoid(idCpu < pVM->cCpus);
    13081308
    13091309    PVMREQ pReq;
    … …  
    13791379
    13801380    /* Shortcut for the uniprocessor case. */
    1381     if (pVM->cCPUs == 1)
     1381    if (pVM->cCpus == 1)
    13821382        return pfnHandler(pVM, pvUser);
    13831383
    13841384    RTCritSectEnter(&pVM->vmm.s.CritSectSync);
    1385     for (VMCPUID idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     1385    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    13861386    {
    13871387        if (idCpu != pVCpu->idCpu)
    … …  
    13931393    }
    13941394    /* Wait until all other VCPUs are waiting for us. */
    1395     while (RTCritSectGetWaiters(&pVM->vmm.s.CritSectSync) != (int32_t)(pVM->cCPUs - 1))
     1395    while (RTCritSectGetWaiters(&pVM->vmm.s.CritSectSync) != (int32_t)(pVM->cCpus - 1))
    13961396        RTThreadSleep(1);
    13971397
    … …  
    14101410{
    14111411    uint32_t cReturned = ASMAtomicIncU32(&pVM->vmm.s.cRendezvousEmtsReturned);
    1412     if (cReturned == pVM->cCPUs - 1U)
     1412    if (cReturned == pVM->cCpus - 1U)
    14131413    {
    14141414        int rc = RTSemEventSignal(pVM->vmm.s.hEvtRendezvousDoneCaller);
    … …  
    14381438     */
    14391439    uint32_t cEntered = ASMAtomicIncU32(&pVM->vmm.s.cRendezvousEmtsEntered);
    1440     if (cEntered != pVM->cCPUs)
     1440    if (cEntered != pVM->cCpus)
    14411441    {
    14421442        if ((fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) == VMMEMTRENDEZVOUS_FLAGS_TYPE_ONE_BY_ONE)
    … …  
    15141514     */
    15151515    uint32_t cDone = ASMAtomicIncU32(&pVM->vmm.s.cRendezvousEmtsDone);
    1516     if (    cDone != pVM->cCPUs
     1516    if (    cDone != pVM->cCpus
    15171517        &&  (fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) != VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE)
    15181518    {
    … …  
    15871587
    15881588    int rc;
    1589     if (pVM->cCPUs == 1)
     1589    if (pVM->cCpus == 1)
    15901590        /*
    15911591         * Shortcut for the single EMT case.
    … …  
    17061706{
    17071707    /* Raw mode implies 1 VCPU. */
    1708     AssertReturn(pVM->cCPUs == 1, VERR_RAW_MODE_INVALID_SMP);
     1708    AssertReturn(pVM->cCpus == 1, VERR_RAW_MODE_INVALID_SMP);
    17091709    PVMCPU pVCpu = &pVM->aCpus[0];
    17101710
    … …  
    18321832{
    18331833    Log(("VMMR3ResumeHyper: eip=%RRv esp=%RRv\n", CPUMGetHyperEIP(pVCpu), CPUMGetHyperESP(pVCpu)));
    1834     AssertReturn(pVM->cCPUs == 1, VERR_RAW_MODE_INVALID_SMP);
     1834    AssertReturn(pVM->cCpus == 1, VERR_RAW_MODE_INVALID_SMP);
    18351835
    18361836    /*
    … …  
    21092109     * Per CPU flags.
    21102110     */
    2111     for (VMCPUID i = 0; i < pVM->cCPUs; i++)
     2111    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    21122112    {
    21132113        const uint32_t fLocalForcedActions = pVM->aCpus[i].fLocalForcedActions;

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

    r22070 r22890  
    10731073
    10741074    if (    iLeaf == 1
    1075         &&  pVM->cCPUs > 1)
     1075        &&  pVM->cCpus > 1)
    10761076    {
    10771077        /* Bits 31-24: Initial APIC ID */
    … …  
    13111311            break;
    13121312    }
    1313     for (unsigned i=0;i<pVM->cCPUs;i++)
     1313    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    13141314    {
    13151315        PVMCPU pVCpu = &pVM->aCpus[i];
    1316 
    13171316        pVCpu->cpum.s.fChanged |= CPUM_CHANGED_CPUID;
    13181317    }
    … …  
    14311430            break;
    14321431    }
    1433     for (unsigned i=0;i<pVM->cCPUs;i++)
     1432    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    14341433    {
    14351434        PVMCPU pVCpu = &pVM->aCpus[i];
    1436 
    14371435        pVCpu->cpum.s.fChanged |= CPUM_CHANGED_CPUID;
    14381436    }

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

    r20981 r22890  
    116116    VMCPUID idCurCpu = VMMGetCpuId(pVM);
    117117
    118     for (unsigned idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     118    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    119119    {
    120120        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    154154VMMDECL(int) HWACCMFlushTLBOnAllVCpus(PVM pVM)
    155155{
    156     if (pVM->cCPUs == 1)
     156    if (pVM->cCpus == 1)
    157157        return HWACCMFlushTLB(&pVM->aCpus[0]);
    158158
    159159    VMCPUID idThisCpu = VMMGetCpuId(pVM);
    160160
    161     for (unsigned idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     161    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    162162    {
    163163        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    231231        VMCPUID idThisCpu = VMMGetCpuId(pVM);
    232232
    233         for (unsigned idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     233        for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    234234        {
    235235            PVMCPU pVCpu = &pVM->aCpus[idCpu];

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

    r22493 r22890  
    5050int iomLock(PVM pVM)
    5151{
    52     Assert(pVM->cCPUs == 1 || !PGMIsLockOwner(pVM));
     52    Assert(pVM->cCpus == 1 || !PGMIsLockOwner(pVM));
    5353    int rc = PDMCritSectEnter(&pVM->iom.s.EmtLock, VERR_SEM_BUSY);
    5454    return rc;

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

    r22039 r22890  
    493493    PVM pVM = pCritSect->s.CTX_SUFF(pVM);
    494494    AssertPtr(pVM);
    495     Assert(idCpu < pVM->cCPUs);
     495    Assert(idCpu < pVM->cCpus);
    496496    return pCritSect->s.Core.NativeThreadOwner == pVM->aCpus[idCpu].hNativeThread
    497497        && (pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK) == 0;

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

    r22545 r22890  
    460460# ifdef IN_RING0
    461461    /* Note: hack alert for difficult to reproduce problem. */
    462     if (    pVM->cCPUs > 1
     462    if (    pVM->cCpus > 1
    463463        &&  rc == VERR_PAGE_TABLE_NOT_PRESENT)
    464464    {
    … …  
    25182518
    25192519    /* Only applies to raw mode -> 1 VPCU */
    2520     Assert(pVM->cCPUs == 1);
     2520    Assert(pVM->cCpus == 1);
    25212521    PVMCPU pVCpu = &pVM->aCpus[0];
    25222522

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

    r22600 r22890  
    856856                        uint64_t fPageShw;
    857857                        rc = PGMShwGetPage(pVCpu, pvFault, &fPageShw, NULL);
    858                         AssertMsg((RT_SUCCESS(rc) && (fPageShw & X86_PTE_RW)) || pVM->cCPUs > 1 /* new monitor can be installed/page table flushed between the trap exit and PGMTrap0eHandler */, ("rc=%Rrc fPageShw=%RX64\n", rc, fPageShw));
     858                        AssertMsg((RT_SUCCESS(rc) && (fPageShw & X86_PTE_RW)) || pVM->cCpus > 1 /* new monitor can be installed/page table flushed between the trap exit and PGMTrap0eHandler */, ("rc=%Rrc fPageShw=%RX64\n", rc, fPageShw));
    859859#   endif /* VBOX_STRICT */
    860860                        STAM_PROFILE_STOP(&pVCpu->pgm.s.StatRZTrap0eTimeOutOfSync, c);
    … …  
    17291729    if (!PdeDst.n.u1Present)
    17301730    {
    1731         AssertMsg(pVM->cCPUs > 1, ("%Unexpected missing PDE p=%llx\n", pPdeDst, (uint64_t)PdeDst.u));
     1731        AssertMsg(pVM->cCpus > 1, ("%Unexpected missing PDE p=%llx\n", pPdeDst, (uint64_t)PdeDst.u));
    17321732        Log(("CPU%d: SyncPage: Pde at %RGv changed behind our back!\n", GCPtrPage));
    17331733        return VINF_SUCCESS;    /* force the instruction to be executed again. */
    … …  
    22552255                else
    22562256                /* Check for stale TLB entry; only applies to the SMP guest case. */
    2257                 if (    pVM->cCPUs > 1
     2257                if (    pVM->cCpus > 1
    22582258                    &&  pPdeDst->n.u1Write
    22592259                    &&  pPdeDst->n.u1Accessed)
    … …  
    23952395                        else
    23962396                        /* Check for stale TLB entry; only applies to the SMP guest case. */
    2397                         if (    pVM->cCPUs > 1
     2397                        if (    pVM->cCpus > 1
    23982398                            &&  pPteDst->n.u1Write == 1
    23992399                            &&  pPteDst->n.u1Accessed == 1)
    … …  
    44714471
    44724472    /* Clean up the old CR3 root. */
    4473     if (    pOldShwPageCR3 
     4473    if (    pOldShwPageCR3
    44744474        &&  pOldShwPageCR3 != pNewShwPageCR3    /* @todo can happen due to incorrect syncing between REM & PGM; find the real cause */)
    44754475    {

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

    r20374 r22890  
    484484    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3HandlerVirtualUpdate), a);
    485485
    486     for (unsigned i=0;i<pVM->cCPUs;i++)
     486    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    487487    {
    488488        PGMHVUSTATE State;
    … …  
    509509        RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, pgmHandlerVirtualResetOne, pVM);
    510510
    511         for (unsigned i=0;i<pVM->cCPUs;i++)
     511        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    512512        {
    513513            PVMCPU pVCpu = &pVM->aCpus[i];

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

    r22756 r22890  
    15421542    for (unsigned iPage = 0; iPage < pVirt->cPages; iPage++, GCPtr += PAGE_SIZE)
    15431543    {
    1544         for (unsigned i=0;i<pVM->cCPUs;i++)
     1544        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    15451545        {
    15461546            PVMCPU pVCpu = &pVM->aCpus[i];

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

    r21964 r22890  
    222222
    223223    if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
    224         ||  pVM->cCPUs > 1)
     224        ||  pVM->cCpus > 1)
    225225        return;
    226226
    … …  
    390390
    391391    if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
    392         ||  pVM->cCPUs > 1)
     392        ||  pVM->cCpus > 1)
    393393        return;
    394394
    … …  
    602602        return;
    603603
    604     Assert(pVM->cCPUs == 1);
     604    Assert(pVM->cCpus == 1);
    605605
    606606    /* This only applies to raw mode where we only support 1 VCPU. */
    … …  
    636636     */
    637637    if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
    638         ||  pVM->cCPUs > 1)
     638        ||  pVM->cCpus > 1)
    639639        return VINF_SUCCESS;
    640640
    … …  
    672672     */
    673673    if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
    674         ||  pVM->cCPUs > 1)
     674        ||  pVM->cCpus > 1)
    675675        return VINF_SUCCESS;
    676676
    … …  
    705705        return false;
    706706
    707     Assert(pVM->cCPUs == 1);
     707    Assert(pVM->cCpus == 1);
    708708
    709709    /* This only applies to raw mode where we only support 1 VCPU. */
    … …  
    801801        return VINF_SUCCESS;
    802802
    803     Assert(pVM->cCPUs == 1);
     803    Assert(pVM->cCpus == 1);
    804804
    805805    /* This only applies to raw mode where we only support 1 VCPU. */

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

    r22788 r22890  
    885885            return false;
    886886    }
    887     if (    (    (pDis->param1.flags & USE_REG_GEN32) 
     887    if (    (    (pDis->param1.flags & USE_REG_GEN32)
    888888             ||  (pDis->param1.flags & USE_REG_GEN64))
    889889        &&  (pDis->param1.base.reg_gen == USE_REG_ESP))
    … …  
    12261226            if (fReused)
    12271227                goto flushPage;
    1228                
     1228
    12291229            /* A mov instruction to change the first page table entry will be remembered so we can detect
    12301230             * full page table changes early on. This will reduce the amount of unnecessary traps we'll take.
    … …  
    13151315        &&  !fForcedFlush
    13161316        &&  pPage->enmKind == PGMPOOLKIND_PAE_PT_FOR_PAE_PT
    1317         &&  (   fNotReusedNotForking 
     1317        &&  (   fNotReusedNotForking
    13181318             || (   !pgmPoolMonitorIsReused(pVM, pVCpu, pRegFrame, pDis, pvFault)
    13191319                 && !pgmPoolMonitorIsForking(pPool, pDis, GCPhysFault & PAGE_OFFSET_MASK))
    … …  
    13621362            {
    13631363                rc = PGMShwModifyPage(pVCpu, pvFault, 1, X86_PTE_RW, ~(uint64_t)X86_PTE_RW);
    1364                 AssertMsg(rc == VINF_SUCCESS 
     1364                AssertMsg(rc == VINF_SUCCESS
    13651365                        /* In the SMP case the page table might be removed while we wait for the PGM lock in the trap handler. */
    1366                         ||  rc == VERR_PAGE_TABLE_NOT_PRESENT 
    1367                         ||  rc == VERR_PAGE_NOT_PRESENT, 
     1366                        ||  rc == VERR_PAGE_TABLE_NOT_PRESENT
     1367                        ||  rc == VERR_PAGE_NOT_PRESENT,
    13681368                        ("PGMShwModifyPage -> GCPtr=%RGv rc=%d\n", pvFault, rc));
    13691369
    13701370                pgmPoolAddDirtyPage(pVM, pPool, pPage);
    13711371                pPage->pvDirtyFault = pvFault;
    1372      
     1372
    13731373                STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), a);
    13741374                pgmUnlock(pVM);
    … …  
    13881388     * interpret then. This may be a bit risky, in which case
    13891389     * the reuse detection must be fixed.
    1390      */       
     1390     */
    13911391    rc = pgmPoolAccessHandlerFlush(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault);
    13921392    if (rc == VINF_EM_RAW_EMULATE_INSTR && fReused)
    … …  
    14231423            RTHCPHYS HCPhys = -1;
    14241424            int rc = PGMPhysGCPhys2HCPhys(pPool->CTX_SUFF(pVM), pGstPT->a[i].u & X86_PTE_PAE_PG_MASK, &HCPhys);
    1425             if (    rc != VINF_SUCCESS 
     1425            if (    rc != VINF_SUCCESS
    14261426                ||  (pShwPT->a[i].u & X86_PTE_PAE_PG_MASK) != HCPhys)
    14271427            {
    … …  
    15551555    RTHCPHYS HCPhys;
    15561556    rc = PGMShwGetPage(VMMGetCpu(pVM), pPage->pvDirtyFault, &fFlags, &HCPhys);
    1557     AssertMsg(      (   rc == VINF_SUCCESS 
     1557    AssertMsg(      (   rc == VINF_SUCCESS
    15581558                     && (!(fFlags & X86_PTE_RW) || HCPhys != pPage->Core.Key))
    15591559              /* In the SMP case the page table might be removed while we wait for the PGM lock in the trap handler. */
    1560               ||    rc == VERR_PAGE_TABLE_NOT_PRESENT 
    1561               ||    rc == VERR_PAGE_NOT_PRESENT, 
     1560              ||    rc == VERR_PAGE_TABLE_NOT_PRESENT
     1561              ||    rc == VERR_PAGE_NOT_PRESENT,
    15621562              ("PGMShwGetPage -> GCPtr=%RGv rc=%d flags=%RX64\n", pPage->pvDirtyFault, rc, fFlags));
    15631563#endif
    … …  
    18281828
    18291829    /*
    1830      * Found a usable page, flush it and return. 
     1830     * Found a usable page, flush it and return.
    18311831     */
    18321832    return pgmPoolFlushPage(pPool, pPage);
    … …  
    26352635
    26362636    /* Clear the PGM_SYNC_CLEAR_PGM_POOL flag on all VCPUs to prevent redundant flushes. */
    2637     for (unsigned idCpu = 0; idCpu < pVM->cCPUs; idCpu++)
     2637    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    26382638    {
    26392639        PVMCPU pVCpu = &pVM->aCpus[idCpu];
    2640 
    26412640        pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_CLEAR_PGM_POOL;
    26422641    }
    … …  
    49114910     * including the root page.
    49124911     */
    4913     for (unsigned i=0;i<pVM->cCPUs;i++)
     4912    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    49144913    {
    49154914        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    50675066    }
    50685067
    5069     for (unsigned i=0;i<pVM->cCPUs;i++)
    5070     {
    5071         PVMCPU pVCpu = &pVM->aCpus[i];
     5068    for (VMCPUID i = 0; i < pVM->cCpus; i++)
     5069    {
    50725070        /*
    50735071         * Re-enter the shadowing mode and assert Sync CR3 FF.
    50745072         */
     5073        PVMCPU pVCpu = &pVM->aCpus[i];
    50755074        pgmR3ReEnterShadowModeAfterPoolFlush(pVM, pVCpu);
    50765075        VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);

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

    r22707 r22890  
    211211VMMDECL(void) REMNotifyHandlerPhysicalFlushIfAlmostFull(PVM pVM, PVMCPU pVCpu)
    212212{
    213     Assert(pVM->cCPUs == 1);
     213    Assert(pVM->cCpus == 1);
    214214
    215215    /*

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

    r19334 r22890  
    5656VMMDECL(RTGCPTR) SELMToFlatBySel(PVM pVM, RTSEL Sel, RTGCPTR Addr)
    5757{
    58     Assert(pVM->cCPUs == 1 && !CPUMIsGuestInLongMode(VMMGetCpu(pVM)));    /* DON'T USE! */
     58    Assert(pVM->cCpus == 1 && !CPUMIsGuestInLongMode(VMMGetCpu(pVM)));    /* DON'T USE! */
    5959
    6060    /** @todo check the limit. */
    … …  
    835835VMMDECL(int) SELMValidateAndConvertCSAddrGCTrap(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr, PRTGCPTR ppvFlat, uint32_t *pcBits)
    836836{
    837     Assert(pVM->cCPUs == 1);
     837    Assert(pVM->cCpus == 1);
    838838    PVMCPU pVCpu = &pVM->aCpus[0];
    839839
    … …  
    996996VMMDECL(int) SELMGetRing1Stack(PVM pVM, uint32_t *pSS, PRTGCPTR32 pEsp)
    997997{
    998     Assert(pVM->cCPUs == 1);
     998    Assert(pVM->cCpus == 1);
    999999    PVMCPU pVCpu = &pVM->aCpus[0];
    10001000

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

    r22808 r22890  
    828828{
    829829    uint32_t c = ASMAtomicDecU32(&pVM->tm.s.cVirtualTicking);
    830     AssertMsgReturn(c < pVM->cCPUs, ("%u vs %u\n", c, pVM->cCPUs), VERR_INTERNAL_ERROR);
     830    AssertMsgReturn(c < pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_INTERNAL_ERROR);
    831831    if (c == 0)
    832832    {
    … …  
    848848{
    849849    uint32_t c = ASMAtomicIncU32(&pVM->tm.s.cVirtualTicking);
    850     AssertMsgReturn(c <= pVM->cCPUs, ("%u vs %u\n", c, pVM->cCPUs), VERR_INTERNAL_ERROR);
     850    AssertMsgReturn(c <= pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_INTERNAL_ERROR);
    851851    if (c == 1)
    852852    {

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

    r20840 r22890  
    366366    PVM pVM = pVCpu->CTX_SUFF(pVM);
    367367    X86EFLAGS eflags;
    368     Assert(pVM->cCPUs == 1);
     368    Assert(pVM->cCpus == 1);
    369369
    370370    STAM_PROFILE_ADV_START(&pVM->trpm.s.CTX_SUFF_Z(StatForwardProf), a);

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

    r22823 r22890  
    6565
    6666#elif defined(IN_RING0)
    67     if (pVM->cCPUs == 1)
     67    if (pVM->cCpus == 1)
    6868        return 0;
    6969    return HWACCMR0GetVMCPUId(pVM);
    … …  
    8888    if (idCpu == NIL_VMCPUID)
    8989        return NULL;
    90     Assert(idCpu < pVM->cCPUs);
     90    Assert(idCpu < pVM->cCpus);
    9191    return &pVM->aCpus[VMR3GetVMCPUId(pVM)];
    9292
    9393#elif defined(IN_RING0)
    94     if (pVM->cCPUs == 1)
     94    if (pVM->cCpus == 1)
    9595        return &pVM->aCpus[0];
    9696    return HWACCMR0GetVMCPU(pVM);
    … …  
    110110VMMDECL(PVMCPU) VMMGetCpu0(PVM pVM)
    111111{
    112     Assert(pVM->cCPUs == 1);
     112    Assert(pVM->cCpus == 1);
    113113    return &pVM->aCpus[0];
    114114}
    … …  
    125125VMMDECL(PVMCPU) VMMGetCpuById(PVM pVM, RTCPUID idCpu)
    126126{
    127     AssertReturn(idCpu < pVM->cCPUs, NULL);
     127    AssertReturn(idCpu < pVM->cCpus, NULL);
    128128    return &pVM->aCpus[idCpu];
    129129}

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

    r20902 r22890  
    418418    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    419419
    420     AssertReturnVoid(idCpu < pVM->cCPUs);
     420    AssertReturnVoid(idCpu < pVM->cCpus);
    421421
    422422    LogFlow(("pdmRCApicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 1\n",
    … …  
    447447    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    448448
    449     AssertReturnVoid(idCpu < pVM->cCPUs);
     449    AssertReturnVoid(idCpu < pVM->cCpus);
    450450
    451451    LogFlow(("pdmRCApicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 0\n",

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

    r21942 r22890  
    144144    if (u32DR7 & X86_DR7_ENABLED_MASK)
    145145    {
    146         for (unsigned i=0;i<pVM->cCPUs;i++)
     146        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    147147            pVM->aCpus[i].cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HOST;
    148148        Log(("CPUMR0Init: host uses debug registers (dr7=%x)\n", u32DR7));

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

    r21915 r22890  
    610610                            pVM->hSelf      = iHandle;
    611611                            pVM->cbSelf     = cbVM;
    612                             pVM->cCPUs      = cCpus;
     612                            pVM->cCpus      = cCpus;
    613613                            pVM->offVMCPU   = RT_UOFFSETOF(VM, aCpus);
    614614
    … …  
    11001100        return rc;
    11011101
    1102     AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_CPU_ID);
     1102    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    11031103    AssertReturn(pGVM->aCpus[idCpu].hEMT == NIL_RTNATIVETHREAD, VERR_ACCESS_DENIED);
    11041104

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

    r22615 r22890  
    847847    }
    848848
    849     for (unsigned i=0;i<pVM->cCPUs;i++)
     849    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    850850    {
    851851        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    932932    ASMAtomicWriteBool(&pCpu->fInUse, true);
    933933
    934     for (unsigned i=0;i<pVM->cCPUs;i++)
     934    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    935935    {
    936936        /* On first entry we'll sync everything. */
    … …  
    11961196
    11971197    /** @todo optimize for large number of VCPUs when that becomes more common. */
    1198     for (unsigned idCpu=0;idCpu<pVM->cCPUs;idCpu++)
     1198    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    11991199    {
    12001200        PVMCPU pVCpu = &pVM->aCpus[idCpu];

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

    r22493 r22890  
    175175
    176176    /* Allocate VMCBs for all guest CPUs. */
    177     for (unsigned i=0;i<pVM->cCPUs;i++)
     177    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    178178    {
    179179        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    223223VMMR0DECL(int) SVMR0TermVM(PVM pVM)
    224224{
    225     for (unsigned i=0;i<pVM->cCPUs;i++)
     225    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    226226    {
    227227        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    274274    Assert(pVM->hwaccm.s.svm.fSupported);
    275275
    276     for (unsigned i=0;i<pVM->cCPUs;i++)
     276    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    277277    {
    278278        PVMCPU    pVCpu = &pVM->aCpus[i];
    … …  
    27782778
    27792779    /* @todo This code is not guest SMP safe (hyper stack and switchers) */
    2780     AssertReturn(pVM->cCPUs == 1, VERR_TOO_MANY_CPUS);
     2780    AssertReturn(pVM->cCpus == 1, VERR_TOO_MANY_CPUS);
    27812781    Assert(pfnHandler);
    27822782

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

    r22493 r22890  
    216216
    217217    /* Allocate VMCBs for all guest CPUs. */
    218     for (unsigned i=0;i<pVM->cCPUs;i++)
     218    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    219219    {
    220220        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    299299VMMR0DECL(int) VMXR0TermVM(PVM pVM)
    300300{
    301     for (unsigned i=0;i<pVM->cCPUs;i++)
     301    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    302302    {
    303303        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    374374    AssertReturn(pVM, VERR_INVALID_PARAMETER);
    375375
    376     for (unsigned i=0;i<pVM->cCPUs;i++)
     376    for (VMCPUID i = 0; i < pVM->cCpus; i++)
    377377    {
    378378        PVMCPU pVCpu = &pVM->aCpus[i];
    … …  
    44474447
    44484448    /* @todo This code is not guest SMP safe (hyper stack and switchers) */
    4449     AssertReturn(pVM->cCPUs == 1, VERR_TOO_MANY_CPUS);
     4449    AssertReturn(pVM->cCpus == 1, VERR_TOO_MANY_CPUS);
    44504450    AssertReturn(pVM->hwaccm.s.pfnHost32ToGuest64R0, VERR_INTERNAL_ERROR);
    44514451    Assert(pVCpu->hwaccm.s.vmx.VMCSCache.Write.cValidEntries <= RT_ELEMENTS(pVCpu->hwaccm.s.vmx.VMCSCache.Write.aField));

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

    r21016 r22890  
    433433    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    434434
    435     AssertReturnVoid(idCpu < pVM->cCPUs);
     435    AssertReturnVoid(idCpu < pVM->cCpus);
    436436
    437437    LogFlow(("pdmR0ApicHlp_SetInterruptFF: CPU%d=caller=%p/%d: VM_FF_INTERRUPT %d -> 1 (CPU%d)\n",
    … …  
    481481    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    482482
    483     AssertReturnVoid(idCpu < pVM->cCPUs);
     483    AssertReturnVoid(idCpu < pVM->cCpus);
    484484
    485485    LogFlow(("pdmR0ApicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 0\n",

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

    r22869 r22890  
    355355     * Initialize the auto sets.
    356356     */
    357     VMCPUID idCpu = pVM->cCPUs;
     357    VMCPUID idCpu = pVM->cCpus;
    358358    AssertReturn(idCpu > 0 && idCpu <= VMM_MAX_CPU_COUNT, VERR_INTERNAL_ERROR);
    359359    while (idCpu-- > 0)
    … …  
    443443         * Clean up and check the auto sets.
    444444         */
    445         VMCPUID idCpu = pVM->cCPUs;
     445        VMCPUID idCpu = pVM->cCpus;
    446446        while (idCpu-- > 0)
    447447        {

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

    r21653 r22890  
    512512VMMR0DECL(void) VMMR0EntryFast(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation)
    513513{
    514     if (RT_UNLIKELY(idCpu >= pVM->cCPUs))
     514    if (RT_UNLIKELY(idCpu >= pVM->cCpus))
    515515        return;
    516516    PVMCPU pVCpu = &pVM->aCpus[idCpu];
    … …  
    531531                bool        fVTxDisabled;
    532532
    533                 if (RT_UNLIKELY(pVM->cCPUs > 1))
     533                if (RT_UNLIKELY(pVM->cCpus > 1))
    534534                {
    535535                    pVCpu->vmm.s.iLastGZRc = VERR_RAW_MODE_INVALID_SMP;
    … …  
    728728        }
    729729
    730         if (RT_UNLIKELY(idCpu >= pVM->cCPUs && idCpu != NIL_VMCPUID))
    731         {
    732             SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu (%u vs cCPUs=%u)\n", idCpu, pVM->cCPUs);
     730        if (RT_UNLIKELY(idCpu >= pVM->cCpus && idCpu != NIL_VMCPUID))
     731        {
     732            SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu (%u vs cCpus=%u)\n", idCpu, pVM->cCpus);
    733733            return VERR_INVALID_PARAMETER;
    734734        }
    … …  
    10901090    if (    VALID_PTR(pVM)
    10911091        &&  pVM->pVMR0
    1092         &&  idCpu < pVM->cCPUs)
     1092        &&  idCpu < pVM->cCpus)
    10931093    {
    10941094        switch (enmOperation)

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

    r20864 r22890  
    7373    pVM->pUVM = pUVM;
    7474
    75     pVM->cCPUs = NUM_CPUS;
    76     pVM->cbSelf = RT_UOFFSETOF(VM, aCpus[pVM->cCPUs]);
     75    pVM->cCpus = NUM_CPUS;
     76    pVM->cbSelf = RT_UOFFSETOF(VM, aCpus[pVM->cCpus]);
    7777
    7878    rc = STAMR3InitUVM(pUVM);

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

    r22793 r22890  
    654654                    pVM->pVMR3 = pVM;
    655655                    pVM->pUVM = pUVM;
    656                     pVM->cCPUs = 1;
     656                    pVM->cCpus = 1;
    657657                    pVM->aCpus[0].pVMR3 = pVM;
    658658                    pVM->aCpus[0].hNativeThread = RTThreadNativeSelf();

  • trunk/src/recompiler/VBoxRecompiler.c

    r22793 r22890  
    668668    uint32_t fRawRing0 = false;
    669669    uint32_t u32Sep;
    670     unsigned i;
     670    uint32_t i;
    671671    int rc;
    672672    PREM pRem;
    … …  
    777777     * Sync the whole CPU state when executing code in the recompiler.
    778778     */
    779     for (i=0;i<pVM->cCPUs;i++)
     779    for (i = 0; i < pVM->cCpus; i++)
    780780    {
    781781        PVMCPU pVCpu = &pVM->aCpus[i];
    782 
    783782        CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_ALL);
    784783    }
    … …  
    28272826
    28282827#ifdef VBOX_STRICT
    2829         if (pVM->cCPUs == 1)
     2828        if (pVM->cCpus == 1)
    28302829        {
    28312830            /* Check that all records are now on the free list. */
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