VirtualBox

source: vbox/trunk/src/VBox/Storage/testcase/tstVDSnap.cpp@ 41911

Last change on this file since 41911 was 38636, checked in by vboxsync, 13 years ago

*,IPRT: Redid the ring-3 init to always convert the arguments to UTF-8.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.9 KB
Line 
1/** @file
2 *
3 * Snapshot VBox HDD container test utility.
4 */
5
6/*
7 * Copyright (C) 2010 Oracle Corporation
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
18#include <VBox/vd.h>
19#include <VBox/err.h>
20#include <VBox/log.h>
21#include <iprt/asm.h>
22#include <iprt/dir.h>
23#include <iprt/string.h>
24#include <iprt/stream.h>
25#include <iprt/file.h>
26#include <iprt/mem.h>
27#include <iprt/initterm.h>
28#include <iprt/rand.h>
29
30/**
31 * A VD snapshot test.
32 */
33typedef struct VDSNAPTEST
34{
35 /** Backend to use */
36 const char *pcszBackend;
37 /** Base image name */
38 const char *pcszBaseImage;
39 /** Diff image ending */
40 const char *pcszDiffSuff;
41 /** Number of iterations before the test exits */
42 uint32_t cIterations;
43 /** Test pattern size */
44 size_t cbTestPattern;
45 /** Minimum number of disk segments */
46 uint32_t cDiskSegsMin;
47 /** Miaximum number of disk segments */
48 uint32_t cDiskSegsMax;
49 /** Minimum number of diffs needed before a merge
50 * operation can occur */
51 unsigned cDiffsMinBeforeMerge;
52 /** Chance to get create instead of a merge operation */
53 uint32_t uCreateDiffChance;
54 /** Chance to change a segment after a diff was created */
55 uint32_t uChangeSegChance;
56 /** Numer of allocated blocks in the base image in percent */
57 uint32_t uAllocatedBlocks;
58 /** Merge direction */
59 bool fForward;
60} VDSNAPTEST, *PVDSNAPTEST;
61
62/**
63 * Structure defining a disk segment.
64 */
65typedef struct VDDISKSEG
66{
67 /** Start offset in the disk. */
68 uint64_t off;
69 /** Size of the segment. */
70 uint64_t cbSeg;
71 /** Pointer to the start of the data in the test pattern used for the segment. */
72 uint8_t *pbData;
73 /** Pointer to the data for a diff write */
74 uint8_t *pbDataDiff;
75} VDDISKSEG, *PVDDISKSEG;
76
77/*******************************************************************************
78* Global Variables *
79*******************************************************************************/
80/** The error count. */
81unsigned g_cErrors = 0;
82/** Global RNG state. */
83RTRAND g_hRand;
84
85static void tstVDError(void *pvUser, int rc, RT_SRC_POS_DECL,
86 const char *pszFormat, va_list va)
87{
88 g_cErrors++;
89 RTPrintf("tstVD: Error %Rrc at %s:%u (%s): ", rc, RT_SRC_POS_ARGS);
90 RTPrintfV(pszFormat, va);
91 RTPrintf("\n");
92}
93
94static int tstVDMessage(void *pvUser, const char *pszFormat, va_list va)
95{
96 RTPrintf("tstVD: ");
97 RTPrintfV(pszFormat, va);
98 return VINF_SUCCESS;
99}
100
101/**
102 * Returns true with the given chance in percent.
103 *
104 * @returns true or false
105 * @param iPercentage The percentage of the chance to return true.
106 */
107static bool tstVDSnapIsTrue(int iPercentage)
108{
109 int uRnd = RTRandAdvU32Ex(g_hRand, 0, 100);
110
111 return (uRnd <= iPercentage); /* This should be enough for our purpose */
112}
113
114static void tstVDSnapSegmentsDice(PVDSNAPTEST pTest, PVDDISKSEG paDiskSeg, uint32_t cDiskSegments,
115 uint8_t *pbTestPattern, size_t cbTestPattern)
116{
117 for (uint32_t i = 0; i < cDiskSegments; i++)
118 {
119 /* Do we want to change the current segment? */
120 if (tstVDSnapIsTrue(pTest->uChangeSegChance))
121 paDiskSeg[i].pbDataDiff = pbTestPattern + RT_ALIGN_64(RTRandAdvU64Ex(g_hRand, 0, cbTestPattern - paDiskSeg[i].cbSeg - 512), 512);
122 }
123}
124
125static int tstVDSnapWrite(PVBOXHDD pVD, PVDDISKSEG paDiskSegments,
126 uint32_t cDiskSegments, uint64_t cbDisk, bool fInit)
127{
128 int rc = VINF_SUCCESS;
129
130 for (uint32_t i = 0; i < cDiskSegments; i++)
131 {
132 if (fInit || paDiskSegments[i].pbDataDiff)
133 {
134 size_t cbWrite = paDiskSegments[i].cbSeg;
135 uint64_t off = paDiskSegments[i].off;
136 uint8_t *pbData = fInit
137 ? paDiskSegments[i].pbData
138 : paDiskSegments[i].pbDataDiff;
139
140 if (pbData)
141 {
142 rc = VDWrite(pVD, off, pbData, cbWrite);
143 if (RT_FAILURE(rc))
144 return rc;
145 }
146 }
147 }
148
149 return rc;
150}
151
152static int tstVDSnapReadVerify(PVBOXHDD pVD, PVDDISKSEG paDiskSegments, uint32_t cDiskSegments, uint64_t cbDisk)
153{
154 int rc = VINF_SUCCESS;
155 uint8_t *pbBuf = (uint8_t *)RTMemAlloc(_1M);
156
157 for (uint32_t i = 0; i < cDiskSegments; i++)
158 {
159 size_t cbRead = paDiskSegments[i].cbSeg;
160 uint64_t off = paDiskSegments[i].off;
161 uint8_t *pbCmp = paDiskSegments[i].pbData;
162
163 Assert(!paDiskSegments[i].pbDataDiff);
164
165 while (cbRead)
166 {
167 size_t cbToRead = RT_MIN(cbRead, _1M);
168
169 rc = VDRead(pVD, off, pbBuf, cbToRead);
170 if (RT_FAILURE(rc))
171 return rc;
172
173 if (pbCmp)
174 {
175 if (memcmp(pbCmp, pbBuf, cbToRead))
176 {
177 for (unsigned iCmp = 0; iCmp < cbToRead; iCmp++)
178 {
179 if (pbCmp[iCmp] != pbBuf[iCmp])
180 {
181 RTPrintf("Unexpected data at %llu expected %#x got %#x\n", off+iCmp, pbCmp[iCmp], pbBuf[iCmp]);
182 break;
183 }
184 }
185 return VERR_INTERNAL_ERROR;
186 }
187 }
188 else
189 {
190 /* Verify that the block is 0 */
191 for (unsigned iCmp = 0; iCmp < cbToRead; iCmp++)
192 {
193 if (pbBuf[iCmp] != 0)
194 {
195 RTPrintf("Zero block contains data at %llu\n", off+iCmp);
196 return VERR_INTERNAL_ERROR;
197 }
198 }
199 }
200
201 cbRead -= cbToRead;
202 off += cbToRead;
203
204 if (pbCmp)
205 pbCmp += cbToRead;
206 }
207 }
208
209 RTMemFree(pbBuf);
210
211 return rc;
212}
213
214static int tstVDOpenCreateWriteMerge(PVDSNAPTEST pTest)
215{
216 int rc;
217 PVBOXHDD pVD = NULL;
218 VDGEOMETRY PCHS = { 0, 0, 0 };
219 VDGEOMETRY LCHS = { 0, 0, 0 };
220 PVDINTERFACE pVDIfs = NULL;
221 VDINTERFACEERROR VDIfError;
222
223 /** Buffer storing the random test pattern. */
224 uint8_t *pbTestPattern = NULL;
225 /** Number of disk segments */
226 uint32_t cDiskSegments;
227 /** Array of disk segments */
228 PVDDISKSEG paDiskSeg = NULL;
229 unsigned cDiffs = 0;
230 unsigned idDiff = 0; /* Diff ID counter for the filename */
231
232 /* Create the virtual disk test data */
233 pbTestPattern = (uint8_t *)RTMemAlloc(pTest->cbTestPattern);
234
235 RTRandAdvBytes(g_hRand, pbTestPattern, pTest->cbTestPattern);
236 cDiskSegments = RTRandAdvU32Ex(g_hRand, pTest->cDiskSegsMin, pTest->cDiskSegsMax);
237
238 uint64_t cbDisk = 0;
239
240 paDiskSeg = (PVDDISKSEG)RTMemAllocZ(cDiskSegments * sizeof(VDDISKSEG));
241 for (unsigned i = 0; i < cDiskSegments; i++)
242 {
243 paDiskSeg[i].off = cbDisk;
244 paDiskSeg[i].cbSeg = RT_ALIGN_64(RTRandAdvU64Ex(g_hRand, 512, pTest->cbTestPattern), 512);
245 if (tstVDSnapIsTrue(pTest->uAllocatedBlocks))
246 paDiskSeg[i].pbData = pbTestPattern + RT_ALIGN_64(RTRandAdvU64Ex(g_hRand, 0, pTest->cbTestPattern - paDiskSeg[i].cbSeg - 512), 512);
247 else
248 paDiskSeg[i].pbData = NULL; /* Not allocated initially */
249 cbDisk += paDiskSeg[i].cbSeg;
250 }
251
252 RTPrintf("Disk size is %llu bytes\n", cbDisk);
253
254#define CHECK(str) \
255 do \
256 { \
257 RTPrintf("%s rc=%Rrc\n", str, rc); \
258 if (RT_FAILURE(rc)) \
259 { \
260 if (pbTestPattern) \
261 RTMemFree(pbTestPattern); \
262 VDDestroy(pVD); \
263 return rc; \
264 } \
265 } while (0)
266
267 /* Create error interface. */
268 /* Create error interface. */
269 VDIfError.pfnError = tstVDError;
270 VDIfError.pfnMessage = tstVDMessage;
271
272 rc = VDInterfaceAdd(&VDIfError.Core, "tstVD_Error", VDINTERFACETYPE_ERROR,
273 NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
274 AssertRC(rc);
275
276
277 rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
278 CHECK("VDCreate()");
279
280 rc = VDCreateBase(pVD, pTest->pcszBackend, pTest->pcszBaseImage, cbDisk,
281 VD_IMAGE_FLAGS_NONE, "Test image",
282 &PCHS, &LCHS, NULL, VD_OPEN_FLAGS_NORMAL,
283 NULL, NULL);
284 CHECK("VDCreateBase()");
285
286 bool fInit = true;
287 uint32_t cIteration = 0;
288
289 /* Do the real work now */
290 while ( RT_SUCCESS(rc)
291 && cIteration < pTest->cIterations)
292 {
293 /* Write */
294 rc = tstVDSnapWrite(pVD, paDiskSeg, cDiskSegments, cbDisk, fInit);
295 CHECK("tstVDSnapWrite()");
296
297 fInit = false;
298
299 /* Write returned, do we want to create a new diff or merge them? */
300 bool fCreate = cDiffs < pTest->cDiffsMinBeforeMerge
301 ? true
302 : tstVDSnapIsTrue(pTest->uCreateDiffChance);
303
304 if (fCreate)
305 {
306 char *pszDiffFilename = NULL;
307
308 RTStrAPrintf(&pszDiffFilename, "tstVDSnapDiff%u.%s", idDiff, pTest->pcszDiffSuff);
309 CHECK("RTStrAPrintf()");
310 idDiff++;
311 cDiffs++;
312
313 rc = VDCreateDiff(pVD, pTest->pcszBackend, pszDiffFilename,
314 VD_IMAGE_FLAGS_NONE, "Test diff image", NULL, NULL,
315 VD_OPEN_FLAGS_NORMAL, NULL, NULL);
316 CHECK("VDCreateDiff()");
317
318 RTStrFree(pszDiffFilename);
319 VDDumpImages(pVD);
320
321 /* Change data */
322 tstVDSnapSegmentsDice(pTest, paDiskSeg, cDiskSegments, pbTestPattern, pTest->cbTestPattern);
323 }
324 else
325 {
326 uint32_t uStartMerge = RTRandAdvU32Ex(g_hRand, 1, cDiffs - 1);
327 uint32_t uEndMerge = RTRandAdvU32Ex(g_hRand, uStartMerge + 1, cDiffs);
328 RTPrintf("Merging %u diffs from %u to %u...\n",
329 uEndMerge - uStartMerge,
330 uStartMerge,
331 uEndMerge);
332 if (pTest->fForward)
333 rc = VDMerge(pVD, uStartMerge, uEndMerge, NULL);
334 else
335 rc = VDMerge(pVD, uEndMerge, uStartMerge, NULL);
336 CHECK("VDMerge()");
337
338 cDiffs -= uEndMerge - uStartMerge;
339
340 VDDumpImages(pVD);
341
342 /* Go through the disk segments and reset pointers. */
343 for (uint32_t i = 0; i < cDiskSegments; i++)
344 {
345 if (paDiskSeg[i].pbDataDiff)
346 {
347 paDiskSeg[i].pbData = paDiskSeg[i].pbDataDiff;
348 paDiskSeg[i].pbDataDiff = NULL;
349 }
350 }
351
352 /* Now compare the result with our test pattern */
353 rc = tstVDSnapReadVerify(pVD, paDiskSeg, cDiskSegments, cbDisk);
354 CHECK("tstVDSnapReadVerify()");
355 }
356 cIteration++;
357 }
358
359 VDDumpImages(pVD);
360
361 VDDestroy(pVD);
362 if (pbTestPattern)
363 RTMemFree(pbTestPattern);
364
365 RTFileDelete(pTest->pcszBaseImage);
366 for (unsigned i = 0; i < idDiff; i++)
367 {
368 char *pszDiffFilename = NULL;
369
370 RTStrAPrintf(&pszDiffFilename, "tstVDSnapDiff%u.%s", i, pTest->pcszDiffSuff);
371 RTFileDelete(pszDiffFilename);
372 RTStrFree(pszDiffFilename);
373 }
374#undef CHECK
375 return 0;
376}
377
378int main(int argc, char *argv[])
379{
380 RTR3InitExe(argc, &argv, 0);
381 int rc;
382 VDSNAPTEST Test;
383
384 RTPrintf("tstVDSnap: TESTING...\n");
385
386 rc = RTRandAdvCreateParkMiller(&g_hRand);
387 if (RT_FAILURE(rc))
388 {
389 RTPrintf("tstVDSnap: Creating RNG failed rc=%Rrc\n", rc);
390 return 1;
391 }
392
393 RTRandAdvSeed(g_hRand, 0x12345678);
394
395 Test.pcszBackend = "vmdk";
396 Test.pcszBaseImage = "tstVDSnapBase.vmdk";
397 Test.pcszDiffSuff = "vmdk";
398 Test.cIterations = 30;
399 Test.cbTestPattern = 10 * _1M;
400 Test.cDiskSegsMin = 10;
401 Test.cDiskSegsMax = 50;
402 Test.cDiffsMinBeforeMerge = 5;
403 Test.uCreateDiffChance = 50; /* % */
404 Test.uChangeSegChance = 50; /* % */
405 Test.uAllocatedBlocks = 50; /* 50% allocated */
406 Test.fForward = true;
407 tstVDOpenCreateWriteMerge(&Test);
408
409 /* Same test with backwards merge */
410 Test.fForward = false;
411 tstVDOpenCreateWriteMerge(&Test);
412
413 rc = VDShutdown();
414 if (RT_FAILURE(rc))
415 {
416 RTPrintf("tstVDSnap: unloading backends failed! rc=%Rrc\n", rc);
417 g_cErrors++;
418 }
419 /*
420 * Summary
421 */
422 if (!g_cErrors)
423 RTPrintf("tstVDSnap: SUCCESS\n");
424 else
425 RTPrintf("tstVDSnap: FAILURE - %d errors\n", g_cErrors);
426
427 RTRandAdvDestroy(g_hRand);
428
429 return !!g_cErrors;
430}
431
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette