VirtualBox

source: vbox/trunk/src/VBox/Storage/VMDK.cpp@ 85724

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

Storage/VMDK.cpp: Missing DECLCALLBACK on definition. bugref:9794
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 260.2 KB
Line 
1/* $Id: VMDK.cpp 85200 2020-07-10 15:16:34Z vboxsync $ */
2/** @file
3 * VMDK disk image, core code.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_VD_VMDK
23#include <VBox/vd-plugin.h>
24#include <VBox/err.h>
25
26#include <VBox/log.h>
27#include <iprt/assert.h>
28#include <iprt/alloc.h>
29#include <iprt/uuid.h>
30#include <iprt/path.h>
31#include <iprt/string.h>
32#include <iprt/rand.h>
33#include <iprt/zip.h>
34#include <iprt/asm.h>
35
36#include "VDBackends.h"
37
38
39/*********************************************************************************************************************************
40* Constants And Macros, Structures and Typedefs *
41*********************************************************************************************************************************/
42
43/** Maximum encoded string size (including NUL) we allow for VMDK images.
44 * Deliberately not set high to avoid running out of descriptor space. */
45#define VMDK_ENCODED_COMMENT_MAX 1024
46
47/** VMDK descriptor DDB entry for PCHS cylinders. */
48#define VMDK_DDB_GEO_PCHS_CYLINDERS "ddb.geometry.cylinders"
49
50/** VMDK descriptor DDB entry for PCHS heads. */
51#define VMDK_DDB_GEO_PCHS_HEADS "ddb.geometry.heads"
52
53/** VMDK descriptor DDB entry for PCHS sectors. */
54#define VMDK_DDB_GEO_PCHS_SECTORS "ddb.geometry.sectors"
55
56/** VMDK descriptor DDB entry for LCHS cylinders. */
57#define VMDK_DDB_GEO_LCHS_CYLINDERS "ddb.geometry.biosCylinders"
58
59/** VMDK descriptor DDB entry for LCHS heads. */
60#define VMDK_DDB_GEO_LCHS_HEADS "ddb.geometry.biosHeads"
61
62/** VMDK descriptor DDB entry for LCHS sectors. */
63#define VMDK_DDB_GEO_LCHS_SECTORS "ddb.geometry.biosSectors"
64
65/** VMDK descriptor DDB entry for image UUID. */
66#define VMDK_DDB_IMAGE_UUID "ddb.uuid.image"
67
68/** VMDK descriptor DDB entry for image modification UUID. */
69#define VMDK_DDB_MODIFICATION_UUID "ddb.uuid.modification"
70
71/** VMDK descriptor DDB entry for parent image UUID. */
72#define VMDK_DDB_PARENT_UUID "ddb.uuid.parent"
73
74/** VMDK descriptor DDB entry for parent image modification UUID. */
75#define VMDK_DDB_PARENT_MODIFICATION_UUID "ddb.uuid.parentmodification"
76
77/** No compression for streamOptimized files. */
78#define VMDK_COMPRESSION_NONE 0
79
80/** Deflate compression for streamOptimized files. */
81#define VMDK_COMPRESSION_DEFLATE 1
82
83/** Marker that the actual GD value is stored in the footer. */
84#define VMDK_GD_AT_END 0xffffffffffffffffULL
85
86/** Marker for end-of-stream in streamOptimized images. */
87#define VMDK_MARKER_EOS 0
88
89/** Marker for grain table block in streamOptimized images. */
90#define VMDK_MARKER_GT 1
91
92/** Marker for grain directory block in streamOptimized images. */
93#define VMDK_MARKER_GD 2
94
95/** Marker for footer in streamOptimized images. */
96#define VMDK_MARKER_FOOTER 3
97
98/** Marker for unknown purpose in streamOptimized images.
99 * Shows up in very recent images created by vSphere, but only sporadically.
100 * They "forgot" to document that one in the VMDK specification. */
101#define VMDK_MARKER_UNSPECIFIED 4
102
103/** Dummy marker for "don't check the marker value". */
104#define VMDK_MARKER_IGNORE 0xffffffffU
105
106/**
107 * Magic number for hosted images created by VMware Workstation 4, VMware
108 * Workstation 5, VMware Server or VMware Player. Not necessarily sparse.
109 */
110#define VMDK_SPARSE_MAGICNUMBER 0x564d444b /* 'V' 'M' 'D' 'K' */
111
112/**
113 * VMDK hosted binary extent header. The "Sparse" is a total misnomer, as
114 * this header is also used for monolithic flat images.
115 */
116#pragma pack(1)
117typedef struct SparseExtentHeader
118{
119 uint32_t magicNumber;
120 uint32_t version;
121 uint32_t flags;
122 uint64_t capacity;
123 uint64_t grainSize;
124 uint64_t descriptorOffset;
125 uint64_t descriptorSize;
126 uint32_t numGTEsPerGT;
127 uint64_t rgdOffset;
128 uint64_t gdOffset;
129 uint64_t overHead;
130 bool uncleanShutdown;
131 char singleEndLineChar;
132 char nonEndLineChar;
133 char doubleEndLineChar1;
134 char doubleEndLineChar2;
135 uint16_t compressAlgorithm;
136 uint8_t pad[433];
137} SparseExtentHeader;
138#pragma pack()
139
140/** The maximum allowed descriptor size in the extent header in sectors. */
141#define VMDK_SPARSE_DESCRIPTOR_SIZE_MAX UINT64_C(20480) /* 10MB */
142
143/** VMDK capacity for a single chunk when 2G splitting is turned on. Should be
144 * divisible by the default grain size (64K) */
145#define VMDK_2G_SPLIT_SIZE (2047 * 1024 * 1024)
146
147/** VMDK streamOptimized file format marker. The type field may or may not
148 * be actually valid, but there's always data to read there. */
149#pragma pack(1)
150typedef struct VMDKMARKER
151{
152 uint64_t uSector;
153 uint32_t cbSize;
154 uint32_t uType;
155} VMDKMARKER, *PVMDKMARKER;
156#pragma pack()
157
158
159/** Convert sector number/size to byte offset/size. */
160#define VMDK_SECTOR2BYTE(u) ((uint64_t)(u) << 9)
161
162/** Convert byte offset/size to sector number/size. */
163#define VMDK_BYTE2SECTOR(u) ((u) >> 9)
164
165/**
166 * VMDK extent type.
167 */
168typedef enum VMDKETYPE
169{
170 /** Hosted sparse extent. */
171 VMDKETYPE_HOSTED_SPARSE = 1,
172 /** Flat extent. */
173 VMDKETYPE_FLAT,
174 /** Zero extent. */
175 VMDKETYPE_ZERO,
176 /** VMFS extent, used by ESX. */
177 VMDKETYPE_VMFS
178} VMDKETYPE, *PVMDKETYPE;
179
180/**
181 * VMDK access type for a extent.
182 */
183typedef enum VMDKACCESS
184{
185 /** No access allowed. */
186 VMDKACCESS_NOACCESS = 0,
187 /** Read-only access. */
188 VMDKACCESS_READONLY,
189 /** Read-write access. */
190 VMDKACCESS_READWRITE
191} VMDKACCESS, *PVMDKACCESS;
192
193/** Forward declaration for PVMDKIMAGE. */
194typedef struct VMDKIMAGE *PVMDKIMAGE;
195
196/**
197 * Extents files entry. Used for opening a particular file only once.
198 */
199typedef struct VMDKFILE
200{
201 /** Pointer to file path. Local copy. */
202 const char *pszFilename;
203 /** Pointer to base name. Local copy. */
204 const char *pszBasename;
205 /** File open flags for consistency checking. */
206 unsigned fOpen;
207 /** Handle for sync/async file abstraction.*/
208 PVDIOSTORAGE pStorage;
209 /** Reference counter. */
210 unsigned uReferences;
211 /** Flag whether the file should be deleted on last close. */
212 bool fDelete;
213 /** Pointer to the image we belong to (for debugging purposes). */
214 PVMDKIMAGE pImage;
215 /** Pointer to next file descriptor. */
216 struct VMDKFILE *pNext;
217 /** Pointer to the previous file descriptor. */
218 struct VMDKFILE *pPrev;
219} VMDKFILE, *PVMDKFILE;
220
221/**
222 * VMDK extent data structure.
223 */
224typedef struct VMDKEXTENT
225{
226 /** File handle. */
227 PVMDKFILE pFile;
228 /** Base name of the image extent. */
229 const char *pszBasename;
230 /** Full name of the image extent. */
231 const char *pszFullname;
232 /** Number of sectors in this extent. */
233 uint64_t cSectors;
234 /** Number of sectors per block (grain in VMDK speak). */
235 uint64_t cSectorsPerGrain;
236 /** Starting sector number of descriptor. */
237 uint64_t uDescriptorSector;
238 /** Size of descriptor in sectors. */
239 uint64_t cDescriptorSectors;
240 /** Starting sector number of grain directory. */
241 uint64_t uSectorGD;
242 /** Starting sector number of redundant grain directory. */
243 uint64_t uSectorRGD;
244 /** Total number of metadata sectors. */
245 uint64_t cOverheadSectors;
246 /** Nominal size (i.e. as described by the descriptor) of this extent. */
247 uint64_t cNominalSectors;
248 /** Sector offset (i.e. as described by the descriptor) of this extent. */
249 uint64_t uSectorOffset;
250 /** Number of entries in a grain table. */
251 uint32_t cGTEntries;
252 /** Number of sectors reachable via a grain directory entry. */
253 uint32_t cSectorsPerGDE;
254 /** Number of entries in the grain directory. */
255 uint32_t cGDEntries;
256 /** Pointer to the next free sector. Legacy information. Do not use. */
257 uint32_t uFreeSector;
258 /** Number of this extent in the list of images. */
259 uint32_t uExtent;
260 /** Pointer to the descriptor (NULL if no descriptor in this extent). */
261 char *pDescData;
262 /** Pointer to the grain directory. */
263 uint32_t *pGD;
264 /** Pointer to the redundant grain directory. */
265 uint32_t *pRGD;
266 /** VMDK version of this extent. 1=1.0/1.1 */
267 uint32_t uVersion;
268 /** Type of this extent. */
269 VMDKETYPE enmType;
270 /** Access to this extent. */
271 VMDKACCESS enmAccess;
272 /** Flag whether this extent is marked as unclean. */
273 bool fUncleanShutdown;
274 /** Flag whether the metadata in the extent header needs to be updated. */
275 bool fMetaDirty;
276 /** Flag whether there is a footer in this extent. */
277 bool fFooter;
278 /** Compression type for this extent. */
279 uint16_t uCompression;
280 /** Append position for writing new grain. Only for sparse extents. */
281 uint64_t uAppendPosition;
282 /** Last grain which was accessed. Only for streamOptimized extents. */
283 uint32_t uLastGrainAccess;
284 /** Starting sector corresponding to the grain buffer. */
285 uint32_t uGrainSectorAbs;
286 /** Grain number corresponding to the grain buffer. */
287 uint32_t uGrain;
288 /** Actual size of the compressed data, only valid for reading. */
289 uint32_t cbGrainStreamRead;
290 /** Size of compressed grain buffer for streamOptimized extents. */
291 size_t cbCompGrain;
292 /** Compressed grain buffer for streamOptimized extents, with marker. */
293 void *pvCompGrain;
294 /** Decompressed grain buffer for streamOptimized extents. */
295 void *pvGrain;
296 /** Reference to the image in which this extent is used. Do not use this
297 * on a regular basis to avoid passing pImage references to functions
298 * explicitly. */
299 struct VMDKIMAGE *pImage;
300} VMDKEXTENT, *PVMDKEXTENT;
301
302/**
303 * Grain table cache size. Allocated per image.
304 */
305#define VMDK_GT_CACHE_SIZE 256
306
307/**
308 * Grain table block size. Smaller than an actual grain table block to allow
309 * more grain table blocks to be cached without having to allocate excessive
310 * amounts of memory for the cache.
311 */
312#define VMDK_GT_CACHELINE_SIZE 128
313
314
315/**
316 * Maximum number of lines in a descriptor file. Not worth the effort of
317 * making it variable. Descriptor files are generally very short (~20 lines),
318 * with the exception of sparse files split in 2G chunks, which need for the
319 * maximum size (almost 2T) exactly 1025 lines for the disk database.
320 */
321#define VMDK_DESCRIPTOR_LINES_MAX 1100U
322
323/**
324 * Parsed descriptor information. Allows easy access and update of the
325 * descriptor (whether separate file or not). Free form text files suck.
326 */
327typedef struct VMDKDESCRIPTOR
328{
329 /** Line number of first entry of the disk descriptor. */
330 unsigned uFirstDesc;
331 /** Line number of first entry in the extent description. */
332 unsigned uFirstExtent;
333 /** Line number of first disk database entry. */
334 unsigned uFirstDDB;
335 /** Total number of lines. */
336 unsigned cLines;
337 /** Total amount of memory available for the descriptor. */
338 size_t cbDescAlloc;
339 /** Set if descriptor has been changed and not yet written to disk. */
340 bool fDirty;
341 /** Array of pointers to the data in the descriptor. */
342 char *aLines[VMDK_DESCRIPTOR_LINES_MAX];
343 /** Array of line indices pointing to the next non-comment line. */
344 unsigned aNextLines[VMDK_DESCRIPTOR_LINES_MAX];
345} VMDKDESCRIPTOR, *PVMDKDESCRIPTOR;
346
347
348/**
349 * Cache entry for translating extent/sector to a sector number in that
350 * extent.
351 */
352typedef struct VMDKGTCACHEENTRY
353{
354 /** Extent number for which this entry is valid. */
355 uint32_t uExtent;
356 /** GT data block number. */
357 uint64_t uGTBlock;
358 /** Data part of the cache entry. */
359 uint32_t aGTData[VMDK_GT_CACHELINE_SIZE];
360} VMDKGTCACHEENTRY, *PVMDKGTCACHEENTRY;
361
362/**
363 * Cache data structure for blocks of grain table entries. For now this is a
364 * fixed size direct mapping cache, but this should be adapted to the size of
365 * the sparse image and maybe converted to a set-associative cache. The
366 * implementation below implements a write-through cache with write allocate.
367 */
368typedef struct VMDKGTCACHE
369{
370 /** Cache entries. */
371 VMDKGTCACHEENTRY aGTCache[VMDK_GT_CACHE_SIZE];
372 /** Number of cache entries (currently unused). */
373 unsigned cEntries;
374} VMDKGTCACHE, *PVMDKGTCACHE;
375
376/**
377 * Complete VMDK image data structure. Mainly a collection of extents and a few
378 * extra global data fields.
379 */
380typedef struct VMDKIMAGE
381{
382 /** Image name. */
383 const char *pszFilename;
384 /** Descriptor file if applicable. */
385 PVMDKFILE pFile;
386
387 /** Pointer to the per-disk VD interface list. */
388 PVDINTERFACE pVDIfsDisk;
389 /** Pointer to the per-image VD interface list. */
390 PVDINTERFACE pVDIfsImage;
391
392 /** Error interface. */
393 PVDINTERFACEERROR pIfError;
394 /** I/O interface. */
395 PVDINTERFACEIOINT pIfIo;
396
397
398 /** Pointer to the image extents. */
399 PVMDKEXTENT pExtents;
400 /** Number of image extents. */
401 unsigned cExtents;
402 /** Pointer to the files list, for opening a file referenced multiple
403 * times only once (happens mainly with raw partition access). */
404 PVMDKFILE pFiles;
405
406 /**
407 * Pointer to an array of segment entries for async I/O.
408 * This is an optimization because the task number to submit is not known
409 * and allocating/freeing an array in the read/write functions every time
410 * is too expensive.
411 */
412 PPDMDATASEG paSegments;
413 /** Entries available in the segments array. */
414 unsigned cSegments;
415
416 /** Open flags passed by VBoxHD layer. */
417 unsigned uOpenFlags;
418 /** Image flags defined during creation or determined during open. */
419 unsigned uImageFlags;
420 /** Total size of the image. */
421 uint64_t cbSize;
422 /** Physical geometry of this image. */
423 VDGEOMETRY PCHSGeometry;
424 /** Logical geometry of this image. */
425 VDGEOMETRY LCHSGeometry;
426 /** Image UUID. */
427 RTUUID ImageUuid;
428 /** Image modification UUID. */
429 RTUUID ModificationUuid;
430 /** Parent image UUID. */
431 RTUUID ParentUuid;
432 /** Parent image modification UUID. */
433 RTUUID ParentModificationUuid;
434
435 /** Pointer to grain table cache, if this image contains sparse extents. */
436 PVMDKGTCACHE pGTCache;
437 /** Pointer to the descriptor (NULL if no separate descriptor file). */
438 char *pDescData;
439 /** Allocation size of the descriptor file. */
440 size_t cbDescAlloc;
441 /** Parsed descriptor file content. */
442 VMDKDESCRIPTOR Descriptor;
443 /** The static region list. */
444 VDREGIONLIST RegionList;
445} VMDKIMAGE;
446
447
448/** State for the input/output callout of the inflate reader/deflate writer. */
449typedef struct VMDKCOMPRESSIO
450{
451 /* Image this operation relates to. */
452 PVMDKIMAGE pImage;
453 /* Current read position. */
454 ssize_t iOffset;
455 /* Size of the compressed grain buffer (available data). */
456 size_t cbCompGrain;
457 /* Pointer to the compressed grain buffer. */
458 void *pvCompGrain;
459} VMDKCOMPRESSIO;
460
461
462/** Tracks async grain allocation. */
463typedef struct VMDKGRAINALLOCASYNC
464{
465 /** Flag whether the allocation failed. */
466 bool fIoErr;
467 /** Current number of transfers pending.
468 * If reached 0 and there is an error the old state is restored. */
469 unsigned cIoXfersPending;
470 /** Sector number */
471 uint64_t uSector;
472 /** Flag whether the grain table needs to be updated. */
473 bool fGTUpdateNeeded;
474 /** Extent the allocation happens. */
475 PVMDKEXTENT pExtent;
476 /** Position of the new grain, required for the grain table update. */
477 uint64_t uGrainOffset;
478 /** Grain table sector. */
479 uint64_t uGTSector;
480 /** Backup grain table sector. */
481 uint64_t uRGTSector;
482} VMDKGRAINALLOCASYNC, *PVMDKGRAINALLOCASYNC;
483
484/**
485 * State information for vmdkRename() and helpers.
486 */
487typedef struct VMDKRENAMESTATE
488{
489 /** Array of old filenames. */
490 char **apszOldName;
491 /** Array of new filenames. */
492 char **apszNewName;
493 /** Array of new lines in the extent descriptor. */
494 char **apszNewLines;
495 /** Name of the old descriptor file if not a sparse image. */
496 char *pszOldDescName;
497 /** Flag whether we called vmdkFreeImage(). */
498 bool fImageFreed;
499 /** Flag whther the descriptor is embedded in the image (sparse) or
500 * in a separate file. */
501 bool fEmbeddedDesc;
502 /** Number of extents in the image. */
503 unsigned cExtents;
504 /** New base filename. */
505 char *pszNewBaseName;
506 /** The old base filename. */
507 char *pszOldBaseName;
508 /** New full filename. */
509 char *pszNewFullName;
510 /** Old full filename. */
511 char *pszOldFullName;
512 /** The old image name. */
513 const char *pszOldImageName;
514 /** Copy of the original VMDK descriptor. */
515 VMDKDESCRIPTOR DescriptorCopy;
516 /** Copy of the extent state for sparse images. */
517 VMDKEXTENT ExtentCopy;
518} VMDKRENAMESTATE;
519/** Pointer to a VMDK rename state. */
520typedef VMDKRENAMESTATE *PVMDKRENAMESTATE;
521
522
523/*********************************************************************************************************************************
524* Static Variables *
525*********************************************************************************************************************************/
526
527/** NULL-terminated array of supported file extensions. */
528static const VDFILEEXTENSION s_aVmdkFileExtensions[] =
529{
530 {"vmdk", VDTYPE_HDD},
531 {NULL, VDTYPE_INVALID}
532};
533
534
535/*********************************************************************************************************************************
536* Internal Functions *
537*********************************************************************************************************************************/
538
539static void vmdkFreeStreamBuffers(PVMDKEXTENT pExtent);
540static int vmdkFreeExtentData(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
541 bool fDelete);
542
543static int vmdkCreateExtents(PVMDKIMAGE pImage, unsigned cExtents);
544static int vmdkFlushImage(PVMDKIMAGE pImage, PVDIOCTX pIoCtx);
545static int vmdkSetImageComment(PVMDKIMAGE pImage, const char *pszComment);
546static int vmdkFreeImage(PVMDKIMAGE pImage, bool fDelete, bool fFlush);
547
548static DECLCALLBACK(int) vmdkAllocGrainComplete(void *pBackendData, PVDIOCTX pIoCtx,
549 void *pvUser, int rcReq);
550
551/**
552 * Internal: open a file (using a file descriptor cache to ensure each file
553 * is only opened once - anything else can cause locking problems).
554 */
555static int vmdkFileOpen(PVMDKIMAGE pImage, PVMDKFILE *ppVmdkFile,
556 const char *pszBasename, const char *pszFilename, uint32_t fOpen)
557{
558 int rc = VINF_SUCCESS;
559 PVMDKFILE pVmdkFile;
560
561 for (pVmdkFile = pImage->pFiles;
562 pVmdkFile != NULL;
563 pVmdkFile = pVmdkFile->pNext)
564 {
565 if (!strcmp(pszFilename, pVmdkFile->pszFilename))
566 {
567 Assert(fOpen == pVmdkFile->fOpen);
568 pVmdkFile->uReferences++;
569
570 *ppVmdkFile = pVmdkFile;
571
572 return rc;
573 }
574 }
575
576 /* If we get here, there's no matching entry in the cache. */
577 pVmdkFile = (PVMDKFILE)RTMemAllocZ(sizeof(VMDKFILE));
578 if (!pVmdkFile)
579 {
580 *ppVmdkFile = NULL;
581 return VERR_NO_MEMORY;
582 }
583
584 pVmdkFile->pszFilename = RTStrDup(pszFilename);
585 if (!pVmdkFile->pszFilename)
586 {
587 RTMemFree(pVmdkFile);
588 *ppVmdkFile = NULL;
589 return VERR_NO_MEMORY;
590 }
591
592 if (pszBasename)
593 {
594 pVmdkFile->pszBasename = RTStrDup(pszBasename);
595 if (!pVmdkFile->pszBasename)
596 {
597 RTStrFree((char *)(void *)pVmdkFile->pszFilename);
598 RTMemFree(pVmdkFile);
599 *ppVmdkFile = NULL;
600 return VERR_NO_MEMORY;
601 }
602 }
603
604 pVmdkFile->fOpen = fOpen;
605
606 rc = vdIfIoIntFileOpen(pImage->pIfIo, pszFilename, fOpen,
607 &pVmdkFile->pStorage);
608 if (RT_SUCCESS(rc))
609 {
610 pVmdkFile->uReferences = 1;
611 pVmdkFile->pImage = pImage;
612 pVmdkFile->pNext = pImage->pFiles;
613 if (pImage->pFiles)
614 pImage->pFiles->pPrev = pVmdkFile;
615 pImage->pFiles = pVmdkFile;
616 *ppVmdkFile = pVmdkFile;
617 }
618 else
619 {
620 RTStrFree((char *)(void *)pVmdkFile->pszFilename);
621 RTMemFree(pVmdkFile);
622 *ppVmdkFile = NULL;
623 }
624
625 return rc;
626}
627
628/**
629 * Internal: close a file, updating the file descriptor cache.
630 */
631static int vmdkFileClose(PVMDKIMAGE pImage, PVMDKFILE *ppVmdkFile, bool fDelete)
632{
633 int rc = VINF_SUCCESS;
634 PVMDKFILE pVmdkFile = *ppVmdkFile;
635
636 AssertPtr(pVmdkFile);
637
638 pVmdkFile->fDelete |= fDelete;
639 Assert(pVmdkFile->uReferences);
640 pVmdkFile->uReferences--;
641 if (pVmdkFile->uReferences == 0)
642 {
643 PVMDKFILE pPrev;
644 PVMDKFILE pNext;
645
646 /* Unchain the element from the list. */
647 pPrev = pVmdkFile->pPrev;
648 pNext = pVmdkFile->pNext;
649
650 if (pNext)
651 pNext->pPrev = pPrev;
652 if (pPrev)
653 pPrev->pNext = pNext;
654 else
655 pImage->pFiles = pNext;
656
657 rc = vdIfIoIntFileClose(pImage->pIfIo, pVmdkFile->pStorage);
658
659 bool fFileDel = pVmdkFile->fDelete;
660 if ( pVmdkFile->pszBasename
661 && fFileDel)
662 {
663 const char *pszSuffix = RTPathSuffix(pVmdkFile->pszBasename);
664 if ( RTPathHasPath(pVmdkFile->pszBasename)
665 || !pszSuffix
666 || ( strcmp(pszSuffix, ".vmdk")
667 && strcmp(pszSuffix, ".bin")
668 && strcmp(pszSuffix, ".img")))
669 fFileDel = false;
670 }
671
672 if (fFileDel)
673 {
674 int rc2 = vdIfIoIntFileDelete(pImage->pIfIo, pVmdkFile->pszFilename);
675 if (RT_SUCCESS(rc))
676 rc = rc2;
677 }
678 else if (pVmdkFile->fDelete)
679 LogRel(("VMDK: Denying deletion of %s\n", pVmdkFile->pszBasename));
680 RTStrFree((char *)(void *)pVmdkFile->pszFilename);
681 if (pVmdkFile->pszBasename)
682 RTStrFree((char *)(void *)pVmdkFile->pszBasename);
683 RTMemFree(pVmdkFile);
684 }
685
686 *ppVmdkFile = NULL;
687 return rc;
688}
689
690/*#define VMDK_USE_BLOCK_DECOMP_API - test and enable */
691#ifndef VMDK_USE_BLOCK_DECOMP_API
692static DECLCALLBACK(int) vmdkFileInflateHelper(void *pvUser, void *pvBuf, size_t cbBuf, size_t *pcbBuf)
693{
694 VMDKCOMPRESSIO *pInflateState = (VMDKCOMPRESSIO *)pvUser;
695 size_t cbInjected = 0;
696
697 Assert(cbBuf);
698 if (pInflateState->iOffset < 0)
699 {
700 *(uint8_t *)pvBuf = RTZIPTYPE_ZLIB;
701 pvBuf = (uint8_t *)pvBuf + 1;
702 cbBuf--;
703 cbInjected = 1;
704 pInflateState->iOffset = RT_UOFFSETOF(VMDKMARKER, uType);
705 }
706 if (!cbBuf)
707 {
708 if (pcbBuf)
709 *pcbBuf = cbInjected;
710 return VINF_SUCCESS;
711 }
712 cbBuf = RT_MIN(cbBuf, pInflateState->cbCompGrain - pInflateState->iOffset);
713 memcpy(pvBuf,
714 (uint8_t *)pInflateState->pvCompGrain + pInflateState->iOffset,
715 cbBuf);
716 pInflateState->iOffset += cbBuf;
717 Assert(pcbBuf);
718 *pcbBuf = cbBuf + cbInjected;
719 return VINF_SUCCESS;
720}
721#endif
722
723/**
724 * Internal: read from a file and inflate the compressed data,
725 * distinguishing between async and normal operation
726 */
727DECLINLINE(int) vmdkFileInflateSync(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
728 uint64_t uOffset, void *pvBuf,
729 size_t cbToRead, const void *pcvMarker,
730 uint64_t *puLBA, uint32_t *pcbMarkerData)
731{
732 int rc;
733#ifndef VMDK_USE_BLOCK_DECOMP_API
734 PRTZIPDECOMP pZip = NULL;
735#endif
736 VMDKMARKER *pMarker = (VMDKMARKER *)pExtent->pvCompGrain;
737 size_t cbCompSize, cbActuallyRead;
738
739 if (!pcvMarker)
740 {
741 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
742 uOffset, pMarker, RT_UOFFSETOF(VMDKMARKER, uType));
743 if (RT_FAILURE(rc))
744 return rc;
745 }
746 else
747 {
748 memcpy(pMarker, pcvMarker, RT_UOFFSETOF(VMDKMARKER, uType));
749 /* pcvMarker endianness has already been partially transformed, fix it */
750 pMarker->uSector = RT_H2LE_U64(pMarker->uSector);
751 pMarker->cbSize = RT_H2LE_U32(pMarker->cbSize);
752 }
753
754 cbCompSize = RT_LE2H_U32(pMarker->cbSize);
755 if (cbCompSize == 0)
756 {
757 AssertMsgFailed(("VMDK: corrupted marker\n"));
758 return VERR_VD_VMDK_INVALID_FORMAT;
759 }
760
761 /* Sanity check - the expansion ratio should be much less than 2. */
762 Assert(cbCompSize < 2 * cbToRead);
763 if (cbCompSize >= 2 * cbToRead)
764 return VERR_VD_VMDK_INVALID_FORMAT;
765
766 /* Compressed grain marker. Data follows immediately. */
767 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
768 uOffset + RT_UOFFSETOF(VMDKMARKER, uType),
769 (uint8_t *)pExtent->pvCompGrain
770 + RT_UOFFSETOF(VMDKMARKER, uType),
771 RT_ALIGN_Z( cbCompSize
772 + RT_UOFFSETOF(VMDKMARKER, uType),
773 512)
774 - RT_UOFFSETOF(VMDKMARKER, uType));
775
776 if (puLBA)
777 *puLBA = RT_LE2H_U64(pMarker->uSector);
778 if (pcbMarkerData)
779 *pcbMarkerData = RT_ALIGN( cbCompSize
780 + RT_UOFFSETOF(VMDKMARKER, uType),
781 512);
782
783#ifdef VMDK_USE_BLOCK_DECOMP_API
784 rc = RTZipBlockDecompress(RTZIPTYPE_ZLIB, 0 /*fFlags*/,
785 pExtent->pvCompGrain, cbCompSize + RT_UOFFSETOF(VMDKMARKER, uType), NULL,
786 pvBuf, cbToRead, &cbActuallyRead);
787#else
788 VMDKCOMPRESSIO InflateState;
789 InflateState.pImage = pImage;
790 InflateState.iOffset = -1;
791 InflateState.cbCompGrain = cbCompSize + RT_UOFFSETOF(VMDKMARKER, uType);
792 InflateState.pvCompGrain = pExtent->pvCompGrain;
793
794 rc = RTZipDecompCreate(&pZip, &InflateState, vmdkFileInflateHelper);
795 if (RT_FAILURE(rc))
796 return rc;
797 rc = RTZipDecompress(pZip, pvBuf, cbToRead, &cbActuallyRead);
798 RTZipDecompDestroy(pZip);
799#endif /* !VMDK_USE_BLOCK_DECOMP_API */
800 if (RT_FAILURE(rc))
801 {
802 if (rc == VERR_ZIP_CORRUPTED)
803 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: Compressed image is corrupted '%s'"), pExtent->pszFullname);
804 return rc;
805 }
806 if (cbActuallyRead != cbToRead)
807 rc = VERR_VD_VMDK_INVALID_FORMAT;
808 return rc;
809}
810
811static DECLCALLBACK(int) vmdkFileDeflateHelper(void *pvUser, const void *pvBuf, size_t cbBuf)
812{
813 VMDKCOMPRESSIO *pDeflateState = (VMDKCOMPRESSIO *)pvUser;
814
815 Assert(cbBuf);
816 if (pDeflateState->iOffset < 0)
817 {
818 pvBuf = (const uint8_t *)pvBuf + 1;
819 cbBuf--;
820 pDeflateState->iOffset = RT_UOFFSETOF(VMDKMARKER, uType);
821 }
822 if (!cbBuf)
823 return VINF_SUCCESS;
824 if (pDeflateState->iOffset + cbBuf > pDeflateState->cbCompGrain)
825 return VERR_BUFFER_OVERFLOW;
826 memcpy((uint8_t *)pDeflateState->pvCompGrain + pDeflateState->iOffset,
827 pvBuf, cbBuf);
828 pDeflateState->iOffset += cbBuf;
829 return VINF_SUCCESS;
830}
831
832/**
833 * Internal: deflate the uncompressed data and write to a file,
834 * distinguishing between async and normal operation
835 */
836DECLINLINE(int) vmdkFileDeflateSync(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
837 uint64_t uOffset, const void *pvBuf,
838 size_t cbToWrite, uint64_t uLBA,
839 uint32_t *pcbMarkerData)
840{
841 int rc;
842 PRTZIPCOMP pZip = NULL;
843 VMDKCOMPRESSIO DeflateState;
844
845 DeflateState.pImage = pImage;
846 DeflateState.iOffset = -1;
847 DeflateState.cbCompGrain = pExtent->cbCompGrain;
848 DeflateState.pvCompGrain = pExtent->pvCompGrain;
849
850 rc = RTZipCompCreate(&pZip, &DeflateState, vmdkFileDeflateHelper,
851 RTZIPTYPE_ZLIB, RTZIPLEVEL_DEFAULT);
852 if (RT_FAILURE(rc))
853 return rc;
854 rc = RTZipCompress(pZip, pvBuf, cbToWrite);
855 if (RT_SUCCESS(rc))
856 rc = RTZipCompFinish(pZip);
857 RTZipCompDestroy(pZip);
858 if (RT_SUCCESS(rc))
859 {
860 Assert( DeflateState.iOffset > 0
861 && (size_t)DeflateState.iOffset <= DeflateState.cbCompGrain);
862
863 /* pad with zeroes to get to a full sector size */
864 uint32_t uSize = DeflateState.iOffset;
865 if (uSize % 512)
866 {
867 uint32_t uSizeAlign = RT_ALIGN(uSize, 512);
868 memset((uint8_t *)pExtent->pvCompGrain + uSize, '\0',
869 uSizeAlign - uSize);
870 uSize = uSizeAlign;
871 }
872
873 if (pcbMarkerData)
874 *pcbMarkerData = uSize;
875
876 /* Compressed grain marker. Data follows immediately. */
877 VMDKMARKER *pMarker = (VMDKMARKER *)pExtent->pvCompGrain;
878 pMarker->uSector = RT_H2LE_U64(uLBA);
879 pMarker->cbSize = RT_H2LE_U32( DeflateState.iOffset
880 - RT_UOFFSETOF(VMDKMARKER, uType));
881 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
882 uOffset, pMarker, uSize);
883 if (RT_FAILURE(rc))
884 return rc;
885 }
886 return rc;
887}
888
889
890/**
891 * Internal: check if all files are closed, prevent leaking resources.
892 */
893static int vmdkFileCheckAllClose(PVMDKIMAGE pImage)
894{
895 int rc = VINF_SUCCESS, rc2;
896 PVMDKFILE pVmdkFile;
897
898 Assert(pImage->pFiles == NULL);
899 for (pVmdkFile = pImage->pFiles;
900 pVmdkFile != NULL;
901 pVmdkFile = pVmdkFile->pNext)
902 {
903 LogRel(("VMDK: leaking reference to file \"%s\"\n",
904 pVmdkFile->pszFilename));
905 pImage->pFiles = pVmdkFile->pNext;
906
907 rc2 = vmdkFileClose(pImage, &pVmdkFile, pVmdkFile->fDelete);
908
909 if (RT_SUCCESS(rc))
910 rc = rc2;
911 }
912 return rc;
913}
914
915/**
916 * Internal: truncate a string (at a UTF8 code point boundary) and encode the
917 * critical non-ASCII characters.
918 */
919static char *vmdkEncodeString(const char *psz)
920{
921 char szEnc[VMDK_ENCODED_COMMENT_MAX + 3];
922 char *pszDst = szEnc;
923
924 AssertPtr(psz);
925
926 for (; *psz; psz = RTStrNextCp(psz))
927 {
928 char *pszDstPrev = pszDst;
929 RTUNICP Cp = RTStrGetCp(psz);
930 if (Cp == '\\')
931 {
932 pszDst = RTStrPutCp(pszDst, Cp);
933 pszDst = RTStrPutCp(pszDst, Cp);
934 }
935 else if (Cp == '\n')
936 {
937 pszDst = RTStrPutCp(pszDst, '\\');
938 pszDst = RTStrPutCp(pszDst, 'n');
939 }
940 else if (Cp == '\r')
941 {
942 pszDst = RTStrPutCp(pszDst, '\\');
943 pszDst = RTStrPutCp(pszDst, 'r');
944 }
945 else
946 pszDst = RTStrPutCp(pszDst, Cp);
947 if (pszDst - szEnc >= VMDK_ENCODED_COMMENT_MAX - 1)
948 {
949 pszDst = pszDstPrev;
950 break;
951 }
952 }
953 *pszDst = '\0';
954 return RTStrDup(szEnc);
955}
956
957/**
958 * Internal: decode a string and store it into the specified string.
959 */
960static int vmdkDecodeString(const char *pszEncoded, char *psz, size_t cb)
961{
962 int rc = VINF_SUCCESS;
963 char szBuf[4];
964
965 if (!cb)
966 return VERR_BUFFER_OVERFLOW;
967
968 AssertPtr(psz);
969
970 for (; *pszEncoded; pszEncoded = RTStrNextCp(pszEncoded))
971 {
972 char *pszDst = szBuf;
973 RTUNICP Cp = RTStrGetCp(pszEncoded);
974 if (Cp == '\\')
975 {
976 pszEncoded = RTStrNextCp(pszEncoded);
977 RTUNICP CpQ = RTStrGetCp(pszEncoded);
978 if (CpQ == 'n')
979 RTStrPutCp(pszDst, '\n');
980 else if (CpQ == 'r')
981 RTStrPutCp(pszDst, '\r');
982 else if (CpQ == '\0')
983 {
984 rc = VERR_VD_VMDK_INVALID_HEADER;
985 break;
986 }
987 else
988 RTStrPutCp(pszDst, CpQ);
989 }
990 else
991 pszDst = RTStrPutCp(pszDst, Cp);
992
993 /* Need to leave space for terminating NUL. */
994 if ((size_t)(pszDst - szBuf) + 1 >= cb)
995 {
996 rc = VERR_BUFFER_OVERFLOW;
997 break;
998 }
999 memcpy(psz, szBuf, pszDst - szBuf);
1000 psz += pszDst - szBuf;
1001 }
1002 *psz = '\0';
1003 return rc;
1004}
1005
1006/**
1007 * Internal: free all buffers associated with grain directories.
1008 */
1009static void vmdkFreeGrainDirectory(PVMDKEXTENT pExtent)
1010{
1011 if (pExtent->pGD)
1012 {
1013 RTMemFree(pExtent->pGD);
1014 pExtent->pGD = NULL;
1015 }
1016 if (pExtent->pRGD)
1017 {
1018 RTMemFree(pExtent->pRGD);
1019 pExtent->pRGD = NULL;
1020 }
1021}
1022
1023/**
1024 * Internal: allocate the compressed/uncompressed buffers for streamOptimized
1025 * images.
1026 */
1027static int vmdkAllocStreamBuffers(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
1028{
1029 int rc = VINF_SUCCESS;
1030
1031 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
1032 {
1033 /* streamOptimized extents need a compressed grain buffer, which must
1034 * be big enough to hold uncompressible data (which needs ~8 bytes
1035 * more than the uncompressed data), the marker and padding. */
1036 pExtent->cbCompGrain = RT_ALIGN_Z( VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain)
1037 + 8 + sizeof(VMDKMARKER), 512);
1038 pExtent->pvCompGrain = RTMemAlloc(pExtent->cbCompGrain);
1039 if (RT_LIKELY(pExtent->pvCompGrain))
1040 {
1041 /* streamOptimized extents need a decompressed grain buffer. */
1042 pExtent->pvGrain = RTMemAlloc(VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
1043 if (!pExtent->pvGrain)
1044 rc = VERR_NO_MEMORY;
1045 }
1046 else
1047 rc = VERR_NO_MEMORY;
1048 }
1049
1050 if (RT_FAILURE(rc))
1051 vmdkFreeStreamBuffers(pExtent);
1052 return rc;
1053}
1054
1055/**
1056 * Internal: allocate all buffers associated with grain directories.
1057 */
1058static int vmdkAllocGrainDirectory(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
1059{
1060 RT_NOREF1(pImage);
1061 int rc = VINF_SUCCESS;
1062 size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
1063
1064 pExtent->pGD = (uint32_t *)RTMemAllocZ(cbGD);
1065 if (RT_LIKELY(pExtent->pGD))
1066 {
1067 if (pExtent->uSectorRGD)
1068 {
1069 pExtent->pRGD = (uint32_t *)RTMemAllocZ(cbGD);
1070 if (RT_UNLIKELY(!pExtent->pRGD))
1071 rc = VERR_NO_MEMORY;
1072 }
1073 }
1074 else
1075 rc = VERR_NO_MEMORY;
1076
1077 if (RT_FAILURE(rc))
1078 vmdkFreeGrainDirectory(pExtent);
1079 return rc;
1080}
1081
1082/**
1083 * Converts the grain directory from little to host endianess.
1084 *
1085 * @returns nothing.
1086 * @param pGD The grain directory.
1087 * @param cGDEntries Number of entries in the grain directory to convert.
1088 */
1089DECLINLINE(void) vmdkGrainDirectoryConvToHost(uint32_t *pGD, uint32_t cGDEntries)
1090{
1091 uint32_t *pGDTmp = pGD;
1092
1093 for (uint32_t i = 0; i < cGDEntries; i++, pGDTmp++)
1094 *pGDTmp = RT_LE2H_U32(*pGDTmp);
1095}
1096
1097/**
1098 * Read the grain directory and allocated grain tables verifying them against
1099 * their back up copies if available.
1100 *
1101 * @returns VBox status code.
1102 * @param pImage Image instance data.
1103 * @param pExtent The VMDK extent.
1104 */
1105static int vmdkReadGrainDirectory(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
1106{
1107 int rc = VINF_SUCCESS;
1108 size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
1109
1110 AssertReturn(( pExtent->enmType == VMDKETYPE_HOSTED_SPARSE
1111 && pExtent->uSectorGD != VMDK_GD_AT_END
1112 && pExtent->uSectorRGD != VMDK_GD_AT_END), VERR_INTERNAL_ERROR);
1113
1114 rc = vmdkAllocGrainDirectory(pImage, pExtent);
1115 if (RT_SUCCESS(rc))
1116 {
1117 /* The VMDK 1.1 spec seems to talk about compressed grain directories,
1118 * but in reality they are not compressed. */
1119 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
1120 VMDK_SECTOR2BYTE(pExtent->uSectorGD),
1121 pExtent->pGD, cbGD);
1122 if (RT_SUCCESS(rc))
1123 {
1124 vmdkGrainDirectoryConvToHost(pExtent->pGD, pExtent->cGDEntries);
1125
1126 if ( pExtent->uSectorRGD
1127 && !(pImage->uOpenFlags & VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS))
1128 {
1129 /* The VMDK 1.1 spec seems to talk about compressed grain directories,
1130 * but in reality they are not compressed. */
1131 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
1132 VMDK_SECTOR2BYTE(pExtent->uSectorRGD),
1133 pExtent->pRGD, cbGD);
1134 if (RT_SUCCESS(rc))
1135 {
1136 vmdkGrainDirectoryConvToHost(pExtent->pRGD, pExtent->cGDEntries);
1137
1138 /* Check grain table and redundant grain table for consistency. */
1139 size_t cbGT = pExtent->cGTEntries * sizeof(uint32_t);
1140 size_t cbGTBuffers = cbGT; /* Start with space for one GT. */
1141 size_t cbGTBuffersMax = _1M;
1142
1143 uint32_t *pTmpGT1 = (uint32_t *)RTMemAlloc(cbGTBuffers);
1144 uint32_t *pTmpGT2 = (uint32_t *)RTMemAlloc(cbGTBuffers);
1145
1146 if ( !pTmpGT1
1147 || !pTmpGT2)
1148 rc = VERR_NO_MEMORY;
1149
1150 size_t i = 0;
1151 uint32_t *pGDTmp = pExtent->pGD;
1152 uint32_t *pRGDTmp = pExtent->pRGD;
1153
1154 /* Loop through all entries. */
1155 while (i < pExtent->cGDEntries)
1156 {
1157 uint32_t uGTStart = *pGDTmp;
1158 uint32_t uRGTStart = *pRGDTmp;
1159 size_t cbGTRead = cbGT;
1160
1161 /* If no grain table is allocated skip the entry. */
1162 if (*pGDTmp == 0 && *pRGDTmp == 0)
1163 {
1164 i++;
1165 continue;
1166 }
1167
1168 if (*pGDTmp == 0 || *pRGDTmp == 0 || *pGDTmp == *pRGDTmp)
1169 {
1170 /* Just one grain directory entry refers to a not yet allocated
1171 * grain table or both grain directory copies refer to the same
1172 * grain table. Not allowed. */
1173 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
1174 N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
1175 break;
1176 }
1177
1178 i++;
1179 pGDTmp++;
1180 pRGDTmp++;
1181
1182 /*
1183 * Read a few tables at once if adjacent to decrease the number
1184 * of I/O requests. Read at maximum 1MB at once.
1185 */
1186 while ( i < pExtent->cGDEntries
1187 && cbGTRead < cbGTBuffersMax)
1188 {
1189 /* If no grain table is allocated skip the entry. */
1190 if (*pGDTmp == 0 && *pRGDTmp == 0)
1191 {
1192 i++;
1193 continue;
1194 }
1195
1196 if (*pGDTmp == 0 || *pRGDTmp == 0 || *pGDTmp == *pRGDTmp)
1197 {
1198 /* Just one grain directory entry refers to a not yet allocated
1199 * grain table or both grain directory copies refer to the same
1200 * grain table. Not allowed. */
1201 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
1202 N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
1203 break;
1204 }
1205
1206 /* Check that the start offsets are adjacent.*/
1207 if ( VMDK_SECTOR2BYTE(uGTStart) + cbGTRead != VMDK_SECTOR2BYTE(*pGDTmp)
1208 || VMDK_SECTOR2BYTE(uRGTStart) + cbGTRead != VMDK_SECTOR2BYTE(*pRGDTmp))
1209 break;
1210
1211 i++;
1212 pGDTmp++;
1213 pRGDTmp++;
1214 cbGTRead += cbGT;
1215 }
1216
1217 /* Increase buffers if required. */
1218 if ( RT_SUCCESS(rc)
1219 && cbGTBuffers < cbGTRead)
1220 {
1221 uint32_t *pTmp;
1222 pTmp = (uint32_t *)RTMemRealloc(pTmpGT1, cbGTRead);
1223 if (pTmp)
1224 {
1225 pTmpGT1 = pTmp;
1226 pTmp = (uint32_t *)RTMemRealloc(pTmpGT2, cbGTRead);
1227 if (pTmp)
1228 pTmpGT2 = pTmp;
1229 else
1230 rc = VERR_NO_MEMORY;
1231 }
1232 else
1233 rc = VERR_NO_MEMORY;
1234
1235 if (rc == VERR_NO_MEMORY)
1236 {
1237 /* Reset to the old values. */
1238 rc = VINF_SUCCESS;
1239 i -= cbGTRead / cbGT;
1240 cbGTRead = cbGT;
1241
1242 /* Don't try to increase the buffer again in the next run. */
1243 cbGTBuffersMax = cbGTBuffers;
1244 }
1245 }
1246
1247 if (RT_SUCCESS(rc))
1248 {
1249 /* The VMDK 1.1 spec seems to talk about compressed grain tables,
1250 * but in reality they are not compressed. */
1251 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
1252 VMDK_SECTOR2BYTE(uGTStart),
1253 pTmpGT1, cbGTRead);
1254 if (RT_FAILURE(rc))
1255 {
1256 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
1257 N_("VMDK: error reading grain table in '%s'"), pExtent->pszFullname);
1258 break;
1259 }
1260 /* The VMDK 1.1 spec seems to talk about compressed grain tables,
1261 * but in reality they are not compressed. */
1262 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
1263 VMDK_SECTOR2BYTE(uRGTStart),
1264 pTmpGT2, cbGTRead);
1265 if (RT_FAILURE(rc))
1266 {
1267 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
1268 N_("VMDK: error reading backup grain table in '%s'"), pExtent->pszFullname);
1269 break;
1270 }
1271 if (memcmp(pTmpGT1, pTmpGT2, cbGTRead))
1272 {
1273 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
1274 N_("VMDK: inconsistency between grain table and backup grain table in '%s'"), pExtent->pszFullname);
1275 break;
1276 }
1277 }
1278 } /* while (i < pExtent->cGDEntries) */
1279
1280 /** @todo figure out what to do for unclean VMDKs. */
1281 if (pTmpGT1)
1282 RTMemFree(pTmpGT1);
1283 if (pTmpGT2)
1284 RTMemFree(pTmpGT2);
1285 }
1286 else
1287 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
1288 N_("VMDK: could not read redundant grain directory in '%s'"), pExtent->pszFullname);
1289 }
1290 }
1291 else
1292 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
1293 N_("VMDK: could not read grain directory in '%s': %Rrc"), pExtent->pszFullname, rc);
1294 }
1295
1296 if (RT_FAILURE(rc))
1297 vmdkFreeGrainDirectory(pExtent);
1298 return rc;
1299}
1300
1301/**
1302 * Creates a new grain directory for the given extent at the given start sector.
1303 *
1304 * @returns VBox status code.
1305 * @param pImage Image instance data.
1306 * @param pExtent The VMDK extent.
1307 * @param uStartSector Where the grain directory should be stored in the image.
1308 * @param fPreAlloc Flag whether to pre allocate the grain tables at this point.
1309 */
1310static int vmdkCreateGrainDirectory(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
1311 uint64_t uStartSector, bool fPreAlloc)
1312{
1313 int rc = VINF_SUCCESS;
1314 unsigned i;
1315 size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
1316 size_t cbGDRounded = RT_ALIGN_64(cbGD, 512);
1317 size_t cbGTRounded;
1318 uint64_t cbOverhead;
1319
1320 if (fPreAlloc)
1321 {
1322 cbGTRounded = RT_ALIGN_64(pExtent->cGDEntries * pExtent->cGTEntries * sizeof(uint32_t), 512);
1323 cbOverhead = VMDK_SECTOR2BYTE(uStartSector) + cbGDRounded + cbGTRounded;
1324 }
1325 else
1326 {
1327 /* Use a dummy start sector for layout computation. */
1328 if (uStartSector == VMDK_GD_AT_END)
1329 uStartSector = 1;
1330 cbGTRounded = 0;
1331 cbOverhead = VMDK_SECTOR2BYTE(uStartSector) + cbGDRounded;
1332 }
1333
1334 /* For streamOptimized extents there is only one grain directory,
1335 * and for all others take redundant grain directory into account. */
1336 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
1337 {
1338 cbOverhead = RT_ALIGN_64(cbOverhead,
1339 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
1340 }
1341 else
1342 {
1343 cbOverhead += cbGDRounded + cbGTRounded;
1344 cbOverhead = RT_ALIGN_64(cbOverhead,
1345 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
1346 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pExtent->pFile->pStorage, cbOverhead);
1347 }
1348
1349 if (RT_SUCCESS(rc))
1350 {
1351 pExtent->uAppendPosition = cbOverhead;
1352 pExtent->cOverheadSectors = VMDK_BYTE2SECTOR(cbOverhead);
1353
1354 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
1355 {
1356 pExtent->uSectorRGD = 0;
1357 pExtent->uSectorGD = uStartSector;
1358 }
1359 else
1360 {
1361 pExtent->uSectorRGD = uStartSector;
1362 pExtent->uSectorGD = uStartSector + VMDK_BYTE2SECTOR(cbGDRounded + cbGTRounded);
1363 }
1364
1365 rc = vmdkAllocStreamBuffers(pImage, pExtent);
1366 if (RT_SUCCESS(rc))
1367 {
1368 rc = vmdkAllocGrainDirectory(pImage, pExtent);
1369 if ( RT_SUCCESS(rc)
1370 && fPreAlloc)
1371 {
1372 uint32_t uGTSectorLE;
1373 uint64_t uOffsetSectors;
1374
1375 if (pExtent->pRGD)
1376 {
1377 uOffsetSectors = pExtent->uSectorRGD + VMDK_BYTE2SECTOR(cbGDRounded);
1378 for (i = 0; i < pExtent->cGDEntries; i++)
1379 {
1380 pExtent->pRGD[i] = uOffsetSectors;
1381 uGTSectorLE = RT_H2LE_U64(uOffsetSectors);
1382 /* Write the redundant grain directory entry to disk. */
1383 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
1384 VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + i * sizeof(uGTSectorLE),
1385 &uGTSectorLE, sizeof(uGTSectorLE));
1386 if (RT_FAILURE(rc))
1387 {
1388 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write new redundant grain directory entry in '%s'"), pExtent->pszFullname);
1389 break;
1390 }
1391 uOffsetSectors += VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
1392 }
1393 }
1394
1395 if (RT_SUCCESS(rc))
1396 {
1397 uOffsetSectors = pExtent->uSectorGD + VMDK_BYTE2SECTOR(cbGDRounded);
1398 for (i = 0; i < pExtent->cGDEntries; i++)
1399 {
1400 pExtent->pGD[i] = uOffsetSectors;
1401 uGTSectorLE = RT_H2LE_U64(uOffsetSectors);
1402 /* Write the grain directory entry to disk. */
1403 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
1404 VMDK_SECTOR2BYTE(pExtent->uSectorGD) + i * sizeof(uGTSectorLE),
1405 &uGTSectorLE, sizeof(uGTSectorLE));
1406 if (RT_FAILURE(rc))
1407 {
1408 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write new grain directory entry in '%s'"), pExtent->pszFullname);
1409 break;
1410 }
1411 uOffsetSectors += VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
1412 }
1413 }
1414 }
1415 }
1416 }
1417
1418 if (RT_FAILURE(rc))
1419 vmdkFreeGrainDirectory(pExtent);
1420 return rc;
1421}
1422
1423/**
1424 * Unquotes the given string returning the result in a separate buffer.
1425 *
1426 * @returns VBox status code.
1427 * @param pImage The VMDK image state.
1428 * @param pszStr The string to unquote.
1429 * @param ppszUnquoted Where to store the return value, use RTMemTmpFree to
1430 * free.
1431 * @param ppszNext Where to store the pointer to any character following
1432 * the quoted value, optional.
1433 */
1434static int vmdkStringUnquote(PVMDKIMAGE pImage, const char *pszStr,
1435 char **ppszUnquoted, char **ppszNext)
1436{
1437 const char *pszStart = pszStr;
1438 char *pszQ;
1439 char *pszUnquoted;
1440
1441 /* Skip over whitespace. */
1442 while (*pszStr == ' ' || *pszStr == '\t')
1443 pszStr++;
1444
1445 if (*pszStr != '"')
1446 {
1447 pszQ = (char *)pszStr;
1448 while (*pszQ && *pszQ != ' ' && *pszQ != '\t')
1449 pszQ++;
1450 }
1451 else
1452 {
1453 pszStr++;
1454 pszQ = (char *)strchr(pszStr, '"');
1455 if (pszQ == NULL)
1456 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s' (raw value %s)"),
1457 pImage->pszFilename, pszStart);
1458 }
1459
1460 pszUnquoted = (char *)RTMemTmpAlloc(pszQ - pszStr + 1);
1461 if (!pszUnquoted)
1462 return VERR_NO_MEMORY;
1463 memcpy(pszUnquoted, pszStr, pszQ - pszStr);
1464 pszUnquoted[pszQ - pszStr] = '\0';
1465 *ppszUnquoted = pszUnquoted;
1466 if (ppszNext)
1467 *ppszNext = pszQ + 1;
1468 return VINF_SUCCESS;
1469}
1470
1471static int vmdkDescInitStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1472 const char *pszLine)
1473{
1474 char *pEnd = pDescriptor->aLines[pDescriptor->cLines];
1475 ssize_t cbDiff = strlen(pszLine) + 1;
1476
1477 if ( pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1
1478 && pEnd - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff)
1479 return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1480
1481 memcpy(pEnd, pszLine, cbDiff);
1482 pDescriptor->cLines++;
1483 pDescriptor->aLines[pDescriptor->cLines] = pEnd + cbDiff;
1484 pDescriptor->fDirty = true;
1485
1486 return VINF_SUCCESS;
1487}
1488
1489static bool vmdkDescGetStr(PVMDKDESCRIPTOR pDescriptor, unsigned uStart,
1490 const char *pszKey, const char **ppszValue)
1491{
1492 size_t cbKey = strlen(pszKey);
1493 const char *pszValue;
1494
1495 while (uStart != 0)
1496 {
1497 if (!strncmp(pDescriptor->aLines[uStart], pszKey, cbKey))
1498 {
1499 /* Key matches, check for a '=' (preceded by whitespace). */
1500 pszValue = pDescriptor->aLines[uStart] + cbKey;
1501 while (*pszValue == ' ' || *pszValue == '\t')
1502 pszValue++;
1503 if (*pszValue == '=')
1504 {
1505 *ppszValue = pszValue + 1;
1506 break;
1507 }
1508 }
1509 uStart = pDescriptor->aNextLines[uStart];
1510 }
1511 return !!uStart;
1512}
1513
1514static int vmdkDescSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1515 unsigned uStart,
1516 const char *pszKey, const char *pszValue)
1517{
1518 char *pszTmp = NULL; /* (MSC naturally cannot figure this isn't used uninitialized) */
1519 size_t cbKey = strlen(pszKey);
1520 unsigned uLast = 0;
1521
1522 while (uStart != 0)
1523 {
1524 if (!strncmp(pDescriptor->aLines[uStart], pszKey, cbKey))
1525 {
1526 /* Key matches, check for a '=' (preceded by whitespace). */
1527 pszTmp = pDescriptor->aLines[uStart] + cbKey;
1528 while (*pszTmp == ' ' || *pszTmp == '\t')
1529 pszTmp++;
1530 if (*pszTmp == '=')
1531 {
1532 pszTmp++;
1533 /** @todo r=bird: Doesn't skipping trailing blanks here just cause unecessary
1534 * bloat and potentially out of space error? */
1535 while (*pszTmp == ' ' || *pszTmp == '\t')
1536 pszTmp++;
1537 break;
1538 }
1539 }
1540 if (!pDescriptor->aNextLines[uStart])
1541 uLast = uStart;
1542 uStart = pDescriptor->aNextLines[uStart];
1543 }
1544 if (uStart)
1545 {
1546 if (pszValue)
1547 {
1548 /* Key already exists, replace existing value. */
1549 size_t cbOldVal = strlen(pszTmp);
1550 size_t cbNewVal = strlen(pszValue);
1551 ssize_t cbDiff = cbNewVal - cbOldVal;
1552 /* Check for buffer overflow. */
1553 if ( pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[0]
1554 > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff)
1555 return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1556
1557 memmove(pszTmp + cbNewVal, pszTmp + cbOldVal,
1558 pDescriptor->aLines[pDescriptor->cLines] - pszTmp - cbOldVal);
1559 memcpy(pszTmp, pszValue, cbNewVal + 1);
1560 for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1561 pDescriptor->aLines[i] += cbDiff;
1562 }
1563 else
1564 {
1565 memmove(pDescriptor->aLines[uStart], pDescriptor->aLines[uStart+1],
1566 pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uStart+1] + 1);
1567 for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1568 {
1569 pDescriptor->aLines[i-1] = pDescriptor->aLines[i];
1570 if (pDescriptor->aNextLines[i])
1571 pDescriptor->aNextLines[i-1] = pDescriptor->aNextLines[i] - 1;
1572 else
1573 pDescriptor->aNextLines[i-1] = 0;
1574 }
1575 pDescriptor->cLines--;
1576 /* Adjust starting line numbers of following descriptor sections. */
1577 if (uStart < pDescriptor->uFirstExtent)
1578 pDescriptor->uFirstExtent--;
1579 if (uStart < pDescriptor->uFirstDDB)
1580 pDescriptor->uFirstDDB--;
1581 }
1582 }
1583 else
1584 {
1585 /* Key doesn't exist, append after the last entry in this category. */
1586 if (!pszValue)
1587 {
1588 /* Key doesn't exist, and it should be removed. Simply a no-op. */
1589 return VINF_SUCCESS;
1590 }
1591 cbKey = strlen(pszKey);
1592 size_t cbValue = strlen(pszValue);
1593 ssize_t cbDiff = cbKey + 1 + cbValue + 1;
1594 /* Check for buffer overflow. */
1595 if ( (pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1)
1596 || ( pDescriptor->aLines[pDescriptor->cLines]
1597 - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff))
1598 return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1599 for (unsigned i = pDescriptor->cLines + 1; i > uLast + 1; i--)
1600 {
1601 pDescriptor->aLines[i] = pDescriptor->aLines[i - 1];
1602 if (pDescriptor->aNextLines[i - 1])
1603 pDescriptor->aNextLines[i] = pDescriptor->aNextLines[i - 1] + 1;
1604 else
1605 pDescriptor->aNextLines[i] = 0;
1606 }
1607 uStart = uLast + 1;
1608 pDescriptor->aNextLines[uLast] = uStart;
1609 pDescriptor->aNextLines[uStart] = 0;
1610 pDescriptor->cLines++;
1611 pszTmp = pDescriptor->aLines[uStart];
1612 memmove(pszTmp + cbDiff, pszTmp,
1613 pDescriptor->aLines[pDescriptor->cLines] - pszTmp);
1614 memcpy(pDescriptor->aLines[uStart], pszKey, cbKey);
1615 pDescriptor->aLines[uStart][cbKey] = '=';
1616 memcpy(pDescriptor->aLines[uStart] + cbKey + 1, pszValue, cbValue + 1);
1617 for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1618 pDescriptor->aLines[i] += cbDiff;
1619
1620 /* Adjust starting line numbers of following descriptor sections. */
1621 if (uStart <= pDescriptor->uFirstExtent)
1622 pDescriptor->uFirstExtent++;
1623 if (uStart <= pDescriptor->uFirstDDB)
1624 pDescriptor->uFirstDDB++;
1625 }
1626 pDescriptor->fDirty = true;
1627 return VINF_SUCCESS;
1628}
1629
1630static int vmdkDescBaseGetU32(PVMDKDESCRIPTOR pDescriptor, const char *pszKey,
1631 uint32_t *puValue)
1632{
1633 const char *pszValue;
1634
1635 if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
1636 &pszValue))
1637 return VERR_VD_VMDK_VALUE_NOT_FOUND;
1638 return RTStrToUInt32Ex(pszValue, NULL, 10, puValue);
1639}
1640
1641/**
1642 * Returns the value of the given key as a string allocating the necessary memory.
1643 *
1644 * @returns VBox status code.
1645 * @retval VERR_VD_VMDK_VALUE_NOT_FOUND if the value could not be found.
1646 * @param pImage The VMDK image state.
1647 * @param pDescriptor The descriptor to fetch the value from.
1648 * @param pszKey The key to get the value from.
1649 * @param ppszValue Where to store the return value, use RTMemTmpFree to
1650 * free.
1651 */
1652static int vmdkDescBaseGetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1653 const char *pszKey, char **ppszValue)
1654{
1655 const char *pszValue;
1656 char *pszValueUnquoted;
1657
1658 if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
1659 &pszValue))
1660 return VERR_VD_VMDK_VALUE_NOT_FOUND;
1661 int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1662 if (RT_FAILURE(rc))
1663 return rc;
1664 *ppszValue = pszValueUnquoted;
1665 return rc;
1666}
1667
1668static int vmdkDescBaseSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1669 const char *pszKey, const char *pszValue)
1670{
1671 char *pszValueQuoted;
1672
1673 RTStrAPrintf(&pszValueQuoted, "\"%s\"", pszValue);
1674 if (!pszValueQuoted)
1675 return VERR_NO_STR_MEMORY;
1676 int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc, pszKey,
1677 pszValueQuoted);
1678 RTStrFree(pszValueQuoted);
1679 return rc;
1680}
1681
1682static void vmdkDescExtRemoveDummy(PVMDKIMAGE pImage,
1683 PVMDKDESCRIPTOR pDescriptor)
1684{
1685 RT_NOREF1(pImage);
1686 unsigned uEntry = pDescriptor->uFirstExtent;
1687 ssize_t cbDiff;
1688
1689 if (!uEntry)
1690 return;
1691
1692 cbDiff = strlen(pDescriptor->aLines[uEntry]) + 1;
1693 /* Move everything including \0 in the entry marking the end of buffer. */
1694 memmove(pDescriptor->aLines[uEntry], pDescriptor->aLines[uEntry + 1],
1695 pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uEntry + 1] + 1);
1696 for (unsigned i = uEntry + 1; i <= pDescriptor->cLines; i++)
1697 {
1698 pDescriptor->aLines[i - 1] = pDescriptor->aLines[i] - cbDiff;
1699 if (pDescriptor->aNextLines[i])
1700 pDescriptor->aNextLines[i - 1] = pDescriptor->aNextLines[i] - 1;
1701 else
1702 pDescriptor->aNextLines[i - 1] = 0;
1703 }
1704 pDescriptor->cLines--;
1705 if (pDescriptor->uFirstDDB)
1706 pDescriptor->uFirstDDB--;
1707
1708 return;
1709}
1710
1711static int vmdkDescExtInsert(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1712 VMDKACCESS enmAccess, uint64_t cNominalSectors,
1713 VMDKETYPE enmType, const char *pszBasename,
1714 uint64_t uSectorOffset)
1715{
1716 static const char *apszAccess[] = { "NOACCESS", "RDONLY", "RW" };
1717 static const char *apszType[] = { "", "SPARSE", "FLAT", "ZERO", "VMFS" };
1718 char *pszTmp;
1719 unsigned uStart = pDescriptor->uFirstExtent, uLast = 0;
1720 char szExt[1024];
1721 ssize_t cbDiff;
1722
1723 Assert((unsigned)enmAccess < RT_ELEMENTS(apszAccess));
1724 Assert((unsigned)enmType < RT_ELEMENTS(apszType));
1725
1726 /* Find last entry in extent description. */
1727 while (uStart)
1728 {
1729 if (!pDescriptor->aNextLines[uStart])
1730 uLast = uStart;
1731 uStart = pDescriptor->aNextLines[uStart];
1732 }
1733
1734 if (enmType == VMDKETYPE_ZERO)
1735 {
1736 RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s ", apszAccess[enmAccess],
1737 cNominalSectors, apszType[enmType]);
1738 }
1739 else if (enmType == VMDKETYPE_FLAT)
1740 {
1741 RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s \"%s\" %llu",
1742 apszAccess[enmAccess], cNominalSectors,
1743 apszType[enmType], pszBasename, uSectorOffset);
1744 }
1745 else
1746 {
1747 RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s \"%s\"",
1748 apszAccess[enmAccess], cNominalSectors,
1749 apszType[enmType], pszBasename);
1750 }
1751 cbDiff = strlen(szExt) + 1;
1752
1753 /* Check for buffer overflow. */
1754 if ( (pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1)
1755 || ( pDescriptor->aLines[pDescriptor->cLines]
1756 - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff))
1757 return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1758
1759 for (unsigned i = pDescriptor->cLines + 1; i > uLast + 1; i--)
1760 {
1761 pDescriptor->aLines[i] = pDescriptor->aLines[i - 1];
1762 if (pDescriptor->aNextLines[i - 1])
1763 pDescriptor->aNextLines[i] = pDescriptor->aNextLines[i - 1] + 1;
1764 else
1765 pDescriptor->aNextLines[i] = 0;
1766 }
1767 uStart = uLast + 1;
1768 pDescriptor->aNextLines[uLast] = uStart;
1769 pDescriptor->aNextLines[uStart] = 0;
1770 pDescriptor->cLines++;
1771 pszTmp = pDescriptor->aLines[uStart];
1772 memmove(pszTmp + cbDiff, pszTmp,
1773 pDescriptor->aLines[pDescriptor->cLines] - pszTmp);
1774 memcpy(pDescriptor->aLines[uStart], szExt, cbDiff);
1775 for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1776 pDescriptor->aLines[i] += cbDiff;
1777
1778 /* Adjust starting line numbers of following descriptor sections. */
1779 if (uStart <= pDescriptor->uFirstDDB)
1780 pDescriptor->uFirstDDB++;
1781
1782 pDescriptor->fDirty = true;
1783 return VINF_SUCCESS;
1784}
1785
1786/**
1787 * Returns the value of the given key from the DDB as a string allocating
1788 * the necessary memory.
1789 *
1790 * @returns VBox status code.
1791 * @retval VERR_VD_VMDK_VALUE_NOT_FOUND if the value could not be found.
1792 * @param pImage The VMDK image state.
1793 * @param pDescriptor The descriptor to fetch the value from.
1794 * @param pszKey The key to get the value from.
1795 * @param ppszValue Where to store the return value, use RTMemTmpFree to
1796 * free.
1797 */
1798static int vmdkDescDDBGetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1799 const char *pszKey, char **ppszValue)
1800{
1801 const char *pszValue;
1802 char *pszValueUnquoted;
1803
1804 if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
1805 &pszValue))
1806 return VERR_VD_VMDK_VALUE_NOT_FOUND;
1807 int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1808 if (RT_FAILURE(rc))
1809 return rc;
1810 *ppszValue = pszValueUnquoted;
1811 return rc;
1812}
1813
1814static int vmdkDescDDBGetU32(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1815 const char *pszKey, uint32_t *puValue)
1816{
1817 const char *pszValue;
1818 char *pszValueUnquoted;
1819
1820 if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
1821 &pszValue))
1822 return VERR_VD_VMDK_VALUE_NOT_FOUND;
1823 int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1824 if (RT_FAILURE(rc))
1825 return rc;
1826 rc = RTStrToUInt32Ex(pszValueUnquoted, NULL, 10, puValue);
1827 RTMemTmpFree(pszValueUnquoted);
1828 return rc;
1829}
1830
1831static int vmdkDescDDBGetUuid(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1832 const char *pszKey, PRTUUID pUuid)
1833{
1834 const char *pszValue;
1835 char *pszValueUnquoted;
1836
1837 if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
1838 &pszValue))
1839 return VERR_VD_VMDK_VALUE_NOT_FOUND;
1840 int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1841 if (RT_FAILURE(rc))
1842 return rc;
1843 rc = RTUuidFromStr(pUuid, pszValueUnquoted);
1844 RTMemTmpFree(pszValueUnquoted);
1845 return rc;
1846}
1847
1848static int vmdkDescDDBSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1849 const char *pszKey, const char *pszVal)
1850{
1851 int rc;
1852 char *pszValQuoted;
1853
1854 if (pszVal)
1855 {
1856 RTStrAPrintf(&pszValQuoted, "\"%s\"", pszVal);
1857 if (!pszValQuoted)
1858 return VERR_NO_STR_MEMORY;
1859 }
1860 else
1861 pszValQuoted = NULL;
1862 rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
1863 pszValQuoted);
1864 if (pszValQuoted)
1865 RTStrFree(pszValQuoted);
1866 return rc;
1867}
1868
1869static int vmdkDescDDBSetUuid(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1870 const char *pszKey, PCRTUUID pUuid)
1871{
1872 char *pszUuid;
1873
1874 RTStrAPrintf(&pszUuid, "\"%RTuuid\"", pUuid);
1875 if (!pszUuid)
1876 return VERR_NO_STR_MEMORY;
1877 int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
1878 pszUuid);
1879 RTStrFree(pszUuid);
1880 return rc;
1881}
1882
1883static int vmdkDescDDBSetU32(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1884 const char *pszKey, uint32_t uValue)
1885{
1886 char *pszValue;
1887
1888 RTStrAPrintf(&pszValue, "\"%d\"", uValue);
1889 if (!pszValue)
1890 return VERR_NO_STR_MEMORY;
1891 int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
1892 pszValue);
1893 RTStrFree(pszValue);
1894 return rc;
1895}
1896
1897/**
1898 * Splits the descriptor data into individual lines checking for correct line
1899 * endings and descriptor size.
1900 *
1901 * @returns VBox status code.
1902 * @param pImage The image instance.
1903 * @param pDesc The descriptor.
1904 * @param pszTmp The raw descriptor data from the image.
1905 */
1906static int vmdkDescSplitLines(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDesc, char *pszTmp)
1907{
1908 unsigned cLine = 0;
1909 int rc = VINF_SUCCESS;
1910
1911 while ( RT_SUCCESS(rc)
1912 && *pszTmp != '\0')
1913 {
1914 pDesc->aLines[cLine++] = pszTmp;
1915 if (cLine >= VMDK_DESCRIPTOR_LINES_MAX)
1916 {
1917 vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1918 rc = VERR_VD_VMDK_INVALID_HEADER;
1919 break;
1920 }
1921
1922 while (*pszTmp != '\0' && *pszTmp != '\n')
1923 {
1924 if (*pszTmp == '\r')
1925 {
1926 if (*(pszTmp + 1) != '\n')
1927 {
1928 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: unsupported end of line in descriptor in '%s'"), pImage->pszFilename);
1929 break;
1930 }
1931 else
1932 {
1933 /* Get rid of CR character. */
1934 *pszTmp = '\0';
1935 }
1936 }
1937 pszTmp++;
1938 }
1939
1940 if (RT_FAILURE(rc))
1941 break;
1942
1943 /* Get rid of LF character. */
1944 if (*pszTmp == '\n')
1945 {
1946 *pszTmp = '\0';
1947 pszTmp++;
1948 }
1949 }
1950
1951 if (RT_SUCCESS(rc))
1952 {
1953 pDesc->cLines = cLine;
1954 /* Pointer right after the end of the used part of the buffer. */
1955 pDesc->aLines[cLine] = pszTmp;
1956 }
1957
1958 return rc;
1959}
1960
1961static int vmdkPreprocessDescriptor(PVMDKIMAGE pImage, char *pDescData,
1962 size_t cbDescData, PVMDKDESCRIPTOR pDescriptor)
1963{
1964 pDescriptor->cbDescAlloc = cbDescData;
1965 int rc = vmdkDescSplitLines(pImage, pDescriptor, pDescData);
1966 if (RT_SUCCESS(rc))
1967 {
1968 if ( strcmp(pDescriptor->aLines[0], "# Disk DescriptorFile")
1969 && strcmp(pDescriptor->aLines[0], "# Disk Descriptor File")
1970 && strcmp(pDescriptor->aLines[0], "#Disk Descriptor File")
1971 && strcmp(pDescriptor->aLines[0], "#Disk DescriptorFile"))
1972 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
1973 N_("VMDK: descriptor does not start as expected in '%s'"), pImage->pszFilename);
1974 else
1975 {
1976 unsigned uLastNonEmptyLine = 0;
1977
1978 /* Initialize those, because we need to be able to reopen an image. */
1979 pDescriptor->uFirstDesc = 0;
1980 pDescriptor->uFirstExtent = 0;
1981 pDescriptor->uFirstDDB = 0;
1982 for (unsigned i = 0; i < pDescriptor->cLines; i++)
1983 {
1984 if (*pDescriptor->aLines[i] != '#' && *pDescriptor->aLines[i] != '\0')
1985 {
1986 if ( !strncmp(pDescriptor->aLines[i], "RW", 2)
1987 || !strncmp(pDescriptor->aLines[i], "RDONLY", 6)
1988 || !strncmp(pDescriptor->aLines[i], "NOACCESS", 8) )
1989 {
1990 /* An extent descriptor. */
1991 if (!pDescriptor->uFirstDesc || pDescriptor->uFirstDDB)
1992 {
1993 /* Incorrect ordering of entries. */
1994 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
1995 N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
1996 break;
1997 }
1998 if (!pDescriptor->uFirstExtent)
1999 {
2000 pDescriptor->uFirstExtent = i;
2001 uLastNonEmptyLine = 0;
2002 }
2003 }
2004 else if (!strncmp(pDescriptor->aLines[i], "ddb.", 4))
2005 {
2006 /* A disk database entry. */
2007 if (!pDescriptor->uFirstDesc || !pDescriptor->uFirstExtent)
2008 {
2009 /* Incorrect ordering of entries. */
2010 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2011 N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
2012 break;
2013 }
2014 if (!pDescriptor->uFirstDDB)
2015 {
2016 pDescriptor->uFirstDDB = i;
2017 uLastNonEmptyLine = 0;
2018 }
2019 }
2020 else
2021 {
2022 /* A normal entry. */
2023 if (pDescriptor->uFirstExtent || pDescriptor->uFirstDDB)
2024 {
2025 /* Incorrect ordering of entries. */
2026 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2027 N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
2028 break;
2029 }
2030 if (!pDescriptor->uFirstDesc)
2031 {
2032 pDescriptor->uFirstDesc = i;
2033 uLastNonEmptyLine = 0;
2034 }
2035 }
2036 if (uLastNonEmptyLine)
2037 pDescriptor->aNextLines[uLastNonEmptyLine] = i;
2038 uLastNonEmptyLine = i;
2039 }
2040 }
2041 }
2042 }
2043
2044 return rc;
2045}
2046
2047static int vmdkDescSetPCHSGeometry(PVMDKIMAGE pImage,
2048 PCVDGEOMETRY pPCHSGeometry)
2049{
2050 int rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
2051 VMDK_DDB_GEO_PCHS_CYLINDERS,
2052 pPCHSGeometry->cCylinders);
2053 if (RT_FAILURE(rc))
2054 return rc;
2055 rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
2056 VMDK_DDB_GEO_PCHS_HEADS,
2057 pPCHSGeometry->cHeads);
2058 if (RT_FAILURE(rc))
2059 return rc;
2060 rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
2061 VMDK_DDB_GEO_PCHS_SECTORS,
2062 pPCHSGeometry->cSectors);
2063 return rc;
2064}
2065
2066static int vmdkDescSetLCHSGeometry(PVMDKIMAGE pImage,
2067 PCVDGEOMETRY pLCHSGeometry)
2068{
2069 int rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
2070 VMDK_DDB_GEO_LCHS_CYLINDERS,
2071 pLCHSGeometry->cCylinders);
2072 if (RT_FAILURE(rc))
2073 return rc;
2074 rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
2075 VMDK_DDB_GEO_LCHS_HEADS,
2076
2077 pLCHSGeometry->cHeads);
2078 if (RT_FAILURE(rc))
2079 return rc;
2080 rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
2081 VMDK_DDB_GEO_LCHS_SECTORS,
2082 pLCHSGeometry->cSectors);
2083 return rc;
2084}
2085
2086static int vmdkCreateDescriptor(PVMDKIMAGE pImage, char *pDescData,
2087 size_t cbDescData, PVMDKDESCRIPTOR pDescriptor)
2088{
2089 pDescriptor->uFirstDesc = 0;
2090 pDescriptor->uFirstExtent = 0;
2091 pDescriptor->uFirstDDB = 0;
2092 pDescriptor->cLines = 0;
2093 pDescriptor->cbDescAlloc = cbDescData;
2094 pDescriptor->fDirty = false;
2095 pDescriptor->aLines[pDescriptor->cLines] = pDescData;
2096 memset(pDescriptor->aNextLines, '\0', sizeof(pDescriptor->aNextLines));
2097
2098 int rc = vmdkDescInitStr(pImage, pDescriptor, "# Disk DescriptorFile");
2099 if (RT_SUCCESS(rc))
2100 rc = vmdkDescInitStr(pImage, pDescriptor, "version=1");
2101 if (RT_SUCCESS(rc))
2102 {
2103 pDescriptor->uFirstDesc = pDescriptor->cLines - 1;
2104 rc = vmdkDescInitStr(pImage, pDescriptor, "");
2105 }
2106 if (RT_SUCCESS(rc))
2107 rc = vmdkDescInitStr(pImage, pDescriptor, "# Extent description");
2108 if (RT_SUCCESS(rc))
2109 rc = vmdkDescInitStr(pImage, pDescriptor, "NOACCESS 0 ZERO ");
2110 if (RT_SUCCESS(rc))
2111 {
2112 pDescriptor->uFirstExtent = pDescriptor->cLines - 1;
2113 rc = vmdkDescInitStr(pImage, pDescriptor, "");
2114 }
2115 if (RT_SUCCESS(rc))
2116 {
2117 /* The trailing space is created by VMware, too. */
2118 rc = vmdkDescInitStr(pImage, pDescriptor, "# The disk Data Base ");
2119 }
2120 if (RT_SUCCESS(rc))
2121 rc = vmdkDescInitStr(pImage, pDescriptor, "#DDB");
2122 if (RT_SUCCESS(rc))
2123 rc = vmdkDescInitStr(pImage, pDescriptor, "");
2124 if (RT_SUCCESS(rc))
2125 rc = vmdkDescInitStr(pImage, pDescriptor, "ddb.virtualHWVersion = \"4\"");
2126 if (RT_SUCCESS(rc))
2127 {
2128 pDescriptor->uFirstDDB = pDescriptor->cLines - 1;
2129
2130 /* Now that the framework is in place, use the normal functions to insert
2131 * the remaining keys. */
2132 char szBuf[9];
2133 RTStrPrintf(szBuf, sizeof(szBuf), "%08x", RTRandU32());
2134 rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc,
2135 "CID", szBuf);
2136 }
2137 if (RT_SUCCESS(rc))
2138 rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc,
2139 "parentCID", "ffffffff");
2140 if (RT_SUCCESS(rc))
2141 rc = vmdkDescDDBSetStr(pImage, pDescriptor, "ddb.adapterType", "ide");
2142
2143 return rc;
2144}
2145
2146static int vmdkParseDescriptor(PVMDKIMAGE pImage, char *pDescData, size_t cbDescData)
2147{
2148 int rc;
2149 unsigned cExtents;
2150 unsigned uLine;
2151 unsigned i;
2152
2153 rc = vmdkPreprocessDescriptor(pImage, pDescData, cbDescData,
2154 &pImage->Descriptor);
2155 if (RT_FAILURE(rc))
2156 return rc;
2157
2158 /* Check version, must be 1. */
2159 uint32_t uVersion;
2160 rc = vmdkDescBaseGetU32(&pImage->Descriptor, "version", &uVersion);
2161 if (RT_FAILURE(rc))
2162 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error finding key 'version' in descriptor in '%s'"), pImage->pszFilename);
2163 if (uVersion != 1)
2164 return vdIfError(pImage->pIfError, VERR_VD_VMDK_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: unsupported format version in descriptor in '%s'"), pImage->pszFilename);
2165
2166 /* Get image creation type and determine image flags. */
2167 char *pszCreateType = NULL; /* initialized to make gcc shut up */
2168 rc = vmdkDescBaseGetStr(pImage, &pImage->Descriptor, "createType",
2169 &pszCreateType);
2170 if (RT_FAILURE(rc))
2171 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot get image type from descriptor in '%s'"), pImage->pszFilename);
2172 if ( !strcmp(pszCreateType, "twoGbMaxExtentSparse")
2173 || !strcmp(pszCreateType, "twoGbMaxExtentFlat"))
2174 pImage->uImageFlags |= VD_VMDK_IMAGE_FLAGS_SPLIT_2G;
2175 else if ( !strcmp(pszCreateType, "partitionedDevice")
2176 || !strcmp(pszCreateType, "fullDevice"))
2177 pImage->uImageFlags |= VD_VMDK_IMAGE_FLAGS_RAWDISK;
2178 else if (!strcmp(pszCreateType, "streamOptimized"))
2179 pImage->uImageFlags |= VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED;
2180 else if (!strcmp(pszCreateType, "vmfs"))
2181 pImage->uImageFlags |= VD_IMAGE_FLAGS_FIXED | VD_VMDK_IMAGE_FLAGS_ESX;
2182 RTMemTmpFree(pszCreateType);
2183
2184 /* Count the number of extent config entries. */
2185 for (uLine = pImage->Descriptor.uFirstExtent, cExtents = 0;
2186 uLine != 0;
2187 uLine = pImage->Descriptor.aNextLines[uLine], cExtents++)
2188 /* nothing */;
2189
2190 if (!pImage->pDescData && cExtents != 1)
2191 {
2192 /* Monolithic image, must have only one extent (already opened). */
2193 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image may only have one extent in '%s'"), pImage->pszFilename);
2194 }
2195
2196 if (pImage->pDescData)
2197 {
2198 /* Non-monolithic image, extents need to be allocated. */
2199 rc = vmdkCreateExtents(pImage, cExtents);
2200 if (RT_FAILURE(rc))
2201 return rc;
2202 }
2203
2204 for (i = 0, uLine = pImage->Descriptor.uFirstExtent;
2205 i < cExtents; i++, uLine = pImage->Descriptor.aNextLines[uLine])
2206 {
2207 char *pszLine = pImage->Descriptor.aLines[uLine];
2208
2209 /* Access type of the extent. */
2210 if (!strncmp(pszLine, "RW", 2))
2211 {
2212 pImage->pExtents[i].enmAccess = VMDKACCESS_READWRITE;
2213 pszLine += 2;
2214 }
2215 else if (!strncmp(pszLine, "RDONLY", 6))
2216 {
2217 pImage->pExtents[i].enmAccess = VMDKACCESS_READONLY;
2218 pszLine += 6;
2219 }
2220 else if (!strncmp(pszLine, "NOACCESS", 8))
2221 {
2222 pImage->pExtents[i].enmAccess = VMDKACCESS_NOACCESS;
2223 pszLine += 8;
2224 }
2225 else
2226 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2227 if (*pszLine++ != ' ')
2228 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2229
2230 /* Nominal size of the extent. */
2231 rc = RTStrToUInt64Ex(pszLine, &pszLine, 10,
2232 &pImage->pExtents[i].cNominalSectors);
2233 if (RT_FAILURE(rc))
2234 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2235 if (*pszLine++ != ' ')
2236 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2237
2238 /* Type of the extent. */
2239 if (!strncmp(pszLine, "SPARSE", 6))
2240 {
2241 pImage->pExtents[i].enmType = VMDKETYPE_HOSTED_SPARSE;
2242 pszLine += 6;
2243 }
2244 else if (!strncmp(pszLine, "FLAT", 4))
2245 {
2246 pImage->pExtents[i].enmType = VMDKETYPE_FLAT;
2247 pszLine += 4;
2248 }
2249 else if (!strncmp(pszLine, "ZERO", 4))
2250 {
2251 pImage->pExtents[i].enmType = VMDKETYPE_ZERO;
2252 pszLine += 4;
2253 }
2254 else if (!strncmp(pszLine, "VMFS", 4))
2255 {
2256 pImage->pExtents[i].enmType = VMDKETYPE_VMFS;
2257 pszLine += 4;
2258 }
2259 else
2260 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2261
2262 if (pImage->pExtents[i].enmType == VMDKETYPE_ZERO)
2263 {
2264 /* This one has no basename or offset. */
2265 if (*pszLine == ' ')
2266 pszLine++;
2267 if (*pszLine != '\0')
2268 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2269 pImage->pExtents[i].pszBasename = NULL;
2270 }
2271 else
2272 {
2273 /* All other extent types have basename and optional offset. */
2274 if (*pszLine++ != ' ')
2275 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2276
2277 /* Basename of the image. Surrounded by quotes. */
2278 char *pszBasename;
2279 rc = vmdkStringUnquote(pImage, pszLine, &pszBasename, &pszLine);
2280 if (RT_FAILURE(rc))
2281 return rc;
2282 pImage->pExtents[i].pszBasename = pszBasename;
2283 if (*pszLine == ' ')
2284 {
2285 pszLine++;
2286 if (*pszLine != '\0')
2287 {
2288 /* Optional offset in extent specified. */
2289 rc = RTStrToUInt64Ex(pszLine, &pszLine, 10,
2290 &pImage->pExtents[i].uSectorOffset);
2291 if (RT_FAILURE(rc))
2292 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2293 }
2294 }
2295
2296 if (*pszLine != '\0')
2297 return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
2298 }
2299 }
2300
2301 /* Determine PCHS geometry (autogenerate if necessary). */
2302 rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
2303 VMDK_DDB_GEO_PCHS_CYLINDERS,
2304 &pImage->PCHSGeometry.cCylinders);
2305 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2306 pImage->PCHSGeometry.cCylinders = 0;
2307 else if (RT_FAILURE(rc))
2308 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
2309 rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
2310 VMDK_DDB_GEO_PCHS_HEADS,
2311 &pImage->PCHSGeometry.cHeads);
2312 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2313 pImage->PCHSGeometry.cHeads = 0;
2314 else if (RT_FAILURE(rc))
2315 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
2316 rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
2317 VMDK_DDB_GEO_PCHS_SECTORS,
2318 &pImage->PCHSGeometry.cSectors);
2319 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2320 pImage->PCHSGeometry.cSectors = 0;
2321 else if (RT_FAILURE(rc))
2322 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
2323 if ( pImage->PCHSGeometry.cCylinders == 0
2324 || pImage->PCHSGeometry.cHeads == 0
2325 || pImage->PCHSGeometry.cHeads > 16
2326 || pImage->PCHSGeometry.cSectors == 0
2327 || pImage->PCHSGeometry.cSectors > 63)
2328 {
2329 /* Mark PCHS geometry as not yet valid (can't do the calculation here
2330 * as the total image size isn't known yet). */
2331 pImage->PCHSGeometry.cCylinders = 0;
2332 pImage->PCHSGeometry.cHeads = 16;
2333 pImage->PCHSGeometry.cSectors = 63;
2334 }
2335
2336 /* Determine LCHS geometry (set to 0 if not specified). */
2337 rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
2338 VMDK_DDB_GEO_LCHS_CYLINDERS,
2339 &pImage->LCHSGeometry.cCylinders);
2340 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2341 pImage->LCHSGeometry.cCylinders = 0;
2342 else if (RT_FAILURE(rc))
2343 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
2344 rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
2345 VMDK_DDB_GEO_LCHS_HEADS,
2346 &pImage->LCHSGeometry.cHeads);
2347 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2348 pImage->LCHSGeometry.cHeads = 0;
2349 else if (RT_FAILURE(rc))
2350 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
2351 rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
2352 VMDK_DDB_GEO_LCHS_SECTORS,
2353 &pImage->LCHSGeometry.cSectors);
2354 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2355 pImage->LCHSGeometry.cSectors = 0;
2356 else if (RT_FAILURE(rc))
2357 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
2358 if ( pImage->LCHSGeometry.cCylinders == 0
2359 || pImage->LCHSGeometry.cHeads == 0
2360 || pImage->LCHSGeometry.cSectors == 0)
2361 {
2362 pImage->LCHSGeometry.cCylinders = 0;
2363 pImage->LCHSGeometry.cHeads = 0;
2364 pImage->LCHSGeometry.cSectors = 0;
2365 }
2366
2367 /* Get image UUID. */
2368 rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_IMAGE_UUID,
2369 &pImage->ImageUuid);
2370 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2371 {
2372 /* Image without UUID. Probably created by VMware and not yet used
2373 * by VirtualBox. Can only be added for images opened in read/write
2374 * mode, so don't bother producing a sensible UUID otherwise. */
2375 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2376 RTUuidClear(&pImage->ImageUuid);
2377 else
2378 {
2379 rc = RTUuidCreate(&pImage->ImageUuid);
2380 if (RT_FAILURE(rc))
2381 return rc;
2382 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
2383 VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
2384 if (RT_FAILURE(rc))
2385 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing image UUID in descriptor in '%s'"), pImage->pszFilename);
2386 }
2387 }
2388 else if (RT_FAILURE(rc))
2389 return rc;
2390
2391 /* Get image modification UUID. */
2392 rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor,
2393 VMDK_DDB_MODIFICATION_UUID,
2394 &pImage->ModificationUuid);
2395 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2396 {
2397 /* Image without UUID. Probably created by VMware and not yet used
2398 * by VirtualBox. Can only be added for images opened in read/write
2399 * mode, so don't bother producing a sensible UUID otherwise. */
2400 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2401 RTUuidClear(&pImage->ModificationUuid);
2402 else
2403 {
2404 rc = RTUuidCreate(&pImage->ModificationUuid);
2405 if (RT_FAILURE(rc))
2406 return rc;
2407 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
2408 VMDK_DDB_MODIFICATION_UUID,
2409 &pImage->ModificationUuid);
2410 if (RT_FAILURE(rc))
2411 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing image modification UUID in descriptor in '%s'"), pImage->pszFilename);
2412 }
2413 }
2414 else if (RT_FAILURE(rc))
2415 return rc;
2416
2417 /* Get UUID of parent image. */
2418 rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_UUID,
2419 &pImage->ParentUuid);
2420 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2421 {
2422 /* Image without UUID. Probably created by VMware and not yet used
2423 * by VirtualBox. Can only be added for images opened in read/write
2424 * mode, so don't bother producing a sensible UUID otherwise. */
2425 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2426 RTUuidClear(&pImage->ParentUuid);
2427 else
2428 {
2429 rc = RTUuidClear(&pImage->ParentUuid);
2430 if (RT_FAILURE(rc))
2431 return rc;
2432 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
2433 VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
2434 if (RT_FAILURE(rc))
2435 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing parent UUID in descriptor in '%s'"), pImage->pszFilename);
2436 }
2437 }
2438 else if (RT_FAILURE(rc))
2439 return rc;
2440
2441 /* Get parent image modification UUID. */
2442 rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor,
2443 VMDK_DDB_PARENT_MODIFICATION_UUID,
2444 &pImage->ParentModificationUuid);
2445 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
2446 {
2447 /* Image without UUID. Probably created by VMware and not yet used
2448 * by VirtualBox. Can only be added for images opened in read/write
2449 * mode, so don't bother producing a sensible UUID otherwise. */
2450 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2451 RTUuidClear(&pImage->ParentModificationUuid);
2452 else
2453 {
2454 RTUuidClear(&pImage->ParentModificationUuid);
2455 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
2456 VMDK_DDB_PARENT_MODIFICATION_UUID,
2457 &pImage->ParentModificationUuid);
2458 if (RT_FAILURE(rc))
2459 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing parent modification UUID in descriptor in '%s'"), pImage->pszFilename);
2460 }
2461 }
2462 else if (RT_FAILURE(rc))
2463 return rc;
2464
2465 return VINF_SUCCESS;
2466}
2467
2468/**
2469 * Internal : Prepares the descriptor to write to the image.
2470 */
2471static int vmdkDescriptorPrepare(PVMDKIMAGE pImage, uint64_t cbLimit,
2472 void **ppvData, size_t *pcbData)
2473{
2474 int rc = VINF_SUCCESS;
2475
2476 /*
2477 * Allocate temporary descriptor buffer.
2478 * In case there is no limit allocate a default
2479 * and increase if required.
2480 */
2481 size_t cbDescriptor = cbLimit ? cbLimit : 4 * _1K;
2482 char *pszDescriptor = (char *)RTMemAllocZ(cbDescriptor);
2483 size_t offDescriptor = 0;
2484
2485 if (!pszDescriptor)
2486 return VERR_NO_MEMORY;
2487
2488 for (unsigned i = 0; i < pImage->Descriptor.cLines; i++)
2489 {
2490 const char *psz = pImage->Descriptor.aLines[i];
2491 size_t cb = strlen(psz);
2492
2493 /*
2494 * Increase the descriptor if there is no limit and
2495 * there is not enough room left for this line.
2496 */
2497 if (offDescriptor + cb + 1 > cbDescriptor)
2498 {
2499 if (cbLimit)
2500 {
2501 rc = vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too long in '%s'"), pImage->pszFilename);
2502 break;
2503 }
2504 else
2505 {
2506 char *pszDescriptorNew = NULL;
2507 LogFlow(("Increasing descriptor cache\n"));
2508
2509 pszDescriptorNew = (char *)RTMemRealloc(pszDescriptor, cbDescriptor + cb + 4 * _1K);
2510 if (!pszDescriptorNew)
2511 {
2512 rc = VERR_NO_MEMORY;
2513 break;
2514 }
2515 pszDescriptor = pszDescriptorNew;
2516 cbDescriptor += cb + 4 * _1K;
2517 }
2518 }
2519
2520 if (cb > 0)
2521 {
2522 memcpy(pszDescriptor + offDescriptor, psz, cb);
2523 offDescriptor += cb;
2524 }
2525
2526 memcpy(pszDescriptor + offDescriptor, "\n", 1);
2527 offDescriptor++;
2528 }
2529
2530 if (RT_SUCCESS(rc))
2531 {
2532 *ppvData = pszDescriptor;
2533 *pcbData = offDescriptor;
2534 }
2535 else if (pszDescriptor)
2536 RTMemFree(pszDescriptor);
2537
2538 return rc;
2539}
2540
2541/**
2542 * Internal: write/update the descriptor part of the image.
2543 */
2544static int vmdkWriteDescriptor(PVMDKIMAGE pImage, PVDIOCTX pIoCtx)
2545{
2546 int rc = VINF_SUCCESS;
2547 uint64_t cbLimit;
2548 uint64_t uOffset;
2549 PVMDKFILE pDescFile;
2550 void *pvDescriptor = NULL;
2551 size_t cbDescriptor;
2552
2553 if (pImage->pDescData)
2554 {
2555 /* Separate descriptor file. */
2556 uOffset = 0;
2557 cbLimit = 0;
2558 pDescFile = pImage->pFile;
2559 }
2560 else
2561 {
2562 /* Embedded descriptor file. */
2563 uOffset = VMDK_SECTOR2BYTE(pImage->pExtents[0].uDescriptorSector);
2564 cbLimit = VMDK_SECTOR2BYTE(pImage->pExtents[0].cDescriptorSectors);
2565 pDescFile = pImage->pExtents[0].pFile;
2566 }
2567 /* Bail out if there is no file to write to. */
2568 if (pDescFile == NULL)
2569 return VERR_INVALID_PARAMETER;
2570
2571 rc = vmdkDescriptorPrepare(pImage, cbLimit, &pvDescriptor, &cbDescriptor);
2572 if (RT_SUCCESS(rc))
2573 {
2574 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pDescFile->pStorage,
2575 uOffset, pvDescriptor,
2576 cbLimit ? cbLimit : cbDescriptor,
2577 pIoCtx, NULL, NULL);
2578 if ( RT_FAILURE(rc)
2579 && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
2580 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error writing descriptor in '%s'"), pImage->pszFilename);
2581 }
2582
2583 if (RT_SUCCESS(rc) && !cbLimit)
2584 {
2585 rc = vdIfIoIntFileSetSize(pImage->pIfIo, pDescFile->pStorage, cbDescriptor);
2586 if (RT_FAILURE(rc))
2587 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error truncating descriptor in '%s'"), pImage->pszFilename);
2588 }
2589
2590 if (RT_SUCCESS(rc))
2591 pImage->Descriptor.fDirty = false;
2592
2593 if (pvDescriptor)
2594 RTMemFree(pvDescriptor);
2595 return rc;
2596
2597}
2598
2599/**
2600 * Internal: validate the consistency check values in a binary header.
2601 */
2602static int vmdkValidateHeader(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, const SparseExtentHeader *pHeader)
2603{
2604 int rc = VINF_SUCCESS;
2605 if (RT_LE2H_U32(pHeader->magicNumber) != VMDK_SPARSE_MAGICNUMBER)
2606 {
2607 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect magic in sparse extent header in '%s'"), pExtent->pszFullname);
2608 return rc;
2609 }
2610 if (RT_LE2H_U32(pHeader->version) != 1 && RT_LE2H_U32(pHeader->version) != 3)
2611 {
2612 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: incorrect version in sparse extent header in '%s', not a VMDK 1.0/1.1 conforming file"), pExtent->pszFullname);
2613 return rc;
2614 }
2615 if ( (RT_LE2H_U32(pHeader->flags) & 1)
2616 && ( pHeader->singleEndLineChar != '\n'
2617 || pHeader->nonEndLineChar != ' '
2618 || pHeader->doubleEndLineChar1 != '\r'
2619 || pHeader->doubleEndLineChar2 != '\n') )
2620 {
2621 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: corrupted by CR/LF translation in '%s'"), pExtent->pszFullname);
2622 return rc;
2623 }
2624 if (RT_LE2H_U64(pHeader->descriptorSize) > VMDK_SPARSE_DESCRIPTOR_SIZE_MAX)
2625 {
2626 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor size out of bounds (%llu vs %llu) '%s'"),
2627 pExtent->pszFullname, RT_LE2H_U64(pHeader->descriptorSize), VMDK_SPARSE_DESCRIPTOR_SIZE_MAX);
2628 return rc;
2629 }
2630 return rc;
2631}
2632
2633/**
2634 * Internal: read metadata belonging to an extent with binary header, i.e.
2635 * as found in monolithic files.
2636 */
2637static int vmdkReadBinaryMetaExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
2638 bool fMagicAlreadyRead)
2639{
2640 SparseExtentHeader Header;
2641 int rc;
2642
2643 if (!fMagicAlreadyRead)
2644 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage, 0,
2645 &Header, sizeof(Header));
2646 else
2647 {
2648 Header.magicNumber = RT_H2LE_U32(VMDK_SPARSE_MAGICNUMBER);
2649 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
2650 RT_UOFFSETOF(SparseExtentHeader, version),
2651 &Header.version,
2652 sizeof(Header)
2653 - RT_UOFFSETOF(SparseExtentHeader, version));
2654 }
2655
2656 if (RT_SUCCESS(rc))
2657 {
2658 rc = vmdkValidateHeader(pImage, pExtent, &Header);
2659 if (RT_SUCCESS(rc))
2660 {
2661 uint64_t cbFile = 0;
2662
2663 if ( (RT_LE2H_U32(Header.flags) & RT_BIT(17))
2664 && RT_LE2H_U64(Header.gdOffset) == VMDK_GD_AT_END)
2665 pExtent->fFooter = true;
2666
2667 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2668 || ( pExtent->fFooter
2669 && !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)))
2670 {
2671 rc = vdIfIoIntFileGetSize(pImage->pIfIo, pExtent->pFile->pStorage, &cbFile);
2672 if (RT_FAILURE(rc))
2673 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot get size of '%s'"), pExtent->pszFullname);
2674 }
2675
2676 if (RT_SUCCESS(rc))
2677 {
2678 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2679 pExtent->uAppendPosition = RT_ALIGN_64(cbFile, 512);
2680
2681 if ( pExtent->fFooter
2682 && ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2683 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)))
2684 {
2685 /* Read the footer, which comes before the end-of-stream marker. */
2686 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
2687 cbFile - 2*512, &Header,
2688 sizeof(Header));
2689 if (RT_FAILURE(rc))
2690 {
2691 vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error reading extent footer in '%s'"), pExtent->pszFullname);
2692 rc = VERR_VD_VMDK_INVALID_HEADER;
2693 }
2694
2695 if (RT_SUCCESS(rc))
2696 rc = vmdkValidateHeader(pImage, pExtent, &Header);
2697 /* Prohibit any writes to this extent. */
2698 pExtent->uAppendPosition = 0;
2699 }
2700
2701 if (RT_SUCCESS(rc))
2702 {
2703 pExtent->uVersion = RT_LE2H_U32(Header.version);
2704 pExtent->enmType = VMDKETYPE_HOSTED_SPARSE; /* Just dummy value, changed later. */
2705 pExtent->cSectors = RT_LE2H_U64(Header.capacity);
2706 pExtent->cSectorsPerGrain = RT_LE2H_U64(Header.grainSize);
2707 pExtent->uDescriptorSector = RT_LE2H_U64(Header.descriptorOffset);
2708 pExtent->cDescriptorSectors = RT_LE2H_U64(Header.descriptorSize);
2709 pExtent->cGTEntries = RT_LE2H_U32(Header.numGTEsPerGT);
2710 pExtent->cOverheadSectors = RT_LE2H_U64(Header.overHead);
2711 pExtent->fUncleanShutdown = !!Header.uncleanShutdown;
2712 pExtent->uCompression = RT_LE2H_U16(Header.compressAlgorithm);
2713 if (RT_LE2H_U32(Header.flags) & RT_BIT(1))
2714 {
2715 pExtent->uSectorRGD = RT_LE2H_U64(Header.rgdOffset);
2716 pExtent->uSectorGD = RT_LE2H_U64(Header.gdOffset);
2717 }
2718 else
2719 {
2720 pExtent->uSectorGD = RT_LE2H_U64(Header.gdOffset);
2721 pExtent->uSectorRGD = 0;
2722 }
2723
2724 if (pExtent->uDescriptorSector && !pExtent->cDescriptorSectors)
2725 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2726 N_("VMDK: inconsistent embedded descriptor config in '%s'"), pExtent->pszFullname);
2727
2728 if ( RT_SUCCESS(rc)
2729 && ( pExtent->uSectorGD == VMDK_GD_AT_END
2730 || pExtent->uSectorRGD == VMDK_GD_AT_END)
2731 && ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2732 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)))
2733 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2734 N_("VMDK: cannot resolve grain directory offset in '%s'"), pExtent->pszFullname);
2735
2736 if (RT_SUCCESS(rc))
2737 {
2738 uint64_t cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
2739 if (!cSectorsPerGDE || cSectorsPerGDE > UINT32_MAX)
2740 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2741 N_("VMDK: incorrect grain directory size in '%s'"), pExtent->pszFullname);
2742 else
2743 {
2744 pExtent->cSectorsPerGDE = cSectorsPerGDE;
2745 pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
2746
2747 /* Fix up the number of descriptor sectors, as some flat images have
2748 * really just one, and this causes failures when inserting the UUID
2749 * values and other extra information. */
2750 if (pExtent->cDescriptorSectors != 0 && pExtent->cDescriptorSectors < 4)
2751 {
2752 /* Do it the easy way - just fix it for flat images which have no
2753 * other complicated metadata which needs space too. */
2754 if ( pExtent->uDescriptorSector + 4 < pExtent->cOverheadSectors
2755 && pExtent->cGTEntries * pExtent->cGDEntries == 0)
2756 pExtent->cDescriptorSectors = 4;
2757 }
2758 }
2759 }
2760 }
2761 }
2762 }
2763 }
2764 else
2765 {
2766 vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error reading extent header in '%s'"), pExtent->pszFullname);
2767 rc = VERR_VD_VMDK_INVALID_HEADER;
2768 }
2769
2770 if (RT_FAILURE(rc))
2771 vmdkFreeExtentData(pImage, pExtent, false);
2772
2773 return rc;
2774}
2775
2776/**
2777 * Internal: read additional metadata belonging to an extent. For those
2778 * extents which have no additional metadata just verify the information.
2779 */
2780static int vmdkReadMetaExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
2781{
2782 int rc = VINF_SUCCESS;
2783
2784/* disabled the check as there are too many truncated vmdk images out there */
2785#ifdef VBOX_WITH_VMDK_STRICT_SIZE_CHECK
2786 uint64_t cbExtentSize;
2787 /* The image must be a multiple of a sector in size and contain the data
2788 * area (flat images only). If not, it means the image is at least
2789 * truncated, or even seriously garbled. */
2790 rc = vdIfIoIntFileGetSize(pImage->pIfIo, pExtent->pFile->pStorage, &cbExtentSize);
2791 if (RT_FAILURE(rc))
2792 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting size in '%s'"), pExtent->pszFullname);
2793 else if ( cbExtentSize != RT_ALIGN_64(cbExtentSize, 512)
2794 && (pExtent->enmType != VMDKETYPE_FLAT || pExtent->cNominalSectors + pExtent->uSectorOffset > VMDK_BYTE2SECTOR(cbExtentSize)))
2795 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2796 N_("VMDK: file size is not a multiple of 512 in '%s', file is truncated or otherwise garbled"), pExtent->pszFullname);
2797#endif /* VBOX_WITH_VMDK_STRICT_SIZE_CHECK */
2798 if ( RT_SUCCESS(rc)
2799 && pExtent->enmType == VMDKETYPE_HOSTED_SPARSE)
2800 {
2801 /* The spec says that this must be a power of two and greater than 8,
2802 * but probably they meant not less than 8. */
2803 if ( (pExtent->cSectorsPerGrain & (pExtent->cSectorsPerGrain - 1))
2804 || pExtent->cSectorsPerGrain < 8)
2805 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2806 N_("VMDK: invalid extent grain size %u in '%s'"), pExtent->cSectorsPerGrain, pExtent->pszFullname);
2807 else
2808 {
2809 /* This code requires that a grain table must hold a power of two multiple
2810 * of the number of entries per GT cache entry. */
2811 if ( (pExtent->cGTEntries & (pExtent->cGTEntries - 1))
2812 || pExtent->cGTEntries < VMDK_GT_CACHELINE_SIZE)
2813 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
2814 N_("VMDK: grain table cache size problem in '%s'"), pExtent->pszFullname);
2815 else
2816 {
2817 rc = vmdkAllocStreamBuffers(pImage, pExtent);
2818 if (RT_SUCCESS(rc))
2819 {
2820 /* Prohibit any writes to this streamOptimized extent. */
2821 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
2822 pExtent->uAppendPosition = 0;
2823
2824 if ( !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
2825 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2826 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
2827 rc = vmdkReadGrainDirectory(pImage, pExtent);
2828 else
2829 {
2830 pExtent->uGrainSectorAbs = pExtent->cOverheadSectors;
2831 pExtent->cbGrainStreamRead = 0;
2832 }
2833 }
2834 }
2835 }
2836 }
2837
2838 if (RT_FAILURE(rc))
2839 vmdkFreeExtentData(pImage, pExtent, false);
2840
2841 return rc;
2842}
2843
2844/**
2845 * Internal: write/update the metadata for a sparse extent.
2846 */
2847static int vmdkWriteMetaSparseExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
2848 uint64_t uOffset, PVDIOCTX pIoCtx)
2849{
2850 SparseExtentHeader Header;
2851
2852 memset(&Header, '\0', sizeof(Header));
2853 Header.magicNumber = RT_H2LE_U32(VMDK_SPARSE_MAGICNUMBER);
2854 Header.version = RT_H2LE_U32(pExtent->uVersion);
2855 Header.flags = RT_H2LE_U32(RT_BIT(0));
2856 if (pExtent->pRGD)
2857 Header.flags |= RT_H2LE_U32(RT_BIT(1));
2858 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
2859 Header.flags |= RT_H2LE_U32(RT_BIT(16) | RT_BIT(17));
2860 Header.capacity = RT_H2LE_U64(pExtent->cSectors);
2861 Header.grainSize = RT_H2LE_U64(pExtent->cSectorsPerGrain);
2862 Header.descriptorOffset = RT_H2LE_U64(pExtent->uDescriptorSector);
2863 Header.descriptorSize = RT_H2LE_U64(pExtent->cDescriptorSectors);
2864 Header.numGTEsPerGT = RT_H2LE_U32(pExtent->cGTEntries);
2865 if (pExtent->fFooter && uOffset == 0)
2866 {
2867 if (pExtent->pRGD)
2868 {
2869 Assert(pExtent->uSectorRGD);
2870 Header.rgdOffset = RT_H2LE_U64(VMDK_GD_AT_END);
2871 Header.gdOffset = RT_H2LE_U64(VMDK_GD_AT_END);
2872 }
2873 else
2874 Header.gdOffset = RT_H2LE_U64(VMDK_GD_AT_END);
2875 }
2876 else
2877 {
2878 if (pExtent->pRGD)
2879 {
2880 Assert(pExtent->uSectorRGD);
2881 Header.rgdOffset = RT_H2LE_U64(pExtent->uSectorRGD);
2882 Header.gdOffset = RT_H2LE_U64(pExtent->uSectorGD);
2883 }
2884 else
2885 Header.gdOffset = RT_H2LE_U64(pExtent->uSectorGD);
2886 }
2887 Header.overHead = RT_H2LE_U64(pExtent->cOverheadSectors);
2888 Header.uncleanShutdown = pExtent->fUncleanShutdown;
2889 Header.singleEndLineChar = '\n';
2890 Header.nonEndLineChar = ' ';
2891 Header.doubleEndLineChar1 = '\r';
2892 Header.doubleEndLineChar2 = '\n';
2893 Header.compressAlgorithm = RT_H2LE_U16(pExtent->uCompression);
2894
2895 int rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
2896 uOffset, &Header, sizeof(Header),
2897 pIoCtx, NULL, NULL);
2898 if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
2899 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error writing extent header in '%s'"), pExtent->pszFullname);
2900 return rc;
2901}
2902
2903/**
2904 * Internal: free the buffers used for streamOptimized images.
2905 */
2906static void vmdkFreeStreamBuffers(PVMDKEXTENT pExtent)
2907{
2908 if (pExtent->pvCompGrain)
2909 {
2910 RTMemFree(pExtent->pvCompGrain);
2911 pExtent->pvCompGrain = NULL;
2912 }
2913 if (pExtent->pvGrain)
2914 {
2915 RTMemFree(pExtent->pvGrain);
2916 pExtent->pvGrain = NULL;
2917 }
2918}
2919
2920/**
2921 * Internal: free the memory used by the extent data structure, optionally
2922 * deleting the referenced files.
2923 *
2924 * @returns VBox status code.
2925 * @param pImage Pointer to the image instance data.
2926 * @param pExtent The extent to free.
2927 * @param fDelete Flag whether to delete the backing storage.
2928 */
2929static int vmdkFreeExtentData(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
2930 bool fDelete)
2931{
2932 int rc = VINF_SUCCESS;
2933
2934 vmdkFreeGrainDirectory(pExtent);
2935 if (pExtent->pDescData)
2936 {
2937 RTMemFree(pExtent->pDescData);
2938 pExtent->pDescData = NULL;
2939 }
2940 if (pExtent->pFile != NULL)
2941 {
2942 /* Do not delete raw extents, these have full and base names equal. */
2943 rc = vmdkFileClose(pImage, &pExtent->pFile,
2944 fDelete
2945 && pExtent->pszFullname
2946 && pExtent->pszBasename
2947 && strcmp(pExtent->pszFullname, pExtent->pszBasename));
2948 }
2949 if (pExtent->pszBasename)
2950 {
2951 RTMemTmpFree((void *)pExtent->pszBasename);
2952 pExtent->pszBasename = NULL;
2953 }
2954 if (pExtent->pszFullname)
2955 {
2956 RTStrFree((char *)(void *)pExtent->pszFullname);
2957 pExtent->pszFullname = NULL;
2958 }
2959 vmdkFreeStreamBuffers(pExtent);
2960
2961 return rc;
2962}
2963
2964/**
2965 * Internal: allocate grain table cache if necessary for this image.
2966 */
2967static int vmdkAllocateGrainTableCache(PVMDKIMAGE pImage)
2968{
2969 PVMDKEXTENT pExtent;
2970
2971 /* Allocate grain table cache if any sparse extent is present. */
2972 for (unsigned i = 0; i < pImage->cExtents; i++)
2973 {
2974 pExtent = &pImage->pExtents[i];
2975 if (pExtent->enmType == VMDKETYPE_HOSTED_SPARSE)
2976 {
2977 /* Allocate grain table cache. */
2978 pImage->pGTCache = (PVMDKGTCACHE)RTMemAllocZ(sizeof(VMDKGTCACHE));
2979 if (!pImage->pGTCache)
2980 return VERR_NO_MEMORY;
2981 for (unsigned j = 0; j < VMDK_GT_CACHE_SIZE; j++)
2982 {
2983 PVMDKGTCACHEENTRY pGCE = &pImage->pGTCache->aGTCache[j];
2984 pGCE->uExtent = UINT32_MAX;
2985 }
2986 pImage->pGTCache->cEntries = VMDK_GT_CACHE_SIZE;
2987 break;
2988 }
2989 }
2990
2991 return VINF_SUCCESS;
2992}
2993
2994/**
2995 * Internal: allocate the given number of extents.
2996 */
2997static int vmdkCreateExtents(PVMDKIMAGE pImage, unsigned cExtents)
2998{
2999 int rc = VINF_SUCCESS;
3000 PVMDKEXTENT pExtents = (PVMDKEXTENT)RTMemAllocZ(cExtents * sizeof(VMDKEXTENT));
3001 if (pExtents)
3002 {
3003 for (unsigned i = 0; i < cExtents; i++)
3004 {
3005 pExtents[i].pFile = NULL;
3006 pExtents[i].pszBasename = NULL;
3007 pExtents[i].pszFullname = NULL;
3008 pExtents[i].pGD = NULL;
3009 pExtents[i].pRGD = NULL;
3010 pExtents[i].pDescData = NULL;
3011 pExtents[i].uVersion = 1;
3012 pExtents[i].uCompression = VMDK_COMPRESSION_NONE;
3013 pExtents[i].uExtent = i;
3014 pExtents[i].pImage = pImage;
3015 }
3016 pImage->pExtents = pExtents;
3017 pImage->cExtents = cExtents;
3018 }
3019 else
3020 rc = VERR_NO_MEMORY;
3021
3022 return rc;
3023}
3024
3025/**
3026 * Reads and processes the descriptor embedded in sparse images.
3027 *
3028 * @returns VBox status code.
3029 * @param pImage VMDK image instance.
3030 * @param pFile The sparse file handle.
3031 */
3032static int vmdkDescriptorReadSparse(PVMDKIMAGE pImage, PVMDKFILE pFile)
3033{
3034 /* It's a hosted single-extent image. */
3035 int rc = vmdkCreateExtents(pImage, 1);
3036 if (RT_SUCCESS(rc))
3037 {
3038 /* The opened file is passed to the extent. No separate descriptor
3039 * file, so no need to keep anything open for the image. */
3040 PVMDKEXTENT pExtent = &pImage->pExtents[0];
3041 pExtent->pFile = pFile;
3042 pImage->pFile = NULL;
3043 pExtent->pszFullname = RTPathAbsDup(pImage->pszFilename);
3044 if (RT_LIKELY(pExtent->pszFullname))
3045 {
3046 /* As we're dealing with a monolithic image here, there must
3047 * be a descriptor embedded in the image file. */
3048 rc = vmdkReadBinaryMetaExtent(pImage, pExtent, true /* fMagicAlreadyRead */);
3049 if ( RT_SUCCESS(rc)
3050 && pExtent->uDescriptorSector
3051 && pExtent->cDescriptorSectors)
3052 {
3053 /* HACK: extend the descriptor if it is unusually small and it fits in
3054 * the unused space after the image header. Allows opening VMDK files
3055 * with extremely small descriptor in read/write mode.
3056 *
3057 * The previous version introduced a possible regression for VMDK stream
3058 * optimized images from VMware which tend to have only a single sector sized
3059 * descriptor. Increasing the descriptor size resulted in adding the various uuid
3060 * entries required to make it work with VBox but for stream optimized images
3061 * the updated binary header wasn't written to the disk creating a mismatch
3062 * between advertised and real descriptor size.
3063 *
3064 * The descriptor size will be increased even if opened readonly now if there
3065 * enough room but the new value will not be written back to the image.
3066 */
3067 if ( pExtent->cDescriptorSectors < 3
3068 && (int64_t)pExtent->uSectorGD - pExtent->uDescriptorSector >= 4
3069 && (!pExtent->uSectorRGD || (int64_t)pExtent->uSectorRGD - pExtent->uDescriptorSector >= 4))
3070 {
3071 uint64_t cDescriptorSectorsOld = pExtent->cDescriptorSectors;
3072
3073 pExtent->cDescriptorSectors = 4;
3074 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
3075 {
3076 /*
3077 * Update the on disk number now to make sure we don't introduce inconsistencies
3078 * in case of stream optimized images from VMware where the descriptor is just
3079 * one sector big (the binary header is not written to disk for complete
3080 * stream optimized images in vmdkFlushImage()).
3081 */
3082 uint64_t u64DescSizeNew = RT_H2LE_U64(pExtent->cDescriptorSectors);
3083 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pFile->pStorage,
3084 RT_UOFFSETOF(SparseExtentHeader, descriptorSize),
3085 &u64DescSizeNew, sizeof(u64DescSizeNew));
3086 if (RT_FAILURE(rc))
3087 {
3088 LogFlowFunc(("Increasing the descriptor size failed with %Rrc\n", rc));
3089 /* Restore the old size and carry on. */
3090 pExtent->cDescriptorSectors = cDescriptorSectorsOld;
3091 }
3092 }
3093 }
3094 /* Read the descriptor from the extent. */
3095 pExtent->pDescData = (char *)RTMemAllocZ(VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
3096 if (RT_LIKELY(pExtent->pDescData))
3097 {
3098 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
3099 VMDK_SECTOR2BYTE(pExtent->uDescriptorSector),
3100 pExtent->pDescData,
3101 VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
3102 if (RT_SUCCESS(rc))
3103 {
3104 rc = vmdkParseDescriptor(pImage, pExtent->pDescData,
3105 VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
3106 if ( RT_SUCCESS(rc)
3107 && ( !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
3108 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)))
3109 {
3110 rc = vmdkReadMetaExtent(pImage, pExtent);
3111 if (RT_SUCCESS(rc))
3112 {
3113 /* Mark the extent as unclean if opened in read-write mode. */
3114 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
3115 && !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
3116 {
3117 pExtent->fUncleanShutdown = true;
3118 pExtent->fMetaDirty = true;
3119 }
3120 }
3121 }
3122 else if (RT_SUCCESS(rc))
3123 rc = VERR_NOT_SUPPORTED;
3124 }
3125 else
3126 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: read error for descriptor in '%s'"), pExtent->pszFullname);
3127 }
3128 else
3129 rc = VERR_NO_MEMORY;
3130 }
3131 else if (RT_SUCCESS(rc))
3132 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image without descriptor in '%s'"), pImage->pszFilename);
3133 }
3134 else
3135 rc = VERR_NO_MEMORY;
3136 }
3137
3138 return rc;
3139}
3140
3141/**
3142 * Reads the descriptor from a pure text file.
3143 *
3144 * @returns VBox status code.
3145 * @param pImage VMDK image instance.
3146 * @param pFile The descriptor file handle.
3147 */
3148static int vmdkDescriptorReadAscii(PVMDKIMAGE pImage, PVMDKFILE pFile)
3149{
3150 /* Allocate at least 10K, and make sure that there is 5K free space
3151 * in case new entries need to be added to the descriptor. Never
3152 * allocate more than 128K, because that's no valid descriptor file
3153 * and will result in the correct "truncated read" error handling. */
3154 uint64_t cbFileSize;
3155 int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pFile->pStorage, &cbFileSize);
3156 if ( RT_SUCCESS(rc)
3157 && cbFileSize >= 50)
3158 {
3159 uint64_t cbSize = cbFileSize;
3160 if (cbSize % VMDK_SECTOR2BYTE(10))
3161 cbSize += VMDK_SECTOR2BYTE(20) - cbSize % VMDK_SECTOR2BYTE(10);
3162 else
3163 cbSize += VMDK_SECTOR2BYTE(10);
3164 cbSize = RT_MIN(cbSize, _128K);
3165 pImage->cbDescAlloc = RT_MAX(VMDK_SECTOR2BYTE(20), cbSize);
3166 pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
3167 if (RT_LIKELY(pImage->pDescData))
3168 {
3169 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pFile->pStorage, 0, pImage->pDescData,
3170 RT_MIN(pImage->cbDescAlloc, cbFileSize));
3171 if (RT_SUCCESS(rc))
3172 {
3173#if 0 /** @todo Revisit */
3174 cbRead += sizeof(u32Magic);
3175 if (cbRead == pImage->cbDescAlloc)
3176 {
3177 /* Likely the read is truncated. Better fail a bit too early
3178 * (normally the descriptor is much smaller than our buffer). */
3179 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: cannot read descriptor in '%s'"), pImage->pszFilename);
3180 goto out;
3181 }
3182#endif
3183 rc = vmdkParseDescriptor(pImage, pImage->pDescData,
3184 pImage->cbDescAlloc);
3185 if (RT_SUCCESS(rc))
3186 {
3187 for (unsigned i = 0; i < pImage->cExtents && RT_SUCCESS(rc); i++)
3188 {
3189 PVMDKEXTENT pExtent = &pImage->pExtents[i];
3190 if (pExtent->pszBasename)
3191 {
3192 /* Hack to figure out whether the specified name in the
3193 * extent descriptor is absolute. Doesn't always work, but
3194 * should be good enough for now. */
3195 char *pszFullname;
3196 /** @todo implement proper path absolute check. */
3197 if (pExtent->pszBasename[0] == RTPATH_SLASH)
3198 {
3199 pszFullname = RTStrDup(pExtent->pszBasename);
3200 if (!pszFullname)
3201 {
3202 rc = VERR_NO_MEMORY;
3203 break;
3204 }
3205 }
3206 else
3207 {
3208 char *pszDirname = RTStrDup(pImage->pszFilename);
3209 if (!pszDirname)
3210 {
3211 rc = VERR_NO_MEMORY;
3212 break;
3213 }
3214 RTPathStripFilename(pszDirname);
3215 pszFullname = RTPathJoinA(pszDirname, pExtent->pszBasename);
3216 RTStrFree(pszDirname);
3217 if (!pszFullname)
3218 {
3219 rc = VERR_NO_STR_MEMORY;
3220 break;
3221 }
3222 }
3223 pExtent->pszFullname = pszFullname;
3224 }
3225 else
3226 pExtent->pszFullname = NULL;
3227
3228 unsigned uOpenFlags = pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0);
3229 switch (pExtent->enmType)
3230 {
3231 case VMDKETYPE_HOSTED_SPARSE:
3232 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3233 VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
3234 if (RT_FAILURE(rc))
3235 {
3236 /* Do NOT signal an appropriate error here, as the VD
3237 * layer has the choice of retrying the open if it
3238 * failed. */
3239 break;
3240 }
3241 rc = vmdkReadBinaryMetaExtent(pImage, pExtent,
3242 false /* fMagicAlreadyRead */);
3243 if (RT_FAILURE(rc))
3244 break;
3245 rc = vmdkReadMetaExtent(pImage, pExtent);
3246 if (RT_FAILURE(rc))
3247 break;
3248
3249 /* Mark extent as unclean if opened in read-write mode. */
3250 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
3251 {
3252 pExtent->fUncleanShutdown = true;
3253 pExtent->fMetaDirty = true;
3254 }
3255 break;
3256 case VMDKETYPE_VMFS:
3257 case VMDKETYPE_FLAT:
3258 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3259 VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
3260 if (RT_FAILURE(rc))
3261 {
3262 /* Do NOT signal an appropriate error here, as the VD
3263 * layer has the choice of retrying the open if it
3264 * failed. */
3265 break;
3266 }
3267 break;
3268 case VMDKETYPE_ZERO:
3269 /* Nothing to do. */
3270 break;
3271 default:
3272 AssertMsgFailed(("unknown vmdk extent type %d\n", pExtent->enmType));
3273 }
3274 }
3275 }
3276 }
3277 else
3278 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: read error for descriptor in '%s'"), pImage->pszFilename);
3279 }
3280 else
3281 rc = VERR_NO_MEMORY;
3282 }
3283 else if (RT_SUCCESS(rc))
3284 rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor in '%s' is too short"), pImage->pszFilename);
3285
3286 return rc;
3287}
3288
3289/**
3290 * Read and process the descriptor based on the image type.
3291 *
3292 * @returns VBox status code.
3293 * @param pImage VMDK image instance.
3294 * @param pFile VMDK file handle.
3295 */
3296static int vmdkDescriptorRead(PVMDKIMAGE pImage, PVMDKFILE pFile)
3297{
3298 uint32_t u32Magic;
3299
3300 /* Read magic (if present). */
3301 int rc = vdIfIoIntFileReadSync(pImage->pIfIo, pFile->pStorage, 0,
3302 &u32Magic, sizeof(u32Magic));
3303 if (RT_SUCCESS(rc))
3304 {
3305 /* Handle the file according to its magic number. */
3306 if (RT_LE2H_U32(u32Magic) == VMDK_SPARSE_MAGICNUMBER)
3307 rc = vmdkDescriptorReadSparse(pImage, pFile);
3308 else
3309 rc = vmdkDescriptorReadAscii(pImage, pFile);
3310 }
3311 else
3312 {
3313 vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error reading the magic number in '%s'"), pImage->pszFilename);
3314 rc = VERR_VD_VMDK_INVALID_HEADER;
3315 }
3316
3317 return rc;
3318}
3319
3320/**
3321 * Internal: Open an image, constructing all necessary data structures.
3322 */
3323static int vmdkOpenImage(PVMDKIMAGE pImage, unsigned uOpenFlags)
3324{
3325 pImage->uOpenFlags = uOpenFlags;
3326 pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
3327 pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
3328 AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
3329
3330 /*
3331 * Open the image.
3332 * We don't have to check for asynchronous access because
3333 * we only support raw access and the opened file is a description
3334 * file were no data is stored.
3335 */
3336 PVMDKFILE pFile;
3337 int rc = vmdkFileOpen(pImage, &pFile, NULL, pImage->pszFilename,
3338 VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
3339 if (RT_SUCCESS(rc))
3340 {
3341 pImage->pFile = pFile;
3342
3343 rc = vmdkDescriptorRead(pImage, pFile);
3344 if (RT_SUCCESS(rc))
3345 {
3346 /* Determine PCHS geometry if not set. */
3347 if (pImage->PCHSGeometry.cCylinders == 0)
3348 {
3349 uint64_t cCylinders = VMDK_BYTE2SECTOR(pImage->cbSize)
3350 / pImage->PCHSGeometry.cHeads
3351 / pImage->PCHSGeometry.cSectors;
3352 pImage->PCHSGeometry.cCylinders = (unsigned)RT_MIN(cCylinders, 16383);
3353 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
3354 && !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
3355 {
3356 rc = vmdkDescSetPCHSGeometry(pImage, &pImage->PCHSGeometry);
3357 AssertRC(rc);
3358 }
3359 }
3360
3361 /* Update the image metadata now in case has changed. */
3362 rc = vmdkFlushImage(pImage, NULL);
3363 if (RT_SUCCESS(rc))
3364 {
3365 /* Figure out a few per-image constants from the extents. */
3366 pImage->cbSize = 0;
3367 for (unsigned i = 0; i < pImage->cExtents; i++)
3368 {
3369 PVMDKEXTENT pExtent = &pImage->pExtents[i];
3370 if (pExtent->enmType == VMDKETYPE_HOSTED_SPARSE)
3371 {
3372 /* Here used to be a check whether the nominal size of an extent
3373 * is a multiple of the grain size. The spec says that this is
3374 * always the case, but unfortunately some files out there in the
3375 * wild violate the spec (e.g. ReactOS 0.3.1). */
3376 }
3377 else if ( pExtent->enmType == VMDKETYPE_FLAT
3378 || pExtent->enmType == VMDKETYPE_ZERO)
3379 pImage->uImageFlags |= VD_IMAGE_FLAGS_FIXED;
3380
3381 pImage->cbSize += VMDK_SECTOR2BYTE(pExtent->cNominalSectors);
3382 }
3383
3384 if ( !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
3385 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
3386 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
3387 rc = vmdkAllocateGrainTableCache(pImage);
3388 }
3389 }
3390 }
3391 /* else: Do NOT signal an appropriate error here, as the VD layer has the
3392 * choice of retrying the open if it failed. */
3393
3394 if (RT_SUCCESS(rc))
3395 {
3396 PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
3397 pImage->RegionList.fFlags = 0;
3398 pImage->RegionList.cRegions = 1;
3399
3400 pRegion->offRegion = 0; /* Disk start. */
3401 pRegion->cbBlock = 512;
3402 pRegion->enmDataForm = VDREGIONDATAFORM_RAW;
3403 pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
3404 pRegion->cbData = 512;
3405 pRegion->cbMetadata = 0;
3406 pRegion->cRegionBlocksOrBytes = pImage->cbSize;
3407 }
3408 else
3409 vmdkFreeImage(pImage, false, false /*fFlush*/); /* Don't try to flush anything if opening failed. */
3410 return rc;
3411}
3412
3413/**
3414 * Internal: create VMDK images for raw disk/partition access.
3415 */
3416static int vmdkCreateRawImage(PVMDKIMAGE pImage, const PVDISKRAW pRaw,
3417 uint64_t cbSize)
3418{
3419 int rc = VINF_SUCCESS;
3420 PVMDKEXTENT pExtent;
3421
3422 if (pRaw->uFlags & VDISKRAW_DISK)
3423 {
3424 /* Full raw disk access. This requires setting up a descriptor
3425 * file and open the (flat) raw disk. */
3426 rc = vmdkCreateExtents(pImage, 1);
3427 if (RT_FAILURE(rc))
3428 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
3429 pExtent = &pImage->pExtents[0];
3430 /* Create raw disk descriptor file. */
3431 rc = vmdkFileOpen(pImage, &pImage->pFile, NULL, pImage->pszFilename,
3432 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
3433 true /* fCreate */));
3434 if (RT_FAILURE(rc))
3435 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pImage->pszFilename);
3436
3437 /* Set up basename for extent description. Cannot use StrDup. */
3438 size_t cbBasename = strlen(pRaw->pszRawDisk) + 1;
3439 char *pszBasename = (char *)RTMemTmpAlloc(cbBasename);
3440 if (!pszBasename)
3441 return VERR_NO_MEMORY;
3442 memcpy(pszBasename, pRaw->pszRawDisk, cbBasename);
3443 pExtent->pszBasename = pszBasename;
3444 /* For raw disks the full name is identical to the base name. */
3445 pExtent->pszFullname = RTStrDup(pszBasename);
3446 if (!pExtent->pszFullname)
3447 return VERR_NO_MEMORY;
3448 pExtent->enmType = VMDKETYPE_FLAT;
3449 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
3450 pExtent->uSectorOffset = 0;
3451 pExtent->enmAccess = (pRaw->uFlags & VDISKRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
3452 pExtent->fMetaDirty = false;
3453
3454 /* Open flat image, the raw disk. */
3455 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3456 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0),
3457 false /* fCreate */));
3458 if (RT_FAILURE(rc))
3459 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not open raw disk file '%s'"), pExtent->pszFullname);
3460 }
3461 else
3462 {
3463 /* Raw partition access. This requires setting up a descriptor
3464 * file, write the partition information to a flat extent and
3465 * open all the (flat) raw disk partitions. */
3466
3467 /* First pass over the partition data areas to determine how many
3468 * extents we need. One data area can require up to 2 extents, as
3469 * it might be necessary to skip over unpartitioned space. */
3470 unsigned cExtents = 0;
3471 uint64_t uStart = 0;
3472 for (unsigned i = 0; i < pRaw->cPartDescs; i++)
3473 {
3474 PVDISKRAWPARTDESC pPart = &pRaw->pPartDescs[i];
3475 if (uStart > pPart->uStart)
3476 return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
3477 N_("VMDK: incorrect partition data area ordering set up by the caller in '%s'"), pImage->pszFilename);
3478
3479 if (uStart < pPart->uStart)
3480 cExtents++;
3481 uStart = pPart->uStart + pPart->cbData;
3482 cExtents++;
3483 }
3484 /* Another extent for filling up the rest of the image. */
3485 if (uStart != cbSize)
3486 cExtents++;
3487
3488 rc = vmdkCreateExtents(pImage, cExtents);
3489 if (RT_FAILURE(rc))
3490 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
3491
3492 /* Create raw partition descriptor file. */
3493 rc = vmdkFileOpen(pImage, &pImage->pFile, NULL, pImage->pszFilename,
3494 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
3495 true /* fCreate */));
3496 if (RT_FAILURE(rc))
3497 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pImage->pszFilename);
3498
3499 /* Create base filename for the partition table extent. */
3500 /** @todo remove fixed buffer without creating memory leaks. */
3501 char pszPartition[1024];
3502 const char *pszBase = RTPathFilename(pImage->pszFilename);
3503 const char *pszSuff = RTPathSuffix(pszBase);
3504 if (pszSuff == NULL)
3505 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: invalid filename '%s'"), pImage->pszFilename);
3506 char *pszBaseBase = RTStrDup(pszBase);
3507 if (!pszBaseBase)
3508 return VERR_NO_MEMORY;
3509 RTPathStripSuffix(pszBaseBase);
3510 RTStrPrintf(pszPartition, sizeof(pszPartition), "%s-pt%s",
3511 pszBaseBase, pszSuff);
3512 RTStrFree(pszBaseBase);
3513
3514 /* Second pass over the partitions, now define all extents. */
3515 uint64_t uPartOffset = 0;
3516 cExtents = 0;
3517 uStart = 0;
3518 for (unsigned i = 0; i < pRaw->cPartDescs; i++)
3519 {
3520 PVDISKRAWPARTDESC pPart = &pRaw->pPartDescs[i];
3521 pExtent = &pImage->pExtents[cExtents++];
3522
3523 if (uStart < pPart->uStart)
3524 {
3525 pExtent->pszBasename = NULL;
3526 pExtent->pszFullname = NULL;
3527 pExtent->enmType = VMDKETYPE_ZERO;
3528 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->uStart - uStart);
3529 pExtent->uSectorOffset = 0;
3530 pExtent->enmAccess = VMDKACCESS_READWRITE;
3531 pExtent->fMetaDirty = false;
3532 /* go to next extent */
3533 pExtent = &pImage->pExtents[cExtents++];
3534 }
3535 uStart = pPart->uStart + pPart->cbData;
3536
3537 if (pPart->pvPartitionData)
3538 {
3539 /* Set up basename for extent description. Can't use StrDup. */
3540 size_t cbBasename = strlen(pszPartition) + 1;
3541 char *pszBasename = (char *)RTMemTmpAlloc(cbBasename);
3542 if (!pszBasename)
3543 return VERR_NO_MEMORY;
3544 memcpy(pszBasename, pszPartition, cbBasename);
3545 pExtent->pszBasename = pszBasename;
3546
3547 /* Set up full name for partition extent. */
3548 char *pszDirname = RTStrDup(pImage->pszFilename);
3549 if (!pszDirname)
3550 return VERR_NO_STR_MEMORY;
3551 RTPathStripFilename(pszDirname);
3552 char *pszFullname = RTPathJoinA(pszDirname, pExtent->pszBasename);
3553 RTStrFree(pszDirname);
3554 if (!pszFullname)
3555 return VERR_NO_STR_MEMORY;
3556 pExtent->pszFullname = pszFullname;
3557 pExtent->enmType = VMDKETYPE_FLAT;
3558 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
3559 pExtent->uSectorOffset = uPartOffset;
3560 pExtent->enmAccess = VMDKACCESS_READWRITE;
3561 pExtent->fMetaDirty = false;
3562
3563 /* Create partition table flat image. */
3564 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3565 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0),
3566 true /* fCreate */));
3567 if (RT_FAILURE(rc))
3568 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new partition data file '%s'"), pExtent->pszFullname);
3569 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
3570 VMDK_SECTOR2BYTE(uPartOffset),
3571 pPart->pvPartitionData,
3572 pPart->cbData);
3573 if (RT_FAILURE(rc))
3574 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not write partition data to '%s'"), pExtent->pszFullname);
3575 uPartOffset += VMDK_BYTE2SECTOR(pPart->cbData);
3576 }
3577 else
3578 {
3579 if (pPart->pszRawDevice)
3580 {
3581 /* Set up basename for extent descr. Can't use StrDup. */
3582 size_t cbBasename = strlen(pPart->pszRawDevice) + 1;
3583 char *pszBasename = (char *)RTMemTmpAlloc(cbBasename);
3584 if (!pszBasename)
3585 return VERR_NO_MEMORY;
3586 memcpy(pszBasename, pPart->pszRawDevice, cbBasename);
3587 pExtent->pszBasename = pszBasename;
3588 /* For raw disks full name is identical to base name. */
3589 pExtent->pszFullname = RTStrDup(pszBasename);
3590 if (!pExtent->pszFullname)
3591 return VERR_NO_MEMORY;
3592 pExtent->enmType = VMDKETYPE_FLAT;
3593 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
3594 pExtent->uSectorOffset = VMDK_BYTE2SECTOR(pPart->uStartOffset);
3595 pExtent->enmAccess = (pPart->uFlags & VDISKRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
3596 pExtent->fMetaDirty = false;
3597
3598 /* Open flat image, the raw partition. */
3599 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3600 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0),
3601 false /* fCreate */));
3602 if (RT_FAILURE(rc))
3603 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not open raw partition file '%s'"), pExtent->pszFullname);
3604 }
3605 else
3606 {
3607 pExtent->pszBasename = NULL;
3608 pExtent->pszFullname = NULL;
3609 pExtent->enmType = VMDKETYPE_ZERO;
3610 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
3611 pExtent->uSectorOffset = 0;
3612 pExtent->enmAccess = VMDKACCESS_READWRITE;
3613 pExtent->fMetaDirty = false;
3614 }
3615 }
3616 }
3617 /* Another extent for filling up the rest of the image. */
3618 if (uStart != cbSize)
3619 {
3620 pExtent = &pImage->pExtents[cExtents++];
3621 pExtent->pszBasename = NULL;
3622 pExtent->pszFullname = NULL;
3623 pExtent->enmType = VMDKETYPE_ZERO;
3624 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize - uStart);
3625 pExtent->uSectorOffset = 0;
3626 pExtent->enmAccess = VMDKACCESS_READWRITE;
3627 pExtent->fMetaDirty = false;
3628 }
3629 }
3630
3631 rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
3632 (pRaw->uFlags & VDISKRAW_DISK) ?
3633 "fullDevice" : "partitionedDevice");
3634 if (RT_FAILURE(rc))
3635 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
3636 return rc;
3637}
3638
3639/**
3640 * Internal: create a regular (i.e. file-backed) VMDK image.
3641 */
3642static int vmdkCreateRegularImage(PVMDKIMAGE pImage, uint64_t cbSize,
3643 unsigned uImageFlags, PVDINTERFACEPROGRESS pIfProgress,
3644 unsigned uPercentStart, unsigned uPercentSpan)
3645{
3646 int rc = VINF_SUCCESS;
3647 unsigned cExtents = 1;
3648 uint64_t cbOffset = 0;
3649 uint64_t cbRemaining = cbSize;
3650
3651 if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
3652 {
3653 cExtents = cbSize / VMDK_2G_SPLIT_SIZE;
3654 /* Do proper extent computation: need one smaller extent if the total
3655 * size isn't evenly divisible by the split size. */
3656 if (cbSize % VMDK_2G_SPLIT_SIZE)
3657 cExtents++;
3658 }
3659 rc = vmdkCreateExtents(pImage, cExtents);
3660 if (RT_FAILURE(rc))
3661 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
3662
3663 /* Basename strings needed for constructing the extent names. */
3664 char *pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
3665 AssertPtr(pszBasenameSubstr);
3666 size_t cbBasenameSubstr = strlen(pszBasenameSubstr) + 1;
3667
3668 /* Create separate descriptor file if necessary. */
3669 if (cExtents != 1 || (uImageFlags & VD_IMAGE_FLAGS_FIXED))
3670 {
3671 rc = vmdkFileOpen(pImage, &pImage->pFile, NULL, pImage->pszFilename,
3672 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
3673 true /* fCreate */));
3674 if (RT_FAILURE(rc))
3675 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new sparse descriptor file '%s'"), pImage->pszFilename);
3676 }
3677 else
3678 pImage->pFile = NULL;
3679
3680 /* Set up all extents. */
3681 for (unsigned i = 0; i < cExtents; i++)
3682 {
3683 PVMDKEXTENT pExtent = &pImage->pExtents[i];
3684 uint64_t cbExtent = cbRemaining;
3685
3686 /* Set up fullname/basename for extent description. Cannot use StrDup
3687 * for basename, as it is not guaranteed that the memory can be freed
3688 * with RTMemTmpFree, which must be used as in other code paths
3689 * StrDup is not usable. */
3690 if (cExtents == 1 && !(uImageFlags & VD_IMAGE_FLAGS_FIXED))
3691 {
3692 char *pszBasename = (char *)RTMemTmpAlloc(cbBasenameSubstr);
3693 if (!pszBasename)
3694 return VERR_NO_MEMORY;
3695 memcpy(pszBasename, pszBasenameSubstr, cbBasenameSubstr);
3696 pExtent->pszBasename = pszBasename;
3697 }
3698 else
3699 {
3700 char *pszBasenameSuff = RTPathSuffix(pszBasenameSubstr);
3701 char *pszBasenameBase = RTStrDup(pszBasenameSubstr);
3702 RTPathStripSuffix(pszBasenameBase);
3703 char *pszTmp;
3704 size_t cbTmp;
3705 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
3706 {
3707 if (cExtents == 1)
3708 RTStrAPrintf(&pszTmp, "%s-flat%s", pszBasenameBase,
3709 pszBasenameSuff);
3710 else
3711 RTStrAPrintf(&pszTmp, "%s-f%03d%s", pszBasenameBase,
3712 i+1, pszBasenameSuff);
3713 }
3714 else
3715 RTStrAPrintf(&pszTmp, "%s-s%03d%s", pszBasenameBase, i+1,
3716 pszBasenameSuff);
3717 RTStrFree(pszBasenameBase);
3718 if (!pszTmp)
3719 return VERR_NO_STR_MEMORY;
3720 cbTmp = strlen(pszTmp) + 1;
3721 char *pszBasename = (char *)RTMemTmpAlloc(cbTmp);
3722 if (!pszBasename)
3723 {
3724 RTStrFree(pszTmp);
3725 return VERR_NO_MEMORY;
3726 }
3727 memcpy(pszBasename, pszTmp, cbTmp);
3728 RTStrFree(pszTmp);
3729 pExtent->pszBasename = pszBasename;
3730 if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
3731 cbExtent = RT_MIN(cbRemaining, VMDK_2G_SPLIT_SIZE);
3732 }
3733 char *pszBasedirectory = RTStrDup(pImage->pszFilename);
3734 if (!pszBasedirectory)
3735 return VERR_NO_STR_MEMORY;
3736 RTPathStripFilename(pszBasedirectory);
3737 char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
3738 RTStrFree(pszBasedirectory);
3739 if (!pszFullname)
3740 return VERR_NO_STR_MEMORY;
3741 pExtent->pszFullname = pszFullname;
3742
3743 /* Create file for extent. */
3744 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3745 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
3746 true /* fCreate */));
3747 if (RT_FAILURE(rc))
3748 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
3749 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
3750 {
3751 rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pExtent->pFile->pStorage, cbExtent,
3752 0 /* fFlags */, pIfProgress,
3753 uPercentStart + cbOffset * uPercentSpan / cbSize,
3754 cbExtent * uPercentSpan / cbSize);
3755 if (RT_FAILURE(rc))
3756 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
3757 }
3758
3759 /* Place descriptor file information (where integrated). */
3760 if (cExtents == 1 && !(uImageFlags & VD_IMAGE_FLAGS_FIXED))
3761 {
3762 pExtent->uDescriptorSector = 1;
3763 pExtent->cDescriptorSectors = VMDK_BYTE2SECTOR(pImage->cbDescAlloc);
3764 /* The descriptor is part of the (only) extent. */
3765 pExtent->pDescData = pImage->pDescData;
3766 pImage->pDescData = NULL;
3767 }
3768
3769 if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
3770 {
3771 uint64_t cSectorsPerGDE, cSectorsPerGD;
3772 pExtent->enmType = VMDKETYPE_HOSTED_SPARSE;
3773 pExtent->cSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(cbExtent, _64K));
3774 pExtent->cSectorsPerGrain = VMDK_BYTE2SECTOR(_64K);
3775 pExtent->cGTEntries = 512;
3776 cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
3777 pExtent->cSectorsPerGDE = cSectorsPerGDE;
3778 pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
3779 cSectorsPerGD = (pExtent->cGDEntries + (512 / sizeof(uint32_t) - 1)) / (512 / sizeof(uint32_t));
3780 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
3781 {
3782 /* The spec says version is 1 for all VMDKs, but the vast
3783 * majority of streamOptimized VMDKs actually contain
3784 * version 3 - so go with the majority. Both are accepted. */
3785 pExtent->uVersion = 3;
3786 pExtent->uCompression = VMDK_COMPRESSION_DEFLATE;
3787 }
3788 }
3789 else
3790 {
3791 if (uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
3792 pExtent->enmType = VMDKETYPE_VMFS;
3793 else
3794 pExtent->enmType = VMDKETYPE_FLAT;
3795 }
3796
3797 pExtent->enmAccess = VMDKACCESS_READWRITE;
3798 pExtent->fUncleanShutdown = true;
3799 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbExtent);
3800 pExtent->uSectorOffset = 0;
3801 pExtent->fMetaDirty = true;
3802
3803 if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
3804 {
3805 /* fPreAlloc should never be false because VMware can't use such images. */
3806 rc = vmdkCreateGrainDirectory(pImage, pExtent,
3807 RT_MAX( pExtent->uDescriptorSector
3808 + pExtent->cDescriptorSectors,
3809 1),
3810 true /* fPreAlloc */);
3811 if (RT_FAILURE(rc))
3812 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
3813 }
3814
3815 cbOffset += cbExtent;
3816
3817 if (RT_SUCCESS(rc))
3818 vdIfProgress(pIfProgress, uPercentStart + cbOffset * uPercentSpan / cbSize);
3819
3820 cbRemaining -= cbExtent;
3821 }
3822
3823 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
3824 {
3825 /* VirtualBox doesn't care, but VMWare ESX freaks out if the wrong
3826 * controller type is set in an image. */
3827 rc = vmdkDescDDBSetStr(pImage, &pImage->Descriptor, "ddb.adapterType", "lsilogic");
3828 if (RT_FAILURE(rc))
3829 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set controller type to lsilogic in '%s'"), pImage->pszFilename);
3830 }
3831
3832 const char *pszDescType = NULL;
3833 if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
3834 {
3835 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
3836 pszDescType = "vmfs";
3837 else
3838 pszDescType = (cExtents == 1)
3839 ? "monolithicFlat" : "twoGbMaxExtentFlat";
3840 }
3841 else
3842 {
3843 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
3844 pszDescType = "streamOptimized";
3845 else
3846 {
3847 pszDescType = (cExtents == 1)
3848 ? "monolithicSparse" : "twoGbMaxExtentSparse";
3849 }
3850 }
3851 rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
3852 pszDescType);
3853 if (RT_FAILURE(rc))
3854 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
3855 return rc;
3856}
3857
3858/**
3859 * Internal: Create a real stream optimized VMDK using only linear writes.
3860 */
3861static int vmdkCreateStreamImage(PVMDKIMAGE pImage, uint64_t cbSize)
3862{
3863 int rc = vmdkCreateExtents(pImage, 1);
3864 if (RT_FAILURE(rc))
3865 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
3866
3867 /* Basename strings needed for constructing the extent names. */
3868 const char *pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
3869 AssertPtr(pszBasenameSubstr);
3870 size_t cbBasenameSubstr = strlen(pszBasenameSubstr) + 1;
3871
3872 /* No separate descriptor file. */
3873 pImage->pFile = NULL;
3874
3875 /* Set up all extents. */
3876 PVMDKEXTENT pExtent = &pImage->pExtents[0];
3877
3878 /* Set up fullname/basename for extent description. Cannot use StrDup
3879 * for basename, as it is not guaranteed that the memory can be freed
3880 * with RTMemTmpFree, which must be used as in other code paths
3881 * StrDup is not usable. */
3882 char *pszBasename = (char *)RTMemTmpAlloc(cbBasenameSubstr);
3883 if (!pszBasename)
3884 return VERR_NO_MEMORY;
3885 memcpy(pszBasename, pszBasenameSubstr, cbBasenameSubstr);
3886 pExtent->pszBasename = pszBasename;
3887
3888 char *pszBasedirectory = RTStrDup(pImage->pszFilename);
3889 RTPathStripFilename(pszBasedirectory);
3890 char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
3891 RTStrFree(pszBasedirectory);
3892 if (!pszFullname)
3893 return VERR_NO_STR_MEMORY;
3894 pExtent->pszFullname = pszFullname;
3895
3896 /* Create file for extent. Make it write only, no reading allowed. */
3897 rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
3898 VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
3899 true /* fCreate */)
3900 & ~RTFILE_O_READ);
3901 if (RT_FAILURE(rc))
3902 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
3903
3904 /* Place descriptor file information. */
3905 pExtent->uDescriptorSector = 1;
3906 pExtent->cDescriptorSectors = VMDK_BYTE2SECTOR(pImage->cbDescAlloc);
3907 /* The descriptor is part of the (only) extent. */
3908 pExtent->pDescData = pImage->pDescData;
3909 pImage->pDescData = NULL;
3910
3911 uint64_t cSectorsPerGDE, cSectorsPerGD;
3912 pExtent->enmType = VMDKETYPE_HOSTED_SPARSE;
3913 pExtent->cSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(cbSize, _64K));
3914 pExtent->cSectorsPerGrain = VMDK_BYTE2SECTOR(_64K);
3915 pExtent->cGTEntries = 512;
3916 cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
3917 pExtent->cSectorsPerGDE = cSectorsPerGDE;
3918 pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
3919 cSectorsPerGD = (pExtent->cGDEntries + (512 / sizeof(uint32_t) - 1)) / (512 / sizeof(uint32_t));
3920
3921 /* The spec says version is 1 for all VMDKs, but the vast
3922 * majority of streamOptimized VMDKs actually contain
3923 * version 3 - so go with the majority. Both are accepted. */
3924 pExtent->uVersion = 3;
3925 pExtent->uCompression = VMDK_COMPRESSION_DEFLATE;
3926 pExtent->fFooter = true;
3927
3928 pExtent->enmAccess = VMDKACCESS_READONLY;
3929 pExtent->fUncleanShutdown = false;
3930 pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
3931 pExtent->uSectorOffset = 0;
3932 pExtent->fMetaDirty = true;
3933
3934 /* Create grain directory, without preallocating it straight away. It will
3935 * be constructed on the fly when writing out the data and written when
3936 * closing the image. The end effect is that the full grain directory is
3937 * allocated, which is a requirement of the VMDK specs. */
3938 rc = vmdkCreateGrainDirectory(pImage, pExtent, VMDK_GD_AT_END,
3939 false /* fPreAlloc */);
3940 if (RT_FAILURE(rc))
3941 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
3942
3943 rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
3944 "streamOptimized");
3945 if (RT_FAILURE(rc))
3946 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
3947
3948 return rc;
3949}
3950
3951/**
3952 * Initializes the UUID fields in the DDB.
3953 *
3954 * @returns VBox status code.
3955 * @param pImage The VMDK image instance.
3956 */
3957static int vmdkCreateImageDdbUuidsInit(PVMDKIMAGE pImage)
3958{
3959 int rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
3960 if (RT_SUCCESS(rc))
3961 {
3962 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
3963 if (RT_SUCCESS(rc))
3964 {
3965 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_MODIFICATION_UUID,
3966 &pImage->ModificationUuid);
3967 if (RT_SUCCESS(rc))
3968 {
3969 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_MODIFICATION_UUID,
3970 &pImage->ParentModificationUuid);
3971 if (RT_FAILURE(rc))
3972 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
3973 N_("VMDK: error storing parent modification UUID in new descriptor in '%s'"), pImage->pszFilename);
3974 }
3975 else
3976 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
3977 N_("VMDK: error storing modification UUID in new descriptor in '%s'"), pImage->pszFilename);
3978 }
3979 else
3980 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
3981 N_("VMDK: error storing parent image UUID in new descriptor in '%s'"), pImage->pszFilename);
3982 }
3983 else
3984 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
3985 N_("VMDK: error storing image UUID in new descriptor in '%s'"), pImage->pszFilename);
3986
3987 return rc;
3988}
3989
3990/**
3991 * Internal: The actual code for creating any VMDK variant currently in
3992 * existence on hosted environments.
3993 */
3994static int vmdkCreateImage(PVMDKIMAGE pImage, uint64_t cbSize,
3995 unsigned uImageFlags, const char *pszComment,
3996 PCVDGEOMETRY pPCHSGeometry,
3997 PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
3998 PVDINTERFACEPROGRESS pIfProgress,
3999 unsigned uPercentStart, unsigned uPercentSpan)
4000{
4001 pImage->uImageFlags = uImageFlags;
4002
4003 pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
4004 pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
4005 AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
4006
4007 int rc = vmdkCreateDescriptor(pImage, pImage->pDescData, pImage->cbDescAlloc,
4008 &pImage->Descriptor);
4009 if (RT_SUCCESS(rc))
4010 {
4011 if ( (uImageFlags & VD_IMAGE_FLAGS_FIXED)
4012 && (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK))
4013 {
4014 /* Raw disk image (includes raw partition). */
4015 const PVDISKRAW pRaw = (const PVDISKRAW)pszComment;
4016 /* As the comment is misused, zap it so that no garbage comment
4017 * is set below. */
4018 pszComment = NULL;
4019 rc = vmdkCreateRawImage(pImage, pRaw, cbSize);
4020 }
4021 else if (uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
4022 {
4023 /* Stream optimized sparse image (monolithic). */
4024 rc = vmdkCreateStreamImage(pImage, cbSize);
4025 }
4026 else
4027 {
4028 /* Regular fixed or sparse image (monolithic or split). */
4029 rc = vmdkCreateRegularImage(pImage, cbSize, uImageFlags,
4030 pIfProgress, uPercentStart,
4031 uPercentSpan * 95 / 100);
4032 }
4033
4034 if (RT_SUCCESS(rc))
4035 {
4036 vdIfProgress(pIfProgress, uPercentStart + uPercentSpan * 98 / 100);
4037
4038 pImage->cbSize = cbSize;
4039
4040 for (unsigned i = 0; i < pImage->cExtents; i++)
4041 {
4042 PVMDKEXTENT pExtent = &pImage->pExtents[i];
4043
4044 rc = vmdkDescExtInsert(pImage, &pImage->Descriptor, pExtent->enmAccess,
4045 pExtent->cNominalSectors, pExtent->enmType,
4046 pExtent->pszBasename, pExtent->uSectorOffset);
4047 if (RT_FAILURE(rc))
4048 {
4049 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not insert the extent list into descriptor in '%s'"), pImage->pszFilename);
4050 break;
4051 }
4052 }
4053
4054 if (RT_SUCCESS(rc))
4055 vmdkDescExtRemoveDummy(pImage, &pImage->Descriptor);
4056
4057 if ( RT_SUCCESS(rc)
4058 && pPCHSGeometry->cCylinders != 0
4059 && pPCHSGeometry->cHeads != 0
4060 && pPCHSGeometry->cSectors != 0)
4061 rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
4062
4063 if ( RT_SUCCESS(rc)
4064 && pLCHSGeometry->cCylinders != 0
4065 && pLCHSGeometry->cHeads != 0
4066 && pLCHSGeometry->cSectors != 0)
4067 rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
4068
4069 pImage->LCHSGeometry = *pLCHSGeometry;
4070 pImage->PCHSGeometry = *pPCHSGeometry;
4071
4072 pImage->ImageUuid = *pUuid;
4073 RTUuidClear(&pImage->ParentUuid);
4074 RTUuidClear(&pImage->ModificationUuid);
4075 RTUuidClear(&pImage->ParentModificationUuid);
4076
4077 if (RT_SUCCESS(rc))
4078 rc = vmdkCreateImageDdbUuidsInit(pImage);
4079
4080 if (RT_SUCCESS(rc))
4081 rc = vmdkAllocateGrainTableCache(pImage);
4082
4083 if (RT_SUCCESS(rc))
4084 {
4085 rc = vmdkSetImageComment(pImage, pszComment);
4086 if (RT_FAILURE(rc))
4087 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot set image comment in '%s'"), pImage->pszFilename);
4088 }
4089
4090 if (RT_SUCCESS(rc))
4091 {
4092 vdIfProgress(pIfProgress, uPercentStart + uPercentSpan * 99 / 100);
4093
4094 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
4095 {
4096 /* streamOptimized is a bit special, we cannot trigger the flush
4097 * until all data has been written. So we write the necessary
4098 * information explicitly. */
4099 pImage->pExtents[0].cDescriptorSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64( pImage->Descriptor.aLines[pImage->Descriptor.cLines]
4100 - pImage->Descriptor.aLines[0], 512));
4101 rc = vmdkWriteMetaSparseExtent(pImage, &pImage->pExtents[0], 0, NULL);
4102 if (RT_SUCCESS(rc))
4103 {
4104 rc = vmdkWriteDescriptor(pImage, NULL);
4105 if (RT_FAILURE(rc))
4106 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write VMDK descriptor in '%s'"), pImage->pszFilename);
4107 }
4108 else
4109 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write VMDK header in '%s'"), pImage->pszFilename);
4110 }
4111 else
4112 rc = vmdkFlushImage(pImage, NULL);
4113 }
4114 }
4115 }
4116 else
4117 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new descriptor in '%s'"), pImage->pszFilename);
4118
4119
4120 if (RT_SUCCESS(rc))
4121 {
4122 PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
4123 pImage->RegionList.fFlags = 0;
4124 pImage->RegionList.cRegions = 1;
4125
4126 pRegion->offRegion = 0; /* Disk start. */
4127 pRegion->cbBlock = 512;
4128 pRegion->enmDataForm = VDREGIONDATAFORM_RAW;
4129 pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
4130 pRegion->cbData = 512;
4131 pRegion->cbMetadata = 0;
4132 pRegion->cRegionBlocksOrBytes = pImage->cbSize;
4133
4134 vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
4135 }
4136 else
4137 vmdkFreeImage(pImage, rc != VERR_ALREADY_EXISTS, false /*fFlush*/);
4138 return rc;
4139}
4140
4141/**
4142 * Internal: Update image comment.
4143 */
4144static int vmdkSetImageComment(PVMDKIMAGE pImage, const char *pszComment)
4145{
4146 char *pszCommentEncoded = NULL;
4147 if (pszComment)
4148 {
4149 pszCommentEncoded = vmdkEncodeString(pszComment);
4150 if (!pszCommentEncoded)
4151 return VERR_NO_MEMORY;
4152 }
4153
4154 int rc = vmdkDescDDBSetStr(pImage, &pImage->Descriptor,
4155 "ddb.comment", pszCommentEncoded);
4156 if (pszCommentEncoded)
4157 RTStrFree(pszCommentEncoded);
4158 if (RT_FAILURE(rc))
4159 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing image comment in descriptor in '%s'"), pImage->pszFilename);
4160 return VINF_SUCCESS;
4161}
4162
4163/**
4164 * Internal. Clear the grain table buffer for real stream optimized writing.
4165 */
4166static void vmdkStreamClearGT(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
4167{
4168 uint32_t cCacheLines = RT_ALIGN(pExtent->cGTEntries, VMDK_GT_CACHELINE_SIZE) / VMDK_GT_CACHELINE_SIZE;
4169 for (uint32_t i = 0; i < cCacheLines; i++)
4170 memset(&pImage->pGTCache->aGTCache[i].aGTData[0], '\0',
4171 VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t));
4172}
4173
4174/**
4175 * Internal. Flush the grain table buffer for real stream optimized writing.
4176 */
4177static int vmdkStreamFlushGT(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
4178 uint32_t uGDEntry)
4179{
4180 int rc = VINF_SUCCESS;
4181 uint32_t cCacheLines = RT_ALIGN(pExtent->cGTEntries, VMDK_GT_CACHELINE_SIZE) / VMDK_GT_CACHELINE_SIZE;
4182
4183 /* VMware does not write out completely empty grain tables in the case
4184 * of streamOptimized images, which according to my interpretation of
4185 * the VMDK 1.1 spec is bending the rules. Since they do it and we can
4186 * handle it without problems do it the same way and save some bytes. */
4187 bool fAllZero = true;
4188 for (uint32_t i = 0; i < cCacheLines; i++)
4189 {
4190 /* Convert the grain table to little endian in place, as it will not
4191 * be used at all after this function has been called. */
4192 uint32_t *pGTTmp = &pImage->pGTCache->aGTCache[i].aGTData[0];
4193 for (uint32_t j = 0; j < VMDK_GT_CACHELINE_SIZE; j++, pGTTmp++)
4194 if (*pGTTmp)
4195 {
4196 fAllZero = false;
4197 break;
4198 }
4199 if (!fAllZero)
4200 break;
4201 }
4202 if (fAllZero)
4203 return VINF_SUCCESS;
4204
4205 uint64_t uFileOffset = pExtent->uAppendPosition;
4206 if (!uFileOffset)
4207 return VERR_INTERNAL_ERROR;
4208 /* Align to sector, as the previous write could have been any size. */
4209 uFileOffset = RT_ALIGN_64(uFileOffset, 512);
4210
4211 /* Grain table marker. */
4212 uint8_t aMarker[512];
4213 PVMDKMARKER pMarker = (PVMDKMARKER)&aMarker[0];
4214 memset(pMarker, '\0', sizeof(aMarker));
4215 pMarker->uSector = RT_H2LE_U64(VMDK_BYTE2SECTOR((uint64_t)pExtent->cGTEntries * sizeof(uint32_t)));
4216 pMarker->uType = RT_H2LE_U32(VMDK_MARKER_GT);
4217 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage, uFileOffset,
4218 aMarker, sizeof(aMarker));
4219 AssertRC(rc);
4220 uFileOffset += 512;
4221
4222 if (!pExtent->pGD || pExtent->pGD[uGDEntry])
4223 return VERR_INTERNAL_ERROR;
4224
4225 pExtent->pGD[uGDEntry] = VMDK_BYTE2SECTOR(uFileOffset);
4226
4227 for (uint32_t i = 0; i < cCacheLines; i++)
4228 {
4229 /* Convert the grain table to little endian in place, as it will not
4230 * be used at all after this function has been called. */
4231 uint32_t *pGTTmp = &pImage->pGTCache->aGTCache[i].aGTData[0];
4232 for (uint32_t j = 0; j < VMDK_GT_CACHELINE_SIZE; j++, pGTTmp++)
4233 *pGTTmp = RT_H2LE_U32(*pGTTmp);
4234
4235 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage, uFileOffset,
4236 &pImage->pGTCache->aGTCache[i].aGTData[0],
4237 VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t));
4238 uFileOffset += VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t);
4239 if (RT_FAILURE(rc))
4240 break;
4241 }
4242 Assert(!(uFileOffset % 512));
4243 pExtent->uAppendPosition = RT_ALIGN_64(uFileOffset, 512);
4244 return rc;
4245}
4246
4247/**
4248 * Internal. Free all allocated space for representing an image, and optionally
4249 * delete the image from disk.
4250 */
4251static int vmdkFreeImage(PVMDKIMAGE pImage, bool fDelete, bool fFlush)
4252{
4253 int rc = VINF_SUCCESS;
4254
4255 /* Freeing a never allocated image (e.g. because the open failed) is
4256 * not signalled as an error. After all nothing bad happens. */
4257 if (pImage)
4258 {
4259 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
4260 {
4261 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
4262 {
4263 /* Check if all extents are clean. */
4264 for (unsigned i = 0; i < pImage->cExtents; i++)
4265 {
4266 Assert(!pImage->pExtents[i].fUncleanShutdown);
4267 }
4268 }
4269 else
4270 {
4271 /* Mark all extents as clean. */
4272 for (unsigned i = 0; i < pImage->cExtents; i++)
4273 {
4274 if ( pImage->pExtents[i].enmType == VMDKETYPE_HOSTED_SPARSE
4275 && pImage->pExtents[i].fUncleanShutdown)
4276 {
4277 pImage->pExtents[i].fUncleanShutdown = false;
4278 pImage->pExtents[i].fMetaDirty = true;
4279 }
4280
4281 /* From now on it's not safe to append any more data. */
4282 pImage->pExtents[i].uAppendPosition = 0;
4283 }
4284 }
4285 }
4286
4287 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
4288 {
4289 /* No need to write any pending data if the file will be deleted
4290 * or if the new file wasn't successfully created. */
4291 if ( !fDelete && pImage->pExtents
4292 && pImage->pExtents[0].cGTEntries
4293 && pImage->pExtents[0].uAppendPosition)
4294 {
4295 PVMDKEXTENT pExtent = &pImage->pExtents[0];
4296 uint32_t uLastGDEntry = pExtent->uLastGrainAccess / pExtent->cGTEntries;
4297 rc = vmdkStreamFlushGT(pImage, pExtent, uLastGDEntry);
4298 AssertRC(rc);
4299 vmdkStreamClearGT(pImage, pExtent);
4300 for (uint32_t i = uLastGDEntry + 1; i < pExtent->cGDEntries; i++)
4301 {
4302 rc = vmdkStreamFlushGT(pImage, pExtent, i);
4303 AssertRC(rc);
4304 }
4305
4306 uint64_t uFileOffset = pExtent->uAppendPosition;
4307 if (!uFileOffset)
4308 return VERR_INTERNAL_ERROR;
4309 uFileOffset = RT_ALIGN_64(uFileOffset, 512);
4310
4311 /* From now on it's not safe to append any more data. */
4312 pExtent->uAppendPosition = 0;
4313
4314 /* Grain directory marker. */
4315 uint8_t aMarker[512];
4316 PVMDKMARKER pMarker = (PVMDKMARKER)&aMarker[0];
4317 memset(pMarker, '\0', sizeof(aMarker));
4318 pMarker->uSector = VMDK_BYTE2SECTOR(RT_ALIGN_64(RT_H2LE_U64((uint64_t)pExtent->cGDEntries * sizeof(uint32_t)), 512));
4319 pMarker->uType = RT_H2LE_U32(VMDK_MARKER_GD);
4320 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage, uFileOffset,
4321 aMarker, sizeof(aMarker));
4322 AssertRC(rc);
4323 uFileOffset += 512;
4324
4325 /* Write grain directory in little endian style. The array will
4326 * not be used after this, so convert in place. */
4327 uint32_t *pGDTmp = pExtent->pGD;
4328 for (uint32_t i = 0; i < pExtent->cGDEntries; i++, pGDTmp++)
4329 *pGDTmp = RT_H2LE_U32(*pGDTmp);
4330 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
4331 uFileOffset, pExtent->pGD,
4332 pExtent->cGDEntries * sizeof(uint32_t));
4333 AssertRC(rc);
4334
4335 pExtent->uSectorGD = VMDK_BYTE2SECTOR(uFileOffset);
4336 pExtent->uSectorRGD = VMDK_BYTE2SECTOR(uFileOffset);
4337 uFileOffset = RT_ALIGN_64( uFileOffset
4338 + pExtent->cGDEntries * sizeof(uint32_t),
4339 512);
4340
4341 /* Footer marker. */
4342 memset(pMarker, '\0', sizeof(aMarker));
4343 pMarker->uSector = VMDK_BYTE2SECTOR(512);
4344 pMarker->uType = RT_H2LE_U32(VMDK_MARKER_FOOTER);
4345 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
4346 uFileOffset, aMarker, sizeof(aMarker));
4347 AssertRC(rc);
4348
4349 uFileOffset += 512;
4350 rc = vmdkWriteMetaSparseExtent(pImage, pExtent, uFileOffset, NULL);
4351 AssertRC(rc);
4352
4353 uFileOffset += 512;
4354 /* End-of-stream marker. */
4355 memset(pMarker, '\0', sizeof(aMarker));
4356 rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
4357 uFileOffset, aMarker, sizeof(aMarker));
4358 AssertRC(rc);
4359 }
4360 }
4361 else if (!fDelete && fFlush)
4362 vmdkFlushImage(pImage, NULL);
4363
4364 if (pImage->pExtents != NULL)
4365 {
4366 for (unsigned i = 0 ; i < pImage->cExtents; i++)
4367 {
4368 int rc2 = vmdkFreeExtentData(pImage, &pImage->pExtents[i], fDelete);
4369 if (RT_SUCCESS(rc))
4370 rc = rc2; /* Propogate any error when closing the file. */
4371 }
4372 RTMemFree(pImage->pExtents);
4373 pImage->pExtents = NULL;
4374 }
4375 pImage->cExtents = 0;
4376 if (pImage->pFile != NULL)
4377 {
4378 int rc2 = vmdkFileClose(pImage, &pImage->pFile, fDelete);
4379 if (RT_SUCCESS(rc))
4380 rc = rc2; /* Propogate any error when closing the file. */
4381 }
4382 int rc2 = vmdkFileCheckAllClose(pImage);
4383 if (RT_SUCCESS(rc))
4384 rc = rc2; /* Propogate any error when closing the file. */
4385
4386 if (pImage->pGTCache)
4387 {
4388 RTMemFree(pImage->pGTCache);
4389 pImage->pGTCache = NULL;
4390 }
4391 if (pImage->pDescData)
4392 {
4393 RTMemFree(pImage->pDescData);
4394 pImage->pDescData = NULL;
4395 }
4396 }
4397
4398 LogFlowFunc(("returns %Rrc\n", rc));
4399 return rc;
4400}
4401
4402/**
4403 * Internal. Flush image data (and metadata) to disk.
4404 */
4405static int vmdkFlushImage(PVMDKIMAGE pImage, PVDIOCTX pIoCtx)
4406{
4407 PVMDKEXTENT pExtent;
4408 int rc = VINF_SUCCESS;
4409
4410 /* Update descriptor if changed. */
4411 if (pImage->Descriptor.fDirty)
4412 rc = vmdkWriteDescriptor(pImage, pIoCtx);
4413
4414 if (RT_SUCCESS(rc))
4415 {
4416 for (unsigned i = 0; i < pImage->cExtents; i++)
4417 {
4418 pExtent = &pImage->pExtents[i];
4419 if (pExtent->pFile != NULL && pExtent->fMetaDirty)
4420 {
4421 switch (pExtent->enmType)
4422 {
4423 case VMDKETYPE_HOSTED_SPARSE:
4424 if (!pExtent->fFooter)
4425 rc = vmdkWriteMetaSparseExtent(pImage, pExtent, 0, pIoCtx);
4426 else
4427 {
4428 uint64_t uFileOffset = pExtent->uAppendPosition;
4429 /* Simply skip writing anything if the streamOptimized
4430 * image hasn't been just created. */
4431 if (!uFileOffset)
4432 break;
4433 uFileOffset = RT_ALIGN_64(uFileOffset, 512);
4434 rc = vmdkWriteMetaSparseExtent(pImage, pExtent,
4435 uFileOffset, pIoCtx);
4436 }
4437 break;
4438 case VMDKETYPE_VMFS:
4439 case VMDKETYPE_FLAT:
4440 /* Nothing to do. */
4441 break;
4442 case VMDKETYPE_ZERO:
4443 default:
4444 AssertMsgFailed(("extent with type %d marked as dirty\n",
4445 pExtent->enmType));
4446 break;
4447 }
4448 }
4449
4450 if (RT_FAILURE(rc))
4451 break;
4452
4453 switch (pExtent->enmType)
4454 {
4455 case VMDKETYPE_HOSTED_SPARSE:
4456 case VMDKETYPE_VMFS:
4457 case VMDKETYPE_FLAT:
4458 /** @todo implement proper path absolute check. */
4459 if ( pExtent->pFile != NULL
4460 && !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
4461 && !(pExtent->pszBasename[0] == RTPATH_SLASH))
4462 rc = vdIfIoIntFileFlush(pImage->pIfIo, pExtent->pFile->pStorage, pIoCtx,
4463 NULL, NULL);
4464 break;
4465 case VMDKETYPE_ZERO:
4466 /* No need to do anything for this extent. */
4467 break;
4468 default:
4469 AssertMsgFailed(("unknown extent type %d\n", pExtent->enmType));
4470 break;
4471 }
4472 }
4473 }
4474
4475 return rc;
4476}
4477
4478/**
4479 * Internal. Find extent corresponding to the sector number in the disk.
4480 */
4481static int vmdkFindExtent(PVMDKIMAGE pImage, uint64_t offSector,
4482 PVMDKEXTENT *ppExtent, uint64_t *puSectorInExtent)
4483{
4484 PVMDKEXTENT pExtent = NULL;
4485 int rc = VINF_SUCCESS;
4486
4487 for (unsigned i = 0; i < pImage->cExtents; i++)
4488 {
4489 if (offSector < pImage->pExtents[i].cNominalSectors)
4490 {
4491 pExtent = &pImage->pExtents[i];
4492 *puSectorInExtent = offSector + pImage->pExtents[i].uSectorOffset;
4493 break;
4494 }
4495 offSector -= pImage->pExtents[i].cNominalSectors;
4496 }
4497
4498 if (pExtent)
4499 *ppExtent = pExtent;
4500 else
4501 rc = VERR_IO_SECTOR_NOT_FOUND;
4502
4503 return rc;
4504}
4505
4506/**
4507 * Internal. Hash function for placing the grain table hash entries.
4508 */
4509static uint32_t vmdkGTCacheHash(PVMDKGTCACHE pCache, uint64_t uSector,
4510 unsigned uExtent)
4511{
4512 /** @todo this hash function is quite simple, maybe use a better one which
4513 * scrambles the bits better. */
4514 return (uSector + uExtent) % pCache->cEntries;
4515}
4516
4517/**
4518 * Internal. Get sector number in the extent file from the relative sector
4519 * number in the extent.
4520 */
4521static int vmdkGetSector(PVMDKIMAGE pImage, PVDIOCTX pIoCtx,
4522 PVMDKEXTENT pExtent, uint64_t uSector,
4523 uint64_t *puExtentSector)
4524{
4525 PVMDKGTCACHE pCache = pImage->pGTCache;
4526 uint64_t uGDIndex, uGTSector, uGTBlock;
4527 uint32_t uGTHash, uGTBlockIndex;
4528 PVMDKGTCACHEENTRY pGTCacheEntry;
4529 uint32_t aGTDataTmp[VMDK_GT_CACHELINE_SIZE];
4530 int rc;
4531
4532 /* For newly created and readonly/sequentially opened streamOptimized
4533 * images this must be a no-op, as the grain directory is not there. */
4534 if ( ( pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
4535 && pExtent->uAppendPosition)
4536 || ( pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
4537 && pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY
4538 && pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
4539 {
4540 *puExtentSector = 0;
4541 return VINF_SUCCESS;
4542 }
4543
4544 uGDIndex = uSector / pExtent->cSectorsPerGDE;
4545 if (uGDIndex >= pExtent->cGDEntries)
4546 return VERR_OUT_OF_RANGE;
4547 uGTSector = pExtent->pGD[uGDIndex];
4548 if (!uGTSector)
4549 {
4550 /* There is no grain table referenced by this grain directory
4551 * entry. So there is absolutely no data in this area. */
4552 *puExtentSector = 0;
4553 return VINF_SUCCESS;
4554 }
4555
4556 uGTBlock = uSector / (pExtent->cSectorsPerGrain * VMDK_GT_CACHELINE_SIZE);
4557 uGTHash = vmdkGTCacheHash(pCache, uGTBlock, pExtent->uExtent);
4558 pGTCacheEntry = &pCache->aGTCache[uGTHash];
4559 if ( pGTCacheEntry->uExtent != pExtent->uExtent
4560 || pGTCacheEntry->uGTBlock != uGTBlock)
4561 {
4562 /* Cache miss, fetch data from disk. */
4563 PVDMETAXFER pMetaXfer;
4564 rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4565 VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
4566 aGTDataTmp, sizeof(aGTDataTmp), pIoCtx, &pMetaXfer, NULL, NULL);
4567 if (RT_FAILURE(rc))
4568 return rc;
4569 /* We can release the metadata transfer immediately. */
4570 vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
4571 pGTCacheEntry->uExtent = pExtent->uExtent;
4572 pGTCacheEntry->uGTBlock = uGTBlock;
4573 for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
4574 pGTCacheEntry->aGTData[i] = RT_LE2H_U32(aGTDataTmp[i]);
4575 }
4576 uGTBlockIndex = (uSector / pExtent->cSectorsPerGrain) % VMDK_GT_CACHELINE_SIZE;
4577 uint32_t uGrainSector = pGTCacheEntry->aGTData[uGTBlockIndex];
4578 if (uGrainSector)
4579 *puExtentSector = uGrainSector + uSector % pExtent->cSectorsPerGrain;
4580 else
4581 *puExtentSector = 0;
4582 return VINF_SUCCESS;
4583}
4584
4585/**
4586 * Internal. Writes the grain and also if necessary the grain tables.
4587 * Uses the grain table cache as a true grain table.
4588 */
4589static int vmdkStreamAllocGrain(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
4590 uint64_t uSector, PVDIOCTX pIoCtx,
4591 uint64_t cbWrite)
4592{
4593 uint32_t uGrain;
4594 uint32_t uGDEntry, uLastGDEntry;
4595 uint32_t cbGrain = 0;
4596 uint32_t uCacheLine, uCacheEntry;
4597 const void *pData;
4598 int rc;
4599
4600 /* Very strict requirements: always write at least one full grain, with
4601 * proper alignment. Everything else would require reading of already
4602 * written data, which we don't support for obvious reasons. The only
4603 * exception is the last grain, and only if the image size specifies
4604 * that only some portion holds data. In any case the write must be
4605 * within the image limits, no "overshoot" allowed. */
4606 if ( cbWrite == 0
4607 || ( cbWrite < VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain)
4608 && pExtent->cNominalSectors - uSector >= pExtent->cSectorsPerGrain)
4609 || uSector % pExtent->cSectorsPerGrain
4610 || uSector + VMDK_BYTE2SECTOR(cbWrite) > pExtent->cNominalSectors)
4611 return VERR_INVALID_PARAMETER;
4612
4613 /* Clip write range to at most the rest of the grain. */
4614 cbWrite = RT_MIN(cbWrite, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSector % pExtent->cSectorsPerGrain));
4615
4616 /* Do not allow to go back. */
4617 uGrain = uSector / pExtent->cSectorsPerGrain;
4618 uCacheLine = uGrain % pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE;
4619 uCacheEntry = uGrain % VMDK_GT_CACHELINE_SIZE;
4620 uGDEntry = uGrain / pExtent->cGTEntries;
4621 uLastGDEntry = pExtent->uLastGrainAccess / pExtent->cGTEntries;
4622 if (uGrain < pExtent->uLastGrainAccess)
4623 return VERR_VD_VMDK_INVALID_WRITE;
4624
4625 /* Zero byte write optimization. Since we don't tell VBoxHDD that we need
4626 * to allocate something, we also need to detect the situation ourself. */
4627 if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
4628 && vdIfIoIntIoCtxIsZero(pImage->pIfIo, pIoCtx, cbWrite, true /* fAdvance */))
4629 return VINF_SUCCESS;
4630
4631 if (uGDEntry != uLastGDEntry)
4632 {
4633 rc = vmdkStreamFlushGT(pImage, pExtent, uLastGDEntry);
4634 if (RT_FAILURE(rc))
4635 return rc;
4636 vmdkStreamClearGT(pImage, pExtent);
4637 for (uint32_t i = uLastGDEntry + 1; i < uGDEntry; i++)
4638 {
4639 rc = vmdkStreamFlushGT(pImage, pExtent, i);
4640 if (RT_FAILURE(rc))
4641 return rc;
4642 }
4643 }
4644
4645 uint64_t uFileOffset;
4646 uFileOffset = pExtent->uAppendPosition;
4647 if (!uFileOffset)
4648 return VERR_INTERNAL_ERROR;
4649 /* Align to sector, as the previous write could have been any size. */
4650 uFileOffset = RT_ALIGN_64(uFileOffset, 512);
4651
4652 /* Paranoia check: extent type, grain table buffer presence and
4653 * grain table buffer space. Also grain table entry must be clear. */
4654 if ( pExtent->enmType != VMDKETYPE_HOSTED_SPARSE
4655 || !pImage->pGTCache
4656 || pExtent->cGTEntries > VMDK_GT_CACHE_SIZE * VMDK_GT_CACHELINE_SIZE
4657 || pImage->pGTCache->aGTCache[uCacheLine].aGTData[uCacheEntry])
4658 return VERR_INTERNAL_ERROR;
4659
4660 /* Update grain table entry. */
4661 pImage->pGTCache->aGTCache[uCacheLine].aGTData[uCacheEntry] = VMDK_BYTE2SECTOR(uFileOffset);
4662
4663 if (cbWrite != VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
4664 {
4665 vdIfIoIntIoCtxCopyFrom(pImage->pIfIo, pIoCtx, pExtent->pvGrain, cbWrite);
4666 memset((char *)pExtent->pvGrain + cbWrite, '\0',
4667 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbWrite);
4668 pData = pExtent->pvGrain;
4669 }
4670 else
4671 {
4672 RTSGSEG Segment;
4673 unsigned cSegments = 1;
4674 size_t cbSeg = 0;
4675
4676 cbSeg = vdIfIoIntIoCtxSegArrayCreate(pImage->pIfIo, pIoCtx, &Segment,
4677 &cSegments, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
4678 Assert(cbSeg == VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
4679 pData = Segment.pvSeg;
4680 }
4681 rc = vmdkFileDeflateSync(pImage, pExtent, uFileOffset, pData,
4682 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
4683 uSector, &cbGrain);
4684 if (RT_FAILURE(rc))
4685 {
4686 pExtent->uGrainSectorAbs = 0;
4687 AssertRC(rc);
4688 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write compressed data block in '%s'"), pExtent->pszFullname);
4689 }
4690 pExtent->uLastGrainAccess = uGrain;
4691 pExtent->uAppendPosition += cbGrain;
4692
4693 return rc;
4694}
4695
4696/**
4697 * Internal: Updates the grain table during grain allocation.
4698 */
4699static int vmdkAllocGrainGTUpdate(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, PVDIOCTX pIoCtx,
4700 PVMDKGRAINALLOCASYNC pGrainAlloc)
4701{
4702 int rc = VINF_SUCCESS;
4703 PVMDKGTCACHE pCache = pImage->pGTCache;
4704 uint32_t aGTDataTmp[VMDK_GT_CACHELINE_SIZE];
4705 uint32_t uGTHash, uGTBlockIndex;
4706 uint64_t uGTSector, uRGTSector, uGTBlock;
4707 uint64_t uSector = pGrainAlloc->uSector;
4708 PVMDKGTCACHEENTRY pGTCacheEntry;
4709
4710 LogFlowFunc(("pImage=%#p pExtent=%#p pCache=%#p pIoCtx=%#p pGrainAlloc=%#p\n",
4711 pImage, pExtent, pCache, pIoCtx, pGrainAlloc));
4712
4713 uGTSector = pGrainAlloc->uGTSector;
4714 uRGTSector = pGrainAlloc->uRGTSector;
4715 LogFlow(("uGTSector=%llu uRGTSector=%llu\n", uGTSector, uRGTSector));
4716
4717 /* Update the grain table (and the cache). */
4718 uGTBlock = uSector / (pExtent->cSectorsPerGrain * VMDK_GT_CACHELINE_SIZE);
4719 uGTHash = vmdkGTCacheHash(pCache, uGTBlock, pExtent->uExtent);
4720 pGTCacheEntry = &pCache->aGTCache[uGTHash];
4721 if ( pGTCacheEntry->uExtent != pExtent->uExtent
4722 || pGTCacheEntry->uGTBlock != uGTBlock)
4723 {
4724 /* Cache miss, fetch data from disk. */
4725 LogFlow(("Cache miss, fetch data from disk\n"));
4726 PVDMETAXFER pMetaXfer = NULL;
4727 rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4728 VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
4729 aGTDataTmp, sizeof(aGTDataTmp), pIoCtx,
4730 &pMetaXfer, vmdkAllocGrainComplete, pGrainAlloc);
4731 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4732 {
4733 pGrainAlloc->cIoXfersPending++;
4734 pGrainAlloc->fGTUpdateNeeded = true;
4735 /* Leave early, we will be called again after the read completed. */
4736 LogFlowFunc(("Metadata read in progress, leaving\n"));
4737 return rc;
4738 }
4739 else if (RT_FAILURE(rc))
4740 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot read allocated grain table entry in '%s'"), pExtent->pszFullname);
4741 vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
4742 pGTCacheEntry->uExtent = pExtent->uExtent;
4743 pGTCacheEntry->uGTBlock = uGTBlock;
4744 for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
4745 pGTCacheEntry->aGTData[i] = RT_LE2H_U32(aGTDataTmp[i]);
4746 }
4747 else
4748 {
4749 /* Cache hit. Convert grain table block back to disk format, otherwise
4750 * the code below will write garbage for all but the updated entry. */
4751 for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
4752 aGTDataTmp[i] = RT_H2LE_U32(pGTCacheEntry->aGTData[i]);
4753 }
4754 pGrainAlloc->fGTUpdateNeeded = false;
4755 uGTBlockIndex = (uSector / pExtent->cSectorsPerGrain) % VMDK_GT_CACHELINE_SIZE;
4756 aGTDataTmp[uGTBlockIndex] = RT_H2LE_U32(VMDK_BYTE2SECTOR(pGrainAlloc->uGrainOffset));
4757 pGTCacheEntry->aGTData[uGTBlockIndex] = VMDK_BYTE2SECTOR(pGrainAlloc->uGrainOffset);
4758 /* Update grain table on disk. */
4759 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4760 VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
4761 aGTDataTmp, sizeof(aGTDataTmp), pIoCtx,
4762 vmdkAllocGrainComplete, pGrainAlloc);
4763 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4764 pGrainAlloc->cIoXfersPending++;
4765 else if (RT_FAILURE(rc))
4766 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write updated grain table in '%s'"), pExtent->pszFullname);
4767 if (pExtent->pRGD)
4768 {
4769 /* Update backup grain table on disk. */
4770 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4771 VMDK_SECTOR2BYTE(uRGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
4772 aGTDataTmp, sizeof(aGTDataTmp), pIoCtx,
4773 vmdkAllocGrainComplete, pGrainAlloc);
4774 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4775 pGrainAlloc->cIoXfersPending++;
4776 else if (RT_FAILURE(rc))
4777 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write updated backup grain table in '%s'"), pExtent->pszFullname);
4778 }
4779
4780 LogFlowFunc(("leaving rc=%Rrc\n", rc));
4781 return rc;
4782}
4783
4784/**
4785 * Internal - complete the grain allocation by updating disk grain table if required.
4786 */
4787static DECLCALLBACK(int) vmdkAllocGrainComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
4788{
4789 RT_NOREF1(rcReq);
4790 int rc = VINF_SUCCESS;
4791 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4792 PVMDKGRAINALLOCASYNC pGrainAlloc = (PVMDKGRAINALLOCASYNC)pvUser;
4793
4794 LogFlowFunc(("pBackendData=%#p pIoCtx=%#p pvUser=%#p rcReq=%Rrc\n",
4795 pBackendData, pIoCtx, pvUser, rcReq));
4796
4797 pGrainAlloc->cIoXfersPending--;
4798 if (!pGrainAlloc->cIoXfersPending && pGrainAlloc->fGTUpdateNeeded)
4799 rc = vmdkAllocGrainGTUpdate(pImage, pGrainAlloc->pExtent, pIoCtx, pGrainAlloc);
4800
4801 if (!pGrainAlloc->cIoXfersPending)
4802 {
4803 /* Grain allocation completed. */
4804 RTMemFree(pGrainAlloc);
4805 }
4806
4807 LogFlowFunc(("Leaving rc=%Rrc\n", rc));
4808 return rc;
4809}
4810
4811/**
4812 * Internal. Allocates a new grain table (if necessary).
4813 */
4814static int vmdkAllocGrain(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, PVDIOCTX pIoCtx,
4815 uint64_t uSector, uint64_t cbWrite)
4816{
4817 PVMDKGTCACHE pCache = pImage->pGTCache; NOREF(pCache);
4818 uint64_t uGDIndex, uGTSector, uRGTSector;
4819 uint64_t uFileOffset;
4820 PVMDKGRAINALLOCASYNC pGrainAlloc = NULL;
4821 int rc;
4822
4823 LogFlowFunc(("pCache=%#p pExtent=%#p pIoCtx=%#p uSector=%llu cbWrite=%llu\n",
4824 pCache, pExtent, pIoCtx, uSector, cbWrite));
4825
4826 pGrainAlloc = (PVMDKGRAINALLOCASYNC)RTMemAllocZ(sizeof(VMDKGRAINALLOCASYNC));
4827 if (!pGrainAlloc)
4828 return VERR_NO_MEMORY;
4829
4830 pGrainAlloc->pExtent = pExtent;
4831 pGrainAlloc->uSector = uSector;
4832
4833 uGDIndex = uSector / pExtent->cSectorsPerGDE;
4834 if (uGDIndex >= pExtent->cGDEntries)
4835 {
4836 RTMemFree(pGrainAlloc);
4837 return VERR_OUT_OF_RANGE;
4838 }
4839 uGTSector = pExtent->pGD[uGDIndex];
4840 if (pExtent->pRGD)
4841 uRGTSector = pExtent->pRGD[uGDIndex];
4842 else
4843 uRGTSector = 0; /**< avoid compiler warning */
4844 if (!uGTSector)
4845 {
4846 LogFlow(("Allocating new grain table\n"));
4847
4848 /* There is no grain table referenced by this grain directory
4849 * entry. So there is absolutely no data in this area. Allocate
4850 * a new grain table and put the reference to it in the GDs. */
4851 uFileOffset = pExtent->uAppendPosition;
4852 if (!uFileOffset)
4853 {
4854 RTMemFree(pGrainAlloc);
4855 return VERR_INTERNAL_ERROR;
4856 }
4857 Assert(!(uFileOffset % 512));
4858
4859 uFileOffset = RT_ALIGN_64(uFileOffset, 512);
4860 uGTSector = VMDK_BYTE2SECTOR(uFileOffset);
4861
4862 /* Normally the grain table is preallocated for hosted sparse extents
4863 * that support more than 32 bit sector numbers. So this shouldn't
4864 * ever happen on a valid extent. */
4865 if (uGTSector > UINT32_MAX)
4866 {
4867 RTMemFree(pGrainAlloc);
4868 return VERR_VD_VMDK_INVALID_HEADER;
4869 }
4870
4871 /* Write grain table by writing the required number of grain table
4872 * cache chunks. Allocate memory dynamically here or we flood the
4873 * metadata cache with very small entries. */
4874 size_t cbGTDataTmp = pExtent->cGTEntries * sizeof(uint32_t);
4875 uint32_t *paGTDataTmp = (uint32_t *)RTMemTmpAllocZ(cbGTDataTmp);
4876
4877 if (!paGTDataTmp)
4878 {
4879 RTMemFree(pGrainAlloc);
4880 return VERR_NO_MEMORY;
4881 }
4882
4883 memset(paGTDataTmp, '\0', cbGTDataTmp);
4884 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4885 VMDK_SECTOR2BYTE(uGTSector),
4886 paGTDataTmp, cbGTDataTmp, pIoCtx,
4887 vmdkAllocGrainComplete, pGrainAlloc);
4888 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4889 pGrainAlloc->cIoXfersPending++;
4890 else if (RT_FAILURE(rc))
4891 {
4892 RTMemTmpFree(paGTDataTmp);
4893 RTMemFree(pGrainAlloc);
4894 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write grain table allocation in '%s'"), pExtent->pszFullname);
4895 }
4896 pExtent->uAppendPosition = RT_ALIGN_64( pExtent->uAppendPosition
4897 + cbGTDataTmp, 512);
4898
4899 if (pExtent->pRGD)
4900 {
4901 AssertReturn(!uRGTSector, VERR_VD_VMDK_INVALID_HEADER);
4902 uFileOffset = pExtent->uAppendPosition;
4903 if (!uFileOffset)
4904 return VERR_INTERNAL_ERROR;
4905 Assert(!(uFileOffset % 512));
4906 uRGTSector = VMDK_BYTE2SECTOR(uFileOffset);
4907
4908 /* Normally the redundant grain table is preallocated for hosted
4909 * sparse extents that support more than 32 bit sector numbers. So
4910 * this shouldn't ever happen on a valid extent. */
4911 if (uRGTSector > UINT32_MAX)
4912 {
4913 RTMemTmpFree(paGTDataTmp);
4914 return VERR_VD_VMDK_INVALID_HEADER;
4915 }
4916
4917 /* Write grain table by writing the required number of grain table
4918 * cache chunks. Allocate memory dynamically here or we flood the
4919 * metadata cache with very small entries. */
4920 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4921 VMDK_SECTOR2BYTE(uRGTSector),
4922 paGTDataTmp, cbGTDataTmp, pIoCtx,
4923 vmdkAllocGrainComplete, pGrainAlloc);
4924 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4925 pGrainAlloc->cIoXfersPending++;
4926 else if (RT_FAILURE(rc))
4927 {
4928 RTMemTmpFree(paGTDataTmp);
4929 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write backup grain table allocation in '%s'"), pExtent->pszFullname);
4930 }
4931
4932 pExtent->uAppendPosition = pExtent->uAppendPosition + cbGTDataTmp;
4933 }
4934
4935 RTMemTmpFree(paGTDataTmp);
4936
4937 /* Update the grain directory on disk (doing it before writing the
4938 * grain table will result in a garbled extent if the operation is
4939 * aborted for some reason. Otherwise the worst that can happen is
4940 * some unused sectors in the extent. */
4941 uint32_t uGTSectorLE = RT_H2LE_U64(uGTSector);
4942 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4943 VMDK_SECTOR2BYTE(pExtent->uSectorGD) + uGDIndex * sizeof(uGTSectorLE),
4944 &uGTSectorLE, sizeof(uGTSectorLE), pIoCtx,
4945 vmdkAllocGrainComplete, pGrainAlloc);
4946 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4947 pGrainAlloc->cIoXfersPending++;
4948 else if (RT_FAILURE(rc))
4949 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write grain directory entry in '%s'"), pExtent->pszFullname);
4950 if (pExtent->pRGD)
4951 {
4952 uint32_t uRGTSectorLE = RT_H2LE_U64(uRGTSector);
4953 rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
4954 VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + uGDIndex * sizeof(uGTSectorLE),
4955 &uRGTSectorLE, sizeof(uRGTSectorLE), pIoCtx,
4956 vmdkAllocGrainComplete, pGrainAlloc);
4957 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
4958 pGrainAlloc->cIoXfersPending++;
4959 else if (RT_FAILURE(rc))
4960 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write backup grain directory entry in '%s'"), pExtent->pszFullname);
4961 }
4962
4963 /* As the final step update the in-memory copy of the GDs. */
4964 pExtent->pGD[uGDIndex] = uGTSector;
4965 if (pExtent->pRGD)
4966 pExtent->pRGD[uGDIndex] = uRGTSector;
4967 }
4968
4969 LogFlow(("uGTSector=%llu uRGTSector=%llu\n", uGTSector, uRGTSector));
4970 pGrainAlloc->uGTSector = uGTSector;
4971 pGrainAlloc->uRGTSector = uRGTSector;
4972
4973 uFileOffset = pExtent->uAppendPosition;
4974 if (!uFileOffset)
4975 return VERR_INTERNAL_ERROR;
4976 Assert(!(uFileOffset % 512));
4977
4978 pGrainAlloc->uGrainOffset = uFileOffset;
4979
4980 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
4981 {
4982 AssertMsgReturn(vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx),
4983 ("Accesses to stream optimized images must be synchronous\n"),
4984 VERR_INVALID_STATE);
4985
4986 if (cbWrite != VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
4987 return vdIfError(pImage->pIfError, VERR_INTERNAL_ERROR, RT_SRC_POS, N_("VMDK: not enough data for a compressed data block in '%s'"), pExtent->pszFullname);
4988
4989 /* Invalidate cache, just in case some code incorrectly allows mixing
4990 * of reads and writes. Normally shouldn't be needed. */
4991 pExtent->uGrainSectorAbs = 0;
4992
4993 /* Write compressed data block and the markers. */
4994 uint32_t cbGrain = 0;
4995 size_t cbSeg = 0;
4996 RTSGSEG Segment;
4997 unsigned cSegments = 1;
4998
4999 cbSeg = vdIfIoIntIoCtxSegArrayCreate(pImage->pIfIo, pIoCtx, &Segment,
5000 &cSegments, cbWrite);
5001 Assert(cbSeg == cbWrite);
5002
5003 rc = vmdkFileDeflateSync(pImage, pExtent, uFileOffset,
5004 Segment.pvSeg, cbWrite, uSector, &cbGrain);
5005 if (RT_FAILURE(rc))
5006 {
5007 AssertRC(rc);
5008 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write allocated compressed data block in '%s'"), pExtent->pszFullname);
5009 }
5010 pExtent->uLastGrainAccess = uSector / pExtent->cSectorsPerGrain;
5011 pExtent->uAppendPosition += cbGrain;
5012 }
5013 else
5014 {
5015 /* Write the data. Always a full grain, or we're in big trouble. */
5016 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pExtent->pFile->pStorage,
5017 uFileOffset, pIoCtx, cbWrite,
5018 vmdkAllocGrainComplete, pGrainAlloc);
5019 if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
5020 pGrainAlloc->cIoXfersPending++;
5021 else if (RT_FAILURE(rc))
5022 return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write allocated data block in '%s'"), pExtent->pszFullname);
5023
5024 pExtent->uAppendPosition += cbWrite;
5025 }
5026
5027 rc = vmdkAllocGrainGTUpdate(pImage, pExtent, pIoCtx, pGrainAlloc);
5028
5029 if (!pGrainAlloc->cIoXfersPending)
5030 {
5031 /* Grain allocation completed. */
5032 RTMemFree(pGrainAlloc);
5033 }
5034
5035 LogFlowFunc(("leaving rc=%Rrc\n", rc));
5036
5037 return rc;
5038}
5039
5040/**
5041 * Internal. Reads the contents by sequentially going over the compressed
5042 * grains (hoping that they are in sequence).
5043 */
5044static int vmdkStreamReadSequential(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
5045 uint64_t uSector, PVDIOCTX pIoCtx,
5046 uint64_t cbRead)
5047{
5048 int rc;
5049
5050 LogFlowFunc(("pImage=%#p pExtent=%#p uSector=%llu pIoCtx=%#p cbRead=%llu\n",
5051 pImage, pExtent, uSector, pIoCtx, cbRead));
5052
5053 AssertMsgReturn(vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx),
5054 ("Async I/O not supported for sequential stream optimized images\n"),
5055 VERR_INVALID_STATE);
5056
5057 /* Do not allow to go back. */
5058 uint32_t uGrain = uSector / pExtent->cSectorsPerGrain;
5059 if (uGrain < pExtent->uLastGrainAccess)
5060 return VERR_VD_VMDK_INVALID_STATE;
5061 pExtent->uLastGrainAccess = uGrain;
5062
5063 /* After a previous error do not attempt to recover, as it would need
5064 * seeking (in the general case backwards which is forbidden). */
5065 if (!pExtent->uGrainSectorAbs)
5066 return VERR_VD_VMDK_INVALID_STATE;
5067
5068 /* Check if we need to read something from the image or if what we have
5069 * in the buffer is good to fulfill the request. */
5070 if (!pExtent->cbGrainStreamRead || uGrain > pExtent->uGrain)
5071 {
5072 uint32_t uGrainSectorAbs = pExtent->uGrainSectorAbs
5073 + VMDK_BYTE2SECTOR(pExtent->cbGrainStreamRead);
5074
5075 /* Get the marker from the next data block - and skip everything which
5076 * is not a compressed grain. If it's a compressed grain which is for
5077 * the requested sector (or after), read it. */
5078 VMDKMARKER Marker;
5079 do
5080 {
5081 RT_ZERO(Marker);
5082 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
5083 VMDK_SECTOR2BYTE(uGrainSectorAbs),
5084 &Marker, RT_UOFFSETOF(VMDKMARKER, uType));
5085 if (RT_FAILURE(rc))
5086 return rc;
5087 Marker.uSector = RT_LE2H_U64(Marker.uSector);
5088 Marker.cbSize = RT_LE2H_U32(Marker.cbSize);
5089
5090 if (Marker.cbSize == 0)
5091 {
5092 /* A marker for something else than a compressed grain. */
5093 rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
5094 VMDK_SECTOR2BYTE(uGrainSectorAbs)
5095 + RT_UOFFSETOF(VMDKMARKER, uType),
5096 &Marker.uType, sizeof(Marker.uType));
5097 if (RT_FAILURE(rc))
5098 return rc;
5099 Marker.uType = RT_LE2H_U32(Marker.uType);
5100 switch (Marker.uType)
5101 {
5102 case VMDK_MARKER_EOS:
5103 uGrainSectorAbs++;
5104 /* Read (or mostly skip) to the end of file. Uses the
5105 * Marker (LBA sector) as it is unused anyway. This
5106 * makes sure that really everything is read in the
5107 * success case. If this read fails it means the image
5108 * is truncated, but this is harmless so ignore. */
5109 vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
5110 VMDK_SECTOR2BYTE(uGrainSectorAbs)
5111 + 511,
5112 &Marker.uSector, 1);
5113 break;
5114 case VMDK_MARKER_GT:
5115 uGrainSectorAbs += 1 + VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
5116 break;
5117 case VMDK_MARKER_GD:
5118 uGrainSectorAbs += 1 + VMDK_BYTE2SECTOR(RT_ALIGN(pExtent->cGDEntries * sizeof(uint32_t), 512));
5119 break;
5120 case VMDK_MARKER_FOOTER:
5121 uGrainSectorAbs += 2;
5122 break;
5123 case VMDK_MARKER_UNSPECIFIED:
5124 /* Skip over the contents of the unspecified marker
5125 * type 4 which exists in some vSphere created files. */
5126 /** @todo figure out what the payload means. */
5127 uGrainSectorAbs += 1;
5128 break;
5129 default:
5130 AssertMsgFailed(("VMDK: corrupted marker, type=%#x\n", Marker.uType));
5131 pExtent->uGrainSectorAbs = 0;
5132 return VERR_VD_VMDK_INVALID_STATE;
5133 }
5134 pExtent->cbGrainStreamRead = 0;
5135 }
5136 else
5137 {
5138 /* A compressed grain marker. If it is at/after what we're
5139 * interested in read and decompress data. */
5140 if (uSector > Marker.uSector + pExtent->cSectorsPerGrain)
5141 {
5142 uGrainSectorAbs += VMDK_BYTE2SECTOR(RT_ALIGN(Marker.cbSize + RT_UOFFSETOF(VMDKMARKER, uType), 512));
5143 continue;
5144 }
5145 uint64_t uLBA = 0;
5146 uint32_t cbGrainStreamRead = 0;
5147 rc = vmdkFileInflateSync(pImage, pExtent,
5148 VMDK_SECTOR2BYTE(uGrainSectorAbs),
5149 pExtent->pvGrain,
5150 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
5151 &Marker, &uLBA, &cbGrainStreamRead);
5152 if (RT_FAILURE(rc))
5153 {
5154 pExtent->uGrainSectorAbs = 0;
5155 return rc;
5156 }
5157 if ( pExtent->uGrain
5158 && uLBA / pExtent->cSectorsPerGrain <= pExtent->uGrain)
5159 {
5160 pExtent->uGrainSectorAbs = 0;
5161 return VERR_VD_VMDK_INVALID_STATE;
5162 }
5163 pExtent->uGrain = uLBA / pExtent->cSectorsPerGrain;
5164 pExtent->cbGrainStreamRead = cbGrainStreamRead;
5165 break;
5166 }
5167 } while (Marker.uType != VMDK_MARKER_EOS);
5168
5169 pExtent->uGrainSectorAbs = uGrainSectorAbs;
5170
5171 if (!pExtent->cbGrainStreamRead && Marker.uType == VMDK_MARKER_EOS)
5172 {
5173 pExtent->uGrain = UINT32_MAX;
5174 /* Must set a non-zero value for pExtent->cbGrainStreamRead or
5175 * the next read would try to get more data, and we're at EOF. */
5176 pExtent->cbGrainStreamRead = 1;
5177 }
5178 }
5179
5180 if (pExtent->uGrain > uSector / pExtent->cSectorsPerGrain)
5181 {
5182 /* The next data block we have is not for this area, so just return
5183 * that there is no data. */
5184 LogFlowFunc(("returns VERR_VD_BLOCK_FREE\n"));
5185 return VERR_VD_BLOCK_FREE;
5186 }
5187
5188 uint32_t uSectorInGrain = uSector % pExtent->cSectorsPerGrain;
5189 vdIfIoIntIoCtxCopyTo(pImage->pIfIo, pIoCtx,
5190 (uint8_t *)pExtent->pvGrain + VMDK_SECTOR2BYTE(uSectorInGrain),
5191 cbRead);
5192 LogFlowFunc(("returns VINF_SUCCESS\n"));
5193 return VINF_SUCCESS;
5194}
5195
5196/**
5197 * Replaces a fragment of a string with the specified string.
5198 *
5199 * @returns Pointer to the allocated UTF-8 string.
5200 * @param pszWhere UTF-8 string to search in.
5201 * @param pszWhat UTF-8 string to search for.
5202 * @param pszByWhat UTF-8 string to replace the found string with.
5203 *
5204 * @note r=bird: This is only used by vmdkRenameWorker(). The first use is
5205 * for updating the base name in the descriptor, the second is for
5206 * generating new filenames for extents. This code borked when
5207 * RTPathAbs started correcting the driver letter case on windows,
5208 * when strstr failed because the pExtent->pszFullname was not
5209 * subjected to RTPathAbs but while pExtent->pszFullname was. I fixed
5210 * this by apply RTPathAbs to the places it wasn't applied.
5211 *
5212 * However, this highlights some undocumented ASSUMPTIONS as well as
5213 * terrible short commings of the approach.
5214 *
5215 * Given the right filename, it may also screw up the descriptor. Take
5216 * the descriptor text 'RW 2048 SPARSE "Test0.vmdk"' for instance,
5217 * we'll be asked to replace "Test0" with something, no problem. No,
5218 * imagine 'RW 2048 SPARSE "SPARSE.vmdk"', 'RW 2048 SPARSE "RW.vmdk"'
5219 * or 'RW 2048 SPARSE "2048.vmdk"', and the strstr approach falls on
5220 * its bum. The descriptor string must be parsed and reconstructed,
5221 * the lazy strstr approach doesn't cut it.
5222 *
5223 * I'm also curious as to what would be the correct escaping of '"' in
5224 * the file name and how that is supposed to be handled, because it
5225 * needs to be or such names must be rejected in several places (maybe
5226 * they are, I didn't check).
5227 *
5228 * When this function is used to replace the start of a path, I think
5229 * the assumption from the prep/setup code is that we kind of knows
5230 * what we're working on (I could be wrong). However, using strstr
5231 * instead of strncmp/RTStrNICmp makes no sense and isn't future proof.
5232 * Especially on unix systems, weird stuff could happen if someone
5233 * unwittingly tinkers with the prep/setup code. What should really be
5234 * done here is using a new RTPathStartEx function that (via flags)
5235 * allows matching partial final component and returns the length of
5236 * what it matched up (in case it skipped slashes and '.' components).
5237 *
5238 */
5239static char *vmdkStrReplace(const char *pszWhere, const char *pszWhat,
5240 const char *pszByWhat)
5241{
5242 AssertPtr(pszWhere);
5243 AssertPtr(pszWhat);
5244 AssertPtr(pszByWhat);
5245 const char *pszFoundStr = strstr(pszWhere, pszWhat);
5246 if (!pszFoundStr)
5247 {
5248 LogFlowFunc(("Failed to find '%s' in '%s'!\n", pszWhat, pszWhere));
5249 return NULL;
5250 }
5251 size_t cbFinal = strlen(pszWhere) + 1 + strlen(pszByWhat) - strlen(pszWhat);
5252 char *pszNewStr = (char *)RTMemAlloc(cbFinal);
5253 if (pszNewStr)
5254 {
5255 char *pszTmp = pszNewStr;
5256 memcpy(pszTmp, pszWhere, pszFoundStr - pszWhere);
5257 pszTmp += pszFoundStr - pszWhere;
5258 memcpy(pszTmp, pszByWhat, strlen(pszByWhat));
5259 pszTmp += strlen(pszByWhat);
5260 strcpy(pszTmp, pszFoundStr + strlen(pszWhat));
5261 }
5262 return pszNewStr;
5263}
5264
5265
5266/** @copydoc VDIMAGEBACKEND::pfnProbe */
5267static DECLCALLBACK(int) vmdkProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
5268 PVDINTERFACE pVDIfsImage, VDTYPE enmDesiredType, VDTYPE *penmType)
5269{
5270 RT_NOREF(enmDesiredType);
5271 LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p penmType=%#p\n",
5272 pszFilename, pVDIfsDisk, pVDIfsImage, penmType));
5273
5274 AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
5275
5276 int rc = VINF_SUCCESS;
5277 PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
5278 if (RT_LIKELY(pImage))
5279 {
5280 pImage->pszFilename = pszFilename;
5281 pImage->pFile = NULL;
5282 pImage->pExtents = NULL;
5283 pImage->pFiles = NULL;
5284 pImage->pGTCache = NULL;
5285 pImage->pDescData = NULL;
5286 pImage->pVDIfsDisk = pVDIfsDisk;
5287 pImage->pVDIfsImage = pVDIfsImage;
5288 /** @todo speed up this test open (VD_OPEN_FLAGS_INFO) by skipping as
5289 * much as possible in vmdkOpenImage. */
5290 rc = vmdkOpenImage(pImage, VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_READONLY);
5291 vmdkFreeImage(pImage, false, false /*fFlush*/);
5292 RTMemFree(pImage);
5293
5294 if (RT_SUCCESS(rc))
5295 *penmType = VDTYPE_HDD;
5296 }
5297 else
5298 rc = VERR_NO_MEMORY;
5299
5300 LogFlowFunc(("returns %Rrc\n", rc));
5301 return rc;
5302}
5303
5304/** @copydoc VDIMAGEBACKEND::pfnOpen */
5305static DECLCALLBACK(int) vmdkOpen(const char *pszFilename, unsigned uOpenFlags,
5306 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
5307 VDTYPE enmType, void **ppBackendData)
5308{
5309 RT_NOREF1(enmType); /**< @todo r=klaus make use of the type info. */
5310
5311 LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n",
5312 pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
5313 int rc;
5314
5315 /* Check open flags. All valid flags are supported. */
5316 AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
5317 AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
5318
5319 PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
5320 if (RT_LIKELY(pImage))
5321 {
5322 pImage->pszFilename = pszFilename;
5323 pImage->pFile = NULL;
5324 pImage->pExtents = NULL;
5325 pImage->pFiles = NULL;
5326 pImage->pGTCache = NULL;
5327 pImage->pDescData = NULL;
5328 pImage->pVDIfsDisk = pVDIfsDisk;
5329 pImage->pVDIfsImage = pVDIfsImage;
5330
5331 rc = vmdkOpenImage(pImage, uOpenFlags);
5332 if (RT_SUCCESS(rc))
5333 *ppBackendData = pImage;
5334 else
5335 RTMemFree(pImage);
5336 }
5337 else
5338 rc = VERR_NO_MEMORY;
5339
5340 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
5341 return rc;
5342}
5343
5344/** @copydoc VDIMAGEBACKEND::pfnCreate */
5345static DECLCALLBACK(int) vmdkCreate(const char *pszFilename, uint64_t cbSize,
5346 unsigned uImageFlags, const char *pszComment,
5347 PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
5348 PCRTUUID pUuid, unsigned uOpenFlags,
5349 unsigned uPercentStart, unsigned uPercentSpan,
5350 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
5351 PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
5352 void **ppBackendData)
5353{
5354 LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p enmType=%u ppBackendData=%#p\n",
5355 pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
5356 int rc;
5357
5358 /* Check the VD container type and image flags. */
5359 if ( enmType != VDTYPE_HDD
5360 || (uImageFlags & ~VD_VMDK_IMAGE_FLAGS_MASK) != 0)
5361 return VERR_VD_INVALID_TYPE;
5362
5363 /* Check size. Maximum 256TB-64K for sparse images, otherwise unlimited. */
5364 if ( !cbSize
5365 || (!(uImageFlags & VD_IMAGE_FLAGS_FIXED) && cbSize >= _1T * 256 - _64K))
5366 return VERR_VD_INVALID_SIZE;
5367
5368 /* Check image flags for invalid combinations. */
5369 if ( (uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
5370 && (uImageFlags & ~(VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED | VD_IMAGE_FLAGS_DIFF)))
5371 return VERR_INVALID_PARAMETER;
5372
5373 /* Check open flags. All valid flags are supported. */
5374 AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
5375 AssertReturn( VALID_PTR(pszFilename)
5376 && *pszFilename
5377 && VALID_PTR(pPCHSGeometry)
5378 && VALID_PTR(pLCHSGeometry)
5379 && !( uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX
5380 && !(uImageFlags & VD_IMAGE_FLAGS_FIXED)),
5381 VERR_INVALID_PARAMETER);
5382
5383 PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
5384 if (RT_LIKELY(pImage))
5385 {
5386 PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
5387
5388 pImage->pszFilename = pszFilename;
5389 pImage->pFile = NULL;
5390 pImage->pExtents = NULL;
5391 pImage->pFiles = NULL;
5392 pImage->pGTCache = NULL;
5393 pImage->pDescData = NULL;
5394 pImage->pVDIfsDisk = pVDIfsDisk;
5395 pImage->pVDIfsImage = pVDIfsImage;
5396 /* Descriptors for split images can be pretty large, especially if the
5397 * filename is long. So prepare for the worst, and allocate quite some
5398 * memory for the descriptor in this case. */
5399 if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
5400 pImage->cbDescAlloc = VMDK_SECTOR2BYTE(200);
5401 else
5402 pImage->cbDescAlloc = VMDK_SECTOR2BYTE(20);
5403 pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
5404 if (RT_LIKELY(pImage->pDescData))
5405 {
5406 rc = vmdkCreateImage(pImage, cbSize, uImageFlags, pszComment,
5407 pPCHSGeometry, pLCHSGeometry, pUuid,
5408 pIfProgress, uPercentStart, uPercentSpan);
5409 if (RT_SUCCESS(rc))
5410 {
5411 /* So far the image is opened in read/write mode. Make sure the
5412 * image is opened in read-only mode if the caller requested that. */
5413 if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
5414 {
5415 vmdkFreeImage(pImage, false, true /*fFlush*/);
5416 rc = vmdkOpenImage(pImage, uOpenFlags);
5417 }
5418
5419 if (RT_SUCCESS(rc))
5420 *ppBackendData = pImage;
5421 }
5422
5423 if (RT_FAILURE(rc))
5424 RTMemFree(pImage->pDescData);
5425 }
5426 else
5427 rc = VERR_NO_MEMORY;
5428
5429 if (RT_FAILURE(rc))
5430 RTMemFree(pImage);
5431 }
5432 else
5433 rc = VERR_NO_MEMORY;
5434
5435 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
5436 return rc;
5437}
5438
5439/**
5440 * Prepares the state for renaming a VMDK image, setting up the state and allocating
5441 * memory.
5442 *
5443 * @returns VBox status code.
5444 * @param pImage VMDK image instance.
5445 * @param pRenameState The state to initialize.
5446 * @param pszFilename The new filename.
5447 */
5448static int vmdkRenameStatePrepare(PVMDKIMAGE pImage, PVMDKRENAMESTATE pRenameState, const char *pszFilename)
5449{
5450 AssertReturn(RTPathFilename(pszFilename) != NULL, VERR_INVALID_PARAMETER);
5451
5452 int rc = VINF_SUCCESS;
5453
5454 memset(&pRenameState->DescriptorCopy, 0, sizeof(pRenameState->DescriptorCopy));
5455
5456 /*
5457 * Allocate an array to store both old and new names of renamed files
5458 * in case we have to roll back the changes. Arrays are initialized
5459 * with zeros. We actually save stuff when and if we change it.
5460 */
5461 pRenameState->cExtents = pImage->cExtents;
5462 pRenameState->apszOldName = (char **)RTMemTmpAllocZ((pRenameState->cExtents + 1) * sizeof(char *));
5463 pRenameState->apszNewName = (char **)RTMemTmpAllocZ((pRenameState->cExtents + 1) * sizeof(char *));
5464 pRenameState->apszNewLines = (char **)RTMemTmpAllocZ(pRenameState->cExtents * sizeof(char *));
5465 if ( pRenameState->apszOldName
5466 && pRenameState->apszNewName
5467 && pRenameState->apszNewLines)
5468 {
5469 /* Save the descriptor size and position. */
5470 if (pImage->pDescData)
5471 {
5472 /* Separate descriptor file. */
5473 pRenameState->fEmbeddedDesc = false;
5474 }
5475 else
5476 {
5477 /* Embedded descriptor file. */
5478 pRenameState->ExtentCopy = pImage->pExtents[0];
5479 pRenameState->fEmbeddedDesc = true;
5480 }
5481
5482 /* Save the descriptor content. */
5483 pRenameState->DescriptorCopy.cLines = pImage->Descriptor.cLines;
5484 for (unsigned i = 0; i < pRenameState->DescriptorCopy.cLines; i++)
5485 {
5486 pRenameState->DescriptorCopy.aLines[i] = RTStrDup(pImage->Descriptor.aLines[i]);
5487 if (!pRenameState->DescriptorCopy.aLines[i])
5488 {
5489 rc = VERR_NO_MEMORY;
5490 break;
5491 }
5492 }
5493
5494 if (RT_SUCCESS(rc))
5495 {
5496 /* Prepare both old and new base names used for string replacement. */
5497 pRenameState->pszNewBaseName = RTStrDup(RTPathFilename(pszFilename));
5498 AssertReturn(pRenameState->pszNewBaseName, VERR_NO_STR_MEMORY);
5499 RTPathStripSuffix(pRenameState->pszNewBaseName);
5500
5501 pRenameState->pszOldBaseName = RTStrDup(RTPathFilename(pImage->pszFilename));
5502 AssertReturn(pRenameState->pszOldBaseName, VERR_NO_STR_MEMORY);
5503 RTPathStripSuffix(pRenameState->pszOldBaseName);
5504
5505 /* Prepare both old and new full names used for string replacement.
5506 Note! Must abspath the stuff here, so the strstr weirdness later in
5507 the renaming process get a match against abspath'ed extent paths.
5508 See RTPathAbsDup call in vmdkDescriptorReadSparse(). */
5509 pRenameState->pszNewFullName = RTPathAbsDup(pszFilename);
5510 AssertReturn(pRenameState->pszNewFullName, VERR_NO_STR_MEMORY);
5511 RTPathStripSuffix(pRenameState->pszNewFullName);
5512
5513 pRenameState->pszOldFullName = RTPathAbsDup(pImage->pszFilename);
5514 AssertReturn(pRenameState->pszOldFullName, VERR_NO_STR_MEMORY);
5515 RTPathStripSuffix(pRenameState->pszOldFullName);
5516
5517 /* Save the old name for easy access to the old descriptor file. */
5518 pRenameState->pszOldDescName = RTStrDup(pImage->pszFilename);
5519 AssertReturn(pRenameState->pszOldDescName, VERR_NO_STR_MEMORY);
5520
5521 /* Save old image name. */
5522 pRenameState->pszOldImageName = pImage->pszFilename;
5523 }
5524 }
5525 else
5526 rc = VERR_NO_TMP_MEMORY;
5527
5528 return rc;
5529}
5530
5531/**
5532 * Destroys the given rename state, freeing all allocated memory.
5533 *
5534 * @returns nothing.
5535 * @param pRenameState The rename state to destroy.
5536 */
5537static void vmdkRenameStateDestroy(PVMDKRENAMESTATE pRenameState)
5538{
5539 for (unsigned i = 0; i < pRenameState->DescriptorCopy.cLines; i++)
5540 if (pRenameState->DescriptorCopy.aLines[i])
5541 RTStrFree(pRenameState->DescriptorCopy.aLines[i]);
5542 if (pRenameState->apszOldName)
5543 {
5544 for (unsigned i = 0; i <= pRenameState->cExtents; i++)
5545 if (pRenameState->apszOldName[i])
5546 RTStrFree(pRenameState->apszOldName[i]);
5547 RTMemTmpFree(pRenameState->apszOldName);
5548 }
5549 if (pRenameState->apszNewName)
5550 {
5551 for (unsigned i = 0; i <= pRenameState->cExtents; i++)
5552 if (pRenameState->apszNewName[i])
5553 RTStrFree(pRenameState->apszNewName[i]);
5554 RTMemTmpFree(pRenameState->apszNewName);
5555 }
5556 if (pRenameState->apszNewLines)
5557 {
5558 for (unsigned i = 0; i < pRenameState->cExtents; i++)
5559 if (pRenameState->apszNewLines[i])
5560 RTStrFree(pRenameState->apszNewLines[i]);
5561 RTMemTmpFree(pRenameState->apszNewLines);
5562 }
5563 if (pRenameState->pszOldDescName)
5564 RTStrFree(pRenameState->pszOldDescName);
5565 if (pRenameState->pszOldBaseName)
5566 RTStrFree(pRenameState->pszOldBaseName);
5567 if (pRenameState->pszNewBaseName)
5568 RTStrFree(pRenameState->pszNewBaseName);
5569 if (pRenameState->pszOldFullName)
5570 RTStrFree(pRenameState->pszOldFullName);
5571 if (pRenameState->pszNewFullName)
5572 RTStrFree(pRenameState->pszNewFullName);
5573}
5574
5575/**
5576 * Rolls back the rename operation to the original state.
5577 *
5578 * @returns VBox status code.
5579 * @param pImage VMDK image instance.
5580 * @param pRenameState The rename state.
5581 */
5582static int vmdkRenameRollback(PVMDKIMAGE pImage, PVMDKRENAMESTATE pRenameState)
5583{
5584 int rc = VINF_SUCCESS;
5585
5586 if (!pRenameState->fImageFreed)
5587 {
5588 /*
5589 * Some extents may have been closed, close the rest. We will
5590 * re-open the whole thing later.
5591 */
5592 vmdkFreeImage(pImage, false, true /*fFlush*/);
5593 }
5594
5595 /* Rename files back. */
5596 for (unsigned i = 0; i <= pRenameState->cExtents; i++)
5597 {
5598 if (pRenameState->apszOldName[i])
5599 {
5600 rc = vdIfIoIntFileMove(pImage->pIfIo, pRenameState->apszNewName[i], pRenameState->apszOldName[i], 0);
5601 AssertRC(rc);
5602 }
5603 }
5604 /* Restore the old descriptor. */
5605 PVMDKFILE pFile;
5606 rc = vmdkFileOpen(pImage, &pFile, NULL, pRenameState->pszOldDescName,
5607 VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_NORMAL,
5608 false /* fCreate */));
5609 AssertRC(rc);
5610 if (pRenameState->fEmbeddedDesc)
5611 {
5612 pRenameState->ExtentCopy.pFile = pFile;
5613 pImage->pExtents = &pRenameState->ExtentCopy;
5614 }
5615 else
5616 {
5617 /* Shouldn't be null for separate descriptor.
5618 * There will be no access to the actual content.
5619 */
5620 pImage->pDescData = pRenameState->pszOldDescName;
5621 pImage->pFile = pFile;
5622 }
5623 pImage->Descriptor = pRenameState->DescriptorCopy;
5624 vmdkWriteDescriptor(pImage, NULL);
5625 vmdkFileClose(pImage, &pFile, false);
5626 /* Get rid of the stuff we implanted. */
5627 pImage->pExtents = NULL;
5628 pImage->pFile = NULL;
5629 pImage->pDescData = NULL;
5630 /* Re-open the image back. */
5631 pImage->pszFilename = pRenameState->pszOldImageName;
5632 rc = vmdkOpenImage(pImage, pImage->uOpenFlags);
5633
5634 return rc;
5635}
5636
5637/**
5638 * Rename worker doing the real work.
5639 *
5640 * @returns VBox status code.
5641 * @param pImage VMDK image instance.
5642 * @param pRenameState The rename state.
5643 * @param pszFilename The new filename.
5644 */
5645static int vmdkRenameWorker(PVMDKIMAGE pImage, PVMDKRENAMESTATE pRenameState, const char *pszFilename)
5646{
5647 int rc = VINF_SUCCESS;
5648 unsigned i, line;
5649
5650 /* Update the descriptor with modified extent names. */
5651 for (i = 0, line = pImage->Descriptor.uFirstExtent;
5652 i < pRenameState->cExtents;
5653 i++, line = pImage->Descriptor.aNextLines[line])
5654 {
5655 /* Update the descriptor. */
5656 pRenameState->apszNewLines[i] = vmdkStrReplace(pImage->Descriptor.aLines[line],
5657 pRenameState->pszOldBaseName,
5658 pRenameState->pszNewBaseName);
5659 if (!pRenameState->apszNewLines[i])
5660 {
5661 rc = VERR_NO_MEMORY;
5662 break;
5663 }
5664 pImage->Descriptor.aLines[line] = pRenameState->apszNewLines[i];
5665 }
5666
5667 if (RT_SUCCESS(rc))
5668 {
5669 /* Make sure the descriptor gets written back. */
5670 pImage->Descriptor.fDirty = true;
5671 /* Flush the descriptor now, in case it is embedded. */
5672 vmdkFlushImage(pImage, NULL);
5673
5674 /* Close and rename/move extents. */
5675 for (i = 0; i < pRenameState->cExtents; i++)
5676 {
5677 PVMDKEXTENT pExtent = &pImage->pExtents[i];
5678 /* Compose new name for the extent. */
5679 pRenameState->apszNewName[i] = vmdkStrReplace(pExtent->pszFullname,
5680 pRenameState->pszOldFullName,
5681 pRenameState->pszNewFullName);
5682 if (!pRenameState->apszNewName[i])
5683 {
5684 rc = VERR_NO_MEMORY;
5685 break;
5686 }
5687 /* Close the extent file. */
5688 rc = vmdkFileClose(pImage, &pExtent->pFile, false);
5689 if (RT_FAILURE(rc))
5690 break;;
5691
5692 /* Rename the extent file. */
5693 rc = vdIfIoIntFileMove(pImage->pIfIo, pExtent->pszFullname, pRenameState->apszNewName[i], 0);
5694 if (RT_FAILURE(rc))
5695 break;
5696 /* Remember the old name. */
5697 pRenameState->apszOldName[i] = RTStrDup(pExtent->pszFullname);
5698 }
5699
5700 if (RT_SUCCESS(rc))
5701 {
5702 /* Release all old stuff. */
5703 rc = vmdkFreeImage(pImage, false, true /*fFlush*/);
5704 if (RT_SUCCESS(rc))
5705 {
5706 pRenameState->fImageFreed = true;
5707
5708 /* Last elements of new/old name arrays are intended for
5709 * storing descriptor's names.
5710 */
5711 pRenameState->apszNewName[pRenameState->cExtents] = RTStrDup(pszFilename);
5712 /* Rename the descriptor file if it's separate. */
5713 if (!pRenameState->fEmbeddedDesc)
5714 {
5715 rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pRenameState->apszNewName[pRenameState->cExtents], 0);
5716 if (RT_SUCCESS(rc))
5717 {
5718 /* Save old name only if we may need to change it back. */
5719 pRenameState->apszOldName[pRenameState->cExtents] = RTStrDup(pszFilename);
5720 }
5721 }
5722
5723 /* Update pImage with the new information. */
5724 pImage->pszFilename = pszFilename;
5725
5726 /* Open the new image. */
5727 rc = vmdkOpenImage(pImage, pImage->uOpenFlags);
5728 }
5729 }
5730 }
5731
5732 return rc;
5733}
5734
5735/** @copydoc VDIMAGEBACKEND::pfnRename */
5736static DECLCALLBACK(int) vmdkRename(void *pBackendData, const char *pszFilename)
5737{
5738 LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
5739
5740 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
5741 VMDKRENAMESTATE RenameState;
5742
5743 memset(&RenameState, 0, sizeof(RenameState));
5744
5745 /* Check arguments. */
5746 AssertReturn(( pImage
5747 && VALID_PTR(pszFilename)
5748 && *pszFilename
5749 && !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)), VERR_INVALID_PARAMETER);
5750
5751 int rc = vmdkRenameStatePrepare(pImage, &RenameState, pszFilename);
5752 if (RT_SUCCESS(rc))
5753 {
5754 /* --- Up to this point we have not done any damage yet. --- */
5755
5756 rc = vmdkRenameWorker(pImage, &RenameState, pszFilename);
5757 /* Roll back all changes in case of failure. */
5758 if (RT_FAILURE(rc))
5759 {
5760 int rrc = vmdkRenameRollback(pImage, &RenameState);
5761 AssertRC(rrc);
5762 }
5763 }
5764
5765 vmdkRenameStateDestroy(&RenameState);
5766 LogFlowFunc(("returns %Rrc\n", rc));
5767 return rc;
5768}
5769
5770/** @copydoc VDIMAGEBACKEND::pfnClose */
5771static DECLCALLBACK(int) vmdkClose(void *pBackendData, bool fDelete)
5772{
5773 LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
5774 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
5775
5776 int rc = vmdkFreeImage(pImage, fDelete, true /*fFlush*/);
5777 RTMemFree(pImage);
5778
5779 LogFlowFunc(("returns %Rrc\n", rc));
5780 return rc;
5781}
5782
5783/** @copydoc VDIMAGEBACKEND::pfnRead */
5784static DECLCALLBACK(int) vmdkRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
5785 PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
5786{
5787 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
5788 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
5789 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
5790
5791 AssertPtr(pImage);
5792 Assert(uOffset % 512 == 0);
5793 Assert(cbToRead % 512 == 0);
5794 AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
5795 AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
5796
5797 /* Find the extent and check access permissions as defined in the extent descriptor. */
5798 PVMDKEXTENT pExtent;
5799 uint64_t uSectorExtentRel;
5800 int rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
5801 &pExtent, &uSectorExtentRel);
5802 if ( RT_SUCCESS(rc)
5803 && pExtent->enmAccess != VMDKACCESS_NOACCESS)
5804 {
5805 /* Clip read range to remain in this extent. */
5806 cbToRead = RT_MIN(cbToRead, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
5807
5808 /* Handle the read according to the current extent type. */
5809 switch (pExtent->enmType)
5810 {
5811 case VMDKETYPE_HOSTED_SPARSE:
5812 {
5813 uint64_t uSectorExtentAbs;
5814
5815 rc = vmdkGetSector(pImage, pIoCtx, pExtent, uSectorExtentRel, &uSectorExtentAbs);
5816 if (RT_FAILURE(rc))
5817 break;
5818 /* Clip read range to at most the rest of the grain. */
5819 cbToRead = RT_MIN(cbToRead, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSectorExtentRel % pExtent->cSectorsPerGrain));
5820 Assert(!(cbToRead % 512));
5821 if (uSectorExtentAbs == 0)
5822 {
5823 if ( !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
5824 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
5825 || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
5826 rc = VERR_VD_BLOCK_FREE;
5827 else
5828 rc = vmdkStreamReadSequential(pImage, pExtent,
5829 uSectorExtentRel,
5830 pIoCtx, cbToRead);
5831 }
5832 else
5833 {
5834 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
5835 {
5836 AssertMsg(vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx),
5837 ("Async I/O is not supported for stream optimized VMDK's\n"));
5838
5839 uint32_t uSectorInGrain = uSectorExtentRel % pExtent->cSectorsPerGrain;
5840 uSectorExtentAbs -= uSectorInGrain;
5841 if (pExtent->uGrainSectorAbs != uSectorExtentAbs)
5842 {
5843 uint64_t uLBA = 0; /* gcc maybe uninitialized */
5844 rc = vmdkFileInflateSync(pImage, pExtent,
5845 VMDK_SECTOR2BYTE(uSectorExtentAbs),
5846 pExtent->pvGrain,
5847 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
5848 NULL, &uLBA, NULL);
5849 if (RT_FAILURE(rc))
5850 {
5851 pExtent->uGrainSectorAbs = 0;
5852 break;
5853 }
5854 pExtent->uGrainSectorAbs = uSectorExtentAbs;
5855 pExtent->uGrain = uSectorExtentRel / pExtent->cSectorsPerGrain;
5856 Assert(uLBA == uSectorExtentRel);
5857 }
5858 vdIfIoIntIoCtxCopyTo(pImage->pIfIo, pIoCtx,
5859 (uint8_t *)pExtent->pvGrain
5860 + VMDK_SECTOR2BYTE(uSectorInGrain),
5861 cbToRead);
5862 }
5863 else
5864 rc = vdIfIoIntFileReadUser(pImage->pIfIo, pExtent->pFile->pStorage,
5865 VMDK_SECTOR2BYTE(uSectorExtentAbs),
5866 pIoCtx, cbToRead);
5867 }
5868 break;
5869 }
5870 case VMDKETYPE_VMFS:
5871 case VMDKETYPE_FLAT:
5872 rc = vdIfIoIntFileReadUser(pImage->pIfIo, pExtent->pFile->pStorage,
5873 VMDK_SECTOR2BYTE(uSectorExtentRel),
5874 pIoCtx, cbToRead);
5875 break;
5876 case VMDKETYPE_ZERO:
5877 {
5878 size_t cbSet;
5879
5880 cbSet = vdIfIoIntIoCtxSet(pImage->pIfIo, pIoCtx, 0, cbToRead);
5881 Assert(cbSet == cbToRead);
5882 break;
5883 }
5884 }
5885 if (pcbActuallyRead)
5886 *pcbActuallyRead = cbToRead;
5887 }
5888 else if (RT_SUCCESS(rc))
5889 rc = VERR_VD_VMDK_INVALID_STATE;
5890
5891 LogFlowFunc(("returns %Rrc\n", rc));
5892 return rc;
5893}
5894
5895/** @copydoc VDIMAGEBACKEND::pfnWrite */
5896static DECLCALLBACK(int) vmdkWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
5897 PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
5898 size_t *pcbPostRead, unsigned fWrite)
5899{
5900 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
5901 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
5902 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
5903 int rc;
5904
5905 AssertPtr(pImage);
5906 Assert(uOffset % 512 == 0);
5907 Assert(cbToWrite % 512 == 0);
5908 AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
5909
5910 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
5911 {
5912 PVMDKEXTENT pExtent;
5913 uint64_t uSectorExtentRel;
5914 uint64_t uSectorExtentAbs;
5915
5916 /* No size check here, will do that later when the extent is located.
5917 * There are sparse images out there which according to the spec are
5918 * invalid, because the total size is not a multiple of the grain size.
5919 * Also for sparse images which are stitched together in odd ways (not at
5920 * grain boundaries, and with the nominal size not being a multiple of the
5921 * grain size), this would prevent writing to the last grain. */
5922
5923 rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
5924 &pExtent, &uSectorExtentRel);
5925 if (RT_SUCCESS(rc))
5926 {
5927 if ( pExtent->enmAccess != VMDKACCESS_READWRITE
5928 && ( !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
5929 && !pImage->pExtents[0].uAppendPosition
5930 && pExtent->enmAccess != VMDKACCESS_READONLY))
5931 rc = VERR_VD_VMDK_INVALID_STATE;
5932 else
5933 {
5934 /* Handle the write according to the current extent type. */
5935 switch (pExtent->enmType)
5936 {
5937 case VMDKETYPE_HOSTED_SPARSE:
5938 rc = vmdkGetSector(pImage, pIoCtx, pExtent, uSectorExtentRel, &uSectorExtentAbs);
5939 if (RT_SUCCESS(rc))
5940 {
5941 if ( pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
5942 && uSectorExtentRel < (uint64_t)pExtent->uLastGrainAccess * pExtent->cSectorsPerGrain)
5943 rc = VERR_VD_VMDK_INVALID_WRITE;
5944 else
5945 {
5946 /* Clip write range to at most the rest of the grain. */
5947 cbToWrite = RT_MIN(cbToWrite,
5948 VMDK_SECTOR2BYTE( pExtent->cSectorsPerGrain
5949 - uSectorExtentRel % pExtent->cSectorsPerGrain));
5950 if (uSectorExtentAbs == 0)
5951 {
5952 if (!(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
5953 {
5954 if (cbToWrite == VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
5955 {
5956 /* Full block write to a previously unallocated block.
5957 * Check if the caller wants to avoid the automatic alloc. */
5958 if (!(fWrite & VD_WRITE_NO_ALLOC))
5959 {
5960 /* Allocate GT and find out where to store the grain. */
5961 rc = vmdkAllocGrain(pImage, pExtent, pIoCtx,
5962 uSectorExtentRel, cbToWrite);
5963 }
5964 else
5965 rc = VERR_VD_BLOCK_FREE;
5966 *pcbPreRead = 0;
5967 *pcbPostRead = 0;
5968 }
5969 else
5970 {
5971 /* Clip write range to remain in this extent. */
5972 cbToWrite = RT_MIN(cbToWrite,
5973 VMDK_SECTOR2BYTE( pExtent->uSectorOffset
5974 + pExtent->cNominalSectors - uSectorExtentRel));
5975 *pcbPreRead = VMDK_SECTOR2BYTE(uSectorExtentRel % pExtent->cSectorsPerGrain);
5976 *pcbPostRead = VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbToWrite - *pcbPreRead;
5977 rc = VERR_VD_BLOCK_FREE;
5978 }
5979 }
5980 else
5981 rc = vmdkStreamAllocGrain(pImage, pExtent, uSectorExtentRel,
5982 pIoCtx, cbToWrite);
5983 }
5984 else
5985 {
5986 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
5987 {
5988 /* A partial write to a streamOptimized image is simply
5989 * invalid. It requires rewriting already compressed data
5990 * which is somewhere between expensive and impossible. */
5991 rc = VERR_VD_VMDK_INVALID_STATE;
5992 pExtent->uGrainSectorAbs = 0;
5993 AssertRC(rc);
5994 }
5995 else
5996 {
5997 Assert(!(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED));
5998 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pExtent->pFile->pStorage,
5999 VMDK_SECTOR2BYTE(uSectorExtentAbs),
6000 pIoCtx, cbToWrite, NULL, NULL);
6001 }
6002 }
6003 }
6004 }
6005 break;
6006 case VMDKETYPE_VMFS:
6007 case VMDKETYPE_FLAT:
6008 /* Clip write range to remain in this extent. */
6009 cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
6010 rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pExtent->pFile->pStorage,
6011 VMDK_SECTOR2BYTE(uSectorExtentRel),
6012 pIoCtx, cbToWrite, NULL, NULL);
6013 break;
6014 case VMDKETYPE_ZERO:
6015 /* Clip write range to remain in this extent. */
6016 cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
6017 break;
6018 }
6019 }
6020
6021 if (pcbWriteProcess)
6022 *pcbWriteProcess = cbToWrite;
6023 }
6024 }
6025 else
6026 rc = VERR_VD_IMAGE_READ_ONLY;
6027
6028 LogFlowFunc(("returns %Rrc\n", rc));
6029 return rc;
6030}
6031
6032/** @copydoc VDIMAGEBACKEND::pfnFlush */
6033static DECLCALLBACK(int) vmdkFlush(void *pBackendData, PVDIOCTX pIoCtx)
6034{
6035 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6036
6037 return vmdkFlushImage(pImage, pIoCtx);
6038}
6039
6040/** @copydoc VDIMAGEBACKEND::pfnGetVersion */
6041static DECLCALLBACK(unsigned) vmdkGetVersion(void *pBackendData)
6042{
6043 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
6044 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6045
6046 AssertPtrReturn(pImage, 0);
6047
6048 return VMDK_IMAGE_VERSION;
6049}
6050
6051/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
6052static DECLCALLBACK(uint64_t) vmdkGetFileSize(void *pBackendData)
6053{
6054 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
6055 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6056 uint64_t cb = 0;
6057
6058 AssertPtrReturn(pImage, 0);
6059
6060 if (pImage->pFile != NULL)
6061 {
6062 uint64_t cbFile;
6063 int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pFile->pStorage, &cbFile);
6064 if (RT_SUCCESS(rc))
6065 cb += cbFile;
6066 }
6067 for (unsigned i = 0; i < pImage->cExtents; i++)
6068 {
6069 if (pImage->pExtents[i].pFile != NULL)
6070 {
6071 uint64_t cbFile;
6072 int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pExtents[i].pFile->pStorage, &cbFile);
6073 if (RT_SUCCESS(rc))
6074 cb += cbFile;
6075 }
6076 }
6077
6078 LogFlowFunc(("returns %lld\n", cb));
6079 return cb;
6080}
6081
6082/** @copydoc VDIMAGEBACKEND::pfnGetPCHSGeometry */
6083static DECLCALLBACK(int) vmdkGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
6084{
6085 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
6086 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6087 int rc = VINF_SUCCESS;
6088
6089 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6090
6091 if (pImage->PCHSGeometry.cCylinders)
6092 *pPCHSGeometry = pImage->PCHSGeometry;
6093 else
6094 rc = VERR_VD_GEOMETRY_NOT_SET;
6095
6096 LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
6097 return rc;
6098}
6099
6100/** @copydoc VDIMAGEBACKEND::pfnSetPCHSGeometry */
6101static DECLCALLBACK(int) vmdkSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
6102{
6103 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
6104 pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
6105 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6106 int rc = VINF_SUCCESS;
6107
6108 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6109
6110 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6111 {
6112 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6113 {
6114 rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
6115 if (RT_SUCCESS(rc))
6116 pImage->PCHSGeometry = *pPCHSGeometry;
6117 }
6118 else
6119 rc = VERR_NOT_SUPPORTED;
6120 }
6121 else
6122 rc = VERR_VD_IMAGE_READ_ONLY;
6123
6124 LogFlowFunc(("returns %Rrc\n", rc));
6125 return rc;
6126}
6127
6128/** @copydoc VDIMAGEBACKEND::pfnGetLCHSGeometry */
6129static DECLCALLBACK(int) vmdkGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
6130{
6131 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
6132 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6133 int rc = VINF_SUCCESS;
6134
6135 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6136
6137 if (pImage->LCHSGeometry.cCylinders)
6138 *pLCHSGeometry = pImage->LCHSGeometry;
6139 else
6140 rc = VERR_VD_GEOMETRY_NOT_SET;
6141
6142 LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
6143 return rc;
6144}
6145
6146/** @copydoc VDIMAGEBACKEND::pfnSetLCHSGeometry */
6147static DECLCALLBACK(int) vmdkSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
6148{
6149 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
6150 pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
6151 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6152 int rc = VINF_SUCCESS;
6153
6154 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6155
6156 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6157 {
6158 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6159 {
6160 rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
6161 if (RT_SUCCESS(rc))
6162 pImage->LCHSGeometry = *pLCHSGeometry;
6163 }
6164 else
6165 rc = VERR_NOT_SUPPORTED;
6166 }
6167 else
6168 rc = VERR_VD_IMAGE_READ_ONLY;
6169
6170 LogFlowFunc(("returns %Rrc\n", rc));
6171 return rc;
6172}
6173
6174/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
6175static DECLCALLBACK(int) vmdkQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
6176{
6177 LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
6178 PVMDKIMAGE pThis = (PVMDKIMAGE)pBackendData;
6179
6180 AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
6181
6182 *ppRegionList = &pThis->RegionList;
6183 LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
6184 return VINF_SUCCESS;
6185}
6186
6187/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
6188static DECLCALLBACK(void) vmdkRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
6189{
6190 RT_NOREF1(pRegionList);
6191 LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
6192 PVMDKIMAGE pThis = (PVMDKIMAGE)pBackendData;
6193 AssertPtr(pThis); RT_NOREF(pThis);
6194
6195 /* Nothing to do here. */
6196}
6197
6198/** @copydoc VDIMAGEBACKEND::pfnGetImageFlags */
6199static DECLCALLBACK(unsigned) vmdkGetImageFlags(void *pBackendData)
6200{
6201 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
6202 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6203
6204 AssertPtrReturn(pImage, 0);
6205
6206 LogFlowFunc(("returns %#x\n", pImage->uImageFlags));
6207 return pImage->uImageFlags;
6208}
6209
6210/** @copydoc VDIMAGEBACKEND::pfnGetOpenFlags */
6211static DECLCALLBACK(unsigned) vmdkGetOpenFlags(void *pBackendData)
6212{
6213 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
6214 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6215
6216 AssertPtrReturn(pImage, 0);
6217
6218 LogFlowFunc(("returns %#x\n", pImage->uOpenFlags));
6219 return pImage->uOpenFlags;
6220}
6221
6222/** @copydoc VDIMAGEBACKEND::pfnSetOpenFlags */
6223static DECLCALLBACK(int) vmdkSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
6224{
6225 LogFlowFunc(("pBackendData=%#p uOpenFlags=%#x\n", pBackendData, uOpenFlags));
6226 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6227 int rc;
6228
6229 /* Image must be opened and the new flags must be valid. */
6230 if (!pImage || (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO
6231 | VD_OPEN_FLAGS_ASYNC_IO | VD_OPEN_FLAGS_SHAREABLE
6232 | VD_OPEN_FLAGS_SEQUENTIAL | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
6233 rc = VERR_INVALID_PARAMETER;
6234 else
6235 {
6236 /* StreamOptimized images need special treatment: reopen is prohibited. */
6237 if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
6238 {
6239 if (pImage->uOpenFlags == uOpenFlags)
6240 rc = VINF_SUCCESS;
6241 else
6242 rc = VERR_INVALID_PARAMETER;
6243 }
6244 else
6245 {
6246 /* Implement this operation via reopening the image. */
6247 vmdkFreeImage(pImage, false, true /*fFlush*/);
6248 rc = vmdkOpenImage(pImage, uOpenFlags);
6249 }
6250 }
6251
6252 LogFlowFunc(("returns %Rrc\n", rc));
6253 return rc;
6254}
6255
6256/** @copydoc VDIMAGEBACKEND::pfnGetComment */
6257static DECLCALLBACK(int) vmdkGetComment(void *pBackendData, char *pszComment, size_t cbComment)
6258{
6259 LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
6260 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6261
6262 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6263
6264 char *pszCommentEncoded = NULL;
6265 int rc = vmdkDescDDBGetStr(pImage, &pImage->Descriptor,
6266 "ddb.comment", &pszCommentEncoded);
6267 if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
6268 {
6269 pszCommentEncoded = NULL;
6270 rc = VINF_SUCCESS;
6271 }
6272
6273 if (RT_SUCCESS(rc))
6274 {
6275 if (pszComment && pszCommentEncoded)
6276 rc = vmdkDecodeString(pszCommentEncoded, pszComment, cbComment);
6277 else if (pszComment)
6278 *pszComment = '\0';
6279
6280 if (pszCommentEncoded)
6281 RTMemTmpFree(pszCommentEncoded);
6282 }
6283
6284 LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
6285 return rc;
6286}
6287
6288/** @copydoc VDIMAGEBACKEND::pfnSetComment */
6289static DECLCALLBACK(int) vmdkSetComment(void *pBackendData, const char *pszComment)
6290{
6291 LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
6292 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6293 int rc;
6294
6295 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6296
6297 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6298 {
6299 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6300 rc = vmdkSetImageComment(pImage, pszComment);
6301 else
6302 rc = VERR_NOT_SUPPORTED;
6303 }
6304 else
6305 rc = VERR_VD_IMAGE_READ_ONLY;
6306
6307 LogFlowFunc(("returns %Rrc\n", rc));
6308 return rc;
6309}
6310
6311/** @copydoc VDIMAGEBACKEND::pfnGetUuid */
6312static DECLCALLBACK(int) vmdkGetUuid(void *pBackendData, PRTUUID pUuid)
6313{
6314 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
6315 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6316
6317 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6318
6319 *pUuid = pImage->ImageUuid;
6320
6321 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
6322 return VINF_SUCCESS;
6323}
6324
6325/** @copydoc VDIMAGEBACKEND::pfnSetUuid */
6326static DECLCALLBACK(int) vmdkSetUuid(void *pBackendData, PCRTUUID pUuid)
6327{
6328 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
6329 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6330 int rc = VINF_SUCCESS;
6331
6332 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6333
6334 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6335 {
6336 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6337 {
6338 pImage->ImageUuid = *pUuid;
6339 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
6340 VMDK_DDB_IMAGE_UUID, pUuid);
6341 if (RT_FAILURE(rc))
6342 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
6343 N_("VMDK: error storing image UUID in descriptor in '%s'"), pImage->pszFilename);
6344 }
6345 else
6346 rc = VERR_NOT_SUPPORTED;
6347 }
6348 else
6349 rc = VERR_VD_IMAGE_READ_ONLY;
6350
6351 LogFlowFunc(("returns %Rrc\n", rc));
6352 return rc;
6353}
6354
6355/** @copydoc VDIMAGEBACKEND::pfnGetModificationUuid */
6356static DECLCALLBACK(int) vmdkGetModificationUuid(void *pBackendData, PRTUUID pUuid)
6357{
6358 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
6359 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6360
6361 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6362
6363 *pUuid = pImage->ModificationUuid;
6364
6365 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
6366 return VINF_SUCCESS;
6367}
6368
6369/** @copydoc VDIMAGEBACKEND::pfnSetModificationUuid */
6370static DECLCALLBACK(int) vmdkSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
6371{
6372 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
6373 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6374 int rc = VINF_SUCCESS;
6375
6376 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6377
6378 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6379 {
6380 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6381 {
6382 /* Only touch the modification uuid if it changed. */
6383 if (RTUuidCompare(&pImage->ModificationUuid, pUuid))
6384 {
6385 pImage->ModificationUuid = *pUuid;
6386 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
6387 VMDK_DDB_MODIFICATION_UUID, pUuid);
6388 if (RT_FAILURE(rc))
6389 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing modification UUID in descriptor in '%s'"), pImage->pszFilename);
6390 }
6391 }
6392 else
6393 rc = VERR_NOT_SUPPORTED;
6394 }
6395 else
6396 rc = VERR_VD_IMAGE_READ_ONLY;
6397
6398 LogFlowFunc(("returns %Rrc\n", rc));
6399 return rc;
6400}
6401
6402/** @copydoc VDIMAGEBACKEND::pfnGetParentUuid */
6403static DECLCALLBACK(int) vmdkGetParentUuid(void *pBackendData, PRTUUID pUuid)
6404{
6405 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
6406 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6407
6408 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6409
6410 *pUuid = pImage->ParentUuid;
6411
6412 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
6413 return VINF_SUCCESS;
6414}
6415
6416/** @copydoc VDIMAGEBACKEND::pfnSetParentUuid */
6417static DECLCALLBACK(int) vmdkSetParentUuid(void *pBackendData, PCRTUUID pUuid)
6418{
6419 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
6420 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6421 int rc = VINF_SUCCESS;
6422
6423 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6424
6425 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6426 {
6427 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6428 {
6429 pImage->ParentUuid = *pUuid;
6430 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
6431 VMDK_DDB_PARENT_UUID, pUuid);
6432 if (RT_FAILURE(rc))
6433 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
6434 N_("VMDK: error storing parent image UUID in descriptor in '%s'"), pImage->pszFilename);
6435 }
6436 else
6437 rc = VERR_NOT_SUPPORTED;
6438 }
6439 else
6440 rc = VERR_VD_IMAGE_READ_ONLY;
6441
6442 LogFlowFunc(("returns %Rrc\n", rc));
6443 return rc;
6444}
6445
6446/** @copydoc VDIMAGEBACKEND::pfnGetParentModificationUuid */
6447static DECLCALLBACK(int) vmdkGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
6448{
6449 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
6450 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6451
6452 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6453
6454 *pUuid = pImage->ParentModificationUuid;
6455
6456 LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
6457 return VINF_SUCCESS;
6458}
6459
6460/** @copydoc VDIMAGEBACKEND::pfnSetParentModificationUuid */
6461static DECLCALLBACK(int) vmdkSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
6462{
6463 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
6464 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6465 int rc = VINF_SUCCESS;
6466
6467 AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
6468
6469 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
6470 {
6471 if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
6472 {
6473 pImage->ParentModificationUuid = *pUuid;
6474 rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
6475 VMDK_DDB_PARENT_MODIFICATION_UUID, pUuid);
6476 if (RT_FAILURE(rc))
6477 rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing parent image UUID in descriptor in '%s'"), pImage->pszFilename);
6478 }
6479 else
6480 rc = VERR_NOT_SUPPORTED;
6481 }
6482 else
6483 rc = VERR_VD_IMAGE_READ_ONLY;
6484
6485 LogFlowFunc(("returns %Rrc\n", rc));
6486 return rc;
6487}
6488
6489/** @copydoc VDIMAGEBACKEND::pfnDump */
6490static DECLCALLBACK(void) vmdkDump(void *pBackendData)
6491{
6492 PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
6493
6494 AssertPtrReturnVoid(pImage);
6495 vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
6496 pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
6497 pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
6498 VMDK_BYTE2SECTOR(pImage->cbSize));
6499 vdIfErrorMessage(pImage->pIfError, "Header: uuidCreation={%RTuuid}\n", &pImage->ImageUuid);
6500 vdIfErrorMessage(pImage->pIfError, "Header: uuidModification={%RTuuid}\n", &pImage->ModificationUuid);
6501 vdIfErrorMessage(pImage->pIfError, "Header: uuidParent={%RTuuid}\n", &pImage->ParentUuid);
6502 vdIfErrorMessage(pImage->pIfError, "Header: uuidParentModification={%RTuuid}\n", &pImage->ParentModificationUuid);
6503}
6504
6505
6506
6507const VDIMAGEBACKEND g_VmdkBackend =
6508{
6509 /* u32Version */
6510 VD_IMGBACKEND_VERSION,
6511 /* pszBackendName */
6512 "VMDK",
6513 /* uBackendCaps */
6514 VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
6515 | VD_CAP_CREATE_SPLIT_2G | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC
6516 | VD_CAP_VFS | VD_CAP_PREFERRED,
6517 /* paFileExtensions */
6518 s_aVmdkFileExtensions,
6519 /* paConfigInfo */
6520 NULL,
6521 /* pfnProbe */
6522 vmdkProbe,
6523 /* pfnOpen */
6524 vmdkOpen,
6525 /* pfnCreate */
6526 vmdkCreate,
6527 /* pfnRename */
6528 vmdkRename,
6529 /* pfnClose */
6530 vmdkClose,
6531 /* pfnRead */
6532 vmdkRead,
6533 /* pfnWrite */
6534 vmdkWrite,
6535 /* pfnFlush */
6536 vmdkFlush,
6537 /* pfnDiscard */
6538 NULL,
6539 /* pfnGetVersion */
6540 vmdkGetVersion,
6541 /* pfnGetFileSize */
6542 vmdkGetFileSize,
6543 /* pfnGetPCHSGeometry */
6544 vmdkGetPCHSGeometry,
6545 /* pfnSetPCHSGeometry */
6546 vmdkSetPCHSGeometry,
6547 /* pfnGetLCHSGeometry */
6548 vmdkGetLCHSGeometry,
6549 /* pfnSetLCHSGeometry */
6550 vmdkSetLCHSGeometry,
6551 /* pfnQueryRegions */
6552 vmdkQueryRegions,
6553 /* pfnRegionListRelease */
6554 vmdkRegionListRelease,
6555 /* pfnGetImageFlags */
6556 vmdkGetImageFlags,
6557 /* pfnGetOpenFlags */
6558 vmdkGetOpenFlags,
6559 /* pfnSetOpenFlags */
6560 vmdkSetOpenFlags,
6561 /* pfnGetComment */
6562 vmdkGetComment,
6563 /* pfnSetComment */
6564 vmdkSetComment,
6565 /* pfnGetUuid */
6566 vmdkGetUuid,
6567 /* pfnSetUuid */
6568 vmdkSetUuid,
6569 /* pfnGetModificationUuid */
6570 vmdkGetModificationUuid,
6571 /* pfnSetModificationUuid */
6572 vmdkSetModificationUuid,
6573 /* pfnGetParentUuid */
6574 vmdkGetParentUuid,
6575 /* pfnSetParentUuid */
6576 vmdkSetParentUuid,
6577 /* pfnGetParentModificationUuid */
6578 vmdkGetParentModificationUuid,
6579 /* pfnSetParentModificationUuid */
6580 vmdkSetParentModificationUuid,
6581 /* pfnDump */
6582 vmdkDump,
6583 /* pfnGetTimestamp */
6584 NULL,
6585 /* pfnGetParentTimestamp */
6586 NULL,
6587 /* pfnSetParentTimestamp */
6588 NULL,
6589 /* pfnGetParentFilename */
6590 NULL,
6591 /* pfnSetParentFilename */
6592 NULL,
6593 /* pfnComposeLocation */
6594 genericFileComposeLocation,
6595 /* pfnComposeName */
6596 genericFileComposeName,
6597 /* pfnCompact */
6598 NULL,
6599 /* pfnResize */
6600 NULL,
6601 /* pfnRepair */
6602 NULL,
6603 /* pfnTraverseMetadata */
6604 NULL,
6605 /* u32VersionEnd */
6606 VD_IMGBACKEND_VERSION
6607};
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