PDMAsyncCompletionFileNormal.cpp@ 39070

Last change on this file since 39070 was 39070, checked in by vboxsync, 13 years ago
VMM,IPRT: -Wunused-function.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 64.3 KB

Line
1	/* $Id: PDMAsyncCompletionFileNormal.cpp 39070 2011-10-21 09:41:18Z vboxsync $ */
2	/** @file
3	* PDM Async I/O - Async File I/O manager.
4	*/
5
6	/*
7	* Copyright (C) 2006-2011 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	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
22	#define RT_STRICT
23	#include <iprt/types.h>
24	#include <iprt/asm.h>
25	#include <iprt/file.h>
26	#include <iprt/mem.h>
27	#include <iprt/string.h>
28	#include <iprt/assert.h>
29	#include <VBox/log.h>
30
31	#include "PDMAsyncCompletionFileInternal.h"
32
33	/** The update period for the I/O load statistics in ms. */
34	#define PDMACEPFILEMGR_LOAD_UPDATE_PERIOD 1000
35	/** Maximum number of requests a manager will handle. */
36	#define PDMACEPFILEMGR_REQS_STEP 512
37
38
39	/*******************************************************************************
40	* Internal functions *
41	*******************************************************************************/
42	static int pdmacFileAioMgrNormalProcessTaskList(PPDMACTASKFILE pTaskHead,
43	PPDMACEPFILEMGR pAioMgr,
44	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
45
46	static PPDMACTASKFILE pdmacFileAioMgrNormalRangeLockFree(PPDMACEPFILEMGR pAioMgr,
47	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
48	PPDMACFILERANGELOCK pRangeLock);
49
50	static void pdmacFileAioMgrNormalReqCompleteRc(PPDMACEPFILEMGR pAioMgr, RTFILEAIOREQ hReq,
51	int rc, size_t cbTransfered);
52
53
54	int pdmacFileAioMgrNormalInit(PPDMACEPFILEMGR pAioMgr)
55	{
56	pAioMgr->cRequestsActiveMax = PDMACEPFILEMGR_REQS_STEP;
57
58	int rc = RTFileAioCtxCreate(&pAioMgr->hAioCtx, RTFILEAIO_UNLIMITED_REQS);
59	if (rc == VERR_OUT_OF_RANGE)
60	rc = RTFileAioCtxCreate(&pAioMgr->hAioCtx, pAioMgr->cRequestsActiveMax);
61
62	if (RT_SUCCESS(rc))
63	{
64	/* Initialize request handle array. */
65	pAioMgr->iFreeEntry = 0;
66	pAioMgr->cReqEntries = pAioMgr->cRequestsActiveMax;
67	pAioMgr->pahReqsFree = (RTFILEAIOREQ )RTMemAllocZ(pAioMgr->cReqEntries sizeof(RTFILEAIOREQ));
68
69	if (pAioMgr->pahReqsFree)
70	{
71	/* Create the range lock memcache. */
72	rc = RTMemCacheCreate(&pAioMgr->hMemCacheRangeLocks, sizeof(PDMACFILERANGELOCK),
73	0, UINT32_MAX, NULL, NULL, NULL, 0);
74	if (RT_SUCCESS(rc))
75	return VINF_SUCCESS;
76
77	RTMemFree(pAioMgr->pahReqsFree);
78	}
79	else
80	{
81	RTFileAioCtxDestroy(pAioMgr->hAioCtx);
82	rc = VERR_NO_MEMORY;
83	}
84	}
85
86	return rc;
87	}
88
89	void pdmacFileAioMgrNormalDestroy(PPDMACEPFILEMGR pAioMgr)
90	{
91	RTFileAioCtxDestroy(pAioMgr->hAioCtx);
92
93	while (pAioMgr->iFreeEntry > 0)
94	{
95	pAioMgr->iFreeEntry--;
96	Assert(pAioMgr->pahReqsFree[pAioMgr->iFreeEntry] != NIL_RTFILEAIOREQ);
97	RTFileAioReqDestroy(pAioMgr->pahReqsFree[pAioMgr->iFreeEntry]);
98	}
99
100	RTMemFree(pAioMgr->pahReqsFree);
101	RTMemCacheDestroy(pAioMgr->hMemCacheRangeLocks);
102	}
103
104	#if 0 /* currently unused */
105	/**
106	* Sorts the endpoint list with insertion sort.
107	*/
108	static void pdmacFileAioMgrNormalEndpointsSortByLoad(PPDMACEPFILEMGR pAioMgr)
109	{
110	PPDMASYNCCOMPLETIONENDPOINTFILE pEpPrev, pEpCurr, pEpNextToSort;
111
112	pEpPrev = pAioMgr->pEndpointsHead;
113	pEpCurr = pEpPrev->AioMgr.pEndpointNext;
114
115	while (pEpCurr)
116	{
117	/* Remember the next element to sort because the list might change. */
118	pEpNextToSort = pEpCurr->AioMgr.pEndpointNext;
119
120	/* Unlink the current element from the list. */
121	PPDMASYNCCOMPLETIONENDPOINTFILE pPrev = pEpCurr->AioMgr.pEndpointPrev;
122	PPDMASYNCCOMPLETIONENDPOINTFILE pNext = pEpCurr->AioMgr.pEndpointNext;
123
124	if (pPrev)
125	pPrev->AioMgr.pEndpointNext = pNext;
126	else
127	pAioMgr->pEndpointsHead = pNext;
128
129	if (pNext)
130	pNext->AioMgr.pEndpointPrev = pPrev;
131
132	/* Go back until we reached the place to insert the current endpoint into. */
133	while (pEpPrev && (pEpPrev->AioMgr.cReqsPerSec < pEpCurr->AioMgr.cReqsPerSec))
134	pEpPrev = pEpPrev->AioMgr.pEndpointPrev;
135
136	/* Link the endpoint into the list. */
137	if (pEpPrev)
138	pNext = pEpPrev->AioMgr.pEndpointNext;
139	else
140	pNext = pAioMgr->pEndpointsHead;
141
142	pEpCurr->AioMgr.pEndpointNext = pNext;
143	pEpCurr->AioMgr.pEndpointPrev = pEpPrev;
144
145	if (pNext)
146	pNext->AioMgr.pEndpointPrev = pEpCurr;
147
148	if (pEpPrev)
149	pEpPrev->AioMgr.pEndpointNext = pEpCurr;
150	else
151	pAioMgr->pEndpointsHead = pEpCurr;
152
153	pEpCurr = pEpNextToSort;
154	}
155
156	#ifdef DEBUG
157	/* Validate sorting algorithm */
158	unsigned cEndpoints = 0;
159	pEpCurr = pAioMgr->pEndpointsHead;
160
161	AssertMsg(pEpCurr, ("No endpoint in the list?\n"));
162	AssertMsg(!pEpCurr->AioMgr.pEndpointPrev, ("First element in the list points to previous element\n"));
163
164	while (pEpCurr)
165	{
166	cEndpoints++;
167
168	PPDMASYNCCOMPLETIONENDPOINTFILE pNext = pEpCurr->AioMgr.pEndpointNext;
169	PPDMASYNCCOMPLETIONENDPOINTFILE pPrev = pEpCurr->AioMgr.pEndpointPrev;
170
171	Assert(!pNext \|\| pNext->AioMgr.cReqsPerSec <= pEpCurr->AioMgr.cReqsPerSec);
172	Assert(!pPrev \|\| pPrev->AioMgr.cReqsPerSec >= pEpCurr->AioMgr.cReqsPerSec);
173
174	pEpCurr = pNext;
175	}
176
177	AssertMsg(cEndpoints == pAioMgr->cEndpoints, ("Endpoints lost during sort!\n"));
178
179	#endif
180	}
181	#endif /* currently unused */
182
183	/**
184	* Removes an endpoint from the currently assigned manager.
185	*
186	* @returns TRUE if there are still requests pending on the current manager for this endpoint.
187	* FALSE otherwise.
188	* @param pEndpointRemove The endpoint to remove.
189	*/
190	static bool pdmacFileAioMgrNormalRemoveEndpoint(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointRemove)
191	{
192	PPDMASYNCCOMPLETIONENDPOINTFILE pPrev = pEndpointRemove->AioMgr.pEndpointPrev;
193	PPDMASYNCCOMPLETIONENDPOINTFILE pNext = pEndpointRemove->AioMgr.pEndpointNext;
194	PPDMACEPFILEMGR pAioMgr = pEndpointRemove->pAioMgr;
195
196	pAioMgr->cEndpoints--;
197
198	if (pPrev)
199	pPrev->AioMgr.pEndpointNext = pNext;
200	else
201	pAioMgr->pEndpointsHead = pNext;
202
203	if (pNext)
204	pNext->AioMgr.pEndpointPrev = pPrev;
205
206	/* Make sure that there is no request pending on this manager for the endpoint. */
207	if (!pEndpointRemove->AioMgr.cRequestsActive)
208	{
209	Assert(!pEndpointRemove->pFlushReq);
210
211	/* Reopen the file so that the new endpoint can re-associate with the file */
212	RTFileClose(pEndpointRemove->hFile);
213	int rc = RTFileOpen(&pEndpointRemove->hFile, pEndpointRemove->Core.pszUri, pEndpointRemove->fFlags);
214	AssertRC(rc);
215	return false;
216	}
217
218	return true;
219	}
220
221	#if 0 /* currently unused */
222
223	static bool pdmacFileAioMgrNormalIsBalancePossible(PPDMACEPFILEMGR pAioMgr)
224	{
225	/* Balancing doesn't make sense with only one endpoint. */
226	if (pAioMgr->cEndpoints == 1)
227	return false;
228
229	/* Doesn't make sens to move endpoints if only one produces the whole load */
230	unsigned cEndpointsWithLoad = 0;
231
232	PPDMASYNCCOMPLETIONENDPOINTFILE pCurr = pAioMgr->pEndpointsHead;
233
234	while (pCurr)
235	{
236	if (pCurr->AioMgr.cReqsPerSec)
237	cEndpointsWithLoad++;
238
239	pCurr = pCurr->AioMgr.pEndpointNext;
240	}
241
242	return (cEndpointsWithLoad > 1);
243	}
244
245	/**
246	* Creates a new I/O manager and spreads the I/O load of the endpoints
247	* between the given I/O manager and the new one.
248	*
249	* @returns nothing.
250	* @param pAioMgr The I/O manager with high I/O load.
251	*/
252	static void pdmacFileAioMgrNormalBalanceLoad(PPDMACEPFILEMGR pAioMgr)
253	{
254	/*
255	* Check if balancing would improve the situation.
256	*/
257	if (pdmacFileAioMgrNormalIsBalancePossible(pAioMgr))
258	{
259	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pAioMgr->pEndpointsHead->Core.pEpClass;
260	PPDMACEPFILEMGR pAioMgrNew = NULL;
261
262	int rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgrNew, PDMACEPFILEMGRTYPE_ASYNC);
263	if (RT_SUCCESS(rc))
264	{
265	/* We will sort the list by request count per second. */
266	pdmacFileAioMgrNormalEndpointsSortByLoad(pAioMgr);
267
268	/* Now move some endpoints to the new manager. */
269	unsigned cReqsHere = pAioMgr->pEndpointsHead->AioMgr.cReqsPerSec;
270	unsigned cReqsOther = 0;
271	PPDMASYNCCOMPLETIONENDPOINTFILE pCurr = pAioMgr->pEndpointsHead->AioMgr.pEndpointNext;
272
273	while (pCurr)
274	{
275	if (cReqsHere <= cReqsOther)
276	{
277	/*
278	* The other manager has more requests to handle now.
279	* We will keep the current endpoint.
280	*/
281	Log(("Keeping endpoint %#p{%s} with %u reqs/s\n", pCurr->Core.pszUri, pCurr->AioMgr.cReqsPerSec));
282	cReqsHere += pCurr->AioMgr.cReqsPerSec;
283	pCurr = pCurr->AioMgr.pEndpointNext;
284	}
285	else
286	{
287	/* Move to other endpoint. */
288	Log(("Moving endpoint %#p{%s} with %u reqs/s to other manager\n", pCurr, pCurr->Core.pszUri, pCurr->AioMgr.cReqsPerSec));
289	cReqsOther += pCurr->AioMgr.cReqsPerSec;
290
291	PPDMASYNCCOMPLETIONENDPOINTFILE pMove = pCurr;
292
293	pCurr = pCurr->AioMgr.pEndpointNext;
294
295	bool fReqsPending = pdmacFileAioMgrNormalRemoveEndpoint(pMove);
296
297	if (fReqsPending)
298	{
299	pMove->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_REMOVING;
300	pMove->AioMgr.fMoving = true;
301	pMove->AioMgr.pAioMgrDst = pAioMgrNew;
302	}
303	else
304	{
305	pMove->AioMgr.fMoving = false;
306	pMove->AioMgr.pAioMgrDst = NULL;
307	pdmacFileAioMgrAddEndpoint(pAioMgrNew, pMove);
308	}
309	}
310	}
311	}
312	else
313	{
314	/* Don't process further but leave a log entry about reduced performance. */
315	LogRel(("AIOMgr: Could not create new I/O manager (rc=%Rrc). Expect reduced performance\n", rc));
316	}
317	}
318	else
319	Log(("AIOMgr: Load balancing would not improve anything\n"));
320	}
321
322	#endif /* unused */
323
324	/**
325	* Increase the maximum number of active requests for the given I/O manager.
326	*
327	* @returns VBox status code.
328	* @param pAioMgr The I/O manager to grow.
329	*/
330	static int pdmacFileAioMgrNormalGrow(PPDMACEPFILEMGR pAioMgr)
331	{
332	LogFlowFunc(("pAioMgr=%#p\n", pAioMgr));
333
334	AssertMsg( pAioMgr->enmState == PDMACEPFILEMGRSTATE_GROWING
335	&& !pAioMgr->cRequestsActive,
336	("Invalid state of the I/O manager\n"));
337
338	#ifdef RT_OS_WINDOWS
339	/*
340	* Reopen the files of all assigned endpoints first so we can assign them to the new
341	* I/O context.
342	*/
343	PPDMASYNCCOMPLETIONENDPOINTFILE pCurr = pAioMgr->pEndpointsHead;
344
345	while (pCurr)
346	{
347	RTFileClose(pCurr->hFile);
348	int rc2 = RTFileOpen(&pCurr->hFile, pCurr->Core.pszUri, pCurr->fFlags); AssertRC(rc2);
349
350	pCurr = pCurr->AioMgr.pEndpointNext;
351	}
352	#endif
353
354	/* Create the new bigger context. */
355	pAioMgr->cRequestsActiveMax += PDMACEPFILEMGR_REQS_STEP;
356
357	RTFILEAIOCTX hAioCtxNew = NIL_RTFILEAIOCTX;
358	int rc = RTFileAioCtxCreate(&hAioCtxNew, RTFILEAIO_UNLIMITED_REQS);
359	if (rc == VERR_OUT_OF_RANGE)
360	rc = RTFileAioCtxCreate(&hAioCtxNew, pAioMgr->cRequestsActiveMax);
361
362	if (RT_SUCCESS(rc))
363	{
364	/* Close the old context. */
365	rc = RTFileAioCtxDestroy(pAioMgr->hAioCtx);
366	AssertRC(rc); /** @todo r=bird: Ignoring error code, will propagate. */
367
368	pAioMgr->hAioCtx = hAioCtxNew;
369
370	/* Create a new I/O task handle array */
371	uint32_t cReqEntriesNew = pAioMgr->cRequestsActiveMax + 1;
372	RTFILEAIOREQ pahReqNew = (RTFILEAIOREQ )RTMemAllocZ(cReqEntriesNew * sizeof(RTFILEAIOREQ));
373
374	if (pahReqNew)
375	{
376	/* Copy the cached request handles. */
377	for (uint32_t iReq = 0; iReq < pAioMgr->cReqEntries; iReq++)
378	pahReqNew[iReq] = pAioMgr->pahReqsFree[iReq];
379
380	RTMemFree(pAioMgr->pahReqsFree);
381	pAioMgr->pahReqsFree = pahReqNew;
382	pAioMgr->cReqEntries = cReqEntriesNew;
383	LogFlowFunc(("I/O manager increased to handle a maximum of %u requests\n",
384	pAioMgr->cRequestsActiveMax));
385	}
386	else
387	rc = VERR_NO_MEMORY;
388	}
389
390	#ifdef RT_OS_WINDOWS
391	/* Assign the file to the new context. */
392	pCurr = pAioMgr->pEndpointsHead;
393	while (pCurr)
394	{
395	rc = RTFileAioCtxAssociateWithFile(pAioMgr->hAioCtx, pCurr->hFile);
396	AssertRC(rc); /** @todo r=bird: Ignoring error code, will propagate. */
397
398	pCurr = pCurr->AioMgr.pEndpointNext;
399	}
400	#endif
401
402	if (RT_FAILURE(rc))
403	{
404	LogFlow(("Increasing size of the I/O manager failed with rc=%Rrc\n", rc));
405	pAioMgr->cRequestsActiveMax -= PDMACEPFILEMGR_REQS_STEP;
406	}
407
408	pAioMgr->enmState = PDMACEPFILEMGRSTATE_RUNNING;
409	LogFlowFunc(("returns rc=%Rrc\n", rc));
410
411	return rc;
412	}
413
414	/**
415	* Checks if a given status code is fatal.
416	* Non fatal errors can be fixed by migrating the endpoint to a
417	* failsafe manager.
418	*
419	* @returns true If the error is fatal and migrating to a failsafe manager doesn't help
420	* false If the error can be fixed by a migration. (image on NFS disk for example)
421	* @param rcReq The status code to check.
422	*/
423	DECLINLINE(bool) pdmacFileAioMgrNormalRcIsFatal(int rcReq)
424	{
425	return rcReq == VERR_DEV_IO_ERROR
426	\|\| rcReq == VERR_FILE_IO_ERROR
427	\|\| rcReq == VERR_DISK_IO_ERROR
428	\|\| rcReq == VERR_DISK_FULL
429	\|\| rcReq == VERR_FILE_TOO_BIG;
430	}
431
432	/**
433	* Error handler which will create the failsafe managers and destroy the failed I/O manager.
434	*
435	* @returns VBox status code
436	* @param pAioMgr The I/O manager the error occurred on.
437	* @param rc The error code.
438	*/
439	static int pdmacFileAioMgrNormalErrorHandler(PPDMACEPFILEMGR pAioMgr, int rc, RT_SRC_POS_DECL)
440	{
441	LogRel(("AIOMgr: I/O manager %#p encountered a critical error (rc=%Rrc) during operation. Falling back to failsafe mode. Expect reduced performance\n",
442	pAioMgr, rc));
443	LogRel(("AIOMgr: Error happened in %s:(%u){%s}\n", RT_SRC_POS_ARGS));
444	LogRel(("AIOMgr: Please contact the product vendor\n"));
445
446	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pAioMgr->pEndpointsHead->Core.pEpClass;
447
448	pAioMgr->enmState = PDMACEPFILEMGRSTATE_FAULT;
449	ASMAtomicWriteU32((volatile uint32_t *)&pEpClassFile->enmMgrTypeOverride, PDMACEPFILEMGRTYPE_SIMPLE);
450
451	AssertMsgFailed(("Implement\n"));
452	return VINF_SUCCESS;
453	}
454
455	/**
456	* Put a list of tasks in the pending request list of an endpoint.
457	*/
458	DECLINLINE(void) pdmacFileAioMgrEpAddTaskList(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTaskHead)
459	{
460	/* Add the rest of the tasks to the pending list */
461	if (!pEndpoint->AioMgr.pReqsPendingHead)
462	{
463	Assert(!pEndpoint->AioMgr.pReqsPendingTail);
464	pEndpoint->AioMgr.pReqsPendingHead = pTaskHead;
465	}
466	else
467	{
468	Assert(pEndpoint->AioMgr.pReqsPendingTail);
469	pEndpoint->AioMgr.pReqsPendingTail->pNext = pTaskHead;
470	}
471
472	/* Update the tail. */
473	while (pTaskHead->pNext)
474	pTaskHead = pTaskHead->pNext;
475
476	pEndpoint->AioMgr.pReqsPendingTail = pTaskHead;
477	pTaskHead->pNext = NULL;
478	}
479
480	/**
481	* Put one task in the pending request list of an endpoint.
482	*/
483	DECLINLINE(void) pdmacFileAioMgrEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask)
484	{
485	/* Add the rest of the tasks to the pending list */
486	if (!pEndpoint->AioMgr.pReqsPendingHead)
487	{
488	Assert(!pEndpoint->AioMgr.pReqsPendingTail);
489	pEndpoint->AioMgr.pReqsPendingHead = pTask;
490	}
491	else
492	{
493	Assert(pEndpoint->AioMgr.pReqsPendingTail);
494	pEndpoint->AioMgr.pReqsPendingTail->pNext = pTask;
495	}
496
497	pEndpoint->AioMgr.pReqsPendingTail = pTask;
498	pTask->pNext = NULL;
499	}
500
501	/**
502	* Allocates a async I/O request.
503	*
504	* @returns Handle to the request.
505	* @param pAioMgr The I/O manager.
506	*/
507	static RTFILEAIOREQ pdmacFileAioMgrNormalRequestAlloc(PPDMACEPFILEMGR pAioMgr)
508	{
509	/* Get a request handle. */
510	RTFILEAIOREQ hReq;
511	if (pAioMgr->iFreeEntry > 0)
512	{
513	pAioMgr->iFreeEntry--;
514	hReq = pAioMgr->pahReqsFree[pAioMgr->iFreeEntry];
515	pAioMgr->pahReqsFree[pAioMgr->iFreeEntry] = NIL_RTFILEAIOREQ;
516	Assert(hReq != NIL_RTFILEAIOREQ);
517	}
518	else
519	{
520	int rc = RTFileAioReqCreate(&hReq);
521	AssertRCReturn(rc, NIL_RTFILEAIOREQ);
522	}
523
524	return hReq;
525	}
526
527	/**
528	* Frees a async I/O request handle.
529	*
530	* @returns nothing.
531	* @param pAioMgr The I/O manager.
532	* @param hReq The I/O request handle to free.
533	*/
534	static void pdmacFileAioMgrNormalRequestFree(PPDMACEPFILEMGR pAioMgr, RTFILEAIOREQ hReq)
535	{
536	Assert(pAioMgr->iFreeEntry < pAioMgr->cReqEntries);
537	Assert(pAioMgr->pahReqsFree[pAioMgr->iFreeEntry] == NIL_RTFILEAIOREQ);
538
539	pAioMgr->pahReqsFree[pAioMgr->iFreeEntry] = hReq;
540	pAioMgr->iFreeEntry++;
541	}
542
543	/**
544	* Wrapper around RTFIleAioCtxSubmit() which is also doing error handling.
545	*/
546	static int pdmacFileAioMgrNormalReqsEnqueue(PPDMACEPFILEMGR pAioMgr,
547	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
548	PRTFILEAIOREQ pahReqs, unsigned cReqs)
549	{
550	pAioMgr->cRequestsActive += cReqs;
551	pEndpoint->AioMgr.cRequestsActive += cReqs;
552
553	LogFlow(("Enqueuing %d requests. I/O manager has a total of %d active requests now\n", cReqs, pAioMgr->cRequestsActive));
554	LogFlow(("Endpoint has a total of %d active requests now\n", pEndpoint->AioMgr.cRequestsActive));
555
556	int rc = RTFileAioCtxSubmit(pAioMgr->hAioCtx, pahReqs, cReqs);
557	if (RT_FAILURE(rc))
558	{
559	if (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES)
560	{
561	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
562
563	/* Append any not submitted task to the waiting list. */
564	for (size_t i = 0; i < cReqs; i++)
565	{
566	int rcReq = RTFileAioReqGetRC(pahReqs[i], NULL);
567
568	if (rcReq != VERR_FILE_AIO_IN_PROGRESS)
569	{
570	PPDMACTASKFILE pTask = (PPDMACTASKFILE)RTFileAioReqGetUser(pahReqs[i]);
571
572	Assert(pTask->hReq == pahReqs[i]);
573	pdmacFileAioMgrEpAddTask(pEndpoint, pTask);
574	pAioMgr->cRequestsActive--;
575	pEndpoint->AioMgr.cRequestsActive--;
576
577	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_FLUSH)
578	{
579	/* Clear the pending flush */
580	Assert(pEndpoint->pFlushReq == pTask);
581	pEndpoint->pFlushReq = NULL;
582	}
583	}
584	}
585
586	pAioMgr->cRequestsActiveMax = pAioMgr->cRequestsActive;
587
588	/* Print an entry in the release log */
589	if (RT_UNLIKELY(!pEpClass->fOutOfResourcesWarningPrinted))
590	{
591	pEpClass->fOutOfResourcesWarningPrinted = true;
592	LogRel(("AIOMgr: Host limits number of active IO requests to %u. Expect a performance impact.\n",
593	pAioMgr->cRequestsActive));
594	}
595
596	LogFlow(("Removed requests. I/O manager has a total of %u active requests now\n", pAioMgr->cRequestsActive));
597	LogFlow(("Endpoint has a total of %u active requests now\n", pEndpoint->AioMgr.cRequestsActive));
598	rc = VINF_SUCCESS;
599	}
600	else /* Another kind of error happened (full disk, ...) */
601	{
602	/* An error happened. Find out which one caused the error and resubmit all other tasks. */
603	for (size_t i = 0; i < cReqs; i++)
604	{
605	int rcReq = RTFileAioReqGetRC(pahReqs[i], NULL);
606
607	if (rcReq == VERR_FILE_AIO_NOT_SUBMITTED)
608	{
609	/* We call ourself again to do any error handling which might come up now. */
610	rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, &pahReqs[i], 1);
611	AssertRC(rc);
612	}
613	else if (rcReq != VERR_FILE_AIO_IN_PROGRESS)
614	pdmacFileAioMgrNormalReqCompleteRc(pAioMgr, pahReqs[i], rcReq, 0);
615	}
616
617
618	if ( pEndpoint->pFlushReq
619	&& !pAioMgr->cRequestsActive
620	&& !pEndpoint->fAsyncFlushSupported)
621	{
622	/*
623	* Complete a pending flush if we don't have requests enqueued and the host doesn't support
624	* the async flush API.
625	* Happens only if this we just noticed that this is not supported
626	* and the only active request was a flush.
627	*/
628	PPDMACTASKFILE pFlush = pEndpoint->pFlushReq;
629	pEndpoint->pFlushReq = NULL;
630	pFlush->pfnCompleted(pFlush, pFlush->pvUser, VINF_SUCCESS);
631	pdmacFileTaskFree(pEndpoint, pFlush);
632	}
633	}
634	}
635
636	return VINF_SUCCESS;
637	}
638
639	static bool pdmacFileAioMgrNormalIsRangeLocked(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
640	RTFOFF offStart, size_t cbRange,
641	PPDMACTASKFILE pTask)
642	{
643	AssertMsg( pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
644	\|\| pTask->enmTransferType == PDMACTASKFILETRANSFER_READ,
645	("Invalid task type %d\n", pTask->enmTransferType));
646
647	PPDMACFILERANGELOCK pRangeLock;
648	pRangeLock = (PPDMACFILERANGELOCK)RTAvlrFileOffsetRangeGet(pEndpoint->AioMgr.pTreeRangesLocked, offStart);
649	if (!pRangeLock)
650	{
651	pRangeLock = (PPDMACFILERANGELOCK)RTAvlrFileOffsetGetBestFit(pEndpoint->AioMgr.pTreeRangesLocked, offStart, true);
652	/* Check if we intersect with the range. */
653	if ( !pRangeLock
654	\|\| !( (pRangeLock->Core.Key) <= (offStart + (RTFOFF)cbRange - 1)
655	&& (pRangeLock->Core.KeyLast) >= offStart))
656	{
657	pRangeLock = NULL; /* False alarm */
658	}
659	}
660
661	/* Check whether we have one of the situations explained below */
662	if ( pRangeLock
663	#if 0 /** @todo later. For now we will just block all requests if they interfere */
664	&& ( (pRangeLock->fReadLock && pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
665	\|\| (!pRangeLock->fReadLock)
666	#endif
667	)
668	{
669	/* Add to the list. */
670	pTask->pNext = NULL;
671
672	if (!pRangeLock->pWaitingTasksHead)
673	{
674	Assert(!pRangeLock->pWaitingTasksTail);
675	pRangeLock->pWaitingTasksHead = pTask;
676	pRangeLock->pWaitingTasksTail = pTask;
677	}
678	else
679	{
680	AssertPtr(pRangeLock->pWaitingTasksTail);
681	pRangeLock->pWaitingTasksTail->pNext = pTask;
682	pRangeLock->pWaitingTasksTail = pTask;
683	}
684	return true;
685	}
686
687	return false;
688	}
689
690	static int pdmacFileAioMgrNormalRangeLock(PPDMACEPFILEMGR pAioMgr,
691	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
692	RTFOFF offStart, size_t cbRange,
693	PPDMACTASKFILE pTask)
694	{
695	AssertMsg(!pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, offStart, cbRange, pTask),
696	("Range is already locked offStart=%RTfoff cbRange=%u\n",
697	offStart, cbRange));
698
699	PPDMACFILERANGELOCK pRangeLock = (PPDMACFILERANGELOCK)RTMemCacheAlloc(pAioMgr->hMemCacheRangeLocks);
700	if (!pRangeLock)
701	return VERR_NO_MEMORY;
702
703	/* Init the lock. */
704	pRangeLock->Core.Key = offStart;
705	pRangeLock->Core.KeyLast = offStart + cbRange - 1;
706	pRangeLock->cRefs = 1;
707	pRangeLock->fReadLock = pTask->enmTransferType == PDMACTASKFILETRANSFER_READ;
708	pRangeLock->pWaitingTasksHead = NULL;
709	pRangeLock->pWaitingTasksTail = NULL;
710
711	bool fInserted = RTAvlrFileOffsetInsert(pEndpoint->AioMgr.pTreeRangesLocked, &pRangeLock->Core);
712	AssertMsg(fInserted, ("Range lock was not inserted!\n"));
713
714	/* Let the task point to its lock. */
715	pTask->pRangeLock = pRangeLock;
716
717	return VINF_SUCCESS;
718	}
719
720	static PPDMACTASKFILE pdmacFileAioMgrNormalRangeLockFree(PPDMACEPFILEMGR pAioMgr,
721	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
722	PPDMACFILERANGELOCK pRangeLock)
723	{
724	PPDMACTASKFILE pTasksWaitingHead;
725
726	AssertPtr(pRangeLock);
727	Assert(pRangeLock->cRefs == 1);
728
729	RTAvlrFileOffsetRemove(pEndpoint->AioMgr.pTreeRangesLocked, pRangeLock->Core.Key);
730	pTasksWaitingHead = pRangeLock->pWaitingTasksHead;
731	pRangeLock->pWaitingTasksHead = NULL;
732	pRangeLock->pWaitingTasksTail = NULL;
733	RTMemCacheFree(pAioMgr->hMemCacheRangeLocks, pRangeLock);
734
735	return pTasksWaitingHead;
736	}
737
738	static int pdmacFileAioMgrNormalTaskPrepareBuffered(PPDMACEPFILEMGR pAioMgr,
739	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
740	PPDMACTASKFILE pTask, PRTFILEAIOREQ phReq)
741	{
742	AssertMsg( pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
743	\|\| (uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) <= pEndpoint->cbFile,
744	("Read exceeds file size offStart=%RTfoff cbToTransfer=%d cbFile=%llu\n",
745	pTask->Off, pTask->DataSeg.cbSeg, pEndpoint->cbFile));
746
747	pTask->fPrefetch = false;
748	pTask->cbBounceBuffer = 0;
749
750	/*
751	* Before we start to setup the request we have to check whether there is a task
752	* already active which range intersects with ours. We have to defer execution
753	* of this task in two cases:
754	* - The pending task is a write and the current is either read or write
755	* - The pending task is a read and the current task is a write task.
756	*
757	* To check whether a range is currently "locked" we use the AVL tree where every pending task
758	* is stored by its file offset range. The current task will be added to the active task
759	* and will be executed when the active one completes. (The method below
760	* which checks whether a range is already used will add the task)
761	*
762	* This is necessary because of the requirement to align all requests to a 512 boundary
763	* which is enforced by the host OS (Linux and Windows atm). It is possible that
764	* we have to process unaligned tasks and need to align them using bounce buffers.
765	* While the data is fetched from the file another request might arrive writing to
766	* the same range. This will result in data corruption if both are executed concurrently.
767	*/
768	int rc = VINF_SUCCESS;
769	bool fLocked = pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, pTask->Off, pTask->DataSeg.cbSeg, pTask);
770	if (!fLocked)
771	{
772	/* Get a request handle. */
773	RTFILEAIOREQ hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
774	AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
775
776	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
777	{
778	/* Grow the file if needed. */
779	if (RT_UNLIKELY((uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) > pEndpoint->cbFile))
780	{
781	ASMAtomicWriteU64(&pEndpoint->cbFile, pTask->Off + pTask->DataSeg.cbSeg);
782	RTFileSetSize(pEndpoint->hFile, pTask->Off + pTask->DataSeg.cbSeg);
783	}
784
785	rc = RTFileAioReqPrepareWrite(hReq, pEndpoint->hFile,
786	pTask->Off, pTask->DataSeg.pvSeg,
787	pTask->DataSeg.cbSeg, pTask);
788	}
789	else
790	rc = RTFileAioReqPrepareRead(hReq, pEndpoint->hFile,
791	pTask->Off, pTask->DataSeg.pvSeg,
792	pTask->DataSeg.cbSeg, pTask);
793	AssertRC(rc);
794
795	rc = pdmacFileAioMgrNormalRangeLock(pAioMgr, pEndpoint, pTask->Off,
796	pTask->DataSeg.cbSeg,
797	pTask);
798
799	if (RT_SUCCESS(rc))
800	{
801	pTask->hReq = hReq;
802	*phReq = hReq;
803	}
804	}
805	else
806	LogFlow(("Task %#p was deferred because the access range is locked\n", pTask));
807
808	return rc;
809	}
810
811	static int pdmacFileAioMgrNormalTaskPrepareNonBuffered(PPDMACEPFILEMGR pAioMgr,
812	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
813	PPDMACTASKFILE pTask, PRTFILEAIOREQ phReq)
814	{
815	/*
816	* Check if the alignment requirements are met.
817	* Offset, transfer size and buffer address
818	* need to be on a 512 boundary.
819	*/
820	RTFOFF offStart = pTask->Off & ~(RTFOFF)(512-1);
821	size_t cbToTransfer = RT_ALIGN_Z(pTask->DataSeg.cbSeg + (pTask->Off - offStart), 512);
822	PDMACTASKFILETRANSFER enmTransferType = pTask->enmTransferType;
823
824	AssertMsg( pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
825	\|\| (uint64_t)(offStart + cbToTransfer) <= pEndpoint->cbFile,
826	("Read exceeds file size offStart=%RTfoff cbToTransfer=%d cbFile=%llu\n",
827	offStart, cbToTransfer, pEndpoint->cbFile));
828
829	pTask->fPrefetch = false;
830
831	/*
832	* Before we start to setup the request we have to check whether there is a task
833	* already active which range intersects with ours. We have to defer execution
834	* of this task in two cases:
835	* - The pending task is a write and the current is either read or write
836	* - The pending task is a read and the current task is a write task.
837	*
838	* To check whether a range is currently "locked" we use the AVL tree where every pending task
839	* is stored by its file offset range. The current task will be added to the active task
840	* and will be executed when the active one completes. (The method below
841	* which checks whether a range is already used will add the task)
842	*
843	* This is necessary because of the requirement to align all requests to a 512 boundary
844	* which is enforced by the host OS (Linux and Windows atm). It is possible that
845	* we have to process unaligned tasks and need to align them using bounce buffers.
846	* While the data is fetched from the file another request might arrive writing to
847	* the same range. This will result in data corruption if both are executed concurrently.
848	*/
849	int rc = VINF_SUCCESS;
850	bool fLocked = pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, offStart, cbToTransfer, pTask);
851	if (!fLocked)
852	{
853	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
854	void *pvBuf = pTask->DataSeg.pvSeg;
855
856	/* Get a request handle. */
857	RTFILEAIOREQ hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
858	AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
859
860	if ( RT_UNLIKELY(cbToTransfer != pTask->DataSeg.cbSeg)
861	\|\| RT_UNLIKELY(offStart != pTask->Off)
862	\|\| ((pEpClassFile->uBitmaskAlignment & (RTR3UINTPTR)pvBuf) != (RTR3UINTPTR)pvBuf))
863	{
864	LogFlow(("Using bounce buffer for task %#p cbToTransfer=%zd cbSeg=%zd offStart=%RTfoff off=%RTfoff\n",
865	pTask, cbToTransfer, pTask->DataSeg.cbSeg, offStart, pTask->Off));
866
867	/* Create bounce buffer. */
868	pTask->cbBounceBuffer = cbToTransfer;
869
870	AssertMsg(pTask->Off >= offStart, ("Overflow in calculation Off=%llu offStart=%llu\n",
871	pTask->Off, offStart));
872	pTask->offBounceBuffer = pTask->Off - offStart;
873
874	/** @todo: I think we need something like a RTMemAllocAligned method here.
875	* Current assumption is that the maximum alignment is 4096byte
876	* (GPT disk on Windows)
877	* so we can use RTMemPageAlloc here.
878	*/
879	pTask->pvBounceBuffer = RTMemPageAlloc(cbToTransfer);
880	if (RT_LIKELY(pTask->pvBounceBuffer))
881	{
882	pvBuf = pTask->pvBounceBuffer;
883
884	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
885	{
886	if ( RT_UNLIKELY(cbToTransfer != pTask->DataSeg.cbSeg)
887	\|\| RT_UNLIKELY(offStart != pTask->Off))
888	{
889	/* We have to fill the buffer first before we can update the data. */
890	LogFlow(("Prefetching data for task %#p\n", pTask));
891	pTask->fPrefetch = true;
892	enmTransferType = PDMACTASKFILETRANSFER_READ;
893	}
894	else
895	memcpy(pvBuf, pTask->DataSeg.pvSeg, pTask->DataSeg.cbSeg);
896	}
897	}
898	else
899	rc = VERR_NO_MEMORY;
900	}
901	else
902	pTask->cbBounceBuffer = 0;
903
904	if (RT_SUCCESS(rc))
905	{
906	AssertMsg((pEpClassFile->uBitmaskAlignment & (RTR3UINTPTR)pvBuf) == (RTR3UINTPTR)pvBuf,
907	("AIO: Alignment restrictions not met! pvBuf=%p uBitmaskAlignment=%p\n", pvBuf, pEpClassFile->uBitmaskAlignment));
908
909	if (enmTransferType == PDMACTASKFILETRANSFER_WRITE)
910	{
911	/* Grow the file if needed. */
912	if (RT_UNLIKELY((uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) > pEndpoint->cbFile))
913	{
914	ASMAtomicWriteU64(&pEndpoint->cbFile, pTask->Off + pTask->DataSeg.cbSeg);
915	RTFileSetSize(pEndpoint->hFile, pTask->Off + pTask->DataSeg.cbSeg);
916	}
917
918	rc = RTFileAioReqPrepareWrite(hReq, pEndpoint->hFile,
919	offStart, pvBuf, cbToTransfer, pTask);
920	}
921	else
922	rc = RTFileAioReqPrepareRead(hReq, pEndpoint->hFile,
923	offStart, pvBuf, cbToTransfer, pTask);
924	AssertRC(rc);
925
926	rc = pdmacFileAioMgrNormalRangeLock(pAioMgr, pEndpoint, offStart, cbToTransfer, pTask);
927
928	if (RT_SUCCESS(rc))
929	{
930	pTask->hReq = hReq;
931	*phReq = hReq;
932	}
933	else
934	{
935	/* Cleanup */
936	if (pTask->cbBounceBuffer)
937	RTMemPageFree(pTask->pvBounceBuffer, pTask->cbBounceBuffer);
938	}
939	}
940	}
941	else
942	LogFlow(("Task %#p was deferred because the access range is locked\n", pTask));
943
944	return rc;
945	}
946
947	static int pdmacFileAioMgrNormalProcessTaskList(PPDMACTASKFILE pTaskHead,
948	PPDMACEPFILEMGR pAioMgr,
949	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
950	{
951	RTFILEAIOREQ apReqs[20];
952	unsigned cRequests = 0;
953	int rc = VINF_SUCCESS;
954
955	AssertMsg(pEndpoint->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE,
956	("Trying to process request lists of a non active endpoint!\n"));
957
958	/* Go through the list and queue the requests until we get a flush request */
959	while ( pTaskHead
960	&& !pEndpoint->pFlushReq
961	&& (pAioMgr->cRequestsActive + cRequests < pAioMgr->cRequestsActiveMax)
962	&& RT_SUCCESS(rc))
963	{
964	RTMSINTERVAL msWhenNext;
965	PPDMACTASKFILE pCurr = pTaskHead;
966
967	if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
968	{
969	pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);
970	break;
971	}
972
973	pTaskHead = pTaskHead->pNext;
974
975	pCurr->pNext = NULL;
976
977	AssertMsg(VALID_PTR(pCurr->pEndpoint) && (pCurr->pEndpoint == pEndpoint),
978	("Endpoints do not match\n"));
979
980	switch (pCurr->enmTransferType)
981	{
982	case PDMACTASKFILETRANSFER_FLUSH:
983	{
984	/* If there is no data transfer request this flush request finished immediately. */
985	if (pEndpoint->fAsyncFlushSupported)
986	{
987	/* Issue a flush to the host. */
988	RTFILEAIOREQ hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
989	AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
990
991	LogFlow(("Flush request %#p\n", hReq));
992
993	rc = RTFileAioReqPrepareFlush(hReq, pEndpoint->hFile, pCurr);
994	if (RT_FAILURE(rc))
995	{
996	pEndpoint->fAsyncFlushSupported = false;
997	pdmacFileAioMgrNormalRequestFree(pAioMgr, hReq);
998	rc = VINF_SUCCESS; /* Fake success */
999	}
1000	else
1001	{
1002	pCurr->hReq = hReq;
1003	apReqs[cRequests] = hReq;
1004	pEndpoint->AioMgr.cReqsProcessed++;
1005	cRequests++;
1006	}
1007	}
1008
1009	if ( !pEndpoint->AioMgr.cRequestsActive
1010	&& !pEndpoint->fAsyncFlushSupported)
1011	{
1012	pCurr->pfnCompleted(pCurr, pCurr->pvUser, VINF_SUCCESS);
1013	pdmacFileTaskFree(pEndpoint, pCurr);
1014	}
1015	else
1016	{
1017	Assert(!pEndpoint->pFlushReq);
1018	pEndpoint->pFlushReq = pCurr;
1019	}
1020	break;
1021	}
1022	case PDMACTASKFILETRANSFER_READ:
1023	case PDMACTASKFILETRANSFER_WRITE:
1024	{
1025	RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
1026
1027	if (pCurr->hReq == NIL_RTFILEAIOREQ)
1028	{
1029	if (pEndpoint->enmBackendType == PDMACFILEEPBACKEND_BUFFERED)
1030	rc = pdmacFileAioMgrNormalTaskPrepareBuffered(pAioMgr, pEndpoint, pCurr, &hReq);
1031	else if (pEndpoint->enmBackendType == PDMACFILEEPBACKEND_NON_BUFFERED)
1032	rc = pdmacFileAioMgrNormalTaskPrepareNonBuffered(pAioMgr, pEndpoint, pCurr, &hReq);
1033	else
1034	AssertMsgFailed(("Invalid backend type %d\n", pEndpoint->enmBackendType));
1035
1036	AssertRC(rc);
1037	}
1038	else
1039	{
1040	LogFlow(("Task %#p has I/O request %#p already\n", pCurr, pCurr->hReq));
1041	hReq = pCurr->hReq;
1042	}
1043
1044	LogFlow(("Read/Write request %#p\n", hReq));
1045
1046	if (hReq != NIL_RTFILEAIOREQ)
1047	{
1048	apReqs[cRequests] = hReq;
1049	cRequests++;
1050	}
1051	break;
1052	}
1053	default:
1054	AssertMsgFailed(("Invalid transfer type %d\n", pCurr->enmTransferType));
1055	} /* switch transfer type */
1056
1057	/* Queue the requests if the array is full. */
1058	if (cRequests == RT_ELEMENTS(apReqs))
1059	{
1060	rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, apReqs, cRequests);
1061	cRequests = 0;
1062	AssertMsg(RT_SUCCESS(rc) \|\| (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
1063	("Unexpected return code\n"));
1064	}
1065	}
1066
1067	if (cRequests)
1068	{
1069	rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, apReqs, cRequests);
1070	AssertMsg(RT_SUCCESS(rc) \|\| (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
1071	("Unexpected return code rc=%Rrc\n", rc));
1072	}
1073
1074	if (pTaskHead)
1075	{
1076	/* Add the rest of the tasks to the pending list */
1077	pdmacFileAioMgrEpAddTaskList(pEndpoint, pTaskHead);
1078
1079	if (RT_UNLIKELY( pAioMgr->cRequestsActiveMax == pAioMgr->cRequestsActive
1080	&& !pEndpoint->pFlushReq))
1081	{
1082	#if 0
1083	/*
1084	* The I/O manager has no room left for more requests
1085	* but there are still requests to process.
1086	* Create a new I/O manager and let it handle some endpoints.
1087	*/
1088	pdmacFileAioMgrNormalBalanceLoad(pAioMgr);
1089	#else
1090	/* Grow the I/O manager */
1091	pAioMgr->enmState = PDMACEPFILEMGRSTATE_GROWING;
1092	#endif
1093	}
1094	}
1095
1096	/* Insufficient resources are not fatal. */
1097	if (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES)
1098	rc = VINF_SUCCESS;
1099
1100	return rc;
1101	}
1102
1103	/**
1104	* Adds all pending requests for the given endpoint
1105	* until a flush request is encountered or there is no
1106	* request anymore.
1107	*
1108	* @returns VBox status code.
1109	* @param pAioMgr The async I/O manager for the endpoint
1110	* @param pEndpoint The endpoint to get the requests from.
1111	*/
1112	static int pdmacFileAioMgrNormalQueueReqs(PPDMACEPFILEMGR pAioMgr,
1113	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
1114	{
1115	int rc = VINF_SUCCESS;
1116	PPDMACTASKFILE pTasksHead = NULL;
1117
1118	AssertMsg(pEndpoint->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE,
1119	("Trying to process request lists of a non active endpoint!\n"));
1120
1121	Assert(!pEndpoint->pFlushReq);
1122
1123	/* Check the pending list first */
1124	if (pEndpoint->AioMgr.pReqsPendingHead)
1125	{
1126	LogFlow(("Queuing pending requests first\n"));
1127
1128	pTasksHead = pEndpoint->AioMgr.pReqsPendingHead;
1129	/*
1130	* Clear the list as the processing routine will insert them into the list
1131	* again if it gets a flush request.
1132	*/
1133	pEndpoint->AioMgr.pReqsPendingHead = NULL;
1134	pEndpoint->AioMgr.pReqsPendingTail = NULL;
1135	rc = pdmacFileAioMgrNormalProcessTaskList(pTasksHead, pAioMgr, pEndpoint);
1136	AssertRC(rc); /** @todo r=bird: status code potentially overwritten. */
1137	}
1138
1139	if (!pEndpoint->pFlushReq && !pEndpoint->AioMgr.pReqsPendingHead)
1140	{
1141	/* Now the request queue. */
1142	pTasksHead = pdmacFileEpGetNewTasks(pEndpoint);
1143	if (pTasksHead)
1144	{
1145	rc = pdmacFileAioMgrNormalProcessTaskList(pTasksHead, pAioMgr, pEndpoint);
1146	AssertRC(rc);
1147	}
1148	}
1149
1150	return rc;
1151	}
1152
1153	static int pdmacFileAioMgrNormalProcessBlockingEvent(PPDMACEPFILEMGR pAioMgr)
1154	{
1155	int rc = VINF_SUCCESS;
1156	bool fNotifyWaiter = false;
1157
1158	LogFlowFunc((": Enter\n"));
1159
1160	Assert(pAioMgr->fBlockingEventPending);
1161
1162	switch (pAioMgr->enmBlockingEvent)
1163	{
1164	case PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT:
1165	{
1166	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointNew = ASMAtomicReadPtrT(&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint, PPDMASYNCCOMPLETIONENDPOINTFILE);
1167	AssertMsg(VALID_PTR(pEndpointNew), ("Adding endpoint event without a endpoint to add\n"));
1168
1169	pEndpointNew->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
1170
1171	pEndpointNew->AioMgr.pEndpointNext = pAioMgr->pEndpointsHead;
1172	pEndpointNew->AioMgr.pEndpointPrev = NULL;
1173	if (pAioMgr->pEndpointsHead)
1174	pAioMgr->pEndpointsHead->AioMgr.pEndpointPrev = pEndpointNew;
1175	pAioMgr->pEndpointsHead = pEndpointNew;
1176
1177	/* Assign the completion point to this file. */
1178	rc = RTFileAioCtxAssociateWithFile(pAioMgr->hAioCtx, pEndpointNew->hFile);
1179	fNotifyWaiter = true;
1180	pAioMgr->cEndpoints++;
1181	break;
1182	}
1183	case PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT:
1184	{
1185	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointRemove = ASMAtomicReadPtrT(&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint, PPDMASYNCCOMPLETIONENDPOINTFILE);
1186	AssertMsg(VALID_PTR(pEndpointRemove), ("Removing endpoint event without a endpoint to remove\n"));
1187
1188	pEndpointRemove->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_REMOVING;
1189	fNotifyWaiter = !pdmacFileAioMgrNormalRemoveEndpoint(pEndpointRemove);
1190	break;
1191	}
1192	case PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT:
1193	{
1194	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointClose = ASMAtomicReadPtrT(&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint, PPDMASYNCCOMPLETIONENDPOINTFILE);
1195	AssertMsg(VALID_PTR(pEndpointClose), ("Close endpoint event without a endpoint to close\n"));
1196
1197	if (pEndpointClose->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE)
1198	{
1199	LogFlowFunc((": Closing endpoint %#p{%s}\n", pEndpointClose, pEndpointClose->Core.pszUri));
1200
1201	/* Make sure all tasks finished. Process the queues a last time first. */
1202	rc = pdmacFileAioMgrNormalQueueReqs(pAioMgr, pEndpointClose);
1203	AssertRC(rc);
1204
1205	pEndpointClose->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_CLOSING;
1206	fNotifyWaiter = !pdmacFileAioMgrNormalRemoveEndpoint(pEndpointClose);
1207	}
1208	else if ( (pEndpointClose->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_CLOSING)
1209	&& (!pEndpointClose->AioMgr.cRequestsActive))
1210	fNotifyWaiter = true;
1211	break;
1212	}
1213	case PDMACEPFILEAIOMGRBLOCKINGEVENT_SHUTDOWN:
1214	{
1215	pAioMgr->enmState = PDMACEPFILEMGRSTATE_SHUTDOWN;
1216	if (!pAioMgr->cRequestsActive)
1217	fNotifyWaiter = true;
1218	break;
1219	}
1220	case PDMACEPFILEAIOMGRBLOCKINGEVENT_SUSPEND:
1221	{
1222	pAioMgr->enmState = PDMACEPFILEMGRSTATE_SUSPENDING;
1223	break;
1224	}
1225	case PDMACEPFILEAIOMGRBLOCKINGEVENT_RESUME:
1226	{
1227	pAioMgr->enmState = PDMACEPFILEMGRSTATE_RUNNING;
1228	fNotifyWaiter = true;
1229	break;
1230	}
1231	default:
1232	AssertReleaseMsgFailed(("Invalid event type %d\n", pAioMgr->enmBlockingEvent));
1233	}
1234
1235	if (fNotifyWaiter)
1236	{
1237	ASMAtomicWriteBool(&pAioMgr->fBlockingEventPending, false);
1238	pAioMgr->enmBlockingEvent = PDMACEPFILEAIOMGRBLOCKINGEVENT_INVALID;
1239
1240	/* Release the waiting thread. */
1241	LogFlow(("Signalling waiter\n"));
1242	rc = RTSemEventSignal(pAioMgr->EventSemBlock);
1243	AssertRC(rc);
1244	}
1245
1246	LogFlowFunc((": Leave\n"));
1247	return rc;
1248	}
1249
1250	/**
1251	* Checks all endpoints for pending events or new requests.
1252	*
1253	* @returns VBox status code.
1254	* @param pAioMgr The I/O manager handle.
1255	*/
1256	static int pdmacFileAioMgrNormalCheckEndpoints(PPDMACEPFILEMGR pAioMgr)
1257	{
1258	/* Check the assigned endpoints for new tasks if there isn't a flush request active at the moment. */
1259	int rc = VINF_SUCCESS;
1260	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint = pAioMgr->pEndpointsHead;
1261
1262	pAioMgr->msBwLimitExpired = RT_INDEFINITE_WAIT;
1263
1264	while (pEndpoint)
1265	{
1266	if (!pEndpoint->pFlushReq
1267	&& (pEndpoint->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE)
1268	&& !pEndpoint->AioMgr.fMoving)
1269	{
1270	rc = pdmacFileAioMgrNormalQueueReqs(pAioMgr, pEndpoint);
1271	if (RT_FAILURE(rc))
1272	return rc;
1273	}
1274	else if ( !pEndpoint->AioMgr.cRequestsActive
1275	&& pEndpoint->enmState != PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE)
1276	{
1277	/* Reopen the file so that the new endpoint can re-associate with the file */
1278	RTFileClose(pEndpoint->hFile);
1279	rc = RTFileOpen(&pEndpoint->hFile, pEndpoint->Core.pszUri, pEndpoint->fFlags);
1280	AssertRC(rc);
1281
1282	if (pEndpoint->AioMgr.fMoving)
1283	{
1284	pEndpoint->AioMgr.fMoving = false;
1285	pdmacFileAioMgrAddEndpoint(pEndpoint->AioMgr.pAioMgrDst, pEndpoint);
1286	}
1287	else
1288	{
1289	Assert(pAioMgr->fBlockingEventPending);
1290	ASMAtomicWriteBool(&pAioMgr->fBlockingEventPending, false);
1291
1292	/* Release the waiting thread. */
1293	LogFlow(("Signalling waiter\n"));
1294	rc = RTSemEventSignal(pAioMgr->EventSemBlock);
1295	AssertRC(rc);
1296	}
1297	}
1298
1299	pEndpoint = pEndpoint->AioMgr.pEndpointNext;
1300	}
1301
1302	return rc;
1303	}
1304
1305	/**
1306	* Wrapper around pdmacFileAioMgrNormalReqCompleteRc().
1307	*/
1308	static void pdmacFileAioMgrNormalReqComplete(PPDMACEPFILEMGR pAioMgr, RTFILEAIOREQ hReq)
1309	{
1310	size_t cbTransfered = 0;
1311	int rcReq = RTFileAioReqGetRC(hReq, &cbTransfered);
1312
1313	pdmacFileAioMgrNormalReqCompleteRc(pAioMgr, hReq, rcReq, cbTransfered);
1314	}
1315
1316	static void pdmacFileAioMgrNormalReqCompleteRc(PPDMACEPFILEMGR pAioMgr, RTFILEAIOREQ hReq,
1317	int rcReq, size_t cbTransfered)
1318	{
1319	int rc = VINF_SUCCESS;
1320	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint;
1321	PPDMACTASKFILE pTask = (PPDMACTASKFILE)RTFileAioReqGetUser(hReq);
1322	PPDMACTASKFILE pTasksWaiting;
1323
1324	LogFlowFunc(("pAioMgr=%#p hReq=%#p\n", pAioMgr, hReq));
1325
1326	pEndpoint = pTask->pEndpoint;
1327
1328	pTask->hReq = NIL_RTFILEAIOREQ;
1329
1330	pAioMgr->cRequestsActive--;
1331	pEndpoint->AioMgr.cRequestsActive--;
1332	pEndpoint->AioMgr.cReqsProcessed++;
1333
1334	/*
1335	* It is possible that the request failed on Linux with kernels < 2.6.23
1336	* if the passed buffer was allocated with remap_pfn_range or if the file
1337	* is on an NFS endpoint which does not support async and direct I/O at the same time.
1338	* The endpoint will be migrated to a failsafe manager in case a request fails.
1339	*/
1340	if (RT_FAILURE(rcReq))
1341	{
1342	/* Free bounce buffers and the IPRT request. */
1343	pdmacFileAioMgrNormalRequestFree(pAioMgr, hReq);
1344
1345	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_FLUSH)
1346	{
1347	LogFlow(("Async flushes are not supported for this endpoint, disabling\n"));
1348	pEndpoint->fAsyncFlushSupported = false;
1349	AssertMsg(pEndpoint->pFlushReq == pTask, ("Failed flush request doesn't match active one\n"));
1350	/* The other method will take over now. */
1351	}
1352	else
1353	{
1354	/* Free the lock and process pending tasks if necessary */
1355	pTasksWaiting = pdmacFileAioMgrNormalRangeLockFree(pAioMgr, pEndpoint, pTask->pRangeLock);
1356	rc = pdmacFileAioMgrNormalProcessTaskList(pTasksWaiting, pAioMgr, pEndpoint);
1357	AssertRC(rc);
1358
1359	if (pTask->cbBounceBuffer)
1360	RTMemPageFree(pTask->pvBounceBuffer, pTask->cbBounceBuffer);
1361
1362	/*
1363	* Fatal errors are reported to the guest and non-fatal errors
1364	* will cause a migration to the failsafe manager in the hope
1365	* that the error disappears.
1366	*/
1367	if (!pdmacFileAioMgrNormalRcIsFatal(rcReq))
1368	{
1369	/* Queue the request on the pending list. */
1370	pTask->pNext = pEndpoint->AioMgr.pReqsPendingHead;
1371	pEndpoint->AioMgr.pReqsPendingHead = pTask;
1372
1373	/* Create a new failsafe manager if necessary. */
1374	if (!pEndpoint->AioMgr.fMoving)
1375	{
1376	PPDMACEPFILEMGR pAioMgrFailsafe;
1377
1378	LogRel(("%s: Request %#p failed with rc=%Rrc, migrating endpoint %s to failsafe manager.\n",
1379	RTThreadGetName(pAioMgr->Thread), pTask, rcReq, pEndpoint->Core.pszUri));
1380
1381	pEndpoint->AioMgr.fMoving = true;
1382
1383	rc = pdmacFileAioMgrCreate((PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass,
1384	&pAioMgrFailsafe, PDMACEPFILEMGRTYPE_SIMPLE);
1385	AssertRC(rc);
1386
1387	pEndpoint->AioMgr.pAioMgrDst = pAioMgrFailsafe;
1388
1389	/* Update the flags to open the file with. Disable async I/O and enable the host cache. */
1390	pEndpoint->fFlags &= ~(RTFILE_O_ASYNC_IO \| RTFILE_O_NO_CACHE);
1391	}
1392
1393	/* If this was the last request for the endpoint migrate it to the new manager. */
1394	if (!pEndpoint->AioMgr.cRequestsActive)
1395	{
1396	bool fReqsPending = pdmacFileAioMgrNormalRemoveEndpoint(pEndpoint);
1397	Assert(!fReqsPending);
1398
1399	rc = pdmacFileAioMgrAddEndpoint(pEndpoint->AioMgr.pAioMgrDst, pEndpoint);
1400	AssertRC(rc);
1401	}
1402	}
1403	else
1404	{
1405	pTask->pfnCompleted(pTask, pTask->pvUser, rcReq);
1406	pdmacFileTaskFree(pEndpoint, pTask);
1407	}
1408	}
1409	}
1410	else
1411	{
1412	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_FLUSH)
1413	{
1414	/* Clear pending flush */
1415	AssertMsg(pEndpoint->pFlushReq == pTask, ("Completed flush request doesn't match active one\n"));
1416	pEndpoint->pFlushReq = NULL;
1417	pdmacFileAioMgrNormalRequestFree(pAioMgr, hReq);
1418
1419	/* Call completion callback */
1420	LogFlow(("Flush task=%#p completed with %Rrc\n", pTask, rcReq));
1421	pTask->pfnCompleted(pTask, pTask->pvUser, rcReq);
1422	pdmacFileTaskFree(pEndpoint, pTask);
1423	}
1424	else
1425	{
1426	/*
1427	* Restart an incomplete transfer.
1428	* This usually means that the request will return an error now
1429	* but to get the cause of the error (disk full, file too big, I/O error, ...)
1430	* the transfer needs to be continued.
1431	*/
1432	if (RT_UNLIKELY( cbTransfered < pTask->DataSeg.cbSeg
1433	\|\| ( pTask->cbBounceBuffer
1434	&& cbTransfered < pTask->cbBounceBuffer)))
1435	{
1436	RTFOFF offStart;
1437	size_t cbToTransfer;
1438	uint8_t *pbBuf = NULL;
1439
1440	LogFlow(("Restarting incomplete transfer %#p (%zu bytes transferred)\n",
1441	pTask, cbTransfered));
1442	Assert(cbTransfered % 512 == 0);
1443
1444	if (pTask->cbBounceBuffer)
1445	{
1446	AssertPtr(pTask->pvBounceBuffer);
1447	offStart = (pTask->Off & ~((RTFOFF)512-1)) + cbTransfered;
1448	cbToTransfer = pTask->cbBounceBuffer - cbTransfered;
1449	pbBuf = (uint8_t *)pTask->pvBounceBuffer + cbTransfered;
1450	}
1451	else
1452	{
1453	Assert(!pTask->pvBounceBuffer);
1454	offStart = pTask->Off + cbTransfered;
1455	cbToTransfer = pTask->DataSeg.cbSeg - cbTransfered;
1456	pbBuf = (uint8_t *)pTask->DataSeg.pvSeg + cbTransfered;
1457	}
1458
1459	if (pTask->fPrefetch \|\| pTask->enmTransferType == PDMACTASKFILETRANSFER_READ)
1460	{
1461	rc = RTFileAioReqPrepareRead(hReq, pEndpoint->hFile, offStart,
1462	pbBuf, cbToTransfer, pTask);
1463	}
1464	else
1465	{
1466	AssertMsg(pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE,
1467	("Invalid transfer type\n"));
1468	rc = RTFileAioReqPrepareWrite(hReq, pEndpoint->hFile, offStart,
1469	pbBuf, cbToTransfer, pTask);
1470	}
1471	AssertRC(rc);
1472
1473	pTask->hReq = hReq;
1474	rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, &hReq, 1);
1475	AssertMsg(RT_SUCCESS(rc) \|\| (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
1476	("Unexpected return code rc=%Rrc\n", rc));
1477	}
1478	else if (pTask->fPrefetch)
1479	{
1480	Assert(pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE);
1481	Assert(pTask->cbBounceBuffer);
1482
1483	memcpy(((uint8_t *)pTask->pvBounceBuffer) + pTask->offBounceBuffer,
1484	pTask->DataSeg.pvSeg,
1485	pTask->DataSeg.cbSeg);
1486
1487	/* Write it now. */
1488	pTask->fPrefetch = false;
1489	size_t cbToTransfer = RT_ALIGN_Z(pTask->DataSeg.cbSeg, 512);
1490	RTFOFF offStart = pTask->Off & ~(RTFOFF)(512-1);
1491
1492	/* Grow the file if needed. */
1493	if (RT_UNLIKELY((uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) > pEndpoint->cbFile))
1494	{
1495	ASMAtomicWriteU64(&pEndpoint->cbFile, pTask->Off + pTask->DataSeg.cbSeg);
1496	RTFileSetSize(pEndpoint->hFile, pTask->Off + pTask->DataSeg.cbSeg);
1497	}
1498
1499	rc = RTFileAioReqPrepareWrite(hReq, pEndpoint->hFile,
1500	offStart, pTask->pvBounceBuffer, cbToTransfer, pTask);
1501	AssertRC(rc);
1502	pTask->hReq = hReq;
1503	rc = pdmacFileAioMgrNormalReqsEnqueue(pAioMgr, pEndpoint, &hReq, 1);
1504	AssertMsg(RT_SUCCESS(rc) \|\| (rc == VERR_FILE_AIO_INSUFFICIENT_RESSOURCES),
1505	("Unexpected return code rc=%Rrc\n", rc));
1506	}
1507	else
1508	{
1509	if (RT_SUCCESS(rc) && pTask->cbBounceBuffer)
1510	{
1511	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_READ)
1512	memcpy(pTask->DataSeg.pvSeg,
1513	((uint8_t *)pTask->pvBounceBuffer) + pTask->offBounceBuffer,
1514	pTask->DataSeg.cbSeg);
1515
1516	RTMemPageFree(pTask->pvBounceBuffer, pTask->cbBounceBuffer);
1517	}
1518
1519	pdmacFileAioMgrNormalRequestFree(pAioMgr, hReq);
1520
1521	/* Free the lock and process pending tasks if necessary */
1522	pTasksWaiting = pdmacFileAioMgrNormalRangeLockFree(pAioMgr, pEndpoint, pTask->pRangeLock);
1523	if (pTasksWaiting)
1524	{
1525	rc = pdmacFileAioMgrNormalProcessTaskList(pTasksWaiting, pAioMgr, pEndpoint);
1526	AssertRC(rc);
1527	}
1528
1529	/* Call completion callback */
1530	LogFlow(("Task=%#p completed with %Rrc\n", pTask, rcReq));
1531	pTask->pfnCompleted(pTask, pTask->pvUser, rcReq);
1532	pdmacFileTaskFree(pEndpoint, pTask);
1533
1534	/*
1535	* If there is no request left on the endpoint but a flush request is set
1536	* it completed now and we notify the owner.
1537	* Furthermore we look for new requests and continue.
1538	*/
1539	if (!pEndpoint->AioMgr.cRequestsActive && pEndpoint->pFlushReq)
1540	{
1541	/* Call completion callback */
1542	pTask = pEndpoint->pFlushReq;
1543	pEndpoint->pFlushReq = NULL;
1544
1545	AssertMsg(pTask->pEndpoint == pEndpoint, ("Endpoint of the flush request does not match assigned one\n"));
1546
1547	pTask->pfnCompleted(pTask, pTask->pvUser, VINF_SUCCESS);
1548	pdmacFileTaskFree(pEndpoint, pTask);
1549	}
1550	else if (RT_UNLIKELY(!pEndpoint->AioMgr.cRequestsActive && pEndpoint->AioMgr.fMoving))
1551	{
1552	/* If the endpoint is about to be migrated do it now. */
1553	bool fReqsPending = pdmacFileAioMgrNormalRemoveEndpoint(pEndpoint);
1554	Assert(!fReqsPending);
1555
1556	rc = pdmacFileAioMgrAddEndpoint(pEndpoint->AioMgr.pAioMgrDst, pEndpoint);
1557	AssertRC(rc);
1558	}
1559	}
1560	} /* Not a flush request */
1561	} /* request completed successfully */
1562	}
1563
1564	/** Helper macro for checking for error codes. */
1565	#define CHECK_RC(pAioMgr, rc) \
1566	if (RT_FAILURE(rc)) \
1567	{\
1568	int rc2 = pdmacFileAioMgrNormalErrorHandler(pAioMgr, rc, RT_SRC_POS);\
1569	return rc2;\
1570	}
1571
1572	/**
1573	* The normal I/O manager using the RTFileAio* API
1574	*
1575	* @returns VBox status code.
1576	* @param ThreadSelf Handle of the thread.
1577	* @param pvUser Opaque user data.
1578	*/
1579	int pdmacFileAioMgrNormal(RTTHREAD ThreadSelf, void *pvUser)
1580	{
1581	int rc = VINF_SUCCESS;
1582	PPDMACEPFILEMGR pAioMgr = (PPDMACEPFILEMGR)pvUser;
1583	uint64_t uMillisEnd = RTTimeMilliTS() + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD;
1584
1585	while ( pAioMgr->enmState == PDMACEPFILEMGRSTATE_RUNNING
1586	\|\| pAioMgr->enmState == PDMACEPFILEMGRSTATE_SUSPENDING
1587	\|\| pAioMgr->enmState == PDMACEPFILEMGRSTATE_GROWING)
1588	{
1589	if (!pAioMgr->cRequestsActive)
1590	{
1591	ASMAtomicWriteBool(&pAioMgr->fWaitingEventSem, true);
1592	if (!ASMAtomicReadBool(&pAioMgr->fWokenUp))
1593	rc = RTSemEventWait(pAioMgr->EventSem, pAioMgr->msBwLimitExpired);
1594	ASMAtomicWriteBool(&pAioMgr->fWaitingEventSem, false);
1595	Assert(RT_SUCCESS(rc) \|\| rc == VERR_TIMEOUT);
1596
1597	LogFlow(("Got woken up\n"));
1598	ASMAtomicWriteBool(&pAioMgr->fWokenUp, false);
1599	}
1600
1601	/* Check for an external blocking event first. */
1602	if (pAioMgr->fBlockingEventPending)
1603	{
1604	rc = pdmacFileAioMgrNormalProcessBlockingEvent(pAioMgr);
1605	CHECK_RC(pAioMgr, rc);
1606	}
1607
1608	if (RT_LIKELY( pAioMgr->enmState == PDMACEPFILEMGRSTATE_RUNNING
1609	\|\| pAioMgr->enmState == PDMACEPFILEMGRSTATE_GROWING))
1610	{
1611	/* We got woken up because an endpoint issued new requests. Queue them. */
1612	rc = pdmacFileAioMgrNormalCheckEndpoints(pAioMgr);
1613	CHECK_RC(pAioMgr, rc);
1614
1615	while (pAioMgr->cRequestsActive)
1616	{
1617	RTFILEAIOREQ apReqs[20];
1618	uint32_t cReqsCompleted = 0;
1619	size_t cReqsWait;
1620
1621	if (pAioMgr->cRequestsActive > RT_ELEMENTS(apReqs))
1622	cReqsWait = RT_ELEMENTS(apReqs);
1623	else
1624	cReqsWait = pAioMgr->cRequestsActive;
1625
1626	LogFlow(("Waiting for %d of %d tasks to complete\n", 1, cReqsWait));
1627
1628	rc = RTFileAioCtxWait(pAioMgr->hAioCtx,
1629	1,
1630	RT_INDEFINITE_WAIT, apReqs,
1631	cReqsWait, &cReqsCompleted);
1632	if (RT_FAILURE(rc) && (rc != VERR_INTERRUPTED))
1633	CHECK_RC(pAioMgr, rc);
1634
1635	LogFlow(("%d tasks completed\n", cReqsCompleted));
1636
1637	for (uint32_t i = 0; i < cReqsCompleted; i++)
1638	pdmacFileAioMgrNormalReqComplete(pAioMgr, apReqs[i]);
1639
1640	/* Check for an external blocking event before we go to sleep again. */
1641	if (pAioMgr->fBlockingEventPending)
1642	{
1643	rc = pdmacFileAioMgrNormalProcessBlockingEvent(pAioMgr);
1644	CHECK_RC(pAioMgr, rc);
1645	}
1646
1647	/* Update load statistics. */
1648	uint64_t uMillisCurr = RTTimeMilliTS();
1649	if (uMillisCurr > uMillisEnd)
1650	{
1651	PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointCurr = pAioMgr->pEndpointsHead;
1652
1653	/* Calculate timespan. */
1654	uMillisCurr -= uMillisEnd;
1655
1656	while (pEndpointCurr)
1657	{
1658	pEndpointCurr->AioMgr.cReqsPerSec = pEndpointCurr->AioMgr.cReqsProcessed / (uMillisCurr + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD);
1659	pEndpointCurr->AioMgr.cReqsProcessed = 0;
1660	pEndpointCurr = pEndpointCurr->AioMgr.pEndpointNext;
1661	}
1662
1663	/* Set new update interval */
1664	uMillisEnd = RTTimeMilliTS() + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD;
1665	}
1666
1667	/* Check endpoints for new requests. */
1668	if (pAioMgr->enmState != PDMACEPFILEMGRSTATE_GROWING)
1669	{
1670	rc = pdmacFileAioMgrNormalCheckEndpoints(pAioMgr);
1671	CHECK_RC(pAioMgr, rc);
1672	}
1673	} /* while requests are active. */
1674
1675	if (pAioMgr->enmState == PDMACEPFILEMGRSTATE_GROWING)
1676	{
1677	rc = pdmacFileAioMgrNormalGrow(pAioMgr);
1678	AssertRC(rc);
1679	Assert(pAioMgr->enmState == PDMACEPFILEMGRSTATE_RUNNING);
1680
1681	rc = pdmacFileAioMgrNormalCheckEndpoints(pAioMgr);
1682	CHECK_RC(pAioMgr, rc);
1683	}
1684	} /* if still running */
1685	} /* while running */
1686
1687	LogFlowFunc(("rc=%Rrc\n", rc));
1688	return rc;
1689	}
1690
1691	#undef CHECK_RC
1692

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

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMAsyncCompletionFileNormal.cpp@ 39070

Download in other formats: