vd-ifs-internal.h@ 60871

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

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

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

Download in other formats: