VirtualBox

Changeset 13782

Show
Ignore:
Timestamp:
11/04/08 13:16:30 (2 months ago)
Author:
vboxsync
Message:

More SMP groundwork.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/include/VBox/uvm.h

    r13755 r13782  
    3636#include <VBox/types.h> 
    3737 
     38/* Forward decl. */ 
     39struct UVM; 
     40 
    3841/** 
    3942 * Per virtual CPU ring-3 (user mode) data. 
    …… 
    4144typedef struct UVMCPU 
    4245{ 
    43     uint32_t     uFiller; 
     46    struct UVM                     *pUVM; 
     47    RTCPUID                         idCPU; 
     48 
    4449    /** The VM internal data. */ 
    4550    struct 
    …… 
    5055        uint8_t                     padding[768]; 
    5156    } vm; 
    52 } UVMCPU; 
     57} UVMCPU, *PUVMCPU; 
    5358 
    5459/** 

  • trunk/include/VBox/vmapi.h

    r13765 r13782  
    272272    VMREQDEST_CPU0          = 0, 
    273273 
    274     /** Request packet for the VM (any VCPU can handle it). */ 
    275     VMREQDEST_ALL           = -1 
     274    /** Request packet for all VMCPU threads. */ 
     275    VMREQDEST_BROADCAST     = 0x1000, 
     276 
     277    /** Request packet for any VMCPU thread. */ 
     278    VMREQDEST_ANY           = 0x1001 
    276279} VMREQDEST; 
    277280 

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

    r13756 r13782  
    23372337 
    23382338                        PDMCritSectLeave(&pCtl->lock); 
    2339                         rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     2339                        rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    23402340                                         (PFNRT)s->pDrvMount->pfnUnmount, 2, s->pDrvMount, false); 
    23412341                        AssertReleaseRC(rc); 
    …… 
    39093909 
    39103910    pCtl->fRedoIdle = true; 
    3911     rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     3911    rc = VMR3ReqCall(PDMDevHlpGetVM(pDevIns), VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    39123912                     (PFNRT)PDMDevHlpVMSuspend, 1, pDevIns); 
    39133913    AssertReleaseRC(rc); 

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

    r13756 r13782  
    249249        PVMREQ pReq; 
    250250 
    251         rc = VMR3ReqCallVoid (pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     251        rc = VMR3ReqCallVoid (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    252252                              (PFNRT) vmmdevCtlGuestFilterMask_EMT, 
    253253                              3, pVMMDevState, u32OrMask, u32NotMask); 
    …… 
    274274     * about something, which has already happened. 
    275275     */ 
    276     rc = VMR3ReqCallEx(pVM, VMREQDEST_ALL, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
     276    rc = VMR3ReqCallEx(pVM, VMREQDEST_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
    277277                       (PFNRT) vmmdevNotifyGuest_EMT, 
    278278                       2, pVMMDevState, u32EventMask); 

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

    r13756 r13782  
    11381138 
    11391139    /* Not safe to execute asynchroneously; forward to EMT */ 
    1140     int rc = VMR3ReqCallEx(PDMDevHlpGetVM(pVMMDevState->pDevIns), VMREQDEST_ALL, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
     1140    int rc = VMR3ReqCallEx(PDMDevHlpGetVM(pVMMDevState->pDevIns), VMREQDEST_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
    11411141                           (PFNRT)hgcmCompletedWorker, 3, pInterface, result, pCmd); 
    11421142    AssertRC(rc); 

  • trunk/src/VBox/Frontends/VBoxBFE/DisplayImpl.cpp

    r13755 r13782  
    378378    /* pdm.h says that this has to be called from the EMT thread */ 
    379379    PVMREQ pReq; 
    380     int rcVBox = VMR3ReqCallVoid(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     380    int rcVBox = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    381381                                 (PFNRT)VMDisplay::doInvalidateAndUpdate, 1, mpDrv); 
    382382    if (VBOX_SUCCESS(rcVBox)) 

  • trunk/src/VBox/Frontends/VBoxBFE/HostUSBImpl.cpp

    r13755 r13782  
    244244    LogFlowMember (("Console::AttachUSBDevice: Proxying USB device '%s' %Vuuid...\n", Address.c_str(), &Uuid)); 
    245245    PVMREQ pReq; 
    246     vrc = VMR3ReqCall (mpVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     246    vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    247247                       (PFNRT)pRhConfig->pfnCreateProxyDevice, 
    248248                       5, pRhConfig, &Uuid, fRemote, 
    …… 
    303303            LogFlowMember (("Console::DetachUSBDevice: Detaching USB proxy device %Vuuid...\n", &Uuid)); 
    304304            PVMREQ pReq; 
    305             vrc = VMR3ReqCall (mpVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)pRhConfig->pfnDestroyProxyDevice, 
     305            vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)pRhConfig->pfnDestroyProxyDevice, 
    306306                               2, pRhConfig, &Uuid); 
    307307            if (VBOX_SUCCESS (vrc)) 

  • trunk/src/VBox/Frontends/VBoxBFE/MachineDebuggerImpl.cpp

    r13755 r13782  
    138138    PVMREQ pReq; 
    139139    EMRAWMODE rawModeFlag = enable ? EMRAW_RING3_DISABLE : EMRAW_RING3_ENABLE; 
    140     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     140    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    141141                             (PFNRT)EMR3RawSetMode, 2, pVM, rawModeFlag); 
    142142    if (VBOX_SUCCESS(rcVBox)) 
    …… 
    198198    PVMREQ pReq; 
    199199    EMRAWMODE rawModeFlag = enable ? EMRAW_RING0_DISABLE : EMRAW_RING0_ENABLE; 
    200     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     200    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    201201                             (PFNRT)EMR3RawSetMode, 2, pVM, rawModeFlag); 
    202202    if (VBOX_SUCCESS(rcVBox)) 

  • trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.cpp

    r13755 r13782  
    965965            /* Power off VM */ 
    966966            PVMREQ pReq; 
    967             rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOff, 1, pVM); 
     967            rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOff, 1, pVM); 
    968968        } 
    969969 
    …… 
    12741274        { 
    12751275            startProgressInfo("Restoring"); 
    1276             rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1276            rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    12771277                             (PFNRT)VMR3Load, 4, pVM, g_pszStateFile, &callProgressInfo, NULL); 
    12781278            endProgressInfo(); 
    …… 
    12801280            { 
    12811281                VMR3ReqFree(pReq); 
    1282                 rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1282                rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    12831283                                 (PFNRT)VMR3Resume, 1, pVM); 
    12841284                if (VBOX_SUCCESS(rc)) 
    …… 
    12941294        else 
    12951295        { 
    1296             rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOn, 1, pVM); 
     1296            rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOn, 1, pVM); 
    12971297            if (VBOX_SUCCESS(rc)) 
    12981298            { 

  • trunk/src/VBox/Frontends/VBoxBFE/VMControl.cpp

    r13755 r13782  
    6363 
    6464    PVMREQ pReq; 
    65     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     65    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    6666                             (PFNRT)VMR3Suspend, 1, pVM); 
    6767    AssertRC(rcVBox); 
    …… 
    8484 
    8585    PVMREQ pReq; 
    86     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     86    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    8787                             (PFNRT)VMR3Resume, 1, pVM); 
    8888    AssertRC(rcVBox); 
    …… 
    102102{ 
    103103    PVMREQ pReq; 
    104     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     104    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    105105                             (PFNRT)VMR3Reset, 1, pVM); 
    106106    AssertRC(rcVBox); 
    …… 
    160160 
    161161    startProgressInfo("Saving"); 
    162     rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     162    rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    163163                     (PFNRT)VMR3Save, 4, pVM, g_pszStateFile, &callProgressInfo, NULL); 
    164164    endProgressInfo(); 
    …… 
    193193    { 
    194194        PVMREQ pReq; 
    195         rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     195        rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    196196                         (PFNRT)VMR3Suspend, 1, pVM); 
    197197        AssertRC(rc); 

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

    r13779 r13782  
    28012801     */ 
    28022802    PVMREQ pReq; 
    2803     int vrc = VMR3ReqCall (mpVM, VMREQDEST_ALL, &pReq, 0 /* no wait! */, 
     2803    int vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, 0 /* no wait! */, 
    28042804                           (PFNRT) Console::changeDrive, 8, 
    28052805                           this, pszDevice, uInstance, uLun, eState, peState, 
    …… 
    55215521/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */ 
    55225522    PVMREQ pReq = NULL; 
    5523     int vrc = VMR3ReqCall (mpVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     5523    int vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    55245524                           (PFNRT) usbAttachCallback, 6, this, aHostDevice, Uuid.ptr(), fRemote, Address.raw(), aMaskedIfs); 
    55255525    if (VBOX_SUCCESS (vrc)) 
    …… 
    56465646    PVMREQ pReq; 
    56475647/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */ 
    5648     int vrc = VMR3ReqCall (mpVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     5648    int vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    56495649                           (PFNRT) usbDetachCallback, 4, 
    56505650                           this, &aIt, (*aIt)->id().raw()); 
    …… 
    71307130                 *  to access Console. 
    71317131                 */ 
    7132                 int vrc = VMR3ReqCall (that->mpVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     7132                int vrc = VMR3ReqCall (that->mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    71337133                                       (PFNRT)reconfigureHardDisks, 3, that->mpVM, 
    71347134                                       atts [i], &rc); 

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

    r13755 r13782  
    13481348        /* send request to the EMT thread */ 
    13491349        PVMREQ pReq = NULL; 
    1350         int vrc = VMR3ReqCall (pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1350        int vrc = VMR3ReqCall (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    13511351                               (PFNRT) changeFramebuffer, 4, 
    13521352                               this, static_cast <IFramebuffer *> (frameBuf), 
    …… 
    14351435        /* send request to the EMT thread */ 
    14361436        PVMREQ pReq = NULL; 
    1437         int vrc = VMR3ReqCall (pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1437        int vrc = VMR3ReqCall (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    14381438                               (PFNRT) changeFramebuffer, 4, 
    14391439                               this, frameBuf, false /* aInternal */, VBOX_VIDEO_PRIMARY_SCREEN); 
    …… 
    14761476        /* send request to the EMT thread */ 
    14771477        PVMREQ pReq = NULL; 
    1478         int vrc = VMR3ReqCall (pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1478        int vrc = VMR3ReqCall (pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    14791479                               (PFNRT) changeFramebuffer, 4, 
    14801480                               this, aFramebuffer, false /* aInternal */, aScreenId); 
    …… 
    16311631        PVMREQ pReq; 
    16321632        size_t cbData = RT_ALIGN_Z(width, 4) * 4 * height; 
    1633         rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1633        rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    16341634                             (PFNRT)mpDrv->pUpPort->pfnSnapshot, 6, mpDrv->pUpPort, 
    16351635                             address, cbData, NULL, NULL, NULL); 
    …… 
    16921692     */ 
    16931693    PVMREQ pReq; 
    1694     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1694    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    16951695                             (PFNRT)mpDrv->pUpPort->pfnDisplayBlt, 6, mpDrv->pUpPort, 
    16961696                             address, x, y, width, height); 
    …… 
    17521752    /* pdm.h says that this has to be called from the EMT thread */ 
    17531753    PVMREQ pReq; 
    1754     int rcVBox = VMR3ReqCallVoid(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     1754    int rcVBox = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    17551755                                 (PFNRT)mpDrv->pUpPort->pfnUpdateDisplayAll, 1, mpDrv->pUpPort); 
    17561756    if (VBOX_SUCCESS(rcVBox)) 

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

    r13755 r13782  
    244244    PVMREQ pReq; 
    245245    EMRAWMODE rawModeFlag = enable ? EMRAW_RING3_DISABLE : EMRAW_RING3_ENABLE; 
    246     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     246    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    247247                             (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag); 
    248248    if (VBOX_SUCCESS(rcVBox)) 
    …… 
    313313    PVMREQ pReq; 
    314314    EMRAWMODE rawModeFlag = enable ? EMRAW_RING0_DISABLE : EMRAW_RING0_ENABLE; 
    315     int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 
     315    int rcVBox = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
    316316                             (PFNRT)EMR3RawSetMode, 2, pVM.raw(), rawModeFlag); 
    317317    if (VBOX_SUCCESS(rcVBox)) 

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

    r13765 r13782  
    611611            { 
    612612                LogFlow(("dbgfR3VMMWait: Processes requests...\n")); 
    613                 rc = VMR3ReqProcessU(pVM->pUVM, VMREQDEST_ALL); 
     613                rc = VMR3ReqProcessU(pVM->pUVM, VMREQDEST_ANY); 
    614614                LogFlow(("dbgfR3VMMWait: VMR3ReqProcess -> %Vrc rcRet=%Vrc\n", rc, rcRet)); 
    615615                if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) 
    …… 
    823823     */ 
    824824    PVMREQ pReq; 
    825     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3Attach, 1, pVM); 
     825    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3Attach, 1, pVM); 
    826826    if (RT_SUCCESS(rc)) 
    827827        rc = pReq->iStatus; 

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

    r13755 r13782  
    288288     */ 
    289289    PVMREQ pReq; 
    290     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetInt3, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp); 
     290    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetInt3, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp); 
    291291    if (VBOX_SUCCESS(rc)) 
    292292        rc = pReq->iStatus; 
    …… 
    437437     */ 
    438438    PVMREQ pReq; 
    439     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetReg, 7, pVM, pAddress, &iHitTrigger, &iHitDisable, fType, cb, piBp); 
     439    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetReg, 7, pVM, pAddress, &iHitTrigger, &iHitDisable, fType, cb, piBp); 
    440440    if (VBOX_SUCCESS(rc)) 
    441441        rc = pReq->iStatus; 
    …… 
    602602     */ 
    603603    PVMREQ pReq; 
    604     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetREM, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp); 
     604    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpSetREM, 5, pVM, pAddress, &iHitTrigger, &iHitDisable, piBp); 
    605605    if (VBOX_SUCCESS(rc)) 
    606606        rc = pReq->iStatus; 
    …… 
    698698     */ 
    699699    PVMREQ pReq; 
    700     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpClear, 2, pVM, iBp); 
     700    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpClear, 2, pVM, iBp); 
    701701    if (VBOX_SUCCESS(rc)) 
    702702        rc = pReq->iStatus; 
    …… 
    775775     */ 
    776776    PVMREQ pReq; 
    777     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpEnable, 2, pVM, iBp); 
     777    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpEnable, 2, pVM, iBp); 
    778778    if (VBOX_SUCCESS(rc)) 
    779779        rc = pReq->iStatus; 
    …… 
    852852     */ 
    853853    PVMREQ pReq; 
    854     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpDisable, 2, pVM, iBp); 
     854    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpDisable, 2, pVM, iBp); 
    855855    if (VBOX_SUCCESS(rc)) 
    856856        rc = pReq->iStatus; 
    …… 
    928928     */ 
    929929    PVMREQ pReq; 
    930     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpEnum, 3, pVM, pfnCallback, pvUser); 
     930    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3BpEnum, 3, pVM, pfnCallback, pvUser); 
    931931    if (VBOX_SUCCESS(rc)) 
    932932        rc = pReq->iStatus; 

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

    r13755 r13782  
    717717            case DBGFINFOTYPE_DEV: 
    718718                if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT) 
    719                     rc = VMR3ReqCallVoid(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Dev.pfnHandler, 3, Info.u.Dev.pDevIns, pHlp, pszArgs); 
     719                    rc = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Dev.pfnHandler, 3, Info.u.Dev.pDevIns, pHlp, pszArgs); 
    720720                else 
    721721                    Info.u.Dev.pfnHandler(Info.u.Dev.pDevIns, pHlp, pszArgs); 
    …… 
    724724            case DBGFINFOTYPE_DRV: 
    725725                if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT) 
    726                     rc = VMR3ReqCallVoid(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Drv.pfnHandler, 3, Info.u.Drv.pDrvIns, pHlp, pszArgs); 
     726                    rc = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Drv.pfnHandler, 3, Info.u.Drv.pDrvIns, pHlp, pszArgs); 
    727727                else 
    728728                    Info.u.Drv.pfnHandler(Info.u.Drv.pDrvIns, pHlp, pszArgs); 
    …… 
    731731            case DBGFINFOTYPE_INT: 
    732732                if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT) 
    733                     rc = VMR3ReqCallVoid(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Int.pfnHandler, 3, pVM, pHlp, pszArgs); 
     733                    rc = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Int.pfnHandler, 3, pVM, pHlp, pszArgs); 
    734734                else 
    735735                    Info.u.Int.pfnHandler(pVM, pHlp, pszArgs); 
    …… 
    738738            case DBGFINFOTYPE_EXT: 
    739739                if (Info.fFlags & DBGFINFO_FLAGS_RUN_ON_EMT) 
    740                     rc = VMR3ReqCallVoid(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Ext.pfnHandler, 3, Info.u.Ext.pvUser, pHlp, pszArgs); 
     740                    rc = VMR3ReqCallVoid(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)Info.u.Ext.pfnHandler, 3, Info.u.Ext.pvUser, pHlp, pszArgs); 
    741741                else 
    742742                    Info.u.Ext.pfnHandler(Info.u.Ext.pvUser, pHlp, pszArgs); 

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

    r13755 r13782  
    5353 
    5454    PVMREQ pReq; 
    55     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyGroups, 2, pVM, pszGroupSettings); 
     55    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyGroups, 2, pVM, pszGroupSettings); 
    5656    if (VBOX_SUCCESS(rc)) 
    5757        rc = pReq->iStatus; 
    …… 
    9090 
    9191    PVMREQ pReq; 
    92     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyFlags, 2, pVM, pszFlagSettings); 
     92    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyFlags, 2, pVM, pszFlagSettings); 
    9393    if (VBOX_SUCCESS(rc)) 
    9494        rc = pReq->iStatus; 
    …… 
    127127 
    128128    PVMREQ pReq; 
    129     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyDestinations, 2, pVM, pszDestSettings); 
     129    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3LogModifyDestinations, 2, pVM, pszDestSettings); 
    130130    if (VBOX_SUCCESS(rc)) 
    131131        rc = pReq->iStatus; 

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

    r13755 r13782  
    113113{ 
    114114    PVMREQ pReq; 
    115     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3MemScan, 6, 
     115    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3MemScan, 6, 
    116116                         pVM, pAddress, cbRange, pabNeedle, cbNeedle, pHitAddress); 
    117117    if (VBOX_SUCCESS(rc)) 
    …… 
    180180{ 
    181181    PVMREQ pReq; 
    182     int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3MemRead, 4, 
     182    int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3MemRead, 4, 
    183183                          pVM, pAddress, pvBuf, cbRead); 
    184184    if (VBOX_SUCCESS(rc)) 
    …… 
    277277     */ 
    278278    PVMREQ pReq; 
    279     int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3MemReadString, 4, 
     279    int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3MemReadString, 4, 
    280280                          pVM, pAddress, pszBuf, cchBuf); 
    281281    if (VBOX_SUCCESS(rc)) 

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

    r13755 r13782  
    115115     */ 
    116116    PVMREQ pReq; 
    117     int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSRegister, 2, pVM, pReg); 
     117    int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSRegister, 2, pVM, pReg); 
    118118    if (RT_SUCCESS(rc)) 
    119119        rc = pReq->iStatus; 
    …… 
    223223     */ 
    224224    PVMREQ pReq; 
    225     int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSDetect, 3, pVM, pszName, cchName); 
     225    int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSDetect, 3, pVM, pszName, cchName); 
    226226    if (RT_SUCCESS(rc)) 
    227227        rc = pReq->iStatus; 
    …… 
    307307     */ 
    308308    PVMREQ pReq; 
    309     int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSQueryNameAndVersion, 
     309    int rc = VMR3ReqCallU(pVM->pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)dbgfR3OSQueryNameAndVersion, 
    310310                          5, pVM, pszName, cchName, pszVersion, cchVersion); 
    311311    if (RT_SUCCESS(rc)) 
    …… 
    358358    void *pvIf = NULL; 
    359359    PVMREQ pReq; 
    360     VMR3ReqCallVoidU(pVM->pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3OSQueryInterface, 3, pVM, enmIf, &pvIf); 
     360    VMR3ReqCallVoidU(pVM->pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3OSQueryInterface, 3, pVM, enmIf, &pvIf); 
    361361    VMR3ReqFree(pReq); 
    362362 

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

    r13755 r13782  
    357357 
    358358    PVMREQ pReq; 
    359     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3StackWalkCtxFull, 4, 
     359    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3StackWalkCtxFull, 4, 
    360360                         pVM, pFrame, CPUMGetGuestCtxCore(pVM), true); 
    361361    if (VBOX_SUCCESS(rc)) 
    …… 
    388388 
    389389    PVMREQ pReq; 
    390     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3StackWalkCtxFull, 4, 
     390    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)dbgfR3StackWalkCtxFull, 4, 
    391391                         pVM, pFrame, CPUMGetHyperCtxCore(pVM), 4); 
    392392    if (VBOX_SUCCESS(rc)) 

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

    r13778 r13782  
    31403140        if (VM_FF_ISSET(pVM, VM_FF_REQUEST)) 
    31413141        { 
    3142             rc2 = VMR3ReqProcessU(pVM->pUVM, VMREQDEST_ALL); 
     3142            rc2 = VMR3ReqProcessU(pVM->pUVM, VMREQDEST_ANY); 
    31433143            if (rc2 == VINF_EM_OFF || rc2 == VINF_EM_TERMINATE) 
    31443144            { 

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

    r13755 r13782  
    19551955        Log(("CSAMCodePageWriteHandler: delayed write!\n")); 
    19561956        AssertCompileSize(RTRCPTR, 4); 
    1957         rc = VMR3ReqCallEx(pVM, VMREQDEST_ALL, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
     1957        rc = VMR3ReqCallEx(pVM, VMREQDEST_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
    19581958                           (PFNRT)CSAMDelayedWriteHandler, 3, pVM, (RTRCPTR)GCPtr, cbBuf); 
    19591959    } 

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

    r13755 r13782  
    19751975        AssertMsg(!PDMCritSectIsOwner(&pVM->pgm.s.CritSect), ("We own the PGM lock -> deadlock danger!!\n")); 
    19761976 
    1977         rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)PGM3PhysGrowRange, 2, pVM, &GCPhysParam); 
     1977        rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)PGM3PhysGrowRange, 2, pVM, &GCPhysParam); 
    19781978        if (VBOX_SUCCESS(rc)) 
    19791979        { 

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

    r13755 r13782  
    546546        if (!pPage->fReusedFlushPending) 
    547547        { 
    548             int rc = VMR3ReqCallEx(pPool->pVMR3, VMREQDEST_ALL, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, (PFNRT)pgmR3PoolFlushReusedPage, 2, pPool, pPage); 
     548            int rc = VMR3ReqCallEx(pPool->pVMR3, VMREQDEST_ANY, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, (PFNRT)pgmR3PoolFlushReusedPage, 2, pPool, pPage); 
    549549            AssertRCReturn(rc, rc); 
    550550            pPage->fReusedFlushPending = true; 

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

    r13778 r13782  
    230230             */ 
    231231            PVMREQ pReq; 
    232             rc = VMR3ReqCallU(pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3CreateU, 
     232            rc = VMR3ReqCallU(pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3CreateU, 
    233233                              4, pUVM, cCPUs, pfnCFGMConstructor, pvUserCFGM); 
    234234            if (RT_SUCCESS(rc)) 
    …… 
    385385    pUVM->vm.s.ppAtRuntimeErrorNext = &pUVM->vm.s.pAtRuntimeError; 
    386386    pUVM->vm.s.enmHaltMethod = VMHALTMETHOD_BOOTSTRAP; 
    387     int rc = RTSemEventCreate(&pUVM->vm.s.EventSemWait); 
     387 
     388    /* Allocate a TLS entry to store the VMINTUSERPERVMCPU pointer. */ 
     389    int rc = RTTlsAllocEx(&pUVM->vm.s.idxTLS, NULL); 
     390    AssertRC(rc); 
     391    if (RT_FAILURE(rc)) 
     392    { 
     393        RTMemFree(pUVM); 
     394        return rc; 
     395    } 
     396 
     397    /* Initialize the VMCPU array in the UVM. */ 
     398    for (unsigned i=0;i<cCPUs;i++) 
     399    { 
     400        pUVM->aCpu[i].pUVM  = pUVM; 
     401        pUVM->aCpu[i].idCPU = i; 
     402    } 
     403 
     404    rc = RTSemEventCreate(&pUVM->vm.s.EventSemWait); 
    388405    if (RT_SUCCESS(rc)) 
    389406    { 
    …… 
    397414                if (RT_SUCCESS(rc)) 
    398415                { 
    399                     rc = RTThreadCreate(&pUVM->vm.s.ThreadEMT, vmR3EmulationThread, pUVM, _1M, 
    400                                         RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "EMT"); 
     416                    /* Start the emulation threads for all VMCPUs. */ 
     417                    for (unsigned i=0;i<cCPUs;i++) 
     418                    { 
     419                        rc = RTThreadCreate(&pUVM->vm.s.ThreadEMT, vmR3EmulationThread, &pUVM->aCpu[i], _1M, 
     420                                            RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "EMT"); 
     421                        if (RT_FAILURE(rc)) 
     422                            break; 
     423                    } 
     424 
    401425                    if (RT_SUCCESS(rc)) 
    402426                    { 
    …… 
    414438        RTSemEventDestroy(pUVM->vm.s.EventSemWait); 
    415439    } 
     440    RTTlsFree(pUVM->vm.s.idxTLS); 
    416441    RTMemFree(pUVM); 
    417442    return rc; 
    …… 
    955980     */ 
    956981    PVMREQ pReq; 
    957     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOn, 1, pVM); 
     982    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOn, 1, pVM); 
    958983    if (VBOX_SUCCESS(rc)) 
    959984    { 
    …… 
    10251050     */ 
    10261051    PVMREQ pReq; 
    1027     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Suspend, 1, pVM); 
     1052    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Suspend, 1, pVM); 
    10281053    if (VBOX_SUCCESS(rc)) 
    10291054    { 
    …… 
    11121137     */ 
    11131138    PVMREQ pReq; 
    1114     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Resume, 1, pVM); 
     1139    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Resume, 1, pVM); 
    11151140    if (VBOX_SUCCESS(rc)) 
    11161141    { 
    …… 
    11931218     */ 
    11941219    PVMREQ pReq; 
    1195     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Save, 4, pVM, pszFilename, pfnProgress, pvUser); 
     1220    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Save, 4, pVM, pszFilename, pfnProgress, pvUser); 
    11961221    if (VBOX_SUCCESS(rc)) 
    11971222    { 
    …… 
    12881313     */ 
    12891314    PVMREQ pReq; 
    1290     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser); 
     1315    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser); 
    12911316    if (VBOX_SUCCESS(rc)) 
    12921317    { 
    …… 
    13771402     */ 
    13781403    PVMREQ pReq; 
    1379     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOff, 1, pVM); 
     1404    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOff, 1, pVM); 
    13801405    if (VBOX_SUCCESS(rc)) 
    13811406    { 
    …… 
    15471572         */ 
    15481573        PVMREQ pReq = NULL; 
    1549         int rc = VMR3ReqCallU(pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3Destroy, 1, pVM); 
     1574        int rc = VMR3ReqCallU(pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3Destroy, 1, pVM); 
    15501575        if (RT_SUCCESS(rc)) 
    15511576            rc = pReq->iStatus; 
    …… 
    17751800    STAMR3TermUVM(pUVM); 
    17761801 
     1802    RTTlsFree(pUVM->vm.s.idxTLS); 
     1803 
    17771804    ASMAtomicUoWriteU32(&pUVM->u32Magic, UINT32_MAX); 
    17781805    RTMemFree(pUVM); 
    …… 
    19331960     */ 
    19341961    PVMREQ pReq = NULL; 
    1935     rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, 0, (PFNRT)vmR3Reset, 1, pVM); 
     1962    rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, 0, (PFNRT)vmR3Reset, 1, pVM); 
    19361963    while (rc == VERR_TIMEOUT) 
    19371964        rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT); 
    …… 
    24512478     */ 
    24522479    PVMREQ pReq; 
    2453     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateRegisterU, 3, pVM->pUVM, pfnAtState, pvUser); 
     2480    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateRegisterU, 3, pVM->pUVM, pfnAtState, pvUser); 
    24542481    if (VBOX_FAILURE(rc)) 
    24552482        return rc; 
    …… 
    25202547     */ 
    25212548    PVMREQ pReq; 
    2522     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateDeregisterU, 3, pVM->pUVM, pfnAtState, pvUser); 
     2549    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateDeregisterU, 3, pVM->pUVM, pfnAtState, pvUser); 
    25232550    if (VBOX_FAILURE(rc)) 
    25242551        return rc; 
    …… 
    26222649     */ 
    26232650    PVMREQ pReq; 
    2624     int rc = VMR3ReqCallU(pUVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3AtErrorRegisterU, 3, pUVM, pfnAtError, pvUser); 
     2651    int rc = VMR3ReqCallU(pUVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3AtErrorRegisterU, 3, pUVM, pfnAtError, pvUser); 
    26252652    if (VBOX_FAILURE(rc)) 
    26262653        return rc; 
    …… 
    26912718     */ 
    26922719    PVMREQ pReq; 
    2693     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtErrorDeregisterU, 3, pVM->pUVM, pfnAtError, pvUser); 
     2720    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtErrorDeregisterU, 3, pVM->pUVM, pfnAtError, pvUser); 
    26942721    if (VBOX_FAILURE(rc)) 
    26952722        return rc; 
    …… 
    29072934     */ 
    29082935    PVMREQ pReq; 
    2909     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorRegisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser); 
     2936    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorRegisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser); 
    29102937    if (VBOX_FAILURE(rc)) 
    29112938        return rc; 
    …… 
    29763003     */ 
    29773004    PVMREQ pReq; 
    2978     int rc = VMR3ReqCall(pVM, VMREQDEST_ALL, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorDeregisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser); 
     3005    int rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorDeregisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser); 
    29793006    if (VBOX_FAILURE(rc)) 
    29803007        return rc; 

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

    </
    r13765 r13782  
    5454DECLCALLBACK(int) vmR3EmulationThread(RTTHREAD ThreadSelf, void *pvArgs) 
    5555{ 
    56     PUVM pUVM = (PUVM)pvArgs; 
     56    PUVMCPU pUVMCPU = (PUVMCPU)pvArgs; 
     57    PUVM    pUVM    = pUVMCPU->pUVM; 
     58    RTCPUID idCPU   = pUVMCPU->idCPU; 
     59    int     rc = VINF_SUCCESS; 
     60