VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstSSM.cpp@ 4672

Last change on this file since 4672 was 4071, checked in by vboxsync, 17 years ago

Biggest check-in ever. New source code headers for all (C) innotek files.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 20.1 KB
Line 
1/* $Id: tstSSM.cpp 4071 2007-08-07 17:07:59Z vboxsync $ */
2/** @file
3 * Saved State Manager Testcase.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#include <VBox/ssm.h>
23#include <VBox/vm.h>
24
25#include <VBox/log.h>
26#include <VBox/sup.h>
27#include <VBox/err.h>
28#include <VBox/param.h>
29#include <iprt/runtime.h>
30#include <iprt/assert.h>
31#include <iprt/stream.h>
32#include <iprt/string.h>
33#include <iprt/time.h>
34
35
36const uint8_t gabPage[PAGE_SIZE] = {0};
37
38const char gachMem1[] = "sdfg\1asdfa\177hjkl;sdfghjkl;dfghjkl;dfghjkl;\0\0asdf;kjasdf;lkjasd;flkjasd;lfkjasd\0;lfk";
39
40uint8_t gabBigMem[8*1024*1024];
41
42/** initializes gabBigMem with some non zero stuff. */
43void initBigMem(void)
44{
45#if 0
46 uint32_t *puch = (uint32_t *)&gabBigMem[0];
47 uint32_t *puchEnd = (uint32_t *)&gabBigMem[sizeof(gabBigMem)];
48 uint32_t u32 = 0xdeadbeef;
49 for (; puch < puchEnd; puch++)
50 {
51 *puch = u32;
52 u32 += 19;
53 u32 = (u32 << 1) | (u32 >> 31);
54 }
55#else
56 uint8_t *pb = &gabBigMem[0];
57 uint8_t *pbEnd = &gabBigMem[sizeof(gabBigMem)];
58 for (; pb < pbEnd; pb += 16)
59 {
60 char szTmp[17];
61 RTStrPrintf(szTmp, sizeof(szTmp), "aaaa%08Xzzzz", (uint32_t)(uintptr_t)pb);
62 memcpy(pb, szTmp, 16);
63 }
64#endif
65}
66
67/**
68 * Execute state save operation.
69 *
70 * @returns VBox status code.
71 * @param pDevIns Device instance of the device which registered the data unit.
72 * @param pSSM SSM operation handle.
73 */
74DECLCALLBACK(int) Item01Save(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
75{
76 uint64_t u64Start = RTTimeNanoTS();
77
78 /*
79 * Test writing some memory block.
80 */
81 int rc = SSMR3PutMem(pSSM, gachMem1, sizeof(gachMem1));
82 if (VBOX_FAILURE(rc))
83 {
84 RTPrintf("Item01: #1 - SSMR3PutMem -> %Vrc\n", rc);
85 return rc;
86 }
87
88 /*
89 * Test writing a zeroterminated string.
90 */
91 rc = SSMR3PutStrZ(pSSM, "String");
92 if (VBOX_FAILURE(rc))
93 {
94 RTPrintf("Item01: #1 - SSMR3PutMem -> %Vrc\n", rc);
95 return rc;
96 }
97
98
99 /*
100 * Test the individual integer put functions to see that they all work.
101 * (Testcases are also known as "The Land of The Ugly Code"...)
102 */
103#define ITEM(suff,bits, val) \
104 rc = SSMR3Put##suff(pSSM, val); \
105 if (VBOX_FAILURE(rc)) \
106 { \
107 RTPrintf("Item01: #" #suff " - SSMR3Put" #suff "(," #val ") -> %Vrc\n", rc); \
108 return rc; \
109 }
110 /* copy & past with the load one! */
111 ITEM(U8, uint8_t, 0xff);
112 ITEM(U8, uint8_t, 0x0);
113 ITEM(U8, uint8_t, 1);
114 ITEM(U8, uint8_t, 42);
115 ITEM(U8, uint8_t, 230);
116 ITEM(S8, int8_t, -128);
117 ITEM(S8, int8_t, 127);
118 ITEM(S8, int8_t, 12);
119 ITEM(S8, int8_t, -76);
120 ITEM(U16, uint16_t, 0xffff);
121 ITEM(U16, uint16_t, 0x0);
122 ITEM(S16, int16_t, 32767);
123 ITEM(S16, int16_t, -32768);
124 ITEM(U32, uint32_t, 4294967295U);
125 ITEM(U32, uint32_t, 0);
126 ITEM(U32, uint32_t, 42);
127 ITEM(U32, uint32_t, 2342342344U);
128 ITEM(S32, int32_t, -2147483647-1);
129 ITEM(S32, int32_t, 2147483647);
130 ITEM(S32, int32_t, 42);
131 ITEM(S32, int32_t, 568459834);
132 ITEM(S32, int32_t, -58758999);
133 ITEM(U64, uint64_t, 18446744073709551615ULL);
134 ITEM(U64, uint64_t, 0);
135 ITEM(U64, uint64_t, 42);
136 ITEM(U64, uint64_t, 593023944758394234ULL);
137 ITEM(S64, int64_t, 9223372036854775807LL);
138 ITEM(S64, int64_t, -9223372036854775807LL - 1);
139 ITEM(S64, int64_t, 42);
140 ITEM(S64, int64_t, 21398723459873LL);
141 ITEM(S64, int64_t, -5848594593453453245LL);
142#undef ITEM
143
144 uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
145 RTPrintf("tstSSM: Saved 1st item in %RI64 ns\n", u64Elapsed);
146 return 0;
147}
148
149/**
150 * Prepare state load operation.
151 *
152 * @returns VBox status code.
153 * @param pDevIns Device instance of the device which registered the data unit.
154 * @param pSSM SSM operation handle.
155 */
156DECLCALLBACK(int) Item01Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version)
157{
158 /*
159 * Load the memory block.
160 */
161 char achTmp[sizeof(gachMem1)];
162 int rc = SSMR3GetMem(pSSM, achTmp, sizeof(gachMem1));
163 if (VBOX_FAILURE(rc))
164 {
165 RTPrintf("Item01: #1 - SSMR3GetMem -> %Vrc\n", rc);
166 return rc;
167 }
168
169 /*
170 * Load the string.
171 */
172 rc = SSMR3GetStrZ(pSSM, achTmp, sizeof(achTmp));
173 if (VBOX_FAILURE(rc))
174 {
175 RTPrintf("Item01: #2 - SSMR3GetStrZ -> %Vrc\n", rc);
176 return rc;
177 }
178
179 /*
180 * Test the individual integer put functions to see that they all work.
181 * (Testcases are also known as "The Land of The Ugly Code"...)
182 */
183#define ITEM(suff, type, val) \
184 do { \
185 type var = {0}; \
186 rc = SSMR3Get##suff(pSSM, &var); \
187 if (VBOX_FAILURE(rc)) \
188 { \
189 RTPrintf("Item01: #" #suff " - SSMR3Get" #suff "(," #val ") -> %Vrc\n", rc); \
190 return rc; \
191 } \
192 if (var != val) \
193 { \
194 RTPrintf("Item01: #" #suff " - SSMR3Get" #suff "(," #val ") -> %d returned wrong value!\n", rc); \
195 return VERR_GENERAL_FAILURE; \
196 } \
197 } while (0)
198 /* copy & past with the load one! */
199 ITEM(U8, uint8_t, 0xff);
200 ITEM(U8, uint8_t, 0x0);
201 ITEM(U8, uint8_t, 1);
202 ITEM(U8, uint8_t, 42);
203 ITEM(U8, uint8_t, 230);
204 ITEM(S8, int8_t, -128);
205 ITEM(S8, int8_t, 127);
206 ITEM(S8, int8_t, 12);
207 ITEM(S8, int8_t, -76);
208 ITEM(U16, uint16_t, 0xffff);
209 ITEM(U16, uint16_t, 0x0);
210 ITEM(S16, int16_t, 32767);
211 ITEM(S16, int16_t, -32768);
212 ITEM(U32, uint32_t, 4294967295U);
213 ITEM(U32, uint32_t, 0);
214 ITEM(U32, uint32_t, 42);
215 ITEM(U32, uint32_t, 2342342344U);
216 ITEM(S32, int32_t, -2147483647-1);
217 ITEM(S32, int32_t, 2147483647);
218 ITEM(S32, int32_t, 42);
219 ITEM(S32, int32_t, 568459834);
220 ITEM(S32, int32_t, -58758999);
221 ITEM(U64, uint64_t, 18446744073709551615ULL);
222 ITEM(U64, uint64_t, 0);
223 ITEM(U64, uint64_t, 42);
224 ITEM(U64, uint64_t, 593023944758394234ULL);
225 ITEM(S64, int64_t, 9223372036854775807LL);
226 ITEM(S64, int64_t, -9223372036854775807LL - 1);
227 ITEM(S64, int64_t, 42);
228 ITEM(S64, int64_t, 21398723459873LL);
229 ITEM(S64, int64_t, -5848594593453453245LL);
230#undef ITEM
231
232 return 0;
233}
234
235
236/**
237 * Execute state save operation.
238 *
239 * @returns VBox status code.
240 * @param pDevIns Device instance of the device which registered the data unit.
241 * @param pSSM SSM operation handle.
242 */
243DECLCALLBACK(int) Item02Save(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
244{
245 uint64_t u64Start = RTTimeNanoTS();
246
247 /*
248 * Put the size.
249 */
250 size_t cb = sizeof(gabBigMem);
251 int rc = SSMR3PutU32(pSSM, cb);
252 if (VBOX_FAILURE(rc))
253 {
254 RTPrintf("Item02: PutU32 -> %Vrc\n", rc);
255 return rc;
256 }
257
258 /*
259 * Put 8MB of memory to the file in 3 chunks.
260 */
261 uint8_t *pbMem = &gabBigMem[0];
262 size_t cbChunk = cb / 47;
263 rc = SSMR3PutMem(pSSM, pbMem, cbChunk);
264 if (VBOX_FAILURE(rc))
265 {
266 RTPrintf("Item02: PutMem(,%p,%#x) -> %Vrc\n", pbMem, cbChunk, rc);
267 return rc;
268 }
269 cb -= cbChunk;
270 pbMem += cbChunk;
271
272 /* next piece. */
273 cbChunk *= 19;
274 rc = SSMR3PutMem(pSSM, pbMem, cbChunk);
275 if (VBOX_FAILURE(rc))
276 {
277 RTPrintf("Item02: PutMem(,%p,%#x) -> %Vrc\n", pbMem, cbChunk, rc);
278 return rc;
279 }
280 cb -= cbChunk;
281 pbMem += cbChunk;
282
283 /* last piece. */
284 cbChunk = cb;
285 rc = SSMR3PutMem(pSSM, pbMem, cbChunk);
286 if (VBOX_FAILURE(rc))
287 {
288 RTPrintf("Item02: PutMem(,%p,%#x) -> %Vrc\n", pbMem, cbChunk, rc);
289 return rc;
290 }
291
292 uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
293 RTPrintf("tstSSM: Saved 2nd item in %RI64 ns\n", u64Elapsed);
294 return 0;
295}
296
297/**
298 * Prepare state load operation.
299 *
300 * @returns VBox status code.
301 * @param pDevIns Device instance of the device which registered the data unit.
302 * @param pSSM SSM operation handle.
303 */
304DECLCALLBACK(int) Item02Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version)
305{
306 /*
307 * Load the size.
308 */
309 uint32_t cb;
310 int rc = SSMR3GetU32(pSSM, &cb);
311 if (VBOX_FAILURE(rc))
312 {
313 RTPrintf("Item02: SSMR3GetU32 -> %Vrc\n", rc);
314 return rc;
315 }
316 if (cb != sizeof(gabBigMem))
317 {
318 RTPrintf("Item02: loaded size doesn't match the real thing. %#x != %#x\n", cb, sizeof(gabBigMem));
319 return VERR_GENERAL_FAILURE;
320 }
321
322 /*
323 * Load the memory chunk by chunk.
324 */
325 uint8_t *pbMem = &gabBigMem[0];
326 char achTmp[16383];
327 size_t cbChunk = sizeof(achTmp);
328 while (cb > 0)
329 {
330 cbChunk -= 7;
331 if (cbChunk < 64)
332 cbChunk = sizeof(achTmp) - (cbChunk % 47);
333 if (cbChunk > cb)
334 cbChunk = cb;
335 rc = SSMR3GetMem(pSSM, &achTmp[0], cbChunk);
336 if (VBOX_FAILURE(rc))
337 {
338 RTPrintf("Item02: SSMR3GetMem(,,%#x) -> %d offset %#x\n", cbChunk, rc, pbMem - &gabBigMem[0]);
339 return rc;
340 }
341 if (memcmp(achTmp, pbMem, cbChunk))
342 {
343 RTPrintf("Item02: compare failed. mem offset=%#x cbChunk=%#x\n", pbMem - &gabBigMem[0], cbChunk);
344 return VERR_GENERAL_FAILURE;
345 }
346
347 /* next */
348 pbMem += cbChunk;
349 cb -= cbChunk;
350 }
351
352 return 0;
353}
354
355
356/**
357 * Execute state save operation.
358 *
359 * @returns VBox status code.
360 * @param pDevIns Device instance of the device which registered the data unit.
361 * @param pSSM SSM operation handle.
362 */
363DECLCALLBACK(int) Item03Save(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
364{
365 uint64_t u64Start = RTTimeNanoTS();
366
367 /*
368 * Put the size.
369 */
370 size_t cb = 512*_1M;
371 int rc = SSMR3PutU32(pSSM, cb);
372 if (VBOX_FAILURE(rc))
373 {
374 RTPrintf("Item03: PutU32 -> %Vrc\n", rc);
375 return rc;
376 }
377
378 /*
379 * Put 512 MB page by page.
380 */
381 const uint8_t *pu8Org = &gabBigMem[0];
382 while (cb > 0)
383 {
384 rc = SSMR3PutMem(pSSM, pu8Org, PAGE_SIZE);
385 if (VBOX_FAILURE(rc))
386 {
387 RTPrintf("Item03: PutMem(,%p,%#x) -> %Vrc\n", pu8Org, PAGE_SIZE, rc);
388 return rc;
389 }
390
391 /* next */
392 cb -= PAGE_SIZE;
393 pu8Org += PAGE_SIZE;
394 if (pu8Org > &gabBigMem[sizeof(gabBigMem)])
395 pu8Org = &gabBigMem[0];
396 }
397
398 uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
399 RTPrintf("tstSSM: Saved 3rd item in %RI64 ns\n", u64Elapsed);
400 return 0;
401}
402
403/**
404 * Prepare state load operation.
405 *
406 * @returns VBox status code.
407 * @param pDevIns Device instance of the device which registered the data unit.
408 * @param pSSM SSM operation handle.
409 */
410DECLCALLBACK(int) Item03Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version)
411{
412 /*
413 * Load the size.
414 */
415 uint32_t cb;
416 int rc = SSMR3GetU32(pSSM, &cb);
417 if (VBOX_FAILURE(rc))
418 {
419 RTPrintf("Item03: SSMR3GetU32 -> %Vrc\n", rc);
420 return rc;
421 }
422 if (cb != 512*_1M)
423 {
424 RTPrintf("Item03: loaded size doesn't match the real thing. %#x != %#x\n", cb, 512*_1M);
425 return VERR_GENERAL_FAILURE;
426 }
427
428 /*
429 * Load the memory page by page.
430 */
431 const uint8_t *pu8Org = &gabBigMem[0];
432 while (cb > 0)
433 {
434 char achPage[PAGE_SIZE];
435 rc = SSMR3GetMem(pSSM, &achPage[0], PAGE_SIZE);
436 if (VBOX_FAILURE(rc))
437 {
438 RTPrintf("Item03: SSMR3GetMem(,,%#x) -> %Vrc offset %#x\n", PAGE_SIZE, rc, 512*_1M - cb);
439 return rc;
440 }
441 if (memcmp(achPage, pu8Org, PAGE_SIZE))
442 {
443 RTPrintf("Item03: compare failed. mem offset=%#x\n", 512*_1M - cb);
444 return VERR_GENERAL_FAILURE;
445 }
446
447 /* next */
448 cb -= PAGE_SIZE;
449 pu8Org += PAGE_SIZE;
450 if (pu8Org > &gabBigMem[sizeof(gabBigMem)])
451 pu8Org = &gabBigMem[0];
452 }
453
454 return 0;
455}
456
457
458/**
459 * Execute state save operation.
460 *
461 * @returns VBox status code.
462 * @param pDevIns Device instance of the device which registered the data unit.
463 * @param pSSM SSM operation handle.
464 */
465DECLCALLBACK(int) Item04Save(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
466{
467 uint64_t u64Start = RTTimeNanoTS();
468
469 /*
470 * Put the size.
471 */
472 size_t cb = 512*_1M;
473 int rc = SSMR3PutU32(pSSM, cb);
474 if (VBOX_FAILURE(rc))
475 {
476 RTPrintf("Item04: PutU32 -> %Vrc\n", rc);
477 return rc;
478 }
479
480 /*
481 * Put 512 MB page by page.
482 */
483 while (cb > 0)
484 {
485 rc = SSMR3PutMem(pSSM, gabPage, PAGE_SIZE);
486 if (VBOX_FAILURE(rc))
487 {
488 RTPrintf("Item04: PutMem(,%p,%#x) -> %Vrc\n", gabPage, PAGE_SIZE, rc);
489 return rc;
490 }
491
492 /* next */
493 cb -= PAGE_SIZE;
494 }
495
496 uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
497 RTPrintf("tstSSM: Saved 4th item in %RI64 ns\n", u64Elapsed);
498 return 0;
499}
500
501/**
502 * Prepare state load operation.
503 *
504 * @returns VBox status code.
505 * @param pDevIns Device instance of the device which registered the data unit.
506 * @param pSSM SSM operation handle.
507 */
508DECLCALLBACK(int) Item04Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version)
509{
510 /*
511 * Load the size.
512 */
513 uint32_t cb;
514 int rc = SSMR3GetU32(pSSM, &cb);
515 if (VBOX_FAILURE(rc))
516 {
517 RTPrintf("Item04: SSMR3GetU32 -> %Vrc\n", rc);
518 return rc;
519 }
520 if (cb != 512*_1M)
521 {
522 RTPrintf("Item04: loaded size doesn't match the real thing. %#x != %#x\n", cb, 512*_1M);
523 return VERR_GENERAL_FAILURE;
524 }
525
526 /*
527 * Load the memory page by page.
528 */
529 while (cb > 0)
530 {
531 char achPage[PAGE_SIZE];
532 rc = SSMR3GetMem(pSSM, &achPage[0], PAGE_SIZE);
533 if (VBOX_FAILURE(rc))
534 {
535 RTPrintf("Item04: SSMR3GetMem(,,%#x) -> %Vrc offset %#x\n", PAGE_SIZE, rc, 512*_1M - cb);
536 return rc;
537 }
538 if (memcmp(achPage, gabPage, PAGE_SIZE))
539 {
540 RTPrintf("Item04: compare failed. mem offset=%#x\n", 512*_1M - cb);
541 return VERR_GENERAL_FAILURE;
542 }
543
544 /* next */
545 cb -= PAGE_SIZE;
546 }
547
548 return 0;
549}
550
551
552int main(int argc, char **argv)
553{
554 /*
555 * Init runtime and static data.
556 */
557 RTR3Init();
558 RTPrintf("tstSSM: TESTING...\n");
559 initBigMem();
560 const char *pszFilename = "SSMTestSave#1";
561
562 /*
563 * Create empty VM structure and init SSM.
564 */
565 PVM pVM;
566 int rc = SUPInit(NULL);
567 if (VBOX_SUCCESS(rc))
568 rc = SUPPageAlloc((sizeof(*pVM) + PAGE_SIZE - 1) >> PAGE_SHIFT, (void **)&pVM);
569 if (VBOX_FAILURE(rc))
570 {
571 RTPrintf("Fatal error: SUP Failure! rc=%Vrc\n", rc);
572 return 1;
573 }
574
575 rc = STAMR3Init(pVM);
576 if (VBOX_FAILURE(rc))
577 {
578 RTPrintf("Fatal error: STAMR3Init failed! rc=%Vrc\n", rc);
579 return 1;
580 }
581
582/*
583 rc = SSMR3Init(pVM);
584 if (VBOX_FAILURE(rc))
585 {
586 RTPrintf("Fatal error: SSMR3Init failed! rc=%Vrc\n", rc);
587 return 1;
588 }
589*/
590
591 /*
592 * Register a few callbacks.
593 */
594 rc = SSMR3Register(pVM, NULL, "SSM Testcase Data Item no.1 (all types)", 1, 0, 256,
595 NULL, Item01Save, NULL,
596 NULL, Item01Load, NULL);
597 if (VBOX_FAILURE(rc))
598 {
599 RTPrintf("SSMR3Register #1 -> %Vrc\n", rc);
600 return 1;
601 }
602
603 rc = SSMR3Register(pVM, NULL, "SSM Testcase Data Item no.2 (rand mem)", 2, 0, _1M * 8,
604 NULL, Item02Save, NULL,
605 NULL, Item02Load, NULL);
606 if (VBOX_FAILURE(rc))
607 {
608 RTPrintf("SSMR3Register #2 -> %Vrc\n", rc);
609 return 1;
610 }
611
612 rc = SSMR3Register(pVM, NULL, "SSM Testcase Data Item no.3 (big mem)", 0, 123, 512*_1M,
613 NULL, Item03Save, NULL,
614 NULL, Item03Load, NULL);
615 if (VBOX_FAILURE(rc))
616 {
617 RTPrintf("SSMR3Register #3 -> %Vrc\n", rc);
618 return 1;
619 }
620
621 rc = SSMR3Register(pVM, NULL, "SSM Testcase Data Item no.4 (big zero mem)", 0, 42, 512*_1M,
622 NULL, Item04Save, NULL,
623 NULL, Item04Load, NULL);
624 if (VBOX_FAILURE(rc))
625 {
626 RTPrintf("SSMR3Register #4 -> %Vrc\n", rc);
627 return 1;
628 }
629
630 /*
631 * Attempt a save.
632 */
633 uint64_t u64Start = RTTimeNanoTS();
634 rc = SSMR3Save(pVM, pszFilename, SSMAFTER_DESTROY, NULL, NULL);
635 if (VBOX_FAILURE(rc))
636 {
637 RTPrintf("SSMR3Save #1 -> %Vrc\n", rc);
638 return 1;
639 }
640 uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
641 RTPrintf("tstSSM: Saved in %RI64 ns\n", u64Elapsed);
642
643 /*
644 * Attempt a load.
645 */
646 u64Start = RTTimeNanoTS();
647 rc = SSMR3Load(pVM, pszFilename, SSMAFTER_RESUME, NULL, NULL);
648 if (VBOX_FAILURE(rc))
649 {
650 RTPrintf("SSMR3Load #1 -> %Vrc\n", rc);
651 return 1;
652 }
653 u64Elapsed = RTTimeNanoTS() - u64Start;
654 RTPrintf("tstSSM: Loaded in %RI64 ns\n", u64Elapsed);
655
656 /*
657 * Validate it.
658 */
659 u64Start = RTTimeNanoTS();
660 rc = SSMR3ValidateFile(pszFilename);
661 if (VBOX_FAILURE(rc))
662 {
663 RTPrintf("SSMR3ValidateFile #1 -> %Vrc\n", rc);
664 return 1;
665 }
666 u64Elapsed = RTTimeNanoTS() - u64Start;
667 RTPrintf("tstSSM: Validated in %RI64 ns\n", u64Elapsed);
668
669 /*
670 * Open it and read.
671 */
672 u64Start = RTTimeNanoTS();
673 PSSMHANDLE pSSM;
674 rc = SSMR3Open(pszFilename, 0, &pSSM);
675 if (VBOX_FAILURE(rc))
676 {
677 RTPrintf("SSMR3Open #1 -> %Vrc\n", rc);
678 return 1;
679 }
680 u64Elapsed = RTTimeNanoTS() - u64Start;
681 RTPrintf("tstSSM: Opened in %RI64 ns\n", u64Elapsed);
682
683 /* negative */
684 u64Start = RTTimeNanoTS();
685 rc = SSMR3Seek(pSSM, "some unit that doesn't exist", 0, NULL);
686 if (rc != VERR_SSM_UNIT_NOT_FOUND)
687 {
688 RTPrintf("SSMR3Seek #1 negative -> %Vrc\n", rc);
689 return 1;
690 }
691 u64Elapsed = RTTimeNanoTS() - u64Start;
692 RTPrintf("tstSSM: Failed seek in %RI64 ns\n", u64Elapsed);
693
694 /* 2nd unit */
695 rc = SSMR3Seek(pSSM, "SSM Testcase Data Item no.2 (rand mem)", 0, NULL);
696 if (VBOX_FAILURE(rc))
697 {
698 RTPrintf("SSMR3Seek #1 unit 2-> %Vrc\n", rc);
699 return 1;
700 }
701 uint32_t u32Version = 0xbadc0ded;
702 rc = SSMR3Seek(pSSM, "SSM Testcase Data Item no.2 (rand mem)", 0, &u32Version);
703 if (VBOX_FAILURE(rc))
704 {
705 RTPrintf("SSMR3Seek #1 unit 2-> %Vrc\n", rc);
706 return 1;
707 }
708 u64Start = RTTimeNanoTS();
709 rc = Item02Load(NULL, pSSM, u32Version);
710 if (VBOX_FAILURE(rc))
711 {
712 RTPrintf("Item02Load #1 -> %Vrc\n", rc);
713 return 1;
714 }
715 u64Elapsed = RTTimeNanoTS() - u64Start;
716 RTPrintf("tstSSM: Loaded 2nd item in %RI64 ns\n", u64Elapsed);
717
718 /* 1st unit */
719 u32Version = 0xbadc0ded;
720 rc = SSMR3Seek(pSSM, "SSM Testcase Data Item no.1 (all types)", 0, &u32Version);
721 if (VBOX_FAILURE(rc))
722 {
723 RTPrintf("SSMR3Seek #1 unit 1 -> %Vrc\n", rc);
724 return 1;
725 }
726 u64Start = RTTimeNanoTS();
727 rc = Item01Load(NULL, pSSM, u32Version);
728 if (VBOX_FAILURE(rc))
729 {
730 RTPrintf("Item01Load #1 -> %Vrc\n", rc);
731 return 1;
732 }
733 u64Elapsed = RTTimeNanoTS() - u64Start;
734 RTPrintf("tstSSM: Loaded 1st item in %RI64 ns\n", u64Elapsed);
735
736 /* 3st unit */
737 u32Version = 0xbadc0ded;
738 rc = SSMR3Seek(pSSM, "SSM Testcase Data Item no.3 (big mem)", 123, &u32Version);
739 if (VBOX_FAILURE(rc))
740 {
741 RTPrintf("SSMR3Seek #3 unit 1 -> %Vrc\n", rc);
742 return 1;
743 }
744 u64Start = RTTimeNanoTS();
745 rc = Item03Load(NULL, pSSM, u32Version);
746 if (VBOX_FAILURE(rc))
747 {
748 RTPrintf("Item01Load #3 -> %Vrc\n", rc);
749 return 1;
750 }
751 u64Elapsed = RTTimeNanoTS() - u64Start;
752 RTPrintf("tstSSM: Loaded 3rd item in %RI64 ns\n", u64Elapsed);
753
754 /* close */
755 rc = SSMR3Close(pSSM);
756 if (VBOX_FAILURE(rc))
757 {
758 RTPrintf("SSMR3Close #1 -> %Vrc\n", rc);
759 return 1;
760 }
761
762 RTPrintf("tstSSM: SUCCESS\n");
763 return 0;
764}
765
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