VirtualBox

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

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

Storage/VD.cpp: Remove duplicate argument validation in VDCreateBase and addressed a couple of todos. bugref:9224
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 378.8 KB
Line 
1/* $Id: VD.cpp 85944 2020-08-28 20:57:37Z 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 AssertPtrReturn(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 AssertPtrBreakStmt(pVDIfsImage, rc = VERR_INVALID_PARAMETER);
6281
6282 /* Check state. Needs a temporary read lock. Holding the write lock
6283 * all the time would be blocking other activities for too long. */
6284 rc2 = vdThreadStartRead(pDisk);
6285 AssertRC(rc2);
6286 fLockRead = true;
6287 AssertMsgBreakStmt(pDisk->cImages == 0,
6288 ("Create base image cannot be done with other images open\n"),
6289 rc = VERR_VD_INVALID_STATE);
6290 rc2 = vdThreadFinishRead(pDisk);
6291 AssertRC(rc2);
6292 fLockRead = false;
6293
6294 /* Set up image descriptor. */
6295 pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
6296 if (!pImage)
6297 {
6298 rc = VERR_NO_MEMORY;
6299 break;
6300 }
6301 pImage->pszFilename = RTStrDup(pszFilename);
6302 if (!pImage->pszFilename)
6303 {
6304 rc = VERR_NO_MEMORY;
6305 break;
6306 }
6307 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
6308 pImage->VDIo.pDisk = pDisk;
6309 pImage->pVDIfsImage = pVDIfsImage;
6310
6311 /* Set up the I/O interface. */
6312 pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
6313 if (!pImage->VDIo.pInterfaceIo)
6314 {
6315 vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
6316 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
6317 pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
6318 pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
6319 }
6320
6321 /* Set up the internal I/O interface. */
6322 AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
6323 vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
6324 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6325 &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
6326 AssertRC(rc);
6327
6328 rc = vdFindImageBackend(pszBackend, &pImage->Backend);
6329 if (RT_FAILURE(rc))
6330 break;
6331 if (!pImage->Backend)
6332 {
6333 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6334 N_("VD: unknown backend name '%s'"), pszBackend);
6335 break;
6336 }
6337 if (!(pImage->Backend->uBackendCaps & ( VD_CAP_CREATE_FIXED
6338 | VD_CAP_CREATE_DYNAMIC)))
6339 {
6340 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6341 N_("VD: backend '%s' cannot create base images"), pszBackend);
6342 break;
6343 }
6344 if ( ( (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
6345 && !(pImage->Backend->uBackendCaps & VD_CAP_CREATE_SPLIT_2G))
6346 || ( (uImageFlags & ( VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
6347 | VD_VMDK_IMAGE_FLAGS_RAWDISK))
6348 && RTStrICmp(pszBackend, "VMDK")))
6349 {
6350 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6351 N_("VD: backend '%s' does not support the selected image variant"), pszBackend);
6352 break;
6353 }
6354
6355 /* Create UUID if the caller didn't specify one. */
6356 if (!pUuid)
6357 {
6358 rc = RTUuidCreate(&uuid);
6359 if (RT_FAILURE(rc))
6360 {
6361 rc = vdError(pDisk, rc, RT_SRC_POS,
6362 N_("VD: cannot generate UUID for image '%s'"),
6363 pszFilename);
6364 break;
6365 }
6366 pUuid = &uuid;
6367 }
6368
6369 pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
6370 uImageFlags &= ~VD_IMAGE_FLAGS_DIFF;
6371 pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
6372 rc = pImage->Backend->pfnCreate(pImage->pszFilename, cbSize,
6373 uImageFlags, pszComment, pPCHSGeometry,
6374 pLCHSGeometry, pUuid,
6375 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
6376 0, 99,
6377 pDisk->pVDIfsDisk,
6378 pImage->pVDIfsImage,
6379 pVDIfsOperation,
6380 pDisk->enmType,
6381 &pImage->pBackendData);
6382
6383 if (RT_SUCCESS(rc))
6384 {
6385 pImage->VDIo.pBackendData = pImage->pBackendData;
6386 pImage->uImageFlags = uImageFlags;
6387
6388 /* Force sane optimization settings. It's not worth avoiding writes
6389 * to fixed size images. The overhead would have almost no payback. */
6390 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
6391 pImage->uOpenFlags |= VD_OPEN_FLAGS_HONOR_SAME;
6392
6393 /* Lock disk for writing, as we modify pDisk information below. */
6394 rc2 = vdThreadStartWrite(pDisk);
6395 AssertRC(rc2);
6396 fLockWrite = true;
6397
6398 /** @todo optionally check UUIDs */
6399
6400 /* Re-check state, as the lock wasn't held and another image
6401 * creation call could have been done by another thread. */
6402 AssertMsgStmt(pDisk->cImages == 0,
6403 ("Create base image cannot be done with other images open\n"),
6404 rc = VERR_VD_INVALID_STATE);
6405 }
6406
6407 if (RT_SUCCESS(rc))
6408 {
6409 /* Cache disk information. */
6410 pDisk->cbSize = vdImageGetSize(pImage);
6411
6412 /* Cache PCHS geometry. */
6413 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
6414 &pDisk->PCHSGeometry);
6415 if (RT_FAILURE(rc2))
6416 {
6417 pDisk->PCHSGeometry.cCylinders = 0;
6418 pDisk->PCHSGeometry.cHeads = 0;
6419 pDisk->PCHSGeometry.cSectors = 0;
6420 }
6421 else
6422 {
6423 /* Make sure the CHS geometry is properly clipped. */
6424 pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
6425 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
6426 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
6427 }
6428
6429 /* Cache LCHS geometry. */
6430 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
6431 &pDisk->LCHSGeometry);
6432 if (RT_FAILURE(rc2))
6433 {
6434 pDisk->LCHSGeometry.cCylinders = 0;
6435 pDisk->LCHSGeometry.cHeads = 0;
6436 pDisk->LCHSGeometry.cSectors = 0;
6437 }
6438 else
6439 {
6440 /* Make sure the CHS geometry is properly clipped. */
6441 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
6442 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
6443 }
6444
6445 /* Image successfully opened, make it the last image. */
6446 vdAddImageToList(pDisk, pImage);
6447 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
6448 pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
6449 }
6450 else
6451 {
6452 /* Error detected, image may or may not be opened. Close and delete
6453 * image if it was opened. */
6454 if (pImage->pBackendData)
6455 {
6456 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, true);
6457 AssertRC(rc2);
6458 pImage->pBackendData = NULL;
6459 }
6460 }
6461 } while (0);
6462
6463 if (RT_UNLIKELY(fLockWrite))
6464 {
6465 rc2 = vdThreadFinishWrite(pDisk);
6466 AssertRC(rc2);
6467 }
6468 else if (RT_UNLIKELY(fLockRead))
6469 {
6470 rc2 = vdThreadFinishRead(pDisk);
6471 AssertRC(rc2);
6472 }
6473
6474 if (RT_FAILURE(rc))
6475 {
6476 if (pImage)
6477 {
6478 if (pImage->pszFilename)
6479 RTStrFree(pImage->pszFilename);
6480 RTMemFree(pImage);
6481 }
6482 }
6483
6484 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
6485 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
6486
6487 LogFlowFunc(("returns %Rrc\n", rc));
6488 return rc;
6489}
6490
6491/**
6492 * Creates and opens a new differencing image file in HDD container.
6493 * See comments for VDOpen function about differencing images.
6494 *
6495 * @returns VBox status code.
6496 * @param pDisk Pointer to HDD container.
6497 * @param pszBackend Name of the image file backend to use.
6498 * @param pszFilename Name of the differencing image file to create.
6499 * @param uImageFlags Flags specifying special image features.
6500 * @param pszComment Pointer to image comment. NULL is ok.
6501 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
6502 * @param pParentUuid New parent UUID of the image. If NULL, the UUID is queried automatically.
6503 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
6504 * @param pVDIfsImage Pointer to the per-image VD interface list.
6505 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6506 */
6507VBOXDDU_DECL(int) VDCreateDiff(PVDISK pDisk, const char *pszBackend,
6508 const char *pszFilename, unsigned uImageFlags,
6509 const char *pszComment, PCRTUUID pUuid,
6510 PCRTUUID pParentUuid, unsigned uOpenFlags,
6511 PVDINTERFACE pVDIfsImage,
6512 PVDINTERFACE pVDIfsOperation)
6513{
6514 int rc = VINF_SUCCESS;
6515 int rc2;
6516 bool fLockWrite = false, fLockRead = false;
6517 PVDIMAGE pImage = NULL;
6518 RTUUID uuid;
6519
6520 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
6521 pDisk, pszBackend, pszFilename, uImageFlags, pszComment, pUuid, uOpenFlags, pVDIfsImage, pVDIfsOperation));
6522
6523 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
6524
6525 do
6526 {
6527 /* sanity check */
6528 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
6529 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
6530
6531 /* Check arguments. */
6532 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
6533 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
6534 rc = VERR_INVALID_PARAMETER);
6535 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
6536 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
6537 rc = VERR_INVALID_PARAMETER);
6538 AssertMsgBreakStmt((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0,
6539 ("uImageFlags=%#x\n", uImageFlags),
6540 rc = VERR_INVALID_PARAMETER);
6541 /* The UUID may be NULL. */
6542 AssertMsgBreakStmt(pUuid == NULL || VALID_PTR(pUuid),
6543 ("pUuid=%#p UUID=%RTuuid\n", pUuid, pUuid),
6544 rc = VERR_INVALID_PARAMETER);
6545 /* The parent UUID may be NULL. */
6546 AssertMsgBreakStmt(pParentUuid == NULL || VALID_PTR(pParentUuid),
6547 ("pParentUuid=%#p ParentUUID=%RTuuid\n", pParentUuid, pParentUuid),
6548 rc = VERR_INVALID_PARAMETER);
6549 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
6550 ("uOpenFlags=%#x\n", uOpenFlags),
6551 rc = VERR_INVALID_PARAMETER);
6552
6553 /* Check state. Needs a temporary read lock. Holding the write lock
6554 * all the time would be blocking other activities for too long. */
6555 rc2 = vdThreadStartRead(pDisk);
6556 AssertRC(rc2);
6557 fLockRead = true;
6558 AssertMsgBreakStmt(pDisk->cImages != 0,
6559 ("Create diff image cannot be done without other images open\n"),
6560 rc = VERR_VD_INVALID_STATE);
6561 rc2 = vdThreadFinishRead(pDisk);
6562 AssertRC(rc2);
6563 fLockRead = false;
6564
6565 /*
6566 * Destroy the current discard state first which might still have pending blocks
6567 * for the currently opened image which will be switched to readonly mode.
6568 */
6569 /* Lock disk for writing, as we modify pDisk information below. */
6570 rc2 = vdThreadStartWrite(pDisk);
6571 AssertRC(rc2);
6572 fLockWrite = true;
6573 rc = vdDiscardStateDestroy(pDisk);
6574 if (RT_FAILURE(rc))
6575 break;
6576 rc2 = vdThreadFinishWrite(pDisk);
6577 AssertRC(rc2);
6578 fLockWrite = false;
6579
6580 /* Set up image descriptor. */
6581 pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
6582 if (!pImage)
6583 {
6584 rc = VERR_NO_MEMORY;
6585 break;
6586 }
6587 pImage->pszFilename = RTStrDup(pszFilename);
6588 if (!pImage->pszFilename)
6589 {
6590 rc = VERR_NO_MEMORY;
6591 break;
6592 }
6593
6594 rc = vdFindImageBackend(pszBackend, &pImage->Backend);
6595 if (RT_FAILURE(rc))
6596 break;
6597 if (!pImage->Backend)
6598 {
6599 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6600 N_("VD: unknown backend name '%s'"), pszBackend);
6601 break;
6602 }
6603 if ( !(pImage->Backend->uBackendCaps & VD_CAP_DIFF)
6604 || !(pImage->Backend->uBackendCaps & ( VD_CAP_CREATE_FIXED
6605 | VD_CAP_CREATE_DYNAMIC)))
6606 {
6607 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6608 N_("VD: backend '%s' cannot create diff images"), pszBackend);
6609 break;
6610 }
6611
6612 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
6613 pImage->VDIo.pDisk = pDisk;
6614 pImage->pVDIfsImage = pVDIfsImage;
6615
6616 /* Set up the I/O interface. */
6617 pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
6618 if (!pImage->VDIo.pInterfaceIo)
6619 {
6620 vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
6621 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
6622 pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
6623 pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
6624 }
6625
6626 /* Set up the internal I/O interface. */
6627 AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
6628 vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
6629 rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6630 &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
6631 AssertRC(rc);
6632
6633 /* Create UUID if the caller didn't specify one. */
6634 if (!pUuid)
6635 {
6636 rc = RTUuidCreate(&uuid);
6637 if (RT_FAILURE(rc))
6638 {
6639 rc = vdError(pDisk, rc, RT_SRC_POS,
6640 N_("VD: cannot generate UUID for image '%s'"),
6641 pszFilename);
6642 break;
6643 }
6644 pUuid = &uuid;
6645 }
6646
6647 pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
6648 pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
6649 uImageFlags |= VD_IMAGE_FLAGS_DIFF;
6650 rc = pImage->Backend->pfnCreate(pImage->pszFilename, pDisk->cbSize,
6651 uImageFlags | VD_IMAGE_FLAGS_DIFF,
6652 pszComment, &pDisk->PCHSGeometry,
6653 &pDisk->LCHSGeometry, pUuid,
6654 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
6655 0, 99,
6656 pDisk->pVDIfsDisk,
6657 pImage->pVDIfsImage,
6658 pVDIfsOperation,
6659 pDisk->enmType,
6660 &pImage->pBackendData);
6661
6662 if (RT_SUCCESS(rc))
6663 {
6664 pImage->VDIo.pBackendData = pImage->pBackendData;
6665 pImage->uImageFlags = uImageFlags;
6666
6667 /* Lock disk for writing, as we modify pDisk information below. */
6668 rc2 = vdThreadStartWrite(pDisk);
6669 AssertRC(rc2);
6670 fLockWrite = true;
6671
6672 /* Switch previous image to read-only mode. */
6673 unsigned uOpenFlagsPrevImg;
6674 uOpenFlagsPrevImg = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
6675 if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
6676 {
6677 uOpenFlagsPrevImg |= VD_OPEN_FLAGS_READONLY;
6678 rc = pDisk->pLast->Backend->pfnSetOpenFlags(pDisk->pLast->pBackendData, uOpenFlagsPrevImg);
6679 }
6680
6681 /** @todo optionally check UUIDs */
6682
6683 /* Re-check state, as the lock wasn't held and another image
6684 * creation call could have been done by another thread. */
6685 AssertMsgStmt(pDisk->cImages != 0,
6686 ("Create diff image cannot be done without other images open\n"),
6687 rc = VERR_VD_INVALID_STATE);
6688 }
6689
6690 if (RT_SUCCESS(rc))
6691 {
6692 RTUUID Uuid;
6693 RTTIMESPEC ts;
6694
6695 if (pParentUuid && !RTUuidIsNull(pParentUuid))
6696 {
6697 Uuid = *pParentUuid;
6698 pImage->Backend->pfnSetParentUuid(pImage->pBackendData, &Uuid);
6699 }
6700 else
6701 {
6702 rc2 = pDisk->pLast->Backend->pfnGetUuid(pDisk->pLast->pBackendData,
6703 &Uuid);
6704 if (RT_SUCCESS(rc2))
6705 pImage->Backend->pfnSetParentUuid(pImage->pBackendData, &Uuid);
6706 }
6707 rc2 = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
6708 &Uuid);
6709 if (RT_SUCCESS(rc2))
6710 pImage->Backend->pfnSetParentModificationUuid(pImage->pBackendData,
6711 &Uuid);
6712 if (pDisk->pLast->Backend->pfnGetTimestamp)
6713 rc2 = pDisk->pLast->Backend->pfnGetTimestamp(pDisk->pLast->pBackendData,
6714 &ts);
6715 else
6716 rc2 = VERR_NOT_IMPLEMENTED;
6717 if (RT_SUCCESS(rc2) && pImage->Backend->pfnSetParentTimestamp)
6718 pImage->Backend->pfnSetParentTimestamp(pImage->pBackendData, &ts);
6719
6720 if (pImage->Backend->pfnSetParentFilename)
6721 rc2 = pImage->Backend->pfnSetParentFilename(pImage->pBackendData, pDisk->pLast->pszFilename);
6722 }
6723
6724 if (RT_SUCCESS(rc))
6725 {
6726 /* Image successfully opened, make it the last image. */
6727 vdAddImageToList(pDisk, pImage);
6728 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
6729 pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
6730 }
6731 else
6732 {
6733 /* Error detected, but image opened. Close and delete image. */
6734 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, true);
6735 AssertRC(rc2);
6736 pImage->pBackendData = NULL;
6737 }
6738 } while (0);
6739
6740 if (RT_UNLIKELY(fLockWrite))
6741 {
6742 rc2 = vdThreadFinishWrite(pDisk);
6743 AssertRC(rc2);
6744 }
6745 else if (RT_UNLIKELY(fLockRead))
6746 {
6747 rc2 = vdThreadFinishRead(pDisk);
6748 AssertRC(rc2);
6749 }
6750
6751 if (RT_FAILURE(rc))
6752 {
6753 if (pImage)
6754 {
6755 if (pImage->pszFilename)
6756 RTStrFree(pImage->pszFilename);
6757 RTMemFree(pImage);
6758 }
6759 }
6760
6761 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
6762 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
6763
6764 LogFlowFunc(("returns %Rrc\n", rc));
6765 return rc;
6766}
6767
6768
6769/**
6770 * Creates and opens new cache image file in HDD container.
6771 *
6772 * @return VBox status code.
6773 * @param pDisk Name of the cache file backend to use (case insensitive).
6774 * @param pszFilename Name of the differencing cache file to create.
6775 * @param cbSize Maximum size of the cache.
6776 * @param uImageFlags Flags specifying special cache features.
6777 * @param pszComment Pointer to image comment. NULL is ok.
6778 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
6779 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
6780 * @param pVDIfsCache Pointer to the per-cache VD interface list.
6781 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6782 */
6783VBOXDDU_DECL(int) VDCreateCache(PVDISK pDisk, const char *pszBackend,
6784 const char *pszFilename, uint64_t cbSize,
6785 unsigned uImageFlags, const char *pszComment,
6786 PCRTUUID pUuid, unsigned uOpenFlags,
6787 PVDINTERFACE pVDIfsCache, PVDINTERFACE pVDIfsOperation)
6788{
6789 int rc = VINF_SUCCESS;
6790 int rc2;
6791 bool fLockWrite = false, fLockRead = false;
6792 PVDCACHE pCache = NULL;
6793 RTUUID uuid;
6794
6795 LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
6796 pDisk, pszBackend, pszFilename, cbSize, uImageFlags, pszComment, pUuid, uOpenFlags, pVDIfsCache, pVDIfsOperation));
6797
6798 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
6799
6800 do
6801 {
6802 /* sanity check */
6803 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
6804 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
6805
6806 /* Check arguments. */
6807 AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
6808 ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
6809 rc = VERR_INVALID_PARAMETER);
6810 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
6811 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
6812 rc = VERR_INVALID_PARAMETER);
6813 AssertMsgBreakStmt(cbSize,
6814 ("cbSize=%llu\n", cbSize),
6815 rc = VERR_INVALID_PARAMETER);
6816 AssertMsgBreakStmt((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0,
6817 ("uImageFlags=%#x\n", uImageFlags),
6818 rc = VERR_INVALID_PARAMETER);
6819 /* The UUID may be NULL. */
6820 AssertMsgBreakStmt(pUuid == NULL || VALID_PTR(pUuid),
6821 ("pUuid=%#p UUID=%RTuuid\n", pUuid, pUuid),
6822 rc = VERR_INVALID_PARAMETER);
6823 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
6824 ("uOpenFlags=%#x\n", uOpenFlags),
6825 rc = VERR_INVALID_PARAMETER);
6826
6827 /* Check state. Needs a temporary read lock. Holding the write lock
6828 * all the time would be blocking other activities for too long. */
6829 rc2 = vdThreadStartRead(pDisk);
6830 AssertRC(rc2);
6831 fLockRead = true;
6832 AssertMsgBreakStmt(!pDisk->pCache,
6833 ("Create cache image cannot be done with a cache already attached\n"),
6834 rc = VERR_VD_CACHE_ALREADY_EXISTS);
6835 rc2 = vdThreadFinishRead(pDisk);
6836 AssertRC(rc2);
6837 fLockRead = false;
6838
6839 /* Set up image descriptor. */
6840 pCache = (PVDCACHE)RTMemAllocZ(sizeof(VDCACHE));
6841 if (!pCache)
6842 {
6843 rc = VERR_NO_MEMORY;
6844 break;
6845 }
6846 pCache->pszFilename = RTStrDup(pszFilename);
6847 if (!pCache->pszFilename)
6848 {
6849 rc = VERR_NO_MEMORY;
6850 break;
6851 }
6852
6853 rc = vdFindCacheBackend(pszBackend, &pCache->Backend);
6854 if (RT_FAILURE(rc))
6855 break;
6856 if (!pCache->Backend)
6857 {
6858 rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
6859 N_("VD: unknown backend name '%s'"), pszBackend);
6860 break;
6861 }
6862
6863 pCache->VDIo.pDisk = pDisk;
6864 pCache->pVDIfsCache = pVDIfsCache;
6865
6866 /* Set up the I/O interface. */
6867 pCache->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsCache);
6868 if (!pCache->VDIo.pInterfaceIo)
6869 {
6870 vdIfIoFallbackCallbacksSetup(&pCache->VDIo.VDIfIo);
6871 rc = VDInterfaceAdd(&pCache->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
6872 pDisk, sizeof(VDINTERFACEIO), &pVDIfsCache);
6873 pCache->VDIo.pInterfaceIo = &pCache->VDIo.VDIfIo;
6874 }
6875
6876 /* Set up the internal I/O interface. */
6877 AssertBreakStmt(!VDIfIoIntGet(pVDIfsCache), rc = VERR_INVALID_PARAMETER);
6878 vdIfIoIntCallbacksSetup(&pCache->VDIo.VDIfIoInt);
6879 rc = VDInterfaceAdd(&pCache->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
6880 &pCache->VDIo, sizeof(VDINTERFACEIOINT), &pCache->pVDIfsCache);
6881 AssertRC(rc);
6882
6883 /* Create UUID if the caller didn't specify one. */
6884 if (!pUuid)
6885 {
6886 rc = RTUuidCreate(&uuid);
6887 if (RT_FAILURE(rc))
6888 {
6889 rc = vdError(pDisk, rc, RT_SRC_POS,
6890 N_("VD: cannot generate UUID for image '%s'"),
6891 pszFilename);
6892 break;
6893 }
6894 pUuid = &uuid;
6895 }
6896
6897 pCache->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
6898 pCache->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
6899 rc = pCache->Backend->pfnCreate(pCache->pszFilename, cbSize,
6900 uImageFlags,
6901 pszComment, pUuid,
6902 uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
6903 0, 99,
6904 pDisk->pVDIfsDisk,
6905 pCache->pVDIfsCache,
6906 pVDIfsOperation,
6907 &pCache->pBackendData);
6908
6909 if (RT_SUCCESS(rc))
6910 {
6911 /* Lock disk for writing, as we modify pDisk information below. */
6912 rc2 = vdThreadStartWrite(pDisk);
6913 AssertRC(rc2);
6914 fLockWrite = true;
6915
6916 pCache->VDIo.pBackendData = pCache->pBackendData;
6917
6918 /* Re-check state, as the lock wasn't held and another image
6919 * creation call could have been done by another thread. */
6920 AssertMsgStmt(!pDisk->pCache,
6921 ("Create cache image cannot be done with another cache open\n"),
6922 rc = VERR_VD_CACHE_ALREADY_EXISTS);
6923 }
6924
6925 if ( RT_SUCCESS(rc)
6926 && pDisk->pLast)
6927 {
6928 RTUUID UuidModification;
6929
6930 /* Set same modification Uuid as the last image. */
6931 rc = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
6932 &UuidModification);
6933 if (RT_SUCCESS(rc))
6934 {
6935 rc = pCache->Backend->pfnSetModificationUuid(pCache->pBackendData,
6936 &UuidModification);
6937 }
6938
6939 if (rc == VERR_NOT_SUPPORTED)
6940 rc = VINF_SUCCESS;
6941 }
6942
6943 if (RT_SUCCESS(rc))
6944 {
6945 /* Cache successfully created. */
6946 pDisk->pCache = pCache;
6947 }
6948 else
6949 {
6950 /* Error detected, but image opened. Close and delete image. */
6951 rc2 = pCache->Backend->pfnClose(pCache->pBackendData, true);
6952 AssertRC(rc2);
6953 pCache->pBackendData = NULL;
6954 }
6955 } while (0);
6956
6957 if (RT_UNLIKELY(fLockWrite))
6958 {
6959 rc2 = vdThreadFinishWrite(pDisk);
6960 AssertRC(rc2);
6961 }
6962 else if (RT_UNLIKELY(fLockRead))
6963 {
6964 rc2 = vdThreadFinishRead(pDisk);
6965 AssertRC(rc2);
6966 }
6967
6968 if (RT_FAILURE(rc))
6969 {
6970 if (pCache)
6971 {
6972 if (pCache->pszFilename)
6973 RTStrFree(pCache->pszFilename);
6974 RTMemFree(pCache);
6975 }
6976 }
6977
6978 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
6979 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
6980
6981 LogFlowFunc(("returns %Rrc\n", rc));
6982 return rc;
6983}
6984
6985/**
6986 * Merges two images (not necessarily with direct parent/child relationship).
6987 * As a side effect the source image and potentially the other images which
6988 * are also merged to the destination are deleted from both the disk and the
6989 * images in the HDD container.
6990 *
6991 * @returns VBox status code.
6992 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
6993 * @param pDisk Pointer to HDD container.
6994 * @param nImageFrom Name of the image file to merge from.
6995 * @param nImageTo Name of the image file to merge to.
6996 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
6997 */
6998VBOXDDU_DECL(int) VDMerge(PVDISK pDisk, unsigned nImageFrom,
6999 unsigned nImageTo, PVDINTERFACE pVDIfsOperation)
7000{
7001 int rc = VINF_SUCCESS;
7002 int rc2;
7003 bool fLockWrite = false, fLockRead = false;
7004 void *pvBuf = NULL;
7005
7006 LogFlowFunc(("pDisk=%#p nImageFrom=%u nImageTo=%u pVDIfsOperation=%#p\n",
7007 pDisk, nImageFrom, nImageTo, pVDIfsOperation));
7008
7009 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7010
7011 do
7012 {
7013 /* sanity check */
7014 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
7015 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
7016
7017 /* For simplicity reasons lock for writing as the image reopen below
7018 * might need it. After all the reopen is usually needed. */
7019 rc2 = vdThreadStartWrite(pDisk);
7020 AssertRC(rc2);
7021 fLockWrite = true;
7022 PVDIMAGE pImageFrom = vdGetImageByNumber(pDisk, nImageFrom);
7023 PVDIMAGE pImageTo = vdGetImageByNumber(pDisk, nImageTo);
7024 if (!pImageFrom || !pImageTo)
7025 {
7026 rc = VERR_VD_IMAGE_NOT_FOUND;
7027 break;
7028 }
7029 AssertBreakStmt(pImageFrom != pImageTo, rc = VERR_INVALID_PARAMETER);
7030
7031 /* Make sure destination image is writable. */
7032 unsigned uOpenFlags = pImageTo->Backend->pfnGetOpenFlags(pImageTo->pBackendData);
7033 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
7034 {
7035 /*
7036 * Clear skip consistency checks because the image is made writable now and
7037 * skipping consistency checks is only possible for readonly images.
7038 */
7039 uOpenFlags &= ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS);
7040 rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
7041 uOpenFlags);
7042 if (RT_FAILURE(rc))
7043 break;
7044 }
7045
7046 /* Get size of destination image. */
7047 uint64_t cbSize = vdImageGetSize(pImageTo);
7048 rc2 = vdThreadFinishWrite(pDisk);
7049 AssertRC(rc2);
7050 fLockWrite = false;
7051
7052 /* Allocate tmp buffer. */
7053 pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
7054 if (!pvBuf)
7055 {
7056 rc = VERR_NO_MEMORY;
7057 break;
7058 }
7059
7060 /* Merging is done directly on the images itself. This potentially
7061 * causes trouble if the disk is full in the middle of operation. */
7062 if (nImageFrom < nImageTo)
7063 {
7064 /* Merge parent state into child. This means writing all not
7065 * allocated blocks in the destination image which are allocated in
7066 * the images to be merged. */
7067 uint64_t uOffset = 0;
7068 uint64_t cbRemaining = cbSize;
7069
7070 do
7071 {
7072 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
7073 RTSGSEG SegmentBuf;
7074 RTSGBUF SgBuf;
7075 VDIOCTX IoCtx;
7076
7077 SegmentBuf.pvSeg = pvBuf;
7078 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
7079 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
7080 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
7081 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
7082
7083 /* Need to hold the write lock during a read-write operation. */
7084 rc2 = vdThreadStartWrite(pDisk);
7085 AssertRC(rc2);
7086 fLockWrite = true;
7087
7088 rc = pImageTo->Backend->pfnRead(pImageTo->pBackendData,
7089 uOffset, cbThisRead,
7090 &IoCtx, &cbThisRead);
7091 if (rc == VERR_VD_BLOCK_FREE)
7092 {
7093 /* Search for image with allocated block. Do not attempt to
7094 * read more than the previous reads marked as valid.
7095 * Otherwise this would return stale data when different
7096 * block sizes are used for the images. */
7097 for (PVDIMAGE pCurrImage = pImageTo->pPrev;
7098 pCurrImage != NULL && pCurrImage != pImageFrom->pPrev && rc == VERR_VD_BLOCK_FREE;
7099 pCurrImage = pCurrImage->pPrev)
7100 {
7101 /*
7102 * Skip reading when offset exceeds image size which can happen when the target is
7103 * bigger than the source.
7104 */
7105 uint64_t cbImage = vdImageGetSize(pCurrImage);
7106 if (uOffset < cbImage)
7107 {
7108 cbThisRead = RT_MIN(cbThisRead, cbImage - uOffset);
7109 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
7110 uOffset, cbThisRead,
7111 &IoCtx, &cbThisRead);
7112 }
7113 else
7114 rc = VERR_VD_BLOCK_FREE;
7115 }
7116
7117 if (rc != VERR_VD_BLOCK_FREE)
7118 {
7119 if (RT_FAILURE(rc))
7120 break;
7121 /* Updating the cache is required because this might be a live merge. */
7122 rc = vdWriteHelperEx(pDisk, pImageTo, pImageFrom->pPrev,
7123 uOffset, pvBuf, cbThisRead,
7124 VDIOCTX_FLAGS_READ_UPDATE_CACHE, 0);
7125 if (RT_FAILURE(rc))
7126 break;
7127 }
7128 else
7129 rc = VINF_SUCCESS;
7130 }
7131 else if (RT_FAILURE(rc))
7132 break;
7133
7134 rc2 = vdThreadFinishWrite(pDisk);
7135 AssertRC(rc2);
7136 fLockWrite = false;
7137
7138 uOffset += cbThisRead;
7139 cbRemaining -= cbThisRead;
7140
7141 if (pIfProgress && pIfProgress->pfnProgress)
7142 {
7143 /** @todo r=klaus: this can update the progress to the same
7144 * percentage over and over again if the image format makes
7145 * relatively small increments. */
7146 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
7147 uOffset * 99 / cbSize);
7148 if (RT_FAILURE(rc))
7149 break;
7150 }
7151 } while (uOffset < cbSize);
7152 }
7153 else
7154 {
7155 /*
7156 * We may need to update the parent uuid of the child coming after
7157 * the last image to be merged. We have to reopen it read/write.
7158 *
7159 * This is done before we do the actual merge to prevent an
7160 * inconsistent chain if the mode change fails for some reason.
7161 */
7162 if (pImageFrom->pNext)
7163 {
7164 PVDIMAGE pImageChild = pImageFrom->pNext;
7165
7166 /* Take the write lock. */
7167 rc2 = vdThreadStartWrite(pDisk);
7168 AssertRC(rc2);
7169 fLockWrite = true;
7170
7171 /* We need to open the image in read/write mode. */
7172 uOpenFlags = pImageChild->Backend->pfnGetOpenFlags(pImageChild->pBackendData);
7173
7174 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
7175 {
7176 uOpenFlags &= ~VD_OPEN_FLAGS_READONLY;
7177 rc = pImageChild->Backend->pfnSetOpenFlags(pImageChild->pBackendData,
7178 uOpenFlags);
7179 if (RT_FAILURE(rc))
7180 break;
7181 }
7182
7183 rc2 = vdThreadFinishWrite(pDisk);
7184 AssertRC(rc2);
7185 fLockWrite = false;
7186 }
7187
7188 /* If the merge is from the last image we have to relay all writes
7189 * to the merge destination as well, so that concurrent writes
7190 * (in case of a live merge) are handled correctly. */
7191 if (!pImageFrom->pNext)
7192 {
7193 /* Take the write lock. */
7194 rc2 = vdThreadStartWrite(pDisk);
7195 AssertRC(rc2);
7196 fLockWrite = true;
7197
7198 pDisk->pImageRelay = pImageTo;
7199
7200 rc2 = vdThreadFinishWrite(pDisk);
7201 AssertRC(rc2);
7202 fLockWrite = false;
7203 }
7204
7205 /* Merge child state into parent. This means writing all blocks
7206 * which are allocated in the image up to the source image to the
7207 * destination image. */
7208 unsigned uProgressOld = 0;
7209 uint64_t uOffset = 0;
7210 uint64_t cbRemaining = cbSize;
7211 do
7212 {
7213 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
7214 RTSGSEG SegmentBuf;
7215 RTSGBUF SgBuf;
7216 VDIOCTX IoCtx;
7217
7218 rc = VERR_VD_BLOCK_FREE;
7219
7220 SegmentBuf.pvSeg = pvBuf;
7221 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
7222 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
7223 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
7224 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
7225
7226 /* Need to hold the write lock during a read-write operation. */
7227 rc2 = vdThreadStartWrite(pDisk);
7228 AssertRC(rc2);
7229 fLockWrite = true;
7230
7231 /* Search for image with allocated block. Do not attempt to
7232 * read more than the previous reads marked as valid. Otherwise
7233 * this would return stale data when different block sizes are
7234 * used for the images. */
7235 for (PVDIMAGE pCurrImage = pImageFrom;
7236 pCurrImage != NULL && pCurrImage != pImageTo && rc == VERR_VD_BLOCK_FREE;
7237 pCurrImage = pCurrImage->pPrev)
7238 {
7239 /*
7240 * Skip reading when offset exceeds image size which can happen when the target is
7241 * bigger than the source.
7242 */
7243 uint64_t cbImage = vdImageGetSize(pCurrImage);
7244 if (uOffset < cbImage)
7245 {
7246 cbThisRead = RT_MIN(cbThisRead, cbImage - uOffset);
7247 rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
7248 uOffset, cbThisRead,
7249 &IoCtx, &cbThisRead);
7250 }
7251 else
7252 rc = VERR_VD_BLOCK_FREE;
7253 }
7254
7255 if (rc != VERR_VD_BLOCK_FREE)
7256 {
7257 if (RT_FAILURE(rc))
7258 break;
7259 rc = vdWriteHelper(pDisk, pImageTo, uOffset, pvBuf,
7260 cbThisRead, VDIOCTX_FLAGS_READ_UPDATE_CACHE);
7261 if (RT_FAILURE(rc))
7262 break;
7263 }
7264 else
7265 rc = VINF_SUCCESS;
7266
7267 rc2 = vdThreadFinishWrite(pDisk);
7268 AssertRC(rc2);
7269 fLockWrite = false;
7270
7271 uOffset += cbThisRead;
7272 cbRemaining -= cbThisRead;
7273
7274 unsigned uProgressNew = uOffset * 99 / cbSize;
7275 if (uProgressNew != uProgressOld)
7276 {
7277 uProgressOld = uProgressNew;
7278
7279 if (pIfProgress && pIfProgress->pfnProgress)
7280 {
7281 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
7282 uProgressOld);
7283 if (RT_FAILURE(rc))
7284 break;
7285 }
7286 }
7287
7288 } while (uOffset < cbSize);
7289
7290 /* In case we set up a "write proxy" image above we must clear
7291 * this again now to prevent stray writes. Failure or not. */
7292 if (!pImageFrom->pNext)
7293 {
7294 /* Take the write lock. */
7295 rc2 = vdThreadStartWrite(pDisk);
7296 AssertRC(rc2);
7297 fLockWrite = true;
7298
7299 pDisk->pImageRelay = NULL;
7300
7301 rc2 = vdThreadFinishWrite(pDisk);
7302 AssertRC(rc2);
7303 fLockWrite = false;
7304 }
7305 }
7306
7307 /*
7308 * Leave in case of an error to avoid corrupted data in the image chain
7309 * (includes cancelling the operation by the user).
7310 */
7311 if (RT_FAILURE(rc))
7312 break;
7313
7314 /* Need to hold the write lock while finishing the merge. */
7315 rc2 = vdThreadStartWrite(pDisk);
7316 AssertRC(rc2);
7317 fLockWrite = true;
7318
7319 /* Update parent UUID so that image chain is consistent.
7320 * The two attempts work around the problem that some backends
7321 * (e.g. iSCSI) do not support UUIDs, so we exploit the fact that
7322 * so far there can only be one such image in the chain. */
7323 /** @todo needs a better long-term solution, passing the UUID
7324 * knowledge from the caller or some such */
7325 RTUUID Uuid;
7326 PVDIMAGE pImageChild = NULL;
7327 if (nImageFrom < nImageTo)
7328 {
7329 if (pImageFrom->pPrev)
7330 {
7331 /* plan A: ask the parent itself for its UUID */
7332 rc = pImageFrom->pPrev->Backend->pfnGetUuid(pImageFrom->pPrev->pBackendData,
7333 &Uuid);
7334 if (RT_FAILURE(rc))
7335 {
7336 /* plan B: ask the child of the parent for parent UUID */
7337 rc = pImageFrom->Backend->pfnGetParentUuid(pImageFrom->pBackendData,
7338 &Uuid);
7339 }
7340 AssertRC(rc);
7341 }
7342 else
7343 RTUuidClear(&Uuid);
7344 rc = pImageTo->Backend->pfnSetParentUuid(pImageTo->pBackendData,
7345 &Uuid);
7346 AssertRC(rc);
7347 }
7348 else
7349 {
7350 /* Update the parent uuid of the child of the last merged image. */
7351 if (pImageFrom->pNext)
7352 {
7353 /* plan A: ask the parent itself for its UUID */
7354 rc = pImageTo->Backend->pfnGetUuid(pImageTo->pBackendData,
7355 &Uuid);
7356 if (RT_FAILURE(rc))
7357 {
7358 /* plan B: ask the child of the parent for parent UUID */
7359 rc = pImageTo->pNext->Backend->pfnGetParentUuid(pImageTo->pNext->pBackendData,
7360 &Uuid);
7361 }
7362 AssertRC(rc);
7363
7364 rc = pImageFrom->Backend->pfnSetParentUuid(pImageFrom->pNext->pBackendData,
7365 &Uuid);
7366 AssertRC(rc);
7367
7368 pImageChild = pImageFrom->pNext;
7369 }
7370 }
7371
7372 /* Delete the no longer needed images. */
7373 PVDIMAGE pImg = pImageFrom, pTmp;
7374 while (pImg != pImageTo)
7375 {
7376 if (nImageFrom < nImageTo)
7377 pTmp = pImg->pNext;
7378 else
7379 pTmp = pImg->pPrev;
7380 vdRemoveImageFromList(pDisk, pImg);
7381 pImg->Backend->pfnClose(pImg->pBackendData, true);
7382 RTMemFree(pImg->pszFilename);
7383 RTMemFree(pImg);
7384 pImg = pTmp;
7385 }
7386
7387 /* Make sure destination image is back to read only if necessary. */
7388 if (pImageTo != pDisk->pLast)
7389 {
7390 uOpenFlags = pImageTo->Backend->pfnGetOpenFlags(pImageTo->pBackendData);
7391 uOpenFlags |= VD_OPEN_FLAGS_READONLY;
7392 rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
7393 uOpenFlags);
7394 if (RT_FAILURE(rc))
7395 break;
7396 }
7397
7398 /*
7399 * Make sure the child is readonly
7400 * for the child -> parent merge direction
7401 * if necessary.
7402 */
7403 if ( nImageFrom > nImageTo
7404 && pImageChild
7405 && pImageChild != pDisk->pLast)
7406 {
7407 uOpenFlags = pImageChild->Backend->pfnGetOpenFlags(pImageChild->pBackendData);
7408 uOpenFlags |= VD_OPEN_FLAGS_READONLY;
7409 rc = pImageChild->Backend->pfnSetOpenFlags(pImageChild->pBackendData,
7410 uOpenFlags);
7411 if (RT_FAILURE(rc))
7412 break;
7413 }
7414 } while (0);
7415
7416 if (RT_UNLIKELY(fLockWrite))
7417 {
7418 rc2 = vdThreadFinishWrite(pDisk);
7419 AssertRC(rc2);
7420 }
7421 else if (RT_UNLIKELY(fLockRead))
7422 {
7423 rc2 = vdThreadFinishRead(pDisk);
7424 AssertRC(rc2);
7425 }
7426
7427 if (pvBuf)
7428 RTMemTmpFree(pvBuf);
7429
7430 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
7431 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
7432
7433 LogFlowFunc(("returns %Rrc\n", rc));
7434 return rc;
7435}
7436
7437/**
7438 * Copies an image from one HDD container to another - extended version.
7439 * The copy is opened in the target HDD container.
7440 * It is possible to convert between different image formats, because the
7441 * backend for the destination may be different from the source.
7442 * If both the source and destination reference the same HDD container,
7443 * then the image is moved (by copying/deleting or renaming) to the new location.
7444 * The source container is unchanged if the move operation fails, otherwise
7445 * the image at the new location is opened in the same way as the old one was.
7446 *
7447 * @note The read/write accesses across disks are not synchronized, just the
7448 * accesses to each disk. Once there is a use case which requires a defined
7449 * read/write behavior in this situation this needs to be extended.
7450 *
7451 * @returns VBox status code.
7452 * @retval VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
7453 * @param pDiskFrom Pointer to source HDD container.
7454 * @param nImage Image number, counts from 0. 0 is always base image of container.
7455 * @param pDiskTo Pointer to destination HDD container.
7456 * @param pszBackend Name of the image file backend to use (may be NULL to use the same as the source, case insensitive).
7457 * @param pszFilename New name of the image (may be NULL to specify that the
7458 * copy destination is the destination container, or
7459 * if pDiskFrom == pDiskTo, i.e. when moving).
7460 * @param fMoveByRename If true, attempt to perform a move by renaming (if successful the new size is ignored).
7461 * @param cbSize New image size (0 means leave unchanged).
7462 * @param nImageFromSame todo
7463 * @param nImageToSame todo
7464 * @param uImageFlags Flags specifying special destination image features.
7465 * @param pDstUuid New UUID of the destination image. If NULL, a new UUID is created.
7466 * This parameter is used if and only if a true copy is created.
7467 * In all rename/move cases or copy to existing image cases the modification UUIDs are copied over.
7468 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
7469 * Only used if the destination image is created.
7470 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7471 * @param pDstVDIfsImage Pointer to the per-image VD interface list, for the
7472 * destination image.
7473 * @param pDstVDIfsOperation Pointer to the per-operation VD interface list,
7474 * for the destination operation.
7475 */
7476VBOXDDU_DECL(int) VDCopyEx(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
7477 const char *pszBackend, const char *pszFilename,
7478 bool fMoveByRename, uint64_t cbSize,
7479 unsigned nImageFromSame, unsigned nImageToSame,
7480 unsigned uImageFlags, PCRTUUID pDstUuid,
7481 unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,
7482 PVDINTERFACE pDstVDIfsImage,
7483 PVDINTERFACE pDstVDIfsOperation)
7484{
7485 int rc = VINF_SUCCESS;
7486 int rc2;
7487 bool fLockReadFrom = false, fLockWriteFrom = false, fLockWriteTo = false;
7488 PVDIMAGE pImageTo = NULL;
7489
7490 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",
7491 pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename, cbSize, nImageFromSame, nImageToSame, uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation, pDstVDIfsImage, pDstVDIfsOperation));
7492
7493 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7494 PVDINTERFACEPROGRESS pDstIfProgress = VDIfProgressGet(pDstVDIfsOperation);
7495
7496 do {
7497 /* Check arguments. */
7498 AssertMsgBreakStmt(VALID_PTR(pDiskFrom), ("pDiskFrom=%#p\n", pDiskFrom),
7499 rc = VERR_INVALID_PARAMETER);
7500 AssertMsg(pDiskFrom->u32Signature == VDISK_SIGNATURE,
7501 ("u32Signature=%08x\n", pDiskFrom->u32Signature));
7502
7503 rc2 = vdThreadStartRead(pDiskFrom);
7504 AssertRC(rc2);
7505 fLockReadFrom = true;
7506 PVDIMAGE pImageFrom = vdGetImageByNumber(pDiskFrom, nImage);
7507 AssertPtrBreakStmt(pImageFrom, rc = VERR_VD_IMAGE_NOT_FOUND);
7508 AssertMsgBreakStmt(VALID_PTR(pDiskTo), ("pDiskTo=%#p\n", pDiskTo),
7509 rc = VERR_INVALID_PARAMETER);
7510 AssertMsg(pDiskTo->u32Signature == VDISK_SIGNATURE,
7511 ("u32Signature=%08x\n", pDiskTo->u32Signature));
7512 AssertMsgBreakStmt( (nImageFromSame < nImage || nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)
7513 && (nImageToSame < pDiskTo->cImages || nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
7514 && ( (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN && nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
7515 || (nImageFromSame != VD_IMAGE_CONTENT_UNKNOWN && nImageToSame != VD_IMAGE_CONTENT_UNKNOWN)),
7516 ("nImageFromSame=%u nImageToSame=%u\n", nImageFromSame, nImageToSame),
7517 rc = VERR_INVALID_PARAMETER);
7518
7519 /* Move the image. */
7520 if (pDiskFrom == pDiskTo)
7521 {
7522 /* Rename only works when backends are the same, are file based
7523 * and the rename method is implemented. */
7524 if ( fMoveByRename
7525 && !RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName)
7526 && pImageFrom->Backend->uBackendCaps & VD_CAP_FILE
7527 && pImageFrom->Backend->pfnRename)
7528 {
7529 rc2 = vdThreadFinishRead(pDiskFrom);
7530 AssertRC(rc2);
7531 fLockReadFrom = false;
7532
7533 rc2 = vdThreadStartWrite(pDiskFrom);
7534 AssertRC(rc2);
7535 fLockWriteFrom = true;
7536 rc = pImageFrom->Backend->pfnRename(pImageFrom->pBackendData, pszFilename ? pszFilename : pImageFrom->pszFilename);
7537 break;
7538 }
7539
7540 /** @todo Moving (including shrinking/growing) of the image is
7541 * requested, but the rename attempt failed or it wasn't possible.
7542 * Must now copy image to temp location. */
7543 AssertReleaseMsgFailed(("VDCopy: moving by copy/delete not implemented\n"));
7544 }
7545
7546 /* pszFilename is allowed to be NULL, as this indicates copy to the existing image. */
7547 AssertMsgBreakStmt(pszFilename == NULL || (VALID_PTR(pszFilename) && *pszFilename),
7548 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
7549 rc = VERR_INVALID_PARAMETER);
7550
7551 uint64_t cbSizeFrom;
7552 cbSizeFrom = vdImageGetSize(pImageFrom);
7553 if (cbSizeFrom == 0)
7554 {
7555 rc = VERR_VD_VALUE_NOT_FOUND;
7556 break;
7557 }
7558
7559 VDGEOMETRY PCHSGeometryFrom = {0, 0, 0};
7560 VDGEOMETRY LCHSGeometryFrom = {0, 0, 0};
7561 pImageFrom->Backend->pfnGetPCHSGeometry(pImageFrom->pBackendData, &PCHSGeometryFrom);
7562 pImageFrom->Backend->pfnGetLCHSGeometry(pImageFrom->pBackendData, &LCHSGeometryFrom);
7563
7564 RTUUID ImageUuid, ImageModificationUuid;
7565 if (pDiskFrom != pDiskTo)
7566 {
7567 if (pDstUuid)
7568 ImageUuid = *pDstUuid;
7569 else
7570 RTUuidCreate(&ImageUuid);
7571 }
7572 else
7573 {
7574 rc = pImageFrom->Backend->pfnGetUuid(pImageFrom->pBackendData, &ImageUuid);
7575 if (RT_FAILURE(rc))
7576 RTUuidCreate(&ImageUuid);
7577 }
7578 rc = pImageFrom->Backend->pfnGetModificationUuid(pImageFrom->pBackendData, &ImageModificationUuid);
7579 if (RT_FAILURE(rc))
7580 RTUuidClear(&ImageModificationUuid);
7581
7582 char szComment[1024];
7583 rc = pImageFrom->Backend->pfnGetComment(pImageFrom->pBackendData, szComment, sizeof(szComment));
7584 if (RT_FAILURE(rc))
7585 szComment[0] = '\0';
7586 else
7587 szComment[sizeof(szComment) - 1] = '\0';
7588
7589 rc2 = vdThreadFinishRead(pDiskFrom);
7590 AssertRC(rc2);
7591 fLockReadFrom = false;
7592
7593 rc2 = vdThreadStartRead(pDiskTo);
7594 AssertRC(rc2);
7595 unsigned cImagesTo = pDiskTo->cImages;
7596 rc2 = vdThreadFinishRead(pDiskTo);
7597 AssertRC(rc2);
7598
7599 if (pszFilename)
7600 {
7601 if (cbSize == 0)
7602 cbSize = cbSizeFrom;
7603
7604 /* Create destination image with the properties of source image. */
7605 /** @todo replace the VDCreateDiff/VDCreateBase calls by direct
7606 * calls to the backend. Unifies the code and reduces the API
7607 * dependencies. Would also make the synchronization explicit. */
7608 if (cImagesTo > 0)
7609 {
7610 rc = VDCreateDiff(pDiskTo, pszBackend, pszFilename,
7611 uImageFlags, szComment, &ImageUuid,
7612 NULL /* pParentUuid */,
7613 uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
7614 pDstVDIfsImage, NULL);
7615
7616 rc2 = vdThreadStartWrite(pDiskTo);
7617 AssertRC(rc2);
7618 fLockWriteTo = true;
7619 } else {
7620 /** @todo hack to force creation of a fixed image for
7621 * the RAW backend, which can't handle anything else. */
7622 if (!RTStrICmp(pszBackend, "RAW"))
7623 uImageFlags |= VD_IMAGE_FLAGS_FIXED;
7624
7625 vdFixupPCHSGeometry(&PCHSGeometryFrom, cbSize);
7626 vdFixupLCHSGeometry(&LCHSGeometryFrom, cbSize);
7627
7628 rc = VDCreateBase(pDiskTo, pszBackend, pszFilename, cbSize,
7629 uImageFlags, szComment,
7630 &PCHSGeometryFrom, &LCHSGeometryFrom,
7631 NULL, uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
7632 pDstVDIfsImage, NULL);
7633
7634 rc2 = vdThreadStartWrite(pDiskTo);
7635 AssertRC(rc2);
7636 fLockWriteTo = true;
7637
7638 if (RT_SUCCESS(rc) && !RTUuidIsNull(&ImageUuid))
7639 pDiskTo->pLast->Backend->pfnSetUuid(pDiskTo->pLast->pBackendData, &ImageUuid);
7640 }
7641 if (RT_FAILURE(rc))
7642 break;
7643
7644 pImageTo = pDiskTo->pLast;
7645 AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
7646
7647 cbSize = RT_MIN(cbSize, cbSizeFrom);
7648 }
7649 else
7650 {
7651 pImageTo = pDiskTo->pLast;
7652 AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
7653
7654 uint64_t cbSizeTo;
7655 cbSizeTo = vdImageGetSize(pImageTo);
7656 if (cbSizeTo == 0)
7657 {
7658 rc = VERR_VD_VALUE_NOT_FOUND;
7659 break;
7660 }
7661
7662 if (cbSize == 0)
7663 cbSize = RT_MIN(cbSizeFrom, cbSizeTo);
7664
7665 vdFixupPCHSGeometry(&PCHSGeometryFrom, cbSize);
7666 vdFixupLCHSGeometry(&LCHSGeometryFrom, cbSize);
7667
7668 /* Update the geometry in the destination image. */
7669 pImageTo->Backend->pfnSetPCHSGeometry(pImageTo->pBackendData, &PCHSGeometryFrom);
7670 pImageTo->Backend->pfnSetLCHSGeometry(pImageTo->pBackendData, &LCHSGeometryFrom);
7671 }
7672
7673 rc2 = vdThreadFinishWrite(pDiskTo);
7674 AssertRC(rc2);
7675 fLockWriteTo = false;
7676
7677 /* Whether we can take the optimized copy path (false) or not.
7678 * Don't optimize if the image existed or if it is a child image. */
7679 bool fSuppressRedundantIo = ( !(pszFilename == NULL || cImagesTo > 0)
7680 || (nImageToSame != VD_IMAGE_CONTENT_UNKNOWN));
7681 unsigned cImagesFromReadBack, cImagesToReadBack;
7682
7683 if (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)
7684 cImagesFromReadBack = 0;
7685 else
7686 {
7687 if (nImage == VD_LAST_IMAGE)
7688 cImagesFromReadBack = pDiskFrom->cImages - nImageFromSame - 1;
7689 else
7690 cImagesFromReadBack = nImage - nImageFromSame;
7691 }
7692
7693 if (nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
7694 cImagesToReadBack = 0;
7695 else
7696 cImagesToReadBack = pDiskTo->cImages - nImageToSame - 1;
7697
7698 /* Copy the data. */
7699 rc = vdCopyHelper(pDiskFrom, pImageFrom, pDiskTo, cbSize,
7700 cImagesFromReadBack, cImagesToReadBack,
7701 fSuppressRedundantIo, pIfProgress, pDstIfProgress);
7702
7703 if (RT_SUCCESS(rc))
7704 {
7705 rc2 = vdThreadStartWrite(pDiskTo);
7706 AssertRC(rc2);
7707 fLockWriteTo = true;
7708
7709 /* Only set modification UUID if it is non-null, since the source
7710 * backend might not provide a valid modification UUID. */
7711 if (!RTUuidIsNull(&ImageModificationUuid))
7712 pImageTo->Backend->pfnSetModificationUuid(pImageTo->pBackendData, &ImageModificationUuid);
7713
7714 /* Set the requested open flags if they differ from the value
7715 * required for creating the image and copying the contents. */
7716 if ( pImageTo && pszFilename
7717 && uOpenFlags != (uOpenFlags & ~VD_OPEN_FLAGS_READONLY))
7718 rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
7719 uOpenFlags);
7720 }
7721 } while (0);
7722
7723 if (RT_FAILURE(rc) && pImageTo && pszFilename)
7724 {
7725 /* Take the write lock only if it is not taken. Not worth making the
7726 * above code even more complicated. */
7727 if (RT_UNLIKELY(!fLockWriteTo))
7728 {
7729 rc2 = vdThreadStartWrite(pDiskTo);
7730 AssertRC(rc2);
7731 fLockWriteTo = true;
7732 }
7733 /* Error detected, but new image created. Remove image from list. */
7734 vdRemoveImageFromList(pDiskTo, pImageTo);
7735
7736 /* Close and delete image. */
7737 rc2 = pImageTo->Backend->pfnClose(pImageTo->pBackendData, true);
7738 AssertRC(rc2);
7739 pImageTo->pBackendData = NULL;
7740
7741 /* Free remaining resources. */
7742 if (pImageTo->pszFilename)
7743 RTStrFree(pImageTo->pszFilename);
7744
7745 RTMemFree(pImageTo);
7746 }
7747
7748 if (RT_UNLIKELY(fLockWriteTo))
7749 {
7750 rc2 = vdThreadFinishWrite(pDiskTo);
7751 AssertRC(rc2);
7752 }
7753 if (RT_UNLIKELY(fLockWriteFrom))
7754 {
7755 rc2 = vdThreadFinishWrite(pDiskFrom);
7756 AssertRC(rc2);
7757 }
7758 else if (RT_UNLIKELY(fLockReadFrom))
7759 {
7760 rc2 = vdThreadFinishRead(pDiskFrom);
7761 AssertRC(rc2);
7762 }
7763
7764 if (RT_SUCCESS(rc))
7765 {
7766 if (pIfProgress && pIfProgress->pfnProgress)
7767 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
7768 if (pDstIfProgress && pDstIfProgress->pfnProgress)
7769 pDstIfProgress->pfnProgress(pDstIfProgress->Core.pvUser, 100);
7770 }
7771
7772 LogFlowFunc(("returns %Rrc\n", rc));
7773 return rc;
7774}
7775
7776/**
7777 * Copies an image from one HDD container to another.
7778 * The copy is opened in the target HDD container.
7779 * It is possible to convert between different image formats, because the
7780 * backend for the destination may be different from the source.
7781 * If both the source and destination reference the same HDD container,
7782 * then the image is moved (by copying/deleting or renaming) to the new location.
7783 * The source container is unchanged if the move operation fails, otherwise
7784 * the image at the new location is opened in the same way as the old one was.
7785 *
7786 * @returns VBox status code.
7787 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
7788 * @param pDiskFrom Pointer to source HDD container.
7789 * @param nImage Image number, counts from 0. 0 is always base image of container.
7790 * @param pDiskTo Pointer to destination HDD container.
7791 * @param pszBackend Name of the image file backend to use.
7792 * @param pszFilename New name of the image (may be NULL if pDiskFrom == pDiskTo).
7793 * @param fMoveByRename If true, attempt to perform a move by renaming (if successful the new size is ignored).
7794 * @param cbSize New image size (0 means leave unchanged).
7795 * @param uImageFlags Flags specifying special destination image features.
7796 * @param pDstUuid New UUID of the destination image. If NULL, a new UUID is created.
7797 * This parameter is used if and only if a true copy is created.
7798 * In all rename/move cases the UUIDs are copied over.
7799 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
7800 * Only used if the destination image is created.
7801 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7802 * @param pDstVDIfsImage Pointer to the per-image VD interface list, for the
7803 * destination image.
7804 * @param pDstVDIfsOperation Pointer to the per-image VD interface list,
7805 * for the destination image.
7806 */
7807VBOXDDU_DECL(int) VDCopy(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
7808 const char *pszBackend, const char *pszFilename,
7809 bool fMoveByRename, uint64_t cbSize,
7810 unsigned uImageFlags, PCRTUUID pDstUuid,
7811 unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,
7812 PVDINTERFACE pDstVDIfsImage,
7813 PVDINTERFACE pDstVDIfsOperation)
7814{
7815 return VDCopyEx(pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename,
7816 cbSize, VD_IMAGE_CONTENT_UNKNOWN, VD_IMAGE_CONTENT_UNKNOWN,
7817 uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation,
7818 pDstVDIfsImage, pDstVDIfsOperation);
7819}
7820
7821/**
7822 * Optimizes the storage consumption of an image. Typically the unused blocks
7823 * have to be wiped with zeroes to achieve a substantial reduced storage use.
7824 * Another optimization done is reordering the image blocks, which can provide
7825 * a significant performance boost, as reads and writes tend to use less random
7826 * file offsets.
7827 *
7828 * @return VBox status code.
7829 * @return VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
7830 * @return VERR_VD_IMAGE_READ_ONLY if image is not writable.
7831 * @return VERR_NOT_SUPPORTED if this kind of image can be compacted, but
7832 * the code for this isn't implemented yet.
7833 * @param pDisk Pointer to HDD container.
7834 * @param nImage Image number, counts from 0. 0 is always base image of container.
7835 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7836 */
7837VBOXDDU_DECL(int) VDCompact(PVDISK pDisk, unsigned nImage,
7838 PVDINTERFACE pVDIfsOperation)
7839{
7840 int rc = VINF_SUCCESS;
7841 int rc2;
7842 bool fLockRead = false, fLockWrite = false;
7843 void *pvBuf = NULL;
7844 void *pvTmp = NULL;
7845
7846 LogFlowFunc(("pDisk=%#p nImage=%u pVDIfsOperation=%#p\n",
7847 pDisk, nImage, pVDIfsOperation));
7848
7849 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7850
7851 do {
7852 /* Check arguments. */
7853 AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
7854 rc = VERR_INVALID_PARAMETER);
7855 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
7856 ("u32Signature=%08x\n", pDisk->u32Signature));
7857
7858 rc2 = vdThreadStartRead(pDisk);
7859 AssertRC(rc2);
7860 fLockRead = true;
7861
7862 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
7863 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
7864
7865 /* If there is no compact callback for not file based backends then
7866 * the backend doesn't need compaction. No need to make much fuss about
7867 * this. For file based ones signal this as not yet supported. */
7868 if (!pImage->Backend->pfnCompact)
7869 {
7870 if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
7871 rc = VERR_NOT_SUPPORTED;
7872 else
7873 rc = VINF_SUCCESS;
7874 break;
7875 }
7876
7877 /* Insert interface for reading parent state into per-operation list,
7878 * if there is a parent image. */
7879 VDINTERFACEPARENTSTATE VDIfParent;
7880 VDPARENTSTATEDESC ParentUser;
7881 if (pImage->pPrev)
7882 {
7883 VDIfParent.pfnParentRead = vdParentRead;
7884 ParentUser.pDisk = pDisk;
7885 ParentUser.pImage = pImage->pPrev;
7886 rc = VDInterfaceAdd(&VDIfParent.Core, "VDCompact_ParentState", VDINTERFACETYPE_PARENTSTATE,
7887 &ParentUser, sizeof(VDINTERFACEPARENTSTATE), &pVDIfsOperation);
7888 AssertRC(rc);
7889 }
7890
7891 rc2 = vdThreadFinishRead(pDisk);
7892 AssertRC(rc2);
7893 fLockRead = false;
7894
7895 rc2 = vdThreadStartWrite(pDisk);
7896 AssertRC(rc2);
7897 fLockWrite = true;
7898
7899 rc = pImage->Backend->pfnCompact(pImage->pBackendData,
7900 0, 99,
7901 pDisk->pVDIfsDisk,
7902 pImage->pVDIfsImage,
7903 pVDIfsOperation);
7904 } while (0);
7905
7906 if (RT_UNLIKELY(fLockWrite))
7907 {
7908 rc2 = vdThreadFinishWrite(pDisk);
7909 AssertRC(rc2);
7910 }
7911 else if (RT_UNLIKELY(fLockRead))
7912 {
7913 rc2 = vdThreadFinishRead(pDisk);
7914 AssertRC(rc2);
7915 }
7916
7917 if (pvBuf)
7918 RTMemTmpFree(pvBuf);
7919 if (pvTmp)
7920 RTMemTmpFree(pvTmp);
7921
7922 if (RT_SUCCESS(rc))
7923 {
7924 if (pIfProgress && pIfProgress->pfnProgress)
7925 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
7926 }
7927
7928 LogFlowFunc(("returns %Rrc\n", rc));
7929 return rc;
7930}
7931
7932/**
7933 * Resizes the given disk image to the given size.
7934 *
7935 * @return VBox status
7936 * @return VERR_VD_IMAGE_READ_ONLY if image is not writable.
7937 * @return VERR_NOT_SUPPORTED if this kind of image can be compacted, but
7938 *
7939 * @param pDisk Pointer to the HDD container.
7940 * @param cbSize New size of the image.
7941 * @param pPCHSGeometry Pointer to the new physical disk geometry <= (16383,16,63). Not NULL.
7942 * @param pLCHSGeometry Pointer to the new logical disk geometry <= (x,255,63). Not NULL.
7943 * @param pVDIfsOperation Pointer to the per-operation VD interface list.
7944 */
7945VBOXDDU_DECL(int) VDResize(PVDISK pDisk, uint64_t cbSize,
7946 PCVDGEOMETRY pPCHSGeometry,
7947 PCVDGEOMETRY pLCHSGeometry,
7948 PVDINTERFACE pVDIfsOperation)
7949{
7950 /** @todo r=klaus resizing was designed to be part of VDCopy, so having a separate function is not desirable. */
7951 int rc = VINF_SUCCESS;
7952 int rc2;
7953 bool fLockRead = false, fLockWrite = false;
7954
7955 LogFlowFunc(("pDisk=%#p cbSize=%llu pVDIfsOperation=%#p\n",
7956 pDisk, cbSize, pVDIfsOperation));
7957
7958 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
7959
7960 do {
7961 /* Check arguments. */
7962 AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
7963 rc = VERR_INVALID_PARAMETER);
7964 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
7965 ("u32Signature=%08x\n", pDisk->u32Signature));
7966
7967 rc2 = vdThreadStartRead(pDisk);
7968 AssertRC(rc2);
7969 fLockRead = true;
7970
7971 /* Must have at least one image in the chain, will resize last. */
7972 AssertMsgBreakStmt(pDisk->cImages >= 1, ("cImages=%u\n", pDisk->cImages),
7973 rc = VERR_NOT_SUPPORTED);
7974
7975 PVDIMAGE pImage = pDisk->pLast;
7976
7977 /* If there is no compact callback for not file based backends then
7978 * the backend doesn't need compaction. No need to make much fuss about
7979 * this. For file based ones signal this as not yet supported. */
7980 if (!pImage->Backend->pfnResize)
7981 {
7982 if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
7983 rc = VERR_NOT_SUPPORTED;
7984 else
7985 rc = VINF_SUCCESS;
7986 break;
7987 }
7988
7989 rc2 = vdThreadFinishRead(pDisk);
7990 AssertRC(rc2);
7991 fLockRead = false;
7992
7993 rc2 = vdThreadStartWrite(pDisk);
7994 AssertRC(rc2);
7995 fLockWrite = true;
7996
7997 VDGEOMETRY PCHSGeometryOld;
7998 VDGEOMETRY LCHSGeometryOld;
7999 PCVDGEOMETRY pPCHSGeometryNew;
8000 PCVDGEOMETRY pLCHSGeometryNew;
8001
8002 if (pPCHSGeometry->cCylinders == 0)
8003 {
8004 /* Auto-detect marker, calculate new value ourself. */
8005 rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData, &PCHSGeometryOld);
8006 if (RT_SUCCESS(rc) && (PCHSGeometryOld.cCylinders != 0))
8007 PCHSGeometryOld.cCylinders = RT_MIN(cbSize / 512 / PCHSGeometryOld.cHeads / PCHSGeometryOld.cSectors, 16383);
8008 else if (rc == VERR_VD_GEOMETRY_NOT_SET)
8009 rc = VINF_SUCCESS;
8010
8011 pPCHSGeometryNew = &PCHSGeometryOld;
8012 }
8013 else
8014 pPCHSGeometryNew = pPCHSGeometry;
8015
8016 if (pLCHSGeometry->cCylinders == 0)
8017 {
8018 /* Auto-detect marker, calculate new value ourself. */
8019 rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData, &LCHSGeometryOld);
8020 if (RT_SUCCESS(rc) && (LCHSGeometryOld.cCylinders != 0))
8021 LCHSGeometryOld.cCylinders = cbSize / 512 / LCHSGeometryOld.cHeads / LCHSGeometryOld.cSectors;
8022 else if (rc == VERR_VD_GEOMETRY_NOT_SET)
8023 rc = VINF_SUCCESS;
8024
8025 pLCHSGeometryNew = &LCHSGeometryOld;
8026 }
8027 else
8028 pLCHSGeometryNew = pLCHSGeometry;
8029
8030 if (RT_SUCCESS(rc))
8031 rc = pImage->Backend->pfnResize(pImage->pBackendData,
8032 cbSize,
8033 pPCHSGeometryNew,
8034 pLCHSGeometryNew,
8035 0, 99,
8036 pDisk->pVDIfsDisk,
8037 pImage->pVDIfsImage,
8038 pVDIfsOperation);
8039 /* Mark the image size as uninitialized so it gets recalculated the next time. */
8040 if (RT_SUCCESS(rc))
8041 pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
8042 } while (0);
8043
8044 if (RT_UNLIKELY(fLockWrite))
8045 {
8046 rc2 = vdThreadFinishWrite(pDisk);
8047 AssertRC(rc2);
8048 }
8049 else if (RT_UNLIKELY(fLockRead))
8050 {
8051 rc2 = vdThreadFinishRead(pDisk);
8052 AssertRC(rc2);
8053 }
8054
8055 if (RT_SUCCESS(rc))
8056 {
8057 if (pIfProgress && pIfProgress->pfnProgress)
8058 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
8059
8060 pDisk->cbSize = cbSize;
8061 }
8062
8063 LogFlowFunc(("returns %Rrc\n", rc));
8064 return rc;
8065}
8066
8067VBOXDDU_DECL(int) VDPrepareWithFilters(PVDISK pDisk, PVDINTERFACE pVDIfsOperation)
8068{
8069 int rc = VINF_SUCCESS;
8070 int rc2;
8071 bool fLockRead = false, fLockWrite = false;
8072
8073 LogFlowFunc(("pDisk=%#p pVDIfsOperation=%#p\n", pDisk, pVDIfsOperation));
8074
8075 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
8076
8077 do {
8078 /* Check arguments. */
8079 AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
8080 rc = VERR_INVALID_PARAMETER);
8081 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
8082 ("u32Signature=%08x\n", pDisk->u32Signature));
8083
8084 rc2 = vdThreadStartRead(pDisk);
8085 AssertRC(rc2);
8086 fLockRead = true;
8087
8088 /* Must have at least one image in the chain. */
8089 AssertMsgBreakStmt(pDisk->cImages >= 1, ("cImages=%u\n", pDisk->cImages),
8090 rc = VERR_VD_NOT_OPENED);
8091
8092 unsigned uOpenFlags = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
8093 AssertMsgBreakStmt(!(uOpenFlags & VD_OPEN_FLAGS_READONLY),
8094 ("Last image should be read write"),
8095 rc = VERR_VD_IMAGE_READ_ONLY);
8096
8097 rc2 = vdThreadFinishRead(pDisk);
8098 AssertRC(rc2);
8099 fLockRead = false;
8100
8101 rc2 = vdThreadStartWrite(pDisk);
8102 AssertRC(rc2);
8103 fLockWrite = true;
8104
8105 /*
8106 * Open all images in the chain in read write mode first to avoid running
8107 * into an error in the middle of the process.
8108 */
8109 PVDIMAGE pImage = pDisk->pBase;
8110
8111 while (pImage)
8112 {
8113 uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8114 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
8115 {
8116 /*
8117 * Clear skip consistency checks because the image is made writable now and
8118 * skipping consistency checks is only possible for readonly images.
8119 */
8120 uOpenFlags &= ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS);
8121 rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
8122 if (RT_FAILURE(rc))
8123 break;
8124 }
8125 pImage = pImage->pNext;
8126 }
8127
8128 if (RT_SUCCESS(rc))
8129 {
8130 unsigned cImgCur = 0;
8131 unsigned uPercentStart = 0;
8132 unsigned uPercentSpan = 100 / pDisk->cImages - 1;
8133
8134 /* Allocate tmp buffer. */
8135 void *pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
8136 if (!pvBuf)
8137 {
8138 rc = VERR_NO_MEMORY;
8139 break;
8140 }
8141
8142 pImage = pDisk->pBase;
8143 pDisk->fLocked = true;
8144
8145 while ( pImage
8146 && RT_SUCCESS(rc))
8147 {
8148 /* Get size of image. */
8149 uint64_t cbSize = vdImageGetSize(pImage);
8150 uint64_t cbSizeFile = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
8151 uint64_t cbFileWritten = 0;
8152 uint64_t uOffset = 0;
8153 uint64_t cbRemaining = cbSize;
8154
8155 do
8156 {
8157 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
8158 RTSGSEG SegmentBuf;
8159 RTSGBUF SgBuf;
8160 VDIOCTX IoCtx;
8161
8162 SegmentBuf.pvSeg = pvBuf;
8163 SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
8164 RTSgBufInit(&SgBuf, &SegmentBuf, 1);
8165 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
8166 &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
8167
8168 rc = pImage->Backend->pfnRead(pImage->pBackendData, uOffset,
8169 cbThisRead, &IoCtx, &cbThisRead);
8170 if (rc != VERR_VD_BLOCK_FREE)
8171 {
8172 if (RT_FAILURE(rc))
8173 break;
8174
8175 /* Apply filter chains. */
8176 rc = vdFilterChainApplyRead(pDisk, uOffset, cbThisRead, &IoCtx);
8177 if (RT_FAILURE(rc))
8178 break;
8179
8180 rc = vdFilterChainApplyWrite(pDisk, uOffset, cbThisRead, &IoCtx);
8181 if (RT_FAILURE(rc))
8182 break;
8183
8184 RTSgBufReset(&SgBuf);
8185 size_t cbThisWrite = 0;
8186 size_t cbPreRead = 0;
8187 size_t cbPostRead = 0;
8188 rc = pImage->Backend->pfnWrite(pImage->pBackendData, uOffset,
8189 cbThisRead, &IoCtx, &cbThisWrite,
8190 &cbPreRead, &cbPostRead, 0);
8191 if (RT_FAILURE(rc))
8192 break;
8193 Assert(cbThisWrite == cbThisRead);
8194 cbFileWritten += cbThisWrite;
8195 }
8196 else
8197 rc = VINF_SUCCESS;
8198
8199 uOffset += cbThisRead;
8200 cbRemaining -= cbThisRead;
8201
8202 if (pIfProgress && pIfProgress->pfnProgress)
8203 {
8204 rc2 = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
8205 uPercentStart + cbFileWritten * uPercentSpan / cbSizeFile);
8206 AssertRC(rc2); /* Cancelling this operation without leaving an inconsistent state is not possible. */
8207 }
8208 } while (uOffset < cbSize);
8209
8210 pImage = pImage->pNext;
8211 cImgCur++;
8212 uPercentStart += uPercentSpan;
8213 }
8214
8215 pDisk->fLocked = false;
8216 if (pvBuf)
8217 RTMemTmpFree(pvBuf);
8218 }
8219
8220 /* Change images except last one back to readonly. */
8221 pImage = pDisk->pBase;
8222 while ( pImage != pDisk->pLast
8223 && pImage)
8224 {
8225 uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8226 uOpenFlags |= VD_OPEN_FLAGS_READONLY;
8227 rc2 = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
8228 if (RT_FAILURE(rc2))
8229 {
8230 if (RT_SUCCESS(rc))
8231 rc = rc2;
8232 break;
8233 }
8234 pImage = pImage->pNext;
8235 }
8236 } while (0);
8237
8238 if (RT_UNLIKELY(fLockWrite))
8239 {
8240 rc2 = vdThreadFinishWrite(pDisk);
8241 AssertRC(rc2);
8242 }
8243 else if (RT_UNLIKELY(fLockRead))
8244 {
8245 rc2 = vdThreadFinishRead(pDisk);
8246 AssertRC(rc2);
8247 }
8248
8249 if ( RT_SUCCESS(rc)
8250 && pIfProgress
8251 && pIfProgress->pfnProgress)
8252 pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
8253
8254 LogFlowFunc(("returns %Rrc\n", rc));
8255 return rc;
8256}
8257
8258/**
8259 * Closes the last opened image file in HDD container.
8260 * If previous image file was opened in read-only mode (the normal case) and
8261 * the last opened image is in read-write mode then the previous image will be
8262 * reopened in read/write mode.
8263 *
8264 * @returns VBox status code.
8265 * @returns VERR_VD_NOT_OPENED if no image is opened in HDD container.
8266 * @param pDisk Pointer to HDD container.
8267 * @param fDelete If true, delete the image from the host disk.
8268 */
8269VBOXDDU_DECL(int) VDClose(PVDISK pDisk, bool fDelete)
8270{
8271 int rc = VINF_SUCCESS;
8272 int rc2;
8273 bool fLockWrite = false;
8274
8275 LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
8276 do
8277 {
8278 /* sanity check */
8279 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8280 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8281
8282 /* Not worth splitting this up into a read lock phase and write
8283 * lock phase, as closing an image is a relatively fast operation
8284 * dominated by the part which needs the write lock. */
8285 rc2 = vdThreadStartWrite(pDisk);
8286 AssertRC(rc2);
8287 fLockWrite = true;
8288
8289 PVDIMAGE pImage = pDisk->pLast;
8290 if (!pImage)
8291 {
8292 rc = VERR_VD_NOT_OPENED;
8293 break;
8294 }
8295
8296 /* Destroy the current discard state first which might still have pending blocks. */
8297 rc = vdDiscardStateDestroy(pDisk);
8298 if (RT_FAILURE(rc))
8299 break;
8300
8301 unsigned uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8302 /* Remove image from list of opened images. */
8303 vdRemoveImageFromList(pDisk, pImage);
8304 /* Close (and optionally delete) image. */
8305 rc = pImage->Backend->pfnClose(pImage->pBackendData, fDelete);
8306 /* Free remaining resources related to the image. */
8307 RTStrFree(pImage->pszFilename);
8308 RTMemFree(pImage);
8309
8310 pImage = pDisk->pLast;
8311 if (!pImage)
8312 break;
8313
8314 /* If disk was previously in read/write mode, make sure it will stay
8315 * like this (if possible) after closing this image. Set the open flags
8316 * accordingly. */
8317 if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
8318 {
8319 uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
8320 uOpenFlags &= ~ VD_OPEN_FLAGS_READONLY;
8321 rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
8322 }
8323
8324 /* Cache disk information. */
8325 pDisk->cbSize = vdImageGetSize(pImage);
8326
8327 /* Cache PCHS geometry. */
8328 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
8329 &pDisk->PCHSGeometry);
8330 if (RT_FAILURE(rc2))
8331 {
8332 pDisk->PCHSGeometry.cCylinders = 0;
8333 pDisk->PCHSGeometry.cHeads = 0;
8334 pDisk->PCHSGeometry.cSectors = 0;
8335 }
8336 else
8337 {
8338 /* Make sure the PCHS geometry is properly clipped. */
8339 pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
8340 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
8341 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
8342 }
8343
8344 /* Cache LCHS geometry. */
8345 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
8346 &pDisk->LCHSGeometry);
8347 if (RT_FAILURE(rc2))
8348 {
8349 pDisk->LCHSGeometry.cCylinders = 0;
8350 pDisk->LCHSGeometry.cHeads = 0;
8351 pDisk->LCHSGeometry.cSectors = 0;
8352 }
8353 else
8354 {
8355 /* Make sure the LCHS geometry is properly clipped. */
8356 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
8357 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
8358 }
8359 } while (0);
8360
8361 if (RT_UNLIKELY(fLockWrite))
8362 {
8363 rc2 = vdThreadFinishWrite(pDisk);
8364 AssertRC(rc2);
8365 }
8366
8367 LogFlowFunc(("returns %Rrc\n", rc));
8368 return rc;
8369}
8370
8371/**
8372 * Closes the currently opened cache image file in HDD container.
8373 *
8374 * @return VBox status code.
8375 * @return VERR_VD_NOT_OPENED if no cache is opened in HDD container.
8376 * @param pDisk Pointer to HDD container.
8377 * @param fDelete If true, delete the image from the host disk.
8378 */
8379VBOXDDU_DECL(int) VDCacheClose(PVDISK pDisk, bool fDelete)
8380{
8381 int rc = VINF_SUCCESS;
8382 int rc2;
8383 bool fLockWrite = false;
8384 PVDCACHE pCache = NULL;
8385
8386 LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
8387
8388 do
8389 {
8390 /* sanity check */
8391 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8392 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8393
8394 rc2 = vdThreadStartWrite(pDisk);
8395 AssertRC(rc2);
8396 fLockWrite = true;
8397
8398 AssertPtrBreakStmt(pDisk->pCache, rc = VERR_VD_CACHE_NOT_FOUND);
8399
8400 pCache = pDisk->pCache;
8401 pDisk->pCache = NULL;
8402
8403 pCache->Backend->pfnClose(pCache->pBackendData, fDelete);
8404 if (pCache->pszFilename)
8405 RTStrFree(pCache->pszFilename);
8406 RTMemFree(pCache);
8407 } while (0);
8408
8409 if (RT_LIKELY(fLockWrite))
8410 {
8411 rc2 = vdThreadFinishWrite(pDisk);
8412 AssertRC(rc2);
8413 }
8414
8415 LogFlowFunc(("returns %Rrc\n", rc));
8416 return rc;
8417}
8418
8419VBOXDDU_DECL(int) VDFilterRemove(PVDISK pDisk, uint32_t fFlags)
8420{
8421 int rc = VINF_SUCCESS;
8422 int rc2;
8423 bool fLockWrite = false;
8424 PVDFILTER pFilter = NULL;
8425
8426 LogFlowFunc(("pDisk=%#p\n", pDisk));
8427
8428 do
8429 {
8430 /* sanity check */
8431 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8432 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8433
8434 AssertMsgBreakStmt(!(fFlags & ~VD_FILTER_FLAGS_MASK),
8435 ("Invalid flags set (fFlags=%#x)\n", fFlags),
8436 rc = VERR_INVALID_PARAMETER);
8437
8438 rc2 = vdThreadStartWrite(pDisk);
8439 AssertRC(rc2);
8440 fLockWrite = true;
8441
8442 if (fFlags & VD_FILTER_FLAGS_WRITE)
8443 {
8444 AssertBreakStmt(!RTListIsEmpty(&pDisk->ListFilterChainWrite), rc = VERR_VD_NOT_OPENED);
8445 pFilter = RTListGetLast(&pDisk->ListFilterChainWrite, VDFILTER, ListNodeChainWrite);
8446 AssertPtr(pFilter);
8447 RTListNodeRemove(&pFilter->ListNodeChainWrite);
8448 vdFilterRelease(pFilter);
8449 }
8450
8451 if (fFlags & VD_FILTER_FLAGS_READ)
8452 {
8453 AssertBreakStmt(!RTListIsEmpty(&pDisk->ListFilterChainRead), rc = VERR_VD_NOT_OPENED);
8454 pFilter = RTListGetLast(&pDisk->ListFilterChainRead, VDFILTER, ListNodeChainRead);
8455 AssertPtr(pFilter);
8456 RTListNodeRemove(&pFilter->ListNodeChainRead);
8457 vdFilterRelease(pFilter);
8458 }
8459 } while (0);
8460
8461 if (RT_LIKELY(fLockWrite))
8462 {
8463 rc2 = vdThreadFinishWrite(pDisk);
8464 AssertRC(rc2);
8465 }
8466
8467 LogFlowFunc(("returns %Rrc\n", rc));
8468 return rc;
8469}
8470
8471/**
8472 * Closes all opened image files in HDD container.
8473 *
8474 * @returns VBox status code.
8475 * @param pDisk Pointer to HDD container.
8476 */
8477VBOXDDU_DECL(int) VDCloseAll(PVDISK pDisk)
8478{
8479 int rc = VINF_SUCCESS;
8480 int rc2;
8481 bool fLockWrite = false;
8482
8483 LogFlowFunc(("pDisk=%#p\n", pDisk));
8484 do
8485 {
8486 /* sanity check */
8487 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8488 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8489
8490 /* Lock the entire operation. */
8491 rc2 = vdThreadStartWrite(pDisk);
8492 AssertRC(rc2);
8493 fLockWrite = true;
8494
8495 PVDCACHE pCache = pDisk->pCache;
8496 if (pCache)
8497 {
8498 rc2 = pCache->Backend->pfnClose(pCache->pBackendData, false);
8499 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
8500 rc = rc2;
8501
8502 if (pCache->pszFilename)
8503 RTStrFree(pCache->pszFilename);
8504 RTMemFree(pCache);
8505 }
8506
8507 PVDIMAGE pImage = pDisk->pLast;
8508 while (VALID_PTR(pImage))
8509 {
8510 PVDIMAGE pPrev = pImage->pPrev;
8511 /* Remove image from list of opened images. */
8512 vdRemoveImageFromList(pDisk, pImage);
8513 /* Close image. */
8514 rc2 = pImage->Backend->pfnClose(pImage->pBackendData, false);
8515 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
8516 rc = rc2;
8517 /* Free remaining resources related to the image. */
8518 RTStrFree(pImage->pszFilename);
8519 RTMemFree(pImage);
8520 pImage = pPrev;
8521 }
8522 Assert(!VALID_PTR(pDisk->pLast));
8523 } while (0);
8524
8525 if (RT_UNLIKELY(fLockWrite))
8526 {
8527 rc2 = vdThreadFinishWrite(pDisk);
8528 AssertRC(rc2);
8529 }
8530
8531 LogFlowFunc(("returns %Rrc\n", rc));
8532 return rc;
8533}
8534
8535/**
8536 * Removes all filters of the given HDD container.
8537 *
8538 * @return VBox status code.
8539 * @param pDisk Pointer to HDD container.
8540 */
8541VBOXDDU_DECL(int) VDFilterRemoveAll(PVDISK pDisk)
8542{
8543 int rc = VINF_SUCCESS;
8544 int rc2;
8545 bool fLockWrite = false;
8546
8547 LogFlowFunc(("pDisk=%#p\n", pDisk));
8548 do
8549 {
8550 /* sanity check */
8551 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8552 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8553
8554 /* Lock the entire operation. */
8555 rc2 = vdThreadStartWrite(pDisk);
8556 AssertRC(rc2);
8557 fLockWrite = true;
8558
8559 PVDFILTER pFilter, pFilterNext;
8560 RTListForEachSafe(&pDisk->ListFilterChainWrite, pFilter, pFilterNext, VDFILTER, ListNodeChainWrite)
8561 {
8562 RTListNodeRemove(&pFilter->ListNodeChainWrite);
8563 vdFilterRelease(pFilter);
8564 }
8565
8566 RTListForEachSafe(&pDisk->ListFilterChainRead, pFilter, pFilterNext, VDFILTER, ListNodeChainRead)
8567 {
8568 RTListNodeRemove(&pFilter->ListNodeChainRead);
8569 vdFilterRelease(pFilter);
8570 }
8571 Assert(RTListIsEmpty(&pDisk->ListFilterChainRead));
8572 Assert(RTListIsEmpty(&pDisk->ListFilterChainWrite));
8573 } while (0);
8574
8575 if (RT_UNLIKELY(fLockWrite))
8576 {
8577 rc2 = vdThreadFinishWrite(pDisk);
8578 AssertRC(rc2);
8579 }
8580
8581 LogFlowFunc(("returns %Rrc\n", rc));
8582 return rc;
8583}
8584
8585/**
8586 * Read data from virtual HDD.
8587 *
8588 * @returns VBox status code.
8589 * @retval VERR_VD_NOT_OPENED if no image is opened in HDD container.
8590 * @param pDisk Pointer to HDD container.
8591 * @param uOffset Offset of first reading byte from start of disk.
8592 * @param pvBuf Pointer to buffer for reading data.
8593 * @param cbRead Number of bytes to read.
8594 */
8595VBOXDDU_DECL(int) VDRead(PVDISK pDisk, uint64_t uOffset, void *pvBuf,
8596 size_t cbRead)
8597{
8598 int rc = VINF_SUCCESS;
8599 int rc2;
8600 bool fLockRead = false;
8601
8602 LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbRead=%zu\n",
8603 pDisk, uOffset, pvBuf, cbRead));
8604 do
8605 {
8606 /* sanity check */
8607 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8608 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8609
8610 /* Check arguments. */
8611 AssertMsgBreakStmt(VALID_PTR(pvBuf),
8612 ("pvBuf=%#p\n", pvBuf),
8613 rc = VERR_INVALID_PARAMETER);
8614 AssertMsgBreakStmt(cbRead,
8615 ("cbRead=%zu\n", cbRead),
8616 rc = VERR_INVALID_PARAMETER);
8617
8618 rc2 = vdThreadStartRead(pDisk);
8619 AssertRC(rc2);
8620 fLockRead = true;
8621
8622 PVDIMAGE pImage = pDisk->pLast;
8623 AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
8624
8625 if (uOffset + cbRead > pDisk->cbSize)
8626 {
8627 /* Floppy images might be smaller than the standard expected by
8628 the floppy controller code. So, we won't fail here. */
8629 AssertMsgBreakStmt(pDisk->enmType == VDTYPE_FLOPPY,
8630 ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
8631 uOffset, cbRead, pDisk->cbSize),
8632 rc = VERR_EOF);
8633 memset(pvBuf, 0xf6, cbRead); /* f6h = format.com filler byte */
8634 if (uOffset >= pDisk->cbSize)
8635 break;
8636 cbRead = pDisk->cbSize - uOffset;
8637 }
8638
8639 rc = vdReadHelper(pDisk, pImage, uOffset, pvBuf, cbRead,
8640 true /* fUpdateCache */);
8641 } while (0);
8642
8643 if (RT_UNLIKELY(fLockRead))
8644 {
8645 rc2 = vdThreadFinishRead(pDisk);
8646 AssertRC(rc2);
8647 }
8648
8649 LogFlowFunc(("returns %Rrc\n", rc));
8650 return rc;
8651}
8652
8653/**
8654 * Write data to virtual HDD.
8655 *
8656 * @returns VBox status code.
8657 * @retval VERR_VD_NOT_OPENED if no image is opened in HDD container.
8658 * @param pDisk Pointer to HDD container.
8659 * @param uOffset Offset of the first byte being
8660 * written from start of disk.
8661 * @param pvBuf Pointer to buffer for writing data.
8662 * @param cbWrite Number of bytes to write.
8663 */
8664VBOXDDU_DECL(int) VDWrite(PVDISK pDisk, uint64_t uOffset, const void *pvBuf,
8665 size_t cbWrite)
8666{
8667 int rc = VINF_SUCCESS;
8668 int rc2;
8669 bool fLockWrite = false;
8670
8671 LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbWrite=%zu\n",
8672 pDisk, uOffset, pvBuf, cbWrite));
8673 do
8674 {
8675 /* sanity check */
8676 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8677 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8678
8679 /* Check arguments. */
8680 AssertMsgBreakStmt(VALID_PTR(pvBuf),
8681 ("pvBuf=%#p\n", pvBuf),
8682 rc = VERR_INVALID_PARAMETER);
8683 AssertMsgBreakStmt(cbWrite,
8684 ("cbWrite=%zu\n", cbWrite),
8685 rc = VERR_INVALID_PARAMETER);
8686
8687 rc2 = vdThreadStartWrite(pDisk);
8688 AssertRC(rc2);
8689 fLockWrite = true;
8690
8691 AssertMsgBreakStmt(uOffset + cbWrite <= pDisk->cbSize,
8692 ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
8693 uOffset, cbWrite, pDisk->cbSize),
8694 rc = VERR_INVALID_PARAMETER);
8695
8696 PVDIMAGE pImage = pDisk->pLast;
8697 AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
8698
8699 vdSetModifiedFlag(pDisk);
8700 rc = vdWriteHelper(pDisk, pImage, uOffset, pvBuf, cbWrite,
8701 VDIOCTX_FLAGS_READ_UPDATE_CACHE);
8702 if (RT_FAILURE(rc))
8703 break;
8704
8705 /* If there is a merge (in the direction towards a parent) running
8706 * concurrently then we have to also "relay" the write to this parent,
8707 * as the merge position might be already past the position where
8708 * this write is going. The "context" of the write can come from the
8709 * natural chain, since merging either already did or will take care
8710 * of the "other" content which is might be needed to fill the block
8711 * to a full allocation size. The cache doesn't need to be touched
8712 * as this write is covered by the previous one. */
8713 if (RT_UNLIKELY(pDisk->pImageRelay))
8714 rc = vdWriteHelper(pDisk, pDisk->pImageRelay, uOffset,
8715 pvBuf, cbWrite, VDIOCTX_FLAGS_DEFAULT);
8716 } while (0);
8717
8718 if (RT_UNLIKELY(fLockWrite))
8719 {
8720 rc2 = vdThreadFinishWrite(pDisk);
8721 AssertRC(rc2);
8722 }
8723
8724 LogFlowFunc(("returns %Rrc\n", rc));
8725 return rc;
8726}
8727
8728/**
8729 * Make sure the on disk representation of a virtual HDD is up to date.
8730 *
8731 * @returns VBox status code.
8732 * @retval VERR_VD_NOT_OPENED if no image is opened in HDD container.
8733 * @param pDisk Pointer to HDD container.
8734 */
8735VBOXDDU_DECL(int) VDFlush(PVDISK pDisk)
8736{
8737 int rc = VINF_SUCCESS;
8738 int rc2;
8739 bool fLockWrite = false;
8740
8741 LogFlowFunc(("pDisk=%#p\n", pDisk));
8742 do
8743 {
8744 /* sanity check */
8745 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
8746 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8747
8748 rc2 = vdThreadStartWrite(pDisk);
8749 AssertRC(rc2);
8750 fLockWrite = true;
8751
8752 PVDIMAGE pImage = pDisk->pLast;
8753 AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
8754
8755 VDIOCTX IoCtx;
8756 RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
8757
8758 rc = RTSemEventCreate(&hEventComplete);
8759 if (RT_FAILURE(rc))
8760 break;
8761
8762 vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, pImage, NULL,
8763 NULL, vdFlushHelperAsync, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE);
8764
8765 IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
8766 IoCtx.Type.Root.pvUser1 = pDisk;
8767 IoCtx.Type.Root.pvUser2 = hEventComplete;
8768 rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
8769
8770 RTSemEventDestroy(hEventComplete);
8771 } while (0);
8772
8773 if (RT_UNLIKELY(fLockWrite))
8774 {
8775 rc2 = vdThreadFinishWrite(pDisk);
8776 AssertRC(rc2);
8777 }
8778
8779 LogFlowFunc(("returns %Rrc\n", rc));
8780 return rc;
8781}
8782
8783/**
8784 * Get number of opened images in HDD container.
8785 *
8786 * @returns Number of opened images for HDD container. 0 if no images have been opened.
8787 * @param pDisk Pointer to HDD container.
8788 */
8789VBOXDDU_DECL(unsigned) VDGetCount(PVDISK pDisk)
8790{
8791 unsigned cImages;
8792 int rc2;
8793 bool fLockRead = false;
8794
8795 LogFlowFunc(("pDisk=%#p\n", pDisk));
8796 do
8797 {
8798 /* sanity check */
8799 AssertPtrBreakStmt(pDisk, cImages = 0);
8800 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8801
8802 rc2 = vdThreadStartRead(pDisk);
8803 AssertRC(rc2);
8804 fLockRead = true;
8805
8806 cImages = pDisk->cImages;
8807 } while (0);
8808
8809 if (RT_UNLIKELY(fLockRead))
8810 {
8811 rc2 = vdThreadFinishRead(pDisk);
8812 AssertRC(rc2);
8813 }
8814
8815 LogFlowFunc(("returns %u\n", cImages));
8816 return cImages;
8817}
8818
8819/**
8820 * Get read/write mode of HDD container.
8821 *
8822 * @returns Virtual disk ReadOnly status.
8823 * @returns true if no image is opened in HDD container.
8824 * @param pDisk Pointer to HDD container.
8825 */
8826VBOXDDU_DECL(bool) VDIsReadOnly(PVDISK pDisk)
8827{
8828 bool fReadOnly;
8829 int rc2;
8830 bool fLockRead = false;
8831
8832 LogFlowFunc(("pDisk=%#p\n", pDisk));
8833 do
8834 {
8835 /* sanity check */
8836 AssertPtrBreakStmt(pDisk, fReadOnly = false);
8837 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8838
8839 rc2 = vdThreadStartRead(pDisk);
8840 AssertRC(rc2);
8841 fLockRead = true;
8842
8843 PVDIMAGE pImage = pDisk->pLast;
8844 AssertPtrBreakStmt(pImage, fReadOnly = true);
8845
8846 unsigned uOpenFlags;
8847 uOpenFlags = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
8848 fReadOnly = !!(uOpenFlags & VD_OPEN_FLAGS_READONLY);
8849 } while (0);
8850
8851 if (RT_UNLIKELY(fLockRead))
8852 {
8853 rc2 = vdThreadFinishRead(pDisk);
8854 AssertRC(rc2);
8855 }
8856
8857 LogFlowFunc(("returns %d\n", fReadOnly));
8858 return fReadOnly;
8859}
8860
8861/**
8862 * Get sector size of an image in HDD container.
8863 *
8864 * @return Virtual disk sector size in bytes.
8865 * @return 0 if image with specified number was not opened.
8866 * @param pDisk Pointer to HDD container.
8867 * @param nImage Image number, counts from 0. 0 is always base image of container.
8868 */
8869VBOXDDU_DECL(uint32_t) VDGetSectorSize(PVDISK pDisk, unsigned nImage)
8870{
8871 uint64_t cbSector;
8872 int rc2;
8873 bool fLockRead = false;
8874
8875 LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
8876 do
8877 {
8878 /* sanity check */
8879 AssertPtrBreakStmt(pDisk, cbSector = 0);
8880 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8881
8882 rc2 = vdThreadStartRead(pDisk);
8883 AssertRC(rc2);
8884 fLockRead = true;
8885
8886 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
8887 AssertPtrBreakStmt(pImage, cbSector = 0);
8888
8889 PCVDREGIONLIST pRegionList = NULL;
8890 int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
8891 if (RT_SUCCESS(rc))
8892 {
8893 AssertBreakStmt(pRegionList->cRegions == 1, cbSector = 0);
8894 cbSector = pRegionList->aRegions[0].cbBlock;
8895
8896 AssertPtr(pImage->Backend->pfnRegionListRelease);
8897 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
8898 }
8899 else
8900 cbSector = 0;
8901 } while (0);
8902
8903 if (RT_UNLIKELY(fLockRead))
8904 {
8905 rc2 = vdThreadFinishRead(pDisk);
8906 AssertRC(rc2);
8907 }
8908
8909 LogFlowFunc(("returns %u\n", cbSector));
8910 return cbSector;
8911}
8912
8913/**
8914 * Get total capacity of an image in HDD container.
8915 *
8916 * @returns Virtual disk size in bytes.
8917 * @returns 0 if no image with specified number was not opened.
8918 * @param pDisk Pointer to HDD container.
8919 * @param nImage Image number, counts from 0. 0 is always base image of container.
8920 */
8921VBOXDDU_DECL(uint64_t) VDGetSize(PVDISK pDisk, unsigned nImage)
8922{
8923 uint64_t cbSize;
8924 int rc2;
8925 bool fLockRead = false;
8926
8927 LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
8928 do
8929 {
8930 /* sanity check */
8931 AssertPtrBreakStmt(pDisk, cbSize = 0);
8932 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8933
8934 rc2 = vdThreadStartRead(pDisk);
8935 AssertRC(rc2);
8936 fLockRead = true;
8937
8938 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
8939 AssertPtrBreakStmt(pImage, cbSize = 0);
8940
8941 cbSize = vdImageGetSize(pImage);
8942 } while (0);
8943
8944 if (RT_UNLIKELY(fLockRead))
8945 {
8946 rc2 = vdThreadFinishRead(pDisk);
8947 AssertRC(rc2);
8948 }
8949
8950 LogFlowFunc(("returns %llu\n", cbSize));
8951 return cbSize;
8952}
8953
8954/**
8955 * Get total file size of an image in HDD container.
8956 *
8957 * @returns Virtual disk size in bytes.
8958 * @returns 0 if no image is opened in HDD container.
8959 * @param pDisk Pointer to HDD container.
8960 * @param nImage Image number, counts from 0. 0 is always base image of container.
8961 */
8962VBOXDDU_DECL(uint64_t) VDGetFileSize(PVDISK pDisk, unsigned nImage)
8963{
8964 uint64_t cbSize;
8965 int rc2;
8966 bool fLockRead = false;
8967
8968 LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
8969 do
8970 {
8971 /* sanity check */
8972 AssertPtrBreakStmt(pDisk, cbSize = 0);
8973 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
8974
8975 rc2 = vdThreadStartRead(pDisk);
8976 AssertRC(rc2);
8977 fLockRead = true;
8978
8979 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
8980 AssertPtrBreakStmt(pImage, cbSize = 0);
8981 cbSize = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
8982 } while (0);
8983
8984 if (RT_UNLIKELY(fLockRead))
8985 {
8986 rc2 = vdThreadFinishRead(pDisk);
8987 AssertRC(rc2);
8988 }
8989
8990 LogFlowFunc(("returns %llu\n", cbSize));
8991 return cbSize;
8992}
8993
8994/**
8995 * Get virtual disk PCHS geometry stored in HDD container.
8996 *
8997 * @returns VBox status code.
8998 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
8999 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9000 * @param pDisk Pointer to HDD container.
9001 * @param nImage Image number, counts from 0. 0 is always base image of container.
9002 * @param pPCHSGeometry Where to store PCHS geometry. Not NULL.
9003 */
9004VBOXDDU_DECL(int) VDGetPCHSGeometry(PVDISK pDisk, unsigned nImage,
9005 PVDGEOMETRY pPCHSGeometry)
9006{
9007 int rc = VINF_SUCCESS;
9008 int rc2;
9009 bool fLockRead = false;
9010
9011 LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p\n",
9012 pDisk, nImage, pPCHSGeometry));
9013 do
9014 {
9015 /* sanity check */
9016 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9017 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9018
9019 /* Check arguments. */
9020 AssertMsgBreakStmt(VALID_PTR(pPCHSGeometry),
9021 ("pPCHSGeometry=%#p\n", pPCHSGeometry),
9022 rc = VERR_INVALID_PARAMETER);
9023
9024 rc2 = vdThreadStartRead(pDisk);
9025 AssertRC(rc2);
9026 fLockRead = true;
9027
9028 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9029 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9030
9031 if (pImage == pDisk->pLast)
9032 {
9033 /* Use cached information if possible. */
9034 if (pDisk->PCHSGeometry.cCylinders != 0)
9035 *pPCHSGeometry = pDisk->PCHSGeometry;
9036 else
9037 rc = VERR_VD_GEOMETRY_NOT_SET;
9038 }
9039 else
9040 rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
9041 pPCHSGeometry);
9042 } while (0);
9043
9044 if (RT_UNLIKELY(fLockRead))
9045 {
9046 rc2 = vdThreadFinishRead(pDisk);
9047 AssertRC(rc2);
9048 }
9049
9050 LogFlowFunc(("%Rrc (PCHS=%u/%u/%u)\n", rc,
9051 pDisk->PCHSGeometry.cCylinders, pDisk->PCHSGeometry.cHeads,
9052 pDisk->PCHSGeometry.cSectors));
9053 return rc;
9054}
9055
9056/**
9057 * Store virtual disk PCHS geometry in HDD container.
9058 *
9059 * Note that in case of unrecoverable error all images in HDD container will be closed.
9060 *
9061 * @returns VBox status code.
9062 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9063 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9064 * @param pDisk Pointer to HDD container.
9065 * @param nImage Image number, counts from 0. 0 is always base image of container.
9066 * @param pPCHSGeometry Where to load PCHS geometry from. Not NULL.
9067 */
9068VBOXDDU_DECL(int) VDSetPCHSGeometry(PVDISK pDisk, unsigned nImage,
9069 PCVDGEOMETRY pPCHSGeometry)
9070{
9071 int rc = VINF_SUCCESS;
9072 int rc2;
9073 bool fLockWrite = false;
9074
9075 LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
9076 pDisk, nImage, pPCHSGeometry, pPCHSGeometry->cCylinders,
9077 pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
9078 do
9079 {
9080 /* sanity check */
9081 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9082 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9083
9084 /* Check arguments. */
9085 AssertMsgBreakStmt( VALID_PTR(pPCHSGeometry)
9086 && pPCHSGeometry->cHeads <= 16
9087 && pPCHSGeometry->cSectors <= 63,
9088 ("pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pPCHSGeometry,
9089 pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads,
9090 pPCHSGeometry->cSectors),
9091 rc = VERR_INVALID_PARAMETER);
9092
9093 rc2 = vdThreadStartWrite(pDisk);
9094 AssertRC(rc2);
9095 fLockWrite = true;
9096
9097 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9098 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9099
9100 if (pImage == pDisk->pLast)
9101 {
9102 if ( pPCHSGeometry->cCylinders != pDisk->PCHSGeometry.cCylinders
9103 || pPCHSGeometry->cHeads != pDisk->PCHSGeometry.cHeads
9104 || pPCHSGeometry->cSectors != pDisk->PCHSGeometry.cSectors)
9105 {
9106 /* Only update geometry if it is changed. Avoids similar checks
9107 * in every backend. Most of the time the new geometry is set
9108 * to the previous values, so no need to go through the hassle
9109 * of updating an image which could be opened in read-only mode
9110 * right now. */
9111 rc = pImage->Backend->pfnSetPCHSGeometry(pImage->pBackendData,
9112 pPCHSGeometry);
9113
9114 /* Cache new geometry values in any case. */
9115 rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
9116 &pDisk->PCHSGeometry);
9117 if (RT_FAILURE(rc2))
9118 {
9119 pDisk->PCHSGeometry.cCylinders = 0;
9120 pDisk->PCHSGeometry.cHeads = 0;
9121 pDisk->PCHSGeometry.cSectors = 0;
9122 }
9123 else
9124 {
9125 /* Make sure the CHS geometry is properly clipped. */
9126 pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 255);
9127 pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
9128 }
9129 }
9130 }
9131 else
9132 {
9133 VDGEOMETRY PCHS;
9134 rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
9135 &PCHS);
9136 if ( RT_FAILURE(rc)
9137 || pPCHSGeometry->cCylinders != PCHS.cCylinders
9138 || pPCHSGeometry->cHeads != PCHS.cHeads
9139 || pPCHSGeometry->cSectors != PCHS.cSectors)
9140 {
9141 /* Only update geometry if it is changed. Avoids similar checks
9142 * in every backend. Most of the time the new geometry is set
9143 * to the previous values, so no need to go through the hassle
9144 * of updating an image which could be opened in read-only mode
9145 * right now. */
9146 rc = pImage->Backend->pfnSetPCHSGeometry(pImage->pBackendData,
9147 pPCHSGeometry);
9148 }
9149 }
9150 } while (0);
9151
9152 if (RT_UNLIKELY(fLockWrite))
9153 {
9154 rc2 = vdThreadFinishWrite(pDisk);
9155 AssertRC(rc2);
9156 }
9157
9158 LogFlowFunc(("returns %Rrc\n", rc));
9159 return rc;
9160}
9161
9162/**
9163 * Get virtual disk LCHS geometry stored in HDD container.
9164 *
9165 * @returns VBox status code.
9166 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9167 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9168 * @param pDisk Pointer to HDD container.
9169 * @param nImage Image number, counts from 0. 0 is always base image of container.
9170 * @param pLCHSGeometry Where to store LCHS geometry. Not NULL.
9171 */
9172VBOXDDU_DECL(int) VDGetLCHSGeometry(PVDISK pDisk, unsigned nImage,
9173 PVDGEOMETRY pLCHSGeometry)
9174{
9175 int rc = VINF_SUCCESS;
9176 int rc2;
9177 bool fLockRead = false;
9178
9179 LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p\n",
9180 pDisk, nImage, pLCHSGeometry));
9181 do
9182 {
9183 /* sanity check */
9184 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9185 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9186
9187 /* Check arguments. */
9188 AssertMsgBreakStmt(VALID_PTR(pLCHSGeometry),
9189 ("pLCHSGeometry=%#p\n", pLCHSGeometry),
9190 rc = VERR_INVALID_PARAMETER);
9191
9192 rc2 = vdThreadStartRead(pDisk);
9193 AssertRC(rc2);
9194 fLockRead = true;
9195
9196 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9197 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9198
9199 if (pImage == pDisk->pLast)
9200 {
9201 /* Use cached information if possible. */
9202 if (pDisk->LCHSGeometry.cCylinders != 0)
9203 *pLCHSGeometry = pDisk->LCHSGeometry;
9204 else
9205 rc = VERR_VD_GEOMETRY_NOT_SET;
9206 }
9207 else
9208 rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
9209 pLCHSGeometry);
9210 } while (0);
9211
9212 if (RT_UNLIKELY(fLockRead))
9213 {
9214 rc2 = vdThreadFinishRead(pDisk);
9215 AssertRC(rc2);
9216 }
9217
9218 LogFlowFunc((": %Rrc (LCHS=%u/%u/%u)\n", rc,
9219 pDisk->LCHSGeometry.cCylinders, pDisk->LCHSGeometry.cHeads,
9220 pDisk->LCHSGeometry.cSectors));
9221 return rc;
9222}
9223
9224/**
9225 * Store virtual disk LCHS geometry in HDD container.
9226 *
9227 * Note that in case of unrecoverable error all images in HDD container will be closed.
9228 *
9229 * @returns VBox status code.
9230 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9231 * @returns VERR_VD_GEOMETRY_NOT_SET if no geometry present in the HDD container.
9232 * @param pDisk Pointer to HDD container.
9233 * @param nImage Image number, counts from 0. 0 is always base image of container.
9234 * @param pLCHSGeometry Where to load LCHS geometry from. Not NULL.
9235 */
9236VBOXDDU_DECL(int) VDSetLCHSGeometry(PVDISK pDisk, unsigned nImage,
9237 PCVDGEOMETRY pLCHSGeometry)
9238{
9239 int rc = VINF_SUCCESS;
9240 int rc2;
9241 bool fLockWrite = false;
9242
9243 LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
9244 pDisk, nImage, pLCHSGeometry, pLCHSGeometry->cCylinders,
9245 pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
9246 do
9247 {
9248 /* sanity check */
9249 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9250 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9251
9252 /* Check arguments. */
9253 AssertMsgBreakStmt( VALID_PTR(pLCHSGeometry)
9254 && pLCHSGeometry->cHeads <= 255
9255 && pLCHSGeometry->cSectors <= 63,
9256 ("pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pLCHSGeometry,
9257 pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads,
9258 pLCHSGeometry->cSectors),
9259 rc = VERR_INVALID_PARAMETER);
9260
9261 rc2 = vdThreadStartWrite(pDisk);
9262 AssertRC(rc2);
9263 fLockWrite = true;
9264
9265 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9266 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9267
9268 if (pImage == pDisk->pLast)
9269 {
9270 if ( pLCHSGeometry->cCylinders != pDisk->LCHSGeometry.cCylinders
9271 || pLCHSGeometry->cHeads != pDisk->LCHSGeometry.cHeads
9272 || pLCHSGeometry->cSectors != pDisk->LCHSGeometry.cSectors)
9273 {
9274 /* Only update geometry if it is changed. Avoids similar checks
9275 * in every backend. Most of the time the new geometry is set
9276 * to the previous values, so no need to go through the hassle
9277 * of updating an image which could be opened in read-only mode
9278 * right now. */
9279 rc = pImage->Backend->pfnSetLCHSGeometry(pImage->pBackendData,
9280 pLCHSGeometry);
9281
9282 /* Cache new geometry values in any case. */
9283 rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
9284 &pDisk->LCHSGeometry);
9285 if (RT_FAILURE(rc2))
9286 {
9287 pDisk->LCHSGeometry.cCylinders = 0;
9288 pDisk->LCHSGeometry.cHeads = 0;
9289 pDisk->LCHSGeometry.cSectors = 0;
9290 }
9291 else
9292 {
9293 /* Make sure the CHS geometry is properly clipped. */
9294 pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
9295 pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
9296 }
9297 }
9298 }
9299 else
9300 {
9301 VDGEOMETRY LCHS;
9302 rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
9303 &LCHS);
9304 if ( RT_FAILURE(rc)
9305 || pLCHSGeometry->cCylinders != LCHS.cCylinders
9306 || pLCHSGeometry->cHeads != LCHS.cHeads
9307 || pLCHSGeometry->cSectors != LCHS.cSectors)
9308 {
9309 /* Only update geometry if it is changed. Avoids similar checks
9310 * in every backend. Most of the time the new geometry is set
9311 * to the previous values, so no need to go through the hassle
9312 * of updating an image which could be opened in read-only mode
9313 * right now. */
9314 rc = pImage->Backend->pfnSetLCHSGeometry(pImage->pBackendData,
9315 pLCHSGeometry);
9316 }
9317 }
9318 } while (0);
9319
9320 if (RT_UNLIKELY(fLockWrite))
9321 {
9322 rc2 = vdThreadFinishWrite(pDisk);
9323 AssertRC(rc2);
9324 }
9325
9326 LogFlowFunc(("returns %Rrc\n", rc));
9327 return rc;
9328}
9329
9330/**
9331 * Queries the available regions of an image in the given VD container.
9332 *
9333 * @return VBox status code.
9334 * @retval VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9335 * @retval VERR_NOT_SUPPORTED if the image backend doesn't support region lists.
9336 * @param pDisk Pointer to HDD container.
9337 * @param nImage Image number, counts from 0. 0 is always base image of container.
9338 * @param fFlags Combination of VD_REGION_LIST_F_* flags.
9339 * @param ppRegionList Where to store the pointer to the region list on success, must be freed
9340 * with VDRegionListFree().
9341 */
9342VBOXDDU_DECL(int) VDQueryRegions(PVDISK pDisk, unsigned nImage, uint32_t fFlags,
9343 PPVDREGIONLIST ppRegionList)
9344{
9345 int rc = VINF_SUCCESS;
9346 int rc2;
9347 bool fLockRead = false;
9348
9349 LogFlowFunc(("pDisk=%#p nImage=%u fFlags=%#x ppRegionList=%#p\n",
9350 pDisk, nImage, fFlags, ppRegionList));
9351 do
9352 {
9353 /* sanity check */
9354 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9355 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9356
9357 /* Check arguments. */
9358 AssertMsgBreakStmt(VALID_PTR(ppRegionList),
9359 ("ppRegionList=%#p\n", ppRegionList),
9360 rc = VERR_INVALID_PARAMETER);
9361
9362 rc2 = vdThreadStartRead(pDisk);
9363 AssertRC(rc2);
9364 fLockRead = true;
9365
9366 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9367 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9368
9369 PCVDREGIONLIST pRegionList = NULL;
9370 rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
9371 if (RT_SUCCESS(rc))
9372 {
9373 rc = vdRegionListConv(pRegionList, fFlags, ppRegionList);
9374
9375 AssertPtr(pImage->Backend->pfnRegionListRelease);
9376 pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
9377 }
9378 } while (0);
9379
9380 if (RT_UNLIKELY(fLockRead))
9381 {
9382 rc2 = vdThreadFinishRead(pDisk);
9383 AssertRC(rc2);
9384 }
9385
9386 LogFlowFunc((": %Rrc\n", rc));
9387 return rc;
9388}
9389
9390/**
9391 * Frees a region list previously queried with VDQueryRegions().
9392 *
9393 * @return nothing.
9394 * @param pRegionList The region list to free.
9395 */
9396VBOXDDU_DECL(void) VDRegionListFree(PVDREGIONLIST pRegionList)
9397{
9398 RTMemFree(pRegionList);
9399}
9400
9401/**
9402 * Get version of image in HDD container.
9403 *
9404 * @returns VBox status code.
9405 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9406 * @param pDisk Pointer to HDD container.
9407 * @param nImage Image number, counts from 0. 0 is always base image of container.
9408 * @param puVersion Where to store the image version.
9409 */
9410VBOXDDU_DECL(int) VDGetVersion(PVDISK pDisk, unsigned nImage,
9411 unsigned *puVersion)
9412{
9413 int rc = VINF_SUCCESS;
9414 int rc2;
9415 bool fLockRead = false;
9416
9417 LogFlowFunc(("pDisk=%#p nImage=%u puVersion=%#p\n",
9418 pDisk, nImage, puVersion));
9419 do
9420 {
9421 /* sanity check */
9422 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9423 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9424
9425 /* Check arguments. */
9426 AssertMsgBreakStmt(VALID_PTR(puVersion),
9427 ("puVersion=%#p\n", puVersion),
9428 rc = VERR_INVALID_PARAMETER);
9429
9430 rc2 = vdThreadStartRead(pDisk);
9431 AssertRC(rc2);
9432 fLockRead = true;
9433
9434 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9435 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9436
9437 *puVersion = pImage->Backend->pfnGetVersion(pImage->pBackendData);
9438 } while (0);
9439
9440 if (RT_UNLIKELY(fLockRead))
9441 {
9442 rc2 = vdThreadFinishRead(pDisk);
9443 AssertRC(rc2);
9444 }
9445
9446 LogFlowFunc(("returns %Rrc uVersion=%#x\n", rc, *puVersion));
9447 return rc;
9448}
9449
9450/**
9451 * List the capabilities of image backend in HDD container.
9452 *
9453 * @returns VBox status code.
9454 * @retval VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9455 * @param pDisk Pointer to the HDD container.
9456 * @param nImage Image number, counts from 0. 0 is always base image of container.
9457 * @param pBackendInfo Where to store the backend information.
9458 */
9459VBOXDDU_DECL(int) VDBackendInfoSingle(PVDISK pDisk, unsigned nImage,
9460 PVDBACKENDINFO pBackendInfo)
9461{
9462 int rc = VINF_SUCCESS;
9463 int rc2;
9464 bool fLockRead = false;
9465
9466 LogFlowFunc(("pDisk=%#p nImage=%u pBackendInfo=%#p\n",
9467 pDisk, nImage, pBackendInfo));
9468 do
9469 {
9470 /* sanity check */
9471 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9472 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9473
9474 /* Check arguments. */
9475 AssertMsgBreakStmt(VALID_PTR(pBackendInfo),
9476 ("pBackendInfo=%#p\n", pBackendInfo),
9477 rc = VERR_INVALID_PARAMETER);
9478
9479 rc2 = vdThreadStartRead(pDisk);
9480 AssertRC(rc2);
9481 fLockRead = true;
9482
9483 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9484 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9485
9486 pBackendInfo->pszBackend = pImage->Backend->pszBackendName;
9487 pBackendInfo->uBackendCaps = pImage->Backend->uBackendCaps;
9488 pBackendInfo->paFileExtensions = pImage->Backend->paFileExtensions;
9489 pBackendInfo->paConfigInfo = pImage->Backend->paConfigInfo;
9490 } while (0);
9491
9492 if (RT_UNLIKELY(fLockRead))
9493 {
9494 rc2 = vdThreadFinishRead(pDisk);
9495 AssertRC(rc2);
9496 }
9497
9498 LogFlowFunc(("returns %Rrc\n", rc));
9499 return rc;
9500}
9501
9502/**
9503 * Get flags of image in HDD container.
9504 *
9505 * @returns VBox status code.
9506 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9507 * @param pDisk Pointer to HDD container.
9508 * @param nImage Image number, counts from 0. 0 is always base image of container.
9509 * @param puImageFlags Where to store the image flags.
9510 */
9511VBOXDDU_DECL(int) VDGetImageFlags(PVDISK pDisk, unsigned nImage,
9512 unsigned *puImageFlags)
9513{
9514 int rc = VINF_SUCCESS;
9515 int rc2;
9516 bool fLockRead = false;
9517
9518 LogFlowFunc(("pDisk=%#p nImage=%u puImageFlags=%#p\n",
9519 pDisk, nImage, puImageFlags));
9520 do
9521 {
9522 /* sanity check */
9523 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9524 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9525
9526 /* Check arguments. */
9527 AssertMsgBreakStmt(VALID_PTR(puImageFlags),
9528 ("puImageFlags=%#p\n", puImageFlags),
9529 rc = VERR_INVALID_PARAMETER);
9530
9531 rc2 = vdThreadStartRead(pDisk);
9532 AssertRC(rc2);
9533 fLockRead = true;
9534
9535 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9536 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9537
9538 *puImageFlags = pImage->uImageFlags;
9539 } while (0);
9540
9541 if (RT_UNLIKELY(fLockRead))
9542 {
9543 rc2 = vdThreadFinishRead(pDisk);
9544 AssertRC(rc2);
9545 }
9546
9547 LogFlowFunc(("returns %Rrc uImageFlags=%#x\n", rc, *puImageFlags));
9548 return rc;
9549}
9550
9551/**
9552 * Get open flags of image in HDD container.
9553 *
9554 * @returns VBox status code.
9555 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9556 * @param pDisk Pointer to HDD container.
9557 * @param nImage Image number, counts from 0. 0 is always base image of container.
9558 * @param puOpenFlags Where to store the image open flags.
9559 */
9560VBOXDDU_DECL(int) VDGetOpenFlags(PVDISK pDisk, unsigned nImage,
9561 unsigned *puOpenFlags)
9562{
9563 int rc = VINF_SUCCESS;
9564 int rc2;
9565 bool fLockRead = false;
9566
9567 LogFlowFunc(("pDisk=%#p nImage=%u puOpenFlags=%#p\n",
9568 pDisk, nImage, puOpenFlags));
9569 do
9570 {
9571 /* sanity check */
9572 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9573 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9574
9575 /* Check arguments. */
9576 AssertMsgBreakStmt(VALID_PTR(puOpenFlags),
9577 ("puOpenFlags=%#p\n", puOpenFlags),
9578 rc = VERR_INVALID_PARAMETER);
9579
9580 rc2 = vdThreadStartRead(pDisk);
9581 AssertRC(rc2);
9582 fLockRead = true;
9583
9584 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9585 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9586
9587 *puOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
9588 } while (0);
9589
9590 if (RT_UNLIKELY(fLockRead))
9591 {
9592 rc2 = vdThreadFinishRead(pDisk);
9593 AssertRC(rc2);
9594 }
9595
9596 LogFlowFunc(("returns %Rrc uOpenFlags=%#x\n", rc, *puOpenFlags));
9597 return rc;
9598}
9599
9600/**
9601 * Set open flags of image in HDD container.
9602 * This operation may cause file locking changes and/or files being reopened.
9603 * Note that in case of unrecoverable error all images in HDD container will be closed.
9604 *
9605 * @returns VBox status code.
9606 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9607 * @param pDisk Pointer to HDD container.
9608 * @param nImage Image number, counts from 0. 0 is always base image of container.
9609 * @param uOpenFlags Image file open mode, see VD_OPEN_FLAGS_* constants.
9610 */
9611VBOXDDU_DECL(int) VDSetOpenFlags(PVDISK pDisk, unsigned nImage,
9612 unsigned uOpenFlags)
9613{
9614 int rc;
9615 int rc2;
9616 bool fLockWrite = false;
9617
9618 LogFlowFunc(("pDisk=%#p uOpenFlags=%#u\n", pDisk, uOpenFlags));
9619 do
9620 {
9621 /* sanity check */
9622 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9623 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9624
9625 /* Check arguments. */
9626 AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
9627 ("uOpenFlags=%#x\n", uOpenFlags),
9628 rc = VERR_INVALID_PARAMETER);
9629
9630 rc2 = vdThreadStartWrite(pDisk);
9631 AssertRC(rc2);
9632 fLockWrite = true;
9633
9634 /* Destroy any discard state because the image might be changed to readonly mode. */
9635 rc = vdDiscardStateDestroy(pDisk);
9636 if (RT_FAILURE(rc))
9637 break;
9638
9639 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9640 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9641
9642 rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData,
9643 uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS));
9644 if (RT_SUCCESS(rc))
9645 pImage->uOpenFlags = uOpenFlags & (VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_DISCARD | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS);
9646 } while (0);
9647
9648 if (RT_UNLIKELY(fLockWrite))
9649 {
9650 rc2 = vdThreadFinishWrite(pDisk);
9651 AssertRC(rc2);
9652 }
9653
9654 LogFlowFunc(("returns %Rrc\n", rc));
9655 return rc;
9656}
9657
9658/**
9659 * Get base filename of image in HDD container. Some image formats use
9660 * other filenames as well, so don't use this for anything but informational
9661 * purposes.
9662 *
9663 * @returns VBox status code.
9664 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9665 * @returns VERR_BUFFER_OVERFLOW if pszFilename buffer too small to hold filename.
9666 * @param pDisk Pointer to HDD container.
9667 * @param nImage Image number, counts from 0. 0 is always base image of container.
9668 * @param pszFilename Where to store the image file name.
9669 * @param cbFilename Size of buffer pszFilename points to.
9670 */
9671VBOXDDU_DECL(int) VDGetFilename(PVDISK pDisk, unsigned nImage,
9672 char *pszFilename, unsigned cbFilename)
9673{
9674 int rc;
9675 int rc2;
9676 bool fLockRead = false;
9677
9678 LogFlowFunc(("pDisk=%#p nImage=%u pszFilename=%#p cbFilename=%u\n",
9679 pDisk, nImage, pszFilename, cbFilename));
9680 do
9681 {
9682 /* sanity check */
9683 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9684 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9685
9686 /* Check arguments. */
9687 AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
9688 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
9689 rc = VERR_INVALID_PARAMETER);
9690 AssertMsgBreakStmt(cbFilename,
9691 ("cbFilename=%u\n", cbFilename),
9692 rc = VERR_INVALID_PARAMETER);
9693
9694 rc2 = vdThreadStartRead(pDisk);
9695 AssertRC(rc2);
9696 fLockRead = true;
9697
9698 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9699 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9700
9701 size_t cb = strlen(pImage->pszFilename);
9702 if (cb <= cbFilename)
9703 {
9704 strcpy(pszFilename, pImage->pszFilename);
9705 rc = VINF_SUCCESS;
9706 }
9707 else
9708 {
9709 strncpy(pszFilename, pImage->pszFilename, cbFilename - 1);
9710 pszFilename[cbFilename - 1] = '\0';
9711 rc = VERR_BUFFER_OVERFLOW;
9712 }
9713 } while (0);
9714
9715 if (RT_UNLIKELY(fLockRead))
9716 {
9717 rc2 = vdThreadFinishRead(pDisk);
9718 AssertRC(rc2);
9719 }
9720
9721 LogFlowFunc(("returns %Rrc, pszFilename=\"%s\"\n", rc, pszFilename));
9722 return rc;
9723}
9724
9725/**
9726 * Get the comment line of image in HDD container.
9727 *
9728 * @returns VBox status code.
9729 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9730 * @returns VERR_BUFFER_OVERFLOW if pszComment buffer too small to hold comment text.
9731 * @param pDisk Pointer to HDD container.
9732 * @param nImage Image number, counts from 0. 0 is always base image of container.
9733 * @param pszComment Where to store the comment string of image. NULL is ok.
9734 * @param cbComment The size of pszComment buffer. 0 is ok.
9735 */
9736VBOXDDU_DECL(int) VDGetComment(PVDISK pDisk, unsigned nImage,
9737 char *pszComment, unsigned cbComment)
9738{
9739 int rc;
9740 int rc2;
9741 bool fLockRead = false;
9742
9743 LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p cbComment=%u\n",
9744 pDisk, nImage, pszComment, cbComment));
9745 do
9746 {
9747 /* sanity check */
9748 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9749 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9750
9751 /* Check arguments. */
9752 AssertMsgBreakStmt(VALID_PTR(pszComment),
9753 ("pszComment=%#p \"%s\"\n", pszComment, pszComment),
9754 rc = VERR_INVALID_PARAMETER);
9755 AssertMsgBreakStmt(cbComment,
9756 ("cbComment=%u\n", cbComment),
9757 rc = VERR_INVALID_PARAMETER);
9758
9759 rc2 = vdThreadStartRead(pDisk);
9760 AssertRC(rc2);
9761 fLockRead = true;
9762
9763 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9764 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9765
9766 rc = pImage->Backend->pfnGetComment(pImage->pBackendData, pszComment,
9767 cbComment);
9768 } while (0);
9769
9770 if (RT_UNLIKELY(fLockRead))
9771 {
9772 rc2 = vdThreadFinishRead(pDisk);
9773 AssertRC(rc2);
9774 }
9775
9776 LogFlowFunc(("returns %Rrc, pszComment=\"%s\"\n", rc, pszComment));
9777 return rc;
9778}
9779
9780/**
9781 * Changes the comment line of image in HDD container.
9782 *
9783 * @returns VBox status code.
9784 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9785 * @param pDisk Pointer to HDD container.
9786 * @param nImage Image number, counts from 0. 0 is always base image of container.
9787 * @param pszComment New comment string (UTF-8). NULL is allowed to reset the comment.
9788 */
9789VBOXDDU_DECL(int) VDSetComment(PVDISK pDisk, unsigned nImage,
9790 const char *pszComment)
9791{
9792 int rc;
9793 int rc2;
9794 bool fLockWrite = false;
9795
9796 LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p \"%s\"\n",
9797 pDisk, nImage, pszComment, pszComment));
9798 do
9799 {
9800 /* sanity check */
9801 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9802 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9803
9804 /* Check arguments. */
9805 AssertMsgBreakStmt(VALID_PTR(pszComment) || pszComment == NULL,
9806 ("pszComment=%#p \"%s\"\n", pszComment, pszComment),
9807 rc = VERR_INVALID_PARAMETER);
9808
9809 rc2 = vdThreadStartWrite(pDisk);
9810 AssertRC(rc2);
9811 fLockWrite = true;
9812
9813 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9814 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9815
9816 rc = pImage->Backend->pfnSetComment(pImage->pBackendData, pszComment);
9817 } while (0);
9818
9819 if (RT_UNLIKELY(fLockWrite))
9820 {
9821 rc2 = vdThreadFinishWrite(pDisk);
9822 AssertRC(rc2);
9823 }
9824
9825 LogFlowFunc(("returns %Rrc\n", rc));
9826 return rc;
9827}
9828
9829
9830/**
9831 * Get UUID of image in HDD container.
9832 *
9833 * @returns VBox status code.
9834 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9835 * @param pDisk Pointer to HDD container.
9836 * @param nImage Image number, counts from 0. 0 is always base image of container.
9837 * @param pUuid Where to store the image creation UUID.
9838 */
9839VBOXDDU_DECL(int) VDGetUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
9840{
9841 int rc;
9842 int rc2;
9843 bool fLockRead = false;
9844
9845 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
9846 do
9847 {
9848 /* sanity check */
9849 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9850 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9851
9852 /* Check arguments. */
9853 AssertMsgBreakStmt(VALID_PTR(pUuid),
9854 ("pUuid=%#p\n", pUuid),
9855 rc = VERR_INVALID_PARAMETER);
9856
9857 rc2 = vdThreadStartRead(pDisk);
9858 AssertRC(rc2);
9859 fLockRead = true;
9860
9861 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9862 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9863
9864 rc = pImage->Backend->pfnGetUuid(pImage->pBackendData, pUuid);
9865 } while (0);
9866
9867 if (RT_UNLIKELY(fLockRead))
9868 {
9869 rc2 = vdThreadFinishRead(pDisk);
9870 AssertRC(rc2);
9871 }
9872
9873 LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
9874 return rc;
9875}
9876
9877/**
9878 * Set the image's UUID. Should not be used by normal applications.
9879 *
9880 * @returns VBox status code.
9881 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9882 * @param pDisk Pointer to HDD container.
9883 * @param nImage Image number, counts from 0. 0 is always base image of container.
9884 * @param pUuid New UUID of the image. If NULL, a new UUID is created.
9885 */
9886VBOXDDU_DECL(int) VDSetUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
9887{
9888 int rc;
9889 int rc2;
9890 bool fLockWrite = false;
9891
9892 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
9893 pDisk, nImage, pUuid, pUuid));
9894 do
9895 {
9896 /* sanity check */
9897 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9898 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9899
9900 AssertMsgBreakStmt(VALID_PTR(pUuid) || pUuid == NULL,
9901 ("pUuid=%#p\n", pUuid),
9902 rc = VERR_INVALID_PARAMETER);
9903
9904 rc2 = vdThreadStartWrite(pDisk);
9905 AssertRC(rc2);
9906 fLockWrite = true;
9907
9908 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9909 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9910
9911 RTUUID Uuid;
9912 if (!pUuid)
9913 {
9914 RTUuidCreate(&Uuid);
9915 pUuid = &Uuid;
9916 }
9917 rc = pImage->Backend->pfnSetUuid(pImage->pBackendData, pUuid);
9918 } while (0);
9919
9920 if (RT_UNLIKELY(fLockWrite))
9921 {
9922 rc2 = vdThreadFinishWrite(pDisk);
9923 AssertRC(rc2);
9924 }
9925
9926 LogFlowFunc(("returns %Rrc\n", rc));
9927 return rc;
9928}
9929
9930/**
9931 * Get last modification UUID of image in HDD container.
9932 *
9933 * @returns VBox status code.
9934 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9935 * @param pDisk Pointer to HDD container.
9936 * @param nImage Image number, counts from 0. 0 is always base image of container.
9937 * @param pUuid Where to store the image modification UUID.
9938 */
9939VBOXDDU_DECL(int) VDGetModificationUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
9940{
9941 int rc = VINF_SUCCESS;
9942 int rc2;
9943 bool fLockRead = false;
9944
9945 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
9946 do
9947 {
9948 /* sanity check */
9949 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9950 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
9951
9952 /* Check arguments. */
9953 AssertMsgBreakStmt(VALID_PTR(pUuid),
9954 ("pUuid=%#p\n", pUuid),
9955 rc = VERR_INVALID_PARAMETER);
9956
9957 rc2 = vdThreadStartRead(pDisk);
9958 AssertRC(rc2);
9959 fLockRead = true;
9960
9961 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
9962 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
9963
9964 rc = pImage->Backend->pfnGetModificationUuid(pImage->pBackendData,
9965 pUuid);
9966 } while (0);
9967
9968 if (RT_UNLIKELY(fLockRead))
9969 {
9970 rc2 = vdThreadFinishRead(pDisk);
9971 AssertRC(rc2);
9972 }
9973
9974 LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
9975 return rc;
9976}
9977
9978/**
9979 * Set the image's last modification UUID. Should not be used by normal applications.
9980 *
9981 * @returns VBox status code.
9982 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
9983 * @param pDisk Pointer to HDD container.
9984 * @param nImage Image number, counts from 0. 0 is always base image of container.
9985 * @param pUuid New modification UUID of the image. If NULL, a new UUID is created.
9986 */
9987VBOXDDU_DECL(int) VDSetModificationUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
9988{
9989 int rc;
9990 int rc2;
9991 bool fLockWrite = false;
9992
9993 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
9994 pDisk, nImage, pUuid, pUuid));
9995 do
9996 {
9997 /* sanity check */
9998 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
9999 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10000
10001 /* Check arguments. */
10002 AssertMsgBreakStmt(VALID_PTR(pUuid) || pUuid == NULL,
10003 ("pUuid=%#p\n", pUuid),
10004 rc = VERR_INVALID_PARAMETER);
10005
10006 rc2 = vdThreadStartWrite(pDisk);
10007 AssertRC(rc2);
10008 fLockWrite = true;
10009
10010 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
10011 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
10012
10013 RTUUID Uuid;
10014 if (!pUuid)
10015 {
10016 RTUuidCreate(&Uuid);
10017 pUuid = &Uuid;
10018 }
10019 rc = pImage->Backend->pfnSetModificationUuid(pImage->pBackendData,
10020 pUuid);
10021 } while (0);
10022
10023 if (RT_UNLIKELY(fLockWrite))
10024 {
10025 rc2 = vdThreadFinishWrite(pDisk);
10026 AssertRC(rc2);
10027 }
10028
10029 LogFlowFunc(("returns %Rrc\n", rc));
10030 return rc;
10031}
10032
10033/**
10034 * Get parent UUID of image in HDD container.
10035 *
10036 * @returns VBox status code.
10037 * @returns VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
10038 * @param pDisk Pointer to HDD container.
10039 * @param nImage Image number, counts from 0. 0 is always base image of container.
10040 * @param pUuid Where to store the parent image UUID.
10041 */
10042VBOXDDU_DECL(int) VDGetParentUuid(PVDISK pDisk, unsigned nImage,
10043 PRTUUID pUuid)
10044{
10045 int rc = VINF_SUCCESS;
10046 int rc2;
10047 bool fLockRead = false;
10048
10049 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
10050 do
10051 {
10052 /* sanity check */
10053 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10054 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10055
10056 /* Check arguments. */
10057 AssertMsgBreakStmt(VALID_PTR(pUuid),
10058 ("pUuid=%#p\n", pUuid),
10059 rc = VERR_INVALID_PARAMETER);
10060
10061 rc2 = vdThreadStartRead(pDisk);
10062 AssertRC(rc2);
10063 fLockRead = true;
10064
10065 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
10066 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
10067
10068 rc = pImage->Backend->pfnGetParentUuid(pImage->pBackendData, pUuid);
10069 } while (0);
10070
10071 if (RT_UNLIKELY(fLockRead))
10072 {
10073 rc2 = vdThreadFinishRead(pDisk);
10074 AssertRC(rc2);
10075 }
10076
10077 LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
10078 return rc;
10079}
10080
10081/**
10082 * Set the image's parent UUID. Should not be used by normal applications.
10083 *
10084 * @returns VBox status code.
10085 * @param pDisk Pointer to HDD container.
10086 * @param nImage Image number, counts from 0. 0 is always base image of container.
10087 * @param pUuid New parent UUID of the image. If NULL, a new UUID is created.
10088 */
10089VBOXDDU_DECL(int) VDSetParentUuid(PVDISK pDisk, unsigned nImage,
10090 PCRTUUID pUuid)
10091{
10092 int rc;
10093 int rc2;
10094 bool fLockWrite = false;
10095
10096 LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
10097 pDisk, nImage, pUuid, pUuid));
10098 do
10099 {
10100 /* sanity check */
10101 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10102 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10103
10104 /* Check arguments. */
10105 AssertMsgBreakStmt(VALID_PTR(pUuid) || pUuid == NULL,
10106 ("pUuid=%#p\n", pUuid),
10107 rc = VERR_INVALID_PARAMETER);
10108
10109 rc2 = vdThreadStartWrite(pDisk);
10110 AssertRC(rc2);
10111 fLockWrite = true;
10112
10113 PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
10114 AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
10115
10116 RTUUID Uuid;
10117 if (!pUuid)
10118 {
10119 RTUuidCreate(&Uuid);
10120 pUuid = &Uuid;
10121 }
10122 rc = pImage->Backend->pfnSetParentUuid(pImage->pBackendData, pUuid);
10123 } while (0);
10124
10125 if (RT_UNLIKELY(fLockWrite))
10126 {
10127 rc2 = vdThreadFinishWrite(pDisk);
10128 AssertRC(rc2);
10129 }
10130
10131 LogFlowFunc(("returns %Rrc\n", rc));
10132 return rc;
10133}
10134
10135
10136/**
10137 * Debug helper - dumps all opened images in HDD container into the log file.
10138 *
10139 * @param pDisk Pointer to HDD container.
10140 */
10141VBOXDDU_DECL(void) VDDumpImages(PVDISK pDisk)
10142{
10143 int rc2;
10144 bool fLockRead = false;
10145
10146 do
10147 {
10148 /* sanity check */
10149 AssertPtrBreak(pDisk);
10150 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10151
10152 if (!pDisk->pInterfaceError || !VALID_PTR(pDisk->pInterfaceError->pfnMessage))
10153 pDisk->pInterfaceError->pfnMessage = vdLogMessage;
10154
10155 rc2 = vdThreadStartRead(pDisk);
10156 AssertRC(rc2);
10157 fLockRead = true;
10158
10159 vdMessageWrapper(pDisk, "--- Dumping VD Disk, Images=%u\n", pDisk->cImages);
10160 for (PVDIMAGE pImage = pDisk->pBase; pImage; pImage = pImage->pNext)
10161 {
10162 vdMessageWrapper(pDisk, "Dumping VD image \"%s\" (Backend=%s)\n",
10163 pImage->pszFilename, pImage->Backend->pszBackendName);
10164 pImage->Backend->pfnDump(pImage->pBackendData);
10165 }
10166 } while (0);
10167
10168 if (RT_UNLIKELY(fLockRead))
10169 {
10170 rc2 = vdThreadFinishRead(pDisk);
10171 AssertRC(rc2);
10172 }
10173}
10174
10175
10176VBOXDDU_DECL(int) VDDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges)
10177{
10178 int rc;
10179 int rc2;
10180 bool fLockWrite = false;
10181
10182 LogFlowFunc(("pDisk=%#p paRanges=%#p cRanges=%u\n",
10183 pDisk, paRanges, cRanges));
10184 do
10185 {
10186 /* sanity check */
10187 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10188 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10189
10190 /* Check arguments. */
10191 AssertMsgBreakStmt(cRanges,
10192 ("cRanges=%u\n", cRanges),
10193 rc = VERR_INVALID_PARAMETER);
10194 AssertMsgBreakStmt(VALID_PTR(paRanges),
10195 ("paRanges=%#p\n", paRanges),
10196 rc = VERR_INVALID_PARAMETER);
10197
10198 rc2 = vdThreadStartWrite(pDisk);
10199 AssertRC(rc2);
10200 fLockWrite = true;
10201
10202 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10203
10204 AssertMsgBreakStmt(pDisk->pLast->uOpenFlags & VD_OPEN_FLAGS_DISCARD,
10205 ("Discarding not supported\n"),
10206 rc = VERR_NOT_SUPPORTED);
10207
10208 VDIOCTX IoCtx;
10209 RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
10210
10211 rc = RTSemEventCreate(&hEventComplete);
10212 if (RT_FAILURE(rc))
10213 break;
10214
10215 vdIoCtxDiscardInit(&IoCtx, pDisk, paRanges, cRanges,
10216 vdIoCtxSyncComplete, pDisk, hEventComplete, NULL,
10217 vdDiscardHelperAsync, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE);
10218 rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
10219
10220 RTSemEventDestroy(hEventComplete);
10221 } while (0);
10222
10223 if (RT_UNLIKELY(fLockWrite))
10224 {
10225 rc2 = vdThreadFinishWrite(pDisk);
10226 AssertRC(rc2);
10227 }
10228
10229 LogFlowFunc(("returns %Rrc\n", rc));
10230 return rc;
10231}
10232
10233
10234VBOXDDU_DECL(int) VDAsyncRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
10235 PCRTSGBUF pcSgBuf,
10236 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10237 void *pvUser1, void *pvUser2)
10238{
10239 int rc = VERR_VD_BLOCK_FREE;
10240 int rc2;
10241 bool fLockRead = false;
10242 PVDIOCTX pIoCtx = NULL;
10243
10244 LogFlowFunc(("pDisk=%#p uOffset=%llu pcSgBuf=%#p cbRead=%zu pvUser1=%#p pvUser2=%#p\n",
10245 pDisk, uOffset, pcSgBuf, cbRead, pvUser1, pvUser2));
10246
10247 do
10248 {
10249 /* sanity check */
10250 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10251 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10252
10253 /* Check arguments. */
10254 AssertMsgBreakStmt(cbRead,
10255 ("cbRead=%zu\n", cbRead),
10256 rc = VERR_INVALID_PARAMETER);
10257 AssertMsgBreakStmt(VALID_PTR(pcSgBuf),
10258 ("pcSgBuf=%#p\n", pcSgBuf),
10259 rc = VERR_INVALID_PARAMETER);
10260
10261 rc2 = vdThreadStartRead(pDisk);
10262 AssertRC(rc2);
10263 fLockRead = true;
10264
10265 AssertMsgBreakStmt(uOffset + cbRead <= pDisk->cbSize,
10266 ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
10267 uOffset, cbRead, pDisk->cbSize),
10268 rc = VERR_INVALID_PARAMETER);
10269 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10270
10271 pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
10272 cbRead, pDisk->pLast, pcSgBuf,
10273 pfnComplete, pvUser1, pvUser2,
10274 NULL, vdReadHelperAsync,
10275 VDIOCTX_FLAGS_ZERO_FREE_BLOCKS);
10276 if (!pIoCtx)
10277 {
10278 rc = VERR_NO_MEMORY;
10279 break;
10280 }
10281
10282 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10283 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10284 {
10285 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10286 vdIoCtxFree(pDisk, pIoCtx);
10287 else
10288 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10289 }
10290 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10291 vdIoCtxFree(pDisk, pIoCtx);
10292
10293 } while (0);
10294
10295 if (RT_UNLIKELY(fLockRead) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10296 {
10297 rc2 = vdThreadFinishRead(pDisk);
10298 AssertRC(rc2);
10299 }
10300
10301 LogFlowFunc(("returns %Rrc\n", rc));
10302 return rc;
10303}
10304
10305
10306VBOXDDU_DECL(int) VDAsyncWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
10307 PCRTSGBUF pcSgBuf,
10308 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10309 void *pvUser1, void *pvUser2)
10310{
10311 int rc;
10312 int rc2;
10313 bool fLockWrite = false;
10314 PVDIOCTX pIoCtx = NULL;
10315
10316 LogFlowFunc(("pDisk=%#p uOffset=%llu cSgBuf=%#p cbWrite=%zu pvUser1=%#p pvUser2=%#p\n",
10317 pDisk, uOffset, pcSgBuf, cbWrite, pvUser1, pvUser2));
10318 do
10319 {
10320 /* sanity check */
10321 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10322 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10323
10324 /* Check arguments. */
10325 AssertMsgBreakStmt(cbWrite,
10326 ("cbWrite=%zu\n", cbWrite),
10327 rc = VERR_INVALID_PARAMETER);
10328 AssertMsgBreakStmt(VALID_PTR(pcSgBuf),
10329 ("pcSgBuf=%#p\n", pcSgBuf),
10330 rc = VERR_INVALID_PARAMETER);
10331
10332 rc2 = vdThreadStartWrite(pDisk);
10333 AssertRC(rc2);
10334 fLockWrite = true;
10335
10336 AssertMsgBreakStmt(uOffset + cbWrite <= pDisk->cbSize,
10337 ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
10338 uOffset, cbWrite, pDisk->cbSize),
10339 rc = VERR_INVALID_PARAMETER);
10340 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10341
10342 pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_WRITE, uOffset,
10343 cbWrite, pDisk->pLast, pcSgBuf,
10344 pfnComplete, pvUser1, pvUser2,
10345 NULL, vdWriteHelperAsync,
10346 VDIOCTX_FLAGS_DEFAULT);
10347 if (!pIoCtx)
10348 {
10349 rc = VERR_NO_MEMORY;
10350 break;
10351 }
10352
10353 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10354 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10355 {
10356 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10357 vdIoCtxFree(pDisk, pIoCtx);
10358 else
10359 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10360 }
10361 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10362 vdIoCtxFree(pDisk, pIoCtx);
10363 } while (0);
10364
10365 if (RT_UNLIKELY(fLockWrite) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10366 {
10367 rc2 = vdThreadFinishWrite(pDisk);
10368 AssertRC(rc2);
10369 }
10370
10371 LogFlowFunc(("returns %Rrc\n", rc));
10372 return rc;
10373}
10374
10375
10376VBOXDDU_DECL(int) VDAsyncFlush(PVDISK pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10377 void *pvUser1, void *pvUser2)
10378{
10379 int rc;
10380 int rc2;
10381 bool fLockWrite = false;
10382 PVDIOCTX pIoCtx = NULL;
10383
10384 LogFlowFunc(("pDisk=%#p\n", pDisk));
10385
10386 do
10387 {
10388 /* sanity check */
10389 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10390 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10391
10392 rc2 = vdThreadStartWrite(pDisk);
10393 AssertRC(rc2);
10394 fLockWrite = true;
10395
10396 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10397
10398 pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_FLUSH, 0,
10399 0, pDisk->pLast, NULL,
10400 pfnComplete, pvUser1, pvUser2,
10401 NULL, vdFlushHelperAsync,
10402 VDIOCTX_FLAGS_DEFAULT);
10403 if (!pIoCtx)
10404 {
10405 rc = VERR_NO_MEMORY;
10406 break;
10407 }
10408
10409 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10410 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10411 {
10412 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10413 vdIoCtxFree(pDisk, pIoCtx);
10414 else
10415 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10416 }
10417 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10418 vdIoCtxFree(pDisk, pIoCtx);
10419 } while (0);
10420
10421 if (RT_UNLIKELY(fLockWrite) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10422 {
10423 rc2 = vdThreadFinishWrite(pDisk);
10424 AssertRC(rc2);
10425 }
10426
10427 LogFlowFunc(("returns %Rrc\n", rc));
10428 return rc;
10429}
10430
10431VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges,
10432 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
10433 void *pvUser1, void *pvUser2)
10434{
10435 int rc;
10436 int rc2;
10437 bool fLockWrite = false;
10438 PVDIOCTX pIoCtx = NULL;
10439
10440 LogFlowFunc(("pDisk=%#p\n", pDisk));
10441
10442 do
10443 {
10444 /* sanity check */
10445 AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
10446 AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
10447
10448 rc2 = vdThreadStartWrite(pDisk);
10449 AssertRC(rc2);
10450 fLockWrite = true;
10451
10452 AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
10453
10454 pIoCtx = vdIoCtxDiscardAlloc(pDisk, paRanges, cRanges,
10455 pfnComplete, pvUser1, pvUser2, NULL,
10456 vdDiscardHelperAsync,
10457 VDIOCTX_FLAGS_DEFAULT);
10458 if (!pIoCtx)
10459 {
10460 rc = VERR_NO_MEMORY;
10461 break;
10462 }
10463
10464 rc = vdIoCtxProcessTryLockDefer(pIoCtx);
10465 if (rc == VINF_VD_ASYNC_IO_FINISHED)
10466 {
10467 if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
10468 vdIoCtxFree(pDisk, pIoCtx);
10469 else
10470 rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
10471 }
10472 else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
10473 vdIoCtxFree(pDisk, pIoCtx);
10474 } while (0);
10475
10476 if (RT_UNLIKELY(fLockWrite) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
10477 {
10478 rc2 = vdThreadFinishWrite(pDisk);
10479 AssertRC(rc2);
10480 }
10481
10482 LogFlowFunc(("returns %Rrc\n", rc));
10483 return rc;
10484}
10485
10486VBOXDDU_DECL(int) VDRepair(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
10487 const char *pszFilename, const char *pszBackend,
10488 uint32_t fFlags)
10489{
10490 int rc = VERR_NOT_SUPPORTED;
10491 PCVDIMAGEBACKEND pBackend = NULL;
10492 VDINTERFACEIOINT VDIfIoInt;
10493 VDINTERFACEIO VDIfIoFallback;
10494 PVDINTERFACEIO pInterfaceIo;
10495
10496 LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
10497 /* Check arguments. */
10498 AssertMsgReturn(VALID_PTR(pszFilename) && *pszFilename,
10499 ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
10500 VERR_INVALID_PARAMETER);
10501 AssertMsgReturn(VALID_PTR(pszBackend),
10502 ("pszBackend=%#p\n", pszBackend),
10503 VERR_INVALID_PARAMETER);
10504 AssertMsgReturn((fFlags & ~VD_REPAIR_FLAGS_MASK) == 0,
10505 ("fFlags=%#x\n", fFlags),
10506 VERR_INVALID_PARAMETER);
10507
10508 pInterfaceIo = VDIfIoGet(pVDIfsImage);
10509 if (!pInterfaceIo)
10510 {
10511 /*
10512 * Caller doesn't provide an I/O interface, create our own using the
10513 * native file API.
10514 */
10515 vdIfIoFallbackCallbacksSetup(&VDIfIoFallback);
10516 pInterfaceIo = &VDIfIoFallback;
10517 }
10518
10519 /* Set up the internal I/O interface. */
10520 AssertReturn(!VDIfIoIntGet(pVDIfsImage), VERR_INVALID_PARAMETER);
10521 VDIfIoInt.pfnOpen = vdIOIntOpenLimited;
10522 VDIfIoInt.pfnClose = vdIOIntCloseLimited;
10523 VDIfIoInt.pfnDelete = vdIOIntDeleteLimited;
10524 VDIfIoInt.pfnMove = vdIOIntMoveLimited;
10525 VDIfIoInt.pfnGetFreeSpace = vdIOIntGetFreeSpaceLimited;
10526 VDIfIoInt.pfnGetModificationTime = vdIOIntGetModificationTimeLimited;
10527 VDIfIoInt.pfnGetSize = vdIOIntGetSizeLimited;
10528 VDIfIoInt.pfnSetSize = vdIOIntSetSizeLimited;
10529 VDIfIoInt.pfnReadUser = vdIOIntReadUserLimited;
10530 VDIfIoInt.pfnWriteUser = vdIOIntWriteUserLimited;
10531 VDIfIoInt.pfnReadMeta = vdIOIntReadMetaLimited;
10532 VDIfIoInt.pfnWriteMeta = vdIOIntWriteMetaLimited;
10533 VDIfIoInt.pfnFlush = vdIOIntFlushLimited;
10534 rc = VDInterfaceAdd(&VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
10535 pInterfaceIo, sizeof(VDINTERFACEIOINT), &pVDIfsImage);
10536 AssertRC(rc);
10537
10538 rc = vdFindImageBackend(pszBackend, &pBackend);
10539 if (RT_SUCCESS(rc))
10540 {
10541 if (pBackend->pfnRepair)
10542 rc = pBackend->pfnRepair(pszFilename, pVDIfsDisk, pVDIfsImage, fFlags);
10543 else
10544 rc = VERR_VD_IMAGE_REPAIR_NOT_SUPPORTED;
10545 }
10546
10547 LogFlowFunc(("returns %Rrc\n", rc));
10548 return rc;
10549}
10550
10551
10552/*
10553 * generic plugin functions
10554 */
10555
10556/**
10557 * @interface_method_impl{VDIMAGEBACKEND,pfnComposeLocation}
10558 */
10559DECLCALLBACK(int) genericFileComposeLocation(PVDINTERFACE pConfig, char **pszLocation)
10560{
10561 RT_NOREF1(pConfig);
10562 *pszLocation = NULL;
10563 return VINF_SUCCESS;
10564}
10565
10566/**
10567 * @interface_method_impl{VDIMAGEBACKEND,pfnComposeName}
10568 */
10569DECLCALLBACK(int) genericFileComposeName(PVDINTERFACE pConfig, char **pszName)
10570{
10571 RT_NOREF1(pConfig);
10572 *pszName = NULL;
10573 return VINF_SUCCESS;
10574}
10575
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