PDMQueue.cpp@ 72064

Last change on this file since 72064 was 69111, checked in by vboxsync, 7 years ago
(C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 29.0 KB

Line
1	/* $Id: PDMQueue.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2	/** @file
3	* PDM Queue - Transport data and tasks to EMT and R3.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
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
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PDM_QUEUE
23	#include "PDMInternal.h"
24	#include <VBox/vmm/pdm.h>
25	#include <VBox/vmm/mm.h>
26	#ifdef VBOX_WITH_REM
27	# include <VBox/vmm/rem.h>
28	#endif
29	#include <VBox/vmm/vm.h>
30	#include <VBox/vmm/uvm.h>
31	#include <VBox/err.h>
32
33	#include <VBox/log.h>
34	#include <iprt/asm.h>
35	#include <iprt/assert.h>
36	#include <iprt/thread.h>
37
38
39	/*********************************************************************************************************************************
40	* Internal Functions *
41	*********************************************************************************************************************************/
42	DECLINLINE(void) pdmR3QueueFreeItem(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem);
43	static bool pdmR3QueueFlush(PPDMQUEUE pQueue);
44	static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
45
46
47
48	/**
49	* Internal worker for the queue creation apis.
50	*
51	* @returns VBox status code.
52	* @param pVM The cross context VM structure.
53	* @param cbItem Item size.
54	* @param cItems Number of items.
55	* @param cMilliesInterval Number of milliseconds between polling the queue.
56	* If 0 then the emulation thread will be notified whenever an item arrives.
57	* @param fRZEnabled Set if the queue will be used from RC/R0 and need to be allocated from the hyper heap.
58	* @param pszName The queue name. Unique. Not copied.
59	* @param ppQueue Where to store the queue handle.
60	*/
61	static int pdmR3QueueCreate(PVM pVM, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval, bool fRZEnabled,
62	const char pszName, PPDMQUEUE ppQueue)
63	{
64	PUVM pUVM = pVM->pUVM;
65
66	/*
67	* Validate input.
68	*/
69	AssertMsgReturn(cbItem >= sizeof(PDMQUEUEITEMCORE) && cbItem < _1M, ("cbItem=%zu\n", cbItem), VERR_OUT_OF_RANGE);
70	AssertMsgReturn(cItems >= 1 && cItems <= _64K, ("cItems=%u\n", cItems), VERR_OUT_OF_RANGE);
71
72	/*
73	* Align the item size and calculate the structure size.
74	*/
75	cbItem = RT_ALIGN(cbItem, sizeof(RTUINTPTR));
76	size_t cb = cbItem * cItems + RT_ALIGN_Z(RT_OFFSETOF(PDMQUEUE, aFreeItems[cItems + PDMQUEUE_FREE_SLACK]), 16);
77	PPDMQUEUE pQueue;
78	int rc;
79	if (fRZEnabled)
80	rc = MMHyperAlloc(pVM, cb, 0, MM_TAG_PDM_QUEUE, (void **)&pQueue );
81	else
82	rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_QUEUE, cb, (void **)&pQueue);
83	if (RT_FAILURE(rc))
84	return rc;
85
86	/*
87	* Initialize the data fields.
88	*/
89	pQueue->pVMR3 = pVM;
90	pQueue->pVMR0 = fRZEnabled ? pVM->pVMR0 : NIL_RTR0PTR;
91	pQueue->pVMRC = fRZEnabled ? pVM->pVMRC : NIL_RTRCPTR;
92	pQueue->pszName = pszName;
93	pQueue->cMilliesInterval = cMilliesInterval;
94	//pQueue->pTimer = NULL;
95	pQueue->cbItem = (uint32_t)cbItem;
96	pQueue->cItems = cItems;
97	//pQueue->pPendingR3 = NULL;
98	//pQueue->pPendingR0 = NULL;
99	//pQueue->pPendingRC = NULL;
100	pQueue->iFreeHead = cItems;
101	//pQueue->iFreeTail = 0;
102	PPDMQUEUEITEMCORE pItem = (PPDMQUEUEITEMCORE)((char *)pQueue + RT_ALIGN_Z(RT_OFFSETOF(PDMQUEUE, aFreeItems[cItems + PDMQUEUE_FREE_SLACK]), 16));
103	for (unsigned i = 0; i < cItems; i++, pItem = (PPDMQUEUEITEMCORE)((char *)pItem + cbItem))
104	{
105	pQueue->aFreeItems[i].pItemR3 = pItem;
106	if (fRZEnabled)
107	{
108	pQueue->aFreeItems[i].pItemR0 = MMHyperR3ToR0(pVM, pItem);
109	pQueue->aFreeItems[i].pItemRC = MMHyperR3ToRC(pVM, pItem);
110	}
111	}
112
113	/*
114	* Create timer?
115	*/
116	if (cMilliesInterval)
117	{
118	rc = TMR3TimerCreateInternal(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, "Queue timer", &pQueue->pTimer);
119	if (RT_SUCCESS(rc))
120	{
121	rc = TMTimerSetMillies(pQueue->pTimer, cMilliesInterval);
122	if (RT_FAILURE(rc))
123	{
124	AssertMsgFailed(("TMTimerSetMillies failed rc=%Rrc\n", rc));
125	int rc2 = TMR3TimerDestroy(pQueue->pTimer); AssertRC(rc2);
126	}
127	}
128	else
129	AssertMsgFailed(("TMR3TimerCreateInternal failed rc=%Rrc\n", rc));
130	if (RT_FAILURE(rc))
131	{
132	if (fRZEnabled)
133	MMHyperFree(pVM, pQueue);
134	else
135	MMR3HeapFree(pQueue);
136	return rc;
137	}
138
139	/*
140	* Insert into the queue list for timer driven queues.
141	*/
142	pdmLock(pVM);
143	pQueue->pNext = pUVM->pdm.s.pQueuesTimer;
144	pUVM->pdm.s.pQueuesTimer = pQueue;
145	pdmUnlock(pVM);
146	}
147	else
148	{
149	/*
150	* Insert into the queue list for forced action driven queues.
151	* This is a FIFO, so insert at the end.
152	*/
153	/** @todo we should add a priority to the queues so we don't have to rely on
154	* the initialization order to deal with problems like @bugref{1605} (pgm/pcnet
155	* deadlock caused by the critsect queue to be last in the chain).
156	* - Update, the critical sections are no longer using queues, so this isn't a real
157	* problem any longer. The priority might be a nice feature for later though.
158	*/
159	pdmLock(pVM);
160	if (!pUVM->pdm.s.pQueuesForced)
161	pUVM->pdm.s.pQueuesForced = pQueue;
162	else
163	{
164	PPDMQUEUE pPrev = pUVM->pdm.s.pQueuesForced;
165	while (pPrev->pNext)
166	pPrev = pPrev->pNext;
167	pPrev->pNext = pQueue;
168	}
169	pdmUnlock(pVM);
170	}
171
172	/*
173	* Register the statistics.
174	*/
175	STAMR3RegisterF(pVM, &pQueue->cbItem, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Item size.", "/PDM/Queue/%s/cbItem", pQueue->pszName);
176	STAMR3RegisterF(pVM, &pQueue->cItems, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Queue size.", "/PDM/Queue/%s/cItems", pQueue->pszName);
177	STAMR3RegisterF(pVM, &pQueue->StatAllocFailures, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "PDMQueueAlloc failures.", "/PDM/Queue/%s/AllocFailures", pQueue->pszName);
178	STAMR3RegisterF(pVM, &pQueue->StatInsert, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "Calls to PDMQueueInsert.", "/PDM/Queue/%s/Insert", pQueue->pszName);
179	STAMR3RegisterF(pVM, &pQueue->StatFlush, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "Calls to pdmR3QueueFlush.", "/PDM/Queue/%s/Flush", pQueue->pszName);
180	STAMR3RegisterF(pVM, &pQueue->StatFlushLeftovers, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Left over items after flush.", "/PDM/Queue/%s/FlushLeftovers", pQueue->pszName);
181	#ifdef VBOX_WITH_STATISTICS
182	STAMR3RegisterF(pVM, &pQueue->StatFlushPrf, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "Profiling pdmR3QueueFlush.", "/PDM/Queue/%s/FlushPrf", pQueue->pszName);
183	STAMR3RegisterF(pVM, (void *)&pQueue->cStatPending, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Pending items.", "/PDM/Queue/%s/Pending", pQueue->pszName);
184	#endif
185
186	*ppQueue = pQueue;
187	return VINF_SUCCESS;
188	}
189
190
191	/**
192	* Create a queue with a device owner.
193	*
194	* @returns VBox status code.
195	* @param pVM The cross context VM structure.
196	* @param pDevIns Device instance.
197	* @param cbItem Size a queue item.
198	* @param cItems Number of items in the queue.
199	* @param cMilliesInterval Number of milliseconds between polling the queue.
200	* If 0 then the emulation thread will be notified whenever an item arrives.
201	* @param pfnCallback The consumer function.
202	* @param fRZEnabled Set if the queue must be usable from RC/R0.
203	* @param pszName The queue name. Unique. Not copied.
204	* @param ppQueue Where to store the queue handle on success.
205	* @thread Emulation thread only.
206	*/
207	VMMR3_INT_DECL(int) PDMR3QueueCreateDevice(PVM pVM, PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
208	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char pszName, PPDMQUEUE ppQueue)
209	{
210	LogFlow(("PDMR3QueueCreateDevice: pDevIns=%p cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p fRZEnabled=%RTbool pszName=%s\n",
211	pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName));
212
213	/*
214	* Validate input.
215	*/
216	VMCPU_ASSERT_EMT(&pVM->aCpus[0]);
217	if (!pfnCallback)
218	{
219	AssertMsgFailed(("No consumer callback!\n"));
220	return VERR_INVALID_PARAMETER;
221	}
222
223	/*
224	* Create the queue.
225	*/
226	PPDMQUEUE pQueue;
227	int rc = pdmR3QueueCreate(pVM, cbItem, cItems, cMilliesInterval, fRZEnabled, pszName, &pQueue);
228	if (RT_SUCCESS(rc))
229	{
230	pQueue->enmType = PDMQUEUETYPE_DEV;
231	pQueue->u.Dev.pDevIns = pDevIns;
232	pQueue->u.Dev.pfnCallback = pfnCallback;
233
234	*ppQueue = pQueue;
235	Log(("PDM: Created device queue %p; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p pDevIns=%p\n",
236	pQueue, cbItem, cItems, cMilliesInterval, pfnCallback, pDevIns));
237	}
238	return rc;
239	}
240
241
242	/**
243	* Create a queue with a driver owner.
244	*
245	* @returns VBox status code.
246	* @param pVM The cross context VM structure.
247	* @param pDrvIns Driver instance.
248	* @param cbItem Size a queue item.
249	* @param cItems Number of items in the queue.
250	* @param cMilliesInterval Number of milliseconds between polling the queue.
251	* If 0 then the emulation thread will be notified whenever an item arrives.
252	* @param pfnCallback The consumer function.
253	* @param pszName The queue name. Unique. Not copied.
254	* @param ppQueue Where to store the queue handle on success.
255	* @thread Emulation thread only.
256	*/
257	VMMR3_INT_DECL(int) PDMR3QueueCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
258	PFNPDMQUEUEDRV pfnCallback, const char pszName, PPDMQUEUE ppQueue)
259	{
260	LogFlow(("PDMR3QueueCreateDriver: pDrvIns=%p cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%s\n",
261	pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName));
262
263	/*
264	* Validate input.
265	*/
266	VMCPU_ASSERT_EMT(&pVM->aCpus[0]);
267	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
268
269	/*
270	* Create the queue.
271	*/
272	PPDMQUEUE pQueue;
273	int rc = pdmR3QueueCreate(pVM, cbItem, cItems, cMilliesInterval, false, pszName, &pQueue);
274	if (RT_SUCCESS(rc))
275	{
276	pQueue->enmType = PDMQUEUETYPE_DRV;
277	pQueue->u.Drv.pDrvIns = pDrvIns;
278	pQueue->u.Drv.pfnCallback = pfnCallback;
279
280	*ppQueue = pQueue;
281	Log(("PDM: Created driver queue %p; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p pDrvIns=%p\n",
282	pQueue, cbItem, cItems, cMilliesInterval, pfnCallback, pDrvIns));
283	}
284	return rc;
285	}
286
287
288	/**
289	* Create a queue with an internal owner.
290	*
291	* @returns VBox status code.
292	* @param pVM The cross context VM structure.
293	* @param cbItem Size a queue item.
294	* @param cItems Number of items in the queue.
295	* @param cMilliesInterval Number of milliseconds between polling the queue.
296	* If 0 then the emulation thread will be notified whenever an item arrives.
297	* @param pfnCallback The consumer function.
298	* @param fRZEnabled Set if the queue must be usable from RC/R0.
299	* @param pszName The queue name. Unique. Not copied.
300	* @param ppQueue Where to store the queue handle on success.
301	* @thread Emulation thread only.
302	*/
303	VMMR3_INT_DECL(int) PDMR3QueueCreateInternal(PVM pVM, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
304	PFNPDMQUEUEINT pfnCallback, bool fRZEnabled, const char pszName, PPDMQUEUE ppQueue)
305	{
306	LogFlow(("PDMR3QueueCreateInternal: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p fRZEnabled=%RTbool pszName=%s\n",
307	cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName));
308
309	/*
310	* Validate input.
311	*/
312	VMCPU_ASSERT_EMT(&pVM->aCpus[0]);
313	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
314
315	/*
316	* Create the queue.
317	*/
318	PPDMQUEUE pQueue;
319	int rc = pdmR3QueueCreate(pVM, cbItem, cItems, cMilliesInterval, fRZEnabled, pszName, &pQueue);
320	if (RT_SUCCESS(rc))
321	{
322	pQueue->enmType = PDMQUEUETYPE_INTERNAL;
323	pQueue->u.Int.pfnCallback = pfnCallback;
324
325	*ppQueue = pQueue;
326	Log(("PDM: Created internal queue %p; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p\n",
327	pQueue, cbItem, cItems, cMilliesInterval, pfnCallback));
328	}
329	return rc;
330	}
331
332
333	/**
334	* Create a queue with an external owner.
335	*
336	* @returns VBox status code.
337	* @param pVM The cross context VM structure.
338	* @param cbItem Size a queue item.
339	* @param cItems Number of items in the queue.
340	* @param cMilliesInterval Number of milliseconds between polling the queue.
341	* If 0 then the emulation thread will be notified whenever an item arrives.
342	* @param pfnCallback The consumer function.
343	* @param pvUser The user argument to the consumer function.
344	* @param pszName The queue name. Unique. Not copied.
345	* @param ppQueue Where to store the queue handle on success.
346	* @thread Emulation thread only.
347	*/
348	VMMR3_INT_DECL(int) PDMR3QueueCreateExternal(PVM pVM, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
349	PFNPDMQUEUEEXT pfnCallback, void pvUser, const char pszName, PPDMQUEUE *ppQueue)
350	{
351	LogFlow(("PDMR3QueueCreateExternal: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%s\n", cbItem, cItems, cMilliesInterval, pfnCallback, pszName));
352
353	/*
354	* Validate input.
355	*/
356	VMCPU_ASSERT_EMT(&pVM->aCpus[0]);
357	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
358
359	/*
360	* Create the queue.
361	*/
362	PPDMQUEUE pQueue;
363	int rc = pdmR3QueueCreate(pVM, cbItem, cItems, cMilliesInterval, false, pszName, &pQueue);
364	if (RT_SUCCESS(rc))
365	{
366	pQueue->enmType = PDMQUEUETYPE_EXTERNAL;
367	pQueue->u.Ext.pvUser = pvUser;
368	pQueue->u.Ext.pfnCallback = pfnCallback;
369
370	*ppQueue = pQueue;
371	Log(("PDM: Created external queue %p; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p pvUser=%p\n",
372	pQueue, cbItem, cItems, cMilliesInterval, pfnCallback, pvUser));
373	}
374	return rc;
375	}
376
377
378	/**
379	* Destroy a queue.
380	*
381	* @returns VBox status code.
382	* @param pQueue Queue to destroy.
383	* @thread Emulation thread only.
384	*/
385	VMMR3_INT_DECL(int) PDMR3QueueDestroy(PPDMQUEUE pQueue)
386	{
387	LogFlow(("PDMR3QueueDestroy: pQueue=%p\n", pQueue));
388
389	/*
390	* Validate input.
391	*/
392	if (!pQueue)
393	return VERR_INVALID_PARAMETER;
394	Assert(pQueue && pQueue->pVMR3);
395	PVM pVM = pQueue->pVMR3;
396	PUVM pUVM = pVM->pUVM;
397
398	pdmLock(pVM);
399
400	/*
401	* Unlink it.
402	*/
403	if (pQueue->pTimer)
404	{
405	if (pUVM->pdm.s.pQueuesTimer != pQueue)
406	{
407	PPDMQUEUE pCur = pUVM->pdm.s.pQueuesTimer;
408	while (pCur)
409	{
410	if (pCur->pNext == pQueue)
411	{
412	pCur->pNext = pQueue->pNext;
413	break;
414	}
415	pCur = pCur->pNext;
416	}
417	AssertMsg(pCur, ("Didn't find the queue!\n"));
418	}
419	else
420	pUVM->pdm.s.pQueuesTimer = pQueue->pNext;
421	}
422	else
423	{
424	if (pUVM->pdm.s.pQueuesForced != pQueue)
425	{
426	PPDMQUEUE pCur = pUVM->pdm.s.pQueuesForced;
427	while (pCur)
428	{
429	if (pCur->pNext == pQueue)
430	{
431	pCur->pNext = pQueue->pNext;
432	break;
433	}
434	pCur = pCur->pNext;
435	}
436	AssertMsg(pCur, ("Didn't find the queue!\n"));
437	}
438	else
439	pUVM->pdm.s.pQueuesForced = pQueue->pNext;
440	}
441	pQueue->pNext = NULL;
442	pQueue->pVMR3 = NULL;
443	pdmUnlock(pVM);
444
445	/*
446	* Deregister statistics.
447	*/
448	STAMR3DeregisterF(pVM->pUVM, "/PDM/Queue/%s/cbItem", pQueue->pszName);
449
450	/*
451	* Destroy the timer and free it.
452	*/
453	if (pQueue->pTimer)
454	{
455	TMR3TimerDestroy(pQueue->pTimer);
456	pQueue->pTimer = NULL;
457	}
458	if (pQueue->pVMRC)
459	{
460	pQueue->pVMRC = NIL_RTRCPTR;
461	pQueue->pVMR0 = NIL_RTR0PTR;
462	MMHyperFree(pVM, pQueue);
463	}
464	else
465	MMR3HeapFree(pQueue);
466
467	return VINF_SUCCESS;
468	}
469
470
471	/**
472	* Destroy a all queues owned by the specified device.
473	*
474	* @returns VBox status code.
475	* @param pVM The cross context VM structure.
476	* @param pDevIns Device instance.
477	* @thread Emulation thread only.
478	*/
479	VMMR3_INT_DECL(int) PDMR3QueueDestroyDevice(PVM pVM, PPDMDEVINS pDevIns)
480	{
481	LogFlow(("PDMR3QueueDestroyDevice: pDevIns=%p\n", pDevIns));
482
483	/*
484	* Validate input.
485	*/
486	if (!pDevIns)
487	return VERR_INVALID_PARAMETER;
488
489	PUVM pUVM = pVM->pUVM;
490	pdmLock(pVM);
491
492	/*
493	* Unlink it.
494	*/
495	PPDMQUEUE pQueueNext = pUVM->pdm.s.pQueuesTimer;
496	PPDMQUEUE pQueue = pUVM->pdm.s.pQueuesForced;
497	do
498	{
499	while (pQueue)
500	{
501	if ( pQueue->enmType == PDMQUEUETYPE_DEV
502	&& pQueue->u.Dev.pDevIns == pDevIns)
503	{
504	PPDMQUEUE pQueueDestroy = pQueue;
505	pQueue = pQueue->pNext;
506	int rc = PDMR3QueueDestroy(pQueueDestroy);
507	AssertRC(rc);
508	}
509	else
510	pQueue = pQueue->pNext;
511	}
512
513	/* next queue list */
514	pQueue = pQueueNext;
515	pQueueNext = NULL;
516	} while (pQueue);
517
518	pdmUnlock(pVM);
519	return VINF_SUCCESS;
520	}
521
522
523	/**
524	* Destroy a all queues owned by the specified driver.
525	*
526	* @returns VBox status code.
527	* @param pVM The cross context VM structure.
528	* @param pDrvIns Driver instance.
529	* @thread Emulation thread only.
530	*/
531	VMMR3_INT_DECL(int) PDMR3QueueDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns)
532	{
533	LogFlow(("PDMR3QueueDestroyDriver: pDrvIns=%p\n", pDrvIns));
534
535	/*
536	* Validate input.
537	*/
538	if (!pDrvIns)
539	return VERR_INVALID_PARAMETER;
540
541	PUVM pUVM = pVM->pUVM;
542	pdmLock(pVM);
543
544	/*
545	* Unlink it.
546	*/
547	PPDMQUEUE pQueueNext = pUVM->pdm.s.pQueuesTimer;
548	PPDMQUEUE pQueue = pUVM->pdm.s.pQueuesForced;
549	do
550	{
551	while (pQueue)
552	{
553	if ( pQueue->enmType == PDMQUEUETYPE_DRV
554	&& pQueue->u.Drv.pDrvIns == pDrvIns)
555	{
556	PPDMQUEUE pQueueDestroy = pQueue;
557	pQueue = pQueue->pNext;
558	int rc = PDMR3QueueDestroy(pQueueDestroy);
559	AssertRC(rc);
560	}
561	else
562	pQueue = pQueue->pNext;
563	}
564
565	/* next queue list */
566	pQueue = pQueueNext;
567	pQueueNext = NULL;
568	} while (pQueue);
569
570	pdmUnlock(pVM);
571	return VINF_SUCCESS;
572	}
573
574
575	/**
576	* Relocate the queues.
577	*
578	* @param pVM The cross context VM structure.
579	* @param offDelta The relocation delta.
580	*/
581	void pdmR3QueueRelocate(PVM pVM, RTGCINTPTR offDelta)
582	{
583	/*
584	* Process the queues.
585	*/
586	PUVM pUVM = pVM->pUVM;
587	PPDMQUEUE pQueueNext = pUVM->pdm.s.pQueuesTimer;
588	PPDMQUEUE pQueue = pUVM->pdm.s.pQueuesForced;
589	do
590	{
591	while (pQueue)
592	{
593	if (pQueue->pVMRC)
594	{
595	pQueue->pVMRC = pVM->pVMRC;
596
597	/* Pending RC items. */
598	if (pQueue->pPendingRC)
599	{
600	pQueue->pPendingRC += offDelta;
601	PPDMQUEUEITEMCORE pCur = (PPDMQUEUEITEMCORE)MMHyperRCToR3(pVM, pQueue->pPendingRC);
602	while (pCur->pNextRC)
603	{
604	pCur->pNextRC += offDelta;
605	pCur = (PPDMQUEUEITEMCORE)MMHyperRCToR3(pVM, pCur->pNextRC);
606	}
607	}
608
609	/* The free items. */
610	uint32_t i = pQueue->iFreeTail;
611	while (i != pQueue->iFreeHead)
612	{
613	pQueue->aFreeItems[i].pItemRC = MMHyperR3ToRC(pVM, pQueue->aFreeItems[i].pItemR3);
614	i = (i + 1) % (pQueue->cItems + PDMQUEUE_FREE_SLACK);
615	}
616	}
617
618	/* next queue */
619	pQueue = pQueue->pNext;
620	}
621
622	/* next queue list */
623	pQueue = pQueueNext;
624	pQueueNext = NULL;
625	} while (pQueue);
626	}
627
628
629	/**
630	* Flush pending queues.
631	* This is a forced action callback.
632	*
633	* @param pVM The cross context VM structure.
634	* @thread Emulation thread only.
635	*/
636	VMMR3_INT_DECL(void) PDMR3QueueFlushAll(PVM pVM)
637	{
638	VM_ASSERT_EMT(pVM);
639	LogFlow(("PDMR3QueuesFlush:\n"));
640
641	/*
642	* Only let one EMT flushing queues at any one time to preserve the order
643	* and to avoid wasting time. The FF is always cleared here, because it's
644	* only used to get someones attention. Queue inserts occurring during the
645	* flush are caught using the pending bit.
646	*
647	* Note! We must check the force action and pending flags after clearing
648	* the active bit!
649	*/
650	VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
651	while (!ASMAtomicBitTestAndSet(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT))
652	{
653	ASMAtomicBitClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT);
654
655	for (PPDMQUEUE pCur = pVM->pUVM->pdm.s.pQueuesForced; pCur; pCur = pCur->pNext)
656	if ( pCur->pPendingR3
657	\|\| pCur->pPendingR0
658	\|\| pCur->pPendingRC)
659	pdmR3QueueFlush(pCur);
660
661	ASMAtomicBitClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT);
662
663	/* We're done if there were no inserts while we were busy. */
664	if ( !ASMBitTest(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT)
665	&& !VM_FF_IS_PENDING(pVM, VM_FF_PDM_QUEUES))
666	break;
667	VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
668	}
669	}
670
671
672	/**
673	* Process pending items in one queue.
674	*
675	* @returns Success indicator.
676	* If false the item the consumer said "enough!".
677	* @param pQueue The queue.
678	*/
679	static bool pdmR3QueueFlush(PPDMQUEUE pQueue)
680	{
681	STAM_PROFILE_START(&pQueue->StatFlushPrf,p);
682
683	/*
684	* Get the lists.
685	*/
686	PPDMQUEUEITEMCORE pItems = ASMAtomicXchgPtrT(&pQueue->pPendingR3, NULL, PPDMQUEUEITEMCORE);
687	RTRCPTR pItemsRC = ASMAtomicXchgRCPtr(&pQueue->pPendingRC, NIL_RTRCPTR);
688	RTR0PTR pItemsR0 = ASMAtomicXchgR0Ptr(&pQueue->pPendingR0, NIL_RTR0PTR);
689
690	AssertMsgReturn( pItemsR0
691	\|\| pItemsRC
692	\|\| pItems,
693	("Someone is racing us? This shouldn't happen!\n"),
694	true);
695
696	/*
697	* Reverse the list (it's inserted in LIFO order to avoid semaphores, remember).
698	*/
699	PPDMQUEUEITEMCORE pCur = pItems;
700	pItems = NULL;
701	while (pCur)
702	{
703	PPDMQUEUEITEMCORE pInsert = pCur;
704	pCur = pCur->pNextR3;
705	pInsert->pNextR3 = pItems;
706	pItems = pInsert;
707	}
708
709	/*
710	* Do the same for any pending RC items.
711	*/
712	while (pItemsRC)
713	{
714	PPDMQUEUEITEMCORE pInsert = (PPDMQUEUEITEMCORE)MMHyperRCToR3(pQueue->pVMR3, pItemsRC);
715	pItemsRC = pInsert->pNextRC;
716	pInsert->pNextRC = NIL_RTRCPTR;
717	pInsert->pNextR3 = pItems;
718	pItems = pInsert;
719	}
720
721	/*
722	* Do the same for any pending R0 items.
723	*/
724	while (pItemsR0)
725	{
726	PPDMQUEUEITEMCORE pInsert = (PPDMQUEUEITEMCORE)MMHyperR0ToR3(pQueue->pVMR3, pItemsR0);
727	pItemsR0 = pInsert->pNextR0;
728	pInsert->pNextR0 = NIL_RTR0PTR;
729	pInsert->pNextR3 = pItems;
730	pItems = pInsert;
731	}
732
733	/*
734	* Feed the items to the consumer function.
735	*/
736	Log2(("pdmR3QueueFlush: pQueue=%p enmType=%d pItems=%p\n", pQueue, pQueue->enmType, pItems));
737	switch (pQueue->enmType)
738	{
739	case PDMQUEUETYPE_DEV:
740	while (pItems)
741	{
742	if (!pQueue->u.Dev.pfnCallback(pQueue->u.Dev.pDevIns, pItems))
743	break;
744	pCur = pItems;
745	pItems = pItems->pNextR3;
746	pdmR3QueueFreeItem(pQueue, pCur);
747	}
748	break;
749
750	case PDMQUEUETYPE_DRV:
751	while (pItems)
752	{
753	if (!pQueue->u.Drv.pfnCallback(pQueue->u.Drv.pDrvIns, pItems))
754	break;
755	pCur = pItems;
756	pItems = pItems->pNextR3;
757	pdmR3QueueFreeItem(pQueue, pCur);
758	}
759	break;
760
761	case PDMQUEUETYPE_INTERNAL:
762	while (pItems)
763	{
764	if (!pQueue->u.Int.pfnCallback(pQueue->pVMR3, pItems))
765	break;
766	pCur = pItems;
767	pItems = pItems->pNextR3;
768	pdmR3QueueFreeItem(pQueue, pCur);
769	}
770	break;
771
772	case PDMQUEUETYPE_EXTERNAL:
773	while (pItems)
774	{
775	if (!pQueue->u.Ext.pfnCallback(pQueue->u.Ext.pvUser, pItems))
776	break;
777	pCur = pItems;
778	pItems = pItems->pNextR3;
779	pdmR3QueueFreeItem(pQueue, pCur);
780	}
781	break;
782
783	default:
784	AssertMsgFailed(("Invalid queue type %d\n", pQueue->enmType));
785	break;
786	}
787
788	/*
789	* Success?
790	*/
791	if (pItems)
792	{
793	/*
794	* Reverse the list.
795	*/
796	pCur = pItems;
797	pItems = NULL;
798	while (pCur)
799	{
800	PPDMQUEUEITEMCORE pInsert = pCur;
801	pCur = pInsert->pNextR3;
802	pInsert->pNextR3 = pItems;
803	pItems = pInsert;
804	}
805
806	/*
807	* Insert the list at the tail of the pending list.
808	*/
809	for (;;)
810	{
811	if (ASMAtomicCmpXchgPtr(&pQueue->pPendingR3, pItems, NULL))
812	break;
813	PPDMQUEUEITEMCORE pPending = ASMAtomicXchgPtrT(&pQueue->pPendingR3, NULL, PPDMQUEUEITEMCORE);
814	if (pPending)
815	{
816	pCur = pPending;
817	while (pCur->pNextR3)
818	pCur = pCur->pNextR3;
819	pCur->pNextR3 = pItems;
820	pItems = pPending;
821	}
822	}
823
824	STAM_REL_COUNTER_INC(&pQueue->StatFlushLeftovers);
825	STAM_PROFILE_STOP(&pQueue->StatFlushPrf,p);
826	return false;
827	}
828
829	STAM_PROFILE_STOP(&pQueue->StatFlushPrf,p);
830	return true;
831	}
832
833
834	/**
835	* Free an item.
836	*
837	* @param pQueue The queue.
838	* @param pItem The item.
839	*/
840	DECLINLINE(void) pdmR3QueueFreeItem(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem)
841	{
842	VM_ASSERT_EMT(pQueue->pVMR3);
843
844	int i = pQueue->iFreeHead;
845	int iNext = (i + 1) % (pQueue->cItems + PDMQUEUE_FREE_SLACK);
846
847	pQueue->aFreeItems[i].pItemR3 = pItem;
848	if (pQueue->pVMRC)
849	{
850	pQueue->aFreeItems[i].pItemRC = MMHyperR3ToRC(pQueue->pVMR3, pItem);
851	pQueue->aFreeItems[i].pItemR0 = MMHyperR3ToR0(pQueue->pVMR3, pItem);
852	}
853
854	if (!ASMAtomicCmpXchgU32(&pQueue->iFreeHead, iNext, i))
855	AssertMsgFailed(("huh? i=%d iNext=%d iFreeHead=%d iFreeTail=%d\n", i, iNext, pQueue->iFreeHead, pQueue->iFreeTail));
856	STAM_STATS({ ASMAtomicDecU32(&pQueue->cStatPending); });
857	}
858
859
860	/**
861	* Timer handler for PDM queues.
862	* This is called by for a single queue.
863	*
864	* @param pVM The cross context VM structure.
865	* @param pTimer Pointer to timer.
866	* @param pvUser Pointer to the queue.
867	*/
868	static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
869	{
870	PPDMQUEUE pQueue = (PPDMQUEUE)pvUser;
871	Assert(pTimer == pQueue->pTimer); NOREF(pTimer); NOREF(pVM);
872
873	if ( pQueue->pPendingR3
874	\|\| pQueue->pPendingR0
875	\|\| pQueue->pPendingRC)
876	pdmR3QueueFlush(pQueue);
877	int rc = TMTimerSetMillies(pQueue->pTimer, pQueue->cMilliesInterval);
878	AssertRC(rc);
879	}
880

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

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMQueue.cpp@ 72064

Download in other formats: