VirtualBox

source: vbox/trunk/src/VBox/VMM/SSM.cpp@ 7072

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

Make our devices use the RTGCPHYS32 type & backed out the alignment changes
Added SSMR3PutGCPhys32 & SSMR3GetGCPhys32
Removed obsolete VBOX types
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 101.7 KB
Line 
1/* $Id: SSM.cpp 7072 2008-02-21 14:06:23Z vboxsync $ */
2/** @file
3 * SSM - Saved State Manager.
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 (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
19/** @page pg_ssm SSM - The Saved State Manager
20 *
21 * The Saved State Manager (SSM) implements facilities for saving and loading
22 * a VM state in a structural manner using callbacks for each collection of
23 * data which needs saving.
24 *
25 * At init time each of the VM components will register data entities which
26 * they need to save and restore. Each entity have a unique name (ascii) and
27 * a set of callbacks associated with it. The name will be used to identify
28 * the entity during restore. The callbacks are for the two operations, save
29 * and restore. There are three callbacks for each of the two - a prepare,
30 * a execute and a what-now.
31 *
32 * The SSM provides a number of APIs for encoding and decoding the data.
33 */
34
35
36/*******************************************************************************
37* Header Files *
38*******************************************************************************/
39#define LOG_GROUP LOG_GROUP_SSM
40#include <VBox/ssm.h>
41#include <VBox/dbgf.h>
42#include <VBox/mm.h>
43#include "SSMInternal.h"
44#include <VBox/vm.h>
45#include <VBox/err.h>
46#include <VBox/log.h>
47
48#include <iprt/assert.h>
49#include <iprt/file.h>
50#include <iprt/alloc.h>
51#include <iprt/uuid.h>
52#include <iprt/zip.h>
53#include <iprt/crc32.h>
54#include <iprt/thread.h>
55#include <iprt/string.h>
56
57
58
59/*******************************************************************************
60* Defined Constants And Macros *
61*******************************************************************************/
62/** Start structure magic. (Isacc Asimov) */
63#define SSMR3STRUCT_BEGIN 0x19200102
64/** End structure magic. (Isacc Asimov) */
65#define SSMR3STRUCT_END 0x19920406
66
67
68/*******************************************************************************
69* Structures and Typedefs *
70*******************************************************************************/
71
72typedef enum SSMSTATE
73{
74 SSMSTATE_SAVE_PREP = 1,
75 SSMSTATE_SAVE_EXEC,
76 SSMSTATE_SAVE_DONE,
77 SSMSTATE_LOAD_PREP,
78 SSMSTATE_LOAD_EXEC,
79 SSMSTATE_LOAD_DONE,
80 SSMSTATE_OPEN_READ
81} SSMSTATE;
82
83
84/**
85 * Handle structure.
86 */
87typedef struct SSMHANDLE
88{
89 /** The file handle. */
90 RTFILE File;
91 /** The VM handle. */
92 PVM pVM;
93 /** The size of the file header.
94 * Because the file header was incorrectly aligned there we've ended up with
95 * differences between the 64-bit and 32-bit file header. */
96 size_t cbFileHdr;
97 /** The current operation. */
98 SSMSTATE enmOp;
99 /** What to do after save completes. (move the enum) */
100 SSMAFTER enmAfter;
101 /** The current rc of the save operation. */
102 int rc;
103 /** The compressor of the current data unit. */
104 PRTZIPCOMP pZipComp;
105 /** The decompressor of the current data unit. */
106 PRTZIPDECOMP pZipDecomp;
107 /** Number of bytes left in the current data unit. */
108 uint64_t cbUnitLeft;
109
110 /** Pointer to the progress callback function. */
111 PFNVMPROGRESS pfnProgress;
112 /** User specified arguemnt to the callback function. */
113 void *pvUser;
114 /** Next completion percentage. (corresponds to offEstProgress) */
115 unsigned uPercent;
116 /** The position of the next progress callback in the estimated file. */
117 uint64_t offEstProgress;
118 /** The estimated total byte count.
119 * (Only valid after the prep.) */
120 uint64_t cbEstTotal;
121 /** Current position in the estimated file. */
122 uint64_t offEst;
123 /** End of current unit in the estimated file. */
124 uint64_t offEstUnitEnd;
125 /** the amount of % we reserve for the 'prepare' phase */
126 unsigned uPercentPrepare;
127 /** the amount of % we reserve for the 'done' stage */
128 unsigned uPercentDone;
129
130} SSMHANDLE;
131
132
133/**
134 * Header of the saved state file.
135 */
136typedef struct SSMFILEHDR
137{
138 /** Magic string which identifies this file as a version of VBox saved state file format. */
139 char achMagic[32];
140 /** The size of this file. Used to check
141 * whether the save completed and that things are fine otherwise. */
142 uint64_t cbFile;
143 /** File checksum. The actual calculation skips past the u32CRC field. */
144 uint32_t u32CRC;
145 /** Padding. */
146 uint32_t u32Reserved;
147 /** The machine UUID. (Ignored if NIL.) */
148 RTUUID MachineUuid;
149} SSMFILEHDR, *PSSMFILEHDR;
150AssertCompileSize(SSMFILEHDR, 64);
151
152
153/**
154 * The x86 edition of the 1.0 header.
155 */
156#pragma pack(1) /* darn, MachineUuid got missaligned! */
157typedef struct SSMFILEHDRV10X86
158{
159 /** Magic string which identifies this file as a version of VBox saved state file format. */
160 char achMagic[32];
161 /** The size of this file. Used to check
162 * whether the save completed and that things are fine otherwise. */
163 uint64_t cbFile;
164 /** File checksum. The actual calculation skips past the u32CRC field. */
165 uint32_t u32CRC;
166 /** The machine UUID. (Ignored if NIL.) */
167 RTUUID MachineUuid;
168} SSMFILEHDRV10X86, *PSSMFILEHDRV10X86;
169#pragma pack()
170
171/**
172 * The amd64 edition of the 1.0 header.
173 */
174typedef SSMFILEHDR SSMFILEHDRV10AMD64, *PSSMFILEHDRV10AMD64;
175
176/** Saved state file magic base string. */
177#define SSMFILEHDR_MAGIC_BASE "\177VirtualBox SavedState "
178/** Saved state file v1.0 magic. */
179#define SSMFILEHDR_MAGIC_V1_0 "\177VirtualBox SavedState V1.0\n"
180/** Saved state file v1.1 magic. */
181#define SSMFILEHDR_MAGIC_V1_1 "\177VirtualBox SavedState V1.1\n"
182
183
184
185
186/**
187 * Data unit header.
188 */
189typedef struct SSMFILEUNITHDR
190{
191 /** Magic. */
192 char achMagic[8];
193 /** Number of bytes in this data unit including the header. */
194 uint64_t cbUnit;
195 /** Data version. */
196 uint32_t u32Version;
197 /** Instance number. */
198 uint32_t u32Instance;
199 /** Size of the data unit name including the terminator. (bytes) */
200 uint32_t cchName;
201 /** Data unit name. */
202 char szName[1];
203} SSMFILEUNITHDR, *PSSMFILEUNITHDR;
204
205/** Data unit magic. */
206#define SSMFILEUNITHDR_MAGIC "\nUnit\n"
207/** Data end marker magic. */
208#define SSMFILEUNITHDR_END "\nTheEnd"
209
210
211
212/*******************************************************************************
213* Internal Functions *
214*******************************************************************************/
215static int smmr3Register(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, PSSMUNIT *ppUnit);
216static int ssmr3CalcChecksum(RTFILE File, uint64_t cbFile, uint32_t *pu32CRC);
217static void ssmR3Progress(PSSMHANDLE pSSM, uint64_t cbAdvance);
218static int ssmr3Validate(RTFILE File, PSSMFILEHDR pHdr, size_t *pcbFileHdr);
219static PSSMUNIT ssmr3Find(PVM pVM, const char *pszName, uint32_t u32Instance);
220static int ssmr3WriteFinish(PSSMHANDLE pSSM);
221static int ssmr3Write(PSSMHANDLE pSSM, const void *pvBuf, size_t cbBuf);
222static DECLCALLBACK(int) ssmr3WriteOut(void *pvSSM, const void *pvBuf, size_t cbBuf);
223static void ssmr3ReadFinish(PSSMHANDLE pSSM);
224static int ssmr3Read(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf);
225static DECLCALLBACK(int) ssmr3ReadIn(void *pvSSM, void *pvBuf, size_t cbBuf, size_t *pcbRead);
226
227
228/**
229 * Internal registration worker.
230 *
231 * @returns VBox status code.
232 * @param pVM The VM handle.
233 * @param pszName Data unit name.
234 * @param u32Instance The instance id.
235 * @param u32Version The data unit version.
236 * @param cbGuess The guessed data unit size.
237 * @param ppUnit Where to store the insterted unit node.
238 * Caller must fill in the missing details.
239 */
240static int smmr3Register(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, PSSMUNIT *ppUnit)
241{
242 /*
243 * Walk to the end of the list checking for duplicates as we go.
244 */
245 size_t cchName = strlen(pszName);
246 PSSMUNIT pUnitPrev = NULL;
247 PSSMUNIT pUnit = pVM->ssm.s.pHead;
248 while (pUnit)
249 {
250 if ( pUnit->u32Instance == u32Instance
251 && pUnit->cchName == cchName
252 && !memcmp(pUnit->szName, pszName, cchName))
253 {
254 AssertMsgFailed(("Duplicate registration %s\n", pszName));
255 return VERR_SSM_UNIT_EXISTS;
256 }
257 /* next */
258 pUnitPrev = pUnit;
259 pUnit = pUnit->pNext;
260 }
261
262 /*
263 * Allocate new node.
264 */
265 pUnit = (PSSMUNIT)MMR3HeapAllocZ(pVM, MM_TAG_SSM, RT_OFFSETOF(SSMUNIT, szName[cchName + 1]));
266 if (!pUnit)
267 return VERR_NO_MEMORY;
268
269 /*
270 * Fill in (some) data. (Stuff is zero'ed.)
271 */
272 pUnit->u32Version = u32Version;
273 pUnit->u32Instance = u32Instance;
274 pUnit->cbGuess = cbGuess;
275 pUnit->cchName = cchName;
276 memcpy(pUnit->szName, pszName, cchName);
277
278 /*
279 * Insert
280 */
281 if (pUnitPrev)
282 pUnitPrev->pNext = pUnit;
283 else
284 pVM->ssm.s.pHead = pUnit;
285
286 *ppUnit = pUnit;
287 return VINF_SUCCESS;
288}
289
290
291/**
292 * Register a PDM Devices data unit.
293 *
294 * @returns VBox status.
295 * @param pVM The VM handle.
296 * @param pDevIns Device instance.
297 * @param pszName Data unit name.
298 * @param u32Instance The instance identifier of the data unit.
299 * This must together with the name be unique.
300 * @param u32Version Data layout version number.
301 * @param cbGuess The approximate amount of data in the unit.
302 * Only for progress indicators.
303 * @param pfnSavePrep Prepare save callback, optional.
304 * @param pfnSaveExec Execute save callback, optional.
305 * @param pfnSaveDone Done save callback, optional.
306 * @param pfnLoadPrep Prepare load callback, optional.
307 * @param pfnLoadExec Execute load callback, optional.
308 * @param pfnLoadDone Done load callback, optional.
309 */
310SSMR3DECL(int) SSMR3Register(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
311 PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
312 PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
313{
314 PSSMUNIT pUnit;
315 int rc = smmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);
316 if (VBOX_SUCCESS(rc))
317 {
318 pUnit->enmType = SSMUNITTYPE_DEV;
319 pUnit->u.Dev.pfnSavePrep = pfnSavePrep;
320 pUnit->u.Dev.pfnSaveExec = pfnSaveExec;
321 pUnit->u.Dev.pfnSaveDone = pfnSaveDone;
322 pUnit->u.Dev.pfnLoadPrep = pfnLoadPrep;
323 pUnit->u.Dev.pfnLoadExec = pfnLoadExec;
324 pUnit->u.Dev.pfnLoadDone = pfnLoadDone;
325 pUnit->u.Dev.pDevIns = pDevIns;
326 }
327 return rc;
328}
329
330
331/**
332 * Register a PDM driver data unit.
333 *
334 * @returns VBox status.
335 * @param pVM The VM handle.
336 * @param pDrvIns Driver instance.
337 * @param pszName Data unit name.
338 * @param u32Instance The instance identifier of the data unit.
339 * This must together with the name be unique.
340 * @param u32Version Data layout version number.
341 * @param cbGuess The approximate amount of data in the unit.
342 * Only for progress indicators.
343 * @param pfnSavePrep Prepare save callback, optional.
344 * @param pfnSaveExec Execute save callback, optional.
345 * @param pfnSaveDone Done save callback, optional.
346 * @param pfnLoadPrep Prepare load callback, optional.
347 * @param pfnLoadExec Execute load callback, optional.
348 * @param pfnLoadDone Done load callback, optional.
349 */
350SSMR3DECL(int) SSMR3RegisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
351 PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
352 PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone)
353{
354 PSSMUNIT pUnit;
355 int rc = smmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);
356 if (VBOX_SUCCESS(rc))
357 {
358 pUnit->enmType = SSMUNITTYPE_DRV;
359 pUnit->u.Drv.pfnSavePrep = pfnSavePrep;
360 pUnit->u.Drv.pfnSaveExec = pfnSaveExec;
361 pUnit->u.Drv.pfnSaveDone = pfnSaveDone;
362 pUnit->u.Drv.pfnLoadPrep = pfnLoadPrep;
363 pUnit->u.Drv.pfnLoadExec = pfnLoadExec;
364 pUnit->u.Drv.pfnLoadDone = pfnLoadDone;
365 pUnit->u.Drv.pDrvIns = pDrvIns;
366 }
367 return rc;
368}
369
370
371/**
372 * Register a internal data unit.
373 *
374 * @returns VBox status.
375 * @param pVM The VM handle.
376 * @param pszName Data unit name.
377 * @param u32Instance The instance identifier of the data unit.
378 * This must together with the name be unique.
379 * @param u32Version Data layout version number.
380 * @param cbGuess The approximate amount of data in the unit.
381 * Only for progress indicators.
382 * @param pfnSavePrep Prepare save callback, optional.
383 * @param pfnSaveExec Execute save callback, optional.
384 * @param pfnSaveDone Done save callback, optional.
385 * @param pfnLoadPrep Prepare load callback, optional.
386 * @param pfnLoadExec Execute load callback, optional.
387 * @param pfnLoadDone Done load callback, optional.
388 */
389SSMR3DECL(int) SSMR3RegisterInternal(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
390 PFNSSMINTSAVEPREP pfnSavePrep, PFNSSMINTSAVEEXEC pfnSaveExec, PFNSSMINTSAVEDONE pfnSaveDone,
391 PFNSSMINTLOADPREP pfnLoadPrep, PFNSSMINTLOADEXEC pfnLoadExec, PFNSSMINTLOADDONE pfnLoadDone)
392{
393 PSSMUNIT pUnit;
394 int rc = smmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);
395 if (VBOX_SUCCESS(rc))
396 {
397 pUnit->enmType = SSMUNITTYPE_INTERNAL;
398 pUnit->u.Internal.pfnSavePrep = pfnSavePrep;
399 pUnit->u.Internal.pfnSaveExec = pfnSaveExec;
400 pUnit->u.Internal.pfnSaveDone = pfnSaveDone;
401 pUnit->u.Internal.pfnLoadPrep = pfnLoadPrep;
402 pUnit->u.Internal.pfnLoadExec = pfnLoadExec;
403 pUnit->u.Internal.pfnLoadDone = pfnLoadDone;
404 }
405 return rc;
406}
407
408
409/**
410 * Register an external data unit.
411 *
412 * @returns VBox status.
413 * @param pVM The VM handle.
414 * @param pszName Data unit name.
415 * @param u32Instance The instance identifier of the data unit.
416 * This must together with the name be unique.
417 * @param u32Version Data layout version number.
418 * @param cbGuess The approximate amount of data in the unit.
419 * Only for progress indicators.
420 * @param pfnSavePrep Prepare save callback, optional.
421 * @param pfnSaveExec Execute save callback, optional.
422 * @param pfnSaveDone Done save callback, optional.
423 * @param pfnLoadPrep Prepare load callback, optional.
424 * @param pfnLoadExec Execute load callback, optional.
425 * @param pfnLoadDone Done load callback, optional.
426 * @param pvUser User argument.
427 */
428SSMR3DECL(int) SSMR3RegisterExternal(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
429 PFNSSMEXTSAVEPREP pfnSavePrep, PFNSSMEXTSAVEEXEC pfnSaveExec, PFNSSMEXTSAVEDONE pfnSaveDone,
430 PFNSSMEXTLOADPREP pfnLoadPrep, PFNSSMEXTLOADEXEC pfnLoadExec, PFNSSMEXTLOADDONE pfnLoadDone, void *pvUser)
431{
432 PSSMUNIT pUnit;
433 int rc = smmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);
434 if (VBOX_SUCCESS(rc))
435 {
436 pUnit->enmType = SSMUNITTYPE_EXTERNAL;
437 pUnit->u.External.pfnSavePrep = pfnSavePrep;
438 pUnit->u.External.pfnSaveExec = pfnSaveExec;
439 pUnit->u.External.pfnSaveDone = pfnSaveDone;
440 pUnit->u.External.pfnLoadPrep = pfnLoadPrep;
441 pUnit->u.External.pfnLoadExec = pfnLoadExec;
442 pUnit->u.External.pfnLoadDone = pfnLoadDone;
443 pUnit->u.External.pvUser = pvUser;
444 }
445 return rc;
446}
447
448
449/**
450 * Deregister one or more PDM Device data units.
451 *
452 * @returns VBox status.
453 * @param pVM The VM handle.
454 * @param pDevIns Device instance.
455 * @param pszName Data unit name.
456 * Use NULL to deregister all data units for that device instance.
457 * @param u32Instance The instance identifier of the data unit.
458 * This must together with the name be unique.
459 * @remark Only for dynmaic data units and dynamic unloaded modules.
460 */
461SSMR3DECL(int) SSMR3Deregister(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance)
462{
463 /*
464 * Validate input.
465 */
466 if (!pDevIns)
467 {
468 AssertMsgFailed(("pDevIns is NULL!\n"));
469 return VERR_INVALID_PARAMETER;
470 }
471
472 /*
473 * Search the list.
474 */
475 size_t cchName = pszName ? strlen(pszName) : 0;
476 int rc = pszName ? VERR_SSM_UNIT_NOT_FOUND : VINF_SUCCESS;
477 PSSMUNIT pUnitPrev = NULL;
478 PSSMUNIT pUnit = pVM->ssm.s.pHead;
479 while (pUnit)
480 {
481 if ( pUnit->enmType == SSMUNITTYPE_DEV
482 && ( !pszName
483 || ( pUnit->cchName == cchName
484 && !memcmp(pUnit->szName, pszName, cchName)))
485 && pUnit->u32Instance == u32Instance
486 )
487 {
488 if (pUnit->u.Dev.pDevIns == pDevIns)
489 {
490 /*
491 * Unlink it, advance pointer, and free the node.
492 */
493 PSSMUNIT pFree = pUnit;
494 pUnit = pUnit->pNext;
495 if (pUnitPrev)
496 pUnitPrev->pNext = pUnit;
497 else
498 pVM->ssm.s.pHead = pUnit;
499 Log(("SSM: Removed data unit '%s' (pdm dev).\n", pFree->szName));
500 MMR3HeapFree(pFree);
501 if (pszName)
502 return VINF_SUCCESS;
503 rc = VINF_SUCCESS;
504 continue;
505 }
506 else if (pszName)
507 {
508 AssertMsgFailed(("Caller is not owner! Owner=%p Caller=%p %s\n",
509 pUnit->u.Dev.pDevIns, pDevIns, pszName));
510 return VERR_SSM_UNIT_NOT_OWNER;
511 }
512 }
513
514 /* next */
515 pUnitPrev = pUnit;
516 pUnit = pUnit->pNext;
517 }
518
519 return rc;
520}
521
522
523/**
524 * Deregister one ore more PDM Driver data units.
525 *
526 * @returns VBox status.
527 * @param pVM The VM handle.
528 * @param pDrvIns Driver instance.
529 * @param pszName Data unit name.
530 * Use NULL to deregister all data units for that driver instance.
531 * @param u32Instance The instance identifier of the data unit.
532 * This must together with the name be unique. Ignored if pszName is NULL.
533 * @remark Only for dynmaic data units and dynamic unloaded modules.
534 */
535SSMR3DECL(int) SSMR3DeregisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance)
536{
537 /*
538 * Validate input.
539 */
540 if (!pDrvIns)
541 {
542 AssertMsgFailed(("pDrvIns is NULL!\n"));
543 return VERR_INVALID_PARAMETER;
544 }
545
546 /*
547 * Search the list.
548 */
549 size_t cchName = pszName ? strlen(pszName) : 0;
550 int rc = pszName ? VERR_SSM_UNIT_NOT_FOUND : VINF_SUCCESS;
551 PSSMUNIT pUnitPrev = NULL;
552 PSSMUNIT pUnit = pVM->ssm.s.pHead;
553 while (pUnit)
554 {
555 if ( pUnit->enmType == SSMUNITTYPE_DRV
556 && ( !pszName
557 || ( pUnit->cchName == cchName
558 && !memcmp(pUnit->szName, pszName, cchName)
559 && pUnit->u32Instance == u32Instance))
560 )
561 {
562 if (pUnit->u.Drv.pDrvIns == pDrvIns)
563 {
564 /*
565 * Unlink it, advance pointer, and free the node.
566 */
567 PSSMUNIT pFree = pUnit;
568 pUnit = pUnit->pNext;
569 if (pUnitPrev)
570 pUnitPrev->pNext = pUnit;
571 else
572 pVM->ssm.s.pHead = pUnit;
573 Log(("SSM: Removed data unit '%s' (pdm drv).\n", pFree->szName));
574 MMR3HeapFree(pFree);
575 if (pszName)
576 return VINF_SUCCESS;
577 rc = VINF_SUCCESS;
578 continue;
579 }
580 else if (pszName)
581 {
582 AssertMsgFailed(("Caller is not owner! Owner=%p Caller=%p %s\n",
583 pUnit->u.Drv.pDrvIns, pDrvIns, pszName));
584 return VERR_SSM_UNIT_NOT_OWNER;
585 }
586 }
587
588 /* next */
589 pUnitPrev = pUnit;
590 pUnit = pUnit->pNext;
591 }
592
593 return rc;
594}
595
596/**
597 * Deregister a data unit.
598 *
599 * @returns VBox status.
600 * @param pVM The VM handle.
601 * @param enmType Unit type
602 * @param pszName Data unit name.
603 * @remark Only for dynmaic data units.
604 */
605static int ssmR3DeregisterByNameAndType(PVM pVM, const char *pszName, SSMUNITTYPE enmType)
606{
607 /*
608 * Validate input.
609 */
610 if (!pszName)
611 {
612 AssertMsgFailed(("pszName is NULL!\n"));
613 return VERR_INVALID_PARAMETER;
614 }
615
616 /*
617 * Search the list.
618 */
619 size_t cchName = strlen(pszName);
620 int rc = VERR_SSM_UNIT_NOT_FOUND;
621 PSSMUNIT pUnitPrev = NULL;
622 PSSMUNIT pUnit = pVM->ssm.s.pHead;
623 while (pUnit)
624 {
625 if ( pUnit->enmType == enmType
626 && pUnit->cchName == cchName
627 && !memcmp(pUnit->szName, pszName, cchName))
628 {
629 /*
630 * Unlink it, advance pointer, and free the node.
631 */
632 PSSMUNIT pFree = pUnit;
633 pUnit = pUnit->pNext;
634 if (pUnitPrev)
635 pUnitPrev->pNext = pUnit;
636 else
637 pVM->ssm.s.pHead = pUnit;
638 Log(("SSM: Removed data unit '%s' (type=%d).\n", pFree->szName, enmType));
639 MMR3HeapFree(pFree);
640 return VINF_SUCCESS;
641 }
642
643 /* next */
644 pUnitPrev = pUnit;
645 pUnit = pUnit->pNext;
646 }
647
648 return rc;
649}
650
651
652/**
653 * Deregister an internal data unit.
654 *
655 * @returns VBox status.
656 * @param pVM The VM handle.
657 * @param pszName Data unit name.
658 * @remark Only for dynmaic data units.
659 */
660SSMR3DECL(int) SSMR3DeregisterInternal(PVM pVM, const char *pszName)
661{
662 return ssmR3DeregisterByNameAndType(pVM, pszName, SSMUNITTYPE_INTERNAL);
663}
664
665
666/**
667 * Deregister an external data unit.
668 *
669 * @returns VBox status.
670 * @param pVM The VM handle.
671 * @param pszName Data unit name.
672 * @remark Only for dynmaic data units.
673 */
674SSMR3DECL(int) SSMR3DeregisterExternal(PVM pVM, const char *pszName)
675{
676 return ssmR3DeregisterByNameAndType(pVM, pszName, SSMUNITTYPE_EXTERNAL);
677}
678
679
680/**
681 * Calculate the checksum of a file portion.
682 *
683 * The current implementation is a cut&past of the libkern/crc32.c file from FreeBSD.
684 *
685 * @returns VBox status.
686 * @param File Handle to the file.
687 * @param cbFile Size of the file.
688 * @param pu32CRC Where to store the calculated checksum.
689 */
690static int ssmr3CalcChecksum(RTFILE File, uint64_t cbFile, uint32_t *pu32CRC)
691{
692 /*
693 * Allocate a buffer.
694 */
695 void *pvBuf = RTMemTmpAlloc(32*1024);
696 if (!pvBuf)
697 return VERR_NO_TMP_MEMORY;
698
699 /*
700 * Loop reading and calculating CRC32.
701 */
702 int rc = VINF_SUCCESS;
703 uint32_t u32CRC = RTCrc32Start();
704 while (cbFile)
705 {
706 /* read chunk */
707 register unsigned cbToRead = 32*1024;
708 if (cbFile < 32*1024)
709 cbToRead = (unsigned)cbFile;
710 rc = RTFileRead(File, pvBuf, cbToRead, NULL);
711 if (VBOX_FAILURE(rc))
712 {
713 AssertMsgFailed(("Failed with rc=%Vrc while calculating crc.\n", rc));
714 RTMemTmpFree(pvBuf);
715 return rc;
716 }
717
718 /* update total */
719 cbFile -= cbToRead;
720
721 /* calc crc32. */
722 u32CRC = RTCrc32Process(u32CRC, pvBuf, cbToRead);
723 }
724 RTMemTmpFree(pvBuf);
725
726 /* store the calculated crc */
727 u32CRC = RTCrc32Finish(u32CRC);
728 Log(("SSM: u32CRC=0x%08x\n", u32CRC));
729 *pu32CRC = u32CRC;
730
731 return VINF_SUCCESS;
732}
733
734
735/**
736 * Works the progress calculation.
737 *
738 * @param pSSM The SSM handle.
739 * @param cbAdvance Number of bytes to advance
740 */
741static void ssmR3Progress(PSSMHANDLE pSSM, uint64_t cbAdvance)
742{
743 /* Can't advance it beyond the estimated end of the unit. */
744 uint64_t cbLeft = pSSM->offEstUnitEnd - pSSM->offEst;
745 if (cbAdvance > cbLeft)
746 cbAdvance = cbLeft;
747 pSSM->offEst += cbAdvance;
748
749 /* uPercentPrepare% prepare, xx% exec, uPercentDone% done+crc */
750 while (pSSM->offEst >= pSSM->offEstProgress && pSSM->uPercent <= 100-pSSM->uPercentDone)
751 {
752 if (pSSM->pfnProgress)
753 pSSM->pfnProgress(pSSM->pVM, pSSM->uPercent, pSSM->pvUser);
754 pSSM->uPercent++;
755 pSSM->offEstProgress = (pSSM->uPercent - pSSM->uPercentPrepare) * pSSM->cbEstTotal /
756 (100-pSSM->uPercentDone-pSSM->uPercentPrepare);
757 }
758}
759
760
761/**
762 * Start VM save operation.
763 * The caller must be the emulation thread!
764 *
765 * @returns VBox status.
766 * @param pVM The VM handle.
767 * @param pszFilename Name of the file to save the state in.
768 * @param enmAfter What is planned after a successful save operation.
769 * @param pfnProgress Progress callback. Optional.
770 * @param pvUser User argument for the progress callback.
771 */
772SSMR3DECL(int) SSMR3Save(PVM pVM, const char *pszFilename, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser)
773{
774 LogFlow(("SSMR3Save: pszFilename=%p:{%s} enmAfter=%d pfnProgress=%p pvUser=%p\n", pszFilename, pszFilename, enmAfter, pfnProgress, pvUser));
775
776 /*
777 * Validate input.
778 */
779 if ( enmAfter != SSMAFTER_DESTROY
780 && enmAfter != SSMAFTER_CONTINUE)
781 {
782 AssertMsgFailed(("Invalid enmAfter=%d!\n", enmAfter));
783 return VERR_INVALID_PARAMETER;
784 }
785
786 /*
787 * Try open the file.
788 */
789 SSMHANDLE Handle = {0};
790 Handle.enmAfter = enmAfter;
791 Handle.pVM = pVM;
792 Handle.cbFileHdr = sizeof(SSMFILEHDR);
793 Handle.pfnProgress = pfnProgress;
794 Handle.pvUser = pvUser;
795 /*
796 * The 'done' part might take much time:
797 * (1) Call the SaveDone function of each module
798 * (2) Calculate the Checksum
799 * (3) RTFileClose() will probably flush the write cache
800 */
801 Handle.uPercentPrepare = 2;
802 Handle.uPercentDone = 20; /* reserve substantial time for crc-checking the image */
803 int rc = RTFileOpen(&Handle.File, pszFilename, RTFILE_O_READWRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE);
804 if (VBOX_FAILURE(rc))
805 {
806 LogRel(("SSM: Failed to create save state file '%s', rc=%Vrc.\n", pszFilename, rc));
807 return rc;
808 }
809
810 Log(("SSM: Starting state save to file '%s'...\n", pszFilename));
811
812 /*
813 * Write header.
814 */
815 SSMFILEHDR Hdr = { SSMFILEHDR_MAGIC_V1_1, 0, 0, 0 };
816 rc = RTFileWrite(Handle.File, &Hdr, sizeof(Hdr), NULL);
817 if (VBOX_SUCCESS(rc))
818 {
819 /*
820 * Clear the per unit flags.
821 */
822 PSSMUNIT pUnit;
823 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
824 pUnit->fCalled = false;
825
826 /*
827 * Do the prepare run.
828 */
829 Handle.rc = VINF_SUCCESS;
830 Handle.enmOp = SSMSTATE_SAVE_PREP;
831 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
832 {
833 switch (pUnit->enmType)
834 {
835 case SSMUNITTYPE_DEV:
836 if (pUnit->u.Dev.pfnSavePrep)
837 {
838 rc = pUnit->u.Dev.pfnSavePrep(pUnit->u.Dev.pDevIns, &Handle);
839 pUnit->fCalled = true;
840 }
841 break;
842 case SSMUNITTYPE_DRV:
843 if (pUnit->u.Drv.pfnSavePrep)
844 {
845 rc = pUnit->u.Drv.pfnSavePrep(pUnit->u.Drv.pDrvIns, &Handle);
846 pUnit->fCalled = true;
847 }
848 break;
849 case SSMUNITTYPE_INTERNAL:
850 if (pUnit->u.Internal.pfnSavePrep)
851 {
852 rc = pUnit->u.Internal.pfnSavePrep(pVM, &Handle);
853 pUnit->fCalled = true;
854 }
855 break;
856 case SSMUNITTYPE_EXTERNAL:
857 if (pUnit->u.External.pfnSavePrep)
858 {
859 rc = pUnit->u.External.pfnSavePrep(&Handle, pUnit->u.External.pvUser);
860 pUnit->fCalled = true;
861 }
862 break;
863 }
864 if (VBOX_FAILURE(rc))
865 {
866 LogRel(("SSM: Prepare save failed with rc=%Vrc for data unit '%s.\n", rc, pUnit->szName));
867 break;
868 }
869
870 Handle.cbEstTotal += pUnit->cbGuess;
871 }
872
873 /* Progress. */
874 if (pfnProgress)
875 pfnProgress(pVM, Handle.uPercentPrepare-1, pvUser);
876 Handle.uPercent = Handle.uPercentPrepare;
877
878 /*
879 * Do the execute run.
880 */
881 if (VBOX_SUCCESS(rc))
882 {
883 Handle.enmOp = SSMSTATE_SAVE_EXEC;
884 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
885 {
886 /*
887 * Estimate.
888 */
889 ssmR3Progress(&Handle, Handle.offEstUnitEnd - Handle.offEst);
890 Handle.offEstUnitEnd += pUnit->cbGuess;
891
892 /*
893 * Does this unit have a callback? If, not skip it.
894 */
895 bool fSkip;
896 switch (pUnit->enmType)
897 {
898 case SSMUNITTYPE_DEV: fSkip = pUnit->u.Dev.pfnSaveExec == NULL; break;
899 case SSMUNITTYPE_DRV: fSkip = pUnit->u.Drv.pfnSaveExec == NULL; break;
900 case SSMUNITTYPE_INTERNAL: fSkip = pUnit->u.Internal.pfnSaveExec == NULL; break;
901 case SSMUNITTYPE_EXTERNAL: fSkip = pUnit->u.External.pfnSaveExec == NULL; break;
902 default: fSkip = true; break;
903 }
904 if (fSkip)
905 {
906 pUnit->fCalled = true;
907 continue;
908 }
909
910 /*
911 * Write data unit header
912 */
913 uint64_t offHdr = RTFileTell(Handle.File);
914 SSMFILEUNITHDR UnitHdr = { SSMFILEUNITHDR_MAGIC, 0, pUnit->u32Version, pUnit->u32Instance, pUnit->cchName + 1, { '\0' } };
915 rc = RTFileWrite(Handle.File, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDR, szName[0]), NULL);
916 if (VBOX_SUCCESS(rc))
917 {
918 rc = RTFileWrite(Handle.File, &pUnit->szName[0], pUnit->cchName + 1, NULL);
919 if (VBOX_SUCCESS(rc))
920 {
921 /*
922 * Call the execute handler.
923 */
924 switch (pUnit->enmType)
925 {
926 case SSMUNITTYPE_DEV:
927 rc = pUnit->u.Dev.pfnSaveExec(pUnit->u.Dev.pDevIns, &Handle);
928 break;
929 case SSMUNITTYPE_DRV:
930 rc = pUnit->u.Drv.pfnSaveExec(pUnit->u.Drv.pDrvIns, &Handle);
931 break;
932 case SSMUNITTYPE_INTERNAL:
933 rc = pUnit->u.Internal.pfnSaveExec(pVM, &Handle);
934 break;
935 case SSMUNITTYPE_EXTERNAL:
936 pUnit->u.External.pfnSaveExec(&Handle, pUnit->u.External.pvUser);
937 rc = Handle.rc;
938 break;
939 }
940 pUnit->fCalled = true;
941 if (VBOX_FAILURE(Handle.rc) && VBOX_SUCCESS(rc))
942 rc = Handle.rc;
943 if (VBOX_SUCCESS(rc))
944 {
945 /*
946 * Flush buffer / end compression stream.
947 */
948 if (Handle.pZipComp)
949 rc = ssmr3WriteFinish(&Handle);
950 if (VBOX_SUCCESS(rc))
951 {
952 /*
953 * Update header with correct length.
954 */
955 uint64_t offEnd = RTFileTell(Handle.File);
956 rc = RTFileSeek(Handle.File, offHdr, RTFILE_SEEK_BEGIN, NULL);
957 if (VBOX_SUCCESS(rc))
958 {
959 UnitHdr.cbUnit = offEnd - offHdr;
960 rc = RTFileWrite(Handle.File, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDR, szName[0]), NULL);
961 if (VBOX_SUCCESS(rc))
962 {
963 rc = RTFileSeek(Handle.File, offEnd, RTFILE_SEEK_BEGIN, NULL);
964 if (VBOX_SUCCESS(rc))
965 Log(("SSM: Data unit: offset %#9llx size %9lld '%s'\n", offHdr, UnitHdr.cbUnit, pUnit->szName));
966 }
967 }
968 }
969 else
970 {
971 LogRel(("SSM: Failed ending compression stream. rc=%Vrc\n", rc));
972 break;
973 }
974 }
975 else
976 {
977 LogRel(("SSM: Execute save failed with rc=%Vrc for data unit '%s.\n", rc, pUnit->szName));
978 break;
979 }
980 }
981 }
982 if (VBOX_FAILURE(rc))
983 {
984 LogRel(("SSM: Failed to write unit header. rc=%Vrc\n", rc));
985 break;
986 }
987 } /* for each unit */
988
989 /* finish the progress. */
990 if (VBOX_SUCCESS(rc))
991 ssmR3Progress(&Handle, Handle.offEstUnitEnd - Handle.offEst);
992 }
993 /* (progress should be pending 99% now) */
994 AssertMsg(VBOX_FAILURE(rc) || Handle.uPercent == (101-Handle.uPercentDone), ("%d\n", Handle.uPercent));
995
996 /*
997 * Do the done run.
998 */
999 Handle.rc = rc;
1000 Handle.enmOp = SSMSTATE_SAVE_DONE;
1001 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
1002 {
1003 switch (pUnit->enmType)
1004 {
1005 case SSMUNITTYPE_DEV:
1006 if ( pUnit->u.Dev.pfnSaveDone
1007 && ( pUnit->fCalled
1008 || (!pUnit->u.Dev.pfnSavePrep && !pUnit->u.Dev.pfnSaveExec)))
1009 rc = pUnit->u.Dev.pfnSaveDone(pUnit->u.Dev.pDevIns, &Handle);
1010 break;
1011 case SSMUNITTYPE_DRV:
1012 if ( pUnit->u.Drv.pfnSaveDone
1013 && ( pUnit->fCalled
1014 || (!pUnit->u.Drv.pfnSavePrep && !pUnit->u.Drv.pfnSaveExec)))
1015 rc = pUnit->u.Drv.pfnSaveDone(pUnit->u.Drv.pDrvIns, &Handle);
1016 break;
1017 case SSMUNITTYPE_INTERNAL:
1018 if ( pUnit->u.Internal.pfnSaveDone
1019 && ( pUnit->fCalled
1020 || (!pUnit->u.Internal.pfnSavePrep && !pUnit->u.Internal.pfnSaveExec)))
1021 rc = pUnit->u.Internal.pfnSaveDone(pVM, &Handle);
1022 break;
1023 case SSMUNITTYPE_EXTERNAL:
1024 if ( pUnit->u.External.pfnSaveDone
1025 && ( pUnit->fCalled
1026 || (!pUnit->u.External.pfnSavePrep && !pUnit->u.External.pfnSaveExec)))
1027 rc = pUnit->u.External.pfnSaveDone(&Handle, pUnit->u.External.pvUser);
1028 break;
1029 }
1030 if (VBOX_FAILURE(rc))
1031 {
1032 LogRel(("SSM: Done save failed with rc=%Vrc for data unit '%s.\n", rc, pUnit->szName));
1033 if (VBOX_SUCCESS(Handle.rc))
1034 Handle.rc = rc;
1035 }
1036 }
1037 rc = Handle.rc;
1038
1039 /*
1040 * Finalize the file if successfully saved.
1041 */
1042 if (VBOX_SUCCESS(rc))
1043 {
1044 /* end record */
1045 SSMFILEUNITHDR UnitHdr = { SSMFILEUNITHDR_END, RT_OFFSETOF(SSMFILEUNITHDR, szName[0]), 0, '\0'};
1046 rc = RTFileWrite(Handle.File, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDR, szName[0]), NULL);
1047 if (VBOX_SUCCESS(rc))
1048 {
1049 /* get size */
1050 Hdr.cbFile = RTFileTell(Handle.File);
1051 /* calc checksum */
1052 rc = RTFileSeek(Handle.File, RT_OFFSETOF(SSMFILEHDR, u32CRC) + sizeof(Hdr.u32CRC), RTFILE_SEEK_BEGIN, NULL);
1053 if (VBOX_SUCCESS(rc))
1054 rc = ssmr3CalcChecksum(Handle.File, Hdr.cbFile - sizeof(Hdr), &Hdr.u32CRC);
1055 if (VBOX_SUCCESS(rc))
1056 {
1057 if (pfnProgress)
1058 pfnProgress(pVM, 90, pvUser);
1059
1060 /*
1061 * Write the update the header to the file.
1062 */
1063 rc = RTFileSeek(Handle.File, 0, RTFILE_SEEK_BEGIN, NULL);
1064 if (VBOX_SUCCESS(rc))
1065 rc = RTFileWrite(Handle.File, &Hdr, sizeof(Hdr), NULL);
1066 if (VBOX_SUCCESS(rc))
1067 {
1068 rc = RTFileClose(Handle.File);
1069 AssertRC(rc);
1070 if (pfnProgress)
1071 pfnProgress(pVM, 100, pvUser);
1072 Log(("SSM: Successfully saved the vm state to '%s'.\n", pszFilename));
1073 Log(("\n\n\n"));
1074 DBGFR3InfoLog(pVM, "cpum", "verbose");
1075 DBGFR3InfoLog(pVM, "timers", NULL);
1076 DBGFR3InfoLog(pVM, "activetimers", NULL);
1077 DBGFR3InfoLog(pVM, "ioport", NULL);
1078 DBGFR3InfoLog(pVM, "mmio", NULL);
1079 DBGFR3InfoLog(pVM, "phys", NULL);
1080 Log(("\n\n\n"));
1081 return VINF_SUCCESS;
1082 }
1083
1084 }
1085 }
1086 LogRel(("SSM: Failed to finalize state file! rc=%Vrc\n", pszFilename));
1087 }
1088 }
1089
1090 /*
1091 * Delete the file on failure and destroy any compressors.
1092 */
1093 int rc2 = RTFileClose(Handle.File);
1094 AssertRC(rc2);
1095 rc2 = RTFileDelete(pszFilename);
1096 AssertRC(rc2);
1097 if (Handle.pZipComp)
1098 RTZipCompDestroy(Handle.pZipComp);
1099
1100 return rc;
1101}
1102
1103
1104/**
1105 * Validates the integrity of a saved state file.
1106 *
1107 * @returns VBox status.
1108 * @param File File to validate.
1109 * The file position is undefined on return.
1110 * @param pHdr Where to store the file header.
1111 * @param pcbFileHdr Where to store the file header size.
1112 */
1113static int ssmr3Validate(RTFILE File, PSSMFILEHDR pHdr, size_t *pcbFileHdr)
1114{
1115 /*
1116 * Read the header.
1117 */
1118 int rc = RTFileRead(File, pHdr, sizeof(*pHdr), NULL);
1119 if (VBOX_FAILURE(rc))
1120 {
1121 Log(("SSM: Failed to read file header. rc=%Vrc\n", rc));
1122 return rc;
1123 }
1124
1125 /*
1126 * Verify the magic and make adjustments for versions differences.
1127 */
1128 if (memcmp(pHdr->achMagic, SSMFILEHDR_MAGIC_BASE, sizeof(SSMFILEHDR_MAGIC_BASE) - 1))
1129 {
1130 Log(("SSM: Not a saved state file. magic=%.*s\n", sizeof(pHdr->achMagic) - 1, pHdr->achMagic));
1131 return VERR_SSM_INTEGRITY_MAGIC;
1132 }
1133
1134 size_t offCrc32 = RT_OFFSETOF(SSMFILEHDR, u32CRC) + sizeof(pHdr->u32CRC);
1135 *pcbFileHdr = sizeof(*pHdr);
1136 if (!memcmp(pHdr->achMagic, SSMFILEHDR_MAGIC_V1_0, sizeof(SSMFILEHDR_MAGIC_V1_0)))
1137 {
1138 if (pHdr->MachineUuid.au32[3])
1139 {
1140 SSMFILEHDRV10X86 OldHdr;
1141 memcpy(&OldHdr, pHdr, sizeof(OldHdr));
1142 pHdr->cbFile = OldHdr.cbFile;
1143 pHdr->u32CRC = OldHdr.u32CRC;
1144 pHdr->u32Reserved = 0;
1145 pHdr->MachineUuid = OldHdr.MachineUuid;
1146
1147 offCrc32 = RT_OFFSETOF(SSMFILEHDRV10X86, u32CRC) + sizeof(pHdr->u32CRC);
1148 *pcbFileHdr = sizeof(OldHdr);
1149 }
1150 else
1151 {
1152 /* (It's identical, but this doesn't harm us and will continue working after future changes.) */
1153 SSMFILEHDRV10AMD64 OldHdr;
1154 memcpy(&OldHdr, pHdr, sizeof(OldHdr));
1155 pHdr->cbFile = OldHdr.cbFile;
1156 pHdr->u32CRC = OldHdr.u32CRC;
1157 pHdr->u32Reserved = 0;
1158 pHdr->MachineUuid = OldHdr.MachineUuid;
1159
1160 offCrc32 = RT_OFFSETOF(SSMFILEHDRV10AMD64, u32CRC) + sizeof(pHdr->u32CRC);
1161 *pcbFileHdr = sizeof(OldHdr);
1162 }
1163 }
1164 else if (memcmp(pHdr->achMagic, SSMFILEHDR_MAGIC_V1_1, sizeof(SSMFILEHDR_MAGIC_V1_1)))
1165 {
1166 Log(("SSM: Unknown file format version. magic=%.*s\n", sizeof(pHdr->achMagic) - 1, pHdr->achMagic));
1167 return VERR_SSM_INTEGRITY_VERSION;
1168 }
1169
1170 /*
1171 * Verify the file size.
1172 */
1173 uint64_t cbFile;
1174 rc = RTFileGetSize(File, &cbFile);
1175 if (VBOX_FAILURE(rc))
1176 {
1177 Log(("SSM: Failed to get file size. rc=%Vrc\n", rc));
1178 return rc;
1179 }
1180 if (cbFile != pHdr->cbFile)
1181 {
1182 Log(("SSM: File size mistmatch. hdr.cbFile=%lld actual %lld\n", pHdr->cbFile, cbFile));
1183 return VERR_SSM_INTEGRITY_SIZE;
1184 }
1185
1186 /*
1187 * Verify the checksum.
1188 */
1189 rc = RTFileSeek(File, offCrc32, RTFILE_SEEK_BEGIN, NULL);
1190 if (VBOX_FAILURE(rc))
1191 {
1192 Log(("SSM: Failed to seek to crc start. rc=%Vrc\n", rc));
1193 return rc;
1194 }
1195 uint32_t u32CRC;
1196 rc = ssmr3CalcChecksum(File, pHdr->cbFile - *pcbFileHdr, &u32CRC);
1197 if (VBOX_FAILURE(rc))
1198 return rc;
1199 if (u32CRC != pHdr->u32CRC)
1200 {
1201 Log(("SSM: Invalid CRC! Calculated %#08x, in header %#08x\n", u32CRC, pHdr->u32CRC));
1202 return VERR_SSM_INTEGRITY_CRC;
1203 }
1204
1205 /*
1206 * Verify Virtual Machine UUID.
1207 */
1208 RTUUID Uuid;
1209 memset(&Uuid, 0, sizeof(Uuid));
1210/** @todo get machine uuids CFGGetUuid(, &Uuid); */
1211 if ( RTUuidCompare(&pHdr->MachineUuid, &Uuid)
1212 && !RTUuidIsNull(&pHdr->MachineUuid)) /* temporary hack, allowing NULL uuids. */
1213 {
1214 Log(("SSM: The UUID of the saved state doesn't match the running VM.\n"));
1215 return VERR_SMM_INTEGRITY_MACHINE;
1216 }
1217
1218 return VINF_SUCCESS;
1219}
1220
1221
1222/**
1223 * Find a data unit by name.
1224 *
1225 * @returns Pointer to the unit.
1226 * @returns NULL if not found.
1227 * @param pVM VM handle.
1228 * @param pszName Data unit name.
1229 * @param u32Instance The data unit instance id.
1230 */
1231static PSSMUNIT ssmr3Find(PVM pVM, const char *pszName, uint32_t u32Instance)
1232{
1233 size_t cchName = strlen(pszName);
1234 PSSMUNIT pUnit = pVM->ssm.s.pHead;
1235 while ( pUnit
1236 && ( pUnit->u32Instance != u32Instance
1237 || pUnit->cchName != cchName
1238 || memcmp(pUnit->szName, pszName, cchName)))
1239 pUnit = pUnit->pNext;
1240 return pUnit;
1241}
1242
1243
1244/**
1245 * Load VM save operation.
1246 * The caller must be the emulation thread!
1247 *
1248 * @returns VBox status.
1249 * @param pVM The VM handle.
1250 * @param pszFilename Name of the file to save the state in.
1251 * @param enmAfter What is planned after a successful load operation.
1252 * Only acceptable values are SSMAFTER_RESUME and SSMAFTER_DEBUG_IT.
1253 * @param pfnProgress Progress callback. Optional.
1254 * @param pvUser User argument for the progress callback.
1255 */
1256SSMR3DECL(int) SSMR3Load(PVM pVM, const char *pszFilename, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser)
1257{
1258 LogFlow(("SSMR3Load: pszFilename=%p:{%s} enmAfter=%d pfnProgress=%p pvUser=%p\n", pszFilename, pszFilename, enmAfter, pfnProgress, pvUser));
1259
1260 /*
1261 * Validate input.
1262 */
1263 if ( enmAfter != SSMAFTER_RESUME
1264 && enmAfter != SSMAFTER_DEBUG_IT)
1265 {
1266 AssertMsgFailed(("Invalid enmAfter=%d!\n", enmAfter));
1267 return VERR_INVALID_PARAMETER;
1268 }
1269
1270 /*
1271 * Open the file.
1272 */
1273 SSMHANDLE Handle = {0};
1274 Handle.enmAfter = enmAfter;
1275 Handle.pVM = pVM;
1276 Handle.cbFileHdr = sizeof(SSMFILEHDR);
1277 Handle.pfnProgress = pfnProgress;
1278 Handle.pvUser = pvUser;
1279 Handle.uPercentPrepare = 20; /* reserve substantial time for validating the image */
1280 Handle.uPercentDone = 2;
1281 int rc = RTFileOpen(&Handle.File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
1282 if (VBOX_FAILURE(rc))
1283 {
1284 Log(("SSM: Failed to open save state file '%s', rc=%Vrc.\n", pszFilename, rc));
1285 return rc;
1286 }
1287
1288 /*
1289 * Read file header and validate it.
1290 */
1291 SSMFILEHDR Hdr;
1292 rc = ssmr3Validate(Handle.File, &Hdr, &Handle.cbFileHdr);
1293 if (VBOX_SUCCESS(rc))
1294 {
1295 /*
1296 * Clear the per unit flags.
1297 */
1298 PSSMUNIT pUnit;
1299 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
1300 pUnit->fCalled = false;
1301
1302 /*
1303 * Do the prepare run.
1304 */
1305 Handle.rc = VINF_SUCCESS;
1306 Handle.enmOp = SSMSTATE_LOAD_PREP;
1307 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
1308 {
1309 switch (pUnit->enmType)
1310 {
1311 case SSMUNITTYPE_DEV:
1312 if (pUnit->u.Dev.pfnLoadPrep)
1313 {
1314 rc = pUnit->u.Dev.pfnLoadPrep(pUnit->u.Dev.pDevIns, &Handle);
1315 pUnit->fCalled = true;
1316 }
1317 break;
1318 case SSMUNITTYPE_DRV:
1319 if (pUnit->u.Drv.pfnLoadPrep)
1320 {
1321 rc = pUnit->u.Drv.pfnLoadPrep(pUnit->u.Drv.pDrvIns, &Handle);
1322 pUnit->fCalled = true;
1323 }
1324 break;
1325 case SSMUNITTYPE_INTERNAL:
1326 if (pUnit->u.Internal.pfnLoadPrep)
1327 {
1328 rc = pUnit->u.Internal.pfnLoadPrep(pVM, &Handle);
1329 pUnit->fCalled = true;
1330 }
1331 break;
1332 case SSMUNITTYPE_EXTERNAL:
1333 if (pUnit->u.External.pfnLoadPrep)
1334 {
1335 rc = pUnit->u.External.pfnLoadPrep(&Handle, pUnit->u.External.pvUser);
1336 pUnit->fCalled = true;
1337 }
1338 break;
1339 }
1340 if (VBOX_FAILURE(rc))
1341 {
1342 LogRel(("SSM: Prepare load failed with rc=%Vrc for data unit '%s.\n", rc, pUnit->szName));
1343 break;
1344 }
1345 }
1346
1347 /* pending 2% */
1348 if (pfnProgress)
1349 pfnProgress(pVM, Handle.uPercentPrepare-1, pvUser);
1350 Handle.uPercent = Handle.uPercentPrepare;
1351 Handle.cbEstTotal = Hdr.cbFile;
1352
1353 /*
1354 * Do the execute run.
1355 */
1356 if (VBOX_SUCCESS(rc))
1357 rc = RTFileSeek(Handle.File, Handle.cbFileHdr, RTFILE_SEEK_BEGIN, NULL);
1358 if (VBOX_SUCCESS(rc))
1359 {
1360 char *pszName = NULL;
1361 size_t cchName = 0;
1362 Handle.enmOp = SSMSTATE_LOAD_EXEC;
1363 for (;;)
1364 {
1365 /*
1366 * Save the current file position and read the data unit header.
1367 */
1368 uint64_t offUnit = RTFileTell(Handle.File);
1369 SSMFILEUNITHDR UnitHdr;
1370 rc = RTFileRead(Handle.File, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDR, szName), NULL);
1371 if (VBOX_SUCCESS(rc))
1372 {
1373 /*
1374 * Check the magic and see if it's valid and whether it is a end header or not.
1375 */
1376 if (memcmp(&UnitHdr.achMagic[0], SSMFILEUNITHDR_MAGIC, sizeof(SSMFILEUNITHDR_MAGIC)))
1377 {
1378 if (!memcmp(&UnitHdr.achMagic[0], SSMFILEUNITHDR_END, sizeof(SSMFILEUNITHDR_END)))
1379 {
1380 Log(("SSM: EndOfFile: offset %#9llx size %9d\n", offUnit, UnitHdr.cbUnit));
1381 /* Complete the progress bar (pending 99% afterwards). */
1382 Handle.offEstUnitEnd = Handle.cbEstTotal;
1383 ssmR3Progress(&Handle, Handle.cbEstTotal - Handle.offEst);
1384 break;
1385 }
1386 LogRel(("SSM: Invalid unit magic at offset %#llx (%lld), '%.*s'!\n",
1387 offUnit, offUnit, sizeof(UnitHdr.achMagic) - 1, &UnitHdr.achMagic[0]));
1388 rc = VERR_SSM_INTEGRITY_UNIT_MAGIC;
1389 break;
1390 }
1391
1392 /*
1393 * Read the name.
1394 * Adjust the name buffer first.
1395 */
1396 if (cchName < UnitHdr.cchName)
1397 {
1398 if (pszName)
1399 RTMemTmpFree(pszName);
1400 cchName = RT_ALIGN_Z(UnitHdr.cchName, 64);
1401 pszName = (char *)RTMemTmpAlloc(cchName);
1402 }
1403 if (pszName)
1404 {
1405 rc = RTFileRead(Handle.File, pszName, UnitHdr.cchName, NULL);
1406 if (VBOX_SUCCESS(rc))
1407 {
1408 if (!pszName[UnitHdr.cchName - 1])
1409 {
1410 Log(("SSM: Data unit: offset %#9llx size %9lld '%s'\n", offUnit, UnitHdr.cbUnit, pszName));
1411
1412 /*
1413 * Progress
1414 */
1415 Handle.offEstUnitEnd += UnitHdr.cbUnit;
1416
1417 /*
1418 * Find the data unit in our internal table.
1419 */
1420 pUnit = ssmr3Find(pVM, pszName, UnitHdr.u32Instance);
1421 if (pUnit)
1422 {
1423 /*
1424 * Call the execute handler.
1425 */
1426 Handle.cbUnitLeft = UnitHdr.cbUnit - RT_OFFSETOF(SSMFILEUNITHDR, szName[UnitHdr.cchName]);
1427 switch (pUnit->enmType)
1428 {
1429 case SSMUNITTYPE_DEV:
1430 if (pUnit->u.Dev.pfnLoadExec)
1431 rc = pUnit->u.Dev.pfnLoadExec(pUnit->u.Dev.pDevIns, &Handle, UnitHdr.u32Version);
1432 else
1433 rc = VERR_SSM_NO_LOAD_EXEC;
1434 break;
1435 case SSMUNITTYPE_DRV:
1436 if (pUnit->u.Drv.pfnLoadExec)
1437 rc = pUnit->u.Drv.pfnLoadExec(pUnit->u.Drv.pDrvIns, &Handle, UnitHdr.u32Version);
1438 else
1439 rc = VERR_SSM_NO_LOAD_EXEC;
1440 break;
1441 case SSMUNITTYPE_INTERNAL:
1442 if (pUnit->u.Internal.pfnLoadExec)
1443 rc = pUnit->u.Internal.pfnLoadExec(pVM, &Handle, UnitHdr.u32Version);
1444 else
1445 rc = VERR_SSM_NO_LOAD_EXEC;
1446 break;
1447 case SSMUNITTYPE_EXTERNAL:
1448 if (pUnit->u.External.pfnLoadExec)
1449 {
1450 rc = pUnit->u.External.pfnLoadExec(&Handle, pUnit->u.External.pvUser, UnitHdr.u32Version);
1451 if (!rc)
1452 rc = Handle.rc;
1453 }
1454 else
1455 rc = VERR_SSM_NO_LOAD_EXEC;
1456 break;
1457 }
1458 if (rc != VERR_SSM_NO_LOAD_EXEC)
1459 {
1460 /*
1461 * Close the reader stream.
1462 */
1463 if (Handle.pZipDecomp)
1464 ssmr3ReadFinish(&Handle);
1465
1466 pUnit->fCalled = true;
1467 if (VBOX_SUCCESS(rc))
1468 rc = Handle.rc;
1469 if (VBOX_SUCCESS(rc))
1470 {
1471 /*
1472 * Now, we'll check the current position to see if all, or
1473 * more than all, the data was read.
1474 *
1475 * Note! Because of buffering / compression we'll only see the
1476 * really bad ones here.
1477 */
1478 uint64_t off = RTFileTell(Handle.File);
1479 int64_t i64Diff = off - (offUnit + UnitHdr.cbUnit);
1480 if (i64Diff < 0)
1481 {
1482 Log(("SSM: Unit '%s' left %lld bytes unread!\n", pszName, -i64Diff));
1483 rc = RTFileSeek(Handle.File, offUnit + UnitHdr.cbUnit, RTFILE_SEEK_BEGIN, NULL);
1484 }
1485 else if (i64Diff > 0)
1486 {
1487 LogRel(("SSM: Unit '%s' read %lld bytes too much!\n", pszName, i64Diff));
1488 rc = VERR_SSM_INTEGRITY;
1489 break;
1490 }
1491
1492 /* Advance the progress bar to the end of the block. */
1493 ssmR3Progress(&Handle, Handle.offEstUnitEnd - Handle.offEst);
1494 }
1495 else
1496 {
1497 /*
1498 * We failed, but if loading for the debugger ignore certain failures
1499 * just to get it all loaded (big hack).
1500 */
1501 LogRel(("SSM: LoadExec failed with rc=%Vrc for unit '%s'!\n", rc, pszName));
1502 if ( Handle.enmAfter != SSMAFTER_DEBUG_IT
1503 || rc != VERR_SSM_LOADED_TOO_MUCH)
1504 break;
1505 Handle.rc = rc = VINF_SUCCESS;
1506 ssmR3Progress(&Handle, Handle.offEstUnitEnd - Handle.offEst);
1507 }
1508 }
1509 else
1510 {
1511 LogRel(("SSM: No load exec callback for unit '%s'!\n", pszName));
1512 rc = VERR_SSM_INTEGRITY;
1513 break;
1514 }
1515 }
1516 else
1517 {
1518 /*
1519 * SSM unit wasn't found - ignore this when loading for the debugger.
1520 */
1521 LogRel(("SSM: Found no handler for unit '%s'!\n", pszName));
1522 rc = VERR_SSM_INTEGRITY_UNIT_NOT_FOUND;
1523 if (Handle.enmAfter != SSMAFTER_DEBUG_IT)
1524 break;
1525 rc = RTFileSeek(Handle.File, offUnit + UnitHdr.cbUnit, RTFILE_SEEK_BEGIN, NULL);
1526 }
1527 }
1528 else
1529 {
1530 LogRel(("SSM: Unit name '%.*s' was not properly terminated.\n", UnitHdr.cchName, pszName));
1531 rc = VERR_SSM_INTEGRITY;
1532 break;
1533 }
1534 }
1535 }
1536 else
1537 rc = VERR_NO_TMP_MEMORY;
1538 }
1539
1540 /*
1541 * I/O errors ends up here (yea, I know, very nice programming).
1542 */
1543 if (VBOX_FAILURE(rc))
1544 {
1545 LogRel(("SSM: I/O error. rc=%Vrc\n", rc));
1546 break;
1547 }
1548 }
1549 }
1550 /* (progress should be pending 99% now) */
1551 AssertMsg(VBOX_FAILURE(rc) || Handle.uPercent == (101-Handle.uPercentDone), ("%d\n", Handle.uPercent));
1552
1553 /*
1554 * Do the done run.
1555 */
1556 Handle.rc = rc;
1557 Handle.enmOp = SSMSTATE_LOAD_DONE;
1558 for (pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
1559 {
1560 rc = VINF_SUCCESS;
1561 switch (pUnit->enmType)
1562 {
1563 case SSMUNITTYPE_DEV:
1564 if ( pUnit->u.Dev.pfnLoadDone
1565 && ( pUnit->fCalled
1566 || (!pUnit->u.Dev.pfnLoadPrep && !pUnit->u.Dev.pfnLoadExec)))
1567 rc = pUnit->u.Dev.pfnLoadDone(pUnit->u.Dev.pDevIns, &Handle);
1568 break;
1569 case SSMUNITTYPE_DRV:
1570 if ( pUnit->u.Drv.pfnLoadDone
1571 && ( pUnit->fCalled
1572 || (!pUnit->u.Drv.pfnLoadPrep && !pUnit->u.Drv.pfnLoadExec)))
1573 rc = pUnit->u.Drv.pfnLoadDone(pUnit->u.Drv.pDrvIns, &Handle);
1574 break;
1575 case SSMUNITTYPE_INTERNAL:
1576 if (pUnit->u.Internal.pfnLoadDone
1577 && ( pUnit->fCalled
1578 || (!pUnit->u.Internal.pfnLoadPrep && !pUnit->u.Internal.pfnLoadExec)))
1579 rc = pUnit->u.Internal.pfnLoadDone(pVM, &Handle);
1580 break;
1581 case SSMUNITTYPE_EXTERNAL:
1582 if (pUnit->u.External.pfnLoadDone
1583 && ( pUnit->fCalled
1584 || (!pUnit->u.Internal.pfnLoadPrep && !pUnit->u.Internal.pfnLoadExec)))
1585 rc = pUnit->u.External.pfnLoadDone(&Handle, pUnit->u.External.pvUser);
1586 break;
1587 }
1588 if (VBOX_FAILURE(rc))
1589 {
1590 LogRel(("SSM: Done load failed with rc=%Vrc for data unit '%s'.\n", rc, pUnit->szName));
1591 if (VBOX_SUCCESS(Handle.rc))
1592 Handle.rc = rc;
1593 }
1594 }
1595 rc = Handle.rc;
1596
1597 /* progress */
1598 if (pfnProgress)
1599 pfnProgress(pVM, 99, pvUser);
1600 }
1601
1602 /*
1603 * Done
1604 */
1605 int rc2 = RTFileClose(Handle.File);
1606 AssertRC(rc2);
1607 if (VBOX_SUCCESS(rc))
1608 {
1609 /* progress */
1610 if (pfnProgress)
1611 pfnProgress(pVM, 100, pvUser);
1612 Log(("SSM: Load of '%s' completed!\n", pszFilename));
1613 Log(("\n\n\n"));
1614 DBGFR3InfoLog(pVM, "cpum", "verbose");
1615 DBGFR3InfoLog(pVM, "timers", NULL);
1616 DBGFR3InfoLog(pVM, "activetimers", NULL);
1617 DBGFR3InfoLog(pVM, "ioport", NULL);
1618 DBGFR3InfoLog(pVM, "mmio", NULL);
1619 DBGFR3InfoLog(pVM, "phys", NULL);
1620 Log(("\n\n\n"));
1621 }
1622 return rc;
1623}
1624
1625
1626/**
1627 * Validates a file as a validate SSM saved state.
1628 *
1629 * This will only verify the file format, the format and content of individual
1630 * data units are not inspected.
1631 *
1632 * @returns VINF_SUCCESS if valid.
1633 * @returns VBox status code on other failures.
1634 * @param pszFilename The path to the file to validate.
1635 */
1636SSMR3DECL(int) SSMR3ValidateFile(const char *pszFilename)
1637{
1638 LogFlow(("SSMR3ValidateFile: pszFilename=%p:{%s}\n", pszFilename, pszFilename));
1639
1640 /*
1641 * Try open the file and validate it.
1642 */
1643 RTFILE File;
1644 int rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
1645 if (VBOX_SUCCESS(rc))
1646 {
1647 size_t cbFileHdr;
1648 SSMFILEHDR Hdr;
1649 rc = ssmr3Validate(File, &Hdr, &cbFileHdr);
1650 RTFileClose(File);
1651 }
1652 else
1653 Log(("SSM: Failed to open saved state file '%s', rc=%Vrc.\n", pszFilename, rc));
1654 return rc;
1655}
1656
1657
1658/**
1659 * Opens a saved state file for reading.
1660 *
1661 * @returns VBox status code.
1662 * @param pszFilename The path to the saved state file.
1663 * @param fFlags Open flags. Reserved, must be 0.
1664 * @param ppSSM Where to store the SSM handle.
1665 */
1666SSMR3DECL(int) SSMR3Open(const char *pszFilename, unsigned fFlags, PSSMHANDLE *ppSSM)
1667{
1668 LogFlow(("SSMR3Open: pszFilename=%p:{%s} fFlags=%#x ppSSM=%p\n", pszFilename, pszFilename, fFlags, ppSSM));
1669
1670 /*
1671 * Validate input.
1672 */
1673 AssertMsgReturn(VALID_PTR(pszFilename), ("%p\n", pszFilename), VERR_INVALID_PARAMETER);
1674 AssertMsgReturn(!fFlags, ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
1675 AssertMsgReturn(VALID_PTR(ppSSM), ("%p\n", ppSSM), VERR_INVALID_PARAMETER);
1676
1677 /*
1678 * Allocate a handle.
1679 */
1680 PSSMHANDLE pSSM = (PSSMHANDLE)RTMemAllocZ(sizeof(*pSSM));
1681 AssertReturn(pSSM, VERR_NO_MEMORY);
1682
1683 /*
1684 * Try open the file and validate it.
1685 */
1686 int rc = RTFileOpen(&pSSM->File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
1687 if (VBOX_SUCCESS(rc))
1688 {
1689 SSMFILEHDR Hdr;
1690 size_t cbFileHdr;
1691 rc = ssmr3Validate(pSSM->File, &Hdr, &cbFileHdr);
1692 if (VBOX_SUCCESS(rc))
1693 {
1694 //pSSM->pVM = NULL;
1695 pSSM->cbFileHdr = cbFileHdr;
1696 pSSM->enmOp = SSMSTATE_OPEN_READ;
1697 pSSM->enmAfter = SSMAFTER_OPENED;
1698 pSSM->uPercentPrepare = 20; /* reserve substantial time for validating the image */
1699 pSSM->uPercentDone = 2;
1700 //pSSM->rc = VINF_SUCCESS;
1701 //pSSM->pZipComp = NULL;
1702 //pSSM->pZipDecomp = NULL;
1703 //pSSM->cbUnitLeft = 0;
1704 //pSSM->pfnProgress = NULL;
1705 //pSSM->pvUser = NULL;
1706 //pSSM->uPercent = 0;
1707 //pSSM->offEstProgress= 0;
1708 //pSSM->cbEstTotal = 0;
1709 //pSSM->offEst = 0;
1710 //pSSM->offEstUnitEnd = 0;
1711 *ppSSM = pSSM;
1712 LogFlow(("SSMR3Open: returns VINF_SUCCESS *ppSSM=%p\n", *ppSSM));
1713 return VINF_SUCCESS;
1714 }
1715 Log(("SSMR3Open: Validation of '%s' failed, rc=%Vrc.\n", pszFilename, rc));
1716 RTFileClose(pSSM->File);
1717 }
1718 else
1719 Log(("SSMR3Open: Failed to open saved state file '%s', rc=%Vrc.\n", pszFilename, rc));
1720 RTMemFree(pSSM);
1721 return rc;
1722
1723}
1724
1725
1726/**
1727 * Closes a saved state file opened by SSMR3Open().
1728 *
1729 * @returns VBox status code.
1730 * @param pSSM The SSM handle returned by SSMR3Open().
1731 */
1732SSMR3DECL(int) SSMR3Close(PSSMHANDLE pSSM)
1733{
1734 LogFlow(("SSMR3Close: pSSM=%p\n", pSSM));
1735
1736 /*
1737 * Validate input.
1738 */
1739 AssertMsgReturn(VALID_PTR(pSSM), ("%p\n", pSSM), VERR_INVALID_PARAMETER);
1740 AssertMsgReturn(pSSM->enmAfter == SSMAFTER_OPENED, ("%d\n", pSSM->enmAfter),VERR_INVALID_PARAMETER);
1741 AssertMsgReturn(pSSM->enmOp == SSMSTATE_OPEN_READ, ("%d\n", pSSM->enmOp), VERR_INVALID_PARAMETER);
1742
1743 /*
1744 * Close the file and free the handle.
1745 */
1746 int rc = RTFileClose(pSSM->File);
1747 AssertRC(rc);
1748 RTMemFree(pSSM);
1749 return rc;
1750}
1751
1752
1753/**
1754 * Seeks to a specific data unit.
1755 *
1756 * After seeking it's possible to use the getters to on
1757 * that data unit.
1758 *
1759 * @returns VBox status code.
1760 * @returns VERR_SSM_UNIT_NOT_FOUND if the unit+instance wasn't found.
1761 * @param pSSM The SSM handle returned by SSMR3Open().
1762 * @param pszUnit The name of the data unit.
1763 * @param iInstance The instance number.
1764 * @param piVersion Where to store the version number. (Optional)
1765 */
1766SSMR3DECL(int) SSMR3Seek(PSSMHANDLE pSSM, const char *pszUnit, uint32_t iInstance, uint32_t *piVersion)
1767{
1768 LogFlow(("SSMR3Seek: pSSM=%p pszUnit=%p:{%s} iInstance=%RU32 piVersion=%p\n",
1769 pSSM, pszUnit, iInstance, piVersion));
1770
1771 /*
1772 * Validate input.
1773 */
1774 AssertMsgReturn(VALID_PTR(pSSM), ("%p\n", pSSM), VERR_INVALID_PARAMETER);
1775 AssertMsgReturn(pSSM->enmAfter == SSMAFTER_OPENED, ("%d\n", pSSM->enmAfter),VERR_INVALID_PARAMETER);
1776 AssertMsgReturn(pSSM->enmOp == SSMSTATE_OPEN_READ, ("%d\n", pSSM->enmOp), VERR_INVALID_PARAMETER);
1777 AssertMsgReturn(VALID_PTR(pszUnit), ("%p\n", pszUnit), VERR_INVALID_POINTER);
1778 AssertMsgReturn(!piVersion || VALID_PTR(piVersion), ("%p\n", piVersion), VERR_INVALID_POINTER);
1779
1780 /*
1781 * Reset the state.
1782 */
1783 if (pSSM->pZipDecomp)
1784 {
1785 RTZipDecompDestroy(pSSM->pZipDecomp);
1786 pSSM->pZipDecomp = NULL;
1787 }
1788 pSSM->rc = VERR_SSM_UNIT_NOT_FOUND;
1789 pSSM->cbUnitLeft = 0;
1790
1791 /*
1792 * Walk the data units until we find EOF or a match.
1793 */
1794 size_t cchUnit = strlen(pszUnit) + 1;
1795 int rc = VINF_SUCCESS;
1796 char *pszName = NULL;
1797 size_t cchName = 0;
1798 SSMFILEUNITHDR UnitHdr;
1799 for (RTFOFF off = pSSM->cbFileHdr; ; off += UnitHdr.cbUnit)
1800 {
1801 /*
1802 * Read the unit header and verify it.
1803 */
1804 rc = RTFileReadAt(pSSM->File, off, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDR, szName), NULL);
1805 AssertRC(rc);
1806 if (VBOX_SUCCESS(rc))
1807 {
1808 if (!memcmp(&UnitHdr.achMagic[0], SSMFILEUNITHDR_MAGIC, sizeof(SSMFILEUNITHDR_MAGIC)))
1809 {
1810 /*
1811 * Does it match thus far or should we just skip along?
1812 */
1813 if ( UnitHdr.u32Instance != iInstance
1814 && UnitHdr.cchName != cchUnit)
1815 continue;
1816
1817 /*
1818 * Read the name.
1819 * Adjust the name buffer first.
1820 */
1821 if (cchName < UnitHdr.cchName)
1822 {
1823 if (pszName)
1824 RTMemTmpFree(pszName);
1825 cchName = RT_ALIGN_Z(UnitHdr.cchName, 64);
1826 pszName = (char *)RTMemTmpAlloc(cchName);
1827 }
1828 rc = VERR_NO_MEMORY;
1829 if (pszName)
1830 {
1831 rc = RTFileRead(pSSM->File, pszName, UnitHdr.cchName, NULL);
1832 AssertRC(rc);
1833 if (VBOX_SUCCESS(rc))
1834 {
1835 if (!pszName[UnitHdr.cchName - 1])
1836 {
1837 /*
1838 * Does the name match? If not continue with the next item.
1839 */
1840 if (memcmp(pszName, pszUnit, cchUnit))
1841 continue;
1842
1843 pSSM->rc = rc = VINF_SUCCESS;
1844 pSSM->cbUnitLeft = UnitHdr.cbUnit - RT_OFFSETOF(SSMFILEUNITHDR, szName[UnitHdr.cchName]);
1845 if (piVersion)
1846 *piVersion = UnitHdr.u32Version;
1847 }
1848 else
1849 {
1850 AssertMsgFailed((" Unit name '%.*s' was not properly terminated.\n", UnitHdr.cchName, pszName));
1851 rc = VERR_SSM_INTEGRITY;
1852 }
1853 }
1854 }
1855 }
1856 else
1857 {
1858 if (!memcmp(&UnitHdr.achMagic[0], SSMFILEUNITHDR_END, sizeof(SSMFILEUNITHDR_END)))
1859 rc = VERR_SSM_UNIT_NOT_FOUND;
1860 else
1861 {
1862 AssertMsgFailed(("Invalid unit magic at offset %RTfoff, '%.*s'!\n",
1863 off, sizeof(UnitHdr.achMagic) - 1, &UnitHdr.achMagic[0]));
1864 rc = VERR_SSM_INTEGRITY_UNIT_MAGIC;
1865 }
1866 }
1867 }
1868
1869 /* error or success, two continue statements cover the iterating */
1870 break;
1871 }
1872
1873 RTMemFree(pszName);
1874 return rc;
1875}
1876
1877
1878/**
1879 * Finishes a data unit.
1880 * All buffers and compressor instances are flushed and destroyed.
1881 *
1882 * @returns VBox status.
1883 * @param pSSM SSM operation handle.
1884 */
1885static int ssmr3WriteFinish(PSSMHANDLE pSSM)
1886{
1887 //Log2(("ssmr3WriteFinish: %#010llx start\n", RTFileTell(pSSM->File)));
1888 if (!pSSM->pZipComp)
1889 return VINF_SUCCESS;
1890
1891 int rc = RTZipCompFinish(pSSM->pZipComp);
1892 if (VBOX_SUCCESS(rc))
1893 {
1894 rc = RTZipCompDestroy(pSSM->pZipComp);
1895 if (VBOX_SUCCESS(rc))
1896 {
1897 pSSM->pZipComp = NULL;
1898 //Log2(("ssmr3WriteFinish: %#010llx done\n", RTFileTell(pSSM->File)));
1899 return VINF_SUCCESS;
1900 }
1901 }
1902 if (VBOX_SUCCESS(pSSM->rc))
1903 pSSM->rc = rc;
1904 Log2(("ssmr3WriteFinish: failure rc=%Vrc\n", rc));
1905 return rc;
1906}
1907
1908/**
1909 * Writes something to the current data item in the saved state file.
1910 *
1911 * @returns VBox status.
1912 * @param pSSM SSM operation handle.
1913 * @param pvBuf The bits to write.
1914 * @param cbBuf The number of bytes to write.
1915 */
1916static int ssmr3Write(PSSMHANDLE pSSM, const void *pvBuf, size_t cbBuf)
1917{
1918 Log2(("ssmr3Write: pvBuf=%p cbBuf=%#x %.*Vhxs%s\n", pvBuf, cbBuf, RT_MIN(cbBuf, 128), pvBuf, cbBuf > 128 ? "..." : ""));
1919
1920 /*
1921 * Check that everything is fine.
1922 */
1923 if (VBOX_SUCCESS(pSSM->rc))
1924 {
1925 /*
1926 * First call starts the compression.
1927 */
1928 if (!pSSM->pZipComp)
1929 {
1930 //int rc = RTZipCompCreate(&pSSM->pZipComp, pSSM, ssmr3WriteOut, RTZIPTYPE_ZLIB, RTZIPLEVEL_FAST);
1931 int rc = RTZipCompCreate(&pSSM->pZipComp, pSSM, ssmr3WriteOut, RTZIPTYPE_LZF, RTZIPLEVEL_FAST);
1932 if (VBOX_FAILURE(rc))
1933 return rc;
1934 }
1935
1936 /*
1937 * Write the data item in 128kb chunks for progress indicator reasons.
1938 */
1939 while (cbBuf > 0)
1940 {
1941 size_t cbChunk = RT_MIN(cbBuf, 128*1024);
1942 pSSM->rc = RTZipCompress(pSSM->pZipComp, pvBuf, cbChunk);
1943 if (VBOX_FAILURE(pSSM->rc))
1944 break;
1945 ssmR3Progress(pSSM, cbChunk);
1946 cbBuf -= cbChunk;
1947 pvBuf = (char *)pvBuf + cbChunk;
1948 }
1949 }
1950
1951 return pSSM->rc;
1952}
1953
1954
1955/**
1956 * Callback for flusing the output buffer of a compression stream.
1957 *
1958 * @returns VBox status.
1959 * @param pvSSM SSM operation handle.
1960 * @param pvBuf Compressed data.
1961 * @param cbBuf Size of the compressed data.
1962 */
1963static DECLCALLBACK(int) ssmr3WriteOut(void *pvSSM, const void *pvBuf, size_t cbBuf)
1964{
1965 //Log2(("ssmr3WriteOut: %#010llx cbBuf=%#x\n", RTFileTell(((PSSMHANDLE)pvSSM)->File), cbBuf));
1966 int rc = RTFileWrite(((PSSMHANDLE)pvSSM)->File, pvBuf, cbBuf, NULL);
1967 if (VBOX_SUCCESS(rc))
1968 return rc;
1969 Log(("ssmr3WriteOut: RTFileWrite(,,%d) -> %d\n", cbBuf, rc));
1970 return rc;
1971}
1972
1973
1974/**
1975 * Puts a structure.
1976 *
1977 * @returns VBox status code.
1978 * @param pSSM The saved state handle.
1979 * @param pvStruct The structure address.
1980 * @param paFields The array of structure fields descriptions.
1981 * The array must be terminated by a SSMFIELD_ENTRY_TERM().
1982 */
1983SSMR3DECL(int) SSMR3PutStruct(PSSMHANDLE pSSM, const void *pvStruct, PCSSMFIELD paFields)
1984{
1985 /* begin marker. */
1986 int rc = SSMR3PutU32(pSSM, SSMR3STRUCT_BEGIN);
1987 if (VBOX_FAILURE(rc))
1988 return rc;
1989
1990 /* put the fields */
1991 for (PCSSMFIELD pCur = paFields;
1992 pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
1993 pCur++)
1994 {
1995 rc = ssmr3Write(pSSM, (uint8_t *)pvStruct + pCur->off, pCur->cb);
1996 if (VBOX_FAILURE(rc))
1997 return rc;
1998 }
1999
2000 /* end marker */
2001 return SSMR3PutU32(pSSM, SSMR3STRUCT_END);
2002}
2003
2004
2005/**
2006 * Saves a boolean item to the current data unit.
2007 *
2008 * @returns VBox status.
2009 * @param pSSM SSM operation handle.
2010 * @param fBool Item to save.
2011 */
2012SSMR3DECL(int) SSMR3PutBool(PSSMHANDLE pSSM, bool fBool)
2013{
2014 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2015 {
2016 uint8_t u8 = fBool; /* enforce 1 byte size */
2017 return ssmr3Write(pSSM, &u8, sizeof(u8));
2018 }
2019 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2020 return VERR_SSM_INVALID_STATE;
2021}
2022
2023/**
2024 * Saves a 8-bit unsigned integer item to the current data unit.
2025 *
2026 * @returns VBox status.
2027 * @param pSSM SSM operation handle.
2028 * @param u8 Item to save.
2029 */
2030SSMR3DECL(int) SSMR3PutU8(PSSMHANDLE pSSM, uint8_t u8)
2031{
2032 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2033 return ssmr3Write(pSSM, &u8, sizeof(u8));
2034 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2035 return VERR_SSM_INVALID_STATE;
2036}
2037
2038/**
2039 * Saves a 8-bit signed integer item to the current data unit.
2040 *
2041 * @returns VBox status.
2042 * @param pSSM SSM operation handle.
2043 * @param i8 Item to save.
2044 */
2045SSMR3DECL(int) SSMR3PutS8(PSSMHANDLE pSSM, int8_t i8)
2046{
2047 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2048 return ssmr3Write(pSSM, &i8, sizeof(i8));
2049 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2050 return VERR_SSM_INVALID_STATE;
2051}
2052
2053/**
2054 * Saves a 16-bit unsigned integer item to the current data unit.
2055 *
2056 * @returns VBox status.
2057 * @param pSSM SSM operation handle.
2058 * @param u16 Item to save.
2059 */
2060SSMR3DECL(int) SSMR3PutU16(PSSMHANDLE pSSM, uint16_t u16)
2061{
2062 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2063 return ssmr3Write(pSSM, &u16, sizeof(u16));
2064 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2065 return VERR_SSM_INVALID_STATE;
2066}
2067
2068/**
2069 * Saves a 16-bit signed integer item to the current data unit.
2070 *
2071 * @returns VBox status.
2072 * @param pSSM SSM operation handle.
2073 * @param i16 Item to save.
2074 */
2075SSMR3DECL(int) SSMR3PutS16(PSSMHANDLE pSSM, int16_t i16)
2076{
2077 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2078 return ssmr3Write(pSSM, &i16, sizeof(i16));
2079 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2080 return VERR_SSM_INVALID_STATE;
2081}
2082
2083/**
2084 * Saves a 32-bit unsigned integer item to the current data unit.
2085 *
2086 * @returns VBox status.
2087 * @param pSSM SSM operation handle.
2088 * @param u32 Item to save.
2089 */
2090SSMR3DECL(int) SSMR3PutU32(PSSMHANDLE pSSM, uint32_t u32)
2091{
2092 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2093 return ssmr3Write(pSSM, &u32, sizeof(u32));
2094 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2095 return VERR_SSM_INVALID_STATE;
2096}
2097
2098/**
2099 * Saves a 32-bit signed integer item to the current data unit.
2100 *
2101 * @returns VBox status.
2102 * @param pSSM SSM operation handle.
2103 * @param i32 Item to save.
2104 */
2105SSMR3DECL(int) SSMR3PutS32(PSSMHANDLE pSSM, int32_t i32)
2106{
2107 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2108 return ssmr3Write(pSSM, &i32, sizeof(i32));
2109 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2110 return VERR_SSM_INVALID_STATE;
2111}
2112
2113/**
2114 * Saves a 64-bit unsigned integer item to the current data unit.
2115 *
2116 * @returns VBox status.
2117 * @param pSSM SSM operation handle.
2118 * @param u64 Item to save.
2119 */
2120SSMR3DECL(int) SSMR3PutU64(PSSMHANDLE pSSM, uint64_t u64)
2121{
2122 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2123 return ssmr3Write(pSSM, &u64, sizeof(u64));
2124 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2125 return VERR_SSM_INVALID_STATE;
2126}
2127
2128/**
2129 * Saves a 64-bit signed integer item to the current data unit.
2130 *
2131 * @returns VBox status.
2132 * @param pSSM SSM operation handle.
2133 * @param i64 Item to save.
2134 */
2135SSMR3DECL(int) SSMR3PutS64(PSSMHANDLE pSSM, int64_t i64)
2136{
2137 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2138 return ssmr3Write(pSSM, &i64, sizeof(i64));
2139 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2140 return VERR_SSM_INVALID_STATE;
2141}
2142
2143/**
2144 * Saves a 128-bit unsigned integer item to the current data unit.
2145 *
2146 * @returns VBox status.
2147 * @param pSSM SSM operation handle.
2148 * @param u128 Item to save.
2149 */
2150SSMR3DECL(int) SSMR3PutU128(PSSMHANDLE pSSM, uint128_t u128)
2151{
2152 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2153 return ssmr3Write(pSSM, &u128, sizeof(u128));
2154 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2155 return VERR_SSM_INVALID_STATE;
2156}
2157
2158/**
2159 * Saves a 128-bit signed integer item to the current data unit.
2160 *
2161 * @returns VBox status.
2162 * @param pSSM SSM operation handle.
2163 * @param i128 Item to save.
2164 */
2165SSMR3DECL(int) SSMR3PutS128(PSSMHANDLE pSSM, int128_t i128)
2166{
2167 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2168 return ssmr3Write(pSSM, &i128, sizeof(i128));
2169 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2170 return VERR_SSM_INVALID_STATE;
2171}
2172
2173/**
2174 * Saves a VBox unsigned integer item to the current data unit.
2175 *
2176 * @returns VBox status.
2177 * @param pSSM SSM operation handle.
2178 * @param u Item to save.
2179 */
2180SSMR3DECL(int) SSMR3PutUInt(PSSMHANDLE pSSM, RTUINT u)
2181{
2182 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2183 return ssmr3Write(pSSM, &u, sizeof(u));
2184 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2185 return VERR_SSM_INVALID_STATE;
2186}
2187
2188
2189/**
2190 * Saves a VBox signed integer item to the current data unit.
2191 *
2192 * @returns VBox status.
2193 * @param pSSM SSM operation handle.
2194 * @param i Item to save.
2195 */
2196SSMR3DECL(int) SSMR3PutSInt(PSSMHANDLE pSSM, RTINT i)
2197{
2198 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2199 return ssmr3Write(pSSM, &i, sizeof(i));
2200 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2201 return VERR_SSM_INVALID_STATE;
2202}
2203
2204
2205/**
2206 * Saves a GC natural unsigned integer item to the current data unit.
2207 *
2208 * @returns VBox status.
2209 * @param pSSM SSM operation handle.
2210 * @param u Item to save.
2211 */
2212SSMR3DECL(int) SSMR3PutGCUInt(PSSMHANDLE pSSM, RTGCUINT u)
2213{
2214 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2215 return ssmr3Write(pSSM, &u, sizeof(u));
2216 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2217 return VERR_SSM_INVALID_STATE;
2218}
2219
2220
2221/**
2222 * Saves a GC natural signed integer item to the current data unit.
2223 *
2224 * @returns VBox status.
2225 * @param pSSM SSM operation handle.
2226 * @param i Item to save.
2227 */
2228SSMR3DECL(int) SSMR3PutGCSInt(PSSMHANDLE pSSM, RTGCINT i)
2229{
2230 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2231 return ssmr3Write(pSSM, &i, sizeof(i));
2232 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2233 return VERR_SSM_INVALID_STATE;
2234}
2235
2236
2237/**
2238 * Saves a 32 bits GC physical address item to the current data unit.
2239 *
2240 * @returns VBox status.
2241 * @param pSSM SSM operation handle.
2242 * @param GCPhys The item to save
2243 */
2244SSMR3DECL(int) SSMR3PutGCPhys32(PSSMHANDLE pSSM, RTGCPHYS32 GCPhys)
2245{
2246 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2247 return ssmr3Write(pSSM, &GCPhys, sizeof(GCPhys));
2248 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2249 return VERR_SSM_INVALID_STATE;
2250}
2251
2252/**
2253 * Saves a GC physical address item to the current data unit.
2254 *
2255 * @returns VBox status.
2256 * @param pSSM SSM operation handle.
2257 * @param GCPhys The item to save
2258 */
2259SSMR3DECL(int) SSMR3PutGCPhys(PSSMHANDLE pSSM, RTGCPHYS GCPhys)
2260{
2261 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2262 return ssmr3Write(pSSM, &GCPhys, sizeof(GCPhys));
2263 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2264 return VERR_SSM_INVALID_STATE;
2265}
2266
2267
2268/**
2269 * Saves a GC virtual address item to the current data unit.
2270 *
2271 * @returns VBox status.
2272 * @param pSSM SSM operation handle.
2273 * @param GCPtr The item to save.
2274 */
2275SSMR3DECL(int) SSMR3PutGCPtr(PSSMHANDLE pSSM, RTGCPTR GCPtr)
2276{
2277 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2278 return ssmr3Write(pSSM, &GCPtr, sizeof(GCPtr));
2279 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2280 return VERR_SSM_INVALID_STATE;
2281}
2282
2283
2284/**
2285 * Saves a GC virtual address (represented as an unsigned integer) item to the current data unit.
2286 *
2287 * @returns VBox status.
2288 * @param pSSM SSM operation handle.
2289 * @param GCPtr The item to save.
2290 */
2291SSMR3DECL(int) SSMR3PutGCUIntPtr(PSSMHANDLE pSSM, RTGCUINTPTR GCPtr)
2292{
2293 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2294 return ssmr3Write(pSSM, &GCPtr, sizeof(GCPtr));
2295 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2296 return VERR_SSM_INVALID_STATE;
2297}
2298
2299
2300/**
2301 * Saves a HC natural unsigned integer item to the current data unit.
2302 *
2303 * @returns VBox status.
2304 * @param pSSM SSM operation handle.
2305 * @param u Item to save.
2306 */
2307SSMR3DECL(int) SSMR3PutHCUInt(PSSMHANDLE pSSM, RTHCUINT u)
2308{
2309 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2310 return ssmr3Write(pSSM, &u, sizeof(u));
2311 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2312 return VERR_SSM_INVALID_STATE;
2313}
2314
2315
2316/**
2317 * Saves a HC natural signed integer item to the current data unit.
2318 *
2319 * @returns VBox status.
2320 * @param pSSM SSM operation handle.
2321 * @param i Item to save.
2322 */
2323SSMR3DECL(int) SSMR3PutHCSInt(PSSMHANDLE pSSM, RTHCINT i)
2324{
2325 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2326 return ssmr3Write(pSSM, &i, sizeof(i));
2327 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2328 return VERR_SSM_INVALID_STATE;
2329}
2330
2331
2332/**
2333 * Saves a I/O port address item to the current data unit.
2334 *
2335 * @returns VBox status.
2336 * @param pSSM SSM operation handle.
2337 * @param IOPort The item to save.
2338 */
2339SSMR3DECL(int) SSMR3PutIOPort(PSSMHANDLE pSSM, RTIOPORT IOPort)
2340{
2341 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2342 return ssmr3Write(pSSM, &IOPort, sizeof(IOPort));
2343 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2344 return VERR_SSM_INVALID_STATE;
2345}
2346
2347
2348/**
2349 * Saves a selector item to the current data unit.
2350 *
2351 * @returns VBox status.
2352 * @param pSSM SSM operation handle.
2353 * @param Sel The item to save.
2354 */
2355SSMR3DECL(int) SSMR3PutSel(PSSMHANDLE pSSM, RTSEL Sel)
2356{
2357 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2358 return ssmr3Write(pSSM, &Sel, sizeof(Sel));
2359 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2360 return VERR_SSM_INVALID_STATE;
2361}
2362
2363
2364/**
2365 * Saves a memory item to the current data unit.
2366 *
2367 * @returns VBox status.
2368 * @param pSSM SSM operation handle.
2369 * @param pv Item to save.
2370 * @param cb Size of the item.
2371 */
2372SSMR3DECL(int) SSMR3PutMem(PSSMHANDLE pSSM, const void *pv, size_t cb)
2373{
2374 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2375 return ssmr3Write(pSSM, pv, cb);
2376 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2377 return VERR_SSM_INVALID_STATE;
2378}
2379
2380/**
2381 * Saves a zero terminated string item to the current data unit.
2382 *
2383 * @returns VBox status.
2384 * @param pSSM SSM operation handle.
2385 * @param psz Item to save.
2386 */
2387SSMR3DECL(int) SSMR3PutStrZ(PSSMHANDLE pSSM, const char *psz)
2388{
2389 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC)
2390 {
2391 size_t cch = strlen(psz);
2392 if (cch > 1024*1024)
2393 {
2394 AssertMsgFailed(("a %d byte long string, what's this!?!\n"));
2395 return VERR_TOO_MUCH_DATA;
2396 }
2397 uint32_t u32 = (uint32_t)cch;
2398 int rc = ssmr3Write(pSSM, &u32, sizeof(u32));
2399 if (rc)
2400 return rc;
2401 return ssmr3Write(pSSM, psz, cch);
2402 }
2403 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2404 return VERR_SSM_INVALID_STATE;
2405}
2406
2407
2408
2409
2410
2411/**
2412 * Closes the decompressor of a data unit.
2413 *
2414 * @param pSSM SSM operation handle.
2415 */
2416static void ssmr3ReadFinish(PSSMHANDLE pSSM)
2417{
2418 int rc = RTZipDecompDestroy(pSSM->pZipDecomp);
2419 AssertRC(rc);
2420 pSSM->pZipDecomp = NULL;
2421}
2422
2423/**
2424 * Internal read worker.
2425 *
2426 * @param pSSM SSM operation handle.
2427 * @param pvBuf Where to store the read data.
2428 * @param cbBuf Number of bytes to read.
2429 */
2430static int ssmr3Read(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf)
2431{
2432 /*
2433 * Check that everything is fine.
2434 */
2435 if (VBOX_SUCCESS(pSSM->rc))
2436 {
2437 /*
2438 * Open the decompressor on the first read.
2439 */
2440 if (!pSSM->pZipDecomp)
2441 {
2442 pSSM->rc = RTZipDecompCreate(&pSSM->pZipDecomp, pSSM, ssmr3ReadIn);
2443 if (VBOX_FAILURE(pSSM->rc))
2444 return pSSM->rc;
2445 }
2446
2447 /*
2448 * Do the requested read.
2449 * Use 32kb chunks to work the progress indicator.
2450 */
2451 pSSM->rc = RTZipDecompress(pSSM->pZipDecomp, pvBuf, cbBuf, NULL);
2452 if (VBOX_SUCCESS(pSSM->rc))
2453 Log2(("ssmr3Read: pvBuf=%p cbBuf=%#x %.*Vhxs%s\n", pvBuf, cbBuf, RT_MIN(cbBuf, 128), pvBuf, cbBuf > 128 ? "..." : ""));
2454 else
2455 AssertMsgFailed(("rc=%Vrc cbBuf=%#x\n", pSSM->rc, cbBuf));
2456 }
2457
2458 return pSSM->rc;
2459}
2460
2461/**
2462 * Callback for reading compressed data into the input buffer of the
2463 * decompressor.
2464 *
2465 * @returns VBox status code.
2466 * @param pvSSM The SSM handle.
2467 * @param pvBuf Where to store the compressed data.
2468 * @param cbBuf Size of the buffer.
2469 * @param pcbRead Number of bytes actually stored in the buffer.
2470 */
2471static DECLCALLBACK(int) ssmr3ReadIn(void *pvSSM, void *pvBuf, size_t cbBuf, size_t *pcbRead)
2472{
2473 PSSMHANDLE pSSM = (PSSMHANDLE)pvSSM;
2474 size_t cbRead = cbBuf;
2475 if (pSSM->cbUnitLeft < cbBuf)
2476 cbRead = (size_t)pSSM->cbUnitLeft;
2477 if (cbRead)
2478 {
2479 //Log2(("ssmr3ReadIn: %#010llx cbBug=%#x cbRead=%#x\n", RTFileTell(pSSM->File), cbBuf, cbRead));
2480 int rc = RTFileRead(pSSM->File, pvBuf, cbRead, NULL);
2481 if (VBOX_SUCCESS(rc))
2482 {
2483 pSSM->cbUnitLeft -= cbRead;
2484 if (pcbRead)
2485 *pcbRead = cbRead;
2486 ssmR3Progress(pSSM, cbRead);
2487 return VINF_SUCCESS;
2488 }
2489 Log(("ssmr3ReadIn: RTFileRead(,,%d) -> %d\n", cbRead, rc));
2490 return rc;
2491 }
2492
2493 /** @todo weed out lazy saving */
2494 if (pSSM->enmAfter != SSMAFTER_DEBUG_IT)
2495 AssertMsgFailed(("SSM: attempted reading more than the unit!\n"));
2496 return VERR_SSM_LOADED_TOO_MUCH;
2497}
2498
2499
2500/**
2501 * Gets a structure.
2502 *
2503 * @returns VBox status code.
2504 * @param pSSM The saved state handle.
2505 * @param pvStruct The structure address.
2506 * @param paFields The array of structure fields descriptions.
2507 * The array must be terminated by a SSMFIELD_ENTRY_TERM().
2508 */
2509SSMR3DECL(int) SSMR3GetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields)
2510{
2511 /* begin marker. */
2512 uint32_t u32Magic;
2513 int rc = SSMR3GetU32(pSSM, &u32Magic);
2514 if (VBOX_FAILURE(rc))
2515 return rc;
2516 if (u32Magic != SSMR3STRUCT_BEGIN)
2517 AssertMsgFailedReturn(("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
2518
2519 /* put the fields */
2520 for (PCSSMFIELD pCur = paFields;
2521 pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
2522 pCur++)
2523 {
2524 rc = ssmr3Read(pSSM, (uint8_t *)pvStruct + pCur->off, pCur->cb);
2525 if (VBOX_FAILURE(rc))
2526 return rc;
2527 }
2528
2529 /* end marker */
2530 rc = SSMR3GetU32(pSSM, &u32Magic);
2531 if (VBOX_FAILURE(rc))
2532 return rc;
2533 if (u32Magic != SSMR3STRUCT_END)
2534 AssertMsgFailedReturn(("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
2535 return rc;
2536}
2537
2538
2539/**
2540 * Loads a boolean item from the current data unit.
2541 *
2542 * @returns VBox status.
2543 * @param pSSM SSM operation handle.
2544 * @param pfBool Where to store the item.
2545 */
2546SSMR3DECL(int) SSMR3GetBool(PSSMHANDLE pSSM, bool *pfBool)
2547{
2548 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2549 {
2550 uint8_t u8; /* see SSMR3PutBool */
2551 int rc = ssmr3Read(pSSM, &u8, sizeof(u8));
2552 if (VBOX_SUCCESS(rc))
2553 {
2554 Assert(u8 <= 1);
2555 *pfBool = !!u8;
2556 }
2557 return rc;
2558 }
2559 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2560 return VERR_SSM_INVALID_STATE;
2561}
2562
2563/**
2564 * Loads a 8-bit unsigned integer item from the current data unit.
2565 *
2566 * @returns VBox status.
2567 * @param pSSM SSM operation handle.
2568 * @param pu8 Where to store the item.
2569 */
2570SSMR3DECL(int) SSMR3GetU8(PSSMHANDLE pSSM, uint8_t *pu8)
2571{
2572 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2573 return ssmr3Read(pSSM, pu8, sizeof(*pu8));
2574 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2575 return VERR_SSM_INVALID_STATE;
2576}
2577
2578/**
2579 * Loads a 8-bit signed integer item from the current data unit.
2580 *
2581 * @returns VBox status.
2582 * @param pSSM SSM operation handle.
2583 * @param pi8 Where to store the item.
2584 */
2585SSMR3DECL(int) SSMR3GetS8(PSSMHANDLE pSSM, int8_t *pi8)
2586{
2587 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2588 return ssmr3Read(pSSM, pi8, sizeof(*pi8));
2589 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2590 return VERR_SSM_INVALID_STATE;
2591}
2592
2593/**
2594 * Loads a 16-bit unsigned integer item from the current data unit.
2595 *
2596 * @returns VBox status.
2597 * @param pSSM SSM operation handle.
2598 * @param pu16 Where to store the item.
2599 */
2600SSMR3DECL(int) SSMR3GetU16(PSSMHANDLE pSSM, uint16_t *pu16)
2601{
2602 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2603 return ssmr3Read(pSSM, pu16, sizeof(*pu16));
2604 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2605 return VERR_SSM_INVALID_STATE;
2606}
2607
2608/**
2609 * Loads a 16-bit signed integer item from the current data unit.
2610 *
2611 * @returns VBox status.
2612 * @param pSSM SSM operation handle.
2613 * @param pi16 Where to store the item.
2614 */
2615SSMR3DECL(int) SSMR3GetS16(PSSMHANDLE pSSM, int16_t *pi16)
2616{
2617 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2618 return ssmr3Read(pSSM, pi16, sizeof(*pi16));
2619 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2620 return VERR_SSM_INVALID_STATE;
2621}
2622
2623/**
2624 * Loads a 32-bit unsigned integer item from the current data unit.
2625 *
2626 * @returns VBox status.
2627 * @param pSSM SSM operation handle.
2628 * @param pu32 Where to store the item.
2629 */
2630SSMR3DECL(int) SSMR3GetU32(PSSMHANDLE pSSM, uint32_t *pu32)
2631{
2632 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2633 return ssmr3Read(pSSM, pu32, sizeof(*pu32));
2634 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2635 return VERR_SSM_INVALID_STATE;
2636}
2637
2638/**
2639 * Loads a 32-bit signed integer item from the current data unit.
2640 *
2641 * @returns VBox status.
2642 * @param pSSM SSM operation handle.
2643 * @param pi32 Where to store the item.
2644 */
2645SSMR3DECL(int) SSMR3GetS32(PSSMHANDLE pSSM, int32_t *pi32)
2646{
2647 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2648 return ssmr3Read(pSSM, pi32, sizeof(*pi32));
2649 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2650 return VERR_SSM_INVALID_STATE;
2651}
2652
2653/**
2654 * Loads a 64-bit unsigned integer item from the current data unit.
2655 *
2656 * @returns VBox status.
2657 * @param pSSM SSM operation handle.
2658 * @param pu64 Where to store the item.
2659 */
2660SSMR3DECL(int) SSMR3GetU64(PSSMHANDLE pSSM, uint64_t *pu64)
2661{
2662 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2663 return ssmr3Read(pSSM, pu64, sizeof(*pu64));
2664 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2665 return VERR_SSM_INVALID_STATE;
2666}
2667
2668/**
2669 * Loads a 64-bit signed integer item from the current data unit.
2670 *
2671 * @returns VBox status.
2672 * @param pSSM SSM operation handle.
2673 * @param pi64 Where to store the item.
2674 */
2675SSMR3DECL(int) SSMR3GetS64(PSSMHANDLE pSSM, int64_t *pi64)
2676{
2677 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2678 return ssmr3Read(pSSM, pi64, sizeof(*pi64));
2679 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2680 return VERR_SSM_INVALID_STATE;
2681}
2682
2683/**
2684 * Loads a 128-bit unsigned integer item from the current data unit.
2685 *
2686 * @returns VBox status.
2687 * @param pSSM SSM operation handle.
2688 * @param pu128 Where to store the item.
2689 */
2690SSMR3DECL(int) SSMR3GetU128(PSSMHANDLE pSSM, uint128_t *pu128)
2691{
2692 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2693 return ssmr3Read(pSSM, pu128, sizeof(*pu128));
2694 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2695 return VERR_SSM_INVALID_STATE;
2696}
2697
2698
2699/**
2700 * Loads a 128-bit signed integer item from the current data unit.
2701 *
2702 * @returns VBox status.
2703 * @param pSSM SSM operation handle.
2704 * @param pi128 Where to store the item.
2705 */
2706SSMR3DECL(int) SSMR3GetS128(PSSMHANDLE pSSM, int128_t *pi128)
2707{
2708 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2709 return ssmr3Read(pSSM, pi128, sizeof(*pi128));
2710 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2711 return VERR_SSM_INVALID_STATE;
2712}
2713
2714
2715/**
2716 * Loads a VBox unsigned integer item from the current data unit.
2717 *
2718 * @returns VBox status.
2719 * @param pSSM SSM operation handle.
2720 * @param pu Where to store the integer.
2721 */
2722SSMR3DECL(int) SSMR3GetUInt(PSSMHANDLE pSSM, PRTUINT pu)
2723{
2724 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2725 return ssmr3Read(pSSM, pu, sizeof(*pu));
2726 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2727 return VERR_SSM_INVALID_STATE;
2728}
2729
2730
2731/**
2732 * Loads a VBox signed integer item from the current data unit.
2733 *
2734 * @returns VBox status.
2735 * @param pSSM SSM operation handle.
2736 * @param pi Where to store the integer.
2737 */
2738SSMR3DECL(int) SSMR3GetSInt(PSSMHANDLE pSSM, PRTINT pi)
2739{
2740 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2741 return ssmr3Read(pSSM, pi, sizeof(*pi));
2742 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2743 return VERR_SSM_INVALID_STATE;
2744}
2745
2746
2747/**
2748 * Loads a GC natural unsigned integer item from the current data unit.
2749 *
2750 * @returns VBox status.
2751 * @param pSSM SSM operation handle.
2752 * @param pu Where to store the integer.
2753 */
2754SSMR3DECL(int) SSMR3GetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
2755{
2756 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2757 return ssmr3Read(pSSM, pu, sizeof(*pu));
2758 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2759 return VERR_SSM_INVALID_STATE;
2760}
2761
2762
2763/**
2764 * Loads a GC natural signed integer item from the current data unit.
2765 *
2766 * @returns VBox status.
2767 * @param pSSM SSM operation handle.
2768 * @param pi Where to store the integer.
2769 */
2770SSMR3DECL(int) SSMR3GetGCSInt(PSSMHANDLE pSSM, PRTGCINT pi)
2771{
2772 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2773 return ssmr3Read(pSSM, pi, sizeof(*pi));
2774 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2775 return VERR_SSM_INVALID_STATE;
2776}
2777
2778/**
2779 * Loads a 32 bits GC physical address item from the current data unit.
2780 *
2781 * @returns VBox status.
2782 * @param pSSM SSM operation handle.
2783 * @param pGCPhys Where to store the GC physical address.
2784 */
2785SSMR3DECL(int) SSMR3GetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
2786{
2787 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2788 return ssmr3Read(pSSM, pGCPhys, sizeof(*pGCPhys));
2789 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2790 return VERR_SSM_INVALID_STATE;
2791}
2792
2793
2794/**
2795 * Loads a GC physical address item from the current data unit.
2796 *
2797 * @returns VBox status.
2798 * @param pSSM SSM operation handle.
2799 * @param pGCPhys Where to store the GC physical address.
2800 */
2801SSMR3DECL(int) SSMR3GetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
2802{
2803 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2804 return ssmr3Read(pSSM, pGCPhys, sizeof(*pGCPhys));
2805 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2806 return VERR_SSM_INVALID_STATE;
2807}
2808
2809
2810/**
2811 * Loads a GC virtual address item from the current data unit.
2812 *
2813 * @returns VBox status.
2814 * @param pSSM SSM operation handle.
2815 * @param pGCPtr Where to store the GC virtual address.
2816 */
2817SSMR3DECL(int) SSMR3GetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
2818{
2819 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2820 return ssmr3Read(pSSM, pGCPtr, sizeof(*pGCPtr));
2821 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2822 return VERR_SSM_INVALID_STATE;
2823}
2824
2825
2826/**
2827 * Loads a GC virtual address (represented as unsigned integer) item from the current data unit.
2828 *
2829 * @returns VBox status.
2830 * @param pSSM SSM operation handle.
2831 * @param pGCPtr Where to store the GC virtual address.
2832 */
2833SSMR3DECL(int) SSMR3GetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
2834{
2835 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2836 return ssmr3Read(pSSM, pGCPtr, sizeof(*pGCPtr));
2837 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2838 return VERR_SSM_INVALID_STATE;
2839}
2840
2841
2842/**
2843 * Loads a I/O port address item from the current data unit.
2844 *
2845 * @returns VBox status.
2846 * @param pSSM SSM operation handle.
2847 * @param pIOPort Where to store the I/O port address.
2848 */
2849SSMR3DECL(int) SSMR3GetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
2850{
2851 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2852 return ssmr3Read(pSSM, pIOPort, sizeof(*pIOPort));
2853 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2854 return VERR_SSM_INVALID_STATE;
2855}
2856
2857
2858/**
2859 * Loads a selector item from the current data unit.
2860 *
2861 * @returns VBox status.
2862 * @param pSSM SSM operation handle.
2863 * @param pSel Where to store the selector.
2864 */
2865SSMR3DECL(int) SSMR3GetSel(PSSMHANDLE pSSM, PRTSEL pSel)
2866{
2867 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2868 return ssmr3Read(pSSM, pSel, sizeof(*pSel));
2869 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2870 return VERR_SSM_INVALID_STATE;
2871}
2872
2873
2874/**
2875 * Loads a memory item from the current data unit.
2876 *
2877 * @returns VBox status.
2878 * @param pSSM SSM operation handle.
2879 * @param pv Where to store the item.
2880 * @param cb Size of the item.
2881 */
2882SSMR3DECL(int) SSMR3GetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
2883{
2884 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2885 return ssmr3Read(pSSM, pv, cb);
2886 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2887 return VERR_SSM_INVALID_STATE;
2888}
2889
2890
2891/**
2892 * Loads a string item from the current data unit.
2893 *
2894 * @returns VBox status.
2895 * @param pSSM SSM operation handle.
2896 * @param psz Where to store the item.
2897 * @param cbMax Max size of the item (including '\\0').
2898 */
2899SSMR3DECL(int) SSMR3GetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
2900{
2901 return SSMR3GetStrZEx(pSSM, psz, cbMax, NULL);
2902}
2903
2904
2905/**
2906 * Loads a string item from the current data unit.
2907 *
2908 * @returns VBox status.
2909 * @param pSSM SSM operation handle.
2910 * @param psz Where to store the item.
2911 * @param cbMax Max size of the item (including '\\0').
2912 * @param pcbStr The length of the loaded string excluding the '\\0'. (optional)
2913 */
2914SSMR3DECL(int) SSMR3GetStrZEx(PSSMHANDLE pSSM, char *psz, size_t cbMax, size_t *pcbStr)
2915{
2916 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ)
2917 {
2918 /* read size prefix. */
2919 uint32_t u32;
2920 int rc = SSMR3GetU32(pSSM, &u32);
2921 if (VBOX_SUCCESS(rc))
2922 {
2923 if (pcbStr)
2924 *pcbStr = u32;
2925 if (u32 < cbMax)
2926 {
2927 /* terminate and read string content. */
2928 psz[u32] = '\0';
2929 return ssmr3Read(pSSM, psz, u32);
2930 }
2931 return VERR_TOO_MUCH_DATA;
2932 }
2933 return rc;
2934 }
2935 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp));
2936 return VERR_SSM_INVALID_STATE;
2937}
2938
2939
2940
2941/**
2942 * Query what the VBox status code of the operation is.
2943 *
2944 * This can be used for putting and getting a batch of values
2945 * without bother checking the result till all the calls have
2946 * been made.
2947 *
2948 * @returns SSMAFTER enum value.
2949 * @param pSSM SSM operation handle.
2950 */
2951SSMR3DECL(int) SSMR3HandleGetStatus(PSSMHANDLE pSSM)
2952{
2953 return pSSM->rc;
2954}
2955
2956/**
2957 * Fail the load operation.
2958 *
2959 * This is mainly intended for sub item loaders (like timers) which
2960 * return code isn't necessarily heeded by the caller but is important
2961 * to SSM.
2962 *
2963 * @returns SSMAFTER enum value.
2964 * @param pSSM SSM operation handle.
2965 * @param iStatus Failure status code. This MUST be a VERR_*.
2966 */
2967SSMR3DECL(int) SSMR3HandleSetStatus(PSSMHANDLE pSSM, int iStatus)
2968{
2969 if (VBOX_FAILURE(iStatus))
2970 {
2971 if (VBOX_SUCCESS(pSSM->rc))
2972 pSSM->rc = iStatus;
2973 return pSSM->rc = iStatus;
2974 }
2975 AssertMsgFailed(("iStatus=%d %Vrc\n", iStatus, iStatus));
2976 return VERR_INVALID_PARAMETER;
2977}
2978
2979
2980/**
2981 * Query what to do after this operation.
2982 *
2983 * @returns SSMAFTER enum value.
2984 * @param pSSM SSM operation handle.
2985 */
2986SSMR3DECL(SSMAFTER) SSMR3HandleGetAfter(PSSMHANDLE pSSM)
2987{
2988 return pSSM->enmAfter;
2989}
2990
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