PDMR3Task.cpp@ 81406

Last change on this file since 81406 was 81406, checked in by vboxsync, 6 years ago
PDM: Enabled PDM task code. Added bunch of new device helper functions. bugref:9218
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.1 KB

Line
1	/* $Id: PDMR3Task.cpp 81406 2019-10-21 12:30:54Z vboxsync $ */
2	/** @file
3	* PDM Task - Asynchronous user mode tasks.
4	*/
5
6	/*
7	* Copyright (C) 2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. 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_TASK
23	#include "PDMInternal.h"
24	#include <VBox/vmm/pdmtask.h>
25	#include <VBox/vmm/mm.h>
26	#include <VBox/vmm/vm.h>
27	#include <VBox/err.h>
28
29	#include <VBox/log.h>
30	#include <VBox/sup.h>
31	#include <iprt/asm.h>
32	#include <iprt/assert.h>
33	#include <iprt/semaphore.h>
34	#include <iprt/thread.h>
35
36
37	/**
38	* @callback_method_impl{FNDBGFINFOARGVINT}
39	*/
40	static DECLCALLBACK(void) pdmR3TaskInfo(PVM pVM, PCDBGFINFOHLP pHlp, int cArgs, char **papszArgs)
41	{
42	RT_NOREF(cArgs, papszArgs); /* for now. */
43
44	uint32_t cSetsDisplayed = 0;
45	for (size_t i = 0; i < RT_ELEMENTS(pVM->pdm.s.apTaskSets); i++)
46	{
47	PPDMTASKSET pTaskSet = pVM->pdm.s.apTaskSets[i];
48	if ( pTaskSet
49	&& ( pTaskSet->cAllocated > 0
50	\|\| ASMAtomicReadU64(&pTaskSet->fTriggered)))
51	{
52	if (cSetsDisplayed > 0)
53	pHlp->pfnPrintf(pHlp, "\n");
54	pHlp->pfnPrintf(pHlp,
55	"Task set #%u - handle base %u, pending %#RX64%s%s, running %d, %u of %u allocated:\n"
56	/* 123: triggered internal 0123456789abcdef 0123456789abcdef 0x0000 SomeFunctionName */
57	" Hnd: State Type pfnCallback pvUser Flags Name\n",
58	i, pTaskSet->uHandleBase, ASMAtomicReadU64(&pTaskSet->fTriggered),
59	(int)ASMAtomicReadU32(&pTaskSet->idxRunning),
60	pTaskSet->fRZEnabled ? " RZ-enabled" : "", pTaskSet->hThread != NIL_RTTHREAD ? "" : " no-thread",
61	pTaskSet->cAllocated, RT_ELEMENTS(pTaskSet->aTasks));
62	for (unsigned j = 0; j < RT_ELEMENTS(pTaskSet->aTasks); j++)
63	{
64	PPDMTASK pTask = &pTaskSet->aTasks[j];
65	if (pTask->pvOwner)
66	{
67	const char *pszType;
68	switch (pTask->enmType)
69	{
70	case PDMTASKTYPE_DEV: pszType = " device "; break;
71	case PDMTASKTYPE_DRV: pszType = " driver "; break;
72	case PDMTASKTYPE_USB: pszType = " usbdev "; break;
73	case PDMTASKTYPE_INTERNAL: pszType = "internal"; break;
74	default: pszType = "unknown "; break;
75	}
76	pHlp->pfnPrintf(pHlp, " %3u: %s %s %p %p %#06 %s\n", pTaskSet->uHandleBase + j,
77	ASMBitTest(&pTaskSet->fTriggered, j) ? "triggered"
78	: ASMAtomicReadU32(&pTaskSet->idxRunning) == j ? " running " : " idle ",
79	pszType, pTask->pfnCallback, pTask->pvUser, pTask->fFlags, pTask->pszName);
80	}
81	}
82
83	cSetsDisplayed++;
84	}
85	}
86	}
87
88
89	/**
90	* Initializes the ring-0 capable tasks during VM construction.
91	*
92	* @returns VBox status code.
93	* @param pVM The cross context VM structure.
94	*/
95	int pdmR3TaskInit(PVM pVM)
96	{
97	for (size_t i = 0; i < RT_ELEMENTS(pVM->pdm.s.aTaskSets); i++)
98	{
99	PPDMTASKSET pTaskSet = &pVM->pdm.s.aTaskSets[i];
100
101	pTaskSet->u32Magic = PDMTASKSET_MAGIC;
102	pTaskSet->fRZEnabled = true;
103	//pTaskSet->cAllocated = 0;
104	pTaskSet->uHandleBase = (uint16_t)(i * RT_ELEMENTS(pTaskSet->aTasks));
105	pTaskSet->hThread = NIL_RTTHREAD;
106	int rc = SUPSemEventCreate(pVM->pSession, &pTaskSet->hEventR0);
107	AssertRCReturn(rc, rc);
108	pTaskSet->hEventR3 = NIL_RTSEMEVENT;
109	//pTaskSet->fTriggered = 0;
110	pTaskSet->idxRunning = UINT8_MAX;
111	//pTaskSet->fShutdown = false;
112
113	pVM->pdm.s.apTaskSets[i] = pTaskSet;
114	}
115
116	int rc = DBGFR3InfoRegisterInternalArgv(pVM, "tasks", "PDM tasks", pdmR3TaskInfo, 0 /fFlags/);
117	AssertRC(rc);
118
119	return VINF_SUCCESS;
120	}
121
122
123	/**
124	* Terminates task threads when the VM is destroyed.
125	*
126	* @param pVM The cross context VM structure.
127	*/
128	void pdmR3TaskTerm(PVM pVM)
129	{
130	/*
131	* Signal all the threads first.
132	*/
133	for (size_t i = 0; i < RT_ELEMENTS(pVM->pdm.s.apTaskSets); i++)
134	{
135	PPDMTASKSET pTaskSet = pVM->pdm.s.apTaskSets[i];
136	if (pTaskSet)
137	{
138	/*
139	* Set the shutdown indicator and signal the thread.
140	*/
141	ASMAtomicWriteBool(&pTaskSet->fShutdown, true);
142
143	if (pTaskSet->hEventR0 != NIL_SUPSEMEVENT)
144	{
145	int rc = SUPSemEventSignal(pVM->pSession, pTaskSet->hEventR0);
146	AssertRC(rc);
147	}
148
149	if (pTaskSet->hEventR3 != NIL_RTSEMEVENT)
150	{
151	int rc = RTSemEventSignal(pTaskSet->hEventR3);
152	AssertRC(rc);
153	}
154	}
155	}
156
157	/*
158	* Wait for them to terminate and clean up semaphores.
159	*/
160	for (size_t i = 0; i < RT_ELEMENTS(pVM->pdm.s.apTaskSets); i++)
161	{
162	PPDMTASKSET pTaskSet = pVM->pdm.s.apTaskSets[i];
163	if (pTaskSet)
164	{
165	/*
166	* Wait for the thread to terminate.
167	*/
168	if (pTaskSet->hThread != NIL_RTTHREAD)
169	{
170	int rc = RTThreadWait(pTaskSet->hThread, RT_MS_30SEC, NULL);
171	AssertLogRelMsg(RT_SUCCESS(rc), ("pTaskSet %u: thread wait failed: %Rrc\n", i, rc));
172	if (RT_SUCCESS(rc))
173	pTaskSet->hThread = NIL_RTTHREAD;
174	}
175
176	/*
177	* Destroy the semaphore.
178	*/
179	if (pTaskSet->hEventR0 != NIL_SUPSEMEVENT)
180	{
181	int rc = SUPSemEventClose(pVM->pSession, pTaskSet->hEventR0);
182	AssertRC(rc);
183	pTaskSet->hEventR0 = NIL_SUPSEMEVENT;
184	}
185
186	if (pTaskSet->hEventR3 != NIL_RTSEMEVENT)
187	{
188	int rc = RTSemEventDestroy(pTaskSet->hEventR3);
189	AssertRC(rc);
190	pTaskSet->hEventR3 = NIL_RTSEMEVENT;
191	}
192	}
193	}
194	}
195
196
197	/**
198	* @callback_method_impl{FNRTTHREAD,
199	* PDM Asynchronous Task Executor Thread}
200	*/
201	static DECLCALLBACK(int) pdmR3TaskThread(RTTHREAD ThreadSelf, void *pvUser)
202	{
203	PPDMTASKSET const pTaskSet = (PPDMTASKSET)pvUser;
204	AssertPtr(pTaskSet);
205	Assert(pTaskSet->u32Magic == PDMTASKSET_MAGIC);
206	RT_NOREF(ThreadSelf);
207
208	/*
209	* Process stuff until we're told to terminate.
210	*/
211	while (!ASMAtomicReadBool(&pTaskSet->fShutdown))
212	{
213	/*
214	* Process pending tasks.
215	*
216	* The outer loop runs till there are no more pending tasks.
217	*
218	* The inner loop takes one snapshot of fTriggered and processes all
219	* pending bits in the snaphot. This ensure fairness.
220	*/
221	for (;;)
222	{
223	uint64_t fTriggered = ASMAtomicReadU64(&pTaskSet->fTriggered);
224	unsigned iTask;
225	while ( (iTask = ASMBitFirstSetU64(fTriggered)) != 0)
226	{
227	iTask--;
228	AssertBreak(iTask < RT_ELEMENTS(pTaskSet->aTasks));
229
230	fTriggered &= ~RT_BIT_64(iTask);
231	if (ASMAtomicBitTestAndClear(&pTaskSet->fTriggered, iTask))
232	{
233	PPDMTASK pTask = &pTaskSet->aTasks[iTask];
234
235	/* Copy out the data we need here to try avoid destruction race trouble. */
236	PDMTASKTYPE const enmType = pTask->enmType;
237	PFNRT const pfnCallback = pTask->pfnCallback;
238	void * const pvOwner = pTask->pvOwner;
239	void * const pvTaskUser = pTask->pvUser;
240
241	ASMAtomicWriteU32(&pTaskSet->idxRunning, iTask);
242
243	if ( pvOwner
244	&& pfnCallback
245	&& pvOwner == pTask->pvOwner
246	&& pfnCallback == pTask->pfnCallback
247	&& pvTaskUser == pTask->pvUser
248	&& enmType == pTask->enmType)
249	{
250	pTask->cRuns += 1;
251	switch (pTask->enmType)
252	{
253	case PDMTASKTYPE_DEV:
254	Log2(("pdmR3TaskThread: Runs dev task %s (%#x)\n", pTask->pszName, iTask + pTaskSet->uHandleBase));
255	((PFNPDMTASKDEV)(pfnCallback))((PPDMDEVINS)pvOwner, pvTaskUser);
256	break;
257	case PDMTASKTYPE_DRV:
258	Log2(("pdmR3TaskThread: Runs drv task %s (%#x)\n", pTask->pszName, iTask + pTaskSet->uHandleBase));
259	((PFNPDMTASKDRV)(pfnCallback))((PPDMDRVINS)pvOwner, pvTaskUser);
260	break;
261	case PDMTASKTYPE_USB:
262	Log2(("pdmR3TaskThread: Runs USB task %s (%#x)\n", pTask->pszName, iTask + pTaskSet->uHandleBase));
263	((PFNPDMTASKUSB)(pfnCallback))((PPDMUSBINS)pvOwner, pvTaskUser);
264	break;
265	case PDMTASKTYPE_INTERNAL:
266	Log2(("pdmR3TaskThread: Runs int task %s (%#x)\n", pTask->pszName, iTask + pTaskSet->uHandleBase));
267	((PFNPDMTASKINT)(pfnCallback))((PVM)pvOwner, pvTaskUser);
268	break;
269	default:
270	AssertFailed();
271	}
272	}
273	else /* Note! There might be a race here during destruction. */
274	AssertMsgFailed(("%d %p %p %p\n", enmType, pvOwner, pfnCallback, pvTaskUser));
275
276	ASMAtomicWriteU32(&pTaskSet->idxRunning, UINT32_MAX);
277	}
278	}
279	}
280	}
281
282	return VINF_SUCCESS;
283	}
284
285
286	/**
287	* Worker for PDMR3TaskCreate().
288	*/
289	DECLINLINE(PPDMTASK) pdmR3TaskAllocInSet(PPDMTASKSET pTaskSet)
290	{
291	if (pTaskSet->cAllocated < RT_ELEMENTS(pTaskSet->aTasks))
292	{
293	for (size_t j = 0; j < RT_ELEMENTS(pTaskSet->aTasks); j++)
294	if (pTaskSet->aTasks[j].pvOwner == NULL)
295	return &pTaskSet->aTasks[j];
296	AssertFailed();
297	}
298	return NULL;
299	}
300
301	/**
302	* Creates a task.
303	*
304	* @returns VBox status code.
305	* @param pVM The cross context VM structure.
306	* @param fFlags PDMTASK_F_XXX.
307	* @param pszName The task name (function name ++).
308	* @param enmType The task owner type.
309	* @param pvOwner The task owner pointer.
310	* @param pfnCallback The task callback.
311	* @param pvUser The user argument for the callback.
312	* @param phTask Where to return the task handle.
313	* @thread EMT(0)
314	*/
315	VMMR3_INT_DECL(int) PDMR3TaskCreate(PVM pVM, uint32_t fFlags, const char pszName, PDMTASKTYPE enmType, void pvOwner,
316	PFNRT pfnCallback, void pvUser, PDMTASKHANDLE phTask)
317	{
318	/*
319	* Validate input.
320	*/
321	AssertReturn(!(fFlags & ~PDMTASK_F_VALID_MASK), VERR_INVALID_FLAGS);
322	AssertPtrReturn(pvOwner, VERR_INVALID_POINTER);
323	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
324	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
325	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
326	VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT); /* implicit serialization by requiring EMT(0) */
327	switch (enmType)
328	{
329	case PDMTASKTYPE_DEV:
330	case PDMTASKTYPE_DRV:
331	case PDMTASKTYPE_USB:
332	break;
333	case PDMTASKTYPE_INTERNAL:
334	AssertReturn(pvOwner == (void *)pVM, VERR_INVALID_PARAMETER);
335	break;
336	default:
337	AssertFailedReturn(VERR_INVALID_PARAMETER);
338	}
339
340	/*
341	* If the callback must be ring-0 triggerable, we are restricted to the
342	* task sets living the VM structure. Otherwise, pick from the dynamically
343	* allocated sets living on ring-3 heap.
344	*/
345	PPDMTASKSET pTaskSet = NULL;
346	PPDMTASK pTask = NULL;
347	if (fFlags & PDMTASK_F_RZ)
348	{
349	for (size_t i = 0; i < RT_ELEMENTS(pVM->pdm.s.aTaskSets); i++)
350	{
351	pTaskSet = &pVM->pdm.s.aTaskSets[i];
352	pTask = pdmR3TaskAllocInSet(pTaskSet);
353	if (pTask)
354	break;
355	}
356	}
357	else
358	{
359	for (size_t i = RT_ELEMENTS(pVM->pdm.s.aTaskSets); i < RT_ELEMENTS(pVM->pdm.s.apTaskSets); i++)
360	{
361	pTaskSet = pVM->pdm.s.apTaskSets[i];
362	if (pTaskSet)
363	{
364	pTask = pdmR3TaskAllocInSet(pTaskSet);
365	if (pTask)
366	break;
367	}
368	else
369	{
370	/*
371	* Try allocate a new set.
372	*/
373	LogFlow(("PDMR3TaskCreate: Allocating new task set (%#u)...\n", i));
374	pTaskSet = (PPDMTASKSET)MMR3HeapAllocZ(pVM, MM_TAG_PDM, sizeof(*pTaskSet));
375	AssertReturn(pTaskSet, VERR_NO_MEMORY);
376
377	pTaskSet->u32Magic = PDMTASKSET_MAGIC;
378	//pTaskSet->fRZEnabled = false;
379	//pTaskSet->cAllocated = 0;
380	pTaskSet->uHandleBase = (uint16_t)(i * RT_ELEMENTS(pTaskSet->aTasks));
381	pTaskSet->hThread = NIL_RTTHREAD;
382	pTaskSet->hEventR0 = NIL_SUPSEMEVENT;
383	int rc = RTSemEventCreate(&pTaskSet->hEventR3);
384	AssertRCReturnStmt(rc, MMR3HeapFree(pTaskSet), rc);
385	//pTaskSet->fTriggered = 0;
386	pTaskSet->idxRunning = UINT8_MAX;
387	//pTaskSet->fShutdown = false;
388
389	pVM->pdm.s.apTaskSets[i] = pTaskSet;
390	pTask = &pTaskSet->aTasks[0];
391	break;
392	}
393	}
394	}
395	AssertLogRelReturn(pTask, VERR_OUT_OF_RESOURCES);
396
397	/*
398	* Do we need to start a worker thread? Do this first as it can fail.
399	*/
400	if (pTaskSet->hThread == NIL_RTTHREAD)
401	{
402	int rc = RTThreadCreateF(&pTaskSet->hThread, pdmR3TaskThread, pTaskSet, 0 /cbStack/, RTTHREADTYPE_MSG_PUMP,
403	RTTHREADFLAGS_WAITABLE, "TaskSet%u", pTaskSet->uHandleBase / RT_ELEMENTS(pTaskSet->aTasks));
404	AssertLogRelRCReturn(rc, rc);
405	}
406
407	/*
408	* Complete the allocation.
409	*/
410	pTask->enmType = enmType;
411	pTask->fFlags = fFlags;
412	pTask->pvUser = pvUser;
413	pTask->pfnCallback = pfnCallback;
414	pTask->pszName = pszName;
415	ASMAtomicWritePtr(&pTask->pvOwner, pvOwner);
416	pTaskSet->cAllocated += 1;
417
418	uint32_t const hTask = pTaskSet->uHandleBase + (uint32_t)(pTask - &pTaskSet->aTasks[0]);
419	*phTask = hTask;
420
421	STAMR3RegisterF(pVM, &pTask->cRuns, STAMTYPE_U32_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,
422	"Number of times the task has been executed.", "/PDM/Tasks/%03u-%s-runs", hTask, pszName);
423	STAMR3RegisterF(pVM, (void *)&pTask->cAlreadyTrigged, STAMTYPE_U32_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,
424	"Number of times the task was re-triggered.", "/PDM/Tasks/%03u-%s-retriggered", hTask, pszName);
425
426	LogFlow(("PDMR3TaskCreate: Allocated %u for %s\n", hTask, pszName));
427	return VINF_SUCCESS;
428	}
429
430
431	/**
432	* Creates an internal task.
433	*
434	* @returns VBox status code.
435	* @param pVM The cross context VM structure.
436	* @param fFlags PDMTASK_F_XXX.
437	* @param pszName The task name (function name ++).
438	* @param pfnCallback The task callback.
439	* @param pvUser The user argument for the callback.
440	* @param phTask Where to return the task handle.
441	* @thread EMT(0)
442	*/
443	VMMR3_INT_DECL(int) PDMR3TaskCreateInternal(PVM pVM, uint32_t fFlags, const char *pszName,
444	PFNPDMTASKINT pfnCallback, void pvUser, PDMTASKHANDLE phTask)
445	{
446	return PDMR3TaskCreate(pVM, fFlags, pszName, PDMTASKTYPE_INTERNAL, pVM, (PFNRT)pfnCallback, pvUser, phTask);
447	}
448
449
450	/**
451	* Worker for PDMR3TaskDestroyAllByOwner() and PDMR3TaskDestroySpecific().
452	*/
453	static void pdmR3TaskDestroyOne(PVM pVM, PPDMTASKSET pTaskSet, PPDMTASK pTask, size_t iTask)
454	{
455	AssertPtr(pTask->pvOwner);
456
457	/*
458	* Delay if busy.
459	*/
460	uint32_t cYields = 64;
461	while ( ASMAtomicReadU32(&pTaskSet->idxRunning) == iTask
462	&& cYields > 0
463	&& pTaskSet->hThread != NIL_RTTHREAD)
464	{
465	ASMNopPause();
466	RTThreadYield();
467	}
468
469	/*
470	* Zap it (very noisy, but whatever).
471	*/
472	LogFlow(("pdmR3TaskDestroyOne: Destroying %zu %s\n", iTask + pTaskSet->uHandleBase, pTask->pszName));
473	AssertPtr(pTask->pvOwner);
474
475	char szPrefix[64];
476	RTStrPrintf(szPrefix, sizeof(szPrefix), "/PDM/Tasks/%03zu-", iTask + pTaskSet->uHandleBase);
477	STAMR3DeregisterByPrefix(pVM->pUVM, szPrefix);
478
479	AssertPtr(pTask->pvOwner);
480	ASMAtomicWriteNullPtr(&pTask->pvOwner);
481	pTask->enmType = (PDMTASKTYPE)0;
482	pTask->fFlags = 0;
483	ASMAtomicWriteNullPtr(&pTask->pfnCallback);
484	ASMAtomicWriteNullPtr(&pTask->pvUser);
485	ASMAtomicWriteNullPtr(&pTask->pszName);
486
487	AssertReturnVoid(pTaskSet->cAllocated > 0);
488	pTaskSet->cAllocated -= 1;
489	}
490
491
492	/**
493	* Destroys all tasks belonging to @a pvOwner.
494	*
495	* @returns VBox status code.
496	* @param pVM The cross context VM structure.
497	* @param enmType The owner type.
498	* @param pvOwner The owner.
499	*/
500	VMMR3_INT_DECL(int) PDMR3TaskDestroyAllByOwner(PVM pVM, PDMTASKTYPE enmType, void *pvOwner)
501	{
502	/*
503	* Validate input.
504	*/
505	AssertReturn(enmType >= PDMTASKTYPE_DEV && enmType < PDMTASKTYPE_INTERNAL, VERR_INVALID_PARAMETER);
506	AssertPtrReturn(pvOwner, VERR_INVALID_POINTER);
507	VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT); /* implicit serialization by requiring EMT(0) */
508
509	/*
510	* Scan all the task sets.
511	*/
512	for (size_t i = 0; i < RT_ELEMENTS(pVM->pdm.s.apTaskSets); i++)
513	{
514	PPDMTASKSET pTaskSet = pVM->pdm.s.apTaskSets[i];
515	if (pTaskSet)
516	{
517	ssize_t cLeft = pTaskSet->cAllocated;
518	for (size_t j = 0; j < RT_ELEMENTS(pTaskSet->aTasks) && cLeft > 0; j++)
519	{
520	PPDMTASK pTask = &pTaskSet->aTasks[j];
521	void * const pvTaskOwner = pTask->pvOwner;
522	if (pvTaskOwner)
523	{
524	if ( pvTaskOwner == pvOwner
525	&& pTask->enmType == enmType)
526	pdmR3TaskDestroyOne(pVM, pTaskSet, pTask, j);
527	else
528	Assert(pvTaskOwner != pvOwner);
529	cLeft--;
530	}
531	}
532	}
533	else
534	break;
535	}
536
537	return VINF_SUCCESS;
538	}
539
540
541	/**
542	* Destroys the task @a hTask.
543	*
544	* @returns VBox status code.
545	* @param pVM The cross context VM structure.
546	* @param enmType The owner type.
547	* @param pvOwner The owner.
548	* @param hTask Handle to the task to destroy.
549	*/
550	VMMR3_INT_DECL(int) PDMR3TaskDestroySpecific(PVM pVM, PDMTASKTYPE enmType, void *pvOwner, PDMTASKHANDLE hTask)
551	{
552	/*
553	* Validate the input.
554	*/
555	AssertReturn(enmType >= PDMTASKTYPE_DEV && enmType <= PDMTASKTYPE_INTERNAL, VERR_INVALID_PARAMETER);
556	AssertPtrReturn(pvOwner, VERR_INVALID_POINTER);
557
558	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
559
560	size_t const iTask = hTask % RT_ELEMENTS(pVM->pdm.s.apTaskSets[0]->aTasks);
561	size_t const iTaskSet = hTask / RT_ELEMENTS(pVM->pdm.s.apTaskSets[0]->aTasks);
562	AssertReturn(iTaskSet < RT_ELEMENTS(pVM->pdm.s.apTaskSets), VERR_INVALID_HANDLE);
563	PPDMTASKSET const pTaskSet = pVM->pdm.s.apTaskSets[iTaskSet];
564	AssertPtrReturn(pTaskSet, VERR_INVALID_HANDLE);
565	AssertPtrReturn(pTaskSet->u32Magic == PDMTASKSET_MAGIC, VERR_INVALID_MAGIC);
566	PPDMTASK const pTask = &pTaskSet->aTasks[iTask];
567
568	VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT); /* implicit serialization by requiring EMT(0) */
569
570	AssertPtrReturn(pTask->pvOwner == pvOwner, VERR_NOT_OWNER);
571	AssertPtrReturn(pTask->enmType == enmType, VERR_NOT_OWNER);
572
573	/*
574	* Do the job.
575	*/
576	pdmR3TaskDestroyOne(pVM, pTaskSet, pTask, iTask);
577
578	return VINF_SUCCESS;
579	}
580
581
582	/**
583	* Destroys the internal task @a hTask.
584	*
585	* @returns VBox status code.
586	* @param pVM The cross context VM structure.
587	* @param hTask Handle to the task to destroy.
588	*/
589	VMMR3_INT_DECL(int) PDMR3TaskDestroyInternal(PVM pVM, PDMTASKHANDLE hTask)
590	{
591	return PDMR3TaskDestroySpecific(pVM, PDMTASKTYPE_INTERNAL, pVM, hTask);
592	}
593

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

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMR3Task.cpp@ 81406

Download in other formats: