vd-ifs-internal.h@ 54558

Last change on this file since 54558 was 51102, checked in by vboxsync, 11 years ago
Storage/FilterCrypt: Remove hardcoded data unit size of 512 bytes and introduce interface to query the size from the generic layer
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.8 KB

Line
1	/** @file
2	* VD Container API - internal interfaces.
3	*/
4
5	/*
6	* Copyright (C) 2011-2013 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	* Initiate a read request for user data.
213	*
214	* @return VBox status code.
215	* @param pvUser The opaque user data passed on container creation.
216	* @param pStorage The storage handle.
217	* @param uOffset The offset to start reading from.
218	* @param pIoCtx I/O context passed in the read/write callback.
219	* @param cbRead How many bytes to read.
220	*/
221	DECLR3CALLBACKMEMBER(int, pfnReadUser, (void *pvUser, PVDIOSTORAGE pStorage,
222	uint64_t uOffset, PVDIOCTX pIoCtx,
223	size_t cbRead));
224
225	/**
226	* Initiate a write request for user data.
227	*
228	* @return VBox status code.
229	* @param pvUser The opaque user data passed on container creation.
230	* @param pStorage The storage handle.
231	* @param uOffset The offset to start writing to.
232	* @param pIoCtx I/O context passed in the read/write callback.
233	* @param cbWrite How many bytes to write.
234	* @param pfnCompleted Completion callback.
235	* @param pvCompleteUser Opaque user data passed in the completion callback.
236	*/
237	DECLR3CALLBACKMEMBER(int, pfnWriteUser, (void *pvUser, PVDIOSTORAGE pStorage,
238	uint64_t uOffset, PVDIOCTX pIoCtx,
239	size_t cbWrite,
240	PFNVDXFERCOMPLETED pfnComplete,
241	void *pvCompleteUser));
242
243	/**
244	* Reads metadata from storage.
245	* The current I/O context will be halted.
246	*
247	* @returns VBox status code.
248	* @param pvUser The opaque user data passed on container creation.
249	* @param pStorage The storage handle.
250	* @param uOffset Offset to start reading from.
251	* @param pvBuffer Where to store the data.
252	* @param cbBuffer How many bytes to read.
253	* @param pIoCtx The I/O context which triggered the read.
254	* @param ppMetaXfer Where to store the metadata transfer handle on success.
255	* @param pfnCompleted Completion callback.
256	* @param pvCompleteUser Opaque user data passed in the completion callback.
257	*
258	* @notes If pIoCtx is NULL the metadata read is handled synchronously
259	* i.e. the call returns only if the data is available in the given
260	* buffer. ppMetaXfer, pfnCompleted and pvCompleteUser are ignored in that case.
261	* Use the synchronous version only when opening/closing the image
262	* or when doing certain operations like resizing, compacting or repairing
263	* the disk.
264	*/
265	DECLR3CALLBACKMEMBER(int, pfnReadMeta, (void *pvUser, PVDIOSTORAGE pStorage,
266	uint64_t uOffset, void *pvBuffer,
267	size_t cbBuffer, PVDIOCTX pIoCtx,
268	PPVDMETAXFER ppMetaXfer,
269	PFNVDXFERCOMPLETED pfnComplete,
270	void *pvCompleteUser));
271
272	/**
273	* Writes metadata to storage.
274	*
275	* @returns VBox status code.
276	* @param pvUser The opaque user data passed on container creation.
277	* @param pStorage The storage handle.
278	* @param uOffset Offset to start writing to.
279	* @param pvBuffer Written data.
280	* @param cbBuffer How many bytes to write.
281	* @param pIoCtx The I/O context which triggered the write.
282	* @param pfnCompleted Completion callback.
283	* @param pvCompleteUser Opaque user data passed in the completion callback.
284	*
285	* @notes See pfnReadMeta().
286	*/
287	DECLR3CALLBACKMEMBER(int, pfnWriteMeta, (void *pvUser, PVDIOSTORAGE pStorage,
288	uint64_t uOffset, const void *pvBuffer,
289	size_t cbBuffer, PVDIOCTX pIoCtx,
290	PFNVDXFERCOMPLETED pfnComplete,
291	void *pvCompleteUser));
292
293	/**
294	* Releases a metadata transfer handle.
295	* The free space can be used for another transfer.
296	*
297	* @returns nothing.
298	* @param pvUser The opaque user data passed on container creation.
299	* @param pMetaXfer The metadata transfer handle to release.
300	*/
301	DECLR3CALLBACKMEMBER(void, pfnMetaXferRelease, (void *pvUser, PVDMETAXFER pMetaXfer));
302
303	/**
304	* Initiates a flush request.
305	*
306	* @return VBox status code.
307	* @param pvUser The opaque data passed on container creation.
308	* @param pStorage The storage handle to flush.
309	* @param pIoCtx I/O context which triggered the flush.
310	* @param pfnCompleted Completion callback.
311	* @param pvCompleteUser Opaque user data passed in the completion callback.
312	*
313	* @notes See pfnReadMeta().
314	*/
315	DECLR3CALLBACKMEMBER(int, pfnFlush, (void *pvUser, PVDIOSTORAGE pStorage,
316	PVDIOCTX pIoCtx,
317	PFNVDXFERCOMPLETED pfnComplete,
318	void *pvCompleteUser));
319
320	/**
321	* Copies a buffer into the I/O context.
322	*
323	* @return Number of bytes copied.
324	* @param pvUser The opaque user data passed on container creation.
325	* @param pIoCtx I/O context to copy the data to.
326	* @param pvBuffer Buffer to copy.
327	* @param cbBuffer Number of bytes to copy.
328	*/
329	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxCopyTo, (void *pvUser, PVDIOCTX pIoCtx,
330	const void *pvBuffer, size_t cbBuffer));
331
332	/**
333	* Copies data from the I/O context into a buffer.
334	*
335	* @return Number of bytes copied.
336	* @param pvUser The opaque user data passed on container creation.
337	* @param pIoCtx I/O context to copy the data from.
338	* @param pvBuffer Destination buffer.
339	* @param cbBuffer Number of bytes to copy.
340	*/
341	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxCopyFrom, (void *pvUser, PVDIOCTX pIoCtx,
342	void *pvBuffer, size_t cbBuffer));
343
344	/**
345	* Sets the buffer of the given context to a specific byte.
346	*
347	* @return Number of bytes set.
348	* @param pvUser The opaque user data passed on container creation.
349	* @param pIoCtx I/O context to copy the data from.
350	* @param ch The byte to set.
351	* @param cbSet Number of bytes to set.
352	*/
353	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxSet, (void *pvUser, PVDIOCTX pIoCtx,
354	int ch, size_t cbSet));
355
356	/**
357	* Creates a segment array from the I/O context data buffer.
358	*
359	* @returns Number of bytes the array describes.
360	* @param pvUser The opaque user data passed on container creation.
361	* @param pIoCtx I/O context to copy the data from.
362	* @param paSeg The uninitialized segment array.
363	* If NULL pcSeg will contain the number of segments needed
364	* to describe the requested amount of data.
365	* @param pcSeg The number of segments the given array has.
366	* This will hold the actual number of entries needed upon return.
367	* @param cbData Number of bytes the new array should describe.
368	*/
369	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxSegArrayCreate, (void *pvUser, PVDIOCTX pIoCtx,
370	PRTSGSEG paSeg, unsigned *pcSeg,
371	size_t cbData));
372	/**
373	* Marks the given number of bytes as completed and continues the I/O context.
374	*
375	* @returns nothing.
376	* @param pvUser The opaque user data passed on container creation.
377	* @param pIoCtx The I/O context.
378	* @param rcReq Status code the request completed with.
379	* @param cbCompleted Number of bytes completed.
380	*/
381	DECLR3CALLBACKMEMBER(void, pfnIoCtxCompleted, (void *pvUser, PVDIOCTX pIoCtx,
382	int rcReq, size_t cbCompleted));
383
384	/**
385	* Returns whether the given I/O context must be treated synchronously.
386	*
387	* @returns true if the I/O context must be processed synchronously
388	* false otherwise.
389	* @param pvUser The opaque user data passed on container creation.
390	* @param pIoCtx The I/O context.
391	*/
392	DECLR3CALLBACKMEMBER(bool, pfnIoCtxIsSynchronous, (void *pvUser, PVDIOCTX pIoCtx));
393
394	/**
395	* Returns whether the user buffer of the I/O context is complete zero
396	* from to current position upto the given number of bytes.
397	*
398	* @returns true if the I/O context user buffer consists solely of zeros
399	* false otherwise.
400	* @param pvUser The opaque user data passed on container creation.
401	* @param pIoCtx The I/O context.
402	* @param cbCheck Number of bytes to check for zeros.
403	* @param fAdvance Flag whether to advance the buffer pointer if true
404	* is returned.
405	*/
406	DECLR3CALLBACKMEMBER(bool, pfnIoCtxIsZero, (void *pvUser, PVDIOCTX pIoCtx,
407	size_t cbCheck, bool fAdvance));
408
409	/**
410	* Returns the data unit size, i.e. the smallest size for a transfer.
411	* (similar to the sector size of disks).
412	*
413	* @returns The data unit size.
414	* @param pvUser The opaque user data passed on container creation.
415	* @param pIoCtx The I/O context.
416	*/
417	DECLR3CALLBACKMEMBER(size_t, pfnIoCtxGetDataUnitSize, (void *pvUser, PVDIOCTX pIoCtx));
418
419	} VDINTERFACEIOINT, *PVDINTERFACEIOINT;
420
421	/**
422	* Get internal I/O interface from interface list.
423	*
424	* @return Pointer to the first internal I/O interface in the list.
425	* @param pVDIfs Pointer to the interface list.
426	*/
427	DECLINLINE(PVDINTERFACEIOINT) VDIfIoIntGet(PVDINTERFACE pVDIfs)
428	{
429	PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_IOINT);
430
431	/* Check that the interface descriptor is a progress interface. */
432	AssertMsgReturn( !pIf
433	\|\| ( (pIf->enmInterface == VDINTERFACETYPE_IOINT)
434	&& (pIf->cbSize == sizeof(VDINTERFACEIOINT))),
435	("Not an internal I/O interface"), NULL);
436
437	return (PVDINTERFACEIOINT)pIf;
438	}
439
440	DECLINLINE(int) vdIfIoIntFileOpen(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename,
441	uint32_t fOpen, PPVDIOSTORAGE ppStorage)
442	{
443	return pIfIoInt->pfnOpen(pIfIoInt->Core.pvUser, pszFilename, fOpen, ppStorage);
444	}
445
446	DECLINLINE(int) vdIfIoIntFileClose(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage)
447	{
448	return pIfIoInt->pfnClose(pIfIoInt->Core.pvUser, pStorage);
449	}
450
451	DECLINLINE(int) vdIfIoIntFileDelete(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename)
452	{
453	return pIfIoInt->pfnDelete(pIfIoInt->Core.pvUser, pszFilename);
454	}
455
456	DECLINLINE(int) vdIfIoIntFileMove(PVDINTERFACEIOINT pIfIoInt, const char *pszSrc,
457	const char *pszDst, unsigned fMove)
458	{
459	return pIfIoInt->pfnMove(pIfIoInt->Core.pvUser, pszSrc, pszDst, fMove);
460	}
461
462	DECLINLINE(int) vdIfIoIntFileGetFreeSpace(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename,
463	int64_t *pcbFree)
464	{
465	return pIfIoInt->pfnGetFreeSpace(pIfIoInt->Core.pvUser, pszFilename, pcbFree);
466	}
467
468	DECLINLINE(int) vdIfIoIntFileGetModificationTime(PVDINTERFACEIOINT pIfIoInt, const char *pcszFilename,
469	PRTTIMESPEC pModificationTime)
470	{
471	return pIfIoInt->pfnGetModificationTime(pIfIoInt->Core.pvUser, pcszFilename,
472	pModificationTime);
473	}
474
475	DECLINLINE(int) vdIfIoIntFileGetSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
476	uint64_t *pcbSize)
477	{
478	return pIfIoInt->pfnGetSize(pIfIoInt->Core.pvUser, pStorage, pcbSize);
479	}
480
481	DECLINLINE(int) vdIfIoIntFileSetSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
482	uint64_t cbSize)
483	{
484	return pIfIoInt->pfnSetSize(pIfIoInt->Core.pvUser, pStorage, cbSize);
485	}
486
487	DECLINLINE(int) vdIfIoIntFileWriteSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
488	uint64_t uOffset, const void *pvBuffer, size_t cbBuffer)
489	{
490	return pIfIoInt->pfnWriteMeta(pIfIoInt->Core.pvUser, pStorage,
491	uOffset, pvBuffer, cbBuffer, NULL,
492	NULL, NULL);
493	}
494
495	DECLINLINE(int) vdIfIoIntFileReadSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
496	uint64_t uOffset, void *pvBuffer, size_t cbBuffer)
497	{
498	return pIfIoInt->pfnReadMeta(pIfIoInt->Core.pvUser, pStorage,
499	uOffset, pvBuffer, cbBuffer, NULL,
500	NULL, NULL, NULL);
501	}
502
503	DECLINLINE(int) vdIfIoIntFileFlushSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage)
504	{
505	return pIfIoInt->pfnFlush(pIfIoInt->Core.pvUser, pStorage, NULL, NULL, NULL);
506	}
507
508	DECLINLINE(int) vdIfIoIntFileReadUser(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
509	uint64_t uOffset, PVDIOCTX pIoCtx, size_t cbRead)
510	{
511	return pIfIoInt->pfnReadUser(pIfIoInt->Core.pvUser, pStorage,
512	uOffset, pIoCtx, cbRead);
513	}
514
515	DECLINLINE(int) vdIfIoIntFileWriteUser(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
516	uint64_t uOffset, PVDIOCTX pIoCtx, size_t cbWrite,
517	PFNVDXFERCOMPLETED pfnComplete,
518	void *pvCompleteUser)
519	{
520	return pIfIoInt->pfnWriteUser(pIfIoInt->Core.pvUser, pStorage,
521	uOffset, pIoCtx, cbWrite, pfnComplete,
522	pvCompleteUser);
523	}
524
525	DECLINLINE(int) vdIfIoIntFileReadMeta(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
526	uint64_t uOffset, void *pvBuffer,
527	size_t cbBuffer, PVDIOCTX pIoCtx,
528	PPVDMETAXFER ppMetaXfer,
529	PFNVDXFERCOMPLETED pfnComplete,
530	void *pvCompleteUser)
531	{
532	return pIfIoInt->pfnReadMeta(pIfIoInt->Core.pvUser, pStorage,
533	uOffset, pvBuffer, cbBuffer, pIoCtx,
534	ppMetaXfer, pfnComplete, pvCompleteUser);
535	}
536
537	DECLINLINE(int) vdIfIoIntFileWriteMeta(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
538	uint64_t uOffset, void *pvBuffer,
539	size_t cbBuffer, PVDIOCTX pIoCtx,
540	PFNVDXFERCOMPLETED pfnComplete,
541	void *pvCompleteUser)
542	{
543	return pIfIoInt->pfnWriteMeta(pIfIoInt->Core.pvUser, pStorage,
544	uOffset, pvBuffer, cbBuffer, pIoCtx,
545	pfnComplete, pvCompleteUser);
546	}
547
548	DECLINLINE(void) vdIfIoIntMetaXferRelease(PVDINTERFACEIOINT pIfIoInt, PVDMETAXFER pMetaXfer)
549	{
550	pIfIoInt->pfnMetaXferRelease(pIfIoInt->Core.pvUser, pMetaXfer);
551	}
552
553	DECLINLINE(int) vdIfIoIntFileFlush(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
554	PVDIOCTX pIoCtx, PFNVDXFERCOMPLETED pfnComplete,
555	void *pvCompleteUser)
556	{
557	return pIfIoInt->pfnFlush(pIfIoInt->Core.pvUser, pStorage, pIoCtx, pfnComplete,
558	pvCompleteUser);
559	}
560
561	DECLINLINE(size_t) vdIfIoIntIoCtxCopyTo(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
562	const void *pvBuffer, size_t cbBuffer)
563	{
564	return pIfIoInt->pfnIoCtxCopyTo(pIfIoInt->Core.pvUser, pIoCtx, pvBuffer, cbBuffer);
565	}
566
567	DECLINLINE(size_t) vdIfIoIntIoCtxCopyFrom(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
568	void *pvBuffer, size_t cbBuffer)
569	{
570	return pIfIoInt->pfnIoCtxCopyFrom(pIfIoInt->Core.pvUser, pIoCtx, pvBuffer, cbBuffer);
571	}
572
573	DECLINLINE(size_t) vdIfIoIntIoCtxSet(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
574	int ch, size_t cbSet)
575	{
576	return pIfIoInt->pfnIoCtxSet(pIfIoInt->Core.pvUser, pIoCtx, ch, cbSet);
577	}
578
579	DECLINLINE(size_t) vdIfIoIntIoCtxSegArrayCreate(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
580	PRTSGSEG paSeg, unsigned *pcSeg,
581	size_t cbData)
582	{
583	return pIfIoInt->pfnIoCtxSegArrayCreate(pIfIoInt->Core.pvUser, pIoCtx, paSeg, pcSeg, cbData);
584	}
585
586	DECLINLINE(bool) vdIfIoIntIoCtxIsSynchronous(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx)
587	{
588	return pIfIoInt->pfnIoCtxIsSynchronous(pIfIoInt->Core.pvUser, pIoCtx);
589	}
590
591	DECLINLINE(bool) vdIfIoIntIoCtxIsZero(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
592	size_t cbCheck, bool fAdvance)
593	{
594	return pIfIoInt->pfnIoCtxIsZero(pIfIoInt->Core.pvUser, pIoCtx, cbCheck, fAdvance);
595	}
596
597	DECLINLINE(size_t) vdIfIoIntIoCtxGetDataUnitSize(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx)
598	{
599	return pIfIoInt->pfnIoCtxGetDataUnitSize(pIfIoInt->Core.pvUser, pIoCtx);
600	}
601
602	/**
603	* Interface for the metadata traverse callback.
604	*
605	* Per-operation interface. Present only for the metadata traverse callback.
606	*/
607	typedef struct VDINTERFACETRAVERSEMETADATA
608	{
609	/**
610	* Common interface header.
611	*/
612	VDINTERFACE Core;
613
614	/**
615	* Traverse callback.
616	*
617	* @returns VBox status code.
618	* @param pvUser The opaque data passed for the operation.
619	* @param pvMetadataChunk Pointer to a chunk of the image metadata.
620	* @param cbMetadataChunk Size of the metadata chunk
621	*/
622	DECLR3CALLBACKMEMBER(int, pfnMetadataCallback, (void pvUser, const void pvMetadataChunk,
623	size_t cbMetadataChunk));
624
625	} VDINTERFACETRAVERSEMETADATA, *PVDINTERFACETRAVERSEMETADATA;
626
627
628	/**
629	* Get parent state interface from interface list.
630	*
631	* @return Pointer to the first parent state interface in the list.
632	* @param pVDIfs Pointer to the interface list.
633	*/
634	DECLINLINE(PVDINTERFACETRAVERSEMETADATA) VDIfTraverseMetadataGet(PVDINTERFACE pVDIfs)
635	{
636	PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_TRAVERSEMETADATA);
637
638	/* Check that the interface descriptor the correct interface. */
639	AssertMsgReturn( !pIf
640	\|\| ( (pIf->enmInterface == VDINTERFACETYPE_TRAVERSEMETADATA)
641	&& (pIf->cbSize == sizeof(VDINTERFACETRAVERSEMETADATA))),
642	("Not a traverse metadata interface"), NULL);
643
644	return (PVDINTERFACETRAVERSEMETADATA)pIf;
645	}
646
647	RT_C_DECLS_END
648
649	/** @} */
650
651	#endif

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

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

Download in other formats: