VirtualBox

Changeset 23011 in vbox


Ignore:
Timestamp:
Sep 14, 2009 3:57:38 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
52307
Message:

VMM,VMMDev: Some VMMR3ReqCall refactoring.

Location:
trunk/src/VBox
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r22823 r23011  
    274274     * about something, which has already happened.
    275275     */
    276     rc = VMR3ReqCallEx(pVM, VMCPUID_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
    277                        (PFNRT) vmmdevNotifyGuest_EMT,
    278                        2, pVMMDevState, u32EventMask);
     276    rc = VMR3ReqCallEx(pVM, VMCPUID_ANY, NULL /*ppReq*/, 0 /*cMillies*/, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
     277                       (PFNRT)vmmdevNotifyGuest_EMT, 2, pVMMDevState, u32EventMask);
    279278    AssertRC(rc);
    280279}

  • trunk/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp

    r21561 r23011  
    20372037 *        efficient...? */
    20382038    /* Not safe to execute asynchroneously; forward to EMT */
    2039     int rc = VMR3ReqCallEx(PDMDevHlpGetVM(pVMMDevState->pDevIns), VMCPUID_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
     2039    int rc = VMR3ReqCallEx(PDMDevHlpGetVM(pVMMDevState->pDevIns), VMCPUID_ANY, NULL, 0 /*cMillies*/,
     2040                           VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
    20402041                           (PFNRT)hgcmCompletedWorker, 3, pInterface, result, pCmd);
    20412042    AssertRC(rc);

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

    r22890 r23011  
    213213        return VMMR3ReadR0Stack(pVM, idCpu, (RTHCUINTPTR)pAddress->FlatPtr, pvBuf, cbRead);
    214214    }
    215     else
    216     {
    217         PVMREQ pReq;
    218         int rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, 0,
    219                               (PFNRT)dbgfR3MemRead, 5, pVM, idCpu, pAddress, pvBuf, cbRead);
    220         if (RT_SUCCESS(rc))
    221             rc = pReq->iStatus;
    222         VMR3ReqFree(pReq);
    223         return rc;
    224     }
     215    return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3MemRead, 5, pVM, idCpu, pAddress, pvBuf, cbRead);
    225216}
    226217
    … …  
    300291     * Pass it on to the EMT.
    301292     */
    302     PVMREQ pReq;
    303     int rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, 0,
    304                           (PFNRT)dbgfR3MemReadString, 5, pVM, idCpu, pAddress, pszBuf, cchBuf);
    305     if (RT_SUCCESS(rc))
    306         rc = pReq->iStatus;
    307     VMR3ReqFree(pReq);
    308 
    309     return rc;
     293    return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3MemReadString, 5, pVM, idCpu, pAddress, pszBuf, cchBuf);
    310294}
    311295
    … …  
    382366{
    383367    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    384 
    385     PVMREQ pReq;
    386     int rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, 0,
    387                           (PFNRT)dbgfR3MemWrite, 5, pVM, idCpu, pAddress, pvBuf, cbWrite);
    388     if (RT_SUCCESS(rc))
    389         rc = pReq->iStatus;
    390     VMR3ReqFree(pReq);
    391 
    392     return rc;
     368    return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3MemWrite, 5, pVM, idCpu, pAddress, pvBuf, cbWrite);
    393369}
    394370
    … …  
    492468     * Dispatch the request to a worker running on the target CPU.
    493469     */
    494     PVMREQ pReq;
    495     int rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, 0,
    496                           (PFNRT)dbgfR3SelQueryInfo, 5, pVM, idCpu, Sel, fFlags, pSelInfo);
    497     if (RT_SUCCESS(rc))
    498         rc = pReq->iStatus;
    499     VMR3ReqFree(pReq);
    500 
    501     return rc;
     470    return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3SelQueryInfo, 5, pVM, idCpu, Sel, fFlags, pSelInfo);
    502471}
    503472

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

    r22108 r23011  
    158158
    159159    /*
    160      * Pass it on to the EMT.
    161      */
    162     PVMREQ pReq;
    163     int rc = VMR3ReqCallU(pVM->pUVM, 0, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSRegister, 2, pVM, pReg);
    164     if (RT_SUCCESS(rc))
    165         rc = pReq->iStatus;
    166     VMR3ReqFree(pReq);
    167 
    168     return rc;
     160     * Pass it on to EMT(0).
     161     */
     162    return VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/, (PFNRT)dbgfR3OSRegister, 2, pVM, pReg);
    169163}
    170164
    … …  
    255249
    256250    /*
    257      * Pass it on to the EMT.
    258      */
    259     PVMREQ pReq;
    260     int rc = VMR3ReqCallU(pVM->pUVM, 0, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSDeregister, 2, pVM, pReg);
    261     if (RT_SUCCESS(rc))
    262         rc = pReq->iStatus;
    263     VMR3ReqFree(pReq);
    264 
    265     return rc;
     251     * Pass it on to EMT(0).
     252     */
     253    return VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/, (PFNRT)dbgfR3OSDeregister, 2, pVM, pReg);
    266254}
    267255
    … …  
    333321
    334322    /*
    335      * Pass it on to the EMT.
    336      */
    337     PVMREQ pReq;
    338     int rc = VMR3ReqCallU(pVM->pUVM, 0, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSDetect, 3, pVM, pszName, cchName);
    339     if (RT_SUCCESS(rc))
    340         rc = pReq->iStatus;
    341     VMR3ReqFree(pReq);
    342 
    343     return rc;
     323     * Pass it on to EMT(0).
     324     */
     325    return VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/, (PFNRT)dbgfR3OSDetect, 3, pVM, pszName, cchName);
    344326}
    345327
    … …  
    417399
    418400    /*
    419      * Pass it on to the EMT.
    420      */
    421     PVMREQ pReq;
    422     int rc = VMR3ReqCallU(pVM->pUVM, 0, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSQueryNameAndVersion,
    423                           5, pVM, pszName, cchName, pszVersion, cchVersion);
    424     if (RT_SUCCESS(rc))
    425         rc = pReq->iStatus;
    426     VMR3ReqFree(pReq);
    427 
    428     return rc;
     401     * Pass it on to EMT(0).
     402     */
     403    return VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/,
     404                            (PFNRT)dbgfR3OSQueryNameAndVersion, 5, pVM, pszName, cchName, pszVersion, cchVersion);
    429405}
    430406
    … …  
    467443
    468444    /*
    469      * Pass it on to the EMT.
     445     * Pass it on to an EMT.
    470446     */
    471447    void *pvIf = NULL;

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

    r22890 r23011  
    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. */
    1540         PVMREQ pReq;
    1541         int rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ANY_QUEUE, &pReq, 0, VMREQFLAGS_NO_WAIT,
    1542                               (PFNRT)hwaccmR3EnablePatching, 4, pVM, VMMGetCpuId(pVM), (RTRCPTR)pPatchMem, cbPatchMem);
     1540        int rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY_QUEUE,
     1541                                    (PFNRT)hwaccmR3EnablePatching, 4, pVM, VMMGetCpuId(pVM), (RTRCPTR)pPatchMem, cbPatchMem);
    15431542        AssertRC(rc);
    15441543        return rc;
    15451544    }
    1546     else
    1547         return hwaccmR3EnablePatching(pVM, VMMGetCpuId(pVM), (RTRCPTR)pPatchMem, cbPatchMem);
     1545    return hwaccmR3EnablePatching(pVM, VMMGetCpuId(pVM), (RTRCPTR)pPatchMem, cbPatchMem);
    15481546}
    15491547

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

    r22890 r23011  
    19821982        Log(("CSAMCodePageWriteHandler: delayed write!\n"));
    19831983        AssertCompileSize(RTRCPTR, 4);
    1984         rc = VMR3ReqCallEx(pVM, VMCPUID_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
     1984        rc = VMR3ReqCallEx(pVM, VMCPUID_ANY, NULL /*ppReq*/, 0 /*cMillies*/, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
    19851985                           (PFNRT)CSAMDelayedWriteHandler, 3, pVM, (RTRCPTR)GCPtr, cbBuf);
    19861986    }

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

    r22890 r23011  
    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. */
    2360         PVMREQ pReq;
    2361         rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ANY_QUEUE, &pReq, 0, VMREQFLAGS_NO_WAIT,
    2362                           (PFNRT)VMR3Suspend, 1, pVM);
     2360        rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY_QUEUE, (PFNRT)VMR3Suspend, 1, pVM);
    23632361        AssertRC(rc);
    23642362        rc = VINF_EM_SUSPEND;
    … …  
    23852383    {
    23862384        /* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */
    2387         PVMREQ pReq;
    2388         rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ANY_QUEUE, &pReq, 0, VMREQFLAGS_NO_WAIT,
    2389                           (PFNRT)VMR3PowerOff, 1, pVM);
     2385        rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY_QUEUE, (PFNRT)VMR3PowerOff, 1, pVM);
    23902386        AssertRC(rc);
    23912387        /* Set the VCPU state to stopped here as well to make sure no

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

    r22783 r23011  
    337337    STAM_REG(pVM, &pPool->StatFlushPage,                STAMTYPE_PROFILE,   "/PGM/Pool/FlushPage",      STAMUNIT_TICKS_PER_CALL,    "Profiling of pgmPoolFlushPage.");
    338338    STAM_REG(pVM, &pPool->StatFree,                     STAMTYPE_PROFILE,   "/PGM/Pool/Free",           STAMUNIT_TICKS_PER_CALL,    "Profiling of pgmPoolFree.");
    339     STAM_REG(pVM, &pPool->StatForceFlushPage,           STAMTYPE_COUNTER,   "/PGM/Pool/FlushForce",     STAMUNIT_OCCURENCES,        "Counting explicit flushes by PGMPoolFlushPage().");   
    340     STAM_REG(pVM, &pPool->StatForceFlushDirtyPage,      STAMTYPE_COUNTER,   "/PGM/Pool/FlushForceDirty",     STAMUNIT_OCCURENCES,   "Counting explicit flushes of dirty pages by PGMPoolFlushPage().");   
     339    STAM_REG(pVM, &pPool->StatForceFlushPage,           STAMTYPE_COUNTER,   "/PGM/Pool/FlushForce",     STAMUNIT_OCCURENCES,        "Counting explicit flushes by PGMPoolFlushPage().");
     340    STAM_REG(pVM, &pPool->StatForceFlushDirtyPage,      STAMTYPE_COUNTER,   "/PGM/Pool/FlushForceDirty",     STAMUNIT_OCCURENCES,   "Counting explicit flushes of dirty pages by PGMPoolFlushPage().");
    341341    STAM_REG(pVM, &pPool->StatForceFlushReused,         STAMTYPE_COUNTER,   "/PGM/Pool/FlushReused",    STAMUNIT_OCCURENCES,        "Counting flushes for reused pages.");
    342342    STAM_REG(pVM, &pPool->StatZeroPage,                 STAMTYPE_PROFILE,   "/PGM/Pool/ZeroPage",       STAMUNIT_TICKS_PER_CALL,    "Profiling time spent zeroing pages. Overlaps with Alloc.");
    … …  
    383383    STAM_REG(pVM, &pPool->StatDirtyPageDupFlush,        STAMTYPE_COUNTER,   "/PGM/Pool/Monitor/Dirty/FlushDup",     STAMUNIT_OCCURENCES,     "Times we've had to flush duplicates for dirty page management.");
    384384    STAM_REG(pVM, &pPool->StatDirtyPageOverFlowFlush,   STAMTYPE_COUNTER,   "/PGM/Pool/Monitor/Dirty/FlushOverflow",STAMUNIT_OCCURENCES,     "Times we've had to flush because of overflow.");
    385    
     385
    386386# endif
    387387# ifdef PGMPOOL_WITH_CACHE
    … …  
    576576        {
    577577            pgmUnlock(pVM);
    578             int rc = VMR3ReqCallEx(pPool->pVMR3, VMCPUID_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, (PFNRT)pgmR3PoolFlushReusedPage, 2, pPool, pPage);
     578            int rc = VMR3ReqCallEx(pPool->pVMR3, VMCPUID_ANY, NULL /*ppReq*/, 0 /*cMillies*/, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
     579                                   (PFNRT)pgmR3PoolFlushReusedPage, 2, pPool, pPage);
    579580            AssertRCReturn(rc, rc);
    580581            pgmLock(pVM);
    … …  
    657658                    RTHCPHYS HCPhys = -1;
    658659                    rc = PGMPhysGCPhys2HCPhys(pPool->CTX_SUFF(pVM), pGstPT->a[j].u & X86_PTE_PAE_PG_MASK, &HCPhys);
    659                     if (    rc != VINF_SUCCESS 
     660                    if (    rc != VINF_SUCCESS
    660661                        ||  (pShwPT->a[j].u & X86_PTE_PAE_PG_MASK) != HCPhys)
    661662                    {

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

    r23009 r23011  
    764764    for (VMCPUID idCpu = 1; idCpu < pVM->cCpus; idCpu++)
    765765    {
    766         PVMREQ pReq;
    767         rc = VMR3ReqCallU(pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    768                           (PFNRT)vmR3RegisterEMT, 2, pVM, idCpu);
    769         if (RT_SUCCESS(rc))
    770             rc = pReq->iStatus;
    771         VMR3ReqFree(pReq);
     766        rc = VMR3ReqCallWaitU(pUVM, idCpu, (PFNRT)vmR3RegisterEMT, 2, pVM, idCpu);
    772767        if (RT_FAILURE(rc))
    773768            return rc;
    … …  
    11961191     * work upfront).
    11971192     */
    1198     PVMREQ pReq;
    1199     int rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ALL, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1200                           (PFNRT)vmR3PowerOn, 1, pVM);
    1201     if (RT_SUCCESS(rc))
    1202     {
    1203         rc = pReq->iStatus;
    1204         VMR3ReqFree(pReq);
    1205     }
    1206 
     1193    int rc = VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ALL, (PFNRT)vmR3PowerOn, 1, pVM);
    12071194    LogFlow(("VMR3PowerOn: returns %Rrc\n", rc));
    12081195    return rc;
    … …  
    12891276     * actual suspending after the other ones have stopped running guest code.
    12901277     */
    1291     PVMREQ pReq;
    1292     int rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ALL_REVERSE, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1293                           (PFNRT)vmR3Suspend, 2, pVM, fFatal);
    1294     if (RT_SUCCESS(rc))
    1295     {
    1296         rc = pReq->iStatus;
    1297         VMR3ReqFree(pReq);
    1298     }
    1299 
    1300     return rc;
     1278    return VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ALL_REVERSE, (PFNRT)vmR3Suspend, 2, pVM, fFatal);
    13011279}
    13021280
    … …  
    13871365     * work upfront).
    13881366     */
    1389     PVMREQ pReq;
    1390     int rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ALL, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1391                           (PFNRT)vmR3Resume, 1, pVM);
    1392     if (RT_SUCCESS(rc))
    1393     {
    1394         rc = pReq->iStatus;
    1395         VMR3ReqFree(pReq);
    1396     }
    1397 
     1367    int rc = VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ALL, (PFNRT)vmR3Resume, 1, pVM);
    13981368    LogFlow(("VMR3Resume: returns %Rrc\n", rc));
    13991369    return rc;
    … …  
    15131483    SSMAFTER    enmAfter = fContinueAfterwards ? SSMAFTER_CONTINUE : SSMAFTER_DESTROY;
    15141484    PSSMHANDLE  pSSM;
    1515     PVMREQ      pReq;
    1516     int rc = VMR3ReqCallU(pVM->pUVM, 0 /*idDstCpu*/, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1517                           (PFNRT)vmR3Save, 6, pVM, pszFilename, enmAfter, pfnProgress, pvUser, &pSSM);
    1518     if (RT_SUCCESS(rc))
    1519     {
    1520         rc = pReq->iStatus;
    1521         VMR3ReqFree(pReq);
    1522     }
     1485    int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/,
     1486                              (PFNRT)vmR3Save, 6, pVM, pszFilename, enmAfter, pfnProgress, pvUser, &pSSM);
    15231487    if (    RT_SUCCESS(rc)
    15241488        &&  pSSM)
    … …  
    15331497            rc = vmR3SuspendCommon(pVM, false /*fFatal*/);
    15341498            if (RT_SUCCESS(rc))
    1535             {
    1536                 rc = VMR3ReqCallU(pVM->pUVM, 0 /*idDstCpu*/, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1537                                   (PFNRT)vmR3SaveLiveStep2, 2, pVM, pSSM);
    1538                 if (RT_SUCCESS(rc))
    1539                 {
    1540                     rc = pReq->iStatus;
    1541                     VMR3ReqFree(pReq);
    1542                 }
    1543             }
     1499                rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/, (PFNRT)vmR3SaveLiveStep2, 2, pVM, pSSM);
    15441500        }
    15451501        else
    … …  
    16771633     * Request the operation in EMT.
    16781634     */
    1679     PVMREQ pReq;
    1680     int rc = VMR3ReqCallU(pVM->pUVM, 0 /*idDstCpu*/, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1681                           (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
    1682     if (RT_SUCCESS(rc))
    1683     {
    1684         rc = pReq->iStatus;
    1685         VMR3ReqFree(pReq);
    1686     }
    1687 
     1635    int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/,
     1636                              (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
    16881637    LogFlow(("VMR3Load: returns %Rrc\n", rc));
    16891638    return rc;
    … …  
    18591808     * Request the operation in EMT. (in reverse order as VCPU 0 does the actual work)
    18601809     */
    1861     PVMREQ pReq = NULL;
    1862     int rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ALL_REVERSE, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1863                           (PFNRT)vmR3PowerOff, 1, pVM);
    1864     if (RT_SUCCESS(rc))
    1865     {
    1866         rc = pReq->iStatus;
    1867         VMR3ReqFree(pReq);
    1868     }
    1869     else
    1870         Assert(pReq == NULL);
    1871 
     1810    int rc = VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ALL_REVERSE, (PFNRT)vmR3PowerOff, 1, pVM);
    18721811    LogFlow(("VMR3PowerOff: returns %Rrc\n", rc));
    18731812    return rc;
    … …  
    19441883        for (VMCPUID idCpu = 1; idCpu < pVM->cCpus; idCpu++)
    19451884        {
    1946             PVMREQ pReq = NULL;
    1947             int rc = VMR3ReqCallU(pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1948                                   (PFNRT)vmR3Destroy, 1, pVM);
    1949             if (RT_SUCCESS(rc))
    1950                 rc = pReq->iStatus;
     1885            int rc = VMR3ReqCallWaitU(pUVM, idCpu, (PFNRT)vmR3Destroy, 1, pVM);
    19511886            AssertLogRelRC(rc);
    1952             VMR3ReqFree(pReq);
    19531887        }
    19541888    }
    … …  
    19561890    {
    19571891        /* vmR3Destroy on all EMTs, ending with EMT(0). */
    1958         PVMREQ pReq = NULL;
    1959         int rc = VMR3ReqCallU(pUVM, VMCPUID_ALL_REVERSE, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    1960                               (PFNRT)vmR3Destroy, 1, pVM);
    1961         if (RT_SUCCESS(rc))
    1962             rc = pReq->iStatus;
     1892        int rc = VMR3ReqCallWaitU(pUVM, VMCPUID_ALL_REVERSE, (PFNRT)vmR3Destroy, 1, pVM);
    19631893        AssertLogRelRC(rc);
    1964         VMR3ReqFree(pReq);
    19651894
    19661895        /* Wait for EMTs and destroy the UVM. */
    … …  
    25362465     * and wait for it to be processed. (in reverse order as VCPU 0 does the real cleanup)
    25372466     */
    2538     PVMREQ pReq = NULL;
    2539     int rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ALL_REVERSE, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    2540                           (PFNRT)vmR3Reset, 1, pVM);
    2541     if (RT_SUCCESS(rc))
    2542         rc = pReq->iStatus;
     2467    int rc = VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ALL_REVERSE, (PFNRT)vmR3Reset, 1, pVM);
    25432468    AssertLogRelRC(rc);
    2544     VMR3ReqFree(pReq);
    2545 
    25462469    return rc;
    25472470}

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

    r22890 r23011  
    12911291    AssertReturnVoid(idCpu < pVM->cCpus);
    12921292
    1293     PVMREQ pReq;
    1294     int rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, 0, VMREQFLAGS_NO_WAIT,
    1295                           (PFNRT)vmmR3SendSipi, 3, pVM, idCpu, uVector);
     1293    int rc = VMR3ReqCallNoWaitU(pVM->pUVM, idCpu, (PFNRT)vmmR3SendSipi, 3, pVM, idCpu, uVector);
    12961294    AssertRC(rc);
    12971295}
    … …  
    13071305    AssertReturnVoid(idCpu < pVM->cCpus);
    13081306
    1309     PVMREQ pReq;
    1310     int rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, 0, VMREQFLAGS_NO_WAIT,
    1311                           (PFNRT)vmmR3SendInitIpi, 2, pVM, idCpu);
     1307    int rc = VMR3ReqCallNoWaitU(pVM->pUVM, idCpu, (PFNRT)vmmR3SendInitIpi, 2, pVM, idCpu);
    13121308    AssertRC(rc);
    13131309}
    … …  
    13871383        if (idCpu != pVCpu->idCpu)
    13881384        {
    1389             rc = VMR3ReqCallU(pVM->pUVM, idCpu, NULL, 0, VMREQFLAGS_NO_WAIT,
    1390                               (PFNRT)vmmR3SyncVCpu, 1, pVM);
     1385            rc = VMR3ReqCallNoWaitU(pVM->pUVM, idCpu, (PFNRT)vmmR3SyncVCpu, 1, pVM);
    13911386            AssertRC(rc);
    13921387        }

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

    r22915 r23011  
    261261     */
    262262    int rc;
    263     PVMREQ pReq;
    264263    if (    !(fFlags & VMSETRTERR_FLAGS_NO_WAIT)
    265264        ||  VM_IS_EMT(pVM))
    … …  
    269268        va_list va2;
    270269        va_copy(va2, va); /* Have to make a copy here or GCC will break. */
    271         rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
    272                           (PFNRT)vmR3SetRuntimeErrorV, 5, pVM, fFlags, pszErrorId, pszFormat, &va2);
     270        rc = VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ANY,
     271                              (PFNRT)vmR3SetRuntimeErrorV, 5, pVM, fFlags, pszErrorId, pszFormat, &va2);
    273272        va_end(va2);
    274         if (RT_SUCCESS(rc))
    275             rc = pReq->iStatus;
    276273    }
    277274    else
    278275    {
    279276        char *pszMessage = MMR3HeapAPrintfV(pVM, MM_TAG_VM, pszFormat, va);
    280 
    281         rc = VMR3ReqCallU(pVM->pUVM, VMCPUID_ANY, &pReq, 0, VMREQFLAGS_VBOX_STATUS | VMREQFLAGS_NO_WAIT,
    282                           (PFNRT)vmR3SetRuntimeError, 4, pVM, fFlags, pszErrorId, pszMessage);
     277        rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY,
     278                                (PFNRT)vmR3SetRuntimeError, 4, pVM, fFlags, pszErrorId, pszMessage);
    283279        if (RT_FAILURE(rc))
    284280            MMR3HeapFree(pszMessage);
    285281    }
    286     VMR3ReqFree(pReq);
    287282
    288283#else

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

    r19537 r23011  
    296296                for (VMCPUID idCpu = 1; idCpu < g_cCpus; idCpu++)
    297297                {
    298                     PVMREQ pReq = NULL;
    299                     rc = VMR3ReqCallU(pVM->pUVM, idCpu, &pReq, 0, VMREQFLAGS_NO_WAIT,  (PFNRT)tstTMWorker, 2, pVM, hTest);
     298                    rc = VMR3ReqCallNoWaitU(pVM->pUVM, idCpu, (PFNRT)tstTMWorker, 2, pVM, hTest);
    300299                    if (RT_FAILURE(rc))
    301300                        RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
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