tstVD.cpp@ 13303

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

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

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

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

Download in other formats: