bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#define LOG_GROUP LOG_GROUP_VM

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/vmm/mm.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/vmm/vmm.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include "VMInternal.h"

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/vmm/vm.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/vmm/uvm.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/err.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/param.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <VBox/log.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <iprt/assert.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <iprt/asm.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <iprt/string.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <iprt/time.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <iprt/semaphore.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync#include <iprt/thread.h>

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsyncstatic int vmR3ReqProcessOneU(PUVM pUVM, PVMREQ pReq);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync

41b3442e21c3a79f3bc61ce67e3445757a83f281vboxsyncVMMR3DECL(int) VMR3ReqCall(PVM pVM, VMCPUID idDstCpu, PVMREQ *ppReq, RTMSINTERVAL cMillies, uint32_t fFlags,

06782e19f5e2144408396dcec922c423c5ef9da8vboxsync PFNRT pfnFunction, unsigned cArgs, ...)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_list va;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync va_start(va, cArgs);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, ppReq, cMillies, fFlags, pfnFunction, cArgs, va);

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync va_end(va);

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync return rc;

63b785c3291332a86a9bc473e68f08121368898bvboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsyncVMMR3DECL(int) VMR3ReqCallWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMREQ pReq;

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync va_list va;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync va_start(va, cArgs);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pfnFunction, cArgs, va);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync va_end(va);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (RT_SUCCESS(rc))

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync rc = pReq->iStatus;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VMR3ReqFree(pReq);

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync return rc;

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync}

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqCallNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_list va;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_start(va, cArgs);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, NULL, 0, VMREQFLAGS_VBOX_STATUS | VMREQFLAGS_NO_WAIT,

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pfnFunction, cArgs, va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_end(va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync

63b785c3291332a86a9bc473e68f08121368898bvboxsyncVMMR3DECL(int) VMR3ReqCallVoidWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)

63b785c3291332a86a9bc473e68f08121368898bvboxsync{

63b785c3291332a86a9bc473e68f08121368898bvboxsync PVMREQ pReq;

63b785c3291332a86a9bc473e68f08121368898bvboxsync va_list va;

80626cd34607c5dbf3f0af51b32396ce58bf493bvboxsync va_start(va, cArgs);

41b3442e21c3a79f3bc61ce67e3445757a83f281vboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID,

80626cd34607c5dbf3f0af51b32396ce58bf493bvboxsync pfnFunction, cArgs, va);

41b3442e21c3a79f3bc61ce67e3445757a83f281vboxsync va_end(va);

41b3442e21c3a79f3bc61ce67e3445757a83f281vboxsync VMR3ReqFree(pReq);

41b3442e21c3a79f3bc61ce67e3445757a83f281vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqCallVoidNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pReq;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_list va;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_start(va, cArgs);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID | VMREQFLAGS_NO_WAIT,

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pfnFunction, cArgs, va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_end(va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync VMR3ReqFree(pReq);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

194a8ad893b721dfc22ac5f955671f09db015a3fvboxsyncVMMR3DECL(int) VMR3ReqPriorityCallWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMREQ pReq;

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync va_list va;

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync va_start(va, cArgs);

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS | VMREQFLAGS_PRIORITY,

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync pfnFunction, cArgs, va);

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync va_end(va);

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync if (RT_SUCCESS(rc))

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync rc = pReq->iStatus;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VMR3ReqFree(pReq);

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync return rc;

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync}

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqPriorityCallVoidWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

41b3442e21c3a79f3bc61ce67e3445757a83f281vboxsync PVMREQ pReq;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_list va;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_start(va, cArgs);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID | VMREQFLAGS_PRIORITY,

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pfnFunction, cArgs, va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_end(va);

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync VMR3ReqFree(pReq);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

6320f517ddc16e8d8dd450a47edfaab81f67942avboxsyncVMMR3DECL(int) VMR3ReqCallU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, RTMSINTERVAL cMillies, uint32_t fFlags,

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PFNRT pfnFunction, unsigned cArgs, ...)

6320f517ddc16e8d8dd450a47edfaab81f67942avboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_list va;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_start(va, cArgs);

6320f517ddc16e8d8dd450a47edfaab81f67942avboxsync int rc = VMR3ReqCallVU(pUVM, idDstCpu, ppReq, cMillies, fFlags, pfnFunction, cArgs, va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync va_end(va);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqCallVU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, RTMSINTERVAL cMillies, uint32_t fFlags,

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PFNRT pfnFunction, unsigned cArgs, va_list Args)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync LogFlow(("VMR3ReqCallV: idDstCpu=%u cMillies=%d fFlags=%#x pfnFunction=%p cArgs=%d\n", idDstCpu, cMillies, fFlags, pfnFunction, cArgs));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertPtrReturn(pUVM, VERR_INVALID_POINTER);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertReturn(!(fFlags & ~(VMREQFLAGS_RETURN_MASK | VMREQFLAGS_NO_WAIT | VMREQFLAGS_POKE | VMREQFLAGS_PRIORITY)), VERR_INVALID_PARAMETER);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (!(fFlags & VMREQFLAGS_NO_WAIT) || ppReq)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertPtrReturn(ppReq, VERR_INVALID_POINTER);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync *ppReq = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pReq = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertMsgReturn(cArgs * sizeof(uintptr_t) <= sizeof(pReq->u.Internal.aArgs),

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ("cArg=%d\n", cArgs),

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync VERR_TOO_MUCH_DATA);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync int rc = VMR3ReqAllocU(pUVM, &pReq, VMREQTYPE_INTERNAL, idDstCpu);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (RT_FAILURE(rc))

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->fFlags = fFlags;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->u.Internal.pfn = pfnFunction;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->u.Internal.cArgs = cArgs;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync for (unsigned iArg = 0; iArg < cArgs; iArg++)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->u.Internal.aArgs[iArg] = va_arg(Args, uintptr_t);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync rc = VMR3ReqQueue(pReq, cMillies);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if ( RT_FAILURE(rc)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync && rc != VERR_TIMEOUT)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync VMR3ReqFree(pReq);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

b2db33cfd2808f9dc0762ab7626a03076a4436c1vboxsync if (!(fFlags & VMREQFLAGS_NO_WAIT))

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync *ppReq = pReq;

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync LogFlow(("VMR3ReqCallV: returns %Rrc *ppReq=%p\n", rc, pReq));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync else

ba05e6aeed3cd14961a36e0162c29a267b66d7f7vboxsync LogFlow(("VMR3ReqCallV: returns %Rrc\n", rc));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(rc != VERR_INTERRUPTED);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncstatic void vmr3ReqJoinFreeSub(volatile PVMREQ *ppHead, PVMREQ pList)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync for (unsigned cIterations = 0;; cIterations++)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pHead = ASMAtomicXchgPtrT(ppHead, pList, PVMREQ);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (!pHead)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pTail = pHead;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync while (pTail->pNext)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pTail = pTail->pNext;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicWritePtr(&pTail->pNext, pList);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMCompilerBarrier();

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (ASMAtomicCmpXchgPtr(ppHead, pHead, pList))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync return;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicWriteNullPtr(&pTail->pNext);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ASMCompilerBarrier();

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (ASMAtomicCmpXchgPtr(ppHead, pHead, NULL))

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pList = pHead;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(cIterations != 32);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(cIterations != 64);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsyncstatic void vmr3ReqJoinFree(PVMINTUSERPERVM pVMInt, PVMREQ pList)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync{

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync unsigned cReqs = 1;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pTail = pList;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync while (pTail->pNext)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (cReqs++ > 25)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync const uint32_t i = pVMInt->iReqFree;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(i + 2) % RT_ELEMENTS(pVMInt->apReqFree)], pTail->pNext);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pTail->pNext = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(i + 2 + (i == pVMInt->iReqFree)) % RT_ELEMENTS(pVMInt->apReqFree)], pTail->pNext);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync pTail = pTail->pNext;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(pVMInt->iReqFree + 2) % RT_ELEMENTS(pVMInt->apReqFree)], pList);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqAlloc(PVM pVM, PVMREQ *ppReq, VMREQTYPE enmType, VMCPUID idDstCpu)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VMR3ReqAllocU(pVM->pUVM, ppReq, enmType, idDstCpu);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqAllocU(PUVM pUVM, PVMREQ *ppReq, VMREQTYPE enmType, VMCPUID idDstCpu)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertMsgReturn(enmType > VMREQTYPE_INVALID && enmType < VMREQTYPE_MAX,

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ("Invalid package type %d valid range %d-%d inclusively.\n",

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync enmType, VMREQTYPE_INVALID + 1, VMREQTYPE_MAX - 1),

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VERR_VM_REQUEST_INVALID_TYPE);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertPtrReturn(ppReq, VERR_INVALID_POINTER);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertMsgReturn( idDstCpu == VMCPUID_ANY

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync || idDstCpu == VMCPUID_ANY_QUEUE

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync || idDstCpu < pUVM->cCpus

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync || idDstCpu == VMCPUID_ALL

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync || idDstCpu == VMCPUID_ALL_REVERSE,

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ("Invalid destination %u (max=%u)\n", idDstCpu, pUVM->cCpus), VERR_INVALID_PARAMETER);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync int cTries = RT_ELEMENTS(pUVM->vm.s.apReqFree) * 2;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync while (--cTries >= 0)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ volatile *ppHead = &pUVM->vm.s.apReqFree[ASMAtomicIncU32(&pUVM->vm.s.iReqFree) % RT_ELEMENTS(pUVM->vm.s.apReqFree)];

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#if 0 /* sad, but this won't work safely because the reading of pReq->pNext. */

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pNext = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pReq = *ppHead;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if ( pReq

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync && !ASMAtomicCmpXchgPtr(ppHead, (pNext = pReq->pNext), pReq)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && (pReq = *ppHead)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && !ASMAtomicCmpXchgPtr(ppHead, (pNext = pReq->pNext), pReq))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (pReq)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(pReq->pNext == pNext); NOREF(pReq);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#else

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pReq = ASMAtomicXchgPtrT(ppHead, NULL, PVMREQ);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (pReq)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pNext = pReq->pNext;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if ( pNext

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && !ASMAtomicCmpXchgPtr(ppHead, pNext, NULL))

67e7d53d62514401efcd0e7a34f5faf772a3fe04vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocRaces);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync vmr3ReqJoinFree(&pUVM->vm.s, pReq->pNext);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#endif

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicDecU32(&pUVM->vm.s.cReqFree);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync if (!pReq->fEventSemClear)

06782e19f5e2144408396dcec922c423c5ef9da8vboxsync {

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync int rc = RTSemEventWait(pReq->EventSem, 0);

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync if (rc != VINF_SUCCESS && rc != VERR_TIMEOUT)

06782e19f5e2144408396dcec922c423c5ef9da8vboxsync {

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync /*

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync AssertMsgFailed(("rc=%Rrc from RTSemEventWait(%#x).\n", rc, pReq->EventSem));

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync RTSemEventDestroy(pReq->EventSem);

3221176430afca4d1be145b04bf50163fab4fdb1vboxsync rc = RTSemEventCreate(&pReq->EventSem);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertRC(rc);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (RT_FAILURE(rc))

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#if 0 ///@todo @bugref{4725} - def RT_LOCK_STRICT

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync for (VMCPUID idCpu = 0; idCpu < pUVM->cCpus; idCpu++)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync RTSemEventAddSignaller(pReq->EventSem, pUVM->aCpus[idCpu].vm.s.ThreadEMT);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#endif

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->fEventSemClear = true;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync else

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(RTSemEventWait(pReq->EventSem, 0) == VERR_TIMEOUT);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(pReq->enmType == VMREQTYPE_INVALID);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(pReq->enmState == VMREQSTATE_FREE);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync Assert(pReq->pUVM == pUVM);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ASMAtomicXchgSize(&pReq->pNext, NULL);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->enmState = VMREQSTATE_ALLOCATED;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->iStatus = VERR_VM_REQUEST_STATUS_STILL_PENDING;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->fFlags = VMREQFLAGS_VBOX_STATUS;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->enmType = enmType;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->idDstCpu = idDstCpu;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync *ppReq = pReq;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocRecycled);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync LogFlow(("VMR3ReqAlloc: returns VINF_SUCCESS *ppReq=%p recycled\n", pReq));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VINF_SUCCESS;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ pReq = (PVMREQ)MMR3HeapAllocU(pUVM, MM_TAG_VM_REQ, sizeof(*pReq));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (!pReq)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VERR_NO_MEMORY;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync int rc = RTSemEventCreate(&pReq->EventSem);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertRC(rc);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (RT_FAILURE(rc))

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync MMR3HeapFree(pReq);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return rc;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#if 0 ///@todo @bugref{4725} - def RT_LOCK_STRICT

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync for (VMCPUID idCpu = 0; idCpu < pUVM->cCpus; idCpu++)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync RTSemEventAddSignaller(pReq->EventSem, pUVM->aCpus[idCpu].vm.s.ThreadEMT);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync#endif

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->pNext = NULL;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->pUVM = pUVM;

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync pReq->enmState = VMREQSTATE_ALLOCATED;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->iStatus = VERR_VM_REQUEST_STATUS_STILL_PENDING;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->fEventSemClear = true;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->fFlags = VMREQFLAGS_VBOX_STATUS;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->enmType = enmType;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->idDstCpu = idDstCpu;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync *ppReq = pReq;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocNew);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync LogFlow(("VMR3ReqAlloc: returns VINF_SUCCESS *ppReq=%p new\n", pReq));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VINF_SUCCESS;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync}

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsyncVMMR3DECL(int) VMR3ReqFree(PVMREQ pReq)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync{

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync if (!pReq)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VINF_SUCCESS;

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync

63b785c3291332a86a9bc473e68f08121368898bvboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync switch (pReq->enmState)

63b785c3291332a86a9bc473e68f08121368898bvboxsync {

63b785c3291332a86a9bc473e68f08121368898bvboxsync case VMREQSTATE_ALLOCATED:

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync case VMREQSTATE_COMPLETED:

63b785c3291332a86a9bc473e68f08121368898bvboxsync break;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync default:

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync AssertMsgFailed(("Invalid state %d!\n", pReq->enmState));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VERR_VM_REQUEST_STATE;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync /*

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->enmState = VMREQSTATE_FREE;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->iStatus = VERR_VM_REQUEST_STATUS_FREED;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync pReq->enmType = VMREQTYPE_INVALID;

63b785c3291332a86a9bc473e68f08121368898bvboxsync

63b785c3291332a86a9bc473e68f08121368898bvboxsync PUVM pUVM = pReq->pUVM;

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync STAM_COUNTER_INC(&pUVM->vm.s.StatReqFree);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync if (pUVM->vm.s.cReqFree < 128)

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ASMAtomicIncU32(&pUVM->vm.s.cReqFree);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync PVMREQ volatile *ppHead = &pUVM->vm.s.apReqFree[ASMAtomicIncU32(&pUVM->vm.s.iReqFree) % RT_ELEMENTS(pUVM->vm.s.apReqFree)];

63b785c3291332a86a9bc473e68f08121368898bvboxsync PVMREQ pNext;

63b785c3291332a86a9bc473e68f08121368898bvboxsync do

63b785c3291332a86a9bc473e68f08121368898bvboxsync {

63b785c3291332a86a9bc473e68f08121368898bvboxsync pNext = ASMAtomicUoReadPtrT(ppHead, PVMREQ);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ASMAtomicWritePtr(&pReq->pNext, pNext);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync ASMCompilerBarrier();

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync } while (!ASMAtomicCmpXchgPtr(ppHead, pReq, pNext));

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync else

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync {

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync STAM_COUNTER_INC(&pReq->pUVM->vm.s.StatReqFreeOverflow);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync RTSemEventDestroy(pReq->EventSem);

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync MMR3HeapFree(pReq);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

aeb9498c4d9854ed42b271541d34c7bad97b4c77vboxsync return VINF_SUCCESS;

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync}

825c2485cf84eec495985ffd605a1c9cddee8c32vboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsyncVMMR3DECL(int) VMR3ReqQueue(PVMREQ pReq, RTMSINTERVAL cMillies)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync LogFlow(("VMR3ReqQueue: pReq=%p cMillies=%d\n", pReq, cMillies));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync AssertMsgReturn(pReq->enmState == VMREQSTATE_ALLOCATED, ("%d\n", pReq->enmState), VERR_VM_REQUEST_STATE);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync AssertMsgReturn( VALID_PTR(pReq->pUVM)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && !pReq->pNext

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && pReq->EventSem != NIL_RTSEMEVENT,

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ("Invalid request package! Anyone cooking their own packages???\n"),

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VERR_VM_REQUEST_INVALID_PACKAGE);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync AssertMsgReturn( pReq->enmType > VMREQTYPE_INVALID

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && pReq->enmType < VMREQTYPE_MAX,

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ("Invalid package type %d valid range %d-%d inclusively. This was verified on alloc too...\n",

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->enmType, VMREQTYPE_INVALID + 1, VMREQTYPE_MAX - 1),

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VERR_VM_REQUEST_INVALID_TYPE);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync Assert(!(pReq->fFlags & ~(VMREQFLAGS_RETURN_MASK | VMREQFLAGS_NO_WAIT | VMREQFLAGS_POKE | VMREQFLAGS_PRIORITY)));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

fb1975a6972d89de9e515bed0248db93f04ec9d8vboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync int rc = VINF_SUCCESS;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PUVM pUVM = ((VMREQ volatile *)pReq)->pUVM; /* volatile paranoia */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PUVMCPU pUVCpu = (PUVMCPU)RTTlsGet(pUVM->vm.s.idxTLS);

2294b1479e3fb6f4e9c9550b3e15f3d3a3f1fc24vboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (pReq->idDstCpu == VMCPUID_ALL)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /* One-by-one. */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync Assert(!(pReq->fFlags & VMREQFLAGS_NO_WAIT));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync for (unsigned i = 0; i < pUVM->cCpus; i++)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /* Reinit some members. */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->enmState = VMREQSTATE_ALLOCATED;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->idDstCpu = i;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = VMR3ReqQueue(pReq, cMillies);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (RT_FAILURE(rc))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync break;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync else if (pReq->idDstCpu == VMCPUID_ALL_REVERSE)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /* One-by-one. */

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync Assert(!(pReq->fFlags & VMREQFLAGS_NO_WAIT));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync for (int i = pUVM->cCpus-1; i >= 0; i--)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /* Reinit some members. */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->enmState = VMREQSTATE_ALLOCATED;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->idDstCpu = i;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = VMR3ReqQueue(pReq, cMillies);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (RT_FAILURE(rc))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync break;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync else if ( pReq->idDstCpu != VMCPUID_ANY /* for a specific VMCPU? */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && pReq->idDstCpu != VMCPUID_ANY_QUEUE

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && ( !pUVCpu /* and it's not the current thread. */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync || pUVCpu->idCpu != pReq->idDstCpu))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync VMCPUID idTarget = pReq->idDstCpu; Assert(idTarget < pUVM->cCpus);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMCPU pVCpu = &pUVM->pVM->aCpus[idTarget];

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync unsigned fFlags = ((VMREQ volatile *)pReq)->fFlags; /* volatile paranoia */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /* Fetch the right UVMCPU */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pUVCpu = &pUVM->aCpus[idTarget];

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync volatile PVMREQ *ppQueueHead = pReq->fFlags & VMREQFLAGS_PRIORITY ? &pUVCpu->vm.s.pPriorityReqs : &pUVCpu->vm.s.pNormalReqs;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->enmState = VMREQSTATE_QUEUED;

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync PVMREQ pNext;

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync do

aceec09dd145a4d6fb14f2ea75a459cc88b334abvboxsync {

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync pNext = ASMAtomicUoReadPtrT(ppQueueHead, PVMREQ);

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync ASMAtomicWritePtr(&pReq->pNext, pNext);

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync ASMCompilerBarrier();

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync } while (!ASMAtomicCmpXchgPtr(ppQueueHead, pReq, pNext));

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync /*

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync if (pUVM->pVM)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VMCPU_FF_SET(pVCpu, VMCPU_FF_REQUEST);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VMR3NotifyCpuFFU(pUVCpu, fFlags & VMREQFLAGS_POKE ? VMNOTIFYFF_FLAGS_POKE : 0);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (!(fFlags & VMREQFLAGS_NO_WAIT))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = VMR3ReqWait(pReq, cMillies);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync LogFlow(("VMR3ReqQueue: returns %Rrc\n", rc));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync else if ( ( pReq->idDstCpu == VMCPUID_ANY

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && !pUVCpu /* only EMT threads have a valid pointer stored in the TLS slot. */)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync || pReq->idDstCpu == VMCPUID_ANY_QUEUE)

508452243fd3328f7b9e0405d39fb9dc004e31b8vboxsync {

508452243fd3328f7b9e0405d39fb9dc004e31b8vboxsync unsigned fFlags = ((VMREQ volatile *)pReq)->fFlags; /* volatile paranoia */

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /* Note: pUVCpu may or may not be NULL in the VMCPUID_ANY_QUEUE case; we don't care. */

f409459bdd4c15cdb8d7fb6c6d54338cce9ac814vboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync volatile PVMREQ *ppQueueHead = pReq->fFlags & VMREQFLAGS_PRIORITY ? &pUVM->vm.s.pPriorityReqs : &pUVM->vm.s.pNormalReqs;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->enmState = VMREQSTATE_QUEUED;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMREQ pNext;

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync do

825c2485cf84eec495985ffd605a1c9cddee8c32vboxsync {

e073b07dcb5c9827f0530a9bfa2643356c5656dbvboxsync pNext = ASMAtomicUoReadPtrT(ppQueueHead, PVMREQ);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicWritePtr(&pReq->pNext, pNext);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMCompilerBarrier();

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync } while (!ASMAtomicCmpXchgPtr(ppQueueHead, pReq, pNext));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync if (pUVM->pVM)

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync VM_FF_SET(pUVM->pVM, VM_FF_REQUEST);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VMR3NotifyGlobalFFU(pUVM, fFlags & VMREQFLAGS_POKE ? VMNOTIFYFF_FLAGS_POKE : 0);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

a425b5e790c27d6a1a2cf738802e9034f0764a00vboxsync if (!(fFlags & VMREQFLAGS_NO_WAIT))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = VMR3ReqWait(pReq, cMillies);

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync LogFlow(("VMR3ReqQueue: returns %Rrc\n", rc));

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync }

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync else

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync Assert(pUVCpu);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReq->enmState = VMREQSTATE_QUEUED;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = vmR3ReqProcessOneU(pUVM, pReq);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync LogFlow(("VMR3ReqQueue: returns %Rrc (processed)\n", rc));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync return rc;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync}

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsyncVMMR3DECL(int) VMR3ReqWait(PVMREQ pReq, RTMSINTERVAL cMillies)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync LogFlow(("VMR3ReqWait: pReq=%p cMillies=%d\n", pReq, cMillies));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync AssertMsgReturn( pReq->enmState == VMREQSTATE_QUEUED

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync || pReq->enmState == VMREQSTATE_PROCESSING

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync || pReq->enmState == VMREQSTATE_COMPLETED,

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync ("Invalid state %d\n", pReq->enmState),

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync VERR_VM_REQUEST_STATE);

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync AssertMsgReturn( VALID_PTR(pReq->pUVM)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && pReq->EventSem != NIL_RTSEMEVENT,

b306a397b157898e6f769f640b0dfdffbf8beec7vboxsync ("Invalid request package! Anyone cooking their own packages???\n"),

b306a397b157898e6f769f640b0dfdffbf8beec7vboxsync VERR_VM_REQUEST_INVALID_PACKAGE);

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync AssertMsgReturn( pReq->enmType > VMREQTYPE_INVALID

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync && pReq->enmType < VMREQTYPE_MAX,

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync ("Invalid package type %d valid range %d-%d inclusively. This was verified on alloc too...\n",

b306a397b157898e6f769f640b0dfdffbf8beec7vboxsync pReq->enmType, VMREQTYPE_INVALID + 1, VMREQTYPE_MAX - 1),

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VERR_VM_REQUEST_INVALID_TYPE);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PUVM pUVM = pReq->pUVM;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync NOREF(pUVM);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync int rc;

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync if (cMillies != RT_INDEFINITE_WAIT)

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync rc = RTSemEventWait(pReq->EventSem, cMillies);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync else

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync do

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = RTSemEventWait(pReq->EventSem, RT_INDEFINITE_WAIT);

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync Assert(rc != VERR_TIMEOUT);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync } while ( pReq->enmState != VMREQSTATE_COMPLETED

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync && pReq->enmState != VMREQSTATE_INVALID);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync if (RT_SUCCESS(rc))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicXchgSize(&pReq->fEventSemClear, true);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (pReq->enmState == VMREQSTATE_COMPLETED)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync rc = VINF_SUCCESS;

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync LogFlow(("VMR3ReqWait: returns %Rrc\n", rc));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync Assert(rc != VERR_INTERRUPTED);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync return rc;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync}

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsyncDECLINLINE(void) vmR3ReqSetFF(PUVM pUVM, VMCPUID idDstCpu)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (RT_LIKELY(pUVM->pVM))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync if (idDstCpu == VMCPUID_ANY)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VM_FF_SET(pUVM->pVM, VM_FF_REQUEST);

40f74699d21578c96f79fa80bd8563a72c7b315cvboxsync else

b306a397b157898e6f769f640b0dfdffbf8beec7vboxsync VMCPU_FF_SET(&pUVM->pVM->aCpus[idDstCpu], VMCPU_FF_REQUEST);

b306a397b157898e6f769f640b0dfdffbf8beec7vboxsync }

b306a397b157898e6f769f640b0dfdffbf8beec7vboxsync}

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsyncstatic PVMREQ vmR3ReqProcessUTooManyHelper(PUVM pUVM, VMCPUID idDstCpu, PVMREQ pReqList, PVMREQ volatile *ppReqs)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync{

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync STAM_COUNTER_INC(&pUVM->vm.s.StatReqMoreThan1);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync PVMREQ pPrev;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMREQ pReqRet = pReqList;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync do

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync pPrev = pReqRet;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReqRet = pReqRet->pNext;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync } while (pReqRet->pNext);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicWriteNullPtr(&pPrev->pNext);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync Log2(("VMR3ReqProcess: Pushing back %p %p...\n", pReqList, pReqList->pNext));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (RT_UNLIKELY(!ASMAtomicCmpXchgPtr(ppReqs, pReqList, NULL)))

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync STAM_COUNTER_INC(&pUVM->vm.s.StatReqPushBackRaces);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync do

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMNopPause();

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync PVMREQ pReqList2 = ASMAtomicXchgPtrT(ppReqs, NULL, PVMREQ);

1207f59aa62006952dbb0bf7700decf34d8caeb2vboxsync if (pReqList2)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMREQ pLast = pReqList2;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync while (pLast->pNext)

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync pLast = pLast->pNext;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync ASMAtomicWritePtr(&pLast->pNext, pReqList);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync pReqList = pReqList2;

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync } while (!ASMAtomicCmpXchgPtr(ppReqs, pReqList, NULL));

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync vmR3ReqSetFF(pUVM, idDstCpu);

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync return pReqRet;

aceec09dd145a4d6fb14f2ea75a459cc88b334abvboxsync}

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync

39fa431e2dbe885a37b126ccd293f8e8255812a6vboxsyncVMMR3DECL(int) VMR3ReqProcessU(PUVM pUVM, VMCPUID idDstCpu, bool fPriorityOnly)

aceec09dd145a4d6fb14f2ea75a459cc88b334abvboxsync{

aceec09dd145a4d6fb14f2ea75a459cc88b334abvboxsync LogFlow(("VMR3ReqProcessU: (enmVMState=%d) idDstCpu=%d\n", pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING, idDstCpu));

aceec09dd145a4d6fb14f2ea75a459cc88b334abvboxsync

39fa431e2dbe885a37b126ccd293f8e8255812a6vboxsync /*

89de31eab6e960abcacfb70916598ae1c2e7f737vboxsync PVMREQ volatile *ppNormalReqs;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync PVMREQ volatile *ppPriorityReqs;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync if (idDstCpu == VMCPUID_ANY)

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync {

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync ppPriorityReqs = &pUVM->vm.s.pPriorityReqs;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync ppNormalReqs = !fPriorityOnly ? &pUVM->vm.s.pNormalReqs : ppPriorityReqs;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync }

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync else

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync {

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync Assert(idDstCpu < pUVM->cCpus);

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync Assert(pUVM->aCpus[idDstCpu].vm.s.NativeThreadEMT == RTThreadNativeSelf());

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync ppPriorityReqs = &pUVM->aCpus[idDstCpu].vm.s.pPriorityReqs;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync ppNormalReqs = !fPriorityOnly ? &pUVM->aCpus[idDstCpu].vm.s.pNormalReqs : ppPriorityReqs;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync }

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync /*

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync int rc = VINF_SUCCESS;

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync for (;;)

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync {

bf88068260ded16af90b7da4867240fbdd9c8017vboxsync /*

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (RT_LIKELY(pUVM->pVM))

1dc37bff2fb26897f5892d8330fe2bc0c9859aecvboxsync {

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (idDstCpu == VMCPUID_ANY)

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VM_FF_CLEAR(pUVM->pVM, VM_FF_REQUEST);

825c2485cf84eec495985ffd605a1c9cddee8c32vboxsync else

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync VMCPU_FF_CLEAR(&pUVM->pVM->aCpus[idDstCpu], VMCPU_FF_REQUEST);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync }

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync PVMREQ pReq = ASMAtomicXchgPtrT(ppPriorityReqs, NULL, PVMREQ);

bddad5eeab93a98d4ea571ccdf016531bb4318advboxsync if (pReq)

41c24e185aa1d6b5dc290edbd061c5a3c23a9e2fvboxsync {

if (RT_UNLIKELY(pReq->pNext))

pReq = vmR3ReqProcessUTooManyHelper(pUVM, idDstCpu, pReq, ppPriorityReqs);

else if (ASMAtomicReadPtrT(ppNormalReqs, PVMREQ))

vmR3ReqSetFF(pUVM, idDstCpu);

}

else

{

pReq = ASMAtomicXchgPtrT(ppNormalReqs, NULL, PVMREQ);

if (!pReq)

break;

if (RT_UNLIKELY(pReq->pNext))

pReq = vmR3ReqProcessUTooManyHelper(pUVM, idDstCpu, pReq, ppNormalReqs);

}

/*

STAM_COUNTER_INC(&pUVM->vm.s.StatReqProcessed);

int rc2 = vmR3ReqProcessOneU(pUVM, pReq);

if ( rc2 >= VINF_EM_FIRST

&& rc2 <= VINF_EM_LAST)

{

rc = rc2;

break;

}

}

LogFlow(("VMR3ReqProcess: returns %Rrc (enmVMState=%d)\n", rc, pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING));

return rc;

}

static int vmR3ReqProcessOneU(PUVM pUVM, PVMREQ pReq)

{

LogFlow(("vmR3ReqProcessOneU: pReq=%p type=%d fFlags=%#x\n", pReq, pReq->enmType, pReq->fFlags));

#if 1 /*def VBOX_STRICT */

/*

PVMCPU pVCpu = NULL;

bool fSavedInRendezvous = true;

bool const fPriorityReq = RT_BOOL(pReq->fFlags & VMREQFLAGS_PRIORITY);

if (fPriorityReq && pUVM->pVM)

{

pVCpu = VMMGetCpu(pUVM->pVM);

fSavedInRendezvous = VMMR3EmtRendezvousSetDisabled(pVCpu, true /*fDisabled*/);

}

#endif

/*

Assert(pReq->enmState == VMREQSTATE_QUEUED);

pReq->enmState = VMREQSTATE_PROCESSING;

int rcRet = VINF_SUCCESS; /* the return code of this function. */

int rcReq = VERR_NOT_IMPLEMENTED; /* the request status. */

switch (pReq->enmType)

{

/*

case VMREQTYPE_INTERNAL:

{

uintptr_t *pauArgs = &pReq->u.Internal.aArgs[0];

union

{

PFNRT pfn;

DECLCALLBACKMEMBER(int, pfn00)(void);

DECLCALLBACKMEMBER(int, pfn01)(uintptr_t);

DECLCALLBACKMEMBER(int, pfn02)(uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn03)(uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn04)(uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn05)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn06)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn07)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn08)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn09)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn10)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn11)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn12)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn13)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn14)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

DECLCALLBACKMEMBER(int, pfn15)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

} u;

u.pfn = pReq->u.Internal.pfn;

#ifdef RT_ARCH_AMD64

switch (pReq->u.Internal.cArgs)

{

case 0: rcRet = u.pfn00(); break;

case 1: rcRet = u.pfn01(pauArgs[0]); break;

case 2: rcRet = u.pfn02(pauArgs[0], pauArgs[1]); break;

case 3: rcRet = u.pfn03(pauArgs[0], pauArgs[1], pauArgs[2]); break;

case 4: rcRet = u.pfn04(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3]); break;

case 5: rcRet = u.pfn05(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4]); break;

case 6: rcRet = u.pfn06(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5]); break;

case 7: rcRet = u.pfn07(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6]); break;

case 8: rcRet = u.pfn08(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7]); break;

case 9: rcRet = u.pfn09(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8]); break;

case 10: rcRet = u.pfn10(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9]); break;

case 11: rcRet = u.pfn11(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10]); break;

case 12: rcRet = u.pfn12(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10], pauArgs[11]); break;

case 13: rcRet = u.pfn13(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10], pauArgs[11], pauArgs[12]); break;

case 14: rcRet = u.pfn14(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10], pauArgs[11], pauArgs[12], pauArgs[13]); break;

case 15: rcRet = u.pfn15(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10], pauArgs[11], pauArgs[12], pauArgs[13], pauArgs[14]); break;

default:

AssertReleaseMsgFailed(("cArgs=%d\n", pReq->u.Internal.cArgs));

rcRet = rcReq = VERR_INTERNAL_ERROR;

break;

}

#else /* x86: */

size_t cbArgs = pReq->u.Internal.cArgs * sizeof(uintptr_t);

# ifdef __GNUC__

__asm__ __volatile__("movl %%esp, %%edx\n\t"

"subl %2, %%esp\n\t"

"andl $0xfffffff0, %%esp\n\t"

"shrl $2, %2\n\t"

"movl %%esp, %%edi\n\t"

"rep movsl\n\t"

"movl %%edx, %%edi\n\t"

"call *%%eax\n\t"

"mov %%edi, %%esp\n\t"

: "=a" (rcRet),

"=S" (pauArgs),

"=c" (cbArgs)

: "0" (u.pfn),

"1" (pauArgs),

"2" (cbArgs)

: "edi", "edx");

# else

__asm

{

xor edx, edx /* just mess it up. */

mov eax, u.pfn

mov ecx, cbArgs

shr ecx, 2

mov esi, pauArgs

mov ebx, esp

sub esp, cbArgs

and esp, 0xfffffff0

mov edi, esp

rep movsd

call eax

mov esp, ebx

mov rcRet, eax

}

# endif

#endif /* x86 */

if ((pReq->fFlags & (VMREQFLAGS_RETURN_MASK)) == VMREQFLAGS_VOID)

rcRet = VINF_SUCCESS;

rcReq = rcRet;

break;

}

default:

AssertMsgFailed(("pReq->enmType=%d\n", pReq->enmType));

rcReq = VERR_NOT_IMPLEMENTED;

break;

}

/*

pReq->iStatus = rcReq;

pReq->enmState = VMREQSTATE_COMPLETED;

if (pReq->fFlags & VMREQFLAGS_NO_WAIT)

{

/* Free the packet, nobody is waiting. */

LogFlow(("vmR3ReqProcessOneU: Completed request %p: rcReq=%Rrc rcRet=%Rrc - freeing it\n",

pReq, rcReq, rcRet));

VMR3ReqFree(pReq);

}

else

{

/* Notify the waiter and him free up the packet. */

LogFlow(("vmR3ReqProcessOneU: Completed request %p: rcReq=%Rrc rcRet=%Rrc - notifying waiting thread\n",

pReq, rcReq, rcRet));

ASMAtomicXchgSize(&pReq->fEventSemClear, false);

int rc2 = RTSemEventSignal(pReq->EventSem);

if (RT_FAILURE(rc2))

{

AssertRC(rc2);

rcRet = rc2;

}

}

#if 1 /*def VBOX_STRICT */