VirtualBox

source: vbox/trunk/src/VBox/Storage/VD.cpp@ 86044

Last change on this file since 86044 was 86044, checked in by vboxsync, 4 years ago

Storage/VD.cpp: Remove wrong assertion causing tstVDSnap to fail
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 378.7 KB
Line 
1/* $Id: VD.cpp 86044 2020-09-07 13:48:31Z vboxsync $ */
2/** @file
3 * VD - Virtual disk container implementation.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_VD
23#include <VBox/vd.h>
24#include <VBox/err.h>
25#include <VBox/sup.h>
26#include <VBox/log.h>
27
28#include <iprt/alloc.h>
29#include <iprt/assert.h>
30#include <iprt/uuid.h>
31#include <iprt/file.h>
32#include <iprt/string.h>
33#include <iprt/asm.h>
34#include <iprt/param.h>
35#include <iprt/path.h>
36#include <iprt/sg.h>
37#include <iprt/semaphore.h>
38#include <iprt/vector.h>
39
40#include "VDInternal.h"
41
42/** Buffer size used for merging images. */
43#define VD_MERGE_BUFFER_SIZE (16 * _1M)
44
45/** Maximum number of segments in one I/O task. */
46#define VD_IO_TASK_SEGMENTS_MAX 64
47
48/** Threshold after not recently used blocks are removed from the list. */
49#define VD_DISCARD_REMOVE_THRESHOLD (10 * _1M) /** @todo experiment */
50
51/**
52 * VD async I/O interface storage descriptor.
53 */
54typedef struct VDIIOFALLBACKSTORAGE
55{
56 /** File handle. */
57 RTFILE File;
58 /** Completion callback. */
59 PFNVDCOMPLETED pfnCompleted;
60 /** Thread for async access. */
61 RTTHREAD ThreadAsync;
62} VDIIOFALLBACKSTORAGE, *PVDIIOFALLBACKSTORAGE;
63
64/**
65 * uModified bit flags.
66 */
67#define VD_IMAGE_MODIFIED_FLAG RT_BIT(0)
68#define VD_IMAGE_MODIFIED_FIRST RT_BIT(1)
69#define VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE RT_BIT(2)
70
71
72# define VD_IS_LOCKED(a_pDisk) \
73 do \
74 { \
75 NOREF(a_pDisk); \
76 AssertMsg((a_pDisk)->fLocked, \
77 ("Lock not held\n"));\
78 } while(0)
79
80/**
81 * VBox parent read descriptor, used internally for compaction.
82 */
83typedef struct VDPARENTSTATEDESC
84{
85 /** Pointer to disk descriptor. */
86 PVDISK pDisk;
87 /** Pointer to image descriptor. */
88 PVDIMAGE pImage;
89} VDPARENTSTATEDESC, *PVDPARENTSTATEDESC;
90
91/**
92 * Transfer direction.
93 */
94typedef enum VDIOCTXTXDIR
95{
96 /** Read */
97 VDIOCTXTXDIR_READ = 0,
98 /** Write */
99 VDIOCTXTXDIR_WRITE,
100 /** Flush */
101 VDIOCTXTXDIR_FLUSH,
102 /** Discard */
103 VDIOCTXTXDIR_DISCARD,
104 /** 32bit hack */
105 VDIOCTXTXDIR_32BIT_HACK = 0x7fffffff
106} VDIOCTXTXDIR, *PVDIOCTXTXDIR;
107
108/** Transfer function */
109typedef DECLCALLBACKTYPE(int, FNVDIOCTXTRANSFER ,(PVDIOCTX pIoCtx));
110/** Pointer to a transfer function. */
111typedef FNVDIOCTXTRANSFER *PFNVDIOCTXTRANSFER;
112
113/**
114 * I/O context
115 */
116typedef struct VDIOCTX
117{
118 /** Pointer to the next I/O context. */
119 struct VDIOCTX * volatile pIoCtxNext;
120 /** Disk this is request is for. */
121 PVDISK pDisk;
122 /** Return code. */
123 int rcReq;
124 /** Various flags for the I/O context. */
125 uint32_t fFlags;
126 /** Number of data transfers currently pending. */
127 volatile uint32_t cDataTransfersPending;
128 /** How many meta data transfers are pending. */
129 volatile uint32_t cMetaTransfersPending;
130 /** Flag whether the request finished */
131 volatile bool fComplete;
132 /** Temporary allocated memory which is freed
133 * when the context completes. */
134 void *pvAllocation;
135 /** Transfer function. */
136 PFNVDIOCTXTRANSFER pfnIoCtxTransfer;
137 /** Next transfer part after the current one completed. */
138 PFNVDIOCTXTRANSFER pfnIoCtxTransferNext;
139 /** Transfer direction */
140 VDIOCTXTXDIR enmTxDir;
141 /** Request type dependent data. */
142 union
143 {
144 /** I/O request (read/write). */
145 struct
146 {
147 /** Number of bytes left until this context completes. */
148 volatile uint32_t cbTransferLeft;
149 /** Current offset */
150 volatile uint64_t uOffset;
151 /** Number of bytes to transfer */
152 volatile size_t cbTransfer;
153 /** Current image in the chain. */
154 PVDIMAGE pImageCur;
155 /** Start image to read from. pImageCur is reset to this
156 * value after it reached the first image in the chain. */
157 PVDIMAGE pImageStart;
158 /** S/G buffer */
159 RTSGBUF SgBuf;
160 /** Number of bytes to clear in the buffer before the current read. */
161 size_t cbBufClear;
162 /** Number of images to read. */
163 unsigned cImagesRead;
164 /** Override for the parent image to start reading from. */
165 PVDIMAGE pImageParentOverride;
166 /** Original offset of the transfer - required for filtering read requests. */
167 uint64_t uOffsetXferOrig;
168 /** Original size of the transfer - required for fitlering read requests. */
169 size_t cbXferOrig;
170 } Io;
171 /** Discard requests. */
172 struct
173 {
174 /** Pointer to the range descriptor array. */
175 PCRTRANGE paRanges;
176 /** Number of ranges in the array. */
177 unsigned cRanges;
178 /** Range descriptor index which is processed. */
179 unsigned idxRange;
180 /** Start offset to discard currently. */
181 uint64_t offCur;
182 /** How many bytes left to discard in the current range. */
183 size_t cbDiscardLeft;
184 /** How many bytes to discard in the current block (<= cbDiscardLeft). */
185 size_t cbThisDiscard;
186 /** Discard block handled currently. */
187 PVDDISCARDBLOCK pBlock;
188 } Discard;
189 } Req;
190 /** Parent I/O context if any. Sets the type of the context (root/child) */
191 PVDIOCTX pIoCtxParent;
192 /** Type dependent data (root/child) */
193 union
194 {
195 /** Root data */
196 struct
197 {
198 /** Completion callback */
199 PFNVDASYNCTRANSFERCOMPLETE pfnComplete;
200 /** User argument 1 passed on completion. */
201 void *pvUser1;
202 /** User argument 2 passed on completion. */
203 void *pvUser2;
204 } Root;
205 /** Child data */
206 struct
207 {
208 /** Saved start offset */
209 uint64_t uOffsetSaved;
210 /** Saved transfer size */
211 size_t cbTransferLeftSaved;
212 /** Number of bytes transferred from the parent if this context completes. */
213 size_t cbTransferParent;
214 /** Number of bytes to pre read */
215 size_t cbPreRead;
216 /** Number of bytes to post read. */
217 size_t cbPostRead;
218 /** Number of bytes to write left in the parent. */
219 size_t cbWriteParent;
220 /** Write type dependent data. */
221 union
222 {
223 /** Optimized */
224 struct
225 {
226 /** Bytes to fill to satisfy the block size. Not part of the virtual disk. */
227 size_t cbFill;
228 /** Bytes to copy instead of reading from the parent */
229 size_t cbWriteCopy;
230 /** Bytes to read from the image. */
231 size_t cbReadImage;
232 } Optimized;
233 } Write;
234 } Child;
235 } Type;
236} VDIOCTX;
237
238/** Default flags for an I/O context, i.e. unblocked and async. */
239#define VDIOCTX_FLAGS_DEFAULT (0)
240/** Flag whether the context is blocked. */
241#define VDIOCTX_FLAGS_BLOCKED RT_BIT_32(0)
242/** Flag whether the I/O context is using synchronous I/O. */
243#define VDIOCTX_FLAGS_SYNC RT_BIT_32(1)
244/** Flag whether the read should update the cache. */
245#define VDIOCTX_FLAGS_READ_UPDATE_CACHE RT_BIT_32(2)
246/** Flag whether free blocks should be zeroed.
247 * If false and no image has data for sepcified
248 * range VERR_VD_BLOCK_FREE is returned for the I/O context.
249 * Note that unallocated blocks are still zeroed
250 * if at least one image has valid data for a part
251 * of the range.
252 */
253#define VDIOCTX_FLAGS_ZERO_FREE_BLOCKS RT_BIT_32(3)
254/** Don't free the I/O context when complete because
255 * it was alloacted elsewhere (stack, ...). */
256#define VDIOCTX_FLAGS_DONT_FREE RT_BIT_32(4)
257/** Don't set the modified flag for this I/O context when writing. */
258#define VDIOCTX_FLAGS_DONT_SET_MODIFIED_FLAG RT_BIT_32(5)
259/** The write filter was applied already and shouldn't be applied a second time.
260 * Used at the beginning of vdWriteHelperAsync() because it might be called
261 * multiple times.
262 */
263#define VDIOCTX_FLAGS_WRITE_FILTER_APPLIED RT_BIT_32(6)
264
265/** NIL I/O context pointer value. */
266#define NIL_VDIOCTX ((PVDIOCTX)0)
267
268/**
269 * List node for deferred I/O contexts.
270 */
271typedef struct VDIOCTXDEFERRED
272{
273 /** Node in the list of deferred requests.
274 * A request can be deferred if the image is growing
275 * and the request accesses the same range or if
276 * the backend needs to read or write metadata from the disk
277 * before it can continue. */
278 RTLISTNODE NodeDeferred;
279 /** I/O context this entry points to. */
280 PVDIOCTX pIoCtx;
281} VDIOCTXDEFERRED, *PVDIOCTXDEFERRED;
282
283/**
284 * I/O task.
285 */
286typedef struct VDIOTASK
287{
288 /** Next I/O task waiting in the list. */
289 struct VDIOTASK * volatile pNext;
290 /** Storage this task belongs to. */
291 PVDIOSTORAGE pIoStorage;
292 /** Optional completion callback. */
293 PFNVDXFERCOMPLETED pfnComplete;
294 /** Opaque user data. */
295 void *pvUser;
296 /** Completion status code for the task. */
297 int rcReq;
298 /** Flag whether this is a meta data transfer. */
299 bool fMeta;
300 /** Type dependent data. */
301 union
302 {
303 /** User data transfer. */
304 struct
305 {
306 /** Number of bytes this task transferred. */
307 uint32_t cbTransfer;
308 /** Pointer to the I/O context the task belongs. */
309 PVDIOCTX pIoCtx;
310 } User;
311 /** Meta data transfer. */
312 struct
313 {
314 /** Meta transfer this task is for. */
315 PVDMETAXFER pMetaXfer;
316 } Meta;
317 } Type;
318} VDIOTASK;
319
320/**
321 * Storage handle.
322 */
323typedef struct VDIOSTORAGE
324{
325 /** Image I/O state this storage handle belongs to. */
326 PVDIO pVDIo;
327 /** AVL tree for pending async metadata transfers. */
328 PAVLRFOFFTREE pTreeMetaXfers;
329 /** Storage handle */
330 void *pStorage;
331} VDIOSTORAGE;
332
333/**
334 * Metadata transfer.
335 *
336 * @note This entry can't be freed if either the list is not empty or
337 * the reference counter is not 0.
338 * The assumption is that the backends don't need to read huge amounts of
339 * metadata to complete a transfer so the additional memory overhead should
340 * be relatively small.
341 */
342typedef struct VDMETAXFER
343{
344 /** AVL core for fast search (the file offset is the key) */
345 AVLRFOFFNODECORE Core;
346 /** I/O storage for this transfer. */
347 PVDIOSTORAGE pIoStorage;
348 /** Flags. */
349 uint32_t fFlags;
350 /** List of I/O contexts waiting for this metadata transfer to complete. */
351 RTLISTNODE ListIoCtxWaiting;
352 /** Number of references to this entry. */
353 unsigned cRefs;
354 /** Size of the data stored with this entry. */
355 size_t cbMeta;
356 /** Shadow buffer which is used in case a write is still active and other
357 * writes update the shadow buffer. */
358 uint8_t *pbDataShw;
359 /** List of I/O contexts updating the shadow buffer while there is a write
360 * in progress. */
361 RTLISTNODE ListIoCtxShwWrites;
362 /** Data stored - variable size. */
363 uint8_t abData[1];
364} VDMETAXFER;
365
366/**
367 * The transfer direction for the metadata.
368 */
369#define VDMETAXFER_TXDIR_MASK 0x3
370#define VDMETAXFER_TXDIR_NONE 0x0
371#define VDMETAXFER_TXDIR_WRITE 0x1
372#define VDMETAXFER_TXDIR_READ 0x2
373#define VDMETAXFER_TXDIR_FLUSH 0x3
374#define VDMETAXFER_TXDIR_GET(flags) ((flags) & VDMETAXFER_TXDIR_MASK)
375#define VDMETAXFER_TXDIR_SET(flags, dir) ((flags) = (flags & ~VDMETAXFER_TXDIR_MASK) | (dir))
376
377/** Forward declaration of the async discard helper. */
378static DECLCALLBACK(int) vdDiscardHelperAsync(PVDIOCTX pIoCtx);
379static DECLCALLBACK(int) vdWriteHelperAsync(PVDIOCTX pIoCtx);
380static void vdDiskProcessBlockedIoCtx(PVDISK pDisk);
381static int vdDiskUnlock(PVDISK pDisk, PVDIOCTX pIoCtxRc);
382static DECLCALLBACK(void) vdIoCtxSyncComplete(void *pvUser1, void *pvUser2, int rcReq);
383
384/**
385 * internal: issue error message.
386 */
387static int vdError(PVDISK pDisk, int rc, RT_SRC_POS_DECL,
388 const char *pszFormat, ...)
389{
390 va_list va;
391 va_start(va, pszFormat);
392 if (pDisk->pInterfaceError)
393 pDisk->pInterfaceError->pfnError(pDisk->pInterfaceError->Core.pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
394 va_end(va);
395 return rc;
396}
397
398/**
399 * internal: thread synchronization, start read.
400 */
401DECLINLINE(int) vdThreadStartRead(PVDISK pDisk)
402{
403 int rc = VINF_SUCCESS;
404 if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
405 rc = pDisk->pInterfaceThreadSync->pfnStartRead(pDisk->pInterfaceThreadSync->Core.pvUser);
406 return rc;
407}
408
409/**
410 * internal: thread synchronization, finish read.
411 */
412DECLINLINE(int) vdThreadFinishRead(PVDISK pDisk)
413{
414 int rc = VINF_SUCCESS;
415 if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
416 rc = pDisk->pInterfaceThreadSync->pfnFinishRead(pDisk->pInterfaceThreadSync->Core.pvUser);
417 return rc;
418}
419
420/**
421 * internal: thread synchronization, start write.
422 */
423DECLINLINE(int) vdThreadStartWrite(PVDISK pDisk)
424{
425 int rc = VINF_SUCCESS;
426 if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
427 rc = pDisk->pInterfaceThreadSync->pfnStartWrite(pDisk->pInterfaceThreadSync->Core.pvUser);
428 return rc;
429}
430
431/**
432 * internal: thread synchronization, finish write.
433 */
434DECLINLINE(int) vdThreadFinishWrite(PVDISK pDisk)
435{
436 int rc = VINF_SUCCESS;
437 if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
438 rc = pDisk->pInterfaceThreadSync->pfnFinishWrite(pDisk->pInterfaceThreadSync->Core.pvUser);
439 return rc;
440}
441
442/**
443 * internal: add image structure to the end of images list.
444 */
445static void vdAddImageToList(PVDISK pDisk, PVDIMAGE pImage)
446{
447 pImage->pPrev = NULL;
448 pImage->pNext = NULL;
449
450 if (pDisk->pBase)
451 {
452 Assert(pDisk->cImages > 0);
453 pImage->pPrev = pDisk->pLast;
454 pDisk->pLast->pNext = pImage;
455 pDisk->pLast = pImage;
456 }
457 else
458 {
459 Assert(pDisk->cImages == 0);
460 pDisk->pBase = pImage;
461 pDisk->pLast = pImage;
462 }
463
464 pDisk->cImages++;
465}
466
467/**
468 * internal: remove image structure from the images list.
469 */
470static void vdRemoveImageFromList(PVDISK pDisk, PVDIMAGE pImage)
471{
472 Assert(pDisk->cImages > 0);
473
474 if (pImage->pPrev)
475 pImage->pPrev->pNext = pImage->pNext;
476 else
477 pDisk->pBase = pImage->pNext;
478
479 if (pImage->pNext)
480 pImage->pNext->pPrev = pImage->pPrev;
481 else
482 pDisk->pLast = pImage->pPrev;
483
484 pImage->pPrev = NULL;
485 pImage->pNext = NULL;
486
487 pDisk->cImages--;
488}
489
490/**
491 * Release a referene to the filter decrementing the counter and destroying the filter
492 * when the counter reaches zero.
493 *
494 * @returns The new reference count.
495 * @param pFilter The filter to release.
496 */
497static uint32_t vdFilterRelease(PVDFILTER pFilter)
498{
499 uint32_t cRefs = ASMAtomicDecU32(&pFilter->cRefs);
500 if (!cRefs)
501 {
502 pFilter->pBackend->pfnDestroy(pFilter->pvBackendData);
503 RTMemFree(pFilter);
504 }
505
506 return cRefs;
507}
508
509/**
510 * Increments the reference counter of the given filter.
511 *
512 * @return The new reference count.
513 * @param pFilter The filter.
514 */
515static uint32_t vdFilterRetain(PVDFILTER pFilter)
516{
517 return ASMAtomicIncU32(&pFilter->cRefs);
518}
519
520/**
521 * internal: find image by index into the images list.
522 */
523static PVDIMAGE vdGetImageByNumber(PVDISK pDisk, unsigned nImage)
524{
525 PVDIMAGE pImage = pDisk->pBase;
526 if (nImage == VD_LAST_IMAGE)
527 return pDisk->pLast;
528 while (pImage && nImage)
529 {
530 pImage = pImage->pNext;
531 nImage--;
532 }
533 return pImage;
534}
535
536/**
537 * Creates a new region list from the given one converting to match the flags if necessary.
538 *
539 * @returns VBox status code.
540 * @param pRegionList The region list to convert from.
541 * @param fFlags The flags for the new region list.
542 * @param ppRegionList Where to store the new region list on success.
543 */
544static int vdRegionListConv(PCVDREGIONLIST pRegionList, uint32_t fFlags, PPVDREGIONLIST ppRegionList)
545{
546 int rc = VINF_SUCCESS;
547 PVDREGIONLIST pRegionListNew = (PVDREGIONLIST)RTMemDup(pRegionList,
548 RT_UOFFSETOF_DYN(VDREGIONLIST, aRegions[pRegionList->cRegions]));
549 if (RT_LIKELY(pRegionListNew))
550 {
551 /* Do we have to convert anything? */
552 if (pRegionList->fFlags != fFlags)
553 {
554 uint64_t offRegionNext = 0;
555
556 pRegionListNew->fFlags = fFlags;
557 for (unsigned i = 0; i < pRegionListNew->cRegions; i++)
558 {
559 PVDREGIONDESC pRegion = &pRegionListNew->aRegions[i];
560
561 if ( (fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
562 && !(pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS))
563 {
564 Assert(!(pRegion->cRegionBlocksOrBytes % pRegion->cbBlock));
565
566 /* Convert from bytes to logical blocks. */
567 pRegion->offRegion = offRegionNext;
568 pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes / pRegion->cbBlock;
569 offRegionNext += pRegion->cRegionBlocksOrBytes;
570 }
571 else
572 {
573 /* Convert from logical blocks to bytes. */
574 pRegion->offRegion = offRegionNext;
575 pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes * pRegion->cbBlock;
576 offRegionNext += pRegion->cRegionBlocksOrBytes;
577 }
578 }
579 }
580
581 *ppRegionList = pRegionListNew;
582 }
583 else
584 rc = VERR_NO_MEMORY;
585
586 return rc;
587}
588
589/**
590 * Returns the virtual size of the image in bytes.
591 *
592 * @returns Size of the given image in bytes.
593 * @param pImage The image to get the size from.
594 */
595static uint64_t vdImageGetSize(PVDIMAGE pImage)
596{
597 uint64_t cbImage = 0;
598
599 if (pImage->cbImage == VD_IMAGE_SIZE_UNINITIALIZED)
600 {
601 PCVDREGIONLIST pRegionList = NULL;
602 int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
603 if (RT_SUCCESS(rc))
604 {
605 if (pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
606 {
607 PVDREGIONLIST pRegionListConv = NULL;
608 rc = vdRegionListConv(pRegionList, 0, &pRegionListConv);
609 if (RT_SUCCESS(rc))
610 {
611 for (uint32_t i = 0; i < pRegionListConv->cRegions; i++)
612 cbImage += pRegionListConv->aRegions[i].cRegionBlocksOrBytes;
613
614 VDRegionListFree(pRegionListConv);
615 }
616 }
617 else
618 for (uint32_t i = 0; i < pRegionList->cRegions; i++)
619 cbImage += pRegionList->aRegions[i].cRegionBlocksOrBytes;
620
621 AssertPtr(pImage->Backend->pfnRegionListRelease);
622 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
623 pImage->cbImage = cbImage; /* Cache the value. */
624 }
625 }
626 else
627 cbImage = pImage->cbImage;
628
629 return cbImage;
630}
631
632/**
633 * Applies the filter chain to the given write request.
634 *
635 * @returns VBox status code.
636 * @param pDisk The HDD container.
637 * @param uOffset The start offset of the write.
638 * @param cbWrite Number of bytes to write.
639 * @param pIoCtx The I/O context associated with the request.
640 */
641static int vdFilterChainApplyWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
642 PVDIOCTX pIoCtx)
643{
644 int rc = VINF_SUCCESS;
645
646 VD_IS_LOCKED(pDisk);
647
648 PVDFILTER pFilter;
649 RTListForEach(&pDisk->ListFilterChainWrite, pFilter, VDFILTER, ListNodeChainWrite)
650 {
651 rc = pFilter->pBackend->pfnFilterWrite(pFilter->pvBackendData, uOffset, cbWrite, pIoCtx);
652 if (RT_FAILURE(rc))
653 break;
654 /* Reset S/G buffer for the next filter. */
655 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
656 }
657
658 return rc;
659}
660
661/**
662 * Applies the filter chain to the given read request.
663 *
664 * @returns VBox status code.
665 * @param pDisk The HDD container.
666 * @param uOffset The start offset of the read.
667 * @param cbRead Number of bytes read.
668 * @param pIoCtx The I/O context associated with the request.
669 */
670static int vdFilterChainApplyRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
671 PVDIOCTX pIoCtx)
672{
673 int rc = VINF_SUCCESS;
674
675 VD_IS_LOCKED(pDisk);
676
677 /* Reset buffer before starting. */
678 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
679
680 PVDFILTER pFilter;
681 RTListForEach(&pDisk->ListFilterChainRead, pFilter, VDFILTER, ListNodeChainRead)
682 {
683 rc = pFilter->pBackend->pfnFilterRead(pFilter->pvBackendData, uOffset, cbRead, pIoCtx);
684 if (RT_FAILURE(rc))
685 break;
686 /* Reset S/G buffer for the next filter. */
687 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
688 }
689
690 return rc;
691}
692
693DECLINLINE(void) vdIoCtxRootComplete(PVDISK pDisk, PVDIOCTX pIoCtx)
694{
695 if ( RT_SUCCESS(pIoCtx->rcReq)
696 && pIoCtx->enmTxDir == VDIOCTXTXDIR_READ)
697 pIoCtx->rcReq = vdFilterChainApplyRead(pDisk, pIoCtx->Req.Io.uOffsetXferOrig,
698 pIoCtx->Req.Io.cbXferOrig, pIoCtx);
699
700 pIoCtx->Type.Root.pfnComplete(pIoCtx->Type.Root.pvUser1,
701 pIoCtx->Type.Root.pvUser2,
702 pIoCtx->rcReq);
703}
704
705/**
706 * Initialize the structure members of a given I/O context.
707 */
708DECLINLINE(void) vdIoCtxInit(PVDIOCTX pIoCtx, PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
709 uint64_t uOffset, size_t cbTransfer, PVDIMAGE pImageStart,
710 PCRTSGBUF pcSgBuf, void *pvAllocation,
711 PFNVDIOCTXTRANSFER pfnIoCtxTransfer, uint32_t fFlags)
712{
713 pIoCtx->pDisk = pDisk;
714 pIoCtx->enmTxDir = enmTxDir;
715 pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbTransfer; Assert((uint32_t)cbTransfer == cbTransfer);
716 pIoCtx->Req.Io.uOffset = uOffset;
717 pIoCtx->Req.Io.cbTransfer = cbTransfer;
718 pIoCtx->Req.Io.pImageStart = pImageStart;
719 pIoCtx->Req.Io.pImageCur = pImageStart;
720 pIoCtx->Req.Io.cbBufClear = 0;
721 pIoCtx->Req.Io.pImageParentOverride = NULL;
722 pIoCtx->Req.Io.uOffsetXferOrig = uOffset;
723 pIoCtx->Req.Io.cbXferOrig = cbTransfer;
724 pIoCtx->cDataTransfersPending = 0;
725 pIoCtx->cMetaTransfersPending = 0;
726 pIoCtx->fComplete = false;
727 pIoCtx->fFlags = fFlags;
728 pIoCtx->pvAllocation = pvAllocation;
729 pIoCtx->pfnIoCtxTransfer = pfnIoCtxTransfer;
730 pIoCtx->pfnIoCtxTransferNext = NULL;
731 pIoCtx->rcReq = VINF_SUCCESS;
732 pIoCtx->pIoCtxParent = NULL;
733
734 /* There is no S/G list for a flush request. */
735 if ( enmTxDir != VDIOCTXTXDIR_FLUSH
736 && enmTxDir != VDIOCTXTXDIR_DISCARD)
737 RTSgBufClone(&pIoCtx->Req.Io.SgBuf, pcSgBuf);
738 else
739 memset(&pIoCtx->Req.Io.SgBuf, 0, sizeof(RTSGBUF));
740}
741
742/**
743 * Internal: Tries to read the desired range from the given cache.
744 *
745 * @returns VBox status code.
746 * @retval VERR_VD_BLOCK_FREE if the block is not in the cache.
747 * pcbRead will be set to the number of bytes not in the cache.
748 * Everything thereafter might be in the cache.
749 * @param pCache The cache to read from.
750 * @param uOffset Offset of the virtual disk to read.
751 * @param cbRead How much to read.
752 * @param pIoCtx The I/O context to read into.
753 * @param pcbRead Where to store the number of bytes actually read.
754 * On success this indicates the number of bytes read from the cache.
755 * If VERR_VD_BLOCK_FREE is returned this gives the number of bytes
756 * which are not in the cache.
757 * In both cases everything beyond this value
758 * might or might not be in the cache.
759 */
760static int vdCacheReadHelper(PVDCACHE pCache, uint64_t uOffset,
761 size_t cbRead, PVDIOCTX pIoCtx, size_t *pcbRead)
762{
763 int rc = VINF_SUCCESS;
764
765 LogFlowFunc(("pCache=%#p uOffset=%llu pIoCtx=%p cbRead=%zu pcbRead=%#p\n",
766 pCache, uOffset, pIoCtx, cbRead, pcbRead));
767
768 AssertPtr(pCache);
769 AssertPtr(pcbRead);
770
771 rc = pCache->Backend->pfnRead(pCache->pBackendData, uOffset, cbRead,
772 pIoCtx, pcbRead);
773
774 LogFlowFunc(("returns rc=%Rrc pcbRead=%zu\n", rc, *pcbRead));
775 return rc;
776}
777
778/**
779 * Internal: Writes data for the given block into the cache.
780 *
781 * @returns VBox status code.
782 * @param pCache The cache to write to.
783 * @param uOffset Offset of the virtual disk to write to the cache.
784 * @param cbWrite How much to write.
785 * @param pIoCtx The I/O context to write from.
786 * @param pcbWritten How much data could be written, optional.
787 */
788static int vdCacheWriteHelper(PVDCACHE pCache, uint64_t uOffset, size_t cbWrite,
789 PVDIOCTX pIoCtx, size_t *pcbWritten)
790{
791 int rc = VINF_SUCCESS;
792
793 LogFlowFunc(("pCache=%#p uOffset=%llu pIoCtx=%p cbWrite=%zu pcbWritten=%#p\n",
794 pCache, uOffset, pIoCtx, cbWrite, pcbWritten));
795
796 AssertPtr(pCache);
797 AssertPtr(pIoCtx);
798 Assert(cbWrite > 0);
799
800 if (pcbWritten)
801 rc = pCache->Backend->pfnWrite(pCache->pBackendData, uOffset, cbWrite,
802 pIoCtx, pcbWritten);
803 else
804 {
805 size_t cbWritten = 0;
806
807 do
808 {
809 rc = pCache->Backend->pfnWrite(pCache->pBackendData, uOffset, cbWrite,
810 pIoCtx, &cbWritten);
811 uOffset += cbWritten;
812 cbWrite -= cbWritten;
813 } while ( cbWrite
814 && ( RT_SUCCESS(rc)
815 || rc == VERR_VD_ASYNC_IO_IN_PROGRESS));
816 }
817
818 LogFlowFunc(("returns rc=%Rrc pcbWritten=%zu\n",
819 rc, pcbWritten ? *pcbWritten : cbWrite));
820 return rc;
821}
822
823/**
824 * Creates a new empty discard state.
825 *
826 * @returns Pointer to the new discard state or NULL if out of memory.
827 */
828static PVDDISCARDSTATE vdDiscardStateCreate(void)
829{
830 PVDDISCARDSTATE pDiscard = (PVDDISCARDSTATE)RTMemAllocZ(sizeof(VDDISCARDSTATE));
831
832 if (pDiscard)
833 {
834 RTListInit(&pDiscard->ListLru);
835 pDiscard->pTreeBlocks = (PAVLRU64TREE)RTMemAllocZ(sizeof(AVLRU64TREE));
836 if (!pDiscard->pTreeBlocks)
837 {
838 RTMemFree(pDiscard);
839 pDiscard = NULL;
840 }
841 }
842
843 return pDiscard;
844}
845
846/**
847 * Removes the least recently used blocks from the waiting list until
848 * the new value is reached.
849 *
850 * @returns VBox status code.
851 * @param pDisk VD disk container.
852 * @param pDiscard The discard state.
853 * @param cbDiscardingNew How many bytes should be waiting on success.
854 * The number of bytes waiting can be less.
855 */
856static int vdDiscardRemoveBlocks(PVDISK pDisk, PVDDISCARDSTATE pDiscard, size_t cbDiscardingNew)
857{
858 int rc = VINF_SUCCESS;
859
860 LogFlowFunc(("pDisk=%#p pDiscard=%#p cbDiscardingNew=%zu\n",
861 pDisk, pDiscard, cbDiscardingNew));
862
863 while (pDiscard->cbDiscarding > cbDiscardingNew)
864 {
865 PVDDISCARDBLOCK pBlock = RTListGetLast(&pDiscard->ListLru, VDDISCARDBLOCK, NodeLru);
866
867 Assert(!RTListIsEmpty(&pDiscard->ListLru));
868
869 /* Go over the allocation bitmap and mark all discarded sectors as unused. */
870 uint64_t offStart = pBlock->Core.Key;
871 uint32_t idxStart = 0;
872 size_t cbLeft = pBlock->cbDiscard;
873 bool fAllocated = ASMBitTest(pBlock->pbmAllocated, idxStart);
874 uint32_t cSectors = (uint32_t)(pBlock->cbDiscard / 512);
875
876 while (cbLeft > 0)
877 {
878 int32_t idxEnd;
879 size_t cbThis = cbLeft;
880
881 if (fAllocated)
882 {
883 /* Check for the first unallocated bit. */
884 idxEnd = ASMBitNextClear(pBlock->pbmAllocated, cSectors, idxStart);
885 if (idxEnd != -1)
886 {
887 cbThis = (idxEnd - idxStart) * 512;
888 fAllocated = false;
889 }
890 }
891 else
892 {
893 /* Mark as unused and check for the first set bit. */
894 idxEnd = ASMBitNextSet(pBlock->pbmAllocated, cSectors, idxStart);
895 if (idxEnd != -1)
896 cbThis = (idxEnd - idxStart) * 512;
897
898
899 VDIOCTX IoCtx;
900 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
901 NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
902 rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData,
903 &IoCtx, offStart, cbThis, NULL,
904 NULL, &cbThis, NULL,
905 VD_DISCARD_MARK_UNUSED);
906 if (RT_FAILURE(rc))
907 break;
908
909 fAllocated = true;
910 }
911
912 idxStart = idxEnd;
913 offStart += cbThis;
914 cbLeft -= cbThis;
915 }
916
917 if (RT_FAILURE(rc))
918 break;
919
920 PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
921 Assert(pBlockRemove == pBlock); NOREF(pBlockRemove);
922 RTListNodeRemove(&pBlock->NodeLru);
923
924 pDiscard->cbDiscarding -= pBlock->cbDiscard;
925 RTMemFree(pBlock->pbmAllocated);
926 RTMemFree(pBlock);
927 }
928
929 Assert(RT_FAILURE(rc) || pDiscard->cbDiscarding <= cbDiscardingNew);
930
931 LogFlowFunc(("returns rc=%Rrc\n", rc));
932 return rc;
933}
934
935/**
936 * Destroys the current discard state, writing any waiting blocks to the image.
937 *
938 * @returns VBox status code.
939 * @param pDisk VD disk container.
940 */
941static int vdDiscardStateDestroy(PVDISK pDisk)
942{
943 int rc = VINF_SUCCESS;
944
945 if (pDisk->pDiscard)
946 {
947 rc = vdDiscardRemoveBlocks(pDisk, pDisk->pDiscard, 0 /* Remove all blocks. */);
948 AssertRC(rc);
949 RTMemFree(pDisk->pDiscard->pTreeBlocks);
950 RTMemFree(pDisk->pDiscard);
951 pDisk->pDiscard = NULL;
952 }
953
954 return rc;
955}
956
957/**
958 * Marks the given range as allocated in the image.
959 * Required if there are discards in progress and a write to a block which can get discarded
960 * is written to.
961 *
962 * @returns VBox status code.
963 * @param pDisk VD container data.
964 * @param uOffset First byte to mark as allocated.
965 * @param cbRange Number of bytes to mark as allocated.
966 */
967static int vdDiscardSetRangeAllocated(PVDISK pDisk, uint64_t uOffset, size_t cbRange)
968{
969 PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
970 int rc = VINF_SUCCESS;
971
972 if (pDiscard)
973 {
974 do
975 {
976 size_t cbThisRange = cbRange;
977 PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTAvlrU64RangeGet(pDiscard->pTreeBlocks, uOffset);
978
979 if (pBlock)
980 {
981 int32_t idxStart, idxEnd;
982
983 Assert(!(cbThisRange % 512));
984 Assert(!((uOffset - pBlock->Core.Key) % 512));
985
986 cbThisRange = RT_MIN(cbThisRange, pBlock->Core.KeyLast - uOffset + 1);
987
988 idxStart = (uOffset - pBlock->Core.Key) / 512;
989 idxEnd = idxStart + (int32_t)(cbThisRange / 512);
990 ASMBitSetRange(pBlock->pbmAllocated, idxStart, idxEnd);
991 }
992 else
993 {
994 pBlock = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, uOffset, true);
995 if (pBlock)
996 cbThisRange = RT_MIN(cbThisRange, pBlock->Core.Key - uOffset);
997 }
998
999 Assert(cbRange >= cbThisRange);
1000
1001 uOffset += cbThisRange;
1002 cbRange -= cbThisRange;
1003 } while (cbRange != 0);
1004 }
1005
1006 return rc;
1007}
1008
1009DECLINLINE(PVDIOCTX) vdIoCtxAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
1010 uint64_t uOffset, size_t cbTransfer,
1011 PVDIMAGE pImageStart,PCRTSGBUF pcSgBuf,
1012 void *pvAllocation, PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
1013 uint32_t fFlags)
1014{
1015 PVDIOCTX pIoCtx = NULL;
1016
1017 pIoCtx = (PVDIOCTX)RTMemCacheAlloc(pDisk->hMemCacheIoCtx);
1018 if (RT_LIKELY(pIoCtx))
1019 {
1020 vdIoCtxInit(pIoCtx, pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
1021 pcSgBuf, pvAllocation, pfnIoCtxTransfer, fFlags);
1022 }
1023
1024 return pIoCtx;
1025}
1026
1027DECLINLINE(PVDIOCTX) vdIoCtxRootAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
1028 uint64_t uOffset, size_t cbTransfer,
1029 PVDIMAGE pImageStart, PCRTSGBUF pcSgBuf,
1030 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
1031 void *pvUser1, void *pvUser2,
1032 void *pvAllocation,
1033 PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
1034 uint32_t fFlags)
1035{
1036 PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
1037 pcSgBuf, pvAllocation, pfnIoCtxTransfer, fFlags);
1038
1039 if (RT_LIKELY(pIoCtx))
1040 {
1041 pIoCtx->pIoCtxParent = NULL;
1042 pIoCtx->Type.Root.pfnComplete = pfnComplete;
1043 pIoCtx->Type.Root.pvUser1 = pvUser1;
1044 pIoCtx->Type.Root.pvUser2 = pvUser2;
1045 }
1046
1047 LogFlow(("Allocated root I/O context %#p\n", pIoCtx));
1048 return pIoCtx;
1049}
1050
1051DECLINLINE(void) vdIoCtxDiscardInit(PVDIOCTX pIoCtx, PVDISK pDisk, PCRTRANGE paRanges,
1052 unsigned cRanges, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
1053 void *pvUser1, void *pvUser2, void *pvAllocation,
1054 PFNVDIOCTXTRANSFER pfnIoCtxTransfer, uint32_t fFlags)
1055{
1056 pIoCtx->pIoCtxNext = NULL;
1057 pIoCtx->pDisk = pDisk;
1058 pIoCtx->enmTxDir = VDIOCTXTXDIR_DISCARD;
1059 pIoCtx->cDataTransfersPending = 0;
1060 pIoCtx->cMetaTransfersPending = 0;
1061 pIoCtx->fComplete = false;
1062 pIoCtx->fFlags = fFlags;
1063 pIoCtx->pvAllocation = pvAllocation;
1064 pIoCtx->pfnIoCtxTransfer = pfnIoCtxTransfer;
1065 pIoCtx->pfnIoCtxTransferNext = NULL;
1066 pIoCtx->rcReq = VINF_SUCCESS;
1067 pIoCtx->Req.Discard.paRanges = paRanges;
1068 pIoCtx->Req.Discard.cRanges = cRanges;
1069 pIoCtx->Req.Discard.idxRange = 0;
1070 pIoCtx->Req.Discard.cbDiscardLeft = 0;
1071 pIoCtx->Req.Discard.offCur = 0;
1072 pIoCtx->Req.Discard.cbThisDiscard = 0;
1073
1074 pIoCtx->pIoCtxParent = NULL;
1075 pIoCtx->Type.Root.pfnComplete = pfnComplete;
1076 pIoCtx->Type.Root.pvUser1 = pvUser1;
1077 pIoCtx->Type.Root.pvUser2 = pvUser2;
1078}
1079
1080DECLINLINE(PVDIOCTX) vdIoCtxDiscardAlloc(PVDISK pDisk, PCRTRANGE paRanges,
1081 unsigned cRanges,
1082 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
1083 void *pvUser1, void *pvUser2,
1084 void *pvAllocation,
1085 PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
1086 uint32_t fFlags)
1087{
1088 PVDIOCTX pIoCtx = NULL;
1089
1090 pIoCtx = (PVDIOCTX)RTMemCacheAlloc(pDisk->hMemCacheIoCtx);
1091 if (RT_LIKELY(pIoCtx))
1092 {
1093 vdIoCtxDiscardInit(pIoCtx, pDisk, paRanges, cRanges, pfnComplete, pvUser1,
1094 pvUser2, pvAllocation, pfnIoCtxTransfer, fFlags);
1095 }
1096
1097 LogFlow(("Allocated discard I/O context %#p\n", pIoCtx));
1098 return pIoCtx;
1099}
1100
1101DECLINLINE(PVDIOCTX) vdIoCtxChildAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
1102 uint64_t uOffset, size_t cbTransfer,
1103 PVDIMAGE pImageStart, PCRTSGBUF pcSgBuf,
1104 PVDIOCTX pIoCtxParent, size_t cbTransferParent,
1105 size_t cbWriteParent, void *pvAllocation,
1106 PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
1107{
1108 PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
1109 pcSgBuf, pvAllocation, pfnIoCtxTransfer, pIoCtxParent->fFlags & ~VDIOCTX_FLAGS_DONT_FREE);
1110
1111 AssertPtr(pIoCtxParent);
1112 Assert(!pIoCtxParent->pIoCtxParent);
1113
1114 if (RT_LIKELY(pIoCtx))
1115 {
1116 pIoCtx->pIoCtxParent = pIoCtxParent;
1117 pIoCtx->Type.Child.uOffsetSaved = uOffset;
1118 pIoCtx->Type.Child.cbTransferLeftSaved = cbTransfer;
1119 pIoCtx->Type.Child.cbTransferParent = cbTransferParent;
1120 pIoCtx->Type.Child.cbWriteParent = cbWriteParent;
1121 }
1122
1123 LogFlow(("Allocated child I/O context %#p\n", pIoCtx));
1124 return pIoCtx;
1125}
1126
1127DECLINLINE(PVDIOTASK) vdIoTaskUserAlloc(PVDIOSTORAGE pIoStorage, PFNVDXFERCOMPLETED pfnComplete, void *pvUser, PVDIOCTX pIoCtx, uint32_t cbTransfer)
1128{
1129 PVDIOTASK pIoTask = NULL;
1130
1131 pIoTask = (PVDIOTASK)RTMemCacheAlloc(pIoStorage->pVDIo->pDisk->hMemCacheIoTask);
1132 if (pIoTask)
1133 {
1134 pIoTask->pIoStorage = pIoStorage;
1135 pIoTask->pfnComplete = pfnComplete;
1136 pIoTask->pvUser = pvUser;
1137 pIoTask->fMeta = false;
1138 pIoTask->Type.User.cbTransfer = cbTransfer;
1139 pIoTask->Type.User.pIoCtx = pIoCtx;
1140 }
1141
1142 return pIoTask;
1143}
1144
1145DECLINLINE(PVDIOTASK) vdIoTaskMetaAlloc(PVDIOSTORAGE pIoStorage, PFNVDXFERCOMPLETED pfnComplete, void *pvUser, PVDMETAXFER pMetaXfer)
1146{
1147 PVDIOTASK pIoTask = NULL;
1148
1149 pIoTask = (PVDIOTASK)RTMemCacheAlloc(pIoStorage->pVDIo->pDisk->hMemCacheIoTask);
1150 if (pIoTask)
1151 {
1152 pIoTask->pIoStorage = pIoStorage;
1153 pIoTask->pfnComplete = pfnComplete;
1154 pIoTask->pvUser = pvUser;
1155 pIoTask->fMeta = true;
1156 pIoTask->Type.Meta.pMetaXfer = pMetaXfer;
1157 }
1158
1159 return pIoTask;
1160}
1161
1162DECLINLINE(void) vdIoCtxFree(PVDISK pDisk, PVDIOCTX pIoCtx)
1163{
1164 Log(("Freeing I/O context %#p\n", pIoCtx));
1165
1166 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_DONT_FREE))
1167 {
1168 if (pIoCtx->pvAllocation)
1169 RTMemFree(pIoCtx->pvAllocation);
1170#ifdef DEBUG
1171 memset(&pIoCtx->pDisk, 0xff, sizeof(void *));
1172#endif
1173 RTMemCacheFree(pDisk->hMemCacheIoCtx, pIoCtx);
1174 }
1175}
1176
1177DECLINLINE(void) vdIoTaskFree(PVDISK pDisk, PVDIOTASK pIoTask)
1178{
1179#ifdef DEBUG
1180 memset(pIoTask, 0xff, sizeof(VDIOTASK));
1181#endif
1182 RTMemCacheFree(pDisk->hMemCacheIoTask, pIoTask);
1183}
1184
1185DECLINLINE(void) vdIoCtxChildReset(PVDIOCTX pIoCtx)
1186{
1187 AssertPtr(pIoCtx->pIoCtxParent);
1188
1189 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
1190 pIoCtx->Req.Io.uOffset = pIoCtx->Type.Child.uOffsetSaved;
1191 pIoCtx->Req.Io.cbTransferLeft = (uint32_t)pIoCtx->Type.Child.cbTransferLeftSaved;
1192 Assert((uint32_t)pIoCtx->Type.Child.cbTransferLeftSaved == pIoCtx->Type.Child.cbTransferLeftSaved);
1193}
1194
1195DECLINLINE(PVDMETAXFER) vdMetaXferAlloc(PVDIOSTORAGE pIoStorage, uint64_t uOffset, size_t cb)
1196{
1197 PVDMETAXFER pMetaXfer = (PVDMETAXFER)RTMemAlloc(RT_UOFFSETOF_DYN(VDMETAXFER, abData[cb]));
1198
1199 if (RT_LIKELY(pMetaXfer))
1200 {
1201 pMetaXfer->Core.Key = uOffset;
1202 pMetaXfer->Core.KeyLast = uOffset + cb - 1;
1203 pMetaXfer->fFlags = VDMETAXFER_TXDIR_NONE;
1204 pMetaXfer->cbMeta = cb;
1205 pMetaXfer->pIoStorage = pIoStorage;
1206 pMetaXfer->cRefs = 0;
1207 pMetaXfer->pbDataShw = NULL;
1208 RTListInit(&pMetaXfer->ListIoCtxWaiting);
1209 RTListInit(&pMetaXfer->ListIoCtxShwWrites);
1210 }
1211 return pMetaXfer;
1212}
1213
1214DECLINLINE(void) vdIoCtxAddToWaitingList(volatile PVDIOCTX *ppList, PVDIOCTX pIoCtx)
1215{
1216 /* Put it on the waiting list. */
1217 PVDIOCTX pNext = ASMAtomicUoReadPtrT(ppList, PVDIOCTX);
1218 PVDIOCTX pHeadOld;
1219 pIoCtx->pIoCtxNext = pNext;
1220 while (!ASMAtomicCmpXchgExPtr(ppList, pIoCtx, pNext, &pHeadOld))
1221 {
1222 pNext = pHeadOld;
1223 Assert(pNext != pIoCtx);
1224 pIoCtx->pIoCtxNext = pNext;
1225 ASMNopPause();
1226 }
1227}
1228
1229DECLINLINE(void) vdIoCtxDefer(PVDISK pDisk, PVDIOCTX pIoCtx)
1230{
1231 LogFlowFunc(("Deferring I/O context pIoCtx=%#p\n", pIoCtx));
1232
1233 Assert(!pIoCtx->pIoCtxParent && !(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED));
1234 pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
1235 vdIoCtxAddToWaitingList(&pDisk->pIoCtxBlockedHead, pIoCtx);
1236}
1237
1238static size_t vdIoCtxCopy(PVDIOCTX pIoCtxDst, PVDIOCTX pIoCtxSrc, size_t cbData)
1239{
1240 return RTSgBufCopy(&pIoCtxDst->Req.Io.SgBuf, &pIoCtxSrc->Req.Io.SgBuf, cbData);
1241}
1242
1243#if 0 /* unused */
1244static int vdIoCtxCmp(PVDIOCTX pIoCtx1, PVDIOCTX pIoCtx2, size_t cbData)
1245{
1246 return RTSgBufCmp(&pIoCtx1->Req.Io.SgBuf, &pIoCtx2->Req.Io.SgBuf, cbData);
1247}
1248#endif
1249
1250static size_t vdIoCtxCopyTo(PVDIOCTX pIoCtx, const uint8_t *pbData, size_t cbData)
1251{
1252 return RTSgBufCopyFromBuf(&pIoCtx->Req.Io.SgBuf, pbData, cbData);
1253}
1254
1255static size_t vdIoCtxCopyFrom(PVDIOCTX pIoCtx, uint8_t *pbData, size_t cbData)
1256{
1257 return RTSgBufCopyToBuf(&pIoCtx->Req.Io.SgBuf, pbData, cbData);
1258}
1259
1260static size_t vdIoCtxSet(PVDIOCTX pIoCtx, uint8_t ch, size_t cbData)
1261{
1262 return RTSgBufSet(&pIoCtx->Req.Io.SgBuf, ch, cbData);
1263}
1264
1265/**
1266 * Returns whether the given I/O context has completed.
1267 *
1268 * @returns Flag whether the I/O context is complete.
1269 * @param pIoCtx The I/O context to check.
1270 */
1271DECLINLINE(bool) vdIoCtxIsComplete(PVDIOCTX pIoCtx)
1272{
1273 if ( !pIoCtx->cMetaTransfersPending
1274 && !pIoCtx->cDataTransfersPending
1275 && !pIoCtx->pfnIoCtxTransfer)
1276 return true;
1277
1278 /*
1279 * We complete the I/O context in case of an error
1280 * if there is no I/O task pending.
1281 */
1282 if ( RT_FAILURE(pIoCtx->rcReq)
1283 && !pIoCtx->cMetaTransfersPending
1284 && !pIoCtx->cDataTransfersPending)
1285 return true;
1286
1287 return false;
1288}
1289
1290/**
1291 * Returns whether the given I/O context is blocked due to a metadata transfer
1292 * or because the backend blocked it.
1293 *
1294 * @returns Flag whether the I/O context is blocked.
1295 * @param pIoCtx The I/O context to check.
1296 */
1297DECLINLINE(bool) vdIoCtxIsBlocked(PVDIOCTX pIoCtx)
1298{
1299 /* Don't change anything if there is a metadata transfer pending or we are blocked. */
1300 if ( pIoCtx->cMetaTransfersPending
1301 || (pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
1302 return true;
1303
1304 return false;
1305}
1306
1307/**
1308 * Process the I/O context, core method which assumes that the I/O context
1309 * acquired the lock.
1310 *
1311 * @returns VBox status code.
1312 * @param pIoCtx I/O context to process.
1313 */
1314static int vdIoCtxProcessLocked(PVDIOCTX pIoCtx)
1315{
1316 int rc = VINF_SUCCESS;
1317
1318 VD_IS_LOCKED(pIoCtx->pDisk);
1319
1320 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
1321
1322 if (!vdIoCtxIsComplete(pIoCtx))
1323 {
1324 if (!vdIoCtxIsBlocked(pIoCtx))
1325 {
1326 if (pIoCtx->pfnIoCtxTransfer)
1327 {
1328 /* Call the transfer function advancing to the next while there is no error. */
1329 while ( pIoCtx->pfnIoCtxTransfer
1330 && !pIoCtx->cMetaTransfersPending
1331 && RT_SUCCESS(rc))
1332 {
1333 LogFlowFunc(("calling transfer function %#p\n", pIoCtx->pfnIoCtxTransfer));
1334 rc = pIoCtx->pfnIoCtxTransfer(pIoCtx);
1335
1336 /* Advance to the next part of the transfer if the current one succeeded. */
1337 if (RT_SUCCESS(rc))
1338 {
1339 pIoCtx->pfnIoCtxTransfer = pIoCtx->pfnIoCtxTransferNext;
1340 pIoCtx->pfnIoCtxTransferNext = NULL;
1341 }
1342 }
1343 }
1344
1345 if ( RT_SUCCESS(rc)
1346 && !pIoCtx->cMetaTransfersPending
1347 && !pIoCtx->cDataTransfersPending
1348 && !(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
1349 rc = VINF_VD_ASYNC_IO_FINISHED;
1350 else if ( RT_SUCCESS(rc)
1351 || rc == VERR_VD_NOT_ENOUGH_METADATA
1352 || rc == VERR_VD_IOCTX_HALT)
1353 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1354 else if ( RT_FAILURE(rc)
1355 && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
1356 {
1357 ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rc, VINF_SUCCESS);
1358
1359 /*
1360 * The I/O context completed if we have an error and there is no data
1361 * or meta data transfer pending.
1362 */
1363 if ( !pIoCtx->cMetaTransfersPending
1364 && !pIoCtx->cDataTransfersPending)
1365 rc = VINF_VD_ASYNC_IO_FINISHED;
1366 else
1367 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1368 }
1369 }
1370 else
1371 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1372 }
1373 else
1374 rc = VINF_VD_ASYNC_IO_FINISHED;
1375
1376 LogFlowFunc(("pIoCtx=%#p rc=%Rrc cDataTransfersPending=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
1377 pIoCtx, rc, pIoCtx->cDataTransfersPending, pIoCtx->cMetaTransfersPending,
1378 pIoCtx->fComplete));
1379
1380 return rc;
1381}
1382
1383/**
1384 * Processes the list of waiting I/O contexts.
1385 *
1386 * @returns VBox status code, only valid if pIoCtxRc is not NULL, treat as void
1387 * function otherwise.
1388 * @param pDisk The disk structure.
1389 * @param pIoCtxRc An I/O context handle which waits on the list. When processed
1390 * The status code is returned. NULL if there is no I/O context
1391 * to return the status code for.
1392 */
1393static int vdDiskProcessWaitingIoCtx(PVDISK pDisk, PVDIOCTX pIoCtxRc)
1394{
1395 int rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1396
1397 LogFlowFunc(("pDisk=%#p pIoCtxRc=%#p\n", pDisk, pIoCtxRc));
1398
1399 VD_IS_LOCKED(pDisk);
1400
1401 /* Get the waiting list and process it in FIFO order. */
1402 PVDIOCTX pIoCtxHead = ASMAtomicXchgPtrT(&pDisk->pIoCtxHead, NULL, PVDIOCTX);
1403
1404 /* Reverse it. */
1405 PVDIOCTX pCur = pIoCtxHead;
1406 pIoCtxHead = NULL;
1407 while (pCur)
1408 {
1409 PVDIOCTX pInsert = pCur;
1410 pCur = pCur->pIoCtxNext;
1411 pInsert->pIoCtxNext = pIoCtxHead;
1412 pIoCtxHead = pInsert;
1413 }
1414
1415 /* Process now. */
1416 pCur = pIoCtxHead;
1417 while (pCur)
1418 {
1419 int rcTmp;
1420 PVDIOCTX pTmp = pCur;
1421
1422 pCur = pCur->pIoCtxNext;
1423 pTmp->pIoCtxNext = NULL;
1424
1425 /*
1426 * Need to clear the sync flag here if there is a new I/O context
1427 * with it set and the context is not given in pIoCtxRc.
1428 * This happens most likely on a different thread and that one shouldn't
1429 * process the context synchronously.
1430 *
1431 * The thread who issued the context will wait on the event semaphore
1432 * anyway which is signalled when the completion handler is called.
1433 */
1434 if ( pTmp->fFlags & VDIOCTX_FLAGS_SYNC
1435 && pTmp != pIoCtxRc)
1436 pTmp->fFlags &= ~VDIOCTX_FLAGS_SYNC;
1437
1438 rcTmp = vdIoCtxProcessLocked(pTmp);
1439 if (pTmp == pIoCtxRc)
1440 {
1441 if ( rcTmp == VINF_VD_ASYNC_IO_FINISHED
1442 && RT_SUCCESS(pTmp->rcReq)
1443 && pTmp->enmTxDir == VDIOCTXTXDIR_READ)
1444 {
1445 int rc2 = vdFilterChainApplyRead(pDisk, pTmp->Req.Io.uOffsetXferOrig,
1446 pTmp->Req.Io.cbXferOrig, pTmp);
1447 if (RT_FAILURE(rc2))
1448 rcTmp = rc2;
1449 }
1450
1451 /* The given I/O context was processed, pass the return code to the caller. */
1452 if ( rcTmp == VINF_VD_ASYNC_IO_FINISHED
1453 && (pTmp->fFlags & VDIOCTX_FLAGS_SYNC))
1454 rc = pTmp->rcReq;
1455 else
1456 rc = rcTmp;
1457 }
1458 else if ( rcTmp == VINF_VD_ASYNC_IO_FINISHED
1459 && ASMAtomicCmpXchgBool(&pTmp->fComplete, true, false))
1460 {
1461 LogFlowFunc(("Waiting I/O context completed pTmp=%#p\n", pTmp));
1462 vdThreadFinishWrite(pDisk);
1463
1464 bool fFreeCtx = RT_BOOL(!(pTmp->fFlags & VDIOCTX_FLAGS_DONT_FREE));
1465 vdIoCtxRootComplete(pDisk, pTmp);
1466
1467 if (fFreeCtx)
1468 vdIoCtxFree(pDisk, pTmp);
1469 }
1470 }
1471
1472 LogFlowFunc(("returns rc=%Rrc\n", rc));
1473 return rc;
1474}
1475
1476/**
1477 * Processes the list of blocked I/O contexts.
1478 *
1479 * @returns nothing.
1480 * @param pDisk The disk structure.
1481 */
1482static void vdDiskProcessBlockedIoCtx(PVDISK pDisk)
1483{
1484 LogFlowFunc(("pDisk=%#p\n", pDisk));
1485
1486 VD_IS_LOCKED(pDisk);
1487
1488 /* Get the waiting list and process it in FIFO order. */
1489 PVDIOCTX pIoCtxHead = ASMAtomicXchgPtrT(&pDisk->pIoCtxBlockedHead, NULL, PVDIOCTX);
1490
1491 /* Reverse it. */
1492 PVDIOCTX pCur = pIoCtxHead;
1493 pIoCtxHead = NULL;
1494 while (pCur)
1495 {
1496 PVDIOCTX pInsert = pCur;
1497 pCur = pCur->pIoCtxNext;
1498 pInsert->pIoCtxNext = pIoCtxHead;
1499 pIoCtxHead = pInsert;
1500 }
1501
1502 /* Process now. */
1503 pCur = pIoCtxHead;
1504 while (pCur)
1505 {
1506 int rc;
1507 PVDIOCTX pTmp = pCur;
1508
1509 pCur = pCur->pIoCtxNext;
1510 pTmp->pIoCtxNext = NULL;
1511
1512 Assert(!pTmp->pIoCtxParent);
1513 Assert(pTmp->fFlags & VDIOCTX_FLAGS_BLOCKED);
1514 pTmp->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
1515
1516 rc = vdIoCtxProcessLocked(pTmp);
1517 if ( rc == VINF_VD_ASYNC_IO_FINISHED
1518 && ASMAtomicCmpXchgBool(&pTmp->fComplete, true, false))
1519 {
1520 LogFlowFunc(("Waiting I/O context completed pTmp=%#p\n", pTmp));
1521 vdThreadFinishWrite(pDisk);
1522
1523 bool fFreeCtx = RT_BOOL(!(pTmp->fFlags & VDIOCTX_FLAGS_DONT_FREE));
1524 vdIoCtxRootComplete(pDisk, pTmp);
1525 if (fFreeCtx)
1526 vdIoCtxFree(pDisk, pTmp);
1527 }
1528 }
1529
1530 LogFlowFunc(("returns\n"));
1531}
1532
1533/**
1534 * Processes the I/O context trying to lock the criticial section.
1535 * The context is deferred if the critical section is busy.
1536 *
1537 * @returns VBox status code.
1538 * @param pIoCtx The I/O context to process.
1539 */
1540static int vdIoCtxProcessTryLockDefer(PVDIOCTX pIoCtx)
1541{
1542 int rc = VINF_SUCCESS;
1543 PVDISK pDisk = pIoCtx->pDisk;
1544
1545 Log(("Defer pIoCtx=%#p\n", pIoCtx));
1546
1547 /* Put it on the waiting list first. */
1548 vdIoCtxAddToWaitingList(&pDisk->pIoCtxHead, pIoCtx);
1549
1550 if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
1551 {
1552 /* Leave it again, the context will be processed just before leaving the lock. */
1553 LogFlowFunc(("Successfully acquired the lock\n"));
1554 rc = vdDiskUnlock(pDisk, pIoCtx);
1555 }
1556 else
1557 {
1558 LogFlowFunc(("Lock is held\n"));
1559 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1560 }
1561
1562 return rc;
1563}
1564
1565/**
1566 * Process the I/O context in a synchronous manner, waiting
1567 * for it to complete.
1568 *
1569 * @returns VBox status code of the completed request.
1570 * @param pIoCtx The sync I/O context.
1571 * @param hEventComplete Event sempahore to wait on for completion.
1572 */
1573static int vdIoCtxProcessSync(PVDIOCTX pIoCtx, RTSEMEVENT hEventComplete)
1574{
1575 int rc = VINF_SUCCESS;
1576 PVDISK pDisk = pIoCtx->pDisk;
1577
1578 LogFlowFunc(("pIoCtx=%p\n", pIoCtx));
1579
1580 AssertMsg(pIoCtx->fFlags & (VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE),
1581 ("I/O context is not marked as synchronous\n"));
1582
1583 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
1584 if (rc == VINF_VD_ASYNC_IO_FINISHED)
1585 rc = VINF_SUCCESS;
1586
1587 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1588 {
1589 rc = RTSemEventWait(hEventComplete, RT_INDEFINITE_WAIT);
1590 AssertRC(rc);
1591 }
1592
1593 rc = pIoCtx->rcReq;
1594 vdIoCtxFree(pDisk, pIoCtx);
1595
1596 return rc;
1597}
1598
1599DECLINLINE(bool) vdIoCtxIsDiskLockOwner(PVDISK pDisk, PVDIOCTX pIoCtx)
1600{
1601 return pDisk->pIoCtxLockOwner == pIoCtx;
1602}
1603
1604static int vdIoCtxLockDisk(PVDISK pDisk, PVDIOCTX pIoCtx)
1605{
1606 int rc = VINF_SUCCESS;
1607
1608 VD_IS_LOCKED(pDisk);
1609
1610 LogFlowFunc(("pDisk=%#p pIoCtx=%#p\n", pDisk, pIoCtx));
1611
1612 if (!ASMAtomicCmpXchgPtr(&pDisk->pIoCtxLockOwner, pIoCtx, NIL_VDIOCTX))
1613 {
1614 Assert(pDisk->pIoCtxLockOwner != pIoCtx); /* No nesting allowed. */
1615 vdIoCtxDefer(pDisk, pIoCtx);
1616 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1617 }
1618
1619 LogFlowFunc(("returns -> %Rrc\n", rc));
1620 return rc;
1621}
1622
1623static void vdIoCtxUnlockDisk(PVDISK pDisk, PVDIOCTX pIoCtx, bool fProcessBlockedReqs)
1624{
1625 RT_NOREF1(pIoCtx);
1626 LogFlowFunc(("pDisk=%#p pIoCtx=%#p fProcessBlockedReqs=%RTbool\n",
1627 pDisk, pIoCtx, fProcessBlockedReqs));
1628
1629 VD_IS_LOCKED(pDisk);
1630
1631 LogFlow(("Unlocking disk lock owner is %#p\n", pDisk->pIoCtxLockOwner));
1632 Assert(pDisk->pIoCtxLockOwner == pIoCtx);
1633 ASMAtomicXchgPtrT(&pDisk->pIoCtxLockOwner, NIL_VDIOCTX, PVDIOCTX);
1634
1635 if (fProcessBlockedReqs)
1636 {
1637 /* Process any blocked writes if the current request didn't caused another growing. */
1638 vdDiskProcessBlockedIoCtx(pDisk);
1639 }
1640
1641 LogFlowFunc(("returns\n"));
1642}
1643
1644/**
1645 * Internal: Reads a given amount of data from the image chain of the disk.
1646 **/
1647static int vdDiskReadHelper(PVDISK pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
1648 uint64_t uOffset, size_t cbRead, PVDIOCTX pIoCtx, size_t *pcbThisRead)
1649{
1650 RT_NOREF1(pDisk);
1651 int rc = VINF_SUCCESS;
1652 size_t cbThisRead = cbRead;
1653
1654 AssertPtr(pcbThisRead);
1655
1656 *pcbThisRead = 0;
1657
1658 /*
1659 * Try to read from the given image.
1660 * If the block is not allocated read from override chain if present.
1661 */
1662 rc = pImage->Backend->pfnRead(pImage->pBackendData,
1663 uOffset, cbThisRead, pIoCtx,
1664 &cbThisRead);
1665
1666 if (rc == VERR_VD_BLOCK_FREE)
1667 {
1668 for (PVDIMAGE pCurrImage = pImageParentOverride ? pImageParentOverride : pImage->pPrev;
1669 pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
1670 pCurrImage = pCurrImage->pPrev)
1671 {
1672 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
1673 uOffset, cbThisRead, pIoCtx,
1674 &cbThisRead);
1675 }
1676 }
1677
1678 if (RT_SUCCESS(rc) || rc == VERR_VD_BLOCK_FREE)
1679 *pcbThisRead = cbThisRead;
1680
1681 return rc;
1682}
1683
1684/**
1685 * internal: read the specified amount of data in whatever blocks the backend
1686 * will give us - async version.
1687 */
1688static DECLCALLBACK(int) vdReadHelperAsync(PVDIOCTX pIoCtx)
1689{
1690 int rc;
1691 PVDISK pDisk = pIoCtx->pDisk;
1692 size_t cbToRead = pIoCtx->Req.Io.cbTransfer;
1693 uint64_t uOffset = pIoCtx->Req.Io.uOffset;
1694 PVDIMAGE pCurrImage = pIoCtx->Req.Io.pImageCur;
1695 PVDIMAGE pImageParentOverride = pIoCtx->Req.Io.pImageParentOverride;
1696 unsigned cImagesRead = pIoCtx->Req.Io.cImagesRead;
1697 size_t cbThisRead;
1698
1699 /*
1700 * Check whether there is a full block write in progress which was not allocated.
1701 * Defer I/O if the range interferes but only if it does not belong to the
1702 * write doing the allocation.
1703 */
1704 if ( pDisk->pIoCtxLockOwner != NIL_VDIOCTX
1705 && uOffset >= pDisk->uOffsetStartLocked
1706 && uOffset < pDisk->uOffsetEndLocked
1707 && ( !pIoCtx->pIoCtxParent
1708 || pIoCtx->pIoCtxParent != pDisk->pIoCtxLockOwner))
1709 {
1710 Log(("Interferring read while allocating a new block => deferring read\n"));
1711 vdIoCtxDefer(pDisk, pIoCtx);
1712 return VERR_VD_ASYNC_IO_IN_PROGRESS;
1713 }
1714
1715 /* Loop until all reads started or we have a backend which needs to read metadata. */
1716 do
1717 {
1718 /* Search for image with allocated block. Do not attempt to read more
1719 * than the previous reads marked as valid. Otherwise this would return
1720 * stale data when different block sizes are used for the images. */
1721 cbThisRead = cbToRead;
1722
1723 if ( pDisk->pCache
1724 && !pImageParentOverride)
1725 {
1726 rc = vdCacheReadHelper(pDisk->pCache, uOffset, cbThisRead,
1727 pIoCtx, &cbThisRead);
1728 if (rc == VERR_VD_BLOCK_FREE)
1729 {
1730 rc = vdDiskReadHelper(pDisk, pCurrImage, NULL, uOffset, cbThisRead,
1731 pIoCtx, &cbThisRead);
1732
1733 /* If the read was successful, write the data back into the cache. */
1734 if ( RT_SUCCESS(rc)
1735 && pIoCtx->fFlags & VDIOCTX_FLAGS_READ_UPDATE_CACHE)
1736 {
1737 rc = vdCacheWriteHelper(pDisk->pCache, uOffset, cbThisRead,
1738 pIoCtx, NULL);
1739 }
1740 }
1741 }
1742 else
1743 {
1744 /*
1745 * Try to read from the given image.
1746 * If the block is not allocated read from override chain if present.
1747 */
1748 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
1749 uOffset, cbThisRead, pIoCtx,
1750 &cbThisRead);
1751
1752 if ( rc == VERR_VD_BLOCK_FREE
1753 && cImagesRead != 1)
1754 {
1755 unsigned cImagesToProcess = cImagesRead;
1756
1757 pCurrImage = pImageParentOverride ? pImageParentOverride : pCurrImage->pPrev;
1758 pIoCtx->Req.Io.pImageParentOverride = NULL;
1759
1760 while (pCurrImage && rc == VERR_VD_BLOCK_FREE)
1761 {
1762 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
1763 uOffset, cbThisRead,
1764 pIoCtx, &cbThisRead);
1765 if (cImagesToProcess == 1)
1766 break;
1767 else if (cImagesToProcess > 0)
1768 cImagesToProcess--;
1769
1770 if (rc == VERR_VD_BLOCK_FREE)
1771 pCurrImage = pCurrImage->pPrev;
1772 }
1773 }
1774 }
1775
1776 /* The task state will be updated on success already, don't do it here!. */
1777 if (rc == VERR_VD_BLOCK_FREE)
1778 {
1779 /* No image in the chain contains the data for the block. */
1780 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbThisRead); Assert(cbThisRead == (uint32_t)cbThisRead);
1781
1782 /* Fill the free space with 0 if we are told to do so
1783 * or a previous read returned valid data. */
1784 if (pIoCtx->fFlags & VDIOCTX_FLAGS_ZERO_FREE_BLOCKS)
1785 vdIoCtxSet(pIoCtx, '\0', cbThisRead);
1786 else
1787 pIoCtx->Req.Io.cbBufClear += cbThisRead;
1788
1789 if (pIoCtx->Req.Io.pImageCur->uOpenFlags & VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS)
1790 rc = VINF_VD_NEW_ZEROED_BLOCK;
1791 else
1792 rc = VINF_SUCCESS;
1793 }
1794 else if (rc == VERR_VD_IOCTX_HALT)
1795 {
1796 uOffset += cbThisRead;
1797 cbToRead -= cbThisRead;
1798 pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
1799 }
1800 else if ( RT_SUCCESS(rc)
1801 || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1802 {
1803 /* First not free block, fill the space before with 0. */
1804 if ( pIoCtx->Req.Io.cbBufClear
1805 && !(pIoCtx->fFlags & VDIOCTX_FLAGS_ZERO_FREE_BLOCKS))
1806 {
1807 RTSGBUF SgBuf;
1808 RTSgBufClone(&SgBuf, &pIoCtx->Req.Io.SgBuf);
1809 RTSgBufReset(&SgBuf);
1810 RTSgBufSet(&SgBuf, 0, pIoCtx->Req.Io.cbBufClear);
1811 pIoCtx->Req.Io.cbBufClear = 0;
1812 pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
1813 }
1814 rc = VINF_SUCCESS;
1815 }
1816
1817 if (RT_FAILURE(rc))
1818 break;
1819
1820 cbToRead -= cbThisRead;
1821 uOffset += cbThisRead;
1822 pCurrImage = pIoCtx->Req.Io.pImageStart; /* Start with the highest image in the chain. */
1823 } while (cbToRead != 0 && RT_SUCCESS(rc));
1824
1825 if ( rc == VERR_VD_NOT_ENOUGH_METADATA
1826 || rc == VERR_VD_IOCTX_HALT)
1827 {
1828 /* Save the current state. */
1829 pIoCtx->Req.Io.uOffset = uOffset;
1830 pIoCtx->Req.Io.cbTransfer = cbToRead;
1831 pIoCtx->Req.Io.pImageCur = pCurrImage ? pCurrImage : pIoCtx->Req.Io.pImageStart;
1832 }
1833
1834 return (!(pIoCtx->fFlags & VDIOCTX_FLAGS_ZERO_FREE_BLOCKS))
1835 ? VERR_VD_BLOCK_FREE
1836 : rc;
1837}
1838
1839/**
1840 * internal: parent image read wrapper for compacting.
1841 */
1842static DECLCALLBACK(int) vdParentRead(void *pvUser, uint64_t uOffset, void *pvBuf,
1843 size_t cbRead)
1844{
1845 PVDPARENTSTATEDESC pParentState = (PVDPARENTSTATEDESC)pvUser;
1846
1847 /** @todo
1848 * Only used for compaction so far which is not possible to mix with async I/O.
1849 * Needs to be changed if we want to support online compaction of images.
1850 */
1851 bool fLocked = ASMAtomicXchgBool(&pParentState->pDisk->fLocked, true);
1852 AssertMsgReturn(!fLocked,
1853 ("Calling synchronous parent read while another thread holds the disk lock\n"),
1854 VERR_VD_INVALID_STATE);
1855
1856 /* Fake an I/O context. */
1857 RTSGSEG Segment;
1858 RTSGBUF SgBuf;
1859 VDIOCTX IoCtx;
1860
1861 Segment.pvSeg = pvBuf;
1862 Segment.cbSeg = cbRead;
1863 RTSgBufInit(&SgBuf, &Segment, 1);
1864 vdIoCtxInit(&IoCtx, pParentState->pDisk, VDIOCTXTXDIR_READ, uOffset, cbRead, pParentState->pImage,
1865 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_ZERO_FREE_BLOCKS);
1866 int rc = vdReadHelperAsync(&IoCtx);
1867 ASMAtomicXchgBool(&pParentState->pDisk->fLocked, false);
1868 return rc;
1869}
1870
1871/**
1872 * Extended version of vdReadHelper(), implementing certain optimizations
1873 * for image cloning.
1874 *
1875 * @returns VBox status code.
1876 * @param pDisk The disk to read from.
1877 * @param pImage The image to start reading from.
1878 * @param pImageParentOverride The parent image to read from
1879 * if the starting image returns a free block.
1880 * If NULL is passed the real parent of the image
1881 * in the chain is used.
1882 * @param uOffset Offset in the disk to start reading from.
1883 * @param pvBuf Where to store the read data.
1884 * @param cbRead How much to read.
1885 * @param fZeroFreeBlocks Flag whether free blocks should be zeroed.
1886 * If false and no image has data for sepcified
1887 * range VERR_VD_BLOCK_FREE is returned.
1888 * Note that unallocated blocks are still zeroed
1889 * if at least one image has valid data for a part
1890 * of the range.
1891 * @param fUpdateCache Flag whether to update the attached cache if
1892 * available.
1893 * @param cImagesRead Number of images in the chain to read until
1894 * the read is cut off. A value of 0 disables the cut off.
1895 */
1896static int vdReadHelperEx(PVDISK pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
1897 uint64_t uOffset, void *pvBuf, size_t cbRead,
1898 bool fZeroFreeBlocks, bool fUpdateCache, unsigned cImagesRead)
1899{
1900 int rc = VINF_SUCCESS;
1901 uint32_t fFlags = VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE;
1902 RTSGSEG Segment;
1903 RTSGBUF SgBuf;
1904 VDIOCTX IoCtx;
1905 RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
1906
1907 rc = RTSemEventCreate(&hEventComplete);
1908 if (RT_FAILURE(rc))
1909 return rc;
1910
1911 if (fZeroFreeBlocks)
1912 fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
1913 if (fUpdateCache)
1914 fFlags |= VDIOCTX_FLAGS_READ_UPDATE_CACHE;
1915
1916 Segment.pvSeg = pvBuf;
1917 Segment.cbSeg = cbRead;
1918 RTSgBufInit(&SgBuf, &Segment, 1);
1919 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, uOffset, cbRead, pImage, &SgBuf,
1920 NULL, vdReadHelperAsync, fFlags);
1921
1922 IoCtx.Req.Io.pImageParentOverride = pImageParentOverride;
1923 IoCtx.Req.Io.cImagesRead = cImagesRead;
1924 IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
1925 IoCtx.Type.Root.pvUser1 = pDisk;
1926 IoCtx.Type.Root.pvUser2 = hEventComplete;
1927 rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
1928 RTSemEventDestroy(hEventComplete);
1929 return rc;
1930}
1931
1932/**
1933 * internal: read the specified amount of data in whatever blocks the backend
1934 * will give us.
1935 */
1936static int vdReadHelper(PVDISK pDisk, PVDIMAGE pImage, uint64_t uOffset,
1937 void *pvBuf, size_t cbRead, bool fUpdateCache)
1938{
1939 return vdReadHelperEx(pDisk, pImage, NULL, uOffset, pvBuf, cbRead,
1940 true /* fZeroFreeBlocks */, fUpdateCache, 0);
1941}
1942
1943/**
1944 * internal: mark the disk as not modified.
1945 */
1946static void vdResetModifiedFlag(PVDISK pDisk)
1947{
1948 if (pDisk->uModified & VD_IMAGE_MODIFIED_FLAG)
1949 {
1950 /* generate new last-modified uuid */
1951 if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
1952 {
1953 RTUUID Uuid;
1954
1955 RTUuidCreate(&Uuid);
1956 pDisk->pLast->Backend->pfnSetModificationUuid(pDisk->pLast->pBackendData,
1957 &Uuid);
1958
1959 if (pDisk->pCache)
1960 pDisk->pCache->Backend->pfnSetModificationUuid(pDisk->pCache->pBackendData,
1961 &Uuid);
1962 }
1963
1964 pDisk->uModified &= ~VD_IMAGE_MODIFIED_FLAG;
1965 }
1966}
1967
1968/**
1969 * internal: mark the disk as modified.
1970 */
1971static void vdSetModifiedFlag(PVDISK pDisk)
1972{
1973 pDisk->uModified |= VD_IMAGE_MODIFIED_FLAG;
1974 if (pDisk->uModified & VD_IMAGE_MODIFIED_FIRST)
1975 {
1976 pDisk->uModified &= ~VD_IMAGE_MODIFIED_FIRST;
1977
1978 /* First modify, so create a UUID and ensure it's written to disk. */
1979 vdResetModifiedFlag(pDisk);
1980
1981 if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
1982 {
1983 VDIOCTX IoCtx;
1984 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, NULL,
1985 NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
1986 pDisk->pLast->Backend->pfnFlush(pDisk->pLast->pBackendData, &IoCtx);
1987 }
1988 }
1989}
1990
1991/**
1992 * internal: write buffer to the image, taking care of block boundaries and
1993 * write optimizations.
1994 */
1995static int vdWriteHelperEx(PVDISK pDisk, PVDIMAGE pImage,
1996 PVDIMAGE pImageParentOverride, uint64_t uOffset,
1997 const void *pvBuf, size_t cbWrite,
1998 uint32_t fFlags, unsigned cImagesRead)
1999{
2000 int rc = VINF_SUCCESS;
2001 RTSGSEG Segment;
2002 RTSGBUF SgBuf;
2003 VDIOCTX IoCtx;
2004 RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
2005
2006 rc = RTSemEventCreate(&hEventComplete);
2007 if (RT_FAILURE(rc))
2008 return rc;
2009
2010 fFlags |= VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE;
2011
2012 Segment.pvSeg = (void *)pvBuf;
2013 Segment.cbSeg = cbWrite;
2014 RTSgBufInit(&SgBuf, &Segment, 1);
2015 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_WRITE, uOffset, cbWrite, pImage, &SgBuf,
2016 NULL, vdWriteHelperAsync, fFlags);
2017
2018 IoCtx.Req.Io.pImageParentOverride = pImageParentOverride;
2019 IoCtx.Req.Io.cImagesRead = cImagesRead;
2020 IoCtx.pIoCtxParent = NULL;
2021 IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
2022 IoCtx.Type.Root.pvUser1 = pDisk;
2023 IoCtx.Type.Root.pvUser2 = hEventComplete;
2024 if (RT_SUCCESS(rc))
2025 rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
2026
2027 RTSemEventDestroy(hEventComplete);
2028 return rc;
2029}
2030
2031/**
2032 * internal: write buffer to the image, taking care of block boundaries and
2033 * write optimizations.
2034 */
2035static int vdWriteHelper(PVDISK pDisk, PVDIMAGE pImage, uint64_t uOffset,
2036 const void *pvBuf, size_t cbWrite, uint32_t fFlags)
2037{
2038 return vdWriteHelperEx(pDisk, pImage, NULL, uOffset, pvBuf, cbWrite,
2039 fFlags, 0);
2040}
2041
2042/**
2043 * Internal: Copies the content of one disk to another one applying optimizations
2044 * to speed up the copy process if possible.
2045 */
2046static int vdCopyHelper(PVDISK pDiskFrom, PVDIMAGE pImageFrom, PVDISK pDiskTo,
2047 uint64_t cbSize, unsigned cImagesFromRead, unsigned cImagesToRead,
2048 bool fSuppressRedundantIo, PVDINTERFACEPROGRESS pIfProgress,
2049 PVDINTERFACEPROGRESS pDstIfProgress)
2050{
2051 int rc = VINF_SUCCESS;
2052 int rc2;
2053 uint64_t uOffset = 0;
2054 uint64_t cbRemaining = cbSize;
2055 void *pvBuf = NULL;
2056 bool fLockReadFrom = false;
2057 bool fLockWriteTo = false;
2058 bool fBlockwiseCopy = false;
2059 unsigned uProgressOld = 0;
2060
2061 LogFlowFunc(("pDiskFrom=%#p pImageFrom=%#p pDiskTo=%#p cbSize=%llu cImagesFromRead=%u cImagesToRead=%u fSuppressRedundantIo=%RTbool pIfProgress=%#p pDstIfProgress=%#p\n",
2062 pDiskFrom, pImageFrom, pDiskTo, cbSize, cImagesFromRead, cImagesToRead, fSuppressRedundantIo, pDstIfProgress, pDstIfProgress));
2063
2064 if ( (fSuppressRedundantIo || (cImagesFromRead > 0))
2065 && RTListIsEmpty(&pDiskFrom->ListFilterChainRead))
2066 fBlockwiseCopy = true;
2067
2068 /* Allocate tmp buffer. */
2069 pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
2070 if (!pvBuf)
2071 return rc;
2072
2073 do
2074 {
2075 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
2076
2077 /* Note that we don't attempt to synchronize cross-disk accesses.
2078 * It wouldn't be very difficult to do, just the lock order would
2079 * need to be defined somehow to prevent deadlocks. Postpone such
2080 * magic as there is no use case for this. */
2081
2082 rc2 = vdThreadStartRead(pDiskFrom);
2083 AssertRC(rc2);
2084 fLockReadFrom = true;
2085
2086 if (fBlockwiseCopy)
2087 {
2088 RTSGSEG SegmentBuf;
2089 RTSGBUF SgBuf;
2090 VDIOCTX IoCtx;
2091
2092 SegmentBuf.pvSeg = pvBuf;
2093 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
2094 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
2095 vdIoCtxInit(&IoCtx, pDiskFrom, VDIOCTXTXDIR_READ, 0, 0, NULL,
2096 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
2097
2098 /* Read the source data. */
2099 rc = pImageFrom->Backend->pfnRead(pImageFrom->pBackendData,
2100 uOffset, cbThisRead, &IoCtx,
2101 &cbThisRead);
2102
2103 if ( rc == VERR_VD_BLOCK_FREE
2104 && cImagesFromRead != 1)
2105 {
2106 unsigned cImagesToProcess = cImagesFromRead;
2107
2108 for (PVDIMAGE pCurrImage = pImageFrom->pPrev;
2109 pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
2110 pCurrImage = pCurrImage->pPrev)
2111 {
2112 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
2113 uOffset, cbThisRead,
2114 &IoCtx, &cbThisRead);
2115 if (cImagesToProcess == 1)
2116 break;
2117 else if (cImagesToProcess > 0)
2118 cImagesToProcess--;
2119 }
2120 }
2121 }
2122 else
2123 rc = vdReadHelper(pDiskFrom, pImageFrom, uOffset, pvBuf, cbThisRead,
2124 false /* fUpdateCache */);
2125
2126 if (RT_FAILURE(rc) && rc != VERR_VD_BLOCK_FREE)
2127 break;
2128
2129 rc2 = vdThreadFinishRead(pDiskFrom);
2130 AssertRC(rc2);
2131 fLockReadFrom = false;
2132
2133 if (rc != VERR_VD_BLOCK_FREE)
2134 {
2135 rc2 = vdThreadStartWrite(pDiskTo);
2136 AssertRC(rc2);
2137 fLockWriteTo = true;
2138
2139 /* Only do collapsed I/O if we are copying the data blockwise. */
2140 rc = vdWriteHelperEx(pDiskTo, pDiskTo->pLast, NULL, uOffset, pvBuf,
2141 cbThisRead, VDIOCTX_FLAGS_DONT_SET_MODIFIED_FLAG /* fFlags */,
2142 fBlockwiseCopy ? cImagesToRead : 0);
2143 if (RT_FAILURE(rc))
2144 break;
2145
2146 rc2 = vdThreadFinishWrite(pDiskTo);
2147 AssertRC(rc2);
2148 fLockWriteTo = false;
2149 }
2150 else /* Don't propagate the error to the outside */
2151 rc = VINF_SUCCESS;
2152
2153 uOffset += cbThisRead;
2154 cbRemaining -= cbThisRead;
2155
2156 unsigned uProgressNew = uOffset * 99 / cbSize;
2157 if (uProgressNew != uProgressOld)
2158 {
2159 uProgressOld = uProgressNew;
2160
2161 if (pIfProgress && pIfProgress->pfnProgress)
2162 {
2163 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2164 uProgressOld);
2165 if (RT_FAILURE(rc))
2166 break;
2167 }
2168 if (pDstIfProgress && pDstIfProgress->pfnProgress)
2169 {
2170 rc = pDstIfProgress->pfnProgress(pDstIfProgress->Core.pvUser,
2171 uProgressOld);
2172 if (RT_FAILURE(rc))
2173 break;
2174 }
2175 }
2176 } while (uOffset < cbSize);
2177
2178 RTMemFree(pvBuf);
2179
2180 if (fLockReadFrom)
2181 {
2182 rc2 = vdThreadFinishRead(pDiskFrom);
2183 AssertRC(rc2);
2184 }
2185
2186 if (fLockWriteTo)
2187 {
2188 rc2 = vdThreadFinishWrite(pDiskTo);
2189 AssertRC(rc2);
2190 }
2191
2192 LogFlowFunc(("returns rc=%Rrc\n", rc));
2193 return rc;
2194}
2195
2196/**
2197 * Flush helper async version.
2198 */
2199static DECLCALLBACK(int) vdSetModifiedHelperAsync(PVDIOCTX pIoCtx)
2200{
2201 int rc = VINF_SUCCESS;
2202 PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
2203
2204 rc = pImage->Backend->pfnFlush(pImage->pBackendData, pIoCtx);
2205 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
2206 rc = VINF_SUCCESS;
2207
2208 return rc;
2209}
2210
2211/**
2212 * internal: mark the disk as modified - async version.
2213 */
2214static int vdSetModifiedFlagAsync(PVDISK pDisk, PVDIOCTX pIoCtx)
2215{
2216 int rc = VINF_SUCCESS;
2217
2218 VD_IS_LOCKED(pDisk);
2219
2220 pDisk->uModified |= VD_IMAGE_MODIFIED_FLAG;
2221 if (pDisk->uModified & VD_IMAGE_MODIFIED_FIRST)
2222 {
2223 rc = vdIoCtxLockDisk(pDisk, pIoCtx);
2224 if (RT_SUCCESS(rc))
2225 {
2226 pDisk->uModified &= ~VD_IMAGE_MODIFIED_FIRST;
2227
2228 /* First modify, so create a UUID and ensure it's written to disk. */
2229 vdResetModifiedFlag(pDisk);
2230
2231 if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
2232 {
2233 PVDIOCTX pIoCtxFlush = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_FLUSH,
2234 0, 0, pDisk->pLast,
2235 NULL, pIoCtx, 0, 0, NULL,
2236 vdSetModifiedHelperAsync);
2237
2238 if (pIoCtxFlush)
2239 {
2240 rc = vdIoCtxProcessLocked(pIoCtxFlush);
2241 if (rc == VINF_VD_ASYNC_IO_FINISHED)
2242 {
2243 vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs */);
2244 vdIoCtxFree(pDisk, pIoCtxFlush);
2245 }
2246 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
2247 {
2248 ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
2249 pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
2250 }
2251 else /* Another error */
2252 vdIoCtxFree(pDisk, pIoCtxFlush);
2253 }
2254 else
2255 rc = VERR_NO_MEMORY;
2256 }
2257 }
2258 }
2259
2260 return rc;
2261}
2262
2263static DECLCALLBACK(int) vdWriteHelperCommitAsync(PVDIOCTX pIoCtx)
2264{
2265 int rc = VINF_SUCCESS;
2266 PVDIMAGE pImage = pIoCtx->Req.Io.pImageStart;
2267 size_t cbPreRead = pIoCtx->Type.Child.cbPreRead;
2268 size_t cbPostRead = pIoCtx->Type.Child.cbPostRead;
2269 size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
2270
2271 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2272 rc = pImage->Backend->pfnWrite(pImage->pBackendData,
2273 pIoCtx->Req.Io.uOffset - cbPreRead,
2274 cbPreRead + cbThisWrite + cbPostRead,
2275 pIoCtx, NULL, &cbPreRead, &cbPostRead, 0);
2276 Assert(rc != VERR_VD_BLOCK_FREE);
2277 Assert(rc == VERR_VD_NOT_ENOUGH_METADATA || cbPreRead == 0);
2278 Assert(rc == VERR_VD_NOT_ENOUGH_METADATA || cbPostRead == 0);
2279 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
2280 rc = VINF_SUCCESS;
2281 else if (rc == VERR_VD_IOCTX_HALT)
2282 {
2283 pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
2284 rc = VINF_SUCCESS;
2285 }
2286
2287 LogFlowFunc(("returns rc=%Rrc\n", rc));
2288 return rc;
2289}
2290
2291static DECLCALLBACK(int) vdWriteHelperOptimizedCmpAndWriteAsync(PVDIOCTX pIoCtx)
2292{
2293 int rc = VINF_SUCCESS;
2294 size_t cbThisWrite = 0;
2295 size_t cbPreRead = pIoCtx->Type.Child.cbPreRead;
2296 size_t cbPostRead = pIoCtx->Type.Child.cbPostRead;
2297 size_t cbWriteCopy = pIoCtx->Type.Child.Write.Optimized.cbWriteCopy;
2298 size_t cbFill = pIoCtx->Type.Child.Write.Optimized.cbFill;
2299 size_t cbReadImage = pIoCtx->Type.Child.Write.Optimized.cbReadImage;
2300 PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
2301
2302 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2303
2304 AssertPtr(pIoCtxParent);
2305 Assert(!pIoCtxParent->pIoCtxParent);
2306 Assert(!pIoCtx->Req.Io.cbTransferLeft && !pIoCtx->cMetaTransfersPending);
2307
2308 vdIoCtxChildReset(pIoCtx);
2309 cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
2310 RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbPreRead);
2311
2312 /* Check if the write would modify anything in this block. */
2313 if (!RTSgBufCmp(&pIoCtx->Req.Io.SgBuf, &pIoCtxParent->Req.Io.SgBuf, cbThisWrite))
2314 {
2315 RTSGBUF SgBufSrcTmp;
2316
2317 RTSgBufClone(&SgBufSrcTmp, &pIoCtxParent->Req.Io.SgBuf);
2318 RTSgBufAdvance(&SgBufSrcTmp, cbThisWrite);
2319 RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbThisWrite);
2320
2321 if (!cbWriteCopy || !RTSgBufCmp(&pIoCtx->Req.Io.SgBuf, &SgBufSrcTmp, cbWriteCopy))
2322 {
2323 /* Block is completely unchanged, so no need to write anything. */
2324 LogFlowFunc(("Block didn't changed\n"));
2325 ASMAtomicWriteU32(&pIoCtx->Req.Io.cbTransferLeft, 0);
2326 RTSgBufAdvance(&pIoCtxParent->Req.Io.SgBuf, cbThisWrite);
2327 return VINF_VD_ASYNC_IO_FINISHED;
2328 }
2329 }
2330
2331 /* Copy the data to the right place in the buffer. */
2332 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
2333 RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbPreRead);
2334 vdIoCtxCopy(pIoCtx, pIoCtxParent, cbThisWrite);
2335
2336 /* Handle the data that goes after the write to fill the block. */
2337 if (cbPostRead)
2338 {
2339 /* Now assemble the remaining data. */
2340 if (cbWriteCopy)
2341 {
2342 /*
2343 * The S/G buffer of the parent needs to be cloned because
2344 * it is not allowed to modify the state.
2345 */
2346 RTSGBUF SgBufParentTmp;
2347
2348 RTSgBufClone(&SgBufParentTmp, &pIoCtxParent->Req.Io.SgBuf);
2349 RTSgBufCopy(&pIoCtx->Req.Io.SgBuf, &SgBufParentTmp, cbWriteCopy);
2350 }
2351
2352 /* Zero out the remainder of this block. Will never be visible, as this
2353 * is beyond the limit of the image. */
2354 if (cbFill)
2355 {
2356 RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbReadImage);
2357 vdIoCtxSet(pIoCtx, '\0', cbFill);
2358 }
2359 }
2360
2361 /* Write the full block to the virtual disk. */
2362 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
2363 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
2364
2365 return rc;
2366}
2367
2368static DECLCALLBACK(int) vdWriteHelperOptimizedPreReadAsync(PVDIOCTX pIoCtx)
2369{
2370 int rc = VINF_SUCCESS;
2371
2372 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2373
2374 pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
2375
2376 if ( pIoCtx->Req.Io.cbTransferLeft
2377 && !pIoCtx->cDataTransfersPending)
2378 rc = vdReadHelperAsync(pIoCtx);
2379
2380 if ( ( RT_SUCCESS(rc)
2381 || (rc == VERR_VD_ASYNC_IO_IN_PROGRESS))
2382 && ( pIoCtx->Req.Io.cbTransferLeft
2383 || pIoCtx->cMetaTransfersPending))
2384 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
2385 else
2386 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedCmpAndWriteAsync;
2387
2388 return rc;
2389}
2390
2391/**
2392 * internal: write a complete block (only used for diff images), taking the
2393 * remaining data from parent images. This implementation optimizes out writes
2394 * that do not change the data relative to the state as of the parent images.
2395 * All backends which support differential/growing images support this - async version.
2396 */
2397static DECLCALLBACK(int) vdWriteHelperOptimizedAsync(PVDIOCTX pIoCtx)
2398{
2399 PVDISK pDisk = pIoCtx->pDisk;
2400 uint64_t uOffset = pIoCtx->Type.Child.uOffsetSaved;
2401 size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
2402 size_t cbPreRead = pIoCtx->Type.Child.cbPreRead;
2403 size_t cbPostRead = pIoCtx->Type.Child.cbPostRead;
2404 size_t cbWrite = pIoCtx->Type.Child.cbWriteParent;
2405 size_t cbFill = 0;
2406 size_t cbWriteCopy = 0;
2407 size_t cbReadImage = 0;
2408
2409 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2410
2411 AssertPtr(pIoCtx->pIoCtxParent);
2412 Assert(!pIoCtx->pIoCtxParent->pIoCtxParent);
2413
2414 if (cbPostRead)
2415 {
2416 /* Figure out how much we cannot read from the image, because
2417 * the last block to write might exceed the nominal size of the
2418 * image for technical reasons. */
2419 if (uOffset + cbThisWrite + cbPostRead > pDisk->cbSize)
2420 cbFill = uOffset + cbThisWrite + cbPostRead - pDisk->cbSize;
2421
2422 /* If we have data to be written, use that instead of reading
2423 * data from the image. */
2424 if (cbWrite > cbThisWrite)
2425 cbWriteCopy = RT_MIN(cbWrite - cbThisWrite, cbPostRead);
2426
2427 /* The rest must be read from the image. */
2428 cbReadImage = cbPostRead - cbWriteCopy - cbFill;
2429 }
2430
2431 pIoCtx->Type.Child.Write.Optimized.cbFill = cbFill;
2432 pIoCtx->Type.Child.Write.Optimized.cbWriteCopy = cbWriteCopy;
2433 pIoCtx->Type.Child.Write.Optimized.cbReadImage = cbReadImage;
2434
2435 /* Read the entire data of the block so that we can compare whether it will
2436 * be modified by the write or not. */
2437 size_t cbTmp = cbPreRead + cbThisWrite + cbPostRead - cbFill; Assert(cbTmp == (uint32_t)cbTmp);
2438 pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbTmp;
2439 pIoCtx->Req.Io.cbTransfer = pIoCtx->Req.Io.cbTransferLeft;
2440 pIoCtx->Req.Io.uOffset -= cbPreRead;
2441
2442 /* Next step */
2443 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedPreReadAsync;
2444 return VINF_SUCCESS;
2445}
2446
2447static DECLCALLBACK(int) vdWriteHelperStandardReadImageAsync(PVDIOCTX pIoCtx)
2448{
2449 int rc = VINF_SUCCESS;
2450
2451 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2452
2453 pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
2454
2455 if ( pIoCtx->Req.Io.cbTransferLeft
2456 && !pIoCtx->cDataTransfersPending)
2457 rc = vdReadHelperAsync(pIoCtx);
2458
2459 if ( RT_SUCCESS(rc)
2460 && ( pIoCtx->Req.Io.cbTransferLeft
2461 || pIoCtx->cMetaTransfersPending))
2462 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
2463 else
2464 {
2465 size_t cbFill = pIoCtx->Type.Child.Write.Optimized.cbFill;
2466
2467 /* Zero out the remainder of this block. Will never be visible, as this
2468 * is beyond the limit of the image. */
2469 if (cbFill)
2470 vdIoCtxSet(pIoCtx, '\0', cbFill);
2471
2472 /* Write the full block to the virtual disk. */
2473 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
2474
2475 vdIoCtxChildReset(pIoCtx);
2476 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
2477 }
2478
2479 return rc;
2480}
2481
2482static DECLCALLBACK(int) vdWriteHelperStandardAssemble(PVDIOCTX pIoCtx)
2483{
2484 int rc = VINF_SUCCESS;
2485 size_t cbPostRead = pIoCtx->Type.Child.cbPostRead;
2486 size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
2487 PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
2488
2489 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2490
2491 vdIoCtxCopy(pIoCtx, pIoCtxParent, cbThisWrite);
2492 if (cbPostRead)
2493 {
2494 size_t cbFill = pIoCtx->Type.Child.Write.Optimized.cbFill;
2495 size_t cbWriteCopy = pIoCtx->Type.Child.Write.Optimized.cbWriteCopy;
2496 size_t cbReadImage = pIoCtx->Type.Child.Write.Optimized.cbReadImage;
2497
2498 /* Now assemble the remaining data. */
2499 if (cbWriteCopy)
2500 {
2501 /*
2502 * The S/G buffer of the parent needs to be cloned because
2503 * it is not allowed to modify the state.
2504 */
2505 RTSGBUF SgBufParentTmp;
2506
2507 RTSgBufClone(&SgBufParentTmp, &pIoCtxParent->Req.Io.SgBuf);
2508 RTSgBufCopy(&pIoCtx->Req.Io.SgBuf, &SgBufParentTmp, cbWriteCopy);
2509 }
2510
2511 if (cbReadImage)
2512 {
2513 /* Read remaining data. */
2514 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardReadImageAsync;
2515
2516 /* Read the data that goes before the write to fill the block. */
2517 pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbReadImage; Assert(cbReadImage == (uint32_t)cbReadImage);
2518 pIoCtx->Req.Io.cbTransfer = pIoCtx->Req.Io.cbTransferLeft;
2519 pIoCtx->Req.Io.uOffset += cbWriteCopy;
2520 }
2521 else
2522 {
2523 /* Zero out the remainder of this block. Will never be visible, as this
2524 * is beyond the limit of the image. */
2525 if (cbFill)
2526 vdIoCtxSet(pIoCtx, '\0', cbFill);
2527
2528 /* Write the full block to the virtual disk. */
2529 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
2530 vdIoCtxChildReset(pIoCtx);
2531 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
2532 }
2533 }
2534 else
2535 {
2536 /* Write the full block to the virtual disk. */
2537 RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
2538 vdIoCtxChildReset(pIoCtx);
2539 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
2540 }
2541
2542 return rc;
2543}
2544
2545static DECLCALLBACK(int) vdWriteHelperStandardPreReadAsync(PVDIOCTX pIoCtx)
2546{
2547 int rc = VINF_SUCCESS;
2548
2549 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2550
2551 pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
2552
2553 if ( pIoCtx->Req.Io.cbTransferLeft
2554 && !pIoCtx->cDataTransfersPending)
2555 rc = vdReadHelperAsync(pIoCtx);
2556
2557 if ( RT_SUCCESS(rc)
2558 && ( pIoCtx->Req.Io.cbTransferLeft
2559 || pIoCtx->cMetaTransfersPending))
2560 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
2561 else
2562 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardAssemble;
2563
2564 return rc;
2565}
2566
2567static DECLCALLBACK(int) vdWriteHelperStandardAsync(PVDIOCTX pIoCtx)
2568{
2569 PVDISK pDisk = pIoCtx->pDisk;
2570 uint64_t uOffset = pIoCtx->Type.Child.uOffsetSaved;
2571 size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
2572 size_t cbPreRead = pIoCtx->Type.Child.cbPreRead;
2573 size_t cbPostRead = pIoCtx->Type.Child.cbPostRead;
2574 size_t cbWrite = pIoCtx->Type.Child.cbWriteParent;
2575 size_t cbFill = 0;
2576 size_t cbWriteCopy = 0;
2577 size_t cbReadImage = 0;
2578
2579 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2580
2581 AssertPtr(pIoCtx->pIoCtxParent);
2582 Assert(!pIoCtx->pIoCtxParent->pIoCtxParent);
2583
2584 /* Calculate the amount of data to read that goes after the write to fill the block. */
2585 if (cbPostRead)
2586 {
2587 /* If we have data to be written, use that instead of reading
2588 * data from the image. */
2589 if (cbWrite > cbThisWrite)
2590 cbWriteCopy = RT_MIN(cbWrite - cbThisWrite, cbPostRead);
2591 else
2592 cbWriteCopy = 0;
2593
2594 /* Figure out how much we cannot read from the image, because
2595 * the last block to write might exceed the nominal size of the
2596 * image for technical reasons. */
2597 if (uOffset + cbThisWrite + cbPostRead > pDisk->cbSize)
2598 cbFill = uOffset + cbThisWrite + cbPostRead - pDisk->cbSize;
2599
2600 /* The rest must be read from the image. */
2601 cbReadImage = cbPostRead - cbWriteCopy - cbFill;
2602 }
2603
2604 pIoCtx->Type.Child.Write.Optimized.cbFill = cbFill;
2605 pIoCtx->Type.Child.Write.Optimized.cbWriteCopy = cbWriteCopy;
2606 pIoCtx->Type.Child.Write.Optimized.cbReadImage = cbReadImage;
2607
2608 /* Next step */
2609 if (cbPreRead)
2610 {
2611 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardPreReadAsync;
2612
2613 /* Read the data that goes before the write to fill the block. */
2614 pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbPreRead; Assert(cbPreRead == (uint32_t)cbPreRead);
2615 pIoCtx->Req.Io.cbTransfer = pIoCtx->Req.Io.cbTransferLeft;
2616 pIoCtx->Req.Io.uOffset -= cbPreRead;
2617 }
2618 else
2619 pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardAssemble;
2620
2621 return VINF_SUCCESS;
2622}
2623
2624/**
2625 * internal: write buffer to the image, taking care of block boundaries and
2626 * write optimizations - async version.
2627 */
2628static DECLCALLBACK(int) vdWriteHelperAsync(PVDIOCTX pIoCtx)
2629{
2630 int rc;
2631 size_t cbWrite = pIoCtx->Req.Io.cbTransfer;
2632 uint64_t uOffset = pIoCtx->Req.Io.uOffset;
2633 PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
2634 PVDISK pDisk = pIoCtx->pDisk;
2635 unsigned fWrite;
2636 size_t cbThisWrite;
2637 size_t cbPreRead, cbPostRead;
2638
2639 /* Apply write filter chain here if it was not done already. */
2640 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_WRITE_FILTER_APPLIED))
2641 {
2642 rc = vdFilterChainApplyWrite(pDisk, uOffset, cbWrite, pIoCtx);
2643 if (RT_FAILURE(rc))
2644 return rc;
2645 pIoCtx->fFlags |= VDIOCTX_FLAGS_WRITE_FILTER_APPLIED;
2646 }
2647
2648 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_DONT_SET_MODIFIED_FLAG))
2649 {
2650 rc = vdSetModifiedFlagAsync(pDisk, pIoCtx);
2651 if (RT_FAILURE(rc)) /* Includes I/O in progress. */
2652 return rc;
2653 }
2654
2655 rc = vdDiscardSetRangeAllocated(pDisk, uOffset, cbWrite);
2656 if (RT_FAILURE(rc))
2657 return rc;
2658
2659 /* Loop until all written. */
2660 do
2661 {
2662 /* Try to write the possibly partial block to the last opened image.
2663 * This works when the block is already allocated in this image or
2664 * if it is a full-block write (and allocation isn't suppressed below).
2665 * For image formats which don't support zero blocks, it's beneficial
2666 * to avoid unnecessarily allocating unchanged blocks. This prevents
2667 * unwanted expanding of images. VMDK is an example. */
2668 cbThisWrite = cbWrite;
2669
2670 /*
2671 * Check whether there is a full block write in progress which was not allocated.
2672 * Defer I/O if the range interferes.
2673 */
2674 if ( pDisk->pIoCtxLockOwner != NIL_VDIOCTX
2675 && uOffset >= pDisk->uOffsetStartLocked
2676 && uOffset < pDisk->uOffsetEndLocked)
2677 {
2678 Log(("Interferring write while allocating a new block => deferring write\n"));
2679 vdIoCtxDefer(pDisk, pIoCtx);
2680 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
2681 break;
2682 }
2683
2684 fWrite = (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
2685 ? 0 : VD_WRITE_NO_ALLOC;
2686 rc = pImage->Backend->pfnWrite(pImage->pBackendData, uOffset, cbThisWrite,
2687 pIoCtx, &cbThisWrite, &cbPreRead, &cbPostRead,
2688 fWrite);
2689 if (rc == VERR_VD_BLOCK_FREE)
2690 {
2691 /* Lock the disk .*/
2692 rc = vdIoCtxLockDisk(pDisk, pIoCtx);
2693 if (RT_SUCCESS(rc))
2694 {
2695 /*
2696 * Allocate segment and buffer in one go.
2697 * A bit hackish but avoids the need to allocate memory twice.
2698 */
2699 PRTSGBUF pTmp = (PRTSGBUF)RTMemAlloc(cbPreRead + cbThisWrite + cbPostRead + sizeof(RTSGSEG) + sizeof(RTSGBUF));
2700 AssertBreakStmt(pTmp, rc = VERR_NO_MEMORY);
2701 PRTSGSEG pSeg = (PRTSGSEG)(pTmp + 1);
2702
2703 pSeg->pvSeg = pSeg + 1;
2704 pSeg->cbSeg = cbPreRead + cbThisWrite + cbPostRead;
2705 RTSgBufInit(pTmp, pSeg, 1);
2706
2707 PVDIOCTX pIoCtxWrite = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_WRITE,
2708 uOffset, pSeg->cbSeg, pImage,
2709 pTmp,
2710 pIoCtx, cbThisWrite,
2711 cbWrite,
2712 pTmp,
2713 (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
2714 ? vdWriteHelperStandardAsync
2715 : vdWriteHelperOptimizedAsync);
2716 if (!VALID_PTR(pIoCtxWrite))
2717 {
2718 RTMemTmpFree(pTmp);
2719 rc = VERR_NO_MEMORY;
2720 break;
2721 }
2722
2723 LogFlowFunc(("Disk is growing because of pIoCtx=%#p pIoCtxWrite=%#p\n",
2724 pIoCtx, pIoCtxWrite));
2725
2726 /* Save the current range for the growing operation to check for intersecting requests later. */
2727 pDisk->uOffsetStartLocked = uOffset - cbPreRead;
2728 pDisk->uOffsetEndLocked = uOffset + cbThisWrite + cbPostRead;
2729
2730 pIoCtxWrite->Type.Child.cbPreRead = cbPreRead;
2731 pIoCtxWrite->Type.Child.cbPostRead = cbPostRead;
2732 pIoCtxWrite->Req.Io.pImageParentOverride = pIoCtx->Req.Io.pImageParentOverride;
2733
2734 /* Process the write request */
2735 rc = vdIoCtxProcessLocked(pIoCtxWrite);
2736
2737 if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
2738 {
2739 vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs*/ );
2740 vdIoCtxFree(pDisk, pIoCtxWrite);
2741 break;
2742 }
2743 else if ( rc == VINF_VD_ASYNC_IO_FINISHED
2744 && ASMAtomicCmpXchgBool(&pIoCtxWrite->fComplete, true, false))
2745 {
2746 LogFlow(("Child write request completed\n"));
2747 Assert(pIoCtx->Req.Io.cbTransferLeft >= cbThisWrite);
2748 Assert(cbThisWrite == (uint32_t)cbThisWrite);
2749 rc = pIoCtxWrite->rcReq;
2750 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbThisWrite);
2751 vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs*/ );
2752 vdIoCtxFree(pDisk, pIoCtxWrite);
2753 }
2754 else
2755 {
2756 LogFlow(("Child write pending\n"));
2757 ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
2758 pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
2759 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
2760 cbWrite -= cbThisWrite;
2761 uOffset += cbThisWrite;
2762 break;
2763 }
2764 }
2765 else
2766 {
2767 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
2768 break;
2769 }
2770 }
2771
2772 if (rc == VERR_VD_IOCTX_HALT)
2773 {
2774 cbWrite -= cbThisWrite;
2775 uOffset += cbThisWrite;
2776 pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
2777 break;
2778 }
2779 else if (rc == VERR_VD_NOT_ENOUGH_METADATA)
2780 break;
2781
2782 cbWrite -= cbThisWrite;
2783 uOffset += cbThisWrite;
2784 } while (cbWrite != 0 && (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS));
2785
2786 if ( rc == VERR_VD_ASYNC_IO_IN_PROGRESS
2787 || rc == VERR_VD_NOT_ENOUGH_METADATA
2788 || rc == VERR_VD_IOCTX_HALT)
2789 {
2790 /*
2791 * Tell the caller that we don't need to go back here because all
2792 * writes are initiated.
2793 */
2794 if ( !cbWrite
2795 && rc != VERR_VD_IOCTX_HALT)
2796 rc = VINF_SUCCESS;
2797
2798 pIoCtx->Req.Io.uOffset = uOffset;
2799 pIoCtx->Req.Io.cbTransfer = cbWrite;
2800 }
2801
2802 return rc;
2803}
2804
2805/**
2806 * Flush helper async version.
2807 */
2808static DECLCALLBACK(int) vdFlushHelperAsync(PVDIOCTX pIoCtx)
2809{
2810 int rc = VINF_SUCCESS;
2811 PVDISK pDisk = pIoCtx->pDisk;
2812 PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
2813
2814 rc = vdIoCtxLockDisk(pDisk, pIoCtx);
2815 if (RT_SUCCESS(rc))
2816 {
2817 /* Mark the whole disk as locked. */
2818 pDisk->uOffsetStartLocked = 0;
2819 pDisk->uOffsetEndLocked = UINT64_C(0xffffffffffffffff);
2820
2821 vdResetModifiedFlag(pDisk);
2822 rc = pImage->Backend->pfnFlush(pImage->pBackendData, pIoCtx);
2823 if ( ( RT_SUCCESS(rc)
2824 || rc == VERR_VD_ASYNC_IO_IN_PROGRESS
2825 || rc == VERR_VD_IOCTX_HALT)
2826 && pDisk->pCache)
2827 {
2828 rc = pDisk->pCache->Backend->pfnFlush(pDisk->pCache->pBackendData, pIoCtx);
2829 if ( RT_SUCCESS(rc)
2830 || ( rc != VERR_VD_ASYNC_IO_IN_PROGRESS
2831 && rc != VERR_VD_IOCTX_HALT))
2832 vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessBlockedReqs */);
2833 else if (rc != VERR_VD_IOCTX_HALT)
2834 rc = VINF_SUCCESS;
2835 }
2836 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
2837 rc = VINF_SUCCESS;
2838 else if (rc != VERR_VD_IOCTX_HALT)/* Some other error. */
2839 vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessBlockedReqs */);
2840 }
2841
2842 return rc;
2843}
2844
2845/**
2846 * Async discard helper - discards a whole block which is recorded in the block
2847 * tree.
2848 *
2849 * @returns VBox status code.
2850 * @param pIoCtx The I/O context to operate on.
2851 */
2852static DECLCALLBACK(int) vdDiscardWholeBlockAsync(PVDIOCTX pIoCtx)
2853{
2854 int rc = VINF_SUCCESS;
2855 PVDISK pDisk = pIoCtx->pDisk;
2856 PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
2857 PVDDISCARDBLOCK pBlock = pIoCtx->Req.Discard.pBlock;
2858 size_t cbPreAllocated, cbPostAllocated, cbActuallyDiscarded;
2859
2860 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
2861
2862 AssertPtr(pBlock);
2863
2864 rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData, pIoCtx,
2865 pBlock->Core.Key, pBlock->cbDiscard,
2866 &cbPreAllocated, &cbPostAllocated,
2867 &cbActuallyDiscarded, NULL, 0);
2868 Assert(rc != VERR_VD_DISCARD_ALIGNMENT_NOT_MET);
2869 Assert(!cbPreAllocated);
2870 Assert(!cbPostAllocated);
2871 Assert(cbActuallyDiscarded == pBlock->cbDiscard || RT_FAILURE(rc));
2872
2873 /* Remove the block on success. */
2874 if ( RT_SUCCESS(rc)
2875 || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
2876 {
2877 PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
2878 Assert(pBlockRemove == pBlock); RT_NOREF1(pBlockRemove);
2879
2880 pDiscard->cbDiscarding -= pBlock->cbDiscard;
2881 RTListNodeRemove(&pBlock->NodeLru);
2882 RTMemFree(pBlock->pbmAllocated);
2883 RTMemFree(pBlock);
2884 pIoCtx->Req.Discard.pBlock = NULL;/* Safety precaution. */
2885 pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync; /* Next part. */
2886 rc = VINF_SUCCESS;
2887 }
2888
2889 LogFlowFunc(("returns rc=%Rrc\n", rc));
2890 return rc;
2891}
2892
2893/**
2894 * Removes the least recently used blocks from the waiting list until
2895 * the new value is reached - version for async I/O.
2896 *
2897 * @returns VBox status code.
2898 * @param pDisk VD disk container.
2899 * @param pIoCtx The I/O context associated with this discard operation.
2900 * @param cbDiscardingNew How many bytes should be waiting on success.
2901 * The number of bytes waiting can be less.
2902 */
2903static int vdDiscardRemoveBlocksAsync(PVDISK pDisk, PVDIOCTX pIoCtx, size_t cbDiscardingNew)
2904{
2905 int rc = VINF_SUCCESS;
2906 PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
2907
2908 LogFlowFunc(("pDisk=%#p pDiscard=%#p cbDiscardingNew=%zu\n",
2909 pDisk, pDiscard, cbDiscardingNew));
2910
2911 while (pDiscard->cbDiscarding > cbDiscardingNew)
2912 {
2913 PVDDISCARDBLOCK pBlock = RTListGetLast(&pDiscard->ListLru, VDDISCARDBLOCK, NodeLru);
2914
2915 Assert(!RTListIsEmpty(&pDiscard->ListLru));
2916
2917 /* Go over the allocation bitmap and mark all discarded sectors as unused. */
2918 uint64_t offStart = pBlock->Core.Key;
2919 uint32_t idxStart = 0;
2920 size_t cbLeft = pBlock->cbDiscard;
2921 bool fAllocated = ASMBitTest(pBlock->pbmAllocated, idxStart);
2922 uint32_t cSectors = (uint32_t)(pBlock->cbDiscard / 512);
2923
2924 while (cbLeft > 0)
2925 {
2926 int32_t idxEnd;
2927 size_t cbThis = cbLeft;
2928
2929 if (fAllocated)
2930 {
2931 /* Check for the first unallocated bit. */
2932 idxEnd = ASMBitNextClear(pBlock->pbmAllocated, cSectors, idxStart);
2933 if (idxEnd != -1)
2934 {
2935 cbThis = (idxEnd - idxStart) * 512;
2936 fAllocated = false;
2937 }
2938 }
2939 else
2940 {
2941 /* Mark as unused and check for the first set bit. */
2942 idxEnd = ASMBitNextSet(pBlock->pbmAllocated, cSectors, idxStart);
2943 if (idxEnd != -1)
2944 cbThis = (idxEnd - idxStart) * 512;
2945
2946 rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData, pIoCtx,
2947 offStart, cbThis, NULL, NULL, &cbThis,
2948 NULL, VD_DISCARD_MARK_UNUSED);
2949 if ( RT_FAILURE(rc)
2950 && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
2951 break;
2952
2953 fAllocated = true;
2954 }
2955
2956 idxStart = idxEnd;
2957 offStart += cbThis;
2958 cbLeft -= cbThis;
2959 }
2960
2961 if ( RT_FAILURE(rc)
2962 && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
2963 break;
2964
2965 PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
2966 Assert(pBlockRemove == pBlock); NOREF(pBlockRemove);
2967 RTListNodeRemove(&pBlock->NodeLru);
2968
2969 pDiscard->cbDiscarding -= pBlock->cbDiscard;
2970 RTMemFree(pBlock->pbmAllocated);
2971 RTMemFree(pBlock);
2972 }
2973
2974 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
2975 rc = VINF_SUCCESS;
2976
2977 Assert(RT_FAILURE(rc) || pDiscard->cbDiscarding <= cbDiscardingNew);
2978
2979 LogFlowFunc(("returns rc=%Rrc\n", rc));
2980 return rc;
2981}
2982
2983/**
2984 * Async discard helper - discards the current range if there is no matching
2985 * block in the tree.
2986 *
2987 * @returns VBox status code.
2988 * @param pIoCtx The I/O context to operate on.
2989 */
2990static DECLCALLBACK(int) vdDiscardCurrentRangeAsync(PVDIOCTX pIoCtx)
2991{
2992 PVDISK pDisk = pIoCtx->pDisk;
2993 PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
2994 uint64_t offStart = pIoCtx->Req.Discard.offCur;
2995 size_t cbThisDiscard = pIoCtx->Req.Discard.cbThisDiscard;
2996 void *pbmAllocated = NULL;
2997 size_t cbPreAllocated, cbPostAllocated;
2998 int rc = VINF_SUCCESS;
2999
3000 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
3001
3002 /* No block found, try to discard using the backend first. */
3003 rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData, pIoCtx,
3004 offStart, cbThisDiscard, &cbPreAllocated,
3005 &cbPostAllocated, &cbThisDiscard,
3006 &pbmAllocated, 0);
3007 if (rc == VERR_VD_DISCARD_ALIGNMENT_NOT_MET)
3008 {
3009 /* Create new discard block. */
3010 PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTMemAllocZ(sizeof(VDDISCARDBLOCK));
3011 if (pBlock)
3012 {
3013 pBlock->Core.Key = offStart - cbPreAllocated;
3014 pBlock->Core.KeyLast = offStart + cbThisDiscard + cbPostAllocated - 1;
3015 pBlock->cbDiscard = cbPreAllocated + cbThisDiscard + cbPostAllocated;
3016 pBlock->pbmAllocated = pbmAllocated;
3017 bool fInserted = RTAvlrU64Insert(pDiscard->pTreeBlocks, &pBlock->Core);
3018 Assert(fInserted); NOREF(fInserted);
3019
3020 RTListPrepend(&pDiscard->ListLru, &pBlock->NodeLru);
3021 pDiscard->cbDiscarding += pBlock->cbDiscard;
3022
3023 Assert(pIoCtx->Req.Discard.cbDiscardLeft >= cbThisDiscard);
3024 pIoCtx->Req.Discard.cbDiscardLeft -= cbThisDiscard;
3025 pIoCtx->Req.Discard.offCur += cbThisDiscard;
3026 pIoCtx->Req.Discard.cbThisDiscard = cbThisDiscard;
3027
3028 if (pDiscard->cbDiscarding > VD_DISCARD_REMOVE_THRESHOLD)
3029 rc = vdDiscardRemoveBlocksAsync(pDisk, pIoCtx, VD_DISCARD_REMOVE_THRESHOLD);
3030 else
3031 rc = VINF_SUCCESS;
3032
3033 if (RT_SUCCESS(rc))
3034 pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync; /* Next part. */
3035 }
3036 else
3037 {
3038 RTMemFree(pbmAllocated);
3039 rc = VERR_NO_MEMORY;
3040 }
3041 }
3042 else if ( RT_SUCCESS(rc)
3043 || rc == VERR_VD_ASYNC_IO_IN_PROGRESS) /* Save state and andvance to next range. */
3044 {
3045 Assert(pIoCtx->Req.Discard.cbDiscardLeft >= cbThisDiscard);
3046 pIoCtx->Req.Discard.cbDiscardLeft -= cbThisDiscard;
3047 pIoCtx->Req.Discard.offCur += cbThisDiscard;
3048 pIoCtx->Req.Discard.cbThisDiscard = cbThisDiscard;
3049 pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync;
3050 rc = VINF_SUCCESS;
3051 }
3052
3053 LogFlowFunc(("returns rc=%Rrc\n", rc));
3054 return rc;
3055}
3056
3057/**
3058 * Async discard helper - entry point.
3059 *
3060 * @returns VBox status code.
3061 * @param pIoCtx The I/O context to operate on.
3062 */
3063static DECLCALLBACK(int) vdDiscardHelperAsync(PVDIOCTX pIoCtx)
3064{
3065 int rc = VINF_SUCCESS;
3066 PVDISK pDisk = pIoCtx->pDisk;
3067 PCRTRANGE paRanges = pIoCtx->Req.Discard.paRanges;
3068 unsigned cRanges = pIoCtx->Req.Discard.cRanges;
3069 PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
3070
3071 LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
3072
3073 /* Check if the I/O context processed all ranges. */
3074 if ( pIoCtx->Req.Discard.idxRange == cRanges
3075 && !pIoCtx->Req.Discard.cbDiscardLeft)
3076 {
3077 LogFlowFunc(("All ranges discarded, completing\n"));
3078 vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessDeferredReqs*/);
3079 return VINF_SUCCESS;
3080 }
3081
3082 if (pDisk->pIoCtxLockOwner != pIoCtx)
3083 rc = vdIoCtxLockDisk(pDisk, pIoCtx);
3084
3085 if (RT_SUCCESS(rc))
3086 {
3087 uint64_t offStart = pIoCtx->Req.Discard.offCur;
3088 size_t cbDiscardLeft = pIoCtx->Req.Discard.cbDiscardLeft;
3089 size_t cbThisDiscard;
3090
3091 pDisk->uOffsetStartLocked = offStart;
3092 pDisk->uOffsetEndLocked = offStart + cbDiscardLeft;
3093
3094 if (RT_UNLIKELY(!pDiscard))
3095 {
3096 pDiscard = vdDiscardStateCreate();
3097 if (!pDiscard)
3098 return VERR_NO_MEMORY;
3099
3100 pDisk->pDiscard = pDiscard;
3101 }
3102
3103 if (!pIoCtx->Req.Discard.cbDiscardLeft)
3104 {
3105 offStart = paRanges[pIoCtx->Req.Discard.idxRange].offStart;
3106 cbDiscardLeft = paRanges[pIoCtx->Req.Discard.idxRange].cbRange;
3107 LogFlowFunc(("New range descriptor loaded (%u) offStart=%llu cbDiscard=%zu\n",
3108 pIoCtx->Req.Discard.idxRange, offStart, cbDiscardLeft));
3109 pIoCtx->Req.Discard.idxRange++;
3110 }
3111
3112 /* Look for a matching block in the AVL tree first. */
3113 PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, offStart, false);
3114 if (!pBlock || pBlock->Core.KeyLast < offStart)
3115 {
3116 PVDDISCARDBLOCK pBlockAbove = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, offStart, true);
3117
3118 /* Clip range to remain in the current block. */
3119 if (pBlockAbove)
3120 cbThisDiscard = RT_MIN(cbDiscardLeft, pBlockAbove->Core.KeyLast - offStart + 1);
3121 else
3122 cbThisDiscard = cbDiscardLeft;
3123
3124 Assert(!(cbThisDiscard % 512));
3125 pIoCtx->Req.Discard.pBlock = NULL;
3126 pIoCtx->pfnIoCtxTransferNext = vdDiscardCurrentRangeAsync;
3127 }
3128 else
3129 {
3130 /* Range lies partly in the block, update allocation bitmap. */
3131 int32_t idxStart, idxEnd;
3132
3133 cbThisDiscard = RT_MIN(cbDiscardLeft, pBlock->Core.KeyLast - offStart + 1);
3134
3135 AssertPtr(pBlock);
3136
3137 Assert(!(cbThisDiscard % 512));
3138 Assert(!((offStart - pBlock->Core.Key) % 512));
3139
3140 idxStart = (offStart - pBlock->Core.Key) / 512;
3141 idxEnd = idxStart + (int32_t)(cbThisDiscard / 512);
3142
3143 ASMBitClearRange(pBlock->pbmAllocated, idxStart, idxEnd);
3144
3145 cbDiscardLeft -= cbThisDiscard;
3146 offStart += cbThisDiscard;
3147
3148 /* Call the backend to discard the block if it is completely unallocated now. */
3149 if (ASMBitFirstSet((volatile void *)pBlock->pbmAllocated, (uint32_t)(pBlock->cbDiscard / 512)) == -1)
3150 {
3151 pIoCtx->Req.Discard.pBlock = pBlock;
3152 pIoCtx->pfnIoCtxTransferNext = vdDiscardWholeBlockAsync;
3153 rc = VINF_SUCCESS;
3154 }
3155 else
3156 {
3157 RTListNodeRemove(&pBlock->NodeLru);
3158 RTListPrepend(&pDiscard->ListLru, &pBlock->NodeLru);
3159
3160 /* Start with next range. */
3161 pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync;
3162 rc = VINF_SUCCESS;
3163 }
3164 }
3165
3166 /* Save state in the context. */
3167 pIoCtx->Req.Discard.offCur = offStart;
3168 pIoCtx->Req.Discard.cbDiscardLeft = cbDiscardLeft;
3169 pIoCtx->Req.Discard.cbThisDiscard = cbThisDiscard;
3170 }
3171
3172 LogFlowFunc(("returns rc=%Rrc\n", rc));
3173 return rc;
3174}
3175
3176/**
3177 * VD async I/O interface open callback.
3178 */
3179static DECLCALLBACK(int) vdIOOpenFallback(void *pvUser, const char *pszLocation,
3180 uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
3181 void **ppStorage)
3182{
3183 RT_NOREF1(pvUser);
3184 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)RTMemAllocZ(sizeof(VDIIOFALLBACKSTORAGE));
3185
3186 if (!pStorage)
3187 return VERR_NO_MEMORY;
3188
3189 pStorage->pfnCompleted = pfnCompleted;
3190
3191 /* Open the file. */
3192 int rc = RTFileOpen(&pStorage->File, pszLocation, fOpen);
3193 if (RT_SUCCESS(rc))
3194 {
3195 *ppStorage = pStorage;
3196 return VINF_SUCCESS;
3197 }
3198
3199 RTMemFree(pStorage);
3200 return rc;
3201}
3202
3203/**
3204 * VD async I/O interface close callback.
3205 */
3206static DECLCALLBACK(int) vdIOCloseFallback(void *pvUser, void *pvStorage)
3207{
3208 RT_NOREF1(pvUser);
3209 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3210
3211 RTFileClose(pStorage->File);
3212 RTMemFree(pStorage);
3213 return VINF_SUCCESS;
3214}
3215
3216static DECLCALLBACK(int) vdIODeleteFallback(void *pvUser, const char *pcszFilename)
3217{
3218 RT_NOREF1(pvUser);
3219 return RTFileDelete(pcszFilename);
3220}
3221
3222static DECLCALLBACK(int) vdIOMoveFallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
3223{
3224 RT_NOREF1(pvUser);
3225 return RTFileMove(pcszSrc, pcszDst, fMove);
3226}
3227
3228static DECLCALLBACK(int) vdIOGetFreeSpaceFallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
3229{
3230 RT_NOREF1(pvUser);
3231 return RTFsQuerySizes(pcszFilename, NULL, pcbFreeSpace, NULL, NULL);
3232}
3233
3234static DECLCALLBACK(int) vdIOGetModificationTimeFallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
3235{
3236 RT_NOREF1(pvUser);
3237 RTFSOBJINFO info;
3238 int rc = RTPathQueryInfo(pcszFilename, &info, RTFSOBJATTRADD_NOTHING);
3239 if (RT_SUCCESS(rc))
3240 *pModificationTime = info.ModificationTime;
3241 return rc;
3242}
3243
3244/**
3245 * VD async I/O interface callback for retrieving the file size.
3246 */
3247static DECLCALLBACK(int) vdIOGetSizeFallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
3248{
3249 RT_NOREF1(pvUser);
3250 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3251
3252 return RTFileQuerySize(pStorage->File, pcbSize);
3253}
3254
3255/**
3256 * VD async I/O interface callback for setting the file size.
3257 */
3258static DECLCALLBACK(int) vdIOSetSizeFallback(void *pvUser, void *pvStorage, uint64_t cbSize)
3259{
3260 RT_NOREF1(pvUser);
3261 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3262
3263 return RTFileSetSize(pStorage->File, cbSize);
3264}
3265
3266/**
3267 * VD async I/O interface callback for setting the file allocation size.
3268 */
3269static DECLCALLBACK(int) vdIOSetAllocationSizeFallback(void *pvUser, void *pvStorage, uint64_t cbSize,
3270 uint32_t fFlags)
3271{
3272 RT_NOREF2(pvUser, fFlags);
3273 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3274
3275 return RTFileSetAllocationSize(pStorage->File, cbSize, RTFILE_ALLOC_SIZE_F_DEFAULT);
3276}
3277
3278/**
3279 * VD async I/O interface callback for a synchronous write to the file.
3280 */
3281static DECLCALLBACK(int) vdIOWriteSyncFallback(void *pvUser, void *pvStorage, uint64_t uOffset,
3282 const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
3283{
3284 RT_NOREF1(pvUser);
3285 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3286
3287 return RTFileWriteAt(pStorage->File, uOffset, pvBuf, cbWrite, pcbWritten);
3288}
3289
3290/**
3291 * VD async I/O interface callback for a synchronous read from the file.
3292 */
3293static DECLCALLBACK(int) vdIOReadSyncFallback(void *pvUser, void *pvStorage, uint64_t uOffset,
3294 void *pvBuf, size_t cbRead, size_t *pcbRead)
3295{
3296 RT_NOREF1(pvUser);
3297 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3298
3299 return RTFileReadAt(pStorage->File, uOffset, pvBuf, cbRead, pcbRead);
3300}
3301
3302/**
3303 * VD async I/O interface callback for a synchronous flush of the file data.
3304 */
3305static DECLCALLBACK(int) vdIOFlushSyncFallback(void *pvUser, void *pvStorage)
3306{
3307 RT_NOREF1(pvUser);
3308 PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
3309
3310 return RTFileFlush(pStorage->File);
3311}
3312
3313/**
3314 * VD async I/O interface callback for a asynchronous read from the file.
3315 */
3316static DECLCALLBACK(int) vdIOReadAsyncFallback(void *pvUser, void *pStorage, uint64_t uOffset,
3317 PCRTSGSEG paSegments, size_t cSegments,
3318 size_t cbRead, void *pvCompletion,
3319 void **ppTask)
3320{
3321 RT_NOREF8(pvUser, pStorage, uOffset, paSegments, cSegments, cbRead, pvCompletion, ppTask);
3322 AssertFailed();
3323 return VERR_NOT_IMPLEMENTED;
3324}
3325
3326/**
3327 * VD async I/O interface callback for a asynchronous write to the file.
3328 */
3329static DECLCALLBACK(int) vdIOWriteAsyncFallback(void *pvUser, void *pStorage, uint64_t uOffset,
3330 PCRTSGSEG paSegments, size_t cSegments,
3331 size_t cbWrite, void *pvCompletion,
3332 void **ppTask)
3333{
3334 RT_NOREF8(pvUser, pStorage, uOffset, paSegments, cSegments, cbWrite, pvCompletion, ppTask);
3335 AssertFailed();
3336 return VERR_NOT_IMPLEMENTED;
3337}
3338
3339/**
3340 * VD async I/O interface callback for a asynchronous flush of the file data.
3341 */
3342static DECLCALLBACK(int) vdIOFlushAsyncFallback(void *pvUser, void *pStorage,
3343 void *pvCompletion, void **ppTask)
3344{
3345 RT_NOREF4(pvUser, pStorage, pvCompletion, ppTask);
3346 AssertFailed();
3347 return VERR_NOT_IMPLEMENTED;
3348}
3349
3350/**
3351 * Internal - Continues an I/O context after
3352 * it was halted because of an active transfer.
3353 */
3354static int vdIoCtxContinue(PVDIOCTX pIoCtx, int rcReq)
3355{
3356 PVDISK pDisk = pIoCtx->pDisk;
3357 int rc = VINF_SUCCESS;
3358
3359 VD_IS_LOCKED(pDisk);
3360
3361 if (RT_FAILURE(rcReq))
3362 ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rcReq, VINF_SUCCESS);
3363
3364 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
3365 {
3366 /* Continue the transfer */
3367 rc = vdIoCtxProcessLocked(pIoCtx);
3368
3369 if ( rc == VINF_VD_ASYNC_IO_FINISHED
3370 && ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
3371 {
3372 LogFlowFunc(("I/O context completed pIoCtx=%#p\n", pIoCtx));
3373 bool fFreeCtx = RT_BOOL(!(pIoCtx->fFlags & VDIOCTX_FLAGS_DONT_FREE));
3374 if (pIoCtx->pIoCtxParent)
3375 {
3376 PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
3377
3378 Assert(!pIoCtxParent->pIoCtxParent);
3379 if (RT_FAILURE(pIoCtx->rcReq))
3380 ASMAtomicCmpXchgS32(&pIoCtxParent->rcReq, pIoCtx->rcReq, VINF_SUCCESS);
3381
3382 ASMAtomicDecU32(&pIoCtxParent->cDataTransfersPending);
3383
3384 if (pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE)
3385 {
3386 LogFlowFunc(("I/O context transferred %u bytes for the parent pIoCtxParent=%p\n",
3387 pIoCtx->Type.Child.cbTransferParent, pIoCtxParent));
3388
3389 /* Update the parent state. */
3390 Assert(pIoCtxParent->Req.Io.cbTransferLeft >= pIoCtx->Type.Child.cbTransferParent);
3391 ASMAtomicSubU32(&pIoCtxParent->Req.Io.cbTransferLeft, (uint32_t)pIoCtx->Type.Child.cbTransferParent);
3392 }
3393 else
3394 Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_FLUSH);
3395
3396 /*
3397 * A completed child write means that we finished growing the image.
3398 * We have to process any pending writes now.
3399 */
3400 vdIoCtxUnlockDisk(pDisk, pIoCtxParent, false /* fProcessDeferredReqs */);
3401
3402 /* Unblock the parent */
3403 pIoCtxParent->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
3404
3405 rc = vdIoCtxProcessLocked(pIoCtxParent);
3406
3407 if ( rc == VINF_VD_ASYNC_IO_FINISHED
3408 && ASMAtomicCmpXchgBool(&pIoCtxParent->fComplete, true, false))
3409 {
3410 LogFlowFunc(("Parent I/O context completed pIoCtxParent=%#p rcReq=%Rrc\n", pIoCtxParent, pIoCtxParent->rcReq));
3411 bool fFreeParentCtx = RT_BOOL(!(pIoCtxParent->fFlags & VDIOCTX_FLAGS_DONT_FREE));
3412 vdIoCtxRootComplete(pDisk, pIoCtxParent);
3413 vdThreadFinishWrite(pDisk);
3414
3415 if (fFreeParentCtx)
3416 vdIoCtxFree(pDisk, pIoCtxParent);
3417 vdDiskProcessBlockedIoCtx(pDisk);
3418 }
3419 else if (!vdIoCtxIsDiskLockOwner(pDisk, pIoCtx))
3420 {
3421 /* Process any pending writes if the current request didn't caused another growing. */
3422 vdDiskProcessBlockedIoCtx(pDisk);
3423 }
3424 }
3425 else
3426 {
3427 if (pIoCtx->enmTxDir == VDIOCTXTXDIR_FLUSH)
3428 {
3429 vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessDerredReqs */);
3430 vdThreadFinishWrite(pDisk);
3431 }
3432 else if ( pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE
3433 || pIoCtx->enmTxDir == VDIOCTXTXDIR_DISCARD)
3434 vdThreadFinishWrite(pDisk);
3435 else
3436 {
3437 Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_READ);
3438 vdThreadFinishRead(pDisk);
3439 }
3440
3441 LogFlowFunc(("I/O context completed pIoCtx=%#p rcReq=%Rrc\n", pIoCtx, pIoCtx->rcReq));
3442 vdIoCtxRootComplete(pDisk, pIoCtx);
3443 }
3444
3445 if (fFreeCtx)
3446 vdIoCtxFree(pDisk, pIoCtx);
3447 }
3448 }
3449
3450 return VINF_SUCCESS;
3451}
3452
3453/**
3454 * Internal - Called when user transfer completed.
3455 */
3456static int vdUserXferCompleted(PVDIOSTORAGE pIoStorage, PVDIOCTX pIoCtx,
3457 PFNVDXFERCOMPLETED pfnComplete, void *pvUser,
3458 size_t cbTransfer, int rcReq)
3459{
3460 int rc = VINF_SUCCESS;
3461 PVDISK pDisk = pIoCtx->pDisk;
3462
3463 LogFlowFunc(("pIoStorage=%#p pIoCtx=%#p pfnComplete=%#p pvUser=%#p cbTransfer=%zu rcReq=%Rrc\n",
3464 pIoStorage, pIoCtx, pfnComplete, pvUser, cbTransfer, rcReq));
3465
3466 VD_IS_LOCKED(pDisk);
3467
3468 Assert(pIoCtx->Req.Io.cbTransferLeft >= cbTransfer);
3469 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbTransfer); Assert(cbTransfer == (uint32_t)cbTransfer);
3470 ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
3471
3472 if (pfnComplete)
3473 rc = pfnComplete(pIoStorage->pVDIo->pBackendData, pIoCtx, pvUser, rcReq);
3474
3475 if (RT_SUCCESS(rc))
3476 rc = vdIoCtxContinue(pIoCtx, rcReq);
3477 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
3478 rc = VINF_SUCCESS;
3479
3480 return rc;
3481}
3482
3483static void vdIoCtxContinueDeferredList(PVDIOSTORAGE pIoStorage, PRTLISTANCHOR pListWaiting,
3484 PFNVDXFERCOMPLETED pfnComplete, void *pvUser, int rcReq)
3485{
3486 LogFlowFunc(("pIoStorage=%#p pListWaiting=%#p pfnComplete=%#p pvUser=%#p rcReq=%Rrc\n",
3487 pIoStorage, pListWaiting, pfnComplete, pvUser, rcReq));
3488
3489 /* Go through the waiting list and continue the I/O contexts. */
3490 while (!RTListIsEmpty(pListWaiting))
3491 {
3492 int rc = VINF_SUCCESS;
3493 PVDIOCTXDEFERRED pDeferred = RTListGetFirst(pListWaiting, VDIOCTXDEFERRED, NodeDeferred);
3494 PVDIOCTX pIoCtx = pDeferred->pIoCtx;
3495 RTListNodeRemove(&pDeferred->NodeDeferred);
3496
3497 RTMemFree(pDeferred);
3498 ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
3499
3500 if (pfnComplete)
3501 rc = pfnComplete(pIoStorage->pVDIo->pBackendData, pIoCtx, pvUser, rcReq);
3502
3503 LogFlow(("Completion callback for I/O context %#p returned %Rrc\n", pIoCtx, rc));
3504
3505 if (RT_SUCCESS(rc))
3506 {
3507 rc = vdIoCtxContinue(pIoCtx, rcReq);
3508 AssertRC(rc);
3509 }
3510 else
3511 Assert(rc == VERR_VD_ASYNC_IO_IN_PROGRESS);
3512 }
3513}
3514
3515/**
3516 * Internal - Called when a meta transfer completed.
3517 */
3518static int vdMetaXferCompleted(PVDIOSTORAGE pIoStorage, PFNVDXFERCOMPLETED pfnComplete, void *pvUser,
3519 PVDMETAXFER pMetaXfer, int rcReq)
3520{
3521 PVDISK pDisk = pIoStorage->pVDIo->pDisk;
3522 RTLISTANCHOR ListIoCtxWaiting;
3523 bool fFlush;
3524
3525 LogFlowFunc(("pIoStorage=%#p pfnComplete=%#p pvUser=%#p pMetaXfer=%#p rcReq=%Rrc\n",
3526 pIoStorage, pfnComplete, pvUser, pMetaXfer, rcReq));
3527
3528 VD_IS_LOCKED(pDisk);
3529
3530 fFlush = VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_FLUSH;
3531
3532 if (!fFlush)
3533 {
3534 RTListMove(&ListIoCtxWaiting, &pMetaXfer->ListIoCtxWaiting);
3535
3536 if (RT_FAILURE(rcReq))
3537 {
3538 /* Remove from the AVL tree. */
3539 LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
3540 bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
3541 Assert(fRemoved); NOREF(fRemoved);
3542 /* If this was a write check if there is a shadow buffer with updated data. */
3543 if (pMetaXfer->pbDataShw)
3544 {
3545 Assert(VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_WRITE);
3546 Assert(!RTListIsEmpty(&pMetaXfer->ListIoCtxShwWrites));
3547 RTListConcatenate(&ListIoCtxWaiting, &pMetaXfer->ListIoCtxShwWrites);
3548 RTMemFree(pMetaXfer->pbDataShw);
3549 pMetaXfer->pbDataShw = NULL;
3550 }
3551 RTMemFree(pMetaXfer);
3552 }
3553 else
3554 {
3555 /* Increase the reference counter to make sure it doesn't go away before the last context is processed. */
3556 pMetaXfer->cRefs++;
3557 }
3558 }
3559 else
3560 RTListMove(&ListIoCtxWaiting, &pMetaXfer->ListIoCtxWaiting);
3561
3562 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
3563 vdIoCtxContinueDeferredList(pIoStorage, &ListIoCtxWaiting, pfnComplete, pvUser, rcReq);
3564
3565 /*
3566 * If there is a shadow buffer and the previous write was successful update with the
3567 * new data and trigger a new write.
3568 */
3569 if ( pMetaXfer->pbDataShw
3570 && RT_SUCCESS(rcReq)
3571 && VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE)
3572 {
3573 LogFlowFunc(("pMetaXfer=%#p Updating from shadow buffer and triggering new write\n", pMetaXfer));
3574 memcpy(pMetaXfer->abData, pMetaXfer->pbDataShw, pMetaXfer->cbMeta);
3575 RTMemFree(pMetaXfer->pbDataShw);
3576 pMetaXfer->pbDataShw = NULL;
3577 Assert(!RTListIsEmpty(&pMetaXfer->ListIoCtxShwWrites));
3578
3579 /* Setup a new I/O write. */
3580 PVDIOTASK pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvUser, pMetaXfer);
3581 if (RT_LIKELY(pIoTask))
3582 {
3583 void *pvTask = NULL;
3584 RTSGSEG Seg;
3585
3586 Seg.cbSeg = pMetaXfer->cbMeta;
3587 Seg.pvSeg = pMetaXfer->abData;
3588
3589 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_WRITE);
3590 rcReq = pIoStorage->pVDIo->pInterfaceIo->pfnWriteAsync(pIoStorage->pVDIo->pInterfaceIo->Core.pvUser,
3591 pIoStorage->pStorage,
3592 pMetaXfer->Core.Key, &Seg, 1,
3593 pMetaXfer->cbMeta, pIoTask,
3594 &pvTask);
3595 if ( RT_SUCCESS(rcReq)
3596 || rcReq != VERR_VD_ASYNC_IO_IN_PROGRESS)
3597 {
3598 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
3599 vdIoTaskFree(pDisk, pIoTask);
3600 }
3601 else
3602 RTListMove(&pMetaXfer->ListIoCtxWaiting, &pMetaXfer->ListIoCtxShwWrites);
3603 }
3604 else
3605 rcReq = VERR_NO_MEMORY;
3606
3607 /* Cleanup if there was an error or the request completed already. */
3608 if (rcReq != VERR_VD_ASYNC_IO_IN_PROGRESS)
3609 vdIoCtxContinueDeferredList(pIoStorage, &pMetaXfer->ListIoCtxShwWrites, pfnComplete, pvUser, rcReq);
3610 }
3611
3612 /* Remove if not used anymore. */
3613 if (!fFlush)
3614 {
3615 pMetaXfer->cRefs--;
3616 if (!pMetaXfer->cRefs && RTListIsEmpty(&pMetaXfer->ListIoCtxWaiting))
3617 {
3618 /* Remove from the AVL tree. */
3619 LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
3620 bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
3621 Assert(fRemoved); NOREF(fRemoved);
3622 RTMemFree(pMetaXfer);
3623 }
3624 }
3625 else if (fFlush)
3626 RTMemFree(pMetaXfer);
3627
3628 return VINF_SUCCESS;
3629}
3630
3631/**
3632 * Processes a list of waiting I/O tasks. The disk lock must be held by caller.
3633 *
3634 * @returns nothing.
3635 * @param pDisk The disk to process the list for.
3636 */
3637static void vdIoTaskProcessWaitingList(PVDISK pDisk)
3638{
3639 LogFlowFunc(("pDisk=%#p\n", pDisk));
3640
3641 VD_IS_LOCKED(pDisk);
3642
3643 PVDIOTASK pHead = ASMAtomicXchgPtrT(&pDisk->pIoTasksPendingHead, NULL, PVDIOTASK);
3644
3645 Log(("I/O task list cleared\n"));
3646
3647 /* Reverse order. */
3648 PVDIOTASK pCur = pHead;
3649 pHead = NULL;
3650 while (pCur)
3651 {
3652 PVDIOTASK pInsert = pCur;
3653 pCur = pCur->pNext;
3654 pInsert->pNext = pHead;
3655 pHead = pInsert;
3656 }
3657
3658 while (pHead)
3659 {
3660 PVDIOSTORAGE pIoStorage = pHead->pIoStorage;
3661
3662 if (!pHead->fMeta)
3663 vdUserXferCompleted(pIoStorage, pHead->Type.User.pIoCtx,
3664 pHead->pfnComplete, pHead->pvUser,
3665 pHead->Type.User.cbTransfer, pHead->rcReq);
3666 else
3667 vdMetaXferCompleted(pIoStorage, pHead->pfnComplete, pHead->pvUser,
3668 pHead->Type.Meta.pMetaXfer, pHead->rcReq);
3669
3670 pCur = pHead;
3671 pHead = pHead->pNext;
3672 vdIoTaskFree(pDisk, pCur);
3673 }
3674}
3675
3676/**
3677 * Process any I/O context on the halted list.
3678 *
3679 * @returns nothing.
3680 * @param pDisk The disk.
3681 */
3682static void vdIoCtxProcessHaltedList(PVDISK pDisk)
3683{
3684 LogFlowFunc(("pDisk=%#p\n", pDisk));
3685
3686 VD_IS_LOCKED(pDisk);
3687
3688 /* Get the waiting list and process it in FIFO order. */
3689 PVDIOCTX pIoCtxHead = ASMAtomicXchgPtrT(&pDisk->pIoCtxHaltedHead, NULL, PVDIOCTX);
3690
3691 /* Reverse it. */
3692 PVDIOCTX pCur = pIoCtxHead;
3693 pIoCtxHead = NULL;
3694 while (pCur)
3695 {
3696 PVDIOCTX pInsert = pCur;
3697 pCur = pCur->pIoCtxNext;
3698 pInsert->pIoCtxNext = pIoCtxHead;
3699 pIoCtxHead = pInsert;
3700 }
3701
3702 /* Process now. */
3703 pCur = pIoCtxHead;
3704 while (pCur)
3705 {
3706 PVDIOCTX pTmp = pCur;
3707
3708 pCur = pCur->pIoCtxNext;
3709 pTmp->pIoCtxNext = NULL;
3710
3711 /* Continue */
3712 pTmp->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
3713 vdIoCtxContinue(pTmp, pTmp->rcReq);
3714 }
3715}
3716
3717/**
3718 * Unlock the disk and process pending tasks.
3719 *
3720 * @returns VBox status code.
3721 * @param pDisk The disk to unlock.
3722 * @param pIoCtxRc The I/O context to get the status code from, optional.
3723 */
3724static int vdDiskUnlock(PVDISK pDisk, PVDIOCTX pIoCtxRc)
3725{
3726 int rc = VINF_SUCCESS;
3727
3728 VD_IS_LOCKED(pDisk);
3729
3730 /*
3731 * Process the list of waiting I/O tasks first
3732 * because they might complete I/O contexts.
3733 * Same for the list of halted I/O contexts.
3734 * Afterwards comes the list of new I/O contexts.
3735 */
3736 vdIoTaskProcessWaitingList(pDisk);
3737 vdIoCtxProcessHaltedList(pDisk);
3738 rc = vdDiskProcessWaitingIoCtx(pDisk, pIoCtxRc);
3739 ASMAtomicXchgBool(&pDisk->fLocked, false);
3740
3741 /*
3742 * Need to check for new I/O tasks and waiting I/O contexts now
3743 * again as other threads might added them while we processed
3744 * previous lists.
3745 */
3746 while ( ASMAtomicUoReadPtrT(&pDisk->pIoCtxHead, PVDIOCTX) != NULL
3747 || ASMAtomicUoReadPtrT(&pDisk->pIoTasksPendingHead, PVDIOTASK) != NULL
3748 || ASMAtomicUoReadPtrT(&pDisk->pIoCtxHaltedHead, PVDIOCTX) != NULL)
3749 {
3750 /* Try lock disk again. */
3751 if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
3752 {
3753 vdIoTaskProcessWaitingList(pDisk);
3754 vdIoCtxProcessHaltedList(pDisk);
3755 vdDiskProcessWaitingIoCtx(pDisk, NULL);
3756 ASMAtomicXchgBool(&pDisk->fLocked, false);
3757 }
3758 else /* Let the other thread everything when he unlocks the disk. */
3759 break;
3760 }
3761
3762 return rc;
3763}
3764
3765/**
3766 * Try to lock the disk to complete pressing of the I/O task.
3767 * The completion is deferred if the disk is locked already.
3768 *
3769 * @returns nothing.
3770 * @param pIoTask The I/O task to complete.
3771 */
3772static void vdXferTryLockDiskDeferIoTask(PVDIOTASK pIoTask)
3773{
3774 PVDIOSTORAGE pIoStorage = pIoTask->pIoStorage;
3775 PVDISK pDisk = pIoStorage->pVDIo->pDisk;
3776
3777 Log(("Deferring I/O task pIoTask=%p\n", pIoTask));
3778
3779 /* Put it on the waiting list. */
3780 PVDIOTASK pNext = ASMAtomicUoReadPtrT(&pDisk->pIoTasksPendingHead, PVDIOTASK);
3781 PVDIOTASK pHeadOld;
3782 pIoTask->pNext = pNext;
3783 while (!ASMAtomicCmpXchgExPtr(&pDisk->pIoTasksPendingHead, pIoTask, pNext, &pHeadOld))
3784 {
3785 pNext = pHeadOld;
3786 Assert(pNext != pIoTask);
3787 pIoTask->pNext = pNext;
3788 ASMNopPause();
3789 }
3790
3791 if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
3792 {
3793 /* Release disk lock, it will take care of processing all lists. */
3794 vdDiskUnlock(pDisk, NULL);
3795 }
3796}
3797
3798static DECLCALLBACK(int) vdIOIntReqCompleted(void *pvUser, int rcReq)
3799{
3800 PVDIOTASK pIoTask = (PVDIOTASK)pvUser;
3801
3802 LogFlowFunc(("Task completed pIoTask=%#p\n", pIoTask));
3803
3804 pIoTask->rcReq = rcReq;
3805 vdXferTryLockDiskDeferIoTask(pIoTask);
3806 return VINF_SUCCESS;
3807}
3808
3809/**
3810 * VD I/O interface callback for opening a file.
3811 */
3812static DECLCALLBACK(int) vdIOIntOpen(void *pvUser, const char *pszLocation,
3813 unsigned uOpenFlags, PPVDIOSTORAGE ppIoStorage)
3814{
3815 int rc = VINF_SUCCESS;
3816 PVDIO pVDIo = (PVDIO)pvUser;
3817 PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
3818
3819 if (!pIoStorage)
3820 return VERR_NO_MEMORY;
3821
3822 /* Create the AVl tree. */
3823 pIoStorage->pTreeMetaXfers = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
3824 if (pIoStorage->pTreeMetaXfers)
3825 {
3826 rc = pVDIo->pInterfaceIo->pfnOpen(pVDIo->pInterfaceIo->Core.pvUser,
3827 pszLocation, uOpenFlags,
3828 vdIOIntReqCompleted,
3829 &pIoStorage->pStorage);
3830 if (RT_SUCCESS(rc))
3831 {
3832 pIoStorage->pVDIo = pVDIo;
3833 *ppIoStorage = pIoStorage;
3834 return VINF_SUCCESS;
3835 }
3836
3837 RTMemFree(pIoStorage->pTreeMetaXfers);
3838 }
3839 else
3840 rc = VERR_NO_MEMORY;
3841
3842 RTMemFree(pIoStorage);
3843 return rc;
3844}
3845
3846static DECLCALLBACK(int) vdIOIntTreeMetaXferDestroy(PAVLRFOFFNODECORE pNode, void *pvUser)
3847{
3848 RT_NOREF2(pNode, pvUser);
3849 AssertMsgFailed(("Tree should be empty at this point!\n"));
3850 return VINF_SUCCESS;
3851}
3852
3853static DECLCALLBACK(int) vdIOIntClose(void *pvUser, PVDIOSTORAGE pIoStorage)
3854{
3855 int rc = VINF_SUCCESS;
3856 PVDIO pVDIo = (PVDIO)pvUser;
3857
3858 /* We free everything here, even if closing the file failed for some reason. */
3859 rc = pVDIo->pInterfaceIo->pfnClose(pVDIo->pInterfaceIo->Core.pvUser, pIoStorage->pStorage);
3860 RTAvlrFileOffsetDestroy(pIoStorage->pTreeMetaXfers, vdIOIntTreeMetaXferDestroy, NULL);
3861 RTMemFree(pIoStorage->pTreeMetaXfers);
3862 RTMemFree(pIoStorage);
3863 return rc;
3864}
3865
3866static DECLCALLBACK(int) vdIOIntDelete(void *pvUser, const char *pcszFilename)
3867{
3868 PVDIO pVDIo = (PVDIO)pvUser;
3869 return pVDIo->pInterfaceIo->pfnDelete(pVDIo->pInterfaceIo->Core.pvUser,
3870 pcszFilename);
3871}
3872
3873static DECLCALLBACK(int) vdIOIntMove(void *pvUser, const char *pcszSrc, const char *pcszDst,
3874 unsigned fMove)
3875{
3876 PVDIO pVDIo = (PVDIO)pvUser;
3877 return pVDIo->pInterfaceIo->pfnMove(pVDIo->pInterfaceIo->Core.pvUser,
3878 pcszSrc, pcszDst, fMove);
3879}
3880
3881static DECLCALLBACK(int) vdIOIntGetFreeSpace(void *pvUser, const char *pcszFilename,
3882 int64_t *pcbFreeSpace)
3883{
3884 PVDIO pVDIo = (PVDIO)pvUser;
3885 return pVDIo->pInterfaceIo->pfnGetFreeSpace(pVDIo->pInterfaceIo->Core.pvUser,
3886 pcszFilename, pcbFreeSpace);
3887}
3888
3889static DECLCALLBACK(int) vdIOIntGetModificationTime(void *pvUser, const char *pcszFilename,
3890 PRTTIMESPEC pModificationTime)
3891{
3892 PVDIO pVDIo = (PVDIO)pvUser;
3893 return pVDIo->pInterfaceIo->pfnGetModificationTime(pVDIo->pInterfaceIo->Core.pvUser,
3894 pcszFilename, pModificationTime);
3895}
3896
3897static DECLCALLBACK(int) vdIOIntGetSize(void *pvUser, PVDIOSTORAGE pIoStorage,
3898 uint64_t *pcbSize)
3899{
3900 PVDIO pVDIo = (PVDIO)pvUser;
3901 return pVDIo->pInterfaceIo->pfnGetSize(pVDIo->pInterfaceIo->Core.pvUser,
3902 pIoStorage->pStorage, pcbSize);
3903}
3904
3905static DECLCALLBACK(int) vdIOIntSetSize(void *pvUser, PVDIOSTORAGE pIoStorage,
3906 uint64_t cbSize)
3907{
3908 PVDIO pVDIo = (PVDIO)pvUser;
3909 return pVDIo->pInterfaceIo->pfnSetSize(pVDIo->pInterfaceIo->Core.pvUser,
3910 pIoStorage->pStorage, cbSize);
3911}
3912
3913static DECLCALLBACK(int) vdIOIntSetAllocationSize(void *pvUser, PVDIOSTORAGE pIoStorage,
3914 uint64_t cbSize, uint32_t fFlags,
3915 PVDINTERFACEPROGRESS pIfProgress,
3916 unsigned uPercentStart, unsigned uPercentSpan)
3917{
3918 PVDIO pVDIo = (PVDIO)pvUser;
3919 int rc = pVDIo->pInterfaceIo->pfnSetAllocationSize(pVDIo->pInterfaceIo->Core.pvUser,
3920 pIoStorage->pStorage, cbSize, fFlags);
3921 if (rc == VERR_NOT_SUPPORTED)
3922 {
3923 /* Fallback if the underlying medium does not support optimized storage allocation. */
3924 uint64_t cbSizeCur = 0;
3925 rc = pVDIo->pInterfaceIo->pfnGetSize(pVDIo->pInterfaceIo->Core.pvUser,
3926 pIoStorage->pStorage, &cbSizeCur);
3927 if (RT_SUCCESS(rc))
3928 {
3929 if (cbSizeCur < cbSize)
3930 {
3931 const size_t cbBuf = 128 * _1K;
3932 void *pvBuf = RTMemTmpAllocZ(cbBuf);
3933 if (RT_LIKELY(pvBuf))
3934 {
3935 uint64_t cbFill = cbSize - cbSizeCur;
3936 uint64_t uOff = 0;
3937
3938 /* Write data to all blocks. */
3939 while ( uOff < cbFill
3940 && RT_SUCCESS(rc))
3941 {
3942 size_t cbChunk = (size_t)RT_MIN(cbFill - uOff, cbBuf);
3943
3944 rc = pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
3945 pIoStorage->pStorage, cbSizeCur + uOff,
3946 pvBuf, cbChunk, NULL);
3947 if (RT_SUCCESS(rc))
3948 {
3949 uOff += cbChunk;
3950
3951 rc = vdIfProgress(pIfProgress, uPercentStart + uOff * uPercentSpan / cbFill);
3952 }
3953 }
3954
3955 RTMemTmpFree(pvBuf);
3956 }
3957 else
3958 rc = VERR_NO_MEMORY;
3959 }
3960 else if (cbSizeCur > cbSize)
3961 rc = pVDIo->pInterfaceIo->pfnSetSize(pVDIo->pInterfaceIo->Core.pvUser,
3962 pIoStorage->pStorage, cbSize);
3963 }
3964 }
3965
3966 if (RT_SUCCESS(rc))
3967 rc = vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
3968
3969 return rc;
3970}
3971
3972static DECLCALLBACK(int) vdIOIntReadUser(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
3973 PVDIOCTX pIoCtx, size_t cbRead)
3974{
3975 int rc = VINF_SUCCESS;
3976 PVDIO pVDIo = (PVDIO)pvUser;
3977 PVDISK pDisk = pVDIo->pDisk;
3978
3979 LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbRead=%u\n",
3980 pvUser, pIoStorage, uOffset, pIoCtx, cbRead));
3981
3982 /** @todo Enable check for sync I/O later. */
3983 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
3984 VD_IS_LOCKED(pDisk);
3985
3986 Assert(cbRead > 0);
3987
3988 if (pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
3989 {
3990 RTSGSEG Seg;
3991 unsigned cSegments = 1;
3992 size_t cbTaskRead = 0;
3993
3994 /* Synchronous I/O contexts only have one buffer segment. */
3995 AssertMsgReturn(pIoCtx->Req.Io.SgBuf.cSegs == 1,
3996 ("Invalid number of buffer segments for synchronous I/O context"),
3997 VERR_INVALID_PARAMETER);
3998
3999 cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, &Seg, &cSegments, cbRead);
4000 Assert(cbRead == cbTaskRead);
4001 Assert(cSegments == 1);
4002 rc = pVDIo->pInterfaceIo->pfnReadSync(pVDIo->pInterfaceIo->Core.pvUser,
4003 pIoStorage->pStorage, uOffset,
4004 Seg.pvSeg, cbRead, NULL);
4005 if (RT_SUCCESS(rc))
4006 {
4007 Assert(cbRead == (uint32_t)cbRead);
4008 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbRead);
4009 }
4010 }
4011 else
4012 {
4013 /* Build the S/G array and spawn a new I/O task */
4014 while (cbRead)
4015 {
4016 RTSGSEG aSeg[VD_IO_TASK_SEGMENTS_MAX];
4017 unsigned cSegments = VD_IO_TASK_SEGMENTS_MAX;
4018 size_t cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbRead);
4019
4020 Assert(cSegments > 0);
4021 Assert(cbTaskRead > 0);
4022 AssertMsg(cbTaskRead <= cbRead, ("Invalid number of bytes to read\n"));
4023
4024 LogFlow(("Reading %u bytes into %u segments\n", cbTaskRead, cSegments));
4025
4026#ifdef RT_STRICT
4027 for (unsigned i = 0; i < cSegments; i++)
4028 AssertMsg(aSeg[i].pvSeg && !(aSeg[i].cbSeg % 512),
4029 ("Segment %u is invalid\n", i));
4030#endif
4031
4032 Assert(cbTaskRead == (uint32_t)cbTaskRead);
4033 PVDIOTASK pIoTask = vdIoTaskUserAlloc(pIoStorage, NULL, NULL, pIoCtx, (uint32_t)cbTaskRead);
4034
4035 if (!pIoTask)
4036 return VERR_NO_MEMORY;
4037
4038 ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
4039
4040 void *pvTask;
4041 Log(("Spawning pIoTask=%p pIoCtx=%p\n", pIoTask, pIoCtx));
4042 rc = pVDIo->pInterfaceIo->pfnReadAsync(pVDIo->pInterfaceIo->Core.pvUser,
4043 pIoStorage->pStorage, uOffset,
4044 aSeg, cSegments, cbTaskRead, pIoTask,
4045 &pvTask);
4046 if (RT_SUCCESS(rc))
4047 {
4048 AssertMsg(cbTaskRead <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
4049 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbTaskRead);
4050 ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
4051 vdIoTaskFree(pDisk, pIoTask);
4052 }
4053 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
4054 {
4055 ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
4056 vdIoTaskFree(pDisk, pIoTask);
4057 break;
4058 }
4059
4060 uOffset += cbTaskRead;
4061 cbRead -= cbTaskRead;
4062 }
4063 }
4064
4065 LogFlowFunc(("returns rc=%Rrc\n", rc));
4066 return rc;
4067}
4068
4069static DECLCALLBACK(int) vdIOIntWriteUser(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
4070 PVDIOCTX pIoCtx, size_t cbWrite, PFNVDXFERCOMPLETED pfnComplete,
4071 void *pvCompleteUser)
4072{
4073 int rc = VINF_SUCCESS;
4074 PVDIO pVDIo = (PVDIO)pvUser;
4075 PVDISK pDisk = pVDIo->pDisk;
4076
4077 LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbWrite=%u\n",
4078 pvUser, pIoStorage, uOffset, pIoCtx, cbWrite));
4079
4080 /** @todo Enable check for sync I/O later. */
4081 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4082 VD_IS_LOCKED(pDisk);
4083
4084 Assert(cbWrite > 0);
4085
4086 if (pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
4087 {
4088 RTSGSEG Seg;
4089 unsigned cSegments = 1;
4090 size_t cbTaskWrite = 0;
4091
4092 /* Synchronous I/O contexts only have one buffer segment. */
4093 AssertMsgReturn(pIoCtx->Req.Io.SgBuf.cSegs == 1,
4094 ("Invalid number of buffer segments for synchronous I/O context"),
4095 VERR_INVALID_PARAMETER);
4096
4097 cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, &Seg, &cSegments, cbWrite);
4098 Assert(cbWrite == cbTaskWrite);
4099 Assert(cSegments == 1);
4100 rc = pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
4101 pIoStorage->pStorage, uOffset,
4102 Seg.pvSeg, cbWrite, NULL);
4103 if (RT_SUCCESS(rc))
4104 {
4105 Assert(pIoCtx->Req.Io.cbTransferLeft >= cbWrite);
4106 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbWrite);
4107 }
4108 }
4109 else
4110 {
4111 /* Build the S/G array and spawn a new I/O task */
4112 while (cbWrite)
4113 {
4114 RTSGSEG aSeg[VD_IO_TASK_SEGMENTS_MAX];
4115 unsigned cSegments = VD_IO_TASK_SEGMENTS_MAX;
4116 size_t cbTaskWrite = 0;
4117
4118 cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbWrite);
4119
4120 Assert(cSegments > 0);
4121 Assert(cbTaskWrite > 0);
4122 AssertMsg(cbTaskWrite <= cbWrite, ("Invalid number of bytes to write\n"));
4123
4124 LogFlow(("Writing %u bytes from %u segments\n", cbTaskWrite, cSegments));
4125
4126#ifdef DEBUG
4127 for (unsigned i = 0; i < cSegments; i++)
4128 AssertMsg(aSeg[i].pvSeg && !(aSeg[i].cbSeg % 512),
4129 ("Segment %u is invalid\n", i));
4130#endif
4131
4132 Assert(cbTaskWrite == (uint32_t)cbTaskWrite);
4133 PVDIOTASK pIoTask = vdIoTaskUserAlloc(pIoStorage, pfnComplete, pvCompleteUser, pIoCtx, (uint32_t)cbTaskWrite);
4134
4135 if (!pIoTask)
4136 return VERR_NO_MEMORY;
4137
4138 ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
4139
4140 void *pvTask;
4141 Log(("Spawning pIoTask=%p pIoCtx=%p\n", pIoTask, pIoCtx));
4142 rc = pVDIo->pInterfaceIo->pfnWriteAsync(pVDIo->pInterfaceIo->Core.pvUser,
4143 pIoStorage->pStorage,
4144 uOffset, aSeg, cSegments,
4145 cbTaskWrite, pIoTask, &pvTask);
4146 if (RT_SUCCESS(rc))
4147 {
4148 AssertMsg(cbTaskWrite <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
4149 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbTaskWrite);
4150 ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
4151 vdIoTaskFree(pDisk, pIoTask);
4152 }
4153 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
4154 {
4155 ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
4156 vdIoTaskFree(pDisk, pIoTask);
4157 break;
4158 }
4159
4160 uOffset += cbTaskWrite;
4161 cbWrite -= cbTaskWrite;
4162 }
4163 }
4164
4165 LogFlowFunc(("returns rc=%Rrc\n", rc));
4166 return rc;
4167}
4168
4169static DECLCALLBACK(int) vdIOIntReadMeta(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
4170 void *pvBuf, size_t cbRead, PVDIOCTX pIoCtx,
4171 PPVDMETAXFER ppMetaXfer, PFNVDXFERCOMPLETED pfnComplete,
4172 void *pvCompleteUser)
4173{
4174 PVDIO pVDIo = (PVDIO)pvUser;
4175 PVDISK pDisk = pVDIo->pDisk;
4176 int rc = VINF_SUCCESS;
4177 RTSGSEG Seg;
4178 PVDIOTASK pIoTask;
4179 PVDMETAXFER pMetaXfer = NULL;
4180 void *pvTask = NULL;
4181
4182 LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pvBuf=%#p cbRead=%u\n",
4183 pvUser, pIoStorage, uOffset, pvBuf, cbRead));
4184
4185 AssertMsgReturn( pIoCtx
4186 || (!ppMetaXfer && !pfnComplete && !pvCompleteUser),
4187 ("A synchronous metadata read is requested but the parameters are wrong\n"),
4188 VERR_INVALID_POINTER);
4189
4190 /** @todo Enable check for sync I/O later. */
4191 if ( pIoCtx
4192 && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4193 VD_IS_LOCKED(pDisk);
4194
4195 if ( !pIoCtx
4196 || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
4197 {
4198 /* Handle synchronous metadata I/O. */
4199 /** @todo Integrate with metadata transfers below. */
4200 rc = pVDIo->pInterfaceIo->pfnReadSync(pVDIo->pInterfaceIo->Core.pvUser,
4201 pIoStorage->pStorage, uOffset,
4202 pvBuf, cbRead, NULL);
4203 if (ppMetaXfer)
4204 *ppMetaXfer = NULL;
4205 }
4206 else
4207 {
4208 pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGet(pIoStorage->pTreeMetaXfers, uOffset);
4209 if (!pMetaXfer)
4210 {
4211#ifdef RT_STRICT
4212 pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGetBestFit(pIoStorage->pTreeMetaXfers, uOffset, false /* fAbove */);
4213 AssertMsg(!pMetaXfer || (pMetaXfer->Core.Key + (RTFOFF)pMetaXfer->cbMeta <= (RTFOFF)uOffset),
4214 ("Overlapping meta transfers!\n"));
4215#endif
4216
4217 /* Allocate a new meta transfer. */
4218 pMetaXfer = vdMetaXferAlloc(pIoStorage, uOffset, cbRead);
4219 if (!pMetaXfer)
4220 return VERR_NO_MEMORY;
4221
4222 pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvCompleteUser, pMetaXfer);
4223 if (!pIoTask)
4224 {
4225 RTMemFree(pMetaXfer);
4226 return VERR_NO_MEMORY;
4227 }
4228
4229 Seg.cbSeg = cbRead;
4230 Seg.pvSeg = pMetaXfer->abData;
4231
4232 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_READ);
4233 rc = pVDIo->pInterfaceIo->pfnReadAsync(pVDIo->pInterfaceIo->Core.pvUser,
4234 pIoStorage->pStorage,
4235 uOffset, &Seg, 1,
4236 cbRead, pIoTask, &pvTask);
4237
4238 if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4239 {
4240 bool fInserted = RTAvlrFileOffsetInsert(pIoStorage->pTreeMetaXfers, &pMetaXfer->Core);
4241 Assert(fInserted); NOREF(fInserted);
4242 }
4243 else
4244 RTMemFree(pMetaXfer);
4245
4246 if (RT_SUCCESS(rc))
4247 {
4248 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
4249 vdIoTaskFree(pDisk, pIoTask);
4250 }
4251 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS && !pfnComplete)
4252 rc = VERR_VD_NOT_ENOUGH_METADATA;
4253 }
4254
4255 Assert(VALID_PTR(pMetaXfer) || RT_FAILURE(rc));
4256
4257 if (RT_SUCCESS(rc) || rc == VERR_VD_NOT_ENOUGH_METADATA || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4258 {
4259 /* If it is pending add the request to the list. */
4260 if (VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_READ)
4261 {
4262 PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
4263 AssertPtr(pDeferred);
4264
4265 RTListInit(&pDeferred->NodeDeferred);
4266 pDeferred->pIoCtx = pIoCtx;
4267
4268 ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
4269 RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
4270 rc = VERR_VD_NOT_ENOUGH_METADATA;
4271 }
4272 else
4273 {
4274 /* Transfer the data. */
4275 pMetaXfer->cRefs++;
4276 Assert(pMetaXfer->cbMeta >= cbRead);
4277 Assert(pMetaXfer->Core.Key == (RTFOFF)uOffset);
4278 if (pMetaXfer->pbDataShw)
4279 memcpy(pvBuf, pMetaXfer->pbDataShw, cbRead);
4280 else
4281 memcpy(pvBuf, pMetaXfer->abData, cbRead);
4282 *ppMetaXfer = pMetaXfer;
4283 }
4284 }
4285 }
4286
4287 LogFlowFunc(("returns rc=%Rrc\n", rc));
4288 return rc;
4289}
4290
4291static DECLCALLBACK(int) vdIOIntWriteMeta(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
4292 const void *pvBuf, size_t cbWrite, PVDIOCTX pIoCtx,
4293 PFNVDXFERCOMPLETED pfnComplete, void *pvCompleteUser)
4294{
4295 PVDIO pVDIo = (PVDIO)pvUser;
4296 PVDISK pDisk = pVDIo->pDisk;
4297 int rc = VINF_SUCCESS;
4298 RTSGSEG Seg;
4299 PVDIOTASK pIoTask;
4300 PVDMETAXFER pMetaXfer = NULL;
4301 bool fInTree = false;
4302 void *pvTask = NULL;
4303
4304 LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pvBuf=%#p cbWrite=%u\n",
4305 pvUser, pIoStorage, uOffset, pvBuf, cbWrite));
4306
4307 AssertMsgReturn( pIoCtx
4308 || (!pfnComplete && !pvCompleteUser),
4309 ("A synchronous metadata write is requested but the parameters are wrong\n"),
4310 VERR_INVALID_POINTER);
4311
4312 /** @todo Enable check for sync I/O later. */
4313 if ( pIoCtx
4314 && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4315 VD_IS_LOCKED(pDisk);
4316
4317 if ( !pIoCtx
4318 || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
4319 {
4320 /* Handle synchronous metadata I/O. */
4321 /** @todo Integrate with metadata transfers below. */
4322 rc = pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
4323 pIoStorage->pStorage, uOffset,
4324 pvBuf, cbWrite, NULL);
4325 }
4326 else
4327 {
4328 pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGet(pIoStorage->pTreeMetaXfers, uOffset);
4329 if (!pMetaXfer)
4330 {
4331 /* Allocate a new meta transfer. */
4332 pMetaXfer = vdMetaXferAlloc(pIoStorage, uOffset, cbWrite);
4333 if (!pMetaXfer)
4334 return VERR_NO_MEMORY;
4335 }
4336 else
4337 {
4338 Assert(pMetaXfer->cbMeta >= cbWrite);
4339 Assert(pMetaXfer->Core.Key == (RTFOFF)uOffset);
4340 fInTree = true;
4341 }
4342
4343 if (VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE)
4344 {
4345 pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvCompleteUser, pMetaXfer);
4346 if (!pIoTask)
4347 {
4348 RTMemFree(pMetaXfer);
4349 return VERR_NO_MEMORY;
4350 }
4351
4352 memcpy(pMetaXfer->abData, pvBuf, cbWrite);
4353 Seg.cbSeg = cbWrite;
4354 Seg.pvSeg = pMetaXfer->abData;
4355
4356 ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
4357
4358 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_WRITE);
4359 rc = pVDIo->pInterfaceIo->pfnWriteAsync(pVDIo->pInterfaceIo->Core.pvUser,
4360 pIoStorage->pStorage,
4361 uOffset, &Seg, 1, cbWrite, pIoTask,
4362 &pvTask);
4363 if (RT_SUCCESS(rc))
4364 {
4365 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
4366 ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
4367 vdIoTaskFree(pDisk, pIoTask);
4368 if (fInTree && !pMetaXfer->cRefs)
4369 {
4370 LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
4371 bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
4372 AssertMsg(fRemoved, ("Metadata transfer wasn't removed\n")); NOREF(fRemoved);
4373 RTMemFree(pMetaXfer);
4374 pMetaXfer = NULL;
4375 }
4376 }
4377 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4378 {
4379 PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
4380 AssertPtr(pDeferred);
4381
4382 RTListInit(&pDeferred->NodeDeferred);
4383 pDeferred->pIoCtx = pIoCtx;
4384
4385 if (!fInTree)
4386 {
4387 bool fInserted = RTAvlrFileOffsetInsert(pIoStorage->pTreeMetaXfers, &pMetaXfer->Core);
4388 Assert(fInserted); NOREF(fInserted);
4389 }
4390
4391 RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
4392 }
4393 else
4394 {
4395 RTMemFree(pMetaXfer);
4396 pMetaXfer = NULL;
4397 }
4398 }
4399 else
4400 {
4401 /* I/O is in progress, update shadow buffer and add to waiting list. */
4402 Assert(VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_WRITE);
4403 if (!pMetaXfer->pbDataShw)
4404 {
4405 /* Allocate shadow buffer and set initial state. */
4406 LogFlowFunc(("pMetaXfer=%#p Creating shadow buffer\n", pMetaXfer));
4407 pMetaXfer->pbDataShw = (uint8_t *)RTMemAlloc(pMetaXfer->cbMeta);
4408 if (RT_LIKELY(pMetaXfer->pbDataShw))
4409 memcpy(pMetaXfer->pbDataShw, pMetaXfer->abData, pMetaXfer->cbMeta);
4410 else
4411 rc = VERR_NO_MEMORY;
4412 }
4413
4414 if (RT_SUCCESS(rc))
4415 {
4416 /* Update with written data and append to waiting list. */
4417 PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
4418 if (pDeferred)
4419 {
4420 LogFlowFunc(("pMetaXfer=%#p Updating shadow buffer\n", pMetaXfer));
4421
4422 RTListInit(&pDeferred->NodeDeferred);
4423 pDeferred->pIoCtx = pIoCtx;
4424 ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
4425 memcpy(pMetaXfer->pbDataShw, pvBuf, cbWrite);
4426 RTListAppend(&pMetaXfer->ListIoCtxShwWrites, &pDeferred->NodeDeferred);
4427 }
4428 else
4429 {
4430 /*
4431 * Free shadow buffer if there is no one depending on it, i.e.
4432 * we just allocated it.
4433 */
4434 if (RTListIsEmpty(&pMetaXfer->ListIoCtxShwWrites))
4435 {
4436 RTMemFree(pMetaXfer->pbDataShw);
4437 pMetaXfer->pbDataShw = NULL;
4438 }
4439 rc = VERR_NO_MEMORY;
4440 }
4441 }
4442 }
4443 }
4444
4445 LogFlowFunc(("returns rc=%Rrc\n", rc));
4446 return rc;
4447}
4448
4449static DECLCALLBACK(void) vdIOIntMetaXferRelease(void *pvUser, PVDMETAXFER pMetaXfer)
4450{
4451 PVDIO pVDIo = (PVDIO)pvUser;
4452 PVDISK pDisk = pVDIo->pDisk;
4453 PVDIOSTORAGE pIoStorage;
4454
4455 /*
4456 * It is possible that we get called with a NULL metadata xfer handle
4457 * for synchronous I/O. Just exit.
4458 */
4459 if (!pMetaXfer)
4460 return;
4461
4462 pIoStorage = pMetaXfer->pIoStorage;
4463
4464 VD_IS_LOCKED(pDisk);
4465
4466 Assert( VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE
4467 || VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_WRITE);
4468 Assert(pMetaXfer->cRefs > 0);
4469
4470 pMetaXfer->cRefs--;
4471 if ( !pMetaXfer->cRefs
4472 && RTListIsEmpty(&pMetaXfer->ListIoCtxWaiting)
4473 && VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE)
4474 {
4475 /* Free the meta data entry. */
4476 LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
4477 bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
4478 AssertMsg(fRemoved, ("Metadata transfer wasn't removed\n")); NOREF(fRemoved);
4479
4480 RTMemFree(pMetaXfer);
4481 }
4482}
4483
4484static DECLCALLBACK(int) vdIOIntFlush(void *pvUser, PVDIOSTORAGE pIoStorage, PVDIOCTX pIoCtx,
4485 PFNVDXFERCOMPLETED pfnComplete, void *pvCompleteUser)
4486{
4487 PVDIO pVDIo = (PVDIO)pvUser;
4488 PVDISK pDisk = pVDIo->pDisk;
4489 int rc = VINF_SUCCESS;
4490 PVDIOTASK pIoTask;
4491 PVDMETAXFER pMetaXfer = NULL;
4492 void *pvTask = NULL;
4493
4494 LogFlowFunc(("pvUser=%#p pIoStorage=%#p pIoCtx=%#p\n",
4495 pvUser, pIoStorage, pIoCtx));
4496
4497 AssertMsgReturn( pIoCtx
4498 || (!pfnComplete && !pvCompleteUser),
4499 ("A synchronous metadata write is requested but the parameters are wrong\n"),
4500 VERR_INVALID_POINTER);
4501
4502 /** @todo Enable check for sync I/O later. */
4503 if ( pIoCtx
4504 && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4505 VD_IS_LOCKED(pDisk);
4506
4507 if (pVDIo->fIgnoreFlush)
4508 return VINF_SUCCESS;
4509
4510 if ( !pIoCtx
4511 || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
4512 {
4513 /* Handle synchronous flushes. */
4514 /** @todo Integrate with metadata transfers below. */
4515 rc = pVDIo->pInterfaceIo->pfnFlushSync(pVDIo->pInterfaceIo->Core.pvUser,
4516 pIoStorage->pStorage);
4517 }
4518 else
4519 {
4520 /* Allocate a new meta transfer. */
4521 pMetaXfer = vdMetaXferAlloc(pIoStorage, 0, 0);
4522 if (!pMetaXfer)
4523 return VERR_NO_MEMORY;
4524
4525 pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvUser, pMetaXfer);
4526 if (!pIoTask)
4527 {
4528 RTMemFree(pMetaXfer);
4529 return VERR_NO_MEMORY;
4530 }
4531
4532 ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
4533
4534 PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
4535 AssertPtr(pDeferred);
4536
4537 RTListInit(&pDeferred->NodeDeferred);
4538 pDeferred->pIoCtx = pIoCtx;
4539
4540 RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
4541 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_FLUSH);
4542 rc = pVDIo->pInterfaceIo->pfnFlushAsync(pVDIo->pInterfaceIo->Core.pvUser,
4543 pIoStorage->pStorage,
4544 pIoTask, &pvTask);
4545 if (RT_SUCCESS(rc))
4546 {
4547 VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
4548 ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
4549 vdIoTaskFree(pDisk, pIoTask);
4550 RTMemFree(pDeferred);
4551 RTMemFree(pMetaXfer);
4552 }
4553 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
4554 RTMemFree(pMetaXfer);
4555 }
4556
4557 LogFlowFunc(("returns rc=%Rrc\n", rc));
4558 return rc;
4559}
4560
4561static DECLCALLBACK(size_t) vdIOIntIoCtxCopyTo(void *pvUser, PVDIOCTX pIoCtx,
4562 const void *pvBuf, size_t cbBuf)
4563{
4564 PVDIO pVDIo = (PVDIO)pvUser;
4565 PVDISK pDisk = pVDIo->pDisk;
4566 size_t cbCopied = 0;
4567
4568 /** @todo Enable check for sync I/O later. */
4569 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4570 VD_IS_LOCKED(pDisk);
4571
4572 cbCopied = vdIoCtxCopyTo(pIoCtx, (uint8_t *)pvBuf, cbBuf);
4573 Assert(cbCopied == cbBuf);
4574
4575 /// @todo Assert(pIoCtx->Req.Io.cbTransferLeft >= cbCopied); - triggers with vdCopyHelper/dmgRead.
4576 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbCopied);
4577
4578 return cbCopied;
4579}
4580
4581static DECLCALLBACK(size_t) vdIOIntIoCtxCopyFrom(void *pvUser, PVDIOCTX pIoCtx,
4582 void *pvBuf, size_t cbBuf)
4583{
4584 PVDIO pVDIo = (PVDIO)pvUser;
4585 PVDISK pDisk = pVDIo->pDisk;
4586 size_t cbCopied = 0;
4587
4588 /** @todo Enable check for sync I/O later. */
4589 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4590 VD_IS_LOCKED(pDisk);
4591
4592 cbCopied = vdIoCtxCopyFrom(pIoCtx, (uint8_t *)pvBuf, cbBuf);
4593 Assert(cbCopied == cbBuf);
4594
4595 /// @todo Assert(pIoCtx->Req.Io.cbTransferLeft > cbCopied); - triggers with vdCopyHelper/dmgRead.
4596 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbCopied);
4597
4598 return cbCopied;
4599}
4600
4601static DECLCALLBACK(size_t) vdIOIntIoCtxSet(void *pvUser, PVDIOCTX pIoCtx, int ch, size_t cb)
4602{
4603 PVDIO pVDIo = (PVDIO)pvUser;
4604 PVDISK pDisk = pVDIo->pDisk;
4605 size_t cbSet = 0;
4606
4607 /** @todo Enable check for sync I/O later. */
4608 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4609 VD_IS_LOCKED(pDisk);
4610
4611 cbSet = vdIoCtxSet(pIoCtx, ch, cb);
4612 Assert(cbSet == cb);
4613
4614 /// @todo Assert(pIoCtx->Req.Io.cbTransferLeft >= cbSet); - triggers with vdCopyHelper/dmgRead.
4615 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbSet);
4616
4617 return cbSet;
4618}
4619
4620static DECLCALLBACK(size_t) vdIOIntIoCtxSegArrayCreate(void *pvUser, PVDIOCTX pIoCtx,
4621 PRTSGSEG paSeg, unsigned *pcSeg,
4622 size_t cbData)
4623{
4624 PVDIO pVDIo = (PVDIO)pvUser;
4625 PVDISK pDisk = pVDIo->pDisk;
4626 size_t cbCreated = 0;
4627
4628 /** @todo It is possible that this gets called from a filter plugin
4629 * outside of the disk lock. Refine assertion or remove completely. */
4630#if 0
4631 /** @todo Enable check for sync I/O later. */
4632 if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
4633 VD_IS_LOCKED(pDisk);
4634#else
4635 NOREF(pDisk);
4636#endif
4637
4638 cbCreated = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, paSeg, pcSeg, cbData);
4639 Assert(!paSeg || cbData == cbCreated);
4640
4641 return cbCreated;
4642}
4643
4644static DECLCALLBACK(void) vdIOIntIoCtxCompleted(void *pvUser, PVDIOCTX pIoCtx, int rcReq,
4645 size_t cbCompleted)
4646{
4647 PVDIO pVDIo = (PVDIO)pvUser;
4648 PVDISK pDisk = pVDIo->pDisk;
4649
4650 LogFlowFunc(("pvUser=%#p pIoCtx=%#p rcReq=%Rrc cbCompleted=%zu\n",
4651 pvUser, pIoCtx, rcReq, cbCompleted));
4652
4653 /*
4654 * Grab the disk critical section to avoid races with other threads which
4655 * might still modify the I/O context.
4656 * Example is that iSCSI is doing an asynchronous write but calls us already
4657 * while the other thread is still hanging in vdWriteHelperAsync and couldn't update
4658 * the blocked state yet.
4659 * It can overwrite the state to true before we call vdIoCtxContinue and the
4660 * the request would hang indefinite.
4661 */
4662 ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rcReq, VINF_SUCCESS);
4663 Assert(pIoCtx->Req.Io.cbTransferLeft >= cbCompleted);
4664 ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbCompleted);
4665
4666 /* Set next transfer function if the current one finished.
4667 * @todo: Find a better way to prevent vdIoCtxContinue from calling the current helper again. */
4668 if (!pIoCtx->Req.Io.cbTransferLeft)
4669 {
4670 pIoCtx->pfnIoCtxTransfer = pIoCtx->pfnIoCtxTransferNext;
4671 pIoCtx->pfnIoCtxTransferNext = NULL;
4672 }
4673
4674 vdIoCtxAddToWaitingList(&pDisk->pIoCtxHaltedHead, pIoCtx);
4675 if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
4676 {
4677 /* Immediately drop the lock again, it will take care of processing the list. */
4678 vdDiskUnlock(pDisk, NULL);
4679 }
4680}
4681
4682static DECLCALLBACK(bool) vdIOIntIoCtxIsSynchronous(void *pvUser, PVDIOCTX pIoCtx)
4683{
4684 NOREF(pvUser);
4685 return !!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC);
4686}
4687
4688static DECLCALLBACK(bool) vdIOIntIoCtxIsZero(void *pvUser, PVDIOCTX pIoCtx, size_t cbCheck,
4689 bool fAdvance)
4690{
4691 NOREF(pvUser);
4692
4693 bool fIsZero = RTSgBufIsZero(&pIoCtx->Req.Io.SgBuf, cbCheck);
4694 if (fIsZero && fAdvance)
4695 RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbCheck);
4696
4697 return fIsZero;
4698}
4699
4700static DECLCALLBACK(size_t) vdIOIntIoCtxGetDataUnitSize(void *pvUser, PVDIOCTX pIoCtx)
4701{
4702 RT_NOREF1(pIoCtx);
4703 PVDIO pVDIo = (PVDIO)pvUser;
4704 PVDISK pDisk = pVDIo->pDisk;
4705 size_t cbSector = 0;
4706
4707 PVDIMAGE pImage = vdGetImageByNumber(pDisk, VD_LAST_IMAGE);
4708 AssertPtrReturn(pImage, 0);
4709
4710 PCVDREGIONLIST pRegionList = NULL;
4711 int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
4712 if (RT_SUCCESS(rc))
4713 {
4714 cbSector = pRegionList->aRegions[0].cbBlock;
4715
4716 AssertPtr(pImage->Backend->pfnRegionListRelease);
4717 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
4718 }
4719
4720 return cbSector;
4721}
4722
4723/**
4724 * VD I/O interface callback for opening a file (limited version for VDGetFormat).
4725 */
4726static DECLCALLBACK(int) vdIOIntOpenLimited(void *pvUser, const char *pszLocation,
4727 uint32_t fOpen, PPVDIOSTORAGE ppIoStorage)
4728{
4729 int rc = VINF_SUCCESS;
4730 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4731 PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
4732
4733 if (!pIoStorage)
4734 return VERR_NO_MEMORY;
4735
4736 rc = pInterfaceIo->pfnOpen(NULL, pszLocation, fOpen, NULL, &pIoStorage->pStorage);
4737 if (RT_SUCCESS(rc))
4738 *ppIoStorage = pIoStorage;
4739 else
4740 RTMemFree(pIoStorage);
4741
4742 return rc;
4743}
4744
4745static DECLCALLBACK(int) vdIOIntCloseLimited(void *pvUser, PVDIOSTORAGE pIoStorage)
4746{
4747 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4748 int rc = pInterfaceIo->pfnClose(NULL, pIoStorage->pStorage);
4749
4750 RTMemFree(pIoStorage);
4751 return rc;
4752}
4753
4754static DECLCALLBACK(int) vdIOIntDeleteLimited(void *pvUser, const char *pcszFilename)
4755{
4756 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4757 return pInterfaceIo->pfnDelete(NULL, pcszFilename);
4758}
4759
4760static DECLCALLBACK(int) vdIOIntMoveLimited(void *pvUser, const char *pcszSrc,
4761 const char *pcszDst, unsigned fMove)
4762{
4763 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4764 return pInterfaceIo->pfnMove(NULL, pcszSrc, pcszDst, fMove);
4765}
4766
4767static DECLCALLBACK(int) vdIOIntGetFreeSpaceLimited(void *pvUser, const char *pcszFilename,
4768 int64_t *pcbFreeSpace)
4769{
4770 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4771 return pInterfaceIo->pfnGetFreeSpace(NULL, pcszFilename, pcbFreeSpace);
4772}
4773
4774static DECLCALLBACK(int) vdIOIntGetModificationTimeLimited(void *pvUser,
4775 const char *pcszFilename,
4776 PRTTIMESPEC pModificationTime)
4777{
4778 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4779 return pInterfaceIo->pfnGetModificationTime(NULL, pcszFilename, pModificationTime);
4780}
4781
4782static DECLCALLBACK(int) vdIOIntGetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
4783 uint64_t *pcbSize)
4784{
4785 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4786 return pInterfaceIo->pfnGetSize(NULL, pIoStorage->pStorage, pcbSize);
4787}
4788
4789static DECLCALLBACK(int) vdIOIntSetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
4790 uint64_t cbSize)
4791{
4792 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4793 return pInterfaceIo->pfnSetSize(NULL, pIoStorage->pStorage, cbSize);
4794}
4795
4796static DECLCALLBACK(int) vdIOIntWriteUserLimited(void *pvUser, PVDIOSTORAGE pStorage,
4797 uint64_t uOffset, PVDIOCTX pIoCtx,
4798 size_t cbWrite,
4799 PFNVDXFERCOMPLETED pfnComplete,
4800 void *pvCompleteUser)
4801{
4802 NOREF(pvUser);
4803 NOREF(pStorage);
4804 NOREF(uOffset);
4805 NOREF(pIoCtx);
4806 NOREF(cbWrite);
4807 NOREF(pfnComplete);
4808 NOREF(pvCompleteUser);
4809 AssertMsgFailedReturn(("This needs to be implemented when called\n"), VERR_NOT_IMPLEMENTED);
4810}
4811
4812static DECLCALLBACK(int) vdIOIntReadUserLimited(void *pvUser, PVDIOSTORAGE pStorage,
4813 uint64_t uOffset, PVDIOCTX pIoCtx,
4814 size_t cbRead)
4815{
4816 NOREF(pvUser);
4817 NOREF(pStorage);
4818 NOREF(uOffset);
4819 NOREF(pIoCtx);
4820 NOREF(cbRead);
4821 AssertMsgFailedReturn(("This needs to be implemented when called\n"), VERR_NOT_IMPLEMENTED);
4822}
4823
4824static DECLCALLBACK(int) vdIOIntWriteMetaLimited(void *pvUser, PVDIOSTORAGE pStorage,
4825 uint64_t uOffset, const void *pvBuffer,
4826 size_t cbBuffer, PVDIOCTX pIoCtx,
4827 PFNVDXFERCOMPLETED pfnComplete,
4828 void *pvCompleteUser)
4829{
4830 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4831
4832 AssertMsgReturn(!pIoCtx && !pfnComplete && !pvCompleteUser,
4833 ("Async I/O not implemented for the limited interface"),
4834 VERR_NOT_SUPPORTED);
4835
4836 return pInterfaceIo->pfnWriteSync(NULL, pStorage->pStorage, uOffset, pvBuffer, cbBuffer, NULL);
4837}
4838
4839static DECLCALLBACK(int) vdIOIntReadMetaLimited(void *pvUser, PVDIOSTORAGE pStorage,
4840 uint64_t uOffset, void *pvBuffer,
4841 size_t cbBuffer, PVDIOCTX pIoCtx,
4842 PPVDMETAXFER ppMetaXfer,
4843 PFNVDXFERCOMPLETED pfnComplete,
4844 void *pvCompleteUser)
4845{
4846 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4847
4848 AssertMsgReturn(!pIoCtx && !ppMetaXfer && !pfnComplete && !pvCompleteUser,
4849 ("Async I/O not implemented for the limited interface"),
4850 VERR_NOT_SUPPORTED);
4851
4852 return pInterfaceIo->pfnReadSync(NULL, pStorage->pStorage, uOffset, pvBuffer, cbBuffer, NULL);
4853}
4854
4855#if 0 /* unsed */
4856static int vdIOIntMetaXferReleaseLimited(void *pvUser, PVDMETAXFER pMetaXfer)
4857{
4858 /* This is a NOP in this case. */
4859 NOREF(pvUser);
4860 NOREF(pMetaXfer);
4861 return VINF_SUCCESS;
4862}
4863#endif
4864
4865static DECLCALLBACK(int) vdIOIntFlushLimited(void *pvUser, PVDIOSTORAGE pStorage,
4866 PVDIOCTX pIoCtx,
4867 PFNVDXFERCOMPLETED pfnComplete,
4868 void *pvCompleteUser)
4869{
4870 PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
4871
4872 AssertMsgReturn(!pIoCtx && !pfnComplete && !pvCompleteUser,
4873 ("Async I/O not implemented for the limited interface"),
4874 VERR_NOT_SUPPORTED);
4875
4876 return pInterfaceIo->pfnFlushSync(NULL, pStorage->pStorage);
4877}
4878
4879/**
4880 * internal: send output to the log (unconditionally).
4881 */
4882static DECLCALLBACK(int) vdLogMessage(void *pvUser, const char *pszFormat, va_list args)
4883{
4884 NOREF(pvUser);
4885 RTLogPrintfV(pszFormat, args);
4886 return VINF_SUCCESS;
4887}
4888
4889DECLINLINE(int) vdMessageWrapper(PVDISK pDisk, const char *pszFormat, ...)
4890{
4891 va_list va;
4892 va_start(va, pszFormat);
4893 int rc = pDisk->pInterfaceError->pfnMessage(pDisk->pInterfaceError->Core.pvUser,
4894 pszFormat, va);
4895 va_end(va);
4896 return rc;
4897}
4898
4899
4900/**
4901 * internal: adjust PCHS geometry
4902 */
4903static void vdFixupPCHSGeometry(PVDGEOMETRY pPCHS, uint64_t cbSize)
4904{
4905 /* Fix broken PCHS geometry. Can happen for two reasons: either the backend
4906 * mixes up PCHS and LCHS, or the application used to create the source
4907 * image has put garbage in it. Additionally, if the PCHS geometry covers
4908 * more than the image size, set it back to the default. */
4909 if ( pPCHS->cHeads > 16
4910 || pPCHS->cSectors > 63
4911 || pPCHS->cCylinders == 0
4912 || (uint64_t)pPCHS->cHeads * pPCHS->cSectors * pPCHS->cCylinders * 512 > cbSize)
4913 {
4914 Assert(!(RT_MIN(cbSize / 512 / 16 / 63, 16383) - (uint32_t)RT_MIN(cbSize / 512 / 16 / 63, 16383)));
4915 pPCHS->cCylinders = (uint32_t)RT_MIN(cbSize / 512 / 16 / 63, 16383);
4916 pPCHS->cHeads = 16;
4917 pPCHS->cSectors = 63;
4918 }
4919}
4920
4921/**
4922 * internal: adjust LCHS geometry
4923 */
4924static void vdFixupLCHSGeometry(PVDGEOMETRY pLCHS, uint64_t cbSize)
4925{
4926 /* Fix broken LCHS geometry. Can happen for two reasons: either the backend
4927 * mixes up PCHS and LCHS, or the application used to create the source
4928 * image has put garbage in it. The fix in this case is to clear the LCHS
4929 * geometry to trigger autodetection when it is used next. If the geometry
4930 * already says "please autodetect" (cylinders=0) keep it. */
4931 if ( ( pLCHS->cHeads > 255
4932 || pLCHS->cHeads == 0
4933 || pLCHS->cSectors > 63
4934 || pLCHS->cSectors == 0)
4935 && pLCHS->cCylinders != 0)
4936 {
4937 pLCHS->cCylinders = 0;
4938 pLCHS->cHeads = 0;
4939 pLCHS->cSectors = 0;
4940 }
4941 /* Always recompute the number of cylinders stored in the LCHS
4942 * geometry if it isn't set to "autotedetect" at the moment.
4943 * This is very useful if the destination image size is
4944 * larger or smaller than the source image size. Do not modify
4945 * the number of heads and sectors. Windows guests hate it. */
4946 if ( pLCHS->cCylinders != 0
4947 && pLCHS->cHeads != 0 /* paranoia */
4948 && pLCHS->cSectors != 0 /* paranoia */)
4949 {
4950 Assert(!(RT_MIN(cbSize / 512 / pLCHS->cHeads / pLCHS->cSectors, 1024) - (uint32_t)RT_MIN(cbSize / 512 / pLCHS->cHeads / pLCHS->cSectors, 1024)));
4951 pLCHS->cCylinders = (uint32_t)RT_MIN(cbSize / 512 / pLCHS->cHeads / pLCHS->cSectors, 1024);
4952 }
4953}
4954
4955/**
4956 * Sets the I/O callbacks of the given interface to the fallback methods
4957 *
4958 * @returns nothing.
4959 * @param pIfIo The I/O interface to setup.
4960 */
4961static void vdIfIoFallbackCallbacksSetup(PVDINTERFACEIO pIfIo)
4962{
4963 pIfIo->pfnOpen = vdIOOpenFallback;
4964 pIfIo->pfnClose = vdIOCloseFallback;
4965 pIfIo->pfnDelete = vdIODeleteFallback;
4966 pIfIo->pfnMove = vdIOMoveFallback;
4967 pIfIo->pfnGetFreeSpace = vdIOGetFreeSpaceFallback;
4968 pIfIo->pfnGetModificationTime = vdIOGetModificationTimeFallback;
4969 pIfIo->pfnGetSize = vdIOGetSizeFallback;
4970 pIfIo->pfnSetSize = vdIOSetSizeFallback;
4971 pIfIo->pfnSetAllocationSize = vdIOSetAllocationSizeFallback;
4972 pIfIo->pfnReadSync = vdIOReadSyncFallback;
4973 pIfIo->pfnWriteSync = vdIOWriteSyncFallback;
4974 pIfIo->pfnFlushSync = vdIOFlushSyncFallback;
4975 pIfIo->pfnReadAsync = vdIOReadAsyncFallback;
4976 pIfIo->pfnWriteAsync = vdIOWriteAsyncFallback;
4977 pIfIo->pfnFlushAsync = vdIOFlushAsyncFallback;
4978}
4979
4980/**
4981 * Sets the internal I/O callbacks of the given interface.
4982 *
4983 * @returns nothing.
4984 * @param pIfIoInt The internal I/O interface to setup.
4985 */
4986static void vdIfIoIntCallbacksSetup(PVDINTERFACEIOINT pIfIoInt)
4987{
4988 pIfIoInt->pfnOpen = vdIOIntOpen;
4989 pIfIoInt->pfnClose = vdIOIntClose;
4990 pIfIoInt->pfnDelete = vdIOIntDelete;
4991 pIfIoInt->pfnMove = vdIOIntMove;
4992 pIfIoInt->pfnGetFreeSpace = vdIOIntGetFreeSpace;
4993 pIfIoInt->pfnGetModificationTime = vdIOIntGetModificationTime;
4994 pIfIoInt->pfnGetSize = vdIOIntGetSize;
4995 pIfIoInt->pfnSetSize = vdIOIntSetSize;
4996 pIfIoInt->pfnSetAllocationSize = vdIOIntSetAllocationSize;
4997 pIfIoInt->pfnReadUser = vdIOIntReadUser;
4998 pIfIoInt->pfnWriteUser = vdIOIntWriteUser;
4999 pIfIoInt->pfnReadMeta = vdIOIntReadMeta;
5000 pIfIoInt->pfnWriteMeta = vdIOIntWriteMeta;
5001 pIfIoInt->pfnMetaXferRelease = vdIOIntMetaXferRelease;
5002 pIfIoInt->pfnFlush = vdIOIntFlush;
5003 pIfIoInt->pfnIoCtxCopyFrom = vdIOIntIoCtxCopyFrom;
5004 pIfIoInt->pfnIoCtxCopyTo = vdIOIntIoCtxCopyTo;
5005 pIfIoInt->pfnIoCtxSet = vdIOIntIoCtxSet;
5006 pIfIoInt->pfnIoCtxSegArrayCreate = vdIOIntIoCtxSegArrayCreate;
5007 pIfIoInt->pfnIoCtxCompleted = vdIOIntIoCtxCompleted;
5008 pIfIoInt->pfnIoCtxIsSynchronous = vdIOIntIoCtxIsSynchronous;
5009 pIfIoInt->pfnIoCtxIsZero = vdIOIntIoCtxIsZero;
5010 pIfIoInt->pfnIoCtxGetDataUnitSize = vdIOIntIoCtxGetDataUnitSize;
5011}
5012
5013/**
5014 * Internally used completion handler for synchronous I/O contexts.
5015 */
5016static DECLCALLBACK(void) vdIoCtxSyncComplete(void *pvUser1, void *pvUser2, int rcReq)
5017{
5018 RT_NOREF2(pvUser1, rcReq);
5019 RTSEMEVENT hEvent = (RTSEMEVENT)pvUser2;
5020
5021 RTSemEventSignal(hEvent);
5022}
5023
5024/**
5025 * Initializes HDD backends.
5026 *
5027 * @returns VBox status code.
5028 */
5029VBOXDDU_DECL(int) VDInit(void)
5030{
5031 int rc = vdPluginInit();
5032 LogRel(("VD: VDInit finished with %Rrc\n", rc));
5033 return rc;
5034}
5035
5036/**
5037 * Destroys loaded HDD backends.
5038 *
5039 * @returns VBox status code.
5040 */
5041VBOXDDU_DECL(int) VDShutdown(void)
5042{
5043 return vdPluginTerm();
5044}
5045
5046/**
5047 * Loads a single plugin given by filename.
5048 *
5049 * @returns VBox status code.
5050 * @param pszFilename The plugin filename to load.
5051 */
5052VBOXDDU_DECL(int) VDPluginLoadFromFilename(const char *pszFilename)
5053{
5054 if (!vdPluginIsInitialized())
5055 {
5056 int rc = VDInit();
5057 if (RT_FAILURE(rc))
5058 return rc;
5059 }
5060
5061 return vdPluginLoadFromFilename(pszFilename);
5062}
5063
5064/**
5065 * Load all plugins from a given path.
5066 *
5067 * @returns VBox statuse code.
5068 * @param pszPath The path to load plugins from.
5069 */
5070VBOXDDU_DECL(int) VDPluginLoadFromPath(const char *pszPath)
5071{
5072 if (!vdPluginIsInitialized())
5073 {
5074 int rc = VDInit();
5075 if (RT_FAILURE(rc))
5076 return rc;
5077 }
5078
5079 return vdPluginLoadFromPath(pszPath);
5080}
5081
5082/**
5083 * Unloads a single plugin given by filename.
5084 *
5085 * @returns VBox status code.
5086 * @param pszFilename The plugin filename to unload.
5087 */
5088VBOXDDU_DECL(int) VDPluginUnloadFromFilename(const char *pszFilename)
5089{
5090 if (!vdPluginIsInitialized())
5091 {
5092 int rc = VDInit();
5093 if (RT_FAILURE(rc))
5094 return rc;
5095 }
5096
5097 return vdPluginUnloadFromFilename(pszFilename);
5098}
5099
5100/**
5101 * Unload all plugins from a given path.
5102 *
5103 * @returns VBox statuse code.
5104 * @param pszPath The path to unload plugins from.
5105 */
5106VBOXDDU_DECL(int) VDPluginUnloadFromPath(const char *pszPath)
5107{
5108 if (!vdPluginIsInitialized())
5109 {
5110 int rc = VDInit();
5111 if (RT_FAILURE(rc))
5112 return rc;
5113 }
5114
5115 return vdPluginUnloadFromPath(pszPath);
5116}
5117
5118/**
5119 * Lists all HDD backends and their capabilities in a caller-provided buffer.
5120 *
5121 * @returns VBox status code.
5122 * VERR_BUFFER_OVERFLOW if not enough space is passed.
5123 * @param cEntriesAlloc Number of list entries available.
5124 * @param pEntries Pointer to array for the entries.
5125 * @param pcEntriesUsed Number of entries returned.
5126 */
5127VBOXDDU_DECL(int) VDBackendInfo(unsigned cEntriesAlloc, PVDBACKENDINFO pEntries,
5128 unsigned *pcEntriesUsed)
5129{
5130 int rc = VINF_SUCCESS;
5131
5132 LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
5133 /* Check arguments. */
5134 AssertMsgReturn(cEntriesAlloc,
5135 ("cEntriesAlloc=%u\n", cEntriesAlloc),
5136 VERR_INVALID_PARAMETER);
5137 AssertMsgReturn(VALID_PTR(pEntries),
5138 ("pEntries=%#p\n", pEntries),
5139 VERR_INVALID_PARAMETER);
5140 AssertMsgReturn(VALID_PTR(pcEntriesUsed),
5141 ("pcEntriesUsed=%#p\n", pcEntriesUsed),
5142 VERR_INVALID_PARAMETER);
5143 if (!vdPluginIsInitialized())
5144 VDInit();
5145
5146 uint32_t cBackends = vdGetImageBackendCount();
5147 if (cEntriesAlloc < cBackends)
5148 {
5149 *pcEntriesUsed = cBackends;
5150 return VERR_BUFFER_OVERFLOW;
5151 }
5152
5153 for (unsigned i = 0; i < cBackends; i++)
5154 {
5155 PCVDIMAGEBACKEND pBackend;
5156 rc = vdQueryImageBackend(i, &pBackend);
5157 AssertRC(rc);
5158
5159 pEntries[i].pszBackend = pBackend->pszBackendName;
5160 pEntries[i].uBackendCaps = pBackend->uBackendCaps;
5161 pEntries[i].paFileExtensions = pBackend->paFileExtensions;
5162 pEntries[i].paConfigInfo = pBackend->paConfigInfo;
5163 pEntries[i].pfnComposeLocation = pBackend->pfnComposeLocation;
5164 pEntries[i].pfnComposeName = pBackend->pfnComposeName;
5165 }
5166
5167 LogFlowFunc(("returns %Rrc *pcEntriesUsed=%u\n", rc, cBackends));
5168 *pcEntriesUsed = cBackends;
5169 return rc;
5170}
5171
5172/**
5173 * Lists the capabilities of a backend identified by its name.
5174 *
5175 * @returns VBox status code.
5176 * @param pszBackend The backend name.
5177 * @param pEntry Pointer to an entry.
5178 */
5179VBOXDDU_DECL(int) VDBackendInfoOne(const char *pszBackend, PVDBACKENDINFO pEntry)
5180{
5181 LogFlowFunc(("pszBackend=%#p pEntry=%#p\n", pszBackend, pEntry));
5182 /* Check arguments. */
5183 AssertMsgReturn(VALID_PTR(pszBackend),
5184 ("pszBackend=%#p\n", pszBackend),
5185 VERR_INVALID_PARAMETER);
5186 AssertMsgReturn(VALID_PTR(pEntry),
5187 ("pEntry=%#p\n", pEntry),
5188 VERR_INVALID_PARAMETER);
5189 if (!vdPluginIsInitialized())
5190 VDInit();
5191
5192 PCVDIMAGEBACKEND pBackend;
5193 int rc = vdFindImageBackend(pszBackend, &pBackend);
5194 if (RT_SUCCESS(rc))
5195 {
5196 pEntry->pszBackend = pBackend->pszBackendName;
5197 pEntry->uBackendCaps = pBackend->uBackendCaps;
5198 pEntry->paFileExtensions = pBackend->paFileExtensions;
5199 pEntry->paConfigInfo = pBackend->paConfigInfo;
5200 }
5201
5202 return rc;
5203}
5204
5205/**
5206 * Lists all filters and their capabilities in a caller-provided buffer.
5207 *
5208 * @return VBox status code.
5209 * VERR_BUFFER_OVERFLOW if not enough space is passed.
5210 * @param cEntriesAlloc Number of list entries available.
5211 * @param pEntries Pointer to array for the entries.
5212 * @param pcEntriesUsed Number of entries returned.
5213 */
5214VBOXDDU_DECL(int) VDFilterInfo(unsigned cEntriesAlloc, PVDFILTERINFO pEntries,
5215 unsigned *pcEntriesUsed)
5216{
5217 int rc = VINF_SUCCESS;
5218
5219 LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
5220 /* Check arguments. */
5221 AssertMsgReturn(cEntriesAlloc,
5222 ("cEntriesAlloc=%u\n", cEntriesAlloc),
5223 VERR_INVALID_PARAMETER);
5224 AssertMsgReturn(VALID_PTR(pEntries),
5225 ("pEntries=%#p\n", pEntries),
5226 VERR_INVALID_PARAMETER);
5227 AssertMsgReturn(VALID_PTR(pcEntriesUsed),
5228 ("pcEntriesUsed=%#p\n", pcEntriesUsed),
5229 VERR_INVALID_PARAMETER);
5230 if (!vdPluginIsInitialized())
5231 VDInit();
5232
5233 uint32_t cBackends = vdGetFilterBackendCount();
5234 if (cEntriesAlloc < cBackends)
5235 {
5236 *pcEntriesUsed = cBackends;
5237 return VERR_BUFFER_OVERFLOW;
5238 }
5239
5240 for (unsigned i = 0; i < cBackends; i++)
5241 {
5242 PCVDFILTERBACKEND pBackend;
5243 rc = vdQueryFilterBackend(i, &pBackend);
5244 pEntries[i].pszFilter = pBackend->pszBackendName;
5245 pEntries[i].paConfigInfo = pBackend->paConfigInfo;
5246 }
5247
5248 LogFlowFunc(("returns %Rrc *pcEntriesUsed=%u\n", rc, cBackends));
5249 *pcEntriesUsed = cBackends;
5250 return rc;
5251}
5252
5253/**
5254 * Lists the capabilities of a filter identified by its name.
5255 *
5256 * @return VBox status code.
5257 * @param pszFilter The filter name (case insensitive).
5258 * @param pEntry Pointer to an entry.
5259 */
5260VBOXDDU_DECL(int) VDFilterInfoOne(const char *pszFilter, PVDFILTERINFO pEntry)
5261{
5262 LogFlowFunc(("pszFilter=%#p pEntry=%#p\n", pszFilter, pEntry));
5263 /* Check arguments. */
5264 AssertMsgReturn(VALID_PTR(pszFilter),
5265 ("pszFilter=%#p\n", pszFilter),
5266 VERR_INVALID_PARAMETER);
5267 AssertMsgReturn(VALID_PTR(pEntry),
5268 ("pEntry=%#p\n", pEntry),
5269 VERR_INVALID_PARAMETER);
5270 if (!vdPluginIsInitialized())
5271 VDInit();
5272
5273 PCVDFILTERBACKEND pBackend;
5274 int rc = vdFindFilterBackend(pszFilter, &pBackend);
5275 if (RT_SUCCESS(rc))
5276 {
5277 pEntry->pszFilter = pBackend->pszBackendName;
5278 pEntry->paConfigInfo = pBackend->paConfigInfo;
5279 }
5280
5281 return rc;
5282}
5283
5284/**
5285 * Allocates and initializes an empty HDD container.
5286 * No image files are opened.
5287 *
5288 * @returns VBox status code.
5289 * @param pVDIfsDisk Pointer to the per-disk VD interface list.
5290 * @param enmType Type of the image container.
5291 * @param ppDisk Where to store the reference to HDD container.
5292 */
5293VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, VDTYPE enmType, PVDISK *ppDisk)
5294{
5295 int rc = VINF_SUCCESS;
5296 PVDISK pDisk = NULL;
5297
5298 LogFlowFunc(("pVDIfsDisk=%#p\n", pVDIfsDisk));
5299 do
5300 {
5301 /* Check arguments. */
5302 AssertMsgBreakStmt(VALID_PTR(ppDisk),
5303 ("ppDisk=%#p\n", ppDisk),
5304 rc = VERR_INVALID_PARAMETER);
5305
5306 pDisk = (PVDISK)RTMemAllocZ(sizeof(VDISK));
5307 if (pDisk)
5308 {
5309 pDisk->u32Signature = VDISK_SIGNATURE;
5310 pDisk->enmType = enmType;
5311 pDisk->cImages = 0;
5312 pDisk->pBase = NULL;
5313 pDisk->pLast = NULL;
5314 pDisk->cbSize = 0;
5315 pDisk->PCHSGeometry.cCylinders = 0;
5316 pDisk->PCHSGeometry.cHeads = 0;
5317 pDisk->PCHSGeometry.cSectors = 0;
5318 pDisk->LCHSGeometry.cCylinders = 0;
5319 pDisk->LCHSGeometry.cHeads = 0;
5320 pDisk->LCHSGeometry.cSectors = 0;
5321 pDisk->pVDIfsDisk = pVDIfsDisk;
5322 pDisk->pInterfaceError = NULL;
5323 pDisk->pInterfaceThreadSync = NULL;
5324 pDisk->pIoCtxLockOwner = NULL;
5325 pDisk->pIoCtxHead = NULL;
5326 pDisk->fLocked = false;
5327 pDisk->hMemCacheIoCtx = NIL_RTMEMCACHE;
5328 pDisk->hMemCacheIoTask = NIL_RTMEMCACHE;
5329 RTListInit(&pDisk->ListFilterChainWrite);
5330 RTListInit(&pDisk->ListFilterChainRead);
5331
5332 /* Create the I/O ctx cache */
5333 rc = RTMemCacheCreate(&pDisk->hMemCacheIoCtx, sizeof(VDIOCTX), 0, UINT32_MAX,
5334 NULL, NULL, NULL, 0);
5335 if (RT_FAILURE(rc))
5336 break;
5337
5338 /* Create the I/O task cache */
5339 rc = RTMemCacheCreate(&pDisk->hMemCacheIoTask, sizeof(VDIOTASK), 0, UINT32_MAX,
5340 NULL, NULL, NULL, 0);
5341 if (RT_FAILURE(rc))
5342 break;
5343
5344 pDisk->pInterfaceError = VDIfErrorGet(pVDIfsDisk);
5345 pDisk->pInterfaceThreadSync = VDIfThreadSyncGet(pVDIfsDisk);
5346
5347 *ppDisk = pDisk;
5348 }
5349 else
5350 {
5351 rc = VERR_NO_MEMORY;
5352 break;
5353 }
5354 } while (0);
5355
5356 if ( RT_FAILURE(rc)
5357 && pDisk)
5358 {
5359 if (pDisk->hMemCacheIoCtx != NIL_RTMEMCACHE)
5360 RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
5361 if (pDisk->hMemCacheIoTask != NIL_RTMEMCACHE)
5362 RTMemCacheDestroy(pDisk->hMemCacheIoTask);
5363 }
5364
5365 LogFlowFunc(("returns %Rrc (pDisk=%#p)\n", rc, pDisk));
5366 return rc;
5367}
5368
5369/**
5370 * Destroys HDD container.
5371 * If container has opened image files they will be closed.
5372 *
5373 * @returns VBox status code.
5374 * @param pDisk Pointer to HDD container.
5375 */
5376VBOXDDU_DECL(int) VDDestroy(PVDISK pDisk)
5377{
5378 int rc = VINF_SUCCESS;
5379 LogFlowFunc(("pDisk=%#p\n", pDisk));
5380 do
5381 {
5382 /* sanity check */
5383 AssertPtrBreak(pDisk);
5384 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
5385 Assert(!pDisk->fLocked);
5386
5387 rc = VDCloseAll(pDisk);
5388 int rc2 = VDFilterRemoveAll(pDisk);
5389 if (RT_SUCCESS(rc))
5390 rc = rc2;
5391
5392 RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
5393 RTMemCacheDestroy(pDisk->hMemCacheIoTask);
5394 RTMemFree(pDisk);
5395 } while (0);
5396 LogFlowFunc(("returns %Rrc\n", rc));
5397 return rc;
5398}
5399
5400/**
5401 * Try to get the backend name which can use this image.
5402 *
5403 * @returns VBox status code.
5404 * VINF_SUCCESS if a plugin was found.
5405 * ppszFormat contains the string which can be used as backend name.
5406 * VERR_NOT_SUPPORTED if no backend was found.
5407 * @param pVDIfsDisk Pointer to the per-disk VD interface list.
5408 * @param pVDIfsImage Pointer to the per-image VD interface list.
5409 * @param pszFilename Name of the image file for which the backend is queried.
5410 * @param enmDesiredType The desired image type, VDTYPE_INVALID if anything goes.
5411 * @param ppszFormat Receives pointer of the UTF-8 string which contains the format name.
5412 * The returned pointer must be freed using RTStrFree().
5413 * @param penmType Where to store the type of the image.
5414 */
5415VBOXDDU_DECL(int) VDGetFormat(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
5416 const char *pszFilename, VDTYPE enmDesiredType,
5417 char **ppszFormat, VDTYPE *penmType)
5418{
5419 int rc = VERR_NOT_SUPPORTED;
5420 VDINTERFACEIOINT VDIfIoInt;
5421 VDINTERFACEIO VDIfIoFallback;
5422 PVDINTERFACEIO pInterfaceIo;
5423
5424 LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
5425 /* Check arguments. */
5426 AssertMsgReturn(VALID_PTR(pszFilename) && *pszFilename,
5427 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
5428 VERR_INVALID_PARAMETER);
5429 AssertMsgReturn(VALID_PTR(ppszFormat),
5430 ("ppszFormat=%#p\n", ppszFormat),
5431 VERR_INVALID_PARAMETER);
5432 AssertMsgReturn(VALID_PTR(penmType),
5433 ("penmType=%#p\n", penmType),
5434 VERR_INVALID_PARAMETER);
5435 AssertReturn(enmDesiredType >= VDTYPE_INVALID && enmDesiredType <= VDTYPE_FLOPPY, VERR_INVALID_PARAMETER);
5436
5437 if (!vdPluginIsInitialized())
5438 VDInit();
5439
5440 pInterfaceIo = VDIfIoGet(pVDIfsImage);
5441 if (!pInterfaceIo)
5442 {
5443 /*
5444 * Caller doesn't provide an I/O interface, create our own using the
5445 * native file API.
5446 */
5447 vdIfIoFallbackCallbacksSetup(&VDIfIoFallback);
5448 pInterfaceIo = &VDIfIoFallback;
5449 }
5450
5451 /* Set up the internal I/O interface. */
5452 AssertReturn(!VDIfIoIntGet(pVDIfsImage), VERR_INVALID_PARAMETER);
5453 VDIfIoInt.pfnOpen = vdIOIntOpenLimited;
5454 VDIfIoInt.pfnClose = vdIOIntCloseLimited;
5455 VDIfIoInt.pfnDelete = vdIOIntDeleteLimited;
5456 VDIfIoInt.pfnMove = vdIOIntMoveLimited;
5457 VDIfIoInt.pfnGetFreeSpace = vdIOIntGetFreeSpaceLimited;
5458 VDIfIoInt.pfnGetModificationTime = vdIOIntGetModificationTimeLimited;
5459 VDIfIoInt.pfnGetSize = vdIOIntGetSizeLimited;
5460 VDIfIoInt.pfnSetSize = vdIOIntSetSizeLimited;
5461 VDIfIoInt.pfnReadUser = vdIOIntReadUserLimited;
5462 VDIfIoInt.pfnWriteUser = vdIOIntWriteUserLimited;
5463 VDIfIoInt.pfnReadMeta = vdIOIntReadMetaLimited;
5464 VDIfIoInt.pfnWriteMeta = vdIOIntWriteMetaLimited;
5465 VDIfIoInt.pfnFlush = vdIOIntFlushLimited;
5466 rc = VDInterfaceAdd(&VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
5467 pInterfaceIo, sizeof(VDINTERFACEIOINT), &pVDIfsImage);
5468 AssertRC(rc);
5469
5470 /** @todo r=bird: Would be better to do a scoring approach here, where the
5471 * backend that scores the highest is choosen. That way we don't have to depend
5472 * on registration order and filename suffixes to figure out what RAW should
5473 * handle and not. Besides, the registration order won't cut it for plug-ins
5474 * anyway, as they end up after the builtin ones.
5475 */
5476
5477 /* Find the backend supporting this file format. */
5478 for (unsigned i = 0; i < vdGetImageBackendCount(); i++)
5479 {
5480 PCVDIMAGEBACKEND pBackend;
5481 rc = vdQueryImageBackend(i, &pBackend);
5482 AssertRC(rc);
5483
5484 if (pBackend->pfnProbe)
5485 {
5486 rc = pBackend->pfnProbe(pszFilename, pVDIfsDisk, pVDIfsImage, enmDesiredType, penmType);
5487 if ( RT_SUCCESS(rc)
5488 /* The correct backend has been found, but there is a small
5489 * incompatibility so that the file cannot be used. Stop here
5490 * and signal success - the actual open will of course fail,
5491 * but that will create a really sensible error message. */
5492
5493 /** @todo r=bird: this bit of code is _certifiably_ _insane_ as it allows
5494 * simple stuff like VERR_EOF to pass thru. I've just amended it with
5495 * disallowing VERR_EOF too, but someone needs to pick up the courage to
5496 * fix this stuff properly or at least update the docs!
5497 * (Parallels returns VERR_EOF, btw.) */
5498
5499 || ( rc != VERR_VD_GEN_INVALID_HEADER
5500 && rc != VERR_VD_VDI_INVALID_HEADER
5501 && rc != VERR_VD_VMDK_INVALID_HEADER
5502 && rc != VERR_VD_ISCSI_INVALID_HEADER
5503 && rc != VERR_VD_VHD_INVALID_HEADER
5504 && rc != VERR_VD_RAW_INVALID_HEADER
5505 && rc != VERR_VD_RAW_SIZE_MODULO_512
5506 && rc != VERR_VD_RAW_SIZE_MODULO_2048
5507 && rc != VERR_VD_RAW_SIZE_OPTICAL_TOO_SMALL
5508 && rc != VERR_VD_RAW_SIZE_FLOPPY_TOO_BIG
5509 && rc != VERR_VD_PARALLELS_INVALID_HEADER
5510 && rc != VERR_VD_DMG_INVALID_HEADER
5511 && rc != VERR_EOF /* bird for viso */
5512 ))
5513 {
5514 /* Copy the name into the new string. */
5515 char *pszFormat = RTStrDup(pBackend->pszBackendName);
5516 if (!pszFormat)
5517 {
5518 rc = VERR_NO_MEMORY;
5519 break;
5520 }
5521 *ppszFormat = pszFormat;
5522 /* Do not consider the typical file access errors as success,
5523 * which allows the caller to deal with such issues. */
5524 if ( rc != VERR_ACCESS_DENIED
5525 && rc != VERR_PATH_NOT_FOUND
5526 && rc != VERR_FILE_NOT_FOUND)
5527 rc = VINF_SUCCESS;
5528 break;
5529 }
5530 rc = VERR_NOT_SUPPORTED;
5531 }
5532 }
5533
5534 /* Try the cache backends. */
5535 if (rc == VERR_NOT_SUPPORTED)
5536 {
5537 for (unsigned i = 0; i < vdGetCacheBackendCount(); i++)
5538 {
5539 PCVDCACHEBACKEND pBackend;
5540 rc = vdQueryCacheBackend(i, &pBackend);
5541 AssertRC(rc);
5542
5543 if (pBackend->pfnProbe)
5544 {
5545 rc = pBackend->pfnProbe(pszFilename, pVDIfsDisk, pVDIfsImage);
5546 if ( RT_SUCCESS(rc)
5547 || (rc != VERR_VD_GEN_INVALID_HEADER))
5548 {
5549 /* Copy the name into the new string. */
5550 char *pszFormat = RTStrDup(pBackend->pszBackendName);
5551 if (!pszFormat)
5552 {
5553 rc = VERR_NO_MEMORY;
5554 break;
5555 }
5556 *ppszFormat = pszFormat;
5557 rc = VINF_SUCCESS;
5558 break;
5559 }
5560 rc = VERR_NOT_SUPPORTED;
5561 }
5562 }
5563 }
5564
5565 LogFlowFunc(("returns %Rrc *ppszFormat=\"%s\"\n", rc, *ppszFormat));
5566 return rc;
5567}
5568
5569/**
5570 * Opens an image file.
5571 *
5572 * The first opened image file in HDD container must have a base image type,
5573 * others (next opened images) must be a differencing or undo images.
5574 * Linkage is checked for differencing image to be in consistence with the previously opened image.
5575 * When another differencing image is opened and the last image was opened in read/write access
5576 * mode, then the last image is reopened in read-only with deny write sharing mode. This allows
5577 * other processes to use images in read-only mode too.
5578 *
5579 * Note that the image is opened in read-only mode if a read/write open is not possible.
5580 * Use VDIsReadOnly to check open mode.
5581 *
5582 * @returns VBox status code.
5583 * @param pDisk Pointer to HDD container.
5584 * @param pszBackend Name of the image file backend to use.
5585 * @param pszFilename Name of the image file to open.
5586 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
5587 * @param pVDIfsImage Pointer to the per-image VD interface list.
5588 */
5589VBOXDDU_DECL(int) VDOpen(PVDISK pDisk, const char *pszBackend,
5590 const char *pszFilename, unsigned uOpenFlags,
5591 PVDINTERFACE pVDIfsImage)
5592{
5593 int rc = VINF_SUCCESS;
5594 int rc2;
5595 bool fLockWrite = false;
5596 PVDIMAGE pImage = NULL;
5597
5598 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsImage=%#p\n",
5599 pDisk, pszBackend, pszFilename, uOpenFlags, pVDIfsImage));
5600
5601 do
5602 {
5603 /* sanity check */
5604 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
5605 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
5606
5607 /* Check arguments. */
5608 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
5609 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
5610 rc = VERR_INVALID_PARAMETER);
5611 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
5612 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
5613 rc = VERR_INVALID_PARAMETER);
5614 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
5615 ("uOpenFlags=%#x\n", uOpenFlags),
5616 rc = VERR_INVALID_PARAMETER);
5617 AssertMsgBreakStmt( !(uOpenFlags & VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)
5618 || (uOpenFlags & VD_OPEN_FLAGS_READONLY),
5619 ("uOpenFlags=%#x\n", uOpenFlags),
5620 rc = VERR_INVALID_PARAMETER);
5621
5622 /*
5623 * Destroy the current discard state first which might still have pending blocks
5624 * for the currently opened image which will be switched to readonly mode.
5625 */
5626 /* Lock disk for writing, as we modify pDisk information below. */
5627 rc2 = vdThreadStartWrite(pDisk);
5628 AssertRC(rc2);
5629 fLockWrite = true;
5630 rc = vdDiscardStateDestroy(pDisk);
5631 if (RT_FAILURE(rc))
5632 break;
5633 rc2 = vdThreadFinishWrite(pDisk);
5634 AssertRC(rc2);
5635 fLockWrite = false;
5636
5637 /* Set up image descriptor. */
5638 pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
5639 if (!pImage)
5640 {
5641 rc = VERR_NO_MEMORY;
5642 break;
5643 }
5644 pImage->pszFilename = RTStrDup(pszFilename);
5645 if (!pImage->pszFilename)
5646 {
5647 rc = VERR_NO_MEMORY;
5648 break;
5649 }
5650
5651 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
5652 pImage->VDIo.pDisk = pDisk;
5653 pImage->pVDIfsImage = pVDIfsImage;
5654
5655 rc = vdFindImageBackend(pszBackend, &pImage->Backend);
5656 if (RT_FAILURE(rc))
5657 break;
5658 if (!pImage->Backend)
5659 {
5660 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
5661 N_("VD: unknown backend name '%s'"), pszBackend);
5662 break;
5663 }
5664
5665 /*
5666 * Fail if the backend can't do async I/O but the
5667 * flag is set.
5668 */
5669 if ( !(pImage->Backend->uBackendCaps & VD_CAP_ASYNC)
5670 && (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO))
5671 {
5672 rc = vdError(pDisk, VERR_NOT_SUPPORTED, RT_SRC_POS,
5673 N_("VD: Backend '%s' does not support async I/O"), pszBackend);
5674 break;
5675 }
5676
5677 /*
5678 * Fail if the backend doesn't support the discard operation but the
5679 * flag is set.
5680 */
5681 if ( !(pImage->Backend->uBackendCaps & VD_CAP_DISCARD)
5682 && (uOpenFlags & VD_OPEN_FLAGS_DISCARD))
5683 {
5684 rc = vdError(pDisk, VERR_VD_DISCARD_NOT_SUPPORTED, RT_SRC_POS,
5685 N_("VD: Backend '%s' does not support discard"), pszBackend);
5686 break;
5687 }
5688
5689 /* Set up the I/O interface. */
5690 pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
5691 if (!pImage->VDIo.pInterfaceIo)
5692 {
5693 vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
5694 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
5695 pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
5696 pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
5697 }
5698
5699 /* Set up the internal I/O interface. */
5700 AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
5701 vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
5702 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
5703 &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
5704 AssertRC(rc);
5705
5706 pImage->uOpenFlags = uOpenFlags & (VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_DISCARD | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS);
5707 pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
5708 rc = pImage->Backend->pfnOpen(pImage->pszFilename,
5709 uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS),
5710 pDisk->pVDIfsDisk,
5711 pImage->pVDIfsImage,
5712 pDisk->enmType,
5713 &pImage->pBackendData);
5714 /*
5715 * If the image is corrupted and there is a repair method try to repair it
5716 * first if it was openend in read-write mode and open again afterwards.
5717 */
5718 if ( RT_UNLIKELY(rc == VERR_VD_IMAGE_CORRUPTED)
5719 && !(uOpenFlags & VD_OPEN_FLAGS_READONLY)
5720 && pImage->Backend->pfnRepair)
5721 {
5722 rc = pImage->Backend->pfnRepair(pszFilename, pDisk->pVDIfsDisk, pImage->pVDIfsImage, 0 /* fFlags */);
5723 if (RT_SUCCESS(rc))
5724 rc = pImage->Backend->pfnOpen(pImage->pszFilename,
5725 uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS),
5726 pDisk->pVDIfsDisk,
5727 pImage->pVDIfsImage,
5728 pDisk->enmType,
5729 &pImage->pBackendData);
5730 else
5731 {
5732 rc = vdError(pDisk, rc, RT_SRC_POS,
5733 N_("VD: error %Rrc repairing corrupted image file '%s'"), rc, pszFilename);
5734 break;
5735 }
5736 }
5737 else if (RT_UNLIKELY(rc == VERR_VD_IMAGE_CORRUPTED))
5738 {
5739 rc = vdError(pDisk, rc, RT_SRC_POS,
5740 N_("VD: Image file '%s' is corrupted and can't be opened"), pszFilename);
5741 break;
5742 }
5743
5744 /* If the open in read-write mode failed, retry in read-only mode. */
5745 if (RT_FAILURE(rc))
5746 {
5747 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY)
5748 && ( rc == VERR_ACCESS_DENIED
5749 || rc == VERR_PERMISSION_DENIED
5750 || rc == VERR_WRITE_PROTECT
5751 || rc == VERR_SHARING_VIOLATION
5752 || rc == VERR_FILE_LOCK_FAILED))
5753 rc = pImage->Backend->pfnOpen(pImage->pszFilename,
5754 (uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS))
5755 | VD_OPEN_FLAGS_READONLY,
5756 pDisk->pVDIfsDisk,
5757 pImage->pVDIfsImage,
5758 pDisk->enmType,
5759 &pImage->pBackendData);
5760 if (RT_FAILURE(rc))
5761 {
5762 rc = vdError(pDisk, rc, RT_SRC_POS,
5763 N_("VD: error %Rrc opening image file '%s'"), rc, pszFilename);
5764 break;
5765 }
5766 }
5767
5768 /* Lock disk for writing, as we modify pDisk information below. */
5769 rc2 = vdThreadStartWrite(pDisk);
5770 AssertRC(rc2);
5771 fLockWrite = true;
5772
5773 pImage->VDIo.pBackendData = pImage->pBackendData;
5774
5775 /* Check image type. As the image itself has only partial knowledge
5776 * whether it's a base image or not, this info is derived here. The
5777 * base image can be fixed or normal, all others must be normal or
5778 * diff images. Some image formats don't distinguish between normal
5779 * and diff images, so this must be corrected here. */
5780 unsigned uImageFlags;
5781 uImageFlags = pImage->Backend->pfnGetImageFlags(pImage->pBackendData);
5782 if (RT_FAILURE(rc))
5783 uImageFlags = VD_IMAGE_FLAGS_NONE;
5784 if ( RT_SUCCESS(rc)
5785 && !(uOpenFlags & VD_OPEN_FLAGS_INFO))
5786 {
5787 if ( pDisk->cImages == 0
5788 && (uImageFlags & VD_IMAGE_FLAGS_DIFF))
5789 {
5790 rc = VERR_VD_INVALID_TYPE;
5791 break;
5792 }
5793 else if (pDisk->cImages != 0)
5794 {
5795 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
5796 {
5797 rc = VERR_VD_INVALID_TYPE;
5798 break;
5799 }
5800 else
5801 uImageFlags |= VD_IMAGE_FLAGS_DIFF;
5802 }
5803 }
5804
5805 /* Ensure we always get correct diff information, even if the backend
5806 * doesn't actually have a stored flag for this. It must not return
5807 * bogus information for the parent UUID if it is not a diff image. */
5808 RTUUID parentUuid;
5809 RTUuidClear(&parentUuid);
5810 rc2 = pImage->Backend->pfnGetParentUuid(pImage->pBackendData, &parentUuid);
5811 if (RT_SUCCESS(rc2) && !RTUuidIsNull(&parentUuid))
5812 uImageFlags |= VD_IMAGE_FLAGS_DIFF;
5813
5814 pImage->uImageFlags = uImageFlags;
5815
5816 /* Force sane optimization settings. It's not worth avoiding writes
5817 * to fixed size images. The overhead would have almost no payback. */
5818 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
5819 pImage->uOpenFlags |= VD_OPEN_FLAGS_HONOR_SAME;
5820
5821 /** @todo optionally check UUIDs */
5822
5823 /* Cache disk information. */
5824 pDisk->cbSize = vdImageGetSize(pImage);
5825
5826 /* Cache PCHS geometry. */
5827 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
5828 &pDisk->PCHSGeometry);
5829 if (RT_FAILURE(rc2))
5830 {
5831 pDisk->PCHSGeometry.cCylinders = 0;
5832 pDisk->PCHSGeometry.cHeads = 0;
5833 pDisk->PCHSGeometry.cSectors = 0;
5834 }
5835 else
5836 {
5837 /* Make sure the PCHS geometry is properly clipped. */
5838 pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
5839 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
5840 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
5841 }
5842
5843 /* Cache LCHS geometry. */
5844 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
5845 &pDisk->LCHSGeometry);
5846 if (RT_FAILURE(rc2))
5847 {
5848 pDisk->LCHSGeometry.cCylinders = 0;
5849 pDisk->LCHSGeometry.cHeads = 0;
5850 pDisk->LCHSGeometry.cSectors = 0;
5851 }
5852 else
5853 {
5854 /* Make sure the LCHS geometry is properly clipped. */
5855 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
5856 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
5857 }
5858
5859 if (pDisk->cImages != 0)
5860 {
5861 /* Switch previous image to read-only mode. */
5862 unsigned uOpenFlagsPrevImg;
5863 uOpenFlagsPrevImg = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
5864 if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
5865 {
5866 uOpenFlagsPrevImg |= VD_OPEN_FLAGS_READONLY;
5867 rc = pDisk->pLast->Backend->pfnSetOpenFlags(pDisk->pLast->pBackendData, uOpenFlagsPrevImg);
5868 }
5869 }
5870
5871 if (RT_SUCCESS(rc))
5872 {
5873 /* Image successfully opened, make it the last image. */
5874 vdAddImageToList(pDisk, pImage);
5875 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
5876 pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
5877 }
5878 else
5879 {
5880 /* Error detected, but image opened. Close image. */
5881 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, false);
5882 AssertRC(rc2);
5883 pImage->pBackendData = NULL;
5884 }
5885 } while (0);
5886
5887 if (RT_UNLIKELY(fLockWrite))
5888 {
5889 rc2 = vdThreadFinishWrite(pDisk);
5890 AssertRC(rc2);
5891 }
5892
5893 if (RT_FAILURE(rc))
5894 {
5895 if (pImage)
5896 {
5897 if (pImage->pszFilename)
5898 RTStrFree(pImage->pszFilename);
5899 RTMemFree(pImage);
5900 }
5901 }
5902
5903 LogFlowFunc(("returns %Rrc\n", rc));
5904 return rc;
5905}
5906
5907/**
5908 * Opens a cache image.
5909 *
5910 * @return VBox status code.
5911 * @param pDisk Pointer to the HDD container which should use the cache image.
5912 * @param pszBackend Name of the cache file backend to use (case insensitive).
5913 * @param pszFilename Name of the cache image to open.
5914 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
5915 * @param pVDIfsCache Pointer to the per-cache VD interface list.
5916 */
5917VBOXDDU_DECL(int) VDCacheOpen(PVDISK pDisk, const char *pszBackend,
5918 const char *pszFilename, unsigned uOpenFlags,
5919 PVDINTERFACE pVDIfsCache)
5920{
5921 int rc = VINF_SUCCESS;
5922 int rc2;
5923 bool fLockWrite = false;
5924 PVDCACHE pCache = NULL;
5925
5926 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsCache=%#p\n",
5927 pDisk, pszBackend, pszFilename, uOpenFlags, pVDIfsCache));
5928
5929 do
5930 {
5931 /* sanity check */
5932 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
5933 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
5934
5935 /* Check arguments. */
5936 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
5937 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
5938 rc = VERR_INVALID_PARAMETER);
5939 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
5940 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
5941 rc = VERR_INVALID_PARAMETER);
5942 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
5943 ("uOpenFlags=%#x\n", uOpenFlags),
5944 rc = VERR_INVALID_PARAMETER);
5945
5946 /* Set up image descriptor. */
5947 pCache = (PVDCACHE)RTMemAllocZ(sizeof(VDCACHE));
5948 if (!pCache)
5949 {
5950 rc = VERR_NO_MEMORY;
5951 break;
5952 }
5953 pCache->pszFilename = RTStrDup(pszFilename);
5954 if (!pCache->pszFilename)
5955 {
5956 rc = VERR_NO_MEMORY;
5957 break;
5958 }
5959
5960 pCache->VDIo.pDisk = pDisk;
5961 pCache->pVDIfsCache = pVDIfsCache;
5962
5963 rc = vdFindCacheBackend(pszBackend, &pCache->Backend);
5964 if (RT_FAILURE(rc))
5965 break;
5966 if (!pCache->Backend)
5967 {
5968 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
5969 N_("VD: unknown backend name '%s'"), pszBackend);
5970 break;
5971 }
5972
5973 /* Set up the I/O interface. */
5974 pCache->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsCache);
5975 if (!pCache->VDIo.pInterfaceIo)
5976 {
5977 vdIfIoFallbackCallbacksSetup(&pCache->VDIo.VDIfIo);
5978 rc = VDInterfaceAdd(&pCache->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
5979 pDisk, sizeof(VDINTERFACEIO), &pVDIfsCache);
5980 pCache->VDIo.pInterfaceIo = &pCache->VDIo.VDIfIo;
5981 }
5982
5983 /* Set up the internal I/O interface. */
5984 AssertBreakStmt(!VDIfIoIntGet(pVDIfsCache), rc = VERR_INVALID_PARAMETER);
5985 vdIfIoIntCallbacksSetup(&pCache->VDIo.VDIfIoInt);
5986 rc = VDInterfaceAdd(&pCache->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
5987 &pCache->VDIo, sizeof(VDINTERFACEIOINT), &pCache->pVDIfsCache);
5988 AssertRC(rc);
5989
5990 pCache->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
5991 rc = pCache->Backend->pfnOpen(pCache->pszFilename,
5992 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
5993 pDisk->pVDIfsDisk,
5994 pCache->pVDIfsCache,
5995 &pCache->pBackendData);
5996 /* If the open in read-write mode failed, retry in read-only mode. */
5997 if (RT_FAILURE(rc))
5998 {
5999 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY)
6000 && ( rc == VERR_ACCESS_DENIED
6001 || rc == VERR_PERMISSION_DENIED
6002 || rc == VERR_WRITE_PROTECT
6003 || rc == VERR_SHARING_VIOLATION
6004 || rc == VERR_FILE_LOCK_FAILED))
6005 rc = pCache->Backend->pfnOpen(pCache->pszFilename,
6006 (uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME)
6007 | VD_OPEN_FLAGS_READONLY,
6008 pDisk->pVDIfsDisk,
6009 pCache->pVDIfsCache,
6010 &pCache->pBackendData);
6011 if (RT_FAILURE(rc))
6012 {
6013 rc = vdError(pDisk, rc, RT_SRC_POS,
6014 N_("VD: error %Rrc opening image file '%s'"), rc, pszFilename);
6015 break;
6016 }
6017 }
6018
6019 /* Lock disk for writing, as we modify pDisk information below. */
6020 rc2 = vdThreadStartWrite(pDisk);
6021 AssertRC(rc2);
6022 fLockWrite = true;
6023
6024 /*
6025 * Check that the modification UUID of the cache and last image
6026 * match. If not the image was modified in-between without the cache.
6027 * The cache might contain stale data.
6028 */
6029 RTUUID UuidImage, UuidCache;
6030
6031 rc = pCache->Backend->pfnGetModificationUuid(pCache->pBackendData,
6032 &UuidCache);
6033 if (RT_SUCCESS(rc))
6034 {
6035 rc = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
6036 &UuidImage);
6037 if (RT_SUCCESS(rc))
6038 {
6039 if (RTUuidCompare(&UuidImage, &UuidCache))
6040 rc = VERR_VD_CACHE_NOT_UP_TO_DATE;
6041 }
6042 }
6043
6044 /*
6045 * We assume that the user knows what he is doing if one of the images
6046 * doesn't support the modification uuid.
6047 */
6048 if (rc == VERR_NOT_SUPPORTED)
6049 rc = VINF_SUCCESS;
6050
6051 if (RT_SUCCESS(rc))
6052 {
6053 /* Cache successfully opened, make it the current one. */
6054 if (!pDisk->pCache)
6055 pDisk->pCache = pCache;
6056 else
6057 rc = VERR_VD_CACHE_ALREADY_EXISTS;
6058 }
6059
6060 if (RT_FAILURE(rc))
6061 {
6062 /* Error detected, but image opened. Close image. */
6063 rc2 = pCache->Backend->pfnClose(pCache->pBackendData, false);
6064 AssertRC(rc2);
6065 pCache->pBackendData = NULL;
6066 }
6067 } while (0);
6068
6069 if (RT_UNLIKELY(fLockWrite))
6070 {
6071 rc2 = vdThreadFinishWrite(pDisk);
6072 AssertRC(rc2);
6073 }
6074
6075 if (RT_FAILURE(rc))
6076 {
6077 if (pCache)
6078 {
6079 if (pCache->pszFilename)
6080 RTStrFree(pCache->pszFilename);
6081 RTMemFree(pCache);
6082 }
6083 }
6084
6085 LogFlowFunc(("returns %Rrc\n", rc));
6086 return rc;
6087}
6088
6089VBOXDDU_DECL(int) VDFilterAdd(PVDISK pDisk, const char *pszFilter, uint32_t fFlags,
6090 PVDINTERFACE pVDIfsFilter)
6091{
6092 int rc = VINF_SUCCESS;
6093 int rc2;
6094 bool fLockWrite = false;
6095 PVDFILTER pFilter = NULL;
6096
6097 LogFlowFunc(("pDisk=%#p pszFilter=\"%s\" pVDIfsFilter=%#p\n",
6098 pDisk, pszFilter, pVDIfsFilter));
6099
6100 do
6101 {
6102 /* sanity check */
6103 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
6104 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
6105
6106 /* Check arguments. */
6107 AssertMsgBreakStmt(VALID_PTR(pszFilter) && *pszFilter,
6108 ("pszFilter=%#p \"%s\"\n", pszFilter, pszFilter),
6109 rc = VERR_INVALID_PARAMETER);
6110
6111 AssertMsgBreakStmt(!(fFlags & ~VD_FILTER_FLAGS_MASK),
6112 ("Invalid flags set (fFlags=%#x)\n", fFlags),
6113 rc = VERR_INVALID_PARAMETER);
6114
6115 /* Set up image descriptor. */
6116 pFilter = (PVDFILTER)RTMemAllocZ(sizeof(VDFILTER));
6117 if (!pFilter)
6118 {
6119 rc = VERR_NO_MEMORY;
6120 break;
6121 }
6122
6123 rc = vdFindFilterBackend(pszFilter, &pFilter->pBackend);
6124 if (RT_FAILURE(rc))
6125 break;
6126 if (!pFilter->pBackend)
6127 {
6128 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6129 N_("VD: unknown filter backend name '%s'"), pszFilter);
6130 break;
6131 }
6132
6133 pFilter->VDIo.pDisk = pDisk;
6134 pFilter->pVDIfsFilter = pVDIfsFilter;
6135
6136 /* Set up the internal I/O interface. */
6137 AssertBreakStmt(!VDIfIoIntGet(pVDIfsFilter), rc = VERR_INVALID_PARAMETER);
6138 vdIfIoIntCallbacksSetup(&pFilter->VDIo.VDIfIoInt);
6139 rc = VDInterfaceAdd(&pFilter->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6140 &pFilter->VDIo, sizeof(VDINTERFACEIOINT), &pFilter->pVDIfsFilter);
6141 AssertRC(rc);
6142
6143 rc = pFilter->pBackend->pfnCreate(pDisk->pVDIfsDisk, fFlags & VD_FILTER_FLAGS_INFO,
6144 pFilter->pVDIfsFilter, &pFilter->pvBackendData);
6145 if (RT_FAILURE(rc))
6146 break;
6147
6148 /* Lock disk for writing, as we modify pDisk information below. */
6149 rc2 = vdThreadStartWrite(pDisk);
6150 AssertRC(rc2);
6151 fLockWrite = true;
6152
6153 /* Add filter to chains. */
6154 if (fFlags & VD_FILTER_FLAGS_WRITE)
6155 {
6156 RTListAppend(&pDisk->ListFilterChainWrite, &pFilter->ListNodeChainWrite);
6157 vdFilterRetain(pFilter);
6158 }
6159
6160 if (fFlags & VD_FILTER_FLAGS_READ)
6161 {
6162 RTListAppend(&pDisk->ListFilterChainRead, &pFilter->ListNodeChainRead);
6163 vdFilterRetain(pFilter);
6164 }
6165 } while (0);
6166
6167 if (RT_UNLIKELY(fLockWrite))
6168 {
6169 rc2 = vdThreadFinishWrite(pDisk);
6170 AssertRC(rc2);
6171 }
6172
6173 if (RT_FAILURE(rc))
6174 {
6175 if (pFilter)
6176 RTMemFree(pFilter);
6177 }
6178
6179 LogFlowFunc(("returns %Rrc\n", rc));
6180 return rc;
6181}
6182
6183/**
6184 * Creates and opens a new base image file.
6185 *
6186 * @returns VBox status code.
6187 * @param pDisk Pointer to HDD container.
6188 * @param pszBackend Name of the image file backend to use.
6189 * @param pszFilename Name of the image file to create.
6190 * @param cbSize Image size in bytes.
6191 * @param uImageFlags Flags specifying special image features.
6192 * @param pszComment Pointer to image comment. NULL is ok.
6193 * @param pPCHSGeometry Pointer to physical disk geometry <= (16383,16,63). Not NULL.
6194 * @param pLCHSGeometry Pointer to logical disk geometry <= (x,255,63). Not NULL.
6195 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
6196 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
6197 * @param pVDIfsImage Pointer to the per-image VD interface list.
6198 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6199 */
6200VBOXDDU_DECL(int) VDCreateBase(PVDISK pDisk, const char *pszBackend,
6201 const char *pszFilename, uint64_t cbSize,
6202 unsigned uImageFlags, const char *pszComment,
6203 PCVDGEOMETRY pPCHSGeometry,
6204 PCVDGEOMETRY pLCHSGeometry,
6205 PCRTUUID pUuid, unsigned uOpenFlags,
6206 PVDINTERFACE pVDIfsImage,
6207 PVDINTERFACE pVDIfsOperation)
6208{
6209 int rc = VINF_SUCCESS;
6210 int rc2;
6211 bool fLockWrite = false, fLockRead = false;
6212 PVDIMAGE pImage = NULL;
6213 RTUUID uuid;
6214
6215 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" PCHS=%u/%u/%u LCHS=%u/%u/%u Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
6216 pDisk, pszBackend, pszFilename, cbSize, uImageFlags, pszComment,
6217 pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads,
6218 pPCHSGeometry->cSectors, pLCHSGeometry->cCylinders,
6219 pLCHSGeometry->cHeads, pLCHSGeometry->cSectors, pUuid,
6220 uOpenFlags, pVDIfsImage, pVDIfsOperation));
6221
6222 AssertPtrNullReturn(pVDIfsOperation, VERR_INVALID_PARAMETER);
6223 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
6224
6225 do
6226 {
6227 /** @todo r=bird: there is no particular reason why this validation has to be
6228 * done inside the do-break-while-goto-is-false loop. (pIfProgress is
6229 * only called on success.) Could just AssertMsgReturn, rather than
6230 * complicated AssertMsgBreakStmt. */
6231 /* sanity check */
6232 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
6233 AssertMsgBreakStmt(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature),
6234 rc = VERR_INVALID_MAGIC);
6235
6236 /* Check arguments. */
6237 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
6238 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
6239 rc = VERR_INVALID_PARAMETER);
6240 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
6241 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
6242 rc = VERR_INVALID_PARAMETER);
6243 AssertMsgBreakStmt(cbSize || (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK),
6244 ("cbSize=%llu\n", cbSize),
6245 rc = VERR_INVALID_PARAMETER);
6246 if (cbSize % 512 && !(uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK))
6247 {
6248 rc = vdError(pDisk, VERR_VD_INVALID_SIZE, RT_SRC_POS,
6249 N_("VD: The given disk size %llu is not aligned on a sector boundary (512 bytes)"), cbSize);
6250 break;
6251 }
6252 AssertMsgBreakStmt( ((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0)
6253 || ((uImageFlags & (VD_IMAGE_FLAGS_FIXED | VD_IMAGE_FLAGS_DIFF)) != VD_IMAGE_FLAGS_FIXED),
6254 ("uImageFlags=%#x\n", uImageFlags),
6255 rc = VERR_INVALID_PARAMETER);
6256 AssertMsgBreakStmt( !(uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
6257 || !(uImageFlags & ~(VD_VMDK_IMAGE_FLAGS_RAWDISK | VD_IMAGE_FLAGS_FIXED)),
6258 ("uImageFlags=%#x\n", uImageFlags),
6259 rc = VERR_INVALID_PARAMETER);
6260 /* The PCHS geometry fields may be 0 to leave it for later. */
6261 AssertPtrBreakStmt(pPCHSGeometry, rc = VERR_INVALID_PARAMETER);
6262 AssertMsgBreakStmt( pPCHSGeometry->cHeads <= 16
6263 && pPCHSGeometry->cSectors <= 63,
6264 ("PCHS=%u/%u/%u\n", pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors),
6265 rc = VERR_INVALID_PARAMETER);
6266 /* The LCHS geometry fields may be 0 to leave it to later autodetection. */
6267 AssertPtrBreakStmt(pLCHSGeometry, rc = VERR_INVALID_PARAMETER);
6268 AssertMsgBreakStmt( pLCHSGeometry->cHeads <= 255
6269 && pLCHSGeometry->cSectors <= 63,
6270 ("LCHS=%u/%u/%u\n", pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors),
6271 rc = VERR_INVALID_PARAMETER);
6272 /* The UUID may be NULL. */
6273 AssertMsgBreakStmt(pUuid == NULL || VALID_PTR(pUuid),
6274 ("pUuid=%#p UUID=%RTuuid\n", pUuid, pUuid),
6275 rc = VERR_INVALID_PARAMETER);
6276 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
6277 ("uOpenFlags=%#x\n", uOpenFlags),
6278 rc = VERR_INVALID_PARAMETER);
6279
6280 /* Check state. Needs a temporary read lock. Holding the write lock
6281 * all the time would be blocking other activities for too long. */
6282 rc2 = vdThreadStartRead(pDisk);
6283 AssertRC(rc2);
6284 fLockRead = true;
6285 AssertMsgBreakStmt(pDisk->cImages == 0,
6286 ("Create base image cannot be done with other images open\n"),
6287 rc = VERR_VD_INVALID_STATE);
6288 rc2 = vdThreadFinishRead(pDisk);
6289 AssertRC(rc2);
6290 fLockRead = false;
6291
6292 /* Set up image descriptor. */
6293 pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
6294 if (!pImage)
6295 {
6296 rc = VERR_NO_MEMORY;
6297 break;
6298 }
6299 pImage->pszFilename = RTStrDup(pszFilename);
6300 if (!pImage->pszFilename)
6301 {
6302 rc = VERR_NO_MEMORY;
6303 break;
6304 }
6305 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
6306 pImage->VDIo.pDisk = pDisk;
6307 pImage->pVDIfsImage = pVDIfsImage;
6308
6309 /* Set up the I/O interface. */
6310 pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
6311 if (!pImage->VDIo.pInterfaceIo)
6312 {
6313 vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
6314 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
6315 pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
6316 pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
6317 }
6318
6319 /* Set up the internal I/O interface. */
6320 AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
6321 vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
6322 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6323 &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
6324 AssertRC(rc);
6325
6326 rc = vdFindImageBackend(pszBackend, &pImage->Backend);
6327 if (RT_FAILURE(rc))
6328 break;
6329 if (!pImage->Backend)
6330 {
6331 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6332 N_("VD: unknown backend name '%s'"), pszBackend);
6333 break;
6334 }
6335 if (!(pImage->Backend->uBackendCaps & ( VD_CAP_CREATE_FIXED
6336 | VD_CAP_CREATE_DYNAMIC)))
6337 {
6338 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6339 N_("VD: backend '%s' cannot create base images"), pszBackend);
6340 break;
6341 }
6342 if ( ( (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
6343 && !(pImage->Backend->uBackendCaps & VD_CAP_CREATE_SPLIT_2G))
6344 || ( (uImageFlags & ( VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
6345 | VD_VMDK_IMAGE_FLAGS_RAWDISK))
6346 && RTStrICmp(pszBackend, "VMDK")))
6347 {
6348 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6349 N_("VD: backend '%s' does not support the selected image variant"), pszBackend);
6350 break;
6351 }
6352
6353 /* Create UUID if the caller didn't specify one. */
6354 if (!pUuid)
6355 {
6356 rc = RTUuidCreate(&uuid);
6357 if (RT_FAILURE(rc))
6358 {
6359 rc = vdError(pDisk, rc, RT_SRC_POS,
6360 N_("VD: cannot generate UUID for image '%s'"),
6361 pszFilename);
6362 break;
6363 }
6364 pUuid = &uuid;
6365 }
6366
6367 pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
6368 uImageFlags &= ~VD_IMAGE_FLAGS_DIFF;
6369 pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
6370 rc = pImage->Backend->pfnCreate(pImage->pszFilename, cbSize,
6371 uImageFlags, pszComment, pPCHSGeometry,
6372 pLCHSGeometry, pUuid,
6373 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
6374 0, 99,
6375 pDisk->pVDIfsDisk,
6376 pImage->pVDIfsImage,
6377 pVDIfsOperation,
6378 pDisk->enmType,
6379 &pImage->pBackendData);
6380
6381 if (RT_SUCCESS(rc))
6382 {
6383 pImage->VDIo.pBackendData = pImage->pBackendData;
6384 pImage->uImageFlags = uImageFlags;
6385
6386 /* Force sane optimization settings. It's not worth avoiding writes
6387 * to fixed size images. The overhead would have almost no payback. */
6388 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
6389 pImage->uOpenFlags |= VD_OPEN_FLAGS_HONOR_SAME;
6390
6391 /* Lock disk for writing, as we modify pDisk information below. */
6392 rc2 = vdThreadStartWrite(pDisk);
6393 AssertRC(rc2);
6394 fLockWrite = true;
6395
6396 /** @todo optionally check UUIDs */
6397
6398 /* Re-check state, as the lock wasn't held and another image
6399 * creation call could have been done by another thread. */
6400 AssertMsgStmt(pDisk->cImages == 0,
6401 ("Create base image cannot be done with other images open\n"),
6402 rc = VERR_VD_INVALID_STATE);
6403 }
6404
6405 if (RT_SUCCESS(rc))
6406 {
6407 /* Cache disk information. */
6408 pDisk->cbSize = vdImageGetSize(pImage);
6409
6410 /* Cache PCHS geometry. */
6411 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
6412 &pDisk->PCHSGeometry);
6413 if (RT_FAILURE(rc2))
6414 {
6415 pDisk->PCHSGeometry.cCylinders = 0;
6416 pDisk->PCHSGeometry.cHeads = 0;
6417 pDisk->PCHSGeometry.cSectors = 0;
6418 }
6419 else
6420 {
6421 /* Make sure the CHS geometry is properly clipped. */
6422 pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
6423 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
6424 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
6425 }
6426
6427 /* Cache LCHS geometry. */
6428 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
6429 &pDisk->LCHSGeometry);
6430 if (RT_FAILURE(rc2))
6431 {
6432 pDisk->LCHSGeometry.cCylinders = 0;
6433 pDisk->LCHSGeometry.cHeads = 0;
6434 pDisk->LCHSGeometry.cSectors = 0;
6435 }
6436 else
6437 {
6438 /* Make sure the CHS geometry is properly clipped. */
6439 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
6440 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
6441 }
6442
6443 /* Image successfully opened, make it the last image. */
6444 vdAddImageToList(pDisk, pImage);
6445 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
6446 pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
6447 }
6448 else
6449 {
6450 /* Error detected, image may or may not be opened. Close and delete
6451 * image if it was opened. */
6452 if (pImage->pBackendData)
6453 {
6454 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, true);
6455 AssertRC(rc2);
6456 pImage->pBackendData = NULL;
6457 }
6458 }
6459 } while (0);
6460
6461 if (RT_UNLIKELY(fLockWrite))
6462 {
6463 rc2 = vdThreadFinishWrite(pDisk);
6464 AssertRC(rc2);
6465 }
6466 else if (RT_UNLIKELY(fLockRead))
6467 {
6468 rc2 = vdThreadFinishRead(pDisk);
6469 AssertRC(rc2);
6470 }
6471
6472 if (RT_FAILURE(rc))
6473 {
6474 if (pImage)
6475 {
6476 if (pImage->pszFilename)
6477 RTStrFree(pImage->pszFilename);
6478 RTMemFree(pImage);
6479 }
6480 }
6481
6482 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
6483 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
6484
6485 LogFlowFunc(("returns %Rrc\n", rc));
6486 return rc;
6487}
6488
6489/**
6490 * Creates and opens a new differencing image file in HDD container.
6491 * See comments for VDOpen function about differencing images.
6492 *
6493 * @returns VBox status code.
6494 * @param pDisk Pointer to HDD container.
6495 * @param pszBackend Name of the image file backend to use.
6496 * @param pszFilename Name of the differencing image file to create.
6497 * @param uImageFlags Flags specifying special image features.
6498 * @param pszComment Pointer to image comment. NULL is ok.
6499 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
6500 * @param pParentUuid New parent UUID of the image. If NULL, the UUID is queried automatically.
6501 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
6502 * @param pVDIfsImage Pointer to the per-image VD interface list.
6503 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6504 */
6505VBOXDDU_DECL(int) VDCreateDiff(PVDISK pDisk, const char *pszBackend,
6506 const char *pszFilename, unsigned uImageFlags,
6507 const char *pszComment, PCRTUUID pUuid,
6508 PCRTUUID pParentUuid, unsigned uOpenFlags,
6509 PVDINTERFACE pVDIfsImage,
6510 PVDINTERFACE pVDIfsOperation)
6511{
6512 int rc = VINF_SUCCESS;
6513 int rc2;
6514 bool fLockWrite = false, fLockRead = false;
6515 PVDIMAGE pImage = NULL;
6516 RTUUID uuid;
6517
6518 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
6519 pDisk, pszBackend, pszFilename, uImageFlags, pszComment, pUuid, uOpenFlags, pVDIfsImage, pVDIfsOperation));
6520
6521 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
6522
6523 do
6524 {
6525 /* sanity check */
6526 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
6527 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
6528
6529 /* Check arguments. */
6530 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
6531 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
6532 rc = VERR_INVALID_PARAMETER);
6533 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
6534 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
6535 rc = VERR_INVALID_PARAMETER);
6536 AssertMsgBreakStmt((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0,
6537 ("uImageFlags=%#x\n", uImageFlags),
6538 rc = VERR_INVALID_PARAMETER);
6539 /* The UUID may be NULL. */
6540 AssertMsgBreakStmt(pUuid == NULL || VALID_PTR(pUuid),
6541 ("pUuid=%#p UUID=%RTuuid\n", pUuid, pUuid),
6542 rc = VERR_INVALID_PARAMETER);
6543 /* The parent UUID may be NULL. */
6544 AssertMsgBreakStmt(pParentUuid == NULL || VALID_PTR(pParentUuid),
6545 ("pParentUuid=%#p ParentUUID=%RTuuid\n", pParentUuid, pParentUuid),
6546 rc = VERR_INVALID_PARAMETER);
6547 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
6548 ("uOpenFlags=%#x\n", uOpenFlags),
6549 rc = VERR_INVALID_PARAMETER);
6550
6551 /* Check state. Needs a temporary read lock. Holding the write lock
6552 * all the time would be blocking other activities for too long. */
6553 rc2 = vdThreadStartRead(pDisk);
6554 AssertRC(rc2);
6555 fLockRead = true;
6556 AssertMsgBreakStmt(pDisk->cImages != 0,
6557 ("Create diff image cannot be done without other images open\n"),
6558 rc = VERR_VD_INVALID_STATE);
6559 rc2 = vdThreadFinishRead(pDisk);
6560 AssertRC(rc2);
6561 fLockRead = false;
6562
6563 /*
6564 * Destroy the current discard state first which might still have pending blocks
6565 * for the currently opened image which will be switched to readonly mode.
6566 */
6567 /* Lock disk for writing, as we modify pDisk information below. */
6568 rc2 = vdThreadStartWrite(pDisk);
6569 AssertRC(rc2);
6570 fLockWrite = true;
6571 rc = vdDiscardStateDestroy(pDisk);
6572 if (RT_FAILURE(rc))
6573 break;
6574 rc2 = vdThreadFinishWrite(pDisk);
6575 AssertRC(rc2);
6576 fLockWrite = false;
6577
6578 /* Set up image descriptor. */
6579 pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
6580 if (!pImage)
6581 {
6582 rc = VERR_NO_MEMORY;
6583 break;
6584 }
6585 pImage->pszFilename = RTStrDup(pszFilename);
6586 if (!pImage->pszFilename)
6587 {
6588 rc = VERR_NO_MEMORY;
6589 break;
6590 }
6591
6592 rc = vdFindImageBackend(pszBackend, &pImage->Backend);
6593 if (RT_FAILURE(rc))
6594 break;
6595 if (!pImage->Backend)
6596 {
6597 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6598 N_("VD: unknown backend name '%s'"), pszBackend);
6599 break;
6600 }
6601 if ( !(pImage->Backend->uBackendCaps & VD_CAP_DIFF)
6602 || !(pImage->Backend->uBackendCaps & ( VD_CAP_CREATE_FIXED
6603 | VD_CAP_CREATE_DYNAMIC)))
6604 {
6605 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6606 N_("VD: backend '%s' cannot create diff images"), pszBackend);
6607 break;
6608 }
6609
6610 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
6611 pImage->VDIo.pDisk = pDisk;
6612 pImage->pVDIfsImage = pVDIfsImage;
6613
6614 /* Set up the I/O interface. */
6615 pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
6616 if (!pImage->VDIo.pInterfaceIo)
6617 {
6618 vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
6619 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
6620 pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
6621 pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
6622 }
6623
6624 /* Set up the internal I/O interface. */
6625 AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
6626 vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
6627 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6628 &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
6629 AssertRC(rc);
6630
6631 /* Create UUID if the caller didn't specify one. */
6632 if (!pUuid)
6633 {
6634 rc = RTUuidCreate(&uuid);
6635 if (RT_FAILURE(rc))
6636 {
6637 rc = vdError(pDisk, rc, RT_SRC_POS,
6638 N_("VD: cannot generate UUID for image '%s'"),
6639 pszFilename);
6640 break;
6641 }
6642 pUuid = &uuid;
6643 }
6644
6645 pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
6646 pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
6647 uImageFlags |= VD_IMAGE_FLAGS_DIFF;
6648 rc = pImage->Backend->pfnCreate(pImage->pszFilename, pDisk->cbSize,
6649 uImageFlags | VD_IMAGE_FLAGS_DIFF,
6650 pszComment, &pDisk->PCHSGeometry,
6651 &pDisk->LCHSGeometry, pUuid,
6652 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
6653 0, 99,
6654 pDisk->pVDIfsDisk,
6655 pImage->pVDIfsImage,
6656 pVDIfsOperation,
6657 pDisk->enmType,
6658 &pImage->pBackendData);
6659
6660 if (RT_SUCCESS(rc))
6661 {
6662 pImage->VDIo.pBackendData = pImage->pBackendData;
6663 pImage->uImageFlags = uImageFlags;
6664
6665 /* Lock disk for writing, as we modify pDisk information below. */
6666 rc2 = vdThreadStartWrite(pDisk);
6667 AssertRC(rc2);
6668 fLockWrite = true;
6669
6670 /* Switch previous image to read-only mode. */
6671 unsigned uOpenFlagsPrevImg;
6672 uOpenFlagsPrevImg = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
6673 if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
6674 {
6675 uOpenFlagsPrevImg |= VD_OPEN_FLAGS_READONLY;
6676 rc = pDisk->pLast->Backend->pfnSetOpenFlags(pDisk->pLast->pBackendData, uOpenFlagsPrevImg);
6677 }
6678
6679 /** @todo optionally check UUIDs */
6680
6681 /* Re-check state, as the lock wasn't held and another image
6682 * creation call could have been done by another thread. */
6683 AssertMsgStmt(pDisk->cImages != 0,
6684 ("Create diff image cannot be done without other images open\n"),
6685 rc = VERR_VD_INVALID_STATE);
6686 }
6687
6688 if (RT_SUCCESS(rc))
6689 {
6690 RTUUID Uuid;
6691 RTTIMESPEC ts;
6692
6693 if (pParentUuid && !RTUuidIsNull(pParentUuid))
6694 {
6695 Uuid = *pParentUuid;
6696 pImage->Backend->pfnSetParentUuid(pImage->pBackendData, &Uuid);
6697 }
6698 else
6699 {
6700 rc2 = pDisk->pLast->Backend->pfnGetUuid(pDisk->pLast->pBackendData,
6701 &Uuid);
6702 if (RT_SUCCESS(rc2))
6703 pImage->Backend->pfnSetParentUuid(pImage->pBackendData, &Uuid);
6704 }
6705 rc2 = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
6706 &Uuid);
6707 if (RT_SUCCESS(rc2))
6708 pImage->Backend->pfnSetParentModificationUuid(pImage->pBackendData,
6709 &Uuid);
6710 if (pDisk->pLast->Backend->pfnGetTimestamp)
6711 rc2 = pDisk->pLast->Backend->pfnGetTimestamp(pDisk->pLast->pBackendData,
6712 &ts);
6713 else
6714 rc2 = VERR_NOT_IMPLEMENTED;
6715 if (RT_SUCCESS(rc2) && pImage->Backend->pfnSetParentTimestamp)
6716 pImage->Backend->pfnSetParentTimestamp(pImage->pBackendData, &ts);
6717
6718 if (pImage->Backend->pfnSetParentFilename)
6719 rc2 = pImage->Backend->pfnSetParentFilename(pImage->pBackendData, pDisk->pLast->pszFilename);
6720 }
6721
6722 if (RT_SUCCESS(rc))
6723 {
6724 /* Image successfully opened, make it the last image. */
6725 vdAddImageToList(pDisk, pImage);
6726 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
6727 pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
6728 }
6729 else
6730 {
6731 /* Error detected, but image opened. Close and delete image. */
6732 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, true);
6733 AssertRC(rc2);
6734 pImage->pBackendData = NULL;
6735 }
6736 } while (0);
6737
6738 if (RT_UNLIKELY(fLockWrite))
6739 {
6740 rc2 = vdThreadFinishWrite(pDisk);
6741 AssertRC(rc2);
6742 }
6743 else if (RT_UNLIKELY(fLockRead))
6744 {
6745 rc2 = vdThreadFinishRead(pDisk);
6746 AssertRC(rc2);
6747 }
6748
6749 if (RT_FAILURE(rc))
6750 {
6751 if (pImage)
6752 {
6753 if (pImage->pszFilename)
6754 RTStrFree(pImage->pszFilename);
6755 RTMemFree(pImage);
6756 }
6757 }
6758
6759 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
6760 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
6761
6762 LogFlowFunc(("returns %Rrc\n", rc));
6763 return rc;
6764}
6765
6766
6767/**
6768 * Creates and opens new cache image file in HDD container.
6769 *
6770 * @return VBox status code.
6771 * @param pDisk Name of the cache file backend to use (case insensitive).
6772 * @param pszFilename Name of the differencing cache file to create.
6773 * @param cbSize Maximum size of the cache.
6774 * @param uImageFlags Flags specifying special cache features.
6775 * @param pszComment Pointer to image comment. NULL is ok.
6776 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
6777 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
6778 * @param pVDIfsCache Pointer to the per-cache VD interface list.
6779 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6780 */
6781VBOXDDU_DECL(int) VDCreateCache(PVDISK pDisk, const char *pszBackend,
6782 const char *pszFilename, uint64_t cbSize,
6783 unsigned uImageFlags, const char *pszComment,
6784 PCRTUUID pUuid, unsigned uOpenFlags,
6785 PVDINTERFACE pVDIfsCache, PVDINTERFACE pVDIfsOperation)
6786{
6787 int rc = VINF_SUCCESS;
6788 int rc2;
6789 bool fLockWrite = false, fLockRead = false;
6790 PVDCACHE pCache = NULL;
6791 RTUUID uuid;
6792
6793 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
6794 pDisk, pszBackend, pszFilename, cbSize, uImageFlags, pszComment, pUuid, uOpenFlags, pVDIfsCache, pVDIfsOperation));
6795
6796 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
6797
6798 do
6799 {
6800 /* sanity check */
6801 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
6802 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
6803
6804 /* Check arguments. */
6805 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
6806 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
6807 rc = VERR_INVALID_PARAMETER);
6808 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
6809 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
6810 rc = VERR_INVALID_PARAMETER);
6811 AssertMsgBreakStmt(cbSize,
6812 ("cbSize=%llu\n", cbSize),
6813 rc = VERR_INVALID_PARAMETER);
6814 AssertMsgBreakStmt((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0,
6815 ("uImageFlags=%#x\n", uImageFlags),
6816 rc = VERR_INVALID_PARAMETER);
6817 /* The UUID may be NULL. */
6818 AssertMsgBreakStmt(pUuid == NULL || VALID_PTR(pUuid),
6819 ("pUuid=%#p UUID=%RTuuid\n", pUuid, pUuid),
6820 rc = VERR_INVALID_PARAMETER);
6821 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
6822 ("uOpenFlags=%#x\n", uOpenFlags),
6823 rc = VERR_INVALID_PARAMETER);
6824
6825 /* Check state. Needs a temporary read lock. Holding the write lock
6826 * all the time would be blocking other activities for too long. */
6827 rc2 = vdThreadStartRead(pDisk);
6828 AssertRC(rc2);
6829 fLockRead = true;
6830 AssertMsgBreakStmt(!pDisk->pCache,
6831 ("Create cache image cannot be done with a cache already attached\n"),
6832 rc = VERR_VD_CACHE_ALREADY_EXISTS);
6833 rc2 = vdThreadFinishRead(pDisk);
6834 AssertRC(rc2);
6835 fLockRead = false;
6836
6837 /* Set up image descriptor. */
6838 pCache = (PVDCACHE)RTMemAllocZ(sizeof(VDCACHE));
6839 if (!pCache)
6840 {
6841 rc = VERR_NO_MEMORY;
6842 break;
6843 }
6844 pCache->pszFilename = RTStrDup(pszFilename);
6845 if (!pCache->pszFilename)
6846 {
6847 rc = VERR_NO_MEMORY;
6848 break;
6849 }
6850
6851 rc = vdFindCacheBackend(pszBackend, &pCache->Backend);
6852 if (RT_FAILURE(rc))
6853 break;
6854 if (!pCache->Backend)
6855 {
6856 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6857 N_("VD: unknown backend name '%s'"), pszBackend);
6858 break;
6859 }
6860
6861 pCache->VDIo.pDisk = pDisk;
6862 pCache->pVDIfsCache = pVDIfsCache;
6863
6864 /* Set up the I/O interface. */
6865 pCache->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsCache);
6866 if (!pCache->VDIo.pInterfaceIo)
6867 {
6868 vdIfIoFallbackCallbacksSetup(&pCache->VDIo.VDIfIo);
6869 rc = VDInterfaceAdd(&pCache->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
6870 pDisk, sizeof(VDINTERFACEIO), &pVDIfsCache);
6871 pCache->VDIo.pInterfaceIo = &pCache->VDIo.VDIfIo;
6872 }
6873
6874 /* Set up the internal I/O interface. */
6875 AssertBreakStmt(!VDIfIoIntGet(pVDIfsCache), rc = VERR_INVALID_PARAMETER);
6876 vdIfIoIntCallbacksSetup(&pCache->VDIo.VDIfIoInt);
6877 rc = VDInterfaceAdd(&pCache->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6878 &pCache->VDIo, sizeof(VDINTERFACEIOINT), &pCache->pVDIfsCache);
6879 AssertRC(rc);
6880
6881 /* Create UUID if the caller didn't specify one. */
6882 if (!pUuid)
6883 {
6884 rc = RTUuidCreate(&uuid);
6885 if (RT_FAILURE(rc))
6886 {
6887 rc = vdError(pDisk, rc, RT_SRC_POS,
6888 N_("VD: cannot generate UUID for image '%s'"),
6889 pszFilename);
6890 break;
6891 }
6892 pUuid = &uuid;
6893 }
6894
6895 pCache->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
6896 pCache->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
6897 rc = pCache->Backend->pfnCreate(pCache->pszFilename, cbSize,
6898 uImageFlags,
6899 pszComment, pUuid,
6900 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
6901 0, 99,
6902 pDisk->pVDIfsDisk,
6903 pCache->pVDIfsCache,
6904 pVDIfsOperation,
6905 &pCache->pBackendData);
6906
6907 if (RT_SUCCESS(rc))
6908 {
6909 /* Lock disk for writing, as we modify pDisk information below. */
6910 rc2 = vdThreadStartWrite(pDisk);
6911 AssertRC(rc2);
6912 fLockWrite = true;
6913
6914 pCache->VDIo.pBackendData = pCache->pBackendData;
6915
6916 /* Re-check state, as the lock wasn't held and another image
6917 * creation call could have been done by another thread. */
6918 AssertMsgStmt(!pDisk->pCache,
6919 ("Create cache image cannot be done with another cache open\n"),
6920 rc = VERR_VD_CACHE_ALREADY_EXISTS);
6921 }
6922
6923 if ( RT_SUCCESS(rc)
6924 && pDisk->pLast)
6925 {
6926 RTUUID UuidModification;
6927
6928 /* Set same modification Uuid as the last image. */
6929 rc = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
6930 &UuidModification);
6931 if (RT_SUCCESS(rc))
6932 {
6933 rc = pCache->Backend->pfnSetModificationUuid(pCache->pBackendData,
6934 &UuidModification);
6935 }
6936
6937 if (rc == VERR_NOT_SUPPORTED)
6938 rc = VINF_SUCCESS;
6939 }
6940
6941 if (RT_SUCCESS(rc))
6942 {
6943 /* Cache successfully created. */
6944 pDisk->pCache = pCache;
6945 }
6946 else
6947 {
6948 /* Error detected, but image opened. Close and delete image. */
6949 rc2 = pCache->Backend->pfnClose(pCache->pBackendData, true);
6950 AssertRC(rc2);
6951 pCache->pBackendData = NULL;
6952 }
6953 } while (0);
6954
6955 if (RT_UNLIKELY(fLockWrite))
6956 {
6957 rc2 = vdThreadFinishWrite(pDisk);
6958 AssertRC(rc2);
6959 }
6960 else if (RT_UNLIKELY(fLockRead))
6961 {
6962 rc2 = vdThreadFinishRead(pDisk);
6963 AssertRC(rc2);
6964 }
6965
6966 if (RT_FAILURE(rc))
6967 {
6968 if (pCache)
6969 {
6970 if (pCache->pszFilename)
6971 RTStrFree(pCache->pszFilename);
6972 RTMemFree(pCache);
6973 }
6974 }
6975
6976 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
6977 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
6978
6979 LogFlowFunc(("returns %Rrc\n", rc));
6980 return rc;
6981}
6982
6983/**
6984 * Merges two images (not necessarily with direct parent/child relationship).
6985 * As a side effect the source image and potentially the other images which
6986 * are also merged to the destination are deleted from both the disk and the
6987 * images in the HDD container.
6988 *
6989 * @returns VBox status code.
6990 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
6991 * @param pDisk Pointer to HDD container.
6992 * @param nImageFrom Name of the image file to merge from.
6993 * @param nImageTo Name of the image file to merge to.
6994 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6995 */
6996VBOXDDU_DECL(int) VDMerge(PVDISK pDisk, unsigned nImageFrom,
6997 unsigned nImageTo, PVDINTERFACE pVDIfsOperation)
6998{
6999 int rc = VINF_SUCCESS;
7000 int rc2;
7001 bool fLockWrite = false, fLockRead = false;
7002 void *pvBuf = NULL;
7003
7004 LogFlowFunc(("pDisk=%#p nImageFrom=%u nImageTo=%u pVDIfsOperation=%#p\n",
7005 pDisk, nImageFrom, nImageTo, pVDIfsOperation));
7006
7007 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7008
7009 do
7010 {
7011 /* sanity check */
7012 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
7013 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
7014
7015 /* For simplicity reasons lock for writing as the image reopen below
7016 * might need it. After all the reopen is usually needed. */
7017 rc2 = vdThreadStartWrite(pDisk);
7018 AssertRC(rc2);
7019 fLockWrite = true;
7020 PVDIMAGE pImageFrom = vdGetImageByNumber(pDisk, nImageFrom);
7021 PVDIMAGE pImageTo = vdGetImageByNumber(pDisk, nImageTo);
7022 if (!pImageFrom || !pImageTo)
7023 {
7024 rc = VERR_VD_IMAGE_NOT_FOUND;
7025 break;
7026 }
7027 AssertBreakStmt(pImageFrom != pImageTo, rc = VERR_INVALID_PARAMETER);
7028
7029 /* Make sure destination image is writable. */
7030 unsigned uOpenFlags = pImageTo->Backend->pfnGetOpenFlags(pImageTo->pBackendData);
7031 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
7032 {
7033 /*
7034 * Clear skip consistency checks because the image is made writable now and
7035 * skipping consistency checks is only possible for readonly images.
7036 */
7037 uOpenFlags &= ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS);
7038 rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
7039 uOpenFlags);
7040 if (RT_FAILURE(rc))
7041 break;
7042 }
7043
7044 /* Get size of destination image. */
7045 uint64_t cbSize = vdImageGetSize(pImageTo);
7046 rc2 = vdThreadFinishWrite(pDisk);
7047 AssertRC(rc2);
7048 fLockWrite = false;
7049
7050 /* Allocate tmp buffer. */
7051 pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
7052 if (!pvBuf)
7053 {
7054 rc = VERR_NO_MEMORY;
7055 break;
7056 }
7057
7058 /* Merging is done directly on the images itself. This potentially
7059 * causes trouble if the disk is full in the middle of operation. */
7060 if (nImageFrom < nImageTo)
7061 {
7062 /* Merge parent state into child. This means writing all not
7063 * allocated blocks in the destination image which are allocated in
7064 * the images to be merged. */
7065 uint64_t uOffset = 0;
7066 uint64_t cbRemaining = cbSize;
7067
7068 do
7069 {
7070 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
7071 RTSGSEG SegmentBuf;
7072 RTSGBUF SgBuf;
7073 VDIOCTX IoCtx;
7074
7075 SegmentBuf.pvSeg = pvBuf;
7076 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
7077 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
7078 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
7079 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
7080
7081 /* Need to hold the write lock during a read-write operation. */
7082 rc2 = vdThreadStartWrite(pDisk);
7083 AssertRC(rc2);
7084 fLockWrite = true;
7085
7086 rc = pImageTo->Backend->pfnRead(pImageTo->pBackendData,
7087 uOffset, cbThisRead,
7088 &IoCtx, &cbThisRead);
7089 if (rc == VERR_VD_BLOCK_FREE)
7090 {
7091 /* Search for image with allocated block. Do not attempt to
7092 * read more than the previous reads marked as valid.
7093 * Otherwise this would return stale data when different
7094 * block sizes are used for the images. */
7095 for (PVDIMAGE pCurrImage = pImageTo->pPrev;
7096 pCurrImage != NULL && pCurrImage != pImageFrom->pPrev && rc == VERR_VD_BLOCK_FREE;
7097 pCurrImage = pCurrImage->pPrev)
7098 {
7099 /*
7100 * Skip reading when offset exceeds image size which can happen when the target is
7101 * bigger than the source.
7102 */
7103 uint64_t cbImage = vdImageGetSize(pCurrImage);
7104 if (uOffset < cbImage)
7105 {
7106 cbThisRead = RT_MIN(cbThisRead, cbImage - uOffset);
7107 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
7108 uOffset, cbThisRead,
7109 &IoCtx, &cbThisRead);
7110 }
7111 else
7112 rc = VERR_VD_BLOCK_FREE;
7113 }
7114
7115 if (rc != VERR_VD_BLOCK_FREE)
7116 {
7117 if (RT_FAILURE(rc))
7118 break;
7119 /* Updating the cache is required because this might be a live merge. */
7120 rc = vdWriteHelperEx(pDisk, pImageTo, pImageFrom->pPrev,
7121 uOffset, pvBuf, cbThisRead,
7122 VDIOCTX_FLAGS_READ_UPDATE_CACHE, 0);
7123 if (RT_FAILURE(rc))
7124 break;
7125 }
7126 else
7127 rc = VINF_SUCCESS;
7128 }
7129 else if (RT_FAILURE(rc))
7130 break;
7131
7132 rc2 = vdThreadFinishWrite(pDisk);
7133 AssertRC(rc2);
7134 fLockWrite = false;
7135
7136 uOffset += cbThisRead;
7137 cbRemaining -= cbThisRead;
7138
7139 if (pIfProgress && pIfProgress->pfnProgress)
7140 {
7141 /** @todo r=klaus: this can update the progress to the same
7142 * percentage over and over again if the image format makes
7143 * relatively small increments. */
7144 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
7145 uOffset * 99 / cbSize);
7146 if (RT_FAILURE(rc))
7147 break;
7148 }
7149 } while (uOffset < cbSize);
7150 }
7151 else
7152 {
7153 /*
7154 * We may need to update the parent uuid of the child coming after
7155 * the last image to be merged. We have to reopen it read/write.
7156 *
7157 * This is done before we do the actual merge to prevent an
7158 * inconsistent chain if the mode change fails for some reason.
7159 */
7160 if (pImageFrom->pNext)
7161 {
7162 PVDIMAGE pImageChild = pImageFrom->pNext;
7163
7164 /* Take the write lock. */
7165 rc2 = vdThreadStartWrite(pDisk);
7166 AssertRC(rc2);
7167 fLockWrite = true;
7168
7169 /* We need to open the image in read/write mode. */
7170 uOpenFlags = pImageChild->Backend->pfnGetOpenFlags(pImageChild->pBackendData);
7171
7172 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
7173 {
7174 uOpenFlags &= ~VD_OPEN_FLAGS_READONLY;
7175 rc = pImageChild->Backend->pfnSetOpenFlags(pImageChild->pBackendData,
7176 uOpenFlags);
7177 if (RT_FAILURE(rc))
7178 break;
7179 }
7180
7181 rc2 = vdThreadFinishWrite(pDisk);
7182 AssertRC(rc2);
7183 fLockWrite = false;
7184 }
7185
7186 /* If the merge is from the last image we have to relay all writes
7187 * to the merge destination as well, so that concurrent writes
7188 * (in case of a live merge) are handled correctly. */
7189 if (!pImageFrom->pNext)
7190 {
7191 /* Take the write lock. */
7192 rc2 = vdThreadStartWrite(pDisk);
7193 AssertRC(rc2);
7194 fLockWrite = true;
7195
7196 pDisk->pImageRelay = pImageTo;
7197
7198 rc2 = vdThreadFinishWrite(pDisk);
7199 AssertRC(rc2);
7200 fLockWrite = false;
7201 }
7202
7203 /* Merge child state into parent. This means writing all blocks
7204 * which are allocated in the image up to the source image to the
7205 * destination image. */
7206 unsigned uProgressOld = 0;
7207 uint64_t uOffset = 0;
7208 uint64_t cbRemaining = cbSize;
7209 do
7210 {
7211 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
7212 RTSGSEG SegmentBuf;
7213 RTSGBUF SgBuf;
7214 VDIOCTX IoCtx;
7215
7216 rc = VERR_VD_BLOCK_FREE;
7217
7218 SegmentBuf.pvSeg = pvBuf;
7219 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
7220 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
7221 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
7222 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
7223
7224 /* Need to hold the write lock during a read-write operation. */
7225 rc2 = vdThreadStartWrite(pDisk);
7226 AssertRC(rc2);
7227 fLockWrite = true;
7228
7229 /* Search for image with allocated block. Do not attempt to
7230 * read more than the previous reads marked as valid. Otherwise
7231 * this would return stale data when different block sizes are
7232 * used for the images. */
7233 for (PVDIMAGE pCurrImage = pImageFrom;
7234 pCurrImage != NULL && pCurrImage != pImageTo && rc == VERR_VD_BLOCK_FREE;
7235 pCurrImage = pCurrImage->pPrev)
7236 {
7237 /*
7238 * Skip reading when offset exceeds image size which can happen when the target is
7239 * bigger than the source.
7240 */
7241 uint64_t cbImage = vdImageGetSize(pCurrImage);
7242 if (uOffset < cbImage)
7243 {
7244 cbThisRead = RT_MIN(cbThisRead, cbImage - uOffset);
7245 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
7246 uOffset, cbThisRead,
7247 &IoCtx, &cbThisRead);
7248 }
7249 else
7250 rc = VERR_VD_BLOCK_FREE;
7251 }
7252
7253 if (rc != VERR_VD_BLOCK_FREE)
7254 {
7255 if (RT_FAILURE(rc))
7256 break;
7257 rc = vdWriteHelper(pDisk, pImageTo, uOffset, pvBuf,
7258 cbThisRead, VDIOCTX_FLAGS_READ_UPDATE_CACHE);
7259 if (RT_FAILURE(rc))
7260 break;
7261 }
7262 else
7263 rc = VINF_SUCCESS;
7264
7265 rc2 = vdThreadFinishWrite(pDisk);
7266 AssertRC(rc2);
7267 fLockWrite = false;
7268
7269 uOffset += cbThisRead;
7270 cbRemaining -= cbThisRead;
7271
7272 unsigned uProgressNew = uOffset * 99 / cbSize;
7273 if (uProgressNew != uProgressOld)
7274 {
7275 uProgressOld = uProgressNew;
7276
7277 if (pIfProgress && pIfProgress->pfnProgress)
7278 {
7279 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
7280 uProgressOld);
7281 if (RT_FAILURE(rc))
7282 break;
7283 }
7284 }
7285
7286 } while (uOffset < cbSize);
7287
7288 /* In case we set up a "write proxy" image above we must clear
7289 * this again now to prevent stray writes. Failure or not. */
7290 if (!pImageFrom->pNext)
7291 {
7292 /* Take the write lock. */
7293 rc2 = vdThreadStartWrite(pDisk);
7294 AssertRC(rc2);
7295 fLockWrite = true;
7296
7297 pDisk->pImageRelay = NULL;
7298
7299 rc2 = vdThreadFinishWrite(pDisk);
7300 AssertRC(rc2);
7301 fLockWrite = false;
7302 }
7303 }
7304
7305 /*
7306 * Leave in case of an error to avoid corrupted data in the image chain
7307 * (includes cancelling the operation by the user).
7308 */
7309 if (RT_FAILURE(rc))
7310 break;
7311
7312 /* Need to hold the write lock while finishing the merge. */
7313 rc2 = vdThreadStartWrite(pDisk);
7314 AssertRC(rc2);
7315 fLockWrite = true;
7316
7317 /* Update parent UUID so that image chain is consistent.
7318 * The two attempts work around the problem that some backends
7319 * (e.g. iSCSI) do not support UUIDs, so we exploit the fact that
7320 * so far there can only be one such image in the chain. */
7321 /** @todo needs a better long-term solution, passing the UUID
7322 * knowledge from the caller or some such */
7323 RTUUID Uuid;
7324 PVDIMAGE pImageChild = NULL;
7325 if (nImageFrom < nImageTo)
7326 {
7327 if (pImageFrom->pPrev)
7328 {
7329 /* plan A: ask the parent itself for its UUID */
7330 rc = pImageFrom->pPrev->Backend->pfnGetUuid(pImageFrom->pPrev->pBackendData,
7331 &Uuid);
7332 if (RT_FAILURE(rc))
7333 {
7334 /* plan B: ask the child of the parent for parent UUID */
7335 rc = pImageFrom->Backend->pfnGetParentUuid(pImageFrom->pBackendData,
7336 &Uuid);
7337 }
7338 AssertRC(rc);
7339 }
7340 else
7341 RTUuidClear(&Uuid);
7342 rc = pImageTo->Backend->pfnSetParentUuid(pImageTo->pBackendData,
7343 &Uuid);
7344 AssertRC(rc);
7345 }
7346 else
7347 {
7348 /* Update the parent uuid of the child of the last merged image. */
7349 if (pImageFrom->pNext)
7350 {
7351 /* plan A: ask the parent itself for its UUID */
7352 rc = pImageTo->Backend->pfnGetUuid(pImageTo->pBackendData,
7353 &Uuid);
7354 if (RT_FAILURE(rc))
7355 {
7356 /* plan B: ask the child of the parent for parent UUID */
7357 rc = pImageTo->pNext->Backend->pfnGetParentUuid(pImageTo->pNext->pBackendData,
7358 &Uuid);
7359 }
7360 AssertRC(rc);
7361
7362 rc = pImageFrom->Backend->pfnSetParentUuid(pImageFrom->pNext->pBackendData,
7363 &Uuid);
7364 AssertRC(rc);
7365
7366 pImageChild = pImageFrom->pNext;
7367 }
7368 }
7369
7370 /* Delete the no longer needed images. */
7371 PVDIMAGE pImg = pImageFrom, pTmp;
7372 while (pImg != pImageTo)
7373 {
7374 if (nImageFrom < nImageTo)
7375 pTmp = pImg->pNext;
7376 else
7377 pTmp = pImg->pPrev;
7378 vdRemoveImageFromList(pDisk, pImg);
7379 pImg->Backend->pfnClose(pImg->pBackendData, true);
7380 RTMemFree(pImg->pszFilename);
7381 RTMemFree(pImg);
7382 pImg = pTmp;
7383 }
7384
7385 /* Make sure destination image is back to read only if necessary. */
7386 if (pImageTo != pDisk->pLast)
7387 {
7388 uOpenFlags = pImageTo->Backend->pfnGetOpenFlags(pImageTo->pBackendData);
7389 uOpenFlags |= VD_OPEN_FLAGS_READONLY;
7390 rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
7391 uOpenFlags);
7392 if (RT_FAILURE(rc))
7393 break;
7394 }
7395
7396 /*
7397 * Make sure the child is readonly
7398 * for the child -> parent merge direction
7399 * if necessary.
7400 */
7401 if ( nImageFrom > nImageTo
7402 && pImageChild
7403 && pImageChild != pDisk->pLast)
7404 {
7405 uOpenFlags = pImageChild->Backend->pfnGetOpenFlags(pImageChild->pBackendData);
7406 uOpenFlags |= VD_OPEN_FLAGS_READONLY;
7407 rc = pImageChild->Backend->pfnSetOpenFlags(pImageChild->pBackendData,
7408 uOpenFlags);
7409 if (RT_FAILURE(rc))
7410 break;
7411 }
7412 } while (0);
7413
7414 if (RT_UNLIKELY(fLockWrite))
7415 {
7416 rc2 = vdThreadFinishWrite(pDisk);
7417 AssertRC(rc2);
7418 }
7419 else if (RT_UNLIKELY(fLockRead))
7420 {
7421 rc2 = vdThreadFinishRead(pDisk);
7422 AssertRC(rc2);
7423 }
7424
7425 if (pvBuf)
7426 RTMemTmpFree(pvBuf);
7427
7428 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
7429 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
7430
7431 LogFlowFunc(("returns %Rrc\n", rc));
7432 return rc;
7433}
7434
7435/**
7436 * Copies an image from one HDD container to another - extended version.
7437 * The copy is opened in the target HDD container.
7438 * It is possible to convert between different image formats, because the
7439 * backend for the destination may be different from the source.
7440 * If both the source and destination reference the same HDD container,
7441 * then the image is moved (by copying/deleting or renaming) to the new location.
7442 * The source container is unchanged if the move operation fails, otherwise
7443 * the image at the new location is opened in the same way as the old one was.
7444 *
7445 * @note The read/write accesses across disks are not synchronized, just the
7446 * accesses to each disk. Once there is a use case which requires a defined
7447 * read/write behavior in this situation this needs to be extended.
7448 *
7449 * @returns VBox status code.
7450 * @retval VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
7451 * @param pDiskFrom Pointer to source HDD container.
7452 * @param nImage Image number, counts from 0. 0 is always base image of container.
7453 * @param pDiskTo Pointer to destination HDD container.
7454 * @param pszBackend Name of the image file backend to use (may be NULL to use the same as the source, case insensitive).
7455 * @param pszFilename New name of the image (may be NULL to specify that the
7456 * copy destination is the destination container, or
7457 * if pDiskFrom == pDiskTo, i.e. when moving).
7458 * @param fMoveByRename If true, attempt to perform a move by renaming (if successful the new size is ignored).
7459 * @param cbSize New image size (0 means leave unchanged).
7460 * @param nImageFromSame todo
7461 * @param nImageToSame todo
7462 * @param uImageFlags Flags specifying special destination image features.
7463 * @param pDstUuid New UUID of the destination image. If NULL, a new UUID is created.
7464 * This parameter is used if and only if a true copy is created.
7465 * In all rename/move cases or copy to existing image cases the modification UUIDs are copied over.
7466 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
7467 * Only used if the destination image is created.
7468 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7469 * @param pDstVDIfsImage Pointer to the per-image VD interface list, for the
7470 * destination image.
7471 * @param pDstVDIfsOperation Pointer to the per-operation VD interface list,
7472 * for the destination operation.
7473 */
7474VBOXDDU_DECL(int) VDCopyEx(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
7475 const char *pszBackend, const char *pszFilename,
7476 bool fMoveByRename, uint64_t cbSize,
7477 unsigned nImageFromSame, unsigned nImageToSame,
7478 unsigned uImageFlags, PCRTUUID pDstUuid,
7479 unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,
7480 PVDINTERFACE pDstVDIfsImage,
7481 PVDINTERFACE pDstVDIfsOperation)
7482{
7483 int rc = VINF_SUCCESS;
7484 int rc2;
7485 bool fLockReadFrom = false, fLockWriteFrom = false, fLockWriteTo = false;
7486 PVDIMAGE pImageTo = NULL;
7487
7488 LogFlowFunc(("pDiskFrom=%#p nImage=%u pDiskTo=%#p pszBackend=\"%s\" pszFilename=\"%s\" fMoveByRename=%d cbSize=%llu nImageFromSame=%u nImageToSame=%u uImageFlags=%#x pDstUuid=%#p uOpenFlags=%#x pVDIfsOperation=%#p pDstVDIfsImage=%#p pDstVDIfsOperation=%#p\n",
7489 pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename, cbSize, nImageFromSame, nImageToSame, uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation, pDstVDIfsImage, pDstVDIfsOperation));
7490
7491 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7492 PVDINTERFACEPROGRESS pDstIfProgress = VDIfProgressGet(pDstVDIfsOperation);
7493
7494 do {
7495 /* Check arguments. */
7496 AssertMsgBreakStmt(VALID_PTR(pDiskFrom), ("pDiskFrom=%#p\n", pDiskFrom),
7497 rc = VERR_INVALID_PARAMETER);
7498 AssertMsg(pDiskFrom->u32Signature == VDISK_SIGNATURE,
7499 ("u32Signature=%08x\n", pDiskFrom->u32Signature));
7500
7501 rc2 = vdThreadStartRead(pDiskFrom);
7502 AssertRC(rc2);
7503 fLockReadFrom = true;
7504 PVDIMAGE pImageFrom = vdGetImageByNumber(pDiskFrom, nImage);
7505 AssertPtrBreakStmt(pImageFrom, rc = VERR_VD_IMAGE_NOT_FOUND);
7506 AssertMsgBreakStmt(VALID_PTR(pDiskTo), ("pDiskTo=%#p\n", pDiskTo),
7507 rc = VERR_INVALID_PARAMETER);
7508 AssertMsg(pDiskTo->u32Signature == VDISK_SIGNATURE,
7509 ("u32Signature=%08x\n", pDiskTo->u32Signature));
7510 AssertMsgBreakStmt( (nImageFromSame < nImage || nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)
7511 && (nImageToSame < pDiskTo->cImages || nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
7512 && ( (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN && nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
7513 || (nImageFromSame != VD_IMAGE_CONTENT_UNKNOWN && nImageToSame != VD_IMAGE_CONTENT_UNKNOWN)),
7514 ("nImageFromSame=%u nImageToSame=%u\n", nImageFromSame, nImageToSame),
7515 rc = VERR_INVALID_PARAMETER);
7516
7517 /* Move the image. */
7518 if (pDiskFrom == pDiskTo)
7519 {
7520 /* Rename only works when backends are the same, are file based
7521 * and the rename method is implemented. */
7522 if ( fMoveByRename
7523 && !RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName)
7524 && pImageFrom->Backend->uBackendCaps & VD_CAP_FILE
7525 && pImageFrom->Backend->pfnRename)
7526 {
7527 rc2 = vdThreadFinishRead(pDiskFrom);
7528 AssertRC(rc2);
7529 fLockReadFrom = false;
7530
7531 rc2 = vdThreadStartWrite(pDiskFrom);
7532 AssertRC(rc2);
7533 fLockWriteFrom = true;
7534 rc = pImageFrom->Backend->pfnRename(pImageFrom->pBackendData, pszFilename ? pszFilename : pImageFrom->pszFilename);
7535 break;
7536 }
7537
7538 /** @todo Moving (including shrinking/growing) of the image is
7539 * requested, but the rename attempt failed or it wasn't possible.
7540 * Must now copy image to temp location. */
7541 AssertReleaseMsgFailed(("VDCopy: moving by copy/delete not implemented\n"));
7542 }
7543
7544 /* pszFilename is allowed to be NULL, as this indicates copy to the existing image. */
7545 AssertMsgBreakStmt(pszFilename == NULL || (VALID_PTR(pszFilename) && *pszFilename),
7546 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
7547 rc = VERR_INVALID_PARAMETER);
7548
7549 uint64_t cbSizeFrom;
7550 cbSizeFrom = vdImageGetSize(pImageFrom);
7551 if (cbSizeFrom == 0)
7552 {
7553 rc = VERR_VD_VALUE_NOT_FOUND;
7554 break;
7555 }
7556
7557 VDGEOMETRY PCHSGeometryFrom = {0, 0, 0};
7558 VDGEOMETRY LCHSGeometryFrom = {0, 0, 0};
7559 pImageFrom->Backend->pfnGetPCHSGeometry(pImageFrom->pBackendData, &PCHSGeometryFrom);
7560 pImageFrom->Backend->pfnGetLCHSGeometry(pImageFrom->pBackendData, &LCHSGeometryFrom);
7561
7562 RTUUID ImageUuid, ImageModificationUuid;
7563 if (pDiskFrom != pDiskTo)
7564 {
7565 if (pDstUuid)
7566 ImageUuid = *pDstUuid;
7567 else
7568 RTUuidCreate(&ImageUuid);
7569 }
7570 else
7571 {
7572 rc = pImageFrom->Backend->pfnGetUuid(pImageFrom->pBackendData, &ImageUuid);
7573 if (RT_FAILURE(rc))
7574 RTUuidCreate(&ImageUuid);
7575 }
7576 rc = pImageFrom->Backend->pfnGetModificationUuid(pImageFrom->pBackendData, &ImageModificationUuid);
7577 if (RT_FAILURE(rc))
7578 RTUuidClear(&ImageModificationUuid);
7579
7580 char szComment[1024];
7581 rc = pImageFrom->Backend->pfnGetComment(pImageFrom->pBackendData, szComment, sizeof(szComment));
7582 if (RT_FAILURE(rc))
7583 szComment[0] = '\0';
7584 else
7585 szComment[sizeof(szComment) - 1] = '\0';
7586
7587 rc2 = vdThreadFinishRead(pDiskFrom);
7588 AssertRC(rc2);
7589 fLockReadFrom = false;
7590
7591 rc2 = vdThreadStartRead(pDiskTo);
7592 AssertRC(rc2);
7593 unsigned cImagesTo = pDiskTo->cImages;
7594 rc2 = vdThreadFinishRead(pDiskTo);
7595 AssertRC(rc2);
7596
7597 if (pszFilename)
7598 {
7599 if (cbSize == 0)
7600 cbSize = cbSizeFrom;
7601
7602 /* Create destination image with the properties of source image. */
7603 /** @todo replace the VDCreateDiff/VDCreateBase calls by direct
7604 * calls to the backend. Unifies the code and reduces the API
7605 * dependencies. Would also make the synchronization explicit. */
7606 if (cImagesTo > 0)
7607 {
7608 rc = VDCreateDiff(pDiskTo, pszBackend, pszFilename,
7609 uImageFlags, szComment, &ImageUuid,
7610 NULL /* pParentUuid */,
7611 uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
7612 pDstVDIfsImage, NULL);
7613
7614 rc2 = vdThreadStartWrite(pDiskTo);
7615 AssertRC(rc2);
7616 fLockWriteTo = true;
7617 } else {
7618 /** @todo hack to force creation of a fixed image for
7619 * the RAW backend, which can't handle anything else. */
7620 if (!RTStrICmp(pszBackend, "RAW"))
7621 uImageFlags |= VD_IMAGE_FLAGS_FIXED;
7622
7623 vdFixupPCHSGeometry(&PCHSGeometryFrom, cbSize);
7624 vdFixupLCHSGeometry(&LCHSGeometryFrom, cbSize);
7625
7626 rc = VDCreateBase(pDiskTo, pszBackend, pszFilename, cbSize,
7627 uImageFlags, szComment,
7628 &PCHSGeometryFrom, &LCHSGeometryFrom,
7629 NULL, uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
7630 pDstVDIfsImage, NULL);
7631
7632 rc2 = vdThreadStartWrite(pDiskTo);
7633 AssertRC(rc2);
7634 fLockWriteTo = true;
7635
7636 if (RT_SUCCESS(rc) && !RTUuidIsNull(&ImageUuid))
7637 pDiskTo->pLast->Backend->pfnSetUuid(pDiskTo->pLast->pBackendData, &ImageUuid);
7638 }
7639 if (RT_FAILURE(rc))
7640 break;
7641
7642 pImageTo = pDiskTo->pLast;
7643 AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
7644
7645 cbSize = RT_MIN(cbSize, cbSizeFrom);
7646 }
7647 else
7648 {
7649 pImageTo = pDiskTo->pLast;
7650 AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
7651
7652 uint64_t cbSizeTo;
7653 cbSizeTo = vdImageGetSize(pImageTo);
7654 if (cbSizeTo == 0)
7655 {
7656 rc = VERR_VD_VALUE_NOT_FOUND;
7657 break;
7658 }
7659
7660 if (cbSize == 0)
7661 cbSize = RT_MIN(cbSizeFrom, cbSizeTo);
7662
7663 vdFixupPCHSGeometry(&PCHSGeometryFrom, cbSize);
7664 vdFixupLCHSGeometry(&LCHSGeometryFrom, cbSize);
7665
7666 /* Update the geometry in the destination image. */
7667 pImageTo->Backend->pfnSetPCHSGeometry(pImageTo->pBackendData, &PCHSGeometryFrom);
7668 pImageTo->Backend->pfnSetLCHSGeometry(pImageTo->pBackendData, &LCHSGeometryFrom);
7669 }
7670
7671 rc2 = vdThreadFinishWrite(pDiskTo);
7672 AssertRC(rc2);
7673 fLockWriteTo = false;
7674
7675 /* Whether we can take the optimized copy path (false) or not.
7676 * Don't optimize if the image existed or if it is a child image. */
7677 bool fSuppressRedundantIo = ( !(pszFilename == NULL || cImagesTo > 0)
7678 || (nImageToSame != VD_IMAGE_CONTENT_UNKNOWN));
7679 unsigned cImagesFromReadBack, cImagesToReadBack;
7680
7681 if (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)
7682 cImagesFromReadBack = 0;
7683 else
7684 {
7685 if (nImage == VD_LAST_IMAGE)
7686 cImagesFromReadBack = pDiskFrom->cImages - nImageFromSame - 1;
7687 else
7688 cImagesFromReadBack = nImage - nImageFromSame;
7689 }
7690
7691 if (nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
7692 cImagesToReadBack = 0;
7693 else
7694 cImagesToReadBack = pDiskTo->cImages - nImageToSame - 1;
7695
7696 /* Copy the data. */
7697 rc = vdCopyHelper(pDiskFrom, pImageFrom, pDiskTo, cbSize,
7698 cImagesFromReadBack, cImagesToReadBack,
7699 fSuppressRedundantIo, pIfProgress, pDstIfProgress);
7700
7701 if (RT_SUCCESS(rc))
7702 {
7703 rc2 = vdThreadStartWrite(pDiskTo);
7704 AssertRC(rc2);
7705 fLockWriteTo = true;
7706
7707 /* Only set modification UUID if it is non-null, since the source
7708 * backend might not provide a valid modification UUID. */
7709 if (!RTUuidIsNull(&ImageModificationUuid))
7710 pImageTo->Backend->pfnSetModificationUuid(pImageTo->pBackendData, &ImageModificationUuid);
7711
7712 /* Set the requested open flags if they differ from the value
7713 * required for creating the image and copying the contents. */
7714 if ( pImageTo && pszFilename
7715 && uOpenFlags != (uOpenFlags & ~VD_OPEN_FLAGS_READONLY))
7716 rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
7717 uOpenFlags);
7718 }
7719 } while (0);
7720
7721 if (RT_FAILURE(rc) && pImageTo && pszFilename)
7722 {
7723 /* Take the write lock only if it is not taken. Not worth making the
7724 * above code even more complicated. */
7725 if (RT_UNLIKELY(!fLockWriteTo))
7726 {
7727 rc2 = vdThreadStartWrite(pDiskTo);
7728 AssertRC(rc2);
7729 fLockWriteTo = true;
7730 }
7731 /* Error detected, but new image created. Remove image from list. */
7732 vdRemoveImageFromList(pDiskTo, pImageTo);
7733
7734 /* Close and delete image. */
7735 rc2 = pImageTo->Backend->pfnClose(pImageTo->pBackendData, true);
7736 AssertRC(rc2);
7737 pImageTo->pBackendData = NULL;
7738
7739 /* Free remaining resources. */
7740 if (pImageTo->pszFilename)
7741 RTStrFree(pImageTo->pszFilename);
7742
7743 RTMemFree(pImageTo);
7744 }
7745
7746 if (RT_UNLIKELY(fLockWriteTo))
7747 {
7748 rc2 = vdThreadFinishWrite(pDiskTo);
7749 AssertRC(rc2);
7750 }
7751 if (RT_UNLIKELY(fLockWriteFrom))
7752 {
7753 rc2 = vdThreadFinishWrite(pDiskFrom);
7754 AssertRC(rc2);
7755 }
7756 else if (RT_UNLIKELY(fLockReadFrom))
7757 {
7758 rc2 = vdThreadFinishRead(pDiskFrom);
7759 AssertRC(rc2);
7760 }
7761
7762 if (RT_SUCCESS(rc))
7763 {
7764 if (pIfProgress && pIfProgress->pfnProgress)
7765 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
7766 if (pDstIfProgress && pDstIfProgress->pfnProgress)
7767 pDstIfProgress->pfnProgress(pDstIfProgress->Core.pvUser, 100);
7768 }
7769
7770 LogFlowFunc(("returns %Rrc\n", rc));
7771 return rc;
7772}
7773
7774/**
7775 * Copies an image from one HDD container to another.
7776 * The copy is opened in the target HDD container.
7777 * It is possible to convert between different image formats, because the
7778 * backend for the destination may be different from the source.
7779 * If both the source and destination reference the same HDD container,
7780 * then the image is moved (by copying/deleting or renaming) to the new location.
7781 * The source container is unchanged if the move operation fails, otherwise
7782 * the image at the new location is opened in the same way as the old one was.
7783 *
7784 * @returns VBox status code.
7785 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
7786 * @param pDiskFrom Pointer to source HDD container.
7787 * @param nImage Image number, counts from 0. 0 is always base image of container.
7788 * @param pDiskTo Pointer to destination HDD container.
7789 * @param pszBackend Name of the image file backend to use.
7790 * @param pszFilename New name of the image (may be NULL if pDiskFrom == pDiskTo).
7791 * @param fMoveByRename If true, attempt to perform a move by renaming (if successful the new size is ignored).
7792 * @param cbSize New image size (0 means leave unchanged).
7793 * @param uImageFlags Flags specifying special destination image features.
7794 * @param pDstUuid New UUID of the destination image. If NULL, a new UUID is created.
7795 * This parameter is used if and only if a true copy is created.
7796 * In all rename/move cases the UUIDs are copied over.
7797 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
7798 * Only used if the destination image is created.
7799 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7800 * @param pDstVDIfsImage Pointer to the per-image VD interface list, for the
7801 * destination image.
7802 * @param pDstVDIfsOperation Pointer to the per-image VD interface list,
7803 * for the destination image.
7804 */
7805VBOXDDU_DECL(int) VDCopy(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
7806 const char *pszBackend, const char *pszFilename,
7807 bool fMoveByRename, uint64_t cbSize,
7808 unsigned uImageFlags, PCRTUUID pDstUuid,
7809 unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,
7810 PVDINTERFACE pDstVDIfsImage,
7811 PVDINTERFACE pDstVDIfsOperation)
7812{
7813 return VDCopyEx(pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename,
7814 cbSize, VD_IMAGE_CONTENT_UNKNOWN, VD_IMAGE_CONTENT_UNKNOWN,
7815 uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation,
7816 pDstVDIfsImage, pDstVDIfsOperation);
7817}
7818
7819/**
7820 * Optimizes the storage consumption of an image. Typically the unused blocks
7821 * have to be wiped with zeroes to achieve a substantial reduced storage use.
7822 * Another optimization done is reordering the image blocks, which can provide
7823 * a significant performance boost, as reads and writes tend to use less random
7824 * file offsets.
7825 *
7826 * @return VBox status code.
7827 * @return VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
7828 * @return VERR_VD_IMAGE_READ_ONLY if image is not writable.
7829 * @return VERR_NOT_SUPPORTED if this kind of image can be compacted, but
7830 * the code for this isn't implemented yet.
7831 * @param pDisk Pointer to HDD container.
7832 * @param nImage Image number, counts from 0. 0 is always base image of container.
7833 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7834 */
7835VBOXDDU_DECL(int) VDCompact(PVDISK pDisk, unsigned nImage,
7836 PVDINTERFACE pVDIfsOperation)
7837{
7838 int rc = VINF_SUCCESS;
7839 int rc2;
7840 bool fLockRead = false, fLockWrite = false;
7841 void *pvBuf = NULL;
7842 void *pvTmp = NULL;
7843
7844 LogFlowFunc(("pDisk=%#p nImage=%u pVDIfsOperation=%#p\n",
7845 pDisk, nImage, pVDIfsOperation));
7846
7847 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7848
7849 do {
7850 /* Check arguments. */
7851 AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
7852 rc = VERR_INVALID_PARAMETER);
7853 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
7854 ("u32Signature=%08x\n", pDisk->u32Signature));
7855
7856 rc2 = vdThreadStartRead(pDisk);
7857 AssertRC(rc2);
7858 fLockRead = true;
7859
7860 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
7861 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
7862
7863 /* If there is no compact callback for not file based backends then
7864 * the backend doesn't need compaction. No need to make much fuss about
7865 * this. For file based ones signal this as not yet supported. */
7866 if (!pImage->Backend->pfnCompact)
7867 {
7868 if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
7869 rc = VERR_NOT_SUPPORTED;
7870 else
7871 rc = VINF_SUCCESS;
7872 break;
7873 }
7874
7875 /* Insert interface for reading parent state into per-operation list,
7876 * if there is a parent image. */
7877 VDINTERFACEPARENTSTATE VDIfParent;
7878 VDPARENTSTATEDESC ParentUser;
7879 if (pImage->pPrev)
7880 {
7881 VDIfParent.pfnParentRead = vdParentRead;
7882 ParentUser.pDisk = pDisk;
7883 ParentUser.pImage = pImage->pPrev;
7884 rc = VDInterfaceAdd(&VDIfParent.Core, "VDCompact_ParentState", VDINTERFACETYPE_PARENTSTATE,
7885 &ParentUser, sizeof(VDINTERFACEPARENTSTATE), &pVDIfsOperation);
7886 AssertRC(rc);
7887 }
7888
7889 rc2 = vdThreadFinishRead(pDisk);
7890 AssertRC(rc2);
7891 fLockRead = false;
7892
7893 rc2 = vdThreadStartWrite(pDisk);
7894 AssertRC(rc2);
7895 fLockWrite = true;
7896
7897 rc = pImage->Backend->pfnCompact(pImage->pBackendData,
7898 0, 99,
7899 pDisk->pVDIfsDisk,
7900 pImage->pVDIfsImage,
7901 pVDIfsOperation);
7902 } while (0);
7903
7904 if (RT_UNLIKELY(fLockWrite))
7905 {
7906 rc2 = vdThreadFinishWrite(pDisk);
7907 AssertRC(rc2);
7908 }
7909 else if (RT_UNLIKELY(fLockRead))
7910 {
7911 rc2 = vdThreadFinishRead(pDisk);
7912 AssertRC(rc2);
7913 }
7914
7915 if (pvBuf)
7916 RTMemTmpFree(pvBuf);
7917 if (pvTmp)
7918 RTMemTmpFree(pvTmp);
7919
7920 if (RT_SUCCESS(rc))
7921 {
7922 if (pIfProgress && pIfProgress->pfnProgress)
7923 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
7924 }
7925
7926 LogFlowFunc(("returns %Rrc\n", rc));
7927 return rc;
7928}
7929
7930/**
7931 * Resizes the given disk image to the given size.
7932 *
7933 * @return VBox status
7934 * @return VERR_VD_IMAGE_READ_ONLY if image is not writable.
7935 * @return VERR_NOT_SUPPORTED if this kind of image can be compacted, but
7936 *
7937 * @param pDisk Pointer to the HDD container.
7938 * @param cbSize New size of the image.
7939 * @param pPCHSGeometry Pointer to the new physical disk geometry <= (16383,16,63). Not NULL.
7940 * @param pLCHSGeometry Pointer to the new logical disk geometry <= (x,255,63). Not NULL.
7941 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7942 */
7943VBOXDDU_DECL(int) VDResize(PVDISK pDisk, uint64_t cbSize,
7944 PCVDGEOMETRY pPCHSGeometry,
7945 PCVDGEOMETRY pLCHSGeometry,
7946 PVDINTERFACE pVDIfsOperation)
7947{
7948 /** @todo r=klaus resizing was designed to be part of VDCopy, so having a separate function is not desirable. */
7949 int rc = VINF_SUCCESS;
7950 int rc2;
7951 bool fLockRead = false, fLockWrite = false;
7952
7953 LogFlowFunc(("pDisk=%#p cbSize=%llu pVDIfsOperation=%#p\n",
7954 pDisk, cbSize, pVDIfsOperation));
7955
7956 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7957
7958 do {
7959 /* Check arguments. */
7960 AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
7961 rc = VERR_INVALID_PARAMETER);
7962 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
7963 ("u32Signature=%08x\n", pDisk->u32Signature));
7964
7965 rc2 = vdThreadStartRead(pDisk);
7966 AssertRC(rc2);
7967 fLockRead = true;
7968
7969 /* Must have at least one image in the chain, will resize last. */
7970 AssertMsgBreakStmt(pDisk->cImages >= 1, ("cImages=%u\n", pDisk->cImages),
7971 rc = VERR_NOT_SUPPORTED);
7972
7973 PVDIMAGE pImage = pDisk->pLast;
7974
7975 /* If there is no compact callback for not file based backends then
7976 * the backend doesn't need compaction. No need to make much fuss about
7977 * this. For file based ones signal this as not yet supported. */
7978 if (!pImage->Backend->pfnResize)
7979 {
7980 if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
7981 rc = VERR_NOT_SUPPORTED;
7982 else
7983 rc = VINF_SUCCESS;
7984 break;
7985 }
7986
7987 rc2 = vdThreadFinishRead(pDisk);
7988 AssertRC(rc2);
7989 fLockRead = false;
7990
7991 rc2 = vdThreadStartWrite(pDisk);
7992 AssertRC(rc2);
7993 fLockWrite = true;
7994
7995 VDGEOMETRY PCHSGeometryOld;
7996 VDGEOMETRY LCHSGeometryOld;
7997 PCVDGEOMETRY pPCHSGeometryNew;
7998 PCVDGEOMETRY pLCHSGeometryNew;
7999
8000 if (pPCHSGeometry->cCylinders == 0)
8001 {
8002 /* Auto-detect marker, calculate new value ourself. */
8003 rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData, &PCHSGeometryOld);
8004 if (RT_SUCCESS(rc) && (PCHSGeometryOld.cCylinders != 0))
8005 PCHSGeometryOld.cCylinders = RT_MIN(cbSize / 512 / PCHSGeometryOld.cHeads / PCHSGeometryOld.cSectors, 16383);
8006 else if (rc == VERR_VD_GEOMETRY_NOT_SET)
8007 rc = VINF_SUCCESS;
8008
8009 pPCHSGeometryNew = &PCHSGeometryOld;
8010 }
8011 else
8012 pPCHSGeometryNew = pPCHSGeometry;
8013
8014 if (pLCHSGeometry->cCylinders == 0)
8015 {
8016 /* Auto-detect marker, calculate new value ourself. */
8017 rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData, &LCHSGeometryOld);
8018 if (RT_SUCCESS(rc) && (LCHSGeometryOld.cCylinders != 0))
8019 LCHSGeometryOld.cCylinders = cbSize / 512 / LCHSGeometryOld.cHeads / LCHSGeometryOld.cSectors;
8020 else if (rc == VERR_VD_GEOMETRY_NOT_SET)
8021 rc = VINF_SUCCESS;
8022
8023 pLCHSGeometryNew = &LCHSGeometryOld;
8024 }
8025 else
8026 pLCHSGeometryNew = pLCHSGeometry;
8027
8028 if (RT_SUCCESS(rc))
8029 rc = pImage->Backend->pfnResize(pImage->pBackendData,
8030 cbSize,
8031 pPCHSGeometryNew,
8032 pLCHSGeometryNew,
8033 0, 99,
8034 pDisk->pVDIfsDisk,
8035 pImage->pVDIfsImage,
8036 pVDIfsOperation);
8037 /* Mark the image size as uninitialized so it gets recalculated the next time. */
8038 if (RT_SUCCESS(rc))
8039 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
8040 } while (0);
8041
8042 if (RT_UNLIKELY(fLockWrite))
8043 {
8044 rc2 = vdThreadFinishWrite(pDisk);
8045 AssertRC(rc2);
8046 }
8047 else if (RT_UNLIKELY(fLockRead))
8048 {
8049 rc2 = vdThreadFinishRead(pDisk);
8050 AssertRC(rc2);
8051 }
8052
8053 if (RT_SUCCESS(rc))
8054 {
8055 if (pIfProgress && pIfProgress->pfnProgress)
8056 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
8057
8058 pDisk->cbSize = cbSize;
8059 }
8060
8061 LogFlowFunc(("returns %Rrc\n", rc));
8062 return rc;
8063}
8064
8065VBOXDDU_DECL(int) VDPrepareWithFilters(PVDISK pDisk, PVDINTERFACE pVDIfsOperation)
8066{
8067 int rc = VINF_SUCCESS;
8068 int rc2;
8069 bool fLockRead = false, fLockWrite = false;
8070
8071 LogFlowFunc(("pDisk=%#p pVDIfsOperation=%#p\n", pDisk, pVDIfsOperation));
8072
8073 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
8074
8075 do {
8076 /* Check arguments. */
8077 AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
8078 rc = VERR_INVALID_PARAMETER);
8079 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
8080 ("u32Signature=%08x\n", pDisk->u32Signature));
8081
8082 rc2 = vdThreadStartRead(pDisk);
8083 AssertRC(rc2);
8084 fLockRead = true;
8085
8086 /* Must have at least one image in the chain. */
8087 AssertMsgBreakStmt(pDisk->cImages >= 1, ("cImages=%u\n", pDisk->cImages),
8088 rc = VERR_VD_NOT_OPENED);
8089
8090 unsigned uOpenFlags = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
8091 AssertMsgBreakStmt(!(uOpenFlags & VD_OPEN_FLAGS_READONLY),
8092 ("Last image should be read write"),
8093 rc = VERR_VD_IMAGE_READ_ONLY);
8094
8095 rc2 = vdThreadFinishRead(pDisk);
8096 AssertRC(rc2);
8097 fLockRead = false;
8098
8099 rc2 = vdThreadStartWrite(pDisk);
8100 AssertRC(rc2);
8101 fLockWrite = true;
8102
8103 /*
8104 * Open all images in the chain in read write mode first to avoid running
8105 * into an error in the middle of the process.
8106 */
8107 PVDIMAGE pImage = pDisk->pBase;
8108
8109 while (pImage)
8110 {
8111 uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8112 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
8113 {
8114 /*
8115 * Clear skip consistency checks because the image is made writable now and
8116 * skipping consistency checks is only possible for readonly images.
8117 */
8118 uOpenFlags &= ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS);
8119 rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
8120 if (RT_FAILURE(rc))
8121 break;
8122 }
8123 pImage = pImage->pNext;
8124 }
8125
8126 if (RT_SUCCESS(rc))
8127 {
8128 unsigned cImgCur = 0;
8129 unsigned uPercentStart = 0;
8130 unsigned uPercentSpan = 100 / pDisk->cImages - 1;
8131
8132 /* Allocate tmp buffer. */
8133 void *pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
8134 if (!pvBuf)
8135 {
8136 rc = VERR_NO_MEMORY;
8137 break;
8138 }
8139
8140 pImage = pDisk->pBase;
8141 pDisk->fLocked = true;
8142
8143 while ( pImage
8144 && RT_SUCCESS(rc))
8145 {
8146 /* Get size of image. */
8147 uint64_t cbSize = vdImageGetSize(pImage);
8148 uint64_t cbSizeFile = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
8149 uint64_t cbFileWritten = 0;
8150 uint64_t uOffset = 0;
8151 uint64_t cbRemaining = cbSize;
8152
8153 do
8154 {
8155 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
8156 RTSGSEG SegmentBuf;
8157 RTSGBUF SgBuf;
8158 VDIOCTX IoCtx;
8159
8160 SegmentBuf.pvSeg = pvBuf;
8161 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
8162 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
8163 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
8164 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
8165
8166 rc = pImage->Backend->pfnRead(pImage->pBackendData, uOffset,
8167 cbThisRead, &IoCtx, &cbThisRead);
8168 if (rc != VERR_VD_BLOCK_FREE)
8169 {
8170 if (RT_FAILURE(rc))
8171 break;
8172
8173 /* Apply filter chains. */
8174 rc = vdFilterChainApplyRead(pDisk, uOffset, cbThisRead, &IoCtx);
8175 if (RT_FAILURE(rc))
8176 break;
8177
8178 rc = vdFilterChainApplyWrite(pDisk, uOffset, cbThisRead, &IoCtx);
8179 if (RT_FAILURE(rc))
8180 break;
8181
8182 RTSgBufReset(&SgBuf);
8183 size_t cbThisWrite = 0;
8184 size_t cbPreRead = 0;
8185 size_t cbPostRead = 0;
8186 rc = pImage->Backend->pfnWrite(pImage->pBackendData, uOffset,
8187 cbThisRead, &IoCtx, &cbThisWrite,
8188 &cbPreRead, &cbPostRead, 0);
8189 if (RT_FAILURE(rc))
8190 break;
8191 Assert(cbThisWrite == cbThisRead);
8192 cbFileWritten += cbThisWrite;
8193 }
8194 else
8195 rc = VINF_SUCCESS;
8196
8197 uOffset += cbThisRead;
8198 cbRemaining -= cbThisRead;
8199
8200 if (pIfProgress && pIfProgress->pfnProgress)
8201 {
8202 rc2 = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
8203 uPercentStart + cbFileWritten * uPercentSpan / cbSizeFile);
8204 AssertRC(rc2); /* Cancelling this operation without leaving an inconsistent state is not possible. */
8205 }
8206 } while (uOffset < cbSize);
8207
8208 pImage = pImage->pNext;
8209 cImgCur++;
8210 uPercentStart += uPercentSpan;
8211 }
8212
8213 pDisk->fLocked = false;
8214 if (pvBuf)
8215 RTMemTmpFree(pvBuf);
8216 }
8217
8218 /* Change images except last one back to readonly. */
8219 pImage = pDisk->pBase;
8220 while ( pImage != pDisk->pLast
8221 && pImage)
8222 {
8223 uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8224 uOpenFlags |= VD_OPEN_FLAGS_READONLY;
8225 rc2 = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
8226 if (RT_FAILURE(rc2))
8227 {
8228 if (RT_SUCCESS(rc))
8229 rc = rc2;
8230 break;
8231 }
8232 pImage = pImage->pNext;
8233 }
8234 } while (0);
8235
8236 if (RT_UNLIKELY(fLockWrite))
8237 {
8238 rc2 = vdThreadFinishWrite(pDisk);
8239 AssertRC(rc2);
8240 }
8241 else if (RT_UNLIKELY(fLockRead))
8242 {
8243 rc2 = vdThreadFinishRead(pDisk);
8244 AssertRC(rc2);
8245 }
8246
8247 if ( RT_SUCCESS(rc)
8248 && pIfProgress
8249 && pIfProgress->pfnProgress)
8250 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
8251
8252 LogFlowFunc(("returns %Rrc\n", rc));
8253 return rc;
8254}
8255
8256/**
8257 * Closes the last opened image file in HDD container.
8258 * If previous image file was opened in read-only mode (the normal case) and
8259 * the last opened image is in read-write mode then the previous image will be
8260 * reopened in read/write mode.
8261 *
8262 * @returns VBox status code.
8263 * @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
8264 * @param pDisk Pointer to HDD container.
8265 * @param fDelete If true, delete the image from the host disk.
8266 */
8267VBOXDDU_DECL(int) VDClose(PVDISK pDisk, bool fDelete)
8268{
8269 int rc = VINF_SUCCESS;
8270 int rc2;
8271 bool fLockWrite = false;
8272
8273 LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
8274 do
8275 {
8276 /* sanity check */
8277 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8278 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8279
8280 /* Not worth splitting this up into a read lock phase and write
8281 * lock phase, as closing an image is a relatively fast operation
8282 * dominated by the part which needs the write lock. */
8283 rc2 = vdThreadStartWrite(pDisk);
8284 AssertRC(rc2);
8285 fLockWrite = true;
8286
8287 PVDIMAGE pImage = pDisk->pLast;
8288 if (!pImage)
8289 {
8290 rc = VERR_VD_NOT_OPENED;
8291 break;
8292 }
8293
8294 /* Destroy the current discard state first which might still have pending blocks. */
8295 rc = vdDiscardStateDestroy(pDisk);
8296 if (RT_FAILURE(rc))
8297 break;
8298
8299 unsigned uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8300 /* Remove image from list of opened images. */
8301 vdRemoveImageFromList(pDisk, pImage);
8302 /* Close (and optionally delete) image. */
8303 rc = pImage->Backend->pfnClose(pImage->pBackendData, fDelete);
8304 /* Free remaining resources related to the image. */
8305 RTStrFree(pImage->pszFilename);
8306 RTMemFree(pImage);
8307
8308 pImage = pDisk->pLast;
8309 if (!pImage)
8310 break;
8311
8312 /* If disk was previously in read/write mode, make sure it will stay
8313 * like this (if possible) after closing this image. Set the open flags
8314 * accordingly. */
8315 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
8316 {
8317 uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8318 uOpenFlags &= ~ VD_OPEN_FLAGS_READONLY;
8319 rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
8320 }
8321
8322 /* Cache disk information. */
8323 pDisk->cbSize = vdImageGetSize(pImage);
8324
8325 /* Cache PCHS geometry. */
8326 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
8327 &pDisk->PCHSGeometry);
8328 if (RT_FAILURE(rc2))
8329 {
8330 pDisk->PCHSGeometry.cCylinders = 0;
8331 pDisk->PCHSGeometry.cHeads = 0;
8332 pDisk->PCHSGeometry.cSectors = 0;
8333 }
8334 else
8335 {
8336 /* Make sure the PCHS geometry is properly clipped. */
8337 pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
8338 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
8339 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
8340 }
8341
8342 /* Cache LCHS geometry. */
8343 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
8344 &pDisk->LCHSGeometry);
8345 if (RT_FAILURE(rc2))
8346 {
8347 pDisk->LCHSGeometry.cCylinders = 0;
8348 pDisk->LCHSGeometry.cHeads = 0;
8349 pDisk->LCHSGeometry.cSectors = 0;
8350 }
8351 else
8352 {
8353 /* Make sure the LCHS geometry is properly clipped. */
8354 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
8355 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
8356 }
8357 } while (0);
8358
8359 if (RT_UNLIKELY(fLockWrite))
8360 {
8361 rc2 = vdThreadFinishWrite(pDisk);
8362 AssertRC(rc2);
8363 }
8364
8365 LogFlowFunc(("returns %Rrc\n", rc));
8366 return rc;
8367}
8368
8369/**
8370 * Closes the currently opened cache image file in HDD container.
8371 *
8372 * @return VBox status code.
8373 * @return VERR_VD_NOT_OPENED if no cache is opened in HDD container.
8374 * @param pDisk Pointer to HDD container.
8375 * @param fDelete If true, delete the image from the host disk.
8376 */
8377VBOXDDU_DECL(int) VDCacheClose(PVDISK pDisk, bool fDelete)
8378{
8379 int rc = VINF_SUCCESS;
8380 int rc2;
8381 bool fLockWrite = false;
8382 PVDCACHE pCache = NULL;
8383
8384 LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
8385
8386 do
8387 {
8388 /* sanity check */
8389 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8390 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8391
8392 rc2 = vdThreadStartWrite(pDisk);
8393 AssertRC(rc2);
8394 fLockWrite = true;
8395
8396 AssertPtrBreakStmt(pDisk->pCache, rc = VERR_VD_CACHE_NOT_FOUND);
8397
8398 pCache = pDisk->pCache;
8399 pDisk->pCache = NULL;
8400
8401 pCache->Backend->pfnClose(pCache->pBackendData, fDelete);
8402 if (pCache->pszFilename)
8403 RTStrFree(pCache->pszFilename);
8404 RTMemFree(pCache);
8405 } while (0);
8406
8407 if (RT_LIKELY(fLockWrite))
8408 {
8409 rc2 = vdThreadFinishWrite(pDisk);
8410 AssertRC(rc2);
8411 }
8412
8413 LogFlowFunc(("returns %Rrc\n", rc));
8414 return rc;
8415}
8416
8417VBOXDDU_DECL(int) VDFilterRemove(PVDISK pDisk, uint32_t fFlags)
8418{
8419 int rc = VINF_SUCCESS;
8420 int rc2;
8421 bool fLockWrite = false;
8422 PVDFILTER pFilter = NULL;
8423
8424 LogFlowFunc(("pDisk=%#p\n", pDisk));
8425
8426 do
8427 {
8428 /* sanity check */
8429 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8430 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8431
8432 AssertMsgBreakStmt(!(fFlags & ~VD_FILTER_FLAGS_MASK),
8433 ("Invalid flags set (fFlags=%#x)\n", fFlags),
8434 rc = VERR_INVALID_PARAMETER);
8435
8436 rc2 = vdThreadStartWrite(pDisk);
8437 AssertRC(rc2);
8438 fLockWrite = true;
8439
8440 if (fFlags & VD_FILTER_FLAGS_WRITE)
8441 {
8442 AssertBreakStmt(!RTListIsEmpty(&pDisk->ListFilterChainWrite), rc = VERR_VD_NOT_OPENED);
8443 pFilter = RTListGetLast(&pDisk->ListFilterChainWrite, VDFILTER, ListNodeChainWrite);
8444 AssertPtr(pFilter);
8445 RTListNodeRemove(&pFilter->ListNodeChainWrite);
8446 vdFilterRelease(pFilter);
8447 }
8448
8449 if (fFlags & VD_FILTER_FLAGS_READ)
8450 {
8451 AssertBreakStmt(!RTListIsEmpty(&pDisk->ListFilterChainRead), rc = VERR_VD_NOT_OPENED);
8452 pFilter = RTListGetLast(&pDisk->ListFilterChainRead, VDFILTER, ListNodeChainRead);
8453 AssertPtr(pFilter);
8454 RTListNodeRemove(&pFilter->ListNodeChainRead);
8455 vdFilterRelease(pFilter);
8456 }
8457 } while (0);
8458
8459 if (RT_LIKELY(fLockWrite))
8460 {
8461 rc2 = vdThreadFinishWrite(pDisk);
8462 AssertRC(rc2);
8463 }
8464
8465 LogFlowFunc(("returns %Rrc\n", rc));
8466 return rc;
8467}
8468
8469/**
8470 * Closes all opened image files in HDD container.
8471 *
8472 * @returns VBox status code.
8473 * @param pDisk Pointer to HDD container.
8474 */
8475VBOXDDU_DECL(int) VDCloseAll(PVDISK pDisk)
8476{
8477 int rc = VINF_SUCCESS;
8478 int rc2;
8479 bool fLockWrite = false;
8480
8481 LogFlowFunc(("pDisk=%#p\n", pDisk));
8482 do
8483 {
8484 /* sanity check */
8485 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8486 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8487
8488 /* Lock the entire operation. */
8489 rc2 = vdThreadStartWrite(pDisk);
8490 AssertRC(rc2);
8491 fLockWrite = true;
8492
8493 PVDCACHE pCache = pDisk->pCache;
8494 if (pCache)
8495 {
8496 rc2 = pCache->Backend->pfnClose(pCache->pBackendData, false);
8497 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
8498 rc = rc2;
8499
8500 if (pCache->pszFilename)
8501 RTStrFree(pCache->pszFilename);
8502 RTMemFree(pCache);
8503 }
8504
8505 PVDIMAGE pImage = pDisk->pLast;
8506 while (VALID_PTR(pImage))
8507 {
8508 PVDIMAGE pPrev = pImage->pPrev;
8509 /* Remove image from list of opened images. */
8510 vdRemoveImageFromList(pDisk, pImage);
8511 /* Close image. */
8512 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, false);
8513 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
8514 rc = rc2;
8515 /* Free remaining resources related to the image. */
8516 RTStrFree(pImage->pszFilename);
8517 RTMemFree(pImage);
8518 pImage = pPrev;
8519 }
8520 Assert(!VALID_PTR(pDisk->pLast));
8521 } while (0);
8522
8523 if (RT_UNLIKELY(fLockWrite))
8524 {
8525 rc2 = vdThreadFinishWrite(pDisk);
8526 AssertRC(rc2);
8527 }
8528
8529 LogFlowFunc(("returns %Rrc\n", rc));
8530 return rc;
8531}
8532
8533/**
8534 * Removes all filters of the given HDD container.
8535 *
8536 * @return VBox status code.
8537 * @param pDisk Pointer to HDD container.
8538 */
8539VBOXDDU_DECL(int) VDFilterRemoveAll(PVDISK pDisk)
8540{
8541 int rc = VINF_SUCCESS;
8542 int rc2;
8543 bool fLockWrite = false;
8544
8545 LogFlowFunc(("pDisk=%#p\n", pDisk));
8546 do
8547 {
8548 /* sanity check */
8549 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8550 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8551
8552 /* Lock the entire operation. */
8553 rc2 = vdThreadStartWrite(pDisk);
8554 AssertRC(rc2);
8555 fLockWrite = true;
8556
8557 PVDFILTER pFilter, pFilterNext;
8558 RTListForEachSafe(&pDisk->ListFilterChainWrite, pFilter, pFilterNext, VDFILTER, ListNodeChainWrite)
8559 {
8560 RTListNodeRemove(&pFilter->ListNodeChainWrite);
8561 vdFilterRelease(pFilter);
8562 }
8563
8564 RTListForEachSafe(&pDisk->ListFilterChainRead, pFilter, pFilterNext, VDFILTER, ListNodeChainRead)
8565 {
8566 RTListNodeRemove(&pFilter->ListNodeChainRead);
8567 vdFilterRelease(pFilter);
8568 }
8569 Assert(RTListIsEmpty(&pDisk->ListFilterChainRead));
8570 Assert(RTListIsEmpty(&pDisk->ListFilterChainWrite));
8571 } while (0);
8572
8573 if (RT_UNLIKELY(fLockWrite))
8574 {
8575 rc2 = vdThreadFinishWrite(pDisk);
8576 AssertRC(rc2);
8577 }
8578
8579 LogFlowFunc(("returns %Rrc\n", rc));
8580 return rc;
8581}
8582
8583/**
8584 * Read data from virtual HDD.
8585 *
8586 * @returns VBox status code.
8587 * @retval VERR_VD_NOT_OPENED if no image is opened in HDD container.
8588 * @param pDisk Pointer to HDD container.
8589 * @param uOffset Offset of first reading byte from start of disk.
8590 * @param pvBuf Pointer to buffer for reading data.
8591 * @param cbRead Number of bytes to read.
8592 */
8593VBOXDDU_DECL(int) VDRead(PVDISK pDisk, uint64_t uOffset, void *pvBuf,
8594 size_t cbRead)
8595{
8596 int rc = VINF_SUCCESS;
8597 int rc2;
8598 bool fLockRead = false;
8599
8600 LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbRead=%zu\n",
8601 pDisk, uOffset, pvBuf, cbRead));
8602 do
8603 {
8604 /* sanity check */
8605 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8606 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8607
8608 /* Check arguments. */
8609 AssertMsgBreakStmt(VALID_PTR(pvBuf),
8610 ("pvBuf=%#p\n", pvBuf),
8611 rc = VERR_INVALID_PARAMETER);
8612 AssertMsgBreakStmt(cbRead,
8613 ("cbRead=%zu\n", cbRead),
8614 rc = VERR_INVALID_PARAMETER);
8615
8616 rc2 = vdThreadStartRead(pDisk);
8617 AssertRC(rc2);
8618 fLockRead = true;
8619
8620 PVDIMAGE pImage = pDisk->pLast;
8621 AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
8622
8623 if (uOffset + cbRead > pDisk->cbSize)
8624 {
8625 /* Floppy images might be smaller than the standard expected by
8626 the floppy controller code. So, we won't fail here. */
8627 AssertMsgBreakStmt(pDisk->enmType == VDTYPE_FLOPPY,
8628 ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
8629 uOffset, cbRead, pDisk->cbSize),
8630 rc = VERR_EOF);
8631 memset(pvBuf, 0xf6, cbRead); /* f6h = format.com filler byte */
8632 if (uOffset >= pDisk->cbSize)
8633 break;
8634 cbRead = pDisk->cbSize - uOffset;
8635 }
8636
8637 rc = vdReadHelper(pDisk, pImage, uOffset, pvBuf, cbRead,
8638 true /* fUpdateCache */);
8639 } while (0);
8640
8641 if (RT_UNLIKELY(fLockRead))
8642 {
8643 rc2 = vdThreadFinishRead(pDisk);
8644 AssertRC(rc2);
8645 }
8646
8647 LogFlowFunc(("returns %Rrc\n", rc));
8648 return rc;
8649}
8650
8651/**
8652 * Write data to virtual HDD.
8653 *
8654 * @returns VBox status code.
8655 * @retval VERR_VD_NOT_OPENED if no image is opened in HDD container.
8656 * @param pDisk Pointer to HDD container.
8657 * @param uOffset Offset of the first byte being
8658 * written from start of disk.
8659 * @param pvBuf Pointer to buffer for writing data.
8660 * @param cbWrite Number of bytes to write.
8661 */
8662VBOXDDU_DECL(int) VDWrite(PVDISK pDisk, uint64_t uOffset, const void *pvBuf,
8663 size_t cbWrite)
8664{
8665 int rc = VINF_SUCCESS;
8666 int rc2;
8667 bool fLockWrite = false;
8668
8669 LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbWrite=%zu\n",
8670 pDisk, uOffset, pvBuf, cbWrite));
8671 do
8672 {
8673 /* sanity check */
8674 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8675 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8676
8677 /* Check arguments. */
8678 AssertMsgBreakStmt(VALID_PTR(pvBuf),
8679 ("pvBuf=%#p\n", pvBuf),
8680 rc = VERR_INVALID_PARAMETER);
8681 AssertMsgBreakStmt(cbWrite,
8682 ("cbWrite=%zu\n", cbWrite),
8683 rc = VERR_INVALID_PARAMETER);
8684
8685 rc2 = vdThreadStartWrite(pDisk);
8686 AssertRC(rc2);
8687 fLockWrite = true;
8688
8689 AssertMsgBreakStmt(uOffset + cbWrite <= pDisk->cbSize,
8690 ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
8691 uOffset, cbWrite, pDisk->cbSize),
8692 rc = VERR_INVALID_PARAMETER);
8693
8694 PVDIMAGE pImage = pDisk->pLast;
8695 AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
8696
8697 vdSetModifiedFlag(pDisk);
8698 rc = vdWriteHelper(pDisk, pImage, uOffset, pvBuf, cbWrite,
8699 VDIOCTX_FLAGS_READ_UPDATE_CACHE);
8700 if (RT_FAILURE(rc))
8701 break;
8702
8703 /* If there is a merge (in the direction towards a parent) running
8704 * concurrently then we have to also "relay" the write to this parent,
8705 * as the merge position might be already past the position where
8706 * this write is going. The "context" of the write can come from the
8707 * natural chain, since merging either already did or will take care
8708 * of the "other" content which is might be needed to fill the block
8709 * to a full allocation size. The cache doesn't need to be touched
8710 * as this write is covered by the previous one. */
8711 if (RT_UNLIKELY(pDisk->pImageRelay))
8712 rc = vdWriteHelper(pDisk, pDisk->pImageRelay, uOffset,
8713 pvBuf, cbWrite, VDIOCTX_FLAGS_DEFAULT);
8714 } while (0);
8715
8716 if (RT_UNLIKELY(fLockWrite))
8717 {
8718 rc2 = vdThreadFinishWrite(pDisk);
8719 AssertRC(rc2);
8720 }
8721
8722 LogFlowFunc(("returns %Rrc\n", rc));
8723 return rc;
8724}
8725
8726/**
8727 * Make sure the on disk representation of a virtual HDD is up to date.
8728 *
8729 * @returns VBox status code.
8730 * @retval VERR_VD_NOT_OPENED if no image is opened in HDD container.
8731 * @param pDisk Pointer to HDD container.
8732 */
8733VBOXDDU_DECL(int) VDFlush(PVDISK pDisk)
8734{
8735 int rc = VINF_SUCCESS;
8736 int rc2;
8737 bool fLockWrite = false;
8738
8739 LogFlowFunc(("pDisk=%#p\n", pDisk));
8740 do
8741 {
8742 /* sanity check */
8743 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8744 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8745
8746 rc2 = vdThreadStartWrite(pDisk);
8747 AssertRC(rc2);
8748 fLockWrite = true;
8749
8750 PVDIMAGE pImage = pDisk->pLast;
8751 AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
8752
8753 VDIOCTX IoCtx;
8754 RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
8755
8756 rc = RTSemEventCreate(&hEventComplete);
8757 if (RT_FAILURE(rc))
8758 break;
8759
8760 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, pImage, NULL,
8761 NULL, vdFlushHelperAsync, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE);
8762
8763 IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
8764 IoCtx.Type.Root.pvUser1 = pDisk;
8765 IoCtx.Type.Root.pvUser2 = hEventComplete;
8766 rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
8767
8768 RTSemEventDestroy(hEventComplete);
8769 } while (0);
8770
8771 if (RT_UNLIKELY(fLockWrite))
8772 {
8773 rc2 = vdThreadFinishWrite(pDisk);
8774 AssertRC(rc2);
8775 }
8776
8777 LogFlowFunc(("returns %Rrc\n", rc));
8778 return rc;
8779}
8780
8781/**
8782 * Get number of opened images in HDD container.
8783 *
8784 * @returns Number of opened images for HDD container. 0 if no images have been opened.
8785 * @param pDisk Pointer to HDD container.
8786 */
8787VBOXDDU_DECL(unsigned) VDGetCount(PVDISK pDisk)
8788{
8789 unsigned cImages;
8790 int rc2;
8791 bool fLockRead = false;
8792
8793 LogFlowFunc(("pDisk=%#p\n", pDisk));
8794 do
8795 {
8796 /* sanity check */
8797 AssertPtrBreakStmt(pDisk, cImages = 0);
8798 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8799
8800 rc2 = vdThreadStartRead(pDisk);
8801 AssertRC(rc2);
8802 fLockRead = true;
8803
8804 cImages = pDisk->cImages;
8805 } while (0);
8806
8807 if (RT_UNLIKELY(fLockRead))
8808 {
8809 rc2 = vdThreadFinishRead(pDisk);
8810 AssertRC(rc2);
8811 }
8812
8813 LogFlowFunc(("returns %u\n", cImages));
8814 return cImages;
8815}
8816
8817/**
8818 * Get read/write mode of HDD container.
8819 *
8820 * @returns Virtual disk ReadOnly status.
8821 * @returns true if no image is opened in HDD container.
8822 * @param pDisk Pointer to HDD container.
8823 */
8824VBOXDDU_DECL(bool) VDIsReadOnly(PVDISK pDisk)
8825{
8826 bool fReadOnly;
8827 int rc2;
8828 bool fLockRead = false;
8829
8830 LogFlowFunc(("pDisk=%#p\n", pDisk));
8831 do
8832 {
8833 /* sanity check */
8834 AssertPtrBreakStmt(pDisk, fReadOnly = false);
8835 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8836
8837 rc2 = vdThreadStartRead(pDisk);
8838 AssertRC(rc2);
8839 fLockRead = true;
8840
8841 PVDIMAGE pImage = pDisk->pLast;
8842 AssertPtrBreakStmt(pImage, fReadOnly = true);
8843
8844 unsigned uOpenFlags;
8845 uOpenFlags = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
8846 fReadOnly = !!(uOpenFlags & VD_OPEN_FLAGS_READONLY);
8847 } while (0);
8848
8849 if (RT_UNLIKELY(fLockRead))
8850 {
8851 rc2 = vdThreadFinishRead(pDisk);
8852 AssertRC(rc2);
8853 }
8854
8855 LogFlowFunc(("returns %d\n", fReadOnly));
8856 return fReadOnly;
8857}
8858
8859/**
8860 * Get sector size of an image in HDD container.
8861 *
8862 * @return Virtual disk sector size in bytes.
8863 * @return 0 if image with specified number was not opened.
8864 * @param pDisk Pointer to HDD container.
8865 * @param nImage Image number, counts from 0. 0 is always base image of container.
8866 */
8867VBOXDDU_DECL(uint32_t) VDGetSectorSize(PVDISK pDisk, unsigned nImage)
8868{
8869 uint64_t cbSector;
8870 int rc2;
8871 bool fLockRead = false;
8872
8873 LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
8874 do
8875 {
8876 /* sanity check */
8877 AssertPtrBreakStmt(pDisk, cbSector = 0);
8878 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8879
8880 rc2 = vdThreadStartRead(pDisk);
8881 AssertRC(rc2);
8882 fLockRead = true;
8883
8884 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
8885 AssertPtrBreakStmt(pImage, cbSector = 0);
8886
8887 PCVDREGIONLIST pRegionList = NULL;
8888 int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
8889 if (RT_SUCCESS(rc))
8890 {
8891 AssertBreakStmt(pRegionList->cRegions == 1, cbSector = 0);
8892 cbSector = pRegionList->aRegions[0].cbBlock;
8893
8894 AssertPtr(pImage->Backend->pfnRegionListRelease);
8895 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
8896 }
8897 else
8898 cbSector = 0;
8899 } while (0);
8900
8901 if (RT_UNLIKELY(fLockRead))
8902 {
8903 rc2 = vdThreadFinishRead(pDisk);
8904 AssertRC(rc2);
8905 }
8906
8907 LogFlowFunc(("returns %u\n", cbSector));
8908 return cbSector;
8909}
8910
8911/**
8912 * Get total capacity of an image in HDD container.
8913 *
8914 * @returns Virtual disk size in bytes.
8915 * @returns 0 if no image with specified number was not opened.
8916 * @param pDisk Pointer to HDD container.
8917 * @param nImage Image number, counts from 0. 0 is always base image of container.
8918 */
8919VBOXDDU_DECL(uint64_t) VDGetSize(PVDISK pDisk, unsigned nImage)
8920{
8921 uint64_t cbSize;
8922 int rc2;
8923 bool fLockRead = false;
8924
8925 LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
8926 do
8927 {
8928 /* sanity check */
8929 AssertPtrBreakStmt(pDisk, cbSize = 0);
8930 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8931
8932 rc2 = vdThreadStartRead(pDisk);
8933 AssertRC(rc2);
8934 fLockRead = true;
8935
8936 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
8937 AssertPtrBreakStmt(pImage, cbSize = 0);
8938
8939 cbSize = vdImageGetSize(pImage);
8940 } while (0);
8941
8942 if (RT_UNLIKELY(fLockRead))
8943 {
8944 rc2 = vdThreadFinishRead(pDisk);
8945 AssertRC(rc2);
8946 }
8947
8948 LogFlowFunc(("returns %llu\n", cbSize));
8949 return cbSize;
8950}
8951
8952/**
8953 * Get total file size of an image in HDD container.
8954 *
8955 * @returns Virtual disk size in bytes.
8956 * @returns 0 if no image is opened in HDD container.
8957 * @param pDisk Pointer to HDD container.
8958 * @param nImage Image number, counts from 0. 0 is always base image of container.
8959 */
8960VBOXDDU_DECL(uint64_t) VDGetFileSize(PVDISK pDisk, unsigned nImage)
8961{
8962 uint64_t cbSize;
8963 int rc2;
8964 bool fLockRead = false;
8965
8966 LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
8967 do
8968 {
8969 /* sanity check */
8970 AssertPtrBreakStmt(pDisk, cbSize = 0);
8971 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8972
8973 rc2 = vdThreadStartRead(pDisk);
8974 AssertRC(rc2);
8975 fLockRead = true;
8976
8977 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
8978 AssertPtrBreakStmt(pImage, cbSize = 0);
8979 cbSize = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
8980 } while (0);
8981
8982 if (RT_UNLIKELY(fLockRead))
8983 {
8984 rc2 = vdThreadFinishRead(pDisk);
8985 AssertRC(rc2);
8986 }
8987
8988 LogFlowFunc(("returns %llu\n", cbSize));
8989 return cbSize;
8990}
8991
8992/**
8993 * Get virtual disk PCHS geometry stored in HDD container.
8994 *
8995 * @returns VBox status code.
8996 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
8997 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
8998 * @param pDisk Pointer to HDD container.
8999 * @param nImage Image number, counts from 0. 0 is always base image of container.
9000 * @param pPCHSGeometry Where to store PCHS geometry. Not NULL.
9001 */
9002VBOXDDU_DECL(int) VDGetPCHSGeometry(PVDISK pDisk, unsigned nImage,
9003 PVDGEOMETRY pPCHSGeometry)
9004{
9005 int rc = VINF_SUCCESS;
9006 int rc2;
9007 bool fLockRead = false;
9008
9009 LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p\n",
9010 pDisk, nImage, pPCHSGeometry));
9011 do
9012 {
9013 /* sanity check */
9014 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9015 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9016
9017 /* Check arguments. */
9018 AssertMsgBreakStmt(VALID_PTR(pPCHSGeometry),
9019 ("pPCHSGeometry=%#p\n", pPCHSGeometry),
9020 rc = VERR_INVALID_PARAMETER);
9021
9022 rc2 = vdThreadStartRead(pDisk);
9023 AssertRC(rc2);
9024 fLockRead = true;
9025
9026 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9027 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9028
9029 if (pImage == pDisk->pLast)
9030 {
9031 /* Use cached information if possible. */
9032 if (pDisk->PCHSGeometry.cCylinders != 0)
9033 *pPCHSGeometry = pDisk->PCHSGeometry;
9034 else
9035 rc = VERR_VD_GEOMETRY_NOT_SET;
9036 }
9037 else
9038 rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
9039 pPCHSGeometry);
9040 } while (0);
9041
9042 if (RT_UNLIKELY(fLockRead))
9043 {
9044 rc2 = vdThreadFinishRead(pDisk);
9045 AssertRC(rc2);
9046 }
9047
9048 LogFlowFunc(("%Rrc (PCHS=%u/%u/%u)\n", rc,
9049 pDisk->PCHSGeometry.cCylinders, pDisk->PCHSGeometry.cHeads,
9050 pDisk->PCHSGeometry.cSectors));
9051 return rc;
9052}
9053
9054/**
9055 * Store virtual disk PCHS geometry in HDD container.
9056 *
9057 * Note that in case of unrecoverable error all images in HDD container will be closed.
9058 *
9059 * @returns VBox status code.
9060 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9061 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9062 * @param pDisk Pointer to HDD container.
9063 * @param nImage Image number, counts from 0. 0 is always base image of container.
9064 * @param pPCHSGeometry Where to load PCHS geometry from. Not NULL.
9065 */
9066VBOXDDU_DECL(int) VDSetPCHSGeometry(PVDISK pDisk, unsigned nImage,
9067 PCVDGEOMETRY pPCHSGeometry)
9068{
9069 int rc = VINF_SUCCESS;
9070 int rc2;
9071 bool fLockWrite = false;
9072
9073 LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
9074 pDisk, nImage, pPCHSGeometry, pPCHSGeometry->cCylinders,
9075 pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
9076 do
9077 {
9078 /* sanity check */
9079 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9080 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9081
9082 /* Check arguments. */
9083 AssertMsgBreakStmt( VALID_PTR(pPCHSGeometry)
9084 && pPCHSGeometry->cHeads <= 16
9085 && pPCHSGeometry->cSectors <= 63,
9086 ("pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pPCHSGeometry,
9087 pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads,
9088 pPCHSGeometry->cSectors),
9089 rc = VERR_INVALID_PARAMETER);
9090
9091 rc2 = vdThreadStartWrite(pDisk);
9092 AssertRC(rc2);
9093 fLockWrite = true;
9094
9095 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9096 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9097
9098 if (pImage == pDisk->pLast)
9099 {
9100 if ( pPCHSGeometry->cCylinders != pDisk->PCHSGeometry.cCylinders
9101 || pPCHSGeometry->cHeads != pDisk->PCHSGeometry.cHeads
9102 || pPCHSGeometry->cSectors != pDisk->PCHSGeometry.cSectors)
9103 {
9104 /* Only update geometry if it is changed. Avoids similar checks
9105 * in every backend. Most of the time the new geometry is set
9106 * to the previous values, so no need to go through the hassle
9107 * of updating an image which could be opened in read-only mode
9108 * right now. */
9109 rc = pImage->Backend->pfnSetPCHSGeometry(pImage->pBackendData,
9110 pPCHSGeometry);
9111
9112 /* Cache new geometry values in any case. */
9113 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
9114 &pDisk->PCHSGeometry);
9115 if (RT_FAILURE(rc2))
9116 {
9117 pDisk->PCHSGeometry.cCylinders = 0;
9118 pDisk->PCHSGeometry.cHeads = 0;
9119 pDisk->PCHSGeometry.cSectors = 0;
9120 }
9121 else
9122 {
9123 /* Make sure the CHS geometry is properly clipped. */
9124 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 255);
9125 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
9126 }
9127 }
9128 }
9129 else
9130 {
9131 VDGEOMETRY PCHS;
9132 rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
9133 &PCHS);
9134 if ( RT_FAILURE(rc)
9135 || pPCHSGeometry->cCylinders != PCHS.cCylinders
9136 || pPCHSGeometry->cHeads != PCHS.cHeads
9137 || pPCHSGeometry->cSectors != PCHS.cSectors)
9138 {
9139 /* Only update geometry if it is changed. Avoids similar checks
9140 * in every backend. Most of the time the new geometry is set
9141 * to the previous values, so no need to go through the hassle
9142 * of updating an image which could be opened in read-only mode
9143 * right now. */
9144 rc = pImage->Backend->pfnSetPCHSGeometry(pImage->pBackendData,
9145 pPCHSGeometry);
9146 }
9147 }
9148 } while (0);
9149
9150 if (RT_UNLIKELY(fLockWrite))
9151 {
9152 rc2 = vdThreadFinishWrite(pDisk);
9153 AssertRC(rc2);
9154 }
9155
9156 LogFlowFunc(("returns %Rrc\n", rc));
9157 return rc;
9158}
9159
9160/**
9161 * Get virtual disk LCHS geometry stored in HDD container.
9162 *
9163 * @returns VBox status code.
9164 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9165 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9166 * @param pDisk Pointer to HDD container.
9167 * @param nImage Image number, counts from 0. 0 is always base image of container.
9168 * @param pLCHSGeometry Where to store LCHS geometry. Not NULL.
9169 */
9170VBOXDDU_DECL(int) VDGetLCHSGeometry(PVDISK pDisk, unsigned nImage,
9171 PVDGEOMETRY pLCHSGeometry)
9172{
9173 int rc = VINF_SUCCESS;
9174 int rc2;
9175 bool fLockRead = false;
9176
9177 LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p\n",
9178 pDisk, nImage, pLCHSGeometry));
9179 do
9180 {
9181 /* sanity check */
9182 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9183 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9184
9185 /* Check arguments. */
9186 AssertMsgBreakStmt(VALID_PTR(pLCHSGeometry),
9187 ("pLCHSGeometry=%#p\n", pLCHSGeometry),
9188 rc = VERR_INVALID_PARAMETER);
9189
9190 rc2 = vdThreadStartRead(pDisk);
9191 AssertRC(rc2);
9192 fLockRead = true;
9193
9194 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9195 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9196
9197 if (pImage == pDisk->pLast)
9198 {
9199 /* Use cached information if possible. */
9200 if (pDisk->LCHSGeometry.cCylinders != 0)
9201 *pLCHSGeometry = pDisk->LCHSGeometry;
9202 else
9203 rc = VERR_VD_GEOMETRY_NOT_SET;
9204 }
9205 else
9206 rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
9207 pLCHSGeometry);
9208 } while (0);
9209
9210 if (RT_UNLIKELY(fLockRead))
9211 {
9212 rc2 = vdThreadFinishRead(pDisk);
9213 AssertRC(rc2);
9214 }
9215
9216 LogFlowFunc((": %Rrc (LCHS=%u/%u/%u)\n", rc,
9217 pDisk->LCHSGeometry.cCylinders, pDisk->LCHSGeometry.cHeads,
9218 pDisk->LCHSGeometry.cSectors));
9219 return rc;
9220}
9221
9222/**
9223 * Store virtual disk LCHS geometry in HDD container.
9224 *
9225 * Note that in case of unrecoverable error all images in HDD container will be closed.
9226 *
9227 * @returns VBox status code.
9228 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9229 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9230 * @param pDisk Pointer to HDD container.
9231 * @param nImage Image number, counts from 0. 0 is always base image of container.
9232 * @param pLCHSGeometry Where to load LCHS geometry from. Not NULL.
9233 */
9234VBOXDDU_DECL(int) VDSetLCHSGeometry(PVDISK pDisk, unsigned nImage,
9235 PCVDGEOMETRY pLCHSGeometry)
9236{
9237 int rc = VINF_SUCCESS;
9238 int rc2;
9239 bool fLockWrite = false;
9240
9241 LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
9242 pDisk, nImage, pLCHSGeometry, pLCHSGeometry->cCylinders,
9243 pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
9244 do
9245 {
9246 /* sanity check */
9247 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9248 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9249
9250 /* Check arguments. */
9251 AssertMsgBreakStmt( VALID_PTR(pLCHSGeometry)
9252 && pLCHSGeometry->cHeads <= 255
9253 && pLCHSGeometry->cSectors <= 63,
9254 ("pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pLCHSGeometry,
9255 pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads,
9256 pLCHSGeometry->cSectors),
9257 rc = VERR_INVALID_PARAMETER);
9258
9259 rc2 = vdThreadStartWrite(pDisk);
9260 AssertRC(rc2);
9261 fLockWrite = true;
9262
9263 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9264 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9265
9266 if (pImage == pDisk->pLast)
9267 {
9268 if ( pLCHSGeometry->cCylinders != pDisk->LCHSGeometry.cCylinders
9269 || pLCHSGeometry->cHeads != pDisk->LCHSGeometry.cHeads
9270 || pLCHSGeometry->cSectors != pDisk->LCHSGeometry.cSectors)
9271 {
9272 /* Only update geometry if it is changed. Avoids similar checks
9273 * in every backend. Most of the time the new geometry is set
9274 * to the previous values, so no need to go through the hassle
9275 * of updating an image which could be opened in read-only mode
9276 * right now. */
9277 rc = pImage->Backend->pfnSetLCHSGeometry(pImage->pBackendData,
9278 pLCHSGeometry);
9279
9280 /* Cache new geometry values in any case. */
9281 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
9282 &pDisk->LCHSGeometry);
9283 if (RT_FAILURE(rc2))
9284 {
9285 pDisk->LCHSGeometry.cCylinders = 0;
9286 pDisk->LCHSGeometry.cHeads = 0;
9287 pDisk->LCHSGeometry.cSectors = 0;
9288 }
9289 else
9290 {
9291 /* Make sure the CHS geometry is properly clipped. */
9292 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
9293 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
9294 }
9295 }
9296 }
9297 else
9298 {
9299 VDGEOMETRY LCHS;
9300 rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
9301 &LCHS);
9302 if ( RT_FAILURE(rc)
9303 || pLCHSGeometry->cCylinders != LCHS.cCylinders
9304 || pLCHSGeometry->cHeads != LCHS.cHeads
9305 || pLCHSGeometry->cSectors != LCHS.cSectors)
9306 {
9307 /* Only update geometry if it is changed. Avoids similar checks
9308 * in every backend. Most of the time the new geometry is set
9309 * to the previous values, so no need to go through the hassle
9310 * of updating an image which could be opened in read-only mode
9311 * right now. */
9312 rc = pImage->Backend->pfnSetLCHSGeometry(pImage->pBackendData,
9313 pLCHSGeometry);
9314 }
9315 }
9316 } while (0);
9317
9318 if (RT_UNLIKELY(fLockWrite))
9319 {
9320 rc2 = vdThreadFinishWrite(pDisk);
9321 AssertRC(rc2);
9322 }
9323
9324 LogFlowFunc(("returns %Rrc\n", rc));
9325 return rc;
9326}
9327
9328/**
9329 * Queries the available regions of an image in the given VD container.
9330 *
9331 * @return VBox status code.
9332 * @retval VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9333 * @retval VERR_NOT_SUPPORTED if the image backend doesn't support region lists.
9334 * @param pDisk Pointer to HDD container.
9335 * @param nImage Image number, counts from 0. 0 is always base image of container.
9336 * @param fFlags Combination of VD_REGION_LIST_F_* flags.
9337 * @param ppRegionList Where to store the pointer to the region list on success, must be freed
9338 * with VDRegionListFree().
9339 */
9340VBOXDDU_DECL(int) VDQueryRegions(PVDISK pDisk, unsigned nImage, uint32_t fFlags,
9341 PPVDREGIONLIST ppRegionList)
9342{
9343 int rc = VINF_SUCCESS;
9344 int rc2;
9345 bool fLockRead = false;
9346
9347 LogFlowFunc(("pDisk=%#p nImage=%u fFlags=%#x ppRegionList=%#p\n",
9348 pDisk, nImage, fFlags, ppRegionList));
9349 do
9350 {
9351 /* sanity check */
9352 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9353 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9354
9355 /* Check arguments. */
9356 AssertMsgBreakStmt(VALID_PTR(ppRegionList),
9357 ("ppRegionList=%#p\n", ppRegionList),
9358 rc = VERR_INVALID_PARAMETER);
9359
9360 rc2 = vdThreadStartRead(pDisk);
9361 AssertRC(rc2);
9362 fLockRead = true;
9363
9364 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9365 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9366
9367 PCVDREGIONLIST pRegionList = NULL;
9368 rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
9369 if (RT_SUCCESS(rc))
9370 {
9371 rc = vdRegionListConv(pRegionList, fFlags, ppRegionList);
9372
9373 AssertPtr(pImage->Backend->pfnRegionListRelease);
9374 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
9375 }
9376 } while (0);
9377
9378 if (RT_UNLIKELY(fLockRead))
9379 {
9380 rc2 = vdThreadFinishRead(pDisk);
9381 AssertRC(rc2);
9382 }
9383
9384 LogFlowFunc((": %Rrc\n", rc));
9385 return rc;
9386}
9387
9388/**
9389 * Frees a region list previously queried with VDQueryRegions().
9390 *
9391 * @return nothing.
9392 * @param pRegionList The region list to free.
9393 */
9394VBOXDDU_DECL(void) VDRegionListFree(PVDREGIONLIST pRegionList)
9395{
9396 RTMemFree(pRegionList);
9397}
9398
9399/**
9400 * Get version of image in HDD container.
9401 *
9402 * @returns VBox status code.
9403 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9404 * @param pDisk Pointer to HDD container.
9405 * @param nImage Image number, counts from 0. 0 is always base image of container.
9406 * @param puVersion Where to store the image version.
9407 */
9408VBOXDDU_DECL(int) VDGetVersion(PVDISK pDisk, unsigned nImage,
9409 unsigned *puVersion)
9410{
9411 int rc = VINF_SUCCESS;
9412 int rc2;
9413 bool fLockRead = false;
9414
9415 LogFlowFunc(("pDisk=%#p nImage=%u puVersion=%#p\n",
9416 pDisk, nImage, puVersion));
9417 do
9418 {
9419 /* sanity check */
9420 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9421 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9422
9423 /* Check arguments. */
9424 AssertMsgBreakStmt(VALID_PTR(puVersion),
9425 ("puVersion=%#p\n", puVersion),
9426 rc = VERR_INVALID_PARAMETER);
9427
9428 rc2 = vdThreadStartRead(pDisk);
9429 AssertRC(rc2);
9430 fLockRead = true;
9431
9432 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9433 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9434
9435 *puVersion = pImage->Backend->pfnGetVersion(pImage->pBackendData);
9436 } while (0);
9437
9438 if (RT_UNLIKELY(fLockRead))
9439 {
9440 rc2 = vdThreadFinishRead(pDisk);
9441 AssertRC(rc2);
9442 }
9443
9444 LogFlowFunc(("returns %Rrc uVersion=%#x\n", rc, *puVersion));
9445 return rc;
9446}
9447
9448/**
9449 * List the capabilities of image backend in HDD container.
9450 *
9451 * @returns VBox status code.
9452 * @retval VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9453 * @param pDisk Pointer to the HDD container.
9454 * @param nImage Image number, counts from 0. 0 is always base image of container.
9455 * @param pBackendInfo Where to store the backend information.
9456 */
9457VBOXDDU_DECL(int) VDBackendInfoSingle(PVDISK pDisk, unsigned nImage,
9458 PVDBACKENDINFO pBackendInfo)
9459{
9460 int rc = VINF_SUCCESS;
9461 int rc2;
9462 bool fLockRead = false;
9463
9464 LogFlowFunc(("pDisk=%#p nImage=%u pBackendInfo=%#p\n",
9465 pDisk, nImage, pBackendInfo));
9466 do
9467 {
9468 /* sanity check */
9469 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9470 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9471
9472 /* Check arguments. */
9473 AssertMsgBreakStmt(VALID_PTR(pBackendInfo),
9474 ("pBackendInfo=%#p\n", pBackendInfo),
9475 rc = VERR_INVALID_PARAMETER);
9476
9477 rc2 = vdThreadStartRead(pDisk);
9478 AssertRC(rc2);
9479 fLockRead = true;
9480
9481 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9482 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9483
9484 pBackendInfo->pszBackend = pImage->Backend->pszBackendName;
9485 pBackendInfo->uBackendCaps = pImage->Backend->uBackendCaps;
9486 pBackendInfo->paFileExtensions = pImage->Backend->paFileExtensions;
9487 pBackendInfo->paConfigInfo = pImage->Backend->paConfigInfo;
9488 } while (0);
9489
9490 if (RT_UNLIKELY(fLockRead))
9491 {
9492 rc2 = vdThreadFinishRead(pDisk);
9493 AssertRC(rc2);
9494 }
9495
9496 LogFlowFunc(("returns %Rrc\n", rc));
9497 return rc;
9498}
9499
9500/**
9501 * Get flags of image in HDD container.
9502 *
9503 * @returns VBox status code.
9504 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9505 * @param pDisk Pointer to HDD container.
9506 * @param nImage Image number, counts from 0. 0 is always base image of container.
9507 * @param puImageFlags Where to store the image flags.
9508 */
9509VBOXDDU_DECL(int) VDGetImageFlags(PVDISK pDisk, unsigned nImage,
9510 unsigned *puImageFlags)
9511{
9512 int rc = VINF_SUCCESS;
9513 int rc2;
9514 bool fLockRead = false;
9515
9516 LogFlowFunc(("pDisk=%#p nImage=%u puImageFlags=%#p\n",
9517 pDisk, nImage, puImageFlags));
9518 do
9519 {
9520 /* sanity check */
9521 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9522 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9523
9524 /* Check arguments. */
9525 AssertMsgBreakStmt(VALID_PTR(puImageFlags),
9526 ("puImageFlags=%#p\n", puImageFlags),
9527 rc = VERR_INVALID_PARAMETER);
9528
9529 rc2 = vdThreadStartRead(pDisk);
9530 AssertRC(rc2);
9531 fLockRead = true;
9532
9533 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9534 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9535
9536 *puImageFlags = pImage->uImageFlags;
9537 } while (0);
9538
9539 if (RT_UNLIKELY(fLockRead))
9540 {
9541 rc2 = vdThreadFinishRead(pDisk);
9542 AssertRC(rc2);
9543 }
9544
9545 LogFlowFunc(("returns %Rrc uImageFlags=%#x\n", rc, *puImageFlags));
9546 return rc;
9547}
9548
9549/**
9550 * Get open flags of image in HDD container.
9551 *
9552 * @returns VBox status code.
9553 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9554 * @param pDisk Pointer to HDD container.
9555 * @param nImage Image number, counts from 0. 0 is always base image of container.
9556 * @param puOpenFlags Where to store the image open flags.
9557 */
9558VBOXDDU_DECL(int) VDGetOpenFlags(PVDISK pDisk, unsigned nImage,
9559 unsigned *puOpenFlags)
9560{
9561 int rc = VINF_SUCCESS;
9562 int rc2;
9563 bool fLockRead = false;
9564
9565 LogFlowFunc(("pDisk=%#p nImage=%u puOpenFlags=%#p\n",
9566 pDisk, nImage, puOpenFlags));
9567 do
9568 {
9569 /* sanity check */
9570 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9571 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9572
9573 /* Check arguments. */
9574 AssertMsgBreakStmt(VALID_PTR(puOpenFlags),
9575 ("puOpenFlags=%#p\n", puOpenFlags),
9576 rc = VERR_INVALID_PARAMETER);
9577
9578 rc2 = vdThreadStartRead(pDisk);
9579 AssertRC(rc2);
9580 fLockRead = true;
9581
9582 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9583 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9584
9585 *puOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
9586 } while (0);
9587
9588 if (RT_UNLIKELY(fLockRead))
9589 {
9590 rc2 = vdThreadFinishRead(pDisk);
9591 AssertRC(rc2);
9592 }
9593
9594 LogFlowFunc(("returns %Rrc uOpenFlags=%#x\n", rc, *puOpenFlags));
9595 return rc;
9596}
9597
9598/**
9599 * Set open flags of image in HDD container.
9600 * This operation may cause file locking changes and/or files being reopened.
9601 * Note that in case of unrecoverable error all images in HDD container will be closed.
9602 *
9603 * @returns VBox status code.
9604 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9605 * @param pDisk Pointer to HDD container.
9606 * @param nImage Image number, counts from 0. 0 is always base image of container.
9607 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
9608 */
9609VBOXDDU_DECL(int) VDSetOpenFlags(PVDISK pDisk, unsigned nImage,
9610 unsigned uOpenFlags)
9611{
9612 int rc;
9613 int rc2;
9614 bool fLockWrite = false;
9615
9616 LogFlowFunc(("pDisk=%#p uOpenFlags=%#u\n", pDisk, uOpenFlags));
9617 do
9618 {
9619 /* sanity check */
9620 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9621 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9622
9623 /* Check arguments. */
9624 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
9625 ("uOpenFlags=%#x\n", uOpenFlags),
9626 rc = VERR_INVALID_PARAMETER);
9627
9628 rc2 = vdThreadStartWrite(pDisk);
9629 AssertRC(rc2);
9630 fLockWrite = true;
9631
9632 /* Destroy any discard state because the image might be changed to readonly mode. */
9633 rc = vdDiscardStateDestroy(pDisk);
9634 if (RT_FAILURE(rc))
9635 break;
9636
9637 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9638 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9639
9640 rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData,
9641 uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS));
9642 if (RT_SUCCESS(rc))
9643 pImage->uOpenFlags = uOpenFlags & (VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_DISCARD | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS);
9644 } while (0);
9645
9646 if (RT_UNLIKELY(fLockWrite))
9647 {
9648 rc2 = vdThreadFinishWrite(pDisk);
9649 AssertRC(rc2);
9650 }
9651
9652 LogFlowFunc(("returns %Rrc\n", rc));
9653 return rc;
9654}
9655
9656/**
9657 * Get base filename of image in HDD container. Some image formats use
9658 * other filenames as well, so don't use this for anything but informational
9659 * purposes.
9660 *
9661 * @returns VBox status code.
9662 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9663 * @returns VERR_BUFFER_OVERFLOW if pszFilename buffer too small to hold filename.
9664 * @param pDisk Pointer to HDD container.
9665 * @param nImage Image number, counts from 0. 0 is always base image of container.
9666 * @param pszFilename Where to store the image file name.
9667 * @param cbFilename Size of buffer pszFilename points to.
9668 */
9669VBOXDDU_DECL(int) VDGetFilename(PVDISK pDisk, unsigned nImage,
9670 char *pszFilename, unsigned cbFilename)
9671{
9672 int rc;
9673 int rc2;
9674 bool fLockRead = false;
9675
9676 LogFlowFunc(("pDisk=%#p nImage=%u pszFilename=%#p cbFilename=%u\n",
9677 pDisk, nImage, pszFilename, cbFilename));
9678 do
9679 {
9680 /* sanity check */
9681 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9682 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9683
9684 /* Check arguments. */
9685 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
9686 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
9687 rc = VERR_INVALID_PARAMETER);
9688 AssertMsgBreakStmt(cbFilename,
9689 ("cbFilename=%u\n", cbFilename),
9690 rc = VERR_INVALID_PARAMETER);
9691
9692 rc2 = vdThreadStartRead(pDisk);
9693 AssertRC(rc2);
9694 fLockRead = true;
9695
9696 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9697 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9698
9699 size_t cb = strlen(pImage->pszFilename);
9700 if (cb <= cbFilename)
9701 {
9702 strcpy(pszFilename, pImage->pszFilename);
9703 rc = VINF_SUCCESS;
9704 }
9705 else
9706 {
9707 strncpy(pszFilename, pImage->pszFilename, cbFilename - 1);
9708 pszFilename[cbFilename - 1] = '\0';
9709 rc = VERR_BUFFER_OVERFLOW;
9710 }
9711 } while (0);
9712
9713 if (RT_UNLIKELY(fLockRead))
9714 {
9715 rc2 = vdThreadFinishRead(pDisk);
9716 AssertRC(rc2);
9717 }
9718
9719 LogFlowFunc(("returns %Rrc, pszFilename=\"%s\"\n", rc, pszFilename));
9720 return rc;
9721}
9722
9723/**
9724 * Get the comment line of image in HDD container.
9725 *
9726 * @returns VBox status code.
9727 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9728 * @returns VERR_BUFFER_OVERFLOW if pszComment buffer too small to hold comment text.
9729 * @param pDisk Pointer to HDD container.
9730 * @param nImage Image number, counts from 0. 0 is always base image of container.
9731 * @param pszComment Where to store the comment string of image. NULL is ok.
9732 * @param cbComment The size of pszComment buffer. 0 is ok.
9733 */
9734VBOXDDU_DECL(int) VDGetComment(PVDISK pDisk, unsigned nImage,
9735 char *pszComment, unsigned cbComment)
9736{
9737 int rc;
9738 int rc2;
9739 bool fLockRead = false;
9740
9741 LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p cbComment=%u\n",
9742 pDisk, nImage, pszComment, cbComment));
9743 do
9744 {
9745 /* sanity check */
9746 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9747 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9748
9749 /* Check arguments. */
9750 AssertMsgBreakStmt(VALID_PTR(pszComment),
9751 ("pszComment=%#p \"%s\"\n", pszComment, pszComment),
9752 rc = VERR_INVALID_PARAMETER);
9753 AssertMsgBreakStmt(cbComment,
9754 ("cbComment=%u\n", cbComment),
9755 rc = VERR_INVALID_PARAMETER);
9756
9757 rc2 = vdThreadStartRead(pDisk);
9758 AssertRC(rc2);
9759 fLockRead = true;
9760
9761 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9762 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9763
9764 rc = pImage->Backend->pfnGetComment(pImage->pBackendData, pszComment,
9765 cbComment);
9766 } while (0);
9767
9768 if (RT_UNLIKELY(fLockRead))
9769 {
9770 rc2 = vdThreadFinishRead(pDisk);
9771 AssertRC(rc2);
9772 }
9773
9774 LogFlowFunc(("returns %Rrc, pszComment=\"%s\"\n", rc, pszComment));
9775 return rc;
9776}
9777
9778/**
9779 * Changes the comment line of image in HDD container.
9780 *
9781 * @returns VBox status code.
9782 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9783 * @param pDisk Pointer to HDD container.
9784 * @param nImage Image number, counts from 0. 0 is always base image of container.
9785 * @param pszComment New comment string (UTF-8). NULL is allowed to reset the comment.
9786 */
9787VBOXDDU_DECL(int) VDSetComment(PVDISK pDisk, unsigned nImage,
9788 const char *pszComment)
9789{
9790 int rc;
9791 int rc2;
9792 bool fLockWrite = false;
9793
9794 LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p \"%s\"\n",
9795 pDisk, nImage, pszComment, pszComment));
9796 do
9797 {
9798 /* sanity check */
9799 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9800 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9801
9802 /* Check arguments. */
9803 AssertMsgBreakStmt(VALID_PTR(pszComment) || pszComment == NULL,
9804 ("pszComment=%#p \"%s\"\n", pszComment, pszComment),
9805 rc = VERR_INVALID_PARAMETER);
9806
9807 rc2 = vdThreadStartWrite(pDisk);
9808 AssertRC(rc2);
9809 fLockWrite = true;
9810
9811 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9812 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9813
9814 rc = pImage->Backend->pfnSetComment(pImage->pBackendData, pszComment);
9815 } while (0);
9816
9817 if (RT_UNLIKELY(fLockWrite))
9818 {
9819 rc2 = vdThreadFinishWrite(pDisk);
9820 AssertRC(rc2);
9821 }
9822
9823 LogFlowFunc(("returns %Rrc\n", rc));
9824 return rc;
9825}
9826
9827
9828/**
9829 * Get UUID of image in HDD container.
9830 *
9831 * @returns VBox status code.
9832 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9833 * @param pDisk Pointer to HDD container.
9834 * @param nImage Image number, counts from 0. 0 is always base image of container.
9835 * @param pUuid Where to store the image creation UUID.
9836 */
9837VBOXDDU_DECL(int) VDGetUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
9838{
9839 int rc;
9840 int rc2;
9841 bool fLockRead = false;
9842
9843 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
9844 do
9845 {
9846 /* sanity check */
9847 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9848 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9849
9850 /* Check arguments. */
9851 AssertMsgBreakStmt(VALID_PTR(pUuid),
9852 ("pUuid=%#p\n", pUuid),
9853 rc = VERR_INVALID_PARAMETER);
9854
9855 rc2 = vdThreadStartRead(pDisk);
9856 AssertRC(rc2);
9857 fLockRead = true;
9858
9859 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9860 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9861
9862 rc = pImage->Backend->pfnGetUuid(pImage->pBackendData, pUuid);
9863 } while (0);
9864
9865 if (RT_UNLIKELY(fLockRead))
9866 {
9867 rc2 = vdThreadFinishRead(pDisk);
9868 AssertRC(rc2);
9869 }
9870
9871 LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
9872 return rc;
9873}
9874
9875/**
9876 * Set the image's UUID. Should not be used by normal applications.
9877 *
9878 * @returns VBox status code.
9879 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9880 * @param pDisk Pointer to HDD container.
9881 * @param nImage Image number, counts from 0. 0 is always base image of container.
9882 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
9883 */
9884VBOXDDU_DECL(int) VDSetUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
9885{
9886 int rc;
9887 int rc2;
9888 bool fLockWrite = false;
9889
9890 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
9891 pDisk, nImage, pUuid, pUuid));
9892 do
9893 {
9894 /* sanity check */
9895 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9896 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9897
9898 AssertMsgBreakStmt(VALID_PTR(pUuid) || pUuid == NULL,
9899 ("pUuid=%#p\n", pUuid),
9900 rc = VERR_INVALID_PARAMETER);
9901
9902 rc2 = vdThreadStartWrite(pDisk);
9903 AssertRC(rc2);
9904 fLockWrite = true;
9905
9906 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9907 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9908
9909 RTUUID Uuid;
9910 if (!pUuid)
9911 {
9912 RTUuidCreate(&Uuid);
9913 pUuid = &Uuid;
9914 }
9915 rc = pImage->Backend->pfnSetUuid(pImage->pBackendData, pUuid);
9916 } while (0);
9917
9918 if (RT_UNLIKELY(fLockWrite))
9919 {
9920 rc2 = vdThreadFinishWrite(pDisk);
9921 AssertRC(rc2);
9922 }
9923
9924 LogFlowFunc(("returns %Rrc\n", rc));
9925 return rc;
9926}
9927
9928/**
9929 * Get last modification UUID of image in HDD container.
9930 *
9931 * @returns VBox status code.
9932 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9933 * @param pDisk Pointer to HDD container.
9934 * @param nImage Image number, counts from 0. 0 is always base image of container.
9935 * @param pUuid Where to store the image modification UUID.
9936 */
9937VBOXDDU_DECL(int) VDGetModificationUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
9938{
9939 int rc = VINF_SUCCESS;
9940 int rc2;
9941 bool fLockRead = false;
9942
9943 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
9944 do
9945 {
9946 /* sanity check */
9947 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9948 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9949
9950 /* Check arguments. */
9951 AssertMsgBreakStmt(VALID_PTR(pUuid),
9952 ("pUuid=%#p\n", pUuid),
9953 rc = VERR_INVALID_PARAMETER);
9954
9955 rc2 = vdThreadStartRead(pDisk);
9956 AssertRC(rc2);
9957 fLockRead = true;
9958
9959 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9960 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9961
9962 rc = pImage->Backend->pfnGetModificationUuid(pImage->pBackendData,
9963 pUuid);
9964 } while (0);
9965
9966 if (RT_UNLIKELY(fLockRead))
9967 {
9968 rc2 = vdThreadFinishRead(pDisk);
9969 AssertRC(rc2);
9970 }
9971
9972 LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
9973 return rc;
9974}
9975
9976/**
9977 * Set the image's last modification UUID. Should not be used by normal applications.
9978 *
9979 * @returns VBox status code.
9980 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9981 * @param pDisk Pointer to HDD container.
9982 * @param nImage Image number, counts from 0. 0 is always base image of container.
9983 * @param pUuid New modification UUID of the image. If NULL, a new UUID is created.
9984 */
9985VBOXDDU_DECL(int) VDSetModificationUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
9986{
9987 int rc;
9988 int rc2;
9989 bool fLockWrite = false;
9990
9991 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
9992 pDisk, nImage, pUuid, pUuid));
9993 do
9994 {
9995 /* sanity check */
9996 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9997 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9998
9999 /* Check arguments. */
10000 AssertMsgBreakStmt(VALID_PTR(pUuid) || pUuid == NULL,
10001 ("pUuid=%#p\n", pUuid),
10002 rc = VERR_INVALID_PARAMETER);
10003
10004 rc2 = vdThreadStartWrite(pDisk);
10005 AssertRC(rc2);
10006 fLockWrite = true;
10007
10008 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
10009 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
10010
10011 RTUUID Uuid;
10012 if (!pUuid)
10013 {
10014 RTUuidCreate(&Uuid);
10015 pUuid = &Uuid;
10016 }
10017 rc = pImage->Backend->pfnSetModificationUuid(pImage->pBackendData,
10018 pUuid);
10019 } while (0);
10020
10021 if (RT_UNLIKELY(fLockWrite))
10022 {
10023 rc2 = vdThreadFinishWrite(pDisk);
10024 AssertRC(rc2);
10025 }
10026
10027 LogFlowFunc(("returns %Rrc\n", rc));
10028 return rc;
10029}
10030
10031/**
10032 * Get parent UUID of image in HDD container.
10033 *
10034 * @returns VBox status code.
10035 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
10036 * @param pDisk Pointer to HDD container.
10037 * @param nImage Image number, counts from 0. 0 is always base image of container.
10038 * @param pUuid Where to store the parent image UUID.
10039 */
10040VBOXDDU_DECL(int) VDGetParentUuid(PVDISK pDisk, unsigned nImage,
10041 PRTUUID pUuid)
10042{
10043 int rc = VINF_SUCCESS;
10044 int rc2;
10045 bool fLockRead = false;
10046
10047 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
10048 do
10049 {
10050 /* sanity check */
10051 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10052 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10053
10054 /* Check arguments. */
10055 AssertMsgBreakStmt(VALID_PTR(pUuid),
10056 ("pUuid=%#p\n", pUuid),
10057 rc = VERR_INVALID_PARAMETER);
10058
10059 rc2 = vdThreadStartRead(pDisk);
10060 AssertRC(rc2);
10061 fLockRead = true;
10062
10063 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
10064 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
10065
10066 rc = pImage->Backend->pfnGetParentUuid(pImage->pBackendData, pUuid);
10067 } while (0);
10068
10069 if (RT_UNLIKELY(fLockRead))
10070 {
10071 rc2 = vdThreadFinishRead(pDisk);
10072 AssertRC(rc2);
10073 }
10074
10075 LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
10076 return rc;
10077}
10078
10079/**
10080 * Set the image's parent UUID. Should not be used by normal applications.
10081 *
10082 * @returns VBox status code.
10083 * @param pDisk Pointer to HDD container.
10084 * @param nImage Image number, counts from 0. 0 is always base image of container.
10085 * @param pUuid New parent UUID of the image. If NULL, a new UUID is created.
10086 */
10087VBOXDDU_DECL(int) VDSetParentUuid(PVDISK pDisk, unsigned nImage,
10088 PCRTUUID pUuid)
10089{
10090 int rc;
10091 int rc2;
10092 bool fLockWrite = false;
10093
10094 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
10095 pDisk, nImage, pUuid, pUuid));
10096 do
10097 {
10098 /* sanity check */
10099 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10100 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10101
10102 /* Check arguments. */
10103 AssertMsgBreakStmt(VALID_PTR(pUuid) || pUuid == NULL,
10104 ("pUuid=%#p\n", pUuid),
10105 rc = VERR_INVALID_PARAMETER);
10106
10107 rc2 = vdThreadStartWrite(pDisk);
10108 AssertRC(rc2);
10109 fLockWrite = true;
10110
10111 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
10112 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
10113
10114 RTUUID Uuid;
10115 if (!pUuid)
10116 {
10117 RTUuidCreate(&Uuid);
10118 pUuid = &Uuid;
10119 }
10120 rc = pImage->Backend->pfnSetParentUuid(pImage->pBackendData, pUuid);
10121 } while (0);
10122
10123 if (RT_UNLIKELY(fLockWrite))
10124 {
10125 rc2 = vdThreadFinishWrite(pDisk);
10126 AssertRC(rc2);
10127 }
10128
10129 LogFlowFunc(("returns %Rrc\n", rc));
10130 return rc;
10131}
10132
10133
10134/**
10135 * Debug helper - dumps all opened images in HDD container into the log file.
10136 *
10137 * @param pDisk Pointer to HDD container.
10138 */
10139VBOXDDU_DECL(void) VDDumpImages(PVDISK pDisk)
10140{
10141 int rc2;
10142 bool fLockRead = false;
10143
10144 do
10145 {
10146 /* sanity check */
10147 AssertPtrBreak(pDisk);
10148 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10149
10150 if (!pDisk->pInterfaceError || !VALID_PTR(pDisk->pInterfaceError->pfnMessage))
10151 pDisk->pInterfaceError->pfnMessage = vdLogMessage;
10152
10153 rc2 = vdThreadStartRead(pDisk);
10154 AssertRC(rc2);
10155 fLockRead = true;
10156
10157 vdMessageWrapper(pDisk, "--- Dumping VD Disk, Images=%u\n", pDisk->cImages);
10158 for (PVDIMAGE pImage = pDisk->pBase; pImage; pImage = pImage->pNext)
10159 {
10160 vdMessageWrapper(pDisk, "Dumping VD image \"%s\" (Backend=%s)\n",
10161 pImage->pszFilename, pImage->Backend->pszBackendName);
10162 pImage->Backend->pfnDump(pImage->pBackendData);
10163 }
10164 } while (0);
10165
10166 if (RT_UNLIKELY(fLockRead))
10167 {
10168 rc2 = vdThreadFinishRead(pDisk);
10169 AssertRC(rc2);
10170 }
10171}
10172
10173
10174VBOXDDU_DECL(int) VDDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges)
10175{
10176 int rc;
10177 int rc2;
10178 bool fLockWrite = false;
10179
10180 LogFlowFunc(("pDisk=%#p paRanges=%#p cRanges=%u\n",
10181 pDisk, paRanges, cRanges));
10182 do
10183 {
10184 /* sanity check */
10185 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10186 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10187
10188 /* Check arguments. */
10189 AssertMsgBreakStmt(cRanges,
10190 ("cRanges=%u\n", cRanges),
10191 rc = VERR_INVALID_PARAMETER);
10192 AssertMsgBreakStmt(VALID_PTR(paRanges),
10193 ("paRanges=%#p\n", paRanges),
10194 rc = VERR_INVALID_PARAMETER);
10195
10196 rc2 = vdThreadStartWrite(pDisk);
10197 AssertRC(rc2);
10198 fLockWrite = true;
10199
10200 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10201
10202 AssertMsgBreakStmt(pDisk->pLast->uOpenFlags & VD_OPEN_FLAGS_DISCARD,
10203 ("Discarding not supported\n"),
10204 rc = VERR_NOT_SUPPORTED);
10205
10206 VDIOCTX IoCtx;
10207 RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
10208
10209 rc = RTSemEventCreate(&hEventComplete);
10210 if (RT_FAILURE(rc))
10211 break;
10212
10213 vdIoCtxDiscardInit(&IoCtx, pDisk, paRanges, cRanges,
10214 vdIoCtxSyncComplete, pDisk, hEventComplete, NULL,
10215 vdDiscardHelperAsync, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE);
10216 rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
10217
10218 RTSemEventDestroy(hEventComplete);
10219 } while (0);
10220
10221 if (RT_UNLIKELY(fLockWrite))
10222 {
10223 rc2 = vdThreadFinishWrite(pDisk);
10224 AssertRC(rc2);
10225 }
10226
10227 LogFlowFunc(("returns %Rrc\n", rc));
10228 return rc;
10229}
10230
10231
10232VBOXDDU_DECL(int) VDAsyncRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
10233 PCRTSGBUF pcSgBuf,
10234 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10235 void *pvUser1, void *pvUser2)
10236{
10237 int rc = VERR_VD_BLOCK_FREE;
10238 int rc2;
10239 bool fLockRead = false;
10240 PVDIOCTX pIoCtx = NULL;
10241
10242 LogFlowFunc(("pDisk=%#p uOffset=%llu pcSgBuf=%#p cbRead=%zu pvUser1=%#p pvUser2=%#p\n",
10243 pDisk, uOffset, pcSgBuf, cbRead, pvUser1, pvUser2));
10244
10245 do
10246 {
10247 /* sanity check */
10248 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10249 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10250
10251 /* Check arguments. */
10252 AssertMsgBreakStmt(cbRead,
10253 ("cbRead=%zu\n", cbRead),
10254 rc = VERR_INVALID_PARAMETER);
10255 AssertMsgBreakStmt(VALID_PTR(pcSgBuf),
10256 ("pcSgBuf=%#p\n", pcSgBuf),
10257 rc = VERR_INVALID_PARAMETER);
10258
10259 rc2 = vdThreadStartRead(pDisk);
10260 AssertRC(rc2);
10261 fLockRead = true;
10262
10263 AssertMsgBreakStmt(uOffset + cbRead <= pDisk->cbSize,
10264 ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
10265 uOffset, cbRead, pDisk->cbSize),
10266 rc = VERR_INVALID_PARAMETER);
10267 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10268
10269 pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
10270 cbRead, pDisk->pLast, pcSgBuf,
10271 pfnComplete, pvUser1, pvUser2,
10272 NULL, vdReadHelperAsync,
10273 VDIOCTX_FLAGS_ZERO_FREE_BLOCKS);
10274 if (!pIoCtx)
10275 {
10276 rc = VERR_NO_MEMORY;
10277 break;
10278 }
10279
10280 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10281 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10282 {
10283 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10284 vdIoCtxFree(pDisk, pIoCtx);
10285 else
10286 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10287 }
10288 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10289 vdIoCtxFree(pDisk, pIoCtx);
10290
10291 } while (0);
10292
10293 if (RT_UNLIKELY(fLockRead) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10294 {
10295 rc2 = vdThreadFinishRead(pDisk);
10296 AssertRC(rc2);
10297 }
10298
10299 LogFlowFunc(("returns %Rrc\n", rc));
10300 return rc;
10301}
10302
10303
10304VBOXDDU_DECL(int) VDAsyncWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
10305 PCRTSGBUF pcSgBuf,
10306 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10307 void *pvUser1, void *pvUser2)
10308{
10309 int rc;
10310 int rc2;
10311 bool fLockWrite = false;
10312 PVDIOCTX pIoCtx = NULL;
10313
10314 LogFlowFunc(("pDisk=%#p uOffset=%llu cSgBuf=%#p cbWrite=%zu pvUser1=%#p pvUser2=%#p\n",
10315 pDisk, uOffset, pcSgBuf, cbWrite, pvUser1, pvUser2));
10316 do
10317 {
10318 /* sanity check */
10319 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10320 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10321
10322 /* Check arguments. */
10323 AssertMsgBreakStmt(cbWrite,
10324 ("cbWrite=%zu\n", cbWrite),
10325 rc = VERR_INVALID_PARAMETER);
10326 AssertMsgBreakStmt(VALID_PTR(pcSgBuf),
10327 ("pcSgBuf=%#p\n", pcSgBuf),
10328 rc = VERR_INVALID_PARAMETER);
10329
10330 rc2 = vdThreadStartWrite(pDisk);
10331 AssertRC(rc2);
10332 fLockWrite = true;
10333
10334 AssertMsgBreakStmt(uOffset + cbWrite <= pDisk->cbSize,
10335 ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
10336 uOffset, cbWrite, pDisk->cbSize),
10337 rc = VERR_INVALID_PARAMETER);
10338 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10339
10340 pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_WRITE, uOffset,
10341 cbWrite, pDisk->pLast, pcSgBuf,
10342 pfnComplete, pvUser1, pvUser2,
10343 NULL, vdWriteHelperAsync,
10344 VDIOCTX_FLAGS_DEFAULT);
10345 if (!pIoCtx)
10346 {
10347 rc = VERR_NO_MEMORY;
10348 break;
10349 }
10350
10351 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10352 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10353 {
10354 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10355 vdIoCtxFree(pDisk, pIoCtx);
10356 else
10357 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10358 }
10359 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10360 vdIoCtxFree(pDisk, pIoCtx);
10361 } while (0);
10362
10363 if (RT_UNLIKELY(fLockWrite) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10364 {
10365 rc2 = vdThreadFinishWrite(pDisk);
10366 AssertRC(rc2);
10367 }
10368
10369 LogFlowFunc(("returns %Rrc\n", rc));
10370 return rc;
10371}
10372
10373
10374VBOXDDU_DECL(int) VDAsyncFlush(PVDISK pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10375 void *pvUser1, void *pvUser2)
10376{
10377 int rc;
10378 int rc2;
10379 bool fLockWrite = false;
10380 PVDIOCTX pIoCtx = NULL;
10381
10382 LogFlowFunc(("pDisk=%#p\n", pDisk));
10383
10384 do
10385 {
10386 /* sanity check */
10387 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10388 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10389
10390 rc2 = vdThreadStartWrite(pDisk);
10391 AssertRC(rc2);
10392 fLockWrite = true;
10393
10394 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10395
10396 pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_FLUSH, 0,
10397 0, pDisk->pLast, NULL,
10398 pfnComplete, pvUser1, pvUser2,
10399 NULL, vdFlushHelperAsync,
10400 VDIOCTX_FLAGS_DEFAULT);
10401 if (!pIoCtx)
10402 {
10403 rc = VERR_NO_MEMORY;
10404 break;
10405 }
10406
10407 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10408 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10409 {
10410 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10411 vdIoCtxFree(pDisk, pIoCtx);
10412 else
10413 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10414 }
10415 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10416 vdIoCtxFree(pDisk, pIoCtx);
10417 } while (0);
10418
10419 if (RT_UNLIKELY(fLockWrite) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10420 {
10421 rc2 = vdThreadFinishWrite(pDisk);
10422 AssertRC(rc2);
10423 }
10424
10425 LogFlowFunc(("returns %Rrc\n", rc));
10426 return rc;
10427}
10428
10429VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges,
10430 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10431 void *pvUser1, void *pvUser2)
10432{
10433 int rc;
10434 int rc2;
10435 bool fLockWrite = false;
10436 PVDIOCTX pIoCtx = NULL;
10437
10438 LogFlowFunc(("pDisk=%#p\n", pDisk));
10439
10440 do
10441 {
10442 /* sanity check */
10443 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10444 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10445
10446 rc2 = vdThreadStartWrite(pDisk);
10447 AssertRC(rc2);
10448 fLockWrite = true;
10449
10450 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10451
10452 pIoCtx = vdIoCtxDiscardAlloc(pDisk, paRanges, cRanges,
10453 pfnComplete, pvUser1, pvUser2, NULL,
10454 vdDiscardHelperAsync,
10455 VDIOCTX_FLAGS_DEFAULT);
10456 if (!pIoCtx)
10457 {
10458 rc = VERR_NO_MEMORY;
10459 break;
10460 }
10461
10462 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10463 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10464 {
10465 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10466 vdIoCtxFree(pDisk, pIoCtx);
10467 else
10468 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10469 }
10470 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10471 vdIoCtxFree(pDisk, pIoCtx);
10472 } while (0);
10473
10474 if (RT_UNLIKELY(fLockWrite) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10475 {
10476 rc2 = vdThreadFinishWrite(pDisk);
10477 AssertRC(rc2);
10478 }
10479
10480 LogFlowFunc(("returns %Rrc\n", rc));
10481 return rc;
10482}
10483
10484VBOXDDU_DECL(int) VDRepair(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
10485 const char *pszFilename, const char *pszBackend,
10486 uint32_t fFlags)
10487{
10488 int rc = VERR_NOT_SUPPORTED;
10489 PCVDIMAGEBACKEND pBackend = NULL;
10490 VDINTERFACEIOINT VDIfIoInt;
10491 VDINTERFACEIO VDIfIoFallback;
10492 PVDINTERFACEIO pInterfaceIo;
10493
10494 LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
10495 /* Check arguments. */
10496 AssertMsgReturn(VALID_PTR(pszFilename) && *pszFilename,
10497 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
10498 VERR_INVALID_PARAMETER);
10499 AssertMsgReturn(VALID_PTR(pszBackend),
10500 ("pszBackend=%#p\n", pszBackend),
10501 VERR_INVALID_PARAMETER);
10502 AssertMsgReturn((fFlags & ~VD_REPAIR_FLAGS_MASK) == 0,
10503 ("fFlags=%#x\n", fFlags),
10504 VERR_INVALID_PARAMETER);
10505
10506 pInterfaceIo = VDIfIoGet(pVDIfsImage);
10507 if (!pInterfaceIo)
10508 {
10509 /*
10510 * Caller doesn't provide an I/O interface, create our own using the
10511 * native file API.
10512 */
10513 vdIfIoFallbackCallbacksSetup(&VDIfIoFallback);
10514 pInterfaceIo = &VDIfIoFallback;
10515 }
10516
10517 /* Set up the internal I/O interface. */
10518 AssertReturn(!VDIfIoIntGet(pVDIfsImage), VERR_INVALID_PARAMETER);
10519 VDIfIoInt.pfnOpen = vdIOIntOpenLimited;
10520 VDIfIoInt.pfnClose = vdIOIntCloseLimited;
10521 VDIfIoInt.pfnDelete = vdIOIntDeleteLimited;
10522 VDIfIoInt.pfnMove = vdIOIntMoveLimited;
10523 VDIfIoInt.pfnGetFreeSpace = vdIOIntGetFreeSpaceLimited;
10524 VDIfIoInt.pfnGetModificationTime = vdIOIntGetModificationTimeLimited;
10525 VDIfIoInt.pfnGetSize = vdIOIntGetSizeLimited;
10526 VDIfIoInt.pfnSetSize = vdIOIntSetSizeLimited;
10527 VDIfIoInt.pfnReadUser = vdIOIntReadUserLimited;
10528 VDIfIoInt.pfnWriteUser = vdIOIntWriteUserLimited;
10529 VDIfIoInt.pfnReadMeta = vdIOIntReadMetaLimited;
10530 VDIfIoInt.pfnWriteMeta = vdIOIntWriteMetaLimited;
10531 VDIfIoInt.pfnFlush = vdIOIntFlushLimited;
10532 rc = VDInterfaceAdd(&VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
10533 pInterfaceIo, sizeof(VDINTERFACEIOINT), &pVDIfsImage);
10534 AssertRC(rc);
10535
10536 rc = vdFindImageBackend(pszBackend, &pBackend);
10537 if (RT_SUCCESS(rc))
10538 {
10539 if (pBackend->pfnRepair)
10540 rc = pBackend->pfnRepair(pszFilename, pVDIfsDisk, pVDIfsImage, fFlags);
10541 else
10542 rc = VERR_VD_IMAGE_REPAIR_NOT_SUPPORTED;
10543 }
10544
10545 LogFlowFunc(("returns %Rrc\n", rc));
10546 return rc;
10547}
10548
10549
10550/*
10551 * generic plugin functions
10552 */
10553
10554/**
10555 * @interface_method_impl{VDIMAGEBACKEND,pfnComposeLocation}
10556 */
10557DECLCALLBACK(int) genericFileComposeLocation(PVDINTERFACE pConfig, char **pszLocation)
10558{
10559 RT_NOREF1(pConfig);
10560 *pszLocation = NULL;
10561 return VINF_SUCCESS;
10562}
10563
10564/**
10565 * @interface_method_impl{VDIMAGEBACKEND,pfnComposeName}
10566 */
10567DECLCALLBACK(int) genericFileComposeName(PVDINTERFACE pConfig, char **pszName)
10568{
10569 RT_NOREF1(pConfig);
10570 *pszName = NULL;
10571 return VINF_SUCCESS;
10572}
10573
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