VirtualBox

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

Last change on this file since 60380 was 59261, checked in by vboxsync, 9 years ago

PDMAsyncCompletion: Don't return an already existing endpoint handle when a file is opened multiple times but create a new handle everytime, fixes a crash when an ISO images is attached multiple times to the same VM
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 47.3 KB
Line 
1/* $Id: PDMAsyncCompletionFile.cpp 59261 2016-01-06 11:32:38Z vboxsync $ */
2/** @file
3 * PDM Async I/O - Transport data asynchronous in R3 using EMT.
4 */
5
6/*
7 * Copyright (C) 2006-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
23#include "PDMInternal.h"
24#include <VBox/vmm/pdm.h>
25#include <VBox/vmm/mm.h>
26#include <VBox/vmm/vm.h>
27#include <VBox/err.h>
28#include <VBox/log.h>
29#include <VBox/dbg.h>
30#include <VBox/vmm/uvm.h>
31#include <VBox/vmm/tm.h>
32
33#include <iprt/asm.h>
34#include <iprt/assert.h>
35#include <iprt/critsect.h>
36#include <iprt/env.h>
37#include <iprt/file.h>
38#include <iprt/mem.h>
39#include <iprt/semaphore.h>
40#include <iprt/string.h>
41#include <iprt/thread.h>
42#include <iprt/path.h>
43#include <iprt/rand.h>
44
45#include "PDMAsyncCompletionFileInternal.h"
46
47
48/*********************************************************************************************************************************
49* Internal Functions *
50*********************************************************************************************************************************/
51#ifdef VBOX_WITH_DEBUGGER
52static FNDBGCCMD pdmacEpFileErrorInject;
53# ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
54static FNDBGCCMD pdmacEpFileDelayInject;
55# endif
56#endif
57
58
59/*********************************************************************************************************************************
60* Global Variables *
61*********************************************************************************************************************************/
62#ifdef VBOX_WITH_DEBUGGER
63static const DBGCVARDESC g_aInjectErrorArgs[] =
64{
65 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
66 { 1, 1, DBGCVAR_CAT_STRING, 0, "direction", "write/read." },
67 { 1, 1, DBGCVAR_CAT_STRING, 0, "filename", "Filename." },
68 { 1, 1, DBGCVAR_CAT_NUMBER, 0, "errcode", "VBox status code." },
69};
70
71# ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
72static const DBGCVARDESC g_aInjectDelayArgs[] =
73{
74 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
75 { 1, 1, DBGCVAR_CAT_STRING, 0, "direction", "write|read|flush|any." },
76 { 1, 1, DBGCVAR_CAT_STRING, 0, "filename", "Filename." },
77 { 1, 1, DBGCVAR_CAT_NUMBER, 0, "delay", "Delay in milliseconds." },
78 { 1, 1, DBGCVAR_CAT_NUMBER, 0, "jitter", "Jitter of the delay." },
79 { 1, 1, DBGCVAR_CAT_NUMBER, 0, "reqs", "Number of requests to delay." }
80
81};
82# endif
83
84/** Command descriptors. */
85static const DBGCCMD g_aCmds[] =
86{
87 /* pszCmd, cArgsMin, cArgsMax, paArgDesc, cArgDescs, fFlags, pfnHandler pszSyntax,.pszDescription */
88 { "injecterror", 3, 3, &g_aInjectErrorArgs[0], 3, 0, pdmacEpFileErrorInject, "", "Inject error into I/O subsystem." }
89# ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
90 ,{ "injectdelay", 3, 5, &g_aInjectDelayArgs[0], RT_ELEMENTS(g_aInjectDelayArgs), 0, pdmacEpFileDelayInject, "", "Inject a delay of a request." }
91# endif
92};
93#endif
94
95
96/**
97 * Frees a task.
98 *
99 * @returns nothing.
100 * @param pEndpoint Pointer to the endpoint the segment was for.
101 * @param pTask The task to free.
102 */
103void pdmacFileTaskFree(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask)
104{
105 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
106
107 LogFlowFunc((": pEndpoint=%p pTask=%p\n", pEndpoint, pTask));
108
109 /* Try the per endpoint cache first. */
110 if (pEndpoint->cTasksCached < pEpClass->cTasksCacheMax)
111 {
112 /* Add it to the list. */
113 pEndpoint->pTasksFreeTail->pNext = pTask;
114 pEndpoint->pTasksFreeTail = pTask;
115 ASMAtomicIncU32(&pEndpoint->cTasksCached);
116 }
117 else
118 {
119 Log(("Freeing task %p because all caches are full\n", pTask));
120 MMR3HeapFree(pTask);
121 }
122}
123
124/**
125 * Allocates a task segment
126 *
127 * @returns Pointer to the new task segment or NULL
128 * @param pEndpoint Pointer to the endpoint
129 */
130PPDMACTASKFILE pdmacFileTaskAlloc(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
131{
132 PPDMACTASKFILE pTask = NULL;
133
134 /* Try the small per endpoint cache first. */
135 if (pEndpoint->pTasksFreeHead == pEndpoint->pTasksFreeTail)
136 {
137 /* Try the bigger endpoint class cache. */
138 PPDMASYNCCOMPLETIONEPCLASSFILE pEndpointClass = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
139
140 /*
141 * Allocate completely new.
142 * If this fails we return NULL.
143 */
144 int rc = MMR3HeapAllocZEx(pEndpointClass->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION,
145 sizeof(PDMACTASKFILE),
146 (void **)&pTask);
147 if (RT_FAILURE(rc))
148 pTask = NULL;
149
150 LogFlow(("Allocated task %p\n", pTask));
151 }
152 else
153 {
154 /* Grab a free task from the head. */
155 AssertMsg(pEndpoint->cTasksCached > 0, ("No tasks cached but list contains more than one element\n"));
156
157 pTask = pEndpoint->pTasksFreeHead;
158 pEndpoint->pTasksFreeHead = pTask->pNext;
159 ASMAtomicDecU32(&pEndpoint->cTasksCached);
160 }
161
162 pTask->pNext = NULL;
163
164 return pTask;
165}
166
167PPDMACTASKFILE pdmacFileEpGetNewTasks(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
168{
169 /*
170 * Get pending tasks.
171 */
172 PPDMACTASKFILE pTasks = ASMAtomicXchgPtrT(&pEndpoint->pTasksNewHead, NULL, PPDMACTASKFILE);
173
174 /* Reverse the list to process in FIFO order. */
175 if (pTasks)
176 {
177 PPDMACTASKFILE pTask = pTasks;
178
179 pTasks = NULL;
180
181 while (pTask)
182 {
183 PPDMACTASKFILE pCur = pTask;
184 pTask = pTask->pNext;
185 pCur->pNext = pTasks;
186 pTasks = pCur;
187 }
188 }
189
190 return pTasks;
191}
192
193static void pdmacFileAioMgrWakeup(PPDMACEPFILEMGR pAioMgr)
194{
195 bool fWokenUp = ASMAtomicXchgBool(&pAioMgr->fWokenUp, true);
196 if (!fWokenUp)
197 {
198 bool fWaitingEventSem = ASMAtomicReadBool(&pAioMgr->fWaitingEventSem);
199 if (fWaitingEventSem)
200 {
201 int rc = RTSemEventSignal(pAioMgr->EventSem);
202 AssertRC(rc);
203 }
204 }
205}
206
207static int pdmacFileAioMgrWaitForBlockingEvent(PPDMACEPFILEMGR pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT enmEvent)
208{
209 ASMAtomicWriteU32((volatile uint32_t *)&pAioMgr->enmBlockingEvent, enmEvent);
210 Assert(!pAioMgr->fBlockingEventPending);
211 ASMAtomicXchgBool(&pAioMgr->fBlockingEventPending, true);
212
213 /* Wakeup the async I/O manager */
214 pdmacFileAioMgrWakeup(pAioMgr);
215
216 /* Wait for completion. */
217 int rc = RTSemEventWait(pAioMgr->EventSemBlock, RT_INDEFINITE_WAIT);
218 AssertRC(rc);
219
220 ASMAtomicXchgBool(&pAioMgr->fBlockingEventPending, false);
221 ASMAtomicWriteU32((volatile uint32_t *)&pAioMgr->enmBlockingEvent, PDMACEPFILEAIOMGRBLOCKINGEVENT_INVALID);
222
223 return rc;
224}
225
226int pdmacFileAioMgrAddEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
227{
228 LogFlowFunc(("pAioMgr=%#p pEndpoint=%#p{%s}\n", pAioMgr, pEndpoint, pEndpoint->Core.pszUri));
229
230 /* Update the assigned I/O manager. */
231 ASMAtomicWritePtr(&pEndpoint->pAioMgr, pAioMgr);
232
233 int rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
234 AssertRCReturn(rc, rc);
235
236 ASMAtomicWritePtr(&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint, pEndpoint);
237 rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT);
238 ASMAtomicWriteNullPtr(&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint);
239
240 RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
241
242 return rc;
243}
244
245#ifdef SOME_UNUSED_FUNCTION
246static int pdmacFileAioMgrRemoveEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
247{
248 int rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
249 AssertRCReturn(rc, rc);
250
251 ASMAtomicWritePtr(&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint, pEndpoint);
252 rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT);
253 ASMAtomicWriteNullPtr(&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint);
254
255 RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
256
257 return rc;
258}
259#endif
260
261static int pdmacFileAioMgrCloseEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
262{
263 int rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
264 AssertRCReturn(rc, rc);
265
266 ASMAtomicWritePtr(&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint, pEndpoint);
267 rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT);
268 ASMAtomicWriteNullPtr(&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint);
269
270 RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
271
272 return rc;
273}
274
275static int pdmacFileAioMgrShutdown(PPDMACEPFILEMGR pAioMgr)
276{
277 int rc = RTCritSectEnter(&pAioMgr->CritSectBlockingEvent);
278 AssertRCReturn(rc, rc);
279
280 rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_SHUTDOWN);
281
282 RTCritSectLeave(&pAioMgr->CritSectBlockingEvent);
283
284 return rc;
285}
286
287int pdmacFileEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask)
288{
289 PPDMACTASKFILE pNext;
290 do
291 {
292 pNext = pEndpoint->pTasksNewHead;
293 pTask->pNext = pNext;
294 } while (!ASMAtomicCmpXchgPtr(&pEndpoint->pTasksNewHead, pTask, pNext));
295
296 pdmacFileAioMgrWakeup(ASMAtomicReadPtrT(&pEndpoint->pAioMgr, PPDMACEPFILEMGR));
297
298 return VINF_SUCCESS;
299}
300
301static DECLCALLBACK(void) pdmacFileEpTaskCompleted(PPDMACTASKFILE pTask, void *pvUser, int rc)
302{
303 PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pvUser;
304
305 LogFlowFunc(("pTask=%#p pvUser=%#p rc=%Rrc\n", pTask, pvUser, rc));
306
307 if (pTask->enmTransferType == PDMACTASKFILETRANSFER_FLUSH)
308 pdmR3AsyncCompletionCompleteTask(&pTaskFile->Core, rc, true);
309 else
310 {
311 Assert((uint32_t)pTask->DataSeg.cbSeg == pTask->DataSeg.cbSeg && (int32_t)pTask->DataSeg.cbSeg >= 0);
312 uint32_t uOld = ASMAtomicSubS32(&pTaskFile->cbTransferLeft, (int32_t)pTask->DataSeg.cbSeg);
313
314 /* The first error will be returned. */
315 if (RT_FAILURE(rc))
316 ASMAtomicCmpXchgS32(&pTaskFile->rc, rc, VINF_SUCCESS);
317#ifdef VBOX_WITH_DEBUGGER
318 else
319 {
320 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pTaskFile->Core.pEndpoint;
321
322 /* Overwrite with injected error code. */
323 if (pTask->enmTransferType == PDMACTASKFILETRANSFER_READ)
324 rc = ASMAtomicXchgS32(&pEpFile->rcReqRead, VINF_SUCCESS);
325 else
326 rc = ASMAtomicXchgS32(&pEpFile->rcReqWrite, VINF_SUCCESS);
327
328 if (RT_FAILURE(rc))
329 ASMAtomicCmpXchgS32(&pTaskFile->rc, rc, VINF_SUCCESS);
330 }
331#endif
332
333 if (!(uOld - pTask->DataSeg.cbSeg)
334 && !ASMAtomicXchgBool(&pTaskFile->fCompleted, true))
335 {
336#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
337 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pTaskFile->Core.pEndpoint;
338 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEpFile->Core.pEpClass;
339
340 /* Check if we should delay completion of the request. */
341 if ( ASMAtomicReadU32(&pEpFile->msDelay) > 0
342 && ASMAtomicReadU32(&pEpFile->cReqsDelay) > 0)
343 {
344 uint64_t tsDelay = pEpFile->msDelay;
345
346 if (pEpFile->msJitter)
347 tsDelay = (RTRandU32() % 100) > 50 ? pEpFile->msDelay + (RTRandU32() % pEpFile->msJitter)
348 : pEpFile->msDelay - (RTRandU32() % pEpFile->msJitter);
349 ASMAtomicDecU32(&pEpFile->cReqsDelay);
350
351 /* Arm the delay. */
352 pTaskFile->tsDelayEnd = RTTimeProgramMilliTS() + tsDelay;
353
354 /* Append to the list. */
355 PPDMASYNCCOMPLETIONTASKFILE pHead = NULL;
356 do
357 {
358 pHead = ASMAtomicReadPtrT(&pEpFile->pDelayedHead, PPDMASYNCCOMPLETIONTASKFILE);
359 pTaskFile->pDelayedNext = pHead;
360 } while (!ASMAtomicCmpXchgPtr(&pEpFile->pDelayedHead, pTaskFile, pHead));
361
362 if (tsDelay < pEpClassFile->cMilliesNext)
363 {
364 ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, tsDelay);
365 TMTimerSetMillies(pEpClassFile->pTimer, tsDelay);
366 }
367
368 LogRel(("AIOMgr: Delaying request %#p for %u ms\n", pTaskFile, tsDelay));
369 }
370 else
371#endif
372 pdmR3AsyncCompletionCompleteTask(&pTaskFile->Core, pTaskFile->rc, true);
373 }
374 }
375}
376
377DECLINLINE(void) pdmacFileEpTaskInit(PPDMASYNCCOMPLETIONTASK pTask, size_t cbTransfer)
378{
379 PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pTask;
380
381 Assert((uint32_t)cbTransfer == cbTransfer && (int32_t)cbTransfer >= 0);
382 ASMAtomicWriteS32(&pTaskFile->cbTransferLeft, (int32_t)cbTransfer);
383 ASMAtomicWriteBool(&pTaskFile->fCompleted, false);
384 ASMAtomicWriteS32(&pTaskFile->rc, VINF_SUCCESS);
385}
386
387int pdmacFileEpTaskInitiate(PPDMASYNCCOMPLETIONTASK pTask,
388 PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
389 PCRTSGSEG paSegments, size_t cSegments,
390 size_t cbTransfer, PDMACTASKFILETRANSFER enmTransfer)
391{
392 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
393 PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pTask;
394
395 Assert( (enmTransfer == PDMACTASKFILETRANSFER_READ)
396 || (enmTransfer == PDMACTASKFILETRANSFER_WRITE));
397
398 for (size_t i = 0; i < cSegments; i++)
399 {
400 PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEpFile);
401 AssertPtr(pIoTask);
402
403 pIoTask->pEndpoint = pEpFile;
404 pIoTask->enmTransferType = enmTransfer;
405 pIoTask->Off = off;
406 pIoTask->DataSeg.cbSeg = paSegments[i].cbSeg;
407 pIoTask->DataSeg.pvSeg = paSegments[i].pvSeg;
408 pIoTask->pvUser = pTaskFile;
409 pIoTask->pfnCompleted = pdmacFileEpTaskCompleted;
410
411 /* Send it off to the I/O manager. */
412 pdmacFileEpAddTask(pEpFile, pIoTask);
413 off += paSegments[i].cbSeg;
414 cbTransfer -= paSegments[i].cbSeg;
415 }
416
417 AssertMsg(!cbTransfer, ("Incomplete transfer %u bytes left\n", cbTransfer));
418
419 return VINF_AIO_TASK_PENDING;
420}
421
422/**
423 * Creates a new async I/O manager.
424 *
425 * @returns VBox status code.
426 * @param pEpClass Pointer to the endpoint class data.
427 * @param ppAioMgr Where to store the pointer to the new async I/O manager on success.
428 * @param enmMgrType Wanted manager type - can be overwritten by the global override.
429 */
430int pdmacFileAioMgrCreate(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass, PPPDMACEPFILEMGR ppAioMgr,
431 PDMACEPFILEMGRTYPE enmMgrType)
432{
433 LogFlowFunc((": Entered\n"));
434
435 PPDMACEPFILEMGR pAioMgrNew;
436 int rc = MMR3HeapAllocZEx(pEpClass->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION, sizeof(PDMACEPFILEMGR), (void **)&pAioMgrNew);
437 if (RT_SUCCESS(rc))
438 {
439 if (enmMgrType < pEpClass->enmMgrTypeOverride)
440 pAioMgrNew->enmMgrType = enmMgrType;
441 else
442 pAioMgrNew->enmMgrType = pEpClass->enmMgrTypeOverride;
443
444 pAioMgrNew->msBwLimitExpired = RT_INDEFINITE_WAIT;
445
446 rc = RTSemEventCreate(&pAioMgrNew->EventSem);
447 if (RT_SUCCESS(rc))
448 {
449 rc = RTSemEventCreate(&pAioMgrNew->EventSemBlock);
450 if (RT_SUCCESS(rc))
451 {
452 rc = RTCritSectInit(&pAioMgrNew->CritSectBlockingEvent);
453 if (RT_SUCCESS(rc))
454 {
455 /* Init the rest of the manager. */
456 if (pAioMgrNew->enmMgrType != PDMACEPFILEMGRTYPE_SIMPLE)
457 rc = pdmacFileAioMgrNormalInit(pAioMgrNew);
458
459 if (RT_SUCCESS(rc))
460 {
461 pAioMgrNew->enmState = PDMACEPFILEMGRSTATE_RUNNING;
462
463 rc = RTThreadCreateF(&pAioMgrNew->Thread,
464 pAioMgrNew->enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE
465 ? pdmacFileAioMgrFailsafe
466 : pdmacFileAioMgrNormal,
467 pAioMgrNew,
468 0,
469 RTTHREADTYPE_IO,
470 0,
471 "AioMgr%d-%s", pEpClass->cAioMgrs,
472 pAioMgrNew->enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE
473 ? "F"
474 : "N");
475 if (RT_SUCCESS(rc))
476 {
477 /* Link it into the list. */
478 RTCritSectEnter(&pEpClass->CritSect);
479 pAioMgrNew->pNext = pEpClass->pAioMgrHead;
480 if (pEpClass->pAioMgrHead)
481 pEpClass->pAioMgrHead->pPrev = pAioMgrNew;
482 pEpClass->pAioMgrHead = pAioMgrNew;
483 pEpClass->cAioMgrs++;
484 RTCritSectLeave(&pEpClass->CritSect);
485
486 *ppAioMgr = pAioMgrNew;
487
488 Log(("PDMAC: Successfully created new file AIO Mgr {%s}\n", RTThreadGetName(pAioMgrNew->Thread)));
489 return VINF_SUCCESS;
490 }
491 pdmacFileAioMgrNormalDestroy(pAioMgrNew);
492 }
493 RTCritSectDelete(&pAioMgrNew->CritSectBlockingEvent);
494 }
495 RTSemEventDestroy(pAioMgrNew->EventSem);
496 }
497 RTSemEventDestroy(pAioMgrNew->EventSemBlock);
498 }
499 MMR3HeapFree(pAioMgrNew);
500 }
501
502 LogFlowFunc((": Leave rc=%Rrc\n", rc));
503
504 return rc;
505}
506
507/**
508 * Destroys a async I/O manager.
509 *
510 * @returns nothing.
511 * @param pEpClassFile Pointer to globals for the file endpoint class.
512 * @param pAioMgr The async I/O manager to destroy.
513 */
514static void pdmacFileAioMgrDestroy(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile, PPDMACEPFILEMGR pAioMgr)
515{
516 int rc = pdmacFileAioMgrShutdown(pAioMgr);
517 AssertRC(rc);
518
519 /* Unlink from the list. */
520 rc = RTCritSectEnter(&pEpClassFile->CritSect);
521 AssertRC(rc);
522
523 PPDMACEPFILEMGR pPrev = pAioMgr->pPrev;
524 PPDMACEPFILEMGR pNext = pAioMgr->pNext;
525
526 if (pPrev)
527 pPrev->pNext = pNext;
528 else
529 pEpClassFile->pAioMgrHead = pNext;
530
531 if (pNext)
532 pNext->pPrev = pPrev;
533
534 pEpClassFile->cAioMgrs--;
535 rc = RTCritSectLeave(&pEpClassFile->CritSect);
536 AssertRC(rc);
537
538 /* Free the resources. */
539 RTCritSectDelete(&pAioMgr->CritSectBlockingEvent);
540 RTSemEventDestroy(pAioMgr->EventSem);
541 if (pAioMgr->enmMgrType != PDMACEPFILEMGRTYPE_SIMPLE)
542 pdmacFileAioMgrNormalDestroy(pAioMgr);
543
544 MMR3HeapFree(pAioMgr);
545}
546
547static int pdmacFileMgrTypeFromName(const char *pszVal, PPDMACEPFILEMGRTYPE penmMgrType)
548{
549 int rc = VINF_SUCCESS;
550
551 if (!RTStrCmp(pszVal, "Simple"))
552 *penmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
553 else if (!RTStrCmp(pszVal, "Async"))
554 *penmMgrType = PDMACEPFILEMGRTYPE_ASYNC;
555 else
556 rc = VERR_CFGM_CONFIG_UNKNOWN_VALUE;
557
558 return rc;
559}
560
561static const char *pdmacFileMgrTypeToName(PDMACEPFILEMGRTYPE enmMgrType)
562{
563 if (enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE)
564 return "Simple";
565 if (enmMgrType == PDMACEPFILEMGRTYPE_ASYNC)
566 return "Async";
567
568 return NULL;
569}
570
571static int pdmacFileBackendTypeFromName(const char *pszVal, PPDMACFILEEPBACKEND penmBackendType)
572{
573 int rc = VINF_SUCCESS;
574
575 if (!RTStrCmp(pszVal, "Buffered"))
576 *penmBackendType = PDMACFILEEPBACKEND_BUFFERED;
577 else if (!RTStrCmp(pszVal, "NonBuffered"))
578 *penmBackendType = PDMACFILEEPBACKEND_NON_BUFFERED;
579 else
580 rc = VERR_CFGM_CONFIG_UNKNOWN_VALUE;
581
582 return rc;
583}
584
585static const char *pdmacFileBackendTypeToName(PDMACFILEEPBACKEND enmBackendType)
586{
587 if (enmBackendType == PDMACFILEEPBACKEND_BUFFERED)
588 return "Buffered";
589 if (enmBackendType == PDMACFILEEPBACKEND_NON_BUFFERED)
590 return "NonBuffered";
591
592 return NULL;
593}
594
595#ifdef VBOX_WITH_DEBUGGER
596
597/**
598 * @callback_method_impl{FNDBGCCMD, The '.injecterror' command.}
599 */
600static DECLCALLBACK(int) pdmacEpFileErrorInject(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR pArgs, unsigned cArgs)
601{
602 /*
603 * Validate input.
604 */
605 DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
606 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs == 3);
607 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, pArgs[0].enmType == DBGCVAR_TYPE_STRING);
608 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, pArgs[1].enmType == DBGCVAR_TYPE_STRING);
609 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 2, pArgs[2].enmType == DBGCVAR_TYPE_NUMBER);
610
611 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile;
612 pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pUVM->pdm.s.apAsyncCompletionEndpointClass[PDMASYNCCOMPLETIONEPCLASSTYPE_FILE];
613
614 /* Syntax is "read|write <filename> <status code>" */
615 bool fWrite;
616 if (!RTStrCmp(pArgs[0].u.pszString, "read"))
617 fWrite = false;
618 else if (!RTStrCmp(pArgs[0].u.pszString, "write"))
619 fWrite = true;
620 else
621 return DBGCCmdHlpFail(pCmdHlp, pCmd, "invalid transfer direction '%s'", pArgs[0].u.pszString);
622
623 int32_t rcToInject = (int32_t)pArgs[2].u.u64Number;
624 if ((uint64_t)rcToInject != pArgs[2].u.u64Number)
625 return DBGCCmdHlpFail(pCmdHlp, pCmd, "The status code '%lld' is out of range", pArgs[0].u.u64Number);
626
627 /*
628 * Search for the matching endpoint.
629 */
630 RTCritSectEnter(&pEpClassFile->Core.CritSect);
631
632 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpClassFile->Core.pEndpointsHead;
633 while (pEpFile)
634 {
635 if (!RTStrCmp(pArgs[1].u.pszString, RTPathFilename(pEpFile->Core.pszUri)))
636 break;
637 pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpFile->Core.pNext;
638 }
639
640 if (pEpFile)
641 {
642 /*
643 * Do the job.
644 */
645 if (fWrite)
646 ASMAtomicXchgS32(&pEpFile->rcReqWrite, rcToInject);
647 else
648 ASMAtomicXchgS32(&pEpFile->rcReqRead, rcToInject);
649
650 DBGCCmdHlpPrintf(pCmdHlp, "Injected %Rrc into '%s' for %s\n",
651 (int)rcToInject, pArgs[1].u.pszString, pArgs[0].u.pszString);
652 }
653
654 RTCritSectLeave(&pEpClassFile->Core.CritSect);
655
656 if (!pEpFile)
657 return DBGCCmdHlpFail(pCmdHlp, pCmd, "No file with name '%s' found", pArgs[1].u.pszString);
658 return VINF_SUCCESS;
659}
660
661# ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
662/**
663 * @callback_method_impl{FNDBGCCMD, The '.injectdelay' command.}
664 */
665static DECLCALLBACK(int) pdmacEpFileDelayInject(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR pArgs, unsigned cArgs)
666{
667 /*
668 * Validate input.
669 */
670 DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
671 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs >= 3);
672 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, pArgs[0].enmType == DBGCVAR_TYPE_STRING);
673 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, pArgs[1].enmType == DBGCVAR_TYPE_STRING);
674 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 2, pArgs[2].enmType == DBGCVAR_TYPE_NUMBER);
675
676 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile;
677 pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pUVM->pdm.s.apAsyncCompletionEndpointClass[PDMASYNCCOMPLETIONEPCLASSTYPE_FILE];
678
679 /* Syntax is "read|write|flush|any <filename> <delay> [reqs]" */
680 PDMACFILEREQTYPEDELAY enmDelayType = PDMACFILEREQTYPEDELAY_ANY;
681 if (!RTStrCmp(pArgs[0].u.pszString, "read"))
682 enmDelayType = PDMACFILEREQTYPEDELAY_READ;
683 else if (!RTStrCmp(pArgs[0].u.pszString, "write"))
684 enmDelayType = PDMACFILEREQTYPEDELAY_WRITE;
685 else if (!RTStrCmp(pArgs[0].u.pszString, "flush"))
686 enmDelayType = PDMACFILEREQTYPEDELAY_FLUSH;
687 else if (!RTStrCmp(pArgs[0].u.pszString, "any"))
688 enmDelayType = PDMACFILEREQTYPEDELAY_ANY;
689 else
690 return DBGCCmdHlpFail(pCmdHlp, pCmd, "invalid transfer direction '%s'", pArgs[0].u.pszString);
691
692 uint32_t msDelay = (uint32_t)pArgs[2].u.u64Number;
693 if ((uint64_t)msDelay != pArgs[2].u.u64Number)
694 return DBGCCmdHlpFail(pCmdHlp, pCmd, "The delay '%lld' is out of range", pArgs[0].u.u64Number);
695
696 uint32_t cReqsDelay = 1;
697 uint32_t msJitter = 0;
698 if (cArgs >= 4)
699 msJitter = (uint32_t)pArgs[3].u.u64Number;
700 if (cArgs == 5)
701 cReqsDelay = (uint32_t)pArgs[4].u.u64Number;
702
703 /*
704 * Search for the matching endpoint.
705 */
706 RTCritSectEnter(&pEpClassFile->Core.CritSect);
707
708 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpClassFile->Core.pEndpointsHead;
709 while (pEpFile)
710 {
711 if (!RTStrCmp(pArgs[1].u.pszString, RTPathFilename(pEpFile->Core.pszUri)))
712 break;
713 pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpFile->Core.pNext;
714 }
715
716 if (pEpFile)
717 {
718 ASMAtomicWriteSize(&pEpFile->enmTypeDelay, enmDelayType);
719 ASMAtomicWriteU32(&pEpFile->msDelay, msDelay);
720 ASMAtomicWriteU32(&pEpFile->msJitter, msJitter);
721 ASMAtomicWriteU32(&pEpFile->cReqsDelay, cReqsDelay);
722
723 DBGCCmdHlpPrintf(pCmdHlp, "Injected delay for the next %u requests of %u ms into '%s' for %s\n",
724 cReqsDelay, msDelay, pArgs[1].u.pszString, pArgs[0].u.pszString);
725 }
726
727 RTCritSectLeave(&pEpClassFile->Core.CritSect);
728
729 if (!pEpFile)
730 return DBGCCmdHlpFail(pCmdHlp, pCmd, "No file with name '%s' found", pArgs[1].u.pszString);
731 return VINF_SUCCESS;
732}
733
734static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
735{
736 uint64_t tsCur = RTTimeProgramMilliTS();
737 uint64_t cMilliesNext = UINT64_MAX;
738 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pvUser;
739
740 ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, UINT64_MAX);
741
742 /* Go through all endpoints and check for expired requests. */
743 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpClassFile->Core.pEndpointsHead;
744
745 while (pEpFile)
746 {
747 /* Check for an expired delay. */
748 if (pEpFile->pDelayedHead != NULL)
749 {
750 PPDMASYNCCOMPLETIONTASKFILE pTaskFile = ASMAtomicXchgPtrT(&pEpFile->pDelayedHead, NULL, PPDMASYNCCOMPLETIONTASKFILE);
751
752 while (pTaskFile)
753 {
754 PPDMASYNCCOMPLETIONTASKFILE pTmp = pTaskFile;
755 pTaskFile = pTaskFile->pDelayedNext;
756
757 if (tsCur >= pTmp->tsDelayEnd)
758 {
759 LogRel(("AIOMgr: Delayed request %#p completed\n", pTmp));
760 pdmR3AsyncCompletionCompleteTask(&pTmp->Core, pTmp->rc, true);
761 }
762 else
763 {
764 /* Prepend to the delayed list again. */
765 PPDMASYNCCOMPLETIONTASKFILE pHead = NULL;
766
767 if (pTmp->tsDelayEnd - tsCur < cMilliesNext)
768 cMilliesNext = pTmp->tsDelayEnd - tsCur;
769
770 do
771 {
772 pHead = ASMAtomicReadPtrT(&pEpFile->pDelayedHead, PPDMASYNCCOMPLETIONTASKFILE);
773 pTmp->pDelayedNext = pHead;
774 } while (!ASMAtomicCmpXchgPtr(&pEpFile->pDelayedHead, pTmp, pHead));
775 }
776 }
777 }
778
779 pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEpFile->Core.pNext;
780 }
781
782 if (cMilliesNext < pEpClassFile->cMilliesNext)
783 {
784 ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, cMilliesNext);
785 TMTimerSetMillies(pEpClassFile->pTimer, cMilliesNext);
786 }
787}
788
789# endif /* PDM_ASYNC_COMPLETION_FILE_WITH_DELAY */
790
791#endif /* VBOX_WITH_DEBUGGER */
792
793static DECLCALLBACK(int) pdmacFileInitialize(PPDMASYNCCOMPLETIONEPCLASS pClassGlobals, PCFGMNODE pCfgNode)
794{
795 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pClassGlobals;
796 RTFILEAIOLIMITS AioLimits; /** < Async I/O limitations. */
797
798 int rc = RTFileAioGetLimits(&AioLimits);
799#ifdef DEBUG
800 if (RT_SUCCESS(rc) && RTEnvExist("VBOX_ASYNC_IO_FAILBACK"))
801 rc = VERR_ENV_VAR_NOT_FOUND;
802#endif
803 if (RT_FAILURE(rc))
804 {
805 LogRel(("AIO: Async I/O manager not supported (rc=%Rrc). Falling back to simple manager\n", rc));
806 pEpClassFile->enmMgrTypeOverride = PDMACEPFILEMGRTYPE_SIMPLE;
807 pEpClassFile->enmEpBackendDefault = PDMACFILEEPBACKEND_BUFFERED;
808 }
809 else
810 {
811 pEpClassFile->uBitmaskAlignment = AioLimits.cbBufferAlignment ? ~((RTR3UINTPTR)AioLimits.cbBufferAlignment - 1) : RTR3UINTPTR_MAX;
812 pEpClassFile->cReqsOutstandingMax = AioLimits.cReqsOutstandingMax;
813
814 if (pCfgNode)
815 {
816 /* Query the default manager type */
817 char *pszVal = NULL;
818 rc = CFGMR3QueryStringAllocDef(pCfgNode, "IoMgr", &pszVal, "Async");
819 AssertLogRelRCReturn(rc, rc);
820
821 rc = pdmacFileMgrTypeFromName(pszVal, &pEpClassFile->enmMgrTypeOverride);
822 MMR3HeapFree(pszVal);
823 if (RT_FAILURE(rc))
824 return rc;
825
826 LogRel(("AIOMgr: Default manager type is '%s'\n", pdmacFileMgrTypeToName(pEpClassFile->enmMgrTypeOverride)));
827
828 /* Query default backend type */
829 rc = CFGMR3QueryStringAllocDef(pCfgNode, "FileBackend", &pszVal, "NonBuffered");
830 AssertLogRelRCReturn(rc, rc);
831
832 rc = pdmacFileBackendTypeFromName(pszVal, &pEpClassFile->enmEpBackendDefault);
833 MMR3HeapFree(pszVal);
834 if (RT_FAILURE(rc))
835 return rc;
836
837 LogRel(("AIOMgr: Default file backend is '%s'\n", pdmacFileBackendTypeToName(pEpClassFile->enmEpBackendDefault)));
838
839#ifdef RT_OS_LINUX
840 if ( pEpClassFile->enmMgrTypeOverride == PDMACEPFILEMGRTYPE_ASYNC
841 && pEpClassFile->enmEpBackendDefault == PDMACFILEEPBACKEND_BUFFERED)
842 {
843 LogRel(("AIOMgr: Linux does not support buffered async I/O, changing to non buffered\n"));
844 pEpClassFile->enmEpBackendDefault = PDMACFILEEPBACKEND_NON_BUFFERED;
845 }
846#endif
847 }
848 else
849 {
850 /* No configuration supplied, set defaults */
851 pEpClassFile->enmEpBackendDefault = PDMACFILEEPBACKEND_NON_BUFFERED;
852 pEpClassFile->enmMgrTypeOverride = PDMACEPFILEMGRTYPE_ASYNC;
853 }
854 }
855
856 /* Init critical section. */
857 rc = RTCritSectInit(&pEpClassFile->CritSect);
858
859#ifdef VBOX_WITH_DEBUGGER
860 /* Install the error injection handler. */
861 if (RT_SUCCESS(rc))
862 {
863 rc = DBGCRegisterCommands(&g_aCmds[0], RT_ELEMENTS(g_aCmds));
864 AssertRC(rc);
865 }
866
867#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
868 rc = TMR3TimerCreateInternal(pEpClassFile->Core.pVM, TMCLOCK_REAL, pdmacR3TimerCallback, pEpClassFile, "AC Delay", &pEpClassFile->pTimer);
869 AssertRC(rc);
870 pEpClassFile->cMilliesNext = UINT64_MAX;
871#endif
872#endif
873
874 return rc;
875}
876
877static DECLCALLBACK(void) pdmacFileTerminate(PPDMASYNCCOMPLETIONEPCLASS pClassGlobals)
878{
879 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pClassGlobals;
880
881 /* All endpoints should be closed at this point. */
882 AssertMsg(!pEpClassFile->Core.pEndpointsHead, ("There are still endpoints left\n"));
883
884 /* Destroy all left async I/O managers. */
885 while (pEpClassFile->pAioMgrHead)
886 pdmacFileAioMgrDestroy(pEpClassFile, pEpClassFile->pAioMgrHead);
887
888 RTCritSectDelete(&pEpClassFile->CritSect);
889}
890
891static DECLCALLBACK(int) pdmacFileEpInitialize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint,
892 const char *pszUri, uint32_t fFlags)
893{
894 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
895 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->pEpClass;
896 PDMACEPFILEMGRTYPE enmMgrType = pEpClassFile->enmMgrTypeOverride;
897 PDMACFILEEPBACKEND enmEpBackend = pEpClassFile->enmEpBackendDefault;
898
899 AssertMsgReturn((fFlags & ~(PDMACEP_FILE_FLAGS_READ_ONLY | PDMACEP_FILE_FLAGS_DONT_LOCK | PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED)) == 0,
900 ("PDMAsyncCompletion: Invalid flag specified\n"), VERR_INVALID_PARAMETER);
901
902 unsigned fFileFlags = RTFILE_O_OPEN;
903
904 /*
905 * Revert to the simple manager and the buffered backend if
906 * the host cache should be enabled.
907 */
908 if (fFlags & PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED)
909 {
910 enmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
911 enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
912 }
913
914 if (fFlags & PDMACEP_FILE_FLAGS_READ_ONLY)
915 fFileFlags |= RTFILE_O_READ | RTFILE_O_DENY_NONE;
916 else
917 {
918 fFileFlags |= RTFILE_O_READWRITE;
919
920 /*
921 * Opened in read/write mode. Check whether the caller wants to
922 * avoid the lock. Return an error in case caching is enabled
923 * because this can lead to data corruption.
924 */
925 if (fFlags & PDMACEP_FILE_FLAGS_DONT_LOCK)
926 fFileFlags |= RTFILE_O_DENY_NONE;
927 else
928 fFileFlags |= RTFILE_O_DENY_WRITE;
929 }
930
931 if (enmMgrType == PDMACEPFILEMGRTYPE_ASYNC)
932 fFileFlags |= RTFILE_O_ASYNC_IO;
933
934 int rc;
935 if (enmEpBackend == PDMACFILEEPBACKEND_NON_BUFFERED)
936 {
937 /*
938 * We only disable the cache if the size of the file is a multiple of 512.
939 * Certain hosts like Windows, Linux and Solaris require that transfer sizes
940 * are aligned to the volume sector size.
941 * If not we just make sure that the data is written to disk with RTFILE_O_WRITE_THROUGH
942 * which will trash the host cache but ensures that the host cache will not
943 * contain dirty buffers.
944 */
945 RTFILE hFile;
946 rc = RTFileOpen(&hFile, pszUri, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
947 if (RT_SUCCESS(rc))
948 {
949 uint64_t cbSize;
950
951 rc = RTFileGetSize(hFile, &cbSize);
952
953 if (RT_SUCCESS(rc) && ((cbSize % 512) == 0))
954 fFileFlags |= RTFILE_O_NO_CACHE;
955 else
956 {
957 /* Downgrade to the buffered backend */
958 enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
959
960#ifdef RT_OS_LINUX
961 fFileFlags &= ~RTFILE_O_ASYNC_IO;
962 enmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
963#endif
964 }
965 RTFileClose(hFile);
966 }
967 }
968
969 /* Open with final flags. */
970 rc = RTFileOpen(&pEpFile->hFile, pszUri, fFileFlags);
971 if ( rc == VERR_INVALID_FUNCTION
972 || rc == VERR_INVALID_PARAMETER)
973 {
974 LogRel(("AIOMgr: pdmacFileEpInitialize: RTFileOpen %s / %08x failed with %Rrc\n",
975 pszUri, fFileFlags, rc));
976 /*
977 * Solaris doesn't support directio on ZFS so far. :-\
978 * Trying to enable it returns VERR_INVALID_FUNCTION
979 * (ENOTTY). Remove it and hope for the best.
980 * ZFS supports write throttling in case applications
981 * write more data than can be synced to the disk
982 * without blocking the whole application.
983 *
984 * On Linux we have the same problem with cifs.
985 * Have to disable async I/O here too because it requires O_DIRECT.
986 */
987 fFileFlags &= ~RTFILE_O_NO_CACHE;
988 enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
989
990#ifdef RT_OS_LINUX
991 fFileFlags &= ~RTFILE_O_ASYNC_IO;
992 enmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
993#endif
994
995 /* Open again. */
996 rc = RTFileOpen(&pEpFile->hFile, pszUri, fFileFlags);
997
998 if (RT_FAILURE(rc))
999 {
1000 LogRel(("AIOMgr: pdmacFileEpInitialize: RTFileOpen %s / %08x failed AGAIN(!) with %Rrc\n",
1001 pszUri, fFileFlags, rc));
1002 }
1003 }
1004
1005 if (RT_SUCCESS(rc))
1006 {
1007 pEpFile->fFlags = fFileFlags;
1008
1009 rc = RTFileGetSize(pEpFile->hFile, (uint64_t *)&pEpFile->cbFile);
1010 if (RT_SUCCESS(rc))
1011 {
1012 /* Initialize the segment cache */
1013 rc = MMR3HeapAllocZEx(pEpClassFile->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION,
1014 sizeof(PDMACTASKFILE),
1015 (void **)&pEpFile->pTasksFreeHead);
1016 if (RT_SUCCESS(rc))
1017 {
1018 PPDMACEPFILEMGR pAioMgr = NULL;
1019
1020 pEpFile->pTasksFreeTail = pEpFile->pTasksFreeHead;
1021 pEpFile->cTasksCached = 0;
1022 pEpFile->enmBackendType = enmEpBackend;
1023 /*
1024 * Disable async flushes on Solaris for now.
1025 * They cause weird hangs which needs more investigations.
1026 */
1027#ifndef RT_OS_SOLARIS
1028 pEpFile->fAsyncFlushSupported = true;
1029#else
1030 pEpFile->fAsyncFlushSupported = false;
1031#endif
1032
1033 if (enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE)
1034 {
1035 /* Simple mode. Every file has its own async I/O manager. */
1036 rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgr, PDMACEPFILEMGRTYPE_SIMPLE);
1037 }
1038 else
1039 {
1040 pAioMgr = pEpClassFile->pAioMgrHead;
1041
1042 /* Check for an idling manager of the same type */
1043 while (pAioMgr)
1044 {
1045 if (pAioMgr->enmMgrType == enmMgrType)
1046 break;
1047 pAioMgr = pAioMgr->pNext;
1048 }
1049
1050 if (!pAioMgr)
1051 rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgr, enmMgrType);
1052 }
1053
1054 if (RT_SUCCESS(rc))
1055 {
1056 pEpFile->AioMgr.pTreeRangesLocked = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
1057 if (!pEpFile->AioMgr.pTreeRangesLocked)
1058 rc = VERR_NO_MEMORY;
1059 else
1060 {
1061 pEpFile->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
1062
1063 /* Assign the endpoint to the thread. */
1064 rc = pdmacFileAioMgrAddEndpoint(pAioMgr, pEpFile);
1065 if (RT_FAILURE(rc))
1066 {
1067 RTMemFree(pEpFile->AioMgr.pTreeRangesLocked);
1068 MMR3HeapFree(pEpFile->pTasksFreeHead);
1069 }
1070 }
1071 }
1072 else if (rc == VERR_FILE_AIO_INSUFFICIENT_EVENTS)
1073 {
1074 PUVM pUVM = VMR3GetUVM(pEpClassFile->Core.pVM);
1075#if defined(RT_OS_LINUX)
1076 rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
1077 N_("Failed to create I/O manager for VM due to insufficient resources on the host. "
1078 "Either increase the amount of allowed events in /proc/sys/fs/aio-max-nr or enable "
1079 "the host I/O cache"));
1080#else
1081 rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
1082 N_("Failed to create I/O manager for VM due to insufficient resources on the host. "
1083 "Enable the host I/O cache"));
1084#endif
1085 }
1086 else
1087 {
1088 PUVM pUVM = VMR3GetUVM(pEpClassFile->Core.pVM);
1089 rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
1090 N_("Failed to create I/O manager for VM due to an unknown error"));
1091 }
1092 }
1093 }
1094
1095 if (RT_FAILURE(rc))
1096 RTFileClose(pEpFile->hFile);
1097 }
1098
1099#ifdef VBOX_WITH_STATISTICS
1100 if (RT_SUCCESS(rc))
1101 {
1102 STAMR3RegisterF(pEpClassFile->Core.pVM, &pEpFile->StatRead,
1103 STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
1104 STAMUNIT_TICKS_PER_CALL, "Time taken to read from the endpoint",
1105 "/PDM/AsyncCompletion/File/%s/%d/Read", RTPathFilename(pEpFile->Core.pszUri), pEpFile->Core.iStatId);
1106
1107 STAMR3RegisterF(pEpClassFile->Core.pVM, &pEpFile->StatWrite,
1108 STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
1109 STAMUNIT_TICKS_PER_CALL, "Time taken to write to the endpoint",
1110 "/PDM/AsyncCompletion/File/%s/%d/Write", RTPathFilename(pEpFile->Core.pszUri), pEpFile->Core.iStatId);
1111 }
1112#endif
1113
1114 if (RT_SUCCESS(rc))
1115 LogRel(("AIOMgr: Endpoint for file '%s' (flags %08x) created successfully\n", pszUri, pEpFile->fFlags));
1116
1117 return rc;
1118}
1119
1120static DECLCALLBACK(int) pdmacFileEpRangesLockedDestroy(PAVLRFOFFNODECORE pNode, void *pvUser)
1121{
1122 NOREF(pNode); NOREF(pvUser);
1123 AssertMsgFailed(("The locked ranges tree should be empty at that point\n"));
1124 return VINF_SUCCESS;
1125}
1126
1127static DECLCALLBACK(int) pdmacFileEpClose(PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
1128{
1129 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
1130 PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->pEpClass;
1131
1132 /* Make sure that all tasks finished for this endpoint. */
1133 int rc = pdmacFileAioMgrCloseEndpoint(pEpFile->pAioMgr, pEpFile);
1134 AssertRC(rc);
1135
1136 /*
1137 * If the async I/O manager is in failsafe mode this is the only endpoint
1138 * he processes and thus can be destroyed now.
1139 */
1140 if (pEpFile->pAioMgr->enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE)
1141 pdmacFileAioMgrDestroy(pEpClassFile, pEpFile->pAioMgr);
1142
1143 /* Free cached tasks. */
1144 PPDMACTASKFILE pTask = pEpFile->pTasksFreeHead;
1145
1146 while (pTask)
1147 {
1148 PPDMACTASKFILE pTaskFree = pTask;
1149 pTask = pTask->pNext;
1150 MMR3HeapFree(pTaskFree);
1151 }
1152
1153 /* Destroy the locked ranges tree now. */
1154 RTAvlrFileOffsetDestroy(pEpFile->AioMgr.pTreeRangesLocked, pdmacFileEpRangesLockedDestroy, NULL);
1155
1156 RTFileClose(pEpFile->hFile);
1157
1158#ifdef VBOX_WITH_STATISTICS
1159 /* Not sure if this might be unnecessary because of similar statement in pdmR3AsyncCompletionStatisticsDeregister? */
1160 STAMR3DeregisterF(pEpClassFile->Core.pVM->pUVM, "/PDM/AsyncCompletion/File/%s/*", RTPathFilename(pEpFile->Core.pszUri));
1161#endif
1162
1163 return VINF_SUCCESS;
1164}
1165
1166static DECLCALLBACK(int) pdmacFileEpRead(PPDMASYNCCOMPLETIONTASK pTask,
1167 PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
1168 PCRTSGSEG paSegments, size_t cSegments,
1169 size_t cbRead)
1170{
1171 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
1172
1173 LogFlowFunc(("pTask=%#p pEndpoint=%#p off=%RTfoff paSegments=%#p cSegments=%zu cbRead=%zu\n",
1174 pTask, pEndpoint, off, paSegments, cSegments, cbRead));
1175
1176 if (RT_UNLIKELY((uint64_t)off + cbRead > pEpFile->cbFile))
1177 return VERR_EOF;
1178
1179 STAM_PROFILE_ADV_START(&pEpFile->StatRead, Read);
1180 pdmacFileEpTaskInit(pTask, cbRead);
1181 int rc = pdmacFileEpTaskInitiate(pTask, pEndpoint, off, paSegments, cSegments, cbRead,
1182 PDMACTASKFILETRANSFER_READ);
1183 STAM_PROFILE_ADV_STOP(&pEpFile->StatRead, Read);
1184
1185 return rc;
1186}
1187
1188static DECLCALLBACK(int) pdmacFileEpWrite(PPDMASYNCCOMPLETIONTASK pTask,
1189 PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
1190 PCRTSGSEG paSegments, size_t cSegments,
1191 size_t cbWrite)
1192{
1193 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
1194
1195 if (RT_UNLIKELY(pEpFile->fReadonly))
1196 return VERR_NOT_SUPPORTED;
1197
1198 STAM_PROFILE_ADV_START(&pEpFile->StatWrite, Write);
1199
1200 pdmacFileEpTaskInit(pTask, cbWrite);
1201
1202 int rc = pdmacFileEpTaskInitiate(pTask, pEndpoint, off, paSegments, cSegments, cbWrite,
1203 PDMACTASKFILETRANSFER_WRITE);
1204
1205 STAM_PROFILE_ADV_STOP(&pEpFile->StatWrite, Write);
1206
1207 return rc;
1208}
1209
1210static DECLCALLBACK(int) pdmacFileEpFlush(PPDMASYNCCOMPLETIONTASK pTask,
1211 PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
1212{
1213 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
1214 PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pTask;
1215
1216 if (RT_UNLIKELY(pEpFile->fReadonly))
1217 return VERR_NOT_SUPPORTED;
1218
1219 pdmacFileEpTaskInit(pTask, 0);
1220
1221 PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEpFile);
1222 if (RT_UNLIKELY(!pIoTask))
1223 return VERR_NO_MEMORY;
1224
1225 pIoTask->pEndpoint = pEpFile;
1226 pIoTask->enmTransferType = PDMACTASKFILETRANSFER_FLUSH;
1227 pIoTask->pvUser = pTaskFile;
1228 pIoTask->pfnCompleted = pdmacFileEpTaskCompleted;
1229 pdmacFileEpAddTask(pEpFile, pIoTask);
1230
1231 return VINF_AIO_TASK_PENDING;
1232}
1233
1234static DECLCALLBACK(int) pdmacFileEpGetSize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t *pcbSize)
1235{
1236 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
1237
1238 *pcbSize = ASMAtomicReadU64(&pEpFile->cbFile);
1239
1240 return VINF_SUCCESS;
1241}
1242
1243static DECLCALLBACK(int) pdmacFileEpSetSize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbSize)
1244{
1245 int rc;
1246 PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
1247
1248 rc = RTFileSetSize(pEpFile->hFile, cbSize);
1249 if (RT_SUCCESS(rc))
1250 ASMAtomicWriteU64(&pEpFile->cbFile, cbSize);
1251
1252 return rc;
1253}
1254
1255const PDMASYNCCOMPLETIONEPCLASSOPS g_PDMAsyncCompletionEndpointClassFile =
1256{
1257 /* u32Version */
1258 PDMAC_EPCLASS_OPS_VERSION,
1259 /* pcszName */
1260 "File",
1261 /* enmClassType */
1262 PDMASYNCCOMPLETIONEPCLASSTYPE_FILE,
1263 /* cbEndpointClassGlobal */
1264 sizeof(PDMASYNCCOMPLETIONEPCLASSFILE),
1265 /* cbEndpoint */
1266 sizeof(PDMASYNCCOMPLETIONENDPOINTFILE),
1267 /* cbTask */
1268 sizeof(PDMASYNCCOMPLETIONTASKFILE),
1269 /* pfnInitialize */
1270 pdmacFileInitialize,
1271 /* pfnTerminate */
1272 pdmacFileTerminate,
1273 /* pfnEpInitialize. */
1274 pdmacFileEpInitialize,
1275 /* pfnEpClose */
1276 pdmacFileEpClose,
1277 /* pfnEpRead */
1278 pdmacFileEpRead,
1279 /* pfnEpWrite */
1280 pdmacFileEpWrite,
1281 /* pfnEpFlush */
1282 pdmacFileEpFlush,
1283 /* pfnEpGetSize */
1284 pdmacFileEpGetSize,
1285 /* pfnEpSetSize */
1286 pdmacFileEpSetSize,
1287 /* u32VersionEnd */
1288 PDMAC_EPCLASS_OPS_VERSION
1289};
1290
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette