VMReq.cpp@ 23495

Last change on this file since 23495 was 23191, checked in by vboxsync, 15 years ago
VMM: Hacked EM to quit processing forced actions on VINF_EM_SUSPEND, VINF_EM_RESET and VINF_EM_OFF. When going from the live to the suspended step in VMR3Save/VMR3Migrate it frequently happened that the vmR3LiveDoStep2 VMREQ was processed right after the VMR3EmtRendezvous that suspended the VM. TM gets very upset if this happens.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 45.6 KB

Line
1	/* $Id: VMReq.cpp 23191 2009-09-21 14:22:37Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_VM
27	#include <VBox/mm.h>
28	#include <VBox/vmm.h>
29	#include "VMInternal.h"
30	#include <VBox/vm.h>
31	#include <VBox/uvm.h>
32
33	#include <VBox/err.h>
34	#include <VBox/param.h>
35	#include <VBox/log.h>
36	#include <iprt/assert.h>
37	#include <iprt/asm.h>
38	#include <iprt/string.h>
39	#include <iprt/time.h>
40	#include <iprt/semaphore.h>
41	#include <iprt/thread.h>
42
43
44	/*******************************************************************************
45	* Internal Functions *
46	*******************************************************************************/
47	static int vmR3ReqProcessOneU(PUVM pUVM, PVMREQ pReq);
48
49
50	/**
51	* Allocate and queue a call request.
52	*
53	* If it's desired to poll on the completion of the request set cMillies
54	* to 0 and use VMR3ReqWait() to check for completation. In the other case
55	* use RT_INDEFINITE_WAIT.
56	* The returned request packet must be freed using VMR3ReqFree().
57	*
58	* @returns VBox status code.
59	* Will not return VERR_INTERRUPTED.
60	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
61	*
62	* @param pVM The VM handle.
63	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
64	* one of the following special values:
65	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
66	* @param ppReq Where to store the pointer to the request.
67	* This will be NULL or a valid request pointer not matter what happends.
68	* @param cMillies Number of milliseconds to wait for the request to
69	* be completed. Use RT_INDEFINITE_WAIT to only
70	* wait till it's completed.
71	* @param fFlags A combination of the VMREQFLAGS values.
72	* @param pfnFunction Pointer to the function to call.
73	* @param cArgs Number of arguments following in the ellipsis.
74	* Not possible to pass 64-bit arguments!
75	* @param ... Function arguments.
76	*/
77	VMMR3DECL(int) VMR3ReqCall(PVM pVM, VMCPUID idDstCpu, PVMREQ *ppReq, unsigned cMillies, uint32_t fFlags,
78	PFNRT pfnFunction, unsigned cArgs, ...)
79	{
80	va_list va;
81	va_start(va, cArgs);
82	int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, ppReq, cMillies, fFlags, pfnFunction, cArgs, va);
83	va_end(va);
84	return rc;
85	}
86
87
88	/**
89	* Convenience wrapper for VMR3ReqCallU.
90	*
91	* This assumes (1) you're calling a function that returns an VBox status code,
92	* (2) that you want it's return code on success, and (3) that you wish to wait
93	* for ever for it to return.
94	*
95	* @returns VBox status code. In the unlikely event that VMR3ReqCallVU fails,
96	* its status code is return. Otherwise, the status of pfnFunction is
97	* returned.
98	*
99	* @param pVM Pointer to the shared VM structure.
100	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
101	* one of the following special values:
102	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
103	* @param pfnFunction Pointer to the function to call.
104	* @param cArgs Number of arguments following in the ellipsis.
105	* Not possible to pass 64-bit arguments!
106	* @param ... Function arguments.
107	*/
108	VMMR3DECL(int) VMR3ReqCallWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
109	{
110	PVMREQ pReq;
111	va_list va;
112	va_start(va, cArgs);
113	int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
114	pfnFunction, cArgs, va);
115	va_end(va);
116	if (RT_SUCCESS(rc))
117	rc = pReq->iStatus;
118	VMR3ReqFree(pReq);
119	return rc;
120	}
121
122
123	/**
124	* Convenience wrapper for VMR3ReqCallU.
125	*
126	* This assumes (1) you're calling a function that returns an VBox status code,
127	* (2) that you want it's return code on success, and (3) that you wish to wait
128	* for ever for it to return.
129	*
130	* @returns VBox status code. In the unlikely event that VMR3ReqCallVU fails,
131	* its status code is return. Otherwise, the status of pfnFunction is
132	* returned.
133	*
134	* @param pUVM Pointer to the user mode VM structure.
135	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
136	* one of the following special values:
137	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
138	* @param pfnFunction Pointer to the function to call.
139	* @param cArgs Number of arguments following in the ellipsis.
140	* Not possible to pass 64-bit arguments!
141	* @param ... Function arguments.
142	*/
143	VMMR3DECL(int) VMR3ReqCallWaitU(PUVM pUVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
144	{
145	PVMREQ pReq;
146	va_list va;
147	va_start(va, cArgs);
148	int rc = VMR3ReqCallVU(pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
149	pfnFunction, cArgs, va);
150	va_end(va);
151	if (RT_SUCCESS(rc))
152	rc = pReq->iStatus;
153	VMR3ReqFree(pReq);
154	return rc;
155	}
156
157
158	/**
159	* Convenience wrapper for VMR3ReqCallU.
160	*
161	* This assumes (1) you're calling a function that returns an VBox status code
162	* and that you do not wish to wait for it to complete.
163	*
164	* @returns VBox status code returned by VMR3ReqCallVU.
165	*
166	* @param pVM Pointer to the shared VM structure.
167	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
168	* one of the following special values:
169	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
170	* @param pfnFunction Pointer to the function to call.
171	* @param cArgs Number of arguments following in the ellipsis.
172	* Not possible to pass 64-bit arguments!
173	* @param ... Function arguments.
174	*/
175	VMMR3DECL(int) VMR3ReqCallNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
176	{
177	va_list va;
178	va_start(va, cArgs);
179	int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, NULL, 0, VMREQFLAGS_VBOX_STATUS \| VMREQFLAGS_NO_WAIT,
180	pfnFunction, cArgs, va);
181	va_end(va);
182	return rc;
183	}
184
185
186	/**
187	* Convenience wrapper for VMR3ReqCallU.
188	*
189	* This assumes (1) you're calling a function that returns an VBox status code
190	* and that you do not wish to wait for it to complete.
191	*
192	* @returns VBox status code returned by VMR3ReqCallVU.
193	*
194	* @param pUVM Pointer to the user mode VM structure.
195	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
196	* one of the following special values:
197	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
198	* @param pfnFunction Pointer to the function to call.
199	* @param cArgs Number of arguments following in the ellipsis.
200	* Not possible to pass 64-bit arguments!
201	* @param ... Function arguments.
202	*/
203	VMMR3DECL(int) VMR3ReqCallNoWaitU(PUVM pUVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
204	{
205	va_list va;
206	va_start(va, cArgs);
207	int rc = VMR3ReqCallVU(pUVM, idDstCpu, NULL, 0, VMREQFLAGS_VBOX_STATUS \| VMREQFLAGS_NO_WAIT,
208	pfnFunction, cArgs, va);
209	va_end(va);
210	return rc;
211	}
212
213
214	/**
215	* Convenience wrapper for VMR3ReqCallU.
216	*
217	* This assumes (1) you're calling a function that returns void, and (2) that
218	* you wish to wait for ever for it to return.
219	*
220	* @returns VBox status code of VMR3ReqCallVU.
221	*
222	* @param pVM Pointer to the shared VM structure.
223	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
224	* one of the following special values:
225	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
226	* @param pfnFunction Pointer to the function to call.
227	* @param cArgs Number of arguments following in the ellipsis.
228	* Not possible to pass 64-bit arguments!
229	* @param ... Function arguments.
230	*/
231	VMMR3DECL(int) VMR3ReqCallVoidWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
232	{
233	PVMREQ pReq;
234	va_list va;
235	va_start(va, cArgs);
236	int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID,
237	pfnFunction, cArgs, va);
238	va_end(va);
239	VMR3ReqFree(pReq);
240	return rc;
241	}
242
243
244	/**
245	* Convenience wrapper for VMR3ReqCallU.
246	*
247	* This assumes (1) you're calling a function that returns void, and (2) that
248	* you wish to wait for ever for it to return.
249	*
250	* @returns VBox status code of VMR3ReqCallVU.
251	*
252	* @param pUVM Pointer to the user mode VM structure.
253	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
254	* one of the following special values:
255	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
256	* @param pfnFunction Pointer to the function to call.
257	* @param cArgs Number of arguments following in the ellipsis.
258	* Not possible to pass 64-bit arguments!
259	* @param ... Function arguments.
260	*/
261	VMMR3DECL(int) VMR3ReqCallVoidWaitU(PUVM pUVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
262	{
263	PVMREQ pReq;
264	va_list va;
265	va_start(va, cArgs);
266	int rc = VMR3ReqCallVU(pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID,
267	pfnFunction, cArgs, va);
268	va_end(va);
269	VMR3ReqFree(pReq);
270	return rc;
271	}
272
273
274	/**
275	* Convenience wrapper for VMR3ReqCallU.
276	*
277	* This assumes (1) you're calling a function that returns void, and (2) that
278	* you do not wish to wait for it to complete.
279	*
280	* @returns VBox status code of VMR3ReqCallVU.
281	*
282	* @param pVM Pointer to the shared VM structure.
283	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
284	* one of the following special values:
285	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
286	* @param pfnFunction Pointer to the function to call.
287	* @param cArgs Number of arguments following in the ellipsis.
288	* Not possible to pass 64-bit arguments!
289	* @param ... Function arguments.
290	*/
291	VMMR3DECL(int) VMR3ReqCallVoidNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
292	{
293	PVMREQ pReq;
294	va_list va;
295	va_start(va, cArgs);
296	int rc = VMR3ReqCallVU(pVM->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID \| VMREQFLAGS_NO_WAIT,
297	pfnFunction, cArgs, va);
298	va_end(va);
299	VMR3ReqFree(pReq);
300	return rc;
301	}
302
303
304	/**
305	* Convenience wrapper for VMR3ReqCallU.
306	*
307	* This assumes (1) you're calling a function that returns void, and (2) that
308	* you do not wish to wait for it to complete.
309	*
310	* @returns VBox status code of VMR3ReqCallVU.
311	*
312	* @param pUVM Pointer to the user mode VM structure.
313	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
314	* one of the following special values:
315	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
316	* @param pfnFunction Pointer to the function to call.
317	* @param cArgs Number of arguments following in the ellipsis.
318	* Not possible to pass 64-bit arguments!
319	* @param ... Function arguments.
320	*/
321	VMMR3DECL(int) VMR3ReqCallVoidNoWaitU(PUVM pUVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
322	{
323	PVMREQ pReq;
324	va_list va;
325	va_start(va, cArgs);
326	int rc = VMR3ReqCallVU(pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VOID \| VMREQFLAGS_NO_WAIT,
327	pfnFunction, cArgs, va);
328	va_end(va);
329	VMR3ReqFree(pReq);
330	return rc;
331	}
332
333
334	/**
335	* Allocate and queue a call request to a void function.
336	*
337	* If it's desired to poll on the completion of the request set cMillies
338	* to 0 and use VMR3ReqWait() to check for completation. In the other case
339	* use RT_INDEFINITE_WAIT.
340	* The returned request packet must be freed using VMR3ReqFree().
341	*
342	* @returns VBox status code.
343	* Will not return VERR_INTERRUPTED.
344	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
345	*
346	* @param pUVM Pointer to the user mode VM structure.
347	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
348	* one of the following special values:
349	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
350	* @param ppReq Where to store the pointer to the request.
351	* This will be NULL or a valid request pointer not matter what happends, unless fFlags
352	* contains VMREQFLAGS_NO_WAIT when it will be optional and always NULL.
353	* @param cMillies Number of milliseconds to wait for the request to
354	* be completed. Use RT_INDEFINITE_WAIT to only
355	* wait till it's completed.
356	* @param fFlags A combination of the VMREQFLAGS values.
357	* @param pfnFunction Pointer to the function to call.
358	* @param cArgs Number of arguments following in the ellipsis.
359	* Not possible to pass 64-bit arguments!
360	* @param ... Function arguments.
361	*/
362	VMMR3DECL(int) VMR3ReqCallU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, unsigned cMillies, unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
363	{
364	va_list va;
365	va_start(va, cArgs);
366	int rc = VMR3ReqCallVU(pUVM, idDstCpu, ppReq, cMillies, fFlags, pfnFunction, cArgs, va);
367	va_end(va);
368	return rc;
369	}
370
371
372	/**
373	* Allocate and queue a call request.
374	*
375	* If it's desired to poll on the completion of the request set cMillies
376	* to 0 and use VMR3ReqWait() to check for completation. In the other case
377	* use RT_INDEFINITE_WAIT.
378	* The returned request packet must be freed using VMR3ReqFree().
379	*
380	* @returns VBox status code.
381	* Will not return VERR_INTERRUPTED.
382	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
383	*
384	* @param pUVM Pointer to the user mode VM structure.
385	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
386	* one of the following special values:
387	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
388	* @param ppReq Where to store the pointer to the request.
389	* This will be NULL or a valid request pointer not matter what happends, unless fFlags
390	* contains VMREQFLAGS_NO_WAIT when it will be optional and always NULL.
391	* @param cMillies Number of milliseconds to wait for the request to
392	* be completed. Use RT_INDEFINITE_WAIT to only
393	* wait till it's completed.
394	* @param pfnFunction Pointer to the function to call.
395	* @param fFlags A combination of the VMREQFLAGS values.
396	* @param cArgs Number of arguments following in the ellipsis.
397	* Stuff which differs in size from uintptr_t is gonna make trouble, so don't try!
398	* @param Args Argument vector.
399	*/
400	VMMR3DECL(int) VMR3ReqCallVU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, unsigned cMillies, unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, va_list Args)
401	{
402	LogFlow(("VMR3ReqCallV: idDstCpu=%u cMillies=%d fFlags=%#x pfnFunction=%p cArgs=%d\n", idDstCpu, cMillies, fFlags, pfnFunction, cArgs));
403
404	/*
405	* Validate input.
406	*/
407	AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);
408	AssertPtrReturn(pUVM, VERR_INVALID_POINTER);
409	AssertReturn(!(fFlags & ~(VMREQFLAGS_RETURN_MASK \| VMREQFLAGS_NO_WAIT \| VMREQFLAGS_POKE)), VERR_INVALID_PARAMETER);
410	if (!(fFlags & VMREQFLAGS_NO_WAIT) \|\| ppReq)
411	{
412	AssertPtrReturn(ppReq, VERR_INVALID_POINTER);
413	*ppReq = NULL;
414	}
415	PVMREQ pReq = NULL;
416	AssertMsgReturn(cArgs * sizeof(uintptr_t) <= sizeof(pReq->u.Internal.aArgs),
417	("cArg=%d\n", cArgs),
418	VERR_TOO_MUCH_DATA);
419
420	/*
421	* Allocate request
422	*/
423	int rc = VMR3ReqAllocU(pUVM, &pReq, VMREQTYPE_INTERNAL, idDstCpu);
424	if (RT_FAILURE(rc))
425	return rc;
426
427	/*
428	* Initialize the request data.
429	*/
430	pReq->fFlags = fFlags;
431	pReq->u.Internal.pfn = pfnFunction;
432	pReq->u.Internal.cArgs = cArgs;
433	for (unsigned iArg = 0; iArg < cArgs; iArg++)
434	pReq->u.Internal.aArgs[iArg] = va_arg(Args, uintptr_t);
435
436	/*
437	* Queue the request and return.
438	*/
439	rc = VMR3ReqQueue(pReq, cMillies);
440	if ( RT_FAILURE(rc)
441	&& rc != VERR_TIMEOUT)
442	{
443	VMR3ReqFree(pReq);
444	pReq = NULL;
445	}
446	if (!(fFlags & VMREQFLAGS_NO_WAIT))
447	{
448	*ppReq = pReq;
449	LogFlow(("VMR3ReqCallV: returns %Rrc *ppReq=%p\n", rc, pReq));
450	}
451	else
452	LogFlow(("VMR3ReqCallV: returns %Rrc\n", rc));
453	Assert(rc != VERR_INTERRUPTED);
454	return rc;
455	}
456
457
458	/**
459	* Joins the list pList with whatever is linked up at *pHead.
460	*/
461	static void vmr3ReqJoinFreeSub(volatile PVMREQ *ppHead, PVMREQ pList)
462	{
463	for (unsigned cIterations = 0;; cIterations++)
464	{
465	PVMREQ pHead = (PVMREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, pList);
466	if (!pHead)
467	return;
468	PVMREQ pTail = pHead;
469	while (pTail->pNext)
470	pTail = pTail->pNext;
471	ASMAtomicWritePtr((void * volatile *)&pTail->pNext, pList);
472	ASMCompilerBarrier();
473	if (ASMAtomicCmpXchgPtr((void * volatile )ppHead, (void )pHead, pList))
474	return;
475	ASMAtomicWritePtr((void * volatile *)&pTail->pNext, NULL);
476	ASMCompilerBarrier();
477	if (ASMAtomicCmpXchgPtr((void * volatile )ppHead, (void )pHead, NULL))
478	return;
479	pList = pHead;
480	Assert(cIterations != 32);
481	Assert(cIterations != 64);
482	}
483	}
484
485
486	/**
487	* Joins the list pList with whatever is linked up at *pHead.
488	*/
489	static void vmr3ReqJoinFree(PVMINTUSERPERVM pVMInt, PVMREQ pList)
490	{
491	/*
492	* Split the list if it's too long.
493	*/
494	unsigned cReqs = 1;
495	PVMREQ pTail = pList;
496	while (pTail->pNext)
497	{
498	if (cReqs++ > 25)
499	{
500	const uint32_t i = pVMInt->iReqFree;
501	vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(i + 2) % RT_ELEMENTS(pVMInt->apReqFree)], pTail->pNext);
502
503	pTail->pNext = NULL;
504	vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(i + 2 + (i == pVMInt->iReqFree)) % RT_ELEMENTS(pVMInt->apReqFree)], pTail->pNext);
505	return;
506	}
507	pTail = pTail->pNext;
508	}
509	vmr3ReqJoinFreeSub(&pVMInt->apReqFree[(pVMInt->iReqFree + 2) % RT_ELEMENTS(pVMInt->apReqFree)], pList);
510	}
511
512
513	/**
514	* Allocates a request packet.
515	*
516	* The caller allocates a request packet, fills in the request data
517	* union and queues the request.
518	*
519	* @returns VBox status code.
520	*
521	* @param pVM VM handle.
522	* @param ppReq Where to store the pointer to the allocated packet.
523	* @param enmType Package type.
524	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
525	* one of the following special values:
526	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
527	*/
528	VMMR3DECL(int) VMR3ReqAlloc(PVM pVM, PVMREQ *ppReq, VMREQTYPE enmType, VMCPUID idDstCpu)
529	{
530	return VMR3ReqAllocU(pVM->pUVM, ppReq, enmType, idDstCpu);
531	}
532
533
534	/**
535	* Allocates a request packet.
536	*
537	* The caller allocates a request packet, fills in the request data
538	* union and queues the request.
539	*
540	* @returns VBox status code.
541	*
542	* @param pUVM Pointer to the user mode VM structure.
543	* @param ppReq Where to store the pointer to the allocated packet.
544	* @param enmType Package type.
545	* @param idDstCpu The destination CPU(s). Either a specific CPU ID or
546	* one of the following special values:
547	* VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
548	*/
549	VMMR3DECL(int) VMR3ReqAllocU(PUVM pUVM, PVMREQ *ppReq, VMREQTYPE enmType, VMCPUID idDstCpu)
550	{
551	/*
552	* Validate input.
553	*/
554	AssertMsgReturn(enmType > VMREQTYPE_INVALID && enmType < VMREQTYPE_MAX,
555	("Invalid package type %d valid range %d-%d inclusivly.\n",
556	enmType, VMREQTYPE_INVALID + 1, VMREQTYPE_MAX - 1),
557	VERR_VM_REQUEST_INVALID_TYPE);
558	AssertPtrReturn(ppReq, VERR_INVALID_POINTER);
559	AssertMsgReturn( idDstCpu == VMCPUID_ANY
560	\|\| idDstCpu == VMCPUID_ANY_QUEUE
561	\|\| idDstCpu < pUVM->cCpus
562	\|\| idDstCpu == VMCPUID_ALL
563	\|\| idDstCpu == VMCPUID_ALL_REVERSE,
564	("Invalid destination %u (max=%u)\n", idDstCpu, pUVM->cCpus), VERR_INVALID_PARAMETER);
565
566	/*
567	* Try get a recycled packet.
568	* While this could all be solved with a single list with a lock, it's a sport
569	* of mine to avoid locks.
570	*/
571	int cTries = RT_ELEMENTS(pUVM->vm.s.apReqFree) * 2;
572	while (--cTries >= 0)
573	{
574	PVMREQ volatile *ppHead = &pUVM->vm.s.apReqFree[ASMAtomicIncU32(&pUVM->vm.s.iReqFree) % RT_ELEMENTS(pUVM->vm.s.apReqFree)];
575	#if 0 /* sad, but this won't work safely because the reading of pReq->pNext. */
576	PVMREQ pNext = NULL;
577	PVMREQ pReq = *ppHead;
578	if ( pReq
579	&& !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq)
580	&& (pReq = *ppHead)
581	&& !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq))
582	pReq = NULL;
583	if (pReq)
584	{
585	Assert(pReq->pNext == pNext); NOREF(pReq);
586	#else
587	PVMREQ pReq = (PVMREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, NULL);
588	if (pReq)
589	{
590	PVMREQ pNext = pReq->pNext;
591	if ( pNext
592	&& !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, pNext, NULL))
593	{
594	STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocRaces);
595	vmr3ReqJoinFree(&pUVM->vm.s, pReq->pNext);
596	}
597	#endif
598	ASMAtomicDecU32(&pUVM->vm.s.cReqFree);
599
600	/*
601	* Make sure the event sem is not signaled.
602	*/
603	if (!pReq->fEventSemClear)
604	{
605	int rc = RTSemEventWait(pReq->EventSem, 0);
606	if (rc != VINF_SUCCESS && rc != VERR_TIMEOUT)
607	{
608	/*
609	* This shall not happen, but if it does we'll just destroy
610	* the semaphore and create a new one.
611	*/
612	AssertMsgFailed(("rc=%Rrc from RTSemEventWait(%#x).\n", rc, pReq->EventSem));
613	RTSemEventDestroy(pReq->EventSem);
614	rc = RTSemEventCreate(&pReq->EventSem);
615	AssertRC(rc);
616	if (RT_FAILURE(rc))
617	return rc;
618	}
619	pReq->fEventSemClear = true;
620	}
621	else
622	Assert(RTSemEventWait(pReq->EventSem, 0) == VERR_TIMEOUT);
623
624	/*
625	* Initialize the packet and return it.
626	*/
627	Assert(pReq->enmType == VMREQTYPE_INVALID);
628	Assert(pReq->enmState == VMREQSTATE_FREE);
629	Assert(pReq->pUVM == pUVM);
630	ASMAtomicXchgSize(&pReq->pNext, NULL);
631	pReq->enmState = VMREQSTATE_ALLOCATED;
632	pReq->iStatus = VERR_VM_REQUEST_STATUS_STILL_PENDING;
633	pReq->fFlags = VMREQFLAGS_VBOX_STATUS;
634	pReq->enmType = enmType;
635	pReq->idDstCpu = idDstCpu;
636
637	*ppReq = pReq;
638	STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocRecycled);
639	LogFlow(("VMR3ReqAlloc: returns VINF_SUCCESS *ppReq=%p recycled\n", pReq));
640	return VINF_SUCCESS;
641	}
642	}
643
644	/*
645	* Ok allocate one.
646	*/
647	PVMREQ pReq = (PVMREQ)MMR3HeapAllocU(pUVM, MM_TAG_VM_REQ, sizeof(*pReq));
648	if (!pReq)
649	return VERR_NO_MEMORY;
650
651	/*
652	* Create the semaphore.
653	*/
654	int rc = RTSemEventCreate(&pReq->EventSem);
655	AssertRC(rc);
656	if (RT_FAILURE(rc))
657	{
658	MMR3HeapFree(pReq);
659	return rc;
660	}
661
662	/*
663	* Initialize the packet and return it.
664	*/
665	pReq->pNext = NULL;
666	pReq->pUVM = pUVM;
667	pReq->enmState = VMREQSTATE_ALLOCATED;
668	pReq->iStatus = VERR_VM_REQUEST_STATUS_STILL_PENDING;
669	pReq->fEventSemClear = true;
670	pReq->fFlags = VMREQFLAGS_VBOX_STATUS;
671	pReq->enmType = enmType;
672	pReq->idDstCpu = idDstCpu;
673
674	*ppReq = pReq;
675	STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocNew);
676	LogFlow(("VMR3ReqAlloc: returns VINF_SUCCESS *ppReq=%p new\n", pReq));
677	return VINF_SUCCESS;
678	}
679
680
681	/**
682	* Free a request packet.
683	*
684	* @returns VBox status code.
685	*
686	* @param pReq Package to free.
687	* @remark The request packet must be in allocated or completed state!
688	*/
689	VMMR3DECL(int) VMR3ReqFree(PVMREQ pReq)
690	{
691	/*
692	* Ignore NULL (all free functions should do this imho).
693	*/
694	if (!pReq)
695	return VINF_SUCCESS;
696
697	/*
698	* Check packet state.
699	*/
700	switch (pReq->enmState)
701	{
702	case VMREQSTATE_ALLOCATED:
703	case VMREQSTATE_COMPLETED:
704	break;
705	default:
706	AssertMsgFailed(("Invalid state %d!\n", pReq->enmState));
707	return VERR_VM_REQUEST_STATE;
708	}
709
710	/*
711	* Make it a free packet and put it into one of the free packet lists.
712	*/
713	pReq->enmState = VMREQSTATE_FREE;
714	pReq->iStatus = VERR_VM_REQUEST_STATUS_FREED;
715	pReq->enmType = VMREQTYPE_INVALID;
716
717	PUVM pUVM = pReq->pUVM;
718	STAM_COUNTER_INC(&pUVM->vm.s.StatReqFree);
719
720	if (pUVM->vm.s.cReqFree < 128)
721	{
722	ASMAtomicIncU32(&pUVM->vm.s.cReqFree);
723	PVMREQ volatile *ppHead = &pUVM->vm.s.apReqFree[ASMAtomicIncU32(&pUVM->vm.s.iReqFree) % RT_ELEMENTS(pUVM->vm.s.apReqFree)];
724	PVMREQ pNext;
725	do
726	{
727	pNext = (PVMREQ)ASMAtomicUoReadPtr((void * volatile *)ppHead);
728	ASMAtomicWritePtr((void * volatile *)&pReq->pNext, pNext);
729	ASMCompilerBarrier();
730	} while (!ASMAtomicCmpXchgPtr((void * volatile )ppHead, (void )pReq, (void *)pNext));
731	}
732	else
733	{
734	STAM_COUNTER_INC(&pReq->pUVM->vm.s.StatReqFreeOverflow);
735	RTSemEventDestroy(pReq->EventSem);
736	MMR3HeapFree(pReq);
737	}
738	return VINF_SUCCESS;
739	}
740
741
742	/**
743	* Queue a request.
744	*
745	* The quest must be allocated using VMR3ReqAlloc() and contain
746	* all the required data.
747	* If it's desired to poll on the completion of the request set cMillies
748	* to 0 and use VMR3ReqWait() to check for completation. In the other case
749	* use RT_INDEFINITE_WAIT.
750	*
751	* @returns VBox status code.
752	* Will not return VERR_INTERRUPTED.
753	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
754	*
755	* @param pReq The request to queue.
756	* @param cMillies Number of milliseconds to wait for the request to
757	* be completed. Use RT_INDEFINITE_WAIT to only
758	* wait till it's completed.
759	*/
760	VMMR3DECL(int) VMR3ReqQueue(PVMREQ pReq, unsigned cMillies)
761	{
762	LogFlow(("VMR3ReqQueue: pReq=%p cMillies=%d\n", pReq, cMillies));
763	/*
764	* Verify the supplied package.
765	*/
766	AssertMsgReturn(pReq->enmState == VMREQSTATE_ALLOCATED, ("%d\n", pReq->enmState), VERR_VM_REQUEST_STATE);
767	AssertMsgReturn( VALID_PTR(pReq->pUVM)
768	&& !pReq->pNext
769	&& pReq->EventSem != NIL_RTSEMEVENT,
770	("Invalid request package! Anyone cooking their own packages???\n"),
771	VERR_VM_REQUEST_INVALID_PACKAGE);
772	AssertMsgReturn( pReq->enmType > VMREQTYPE_INVALID
773	&& pReq->enmType < VMREQTYPE_MAX,
774	("Invalid package type %d valid range %d-%d inclusivly. This was verified on alloc too...\n",
775	pReq->enmType, VMREQTYPE_INVALID + 1, VMREQTYPE_MAX - 1),
776	VERR_VM_REQUEST_INVALID_TYPE);
777	Assert(!(pReq->fFlags & ~(VMREQFLAGS_RETURN_MASK \| VMREQFLAGS_NO_WAIT \| VMREQFLAGS_POKE)));
778
779	/*
780	* Are we the EMT or not?
781	* Also, store pVM (and fFlags) locally since pReq may be invalid after queuing it.
782	*/
783	int rc = VINF_SUCCESS;
784	PUVM pUVM = ((VMREQ volatile )pReq)->pUVM; / volatile paranoia */
785	PUVMCPU pUVCpu = (PUVMCPU)RTTlsGet(pUVM->vm.s.idxTLS);
786
787	if (pReq->idDstCpu == VMCPUID_ALL)
788	{
789	/* One-by-one. */
790	Assert(!(pReq->fFlags & VMREQFLAGS_NO_WAIT));
791	for (unsigned i = 0; i < pUVM->cCpus; i++)
792	{
793	/* Reinit some members. */
794	pReq->enmState = VMREQSTATE_ALLOCATED;
795	pReq->idDstCpu = i;
796	rc = VMR3ReqQueue(pReq, cMillies);
797	if (RT_FAILURE(rc))
798	break;
799	}
800	}
801	else if (pReq->idDstCpu == VMCPUID_ALL_REVERSE)
802	{
803	/* One-by-one. */
804	Assert(!(pReq->fFlags & VMREQFLAGS_NO_WAIT));
805	for (int i = pUVM->cCpus-1; i >= 0; i--)
806	{
807	/* Reinit some members. */
808	pReq->enmState = VMREQSTATE_ALLOCATED;
809	pReq->idDstCpu = i;
810	rc = VMR3ReqQueue(pReq, cMillies);
811	if (RT_FAILURE(rc))
812	break;
813	}
814	}
815	else if ( pReq->idDstCpu != VMCPUID_ANY /* for a specific VMCPU? */
816	&& pReq->idDstCpu != VMCPUID_ANY_QUEUE
817	&& ( !pUVCpu /* and it's not the current thread. */
818	\|\| pUVCpu->idCpu != pReq->idDstCpu))
819	{
820	VMCPUID idTarget = pReq->idDstCpu; Assert(idTarget < pUVM->cCpus);
821	PVMCPU pVCpu = &pUVM->pVM->aCpus[idTarget];
822	unsigned fFlags = ((VMREQ volatile )pReq)->fFlags; / volatile paranoia */
823
824	/* Fetch the right UVMCPU */
825	pUVCpu = &pUVM->aCpus[idTarget];
826
827	/*
828	* Insert it.
829	*/
830	pReq->enmState = VMREQSTATE_QUEUED;
831	PVMREQ pNext;
832	do
833	{
834	pNext = (PVMREQ)ASMAtomicUoReadPtr((void * volatile *)&pUVCpu->vm.s.pReqs);
835	ASMAtomicWritePtr((void * volatile *)&pReq->pNext, pNext);
836	ASMCompilerBarrier();
837	} while (!ASMAtomicCmpXchgPtr((void * volatile )&pUVCpu->vm.s.pReqs, (void )pReq, (void *)pNext));
838
839	/*
840	* Notify EMT.
841	*/
842	if (pUVM->pVM)
843	VMCPU_FF_SET(pVCpu, VMCPU_FF_REQUEST);
844	VMR3NotifyCpuFFU(pUVCpu, fFlags & VMREQFLAGS_POKE ? VMNOTIFYFF_FLAGS_POKE : 0);
845
846	/*
847	* Wait and return.
848	*/
849	if (!(fFlags & VMREQFLAGS_NO_WAIT))
850	rc = VMR3ReqWait(pReq, cMillies);
851	LogFlow(("VMR3ReqQueue: returns %Rrc\n", rc));
852	}
853	else if ( ( pReq->idDstCpu == VMCPUID_ANY
854	&& !pUVCpu /* only EMT threads have a valid pointer stored in the TLS slot. */)
855	\|\| pReq->idDstCpu == VMCPUID_ANY_QUEUE)
856	{
857	unsigned fFlags = ((VMREQ volatile )pReq)->fFlags; / volatile paranoia */
858
859	Assert(pReq->idDstCpu != VMCPUID_ANY_QUEUE \|\| pUVCpu);
860
861	/*
862	* Insert it.
863	*/
864	pReq->enmState = VMREQSTATE_QUEUED;
865	PVMREQ pNext;
866	do
867	{
868	pNext = (PVMREQ)ASMAtomicUoReadPtr((void * volatile *)&pUVM->vm.s.pReqs);
869	ASMAtomicWritePtr((void * volatile *)&pReq->pNext, pNext);
870	ASMCompilerBarrier();
871	} while (!ASMAtomicCmpXchgPtr((void * volatile )&pUVM->vm.s.pReqs, (void )pReq, (void *)pNext));
872
873	/*
874	* Notify EMT.
875	*/
876	if (pUVM->pVM)
877	VM_FF_SET(pUVM->pVM, VM_FF_REQUEST);
878	VMR3NotifyGlobalFFU(pUVM, fFlags & VMREQFLAGS_POKE ? VMNOTIFYFF_FLAGS_POKE : 0);
879
880	/*
881	* Wait and return.
882	*/
883	if (!(fFlags & VMREQFLAGS_NO_WAIT))
884	rc = VMR3ReqWait(pReq, cMillies);
885	LogFlow(("VMR3ReqQueue: returns %Rrc\n", rc));
886	}
887	else
888	{
889	Assert(pUVCpu);
890
891	/*
892	* The requester was an EMT, just execute it.
893	*/
894	pReq->enmState = VMREQSTATE_QUEUED;
895	rc = vmR3ReqProcessOneU(pUVM, pReq);
896	LogFlow(("VMR3ReqQueue: returns %Rrc (processed)\n", rc));
897	}
898	return rc;
899	}
900
901
902	/**
903	* Wait for a request to be completed.
904	*
905	* @returns VBox status code.
906	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
907	*
908	* @param pReq The request to wait for.
909	* @param cMillies Number of milliseconds to wait.
910	* Use RT_INDEFINITE_WAIT to only wait till it's completed.
911	*/
912	VMMR3DECL(int) VMR3ReqWait(PVMREQ pReq, unsigned cMillies)
913	{
914	LogFlow(("VMR3ReqWait: pReq=%p cMillies=%d\n", pReq, cMillies));
915
916	/*
917	* Verify the supplied package.
918	*/
919	AssertMsgReturn( pReq->enmState == VMREQSTATE_QUEUED
920	\|\| pReq->enmState == VMREQSTATE_PROCESSING
921	\|\| pReq->enmState == VMREQSTATE_COMPLETED,
922	("Invalid state %d\n", pReq->enmState),
923	VERR_VM_REQUEST_STATE);
924	AssertMsgReturn( VALID_PTR(pReq->pUVM)
925	&& pReq->EventSem != NIL_RTSEMEVENT,
926	("Invalid request package! Anyone cooking their own packages???\n"),
927	VERR_VM_REQUEST_INVALID_PACKAGE);
928	AssertMsgReturn( pReq->enmType > VMREQTYPE_INVALID
929	&& pReq->enmType < VMREQTYPE_MAX,
930	("Invalid package type %d valid range %d-%d inclusivly. This was verified on alloc too...\n",
931	pReq->enmType, VMREQTYPE_INVALID + 1, VMREQTYPE_MAX - 1),
932	VERR_VM_REQUEST_INVALID_TYPE);
933
934	/*
935	* Check for deadlock condition
936	*/
937	PUVM pUVM = pReq->pUVM;
938	NOREF(pUVM);
939
940	/*
941	* Wait on the package.
942	*/
943	int rc;
944	if (cMillies != RT_INDEFINITE_WAIT)
945	rc = RTSemEventWait(pReq->EventSem, cMillies);
946	else
947	{
948	do
949	{
950	rc = RTSemEventWait(pReq->EventSem, RT_INDEFINITE_WAIT);
951	Assert(rc != VERR_TIMEOUT);
952	} while ( pReq->enmState != VMREQSTATE_COMPLETED
953	&& pReq->enmState != VMREQSTATE_INVALID);
954	}
955	if (RT_SUCCESS(rc))
956	ASMAtomicXchgSize(&pReq->fEventSemClear, true);
957	if (pReq->enmState == VMREQSTATE_COMPLETED)
958	rc = VINF_SUCCESS;
959	LogFlow(("VMR3ReqWait: returns %Rrc\n", rc));
960	Assert(rc != VERR_INTERRUPTED);
961	return rc;
962	}
963
964
965	/**
966	* Process pending request(s).
967	*
968	* This function is called from a forced action handler in the EMT
969	* or from one of the EMT loops.
970	*
971	* @returns VBox status code.
972	*
973	* @param pUVM Pointer to the user mode VM structure.
974	* @param idDstCpu Pass VMCPUID_ANY to process the common request queue
975	* and the CPU ID for a CPU specific one. In the latter
976	* case the calling thread must be the EMT of that CPU.
977	*
978	* @note SMP safe (multiple EMTs trying to satisfy VM_FF_REQUESTs).
979	*/
980	VMMR3DECL(int) VMR3ReqProcessU(PUVM pUVM, VMCPUID idDstCpu)
981	{
982	LogFlow(("VMR3ReqProcessU: (enmVMState=%d) idDstCpu=%d\n", pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING, idDstCpu));
983
984	/*
985	* Process loop.
986	*
987	* We do not repeat the outer loop if we've got an informational status code
988	* since that code needs processing by our caller.
989	*/
990	int rc = VINF_SUCCESS;
991	while (rc <= VINF_SUCCESS)
992	{
993	/*
994	* Get pending requests.
995	*/
996	void * volatile *ppReqs;
997	if (idDstCpu == VMCPUID_ANY)
998	{
999	ppReqs = (void * volatile *)&pUVM->vm.s.pReqs;
1000	if (RT_LIKELY(pUVM->pVM))
1001	VM_FF_CLEAR(pUVM->pVM, VM_FF_REQUEST);
1002	}
1003	else
1004	{
1005	Assert(idDstCpu < pUVM->cCpus);
1006	Assert(pUVM->aCpus[idDstCpu].vm.s.NativeThreadEMT == RTThreadNativeSelf());
1007	ppReqs = (void * volatile *)&pUVM->aCpus[idDstCpu].vm.s.pReqs;
1008	if (RT_LIKELY(pUVM->pVM))
1009	VMCPU_FF_CLEAR(&pUVM->pVM->aCpus[idDstCpu], VMCPU_FF_REQUEST);
1010	}
1011	PVMREQ pReqs = (PVMREQ)ASMAtomicXchgPtr(ppReqs, NULL);
1012	if (!pReqs)
1013	break;
1014
1015	/*
1016	* Reverse the list to process it in FIFO order.
1017	*/
1018	PVMREQ pReq = pReqs;
1019	if (pReq->pNext)
1020	Log2(("VMR3ReqProcess: 2+ requests: %p %p %p\n", pReq, pReq->pNext, pReq->pNext->pNext));
1021	pReqs = NULL;
1022	while (pReq)
1023	{
1024	Assert(pReq->enmState == VMREQSTATE_QUEUED);
1025	Assert(pReq->pUVM == pUVM);
1026	PVMREQ pCur = pReq;
1027	pReq = pReq->pNext;
1028	pCur->pNext = pReqs;
1029	pReqs = pCur;
1030	}
1031
1032
1033	/*
1034	* Process the requests.
1035	*
1036	* Since this is a FF worker certain rules applies to the
1037	* status codes. See the EM section in VBox/err.h and EM.cpp for details.
1038	*/
1039	while (pReqs)
1040	{
1041	/* Unchain the first request and advance the list. */
1042	pReq = pReqs;
1043	pReqs = pReqs->pNext;
1044	pReq->pNext = NULL;
1045
1046	/* Process the request */
1047	int rc2 = vmR3ReqProcessOneU(pUVM, pReq);
1048
1049	/*
1050	* The status code handling extremely important yet very fragile. Should probably
1051	* look for a better way of communicating status changes to EM...
1052	*/
1053	if ( rc2 >= VINF_EM_FIRST
1054	&& rc2 <= VINF_EM_LAST
1055	&& ( rc == VINF_SUCCESS
1056	\|\| rc2 < rc) )
1057	rc = rc2;
1058	/** @todo may have to abort processing to propagate EM scheduling status codes
1059	* up to the caller... See the ugly hacks after VMMR3EmtRendezvousFF
1060	* and VMR3ReqProcessU in EM.cpp. */
1061	}
1062	}
1063
1064	LogFlow(("VMR3ReqProcess: returns %Rrc (enmVMState=%d)\n", rc, pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING));
1065	return rc;
1066	}
1067
1068
1069	/**
1070	* Process one request.
1071	*
1072	* @returns VBox status code.
1073	*
1074	* @param pVM VM handle.
1075	* @param pReq Request packet to process.
1076	*/
1077	static int vmR3ReqProcessOneU(PUVM pUVM, PVMREQ pReq)
1078	{
1079	LogFlow(("vmR3ReqProcessOne: pReq=%p type=%d fFlags=%#x\n", pReq, pReq->enmType, pReq->fFlags));
1080
1081	/*
1082	* Process the request.
1083	*/
1084	Assert(pReq->enmState == VMREQSTATE_QUEUED);
1085	pReq->enmState = VMREQSTATE_PROCESSING;
1086	int rcRet = VINF_SUCCESS; /* the return code of this function. */
1087	int rcReq = VERR_NOT_IMPLEMENTED; /* the request status. */
1088	switch (pReq->enmType)
1089	{
1090	/*
1091	* A packed down call frame.
1092	*/
1093	case VMREQTYPE_INTERNAL:
1094	{
1095	uintptr_t *pauArgs = &pReq->u.Internal.aArgs[0];
1096	union
1097	{
1098	PFNRT pfn;
1099	DECLCALLBACKMEMBER(int, pfn00)(void);
1100	DECLCALLBACKMEMBER(int, pfn01)(uintptr_t);
1101	DECLCALLBACKMEMBER(int, pfn02)(uintptr_t, uintptr_t);
1102	DECLCALLBACKMEMBER(int, pfn03)(uintptr_t, uintptr_t, uintptr_t);
1103	DECLCALLBACKMEMBER(int, pfn04)(uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1104	DECLCALLBACKMEMBER(int, pfn05)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1105	DECLCALLBACKMEMBER(int, pfn06)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1106	DECLCALLBACKMEMBER(int, pfn07)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1107	DECLCALLBACKMEMBER(int, pfn08)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1108	DECLCALLBACKMEMBER(int, pfn09)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1109	DECLCALLBACKMEMBER(int, pfn10)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
1110	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);
1111	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);
1112	} u;
1113	u.pfn = pReq->u.Internal.pfn;
1114	#ifdef RT_ARCH_AMD64
1115	switch (pReq->u.Internal.cArgs)
1116	{
1117	case 0: rcRet = u.pfn00(); break;
1118	case 1: rcRet = u.pfn01(pauArgs[0]); break;
1119	case 2: rcRet = u.pfn02(pauArgs[0], pauArgs[1]); break;
1120	case 3: rcRet = u.pfn03(pauArgs[0], pauArgs[1], pauArgs[2]); break;
1121	case 4: rcRet = u.pfn04(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3]); break;
1122	case 5: rcRet = u.pfn05(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4]); break;
1123	case 6: rcRet = u.pfn06(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5]); break;
1124	case 7: rcRet = u.pfn07(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6]); break;
1125	case 8: rcRet = u.pfn08(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7]); break;
1126	case 9: rcRet = u.pfn09(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8]); break;
1127	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;
1128	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;
1129	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;
1130	default:
1131	AssertReleaseMsgFailed(("cArgs=%d\n", pReq->u.Internal.cArgs));
1132	rcRet = rcReq = VERR_INTERNAL_ERROR;
1133	break;
1134	}
1135	#else /* x86: */
1136	size_t cbArgs = pReq->u.Internal.cArgs * sizeof(uintptr_t);
1137	# ifdef __GNUC__
1138	__asm__ __volatile__("movl %%esp, %%edx\n\t"
1139	"subl %2, %%esp\n\t"
1140	"andl $0xfffffff0, %%esp\n\t"
1141	"shrl $2, %2\n\t"
1142	"movl %%esp, %%edi\n\t"
1143	"rep movsl\n\t"
1144	"movl %%edx, %%edi\n\t"
1145	"call *%%eax\n\t"
1146	"mov %%edi, %%esp\n\t"
1147	: "=a" (rcRet),
1148	"=S" (pauArgs),
1149	"=c" (cbArgs)
1150	: "0" (u.pfn),
1151	"1" (pauArgs),
1152	"2" (cbArgs)
1153	: "edi", "edx");
1154	# else
1155	__asm
1156	{
1157	xor edx, edx /* just mess it up. */
1158	mov eax, u.pfn
1159	mov ecx, cbArgs
1160	shr ecx, 2
1161	mov esi, pauArgs
1162	mov ebx, esp
1163	sub esp, cbArgs
1164	and esp, 0xfffffff0
1165	mov edi, esp
1166	rep movsd
1167	call eax
1168	mov esp, ebx
1169	mov rcRet, eax
1170	}
1171	# endif
1172	#endif /* x86 */
1173	if ((pReq->fFlags & (VMREQFLAGS_RETURN_MASK)) == VMREQFLAGS_VOID)
1174	rcRet = VINF_SUCCESS;
1175	rcReq = rcRet;
1176	break;
1177	}
1178
1179	default:
1180	AssertMsgFailed(("pReq->enmType=%d\n", pReq->enmType));
1181	rcReq = VERR_NOT_IMPLEMENTED;
1182	break;
1183	}
1184
1185	/*
1186	* Complete the request.
1187	*/
1188	pReq->iStatus = rcReq;
1189	pReq->enmState = VMREQSTATE_COMPLETED;
1190	if (pReq->fFlags & VMREQFLAGS_NO_WAIT)
1191	{
1192	/* Free the packet, nobody is waiting. */
1193	LogFlow(("vmR3ReqProcessOne: Completed request %p: rcReq=%Rrc rcRet=%Rrc - freeing it\n",
1194	pReq, rcReq, rcRet));
1195	VMR3ReqFree(pReq);
1196	}
1197	else
1198	{
1199	/* Notify the waiter and him free up the packet. */
1200	LogFlow(("vmR3ReqProcessOne: Completed request %p: rcReq=%Rrc rcRet=%Rrc - notifying waiting thread\n",
1201	pReq, rcReq, rcRet));
1202	ASMAtomicXchgSize(&pReq->fEventSemClear, false);
1203	int rc2 = RTSemEventSignal(pReq->EventSem);
1204	if (RT_FAILURE(rc2))
1205	{
1206	AssertRC(rc2);
1207	rcRet = rc2;
1208	}
1209	}
1210	return rcRet;
1211	}
1212
1213
1214
1215

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMReq.cpp@ 23495

Download in other formats: