PDMAsyncCompletionFileInternal.h

Last change on this file was 106061, checked in by vboxsync, 8 weeks ago
Copyright year updates by scm.
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 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* PDM Async I/O - Transport data asynchronous in R3 using EMT.
4	*/
5
6	/*
7	* Copyright (C) 2006-2024 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
64	RT_C_DECLS_BEGIN
65
66	/**
67	* A few forward declarations.
68	*/
69	typedef struct PDMASYNCCOMPLETIONENDPOINTFILE *PPDMASYNCCOMPLETIONENDPOINTFILE;
70	/** Pointer to a request segment. */
71	typedef struct PDMACTASKFILE *PPDMACTASKFILE;
72	/** Pointer to the endpoint class data. */
73	typedef struct PDMASYNCCOMPLETIONTASKFILE *PPDMASYNCCOMPLETIONTASKFILE;
74	/** Pointer to a cache LRU list. */
75	typedef struct PDMACFILELRULIST *PPDMACFILELRULIST;
76	/** Pointer to the global cache structure. */
77	typedef struct PDMACFILECACHEGLOBAL *PPDMACFILECACHEGLOBAL;
78	/** Pointer to a task segment. */
79	typedef struct PDMACFILETASKSEG *PPDMACFILETASKSEG;
80
81	/**
82	* Blocking event types.
83	*/
84	typedef 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	*/
107	typedef 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 */
117	typedef PDMACEPFILEMGRTYPE *PPDMACEPFILEMGRTYPE;
118
119	/**
120	* States of the I/O manager.
121	*/
122	typedef 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	*/
153	typedef 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. */
227	typedef PDMACEPFILEMGR *PPDMACEPFILEMGR;
228	/** Pointer to a async I/O manager state pointer. */
229	typedef PPDMACEPFILEMGR *PPPDMACEPFILEMGR;
230
231	/**
232	* A file access range lock.
233	*/
234	typedef 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	*/
251	typedef 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. */
261	typedef PDMACFILEEPBACKEND *PPDMACFILEEPBACKEND;
262
263	/**
264	* Global data for the file endpoint class.
265	*/
266	typedef 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. */
295	typedef PDMASYNCCOMPLETIONEPCLASSFILE *PPDMASYNCCOMPLETIONEPCLASSFILE;
296
297	typedef 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	*/
310	typedef 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
332	typedef 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	*/
344	typedef 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. */
459	typedef PDMASYNCCOMPLETIONENDPOINTFILE *PPDMASYNCCOMPLETIONENDPOINTFILE;
460	#ifdef VBOX_WITH_STATISTICS
461	AssertCompileMemberAlignment(PDMASYNCCOMPLETIONENDPOINTFILE, StatRead, sizeof(uint64_t));
462	#endif
463
464	/** Request completion function */
465	typedef DECLCALLBACKTYPE(void, FNPDMACTASKCOMPLETED,(PPDMACTASKFILE pTask, void *pvUser, int rc));
466	/** Pointer to a request completion function. */
467	typedef FNPDMACTASKCOMPLETED *PFNPDMACTASKCOMPLETED;
468
469	/**
470	* Transfer type.
471	*/
472	typedef 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	*/
487	typedef 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	*/
526	typedef 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
543	DECLCALLBACK(int) pdmacFileAioMgrFailsafe(RTTHREAD hThreadSelf, void *pvUser);
544	DECLCALLBACK(int) pdmacFileAioMgrNormal(RTTHREAD hThreadSelf, void *pvUser);
545
546	int pdmacFileAioMgrNormalInit(PPDMACEPFILEMGR pAioMgr);
547	void pdmacFileAioMgrNormalDestroy(PPDMACEPFILEMGR pAioMgr);
548
549	int pdmacFileAioMgrCreate(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass, PPPDMACEPFILEMGR ppAioMgr, PDMACEPFILEMGRTYPE enmMgrType);
550
551	int pdmacFileAioMgrAddEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
552
553	PPDMACTASKFILE pdmacFileEpGetNewTasks(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
554	PPDMACTASKFILE pdmacFileTaskAlloc(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
555	void pdmacFileTaskFree(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
556	PPDMACTASKFILE pTask);
557
558	int pdmacFileEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask);
559
560	int pdmacFileCacheInit(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile, PCFGMNODE pCfgNode);
561	void pdmacFileCacheDestroy(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);
562	int pdmacFileEpCacheInit(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);
563	void pdmacFileEpCacheDestroy(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
564
565	int pdmacFileEpCacheRead(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask,
566	RTFOFF off, PCRTSGSEG paSegments, size_t cSegments,
567	size_t cbRead);
568	int pdmacFileEpCacheWrite(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask,
569	RTFOFF off, PCRTSGSEG paSegments, size_t cSegments,
570	size_t cbWrite);
571	int pdmacFileEpCacheFlush(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
572
573	RT_C_DECLS_END
574
575	#endif /* !VMM_INCLUDED_SRC_include_PDMAsyncCompletionFileInternal_h */
576

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

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

Download in other formats: