vd-ifs-internal.h@ 42129

Last change on this file since 42129 was 38469, checked in by vboxsync, 13 years ago
VD: Interface cleanup. Merge the two involved structures (generic interface descriptor and callback table) into one, remove the duplicated interface wrappers in the backends and move the interface definitions into separate headers separating public and private interfaces.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.2 KB

Line
1	/** @file
2	* VD Container API - internal interfaces.
3	*/
4
5	/*
6	* Copyright (C) 2011 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*/
25
26	#ifndef ___VBox_VD_Interfaces_Internal_h
27	#define ___VBox_VD_Interfaces_Internal_h
28
29	#include <iprt/sg.h>
30	#include <VBox/vd-ifs.h>
31
32	RT_C_DECLS_BEGIN
33
34	/**
35	* Interface to get the parent state.
36	*
37	* Per-operation interface. Optional, present only if there is a parent, and
38	* used only internally for compacting.
39	*/
40	typedef struct VDINTERFACEPARENTSTATE
41	{
42	/**
43	* Common interface header.
44	*/
45	VDINTERFACE Core;
46
47	/**
48	* Read data callback.
49	*
50	* @return VBox status code.
51	* @return VERR_VD_NOT_OPENED if no image is opened in HDD container.
52	* @param pvUser The opaque data passed for the operation.
53	* @param uOffset Offset of first reading byte from start of disk.
54	* Must be aligned to a sector boundary.
55	* @param pvBuffer Pointer to buffer for reading data.
56	* @param cbBuffer Number of bytes to read.
57	* Must be aligned to a sector boundary.
58	*/
59	DECLR3CALLBACKMEMBER(int, pfnParentRead, (void pvUser, uint64_t uOffset, void pvBuffer, size_t cbBuffer));
60
61	} VDINTERFACEPARENTSTATE, *PVDINTERFACEPARENTSTATE;
62
63
64	/**
65	* Get parent state interface from interface list.
66	*
67	* @return Pointer to the first parent state interface in the list.
68	* @param pVDIfs Pointer to the interface list.
69	*/
70	DECLINLINE(PVDINTERFACEPARENTSTATE) VDIfParentStateGet(PVDINTERFACE pVDIfs)
71	{
72	PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_PARENTSTATE);
73
74	/* Check that the interface descriptor is a progress interface. */
75	AssertMsgReturn( !pIf
76	\|\| ( (pIf->enmInterface == VDINTERFACETYPE_PARENTSTATE)
77	&& (pIf->cbSize == sizeof(VDINTERFACEPARENTSTATE))),
78	("Not a parent state interface"), NULL);
79
80	return (PVDINTERFACEPARENTSTATE)pIf;
81	}
82
83	/** Forward declaration. Only visible in the VBoxHDD module. */
84	/** I/O context */
85	typedef struct VDIOCTX *PVDIOCTX;
86	/** Storage backend handle. */
87	typedef struct VDIOSTORAGE *PVDIOSTORAGE;
88	/** Pointer to a storage backend handle. */
89	typedef PVDIOSTORAGE *PPVDIOSTORAGE;
90
91	/**
92	* Completion callback for meta/userdata reads or writes.
93	*
94	* @return VBox status code.
95	* VINF_SUCCESS if everything was successful and the transfer can continue.
96	* VERR_VD_ASYNC_IO_IN_PROGRESS if there is another data transfer pending.
97	* @param pBackendData The opaque backend data.
98	* @param pIoCtx I/O context associated with this request.
99	* @param pvUser Opaque user data passed during a read/write request.
100	* @param rcReq Status code for the completed request.
101	*/
102	typedef DECLCALLBACK(int) FNVDXFERCOMPLETED(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq);
103	/** Pointer to FNVDXFERCOMPLETED() */
104	typedef FNVDXFERCOMPLETED *PFNVDXFERCOMPLETED;
105
106	/** Metadata transfer handle. */
107	typedef struct VDMETAXFER *PVDMETAXFER;
108	/** Pointer to a metadata transfer handle. */
109	typedef PVDMETAXFER *PPVDMETAXFER;
110
111
112	/**
113	* Internal I/O interface between the generic VD layer and the backends.
114	*
115	* Per-image. Always passed to backends.
116	*/
117	typedef struct VDINTERFACEIOINT
118	{
119	/**
120	* Common interface header.
121	*/
122	VDINTERFACE Core;
123
124	/**
125	* Open callback
126	*
127	* @return VBox status code.
128	* @param pvUser The opaque data passed on container creation.
129	* @param pszLocation Name of the location to open.
130	* @param fOpen Flags for opening the backend.
131	* See RTFILE_O_* #defines, inventing another set
132	* of open flags is not worth the mapping effort.
133	* @param ppStorage Where to store the storage handle.
134	*/
135	DECLR3CALLBACKMEMBER(int, pfnOpen, (void pvUser, const char pszLocation,
136	uint32_t fOpen, PPVDIOSTORAGE ppStorage));
137
138	/**
139	* Close callback.
140	*
141	* @return VBox status code.
142	* @param pvUser The opaque data passed on container creation.
143	* @param pStorage The storage handle to close.
144	*/
145	DECLR3CALLBACKMEMBER(int, pfnClose, (void *pvUser, PVDIOSTORAGE pStorage));
146
147	/**
148	* Delete callback.
149	*
150	* @return VBox status code.
151	* @param pvUser The opaque data passed on container creation.
152	* @param pcszFilename Name of the file to delete.
153	*/
154	DECLR3CALLBACKMEMBER(int, pfnDelete, (void pvUser, const char pcszFilename));
155
156	/**
157	* Move callback.
158	*
159	* @return VBox status code.
160	* @param pvUser The opaque data passed on container creation.
161	* @param pcszSrc The path to the source file.
162	* @param pcszDst The path to the destination file.
163	* This file will be created.
164	* @param fMove A combination of the RTFILEMOVE_* flags.
165	*/
166	DECLR3CALLBACKMEMBER(int, pfnMove, (void pvUser, const char pcszSrc, const char *pcszDst, unsigned fMove));
167
168	/**
169	* Returns the free space on a disk.
170	*
171	* @return VBox status code.
172	* @param pvUser The opaque data passed on container creation.
173	* @param pcszFilename Name of a file to identify the disk.
174	* @param pcbFreeSpace Where to store the free space of the disk.
175	*/
176	DECLR3CALLBACKMEMBER(int, pfnGetFreeSpace, (void pvUser, const char pcszFilename, int64_t *pcbFreeSpace));
177
178	/**
179	* Returns the last modification timestamp of a file.
180	*
181	* @return VBox status code.
182	* @param pvUser The opaque data passed on container creation.
183	* @param pcszFilename Name of a file to identify the disk.
184	* @param pModificationTime Where to store the timestamp of the file.
185	*/
186	DECLR3CALLBACKMEMBER(int, pfnGetModificationTime, (void pvUser, const char pcszFilename, PRTTIMESPEC pModificationTime));
187
188	/**
189	* Returns the size of the opened storage backend.
190	*
191	* @return VBox status code.
192	* @param pvUser The opaque data passed on container creation.
193	* @param pStorage The storage handle to get the size from.
194	* @param pcbSize Where to store the size of the storage backend.
195	*/
196	DECLR3CALLBACKMEMBER(int, pfnGetSize, (void *pvUser, PVDIOSTORAGE pStorage,
197	uint64_t *pcbSize));
198
199	/**
200	* Sets the size of the opened storage backend if possible.
201	*
202	* @return VBox status code.
203	* @retval VERR_NOT_SUPPORTED if the backend does not support this operation.
204	* @param pvUser The opaque data passed on container creation.
205	* @param pStorage The storage handle.
206	* @param cbSize The new size of the image.
207	*/
208	DECLR3CALLBACKMEMBER(int, pfnSetSize, (void *pvUser, PVDIOSTORAGE pStorage,
209	uint64_t cbSize));
210
211	/**
212	* Synchronous write callback.
213	*
214	* @return VBox status code.
215	* @param pvUser The opaque data passed on container creation.
216	* @param pStorage The storage handle to use.
217	* @param uOffset The offset to start from.
218	* @param pvBuffer Pointer to the bits need to be written.
219	* @param cbBuffer How many bytes to write.
220	* @param pcbWritten Where to store how many bytes were actually written.
221	*
222	* @notes Do not use in code called from the async read/write entry points in the backends.
223	* This should be only used during open/close of images and for the support functions
224	* which are not called while a VM is running (pfnCompact).
225	*/
226	DECLR3CALLBACKMEMBER(int, pfnWriteSync, (void *pvUser, PVDIOSTORAGE pStorage, uint64_t uOffset,
227	const void pvBuffer, size_t cbBuffer, size_t pcbWritten));
228
229	/**
230	* Synchronous read callback.
231	*
232	* @return VBox status code.
233	* @param pvUser The opaque data passed on container creation.
234	* @param pStorage The storage handle to use.
235	* @param uOffset The offset to start from.
236	* @param pvBuffer Where to store the read bits.
237	* @param cbBuffer How many bytes to read.
238	* @param pcbRead Where to store how many bytes were actually read.
239	*
240	* @notes See pfnWriteSync()
241	*/
242	DECLR3CALLBACKMEMBER(int, pfnReadSync, (void *pvUser, PVDIOSTORAGE pStorage, uint64_t uOffset,
243	void pvBuffer, size_t cbBuffer, size_t pcbRead));
244
245	/**
246	* Flush data to the storage backend.
247	*
248	* @return VBox status code.
249	* @param pvUser The opaque data passed on container creation.
250	* @param pStorage The storage handle to flush.
251	*
252	* @notes See pfnWriteSync()
253	*/
254	DECLR3CALLBACKMEMBER(int, pfnFlushSync, (void *pvUser, PVDIOSTORAGE pStorage));
255
256	/**
257	* Initiate an asynchronous read request for user data.
258	*
259	* @return VBox status code.
260	* @param pvUser The opaque user data passed on container creation.
261	* @param pStorage The storage handle.
262	* @param uOffset The offset to start reading from.
263	* @param pIoCtx I/O context passed in VDAsyncRead/Write.
264	* @param cbRead How many bytes to read.
265	*/
266	DECLR3CALLBACKMEMBER(int, pfnReadUserAsync, (void *pvUser, PVDIOSTORAGE pStorage,
267	uint64_t uOffset, PVDIOCTX pIoCtx,
268	size_t cbRead));
269
270	/**
271	* Initiate an asynchronous write request for user data.
272	*
273	* @return VBox status code.
274	* @param pvUser The opaque user data passed on container creation.
275	* @param pStorage The storage handle.
276	* @param uOffset The offset to start writing to.
277	* @param pIoCtx I/O context passed in VDAsyncRead/Write
278	* @param cbWrite How many bytes to write.
279	* @param pfnCompleted Completion callback.
280	* @param pvCompleteUser Opaque user data passed in the completion callback.
281	*/
282	DECLR3CALLBACKMEMBER(int, pfnWriteUserAsync, (void *pvUser, PVDIOSTORAGE pStorage,
283	uint64_t uOffset, PVDIOCTX pIoCtx,
284	size_t cbWrite,
285	PFNVDXFERCOMPLETED pfnComplete,
286	void *pvCompleteUser));
287
288	/**
289	* Reads metadata asynchronously from storage.
290	* The current I/O context will be halted.
291	*
292	* @returns VBox status code.
293	* @param pvUser The opaque user data passed on container creation.
294	* @param pStorage The storage handle.
295	* @param uOffset Offset to start reading from.
296	* @param pvBuffer Where to store the data.
297	* @param cbBuffer How many bytes to read.
298	* @param pIoCtx The I/O context which triggered the read.
299	* @param ppMetaXfer Where to store the metadata transfer handle on success.
300	* @param pfnCompleted Completion callback.
301	* @param pvCompleteUser Opaque user data passed in the completion callback.
302	*/
303	DECLR3CALLBACKMEMBER(int, pfnReadMetaAsync, (void *pvUser, PVDIOSTORAGE pStorage,
304	uint64_t uOffset, void *pvBuffer,
305	size_t cbBuffer, PVDIOCTX pIoCtx,
306	PPVDMETAXFER ppMetaXfer,
307	PFNVDXFERCOMPLETED pfnComplete,
308	void *pvCompleteUser));
309
310	/**
311	* Writes metadata asynchronously to storage.
312	*
313	* @returns VBox status code.
314	* @param pvUser The opaque user data passed on container creation.
315	* @param pStorage The storage handle.
316	* @param uOffset Offset to start writing to.
317	* @param pvBuffer Written data.
318	* @param cbBuffer How many bytes to write.
319	* @param pIoCtx The I/O context which triggered the write.
320	* @param pfnCompleted Completion callback.
321	* @param pvCompleteUser Opaque user data passed in the completion callback.
322	*/
323	DECLR3CALLBACKMEMBER(int, pfnWriteMetaAsync, (void *pvUser, PVDIOSTORAGE pStorage,
324	uint64_t uOffset, void *pvBuffer,
325	size_t cbBuffer, PVDIOCTX pIoCtx,
326	PFNVDXFERCOMPLETED pfnComplete,
327	void *pvCompleteUser));
328
329	/**
330	* Releases a metadata transfer handle.
331	* The free space can be used for another transfer.
332	*
333	* @returns nothing.
334	* @param pvUser The opaque user data passed on container creation.
335	* @param pMetaXfer The metadata transfer handle to release.
336	*/
337	DECLR3CALLBACKMEMBER(void, pfnMetaXferRelease, (void *pvUser, PVDMETAXFER pMetaXfer));
338
339	/**
340	* Initiates an async flush request.
341	*
342	* @return VBox status code.
343	* @param pvUser The opaque data passed on container creation.
344	* @param pStorage The storage handle to flush.
345	* @param pIoCtx I/O context which triggered the flush.
346	* @param pfnCompleted Completion callback.
347	* @param pvCompleteUser Opaque user data passed in the completion callback.
348	*/
349	DECLR3CALLBACKMEMBER(int, pfnFlushAsync, (void *pvUser, PVDIOSTORAGE pStorage,
350	PVDIOCTX pIoCtx,
351	PFNVDXFERCOMPLETED pfnComplete,
352	void *pvCompleteUser));
353
354	/**
355	* Copies a buffer into the I/O context.
356	*
357	* @return Number of bytes copied.
358	* @param pvUser The opaque user data passed on container creation.
359	* @param pIoCtx I/O context to copy the data to.
360	* @param pvBuffer Buffer to copy.
361	* @param cbBuffer Number of bytes to copy.
362	*/
363	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxCopyTo, (void *pvUser, PVDIOCTX pIoCtx,
364	void *pvBuffer, size_t cbBuffer));
365
366	/**
367	* Copies data from the I/O context into a buffer.
368	*
369	* @return Number of bytes copied.
370	* @param pvUser The opaque user data passed on container creation.
371	* @param pIoCtx I/O context to copy the data from.
372	* @param pvBuffer Destination buffer.
373	* @param cbBuffer Number of bytes to copy.
374	*/
375	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxCopyFrom, (void *pvUser, PVDIOCTX pIoCtx,
376	void *pvBuffer, size_t cbBuffer));
377
378	/**
379	* Sets the buffer of the given context to a specific byte.
380	*
381	* @return Number of bytes set.
382	* @param pvUser The opaque user data passed on container creation.
383	* @param pIoCtx I/O context to copy the data from.
384	* @param ch The byte to set.
385	* @param cbSet Number of bytes to set.
386	*/
387	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxSet, (void *pvUser, PVDIOCTX pIoCtx,
388	int ch, size_t cbSet));
389
390	/**
391	* Creates a segment array from the I/O context data buffer.
392	*
393	* @returns Number of bytes the array describes.
394	* @param pvUser The opaque user data passed on container creation.
395	* @param pIoCtx I/O context to copy the data from.
396	* @param paSeg The uninitialized segment array.
397	* If NULL pcSeg will contain the number of segments needed
398	* to describe the requested amount of data.
399	* @param pcSeg The number of segments the given array has.
400	* This will hold the actual number of entries needed upon return.
401	* @param cbData Number of bytes the new array should describe.
402	*/
403	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxSegArrayCreate, (void *pvUser, PVDIOCTX pIoCtx,
404	PRTSGSEG paSeg, unsigned *pcSeg,
405	size_t cbData));
406	/**
407	* Marks the given number of bytes as completed and continues the I/O context.
408	*
409	* @returns nothing.
410	* @param pvUser The opaque user data passed on container creation.
411	* @param pIoCtx The I/O context.
412	* @param rcReq Status code the request completed with.
413	* @param cbCompleted Number of bytes completed.
414	*/
415	DECLR3CALLBACKMEMBER(void, pfnIoCtxCompleted, (void *pvUser, PVDIOCTX pIoCtx,
416	int rcReq, size_t cbCompleted));
417	} VDINTERFACEIOINT, *PVDINTERFACEIOINT;
418
419	/**
420	* Get internal I/O interface from interface list.
421	*
422	* @return Pointer to the first internal I/O interface in the list.
423	* @param pVDIfs Pointer to the interface list.
424	*/
425	DECLINLINE(PVDINTERFACEIOINT) VDIfIoIntGet(PVDINTERFACE pVDIfs)
426	{
427	PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_IOINT);
428
429	/* Check that the interface descriptor is a progress interface. */
430	AssertMsgReturn( !pIf
431	\|\| ( (pIf->enmInterface == VDINTERFACETYPE_IOINT)
432	&& (pIf->cbSize == sizeof(VDINTERFACEIOINT))),
433	("Not an internal I/O interface"), NULL);
434
435	return (PVDINTERFACEIOINT)pIf;
436	}
437
438	DECLINLINE(int) vdIfIoIntFileOpen(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename,
439	uint32_t fOpen, PPVDIOSTORAGE ppStorage)
440	{
441	return pIfIoInt->pfnOpen(pIfIoInt->Core.pvUser, pszFilename, fOpen, ppStorage);
442	}
443
444	DECLINLINE(int) vdIfIoIntFileClose(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage)
445	{
446	return pIfIoInt->pfnClose(pIfIoInt->Core.pvUser, pStorage);
447	}
448
449	DECLINLINE(int) vdIfIoIntFileDelete(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename)
450	{
451	return pIfIoInt->pfnDelete(pIfIoInt->Core.pvUser, pszFilename);
452	}
453
454	DECLINLINE(int) vdIfIoIntFileMove(PVDINTERFACEIOINT pIfIoInt, const char *pszSrc,
455	const char *pszDst, unsigned fMove)
456	{
457	return pIfIoInt->pfnMove(pIfIoInt->Core.pvUser, pszSrc, pszDst, fMove);
458	}
459
460	DECLINLINE(int) vdIfIoIntFileGetFreeSpace(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename,
461	int64_t *pcbFree)
462	{
463	return pIfIoInt->pfnGetFreeSpace(pIfIoInt->Core.pvUser, pszFilename, pcbFree);
464	}
465
466	DECLINLINE(int) vdIfIoIntFileGetModificationTime(PVDINTERFACEIOINT pIfIoInt, const char *pcszFilename,
467	PRTTIMESPEC pModificationTime)
468	{
469	return pIfIoInt->pfnGetModificationTime(pIfIoInt->Core.pvUser, pcszFilename,
470	pModificationTime);
471	}
472
473	DECLINLINE(int) vdIfIoIntFileGetSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
474	uint64_t *pcbSize)
475	{
476	return pIfIoInt->pfnGetSize(pIfIoInt->Core.pvUser, pStorage, pcbSize);
477	}
478
479	DECLINLINE(int) vdIfIoIntFileSetSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
480	uint64_t cbSize)
481	{
482	return pIfIoInt->pfnSetSize(pIfIoInt->Core.pvUser, pStorage, cbSize);
483	}
484
485	DECLINLINE(int) vdIfIoIntFileWriteSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
486	uint64_t uOffset, const void *pvBuffer, size_t cbBuffer,
487	size_t *pcbWritten)
488	{
489	return pIfIoInt->pfnWriteSync(pIfIoInt->Core.pvUser, pStorage, uOffset,
490	pvBuffer, cbBuffer, pcbWritten);
491	}
492
493	DECLINLINE(int) vdIfIoIntFileReadSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
494	uint64_t uOffset, void *pvBuffer, size_t cbBuffer,
495	size_t *pcbRead)
496	{
497	return pIfIoInt->pfnReadSync(pIfIoInt->Core.pvUser, pStorage, uOffset,
498	pvBuffer, cbBuffer, pcbRead);
499	}
500
501	DECLINLINE(int) vdIfIoIntFileFlushSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage)
502	{
503	return pIfIoInt->pfnFlushSync(pIfIoInt->Core.pvUser, pStorage);
504	}
505
506	DECLINLINE(int) vdIfIoIntFileReadUserAsync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
507	uint64_t uOffset, PVDIOCTX pIoCtx, size_t cbRead)
508	{
509	return pIfIoInt->pfnReadUserAsync(pIfIoInt->Core.pvUser, pStorage,
510	uOffset, pIoCtx, cbRead);
511	}
512
513	DECLINLINE(int) vdIfIoIntFileWriteUserAsync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
514	uint64_t uOffset, PVDIOCTX pIoCtx, size_t cbWrite,
515	PFNVDXFERCOMPLETED pfnComplete,
516	void *pvCompleteUser)
517	{
518	return pIfIoInt->pfnWriteUserAsync(pIfIoInt->Core.pvUser, pStorage,
519	uOffset, pIoCtx, cbWrite, pfnComplete,
520	pvCompleteUser);
521	}
522
523	DECLINLINE(int) vdIfIoIntFileReadMetaAsync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
524	uint64_t uOffset, void *pvBuffer,
525	size_t cbBuffer, PVDIOCTX pIoCtx,
526	PPVDMETAXFER ppMetaXfer,
527	PFNVDXFERCOMPLETED pfnComplete,
528	void *pvCompleteUser)
529	{
530	return pIfIoInt->pfnReadMetaAsync(pIfIoInt->Core.pvUser, pStorage,
531	uOffset, pvBuffer, cbBuffer, pIoCtx,
532	ppMetaXfer, pfnComplete, pvCompleteUser);
533	}
534
535	DECLINLINE(int) vdIfIoIntFileWriteMetaAsync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
536	uint64_t uOffset, void *pvBuffer,
537	size_t cbBuffer, PVDIOCTX pIoCtx,
538	PFNVDXFERCOMPLETED pfnComplete,
539	void *pvCompleteUser)
540	{
541	return pIfIoInt->pfnWriteMetaAsync(pIfIoInt->Core.pvUser, pStorage,
542	uOffset, pvBuffer, cbBuffer, pIoCtx,
543	pfnComplete, pvCompleteUser);
544	}
545
546	DECLINLINE(void) vdIfIoIntMetaXferRelease(PVDINTERFACEIOINT pIfIoInt, PVDMETAXFER pMetaXfer)
547	{
548	pIfIoInt->pfnMetaXferRelease(pIfIoInt->Core.pvUser, pMetaXfer);
549	}
550
551	DECLINLINE(int) vdIfIoIntFileFlushAsync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
552	PVDIOCTX pIoCtx, PFNVDXFERCOMPLETED pfnComplete,
553	void *pvCompleteUser)
554	{
555	return pIfIoInt->pfnFlushAsync(pIfIoInt->Core.pvUser, pStorage, pIoCtx, pfnComplete,
556	pvCompleteUser);
557	}
558
559	DECLINLINE(size_t) vdIfIoIntIoCtxSet(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
560	int ch, size_t cbSet)
561	{
562	return pIfIoInt->pfnIoCtxSet(pIfIoInt->Core.pvUser, pIoCtx, ch, cbSet);
563	}
564
565	RT_C_DECLS_END
566
567	/** @} */
568
569	#endif

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

source: vbox/trunk/include/VBox/vd-ifs-internal.h@ 42129

Download in other formats: