SSM.cpp@ 19167

Last change on this file since 19167 was 18045, checked in by vboxsync, 16 years ago
SSM: Added SSMR3HandleGetUnitOffset for assiting in debugging saved state fun.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 117.3 KB

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

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

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

Download in other formats: