VmdkHDDCore.cpp@ 13303

Last change on this file since 13303 was 13295, checked in by vboxsync, 16 years ago
#3230: Fixed memory leaks in VMDK, tstVD and VBoxHDD-new.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 190.8 KB

Line
1	/* $Id: VmdkHDDCore.cpp 13295 2008-10-15 18:07:59Z vboxsync $ */
2	/** @file
3	* VMDK Disk image, Core Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	#define LOG_GROUP LOG_GROUP_VD_VMDK
26	#include "VBoxHDD-newInternal.h"
27	#include <VBox/err.h>
28
29	#include <VBox/log.h>
30	#include <iprt/assert.h>
31	#include <iprt/alloc.h>
32	#include <iprt/uuid.h>
33	#include <iprt/file.h>
34	#include <iprt/path.h>
35	#include <iprt/string.h>
36	#include <iprt/rand.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	/**
78	* Magic number for hosted images created by VMware Workstation 4, VMware
79	* Workstation 5, VMware Server or VMware Player. Not necessarily sparse.
80	*/
81	#define VMDK_SPARSE_MAGICNUMBER 0x564d444b /* 'V' 'M' 'D' 'K' */
82
83	/**
84	* VMDK hosted binary extent header. The "Sparse" is a total misnomer, as
85	* this header is also used for monolithic flat images.
86	*/
87	#pragma pack(1)
88	typedef struct SparseExtentHeader
89	{
90	uint32_t magicNumber;
91	uint32_t version;
92	uint32_t flags;
93	uint64_t capacity;
94	uint64_t grainSize;
95	uint64_t descriptorOffset;
96	uint64_t descriptorSize;
97	uint32_t numGTEsPerGT;
98	uint64_t rgdOffset;
99	uint64_t gdOffset;
100	uint64_t overHead;
101	bool uncleanShutdown;
102	char singleEndLineChar;
103	char nonEndLineChar;
104	char doubleEndLineChar1;
105	char doubleEndLineChar2;
106	uint8_t pad[435];
107	} SparseExtentHeader;
108	#pragma pack()
109
110	/** VMDK capacity for a single chunk when 2G splitting is turned on. Should be
111	* divisible by the default grain size (64K) */
112	#define VMDK_2G_SPLIT_SIZE (2047 * 1024 * 1024)
113
114
115	#ifdef VBOX_WITH_VMDK_ESX
116
117	/** @todo the ESX code is not tested, not used, and lacks error messages. */
118
119	/**
120	* Magic number for images created by VMware GSX Server 3 or ESX Server 3.
121	*/
122	#define VMDK_ESX_SPARSE_MAGICNUMBER 0x44574f43 /* 'C' 'O' 'W' 'D' */
123
124	#pragma pack(1)
125	typedef struct COWDisk_Header
126	{
127	uint32_t magicNumber;
128	uint32_t version;
129	uint32_t flags;
130	uint32_t numSectors;
131	uint32_t grainSize;
132	uint32_t gdOffset;
133	uint32_t numGDEntries;
134	uint32_t freeSector;
135	/* The spec incompletely documents quite a few further fields, but states
136	* that they are unused by the current format. Replace them by padding. */
137	char reserved1[1604];
138	uint32_t savedGeneration;
139	char reserved2[8];
140	uint32_t uncleanShutdown;
141	char padding[396];
142	} COWDisk_Header;
143	#pragma pack()
144	#endif /* VBOX_WITH_VMDK_ESX */
145
146
147	/** Convert sector number/size to byte offset/size. */
148	#define VMDK_SECTOR2BYTE(u) ((u) << 9)
149
150	/** Convert byte offset/size to sector number/size. */
151	#define VMDK_BYTE2SECTOR(u) ((u) >> 9)
152
153	/**
154	* VMDK extent type.
155	*/
156	typedef enum VMDKETYPE
157	{
158	/** Hosted sparse extent. */
159	VMDKETYPE_HOSTED_SPARSE = 1,
160	/** Flat extent. */
161	VMDKETYPE_FLAT,
162	/** Zero extent. */
163	VMDKETYPE_ZERO
164	#ifdef VBOX_WITH_VMDK_ESX
165	,
166	/** ESX sparse extent. */
167	VMDKETYPE_ESX_SPARSE
168	#endif /* VBOX_WITH_VMDK_ESX */
169	} VMDKETYPE, *PVMDKETYPE;
170
171	/**
172	* VMDK access type for a extent.
173	*/
174	typedef enum VMDKACCESS
175	{
176	/** No access allowed. */
177	VMDKACCESS_NOACCESS = 0,
178	/** Read-only access. */
179	VMDKACCESS_READONLY,
180	/** Read-write access. */
181	VMDKACCESS_READWRITE
182	} VMDKACCESS, *PVMDKACCESS;
183
184	/** Forward declaration for PVMDKIMAGE. */
185	typedef struct VMDKIMAGE *PVMDKIMAGE;
186
187	/**
188	* Extents files entry. Used for opening a particular file only once.
189	*/
190	typedef struct VMDKFILE
191	{
192	/** Pointer to filename. Local copy. */
193	const char *pszFilename;
194	/** File open flags for consistency checking. */
195	unsigned fOpen;
196	/** File handle. */
197	RTFILE File;
198	/** Handle for asnychronous access if requested.*/
199	void *pStorage;
200	/** Flag whether to use File or pStorage. */
201	bool fAsyncIO;
202	/** Reference counter. */
203	unsigned uReferences;
204	/** Flag whether the file should be deleted on last close. */
205	bool fDelete;
206	/** Pointer to the image we belong to. */
207	PVMDKIMAGE pImage;
208	/** Pointer to next file descriptor. */
209	struct VMDKFILE *pNext;
210	/** Pointer to the previous file descriptor. */
211	struct VMDKFILE *pPrev;
212	} VMDKFILE, *PVMDKFILE;
213
214	/**
215	* VMDK extent data structure.
216	*/
217	typedef struct VMDKEXTENT
218	{
219	/** File handle. */
220	PVMDKFILE pFile;
221	/** Base name of the image extent. */
222	const char *pszBasename;
223	/** Full name of the image extent. */
224	const char *pszFullname;
225	/** Number of sectors in this extent. */
226	uint64_t cSectors;
227	/** Number of sectors per block (grain in VMDK speak). */
228	uint64_t cSectorsPerGrain;
229	/** Starting sector number of descriptor. */
230	uint64_t uDescriptorSector;
231	/** Size of descriptor in sectors. */
232	uint64_t cDescriptorSectors;
233	/** Starting sector number of grain directory. */
234	uint64_t uSectorGD;
235	/** Starting sector number of redundant grain directory. */
236	uint64_t uSectorRGD;
237	/** Total number of metadata sectors. */
238	uint64_t cOverheadSectors;
239	/** Nominal size (i.e. as described by the descriptor) of this extent. */
240	uint64_t cNominalSectors;
241	/** Sector offset (i.e. as described by the descriptor) of this extent. */
242	uint64_t uSectorOffset;
243	/** Number of entries in a grain table. */
244	uint32_t cGTEntries;
245	/** Number of sectors reachable via a grain directory entry. */
246	uint32_t cSectorsPerGDE;
247	/** Number of entries in the grain directory. */
248	uint32_t cGDEntries;
249	/** Pointer to the next free sector. Legacy information. Do not use. */
250	uint32_t uFreeSector;
251	/** Number of this extent in the list of images. */
252	uint32_t uExtent;
253	/** Pointer to the descriptor (NULL if no descriptor in this extent). */
254	char *pDescData;
255	/** Pointer to the grain directory. */
256	uint32_t *pGD;
257	/** Pointer to the redundant grain directory. */
258	uint32_t *pRGD;
259	/** Type of this extent. */
260	VMDKETYPE enmType;
261	/** Access to this extent. */
262	VMDKACCESS enmAccess;
263	/** Flag whether this extent is marked as unclean. */
264	bool fUncleanShutdown;
265	/** Flag whether the metadata in the extent header needs to be updated. */
266	bool fMetaDirty;
267	/** Reference to the image in which this extent is used. Do not use this
268	* on a regular basis to avoid passing pImage references to functions
269	* explicitly. */
270	struct VMDKIMAGE *pImage;
271	} VMDKEXTENT, *PVMDKEXTENT;
272
273	/**
274	* Grain table cache size. Allocated per image.
275	*/
276	#define VMDK_GT_CACHE_SIZE 256
277
278	/**
279	* Grain table block size. Smaller than an actual grain table block to allow
280	* more grain table blocks to be cached without having to allocate excessive
281	* amounts of memory for the cache.
282	*/
283	#define VMDK_GT_CACHELINE_SIZE 128
284
285
286	/**
287	* Maximum number of lines in a descriptor file. Not worth the effort of
288	* making it variable. Descriptor files are generally very short (~20 lines).
289	*/
290	#define VMDK_DESCRIPTOR_LINES_MAX 100U
291
292	/**
293	* Parsed descriptor information. Allows easy access and update of the
294	* descriptor (whether separate file or not). Free form text files suck.
295	*/
296	typedef struct VMDKDESCRIPTOR
297	{
298	/** Line number of first entry of the disk descriptor. */
299	unsigned uFirstDesc;
300	/** Line number of first entry in the extent description. */
301	unsigned uFirstExtent;
302	/** Line number of first disk database entry. */
303	unsigned uFirstDDB;
304	/** Total number of lines. */
305	unsigned cLines;
306	/** Total amount of memory available for the descriptor. */
307	size_t cbDescAlloc;
308	/** Set if descriptor has been changed and not yet written to disk. */
309	bool fDirty;
310	/** Array of pointers to the data in the descriptor. */
311	char *aLines[VMDK_DESCRIPTOR_LINES_MAX];
312	/** Array of line indices pointing to the next non-comment line. */
313	unsigned aNextLines[VMDK_DESCRIPTOR_LINES_MAX];
314	} VMDKDESCRIPTOR, *PVMDKDESCRIPTOR;
315
316
317	/**
318	* Cache entry for translating extent/sector to a sector number in that
319	* extent.
320	*/
321	typedef struct VMDKGTCACHEENTRY
322	{
323	/** Extent number for which this entry is valid. */
324	uint32_t uExtent;
325	/** GT data block number. */
326	uint64_t uGTBlock;
327	/** Data part of the cache entry. */
328	uint32_t aGTData[VMDK_GT_CACHELINE_SIZE];
329	} VMDKGTCACHEENTRY, *PVMDKGTCACHEENTRY;
330
331	/**
332	* Cache data structure for blocks of grain table entries. For now this is a
333	* fixed size direct mapping cache, but this should be adapted to the size of
334	* the sparse image and maybe converted to a set-associative cache. The
335	* implementation below implements a write-through cache with write allocate.
336	*/
337	typedef struct VMDKGTCACHE
338	{
339	/** Cache entries. */
340	VMDKGTCACHEENTRY aGTCache[VMDK_GT_CACHE_SIZE];
341	/** Number of cache entries (currently unused). */
342	unsigned cEntries;
343	} VMDKGTCACHE, *PVMDKGTCACHE;
344
345	/**
346	* Complete VMDK image data structure. Mainly a collection of extents and a few
347	* extra global data fields.
348	*/
349	typedef struct VMDKIMAGE
350	{
351	/** Pointer to the image extents. */
352	PVMDKEXTENT pExtents;
353	/** Number of image extents. */
354	unsigned cExtents;
355	/** Pointer to the files list, for opening a file referenced multiple
356	* times only once (happens mainly with raw partition access). */
357	PVMDKFILE pFiles;
358
359	/** Base image name. */
360	const char *pszFilename;
361	/** Descriptor file if applicable. */
362	PVMDKFILE pFile;
363
364	/** Pointer to the per-disk VD interface list. */
365	PVDINTERFACE pVDIfsDisk;
366
367	/** Error interface. */
368	PVDINTERFACE pInterfaceError;
369	/** Error interface callbacks. */
370	PVDINTERFACEERROR pInterfaceErrorCallbacks;
371
372	/** Async I/O interface. */
373	PVDINTERFACE pInterfaceAsyncIO;
374	/** Async I/O interface callbacks. */
375	PVDINTERFACEASYNCIO pInterfaceAsyncIOCallbacks;
376	/**
377	* Pointer to an array of task handles for task submission.
378	* This is an optimization because the task number to submit is not known
379	* and allocating/freeing an array in the read/write functions every time
380	* is too expensive.
381	*/
382	void **apTask;
383	/** Entries available in the task handle array. */
384	unsigned cTask;
385
386	/** Open flags passed by VBoxHD layer. */
387	unsigned uOpenFlags;
388	/** Image type. */
389	VDIMAGETYPE enmImageType;
390	/** Image flags defined during creation or determined during open. */
391	unsigned uImageFlags;
392	/** Total size of the image. */
393	uint64_t cbSize;
394	/** Physical geometry of this image. */
395	PDMMEDIAGEOMETRY PCHSGeometry;
396	/** Logical geometry of this image. */
397	PDMMEDIAGEOMETRY LCHSGeometry;
398	/** Image UUID. */
399	RTUUID ImageUuid;
400	/** Image modification UUID. */
401	RTUUID ModificationUuid;
402	/** Parent image UUID. */
403	RTUUID ParentUuid;
404	/** Parent image modification UUID. */
405	RTUUID ParentModificationUuid;
406
407	/** Pointer to grain table cache, if this image contains sparse extents. */
408	PVMDKGTCACHE pGTCache;
409	/** Pointer to the descriptor (NULL if no separate descriptor file). */
410	char *pDescData;
411	/** Allocation size of the descriptor file. */
412	size_t cbDescAlloc;
413	/** Parsed descriptor file content. */
414	VMDKDESCRIPTOR Descriptor;
415	} VMDKIMAGE;
416
417	/*******************************************************************************
418	* Static Variables *
419	*******************************************************************************/
420
421	/** NULL-terminated array of supported file extensions. */
422	static const char *const s_apszVmdkFileExtensions[] =
423	{
424	"vmdk",
425	NULL
426	};
427
428	/*******************************************************************************
429	* Internal Functions *
430	*******************************************************************************/
431
432	static void vmdkFreeGrainDirectory(PVMDKEXTENT pExtent);
433
434	static void vmdkFreeExtentData(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
435	bool fDelete);
436
437	static int vmdkCreateExtents(PVMDKIMAGE pImage, unsigned cExtents);
438	static int vmdkFlushImage(PVMDKIMAGE pImage);
439	static int vmdkSetImageComment(PVMDKIMAGE pImage, const char *pszComment);
440	static void vmdkFreeImage(PVMDKIMAGE pImage, bool fDelete);
441
442
443	/**
444	* Internal: signal an error to the frontend.
445	*/
446	DECLINLINE(int) vmdkError(PVMDKIMAGE pImage, int rc, RT_SRC_POS_DECL,
447	const char *pszFormat, ...)
448	{
449	va_list va;
450	va_start(va, pszFormat);
451	if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
452	pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS,
453	pszFormat, va);
454	va_end(va);
455	return rc;
456	}
457
458	/**
459	* Internal: open a file (using a file descriptor cache to ensure each file
460	* is only opened once - anything else can cause locking problems).
461	*/
462	static int vmdkFileOpen(PVMDKIMAGE pImage, PVMDKFILE *ppVmdkFile,
463	const char *pszFilename, unsigned fOpen, bool fAsyncIO)
464	{
465	int rc = VINF_SUCCESS;
466	PVMDKFILE pVmdkFile;
467
468	for (pVmdkFile = pImage->pFiles;
469	pVmdkFile != NULL;
470	pVmdkFile = pVmdkFile->pNext)
471	{
472	if (!strcmp(pszFilename, pVmdkFile->pszFilename))
473	{
474	Assert(fOpen == pVmdkFile->fOpen);
475	pVmdkFile->uReferences++;
476
477	*ppVmdkFile = pVmdkFile;
478
479	return rc;
480	}
481	}
482
483	/* If we get here, there's no matching entry in the cache. */
484	pVmdkFile = (PVMDKFILE)RTMemAllocZ(sizeof(VMDKFILE));
485	if (!VALID_PTR(pVmdkFile))
486	{
487	*ppVmdkFile = NULL;
488	return VERR_NO_MEMORY;
489	}
490
491	pVmdkFile->pszFilename = RTStrDup(pszFilename);
492	if (!VALID_PTR(pVmdkFile->pszFilename))
493	{
494	RTMemFree(pVmdkFile);
495	*ppVmdkFile = NULL;
496	return VERR_NO_MEMORY;
497	}
498	pVmdkFile->fOpen = fOpen;
499	if ((pImage->uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO) && (fAsyncIO))
500	{
501	rc = pImage->pInterfaceAsyncIOCallbacks->pfnOpen(pImage->pInterfaceAsyncIO->pvUser,
502	pszFilename,
503	pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY
504	? true
505	: false,
506	&pVmdkFile->pStorage);
507	pVmdkFile->fAsyncIO = true;
508	}
509	else
510	{
511	rc = RTFileOpen(&pVmdkFile->File, pszFilename, fOpen);
512	pVmdkFile->fAsyncIO = false;
513	}
514	if (RT_SUCCESS(rc))
515	{
516	pVmdkFile->uReferences = 1;
517	pVmdkFile->pImage = pImage;
518	pVmdkFile->pNext = pImage->pFiles;
519	if (pImage->pFiles)
520	pImage->pFiles->pPrev = pVmdkFile;
521	pImage->pFiles = pVmdkFile;
522	*ppVmdkFile = pVmdkFile;
523	}
524	else
525	{
526	RTStrFree((char )(void )pVmdkFile->pszFilename);
527	RTMemFree(pVmdkFile);
528	*ppVmdkFile = NULL;
529	}
530
531	return rc;
532	}
533
534	/**
535	* Internal: close a file, updating the file descriptor cache.
536	*/
537	static int vmdkFileClose(PVMDKIMAGE pImage, PVMDKFILE *ppVmdkFile, bool fDelete)
538	{
539	int rc = VINF_SUCCESS;
540	PVMDKFILE pVmdkFile = *ppVmdkFile;
541
542	Assert(VALID_PTR(pVmdkFile));
543
544	pVmdkFile->fDelete \|= fDelete;
545	Assert(pVmdkFile->uReferences);
546	pVmdkFile->uReferences--;
547	if (pVmdkFile->uReferences == 0)
548	{
549	PVMDKFILE pPrev;
550	PVMDKFILE pNext;
551
552	/* Unchain the element from the list. */
553	pPrev = pVmdkFile->pPrev;
554	pNext = pVmdkFile->pNext;
555
556	if (pNext)
557	pNext->pPrev = pPrev;
558	if (pPrev)
559	pPrev->pNext = pNext;
560	else
561	pImage->pFiles = pNext;
562
563	if (pVmdkFile->fAsyncIO)
564	{
565	rc = pImage->pInterfaceAsyncIOCallbacks->pfnClose(pImage->pInterfaceAsyncIO->pvUser,
566	pVmdkFile->pStorage);
567	}
568	else
569	{
570	rc = RTFileClose(pVmdkFile->File);
571	}
572	if (RT_SUCCESS(rc) && pVmdkFile->fDelete)
573	rc = RTFileDelete(pVmdkFile->pszFilename);
574	RTStrFree((char )(void )pVmdkFile->pszFilename);
575	RTMemFree(pVmdkFile);
576	}
577
578	*ppVmdkFile = NULL;
579	return rc;
580	}
581
582	/**
583	* Internal: read from a file distinguishing between async and normal operation
584	*/
585	DECLINLINE(int) vmdkFileReadAt(PVMDKFILE pVmdkFile,
586	uint64_t uOffset, void *pvBuf,
587	size_t cbToRead, size_t *pcbRead)
588	{
589	PVMDKIMAGE pImage = pVmdkFile->pImage;
590
591	if (pVmdkFile->fAsyncIO)
592	return pImage->pInterfaceAsyncIOCallbacks->pfnRead(pImage->pInterfaceAsyncIO->pvUser,
593	pVmdkFile->pStorage, uOffset,
594	cbToRead, pvBuf, pcbRead);
595	else
596	return RTFileReadAt(pVmdkFile->File, uOffset, pvBuf, cbToRead, pcbRead);
597	}
598
599	/**
600	* Internal: write to a file distinguishing between async and normal operation
601	*/
602	DECLINLINE(int) vmdkFileWriteAt(PVMDKFILE pVmdkFile,
603	uint64_t uOffset, const void *pvBuf,
604	size_t cbToWrite, size_t *pcbWritten)
605	{
606	PVMDKIMAGE pImage = pVmdkFile->pImage;
607
608	if (pVmdkFile->fAsyncIO)
609	return pImage->pInterfaceAsyncIOCallbacks->pfnWrite(pImage->pInterfaceAsyncIO->pvUser,
610	pVmdkFile->pStorage, uOffset,
611	cbToWrite, pvBuf, pcbWritten);
612	else
613	return RTFileWriteAt(pVmdkFile->File, uOffset, pvBuf, cbToWrite, pcbWritten);
614	}
615
616	/**
617	* Internal: get the size of a file distinguishing beween async and normal operation
618	*/
619	DECLINLINE(int) vmdkFileGetSize(PVMDKFILE pVmdkFile, uint64_t *pcbSize)
620	{
621	if (pVmdkFile->fAsyncIO)
622	{
623	AssertMsgFailed(("TODO\n"));
624	return 0;
625	}
626	else
627	return RTFileGetSize(pVmdkFile->File, pcbSize);
628	}
629
630	/**
631	* Internal: set the size of a file distinguishing beween async and normal operation
632	*/
633	DECLINLINE(int) vmdkFileSetSize(PVMDKFILE pVmdkFile, uint64_t cbSize)
634	{
635	if (pVmdkFile->fAsyncIO)
636	{
637	AssertMsgFailed(("TODO\n"));
638	return VERR_NOT_SUPPORTED;
639	}
640	else
641	return RTFileSetSize(pVmdkFile->File, cbSize);
642	}
643
644	/**
645	* Internal: flush a file distinguishing between async and normal operation
646	*/
647	DECLINLINE(int) vmdkFileFlush(PVMDKFILE pVmdkFile)
648	{
649	PVMDKIMAGE pImage = pVmdkFile->pImage;
650
651	if (pVmdkFile->fAsyncIO)
652	return pImage->pInterfaceAsyncIOCallbacks->pfnFlush(pImage->pInterfaceAsyncIO->pvUser,
653	pVmdkFile->pStorage);
654	else
655	return RTFileFlush(pVmdkFile->File);
656	}
657
658	/**
659	* Internal: check if all files are closed, prevent leaking resources.
660	*/
661	static int vmdkFileCheckAllClose(PVMDKIMAGE pImage)
662	{
663	int rc = VINF_SUCCESS, rc2;
664	PVMDKFILE pVmdkFile;
665
666	Assert(pImage->pFiles == NULL);
667	for (pVmdkFile = pImage->pFiles;
668	pVmdkFile != NULL;
669	pVmdkFile = pVmdkFile->pNext)
670	{
671	LogRel(("VMDK: leaking reference to file \"%s\"\n",
672	pVmdkFile->pszFilename));
673	pImage->pFiles = pVmdkFile->pNext;
674
675	if (pImage->uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)
676	rc2 = pImage->pInterfaceAsyncIOCallbacks->pfnClose(pImage->pInterfaceAsyncIO->pvUser,
677	pVmdkFile->pStorage);
678	else
679	rc2 = RTFileClose(pVmdkFile->File);
680
681	if (RT_SUCCESS(rc) && pVmdkFile->fDelete)
682	rc2 = RTFileDelete(pVmdkFile->pszFilename);
683	RTStrFree((char )(void )pVmdkFile->pszFilename);
684	RTMemFree(pVmdkFile);
685	if (RT_SUCCESS(rc))
686	rc = rc2;
687	}
688	return rc;
689	}
690
691	/**
692	* Internal: truncate a string (at a UTF8 code point boundary) and encode the
693	* critical non-ASCII characters.
694	*/
695	static char vmdkEncodeString(const char psz)
696	{
697	char szEnc[VMDK_ENCODED_COMMENT_MAX + 3];
698	char *pszDst = szEnc;
699
700	Assert(VALID_PTR(psz));
701
702	for (; *psz; psz = RTStrNextCp(psz))
703	{
704	char *pszDstPrev = pszDst;
705	RTUNICP Cp = RTStrGetCp(psz);
706	if (Cp == '\\')
707	{
708	pszDst = RTStrPutCp(pszDst, Cp);
709	pszDst = RTStrPutCp(pszDst, Cp);
710	}
711	else if (Cp == '\n')
712	{
713	pszDst = RTStrPutCp(pszDst, '\\');
714	pszDst = RTStrPutCp(pszDst, 'n');
715	}
716	else if (Cp == '\r')
717	{
718	pszDst = RTStrPutCp(pszDst, '\\');
719	pszDst = RTStrPutCp(pszDst, 'r');
720	}
721	else
722	pszDst = RTStrPutCp(pszDst, Cp);
723	if (pszDst - szEnc >= VMDK_ENCODED_COMMENT_MAX - 1)
724	{
725	pszDst = pszDstPrev;
726	break;
727	}
728	}
729	*pszDst = '\0';
730	return RTStrDup(szEnc);
731	}
732
733	/**
734	* Internal: decode a string and store it into the specified string.
735	*/
736	static int vmdkDecodeString(const char pszEncoded, char psz, size_t cb)
737	{
738	int rc = VINF_SUCCESS;
739	char szBuf[4];
740
741	if (!cb)
742	return VERR_BUFFER_OVERFLOW;
743
744	Assert(VALID_PTR(psz));
745
746	for (; *pszEncoded; pszEncoded = RTStrNextCp(pszEncoded))
747	{
748	char *pszDst = szBuf;
749	RTUNICP Cp = RTStrGetCp(pszEncoded);
750	if (Cp == '\\')
751	{
752	pszEncoded = RTStrNextCp(pszEncoded);
753	RTUNICP CpQ = RTStrGetCp(pszEncoded);
754	if (CpQ == 'n')
755	RTStrPutCp(pszDst, '\n');
756	else if (CpQ == 'r')
757	RTStrPutCp(pszDst, '\r');
758	else if (CpQ == '\0')
759	{
760	rc = VERR_VDI_INVALID_HEADER;
761	break;
762	}
763	else
764	RTStrPutCp(pszDst, CpQ);
765	}
766	else
767	pszDst = RTStrPutCp(pszDst, Cp);
768
769	/* Need to leave space for terminating NUL. */
770	if ((size_t)(pszDst - szBuf) + 1 >= cb)
771	{
772	rc = VERR_BUFFER_OVERFLOW;
773	break;
774	}
775	memcpy(psz, szBuf, pszDst - szBuf);
776	psz += pszDst - szBuf;
777	}
778	*psz = '\0';
779	return rc;
780	}
781
782	static int vmdkReadGrainDirectory(PVMDKEXTENT pExtent)
783	{
784	int rc = VINF_SUCCESS;
785	unsigned i;
786	uint32_t pGD = NULL, pRGD = NULL, pGDTmp, pRGDTmp;
787	size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
788
789	if (pExtent->enmType != VMDKETYPE_HOSTED_SPARSE)
790	goto out;
791
792	pGD = (uint32_t *)RTMemAllocZ(cbGD);
793	if (!pGD)
794	{
795	rc = VERR_NO_MEMORY;
796	goto out;
797	}
798	pExtent->pGD = pGD;
799	rc = vmdkFileReadAt(pExtent->pFile, VMDK_SECTOR2BYTE(pExtent->uSectorGD),
800	pGD, cbGD, NULL);
801	AssertRC(rc);
802	if (RT_FAILURE(rc))
803	{
804	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: could not read grain directory in '%s'"), pExtent->pszFullname);
805	goto out;
806	}
807	for (i = 0, pGDTmp = pGD; i < pExtent->cGDEntries; i++, pGDTmp++)
808	pGDTmp = RT_LE2H_U32(pGDTmp);
809
810	if (pExtent->uSectorRGD)
811	{
812	pRGD = (uint32_t *)RTMemAllocZ(cbGD);
813	if (!pRGD)
814	{
815	rc = VERR_NO_MEMORY;
816	goto out;
817	}
818	pExtent->pRGD = pRGD;
819	rc = vmdkFileReadAt(pExtent->pFile, VMDK_SECTOR2BYTE(pExtent->uSectorRGD),
820	pRGD, cbGD, NULL);
821	AssertRC(rc);
822	if (RT_FAILURE(rc))
823	{
824	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: could not read redundant grain directory in '%s'"), pExtent->pszFullname);
825	goto out;
826	}
827	for (i = 0, pRGDTmp = pRGD; i < pExtent->cGDEntries; i++, pRGDTmp++)
828	pRGDTmp = RT_LE2H_U32(pRGDTmp);
829
830	/* Check grain table and redundant grain table for consistency. */
831	size_t cbGT = pExtent->cGTEntries;
832	uint32_t pTmpGT1 = (uint32_t )RTMemTmpAlloc(cbGT);
833	if (!pTmpGT1)
834	{
835	rc = VERR_NO_MEMORY;
836	goto out;
837	}
838	uint32_t pTmpGT2 = (uint32_t )RTMemTmpAlloc(cbGT);
839	if (!pTmpGT2)
840	{
841	RTMemTmpFree(pTmpGT1);
842	rc = VERR_NO_MEMORY;
843	goto out;
844	}
845
846	for (i = 0, pGDTmp = pGD, pRGDTmp = pRGD;
847	i < pExtent->cGDEntries;
848	i++, pGDTmp++, pRGDTmp++)
849	{
850	/* If no grain table is allocated skip the entry. */
851	if (pGDTmp == 0 && pRGDTmp == 0)
852	continue;
853
854	if (pGDTmp == 0 \|\| pRGDTmp == 0 \|\| pGDTmp == pRGDTmp)
855	{
856	/* Just one grain directory entry refers to a not yet allocated
857	* grain table or both grain directory copies refer to the same
858	* grain table. Not allowed. */
859	RTMemTmpFree(pTmpGT1);
860	RTMemTmpFree(pTmpGT2);
861	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
862	goto out;
863	}
864	rc = vmdkFileReadAt(pExtent->pFile, VMDK_SECTOR2BYTE(*pGDTmp),
865	pTmpGT1, cbGT, NULL);
866	if (RT_FAILURE(rc))
867	{
868	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error reading grain table in '%s'"), pExtent->pszFullname);
869	RTMemTmpFree(pTmpGT1);
870	RTMemTmpFree(pTmpGT2);
871	goto out;
872	}
873	rc = vmdkFileReadAt(pExtent->pFile, VMDK_SECTOR2BYTE(*pRGDTmp),
874	pTmpGT2, cbGT, NULL);
875	if (RT_FAILURE(rc))
876	{
877	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error reading backup grain table in '%s'"), pExtent->pszFullname);
878	RTMemTmpFree(pTmpGT1);
879	RTMemTmpFree(pTmpGT2);
880	goto out;
881	}
882	if (memcmp(pTmpGT1, pTmpGT2, cbGT))
883	{
884	RTMemTmpFree(pTmpGT1);
885	RTMemTmpFree(pTmpGT2);
886	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistency between grain table and backup grain table in '%s'"), pExtent->pszFullname);
887	goto out;
888	}
889	}
890
891	/** @todo figure out what to do for unclean VMDKs. */
892	RTMemTmpFree(pTmpGT1);
893	RTMemTmpFree(pTmpGT2);
894	}
895
896	out:
897	if (RT_FAILURE(rc))
898	vmdkFreeGrainDirectory(pExtent);
899	return rc;
900	}
901
902	static int vmdkCreateGrainDirectory(PVMDKEXTENT pExtent, uint64_t uStartSector,
903	bool fPreAlloc)
904	{
905	int rc = VINF_SUCCESS;
906	unsigned i;
907	uint32_t pGD = NULL, pRGD = NULL;
908	size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
909	size_t cbGDRounded = RT_ALIGN_64(pExtent->cGDEntries * sizeof(uint32_t), 512);
910	size_t cbGTRounded;
911	uint64_t cbOverhead;
912
913	if (fPreAlloc)
914	cbGTRounded = RT_ALIGN_64(pExtent->cGDEntries * pExtent->cGTEntries * sizeof(uint32_t), 512);
915	else
916	cbGTRounded = 0;
917
918	pGD = (uint32_t *)RTMemAllocZ(cbGD);
919	if (!pGD)
920	{
921	rc = VERR_NO_MEMORY;
922	goto out;
923	}
924	pExtent->pGD = pGD;
925	pRGD = (uint32_t *)RTMemAllocZ(cbGD);
926	if (!pRGD)
927	{
928	rc = VERR_NO_MEMORY;
929	goto out;
930	}
931	pExtent->pRGD = pRGD;
932
933	cbOverhead = RT_ALIGN_64(VMDK_SECTOR2BYTE(uStartSector) + 2 * (cbGDRounded + cbGTRounded), VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
934	rc = vmdkFileSetSize(pExtent->pFile, cbOverhead);
935	if (RT_FAILURE(rc))
936	goto out;
937	pExtent->uSectorRGD = uStartSector;
938	pExtent->uSectorGD = uStartSector + VMDK_BYTE2SECTOR(cbGDRounded + cbGTRounded);
939
940	if (fPreAlloc)
941	{
942	uint32_t uGTSectorLE;
943	uint64_t uOffsetSectors;
944
945	uOffsetSectors = pExtent->uSectorRGD + VMDK_BYTE2SECTOR(cbGDRounded);
946	for (i = 0; i < pExtent->cGDEntries; i++)
947	{
948	pRGD[i] = uOffsetSectors;
949	uGTSectorLE = RT_H2LE_U64(uOffsetSectors);
950	/* Write the redundant grain directory entry to disk. */
951	rc = vmdkFileWriteAt(pExtent->pFile,
952	VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + i * sizeof(uGTSectorLE),
953	&uGTSectorLE, sizeof(uGTSectorLE), NULL);
954	if (RT_FAILURE(rc))
955	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write new redundant grain directory entry in '%s'"), pExtent->pszFullname);
956	uOffsetSectors += VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
957	}
958
959	uOffsetSectors = pExtent->uSectorGD + VMDK_BYTE2SECTOR(cbGDRounded);
960	for (i = 0; i < pExtent->cGDEntries; i++)
961	{
962	pGD[i] = uOffsetSectors;
963	uGTSectorLE = RT_H2LE_U64(uOffsetSectors);
964	/* Write the grain directory entry to disk. */
965	rc = vmdkFileWriteAt(pExtent->pFile,
966	VMDK_SECTOR2BYTE(pExtent->uSectorGD) + i * sizeof(uGTSectorLE),
967	&uGTSectorLE, sizeof(uGTSectorLE), NULL);
968	if (RT_FAILURE(rc))
969	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write new grain directory entry in '%s'"), pExtent->pszFullname);
970	uOffsetSectors += VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
971	}
972	}
973	pExtent->cOverheadSectors = VMDK_BYTE2SECTOR(cbOverhead);
974
975	out:
976	if (RT_FAILURE(rc))
977	vmdkFreeGrainDirectory(pExtent);
978	return rc;
979	}
980
981	static void vmdkFreeGrainDirectory(PVMDKEXTENT pExtent)
982	{
983	if (pExtent->pGD)
984	{
985	RTMemFree(pExtent->pGD);
986	pExtent->pGD = NULL;
987	}
988	if (pExtent->pRGD)
989	{
990	RTMemFree(pExtent->pRGD);
991	pExtent->pRGD = NULL;
992	}
993	}
994
995	static int vmdkStringUnquote(PVMDKIMAGE pImage, const char *pszStr,
996	char ppszUnquoted, char ppszNext)
997	{
998	char *pszQ;
999	char *pszUnquoted;
1000
1001	/* Skip over whitespace. */
1002	while (pszStr == ' ' \|\| pszStr == '\t')
1003	pszStr++;
1004	if (*pszStr++ != '"')
1005	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s'"), pImage->pszFilename);
1006
1007	pszQ = (char *)strchr(pszStr, '"');
1008	if (pszQ == NULL)
1009	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s'"), pImage->pszFilename);
1010	pszUnquoted = (char *)RTMemTmpAlloc(pszQ - pszStr + 1);
1011	if (!pszUnquoted)
1012	return VERR_NO_MEMORY;
1013	memcpy(pszUnquoted, pszStr, pszQ - pszStr);
1014	pszUnquoted[pszQ - pszStr] = '\0';
1015	*ppszUnquoted = pszUnquoted;
1016	if (ppszNext)
1017	*ppszNext = pszQ + 1;
1018	return VINF_SUCCESS;
1019	}
1020
1021	static int vmdkDescInitStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1022	const char *pszLine)
1023	{
1024	char *pEnd = pDescriptor->aLines[pDescriptor->cLines];
1025	ssize_t cbDiff = strlen(pszLine) + 1;
1026
1027	if ( pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1
1028	&& pEnd - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff)
1029	return vmdkError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1030
1031	memcpy(pEnd, pszLine, cbDiff);
1032	pDescriptor->cLines++;
1033	pDescriptor->aLines[pDescriptor->cLines] = pEnd + cbDiff;
1034	pDescriptor->fDirty = true;
1035
1036	return VINF_SUCCESS;
1037	}
1038
1039	static bool vmdkDescGetStr(PVMDKDESCRIPTOR pDescriptor, unsigned uStart,
1040	const char pszKey, const char *ppszValue)
1041	{
1042	size_t cbKey = strlen(pszKey);
1043	const char *pszValue;
1044
1045	while (uStart != 0)
1046	{
1047	if (!strncmp(pDescriptor->aLines[uStart], pszKey, cbKey))
1048	{
1049	/* Key matches, check for a '=' (preceded by whitespace). */
1050	pszValue = pDescriptor->aLines[uStart] + cbKey;
1051	while (pszValue == ' ' \|\| pszValue == '\t')
1052	pszValue++;
1053	if (*pszValue == '=')
1054	{
1055	*ppszValue = pszValue + 1;
1056	break;
1057	}
1058	}
1059	uStart = pDescriptor->aNextLines[uStart];
1060	}
1061	return !!uStart;
1062	}
1063
1064	static int vmdkDescSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1065	unsigned uStart,
1066	const char pszKey, const char pszValue)
1067	{
1068	char *pszTmp;
1069	size_t cbKey = strlen(pszKey);
1070	unsigned uLast = 0;
1071
1072	while (uStart != 0)
1073	{
1074	if (!strncmp(pDescriptor->aLines[uStart], pszKey, cbKey))
1075	{
1076	/* Key matches, check for a '=' (preceded by whitespace). */
1077	pszTmp = pDescriptor->aLines[uStart] + cbKey;
1078	while (pszTmp == ' ' \|\| pszTmp == '\t')
1079	pszTmp++;
1080	if (*pszTmp == '=')
1081	{
1082	pszTmp++;
1083	while (pszTmp == ' ' \|\| pszTmp == '\t')
1084	pszTmp++;
1085	break;
1086	}
1087	}
1088	if (!pDescriptor->aNextLines[uStart])
1089	uLast = uStart;
1090	uStart = pDescriptor->aNextLines[uStart];
1091	}
1092	if (uStart)
1093	{
1094	if (pszValue)
1095	{
1096	/* Key already exists, replace existing value. */
1097	size_t cbOldVal = strlen(pszTmp);
1098	size_t cbNewVal = strlen(pszValue);
1099	ssize_t cbDiff = cbNewVal - cbOldVal;
1100	/* Check for buffer overflow. */
1101	if ( pDescriptor->aLines[pDescriptor->cLines]
1102	- pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff)
1103	return vmdkError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1104
1105	memmove(pszTmp + cbNewVal, pszTmp + cbOldVal,
1106	pDescriptor->aLines[pDescriptor->cLines] - pszTmp - cbOldVal);
1107	memcpy(pszTmp, pszValue, cbNewVal + 1);
1108	for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1109	pDescriptor->aLines[i] += cbDiff;
1110	}
1111	else
1112	{
1113	memmove(pDescriptor->aLines[uStart], pDescriptor->aLines[uStart+1],
1114	pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uStart+1] + 1);
1115	for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1116	{
1117	pDescriptor->aLines[i-1] = pDescriptor->aLines[i];
1118	if (pDescriptor->aNextLines[i])
1119	pDescriptor->aNextLines[i-1] = pDescriptor->aNextLines[i] - 1;
1120	else
1121	pDescriptor->aNextLines[i-1] = 0;
1122	}
1123	pDescriptor->cLines--;
1124	/* Adjust starting line numbers of following descriptor sections. */
1125	if (uStart < pDescriptor->uFirstExtent)
1126	pDescriptor->uFirstExtent--;
1127	if (uStart < pDescriptor->uFirstDDB)
1128	pDescriptor->uFirstDDB--;
1129	}
1130	}
1131	else
1132	{
1133	/* Key doesn't exist, append after the last entry in this category. */
1134	if (!pszValue)
1135	{
1136	/* Key doesn't exist, and it should be removed. Simply a no-op. */
1137	return VINF_SUCCESS;
1138	}
1139	size_t cbKey = strlen(pszKey);
1140	size_t cbValue = strlen(pszValue);
1141	ssize_t cbDiff = cbKey + 1 + cbValue + 1;
1142	/* Check for buffer overflow. */
1143	if ( (pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1)
1144	\|\| ( pDescriptor->aLines[pDescriptor->cLines]
1145	- pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff))
1146	return vmdkError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1147	for (unsigned i = pDescriptor->cLines + 1; i > uLast + 1; i--)
1148	{
1149	pDescriptor->aLines[i] = pDescriptor->aLines[i - 1];
1150	if (pDescriptor->aNextLines[i - 1])
1151	pDescriptor->aNextLines[i] = pDescriptor->aNextLines[i - 1] + 1;
1152	else
1153	pDescriptor->aNextLines[i] = 0;
1154	}
1155	uStart = uLast + 1;
1156	pDescriptor->aNextLines[uLast] = uStart;
1157	pDescriptor->aNextLines[uStart] = 0;
1158	pDescriptor->cLines++;
1159	pszTmp = pDescriptor->aLines[uStart];
1160	memmove(pszTmp + cbDiff, pszTmp,
1161	pDescriptor->aLines[pDescriptor->cLines] - pszTmp);
1162	memcpy(pDescriptor->aLines[uStart], pszKey, cbKey);
1163	pDescriptor->aLines[uStart][cbKey] = '=';
1164	memcpy(pDescriptor->aLines[uStart] + cbKey + 1, pszValue, cbValue + 1);
1165	for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1166	pDescriptor->aLines[i] += cbDiff;
1167
1168	/* Adjust starting line numbers of following descriptor sections. */
1169	if (uStart <= pDescriptor->uFirstExtent)
1170	pDescriptor->uFirstExtent++;
1171	if (uStart <= pDescriptor->uFirstDDB)
1172	pDescriptor->uFirstDDB++;
1173	}
1174	pDescriptor->fDirty = true;
1175	return VINF_SUCCESS;
1176	}
1177
1178	static int vmdkDescBaseGetU32(PVMDKDESCRIPTOR pDescriptor, const char *pszKey,
1179	uint32_t *puValue)
1180	{
1181	const char *pszValue;
1182
1183	if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
1184	&pszValue))
1185	return VERR_VDI_VALUE_NOT_FOUND;
1186	return RTStrToUInt32Ex(pszValue, NULL, 10, puValue);
1187	}
1188
1189	static int vmdkDescBaseGetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1190	const char pszKey, const char *ppszValue)
1191	{
1192	const char *pszValue;
1193	char *pszValueUnquoted;
1194
1195	if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
1196	&pszValue))
1197	return VERR_VDI_VALUE_NOT_FOUND;
1198	int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1199	if (RT_FAILURE(rc))
1200	return rc;
1201	*ppszValue = pszValueUnquoted;
1202	return rc;
1203	}
1204
1205	static int vmdkDescBaseSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1206	const char pszKey, const char pszValue)
1207	{
1208	char *pszValueQuoted;
1209
1210	int rc = RTStrAPrintf(&pszValueQuoted, "\"%s\"", pszValue);
1211	if (RT_FAILURE(rc))
1212	return rc;
1213	rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc, pszKey,
1214	pszValueQuoted);
1215	RTStrFree(pszValueQuoted);
1216	return rc;
1217	}
1218
1219	static void vmdkDescExtRemoveDummy(PVMDKIMAGE pImage,
1220	PVMDKDESCRIPTOR pDescriptor)
1221	{
1222	unsigned uEntry = pDescriptor->uFirstExtent;
1223	ssize_t cbDiff;
1224
1225	if (!uEntry)
1226	return;
1227
1228	cbDiff = strlen(pDescriptor->aLines[uEntry]) + 1;
1229	/* Move everything including \0 in the entry marking the end of buffer. */
1230	memmove(pDescriptor->aLines[uEntry], pDescriptor->aLines[uEntry + 1],
1231	pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uEntry + 1] + 1);
1232	for (unsigned i = uEntry + 1; i <= pDescriptor->cLines; i++)
1233	{
1234	pDescriptor->aLines[i - 1] = pDescriptor->aLines[i] - cbDiff;
1235	if (pDescriptor->aNextLines[i])
1236	pDescriptor->aNextLines[i - 1] = pDescriptor->aNextLines[i] - 1;
1237	else
1238	pDescriptor->aNextLines[i - 1] = 0;
1239	}
1240	pDescriptor->cLines--;
1241	if (pDescriptor->uFirstDDB)
1242	pDescriptor->uFirstDDB--;
1243
1244	return;
1245	}
1246
1247	static int vmdkDescExtInsert(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1248	VMDKACCESS enmAccess, uint64_t cNominalSectors,
1249	VMDKETYPE enmType, const char *pszBasename,
1250	uint64_t uSectorOffset)
1251	{
1252	static const char *apszAccess[] = { "NOACCESS", "RDONLY", "RW" };
1253	static const char *apszType[] = { "", "SPARSE", "FLAT", "ZERO" };
1254	char *pszTmp;
1255	unsigned uStart = pDescriptor->uFirstExtent, uLast = 0;
1256	char szExt[1024];
1257	ssize_t cbDiff;
1258
1259	/* Find last entry in extent description. */
1260	while (uStart)
1261	{
1262	if (!pDescriptor->aNextLines[uStart])
1263	uLast = uStart;
1264	uStart = pDescriptor->aNextLines[uStart];
1265	}
1266
1267	if (enmType == VMDKETYPE_ZERO)
1268	{
1269	RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s ", apszAccess[enmAccess],
1270	cNominalSectors, apszType[enmType]);
1271	}
1272	else
1273	{
1274	if (!uSectorOffset)
1275	RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s \"%s\"",
1276	apszAccess[enmAccess], cNominalSectors,
1277	apszType[enmType], pszBasename);
1278	else
1279	RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s \"%s\" %llu",
1280	apszAccess[enmAccess], cNominalSectors,
1281	apszType[enmType], pszBasename, uSectorOffset);
1282	}
1283	cbDiff = strlen(szExt) + 1;
1284
1285	/* Check for buffer overflow. */
1286	if ( (pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1)
1287	\|\| ( pDescriptor->aLines[pDescriptor->cLines]
1288	- pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff))
1289	return vmdkError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1290
1291	for (unsigned i = pDescriptor->cLines + 1; i > uLast + 1; i--)
1292	{
1293	pDescriptor->aLines[i] = pDescriptor->aLines[i - 1];
1294	if (pDescriptor->aNextLines[i - 1])
1295	pDescriptor->aNextLines[i] = pDescriptor->aNextLines[i - 1] + 1;
1296	else
1297	pDescriptor->aNextLines[i] = 0;
1298	}
1299	uStart = uLast + 1;
1300	pDescriptor->aNextLines[uLast] = uStart;
1301	pDescriptor->aNextLines[uStart] = 0;
1302	pDescriptor->cLines++;
1303	pszTmp = pDescriptor->aLines[uStart];
1304	memmove(pszTmp + cbDiff, pszTmp,
1305	pDescriptor->aLines[pDescriptor->cLines] - pszTmp);
1306	memcpy(pDescriptor->aLines[uStart], szExt, cbDiff);
1307	for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
1308	pDescriptor->aLines[i] += cbDiff;
1309
1310	/* Adjust starting line numbers of following descriptor sections. */
1311	if (uStart <= pDescriptor->uFirstDDB)
1312	pDescriptor->uFirstDDB++;
1313
1314	pDescriptor->fDirty = true;
1315	return VINF_SUCCESS;
1316	}
1317
1318	static int vmdkDescDDBGetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1319	const char pszKey, const char *ppszValue)
1320	{
1321	const char *pszValue;
1322	char *pszValueUnquoted;
1323
1324	if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
1325	&pszValue))
1326	return VERR_VDI_VALUE_NOT_FOUND;
1327	int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1328	if (RT_FAILURE(rc))
1329	return rc;
1330	*ppszValue = pszValueUnquoted;
1331	return rc;
1332	}
1333
1334	static int vmdkDescDDBGetU32(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1335	const char pszKey, uint32_t puValue)
1336	{
1337	const char *pszValue;
1338	char *pszValueUnquoted;
1339
1340	if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
1341	&pszValue))
1342	return VERR_VDI_VALUE_NOT_FOUND;
1343	int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1344	if (RT_FAILURE(rc))
1345	return rc;
1346	rc = RTStrToUInt32Ex(pszValueUnquoted, NULL, 10, puValue);
1347	RTMemTmpFree(pszValueUnquoted);
1348	return rc;
1349	}
1350
1351	static int vmdkDescDDBGetUuid(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1352	const char *pszKey, PRTUUID pUuid)
1353	{
1354	const char *pszValue;
1355	char *pszValueUnquoted;
1356
1357	if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
1358	&pszValue))
1359	return VERR_VDI_VALUE_NOT_FOUND;
1360	int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
1361	if (RT_FAILURE(rc))
1362	return rc;
1363	rc = RTUuidFromStr(pUuid, pszValueUnquoted);
1364	RTMemTmpFree(pszValueUnquoted);
1365	return rc;
1366	}
1367
1368	static int vmdkDescDDBSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1369	const char pszKey, const char pszVal)
1370	{
1371	int rc;
1372	char *pszValQuoted;
1373
1374	if (pszVal)
1375	{
1376	rc = RTStrAPrintf(&pszValQuoted, "\"%s\"", pszVal);
1377	if (RT_FAILURE(rc))
1378	return rc;
1379	}
1380	else
1381	pszValQuoted = NULL;
1382	rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
1383	pszValQuoted);
1384	if (pszValQuoted)
1385	RTStrFree(pszValQuoted);
1386	return rc;
1387	}
1388
1389	static int vmdkDescDDBSetUuid(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1390	const char *pszKey, PCRTUUID pUuid)
1391	{
1392	char *pszUuid;
1393
1394	int rc = RTStrAPrintf(&pszUuid, "\"%RTuuid\"", pUuid);
1395	if (RT_FAILURE(rc))
1396	return rc;
1397	rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
1398	pszUuid);
1399	RTStrFree(pszUuid);
1400	return rc;
1401	}
1402
1403	static int vmdkDescDDBSetU32(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
1404	const char *pszKey, uint32_t uValue)
1405	{
1406	char *pszValue;
1407
1408	int rc = RTStrAPrintf(&pszValue, "\"%d\"", uValue);
1409	if (RT_FAILURE(rc))
1410	return rc;
1411	rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
1412	pszValue);
1413	RTStrFree(pszValue);
1414	return rc;
1415	}
1416
1417	static int vmdkPreprocessDescriptor(PVMDKIMAGE pImage, char *pDescData,
1418	size_t cbDescData,
1419	PVMDKDESCRIPTOR pDescriptor)
1420	{
1421	int rc = VINF_SUCCESS;
1422	unsigned cLine = 0, uLastNonEmptyLine = 0;
1423	char *pTmp = pDescData;
1424
1425	pDescriptor->cbDescAlloc = cbDescData;
1426	while (*pTmp != '\0')
1427	{
1428	pDescriptor->aLines[cLine++] = pTmp;
1429	if (cLine >= VMDK_DESCRIPTOR_LINES_MAX)
1430	{
1431	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
1432	goto out;
1433	}
1434
1435	while (pTmp != '\0' && pTmp != '\n')
1436	{
1437	if (*pTmp == '\r')
1438	{
1439	if (*(pTmp + 1) != '\n')
1440	{
1441	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: unsupported end of line in descriptor in '%s'"), pImage->pszFilename);
1442	goto out;
1443	}
1444	else
1445	{
1446	/* Get rid of CR character. */
1447	*pTmp = '\0';
1448	}
1449	}
1450	pTmp++;
1451	}
1452	/* Get rid of LF character. */
1453	if (*pTmp == '\n')
1454	{
1455	*pTmp = '\0';
1456	pTmp++;
1457	}
1458	}
1459	pDescriptor->cLines = cLine;
1460	/* Pointer right after the end of the used part of the buffer. */
1461	pDescriptor->aLines[cLine] = pTmp;
1462
1463	if ( strcmp(pDescriptor->aLines[0], "# Disk DescriptorFile")
1464	&& strcmp(pDescriptor->aLines[0], "# Disk Descriptor File"))
1465	{
1466	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor does not start as expected in '%s'"), pImage->pszFilename);
1467	goto out;
1468	}
1469
1470	/* Initialize those, because we need to be able to reopen an image. */
1471	pDescriptor->uFirstDesc = 0;
1472	pDescriptor->uFirstExtent = 0;
1473	pDescriptor->uFirstDDB = 0;
1474	for (unsigned i = 0; i < cLine; i++)
1475	{
1476	if (pDescriptor->aLines[i] != '#' && pDescriptor->aLines[i] != '\0')
1477	{
1478	if ( !strncmp(pDescriptor->aLines[i], "RW", 2)
1479	\|\| !strncmp(pDescriptor->aLines[i], "RDONLY", 6)
1480	\|\| !strncmp(pDescriptor->aLines[i], "NOACCESS", 8) )
1481	{
1482	/* An extent descriptor. */
1483	if (!pDescriptor->uFirstDesc \|\| pDescriptor->uFirstDDB)
1484	{
1485	/* Incorrect ordering of entries. */
1486	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
1487	goto out;
1488	}
1489	if (!pDescriptor->uFirstExtent)
1490	{
1491	pDescriptor->uFirstExtent = i;
1492	uLastNonEmptyLine = 0;
1493	}
1494	}
1495	else if (!strncmp(pDescriptor->aLines[i], "ddb.", 4))
1496	{
1497	/* A disk database entry. */
1498	if (!pDescriptor->uFirstDesc \|\| !pDescriptor->uFirstExtent)
1499	{
1500	/* Incorrect ordering of entries. */
1501	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
1502	goto out;
1503	}
1504	if (!pDescriptor->uFirstDDB)
1505	{
1506	pDescriptor->uFirstDDB = i;
1507	uLastNonEmptyLine = 0;
1508	}
1509	}
1510	else
1511	{
1512	/* A normal entry. */
1513	if (pDescriptor->uFirstExtent \|\| pDescriptor->uFirstDDB)
1514	{
1515	/* Incorrect ordering of entries. */
1516	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
1517	goto out;
1518	}
1519	if (!pDescriptor->uFirstDesc)
1520	{
1521	pDescriptor->uFirstDesc = i;
1522	uLastNonEmptyLine = 0;
1523	}
1524	}
1525	if (uLastNonEmptyLine)
1526	pDescriptor->aNextLines[uLastNonEmptyLine] = i;
1527	uLastNonEmptyLine = i;
1528	}
1529	}
1530
1531	out:
1532	return rc;
1533	}
1534
1535	static int vmdkDescSetPCHSGeometry(PVMDKIMAGE pImage,
1536	PCPDMMEDIAGEOMETRY pPCHSGeometry)
1537	{
1538	int rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
1539	VMDK_DDB_GEO_PCHS_CYLINDERS,
1540	pPCHSGeometry->cCylinders);
1541	if (RT_FAILURE(rc))
1542	return rc;
1543	rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
1544	VMDK_DDB_GEO_PCHS_HEADS,
1545	pPCHSGeometry->cHeads);
1546	if (RT_FAILURE(rc))
1547	return rc;
1548	rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
1549	VMDK_DDB_GEO_PCHS_SECTORS,
1550	pPCHSGeometry->cSectors);
1551	return rc;
1552	}
1553
1554	static int vmdkDescSetLCHSGeometry(PVMDKIMAGE pImage,
1555	PCPDMMEDIAGEOMETRY pLCHSGeometry)
1556	{
1557	int rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
1558	VMDK_DDB_GEO_LCHS_CYLINDERS,
1559	pLCHSGeometry->cCylinders);
1560	if (RT_FAILURE(rc))
1561	return rc;
1562	rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
1563	VMDK_DDB_GEO_LCHS_HEADS,
1564	pLCHSGeometry->cHeads);
1565	if (RT_FAILURE(rc))
1566	return rc;
1567	rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
1568	VMDK_DDB_GEO_LCHS_SECTORS,
1569	pLCHSGeometry->cSectors);
1570	return rc;
1571	}
1572
1573	static int vmdkCreateDescriptor(PVMDKIMAGE pImage, char *pDescData,
1574	size_t cbDescData, PVMDKDESCRIPTOR pDescriptor)
1575	{
1576	int rc;
1577
1578	pDescriptor->uFirstDesc = 0;
1579	pDescriptor->uFirstExtent = 0;
1580	pDescriptor->uFirstDDB = 0;
1581	pDescriptor->cLines = 0;
1582	pDescriptor->cbDescAlloc = cbDescData;
1583	pDescriptor->fDirty = false;
1584	pDescriptor->aLines[pDescriptor->cLines] = pDescData;
1585	memset(pDescriptor->aNextLines, '\0', sizeof(pDescriptor->aNextLines));
1586
1587	rc = vmdkDescInitStr(pImage, pDescriptor, "# Disk DescriptorFile");
1588	if (RT_FAILURE(rc))
1589	goto out;
1590	rc = vmdkDescInitStr(pImage, pDescriptor, "version=1");
1591	if (RT_FAILURE(rc))
1592	goto out;
1593	pDescriptor->uFirstDesc = pDescriptor->cLines - 1;
1594	rc = vmdkDescInitStr(pImage, pDescriptor, "");
1595	if (RT_FAILURE(rc))
1596	goto out;
1597	rc = vmdkDescInitStr(pImage, pDescriptor, "# Extent description");
1598	if (RT_FAILURE(rc))
1599	goto out;
1600	rc = vmdkDescInitStr(pImage, pDescriptor, "NOACCESS 0 ZERO ");
1601	if (RT_FAILURE(rc))
1602	goto out;
1603	pDescriptor->uFirstExtent = pDescriptor->cLines - 1;
1604	rc = vmdkDescInitStr(pImage, pDescriptor, "");
1605	if (RT_FAILURE(rc))
1606	goto out;
1607	/* The trailing space is created by VMware, too. */
1608	rc = vmdkDescInitStr(pImage, pDescriptor, "# The disk Data Base ");
1609	if (RT_FAILURE(rc))
1610	goto out;
1611	rc = vmdkDescInitStr(pImage, pDescriptor, "#DDB");
1612	if (RT_FAILURE(rc))
1613	goto out;
1614	rc = vmdkDescInitStr(pImage, pDescriptor, "");
1615	if (RT_FAILURE(rc))
1616	goto out;
1617	rc = vmdkDescInitStr(pImage, pDescriptor, "ddb.virtualHWVersion = \"4\"");
1618	if (RT_FAILURE(rc))
1619	goto out;
1620	pDescriptor->uFirstDDB = pDescriptor->cLines - 1;
1621
1622	/* Now that the framework is in place, use the normal functions to insert
1623	* the remaining keys. */
1624	char szBuf[9];
1625	RTStrPrintf(szBuf, sizeof(szBuf), "%08x", RTRandU32());
1626	rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc,
1627	"CID", szBuf);
1628	if (RT_FAILURE(rc))
1629	goto out;
1630	rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc,
1631	"parentCID", "ffffffff");
1632	if (RT_FAILURE(rc))
1633	goto out;
1634
1635	rc = vmdkDescDDBSetStr(pImage, pDescriptor, "ddb.adapterType", "ide");
1636	if (RT_FAILURE(rc))
1637	goto out;
1638
1639	out:
1640	return rc;
1641	}
1642
1643	static int vmdkParseDescriptor(PVMDKIMAGE pImage, char *pDescData,
1644	size_t cbDescData)
1645	{
1646	int rc;
1647	unsigned cExtents;
1648	unsigned uLine;
1649
1650	rc = vmdkPreprocessDescriptor(pImage, pDescData, cbDescData,
1651	&pImage->Descriptor);
1652	if (RT_FAILURE(rc))
1653	return rc;
1654
1655	/* Check version, must be 1. */
1656	uint32_t uVersion;
1657	rc = vmdkDescBaseGetU32(&pImage->Descriptor, "version", &uVersion);
1658	if (RT_FAILURE(rc))
1659	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error finding key 'version' in descriptor in '%s'"), pImage->pszFilename);
1660	if (uVersion != 1)
1661	return vmdkError(pImage, VERR_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: unsupported format version in descriptor in '%s'"), pImage->pszFilename);
1662
1663	/* Get image creation type and determine image flags. */
1664	const char *pszCreateType;
1665	rc = vmdkDescBaseGetStr(pImage, &pImage->Descriptor, "createType",
1666	&pszCreateType);
1667	if (RT_FAILURE(rc))
1668	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: cannot get image type from descriptor in '%s'"), pImage->pszFilename);
1669	if ( !strcmp(pszCreateType, "twoGbMaxExtentSparse")
1670	\|\| !strcmp(pszCreateType, "twoGbMaxExtentFlat"))
1671	pImage->uImageFlags = VD_VMDK_IMAGE_FLAGS_SPLIT_2G;
1672	if ( !strcmp(pszCreateType, "partitionedDevice")
1673	\|\| !strcmp(pszCreateType, "fullDevice"))
1674	pImage->uImageFlags = VD_VMDK_IMAGE_FLAGS_RAWDISK;
1675	else
1676	pImage->uImageFlags = 0;
1677	RTStrFree((char )(void )pszCreateType);
1678
1679	/* Count the number of extent config entries. */
1680	for (uLine = pImage->Descriptor.uFirstExtent, cExtents = 0;
1681	uLine != 0;
1682	uLine = pImage->Descriptor.aNextLines[uLine], cExtents++)
1683	/* nothing */;
1684
1685	if (!pImage->pDescData && cExtents != 1)
1686	{
1687	/* Monolithic image, must have only one extent (already opened). */
1688	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image may only have one extent in '%s'"), pImage->pszFilename);
1689	}
1690
1691	if (pImage->pDescData)
1692	{
1693	/* Non-monolithic image, extents need to be allocated. */
1694	rc = vmdkCreateExtents(pImage, cExtents);
1695	if (RT_FAILURE(rc))
1696	return rc;
1697	}
1698
1699	for (unsigned i = 0, uLine = pImage->Descriptor.uFirstExtent;
1700	i < cExtents; i++, uLine = pImage->Descriptor.aNextLines[uLine])
1701	{
1702	char *pszLine = pImage->Descriptor.aLines[uLine];
1703
1704	/* Access type of the extent. */
1705	if (!strncmp(pszLine, "RW", 2))
1706	{
1707	pImage->pExtents[i].enmAccess = VMDKACCESS_READWRITE;
1708	pszLine += 2;
1709	}
1710	else if (!strncmp(pszLine, "RDONLY", 6))
1711	{
1712	pImage->pExtents[i].enmAccess = VMDKACCESS_READONLY;
1713	pszLine += 6;
1714	}
1715	else if (!strncmp(pszLine, "NOACCESS", 8))
1716	{
1717	pImage->pExtents[i].enmAccess = VMDKACCESS_NOACCESS;
1718	pszLine += 8;
1719	}
1720	else
1721	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1722	if (*pszLine++ != ' ')
1723	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1724
1725	/* Nominal size of the extent. */
1726	rc = RTStrToUInt64Ex(pszLine, &pszLine, 10,
1727	&pImage->pExtents[i].cNominalSectors);
1728	if (RT_FAILURE(rc))
1729	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1730	if (*pszLine++ != ' ')
1731	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1732
1733	/* Type of the extent. */
1734	#ifdef VBOX_WITH_VMDK_ESX
1735	/** @todo Add the ESX extent types. Not necessary for now because
1736	* the ESX extent types are only used inside an ESX server. They are
1737	* automatically converted if the VMDK is exported. */
1738	#endif /* VBOX_WITH_VMDK_ESX */
1739	if (!strncmp(pszLine, "SPARSE", 6))
1740	{
1741	pImage->pExtents[i].enmType = VMDKETYPE_HOSTED_SPARSE;
1742	pszLine += 6;
1743	}
1744	else if (!strncmp(pszLine, "FLAT", 4))
1745	{
1746	pImage->pExtents[i].enmType = VMDKETYPE_FLAT;
1747	pszLine += 4;
1748	}
1749	else if (!strncmp(pszLine, "ZERO", 4))
1750	{
1751	pImage->pExtents[i].enmType = VMDKETYPE_ZERO;
1752	pszLine += 4;
1753	}
1754	else
1755	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1756	if (pImage->pExtents[i].enmType == VMDKETYPE_ZERO)
1757	{
1758	/* This one has no basename or offset. */
1759	if (*pszLine == ' ')
1760	pszLine++;
1761	if (*pszLine != '\0')
1762	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1763	pImage->pExtents[i].pszBasename = NULL;
1764	}
1765	else
1766	{
1767	/* All other extent types have basename and optional offset. */
1768	if (*pszLine++ != ' ')
1769	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1770
1771	/* Basename of the image. Surrounded by quotes. */
1772	char *pszBasename;
1773	rc = vmdkStringUnquote(pImage, pszLine, &pszBasename, &pszLine);
1774	if (RT_FAILURE(rc))
1775	return rc;
1776	pImage->pExtents[i].pszBasename = pszBasename;
1777	if (*pszLine == ' ')
1778	{
1779	pszLine++;
1780	if (*pszLine != '\0')
1781	{
1782	/* Optional offset in extent specified. */
1783	rc = RTStrToUInt64Ex(pszLine, &pszLine, 10,
1784	&pImage->pExtents[i].uSectorOffset);
1785	if (RT_FAILURE(rc))
1786	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1787	}
1788	}
1789
1790	if (*pszLine != '\0')
1791	return vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
1792	}
1793	}
1794
1795	/* Determine PCHS geometry (autogenerate if necessary). */
1796	rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
1797	VMDK_DDB_GEO_PCHS_CYLINDERS,
1798	&pImage->PCHSGeometry.cCylinders);
1799	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1800	pImage->PCHSGeometry.cCylinders = 0;
1801	else if (RT_FAILURE(rc))
1802	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
1803	rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
1804	VMDK_DDB_GEO_PCHS_HEADS,
1805	&pImage->PCHSGeometry.cHeads);
1806	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1807	pImage->PCHSGeometry.cHeads = 0;
1808	else if (RT_FAILURE(rc))
1809	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
1810	rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
1811	VMDK_DDB_GEO_PCHS_SECTORS,
1812	&pImage->PCHSGeometry.cSectors);
1813	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1814	pImage->PCHSGeometry.cSectors = 0;
1815	else if (RT_FAILURE(rc))
1816	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
1817	if ( pImage->PCHSGeometry.cCylinders == 0
1818	\|\| pImage->PCHSGeometry.cHeads == 0
1819	\|\| pImage->PCHSGeometry.cHeads > 16
1820	\|\| pImage->PCHSGeometry.cSectors == 0
1821	\|\| pImage->PCHSGeometry.cSectors > 63)
1822	{
1823	/* Mark PCHS geometry as not yet valid (can't do the calculation here
1824	* as the total image size isn't known yet). */
1825	pImage->PCHSGeometry.cCylinders = 0;
1826	pImage->PCHSGeometry.cHeads = 16;
1827	pImage->PCHSGeometry.cSectors = 63;
1828	}
1829
1830	/* Determine LCHS geometry (set to 0 if not specified). */
1831	rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
1832	VMDK_DDB_GEO_LCHS_CYLINDERS,
1833	&pImage->LCHSGeometry.cCylinders);
1834	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1835	pImage->LCHSGeometry.cCylinders = 0;
1836	else if (RT_FAILURE(rc))
1837	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
1838	rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
1839	VMDK_DDB_GEO_LCHS_HEADS,
1840	&pImage->LCHSGeometry.cHeads);
1841	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1842	pImage->LCHSGeometry.cHeads = 0;
1843	else if (RT_FAILURE(rc))
1844	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
1845	rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
1846	VMDK_DDB_GEO_LCHS_SECTORS,
1847	&pImage->LCHSGeometry.cSectors);
1848	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1849	pImage->LCHSGeometry.cSectors = 0;
1850	else if (RT_FAILURE(rc))
1851	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
1852	if ( pImage->LCHSGeometry.cCylinders == 0
1853	\|\| pImage->LCHSGeometry.cHeads == 0
1854	\|\| pImage->LCHSGeometry.cSectors == 0)
1855	{
1856	pImage->LCHSGeometry.cCylinders = 0;
1857	pImage->LCHSGeometry.cHeads = 0;
1858	pImage->LCHSGeometry.cSectors = 0;
1859	}
1860
1861	/* Get image UUID. */
1862	rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_IMAGE_UUID,
1863	&pImage->ImageUuid);
1864	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1865	{
1866	/* Image without UUID. Probably created by VMware and not yet used
1867	* by VirtualBox. Can only be added for images opened in read/write
1868	* mode, so don't bother producing a sensible UUID otherwise. */
1869	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1870	RTUuidClear(&pImage->ImageUuid);
1871	else
1872	{
1873	rc = RTUuidCreate(&pImage->ImageUuid);
1874	if (RT_FAILURE(rc))
1875	return rc;
1876	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
1877	VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
1878	if (RT_FAILURE(rc))
1879	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing image UUID in descriptor in '%s'"), pImage->pszFilename);
1880	}
1881	}
1882	else if (RT_FAILURE(rc))
1883	return rc;
1884
1885	/* Get image modification UUID. */
1886	rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor,
1887	VMDK_DDB_MODIFICATION_UUID,
1888	&pImage->ModificationUuid);
1889	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1890	{
1891	/* Image without UUID. Probably created by VMware and not yet used
1892	* by VirtualBox. Can only be added for images opened in read/write
1893	* mode, so don't bother producing a sensible UUID otherwise. */
1894	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1895	RTUuidClear(&pImage->ModificationUuid);
1896	else
1897	{
1898	rc = RTUuidCreate(&pImage->ModificationUuid);
1899	if (RT_FAILURE(rc))
1900	return rc;
1901	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
1902	VMDK_DDB_MODIFICATION_UUID,
1903	&pImage->ModificationUuid);
1904	if (RT_FAILURE(rc))
1905	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing image modification UUID in descriptor in '%s'"), pImage->pszFilename);
1906	}
1907	}
1908	else if (RT_FAILURE(rc))
1909	return rc;
1910
1911	/* Get UUID of parent image. */
1912	rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_UUID,
1913	&pImage->ParentUuid);
1914	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1915	{
1916	/* Image without UUID. Probably created by VMware and not yet used
1917	* by VirtualBox. Can only be added for images opened in read/write
1918	* mode, so don't bother producing a sensible UUID otherwise. */
1919	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1920	RTUuidClear(&pImage->ParentUuid);
1921	else
1922	{
1923	rc = RTUuidClear(&pImage->ParentUuid);
1924	if (RT_FAILURE(rc))
1925	return rc;
1926	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
1927	VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
1928	if (RT_FAILURE(rc))
1929	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent UUID in descriptor in '%s'"), pImage->pszFilename);
1930	}
1931	}
1932	else if (RT_FAILURE(rc))
1933	return rc;
1934
1935	/* Get parent image modification UUID. */
1936	rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor,
1937	VMDK_DDB_PARENT_MODIFICATION_UUID,
1938	&pImage->ParentModificationUuid);
1939	if (rc == VERR_VDI_VALUE_NOT_FOUND)
1940	{
1941	/* Image without UUID. Probably created by VMware and not yet used
1942	* by VirtualBox. Can only be added for images opened in read/write
1943	* mode, so don't bother producing a sensible UUID otherwise. */
1944	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1945	RTUuidClear(&pImage->ParentModificationUuid);
1946	else
1947	{
1948	rc = RTUuidCreate(&pImage->ParentModificationUuid);
1949	if (RT_FAILURE(rc))
1950	return rc;
1951	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
1952	VMDK_DDB_PARENT_MODIFICATION_UUID,
1953	&pImage->ParentModificationUuid);
1954	if (RT_FAILURE(rc))
1955	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent modification UUID in descriptor in '%s'"), pImage->pszFilename);
1956	}
1957	}
1958	else if (RT_FAILURE(rc))
1959	return rc;
1960
1961	return VINF_SUCCESS;
1962	}
1963
1964	/**
1965	* Internal: write/update the descriptor part of the image.
1966	*/
1967	static int vmdkWriteDescriptor(PVMDKIMAGE pImage)
1968	{
1969	int rc = VINF_SUCCESS;
1970	uint64_t cbLimit;
1971	uint64_t uOffset;
1972	PVMDKFILE pDescFile;
1973
1974	if (pImage->pDescData)
1975	{
1976	/* Separate descriptor file. */
1977	uOffset = 0;
1978	cbLimit = 0;
1979	pDescFile = pImage->pFile;
1980	}
1981	else
1982	{
1983	/* Embedded descriptor file. */
1984	uOffset = VMDK_SECTOR2BYTE(pImage->pExtents[0].uDescriptorSector);
1985	cbLimit = VMDK_SECTOR2BYTE(pImage->pExtents[0].cDescriptorSectors);
1986	cbLimit += uOffset;
1987	pDescFile = pImage->pExtents[0].pFile;
1988	}
1989	for (unsigned i = 0; i < pImage->Descriptor.cLines; i++)
1990	{
1991	const char *psz = pImage->Descriptor.aLines[i];
1992	size_t cb = strlen(psz);
1993
1994	if (cbLimit && uOffset + cb + 1 > cbLimit)
1995	return vmdkError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too long in '%s'"), pImage->pszFilename);
1996	rc = vmdkFileWriteAt(pDescFile, uOffset, psz, cb, NULL);
1997	if (RT_FAILURE(rc))
1998	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error writing descriptor in '%s'"), pImage->pszFilename);
1999	uOffset += cb;
2000	rc = vmdkFileWriteAt(pDescFile, uOffset, "\n", 1, NULL);
2001	if (RT_FAILURE(rc))
2002	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error writing descriptor in '%s'"), pImage->pszFilename);
2003	uOffset++;
2004	}
2005	if (cbLimit)
2006	{
2007	/* Inefficient, but simple. */
2008	while (uOffset < cbLimit)
2009	{
2010	rc = vmdkFileWriteAt(pDescFile, uOffset, "", 1, NULL);
2011	if (RT_FAILURE(rc))
2012	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error writing descriptor in '%s'"), pImage->pszFilename);
2013	uOffset++;
2014	}
2015	}
2016	else
2017	{
2018	rc = vmdkFileSetSize(pDescFile, uOffset);
2019	if (RT_FAILURE(rc))
2020	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error truncating descriptor in '%s'"), pImage->pszFilename);
2021	}
2022	pImage->Descriptor.fDirty = false;
2023	return rc;
2024	}
2025
2026	/**
2027	* Internal: read metadata belonging to an extent with binary header, i.e.
2028	* as found in monolithic files.
2029	*/
2030	static int vmdkReadBinaryMetaExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
2031	{
2032	SparseExtentHeader Header;
2033	uint64_t cSectorsPerGDE;
2034
2035	int rc = vmdkFileReadAt(pExtent->pFile, 0, &Header, sizeof(Header), NULL);
2036	AssertRC(rc);
2037	if (RT_FAILURE(rc))
2038	{
2039	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error reading extent header in '%s'"), pExtent->pszFullname);
2040	goto out;
2041	}
2042	if ( RT_LE2H_U32(Header.magicNumber) != VMDK_SPARSE_MAGICNUMBER
2043	\|\| RT_LE2H_U32(Header.version) != 1)
2044	{
2045	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect magic/version in extent header in '%s'"), pExtent->pszFullname);
2046	goto out;
2047	}
2048	if ( (RT_LE2H_U32(Header.flags) & 1)
2049	&& ( Header.singleEndLineChar != '\n'
2050	\|\| Header.nonEndLineChar != ' '
2051	\|\| Header.doubleEndLineChar1 != '\r'
2052	\|\| Header.doubleEndLineChar2 != '\n') )
2053	{
2054	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: corrupted by CR/LF translation in '%s'"), pExtent->pszFullname);
2055	goto out;
2056	}
2057	pExtent->enmType = VMDKETYPE_HOSTED_SPARSE; /* Just dummy value, changed later. */
2058	pExtent->cSectors = RT_LE2H_U64(Header.capacity);
2059	pExtent->cSectorsPerGrain = RT_LE2H_U64(Header.grainSize);
2060	pExtent->uDescriptorSector = RT_LE2H_U64(Header.descriptorOffset);
2061	pExtent->cDescriptorSectors = RT_LE2H_U64(Header.descriptorSize);
2062	if (pExtent->uDescriptorSector && !pExtent->cDescriptorSectors)
2063	{
2064	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: inconsistent embedded descriptor config in '%s'"), pExtent->pszFullname);
2065	goto out;
2066	}
2067	pExtent->cGTEntries = RT_LE2H_U32(Header.numGTEsPerGT);
2068	if (RT_LE2H_U32(Header.flags) & 2)
2069	{
2070	pExtent->uSectorRGD = RT_LE2H_U64(Header.rgdOffset);
2071	pExtent->uSectorGD = RT_LE2H_U64(Header.gdOffset);
2072	}
2073	else
2074	{
2075	/** @todo this is just guesswork, the spec doesn't document this
2076	* properly and I don't have a vmdk without RGD. */
2077	pExtent->uSectorGD = RT_LE2H_U64(Header.rgdOffset);
2078	pExtent->uSectorRGD = 0;
2079	}
2080	pExtent->cOverheadSectors = RT_LE2H_U64(Header.overHead);
2081	pExtent->fUncleanShutdown = !!Header.uncleanShutdown;
2082	cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
2083	if (!cSectorsPerGDE \|\| cSectorsPerGDE > UINT32_MAX)
2084	{
2085	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect grain directory size in '%s'"), pExtent->pszFullname);
2086	goto out;
2087	}
2088	pExtent->cSectorsPerGDE = cSectorsPerGDE;
2089	pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
2090
2091	/* Fix up the number of descriptor sectors, as some flat images have
2092	* really just one, and this causes failures when inserting the UUID
2093	* values and other extra information. */
2094	if (pExtent->cDescriptorSectors != 0 && pExtent->cDescriptorSectors < 4)
2095	{
2096	/* Do it the easy way - just fix it for flat images which have no
2097	* other complicated metadata which needs space too. */
2098	if ( pExtent->uDescriptorSector + 4 < pExtent->cOverheadSectors
2099	&& pExtent->cGTEntries * pExtent->cGDEntries == 0)
2100	pExtent->cDescriptorSectors = 4;
2101	}
2102
2103	out:
2104	if (RT_FAILURE(rc))
2105	vmdkFreeExtentData(pImage, pExtent, false);
2106
2107	return rc;
2108	}
2109
2110	/**
2111	* Internal: read additional metadata belonging to an extent. For those
2112	* extents which have no additional metadata just verify the information.
2113	*/
2114	static int vmdkReadMetaExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
2115	{
2116	int rc = VINF_SUCCESS;
2117	uint64_t cbExtentSize;
2118
2119	/* The image must be a multiple of a sector in size and contain the data
2120	* area (flat images only). If not, it means the image is at least
2121	* truncated, or even seriously garbled. */
2122	rc = vmdkFileGetSize(pExtent->pFile, &cbExtentSize);
2123	if (RT_FAILURE(rc))
2124	{
2125	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error getting size in '%s'"), pExtent->pszFullname);
2126	goto out;
2127	}
2128	/* disabled the size check again as there are too many too short vmdks out there */
2129	#ifdef VBOX_WITH_VMDK_STRICT_SIZE_CHECK
2130	if ( cbExtentSize != RT_ALIGN_64(cbExtentSize, 512)
2131	&& (pExtent->enmType != VMDKETYPE_FLAT \|\| pExtent->cNominalSectors + pExtent->uSectorOffset > VMDK_BYTE2SECTOR(cbExtentSize)))
2132	{
2133	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: file size is not a multiple of 512 in '%s', file is truncated or otherwise garbled"), pExtent->pszFullname);
2134	goto out;
2135	}
2136	#endif /* VBOX_WITH_VMDK_STRICT_SIZE_CHECK */
2137	if (pExtent->enmType != VMDKETYPE_HOSTED_SPARSE)
2138	goto out;
2139
2140	/* The spec says that this must be a power of two and greater than 8,
2141	* but probably they meant not less than 8. */
2142	if ( (pExtent->cSectorsPerGrain & (pExtent->cSectorsPerGrain - 1))
2143	\|\| pExtent->cSectorsPerGrain < 8)
2144	{
2145	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: invalid extent grain size %u in '%s'"), pExtent->cSectorsPerGrain, pExtent->pszFullname);
2146	goto out;
2147	}
2148
2149	/* This code requires that a grain table must hold a power of two multiple
2150	* of the number of entries per GT cache entry. */
2151	if ( (pExtent->cGTEntries & (pExtent->cGTEntries - 1))
2152	\|\| pExtent->cGTEntries < VMDK_GT_CACHELINE_SIZE)
2153	{
2154	rc = vmdkError(pExtent->pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: grain table cache size problem in '%s'"), pExtent->pszFullname);
2155	goto out;
2156	}
2157
2158	rc = vmdkReadGrainDirectory(pExtent);
2159
2160	out:
2161	if (RT_FAILURE(rc))
2162	vmdkFreeExtentData(pImage, pExtent, false);
2163
2164	return rc;
2165	}
2166
2167	/**
2168	* Internal: write/update the metadata for a sparse extent.
2169	*/
2170	static int vmdkWriteMetaSparseExtent(PVMDKEXTENT pExtent)
2171	{
2172	SparseExtentHeader Header;
2173
2174	memset(&Header, '\0', sizeof(Header));
2175	Header.magicNumber = RT_H2LE_U32(VMDK_SPARSE_MAGICNUMBER);
2176	Header.version = RT_H2LE_U32(1);
2177	Header.flags = RT_H2LE_U32(1 \| ((pExtent->pRGD) ? 2 : 0));
2178	Header.capacity = RT_H2LE_U64(pExtent->cSectors);
2179	Header.grainSize = RT_H2LE_U64(pExtent->cSectorsPerGrain);
2180	Header.descriptorOffset = RT_H2LE_U64(pExtent->uDescriptorSector);
2181	Header.descriptorSize = RT_H2LE_U64(pExtent->cDescriptorSectors);
2182	Header.numGTEsPerGT = RT_H2LE_U32(pExtent->cGTEntries);
2183	if (pExtent->pRGD)
2184	{
2185	Assert(pExtent->uSectorRGD);
2186	Header.rgdOffset = RT_H2LE_U64(pExtent->uSectorRGD);
2187	Header.gdOffset = RT_H2LE_U64(pExtent->uSectorGD);
2188	}
2189	else
2190	{
2191	/** @todo this is just guesswork, the spec doesn't document this
2192	* properly and I don't have a vmdk without RGD. */
2193	Header.rgdOffset = RT_H2LE_U64(pExtent->uSectorGD);
2194	}
2195	Header.overHead = RT_H2LE_U64(pExtent->cOverheadSectors);
2196	Header.uncleanShutdown = pExtent->fUncleanShutdown;
2197	Header.singleEndLineChar = '\n';
2198	Header.nonEndLineChar = ' ';
2199	Header.doubleEndLineChar1 = '\r';
2200	Header.doubleEndLineChar2 = '\n';
2201
2202	int rc = vmdkFileWriteAt(pExtent->pFile, 0, &Header, sizeof(Header), NULL);
2203	AssertRC(rc);
2204	if (RT_FAILURE(rc))
2205	rc = vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error writing extent header in '%s'"), pExtent->pszFullname);
2206	return rc;
2207	}
2208
2209	#ifdef VBOX_WITH_VMDK_ESX
2210	/**
2211	* Internal: unused code to read the metadata of a sparse ESX extent.
2212	*
2213	* Such extents never leave ESX server, so this isn't ever used.
2214	*/
2215	static int vmdkReadMetaESXSparseExtent(PVMDKEXTENT pExtent)
2216	{
2217	COWDisk_Header Header;
2218	uint64_t cSectorsPerGDE;
2219
2220	int rc = vmdkFileReadAt(pExtent->pFile, 0, &Header, sizeof(Header), NULL);
2221	AssertRC(rc);
2222	if (RT_FAILURE(rc))
2223	goto out;
2224	if ( RT_LE2H_U32(Header.magicNumber) != VMDK_ESX_SPARSE_MAGICNUMBER
2225	\|\| RT_LE2H_U32(Header.version) != 1
2226	\|\| RT_LE2H_U32(Header.flags) != 3)
2227	{
2228	rc = VERR_VDI_INVALID_HEADER;
2229	goto out;
2230	}
2231	pExtent->enmType = VMDKETYPE_ESX_SPARSE;
2232	pExtent->cSectors = RT_LE2H_U32(Header.numSectors);
2233	pExtent->cSectorsPerGrain = RT_LE2H_U32(Header.grainSize);
2234	/* The spec says that this must be between 1 sector and 1MB. This code
2235	* assumes it's a power of two, so check that requirement, too. */
2236	if ( (pExtent->cSectorsPerGrain & (pExtent->cSectorsPerGrain - 1))
2237	\|\| pExtent->cSectorsPerGrain == 0
2238	\|\| pExtent->cSectorsPerGrain > 2048)
2239	{
2240	rc = VERR_VDI_INVALID_HEADER;
2241	goto out;
2242	}
2243	pExtent->uDescriptorSector = 0;
2244	pExtent->cDescriptorSectors = 0;
2245	pExtent->uSectorGD = RT_LE2H_U32(Header.gdOffset);
2246	pExtent->uSectorRGD = 0;
2247	pExtent->cOverheadSectors = 0;
2248	pExtent->cGTEntries = 4096;
2249	cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
2250	if (!cSectorsPerGDE \|\| cSectorsPerGDE > UINT32_MAX)
2251	{
2252	rc = VERR_VDI_INVALID_HEADER;
2253	goto out;
2254	}
2255	pExtent->cSectorsPerGDE = cSectorsPerGDE;
2256	pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
2257	if (pExtent->cGDEntries != RT_LE2H_U32(Header.numGDEntries))
2258	{
2259	/* Inconsistency detected. Computed number of GD entries doesn't match
2260	* stored value. Better be safe than sorry. */
2261	rc = VERR_VDI_INVALID_HEADER;
2262	goto out;
2263	}
2264	pExtent->uFreeSector = RT_LE2H_U32(Header.freeSector);
2265	pExtent->fUncleanShutdown = !!Header.uncleanShutdown;
2266
2267	rc = vmdkReadGrainDirectory(pExtent);
2268
2269	out:
2270	if (RT_FAILURE(rc))
2271	vmdkFreeExtentData(pImage, pExtent, false);
2272
2273	return rc;
2274	}
2275	#endif /* VBOX_WITH_VMDK_ESX */
2276
2277	/**
2278	* Internal: free the memory used by the extent data structure, optionally
2279	* deleting the referenced files.
2280	*/
2281	static void vmdkFreeExtentData(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
2282	bool fDelete)
2283	{
2284	vmdkFreeGrainDirectory(pExtent);
2285	if (pExtent->pDescData)
2286	{
2287	RTMemFree(pExtent->pDescData);
2288	pExtent->pDescData = NULL;
2289	}
2290	if (pExtent->pFile != NULL)
2291	{
2292	/* Do not delete raw extents, these have full and base names equal. */
2293	vmdkFileClose(pImage, &pExtent->pFile,
2294	fDelete
2295	&& pExtent->pszFullname
2296	&& strcmp(pExtent->pszFullname, pExtent->pszBasename));
2297	}
2298	if (pExtent->pszBasename)
2299	{
2300	RTMemTmpFree((void *)pExtent->pszBasename);
2301	pExtent->pszBasename = NULL;
2302	}
2303	if (pExtent->pszFullname)
2304	{
2305	RTStrFree((char )(void )pExtent->pszFullname);
2306	pExtent->pszFullname = NULL;
2307	}
2308	}
2309
2310	/**
2311	* Internal: allocate grain table cache if necessary for this image.
2312	*/
2313	static int vmdkAllocateGrainTableCache(PVMDKIMAGE pImage)
2314	{
2315	PVMDKEXTENT pExtent;
2316
2317	/* Allocate grain table cache if any sparse extent is present. */
2318	for (unsigned i = 0; i < pImage->cExtents; i++)
2319	{
2320	pExtent = &pImage->pExtents[i];
2321	if ( pExtent->enmType == VMDKETYPE_HOSTED_SPARSE
2322	#ifdef VBOX_WITH_VMDK_ESX
2323	\|\| pExtent->enmType == VMDKETYPE_ESX_SPARSE
2324	#endif /* VBOX_WITH_VMDK_ESX */
2325	)
2326	{
2327	/* Allocate grain table cache. */
2328	pImage->pGTCache = (PVMDKGTCACHE)RTMemAllocZ(sizeof(VMDKGTCACHE));
2329	if (!pImage->pGTCache)
2330	return VERR_NO_MEMORY;
2331	for (unsigned i = 0; i < VMDK_GT_CACHE_SIZE; i++)
2332	{
2333	PVMDKGTCACHEENTRY pGCE = &pImage->pGTCache->aGTCache[i];
2334	pGCE->uExtent = UINT32_MAX;
2335	}
2336	pImage->pGTCache->cEntries = VMDK_GT_CACHE_SIZE;
2337	break;
2338	}
2339	}
2340
2341	return VINF_SUCCESS;
2342	}
2343
2344	/**
2345	* Internal: allocate the given number of extents.
2346	*/
2347	static int vmdkCreateExtents(PVMDKIMAGE pImage, unsigned cExtents)
2348	{
2349	int rc = VINF_SUCCESS;
2350	PVMDKEXTENT pExtents = (PVMDKEXTENT)RTMemAllocZ(cExtents * sizeof(VMDKEXTENT));
2351	if (pImage)
2352	{
2353	for (unsigned i = 0; i < cExtents; i++)
2354	{
2355	pExtents[i].pFile = NULL;
2356	pExtents[i].pszBasename = NULL;
2357	pExtents[i].pszFullname = NULL;
2358	pExtents[i].pGD = NULL;
2359	pExtents[i].pRGD = NULL;
2360	pExtents[i].pDescData = NULL;
2361	pExtents[i].uExtent = i;
2362	pExtents[i].pImage = pImage;
2363	}
2364	pImage->pExtents = pExtents;
2365	pImage->cExtents = cExtents;
2366	}
2367	else
2368	rc = VERR_NO_MEMORY;
2369
2370	return rc;
2371	}
2372
2373	/**
2374	* Internal: Open an image, constructing all necessary data structures.
2375	*/
2376	static int vmdkOpenImage(PVMDKIMAGE pImage, unsigned uOpenFlags)
2377	{
2378	int rc;
2379	uint32_t u32Magic;
2380	PVMDKFILE pFile;
2381	PVMDKEXTENT pExtent;
2382
2383	pImage->uOpenFlags = uOpenFlags;
2384
2385	/* Try to get error interface. */
2386	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
2387	if (pImage->pInterfaceError)
2388	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
2389
2390	/* Try to get async I/O interface. */
2391	pImage->pInterfaceAsyncIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ASYNCIO);
2392	if (pImage->pInterfaceAsyncIO)
2393	pImage->pInterfaceAsyncIOCallbacks = VDGetInterfaceAsyncIO(pImage->pInterfaceAsyncIO);
2394
2395	/*
2396	* Open the image.
2397	* We don't have to check for asynchronous access because
2398	* we only support raw access and the opened file is a description
2399	* file were no data is stored.
2400	*/
2401	rc = vmdkFileOpen(pImage, &pFile, pImage->pszFilename,
2402	uOpenFlags & VD_OPEN_FLAGS_READONLY
2403	? RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE
2404	: RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, false);
2405	if (RT_FAILURE(rc))
2406	{
2407	/* Do NOT signal an appropriate error here, as the VD layer has the
2408	* choice of retrying the open if it failed. */
2409	goto out;
2410	}
2411	pImage->pFile = pFile;
2412
2413	/* Read magic (if present). */
2414	rc = vmdkFileReadAt(pFile, 0, &u32Magic, sizeof(u32Magic), NULL);
2415	if (RT_FAILURE(rc))
2416	{
2417	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error reading the magic number in '%s'"), pImage->pszFilename);
2418	goto out;
2419	}
2420
2421	/* Handle the file according to its magic number. */
2422	if (RT_LE2H_U32(u32Magic) == VMDK_SPARSE_MAGICNUMBER)
2423	{
2424	/* It's a hosted single-extent image. */
2425	rc = vmdkCreateExtents(pImage, 1);
2426	if (RT_FAILURE(rc))
2427	goto out;
2428	/* The opened file is passed to the extent. No separate descriptor
2429	* file, so no need to keep anything open for the image. */
2430	pExtent = &pImage->pExtents[0];
2431	pExtent->pFile = pFile;
2432	pImage->pFile = NULL;
2433	pExtent->pszFullname = RTPathAbsDup(pImage->pszFilename);
2434	if (!pExtent->pszFullname)
2435	{
2436	rc = VERR_NO_MEMORY;
2437	goto out;
2438	}
2439	rc = vmdkReadBinaryMetaExtent(pImage, pExtent);
2440	if (RT_FAILURE(rc))
2441	goto out;
2442	/* As we're dealing with a monolithic image here, there must
2443	* be a descriptor embedded in the image file. */
2444	if (!pExtent->uDescriptorSector \|\| !pExtent->cDescriptorSectors)
2445	{
2446	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image without descriptor in '%s'"), pImage->pszFilename);
2447	goto out;
2448	}
2449	/* Read the descriptor from the extent. */
2450	pExtent->pDescData = (char *)RTMemAllocZ(VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
2451	if (!pExtent->pDescData)
2452	{
2453	rc = VERR_NO_MEMORY;
2454	goto out;
2455	}
2456	rc = vmdkFileReadAt(pExtent->pFile,
2457	VMDK_SECTOR2BYTE(pExtent->uDescriptorSector),
2458	pExtent->pDescData,
2459	VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors), NULL);
2460	AssertRC(rc);
2461	if (RT_FAILURE(rc))
2462	{
2463	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: read error for descriptor in '%s'"), pExtent->pszFullname);
2464	goto out;
2465	}
2466
2467	rc = vmdkParseDescriptor(pImage, pExtent->pDescData,
2468	VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
2469	if (RT_FAILURE(rc))
2470	goto out;
2471
2472	rc = vmdkReadMetaExtent(pImage, pExtent);
2473	if (RT_FAILURE(rc))
2474	goto out;
2475
2476	/* Mark the extent as unclean if opened in read-write mode. */
2477	if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
2478	{
2479	pExtent->fUncleanShutdown = true;
2480	pExtent->fMetaDirty = true;
2481	}
2482	}
2483	else
2484	{
2485	pImage->cbDescAlloc = VMDK_SECTOR2BYTE(20);
2486	pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
2487	if (!pImage->pDescData)
2488	{
2489	rc = VERR_NO_MEMORY;
2490	goto out;
2491	}
2492
2493	size_t cbRead;
2494	rc = vmdkFileReadAt(pImage->pFile, 0, pImage->pDescData,
2495	pImage->cbDescAlloc, &cbRead);
2496	if (RT_FAILURE(rc))
2497	{
2498	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: read error for descriptor in '%s'"), pImage->pszFilename);
2499	goto out;
2500	}
2501	if (cbRead == pImage->cbDescAlloc)
2502	{
2503	/* Likely the read is truncated. Better fail a bit too early
2504	* (normally the descriptor is much smaller than our buffer). */
2505	rc = vmdkError(pImage, VERR_VDI_INVALID_HEADER, RT_SRC_POS, N_("VMDK: cannot read descriptor in '%s'"), pImage->pszFilename);
2506	goto out;
2507	}
2508
2509	rc = vmdkParseDescriptor(pImage, pImage->pDescData,
2510	pImage->cbDescAlloc);
2511	if (RT_FAILURE(rc))
2512	goto out;
2513
2514	/*
2515	* We have to check for the asynchronous open flag. The
2516	* extents are parsed and the type of all are known now.
2517	* Check if every extent is either FLAT or ZERO.
2518	*/
2519	if (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)
2520	{
2521	for (unsigned i = 0; i < pImage->cExtents; i++)
2522	{
2523	PVMDKEXTENT pExtent = &pImage->pExtents[i];
2524
2525	if ( (pExtent->enmType != VMDKETYPE_FLAT)
2526	&& (pExtent->enmType != VMDKETYPE_ZERO))
2527	{
2528	/*
2529	* Opened image contains at least one none flat or zero extent.
2530	* Return error but don't set error message as the caller
2531	* has the chance to open in non async I/O mode.
2532	*/
2533	rc = VERR_NOT_SUPPORTED;
2534	goto out;
2535	}
2536	}
2537	}
2538
2539	for (unsigned i = 0; i < pImage->cExtents; i++)
2540	{
2541	PVMDKEXTENT pExtent = &pImage->pExtents[i];
2542
2543	if (pExtent->pszBasename)
2544	{
2545	/* Hack to figure out whether the specified name in the
2546	* extent descriptor is absolute. Doesn't always work, but
2547	* should be good enough for now. */
2548	char *pszFullname;
2549	/** @todo implement proper path absolute check. */
2550	if (pExtent->pszBasename[0] == RTPATH_SLASH)
2551	{
2552	pszFullname = RTStrDup(pExtent->pszBasename);
2553	if (!pszFullname)
2554	{
2555	rc = VERR_NO_MEMORY;
2556	goto out;
2557	}
2558	}
2559	else
2560	{
2561	size_t cbDirname;
2562	char *pszDirname = RTStrDup(pImage->pszFilename);
2563	if (!pszDirname)
2564	{
2565	rc = VERR_NO_MEMORY;
2566	goto out;
2567	}
2568	RTPathStripFilename(pszDirname);
2569	cbDirname = strlen(pszDirname);
2570	rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszDirname,
2571	RTPATH_SLASH, pExtent->pszBasename);
2572	RTStrFree(pszDirname);
2573	if (RT_FAILURE(rc))
2574	goto out;
2575	}
2576	pExtent->pszFullname = pszFullname;
2577	}
2578	else
2579	pExtent->pszFullname = NULL;
2580
2581	switch (pExtent->enmType)
2582	{
2583	case VMDKETYPE_HOSTED_SPARSE:
2584	rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
2585	uOpenFlags & VD_OPEN_FLAGS_READONLY
2586	? RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE
2587	: RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, false);
2588	if (RT_FAILURE(rc))
2589	{
2590	/* Do NOT signal an appropriate error here, as the VD
2591	* layer has the choice of retrying the open if it
2592	* failed. */
2593	goto out;
2594	}
2595	rc = vmdkReadBinaryMetaExtent(pImage, pExtent);
2596	if (RT_FAILURE(rc))
2597	goto out;
2598	rc = vmdkReadMetaExtent(pImage, pExtent);
2599	if (RT_FAILURE(rc))
2600	goto out;
2601
2602	/* Mark extent as unclean if opened in read-write mode. */
2603	if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
2604	{
2605	pExtent->fUncleanShutdown = true;
2606	pExtent->fMetaDirty = true;
2607	}
2608	break;
2609	case VMDKETYPE_FLAT:
2610	rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
2611	uOpenFlags & VD_OPEN_FLAGS_READONLY
2612	? RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE
2613	: RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, true);
2614	if (RT_FAILURE(rc))
2615	{
2616	/* Do NOT signal an appropriate error here, as the VD
2617	* layer has the choice of retrying the open if it
2618	* failed. */
2619	goto out;
2620	}
2621	break;
2622	case VMDKETYPE_ZERO:
2623	/* Nothing to do. */
2624	break;
2625	default:
2626	AssertMsgFailed(("unknown vmdk extent type %d\n", pExtent->enmType));
2627	}
2628	}
2629	}
2630
2631	/* Make sure this is not reached accidentally with an error status. */
2632	AssertRC(rc);
2633
2634	/* Determine PCHS geometry if not set. */
2635	if (pImage->PCHSGeometry.cCylinders == 0)
2636	{
2637	uint64_t cCylinders = VMDK_BYTE2SECTOR(pImage->cbSize)
2638	/ pImage->PCHSGeometry.cHeads
2639	/ pImage->PCHSGeometry.cSectors;
2640	pImage->PCHSGeometry.cCylinders = (unsigned)RT_MIN(cCylinders, 16383);
2641	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2642	{
2643	rc = vmdkDescSetPCHSGeometry(pImage, &pImage->PCHSGeometry);
2644	AssertRC(rc);
2645	}
2646	}
2647
2648	/* Update the image metadata now in case has changed. */
2649	rc = vmdkFlushImage(pImage);
2650	if (RT_FAILURE(rc))
2651	goto out;
2652
2653	/* Figure out a few per-image constants from the extents. */
2654	pImage->cbSize = 0;
2655	for (unsigned i = 0; i < pImage->cExtents; i++)
2656	{
2657	pExtent = &pImage->pExtents[i];
2658	if ( pExtent->enmType == VMDKETYPE_HOSTED_SPARSE
2659	#ifdef VBOX_WITH_VMDK_ESX
2660	\|\| pExtent->enmType == VMDKETYPE_ESX_SPARSE
2661	#endif /* VBOX_WITH_VMDK_ESX */
2662	)
2663	{
2664	/* Here used to be a check whether the nominal size of an extent
2665	* is a multiple of the grain size. The spec says that this is
2666	* always the case, but unfortunately some files out there in the
2667	* wild violate the spec (e.g. ReactOS 0.3.1). */
2668	}
2669	pImage->cbSize += VMDK_SECTOR2BYTE(pExtent->cNominalSectors);
2670	}
2671
2672	pImage->enmImageType = VD_IMAGE_TYPE_NORMAL;
2673	for (unsigned i = 0; i < pImage->cExtents; i++)
2674	{
2675	pExtent = &pImage->pExtents[i];
2676	if ( pImage->pExtents[i].enmType == VMDKETYPE_FLAT
2677	\|\| pImage->pExtents[i].enmType == VMDKETYPE_ZERO)
2678	{
2679	pImage->enmImageType = VD_IMAGE_TYPE_FIXED;
2680	break;
2681	}
2682	}
2683
2684	rc = vmdkAllocateGrainTableCache(pImage);
2685	if (RT_FAILURE(rc))
2686	goto out;
2687
2688	out:
2689	if (RT_FAILURE(rc))
2690	vmdkFreeImage(pImage, false);
2691	return rc;
2692	}
2693
2694	/**
2695	* Internal: create VMDK images for raw disk/partition access.
2696	*/
2697	static int vmdkCreateRawImage(PVMDKIMAGE pImage, const PVBOXHDDRAW pRaw,
2698	uint64_t cbSize)
2699	{
2700	int rc = VINF_SUCCESS;
2701	PVMDKEXTENT pExtent;
2702
2703	if (pRaw->fRawDisk)
2704	{
2705	/* Full raw disk access. This requires setting up a descriptor
2706	* file and open the (flat) raw disk. */
2707	rc = vmdkCreateExtents(pImage, 1);
2708	if (RT_FAILURE(rc))
2709	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
2710	pExtent = &pImage->pExtents[0];
2711	/* Create raw disk descriptor file. */
2712	rc = vmdkFileOpen(pImage, &pImage->pFile, pImage->pszFilename,
2713	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE \| RTFILE_O_NOT_CONTENT_INDEXED,
2714	false);
2715	if (RT_FAILURE(rc))
2716	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pImage->pszFilename);
2717
2718	/* Set up basename for extent description. Cannot use StrDup. */
2719	size_t cbBasename = strlen(pRaw->pszRawDisk) + 1;
2720	char pszBasename = (char )RTMemTmpAlloc(cbBasename);
2721	if (!pszBasename)
2722	return VERR_NO_MEMORY;
2723	memcpy(pszBasename, pRaw->pszRawDisk, cbBasename);
2724	pExtent->pszBasename = pszBasename;
2725	/* For raw disks the full name is identical to the base name. */
2726	pExtent->pszFullname = RTStrDup(pszBasename);
2727	if (!pExtent->pszFullname)
2728	return VERR_NO_MEMORY;
2729	pExtent->enmType = VMDKETYPE_FLAT;
2730	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
2731	pExtent->uSectorOffset = 0;
2732	pExtent->enmAccess = VMDKACCESS_READWRITE;
2733	pExtent->fMetaDirty = false;
2734
2735	/* Open flat image, the raw disk. */
2736	rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
2737	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, false);
2738	if (RT_FAILURE(rc))
2739	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not open raw disk file '%s'"), pExtent->pszFullname);
2740	}
2741	else
2742	{
2743	/* Raw partition access. This requires setting up a descriptor
2744	* file, write the partition information to a flat extent and
2745	* open all the (flat) raw disk partitions. */
2746
2747	/* First pass over the partitions to determine how many
2748	* extents we need. One partition can require up to 4 extents.
2749	* One to skip over unpartitioned space, one for the
2750	* partitioning data, one to skip over unpartitioned space
2751	* and one for the partition data. */
2752	unsigned cExtents = 0;
2753	uint64_t uStart = 0;
2754	for (unsigned i = 0; i < pRaw->cPartitions; i++)
2755	{
2756	PVBOXHDDRAWPART pPart = &pRaw->pPartitions[i];
2757	if (pPart->cbPartitionData)
2758	{
2759	if (uStart > pPart->uPartitionDataStart)
2760	return vmdkError(pImage, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("VMDK: cannot go backwards for partitioning information in '%s'"), pImage->pszFilename);
2761	else if (uStart != pPart->uPartitionDataStart)
2762	cExtents++;
2763	uStart = pPart->uPartitionDataStart + pPart->cbPartitionData;
2764	cExtents++;
2765	}
2766	if (pPart->cbPartition)
2767	{
2768	if (uStart > pPart->uPartitionStart)
2769	return vmdkError(pImage, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("VMDK: cannot go backwards for partition data in '%s'"), pImage->pszFilename);
2770	else if (uStart != pPart->uPartitionStart)
2771	cExtents++;
2772	uStart = pPart->uPartitionStart + pPart->cbPartition;
2773	cExtents++;
2774	}
2775	}
2776	/* Another extent for filling up the rest of the image. */
2777	if (uStart != cbSize)
2778	cExtents++;
2779
2780	rc = vmdkCreateExtents(pImage, cExtents);
2781	if (RT_FAILURE(rc))
2782	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
2783
2784	/* Create raw partition descriptor file. */
2785	rc = vmdkFileOpen(pImage, &pImage->pFile, pImage->pszFilename,
2786	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE \| RTFILE_O_NOT_CONTENT_INDEXED,
2787	false);
2788	if (RT_FAILURE(rc))
2789	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pImage->pszFilename);
2790
2791	/* Create base filename for the partition table extent. */
2792	/** @todo remove fixed buffer without creating memory leaks. */
2793	char pszPartition[1024];
2794	const char *pszBase = RTPathFilename(pImage->pszFilename);
2795	const char *pszExt = RTPathExt(pszBase);
2796	if (pszExt == NULL)
2797	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: invalid filename '%s'"), pImage->pszFilename);
2798	char *pszBaseBase = RTStrDup(pszBase);
2799	if (!pszBaseBase)
2800	return VERR_NO_MEMORY;
2801	RTPathStripExt(pszBaseBase);
2802	RTStrPrintf(pszPartition, sizeof(pszPartition), "%s-pt%s",
2803	pszBaseBase, pszExt);
2804	RTStrFree(pszBaseBase);
2805
2806	/* Second pass over the partitions, now define all extents. */
2807	uint64_t uPartOffset = 0;
2808	cExtents = 0;
2809	uStart = 0;
2810	for (unsigned i = 0; i < pRaw->cPartitions; i++)
2811	{
2812	PVBOXHDDRAWPART pPart = &pRaw->pPartitions[i];
2813	if (pPart->cbPartitionData)
2814	{
2815	if (uStart != pPart->uPartitionDataStart)
2816	{
2817	pExtent = &pImage->pExtents[cExtents++];
2818	pExtent->pszBasename = NULL;
2819	pExtent->pszFullname = NULL;
2820	pExtent->enmType = VMDKETYPE_ZERO;
2821	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->uPartitionDataStart - uStart);
2822	pExtent->uSectorOffset = 0;
2823	pExtent->enmAccess = VMDKACCESS_READWRITE;
2824	pExtent->fMetaDirty = false;
2825	}
2826	uStart = pPart->uPartitionDataStart + pPart->cbPartitionData;
2827	pExtent = &pImage->pExtents[cExtents++];
2828	/* Set up basename for extent description. Can't use StrDup. */
2829	size_t cbBasename = strlen(pszPartition) + 1;
2830	char pszBasename = (char )RTMemTmpAlloc(cbBasename);
2831	if (!pszBasename)
2832	return VERR_NO_MEMORY;
2833	memcpy(pszBasename, pszPartition, cbBasename);
2834	pExtent->pszBasename = pszBasename;
2835
2836	/* Set up full name for partition extent. */
2837	size_t cbDirname;
2838	char *pszDirname = RTStrDup(pImage->pszFilename);
2839	if (!pszDirname)
2840	return VERR_NO_MEMORY;
2841	RTPathStripFilename(pszDirname);
2842	cbDirname = strlen(pszDirname);
2843	char *pszFullname;
2844	rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszDirname,
2845	RTPATH_SLASH, pExtent->pszBasename);
2846	RTStrFree(pszDirname);
2847	if (RT_FAILURE(rc))
2848	return rc;
2849	pExtent->pszFullname = pszFullname;
2850	pExtent->enmType = VMDKETYPE_FLAT;
2851	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbPartitionData);
2852	pExtent->uSectorOffset = uPartOffset;
2853	pExtent->enmAccess = VMDKACCESS_READWRITE;
2854	pExtent->fMetaDirty = false;
2855
2856	/* Create partition table flat image. */
2857	rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
2858	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE \| RTFILE_O_NOT_CONTENT_INDEXED,
2859	false);
2860	if (RT_FAILURE(rc))
2861	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new partition data file '%s'"), pExtent->pszFullname);
2862	rc = vmdkFileWriteAt(pExtent->pFile,
2863	VMDK_SECTOR2BYTE(uPartOffset),
2864	pPart->pvPartitionData,
2865	pPart->cbPartitionData, NULL);
2866	if (RT_FAILURE(rc))
2867	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not write partition data to '%s'"), pExtent->pszFullname);
2868	uPartOffset += VMDK_BYTE2SECTOR(pPart->cbPartitionData);
2869	}
2870	if (pPart->cbPartition)
2871	{
2872	if (uStart != pPart->uPartitionStart)
2873	{
2874	pExtent = &pImage->pExtents[cExtents++];
2875	pExtent->pszBasename = NULL;
2876	pExtent->pszFullname = NULL;
2877	pExtent->enmType = VMDKETYPE_ZERO;
2878	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->uPartitionStart - uStart);
2879	pExtent->uSectorOffset = 0;
2880	pExtent->enmAccess = VMDKACCESS_READWRITE;
2881	pExtent->fMetaDirty = false;
2882	}
2883	uStart = pPart->uPartitionStart + pPart->cbPartition;
2884	pExtent = &pImage->pExtents[cExtents++];
2885	if (pPart->pszRawDevice)
2886	{
2887	/* Set up basename for extent descr. Can't use StrDup. */
2888	size_t cbBasename = strlen(pPart->pszRawDevice) + 1;
2889	char pszBasename = (char )RTMemTmpAlloc(cbBasename);
2890	if (!pszBasename)
2891	return VERR_NO_MEMORY;
2892	memcpy(pszBasename, pPart->pszRawDevice, cbBasename);
2893	pExtent->pszBasename = pszBasename;
2894	/* For raw disks full name is identical to base name. */
2895	pExtent->pszFullname = RTStrDup(pszBasename);
2896	if (!pExtent->pszFullname)
2897	return VERR_NO_MEMORY;
2898	pExtent->enmType = VMDKETYPE_FLAT;
2899	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbPartition);
2900	pExtent->uSectorOffset = VMDK_BYTE2SECTOR(pPart->uPartitionStartOffset);
2901	pExtent->enmAccess = VMDKACCESS_READWRITE;
2902	pExtent->fMetaDirty = false;
2903
2904	/* Open flat image, the raw partition. */
2905	rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
2906	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE,
2907	false);
2908	if (RT_FAILURE(rc))
2909	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not open raw partition file '%s'"), pExtent->pszFullname);
2910	}
2911	else
2912	{
2913	pExtent->pszBasename = NULL;
2914	pExtent->pszFullname = NULL;
2915	pExtent->enmType = VMDKETYPE_ZERO;
2916	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbPartition);
2917	pExtent->uSectorOffset = 0;
2918	pExtent->enmAccess = VMDKACCESS_READWRITE;
2919	pExtent->fMetaDirty = false;
2920	}
2921	}
2922	}
2923	/* Another extent for filling up the rest of the image. */
2924	if (uStart != cbSize)
2925	{
2926	pExtent = &pImage->pExtents[cExtents++];
2927	pExtent->pszBasename = NULL;
2928	pExtent->pszFullname = NULL;
2929	pExtent->enmType = VMDKETYPE_ZERO;
2930	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize - uStart);
2931	pExtent->uSectorOffset = 0;
2932	pExtent->enmAccess = VMDKACCESS_READWRITE;
2933	pExtent->fMetaDirty = false;
2934	}
2935	}
2936
2937	rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
2938	pRaw->fRawDisk ?
2939	"fullDevice" : "partitionedDevice");
2940	if (RT_FAILURE(rc))
2941	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
2942	return rc;
2943	}
2944
2945	/**
2946	* Internal: create a regular (i.e. file-backed) VMDK image.
2947	*/
2948	static int vmdkCreateRegularImage(PVMDKIMAGE pImage, VDIMAGETYPE enmType,
2949	uint64_t cbSize, unsigned uImageFlags,
2950	PFNVMPROGRESS pfnProgress, void *pvUser,
2951	unsigned uPercentStart, unsigned uPercentSpan)
2952	{
2953	int rc = VINF_SUCCESS;
2954	unsigned cExtents = 1;
2955	uint64_t cbOffset = 0;
2956	uint64_t cbRemaining = cbSize;
2957
2958	if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
2959	{
2960	cExtents = cbSize / VMDK_2G_SPLIT_SIZE;
2961	/* Do proper extent computation: need one smaller extent if the total
2962	* size isn't evenly divisible by the split size. */
2963	if (cbSize % VMDK_2G_SPLIT_SIZE)
2964	cExtents++;
2965	}
2966	rc = vmdkCreateExtents(pImage, cExtents);
2967	if (RT_FAILURE(rc))
2968	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
2969
2970	/* Basename strings needed for constructing the extent names. */
2971	char *pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
2972	Assert(pszBasenameSubstr);
2973	size_t cbBasenameSubstr = strlen(pszBasenameSubstr) + 1;
2974
2975	/* Create searate descriptor file if necessary. */
2976	if (cExtents != 1 \|\| enmType == VD_IMAGE_TYPE_FIXED)
2977	{
2978	rc = vmdkFileOpen(pImage, &pImage->pFile, pImage->pszFilename,
2979	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE \| RTFILE_O_NOT_CONTENT_INDEXED,
2980	false);
2981	if (RT_FAILURE(rc))
2982	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new sparse descriptor file '%s'"), pImage->pszFilename);
2983	// @todo Is there any sense in the following line I've commented out?
2984	//pImage->pszFilename = RTStrDup(pImage->pszFilename);
2985	}
2986	else
2987	pImage->pFile = NULL;
2988
2989	/* Set up all extents. */
2990	for (unsigned i = 0; i < cExtents; i++)
2991	{
2992	PVMDKEXTENT pExtent = &pImage->pExtents[i];
2993	uint64_t cbExtent = cbRemaining;
2994
2995	/* Set up fullname/basename for extent description. Cannot use StrDup
2996	* for basename, as it is not guaranteed that the memory can be freed
2997	* with RTMemTmpFree, which must be used as in other code paths
2998	* StrDup is not usable. */
2999	if (cExtents == 1 && enmType != VD_IMAGE_TYPE_FIXED)
3000	{
3001	char pszBasename = (char )RTMemTmpAlloc(cbBasenameSubstr);
3002	if (!pszBasename)
3003	return VERR_NO_MEMORY;
3004	memcpy(pszBasename, pszBasenameSubstr, cbBasenameSubstr);
3005	pExtent->pszBasename = pszBasename;
3006	}
3007	else
3008	{
3009	char *pszBasenameExt = RTPathExt(pszBasenameSubstr);
3010	char *pszBasenameBase = RTStrDup(pszBasenameSubstr);
3011	RTPathStripExt(pszBasenameBase);
3012	char *pszTmp;
3013	size_t cbTmp;
3014	if (enmType == VD_IMAGE_TYPE_FIXED)
3015	{
3016	if (cExtents == 1)
3017	rc = RTStrAPrintf(&pszTmp, "%s-flat%s", pszBasenameBase,
3018	pszBasenameExt);
3019	else
3020	rc = RTStrAPrintf(&pszTmp, "%s-f%03d%s", pszBasenameBase,
3021	i+1, pszBasenameExt);
3022	}
3023	else
3024	rc = RTStrAPrintf(&pszTmp, "%s-s%03d%s", pszBasenameBase, i+1,
3025	pszBasenameExt);
3026	RTStrFree(pszBasenameBase);
3027	if (RT_FAILURE(rc))
3028	return rc;
3029	cbTmp = strlen(pszTmp) + 1;
3030	char pszBasename = (char )RTMemTmpAlloc(cbTmp);
3031	if (!pszBasename)
3032	return VERR_NO_MEMORY;
3033	memcpy(pszBasename, pszTmp, cbTmp);
3034	RTStrFree(pszTmp);
3035	pExtent->pszBasename = pszBasename;
3036	if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
3037	cbExtent = RT_MIN(cbRemaining, VMDK_2G_SPLIT_SIZE);
3038	}
3039	char *pszBasedirectory = RTStrDup(pImage->pszFilename);
3040	RTPathStripFilename(pszBasedirectory);
3041	char *pszFullname;
3042	rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszBasedirectory,
3043	RTPATH_SLASH, pExtent->pszBasename);
3044	RTStrFree(pszBasedirectory);
3045	if (RT_FAILURE(rc))
3046	return rc;
3047	pExtent->pszFullname = pszFullname;
3048
3049	/* Create file for extent. */
3050	rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
3051	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE \| RTFILE_O_NOT_CONTENT_INDEXED,
3052	false);
3053	if (RT_FAILURE(rc))
3054	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
3055	if (enmType == VD_IMAGE_TYPE_FIXED)
3056	{
3057	rc = vmdkFileSetSize(pExtent->pFile, cbExtent);
3058	if (RT_FAILURE(rc))
3059	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
3060
3061	/* Fill image with zeroes. We do this for every fixed-size image since on some systems
3062	* (for example Windows Vista), it takes ages to write a block near the end of a sparse
3063	* file and the guest could complain about an ATA timeout. */
3064
3065	/** @todo Starting with Linux 2.6.23, there is an fallocate() system call.
3066	* Currently supported file systems are ext4 and ocfs2. */
3067
3068	/* Allocate a temporary zero-filled buffer. Use a bigger block size to optimize writing */
3069	const size_t cbBuf = 128 * _1K;
3070	void *pvBuf = RTMemTmpAllocZ(cbBuf);
3071	if (!pvBuf)
3072	return VERR_NO_MEMORY;
3073
3074	uint64_t uOff = 0;
3075	/* Write data to all image blocks. */
3076	while (uOff < cbExtent)
3077	{
3078	unsigned cbChunk = (unsigned)RT_MIN(cbExtent, cbBuf);
3079
3080	rc = vmdkFileWriteAt(pExtent->pFile, uOff, pvBuf, cbChunk, NULL);
3081	if (RT_FAILURE(rc))
3082	{
3083	RTMemFree(pvBuf);
3084	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: writing block failed for '%s'"), pImage->pszFilename);
3085	}
3086
3087	uOff += cbChunk;
3088
3089	if (pfnProgress)
3090	{
3091	rc = pfnProgress(NULL /* WARNING! pVM=NULL */,
3092	uPercentStart + uOff * uPercentSpan / cbExtent,
3093	pvUser);
3094	if (RT_FAILURE(rc))
3095	{
3096	RTMemFree(pvBuf);
3097	return rc;
3098	}
3099	}
3100	}
3101	RTMemTmpFree(pvBuf);
3102	}
3103
3104	/* Place descriptor file information (where integrated). */
3105	if (cExtents == 1 && enmType != VD_IMAGE_TYPE_FIXED)
3106	{
3107	pExtent->uDescriptorSector = 1;
3108	pExtent->cDescriptorSectors = VMDK_BYTE2SECTOR(pImage->cbDescAlloc);
3109	/* The descriptor is part of the (only) extent. */
3110	pExtent->pDescData = pImage->pDescData;
3111	pImage->pDescData = NULL;
3112	}
3113
3114	if (enmType == VD_IMAGE_TYPE_NORMAL)
3115	{
3116	uint64_t cSectorsPerGDE, cSectorsPerGD;
3117	pExtent->enmType = VMDKETYPE_HOSTED_SPARSE;
3118	pExtent->cSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(cbExtent, 65536));
3119	pExtent->cSectorsPerGrain = VMDK_BYTE2SECTOR(65536);
3120	pExtent->cGTEntries = 512;
3121	cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
3122	pExtent->cSectorsPerGDE = cSectorsPerGDE;
3123	pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
3124	cSectorsPerGD = (pExtent->cGDEntries + (512 / sizeof(uint32_t) - 1)) / (512 / sizeof(uint32_t));
3125	}
3126	else
3127	pExtent->enmType = VMDKETYPE_FLAT;
3128
3129	pExtent->enmAccess = VMDKACCESS_READWRITE;
3130	pExtent->fUncleanShutdown = true;
3131	pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbExtent);
3132	pExtent->uSectorOffset = VMDK_BYTE2SECTOR(cbOffset);
3133	pExtent->fMetaDirty = true;
3134
3135	if (enmType == VD_IMAGE_TYPE_NORMAL)
3136	{
3137	rc = vmdkCreateGrainDirectory(pExtent,
3138	RT_MAX( pExtent->uDescriptorSector
3139	+ pExtent->cDescriptorSectors,
3140	1),
3141	true);
3142	if (RT_FAILURE(rc))
3143	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
3144	}
3145
3146	if (RT_SUCCESS(rc) && pfnProgress)
3147	pfnProgress(NULL /* WARNING! pVM=NULL */,
3148	uPercentStart + i * uPercentSpan / cExtents,
3149	pvUser);
3150
3151	cbRemaining -= cbExtent;
3152	cbOffset += cbExtent;
3153	}
3154
3155	const char *pszDescType = NULL;
3156	if (enmType == VD_IMAGE_TYPE_FIXED)
3157	{
3158	pszDescType = (cExtents == 1)
3159	? "monolithicFlat" : "twoGbMaxExtentFlat";
3160	}
3161	else if (enmType == VD_IMAGE_TYPE_NORMAL)
3162	{
3163	pszDescType = (cExtents == 1)
3164	? "monolithicSparse" : "twoGbMaxExtentSparse";
3165	}
3166	else
3167	AssertMsgFailed(("invalid image type %d\n", enmType));
3168	rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
3169	pszDescType);
3170	if (RT_FAILURE(rc))
3171	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
3172	return rc;
3173	}
3174
3175	/**
3176	* Internal: The actual code for creating any VMDK variant currently in
3177	* existence on hosted environments.
3178	*/
3179	static int vmdkCreateImage(PVMDKIMAGE pImage, VDIMAGETYPE enmType,
3180	uint64_t cbSize, unsigned uImageFlags,
3181	const char *pszComment,
3182	PCPDMMEDIAGEOMETRY pPCHSGeometry,
3183	PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
3184	PFNVMPROGRESS pfnProgress, void *pvUser,
3185	unsigned uPercentStart, unsigned uPercentSpan)
3186	{
3187	int rc;
3188
3189	pImage->uImageFlags = uImageFlags;
3190
3191	/* Try to get error interface. */
3192	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
3193	if (pImage->pInterfaceError)
3194	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
3195
3196	/* Try to get async I/O interface. */
3197	pImage->pInterfaceAsyncIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ASYNCIO);
3198	if (pImage->pInterfaceAsyncIO)
3199	pImage->pInterfaceAsyncIOCallbacks = VDGetInterfaceAsyncIO(pImage->pInterfaceAsyncIO);
3200
3201	rc = vmdkCreateDescriptor(pImage, pImage->pDescData, pImage->cbDescAlloc,
3202	&pImage->Descriptor);
3203	if (RT_FAILURE(rc))
3204	{
3205	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new descriptor in '%s'"), pImage->pszFilename);
3206	goto out;
3207	}
3208
3209	if ( enmType == VD_IMAGE_TYPE_FIXED
3210	&& (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK))
3211	{
3212	/* Raw disk image (includes raw partition). */
3213	const PVBOXHDDRAW pRaw = (const PVBOXHDDRAW)pszComment;
3214	/* As the comment is misused, zap it so that no garbage comment
3215	* is set below. */
3216	pszComment = NULL;
3217	rc = vmdkCreateRawImage(pImage, pRaw, cbSize);
3218	}
3219	else if ( enmType == VD_IMAGE_TYPE_FIXED
3220	\|\| enmType == VD_IMAGE_TYPE_NORMAL)
3221	{
3222	/* Regular fixed or sparse image (monolithic or split). */
3223	rc = vmdkCreateRegularImage(pImage, enmType, cbSize, uImageFlags,
3224	pfnProgress, pvUser, uPercentStart,
3225	uPercentSpan * 95 / 100);
3226	}
3227	else
3228	{
3229	/* Unknown/invalid image type. */
3230	rc = VERR_NOT_IMPLEMENTED;
3231	}
3232
3233	if (RT_FAILURE(rc))
3234	goto out;
3235
3236	if (RT_SUCCESS(rc) && pfnProgress)
3237	pfnProgress(NULL /* WARNING! pVM=NULL */,
3238	uPercentStart + uPercentSpan * 98 / 100, pvUser);
3239
3240	pImage->enmImageType = enmType;
3241	pImage->cbSize = cbSize;
3242
3243	for (unsigned i = 0; i < pImage->cExtents; i++)
3244	{
3245	PVMDKEXTENT pExtent = &pImage->pExtents[i];
3246
3247	rc = vmdkDescExtInsert(pImage, &pImage->Descriptor, pExtent->enmAccess,
3248	pExtent->cNominalSectors, pExtent->enmType,
3249	pExtent->pszBasename, pExtent->uSectorOffset);
3250	if (RT_FAILURE(rc))
3251	{
3252	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not insert the extent list into descriptor in '%s'"), pImage->pszFilename);
3253	goto out;
3254	}
3255	}
3256	vmdkDescExtRemoveDummy(pImage, &pImage->Descriptor);
3257
3258	if ( pPCHSGeometry->cCylinders != 0
3259	&& pPCHSGeometry->cHeads != 0
3260	&& pPCHSGeometry->cSectors != 0)
3261	{
3262	rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
3263	if (RT_FAILURE(rc))
3264	goto out;
3265	}
3266	if ( pLCHSGeometry->cCylinders != 0
3267	&& pLCHSGeometry->cHeads != 0
3268	&& pLCHSGeometry->cSectors != 0)
3269	{
3270	rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
3271	if (RT_FAILURE(rc))
3272	goto out;
3273	}
3274
3275	pImage->LCHSGeometry = *pLCHSGeometry;
3276	pImage->PCHSGeometry = *pPCHSGeometry;
3277
3278	pImage->ImageUuid = *pUuid;
3279	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
3280	VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
3281	if (RT_FAILURE(rc))
3282	{
3283	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing image UUID in new descriptor in '%s'"), pImage->pszFilename);
3284	goto out;
3285	}
3286	RTUuidClear(&pImage->ParentUuid);
3287	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
3288	VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
3289	if (RT_FAILURE(rc))
3290	{
3291	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent image UUID in new descriptor in '%s'"), pImage->pszFilename);
3292	goto out;
3293	}
3294	RTUuidClear(&pImage->ModificationUuid);
3295	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
3296	VMDK_DDB_MODIFICATION_UUID,
3297	&pImage->ModificationUuid);
3298	if (RT_FAILURE(rc))
3299	{
3300	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing modification UUID in new descriptor in '%s'"), pImage->pszFilename);
3301	goto out;
3302	}
3303	RTUuidClear(&pImage->ParentModificationUuid);
3304	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
3305	VMDK_DDB_PARENT_MODIFICATION_UUID,
3306	&pImage->ParentModificationUuid);
3307	if (RT_FAILURE(rc))
3308	{
3309	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent modification UUID in new descriptor in '%s'"), pImage->pszFilename);
3310	goto out;
3311	}
3312
3313	rc = vmdkAllocateGrainTableCache(pImage);
3314	if (RT_FAILURE(rc))
3315	goto out;
3316
3317	rc = vmdkSetImageComment(pImage, pszComment);
3318	if (RT_FAILURE(rc))
3319	{
3320	rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: cannot set image comment in '%s'"), pImage->pszFilename);
3321	goto out;
3322	}
3323
3324	if (RT_SUCCESS(rc) && pfnProgress)
3325	pfnProgress(NULL /* WARNING! pVM=NULL */,
3326	uPercentStart + uPercentSpan * 99 / 100, pvUser);
3327
3328	rc = vmdkFlushImage(pImage);
3329
3330	out:
3331	if (RT_SUCCESS(rc) && pfnProgress)
3332	pfnProgress(NULL /* WARNING! pVM=NULL */,
3333	uPercentStart + uPercentSpan, pvUser);
3334
3335	if (RT_FAILURE(rc))
3336	vmdkFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
3337	return rc;
3338	}
3339
3340	/**
3341	* Internal: Update image comment.
3342	*/
3343	static int vmdkSetImageComment(PVMDKIMAGE pImage, const char *pszComment)
3344	{
3345	char *pszCommentEncoded;
3346	if (pszComment)
3347	{
3348	pszCommentEncoded = vmdkEncodeString(pszComment);
3349	if (!pszCommentEncoded)
3350	return VERR_NO_MEMORY;
3351	}
3352	else
3353	pszCommentEncoded = NULL;
3354	int rc = vmdkDescDDBSetStr(pImage, &pImage->Descriptor,
3355	"ddb.comment", pszCommentEncoded);
3356	if (pszComment)
3357	RTStrFree(pszCommentEncoded);
3358	if (RT_FAILURE(rc))
3359	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing image comment in descriptor in '%s'"), pImage->pszFilename);
3360	return VINF_SUCCESS;
3361	}
3362
3363	/**
3364	* Internal. Free all allocated space for representing an image, and optionally
3365	* delete the image from disk.
3366	*/
3367	static void vmdkFreeImage(PVMDKIMAGE pImage, bool fDelete)
3368	{
3369	Assert(pImage);
3370
3371	if (pImage->enmImageType)
3372	{
3373	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
3374	{
3375	/* Mark all extents as clean. */
3376	for (unsigned i = 0; i < pImage->cExtents; i++)
3377	{
3378	if (( pImage->pExtents[i].enmType == VMDKETYPE_HOSTED_SPARSE
3379	#ifdef VBOX_WITH_VMDK_ESX
3380	\|\| pImage->pExtents[i].enmType == VMDKETYPE_ESX_SPARSE
3381	#endif /* VBOX_WITH_VMDK_ESX */
3382	)
3383	&& pImage->pExtents[i].fUncleanShutdown)
3384	{
3385	pImage->pExtents[i].fUncleanShutdown = false;
3386	pImage->pExtents[i].fMetaDirty = true;
3387	}
3388	}
3389	}
3390	(void)vmdkFlushImage(pImage);
3391	}
3392	if (pImage->pExtents != NULL)
3393	{
3394	for (unsigned i = 0 ; i < pImage->cExtents; i++)
3395	vmdkFreeExtentData(pImage, &pImage->pExtents[i], fDelete);
3396	RTMemFree(pImage->pExtents);
3397	pImage->pExtents = NULL;
3398	}
3399	pImage->cExtents = 0;
3400	if (pImage->pFile != NULL)
3401	vmdkFileClose(pImage, &pImage->pFile, fDelete);
3402	vmdkFileCheckAllClose(pImage);
3403	if (pImage->pGTCache)
3404	{
3405	RTMemFree(pImage->pGTCache);
3406	pImage->pGTCache = NULL;
3407	}
3408	if (pImage->pDescData)
3409	{
3410	RTMemFree(pImage->pDescData);
3411	pImage->pDescData = NULL;
3412	}
3413	}
3414
3415	/**
3416	* Internal. Flush image data (and metadata) to disk.
3417	*/
3418	static int vmdkFlushImage(PVMDKIMAGE pImage)
3419	{
3420	PVMDKEXTENT pExtent;
3421	int rc = VINF_SUCCESS;
3422
3423	/* Update descriptor if changed. */
3424	if (pImage->Descriptor.fDirty)
3425	{
3426	rc = vmdkWriteDescriptor(pImage);
3427	if (RT_FAILURE(rc))
3428	goto out;
3429	}
3430
3431	for (unsigned i = 0; i < pImage->cExtents; i++)
3432	{
3433	pExtent = &pImage->pExtents[i];
3434	if (pExtent->pFile != NULL && pExtent->fMetaDirty)
3435	{
3436	switch (pExtent->enmType)
3437	{
3438	case VMDKETYPE_HOSTED_SPARSE:
3439	rc = vmdkWriteMetaSparseExtent(pExtent);
3440	if (RT_FAILURE(rc))
3441	goto out;
3442	break;
3443	#ifdef VBOX_WITH_VMDK_ESX
3444	case VMDKETYPE_ESX_SPARSE:
3445	/** @todo update the header. */
3446	break;
3447	#endif /* VBOX_WITH_VMDK_ESX */
3448	case VMDKETYPE_FLAT:
3449	/* Nothing to do. */
3450	break;
3451	case VMDKETYPE_ZERO:
3452	default:
3453	AssertMsgFailed(("extent with type %d marked as dirty\n",
3454	pExtent->enmType));
3455	break;
3456	}
3457	}
3458	switch (pExtent->enmType)
3459	{
3460	case VMDKETYPE_HOSTED_SPARSE:
3461	#ifdef VBOX_WITH_VMDK_ESX
3462	case VMDKETYPE_ESX_SPARSE:
3463	#endif /* VBOX_WITH_VMDK_ESX */
3464	case VMDKETYPE_FLAT:
3465	/** @todo implement proper path absolute check. */
3466	if ( pExtent->pFile != NULL
3467	&& !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
3468	&& !(pExtent->pszBasename[0] == RTPATH_SLASH))
3469	rc = vmdkFileFlush(pExtent->pFile);
3470	break;
3471	case VMDKETYPE_ZERO:
3472	/* No need to do anything for this extent. */
3473	break;
3474	default:
3475	AssertMsgFailed(("unknown extent type %d\n", pExtent->enmType));
3476	break;
3477	}
3478	}
3479
3480	out:
3481	return rc;
3482	}
3483
3484	/**
3485	* Internal. Find extent corresponding to the sector number in the disk.
3486	*/
3487	static int vmdkFindExtent(PVMDKIMAGE pImage, uint64_t offSector,
3488	PVMDKEXTENT ppExtent, uint64_t puSectorInExtent)
3489	{
3490	PVMDKEXTENT pExtent = NULL;
3491	int rc = VINF_SUCCESS;
3492
3493	for (unsigned i = 0; i < pImage->cExtents; i++)
3494	{
3495	if (offSector < pImage->pExtents[i].cNominalSectors)
3496	{
3497	pExtent = &pImage->pExtents[i];
3498	*puSectorInExtent = offSector + pImage->pExtents[i].uSectorOffset;
3499	break;
3500	}
3501	offSector -= pImage->pExtents[i].cNominalSectors;
3502	}
3503
3504	if (pExtent)
3505	*ppExtent = pExtent;
3506	else
3507	rc = VERR_IO_SECTOR_NOT_FOUND;
3508
3509	return rc;
3510	}
3511
3512	/**
3513	* Internal. Hash function for placing the grain table hash entries.
3514	*/
3515	static uint32_t vmdkGTCacheHash(PVMDKGTCACHE pCache, uint64_t uSector,
3516	unsigned uExtent)
3517	{
3518	/** @todo this hash function is quite simple, maybe use a better one which
3519	* scrambles the bits better. */
3520	return (uSector + uExtent) % pCache->cEntries;
3521	}
3522
3523	/**
3524	* Internal. Get sector number in the extent file from the relative sector
3525	* number in the extent.
3526	*/
3527	static int vmdkGetSector(PVMDKGTCACHE pCache, PVMDKEXTENT pExtent,
3528	uint64_t uSector, uint64_t *puExtentSector)
3529	{
3530	uint64_t uGDIndex, uGTSector, uGTBlock;
3531	uint32_t uGTHash, uGTBlockIndex;
3532	PVMDKGTCACHEENTRY pGTCacheEntry;
3533	uint32_t aGTDataTmp[VMDK_GT_CACHELINE_SIZE];
3534	int rc;
3535
3536	uGDIndex = uSector / pExtent->cSectorsPerGDE;
3537	if (uGDIndex >= pExtent->cGDEntries)
3538	return VERR_OUT_OF_RANGE;
3539	uGTSector = pExtent->pGD[uGDIndex];
3540	if (!uGTSector)
3541	{
3542	/* There is no grain table referenced by this grain directory
3543	* entry. So there is absolutely no data in this area. */
3544	*puExtentSector = 0;
3545	return VINF_SUCCESS;
3546	}
3547
3548	uGTBlock = uSector / (pExtent->cSectorsPerGrain * VMDK_GT_CACHELINE_SIZE);
3549	uGTHash = vmdkGTCacheHash(pCache, uGTBlock, pExtent->uExtent);
3550	pGTCacheEntry = &pCache->aGTCache[uGTHash];
3551	if ( pGTCacheEntry->uExtent != pExtent->uExtent
3552	\|\| pGTCacheEntry->uGTBlock != uGTBlock)
3553	{
3554	/* Cache miss, fetch data from disk. */
3555	rc = vmdkFileReadAt(pExtent->pFile,
3556	VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
3557	aGTDataTmp, sizeof(aGTDataTmp), NULL);
3558	if (RT_FAILURE(rc))
3559	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot read grain table entry in '%s'"), pExtent->pszFullname);
3560	pGTCacheEntry->uExtent = pExtent->uExtent;
3561	pGTCacheEntry->uGTBlock = uGTBlock;
3562	for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
3563	pGTCacheEntry->aGTData[i] = RT_LE2H_U32(aGTDataTmp[i]);
3564	}
3565	uGTBlockIndex = (uSector / pExtent->cSectorsPerGrain) % VMDK_GT_CACHELINE_SIZE;
3566	uint64_t uGrainSector = pGTCacheEntry->aGTData[uGTBlockIndex];
3567	if (uGrainSector)
3568	*puExtentSector = uGrainSector + uSector % pExtent->cSectorsPerGrain;
3569	else
3570	*puExtentSector = 0;
3571	return VINF_SUCCESS;
3572	}
3573
3574	/**
3575	* Internal. Allocates a new grain table (if necessary), writes the grain
3576	* and updates the grain table. The cache is also updated by this operation.
3577	* This is separate from vmdkGetSector, because that should be as fast as
3578	* possible. Most code from vmdkGetSector also appears here.
3579	*/
3580	static int vmdkAllocGrain(PVMDKGTCACHE pCache, PVMDKEXTENT pExtent,
3581	uint64_t uSector, const void *pvBuf,
3582	uint64_t cbWrite)
3583	{
3584	uint64_t uGDIndex, uGTSector, uRGTSector, uGTBlock;
3585	uint64_t cbExtentSize;
3586	uint32_t uGTHash, uGTBlockIndex;
3587	PVMDKGTCACHEENTRY pGTCacheEntry;
3588	uint32_t aGTDataTmp[VMDK_GT_CACHELINE_SIZE];
3589	int rc;
3590
3591	uGDIndex = uSector / pExtent->cSectorsPerGDE;
3592	if (uGDIndex >= pExtent->cGDEntries)
3593	return VERR_OUT_OF_RANGE;
3594	uGTSector = pExtent->pGD[uGDIndex];
3595	if (pExtent->pRGD)
3596	uRGTSector = pExtent->pRGD[uGDIndex];
3597	else
3598	uRGTSector = 0; /*< avoid compiler warning /
3599	if (!uGTSector)
3600	{
3601	/* There is no grain table referenced by this grain directory
3602	* entry. So there is absolutely no data in this area. Allocate
3603	* a new grain table and put the reference to it in the GDs. */
3604	rc = vmdkFileGetSize(pExtent->pFile, &cbExtentSize);
3605	if (RT_FAILURE(rc))
3606	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error getting size in '%s'"), pExtent->pszFullname);
3607	Assert(!(cbExtentSize % 512));
3608	cbExtentSize = RT_ALIGN_64(cbExtentSize, 512);
3609	uGTSector = VMDK_BYTE2SECTOR(cbExtentSize);
3610	/* Normally the grain table is preallocated for hosted sparse extents
3611	* that support more than 32 bit sector numbers. So this shouldn't
3612	* ever happen on a valid extent. */
3613	if (uGTSector > UINT32_MAX)
3614	return VERR_VDI_INVALID_HEADER;
3615	/* Write grain table by writing the required number of grain table
3616	* cache chunks. Avoids dynamic memory allocation, but is a bit
3617	* slower. But as this is a pretty infrequently occurring case it
3618	* should be acceptable. */
3619	memset(aGTDataTmp, '\0', sizeof(aGTDataTmp));
3620	for (unsigned i = 0;
3621	i < pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE;
3622	i++)
3623	{
3624	rc = vmdkFileWriteAt(pExtent->pFile,
3625	VMDK_SECTOR2BYTE(uGTSector) + i * sizeof(aGTDataTmp),
3626	aGTDataTmp, sizeof(aGTDataTmp), NULL);
3627	if (RT_FAILURE(rc))
3628	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write grain table allocation in '%s'"), pExtent->pszFullname);
3629	}
3630	if (pExtent->pRGD)
3631	{
3632	AssertReturn(!uRGTSector, VERR_VDI_INVALID_HEADER);
3633	rc = vmdkFileGetSize(pExtent->pFile, &cbExtentSize);
3634	if (RT_FAILURE(rc))
3635	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error getting size in '%s'"), pExtent->pszFullname);
3636	Assert(!(cbExtentSize % 512));
3637	uRGTSector = VMDK_BYTE2SECTOR(cbExtentSize);
3638	/* Normally the redundant grain table is preallocated for hosted
3639	* sparse extents that support more than 32 bit sector numbers. So
3640	* this shouldn't ever happen on a valid extent. */
3641	if (uRGTSector > UINT32_MAX)
3642	return VERR_VDI_INVALID_HEADER;
3643	/* Write backup grain table by writing the required number of grain
3644	* table cache chunks. Avoids dynamic memory allocation, but is a
3645	* bit slower. But as this is a pretty infrequently occurring case
3646	* it should be acceptable. */
3647	for (unsigned i = 0;
3648	i < pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE;
3649	i++)
3650	{
3651	rc = vmdkFileWriteAt(pExtent->pFile,
3652	VMDK_SECTOR2BYTE(uRGTSector) + i * sizeof(aGTDataTmp),
3653	aGTDataTmp, sizeof(aGTDataTmp), NULL);
3654	if (RT_FAILURE(rc))
3655	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write backup grain table allocation in '%s'"), pExtent->pszFullname);
3656	}
3657	}
3658
3659	/* Update the grain directory on disk (doing it before writing the
3660	* grain table will result in a garbled extent if the operation is
3661	* aborted for some reason. Otherwise the worst that can happen is
3662	* some unused sectors in the extent. */
3663	uint32_t uGTSectorLE = RT_H2LE_U64(uGTSector);
3664	rc = vmdkFileWriteAt(pExtent->pFile,
3665	VMDK_SECTOR2BYTE(pExtent->uSectorGD) + uGDIndex * sizeof(uGTSectorLE),
3666	&uGTSectorLE, sizeof(uGTSectorLE), NULL);
3667	if (RT_FAILURE(rc))
3668	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write grain directory entry in '%s'"), pExtent->pszFullname);
3669	if (pExtent->pRGD)
3670	{
3671	uint32_t uRGTSectorLE = RT_H2LE_U64(uRGTSector);
3672	rc = vmdkFileWriteAt(pExtent->pFile,
3673	VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + uGDIndex * sizeof(uRGTSectorLE),
3674	&uRGTSectorLE, sizeof(uRGTSectorLE), NULL);
3675	if (RT_FAILURE(rc))
3676	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write backup grain directory entry in '%s'"), pExtent->pszFullname);
3677	}
3678
3679	/* As the final step update the in-memory copy of the GDs. */
3680	pExtent->pGD[uGDIndex] = uGTSector;
3681	if (pExtent->pRGD)
3682	pExtent->pRGD[uGDIndex] = uRGTSector;
3683	}
3684
3685	rc = vmdkFileGetSize(pExtent->pFile, &cbExtentSize);
3686	if (RT_FAILURE(rc))
3687	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: error getting size in '%s'"), pExtent->pszFullname);
3688	Assert(!(cbExtentSize % 512));
3689
3690	/* Write the data. */
3691	rc = vmdkFileWriteAt(pExtent->pFile, cbExtentSize, pvBuf, cbWrite, NULL);
3692	if (RT_FAILURE(rc))
3693	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write allocated data block in '%s'"), pExtent->pszFullname);
3694
3695	/* Update the grain table (and the cache). */
3696	uGTBlock = uSector / (pExtent->cSectorsPerGrain * VMDK_GT_CACHELINE_SIZE);
3697	uGTHash = vmdkGTCacheHash(pCache, uGTBlock, pExtent->uExtent);
3698	pGTCacheEntry = &pCache->aGTCache[uGTHash];
3699	if ( pGTCacheEntry->uExtent != pExtent->uExtent
3700	\|\| pGTCacheEntry->uGTBlock != uGTBlock)
3701	{
3702	/* Cache miss, fetch data from disk. */
3703	rc = vmdkFileReadAt(pExtent->pFile,
3704	VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
3705	aGTDataTmp, sizeof(aGTDataTmp), NULL);
3706	if (RT_FAILURE(rc))
3707	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot read allocated grain table entry in '%s'"), pExtent->pszFullname);
3708	pGTCacheEntry->uExtent = pExtent->uExtent;
3709	pGTCacheEntry->uGTBlock = uGTBlock;
3710	for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
3711	pGTCacheEntry->aGTData[i] = RT_LE2H_U32(aGTDataTmp[i]);
3712	}
3713	else
3714	{
3715	/* Cache hit. Convert grain table block back to disk format, otherwise
3716	* the code below will write garbage for all but the updated entry. */
3717	for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
3718	aGTDataTmp[i] = RT_H2LE_U32(pGTCacheEntry->aGTData[i]);
3719	}
3720	uGTBlockIndex = (uSector / pExtent->cSectorsPerGrain) % VMDK_GT_CACHELINE_SIZE;
3721	aGTDataTmp[uGTBlockIndex] = RT_H2LE_U32(VMDK_BYTE2SECTOR(cbExtentSize));
3722	pGTCacheEntry->aGTData[uGTBlockIndex] = VMDK_BYTE2SECTOR(cbExtentSize);
3723	/* Update grain table on disk. */
3724	rc = vmdkFileWriteAt(pExtent->pFile,
3725	VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
3726	aGTDataTmp, sizeof(aGTDataTmp), NULL);
3727	if (RT_FAILURE(rc))
3728	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write updated grain table in '%s'"), pExtent->pszFullname);
3729	if (pExtent->pRGD)
3730	{
3731	/* Update backup grain table on disk. */
3732	rc = vmdkFileWriteAt(pExtent->pFile,
3733	VMDK_SECTOR2BYTE(uRGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
3734	aGTDataTmp, sizeof(aGTDataTmp), NULL);
3735	if (RT_FAILURE(rc))
3736	return vmdkError(pExtent->pImage, rc, RT_SRC_POS, N_("VMDK: cannot write updated backup grain table in '%s'"), pExtent->pszFullname);
3737	}
3738	#ifdef VBOX_WITH_VMDK_ESX
3739	if (RT_SUCCESS(rc) && pExtent->enmType == VMDKETYPE_ESX_SPARSE)
3740	{
3741	pExtent->uFreeSector = uGTSector + VMDK_BYTE2SECTOR(cbWrite);
3742	pExtent->fMetaDirty = true;
3743	}
3744	#endif /* VBOX_WITH_VMDK_ESX */
3745	return rc;
3746	}
3747
3748
3749	/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
3750	static int vmdkCheckIfValid(const char *pszFilename)
3751	{
3752	LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
3753	int rc = VINF_SUCCESS;
3754	PVMDKIMAGE pImage;
3755
3756	if ( !pszFilename
3757	\|\| !*pszFilename
3758	\|\| strchr(pszFilename, '"'))
3759	{
3760	rc = VERR_INVALID_PARAMETER;
3761	goto out;
3762	}
3763
3764	pImage = (PVMDKIMAGE)RTMemAllocZ(sizeof(VMDKIMAGE));
3765	if (!pImage)
3766	{
3767	rc = VERR_NO_MEMORY;
3768	goto out;
3769	}
3770	pImage->pszFilename = pszFilename;
3771	pImage->pFile = NULL;
3772	pImage->pExtents = NULL;
3773	pImage->pFiles = NULL;
3774	pImage->pGTCache = NULL;
3775	pImage->pDescData = NULL;
3776	pImage->pVDIfsDisk = NULL;
3777	/** @todo speed up this test open (VD_OPEN_FLAGS_INFO) by skipping as
3778	* much as possible in vmdkOpenImage. */
3779	rc = vmdkOpenImage(pImage, VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_READONLY);
3780	vmdkFreeImage(pImage, false);
3781	RTMemFree(pImage);
3782
3783	out:
3784	LogFlowFunc(("returns %Rrc\n", rc));
3785	return rc;
3786	}
3787
3788	/** @copydoc VBOXHDDBACKEND::pfnOpen */
3789	static int vmdkOpen(const char *pszFilename, unsigned uOpenFlags,
3790	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
3791	void **ppBackendData)
3792	{
3793	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
3794	int rc;
3795	PVMDKIMAGE pImage;
3796
3797	/* Check open flags. All valid flags are supported. */
3798	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
3799	{
3800	rc = VERR_INVALID_PARAMETER;
3801	goto out;
3802	}
3803
3804	/* Check remaining arguments. */
3805	if ( !VALID_PTR(pszFilename)
3806	\|\| !*pszFilename
3807	\|\| strchr(pszFilename, '"'))
3808	{
3809	rc = VERR_INVALID_PARAMETER;
3810	goto out;
3811	}
3812
3813
3814	pImage = (PVMDKIMAGE)RTMemAllocZ(sizeof(VMDKIMAGE));
3815	if (!pImage)
3816	{
3817	rc = VERR_NO_MEMORY;
3818	goto out;
3819	}
3820	pImage->pszFilename = pszFilename;
3821	pImage->pFile = NULL;
3822	pImage->pExtents = NULL;
3823	pImage->pFiles = NULL;
3824	pImage->pGTCache = NULL;
3825	pImage->pDescData = NULL;
3826	pImage->pVDIfsDisk = pVDIfsDisk;
3827
3828	rc = vmdkOpenImage(pImage, uOpenFlags);
3829	if (RT_SUCCESS(rc))
3830	*ppBackendData = pImage;
3831
3832	out:
3833	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
3834	return rc;
3835	}
3836
3837	/** @copydoc VBOXHDDBACKEND::pfnCreate */
3838	static int vmdkCreate(const char *pszFilename, VDIMAGETYPE enmType,
3839	uint64_t cbSize, unsigned uImageFlags,
3840	const char *pszComment,
3841	PCPDMMEDIAGEOMETRY pPCHSGeometry,
3842	PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
3843	unsigned uOpenFlags, unsigned uPercentStart,
3844	unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
3845	PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation,
3846	void **ppBackendData)
3847	{
3848	LogFlowFunc(("pszFilename=\"%s\" enmType=%d cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p ppBackendData=%#p", pszFilename, enmType, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
3849	int rc;
3850	PVMDKIMAGE pImage;
3851
3852	PFNVMPROGRESS pfnProgress = NULL;
3853	void *pvUser = NULL;
3854	PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
3855	VDINTERFACETYPE_PROGRESS);
3856	PVDINTERFACEPROGRESS pCbProgress = NULL;
3857	if (pIfProgress)
3858	{
3859	pCbProgress = VDGetInterfaceProgress(pIfProgress);
3860	pfnProgress = pCbProgress->pfnProgress;
3861	pvUser = pIfProgress->pvUser;
3862	}
3863
3864	/* Check open flags. All valid flags are supported. */
3865	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
3866	{
3867	rc = VERR_INVALID_PARAMETER;
3868	goto out;
3869	}
3870
3871	/* @todo A quick hack to support differencing images in VMDK. */
3872	if (enmType == VD_IMAGE_TYPE_DIFF)
3873	enmType = VD_IMAGE_TYPE_NORMAL;
3874
3875	/* Check remaining arguments. */
3876	if ( !VALID_PTR(pszFilename)
3877	\|\| !*pszFilename
3878	\|\| strchr(pszFilename, '"')
3879	\|\| (enmType != VD_IMAGE_TYPE_NORMAL && enmType != VD_IMAGE_TYPE_FIXED)
3880	\|\| !VALID_PTR(pPCHSGeometry)
3881	\|\| !VALID_PTR(pLCHSGeometry))
3882	{
3883	rc = VERR_INVALID_PARAMETER;
3884	goto out;
3885	}
3886
3887	pImage = (PVMDKIMAGE)RTMemAllocZ(sizeof(VMDKIMAGE));
3888	if (!pImage)
3889	{
3890	rc = VERR_NO_MEMORY;
3891	goto out;
3892	}
3893	pImage->pszFilename = pszFilename;
3894	pImage->pFile = NULL;
3895	pImage->pExtents = NULL;
3896	pImage->pFiles = NULL;
3897	pImage->pGTCache = NULL;
3898	pImage->pDescData = NULL;
3899	pImage->pVDIfsDisk = NULL;
3900	pImage->cbDescAlloc = VMDK_SECTOR2BYTE(20);
3901	pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
3902	if (!pImage->pDescData)
3903	{
3904	rc = VERR_NO_MEMORY;
3905	goto out;
3906	}
3907
3908	rc = vmdkCreateImage(pImage, enmType, cbSize, uImageFlags, pszComment,
3909	pPCHSGeometry, pLCHSGeometry, pUuid,
3910	pfnProgress, pvUser, uPercentStart, uPercentSpan);
3911	if (RT_SUCCESS(rc))
3912	{
3913	/* So far the image is opened in read/write mode. Make sure the
3914	* image is opened in read-only mode if the caller requested that. */
3915	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
3916	{
3917	vmdkFreeImage(pImage, false);
3918	rc = vmdkOpenImage(pImage, uOpenFlags);
3919	if (RT_FAILURE(rc))
3920	goto out;
3921	}
3922	*ppBackendData = pImage;
3923	}
3924	else
3925	{
3926	RTMemFree(pImage->pDescData);
3927	RTMemFree(pImage);
3928	}
3929
3930	out:
3931	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
3932	return rc;
3933	}
3934
3935	/**
3936	* Replaces a fragment of a string with the specified string.
3937	*
3938	* @returns Pointer to the allocated UTF-8 string.
3939	* @param pszWhere UTF-8 string to search in.
3940	* @param pszWhat UTF-8 string to search for.
3941	* @param pszByWhat UTF-8 string to replace the found string with.
3942	*/
3943	static char * vmdkStrReplace(const char pszWhere, const char pszWhat, const char *pszByWhat)
3944	{
3945	Assert(VALID_PTR(pszWhere));
3946	Assert(VALID_PTR(pszWhat));
3947	Assert(VALID_PTR(pszByWhat));
3948	const char *pszFoundStr = strstr(pszWhere, pszWhat);
3949	if (!pszFoundStr)
3950	return NULL;
3951	size_t cFinal = strlen(pszWhere) + 1 + strlen(pszByWhat) - strlen(pszWhat);
3952	char pszNewStr = (char )RTMemAlloc(cFinal);
3953	if (pszNewStr)
3954	{
3955	char *pszTmp = pszNewStr;
3956	memcpy(pszTmp, pszWhere, pszFoundStr - pszWhere);
3957	pszTmp += pszFoundStr - pszWhere;
3958	memcpy(pszTmp, pszByWhat, strlen(pszByWhat));
3959	pszTmp += strlen(pszByWhat);
3960	strcpy(pszTmp, pszFoundStr + strlen(pszWhat));
3961	}
3962	return pszNewStr;
3963	}
3964
3965	/** @copydoc VBOXHDDBACKEND::pfnRename */
3966	static int vmdkRename(void pBackendData, const char pszFilename)
3967	{
3968	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
3969
3970	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
3971	int rc = VINF_SUCCESS;
3972	char **apszOldName = NULL;
3973	char **apszNewName = NULL;
3974	char **apszNewLines = NULL;
3975	char *pszOldDescName = NULL;
3976	bool fImageFreed = false;
3977	bool fEmbeddedDesc = false;
3978	unsigned cExtents = pImage->cExtents;
3979	char *pszNewBaseName = NULL;
3980	char *pszOldBaseName = NULL;
3981	char *pszNewFullName = NULL;
3982	char *pszOldFullName = NULL;
3983	const char *pszOldImageName;
3984	unsigned i, line;
3985	VMDKDESCRIPTOR DescriptorCopy;
3986	VMDKEXTENT ExtentCopy;
3987
3988	memset(&DescriptorCopy, 0, sizeof(DescriptorCopy));
3989
3990	/* Check arguments. */
3991	if ( !pImage
3992	\|\| (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
3993	\|\| !VALID_PTR(pszFilename)
3994	\|\| !*pszFilename)
3995	{
3996	rc = VERR_INVALID_PARAMETER;
3997	goto out;
3998	}
3999
4000	/*
4001	* Allocate an array to store both old and new names of renamed files
4002	* in case we have to roll back the changes. Arrays are initialized
4003	* with zeros. We actually save stuff when and if we change it.
4004	*/
4005	apszOldName = (char *)RTMemTmpAllocZ((cExtents + 1) sizeof(char*));
4006	apszNewName = (char *)RTMemTmpAllocZ((cExtents + 1) sizeof(char*));
4007	apszNewLines = (char *)RTMemTmpAllocZ((cExtents) sizeof(char*));
4008	if (!apszOldName \|\| !apszNewName \|\| !apszNewLines)
4009	{
4010	rc = VERR_NO_MEMORY;
4011	goto out;
4012	}
4013
4014	/* Save the descriptor size and position. */
4015	if (pImage->pDescData)
4016	{
4017	/* Separate descriptor file. */
4018	fEmbeddedDesc = false;
4019	}
4020	else
4021	{
4022	/* Embedded descriptor file. */
4023	ExtentCopy = pImage->pExtents[0];
4024	fEmbeddedDesc = true;
4025	}
4026	/* Save the descriptor content. */
4027	DescriptorCopy.cLines = pImage->Descriptor.cLines;
4028	for (i = 0; i < DescriptorCopy.cLines; i++)
4029	{
4030	DescriptorCopy.aLines[i] = RTStrDup(pImage->Descriptor.aLines[i]);
4031	if (!DescriptorCopy.aLines[i])
4032	{
4033	rc = VERR_NO_MEMORY;
4034	goto out;
4035	}
4036	}
4037
4038	/* Prepare both old and new base names used for string replacement. */
4039	pszNewBaseName = RTStrDup(RTPathFilename(pszFilename));
4040	RTPathStripExt(pszNewBaseName);
4041	pszOldBaseName = RTStrDup(RTPathFilename(pImage->pszFilename));
4042	RTPathStripExt(pszOldBaseName);
4043	/* Prepare both old and new full names used for string replacement. */
4044	pszNewFullName = RTStrDup(pszFilename);
4045	RTPathStripExt(pszNewFullName);
4046	pszOldFullName = RTStrDup(pImage->pszFilename);
4047	RTPathStripExt(pszOldFullName);
4048
4049	/* --- Up to this point we have not done any damage yet. --- */
4050
4051	/* Save the old name for easy access to the old descriptor file. */
4052	pszOldDescName = RTStrDup(pImage->pszFilename);
4053	/* Save old image name. */
4054	pszOldImageName = pImage->pszFilename;
4055
4056	/* Update the descriptor with modified extent names. */
4057	for (i = 0, line = pImage->Descriptor.uFirstExtent;
4058	i < cExtents;
4059	i++, line = pImage->Descriptor.aNextLines[line])
4060	{
4061	/* Assume that vmdkStrReplace will fail. */
4062	rc = VERR_NO_MEMORY;
4063	/* Update the descriptor. */
4064	apszNewLines[i] = vmdkStrReplace(pImage->Descriptor.aLines[line],
4065	pszOldBaseName, pszNewBaseName);
4066	if (!apszNewLines[i])
4067	goto rollback;
4068	pImage->Descriptor.aLines[line] = apszNewLines[i];
4069	}
4070	/* Make sure the descriptor gets written back. */
4071	pImage->Descriptor.fDirty = true;
4072	/* Flush the descriptor now, in case it is embedded. */
4073	vmdkFlushImage(pImage);
4074
4075	/* Close and rename/move extents. */
4076	for (i = 0; i < cExtents; i++)
4077	{
4078	PVMDKEXTENT pExtent = &pImage->pExtents[i];
4079	/* Compose new name for the extent. */
4080	apszNewName[i] = vmdkStrReplace(pExtent->pszFullname,
4081	pszOldFullName, pszNewFullName);
4082	if (!apszNewName[i])
4083	goto rollback;
4084	/* Close the extent file. */
4085	vmdkFileClose(pImage, &pExtent->pFile, false);
4086	/* Rename the extent file. */
4087	rc = RTFileMove(pExtent->pszFullname, apszNewName[i], 0);
4088	if (RT_FAILURE(rc))
4089	goto rollback;
4090	/* Remember the old name. */
4091	apszOldName[i] = RTStrDup(pExtent->pszFullname);
4092	}
4093	/* Release all old stuff. */
4094	vmdkFreeImage(pImage, false);
4095
4096	fImageFreed = true;
4097
4098	/* Last elements of new/old name arrays are intended for
4099	* storing descriptor's names.
4100	*/
4101	apszNewName[cExtents] = RTStrDup(pszFilename);
4102	/* Rename the descriptor file if it's separate. */
4103	if (!fEmbeddedDesc)
4104	{
4105	rc = RTFileMove(pImage->pszFilename, apszNewName[cExtents], 0);
4106	if (RT_FAILURE(rc))
4107	goto rollback;
4108	/* Save old name only if we may need to change it back. */
4109	apszOldName[cExtents] = RTStrDup(pszFilename);
4110	}
4111
4112	/* Update pImage with the new information. */
4113	pImage->pszFilename = pszFilename;
4114
4115	/* Open the new image. */
4116	rc = vmdkOpenImage(pImage, pImage->uOpenFlags);
4117	if (RT_SUCCESS(rc))
4118	goto out;
4119
4120	rollback:
4121	/* Roll back all changes in case of failure. */
4122	if (RT_FAILURE(rc))
4123	{
4124	int rrc;
4125	if (!fImageFreed)
4126	{
4127	/*
4128	* Some extents may have been closed, close the rest. We will
4129	* re-open the whole thing later.
4130	*/
4131	vmdkFreeImage(pImage, false);
4132	}
4133	/* Rename files back. */
4134	for (i = 0; i <= cExtents; i++)
4135	{
4136	if (apszOldName[i])
4137	{
4138	rrc = RTFileMove(apszNewName[i], apszOldName[i], 0);
4139	AssertRC(rrc);
4140	}
4141	}
4142	/* Restore the old descriptor. */
4143	PVMDKFILE pFile;
4144	rrc = vmdkFileOpen(pImage, &pFile, pszOldDescName,
4145	RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, false);
4146	AssertRC(rrc);
4147	if (fEmbeddedDesc)
4148	{
4149	ExtentCopy.pFile = pFile;
4150	pImage->pExtents = &ExtentCopy;
4151	}
4152	else
4153	{
4154	/* Shouldn't be null for separate descriptor.
4155	* There will be no access to the actual content.
4156	*/
4157	pImage->pDescData = pszOldDescName;
4158	pImage->pFile = pFile;
4159	}
4160	pImage->Descriptor = DescriptorCopy;
4161	vmdkWriteDescriptor(pImage);
4162	vmdkFileClose(pImage, &pFile, false);
4163	/* Get rid of the stuff we implanted. */
4164	pImage->pExtents = NULL;
4165	pImage->pFile = NULL;
4166	pImage->pDescData = NULL;
4167	/* Re-open the image back. */
4168	pImage->pszFilename = pszOldImageName;
4169	rrc = vmdkOpenImage(pImage, pImage->uOpenFlags);
4170	AssertRC(rrc);
4171	}
4172
4173	out:
4174	for (i = 0; i < DescriptorCopy.cLines; i++)
4175	if (DescriptorCopy.aLines[i])
4176	RTStrFree(DescriptorCopy.aLines[i]);
4177	if (apszOldName)
4178	{
4179	for (i = 0; i <= cExtents; i++)
4180	if (apszOldName[i])
4181	RTStrFree(apszOldName[i]);
4182	RTMemTmpFree(apszOldName);
4183	}
4184	if (apszNewName)
4185	{
4186	for (i = 0; i <= cExtents; i++)
4187	if (apszNewName[i])
4188	RTStrFree(apszNewName[i]);
4189	RTMemTmpFree(apszNewName);
4190	}
4191	if (apszNewLines)
4192	{
4193	for (i = 0; i < cExtents; i++)
4194	if (apszNewLines[i])
4195	RTStrFree(apszNewLines[i]);
4196	RTMemTmpFree(apszNewLines);
4197	}
4198	if (pszOldDescName)
4199	RTStrFree(pszOldDescName);
4200	if (pszOldBaseName)
4201	RTStrFree(pszOldBaseName);
4202	if (pszNewBaseName)
4203	RTStrFree(pszNewBaseName);
4204	if (pszOldFullName)
4205	RTStrFree(pszOldFullName);
4206	if (pszNewFullName)
4207	RTStrFree(pszNewFullName);
4208	LogFlowFunc(("returns %Rrc\n", rc));
4209	return rc;
4210	}
4211
4212	/** @copydoc VBOXHDDBACKEND::pfnClose */
4213	static int vmdkClose(void *pBackendData, bool fDelete)
4214	{
4215	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
4216	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4217	int rc = VINF_SUCCESS;
4218
4219	/* Freeing a never allocated image (e.g. because the open failed) is
4220	* not signalled as an error. After all nothing bad happens. */
4221	if (pImage)
4222	{
4223	vmdkFreeImage(pImage, fDelete);
4224	RTMemFree(pImage);
4225	}
4226
4227	LogFlowFunc(("returns %Rrc\n", rc));
4228	return rc;
4229	}
4230
4231	/** @copydoc VBOXHDDBACKEND::pfnRead */
4232	static int vmdkRead(void pBackendData, uint64_t uOffset, void pvBuf,
4233	size_t cbToRead, size_t *pcbActuallyRead)
4234	{
4235	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
4236	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4237	PVMDKEXTENT pExtent;
4238	uint64_t uSectorExtentRel;
4239	uint64_t uSectorExtentAbs;
4240	int rc;
4241
4242	Assert(pImage);
4243	Assert(uOffset % 512 == 0);
4244	Assert(cbToRead % 512 == 0);
4245
4246	if ( uOffset + cbToRead > pImage->cbSize
4247	\|\| cbToRead == 0)
4248	{
4249	rc = VERR_INVALID_PARAMETER;
4250	goto out;
4251	}
4252
4253	rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
4254	&pExtent, &uSectorExtentRel);
4255	if (RT_FAILURE(rc))
4256	goto out;
4257
4258	/* Check access permissions as defined in the extent descriptor. */
4259	if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
4260	{
4261	rc = VERR_VDI_INVALID_STATE;
4262	goto out;
4263	}
4264
4265	/* Clip read range to remain in this extent. */
4266	cbToRead = RT_MIN(cbToRead, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
4267
4268	/* Handle the read according to the current extent type. */
4269	switch (pExtent->enmType)
4270	{
4271	case VMDKETYPE_HOSTED_SPARSE:
4272	#ifdef VBOX_WITH_VMDK_ESX
4273	case VMDKETYPE_ESX_SPARSE:
4274	#endif /* VBOX_WITH_VMDK_ESX */
4275	rc = vmdkGetSector(pImage->pGTCache, pExtent, uSectorExtentRel,
4276	&uSectorExtentAbs);
4277	if (RT_FAILURE(rc))
4278	goto out;
4279	/* Clip read range to at most the rest of the grain. */
4280	cbToRead = RT_MIN(cbToRead, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSectorExtentRel % pExtent->cSectorsPerGrain));
4281	Assert(!(cbToRead % 512));
4282	if (uSectorExtentAbs == 0)
4283	rc = VERR_VDI_BLOCK_FREE;
4284	else
4285	rc = vmdkFileReadAt(pExtent->pFile,
4286	VMDK_SECTOR2BYTE(uSectorExtentAbs),
4287	pvBuf, cbToRead, NULL);
4288	break;
4289	case VMDKETYPE_FLAT:
4290	rc = vmdkFileReadAt(pExtent->pFile,
4291	VMDK_SECTOR2BYTE(uSectorExtentRel),
4292	pvBuf, cbToRead, NULL);
4293	break;
4294	case VMDKETYPE_ZERO:
4295	memset(pvBuf, '\0', cbToRead);
4296	break;
4297	}
4298	*pcbActuallyRead = cbToRead;
4299
4300	out:
4301	LogFlowFunc(("returns %Rrc\n", rc));
4302	return rc;
4303	}
4304
4305	/** @copydoc VBOXHDDBACKEND::pfnWrite */
4306	static int vmdkWrite(void pBackendData, uint64_t uOffset, const void pvBuf,
4307	size_t cbToWrite, size_t *pcbWriteProcess,
4308	size_t pcbPreRead, size_t pcbPostRead, unsigned fWrite)
4309	{
4310	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
4311	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4312	PVMDKEXTENT pExtent;
4313	uint64_t uSectorExtentRel;
4314	uint64_t uSectorExtentAbs;
4315	int rc;
4316
4317	Assert(pImage);
4318	Assert(uOffset % 512 == 0);
4319	Assert(cbToWrite % 512 == 0);
4320
4321	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
4322	{
4323	rc = VERR_VDI_IMAGE_READ_ONLY;
4324	goto out;
4325	}
4326
4327	if (cbToWrite == 0)
4328	{
4329	rc = VERR_INVALID_PARAMETER;
4330	goto out;
4331	}
4332
4333	/* No size check here, will do that later when the extent is located.
4334	* There are sparse images out there which according to the spec are
4335	* invalid, because the total size is not a multiple of the grain size.
4336	* Also for sparse images which are stitched together in odd ways (not at
4337	* grain boundaries, and with the nominal size not being a multiple of the
4338	* grain size), this would prevent writing to the last grain. */
4339
4340	rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
4341	&pExtent, &uSectorExtentRel);
4342	if (RT_FAILURE(rc))
4343	goto out;
4344
4345	/* Check access permissions as defined in the extent descriptor. */
4346	if (pExtent->enmAccess != VMDKACCESS_READWRITE)
4347	{
4348	rc = VERR_VDI_INVALID_STATE;
4349	goto out;
4350	}
4351
4352	/* Handle the write according to the current extent type. */
4353	switch (pExtent->enmType)
4354	{
4355	case VMDKETYPE_HOSTED_SPARSE:
4356	#ifdef VBOX_WITH_VMDK_ESX
4357	case VMDKETYPE_ESX_SPARSE:
4358	#endif /* VBOX_WITH_VMDK_ESX */
4359	rc = vmdkGetSector(pImage->pGTCache, pExtent, uSectorExtentRel,
4360	&uSectorExtentAbs);
4361	if (RT_FAILURE(rc))
4362	goto out;
4363	/* Clip write range to at most the rest of the grain. */
4364	cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSectorExtentRel % pExtent->cSectorsPerGrain));
4365	if (uSectorExtentAbs == 0)
4366	{
4367	if (cbToWrite == VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
4368	{
4369	/* Full block write to a previously unallocated block.
4370	* Check if the caller wants to avoid this. */
4371	if (!(fWrite & VD_WRITE_NO_ALLOC))
4372	{
4373	/* Allocate GT and find out where to store the grain. */
4374	rc = vmdkAllocGrain(pImage->pGTCache, pExtent,
4375	uSectorExtentRel, pvBuf, cbToWrite);
4376	}
4377	else
4378	rc = VERR_VDI_BLOCK_FREE;
4379	*pcbPreRead = 0;
4380	*pcbPostRead = 0;
4381	}
4382	else
4383	{
4384	/* Clip write range to remain in this extent. */
4385	cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
4386	*pcbPreRead = VMDK_SECTOR2BYTE(uSectorExtentRel % pExtent->cSectorsPerGrain);
4387	pcbPostRead = VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbToWrite - pcbPreRead;
4388	rc = VERR_VDI_BLOCK_FREE;
4389	}
4390	}
4391	else
4392	rc = vmdkFileWriteAt(pExtent->pFile,
4393	VMDK_SECTOR2BYTE(uSectorExtentAbs),
4394	pvBuf, cbToWrite, NULL);
4395	break;
4396	case VMDKETYPE_FLAT:
4397	/* Clip write range to remain in this extent. */
4398	cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
4399	rc = vmdkFileWriteAt(pExtent->pFile,
4400	VMDK_SECTOR2BYTE(uSectorExtentRel),
4401	pvBuf, cbToWrite, NULL);
4402	break;
4403	case VMDKETYPE_ZERO:
4404	/* Clip write range to remain in this extent. */
4405	cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
4406	break;
4407	}
4408	if (pcbWriteProcess)
4409	*pcbWriteProcess = cbToWrite;
4410
4411	out:
4412	LogFlowFunc(("returns %Rrc\n", rc));
4413	return rc;
4414	}
4415
4416	/** @copydoc VBOXHDDBACKEND::pfnFlush */
4417	static int vmdkFlush(void *pBackendData)
4418	{
4419	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
4420	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4421	int rc;
4422
4423	Assert(pImage);
4424
4425	rc = vmdkFlushImage(pImage);
4426	LogFlowFunc(("returns %Rrc\n", rc));
4427	return rc;
4428	}
4429
4430	/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
4431	static unsigned vmdkGetVersion(void *pBackendData)
4432	{
4433	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
4434	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4435
4436	Assert(pImage);
4437
4438	if (pImage)
4439	return VMDK_IMAGE_VERSION;
4440	else
4441	return 0;
4442	}
4443
4444	/** @copydoc VBOXHDDBACKEND::pfnGetImageType */
4445	static int vmdkGetImageType(void *pBackendData, PVDIMAGETYPE penmImageType)
4446	{
4447	LogFlowFunc(("pBackendData=%#p penmImageType=%#p\n", pBackendData, penmImageType));
4448	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4449	int rc = VINF_SUCCESS;
4450
4451	Assert(pImage);
4452	Assert(penmImageType);
4453
4454	if (pImage && pImage->cExtents != 0)
4455	*penmImageType = pImage->enmImageType;
4456	else
4457	rc = VERR_VDI_NOT_OPENED;
4458
4459	LogFlowFunc(("returns %Rrc enmImageType=%u\n", rc, *penmImageType));
4460	return rc;
4461	}
4462
4463	/** @copydoc VBOXHDDBACKEND::pfnGetSize */
4464	static uint64_t vmdkGetSize(void *pBackendData)
4465	{
4466	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
4467	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4468
4469	Assert(pImage);
4470
4471	if (pImage)
4472	return pImage->cbSize;
4473	else
4474	return 0;
4475	}
4476
4477	/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
4478	static uint64_t vmdkGetFileSize(void *pBackendData)
4479	{
4480	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
4481	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4482	uint64_t cb = 0;
4483
4484	Assert(pImage);
4485
4486	if (pImage)
4487	{
4488	uint64_t cbFile;
4489	if (pImage->pFile != NULL)
4490	{
4491	int rc = vmdkFileGetSize(pImage->pFile, &cbFile);
4492	if (RT_SUCCESS(rc))
4493	cb += cbFile;
4494	for (unsigned i = 0; i <= pImage->cExtents; i++)
4495	{
4496	rc = vmdkFileGetSize(pImage->pFile, &cbFile);
4497	if (RT_SUCCESS(rc))
4498	cb += cbFile;
4499	}
4500	}
4501	}
4502
4503	LogFlowFunc(("returns %lld\n", cb));
4504	return cb;
4505	}
4506
4507	/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
4508	static int vmdkGetPCHSGeometry(void *pBackendData,
4509	PPDMMEDIAGEOMETRY pPCHSGeometry)
4510	{
4511	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
4512	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4513	int rc;
4514
4515	Assert(pImage);
4516
4517	if (pImage)
4518	{
4519	if (pImage->PCHSGeometry.cCylinders)
4520	{
4521	*pPCHSGeometry = pImage->PCHSGeometry;
4522	rc = VINF_SUCCESS;
4523	}
4524	else
4525	rc = VERR_VDI_GEOMETRY_NOT_SET;
4526	}
4527	else
4528	rc = VERR_VDI_NOT_OPENED;
4529
4530	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
4531	return rc;
4532	}
4533
4534	/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
4535	static int vmdkSetPCHSGeometry(void *pBackendData,
4536	PCPDMMEDIAGEOMETRY pPCHSGeometry)
4537	{
4538	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
4539	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4540	int rc;
4541
4542	Assert(pImage);
4543
4544	if (pImage)
4545	{
4546	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
4547	{
4548	rc = VERR_VDI_IMAGE_READ_ONLY;
4549	goto out;
4550	}
4551	rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
4552	if (RT_FAILURE(rc))
4553	goto out;
4554
4555	pImage->PCHSGeometry = *pPCHSGeometry;
4556	rc = VINF_SUCCESS;
4557	}
4558	else
4559	rc = VERR_VDI_NOT_OPENED;
4560
4561	out:
4562	LogFlowFunc(("returns %Rrc\n", rc));
4563	return rc;
4564	}
4565
4566	/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
4567	static int vmdkGetLCHSGeometry(void *pBackendData,
4568	PPDMMEDIAGEOMETRY pLCHSGeometry)
4569	{
4570	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
4571	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4572	int rc;
4573
4574	Assert(pImage);
4575
4576	if (pImage)
4577	{
4578	if (pImage->LCHSGeometry.cCylinders)
4579	{
4580	*pLCHSGeometry = pImage->LCHSGeometry;
4581	rc = VINF_SUCCESS;
4582	}
4583	else
4584	rc = VERR_VDI_GEOMETRY_NOT_SET;
4585	}
4586	else
4587	rc = VERR_VDI_NOT_OPENED;
4588
4589	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
4590	return rc;
4591	}
4592
4593	/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
4594	static int vmdkSetLCHSGeometry(void *pBackendData,
4595	PCPDMMEDIAGEOMETRY pLCHSGeometry)
4596	{
4597	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
4598	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4599	int rc;
4600
4601	Assert(pImage);
4602
4603	if (pImage)
4604	{
4605	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
4606	{
4607	rc = VERR_VDI_IMAGE_READ_ONLY;
4608	goto out;
4609	}
4610	rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
4611	if (RT_FAILURE(rc))
4612	goto out;
4613
4614	pImage->LCHSGeometry = *pLCHSGeometry;
4615	rc = VINF_SUCCESS;
4616	}
4617	else
4618	rc = VERR_VDI_NOT_OPENED;
4619
4620	out:
4621	LogFlowFunc(("returns %Rrc\n", rc));
4622	return rc;
4623	}
4624
4625	/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
4626	static unsigned vmdkGetImageFlags(void *pBackendData)
4627	{
4628	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
4629	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4630	unsigned uImageFlags;
4631
4632	Assert(pImage);
4633
4634	if (pImage)
4635	uImageFlags = pImage->uImageFlags;
4636	else
4637	uImageFlags = 0;
4638
4639	LogFlowFunc(("returns %#x\n", uImageFlags));
4640	return uImageFlags;
4641	}
4642
4643	/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
4644	static unsigned vmdkGetOpenFlags(void *pBackendData)
4645	{
4646	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
4647	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4648	unsigned uOpenFlags;
4649
4650	Assert(pImage);
4651
4652	if (pImage)
4653	uOpenFlags = pImage->uOpenFlags;
4654	else
4655	uOpenFlags = 0;
4656
4657	LogFlowFunc(("returns %#x\n", uOpenFlags));
4658	return uOpenFlags;
4659	}
4660
4661	/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
4662	static int vmdkSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
4663	{
4664	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
4665	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4666	int rc;
4667
4668	/* Image must be opened and the new flags must be valid. Just readonly flag
4669	* is supported. */
4670	if (!pImage \|\| uOpenFlags & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_ASYNC_IO))
4671	{
4672	rc = VERR_INVALID_PARAMETER;
4673	goto out;
4674	}
4675
4676	/* Implement this operation via reopening the image. */
4677	vmdkFreeImage(pImage, false);
4678	rc = vmdkOpenImage(pImage, uOpenFlags);
4679
4680	out:
4681	LogFlowFunc(("returns %Rrc\n", rc));
4682	return rc;
4683	}
4684
4685	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
4686	static int vmdkGetComment(void pBackendData, char pszComment,
4687	size_t cbComment)
4688	{
4689	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
4690	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4691	int rc;
4692
4693	Assert(pImage);
4694
4695	if (pImage)
4696	{
4697	const char *pszCommentEncoded = NULL;
4698	rc = vmdkDescDDBGetStr(pImage, &pImage->Descriptor,
4699	"ddb.comment", &pszCommentEncoded);
4700	if (rc == VERR_VDI_VALUE_NOT_FOUND)
4701	pszCommentEncoded = NULL;
4702	else if (RT_FAILURE(rc))
4703	goto out;
4704
4705	if (pszComment)
4706	rc = vmdkDecodeString(pszCommentEncoded, pszComment, cbComment);
4707	else
4708	rc = VINF_SUCCESS;
4709	if (pszCommentEncoded)
4710	RTStrFree((char )(void )pszCommentEncoded);
4711	}
4712	else
4713	rc = VERR_VDI_NOT_OPENED;
4714
4715	out:
4716	LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
4717	return rc;
4718	}
4719
4720	/** @copydoc VBOXHDDBACKEND::pfnSetComment */
4721	static int vmdkSetComment(void pBackendData, const char pszComment)
4722	{
4723	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
4724	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4725	int rc;
4726
4727	Assert(pImage);
4728
4729	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
4730	{
4731	rc = VERR_VDI_IMAGE_READ_ONLY;
4732	goto out;
4733	}
4734
4735	if (pImage)
4736	rc = vmdkSetImageComment(pImage, pszComment);
4737	else
4738	rc = VERR_VDI_NOT_OPENED;
4739
4740	out:
4741	LogFlowFunc(("returns %Rrc\n", rc));
4742	return rc;
4743	}
4744
4745	/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
4746	static int vmdkGetUuid(void *pBackendData, PRTUUID pUuid)
4747	{
4748	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
4749	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4750	int rc;
4751
4752	Assert(pImage);
4753
4754	if (pImage)
4755	{
4756	*pUuid = pImage->ImageUuid;
4757	rc = VINF_SUCCESS;
4758	}
4759	else
4760	rc = VERR_VDI_NOT_OPENED;
4761
4762	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
4763	return rc;
4764	}
4765
4766	/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
4767	static int vmdkSetUuid(void *pBackendData, PCRTUUID pUuid)
4768	{
4769	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
4770	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4771	int rc;
4772
4773	LogFlowFunc(("%RTuuid\n", pUuid));
4774	Assert(pImage);
4775
4776	if (pImage)
4777	{
4778	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
4779	{
4780	pImage->ImageUuid = *pUuid;
4781	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
4782	VMDK_DDB_IMAGE_UUID, pUuid);
4783	if (RT_FAILURE(rc))
4784	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing image UUID in descriptor in '%s'"), pImage->pszFilename);
4785	rc = VINF_SUCCESS;
4786	}
4787	else
4788	rc = VERR_VDI_IMAGE_READ_ONLY;
4789	}
4790	else
4791	rc = VERR_VDI_NOT_OPENED;
4792
4793	LogFlowFunc(("returns %Rrc\n", rc));
4794	return rc;
4795	}
4796
4797	/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
4798	static int vmdkGetModificationUuid(void *pBackendData, PRTUUID pUuid)
4799	{
4800	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
4801	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4802	int rc;
4803
4804	Assert(pImage);
4805
4806	if (pImage)
4807	{
4808	*pUuid = pImage->ModificationUuid;
4809	rc = VINF_SUCCESS;
4810	}
4811	else
4812	rc = VERR_VDI_NOT_OPENED;
4813
4814	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
4815	return rc;
4816	}
4817
4818	/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
4819	static int vmdkSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
4820	{
4821	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
4822	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4823	int rc;
4824
4825	Assert(pImage);
4826
4827	if (pImage)
4828	{
4829	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
4830	{
4831	pImage->ModificationUuid = *pUuid;
4832	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
4833	VMDK_DDB_MODIFICATION_UUID, pUuid);
4834	if (RT_FAILURE(rc))
4835	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing modification UUID in descriptor in '%s'"), pImage->pszFilename);
4836	rc = VINF_SUCCESS;
4837	}
4838	else
4839	rc = VERR_VDI_IMAGE_READ_ONLY;
4840	}
4841	else
4842	rc = VERR_VDI_NOT_OPENED;
4843
4844	LogFlowFunc(("returns %Rrc\n", rc));
4845	return rc;
4846	}
4847
4848	/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
4849	static int vmdkGetParentUuid(void *pBackendData, PRTUUID pUuid)
4850	{
4851	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
4852	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4853	int rc;
4854
4855	Assert(pImage);
4856
4857	if (pImage)
4858	{
4859	*pUuid = pImage->ParentUuid;
4860	rc = VINF_SUCCESS;
4861	}
4862	else
4863	rc = VERR_VDI_NOT_OPENED;
4864
4865	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
4866	return rc;
4867	}
4868
4869	/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
4870	static int vmdkSetParentUuid(void *pBackendData, PCRTUUID pUuid)
4871	{
4872	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
4873	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4874	int rc;
4875
4876	Assert(pImage);
4877
4878	if (pImage)
4879	{
4880	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
4881	{
4882	pImage->ParentUuid = *pUuid;
4883	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
4884	VMDK_DDB_PARENT_UUID, pUuid);
4885	if (RT_FAILURE(rc))
4886	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent image UUID in descriptor in '%s'"), pImage->pszFilename);
4887	rc = VINF_SUCCESS;
4888	}
4889	else
4890	rc = VERR_VDI_IMAGE_READ_ONLY;
4891	}
4892	else
4893	rc = VERR_VDI_NOT_OPENED;
4894
4895	LogFlowFunc(("returns %Rrc\n", rc));
4896	return rc;
4897	}
4898
4899	/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
4900	static int vmdkGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
4901	{
4902	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
4903	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4904	int rc;
4905
4906	Assert(pImage);
4907
4908	if (pImage)
4909	{
4910	*pUuid = pImage->ParentModificationUuid;
4911	rc = VINF_SUCCESS;
4912	}
4913	else
4914	rc = VERR_VDI_NOT_OPENED;
4915
4916	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
4917	return rc;
4918	}
4919
4920	/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
4921	static int vmdkSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
4922	{
4923	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
4924	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4925	int rc;
4926
4927	Assert(pImage);
4928
4929	if (pImage)
4930	{
4931	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
4932	{
4933	pImage->ParentModificationUuid = *pUuid;
4934	rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
4935	VMDK_DDB_PARENT_MODIFICATION_UUID, pUuid);
4936	if (RT_FAILURE(rc))
4937	return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent image UUID in descriptor in '%s'"), pImage->pszFilename);
4938	rc = VINF_SUCCESS;
4939	}
4940	else
4941	rc = VERR_VDI_IMAGE_READ_ONLY;
4942	}
4943	else
4944	rc = VERR_VDI_NOT_OPENED;
4945
4946	LogFlowFunc(("returns %Rrc\n", rc));
4947	return rc;
4948	}
4949
4950	/** @copydoc VBOXHDDBACKEND::pfnDump */
4951	static void vmdkDump(void *pBackendData)
4952	{
4953	PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
4954
4955	Assert(pImage);
4956	if (pImage)
4957	{
4958	RTLogPrintf("Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
4959	pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
4960	pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
4961	VMDK_BYTE2SECTOR(pImage->cbSize));
4962	RTLogPrintf("Header: uuidCreation={%RTuuid}\n", &pImage->ImageUuid);
4963	RTLogPrintf("Header: uuidModification={%RTuuid}\n", &pImage->ModificationUuid);
4964	RTLogPrintf("Header: uuidParent={%RTuuid}\n", &pImage->ParentUuid);
4965	RTLogPrintf("Header: uuidParentModification={%RTuuid}\n", &pImage->ParentModificationUuid);
4966	}
4967	}
4968
4969
4970	static int vmdkGetTimeStamp(void *pvBackendData, PRTTIMESPEC pTimeStamp)
4971	{
4972	int rc = VERR_NOT_IMPLEMENTED;
4973	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
4974	return rc;
4975	}
4976
4977	static int vmdkGetParentTimeStamp(void *pvBackendData, PRTTIMESPEC pTimeStamp)
4978	{
4979	int rc = VERR_NOT_IMPLEMENTED;
4980	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
4981	return rc;
4982	}
4983
4984	static int vmdkSetParentTimeStamp(void *pvBackendData, PCRTTIMESPEC pTimeStamp)
4985	{
4986	int rc = VERR_NOT_IMPLEMENTED;
4987	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
4988	return rc;
4989	}
4990
4991	static int vmdkGetParentFilename(void pvBackendData, char *ppszParentFilename)
4992	{
4993	int rc = VERR_NOT_IMPLEMENTED;
4994	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
4995	return rc;
4996	}
4997
4998	static int vmdkSetParentFilename(void pvBackendData, const char pszParentFilename)
4999	{
5000	int rc = VERR_NOT_IMPLEMENTED;
5001	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
5002	return rc;
5003	}
5004
5005	static bool vmdkIsAsyncIOSupported(void *pvBackendData)
5006	{
5007	PVMDKIMAGE pImage = (PVMDKIMAGE)pvBackendData;
5008	bool fAsyncIOSupported = false;
5009
5010	if (pImage)
5011	{
5012	/* We only support async I/O support if the image only consists of FLAT or ZERO extents. */
5013	fAsyncIOSupported = true;
5014	for (unsigned i = 0; i < pImage->cExtents; i++)
5015	{
5016	if ( (pImage->pExtents[i].enmType != VMDKETYPE_FLAT)
5017	&& (pImage->pExtents[i].enmType != VMDKETYPE_ZERO))
5018	{
5019	fAsyncIOSupported = false;
5020	break; /* Stop search */
5021	}
5022	}
5023	}
5024
5025	return fAsyncIOSupported;
5026	}
5027
5028	static int vmdkAsyncRead(void *pvBackendData, uint64_t uOffset, size_t cbRead,
5029	PPDMDATASEG paSeg, unsigned cSeg, void *pvUser)
5030	{
5031	PVMDKIMAGE pImage = (PVMDKIMAGE)pvBackendData;
5032	PVMDKEXTENT pExtent;
5033	int rc = VINF_SUCCESS;
5034	unsigned cTasksToSubmit = 0;
5035	PPDMDATASEG paSegCurrent = paSeg;
5036	unsigned cbLeftInCurrentSegment = paSegCurrent->cbSeg;
5037	unsigned uOffsetInCurrentSegment = 0;
5038
5039	Assert(pImage);
5040	Assert(uOffset % 512 == 0);
5041	Assert(cbRead % 512 == 0);
5042
5043	if ( uOffset + cbRead > pImage->cbSize
5044	\|\| cbRead == 0)
5045	{
5046	rc = VERR_INVALID_PARAMETER;
5047	goto out;
5048	}
5049
5050	while (cbRead && cSeg)
5051	{
5052	unsigned cbToRead;
5053	uint64_t uSectorExtentRel;
5054
5055	rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
5056	&pExtent, &uSectorExtentRel);
5057	if (RT_FAILURE(rc))
5058	goto out;
5059
5060	/* Check access permissions as defined in the extent descriptor. */
5061	if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
5062	{
5063	rc = VERR_VDI_INVALID_STATE;
5064	goto out;
5065	}
5066
5067	/* Clip read range to remain in this extent. */
5068	cbToRead = RT_MIN(cbRead, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
5069	/* Clip read range to remain into current data segment. */
5070	cbToRead = RT_MIN(cbToRead, cbLeftInCurrentSegment);
5071
5072	switch (pExtent->enmType)
5073	{
5074	case VMDKETYPE_FLAT:
5075	{
5076	/* Setup new task. */
5077	void *pTask;
5078	rc = pImage->pInterfaceAsyncIOCallbacks->pfnPrepareRead(pImage->pInterfaceAsyncIO->pvUser, pExtent->pFile->pStorage,
5079	VMDK_SECTOR2BYTE(uSectorExtentRel),
5080	(uint8_t *)paSegCurrent->pvSeg + uOffsetInCurrentSegment,
5081	cbToRead, &pTask);
5082	if (RT_FAILURE(rc))
5083	{
5084	AssertMsgFailed(("Preparing read failed rc=%Rrc\n", rc));
5085	goto out;
5086	}
5087
5088	/* Check for enough room first. */
5089	if (cTasksToSubmit >= pImage->cTask)
5090	{
5091	/* We reached maximum, resize array. Try to realloc memory first. */
5092	void apTaskNew = (void )RTMemRealloc(pImage->apTask, (cTasksToSubmit + 10)sizeof(void ));
5093
5094	if (!apTaskNew)
5095	{
5096	/* We failed. Allocate completely new. */
5097	apTaskNew = (void *)RTMemAllocZ((cTasksToSubmit + 10) sizeof(void *));
5098	if (!apTaskNew)
5099	{
5100	/* Damn, we are out of memory. */
5101	rc = VERR_NO_MEMORY;
5102	goto out;
5103	}
5104
5105	/* Copy task handles over. */
5106	for (unsigned i = 0; i < cTasksToSubmit; i++)
5107	apTaskNew[i] = pImage->apTask[i];
5108
5109	/* Free old memory. */
5110	RTMemFree(pImage->apTask);
5111	}
5112
5113	pImage->cTask = cTasksToSubmit + 10;
5114	pImage->apTask = apTaskNew;
5115	}
5116
5117	pImage->apTask[cTasksToSubmit] = pTask;
5118	cTasksToSubmit++;
5119	break;
5120	}
5121	case VMDKETYPE_ZERO:
5122	memset((uint8_t *)paSegCurrent->pvSeg + uOffsetInCurrentSegment, 0, cbToRead);
5123	break;
5124	default:
5125	AssertMsgFailed(("Unsupported extent type %u\n", pExtent->enmType));
5126	}
5127
5128	cbRead -= cbToRead;
5129	uOffset += cbToRead;
5130	cbLeftInCurrentSegment -= cbToRead;
5131	uOffsetInCurrentSegment += cbToRead;
5132	/* Go to next extent if there is no space left in current one. */
5133	if (!cbLeftInCurrentSegment)
5134	{
5135	uOffsetInCurrentSegment = 0;
5136	paSegCurrent++;
5137	cSeg--;
5138	cbLeftInCurrentSegment = paSegCurrent->cbSeg;
5139	}
5140	}
5141
5142	AssertMsg(cbRead == 0, ("No segment left but there is still data to read\n"));
5143
5144	if (cTasksToSubmit == 0)
5145	{
5146	/* The request was completely in a ZERO extent nothing to do. */
5147	rc = VINF_VDI_ASYNC_IO_FINISHED;
5148	}
5149	else
5150	{
5151	/* Submit tasks. */
5152	rc = pImage->pInterfaceAsyncIOCallbacks->pfnTasksSubmit(pImage->pInterfaceAsyncIO->pvUser,
5153	pImage->apTask, cTasksToSubmit,
5154	NULL, pvUser,
5155	NULL /* Nothing required after read. */);
5156	AssertMsgRC(rc, ("Failed to enqueue tasks rc=%Rrc\n", rc));
5157	}
5158
5159	out:
5160	LogFlowFunc(("returns %Rrc\n", rc));
5161	return rc;
5162	}
5163
5164	static int vmdkAsyncWrite(void *pvBackendData, uint64_t uOffset, size_t cbWrite,
5165	PPDMDATASEG paSeg, unsigned cSeg, void *pvUser)
5166	{
5167	PVMDKIMAGE pImage = (PVMDKIMAGE)pvBackendData;
5168	PVMDKEXTENT pExtent;
5169	int rc = VINF_SUCCESS;
5170	unsigned cTasksToSubmit = 0;
5171	PPDMDATASEG paSegCurrent = paSeg;
5172	unsigned cbLeftInCurrentSegment = paSegCurrent->cbSeg;
5173	unsigned uOffsetInCurrentSegment = 0;
5174
5175	Assert(pImage);
5176	Assert(uOffset % 512 == 0);
5177	Assert(cbWrite % 512 == 0);
5178
5179	if ( uOffset + cbWrite > pImage->cbSize
5180	\|\| cbWrite == 0)
5181	{
5182	rc = VERR_INVALID_PARAMETER;
5183	goto out;
5184	}
5185
5186	while (cbWrite && cSeg)
5187	{
5188	unsigned cbToWrite;
5189	uint64_t uSectorExtentRel;
5190
5191	rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
5192	&pExtent, &uSectorExtentRel);
5193	if (RT_FAILURE(rc))
5194	goto out;
5195
5196	/* Check access permissions as defined in the extent descriptor. */
5197	if (pExtent->enmAccess == VMDKACCESS_NOACCESS)
5198	{
5199	rc = VERR_VDI_INVALID_STATE;
5200	goto out;
5201	}
5202
5203	/* Clip write range to remain in this extent. */
5204	cbToWrite = RT_MIN(cbWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
5205	/* Clip write range to remain into current data segment. */
5206	cbToWrite = RT_MIN(cbToWrite, cbLeftInCurrentSegment);
5207
5208	switch (pExtent->enmType)
5209	{
5210	case VMDKETYPE_FLAT:
5211	{
5212	/* Setup new task. */
5213	void *pTask;
5214	rc = pImage->pInterfaceAsyncIOCallbacks->pfnPrepareWrite(pImage->pInterfaceAsyncIO->pvUser, pExtent->pFile->pStorage,
5215	VMDK_SECTOR2BYTE(uSectorExtentRel),
5216	(uint8_t *)paSegCurrent->pvSeg + uOffsetInCurrentSegment,
5217	cbToWrite, &pTask);
5218	if (RT_FAILURE(rc))
5219	{
5220	AssertMsgFailed(("Preparing read failed rc=%Rrc\n", rc));
5221	goto out;
5222	}
5223
5224	/* Check for enough room first. */
5225	if (cTasksToSubmit >= pImage->cTask)
5226	{
5227	/* We reached maximum, resize array. Try to realloc memory first. */
5228	void apTaskNew = (void )RTMemRealloc(pImage->apTask, (cTasksToSubmit + 10)sizeof(void ));
5229
5230	if (!apTaskNew)
5231	{
5232	/* We failed. Allocate completely new. */
5233	apTaskNew = (void *)RTMemAllocZ((cTasksToSubmit + 10) sizeof(void *));
5234	if (!apTaskNew)
5235	{
5236	/* Damn, we are out of memory. */
5237	rc = VERR_NO_MEMORY;
5238	goto out;
5239	}
5240
5241	/* Copy task handles over. */
5242	for (unsigned i = 0; i < cTasksToSubmit; i++)
5243	apTaskNew[i] = pImage->apTask[i];
5244
5245	/* Free old memory. */
5246	RTMemFree(pImage->apTask);
5247	}
5248
5249	pImage->cTask = cTasksToSubmit + 10;
5250	pImage->apTask = apTaskNew;
5251	}
5252
5253	pImage->apTask[cTasksToSubmit] = pTask;
5254	cTasksToSubmit++;
5255	break;
5256	}
5257	case VMDKETYPE_ZERO:
5258	/* Nothing left to do. */
5259	break;
5260	default:
5261	AssertMsgFailed(("Unsupported extent type %u\n", pExtent->enmType));
5262	}
5263
5264	cbWrite -= cbToWrite;
5265	uOffset += cbToWrite;
5266	cbLeftInCurrentSegment -= cbToWrite;
5267	uOffsetInCurrentSegment += cbToWrite;
5268	/* Go to next extent if there is no space left in current one. */
5269	if (!cbLeftInCurrentSegment)
5270	{
5271	uOffsetInCurrentSegment = 0;
5272	paSegCurrent++;
5273	cSeg--;
5274	cbLeftInCurrentSegment = paSegCurrent->cbSeg;
5275	}
5276	}
5277
5278	AssertMsg(cbWrite == 0, ("No segment left but there is still data to read\n"));
5279
5280	if (cTasksToSubmit == 0)
5281	{
5282	/* The request was completely in a ZERO extent nothing to do. */
5283	rc = VINF_VDI_ASYNC_IO_FINISHED;
5284	}
5285	else
5286	{
5287	/* Submit tasks. */
5288	rc = pImage->pInterfaceAsyncIOCallbacks->pfnTasksSubmit(pImage->pInterfaceAsyncIO->pvUser,
5289	pImage->apTask, cTasksToSubmit,
5290	NULL, pvUser,
5291	NULL /* Nothing required after read. */);
5292	AssertMsgRC(rc, ("Failed to enqueue tasks rc=%Rrc\n", rc));
5293	}
5294
5295	out:
5296	LogFlowFunc(("returns %Rrc\n", rc));
5297	return rc;
5298
5299	}
5300
5301
5302	VBOXHDDBACKEND g_VmdkBackend =
5303	{
5304	/* pszBackendName */
5305	"VMDK",
5306	/* cbSize */
5307	sizeof(VBOXHDDBACKEND),
5308	/* uBackendCaps */
5309	VD_CAP_UUID \| VD_CAP_CREATE_FIXED \| VD_CAP_CREATE_DYNAMIC
5310	\| VD_CAP_CREATE_SPLIT_2G \| VD_CAP_DIFF \| VD_CAP_FILE \|VD_CAP_ASYNC,
5311	/* papszFileExtensions */
5312	s_apszVmdkFileExtensions,
5313	/* paConfigInfo */
5314	NULL,
5315	/* pfnCheckIfValid */
5316	vmdkCheckIfValid,
5317	/* pfnOpen */
5318	vmdkOpen,
5319	/* pfnCreate */
5320	vmdkCreate,
5321	/* pfnRename */
5322	vmdkRename,
5323	/* pfnClose */
5324	vmdkClose,
5325	/* pfnRead */
5326	vmdkRead,
5327	/* pfnWrite */
5328	vmdkWrite,
5329	/* pfnFlush */
5330	vmdkFlush,
5331	/* pfnGetVersion */
5332	vmdkGetVersion,
5333	/* pfnGetImageType */
5334	vmdkGetImageType,
5335	/* pfnGetSize */
5336	vmdkGetSize,
5337	/* pfnGetFileSize */
5338	vmdkGetFileSize,
5339	/* pfnGetPCHSGeometry */
5340	vmdkGetPCHSGeometry,
5341	/* pfnSetPCHSGeometry */
5342	vmdkSetPCHSGeometry,
5343	/* pfnGetLCHSGeometry */
5344	vmdkGetLCHSGeometry,
5345	/* pfnSetLCHSGeometry */
5346	vmdkSetLCHSGeometry,
5347	/* pfnGetImageFlags */
5348	vmdkGetImageFlags,
5349	/* pfnGetOpenFlags */
5350	vmdkGetOpenFlags,
5351	/* pfnSetOpenFlags */
5352	vmdkSetOpenFlags,
5353	/* pfnGetComment */
5354	vmdkGetComment,
5355	/* pfnSetComment */
5356	vmdkSetComment,
5357	/* pfnGetUuid */
5358	vmdkGetUuid,
5359	/* pfnSetUuid */
5360	vmdkSetUuid,
5361	/* pfnGetModificationUuid */
5362	vmdkGetModificationUuid,
5363	/* pfnSetModificationUuid */
5364	vmdkSetModificationUuid,
5365	/* pfnGetParentUuid */
5366	vmdkGetParentUuid,
5367	/* pfnSetParentUuid */
5368	vmdkSetParentUuid,
5369	/* pfnGetParentModificationUuid */
5370	vmdkGetParentModificationUuid,
5371	/* pfnSetParentModificationUuid */
5372	vmdkSetParentModificationUuid,
5373	/* pfnDump */
5374	vmdkDump,
5375	/* pfnGetTimeStamp */
5376	vmdkGetTimeStamp,
5377	/* pfnGetParentTimeStamp */
5378	vmdkGetParentTimeStamp,
5379	/* pfnSetParentTimeStamp */
5380	vmdkSetParentTimeStamp,
5381	/* pfnGetParentFilename */
5382	vmdkGetParentFilename,
5383	/* pfnSetParentFilename */
5384	vmdkSetParentFilename,
5385	/* pfnIsAsyncIOSupported */
5386	vmdkIsAsyncIOSupported,
5387	/* pfnAsyncRead */
5388	vmdkAsyncRead,
5389	/* pfnAsyncWrite */
5390	vmdkAsyncWrite
5391	};

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

source: vbox/trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp@ 13303

Download in other formats: