VirtualBox

source: vbox/trunk/src/VBox/VMM/include/PDMAsyncCompletionFileInternal.h@ 77922

Last change on this file since 77922 was 76585, checked in by vboxsync, 6 years ago

*: scm --fix-header-guard-endif
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.7 KB
Line 
1/* $Id: PDMAsyncCompletionFileInternal.h 76585 2019-01-01 06:31:29Z vboxsync $ */
2/** @file
3 * PDM Async I/O - Transport data asynchronous in R3 using EMT.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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#ifndef VMM_INCLUDED_SRC_include_PDMAsyncCompletionFileInternal_h
19#define VMM_INCLUDED_SRC_include_PDMAsyncCompletionFileInternal_h
20#ifndef RT_WITHOUT_PRAGMA_ONCE
21# pragma once
22#endif
23
24#include <VBox/vmm/cfgm.h>
25#include <VBox/vmm/stam.h>
26#include <VBox/vmm/tm.h>
27#include <iprt/types.h>
28#include <iprt/file.h>
29#include <iprt/thread.h>
30#include <iprt/semaphore.h>
31#include <iprt/critsect.h>
32#include <iprt/avl.h>
33#include <iprt/list.h>
34#include <iprt/spinlock.h>
35#include <iprt/memcache.h>
36
37#include "PDMAsyncCompletionInternal.h"
38
39/** @todo: Revise the caching of tasks. We have currently four caches:
40 * Per endpoint task cache
41 * Per class cache
42 * Per endpoint task segment cache
43 * Per class task segment cache
44 *
45 * We could use the RT heap for this probably or extend MMR3Heap (uses RTMemAlloc
46 * instead of managing larger blocks) to have this global for the whole VM.
47 */
48
49/** Enable for delay injection from the debugger. */
50#if 0
51# define PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
52#endif
53
54RT_C_DECLS_BEGIN
55
56/**
57 * A few forward declarations.
58 */
59typedef struct PDMASYNCCOMPLETIONENDPOINTFILE *PPDMASYNCCOMPLETIONENDPOINTFILE;
60/** Pointer to a request segment. */
61typedef struct PDMACTASKFILE *PPDMACTASKFILE;
62/** Pointer to the endpoint class data. */
63typedef struct PDMASYNCCOMPLETIONTASKFILE *PPDMASYNCCOMPLETIONTASKFILE;
64/** Pointer to a cache LRU list. */
65typedef struct PDMACFILELRULIST *PPDMACFILELRULIST;
66/** Pointer to the global cache structure. */
67typedef struct PDMACFILECACHEGLOBAL *PPDMACFILECACHEGLOBAL;
68/** Pointer to a task segment. */
69typedef struct PDMACFILETASKSEG *PPDMACFILETASKSEG;
70
71/**
72 * Blocking event types.
73 */
74typedef enum PDMACEPFILEAIOMGRBLOCKINGEVENT
75{
76 /** Invalid tye */
77 PDMACEPFILEAIOMGRBLOCKINGEVENT_INVALID = 0,
78 /** An endpoint is added to the manager. */
79 PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT,
80 /** An endpoint is removed from the manager. */
81 PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT,
82 /** An endpoint is about to be closed. */
83 PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT,
84 /** The manager is requested to terminate */
85 PDMACEPFILEAIOMGRBLOCKINGEVENT_SHUTDOWN,
86 /** The manager is requested to suspend */
87 PDMACEPFILEAIOMGRBLOCKINGEVENT_SUSPEND,
88 /** The manager is requested to resume */
89 PDMACEPFILEAIOMGRBLOCKINGEVENT_RESUME,
90 /** 32bit hack */
91 PDMACEPFILEAIOMGRBLOCKINGEVENT_32BIT_HACK = 0x7fffffff
92} PDMACEPFILEAIOMGRBLOCKINGEVENT;
93
94/**
95 * I/O manager type.
96 */
97typedef enum PDMACEPFILEMGRTYPE
98{
99 /** Simple aka failsafe */
100 PDMACEPFILEMGRTYPE_SIMPLE = 0,
101 /** Async I/O with host cache enabled. */
102 PDMACEPFILEMGRTYPE_ASYNC,
103 /** 32bit hack */
104 PDMACEPFILEMGRTYPE_32BIT_HACK = 0x7fffffff
105} PDMACEPFILEMGRTYPE;
106/** Pointer to a I/O manager type */
107typedef PDMACEPFILEMGRTYPE *PPDMACEPFILEMGRTYPE;
108
109/**
110 * States of the I/O manager.
111 */
112typedef enum PDMACEPFILEMGRSTATE
113{
114 /** Invalid state. */
115 PDMACEPFILEMGRSTATE_INVALID = 0,
116 /** Normal running state accepting new requests
117 * and processing them.
118 */
119 PDMACEPFILEMGRSTATE_RUNNING,
120 /** Fault state - not accepting new tasks for endpoints but waiting for
121 * remaining ones to finish.
122 */
123 PDMACEPFILEMGRSTATE_FAULT,
124 /** Suspending state - not accepting new tasks for endpoints but waiting
125 * for remaining ones to finish.
126 */
127 PDMACEPFILEMGRSTATE_SUSPENDING,
128 /** Shutdown state - not accepting new tasks for endpoints but waiting
129 * for remaining ones to finish.
130 */
131 PDMACEPFILEMGRSTATE_SHUTDOWN,
132 /** The I/O manager waits for all active requests to complete and doesn't queue
133 * new ones because it needs to grow to handle more requests.
134 */
135 PDMACEPFILEMGRSTATE_GROWING,
136 /** 32bit hack */
137 PDMACEPFILEMGRSTATE_32BIT_HACK = 0x7fffffff
138} PDMACEPFILEMGRSTATE;
139
140/**
141 * State of a async I/O manager.
142 */
143typedef struct PDMACEPFILEMGR
144{
145 /** Next Aio manager in the list. */
146 R3PTRTYPE(struct PDMACEPFILEMGR *) pNext;
147 /** Previous Aio manager in the list. */
148 R3PTRTYPE(struct PDMACEPFILEMGR *) pPrev;
149 /** Manager type */
150 PDMACEPFILEMGRTYPE enmMgrType;
151 /** Current state of the manager. */
152 PDMACEPFILEMGRSTATE enmState;
153 /** Event semaphore the manager sleeps on when waiting for new requests. */
154 RTSEMEVENT EventSem;
155 /** Flag whether the thread waits in the event semaphore. */
156 volatile bool fWaitingEventSem;
157 /** Thread data */
158 RTTHREAD Thread;
159 /** The async I/O context for this manager. */
160 RTFILEAIOCTX hAioCtx;
161 /** Flag whether the I/O manager was woken up. */
162 volatile bool fWokenUp;
163 /** List of endpoints assigned to this manager. */
164 R3PTRTYPE(PPDMASYNCCOMPLETIONENDPOINTFILE) pEndpointsHead;
165 /** Number of endpoints assigned to the manager. */
166 unsigned cEndpoints;
167 /** Number of requests active currently. */
168 unsigned cRequestsActive;
169 /** Number of maximum requests active. */
170 uint32_t cRequestsActiveMax;
171 /** Pointer to an array of free async I/O request handles. */
172 RTFILEAIOREQ *pahReqsFree;
173 /** Index of the next free entry in the cache. */
174 uint32_t iFreeEntry;
175 /** Size of the array. */
176 unsigned cReqEntries;
177 /** Memory cache for file range locks. */
178 RTMEMCACHE hMemCacheRangeLocks;
179 /** Number of milliseconds to wait until the bandwidth is refreshed for at least
180 * one endpoint and it is possible to process more requests. */
181 RTMSINTERVAL msBwLimitExpired;
182 /** Critical section protecting the blocking event handling. */
183 RTCRITSECT CritSectBlockingEvent;
184 /** Event semaphore for blocking external events.
185 * The caller waits on it until the async I/O manager
186 * finished processing the event. */
187 RTSEMEVENT EventSemBlock;
188 /** Flag whether a blocking event is pending and needs
189 * processing by the I/O manager. */
190 volatile bool fBlockingEventPending;
191 /** Blocking event type */
192 volatile PDMACEPFILEAIOMGRBLOCKINGEVENT enmBlockingEvent;
193 /** Event type data */
194 union
195 {
196 /** Add endpoint event. */
197 struct
198 {
199 /** The endpoint to be added */
200 volatile PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint;
201 } AddEndpoint;
202 /** Remove endpoint event. */
203 struct
204 {
205 /** The endpoint to be removed */
206 volatile PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint;
207 } RemoveEndpoint;
208 /** Close endpoint event. */
209 struct
210 {
211 /** The endpoint to be closed */
212 volatile PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint;
213 } CloseEndpoint;
214 } BlockingEventData;
215} PDMACEPFILEMGR;
216/** Pointer to a async I/O manager state. */
217typedef PDMACEPFILEMGR *PPDMACEPFILEMGR;
218/** Pointer to a async I/O manager state pointer. */
219typedef PPDMACEPFILEMGR *PPPDMACEPFILEMGR;
220
221/**
222 * A file access range lock.
223 */
224typedef struct PDMACFILERANGELOCK
225{
226 /** AVL node in the locked range tree of the endpoint. */
227 AVLRFOFFNODECORE Core;
228 /** How many tasks have locked this range. */
229 uint32_t cRefs;
230 /** Flag whether this is a read or write lock. */
231 bool fReadLock;
232 /** List of tasks which are waiting that the range gets unlocked. */
233 PPDMACTASKFILE pWaitingTasksHead;
234 /** List of tasks which are waiting that the range gets unlocked. */
235 PPDMACTASKFILE pWaitingTasksTail;
236} PDMACFILERANGELOCK, *PPDMACFILERANGELOCK;
237
238/**
239 * Backend type for the endpoint.
240 */
241typedef enum PDMACFILEEPBACKEND
242{
243 /** Non buffered. */
244 PDMACFILEEPBACKEND_NON_BUFFERED = 0,
245 /** Buffered (i.e host cache enabled) */
246 PDMACFILEEPBACKEND_BUFFERED,
247 /** 32bit hack */
248 PDMACFILEEPBACKEND_32BIT_HACK = 0x7fffffff
249} PDMACFILEEPBACKEND;
250/** Pointer to a backend type. */
251typedef PDMACFILEEPBACKEND *PPDMACFILEEPBACKEND;
252
253/**
254 * Global data for the file endpoint class.
255 */
256typedef struct PDMASYNCCOMPLETIONEPCLASSFILE
257{
258 /** Common data. */
259 PDMASYNCCOMPLETIONEPCLASS Core;
260 /** Override I/O manager type - set to SIMPLE after failure. */
261 PDMACEPFILEMGRTYPE enmMgrTypeOverride;
262 /** Default backend type for the endpoint. */
263 PDMACFILEEPBACKEND enmEpBackendDefault;
264 RTCRITSECT CritSect;
265 /** Pointer to the head of the async I/O managers. */
266 R3PTRTYPE(PPDMACEPFILEMGR) pAioMgrHead;
267 /** Number of async I/O managers currently running. */
268 unsigned cAioMgrs;
269 /** Maximum number of segments to cache per endpoint */
270 unsigned cTasksCacheMax;
271 /** Maximum number of simultaneous outstandingrequests. */
272 uint32_t cReqsOutstandingMax;
273 /** Bitmask for checking the alignment of a buffer. */
274 RTR3UINTPTR uBitmaskAlignment;
275 /** Flag whether the out of resources warning was printed already. */
276 bool fOutOfResourcesWarningPrinted;
277#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
278 /** Timer for delayed request completion. */
279 PTMTIMERR3 pTimer;
280 /** Milliseconds until the next delay expires. */
281 volatile uint64_t cMilliesNext;
282#endif
283} PDMASYNCCOMPLETIONEPCLASSFILE;
284/** Pointer to the endpoint class data. */
285typedef PDMASYNCCOMPLETIONEPCLASSFILE *PPDMASYNCCOMPLETIONEPCLASSFILE;
286
287typedef enum PDMACEPFILEBLOCKINGEVENT
288{
289 /** The invalid event type */
290 PDMACEPFILEBLOCKINGEVENT_INVALID = 0,
291 /** A task is about to be canceled */
292 PDMACEPFILEBLOCKINGEVENT_CANCEL,
293 /** Usual 32bit hack */
294 PDMACEPFILEBLOCKINGEVENT_32BIT_HACK = 0x7fffffff
295} PDMACEPFILEBLOCKINGEVENT;
296
297/**
298 * States of the endpoint.
299 */
300typedef enum PDMASYNCCOMPLETIONENDPOINTFILESTATE
301{
302 /** Invalid state. */
303 PDMASYNCCOMPLETIONENDPOINTFILESTATE_INVALID = 0,
304 /** Normal running state accepting new requests
305 * and processing them.
306 */
307 PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE,
308 /** The endpoint is about to be closed - not accepting new tasks for endpoints but waiting for
309 * remaining ones to finish.
310 */
311 PDMASYNCCOMPLETIONENDPOINTFILESTATE_CLOSING,
312 /** Removing from current I/O manager state - not processing new tasks for endpoints but waiting
313 * for remaining ones to finish.
314 */
315 PDMASYNCCOMPLETIONENDPOINTFILESTATE_REMOVING,
316 /** The current endpoint will be migrated to another I/O manager. */
317 PDMASYNCCOMPLETIONENDPOINTFILESTATE_MIGRATING,
318 /** 32bit hack */
319 PDMASYNCCOMPLETIONENDPOINTFILESTATE_32BIT_HACK = 0x7fffffff
320} PDMASYNCCOMPLETIONENDPOINTFILESTATE;
321
322typedef enum PDMACFILEREQTYPEDELAY
323{
324 PDMACFILEREQTYPEDELAY_ANY = 0,
325 PDMACFILEREQTYPEDELAY_READ,
326 PDMACFILEREQTYPEDELAY_WRITE,
327 PDMACFILEREQTYPEDELAY_FLUSH,
328 PDMACFILEREQTYPEDELAY_32BIT_HACK = 0x7fffffff
329} PDMACFILEREQTYPEDELAY;
330
331/**
332 * Data for the file endpoint.
333 */
334typedef struct PDMASYNCCOMPLETIONENDPOINTFILE
335{
336 /** Common data. */
337 PDMASYNCCOMPLETIONENDPOINT Core;
338 /** Current state of the endpoint. */
339 PDMASYNCCOMPLETIONENDPOINTFILESTATE enmState;
340 /** The backend to use for this endpoint. */
341 PDMACFILEEPBACKEND enmBackendType;
342 /** async I/O manager this endpoint is assigned to. */
343 R3PTRTYPE(volatile PPDMACEPFILEMGR) pAioMgr;
344 /** Flags for opening the file. */
345 unsigned fFlags;
346 /** File handle. */
347 RTFILE hFile;
348 /** Real size of the file. Only updated if data is appended. */
349 volatile uint64_t cbFile;
350 /** List of new tasks. */
351 R3PTRTYPE(volatile PPDMACTASKFILE) pTasksNewHead;
352
353 /** Head of the small cache for allocated task segments for exclusive
354 * use by this endpoint. */
355 R3PTRTYPE(volatile PPDMACTASKFILE) pTasksFreeHead;
356 /** Tail of the small cache for allocated task segments for exclusive
357 * use by this endpoint. */
358 R3PTRTYPE(volatile PPDMACTASKFILE) pTasksFreeTail;
359 /** Number of elements in the cache. */
360 volatile uint32_t cTasksCached;
361
362 /** Flag whether a flush request is currently active */
363 PPDMACTASKFILE pFlushReq;
364
365#ifdef VBOX_WITH_STATISTICS
366 /** Time spend in a read. */
367 STAMPROFILEADV StatRead;
368 /** Time spend in a write. */
369 STAMPROFILEADV StatWrite;
370#endif
371
372 /** Event semaphore for blocking external events.
373 * The caller waits on it until the async I/O manager
374 * finished processing the event. */
375 RTSEMEVENT EventSemBlock;
376 /** Flag whether caching is enabled for this file. */
377 bool fCaching;
378 /** Flag whether the file was opened readonly. */
379 bool fReadonly;
380 /** Flag whether the host supports the async flush API. */
381 bool fAsyncFlushSupported;
382#ifdef VBOX_WITH_DEBUGGER
383 /** Status code to inject for the next complete read. */
384 volatile int rcReqRead;
385 /** Status code to inject for the next complete write. */
386 volatile int rcReqWrite;
387#endif
388#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
389 /** Request delay. */
390 volatile uint32_t msDelay;
391 /** Request delay jitter. */
392 volatile uint32_t msJitter;
393 /** Number of requests to delay. */
394 volatile uint32_t cReqsDelay;
395 /** Task type to delay. */
396 PDMACFILEREQTYPEDELAY enmTypeDelay;
397 /** The current task which gets delayed. */
398 PPDMASYNCCOMPLETIONTASKFILE pDelayedHead;
399#endif
400 /** Flag whether a blocking event is pending and needs
401 * processing by the I/O manager. */
402 bool fBlockingEventPending;
403 /** Blocking event type */
404 PDMACEPFILEBLOCKINGEVENT enmBlockingEvent;
405
406 /** Additional data needed for the event types. */
407 union
408 {
409 /** Cancelation event. */
410 struct
411 {
412 /** The task to cancel. */
413 PPDMACTASKFILE pTask;
414 } Cancel;
415 } BlockingEventData;
416 /** Data for exclusive use by the assigned async I/O manager. */
417 struct
418 {
419 /** Pointer to the next endpoint assigned to the manager. */
420 R3PTRTYPE(PPDMASYNCCOMPLETIONENDPOINTFILE) pEndpointNext;
421 /** Pointer to the previous endpoint assigned to the manager. */
422 R3PTRTYPE(PPDMASYNCCOMPLETIONENDPOINTFILE) pEndpointPrev;
423 /** List of pending requests (not submitted due to usage restrictions
424 * or a pending flush request) */
425 R3PTRTYPE(PPDMACTASKFILE) pReqsPendingHead;
426 /** Tail of pending requests. */
427 R3PTRTYPE(PPDMACTASKFILE) pReqsPendingTail;
428 /** Tree of currently locked ranges.
429 * If a write task is enqueued the range gets locked and any other
430 * task writing to that range has to wait until the task completes.
431 */
432 PAVLRFOFFTREE pTreeRangesLocked;
433 /** Number of requests with a range lock active. */
434 unsigned cLockedReqsActive;
435 /** Number of requests currently being processed for this endpoint
436 * (excluded flush requests). */
437 unsigned cRequestsActive;
438 /** Number of requests processed during the last second. */
439 unsigned cReqsPerSec;
440 /** Current number of processed requests for the current update period. */
441 unsigned cReqsProcessed;
442 /** Flag whether the endpoint is about to be moved to another manager. */
443 bool fMoving;
444 /** Destination I/O manager. */
445 PPDMACEPFILEMGR pAioMgrDst;
446 } AioMgr;
447} PDMASYNCCOMPLETIONENDPOINTFILE;
448/** Pointer to the endpoint class data. */
449typedef PDMASYNCCOMPLETIONENDPOINTFILE *PPDMASYNCCOMPLETIONENDPOINTFILE;
450#ifdef VBOX_WITH_STATISTICS
451AssertCompileMemberAlignment(PDMASYNCCOMPLETIONENDPOINTFILE, StatRead, sizeof(uint64_t));
452#endif
453
454/** Request completion function */
455typedef DECLCALLBACK(void) FNPDMACTASKCOMPLETED(PPDMACTASKFILE pTask, void *pvUser, int rc);
456/** Pointer to a request completion function. */
457typedef FNPDMACTASKCOMPLETED *PFNPDMACTASKCOMPLETED;
458
459/**
460 * Transfer type.
461 */
462typedef enum PDMACTASKFILETRANSFER
463{
464 /** Invalid. */
465 PDMACTASKFILETRANSFER_INVALID = 0,
466 /** Read transfer. */
467 PDMACTASKFILETRANSFER_READ,
468 /** Write transfer. */
469 PDMACTASKFILETRANSFER_WRITE,
470 /** Flush transfer. */
471 PDMACTASKFILETRANSFER_FLUSH
472} PDMACTASKFILETRANSFER;
473
474/**
475 * Data of a request.
476 */
477typedef struct PDMACTASKFILE
478{
479 /** Pointer to the range lock we are waiting for */
480 PPDMACFILERANGELOCK pRangeLock;
481 /** Next task in the list. (Depending on the state) */
482 struct PDMACTASKFILE *pNext;
483 /** Endpoint */
484 PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint;
485 /** Transfer type. */
486 PDMACTASKFILETRANSFER enmTransferType;
487 /** Start offset */
488 RTFOFF Off;
489 /** Amount of data transfered so far. */
490 size_t cbTransfered;
491 /** Data segment. */
492 RTSGSEG DataSeg;
493 /** When non-zero the segment uses a bounce buffer because the provided buffer
494 * doesn't meet host requirements. */
495 size_t cbBounceBuffer;
496 /** Pointer to the used bounce buffer if any. */
497 void *pvBounceBuffer;
498 /** Start offset in the bounce buffer to copy from. */
499 uint32_t offBounceBuffer;
500 /** Flag whether this is a prefetch request. */
501 bool fPrefetch;
502 /** Already prepared native I/O request.
503 * Used if the request is prepared already but
504 * was not queued because the host has not enough
505 * resources. */
506 RTFILEAIOREQ hReq;
507 /** Completion function to call on completion. */
508 PFNPDMACTASKCOMPLETED pfnCompleted;
509 /** User data */
510 void *pvUser;
511} PDMACTASKFILE;
512
513/**
514 * Per task data.
515 */
516typedef struct PDMASYNCCOMPLETIONTASKFILE
517{
518 /** Common data. */
519 PDMASYNCCOMPLETIONTASK Core;
520 /** Number of bytes to transfer until this task completes. */
521 volatile int32_t cbTransferLeft;
522 /** Flag whether the task completed. */
523 volatile bool fCompleted;
524 /** Return code. */
525 volatile int rc;
526#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
527 volatile PPDMASYNCCOMPLETIONTASKFILE pDelayedNext;
528 /** Timestamp when the delay expires. */
529 uint64_t tsDelayEnd;
530#endif
531} PDMASYNCCOMPLETIONTASKFILE;
532
533DECLCALLBACK(int) pdmacFileAioMgrFailsafe(RTTHREAD hThreadSelf, void *pvUser);
534DECLCALLBACK(int) pdmacFileAioMgrNormal(RTTHREAD hThreadSelf, void *pvUser);
535
536int pdmacFileAioMgrNormalInit(PPDMACEPFILEMGR pAioMgr);
537void pdmacFileAioMgrNormalDestroy(PPDMACEPFILEMGR pAioMgr);
538
539int pdmacFileAioMgrCreate(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass, PPPDMACEPFILEMGR ppAioMgr, PDMACEPFILEMGRTYPE enmMgrType);
540
541int pdmacFileAioMgrAddEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
542
543PPDMACTASKFILE pdmacFileEpGetNewTasks(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
544PPDMACTASKFILE pdmacFileTaskAlloc(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
545void pdmacFileTaskFree(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
546 PPDMACTASKFILE pTask);
547
548int pdmacFileEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask);
549
550int pdmacFileCacheInit(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile, PCFGMNODE pCfgNode);
551void pdmacFileCacheDestroy(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);
552int pdmacFileEpCacheInit(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);
553void pdmacFileEpCacheDestroy(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
554
555int pdmacFileEpCacheRead(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask,
556 RTFOFF off, PCRTSGSEG paSegments, size_t cSegments,
557 size_t cbRead);
558int pdmacFileEpCacheWrite(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask,
559 RTFOFF off, PCRTSGSEG paSegments, size_t cSegments,
560 size_t cbWrite);
561int pdmacFileEpCacheFlush(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
562
563RT_C_DECLS_END
564
565#endif /* !VMM_INCLUDED_SRC_include_PDMAsyncCompletionFileInternal_h */
566
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