QED.cpp@ 99739

Last change on this file since 99739 was 99739, checked in by vboxsync, 17 months ago
*: doxygen corrections (mostly about removing @returns from functions returning void).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 86.9 KB

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

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

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

Download in other formats: