VirtualBox

source: vbox/trunk/src/VBox/Storage/VDI.cpp@ 53409

Last change on this file since 53409 was 50988, checked in by vboxsync, 11 years ago

Storage/VD: Cleanup VD plugin handling. One shared object can now support an arbitrary number of image backends instead of just one like before
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 119.0 KB
Line 
1/* $Id: VDI.cpp 50988 2014-04-07 19:36:54Z vboxsync $ */
2/** @file
3 * Virtual Disk Image (VDI), Core Code.
4 */
5
6/*
7 * Copyright (C) 2006-2013 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* Header Files *
20*******************************************************************************/
21#define LOG_GROUP LOG_GROUP_VD_VDI
22#include <VBox/vd-plugin.h>
23#include "VDICore.h"
24#include <VBox/err.h>
25
26#include <VBox/log.h>
27#include <iprt/alloc.h>
28#include <iprt/assert.h>
29#include <iprt/uuid.h>
30#include <iprt/string.h>
31#include <iprt/asm.h>
32
33#include "VDBackends.h"
34
35#define VDI_IMAGE_DEFAULT_BLOCK_SIZE _1M
36
37/** Macros for endianess conversion. */
38#define SET_ENDIAN_U32(conv, u32) (conv == VDIECONV_H2F ? RT_H2LE_U32(u32) : RT_LE2H_U32(u32))
39#define SET_ENDIAN_U64(conv, u64) (conv == VDIECONV_H2F ? RT_H2LE_U64(u64) : RT_LE2H_U64(u64))
40
41/*******************************************************************************
42* Static Variables *
43*******************************************************************************/
44
45/** NULL-terminated array of supported file extensions. */
46static const VDFILEEXTENSION s_aVdiFileExtensions[] =
47{
48 {"vdi", VDTYPE_HDD},
49 {NULL, VDTYPE_INVALID}
50};
51
52/*******************************************************************************
53* Internal Functions *
54*******************************************************************************/
55static unsigned getPowerOfTwo(unsigned uNumber);
56static void vdiInitPreHeader(PVDIPREHEADER pPreHdr);
57static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr);
58static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
59 const char *pszComment, uint64_t cbDisk,
60 uint32_t cbBlock, uint32_t cbBlockExtra);
61static int vdiValidateHeader(PVDIHEADER pHeader);
62static void vdiSetupImageDesc(PVDIIMAGEDESC pImage);
63static int vdiUpdateHeader(PVDIIMAGEDESC pImage);
64static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock);
65static int vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx);
66static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock, PVDIOCTX pIoCtx,
67 bool fUpdateHdr);
68
69/**
70 * Internal: Convert the PreHeader fields to the appropriate endianess.
71 * @param enmConv Direction of the conversion.
72 * @param pPreHdrConv Where to store the converted pre header.
73 * @param pPreHdr PreHeader pointer.
74 */
75static void vdiConvPreHeaderEndianess(VDIECONV enmConv, PVDIPREHEADER pPreHdrConv,
76 PVDIPREHEADER pPreHdr)
77{
78 memcpy(pPreHdrConv->szFileInfo, pPreHdr->szFileInfo, sizeof(pPreHdr->szFileInfo));
79 pPreHdrConv->u32Signature = SET_ENDIAN_U32(enmConv, pPreHdr->u32Signature);
80 pPreHdrConv->u32Version = SET_ENDIAN_U32(enmConv, pPreHdr->u32Version);
81}
82
83/**
84 * Internal: Convert the VDIDISKGEOMETRY fields to the appropriate endianess.
85 * @param enmConv Direction of the conversion.
86 * @param pDiskGeoConv Where to store the converted geometry.
87 * @param pDiskGeo Pointer to the disk geometry to convert.
88 */
89static void vdiConvGeometryEndianess(VDIECONV enmConv, PVDIDISKGEOMETRY pDiskGeoConv,
90 PVDIDISKGEOMETRY pDiskGeo)
91{
92 pDiskGeoConv->cCylinders = SET_ENDIAN_U32(enmConv, pDiskGeo->cCylinders);
93 pDiskGeoConv->cHeads = SET_ENDIAN_U32(enmConv, pDiskGeo->cHeads);
94 pDiskGeoConv->cSectors = SET_ENDIAN_U32(enmConv, pDiskGeo->cSectors);
95 pDiskGeoConv->cbSector = SET_ENDIAN_U32(enmConv, pDiskGeo->cbSector);
96}
97
98/**
99 * Internal: Convert the Header - version 0 fields to the appropriate endianess.
100 * @param enmConv Direction of the conversion.
101 * @param pHdrConv Where to store the converted header.
102 * @param pHdr Pointer to the version 0 header.
103 */
104static void vdiConvHeaderEndianessV0(VDIECONV enmConv, PVDIHEADER0 pHdrConv,
105 PVDIHEADER0 pHdr)
106{
107 memmove(pHdrConv->szComment, pHdr->szComment, sizeof(pHdr->szComment));
108 pHdrConv->u32Type = SET_ENDIAN_U32(enmConv, pHdr->u32Type);
109 pHdrConv->fFlags = SET_ENDIAN_U32(enmConv, pHdr->fFlags);
110 vdiConvGeometryEndianess(enmConv, &pHdrConv->LegacyGeometry, &pHdr->LegacyGeometry);
111 pHdrConv->cbDisk = SET_ENDIAN_U64(enmConv, pHdr->cbDisk);
112 pHdrConv->cbBlock = SET_ENDIAN_U32(enmConv, pHdr->cbBlock);
113 pHdrConv->cBlocks = SET_ENDIAN_U32(enmConv, pHdr->cBlocks);
114 pHdrConv->cBlocksAllocated = SET_ENDIAN_U32(enmConv, pHdr->cBlocksAllocated);
115 /* Don't convert the RTUUID fields. */
116 pHdrConv->uuidCreate = pHdr->uuidCreate;
117 pHdrConv->uuidModify = pHdr->uuidModify;
118 pHdrConv->uuidLinkage = pHdr->uuidLinkage;
119}
120
121/**
122 * Internal: Set the Header - version 1 fields to the appropriate endianess.
123 * @param enmConv Direction of the conversion.
124 * @param pHdrConv Where to store the converted header.
125 * @param pHdr Version 1 Header pointer.
126 */
127static void vdiConvHeaderEndianessV1(VDIECONV enmConv, PVDIHEADER1 pHdrConv,
128 PVDIHEADER1 pHdr)
129{
130 memmove(pHdrConv->szComment, pHdr->szComment, sizeof(pHdr->szComment));
131 pHdrConv->cbHeader = SET_ENDIAN_U32(enmConv, pHdr->cbHeader);
132 pHdrConv->u32Type = SET_ENDIAN_U32(enmConv, pHdr->u32Type);
133 pHdrConv->fFlags = SET_ENDIAN_U32(enmConv, pHdr->fFlags);
134 pHdrConv->offBlocks = SET_ENDIAN_U32(enmConv, pHdr->offBlocks);
135 pHdrConv->offData = SET_ENDIAN_U32(enmConv, pHdr->offData);
136 vdiConvGeometryEndianess(enmConv, &pHdrConv->LegacyGeometry, &pHdr->LegacyGeometry);
137 pHdrConv->u32Dummy = SET_ENDIAN_U32(enmConv, pHdr->u32Dummy);
138 pHdrConv->cbDisk = SET_ENDIAN_U64(enmConv, pHdr->cbDisk);
139 pHdrConv->cbBlock = SET_ENDIAN_U32(enmConv, pHdr->cbBlock);
140 pHdrConv->cbBlockExtra = SET_ENDIAN_U32(enmConv, pHdr->cbBlockExtra);
141 pHdrConv->cBlocks = SET_ENDIAN_U32(enmConv, pHdr->cBlocks);
142 pHdrConv->cBlocksAllocated = SET_ENDIAN_U32(enmConv, pHdr->cBlocksAllocated);
143 /* Don't convert the RTUUID fields. */
144 pHdrConv->uuidCreate = pHdr->uuidCreate;
145 pHdrConv->uuidModify = pHdr->uuidModify;
146 pHdrConv->uuidLinkage = pHdr->uuidLinkage;
147 pHdrConv->uuidParentModify = pHdr->uuidParentModify;
148}
149
150/**
151 * Internal: Set the Header - version 1plus fields to the appropriate endianess.
152 * @param enmConv Direction of the conversion.
153 * @param pHdrConv Where to store the converted header.
154 * @param pHdr Version 1+ Header pointer.
155 */
156static void vdiConvHeaderEndianessV1p(VDIECONV enmConv, PVDIHEADER1PLUS pHdrConv,
157 PVDIHEADER1PLUS pHdr)
158{
159 memmove(pHdrConv->szComment, pHdr->szComment, sizeof(pHdr->szComment));
160 pHdrConv->cbHeader = SET_ENDIAN_U32(enmConv, pHdr->cbHeader);
161 pHdrConv->u32Type = SET_ENDIAN_U32(enmConv, pHdr->u32Type);
162 pHdrConv->fFlags = SET_ENDIAN_U32(enmConv, pHdr->fFlags);
163 pHdrConv->offBlocks = SET_ENDIAN_U32(enmConv, pHdr->offBlocks);
164 pHdrConv->offData = SET_ENDIAN_U32(enmConv, pHdr->offData);
165 vdiConvGeometryEndianess(enmConv, &pHdrConv->LegacyGeometry, &pHdr->LegacyGeometry);
166 pHdrConv->u32Dummy = SET_ENDIAN_U32(enmConv, pHdr->u32Dummy);
167 pHdrConv->cbDisk = SET_ENDIAN_U64(enmConv, pHdr->cbDisk);
168 pHdrConv->cbBlock = SET_ENDIAN_U32(enmConv, pHdr->cbBlock);
169 pHdrConv->cbBlockExtra = SET_ENDIAN_U32(enmConv, pHdr->cbBlockExtra);
170 pHdrConv->cBlocks = SET_ENDIAN_U32(enmConv, pHdr->cBlocks);
171 pHdrConv->cBlocksAllocated = SET_ENDIAN_U32(enmConv, pHdr->cBlocksAllocated);
172 /* Don't convert the RTUUID fields. */
173 pHdrConv->uuidCreate = pHdr->uuidCreate;
174 pHdrConv->uuidModify = pHdr->uuidModify;
175 pHdrConv->uuidLinkage = pHdr->uuidLinkage;
176 pHdrConv->uuidParentModify = pHdr->uuidParentModify;
177 vdiConvGeometryEndianess(enmConv, &pHdrConv->LCHSGeometry, &pHdr->LCHSGeometry);
178}
179
180/**
181 * Internal: Set the appropriate endianess on all the Blocks pointed.
182 * @param enmConv Direction of the conversion.
183 * @param paBlocks Pointer to the block array.
184 * @param cEntries Number of entries in the block array.
185 *
186 * @note Unlike the other conversion functions this method does an in place conversion
187 * to avoid temporary memory allocations when writing the block array.
188 */
189static void vdiConvBlocksEndianess(VDIECONV enmConv, PVDIIMAGEBLOCKPOINTER paBlocks,
190 unsigned cEntries)
191{
192 for (unsigned i = 0; i < cEntries; i++)
193 paBlocks[i] = SET_ENDIAN_U32(enmConv, paBlocks[i]);
194}
195
196/**
197 * Internal: Flush the image file to disk.
198 */
199static void vdiFlushImage(PVDIIMAGEDESC pImage)
200{
201 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
202 {
203 /* Save header. */
204 int rc = vdiUpdateHeader(pImage);
205 AssertMsgRC(rc, ("vdiUpdateHeader() failed, filename=\"%s\", rc=%Rrc\n",
206 pImage->pszFilename, rc));
207 vdIfIoIntFileFlushSync(pImage->pIfIo, pImage->pStorage);
208 }
209}
210
211/**
212 * Internal: Free all allocated space for representing an image, and optionally
213 * delete the image from disk.
214 */
215static int vdiFreeImage(PVDIIMAGEDESC pImage, bool fDelete)
216{
217 int rc = VINF_SUCCESS;
218
219 /* Freeing a never allocated image (e.g. because the open failed) is
220 * not signalled as an error. After all nothing bad happens. */
221 if (pImage)
222 {
223 if (pImage->pStorage)
224 {
225 /* No point updating the file that is deleted anyway. */
226 if (!fDelete)
227 vdiFlushImage(pImage);
228
229 rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
230 pImage->pStorage = NULL;
231 }
232
233 if (pImage->paBlocks)
234 {
235 RTMemFree(pImage->paBlocks);
236 pImage->paBlocks = NULL;
237 }
238
239 if (pImage->paBlocksRev)
240 {
241 RTMemFree(pImage->paBlocksRev);
242 pImage->paBlocksRev = NULL;
243 }
244
245 if (fDelete && pImage->pszFilename)
246 vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
247 }
248
249 LogFlowFunc(("returns %Rrc\n", rc));
250 return rc;
251}
252
253/**
254 * internal: return power of 2 or 0 if num error.
255 */
256static unsigned getPowerOfTwo(unsigned uNumber)
257{
258 if (uNumber == 0)
259 return 0;
260 unsigned uPower2 = 0;
261 while ((uNumber & 1) == 0)
262 {
263 uNumber >>= 1;
264 uPower2++;
265 }
266 return uNumber == 1 ? uPower2 : 0;
267}
268
269/**
270 * Internal: Init VDI preheader.
271 */
272static void vdiInitPreHeader(PVDIPREHEADER pPreHdr)
273{
274 pPreHdr->u32Signature = VDI_IMAGE_SIGNATURE;
275 pPreHdr->u32Version = VDI_IMAGE_VERSION;
276 memset(pPreHdr->szFileInfo, 0, sizeof(pPreHdr->szFileInfo));
277 strncat(pPreHdr->szFileInfo, VDI_IMAGE_FILE_INFO, sizeof(pPreHdr->szFileInfo)-1);
278}
279
280/**
281 * Internal: check VDI preheader.
282 */
283static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr)
284{
285 if (pPreHdr->u32Signature != VDI_IMAGE_SIGNATURE)
286 return VERR_VD_VDI_INVALID_HEADER;
287
288 if ( VDI_GET_VERSION_MAJOR(pPreHdr->u32Version) != VDI_IMAGE_VERSION_MAJOR
289 && pPreHdr->u32Version != 0x00000002) /* old version. */
290 return VERR_VD_VDI_UNSUPPORTED_VERSION;
291
292 return VINF_SUCCESS;
293}
294
295/**
296 * Internal: translate VD image flags to VDI image type enum.
297 */
298static VDIIMAGETYPE vdiTranslateImageFlags2VDI(unsigned uImageFlags)
299{
300 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
301 return VDI_IMAGE_TYPE_FIXED;
302 else if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
303 return VDI_IMAGE_TYPE_DIFF;
304 else
305 return VDI_IMAGE_TYPE_NORMAL;
306}
307
308/**
309 * Internal: translate VDI image type enum to VD image type enum.
310 */
311static unsigned vdiTranslateVDI2ImageFlags(VDIIMAGETYPE enmType)
312{
313 switch (enmType)
314 {
315 case VDI_IMAGE_TYPE_NORMAL:
316 return VD_IMAGE_FLAGS_NONE;
317 case VDI_IMAGE_TYPE_FIXED:
318 return VD_IMAGE_FLAGS_FIXED;
319 case VDI_IMAGE_TYPE_DIFF:
320 return VD_IMAGE_FLAGS_DIFF;
321 default:
322 AssertMsgFailed(("invalid VDIIMAGETYPE enmType=%d\n", (int)enmType));
323 return VD_IMAGE_FLAGS_NONE;
324 }
325}
326
327/**
328 * Internal: Init VDI header. Always use latest header version.
329 * @param pHeader Assumes it was initially initialized to all zeros.
330 */
331static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
332 const char *pszComment, uint64_t cbDisk,
333 uint32_t cbBlock, uint32_t cbBlockExtra,
334 uint32_t cbDataAlign)
335{
336 pHeader->uVersion = VDI_IMAGE_VERSION;
337 pHeader->u.v1plus.cbHeader = sizeof(VDIHEADER1PLUS);
338 pHeader->u.v1plus.u32Type = (uint32_t)vdiTranslateImageFlags2VDI(uImageFlags);
339 pHeader->u.v1plus.fFlags = (uImageFlags & VD_VDI_IMAGE_FLAGS_ZERO_EXPAND) ? 1 : 0;
340#ifdef VBOX_STRICT
341 char achZero[VDI_IMAGE_COMMENT_SIZE] = {0};
342 Assert(!memcmp(pHeader->u.v1plus.szComment, achZero, VDI_IMAGE_COMMENT_SIZE));
343#endif
344 pHeader->u.v1plus.szComment[0] = '\0';
345 if (pszComment)
346 {
347 AssertMsg(strlen(pszComment) < sizeof(pHeader->u.v1plus.szComment),
348 ("HDD Comment is too long, cb=%d\n", strlen(pszComment)));
349 strncat(pHeader->u.v1plus.szComment, pszComment, sizeof(pHeader->u.v1plus.szComment)-1);
350 }
351
352 /* Mark the legacy geometry not-calculated. */
353 pHeader->u.v1plus.LegacyGeometry.cCylinders = 0;
354 pHeader->u.v1plus.LegacyGeometry.cHeads = 0;
355 pHeader->u.v1plus.LegacyGeometry.cSectors = 0;
356 pHeader->u.v1plus.LegacyGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
357 pHeader->u.v1plus.u32Dummy = 0; /* used to be the translation value */
358
359 pHeader->u.v1plus.cbDisk = cbDisk;
360 pHeader->u.v1plus.cbBlock = cbBlock;
361 pHeader->u.v1plus.cBlocks = (uint32_t)(cbDisk / cbBlock);
362 if (cbDisk % cbBlock)
363 pHeader->u.v1plus.cBlocks++;
364 pHeader->u.v1plus.cbBlockExtra = cbBlockExtra;
365 pHeader->u.v1plus.cBlocksAllocated = 0;
366
367 /* Init offsets. */
368 pHeader->u.v1plus.offBlocks = RT_ALIGN_32(sizeof(VDIPREHEADER) + sizeof(VDIHEADER1PLUS), cbDataAlign);
369 pHeader->u.v1plus.offData = RT_ALIGN_32(pHeader->u.v1plus.offBlocks + (pHeader->u.v1plus.cBlocks * sizeof(VDIIMAGEBLOCKPOINTER)), cbDataAlign);
370
371 /* Init uuids. */
372 RTUuidCreate(&pHeader->u.v1plus.uuidCreate);
373 RTUuidClear(&pHeader->u.v1plus.uuidModify);
374 RTUuidClear(&pHeader->u.v1plus.uuidLinkage);
375 RTUuidClear(&pHeader->u.v1plus.uuidParentModify);
376
377 /* Mark LCHS geometry not-calculated. */
378 pHeader->u.v1plus.LCHSGeometry.cCylinders = 0;
379 pHeader->u.v1plus.LCHSGeometry.cHeads = 0;
380 pHeader->u.v1plus.LCHSGeometry.cSectors = 0;
381 pHeader->u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
382}
383
384/**
385 * Internal: Check VDI header.
386 */
387static int vdiValidateHeader(PVDIHEADER pHeader)
388{
389 /* Check version-dependent header parameters. */
390 switch (GET_MAJOR_HEADER_VERSION(pHeader))
391 {
392 case 0:
393 {
394 /* Old header version. */
395 break;
396 }
397 case 1:
398 {
399 /* Current header version. */
400
401 if (pHeader->u.v1.cbHeader < sizeof(VDIHEADER1))
402 {
403 LogRel(("VDI: v1 header size wrong (%d < %d)\n",
404 pHeader->u.v1.cbHeader, sizeof(VDIHEADER1)));
405 return VERR_VD_VDI_INVALID_HEADER;
406 }
407
408 if (getImageBlocksOffset(pHeader) < (sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)))
409 {
410 LogRel(("VDI: v1 blocks offset wrong (%d < %d)\n",
411 getImageBlocksOffset(pHeader), sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)));
412 return VERR_VD_VDI_INVALID_HEADER;
413 }
414
415 if (getImageDataOffset(pHeader) < (getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)))
416 {
417 LogRel(("VDI: v1 image data offset wrong (%d < %d)\n",
418 getImageDataOffset(pHeader), getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)));
419 return VERR_VD_VDI_INVALID_HEADER;
420 }
421
422 break;
423 }
424 default:
425 /* Unsupported. */
426 return VERR_VD_VDI_UNSUPPORTED_VERSION;
427 }
428
429 /* Check common header parameters. */
430
431 bool fFailed = false;
432
433 if ( getImageType(pHeader) < VDI_IMAGE_TYPE_FIRST
434 || getImageType(pHeader) > VDI_IMAGE_TYPE_LAST)
435 {
436 LogRel(("VDI: bad image type %d\n", getImageType(pHeader)));
437 fFailed = true;
438 }
439
440 if (getImageFlags(pHeader) & ~VD_VDI_IMAGE_FLAGS_MASK)
441 {
442 LogRel(("VDI: bad image flags %08x\n", getImageFlags(pHeader)));
443 fFailed = true;
444 }
445
446 if ( getImageLCHSGeometry(pHeader)
447 && (getImageLCHSGeometry(pHeader))->cbSector != VDI_GEOMETRY_SECTOR_SIZE)
448 {
449 LogRel(("VDI: wrong sector size (%d != %d)\n",
450 (getImageLCHSGeometry(pHeader))->cbSector, VDI_GEOMETRY_SECTOR_SIZE));
451 fFailed = true;
452 }
453
454 if ( getImageDiskSize(pHeader) == 0
455 || getImageBlockSize(pHeader) == 0
456 || getImageBlocks(pHeader) == 0
457 || getPowerOfTwo(getImageBlockSize(pHeader)) == 0)
458 {
459 LogRel(("VDI: wrong size (%lld, %d, %d, %d)\n",
460 getImageDiskSize(pHeader), getImageBlockSize(pHeader),
461 getImageBlocks(pHeader), getPowerOfTwo(getImageBlockSize(pHeader))));
462 fFailed = true;
463 }
464
465 if (getImageBlocksAllocated(pHeader) > getImageBlocks(pHeader))
466 {
467 LogRel(("VDI: too many blocks allocated (%d > %d)\n"
468 " blocksize=%d disksize=%lld\n",
469 getImageBlocksAllocated(pHeader), getImageBlocks(pHeader),
470 getImageBlockSize(pHeader), getImageDiskSize(pHeader)));
471 fFailed = true;
472 }
473
474 if ( getImageExtraBlockSize(pHeader) != 0
475 && getPowerOfTwo(getImageExtraBlockSize(pHeader)) == 0)
476 {
477 LogRel(("VDI: wrong extra size (%d, %d)\n",
478 getImageExtraBlockSize(pHeader), getPowerOfTwo(getImageExtraBlockSize(pHeader))));
479 fFailed = true;
480 }
481
482 if ((uint64_t)getImageBlockSize(pHeader) * getImageBlocks(pHeader) < getImageDiskSize(pHeader))
483 {
484 LogRel(("VDI: wrong disk size (%d, %d, %lld)\n",
485 getImageBlockSize(pHeader), getImageBlocks(pHeader), getImageDiskSize(pHeader)));
486 fFailed = true;
487 }
488
489 if (RTUuidIsNull(getImageCreationUUID(pHeader)))
490 {
491 LogRel(("VDI: uuid of creator is 0\n"));
492 fFailed = true;
493 }
494
495 if (RTUuidIsNull(getImageModificationUUID(pHeader)))
496 {
497 LogRel(("VDI: uuid of modifier is 0\n"));
498 fFailed = true;
499 }
500
501 return fFailed ? VERR_VD_VDI_INVALID_HEADER : VINF_SUCCESS;
502}
503
504/**
505 * Internal: Set up VDIIMAGEDESC structure by image header.
506 */
507static void vdiSetupImageDesc(PVDIIMAGEDESC pImage)
508{
509 pImage->uImageFlags = getImageFlags(&pImage->Header);
510 pImage->uImageFlags |= vdiTranslateVDI2ImageFlags(getImageType(&pImage->Header));
511 pImage->offStartBlocks = getImageBlocksOffset(&pImage->Header);
512 pImage->offStartData = getImageDataOffset(&pImage->Header);
513 pImage->uBlockMask = getImageBlockSize(&pImage->Header) - 1;
514 pImage->uShiftOffset2Index = getPowerOfTwo(getImageBlockSize(&pImage->Header));
515 pImage->offStartBlockData = getImageExtraBlockSize(&pImage->Header);
516 pImage->cbTotalBlockData = pImage->offStartBlockData
517 + getImageBlockSize(&pImage->Header);
518}
519
520/**
521 * Internal: Create VDI image file.
522 */
523static int vdiCreateImage(PVDIIMAGEDESC pImage, uint64_t cbSize,
524 unsigned uImageFlags, const char *pszComment,
525 PCVDGEOMETRY pPCHSGeometry,
526 PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
527 unsigned uOpenFlags, PFNVDPROGRESS pfnProgress,
528 void *pvUser, unsigned uPercentStart,
529 unsigned uPercentSpan, PVDINTERFACECONFIG pIfCfg)
530{
531 int rc;
532 uint64_t cbTotal;
533 uint64_t cbFill;
534 uint64_t uOff;
535 uint32_t cbDataAlign = VDI_DATA_ALIGN;
536
537 AssertPtr(pPCHSGeometry);
538 AssertPtr(pLCHSGeometry);
539
540 pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
541 pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
542 AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
543
544 /* Special check for comment length. */
545 if ( VALID_PTR(pszComment)
546 && strlen(pszComment) >= VDI_IMAGE_COMMENT_SIZE)
547 {
548 rc = vdIfError(pImage->pIfError, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS,
549 N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
550 goto out;
551 }
552
553 if (pIfCfg)
554 {
555 rc = VDCFGQueryU32Def(pIfCfg, "DataAlignment", &cbDataAlign, VDI_DATA_ALIGN);
556 if (RT_FAILURE(rc))
557 {
558 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
559 N_("VDI: Getting data alignment for '%s' failed (%Rrc)"), pImage->pszFilename);
560 goto out;
561 }
562 }
563
564 vdiInitPreHeader(&pImage->PreHeader);
565 vdiInitHeader(&pImage->Header, uImageFlags, pszComment, cbSize, VDI_IMAGE_DEFAULT_BLOCK_SIZE, 0,
566 cbDataAlign);
567 /* Save PCHS geometry. Not much work, and makes the flow of information
568 * quite a bit clearer - relying on the higher level isn't obvious. */
569 pImage->PCHSGeometry = *pPCHSGeometry;
570 /* Set LCHS geometry (legacy geometry is ignored for the current 1.1+). */
571 pImage->Header.u.v1plus.LCHSGeometry.cCylinders = pLCHSGeometry->cCylinders;
572 pImage->Header.u.v1plus.LCHSGeometry.cHeads = pLCHSGeometry->cHeads;
573 pImage->Header.u.v1plus.LCHSGeometry.cSectors = pLCHSGeometry->cSectors;
574 pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
575
576 pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
577 if (!pImage->paBlocks)
578 {
579 rc = VERR_NO_MEMORY;
580 goto out;
581 }
582
583 if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
584 {
585 /* for growing images mark all blocks in paBlocks as free. */
586 for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
587 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
588 }
589 else
590 {
591 /* for fixed images mark all blocks in paBlocks as allocated */
592 for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
593 pImage->paBlocks[i] = i;
594 pImage->Header.u.v1.cBlocksAllocated = pImage->Header.u.v1.cBlocks;
595 }
596
597 /* Setup image parameters. */
598 vdiSetupImageDesc(pImage);
599
600 /* Create image file. */
601 rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
602 VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
603 true /* fCreate */),
604 &pImage->pStorage);
605 if (RT_FAILURE(rc))
606 {
607 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: cannot create image '%s'"),
608 pImage->pszFilename);
609 goto out;
610 }
611
612 cbTotal = pImage->offStartData
613 + (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
614
615 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
616 {
617 /* Check the free space on the disk and leave early if there is not
618 * sufficient space available. */
619 int64_t cbFree = 0;
620 rc = vdIfIoIntFileGetFreeSpace(pImage->pIfIo, pImage->pszFilename, &cbFree);
621 if (RT_SUCCESS(rc) /* ignore errors */ && ((uint64_t)cbFree < cbTotal))
622 {
623 rc = vdIfError(pImage->pIfError, VERR_DISK_FULL, RT_SRC_POS,
624 N_("VDI: disk would overflow creating image '%s'"), pImage->pszFilename);
625 goto out;
626 }
627 }
628
629 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
630 {
631 /*
632 * Allocate & commit whole file if fixed image, it must be more
633 * effective than expanding file by write operations.
634 */
635 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, cbTotal);
636 pImage->cbImage = cbTotal;
637 }
638 else
639 {
640 /* Set file size to hold header and blocks array. */
641 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, pImage->offStartData);
642 pImage->cbImage = pImage->offStartData;
643 }
644 if (RT_FAILURE(rc))
645 {
646 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: setting image size failed for '%s'"),
647 pImage->pszFilename);
648 goto out;
649 }
650
651 /* Use specified image uuid */
652 *getImageCreationUUID(&pImage->Header) = *pUuid;
653
654 /* Generate image last-modify uuid */
655 RTUuidCreate(getImageModificationUUID(&pImage->Header));
656
657 /* Write pre-header. */
658 VDIPREHEADER PreHeader;
659 vdiConvPreHeaderEndianess(VDIECONV_H2F, &PreHeader, &pImage->PreHeader);
660 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0,
661 &PreHeader, sizeof(PreHeader));
662 if (RT_FAILURE(rc))
663 {
664 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: writing pre-header failed for '%s'"),
665 pImage->pszFilename);
666 goto out;
667 }
668
669 /* Write header. */
670 VDIHEADER1PLUS Hdr;
671 vdiConvHeaderEndianessV1p(VDIECONV_H2F, &Hdr, &pImage->Header.u.v1plus);
672 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, sizeof(pImage->PreHeader),
673 &Hdr, sizeof(Hdr));
674 if (RT_FAILURE(rc))
675 {
676 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: writing header failed for '%s'"),
677 pImage->pszFilename);
678 goto out;
679 }
680
681 vdiConvBlocksEndianess(VDIECONV_H2F, pImage->paBlocks, getImageBlocks(&pImage->Header));
682 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->offStartBlocks, pImage->paBlocks,
683 getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER));
684 vdiConvBlocksEndianess(VDIECONV_F2H, pImage->paBlocks, getImageBlocks(&pImage->Header));
685 if (RT_FAILURE(rc))
686 {
687 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: writing block pointers failed for '%s'"),
688 pImage->pszFilename);
689 goto out;
690 }
691
692 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
693 {
694 /* Fill image with zeroes. We do this for every fixed-size image since on some systems
695 * (for example Windows Vista), it takes ages to write a block near the end of a sparse
696 * file and the guest could complain about an ATA timeout. */
697
698 /** @todo Starting with Linux 2.6.23, there is an fallocate() system call.
699 * Currently supported file systems are ext4 and ocfs2. */
700
701 /* Allocate a temporary zero-filled buffer. Use a bigger block size to optimize writing */
702 const size_t cbBuf = 128 * _1K;
703 void *pvBuf = RTMemTmpAllocZ(cbBuf);
704 if (!pvBuf)
705 {
706 rc = VERR_NO_MEMORY;
707 goto out;
708 }
709
710 cbFill = (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
711 uOff = 0;
712 /* Write data to all image blocks. */
713 while (uOff < cbFill)
714 {
715 unsigned cbChunk = (unsigned)RT_MIN(cbFill, cbBuf);
716
717 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->offStartData + uOff,
718 pvBuf, cbChunk);
719 if (RT_FAILURE(rc))
720 {
721 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: writing block failed for '%s'"), pImage->pszFilename);
722 RTMemTmpFree(pvBuf);
723 goto out;
724 }
725
726 uOff += cbChunk;
727
728 if (pfnProgress)
729 {
730 rc = pfnProgress(pvUser,
731 uPercentStart + uOff * uPercentSpan / cbFill);
732 if (RT_FAILURE(rc))
733 goto out;
734 }
735 }
736 RTMemTmpFree(pvBuf);
737 }
738
739out:
740 if (RT_SUCCESS(rc) && pfnProgress)
741 pfnProgress(pvUser, uPercentStart + uPercentSpan);
742
743 if (RT_FAILURE(rc))
744 vdiFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
745 return rc;
746}
747
748/**
749 * Internal: Open a VDI image.
750 */
751static int vdiOpenImage(PVDIIMAGEDESC pImage, unsigned uOpenFlags)
752{
753 int rc;
754
755 pImage->uOpenFlags = uOpenFlags;
756
757 pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
758 pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
759 AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
760
761 /*
762 * Open the image.
763 */
764 rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
765 VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */),
766 &pImage->pStorage);
767 if (RT_FAILURE(rc))
768 {
769 /* Do NOT signal an appropriate error here, as the VD layer has the
770 * choice of retrying the open if it failed. */
771 goto out;
772 }
773
774 /* Get file size. */
775 rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage,
776 &pImage->cbImage);
777 if (RT_FAILURE(rc))
778 {
779 vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: error getting the image size in '%s'"), pImage->pszFilename);
780 rc = VERR_VD_VDI_INVALID_HEADER;
781 goto out;
782 }
783
784 /* Read pre-header. */
785 VDIPREHEADER PreHeader;
786 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, 0,
787 &PreHeader, sizeof(PreHeader));
788 if (RT_FAILURE(rc))
789 {
790 vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: error reading pre-header in '%s'"), pImage->pszFilename);
791 rc = VERR_VD_VDI_INVALID_HEADER;
792 goto out;
793 }
794 vdiConvPreHeaderEndianess(VDIECONV_F2H, &pImage->PreHeader, &PreHeader);
795 rc = vdiValidatePreHeader(&pImage->PreHeader);
796 if (RT_FAILURE(rc))
797 {
798 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: invalid pre-header in '%s'"), pImage->pszFilename);
799 goto out;
800 }
801
802 /* Read header. */
803 pImage->Header.uVersion = pImage->PreHeader.u32Version;
804 switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
805 {
806 case 0:
807 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, sizeof(pImage->PreHeader),
808 &pImage->Header.u.v0, sizeof(pImage->Header.u.v0));
809 if (RT_FAILURE(rc))
810 {
811 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: error reading v0 header in '%s'"), pImage->pszFilename);
812 goto out;
813 }
814 vdiConvHeaderEndianessV0(VDIECONV_F2H, &pImage->Header.u.v0, &pImage->Header.u.v0);
815 break;
816 case 1:
817 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, sizeof(pImage->PreHeader),
818 &pImage->Header.u.v1, sizeof(pImage->Header.u.v1));
819 if (RT_FAILURE(rc))
820 {
821 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: error reading v1 header in '%s'"), pImage->pszFilename);
822 goto out;
823 }
824 vdiConvHeaderEndianessV1(VDIECONV_F2H, &pImage->Header.u.v1, &pImage->Header.u.v1);
825 /* Convert VDI 1.1 images to VDI 1.1+ on open in read/write mode.
826 * Conversion is harmless, as any VirtualBox version supporting VDI
827 * 1.1 doesn't touch fields it doesn't know about. */
828 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
829 && GET_MINOR_HEADER_VERSION(&pImage->Header) == 1
830 && pImage->Header.u.v1.cbHeader < sizeof(pImage->Header.u.v1plus))
831 {
832 pImage->Header.u.v1plus.cbHeader = sizeof(pImage->Header.u.v1plus);
833 /* Mark LCHS geometry not-calculated. */
834 pImage->Header.u.v1plus.LCHSGeometry.cCylinders = 0;
835 pImage->Header.u.v1plus.LCHSGeometry.cHeads = 0;
836 pImage->Header.u.v1plus.LCHSGeometry.cSectors = 0;
837 pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
838 }
839 else if (pImage->Header.u.v1.cbHeader >= sizeof(pImage->Header.u.v1plus))
840 {
841 /* Read the actual VDI 1.1+ header completely. */
842 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, sizeof(pImage->PreHeader),
843 &pImage->Header.u.v1plus,
844 sizeof(pImage->Header.u.v1plus));
845 if (RT_FAILURE(rc))
846 {
847 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: error reading v1.1+ header in '%s'"), pImage->pszFilename);
848 goto out;
849 }
850 vdiConvHeaderEndianessV1p(VDIECONV_F2H, &pImage->Header.u.v1plus, &pImage->Header.u.v1plus);
851 }
852 break;
853 default:
854 rc = vdIfError(pImage->pIfError, VERR_VD_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VDI: unsupported major version %u in '%s'"), GET_MAJOR_HEADER_VERSION(&pImage->Header), pImage->pszFilename);
855 goto out;
856 }
857
858 rc = vdiValidateHeader(&pImage->Header);
859 if (RT_FAILURE(rc))
860 {
861 rc = vdIfError(pImage->pIfError, VERR_VD_VDI_INVALID_HEADER, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
862 goto out;
863 }
864
865 /* Setup image parameters by header. */
866 vdiSetupImageDesc(pImage);
867
868 /* Allocate memory for blocks array. */
869 pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
870 if (!pImage->paBlocks)
871 {
872 rc = VERR_NO_MEMORY;
873 goto out;
874 }
875
876 /* Read blocks array. */
877 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, pImage->offStartBlocks, pImage->paBlocks,
878 getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER));
879 if (RT_FAILURE(rc))
880 {
881 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VDI: Error reading the block table in '%s'"), pImage->pszFilename);
882 goto out;
883 }
884 vdiConvBlocksEndianess(VDIECONV_F2H, pImage->paBlocks, getImageBlocks(&pImage->Header));
885
886 if (uOpenFlags & VD_OPEN_FLAGS_DISCARD)
887 {
888 /*
889 * Create the back resolving table for discards.
890 * any error or inconsistency results in a fail because this might
891 * get us into trouble later on.
892 */
893 pImage->paBlocksRev = (unsigned *)RTMemAllocZ(sizeof(unsigned) * getImageBlocks(&pImage->Header));
894 if (pImage->paBlocksRev)
895 {
896 unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
897 unsigned cBlocks = getImageBlocks(&pImage->Header);
898
899 for (unsigned i = 0; i < cBlocks; i++)
900 pImage->paBlocksRev[i] = VDI_IMAGE_BLOCK_FREE;
901
902 for (unsigned i = 0; i < cBlocks; i++)
903 {
904 VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
905 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
906 {
907 if (ptrBlock < cBlocksAllocated)
908 {
909 if (pImage->paBlocksRev[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
910 pImage->paBlocksRev[ptrBlock] = i;
911 else
912 {
913 rc = VERR_VD_VDI_INVALID_HEADER;
914 break;
915 }
916 }
917 else
918 {
919 rc = VERR_VD_VDI_INVALID_HEADER;
920 break;
921 }
922 }
923 }
924 }
925 else
926 rc = VERR_NO_MEMORY;
927 }
928
929out:
930 if (RT_FAILURE(rc))
931 vdiFreeImage(pImage, false);
932 return rc;
933}
934
935/**
936 * Internal: Save header to file.
937 */
938static int vdiUpdateHeader(PVDIIMAGEDESC pImage)
939{
940 int rc;
941 switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
942 {
943 case 0:
944 {
945 VDIHEADER0 Hdr;
946 vdiConvHeaderEndianessV0(VDIECONV_H2F, &Hdr, &pImage->Header.u.v0);
947 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, sizeof(VDIPREHEADER),
948 &Hdr, sizeof(Hdr));
949 break;
950 }
951 case 1:
952 if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
953 {
954 VDIHEADER1 Hdr;
955 vdiConvHeaderEndianessV1(VDIECONV_H2F, &Hdr, &pImage->Header.u.v1);
956 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, sizeof(VDIPREHEADER),
957 &Hdr, sizeof(Hdr));
958 }
959 else
960 {
961 VDIHEADER1PLUS Hdr;
962 vdiConvHeaderEndianessV1p(VDIECONV_H2F, &Hdr, &pImage->Header.u.v1plus);
963 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, sizeof(VDIPREHEADER),
964 &Hdr, sizeof(Hdr));
965 }
966 break;
967 default:
968 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
969 break;
970 }
971 AssertMsgRC(rc, ("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
972 return rc;
973}
974
975/**
976 * Internal: Save header to file - async version.
977 */
978static int vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
979{
980 int rc;
981 switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
982 {
983 case 0:
984 {
985 VDIHEADER0 Hdr;
986 vdiConvHeaderEndianessV0(VDIECONV_H2F, &Hdr, &pImage->Header.u.v0);
987 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
988 sizeof(VDIPREHEADER), &Hdr, sizeof(Hdr),
989 pIoCtx, NULL, NULL);
990 break;
991 }
992 case 1:
993 if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
994 {
995 VDIHEADER1 Hdr;
996 vdiConvHeaderEndianessV1(VDIECONV_H2F, &Hdr, &pImage->Header.u.v1);
997 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
998 sizeof(VDIPREHEADER), &Hdr, sizeof(Hdr),
999 pIoCtx, NULL, NULL);
1000 }
1001 else
1002 {
1003 VDIHEADER1PLUS Hdr;
1004 vdiConvHeaderEndianessV1p(VDIECONV_H2F, &Hdr, &pImage->Header.u.v1plus);
1005 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1006 sizeof(VDIPREHEADER), &Hdr, sizeof(Hdr),
1007 pIoCtx, NULL, NULL);
1008 }
1009 break;
1010 default:
1011 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1012 break;
1013 }
1014 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
1015 ("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
1016 return rc;
1017}
1018
1019/**
1020 * Internal: Save block pointer to file, save header to file.
1021 */
1022static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock)
1023{
1024 /* Update image header. */
1025 int rc = vdiUpdateHeader(pImage);
1026 if (RT_SUCCESS(rc))
1027 {
1028 /* write only one block pointer. */
1029 VDIIMAGEBLOCKPOINTER ptrBlock = RT_H2LE_U32(pImage->paBlocks[uBlock]);
1030 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
1031 pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
1032 &ptrBlock, sizeof(VDIIMAGEBLOCKPOINTER));
1033 AssertMsgRC(rc, ("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
1034 uBlock, pImage->pszFilename, rc));
1035 }
1036 return rc;
1037}
1038
1039/**
1040 * Internal: Save block pointer to file, save header to file - async version.
1041 */
1042static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock,
1043 PVDIOCTX pIoCtx, bool fUpdateHdr)
1044{
1045 int rc = VINF_SUCCESS;
1046
1047 /* Update image header. */
1048 if (fUpdateHdr)
1049 rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
1050
1051 if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1052 {
1053 /* write only one block pointer. */
1054 VDIIMAGEBLOCKPOINTER ptrBlock = RT_H2LE_U32(pImage->paBlocks[uBlock]);
1055 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1056 pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
1057 &ptrBlock, sizeof(VDIIMAGEBLOCKPOINTER),
1058 pIoCtx, NULL, NULL);
1059 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
1060 ("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
1061 uBlock, pImage->pszFilename, rc));
1062 }
1063 return rc;
1064}
1065
1066/**
1067 * Internal: Flush the image file to disk - async version.
1068 */
1069static int vdiFlushImageIoCtx(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
1070{
1071 int rc = VINF_SUCCESS;
1072
1073 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1074 {
1075 /* Save header. */
1076 rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
1077 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
1078 ("vdiUpdateHeaderAsync() failed, filename=\"%s\", rc=%Rrc\n",
1079 pImage->pszFilename, rc));
1080 rc = vdIfIoIntFileFlush(pImage->pIfIo, pImage->pStorage, pIoCtx, NULL, NULL);
1081 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
1082 ("Flushing data to disk failed rc=%Rrc\n", rc));
1083 }
1084
1085 return rc;
1086}
1087
1088/**
1089 * Completion callback for meta/userdata reads or writes.
1090 *
1091 * @return VBox status code.
1092 * VINF_SUCCESS if everything was successful and the transfer can continue.
1093 * VERR_VD_ASYNC_IO_IN_PROGRESS if there is another data transfer pending.
1094 * @param pBackendData The opaque backend data.
1095 * @param pIoCtx I/O context associated with this request.
1096 * @param pvUser Opaque user data passed during a read/write request.
1097 * @param rcReq Status code for the completed request.
1098 */
1099static DECLCALLBACK(int) vdiDiscardBlockAsyncUpdate(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
1100{
1101 int rc = VINF_SUCCESS;
1102 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1103 PVDIBLOCKDISCARDASYNC pDiscardAsync = (PVDIBLOCKDISCARDASYNC)pvUser;
1104
1105 switch (pDiscardAsync->enmState)
1106 {
1107 case VDIBLOCKDISCARDSTATE_READ_BLOCK:
1108 {
1109 PVDMETAXFER pMetaXfer;
1110 uint64_t u64Offset = (uint64_t)pDiscardAsync->idxLastBlock * pImage->cbTotalBlockData + pImage->offStartData;
1111 rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage, u64Offset,
1112 pDiscardAsync->pvBlock, pImage->cbTotalBlockData, pIoCtx,
1113 &pMetaXfer, vdiDiscardBlockAsyncUpdate, pDiscardAsync);
1114 if (RT_FAILURE(rc))
1115 break;
1116
1117 /* Release immediately and go to next step. */
1118 vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
1119 pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_WRITE_BLOCK;
1120 }
1121 case VDIBLOCKDISCARDSTATE_WRITE_BLOCK:
1122 {
1123 /* Block read complete. Write to the new location (discarded block). */
1124 uint64_t u64Offset = (uint64_t)pDiscardAsync->ptrBlockDiscard * pImage->cbTotalBlockData + pImage->offStartData;
1125 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage, u64Offset,
1126 pDiscardAsync->pvBlock, pImage->cbTotalBlockData, pIoCtx,
1127 vdiDiscardBlockAsyncUpdate, pDiscardAsync);
1128
1129 pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_UPDATE_METADATA;
1130 if (RT_FAILURE(rc))
1131 break;
1132 }
1133 case VDIBLOCKDISCARDSTATE_UPDATE_METADATA:
1134 {
1135 int rc2;
1136
1137 /* Block write complete. Update metadata. */
1138 pImage->paBlocksRev[pDiscardAsync->idxLastBlock] = VDI_IMAGE_BLOCK_FREE;
1139 pImage->paBlocks[pDiscardAsync->uBlock] = VDI_IMAGE_BLOCK_ZERO;
1140
1141 if (pDiscardAsync->idxLastBlock != pDiscardAsync->ptrBlockDiscard)
1142 {
1143 pImage->paBlocks[pDiscardAsync->uBlockLast] = pDiscardAsync->ptrBlockDiscard;
1144 pImage->paBlocksRev[pDiscardAsync->ptrBlockDiscard] = pDiscardAsync->uBlockLast;
1145
1146 rc = vdiUpdateBlockInfoAsync(pImage, pDiscardAsync->uBlockLast, pIoCtx, false /* fUpdateHdr */);
1147 if ( RT_FAILURE(rc)
1148 && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
1149 break;
1150 }
1151
1152 setImageBlocksAllocated(&pImage->Header, pDiscardAsync->idxLastBlock);
1153 rc = vdiUpdateBlockInfoAsync(pImage, pDiscardAsync->uBlock, pIoCtx, true /* fUpdateHdr */);
1154 if ( RT_FAILURE(rc)
1155 && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
1156 break;
1157
1158 pImage->cbImage -= pImage->cbTotalBlockData;
1159 LogFlowFunc(("Set new size %llu\n", pImage->cbImage));
1160 rc2 = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, pImage->cbImage);
1161 if (RT_FAILURE(rc2))
1162 rc = rc2;
1163
1164 /* Free discard state. */
1165 RTMemFree(pDiscardAsync->pvBlock);
1166 RTMemFree(pDiscardAsync);
1167 break;
1168 }
1169 default:
1170 AssertMsgFailed(("Invalid state %d\n", pDiscardAsync->enmState));
1171 }
1172
1173 if (rc == VERR_VD_NOT_ENOUGH_METADATA)
1174 rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1175
1176 return rc;
1177}
1178
1179/**
1180 * Internal: Discard a whole block from the image filling the created hole with
1181 * data from another block - async I/O version.
1182 *
1183 * @returns VBox status code.
1184 * @param pImage VDI image instance data.
1185 * @param pIoCtx I/O context associated with this request.
1186 * @param uBlock The block to discard.
1187 * @param pvBlock Memory to use for the I/O.
1188 */
1189static int vdiDiscardBlockAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx,
1190 unsigned uBlock, void *pvBlock)
1191{
1192 int rc = VINF_SUCCESS;
1193 PVDIBLOCKDISCARDASYNC pDiscardAsync = NULL;
1194
1195 LogFlowFunc(("pImage=%#p uBlock=%u pvBlock=%#p\n",
1196 pImage, uBlock, pvBlock));
1197
1198 pDiscardAsync = (PVDIBLOCKDISCARDASYNC)RTMemAllocZ(sizeof(VDIBLOCKDISCARDASYNC));
1199 if (RT_UNLIKELY(!pDiscardAsync))
1200 return VERR_NO_MEMORY;
1201
1202 /* Init block discard state. */
1203 pDiscardAsync->uBlock = uBlock;
1204 pDiscardAsync->pvBlock = pvBlock;
1205 pDiscardAsync->ptrBlockDiscard = pImage->paBlocks[uBlock];
1206 pDiscardAsync->idxLastBlock = getImageBlocksAllocated(&pImage->Header) - 1;
1207 pDiscardAsync->uBlockLast = pImage->paBlocksRev[pDiscardAsync->idxLastBlock];
1208
1209 /*
1210 * The block is empty, remove it.
1211 * Read the last block of the image first.
1212 */
1213 if (pDiscardAsync->idxLastBlock != pDiscardAsync->ptrBlockDiscard)
1214 {
1215 LogFlowFunc(("Moving block [%u]=%u into [%u]=%u\n",
1216 pDiscardAsync->uBlockLast, pDiscardAsync->idxLastBlock,
1217 uBlock, pImage->paBlocks[uBlock]));
1218 pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_READ_BLOCK;
1219 }
1220 else
1221 {
1222 pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_UPDATE_METADATA; /* Start immediately to shrink the image. */
1223 LogFlowFunc(("Discard last block [%u]=%u\n", uBlock, pImage->paBlocks[uBlock]));
1224 }
1225
1226 /* Call the update callback directly. */
1227 rc = vdiDiscardBlockAsyncUpdate(pImage, pIoCtx, pDiscardAsync, VINF_SUCCESS);
1228
1229 LogFlowFunc(("returns rc=%Rrc\n", rc));
1230 return rc;
1231}
1232
1233/**
1234 * Internal: Creates a allocation bitmap from the given data.
1235 * Sectors which contain only 0 are marked as unallocated and sectors with
1236 * other data as allocated.
1237 *
1238 * @returns Pointer to the allocation bitmap or NULL on failure.
1239 * @param pvData The data to create the allocation bitmap for.
1240 * @param cbData Number of bytes in the buffer.
1241 */
1242static void *vdiAllocationBitmapCreate(void *pvData, size_t cbData)
1243{
1244 Assert(cbData <= UINT32_MAX / 8);
1245 uint32_t cSectors = (uint32_t)(cbData / 512);
1246 uint32_t uSectorCur = 0;
1247 void *pbmAllocationBitmap = NULL;
1248
1249 Assert(!(cbData % 512));
1250 Assert(!(cSectors % 8));
1251
1252 pbmAllocationBitmap = RTMemAllocZ(cSectors / 8);
1253 if (!pbmAllocationBitmap)
1254 return NULL;
1255
1256 while (uSectorCur < cSectors)
1257 {
1258 int idxSet = ASMBitFirstSet((uint8_t *)pvData + uSectorCur * 512, (uint32_t)cbData * 8);
1259
1260 if (idxSet != -1)
1261 {
1262 unsigned idxSectorAlloc = idxSet / 8 / 512;
1263 ASMBitSet(pbmAllocationBitmap, uSectorCur + idxSectorAlloc);
1264
1265 uSectorCur += idxSectorAlloc + 1;
1266 cbData -= (idxSectorAlloc + 1) * 512;
1267 }
1268 else
1269 break;
1270 }
1271
1272 return pbmAllocationBitmap;
1273}
1274
1275
1276/**
1277 * Updates the state of the async cluster allocation.
1278 *
1279 * @returns VBox status code.
1280 * @param pBackendData The opaque backend data.
1281 * @param pIoCtx I/O context associated with this request.
1282 * @param pvUser Opaque user data passed during a read/write request.
1283 * @param rcReq Status code for the completed request.
1284 */
1285static DECLCALLBACK(int) vdiBlockAllocUpdate(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
1286{
1287 int rc = VINF_SUCCESS;
1288 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1289 PVDIASYNCBLOCKALLOC pBlockAlloc = (PVDIASYNCBLOCKALLOC)pvUser;
1290
1291 if (RT_SUCCESS(rcReq))
1292 {
1293 pImage->cbImage += pImage->cbTotalBlockData;
1294 pImage->paBlocks[pBlockAlloc->uBlock] = pBlockAlloc->cBlocksAllocated;
1295
1296 if (pImage->paBlocksRev)
1297 pImage->paBlocksRev[pBlockAlloc->cBlocksAllocated] = pBlockAlloc->uBlock;
1298
1299 setImageBlocksAllocated(&pImage->Header, pBlockAlloc->cBlocksAllocated + 1);
1300 rc = vdiUpdateBlockInfoAsync(pImage, pBlockAlloc->uBlock, pIoCtx,
1301 true /* fUpdateHdr */);
1302 }
1303 /* else: I/O error don't update the block table. */
1304
1305 RTMemFree(pBlockAlloc);
1306 return rc;
1307}
1308
1309/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
1310static int vdiCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1311 PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
1312{
1313 LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
1314 int rc = VINF_SUCCESS;
1315 PVDIIMAGEDESC pImage;
1316
1317 if ( !VALID_PTR(pszFilename)
1318 || !*pszFilename)
1319 {
1320 rc = VERR_INVALID_PARAMETER;
1321 goto out;
1322 }
1323
1324 pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1325 if (!pImage)
1326 {
1327 rc = VERR_NO_MEMORY;
1328 goto out;
1329 }
1330 pImage->pszFilename = pszFilename;
1331 pImage->pStorage = NULL;
1332 pImage->paBlocks = NULL;
1333 pImage->pVDIfsDisk = pVDIfsDisk;
1334 pImage->pVDIfsImage = pVDIfsImage;
1335
1336 rc = vdiOpenImage(pImage, VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_READONLY);
1337 vdiFreeImage(pImage, false);
1338 RTMemFree(pImage);
1339
1340 if (RT_SUCCESS(rc))
1341 *penmType = VDTYPE_HDD;
1342
1343out:
1344 LogFlowFunc(("returns %Rrc\n", rc));
1345 return rc;
1346}
1347
1348/** @copydoc VBOXHDDBACKEND::pfnOpen */
1349static int vdiOpen(const char *pszFilename, unsigned uOpenFlags,
1350 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1351 VDTYPE enmType, void **ppBackendData)
1352{
1353 LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
1354 int rc;
1355 PVDIIMAGEDESC pImage;
1356
1357 /* Check open flags. All valid flags are supported. */
1358 if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1359 {
1360 rc = VERR_INVALID_PARAMETER;
1361 goto out;
1362 }
1363
1364 /* Check remaining arguments. */
1365 if ( !VALID_PTR(pszFilename)
1366 || !*pszFilename)
1367 {
1368 rc = VERR_INVALID_PARAMETER;
1369 goto out;
1370 }
1371
1372 pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1373 if (!pImage)
1374 {
1375 rc = VERR_NO_MEMORY;
1376 goto out;
1377 }
1378 pImage->pszFilename = pszFilename;
1379 pImage->pStorage = NULL;
1380 pImage->paBlocks = NULL;
1381 pImage->pVDIfsDisk = pVDIfsDisk;
1382 pImage->pVDIfsImage = pVDIfsImage;
1383
1384 rc = vdiOpenImage(pImage, uOpenFlags);
1385 if (RT_SUCCESS(rc))
1386 *ppBackendData = pImage;
1387 else
1388 RTMemFree(pImage);
1389
1390out:
1391 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1392 return rc;
1393}
1394
1395/** @copydoc VBOXHDDBACKEND::pfnCreate */
1396static int vdiCreate(const char *pszFilename, uint64_t cbSize,
1397 unsigned uImageFlags, const char *pszComment,
1398 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
1399 PCRTUUID pUuid, unsigned uOpenFlags,
1400 unsigned uPercentStart, unsigned uPercentSpan,
1401 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1402 PVDINTERFACE pVDIfsOperation, void **ppBackendData)
1403{
1404 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 ppBackendData=%#p\n", pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
1405 int rc;
1406 PVDIIMAGEDESC pImage;
1407
1408 PFNVDPROGRESS pfnProgress = NULL;
1409 void *pvUser = NULL;
1410 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
1411 if (pIfProgress)
1412 {
1413 pfnProgress = pIfProgress->pfnProgress;
1414 pvUser = pIfProgress->Core.pvUser;
1415 }
1416
1417 PVDINTERFACECONFIG pIfCfg = VDIfConfigGet(pVDIfsOperation);
1418
1419 /* Check the image flags. */
1420 if ((uImageFlags & ~VD_VDI_IMAGE_FLAGS_MASK) != 0)
1421 {
1422 rc = VERR_VD_INVALID_TYPE;
1423 goto out;
1424 }
1425
1426 /* Check open flags. All valid flags are supported. */
1427 if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1428 {
1429 rc = VERR_INVALID_PARAMETER;
1430 goto out;
1431 }
1432
1433 /* Check size. Maximum 4PB-3M. No tricks with adjusting the 1M block size
1434 * so far, which would extend the size. */
1435 if ( !cbSize
1436 || cbSize >= _1P * 4 - _1M * 3)
1437 {
1438 rc = VERR_VD_INVALID_SIZE;
1439 goto out;
1440 }
1441
1442 /* Check remaining arguments. */
1443 if ( !VALID_PTR(pszFilename)
1444 || !*pszFilename
1445 || cbSize < VDI_IMAGE_DEFAULT_BLOCK_SIZE
1446 || !VALID_PTR(pPCHSGeometry)
1447 || !VALID_PTR(pLCHSGeometry))
1448 {
1449 rc = VERR_INVALID_PARAMETER;
1450 goto out;
1451 }
1452
1453 pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1454 if (!pImage)
1455 {
1456 rc = VERR_NO_MEMORY;
1457 goto out;
1458 }
1459 pImage->pszFilename = pszFilename;
1460 pImage->pStorage = NULL;
1461 pImage->paBlocks = NULL;
1462 pImage->pVDIfsDisk = pVDIfsDisk;
1463 pImage->pVDIfsImage = pVDIfsImage;
1464
1465 rc = vdiCreateImage(pImage, cbSize, uImageFlags, pszComment,
1466 pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags,
1467 pfnProgress, pvUser, uPercentStart, uPercentSpan,
1468 pIfCfg);
1469 if (RT_SUCCESS(rc))
1470 {
1471 /* So far the image is opened in read/write mode. Make sure the
1472 * image is opened in read-only mode if the caller requested that. */
1473 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
1474 {
1475 vdiFreeImage(pImage, false);
1476 rc = vdiOpenImage(pImage, uOpenFlags);
1477 if (RT_FAILURE(rc))
1478 {
1479 RTMemFree(pImage);
1480 goto out;
1481 }
1482 }
1483 *ppBackendData = pImage;
1484 }
1485 else
1486 RTMemFree(pImage);
1487
1488out:
1489 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1490 return rc;
1491}
1492
1493/** @copydoc VBOXHDDBACKEND::pfnRename */
1494static int vdiRename(void *pBackendData, const char *pszFilename)
1495{
1496 LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
1497
1498 int rc = VINF_SUCCESS;
1499 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1500
1501 /* Check arguments. */
1502 if ( !pImage
1503 || !pszFilename
1504 || !*pszFilename)
1505 {
1506 rc = VERR_INVALID_PARAMETER;
1507 goto out;
1508 }
1509
1510 /* Close the image. */
1511 rc = vdiFreeImage(pImage, false);
1512 if (RT_SUCCESS(rc))
1513 {
1514 /* Rename the file. */
1515 rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
1516 if (RT_FAILURE(rc))
1517 {
1518 /* The move failed, try to reopen the original image. */
1519 int rc2 = vdiOpenImage(pImage, pImage->uOpenFlags);
1520 if (RT_FAILURE(rc2))
1521 rc = rc2;
1522
1523 goto out;
1524 }
1525
1526 /* Update pImage with the new information. */
1527 pImage->pszFilename = pszFilename;
1528
1529 /* Open the new image. */
1530 rc = vdiOpenImage(pImage, pImage->uOpenFlags);
1531 if (RT_FAILURE(rc))
1532 goto out;
1533 }
1534
1535out:
1536 LogFlowFunc(("returns %Rrc\n", rc));
1537 return rc;
1538}
1539
1540/** @copydoc VBOXHDDBACKEND::pfnClose */
1541static int vdiClose(void *pBackendData, bool fDelete)
1542{
1543 LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1544 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1545 int rc;
1546
1547 rc = vdiFreeImage(pImage, fDelete);
1548 RTMemFree(pImage);
1549
1550 LogFlowFunc(("returns %Rrc\n", rc));
1551 return rc;
1552}
1553
1554static int vdiRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1555 PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1556{
1557 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
1558 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
1559 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1560 unsigned uBlock;
1561 unsigned offRead;
1562 int rc;
1563
1564 AssertPtr(pImage);
1565 Assert(!(uOffset % 512));
1566 Assert(!(cbToRead % 512));
1567
1568 if ( uOffset + cbToRead > getImageDiskSize(&pImage->Header)
1569 || !VALID_PTR(pIoCtx)
1570 || !cbToRead)
1571 {
1572 rc = VERR_INVALID_PARAMETER;
1573 goto out;
1574 }
1575
1576 /* Calculate starting block number and offset inside it. */
1577 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1578 offRead = (unsigned)uOffset & pImage->uBlockMask;
1579
1580 /* Clip read range to at most the rest of the block. */
1581 cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
1582 Assert(!(cbToRead % 512));
1583
1584 if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
1585 rc = VERR_VD_BLOCK_FREE;
1586 else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
1587 {
1588 size_t cbSet;
1589
1590 cbSet = vdIfIoIntIoCtxSet(pImage->pIfIo, pIoCtx, 0, cbToRead);
1591 Assert(cbSet == cbToRead);
1592
1593 rc = VINF_SUCCESS;
1594 }
1595 else
1596 {
1597 /* Block present in image file, read relevant data. */
1598 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1599 + (pImage->offStartData + pImage->offStartBlockData + offRead);
1600
1601 if (u64Offset + cbToRead <= pImage->cbImage)
1602 rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, u64Offset,
1603 pIoCtx, cbToRead);
1604 else
1605 {
1606 LogRel(("VDI: Out of range access (%llu) in image %s, image size %llu\n",
1607 u64Offset, pImage->pszFilename, pImage->cbImage));
1608 vdIfIoIntIoCtxSet(pImage->pIfIo, pIoCtx, 0, cbToRead);
1609 rc = VERR_VD_READ_OUT_OF_RANGE;
1610 }
1611 }
1612
1613 if (pcbActuallyRead)
1614 *pcbActuallyRead = cbToRead;
1615
1616out:
1617 LogFlowFunc(("returns %Rrc\n", rc));
1618 return rc;
1619}
1620
1621static int vdiWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
1622 PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
1623 size_t *pcbPostRead, unsigned fWrite)
1624{
1625 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
1626 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
1627 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1628 unsigned uBlock;
1629 unsigned offWrite;
1630 int rc = VINF_SUCCESS;
1631
1632 AssertPtr(pImage);
1633 Assert(!(uOffset % 512));
1634 Assert(!(cbToWrite % 512));
1635
1636 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1637 {
1638 rc = VERR_VD_IMAGE_READ_ONLY;
1639 goto out;
1640 }
1641
1642 if (!VALID_PTR(pIoCtx) || !cbToWrite)
1643 {
1644 rc = VERR_INVALID_PARAMETER;
1645 goto out;
1646 }
1647
1648 /* No size check here, will do that later. For dynamic images which are
1649 * not multiples of the block size in length, this would prevent writing to
1650 * the last block. */
1651
1652 /* Calculate starting block number and offset inside it. */
1653 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1654 offWrite = (unsigned)uOffset & pImage->uBlockMask;
1655
1656 /* Clip write range to at most the rest of the block. */
1657 cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
1658 Assert(!(cbToWrite % 512));
1659
1660 do
1661 {
1662 if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
1663 {
1664 /* Block is either free or zero. */
1665 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
1666 && ( pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
1667 || cbToWrite == getImageBlockSize(&pImage->Header)))
1668 {
1669 /* If the destination block is unallocated at this point, it's
1670 * either a zero block or a block which hasn't been used so far
1671 * (which also means that it's a zero block. Don't need to write
1672 * anything to this block if the data consists of just zeroes. */
1673 if (vdIfIoIntIoCtxIsZero(pImage->pIfIo, pIoCtx, cbToWrite, true))
1674 {
1675 pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
1676 *pcbPreRead = 0;
1677 *pcbPostRead = 0;
1678 break;
1679 }
1680 }
1681
1682 if ( cbToWrite == getImageBlockSize(&pImage->Header)
1683 && !(fWrite & VD_WRITE_NO_ALLOC))
1684 {
1685 /* Full block write to previously unallocated block.
1686 * Allocate block and write data. */
1687 Assert(!offWrite);
1688 PVDIASYNCBLOCKALLOC pBlockAlloc = (PVDIASYNCBLOCKALLOC)RTMemAllocZ(sizeof(VDIASYNCBLOCKALLOC));
1689 if (!pBlockAlloc)
1690 {
1691 rc = VERR_NO_MEMORY;
1692 break;
1693 }
1694
1695 unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
1696 uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
1697 + (pImage->offStartData + pImage->offStartBlockData);
1698
1699 pBlockAlloc->cBlocksAllocated = cBlocksAllocated;
1700 pBlockAlloc->uBlock = uBlock;
1701
1702 *pcbPreRead = 0;
1703 *pcbPostRead = 0;
1704
1705 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1706 u64Offset, pIoCtx, cbToWrite,
1707 vdiBlockAllocUpdate, pBlockAlloc);
1708 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1709 break;
1710 else if (RT_FAILURE(rc))
1711 {
1712 RTMemFree(pBlockAlloc);
1713 break;
1714 }
1715
1716 rc = vdiBlockAllocUpdate(pImage, pIoCtx, pBlockAlloc, rc);
1717 }
1718 else
1719 {
1720 /* Trying to do a partial write to an unallocated block. Don't do
1721 * anything except letting the upper layer know what to do. */
1722 *pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
1723 *pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - *pcbPreRead;
1724 rc = VERR_VD_BLOCK_FREE;
1725 }
1726 }
1727 else
1728 {
1729 /* Block present in image file, write relevant data. */
1730 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1731 + (pImage->offStartData + pImage->offStartBlockData + offWrite);
1732 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1733 u64Offset, pIoCtx, cbToWrite, NULL, NULL);
1734 }
1735 } while (0);
1736
1737 if (pcbWriteProcess)
1738 *pcbWriteProcess = cbToWrite;
1739
1740out:
1741 LogFlowFunc(("returns %Rrc\n", rc));
1742 return rc;
1743}
1744
1745static int vdiFlush(void *pBackendData, PVDIOCTX pIoCtx)
1746{
1747 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1748 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1749 int rc = VINF_SUCCESS;
1750
1751 Assert(pImage);
1752
1753 rc = vdiFlushImageIoCtx(pImage, pIoCtx);
1754 LogFlowFunc(("returns %Rrc\n", rc));
1755 return rc;
1756}
1757
1758/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
1759static unsigned vdiGetVersion(void *pBackendData)
1760{
1761 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1762 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1763 unsigned uVersion;
1764
1765 AssertPtr(pImage);
1766
1767 if (pImage)
1768 uVersion = pImage->PreHeader.u32Version;
1769 else
1770 uVersion = 0;
1771
1772 LogFlowFunc(("returns %#x\n", uVersion));
1773 return uVersion;
1774}
1775
1776/** @copydoc VBOXHDDBACKEND::pfnGetSectorSize */
1777static uint32_t vdiGetSectorSize(void *pBackendData)
1778{
1779 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1780 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1781 uint64_t cbSector = 0;
1782
1783 AssertPtr(pImage);
1784
1785 if (pImage && pImage->pStorage)
1786 cbSector = 512;
1787
1788 LogFlowFunc(("returns %zu\n", cbSector));
1789 return cbSector;
1790}
1791
1792/** @copydoc VBOXHDDBACKEND::pfnGetSize */
1793static uint64_t vdiGetSize(void *pBackendData)
1794{
1795 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1796 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1797 uint64_t cbSize;
1798
1799 AssertPtr(pImage);
1800
1801 if (pImage)
1802 cbSize = getImageDiskSize(&pImage->Header);
1803 else
1804 cbSize = 0;
1805
1806 LogFlowFunc(("returns %llu\n", cbSize));
1807 return cbSize;
1808}
1809
1810/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
1811static uint64_t vdiGetFileSize(void *pBackendData)
1812{
1813 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1814 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1815 uint64_t cb = 0;
1816
1817 AssertPtr(pImage);
1818
1819 if (pImage)
1820 {
1821 uint64_t cbFile;
1822 if (pImage->pStorage)
1823 {
1824 int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
1825 if (RT_SUCCESS(rc))
1826 cb += cbFile;
1827 }
1828 }
1829
1830 LogFlowFunc(("returns %lld\n", cb));
1831 return cb;
1832}
1833
1834/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
1835static int vdiGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
1836{
1837 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1838 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1839 int rc;
1840
1841 AssertPtr(pImage);
1842
1843 if (pImage)
1844 {
1845 if (pImage->PCHSGeometry.cCylinders)
1846 {
1847 *pPCHSGeometry = pImage->PCHSGeometry;
1848 rc = VINF_SUCCESS;
1849 }
1850 else
1851 rc = VERR_VD_GEOMETRY_NOT_SET;
1852 }
1853 else
1854 rc = VERR_VD_NOT_OPENED;
1855
1856 LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1857 return rc;
1858}
1859
1860/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
1861static int vdiSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
1862{
1863 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1864 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1865 int rc;
1866
1867 AssertPtr(pImage);
1868
1869 if (pImage)
1870 {
1871 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1872 {
1873 rc = VERR_VD_IMAGE_READ_ONLY;
1874 goto out;
1875 }
1876
1877 pImage->PCHSGeometry = *pPCHSGeometry;
1878 rc = VINF_SUCCESS;
1879 }
1880 else
1881 rc = VERR_VD_NOT_OPENED;
1882
1883out:
1884 LogFlowFunc(("returns %Rrc\n", rc));
1885 return rc;
1886}
1887
1888/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
1889static int vdiGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
1890{
1891 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1892 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1893 int rc;
1894
1895 AssertPtr(pImage);
1896
1897 if (pImage)
1898 {
1899 VDIDISKGEOMETRY DummyGeo = { 0, 0, 0, VDI_GEOMETRY_SECTOR_SIZE };
1900 PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
1901 if (!pGeometry)
1902 pGeometry = &DummyGeo;
1903
1904 if ( pGeometry->cCylinders > 0
1905 && pGeometry->cHeads > 0
1906 && pGeometry->cSectors > 0)
1907 {
1908 pLCHSGeometry->cCylinders = pGeometry->cCylinders;
1909 pLCHSGeometry->cHeads = pGeometry->cHeads;
1910 pLCHSGeometry->cSectors = pGeometry->cSectors;
1911 rc = VINF_SUCCESS;
1912 }
1913 else
1914 rc = VERR_VD_GEOMETRY_NOT_SET;
1915 }
1916 else
1917 rc = VERR_VD_NOT_OPENED;
1918
1919 LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1920 return rc;
1921}
1922
1923/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
1924static int vdiSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
1925{
1926 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1927 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1928 PVDIDISKGEOMETRY pGeometry;
1929 int rc;
1930
1931 AssertPtr(pImage);
1932
1933 if (pImage)
1934 {
1935 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1936 {
1937 rc = VERR_VD_IMAGE_READ_ONLY;
1938 goto out;
1939 }
1940
1941 pGeometry = getImageLCHSGeometry(&pImage->Header);
1942 if (pGeometry)
1943 {
1944 pGeometry->cCylinders = pLCHSGeometry->cCylinders;
1945 pGeometry->cHeads = pLCHSGeometry->cHeads;
1946 pGeometry->cSectors = pLCHSGeometry->cSectors;
1947 pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
1948
1949 /* Update header information in base image file. */
1950 vdiFlushImage(pImage);
1951 }
1952 rc = VINF_SUCCESS;
1953 }
1954 else
1955 rc = VERR_VD_NOT_OPENED;
1956
1957out:
1958 LogFlowFunc(("returns %Rrc\n", rc));
1959 return rc;
1960}
1961
1962/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
1963static unsigned vdiGetImageFlags(void *pBackendData)
1964{
1965 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1966 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1967 unsigned uImageFlags;
1968
1969 AssertPtr(pImage);
1970
1971 if (pImage)
1972 uImageFlags = pImage->uImageFlags;
1973 else
1974 uImageFlags = 0;
1975
1976 LogFlowFunc(("returns %#x\n", uImageFlags));
1977 return uImageFlags;
1978}
1979
1980/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
1981static unsigned vdiGetOpenFlags(void *pBackendData)
1982{
1983 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1984 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1985 unsigned uOpenFlags;
1986
1987 AssertPtr(pImage);
1988
1989 if (pImage)
1990 uOpenFlags = pImage->uOpenFlags;
1991 else
1992 uOpenFlags = 0;
1993
1994 LogFlowFunc(("returns %#x\n", uOpenFlags));
1995 return uOpenFlags;
1996}
1997
1998/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
1999static int vdiSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
2000{
2001 LogFlowFunc(("pBackendData=%#p uOpenFlags=%#x\n", pBackendData, uOpenFlags));
2002 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2003 int rc;
2004 const char *pszFilename;
2005
2006 /* Image must be opened and the new flags must be valid. */
2007 if (!pImage || (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO
2008 | VD_OPEN_FLAGS_ASYNC_IO | VD_OPEN_FLAGS_SHAREABLE
2009 | VD_OPEN_FLAGS_SEQUENTIAL | VD_OPEN_FLAGS_DISCARD
2010 | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
2011 {
2012 rc = VERR_INVALID_PARAMETER;
2013 goto out;
2014 }
2015
2016 /* Implement this operation via reopening the image. */
2017 pszFilename = pImage->pszFilename;
2018 rc = vdiFreeImage(pImage, false);
2019 if (RT_FAILURE(rc))
2020 goto out;
2021 rc = vdiOpenImage(pImage, uOpenFlags);
2022
2023out:
2024 LogFlowFunc(("returns %Rrc\n", rc));
2025 return rc;
2026}
2027
2028/** @copydoc VBOXHDDBACKEND::pfnGetComment */
2029static int vdiGetComment(void *pBackendData, char *pszComment,
2030 size_t cbComment)
2031{
2032 LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
2033 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2034 int rc = VINF_SUCCESS;
2035
2036 AssertPtr(pImage);
2037
2038 if (pImage)
2039 {
2040 char *pszTmp = getImageComment(&pImage->Header);
2041 /* Make this foolproof even if the image doesn't have the zero
2042 * termination. With some luck the repaired header will be saved. */
2043 size_t cb = RTStrNLen(pszTmp, VDI_IMAGE_COMMENT_SIZE);
2044 if (cb == VDI_IMAGE_COMMENT_SIZE)
2045 {
2046 pszTmp[VDI_IMAGE_COMMENT_SIZE-1] = '\0';
2047 cb--;
2048 }
2049 if (cb < cbComment)
2050 {
2051 /* memcpy is much better than strncpy. */
2052 memcpy(pszComment, pszTmp, cb + 1);
2053 }
2054 else
2055 rc = VERR_BUFFER_OVERFLOW;
2056 }
2057 else
2058 rc = VERR_VD_NOT_OPENED;
2059
2060 LogFlowFunc(("returns %Rrc comment=\"%s\"\n", rc, pszComment));
2061 return rc;
2062}
2063
2064/** @copydoc VBOXHDDBACKEND::pfnGetComment */
2065static int vdiSetComment(void *pBackendData, const char *pszComment)
2066{
2067 LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
2068 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2069 int rc;
2070
2071 AssertPtr(pImage);
2072
2073 if (pImage)
2074 {
2075 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2076 rc = VERR_VD_IMAGE_READ_ONLY;
2077 else
2078 {
2079 size_t cchComment = pszComment ? strlen(pszComment) : 0;
2080 if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
2081 {
2082 LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
2083 rc = VERR_VD_VDI_COMMENT_TOO_LONG;
2084 goto out;
2085 }
2086
2087 /* we don't support old style images */
2088 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
2089 {
2090 /*
2091 * Update the comment field, making sure to zero out all of the previous comment.
2092 */
2093 memset(pImage->Header.u.v1.szComment, '\0', VDI_IMAGE_COMMENT_SIZE);
2094 memcpy(pImage->Header.u.v1.szComment, pszComment, cchComment);
2095
2096 /* write out new the header */
2097 rc = vdiUpdateHeader(pImage);
2098 }
2099 else
2100 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
2101 }
2102 }
2103 else
2104 rc = VERR_VD_NOT_OPENED;
2105
2106out:
2107 LogFlowFunc(("returns %Rrc\n", rc));
2108 return rc;
2109}
2110
2111/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
2112static int vdiGetUuid(void *pBackendData, PRTUUID pUuid)
2113{
2114 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2115 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2116 int rc;
2117
2118 AssertPtr(pImage);
2119
2120 if (pImage)
2121 {
2122 *pUuid = *getImageCreationUUID(&pImage->Header);
2123 rc = VINF_SUCCESS;
2124 }
2125 else
2126 rc = VERR_VD_NOT_OPENED;
2127
2128 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2129 return rc;
2130}
2131
2132/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
2133static int vdiSetUuid(void *pBackendData, PCRTUUID pUuid)
2134{
2135 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2136 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2137 int rc = VINF_SUCCESS;
2138
2139 AssertPtr(pImage);
2140
2141 if (pImage)
2142 {
2143 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2144 {
2145 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
2146 pImage->Header.u.v1.uuidCreate = *pUuid;
2147 /* Make it possible to clone old VDIs. */
2148 else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
2149 pImage->Header.u.v0.uuidCreate = *pUuid;
2150 else
2151 {
2152 LogFunc(("Version is not supported!\n"));
2153 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
2154 }
2155 }
2156 else
2157 rc = VERR_VD_IMAGE_READ_ONLY;
2158 }
2159 else
2160 rc = VERR_VD_NOT_OPENED;
2161
2162 LogFlowFunc(("returns %Rrc\n", rc));
2163 return rc;
2164}
2165
2166/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
2167static int vdiGetModificationUuid(void *pBackendData, PRTUUID pUuid)
2168{
2169 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2170 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2171 int rc;
2172
2173 AssertPtr(pImage);
2174
2175 if (pImage)
2176 {
2177 *pUuid = *getImageModificationUUID(&pImage->Header);
2178 rc = VINF_SUCCESS;
2179 }
2180 else
2181 rc = VERR_VD_NOT_OPENED;
2182
2183 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2184 return rc;
2185}
2186
2187/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
2188static int vdiSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
2189{
2190 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2191 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2192 int rc = VINF_SUCCESS;
2193
2194 AssertPtr(pImage);
2195
2196 if (pImage)
2197 {
2198 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2199 {
2200 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
2201 pImage->Header.u.v1.uuidModify = *pUuid;
2202 /* Make it possible to clone old VDIs. */
2203 else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
2204 pImage->Header.u.v0.uuidModify = *pUuid;
2205 else
2206 {
2207 LogFunc(("Version is not supported!\n"));
2208 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
2209 }
2210 }
2211 else
2212 rc = VERR_VD_IMAGE_READ_ONLY;
2213 }
2214 else
2215 rc = VERR_VD_NOT_OPENED;
2216
2217 LogFlowFunc(("returns %Rrc\n", rc));
2218 return rc;
2219}
2220
2221/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
2222static int vdiGetParentUuid(void *pBackendData, PRTUUID pUuid)
2223{
2224 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2225 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2226 int rc;
2227
2228 AssertPtr(pImage);
2229
2230 if (pImage)
2231 {
2232 *pUuid = *getImageParentUUID(&pImage->Header);
2233 rc = VINF_SUCCESS;
2234 }
2235 else
2236 rc = VERR_VD_NOT_OPENED;
2237
2238 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2239 return rc;
2240}
2241
2242/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
2243static int vdiSetParentUuid(void *pBackendData, PCRTUUID pUuid)
2244{
2245 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2246 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2247 int rc = VINF_SUCCESS;
2248
2249 AssertPtr(pImage);
2250
2251 if (pImage)
2252 {
2253 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2254 {
2255 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
2256 pImage->Header.u.v1.uuidLinkage = *pUuid;
2257 /* Make it possible to clone old VDIs. */
2258 else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
2259 pImage->Header.u.v0.uuidLinkage = *pUuid;
2260 else
2261 {
2262 LogFunc(("Version is not supported!\n"));
2263 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
2264 }
2265 }
2266 else
2267 rc = VERR_VD_IMAGE_READ_ONLY;
2268 }
2269 else
2270 rc = VERR_VD_NOT_OPENED;
2271
2272 LogFlowFunc(("returns %Rrc\n", rc));
2273 return rc;
2274}
2275
2276/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
2277static int vdiGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
2278{
2279 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2280 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2281 int rc;
2282
2283 AssertPtr(pImage);
2284
2285 if (pImage)
2286 {
2287 *pUuid = *getImageParentModificationUUID(&pImage->Header);
2288 rc = VINF_SUCCESS;
2289 }
2290 else
2291 rc = VERR_VD_NOT_OPENED;
2292
2293 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2294 return rc;
2295}
2296
2297/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
2298static int vdiSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
2299{
2300 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2301 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2302 int rc = VINF_SUCCESS;
2303
2304 AssertPtr(pImage);
2305
2306 if (pImage)
2307 {
2308 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2309 {
2310 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
2311 pImage->Header.u.v1.uuidParentModify = *pUuid;
2312 else
2313 {
2314 LogFunc(("Version is not supported!\n"));
2315 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
2316 }
2317 }
2318 else
2319 rc = VERR_VD_IMAGE_READ_ONLY;
2320 }
2321 else
2322 rc = VERR_VD_NOT_OPENED;
2323
2324 LogFlowFunc(("returns %Rrc\n", rc));
2325 return rc;
2326}
2327
2328/** @copydoc VBOXHDDBACKEND::pfnDump */
2329static void vdiDump(void *pBackendData)
2330{
2331 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2332
2333 vdIfErrorMessage(pImage->pIfError, "Dumping VDI image \"%s\" mode=%s uOpenFlags=%X File=%#p\n",
2334 pImage->pszFilename,
2335 (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY) ? "r/o" : "r/w",
2336 pImage->uOpenFlags,
2337 pImage->pStorage);
2338 vdIfErrorMessage(pImage->pIfError, "Header: Version=%08X Type=%X Flags=%X Size=%llu\n",
2339 pImage->PreHeader.u32Version,
2340 getImageType(&pImage->Header),
2341 getImageFlags(&pImage->Header),
2342 getImageDiskSize(&pImage->Header));
2343 vdIfErrorMessage(pImage->pIfError, "Header: cbBlock=%u cbBlockExtra=%u cBlocks=%u cBlocksAllocated=%u\n",
2344 getImageBlockSize(&pImage->Header),
2345 getImageExtraBlockSize(&pImage->Header),
2346 getImageBlocks(&pImage->Header),
2347 getImageBlocksAllocated(&pImage->Header));
2348 vdIfErrorMessage(pImage->pIfError, "Header: offBlocks=%u offData=%u\n",
2349 getImageBlocksOffset(&pImage->Header),
2350 getImageDataOffset(&pImage->Header));
2351 PVDIDISKGEOMETRY pg = getImageLCHSGeometry(&pImage->Header);
2352 if (pg)
2353 vdIfErrorMessage(pImage->pIfError, "Header: Geometry: C/H/S=%u/%u/%u cbSector=%u\n",
2354 pg->cCylinders, pg->cHeads, pg->cSectors, pg->cbSector);
2355 vdIfErrorMessage(pImage->pIfError, "Header: uuidCreation={%RTuuid}\n", getImageCreationUUID(&pImage->Header));
2356 vdIfErrorMessage(pImage->pIfError, "Header: uuidModification={%RTuuid}\n", getImageModificationUUID(&pImage->Header));
2357 vdIfErrorMessage(pImage->pIfError, "Header: uuidParent={%RTuuid}\n", getImageParentUUID(&pImage->Header));
2358 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) >= 1)
2359 vdIfErrorMessage(pImage->pIfError, "Header: uuidParentModification={%RTuuid}\n", getImageParentModificationUUID(&pImage->Header));
2360 vdIfErrorMessage(pImage->pIfError, "Image: fFlags=%08X offStartBlocks=%u offStartData=%u\n",
2361 pImage->uImageFlags, pImage->offStartBlocks, pImage->offStartData);
2362 vdIfErrorMessage(pImage->pIfError, "Image: uBlockMask=%08X cbTotalBlockData=%u uShiftOffset2Index=%u offStartBlockData=%u\n",
2363 pImage->uBlockMask,
2364 pImage->cbTotalBlockData,
2365 pImage->uShiftOffset2Index,
2366 pImage->offStartBlockData);
2367
2368 unsigned uBlock, cBlocksNotFree, cBadBlocks, cBlocks = getImageBlocks(&pImage->Header);
2369 for (uBlock=0, cBlocksNotFree=0, cBadBlocks=0; uBlock<cBlocks; uBlock++)
2370 {
2371 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
2372 {
2373 cBlocksNotFree++;
2374 if (pImage->paBlocks[uBlock] >= cBlocks)
2375 cBadBlocks++;
2376 }
2377 }
2378 if (cBlocksNotFree != getImageBlocksAllocated(&pImage->Header))
2379 {
2380 vdIfErrorMessage(pImage->pIfError, "!! WARNING: %u blocks actually allocated (cBlocksAllocated=%u) !!\n",
2381 cBlocksNotFree, getImageBlocksAllocated(&pImage->Header));
2382 }
2383 if (cBadBlocks)
2384 {
2385 vdIfErrorMessage(pImage->pIfError, "!! WARNING: %u bad blocks found !!\n",
2386 cBadBlocks);
2387 }
2388}
2389
2390/** @copydoc VBOXHDDBACKEND::pfnCompact */
2391static int vdiCompact(void *pBackendData, unsigned uPercentStart,
2392 unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
2393 PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation)
2394{
2395 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2396 int rc = VINF_SUCCESS;
2397 void *pvBuf = NULL, *pvTmp = NULL;
2398 unsigned *paBlocks2 = NULL;
2399
2400 int (*pfnParentRead)(void *, uint64_t, void *, size_t) = NULL;
2401 void *pvParent = NULL;
2402 PVDINTERFACEPARENTSTATE pIfParentState = VDIfParentStateGet(pVDIfsOperation);
2403 if (pIfParentState)
2404 {
2405 pfnParentRead = pIfParentState->pfnParentRead;
2406 pvParent = pIfParentState->Core.pvUser;
2407 }
2408
2409 PFNVDPROGRESS pfnProgress = NULL;
2410 void *pvUser = NULL;
2411 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
2412
2413 PVDINTERFACEQUERYRANGEUSE pIfQueryRangeUse = VDIfQueryRangeUseGet(pVDIfsOperation);
2414
2415 do {
2416 AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
2417
2418 AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2419 rc = VERR_VD_IMAGE_READ_ONLY);
2420
2421 unsigned cBlocks;
2422 unsigned cBlocksToMove = 0;
2423 size_t cbBlock;
2424 cBlocks = getImageBlocks(&pImage->Header);
2425 cbBlock = getImageBlockSize(&pImage->Header);
2426 if (pfnParentRead)
2427 {
2428 pvBuf = RTMemTmpAlloc(cbBlock);
2429 AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
2430 }
2431 pvTmp = RTMemTmpAlloc(cbBlock);
2432 AssertBreakStmt(VALID_PTR(pvTmp), rc = VERR_NO_MEMORY);
2433
2434 uint64_t cbFile;
2435 rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
2436 AssertRCBreak(rc);
2437 unsigned cBlocksAllocated = (unsigned)((cbFile - pImage->offStartData - pImage->offStartBlockData) >> pImage->uShiftOffset2Index);
2438 if (cBlocksAllocated == 0)
2439 {
2440 /* No data blocks in this image, no need to compact. */
2441 rc = VINF_SUCCESS;
2442 break;
2443 }
2444
2445 /* Allocate block array for back resolving. */
2446 paBlocks2 = (unsigned *)RTMemAlloc(sizeof(unsigned *) * cBlocksAllocated);
2447 AssertBreakStmt(VALID_PTR(paBlocks2), rc = VERR_NO_MEMORY);
2448 /* Fill out back resolving, check/fix allocation errors before
2449 * compacting the image, just to be on the safe side. Update the
2450 * image contents straight away, as this enables cancelling. */
2451 for (unsigned i = 0; i < cBlocksAllocated; i++)
2452 paBlocks2[i] = VDI_IMAGE_BLOCK_FREE;
2453 rc = VINF_SUCCESS;
2454 for (unsigned i = 0; i < cBlocks; i++)
2455 {
2456 VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
2457 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
2458 {
2459 if (ptrBlock < cBlocksAllocated)
2460 {
2461 if (paBlocks2[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
2462 paBlocks2[ptrBlock] = i;
2463 else
2464 {
2465 LogFunc(("Freed cross-linked block %u in file \"%s\"\n",
2466 i, pImage->pszFilename));
2467 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2468 rc = vdiUpdateBlockInfo(pImage, i);
2469 if (RT_FAILURE(rc))
2470 break;
2471 }
2472 }
2473 else
2474 {
2475 LogFunc(("Freed out of bounds reference for block %u in file \"%s\"\n",
2476 i, pImage->pszFilename));
2477 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2478 rc = vdiUpdateBlockInfo(pImage, i);
2479 if (RT_FAILURE(rc))
2480 break;
2481 }
2482 }
2483 }
2484 if (RT_FAILURE(rc))
2485 break;
2486
2487 /* Find redundant information and update the block pointers
2488 * accordingly, creating bubbles. Keep disk up to date, as this
2489 * enables cancelling. */
2490 for (unsigned i = 0; i < cBlocks; i++)
2491 {
2492 VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
2493 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
2494 {
2495 /* Block present in image file, read relevant data. */
2496 uint64_t u64Offset = (uint64_t)ptrBlock * pImage->cbTotalBlockData
2497 + (pImage->offStartData + pImage->offStartBlockData);
2498 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, u64Offset, pvTmp, cbBlock);
2499 if (RT_FAILURE(rc))
2500 break;
2501
2502 if (ASMBitFirstSet((volatile void *)pvTmp, (uint32_t)cbBlock * 8) == -1)
2503 {
2504 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_ZERO;
2505 rc = vdiUpdateBlockInfo(pImage, i);
2506 if (RT_FAILURE(rc))
2507 break;
2508 paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2509 /* Adjust progress info, one block to be relocated. */
2510 cBlocksToMove++;
2511 }
2512 else if (pfnParentRead)
2513 {
2514 rc = pfnParentRead(pvParent, (uint64_t)i * cbBlock, pvBuf, cbBlock);
2515 if (RT_FAILURE(rc))
2516 break;
2517 if (!memcmp(pvTmp, pvBuf, cbBlock))
2518 {
2519 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2520 rc = vdiUpdateBlockInfo(pImage, i);
2521 if (RT_FAILURE(rc))
2522 break;
2523 paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2524 /* Adjust progress info, one block to be relocated. */
2525 cBlocksToMove++;
2526 }
2527 }
2528 }
2529
2530 /* Check if the range is in use if the block is still allocated. */
2531 ptrBlock = pImage->paBlocks[i];
2532 if ( IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock)
2533 && pIfQueryRangeUse)
2534 {
2535 bool fUsed = true;
2536
2537 rc = vdIfQueryRangeUse(pIfQueryRangeUse, (uint64_t)i * cbBlock, cbBlock, &fUsed);
2538 if (RT_FAILURE(rc))
2539 break;
2540 if (!fUsed)
2541 {
2542 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_ZERO;
2543 rc = vdiUpdateBlockInfo(pImage, i);
2544 if (RT_FAILURE(rc))
2545 break;
2546 paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2547 /* Adjust progress info, one block to be relocated. */
2548 cBlocksToMove++;
2549 }
2550 }
2551
2552 if (pIfProgress && pIfProgress->pfnProgress)
2553 {
2554 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2555 (uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2556 if (RT_FAILURE(rc))
2557 break;
2558 }
2559 }
2560 if (RT_FAILURE(rc))
2561 break;
2562
2563 /* Fill bubbles with other data (if available). */
2564 unsigned cBlocksMoved = 0;
2565 unsigned uBlockUsedPos = cBlocksAllocated;
2566 for (unsigned i = 0; i < cBlocksAllocated; i++)
2567 {
2568 unsigned uBlock = paBlocks2[i];
2569 if (uBlock == VDI_IMAGE_BLOCK_FREE)
2570 {
2571 unsigned uBlockData = VDI_IMAGE_BLOCK_FREE;
2572 while (uBlockUsedPos > i && uBlockData == VDI_IMAGE_BLOCK_FREE)
2573 {
2574 uBlockUsedPos--;
2575 uBlockData = paBlocks2[uBlockUsedPos];
2576 }
2577 /* Terminate early if there is no block which needs copying. */
2578 if (uBlockUsedPos == i)
2579 break;
2580 uint64_t u64Offset = (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2581 + (pImage->offStartData + pImage->offStartBlockData);
2582 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, u64Offset,
2583 pvTmp, cbBlock);
2584 u64Offset = (uint64_t)i * pImage->cbTotalBlockData
2585 + (pImage->offStartData + pImage->offStartBlockData);
2586 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, u64Offset,
2587 pvTmp, cbBlock);
2588 pImage->paBlocks[uBlockData] = i;
2589 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated - cBlocksMoved);
2590 rc = vdiUpdateBlockInfo(pImage, uBlockData);
2591 if (RT_FAILURE(rc))
2592 break;
2593 paBlocks2[i] = uBlockData;
2594 paBlocks2[uBlockUsedPos] = VDI_IMAGE_BLOCK_FREE;
2595 cBlocksMoved++;
2596 }
2597
2598 if (pIfProgress && pIfProgress->pfnProgress)
2599 {
2600 rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2601 (uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2602
2603 if (RT_FAILURE(rc))
2604 break;
2605 }
2606 }
2607 if (RT_FAILURE(rc))
2608 break;
2609
2610 /* Update image header. */
2611 setImageBlocksAllocated(&pImage->Header, uBlockUsedPos);
2612 vdiUpdateHeader(pImage);
2613
2614 /* Truncate the image to the proper size to finish compacting. */
2615 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
2616 (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2617 + pImage->offStartData + pImage->offStartBlockData);
2618 } while (0);
2619
2620 if (paBlocks2)
2621 RTMemTmpFree(paBlocks2);
2622 if (pvTmp)
2623 RTMemTmpFree(pvTmp);
2624 if (pvBuf)
2625 RTMemTmpFree(pvBuf);
2626
2627 if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
2628 {
2629 pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2630 uPercentStart + uPercentSpan);
2631 }
2632
2633 LogFlowFunc(("returns %Rrc\n", rc));
2634 return rc;
2635}
2636
2637
2638/** @copydoc VBOXHDDBACKEND::pfnResize */
2639static int vdiResize(void *pBackendData, uint64_t cbSize,
2640 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
2641 unsigned uPercentStart, unsigned uPercentSpan,
2642 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
2643 PVDINTERFACE pVDIfsOperation)
2644{
2645 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2646 int rc = VINF_SUCCESS;
2647
2648 PFNVDPROGRESS pfnProgress = NULL;
2649 void *pvUser = NULL;
2650 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
2651
2652 /*
2653 * Making the image smaller is not supported at the moment.
2654 * Resizing is also not supported for fixed size images and
2655 * very old images.
2656 */
2657 /** @todo implement making the image smaller, it is the responsibility of
2658 * the user to know what he's doing. */
2659 if ( cbSize < getImageDiskSize(&pImage->Header)
2660 || GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0
2661 || pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2662 rc = VERR_NOT_SUPPORTED;
2663 else if (cbSize > getImageDiskSize(&pImage->Header))
2664 {
2665 unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header); /** < Blocks currently allocated, doesn't change during resize */
2666 uint32_t cBlocksNew = cbSize / getImageBlockSize(&pImage->Header); /** < New number of blocks in the image after the resize */
2667 if (cbSize % getImageBlockSize(&pImage->Header))
2668 cBlocksNew++;
2669
2670 uint32_t cBlocksOld = getImageBlocks(&pImage->Header); /** < Number of blocks before the resize. */
2671 uint64_t cbBlockspaceNew = cBlocksNew * sizeof(VDIIMAGEBLOCKPOINTER); /** < Required space for the block array after the resize. */
2672 uint64_t offStartDataNew = RT_ALIGN_32(pImage->offStartBlocks + cbBlockspaceNew, VDI_DATA_ALIGN); /** < New start offset for block data after the resize */
2673
2674 if ( pImage->offStartData != offStartDataNew
2675 && cBlocksAllocated > 0)
2676 {
2677 /* Calculate how many sectors need to be relocated. */
2678 uint64_t cbOverlapping = offStartDataNew - pImage->offStartData;
2679 unsigned cBlocksReloc = cbOverlapping / getImageBlockSize(&pImage->Header);
2680 if (cbOverlapping % getImageBlockSize(&pImage->Header))
2681 cBlocksReloc++;
2682
2683 /* Since only full blocks can be relocated the new data start is
2684 * determined by moving it block by block. */
2685 cBlocksReloc = RT_MIN(cBlocksReloc, cBlocksAllocated);
2686 offStartDataNew = pImage->offStartData;
2687
2688 /* Do the relocation. */
2689 LogFlow(("Relocating %u blocks\n", cBlocksReloc));
2690
2691 /*
2692 * Get the blocks we need to relocate first, they are appended to the end
2693 * of the image.
2694 */
2695 void *pvBuf = NULL, *pvZero = NULL;
2696 do
2697 {
2698 /* Allocate data buffer. */
2699 pvBuf = RTMemAllocZ(pImage->cbTotalBlockData);
2700 if (!pvBuf)
2701 {
2702 rc = VERR_NO_MEMORY;
2703 break;
2704 }
2705
2706 /* Allocate buffer for overwriting with zeroes. */
2707 pvZero = RTMemAllocZ(pImage->cbTotalBlockData);
2708 if (!pvZero)
2709 {
2710 rc = VERR_NO_MEMORY;
2711 break;
2712 }
2713
2714 for (unsigned i = 0; i < cBlocksReloc; i++)
2715 {
2716 /* Search the index in the block table. */
2717 for (unsigned idxBlock = 0; idxBlock < cBlocksOld; idxBlock++)
2718 {
2719 if (!pImage->paBlocks[idxBlock])
2720 {
2721 /* Read data and append to the end of the image. */
2722 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2723 offStartDataNew, pvBuf,
2724 pImage->cbTotalBlockData);
2725 if (RT_FAILURE(rc))
2726 break;
2727
2728 uint64_t offBlockAppend;
2729 rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &offBlockAppend);
2730 if (RT_FAILURE(rc))
2731 break;
2732
2733 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2734 offBlockAppend, pvBuf,
2735 pImage->cbTotalBlockData);
2736 if (RT_FAILURE(rc))
2737 break;
2738
2739 /* Zero out the old block area. */
2740 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2741 offStartDataNew, pvZero,
2742 pImage->cbTotalBlockData);
2743 if (RT_FAILURE(rc))
2744 break;
2745
2746 /* Update block counter. */
2747 pImage->paBlocks[idxBlock] = cBlocksAllocated - 1;
2748
2749 /*
2750 * Decrease the block number of all other entries in the array.
2751 * They were moved one block to the front.
2752 * Doing it as a separate step iterating over the array again
2753 * because an error while relocating the block might end up
2754 * in a corrupted image otherwise.
2755 */
2756 for (unsigned idxBlock2 = 0; idxBlock2 < cBlocksOld; idxBlock2++)
2757 {
2758 if ( idxBlock2 != idxBlock
2759 && IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[idxBlock2]))
2760 pImage->paBlocks[idxBlock2]--;
2761 }
2762
2763 /* Continue with the next block. */
2764 break;
2765 }
2766 }
2767
2768 if (RT_FAILURE(rc))
2769 break;
2770
2771 offStartDataNew += pImage->cbTotalBlockData;
2772 }
2773 } while (0);
2774
2775 if (pvBuf)
2776 RTMemFree(pvBuf);
2777 if (pvZero)
2778 RTMemFree(pvZero);
2779 }
2780
2781 /*
2782 * We need to update the new offsets for the image data in the out of memory
2783 * case too because we relocated the blocks already.
2784 */
2785 pImage->offStartData = offStartDataNew;
2786 setImageDataOffset(&pImage->Header, offStartDataNew);
2787
2788 /*
2789 * Relocation done, expand the block array and update the header with
2790 * the new data.
2791 */
2792 if (RT_SUCCESS(rc))
2793 {
2794 PVDIIMAGEBLOCKPOINTER paBlocksNew = (PVDIIMAGEBLOCKPOINTER)RTMemRealloc(pImage->paBlocks, cbBlockspaceNew);
2795 if (paBlocksNew)
2796 {
2797 pImage->paBlocks = paBlocksNew;
2798
2799 /* Mark the new blocks as unallocated. */
2800 for (unsigned idxBlock = cBlocksOld; idxBlock < cBlocksNew; idxBlock++)
2801 pImage->paBlocks[idxBlock] = VDI_IMAGE_BLOCK_FREE;
2802 }
2803 else
2804 rc = VERR_NO_MEMORY;
2805
2806 /* Write the block array before updating the rest. */
2807 vdiConvBlocksEndianess(VDIECONV_H2F, pImage->paBlocks, cBlocksNew);
2808 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->offStartBlocks,
2809 pImage->paBlocks, cbBlockspaceNew);
2810 vdiConvBlocksEndianess(VDIECONV_F2H, pImage->paBlocks, cBlocksNew);
2811
2812 if (RT_SUCCESS(rc))
2813 {
2814 /* Update size and new block count. */
2815 setImageDiskSize(&pImage->Header, cbSize);
2816 setImageBlocks(&pImage->Header, cBlocksNew);
2817 /* Update geometry. */
2818 pImage->PCHSGeometry = *pPCHSGeometry;
2819 pImage->cbImage = cbSize;
2820
2821 PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
2822 if (pGeometry)
2823 {
2824 pGeometry->cCylinders = pLCHSGeometry->cCylinders;
2825 pGeometry->cHeads = pLCHSGeometry->cHeads;
2826 pGeometry->cSectors = pLCHSGeometry->cSectors;
2827 pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
2828 }
2829 }
2830 }
2831
2832 /* Update header information in base image file. */
2833 vdiFlushImage(pImage);
2834 }
2835 /* Same size doesn't change the image at all. */
2836
2837 LogFlowFunc(("returns %Rrc\n", rc));
2838 return rc;
2839}
2840
2841/** @copydoc VBOXHDDBACKEND::pfnDiscard */
2842static DECLCALLBACK(int) vdiDiscard(void *pBackendData, PVDIOCTX pIoCtx,
2843 uint64_t uOffset, size_t cbDiscard,
2844 size_t *pcbPreAllocated,
2845 size_t *pcbPostAllocated,
2846 size_t *pcbActuallyDiscarded,
2847 void **ppbmAllocationBitmap,
2848 unsigned fDiscard)
2849{
2850 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2851 unsigned uBlock;
2852 unsigned offDiscard;
2853 int rc = VINF_SUCCESS;
2854 void *pvBlock = NULL;
2855
2856 LogFlowFunc(("pBackendData=%#p pIoCtx=%#p uOffset=%llu cbDiscard=%zu pcbPreAllocated=%#p pcbPostAllocated=%#p pcbActuallyDiscarded=%#p ppbmAllocationBitmap=%#p fDiscard=%#x\n",
2857 pBackendData, pIoCtx, uOffset, cbDiscard, pcbPreAllocated, pcbPostAllocated, pcbActuallyDiscarded, ppbmAllocationBitmap, fDiscard));
2858
2859 AssertPtr(pImage);
2860 Assert(!(uOffset % 512));
2861 Assert(!(cbDiscard % 512));
2862
2863 AssertMsgReturn(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2864 ("Image is readonly\n"), VERR_VD_IMAGE_READ_ONLY);
2865 AssertMsgReturn( uOffset + cbDiscard <= getImageDiskSize(&pImage->Header)
2866 && cbDiscard,
2867 ("Invalid parameters uOffset=%llu cbDiscard=%zu\n",
2868 uOffset, cbDiscard),
2869 VERR_INVALID_PARAMETER);
2870
2871 do
2872 {
2873 AssertMsgBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2874 ("Image is opened readonly\n"),
2875 rc = VERR_VD_IMAGE_READ_ONLY);
2876
2877 AssertMsgBreakStmt(cbDiscard,
2878 ("cbDiscard=%u\n", cbDiscard),
2879 rc = VERR_INVALID_PARAMETER);
2880
2881 /* Calculate starting block number and offset inside it. */
2882 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
2883 offDiscard = (unsigned)uOffset & pImage->uBlockMask;
2884
2885 /* Clip range to at most the rest of the block. */
2886 cbDiscard = RT_MIN(cbDiscard, getImageBlockSize(&pImage->Header) - offDiscard);
2887 Assert(!(cbDiscard % 512));
2888
2889 if (pcbPreAllocated)
2890 *pcbPreAllocated = 0;
2891
2892 if (pcbPostAllocated)
2893 *pcbPostAllocated = 0;
2894
2895 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
2896 {
2897 uint8_t *pbBlockData;
2898 size_t cbPreAllocated, cbPostAllocated;
2899
2900 cbPreAllocated = offDiscard % getImageBlockSize(&pImage->Header);
2901 cbPostAllocated = getImageBlockSize(&pImage->Header) - cbDiscard - cbPreAllocated;
2902
2903 /* Read the block data. */
2904 pvBlock = RTMemAlloc(pImage->cbTotalBlockData);
2905 if (!pvBlock)
2906 {
2907 rc = VERR_NO_MEMORY;
2908 break;
2909 }
2910
2911 if (!cbPreAllocated && !cbPostAllocated)
2912 {
2913 /*
2914 * Discarding a whole block, don't check for allocated sectors.
2915 * It is possible to just remove the whole block which avoids
2916 * one read and checking the whole block for data.
2917 */
2918 rc = vdiDiscardBlockAsync(pImage, pIoCtx, uBlock, pvBlock);
2919 }
2920 else if (fDiscard & VD_DISCARD_MARK_UNUSED)
2921 {
2922 /* Just zero out the given range. */
2923 memset(pvBlock, 0, cbDiscard);
2924
2925 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData + pImage->offStartData + offDiscard;
2926 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
2927 u64Offset, pvBlock, cbDiscard, pIoCtx,
2928 NULL, NULL);
2929 RTMemFree(pvBlock);
2930 }
2931 else
2932 {
2933 /*
2934 * Read complete block as metadata, the I/O context has no memory buffer
2935 * and we need to access the content directly anyway.
2936 */
2937 PVDMETAXFER pMetaXfer;
2938 pbBlockData = (uint8_t *)pvBlock + pImage->offStartBlockData;
2939
2940 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData + pImage->offStartData;
2941 rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage, u64Offset,
2942 pbBlockData, pImage->cbTotalBlockData,
2943 pIoCtx, &pMetaXfer, NULL, NULL);
2944 if (RT_FAILURE(rc))
2945 {
2946 RTMemFree(pvBlock);
2947 break;
2948 }
2949
2950 vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
2951
2952 /* Clear data. */
2953 memset(pbBlockData + offDiscard , 0, cbDiscard);
2954
2955 Assert(!(cbDiscard % 4));
2956 Assert(getImageBlockSize(&pImage->Header) * 8 <= UINT32_MAX);
2957 if (ASMBitFirstSet((volatile void *)pbBlockData, getImageBlockSize(&pImage->Header) * 8) == -1)
2958 rc = vdiDiscardBlockAsync(pImage, pIoCtx, uBlock, pvBlock);
2959 else
2960 {
2961 /* Block has data, create allocation bitmap. */
2962 *pcbPreAllocated = cbPreAllocated;
2963 *pcbPostAllocated = cbPostAllocated;
2964 *ppbmAllocationBitmap = vdiAllocationBitmapCreate(pbBlockData, getImageBlockSize(&pImage->Header));
2965 if (RT_UNLIKELY(!*ppbmAllocationBitmap))
2966 rc = VERR_NO_MEMORY;
2967 else
2968 rc = VERR_VD_DISCARD_ALIGNMENT_NOT_MET;
2969
2970 RTMemFree(pvBlock);
2971 }
2972 } /* if: no complete block discarded */
2973 } /* if: Block is allocated. */
2974 /* else: nothing to do. */
2975 } while (0);
2976
2977 if (pcbActuallyDiscarded)
2978 *pcbActuallyDiscarded = cbDiscard;
2979
2980 LogFlowFunc(("returns %Rrc\n", rc));
2981 return rc;
2982}
2983
2984/** @copydoc VBOXHDDBACKEND::pfnRepair */
2985static DECLCALLBACK(int) vdiRepair(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
2986 PVDINTERFACE pVDIfsImage, uint32_t fFlags)
2987{
2988 LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
2989 int rc;
2990 PVDINTERFACEERROR pIfError;
2991 PVDINTERFACEIOINT pIfIo;
2992 PVDIOSTORAGE pStorage;
2993 uint64_t cbFile;
2994 PVDIIMAGEBLOCKPOINTER paBlocks = NULL;
2995 uint32_t *pu32BlockBitmap = NULL;
2996 VDIPREHEADER PreHdr;
2997 VDIHEADER Hdr;
2998
2999 pIfIo = VDIfIoIntGet(pVDIfsImage);
3000 AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
3001
3002 pIfError = VDIfErrorGet(pVDIfsDisk);
3003
3004 do
3005 {
3006 bool fRepairHdr = false;
3007 bool fRepairBlockArray = false;
3008
3009 rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
3010 VDOpenFlagsToFileOpenFlags( fFlags & VD_REPAIR_DRY_RUN
3011 ? VD_OPEN_FLAGS_READONLY
3012 : 0,
3013 false /* fCreate */),
3014 &pStorage);
3015 if (RT_FAILURE(rc))
3016 {
3017 rc = vdIfError(pIfError, rc, RT_SRC_POS, "VDI: Failed to open image \"%s\"", pszFilename);
3018 break;
3019 }
3020
3021 rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
3022 if (RT_FAILURE(rc))
3023 {
3024 rc = vdIfError(pIfError, rc, RT_SRC_POS, "VDI: Failed to query image size");
3025 break;
3026 }
3027
3028 /* Read pre-header. */
3029 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &PreHdr, sizeof(PreHdr));
3030 if (RT_FAILURE(rc))
3031 {
3032 rc = vdIfError(pIfError, rc, RT_SRC_POS, N_("VDI: Error reading pre-header in '%s'"), pszFilename);
3033 break;
3034 }
3035 vdiConvPreHeaderEndianess(VDIECONV_F2H, &PreHdr, &PreHdr);
3036 rc = vdiValidatePreHeader(&PreHdr);
3037 if (RT_FAILURE(rc))
3038 {
3039 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3040 N_("VDI: invalid pre-header in '%s'"), pszFilename);
3041 break;
3042 }
3043
3044 /* Read header. */
3045 Hdr.uVersion = PreHdr.u32Version;
3046 switch (GET_MAJOR_HEADER_VERSION(&Hdr))
3047 {
3048 case 0:
3049 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, sizeof(PreHdr),
3050 &Hdr.u.v0, sizeof(Hdr.u.v0));
3051 if (RT_FAILURE(rc))
3052 rc = vdIfError(pIfError, rc, RT_SRC_POS, N_("VDI: error reading v0 header in '%s'"),
3053 pszFilename);
3054 vdiConvHeaderEndianessV0(VDIECONV_F2H, &Hdr.u.v0, &Hdr.u.v0);
3055 break;
3056 case 1:
3057 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, sizeof(PreHdr),
3058 &Hdr.u.v1, sizeof(Hdr.u.v1));
3059 if (RT_FAILURE(rc))
3060 {
3061 rc = vdIfError(pIfError, rc, RT_SRC_POS, N_("VDI: error reading v1 header in '%s'"),
3062 pszFilename);
3063 }
3064 vdiConvHeaderEndianessV1(VDIECONV_F2H, &Hdr.u.v1, &Hdr.u.v1);
3065 if (Hdr.u.v1.cbHeader >= sizeof(Hdr.u.v1plus))
3066 {
3067 /* Read the VDI 1.1+ header completely. */
3068 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, sizeof(PreHdr),
3069 &Hdr.u.v1plus, sizeof(Hdr.u.v1plus));
3070 if (RT_FAILURE(rc))
3071 rc = vdIfError(pIfError, rc, RT_SRC_POS, N_("VDI: error reading v1.1+ header in '%s'"),
3072 pszFilename);
3073 vdiConvHeaderEndianessV1p(VDIECONV_F2H, &Hdr.u.v1plus, &Hdr.u.v1plus);
3074 }
3075 break;
3076 default:
3077 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3078 N_("VDI: unsupported major version %u in '%s'"),
3079 GET_MAJOR_HEADER_VERSION(&Hdr), pszFilename);
3080 break;
3081 }
3082
3083 if (RT_SUCCESS(rc))
3084 {
3085 rc = vdiValidateHeader(&Hdr);
3086 if (RT_FAILURE(rc))
3087 {
3088 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3089 N_("VDI: invalid header in '%s'"), pszFilename);
3090 break;
3091 }
3092 }
3093
3094 /* Setup image parameters by header. */
3095 uint64_t offStartBlocks, offStartData;
3096 size_t cbTotalBlockData;
3097
3098 offStartBlocks = getImageBlocksOffset(&Hdr);
3099 offStartData = getImageDataOffset(&Hdr);
3100 cbTotalBlockData = getImageExtraBlockSize(&Hdr) + getImageBlockSize(&Hdr);
3101
3102 /* Allocate memory for blocks array. */
3103 paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&Hdr));
3104 if (!paBlocks)
3105 {
3106 rc = vdIfError(pIfError, VERR_NO_MEMORY, RT_SRC_POS,
3107 "Failed to allocate memory for block array");
3108 break;
3109 }
3110
3111 /* Read blocks array. */
3112 rc = vdIfIoIntFileReadSync(pIfIo, pStorage, offStartBlocks, paBlocks,
3113 getImageBlocks(&Hdr) * sizeof(VDIIMAGEBLOCKPOINTER));
3114 if (RT_FAILURE(rc))
3115 {
3116 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3117 "Failed to read block array (at %llu), %Rrc",
3118 offStartBlocks, rc);
3119 break;
3120 }
3121 vdiConvBlocksEndianess(VDIECONV_F2H, paBlocks, getImageBlocks(&Hdr));
3122
3123 pu32BlockBitmap = (uint32_t *)RTMemAllocZ(RT_ALIGN_Z(getImageBlocks(&Hdr) / 8, 4));
3124 if (!pu32BlockBitmap)
3125 {
3126 rc = vdIfError(pIfError, VERR_NO_MEMORY, RT_SRC_POS,
3127 "Failed to allocate memory for block bitmap");
3128 break;
3129 }
3130
3131 for (uint32_t i = 0; i < getImageBlocks(&Hdr); i++)
3132 {
3133 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(paBlocks[i]))
3134 {
3135 uint64_t offBlock = (uint64_t)paBlocks[i] * cbTotalBlockData
3136 + offStartData;
3137
3138 /*
3139 * Check that the offsets are valid (inside of the image) and
3140 * that there are no double references.
3141 */
3142 if (offBlock + cbTotalBlockData > cbFile)
3143 {
3144 vdIfErrorMessage(pIfError, "Entry %u points to invalid offset %llu, clearing\n",
3145 i, offBlock);
3146 paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
3147 fRepairBlockArray = true;
3148 }
3149 else if (ASMBitTestAndSet(pu32BlockBitmap, paBlocks[i]))
3150 {
3151 vdIfErrorMessage(pIfError, "Entry %u points to an already referenced data block, clearing\n",
3152 i);
3153 paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
3154 fRepairBlockArray = true;
3155 }
3156 }
3157 }
3158
3159 /* Write repaired structures now. */
3160 if (!fRepairBlockArray)
3161 vdIfErrorMessage(pIfError, "VDI image is in a consistent state, no repair required\n");
3162 else if (!(fFlags & VD_REPAIR_DRY_RUN))
3163 {
3164 vdIfErrorMessage(pIfError, "Writing repaired block allocation table...\n");
3165
3166 vdiConvBlocksEndianess(VDIECONV_H2F, paBlocks, getImageBlocks(&Hdr));
3167 rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offStartBlocks, paBlocks,
3168 getImageBlocks(&Hdr) * sizeof(VDIIMAGEBLOCKPOINTER));
3169 if (RT_FAILURE(rc))
3170 {
3171 rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3172 "Could not write repaired block allocation table (at %llu), %Rrc",
3173 offStartBlocks, rc);
3174 break;
3175 }
3176 }
3177
3178 vdIfErrorMessage(pIfError, "Corrupted VDI image repaired successfully\n");
3179 } while(0);
3180
3181 if (paBlocks)
3182 RTMemFree(paBlocks);
3183
3184 if (pu32BlockBitmap)
3185 RTMemFree(pu32BlockBitmap);
3186
3187 if (pStorage)
3188 {
3189 int rc2 = vdIfIoIntFileClose(pIfIo, pStorage);
3190 if (RT_SUCCESS(rc))
3191 rc = rc2; /* Propagate error code only if repairing was successful. */
3192 }
3193
3194 LogFlowFunc(("returns %Rrc\n", rc));
3195 return rc;
3196}
3197
3198const VBOXHDDBACKEND g_VDIBackend =
3199{
3200 /* pszBackendName */
3201 "VDI",
3202 /* cbSize */
3203 sizeof(VBOXHDDBACKEND),
3204 /* uBackendCaps */
3205 VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
3206 | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS | VD_CAP_DISCARD,
3207 /* paFileExtensions */
3208 s_aVdiFileExtensions,
3209 /* paConfigInfo */
3210 NULL,
3211 /* pfnCheckIfValid */
3212 vdiCheckIfValid,
3213 /* pfnOpen */
3214 vdiOpen,
3215 /* pfnCreate */
3216 vdiCreate,
3217 /* pfnRename */
3218 vdiRename,
3219 /* pfnClose */
3220 vdiClose,
3221 /* pfnRead */
3222 vdiRead,
3223 /* pfnWrite */
3224 vdiWrite,
3225 /* pfnFlush */
3226 vdiFlush,
3227 /* pfnDiscard */
3228 vdiDiscard,
3229 /* pfnGetVersion */
3230 vdiGetVersion,
3231 /* pfnGetSectorSize */
3232 vdiGetSectorSize,
3233 /* pfnGetSize */
3234 vdiGetSize,
3235 /* pfnGetFileSize */
3236 vdiGetFileSize,
3237 /* pfnGetPCHSGeometry */
3238 vdiGetPCHSGeometry,
3239 /* pfnSetPCHSGeometry */
3240 vdiSetPCHSGeometry,
3241 /* pfnGetLCHSGeometry */
3242 vdiGetLCHSGeometry,
3243 /* pfnSetLCHSGeometry */
3244 vdiSetLCHSGeometry,
3245 /* pfnGetImageFlags */
3246 vdiGetImageFlags,
3247 /* pfnGetOpenFlags */
3248 vdiGetOpenFlags,
3249 /* pfnSetOpenFlags */
3250 vdiSetOpenFlags,
3251 /* pfnGetComment */
3252 vdiGetComment,
3253 /* pfnSetComment */
3254 vdiSetComment,
3255 /* pfnGetUuid */
3256 vdiGetUuid,
3257 /* pfnSetUuid */
3258 vdiSetUuid,
3259 /* pfnGetModificationUuid */
3260 vdiGetModificationUuid,
3261 /* pfnSetModificationUuid */
3262 vdiSetModificationUuid,
3263 /* pfnGetParentUuid */
3264 vdiGetParentUuid,
3265 /* pfnSetParentUuid */
3266 vdiSetParentUuid,
3267 /* pfnGetParentModificationUuid */
3268 vdiGetParentModificationUuid,
3269 /* pfnSetParentModificationUuid */
3270 vdiSetParentModificationUuid,
3271 /* pfnDump */
3272 vdiDump,
3273 /* pfnGetTimeStamp */
3274 NULL,
3275 /* pfnGetParentTimeStamp */
3276 NULL,
3277 /* pfnSetParentTimeStamp */
3278 NULL,
3279 /* pfnGetParentFilename */
3280 NULL,
3281 /* pfnSetParentFilename */
3282 NULL,
3283 /* pfnComposeLocation */
3284 genericFileComposeLocation,
3285 /* pfnComposeName */
3286 genericFileComposeName,
3287 /* pfnCompact */
3288 vdiCompact,
3289 /* pfnResize */
3290 vdiResize,
3291 /* pfnRepair */
3292 vdiRepair,
3293 /* pfnTraverseMetadata */
3294 NULL
3295};
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