← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/virtualbox-ose/gutsy

« back to all changes in this revision

Viewing changes to src/VBox/VMM/testcase/tstSSM.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-09-08 16:44:58 UTC
  • Revision ID: james.westby@ubuntu.com-20070908164458-wao29470vqtr8ksy
Tags: upstream-1.5.0-dfsg2
Import upstream version 1.5.0-dfsg2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/VMM/testcase/tstSSM.cpp
 
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
 
 
36
const uint8_t gabPage[PAGE_SIZE] = {0};
 
37
 
 
38
const char gachMem1[] = "sdfg\1asdfa\177hjkl;sdfghjkl;dfghjkl;dfghjkl;\0\0asdf;kjasdf;lkjasd;flkjasd;lfkjasd\0;lfk";
 
39
 
 
40
uint8_t gabBigMem[8*1024*1024];
 
41
 
 
42
/** initializes gabBigMem with some non zero stuff. */
 
43
void 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
 */
 
74
DECLCALLBACK(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
 */
 
156
DECLCALLBACK(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
 */
 
243
DECLCALLBACK(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
 */
 
304
DECLCALLBACK(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
 */
 
363
DECLCALLBACK(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
 */
 
410
DECLCALLBACK(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
 */
 
465
DECLCALLBACK(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
 */
 
508
DECLCALLBACK(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
 
 
552
int 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