PDMAsyncCompletionFileInternal.h@ 94249

Last change on this file since 94249 was 93115, checked in by vboxsync, 3 years ago
scm --update-copyright-year
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 93115 2022-01-01 11:31:46Z vboxsync $ */
2	/** @file
3	* PDM Async I/O - Transport data asynchronous in R3 using EMT.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 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
54	RT_C_DECLS_BEGIN
55
56	/**
57	* A few forward declarations.
58	*/
59	typedef struct PDMASYNCCOMPLETIONENDPOINTFILE *PPDMASYNCCOMPLETIONENDPOINTFILE;
60	/** Pointer to a request segment. */
61	typedef struct PDMACTASKFILE *PPDMACTASKFILE;
62	/** Pointer to the endpoint class data. */
63	typedef struct PDMASYNCCOMPLETIONTASKFILE *PPDMASYNCCOMPLETIONTASKFILE;
64	/** Pointer to a cache LRU list. */
65	typedef struct PDMACFILELRULIST *PPDMACFILELRULIST;
66	/** Pointer to the global cache structure. */
67	typedef struct PDMACFILECACHEGLOBAL *PPDMACFILECACHEGLOBAL;
68	/** Pointer to a task segment. */
69	typedef struct PDMACFILETASKSEG *PPDMACFILETASKSEG;
70
71	/**
72	* Blocking event types.
73	*/
74	typedef 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	*/
97	typedef 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 */
107	typedef PDMACEPFILEMGRTYPE *PPDMACEPFILEMGRTYPE;
108
109	/**
110	* States of the I/O manager.
111	*/
112	typedef 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	*/
143	typedef 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. */
217	typedef PDMACEPFILEMGR *PPDMACEPFILEMGR;
218	/** Pointer to a async I/O manager state pointer. */
219	typedef PPDMACEPFILEMGR *PPPDMACEPFILEMGR;
220
221	/**
222	* A file access range lock.
223	*/
224	typedef 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	*/
241	typedef 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. */
251	typedef PDMACFILEEPBACKEND *PPDMACFILEEPBACKEND;
252
253	/**
254	* Global data for the file endpoint class.
255	*/
256	typedef 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	TMTIMERHANDLE hTimer;
280	/** Milliseconds until the next delay expires. */
281	volatile uint64_t cMilliesNext;
282	#endif
283	} PDMASYNCCOMPLETIONEPCLASSFILE;
284	/** Pointer to the endpoint class data. */
285	typedef PDMASYNCCOMPLETIONEPCLASSFILE *PPDMASYNCCOMPLETIONEPCLASSFILE;
286
287	typedef 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	*/
300	typedef 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
322	typedef 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	*/
334	typedef 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. */
449	typedef PDMASYNCCOMPLETIONENDPOINTFILE *PPDMASYNCCOMPLETIONENDPOINTFILE;
450	#ifdef VBOX_WITH_STATISTICS
451	AssertCompileMemberAlignment(PDMASYNCCOMPLETIONENDPOINTFILE, StatRead, sizeof(uint64_t));
452	#endif
453
454	/** Request completion function */
455	typedef DECLCALLBACKTYPE(void, FNPDMACTASKCOMPLETED,(PPDMACTASKFILE pTask, void *pvUser, int rc));
456	/** Pointer to a request completion function. */
457	typedef FNPDMACTASKCOMPLETED *PFNPDMACTASKCOMPLETED;
458
459	/**
460	* Transfer type.
461	*/
462	typedef 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	*/
477	typedef 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	*/
516	typedef 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
533	DECLCALLBACK(int) pdmacFileAioMgrFailsafe(RTTHREAD hThreadSelf, void *pvUser);
534	DECLCALLBACK(int) pdmacFileAioMgrNormal(RTTHREAD hThreadSelf, void *pvUser);
535
536	int pdmacFileAioMgrNormalInit(PPDMACEPFILEMGR pAioMgr);
537	void pdmacFileAioMgrNormalDestroy(PPDMACEPFILEMGR pAioMgr);
538
539	int pdmacFileAioMgrCreate(PPDMASYNCCOMPLETIONEPCLASSFILE pEpClass, PPPDMACEPFILEMGR ppAioMgr, PDMACEPFILEMGRTYPE enmMgrType);
540
541	int pdmacFileAioMgrAddEndpoint(PPDMACEPFILEMGR pAioMgr, PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
542
543	PPDMACTASKFILE pdmacFileEpGetNewTasks(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
544	PPDMACTASKFILE pdmacFileTaskAlloc(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
545	void pdmacFileTaskFree(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
546	PPDMACTASKFILE pTask);
547
548	int pdmacFileEpAddTask(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMACTASKFILE pTask);
549
550	int pdmacFileCacheInit(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile, PCFGMNODE pCfgNode);
551	void pdmacFileCacheDestroy(PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);
552	int pdmacFileEpCacheInit(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONEPCLASSFILE pClassFile);
553	void pdmacFileEpCacheDestroy(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
554
555	int pdmacFileEpCacheRead(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask,
556	RTFOFF off, PCRTSGSEG paSegments, size_t cSegments,
557	size_t cbRead);
558	int pdmacFileEpCacheWrite(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask,
559	RTFOFF off, PCRTSGSEG paSegments, size_t cSegments,
560	size_t cbWrite);
561	int pdmacFileEpCacheFlush(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint);
562
563	RT_C_DECLS_END
564
565	#endif /* !VMM_INCLUDED_SRC_include_PDMAsyncCompletionFileInternal_h */
566

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

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

Download in other formats: