VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMAsyncCompletionFileFailsafe.cpp@ 61574

Last change on this file since 61574 was 57358, checked in by vboxsync, 9 years ago

*: scm cleanup run.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.1 KB
Line 
1/* $Id: PDMAsyncCompletionFileFailsafe.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2/** @file
3 * PDM Async I/O - Transport data asynchronous in R3 using EMT.
4 * Simple File I/O manager.
5 */
6
7/*
8 * Copyright (C) 2006-2015 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19
20/*********************************************************************************************************************************
21* Header Files *
22*********************************************************************************************************************************/
23#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
24#include <iprt/asm.h>
25#include <iprt/assert.h>
26#include <VBox/log.h>
27
28#include "PDMAsyncCompletionFileInternal.h"
29
30/**
31 * Put a list of tasks in the pending request list of an endpoint.
32 */
33DECLINLINE(void) pdmacFileAioMgrEpAddTaskList(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTaskHead)
34{
35 /* Add the rest of the tasks to the pending list */
36 if (!pEndpoint->AioMgr.pReqsPendingHead)
37 {
38 Assert(!pEndpoint->AioMgr.pReqsPendingTail);
39 pEndpoint->AioMgr.pReqsPendingHead = pTaskHead;
40 }
41 else
42 {
43 Assert(pEndpoint->AioMgr.pReqsPendingTail);
44 pEndpoint->AioMgr.pReqsPendingTail->pNext = pTaskHead;
45 }
46
47 /* Update the tail. */
48 while (pTaskHead->pNext)
49 pTaskHead = pTaskHead->pNext;
50
51 pEndpoint->AioMgr.pReqsPendingTail = pTaskHead;
52 pTaskHead->pNext = NULL;
53}
54
55/**
56 * Processes a given task list for assigned to the given endpoint.
57 */
58static int pdmacFileAioMgrFailsafeProcessEndpointTaskList(PPDMACEPFILEMGR pAioMgr,
59 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
60 PPDMACTASKFILE pTasks)
61{
62 int rc = VINF_SUCCESS;
63
64 while (pTasks)
65 {
66 RTMSINTERVAL msWhenNext;
67 PPDMACTASKFILE pCurr = pTasks;
68
69 if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
70 {
71 pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);
72 break;
73 }
74
75 pTasks = pTasks->pNext;
76
77 switch (pCurr->enmTransferType)
78 {
79 case PDMACTASKFILETRANSFER_FLUSH:
80 {
81 rc = RTFileFlush(pEndpoint->hFile);
82 break;
83 }
84 case PDMACTASKFILETRANSFER_READ:
85 case PDMACTASKFILETRANSFER_WRITE:
86 {
87 if (pCurr->enmTransferType == PDMACTASKFILETRANSFER_READ)
88 {
89 rc = RTFileReadAt(pEndpoint->hFile, pCurr->Off,
90 pCurr->DataSeg.pvSeg,
91 pCurr->DataSeg.cbSeg,
92 NULL);
93 }
94 else
95 {
96 if (RT_UNLIKELY((uint64_t)pCurr->Off + pCurr->DataSeg.cbSeg > pEndpoint->cbFile))
97 {
98 ASMAtomicWriteU64(&pEndpoint->cbFile, pCurr->Off + pCurr->DataSeg.cbSeg);
99 RTFileSetSize(pEndpoint->hFile, pCurr->Off + pCurr->DataSeg.cbSeg);
100 }
101
102 rc = RTFileWriteAt(pEndpoint->hFile, pCurr->Off,
103 pCurr->DataSeg.pvSeg,
104 pCurr->DataSeg.cbSeg,
105 NULL);
106 }
107
108 break;
109 }
110 default:
111 AssertMsgFailed(("Invalid transfer type %d\n", pTasks->enmTransferType));
112 }
113
114 pCurr->pfnCompleted(pCurr, pCurr->pvUser, rc);
115 pdmacFileTaskFree(pEndpoint, pCurr);
116 }
117
118 if (pTasks)
119 {
120 /* Add the rest of the tasks to the pending list */
121 pdmacFileAioMgrEpAddTaskList(pEndpoint, pTasks);
122 }
123
124 return VINF_SUCCESS;
125}
126
127static int pdmacFileAioMgrFailsafeProcessEndpoint(PPDMACEPFILEMGR pAioMgr,
128 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint)
129{
130 int rc = VINF_SUCCESS;
131 PPDMACTASKFILE pTasks = pEndpoint->AioMgr.pReqsPendingHead;
132
133 pEndpoint->AioMgr.pReqsPendingHead = NULL;
134 pEndpoint->AioMgr.pReqsPendingTail = NULL;
135
136 /* Process the request pending list first in case the endpoint was migrated due to an error. */
137 if (pTasks)
138 rc = pdmacFileAioMgrFailsafeProcessEndpointTaskList(pAioMgr, pEndpoint, pTasks);
139
140 if (RT_SUCCESS(rc))
141 {
142 pTasks = pdmacFileEpGetNewTasks(pEndpoint);
143
144 if (pTasks)
145 rc = pdmacFileAioMgrFailsafeProcessEndpointTaskList(pAioMgr, pEndpoint, pTasks);
146 }
147
148 return rc;
149}
150
151/**
152 * A fallback method in case something goes wrong with the normal
153 * I/O manager.
154 */
155DECLCALLBACK(int) pdmacFileAioMgrFailsafe(RTTHREAD hThreadSelf, void *pvUser)
156{
157 int rc = VINF_SUCCESS;
158 PPDMACEPFILEMGR pAioMgr = (PPDMACEPFILEMGR)pvUser;
159 NOREF(hThreadSelf);
160
161 while ( (pAioMgr->enmState == PDMACEPFILEMGRSTATE_RUNNING)
162 || (pAioMgr->enmState == PDMACEPFILEMGRSTATE_SUSPENDING))
163 {
164 ASMAtomicWriteBool(&pAioMgr->fWaitingEventSem, true);
165 if (!ASMAtomicReadBool(&pAioMgr->fWokenUp))
166 rc = RTSemEventWait(pAioMgr->EventSem, pAioMgr->msBwLimitExpired);
167 ASMAtomicWriteBool(&pAioMgr->fWaitingEventSem, false);
168 Assert(RT_SUCCESS(rc) || rc == VERR_TIMEOUT);
169
170 LogFlow(("Got woken up\n"));
171 ASMAtomicWriteBool(&pAioMgr->fWokenUp, false);
172
173 /* Process endpoint events first. */
174 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint = pAioMgr->pEndpointsHead;
175 while (pEndpoint)
176 {
177 pAioMgr->msBwLimitExpired = RT_INDEFINITE_WAIT;
178 rc = pdmacFileAioMgrFailsafeProcessEndpoint(pAioMgr, pEndpoint);
179 AssertRC(rc);
180 pEndpoint = pEndpoint->AioMgr.pEndpointNext;
181 }
182
183 /* Now check for an external blocking event. */
184 if (pAioMgr->fBlockingEventPending)
185 {
186 switch (pAioMgr->enmBlockingEvent)
187 {
188 case PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT:
189 {
190 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointNew = pAioMgr->BlockingEventData.AddEndpoint.pEndpoint;
191 AssertMsg(VALID_PTR(pEndpointNew), ("Adding endpoint event without a endpoint to add\n"));
192
193 pEndpointNew->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
194
195 pEndpointNew->AioMgr.pEndpointNext = pAioMgr->pEndpointsHead;
196 pEndpointNew->AioMgr.pEndpointPrev = NULL;
197 if (pAioMgr->pEndpointsHead)
198 pAioMgr->pEndpointsHead->AioMgr.pEndpointPrev = pEndpointNew;
199 pAioMgr->pEndpointsHead = pEndpointNew;
200
201 pAioMgr->cEndpoints++;
202
203 /*
204 * Process the task list the first time. There might be pending requests
205 * if the endpoint was migrated from another endpoint.
206 */
207 rc = pdmacFileAioMgrFailsafeProcessEndpoint(pAioMgr, pEndpointNew);
208 AssertRC(rc);
209 break;
210 }
211 case PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT:
212 {
213 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointRemove = pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint;
214 AssertMsg(VALID_PTR(pEndpointRemove), ("Removing endpoint event without a endpoint to remove\n"));
215
216 pEndpointRemove->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_REMOVING;
217
218 PPDMASYNCCOMPLETIONENDPOINTFILE pPrev = pEndpointRemove->AioMgr.pEndpointPrev;
219 PPDMASYNCCOMPLETIONENDPOINTFILE pNext = pEndpointRemove->AioMgr.pEndpointNext;
220
221 if (pPrev)
222 pPrev->AioMgr.pEndpointNext = pNext;
223 else
224 pAioMgr->pEndpointsHead = pNext;
225
226 if (pNext)
227 pNext->AioMgr.pEndpointPrev = pPrev;
228
229 pAioMgr->cEndpoints--;
230 break;
231 }
232 case PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT:
233 {
234 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointClose = pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint;
235 AssertMsg(VALID_PTR(pEndpointClose), ("Close endpoint event without a endpoint to Close\n"));
236
237 pEndpointClose->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_CLOSING;
238
239 /* Make sure all tasks finished. */
240 rc = pdmacFileAioMgrFailsafeProcessEndpoint(pAioMgr, pEndpointClose);
241 AssertRC(rc);
242 break;
243 }
244 case PDMACEPFILEAIOMGRBLOCKINGEVENT_SHUTDOWN:
245 pAioMgr->enmState = PDMACEPFILEMGRSTATE_SHUTDOWN;
246 break;
247 case PDMACEPFILEAIOMGRBLOCKINGEVENT_SUSPEND:
248 pAioMgr->enmState = PDMACEPFILEMGRSTATE_SUSPENDING;
249 break;
250 case PDMACEPFILEAIOMGRBLOCKINGEVENT_RESUME:
251 pAioMgr->enmState = PDMACEPFILEMGRSTATE_RUNNING;
252 break;
253 default:
254 AssertMsgFailed(("Invalid event type %d\n", pAioMgr->enmBlockingEvent));
255 }
256
257 ASMAtomicWriteBool(&pAioMgr->fBlockingEventPending, false);
258 pAioMgr->enmBlockingEvent = PDMACEPFILEAIOMGRBLOCKINGEVENT_INVALID;
259
260 /* Release the waiting thread. */
261 rc = RTSemEventSignal(pAioMgr->EventSemBlock);
262 AssertRC(rc);
263 }
264 }
265
266 return rc;
267}
268
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