PDMQueue.cpp@ 104933

Last change on this file since 104933 was 99739, checked in by vboxsync, 19 months ago
*: doxygen corrections (mostly about removing @returns from functions returning void).
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 34.0 KB

Line
1	/* $Id: PDMQueue.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
2	/** @file
3	* PDM Queue - Transport data and tasks to EMT and R3.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_PDM_QUEUE
33	#include "PDMInternal.h"
34	#include <VBox/vmm/pdm.h>
35	#include <VBox/vmm/mm.h>
36	#include <VBox/vmm/vm.h>
37	#include <VBox/vmm/uvm.h>
38	#include <iprt/errcore.h>
39
40	#include <VBox/log.h>
41	#include <iprt/asm.h>
42	#include <iprt/assert.h>
43	#include <iprt/mem.h>
44	#include <iprt/thread.h>
45
46
47	/*********************************************************************************************************************************
48	* Internal Functions *
49	*********************************************************************************************************************************/
50	static int pdmR3QueueDestroyLocked(PVM pVM, PDMQUEUEHANDLE hQueue, void *pvOwner);
51	static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
52
53
54
55	/**
56	* Internal worker for the queue creation apis.
57	*
58	* @returns VBox status code.
59	* @param pVM The cross context VM structure.
60	* @param cbItem Item size.
61	* @param cItems Number of items.
62	* @param cMilliesInterval Number of milliseconds between polling the queue.
63	* If 0 then the emulation thread will be notified whenever an item arrives.
64	* @param fRZEnabled Set if the queue will be used from RC/R0,
65	* these can only be created from EMT0.
66	* @param pszName The queue name. Unique. Not copied.
67	* @param enmType Owner type.
68	* @param pvOwner The queue owner pointer.
69	* @param uCallback Callback function.
70	* @param phQueue Where to store the queue handle.
71	*
72	* @thread Emulation thread only. When @a fRZEnables is true only EMT0.
73	* @note Caller owns ListCritSect.
74	*/
75	static int pdmR3QueueCreateLocked(PVM pVM, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval, bool fRZEnabled,
76	const char pszName, PDMQUEUETYPE enmType, void pvOwner, uintptr_t uCallback,
77	PDMQUEUEHANDLE *phQueue)
78	{
79	/*
80	* Validate and adjust the input.
81	*/
82	if (fRZEnabled)
83	VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
84	else
85	VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
86
87	cbItem = RT_ALIGN(cbItem, sizeof(uint64_t));
88	AssertMsgReturn(cbItem >= sizeof(PDMQUEUEITEMCORE) && cbItem < PDMQUEUE_MAX_ITEM_SIZE, ("cbItem=%zu\n", cbItem),
89	VERR_OUT_OF_RANGE);
90	AssertMsgReturn(cItems >= 1 && cItems <= PDMQUEUE_MAX_ITEMS, ("cItems=%u\n", cItems), VERR_OUT_OF_RANGE);
91	AssertMsgReturn((uint64_t)cbItem * cItems <= (fRZEnabled ? PDMQUEUE_MAX_TOTAL_SIZE_R0 : PDMQUEUE_MAX_TOTAL_SIZE_R3),
92	("cItems=%u cbItem=%#x -> %#RX64, max %'u\n", cItems, cbItem, (uint64_t)cbItem * cItems,
93	fRZEnabled ? PDMQUEUE_MAX_TOTAL_SIZE_R0 : PDMQUEUE_MAX_TOTAL_SIZE_R3),
94	VERR_OUT_OF_RANGE);
95	AssertReturn(!fRZEnabled \|\| enmType == PDMQUEUETYPE_INTERNAL \|\| enmType == PDMQUEUETYPE_DEV, VERR_INVALID_PARAMETER);
96	if (SUPR3IsDriverless())
97	fRZEnabled = false;
98
99	/* Unqiue name that fits within the szName field: */
100	size_t cchName = strlen(pszName);
101	AssertReturn(cchName > 0, VERR_INVALID_NAME);
102	AssertMsgReturn(cchName < RT_SIZEOFMEMB(PDMQUEUE, szName), ("'%s' is too long\n", pszName), VERR_INVALID_NAME);
103	size_t i = pVM->pdm.s.cRing3Queues;
104	while (i-- > 0 )
105	AssertMsgReturn(strcmp(pVM->pdm.s.papRing3Queues[i]->szName, pszName) != 0, ("%s\n", pszName), VERR_DUPLICATE);
106	i = pVM->pdm.s.cRing0Queues;
107	while (i-- > 0 )
108	AssertMsgReturn(strcmp(pVM->pdm.s.apRing0Queues[i]->szName, pszName) != 0, ("%s\n", pszName), VERR_DUPLICATE);
109
110	/*
111	* Align the item size and calculate the structure size.
112	*/
113	PPDMQUEUE pQueue;
114	PDMQUEUEHANDLE hQueue;
115	if (fRZEnabled)
116	{
117	/* Call ring-0 to allocate and create the queue: */
118	PDMQUEUECREATEREQ Req;
119	Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
120	Req.Hdr.cbReq = sizeof(Req);
121	Req.cItems = cItems;
122	Req.cbItem = (uint32_t)cbItem;
123	Req.enmType = enmType;
124	Req.pvOwner = pvOwner;
125	Req.pfnCallback = (RTR3PTR)uCallback;
126	RTStrCopy(Req.szName, sizeof(Req.szName), pszName);
127	AssertCompileMembersSameSize(PDMQUEUECREATEREQ, szName, PDMQUEUE, szName);
128	Req.hQueue = NIL_PDMQUEUEHANDLE;
129
130	int rc = VMMR3CallR0(pVM, VMMR0_DO_PDM_QUEUE_CREATE, 0, &Req.Hdr);
131	if (RT_FAILURE(rc))
132	return rc;
133	hQueue = Req.hQueue;
134	AssertReturn(hQueue < RT_ELEMENTS(pVM->pdm.s.apRing0Queues), VERR_INTERNAL_ERROR_2);
135	pQueue = pVM->pdm.s.apRing0Queues[hQueue];
136	AssertPtrReturn(pQueue, VERR_INTERNAL_ERROR_3);
137	AssertReturn(pQueue->u32Magic == PDMQUEUE_MAGIC, VERR_INTERNAL_ERROR_4);
138	AssertReturn(pQueue->cbItem == cbItem, VERR_INTERNAL_ERROR_4);
139	AssertReturn(pQueue->cItems == cItems, VERR_INTERNAL_ERROR_4);
140	AssertReturn(pQueue->enmType == enmType, VERR_INTERNAL_ERROR_4);
141	AssertReturn(pQueue->u.Gen.pvOwner == pvOwner, VERR_INTERNAL_ERROR_4);
142	AssertReturn(pQueue->u.Gen.pfnCallback == (RTR3PTR)uCallback, VERR_INTERNAL_ERROR_4);
143	}
144	else
145	{
146	/* Do it here using the paged heap: */
147	uint32_t const cbBitmap = RT_ALIGN_32(RT_ALIGN_32(cItems, 64) / 8, 64); /* keep bitmap in it's own cacheline */
148	uint32_t const cbQueue = RT_OFFSETOF(PDMQUEUE, bmAlloc)
149	+ cbBitmap
150	+ (uint32_t)cbItem * cItems;
151	pQueue = (PPDMQUEUE)RTMemPageAllocZ(cbQueue);
152	if (!pQueue)
153	return VERR_NO_PAGE_MEMORY;
154	pdmQueueInit(pQueue, cbBitmap, (uint32_t)cbItem, cItems, pszName, enmType, (RTR3PTR)uCallback, pvOwner);
155
156	uint32_t iQueue = pVM->pdm.s.cRing3Queues;
157	if (iQueue >= pVM->pdm.s.cRing3QueuesAlloc)
158	{
159	AssertLogRelMsgReturnStmt(iQueue < _16K, ("%#x\n", iQueue), RTMemPageFree(pQueue, cbQueue), VERR_TOO_MANY_OPENS);
160
161	uint32_t const cNewAlloc = RT_ALIGN_32(iQueue, 64) + 64;
162	PPDMQUEUE papQueuesNew = (PPDMQUEUE )RTMemAllocZ(cNewAlloc * sizeof(papQueuesNew[0]));
163	AssertLogRelMsgReturnStmt(papQueuesNew, ("cNewAlloc=%u\n", cNewAlloc), RTMemPageFree(pQueue, cbQueue), VERR_NO_MEMORY);
164
165	if (iQueue)
166	memcpy(papQueuesNew, pVM->pdm.s.papRing3Queues, iQueue * sizeof(papQueuesNew[0]));
167	PPDMQUEUE papQueuesOld = ASMAtomicXchgPtrT(&pVM->pdm.s.papRing3Queues, papQueuesNew, PPDMQUEUE );
168	pVM->pdm.s.cRing3QueuesAlloc = cNewAlloc;
169	RTMemFree(papQueuesOld);
170	}
171
172	pVM->pdm.s.papRing3Queues[iQueue] = pQueue;
173	pVM->pdm.s.cRing3Queues = iQueue + 1;
174	hQueue = iQueue + RT_ELEMENTS(pVM->pdm.s.apRing0Queues);
175	}
176
177	/*
178	* Create timer?
179	*/
180	if (cMilliesInterval)
181	{
182	char szName[48+6];
183	RTStrPrintf(szName, sizeof(szName), "Que/%s", pQueue->szName);
184	int rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, szName, &pQueue->hTimer);
185	if (RT_SUCCESS(rc))
186	{
187	rc = TMTimerSetMillies(pVM, pQueue->hTimer, cMilliesInterval);
188	if (RT_SUCCESS(rc))
189	pQueue->cMilliesInterval = cMilliesInterval;
190	else
191	{
192	AssertMsgFailed(("TMTimerSetMillies failed rc=%Rrc\n", rc));
193	int rc2 = TMR3TimerDestroy(pVM, pQueue->hTimer); AssertRC(rc2);
194	pQueue->hTimer = NIL_TMTIMERHANDLE;
195	}
196	}
197	else
198	AssertMsgFailed(("TMR3TimerCreateInternal failed rc=%Rrc\n", rc));
199	if (RT_FAILURE(rc))
200	{
201	if (!fRZEnabled)
202	pdmR3QueueDestroyLocked(pVM, hQueue, pvOwner);
203	/* else: will clean up queue when VM is destroyed */
204	return rc;
205	}
206	}
207
208	/*
209	* Register the statistics.
210	*/
211	STAMR3RegisterF(pVM, &pQueue->cbItem, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,
212	"Item size.", "/PDM/Queue/%s/cbItem", pQueue->szName);
213	STAMR3RegisterF(pVM, &pQueue->cItems, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,
214	"Queue size.", "/PDM/Queue/%s/cItems", pQueue->szName);
215	STAMR3RegisterF(pVM, &pQueue->rcOkay, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,
216	"Non-zero means queue is busted.", "/PDM/Queue/%s/rcOkay", pQueue->szName);
217	STAMR3RegisterF(pVM, &pQueue->StatAllocFailures, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,
218	"PDMQueueAlloc failures.", "/PDM/Queue/%s/AllocFailures", pQueue->szName);
219	STAMR3RegisterF(pVM, &pQueue->StatInsert, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
220	"Calls to PDMQueueInsert.", "/PDM/Queue/%s/Insert", pQueue->szName);
221	STAMR3RegisterF(pVM, &pQueue->StatFlush, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS,
222	"Calls to pdmR3QueueFlush.", "/PDM/Queue/%s/Flush", pQueue->szName);
223	STAMR3RegisterF(pVM, &pQueue->StatFlushLeftovers, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,
224	"Left over items after flush.", "/PDM/Queue/%s/FlushLeftovers", pQueue->szName);
225	#ifdef VBOX_WITH_STATISTICS
226	STAMR3RegisterF(pVM, &pQueue->StatFlushPrf, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,
227	"Profiling pdmR3QueueFlush.", "/PDM/Queue/%s/FlushPrf", pQueue->szName);
228	STAMR3RegisterF(pVM, (void *)&pQueue->cStatPending, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,
229	"Pending items.", "/PDM/Queue/%s/Pending", pQueue->szName);
230	#endif
231
232	*phQueue = hQueue;
233	return VINF_SUCCESS;
234	}
235
236
237	/**
238	* Create a queue with a device owner.
239	*
240	* @returns VBox status code.
241	* @param pVM The cross context VM structure.
242	* @param pDevIns Device instance.
243	* @param cbItem Size a queue item.
244	* @param cItems Number of items in the queue.
245	* @param cMilliesInterval Number of milliseconds between polling the queue.
246	* If 0 then the emulation thread will be notified whenever an item arrives.
247	* @param pfnCallback The consumer function.
248	* @param fRZEnabled Set if the queue must be usable from RC/R0.
249	* @param pszName The queue name. Unique. Copied.
250	* @param phQueue Where to store the queue handle on success.
251	* @thread Emulation thread only. Only EMT0 when @a fRZEnables is true.
252	*/
253	VMMR3_INT_DECL(int) PDMR3QueueCreateDevice(PVM pVM, PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems,
254	uint32_t cMilliesInterval, PFNPDMQUEUEDEV pfnCallback,
255	bool fRZEnabled, const char pszName, PDMQUEUEHANDLE phQueue)
256	{
257	LogFlow(("PDMR3QueueCreateDevice: pDevIns=%p cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p fRZEnabled=%RTbool pszName=%s\n",
258	pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName));
259
260	/*
261	* Validate input.
262	*/
263	VM_ASSERT_EMT0(pVM);
264	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
265	AssertPtrReturn(pDevIns, VERR_INVALID_POINTER);
266
267	if (!(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_R0_ENABLED))
268	fRZEnabled = false;
269
270	/*
271	* Create the queue.
272	*/
273	int rc = RTCritSectEnter(&pVM->pUVM->pdm.s.ListCritSect);
274	AssertRCReturn(rc, rc);
275
276	rc = pdmR3QueueCreateLocked(pVM, cbItem, cItems, cMilliesInterval, fRZEnabled, pszName,
277	PDMQUEUETYPE_DEV, pDevIns, (uintptr_t)pfnCallback, phQueue);
278
279	RTCritSectLeave(&pVM->pUVM->pdm.s.ListCritSect);
280	if (RT_SUCCESS(rc))
281	Log(("PDM: Created device queue %#RX64; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p pDevIns=%p\n",
282	*phQueue, cbItem, cItems, cMilliesInterval, pfnCallback, pDevIns));
283	return rc;
284	}
285
286
287	/**
288	* Create a queue with a driver owner.
289	*
290	* @returns VBox status code.
291	* @param pVM The cross context VM structure.
292	* @param pDrvIns Driver instance.
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 pszName The queue name. Unique. Copied.
299	* @param phQueue Where to store the queue handle on success.
300	* @thread Emulation thread only.
301	*/
302	VMMR3_INT_DECL(int) PDMR3QueueCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
303	PFNPDMQUEUEDRV pfnCallback, const char pszName, PDMQUEUEHANDLE phQueue)
304	{
305	LogFlow(("PDMR3QueueCreateDriver: pDrvIns=%p cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%s\n",
306	pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName));
307
308	/*
309	* Validate input.
310	*/
311	VM_ASSERT_EMT0(pVM);
312	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
313	AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
314
315	/*
316	* Create the queue.
317	*/
318	int rc = RTCritSectEnter(&pVM->pUVM->pdm.s.ListCritSect);
319	AssertRCReturn(rc, rc);
320
321	rc = pdmR3QueueCreateLocked(pVM, cbItem, cItems, cMilliesInterval, false /fRZEnabled/, pszName,
322	PDMQUEUETYPE_DRV, pDrvIns, (uintptr_t)pfnCallback, phQueue);
323
324	RTCritSectLeave(&pVM->pUVM->pdm.s.ListCritSect);
325	if (RT_SUCCESS(rc))
326	Log(("PDM: Created driver queue %#RX64; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p pDrvIns=%p\n",
327	*phQueue, cbItem, cItems, cMilliesInterval, pfnCallback, pDrvIns));
328	return rc;
329	}
330
331
332	/**
333	* Create a queue with an internal owner.
334	*
335	* @returns VBox status code.
336	* @param pVM The cross context VM structure.
337	* @param cbItem Size a queue item.
338	* @param cItems Number of items in the queue.
339	* @param cMilliesInterval Number of milliseconds between polling the queue.
340	* If 0 then the emulation thread will be notified whenever an item arrives.
341	* @param pfnCallback The consumer function.
342	* @param fRZEnabled Set if the queue must be usable from RC/R0.
343	* @param pszName The queue name. Unique. Copied.
344	* @param phQueue Where to store the queue handle on success.
345	* @thread Emulation thread only. When @a fRZEnables is true only EMT0.
346	*/
347	VMMR3_INT_DECL(int) PDMR3QueueCreateInternal(PVM pVM, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
348	PFNPDMQUEUEINT pfnCallback, bool fRZEnabled,
349	const char pszName, PDMQUEUEHANDLE phQueue)
350	{
351	LogFlow(("PDMR3QueueCreateInternal: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p fRZEnabled=%RTbool pszName=%s\n",
352	cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName));
353
354	/*
355	* Validate input.
356	*/
357	VM_ASSERT_EMT0(pVM);
358	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
359
360	/*
361	* Create the queue.
362	*/
363	int rc = RTCritSectEnter(&pVM->pUVM->pdm.s.ListCritSect);
364	AssertRCReturn(rc, rc);
365
366	rc = pdmR3QueueCreateLocked(pVM, cbItem, cItems, cMilliesInterval, fRZEnabled, pszName,
367	PDMQUEUETYPE_INTERNAL, pVM, (uintptr_t)pfnCallback, phQueue);
368
369	RTCritSectLeave(&pVM->pUVM->pdm.s.ListCritSect);
370	if (RT_SUCCESS(rc))
371	Log(("PDM: Created internal queue %p; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p\n",
372	*phQueue, cbItem, cItems, cMilliesInterval, pfnCallback));
373	return rc;
374	}
375
376
377	/**
378	* Create a queue with an external owner.
379	*
380	* @returns VBox status code.
381	* @param pVM The cross context VM structure.
382	* @param cbItem Size a queue item.
383	* @param cItems Number of items in the queue.
384	* @param cMilliesInterval Number of milliseconds between polling the queue.
385	* If 0 then the emulation thread will be notified whenever an item arrives.
386	* @param pfnCallback The consumer function.
387	* @param pvUser The user argument to the consumer function.
388	* @param pszName The queue name. Unique. Not copied.
389	* @param phQueue Where to store the queue handle on success.
390	* @thread Emulation thread only.
391	*/
392	VMMR3DECL(int) PDMR3QueueCreateExternal(PVM pVM, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
393	PFNPDMQUEUEEXT pfnCallback, void *pvUser,
394	const char pszName, PDMQUEUEHANDLE phQueue)
395	{
396	LogFlow(("PDMR3QueueCreateExternal: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%s\n",
397	cbItem, cItems, cMilliesInterval, pfnCallback, pszName));
398
399	/*
400	* Validate input.
401	*/
402	VM_ASSERT_EMT0(pVM);
403	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
404
405	/*
406	* Create the queue.
407	*/
408	int rc = RTCritSectEnter(&pVM->pUVM->pdm.s.ListCritSect);
409	AssertRCReturn(rc, rc);
410
411	rc = pdmR3QueueCreateLocked(pVM, cbItem, cItems, cMilliesInterval, false /fRZEnabled/, pszName,
412	PDMQUEUETYPE_EXTERNAL, pvUser, (uintptr_t)pfnCallback, phQueue);
413
414	RTCritSectLeave(&pVM->pUVM->pdm.s.ListCritSect);
415	if (RT_SUCCESS(rc))
416	Log(("PDM: Created external queue %p; cbItem=%d cItems=%d cMillies=%d pfnCallback=%p pvUser=%p\n",
417	*phQueue, cbItem, cItems, cMilliesInterval, pfnCallback, pvUser));
418	return rc;
419	}
420
421
422	/**
423	* Destroy a queue.
424	*
425	* @returns VBox status code.
426	* @param pVM Pointer to the cross context VM structure.
427	* @param hQueue Handle to the queue that should be destroyed.
428	* @param pvOwner The owner address.
429	* @thread EMT
430	*/
431	static int pdmR3QueueDestroyLocked(PVM pVM, PDMQUEUEHANDLE hQueue, void *pvOwner)
432	{
433	LogFlow(("pdmR3QueueDestroyLocked: hQueue=%p pvOwner=%p\n", hQueue, pvOwner));
434	Assert(RTCritSectIsOwner(&pVM->pUVM->pdm.s.ListCritSect));
435
436	/*
437	* Validate input.
438	*/
439	VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
440	if (hQueue == NIL_PDMQUEUEHANDLE)
441	return VINF_SUCCESS;
442
443	PPDMQUEUE pQueue;
444	bool fRZEnabled = false;
445	if (hQueue < RT_ELEMENTS(pVM->pdm.s.apRing0Queues))
446	{
447	AssertReturn(hQueue < pVM->pdm.s.cRing0Queues, VERR_INVALID_HANDLE);
448	pQueue = pVM->pdm.s.apRing0Queues[hQueue];
449	AssertPtrReturn(pQueue, VERR_INVALID_HANDLE);
450	AssertReturn(pQueue->u32Magic == PDMQUEUE_MAGIC, VERR_INVALID_HANDLE);
451	AssertReturn(pQueue->u.Gen.pvOwner == pvOwner, VERR_INVALID_HANDLE);
452
453	/* Lazy bird: Cannot dynamically delete ring-0 capable queues. */
454	AssertFailedReturn(VERR_NOT_SUPPORTED);
455	}
456	else
457	{
458	hQueue -= RT_ELEMENTS(pVM->pdm.s.apRing0Queues);
459	AssertReturn(hQueue < pVM->pdm.s.cRing3Queues, VERR_INVALID_HANDLE);
460	pQueue = pVM->pdm.s.papRing3Queues[hQueue];
461	AssertPtrReturn(pQueue, VERR_INVALID_HANDLE);
462	AssertReturn(pQueue->u32Magic == PDMQUEUE_MAGIC, VERR_INVALID_HANDLE);
463	AssertReturn(pQueue->u.Gen.pvOwner == pvOwner, VERR_INVALID_HANDLE);
464
465	/* Enter the lock here to serialize with other EMTs traversing the handles. */
466	pdmLock(pVM);
467	pVM->pdm.s.papRing3Queues[hQueue] = NULL;
468	if (hQueue + 1 == pVM->pdm.s.cRing3Queues)
469	{
470	while (hQueue > 0 && pVM->pdm.s.papRing3Queues[hQueue - 1] == NULL)
471	hQueue--;
472	pVM->pdm.s.cRing3Queues = hQueue;
473	}
474	pQueue->u32Magic = PDMQUEUE_MAGIC_DEAD;
475	pdmUnlock(pVM);
476	}
477
478	/*
479	* Deregister statistics.
480	*/
481	STAMR3DeregisterF(pVM->pUVM, "/PDM/Queue/%s/*", pQueue->szName);
482
483	/*
484	* Destroy the timer and free it.
485	*/
486	if (pQueue->hTimer != NIL_TMTIMERHANDLE)
487	{
488	TMR3TimerDestroy(pVM, pQueue->hTimer);
489	pQueue->hTimer = NIL_TMTIMERHANDLE;
490	}
491	if (!fRZEnabled)
492	RTMemPageFree(pQueue, pQueue->offItems + pQueue->cbItem * pQueue->cItems);
493
494	return VINF_SUCCESS;
495	}
496
497
498	/**
499	* Destroy a queue.
500	*
501	* @returns VBox status code.
502	* @param pVM Pointer to the cross context VM structure.
503	* @param hQueue Handle to the queue that should be destroyed.
504	* @param pvOwner The owner address.
505	* @thread EMT
506	* @note Externally visible mainly for testing purposes.
507	*/
508	VMMR3DECL(int) PDMR3QueueDestroy(PVM pVM, PDMQUEUEHANDLE hQueue, void *pvOwner)
509	{
510	PUVM const pUVM = pVM->pUVM;
511	RTCritSectEnter(&pUVM->pdm.s.ListCritSect);
512
513	int rc = pdmR3QueueDestroyLocked(pVM, hQueue, pvOwner);
514
515	RTCritSectLeave(&pUVM->pdm.s.ListCritSect);
516	return rc;
517	}
518
519
520	/**
521	* Destroy a all queues with a given owner.
522	*
523	* @returns VBox status code.
524	* @param pVM The cross context VM structure.
525	* @param pvOwner The owner pointer.
526	* @param enmType Owner type.
527	* @thread EMT
528	*/
529	static int pdmR3QueueDestroyByOwner(PVM pVM, void *pvOwner, PDMQUEUETYPE enmType)
530	{
531	LogFlow(("pdmR3QueueDestroyByOwner: pvOwner=%p enmType=%d\n", pvOwner, enmType));
532
533	/*
534	* Validate input.
535	*/
536	AssertPtrReturn(pvOwner, VERR_INVALID_PARAMETER);
537	AssertReturn(pvOwner != pVM, VERR_INVALID_PARAMETER);
538	VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT); /* Not requiring EMT0 here as we cannot destroy RZ capable ones here. */
539
540	/*
541	* Scan and destroy.
542	*/
543	PUVM const pUVM = pVM->pUVM;
544	RTCritSectEnter(&pUVM->pdm.s.ListCritSect);
545
546	uint32_t i = pVM->pdm.s.cRing0Queues;
547	while (i-- > 0)
548	{
549	PPDMQUEUE pQueue = pVM->pdm.s.apRing0Queues[i];
550	if ( pQueue
551	&& pQueue->u.Gen.pvOwner == pvOwner
552	&& pQueue->enmType == enmType)
553	{
554	/* Not supported at runtime. */
555	VM_ASSERT_STATE_RETURN(pVM, VMSTATE_DESTROYING, VERR_WRONG_ORDER);
556	}
557	}
558
559	i = pVM->pdm.s.cRing3Queues;
560	while (i-- > 0)
561	{
562	PPDMQUEUE pQueue = pVM->pdm.s.papRing3Queues[i];
563	if ( pQueue
564	&& pQueue->u.Gen.pvOwner == pvOwner
565	&& pQueue->enmType == enmType)
566	pdmR3QueueDestroyLocked(pVM, i + RT_ELEMENTS(pVM->pdm.s.apRing0Queues), pvOwner);
567	}
568
569	RTCritSectLeave(&pUVM->pdm.s.ListCritSect);
570	return VINF_SUCCESS;
571	}
572
573
574	/**
575	* Destroy a all queues owned by the specified device.
576	*
577	* @returns VBox status code.
578	* @param pVM The cross context VM structure.
579	* @param pDevIns Device instance.
580	* @thread EMT(0)
581	*/
582	VMMR3_INT_DECL(int) PDMR3QueueDestroyDevice(PVM pVM, PPDMDEVINS pDevIns)
583	{
584	LogFlow(("PDMR3QueueDestroyDevice: pDevIns=%p\n", pDevIns));
585	return pdmR3QueueDestroyByOwner(pVM, pDevIns, PDMQUEUETYPE_DEV);
586	}
587
588
589	/**
590	* Destroy a all queues owned by the specified driver.
591	*
592	* @returns VBox status code.
593	* @param pVM The cross context VM structure.
594	* @param pDrvIns Driver instance.
595	* @thread EMT(0)
596	*/
597	VMMR3_INT_DECL(int) PDMR3QueueDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns)
598	{
599	LogFlow(("PDMR3QueueDestroyDriver: pDrvIns=%p\n", pDrvIns));
600	return pdmR3QueueDestroyByOwner(pVM, pDrvIns, PDMQUEUETYPE_DRV);
601	}
602
603
604	/**
605	* Free an item.
606	*
607	* @param pQueue The queue.
608	* @param pbItems Where the items area starts.
609	* @param cbItem Item size.
610	* @param pItem The item to free.
611	*/
612	DECLINLINE(void) pdmR3QueueFreeItem(PPDMQUEUE pQueue, uint8_t *pbItems, uint32_t cbItem, PPDMQUEUEITEMCORE pItem)
613	{
614	pItem->u64View = UINT64_C(0xfeedfeedfeedfeed);
615
616	uintptr_t const offItem = (uintptr_t)pItem - (uintptr_t)pbItems;
617	uintptr_t const iItem = offItem / cbItem;
618	Assert(!(offItem % cbItem));
619	Assert(iItem < pQueue->cItems);
620	AssertReturnVoidStmt(ASMAtomicBitTestAndSet(pQueue->bmAlloc, iItem) == false, pQueue->rcOkay = VERR_INTERNAL_ERROR_4);
621	STAM_STATS({ ASMAtomicDecU32(&pQueue->cStatPending); });
622	}
623
624
625
626	/**
627	* Process pending items in one queue.
628	*
629	* @returns VBox status code.
630	* @param pVM The cross context VM structure.
631	* @param pQueue The queue needing flushing.
632	*/
633	static int pdmR3QueueFlush(PVM pVM, PPDMQUEUE pQueue)
634	{
635	STAM_PROFILE_START(&pQueue->StatFlushPrf,p);
636
637	uint32_t const cbItem = pQueue->cbItem;
638	uint32_t const cItems = pQueue->cItems;
639	uint8_t * const pbItems = (uint8_t *)pQueue + pQueue->offItems;
640
641	/*
642	* Get the list and reverse it into a pointer list (inserted in LIFO order to avoid locking).
643	*/
644	uint32_t cPending = 0;
645	PPDMQUEUEITEMCORE pHead = NULL;
646	{
647	uint32_t iCur = ASMAtomicXchgU32(&pQueue->iPending, UINT32_MAX);
648	do
649	{
650	AssertMsgReturn(iCur < cItems, ("%#x vs %#x\n", iCur, cItems), pQueue->rcOkay = VERR_INTERNAL_ERROR_5);
651	AssertReturn(ASMBitTest(pQueue->bmAlloc, iCur) == false, pQueue->rcOkay = VERR_INTERNAL_ERROR_3);
652	PPDMQUEUEITEMCORE pCur = (PPDMQUEUEITEMCORE)&pbItems[iCur * cbItem];
653
654	iCur = pCur->iNext;
655	ASMCompilerBarrier(); /* paranoia */
656	pCur->pNext = pHead;
657	pHead = pCur;
658	cPending++;
659	} while (iCur != UINT32_MAX);
660	}
661	RT_NOREF(cPending);
662
663	/*
664	* Feed the items to the consumer function.
665	*/
666	Log2(("pdmR3QueueFlush: pQueue=%p enmType=%d pHead=%p cItems=%u\n", pQueue, pQueue->enmType, pHead, cPending));
667	switch (pQueue->enmType)
668	{
669	case PDMQUEUETYPE_DEV:
670	while (pHead)
671	{
672	if (!pQueue->u.Dev.pfnCallback(pQueue->u.Dev.pDevIns, pHead))
673	break;
674	PPDMQUEUEITEMCORE pFree = pHead;
675	pHead = pHead->pNext;
676	ASMCompilerBarrier(); /* paranoia */
677	pdmR3QueueFreeItem(pQueue, pbItems, cbItem, pFree);
678	}
679	break;
680
681	case PDMQUEUETYPE_DRV:
682	while (pHead)
683	{
684	if (!pQueue->u.Drv.pfnCallback(pQueue->u.Drv.pDrvIns, pHead))
685	break;
686	PPDMQUEUEITEMCORE pFree = pHead;
687	pHead = pHead->pNext;
688	ASMCompilerBarrier(); /* paranoia */
689	pdmR3QueueFreeItem(pQueue, pbItems, cbItem, pFree);
690	}
691	break;
692
693	case PDMQUEUETYPE_INTERNAL:
694	while (pHead)
695	{
696	if (!pQueue->u.Int.pfnCallback(pVM, pHead))
697	break;
698	PPDMQUEUEITEMCORE pFree = pHead;
699	pHead = pHead->pNext;
700	ASMCompilerBarrier(); /* paranoia */
701	pdmR3QueueFreeItem(pQueue, pbItems, cbItem, pFree);
702	}
703	break;
704
705	case PDMQUEUETYPE_EXTERNAL:
706	while (pHead)
707	{
708	if (!pQueue->u.Ext.pfnCallback(pQueue->u.Ext.pvUser, pHead))
709	break;
710	PPDMQUEUEITEMCORE pFree = pHead;
711	pHead = pHead->pNext;
712	ASMCompilerBarrier(); /* paranoia */
713	pdmR3QueueFreeItem(pQueue, pbItems, cbItem, pFree);
714	}
715	break;
716
717	default:
718	AssertMsgFailed(("Invalid queue type %d\n", pQueue->enmType));
719	break;
720	}
721
722	/*
723	* Success?
724	*/
725	if (!pHead)
726	{ /* likely */ }
727	else
728	{
729	/*
730	* Reverse the list and turn it back into index chain.
731	*/
732	uint32_t iPendingHead = UINT32_MAX;
733	do
734	{
735	PPDMQUEUEITEMCORE pInsert = pHead;
736	pHead = pHead->pNext;
737	ASMCompilerBarrier(); /* paranoia */
738	pInsert->iNext = iPendingHead;
739	iPendingHead = ((uintptr_t)pInsert - (uintptr_t)pbItems) / cbItem;
740	} while (pHead);
741
742	/*
743	* Insert the list at the tail of the pending list. If someone races
744	* us there, we have to join the new LIFO with the old.
745	*/
746	for (;;)
747	{
748	if (ASMAtomicCmpXchgU32(&pQueue->iPending, iPendingHead, UINT32_MAX))
749	break;
750
751	uint32_t const iNewPending = ASMAtomicXchgU32(&pQueue->iPending, UINT32_MAX);
752	if (iNewPending != UINT32_MAX)
753	{
754	/* Find the last entry and chain iPendingHead onto it. */
755	uint32_t iCur = iNewPending;
756	for (;;)
757	{
758	AssertReturn(iCur < cItems, pQueue->rcOkay = VERR_INTERNAL_ERROR_2);
759	AssertReturn(ASMBitTest(pQueue->bmAlloc, iCur) == false, pQueue->rcOkay = VERR_INTERNAL_ERROR_3);
760	PPDMQUEUEITEMCORE pCur = (PPDMQUEUEITEMCORE)&pbItems[iCur * cbItem];
761	iCur = pCur->iNext;
762	if (iCur == UINT32_MAX)
763	{
764	pCur->iNext = iPendingHead;
765	break;
766	}
767	}
768
769	iPendingHead = iNewPending;
770	}
771	}
772
773	STAM_REL_COUNTER_INC(&pQueue->StatFlushLeftovers);
774	}
775
776	STAM_PROFILE_STOP(&pQueue->StatFlushPrf,p);
777	return VINF_SUCCESS;
778	}
779
780
781	/**
782	* Flush pending queues.
783	* This is a forced action callback.
784	*
785	* @param pVM The cross context VM structure.
786	* @thread Emulation thread only.
787	* @note Internal, but exported for use in the testcase.
788	*/
789	VMMR3DECL(void) PDMR3QueueFlushAll(PVM pVM)
790	{
791	VM_ASSERT_EMT(pVM);
792	LogFlow(("PDMR3QueuesFlush:\n"));
793
794	/*
795	* Only let one EMT flushing queues at any one time to preserve the order
796	* and to avoid wasting time. The FF is always cleared here, because it's
797	* only used to get someones attention. Queue inserts occurring during the
798	* flush are caught using the pending bit.
799	*
800	* Note! We must check the force action and pending flags after clearing
801	* the active bit!
802	*/
803	VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
804	while (!ASMAtomicBitTestAndSet(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT))
805	{
806	ASMAtomicBitClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT);
807
808	/* Scan the ring-0 queues: */
809	size_t i = pVM->pdm.s.cRing0Queues;
810	while (i-- > 0)
811	{
812	PPDMQUEUE pQueue = pVM->pdm.s.apRing0Queues[i];
813	if ( pQueue
814	&& pQueue->iPending != UINT32_MAX
815	&& pQueue->hTimer == NIL_TMTIMERHANDLE
816	&& pQueue->rcOkay == VINF_SUCCESS)
817	pdmR3QueueFlush(pVM, pQueue);
818	}
819
820	/* Scan the ring-3 queues: */
821	/** @todo Deal with destroy concurrency issues. */
822	i = pVM->pdm.s.cRing3Queues;
823	while (i-- > 0)
824	{
825	PPDMQUEUE pQueue = pVM->pdm.s.papRing3Queues[i];
826	if ( pQueue
827	&& pQueue->iPending != UINT32_MAX
828	&& pQueue->hTimer == NIL_TMTIMERHANDLE
829	&& pQueue->rcOkay == VINF_SUCCESS)
830	pdmR3QueueFlush(pVM, pQueue);
831	}
832
833	ASMAtomicBitClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT);
834
835	/* We're done if there were no inserts while we were busy. */
836	if ( !ASMBitTest(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT)
837	&& !VM_FF_IS_SET(pVM, VM_FF_PDM_QUEUES))
838	break;
839	VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
840	}
841	}
842
843
844
845	/**
846	* @callback_method_impl{FNTMTIMERINT, Timer handler for one PDM queue.}
847	*/
848	static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
849	{
850	PPDMQUEUE pQueue = (PPDMQUEUE)pvUser;
851	Assert(hTimer == pQueue->hTimer);
852
853	if (pQueue->iPending != UINT32_MAX)
854	pdmR3QueueFlush(pVM, pQueue);
855
856	int rc = TMTimerSetMillies(pVM, hTimer, pQueue->cMilliesInterval);
857	AssertRC(rc);
858	}
859
860
861	/**
862	* Terminate the queues, freeing any resources still allocated.
863	*
864	* @param pVM The cross-context VM structure.
865	*/
866	DECLHIDDEN(void) pdmR3QueueTerm(PVM pVM)
867	{
868	PUVM const pUVM = pVM->pUVM;
869	RTCritSectEnter(&pUVM->pdm.s.ListCritSect);
870
871	if (pVM->pdm.s.papRing3Queues)
872	{
873	/*
874	* Free the R3 queue handle array.
875	*/
876	PDMQUEUEHANDLE cQueues = pVM->pdm.s.cRing3Queues;
877	for (PDMQUEUEHANDLE i = 0; i < cQueues; i++)
878	if (pVM->pdm.s.papRing3Queues[i])
879	{
880	PPDMQUEUE pQueue = pVM->pdm.s.papRing3Queues[i];
881
882	pdmR3QueueDestroyLocked(pVM, RT_ELEMENTS(pVM->pdm.s.apRing0Queues) + i, pQueue->u.Gen.pvOwner);
883	Assert(!pVM->pdm.s.papRing3Queues[i]);
884	}
885
886	RTMemFree(pVM->pdm.s.papRing3Queues);
887	pVM->pdm.s.cRing3QueuesAlloc = 0;
888	pVM->pdm.s.papRing3Queues = NULL;
889	}
890
891	RTCritSectLeave(&pUVM->pdm.s.ListCritSect);
892	}

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

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

Download in other formats: