VMReq.cpp revision 50f998bb47f333d10515d4c12ad01a4e92a0747b
/* $Id$ */
/** @file
* VM - Virtual Machine
*/
/*
* Copyright (C) 2006-2007 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_VM
#include "VMInternal.h"
#include <iprt/semaphore.h>
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
/**
* Allocate and queue a call request.
*
* If it's desired to poll on the completion of the request set cMillies
* to 0 and use VMR3ReqWait() to check for completion. In the other case
* use RT_INDEFINITE_WAIT.
* The returned request packet must be freed using VMR3ReqFree().
*
* @returns VBox status code.
* Will not return VERR_INTERRUPTED.
* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
*
* @param pVM The VM handle.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param ppReq Where to store the pointer to the request.
* This will be NULL or a valid request pointer not matter what happens.
* @param cMillies Number of milliseconds to wait for the request to
* be completed. Use RT_INDEFINITE_WAIT to only
* wait till it's completed.
* @param fFlags A combination of the VMREQFLAGS values.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
VMMR3DECL(int) VMR3ReqCall(PVM pVM, VMCPUID idDstCpu, PVMREQ *ppReq, RTMSINTERVAL cMillies, uint32_t fFlags,
{
return rc;
}
/**
* Convenience wrapper for VMR3ReqCallU.
*
* This assumes (1) you're calling a function that returns an VBox status code,
* (2) that you want it's return code on success, and (3) that you wish to wait
* for ever for it to return.
*
* @returns VBox status code. In the unlikely event that VMR3ReqCallVU fails,
* its status code is return. Otherwise, the status of pfnFunction is
* returned.
*
* @param pVM Pointer to the shared VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
{
if (RT_SUCCESS(rc))
return rc;
}
/**
* Convenience wrapper for VMR3ReqCallU.
*
* This assumes (1) you're calling a function that returns an VBox status code
* and that you do not wish to wait for it to complete.
*
* @returns VBox status code returned by VMR3ReqCallVU.
*
* @param pVM Pointer to the shared VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
{
return rc;
}
/**
* Convenience wrapper for VMR3ReqCallU.
*
* This assumes (1) you're calling a function that returns void, and (2) that
* you wish to wait for ever for it to return.
*
* @returns VBox status code of VMR3ReqCallVU.
*
* @param pVM Pointer to the shared VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
VMMR3DECL(int) VMR3ReqCallVoidWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
{
return rc;
}
/**
* Convenience wrapper for VMR3ReqCallU.
*
* This assumes (1) you're calling a function that returns void, and (2) that
* you do not wish to wait for it to complete.
*
* @returns VBox status code of VMR3ReqCallVU.
*
* @param pVM Pointer to the shared VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
VMMR3DECL(int) VMR3ReqCallVoidNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
{
int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID | VMREQFLAGS_NO_WAIT,
return rc;
}
/**
* Convenience wrapper for VMR3ReqCallU.
*
* This assumes (1) you're calling a function that returns an VBox status code,
* (2) that you want it's return code on success, (3) that you wish to wait for
* ever for it to return, and (4) that it's priority request that can be safely
* be handled during async suspend and power off.
*
* @returns VBox status code. In the unlikely event that VMR3ReqCallVU fails,
* its status code is return. Otherwise, the status of pfnFunction is
* returned.
*
* @param pVM Pointer to the shared VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
VMMR3DECL(int) VMR3ReqPriorityCallWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
{
int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS | VMREQFLAGS_PRIORITY,
if (RT_SUCCESS(rc))
return rc;
}
/**
* Convenience wrapper for VMR3ReqCallU.
*
* This assumes (1) you're calling a function that returns void, (2) that you
* wish to wait for ever for it to return, and (3) that it's priority request
* that can be safely be handled during async suspend and power off.
*
* @returns VBox status code of VMR3ReqCallVU.
*
* @param pVM Pointer to the shared VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
VMMR3DECL(int) VMR3ReqPriorityCallVoidWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
{
int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID | VMREQFLAGS_PRIORITY,
return rc;
}
/**
* Allocate and queue a call request to a void function.
*
* If it's desired to poll on the completion of the request set cMillies
* to 0 and use VMR3ReqWait() to check for completion. In the other case
* use RT_INDEFINITE_WAIT.
* The returned request packet must be freed using VMR3ReqFree().
*
* @returns VBox status code.
* Will not return VERR_INTERRUPTED.
* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
*
* @param pUVM Pointer to the user mode VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param ppReq Where to store the pointer to the request.
* This will be NULL or a valid request pointer not matter what happens, unless fFlags
* contains VMREQFLAGS_NO_WAIT when it will be optional and always NULL.
* @param cMillies Number of milliseconds to wait for the request to
* be completed. Use RT_INDEFINITE_WAIT to only
* wait till it's completed.
* @param fFlags A combination of the VMREQFLAGS values.
* @param pfnFunction Pointer to the function to call.
* @param cArgs Number of arguments following in the ellipsis.
* @param ... Function arguments.
*
* @remarks See remarks on VMR3ReqCallVU.
*/
VMMR3DECL(int) VMR3ReqCallU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, RTMSINTERVAL cMillies, uint32_t fFlags,
{
return rc;
}
/**
* Allocate and queue a call request.
*
* If it's desired to poll on the completion of the request set cMillies
* to 0 and use VMR3ReqWait() to check for completion. In the other case
* use RT_INDEFINITE_WAIT.
* The returned request packet must be freed using VMR3ReqFree().
*
* @returns VBox status code.
* Will not return VERR_INTERRUPTED.
* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
*
* @param pUVM Pointer to the user mode VM structure.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
* @param ppReq Where to store the pointer to the request.
* This will be NULL or a valid request pointer not matter what happens, unless fFlags
* contains VMREQFLAGS_NO_WAIT when it will be optional and always NULL.
* @param cMillies Number of milliseconds to wait for the request to
* be completed. Use RT_INDEFINITE_WAIT to only
* wait till it's completed.
* @param pfnFunction Pointer to the function to call.
* @param fFlags A combination of the VMREQFLAGS values.
* @param cArgs Number of arguments following in the ellipsis.
* Stuff which differs in size from uintptr_t is gonna make trouble, so don't try!
* @param Args Argument vector.
*
* @remarks Caveats:
* - Do not pass anything which is larger than an uintptr_t.
* - 64-bit integers are larger than uintptr_t on 32-bit hosts.
* Pass integers > 32-bit by reference (pointers).
* - Don't use NULL since it should be the integer 0 in C++ and may
* therefore end up with garbage in the bits 63:32 on 64-bit
* hosts because 'int' is 32-bit.
* Use (void *)NULL or (uintptr_t)0 instead of NULL.
*/
VMMR3DECL(int) VMR3ReqCallVU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, RTMSINTERVAL cMillies, uint32_t fFlags,
{
LogFlow(("VMR3ReqCallV: idDstCpu=%u cMillies=%d fFlags=%#x pfnFunction=%p cArgs=%d\n", idDstCpu, cMillies, fFlags, pfnFunction, cArgs));
/*
* Validate input.
*/
AssertReturn(!(fFlags & ~(VMREQFLAGS_RETURN_MASK | VMREQFLAGS_NO_WAIT | VMREQFLAGS_POKE | VMREQFLAGS_PRIORITY)), VERR_INVALID_PARAMETER);
{
}
("cArg=%d\n", cArgs),
/*
* Allocate request
*/
if (RT_FAILURE(rc))
return rc;
/*
* Initialize the request data.
*/
/*
* Queue the request and return.
*/
if ( RT_FAILURE(rc)
&& rc != VERR_TIMEOUT)
{
}
if (!(fFlags & VMREQFLAGS_NO_WAIT))
{
}
else
return rc;
}
/**
* Joins the list pList with whatever is linked up at *pHead.
*/
{
for (unsigned cIterations = 0;; cIterations++)
{
if (!pHead)
return;
return;
return;
}
}
/**
* Joins the list pList with whatever is linked up at *pHead.
*/
{
/*
* Split the list if it's too long.
*/
unsigned cReqs = 1;
{
if (cReqs++ > 25)
{
vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(i + 2 + (i == pVMInt->iReqFree)) % RT_ELEMENTS(pVMInt->apReqFree)], pTail->pNext);
return;
}
}
vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(pVMInt->iReqFree + 2) % RT_ELEMENTS(pVMInt->apReqFree)], pList);
}
/**
* Allocates a request packet.
*
* The caller allocates a request packet, fills in the request data
* union and queues the request.
*
* @returns VBox status code.
*
* @param pVM VM handle.
* @param ppReq Where to store the pointer to the allocated packet.
* @param enmType Package type.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
*/
{
}
/**
* Allocates a request packet.
*
* The caller allocates a request packet, fills in the request data
* union and queues the request.
*
* @returns VBox status code.
*
* @param pUVM Pointer to the user mode VM structure.
* @param ppReq Where to store the pointer to the allocated packet.
* @param enmType Package type.
* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
* one of the following special values:
* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
*/
{
/*
* Validate input.
*/
("Invalid package type %d valid range %d-%d inclusively.\n",
|| idDstCpu == VMCPUID_ANY_QUEUE
|| idDstCpu == VMCPUID_ALL
|| idDstCpu == VMCPUID_ALL_REVERSE,
/*
* Try get a recycled packet.
* While this could all be solved with a single list with a lock, it's a sport
* of mine to avoid locks.
*/
while (--cTries >= 0)
{
PVMREQ volatile *ppHead = &pUVM->vm.s.apReqFree[ASMAtomicIncU32(&pUVM->vm.s.iReqFree) % RT_ELEMENTS(pUVM->vm.s.apReqFree)];
#if 0 /* sad, but this won't work safely because the reading of pReq->pNext. */
if ( pReq
if (pReq)
{
#else
if (pReq)
{
if ( pNext
{
}
#endif
/*
* Make sure the event sem is not signaled.
*/
if (!pReq->fEventSemClear)
{
{
/*
* This shall not happen, but if it does we'll just destroy
* the semaphore and create a new one.
*/
if (RT_FAILURE(rc))
return rc;
#if 0 ///@todo @bugref{4725} - def RT_LOCK_STRICT
#endif
}
pReq->fEventSemClear = true;
}
else
/*
* Initialize the packet and return it.
*/
return VINF_SUCCESS;
}
}
/*
* Ok allocate one.
*/
if (!pReq)
return VERR_NO_MEMORY;
/*
* Create the semaphore.
*/
if (RT_FAILURE(rc))
{
return rc;
}
#if 0 ///@todo @bugref{4725} - def RT_LOCK_STRICT
#endif
/*
* Initialize the packet and return it.
*/
pReq->fEventSemClear = true;
return VINF_SUCCESS;
}
/**
* Free a request packet.
*
* @returns VBox status code.
*
* @param pReq Package to free.
* @remark The request packet must be in allocated or completed state!
*/
{
/*
* Ignore NULL (all free functions should do this imho).
*/
if (!pReq)
return VINF_SUCCESS;
/*
* Check packet state.
*/
{
case VMREQSTATE_ALLOCATED:
case VMREQSTATE_COMPLETED:
break;
default:
return VERR_VM_REQUEST_STATE;
}
/*
* Make it a free packet and put it into one of the free packet lists.
*/
{
PVMREQ volatile *ppHead = &pUVM->vm.s.apReqFree[ASMAtomicIncU32(&pUVM->vm.s.iReqFree) % RT_ELEMENTS(pUVM->vm.s.apReqFree)];
do
{
}
else
{
}
return VINF_SUCCESS;
}
/**
* Queue a request.
*
* The quest must be allocated using VMR3ReqAlloc() and contain
* all the required data.
* If it's desired to poll on the completion of the request set cMillies
* to 0 and use VMR3ReqWait() to check for completion. In the other case
* use RT_INDEFINITE_WAIT.
*
* @returns VBox status code.
* Will not return VERR_INTERRUPTED.
* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
*
* @param pReq The request to queue.
* @param cMillies Number of milliseconds to wait for the request to
* be completed. Use RT_INDEFINITE_WAIT to only
* wait till it's completed.
*/
{
/*
* Verify the supplied package.
*/
AssertMsgReturn(pReq->enmState == VMREQSTATE_ALLOCATED, ("%d\n", pReq->enmState), VERR_VM_REQUEST_STATE);
("Invalid request package! Anyone cooking their own packages???\n"),
("Invalid package type %d valid range %d-%d inclusively. This was verified on alloc too...\n",
Assert(!(pReq->fFlags & ~(VMREQFLAGS_RETURN_MASK | VMREQFLAGS_NO_WAIT | VMREQFLAGS_POKE | VMREQFLAGS_PRIORITY)));
/*
* Are we the EMT or not?
* Also, store pVM (and fFlags) locally since pReq may be invalid after queuing it.
*/
int rc = VINF_SUCCESS;
{
/* One-by-one. */
{
/* Reinit some members. */
if (RT_FAILURE(rc))
break;
}
}
{
/* One-by-one. */
{
/* Reinit some members. */
if (RT_FAILURE(rc))
break;
}
}
&& ( !pUVCpu /* and it's not the current thread. */
{
/* Fetch the right UVMCPU */
/*
* Insert it.
*/
volatile PVMREQ *ppQueueHead = pReq->fFlags & VMREQFLAGS_PRIORITY ? &pUVCpu->vm.s.pPriorityReqs : &pUVCpu->vm.s.pNormalReqs;
do
{
/*
* Notify EMT.
*/
/*
* Wait and return.
*/
if (!(fFlags & VMREQFLAGS_NO_WAIT))
}
&& !pUVCpu /* only EMT threads have a valid pointer stored in the TLS slot. */)
{
/* Note: pUVCpu may or may not be NULL in the VMCPUID_ANY_QUEUE case; we don't care. */
/*
* Insert it.
*/
volatile PVMREQ *ppQueueHead = pReq->fFlags & VMREQFLAGS_PRIORITY ? &pUVM->vm.s.pPriorityReqs : &pUVM->vm.s.pNormalReqs;
do
{
/*
* Notify EMT.
*/
/*
* Wait and return.
*/
if (!(fFlags & VMREQFLAGS_NO_WAIT))
}
else
{
/*
* The requester was an EMT, just execute it.
*/
}
return rc;
}
/**
* Wait for a request to be completed.
*
* @returns VBox status code.
* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
*
* @param pReq The request to wait for.
* @param cMillies Number of milliseconds to wait.
* Use RT_INDEFINITE_WAIT to only wait till it's completed.
*/
{
/*
* Verify the supplied package.
*/
("Invalid request package! Anyone cooking their own packages???\n"),
("Invalid package type %d valid range %d-%d inclusively. This was verified on alloc too...\n",
/*
* Check for deadlock condition
*/
/*
* Wait on the package.
*/
int rc;
if (cMillies != RT_INDEFINITE_WAIT)
else
{
do
{
}
if (RT_SUCCESS(rc))
rc = VINF_SUCCESS;
return rc;
}
/**
* Sets the relevant FF.
*
* @param pUVM Pointer to the user mode VM structure.
* @param idDstCpu VMCPUID_ANY or the ID of the current CPU.
*/
{
{
if (idDstCpu == VMCPUID_ANY)
else
}
}
/**
* VMR3ReqProcessU helper that handles cases where there are more than one
* pending request.
*
* @returns The oldest request.
* @param pUVM Pointer to the user mode VM structure
* @param idDstCpu VMCPUID_ANY or virtual CPU ID.
* @param pReqList The list of requests.
* @param ppReqs Pointer to the list head.
*/
static PVMREQ vmR3ReqProcessUTooManyHelper(PUVM pUVM, VMCPUID idDstCpu, PVMREQ pReqList, PVMREQ volatile *ppReqs)
{
/*
* Chop off the last one (pReq).
*/
do
{
/*
* Push the others back onto the list (end of it).
*/
{
do
{
ASMNopPause();
if (pReqList2)
{
}
}
return pReqRet;
}
/**
* Process pending request(s).
*
* This function is called from a forced action handler in the EMT
* or from one of the EMT loops.
*
* @returns VBox status code.
*
* @param pUVM Pointer to the user mode VM structure.
* @param idDstCpu Pass VMCPUID_ANY to process the common request queue
* and the CPU ID for a CPU specific one. In the latter
* case the calling thread must be the EMT of that CPU.
* @param fPriorityOnly When set, only process the priority request queue.
*
* @note SMP safe (multiple EMTs trying to satisfy VM_FF_REQUESTs).
*
* @remarks This was made reentrant for async PDM handling, the debugger and
* others.
*/
{
LogFlow(("VMR3ReqProcessU: (enmVMState=%d) idDstCpu=%d\n", pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING, idDstCpu));
/*
* Determine which queues to process.
*/
PVMREQ volatile *ppNormalReqs;
PVMREQ volatile *ppPriorityReqs;
if (idDstCpu == VMCPUID_ANY)
{
}
else
{
}
/*
* Process loop.
*
* We do not repeat the outer loop if we've got an informational status code
* since that code needs processing by our caller (usually EM).
*/
int rc = VINF_SUCCESS;
for (;;)
{
/*
* Get the pending requests.
*
* If there are more than one request, unlink the oldest and put the
* rest back so that we're reentrant.
*/
{
if (idDstCpu == VMCPUID_ANY)
else
}
if (pReq)
{
}
else
{
if (!pReq)
break;
}
/*
* Process the request
*/
if ( rc2 >= VINF_EM_FIRST
&& rc2 <= VINF_EM_LAST)
{
break;
}
}
LogFlow(("VMR3ReqProcess: returns %Rrc (enmVMState=%d)\n", rc, pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING));
return rc;
}
/**
* Process one request.
*
* @returns VBox status code.
*
* @param pVM VM handle.
* @param pReq Request packet to process.
*/
{
#if 1 /*def VBOX_STRICT */
/*
* Disable rendezvous if servicing a priority request. Priority requests
* can not make use of the EMT rendezvous API.
*/
bool fSavedInRendezvous = true;
{
}
#endif
/*
* Process the request.
*/
{
/*
* A packed down call frame.
*/
case VMREQTYPE_INTERNAL:
{
union
{
DECLCALLBACKMEMBER(int, pfn00)(void);
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;
#ifdef RT_ARCH_AMD64
{
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:
break;
}
#else /* x86: */
# ifdef __GNUC__
"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
{
}
# endif
#endif /* x86 */
break;
}
default:
break;
}
/*
* Complete the request.
*/
{
/* Free the packet, nobody is waiting. */
LogFlow(("vmR3ReqProcessOneU: Completed request %p: rcReq=%Rrc rcRet=%Rrc - freeing it\n",
}
else
{
/* Notify the waiter and him free up the packet. */
LogFlow(("vmR3ReqProcessOneU: Completed request %p: rcReq=%Rrc rcRet=%Rrc - notifying waiting thread\n",
if (RT_FAILURE(rc2))
{
}
}
#if 1 /*def VBOX_STRICT */
/*
* Restore the rendezvous disabled state.
*/
if (!fSavedInRendezvous)
#endif
return rcRet;
}