VirtualBox

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

Last change on this file since 96860 was 96407, checked in by vboxsync, 22 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use