VMDK.cpp@ 72577

Last change on this file since 72577 was 70853, checked in by vboxsync, 7 years ago
Storage/VMDK: Quick fix for handling descriptors of VMDK images created by Amazon EC2 VM Export
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 255.2 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: