vd-ifs-internal.h@ 67180

Last change on this file since 67180 was 63912, checked in by vboxsync, 8 years ago
vd*.h: Correct guard macros
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.8 KB

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

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

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

Download in other formats: