QED.cpp

Last change on this file was 106061, checked in by vboxsync, 4 weeks ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 87.0 KB

Rev	Line
[38463]	1	/* $Id: QED.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
	2	/** @file
	3	* QED - QED Disk image.
[99739]	4	*
	5	* The QED backend implements support for the qemu enhanced disk format (short QED)
	6	* The specification for the format is available under http://wiki.qemu.org/Features/QED/Specification
	7	*
	8	* Missing things to implement:
	9	* - compaction
	10	* - resizing which requires block relocation (very rare case)
[38463]	11	*/
	12
	13	/*
[106061]	14	* Copyright (C) 2011-2024 Oracle and/or its affiliates.
[38463]	15	*
[96407]	16	* This file is part of VirtualBox base platform packages, as
	17	* available from https://www.virtualbox.org.
	18	*
	19	* This program is free software; you can redistribute it and/or
	20	* modify it under the terms of the GNU General Public License
	21	* as published by the Free Software Foundation, in version 3 of the
	22	* License.
	23	*
	24	* This program is distributed in the hope that it will be useful, but
	25	* WITHOUT ANY WARRANTY; without even the implied warranty of
	26	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	27	* General Public License for more details.
	28	*
	29	* You should have received a copy of the GNU General Public License
	30	* along with this program; if not, see <https://www.gnu.org/licenses>.
	31	*
	32	* SPDX-License-Identifier: GPL-3.0-only
[38463]	33	*/
	34
[57358]	35
	36	/*********************************************************************************************************************************
	37	* Header Files *
	38	*********************************************************************************************************************************/
[38623]	39	#define LOG_GROUP LOG_GROUP_VD_QED
[38463]	40	#include <VBox/vd-plugin.h>
	41	#include <VBox/err.h>
	42
	43	#include <VBox/log.h>
[103005]	44	#include <iprt/asm-mem.h>
[38463]	45	#include <iprt/asm.h>
	46	#include <iprt/assert.h>
	47	#include <iprt/string.h>
	48	#include <iprt/alloc.h>
	49	#include <iprt/path.h>
	50	#include <iprt/list.h>
	51
[50988]	52	#include "VDBackends.h"
[66494]	53	#include "VDBackendsInline.h"
[50988]	54
[38463]	55
[57358]	56	/*********************************************************************************************************************************
	57	* Structures in a QED image, little endian *
	58	*********************************************************************************************************************************/
	59
[38463]	60	#pragma pack(1)
	61	typedef struct QedHeader
	62	{
	63	/** Magic value. */
	64	uint32_t u32Magic;
	65	/** Cluster size in bytes. */
	66	uint32_t u32ClusterSize;
	67	/** Size of L1 and L2 tables in clusters. */
	68	uint32_t u32TableSize;
	69	/** size of this header structure in clusters. */
	70	uint32_t u32HeaderSize;
	71	/** Features used for the image. */
	72	uint64_t u64FeatureFlags;
	73	/** Compatibility features used for the image. */
	74	uint64_t u64CompatFeatureFlags;
	75	/** Self resetting feature bits. */
	76	uint64_t u64AutoresetFeatureFlags;
	77	/** Offset of the L1 table in bytes. */
	78	uint64_t u64OffL1Table;
	79	/** Logical image size as seen by the guest. */
	80	uint64_t u64Size;
	81	/** Offset of the backing filename in bytes. */
	82	uint32_t u32OffBackingFilename;
	83	/** Size of the backing filename. */
	84	uint32_t u32BackingFilenameSize;
	85	} QedHeader;
	86	#pragma pack()
	87	/** Pointer to a on disk QED header. */
	88	typedef QedHeader *PQedHeader;
	89
	90	/** QED magic value. */
	91	#define QED_MAGIC UINT32_C(0x00444551) /* QED\0 */
	92	/** Cluster size minimum. */
	93	#define QED_CLUSTER_SIZE_MIN RT_BIT(12)
	94	/** Cluster size maximum. */
	95	#define QED_CLUSTER_SIZE_MAX RT_BIT(26)
	96	/** L1 and L2 Table size minimum. */
	97	#define QED_TABLE_SIZE_MIN 1
	98	/** L1 and L2 Table size maximum. */
	99	#define QED_TABLE_SIZE_MAX 16
	100
	101	/** QED default cluster size when creating an image. */
	102	#define QED_CLUSTER_SIZE_DEFAULT (64 * _1K)
	103	/** The default table size in clusters. */
	104	#define QED_TABLE_SIZE_DEFAULT 4
	105
	106	/** Feature flags.
	107	* @{
	108	*/
	109	/** Image uses a backing file to provide data for unallocated clusters. */
[40843]	110	#define QED_FEATURE_BACKING_FILE RT_BIT_64(0)
[38463]	111	/** Image needs checking before use. */
[40843]	112	#define QED_FEATURE_NEED_CHECK RT_BIT_64(1)
[38463]	113	/** Don't probe for format of the backing file, treat as raw image. */
[40843]	114	#define QED_FEATURE_BACKING_FILE_NO_PROBE RT_BIT_64(2)
[38463]	115	/** Mask of valid features. */
	116	#define QED_FEATURE_MASK (QED_FEATURE_BACKING_FILE \| QED_FEATURE_NEED_CHECK \| QED_FEATURE_BACKING_FILE_NO_PROBE)
	117	/** @} */
	118
	119	/** Compatibility feature flags.
	120	* @{
	121	*/
	122	/** Mask of valid compatibility features. */
	123	#define QED_COMPAT_FEATURE_MASK (0)
	124	/** @} */
	125
	126	/** Autoreset feature flags.
	127	* @{
	128	*/
	129	/** Mask of valid autoreset features. */
	130	#define QED_AUTORESET_FEATURE_MASK (0)
	131	/** @} */
	132
	133
[57358]	134	/*********************************************************************************************************************************
	135	* Constants And Macros, Structures and Typedefs *
	136	*********************************************************************************************************************************/
	137
[38463]	138	/**
	139	* QED L2 cache entry.
	140	*/
	141	typedef struct QEDL2CACHEENTRY
	142	{
	143	/** List node for the search list. */
	144	RTLISTNODE NodeSearch;
	145	/** List node for the LRU list. */
	146	RTLISTNODE NodeLru;
	147	/** Reference counter. */
	148	uint32_t cRefs;
	149	/** The offset of the L2 table, used as search key. */
	150	uint64_t offL2Tbl;
	151	/** Pointer to the cached L2 table. */
	152	uint64_t *paL2Tbl;
	153	} QEDL2CACHEENTRY, *PQEDL2CACHEENTRY;
	154
	155	/** Maximum amount of memory the cache is allowed to use. */
	156	#define QED_L2_CACHE_MEMORY_MAX (2*_1M)
	157
	158	/**
	159	* QED image data structure.
	160	*/
	161	typedef struct QEDIMAGE
	162	{
	163	/** Image name. */
	164	const char *pszFilename;
	165	/** Storage handle. */
	166	PVDIOSTORAGE pStorage;
	167
	168	/** Pointer to the per-disk VD interface list. */
	169	PVDINTERFACE pVDIfsDisk;
	170	/** Pointer to the per-image VD interface list. */
	171	PVDINTERFACE pVDIfsImage;
[38469]	172	/** Error interface. */
	173	PVDINTERFACEERROR pIfError;
	174	/** I/O interface. */
	175	PVDINTERFACEIOINT pIfIo;
[38463]	176
	177	/** Open flags passed by VBoxHD layer. */
	178	unsigned uOpenFlags;
	179	/** Image flags defined during creation or determined during open. */
	180	unsigned uImageFlags;
	181	/** Total size of the image. */
	182	uint64_t cbSize;
	183	/** Physical geometry of this image. */
	184	VDGEOMETRY PCHSGeometry;
	185	/** Logical geometry of this image. */
	186	VDGEOMETRY LCHSGeometry;
	187
	188	/** Filename of the backing file if any. */
	189	char *pszBackingFilename;
	190	/** Offset of the filename in the image. */
	191	uint32_t offBackingFilename;
	192	/** Size of the backing filename excluding \0. */
	193	uint32_t cbBackingFilename;
	194
	195	/** Size of the image, multiple of clusters. */
	196	uint64_t cbImage;
	197	/** Cluster size in bytes. */
[38469]	198	uint32_t cbCluster;
[38463]	199	/** Number of entries in the L1 and L2 table. */
	200	uint32_t cTableEntries;
	201	/** Size of an L1 or L2 table rounded to the next cluster size. */
[38469]	202	uint32_t cbTable;
[38463]	203	/** Pointer to the L1 table. */
	204	uint64_t *paL1Table;
	205	/** Offset of the L1 table. */
	206	uint64_t offL1Table;
	207
	208	/** Offset mask for a cluster. */
	209	uint64_t fOffsetMask;
	210	/** L1 table mask to get the L1 index. */
	211	uint64_t fL1Mask;
	212	/** Number of bits to shift to get the L1 index. */
	213	uint32_t cL1Shift;
	214	/** L2 table mask to get the L2 index. */
	215	uint64_t fL2Mask;
	216	/** Number of bits to shift to get the L2 index. */
	217	uint32_t cL2Shift;
	218
[64832]	219	/** Pointer to the L2 table we are currently allocating
	220	* (can be only one at a time). */
	221	PQEDL2CACHEENTRY pL2TblAlloc;
	222
[38463]	223	/** Memory occupied by the L2 table cache. */
	224	size_t cbL2Cache;
	225	/** The sorted L2 entry list used for searching. */
	226	RTLISTNODE ListSearch;
	227	/** The LRU L2 entry list used for eviction. */
	228	RTLISTNODE ListLru;
[66486]	229	/** The static region list. */
	230	VDREGIONLIST RegionList;
[38463]	231	} QEDIMAGE, *PQEDIMAGE;
	232
	233	/**
	234	* State of the async cluster allocation.
	235	*/
	236	typedef enum QEDCLUSTERASYNCALLOCSTATE
	237	{
	238	/** Invalid. */
	239	QEDCLUSTERASYNCALLOCSTATE_INVALID = 0,
	240	/** L2 table allocation. */
	241	QEDCLUSTERASYNCALLOCSTATE_L2_ALLOC,
	242	/** Link L2 table into L1. */
	243	QEDCLUSTERASYNCALLOCSTATE_L2_LINK,
	244	/** Allocate user data cluster. */
	245	QEDCLUSTERASYNCALLOCSTATE_USER_ALLOC,
	246	/** Link user data cluster. */
	247	QEDCLUSTERASYNCALLOCSTATE_USER_LINK,
	248	/** 32bit blowup. */
	249	QEDCLUSTERASYNCALLOCSTATE_32BIT_HACK = 0x7fffffff
	250	} QEDCLUSTERASYNCALLOCSTATE, *PQEDCLUSTERASYNCALLOCSTATE;
	251
	252	/**
	253	* Data needed to track async cluster allocation.
	254	*/
	255	typedef struct QEDCLUSTERASYNCALLOC
	256	{
	257	/** The state of the cluster allocation. */
	258	QEDCLUSTERASYNCALLOCSTATE enmAllocState;
	259	/** Old image size to rollback in case of an error. */
	260	uint64_t cbImageOld;
	261	/** L1 index to link if any. */
	262	uint32_t idxL1;
	263	/** L2 index to link, required in any case. */
	264	uint32_t idxL2;
	265	/** Start offset of the allocated cluster. */
	266	uint64_t offClusterNew;
	267	/** L2 cache entry if a L2 table is allocated. */
	268	PQEDL2CACHEENTRY pL2Entry;
	269	/** Number of bytes to write. */
	270	size_t cbToWrite;
	271	} QEDCLUSTERASYNCALLOC, *PQEDCLUSTERASYNCALLOC;
	272
	273
[57358]	274	/*********************************************************************************************************************************
	275	* Static Variables *
	276	*********************************************************************************************************************************/
	277
[38463]	278	/** NULL-terminated array of supported file extensions. */
	279	static const VDFILEEXTENSION s_aQedFileExtensions[] =
	280	{
	281	{"qed", VDTYPE_HDD},
	282	{NULL, VDTYPE_INVALID}
	283	};
	284
	285
[57358]	286	/*********************************************************************************************************************************
	287	* Internal Functions *
	288	*********************************************************************************************************************************/
	289
[38463]	290	/**
	291	* Converts the image header to the host endianess and performs basic checks.
	292	*
	293	* @returns Whether the given header is valid or not.
	294	* @param pHeader Pointer to the header to convert.
	295	*/
	296	static bool qedHdrConvertToHostEndianess(PQedHeader pHeader)
	297	{
	298	pHeader->u32Magic = RT_LE2H_U32(pHeader->u32Magic);
	299	pHeader->u32ClusterSize = RT_LE2H_U32(pHeader->u32ClusterSize);
	300	pHeader->u32TableSize = RT_LE2H_U32(pHeader->u32TableSize);
	301	pHeader->u32HeaderSize = RT_LE2H_U32(pHeader->u32HeaderSize);
	302	pHeader->u64FeatureFlags = RT_LE2H_U64(pHeader->u64FeatureFlags);
	303	pHeader->u64CompatFeatureFlags = RT_LE2H_U64(pHeader->u64CompatFeatureFlags);
	304	pHeader->u64AutoresetFeatureFlags = RT_LE2H_U64(pHeader->u64AutoresetFeatureFlags);
	305	pHeader->u64OffL1Table = RT_LE2H_U64(pHeader->u64OffL1Table);
	306	pHeader->u64Size = RT_LE2H_U64(pHeader->u64Size);
	307	pHeader->u32OffBackingFilename = RT_LE2H_U32(pHeader->u32OffBackingFilename);
	308	pHeader->u32BackingFilenameSize = RT_LE2H_U32(pHeader->u32BackingFilenameSize);
	309
	310	if (RT_UNLIKELY(pHeader->u32Magic != QED_MAGIC))
	311	return false;
	312	if (RT_UNLIKELY( pHeader->u32ClusterSize < QED_CLUSTER_SIZE_MIN
	313	\|\| pHeader->u32ClusterSize > QED_CLUSTER_SIZE_MAX))
	314	return false;
	315	if (RT_UNLIKELY( pHeader->u32TableSize < QED_TABLE_SIZE_MIN
	316	\|\| pHeader->u32TableSize > QED_TABLE_SIZE_MAX))
	317	return false;
	318	if (RT_UNLIKELY(pHeader->u64Size % 512 != 0))
	319	return false;
[63636]	320	if (RT_UNLIKELY( pHeader->u64FeatureFlags & QED_FEATURE_BACKING_FILE
	321	&& ( pHeader->u32BackingFilenameSize == 0
	322	\|\| pHeader->u32BackingFilenameSize == UINT32_MAX)))
	323	return false;
[38463]	324
	325	return true;
	326	}
	327
	328	/**
	329	* Creates a QED header from the given image state.
	330	*
	331	* @param pImage Image instance data.
	332	* @param pHeader Pointer to the header to convert.
	333	*/
	334	static void qedHdrConvertFromHostEndianess(PQEDIMAGE pImage, PQedHeader pHeader)
	335	{
[38562]	336	pHeader->u32Magic = RT_H2LE_U32(QED_MAGIC);
	337	pHeader->u32ClusterSize = RT_H2LE_U32(pImage->cbCluster);
	338	pHeader->u32TableSize = RT_H2LE_U32(pImage->cbTable / pImage->cbCluster);
	339	pHeader->u32HeaderSize = RT_H2LE_U32(1);
[40843]	340	pHeader->u64FeatureFlags = RT_H2LE_U64(pImage->pszBackingFilename ? QED_FEATURE_BACKING_FILE : UINT64_C(0));
	341	pHeader->u64CompatFeatureFlags = RT_H2LE_U64(UINT64_C(0));
	342	pHeader->u64AutoresetFeatureFlags = RT_H2LE_U64(UINT64_C(0));
[38562]	343	pHeader->u64OffL1Table = RT_H2LE_U64(pImage->offL1Table);
	344	pHeader->u64Size = RT_H2LE_U64(pImage->cbSize);
	345	pHeader->u32OffBackingFilename = RT_H2LE_U32(pImage->offBackingFilename);
	346	pHeader->u32BackingFilenameSize = RT_H2LE_U32(pImage->cbBackingFilename);
[38463]	347	}
	348
	349	/**
	350	* Convert table entries from little endian to host endianess.
	351	*
	352	* @param paTbl Pointer to the table.
	353	* @param cEntries Number of entries in the table.
	354	*/
	355	static void qedTableConvertToHostEndianess(uint64_t *paTbl, uint32_t cEntries)
	356	{
[99739]	357	while (cEntries-- > 0)
[38463]	358	{
	359	paTbl = RT_LE2H_U64(paTbl);
	360	paTbl++;
	361	}
	362	}
	363
[62873]	364	#if defined(RT_BIG_ENDIAN)
[38463]	365	/**
	366	* Convert table entries from host to little endian format.
	367	*
	368	* @param paTblImg Pointer to the table which will store the little endian table.
	369	* @param paTbl The source table to convert.
	370	* @param cEntries Number of entries in the table.
	371	*/
[99739]	372	static void qedTableConvertFromHostEndianess(uint64_t paTblImg, uint64_t const paTbl,
[38463]	373	uint32_t cEntries)
	374	{
[99739]	375	while (cEntries-- > 0)
[38463]	376	{
	377	paTblImg = RT_H2LE_U64(paTbl);
	378	paTbl++;
	379	paTblImg++;
	380	}
	381	}
[62873]	382	#endif
[38463]	383
	384	/**
	385	* Creates the L2 table cache.
	386	*
	387	* @returns VBox status code.
	388	* @param pImage The image instance data.
	389	*/
	390	static int qedL2TblCacheCreate(PQEDIMAGE pImage)
	391	{
	392	pImage->cbL2Cache = 0;
	393	RTListInit(&pImage->ListSearch);
	394	RTListInit(&pImage->ListLru);
	395
	396	return VINF_SUCCESS;
	397	}
	398
	399	/**
	400	* Destroys the L2 table cache.
	401	*
	402	* @param pImage The image instance data.
	403	*/
	404	static void qedL2TblCacheDestroy(PQEDIMAGE pImage)
	405	{
[64766]	406	PQEDL2CACHEENTRY pL2Entry;
	407	PQEDL2CACHEENTRY pL2Next;
[38463]	408	RTListForEachSafe(&pImage->ListSearch, pL2Entry, pL2Next, QEDL2CACHEENTRY, NodeSearch)
	409	{
	410	Assert(!pL2Entry->cRefs);
	411
	412	RTListNodeRemove(&pL2Entry->NodeSearch);
	413	RTMemPageFree(pL2Entry->paL2Tbl, pImage->cbTable);
	414	RTMemFree(pL2Entry);
	415	}
	416
	417	pImage->cbL2Cache = 0;
	418	RTListInit(&pImage->ListSearch);
	419	RTListInit(&pImage->ListLru);
	420	}
	421
	422	/**
	423	* Returns the L2 table matching the given offset or NULL if none could be found.
	424	*
	425	* @returns Pointer to the L2 table cache entry or NULL.
	426	* @param pImage The image instance data.
	427	* @param offL2Tbl Offset of the L2 table to search for.
	428	*/
	429	static PQEDL2CACHEENTRY qedL2TblCacheRetain(PQEDIMAGE pImage, uint64_t offL2Tbl)
	430	{
[64832]	431	if ( pImage->pL2TblAlloc
	432	&& pImage->pL2TblAlloc->offL2Tbl == offL2Tbl)
	433	{
	434	pImage->pL2TblAlloc->cRefs++;
	435	return pImage->pL2TblAlloc;
	436	}
	437
[64766]	438	PQEDL2CACHEENTRY pL2Entry;
[38463]	439	RTListForEach(&pImage->ListSearch, pL2Entry, QEDL2CACHEENTRY, NodeSearch)
	440	{
	441	if (pL2Entry->offL2Tbl == offL2Tbl)
	442	break;
	443	}
	444
	445	if (!RTListNodeIsDummy(&pImage->ListSearch, pL2Entry, QEDL2CACHEENTRY, NodeSearch))
	446	{
	447	/* Update LRU list. */
	448	RTListNodeRemove(&pL2Entry->NodeLru);
	449	RTListPrepend(&pImage->ListLru, &pL2Entry->NodeLru);
	450	pL2Entry->cRefs++;
	451	return pL2Entry;
	452	}
	453	else
	454	return NULL;
	455	}
	456
	457	/**
	458	* Releases a L2 table cache entry.
	459	*
	460	* @param pL2Entry The L2 cache entry.
	461	*/
	462	static void qedL2TblCacheEntryRelease(PQEDL2CACHEENTRY pL2Entry)
	463	{
	464	Assert(pL2Entry->cRefs > 0);
	465	pL2Entry->cRefs--;
	466	}
	467
	468	/**
	469	* Allocates a new L2 table from the cache evicting old entries if required.
	470	*
	471	* @returns Pointer to the L2 cache entry or NULL.
	472	* @param pImage The image instance data.
	473	*/
	474	static PQEDL2CACHEENTRY qedL2TblCacheEntryAlloc(PQEDIMAGE pImage)
	475	{
	476	PQEDL2CACHEENTRY pL2Entry = NULL;
	477
	478	if (pImage->cbL2Cache + pImage->cbTable <= QED_L2_CACHE_MEMORY_MAX)
	479	{
	480	/* Add a new entry. */
	481	pL2Entry = (PQEDL2CACHEENTRY)RTMemAllocZ(sizeof(QEDL2CACHEENTRY));
	482	if (pL2Entry)
	483	{
	484	pL2Entry->paL2Tbl = (uint64_t *)RTMemPageAllocZ(pImage->cbTable);
	485	if (RT_UNLIKELY(!pL2Entry->paL2Tbl))
	486	{
	487	RTMemFree(pL2Entry);
	488	pL2Entry = NULL;
	489	}
	490	else
	491	{
	492	pL2Entry->cRefs = 1;
	493	pImage->cbL2Cache += pImage->cbTable;
	494	}
	495	}
	496	}
	497	else
	498	{
	499	/* Evict the last not in use entry and use it */
	500	Assert(!RTListIsEmpty(&pImage->ListLru));
	501
	502	RTListForEachReverse(&pImage->ListLru, pL2Entry, QEDL2CACHEENTRY, NodeLru)
	503	{
	504	if (!pL2Entry->cRefs)
	505	break;
	506	}
	507
	508	if (!RTListNodeIsDummy(&pImage->ListSearch, pL2Entry, QEDL2CACHEENTRY, NodeSearch))
	509	{
	510	RTListNodeRemove(&pL2Entry->NodeSearch);
	511	RTListNodeRemove(&pL2Entry->NodeLru);
	512	pL2Entry->offL2Tbl = 0;
	513	pL2Entry->cRefs = 1;
	514	}
	515	else
	516	pL2Entry = NULL;
	517	}
	518
	519	return pL2Entry;
	520	}
	521
	522	/**
	523	* Frees a L2 table cache entry.
	524	*
	525	* @param pImage The image instance data.
	526	* @param pL2Entry The L2 cache entry to free.
	527	*/
	528	static void qedL2TblCacheEntryFree(PQEDIMAGE pImage, PQEDL2CACHEENTRY pL2Entry)
	529	{
	530	Assert(!pL2Entry->cRefs);
	531	RTMemPageFree(pL2Entry->paL2Tbl, pImage->cbTable);
	532	RTMemFree(pL2Entry);
	533
	534	pImage->cbL2Cache -= pImage->cbTable;
	535	}
	536
	537	/**
	538	* Inserts an entry in the L2 table cache.
	539	*
	540	* @param pImage The image instance data.
	541	* @param pL2Entry The L2 cache entry to insert.
	542	*/
	543	static void qedL2TblCacheEntryInsert(PQEDIMAGE pImage, PQEDL2CACHEENTRY pL2Entry)
	544	{
	545	Assert(pL2Entry->offL2Tbl > 0);
	546
	547	/* Insert at the top of the LRU list. */
	548	RTListPrepend(&pImage->ListLru, &pL2Entry->NodeLru);
	549
	550	if (RTListIsEmpty(&pImage->ListSearch))
	551	{
	552	RTListAppend(&pImage->ListSearch, &pL2Entry->NodeSearch);
	553	}
	554	else
	555	{
	556	/* Insert into search list. */
[64766]	557	PQEDL2CACHEENTRY pIt;
[38562]	558	pIt = RTListGetFirst(&pImage->ListSearch, QEDL2CACHEENTRY, NodeSearch);
	559	if (pIt->offL2Tbl > pL2Entry->offL2Tbl)
	560	RTListPrepend(&pImage->ListSearch, &pL2Entry->NodeSearch);
	561	else
[38463]	562	{
[38562]	563	bool fInserted = false;
	564
	565	RTListForEach(&pImage->ListSearch, pIt, QEDL2CACHEENTRY, NodeSearch)
[38463]	566	{
[38562]	567	Assert(pIt->offL2Tbl != pL2Entry->offL2Tbl);
	568	if (pIt->offL2Tbl < pL2Entry->offL2Tbl)
	569	{
	570	RTListNodeInsertAfter(&pIt->NodeSearch, &pL2Entry->NodeSearch);
	571	fInserted = true;
	572	break;
	573	}
[38463]	574	}
[64766]	575	Assert(fInserted);
[38463]	576	}
	577	}
	578	}
	579
	580	/**
	581	* Fetches the L2 from the given offset trying the LRU cache first and
	582	* reading it from the image after a cache miss - version for async I/O.
	583	*
	584	* @returns VBox status code.
	585	* @param pImage Image instance data.
	586	* @param pIoCtx The I/O context.
	587	* @param offL2Tbl The offset of the L2 table in the image.
	588	* @param ppL2Entry Where to store the L2 table on success.
	589	*/
	590	static int qedL2TblCacheFetchAsync(PQEDIMAGE pImage, PVDIOCTX pIoCtx,
	591	uint64_t offL2Tbl, PQEDL2CACHEENTRY *ppL2Entry)
	592	{
	593	int rc = VINF_SUCCESS;
	594
	595	/* Try to fetch the L2 table from the cache first. */
	596	PQEDL2CACHEENTRY pL2Entry = qedL2TblCacheRetain(pImage, offL2Tbl);
	597	if (!pL2Entry)
	598	{
	599	pL2Entry = qedL2TblCacheEntryAlloc(pImage);
	600
	601	if (pL2Entry)
	602	{
	603	/* Read from the image. */
	604	PVDMETAXFER pMetaXfer;
	605
	606	pL2Entry->offL2Tbl = offL2Tbl;
[44233]	607	rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage,
	608	offL2Tbl, pL2Entry->paL2Tbl,
	609	pImage->cbTable, pIoCtx,
	610	&pMetaXfer, NULL, NULL);
[38463]	611	if (RT_SUCCESS(rc))
	612	{
[38469]	613	vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
[38463]	614	#if defined(RT_BIG_ENDIAN)
[38562]	615	qedTableConvertToHostEndianess(pL2Entry->paL2Tbl, pImage->cTableEntries);
[38463]	616	#endif
	617	qedL2TblCacheEntryInsert(pImage, pL2Entry);
	618	}
	619	else
	620	{
	621	qedL2TblCacheEntryRelease(pL2Entry);
	622	qedL2TblCacheEntryFree(pImage, pL2Entry);
	623	}
	624	}
	625	else
	626	rc = VERR_NO_MEMORY;
	627	}
	628
	629	if (RT_SUCCESS(rc))
	630	*ppL2Entry = pL2Entry;
	631
	632	return rc;
	633	}
	634
	635	/**
	636	* Return power of 2 or 0 if num error.
	637	*
	638	* @returns The power of 2 or 0 if the given number is not a power of 2.
	639	* @param u32 The number.
	640	*/
	641	static uint32_t qedGetPowerOfTwo(uint32_t u32)
	642	{
	643	if (u32 == 0)
	644	return 0;
	645	uint32_t uPower2 = 0;
	646	while ((u32 & 1) == 0)
	647	{
	648	u32 >>= 1;
	649	uPower2++;
	650	}
	651	return u32 == 1 ? uPower2 : 0;
	652	}
	653
	654	/**
	655	* Sets the L1, L2 and offset bitmasks and L1 and L2 bit shift members.
	656	*
	657	* @param pImage The image instance data.
	658	*/
	659	static void qedTableMasksInit(PQEDIMAGE pImage)
	660	{
	661	uint32_t cClusterBits, cTableBits;
	662
	663	cClusterBits = qedGetPowerOfTwo(pImage->cbCluster);
	664	cTableBits = qedGetPowerOfTwo(pImage->cTableEntries);
	665
	666	Assert(cClusterBits + 2 * cTableBits <= 64);
	667
	668	pImage->fOffsetMask = ((uint64_t)pImage->cbCluster - 1);
	669	pImage->fL2Mask = ((uint64_t)pImage->cTableEntries - 1) << cClusterBits;
	670	pImage->cL2Shift = cClusterBits;
	671	pImage->fL1Mask = ((uint64_t)pImage->cTableEntries - 1) << (cClusterBits + cTableBits);
	672	pImage->cL1Shift = cClusterBits + cTableBits;
	673	}
	674
	675	/**
[44940]	676	* Converts a given logical offset into the
[38463]	677	*
	678	* @param pImage The image instance data.
	679	* @param off The logical offset to convert.
	680	* @param pidxL1 Where to store the index in the L1 table on success.
	681	* @param pidxL2 Where to store the index in the L2 table on success.
	682	* @param poffCluster Where to store the offset in the cluster on success.
	683	*/
	684	DECLINLINE(void) qedConvertLogicalOffset(PQEDIMAGE pImage, uint64_t off, uint32_t *pidxL1,
	685	uint32_t pidxL2, uint32_t poffCluster)
	686	{
	687	AssertPtr(pidxL1);
	688	AssertPtr(pidxL2);
	689	AssertPtr(poffCluster);
	690
	691	*poffCluster = off & pImage->fOffsetMask;
	692	*pidxL1 = (off & pImage->fL1Mask) >> pImage->cL1Shift;
	693	*pidxL2 = (off & pImage->fL2Mask) >> pImage->cL2Shift;
	694	}
	695
	696	/**
	697	* Converts Cluster size to a byte size.
	698	*
	699	* @returns Number of bytes derived from the given number of clusters.
	700	* @param pImage The image instance data.
	701	* @param cClusters The clusters to convert.
	702	*/
	703	DECLINLINE(uint64_t) qedCluster2Byte(PQEDIMAGE pImage, uint64_t cClusters)
	704	{
	705	return cClusters * pImage->cbCluster;
	706	}
	707
	708	/**
	709	* Converts number of bytes to cluster size rounding to the next cluster.
	710	*
	711	* @returns Number of bytes derived from the given number of clusters.
	712	* @param pImage The image instance data.
	713	* @param cb Number of bytes to convert.
	714	*/
	715	DECLINLINE(uint64_t) qedByte2Cluster(PQEDIMAGE pImage, uint64_t cb)
	716	{
	717	return cb / pImage->cbCluster + (cb % pImage->cbCluster ? 1 : 0);
	718	}
	719
	720	/**
	721	* Allocates a new cluster in the image.
	722	*
	723	* @returns The start offset of the new cluster in the image.
	724	* @param pImage The image instance data.
[64272]	725	* @param cClusters Number of clusters to allocate.
[38463]	726	*/
	727	DECLINLINE(uint64_t) qedClusterAllocate(PQEDIMAGE pImage, uint32_t cClusters)
	728	{
	729	uint64_t offCluster;
	730
	731	offCluster = pImage->cbImage;
	732	pImage->cbImage += cClusters*pImage->cbCluster;
	733
	734	return offCluster;
	735	}
	736
	737	/**
	738	* Returns the real image offset for a given cluster or an error if the cluster is not
	739	* yet allocated.
	740	*
	741	* @returns VBox status code.
	742	* VERR_VD_BLOCK_FREE if the cluster is not yet allocated.
	743	* @param pImage The image instance data.
[44252]	744	* @param pIoCtx The I/O context.
[38463]	745	* @param idxL1 The L1 index.
	746	* @param idxL2 The L2 index.
	747	* @param offCluster Offset inside the cluster.
	748	* @param poffImage Where to store the image offset on success;
	749	*/
[44252]	750	static int qedConvertToImageOffset(PQEDIMAGE pImage, PVDIOCTX pIoCtx,
	751	uint32_t idxL1, uint32_t idxL2,
[38463]	752	uint32_t offCluster, uint64_t *poffImage)
	753	{
	754	int rc = VERR_VD_BLOCK_FREE;
	755
	756	AssertReturn(idxL1 < pImage->cTableEntries, VERR_INVALID_PARAMETER);
	757	AssertReturn(idxL2 < pImage->cTableEntries, VERR_INVALID_PARAMETER);
	758
	759	if (pImage->paL1Table[idxL1])
	760	{
	761	PQEDL2CACHEENTRY pL2Entry;
	762
	763	rc = qedL2TblCacheFetchAsync(pImage, pIoCtx, pImage->paL1Table[idxL1],
	764	&pL2Entry);
	765	if (RT_SUCCESS(rc))
	766	{
	767	/* Get real file offset. */
	768	if (pL2Entry->paL2Tbl[idxL2])
	769	*poffImage = pL2Entry->paL2Tbl[idxL2] + offCluster;
	770	else
	771	rc = VERR_VD_BLOCK_FREE;
	772
	773	qedL2TblCacheEntryRelease(pL2Entry);
	774	}
	775	}
	776
	777	return rc;
	778	}
	779
[63741]	780	/**
	781	* Write the given table to image converting to the image endianess if required.
	782	*
	783	* @returns VBox status code.
	784	* @param pImage The image instance data.
	785	* @param pIoCtx The I/O context.
	786	* @param offTbl The offset the table should be written to.
	787	* @param paTbl The table to write.
	788	* @param pfnComplete Callback called when the write completes.
	789	* @param pvUser Opaque user data to pass in the completion callback.
	790	*/
	791	static int qedTblWrite(PQEDIMAGE pImage, PVDIOCTX pIoCtx, uint64_t offTbl, uint64_t *paTbl,
	792	PFNVDXFERCOMPLETED pfnComplete, void *pvUser)
	793	{
	794	int rc = VINF_SUCCESS;
[38463]	795
[63741]	796	#if defined(RT_BIG_ENDIAN)
	797	uint64_t paTblImg = (uint64_t )RTMemAllocZ(pImage->cbTable);
	798	if (paTblImg)
	799	{
	800	qedTableConvertFromHostEndianess(paTblImg, paTbl,
	801	pImage->cTableEntries);
	802	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
	803	offTbl, paTblImg, pImage->cbTable,
	804	pIoCtx, pfnComplete, pvUser);
	805	RTMemFree(paTblImg);
	806	}
	807	else
	808	rc = VERR_NO_MEMORY;
	809	#else
	810	/* Write table directly. */
	811	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
	812	offTbl, paTbl, pImage->cbTable, pIoCtx,
	813	pfnComplete, pvUser);
	814	#endif
	815
	816	return rc;
	817	}
	818
[38463]	819	/**
	820	* Internal. Flush image data to disk.
	821	*/
	822	static int qedFlushImage(PQEDIMAGE pImage)
	823	{
	824	int rc = VINF_SUCCESS;
	825
	826	if ( pImage->pStorage
	827	&& !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
	828	{
	829	QedHeader Header;
	830
	831	Assert(!(pImage->cbTable % pImage->cbCluster));
	832	#if defined(RT_BIG_ENDIAN)
	833	uint64_t paL1TblImg = (uint64_t )RTMemAllocZ(pImage->cbTable);
	834	if (paL1TblImg)
	835	{
[38562]	836	qedTableConvertFromHostEndianess(paL1TblImg, pImage->paL1Table,
[38463]	837	pImage->cTableEntries);
[38469]	838	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
	839	pImage->offL1Table, paL1TblImg,
[51680]	840	pImage->cbTable);
[38463]	841	RTMemFree(paL1TblImg);
	842	}
	843	else
	844	rc = VERR_NO_MEMORY;
	845	#else
	846	/* Write L1 table directly. */
[38469]	847	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->offL1Table,
[44233]	848	pImage->paL1Table, pImage->cbTable);
[38463]	849	#endif
	850	if (RT_SUCCESS(rc))
	851	{
	852	/* Write header. */
	853	qedHdrConvertFromHostEndianess(pImage, &Header);
[38469]	854	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0, &Header,
[44233]	855	sizeof(Header));
[38463]	856	if (RT_SUCCESS(rc))
[38469]	857	rc = vdIfIoIntFileFlushSync(pImage->pIfIo, pImage->pStorage);
[38463]	858	}
	859	}
	860
	861	return rc;
	862	}
	863
	864	/**
	865	* Checks whether the given cluster offset is valid.
	866	*
	867	* @returns Whether the given cluster offset is valid.
	868	* @param offCluster The table offset to check.
	869	* @param cbFile The real file size of the image.
	870	* @param cbCluster The cluster size in bytes.
	871	*/
	872	DECLINLINE(bool) qedIsClusterOffsetValid(uint64_t offCluster, uint64_t cbFile, size_t cbCluster)
	873	{
	874	return (offCluster <= cbFile - cbCluster)
	875	&& !(offCluster & (cbCluster - 1));
	876	}
	877
	878	/**
	879	* Checks whether the given table offset is valid.
	880	*
	881	* @returns Whether the given table offset is valid.
	882	* @param offTbl The table offset to check.
	883	* @param cbFile The real file size of the image.
	884	* @param cbTable The table size in bytes.
	885	* @param cbCluster The cluster size in bytes.
	886	*/
	887	DECLINLINE(bool) qedIsTblOffsetValid(uint64_t offTbl, uint64_t cbFile, size_t cbTable, size_t cbCluster)
	888	{
	889	return (offTbl <= cbFile - cbTable)
	890	&& !(offTbl & (cbCluster - 1));
	891	}
	892
	893	/**
	894	* Sets the specified range in the cluster bitmap checking whether any of the clusters is already
	895	* used before.
	896	*
	897	* @returns Whether the range was clear and is set now.
	898	* @param pvClusterBitmap The cluster bitmap to use.
	899	* @param offClusterStart The first cluster to check and set.
	900	* @param offClusterEnd The first cluster to not check and set anymore.
	901	*/
	902	static bool qedClusterBitmapCheckAndSet(void *pvClusterBitmap, uint32_t offClusterStart, uint32_t offClusterEnd)
	903	{
	904	for (uint32_t offCluster = offClusterStart; offCluster < offClusterEnd; offCluster++)
	905	if (ASMBitTest(pvClusterBitmap, offCluster))
	906	return false;
	907
	908	ASMBitSetRange(pvClusterBitmap, offClusterStart, offClusterEnd);
	909	return true;
	910	}
	911
	912	/**
	913	* Checks the given image for consistency, usually called when the
	914	* QED_FEATURE_NEED_CHECK bit is set.
	915	*
	916	* @returns VBox status code.
	917	* @retval VINF_SUCCESS when the image can be accessed.
	918	* @param pImage The image instance data.
	919	* @param pHeader The header to use for checking.
	920	*
	921	* @note It is not required that the image state is fully initialized Only
	922	* The I/O interface and storage handle need to be valid.
	923	* @note The header must be converted to the host CPU endian format already
	924	* and should be validated already.
	925	*/
	926	static int qedCheckImage(PQEDIMAGE pImage, PQedHeader pHeader)
	927	{
	928	uint64_t cbFile;
[38469]	929	uint32_t cbTable;
[38463]	930	uint32_t cTableEntries;
	931	uint64_t *paL1Tbl = NULL;
	932	uint64_t *paL2Tbl = NULL;
	933	void *pvClusterBitmap = NULL;
	934	uint32_t offClusterStart;
	935	int rc = VINF_SUCCESS;
	936
	937	pImage->cbCluster = pHeader->u32ClusterSize;
	938	cbTable = pHeader->u32TableSize * pHeader->u32ClusterSize;
	939	cTableEntries = cbTable / sizeof(uint64_t);
	940
	941	do
	942	{
[38469]	943	rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
[38463]	944	if (RT_FAILURE(rc))
	945	{
[38469]	946	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	947	N_("Qed: Querying the file size of image '%s' failed"),
	948	pImage->pszFilename);
[38463]	949	break;
	950	}
	951
	952	/* Allocate L1 table. */
	953	paL1Tbl = (uint64_t *)RTMemAllocZ(cbTable);
	954	if (!paL1Tbl)
	955	{
[38469]	956	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
[38463]	957	N_("Qed: Allocating memory for the L1 table for image '%s' failed"),
	958	pImage->pszFilename);
	959	break;
	960	}
	961
	962	paL2Tbl = (uint64_t *)RTMemAllocZ(cbTable);
	963	if (!paL2Tbl)
	964	{
[38469]	965	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
	966	N_("Qed: Allocating memory for the L2 table for image '%s' failed"),
	967	pImage->pszFilename);
[38463]	968	break;
	969	}
	970
	971	pvClusterBitmap = RTMemAllocZ(cbFile / pHeader->u32ClusterSize / 8);
	972	if (!pvClusterBitmap)
	973	{
[38469]	974	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
	975	N_("Qed: Allocating memory for the cluster bitmap for image '%s' failed"),
	976	pImage->pszFilename);
[38463]	977	break;
	978	}
	979
	980	/* Validate L1 table offset. */
	981	if (!qedIsTblOffsetValid(pHeader->u64OffL1Table, cbFile, cbTable, pHeader->u32ClusterSize))
	982	{
[38469]	983	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	984	N_("Qed: L1 table offset of image '%s' is corrupt (%llu)"),
	985	pImage->pszFilename, pHeader->u64OffL1Table);
[38463]	986	break;
	987	}
	988
	989	/* Read L1 table. */
[38469]	990	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
[44233]	991	pHeader->u64OffL1Table, paL1Tbl, cbTable);
[38463]	992	if (RT_FAILURE(rc))
	993	{
[38469]	994	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	995	N_("Qed: Reading the L1 table from image '%s' failed"),
	996	pImage->pszFilename);
[38463]	997	break;
	998	}
	999
	1000	/* Mark the L1 table in cluster bitmap. */
	1001	ASMBitSet(pvClusterBitmap, 0); /* Header is always in cluster 0. */
	1002	offClusterStart = qedByte2Cluster(pImage, pHeader->u64OffL1Table);
	1003	bool fSet = qedClusterBitmapCheckAndSet(pvClusterBitmap, offClusterStart, offClusterStart + pHeader->u32TableSize);
	1004	Assert(fSet);
	1005
	1006	/* Scan the L1 and L2 tables for invalid entries. */
	1007	qedTableConvertToHostEndianess(paL1Tbl, cTableEntries);
	1008
	1009	for (unsigned iL1 = 0; iL1 < cTableEntries; iL1++)
	1010	{
	1011	if (!paL1Tbl[iL1])
	1012	continue; /* Skip unallocated clusters. */
	1013
	1014	if (!qedIsTblOffsetValid(paL1Tbl[iL1], cbFile, cbTable, pHeader->u32ClusterSize))
	1015	{
[38469]	1016	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1017	N_("Qed: Entry %d of the L1 table from image '%s' is invalid (%llu)"),
	1018	iL1, pImage->pszFilename, paL1Tbl[iL1]);
[38463]	1019	break;
	1020	}
	1021
	1022	/* Now check that the clusters are not allocated already. */
	1023	offClusterStart = qedByte2Cluster(pImage, paL1Tbl[iL1]);
	1024	fSet = qedClusterBitmapCheckAndSet(pvClusterBitmap, offClusterStart, offClusterStart + pHeader->u32TableSize);
	1025	if (!fSet)
	1026	{
[38469]	1027	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1028	N_("Qed: Entry %d of the L1 table from image '%s' points to a already used cluster (%llu)"),
	1029	iL1, pImage->pszFilename, paL1Tbl[iL1]);
[38463]	1030	break;
	1031	}
	1032
	1033	/* Read the linked L2 table and check it. */
[38469]	1034	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
[44233]	1035	paL1Tbl[iL1], paL2Tbl, cbTable);
[38463]	1036	if (RT_FAILURE(rc))
	1037	{
[38469]	1038	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1039	N_("Qed: Reading the L2 table from image '%s' failed"),
	1040	pImage->pszFilename);
[38463]	1041	break;
	1042	}
	1043
	1044	/* Check all L2 entries. */
	1045	for (unsigned iL2 = 0; iL2 < cTableEntries; iL2++)
	1046	{
	1047	if (paL2Tbl[iL2])
	1048	continue; /* Skip unallocated clusters. */
	1049
	1050	if (!qedIsClusterOffsetValid(paL2Tbl[iL2], cbFile, pHeader->u32ClusterSize))
	1051	{
[38469]	1052	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1053	N_("Qed: Entry %d of the L2 table from image '%s' is invalid (%llu)"),
	1054	iL2, pImage->pszFilename, paL2Tbl[iL2]);
[38463]	1055	break;
	1056	}
	1057
	1058	/* Now check that the clusters are not allocated already. */
	1059	offClusterStart = qedByte2Cluster(pImage, paL2Tbl[iL2]);
	1060	fSet = qedClusterBitmapCheckAndSet(pvClusterBitmap, offClusterStart, offClusterStart + 1);
	1061	if (!fSet)
	1062	{
[38469]	1063	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1064	N_("Qed: Entry %d of the L2 table from image '%s' points to a already used cluster (%llu)"),
	1065	iL2, pImage->pszFilename, paL2Tbl[iL2]);
[38463]	1066	break;
	1067	}
	1068	}
	1069	}
	1070	} while(0);
	1071
	1072	if (paL1Tbl)
	1073	RTMemFree(paL1Tbl);
	1074	if (paL2Tbl)
	1075	RTMemFree(paL2Tbl);
	1076	if (pvClusterBitmap)
	1077	RTMemFree(pvClusterBitmap);
	1078
	1079	return rc;
	1080	}
	1081
	1082	/**
	1083	* Internal. Free all allocated space for representing an image except pImage,
	1084	* and optionally delete the image from disk.
	1085	*/
	1086	static int qedFreeImage(PQEDIMAGE pImage, bool fDelete)
	1087	{
	1088	int rc = VINF_SUCCESS;
	1089
	1090	/* Freeing a never allocated image (e.g. because the open failed) is
	1091	* not signalled as an error. After all nothing bad happens. */
	1092	if (pImage)
	1093	{
	1094	if (pImage->pStorage)
	1095	{
	1096	/* No point updating the file that is deleted anyway. */
	1097	if (!fDelete)
	1098	qedFlushImage(pImage);
	1099
[46613]	1100	rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
[38463]	1101	pImage->pStorage = NULL;
	1102	}
	1103
	1104	if (pImage->paL1Table)
	1105	RTMemFree(pImage->paL1Table);
	1106
	1107	if (pImage->pszBackingFilename)
[44940]	1108	{
[77232]	1109	RTStrFree(pImage->pszBackingFilename);
[44940]	1110	pImage->pszBackingFilename = NULL;
	1111	}
[38463]	1112
	1113	qedL2TblCacheDestroy(pImage);
	1114
	1115	if (fDelete && pImage->pszFilename)
[38469]	1116	vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
[38463]	1117	}
	1118
	1119	LogFlowFunc(("returns %Rrc\n", rc));
	1120	return rc;
	1121	}
	1122
	1123	/**
	1124	* Internal: Open an image, constructing all necessary data structures.
	1125	*/
	1126	static int qedOpenImage(PQEDIMAGE pImage, unsigned uOpenFlags)
	1127	{
	1128	pImage->uOpenFlags = uOpenFlags;
[63789]	1129
[38469]	1130	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
	1131	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
	1132	AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
[38463]	1133
	1134	/*
[51625]	1135	* Create the L2 cache before opening the image so we can call qedFreeImage()
	1136	* even if opening the image file fails.
	1137	*/
[63792]	1138	int rc = qedL2TblCacheCreate(pImage);
	1139	if (RT_SUCCESS(rc))
[51625]	1140	{
[63792]	1141	/* Open the image. */
	1142	rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
	1143	VDOpenFlagsToFileOpenFlags(uOpenFlags,
	1144	false /* fCreate */),
	1145	&pImage->pStorage);
	1146	if (RT_SUCCESS(rc))
[38463]	1147	{
[63792]	1148	uint64_t cbFile;
	1149	rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
	1150	if ( RT_SUCCESS(rc)
	1151	&& cbFile > sizeof(QedHeader))
[38463]	1152	{
[63792]	1153	QedHeader Header;
[38463]	1154
[63792]	1155	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, 0, &Header, sizeof(Header));
[38463]	1156	if ( RT_SUCCESS(rc)
[63792]	1157	&& qedHdrConvertToHostEndianess(&Header))
[38463]	1158	{
[63792]	1159	if ( !(Header.u64FeatureFlags & ~QED_FEATURE_MASK)
	1160	&& !(Header.u64FeatureFlags & QED_FEATURE_BACKING_FILE_NO_PROBE))
[38463]	1161	{
[63792]	1162	if (Header.u64FeatureFlags & QED_FEATURE_NEED_CHECK)
	1163	{
	1164	/* Image needs checking. */
	1165	if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
	1166	rc = qedCheckImage(pImage, &Header);
	1167	else
	1168	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1169	N_("Qed: Image '%s' needs checking but is opened readonly"),
	1170	pImage->pszFilename);
	1171	}
[38463]	1172
[63792]	1173	if ( RT_SUCCESS(rc)
	1174	&& (Header.u64FeatureFlags & QED_FEATURE_BACKING_FILE))
	1175	{
	1176	/* Load backing filename from image. */
[77232]	1177	pImage->pszBackingFilename = RTStrAlloc(Header.u32BackingFilenameSize + 1); /* +1 for \0 terminator. */
[63792]	1178	if (pImage->pszBackingFilename)
	1179	{
[77232]	1180	RT_BZERO(pImage->pszBackingFilename, Header.u32BackingFilenameSize + 1);
[63792]	1181	pImage->cbBackingFilename = Header.u32BackingFilenameSize;
	1182	pImage->offBackingFilename = Header.u32OffBackingFilename;
	1183	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
	1184	Header.u32OffBackingFilename, pImage->pszBackingFilename,
	1185	Header.u32BackingFilenameSize);
[77232]	1186	if (RT_SUCCESS(rc))
	1187	rc = RTStrValidateEncoding(pImage->pszBackingFilename);
[63792]	1188	}
	1189	else
[77232]	1190	rc = VERR_NO_STR_MEMORY;
[63792]	1191	}
[38463]	1192
	1193	if (RT_SUCCESS(rc))
	1194	{
[63792]	1195	pImage->cbImage = cbFile;
	1196	pImage->cbCluster = Header.u32ClusterSize;
	1197	pImage->cbTable = Header.u32TableSize * pImage->cbCluster;
	1198	pImage->cTableEntries = pImage->cbTable / sizeof(uint64_t);
	1199	pImage->offL1Table = Header.u64OffL1Table;
	1200	pImage->cbSize = Header.u64Size;
	1201	qedTableMasksInit(pImage);
[51625]	1202
[63792]	1203	/* Allocate L1 table. */
	1204	pImage->paL1Table = (uint64_t *)RTMemAllocZ(pImage->cbTable);
	1205	if (pImage->paL1Table)
	1206	{
	1207	/* Read from the image. */
	1208	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
	1209	pImage->offL1Table, pImage->paL1Table,
	1210	pImage->cbTable);
	1211	if (RT_SUCCESS(rc))
	1212	{
	1213	qedTableConvertToHostEndianess(pImage->paL1Table, pImage->cTableEntries);
	1214
	1215	/* If the consistency check succeeded, clear the flag by flushing the image. */
	1216	if (Header.u64FeatureFlags & QED_FEATURE_NEED_CHECK)
	1217	rc = qedFlushImage(pImage);
	1218	}
	1219	else
	1220	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1221	N_("Qed: Reading the L1 table for image '%s' failed"),
	1222	pImage->pszFilename);
	1223	}
	1224	else
	1225	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
	1226	N_("Qed: Out of memory allocating L1 table for image '%s'"),
	1227	pImage->pszFilename);
[38463]	1228	}
	1229	}
	1230	else
[63792]	1231	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1232	N_("Qed: The image '%s' makes use of unsupported features"),
[38469]	1233	pImage->pszFilename);
[38463]	1234	}
[63792]	1235	else if (RT_SUCCESS(rc))
	1236	rc = VERR_VD_GEN_INVALID_HEADER;
[38463]	1237	}
[63792]	1238	else if (RT_SUCCESS(rc))
	1239	rc = VERR_VD_GEN_INVALID_HEADER;
[38463]	1240	}
[63792]	1241	/* else: Do NOT signal an appropriate error here, as the VD layer has the
	1242	* choice of retrying the open if it failed. */
[38463]	1243	}
	1244	else
[63792]	1245	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1246	N_("Qed: Creating the L2 table cache for image '%s' failed"),
	1247	pImage->pszFilename);
[38463]	1248
[66486]	1249	if (RT_SUCCESS(rc))
	1250	{
	1251	PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
	1252	pImage->RegionList.fFlags = 0;
	1253	pImage->RegionList.cRegions = 1;
	1254
	1255	pRegion->offRegion = 0; /* Disk start. */
	1256	pRegion->cbBlock = 512;
	1257	pRegion->enmDataForm = VDREGIONDATAFORM_RAW;
	1258	pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
	1259	pRegion->cbData = 512;
	1260	pRegion->cbMetadata = 0;
	1261	pRegion->cRegionBlocksOrBytes = pImage->cbSize;
	1262	}
	1263	else
[38463]	1264	qedFreeImage(pImage, false);
	1265	return rc;
	1266	}
	1267
	1268	/**
	1269	* Internal: Create a qed image.
	1270	*/
	1271	static int qedCreateImage(PQEDIMAGE pImage, uint64_t cbSize,
	1272	unsigned uImageFlags, const char *pszComment,
	1273	PCVDGEOMETRY pPCHSGeometry,
	1274	PCVDGEOMETRY pLCHSGeometry, unsigned uOpenFlags,
[63792]	1275	PVDINTERFACEPROGRESS pIfProgress,
[38463]	1276	unsigned uPercentStart, unsigned uPercentSpan)
	1277	{
[62746]	1278	RT_NOREF1(pszComment);
[38463]	1279	int rc;
	1280
[63792]	1281	if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
[38463]	1282	{
[63792]	1283	rc = qedL2TblCacheCreate(pImage);
	1284	if (RT_SUCCESS(rc))
	1285	{
	1286	pImage->uOpenFlags = uOpenFlags & ~VD_OPEN_FLAGS_READONLY;
	1287	pImage->uImageFlags = uImageFlags;
	1288	pImage->PCHSGeometry = *pPCHSGeometry;
	1289	pImage->LCHSGeometry = *pLCHSGeometry;
[38463]	1290
[63792]	1291	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
	1292	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
	1293	AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
[38463]	1294
[63792]	1295	/* Create image file. */
	1296	uint32_t fOpen = VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags, true /* fCreate */);
	1297	rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename, fOpen, &pImage->pStorage);
	1298	if (RT_SUCCESS(rc))
	1299	{
	1300	/* Init image state. */
	1301	pImage->cbSize = cbSize;
	1302	pImage->cbCluster = QED_CLUSTER_SIZE_DEFAULT;
	1303	pImage->cbTable = qedCluster2Byte(pImage, QED_TABLE_SIZE_DEFAULT);
	1304	pImage->cTableEntries = pImage->cbTable / sizeof(uint64_t);
	1305	pImage->offL1Table = qedCluster2Byte(pImage, 1); /* Cluster 0 is the header. */
	1306	pImage->cbImage = (1 * pImage->cbCluster) + pImage->cbTable; /* Header + L1 table size. */
	1307	pImage->cbBackingFilename = 0;
	1308	pImage->offBackingFilename = 0;
	1309	qedTableMasksInit(pImage);
[38463]	1310
[63792]	1311	/* Init L1 table. */
	1312	pImage->paL1Table = (uint64_t *)RTMemAllocZ(pImage->cbTable);
	1313	if (RT_LIKELY(pImage->paL1Table))
	1314	{
	1315	vdIfProgress(pIfProgress, uPercentStart + uPercentSpan * 98 / 100);
	1316	rc = qedFlushImage(pImage);
	1317	}
	1318	else
	1319	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("Qed: cannot allocate memory for L1 table of image '%s'"),
	1320	pImage->pszFilename);
	1321	}
	1322	else
	1323	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Qed: cannot create image '%s'"), pImage->pszFilename);
	1324	}
	1325	else
	1326	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Qed: Failed to create L2 cache for image '%s'"),
	1327	pImage->pszFilename);
[38463]	1328	}
[63792]	1329	else
	1330	rc = vdIfError(pImage->pIfError, VERR_VD_INVALID_TYPE, RT_SRC_POS, N_("Qed: cannot create fixed image '%s'"), pImage->pszFilename);
[38463]	1331
[63792]	1332	if (RT_SUCCESS(rc))
[66486]	1333	{
	1334	PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
	1335	pImage->RegionList.fFlags = 0;
	1336	pImage->RegionList.cRegions = 1;
	1337
	1338	pRegion->offRegion = 0; /* Disk start. */
	1339	pRegion->cbBlock = 512;
	1340	pRegion->enmDataForm = VDREGIONDATAFORM_RAW;
	1341	pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
	1342	pRegion->cbData = 512;
	1343	pRegion->cbMetadata = 0;
	1344	pRegion->cRegionBlocksOrBytes = pImage->cbSize;
	1345
[63792]	1346	vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
[66486]	1347	}
[63792]	1348	else
	1349	qedFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
[38463]	1350
	1351	return rc;
	1352	}
	1353
	1354	/**
	1355	* Rollback anything done during async cluster allocation.
	1356	*
	1357	* @returns VBox status code.
	1358	* @param pImage The image instance data.
	1359	* @param pIoCtx The I/O context.
	1360	* @param pClusterAlloc The cluster allocation to rollback.
	1361	*/
	1362	static int qedAsyncClusterAllocRollback(PQEDIMAGE pImage, PVDIOCTX pIoCtx, PQEDCLUSTERASYNCALLOC pClusterAlloc)
	1363	{
[62746]	1364	RT_NOREF1(pIoCtx);
[38463]	1365	int rc = VINF_SUCCESS;
	1366
	1367	switch (pClusterAlloc->enmAllocState)
	1368	{
	1369	case QEDCLUSTERASYNCALLOCSTATE_L2_ALLOC:
	1370	case QEDCLUSTERASYNCALLOCSTATE_L2_LINK:
	1371	{
[63741]	1372	/* Revert the L1 table entry */
	1373	pImage->paL1Table[pClusterAlloc->idxL1] = 0;
[64832]	1374	pImage->pL2TblAlloc = NULL;
[63741]	1375
	1376	/* Assumption right now is that the L1 table is not modified on storage if the link fails. */
[38469]	1377	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, pClusterAlloc->cbImageOld);
[38463]	1378	qedL2TblCacheEntryRelease(pClusterAlloc->pL2Entry); /* Release L2 cache entry. */
[64832]	1379	Assert(!pClusterAlloc->pL2Entry->cRefs);
[38463]	1380	qedL2TblCacheEntryFree(pImage, pClusterAlloc->pL2Entry); /* Free it, it is not in the cache yet. */
[38562]	1381	break;
[38463]	1382	}
	1383	case QEDCLUSTERASYNCALLOCSTATE_USER_ALLOC:
	1384	case QEDCLUSTERASYNCALLOCSTATE_USER_LINK:
	1385	{
	1386	/* Assumption right now is that the L2 table is not modified if the link fails. */
[63741]	1387	pClusterAlloc->pL2Entry->paL2Tbl[pClusterAlloc->idxL2] = 0;
[38469]	1388	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, pClusterAlloc->cbImageOld);
[38463]	1389	qedL2TblCacheEntryRelease(pClusterAlloc->pL2Entry); /* Release L2 cache entry. */
[38562]	1390	break;
[38463]	1391	}
	1392	default:
	1393	AssertMsgFailed(("Invalid cluster allocation state %d\n", pClusterAlloc->enmAllocState));
	1394	rc = VERR_INVALID_STATE;
	1395	}
	1396
	1397	RTMemFree(pClusterAlloc);
	1398	return rc;
	1399	}
	1400
	1401	/**
	1402	* Updates the state of the async cluster allocation.
	1403	*
	1404	* @returns VBox status code.
	1405	* @param pBackendData The opaque backend data.
	1406	* @param pIoCtx I/O context associated with this request.
	1407	* @param pvUser Opaque user data passed during a read/write request.
	1408	* @param rcReq Status code for the completed request.
	1409	*/
	1410	static DECLCALLBACK(int) qedAsyncClusterAllocUpdate(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq)
	1411	{
	1412	int rc = VINF_SUCCESS;
	1413	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1414	PQEDCLUSTERASYNCALLOC pClusterAlloc = (PQEDCLUSTERASYNCALLOC)pvUser;
	1415
	1416	if (RT_FAILURE(rcReq))
	1417	return qedAsyncClusterAllocRollback(pImage, pIoCtx, pClusterAlloc);
	1418
	1419	AssertPtr(pClusterAlloc->pL2Entry);
	1420
	1421	switch (pClusterAlloc->enmAllocState)
	1422	{
	1423	case QEDCLUSTERASYNCALLOCSTATE_L2_ALLOC:
	1424	{
[63741]	1425	/* Update the link in the in memory L1 table now. */
	1426	pImage->paL1Table[pClusterAlloc->idxL1] = pClusterAlloc->pL2Entry->offL2Tbl;
[38463]	1427
	1428	/* Update the link in the on disk L1 table now. */
	1429	pClusterAlloc->enmAllocState = QEDCLUSTERASYNCALLOCSTATE_L2_LINK;
[63741]	1430	rc = qedTblWrite(pImage, pIoCtx, pImage->offL1Table, pImage->paL1Table,
	1431	qedAsyncClusterAllocUpdate, pClusterAlloc);
[38463]	1432	if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1433	break;
	1434	else if (RT_FAILURE(rc))
	1435	{
	1436	/* Rollback. */
	1437	qedAsyncClusterAllocRollback(pImage, pIoCtx, pClusterAlloc);
	1438	break;
	1439	}
	1440	}
[69046]	1441	RT_FALL_THRU();
[38463]	1442	case QEDCLUSTERASYNCALLOCSTATE_L2_LINK:
	1443	{
	1444	/* L2 link updated in L1 , save L2 entry in cache and allocate new user data cluster. */
	1445	uint64_t offData = qedClusterAllocate(pImage, 1);
	1446
[64832]	1447	pImage->pL2TblAlloc = NULL;
[38463]	1448	qedL2TblCacheEntryInsert(pImage, pClusterAlloc->pL2Entry);
	1449
	1450	pClusterAlloc->enmAllocState = QEDCLUSTERASYNCALLOCSTATE_USER_ALLOC;
	1451	pClusterAlloc->cbImageOld = offData;
	1452	pClusterAlloc->offClusterNew = offData;
	1453
	1454	/* Write data. */
[44233]	1455	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
	1456	offData, pIoCtx, pClusterAlloc->cbToWrite,
	1457	qedAsyncClusterAllocUpdate, pClusterAlloc);
[38463]	1458	if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1459	break;
	1460	else if (RT_FAILURE(rc))
	1461	{
	1462	qedAsyncClusterAllocRollback(pImage, pIoCtx, pClusterAlloc);
	1463	RTMemFree(pClusterAlloc);
	1464	break;
	1465	}
	1466	}
[69046]	1467	RT_FALL_THRU();
[38463]	1468	case QEDCLUSTERASYNCALLOCSTATE_USER_ALLOC:
	1469	{
	1470	pClusterAlloc->enmAllocState = QEDCLUSTERASYNCALLOCSTATE_USER_LINK;
[63741]	1471	pClusterAlloc->pL2Entry->paL2Tbl[pClusterAlloc->idxL2] = pClusterAlloc->offClusterNew;
[38463]	1472
	1473	/* Link L2 table and update it. */
[63741]	1474	rc = qedTblWrite(pImage, pIoCtx, pImage->paL1Table[pClusterAlloc->idxL1],
	1475	pClusterAlloc->pL2Entry->paL2Tbl,
	1476	qedAsyncClusterAllocUpdate, pClusterAlloc);
[38463]	1477	if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1478	break;
	1479	else if (RT_FAILURE(rc))
	1480	{
	1481	qedAsyncClusterAllocRollback(pImage, pIoCtx, pClusterAlloc);
	1482	RTMemFree(pClusterAlloc);
	1483	break;
	1484	}
	1485	}
[69046]	1486	RT_FALL_THRU();
[38463]	1487	case QEDCLUSTERASYNCALLOCSTATE_USER_LINK:
	1488	{
	1489	/* Everything done without errors, signal completion. */
	1490	qedL2TblCacheEntryRelease(pClusterAlloc->pL2Entry);
	1491	RTMemFree(pClusterAlloc);
	1492	rc = VINF_SUCCESS;
	1493	break;
	1494	}
	1495	default:
	1496	AssertMsgFailed(("Invalid async cluster allocation state %d\n",
	1497	pClusterAlloc->enmAllocState));
	1498	}
	1499
	1500	return rc;
	1501	}
	1502
[63802]	1503	/** @copydoc VDIMAGEBACKEND::pfnProbe */
	1504	static DECLCALLBACK(int) qedProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
[79965]	1505	PVDINTERFACE pVDIfsImage, VDTYPE enmDesiredType, VDTYPE *penmType)
[38463]	1506	{
[79965]	1507	RT_NOREF(pVDIfsDisk, enmDesiredType);
[38463]	1508	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
	1509	PVDIOSTORAGE pStorage = NULL;
	1510	int rc = VINF_SUCCESS;
	1511
	1512	/* Get I/O interface. */
[38469]	1513	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
	1514	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
[90802]	1515	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
	1516	AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
[38463]	1517
[90802]	1518
[38463]	1519	/*
	1520	* Open the file and read the footer.
	1521	*/
[38469]	1522	rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
	1523	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
	1524	false /* fCreate */),
	1525	&pStorage);
[38463]	1526	if (RT_SUCCESS(rc))
[62746]	1527	{
[63792]	1528	uint64_t cbFile;
	1529
[38469]	1530	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
[38463]	1531	if ( RT_SUCCESS(rc)
[62746]	1532	&& cbFile > sizeof(QedHeader))
[38463]	1533	{
[62746]	1534	QedHeader Header;
	1535
	1536	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &Header, sizeof(Header));
	1537	if ( RT_SUCCESS(rc)
	1538	&& qedHdrConvertToHostEndianess(&Header))
	1539	*penmType = VDTYPE_HDD;
	1540	else
	1541	rc = VERR_VD_GEN_INVALID_HEADER;
[38463]	1542	}
	1543	else
	1544	rc = VERR_VD_GEN_INVALID_HEADER;
	1545	}
	1546
	1547	if (pStorage)
[38469]	1548	vdIfIoIntFileClose(pIfIo, pStorage);
[38463]	1549
	1550	LogFlowFunc(("returns %Rrc\n", rc));
	1551	return rc;
	1552	}
	1553
[63785]	1554	/** @copydoc VDIMAGEBACKEND::pfnOpen */
[57388]	1555	static DECLCALLBACK(int) qedOpen(const char *pszFilename, unsigned uOpenFlags,
	1556	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
	1557	VDTYPE enmType, void **ppBackendData)
[38463]	1558	{
[63792]	1559	RT_NOREF1(enmType); /*< @todo r=klaus make use of the type info. /
	1560
	1561	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n",
	1562	pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
[38463]	1563	int rc;
	1564
	1565	/* Check open flags. All valid flags are supported. */
[63792]	1566	AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
[90802]	1567	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
	1568	AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
[38463]	1569
[90802]	1570
[66486]	1571	PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(RT_UOFFSETOF(QEDIMAGE, RegionList.aRegions[1]));
[63792]	1572	if (RT_LIKELY(pImage))
[38463]	1573	{
[63792]	1574	pImage->pszFilename = pszFilename;
	1575	pImage->pStorage = NULL;
	1576	pImage->pVDIfsDisk = pVDIfsDisk;
	1577	pImage->pVDIfsImage = pVDIfsImage;
[38463]	1578
[63792]	1579	rc = qedOpenImage(pImage, uOpenFlags);
	1580	if (RT_SUCCESS(rc))
	1581	*ppBackendData = pImage;
	1582	else
	1583	RTMemFree(pImage);
[38463]	1584	}
	1585	else
[63792]	1586	rc = VERR_NO_MEMORY;
[38463]	1587
	1588	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
	1589	return rc;
	1590	}
	1591
[63785]	1592	/** @copydoc VDIMAGEBACKEND::pfnCreate */
[57388]	1593	static DECLCALLBACK(int) qedCreate(const char *pszFilename, uint64_t cbSize,
	1594	unsigned uImageFlags, const char *pszComment,
	1595	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
	1596	PCRTUUID pUuid, unsigned uOpenFlags,
	1597	unsigned uPercentStart, unsigned uPercentSpan,
	1598	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
	1599	PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
	1600	void **ppBackendData)
[38463]	1601	{
[62746]	1602	RT_NOREF1(pUuid);
[56993]	1603	LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p enmType=%d ppBackendData=%#p",
[54430]	1604	pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
[38463]	1605	int rc;
	1606
[54430]	1607	/* Check the VD container type. */
	1608	if (enmType != VDTYPE_HDD)
[63792]	1609	return VERR_VD_INVALID_TYPE;
[54430]	1610
[38463]	1611	/* Check open flags. All valid flags are supported. */
[63792]	1612	AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
[90802]	1613	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
	1614	AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
	1615	AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
	1616	AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
[38463]	1617
[66486]	1618	PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(RT_UOFFSETOF(QEDIMAGE, RegionList.aRegions[1]));
[63792]	1619	if (RT_LIKELY(pImage))
[38463]	1620	{
[63792]	1621	PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
[38463]	1622
[63792]	1623	pImage->pszFilename = pszFilename;
	1624	pImage->pStorage = NULL;
	1625	pImage->pVDIfsDisk = pVDIfsDisk;
	1626	pImage->pVDIfsImage = pVDIfsImage;
[38463]	1627
[63792]	1628	rc = qedCreateImage(pImage, cbSize, uImageFlags, pszComment,
	1629	pPCHSGeometry, pLCHSGeometry, uOpenFlags,
	1630	pIfProgress, uPercentStart, uPercentSpan);
	1631	if (RT_SUCCESS(rc))
[38463]	1632	{
[63792]	1633	/* So far the image is opened in read/write mode. Make sure the
	1634	* image is opened in read-only mode if the caller requested that. */
	1635	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
[38463]	1636	{
[63792]	1637	qedFreeImage(pImage, false);
	1638	rc = qedOpenImage(pImage, uOpenFlags);
[38463]	1639	}
[63792]	1640
	1641	if (RT_SUCCESS(rc))
	1642	*ppBackendData = pImage;
[38463]	1643	}
[63792]	1644
[63811]	1645	if (RT_FAILURE(rc))
[63792]	1646	RTMemFree(pImage);
[38463]	1647	}
	1648	else
[63792]	1649	rc = VERR_NO_MEMORY;
[38463]	1650
	1651	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
	1652	return rc;
	1653	}
	1654
[63785]	1655	/** @copydoc VDIMAGEBACKEND::pfnRename */
[57388]	1656	static DECLCALLBACK(int) qedRename(void pBackendData, const char pszFilename)
[38463]	1657	{
	1658	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
	1659	int rc = VINF_SUCCESS;
	1660	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1661
	1662	/* Check arguments. */
[63792]	1663	AssertReturn((pImage && pszFilename && *pszFilename), VERR_INVALID_PARAMETER);
[38463]	1664
	1665	/* Close the image. */
	1666	rc = qedFreeImage(pImage, false);
[63792]	1667	if (RT_SUCCESS(rc))
[38463]	1668	{
[63792]	1669	/* Rename the file. */
	1670	rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
	1671	if (RT_SUCCESS(rc))
	1672	{
	1673	/* Update pImage with the new information. */
	1674	pImage->pszFilename = pszFilename;
[38463]	1675
[63792]	1676	/* Open the old image with new name. */
	1677	rc = qedOpenImage(pImage, pImage->uOpenFlags);
	1678	}
	1679	else
	1680	{
	1681	/* The move failed, try to reopen the original image. */
	1682	int rc2 = qedOpenImage(pImage, pImage->uOpenFlags);
	1683	if (RT_FAILURE(rc2))
	1684	rc = rc2;
	1685	}
[38463]	1686	}
	1687
	1688	LogFlowFunc(("returns %Rrc\n", rc));
	1689	return rc;
	1690	}
	1691
[63785]	1692	/** @copydoc VDIMAGEBACKEND::pfnClose */
[57388]	1693	static DECLCALLBACK(int) qedClose(void *pBackendData, bool fDelete)
[38463]	1694	{
	1695	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
	1696	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1697
[63792]	1698	int rc = qedFreeImage(pImage, fDelete);
[38463]	1699	RTMemFree(pImage);
	1700
	1701	LogFlowFunc(("returns %Rrc\n", rc));
	1702	return rc;
	1703	}
	1704
[64272]	1705	/** @copydoc VDIMAGEBACKEND::pfnRead */
[57388]	1706	static DECLCALLBACK(int) qedRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
	1707	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
[38463]	1708	{
[44252]	1709	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
	1710	pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
[38463]	1711	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1712	uint32_t offCluster = 0;
	1713	uint32_t idxL1 = 0;
	1714	uint32_t idxL2 = 0;
	1715	uint64_t offFile = 0;
	1716
	1717	AssertPtr(pImage);
	1718	Assert(uOffset % 512 == 0);
	1719	Assert(cbToRead % 512 == 0);
[90802]	1720	AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
	1721	AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
[63792]	1722	AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
[38463]	1723
	1724	qedConvertLogicalOffset(pImage, uOffset, &idxL1, &idxL2, &offCluster);
	1725
	1726	/* Clip read size to remain in the cluster. */
	1727	cbToRead = RT_MIN(cbToRead, pImage->cbCluster - offCluster);
	1728
	1729	/* Get offset in image. */
[63792]	1730	int rc = qedConvertToImageOffset(pImage, pIoCtx, idxL1, idxL2, offCluster, &offFile);
[38463]	1731	if (RT_SUCCESS(rc))
[44252]	1732	rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, offFile,
	1733	pIoCtx, cbToRead);
[38463]	1734
[44252]	1735	if ( ( RT_SUCCESS(rc)
	1736	\|\| rc == VERR_VD_BLOCK_FREE
	1737	\|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
[38463]	1738	&& pcbActuallyRead)
	1739	*pcbActuallyRead = cbToRead;
	1740
	1741	LogFlowFunc(("returns %Rrc\n", rc));
	1742	return rc;
	1743	}
	1744
[64272]	1745	/** @copydoc VDIMAGEBACKEND::pfnWrite */
[57388]	1746	static DECLCALLBACK(int) qedWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
	1747	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
	1748	size_t *pcbPostRead, unsigned fWrite)
[38463]	1749	{
[44252]	1750	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
	1751	pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
[38463]	1752	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1753	uint32_t offCluster = 0;
	1754	uint32_t idxL1 = 0;
	1755	uint32_t idxL2 = 0;
	1756	uint64_t offImage = 0;
[44252]	1757	int rc = VINF_SUCCESS;
[38463]	1758
	1759	AssertPtr(pImage);
[44252]	1760	Assert(!(uOffset % 512));
	1761	Assert(!(cbToWrite % 512));
[90802]	1762	AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
	1763	AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
[63792]	1764	AssertReturn(uOffset + cbToWrite <= pImage->cbSize, VERR_INVALID_PARAMETER);
[38463]	1765
[63792]	1766	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
[38463]	1767	{
[63792]	1768	/* Convert offset to L1, L2 index and cluster offset. */
	1769	qedConvertLogicalOffset(pImage, uOffset, &idxL1, &idxL2, &offCluster);
[38463]	1770
[63792]	1771	/* Clip write size to remain in the cluster. */
	1772	cbToWrite = RT_MIN(cbToWrite, pImage->cbCluster - offCluster);
	1773	Assert(!(cbToWrite % 512));
[44252]	1774
[63792]	1775	/* Get offset in image. */
	1776	rc = qedConvertToImageOffset(pImage, pIoCtx, idxL1, idxL2, offCluster, &offImage);
	1777	if (RT_SUCCESS(rc))
	1778	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
	1779	offImage, pIoCtx, cbToWrite, NULL, NULL);
	1780	else if (rc == VERR_VD_BLOCK_FREE)
[38463]	1781	{
[63792]	1782	if ( cbToWrite == pImage->cbCluster
	1783	&& !(fWrite & VD_WRITE_NO_ALLOC))
[38463]	1784	{
[63792]	1785	PQEDL2CACHEENTRY pL2Entry = NULL;
[38463]	1786
[63792]	1787	/* Full cluster write to previously unallocated cluster.
	1788	* Allocate cluster and write data. */
	1789	Assert(!offCluster);
[44252]	1790
[63792]	1791	do
[38463]	1792	{
[63792]	1793	/* Check if we have to allocate a new cluster for L2 tables. */
	1794	if (!pImage->paL1Table[idxL1])
[44252]	1795	{
[63792]	1796	uint64_t offL2Tbl;
	1797	PQEDCLUSTERASYNCALLOC pL2ClusterAlloc = NULL;
[38463]	1798
[44252]	1799	/* Allocate new async cluster allocation state. */
[63792]	1800	pL2ClusterAlloc = (PQEDCLUSTERASYNCALLOC)RTMemAllocZ(sizeof(QEDCLUSTERASYNCALLOC));
	1801	if (RT_UNLIKELY(!pL2ClusterAlloc))
[44252]	1802	{
	1803	rc = VERR_NO_MEMORY;
	1804	break;
	1805	}
	1806
[63792]	1807	pL2Entry = qedL2TblCacheEntryAlloc(pImage);
	1808	if (!pL2Entry)
	1809	{
	1810	rc = VERR_NO_MEMORY;
	1811	RTMemFree(pL2ClusterAlloc);
	1812	break;
	1813	}
[44252]	1814
[63792]	1815	offL2Tbl = qedClusterAllocate(pImage, qedByte2Cluster(pImage, pImage->cbTable));
	1816	pL2Entry->offL2Tbl = offL2Tbl;
	1817	memset(pL2Entry->paL2Tbl, 0, pImage->cbTable);
[44252]	1818
[63792]	1819	pL2ClusterAlloc->enmAllocState = QEDCLUSTERASYNCALLOCSTATE_L2_ALLOC;
	1820	pL2ClusterAlloc->cbImageOld = offL2Tbl;
	1821	pL2ClusterAlloc->offClusterNew = offL2Tbl;
	1822	pL2ClusterAlloc->idxL1 = idxL1;
	1823	pL2ClusterAlloc->idxL2 = idxL2;
	1824	pL2ClusterAlloc->cbToWrite = cbToWrite;
	1825	pL2ClusterAlloc->pL2Entry = pL2Entry;
	1826
[64832]	1827	pImage->pL2TblAlloc = pL2Entry;
	1828
	1829	LogFlowFunc(("Allocating new L2 table at cluster offset %llu\n", offL2Tbl));
	1830
[63792]	1831	/*
	1832	* Write the L2 table first and link to the L1 table afterwards.
	1833	* If something unexpected happens the worst case which can happen
	1834	* is a leak of some clusters.
	1835	*/
	1836	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
	1837	offL2Tbl, pL2Entry->paL2Tbl, pImage->cbTable, pIoCtx,
	1838	qedAsyncClusterAllocUpdate, pL2ClusterAlloc);
[44252]	1839	if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1840	break;
	1841	else if (RT_FAILURE(rc))
	1842	{
[63792]	1843	RTMemFree(pL2ClusterAlloc);
	1844	qedL2TblCacheEntryFree(pImage, pL2Entry);
[44252]	1845	break;
	1846	}
	1847
[63792]	1848	rc = qedAsyncClusterAllocUpdate(pImage, pIoCtx, pL2ClusterAlloc, rc);
[44252]	1849	}
[63792]	1850	else
	1851	{
[64832]	1852	LogFlowFunc(("Fetching L2 table at cluster offset %llu\n", pImage->paL1Table[idxL1]));
	1853
[63792]	1854	rc = qedL2TblCacheFetchAsync(pImage, pIoCtx, pImage->paL1Table[idxL1],
	1855	&pL2Entry);
[38463]	1856
[63792]	1857	if (RT_SUCCESS(rc))
	1858	{
	1859	PQEDCLUSTERASYNCALLOC pDataClusterAlloc = NULL;
[38463]	1860
[63792]	1861	/* Allocate new async cluster allocation state. */
	1862	pDataClusterAlloc = (PQEDCLUSTERASYNCALLOC)RTMemAllocZ(sizeof(QEDCLUSTERASYNCALLOC));
	1863	if (RT_UNLIKELY(!pDataClusterAlloc))
	1864	{
	1865	rc = VERR_NO_MEMORY;
	1866	break;
	1867	}
	1868
	1869	/* Allocate new cluster for the data. */
	1870	uint64_t offData = qedClusterAllocate(pImage, 1);
	1871
	1872	pDataClusterAlloc->enmAllocState = QEDCLUSTERASYNCALLOCSTATE_USER_ALLOC;
	1873	pDataClusterAlloc->cbImageOld = offData;
	1874	pDataClusterAlloc->offClusterNew = offData;
	1875	pDataClusterAlloc->idxL1 = idxL1;
	1876	pDataClusterAlloc->idxL2 = idxL2;
	1877	pDataClusterAlloc->cbToWrite = cbToWrite;
	1878	pDataClusterAlloc->pL2Entry = pL2Entry;
	1879
	1880	/* Write data. */
	1881	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
	1882	offData, pIoCtx, cbToWrite,
	1883	qedAsyncClusterAllocUpdate, pDataClusterAlloc);
	1884	if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1885	break;
	1886	else if (RT_FAILURE(rc))
	1887	{
	1888	RTMemFree(pDataClusterAlloc);
	1889	break;
	1890	}
	1891
	1892	rc = qedAsyncClusterAllocUpdate(pImage, pIoCtx, pDataClusterAlloc, rc);
	1893	}
	1894	}
	1895
	1896	} while (0);
	1897
	1898	*pcbPreRead = 0;
	1899	*pcbPostRead = 0;
	1900	}
	1901	else
	1902	{
	1903	/* Trying to do a partial write to an unallocated cluster. Don't do
	1904	* anything except letting the upper layer know what to do. */
	1905	*pcbPreRead = offCluster;
	1906	pcbPostRead = pImage->cbCluster - cbToWrite - pcbPreRead;
	1907	}
[38463]	1908	}
[63792]	1909
	1910	if (pcbWriteProcess)
	1911	*pcbWriteProcess = cbToWrite;
[38463]	1912	}
[63792]	1913	else
	1914	rc = VERR_VD_IMAGE_READ_ONLY;
[38463]	1915
	1916	LogFlowFunc(("returns %Rrc\n", rc));
	1917	return rc;
	1918	}
	1919
[63792]	1920	/** @copydoc VDIMAGEBACKEND::pfnFlush */
[57388]	1921	static DECLCALLBACK(int) qedFlush(void *pBackendData, PVDIOCTX pIoCtx)
[38463]	1922	{
	1923	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	1924	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
[44252]	1925	int rc = VINF_SUCCESS;
[38463]	1926
[63792]	1927	AssertPtr(pImage);
	1928	AssertPtrReturn(pIoCtx, VERR_INVALID_PARAMETER);
[44252]	1929
[63792]	1930	if ( pImage->pStorage
	1931	&& !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
	1932	{
	1933	QedHeader Header;
[44252]	1934
[63792]	1935	Assert(!(pImage->cbTable % pImage->cbCluster));
	1936	rc = qedTblWrite(pImage, pIoCtx, pImage->offL1Table, pImage->paL1Table,
	1937	NULL, NULL);
	1938	if (RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1939	{
	1940	/* Write header. */
	1941	qedHdrConvertFromHostEndianess(pImage, &Header);
	1942	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
	1943	0, &Header, sizeof(Header),
	1944	pIoCtx, NULL, NULL);
	1945	if (RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
	1946	rc = vdIfIoIntFileFlush(pImage->pIfIo, pImage->pStorage,
	1947	pIoCtx, NULL, NULL);
	1948	}
	1949	}
	1950
[38463]	1951	LogFlowFunc(("returns %Rrc\n", rc));
	1952	return rc;
	1953	}
	1954
[63785]	1955	/** @copydoc VDIMAGEBACKEND::pfnGetVersion */
[57388]	1956	static DECLCALLBACK(unsigned) qedGetVersion(void *pBackendData)
[38463]	1957	{
	1958	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	1959	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1960
[63792]	1961	AssertPtrReturn(pImage, 0);
[38463]	1962
[63792]	1963	return 1;
[38463]	1964	}
	1965
[63785]	1966	/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
[57388]	1967	static DECLCALLBACK(uint64_t) qedGetFileSize(void *pBackendData)
[38463]	1968	{
	1969	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	1970	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	1971	uint64_t cb = 0;
	1972
[63792]	1973	AssertPtrReturn(pImage, 0);
[38463]	1974
[63792]	1975	uint64_t cbFile;
	1976	if (pImage->pStorage)
[38463]	1977	{
[63792]	1978	int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
	1979	if (RT_SUCCESS(rc))
	1980	cb += cbFile;
[38463]	1981	}
	1982
	1983	LogFlowFunc(("returns %lld\n", cb));
	1984	return cb;
	1985	}
	1986
[63785]	1987	/** @copydoc VDIMAGEBACKEND::pfnGetPCHSGeometry */
[57388]	1988	static DECLCALLBACK(int) qedGetPCHSGeometry(void *pBackendData,
	1989	PVDGEOMETRY pPCHSGeometry)
[38463]	1990	{
	1991	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
	1992	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
[63792]	1993	int rc = VINF_SUCCESS;
[38463]	1994
[63792]	1995	AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
[38463]	1996
[63792]	1997	if (pImage->PCHSGeometry.cCylinders)
	1998	*pPCHSGeometry = pImage->PCHSGeometry;
[38463]	1999	else
[63792]	2000	rc = VERR_VD_GEOMETRY_NOT_SET;
[38463]	2001
	2002	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
	2003	return rc;
	2004	}
	2005
[63785]	2006	/** @copydoc VDIMAGEBACKEND::pfnSetPCHSGeometry */
[57388]	2007	static DECLCALLBACK(int) qedSetPCHSGeometry(void *pBackendData,
	2008	PCVDGEOMETRY pPCHSGeometry)
[38463]	2009	{
[63792]	2010	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
	2011	pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
[38463]	2012	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
[63792]	2013	int rc = VINF_SUCCESS;
[38463]	2014
[63792]	2015	AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
[38463]	2016
[63792]	2017	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2018	rc = VERR_VD_IMAGE_READ_ONLY;
	2019	else
[38463]	2020	pImage->PCHSGeometry = *pPCHSGeometry;
	2021
	2022	LogFlowFunc(("returns %Rrc\n", rc));
	2023	return rc;
	2024	}
	2025
[63785]	2026	/** @copydoc VDIMAGEBACKEND::pfnGetLCHSGeometry */
[63792]	2027	static DECLCALLBACK(int) qedGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
[38463]	2028	{
[63792]	2029	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
[38463]	2030	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
[63792]	2031	int rc = VINF_SUCCESS;
[38463]	2032
[63792]	2033	AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
[38463]	2034
[63792]	2035	if (pImage->LCHSGeometry.cCylinders)
	2036	*pLCHSGeometry = pImage->LCHSGeometry;
[38463]	2037	else
[63792]	2038	rc = VERR_VD_GEOMETRY_NOT_SET;
[38463]	2039
[63792]	2040	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders,
	2041	pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
[38463]	2042	return rc;
	2043	}
	2044
[63785]	2045	/** @copydoc VDIMAGEBACKEND::pfnSetLCHSGeometry */
[63792]	2046	static DECLCALLBACK(int) qedSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
[38463]	2047	{
[63792]	2048	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData,
	2049	pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
[38463]	2050	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
[63792]	2051	int rc = VINF_SUCCESS;
[38463]	2052
[63792]	2053	AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
[38463]	2054
[63792]	2055	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2056	rc = VERR_VD_IMAGE_READ_ONLY;
	2057	else
[38463]	2058	pImage->LCHSGeometry = *pLCHSGeometry;
	2059
	2060	LogFlowFunc(("returns %Rrc\n", rc));
	2061	return rc;
	2062	}
	2063
[66486]	2064	/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
	2065	static DECLCALLBACK(int) qedQueryRegions(void pBackendData, PCVDREGIONLIST ppRegionList)
	2066	{
	2067	LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
	2068	PQEDIMAGE pThis = (PQEDIMAGE)pBackendData;
	2069
	2070	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	2071
	2072	*ppRegionList = &pThis->RegionList;
	2073	LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
	2074	return VINF_SUCCESS;
	2075	}
	2076
	2077	/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
	2078	static DECLCALLBACK(void) qedRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
	2079	{
	2080	RT_NOREF1(pRegionList);
	2081	LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
	2082	PQEDIMAGE pThis = (PQEDIMAGE)pBackendData;
	2083	AssertPtr(pThis); RT_NOREF(pThis);
	2084
	2085	/* Nothing to do here. */
	2086	}
	2087
[63785]	2088	/** @copydoc VDIMAGEBACKEND::pfnGetImageFlags */
[57388]	2089	static DECLCALLBACK(unsigned) qedGetImageFlags(void *pBackendData)
[38463]	2090	{
	2091	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	2092	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	2093
[63792]	2094	AssertPtrReturn(pImage, 0);
[38463]	2095
[63792]	2096	LogFlowFunc(("returns %#x\n", pImage->uImageFlags));
	2097	return pImage->uImageFlags;
[38463]	2098	}
	2099
[63785]	2100	/** @copydoc VDIMAGEBACKEND::pfnGetOpenFlags */
[57388]	2101	static DECLCALLBACK(unsigned) qedGetOpenFlags(void *pBackendData)
[38463]	2102	{
	2103	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	2104	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	2105
[63792]	2106	AssertPtrReturn(pImage, 0);
[38463]	2107
[63792]	2108	LogFlowFunc(("returns %#x\n", pImage->uOpenFlags));
	2109	return pImage->uOpenFlags;
[38463]	2110	}
	2111
[63785]	2112	/** @copydoc VDIMAGEBACKEND::pfnSetOpenFlags */
[57388]	2113	static DECLCALLBACK(int) qedSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
[38463]	2114	{
	2115	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
	2116	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
[63792]	2117	int rc = VINF_SUCCESS;
[38463]	2118
	2119	/* Image must be opened and the new flags must be valid. */
[44232]	2120	if (!pImage \|\| (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO
[63792]	2121	\| VD_OPEN_FLAGS_ASYNC_IO \| VD_OPEN_FLAGS_SHAREABLE
	2122	\| VD_OPEN_FLAGS_SEQUENTIAL \| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
	2123	rc = VERR_INVALID_PARAMETER;
	2124	else
[38463]	2125	{
[63792]	2126	/* Implement this operation via reopening the image. */
	2127	rc = qedFreeImage(pImage, false);
	2128	if (RT_SUCCESS(rc))
	2129	rc = qedOpenImage(pImage, uOpenFlags);
[38463]	2130	}
	2131
	2132	LogFlowFunc(("returns %Rrc\n", rc));
	2133	return rc;
	2134	}
	2135
[63785]	2136	/** @copydoc VDIMAGEBACKEND::pfnGetComment */
[66494]	2137	VD_BACKEND_CALLBACK_GET_COMMENT_DEF_NOT_SUPPORTED(qedGetComment);
[38463]	2138
[63785]	2139	/** @copydoc VDIMAGEBACKEND::pfnSetComment */
[66494]	2140	VD_BACKEND_CALLBACK_SET_COMMENT_DEF_NOT_SUPPORTED(qedSetComment, PQEDIMAGE);
[38463]	2141
[63785]	2142	/** @copydoc VDIMAGEBACKEND::pfnGetUuid */
[66494]	2143	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(qedGetUuid);
[38463]	2144
[63785]	2145	/** @copydoc VDIMAGEBACKEND::pfnSetUuid */
[66494]	2146	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(qedSetUuid, PQEDIMAGE);
[38463]	2147
[63785]	2148	/** @copydoc VDIMAGEBACKEND::pfnGetModificationUuid */
[66494]	2149	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(qedGetModificationUuid);
[38463]	2150
[63785]	2151	/** @copydoc VDIMAGEBACKEND::pfnSetModificationUuid */
[66494]	2152	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(qedSetModificationUuid, PQEDIMAGE);
[38463]	2153
[63785]	2154	/** @copydoc VDIMAGEBACKEND::pfnGetParentUuid */
[66494]	2155	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(qedGetParentUuid);
[38463]	2156
[63785]	2157	/** @copydoc VDIMAGEBACKEND::pfnSetParentUuid */
[66494]	2158	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(qedSetParentUuid, PQEDIMAGE);
[38463]	2159
[63785]	2160	/** @copydoc VDIMAGEBACKEND::pfnGetParentModificationUuid */
[66494]	2161	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(qedGetParentModificationUuid);
[38463]	2162
[63785]	2163	/** @copydoc VDIMAGEBACKEND::pfnSetParentModificationUuid */
[66494]	2164	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(qedSetParentModificationUuid, PQEDIMAGE);
[38463]	2165
[63785]	2166	/** @copydoc VDIMAGEBACKEND::pfnDump */
[57388]	2167	static DECLCALLBACK(void) qedDump(void *pBackendData)
[38463]	2168	{
	2169	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	2170
[63792]	2171	AssertPtrReturnVoid(pImage);
	2172	vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
	2173	pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
	2174	pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
	2175	pImage->cbSize / 512);
[38463]	2176	}
	2177
[63785]	2178	/** @copydoc VDIMAGEBACKEND::pfnGetParentFilename */
[57388]	2179	static DECLCALLBACK(int) qedGetParentFilename(void pBackendData, char *ppszParentFilename)
[38463]	2180	{
	2181	int rc = VINF_SUCCESS;
	2182	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	2183
[63792]	2184	AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
	2185
	2186	if (pImage->pszBackingFilename)
	2187	*ppszParentFilename = RTStrDup(pImage->pszBackingFilename);
[38463]	2188	else
[63792]	2189	rc = VERR_NOT_SUPPORTED;
[38463]	2190
	2191	LogFlowFunc(("returns %Rrc\n", rc));
	2192	return rc;
	2193	}
	2194
[63785]	2195	/** @copydoc VDIMAGEBACKEND::pfnSetParentFilename */
[57388]	2196	static DECLCALLBACK(int) qedSetParentFilename(void pBackendData, const char pszParentFilename)
[38463]	2197	{
	2198	int rc = VINF_SUCCESS;
	2199	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	2200
[63792]	2201	AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
	2202
	2203	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2204	rc = VERR_VD_IMAGE_READ_ONLY;
	2205	else if ( pImage->pszBackingFilename
	2206	&& (strlen(pszParentFilename) > pImage->cbBackingFilename))
	2207	rc = VERR_NOT_SUPPORTED; /* The new filename is longer than the old one. */
	2208	else
[38463]	2209	{
[63792]	2210	if (pImage->pszBackingFilename)
	2211	RTStrFree(pImage->pszBackingFilename);
	2212	pImage->pszBackingFilename = RTStrDup(pszParentFilename);
	2213	if (!pImage->pszBackingFilename)
[77232]	2214	rc = VERR_NO_STR_MEMORY;
[38463]	2215	else
	2216	{
[63792]	2217	if (!pImage->offBackingFilename)
[38463]	2218	{
[63792]	2219	/* Allocate new cluster. */
	2220	uint64_t offData = qedClusterAllocate(pImage, 1);
[38463]	2221
[63792]	2222	Assert((offData & UINT32_MAX) == offData);
	2223	pImage->offBackingFilename = (uint32_t)offData;
	2224	pImage->cbBackingFilename = (uint32_t)strlen(pszParentFilename);
	2225	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
	2226	offData + pImage->cbCluster);
	2227	}
[38463]	2228
[63792]	2229	if (RT_SUCCESS(rc))
	2230	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
	2231	pImage->offBackingFilename,
	2232	pImage->pszBackingFilename,
	2233	strlen(pImage->pszBackingFilename));
[38463]	2234	}
	2235	}
	2236
	2237	LogFlowFunc(("returns %Rrc\n", rc));
	2238	return rc;
	2239	}
	2240
[63785]	2241	/** @copydoc VDIMAGEBACKEND::pfnResize */
[57388]	2242	static DECLCALLBACK(int) qedResize(void *pBackendData, uint64_t cbSize,
	2243	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
	2244	unsigned uPercentStart, unsigned uPercentSpan,
	2245	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
	2246	PVDINTERFACE pVDIfsOperation)
[38463]	2247	{
[62746]	2248	RT_NOREF7(pPCHSGeometry, pLCHSGeometry, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation);
[38463]	2249	PQEDIMAGE pImage = (PQEDIMAGE)pBackendData;
	2250	int rc = VINF_SUCCESS;
	2251
	2252	/* Making the image smaller is not supported at the moment. */
	2253	if (cbSize < pImage->cbSize)
	2254	rc = VERR_NOT_SUPPORTED;
	2255	else if (cbSize > pImage->cbSize)
	2256	{
	2257	/*
	2258	* It is enough to just update the size field in the header to complete
	2259	* growing. With the default cluster and table sizes the image can be expanded
	2260	* to 64TB without overflowing the L1 and L2 tables making block relocation
	2261	* superfluous.
	2262	* @todo: The rare case where block relocation is still required (non default
	2263	* table and/or cluster size or images with more than 64TB) is not
	2264	* implemented yet and resizing such an image will fail with an error.
	2265	*/
	2266	if (qedByte2Cluster(pImage, pImage->cbTable)pImage->cTableEntriespImage->cTableEntries*pImage->cbCluster < cbSize)
[38469]	2267	rc = vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS,
	2268	N_("Qed: Resizing the image '%s' is not supported because it would overflow the L1 and L2 table\n"),
	2269	pImage->pszFilename);
[38463]	2270	else
	2271	{
	2272	uint64_t cbSizeOld = pImage->cbSize;
	2273
	2274	pImage->cbSize = cbSize;
	2275	rc = qedFlushImage(pImage);
	2276	if (RT_FAILURE(rc))
	2277	{
	2278	pImage->cbSize = cbSizeOld; /* Restore */
	2279
[38469]	2280	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Qed: Resizing the image '%s' failed\n"),
	2281	pImage->pszFilename);
[38463]	2282	}
	2283	}
	2284	}
	2285	/* Same size doesn't change the image at all. */
	2286
	2287	LogFlowFunc(("returns %Rrc\n", rc));
	2288	return rc;
	2289	}
	2290
	2291
[63781]	2292	const VDIMAGEBACKEND g_QedBackend =
[38463]	2293	{
[63905]	2294	/* u32Version */
	2295	VD_IMGBACKEND_VERSION,
[38463]	2296	/* pszBackendName */
	2297	"QED",
	2298	/* uBackendCaps */
	2299	VD_CAP_FILE \| VD_CAP_VFS \| VD_CAP_CREATE_DYNAMIC \| VD_CAP_DIFF \| VD_CAP_ASYNC,
	2300	/* paFileExtensions */
	2301	s_aQedFileExtensions,
	2302	/* paConfigInfo */
	2303	NULL,
[63802]	2304	/* pfnProbe */
	2305	qedProbe,
[38463]	2306	/* pfnOpen */
	2307	qedOpen,
	2308	/* pfnCreate */
	2309	qedCreate,
	2310	/* pfnRename */
	2311	qedRename,
	2312	/* pfnClose */
	2313	qedClose,
	2314	/* pfnRead */
	2315	qedRead,
	2316	/* pfnWrite */
	2317	qedWrite,
	2318	/* pfnFlush */
	2319	qedFlush,
[44252]	2320	/* pfnDiscard */
	2321	NULL,
[38463]	2322	/* pfnGetVersion */
	2323	qedGetVersion,
	2324	/* pfnGetFileSize */
	2325	qedGetFileSize,
	2326	/* pfnGetPCHSGeometry */
	2327	qedGetPCHSGeometry,
	2328	/* pfnSetPCHSGeometry */
	2329	qedSetPCHSGeometry,
	2330	/* pfnGetLCHSGeometry */
	2331	qedGetLCHSGeometry,
	2332	/* pfnSetLCHSGeometry */
	2333	qedSetLCHSGeometry,
[66110]	2334	/* pfnQueryRegions */
[66486]	2335	qedQueryRegions,
[66110]	2336	/* pfnRegionListRelease */
[66486]	2337	qedRegionListRelease,
[38463]	2338	/* pfnGetImageFlags */
	2339	qedGetImageFlags,
	2340	/* pfnGetOpenFlags */
	2341	qedGetOpenFlags,
	2342	/* pfnSetOpenFlags */
	2343	qedSetOpenFlags,
	2344	/* pfnGetComment */
	2345	qedGetComment,
	2346	/* pfnSetComment */
	2347	qedSetComment,
	2348	/* pfnGetUuid */
	2349	qedGetUuid,
	2350	/* pfnSetUuid */
	2351	qedSetUuid,
	2352	/* pfnGetModificationUuid */
	2353	qedGetModificationUuid,
	2354	/* pfnSetModificationUuid */
	2355	qedSetModificationUuid,
	2356	/* pfnGetParentUuid */
	2357	qedGetParentUuid,
	2358	/* pfnSetParentUuid */
	2359	qedSetParentUuid,
	2360	/* pfnGetParentModificationUuid */
	2361	qedGetParentModificationUuid,
	2362	/* pfnSetParentModificationUuid */
	2363	qedSetParentModificationUuid,
	2364	/* pfnDump */
	2365	qedDump,
[58132]	2366	/* pfnGetTimestamp */
[38463]	2367	NULL,
[58132]	2368	/* pfnGetParentTimestamp */
[38463]	2369	NULL,
[58132]	2370	/* pfnSetParentTimestamp */
[38463]	2371	NULL,
	2372	/* pfnGetParentFilename */
	2373	qedGetParentFilename,
	2374	/* pfnSetParentFilename */
	2375	qedSetParentFilename,
	2376	/* pfnComposeLocation */
	2377	genericFileComposeLocation,
	2378	/* pfnComposeName */
	2379	genericFileComposeName,
	2380	/* pfnCompact */
	2381	NULL,
	2382	/* pfnResize */
[38621]	2383	qedResize,
[39519]	2384	/* pfnRepair */
[50988]	2385	NULL,
	2386	/* pfnTraverseMetadata */
[63905]	2387	NULL,
	2388	/* u32Version */
	2389	VD_IMGBACKEND_VERSION
[38463]	2390	};

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

source: vbox/trunk/src/VBox/Storage/QED.cpp

Download in other formats: