VirtualBox

Changeset 23012 in vbox


Ignore:
Timestamp:
Sep 14, 2009 4:38:13 PM (15 years ago)
Author:
vboxsync
Message:

VMM,Devices,Main: VMR3ReqCall w/ RT_INDEFINITE_WAIT -> VMR3ReqCallWait.

Location:
trunk/src
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Storage/ATAController.cpp

    r21321 r23012  
    22562256
    22572257                        PDMCritSectLeave(&pCtl->lock);
    2258                         rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    2259                                          (PFNRT)s->pDrvMount->pfnUnmount, 2, s->pDrvMount, false);
     2258                        rc = VMR3ReqCallWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
     2259                                             (PFNRT)s->pDrvMount->pfnUnmount, 2, s->pDrvMount, false);
    22602260                        AssertReleaseRC(rc);
    2261                         VMR3ReqFree(pReq);
    22622261                        {
    22632262                            STAM_PROFILE_START(&pCtl->StatLockWait, a);
    … …  
    38223821{
    38233822    PPDMDEVINS  pDevIns = CONTROLLER_2_DEVINS(pCtl);
    3824     PVMREQ      pReq;
    38253823    int         rc;
    38263824
    38273825    pCtl->fRedoIdle = true;
    3828     rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    3829                      (PFNRT)PDMDevHlpVMSuspend, 1, pDevIns);
     3826    rc = VMR3ReqCallWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
     3827                         (PFNRT)PDMDevHlpVMSuspend, 1, pDevIns);
    38303828    AssertReleaseRC(rc);
    3831     VMR3ReqFree(pReq);
    38323829}
    38333830

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r22793 r23012  
    36583658                            PAHCI pAhci = pAhciPort->CTX_SUFF(pAhci);
    36593659                            PPDMDEVINS pDevIns = pAhci->CTX_SUFF(pDevIns);
    3660                             PVMREQ pReq;
    3661 
    3662                             rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    3663                                              (PFNRT)pAhciPort->pDrvMount->pfnUnmount, 2, pAhciPort->pDrvMount, false);
     3660
     3661                            rc = VMR3ReqCallWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
     3662                                                 (PFNRT)pAhciPort->pDrvMount->pfnUnmount, 2, pAhciPort->pDrvMount, false);
    36643663                            AssertReleaseRC(rc);
    3665                             VMR3ReqFree(pReq);
    36663664                        }
    36673665                        break;

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r22934 r23012  
    14101410{
    14111411    PPDMDEVINS  pDevIns = CONTROLLER_2_DEVINS(pCtl);
    1412     PVMREQ      pReq;
    14131412    int         rc;
    14141413
    14151414    pCtl->fRedoIdle = true;
    1416     rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1417                      (PFNRT)PDMDevHlpVMSuspend, 1, pDevIns);
     1415    rc = VMR3ReqCallWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
     1416                         (PFNRT)PDMDevHlpVMSuspend, 1, pDevIns);
    14181417    AssertReleaseRC(rc);
    1419     VMR3ReqFree(pReq);
    14201418}
    14211419
    … …  
    28912889                        PATACONTROLLER pCtl = ATADEVSTATE_2_CONTROLLER(s);
    28922890                        PPDMDEVINS pDevIns = ATADEVSTATE_2_DEVINS(s);
    2893                         PVMREQ pReq;
    28942891
    28952892                        PDMCritSectLeave(&pCtl->lock);
    2896                         rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    2897                                          (PFNRT)s->pDrvMount->pfnUnmount, 2, s->pDrvMount, false);
     2893                        rc = VMR3ReqCallWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
     2894                                             (PFNRT)s->pDrvMount->pfnUnmount, 2, s->pDrvMount, false);
    28982895                        AssertReleaseRC(rc);
    2899                         VMR3ReqFree(pReq);
    29002896                        {
    29012897                            STAM_PROFILE_START(&pCtl->StatLockWait, a);

  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r23009 r23012  
    29282928                           this, pszDevice, uInstance, uLun, eState, peState,
    29292929                           pszPath, fPassthrough);
    2930     /// @todo (r=dmik) bird, it would be nice to have a special VMR3Req method
    2931     //  for that purpose, that doesn't return useless VERR_TIMEOUT
    2932     if (vrc == VERR_TIMEOUT)
    2933         vrc = VINF_SUCCESS;
    29342930
    29352931    /* leave the lock before waiting for a result (EMT will call us back!) */
    29362932    alock.leave();
    29372933
    2938     if (VBOX_SUCCESS (vrc))
     2934    if (vrc == VERR_TIMEOUT || VBOX_SUCCESS (vrc))
    29392935    {
    29402936        vrc = VMR3ReqWait (pReq, RT_INDEFINITE_WAIT);
    … …  
    58825878
    58835879/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */
    5884     PVMREQ pReq = NULL;
    5885     int vrc = VMR3ReqCall (mpVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    5886                            (PFNRT) usbAttachCallback, 6, this, aHostDevice, uuid.ptr(), fRemote, Address.raw(), aMaskedIfs);
    5887     if (VBOX_SUCCESS (vrc))
    5888         vrc = pReq->iStatus;
    5889     VMR3ReqFree (pReq);
     5880    int vrc = VMR3ReqCallWait (mpVM, VMCPUID_ANY,
     5881                               (PFNRT) usbAttachCallback, 6, this, aHostDevice, uuid.ptr(), fRemote, Address.raw(), aMaskedIfs);
    58905882
    58915883    /* restore the lock */
    … …  
    60065998    alock.leave();
    60075999
    6008     PVMREQ pReq;
    60096000/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */
    6010     int vrc = VMR3ReqCall (mpVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    6011                            (PFNRT) usbDetachCallback, 4,
    6012                            this, &aIt, (*aIt)->id().raw());
    6013     if (VBOX_SUCCESS (vrc))
    6014         vrc = pReq->iStatus;
    6015     VMR3ReqFree (pReq);
    6016 
     6001    int vrc = VMR3ReqCallWait (mpVM, VMCPUID_ANY,
     6002                               (PFNRT) usbDetachCallback, 4, this, &aIt, (*aIt)->id().raw());
    60176003    ComAssertRCRet (vrc, E_FAIL);
    60186004
    … …  
    73877373                 *  to access Console.
    73887374                 */
    7389                 int vrc = VMR3ReqCall(that->mpVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    7390                                       (PFNRT)reconfigureHardDisks, 5, that->mpVM, lInstance, enmController, atts[i], &rc);
    7391                 if (RT_SUCCESS(vrc))
    7392                     vrc = pReq->iStatus;
    7393                 VMR3ReqFree(pReq);
     7375                int vrc = VMR3ReqCallWait(that->mpVM, VMCPUID_ANY,
     7376                                          (PFNRT)reconfigureHardDisks, 5, that->mpVM, lInstance, enmController, atts[i], &rc);
    73947377                if (RT_FAILURE(vrc))
    73957378                {

  • trunk/src/VBox/Main/DisplayImpl.cpp

    r22793 r23012  
    14221422
    14231423        /* send request to the EMT thread */
    1424         PVMREQ pReq = NULL;
    1425         int vrc = VMR3ReqCall (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1426             (PFNRT) changeFramebuffer, 3, this, aFramebuffer, aScreenId);
    1427         if (RT_SUCCESS(vrc))
    1428             vrc = pReq->iStatus;
    1429         VMR3ReqFree (pReq);
     1424        int vrc = VMR3ReqCallWait (pVM, VMCPUID_ANY,
     1425                                   (PFNRT) changeFramebuffer, 3, this, aFramebuffer, aScreenId);
    14301426
    14311427        alock.enter ();
    … …  
    15771573        &&  mpDrv->Connector.cy == height)
    15781574    {
    1579         PVMREQ pReq;
    15801575        size_t cbData = RT_ALIGN_Z(width, 4) * 4 * height;
    1581         rcVBox = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1582             (PFNRT)mpDrv->pUpPort->pfnSnapshot, 6, mpDrv->pUpPort,
    1583             address, cbData, (uintptr_t)NULL, (uintptr_t)NULL, (uintptr_t)NULL);
    1584         if (RT_SUCCESS(rcVBox))
    1585         {
    1586             rcVBox = pReq->iStatus;
    1587             VMR3ReqFree(pReq);
    1588         }
     1576        rcVBox = VMR3ReqCallWait(pVM, VMCPUID_ANY,  (PFNRT)mpDrv->pUpPort->pfnSnapshot, 6, mpDrv->pUpPort,
     1577                                 address, cbData, (uintptr_t)NULL, (uintptr_t)NULL, (uintptr_t)NULL);
    15891578    }
    15901579
    … …  
    16491638     * dirty conversion work.
    16501639     */
    1651     PVMREQ pReq;
    1652     int rcVBox = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1653         (PFNRT)mpDrv->pUpPort->pfnDisplayBlt, 6, mpDrv->pUpPort,
    1654         address, x, y, width, height);
    1655     if (RT_SUCCESS(rcVBox))
    1656     {
    1657         rcVBox = pReq->iStatus;
    1658         VMR3ReqFree(pReq);
    1659     }
     1640    int rcVBox = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)mpDrv->pUpPort->pfnDisplayBlt, 6,
     1641                                 mpDrv->pUpPort, address, x, y, width, height);
    16601642
    16611643    /*

  • trunk/src/VBox/Main/MachineDebuggerImpl.cpp

    r21878 r23012  
    198198    CheckComRCReturnRC(pVM.rc());
    199199
    200     PVMREQ pReq;
    201200    EMRAWMODE rawModeFlag = aEnable ? EMRAW_RING3_DISABLE : EMRAW_RING3_ENABLE;
    202     int rcVBox = VMR3ReqCall (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    203                               (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag);
    204     if (RT_SUCCESS(rcVBox))
    205     {
    206         rcVBox = pReq->iStatus;
    207         VMR3ReqFree (pReq);
    208     }
    209 
     201    int rcVBox = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag);
    210202    if (RT_SUCCESS(rcVBox))
    211203        return S_OK;
    … …  
    266258    CheckComRCReturnRC(pVM.rc());
    267259
    268     PVMREQ pReq;
    269260    EMRAWMODE rawModeFlag = aEnable ? EMRAW_RING0_DISABLE : EMRAW_RING0_ENABLE;
    270     int rcVBox = VMR3ReqCall (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    271                               (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag);
    272     if (RT_SUCCESS(rcVBox))
    273     {
    274         rcVBox = pReq->iStatus;
    275         VMR3ReqFree (pReq);
    276     }
    277 
     261    int rcVBox = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag);
    278262    if (RT_SUCCESS(rcVBox))
    279263        return S_OK;

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

    r22890 r23012  
    853853     * Call the VM, use EMT for serialization.
    854854     */
    855     PVMREQ pReq;
    856     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3Attach, 1, pVM);
    857     if (RT_SUCCESS(rc))
    858         rc = pReq->iStatus;
    859     VMR3ReqFree(pReq);
    860 
    861     return rc;
     855    /** @todo SMP */
     856    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3Attach, 1, pVM);
    862857}
    863858

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

    r22890 r23012  
    277277            rc = dbgfR3AddrToPhysOnVCpu(pVCpu, pAddress, pGCPhys);
    278278        else
    279         {
    280             PVMREQ pReq = NULL;
    281             rc = VMR3ReqCall(pVCpu->pVMR3, pVCpu->idCpu, &pReq, RT_INDEFINITE_WAIT,
    282                              (PFNRT)dbgfR3AddrToPhysOnVCpu, 3, pVCpu, pAddress, pGCPhys);
    283             if (RT_SUCCESS(rc))
    284             {
    285                 rc = pReq->iStatus;
    286                 VMR3ReqFree(pReq);
    287             }
    288         }
     279            rc = VMR3ReqCallWait(pVCpu->pVMR3, pVCpu->idCpu,
     280                                 (PFNRT)dbgfR3AddrToPhysOnVCpu, 3, pVCpu, pAddress, pGCPhys);
    289281    }
    290282    return rc;
    … …  
    443435     * Convert it.
    444436     */
    445     PVMREQ pReq = NULL;
    446     int rc = VMR3ReqCall(pVM, idCpu, &pReq, RT_INDEFINITE_WAIT,
    447                          (PFNRT)dbgfR3AddrToVolatileR3PtrOnVCpu, 5, pVM, idCpu, pAddress, fReadOnly, ppvR3Ptr);
    448     if (RT_SUCCESS(rc))
    449     {
    450         rc = pReq->iStatus;
    451         VMR3ReqFree(pReq);
    452     }
    453 
    454     return rc;
     437    return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3AddrToVolatileR3PtrOnVCpu, 5, pVM, idCpu, pAddress, fReadOnly, ppvR3Ptr);
    455438}
    456439

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

    r20374 r23012  
    287287     * This must be done in EMT.
    288288     */
    289     PVMREQ pReq;
    290     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetInt3, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp);
    291     if (RT_SUCCESS(rc))
    292         rc = pReq->iStatus;
    293     VMR3ReqFree(pReq);
     289    /** @todo SMP? */
     290    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpSetInt3, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp);
    294291    LogFlow(("DBGFR3BpSet: returns %Rrc\n", rc));
    295292    return rc;
    … …  
    448445     * This must be done in EMT.
    449446     */
    450     PVMREQ pReq;
    451     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetReg, 7, pVM, pAddress, &iHitTrigger, &iHitDisable, fType, cb, piBp);
    452     if (RT_SUCCESS(rc))
    453         rc = pReq->iStatus;
    454     VMR3ReqFree(pReq);
     447    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpSetReg, 7, pVM, pAddress, &iHitTrigger, &iHitDisable, fType, cb, piBp);
    455448    LogFlow(("DBGFR3BpSetReg: returns %Rrc\n", rc));
    456449    return rc;
    … …  
    619612     * This must be done in EMT.
    620613     */
    621     PVMREQ pReq;
    622     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetREM, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp);
    623     if (RT_SUCCESS(rc))
    624         rc = pReq->iStatus;
    625     VMR3ReqFree(pReq);
     614    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpSetREM, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp);
    626615    LogFlow(("DBGFR3BpSetREM: returns %Rrc\n", rc));
    627616    return rc;
    … …  
    715704     * This must be done in EMT.
    716705     */
    717     PVMREQ pReq;
    718     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpClear, 2, pVM, iBp);
    719     if (RT_SUCCESS(rc))
    720         rc = pReq->iStatus;
    721     VMR3ReqFree(pReq);
     706    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpClear, 2, pVM, iBp);
    722707    LogFlow(("DBGFR3BpClear: returns %Rrc\n", rc));
    723708    return rc;
    … …  
    792777     * This must be done in EMT.
    793778     */
    794     PVMREQ pReq;
    795     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpEnable, 2, pVM, iBp);
    796     if (RT_SUCCESS(rc))
    797         rc = pReq->iStatus;
    798     VMR3ReqFree(pReq);
     779    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpEnable, 2, pVM, iBp);
    799780    LogFlow(("DBGFR3BpEnable: returns %Rrc\n", rc));
    800781    return rc;
    … …  
    869850     * This must be done in EMT.
    870851     */
    871     PVMREQ pReq;
    872     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpDisable, 2, pVM, iBp);
    873     if (RT_SUCCESS(rc))
    874         rc = pReq->iStatus;
    875     VMR3ReqFree(pReq);
     852    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpDisable, 2, pVM, iBp);
    876853    LogFlow(("DBGFR3BpDisable: returns %Rrc\n", rc));
    877854    return rc;
    … …  
    945922     * This must be done in EMT.
    946923     */
    947     PVMREQ pReq;
    948     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpEnum, 3, pVM, pfnCallback, pvUser);
    949     if (RT_SUCCESS(rc))
    950         rc = pReq->iStatus;
    951     VMR3ReqFree(pReq);
     924    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3BpEnum, 3, pVM, pfnCallback, pvUser);
    952925    LogFlow(("DBGFR3BpClear: returns %Rrc\n", rc));
    953926    return rc;

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

    r22890 r23012  
    563563        rc = dbgfR3DisasInstrExOnVCpu(pVM, pVCpu, Sel, &GCPtr, fFlags, pszOutput, cchOutput, pcbInstr);
    564564    else
    565     {
    566         PVMREQ pReq = NULL;
    567         rc = VMR3ReqCall(pVM, idCpu, &pReq, RT_INDEFINITE_WAIT,
    568                          (PFNRT)dbgfR3DisasInstrExOnVCpu, 8,
    569                          pVM, VMMGetCpuById(pVM, idCpu), Sel, &GCPtr, fFlags, pszOutput, cchOutput, pcbInstr);
    570         if (RT_SUCCESS(rc))
    571         {
    572             rc = pReq->iStatus;
    573             VMR3ReqFree(pReq);
    574         }
    575     }
     565        rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3DisasInstrExOnVCpu, 8,
     566                             pVM, VMMGetCpuById(pVM, idCpu), Sel, &GCPtr, fFlags, pszOutput, cchOutput, pcbInstr);
    576567    return rc;
    577568}

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

    r21377 r23012  
    4949VMMR3DECL(int) DBGFR3LogModifyGroups(PVM pVM, const char *pszGroupSettings)
    5050{
    51     AssertReturn(VALID_PTR(pVM), VERR_INVALID_POINTER);
    52     AssertReturn(VALID_PTR(pszGroupSettings), VERR_INVALID_POINTER);
     51    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
     52    AssertPtrReturn(pszGroupSettings, VERR_INVALID_POINTER);
    5353
    54     PVMREQ pReq;
    55     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyGroups, 2, pVM, pszGroupSettings);
    56     if (RT_SUCCESS(rc))
    57         rc = pReq->iStatus;
    58     VMR3ReqFree(pReq);
    59     return rc;
     54    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3LogModifyGroups, 2, pVM, pszGroupSettings);
    6055}
    6156
    … …  
    8681VMMR3DECL(int) DBGFR3LogModifyFlags(PVM pVM, const char *pszFlagSettings)
    8782{
    88     AssertReturn(VALID_PTR(pVM), VERR_INVALID_POINTER);
    89     AssertReturn(VALID_PTR(pszFlagSettings), VERR_INVALID_POINTER);
     83    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
     84    AssertPtrReturn(pszFlagSettings, VERR_INVALID_POINTER);
    9085
    91     PVMREQ pReq;
    92     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyFlags, 2, pVM, pszFlagSettings);
    93     if (RT_SUCCESS(rc))
    94         rc = pReq->iStatus;
    95     VMR3ReqFree(pReq);
    96     return rc;
     86    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3LogModifyFlags, 2, pVM, pszFlagSettings);
    9787}
    9888
    … …  
    126116    AssertReturn(VALID_PTR(pszDestSettings), VERR_INVALID_POINTER);
    127117
    128     PVMREQ pReq;
    129     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyDestinations, 2, pVM, pszDestSettings);
    130     if (RT_SUCCESS(rc))
    131         rc = pReq->iStatus;
    132     VMR3ReqFree(pReq);
    133     return rc;
     118    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3LogModifyDestinations, 2, pVM, pszDestSettings);
    134119}
    135120

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

    r23011 r23012  
    123123{
    124124    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    125 
    126     PVMREQ pReq;
    127     int rc = VMR3ReqCall(pVM, idCpu, &pReq, RT_INDEFINITE_WAIT,
    128                          (PFNRT)dbgfR3MemScan, 7, pVM, idCpu, pAddress, &cbRange, pabNeedle, cbNeedle, pHitAddress);
    129     if (RT_SUCCESS(rc))
    130         rc = pReq->iStatus;
    131     VMR3ReqFree(pReq);
    132 
    133     return rc;
     125    return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3MemScan, 7,
     126                           pVM, idCpu, pAddress, &cbRange, pabNeedle, cbNeedle, pHitAddress);
     127
    134128}
    135129

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

    r22890 r23012  
    464464            AssertFailedReturn(VERR_INVALID_PARAMETER);
    465465    }
    466     PVMREQ pReq;
    467     int rc = VMR3ReqCall(pVM, idCpu, &pReq, RT_INDEFINITE_WAIT,
    468                          (PFNRT)dbgfR3StackWalkCtxFull, 10,
    469                          pVM, idCpu, pCtxCore, hAs, enmCodeType,
    470                          pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
    471     if (RT_SUCCESS(rc))
    472         rc = pReq->iStatus;
    473     VMR3ReqFree(pReq);
    474 
    475     return rc;
    476 
     466    return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3StackWalkCtxFull, 10,
     467                           pVM, idCpu, pCtxCore, hAs, enmCodeType,
     468                           pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
    477469}
    478470

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

    r23009 r23012  
    148148                    pgmUnlock(pVM);
    149149
    150                     PVMREQ pReq = NULL;
    151                     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    152                                          (PFNRT)pgmR3PhysReadExternalEMT, 4, pVM, &GCPhys, pvBuf, cbRead);
    153                     if (RT_SUCCESS(rc))
    154                     {
    155                         rc = pReq->iStatus;
    156                         VMR3ReqFree(pReq);
    157                     }
    158                     return rc;
     150                    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysReadExternalEMT, 4,
     151                                           pVM, &GCPhys, pvBuf, cbRead);
    159152                }
    160153                Assert(!PGM_PAGE_IS_MMIO(pPage));
    … …  
    284277                    pgmUnlock(pVM);
    285278
    286                     PVMREQ pReq = NULL;
    287                     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    288                                          (PFNRT)pgmR3PhysWriteExternalEMT, 4, pVM, &GCPhys, pvBuf, cbWrite);
    289                     if (RT_SUCCESS(rc))
    290                     {
    291                         rc = pReq->iStatus;
    292                         VMR3ReqFree(pReq);
    293                     }
    294                     return rc;
     279                    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysWriteExternalEMT, 4,
     280                                           pVM, &GCPhys, pvBuf, cbWrite);
    295281                }
    296282                Assert(!PGM_PAGE_IS_MMIO(pPage));
    … …  
    458444                pgmUnlock(pVM);
    459445
    460                 PVMREQ pReq = NULL;
    461                 rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    462                                  (PFNRT)pgmR3PhysGCPhys2CCPtrDelegated, 4, pVM, &GCPhys, ppv, pLock);
    463                 if (RT_SUCCESS(rc))
    464                 {
    465                     rc = pReq->iStatus;
    466                     VMR3ReqFree(pReq);
    467                 }
    468                 return rc;
     446                return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysGCPhys2CCPtrDelegated, 4,
     447                                       pVM, &GCPhys, ppv, pLock);
    469448            }
    470449

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

    r22890 r23012  
    25232523VMMDECL(int) TMR3SetWarpDrive(PVM pVM, uint32_t u32Percent)
    25242524{
    2525     PVMREQ pReq;
    2526     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    2527                          (PFNRT)tmR3SetWarpDrive, 2, pVM, u32Percent);
    2528     if (RT_SUCCESS(rc))
    2529         rc = pReq->iStatus;
    2530     VMR3ReqFree(pReq);
    2531     return rc;
     2525    return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)tmR3SetWarpDrive, 2, pVM, u32Percent);
    25322526}
    25332527

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

    r21367 r23012  
    192192
    193193#else /* IN_RING3: */
    194     PVMREQ pReq;
    195     VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)PDMR3QueueFlushWorker, 2, pVM, pQueue);
    196     VMR3ReqFree(pReq);
     194    VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)PDMR3QueueFlushWorker, 2, pVM, pQueue);
    197195#endif
    198196}

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

    r23011 r23012  
    8585    va_list va2;
    8686    va_copy(va2, args); /* Have to make a copy here or GCC will break. */
    87     PVMREQ pReq;
    88     VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3SetErrorUV, 7,   /* ASSUMES 3 source pos args! */
    89                 pVM->pUVM, rc, RT_SRC_POS_ARGS, pszFormat, &va2);
    90     VMR3ReqFree(pReq);
     87    VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)vmR3SetErrorUV, 7,   /* ASSUMES 3 source pos args! */
     88                    pVM->pUVM, rc, RT_SRC_POS_ARGS, pszFormat, &va2);
    9189    va_end(va2);
    9290

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

    r19500 r23012  
    834834         * Load memory.
    835835         */
    836         PVMREQ pReq1 = NULL;
    837836        if (FileRawMem != NIL_RTFILE)
    838             rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)loadMem, 3, pVM, FileRawMem, &offRawMem);
     837            rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)loadMem, 3, pVM, FileRawMem, &offRawMem);
    839838        else
    840             rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)SSMR3Load, 4, pVM, pszSavedState, SSMAFTER_DEBUG_IT, NULL, NULL);
    841         AssertReleaseRC(rc);
    842         rc = pReq1->iStatus;
    843         VMR3ReqFree(pReq1);
     839            rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)SSMR3Load, 4, pVM, pszSavedState, SSMAFTER_DEBUG_IT, NULL, NULL);
    844840        if (RT_SUCCESS(rc))
    845841        {
    … …  
    848844             */
    849845            if (FileScript != NIL_RTFILE)
    850             {
    851                 rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)scriptRun, 2, pVM, FileScript);
    852                 AssertReleaseRC(rc);
    853                 rc = pReq1->iStatus;
    854                 VMR3ReqFree(pReq1);
    855             }
     846                rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)scriptRun, 2, pVM, FileScript);
    856847            if (RT_SUCCESS(rc))
    857848            {
    … …  
    877868                    if (RT_SUCCESS(rc))
    878869                    {
    879                         rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)EMR3RawSetMode, 2, pVM, EMRAW_NONE);
     870                        rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)EMR3RawSetMode, 2, pVM, EMRAW_NONE);
    880871                        AssertReleaseRC(rc);
    881                         VMR3ReqFree(pReq1);
    882 
    883872                        DBGFR3Info(pVM, "cpumguest", "verbose", NULL);
    884873                        if (fPowerOn)

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

    r19300 r23012  
    9393         */
    9494        RTPrintf(TESTCASE ": Testing...\n");
    95         PVMREQ pReq1 = NULL;
    96         rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)VMMDoHwAccmTest, 1, pVM);
     95        rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMMDoHwAccmTest, 1, pVM);
    9796        AssertRC(rc);
    98         VMR3ReqFree(pReq1);
    9997
    10098        STAMR3Dump(pVM, "*");
    … …  
    104102         */
    105103        rc = VMR3Destroy(pVM);
    106         if (!RT_SUCCESS(rc))
     104        if (RT_FAILURE(rc))
    107105        {
    108106            RTPrintf(TESTCASE ": error: failed to destroy vm! rc=%d\n", rc);

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

    r23011 r23012  
    281281            {
    282282                RTTestSub(hTest, "VMM");
    283                 PVMREQ pReq1 = NULL;
    284                 rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)VMMDoTest, 1, pVM);
     283                rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMMDoTest, 1, pVM);
    285284                if (RT_FAILURE(rc))
    286                     RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
    287                 else if (RT_FAILURE(pReq1->iStatus))
    288285                    RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
    289                 VMR3ReqFree(pReq1);
    290286                break;
    291287            }
    … …  
    301297                }
    302298
    303                 PVMREQ pReq1 = NULL;
    304                 rc = VMR3ReqCall(pVM, 0, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)tstTMWorker, 2, pVM, hTest);
     299                rc = VMR3ReqCallWait(pVM, 0 /*idDstCpu*/, (PFNRT)tstTMWorker, 2, pVM, hTest);
    305300                if (RT_FAILURE(rc))
    306                     RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
    307                 else if (RT_FAILURE(pReq1->iStatus))
    308301                    RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
    309                 VMR3ReqFree(pReq1);
    310302                break;
    311303            }

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

    r19300 r23012  
    136136                RTPrintf(TESTCASE ": fork() returned fine.\n");
    137137                RTPrintf(TESTCASE ": testing VM after fork.\n");
    138                 PVMREQ pReq1 = NULL;
    139                 rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq1, RT_INDEFINITE_WAIT, (PFNRT)VMMDoTest, 1, pVM);
    140                 AssertRC(rc);
    141                 VMR3ReqFree(pReq1);
     138                VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMMDoTest, 1, pVM);
    142139
    143140                STAMR3Dump(pVM, "*");

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

    r19300 r23012  
    134134#endif
    135135
    136     PVMREQ pReq;
    137     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)PassVACallback, 5,
    138                          pVM, _4K, _1G, pszFormat, pvVA);
    139     if (RT_SUCCESS(rc))
    140         rc = pReq->iStatus;
    141     VMR3ReqFree(pReq);
     136    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)PassVACallback, 5, pVM, _4K, _1G, pszFormat, pvVA);
     137    NOREF(rc);
    142138
    143139#if 1
    … …  
    156152    va_list va1;
    157153    va_start(va1, pszFormat);
    158     PVMREQ pReq;
    159     int rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)PassVACallback, 5,
    160                          pVM, _4K, _1G, pszFormat, &va1);
    161     if (RT_SUCCESS(rc))
    162         rc = pReq->iStatus;
    163     VMR3ReqFree(pReq);
     154    int rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)PassVACallback, 5, pVM, _4K, _1G, pszFormat, &va1);
    164155    va_end(va1);
     156    NOREF(rc);
    165157
    166158    /* 2nd test */

  • trunk/src/recompiler/VBoxRecompiler.c

    r22890 r23012  
    36473647        return remR3DisasEnableStepping(pVM, fEnable);
    36483648
    3649     rc = VMR3ReqCall(pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)remR3DisasEnableStepping, 2, pVM, fEnable);
     3649    rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)remR3DisasEnableStepping, 2, pVM, fEnable);
    36503650    AssertRC(rc);
    36513651    if (RT_SUCCESS(rc))
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette