req.cpp@ 3460

Last change on this file since 3460 was 2981, checked in by vboxsync, 18 years ago
InnoTek -> innotek: all the headers and comments.
File size: 30.9 KB

Line
1	/* $Id: VMReq.cpp 17451 2007-01-15 14:08:28Z bird $ */
2	/** @file
3	* innotek Portable Runtime - Request packets
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26
27	#include <iprt/assert.h>
28	#include <iprt/asm.h>
29	#include <iprt/string.h>
30	#include <iprt/time.h>
31	#include <iprt/semaphore.h>
32	#include <iprt/thread.h>
33	#include <iprt/req.h>
34	#include <iprt/log.h>
35	#include <iprt/mem.h>
36
37
38	/*******************************************************************************
39	* Internal Functions *
40	*******************************************************************************/
41	static int rtReqProcessOne(PRTREQ pReq);
42
43
44
45	/**
46	* Create a request packet queueu
47	*
48	* @returns iprt status code.
49	* @param pReqQueue The request queue.
50	*/
51	RTDECL(int) RTReqCreateQueue(PRTREQQUEUE *ppQueue)
52	{
53	*ppQueue = (PRTREQQUEUE)RTMemAllocZ(sizeof(RTREQQUEUE));
54	if (!ppQueue)
55	return VERR_NO_MEMORY;
56
57	int rc = RTSemEventCreate(&(*ppQueue)->EventSem);
58	if (rc != VINF_SUCCESS)
59	RTMemFree(*ppQueue);
60
61	return rc;
62	}
63
64
65	/**
66	* Destroy a request packet queueu
67	*
68	* @returns iprt status code.
69	* @param pReqQueue The request queue.
70	*/
71	RTDECL(int) RTReqDestroyQueue(PRTREQQUEUE pQueue)
72	{
73	/*
74	* Check input.
75	*/
76	if (!pQueue)
77	{
78	AssertFailed();
79	return VERR_INVALID_PARAMETER;
80	}
81	RTSemEventDestroy(pQueue->EventSem);
82	RTMemFree(pQueue);
83	return VINF_SUCCESS;
84	}
85
86	/**
87	* Process one or more request packets
88	*
89	* @returns iprt status code.
90	* @returns VERR_TIMEOUT if cMillies was reached without the packet being added.
91	*
92	* @param pReqQueue The request queue.
93	* @param cMillies Number of milliseconds to wait for a pending request.
94	* Use RT_INDEFINITE_WAIT to only wait till one is added.
95	*/
96	RTDECL(int) RTReqProcess(PRTREQQUEUE pQueue, unsigned cMillies)
97	{
98	LogFlow(("RTReqProcess %x\n", pQueue));
99	/*
100	* Check input.
101	*/
102	if (!pQueue)
103	{
104	AssertFailed();
105	return VERR_INVALID_PARAMETER;
106	}
107
108	/*
109	* Process loop.
110	*
111	* We do not repeat the outer loop if we've got an informationtional status code
112	* since that code needs processing by our caller.
113	*/
114	int rc = VINF_SUCCESS;
115	while (rc <= VINF_SUCCESS)
116	{
117	/*
118	* Get pending requests.
119	*/
120	PRTREQ pReqs = (PRTREQ)ASMAtomicXchgPtr((void * volatile *)&pQueue->pReqs, NULL);
121	if (!pReqs)
122	{
123	/** @note We currently don't care if the entire time wasted here is larger than cMillies */
124	rc = RTSemEventWait(pQueue->EventSem, cMillies);
125	if (rc != VINF_SUCCESS)
126	break;
127	continue;
128	}
129
130	/*
131	* Reverse the list to process it in FIFO order.
132	*/
133	PRTREQ pReq = pReqs;
134	if (pReq->pNext)
135	Log2(("RTReqProcess: 2+ requests: %p %p %p\n", pReq, pReq->pNext, pReq->pNext->pNext));
136	pReqs = NULL;
137	while (pReq)
138	{
139	Assert(pReq->enmState == RTREQSTATE_QUEUED);
140	Assert(pReq->pQueue == pQueue);
141	PRTREQ pCur = pReq;
142	pReq = pReq->pNext;
143	pCur->pNext = pReqs;
144	pReqs = pCur;
145	}
146
147
148	/*
149	* Process the requests.
150	*/
151	while (pReqs)
152	{
153	/* Unchain the first request and advance the list. */
154	pReq = pReqs;
155	pReqs = pReqs->pNext;
156	pReq->pNext = NULL;
157
158	/* Process the request */
159	rc = rtReqProcessOne(pReq);
160	AssertRC(rc);
161	if (rc != VINF_SUCCESS)
162	break;
163	}
164	}
165
166	LogFlow(("RTReqProcess: returns %Vrc\n", rc));
167	return rc;
168	}
169
170	/**
171	* Allocate and queue a call request.
172	*
173	* If it's desired to poll on the completion of the request set cMillies
174	* to 0 and use RTReqWait() to check for completation. In the other case
175	* use RT_INDEFINITE_WAIT.
176	* The returned request packet must be freed using RTReqFree().
177	*
178	* @returns iprt statuscode.
179	* Will not return VERR_INTERRUPTED.
180	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
181	*
182	* @param pReqQueue The request queue.
183	* @param ppReq Where to store the pointer to the request.
184	* This will be NULL or a valid request pointer not matter what happens.
185	* @param cMillies Number of milliseconds to wait for the request to
186	* be completed. Use RT_INDEFINITE_WAIT to only
187	* wait till it's completed.
188	* @param pfnFunction Pointer to the function to call.
189	* @param cArgs Number of arguments following in the ellipsis.
190	* Not possible to pass 64-bit arguments!
191	* @param ... Function arguments.
192	*/
193	RTDECL(int) RTReqCall(PRTREQQUEUE pQueue, PRTREQ *ppReq, unsigned cMillies, PFNRT pfnFunction, unsigned cArgs, ...)
194	{
195	va_list va;
196	va_start(va, cArgs);
197	int rc = RTReqCallV(pQueue, ppReq, cMillies, RTREQFLAGS_IPRT_STATUS, pfnFunction, cArgs, va);
198	va_end(va);
199	return rc;
200	}
201
202
203	/**
204	* Allocate and queue a call request to a void function.
205	*
206	* If it's desired to poll on the completion of the request set cMillies
207	* to 0 and use RTReqWait() to check for completation. In the other case
208	* use RT_INDEFINITE_WAIT.
209	* The returned request packet must be freed using RTReqFree().
210	*
211	* @returns iprt status code.
212	* Will not return VERR_INTERRUPTED.
213	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
214	*
215	* @param pReqQueue The request queue.
216	* @param ppReq Where to store the pointer to the request.
217	* This will be NULL or a valid request pointer not matter what happends.
218	* @param cMillies Number of milliseconds to wait for the request to
219	* be completed. Use RT_INDEFINITE_WAIT to only
220	* wait till it's completed.
221	* @param pfnFunction Pointer to the function to call.
222	* @param cArgs Number of arguments following in the ellipsis.
223	* Not possible to pass 64-bit arguments!
224	* @param ... Function arguments.
225	*/
226	RTDECL(int) RTReqCallVoid(PRTREQQUEUE pQueue, PRTREQ *ppReq, unsigned cMillies, PFNRT pfnFunction, unsigned cArgs, ...)
227	{
228	va_list va;
229	va_start(va, cArgs);
230	int rc = RTReqCallV(pQueue, ppReq, cMillies, RTREQFLAGS_VOID, pfnFunction, cArgs, va);
231	va_end(va);
232	return rc;
233	}
234
235
236	/**
237	* Allocate and queue a call request to a void function.
238	*
239	* If it's desired to poll on the completion of the request set cMillies
240	* to 0 and use RTReqWait() to check for completation. In the other case
241	* use RT_INDEFINITE_WAIT.
242	* The returned request packet must be freed using RTReqFree().
243	*
244	* @returns iprt status code.
245	* Will not return VERR_INTERRUPTED.
246	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
247	*
248	* @param pReqQueue The request queue.
249	* @param ppReq Where to store the pointer to the request.
250	* This will be NULL or a valid request pointer not matter what happends, unless fFlags
251	* contains RTREQFLAGS_NO_WAIT when it will be optional and always NULL.
252	* @param cMillies Number of milliseconds to wait for the request to
253	* be completed. Use RT_INDEFINITE_WAIT to only
254	* wait till it's completed.
255	* @param fFlags A combination of the RTREQFLAGS values.
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	RTDECL(int) RTReqCallEx(PRTREQQUEUE pQueue, PRTREQ *ppReq, unsigned cMillies, unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
262	{
263	va_list va;
264	va_start(va, cArgs);
265	int rc = RTReqCallV(pQueue, ppReq, cMillies, fFlags, pfnFunction, cArgs, va);
266	va_end(va);
267	return rc;
268	}
269
270
271	/**
272	* Allocate and queue a call request.
273	*
274	* If it's desired to poll on the completion of the request set cMillies
275	* to 0 and use RTReqWait() to check for completation. In the other case
276	* use RT_INDEFINITE_WAIT.
277	* The returned request packet must be freed using RTReqFree().
278	*
279	* @returns iprt status code.
280	* Will not return VERR_INTERRUPTED.
281	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
282	*
283	* @param pReqQueue The request queue.
284	* @param ppReq Where to store the pointer to the request.
285	* This will be NULL or a valid request pointer not matter what happends, unless fFlags
286	* contains RTREQFLAGS_NO_WAIT when it will be optional and always NULL.
287	* @param cMillies Number of milliseconds to wait for the request to
288	* be completed. Use RT_INDEFINITE_WAIT to only
289	* wait till it's completed.
290	* @param fFlags A combination of the RTREQFLAGS values.
291	* @param pfnFunction Pointer to the function to call.
292	* @param cArgs Number of arguments following in the ellipsis.
293	* Not possible to pass 64-bit arguments!
294	* @param pvArgs Pointer to function arguments.
295	*/
296	RTDECL(int) RTReqCallV(PRTREQQUEUE pQueue, PRTREQ *ppReq, unsigned cMillies, unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, va_list Args)
297	{
298	LogFlow(("RTReqCallV: cMillies=%d fFlags=%#x pfnFunction=%p cArgs=%d\n", cMillies, fFlags, pfnFunction, cArgs));
299
300	/*
301	* Check input.
302	*/
303	if (!pfnFunction \|\| !pQueue \|\| (fFlags & ~(RTREQFLAGS_RETURN_MASK \| RTREQFLAGS_NO_WAIT)))
304	{
305	AssertFailed();
306	return VERR_INVALID_PARAMETER;
307	}
308	if (!(fFlags & RTREQFLAGS_NO_WAIT) \|\| ppReq)
309	{
310	Assert(ppReq);
311	*ppReq = NULL;
312	}
313	PRTREQ pReq = NULL;
314	if (cArgs * sizeof(uintptr_t) > sizeof(pReq->u.Internal.aArgs))
315	{
316	AssertMsgFailed(("cArg=%d\n", cArgs));
317	return VERR_TOO_MUCH_DATA;
318	}
319
320	/*
321	* Allocate request
322	*/
323	int rc = RTReqAlloc(pQueue, &pReq, RTREQTYPE_INTERNAL);
324	if (rc != VINF_SUCCESS)
325	return rc;
326
327	/*
328	* Initialize the request data.
329	*/
330	pReq->fFlags = fFlags;
331	pReq->u.Internal.pfn = pfnFunction;
332	pReq->u.Internal.cArgs = cArgs;
333	for (unsigned iArg = 0; iArg < cArgs; iArg++)
334	pReq->u.Internal.aArgs[iArg] = va_arg(Args, uintptr_t);
335
336	/*
337	* Queue the request and return.
338	*/
339	rc = RTReqQueue(pReq, cMillies);
340	if ( rc != VINF_SUCCESS
341	&& rc != VERR_TIMEOUT)
342	{
343	RTReqFree(pReq);
344	pReq = NULL;
345	}
346	if (!(fFlags & RTREQFLAGS_NO_WAIT))
347	{
348	*ppReq = pReq;
349	LogFlow(("RTReqCallV: returns %Vrc *ppReq=%p\n", rc, pReq));
350	}
351	else
352	LogFlow(("RTReqCallV: returns %Vrc\n", rc));
353	Assert(rc != VERR_INTERRUPTED);
354	return rc;
355	}
356
357
358	/**
359	* Joins the list pList with whatever is linked up at *pHead.
360	*/
361	static void vmr3ReqJoinFreeSub(volatile PRTREQ *ppHead, PRTREQ pList)
362	{
363	for (unsigned cIterations = 0;; cIterations++)
364	{
365	PRTREQ pHead = (PRTREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, pList);
366	if (!pHead)
367	return;
368	PRTREQ pTail = pHead;
369	while (pTail->pNext)
370	pTail = pTail->pNext;
371	pTail->pNext = pList;
372	if (ASMAtomicCmpXchgPtr((void * volatile )ppHead, (void )pHead, pList))
373	return;
374	pTail->pNext = NULL;
375	if (ASMAtomicCmpXchgPtr((void * volatile )ppHead, (void )pHead, NULL))
376	return;
377	pList = pHead;
378	Assert(cIterations != 32);
379	Assert(cIterations != 64);
380	}
381	}
382
383
384	/**
385	* Joins the list pList with whatever is linked up at *pHead.
386	*/
387	static void vmr3ReqJoinFree(PRTREQQUEUE pQueue, PRTREQ pList)
388	{
389	/*
390	* Split the list if it's too long.
391	*/
392	unsigned cReqs = 1;
393	PRTREQ pTail = pList;
394	while (pTail->pNext)
395	{
396	if (cReqs++ > 25)
397	{
398	const uint32_t i = pQueue->iReqFree;
399	vmr3ReqJoinFreeSub(&pQueue->apReqFree[(i + 2) % ELEMENTS(pQueue->apReqFree)], pTail->pNext);
400
401	pTail->pNext = NULL;
402	vmr3ReqJoinFreeSub(&pQueue->apReqFree[(i + 2 + (i == pQueue->iReqFree)) % ELEMENTS(pQueue->apReqFree)], pTail->pNext);
403	return;
404	}
405	pTail = pTail->pNext;
406	}
407	vmr3ReqJoinFreeSub(&pQueue->apReqFree[(pQueue->iReqFree + 2) % ELEMENTS(pQueue->apReqFree)], pList);
408	}
409
410
411	/**
412	* Allocates a request packet.
413	*
414	* The caller allocates a request packet, fills in the request data
415	* union and queues the request.
416	*
417	* @returns iprt status code.
418	*
419	* @param pReqQueue The request queue.
420	* @param ppReq Where to store the pointer to the allocated packet.
421	* @param enmType Package type.
422	*/
423	RTDECL(int) RTReqAlloc(PRTREQQUEUE pQueue, PRTREQ *ppReq, RTREQTYPE enmType)
424	{
425	/*
426	* Validate input.
427	*/
428	if ( enmType < RTREQTYPE_INVALID
429	\|\| enmType > RTREQTYPE_MAX)
430	{
431	AssertMsgFailed(("Invalid package type %d valid range %d-%d inclusivly.\n",
432	enmType, RTREQTYPE_INVALID + 1, RTREQTYPE_MAX - 1));
433	return VERR_RT_REQUEST_INVALID_TYPE;
434	}
435
436	/*
437	* Try get a recycled packet.
438	* While this could all be solved with a single list with a lock, it's a sport
439	* of mine to avoid locks.
440	*/
441	int cTries = ELEMENTS(pQueue->apReqFree) * 2;
442	while (--cTries >= 0)
443	{
444	PRTREQ volatile *ppHead = &pQueue->apReqFree[ASMAtomicIncU32(&pQueue->iReqFree) % ELEMENTS(pQueue->apReqFree)];
445	#if 0 /* sad, but this won't work safely because the reading of pReq->pNext. */
446	PRTREQ pNext = NULL;
447	PRTREQ pReq = *ppHead;
448	if ( pReq
449	&& !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq)
450	&& (pReq = *ppHead)
451	&& !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq))
452	pReq = NULL;
453	if (pReq)
454	{
455	Assert(pReq->pNext == pNext); NOREF(pReq);
456	#else
457	PRTREQ pReq = (PRTREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, NULL);
458	if (pReq)
459	{
460	PRTREQ pNext = pReq->pNext;
461	if ( pNext
462	&& !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, pNext, NULL))
463	{
464	vmr3ReqJoinFree(pQueue, pReq->pNext);
465	}
466	#endif
467	ASMAtomicDecU32(&pQueue->cReqFree);
468
469	/*
470	* Make sure the event sem is not signaled.
471	*/
472	if (!pReq->fEventSemClear)
473	{
474	int rc = RTSemEventWait(pReq->EventSem, 0);
475	if (rc != VINF_SUCCESS && rc != VERR_TIMEOUT)
476	{
477	/*
478	* This shall not happen, but if it does we'll just destroy
479	* the semaphore and create a new one.
480	*/
481	AssertMsgFailed(("rc=%Vrc from RTSemEventWait(%#x).\n", rc, pReq->EventSem));
482	RTSemEventDestroy(pReq->EventSem);
483	rc = RTSemEventCreate(&pReq->EventSem);
484	AssertRC(rc);
485	if (rc != VINF_SUCCESS)
486	return rc;
487	}
488	pReq->fEventSemClear = true;
489	}
490	else
491	Assert(RTSemEventWait(pReq->EventSem, 0) == VERR_TIMEOUT);
492
493	/*
494	* Initialize the packet and return it.
495	*/
496	Assert(pReq->enmType == RTREQTYPE_INVALID);
497	Assert(pReq->enmState == RTREQSTATE_FREE);
498	Assert(pReq->pQueue == pQueue);
499	ASMAtomicXchgSize(&pReq->pNext, NULL);
500	pReq->enmState = RTREQSTATE_ALLOCATED;
501	pReq->iStatus = VERR_RT_REQUEST_STATUS_STILL_PENDING;
502	pReq->fFlags = RTREQFLAGS_IPRT_STATUS;
503	pReq->enmType = enmType;
504
505	*ppReq = pReq;
506	LogFlow(("RTReqAlloc: returns VINF_SUCCESS *ppReq=%p recycled\n", pReq));
507	return VINF_SUCCESS;
508	}
509	}
510
511	/*
512	* Ok allocate one.
513	*/
514	PRTREQ pReq = (PRTREQ)RTMemAllocZ(sizeof(*pReq));
515	if (!pReq)
516	return VERR_NO_MEMORY;
517
518	/*
519	* Create the semaphore.
520	*/
521	int rc = RTSemEventCreate(&pReq->EventSem);
522	AssertRC(rc);
523	if (rc != VINF_SUCCESS)
524	{
525	RTMemFree(pReq);
526	return rc;
527	}
528
529	/*
530	* Initialize the packet and return it.
531	*/
532	pReq->pNext = NULL;
533	pReq->pQueue = pQueue;
534	pReq->enmState = RTREQSTATE_ALLOCATED;
535	pReq->iStatus = VERR_RT_REQUEST_STATUS_STILL_PENDING;
536	pReq->fEventSemClear = true;
537	pReq->fFlags = RTREQFLAGS_IPRT_STATUS;
538	pReq->enmType = enmType;
539
540	*ppReq = pReq;
541	LogFlow(("RTReqAlloc: returns VINF_SUCCESS *ppReq=%p new\n", pReq));
542	return VINF_SUCCESS;
543	}
544
545
546	/**
547	* Free a request packet.
548	*
549	* @returns iprt status code.
550	*
551	* @param pReq Package to free.
552	* @remark The request packet must be in allocated or completed state!
553	*/
554	RTDECL(int) RTReqFree(PRTREQ pReq)
555	{
556	/*
557	* Ignore NULL (all free functions should do this imho).
558	*/
559	if (!pReq)
560	return VINF_SUCCESS;
561
562
563	/*
564	* Check packet state.
565	*/
566	switch (pReq->enmState)
567	{
568	case RTREQSTATE_ALLOCATED:
569	case RTREQSTATE_COMPLETED:
570	break;
571	default:
572	AssertMsgFailed(("Invalid state %d!\n", pReq->enmState));
573	return VERR_RT_REQUEST_STATE;
574	}
575
576	/*
577	* Make it a free packet and put it into one of the free packet lists.
578	*/
579	pReq->enmState = RTREQSTATE_FREE;
580	pReq->iStatus = VERR_RT_REQUEST_STATUS_FREED;
581	pReq->enmType = RTREQTYPE_INVALID;
582
583	PRTREQQUEUE pQueue = pReq->pQueue;
584	if (pQueue->cReqFree < 128)
585	{
586	ASMAtomicIncU32(&pQueue->cReqFree);
587	PRTREQ volatile *ppHead = &pQueue->apReqFree[ASMAtomicIncU32(&pQueue->iReqFree) % ELEMENTS(pQueue->apReqFree)];
588	PRTREQ pNext;
589	do
590	{
591	pNext = *ppHead;
592	ASMAtomicXchgPtr((void * volatile *)&pReq->pNext, pNext);
593	} while (!ASMAtomicCmpXchgPtr((void * volatile )ppHead, (void )pReq, (void *)pNext));
594	}
595	else
596	{
597	RTSemEventDestroy(pReq->EventSem);
598	RTMemFree(pReq);
599	}
600	return VINF_SUCCESS;
601	}
602
603
604	/**
605	* Queue a request.
606	*
607	* The quest must be allocated using RTReqAlloc() and contain
608	* all the required data.
609	* If it's disired to poll on the completion of the request set cMillies
610	* to 0 and use RTReqWait() to check for completation. In the other case
611	* use RT_INDEFINITE_WAIT.
612	*
613	* @returns iprt status code.
614	* Will not return VERR_INTERRUPTED.
615	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
616	*
617	* @param pReq The request to queue.
618	* @param cMillies Number of milliseconds to wait for the request to
619	* be completed. Use RT_INDEFINITE_WAIT to only
620	* wait till it's completed.
621	*/
622	RTDECL(int) RTReqQueue(PRTREQ pReq, unsigned cMillies)
623	{
624	LogFlow(("RTReqQueue: pReq=%p cMillies=%d\n", pReq, cMillies));
625	/*
626	* Verify the supplied package.
627	*/
628	if (pReq->enmState != RTREQSTATE_ALLOCATED)
629	{
630	AssertMsgFailed(("Invalid state %d\n", pReq->enmState));
631	return VERR_RT_REQUEST_STATE;
632	}
633	if ( !pReq->pQueue
634	\|\| pReq->pNext
635	\|\| !pReq->EventSem)
636	{
637	AssertMsgFailed(("Invalid request package! Anyone cooking their own packages???\n"));
638	return VERR_RT_REQUEST_INVALID_PACKAGE;
639	}
640	if ( pReq->enmType < RTREQTYPE_INVALID
641	\|\| pReq->enmType > RTREQTYPE_MAX)
642	{
643	AssertMsgFailed(("Invalid package type %d valid range %d-%d inclusivly. This was verified on alloc too...\n",
644	pReq->enmType, RTREQTYPE_INVALID + 1, RTREQTYPE_MAX - 1));
645	return VERR_RT_REQUEST_INVALID_TYPE;
646	}
647
648	int rc = VINF_SUCCESS;
649	/*
650	* Insert it.
651	*/
652	pReq->enmState = RTREQSTATE_QUEUED;
653	PRTREQ pNext;
654	do
655	{
656	pNext = pReq->pQueue->pReqs;
657	pReq->pNext = pNext;
658	} while (!ASMAtomicCmpXchgPtr((void * volatile )&pReq->pQueue->pReqs, (void )pReq, (void *)pNext));
659
660	/*
661	* Notify queue thread.
662	*/
663	RTSemEventSignal(pReq->pQueue->EventSem);
664
665	/*
666	* Wait and return.
667	*/
668	if (!(pReq->fFlags & RTREQFLAGS_NO_WAIT))
669	rc = RTReqWait(pReq, cMillies);
670	LogFlow(("RTReqQueue: returns %Vrc\n", rc));
671	return rc;
672	}
673
674
675	/**
676	* Wait for a request to be completed.
677	*
678	* @returns iprt status code.
679	* Will not return VERR_INTERRUPTED.
680	* @returns VERR_TIMEOUT if cMillies was reached without the packet being completed.
681	*
682	* @param pReq The request to wait for.
683	* @param cMillies Number of milliseconds to wait.
684	* Use RT_INDEFINITE_WAIT to only wait till it's completed.
685	*/
686	RTDECL(int) RTReqWait(PRTREQ pReq, unsigned cMillies)
687	{
688	LogFlow(("RTReqWait: pReq=%p cMillies=%d\n", pReq, cMillies));
689
690	/*
691	* Verify the supplied package.
692	*/
693	if ( pReq->enmState != RTREQSTATE_QUEUED
694	&& pReq->enmState != RTREQSTATE_PROCESSING
695	&& pReq->enmState != RTREQSTATE_COMPLETED)
696	{
697	AssertMsgFailed(("Invalid state %d\n", pReq->enmState));
698	return VERR_RT_REQUEST_STATE;
699	}
700	if ( !pReq->pQueue
701	\|\| !pReq->EventSem)
702	{
703	AssertMsgFailed(("Invalid request package! Anyone cooking their own packages???\n"));
704	return VERR_RT_REQUEST_INVALID_PACKAGE;
705	}
706	if ( pReq->enmType < RTREQTYPE_INVALID
707	\|\| pReq->enmType > RTREQTYPE_MAX)
708	{
709	AssertMsgFailed(("Invalid package type %d valid range %d-%d inclusivly. This was verified on alloc and queue too...\n",
710	pReq->enmType, RTREQTYPE_INVALID + 1, RTREQTYPE_MAX - 1));
711	return VERR_RT_REQUEST_INVALID_TYPE;
712	}
713
714	/*
715	* Wait on the package.
716	*/
717	int rc;
718	if (cMillies != RT_INDEFINITE_WAIT)
719	rc = RTSemEventWait(pReq->EventSem, cMillies);
720	else
721	{
722	do
723	{
724	rc = RTSemEventWait(pReq->EventSem, RT_INDEFINITE_WAIT);
725	Assert(rc != VERR_TIMEOUT);
726	} while (pReq->enmState != RTREQSTATE_COMPLETED);
727	}
728	if (rc == VINF_SUCCESS)
729	ASMAtomicXchgSize(&pReq->fEventSemClear, true);
730	if (pReq->enmState == RTREQSTATE_COMPLETED)
731	rc = VINF_SUCCESS;
732	LogFlow(("RTReqWait: returns %Vrc\n", rc));
733	Assert(rc != VERR_INTERRUPTED);
734	return rc;
735	}
736
737
738	/**
739	* Process one request.
740	*
741	* @returns IPRT status code.
742	*
743	* @param pReq Request packet to process.
744	*/
745	static int rtReqProcessOne(PRTREQ pReq)
746	{
747	LogFlow(("rtReqProcessOne: pReq=%p type=%d fFlags=%#x\n", pReq, pReq->enmType, pReq->fFlags));
748
749	/*
750	* Process the request.
751	*/
752	Assert(pReq->enmState == RTREQSTATE_QUEUED);
753	pReq->enmState = RTREQSTATE_PROCESSING;
754	int rcRet = VINF_SUCCESS; /* the return code of this function. */
755	int rcReq = VERR_NOT_IMPLEMENTED; /* the request status. */
756	switch (pReq->enmType)
757	{
758	/*
759	* A packed down call frame.
760	*/
761	case RTREQTYPE_INTERNAL:
762	{
763	uintptr_t *pauArgs = &pReq->u.Internal.aArgs[0];
764	union
765	{
766	PFNRT pfn;
767	DECLCALLBACKMEMBER(int, pfn00)(void);
768	DECLCALLBACKMEMBER(int, pfn01)(uintptr_t);
769	DECLCALLBACKMEMBER(int, pfn02)(uintptr_t, uintptr_t);
770	DECLCALLBACKMEMBER(int, pfn03)(uintptr_t, uintptr_t, uintptr_t);
771	DECLCALLBACKMEMBER(int, pfn04)(uintptr_t, uintptr_t, uintptr_t, uintptr_t);
772	DECLCALLBACKMEMBER(int, pfn05)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
773	DECLCALLBACKMEMBER(int, pfn06)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
774	DECLCALLBACKMEMBER(int, pfn07)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
775	DECLCALLBACKMEMBER(int, pfn08)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
776	DECLCALLBACKMEMBER(int, pfn09)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
777	DECLCALLBACKMEMBER(int, pfn10)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
778	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);
779	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);
780	} u;
781	u.pfn = pReq->u.Internal.pfn;
782	#ifdef __AMD64__
783	switch (pReq->u.Internal.cArgs)
784	{
785	case 0: rcRet = u.pfn00(); break;
786	case 1: rcRet = u.pfn01(pauArgs[0]); break;
787	case 2: rcRet = u.pfn02(pauArgs[0], pauArgs[1]); break;
788	case 3: rcRet = u.pfn03(pauArgs[0], pauArgs[1], pauArgs[2]); break;
789	case 4: rcRet = u.pfn04(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3]); break;
790	case 5: rcRet = u.pfn05(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4]); break;
791	case 6: rcRet = u.pfn06(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5]); break;
792	case 7: rcRet = u.pfn07(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6]); break;
793	case 8: rcRet = u.pfn08(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7]); break;
794	case 9: rcRet = u.pfn09(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8]); break;
795	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;
796	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;
797	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;
798	default:
799	AssertReleaseMsgFailed(("cArgs=%d\n", pReq->u.Internal.cArgs));
800	rcRet = rcReq = VERR_INTERNAL_ERROR;
801	break;
802	}
803	#else /* x86: */
804	size_t cbArgs = pReq->u.Internal.cArgs * sizeof(uintptr_t);
805	# ifdef __GNUC__
806	__asm__ __volatile__("movl %%esp, %%edx\n\t"
807	"subl %2, %%esp\n\t"
808	"andl $0xfffffff0, %%esp\n\t"
809	"shrl $2, %2\n\t"
810	"movl %%esp, %%edi\n\t"
811	"rep movsl\n\t"
812	"movl %%edx, %%edi\n\t"
813	"call *%%eax\n\t"
814	"mov %%edi, %%esp\n\t"
815	: "=a" (rcRet),
816	"=S" (pauArgs),
817	"=c" (cbArgs)
818	: "0" (u.pfn),
819	"1" (pauArgs),
820	"2" (cbArgs)
821	: "edi", "edx");
822	# else
823	__asm
824	{
825	xor edx, edx /* just mess it up. */
826	mov eax, u.pfn
827	mov ecx, cbArgs
828	shr ecx, 2
829	mov esi, pauArgs
830	mov ebx, esp
831	sub esp, cbArgs
832	and esp, 0xfffffff0
833	mov edi, esp
834	rep movsd
835	call eax
836	mov esp, ebx
837	mov rcRet, eax
838	}
839	# endif
840	#endif /* x86 */
841	if ((pReq->fFlags & (RTREQFLAGS_RETURN_MASK)) == RTREQFLAGS_VOID)
842	rcRet = VINF_SUCCESS;
843	rcReq = rcRet;
844	break;
845	}
846
847	default:
848	AssertMsgFailed(("pReq->enmType=%d\n", pReq->enmType));
849	rcReq = VERR_NOT_IMPLEMENTED;
850	break;
851	}
852
853	/*
854	* Complete the request.
855	*/
856	pReq->iStatus = rcReq;
857	pReq->enmState = RTREQSTATE_COMPLETED;
858	if (pReq->fFlags & RTREQFLAGS_NO_WAIT)
859	{
860	/* Free the packet, nobody is waiting. */
861	LogFlow(("rtReqProcessOne: Completed request %p: rcReq=%Vrc rcRet=%Vrc - freeing it\n",
862	pReq, rcReq, rcRet));
863	RTReqFree(pReq);
864	}
865	else
866	{
867	/* Notify the waiter and him free up the packet. */
868	LogFlow(("rtReqProcessOne: Completed request %p: rcReq=%Vrc rcRet=%Vrc - notifying waiting thread\n",
869	pReq, rcReq, rcRet));
870	ASMAtomicXchgSize(&pReq->fEventSemClear, false);
871	int rc2 = RTSemEventSignal(pReq->EventSem);
872	if (rc2 != VINF_SUCCESS)
873	{
874	AssertRC(rc2);
875	rcRet = rc2;
876	}
877	}
878	return rcRet;
879	}
880
881
882
883

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

source: vbox/trunk/src/VBox/Runtime/req.cpp@ 3460

Download in other formats: