VirtualBox

source: vbox/trunk/src/VBox/Storage/VHD.cpp@ 65125

Last change on this file since 65125 was 64272, checked in by vboxsync, 8 years ago

Storage: Doxygen fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 116.8 KB
Line 
1/* $Id: VHD.cpp 64272 2016-10-14 08:25:05Z vboxsync $ */
2/** @file
3 * VHD Disk image, Core Code.
4 */
5
6/*
7 * Copyright (C) 2006-2016 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_VHD
23#include <VBox/vd-plugin.h>
24#include <VBox/err.h>
25
26#include <VBox/log.h>
27#include <VBox/version.h>
28#include <iprt/asm.h>
29#include <iprt/assert.h>
30#include <iprt/mem.h>
31#include <iprt/uuid.h>
32#include <iprt/path.h>
33#include <iprt/string.h>
34
35#include "VDBackends.h"
36
37#define VHD_RELATIVE_MAX_PATH 512
38#define VHD_ABSOLUTE_MAX_PATH 512
39
40#define VHD_SECTOR_SIZE 512
41#define VHD_BLOCK_SIZE (2 * _1M)
42
43/* This is common to all VHD disk types and is located at the end of the image */
44#pragma pack(1)
45typedef struct VHDFooter
46{
47 char Cookie[8];
48 uint32_t Features;
49 uint32_t Version;
50 uint64_t DataOffset;
51 uint32_t Timestamp;
52 uint8_t CreatorApp[4];
53 uint32_t CreatorVer;
54 uint32_t CreatorOS;
55 uint64_t OrigSize;
56 uint64_t CurSize;
57 uint16_t DiskGeometryCylinder;
58 uint8_t DiskGeometryHeads;
59 uint8_t DiskGeometrySectors;
60 uint32_t DiskType;
61 uint32_t Checksum;
62 char UniqueID[16];
63 uint8_t SavedState;
64 uint8_t Reserved[427];
65} VHDFooter;
66#pragma pack()
67
68/* this really is spelled with only one n */
69#define VHD_FOOTER_COOKIE "conectix"
70#define VHD_FOOTER_COOKIE_SIZE 8
71
72#define VHD_FOOTER_FEATURES_NOT_ENABLED 0
73#define VHD_FOOTER_FEATURES_TEMPORARY 1
74#define VHD_FOOTER_FEATURES_RESERVED 2
75
76#define VHD_FOOTER_FILE_FORMAT_VERSION 0x00010000
77#define VHD_FOOTER_DATA_OFFSET_FIXED UINT64_C(0xffffffffffffffff)
78#define VHD_FOOTER_DISK_TYPE_FIXED 2
79#define VHD_FOOTER_DISK_TYPE_DYNAMIC 3
80#define VHD_FOOTER_DISK_TYPE_DIFFERENCING 4
81
82#define VHD_MAX_LOCATOR_ENTRIES 8
83#define VHD_PLATFORM_CODE_NONE 0
84#define VHD_PLATFORM_CODE_WI2R 0x57693272
85#define VHD_PLATFORM_CODE_WI2K 0x5769326B
86#define VHD_PLATFORM_CODE_W2RU 0x57327275
87#define VHD_PLATFORM_CODE_W2KU 0x57326B75
88#define VHD_PLATFORM_CODE_MAC 0x4D163220
89#define VHD_PLATFORM_CODE_MACX 0x4D163258
90
91/* Header for expanding disk images. */
92#pragma pack(1)
93typedef struct VHDParentLocatorEntry
94{
95 uint32_t u32Code;
96 uint32_t u32DataSpace;
97 uint32_t u32DataLength;
98 uint32_t u32Reserved;
99 uint64_t u64DataOffset;
100} VHDPLE, *PVHDPLE;
101
102typedef struct VHDDynamicDiskHeader
103{
104 char Cookie[8];
105 uint64_t DataOffset;
106 uint64_t TableOffset;
107 uint32_t HeaderVersion;
108 uint32_t MaxTableEntries;
109 uint32_t BlockSize;
110 uint32_t Checksum;
111 uint8_t ParentUuid[16];
112 uint32_t ParentTimestamp;
113 uint32_t Reserved0;
114 uint16_t ParentUnicodeName[256];
115 VHDPLE ParentLocatorEntry[VHD_MAX_LOCATOR_ENTRIES];
116 uint8_t Reserved1[256];
117} VHDDynamicDiskHeader;
118#pragma pack()
119
120#define VHD_DYNAMIC_DISK_HEADER_COOKIE "cxsparse"
121#define VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE 8
122#define VHD_DYNAMIC_DISK_HEADER_VERSION 0x00010000
123
124/**
125 * Complete VHD image data structure.
126 */
127typedef struct VHDIMAGE
128{
129 /** Image file name. */
130 const char *pszFilename;
131 /** Opaque storage handle. */
132 PVDIOSTORAGE pStorage;
133
134 /** Pointer to the per-disk VD interface list. */
135 PVDINTERFACE pVDIfsDisk;
136 /** Pointer to the per-image VD interface list. */
137 PVDINTERFACE pVDIfsImage;
138 /** Error interface. */
139 PVDINTERFACEERROR pIfError;
140 /** I/O interface. */
141 PVDINTERFACEIOINT pIfIo;
142
143 /** Open flags passed by VBoxHDD layer. */
144 unsigned uOpenFlags;
145 /** Image flags defined during creation or determined during open. */
146 unsigned uImageFlags;
147 /** Total size of the image. */
148 uint64_t cbSize;
149
150 /** Physical geometry of this image. */
151 VDGEOMETRY PCHSGeometry;
152 /** Logical geometry of this image. */
153 VDGEOMETRY LCHSGeometry;
154
155 /** Image UUID. */
156 RTUUID ImageUuid;
157 /** Parent image UUID. */
158 RTUUID ParentUuid;
159
160 /** Parent's time stamp at the time of image creation. */
161 uint32_t u32ParentTimestamp;
162 /** Relative path to the parent image. */
163 char *pszParentFilename;
164
165 /** The Block Allocation Table. */
166 uint32_t *pBlockAllocationTable;
167 /** Number of entries in the table. */
168 uint32_t cBlockAllocationTableEntries;
169
170 /** Size of one data block. */
171 uint32_t cbDataBlock;
172 /** Sectors per data block. */
173 uint32_t cSectorsPerDataBlock;
174 /** Length of the sector bitmap in bytes. */
175 uint32_t cbDataBlockBitmap;
176 /** A copy of the disk footer. */
177 VHDFooter vhdFooterCopy;
178 /** Current end offset of the file (without the disk footer). */
179 uint64_t uCurrentEndOfFile;
180 /** Size of the data block bitmap in sectors. */
181 uint32_t cDataBlockBitmapSectors;
182 /** Start of the block allocation table. */
183 uint64_t uBlockAllocationTableOffset;
184 /** Buffer to hold block's bitmap for bit search operations. */
185 uint8_t *pu8Bitmap;
186 /** Offset to the next data structure (dynamic disk header). */
187 uint64_t u64DataOffset;
188 /** Flag to force dynamic disk header update. */
189 bool fDynHdrNeedsUpdate;
190} VHDIMAGE, *PVHDIMAGE;
191
192/**
193 * Structure tracking the expansion process of the image
194 * for async access.
195 */
196typedef struct VHDIMAGEEXPAND
197{
198 /** Flag indicating the status of each step. */
199 volatile uint32_t fFlags;
200 /** The index in the block allocation table which is written. */
201 uint32_t idxBatAllocated;
202 /** Big endian representation of the block index
203 * which is written in the BAT. */
204 uint32_t idxBlockBe;
205 /** Old end of the file - used for rollback in case of an error. */
206 uint64_t cbEofOld;
207 /** Sector bitmap written to the new block - variable in size. */
208 uint8_t au8Bitmap[1];
209} VHDIMAGEEXPAND, *PVHDIMAGEEXPAND;
210
211/**
212 * Flag defines
213 */
214#define VHDIMAGEEXPAND_STEP_IN_PROGRESS (0x0)
215#define VHDIMAGEEXPAND_STEP_FAILED (0x2)
216#define VHDIMAGEEXPAND_STEP_SUCCESS (0x3)
217/** All steps completed successfully. */
218#define VHDIMAGEEXPAND_ALL_SUCCESS (0xff)
219/** All steps completed (no success indicator) */
220#define VHDIMAGEEXPAND_ALL_COMPLETE (0xaa)
221
222/** Every status field has 2 bits so we can encode 4 steps in one byte. */
223#define VHDIMAGEEXPAND_STATUS_MASK 0x03
224#define VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT 0x00
225#define VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT 0x02
226#define VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT 0x04
227#define VHDIMAGEEXPAND_BAT_STATUS_SHIFT 0x06
228
229/**
230 * Helper macros to get and set the status field.
231 */
232#define VHDIMAGEEXPAND_STATUS_GET(fFlags, cShift) \
233 (((fFlags) >> (cShift)) & VHDIMAGEEXPAND_STATUS_MASK)
234#define VHDIMAGEEXPAND_STATUS_SET(fFlags, cShift, uVal) \
235 ASMAtomicOrU32(&(fFlags), ((uVal) & VHDIMAGEEXPAND_STATUS_MASK) << (cShift))
236
237
238/*********************************************************************************************************************************
239* Static Variables *
240*********************************************************************************************************************************/
241
242/** NULL-terminated array of supported file extensions. */
243static const VDFILEEXTENSION s_aVhdFileExtensions[] =
244{
245 {"vhd", VDTYPE_HDD},
246 {NULL, VDTYPE_INVALID}
247};
248
249
250/*********************************************************************************************************************************
251* Internal Functions *
252*********************************************************************************************************************************/
253
254
255/**
256 * Internal: Compute and update header checksum.
257 */
258static uint32_t vhdChecksum(void *pHeader, uint32_t cbSize)
259{
260 uint32_t u32ChkSum = 0;
261 for (uint32_t i = 0; i < cbSize; i++)
262 u32ChkSum += ((unsigned char *)pHeader)[i];
263 return ~u32ChkSum;
264}
265
266/**
267 * Internal: Convert filename to UTF16 with appropriate endianness.
268 */
269static int vhdFilenameToUtf16(const char *pszFilename, uint16_t *pu16Buf,
270 uint32_t cbBufSize, uint32_t *pcbActualSize,
271 bool fBigEndian)
272{
273 int rc;
274 PRTUTF16 pTmp16 = NULL;
275 size_t cTmp16Len;
276
277 rc = RTStrToUtf16(pszFilename, &pTmp16);
278 if (RT_SUCCESS(rc))
279 {
280 cTmp16Len = RTUtf16Len(pTmp16);
281 if (cTmp16Len * sizeof(*pTmp16) <= cbBufSize)
282 {
283 if (fBigEndian)
284 for (unsigned i = 0; i < cTmp16Len; i++)
285 pu16Buf[i] = RT_H2BE_U16(pTmp16[i]);
286 else
287 memcpy(pu16Buf, pTmp16, cTmp16Len * sizeof(*pTmp16));
288 if (pcbActualSize)
289 *pcbActualSize = (uint32_t)(cTmp16Len * sizeof(*pTmp16));
290 }
291 else
292 rc = VERR_FILENAME_TOO_LONG;
293 }
294
295 if (pTmp16)
296 RTUtf16Free(pTmp16);
297 return rc;
298}
299
300/**
301 * Internal: Update one locator entry.
302 */
303static int vhdLocatorUpdate(PVHDIMAGE pImage, PVHDPLE pLocator, const char *pszFilename)
304{
305 int rc = VINF_SUCCESS;
306 uint32_t cb = 0;
307 uint32_t cbMaxLen = RT_BE2H_U32(pLocator->u32DataSpace);
308 void *pvBuf = RTMemTmpAllocZ(cbMaxLen);
309 char *pszTmp;
310
311 if (!pvBuf)
312 return VERR_NO_MEMORY;
313
314 switch (RT_BE2H_U32(pLocator->u32Code))
315 {
316 case VHD_PLATFORM_CODE_WI2R:
317 {
318 if (RTPathStartsWithRoot(pszFilename))
319 {
320 /* Convert to relative path. */
321 char szPath[RTPATH_MAX];
322 rc = RTPathCalcRelative(szPath, sizeof(szPath), pImage->pszFilename,
323 pszFilename);
324 if (RT_SUCCESS(rc))
325 {
326 /* Update plain relative name. */
327 cb = (uint32_t)strlen(szPath);
328 if (cb > cbMaxLen)
329 {
330 rc = VERR_FILENAME_TOO_LONG;
331 break;
332 }
333 memcpy(pvBuf, szPath, cb);
334 }
335 }
336 else
337 {
338 /* Update plain relative name. */
339 cb = (uint32_t)strlen(pszFilename);
340 if (cb > cbMaxLen)
341 {
342 rc = VERR_FILENAME_TOO_LONG;
343 break;
344 }
345 memcpy(pvBuf, pszFilename, cb);
346 }
347 if (RT_SUCCESS(rc))
348 pLocator->u32DataLength = RT_H2BE_U32(cb);
349 break;
350 }
351 case VHD_PLATFORM_CODE_WI2K:
352 /* Update plain absolute name. */
353 rc = RTPathAbs(pszFilename, (char *)pvBuf, cbMaxLen);
354 if (RT_SUCCESS(rc))
355 {
356 cb = (uint32_t)strlen((const char *)pvBuf);
357 pLocator->u32DataLength = RT_H2BE_U32(cb);
358 }
359 break;
360 case VHD_PLATFORM_CODE_W2RU:
361 if (RTPathStartsWithRoot(pszFilename))
362 {
363 /* Convert to relative path. */
364 char szPath[RTPATH_MAX];
365 rc = RTPathCalcRelative(szPath, sizeof(szPath), pImage->pszFilename,
366 pszFilename);
367 if (RT_SUCCESS(rc))
368 rc = vhdFilenameToUtf16(szPath, (uint16_t *)pvBuf, cbMaxLen, &cb, false);
369 }
370 else
371 {
372 /* Update unicode relative name. */
373 rc = vhdFilenameToUtf16(pszFilename, (uint16_t *)pvBuf, cbMaxLen, &cb, false);
374 }
375
376 if (RT_SUCCESS(rc))
377 pLocator->u32DataLength = RT_H2BE_U32(cb);
378 break;
379 case VHD_PLATFORM_CODE_W2KU:
380 /* Update unicode absolute name. */
381 pszTmp = (char*)RTMemTmpAllocZ(cbMaxLen);
382 if (!pszTmp)
383 {
384 rc = VERR_NO_MEMORY;
385 break;
386 }
387 rc = RTPathAbs(pszFilename, pszTmp, cbMaxLen);
388 if (RT_FAILURE(rc))
389 {
390 RTMemTmpFree(pszTmp);
391 break;
392 }
393 rc = vhdFilenameToUtf16(pszTmp, (uint16_t *)pvBuf, cbMaxLen, &cb, false);
394 RTMemTmpFree(pszTmp);
395 if (RT_SUCCESS(rc))
396 pLocator->u32DataLength = RT_H2BE_U32(cb);
397 break;
398 default:
399 rc = VERR_NOT_IMPLEMENTED;
400 break;
401 }
402
403 if (RT_SUCCESS(rc))
404 {
405 Assert(cb > 0);
406 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
407 RT_BE2H_U64(pLocator->u64DataOffset),
408 pvBuf, cb);
409 }
410
411 if (pvBuf)
412 RTMemTmpFree(pvBuf);
413 return rc;
414}
415
416/**
417 * Internal: Update dynamic disk header from VHDIMAGE.
418 */
419static int vhdDynamicHeaderUpdate(PVHDIMAGE pImage)
420{
421 VHDDynamicDiskHeader ddh;
422 int rc, i;
423
424 if (!pImage)
425 return VERR_VD_NOT_OPENED;
426
427 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
428 pImage->u64DataOffset, &ddh, sizeof(ddh));
429 if (RT_FAILURE(rc))
430 return rc;
431 if (memcmp(ddh.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE) != 0)
432 return VERR_VD_VHD_INVALID_HEADER;
433
434 uint32_t u32Checksum = RT_BE2H_U32(ddh.Checksum);
435 ddh.Checksum = 0;
436 if (u32Checksum != vhdChecksum(&ddh, sizeof(ddh)))
437 return VERR_VD_VHD_INVALID_HEADER;
438
439 /* Update parent's timestamp. */
440 ddh.ParentTimestamp = RT_H2BE_U32(pImage->u32ParentTimestamp);
441 /* Update parent's filename. */
442 if (pImage->pszParentFilename)
443 {
444 rc = vhdFilenameToUtf16(RTPathFilename(pImage->pszParentFilename),
445 ddh.ParentUnicodeName, sizeof(ddh.ParentUnicodeName) - 1, NULL, true);
446 if (RT_FAILURE(rc))
447 return rc;
448 }
449
450 /* Update parent's locators. */
451 for (i = 0; i < VHD_MAX_LOCATOR_ENTRIES; i++)
452 {
453 /* Skip empty locators */
454 if ( ddh.ParentLocatorEntry[i].u32Code != RT_H2BE_U32(VHD_PLATFORM_CODE_NONE)
455 && pImage->pszParentFilename)
456 {
457 rc = vhdLocatorUpdate(pImage, &ddh.ParentLocatorEntry[i], pImage->pszParentFilename);
458 if (RT_FAILURE(rc))
459 return rc;
460 }
461 }
462 /* Update parent's UUID */
463 memcpy(ddh.ParentUuid, pImage->ParentUuid.au8, sizeof(ddh.ParentUuid));
464
465 /* Update data offset and number of table entries. */
466 ddh.MaxTableEntries = RT_H2BE_U32(pImage->cBlockAllocationTableEntries);
467
468 ddh.Checksum = 0;
469 ddh.Checksum = RT_H2BE_U32(vhdChecksum(&ddh, sizeof(ddh)));
470 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
471 pImage->u64DataOffset, &ddh, sizeof(ddh));
472 return rc;
473}
474
475/**
476 * Internal: Update the VHD footer.
477 */
478static int vhdUpdateFooter(PVHDIMAGE pImage)
479{
480 int rc = VINF_SUCCESS;
481
482 /* Update fields which can change. */
483 pImage->vhdFooterCopy.CurSize = RT_H2BE_U64(pImage->cbSize);
484 pImage->vhdFooterCopy.DiskGeometryCylinder = RT_H2BE_U16(pImage->PCHSGeometry.cCylinders);
485 pImage->vhdFooterCopy.DiskGeometryHeads = pImage->PCHSGeometry.cHeads;
486 pImage->vhdFooterCopy.DiskGeometrySectors = pImage->PCHSGeometry.cSectors;
487
488 pImage->vhdFooterCopy.Checksum = 0;
489 pImage->vhdFooterCopy.Checksum = RT_H2BE_U32(vhdChecksum(&pImage->vhdFooterCopy, sizeof(VHDFooter)));
490
491 if (pImage->pBlockAllocationTable)
492 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0,
493 &pImage->vhdFooterCopy, sizeof(VHDFooter));
494
495 if (RT_SUCCESS(rc))
496 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
497 pImage->uCurrentEndOfFile, &pImage->vhdFooterCopy,
498 sizeof(VHDFooter));
499
500 return rc;
501}
502
503/**
504 * Internal. Flush image data to disk.
505 */
506static int vhdFlushImage(PVHDIMAGE pImage)
507{
508 int rc = VINF_SUCCESS;
509
510 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
511 return VINF_SUCCESS;
512
513 if (pImage->pBlockAllocationTable)
514 {
515 /*
516 * This is an expanding image. Write the BAT and copy of the disk footer.
517 */
518 size_t cbBlockAllocationTableToWrite = pImage->cBlockAllocationTableEntries * sizeof(uint32_t);
519 uint32_t *pBlockAllocationTableToWrite = (uint32_t *)RTMemAllocZ(cbBlockAllocationTableToWrite);
520
521 if (!pBlockAllocationTableToWrite)
522 return VERR_NO_MEMORY;
523
524 /*
525 * The BAT entries have to be stored in big endian format.
526 */
527 for (unsigned i = 0; i < pImage->cBlockAllocationTableEntries; i++)
528 pBlockAllocationTableToWrite[i] = RT_H2BE_U32(pImage->pBlockAllocationTable[i]);
529
530 /*
531 * Write the block allocation table after the copy of the disk footer and the dynamic disk header.
532 */
533 vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->uBlockAllocationTableOffset,
534 pBlockAllocationTableToWrite, cbBlockAllocationTableToWrite);
535 if (pImage->fDynHdrNeedsUpdate)
536 rc = vhdDynamicHeaderUpdate(pImage);
537 RTMemFree(pBlockAllocationTableToWrite);
538 }
539
540 if (RT_SUCCESS(rc))
541 rc = vhdUpdateFooter(pImage);
542
543 if (RT_SUCCESS(rc))
544 rc = vdIfIoIntFileFlushSync(pImage->pIfIo, pImage->pStorage);
545
546 return rc;
547}
548
549/**
550 * Internal. Free all allocated space for representing an image except pImage,
551 * and optionally delete the image from disk.
552 */
553static int vhdFreeImage(PVHDIMAGE pImage, bool fDelete)
554{
555 int rc = VINF_SUCCESS;
556
557 /* Freeing a never allocated image (e.g. because the open failed) is
558 * not signalled as an error. After all nothing bad happens. */
559 if (pImage)
560 {
561 if (pImage->pStorage)
562 {
563 /* No point updating the file that is deleted anyway. */
564 if (!fDelete)
565 vhdFlushImage(pImage);
566
567 rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
568 pImage->pStorage = NULL;
569 }
570
571 if (pImage->pszParentFilename)
572 {
573 RTStrFree(pImage->pszParentFilename);
574 pImage->pszParentFilename = NULL;
575 }
576 if (pImage->pBlockAllocationTable)
577 {
578 RTMemFree(pImage->pBlockAllocationTable);
579 pImage->pBlockAllocationTable = NULL;
580 }
581 if (pImage->pu8Bitmap)
582 {
583 RTMemFree(pImage->pu8Bitmap);
584 pImage->pu8Bitmap = NULL;
585 }
586
587 if (fDelete && pImage->pszFilename)
588 vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
589 }
590
591 LogFlowFunc(("returns %Rrc\n", rc));
592 return rc;
593}
594
595/* 946684800 is the number of seconds between 1/1/1970 and 1/1/2000 */
596#define VHD_TO_UNIX_EPOCH_SECONDS UINT64_C(946684800)
597
598static uint32_t vhdRtTime2VhdTime(PCRTTIMESPEC pRtTimestamp)
599{
600 uint64_t u64Seconds = RTTimeSpecGetSeconds(pRtTimestamp);
601 return (uint32_t)(u64Seconds - VHD_TO_UNIX_EPOCH_SECONDS);
602}
603
604static void vhdTime2RtTime(PRTTIMESPEC pRtTimestamp, uint32_t u32VhdTimestamp)
605{
606 RTTimeSpecSetSeconds(pRtTimestamp, VHD_TO_UNIX_EPOCH_SECONDS + u32VhdTimestamp);
607}
608
609/**
610 * Internal: Allocates the block bitmap rounding up to the next 32bit or 64bit boundary.
611 * Can be freed with RTMemFree. The memory is zeroed.
612 */
613DECLINLINE(uint8_t *)vhdBlockBitmapAllocate(PVHDIMAGE pImage)
614{
615#ifdef RT_ARCH_AMD64
616 return (uint8_t *)RTMemAllocZ(pImage->cbDataBlockBitmap + 8);
617#else
618 return (uint8_t *)RTMemAllocZ(pImage->cbDataBlockBitmap + 4);
619#endif
620}
621
622/**
623 * Internal: called when the async expansion process completed (failure or success).
624 * Will do the necessary rollback if an error occurred.
625 */
626static int vhdAsyncExpansionComplete(PVHDIMAGE pImage, PVDIOCTX pIoCtx, PVHDIMAGEEXPAND pExpand)
627{
628 int rc = VINF_SUCCESS;
629 uint32_t fFlags = ASMAtomicReadU32(&pExpand->fFlags);
630 bool fIoInProgress = false;
631
632 /* Quick path, check if everything succeeded. */
633 if (fFlags == VHDIMAGEEXPAND_ALL_SUCCESS)
634 {
635 pImage->pBlockAllocationTable[pExpand->idxBatAllocated] = RT_BE2H_U32(pExpand->idxBlockBe);
636 RTMemFree(pExpand);
637 }
638 else
639 {
640 uint32_t uStatus;
641
642 uStatus = VHDIMAGEEXPAND_STATUS_GET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT);
643 if ( uStatus == VHDIMAGEEXPAND_STEP_FAILED
644 || uStatus == VHDIMAGEEXPAND_STEP_SUCCESS)
645 {
646 /* Undo and restore the old value. */
647 pImage->pBlockAllocationTable[pExpand->idxBatAllocated] = ~0U;
648
649 /* Restore the old value on the disk.
650 * No need for a completion callback because we can't
651 * do anything if this fails. */
652 if (uStatus == VHDIMAGEEXPAND_STEP_SUCCESS)
653 {
654 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
655 pImage->uBlockAllocationTableOffset
656 + pExpand->idxBatAllocated * sizeof(uint32_t),
657 &pImage->pBlockAllocationTable[pExpand->idxBatAllocated],
658 sizeof(uint32_t), pIoCtx, NULL, NULL);
659 fIoInProgress |= rc == VERR_VD_ASYNC_IO_IN_PROGRESS;
660 }
661 }
662
663 /* Restore old size (including the footer because another application might
664 * fill up the free space making it impossible to add the footer)
665 * and add the footer at the right place again. */
666 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
667 pExpand->cbEofOld + sizeof(VHDFooter));
668 AssertRC(rc);
669
670 pImage->uCurrentEndOfFile = pExpand->cbEofOld;
671 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
672 pImage->uCurrentEndOfFile,
673 &pImage->vhdFooterCopy, sizeof(VHDFooter),
674 pIoCtx, NULL, NULL);
675 fIoInProgress |= rc == VERR_VD_ASYNC_IO_IN_PROGRESS;
676 }
677
678 return fIoInProgress ? VERR_VD_ASYNC_IO_IN_PROGRESS : rc;
679}
680
681static int vhdAsyncExpansionStepCompleted(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq, unsigned iStep)
682{
683 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
684 PVHDIMAGEEXPAND pExpand = (PVHDIMAGEEXPAND)pvUser;
685
686 LogFlowFunc(("pBackendData=%#p pIoCtx=%#p pvUser=%#p rcReq=%Rrc iStep=%u\n",
687 pBackendData, pIoCtx, pvUser, rcReq, iStep));
688
689 if (RT_SUCCESS(rcReq))
690 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, iStep, VHDIMAGEEXPAND_STEP_SUCCESS);
691 else
692 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, iStep, VHDIMAGEEXPAND_STEP_FAILED);
693
694 if ((pExpand->fFlags & VHDIMAGEEXPAND_ALL_COMPLETE) == VHDIMAGEEXPAND_ALL_COMPLETE)
695 return vhdAsyncExpansionComplete(pImage, pIoCtx, pExpand);
696
697 return VERR_VD_ASYNC_IO_IN_PROGRESS;
698}
699
700static DECLCALLBACK(int) vhdAsyncExpansionDataBlockBitmapComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
701{
702 return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT);
703}
704
705static DECLCALLBACK(int) vhdAsyncExpansionDataComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
706{
707 return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT);
708}
709
710static DECLCALLBACK(int) vhdAsyncExpansionBatUpdateComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
711{
712 return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_BAT_STATUS_SHIFT);
713}
714
715static DECLCALLBACK(int) vhdAsyncExpansionFooterUpdateComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
716{
717 return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT);
718}
719
720static int vhdLoadDynamicDisk(PVHDIMAGE pImage, uint64_t uDynamicDiskHeaderOffset)
721{
722 VHDDynamicDiskHeader vhdDynamicDiskHeader;
723 int rc = VINF_SUCCESS;
724 uint32_t *pBlockAllocationTable;
725 uint64_t uBlockAllocationTableOffset;
726 unsigned i = 0;
727
728 Log(("Open a dynamic disk.\n"));
729
730 /*
731 * Read the dynamic disk header.
732 */
733 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, uDynamicDiskHeaderOffset,
734 &vhdDynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
735 if (memcmp(vhdDynamicDiskHeader.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE))
736 return VERR_INVALID_PARAMETER;
737
738 pImage->cbDataBlock = RT_BE2H_U32(vhdDynamicDiskHeader.BlockSize);
739 LogFlowFunc(("BlockSize=%u\n", pImage->cbDataBlock));
740 pImage->cBlockAllocationTableEntries = RT_BE2H_U32(vhdDynamicDiskHeader.MaxTableEntries);
741 LogFlowFunc(("MaxTableEntries=%lu\n", pImage->cBlockAllocationTableEntries));
742 AssertMsg(!(pImage->cbDataBlock % VHD_SECTOR_SIZE), ("%s: Data block size is not a multiple of %!\n", __FUNCTION__, VHD_SECTOR_SIZE));
743
744 pImage->cSectorsPerDataBlock = pImage->cbDataBlock / VHD_SECTOR_SIZE;
745 LogFlowFunc(("SectorsPerDataBlock=%u\n", pImage->cSectorsPerDataBlock));
746
747 /*
748 * Every block starts with a bitmap indicating which sectors are valid and which are not.
749 * We store the size of it to be able to calculate the real offset.
750 */
751 pImage->cbDataBlockBitmap = pImage->cSectorsPerDataBlock / 8;
752 pImage->cDataBlockBitmapSectors = pImage->cbDataBlockBitmap / VHD_SECTOR_SIZE;
753 /* Round up to full sector size */
754 if (pImage->cbDataBlockBitmap % VHD_SECTOR_SIZE > 0)
755 pImage->cDataBlockBitmapSectors++;
756 LogFlowFunc(("cbDataBlockBitmap=%u\n", pImage->cbDataBlockBitmap));
757 LogFlowFunc(("cDataBlockBitmapSectors=%u\n", pImage->cDataBlockBitmapSectors));
758
759 pImage->pu8Bitmap = vhdBlockBitmapAllocate(pImage);
760 if (!pImage->pu8Bitmap)
761 return VERR_NO_MEMORY;
762
763 pBlockAllocationTable = (uint32_t *)RTMemAllocZ(pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
764 if (!pBlockAllocationTable)
765 return VERR_NO_MEMORY;
766
767 /*
768 * Read the table.
769 */
770 uBlockAllocationTableOffset = RT_BE2H_U64(vhdDynamicDiskHeader.TableOffset);
771 LogFlowFunc(("uBlockAllocationTableOffset=%llu\n", uBlockAllocationTableOffset));
772 pImage->uBlockAllocationTableOffset = uBlockAllocationTableOffset;
773 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
774 uBlockAllocationTableOffset, pBlockAllocationTable,
775 pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
776
777 /*
778 * Because the offset entries inside the allocation table are stored big endian
779 * we need to convert them into host endian.
780 */
781 pImage->pBlockAllocationTable = (uint32_t *)RTMemAllocZ(pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
782 if (!pImage->pBlockAllocationTable)
783 {
784 RTMemFree(pBlockAllocationTable);
785 return VERR_NO_MEMORY;
786 }
787
788 for (i = 0; i < pImage->cBlockAllocationTableEntries; i++)
789 pImage->pBlockAllocationTable[i] = RT_BE2H_U32(pBlockAllocationTable[i]);
790
791 RTMemFree(pBlockAllocationTable);
792
793 if (pImage->uImageFlags & VD_IMAGE_FLAGS_DIFF)
794 memcpy(pImage->ParentUuid.au8, vhdDynamicDiskHeader.ParentUuid, sizeof(pImage->ParentUuid));
795
796 return rc;
797}
798
799static int vhdOpenImage(PVHDIMAGE pImage, unsigned uOpenFlags)
800{
801 uint64_t FileSize;
802 VHDFooter vhdFooter;
803
804 pImage->uOpenFlags = uOpenFlags;
805
806 pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
807 pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
808 AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
809
810 /*
811 * Open the image.
812 */
813 int rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
814 VDOpenFlagsToFileOpenFlags(uOpenFlags,
815 false /* fCreate */),
816 &pImage->pStorage);
817 if (RT_FAILURE(rc))
818 {
819 /* Do NOT signal an appropriate error here, as the VD layer has the
820 * choice of retrying the open if it failed. */
821 return rc;
822 }
823
824 rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &FileSize);
825 pImage->uCurrentEndOfFile = FileSize - sizeof(VHDFooter);
826
827 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, pImage->uCurrentEndOfFile,
828 &vhdFooter, sizeof(VHDFooter));
829 if (RT_SUCCESS(rc))
830 {
831 if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
832 {
833 /*
834 * There is also a backup header at the beginning in case the image got corrupted.
835 * Such corrupted images are detected here to let the open handler repair it later.
836 */
837 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, 0,
838 &vhdFooter, sizeof(VHDFooter));
839 if (RT_SUCCESS(rc))
840 {
841 if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
842 rc = VERR_VD_VHD_INVALID_HEADER;
843 else
844 rc = VERR_VD_IMAGE_CORRUPTED;
845 }
846 }
847 }
848
849 if (RT_FAILURE(rc))
850 return rc;
851
852 switch (RT_BE2H_U32(vhdFooter.DiskType))
853 {
854 case VHD_FOOTER_DISK_TYPE_FIXED:
855 pImage->uImageFlags |= VD_IMAGE_FLAGS_FIXED;
856 break;
857 case VHD_FOOTER_DISK_TYPE_DYNAMIC:
858 pImage->uImageFlags &= ~VD_IMAGE_FLAGS_FIXED;
859 break;
860 case VHD_FOOTER_DISK_TYPE_DIFFERENCING:
861 pImage->uImageFlags |= VD_IMAGE_FLAGS_DIFF;
862 pImage->uImageFlags &= ~VD_IMAGE_FLAGS_FIXED;
863 break;
864 default:
865 return VERR_NOT_IMPLEMENTED;
866 }
867
868 pImage->cbSize = RT_BE2H_U64(vhdFooter.CurSize);
869 pImage->LCHSGeometry.cCylinders = 0;
870 pImage->LCHSGeometry.cHeads = 0;
871 pImage->LCHSGeometry.cSectors = 0;
872 pImage->PCHSGeometry.cCylinders = RT_BE2H_U16(vhdFooter.DiskGeometryCylinder);
873 pImage->PCHSGeometry.cHeads = vhdFooter.DiskGeometryHeads;
874 pImage->PCHSGeometry.cSectors = vhdFooter.DiskGeometrySectors;
875
876 /*
877 * Copy of the disk footer.
878 * If we allocate new blocks in differencing disks on write access
879 * the footer is overwritten. We need to write it at the end of the file.
880 */
881 memcpy(&pImage->vhdFooterCopy, &vhdFooter, sizeof(VHDFooter));
882
883 /*
884 * Is there a better way?
885 */
886 memcpy(&pImage->ImageUuid, &vhdFooter.UniqueID, 16);
887
888 pImage->u64DataOffset = RT_BE2H_U64(vhdFooter.DataOffset);
889 LogFlowFunc(("DataOffset=%llu\n", pImage->u64DataOffset));
890
891 if (!(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED))
892 rc = vhdLoadDynamicDisk(pImage, pImage->u64DataOffset);
893
894 if (RT_FAILURE(rc))
895 vhdFreeImage(pImage, false);
896 return rc;
897}
898
899/**
900 * Internal: Checks if a sector in the block bitmap is set
901 */
902DECLINLINE(bool) vhdBlockBitmapSectorContainsData(PVHDIMAGE pImage, uint32_t cBlockBitmapEntry)
903{
904 uint32_t iBitmap = (cBlockBitmapEntry / 8); /* Byte in the block bitmap. */
905
906 /*
907 * The index of the bit in the byte of the data block bitmap.
908 * The most significant bit stands for a lower sector number.
909 */
910 uint8_t iBitInByte = (8-1) - (cBlockBitmapEntry % 8);
911 uint8_t *puBitmap = pImage->pu8Bitmap + iBitmap;
912
913 AssertMsg(puBitmap < (pImage->pu8Bitmap + pImage->cbDataBlockBitmap),
914 ("VHD: Current bitmap position exceeds maximum size of the bitmap\n"));
915
916 return ((*puBitmap) & RT_BIT(iBitInByte)) != 0;
917}
918
919/**
920 * Internal: Sets the given sector in the sector bitmap.
921 */
922DECLINLINE(bool) vhdBlockBitmapSectorSet(PVHDIMAGE pImage, uint8_t *pu8Bitmap, uint32_t cBlockBitmapEntry)
923{
924 RT_NOREF1(pImage);
925 uint32_t iBitmap = (cBlockBitmapEntry / 8); /* Byte in the block bitmap. */
926
927 /*
928 * The index of the bit in the byte of the data block bitmap.
929 * The most significant bit stands for a lower sector number.
930 */
931 uint8_t iBitInByte = (8-1) - (cBlockBitmapEntry % 8);
932 uint8_t *puBitmap = pu8Bitmap + iBitmap;
933
934 AssertMsg(puBitmap < (pu8Bitmap + pImage->cbDataBlockBitmap),
935 ("VHD: Current bitmap position exceeds maximum size of the bitmap\n"));
936
937 bool fClear = ((*puBitmap) & RT_BIT(iBitInByte)) == 0;
938 *puBitmap |= RT_BIT(iBitInByte);
939 return fClear;
940}
941
942/**
943 * Internal: Derive drive geometry from its size.
944 */
945static void vhdSetDiskGeometry(PVHDIMAGE pImage, uint64_t cbSize)
946{
947 uint64_t u64TotalSectors = cbSize / VHD_SECTOR_SIZE;
948 uint32_t u32CylinderTimesHeads, u32Heads, u32SectorsPerTrack;
949
950 if (u64TotalSectors > 65535 * 16 * 255)
951 {
952 /* ATA disks limited to 127 GB. */
953 u64TotalSectors = 65535 * 16 * 255;
954 }
955
956 if (u64TotalSectors >= 65535 * 16 * 63)
957 {
958 u32SectorsPerTrack = 255;
959 u32Heads = 16;
960 u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
961 }
962 else
963 {
964 u32SectorsPerTrack = 17;
965 u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
966
967 u32Heads = (u32CylinderTimesHeads + 1023) / 1024;
968
969 if (u32Heads < 4)
970 {
971 u32Heads = 4;
972 }
973 if (u32CylinderTimesHeads >= (u32Heads * 1024) || u32Heads > 16)
974 {
975 u32SectorsPerTrack = 31;
976 u32Heads = 16;
977 u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
978 }
979 if (u32CylinderTimesHeads >= (u32Heads * 1024))
980 {
981 u32SectorsPerTrack = 63;
982 u32Heads = 16;
983 u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
984 }
985 }
986 pImage->PCHSGeometry.cCylinders = u32CylinderTimesHeads / u32Heads;
987 pImage->PCHSGeometry.cHeads = u32Heads;
988 pImage->PCHSGeometry.cSectors = u32SectorsPerTrack;
989 pImage->LCHSGeometry.cCylinders = 0;
990 pImage->LCHSGeometry.cHeads = 0;
991 pImage->LCHSGeometry.cSectors = 0;
992}
993
994
995static uint32_t vhdAllocateParentLocators(PVHDIMAGE pImage, VHDDynamicDiskHeader *pDDH, uint64_t u64Offset)
996{
997 RT_NOREF1(pImage);
998 PVHDPLE pLocator = pDDH->ParentLocatorEntry;
999
1000 /*
1001 * The VHD spec states that the DataSpace field holds the number of sectors
1002 * required to store the parent locator path.
1003 * As it turned out VPC and Hyper-V store the amount of bytes reserved for the
1004 * path and not the number of sectors.
1005 */
1006
1007 /* Unicode absolute Windows path. */
1008 pLocator->u32Code = RT_H2BE_U32(VHD_PLATFORM_CODE_W2KU);
1009 pLocator->u32DataSpace = RT_H2BE_U32(VHD_ABSOLUTE_MAX_PATH * sizeof(RTUTF16));
1010 pLocator->u64DataOffset = RT_H2BE_U64(u64Offset);
1011 pLocator++;
1012 u64Offset += VHD_ABSOLUTE_MAX_PATH * sizeof(RTUTF16);
1013 /* Unicode relative Windows path. */
1014 pLocator->u32Code = RT_H2BE_U32(VHD_PLATFORM_CODE_W2RU);
1015 pLocator->u32DataSpace = RT_H2BE_U32(VHD_RELATIVE_MAX_PATH * sizeof(RTUTF16));
1016 pLocator->u64DataOffset = RT_H2BE_U64(u64Offset);
1017 u64Offset += VHD_RELATIVE_MAX_PATH * sizeof(RTUTF16);
1018 return u64Offset;
1019}
1020
1021/**
1022 * Internal: Additional code for dynamic VHD image creation.
1023 */
1024static int vhdCreateDynamicImage(PVHDIMAGE pImage, uint64_t cbSize)
1025{
1026 int rc;
1027 VHDDynamicDiskHeader DynamicDiskHeader;
1028 uint32_t u32BlockAllocationTableSectors;
1029 void *pvTmp = NULL;
1030
1031 memset(&DynamicDiskHeader, 0, sizeof(DynamicDiskHeader));
1032
1033 pImage->u64DataOffset = sizeof(VHDFooter);
1034 pImage->cbDataBlock = VHD_BLOCK_SIZE; /* 2 MB */
1035 pImage->cSectorsPerDataBlock = pImage->cbDataBlock / VHD_SECTOR_SIZE;
1036 pImage->cbDataBlockBitmap = pImage->cSectorsPerDataBlock / 8;
1037 pImage->cDataBlockBitmapSectors = pImage->cbDataBlockBitmap / VHD_SECTOR_SIZE;
1038 /* Align to sector boundary */
1039 if (pImage->cbDataBlockBitmap % VHD_SECTOR_SIZE > 0)
1040 pImage->cDataBlockBitmapSectors++;
1041 pImage->pu8Bitmap = vhdBlockBitmapAllocate(pImage);
1042 if (!pImage->pu8Bitmap)
1043 return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot allocate memory for bitmap storage"));
1044
1045 /* Initialize BAT. */
1046 pImage->uBlockAllocationTableOffset = (uint64_t)sizeof(VHDFooter) + sizeof(VHDDynamicDiskHeader);
1047 pImage->cBlockAllocationTableEntries = (uint32_t)((cbSize + pImage->cbDataBlock - 1) / pImage->cbDataBlock); /* Align table to the block size. */
1048 u32BlockAllocationTableSectors = (pImage->cBlockAllocationTableEntries * sizeof(uint32_t) + VHD_SECTOR_SIZE - 1) / VHD_SECTOR_SIZE;
1049 pImage->pBlockAllocationTable = (uint32_t *)RTMemAllocZ(pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
1050 if (!pImage->pBlockAllocationTable)
1051 return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot allocate memory for BAT"));
1052
1053 for (unsigned i = 0; i < pImage->cBlockAllocationTableEntries; i++)
1054 {
1055 pImage->pBlockAllocationTable[i] = 0xFFFFFFFF; /* It is actually big endian. */
1056 }
1057
1058 /* Round up to the sector size. */
1059 if (pImage->uImageFlags & VD_IMAGE_FLAGS_DIFF) /* fix hyper-v unreadable error */
1060 pImage->uCurrentEndOfFile = vhdAllocateParentLocators(pImage, &DynamicDiskHeader,
1061 pImage->uBlockAllocationTableOffset + u32BlockAllocationTableSectors * VHD_SECTOR_SIZE);
1062 else
1063 pImage->uCurrentEndOfFile = pImage->uBlockAllocationTableOffset + u32BlockAllocationTableSectors * VHD_SECTOR_SIZE;
1064
1065 /* Set dynamic image size. */
1066 pvTmp = RTMemTmpAllocZ(pImage->uCurrentEndOfFile + sizeof(VHDFooter));
1067 if (!pvTmp)
1068 return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
1069
1070 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0, pvTmp,
1071 pImage->uCurrentEndOfFile + sizeof(VHDFooter));
1072 if (RT_FAILURE(rc))
1073 {
1074 RTMemTmpFree(pvTmp);
1075 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
1076 }
1077
1078 RTMemTmpFree(pvTmp);
1079
1080 /* Initialize and write the dynamic disk header. */
1081 memcpy(DynamicDiskHeader.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, sizeof(DynamicDiskHeader.Cookie));
1082 DynamicDiskHeader.DataOffset = UINT64_C(0xFFFFFFFFFFFFFFFF); /* Initially the disk has no data. */
1083 DynamicDiskHeader.TableOffset = RT_H2BE_U64(pImage->uBlockAllocationTableOffset);
1084 DynamicDiskHeader.HeaderVersion = RT_H2BE_U32(VHD_DYNAMIC_DISK_HEADER_VERSION);
1085 DynamicDiskHeader.BlockSize = RT_H2BE_U32(pImage->cbDataBlock);
1086 DynamicDiskHeader.MaxTableEntries = RT_H2BE_U32(pImage->cBlockAllocationTableEntries);
1087 /* Compute and update checksum. */
1088 DynamicDiskHeader.Checksum = 0;
1089 DynamicDiskHeader.Checksum = RT_H2BE_U32(vhdChecksum(&DynamicDiskHeader, sizeof(DynamicDiskHeader)));
1090
1091 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, sizeof(VHDFooter),
1092 &DynamicDiskHeader, sizeof(DynamicDiskHeader));
1093 if (RT_FAILURE(rc))
1094 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write dynamic disk header to image '%s'"), pImage->pszFilename);
1095
1096 /* Write BAT. */
1097 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->uBlockAllocationTableOffset,
1098 pImage->pBlockAllocationTable,
1099 pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
1100 if (RT_FAILURE(rc))
1101 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write BAT to image '%s'"), pImage->pszFilename);
1102
1103 return rc;
1104}
1105
1106/**
1107 * Internal: The actual code for VHD image creation, both fixed and dynamic.
1108 */
1109static int vhdCreateImage(PVHDIMAGE pImage, uint64_t cbSize,
1110 unsigned uImageFlags, const char *pszComment,
1111 PCVDGEOMETRY pPCHSGeometry,
1112 PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
1113 unsigned uOpenFlags,
1114 PVDINTERFACEPROGRESS pIfProgress,
1115 unsigned uPercentStart, unsigned uPercentSpan)
1116{
1117 RT_NOREF3(pszComment, pPCHSGeometry, pLCHSGeometry);
1118 VHDFooter Footer;
1119 RTTIMESPEC now;
1120
1121 pImage->uOpenFlags = uOpenFlags;
1122 pImage->uImageFlags = uImageFlags;
1123 pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
1124
1125 int rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
1126 VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
1127 true /* fCreate */),
1128 &pImage->pStorage);
1129 if (RT_SUCCESS(rc))
1130 {
1131 pImage->cbSize = cbSize;
1132 pImage->ImageUuid = *pUuid;
1133 RTUuidClear(&pImage->ParentUuid);
1134 vhdSetDiskGeometry(pImage, cbSize);
1135
1136 /* Initialize the footer. */
1137 memset(&Footer, 0, sizeof(Footer));
1138 memcpy(Footer.Cookie, VHD_FOOTER_COOKIE, sizeof(Footer.Cookie));
1139 Footer.Features = RT_H2BE_U32(0x2);
1140 Footer.Version = RT_H2BE_U32(VHD_FOOTER_FILE_FORMAT_VERSION);
1141 Footer.Timestamp = RT_H2BE_U32(vhdRtTime2VhdTime(RTTimeNow(&now)));
1142 memcpy(Footer.CreatorApp, "vbox", sizeof(Footer.CreatorApp));
1143 Footer.CreatorVer = RT_H2BE_U32(VBOX_VERSION);
1144#ifdef RT_OS_DARWIN
1145 Footer.CreatorOS = RT_H2BE_U32(0x4D616320); /* "Mac " */
1146#else /* Virtual PC supports only two platforms atm, so everything else will be Wi2k. */
1147 Footer.CreatorOS = RT_H2BE_U32(0x5769326B); /* "Wi2k" */
1148#endif
1149 Footer.OrigSize = RT_H2BE_U64(cbSize);
1150 Footer.CurSize = Footer.OrigSize;
1151 Footer.DiskGeometryCylinder = RT_H2BE_U16(pImage->PCHSGeometry.cCylinders);
1152 Footer.DiskGeometryHeads = pImage->PCHSGeometry.cHeads;
1153 Footer.DiskGeometrySectors = pImage->PCHSGeometry.cSectors;
1154 memcpy(Footer.UniqueID, pImage->ImageUuid.au8, sizeof(Footer.UniqueID));
1155 Footer.SavedState = 0;
1156
1157 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
1158 {
1159 Footer.DiskType = RT_H2BE_U32(VHD_FOOTER_DISK_TYPE_FIXED);
1160 /*
1161 * Initialize fixed image.
1162 * "The size of the entire file is the size of the hard disk in
1163 * the guest operating system plus the size of the footer."
1164 */
1165 pImage->u64DataOffset = VHD_FOOTER_DATA_OFFSET_FIXED;
1166 pImage->uCurrentEndOfFile = cbSize;
1167 rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pImage->pStorage, pImage->uCurrentEndOfFile + sizeof(VHDFooter),
1168 0 /* fFlags */, pIfProgress,
1169 uPercentStart, uPercentSpan);
1170 if (RT_FAILURE(rc))
1171 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
1172 }
1173 else
1174 {
1175 /*
1176 * Initialize dynamic image.
1177 *
1178 * The overall structure of dynamic disk is:
1179 *
1180 * [Copy of hard disk footer (512 bytes)]
1181 * [Dynamic disk header (1024 bytes)]
1182 * [BAT (Block Allocation Table)]
1183 * [Parent Locators]
1184 * [Data block 1]
1185 * [Data block 2]
1186 * ...
1187 * [Data block N]
1188 * [Hard disk footer (512 bytes)]
1189 */
1190 Footer.DiskType = (uImageFlags & VD_IMAGE_FLAGS_DIFF)
1191 ? RT_H2BE_U32(VHD_FOOTER_DISK_TYPE_DIFFERENCING)
1192 : RT_H2BE_U32(VHD_FOOTER_DISK_TYPE_DYNAMIC);
1193 /* We are half way thorough with creation of image, let the caller know. */
1194 vdIfProgress(pIfProgress, (uPercentStart + uPercentSpan) / 2);
1195
1196 rc = vhdCreateDynamicImage(pImage, cbSize);
1197 }
1198
1199 if (RT_SUCCESS(rc))
1200 {
1201 /* Compute and update the footer checksum. */
1202 Footer.DataOffset = RT_H2BE_U64(pImage->u64DataOffset);
1203 Footer.Checksum = 0;
1204 Footer.Checksum = RT_H2BE_U32(vhdChecksum(&Footer, sizeof(Footer)));
1205
1206 pImage->vhdFooterCopy = Footer;
1207
1208 /* Store the footer */
1209 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->uCurrentEndOfFile,
1210 &Footer, sizeof(Footer));
1211 if (RT_SUCCESS(rc))
1212 {
1213 /* Dynamic images contain a copy of the footer at the very beginning of the file. */
1214 if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
1215 {
1216 /* Write the copy of the footer. */
1217 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0, &Footer, sizeof(Footer));
1218 if (RT_FAILURE(rc))
1219 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write a copy of footer to image '%s'"), pImage->pszFilename);
1220 }
1221 }
1222 else
1223 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write footer to image '%s'"), pImage->pszFilename);
1224 }
1225 }
1226 else
1227 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot create image '%s'"), pImage->pszFilename);
1228
1229 if (RT_SUCCESS(rc))
1230 vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
1231
1232 if (RT_FAILURE(rc))
1233 vhdFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
1234 return rc;
1235}
1236
1237
1238/** @interface_method_impl{VDIMAGEBACKEND,pfnProbe} */
1239static DECLCALLBACK(int) vhdProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1240 PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
1241{
1242 RT_NOREF1(pVDIfsDisk);
1243 LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
1244 PVDIOSTORAGE pStorage;
1245 PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
1246 AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
1247
1248 int rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
1249 VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
1250 false /* fCreate */),
1251 &pStorage);
1252 if (RT_SUCCESS(rc))
1253 {
1254 uint64_t cbFile;
1255
1256 rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
1257 if ( RT_SUCCESS(rc)
1258 && cbFile >= sizeof(VHDFooter))
1259 {
1260 VHDFooter vhdFooter;
1261
1262 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, cbFile - sizeof(VHDFooter),
1263 &vhdFooter, sizeof(VHDFooter));
1264 if (RT_SUCCESS(rc))
1265 {
1266 if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
1267 {
1268 /*
1269 * There is also a backup header at the beginning in case the image got corrupted.
1270 * Such corrupted images are detected here to let the open handler repair it later.
1271 */
1272 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &vhdFooter, sizeof(VHDFooter));
1273 if ( RT_FAILURE(rc)
1274 || (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0))
1275 rc = VERR_VD_VHD_INVALID_HEADER;
1276 }
1277
1278 if (RT_SUCCESS(rc))
1279 *penmType = VDTYPE_HDD;
1280 }
1281 else
1282 rc = VERR_VD_VHD_INVALID_HEADER;
1283 }
1284 else if (RT_SUCCESS(rc))
1285 rc = VERR_VD_VHD_INVALID_HEADER;
1286
1287 vdIfIoIntFileClose(pIfIo, pStorage);
1288 }
1289
1290 LogFlowFunc(("returns %Rrc\n", rc));
1291 return rc;
1292}
1293
1294/** @interface_method_impl{VDIMAGEBACKEND,pfnOpen} */
1295static DECLCALLBACK(int) vhdOpen(const char *pszFilename, unsigned uOpenFlags,
1296 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1297 VDTYPE enmType, void **ppBackendData)
1298{
1299 RT_NOREF1(enmType); /**< @todo r=klaus make use of the type info. */
1300
1301 LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n",
1302 pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
1303 int rc = VINF_SUCCESS;
1304
1305 /* Check open flags. All valid flags are supported. */
1306 AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
1307 AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
1308
1309 PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(sizeof(VHDIMAGE));
1310 if (RT_LIKELY(pImage))
1311 {
1312 pImage->pszFilename = pszFilename;
1313 pImage->pStorage = NULL;
1314 pImage->pVDIfsDisk = pVDIfsDisk;
1315 pImage->pVDIfsImage = pVDIfsImage;
1316
1317 rc = vhdOpenImage(pImage, uOpenFlags);
1318 if (RT_SUCCESS(rc))
1319 *ppBackendData = pImage;
1320 else
1321 RTMemFree(pImage);
1322 }
1323 else
1324 rc = VERR_NO_MEMORY;
1325
1326 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1327 return rc;
1328}
1329
1330/** @interface_method_impl{VDIMAGEBACKEND,pfnCreate} */
1331static DECLCALLBACK(int) vhdCreate(const char *pszFilename, uint64_t cbSize,
1332 unsigned uImageFlags, const char *pszComment,
1333 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
1334 PCRTUUID pUuid, unsigned uOpenFlags,
1335 unsigned uPercentStart, unsigned uPercentSpan,
1336 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1337 PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
1338 void **ppBackendData)
1339{
1340 LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p enmType=%u ppBackendData=%#p",
1341 pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
1342 int rc;
1343 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
1344
1345 /* Check the VD container type. */
1346 if (enmType != VDTYPE_HDD)
1347 return VERR_VD_INVALID_TYPE;
1348
1349 /* Check open flags. All valid flags are supported. */
1350 AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
1351 AssertReturn( VALID_PTR(pszFilename)
1352 && *pszFilename
1353 && VALID_PTR(pPCHSGeometry)
1354 && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
1355 /** @todo Check the values of other params */
1356
1357 PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(sizeof(VHDIMAGE));
1358 if (RT_LIKELY(pImage))
1359 {
1360 pImage->pszFilename = pszFilename;
1361 pImage->pStorage = NULL;
1362 pImage->pVDIfsDisk = pVDIfsDisk;
1363 pImage->pVDIfsImage = pVDIfsImage;
1364
1365 /* Get I/O interface. */
1366 pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
1367 if (RT_LIKELY(VALID_PTR(pImage->pIfIo)))
1368 {
1369 rc = vhdCreateImage(pImage, cbSize, uImageFlags, pszComment,
1370 pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags,
1371 pIfProgress, uPercentStart, uPercentSpan);
1372 if (RT_SUCCESS(rc))
1373 {
1374 /* So far the image is opened in read/write mode. Make sure the
1375 * image is opened in read-only mode if the caller requested that. */
1376 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
1377 {
1378 vhdFreeImage(pImage, false);
1379 rc = vhdOpenImage(pImage, uOpenFlags);
1380 }
1381
1382 if (RT_SUCCESS(rc))
1383 *ppBackendData = pImage;
1384 }
1385 }
1386 else
1387 rc = VERR_INVALID_PARAMETER;
1388
1389 if (RT_FAILURE(rc))
1390 RTMemFree(pImage);
1391 }
1392 else
1393 rc = VERR_NO_MEMORY;
1394
1395 LogFlowFunc(("returns %Rrc\n", rc));
1396 return rc;
1397}
1398
1399/** @interface_method_impl{VDIMAGEBACKEND,pfnRename} */
1400static DECLCALLBACK(int) vhdRename(void *pBackendData, const char *pszFilename)
1401{
1402 LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
1403 int rc = VINF_SUCCESS;
1404 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1405
1406 /* Check arguments. */
1407 AssertReturn((pImage && pszFilename && *pszFilename), VERR_INVALID_PARAMETER);
1408
1409 /* Close the image. */
1410 rc = vhdFreeImage(pImage, false);
1411 if (RT_SUCCESS(rc))
1412 {
1413 /* Rename the file. */
1414 rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
1415 if (RT_SUCCESS(rc))
1416 {
1417 /* Update pImage with the new information. */
1418 pImage->pszFilename = pszFilename;
1419
1420 /* Open the old file with new name. */
1421 rc = vhdOpenImage(pImage, pImage->uOpenFlags);
1422 }
1423 else
1424 {
1425 /* The move failed, try to reopen the original image. */
1426 int rc2 = vhdOpenImage(pImage, pImage->uOpenFlags);
1427 if (RT_FAILURE(rc2))
1428 rc = rc2;
1429 }
1430 }
1431
1432 LogFlowFunc(("returns %Rrc\n", rc));
1433 return rc;
1434}
1435
1436/** @interface_method_impl{VDIMAGEBACKEND,pfnClose} */
1437static DECLCALLBACK(int) vhdClose(void *pBackendData, bool fDelete)
1438{
1439 LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1440 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1441
1442 int rc = vhdFreeImage(pImage, fDelete);
1443 RTMemFree(pImage);
1444
1445 LogFlowFunc(("returns %Rrc\n", rc));
1446 return rc;
1447}
1448
1449/** @interface_method_impl{VDIMAGEBACKEND,pfnRead} */
1450static DECLCALLBACK(int) vhdRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1451 PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1452{
1453 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1454 int rc = VINF_SUCCESS;
1455
1456 LogFlowFunc(("pBackendData=%p uOffset=%#llx pIoCtx=%#p cbToRead=%u pcbActuallyRead=%p\n",
1457 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
1458
1459 AssertPtr(pImage);
1460 Assert(uOffset % 512 == 0);
1461 Assert(cbToRead % 512 == 0);
1462 AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
1463 AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
1464
1465 /*
1466 * If we have a dynamic disk image, we need to find the data block and sector to read.
1467 */
1468 if (pImage->pBlockAllocationTable)
1469 {
1470 /*
1471 * Get the data block first.
1472 */
1473 uint32_t cBlockAllocationTableEntry = (uOffset / VHD_SECTOR_SIZE) / pImage->cSectorsPerDataBlock;
1474 uint32_t cBATEntryIndex = (uOffset / VHD_SECTOR_SIZE) % pImage->cSectorsPerDataBlock;
1475 uint64_t uVhdOffset;
1476
1477 LogFlowFunc(("cBlockAllocationTableEntry=%u cBatEntryIndex=%u\n", cBlockAllocationTableEntry, cBATEntryIndex));
1478 LogFlowFunc(("BlockAllocationEntry=%u\n", pImage->pBlockAllocationTable[cBlockAllocationTableEntry]));
1479
1480 /*
1481 * Clip read range to remain in this data block.
1482 */
1483 cbToRead = RT_MIN(cbToRead, (pImage->cbDataBlock - (cBATEntryIndex * VHD_SECTOR_SIZE)));
1484
1485 /*
1486 * If the block is not allocated the content of the entry is ~0
1487 */
1488 if (pImage->pBlockAllocationTable[cBlockAllocationTableEntry] == ~0U)
1489 rc = VERR_VD_BLOCK_FREE;
1490 else
1491 {
1492 uVhdOffset = ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry] + pImage->cDataBlockBitmapSectors + cBATEntryIndex) * VHD_SECTOR_SIZE;
1493 LogFlowFunc(("uVhdOffset=%llu cbToRead=%u\n", uVhdOffset, cbToRead));
1494
1495 /* Read in the block's bitmap. */
1496 PVDMETAXFER pMetaXfer;
1497 rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage,
1498 ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry]) * VHD_SECTOR_SIZE,
1499 pImage->pu8Bitmap, pImage->cbDataBlockBitmap,
1500 pIoCtx, &pMetaXfer, NULL, NULL);
1501
1502 if (RT_SUCCESS(rc))
1503 {
1504 uint32_t cSectors = 0;
1505
1506 vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
1507 if (vhdBlockBitmapSectorContainsData(pImage, cBATEntryIndex))
1508 {
1509 cBATEntryIndex++;
1510 cSectors = 1;
1511
1512 /*
1513 * The first sector being read is marked dirty, read as much as we
1514 * can from child. Note that only sectors that are marked dirty
1515 * must be read from child.
1516 */
1517 while ( (cSectors < (cbToRead / VHD_SECTOR_SIZE))
1518 && vhdBlockBitmapSectorContainsData(pImage, cBATEntryIndex))
1519 {
1520 cBATEntryIndex++;
1521 cSectors++;
1522 }
1523
1524 cbToRead = cSectors * VHD_SECTOR_SIZE;
1525
1526 LogFlowFunc(("uVhdOffset=%llu cbToRead=%u\n", uVhdOffset, cbToRead));
1527 rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage,
1528 uVhdOffset, pIoCtx, cbToRead);
1529 }
1530 else
1531 {
1532 /*
1533 * The first sector being read is marked clean, so we should read from
1534 * our parent instead, but only as much as there are the following
1535 * clean sectors, because the block may still contain dirty sectors
1536 * further on. We just need to compute the number of clean sectors
1537 * and pass it to our caller along with the notification that they
1538 * should be read from the parent.
1539 */
1540 cBATEntryIndex++;
1541 cSectors = 1;
1542
1543 while ( (cSectors < (cbToRead / VHD_SECTOR_SIZE))
1544 && !vhdBlockBitmapSectorContainsData(pImage, cBATEntryIndex))
1545 {
1546 cBATEntryIndex++;
1547 cSectors++;
1548 }
1549
1550 cbToRead = cSectors * VHD_SECTOR_SIZE;
1551 LogFunc(("Sectors free: uVhdOffset=%llu cbToRead=%u\n", uVhdOffset, cbToRead));
1552 rc = VERR_VD_BLOCK_FREE;
1553 }
1554 }
1555 else
1556 AssertMsg(rc == VERR_VD_NOT_ENOUGH_METADATA, ("Reading block bitmap failed rc=%Rrc\n", rc));
1557 }
1558 }
1559 else
1560 rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, uOffset, pIoCtx, cbToRead);
1561
1562 if (pcbActuallyRead)
1563 *pcbActuallyRead = cbToRead;
1564
1565 LogFlowFunc(("returns rc=%Rrc\n", rc));
1566 return rc;
1567}
1568
1569/** @interface_method_impl{VDIMAGEBACKEND,pfnWrite} */
1570static DECLCALLBACK(int) vhdWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
1571 PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
1572 size_t *pcbPostRead, unsigned fWrite)
1573{
1574 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1575 int rc = VINF_SUCCESS;
1576
1577 LogFlowFunc(("pBackendData=%p uOffset=%llu pIoCtx=%#p cbToWrite=%u pcbWriteProcess=%p pcbPreRead=%p pcbPostRead=%p fWrite=%u\n",
1578 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite));
1579
1580 AssertPtr(pImage);
1581 Assert(!(uOffset % VHD_SECTOR_SIZE));
1582 Assert(!(cbToWrite % VHD_SECTOR_SIZE));
1583 AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
1584 AssertReturn(uOffset + cbToWrite <= pImage->cbSize, VERR_INVALID_PARAMETER);
1585
1586 if (pImage->pBlockAllocationTable)
1587 {
1588 /*
1589 * Get the data block first.
1590 */
1591 uint32_t cSector = uOffset / VHD_SECTOR_SIZE;
1592 uint32_t cBlockAllocationTableEntry = cSector / pImage->cSectorsPerDataBlock;
1593 uint32_t cBATEntryIndex = cSector % pImage->cSectorsPerDataBlock;
1594 uint64_t uVhdOffset;
1595
1596 /*
1597 * Clip write range.
1598 */
1599 cbToWrite = RT_MIN(cbToWrite, (pImage->cbDataBlock - (cBATEntryIndex * VHD_SECTOR_SIZE)));
1600
1601 /*
1602 * If the block is not allocated the content of the entry is ~0
1603 * and we need to allocate a new block. Note that while blocks are
1604 * allocated with a relatively big granularity, each sector has its
1605 * own bitmap entry, indicating whether it has been written or not.
1606 * So that means for the purposes of the higher level that the
1607 * granularity is invisible. This means there's no need to return
1608 * VERR_VD_BLOCK_FREE unless the block hasn't been allocated yet.
1609 */
1610 if (pImage->pBlockAllocationTable[cBlockAllocationTableEntry] == ~0U)
1611 {
1612 /* Check if the block allocation should be suppressed. */
1613 if ( (fWrite & VD_WRITE_NO_ALLOC)
1614 || (cbToWrite != pImage->cbDataBlock))
1615 {
1616 *pcbPreRead = cBATEntryIndex * VHD_SECTOR_SIZE;
1617 *pcbPostRead = pImage->cSectorsPerDataBlock * VHD_SECTOR_SIZE - cbToWrite - *pcbPreRead;
1618
1619 if (pcbWriteProcess)
1620 *pcbWriteProcess = cbToWrite;
1621 return VERR_VD_BLOCK_FREE;
1622 }
1623
1624 PVHDIMAGEEXPAND pExpand = (PVHDIMAGEEXPAND)RTMemAllocZ(RT_OFFSETOF(VHDIMAGEEXPAND, au8Bitmap[pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE]));
1625 bool fIoInProgress = false;
1626
1627 if (!pExpand)
1628 return VERR_NO_MEMORY;
1629
1630 pExpand->cbEofOld = pImage->uCurrentEndOfFile;
1631 pExpand->idxBatAllocated = cBlockAllocationTableEntry;
1632 pExpand->idxBlockBe = RT_H2BE_U32(pImage->uCurrentEndOfFile / VHD_SECTOR_SIZE);
1633
1634 /* Set the bits for all sectors having been written. */
1635 for (uint32_t iSector = 0; iSector < (cbToWrite / VHD_SECTOR_SIZE); iSector++)
1636 {
1637 /* No need to check for a changed value because this is an initial write. */
1638 vhdBlockBitmapSectorSet(pImage, pExpand->au8Bitmap, cBATEntryIndex);
1639 cBATEntryIndex++;
1640 }
1641
1642 do
1643 {
1644 /*
1645 * Start with the sector bitmap.
1646 */
1647 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1648 pImage->uCurrentEndOfFile,
1649 pExpand->au8Bitmap,
1650 pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE, pIoCtx,
1651 vhdAsyncExpansionDataBlockBitmapComplete,
1652 pExpand);
1653 if (RT_SUCCESS(rc))
1654 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1655 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1656 fIoInProgress = true;
1657 else
1658 {
1659 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1660 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1661 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1662 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1663 break;
1664 }
1665
1666
1667 /*
1668 * Write the new block at the current end of the file.
1669 */
1670 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1671 pImage->uCurrentEndOfFile + (pImage->cDataBlockBitmapSectors + (cSector % pImage->cSectorsPerDataBlock)) * VHD_SECTOR_SIZE,
1672 pIoCtx, cbToWrite,
1673 vhdAsyncExpansionDataComplete,
1674 pExpand);
1675 if (RT_SUCCESS(rc))
1676 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1677 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1678 fIoInProgress = true;
1679 else
1680 {
1681 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1682 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1683 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1684 break;
1685 }
1686
1687 /*
1688 * Write entry in the BAT.
1689 */
1690 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1691 pImage->uBlockAllocationTableOffset + cBlockAllocationTableEntry * sizeof(uint32_t),
1692 &pExpand->idxBlockBe, sizeof(uint32_t), pIoCtx,
1693 vhdAsyncExpansionBatUpdateComplete,
1694 pExpand);
1695 if (RT_SUCCESS(rc))
1696 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1697 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1698 fIoInProgress = true;
1699 else
1700 {
1701 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1702 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1703 break;
1704 }
1705
1706 /*
1707 * Set the new end of the file and link the new block into the BAT.
1708 */
1709 pImage->uCurrentEndOfFile += pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE + pImage->cbDataBlock;
1710
1711 /* Update the footer. */
1712 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1713 pImage->uCurrentEndOfFile,
1714 &pImage->vhdFooterCopy,
1715 sizeof(VHDFooter), pIoCtx,
1716 vhdAsyncExpansionFooterUpdateComplete,
1717 pExpand);
1718 if (RT_SUCCESS(rc))
1719 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1720 else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1721 fIoInProgress = true;
1722 else
1723 {
1724 VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1725 break;
1726 }
1727
1728 } while (0);
1729
1730 if (!fIoInProgress)
1731 vhdAsyncExpansionComplete(pImage, pIoCtx, pExpand);
1732 else
1733 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1734 }
1735 else
1736 {
1737 /*
1738 * Calculate the real offset in the file.
1739 */
1740 uVhdOffset = ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry] + pImage->cDataBlockBitmapSectors + cBATEntryIndex) * VHD_SECTOR_SIZE;
1741
1742 /* Read in the block's bitmap. */
1743 PVDMETAXFER pMetaXfer;
1744 rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage,
1745 ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry]) * VHD_SECTOR_SIZE,
1746 pImage->pu8Bitmap,
1747 pImage->cbDataBlockBitmap, pIoCtx,
1748 &pMetaXfer, NULL, NULL);
1749 if (RT_SUCCESS(rc))
1750 {
1751 vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
1752
1753 /* Write data. */
1754 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1755 uVhdOffset, pIoCtx, cbToWrite,
1756 NULL, NULL);
1757 if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1758 {
1759 bool fChanged = false;
1760
1761 /* Set the bits for all sectors having been written. */
1762 for (uint32_t iSector = 0; iSector < (cbToWrite / VHD_SECTOR_SIZE); iSector++)
1763 {
1764 fChanged |= vhdBlockBitmapSectorSet(pImage, pImage->pu8Bitmap, cBATEntryIndex);
1765 cBATEntryIndex++;
1766 }
1767
1768 /* Only write the bitmap if it was changed. */
1769 if (fChanged)
1770 {
1771 /*
1772 * Write the bitmap back.
1773 *
1774 * @note We don't have a completion callback here because we
1775 * can't do anything if the write fails for some reason.
1776 * The error will propagated to the device/guest
1777 * by the generic VD layer already and we don't need
1778 * to rollback anything here.
1779 */
1780 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1781 ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry]) * VHD_SECTOR_SIZE,
1782 pImage->pu8Bitmap,
1783 pImage->cbDataBlockBitmap,
1784 pIoCtx, NULL, NULL);
1785 }
1786 }
1787 }
1788 }
1789 }
1790 else
1791 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1792 uOffset, pIoCtx, cbToWrite, NULL, NULL);
1793
1794 if (pcbWriteProcess)
1795 *pcbWriteProcess = cbToWrite;
1796
1797 /* Stay on the safe side. Do not run the risk of confusing the higher
1798 * level, as that can be pretty lethal to image consistency. */
1799 *pcbPreRead = 0;
1800 *pcbPostRead = 0;
1801
1802 return rc;
1803}
1804
1805/** @interface_method_impl{VDIMAGEBACKEND,pfnFlush} */
1806static DECLCALLBACK(int) vhdFlush(void *pBackendData, PVDIOCTX pIoCtx)
1807{
1808 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1809 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1810
1811 /* No need to write anything here. Data is always updated on a write. */
1812 int rc = vdIfIoIntFileFlush(pImage->pIfIo, pImage->pStorage, pIoCtx, NULL, NULL);
1813 LogFlowFunc(("returns %Rrc\n", rc));
1814 return rc;
1815}
1816
1817/** @interface_method_impl{VDIMAGEBACKEND,pfnGetVersion} */
1818static DECLCALLBACK(unsigned) vhdGetVersion(void *pBackendData)
1819{
1820 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1821 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1822
1823 AssertPtrReturn(pImage, 0);
1824
1825 unsigned uVersion = 1; /**< @todo use correct version */
1826
1827 LogFlowFunc(("returns %u\n", uVersion));
1828 return uVersion;
1829}
1830
1831/** @interface_method_impl{VDIMAGEBACKEND,pfnGetSectorSize} */
1832static DECLCALLBACK(uint32_t) vhdGetSectorSize(void *pBackendData)
1833{
1834 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1835 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1836 uint32_t cb = 0;
1837
1838 AssertPtrReturn(pImage, 0);
1839
1840 if (pImage->pStorage)
1841 cb = VHD_SECTOR_SIZE;
1842
1843 LogFlowFunc(("returns %zu\n", cb));
1844 return cb;
1845}
1846
1847/** @interface_method_impl{VDIMAGEBACKEND,pfnGetSize} */
1848static DECLCALLBACK(uint64_t) vhdGetSize(void *pBackendData)
1849{
1850 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1851 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1852 uint64_t cb = 0;
1853
1854 AssertPtr(pImage);
1855
1856 if (pImage && pImage->pStorage)
1857 cb = pImage->cbSize;
1858
1859 LogFlowFunc(("returns %llu\n", cb));
1860 return cb;
1861}
1862
1863/** @interface_method_impl{VDIMAGEBACKEND,pfnGetFileSize} */
1864static DECLCALLBACK(uint64_t) vhdGetFileSize(void *pBackendData)
1865{
1866 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1867 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1868 uint64_t cb = 0;
1869
1870 AssertPtrReturn(pImage, 0);
1871
1872 if (pImage->pStorage)
1873 cb = pImage->uCurrentEndOfFile + sizeof(VHDFooter);
1874
1875 LogFlowFunc(("returns %lld\n", cb));
1876 return cb;
1877}
1878
1879/** @interface_method_impl{VDIMAGEBACKEND,pfnGetPCHSGeometry} */
1880static DECLCALLBACK(int) vhdGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
1881{
1882 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1883 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1884 int rc = VINF_SUCCESS;
1885
1886 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
1887
1888 if (pImage->PCHSGeometry.cCylinders)
1889 *pPCHSGeometry = pImage->PCHSGeometry;
1890 else
1891 rc = VERR_VD_GEOMETRY_NOT_SET;
1892
1893 LogFlowFunc(("returns %Rrc (CHS=%u/%u/%u)\n", rc, pImage->PCHSGeometry.cCylinders,
1894 pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors));
1895 return rc;
1896}
1897
1898/** @interface_method_impl{VDIMAGEBACKEND,pfnSetPCHSGeometry} */
1899static DECLCALLBACK(int) vhdSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
1900{
1901 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
1902 pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1903 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1904 int rc = VINF_SUCCESS;
1905
1906 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
1907
1908 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1909 rc = VERR_VD_IMAGE_READ_ONLY;
1910 else
1911 pImage->PCHSGeometry = *pPCHSGeometry;
1912
1913 LogFlowFunc(("returns %Rrc\n", rc));
1914 return rc;
1915}
1916
1917/** @interface_method_impl{VDIMAGEBACKEND,pfnGetLCHSGeometry} */
1918static DECLCALLBACK(int) vhdGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
1919{
1920 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1921 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1922 int rc = VINF_SUCCESS;
1923
1924 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
1925
1926 if (pImage->LCHSGeometry.cCylinders)
1927 *pLCHSGeometry = pImage->LCHSGeometry;
1928 else
1929 rc = VERR_VD_GEOMETRY_NOT_SET;
1930
1931 LogFlowFunc(("returns %Rrc (CHS=%u/%u/%u)\n", rc, pImage->LCHSGeometry.cCylinders,
1932 pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors));
1933 return rc;
1934}
1935
1936/** @interface_method_impl{VDIMAGEBACKEND,pfnSetLCHSGeometry} */
1937static DECLCALLBACK(int) vhdSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
1938{
1939 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1940 int rc = VINF_SUCCESS;
1941
1942 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
1943
1944 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1945 rc = VERR_VD_IMAGE_READ_ONLY;
1946 else
1947 pImage->LCHSGeometry = *pLCHSGeometry;
1948
1949 LogFlowFunc(("returns %Rrc\n", rc));
1950 return rc;
1951}
1952
1953/** @interface_method_impl{VDIMAGEBACKEND,pfnGetImageFlags} */
1954static DECLCALLBACK(unsigned) vhdGetImageFlags(void *pBackendData)
1955{
1956 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1957 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1958
1959 AssertPtrReturn(pImage, 0);
1960
1961 LogFlowFunc(("returns %#x\n", pImage->uImageFlags));
1962 return pImage->uImageFlags;
1963}
1964
1965/** @interface_method_impl{VDIMAGEBACKEND,pfnGetOpenFlags} */
1966static DECLCALLBACK(unsigned) vhdGetOpenFlags(void *pBackendData)
1967{
1968 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1969 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1970
1971 AssertPtrReturn(pImage, 0);
1972
1973 LogFlowFunc(("returns %#x\n", pImage->uOpenFlags));
1974 return pImage->uOpenFlags;
1975}
1976
1977/** @interface_method_impl{VDIMAGEBACKEND,pfnSetOpenFlags} */
1978static DECLCALLBACK(int) vhdSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
1979{
1980 LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
1981 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1982 int rc = VINF_SUCCESS;
1983
1984 /* Image must be opened and the new flags must be valid. */
1985 if (!pImage || (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO
1986 | VD_OPEN_FLAGS_ASYNC_IO | VD_OPEN_FLAGS_SHAREABLE
1987 | VD_OPEN_FLAGS_SEQUENTIAL | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
1988 rc = VERR_INVALID_PARAMETER;
1989 else
1990 {
1991 /* Implement this operation via reopening the image. */
1992 rc = vhdFreeImage(pImage, false);
1993 if (RT_SUCCESS(rc))
1994 rc = vhdOpenImage(pImage, uOpenFlags);
1995 }
1996
1997 LogFlowFunc(("returns %Rrc\n", rc));
1998 return rc;
1999}
2000
2001/** @interface_method_impl{VDIMAGEBACKEND,pfnGetComment} */
2002static DECLCALLBACK(int) vhdGetComment(void *pBackendData, char *pszComment,
2003 size_t cbComment)
2004{
2005 RT_NOREF2(pszComment, cbComment);
2006 LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
2007 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2008
2009 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2010
2011 LogFlowFunc(("returns %Rrc comment='%s'\n", VERR_NOT_SUPPORTED, pszComment));
2012 return VERR_NOT_SUPPORTED;
2013}
2014
2015/** @interface_method_impl{VDIMAGEBACKEND,pfnSetComment} */
2016static DECLCALLBACK(int) vhdSetComment(void *pBackendData, const char *pszComment)
2017{
2018 RT_NOREF1(pszComment);
2019 LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
2020 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2021
2022 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2023
2024 int rc;
2025 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2026 rc = VERR_VD_IMAGE_READ_ONLY;
2027 else
2028 rc = VERR_NOT_SUPPORTED;
2029
2030 LogFlowFunc(("returns %Rrc\n", rc));
2031 return rc;
2032}
2033
2034/** @interface_method_impl{VDIMAGEBACKEND,pfnGetUuid} */
2035static DECLCALLBACK(int) vhdGetUuid(void *pBackendData, PRTUUID pUuid)
2036{
2037 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2038 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2039
2040 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2041
2042 *pUuid = pImage->ImageUuid;
2043
2044 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
2045 return VINF_SUCCESS;
2046}
2047
2048/** @interface_method_impl{VDIMAGEBACKEND,pfnSetUuid} */
2049static DECLCALLBACK(int) vhdSetUuid(void *pBackendData, PCRTUUID pUuid)
2050{
2051 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2052 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2053 int rc = VINF_SUCCESS;
2054
2055 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2056
2057 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2058 {
2059 pImage->ImageUuid = *pUuid;
2060 /* Update the footer copy. It will get written to disk when the image is closed. */
2061 memcpy(&pImage->vhdFooterCopy.UniqueID, pUuid, 16);
2062 /* Update checksum. */
2063 pImage->vhdFooterCopy.Checksum = 0;
2064 pImage->vhdFooterCopy.Checksum = RT_H2BE_U32(vhdChecksum(&pImage->vhdFooterCopy, sizeof(VHDFooter)));
2065
2066 /* Need to update the dynamic disk header to update the disk footer copy at the beginning. */
2067 if (!(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED))
2068 pImage->fDynHdrNeedsUpdate = true;
2069 }
2070 else
2071 rc = VERR_VD_IMAGE_READ_ONLY;
2072
2073 LogFlowFunc(("returns %Rrc\n", rc));
2074 return rc;
2075}
2076
2077/** @interface_method_impl{VDIMAGEBACKEND,pfnGetModificationUuid} */
2078static DECLCALLBACK(int) vhdGetModificationUuid(void *pBackendData, PRTUUID pUuid)
2079{
2080 RT_NOREF1(pUuid);
2081 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2082 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2083
2084 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2085
2086 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VERR_NOT_SUPPORTED, pUuid));
2087 return VERR_NOT_SUPPORTED;
2088}
2089
2090/** @interface_method_impl{VDIMAGEBACKEND,pfnSetModificationUuid} */
2091static DECLCALLBACK(int) vhdSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
2092{
2093 RT_NOREF1(pUuid);
2094 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2095 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2096
2097 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2098
2099 int rc;
2100 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2101 rc = VERR_VD_IMAGE_READ_ONLY;
2102 else
2103 rc = VERR_NOT_SUPPORTED;
2104
2105 LogFlowFunc(("returns %Rrc\n", rc));
2106 return rc;
2107}
2108
2109/** @interface_method_impl{VDIMAGEBACKEND,pfnGetParentUuid} */
2110static DECLCALLBACK(int) vhdGetParentUuid(void *pBackendData, PRTUUID pUuid)
2111{
2112 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2113 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2114
2115 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2116
2117 *pUuid = pImage->ParentUuid;
2118
2119 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
2120 return VINF_SUCCESS;
2121}
2122
2123/** @interface_method_impl{VDIMAGEBACKEND,pfnSetParentUuid} */
2124static DECLCALLBACK(int) vhdSetParentUuid(void *pBackendData, PCRTUUID pUuid)
2125{
2126 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2127 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2128 int rc = VINF_SUCCESS;
2129
2130 if (pImage && pImage->pStorage)
2131 {
2132 if (!(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED))
2133 {
2134 pImage->ParentUuid = *pUuid;
2135 pImage->fDynHdrNeedsUpdate = true;
2136 }
2137 else
2138 rc = VERR_VD_IMAGE_READ_ONLY;
2139 }
2140 else
2141 rc = VERR_VD_NOT_OPENED;
2142
2143 LogFlowFunc(("returns %Rrc\n", rc));
2144 return rc;
2145}
2146
2147/** @interface_method_impl{VDIMAGEBACKEND,pfnGetParentModificationUuid} */
2148static DECLCALLBACK(int) vhdGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
2149{
2150 RT_NOREF1(pUuid);
2151 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2152 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2153
2154 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2155
2156 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VERR_NOT_SUPPORTED, pUuid));
2157 return VERR_NOT_SUPPORTED;
2158}
2159
2160/** @interface_method_impl{VDIMAGEBACKEND,pfnSetParentModificationUuid} */
2161static DECLCALLBACK(int) vhdSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
2162{
2163 RT_NOREF1(pUuid);
2164 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2165 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2166
2167 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2168
2169 int rc;
2170 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2171 rc = VERR_VD_IMAGE_READ_ONLY;
2172 else
2173 rc = VERR_NOT_SUPPORTED;
2174
2175 LogFlowFunc(("returns %Rrc\n", rc));
2176 return rc;
2177}
2178
2179/** @interface_method_impl{VDIMAGEBACKEND,pfnDump} */
2180static DECLCALLBACK(void) vhdDump(void *pBackendData)
2181{
2182 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2183
2184 AssertPtrReturnVoid(pImage);
2185 vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%u\n",
2186 pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
2187 pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
2188 VHD_SECTOR_SIZE);
2189 vdIfErrorMessage(pImage->pIfError, "Header: uuidCreation={%RTuuid}\n", &pImage->ImageUuid);
2190 vdIfErrorMessage(pImage->pIfError, "Header: uuidParent={%RTuuid}\n", &pImage->ParentUuid);
2191}
2192
2193/** @interface_method_impl{VDIMAGEBACKEND,pfnGetTimestamp} */
2194static DECLCALLBACK(int) vhdGetTimestamp(void *pBackendData, PRTTIMESPEC pTimestamp)
2195{
2196 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2197
2198 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2199
2200 int rc = vdIfIoIntFileGetModificationTime(pImage->pIfIo, pImage->pszFilename, pTimestamp);
2201
2202 LogFlowFunc(("returns %Rrc\n", rc));
2203 return rc;
2204}
2205
2206/** @interface_method_impl{VDIMAGEBACKEND,pfnGetParentTimestamp} */
2207static DECLCALLBACK(int) vhdGetParentTimestamp(void *pBackendData, PRTTIMESPEC pTimestamp)
2208{
2209 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2210
2211 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2212
2213 vhdTime2RtTime(pTimestamp, pImage->u32ParentTimestamp);
2214 LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
2215 return VINF_SUCCESS;
2216}
2217
2218/** @interface_method_impl{VDIMAGEBACKEND,pfnSetParentTimestamp} */
2219static DECLCALLBACK(int) vhdSetParentTimestamp(void *pBackendData, PCRTTIMESPEC pTimestamp)
2220{
2221 int rc = VINF_SUCCESS;
2222 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2223
2224 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2225 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2226 rc = VERR_VD_IMAGE_READ_ONLY;
2227 else
2228 {
2229 pImage->u32ParentTimestamp = vhdRtTime2VhdTime(pTimestamp);
2230 pImage->fDynHdrNeedsUpdate = true;
2231 }
2232
2233 LogFlowFunc(("returns %Rrc\n", rc));
2234 return rc;
2235}
2236
2237/** @interface_method_impl{VDIMAGEBACKEND,pfnGetParentFilename} */
2238static DECLCALLBACK(int) vhdGetParentFilename(void *pBackendData, char **ppszParentFilename)
2239{
2240 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2241
2242 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2243 *ppszParentFilename = RTStrDup(pImage->pszParentFilename);
2244
2245 LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
2246 return VINF_SUCCESS;
2247}
2248
2249/** @interface_method_impl{VDIMAGEBACKEND,pfnSetParentFilename} */
2250static DECLCALLBACK(int) vhdSetParentFilename(void *pBackendData, const char *pszParentFilename)
2251{
2252 int rc = VINF_SUCCESS;
2253 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2254
2255 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
2256
2257 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2258 rc = VERR_VD_IMAGE_READ_ONLY;
2259 else
2260 {
2261 if (pImage->pszParentFilename)
2262 RTStrFree(pImage->pszParentFilename);
2263 pImage->pszParentFilename = RTStrDup(pszParentFilename);
2264 if (!pImage->pszParentFilename)
2265 rc = VERR_NO_MEMORY;
2266 else
2267 pImage->fDynHdrNeedsUpdate = true;
2268 }
2269
2270 LogFlowFunc(("returns %Rrc\n", rc));
2271 return rc;
2272}
2273
2274/** @interface_method_impl{VDIMAGEBACKEND,pfnCompact} */
2275static DECLCALLBACK(int) vhdCompact(void *pBackendData, unsigned uPercentStart,
2276 unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
2277 PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation)
2278{
2279 RT_NOREF2(pVDIfsDisk, pVDIfsImage);
2280 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2281 int rc = VINF_SUCCESS;
2282 void *pvBuf = NULL;
2283 uint32_t *paBlocks = NULL;
2284 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
2285
2286 DECLCALLBACKMEMBER(int, pfnParentRead)(void *, uint64_t, void *, size_t) = NULL;
2287 void *pvParent = NULL;
2288 PVDINTERFACEPARENTSTATE pIfParentState = VDIfParentStateGet(pVDIfsOperation);
2289 if (pIfParentState)
2290 {
2291 pfnParentRead = pIfParentState->pfnParentRead;
2292 pvParent = pIfParentState->Core.pvUser;
2293 }
2294
2295 do
2296 {
2297 AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
2298
2299 AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2300 rc = VERR_VD_IMAGE_READ_ONLY);
2301
2302 /* Reject fixed images as they don't have a BAT. */
2303 if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2304 {
2305 rc = VERR_NOT_SUPPORTED;
2306 break;
2307 }
2308
2309 if (pfnParentRead)
2310 {
2311 pvParent = RTMemTmpAlloc(pImage->cbDataBlock);
2312 AssertBreakStmt(pvParent, rc = VERR_NO_MEMORY);
2313 }
2314 pvBuf = RTMemTmpAlloc(pImage->cbDataBlock);
2315 AssertBreakStmt(pvBuf, rc = VERR_NO_MEMORY);
2316
2317 unsigned cBlocksAllocated = 0;
2318 unsigned cBlocksToMove = 0;
2319 unsigned cBlocks = pImage->cBlockAllocationTableEntries;
2320 uint32_t offBlocksStart = ~0U; /* Start offset of data blocks in sectors. */
2321 uint32_t *paBat = pImage->pBlockAllocationTable;
2322
2323 /* Count the number of allocated blocks and find the start offset for the data blocks. */
2324 for (unsigned i = 0; i < cBlocks; i++)
2325 if (paBat[i] != ~0U)
2326 {
2327 cBlocksAllocated++;
2328 if (paBat[i] < offBlocksStart)
2329 offBlocksStart = paBat[i];
2330 }
2331
2332 if (!cBlocksAllocated)
2333 {
2334 /* Nothing to do. */
2335 rc = VINF_SUCCESS;
2336 break;
2337 }
2338
2339 paBlocks = (uint32_t *)RTMemTmpAllocZ(cBlocksAllocated * sizeof(uint32_t));
2340 AssertBreakStmt(paBlocks, rc = VERR_NO_MEMORY);
2341
2342 /* Invalidate the back resolving array. */
2343 for (unsigned i = 0; i < cBlocksAllocated; i++)
2344 paBlocks[i] = ~0U;
2345
2346 /* Fill the back resolving table. */
2347 for (unsigned i = 0; i < cBlocks; i++)
2348 if (paBat[i] != ~0U)
2349 {
2350 unsigned idxBlock = (paBat[i] - offBlocksStart) / pImage->cSectorsPerDataBlock;
2351 if ( idxBlock < cBlocksAllocated
2352 && paBlocks[idxBlock] == ~0U)
2353 paBlocks[idxBlock] = i;
2354 else
2355 {
2356 /* The image is in an inconsistent state. Don't go further. */
2357 rc = VERR_INVALID_STATE;
2358 break;
2359 }
2360 }
2361
2362 if (RT_FAILURE(rc))
2363 break;
2364
2365 /* Find redundant information and update the block pointers
2366 * accordingly, creating bubbles. Keep disk up to date, as this
2367 * enables cancelling. */
2368 for (unsigned i = 0; i < cBlocks; i++)
2369 {
2370 if (paBat[i] != ~0U)
2371 {
2372 unsigned idxBlock = (paBat[i] - offBlocksStart) / pImage->cSectorsPerDataBlock;
2373
2374 /* Block present in image file, read relevant data. */
2375 uint64_t u64Offset = ((uint64_t)paBat[i] + pImage->cDataBlockBitmapSectors) * VHD_SECTOR_SIZE;
2376 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2377 u64Offset, pvBuf, pImage->cbDataBlock);
2378 if (RT_FAILURE(rc))
2379 break;
2380
2381 if (ASMBitFirstSet((volatile void *)pvBuf, (uint32_t)pImage->cbDataBlock * 8) == -1)
2382 {
2383 paBat[i] = UINT32_MAX;
2384 paBlocks[idxBlock] = ~0U;
2385 /* Adjust progress info, one block to be relocated. */
2386 cBlocksToMove++;
2387 }
2388 else if (pfnParentRead)
2389 {
2390 rc = pfnParentRead(pvParent, (uint64_t)i * pImage->cbDataBlock, pvParent, pImage->cbDataBlock);
2391 if (RT_FAILURE(rc))
2392 break;
2393 if (!memcmp(pvParent, pvBuf, pImage->cbDataBlock))
2394 {
2395 paBat[i] = ~0U;
2396 paBlocks[idxBlock] = ~0U;
2397 /* Adjust progress info, one block to be relocated. */
2398 cBlocksToMove++;
2399 }
2400 }
2401 }
2402
2403 vdIfProgress(pIfProgress, (uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2404 }
2405
2406 if (RT_SUCCESS(rc))
2407 {
2408 /* Fill bubbles with other data (if available). */
2409 unsigned cBlocksMoved = 0;
2410 unsigned uBlockUsedPos = cBlocksAllocated;
2411 size_t cbBlock = pImage->cbDataBlock + pImage->cbDataBlockBitmap; /** < Size of whole block containing the bitmap and the user data. */
2412
2413 /* Allocate data buffer to hold the data block and allocation bitmap in front of the actual data. */
2414 RTMemTmpFree(pvBuf);
2415 pvBuf = RTMemTmpAllocZ(cbBlock);
2416 AssertBreakStmt(pvBuf, rc = VERR_NO_MEMORY);
2417
2418 for (unsigned i = 0; i < cBlocksAllocated; i++)
2419 {
2420 unsigned uBlock = paBlocks[i];
2421 if (uBlock == ~0U)
2422 {
2423 unsigned uBlockData = ~0U;
2424 while (uBlockUsedPos > i && uBlockData == ~0U)
2425 {
2426 uBlockUsedPos--;
2427 uBlockData = paBlocks[uBlockUsedPos];
2428 }
2429 /* Terminate early if there is no block which needs copying. */
2430 if (uBlockUsedPos == i)
2431 break;
2432 uint64_t u64Offset = (uint64_t)uBlockUsedPos * cbBlock
2433 + (offBlocksStart * VHD_SECTOR_SIZE);
2434 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2435 u64Offset, pvBuf, cbBlock);
2436 if (RT_FAILURE(rc))
2437 break;
2438
2439 u64Offset = (uint64_t)i * cbBlock
2440 + (offBlocksStart * VHD_SECTOR_SIZE);
2441 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2442 u64Offset, pvBuf, cbBlock);
2443 if (RT_FAILURE(rc))
2444 break;
2445
2446 paBat[uBlockData] = i*(pImage->cSectorsPerDataBlock + pImage->cDataBlockBitmapSectors) + offBlocksStart;
2447
2448 /* Truncate the file but leave enough room for the footer to avoid
2449 * races if other processes fill the whole harddisk. */
2450 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
2451 pImage->uCurrentEndOfFile - cbBlock + VHD_SECTOR_SIZE);
2452 if (RT_FAILURE(rc))
2453 break;
2454
2455 /* Update pointers and write footer. */
2456 pImage->uCurrentEndOfFile -= cbBlock;
2457
2458 /* We're kinda screwed if this failes. */
2459 rc = vhdUpdateFooter(pImage);
2460 if (RT_FAILURE(rc))
2461 break;
2462
2463 paBlocks[i] = uBlockData;
2464 paBlocks[uBlockUsedPos] = ~0U;
2465 cBlocksMoved++;
2466 }
2467
2468 rc = vdIfProgress(pIfProgress, (uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2469 }
2470 }
2471
2472 /* Write the new BAT in any case. */
2473 rc = vhdFlushImage(pImage);
2474 } while (0);
2475
2476 if (paBlocks)
2477 RTMemTmpFree(paBlocks);
2478 if (pvParent)
2479 RTMemTmpFree(pvParent);
2480 if (pvBuf)
2481 RTMemTmpFree(pvBuf);
2482
2483 if (RT_SUCCESS(rc))
2484 vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
2485
2486 LogFlowFunc(("returns %Rrc\n", rc));
2487 return rc;
2488}
2489
2490/** @interface_method_impl{VDIMAGEBACKEND,pfnResize} */
2491static DECLCALLBACK(int) vhdResize(void *pBackendData, uint64_t cbSize,
2492 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
2493 unsigned uPercentStart, unsigned uPercentSpan,
2494 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
2495 PVDINTERFACE pVDIfsOperation)
2496{
2497 RT_NOREF5(uPercentSpan, uPercentStart, pVDIfsDisk, pVDIfsImage, pVDIfsOperation);
2498 PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2499 int rc = VINF_SUCCESS;
2500
2501 /* Making the image smaller is not supported at the moment. */
2502 if ( cbSize < pImage->cbSize
2503 || pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2504 rc = VERR_NOT_SUPPORTED;
2505 else if (cbSize > pImage->cbSize)
2506 {
2507 unsigned cBlocksAllocated = 0;
2508 size_t cbBlock = pImage->cbDataBlock + pImage->cbDataBlockBitmap; /** < Size of a block including the sector bitmap. */
2509 uint32_t cBlocksNew = cbSize / pImage->cbDataBlock; /** < New number of blocks in the image after the resize */
2510 if (cbSize % pImage->cbDataBlock)
2511 cBlocksNew++;
2512
2513 uint32_t cBlocksOld = pImage->cBlockAllocationTableEntries; /** < Number of blocks before the resize. */
2514 uint64_t cbBlockspaceNew = RT_ALIGN_32(cBlocksNew * sizeof(uint32_t), VHD_SECTOR_SIZE); /** < Required space for the block array after the resize. */
2515 uint64_t offStartDataNew = RT_ALIGN_32(pImage->uBlockAllocationTableOffset + cbBlockspaceNew, VHD_SECTOR_SIZE); /** < New start offset for block data after the resize */
2516 uint64_t offStartDataOld = ~0ULL;
2517
2518 /* Go through the BAT and find the data start offset. */
2519 for (unsigned idxBlock = 0; idxBlock < pImage->cBlockAllocationTableEntries; idxBlock++)
2520 {
2521 if (pImage->pBlockAllocationTable[idxBlock] != ~0U)
2522 {
2523 uint64_t offStartBlock = (uint64_t)pImage->pBlockAllocationTable[idxBlock] * VHD_SECTOR_SIZE;
2524 if (offStartBlock < offStartDataOld)
2525 offStartDataOld = offStartBlock;
2526 cBlocksAllocated++;
2527 }
2528 }
2529
2530 if ( offStartDataOld != offStartDataNew
2531 && cBlocksAllocated > 0)
2532 {
2533 /* Calculate how many sectors nee to be relocated. */
2534 uint64_t cbOverlapping = offStartDataNew - offStartDataOld;
2535 unsigned cBlocksReloc = (unsigned)(cbOverlapping / cbBlock);
2536 if (cbOverlapping % cbBlock)
2537 cBlocksReloc++;
2538
2539 cBlocksReloc = RT_MIN(cBlocksReloc, cBlocksAllocated);
2540 offStartDataNew = offStartDataOld;
2541
2542 /* Do the relocation. */
2543 LogFlow(("Relocating %u blocks\n", cBlocksReloc));
2544
2545 /*
2546 * Get the blocks we need to relocate first, they are appended to the end
2547 * of the image.
2548 */
2549 void *pvBuf = NULL, *pvZero = NULL;
2550 do
2551 {
2552 /* Allocate data buffer. */
2553 pvBuf = RTMemAllocZ(cbBlock);
2554 if (!pvBuf)
2555 {
2556 rc = VERR_NO_MEMORY;
2557 break;
2558 }
2559
2560 /* Allocate buffer for overwriting with zeroes. */
2561 pvZero = RTMemAllocZ(cbBlock);
2562 if (!pvZero)
2563 {
2564 rc = VERR_NO_MEMORY;
2565 break;
2566 }
2567
2568 for (unsigned i = 0; i < cBlocksReloc; i++)
2569 {
2570 uint32_t uBlock = offStartDataNew / VHD_SECTOR_SIZE;
2571
2572 /* Search the index in the block table. */
2573 for (unsigned idxBlock = 0; idxBlock < cBlocksOld; idxBlock++)
2574 {
2575 if (pImage->pBlockAllocationTable[idxBlock] == uBlock)
2576 {
2577 /* Read data and append to the end of the image. */
2578 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2579 offStartDataNew, pvBuf, cbBlock);
2580 if (RT_FAILURE(rc))
2581 break;
2582
2583 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2584 pImage->uCurrentEndOfFile, pvBuf, cbBlock);
2585 if (RT_FAILURE(rc))
2586 break;
2587
2588 /* Zero out the old block area. */
2589 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2590 offStartDataNew, pvZero, cbBlock);
2591 if (RT_FAILURE(rc))
2592 break;
2593
2594 /* Update block counter. */
2595 pImage->pBlockAllocationTable[idxBlock] = pImage->uCurrentEndOfFile / VHD_SECTOR_SIZE;
2596
2597 pImage->uCurrentEndOfFile += cbBlock;
2598
2599 /* Continue with the next block. */
2600 break;
2601 }
2602 }
2603
2604 if (RT_FAILURE(rc))
2605 break;
2606
2607 offStartDataNew += cbBlock;
2608 }
2609 } while (0);
2610
2611 if (pvBuf)
2612 RTMemFree(pvBuf);
2613 if (pvZero)
2614 RTMemFree(pvZero);
2615 }
2616
2617 /*
2618 * Relocation done, expand the block array and update the header with
2619 * the new data.
2620 */
2621 if (RT_SUCCESS(rc))
2622 {
2623 uint32_t *paBlocksNew = (uint32_t *)RTMemRealloc(pImage->pBlockAllocationTable, cBlocksNew * sizeof(uint32_t));
2624 if (paBlocksNew)
2625 {
2626 pImage->pBlockAllocationTable = paBlocksNew;
2627
2628 /* Mark the new blocks as unallocated. */
2629 for (unsigned idxBlock = cBlocksOld; idxBlock < cBlocksNew; idxBlock++)
2630 pImage->pBlockAllocationTable[idxBlock] = ~0U;
2631 }
2632 else
2633 rc = VERR_NO_MEMORY;
2634
2635 if (RT_SUCCESS(rc))
2636 {
2637 /* Write the block array before updating the rest. */
2638 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2639 pImage->uBlockAllocationTableOffset,
2640 pImage->pBlockAllocationTable,
2641 cBlocksNew * sizeof(uint32_t));
2642 }
2643
2644 if (RT_SUCCESS(rc))
2645 {
2646 /* Update size and new block count. */
2647 pImage->cBlockAllocationTableEntries = cBlocksNew;
2648 pImage->cbSize = cbSize;
2649
2650 /* Update geometry. */
2651 pImage->PCHSGeometry = *pPCHSGeometry;
2652 pImage->LCHSGeometry = *pLCHSGeometry;
2653 }
2654 }
2655
2656 /* Update header information in base image file. */
2657 pImage->fDynHdrNeedsUpdate = true;
2658 vhdFlushImage(pImage);
2659 }
2660 /* Same size doesn't change the image at all. */
2661
2662 LogFlowFunc(("returns %Rrc\n", rc));
2663 return rc;
2664}
2665
2666/** @interface_method_impl{VDIMAGEBACKEND,pfnRepair} */
2667static DECLCALLBACK(int) vhdRepair(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
2668 PVDINTERFACE pVDIfsImage, uint32_t fFlags)
2669{
2670 LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
2671 int rc;
2672 PVDINTERFACEERROR pIfError;
2673 PVDINTERFACEIOINT pIfIo;
2674 PVDIOSTORAGE pStorage;
2675 uint64_t cbFile;
2676 VHDFooter vhdFooter;
2677 VHDDynamicDiskHeader dynamicDiskHeader;
2678 uint32_t *paBat = NULL;
2679 uint32_t *pu32BlockBitmap = NULL;
2680
2681 pIfIo = VDIfIoIntGet(pVDIfsImage);
2682 AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
2683
2684 pIfError = VDIfErrorGet(pVDIfsDisk);
2685
2686 do
2687 {
2688 uint64_t offDynamicDiskHeader = 0;
2689 uint64_t offBat = 0;
2690 uint64_t offFooter = 0;
2691 uint32_t cBatEntries = 0;
2692 bool fDynamic = false;
2693 bool fRepairFooter = false;
2694 bool fRepairBat = false;
2695 bool fRepairDynHeader = false;
2696
2697 rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
2698 VDOpenFlagsToFileOpenFlags( fFlags & VD_REPAIR_DRY_RUN
2699 ? VD_OPEN_FLAGS_READONLY
2700 : 0,
2701 false /* fCreate */),
2702 &pStorage);
2703 if (RT_FAILURE(rc))
2704 {
2705 rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to open image \"%s\"", pszFilename);
2706 break;
2707 }
2708
2709 rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
2710 if (RT_FAILURE(rc))
2711 {
2712 rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to query image size");
2713 break;
2714 }
2715
2716 if (cbFile < sizeof(VHDFooter))
2717 {
2718 rc = vdIfError(pIfError, VERR_VD_INVALID_SIZE, RT_SRC_POS,
2719 "Image must be at least %u bytes (got %llu)",
2720 sizeof(VHDFooter), cbFile);
2721 break;
2722 }
2723
2724 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, cbFile - sizeof(VHDFooter),
2725 &vhdFooter, sizeof(VHDFooter));
2726 if (RT_FAILURE(rc))
2727 {
2728 rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to read footer of image");
2729 break;
2730 }
2731
2732 if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
2733 {
2734 /* Dynamic images have a backup at the beginning of the image. */
2735 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0,
2736 &vhdFooter, sizeof(VHDFooter));
2737 if (RT_FAILURE(rc))
2738 {
2739 rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to read header of image");
2740 break;
2741 }
2742
2743 /*
2744 * Check for the header, if this fails the image is either completely corrupted
2745 * and impossible to repair or in another format.
2746 */
2747 if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
2748 {
2749 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2750 "No valid VHD structures found");
2751 break;
2752 }
2753 else
2754 vdIfErrorMessage(pIfError, "Missing footer structure, using backup\n");
2755
2756 /* Remember to fix the footer structure. */
2757 fRepairFooter = true;
2758 }
2759
2760 offFooter = cbFile - sizeof(VHDFooter);
2761
2762 /* Verify that checksums match. */
2763 uint32_t u32ChkSumOld = RT_BE2H_U32(vhdFooter.Checksum);
2764 vhdFooter.Checksum = 0;
2765 uint32_t u32ChkSum = vhdChecksum(&vhdFooter, sizeof(VHDFooter));
2766
2767 vhdFooter.Checksum = RT_H2BE_U32(u32ChkSum);
2768
2769 if (u32ChkSumOld != u32ChkSum)
2770 {
2771 vdIfErrorMessage(pIfError, "Checksum is invalid (should be %u got %u), repairing\n",
2772 u32ChkSum, u32ChkSumOld);
2773 fRepairFooter = true;
2774 break;
2775 }
2776
2777 switch (RT_BE2H_U32(vhdFooter.DiskType))
2778 {
2779 case VHD_FOOTER_DISK_TYPE_FIXED:
2780 fDynamic = false;
2781 break;
2782 case VHD_FOOTER_DISK_TYPE_DYNAMIC:
2783 fDynamic = true;
2784 break;
2785 case VHD_FOOTER_DISK_TYPE_DIFFERENCING:
2786 fDynamic = true;
2787 break;
2788 default:
2789 {
2790 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2791 "VHD image type %u is not supported",
2792 RT_BE2H_U32(vhdFooter.DiskType));
2793 break;
2794 }
2795 }
2796
2797 /* Load and check dynamic disk header if required. */
2798 if (fDynamic)
2799 {
2800 size_t cbBlock;
2801
2802 offDynamicDiskHeader = RT_BE2H_U64(vhdFooter.DataOffset);
2803 if (offDynamicDiskHeader + sizeof(VHDDynamicDiskHeader) > cbFile)
2804 {
2805 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2806 "VHD image type is not supported");
2807 break;
2808 }
2809
2810 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, offDynamicDiskHeader,
2811 &dynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
2812 if (RT_FAILURE(rc))
2813 {
2814 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2815 "Failed to read dynamic disk header (at %llu), %Rrc",
2816 offDynamicDiskHeader, rc);
2817 break;
2818 }
2819
2820 /* Verify that checksums match. */
2821 u32ChkSumOld = RT_BE2H_U32(dynamicDiskHeader.Checksum);
2822 dynamicDiskHeader.Checksum = 0;
2823 u32ChkSum = vhdChecksum(&dynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
2824
2825 dynamicDiskHeader.Checksum = RT_H2BE_U32(u32ChkSum);
2826
2827 if (u32ChkSumOld != u32ChkSum)
2828 {
2829 vdIfErrorMessage(pIfError, "Checksum of dynamic disk header is invalid (should be %u got %u), repairing\n",
2830 u32ChkSum, u32ChkSumOld);
2831 fRepairDynHeader = true;
2832 break;
2833 }
2834
2835 /* Read the block allocation table and fix any inconsistencies. */
2836 offBat = RT_BE2H_U64(dynamicDiskHeader.TableOffset);
2837 cBatEntries = RT_BE2H_U32(dynamicDiskHeader.MaxTableEntries);
2838 cbBlock = RT_BE2H_U32(dynamicDiskHeader.BlockSize);
2839 cbBlock += cbBlock / VHD_SECTOR_SIZE / 8;
2840
2841 if (offBat + cBatEntries * sizeof(uint32_t) > cbFile)
2842 {
2843 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2844 "Block allocation table is not inside the image");
2845 break;
2846 }
2847
2848 paBat = (uint32_t *)RTMemAllocZ(cBatEntries * sizeof(uint32_t));
2849 if (!paBat)
2850 {
2851 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2852 "Could not allocate memory for the block allocation table (%u bytes)",
2853 cBatEntries * sizeof(uint32_t));
2854 break;
2855 }
2856
2857 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, offBat, paBat,
2858 cBatEntries * sizeof(uint32_t));
2859 if (RT_FAILURE(rc))
2860 {
2861 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2862 "Could not read block allocation table (at %llu), %Rrc",
2863 offBat, rc);
2864 break;
2865 }
2866
2867 pu32BlockBitmap = (uint32_t *)RTMemAllocZ(RT_ALIGN_Z(cBatEntries / 8, 4));
2868 if (!pu32BlockBitmap)
2869 {
2870 rc = vdIfError(pIfError, VERR_NO_MEMORY, RT_SRC_POS,
2871 "Failed to allocate memory for block bitmap");
2872 break;
2873 }
2874
2875 uint32_t idxMinBlock = UINT32_C(0xffffffff);
2876 for (uint32_t i = 0; i < cBatEntries; i++)
2877 {
2878 paBat[i] = RT_BE2H_U32(paBat[i]);
2879 if (paBat[i] < idxMinBlock)
2880 idxMinBlock = paBat[i];
2881 }
2882
2883 vdIfErrorMessage(pIfError, "First data block at sector %u\n", idxMinBlock);
2884
2885 for (uint32_t i = 0; i < cBatEntries; i++)
2886 {
2887 if (paBat[i] != UINT32_C(0xffffffff))
2888 {
2889 uint64_t offBlock =(uint64_t)paBat[i] * VHD_SECTOR_SIZE;
2890
2891 /*
2892 * Check that the offsets are valid (inside of the image) and
2893 * that there are no double references.
2894 */
2895 if (offBlock + cbBlock > cbFile)
2896 {
2897 vdIfErrorMessage(pIfError, "Entry %u points to invalid offset %llu, clearing\n",
2898 i, offBlock);
2899 paBat[i] = UINT32_C(0xffffffff);
2900 fRepairBat = true;
2901 }
2902 else if (offBlock + cbBlock > offFooter)
2903 {
2904 vdIfErrorMessage(pIfError, "Entry %u intersects with footer, aligning footer\n",
2905 i);
2906 offFooter = offBlock + cbBlock;
2907 fRepairBat = true;
2908 }
2909
2910 if ( paBat[i] != UINT32_C(0xffffffff)
2911 && ASMBitTestAndSet(pu32BlockBitmap, (uint32_t)((paBat[i] - idxMinBlock) / (cbBlock / VHD_SECTOR_SIZE))))
2912 {
2913 vdIfErrorMessage(pIfError, "Entry %u points to an already referenced data block, clearing\n",
2914 i);
2915 paBat[i] = UINT32_C(0xffffffff);
2916 fRepairBat = true;
2917 }
2918 }
2919 }
2920 }
2921
2922 /* Write repaired structures now. */
2923 if (!(fRepairBat || fRepairDynHeader || fRepairFooter))
2924 vdIfErrorMessage(pIfError, "VHD image is in a consistent state, no repair required\n");
2925 else if (!(fFlags & VD_REPAIR_DRY_RUN))
2926 {
2927 if (fRepairBat)
2928 {
2929 for (uint32_t i = 0; i < cBatEntries; i++)
2930 paBat[i] = RT_H2BE_U32(paBat[i]);
2931
2932 vdIfErrorMessage(pIfError, "Writing repaired block allocation table...\n");
2933
2934 rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offBat, paBat,
2935 cBatEntries * sizeof(uint32_t));
2936 if (RT_FAILURE(rc))
2937 {
2938 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2939 "Could not write repaired block allocation table (at %llu), %Rrc",
2940 offBat, rc);
2941 break;
2942 }
2943 }
2944
2945 if (fRepairDynHeader)
2946 {
2947 Assert(fDynamic);
2948
2949 vdIfErrorMessage(pIfError, "Writing repaired dynamic disk header...\n");
2950 rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offDynamicDiskHeader, &dynamicDiskHeader,
2951 sizeof(VHDDynamicDiskHeader));
2952 if (RT_FAILURE(rc))
2953 {
2954 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2955 "Could not write repaired dynamic disk header (at %llu), %Rrc",
2956 offDynamicDiskHeader, rc);
2957 break;
2958 }
2959 }
2960
2961 if (fRepairFooter)
2962 {
2963 vdIfErrorMessage(pIfError, "Writing repaired Footer...\n");
2964
2965 if (fDynamic)
2966 {
2967 /* Write backup at image beginning. */
2968 rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, 0, &vhdFooter,
2969 sizeof(VHDFooter));
2970 if (RT_FAILURE(rc))
2971 {
2972 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2973 "Could not write repaired backup footer (at %llu), %Rrc",
2974 0, rc);
2975 break;
2976 }
2977 }
2978
2979 rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offFooter, &vhdFooter,
2980 sizeof(VHDFooter));
2981 if (RT_FAILURE(rc))
2982 {
2983 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2984 "Could not write repaired footer (at %llu), %Rrc",
2985 cbFile - sizeof(VHDFooter), rc);
2986 break;
2987 }
2988 }
2989
2990 vdIfErrorMessage(pIfError, "Corrupted VHD image repaired successfully\n");
2991 }
2992 } while(0);
2993
2994 if (paBat)
2995 RTMemFree(paBat);
2996
2997 if (pu32BlockBitmap)
2998 RTMemFree(pu32BlockBitmap);
2999
3000 if (pStorage)
3001 {
3002 int rc2 = vdIfIoIntFileClose(pIfIo, pStorage);
3003 if (RT_SUCCESS(rc))
3004 rc = rc2; /* Propagate status code only when repairing the image was successful. */
3005 }
3006
3007 LogFlowFunc(("returns %Rrc\n", rc));
3008 return rc;
3009}
3010
3011
3012const VDIMAGEBACKEND g_VhdBackend =
3013{
3014 /* u32Version */
3015 VD_IMGBACKEND_VERSION,
3016 /* pszBackendName */
3017 "VHD",
3018 /* uBackendCaps */
3019 VD_CAP_UUID | VD_CAP_DIFF | VD_CAP_FILE |
3020 VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC |
3021 VD_CAP_ASYNC | VD_CAP_VFS | VD_CAP_PREFERRED,
3022 /* paFileExtensions */
3023 s_aVhdFileExtensions,
3024 /* paConfigInfo */
3025 NULL,
3026 /* pfnProbe */
3027 vhdProbe,
3028 /* pfnOpen */
3029 vhdOpen,
3030 /* pfnCreate */
3031 vhdCreate,
3032 /* pfnRename */
3033 vhdRename,
3034 /* pfnClose */
3035 vhdClose,
3036 /* pfnRead */
3037 vhdRead,
3038 /* pfnWrite */
3039 vhdWrite,
3040 /* pfnFlush */
3041 vhdFlush,
3042 /* pfnDiscard */
3043 NULL,
3044 /* pfnGetVersion */
3045 vhdGetVersion,
3046 /* pfnGetSectorSize */
3047 vhdGetSectorSize,
3048 /* pfnGetSize */
3049 vhdGetSize,
3050 /* pfnGetFileSize */
3051 vhdGetFileSize,
3052 /* pfnGetPCHSGeometry */
3053 vhdGetPCHSGeometry,
3054 /* pfnSetPCHSGeometry */
3055 vhdSetPCHSGeometry,
3056 /* pfnGetLCHSGeometry */
3057 vhdGetLCHSGeometry,
3058 /* pfnSetLCHSGeometry */
3059 vhdSetLCHSGeometry,
3060 /* pfnGetImageFlags */
3061 vhdGetImageFlags,
3062 /* pfnGetOpenFlags */
3063 vhdGetOpenFlags,
3064 /* pfnSetOpenFlags */
3065 vhdSetOpenFlags,
3066 /* pfnGetComment */
3067 vhdGetComment,
3068 /* pfnSetComment */
3069 vhdSetComment,
3070 /* pfnGetUuid */
3071 vhdGetUuid,
3072 /* pfnSetUuid */
3073 vhdSetUuid,
3074 /* pfnGetModificationUuid */
3075 vhdGetModificationUuid,
3076 /* pfnSetModificationUuid */
3077 vhdSetModificationUuid,
3078 /* pfnGetParentUuid */
3079 vhdGetParentUuid,
3080 /* pfnSetParentUuid */
3081 vhdSetParentUuid,
3082 /* pfnGetParentModificationUuid */
3083 vhdGetParentModificationUuid,
3084 /* pfnSetParentModificationUuid */
3085 vhdSetParentModificationUuid,
3086 /* pfnDump */
3087 vhdDump,
3088 /* pfnGetTimestamp */
3089 vhdGetTimestamp,
3090 /* pfnGetParentTimestamp */
3091 vhdGetParentTimestamp,
3092 /* pfnSetParentTimestamp */
3093 vhdSetParentTimestamp,
3094 /* pfnGetParentFilename */
3095 vhdGetParentFilename,
3096 /* pfnSetParentFilename */
3097 vhdSetParentFilename,
3098 /* pfnComposeLocation */
3099 genericFileComposeLocation,
3100 /* pfnComposeName */
3101 genericFileComposeName,
3102 /* pfnCompact */
3103 vhdCompact,
3104 /* pfnResize */
3105 vhdResize,
3106 /* pfnRepair */
3107 vhdRepair,
3108 /* pfnTraverseMetadata */
3109 NULL,
3110 /* u32VersionEnd */
3111 VD_IMGBACKEND_VERSION
3112};
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