VirtualBox

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

Last change on this file since 74795 was 74790, checked in by vboxsync, 6 years ago

vm.h,VMM: Use VM_FF_IS_SET instead of VM_FF_IS_PENDING when checking a single flag. Added compile time assertion on single flag. bugref:9180
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 29.0 KB
Line 
1/* $Id: PDMQueue.cpp 74790 2018-10-12 10:42:58Z 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*********************************************************************************************************************************/
42DECLINLINE(void) pdmR3QueueFreeItem(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem);
43static bool pdmR3QueueFlush(PPDMQUEUE pQueue);
44static 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 */
61static 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_UOFFSETOF_DYN(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_UOFFSETOF_DYN(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 */
207VMMR3_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 */
257VMMR3_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 */
303VMMR3_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 */
348VMMR3_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 */
385VMMR3_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 */
479VMMR3_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 */
531VMMR3_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 */
581void 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 */
636VMMR3_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_SET(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 */
679static 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 */
840DECLINLINE(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 */
868static 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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use