VirtualBox

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

Last change on this file since 78255 was 76585, checked in by vboxsync, 6 years ago

*: scm --fix-header-guard-endif

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.9 KB
Line 
1/** @file
2 * VD Container API - internal interfaces.
3 */
4
5/*
6 * Copyright (C) 2011-2019 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_INCLUDED_vd_ifs_internal_h
27#define VBOX_INCLUDED_vd_ifs_internal_h
28#ifndef RT_WITHOUT_PRAGMA_ONCE
29# pragma once
30#endif
31
32#include <iprt/sg.h>
33#include <VBox/vd-ifs.h>
34
35RT_C_DECLS_BEGIN
36
37/**
38 * Interface to get the parent state.
39 *
40 * Per-operation interface. Optional, present only if there is a parent, and
41 * used only internally for compacting.
42 */
43typedef struct VDINTERFACEPARENTSTATE
44{
45 /**
46 * Common interface header.
47 */
48 VDINTERFACE Core;
49
50 /**
51 * Read data callback.
52 *
53 * @return VBox status code.
54 * @return VERR_VD_NOT_OPENED if no image is opened in HDD container.
55 * @param pvUser The opaque data passed for the operation.
56 * @param uOffset Offset of first reading byte from start of disk.
57 * Must be aligned to a sector boundary.
58 * @param pvBuffer Pointer to buffer for reading data.
59 * @param cbBuffer Number of bytes to read.
60 * Must be aligned to a sector boundary.
61 */
62 DECLR3CALLBACKMEMBER(int, pfnParentRead, (void *pvUser, uint64_t uOffset, void *pvBuffer, size_t cbBuffer));
63
64} VDINTERFACEPARENTSTATE, *PVDINTERFACEPARENTSTATE;
65
66
67/**
68 * Get parent state interface from interface list.
69 *
70 * @return Pointer to the first parent state interface in the list.
71 * @param pVDIfs Pointer to the interface list.
72 */
73DECLINLINE(PVDINTERFACEPARENTSTATE) VDIfParentStateGet(PVDINTERFACE pVDIfs)
74{
75 PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_PARENTSTATE);
76
77 /* Check that the interface descriptor is a progress interface. */
78 AssertMsgReturn( !pIf
79 || ( (pIf->enmInterface == VDINTERFACETYPE_PARENTSTATE)
80 && (pIf->cbSize == sizeof(VDINTERFACEPARENTSTATE))),
81 ("Not a parent state interface"), NULL);
82
83 return (PVDINTERFACEPARENTSTATE)pIf;
84}
85
86/** Forward declaration. Only visible in the VBoxHDD module. */
87/** I/O context */
88typedef struct VDIOCTX *PVDIOCTX;
89/** Storage backend handle. */
90typedef struct VDIOSTORAGE *PVDIOSTORAGE;
91/** Pointer to a storage backend handle. */
92typedef PVDIOSTORAGE *PPVDIOSTORAGE;
93
94/**
95 * Completion callback for meta/userdata reads or writes.
96 *
97 * @return VBox status code.
98 * VINF_SUCCESS if everything was successful and the transfer can continue.
99 * VERR_VD_ASYNC_IO_IN_PROGRESS if there is another data transfer pending.
100 * @param pBackendData The opaque backend data.
101 * @param pIoCtx I/O context associated with this request.
102 * @param pvUser Opaque user data passed during a read/write request.
103 * @param rcReq Status code for the completed request.
104 */
105typedef DECLCALLBACK(int) FNVDXFERCOMPLETED(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq);
106/** Pointer to FNVDXFERCOMPLETED() */
107typedef FNVDXFERCOMPLETED *PFNVDXFERCOMPLETED;
108
109/** Metadata transfer handle. */
110typedef struct VDMETAXFER *PVDMETAXFER;
111/** Pointer to a metadata transfer handle. */
112typedef PVDMETAXFER *PPVDMETAXFER;
113
114
115/**
116 * Internal I/O interface between the generic VD layer and the backends.
117 *
118 * Per-image. Always passed to backends.
119 */
120typedef struct VDINTERFACEIOINT
121{
122 /**
123 * Common interface header.
124 */
125 VDINTERFACE Core;
126
127 /**
128 * Open callback
129 *
130 * @return VBox status code.
131 * @param pvUser The opaque data passed on container creation.
132 * @param pszLocation Name of the location to open.
133 * @param fOpen Flags for opening the backend.
134 * See RTFILE_O_* \#defines, inventing another set
135 * of open flags is not worth the mapping effort.
136 * @param ppStorage Where to store the storage handle.
137 */
138 DECLR3CALLBACKMEMBER(int, pfnOpen, (void *pvUser, const char *pszLocation,
139 uint32_t fOpen, PPVDIOSTORAGE ppStorage));
140
141 /**
142 * Close callback.
143 *
144 * @return VBox status code.
145 * @param pvUser The opaque data passed on container creation.
146 * @param pStorage The storage handle to close.
147 */
148 DECLR3CALLBACKMEMBER(int, pfnClose, (void *pvUser, PVDIOSTORAGE pStorage));
149
150 /**
151 * Delete callback.
152 *
153 * @return VBox status code.
154 * @param pvUser The opaque data passed on container creation.
155 * @param pcszFilename Name of the file to delete.
156 */
157 DECLR3CALLBACKMEMBER(int, pfnDelete, (void *pvUser, const char *pcszFilename));
158
159 /**
160 * Move callback.
161 *
162 * @return VBox status code.
163 * @param pvUser The opaque data passed on container creation.
164 * @param pcszSrc The path to the source file.
165 * @param pcszDst The path to the destination file.
166 * This file will be created.
167 * @param fMove A combination of the RTFILEMOVE_* flags.
168 */
169 DECLR3CALLBACKMEMBER(int, pfnMove, (void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove));
170
171 /**
172 * Returns the free space on a disk.
173 *
174 * @return VBox status code.
175 * @param pvUser The opaque data passed on container creation.
176 * @param pcszFilename Name of a file to identify the disk.
177 * @param pcbFreeSpace Where to store the free space of the disk.
178 */
179 DECLR3CALLBACKMEMBER(int, pfnGetFreeSpace, (void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace));
180
181 /**
182 * Returns the last modification timestamp of a file.
183 *
184 * @return VBox status code.
185 * @param pvUser The opaque data passed on container creation.
186 * @param pcszFilename Name of a file to identify the disk.
187 * @param pModificationTime Where to store the timestamp of the file.
188 */
189 DECLR3CALLBACKMEMBER(int, pfnGetModificationTime, (void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime));
190
191 /**
192 * Returns the size of the opened storage backend.
193 *
194 * @return VBox status code.
195 * @param pvUser The opaque data passed on container creation.
196 * @param pStorage The storage handle to get the size from.
197 * @param pcbSize Where to store the size of the storage backend.
198 */
199 DECLR3CALLBACKMEMBER(int, pfnGetSize, (void *pvUser, PVDIOSTORAGE pStorage,
200 uint64_t *pcbSize));
201
202 /**
203 * Sets the size of the opened storage backend if possible.
204 *
205 * @return VBox status code.
206 * @retval VERR_NOT_SUPPORTED if the backend does not support this operation.
207 * @param pvUser The opaque data passed on container creation.
208 * @param pStorage The storage handle.
209 * @param cbSize The new size of the image.
210 *
211 * @note Depending on the host the underlying storage (backing file, etc.)
212 * might not have all required storage allocated (sparse file) which
213 * can delay writes or fail with a not enough free space error if there
214 * is not enough space on the storage medium when writing to the range for
215 * the first time.
216 * Use VDINTERFACEIOINT::pfnSetAllocationSize to make sure the storage is
217 * really alloacted.
218 */
219 DECLR3CALLBACKMEMBER(int, pfnSetSize, (void *pvUser, PVDIOSTORAGE pStorage,
220 uint64_t cbSize));
221
222 /**
223 * Sets the size of the opened storage backend making sure the given size
224 * is really allocated.
225 *
226 * @return VBox status code.
227 * @param pvUser The opaque data passed on container creation.
228 * @param pStorage The storage handle.
229 * @param cbSize The new size of the image.
230 * @param fFlags Flags for controlling the allocation strategy.
231 * Reserved for future use, MBZ.
232 * @param pIfProgress Progress interface (optional).
233 * @param uPercentStart Progress starting point.
234 * @param uPercentSpan Length of operation in percent.
235 */
236 DECLR3CALLBACKMEMBER(int, pfnSetAllocationSize, (void *pvUser, PVDIOSTORAGE pStorage,
237 uint64_t cbSize, uint32_t fFlags,
238 PVDINTERFACEPROGRESS pIfProgress,
239 unsigned uPercentStart, unsigned uPercentSpan));
240
241 /**
242 * Initiate a read request for user data.
243 *
244 * @return VBox status code.
245 * @param pvUser The opaque user data passed on container creation.
246 * @param pStorage The storage handle.
247 * @param uOffset The offset to start reading from.
248 * @param pIoCtx I/O context passed in the read/write callback.
249 * @param cbRead How many bytes to read.
250 */
251 DECLR3CALLBACKMEMBER(int, pfnReadUser, (void *pvUser, PVDIOSTORAGE pStorage,
252 uint64_t uOffset, PVDIOCTX pIoCtx,
253 size_t cbRead));
254
255 /**
256 * Initiate a write request for user data.
257 *
258 * @return VBox status code.
259 * @param pvUser The opaque user data passed on container creation.
260 * @param pStorage The storage handle.
261 * @param uOffset The offset to start writing to.
262 * @param pIoCtx I/O context passed in the read/write callback.
263 * @param cbWrite How many bytes to write.
264 * @param pfnCompleted Completion callback.
265 * @param pvCompleteUser Opaque user data passed in the completion callback.
266 */
267 DECLR3CALLBACKMEMBER(int, pfnWriteUser, (void *pvUser, PVDIOSTORAGE pStorage,
268 uint64_t uOffset, PVDIOCTX pIoCtx,
269 size_t cbWrite,
270 PFNVDXFERCOMPLETED pfnComplete,
271 void *pvCompleteUser));
272
273 /**
274 * Reads metadata from storage.
275 * The current I/O context will be halted.
276 *
277 * @returns VBox status code.
278 * @param pvUser The opaque user data passed on container creation.
279 * @param pStorage The storage handle.
280 * @param uOffset Offset to start reading from.
281 * @param pvBuffer Where to store the data.
282 * @param cbBuffer How many bytes to read.
283 * @param pIoCtx The I/O context which triggered the read.
284 * @param ppMetaXfer Where to store the metadata transfer handle on success.
285 * @param pfnCompleted Completion callback.
286 * @param pvCompleteUser Opaque user data passed in the completion callback.
287 *
288 * @note If pIoCtx is NULL the metadata read is handled synchronously
289 * i.e. the call returns only if the data is available in the given
290 * buffer. ppMetaXfer, pfnCompleted and pvCompleteUser are ignored in that case.
291 * Use the synchronous version only when opening/closing the image
292 * or when doing certain operations like resizing, compacting or repairing
293 * the disk.
294 */
295 DECLR3CALLBACKMEMBER(int, pfnReadMeta, (void *pvUser, PVDIOSTORAGE pStorage,
296 uint64_t uOffset, void *pvBuffer,
297 size_t cbBuffer, PVDIOCTX pIoCtx,
298 PPVDMETAXFER ppMetaXfer,
299 PFNVDXFERCOMPLETED pfnComplete,
300 void *pvCompleteUser));
301
302 /**
303 * Writes metadata to storage.
304 *
305 * @returns VBox status code.
306 * @param pvUser The opaque user data passed on container creation.
307 * @param pStorage The storage handle.
308 * @param uOffset Offset to start writing to.
309 * @param pvBuffer Written data.
310 * @param cbBuffer How many bytes to write.
311 * @param pIoCtx The I/O context which triggered the write.
312 * @param pfnCompleted Completion callback.
313 * @param pvCompleteUser Opaque user data passed in the completion callback.
314 *
315 * @sa VDINTERFACEIOINT::pfnReadMeta
316 */
317 DECLR3CALLBACKMEMBER(int, pfnWriteMeta, (void *pvUser, PVDIOSTORAGE pStorage,
318 uint64_t uOffset, const void *pvBuffer,
319 size_t cbBuffer, PVDIOCTX pIoCtx,
320 PFNVDXFERCOMPLETED pfnComplete,
321 void *pvCompleteUser));
322
323 /**
324 * Releases a metadata transfer handle.
325 * The free space can be used for another transfer.
326 *
327 * @returns nothing.
328 * @param pvUser The opaque user data passed on container creation.
329 * @param pMetaXfer The metadata transfer handle to release.
330 */
331 DECLR3CALLBACKMEMBER(void, pfnMetaXferRelease, (void *pvUser, PVDMETAXFER pMetaXfer));
332
333 /**
334 * Initiates a flush request.
335 *
336 * @return VBox status code.
337 * @param pvUser The opaque data passed on container creation.
338 * @param pStorage The storage handle to flush.
339 * @param pIoCtx I/O context which triggered the flush.
340 * @param pfnCompleted Completion callback.
341 * @param pvCompleteUser Opaque user data passed in the completion callback.
342 *
343 * @sa VDINTERFACEIOINT::pfnReadMeta
344 */
345 DECLR3CALLBACKMEMBER(int, pfnFlush, (void *pvUser, PVDIOSTORAGE pStorage,
346 PVDIOCTX pIoCtx,
347 PFNVDXFERCOMPLETED pfnComplete,
348 void *pvCompleteUser));
349
350 /**
351 * Copies a buffer into the I/O context.
352 *
353 * @return Number of bytes copied.
354 * @param pvUser The opaque user data passed on container creation.
355 * @param pIoCtx I/O context to copy the data to.
356 * @param pvBuffer Buffer to copy.
357 * @param cbBuffer Number of bytes to copy.
358 */
359 DECLR3CALLBACKMEMBER(size_t, pfnIoCtxCopyTo, (void *pvUser, PVDIOCTX pIoCtx,
360 const void *pvBuffer, size_t cbBuffer));
361
362 /**
363 * Copies data from the I/O context into a buffer.
364 *
365 * @return Number of bytes copied.
366 * @param pvUser The opaque user data passed on container creation.
367 * @param pIoCtx I/O context to copy the data from.
368 * @param pvBuffer Destination buffer.
369 * @param cbBuffer Number of bytes to copy.
370 */
371 DECLR3CALLBACKMEMBER(size_t, pfnIoCtxCopyFrom, (void *pvUser, PVDIOCTX pIoCtx,
372 void *pvBuffer, size_t cbBuffer));
373
374 /**
375 * Sets the buffer of the given context to a specific byte.
376 *
377 * @return Number of bytes set.
378 * @param pvUser The opaque user data passed on container creation.
379 * @param pIoCtx I/O context to copy the data from.
380 * @param ch The byte to set.
381 * @param cbSet Number of bytes to set.
382 */
383 DECLR3CALLBACKMEMBER(size_t, pfnIoCtxSet, (void *pvUser, PVDIOCTX pIoCtx,
384 int ch, size_t cbSet));
385
386 /**
387 * Creates a segment array from the I/O context data buffer.
388 *
389 * @returns Number of bytes the array describes.
390 * @param pvUser The opaque user data passed on container creation.
391 * @param pIoCtx I/O context to copy the data from.
392 * @param paSeg The uninitialized segment array.
393 * If NULL pcSeg will contain the number of segments needed
394 * to describe the requested amount of data.
395 * @param pcSeg The number of segments the given array has.
396 * This will hold the actual number of entries needed upon return.
397 * @param cbData Number of bytes the new array should describe.
398 */
399 DECLR3CALLBACKMEMBER(size_t, pfnIoCtxSegArrayCreate, (void *pvUser, PVDIOCTX pIoCtx,
400 PRTSGSEG paSeg, unsigned *pcSeg,
401 size_t cbData));
402 /**
403 * Marks the given number of bytes as completed and continues the I/O context.
404 *
405 * @returns nothing.
406 * @param pvUser The opaque user data passed on container creation.
407 * @param pIoCtx The I/O context.
408 * @param rcReq Status code the request completed with.
409 * @param cbCompleted Number of bytes completed.
410 */
411 DECLR3CALLBACKMEMBER(void, pfnIoCtxCompleted, (void *pvUser, PVDIOCTX pIoCtx,
412 int rcReq, size_t cbCompleted));
413
414 /**
415 * Returns whether the given I/O context must be treated synchronously.
416 *
417 * @returns true if the I/O context must be processed synchronously
418 * false otherwise.
419 * @param pvUser The opaque user data passed on container creation.
420 * @param pIoCtx The I/O context.
421 */
422 DECLR3CALLBACKMEMBER(bool, pfnIoCtxIsSynchronous, (void *pvUser, PVDIOCTX pIoCtx));
423
424 /**
425 * Returns whether the user buffer of the I/O context is complete zero
426 * from to current position upto the given number of bytes.
427 *
428 * @returns true if the I/O context user buffer consists solely of zeros
429 * false otherwise.
430 * @param pvUser The opaque user data passed on container creation.
431 * @param pIoCtx The I/O context.
432 * @param cbCheck Number of bytes to check for zeros.
433 * @param fAdvance Flag whether to advance the buffer pointer if true
434 * is returned.
435 */
436 DECLR3CALLBACKMEMBER(bool, pfnIoCtxIsZero, (void *pvUser, PVDIOCTX pIoCtx,
437 size_t cbCheck, bool fAdvance));
438
439 /**
440 * Returns the data unit size, i.e. the smallest size for a transfer.
441 * (similar to the sector size of disks).
442 *
443 * @returns The data unit size.
444 * @param pvUser The opaque user data passed on container creation.
445 * @param pIoCtx The I/O context.
446 */
447 DECLR3CALLBACKMEMBER(size_t, pfnIoCtxGetDataUnitSize, (void *pvUser, PVDIOCTX pIoCtx));
448
449} VDINTERFACEIOINT, *PVDINTERFACEIOINT;
450
451/**
452 * Get internal I/O interface from interface list.
453 *
454 * @return Pointer to the first internal I/O interface in the list.
455 * @param pVDIfs Pointer to the interface list.
456 */
457DECLINLINE(PVDINTERFACEIOINT) VDIfIoIntGet(PVDINTERFACE pVDIfs)
458{
459 PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_IOINT);
460
461 /* Check that the interface descriptor is a progress interface. */
462 AssertMsgReturn( !pIf
463 || ( (pIf->enmInterface == VDINTERFACETYPE_IOINT)
464 && (pIf->cbSize == sizeof(VDINTERFACEIOINT))),
465 ("Not an internal I/O interface"), NULL);
466
467 return (PVDINTERFACEIOINT)pIf;
468}
469
470DECLINLINE(int) vdIfIoIntFileOpen(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename,
471 uint32_t fOpen, PPVDIOSTORAGE ppStorage)
472{
473 return pIfIoInt->pfnOpen(pIfIoInt->Core.pvUser, pszFilename, fOpen, ppStorage);
474}
475
476DECLINLINE(int) vdIfIoIntFileClose(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage)
477{
478 return pIfIoInt->pfnClose(pIfIoInt->Core.pvUser, pStorage);
479}
480
481DECLINLINE(int) vdIfIoIntFileDelete(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename)
482{
483 return pIfIoInt->pfnDelete(pIfIoInt->Core.pvUser, pszFilename);
484}
485
486DECLINLINE(int) vdIfIoIntFileMove(PVDINTERFACEIOINT pIfIoInt, const char *pszSrc,
487 const char *pszDst, unsigned fMove)
488{
489 return pIfIoInt->pfnMove(pIfIoInt->Core.pvUser, pszSrc, pszDst, fMove);
490}
491
492DECLINLINE(int) vdIfIoIntFileGetFreeSpace(PVDINTERFACEIOINT pIfIoInt, const char *pszFilename,
493 int64_t *pcbFree)
494{
495 return pIfIoInt->pfnGetFreeSpace(pIfIoInt->Core.pvUser, pszFilename, pcbFree);
496}
497
498DECLINLINE(int) vdIfIoIntFileGetModificationTime(PVDINTERFACEIOINT pIfIoInt, const char *pcszFilename,
499 PRTTIMESPEC pModificationTime)
500{
501 return pIfIoInt->pfnGetModificationTime(pIfIoInt->Core.pvUser, pcszFilename,
502 pModificationTime);
503}
504
505DECLINLINE(int) vdIfIoIntFileGetSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
506 uint64_t *pcbSize)
507{
508 return pIfIoInt->pfnGetSize(pIfIoInt->Core.pvUser, pStorage, pcbSize);
509}
510
511DECLINLINE(int) vdIfIoIntFileSetSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
512 uint64_t cbSize)
513{
514 return pIfIoInt->pfnSetSize(pIfIoInt->Core.pvUser, pStorage, cbSize);
515}
516
517DECLINLINE(int) vdIfIoIntFileSetAllocationSize(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
518 uint64_t cbSize, uint32_t fFlags,
519 PVDINTERFACEPROGRESS pIfProgress,
520 unsigned uPercentStart, unsigned uPercentSpan)
521{
522 return pIfIoInt->pfnSetAllocationSize(pIfIoInt->Core.pvUser, pStorage, cbSize, fFlags,
523 pIfProgress, uPercentStart, uPercentSpan);
524}
525
526DECLINLINE(int) vdIfIoIntFileWriteSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
527 uint64_t uOffset, const void *pvBuffer, size_t cbBuffer)
528{
529 return pIfIoInt->pfnWriteMeta(pIfIoInt->Core.pvUser, pStorage,
530 uOffset, pvBuffer, cbBuffer, NULL,
531 NULL, NULL);
532}
533
534DECLINLINE(int) vdIfIoIntFileReadSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
535 uint64_t uOffset, void *pvBuffer, size_t cbBuffer)
536{
537 return pIfIoInt->pfnReadMeta(pIfIoInt->Core.pvUser, pStorage,
538 uOffset, pvBuffer, cbBuffer, NULL,
539 NULL, NULL, NULL);
540}
541
542DECLINLINE(int) vdIfIoIntFileFlushSync(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage)
543{
544 return pIfIoInt->pfnFlush(pIfIoInt->Core.pvUser, pStorage, NULL, NULL, NULL);
545}
546
547DECLINLINE(int) vdIfIoIntFileReadUser(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
548 uint64_t uOffset, PVDIOCTX pIoCtx, size_t cbRead)
549{
550 return pIfIoInt->pfnReadUser(pIfIoInt->Core.pvUser, pStorage,
551 uOffset, pIoCtx, cbRead);
552}
553
554DECLINLINE(int) vdIfIoIntFileWriteUser(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
555 uint64_t uOffset, PVDIOCTX pIoCtx, size_t cbWrite,
556 PFNVDXFERCOMPLETED pfnComplete,
557 void *pvCompleteUser)
558{
559 return pIfIoInt->pfnWriteUser(pIfIoInt->Core.pvUser, pStorage,
560 uOffset, pIoCtx, cbWrite, pfnComplete,
561 pvCompleteUser);
562}
563
564DECLINLINE(int) vdIfIoIntFileReadMeta(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
565 uint64_t uOffset, void *pvBuffer,
566 size_t cbBuffer, PVDIOCTX pIoCtx,
567 PPVDMETAXFER ppMetaXfer,
568 PFNVDXFERCOMPLETED pfnComplete,
569 void *pvCompleteUser)
570{
571 return pIfIoInt->pfnReadMeta(pIfIoInt->Core.pvUser, pStorage,
572 uOffset, pvBuffer, cbBuffer, pIoCtx,
573 ppMetaXfer, pfnComplete, pvCompleteUser);
574}
575
576DECLINLINE(int) vdIfIoIntFileWriteMeta(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
577 uint64_t uOffset, void *pvBuffer,
578 size_t cbBuffer, PVDIOCTX pIoCtx,
579 PFNVDXFERCOMPLETED pfnComplete,
580 void *pvCompleteUser)
581{
582 return pIfIoInt->pfnWriteMeta(pIfIoInt->Core.pvUser, pStorage,
583 uOffset, pvBuffer, cbBuffer, pIoCtx,
584 pfnComplete, pvCompleteUser);
585}
586
587DECLINLINE(void) vdIfIoIntMetaXferRelease(PVDINTERFACEIOINT pIfIoInt, PVDMETAXFER pMetaXfer)
588{
589 pIfIoInt->pfnMetaXferRelease(pIfIoInt->Core.pvUser, pMetaXfer);
590}
591
592DECLINLINE(int) vdIfIoIntFileFlush(PVDINTERFACEIOINT pIfIoInt, PVDIOSTORAGE pStorage,
593 PVDIOCTX pIoCtx, PFNVDXFERCOMPLETED pfnComplete,
594 void *pvCompleteUser)
595{
596 return pIfIoInt->pfnFlush(pIfIoInt->Core.pvUser, pStorage, pIoCtx, pfnComplete,
597 pvCompleteUser);
598}
599
600DECLINLINE(size_t) vdIfIoIntIoCtxCopyTo(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
601 const void *pvBuffer, size_t cbBuffer)
602{
603 return pIfIoInt->pfnIoCtxCopyTo(pIfIoInt->Core.pvUser, pIoCtx, pvBuffer, cbBuffer);
604}
605
606DECLINLINE(size_t) vdIfIoIntIoCtxCopyFrom(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
607 void *pvBuffer, size_t cbBuffer)
608{
609 return pIfIoInt->pfnIoCtxCopyFrom(pIfIoInt->Core.pvUser, pIoCtx, pvBuffer, cbBuffer);
610}
611
612DECLINLINE(size_t) vdIfIoIntIoCtxSet(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
613 int ch, size_t cbSet)
614{
615 return pIfIoInt->pfnIoCtxSet(pIfIoInt->Core.pvUser, pIoCtx, ch, cbSet);
616}
617
618DECLINLINE(size_t) vdIfIoIntIoCtxSegArrayCreate(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
619 PRTSGSEG paSeg, unsigned *pcSeg,
620 size_t cbData)
621{
622 return pIfIoInt->pfnIoCtxSegArrayCreate(pIfIoInt->Core.pvUser, pIoCtx, paSeg, pcSeg, cbData);
623}
624
625DECLINLINE(bool) vdIfIoIntIoCtxIsSynchronous(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx)
626{
627 return pIfIoInt->pfnIoCtxIsSynchronous(pIfIoInt->Core.pvUser, pIoCtx);
628}
629
630DECLINLINE(bool) vdIfIoIntIoCtxIsZero(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx,
631 size_t cbCheck, bool fAdvance)
632{
633 return pIfIoInt->pfnIoCtxIsZero(pIfIoInt->Core.pvUser, pIoCtx, cbCheck, fAdvance);
634}
635
636DECLINLINE(size_t) vdIfIoIntIoCtxGetDataUnitSize(PVDINTERFACEIOINT pIfIoInt, PVDIOCTX pIoCtx)
637{
638 return pIfIoInt->pfnIoCtxGetDataUnitSize(pIfIoInt->Core.pvUser, pIoCtx);
639}
640
641/**
642 * Interface for the metadata traverse callback.
643 *
644 * Per-operation interface. Present only for the metadata traverse callback.
645 */
646typedef struct VDINTERFACETRAVERSEMETADATA
647{
648 /**
649 * Common interface header.
650 */
651 VDINTERFACE Core;
652
653 /**
654 * Traverse callback.
655 *
656 * @returns VBox status code.
657 * @param pvUser The opaque data passed for the operation.
658 * @param pvMetadataChunk Pointer to a chunk of the image metadata.
659 * @param cbMetadataChunk Size of the metadata chunk
660 */
661 DECLR3CALLBACKMEMBER(int, pfnMetadataCallback, (void *pvUser, const void *pvMetadataChunk,
662 size_t cbMetadataChunk));
663
664} VDINTERFACETRAVERSEMETADATA, *PVDINTERFACETRAVERSEMETADATA;
665
666
667/**
668 * Get parent state interface from interface list.
669 *
670 * @return Pointer to the first parent state interface in the list.
671 * @param pVDIfs Pointer to the interface list.
672 */
673DECLINLINE(PVDINTERFACETRAVERSEMETADATA) VDIfTraverseMetadataGet(PVDINTERFACE pVDIfs)
674{
675 PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_TRAVERSEMETADATA);
676
677 /* Check that the interface descriptor the correct interface. */
678 AssertMsgReturn( !pIf
679 || ( (pIf->enmInterface == VDINTERFACETYPE_TRAVERSEMETADATA)
680 && (pIf->cbSize == sizeof(VDINTERFACETRAVERSEMETADATA))),
681 ("Not a traverse metadata interface"), NULL);
682
683 return (PVDINTERFACETRAVERSEMETADATA)pIf;
684}
685
686RT_C_DECLS_END
687
688/** @} */
689
690#endif /* !VBOX_INCLUDED_vd_ifs_internal_h */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette