PDMAsyncCompletionFile.cpp@ 22997

Last change on this file since 22997 was 22981, checked in by vboxsync, 15 years ago
PDMAsyncCompletionFile.cpp: The env.var. VBOX_ASYNC_IO_FAILBACK can be used to force debug builds to use the fallback path.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.1 KB

Line
1	/* $Id: PDMAsyncCompletionFile.cpp 22981 2009-09-13 22:09:27Z vboxsync $ */
2	/** @file
3	* PDM Async I/O - Transport data asynchronous in R3 using EMT.
4	*/
5
6	/*
7	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
27	#include "PDMInternal.h"
28	#include <VBox/pdm.h>
29	#include <VBox/mm.h>
30	#include <VBox/vm.h>
31	#include <VBox/err.h>
32	#include <VBox/log.h>
33
34	#include <iprt/asm.h>
35	#include <iprt/assert.h>
36	#include <iprt/critsect.h>
37	#include <iprt/env.h>
38	#include <iprt/file.h>
39	#include <iprt/mem.h>
40	#include <iprt/semaphore.h>
41	#include <iprt/string.h>
42	#include <iprt/thread.h>
43
44	#include "PDMAsyncCompletionFileInternal.h"
45
46	/**
47	* Frees a task.
48	*
49	* @returns nothing.
50	* @param pEndpoint Pointer to the endpoint the segment was for.
51	* @param pTask The task to free.
52	*/
53	void pdmacFileTaskFree(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
54	PPDMACTASKFILE pTask)
55	{
56	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
57
58	LogFlowFunc((": pEndpoint=%p pTask=%p\n", pEndpoint, pTask));
59
60	/* Try the per endpoint cache first. */
61	if (pEndpoint->cTasksCached < pEpClass->cTasksCacheMax)
62	{
63	/* Add it to the list. */
64	pEndpoint->pTasksFreeTail->pNext = pTask;
65	pEndpoint->pTasksFreeTail = pTask;
66	ASMAtomicIncU32(&pEndpoint->cTasksCached);
67	}
68	else if (false)
69	{
70	/* Bigger class cache */
71	}
72	else
73	{
74	Log(("Freeing task %p because all caches are full\n", pTask));
75	MMR3HeapFree(pTask);
76	}
77	}
78
79	/**
80	* Allocates a task segment
81	*
82	* @returns Pointer to the new task segment or NULL
83	* @param pEndpoint Pointer to the endpoint
84	*/
85	PPDMACTASKFILE pdmacFileTaskAlloc(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
86	{
87	PPDMACTASKFILE pTask = NULL;
88
89	/* Try the small per endpoint cache first. */
90	if (pEndpoint->pTasksFreeHead == pEndpoint->pTasksFreeTail)
91	{
92	/* Try the bigger endpoint class cache. */
93	PPDMASYNCCOMPLETIONEPCLASSFILE pEndpointClass = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
94
95	#if 0
96	/* We start with the assigned slot id to distribute the load when allocating new tasks. */
97	unsigned iSlot = pEndpoint->iSlotStart;
98	do
99	{
100	pTask = (PPDMASYNCCOMPLETIONTASK)ASMAtomicXchgPtr((void * volatile *)&pEndpointClass->apTaskCache[iSlot], NULL);
101	if (pTask)
102	break;
103
104	iSlot = (iSlot + 1) % RT_ELEMENTS(pEndpointClass->apTaskCache);
105	} while (iSlot != pEndpoint->iSlotStart);
106	#endif
107	if (!pTask)
108	{
109	/*
110	* Allocate completely new.
111	* If this fails we return NULL.
112	*/
113	int rc = MMR3HeapAllocZEx(pEndpointClass->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION,
114	sizeof(PDMACTASKFILE),
115	(void **)&pTask);
116	if (RT_FAILURE(rc))
117	pTask = NULL;
118
119	LogFlow(("Allocated task %p\n", pTask));
120	}
121	#if 0
122	else
123	{
124	/* Remove the first element and put the rest into the slot again. */
125	PPDMASYNCCOMPLETIONTASK pTaskHeadNew = pTask->pNext;
126
127	pTaskHeadNew->pPrev = NULL;
128
129	/* Put back into the list adding any new tasks. */
130	while (true)
131	{
132	bool fChanged = ASMAtomicCmpXchgPtr((void * volatile *)&pEndpointClass->apTaskCache[iSlot], pTaskHeadNew, NULL);
133
134	if (fChanged)
135	break;
136
137	PPDMASYNCCOMPLETIONTASK pTaskHead = (PPDMASYNCCOMPLETIONTASK)ASMAtomicXchgPtr((void * volatile *)&pEndpointClass->apTaskCache[iSlot], NULL);
138
139	/* The new task could be taken inbetween */
140	if (pTaskHead)
141	{
142	/* Go to the end of the probably much shorter new list. */
143	PPDMASYNCCOMPLETIONTASK pTaskTail = pTaskHead;
144	while (pTaskTail->pNext)
145	pTaskTail = pTaskTail->pNext;
146
147	/* Concatenate */
148	pTaskTail->pNext = pTaskHeadNew;
149
150	pTaskHeadNew = pTaskHead;
151	}
152	/* Another round trying to change the list. */
153	}
154	/* We got a task from the global cache so decrement the counter */
155	ASMAtomicDecU32(&pEndpointClass->cTasksCached);
156	}
157	#endif
158	}
159	else
160	{
161	/* Grab a free task from the head. */
162	AssertMsg(pEndpoint->cTasksCached > 0, ("No tasks cached but list contains more than one element\n"));
163
164	pTask = pEndpoint->pTasksFreeHead;
165	pEndpoint->pTasksFreeHead = pTask->pNext;
166	ASMAtomicDecU32(&pEndpoint->cTasksCached);
167	}
168
169	pTask->pNext = NULL;
170
171	return pTask;
172	}
173
174	PPDMACTASKFILE pdmacFileEpGetNewTasks(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
175	{
176	PPDMACTASKFILE pTasks = NULL;
177
178	/*
179	* Get pending tasks.
180	*/
181	pTasks = (PPDMACTASKFILE)ASMAtomicXchgPtr((void * volatile *)&pEndpoint->pTasksNewHead, NULL);
182
183	/* Reverse the list to process in FIFO order. */
184	if (pTasks)
185	{
186	PPDMACTASKFILE pTask = pTasks;
187
188	pTasks = NULL;
189
190	while (pTask)
191	{
192	PPDMACTASKFILE pCur = pTask;
193	pTask = pTask->pNext;
194	pCur->pNext = pTasks;
195	pTasks = pCur;
196	}
197	}
198
199	return pTasks;
200	}
201
202	static void pdmacFileAioMgrWakeup(PPDMACEPFILEMGR pAioMgr)
203	{
204	bool fWokenUp = ASMAtomicXchgBool(&pAioMgr->fWokenUp, true);
205
206	if (!fWokenUp)
207	{
208	int rc = VINF_SUCCESS;
209	bool fWaitingEventSem = ASMAtomicReadBool(&pAioMgr->fWaitingEventSem);
210
211	if (fWaitingEventSem)
212	rc = RTSemEventSignal(pAioMgr->EventSem);
213
214	AssertRC(rc);
215	}
216	}
217
218	static int pdmacFileAioMgrWaitForBlockingEvent(PPDMACEPFILEMGR pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT enmEvent)
219	{
220	int rc = VINF_SUCCESS;
221
222	ASMAtomicWriteU32((volatile uint32_t *)&pAioMgr->enmBlockingEvent, enmEvent);
223	Assert(!pAioMgr->fBlockingEventPending);
224	ASMAtomicXchgBool(&pAioMgr->fBlockingEventPending, true);
225
226	/* Wakeup the async I/O manager */
227	pdmacFileAioMgrWakeup(pAioMgr);
228
229	/* Wait for completion. */
230	rc = RTSemEventWait(pAioMgr->EventSemBlock, RT_INDEFINITE_WAIT);
231	AssertRC(rc);
232
233	ASMAtomicXchgBool(&pAioMgr->fBlockingEventPending, false);
234	ASMAtomicWriteU32((volatile uint32_t *)&pAioMgr->enmBlockingEvent, PDMACEPFILEAIOMGRBLOCKINGEVENT_INVALID);
235
236	return rc;
237	}
238
239	int pdmacFileAioMgrAddEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
240	{
241	int rc;
242
243	rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
244	AssertRCReturn(rc, rc);
245
246	ASMAtomicWritePtr((void * volatile *)&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint, pEndpoint);
247	rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT);
248
249	RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
250
251	if (RT_SUCCESS(rc))
252	ASMAtomicWritePtr((void * volatile *)&pEndpoint->pAioMgr, pAioMgr);
253
254	return rc;
255	}
256
257	static int pdmacFileAioMgrRemoveEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
258	{
259	int rc;
260
261	rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
262	AssertRCReturn(rc, rc);
263
264	ASMAtomicWritePtr((void * volatile *)&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint, pEndpoint);
265	rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT);
266
267	RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
268
269	return rc;
270	}
271
272	static int pdmacFileAioMgrCloseEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
273	{
274	int rc;
275
276	rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
277	AssertRCReturn(rc, rc);
278
279	ASMAtomicWritePtr((void * volatile *)&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint, pEndpoint);
280	rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT);
281
282	RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
283
284	return rc;
285	}
286
287	static int pdmacFileAioMgrShutdown(PPDMACEPFILEMGR pAioMgr)
288	{
289	int rc;
290
291	rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
292	AssertRCReturn(rc, rc);
293
294	rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_SHUTDOWN);
295
296	RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
297
298	return rc;
299	}
300
301	int pdmacFileEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask)
302	{
303	PPDMACTASKFILE pNext;
304	do
305	{
306	pNext = pEndpoint->pTasksNewHead;
307	pTask->pNext = pNext;
308	} while (!ASMAtomicCmpXchgPtr((void * volatile )&pEndpoint->pTasksNewHead, (void )pTask, (void *)pNext));
309
310	pdmacFileAioMgrWakeup((PPDMACEPFILEMGR)ASMAtomicReadPtr((void * volatile *)&pEndpoint->pAioMgr));
311
312	return VINF_SUCCESS;
313	}
314
315	void pdmacFileEpTaskCompleted(PPDMACTASKFILE pTask, void *pvUser)
316	{
317	PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pvUser;
318
319	if (pTask->enmTransferType == PDMACTASKFILETRANSFER_FLUSH)
320	{
321	pdmR3AsyncCompletionCompleteTask(&pTaskFile->Core);
322	}
323	else
324	{
325	uint32_t uOld = ASMAtomicSubU32(&pTaskFile->cbTransferLeft, pTask->DataSeg.cbSeg);
326
327	if (!(uOld - pTask->DataSeg.cbSeg)
328	&& !ASMAtomicXchgBool(&pTaskFile->fCompleted, true))
329	pdmR3AsyncCompletionCompleteTask(&pTaskFile->Core);
330	}
331	}
332
333	int pdmacFileEpTaskInitiate(PPDMASYNCCOMPLETIONTASK pTask,
334	PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
335	PCPDMDATASEG paSegments, size_t cSegments,
336	size_t cbTransfer, PDMACTASKFILETRANSFER enmTransfer)
337	{
338	int rc = VINF_SUCCESS;
339	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
340	PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pTask;
341	PPDMACEPFILEMGR pAioMgr = pEpFile->pAioMgr;
342
343	Assert( (enmTransfer == PDMACTASKFILETRANSFER_READ)
344	\|\| (enmTransfer == PDMACTASKFILETRANSFER_WRITE));
345
346	ASMAtomicWriteS32(&pTaskFile->cbTransferLeft, cbTransfer);
347	ASMAtomicWriteBool(&pTaskFile->fCompleted, false);
348
349	for (unsigned i = 0; i < cSegments; i++)
350	{
351	PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEpFile);
352	AssertPtr(pIoTask);
353
354	pIoTask->pEndpoint = pEpFile;
355	pIoTask->enmTransferType = enmTransfer;
356	pIoTask->Off = off;
357	pIoTask->DataSeg.cbSeg = paSegments[i].cbSeg;
358	pIoTask->DataSeg.pvSeg = paSegments[i].pvSeg;
359	pIoTask->pvUser = pTaskFile;
360	pIoTask->pfnCompleted = pdmacFileEpTaskCompleted;
361
362	/* Send it off to the I/O manager. */
363	pdmacFileEpAddTask(pEpFile, pIoTask);
364	off += paSegments[i].cbSeg;
365	cbTransfer -= paSegments[i].cbSeg;
366	}
367
368	AssertMsg(!cbTransfer, ("Incomplete transfer %u bytes left\n", cbTransfer));
369
370	if (ASMAtomicReadS32(&pTaskFile->cbTransferLeft) == 0
371	&& !ASMAtomicXchgBool(&pTaskFile->fCompleted, true))
372	pdmR3AsyncCompletionCompleteTask(pTask);
373
374	return VINF_SUCCESS;
375	}
376
377	/**
378	* Creates a new async I/O manager.
379	*
380	* @returns VBox status code.
381	* @param pEpClass Pointer to the endpoint class data.
382	* @param ppAioMgr Where to store the pointer to the new async I/O manager on success.
383	*/
384	int pdmacFileAioMgrCreate(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass, PPPDMACEPFILEMGR ppAioMgr)
385	{
386	int rc = VINF_SUCCESS;
387	PPDMACEPFILEMGR pAioMgrNew;
388
389	LogFlowFunc((": Entered\n"));
390
391	rc = MMR3HeapAllocZEx(pEpClass->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION, sizeof(PDMACEPFILEMGR), (void **)&pAioMgrNew);
392	if (RT_SUCCESS(rc))
393	{
394	pAioMgrNew->fFailsafe = pEpClass->fFailsafe;
395
396	rc = RTSemEventCreate(&pAioMgrNew->EventSem);
397	if (RT_SUCCESS(rc))
398	{
399	rc = RTSemEventCreate(&pAioMgrNew->EventSemBlock);
400	if (RT_SUCCESS(rc))
401	{
402	rc = RTCritSectInit(&pAioMgrNew->CritSectBlockingEvent);
403	if (RT_SUCCESS(rc))
404	{
405	/* Init the rest of the manager. */
406	if (!pAioMgrNew->fFailsafe)
407	rc = pdmacFileAioMgrNormalInit(pAioMgrNew);
408
409	if (RT_SUCCESS(rc))
410	{
411	pAioMgrNew->enmState = PDMACEPFILEMGRSTATE_RUNNING;
412
413	rc = RTThreadCreateF(&pAioMgrNew->Thread,
414	pAioMgrNew->fFailsafe
415	? pdmacFileAioMgrFailsafe
416	: pdmacFileAioMgrNormal,
417	pAioMgrNew,
418	0,
419	RTTHREADTYPE_IO,
420	0,
421	"AioMgr%d-%s", pEpClass->cAioMgrs,
422	pAioMgrNew->fFailsafe
423	? "F"
424	: "N");
425	if (RT_SUCCESS(rc))
426	{
427	/* Link it into the list. */
428	RTCritSectEnter(&pEpClass->CritSect);
429	pAioMgrNew->pNext = pEpClass->pAioMgrHead;
430	if (pEpClass->pAioMgrHead)
431	pEpClass->pAioMgrHead->pPrev = pAioMgrNew;
432	pEpClass->pAioMgrHead = pAioMgrNew;
433	pEpClass->cAioMgrs++;
434	RTCritSectLeave(&pEpClass->CritSect);
435
436	*ppAioMgr = pAioMgrNew;
437
438	Log(("PDMAC: Successfully created new file AIO Mgr {%s}\n", RTThreadGetName(pAioMgrNew->Thread)));
439	return VINF_SUCCESS;
440	}
441	pdmacFileAioMgrNormalDestroy(pAioMgrNew);
442	}
443	RTCritSectDelete(&pAioMgrNew->CritSectBlockingEvent);
444	}
445	RTSemEventDestroy(pAioMgrNew->EventSem);
446	}
447	RTSemEventDestroy(pAioMgrNew->EventSemBlock);
448	}
449	MMR3HeapFree(pAioMgrNew);
450	}
451
452	LogFlowFunc((": Leave rc=%Rrc\n", rc));
453
454	return rc;
455	}
456
457	/**
458	* Destroys a async I/O manager.
459	*
460	* @returns nothing.
461	* @param pAioMgr The async I/O manager to destroy.
462	*/
463	static void pdmacFileAioMgrDestroy(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile, PPDMACEPFILEMGR pAioMgr)
464	{
465	int rc = pdmacFileAioMgrShutdown(pAioMgr);
466	AssertRC(rc);
467
468	/* Unlink from the list. */
469	rc = RTCritSectEnter(&pEpClassFile->CritSect);
470	AssertRC(rc);
471
472	PPDMACEPFILEMGR pPrev = pAioMgr->pPrev;
473	PPDMACEPFILEMGR pNext = pAioMgr->pNext;
474
475	if (pPrev)
476	pPrev->pNext = pNext;
477	else
478	pEpClassFile->pAioMgrHead = pNext;
479
480	if (pNext)
481	pNext->pPrev = pPrev;
482
483	pEpClassFile->cAioMgrs--;
484
485	rc = RTCritSectLeave(&pEpClassFile->CritSect);
486	AssertRC(rc);
487
488	/* Free the ressources. */
489	RTCritSectDelete(&pAioMgr->CritSectBlockingEvent);
490	RTSemEventDestroy(pAioMgr->EventSem);
491	if (!pAioMgr->fFailsafe)
492	pdmacFileAioMgrNormalDestroy(pAioMgr);
493
494	MMR3HeapFree(pAioMgr);
495	}
496
497	static int pdmacFileInitialize(PPDMASYNCCOMPLETIONEPCLASS pClassGlobals, PCFGMNODE pCfgNode)
498	{
499	int rc = VINF_SUCCESS;
500	RTFILEAIOLIMITS AioLimits; /** < Async I/O limitations. */
501
502	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pClassGlobals;
503
504	rc = RTFileAioGetLimits(&AioLimits);
505	#ifdef DEBUG
506	if (RT_SUCCESS(rc) && RTEnvExist("VBOX_ASYNC_IO_FAILBACK"))
507	rc = VERR_ENV_VAR_NOT_FOUND;
508	#endif
509	if (RT_FAILURE(rc))
510	{
511	LogRel(("AIO: Async I/O manager not supported (rc=%Rrc). Falling back to failsafe manager\n",
512	rc));
513	pEpClassFile->fFailsafe = true;
514	}
515	else
516	{
517	pEpClassFile->uBitmaskAlignment = AioLimits.cbBufferAlignment ? ~((RTR3UINTPTR)AioLimits.cbBufferAlignment - 1) : RTR3UINTPTR_MAX;
518	pEpClassFile->cReqsOutstandingMax = AioLimits.cReqsOutstandingMax;
519	pEpClassFile->fFailsafe = false;
520	}
521
522	/* Init critical section. */
523	rc = RTCritSectInit(&pEpClassFile->CritSect);
524	if (RT_SUCCESS(rc))
525	{
526	/* Init cache structure */
527	rc = pdmacFileCacheInit(pEpClassFile, pCfgNode);
528	if (RT_FAILURE(rc))
529	RTCritSectDelete(&pEpClassFile->CritSect);
530	}
531
532	return rc;
533	}
534
535	static void pdmacFileTerminate(PPDMASYNCCOMPLETIONEPCLASS pClassGlobals)
536	{
537	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pClassGlobals;
538
539	/* All endpoints should be closed at this point. */
540	AssertMsg(!pEpClassFile->Core.pEndpointsHead, ("There are still endpoints left\n"));
541
542	/* Destroy all left async I/O managers. */
543	while (pEpClassFile->pAioMgrHead)
544	pdmacFileAioMgrDestroy(pEpClassFile, pEpClassFile->pAioMgrHead);
545
546	RTCritSectDelete(&pEpClassFile->CritSect);
547	}
548
549	static int pdmacFileEpInitialize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint,
550	const char *pszUri, uint32_t fFlags)
551	{
552	int rc = VINF_SUCCESS;
553	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
554	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->pEpClass;
555
556	AssertMsgReturn((fFlags & ~(PDMACEP_FILE_FLAGS_READ_ONLY \| PDMACEP_FILE_FLAGS_CACHING)) == 0,
557	("PDMAsyncCompletion: Invalid flag specified\n"), VERR_INVALID_PARAMETER);
558
559	unsigned fFileFlags = fFlags & PDMACEP_FILE_FLAGS_READ_ONLY
560	? RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE
561	: RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE;
562
563	if (!pEpClassFile->fFailsafe)
564	{
565	fFileFlags \|= (RTFILE_O_ASYNC_IO \| RTFILE_O_WRITE_THROUGH);
566
567	/*
568	* We only disable the cache if the size of the file is a multiple of 512.
569	* Certain hosts like Windows, Linux and Solaris require that transfer sizes
570	* are aligned to the volume sector size.
571	* If not we just make sure that the data is written to disk with RTFILE_O_WRITE_THROUGH
572	* which will trash the host cache but ensures that the host cache will not
573	* contain dirty buffers.
574	*/
575	RTFILE File = NIL_RTFILE;
576
577	rc = RTFileOpen(&File, pszUri, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE);
578	if (RT_SUCCESS(rc))
579	{
580	uint64_t cbSize;
581
582	rc = RTFileGetSize(File, &cbSize);
583	if (RT_SUCCESS(rc) && ((cbSize % 512) == 0))
584	{
585	fFileFlags &= ~RTFILE_O_WRITE_THROUGH;
586	fFileFlags \|= RTFILE_O_NO_CACHE;
587	}
588
589	pEpFile->cbFile = cbSize;
590
591	RTFileClose(File);
592	}
593	}
594
595	pEpFile->fFlags = fFileFlags;
596
597	/* Open with final flags. */
598	rc = RTFileOpen(&pEpFile->File, pszUri, fFileFlags);
599	if (RT_SUCCESS(rc))
600	{
601	rc = RTFileGetSize(pEpFile->File, (uint64_t *)&pEpFile->cbFile);
602	if (RT_SUCCESS(rc))
603	{
604	/* Initialize the segment cache */
605	rc = MMR3HeapAllocZEx(pEpClassFile->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION,
606	sizeof(PDMACTASKFILE),
607	(void **)&pEpFile->pTasksFreeHead);
608	if (RT_SUCCESS(rc))
609	{
610	PPDMACEPFILEMGR pAioMgr = NULL;
611
612	pEpFile->pTasksFreeTail = pEpFile->pTasksFreeHead;
613	pEpFile->cTasksCached = 0;
614
615	if (pEpClassFile->fFailsafe)
616	{
617	/* Safe mode. Every file has its own async I/O manager. */
618	rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgr);
619	AssertRC(rc);
620	}
621	else
622	{
623	if (fFlags & PDMACEP_FILE_FLAGS_CACHING)
624	{
625	pEpFile->fCaching = true;
626	rc = pdmacFileEpCacheInit(pEpFile, pEpClassFile);
627	if (RT_FAILURE(rc))
628	{
629	LogRel(("AIOMgr: Endpoint for \"%s\" was opened with caching but initializing cache failed. Disabled caching\n", pszUri));
630	pEpFile->fCaching = false;
631	}
632	}
633
634	/* Check for an idling one or create new if not found */
635	if (!pEpClassFile->pAioMgrHead)
636	{
637	rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgr);
638	AssertRC(rc);
639	}
640	else
641	{
642	pAioMgr = pEpClassFile->pAioMgrHead;
643	}
644	}
645
646	pEpFile->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
647
648	/* Assign the endpoint to the thread. */
649	rc = pdmacFileAioMgrAddEndpoint(pAioMgr, pEpFile);
650	if (RT_FAILURE(rc))
651	MMR3HeapFree(pEpFile->pTasksFreeHead);
652	}
653	}
654
655	if (RT_FAILURE(rc))
656	RTFileClose(pEpFile->File);
657	}
658
659	return rc;
660	}
661
662	static int pdmacFileEpClose(PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
663	{
664	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
665	PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->pEpClass;
666
667	/* Make sure that all tasks finished for this endpoint. */
668	int rc = pdmacFileAioMgrCloseEndpoint(pEpFile->pAioMgr, pEpFile);
669	AssertRC(rc);
670
671	/*
672	* If the async I/O manager is in failsafe mode this is the only endpoint
673	* he processes and thus can be destroyed now.
674	*/
675	if (pEpFile->pAioMgr->fFailsafe)
676	pdmacFileAioMgrDestroy(pEpClassFile, pEpFile->pAioMgr);
677
678	/* Free cached tasks. */
679	PPDMACTASKFILE pTask = pEpFile->pTasksFreeHead;
680
681	while (pTask)
682	{
683	PPDMACTASKFILE pTaskFree = pTask;
684	pTask = pTask->pNext;
685	MMR3HeapFree(pTaskFree);
686	}
687
688	/* Free the cached data. */
689	if (pEpFile->fCaching)
690	pdmacFileEpCacheDestroy(pEpFile);
691
692	return VINF_SUCCESS;
693	}
694
695	static int pdmacFileEpRead(PPDMASYNCCOMPLETIONTASK pTask,
696	PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
697	PCPDMDATASEG paSegments, size_t cSegments,
698	size_t cbRead)
699	{
700	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
701
702	if (pEpFile->fCaching)
703	return pdmacFileEpCacheRead(pEpFile, (PPDMASYNCCOMPLETIONTASKFILE)pTask,
704	off, paSegments, cSegments, cbRead);
705	else
706	return pdmacFileEpTaskInitiate(pTask, pEndpoint, off, paSegments, cSegments, cbRead,
707	PDMACTASKFILETRANSFER_READ);
708	}
709
710	static int pdmacFileEpWrite(PPDMASYNCCOMPLETIONTASK pTask,
711	PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
712	PCPDMDATASEG paSegments, size_t cSegments,
713	size_t cbWrite)
714	{
715	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
716
717	if (RT_UNLIKELY(pEpFile->fReadonly))
718	return VERR_NOT_SUPPORTED;
719
720	if (pEpFile->fCaching)
721	return pdmacFileEpCacheWrite(pEpFile, (PPDMASYNCCOMPLETIONTASKFILE)pTask,
722	off, paSegments, cSegments, cbWrite);
723	else
724	return pdmacFileEpTaskInitiate(pTask, pEndpoint, off, paSegments, cSegments, cbWrite,
725	PDMACTASKFILETRANSFER_WRITE);
726	}
727
728	static int pdmacFileEpFlush(PPDMASYNCCOMPLETIONTASK pTask,
729	PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
730	{
731	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
732	PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pTask;
733
734	if (RT_UNLIKELY(pEpFile->fReadonly))
735	return VERR_NOT_SUPPORTED;
736
737	pTaskFile->cbTransferLeft = 0;
738
739	PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEpFile);
740	AssertPtr(pIoTask);
741
742	pIoTask->pEndpoint = pEpFile;
743	pIoTask->enmTransferType = PDMACTASKFILETRANSFER_FLUSH;
744	pIoTask->pvUser = pTaskFile;
745	pIoTask->pfnCompleted = pdmacFileEpTaskCompleted;
746	pdmacFileEpAddTask(pEpFile, pIoTask);
747
748	return VINF_SUCCESS;
749	}
750
751	static int pdmacFileEpGetSize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t *pcbSize)
752	{
753	PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
754
755	*pcbSize = ASMAtomicReadU64(&pEpFile->cbFile);
756
757	return VINF_SUCCESS;
758	}
759
760	const PDMASYNCCOMPLETIONEPCLASSOPS g_PDMAsyncCompletionEndpointClassFile =
761	{
762	/* u32Version */
763	PDMAC_EPCLASS_OPS_VERSION,
764	/* pcszName */
765	"File",
766	/* enmClassType */
767	PDMASYNCCOMPLETIONEPCLASSTYPE_FILE,
768	/* cbEndpointClassGlobal */
769	sizeof(PDMASYNCCOMPLETIONEPCLASSFILE),
770	/* cbEndpoint */
771	sizeof(PDMASYNCCOMPLETIONENDPOINTFILE),
772	/* cbTask */
773	sizeof(PDMASYNCCOMPLETIONTASKFILE),
774	/* pfnInitialize */
775	pdmacFileInitialize,
776	/* pfnTerminate */
777	pdmacFileTerminate,
778	/* pfnEpInitialize. */
779	pdmacFileEpInitialize,
780	/* pfnEpClose */
781	pdmacFileEpClose,
782	/* pfnEpRead */
783	pdmacFileEpRead,
784	/* pfnEpWrite */
785	pdmacFileEpWrite,
786	/* pfnEpFlush */
787	pdmacFileEpFlush,
788	/* pfnEpGetSize */
789	pdmacFileEpGetSize,
790	/* u32VersionEnd */
791	PDMAC_EPCLASS_OPS_VERSION
792	};
793

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

source: vbox/trunk/src/VBox/VMM/PDMAsyncCompletionFile.cpp@ 22997

Download in other formats: