VirtualBox

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

Last change on this file since 38462 was 38202, checked in by vboxsync, 13 years ago

VDI: Logging fix
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 95.6 KB
Line 
1/** @file
2 * Virtual Disk Image (VDI), Core Code.
3 */
4
5/*
6 * Copyright (C) 2006-2011 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16
17/*******************************************************************************
18* Header Files *
19*******************************************************************************/
20#define LOG_GROUP LOG_GROUP_VD_VDI
21#include <VBox/vd-plugin.h>
22#define VBOX_VDICORE_VD /* Signal that the header is included from here. */
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#define VDI_IMAGE_DEFAULT_BLOCK_SIZE _1M
34
35/*******************************************************************************
36* Static Variables *
37*******************************************************************************/
38
39/** NULL-terminated array of supported file extensions. */
40static const VDFILEEXTENSION s_aVdiFileExtensions[] =
41{
42 {"vdi", VDTYPE_HDD},
43 {NULL, VDTYPE_INVALID}
44};
45
46/*******************************************************************************
47* Internal Functions *
48*******************************************************************************/
49static unsigned getPowerOfTwo(unsigned uNumber);
50static void vdiInitPreHeader(PVDIPREHEADER pPreHdr);
51static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr);
52static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
53 const char *pszComment, uint64_t cbDisk,
54 uint32_t cbBlock, uint32_t cbBlockExtra);
55static int vdiValidateHeader(PVDIHEADER pHeader);
56static void vdiSetupImageDesc(PVDIIMAGEDESC pImage);
57static int vdiUpdateHeader(PVDIIMAGEDESC pImage);
58static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock);
59static int vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx);
60static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock, PVDIOCTX pIoCtx);
61
62/**
63 * Internal: signal an error to the frontend.
64 */
65DECLINLINE(int) vdiError(PVDIIMAGEDESC pImage, int rc, RT_SRC_POS_DECL,
66 const char *pszFormat, ...)
67{
68 va_list va;
69 va_start(va, pszFormat);
70 if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
71 pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser,
72 rc, RT_SRC_POS_ARGS,
73 pszFormat, va);
74 va_end(va);
75 return rc;
76}
77
78/**
79 * Internal: signal an informational message to the frontend.
80 */
81DECLINLINE(int) vdiMessage(PVDIIMAGEDESC pImage, const char *pszFormat, ...)
82{
83 int rc = VINF_SUCCESS;
84 va_list va;
85 va_start(va, pszFormat);
86 if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
87 rc = pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser,
88 pszFormat, va);
89 va_end(va);
90 return rc;
91}
92
93
94DECLINLINE(int) vdiFileOpen(PVDIIMAGEDESC pImage, const char *pszFilename,
95 uint32_t fOpen)
96{
97 return pImage->pInterfaceIOCallbacks->pfnOpen(pImage->pInterfaceIO->pvUser,
98 pszFilename, fOpen,
99 &pImage->pStorage);
100}
101
102DECLINLINE(int) vdiFileClose(PVDIIMAGEDESC pImage)
103{
104 return pImage->pInterfaceIOCallbacks->pfnClose(pImage->pInterfaceIO->pvUser,
105 pImage->pStorage);
106}
107
108DECLINLINE(int) vdiFileDelete(PVDIIMAGEDESC pImage, const char *pszFilename)
109{
110 return pImage->pInterfaceIOCallbacks->pfnDelete(pImage->pInterfaceIO->pvUser,
111 pszFilename);
112}
113
114DECLINLINE(int) vdiFileMove(PVDIIMAGEDESC pImage, const char *pszSrc,
115 const char *pszDst, unsigned fMove)
116{
117 return pImage->pInterfaceIOCallbacks->pfnMove(pImage->pInterfaceIO->pvUser,
118 pszSrc, pszDst, fMove);
119}
120
121DECLINLINE(int) vdiFileGetFreeSpace(PVDIIMAGEDESC pImage, const char *pszFilename,
122 int64_t *pcbFree)
123{
124 return pImage->pInterfaceIOCallbacks->pfnGetFreeSpace(pImage->pInterfaceIO->pvUser,
125 pszFilename, pcbFree);
126}
127
128DECLINLINE(int) vdiFileGetSize(PVDIIMAGEDESC pImage, uint64_t *pcbSize)
129{
130 return pImage->pInterfaceIOCallbacks->pfnGetSize(pImage->pInterfaceIO->pvUser,
131 pImage->pStorage, pcbSize);
132}
133
134DECLINLINE(int) vdiFileSetSize(PVDIIMAGEDESC pImage, uint64_t cbSize)
135{
136 return pImage->pInterfaceIOCallbacks->pfnSetSize(pImage->pInterfaceIO->pvUser,
137 pImage->pStorage, cbSize);
138}
139
140DECLINLINE(int) vdiFileWriteSync(PVDIIMAGEDESC pImage, uint64_t uOffset,
141 const void *pvBuffer, size_t cbBuffer,
142 size_t *pcbWritten)
143{
144 return pImage->pInterfaceIOCallbacks->pfnWriteSync(pImage->pInterfaceIO->pvUser,
145 pImage->pStorage, uOffset,
146 pvBuffer, cbBuffer, pcbWritten);
147}
148
149DECLINLINE(int) vdiFileReadSync(PVDIIMAGEDESC pImage, uint64_t uOffset,
150 void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
151{
152 return pImage->pInterfaceIOCallbacks->pfnReadSync(pImage->pInterfaceIO->pvUser,
153 pImage->pStorage, uOffset,
154 pvBuffer, cbBuffer, pcbRead);
155}
156
157DECLINLINE(int) vdiFileFlushSync(PVDIIMAGEDESC pImage)
158{
159 return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
160 pImage->pStorage);
161}
162
163DECLINLINE(int) vdiFileReadUserAsync(PVDIIMAGEDESC pImage, uint64_t uOffset,
164 PVDIOCTX pIoCtx, size_t cbRead)
165{
166 return pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
167 pImage->pStorage,
168 uOffset, pIoCtx,
169 cbRead);
170}
171
172DECLINLINE(int) vdiFileWriteUserAsync(PVDIIMAGEDESC pImage, uint64_t uOffset,
173 PVDIOCTX pIoCtx, size_t cbWrite,
174 PFNVDXFERCOMPLETED pfnComplete,
175 void *pvCompleteUser)
176{
177 return pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
178 pImage->pStorage,
179 uOffset, pIoCtx,
180 cbWrite,
181 pfnComplete,
182 pvCompleteUser);
183}
184
185DECLINLINE(int) vdiFileWriteMetaAsync(PVDIIMAGEDESC pImage, uint64_t uOffset,
186 void *pvBuffer, size_t cbBuffer,
187 PVDIOCTX pIoCtx,
188 PFNVDXFERCOMPLETED pfnComplete,
189 void *pvCompleteUser)
190{
191 return pImage->pInterfaceIOCallbacks->pfnWriteMetaAsync(pImage->pInterfaceIO->pvUser,
192 pImage->pStorage,
193 uOffset, pvBuffer,
194 cbBuffer, pIoCtx,
195 pfnComplete,
196 pvCompleteUser);
197}
198
199DECLINLINE(int) vdiFileFlushAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx,
200 PFNVDXFERCOMPLETED pfnComplete,
201 void *pvCompleteUser)
202{
203 return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
204 pImage->pStorage,
205 pIoCtx, pfnComplete,
206 pvCompleteUser);
207}
208
209DECLINLINE(size_t) vdiFileIoCtxSet(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx,
210 int ch, size_t cbSet)
211{
212 return pImage->pInterfaceIOCallbacks->pfnIoCtxSet(pImage->pInterfaceIO->pvUser,
213 pIoCtx, ch, cbSet);
214}
215
216
217/**
218 * Internal: Flush the image file to disk.
219 */
220static void vdiFlushImage(PVDIIMAGEDESC pImage)
221{
222 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
223 {
224 /* Save header. */
225 int rc = vdiUpdateHeader(pImage);
226 AssertMsgRC(rc, ("vdiUpdateHeader() failed, filename=\"%s\", rc=%Rrc\n",
227 pImage->pszFilename, rc));
228 vdiFileFlushSync(pImage);
229 }
230}
231
232/**
233 * Internal: Free all allocated space for representing an image, and optionally
234 * delete the image from disk.
235 */
236static int vdiFreeImage(PVDIIMAGEDESC pImage, bool fDelete)
237{
238 int rc = VINF_SUCCESS;
239
240 /* Freeing a never allocated image (e.g. because the open failed) is
241 * not signalled as an error. After all nothing bad happens. */
242 if (pImage)
243 {
244 if (pImage->pStorage)
245 {
246 /* No point updating the file that is deleted anyway. */
247 if (!fDelete)
248 vdiFlushImage(pImage);
249
250 vdiFileClose(pImage);
251 pImage->pStorage = NULL;
252 }
253
254 if (pImage->paBlocks)
255 {
256 RTMemFree(pImage->paBlocks);
257 pImage->paBlocks = NULL;
258 }
259
260 if (fDelete && pImage->pszFilename)
261 vdiFileDelete(pImage, pImage->pszFilename);
262 }
263
264 LogFlowFunc(("returns %Rrc\n", rc));
265 return rc;
266}
267
268/**
269 * internal: return power of 2 or 0 if num error.
270 */
271static unsigned getPowerOfTwo(unsigned uNumber)
272{
273 if (uNumber == 0)
274 return 0;
275 unsigned uPower2 = 0;
276 while ((uNumber & 1) == 0)
277 {
278 uNumber >>= 1;
279 uPower2++;
280 }
281 return uNumber == 1 ? uPower2 : 0;
282}
283
284/**
285 * Internal: Init VDI preheader.
286 */
287static void vdiInitPreHeader(PVDIPREHEADER pPreHdr)
288{
289 pPreHdr->u32Signature = VDI_IMAGE_SIGNATURE;
290 pPreHdr->u32Version = VDI_IMAGE_VERSION;
291 memset(pPreHdr->szFileInfo, 0, sizeof(pPreHdr->szFileInfo));
292 strncat(pPreHdr->szFileInfo, VDI_IMAGE_FILE_INFO, sizeof(pPreHdr->szFileInfo)-1);
293}
294
295/**
296 * Internal: check VDI preheader.
297 */
298static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr)
299{
300 if (pPreHdr->u32Signature != VDI_IMAGE_SIGNATURE)
301 return VERR_VD_VDI_INVALID_HEADER;
302
303 if ( VDI_GET_VERSION_MAJOR(pPreHdr->u32Version) != VDI_IMAGE_VERSION_MAJOR
304 && pPreHdr->u32Version != 0x00000002) /* old version. */
305 return VERR_VD_VDI_UNSUPPORTED_VERSION;
306
307 return VINF_SUCCESS;
308}
309
310/**
311 * Internal: translate VD image flags to VDI image type enum.
312 */
313static VDIIMAGETYPE vdiTranslateImageFlags2VDI(unsigned uImageFlags)
314{
315 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
316 return VDI_IMAGE_TYPE_FIXED;
317 else if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
318 return VDI_IMAGE_TYPE_DIFF;
319 else
320 return VDI_IMAGE_TYPE_NORMAL;
321}
322
323/**
324 * Internal: translate VDI image type enum to VD image type enum.
325 */
326static unsigned vdiTranslateVDI2ImageFlags(VDIIMAGETYPE enmType)
327{
328 switch (enmType)
329 {
330 case VDI_IMAGE_TYPE_NORMAL:
331 return VD_IMAGE_FLAGS_NONE;
332 case VDI_IMAGE_TYPE_FIXED:
333 return VD_IMAGE_FLAGS_FIXED;
334 case VDI_IMAGE_TYPE_DIFF:
335 return VD_IMAGE_FLAGS_DIFF;
336 default:
337 AssertMsgFailed(("invalid VDIIMAGETYPE enmType=%d\n", (int)enmType));
338 return VD_IMAGE_FLAGS_NONE;
339 }
340}
341
342/**
343 * Internal: Init VDI header. Always use latest header version.
344 * @param pHeader Assumes it was initially initialized to all zeros.
345 */
346static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
347 const char *pszComment, uint64_t cbDisk,
348 uint32_t cbBlock, uint32_t cbBlockExtra)
349{
350 pHeader->uVersion = VDI_IMAGE_VERSION;
351 pHeader->u.v1plus.cbHeader = sizeof(VDIHEADER1PLUS);
352 pHeader->u.v1plus.u32Type = (uint32_t)vdiTranslateImageFlags2VDI(uImageFlags);
353 pHeader->u.v1plus.fFlags = (uImageFlags & VD_VDI_IMAGE_FLAGS_ZERO_EXPAND) ? 1 : 0;
354#ifdef VBOX_STRICT
355 char achZero[VDI_IMAGE_COMMENT_SIZE] = {0};
356 Assert(!memcmp(pHeader->u.v1plus.szComment, achZero, VDI_IMAGE_COMMENT_SIZE));
357#endif
358 pHeader->u.v1plus.szComment[0] = '\0';
359 if (pszComment)
360 {
361 AssertMsg(strlen(pszComment) < sizeof(pHeader->u.v1plus.szComment),
362 ("HDD Comment is too long, cb=%d\n", strlen(pszComment)));
363 strncat(pHeader->u.v1plus.szComment, pszComment, sizeof(pHeader->u.v1plus.szComment)-1);
364 }
365
366 /* Mark the legacy geometry not-calculated. */
367 pHeader->u.v1plus.LegacyGeometry.cCylinders = 0;
368 pHeader->u.v1plus.LegacyGeometry.cHeads = 0;
369 pHeader->u.v1plus.LegacyGeometry.cSectors = 0;
370 pHeader->u.v1plus.LegacyGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
371 pHeader->u.v1plus.u32Dummy = 0; /* used to be the translation value */
372
373 pHeader->u.v1plus.cbDisk = cbDisk;
374 pHeader->u.v1plus.cbBlock = cbBlock;
375 pHeader->u.v1plus.cBlocks = (uint32_t)(cbDisk / cbBlock);
376 if (cbDisk % cbBlock)
377 pHeader->u.v1plus.cBlocks++;
378 pHeader->u.v1plus.cbBlockExtra = cbBlockExtra;
379 pHeader->u.v1plus.cBlocksAllocated = 0;
380
381 /* Init offsets. */
382 pHeader->u.v1plus.offBlocks = RT_ALIGN_32(sizeof(VDIPREHEADER) + sizeof(VDIHEADER1PLUS), VDI_DATA_ALIGN);
383 pHeader->u.v1plus.offData = RT_ALIGN_32(pHeader->u.v1plus.offBlocks + (pHeader->u.v1plus.cBlocks * sizeof(VDIIMAGEBLOCKPOINTER)), VDI_DATA_ALIGN);
384
385 /* Init uuids. */
386 RTUuidCreate(&pHeader->u.v1plus.uuidCreate);
387 RTUuidClear(&pHeader->u.v1plus.uuidModify);
388 RTUuidClear(&pHeader->u.v1plus.uuidLinkage);
389 RTUuidClear(&pHeader->u.v1plus.uuidParentModify);
390
391 /* Mark LCHS geometry not-calculated. */
392 pHeader->u.v1plus.LCHSGeometry.cCylinders = 0;
393 pHeader->u.v1plus.LCHSGeometry.cHeads = 0;
394 pHeader->u.v1plus.LCHSGeometry.cSectors = 0;
395 pHeader->u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
396}
397
398/**
399 * Internal: Check VDI header.
400 */
401static int vdiValidateHeader(PVDIHEADER pHeader)
402{
403 /* Check version-dependent header parameters. */
404 switch (GET_MAJOR_HEADER_VERSION(pHeader))
405 {
406 case 0:
407 {
408 /* Old header version. */
409 break;
410 }
411 case 1:
412 {
413 /* Current header version. */
414
415 if (pHeader->u.v1.cbHeader < sizeof(VDIHEADER1))
416 {
417 LogRel(("VDI: v1 header size wrong (%d < %d)\n",
418 pHeader->u.v1.cbHeader, sizeof(VDIHEADER1)));
419 return VERR_VD_VDI_INVALID_HEADER;
420 }
421
422 if (getImageBlocksOffset(pHeader) < (sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)))
423 {
424 LogRel(("VDI: v1 blocks offset wrong (%d < %d)\n",
425 getImageBlocksOffset(pHeader), sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)));
426 return VERR_VD_VDI_INVALID_HEADER;
427 }
428
429 if (getImageDataOffset(pHeader) < (getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)))
430 {
431 LogRel(("VDI: v1 image data offset wrong (%d < %d)\n",
432 getImageDataOffset(pHeader), getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)));
433 return VERR_VD_VDI_INVALID_HEADER;
434 }
435
436 break;
437 }
438 default:
439 /* Unsupported. */
440 return VERR_VD_VDI_UNSUPPORTED_VERSION;
441 }
442
443 /* Check common header parameters. */
444
445 bool fFailed = false;
446
447 if ( getImageType(pHeader) < VDI_IMAGE_TYPE_FIRST
448 || getImageType(pHeader) > VDI_IMAGE_TYPE_LAST)
449 {
450 LogRel(("VDI: bad image type %d\n", getImageType(pHeader)));
451 fFailed = true;
452 }
453
454 if (getImageFlags(pHeader) & ~VD_VDI_IMAGE_FLAGS_MASK)
455 {
456 LogRel(("VDI: bad image flags %08x\n", getImageFlags(pHeader)));
457 fFailed = true;
458 }
459
460 if ( getImageLCHSGeometry(pHeader)
461 && (getImageLCHSGeometry(pHeader))->cbSector != VDI_GEOMETRY_SECTOR_SIZE)
462 {
463 LogRel(("VDI: wrong sector size (%d != %d)\n",
464 (getImageLCHSGeometry(pHeader))->cbSector, VDI_GEOMETRY_SECTOR_SIZE));
465 fFailed = true;
466 }
467
468 if ( getImageDiskSize(pHeader) == 0
469 || getImageBlockSize(pHeader) == 0
470 || getImageBlocks(pHeader) == 0
471 || getPowerOfTwo(getImageBlockSize(pHeader)) == 0)
472 {
473 LogRel(("VDI: wrong size (%lld, %d, %d, %d)\n",
474 getImageDiskSize(pHeader), getImageBlockSize(pHeader),
475 getImageBlocks(pHeader), getPowerOfTwo(getImageBlockSize(pHeader))));
476 fFailed = true;
477 }
478
479 if (getImageBlocksAllocated(pHeader) > getImageBlocks(pHeader))
480 {
481 LogRel(("VDI: too many blocks allocated (%d > %d)\n"
482 " blocksize=%d disksize=%lld\n",
483 getImageBlocksAllocated(pHeader), getImageBlocks(pHeader),
484 getImageBlockSize(pHeader), getImageDiskSize(pHeader)));
485 fFailed = true;
486 }
487
488 if ( getImageExtraBlockSize(pHeader) != 0
489 && getPowerOfTwo(getImageExtraBlockSize(pHeader)) == 0)
490 {
491 LogRel(("VDI: wrong extra size (%d, %d)\n",
492 getImageExtraBlockSize(pHeader), getPowerOfTwo(getImageExtraBlockSize(pHeader))));
493 fFailed = true;
494 }
495
496 if ((uint64_t)getImageBlockSize(pHeader) * getImageBlocks(pHeader) < getImageDiskSize(pHeader))
497 {
498 LogRel(("VDI: wrong disk size (%d, %d, %lld)\n",
499 getImageBlockSize(pHeader), getImageBlocks(pHeader), getImageDiskSize(pHeader)));
500 fFailed = true;
501 }
502
503 if (RTUuidIsNull(getImageCreationUUID(pHeader)))
504 {
505 LogRel(("VDI: uuid of creator is 0\n"));
506 fFailed = true;
507 }
508
509 if (RTUuidIsNull(getImageModificationUUID(pHeader)))
510 {
511 LogRel(("VDI: uuid of modifier is 0\n"));
512 fFailed = true;
513 }
514
515 return fFailed ? VERR_VD_VDI_INVALID_HEADER : VINF_SUCCESS;
516}
517
518/**
519 * Internal: Set up VDIIMAGEDESC structure by image header.
520 */
521static void vdiSetupImageDesc(PVDIIMAGEDESC pImage)
522{
523 pImage->uImageFlags = getImageFlags(&pImage->Header);
524 pImage->uImageFlags |= vdiTranslateVDI2ImageFlags(getImageType(&pImage->Header));
525 pImage->offStartBlocks = getImageBlocksOffset(&pImage->Header);
526 pImage->offStartData = getImageDataOffset(&pImage->Header);
527 pImage->uBlockMask = getImageBlockSize(&pImage->Header) - 1;
528 pImage->uShiftOffset2Index = getPowerOfTwo(getImageBlockSize(&pImage->Header));
529 pImage->offStartBlockData = getImageExtraBlockSize(&pImage->Header);
530 pImage->cbTotalBlockData = pImage->offStartBlockData
531 + getImageBlockSize(&pImage->Header);
532}
533
534/**
535 * Internal: Create VDI image file.
536 */
537static int vdiCreateImage(PVDIIMAGEDESC pImage, uint64_t cbSize,
538 unsigned uImageFlags, const char *pszComment,
539 PCVDGEOMETRY pPCHSGeometry,
540 PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
541 unsigned uOpenFlags, PFNVDPROGRESS pfnProgress,
542 void *pvUser, unsigned uPercentStart,
543 unsigned uPercentSpan)
544{
545 int rc;
546 uint64_t cbTotal;
547 uint64_t cbFill;
548 uint64_t uOff;
549
550 /* Special check for comment length. */
551 if ( VALID_PTR(pszComment)
552 && strlen(pszComment) >= VDI_IMAGE_COMMENT_SIZE)
553 {
554 rc = vdiError(pImage, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS, N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
555 goto out;
556 }
557 AssertPtr(pPCHSGeometry);
558 AssertPtr(pLCHSGeometry);
559
560 pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
561 if (pImage->pInterfaceError)
562 pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
563
564 /* Get I/O interface. */
565 pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
566 AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
567 pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
568 AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
569
570 vdiInitPreHeader(&pImage->PreHeader);
571 vdiInitHeader(&pImage->Header, uImageFlags, pszComment, cbSize, VDI_IMAGE_DEFAULT_BLOCK_SIZE, 0);
572 /* Save PCHS geometry. Not much work, and makes the flow of information
573 * quite a bit clearer - relying on the higher level isn't obvious. */
574 pImage->PCHSGeometry = *pPCHSGeometry;
575 /* Set LCHS geometry (legacy geometry is ignored for the current 1.1+). */
576 pImage->Header.u.v1plus.LCHSGeometry.cCylinders = pLCHSGeometry->cCylinders;
577 pImage->Header.u.v1plus.LCHSGeometry.cHeads = pLCHSGeometry->cHeads;
578 pImage->Header.u.v1plus.LCHSGeometry.cSectors = pLCHSGeometry->cSectors;
579 pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
580
581 pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
582 if (!pImage->paBlocks)
583 {
584 rc = VERR_NO_MEMORY;
585 goto out;
586 }
587
588 if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
589 {
590 /* for growing images mark all blocks in paBlocks as free. */
591 for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
592 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
593 }
594 else
595 {
596 /* for fixed images mark all blocks in paBlocks as allocated */
597 for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
598 pImage->paBlocks[i] = i;
599 pImage->Header.u.v1.cBlocksAllocated = pImage->Header.u.v1.cBlocks;
600 }
601
602 /* Setup image parameters. */
603 vdiSetupImageDesc(pImage);
604
605 /* Create image file. */
606 rc = vdiFileOpen(pImage, pImage->pszFilename,
607 VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
608 true /* fCreate */));
609 if (RT_FAILURE(rc))
610 {
611 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: cannot create image '%s'"), pImage->pszFilename);
612 goto out;
613 }
614
615 cbTotal = pImage->offStartData
616 + (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
617
618 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
619 {
620 /* Check the free space on the disk and leave early if there is not
621 * sufficient space available. */
622 int64_t cbFree = 0;
623 rc = vdiFileGetFreeSpace(pImage, pImage->pszFilename, &cbFree);
624 if (RT_SUCCESS(rc) /* ignore errors */ && ((uint64_t)cbFree < cbTotal))
625 {
626 rc = vdiError(pImage, VERR_DISK_FULL, RT_SRC_POS, N_("VDI: disk would overflow creating image '%s'"), pImage->pszFilename);
627 goto out;
628 }
629 }
630
631 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
632 {
633 /*
634 * Allocate & commit whole file if fixed image, it must be more
635 * effective than expanding file by write operations.
636 */
637 rc = vdiFileSetSize(pImage, cbTotal);
638 }
639 else
640 {
641 /* Set file size to hold header and blocks array. */
642 rc = vdiFileSetSize(pImage, pImage->offStartData);
643 }
644 if (RT_FAILURE(rc))
645 {
646 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: setting image size failed for '%s'"), pImage->pszFilename);
647 goto out;
648 }
649
650 /* Use specified image uuid */
651 *getImageCreationUUID(&pImage->Header) = *pUuid;
652
653 /* Generate image last-modify uuid */
654 RTUuidCreate(getImageModificationUUID(&pImage->Header));
655
656 /* Write pre-header. */
657 rc = vdiFileWriteSync(pImage, 0, &pImage->PreHeader, sizeof(pImage->PreHeader), NULL);
658 if (RT_FAILURE(rc))
659 {
660 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing pre-header failed for '%s'"), pImage->pszFilename);
661 goto out;
662 }
663
664 /* Write header. */
665 rc = vdiFileWriteSync(pImage, sizeof(pImage->PreHeader),
666 &pImage->Header.u.v1plus,
667 sizeof(pImage->Header.u.v1plus), NULL);
668 if (RT_FAILURE(rc))
669 {
670 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing header failed for '%s'"), pImage->pszFilename);
671 goto out;
672 }
673
674 rc = vdiFileWriteSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
675 getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
676 NULL);
677 if (RT_FAILURE(rc))
678 {
679 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block pointers failed for '%s'"), pImage->pszFilename);
680 goto out;
681 }
682
683 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
684 {
685 /* Fill image with zeroes. We do this for every fixed-size image since on some systems
686 * (for example Windows Vista), it takes ages to write a block near the end of a sparse
687 * file and the guest could complain about an ATA timeout. */
688
689 /** @todo Starting with Linux 2.6.23, there is an fallocate() system call.
690 * Currently supported file systems are ext4 and ocfs2. */
691
692 /* Allocate a temporary zero-filled buffer. Use a bigger block size to optimize writing */
693 const size_t cbBuf = 128 * _1K;
694 void *pvBuf = RTMemTmpAllocZ(cbBuf);
695 if (!pvBuf)
696 {
697 rc = VERR_NO_MEMORY;
698 goto out;
699 }
700
701 cbFill = (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
702 uOff = 0;
703 /* Write data to all image blocks. */
704 while (uOff < cbFill)
705 {
706 unsigned cbChunk = (unsigned)RT_MIN(cbFill, cbBuf);
707
708 rc = vdiFileWriteSync(pImage, pImage->offStartData + uOff,
709 pvBuf, cbChunk, NULL);
710 if (RT_FAILURE(rc))
711 {
712 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block failed for '%s'"), pImage->pszFilename);
713 RTMemTmpFree(pvBuf);
714 goto out;
715 }
716
717 uOff += cbChunk;
718
719 if (pfnProgress)
720 {
721 rc = pfnProgress(pvUser,
722 uPercentStart + uOff * uPercentSpan / cbFill);
723 if (RT_FAILURE(rc))
724 goto out;
725 }
726 }
727 RTMemTmpFree(pvBuf);
728 }
729
730out:
731 if (RT_SUCCESS(rc) && pfnProgress)
732 pfnProgress(pvUser, uPercentStart + uPercentSpan);
733
734 if (RT_FAILURE(rc))
735 vdiFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
736 return rc;
737}
738
739/**
740 * Internal: Open a VDI image.
741 */
742static int vdiOpenImage(PVDIIMAGEDESC pImage, unsigned uOpenFlags)
743{
744 int rc;
745
746 pImage->uOpenFlags = uOpenFlags;
747
748 pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
749 if (pImage->pInterfaceError)
750 pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
751
752 /* Get I/O interface. */
753 pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
754 AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
755 pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
756 AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
757
758 /*
759 * Open the image.
760 */
761 rc = vdiFileOpen(pImage, pImage->pszFilename,
762 VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
763 if (RT_FAILURE(rc))
764 {
765 /* Do NOT signal an appropriate error here, as the VD layer has the
766 * choice of retrying the open if it failed. */
767 goto out;
768 }
769
770 /* Read pre-header. */
771 rc = vdiFileReadSync(pImage, 0, &pImage->PreHeader, sizeof(pImage->PreHeader), NULL);
772 if (RT_FAILURE(rc))
773 {
774 vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading pre-header in '%s'"), pImage->pszFilename);
775 rc = VERR_VD_VDI_INVALID_HEADER;
776 goto out;
777 }
778 rc = vdiValidatePreHeader(&pImage->PreHeader);
779 if (RT_FAILURE(rc))
780 {
781 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: invalid pre-header in '%s'"), pImage->pszFilename);
782 goto out;
783 }
784
785 /* Read header. */
786 pImage->Header.uVersion = pImage->PreHeader.u32Version;
787 switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
788 {
789 case 0:
790 rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader),
791 &pImage->Header.u.v0, sizeof(pImage->Header.u.v0),
792 NULL);
793 if (RT_FAILURE(rc))
794 {
795 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v0 header in '%s'"), pImage->pszFilename);
796 goto out;
797 }
798 break;
799 case 1:
800 rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader),
801 &pImage->Header.u.v1, sizeof(pImage->Header.u.v1),
802 NULL);
803 if (RT_FAILURE(rc))
804 {
805 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1 header in '%s'"), pImage->pszFilename);
806 goto out;
807 }
808 /* Convert VDI 1.1 images to VDI 1.1+ on open in read/write mode.
809 * Conversion is harmless, as any VirtualBox version supporting VDI
810 * 1.1 doesn't touch fields it doesn't know about. */
811 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
812 && GET_MINOR_HEADER_VERSION(&pImage->Header) == 1
813 && pImage->Header.u.v1.cbHeader < sizeof(pImage->Header.u.v1plus))
814 {
815 pImage->Header.u.v1plus.cbHeader = sizeof(pImage->Header.u.v1plus);
816 /* Mark LCHS geometry not-calculated. */
817 pImage->Header.u.v1plus.LCHSGeometry.cCylinders = 0;
818 pImage->Header.u.v1plus.LCHSGeometry.cHeads = 0;
819 pImage->Header.u.v1plus.LCHSGeometry.cSectors = 0;
820 pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
821 }
822 else if (pImage->Header.u.v1.cbHeader >= sizeof(pImage->Header.u.v1plus))
823 {
824 /* Read the actual VDI 1.1+ header completely. */
825 rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader),
826 &pImage->Header.u.v1plus,
827 sizeof(pImage->Header.u.v1plus), NULL);
828 if (RT_FAILURE(rc))
829 {
830 rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1.1+ header in '%s'"), pImage->pszFilename);
831 goto out;
832 }
833 }
834 break;
835 default:
836 rc = vdiError(pImage, VERR_VD_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VDI: unsupported major version %u in '%s'"), GET_MAJOR_HEADER_VERSION(&pImage->Header), pImage->pszFilename);
837 goto out;
838 }
839
840 rc = vdiValidateHeader(&pImage->Header);
841 if (RT_FAILURE(rc))
842 {
843 rc = vdiError(pImage, VERR_VD_VDI_INVALID_HEADER, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
844 goto out;
845 }
846
847 /* Setup image parameters by header. */
848 vdiSetupImageDesc(pImage);
849
850 /* Allocate memory for blocks array. */
851 pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
852 if (!pImage->paBlocks)
853 {
854 rc = VERR_NO_MEMORY;
855 goto out;
856 }
857
858 /* Read blocks array. */
859 rc = vdiFileReadSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
860 getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
861 NULL);
862
863out:
864 if (RT_FAILURE(rc))
865 vdiFreeImage(pImage, false);
866 return rc;
867}
868
869/**
870 * Internal: Save header to file.
871 */
872static int vdiUpdateHeader(PVDIIMAGEDESC pImage)
873{
874 int rc;
875 switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
876 {
877 case 0:
878 rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER),
879 &pImage->Header.u.v0, sizeof(pImage->Header.u.v0),
880 NULL);
881 break;
882 case 1:
883 if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
884 rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER),
885 &pImage->Header.u.v1, sizeof(pImage->Header.u.v1),
886 NULL);
887 else
888 rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER),
889 &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus),
890 NULL);
891 break;
892 default:
893 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
894 break;
895 }
896 AssertMsgRC(rc, ("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
897 return rc;
898}
899
900/**
901 * Internal: Save header to file - async version.
902 */
903static int vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
904{
905 int rc;
906 switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
907 {
908 case 0:
909 rc = vdiFileWriteMetaAsync(pImage, sizeof(VDIPREHEADER),
910 &pImage->Header.u.v0,
911 sizeof(pImage->Header.u.v0),
912 pIoCtx, NULL, NULL);
913 break;
914 case 1:
915 if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
916 rc = vdiFileWriteMetaAsync(pImage, sizeof(VDIPREHEADER),
917 &pImage->Header.u.v1,
918 sizeof(pImage->Header.u.v1),
919 pIoCtx, NULL, NULL);
920 else
921 rc = vdiFileWriteMetaAsync(pImage, sizeof(VDIPREHEADER),
922 &pImage->Header.u.v1plus,
923 sizeof(pImage->Header.u.v1plus),
924 pIoCtx, NULL, NULL);
925 break;
926 default:
927 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
928 break;
929 }
930 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
931 ("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
932 return rc;
933}
934
935/**
936 * Internal: Save block pointer to file, save header to file.
937 */
938static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock)
939{
940 /* Update image header. */
941 int rc = vdiUpdateHeader(pImage);
942 if (RT_SUCCESS(rc))
943 {
944 /* write only one block pointer. */
945 rc = vdiFileWriteSync(pImage, pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
946 &pImage->paBlocks[uBlock], sizeof(VDIIMAGEBLOCKPOINTER),
947 NULL);
948 AssertMsgRC(rc, ("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
949 uBlock, pImage->pszFilename, rc));
950 }
951 return rc;
952}
953
954/**
955 * Internal: Save block pointer to file, save header to file - async version.
956 */
957static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock,
958 PVDIOCTX pIoCtx)
959{
960 /* Update image header. */
961 int rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
962 if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
963 {
964 /* write only one block pointer. */
965 rc = vdiFileWriteMetaAsync(pImage,
966 pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
967 &pImage->paBlocks[uBlock],
968 sizeof(VDIIMAGEBLOCKPOINTER),
969 pIoCtx, NULL, NULL);
970 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
971 ("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
972 uBlock, pImage->pszFilename, rc));
973 }
974 return rc;
975}
976
977/**
978 * Internal: Flush the image file to disk - async version.
979 */
980static int vdiFlushImageAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
981{
982 int rc = VINF_SUCCESS;
983
984 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
985 {
986 /* Save header. */
987 rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
988 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
989 ("vdiUpdateHeaderAsync() failed, filename=\"%s\", rc=%Rrc\n",
990 pImage->pszFilename, rc));
991 rc = vdiFileFlushAsync(pImage, pIoCtx, NULL, NULL);
992 AssertMsg(RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
993 ("Flushing data to disk failed rc=%Rrc\n", rc));
994 }
995
996 return rc;
997}
998
999
1000/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
1001static int vdiCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1002 PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
1003{
1004 LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
1005 int rc = VINF_SUCCESS;
1006 PVDIIMAGEDESC pImage;
1007
1008 if ( !VALID_PTR(pszFilename)
1009 || !*pszFilename)
1010 {
1011 rc = VERR_INVALID_PARAMETER;
1012 goto out;
1013 }
1014
1015 pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1016 if (!pImage)
1017 {
1018 rc = VERR_NO_MEMORY;
1019 goto out;
1020 }
1021 pImage->pszFilename = pszFilename;
1022 pImage->pStorage = NULL;
1023 pImage->paBlocks = NULL;
1024 pImage->pVDIfsDisk = pVDIfsDisk;
1025 pImage->pVDIfsImage = pVDIfsImage;
1026
1027 rc = vdiOpenImage(pImage, VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_READONLY);
1028 vdiFreeImage(pImage, false);
1029 RTMemFree(pImage);
1030
1031 if (RT_SUCCESS(rc))
1032 *penmType = VDTYPE_HDD;
1033
1034out:
1035 LogFlowFunc(("returns %Rrc\n", rc));
1036 return rc;
1037}
1038
1039/** @copydoc VBOXHDDBACKEND::pfnOpen */
1040static int vdiOpen(const char *pszFilename, unsigned uOpenFlags,
1041 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1042 VDTYPE enmType, void **ppBackendData)
1043{
1044 LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
1045 int rc;
1046 PVDIIMAGEDESC pImage;
1047
1048 /* Check open flags. All valid flags are supported. */
1049 if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1050 {
1051 rc = VERR_INVALID_PARAMETER;
1052 goto out;
1053 }
1054
1055 /* Check remaining arguments. */
1056 if ( !VALID_PTR(pszFilename)
1057 || !*pszFilename)
1058 {
1059 rc = VERR_INVALID_PARAMETER;
1060 goto out;
1061 }
1062
1063 pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1064 if (!pImage)
1065 {
1066 rc = VERR_NO_MEMORY;
1067 goto out;
1068 }
1069 pImage->pszFilename = pszFilename;
1070 pImage->pStorage = NULL;
1071 pImage->paBlocks = NULL;
1072 pImage->pVDIfsDisk = pVDIfsDisk;
1073 pImage->pVDIfsImage = pVDIfsImage;
1074
1075 rc = vdiOpenImage(pImage, uOpenFlags);
1076 if (RT_SUCCESS(rc))
1077 *ppBackendData = pImage;
1078
1079out:
1080 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1081 return rc;
1082}
1083
1084/** @copydoc VBOXHDDBACKEND::pfnCreate */
1085static int vdiCreate(const char *pszFilename, uint64_t cbSize,
1086 unsigned uImageFlags, const char *pszComment,
1087 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
1088 PCRTUUID pUuid, unsigned uOpenFlags,
1089 unsigned uPercentStart, unsigned uPercentSpan,
1090 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1091 PVDINTERFACE pVDIfsOperation, void **ppBackendData)
1092{
1093 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));
1094 int rc;
1095 PVDIIMAGEDESC pImage;
1096
1097 PFNVDPROGRESS pfnProgress = NULL;
1098 void *pvUser = NULL;
1099 PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
1100 VDINTERFACETYPE_PROGRESS);
1101 PVDINTERFACEPROGRESS pCbProgress = NULL;
1102 if (pIfProgress)
1103 {
1104 pCbProgress = VDGetInterfaceProgress(pIfProgress);
1105 if (pCbProgress)
1106 pfnProgress = pCbProgress->pfnProgress;
1107 pvUser = pIfProgress->pvUser;
1108 }
1109
1110 /* Check the image flags. */
1111 if ((uImageFlags & ~VD_VDI_IMAGE_FLAGS_MASK) != 0)
1112 {
1113 rc = VERR_VD_INVALID_TYPE;
1114 goto out;
1115 }
1116
1117 /* Check open flags. All valid flags are supported. */
1118 if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1119 {
1120 rc = VERR_INVALID_PARAMETER;
1121 goto out;
1122 }
1123
1124 /* Check size. Maximum 4PB-3M. No tricks with adjusting the 1M block size
1125 * so far, which would extend the size. */
1126 cbSize = RT_ALIGN_64(cbSize, _1M);
1127 if ( !cbSize
1128 || cbSize >= _1P * 4 - _1M * 3)
1129 {
1130 rc = VERR_VD_INVALID_SIZE;
1131 goto out;
1132 }
1133
1134 /* Check remaining arguments. */
1135 if ( !VALID_PTR(pszFilename)
1136 || !*pszFilename
1137 || cbSize < VDI_IMAGE_DEFAULT_BLOCK_SIZE
1138 || !VALID_PTR(pPCHSGeometry)
1139 || !VALID_PTR(pLCHSGeometry))
1140 {
1141 rc = VERR_INVALID_PARAMETER;
1142 goto out;
1143 }
1144
1145 pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1146 if (!pImage)
1147 {
1148 rc = VERR_NO_MEMORY;
1149 goto out;
1150 }
1151 pImage->pszFilename = pszFilename;
1152 pImage->pStorage = NULL;
1153 pImage->paBlocks = NULL;
1154 pImage->pVDIfsDisk = pVDIfsDisk;
1155 pImage->pVDIfsImage = pVDIfsImage;
1156
1157 rc = vdiCreateImage(pImage, cbSize, uImageFlags, pszComment,
1158 pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags,
1159 pfnProgress, pvUser, uPercentStart, uPercentSpan);
1160 if (RT_SUCCESS(rc))
1161 {
1162 /* So far the image is opened in read/write mode. Make sure the
1163 * image is opened in read-only mode if the caller requested that. */
1164 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
1165 {
1166 vdiFreeImage(pImage, false);
1167 rc = vdiOpenImage(pImage, uOpenFlags);
1168 if (RT_FAILURE(rc))
1169 {
1170 RTMemFree(pImage);
1171 goto out;
1172 }
1173 }
1174 *ppBackendData = pImage;
1175 }
1176 else
1177 RTMemFree(pImage);
1178
1179out:
1180 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1181 return rc;
1182}
1183
1184/** @copydoc VBOXHDDBACKEND::pfnRename */
1185static int vdiRename(void *pBackendData, const char *pszFilename)
1186{
1187 LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
1188
1189 int rc = VINF_SUCCESS;
1190 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1191
1192 /* Check arguments. */
1193 if ( !pImage
1194 || !pszFilename
1195 || !*pszFilename)
1196 {
1197 rc = VERR_INVALID_PARAMETER;
1198 goto out;
1199 }
1200
1201 /* Close the image. */
1202 vdiFreeImage(pImage, false);
1203
1204 /* Rename the file. */
1205 rc = vdiFileMove(pImage, pImage->pszFilename, pszFilename, 0);
1206 if (RT_FAILURE(rc))
1207 {
1208 /* The move failed, try to reopen the original image. */
1209 int rc2 = vdiOpenImage(pImage, pImage->uOpenFlags);
1210 if (RT_FAILURE(rc2))
1211 rc = rc2;
1212
1213 goto out;
1214 }
1215
1216 /* Update pImage with the new information. */
1217 pImage->pszFilename = pszFilename;
1218
1219 /* Open the new image. */
1220 rc = vdiOpenImage(pImage, pImage->uOpenFlags);
1221 if (RT_FAILURE(rc))
1222 goto out;
1223
1224out:
1225 LogFlowFunc(("returns %Rrc\n", rc));
1226 return rc;
1227}
1228
1229/** @copydoc VBOXHDDBACKEND::pfnClose */
1230static int vdiClose(void *pBackendData, bool fDelete)
1231{
1232 LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1233 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1234 int rc;
1235
1236 rc = vdiFreeImage(pImage, fDelete);
1237 RTMemFree(pImage);
1238
1239 LogFlowFunc(("returns %Rrc\n", rc));
1240 return rc;
1241}
1242
1243/** @copydoc VBOXHDDBACKEND::pfnRead */
1244static int vdiRead(void *pBackendData, uint64_t uOffset, void *pvBuf,
1245 size_t cbToRead, size_t *pcbActuallyRead)
1246{
1247 LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
1248 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1249 unsigned uBlock;
1250 unsigned offRead;
1251 int rc;
1252
1253 AssertPtr(pImage);
1254 Assert(!(uOffset % 512));
1255 Assert(!(cbToRead % 512));
1256
1257 if ( uOffset + cbToRead > getImageDiskSize(&pImage->Header)
1258 || !VALID_PTR(pvBuf)
1259 || !cbToRead)
1260 {
1261 rc = VERR_INVALID_PARAMETER;
1262 goto out;
1263 }
1264
1265 /* Calculate starting block number and offset inside it. */
1266 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1267 offRead = (unsigned)uOffset & pImage->uBlockMask;
1268
1269 /* Clip read range to at most the rest of the block. */
1270 cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
1271 Assert(!(cbToRead % 512));
1272
1273 if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
1274 rc = VERR_VD_BLOCK_FREE;
1275 else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
1276 {
1277 memset(pvBuf, 0, cbToRead);
1278 rc = VINF_SUCCESS;
1279 }
1280 else
1281 {
1282 /* Block present in image file, read relevant data. */
1283 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1284 + (pImage->offStartData + pImage->offStartBlockData + offRead);
1285 rc = vdiFileReadSync(pImage, u64Offset, pvBuf, cbToRead, NULL);
1286 }
1287
1288 if (pcbActuallyRead)
1289 *pcbActuallyRead = cbToRead;
1290
1291out:
1292 LogFlowFunc(("returns %Rrc\n", rc));
1293 return rc;
1294}
1295
1296/**@copydoc VBOXHDDBACKEND::pfnWrite */
1297static int vdiWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
1298 size_t cbToWrite, size_t *pcbWriteProcess,
1299 size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite)
1300{
1301 LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
1302 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1303 unsigned uBlock;
1304 unsigned offWrite;
1305 int rc = VINF_SUCCESS;
1306
1307 AssertPtr(pImage);
1308 Assert(!(uOffset % 512));
1309 Assert(!(cbToWrite % 512));
1310
1311 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1312 {
1313 rc = VERR_VD_IMAGE_READ_ONLY;
1314 goto out;
1315 }
1316
1317 if (!VALID_PTR(pvBuf) || !cbToWrite)
1318 {
1319 rc = VERR_INVALID_PARAMETER;
1320 goto out;
1321 }
1322
1323 /* No size check here, will do that later. For dynamic images which are
1324 * not multiples of the block size in length, this would prevent writing to
1325 * the last block. */
1326
1327 /* Calculate starting block number and offset inside it. */
1328 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1329 offWrite = (unsigned)uOffset & pImage->uBlockMask;
1330
1331 /* Clip write range to at most the rest of the block. */
1332 cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
1333 Assert(!(cbToWrite % 512));
1334
1335 do
1336 {
1337 if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
1338 {
1339 /* Block is either free or zero. */
1340 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
1341 && ( pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
1342 || cbToWrite == getImageBlockSize(&pImage->Header)))
1343 {
1344 /* If the destination block is unallocated at this point, it's
1345 * either a zero block or a block which hasn't been used so far
1346 * (which also means that it's a zero block. Don't need to write
1347 * anything to this block if the data consists of just zeroes. */
1348 Assert(!(cbToWrite % 4));
1349 Assert(cbToWrite * 8 <= UINT32_MAX);
1350 if (ASMBitFirstSet((volatile void *)pvBuf, (uint32_t)cbToWrite * 8) == -1)
1351 {
1352 pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
1353 break;
1354 }
1355 }
1356
1357 if ( cbToWrite == getImageBlockSize(&pImage->Header)
1358 && !(fWrite & VD_WRITE_NO_ALLOC))
1359 {
1360 /* Full block write to previously unallocated block.
1361 * Allocate block and write data. */
1362 Assert(!offWrite);
1363 unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
1364 uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
1365 + (pImage->offStartData + pImage->offStartBlockData);
1366 rc = vdiFileWriteSync(pImage, u64Offset, pvBuf, cbToWrite, NULL);
1367 if (RT_FAILURE(rc))
1368 goto out;
1369 pImage->paBlocks[uBlock] = cBlocksAllocated;
1370 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
1371
1372 rc = vdiUpdateBlockInfo(pImage, uBlock);
1373 if (RT_FAILURE(rc))
1374 goto out;
1375
1376 *pcbPreRead = 0;
1377 *pcbPostRead = 0;
1378 }
1379 else
1380 {
1381 /* Trying to do a partial write to an unallocated block. Don't do
1382 * anything except letting the upper layer know what to do. */
1383 *pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
1384 *pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - *pcbPreRead;
1385 rc = VERR_VD_BLOCK_FREE;
1386 }
1387 }
1388 else
1389 {
1390 /* Block present in image file, write relevant data. */
1391 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1392 + (pImage->offStartData + pImage->offStartBlockData + offWrite);
1393 rc = vdiFileWriteSync(pImage, u64Offset, pvBuf, cbToWrite, NULL);
1394 }
1395 } while (0);
1396
1397 if (pcbWriteProcess)
1398 *pcbWriteProcess = cbToWrite;
1399
1400out:
1401 LogFlowFunc(("returns %Rrc\n", rc));
1402 return rc;
1403}
1404
1405/** @copydoc VBOXHDDBACKEND::pfnFlush */
1406static int vdiFlush(void *pBackendData)
1407{
1408 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1409 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1410 int rc = VINF_SUCCESS;
1411
1412 Assert(pImage);
1413
1414 vdiFlushImage(pImage);
1415 LogFlowFunc(("returns %Rrc\n", rc));
1416 return rc;
1417}
1418
1419/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
1420static unsigned vdiGetVersion(void *pBackendData)
1421{
1422 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1423 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1424 unsigned uVersion;
1425
1426 AssertPtr(pImage);
1427
1428 if (pImage)
1429 uVersion = pImage->PreHeader.u32Version;
1430 else
1431 uVersion = 0;
1432
1433 LogFlowFunc(("returns %#x\n", uVersion));
1434 return uVersion;
1435}
1436
1437/** @copydoc VBOXHDDBACKEND::pfnGetSize */
1438static uint64_t vdiGetSize(void *pBackendData)
1439{
1440 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1441 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1442 uint64_t cbSize;
1443
1444 AssertPtr(pImage);
1445
1446 if (pImage)
1447 cbSize = getImageDiskSize(&pImage->Header);
1448 else
1449 cbSize = 0;
1450
1451 LogFlowFunc(("returns %llu\n", cbSize));
1452 return cbSize;
1453}
1454
1455/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
1456static uint64_t vdiGetFileSize(void *pBackendData)
1457{
1458 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1459 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1460 uint64_t cb = 0;
1461
1462 AssertPtr(pImage);
1463
1464 if (pImage)
1465 {
1466 uint64_t cbFile;
1467 if (pImage->pStorage)
1468 {
1469 int rc = vdiFileGetSize(pImage, &cbFile);
1470 if (RT_SUCCESS(rc))
1471 cb += cbFile;
1472 }
1473 }
1474
1475 LogFlowFunc(("returns %lld\n", cb));
1476 return cb;
1477}
1478
1479/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
1480static int vdiGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
1481{
1482 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1483 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1484 int rc;
1485
1486 AssertPtr(pImage);
1487
1488 if (pImage)
1489 {
1490 if (pImage->PCHSGeometry.cCylinders)
1491 {
1492 *pPCHSGeometry = pImage->PCHSGeometry;
1493 rc = VINF_SUCCESS;
1494 }
1495 else
1496 rc = VERR_VD_GEOMETRY_NOT_SET;
1497 }
1498 else
1499 rc = VERR_VD_NOT_OPENED;
1500
1501 LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1502 return rc;
1503}
1504
1505/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
1506static int vdiSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
1507{
1508 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1509 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1510 int rc;
1511
1512 AssertPtr(pImage);
1513
1514 if (pImage)
1515 {
1516 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1517 {
1518 rc = VERR_VD_IMAGE_READ_ONLY;
1519 goto out;
1520 }
1521
1522 pImage->PCHSGeometry = *pPCHSGeometry;
1523 rc = VINF_SUCCESS;
1524 }
1525 else
1526 rc = VERR_VD_NOT_OPENED;
1527
1528out:
1529 LogFlowFunc(("returns %Rrc\n", rc));
1530 return rc;
1531}
1532
1533/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
1534static int vdiGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
1535{
1536 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1537 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1538 int rc;
1539
1540 AssertPtr(pImage);
1541
1542 if (pImage)
1543 {
1544 VDIDISKGEOMETRY DummyGeo = { 0, 0, 0, VDI_GEOMETRY_SECTOR_SIZE };
1545 PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
1546 if (!pGeometry)
1547 pGeometry = &DummyGeo;
1548
1549 if ( pGeometry->cCylinders > 0
1550 && pGeometry->cHeads > 0
1551 && pGeometry->cSectors > 0)
1552 {
1553 pLCHSGeometry->cCylinders = pGeometry->cCylinders;
1554 pLCHSGeometry->cHeads = pGeometry->cHeads;
1555 pLCHSGeometry->cSectors = pGeometry->cSectors;
1556 rc = VINF_SUCCESS;
1557 }
1558 else
1559 rc = VERR_VD_GEOMETRY_NOT_SET;
1560 }
1561 else
1562 rc = VERR_VD_NOT_OPENED;
1563
1564 LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1565 return rc;
1566}
1567
1568/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
1569static int vdiSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
1570{
1571 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1572 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1573 PVDIDISKGEOMETRY pGeometry;
1574 int rc;
1575
1576 AssertPtr(pImage);
1577
1578 if (pImage)
1579 {
1580 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1581 {
1582 rc = VERR_VD_IMAGE_READ_ONLY;
1583 goto out;
1584 }
1585
1586 pGeometry = getImageLCHSGeometry(&pImage->Header);
1587 if (pGeometry)
1588 {
1589 pGeometry->cCylinders = pLCHSGeometry->cCylinders;
1590 pGeometry->cHeads = pLCHSGeometry->cHeads;
1591 pGeometry->cSectors = pLCHSGeometry->cSectors;
1592 pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
1593
1594 /* Update header information in base image file. */
1595 vdiFlushImage(pImage);
1596 }
1597 rc = VINF_SUCCESS;
1598 }
1599 else
1600 rc = VERR_VD_NOT_OPENED;
1601
1602out:
1603 LogFlowFunc(("returns %Rrc\n", rc));
1604 return rc;
1605}
1606
1607/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
1608static unsigned vdiGetImageFlags(void *pBackendData)
1609{
1610 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1611 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1612 unsigned uImageFlags;
1613
1614 AssertPtr(pImage);
1615
1616 if (pImage)
1617 uImageFlags = pImage->uImageFlags;
1618 else
1619 uImageFlags = 0;
1620
1621 LogFlowFunc(("returns %#x\n", uImageFlags));
1622 return uImageFlags;
1623}
1624
1625/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
1626static unsigned vdiGetOpenFlags(void *pBackendData)
1627{
1628 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1629 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1630 unsigned uOpenFlags;
1631
1632 AssertPtr(pImage);
1633
1634 if (pImage)
1635 uOpenFlags = pImage->uOpenFlags;
1636 else
1637 uOpenFlags = 0;
1638
1639 LogFlowFunc(("returns %#x\n", uOpenFlags));
1640 return uOpenFlags;
1641}
1642
1643/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
1644static int vdiSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
1645{
1646 LogFlowFunc(("pBackendData=%#p uOpenFlags=%#x\n", pBackendData, uOpenFlags));
1647 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1648 int rc;
1649 const char *pszFilename;
1650
1651 /* Image must be opened and the new flags must be valid. */
1652 if (!pImage || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_ASYNC_IO | VD_OPEN_FLAGS_SHAREABLE | VD_OPEN_FLAGS_SEQUENTIAL)))
1653 {
1654 rc = VERR_INVALID_PARAMETER;
1655 goto out;
1656 }
1657
1658 /* Implement this operation via reopening the image. */
1659 pszFilename = pImage->pszFilename;
1660 rc = vdiFreeImage(pImage, false);
1661 if (RT_FAILURE(rc))
1662 goto out;
1663 rc = vdiOpenImage(pImage, uOpenFlags);
1664
1665out:
1666 LogFlowFunc(("returns %Rrc\n", rc));
1667 return rc;
1668}
1669
1670/** @copydoc VBOXHDDBACKEND::pfnGetComment */
1671static int vdiGetComment(void *pBackendData, char *pszComment,
1672 size_t cbComment)
1673{
1674 LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
1675 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1676 int rc = VINF_SUCCESS;
1677
1678 AssertPtr(pImage);
1679
1680 if (pImage)
1681 {
1682 char *pszTmp = getImageComment(&pImage->Header);
1683 /* Make this foolproof even if the image doesn't have the zero
1684 * termination. With some luck the repaired header will be saved. */
1685 size_t cb = RTStrNLen(pszTmp, VDI_IMAGE_COMMENT_SIZE);
1686 if (cb == VDI_IMAGE_COMMENT_SIZE)
1687 {
1688 pszTmp[VDI_IMAGE_COMMENT_SIZE-1] = '\0';
1689 cb--;
1690 }
1691 if (cb < cbComment)
1692 {
1693 /* memcpy is much better than strncpy. */
1694 memcpy(pszComment, pszTmp, cb + 1);
1695 }
1696 else
1697 rc = VERR_BUFFER_OVERFLOW;
1698 }
1699 else
1700 rc = VERR_VD_NOT_OPENED;
1701
1702 LogFlowFunc(("returns %Rrc comment=\"%s\"\n", rc, pszComment));
1703 return rc;
1704}
1705
1706/** @copydoc VBOXHDDBACKEND::pfnGetComment */
1707static int vdiSetComment(void *pBackendData, const char *pszComment)
1708{
1709 LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
1710 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1711 int rc;
1712
1713 AssertPtr(pImage);
1714
1715 if (pImage)
1716 {
1717 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1718 rc = VERR_VD_IMAGE_READ_ONLY;
1719 else
1720 {
1721 size_t cchComment = pszComment ? strlen(pszComment) : 0;
1722 if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
1723 {
1724 LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
1725 rc = VERR_VD_VDI_COMMENT_TOO_LONG;
1726 goto out;
1727 }
1728
1729 /* we don't support old style images */
1730 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1731 {
1732 /*
1733 * Update the comment field, making sure to zero out all of the previous comment.
1734 */
1735 memset(pImage->Header.u.v1.szComment, '\0', VDI_IMAGE_COMMENT_SIZE);
1736 memcpy(pImage->Header.u.v1.szComment, pszComment, cchComment);
1737
1738 /* write out new the header */
1739 rc = vdiUpdateHeader(pImage);
1740 }
1741 else
1742 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1743 }
1744 }
1745 else
1746 rc = VERR_VD_NOT_OPENED;
1747
1748out:
1749 LogFlowFunc(("returns %Rrc\n", rc));
1750 return rc;
1751}
1752
1753/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
1754static int vdiGetUuid(void *pBackendData, PRTUUID pUuid)
1755{
1756 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1757 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1758 int rc;
1759
1760 AssertPtr(pImage);
1761
1762 if (pImage)
1763 {
1764 *pUuid = *getImageCreationUUID(&pImage->Header);
1765 rc = VINF_SUCCESS;
1766 }
1767 else
1768 rc = VERR_VD_NOT_OPENED;
1769
1770 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1771 return rc;
1772}
1773
1774/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
1775static int vdiSetUuid(void *pBackendData, PCRTUUID pUuid)
1776{
1777 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1778 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1779 int rc = VINF_SUCCESS;
1780
1781 AssertPtr(pImage);
1782
1783 if (pImage)
1784 {
1785 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1786 {
1787 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1788 pImage->Header.u.v1.uuidCreate = *pUuid;
1789 /* Make it possible to clone old VDIs. */
1790 else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1791 pImage->Header.u.v0.uuidCreate = *pUuid;
1792 else
1793 {
1794 LogFunc(("Version is not supported!\n"));
1795 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1796 }
1797 }
1798 else
1799 rc = VERR_VD_IMAGE_READ_ONLY;
1800 }
1801 else
1802 rc = VERR_VD_NOT_OPENED;
1803
1804 LogFlowFunc(("returns %Rrc\n", rc));
1805 return rc;
1806}
1807
1808/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
1809static int vdiGetModificationUuid(void *pBackendData, PRTUUID pUuid)
1810{
1811 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1812 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1813 int rc;
1814
1815 AssertPtr(pImage);
1816
1817 if (pImage)
1818 {
1819 *pUuid = *getImageModificationUUID(&pImage->Header);
1820 rc = VINF_SUCCESS;
1821 }
1822 else
1823 rc = VERR_VD_NOT_OPENED;
1824
1825 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1826 return rc;
1827}
1828
1829/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
1830static int vdiSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
1831{
1832 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1833 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1834 int rc = VINF_SUCCESS;
1835
1836 AssertPtr(pImage);
1837
1838 if (pImage)
1839 {
1840 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1841 {
1842 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1843 pImage->Header.u.v1.uuidModify = *pUuid;
1844 /* Make it possible to clone old VDIs. */
1845 else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1846 pImage->Header.u.v0.uuidModify = *pUuid;
1847 else
1848 {
1849 LogFunc(("Version is not supported!\n"));
1850 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1851 }
1852 }
1853 else
1854 rc = VERR_VD_IMAGE_READ_ONLY;
1855 }
1856 else
1857 rc = VERR_VD_NOT_OPENED;
1858
1859 LogFlowFunc(("returns %Rrc\n", rc));
1860 return rc;
1861}
1862
1863/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
1864static int vdiGetParentUuid(void *pBackendData, PRTUUID pUuid)
1865{
1866 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1867 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1868 int rc;
1869
1870 AssertPtr(pImage);
1871
1872 if (pImage)
1873 {
1874 *pUuid = *getImageParentUUID(&pImage->Header);
1875 rc = VINF_SUCCESS;
1876 }
1877 else
1878 rc = VERR_VD_NOT_OPENED;
1879
1880 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1881 return rc;
1882}
1883
1884/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
1885static int vdiSetParentUuid(void *pBackendData, PCRTUUID pUuid)
1886{
1887 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1888 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1889 int rc = VINF_SUCCESS;
1890
1891 AssertPtr(pImage);
1892
1893 if (pImage)
1894 {
1895 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1896 {
1897 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1898 pImage->Header.u.v1.uuidLinkage = *pUuid;
1899 /* Make it possible to clone old VDIs. */
1900 else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1901 pImage->Header.u.v0.uuidLinkage = *pUuid;
1902 else
1903 {
1904 LogFunc(("Version is not supported!\n"));
1905 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1906 }
1907 }
1908 else
1909 rc = VERR_VD_IMAGE_READ_ONLY;
1910 }
1911 else
1912 rc = VERR_VD_NOT_OPENED;
1913
1914 LogFlowFunc(("returns %Rrc\n", rc));
1915 return rc;
1916}
1917
1918/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
1919static int vdiGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
1920{
1921 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1922 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1923 int rc;
1924
1925 AssertPtr(pImage);
1926
1927 if (pImage)
1928 {
1929 *pUuid = *getImageParentModificationUUID(&pImage->Header);
1930 rc = VINF_SUCCESS;
1931 }
1932 else
1933 rc = VERR_VD_NOT_OPENED;
1934
1935 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1936 return rc;
1937}
1938
1939/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
1940static int vdiSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
1941{
1942 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1943 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1944 int rc = VINF_SUCCESS;
1945
1946 AssertPtr(pImage);
1947
1948 if (pImage)
1949 {
1950 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1951 {
1952 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1953 pImage->Header.u.v1.uuidParentModify = *pUuid;
1954 else
1955 {
1956 LogFunc(("Version is not supported!\n"));
1957 rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1958 }
1959 }
1960 else
1961 rc = VERR_VD_IMAGE_READ_ONLY;
1962 }
1963 else
1964 rc = VERR_VD_NOT_OPENED;
1965
1966 LogFlowFunc(("returns %Rrc\n", rc));
1967 return rc;
1968}
1969
1970/** @copydoc VBOXHDDBACKEND::pfnDump */
1971static void vdiDump(void *pBackendData)
1972{
1973 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1974
1975 vdiMessage(pImage, "Dumping VDI image \"%s\" mode=%s uOpenFlags=%X File=%#p\n",
1976 pImage->pszFilename,
1977 (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY) ? "r/o" : "r/w",
1978 pImage->uOpenFlags,
1979 pImage->pStorage);
1980 vdiMessage(pImage, "Header: Version=%08X Type=%X Flags=%X Size=%llu\n",
1981 pImage->PreHeader.u32Version,
1982 getImageType(&pImage->Header),
1983 getImageFlags(&pImage->Header),
1984 getImageDiskSize(&pImage->Header));
1985 vdiMessage(pImage, "Header: cbBlock=%u cbBlockExtra=%u cBlocks=%u cBlocksAllocated=%u\n",
1986 getImageBlockSize(&pImage->Header),
1987 getImageExtraBlockSize(&pImage->Header),
1988 getImageBlocks(&pImage->Header),
1989 getImageBlocksAllocated(&pImage->Header));
1990 vdiMessage(pImage, "Header: offBlocks=%u offData=%u\n",
1991 getImageBlocksOffset(&pImage->Header),
1992 getImageDataOffset(&pImage->Header));
1993 PVDIDISKGEOMETRY pg = getImageLCHSGeometry(&pImage->Header);
1994 if (pg)
1995 vdiMessage(pImage, "Header: Geometry: C/H/S=%u/%u/%u cbSector=%u\n",
1996 pg->cCylinders, pg->cHeads, pg->cSectors, pg->cbSector);
1997 vdiMessage(pImage, "Header: uuidCreation={%RTuuid}\n", getImageCreationUUID(&pImage->Header));
1998 vdiMessage(pImage, "Header: uuidModification={%RTuuid}\n", getImageModificationUUID(&pImage->Header));
1999 vdiMessage(pImage, "Header: uuidParent={%RTuuid}\n", getImageParentUUID(&pImage->Header));
2000 if (GET_MAJOR_HEADER_VERSION(&pImage->Header) >= 1)
2001 vdiMessage(pImage, "Header: uuidParentModification={%RTuuid}\n", getImageParentModificationUUID(&pImage->Header));
2002 vdiMessage(pImage, "Image: fFlags=%08X offStartBlocks=%u offStartData=%u\n",
2003 pImage->uImageFlags, pImage->offStartBlocks, pImage->offStartData);
2004 vdiMessage(pImage, "Image: uBlockMask=%08X cbTotalBlockData=%u uShiftOffset2Index=%u offStartBlockData=%u\n",
2005 pImage->uBlockMask,
2006 pImage->cbTotalBlockData,
2007 pImage->uShiftOffset2Index,
2008 pImage->offStartBlockData);
2009
2010 unsigned uBlock, cBlocksNotFree, cBadBlocks, cBlocks = getImageBlocks(&pImage->Header);
2011 for (uBlock=0, cBlocksNotFree=0, cBadBlocks=0; uBlock<cBlocks; uBlock++)
2012 {
2013 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
2014 {
2015 cBlocksNotFree++;
2016 if (pImage->paBlocks[uBlock] >= cBlocks)
2017 cBadBlocks++;
2018 }
2019 }
2020 if (cBlocksNotFree != getImageBlocksAllocated(&pImage->Header))
2021 {
2022 vdiMessage(pImage, "!! WARNING: %u blocks actually allocated (cBlocksAllocated=%u) !!\n",
2023 cBlocksNotFree, getImageBlocksAllocated(&pImage->Header));
2024 }
2025 if (cBadBlocks)
2026 {
2027 vdiMessage(pImage, "!! WARNING: %u bad blocks found !!\n",
2028 cBadBlocks);
2029 }
2030}
2031
2032static int vdiAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
2033 PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
2034{
2035 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
2036 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
2037 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2038 unsigned uBlock;
2039 unsigned offRead;
2040 int rc;
2041
2042 AssertPtr(pImage);
2043 Assert(!(uOffset % 512));
2044 Assert(!(cbToRead % 512));
2045
2046 if ( uOffset + cbToRead > getImageDiskSize(&pImage->Header)
2047 || !VALID_PTR(pIoCtx)
2048 || !cbToRead)
2049 {
2050 rc = VERR_INVALID_PARAMETER;
2051 goto out;
2052 }
2053
2054 /* Calculate starting block number and offset inside it. */
2055 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
2056 offRead = (unsigned)uOffset & pImage->uBlockMask;
2057
2058 /* Clip read range to at most the rest of the block. */
2059 cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
2060 Assert(!(cbToRead % 512));
2061
2062 if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
2063 rc = VERR_VD_BLOCK_FREE;
2064 else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
2065 {
2066 size_t cbSet;
2067
2068 cbSet = vdiFileIoCtxSet(pImage, pIoCtx, 0, cbToRead);
2069 Assert(cbSet == cbToRead);
2070
2071 rc = VINF_SUCCESS;
2072 }
2073 else
2074 {
2075 /* Block present in image file, read relevant data. */
2076 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
2077 + (pImage->offStartData + pImage->offStartBlockData + offRead);
2078 rc = vdiFileReadUserAsync(pImage, u64Offset, pIoCtx, cbToRead);
2079 }
2080
2081 if (pcbActuallyRead)
2082 *pcbActuallyRead = cbToRead;
2083
2084out:
2085 LogFlowFunc(("returns %Rrc\n", rc));
2086 return rc;
2087}
2088
2089static int vdiAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
2090 PVDIOCTX pIoCtx,
2091 size_t *pcbWriteProcess, size_t *pcbPreRead,
2092 size_t *pcbPostRead, unsigned fWrite)
2093{
2094 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
2095 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
2096 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2097 unsigned uBlock;
2098 unsigned offWrite;
2099 int rc = VINF_SUCCESS;
2100
2101 AssertPtr(pImage);
2102 Assert(!(uOffset % 512));
2103 Assert(!(cbToWrite % 512));
2104
2105 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2106 {
2107 rc = VERR_VD_IMAGE_READ_ONLY;
2108 goto out;
2109 }
2110
2111 if (!VALID_PTR(pIoCtx) || !cbToWrite)
2112 {
2113 rc = VERR_INVALID_PARAMETER;
2114 goto out;
2115 }
2116
2117 /* No size check here, will do that later. For dynamic images which are
2118 * not multiples of the block size in length, this would prevent writing to
2119 * the last block. */
2120
2121 /* Calculate starting block number and offset inside it. */
2122 uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
2123 offWrite = (unsigned)uOffset & pImage->uBlockMask;
2124
2125 /* Clip write range to at most the rest of the block. */
2126 cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
2127 Assert(!(cbToWrite % 512));
2128
2129 do
2130 {
2131 if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
2132 {
2133 /* Block is either free or zero. */
2134 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
2135 && ( pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
2136 || cbToWrite == getImageBlockSize(&pImage->Header)))
2137 {
2138#if 0 /** @todo Provide interface to check an I/O context for a specific value */
2139 /* If the destination block is unallocated at this point, it's
2140 * either a zero block or a block which hasn't been used so far
2141 * (which also means that it's a zero block. Don't need to write
2142 * anything to this block if the data consists of just zeroes. */
2143 Assert(!(cbToWrite % 4));
2144 Assert(cbToWrite * 8 <= UINT32_MAX);
2145 if (ASMBitFirstSet((volatile void *)pvBuf, (uint32_t)cbToWrite * 8) == -1)
2146 {
2147 pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
2148 break;
2149 }
2150#endif
2151 }
2152
2153 if ( cbToWrite == getImageBlockSize(&pImage->Header)
2154 && !(fWrite & VD_WRITE_NO_ALLOC))
2155 {
2156 /* Full block write to previously unallocated block.
2157 * Allocate block and write data. */
2158 Assert(!offWrite);
2159 unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
2160 uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
2161 + (pImage->offStartData + pImage->offStartBlockData);
2162 rc = vdiFileWriteUserAsync(pImage, u64Offset, pIoCtx, cbToWrite, NULL, NULL);
2163 if (RT_UNLIKELY(RT_FAILURE_NP(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)))
2164 goto out;
2165 pImage->paBlocks[uBlock] = cBlocksAllocated;
2166 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
2167
2168 rc = vdiUpdateBlockInfoAsync(pImage, uBlock, pIoCtx);
2169 if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
2170 goto out;
2171
2172 *pcbPreRead = 0;
2173 *pcbPostRead = 0;
2174 }
2175 else
2176 {
2177 /* Trying to do a partial write to an unallocated block. Don't do
2178 * anything except letting the upper layer know what to do. */
2179 *pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
2180 *pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - *pcbPreRead;
2181 rc = VERR_VD_BLOCK_FREE;
2182 }
2183 }
2184 else
2185 {
2186 /* Block present in image file, write relevant data. */
2187 uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
2188 + (pImage->offStartData + pImage->offStartBlockData + offWrite);
2189 rc = vdiFileWriteUserAsync(pImage, u64Offset, pIoCtx, cbToWrite, NULL, NULL);
2190 }
2191 } while (0);
2192
2193 if (pcbWriteProcess)
2194 *pcbWriteProcess = cbToWrite;
2195
2196out:
2197 LogFlowFunc(("returns %Rrc\n", rc));
2198 return rc;
2199}
2200
2201static int vdiAsyncFlush(void *pBackendData, PVDIOCTX pIoCtx)
2202{
2203 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2204 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2205 int rc = VINF_SUCCESS;
2206
2207 Assert(pImage);
2208
2209 rc = vdiFlushImageAsync(pImage, pIoCtx);
2210 LogFlowFunc(("returns %Rrc\n", rc));
2211 return rc;
2212}
2213
2214/** @copydoc VBOXHDDBACKEND::pfnCompact */
2215static int vdiCompact(void *pBackendData, unsigned uPercentStart,
2216 unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
2217 PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation)
2218{
2219 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2220 int rc = VINF_SUCCESS;
2221 void *pvBuf = NULL, *pvTmp = NULL;
2222 unsigned *paBlocks2 = NULL;
2223
2224 int (*pfnParentRead)(void *, uint64_t, void *, size_t) = NULL;
2225 void *pvParent = NULL;
2226 PVDINTERFACE pIfParentState = VDInterfaceGet(pVDIfsOperation,
2227 VDINTERFACETYPE_PARENTSTATE);
2228 PVDINTERFACEPARENTSTATE pCbParentState = NULL;
2229 if (pIfParentState)
2230 {
2231 pCbParentState = VDGetInterfaceParentState(pIfParentState);
2232 if (pCbParentState)
2233 pfnParentRead = pCbParentState->pfnParentRead;
2234 pvParent = pIfParentState->pvUser;
2235 }
2236
2237 PFNVDPROGRESS pfnProgress = NULL;
2238 void *pvUser = NULL;
2239 PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
2240 VDINTERFACETYPE_PROGRESS);
2241 PVDINTERFACEPROGRESS pCbProgress = NULL;
2242 if (pIfProgress)
2243 {
2244 pCbProgress = VDGetInterfaceProgress(pIfProgress);
2245 if (pCbProgress)
2246 pfnProgress = pCbProgress->pfnProgress;
2247 pvUser = pIfProgress->pvUser;
2248 }
2249
2250 do {
2251 AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
2252
2253 AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2254 rc = VERR_VD_IMAGE_READ_ONLY);
2255
2256 unsigned cBlocks;
2257 unsigned cBlocksToMove = 0;
2258 size_t cbBlock;
2259 cBlocks = getImageBlocks(&pImage->Header);
2260 cbBlock = getImageBlockSize(&pImage->Header);
2261 if (pfnParentRead)
2262 {
2263 pvBuf = RTMemTmpAlloc(cbBlock);
2264 AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
2265 }
2266 pvTmp = RTMemTmpAlloc(cbBlock);
2267 AssertBreakStmt(VALID_PTR(pvTmp), rc = VERR_NO_MEMORY);
2268
2269 uint64_t cbFile;
2270 rc = vdiFileGetSize(pImage, &cbFile);
2271 AssertRCBreak(rc);
2272 unsigned cBlocksAllocated = (unsigned)((cbFile - pImage->offStartData - pImage->offStartBlockData) >> pImage->uShiftOffset2Index);
2273 if (cBlocksAllocated == 0)
2274 {
2275 /* No data blocks in this image, no need to compact. */
2276 rc = VINF_SUCCESS;
2277 break;
2278 }
2279
2280 /* Allocate block array for back resolving. */
2281 paBlocks2 = (unsigned *)RTMemAlloc(sizeof(unsigned *) * cBlocksAllocated);
2282 AssertBreakStmt(VALID_PTR(paBlocks2), rc = VERR_NO_MEMORY);
2283 /* Fill out back resolving, check/fix allocation errors before
2284 * compacting the image, just to be on the safe side. Update the
2285 * image contents straight away, as this enables cancelling. */
2286 for (unsigned i = 0; i < cBlocksAllocated; i++)
2287 paBlocks2[i] = VDI_IMAGE_BLOCK_FREE;
2288 rc = VINF_SUCCESS;
2289 for (unsigned i = 0; i < cBlocks; i++)
2290 {
2291 VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
2292 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
2293 {
2294 if (ptrBlock < cBlocksAllocated)
2295 {
2296 if (paBlocks2[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
2297 paBlocks2[ptrBlock] = i;
2298 else
2299 {
2300 LogFunc(("Freed cross-linked block %u in file \"%s\"\n",
2301 i, pImage->pszFilename));
2302 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2303 rc = vdiUpdateBlockInfo(pImage, i);
2304 if (RT_FAILURE(rc))
2305 break;
2306 }
2307 }
2308 else
2309 {
2310 LogFunc(("Freed out of bounds reference for block %u in file \"%s\"\n",
2311 i, pImage->pszFilename));
2312 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2313 rc = vdiUpdateBlockInfo(pImage, i);
2314 if (RT_FAILURE(rc))
2315 break;
2316 }
2317 }
2318 }
2319 if (RT_FAILURE(rc))
2320 break;
2321
2322 /* Find redundant information and update the block pointers
2323 * accordingly, creating bubbles. Keep disk up to date, as this
2324 * enables cancelling. */
2325 for (unsigned i = 0; i < cBlocks; i++)
2326 {
2327 VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
2328 if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
2329 {
2330 /* Block present in image file, read relevant data. */
2331 uint64_t u64Offset = (uint64_t)ptrBlock * pImage->cbTotalBlockData
2332 + (pImage->offStartData + pImage->offStartBlockData);
2333 rc = vdiFileReadSync(pImage, u64Offset, pvTmp, cbBlock, NULL);
2334 if (RT_FAILURE(rc))
2335 break;
2336
2337 if (ASMBitFirstSet((volatile void *)pvTmp, (uint32_t)cbBlock * 8) == -1)
2338 {
2339 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_ZERO;
2340 rc = vdiUpdateBlockInfo(pImage, i);
2341 if (RT_FAILURE(rc))
2342 break;
2343 paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2344 /* Adjust progress info, one block to be relocated. */
2345 cBlocksToMove++;
2346 }
2347 else if (pfnParentRead)
2348 {
2349 rc = pfnParentRead(pvParent, i * cbBlock, pvBuf, cbBlock);
2350 if (RT_FAILURE(rc))
2351 break;
2352 if (!memcmp(pvTmp, pvBuf, cbBlock))
2353 {
2354 pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2355 rc = vdiUpdateBlockInfo(pImage, i);
2356 if (RT_FAILURE(rc))
2357 break;
2358 paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2359 /* Adjust progress info, one block to be relocated. */
2360 cBlocksToMove++;
2361 }
2362 }
2363 }
2364
2365 if (pCbProgress && pCbProgress->pfnProgress)
2366 {
2367 rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
2368 (uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2369 if (RT_FAILURE(rc))
2370 break;
2371 }
2372 }
2373 if (RT_FAILURE(rc))
2374 break;
2375
2376 /* Fill bubbles with other data (if available). */
2377 unsigned cBlocksMoved = 0;
2378 unsigned uBlockUsedPos = cBlocksAllocated;
2379 for (unsigned i = 0; i < cBlocksAllocated; i++)
2380 {
2381 unsigned uBlock = paBlocks2[i];
2382 if (uBlock == VDI_IMAGE_BLOCK_FREE)
2383 {
2384 unsigned uBlockData = VDI_IMAGE_BLOCK_FREE;
2385 while (uBlockUsedPos > i && uBlockData == VDI_IMAGE_BLOCK_FREE)
2386 {
2387 uBlockUsedPos--;
2388 uBlockData = paBlocks2[uBlockUsedPos];
2389 }
2390 /* Terminate early if there is no block which needs copying. */
2391 if (uBlockUsedPos == i)
2392 break;
2393 uint64_t u64Offset = (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2394 + (pImage->offStartData + pImage->offStartBlockData);
2395 rc = vdiFileReadSync(pImage, u64Offset, pvTmp, cbBlock, NULL);
2396 u64Offset = (uint64_t)i * pImage->cbTotalBlockData
2397 + (pImage->offStartData + pImage->offStartBlockData);
2398 rc = vdiFileWriteSync(pImage, u64Offset, pvTmp, cbBlock, NULL);
2399 pImage->paBlocks[uBlockData] = i;
2400 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated - cBlocksMoved);
2401 rc = vdiUpdateBlockInfo(pImage, uBlockData);
2402 if (RT_FAILURE(rc))
2403 break;
2404 paBlocks2[i] = uBlockData;
2405 paBlocks2[uBlockUsedPos] = VDI_IMAGE_BLOCK_FREE;
2406 cBlocksMoved++;
2407 }
2408
2409 if (pCbProgress && pCbProgress->pfnProgress)
2410 {
2411 rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
2412 (uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2413
2414 if (RT_FAILURE(rc))
2415 break;
2416 }
2417 }
2418 if (RT_FAILURE(rc))
2419 break;
2420
2421 /* Update image header. */
2422 setImageBlocksAllocated(&pImage->Header, uBlockUsedPos);
2423 vdiUpdateHeader(pImage);
2424
2425 /* Truncate the image to the proper size to finish compacting. */
2426 rc = vdiFileSetSize(pImage,
2427 (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2428 + pImage->offStartData + pImage->offStartBlockData);
2429 } while (0);
2430
2431 if (paBlocks2)
2432 RTMemTmpFree(paBlocks2);
2433 if (pvTmp)
2434 RTMemTmpFree(pvTmp);
2435 if (pvBuf)
2436 RTMemTmpFree(pvBuf);
2437
2438 if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
2439 {
2440 pCbProgress->pfnProgress(pIfProgress->pvUser,
2441 uPercentStart + uPercentSpan);
2442 }
2443
2444 LogFlowFunc(("returns %Rrc\n", rc));
2445 return rc;
2446}
2447
2448
2449/** @copydoc VBOXHDDBACKEND::pfnResize */
2450static int vdiResize(void *pBackendData, uint64_t cbSize,
2451 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
2452 unsigned uPercentStart, unsigned uPercentSpan,
2453 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
2454 PVDINTERFACE pVDIfsOperation)
2455{
2456 PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2457 int rc = VINF_SUCCESS;
2458
2459 PFNVDPROGRESS pfnProgress = NULL;
2460 void *pvUser = NULL;
2461 PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
2462 VDINTERFACETYPE_PROGRESS);
2463 PVDINTERFACEPROGRESS pCbProgress = NULL;
2464 if (pIfProgress)
2465 {
2466 pCbProgress = VDGetInterfaceProgress(pIfProgress);
2467 if (pCbProgress)
2468 pfnProgress = pCbProgress->pfnProgress;
2469 pvUser = pIfProgress->pvUser;
2470 }
2471
2472 /*
2473 * Making the image smaller is not supported at the moment.
2474 * Resizing is also not supported for fixed size images and
2475 * very old images.
2476 */
2477 /** @todo implement making the image smaller, it is the responsibility of
2478 * the user to know what he's doing. */
2479 if ( cbSize < getImageDiskSize(&pImage->Header)
2480 || GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0
2481 || pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2482 rc = VERR_NOT_SUPPORTED;
2483 else if (cbSize > getImageDiskSize(&pImage->Header))
2484 {
2485 unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header); /** < Blocks currently allocated, doesn't change during resize */
2486 uint32_t cBlocksNew = cbSize / getImageBlockSize(&pImage->Header); /** < New number of blocks in the image after the resize */
2487 if (cbSize % getImageBlockSize(&pImage->Header))
2488 cBlocksNew++;
2489
2490 uint32_t cBlocksOld = getImageBlocks(&pImage->Header); /** < Number of blocks before the resize. */
2491 uint64_t cbBlockspaceNew = cBlocksNew * sizeof(VDIIMAGEBLOCKPOINTER); /** < Required space for the block array after the resize. */
2492 uint64_t offStartDataNew = RT_ALIGN_32(pImage->offStartBlocks + cbBlockspaceNew, VDI_DATA_ALIGN); /** < New start offset for block data after the resize */
2493
2494 if ( pImage->offStartData != offStartDataNew
2495 && cBlocksAllocated > 0)
2496 {
2497 /* Calculate how many sectors need to be relocated. */
2498 uint64_t cbOverlapping = offStartDataNew - pImage->offStartData;
2499 unsigned cBlocksReloc = cbOverlapping / getImageBlockSize(&pImage->Header);
2500 if (cbOverlapping % getImageBlockSize(&pImage->Header))
2501 cBlocksReloc++;
2502
2503 /* Since only full blocks can be relocated the new data start is
2504 * determined by moving it block by block. */
2505 cBlocksReloc = RT_MIN(cBlocksReloc, cBlocksAllocated);
2506 offStartDataNew = pImage->offStartData;
2507
2508 /* Do the relocation. */
2509 LogFlow(("Relocating %u blocks\n", cBlocksReloc));
2510
2511 /*
2512 * Get the blocks we need to relocate first, they are appended to the end
2513 * of the image.
2514 */
2515 void *pvBuf = NULL, *pvZero = NULL;
2516 do
2517 {
2518 VDIIMAGEBLOCKPOINTER uBlock = 0;
2519
2520 /* Allocate data buffer. */
2521 pvBuf = RTMemAllocZ(pImage->cbTotalBlockData);
2522 if (!pvBuf)
2523 {
2524 rc = VERR_NO_MEMORY;
2525 break;
2526 }
2527
2528 /* Allocate buffer for overwriting with zeroes. */
2529 pvZero = RTMemAllocZ(pImage->cbTotalBlockData);
2530 if (!pvZero)
2531 {
2532 rc = VERR_NO_MEMORY;
2533 break;
2534 }
2535
2536 for (unsigned i = 0; i < cBlocksReloc; i++)
2537 {
2538 /* Search the index in the block table. */
2539 for (unsigned idxBlock = 0; idxBlock < cBlocksOld; idxBlock++)
2540 {
2541 if (pImage->paBlocks[idxBlock] == uBlock)
2542 {
2543 /* Read data and append to the end of the image. */
2544 rc = vdiFileReadSync(pImage, offStartDataNew, pvBuf, pImage->cbTotalBlockData, NULL);
2545 if (RT_FAILURE(rc))
2546 break;
2547
2548 uint64_t offBlockAppend;
2549 rc = vdiFileGetSize(pImage, &offBlockAppend);
2550 if (RT_FAILURE(rc))
2551 break;
2552
2553 rc = vdiFileWriteSync(pImage, offBlockAppend, pvBuf, pImage->cbTotalBlockData, NULL);
2554 if (RT_FAILURE(rc))
2555 break;
2556
2557 /* Zero out the old block area. */
2558 rc = vdiFileWriteSync(pImage, offStartDataNew, pvZero, pImage->cbTotalBlockData, NULL);
2559 if (RT_FAILURE(rc))
2560 break;
2561
2562 /* Update block counter. */
2563 pImage->paBlocks[idxBlock] = cBlocksAllocated - 1;
2564
2565 /*
2566 * Decrease the block number of all other entries in the array.
2567 * They were moved one block to the front.
2568 * Doing it as a separate step iterating over the array again
2569 * because an error while relocating the block might end up
2570 * in a corrupted image otherwise.
2571 */
2572 for (unsigned idxBlock2 = 0; idxBlock2 < cBlocksOld; idxBlock2++)
2573 {
2574 if ( idxBlock2 != idxBlock
2575 && IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[idxBlock2]))
2576 pImage->paBlocks[idxBlock2]--;
2577 }
2578
2579 /* Continue with the next block. */
2580 break;
2581 }
2582 }
2583
2584 if (RT_FAILURE(rc))
2585 break;
2586
2587 uBlock++;
2588 offStartDataNew += pImage->cbTotalBlockData;
2589 }
2590 } while (0);
2591
2592 if (pvBuf)
2593 RTMemFree(pvBuf);
2594 if (pvZero)
2595 RTMemFree(pvZero);
2596 }
2597
2598 /*
2599 * We need to update the new offsets for the image data in the out of memory
2600 * case too because we relocated the blocks already.
2601 */
2602 pImage->offStartData = offStartDataNew;
2603 setImageDataOffset(&pImage->Header, offStartDataNew);
2604
2605 /*
2606 * Relocation done, expand the block array and update the header with
2607 * the new data.
2608 */
2609 if (RT_SUCCESS(rc))
2610 {
2611 PVDIIMAGEBLOCKPOINTER paBlocksNew = (PVDIIMAGEBLOCKPOINTER)RTMemRealloc(pImage->paBlocks, cbBlockspaceNew);
2612 if (paBlocksNew)
2613 {
2614 pImage->paBlocks = paBlocksNew;
2615
2616 /* Mark the new blocks as unallocated. */
2617 for (unsigned idxBlock = cBlocksOld; idxBlock < cBlocksNew; idxBlock++)
2618 pImage->paBlocks[idxBlock] = VDI_IMAGE_BLOCK_FREE;
2619 }
2620 else
2621 rc = VERR_NO_MEMORY;
2622
2623 /* Write the block array before updating the rest. */
2624 rc = vdiFileWriteSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
2625 cbBlockspaceNew, NULL);
2626
2627 if (RT_SUCCESS(rc))
2628 {
2629 /* Update size and new block count. */
2630 setImageDiskSize(&pImage->Header, cbSize);
2631 setImageBlocks(&pImage->Header, cBlocksNew);
2632 /* Update geometry. */
2633 pImage->PCHSGeometry = *pPCHSGeometry;
2634
2635 PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
2636 if (pGeometry)
2637 {
2638 pGeometry->cCylinders = pLCHSGeometry->cCylinders;
2639 pGeometry->cHeads = pLCHSGeometry->cHeads;
2640 pGeometry->cSectors = pLCHSGeometry->cSectors;
2641 pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
2642 }
2643 }
2644 }
2645
2646 /* Update header information in base image file. */
2647 vdiFlushImage(pImage);
2648 }
2649 /* Same size doesn't change the image at all. */
2650
2651 LogFlowFunc(("returns %Rrc\n", rc));
2652 return rc;
2653}
2654
2655
2656VBOXHDDBACKEND g_VDIBackend =
2657{
2658 /* pszBackendName */
2659 "VDI",
2660 /* cbSize */
2661 sizeof(VBOXHDDBACKEND),
2662 /* uBackendCaps */
2663 VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
2664 | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS,
2665 /* paFileExtensions */
2666 s_aVdiFileExtensions,
2667 /* paConfigInfo */
2668 NULL,
2669 /* hPlugin */
2670 NIL_RTLDRMOD,
2671 /* pfnCheckIfValid */
2672 vdiCheckIfValid,
2673 /* pfnOpen */
2674 vdiOpen,
2675 /* pfnCreate */
2676 vdiCreate,
2677 /* pfnRename */
2678 vdiRename,
2679 /* pfnClose */
2680 vdiClose,
2681 /* pfnRead */
2682 vdiRead,
2683 /* pfnWrite */
2684 vdiWrite,
2685 /* pfnFlush */
2686 vdiFlush,
2687 /* pfnGetVersion */
2688 vdiGetVersion,
2689 /* pfnGetSize */
2690 vdiGetSize,
2691 /* pfnGetFileSize */
2692 vdiGetFileSize,
2693 /* pfnGetPCHSGeometry */
2694 vdiGetPCHSGeometry,
2695 /* pfnSetPCHSGeometry */
2696 vdiSetPCHSGeometry,
2697 /* pfnGetLCHSGeometry */
2698 vdiGetLCHSGeometry,
2699 /* pfnSetLCHSGeometry */
2700 vdiSetLCHSGeometry,
2701 /* pfnGetImageFlags */
2702 vdiGetImageFlags,
2703 /* pfnGetOpenFlags */
2704 vdiGetOpenFlags,
2705 /* pfnSetOpenFlags */
2706 vdiSetOpenFlags,
2707 /* pfnGetComment */
2708 vdiGetComment,
2709 /* pfnSetComment */
2710 vdiSetComment,
2711 /* pfnGetUuid */
2712 vdiGetUuid,
2713 /* pfnSetUuid */
2714 vdiSetUuid,
2715 /* pfnGetModificationUuid */
2716 vdiGetModificationUuid,
2717 /* pfnSetModificationUuid */
2718 vdiSetModificationUuid,
2719 /* pfnGetParentUuid */
2720 vdiGetParentUuid,
2721 /* pfnSetParentUuid */
2722 vdiSetParentUuid,
2723 /* pfnGetParentModificationUuid */
2724 vdiGetParentModificationUuid,
2725 /* pfnSetParentModificationUuid */
2726 vdiSetParentModificationUuid,
2727 /* pfnDump */
2728 vdiDump,
2729 /* pfnGetTimeStamp */
2730 NULL,
2731 /* pfnGetParentTimeStamp */
2732 NULL,
2733 /* pfnSetParentTimeStamp */
2734 NULL,
2735 /* pfnGetParentFilename */
2736 NULL,
2737 /* pfnSetParentFilename */
2738 NULL,
2739 /* pfnAsyncRead */
2740 vdiAsyncRead,
2741 /* pfnAsyncWrite */
2742 vdiAsyncWrite,
2743 /* pfnAsyncFlush */
2744 vdiAsyncFlush,
2745 /* pfnComposeLocation */
2746 genericFileComposeLocation,
2747 /* pfnComposeName */
2748 genericFileComposeName,
2749 /* pfnCompact */
2750 vdiCompact,
2751 /* pfnResize */
2752 vdiResize
2753};
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