tstVD.cpp@ 105352

Last change on this file since 105352 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.3 KB

Line
1	/* $Id: tstVD.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* Simple VBox HDD container test utility.
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	#include <VBox/vd.h>
33	#include <iprt/errcore.h>
34	#include <VBox/log.h>
35	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
36	# include <iprt/asm-amd64-x86.h>
37	#endif
38	#include <iprt/dir.h>
39	#include <iprt/string.h>
40	#include <iprt/stream.h>
41	#include <iprt/file.h>
42	#include <iprt/mem.h>
43	#include <iprt/initterm.h>
44	#include <iprt/rand.h>
45	#include "stdio.h"
46	#include "stdlib.h"
47
48	#define VHD_TEST
49	#define VDI_TEST
50	#define VMDK_TEST
51
52
53	/*********************************************************************************************************************************
54	* Global Variables *
55	*********************************************************************************************************************************/
56	/** The error count. */
57	unsigned g_cErrors = 0;
58
59
60	static DECLCALLBACK(void) tstVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
61	{
62	RT_NOREF1(pvUser);
63	g_cErrors++;
64	RTPrintf("tstVD: Error %Rrc at %s:%u (%s): ", rc, RT_SRC_POS_ARGS);
65	RTPrintfV(pszFormat, va);
66	RTPrintf("\n");
67	}
68
69	static DECLCALLBACK(int) tstVDMessage(void pvUser, const char pszFormat, va_list va)
70	{
71	RT_NOREF1(pvUser);
72	RTPrintf("tstVD: ");
73	RTPrintfV(pszFormat, va);
74	return VINF_SUCCESS;
75	}
76
77	static int tstVDCreateDelete(const char pszBackend, const char pszFilename,
78	uint64_t cbSize, unsigned uFlags, bool fDelete)
79	{
80	int rc;
81	PVDISK pVD = NULL;
82	VDGEOMETRY PCHS = { 0, 0, 0 };
83	VDGEOMETRY LCHS = { 0, 0, 0 };
84	PVDINTERFACE pVDIfs = NULL;
85	VDINTERFACEERROR VDIfError;
86
87	#define CHECK(str) \
88	do \
89	{ \
90	RTPrintf("%s rc=%Rrc\n", str, rc); \
91	if (RT_FAILURE(rc)) \
92	{ \
93	VDDestroy(pVD); \
94	return rc; \
95	} \
96	} while (0)
97
98	/* Create error interface. */
99	VDIfError.pfnError = tstVDError;
100	VDIfError.pfnMessage = tstVDMessage;
101
102	rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
103	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
104	AssertRC(rc);
105
106	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
107	CHECK("VDCreate()");
108
109	rc = VDCreateBase(pVD, pszBackend, pszFilename, cbSize,
110	uFlags, "Test image", &PCHS, &LCHS, NULL,
111	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
112	CHECK("VDCreateBase()");
113
114	VDDumpImages(pVD);
115
116	VDClose(pVD, fDelete);
117	if (fDelete)
118	{
119	RTFILE File;
120	rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
121	if (RT_SUCCESS(rc))
122	{
123	RTFileClose(File);
124	return VERR_INTERNAL_ERROR;
125	}
126	}
127
128	VDDestroy(pVD);
129	#undef CHECK
130	return 0;
131	}
132
133	static int tstVDOpenDelete(const char pszBackend, const char pszFilename)
134	{
135	int rc;
136	PVDISK pVD = NULL;
137	PVDINTERFACE pVDIfs = NULL;
138	VDINTERFACEERROR VDIfError;
139
140	#define CHECK(str) \
141	do \
142	{ \
143	RTPrintf("%s rc=%Rrc\n", str, rc); \
144	if (RT_FAILURE(rc)) \
145	{ \
146	VDDestroy(pVD); \
147	return rc; \
148	} \
149	} while (0)
150
151	/* Create error interface. */
152	VDIfError.pfnError = tstVDError;
153	VDIfError.pfnMessage = tstVDMessage;
154
155	rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
156	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
157	AssertRC(rc);
158
159
160	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
161	CHECK("VDCreate()");
162
163	rc = VDOpen(pVD, pszBackend, pszFilename, VD_OPEN_FLAGS_NORMAL, NULL);
164	CHECK("VDOpen()");
165
166	VDDumpImages(pVD);
167
168	VDClose(pVD, true);
169	RTFILE File;
170	rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
171	if (RT_SUCCESS(rc))
172	{
173	RTFileClose(File);
174	return VERR_INTERNAL_ERROR;
175	}
176
177	VDDestroy(pVD);
178	#undef CHECK
179	return 0;
180	}
181
182
183	#undef RTDECL
184	#define RTDECL(x) static x
185
186	/* Start of IPRT code */
187
188	/**
189	* The following code is based on the work of George Marsaglia
190	* taken from
191	* http://groups.google.ws/group/comp.sys.sun.admin/msg/7c667186f6cbf354
192	* and
193	* http://groups.google.ws/group/comp.lang.c/msg/0e170777c6e79e8d
194	*/
195
196	/*
197	A C version of a very very good 64-bit RNG is given below.
198	You should be able to adapt it to your particular needs.
199
200	It is based on the complimentary-multiple-with-carry
201	sequence
202	x(n)=a*x(n-4)+carry mod 2^64-1,
203	which works as follows:
204	Assume a certain multiplier 'a' and a base 'b'.
205	Given a current x value and a current carry 'c',
206	form: t=a*x+c
207	Then the new carry is c=floor(t/b)
208	and the new x value is x = b-1-(t mod b).
209
210
211	Ordinarily, for 32-bit mwc or cmwc sequences, the
212	value t=a*x+c can be formed in 64 bits, then the new c
213	is the top and the new x the bottom 32 bits (with a little
214	fiddling when b=2^32-1 and cmwc rather than mwc.)
215
216
217	To generate 64-bit x's, it is difficult to form
218	t=a*x+c in 128 bits then get the new c and new x
219	from the top and bottom halves.
220	But if 'a' has a special form, for example,
221	a=2^62+2^47+2 and b=2^64-1, then the new c and
222	the new x can be formed with shifts, tests and +/-'s,
223	again with a little fiddling because b=2^64-1 rather
224	than 2^64. (The latter is not an optimal choice because,
225	being a square, it cannot be a primitive root of the
226	prime a*b^k+1, where 'k' is the 'lag':
227	x(n)=a*x(n-k)+carry mod b.)
228	But the multiplier a=2^62+2^47+2 makes a*b^4+1 a prime for
229	which b=2^64-1 is a primitive root, and getting the new x and
230	new c can be done with arithmetic on integers the size of x.
231	*/
232
233	struct RndCtx
234	{
235	uint64_t x;
236	uint64_t y;
237	uint64_t z;
238	uint64_t w;
239	uint64_t c;
240	uint32_t u32x;
241	uint32_t u32y;
242	};
243	typedef struct RndCtx RNDCTX;
244	typedef RNDCTX *PRNDCTX;
245
246	/**
247	* Initialize seeds.
248	*
249	* @remarks You should choose ANY 4 random 64-bit
250	* seeds x,y,z,w < 2^64-1 and a random seed c in
251	* 0<= c < a = 2^62+2^47+2.
252	* There are P=(2^62+2^46+2)*(2^64-1)^4 > 2^318 possible choices
253	* for seeds, the period of the RNG.
254	*/
255	RTDECL(int) RTPRandInit(PRNDCTX pCtx, uint32_t u32Seed)
256	{
257	if (u32Seed == 0)
258	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
259	u32Seed = (uint32_t)(ASMReadTSC() >> 8);
260	#else
261	u32Seed = (uint32_t)(RTTimeNanoTS() >> 19);
262	#endif
263	/* Zero is not a good seed. */
264	if (u32Seed == 0)
265	u32Seed = 362436069;
266	pCtx->x = u32Seed;
267	pCtx->y = 17280675555674358941ULL;
268	pCtx->z = 6376492577913983186ULL;
269	pCtx->w = 9064188857900113776ULL;
270	pCtx->c = 123456789;
271	pCtx->u32x = 2282008;
272	pCtx->u32y = u32Seed;
273	return VINF_SUCCESS;
274	}
275
276	RTDECL(uint32_t) RTPRandGetSeedInfo(PRNDCTX pCtx)
277	{
278	return pCtx->u32y;
279	}
280
281	/**
282	* Generate a 64-bit unsigned random number.
283	*
284	* @returns The pseudo random number.
285	*/
286	RTDECL(uint64_t) RTPRandU64(PRNDCTX pCtx)
287	{
288	uint64_t t;
289	t = (pCtx->x<<47) + (pCtx->x<<62) + (pCtx->x<<1);
290	t += pCtx->c; t+= (t < pCtx->c);
291	pCtx->c = (t<pCtx->c) + (pCtx->x>>17) + (pCtx->x>>2) + (pCtx->x>>63);
292	pCtx->x = pCtx->y; pCtx->y = pCtx->z ; pCtx->z = pCtx->w;
293	return (pCtx->w = ~(t + pCtx->c)-1);
294	}
295
296	/**
297	* Generate a 64-bit unsigned pseudo random number in the set
298	* [u64First..u64Last].
299	*
300	* @returns The pseudo random number.
301	* @param u64First First number in the set.
302	* @param u64Last Last number in the set.
303	*/
304	RTDECL(uint64_t) RTPRandU64Ex(PRNDCTX pCtx, uint64_t u64First, uint64_t u64Last)
305	{
306	if (u64First == 0 && u64Last == UINT64_MAX)
307	return RTPRandU64(pCtx);
308
309	uint64_t u64Tmp;
310	uint64_t u64Range = u64Last - u64First + 1;
311	uint64_t u64Scale = UINT64_MAX / u64Range;
312
313	do
314	{
315	u64Tmp = RTPRandU64(pCtx) / u64Scale;
316	} while (u64Tmp >= u64Range);
317	return u64First + u64Tmp;
318	}
319
320	/**
321	* Generate a 32-bit unsigned random number.
322	*
323	* @returns The pseudo random number.
324	*/
325	RTDECL(uint32_t) RTPRandU32(PRNDCTX pCtx)
326	{
327	return ( pCtx->u32x = 69069 * pCtx->u32x + 123,
328	pCtx->u32y ^= pCtx->u32y<<13,
329	pCtx->u32y ^= pCtx->u32y>>17,
330	pCtx->u32y ^= pCtx->u32y<<5,
331	pCtx->u32x + pCtx->u32y );
332	}
333
334	/**
335	* Generate a 32-bit unsigned pseudo random number in the set
336	* [u32First..u32Last].
337	*
338	* @returns The pseudo random number.
339	* @param u32First First number in the set.
340	* @param u32Last Last number in the set.
341	*/
342	RTDECL(uint32_t) RTPRandU32Ex(PRNDCTX pCtx, uint32_t u32First, uint32_t u32Last)
343	{
344	if (u32First == 0 && u32Last == UINT32_MAX)
345	return RTPRandU32(pCtx);
346
347	uint32_t u32Tmp;
348	uint32_t u32Range = u32Last - u32First + 1;
349	uint32_t u32Scale = UINT32_MAX / u32Range;
350
351	do
352	{
353	u32Tmp = RTPRandU32(pCtx) / u32Scale;
354	} while (u32Tmp >= u32Range);
355	return u32First + u32Tmp;
356	}
357
358	/* End of IPRT code */
359
360	struct Segment
361	{
362	uint64_t u64Offset;
363	uint32_t u32Length;
364	uint32_t u8Value;
365	};
366	typedef struct Segment *PSEGMENT;
367
368	static void initializeRandomGenerator(PRNDCTX pCtx, uint32_t u32Seed)
369	{
370	int rc = RTPRandInit(pCtx, u32Seed);
371	if (RT_FAILURE(rc))
372	RTPrintf("ERROR: Failed to initialize random generator. RC=%Rrc\n", rc);
373	else
374	{
375	RTPrintf("INFO: Random generator seed used: %x\n", RTPRandGetSeedInfo(pCtx));
376	RTLogPrintf("INFO: Random generator seed used: %x\n", RTPRandGetSeedInfo(pCtx));
377	}
378	}
379
380	static int compareSegments(const void left, const void right) RT_NOTHROW_DEF
381	{
382	/* Note that no duplicates are allowed in the array being sorted. */
383	return ((PSEGMENT)left)->u64Offset < ((PSEGMENT)right)->u64Offset ? -1 : 1;
384	}
385
386	static void generateRandomSegments(PRNDCTX pCtx, PSEGMENT pSegment, uint32_t nSegments, uint32_t u32MaxSegmentSize, uint64_t u64DiskSize, uint32_t u32SectorSize, uint8_t u8ValueLow, uint8_t u8ValueHigh)
387	{
388	uint32_t i;
389	/* Generate segment offsets. */
390	for (i = 0; i < nSegments; i++)
391	{
392	bool fDuplicateFound;
393	do
394	{
395	pSegment[i].u64Offset = RTPRandU64Ex(pCtx, 0, u64DiskSize / u32SectorSize - 1) * u32SectorSize;
396	fDuplicateFound = false;
397	for (uint32_t j = 0; j < i; j++)
398	if (pSegment[i].u64Offset == pSegment[j].u64Offset)
399	{
400	fDuplicateFound = true;
401	break;
402	}
403	} while (fDuplicateFound);
404	}
405	/* Sort in offset-ascending order. */
406	qsort(pSegment, nSegments, sizeof(*pSegment), compareSegments);
407	/* Put a sentinel at the end. */
408	pSegment[nSegments].u64Offset = u64DiskSize;
409	pSegment[nSegments].u32Length = 0;
410	/* Generate segment lengths and values. */
411	for (i = 0; i < nSegments; i++)
412	{
413	pSegment[i].u32Length = RTPRandU32Ex(pCtx, 1, RT_MIN(pSegment[i+1].u64Offset - pSegment[i].u64Offset,
414	u32MaxSegmentSize) / u32SectorSize) * u32SectorSize;
415	Assert(pSegment[i].u32Length <= u32MaxSegmentSize);
416	pSegment[i].u8Value = RTPRandU32Ex(pCtx, (uint32_t)u8ValueLow, (uint32_t)u8ValueHigh);
417	}
418	}
419
420	static void mergeSegments(PSEGMENT pBaseSegment, PSEGMENT pDiffSegment, PSEGMENT pMergeSegment, uint32_t u32MaxLength)
421	{
422	RT_NOREF1(u32MaxLength);
423
424	while (pBaseSegment->u32Length > 0 \|\| pDiffSegment->u32Length > 0)
425	{
426	if (pBaseSegment->u64Offset < pDiffSegment->u64Offset)
427	{
428	pMergeSegment = pBaseSegment;
429	if (pMergeSegment->u64Offset + pMergeSegment->u32Length <= pDiffSegment->u64Offset)
430	pBaseSegment++;
431	else
432	{
433	pMergeSegment->u32Length = pDiffSegment->u64Offset - pMergeSegment->u64Offset;
434	Assert(pMergeSegment->u32Length <= u32MaxLength);
435	if (pBaseSegment->u64Offset + pBaseSegment->u32Length >
436	pDiffSegment->u64Offset + pDiffSegment->u32Length)
437	{
438	pBaseSegment->u32Length -= pDiffSegment->u64Offset + pDiffSegment->u32Length - pBaseSegment->u64Offset;
439	Assert(pBaseSegment->u32Length <= u32MaxLength);
440	pBaseSegment->u64Offset = pDiffSegment->u64Offset + pDiffSegment->u32Length;
441	}
442	else
443	pBaseSegment++;
444	}
445	pMergeSegment++;
446	}
447	else
448	{
449	pMergeSegment = pDiffSegment;
450	if (pMergeSegment->u64Offset + pMergeSegment->u32Length <= pBaseSegment->u64Offset)
451	{
452	pDiffSegment++;
453	pMergeSegment++;
454	}
455	else
456	{
457	if (pBaseSegment->u64Offset + pBaseSegment->u32Length > pDiffSegment->u64Offset + pDiffSegment->u32Length)
458	{
459	pBaseSegment->u32Length -= pDiffSegment->u64Offset + pDiffSegment->u32Length - pBaseSegment->u64Offset;
460	Assert(pBaseSegment->u32Length <= u32MaxLength);
461	pBaseSegment->u64Offset = pDiffSegment->u64Offset + pDiffSegment->u32Length;
462	pDiffSegment++;
463	pMergeSegment++;
464	}
465	else
466	pBaseSegment++;
467	}
468	}
469	}
470	}
471
472	static void writeSegmentsToDisk(PVDISK pVD, void *pvBuf, PSEGMENT pSegment)
473	{
474	while (pSegment->u32Length)
475	{
476	//memset((uint8_t*)pvBuf + pSegment->u64Offset, pSegment->u8Value, pSegment->u32Length);
477	memset(pvBuf, pSegment->u8Value, pSegment->u32Length);
478	VDWrite(pVD, pSegment->u64Offset, pvBuf, pSegment->u32Length);
479	pSegment++;
480	}
481	}
482
483	static int readAndCompareSegments(PVDISK pVD, void *pvBuf, PSEGMENT pSegment)
484	{
485	while (pSegment->u32Length)
486	{
487	int rc = VDRead(pVD, pSegment->u64Offset, pvBuf, pSegment->u32Length);
488	if (RT_FAILURE(rc))
489	{
490	RTPrintf("ERROR: Failed to read from virtual disk\n");
491	return rc;
492	}
493	else
494	{
495	for (unsigned i = 0; i < pSegment->u32Length; i++)
496	if (((uint8_t*)pvBuf)[i] != pSegment->u8Value)
497	{
498	RTPrintf("ERROR: Segment at %Lx of %x bytes is corrupt at offset %x (found %x instead of %x)\n",
499	pSegment->u64Offset, pSegment->u32Length, i, ((uint8_t*)pvBuf)[i],
500	pSegment->u8Value);
501	RTLogPrintf("ERROR: Segment at %Lx of %x bytes is corrupt at offset %x (found %x instead of %x)\n",
502	pSegment->u64Offset, pSegment->u32Length, i, ((uint8_t*)pvBuf)[i],
503	pSegment->u8Value);
504	return VERR_INTERNAL_ERROR;
505	}
506	}
507	pSegment++;
508	}
509
510	return VINF_SUCCESS;
511	}
512
513	static int tstVDOpenCreateWriteMerge(const char *pszBackend,
514	const char *pszBaseFilename,
515	const char *pszDiffFilename,
516	uint32_t u32Seed)
517	{
518	int rc;
519	PVDISK pVD = NULL;
520	char *pszFormat;
521	VDTYPE enmType = VDTYPE_INVALID;
522	VDGEOMETRY PCHS = { 0, 0, 0 };
523	VDGEOMETRY LCHS = { 0, 0, 0 };
524	uint64_t u64DiskSize = 1000 * _1M;
525	uint32_t u32SectorSize = 512;
526	PVDINTERFACE pVDIfs = NULL;
527	VDINTERFACEERROR VDIfError;
528
529	#define CHECK(str) \
530	do \
531	{ \
532	RTPrintf("%s rc=%Rrc\n", str, rc); \
533	if (RT_FAILURE(rc)) \
534	{ \
535	if (pvBuf) \
536	RTMemFree(pvBuf); \
537	VDDestroy(pVD); \
538	return rc; \
539	} \
540	} while (0)
541
542	void *pvBuf = RTMemAlloc(_1M);
543
544	/* Create error interface. */
545	VDIfError.pfnError = tstVDError;
546	VDIfError.pfnMessage = tstVDMessage;
547
548	rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
549	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
550	AssertRC(rc);
551
552
553	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
554	CHECK("VDCreate()");
555
556	RTFILE File;
557	rc = RTFileOpen(&File, pszBaseFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
558	if (RT_SUCCESS(rc))
559	{
560	RTFileClose(File);
561	rc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
562	pszBaseFilename, VDTYPE_INVALID, &pszFormat, &enmType);
563	RTPrintf("VDGetFormat() pszFormat=%s rc=%Rrc\n", pszFormat, rc);
564	if (RT_SUCCESS(rc) && strcmp(pszFormat, pszBackend))
565	{
566	rc = VERR_GENERAL_FAILURE;
567	RTPrintf("VDGetFormat() returned incorrect backend name\n");
568	}
569	RTStrFree(pszFormat);
570	CHECK("VDGetFormat()");
571
572	rc = VDOpen(pVD, pszBackend, pszBaseFilename, VD_OPEN_FLAGS_NORMAL,
573	NULL);
574	CHECK("VDOpen()");
575	}
576	else
577	{
578	rc = VDCreateBase(pVD, pszBackend, pszBaseFilename, u64DiskSize,
579	VD_IMAGE_FLAGS_NONE, "Test image",
580	&PCHS, &LCHS, NULL, VD_OPEN_FLAGS_NORMAL,
581	NULL, NULL);
582	CHECK("VDCreateBase()");
583	}
584
585	int nSegments = 100;
586	/* Allocate one extra element for a sentinel. */
587	PSEGMENT paBaseSegments = (PSEGMENT)RTMemAllocZ(sizeof(struct Segment) * (nSegments + 1));
588	PSEGMENT paDiffSegments = (PSEGMENT)RTMemAllocZ(sizeof(struct Segment) * (nSegments + 1));
589	PSEGMENT paMergeSegments = (PSEGMENT)RTMemAllocZ(sizeof(struct Segment) * (nSegments + 1) * 3);
590
591	RNDCTX ctx;
592	initializeRandomGenerator(&ctx, u32Seed);
593	generateRandomSegments(&ctx, paBaseSegments, nSegments, _1M, u64DiskSize, u32SectorSize, 0u, 127u);
594	generateRandomSegments(&ctx, paDiffSegments, nSegments, _1M, u64DiskSize, u32SectorSize, 128u, 255u);
595
596	/*PSEGMENT pSegment;
597	RTPrintf("Base segments:\n");
598	for (pSegment = paBaseSegments; pSegment->u32Length; pSegment++)
599	RTPrintf("off: %08Lx len: %05x val: %02x\n", pSegment->u64Offset, pSegment->u32Length, pSegment->u8Value);*/
600	writeSegmentsToDisk(pVD, pvBuf, paBaseSegments);
601
602	rc = VDCreateDiff(pVD, pszBackend, pszDiffFilename,
603	VD_IMAGE_FLAGS_NONE, "Test diff image", NULL, NULL,
604	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
605	CHECK("VDCreateDiff()");
606
607	/*RTPrintf("\nDiff segments:\n");
608	for (pSegment = paDiffSegments; pSegment->u32Length; pSegment++)
609	RTPrintf("off: %08Lx len: %05x val: %02x\n", pSegment->u64Offset, pSegment->u32Length, pSegment->u8Value);*/
610	writeSegmentsToDisk(pVD, pvBuf, paDiffSegments);
611
612	VDDumpImages(pVD);
613
614	RTPrintf("Merging diff into base..\n");
615	rc = VDMerge(pVD, VD_LAST_IMAGE, 0, NULL);
616	CHECK("VDMerge()");
617
618	mergeSegments(paBaseSegments, paDiffSegments, paMergeSegments, _1M);
619	/*RTPrintf("\nMerged segments:\n");
620	for (pSegment = paMergeSegments; pSegment->u32Length; pSegment++)
621	RTPrintf("off: %08Lx len: %05x val: %02x\n", pSegment->u64Offset, pSegment->u32Length, pSegment->u8Value);*/
622	rc = readAndCompareSegments(pVD, pvBuf, paMergeSegments);
623	CHECK("readAndCompareSegments()");
624
625	RTMemFree(paMergeSegments);
626	RTMemFree(paDiffSegments);
627	RTMemFree(paBaseSegments);
628
629	VDDumpImages(pVD);
630
631	VDDestroy(pVD);
632	if (pvBuf)
633	RTMemFree(pvBuf);
634	#undef CHECK
635	return 0;
636	}
637
638	static int tstVDCreateWriteOpenRead(const char *pszBackend,
639	const char *pszFilename,
640	uint32_t u32Seed)
641	{
642	int rc;
643	PVDISK pVD = NULL;
644	VDGEOMETRY PCHS = { 0, 0, 0 };
645	VDGEOMETRY LCHS = { 0, 0, 0 };
646	uint64_t u64DiskSize = 1000 * _1M;
647	uint32_t u32SectorSize = 512;
648	PVDINTERFACE pVDIfs = NULL;
649	VDINTERFACEERROR VDIfError;
650
651	#define CHECK(str) \
652	do \
653	{ \
654	RTPrintf("%s rc=%Rrc\n", str, rc); \
655	if (RT_FAILURE(rc)) \
656	{ \
657	if (pvBuf) \
658	RTMemFree(pvBuf); \
659	VDDestroy(pVD); \
660	return rc; \
661	} \
662	} while (0)
663
664	void *pvBuf = RTMemAlloc(_1M);
665
666	/* Create error interface. */
667	VDIfError.pfnError = tstVDError;
668	VDIfError.pfnMessage = tstVDMessage;
669
670	rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
671	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
672	AssertRC(rc);
673
674	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
675	CHECK("VDCreate()");
676
677	RTFILE File;
678	rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
679	if (RT_SUCCESS(rc))
680	{
681	RTFileClose(File);
682	RTFileDelete(pszFilename);
683	}
684
685	rc = VDCreateBase(pVD, pszBackend, pszFilename, u64DiskSize,
686	VD_IMAGE_FLAGS_NONE, "Test image",
687	&PCHS, &LCHS, NULL, VD_OPEN_FLAGS_NORMAL,
688	NULL, NULL);
689	CHECK("VDCreateBase()");
690
691	int nSegments = 100;
692	/* Allocate one extra element for a sentinel. */
693	PSEGMENT paSegments = (PSEGMENT)RTMemAllocZ(sizeof(struct Segment) * (nSegments + 1));
694
695	RNDCTX ctx;
696	initializeRandomGenerator(&ctx, u32Seed);
697	generateRandomSegments(&ctx, paSegments, nSegments, _1M, u64DiskSize, u32SectorSize, 0u, 127u);
698	/*for (PSEGMENT pSegment = paSegments; pSegment->u32Length; pSegment++)
699	RTPrintf("off: %08Lx len: %05x val: %02x\n", pSegment->u64Offset, pSegment->u32Length, pSegment->u8Value);*/
700
701	writeSegmentsToDisk(pVD, pvBuf, paSegments);
702
703	VDCloseAll(pVD);
704
705	rc = VDOpen(pVD, pszBackend, pszFilename, VD_OPEN_FLAGS_NORMAL, NULL);
706	CHECK("VDOpen()");
707	rc = readAndCompareSegments(pVD, pvBuf, paSegments);
708	CHECK("readAndCompareSegments()");
709
710	RTMemFree(paSegments);
711
712	VDDestroy(pVD);
713	if (pvBuf)
714	RTMemFree(pvBuf);
715	#undef CHECK
716	return 0;
717	}
718
719	static int tstVmdkRename(const char src, const char dst)
720	{
721	int rc;
722	PVDISK pVD = NULL;
723	PVDINTERFACE pVDIfs = NULL;
724	VDINTERFACEERROR VDIfError;
725
726	#define CHECK(str) \
727	do \
728	{ \
729	RTPrintf("%s rc=%Rrc\n", str, rc); \
730	if (RT_FAILURE(rc)) \
731	{ \
732	VDDestroy(pVD); \
733	return rc; \
734	} \
735	} while (0)
736
737	/* Create error interface. */
738	VDIfError.pfnError = tstVDError;
739	VDIfError.pfnMessage = tstVDMessage;
740
741	rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
742	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
743	AssertRC(rc);
744
745	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
746	CHECK("VDCreate()");
747
748	rc = VDOpen(pVD, "VMDK", src, VD_OPEN_FLAGS_NORMAL, NULL);
749	CHECK("VDOpen()");
750	rc = VDCopy(pVD, 0, pVD, "VMDK", dst, true, 0, VD_IMAGE_FLAGS_NONE, NULL,
751	VD_OPEN_FLAGS_NORMAL, NULL, NULL, NULL);
752	CHECK("VDCopy()");
753
754	VDDestroy(pVD);
755	#undef CHECK
756	return 0;
757	}
758
759	static int tstVmdkCreateRenameOpen(const char src, const char dst,
760	uint64_t cbSize, unsigned uFlags)
761	{
762	int rc = tstVDCreateDelete("VMDK", src, cbSize, uFlags, false);
763	if (RT_FAILURE(rc))
764	return rc;
765
766	rc = tstVmdkRename(src, dst);
767	if (RT_FAILURE(rc))
768	return rc;
769
770	PVDISK pVD = NULL;
771	PVDINTERFACE pVDIfs = NULL;
772	VDINTERFACEERROR VDIfError;
773
774	#define CHECK(str) \
775	do \
776	{ \
777	RTPrintf("%s rc=%Rrc\n", str, rc); \
778	if (RT_FAILURE(rc)) \
779	{ \
780	VDCloseAll(pVD); \
781	return rc; \
782	} \
783	} while (0)
784
785	/* Create error interface. */
786	VDIfError.pfnError = tstVDError;
787	VDIfError.pfnMessage = tstVDMessage;
788
789	rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
790	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
791	AssertRC(rc);
792
793	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
794	CHECK("VDCreate()");
795
796	rc = VDOpen(pVD, "VMDK", dst, VD_OPEN_FLAGS_NORMAL, NULL);
797	CHECK("VDOpen()");
798
799	VDClose(pVD, true);
800	CHECK("VDClose()");
801	VDDestroy(pVD);
802	#undef CHECK
803	return rc;
804	}
805
806	#if defined(RT_OS_OS2) \|\| defined(RT_OS_WINDOWS)
807	#define DST_PATH "tmp\\tmpVDRename.vmdk"
808	#else
809	#define DST_PATH "tmp/tmpVDRename.vmdk"
810	#endif
811
812	static void tstVmdk()
813	{
814	int rc = tstVmdkCreateRenameOpen("tmpVDCreate.vmdk", "tmpVDRename.vmdk", _4G,
815	VD_IMAGE_FLAGS_NONE);
816	if (RT_FAILURE(rc))
817	{
818	RTPrintf("tstVD: VMDK rename (single extent, embedded descriptor, same dir) test failed! rc=%Rrc\n", rc);
819	g_cErrors++;
820	}
821	rc = tstVmdkCreateRenameOpen("tmpVDCreate.vmdk", "tmpVDRename.vmdk", _4G,
822	VD_VMDK_IMAGE_FLAGS_SPLIT_2G);
823	if (RT_FAILURE(rc))
824	{
825	RTPrintf("tstVD: VMDK rename (multiple extent, separate descriptor, same dir) test failed! rc=%Rrc\n", rc);
826	g_cErrors++;
827	}
828	rc = tstVmdkCreateRenameOpen("tmpVDCreate.vmdk", DST_PATH, _4G,
829	VD_IMAGE_FLAGS_NONE);
830	if (RT_FAILURE(rc))
831	{
832	RTPrintf("tstVD: VMDK rename (single extent, embedded descriptor, another dir) test failed! rc=%Rrc\n", rc);
833	g_cErrors++;
834	}
835	rc = tstVmdkCreateRenameOpen("tmpVDCreate.vmdk", DST_PATH, _4G,
836	VD_VMDK_IMAGE_FLAGS_SPLIT_2G);
837	if (RT_FAILURE(rc))
838	{
839	RTPrintf("tstVD: VMDK rename (multiple extent, separate descriptor, another dir) test failed! rc=%Rrc\n", rc);
840	g_cErrors++;
841	}
842
843	RTFILE File;
844	rc = RTFileOpen(&File, DST_PATH, RTFILE_O_WRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_NONE);
845	if (RT_SUCCESS(rc))
846	RTFileClose(File);
847
848	rc = tstVmdkCreateRenameOpen("tmpVDCreate.vmdk", DST_PATH, _4G,
849	VD_VMDK_IMAGE_FLAGS_SPLIT_2G);
850	if (RT_SUCCESS(rc))
851	{
852	RTPrintf("tstVD: VMDK rename (multiple extent, separate descriptor, another dir, already exists) test failed!\n");
853	g_cErrors++;
854	}
855	RTFileDelete(DST_PATH);
856	RTFileDelete("tmpVDCreate.vmdk");
857	RTFileDelete("tmpVDCreate-s001.vmdk");
858	RTFileDelete("tmpVDCreate-s002.vmdk");
859	RTFileDelete("tmpVDCreate-s003.vmdk");
860	}
861
862	int main(int argc, char *argv[])
863	{
864	RTR3InitExe(argc, &argv, 0);
865	int rc;
866
867	uint32_t u32Seed = 0; // Means choose random
868
869	if (argc > 1)
870	if (sscanf(argv[1], "%x", &u32Seed) != 1)
871	{
872	RTPrintf("ERROR: Invalid parameter %s. Valid usage is %s <32-bit seed>.\n",
873	argv[1], argv[0]);
874	return 1;
875	}
876
877	RTPrintf("tstVD: TESTING...\n");
878
879	/*
880	* Clean up potential leftovers from previous unsuccessful runs.
881	*/
882	RTFileDelete("tmpVDCreate.vdi");
883	RTFileDelete("tmpVDCreate.vmdk");
884	RTFileDelete("tmpVDCreate.vhd");
885	RTFileDelete("tmpVDBase.vdi");
886	RTFileDelete("tmpVDDiff.vdi");
887	RTFileDelete("tmpVDBase.vmdk");
888	RTFileDelete("tmpVDDiff.vmdk");
889	RTFileDelete("tmpVDBase.vhd");
890	RTFileDelete("tmpVDDiff.vhd");
891	RTFileDelete("tmpVDCreate-s001.vmdk");
892	RTFileDelete("tmpVDCreate-s002.vmdk");
893	RTFileDelete("tmpVDCreate-s003.vmdk");
894	RTFileDelete("tmpVDRename.vmdk");
895	RTFileDelete("tmpVDRename-s001.vmdk");
896	RTFileDelete("tmpVDRename-s002.vmdk");
897	RTFileDelete("tmpVDRename-s003.vmdk");
898	RTFileDelete("tmp/tmpVDRename.vmdk");
899	RTFileDelete("tmp/tmpVDRename-s001.vmdk");
900	RTFileDelete("tmp/tmpVDRename-s002.vmdk");
901	RTFileDelete("tmp/tmpVDRename-s003.vmdk");
902
903	if (!RTDirExists("tmp"))
904	{
905	rc = RTDirCreate("tmp", RTFS_UNIX_IRWXU, 0);
906	if (RT_FAILURE(rc))
907	{
908	RTPrintf("tstVD: Failed to create 'tmp' directory! rc=%Rrc\n", rc);
909	g_cErrors++;
910	}
911	}
912
913	#ifdef VMDK_TEST
914	rc = tstVDCreateDelete("VMDK", "tmpVDCreate.vmdk", 2 * _4G,
915	VD_IMAGE_FLAGS_NONE, true);
916	if (RT_FAILURE(rc))
917	{
918	RTPrintf("tstVD: dynamic VMDK create test failed! rc=%Rrc\n", rc);
919	g_cErrors++;
920	}
921	rc = tstVDCreateDelete("VMDK", "tmpVDCreate.vmdk", 2 * _4G,
922	VD_IMAGE_FLAGS_NONE, false);
923	if (RT_FAILURE(rc))
924	{
925	RTPrintf("tstVD: dynamic VMDK create test failed! rc=%Rrc\n", rc);
926	g_cErrors++;
927	}
928	rc = tstVDOpenDelete("VMDK", "tmpVDCreate.vmdk");
929	if (RT_FAILURE(rc))
930	{
931	RTPrintf("tstVD: VMDK delete test failed! rc=%Rrc\n", rc);
932	g_cErrors++;
933	}
934
935	tstVmdk();
936	#endif /* VMDK_TEST */
937	#ifdef VDI_TEST
938	rc = tstVDCreateDelete("VDI", "tmpVDCreate.vdi", 2 * _4G,
939	VD_IMAGE_FLAGS_NONE, true);
940	if (RT_FAILURE(rc))
941	{
942	RTPrintf("tstVD: dynamic VDI create test failed! rc=%Rrc\n", rc);
943	g_cErrors++;
944	}
945	rc = tstVDCreateDelete("VDI", "tmpVDCreate.vdi", 2 * _4G,
946	VD_IMAGE_FLAGS_NONE, true);
947	if (RT_FAILURE(rc))
948	{
949	RTPrintf("tstVD: fixed VDI create test failed! rc=%Rrc\n", rc);
950	g_cErrors++;
951	}
952	#endif /* VDI_TEST */
953	#ifdef VMDK_TEST
954	rc = tstVDCreateDelete("VMDK", "tmpVDCreate.vmdk", 2 * _4G,
955	VD_IMAGE_FLAGS_NONE, true);
956	if (RT_FAILURE(rc))
957	{
958	RTPrintf("tstVD: dynamic VMDK create test failed! rc=%Rrc\n", rc);
959	g_cErrors++;
960	}
961	rc = tstVDCreateDelete("VMDK", "tmpVDCreate.vmdk", 2 * _4G,
962	VD_VMDK_IMAGE_FLAGS_SPLIT_2G, true);
963	if (RT_FAILURE(rc))
964	{
965	RTPrintf("tstVD: dynamic split VMDK create test failed! rc=%Rrc\n", rc);
966	g_cErrors++;
967	}
968	rc = tstVDCreateDelete("VMDK", "tmpVDCreate.vmdk", 2 * _4G,
969	VD_IMAGE_FLAGS_FIXED, true);
970	if (RT_FAILURE(rc))
971	{
972	RTPrintf("tstVD: fixed VMDK create test failed! rc=%Rrc\n", rc);
973	g_cErrors++;
974	}
975	rc = tstVDCreateDelete("VMDK", "tmpVDCreate.vmdk", 2 * _4G,
976	VD_IMAGE_FLAGS_FIXED \| VD_VMDK_IMAGE_FLAGS_SPLIT_2G,
977	true);
978	if (RT_FAILURE(rc))
979	{
980	RTPrintf("tstVD: fixed split VMDK create test failed! rc=%Rrc\n", rc);
981	g_cErrors++;
982	}
983	#endif /* VMDK_TEST */
984	#ifdef VHD_TEST
985	rc = tstVDCreateDelete("VHD", "tmpVDCreate.vhd", 2 * _4G,
986	VD_IMAGE_FLAGS_NONE, true);
987	if (RT_FAILURE(rc))
988	{
989	RTPrintf("tstVD: dynamic VHD create test failed! rc=%Rrc\n", rc);
990	g_cErrors++;
991	}
992	rc = tstVDCreateDelete("VHD", "tmpVDCreate.vhd", 2 * _4G,
993	VD_IMAGE_FLAGS_FIXED, true);
994	if (RT_FAILURE(rc))
995	{
996	RTPrintf("tstVD: fixed VHD create test failed! rc=%Rrc\n", rc);
997	g_cErrors++;
998	}
999	#endif /* VHD_TEST */
1000	#ifdef VDI_TEST
1001	rc = tstVDOpenCreateWriteMerge("VDI", "tmpVDBase.vdi", "tmpVDDiff.vdi", u32Seed);
1002	if (RT_FAILURE(rc))
1003	{
1004	RTPrintf("tstVD: VDI test failed (new image)! rc=%Rrc\n", rc);
1005	g_cErrors++;
1006	}
1007	rc = tstVDOpenCreateWriteMerge("VDI", "tmpVDBase.vdi", "tmpVDDiff.vdi", u32Seed);
1008	if (RT_FAILURE(rc))
1009	{
1010	RTPrintf("tstVD: VDI test failed (existing image)! rc=%Rrc\n", rc);
1011	g_cErrors++;
1012	}
1013	#endif /* VDI_TEST */
1014	#ifdef VMDK_TEST
1015	rc = tstVDOpenCreateWriteMerge("VMDK", "tmpVDBase.vmdk", "tmpVDDiff.vmdk", u32Seed);
1016	if (RT_FAILURE(rc))
1017	{
1018	RTPrintf("tstVD: VMDK test failed (new image)! rc=%Rrc\n", rc);
1019	g_cErrors++;
1020	}
1021	rc = tstVDOpenCreateWriteMerge("VMDK", "tmpVDBase.vmdk", "tmpVDDiff.vmdk", u32Seed);
1022	if (RT_FAILURE(rc))
1023	{
1024	RTPrintf("tstVD: VMDK test failed (existing image)! rc=%Rrc\n", rc);
1025	g_cErrors++;
1026	}
1027	#endif /* VMDK_TEST */
1028	#ifdef VHD_TEST
1029	rc = tstVDCreateWriteOpenRead("VHD", "tmpVDCreate.vhd", u32Seed);
1030	if (RT_FAILURE(rc))
1031	{
1032	RTPrintf("tstVD: VHD test failed (creating image)! rc=%Rrc\n", rc);
1033	g_cErrors++;
1034	}
1035
1036	rc = tstVDOpenCreateWriteMerge("VHD", "tmpVDBase.vhd", "tmpVDDiff.vhd", u32Seed);
1037	if (RT_FAILURE(rc))
1038	{
1039	RTPrintf("tstVD: VHD test failed (existing image)! rc=%Rrc\n", rc);
1040	g_cErrors++;
1041	}
1042	#endif /* VHD_TEST */
1043
1044	/*
1045	* Clean up any leftovers.
1046	*/
1047	RTFileDelete("tmpVDCreate.vdi");
1048	RTFileDelete("tmpVDCreate.vmdk");
1049	RTFileDelete("tmpVDCreate.vhd");
1050	RTFileDelete("tmpVDBase.vdi");
1051	RTFileDelete("tmpVDDiff.vdi");
1052	RTFileDelete("tmpVDBase.vmdk");
1053	RTFileDelete("tmpVDDiff.vmdk");
1054	RTFileDelete("tmpVDBase.vhd");
1055	RTFileDelete("tmpVDDiff.vhd");
1056	RTFileDelete("tmpVDCreate-s001.vmdk");
1057	RTFileDelete("tmpVDCreate-s002.vmdk");
1058	RTFileDelete("tmpVDCreate-s003.vmdk");
1059	RTFileDelete("tmpVDRename.vmdk");
1060	RTFileDelete("tmpVDRename-s001.vmdk");
1061	RTFileDelete("tmpVDRename-s002.vmdk");
1062	RTFileDelete("tmpVDRename-s003.vmdk");
1063
1064	rc = VDShutdown();
1065	if (RT_FAILURE(rc))
1066	{
1067	RTPrintf("tstVD: unloading backends failed! rc=%Rrc\n", rc);
1068	g_cErrors++;
1069	}
1070	/*
1071	* Summary
1072	*/
1073	if (!g_cErrors)
1074	RTPrintf("tstVD: SUCCESS\n");
1075	else
1076	RTPrintf("tstVD: FAILURE - %d errors\n", g_cErrors);
1077
1078	return !!g_cErrors;
1079	}
1080

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

source: vbox/trunk/src/VBox/Storage/testcase/tstVD.cpp@ 105352

Download in other formats: