VCICache.cpp@ 99749

Last change on this file since 99749 was 99739, checked in by vboxsync, 19 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: 65.8 KB

Line
1	/* $Id: VCICache.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
2	/** @file
3	* VCICacheCore - VirtualBox Cache Image, Core Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_VD_RAW /** @todo logging group */
33	#include <VBox/vd-cache-backend.h>
34	#include <VBox/err.h>
35
36	#include <VBox/log.h>
37	#include <iprt/assert.h>
38	#include <iprt/alloc.h>
39	#include <iprt/file.h>
40	#include <iprt/asm.h>
41
42	#include "VDBackends.h"
43
44	/*******************************************************************************
45	* On disk data structures *
46	*******************************************************************************/
47
48	/** @note All structures which are written to the disk are written in camel case
49	* and packed. */
50
51	/** Block size used internally, because we cache sectors the smallest unit we
52	* have to care about is 512 bytes. */
53	#define VCI_BLOCK_SIZE 512
54
55	/** Convert block number/size to byte offset/size. */
56	#define VCI_BLOCK2BYTE(u) ((uint64_t)(u) << 9)
57
58	/** Convert byte offset/size to block number/size. */
59	#define VCI_BYTE2BLOCK(u) ((u) >> 9)
60
61	/**
62	* The VCI header - at the beginning of the file.
63	*
64	* All entries a stored in little endian order.
65	*/
66	#pragma pack(1)
67	typedef struct VciHdr
68	{
69	/** The signature to identify a cache image. */
70	uint32_t u32Signature;
71	/** Version of the layout of metadata in the cache. */
72	uint32_t u32Version;
73	/** Maximum size of the cache file in blocks.
74	* This includes all metadata. */
75	uint64_t cBlocksCache;
76	/** Flag indicating whether the cache was closed cleanly. */
77	uint8_t fUncleanShutdown;
78	/** Cache type. */
79	uint32_t u32CacheType;
80	/** Offset of the B+-Tree root in the image in blocks. */
81	uint64_t offTreeRoot;
82	/** Offset of the block allocation bitmap in blocks. */
83	uint64_t offBlkMap;
84	/** Size of the block allocation bitmap in blocks. */
85	uint32_t cBlkMap;
86	/** UUID of the image. */
87	RTUUID uuidImage;
88	/** Modification UUID for the cache. */
89	RTUUID uuidModification;
90	/** Reserved for future use. */
91	uint8_t abReserved[951];
92	} VciHdr, *PVciHdr;
93	#pragma pack()
94	AssertCompileSize(VciHdr, 2 * VCI_BLOCK_SIZE);
95
96	/** VCI signature to identify a valid image. */
97	#define VCI_HDR_SIGNATURE UINT32_C(0x00494356) /* \0ICV */
98	/** Current version we support. */
99	#define VCI_HDR_VERSION UINT32_C(0x00000001)
100
101	/** Value for an unclean cache shutdown. */
102	#define VCI_HDR_UNCLEAN_SHUTDOWN UINT8_C(0x01)
103	/** Value for a clean cache shutdown. */
104	#define VCI_HDR_CLEAN_SHUTDOWN UINT8_C(0x00)
105
106	/** Cache type: Dynamic image growing to the maximum value. */
107	#define VCI_HDR_CACHE_TYPE_DYNAMIC UINT32_C(0x00000001)
108	/** Cache type: Fixed image, space is preallocated. */
109	#define VCI_HDR_CACHE_TYPE_FIXED UINT32_C(0x00000002)
110
111	/**
112	* On disk representation of an extent describing a range of cached data.
113	*
114	* All entries a stored in little endian order.
115	*/
116	#pragma pack(1)
117	typedef struct VciCacheExtent
118	{
119	/** Block address of the previous extent in the LRU list. */
120	uint64_t u64ExtentPrev;
121	/** Block address of the next extent in the LRU list. */
122	uint64_t u64ExtentNext;
123	/** Flags (for compression, encryption etc.) - currently unused and should be always 0. */
124	uint8_t u8Flags;
125	/** Reserved */
126	uint8_t u8Reserved;
127	/** First block of cached data the extent represents. */
128	uint64_t u64BlockOffset;
129	/** Number of blocks the extent represents. */
130	uint32_t u32Blocks;
131	/** First block in the image where the data is stored. */
132	uint64_t u64BlockAddr;
133	} VciCacheExtent, *PVciCacheExtent;
134	#pragma pack()
135	AssertCompileSize(VciCacheExtent, 38);
136
137	/**
138	* On disk representation of an internal node.
139	*
140	* All entries a stored in little endian order.
141	*/
142	#pragma pack(1)
143	typedef struct VciTreeNodeInternal
144	{
145	/** First block of cached data the internal node represents. */
146	uint64_t u64BlockOffset;
147	/** Number of blocks the internal node represents. */
148	uint32_t u32Blocks;
149	/** Block address in the image where the next node in the tree is stored. */
150	uint64_t u64ChildAddr;
151	} VciTreeNodeInternal, *PVciTreeNodeInternal;
152	#pragma pack()
153	AssertCompileSize(VciTreeNodeInternal, 20);
154
155	/**
156	* On-disk representation of a node in the B+-Tree.
157	*
158	* All entries a stored in little endian order.
159	*/
160	#pragma pack(1)
161	typedef struct VciTreeNode
162	{
163	/** Type of the node (root, internal, leaf). */
164	uint8_t u8Type;
165	/** Data in the node. */
166	uint8_t au8Data[4095];
167	} VciTreeNode, *PVciTreeNode;
168	#pragma pack()
169	AssertCompileSize(VciTreeNode, 8 * VCI_BLOCK_SIZE);
170
171	/** Node type: Internal node containing links to other nodes (VciTreeNodeInternal). */
172	#define VCI_TREE_NODE_TYPE_INTERNAL UINT8_C(0x01)
173	/** Node type: Leaf of the tree (VciCacheExtent). */
174	#define VCI_TREE_NODE_TYPE_LEAF UINT8_C(0x02)
175
176	/** Number of cache extents described by one node. */
177	#define VCI_TREE_EXTENTS_PER_NODE ((sizeof(VciTreeNode)-1) / sizeof(VciCacheExtent))
178	/** Number of internal nodes managed by one tree node. */
179	#define VCI_TREE_INTERNAL_NODES_PER_NODE ((sizeof(VciTreeNode)-1) / sizeof(VciTreeNodeInternal))
180
181	/**
182	* VCI block bitmap header.
183	*
184	* All entries a stored in little endian order.
185	*/
186	#pragma pack(1)
187	typedef struct VciBlkMap
188	{
189	/** Magic of the block bitmap. */
190	uint32_t u32Magic;
191	/** Version of the block bitmap. */
192	uint32_t u32Version;
193	/** Number of blocks this block map manages. */
194	uint64_t cBlocks;
195	/** Number of free blocks. */
196	uint64_t cBlocksFree;
197	/** Number of blocks allocated for metadata. */
198	uint64_t cBlocksAllocMeta;
199	/** Number of blocks allocated for actual cached data. */
200	uint64_t cBlocksAllocData;
201	/** Reserved for future use. */
202	uint8_t au8Reserved[472];
203	} VciBlkMap, *PVciBlkMap;
204	#pragma pack()
205	AssertCompileSize(VciBlkMap, VCI_BLOCK_SIZE);
206
207	/** The magic which identifies a block map. */
208	#define VCI_BLKMAP_MAGIC UINT32_C(0x4b4c4256) /* KLBV */
209	/** Current version. */
210	#define VCI_BLKMAP_VERSION UINT32_C(0x00000001)
211
212	/** Block bitmap entry */
213	typedef uint8_t VciBlkMapEnt;
214
215
216	/*********************************************************************************************************************************
217	* Constants And Macros, Structures and Typedefs *
218	*********************************************************************************************************************************/
219
220	/**
221	* Block range descriptor.
222	*/
223	typedef struct VCIBLKRANGEDESC
224	{
225	/** Previous entry in the list. */
226	struct VCIBLKRANGEDESC *pPrev;
227	/** Next entry in the list. */
228	struct VCIBLKRANGEDESC *pNext;
229	/** Start address of the range. */
230	uint64_t offAddrStart;
231	/** Number of blocks in the range. */
232	uint64_t cBlocks;
233	/** Flag whether the range is free or allocated. */
234	bool fFree;
235	} VCIBLKRANGEDESC, *PVCIBLKRANGEDESC;
236
237	/**
238	* Block map for the cache image - in memory structure.
239	*/
240	typedef struct VCIBLKMAP
241	{
242	/** Number of blocks the map manages. */
243	uint64_t cBlocks;
244	/** Number of blocks allocated for metadata. */
245	uint64_t cBlocksAllocMeta;
246	/** Number of blocks allocated for actual cached data. */
247	uint64_t cBlocksAllocData;
248	/** Number of free blocks. */
249	uint64_t cBlocksFree;
250
251	/** Pointer to the head of the block range list. */
252	PVCIBLKRANGEDESC pRangesHead;
253	/** Pointer to the tail of the block range list. */
254	PVCIBLKRANGEDESC pRangesTail;
255
256	} VCIBLKMAP;
257	/** Pointer to a block map. */
258	typedef VCIBLKMAP *PVCIBLKMAP;
259
260	/**
261	* B+-Tree node header.
262	*/
263	typedef struct VCITREENODE
264	{
265	/** Type of the node (VCI_TREE_NODE_TYPE_). /
266	uint8_t u8Type;
267	/** Block address where the node is stored. */
268	uint64_t u64BlockAddr;
269	/** Pointer to the parent. */
270	struct VCITREENODE *pParent;
271	} VCITREENODE, *PVCITREENODE;
272
273	/**
274	* B+-Tree node pointer.
275	*/
276	typedef struct VCITREENODEPTR
277	{
278	/** Flag whether the node is in memory or still on the disk. */
279	bool fInMemory;
280	/** Type dependent data. */
281	union
282	{
283	/** Pointer to a in memory node. */
284	PVCITREENODE pNode;
285	/** Start block address of the node. */
286	uint64_t offAddrBlockNode;
287	} u;
288	} VCITREENODEPTR, *PVCITREENODEPTR;
289
290	/**
291	* Internal node.
292	*/
293	typedef struct VCINODEINTERNAL
294	{
295	/** First block of cached data the internal node represents. */
296	uint64_t u64BlockOffset;
297	/** Number of blocks the internal node represents. */
298	uint32_t u32Blocks;
299	/** Pointer to the child node. */
300	VCITREENODEPTR PtrChild;
301	} VCINODEINTERNAL, *PVCINODEINTERNAL;
302
303	/**
304	* A in memory internal B+-tree node.
305	*/
306	typedef struct VCITREENODEINT
307	{
308	/** Node core. */
309	VCITREENODE Core;
310	/** Number of used nodes. */
311	unsigned cUsedNodes;
312	/** Array of internal nodes. */
313	VCINODEINTERNAL aIntNodes[VCI_TREE_INTERNAL_NODES_PER_NODE];
314	} VCITREENODEINT, *PVCITREENODEINT;
315
316	/**
317	* A in memory cache extent.
318	*/
319	typedef struct VCICACHEEXTENT
320	{
321	/** First block of cached data the extent represents. */
322	uint64_t u64BlockOffset;
323	/** Number of blocks the extent represents. */
324	uint32_t u32Blocks;
325	/** First block in the image where the data is stored. */
326	uint64_t u64BlockAddr;
327	} VCICACHEEXTENT, *PVCICACHEEXTENT;
328
329	/**
330	* A in memory leaf B+-tree node.
331	*/
332	typedef struct VCITREENODELEAF
333	{
334	/** Node core. */
335	VCITREENODE Core;
336	/** Next leaf node in the list. */
337	struct VCITREENODELEAF *pNext;
338	/** Number of used nodes. */
339	unsigned cUsedNodes;
340	/** The extents in the node. */
341	VCICACHEEXTENT aExtents[VCI_TREE_EXTENTS_PER_NODE];
342	} VCITREENODELEAF, *PVCITREENODELEAF;
343
344	/**
345	* VCI image data structure.
346	*/
347	typedef struct VCICACHE
348	{
349	/** Image name. */
350	const char *pszFilename;
351	/** Storage handle. */
352	PVDIOSTORAGE pStorage;
353
354	/** Pointer to the per-disk VD interface list. */
355	PVDINTERFACE pVDIfsDisk;
356	/** Pointer to the per-image VD interface list. */
357	PVDINTERFACE pVDIfsImage;
358	/** Error interface. */
359	PVDINTERFACEERROR pIfError;
360	/** I/O interface. */
361	PVDINTERFACEIOINT pIfIo;
362
363	/** Open flags passed by VBoxHD layer. */
364	unsigned uOpenFlags;
365	/** Image flags defined during creation or determined during open. */
366	unsigned uImageFlags;
367	/** Total size of the image. */
368	uint64_t cbSize;
369
370	/** Offset of the B+-Tree in the image in bytes. */
371	uint64_t offTreeRoot;
372	/** Pointer to the root node of the B+-Tree. */
373	PVCITREENODE pRoot;
374	/** Offset to the block allocation bitmap in bytes. */
375	uint64_t offBlksBitmap;
376	/** Block map. */
377	PVCIBLKMAP pBlkMap;
378	} VCICACHE, *PVCICACHE;
379
380	/** No block free in bitmap error code. */
381	#define VERR_VCI_NO_BLOCKS_FREE (-65536)
382
383	/** Flags for the block map allocator. */
384	#define VCIBLKMAP_ALLOC_DATA 0
385	#define VCIBLKMAP_ALLOC_META RT_BIT(0)
386	#define VCIBLKMAP_ALLOC_MASK 0x1
387
388
389	/*********************************************************************************************************************************
390	* Static Variables *
391	*********************************************************************************************************************************/
392
393	/** NULL-terminated array of supported file extensions. */
394	static const char *const s_apszVciFileExtensions[] =
395	{
396	"vci",
397	NULL
398	};
399
400
401	/*********************************************************************************************************************************
402	* Internal Functions *
403	*********************************************************************************************************************************/
404
405	/**
406	* Internal. Flush image data to disk.
407	*/
408	static int vciFlushImage(PVCICACHE pCache)
409	{
410	int rc = VINF_SUCCESS;
411
412	if ( pCache->pStorage
413	&& !(pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY))
414	{
415	rc = vdIfIoIntFileFlushSync(pCache->pIfIo, pCache->pStorage);
416	}
417
418	return rc;
419	}
420
421	/**
422	* Internal. Free all allocated space for representing an image except pCache,
423	* and optionally delete the image from disk.
424	*/
425	static int vciFreeImage(PVCICACHE pCache, bool fDelete)
426	{
427	int rc = VINF_SUCCESS;
428
429	/* Freeing a never allocated image (e.g. because the open failed) is
430	* not signalled as an error. After all nothing bad happens. */
431	if (pCache)
432	{
433	if (pCache->pStorage)
434	{
435	/* No point updating the file that is deleted anyway. */
436	if (!fDelete)
437	vciFlushImage(pCache);
438
439	vdIfIoIntFileClose(pCache->pIfIo, pCache->pStorage);
440	pCache->pStorage = NULL;
441	}
442
443	if (fDelete && pCache->pszFilename)
444	vdIfIoIntFileDelete(pCache->pIfIo, pCache->pszFilename);
445	}
446
447	LogFlowFunc(("returns %Rrc\n", rc));
448	return rc;
449	}
450
451	/**
452	* Creates a new block map which can manage the given number of blocks.
453	*
454	* The size of the bitmap is aligned to the VCI block size.
455	*
456	* @returns VBox status code.
457	* @param cBlocks The number of blocks the bitmap can manage.
458	* @param ppBlkMap Where to store the pointer to the block bitmap.
459	* @param pcBlkMap Where to store the size of the block bitmap in blocks
460	* needed on the disk.
461	*/
462	static int vciBlkMapCreate(uint64_t cBlocks, PVCIBLKMAP ppBlkMap, uint32_t pcBlkMap)
463	{
464	int rc = VINF_SUCCESS;
465	uint32_t cbBlkMap = RT_ALIGN_Z(cBlocks / sizeof(VciBlkMapEnt) / 8, VCI_BLOCK_SIZE);
466	PVCIBLKMAP pBlkMap = (PVCIBLKMAP)RTMemAllocZ(sizeof(VCIBLKMAP));
467	PVCIBLKRANGEDESC pFree = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));
468
469	LogFlowFunc(("cBlocks=%u ppBlkMap=%#p pcBlkMap=%#p\n", cBlocks, ppBlkMap, pcBlkMap));
470
471	if (pBlkMap && pFree)
472	{
473	pBlkMap->cBlocks = cBlocks;
474	pBlkMap->cBlocksAllocMeta = 0;
475	pBlkMap->cBlocksAllocData = 0;
476	pBlkMap->cBlocksFree = cBlocks;
477
478	pFree->pPrev = NULL;
479	pFree->pNext = NULL;
480	pFree->offAddrStart = 0;
481	pFree->cBlocks = cBlocks;
482	pFree->fFree = true;
483
484	pBlkMap->pRangesHead = pFree;
485	pBlkMap->pRangesTail = pFree;
486
487	Assert(!((cbBlkMap + sizeof(VciBlkMap)) % VCI_BLOCK_SIZE));
488	*ppBlkMap = pBlkMap;
489	*pcBlkMap = VCI_BYTE2BLOCK(cbBlkMap + sizeof(VciBlkMap));
490	}
491	else
492	{
493	if (pBlkMap)
494	RTMemFree(pBlkMap);
495	if (pFree)
496	RTMemFree(pFree);
497
498	rc = VERR_NO_MEMORY;
499	}
500
501	LogFlowFunc(("returns rc=%Rrc cBlkMap=%u\n", rc, *pcBlkMap));
502	return rc;
503	}
504
505	#if 0 /** @todo unsued vciBlkMapDestroy */
506	/**
507	* Frees a block map.
508	*
509	* @param pBlkMap The block bitmap to destroy.
510	*/
511	static void vciBlkMapDestroy(PVCIBLKMAP pBlkMap)
512	{
513	LogFlowFunc(("pBlkMap=%#p\n", pBlkMap));
514
515	PVCIBLKRANGEDESC pRangeCur = pBlkMap->pRangesHead;
516
517	while (pRangeCur)
518	{
519	PVCIBLKRANGEDESC pTmp = pRangeCur;
520
521	RTMemFree(pTmp);
522
523	pRangeCur = pRangeCur->pNext;
524	}
525
526	RTMemFree(pBlkMap);
527
528	LogFlowFunc(("returns\n"));
529	}
530	#endif
531
532	/**
533	* Loads the block map from the specified medium and creates all necessary
534	* in memory structures to manage used and free blocks.
535	*
536	* @returns VBox status code.
537	* @param pStorage Storage handle to read the block bitmap from.
538	* @param offBlkMap Start of the block bitmap in blocks.
539	* @param cBlkMap Size of the block bitmap on the disk in blocks.
540	* @param ppBlkMap Where to store the block bitmap on success.
541	*/
542	static int vciBlkMapLoad(PVCICACHE pStorage, uint64_t offBlkMap, uint32_t cBlkMap, PVCIBLKMAP *ppBlkMap)
543	{
544	int rc = VINF_SUCCESS;
545	VciBlkMap BlkMap;
546
547	LogFlowFunc(("pStorage=%#p offBlkMap=%llu cBlkMap=%u ppBlkMap=%#p\n",
548	pStorage, offBlkMap, cBlkMap, ppBlkMap));
549
550	if (cBlkMap >= VCI_BYTE2BLOCK(sizeof(VciBlkMap)))
551	{
552	cBlkMap -= VCI_BYTE2BLOCK(sizeof(VciBlkMap));
553
554	rc = vdIfIoIntFileReadSync(pStorage->pIfIo, pStorage->pStorage, offBlkMap,
555	&BlkMap, VCI_BYTE2BLOCK(sizeof(VciBlkMap)));
556	if (RT_SUCCESS(rc))
557	{
558	offBlkMap += VCI_BYTE2BLOCK(sizeof(VciBlkMap));
559
560	BlkMap.u32Magic = RT_LE2H_U32(BlkMap.u32Magic);
561	BlkMap.u32Version = RT_LE2H_U32(BlkMap.u32Version);
562	BlkMap.cBlocks = RT_LE2H_U32(BlkMap.cBlocks);
563	BlkMap.cBlocksFree = RT_LE2H_U32(BlkMap.cBlocksFree);
564	BlkMap.cBlocksAllocMeta = RT_LE2H_U32(BlkMap.cBlocksAllocMeta);
565	BlkMap.cBlocksAllocData = RT_LE2H_U32(BlkMap.cBlocksAllocData);
566
567	if ( BlkMap.u32Magic == VCI_BLKMAP_MAGIC
568	&& BlkMap.u32Version == VCI_BLKMAP_VERSION
569	&& BlkMap.cBlocks == BlkMap.cBlocksFree + BlkMap.cBlocksAllocMeta + BlkMap.cBlocksAllocData
570	&& VCI_BYTE2BLOCK(BlkMap.cBlocks / 8) == cBlkMap)
571	{
572	PVCIBLKMAP pBlkMap = (PVCIBLKMAP)RTMemAllocZ(sizeof(VCIBLKMAP));
573	if (pBlkMap)
574	{
575	pBlkMap->cBlocks = BlkMap.cBlocks;
576	pBlkMap->cBlocksFree = BlkMap.cBlocksFree;
577	pBlkMap->cBlocksAllocMeta = BlkMap.cBlocksAllocMeta;
578	pBlkMap->cBlocksAllocData = BlkMap.cBlocksAllocData;
579
580	/* Load the bitmap and construct the range list. */
581	PVCIBLKRANGEDESC pRangeCur = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));
582
583	if (pRangeCur)
584	{
585	uint8_t abBitmapBuffer[16 * _1K];
586	uint32_t cBlocksRead = 0;
587	uint64_t cBlocksLeft = VCI_BYTE2BLOCK(pBlkMap->cBlocks / 8);
588
589	cBlocksRead = RT_MIN(VCI_BYTE2BLOCK(sizeof(abBitmapBuffer)), cBlocksLeft);
590	rc = vdIfIoIntFileReadSync(pStorage->pIfIo, pStorage->pStorage,
591	offBlkMap, abBitmapBuffer,
592	cBlocksRead);
593
594	if (RT_SUCCESS(rc))
595	{
596	pRangeCur->fFree = !(abBitmapBuffer[0] & 0x01);
597	pRangeCur->offAddrStart = 0;
598	pRangeCur->cBlocks = 0;
599	pRangeCur->pNext = NULL;
600	pRangeCur->pPrev = NULL;
601	pBlkMap->pRangesHead = pRangeCur;
602	pBlkMap->pRangesTail = pRangeCur;
603	}
604	else
605	RTMemFree(pRangeCur);
606
607	while ( RT_SUCCESS(rc)
608	&& cBlocksLeft)
609	{
610	int iBit = 0;
611	uint32_t cBits = VCI_BLOCK2BYTE(cBlocksRead) * 8;
612	uint32_t iBitPrev = 0xffffffff;
613
614	while (cBits)
615	{
616	if (pRangeCur->fFree)
617	{
618	/* Check for the first set bit. */
619	iBit = ASMBitNextSet(abBitmapBuffer, cBits, iBitPrev);
620	}
621	else
622	{
623	/* Check for the first free bit. */
624	iBit = ASMBitNextClear(abBitmapBuffer, cBits, iBitPrev);
625	}
626
627	if (iBit == -1)
628	{
629	/* No change. */
630	pRangeCur->cBlocks += cBits;
631	cBits = 0;
632	}
633	else
634	{
635	Assert((uint32_t)iBit < cBits);
636	pRangeCur->cBlocks += iBit;
637
638	/* Create a new range descriptor. */
639	PVCIBLKRANGEDESC pRangeNew = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));
640	if (!pRangeNew)
641	{
642	rc = VERR_NO_MEMORY;
643	break;
644	}
645
646	pRangeNew->fFree = !pRangeCur->fFree;
647	pRangeNew->offAddrStart = pRangeCur->offAddrStart + pRangeCur->cBlocks;
648	pRangeNew->cBlocks = 0;
649	pRangeNew->pPrev = pRangeCur;
650	pRangeCur->pNext = pRangeNew;
651	pBlkMap->pRangesTail = pRangeNew;
652	pRangeCur = pRangeNew;
653	cBits -= iBit;
654	iBitPrev = iBit;
655	}
656	}
657
658	cBlocksLeft -= cBlocksRead;
659	offBlkMap += cBlocksRead;
660
661	if ( RT_SUCCESS(rc)
662	&& cBlocksLeft)
663	{
664	/* Read next chunk. */
665	cBlocksRead = RT_MIN(VCI_BYTE2BLOCK(sizeof(abBitmapBuffer)), cBlocksLeft);
666	rc = vdIfIoIntFileReadSync(pStorage->pIfIo, pStorage->pStorage,
667	offBlkMap, abBitmapBuffer, cBlocksRead);
668	}
669	}
670	}
671	else
672	rc = VERR_NO_MEMORY;
673
674	if (RT_SUCCESS(rc))
675	{
676	*ppBlkMap = pBlkMap;
677	LogFlowFunc(("return success\n"));
678	return VINF_SUCCESS;
679	}
680
681	RTMemFree(pBlkMap);
682	}
683	else
684	rc = VERR_NO_MEMORY;
685	}
686	else
687	rc = VERR_VD_GEN_INVALID_HEADER;
688	}
689	else
690	rc = VERR_VD_GEN_INVALID_HEADER;
691	}
692	else
693	rc = VERR_VD_GEN_INVALID_HEADER;
694
695	LogFlowFunc(("returns rc=%Rrc\n", rc));
696	return rc;
697	}
698
699	/**
700	* Saves the block map in the cache image. All necessary on disk structures
701	* are written.
702	*
703	* @returns VBox status code.
704	* @param pBlkMap The block bitmap to save.
705	* @param pStorage Where the block bitmap should be written to.
706	* @param offBlkMap Start of the block bitmap in blocks.
707	* @param cBlkMap Size of the block bitmap on the disk in blocks.
708	*/
709	static int vciBlkMapSave(PVCIBLKMAP pBlkMap, PVCICACHE pStorage, uint64_t offBlkMap, uint32_t cBlkMap)
710	{
711	int rc = VINF_SUCCESS;
712	VciBlkMap BlkMap;
713
714	LogFlowFunc(("pBlkMap=%#p pStorage=%#p offBlkMap=%llu cBlkMap=%u\n",
715	pBlkMap, pStorage, offBlkMap, cBlkMap));
716
717	/* Make sure the number of blocks allocated for us match our expectations. */
718	if (VCI_BYTE2BLOCK(pBlkMap->cBlocks / 8) + VCI_BYTE2BLOCK(sizeof(VciBlkMap)) == cBlkMap)
719	{
720	/* Setup the header */
721	memset(&BlkMap, 0, sizeof(VciBlkMap));
722
723	BlkMap.u32Magic = RT_H2LE_U32(VCI_BLKMAP_MAGIC);
724	BlkMap.u32Version = RT_H2LE_U32(VCI_BLKMAP_VERSION);
725	BlkMap.cBlocks = RT_H2LE_U32(pBlkMap->cBlocks);
726	BlkMap.cBlocksFree = RT_H2LE_U32(pBlkMap->cBlocksFree);
727	BlkMap.cBlocksAllocMeta = RT_H2LE_U32(pBlkMap->cBlocksAllocMeta);
728	BlkMap.cBlocksAllocData = RT_H2LE_U32(pBlkMap->cBlocksAllocData);
729
730	rc = vdIfIoIntFileWriteSync(pStorage->pIfIo, pStorage->pStorage, offBlkMap,
731	&BlkMap, VCI_BYTE2BLOCK(sizeof(VciBlkMap)));
732	if (RT_SUCCESS(rc))
733	{
734	uint8_t abBitmapBuffer[16*_1K];
735	unsigned iBit = 0;
736	PVCIBLKRANGEDESC pCur = pBlkMap->pRangesHead;
737
738	offBlkMap += VCI_BYTE2BLOCK(sizeof(VciBlkMap));
739
740	/* Write the descriptor ranges. */
741	while (pCur)
742	{
743	uint64_t cBlocks = pCur->cBlocks;
744
745	while (cBlocks)
746	{
747	uint64_t cBlocksMax = RT_MIN(cBlocks, sizeof(abBitmapBuffer) * 8 - iBit);
748
749	if (pCur->fFree)
750	ASMBitClearRange(abBitmapBuffer, iBit, iBit + cBlocksMax);
751	else
752	ASMBitSetRange(abBitmapBuffer, iBit, iBit + cBlocksMax);
753
754	iBit += cBlocksMax;
755	cBlocks -= cBlocksMax;
756
757	if (iBit == sizeof(abBitmapBuffer) * 8)
758	{
759	/* Buffer is full, write to file and reset. */
760	rc = vdIfIoIntFileWriteSync(pStorage->pIfIo, pStorage->pStorage,
761	offBlkMap, abBitmapBuffer,
762	VCI_BYTE2BLOCK(sizeof(abBitmapBuffer)));
763	if (RT_FAILURE(rc))
764	break;
765
766	offBlkMap += VCI_BYTE2BLOCK(sizeof(abBitmapBuffer));
767	iBit = 0;
768	}
769	}
770
771	pCur = pCur->pNext;
772	}
773
774	Assert(iBit % 8 == 0);
775
776	if (RT_SUCCESS(rc) && iBit)
777	rc = vdIfIoIntFileWriteSync(pStorage->pIfIo, pStorage->pStorage,
778	offBlkMap, abBitmapBuffer, VCI_BYTE2BLOCK(iBit / 8));
779	}
780	}
781	else
782	rc = VERR_INTERNAL_ERROR; /** @todo Better error code. */
783
784	LogFlowFunc(("returns rc=%Rrc\n", rc));
785	return rc;
786	}
787
788	#if 0 /* unused */
789	/**
790	* Finds the range block describing the given block address.
791	*
792	* @returns Pointer to the block range descriptor or NULL if none could be found.
793	* @param pBlkMap The block bitmap to search on.
794	* @param offBlockAddr The block address to search for.
795	*/
796	static PVCIBLKRANGEDESC vciBlkMapFindByBlock(PVCIBLKMAP pBlkMap, uint64_t offBlockAddr)
797	{
798	PVCIBLKRANGEDESC pBlk = pBlkMap->pRangesHead;
799
800	while ( pBlk
801	&& pBlk->offAddrStart < offBlockAddr)
802	pBlk = pBlk->pNext;
803
804	return pBlk;
805	}
806	#endif
807
808	/**
809	* Allocates the given number of blocks in the bitmap and returns the start block address.
810	*
811	* @returns VBox status code.
812	* @param pBlkMap The block bitmap to allocate the blocks from.
813	* @param cBlocks How many blocks to allocate.
814	* @param fFlags Allocation flags, comgination of VCIBLKMAP_ALLOC_*.
815	* @param poffBlockAddr Where to store the start address of the allocated region.
816	*/
817	static int vciBlkMapAllocate(PVCIBLKMAP pBlkMap, uint32_t cBlocks, uint32_t fFlags,
818	uint64_t *poffBlockAddr)
819	{
820	PVCIBLKRANGEDESC pBestFit = NULL;
821	PVCIBLKRANGEDESC pCur = NULL;
822	int rc = VINF_SUCCESS;
823
824	LogFlowFunc(("pBlkMap=%#p cBlocks=%u poffBlockAddr=%#p\n",
825	pBlkMap, cBlocks, poffBlockAddr));
826
827	pCur = pBlkMap->pRangesHead;
828
829	while (pCur)
830	{
831	if ( pCur->fFree
832	&& pCur->cBlocks >= cBlocks)
833	{
834	if ( !pBestFit
835	\|\| pCur->cBlocks < pBestFit->cBlocks)
836	{
837	pBestFit = pCur;
838	/* Stop searching if the size is matching exactly. */
839	if (pBestFit->cBlocks == cBlocks)
840	break;
841	}
842	}
843	pCur = pCur->pNext;
844	}
845
846	Assert(!pBestFit \|\| pBestFit->fFree);
847
848	if (pBestFit)
849	{
850	pBestFit->fFree = false;
851
852	if (pBestFit->cBlocks > cBlocks)
853	{
854	/* Create a new free block. */
855	PVCIBLKRANGEDESC pFree = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));
856
857	if (pFree)
858	{
859	pFree->fFree = true;
860	pFree->cBlocks = pBestFit->cBlocks - cBlocks;
861	pBestFit->cBlocks -= pFree->cBlocks;
862	pFree->offAddrStart = pBestFit->offAddrStart + cBlocks;
863
864	/* Link into the list. */
865	pFree->pNext = pBestFit->pNext;
866	pBestFit->pNext = pFree;
867	pFree->pPrev = pBestFit;
868	if (!pFree->pNext)
869	pBlkMap->pRangesTail = pFree;
870
871	*poffBlockAddr = pBestFit->offAddrStart;
872	}
873	else
874	{
875	rc = VERR_NO_MEMORY;
876	pBestFit->fFree = true;
877	}
878	}
879	}
880	else
881	rc = VERR_VCI_NO_BLOCKS_FREE;
882
883	if (RT_SUCCESS(rc))
884	{
885	if ((fFlags & VCIBLKMAP_ALLOC_MASK) == VCIBLKMAP_ALLOC_DATA)
886	pBlkMap->cBlocksAllocMeta += cBlocks;
887	else
888	pBlkMap->cBlocksAllocData += cBlocks;
889
890	pBlkMap->cBlocksFree -= cBlocks;
891	}
892
893	LogFlowFunc(("returns rc=%Rrc offBlockAddr=%llu\n", rc, *poffBlockAddr));
894	return rc;
895	}
896
897	#if 0 /* unused */
898	/**
899	* Try to extend the space of an already allocated block.
900	*
901	* @returns VBox status code.
902	* @param pBlkMap The block bitmap to allocate the blocks from.
903	* @param cBlocksNew How many blocks the extended block should have.
904	* @param offBlockAddrOld The start address of the block to reallocate.
905	* @param poffBlockAddr Where to store the start address of the allocated region.
906	*/
907	static int vciBlkMapRealloc(PVCIBLKMAP pBlkMap, uint32_t cBlocksNew, uint64_t offBlockAddrOld,
908	uint64_t *poffBlockAddr)
909	{
910	int rc = VINF_SUCCESS;
911
912	LogFlowFunc(("pBlkMap=%#p cBlocksNew=%u offBlockAddrOld=%llu poffBlockAddr=%#p\n",
913	pBlkMap, cBlocksNew, offBlockAddrOld, poffBlockAddr));
914
915	AssertMsgFailed(("Implement\n"));
916	RT_NOREF4(pBlkMap, cBlocksNew, offBlockAddrOld, poffBlockAddr);
917
918	LogFlowFunc(("returns rc=%Rrc offBlockAddr=%llu\n", rc, *poffBlockAddr));
919	return rc;
920	}
921	#endif /* unused */
922
923	#if 0 /* unused */
924	/**
925	* Frees a range of blocks.
926	*
927	* @param pBlkMap The block bitmap.
928	* @param offBlockAddr Address of the first block to free.
929	* @param cBlocks How many blocks to free.
930	* @param fFlags Allocation flags, comgination of VCIBLKMAP_ALLOC_*.
931	*/
932	static void vciBlkMapFree(PVCIBLKMAP pBlkMap, uint64_t offBlockAddr, uint32_t cBlocks,
933	uint32_t fFlags)
934	{
935	PVCIBLKRANGEDESC pBlk;
936
937	LogFlowFunc(("pBlkMap=%#p offBlockAddr=%llu cBlocks=%u\n",
938	pBlkMap, offBlockAddr, cBlocks));
939
940	while (cBlocks)
941	{
942	pBlk = vciBlkMapFindByBlock(pBlkMap, offBlockAddr);
943	AssertPtr(pBlk);
944
945	/* Easy case, the whole block is freed. */
946	if ( pBlk->offAddrStart == offBlockAddr
947	&& pBlk->cBlocks <= cBlocks)
948	{
949	pBlk->fFree = true;
950	cBlocks -= pBlk->cBlocks;
951	offBlockAddr += pBlk->cBlocks;
952
953	/* Check if it is possible to merge free blocks. */
954	if ( pBlk->pPrev
955	&& pBlk->pPrev->fFree)
956	{
957	PVCIBLKRANGEDESC pBlkPrev = pBlk->pPrev;
958
959	Assert(pBlkPrev->offAddrStart + pBlkPrev->cBlocks == pBlk->offAddrStart);
960	pBlkPrev->cBlocks += pBlk->cBlocks;
961	pBlkPrev->pNext = pBlk->pNext;
962	if (pBlk->pNext)
963	pBlk->pNext->pPrev = pBlkPrev;
964	else
965	pBlkMap->pRangesTail = pBlkPrev;
966
967	RTMemFree(pBlk);
968	pBlk = pBlkPrev;
969	}
970
971	/* Now the one to the right. */
972	if ( pBlk->pNext
973	&& pBlk->pNext->fFree)
974	{
975	PVCIBLKRANGEDESC pBlkNext = pBlk->pNext;
976
977	Assert(pBlk->offAddrStart + pBlk->cBlocks == pBlkNext->offAddrStart);
978	pBlk->cBlocks += pBlkNext->cBlocks;
979	pBlk->pNext = pBlkNext->pNext;
980	if (pBlkNext->pNext)
981	pBlkNext->pNext->pPrev = pBlk;
982	else
983	pBlkMap->pRangesTail = pBlk;
984
985	RTMemFree(pBlkNext);
986	}
987	}
988	else
989	{
990	/* The block is intersecting. */
991	AssertMsgFailed(("TODO\n"));
992	}
993	}
994
995	if ((fFlags & VCIBLKMAP_ALLOC_MASK) == VCIBLKMAP_ALLOC_DATA)
996	pBlkMap->cBlocksAllocMeta -= cBlocks;
997	else
998	pBlkMap->cBlocksAllocData -= cBlocks;
999
1000	pBlkMap->cBlocksFree += cBlocks;
1001
1002	LogFlowFunc(("returns\n"));
1003	}
1004	#endif /* unused */
1005
1006	/**
1007	* Converts a tree node from the image to the in memory structure.
1008	*
1009	* @returns Pointer to the in memory tree node.
1010	* @param offBlockAddrNode Block address of the node.
1011	* @param pNodeImage Pointer to the image representation of the node.
1012	*/
1013	static PVCITREENODE vciTreeNodeImage2Host(uint64_t offBlockAddrNode, PVciTreeNode pNodeImage)
1014	{
1015	PVCITREENODE pNode = NULL;
1016
1017	if (pNodeImage->u8Type == VCI_TREE_NODE_TYPE_LEAF)
1018	{
1019	PVCITREENODELEAF pLeaf = (PVCITREENODELEAF)RTMemAllocZ(sizeof(VCITREENODELEAF));
1020
1021	if (pLeaf)
1022	{
1023	PVciCacheExtent pExtent = (PVciCacheExtent)&pNodeImage->au8Data[0];
1024
1025	pLeaf->Core.u8Type = VCI_TREE_NODE_TYPE_LEAF;
1026
1027	for (unsigned idx = 0; idx < RT_ELEMENTS(pLeaf->aExtents); idx++)
1028	{
1029	pLeaf->aExtents[idx].u64BlockOffset = RT_LE2H_U64(pExtent->u64BlockOffset);
1030	pLeaf->aExtents[idx].u32Blocks = RT_LE2H_U32(pExtent->u32Blocks);
1031	pLeaf->aExtents[idx].u64BlockAddr = RT_LE2H_U64(pExtent->u64BlockAddr);
1032	pExtent++;
1033
1034	if ( pLeaf->aExtents[idx].u32Blocks
1035	&& pLeaf->aExtents[idx].u64BlockAddr)
1036	pLeaf->cUsedNodes++;
1037	}
1038
1039	pNode = &pLeaf->Core;
1040	}
1041	}
1042	else if (pNodeImage->u8Type == VCI_TREE_NODE_TYPE_INTERNAL)
1043	{
1044	PVCITREENODEINT pInt = (PVCITREENODEINT)RTMemAllocZ(sizeof(VCITREENODEINT));
1045
1046	if (pInt)
1047	{
1048	PVciTreeNodeInternal pIntImage = (PVciTreeNodeInternal)&pNodeImage->au8Data[0];
1049
1050	pInt->Core.u8Type = VCI_TREE_NODE_TYPE_INTERNAL;
1051
1052	for (unsigned idx = 0; idx < RT_ELEMENTS(pInt->aIntNodes); idx++)
1053	{
1054	pInt->aIntNodes[idx].u64BlockOffset = RT_LE2H_U64(pIntImage->u64BlockOffset);
1055	pInt->aIntNodes[idx].u32Blocks = RT_LE2H_U32(pIntImage->u32Blocks);
1056	pInt->aIntNodes[idx].PtrChild.fInMemory = false;
1057	pInt->aIntNodes[idx].PtrChild.u.offAddrBlockNode = RT_LE2H_U64(pIntImage->u64ChildAddr);
1058	pIntImage++;
1059
1060	if ( pInt->aIntNodes[idx].u32Blocks
1061	&& pInt->aIntNodes[idx].PtrChild.u.offAddrBlockNode)
1062	pInt->cUsedNodes++;
1063	}
1064
1065	pNode = &pInt->Core;
1066	}
1067	}
1068	else
1069	AssertMsgFailed(("Invalid node type %d\n", pNodeImage->u8Type));
1070
1071	if (pNode)
1072	pNode->u64BlockAddr = offBlockAddrNode;
1073
1074	return pNode;
1075	}
1076
1077	/**
1078	* Looks up the cache extent for the given virtual block address.
1079	*
1080	* @returns Pointer to the cache extent or NULL if none could be found.
1081	* @param pCache The cache image instance.
1082	* @param offBlockOffset The block offset to search for.
1083	* @param ppNextBestFit Where to store the pointer to the next best fit
1084	* cache extent above offBlockOffset if existing. - Optional
1085	* This is always filled if possible even if the function returns NULL.
1086	*/
1087	static PVCICACHEEXTENT vciCacheExtentLookup(PVCICACHE pCache, uint64_t offBlockOffset,
1088	PVCICACHEEXTENT *ppNextBestFit)
1089	{
1090	int rc = VINF_SUCCESS;
1091	PVCICACHEEXTENT pExtent = NULL;
1092	PVCITREENODE pNodeCur = pCache->pRoot;
1093
1094	while ( RT_SUCCESS(rc)
1095	&& pNodeCur
1096	&& pNodeCur->u8Type != VCI_TREE_NODE_TYPE_LEAF)
1097	{
1098	PVCITREENODEINT pNodeInt = (PVCITREENODEINT)pNodeCur;
1099
1100	Assert(pNodeCur->u8Type == VCI_TREE_NODE_TYPE_INTERNAL);
1101
1102	/* Search for the correct internal node. */
1103	unsigned idxMin = 0;
1104	unsigned idxMax = pNodeInt->cUsedNodes;
1105	unsigned idxCur = pNodeInt->cUsedNodes / 2;
1106
1107	while (idxMin < idxMax)
1108	{
1109	PVCINODEINTERNAL pInt = &pNodeInt->aIntNodes[idxCur];
1110
1111	/* Determine the search direction. */
1112	if (offBlockOffset < pInt->u64BlockOffset)
1113	{
1114	/* Search left from the current extent. */
1115	idxMax = idxCur;
1116	}
1117	else if (offBlockOffset >= pInt->u64BlockOffset + pInt->u32Blocks)
1118	{
1119	/* Search right from the current extent. */
1120	idxMin = idxCur;
1121	}
1122	else
1123	{
1124	/* The block lies in the node, stop searching. */
1125	if (pInt->PtrChild.fInMemory)
1126	pNodeCur = pInt->PtrChild.u.pNode;
1127	else
1128	{
1129	PVCITREENODE pNodeNew;
1130	VciTreeNode NodeTree;
1131
1132	/* Read from disk and add to the tree. */
1133	rc = vdIfIoIntFileReadSync(pCache->pIfIo, pCache->pStorage,
1134	VCI_BLOCK2BYTE(pInt->PtrChild.u.offAddrBlockNode),
1135	&NodeTree, sizeof(NodeTree));
1136	AssertRC(rc);
1137
1138	pNodeNew = vciTreeNodeImage2Host(pInt->PtrChild.u.offAddrBlockNode, &NodeTree);
1139	if (pNodeNew)
1140	{
1141	/* Link to the parent. */
1142	pInt->PtrChild.fInMemory = true;
1143	pInt->PtrChild.u.pNode = pNodeNew;
1144	pNodeNew->pParent = pNodeCur;
1145	pNodeCur = pNodeNew;
1146	}
1147	else
1148	rc = VERR_NO_MEMORY;
1149	}
1150	break;
1151	}
1152
1153	idxCur = idxMin + (idxMax - idxMin) / 2;
1154	}
1155	}
1156
1157	if ( RT_SUCCESS(rc)
1158	&& pNodeCur)
1159	{
1160	PVCITREENODELEAF pLeaf = (PVCITREENODELEAF)pNodeCur;
1161	Assert(pNodeCur->u8Type == VCI_TREE_NODE_TYPE_LEAF);
1162
1163	/* Search the range. */
1164	unsigned idxMin = 0;
1165	unsigned idxMax = pLeaf->cUsedNodes;
1166	unsigned idxCur = pLeaf->cUsedNodes / 2;
1167
1168	while (idxMin < idxMax)
1169	{
1170	PVCICACHEEXTENT pExtentCur = &pLeaf->aExtents[idxCur];
1171
1172	/* Determine the search direction. */
1173	if (offBlockOffset < pExtentCur->u64BlockOffset)
1174	{
1175	/* Search left from the current extent. */
1176	idxMax = idxCur;
1177	}
1178	else if (offBlockOffset >= pExtentCur->u64BlockOffset + pExtentCur->u32Blocks)
1179	{
1180	/* Search right from the current extent. */
1181	idxMin = idxCur;
1182	}
1183	else
1184	{
1185	/* We found the extent, stop searching. */
1186	pExtent = pExtentCur;
1187	break;
1188	}
1189
1190	idxCur = idxMin + (idxMax - idxMin) / 2;
1191	}
1192
1193	/* Get the next best fit extent if it exists. */
1194	if (ppNextBestFit)
1195	{
1196	if (idxCur < pLeaf->cUsedNodes - 1)
1197	*ppNextBestFit = &pLeaf->aExtents[idxCur + 1];
1198	else
1199	{
1200	/*
1201	* Go up the tree and find the best extent
1202	* in the leftmost tree of the child subtree to the right.
1203	*/
1204	PVCITREENODEINT pInt = (PVCITREENODEINT)pLeaf->Core.pParent;
1205
1206	while (pInt)
1207	{
1208
1209	}
1210	}
1211	}
1212	}
1213
1214	return pExtent;
1215	}
1216
1217	/**
1218	* Internal: Open an image, constructing all necessary data structures.
1219	*/
1220	static int vciOpenImage(PVCICACHE pCache, unsigned uOpenFlags)
1221	{
1222	VciHdr Hdr;
1223	uint64_t cbFile;
1224	int rc;
1225
1226	pCache->uOpenFlags = uOpenFlags;
1227
1228	pCache->pIfError = VDIfErrorGet(pCache->pVDIfsDisk);
1229	pCache->pIfIo = VDIfIoIntGet(pCache->pVDIfsImage);
1230	AssertPtrReturn(pCache->pIfIo, VERR_INVALID_PARAMETER);
1231
1232	/*
1233	* Open the image.
1234	*/
1235	rc = vdIfIoIntFileOpen(pCache->pIfIo, pCache->pszFilename,
1236	VDOpenFlagsToFileOpenFlags(uOpenFlags,
1237	false /* fCreate */),
1238	&pCache->pStorage);
1239	if (RT_FAILURE(rc))
1240	{
1241	/* Do NOT signal an appropriate error here, as the VD layer has the
1242	* choice of retrying the open if it failed. */
1243	goto out;
1244	}
1245
1246	rc = vdIfIoIntFileGetSize(pCache->pIfIo, pCache->pStorage, &cbFile);
1247	if (RT_FAILURE(rc) \|\| cbFile < sizeof(VciHdr))
1248	{
1249	rc = VERR_VD_GEN_INVALID_HEADER;
1250	goto out;
1251	}
1252
1253	rc = vdIfIoIntFileReadSync(pCache->pIfIo, pCache->pStorage, 0, &Hdr,
1254	VCI_BYTE2BLOCK(sizeof(Hdr)));
1255	if (RT_FAILURE(rc))
1256	{
1257	rc = VERR_VD_GEN_INVALID_HEADER;
1258	goto out;
1259	}
1260
1261	Hdr.u32Signature = RT_LE2H_U32(Hdr.u32Signature);
1262	Hdr.u32Version = RT_LE2H_U32(Hdr.u32Version);
1263	Hdr.cBlocksCache = RT_LE2H_U64(Hdr.cBlocksCache);
1264	Hdr.u32CacheType = RT_LE2H_U32(Hdr.u32CacheType);
1265	Hdr.offTreeRoot = RT_LE2H_U64(Hdr.offTreeRoot);
1266	Hdr.offBlkMap = RT_LE2H_U64(Hdr.offBlkMap);
1267	Hdr.cBlkMap = RT_LE2H_U32(Hdr.cBlkMap);
1268
1269	if ( Hdr.u32Signature == VCI_HDR_SIGNATURE
1270	&& Hdr.u32Version == VCI_HDR_VERSION)
1271	{
1272	pCache->offTreeRoot = Hdr.offTreeRoot;
1273	pCache->offBlksBitmap = Hdr.offBlkMap;
1274
1275	/* Load the block map. */
1276	rc = vciBlkMapLoad(pCache, pCache->offBlksBitmap, Hdr.cBlkMap, &pCache->pBlkMap);
1277	if (RT_SUCCESS(rc))
1278	{
1279	/* Load the first tree node. */
1280	VciTreeNode RootNode;
1281
1282	rc = vdIfIoIntFileReadSync(pCache->pIfIo, pCache->pStorage,
1283	pCache->offTreeRoot, &RootNode,
1284	VCI_BYTE2BLOCK(sizeof(VciTreeNode)));
1285	if (RT_SUCCESS(rc))
1286	{
1287	pCache->pRoot = vciTreeNodeImage2Host(pCache->offTreeRoot, &RootNode);
1288	if (!pCache->pRoot)
1289	rc = VERR_NO_MEMORY;
1290	}
1291	}
1292	}
1293	else
1294	rc = VERR_VD_GEN_INVALID_HEADER;
1295
1296	out:
1297	if (RT_FAILURE(rc))
1298	vciFreeImage(pCache, false);
1299	return rc;
1300	}
1301
1302	/**
1303	* Internal: Create a vci image.
1304	*/
1305	static int vciCreateImage(PVCICACHE pCache, uint64_t cbSize,
1306	unsigned uImageFlags, const char *pszComment,
1307	unsigned uOpenFlags, PFNVDPROGRESS pfnProgress,
1308	void *pvUser, unsigned uPercentStart,
1309	unsigned uPercentSpan)
1310	{
1311	RT_NOREF1(pszComment);
1312	VciHdr Hdr;
1313	VciTreeNode NodeRoot;
1314	int rc;
1315	uint64_t cBlocks = cbSize / VCI_BLOCK_SIZE; /* Size of the cache in blocks. */
1316
1317	pCache->uImageFlags = uImageFlags;
1318	pCache->uOpenFlags = uOpenFlags & ~VD_OPEN_FLAGS_READONLY;
1319
1320	pCache->pIfError = VDIfErrorGet(pCache->pVDIfsDisk);
1321	pCache->pIfIo = VDIfIoIntGet(pCache->pVDIfsImage);
1322	AssertPtrReturn(pCache->pIfIo, VERR_INVALID_PARAMETER);
1323
1324	if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
1325	{
1326	rc = vdIfError(pCache->pIfError, VERR_VD_RAW_INVALID_TYPE, RT_SRC_POS, N_("VCI: cannot create diff image '%s'"), pCache->pszFilename);
1327	return rc;
1328	}
1329
1330	do
1331	{
1332	/* Create image file. */
1333	rc = vdIfIoIntFileOpen(pCache->pIfIo, pCache->pszFilename,
1334	VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
1335	true /* fCreate */),
1336	&pCache->pStorage);
1337	if (RT_FAILURE(rc))
1338	{
1339	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot create image '%s'"), pCache->pszFilename);
1340	break;
1341	}
1342
1343	/* Allocate block bitmap. */
1344	uint32_t cBlkMap = 0;
1345	rc = vciBlkMapCreate(cBlocks, &pCache->pBlkMap, &cBlkMap);
1346	if (RT_FAILURE(rc))
1347	{
1348	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot create block bitmap '%s'"), pCache->pszFilename);
1349	break;
1350	}
1351
1352	/*
1353	* Allocate space for the header in the block bitmap.
1354	* Because the block map is empty the header has to start at block 0
1355	*/
1356	uint64_t offHdr = 0;
1357	rc = vciBlkMapAllocate(pCache->pBlkMap, VCI_BYTE2BLOCK(sizeof(VciHdr)), VCIBLKMAP_ALLOC_META, &offHdr);
1358	if (RT_FAILURE(rc))
1359	{
1360	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot allocate space for header in block bitmap '%s'"), pCache->pszFilename);
1361	break;
1362	}
1363
1364	Assert(offHdr == 0);
1365
1366	/*
1367	* Allocate space for the block map itself.
1368	*/
1369	uint64_t offBlkMap = 0;
1370	rc = vciBlkMapAllocate(pCache->pBlkMap, cBlkMap, VCIBLKMAP_ALLOC_META, &offBlkMap);
1371	if (RT_FAILURE(rc))
1372	{
1373	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot allocate space for block map in block map '%s'"), pCache->pszFilename);
1374	break;
1375	}
1376
1377	/*
1378	* Allocate space for the tree root node.
1379	*/
1380	uint64_t offTreeRoot = 0;
1381	rc = vciBlkMapAllocate(pCache->pBlkMap, VCI_BYTE2BLOCK(sizeof(VciTreeNode)), VCIBLKMAP_ALLOC_META, &offTreeRoot);
1382	if (RT_FAILURE(rc))
1383	{
1384	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot allocate space for block map in block map '%s'"), pCache->pszFilename);
1385	break;
1386	}
1387
1388	/*
1389	* Allocate the in memory root node.
1390	*/
1391	pCache->pRoot = (PVCITREENODE)RTMemAllocZ(sizeof(VCITREENODELEAF));
1392	if (!pCache->pRoot)
1393	{
1394	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot allocate B+-Tree root pointer '%s'"), pCache->pszFilename);
1395	break;
1396	}
1397
1398	pCache->pRoot->u8Type = VCI_TREE_NODE_TYPE_LEAF;
1399	/* Rest remains 0 as the tree is still empty. */
1400
1401	/*
1402	* Now that we are here we have all the basic structures and know where to place them in the image.
1403	* It's time to write it now.
1404	*/
1405
1406	/* Setup the header. */
1407	memset(&Hdr, 0, sizeof(VciHdr));
1408	Hdr.u32Signature = RT_H2LE_U32(VCI_HDR_SIGNATURE);
1409	Hdr.u32Version = RT_H2LE_U32(VCI_HDR_VERSION);
1410	Hdr.cBlocksCache = RT_H2LE_U64(cBlocks);
1411	Hdr.fUncleanShutdown = VCI_HDR_UNCLEAN_SHUTDOWN;
1412	Hdr.u32CacheType = uImageFlags & VD_IMAGE_FLAGS_FIXED
1413	? RT_H2LE_U32(VCI_HDR_CACHE_TYPE_FIXED)
1414	: RT_H2LE_U32(VCI_HDR_CACHE_TYPE_DYNAMIC);
1415	Hdr.offTreeRoot = RT_H2LE_U64(offTreeRoot);
1416	Hdr.offBlkMap = RT_H2LE_U64(offBlkMap);
1417	Hdr.cBlkMap = RT_H2LE_U32(cBlkMap);
1418
1419	rc = vdIfIoIntFileWriteSync(pCache->pIfIo, pCache->pStorage, offHdr, &Hdr,
1420	VCI_BYTE2BLOCK(sizeof(VciHdr)));
1421	if (RT_FAILURE(rc))
1422	{
1423	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot write header '%s'"), pCache->pszFilename);
1424	break;
1425	}
1426
1427	rc = vciBlkMapSave(pCache->pBlkMap, pCache, offBlkMap, cBlkMap);
1428	if (RT_FAILURE(rc))
1429	{
1430	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot write block map '%s'"), pCache->pszFilename);
1431	break;
1432	}
1433
1434	/* Setup the root tree. */
1435	memset(&NodeRoot, 0, sizeof(VciTreeNode));
1436	NodeRoot.u8Type = VCI_TREE_NODE_TYPE_LEAF;
1437
1438	rc = vdIfIoIntFileWriteSync(pCache->pIfIo, pCache->pStorage, offTreeRoot,
1439	&NodeRoot, VCI_BYTE2BLOCK(sizeof(VciTreeNode)));
1440	if (RT_FAILURE(rc))
1441	{
1442	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot write root node '%s'"), pCache->pszFilename);
1443	break;
1444	}
1445
1446	rc = vciFlushImage(pCache);
1447	if (RT_FAILURE(rc))
1448	{
1449	rc = vdIfError(pCache->pIfError, rc, RT_SRC_POS, N_("VCI: cannot flush '%s'"), pCache->pszFilename);
1450	break;
1451	}
1452
1453	pCache->cbSize = cbSize;
1454
1455	} while (0);
1456
1457	if (RT_SUCCESS(rc) && pfnProgress)
1458	pfnProgress(pvUser, uPercentStart + uPercentSpan);
1459
1460	if (RT_FAILURE(rc))
1461	vciFreeImage(pCache, rc != VERR_ALREADY_EXISTS);
1462	return rc;
1463	}
1464
1465	/** @copydoc VDCACHEBACKEND::pfnProbe */
1466	static DECLCALLBACK(int) vciProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1467	PVDINTERFACE pVDIfsImage)
1468	{
1469	RT_NOREF1(pVDIfsDisk);
1470	VciHdr Hdr;
1471	PVDIOSTORAGE pStorage = NULL;
1472	uint64_t cbFile;
1473	int rc = VINF_SUCCESS;
1474
1475	LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
1476
1477	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
1478	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
1479
1480	rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
1481	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
1482	false /* fCreate */),
1483	&pStorage);
1484	if (RT_FAILURE(rc))
1485	goto out;
1486
1487	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
1488	if (RT_FAILURE(rc) \|\| cbFile < sizeof(VciHdr))
1489	{
1490	rc = VERR_VD_GEN_INVALID_HEADER;
1491	goto out;
1492	}
1493
1494	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &Hdr, sizeof(Hdr));
1495	if (RT_FAILURE(rc))
1496	{
1497	rc = VERR_VD_GEN_INVALID_HEADER;
1498	goto out;
1499	}
1500
1501	Hdr.u32Signature = RT_LE2H_U32(Hdr.u32Signature);
1502	Hdr.u32Version = RT_LE2H_U32(Hdr.u32Version);
1503	Hdr.cBlocksCache = RT_LE2H_U64(Hdr.cBlocksCache);
1504	Hdr.u32CacheType = RT_LE2H_U32(Hdr.u32CacheType);
1505	Hdr.offTreeRoot = RT_LE2H_U64(Hdr.offTreeRoot);
1506	Hdr.offBlkMap = RT_LE2H_U64(Hdr.offBlkMap);
1507	Hdr.cBlkMap = RT_LE2H_U32(Hdr.cBlkMap);
1508
1509	if ( Hdr.u32Signature == VCI_HDR_SIGNATURE
1510	&& Hdr.u32Version == VCI_HDR_VERSION)
1511	rc = VINF_SUCCESS;
1512	else
1513	rc = VERR_VD_GEN_INVALID_HEADER;
1514
1515	out:
1516	if (pStorage)
1517	vdIfIoIntFileClose(pIfIo, pStorage);
1518
1519	LogFlowFunc(("returns %Rrc\n", rc));
1520	return rc;
1521	}
1522
1523	/** @copydoc VDCACHEBACKEND::pfnOpen */
1524	static DECLCALLBACK(int) vciOpen(const char *pszFilename, unsigned uOpenFlags,
1525	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1526	void **ppBackendData)
1527	{
1528	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
1529	int rc;
1530	PVCICACHE pCache;
1531
1532	/* Check open flags. All valid flags are supported. */
1533	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1534	{
1535	rc = VERR_INVALID_PARAMETER;
1536	goto out;
1537	}
1538
1539	/* Check remaining arguments. */
1540	if ( !RT_VALID_PTR(pszFilename)
1541	\|\| !*pszFilename)
1542	{
1543	rc = VERR_INVALID_PARAMETER;
1544	goto out;
1545	}
1546
1547
1548	pCache = (PVCICACHE)RTMemAllocZ(sizeof(VCICACHE));
1549	if (!pCache)
1550	{
1551	rc = VERR_NO_MEMORY;
1552	goto out;
1553	}
1554	pCache->pszFilename = pszFilename;
1555	pCache->pStorage = NULL;
1556	pCache->pVDIfsDisk = pVDIfsDisk;
1557	pCache->pVDIfsImage = pVDIfsImage;
1558
1559	rc = vciOpenImage(pCache, uOpenFlags);
1560	if (RT_SUCCESS(rc))
1561	*ppBackendData = pCache;
1562	else
1563	RTMemFree(pCache);
1564
1565	out:
1566	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1567	return rc;
1568	}
1569
1570	/** @copydoc VDCACHEBACKEND::pfnCreate */
1571	static DECLCALLBACK(int) vciCreate(const char *pszFilename, uint64_t cbSize,
1572	unsigned uImageFlags, const char *pszComment,
1573	PCRTUUID pUuid, unsigned uOpenFlags,
1574	unsigned uPercentStart, unsigned uPercentSpan,
1575	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1576	PVDINTERFACE pVDIfsOperation, void **ppBackendData)
1577	{
1578	RT_NOREF1(pUuid);
1579	LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p ppBackendData=%#p",
1580	pszFilename, cbSize, uImageFlags, pszComment, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
1581	int rc;
1582	PVCICACHE pCache;
1583
1584	PFNVDPROGRESS pfnProgress = NULL;
1585	void *pvUser = NULL;
1586	PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
1587	if (pIfProgress)
1588	{
1589	pfnProgress = pIfProgress->pfnProgress;
1590	pvUser = pIfProgress->Core.pvUser;
1591	}
1592
1593	/* Check open flags. All valid flags are supported. */
1594	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1595	{
1596	rc = VERR_INVALID_PARAMETER;
1597	goto out;
1598	}
1599
1600	/* Check remaining arguments. */
1601	if ( !RT_VALID_PTR(pszFilename)
1602	\|\| !*pszFilename)
1603	{
1604	rc = VERR_INVALID_PARAMETER;
1605	goto out;
1606	}
1607
1608	pCache = (PVCICACHE)RTMemAllocZ(sizeof(VCICACHE));
1609	if (!pCache)
1610	{
1611	rc = VERR_NO_MEMORY;
1612	goto out;
1613	}
1614	pCache->pszFilename = pszFilename;
1615	pCache->pStorage = NULL;
1616	pCache->pVDIfsDisk = pVDIfsDisk;
1617	pCache->pVDIfsImage = pVDIfsImage;
1618
1619	rc = vciCreateImage(pCache, cbSize, uImageFlags, pszComment, uOpenFlags,
1620	pfnProgress, pvUser, uPercentStart, uPercentSpan);
1621	if (RT_SUCCESS(rc))
1622	{
1623	/* So far the image is opened in read/write mode. Make sure the
1624	* image is opened in read-only mode if the caller requested that. */
1625	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
1626	{
1627	vciFreeImage(pCache, false);
1628	rc = vciOpenImage(pCache, uOpenFlags);
1629	if (RT_FAILURE(rc))
1630	{
1631	RTMemFree(pCache);
1632	goto out;
1633	}
1634	}
1635	*ppBackendData = pCache;
1636	}
1637	else
1638	RTMemFree(pCache);
1639
1640	out:
1641	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1642	return rc;
1643	}
1644
1645	/** @copydoc VDCACHEBACKEND::pfnClose */
1646	static DECLCALLBACK(int) vciClose(void *pBackendData, bool fDelete)
1647	{
1648	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1649	PVCICACHE pCache = (PVCICACHE)pBackendData;
1650	int rc;
1651
1652	rc = vciFreeImage(pCache, fDelete);
1653	RTMemFree(pCache);
1654
1655	LogFlowFunc(("returns %Rrc\n", rc));
1656	return rc;
1657	}
1658
1659	/** @copydoc VDCACHEBACKEND::pfnRead */
1660	static DECLCALLBACK(int) vciRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1661	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1662	{
1663	LogFlowFunc(("pBackendData=%#p uOffset=%llu cbToRead=%zu pIoCtx=%#p pcbActuallyRead=%#p\n",
1664	pBackendData, uOffset, cbToRead, pIoCtx, pcbActuallyRead));
1665	PVCICACHE pCache = (PVCICACHE)pBackendData;
1666	int rc = VINF_SUCCESS;
1667	PVCICACHEEXTENT pExtent;
1668	uint64_t cBlocksToRead = VCI_BYTE2BLOCK(cbToRead);
1669	uint64_t offBlockAddr = VCI_BYTE2BLOCK(uOffset);
1670
1671	AssertPtr(pCache);
1672	Assert(uOffset % 512 == 0);
1673	Assert(cbToRead % 512 == 0);
1674
1675	pExtent = vciCacheExtentLookup(pCache, offBlockAddr, NULL);
1676	if (pExtent)
1677	{
1678	uint64_t offRead = offBlockAddr - pExtent->u64BlockOffset;
1679	cBlocksToRead = RT_MIN(cBlocksToRead, pExtent->u32Blocks - offRead);
1680
1681	rc = vdIfIoIntFileReadUser(pCache->pIfIo, pCache->pStorage,
1682	pExtent->u64BlockAddr + offRead,
1683	pIoCtx, cBlocksToRead);
1684	}
1685	else
1686	{
1687	/** @todo Best fit to check whether we have cached data later and set
1688	* pcbActuallyRead accordingly. */
1689	rc = VERR_VD_BLOCK_FREE;
1690	}
1691
1692	if (pcbActuallyRead)
1693	*pcbActuallyRead = VCI_BLOCK2BYTE(cBlocksToRead);
1694
1695	LogFlowFunc(("returns %Rrc\n", rc));
1696	return rc;
1697	}
1698
1699	/** @copydoc VDCACHEBACKEND::pfnWrite */
1700	static DECLCALLBACK(int) vciWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
1701	PVDIOCTX pIoCtx, size_t *pcbWriteProcess)
1702	{
1703	RT_NOREF5(pBackendData, uOffset, cbToWrite, pIoCtx, pcbWriteProcess);
1704	LogFlowFunc(("pBackendData=%#p uOffset=%llu cbToWrite=%zu pIoCtx=%#p pcbWriteProcess=%#p\n",
1705	pBackendData, uOffset, cbToWrite, pIoCtx, pcbWriteProcess));
1706	PVCICACHE pCache = (PVCICACHE)pBackendData;
1707	int rc = VINF_SUCCESS;
1708	uint64_t cBlocksToWrite = VCI_BYTE2BLOCK(cbToWrite);
1709	//uint64_t offBlockAddr = VCI_BYTE2BLOCK(uOffset);
1710
1711	AssertPtr(pCache); NOREF(pCache);
1712	Assert(uOffset % 512 == 0);
1713	Assert(cbToWrite % 512 == 0);
1714	while (cBlocksToWrite)
1715	{
1716
1717	}
1718
1719	pcbWriteProcess = cbToWrite; /* @todo Implement. */
1720
1721	LogFlowFunc(("returns %Rrc\n", rc));
1722	return rc;
1723	}
1724
1725	/** @copydoc VDCACHEBACKEND::pfnFlush */
1726	static DECLCALLBACK(int) vciFlush(void *pBackendData, PVDIOCTX pIoCtx)
1727	{
1728	RT_NOREF1(pIoCtx);
1729	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1730	PVCICACHE pCache = (PVCICACHE)pBackendData;
1731
1732	int rc = vciFlushImage(pCache);
1733	LogFlowFunc(("returns %Rrc\n", rc));
1734	return rc;
1735	}
1736
1737	/** @copydoc VDCACHEBACKEND::pfnGetVersion */
1738	static DECLCALLBACK(unsigned) vciGetVersion(void *pBackendData)
1739	{
1740	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1741	PVCICACHE pCache = (PVCICACHE)pBackendData;
1742
1743	AssertPtr(pCache);
1744
1745	if (pCache)
1746	return 1;
1747	else
1748	return 0;
1749	}
1750
1751	/** @copydoc VDCACHEBACKEND::pfnGetSize */
1752	static DECLCALLBACK(uint64_t) vciGetSize(void *pBackendData)
1753	{
1754	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1755	PVCICACHE pCache = (PVCICACHE)pBackendData;
1756	uint64_t cb = 0;
1757
1758	AssertPtr(pCache);
1759
1760	if (pCache && pCache->pStorage)
1761	cb = pCache->cbSize;
1762
1763	LogFlowFunc(("returns %llu\n", cb));
1764	return cb;
1765	}
1766
1767	/** @copydoc VDCACHEBACKEND::pfnGetFileSize */
1768	static DECLCALLBACK(uint64_t) vciGetFileSize(void *pBackendData)
1769	{
1770	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1771	PVCICACHE pCache = (PVCICACHE)pBackendData;
1772	uint64_t cb = 0;
1773
1774	AssertPtr(pCache);
1775
1776	if (pCache)
1777	{
1778	uint64_t cbFile;
1779	if (pCache->pStorage)
1780	{
1781	int rc = vdIfIoIntFileGetSize(pCache->pIfIo, pCache->pStorage, &cbFile);
1782	if (RT_SUCCESS(rc))
1783	cb = cbFile;
1784	}
1785	}
1786
1787	LogFlowFunc(("returns %lld\n", cb));
1788	return cb;
1789	}
1790
1791	/** @copydoc VDCACHEBACKEND::pfnGetImageFlags */
1792	static DECLCALLBACK(unsigned) vciGetImageFlags(void *pBackendData)
1793	{
1794	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1795	PVCICACHE pCache = (PVCICACHE)pBackendData;
1796	unsigned uImageFlags;
1797
1798	AssertPtr(pCache);
1799
1800	if (pCache)
1801	uImageFlags = pCache->uImageFlags;
1802	else
1803	uImageFlags = 0;
1804
1805	LogFlowFunc(("returns %#x\n", uImageFlags));
1806	return uImageFlags;
1807	}
1808
1809	/** @copydoc VDCACHEBACKEND::pfnGetOpenFlags */
1810	static DECLCALLBACK(unsigned) vciGetOpenFlags(void *pBackendData)
1811	{
1812	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1813	PVCICACHE pCache = (PVCICACHE)pBackendData;
1814	unsigned uOpenFlags;
1815
1816	AssertPtr(pCache);
1817
1818	if (pCache)
1819	uOpenFlags = pCache->uOpenFlags;
1820	else
1821	uOpenFlags = 0;
1822
1823	LogFlowFunc(("returns %#x\n", uOpenFlags));
1824	return uOpenFlags;
1825	}
1826
1827	/** @copydoc VDCACHEBACKEND::pfnSetOpenFlags */
1828	static DECLCALLBACK(int) vciSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
1829	{
1830	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
1831	PVCICACHE pCache = (PVCICACHE)pBackendData;
1832	int rc;
1833
1834	/* Image must be opened and the new flags must be valid. Just readonly and
1835	* info flags are supported. */
1836	if (!pCache \|\| (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO)))
1837	{
1838	rc = VERR_INVALID_PARAMETER;
1839	goto out;
1840	}
1841
1842	/* Implement this operation via reopening the image. */
1843	rc = vciFreeImage(pCache, false);
1844	if (RT_FAILURE(rc))
1845	goto out;
1846	rc = vciOpenImage(pCache, uOpenFlags);
1847
1848	out:
1849	LogFlowFunc(("returns %Rrc\n", rc));
1850	return rc;
1851	}
1852
1853	/** @copydoc VDCACHEBACKEND::pfnGetComment */
1854	static DECLCALLBACK(int) vciGetComment(void pBackendData, char pszComment,
1855	size_t cbComment)
1856	{
1857	RT_NOREF2(pszComment, cbComment);
1858	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
1859	PVCICACHE pCache = (PVCICACHE)pBackendData;
1860	int rc;
1861
1862	AssertPtr(pCache);
1863
1864	if (pCache)
1865	rc = VERR_NOT_SUPPORTED;
1866	else
1867	rc = VERR_VD_NOT_OPENED;
1868
1869	LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
1870	return rc;
1871	}
1872
1873	/** @copydoc VDCACHEBACKEND::pfnSetComment */
1874	static DECLCALLBACK(int) vciSetComment(void pBackendData, const char pszComment)
1875	{
1876	RT_NOREF1(pszComment);
1877	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
1878	PVCICACHE pCache = (PVCICACHE)pBackendData;
1879	int rc;
1880
1881	AssertPtr(pCache);
1882
1883	if (pCache)
1884	{
1885	if (pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1886	rc = VERR_VD_IMAGE_READ_ONLY;
1887	else
1888	rc = VERR_NOT_SUPPORTED;
1889	}
1890	else
1891	rc = VERR_VD_NOT_OPENED;
1892
1893	LogFlowFunc(("returns %Rrc\n", rc));
1894	return rc;
1895	}
1896
1897	/** @copydoc VDCACHEBACKEND::pfnGetUuid */
1898	static DECLCALLBACK(int) vciGetUuid(void *pBackendData, PRTUUID pUuid)
1899	{
1900	RT_NOREF1(pUuid);
1901	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1902	PVCICACHE pCache = (PVCICACHE)pBackendData;
1903	int rc;
1904
1905	AssertPtr(pCache);
1906
1907	if (pCache)
1908	rc = VERR_NOT_SUPPORTED;
1909	else
1910	rc = VERR_VD_NOT_OPENED;
1911
1912	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1913	return rc;
1914	}
1915
1916	/** @copydoc VDCACHEBACKEND::pfnSetUuid */
1917	static DECLCALLBACK(int) vciSetUuid(void *pBackendData, PCRTUUID pUuid)
1918	{
1919	RT_NOREF1(pUuid);
1920	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1921	PVCICACHE pCache = (PVCICACHE)pBackendData;
1922	int rc;
1923
1924	LogFlowFunc(("%RTuuid\n", pUuid));
1925	AssertPtr(pCache);
1926
1927	if (pCache)
1928	{
1929	if (!(pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1930	rc = VERR_NOT_SUPPORTED;
1931	else
1932	rc = VERR_VD_IMAGE_READ_ONLY;
1933	}
1934	else
1935	rc = VERR_VD_NOT_OPENED;
1936
1937	LogFlowFunc(("returns %Rrc\n", rc));
1938	return rc;
1939	}
1940
1941	/** @copydoc VDCACHEBACKEND::pfnGetModificationUuid */
1942	static DECLCALLBACK(int) vciGetModificationUuid(void *pBackendData, PRTUUID pUuid)
1943	{
1944	RT_NOREF1(pUuid);
1945	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1946	PVCICACHE pCache = (PVCICACHE)pBackendData;
1947	int rc;
1948
1949	AssertPtr(pCache);
1950
1951	if (pCache)
1952	rc = VERR_NOT_SUPPORTED;
1953	else
1954	rc = VERR_VD_NOT_OPENED;
1955
1956	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1957	return rc;
1958	}
1959
1960	/** @copydoc VDCACHEBACKEND::pfnSetModificationUuid */
1961	static DECLCALLBACK(int) vciSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
1962	{
1963	RT_NOREF1(pUuid);
1964	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1965	PVCICACHE pCache = (PVCICACHE)pBackendData;
1966	int rc;
1967
1968	AssertPtr(pCache);
1969
1970	if (pCache)
1971	{
1972	if (!(pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1973	rc = VERR_NOT_SUPPORTED;
1974	else
1975	rc = VERR_VD_IMAGE_READ_ONLY;
1976	}
1977	else
1978	rc = VERR_VD_NOT_OPENED;
1979
1980	LogFlowFunc(("returns %Rrc\n", rc));
1981	return rc;
1982	}
1983
1984	/** @copydoc VDCACHEBACKEND::pfnDump */
1985	static DECLCALLBACK(void) vciDump(void *pBackendData)
1986	{
1987	NOREF(pBackendData);
1988	}
1989
1990
1991	const VDCACHEBACKEND g_VciCacheBackend =
1992	{
1993	/* u32Version */
1994	VD_CACHEBACKEND_VERSION,
1995	/* pszBackendName */
1996	"vci",
1997	/* uBackendCaps */
1998	VD_CAP_CREATE_FIXED \| VD_CAP_CREATE_DYNAMIC \| VD_CAP_FILE \| VD_CAP_VFS,
1999	/* papszFileExtensions */
2000	s_apszVciFileExtensions,
2001	/* paConfigInfo */
2002	NULL,
2003	/* pfnProbe */
2004	vciProbe,
2005	/* pfnOpen */
2006	vciOpen,
2007	/* pfnCreate */
2008	vciCreate,
2009	/* pfnClose */
2010	vciClose,
2011	/* pfnRead */
2012	vciRead,
2013	/* pfnWrite */
2014	vciWrite,
2015	/* pfnFlush */
2016	vciFlush,
2017	/* pfnDiscard */
2018	NULL,
2019	/* pfnGetVersion */
2020	vciGetVersion,
2021	/* pfnGetSize */
2022	vciGetSize,
2023	/* pfnGetFileSize */
2024	vciGetFileSize,
2025	/* pfnGetImageFlags */
2026	vciGetImageFlags,
2027	/* pfnGetOpenFlags */
2028	vciGetOpenFlags,
2029	/* pfnSetOpenFlags */
2030	vciSetOpenFlags,
2031	/* pfnGetComment */
2032	vciGetComment,
2033	/* pfnSetComment */
2034	vciSetComment,
2035	/* pfnGetUuid */
2036	vciGetUuid,
2037	/* pfnSetUuid */
2038	vciSetUuid,
2039	/* pfnGetModificationUuid */
2040	vciGetModificationUuid,
2041	/* pfnSetModificationUuid */
2042	vciSetModificationUuid,
2043	/* pfnDump */
2044	vciDump,
2045	/* pfnComposeLocation */
2046	NULL,
2047	/* pfnComposeName */
2048	NULL,
2049	/* u32VersionEnd */
2050	VD_CACHEBACKEND_VERSION
2051	};
2052

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

source: vbox/trunk/src/VBox/Storage/VCICache.cpp@ 99749

Download in other formats: