ssm.h@ 96445

Last change on this file since 96445 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.4 KB

Line
1	/** @file
2	* SSM - The Save State Manager.
3	*/
4
5	/*
6	* Copyright (C) 2006-2022 Oracle and/or its affiliates.
7	*
8	* This file is part of VirtualBox base platform packages, as
9	* available from https://www.virtualbox.org.
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU General Public License
13	* as published by the Free Software Foundation, in version 3 of the
14	* License.
15	*
16	* This program is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, see <https://www.gnu.org/licenses>.
23	*
24	* The contents of this file may alternatively be used under the terms
25	* of the Common Development and Distribution License Version 1.0
26	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27	* in the VirtualBox distribution, in which case the provisions of the
28	* CDDL are applicable instead of those of the GPL.
29	*
30	* You may elect to license modified versions of this file under the
31	* terms and conditions of either the GPL or the CDDL or both.
32	*
33	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34	*/
35
36	#ifndef VBOX_INCLUDED_vmm_ssm_h
37	#define VBOX_INCLUDED_vmm_ssm_h
38	#ifndef RT_WITHOUT_PRAGMA_ONCE
39	# pragma once
40	#endif
41
42	#include <VBox/types.h>
43	#include <VBox/vmm/tm.h>
44	#include <VBox/vmm/vmapi.h>
45
46
47	RT_C_DECLS_BEGIN
48
49	/** @defgroup grp_ssm The Saved State Manager API
50	* @ingroup grp_vmm
51	* @{
52	*/
53
54	/**
55	* Determine the major version of the SSM version. If the major SSM version of two snapshots is
56	* different, the snapshots are incompatible.
57	*/
58	#define SSM_VERSION_MAJOR(ver) ((ver) & 0xffff0000)
59
60	/**
61	* Determine the minor version of the SSM version. If the major SSM version of two snapshots is
62	* the same, the code must handle incompatibilies between minor version changes (e.g. use dummy
63	* values for non-existent fields).
64	*/
65	#define SSM_VERSION_MINOR(ver) ((ver) & 0x0000ffff)
66
67	/**
68	* Determine if the major version changed between two SSM versions.
69	*/
70	#define SSM_VERSION_MAJOR_CHANGED(ver1,ver2) (SSM_VERSION_MAJOR(ver1) != SSM_VERSION_MAJOR(ver2))
71
72	/** The special value for the final pass. */
73	#define SSM_PASS_FINAL UINT32_MAX
74
75
76	#ifdef IN_RING3
77	/** @defgroup grp_ssm_r3 The SSM Host Context Ring-3 API
78	* @{
79	*/
80
81
82	/**
83	* What to do after the save/load operation.
84	*/
85	typedef enum SSMAFTER
86	{
87	/** Invalid. */
88	SSMAFTER_INVALID = 0,
89	/** Will resume the loaded state. */
90	SSMAFTER_RESUME,
91	/** Will destroy the VM after saving. */
92	SSMAFTER_DESTROY,
93	/** Will continue execution after saving the VM. */
94	SSMAFTER_CONTINUE,
95	/** Will teleport the VM.
96	* The source VM will be destroyed (then one saving), the destination VM
97	* will continue execution. */
98	SSMAFTER_TELEPORT,
99	/** Will debug the saved state.
100	* This is used to drop some of the stricter consitentcy checks so it'll
101	* load fine in the debugger or animator. */
102	SSMAFTER_DEBUG_IT,
103	/** The file was opened using SSMR3Open() and we have no idea what the plan is. */
104	SSMAFTER_OPENED
105	} SSMAFTER;
106
107
108	/** Pointer to a structure field description. */
109	typedef struct SSMFIELD *PSSMFIELD;
110	/** Pointer to a const structure field description. */
111	typedef const struct SSMFIELD *PCSSMFIELD;
112
113	/**
114	* SSMFIELD Get/Put callback function.
115	*
116	* This is call for getting and putting the field it is associated with. It's
117	* up to the callback to work the saved state correctly.
118	*
119	* @returns VBox status code.
120	*
121	* @param pSSM The saved state handle.
122	* @param pField The field that is being processed.
123	* @param pvStruct Pointer to the structure.
124	* @param fFlags SSMSTRUCT_FLAGS_XXX.
125	* @param fGetOrPut True if getting, false if putting.
126	* @param pvUser The user argument specified to SSMR3GetStructEx or
127	* SSMR3PutStructEx.
128	*/
129	typedef DECLCALLBACKTYPE(int, FNSSMFIELDGETPUT,(PSSMHANDLE pSSM, const struct SSMFIELD pField, void pvStruct,
130	uint32_t fFlags, bool fGetOrPut, void *pvUser));
131	/** Pointer to a SSMFIELD Get/Put callback. */
132	typedef FNSSMFIELDGETPUT *PFNSSMFIELDGETPUT;
133
134	/**
135	* SSM field transformers.
136	*
137	* These are stored in the SSMFIELD::pfnGetPutOrTransformer and must therefore
138	* have values outside the valid pointer range.
139	*/
140	typedef enum SSMFIELDTRANS
141	{
142	/** Invalid. */
143	SSMFIELDTRANS_INVALID = 0,
144	/** No transformation. */
145	SSMFIELDTRANS_NO_TRANSFORMATION,
146	/** Guest context (GC) physical address. */
147	SSMFIELDTRANS_GCPHYS,
148	/** Guest context (GC) virtual address. */
149	SSMFIELDTRANS_GCPTR,
150	/** Raw-mode context (RC) virtual address. */
151	SSMFIELDTRANS_RCPTR,
152	/** Array of raw-mode context (RC) virtual addresses. */
153	SSMFIELDTRANS_RCPTR_ARRAY,
154	/** Host context (HC) virtual address used as a NULL indicator. See
155	* SSMFIELD_ENTRY_HCPTR_NI. */
156	SSMFIELDTRANS_HCPTR_NI,
157	/** Array of SSMFIELDTRANS_HCPTR_NI. */
158	SSMFIELDTRANS_HCPTR_NI_ARRAY,
159	/** Host context (HC) virtual address used to hold a unsigned 32-bit value. */
160	SSMFIELDTRANS_HCPTR_HACK_U32,
161	/** Load a 32-bit unsigned filed from the state and zero extend it into a 64-bit
162	* structure member. */
163	SSMFIELDTRANS_U32_ZX_U64,
164
165	/** Ignorable field. See SSMFIELD_ENTRY_IGNORE. */
166	SSMFIELDTRANS_IGNORE,
167	/** Ignorable guest context (GC) physical address. */
168	SSMFIELDTRANS_IGN_GCPHYS,
169	/** Ignorable guest context (GC) virtual address. */
170	SSMFIELDTRANS_IGN_GCPTR,
171	/** Ignorable raw-mode context (RC) virtual address. */
172	SSMFIELDTRANS_IGN_RCPTR,
173	/** Ignorable host context (HC) virtual address. */
174	SSMFIELDTRANS_IGN_HCPTR,
175
176	/** Old field.
177	* Save as zeros and skip on restore (nowhere to restore it any longer). */
178	SSMFIELDTRANS_OLD,
179	/** Old guest context (GC) physical address. */
180	SSMFIELDTRANS_OLD_GCPHYS,
181	/** Old guest context (GC) virtual address. */
182	SSMFIELDTRANS_OLD_GCPTR,
183	/** Old raw-mode context (RC) virtual address. */
184	SSMFIELDTRANS_OLD_RCPTR,
185	/** Old host context (HC) virtual address. */
186	SSMFIELDTRANS_OLD_HCPTR,
187	/** Old host context specific padding.
188	* The lower word is the size of 32-bit hosts, the upper for 64-bit hosts. */
189	SSMFIELDTRANS_OLD_PAD_HC,
190	/** Old padding specific to the 32-bit Microsoft C Compiler. */
191	SSMFIELDTRANS_OLD_PAD_MSC32,
192
193	/** Padding that differs between 32-bit and 64-bit hosts.
194	* The first byte of SSMFIELD::cb contains the size for 32-bit hosts.
195	* The second byte of SSMFIELD::cb contains the size for 64-bit hosts.
196	* The upper word of SSMFIELD::cb contains the actual field size.
197	*/
198	SSMFIELDTRANS_PAD_HC,
199	/** Padding for 32-bit hosts only.
200	* SSMFIELD::cb has the same format as for SSMFIELDTRANS_PAD_HC. */
201	SSMFIELDTRANS_PAD_HC32,
202	/** Padding for 64-bit hosts only.
203	* SSMFIELD::cb has the same format as for SSMFIELDTRANS_PAD_HC. */
204	SSMFIELDTRANS_PAD_HC64,
205	/** Automatic compiler padding that may differ between 32-bit and
206	* 64-bit hosts. SSMFIELD::cb has the same format as for
207	* SSMFIELDTRANS_PAD_HC. */
208	SSMFIELDTRANS_PAD_HC_AUTO,
209	/** Automatic compiler padding specific to the 32-bit Microsoft C
210	* compiler.
211	* SSMFIELD::cb has the same format as for SSMFIELDTRANS_PAD_HC. */
212	SSMFIELDTRANS_PAD_MSC32_AUTO
213	} SSMFIELDTRANS;
214
215	/** Tests if it's a padding field with the special SSMFIELD::cb format.
216	* @returns true / false.
217	* @param pfn The SSMFIELD::pfnGetPutOrTransformer value.
218	*/
219	#define SSMFIELDTRANS_IS_PADDING(pfn) \
220	( (uintptr_t)(pfn) >= SSMFIELDTRANS_PAD_HC && (uintptr_t)(pfn) <= SSMFIELDTRANS_PAD_MSC32_AUTO )
221
222	/** Tests if it's an entry for an old field.
223	*
224	* @returns true / false.
225	* @param pfn The SSMFIELD::pfnGetPutOrTransformer value.
226	*/
227	#define SSMFIELDTRANS_IS_OLD(pfn) \
228	( (uintptr_t)(pfn) >= SSMFIELDTRANS_OLD && (uintptr_t)(pfn) <= SSMFIELDTRANS_OLD_PAD_MSC32 )
229
230	/**
231	* A structure field description.
232	*/
233	typedef struct SSMFIELD
234	{
235	/** Getter and putter callback or transformer index. */
236	PFNSSMFIELDGETPUT pfnGetPutOrTransformer;
237	/** Field offset into the structure. */
238	uint32_t off;
239	/** The size of the field. */
240	uint32_t cb;
241	/** This field was first saved by this unit version number. */
242	uint32_t uFirstVer;
243	/** Field name. */
244	const char *pszName;
245	} SSMFIELD;
246
247	/** Emit a SSMFIELD array entry.
248	* @internal */
249	#define SSMFIELD_ENTRY_INT(Name, off, cb, enmTransformer, uFirstVer) \
250	{ (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), (uint32_t)(off), (uint32_t)(cb), (uFirstVer), Name }
251	/** Emit a SSMFIELD array entry.
252	* @internal */
253	#define SSMFIELD_ENTRY_TF_INT(Type, Field, enmTransformer, uFirstVer) \
254	SSMFIELD_ENTRY_INT(#Type "::" #Field, RT_UOFFSETOF(Type, Field), RT_SIZEOFMEMB(Type, Field), enmTransformer, uFirstVer)
255	/** Emit a SSMFIELD array entry for an old field.
256	* @internal */
257	#define SSMFIELD_ENTRY_OLD_INT(Field, cb, enmTransformer) \
258	SSMFIELD_ENTRY_INT("old::" #Field, UINT32_MAX / 2, (cb), enmTransformer, 0)
259	/** Emit a SSMFIELD array entry for an alignment padding.
260	* @internal */
261	#define SSMFIELD_ENTRY_PAD_INT(Type, Field, cb32, cb64, enmTransformer) \
262	SSMFIELD_ENTRY_INT(#Type "::" #Field, RT_UOFFSETOF(Type, Field), \
263	(RT_SIZEOFMEMB(Type, Field) << 16) \| (cb32) \| ((cb64) << 8), enmTransformer, 0)
264	/** Emit a SSMFIELD array entry for an alignment padding.
265	* @internal */
266	#define SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, cb32, cb64, enmTransformer) \
267	SSMFIELD_ENTRY_INT(#Type "::" #Field, UINT32_MAX / 2, 0 \| (cb32) \| ((cb64) << 8), enmTransformer, 0)
268
269	/** Emit a SSMFIELD array entry. */
270	#define SSMFIELD_ENTRY(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_NO_TRANSFORMATION, 0)
271	/** Emit a SSMFIELD array entry with first version. */
272	#define SSMFIELD_ENTRY_VER(Type, Field, uFirstVer) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_NO_TRANSFORMATION, uFirstVer)
273	/** Emit a SSMFIELD array entry for a custom made field. This is intended
274	* for working around bitfields in old structures. */
275	#define SSMFIELD_ENTRY_CUSTOM(Field, off, cb) SSMFIELD_ENTRY_INT("custom::" #Field, off, cb, \
276	SSMFIELDTRANS_NO_TRANSFORMATION, 0)
277	/** Emit a SSMFIELD array entry for a RTGCPHYS type. */
278	#define SSMFIELD_ENTRY_GCPHYS(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_GCPHYS, 0)
279	/** Emit a SSMFIELD array entry for a RTGCPTR type. */
280	#define SSMFIELD_ENTRY_GCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_GCPTR, 0)
281	/** Emit a SSMFIELD array entry for a raw-mode context pointer. */
282	#define SSMFIELD_ENTRY_RCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_RCPTR, 0)
283	/** Emit a SSMFIELD array entry for a raw-mode context pointer. */
284	#define SSMFIELD_ENTRY_RCPTR_ARRAY(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_RCPTR_ARRAY, 0)
285	/** Emit a SSMFIELD array entry for a ring-0 or ring-3 pointer type that is only
286	* of interest as a NULL indicator.
287	*
288	* This is always restored as a 0 (NULL) or 1 value. When
289	* SSMSTRUCT_FLAGS_DONT_IGNORE is set, the pointer will be saved in its
290	* entirety, when clear it will be saved as a boolean. */
291	#define SSMFIELD_ENTRY_HCPTR_NI(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI, 0)
292	/** Same as SSMFIELD_ENTRY_HCPTR_NI, except it's an array of the buggers. */
293	#define SSMFIELD_ENTRY_HCPTR_NI_ARRAY(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI_ARRAY, 0)
294	/** Emit a SSMFIELD array entry for a ring-0 or ring-3 pointer type that has
295	* been hacked such that it will never exceed 32-bit. No sign extending. */
296	#define SSMFIELD_ENTRY_HCPTR_HACK_U32(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_HCPTR_HACK_U32, 0)
297	/** Emit a SSMFIELD array entry for loading a 32-bit field into a 64-bit
298	* structure member, zero extending the value. */
299	#define SSMFIELD_ENTRY_U32_ZX_U64(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_U32_ZX_U64, 0)
300
301	/** Emit a SSMFIELD array entry for a field that can be ignored.
302	* It is stored as zeros if SSMSTRUCT_FLAGS_DONT_IGNORE is specified to
303	* SSMR3PutStructEx. The member is never touched upon restore. */
304	#define SSMFIELD_ENTRY_IGNORE(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGNORE, 0)
305	/** Emit a SSMFIELD array entry for an ignorable RTGCPHYS type. */
306	#define SSMFIELD_ENTRY_IGN_GCPHYS(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_GCPHYS, 0)
307	/** Emit a SSMFIELD array entry for an ignorable RTGCPHYS type. */
308	#define SSMFIELD_ENTRY_IGN_GCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_GCPTR, 0)
309	/** Emit a SSMFIELD array entry for an ignorable raw-mode context pointer. */
310	#define SSMFIELD_ENTRY_IGN_RCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_RCPTR, 0)
311	/** Emit a SSMFIELD array entry for an ignorable ring-3 or/and ring-0 pointer. */
312	#define SSMFIELD_ENTRY_IGN_HCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_HCPTR, 0)
313
314	/** Emit a SSMFIELD array entry for an old field that should be ignored now.
315	* It is stored as zeros and skipped on load. */
316	#define SSMFIELD_ENTRY_OLD(Field, cb) SSMFIELD_ENTRY_OLD_INT(Field, cb, SSMFIELDTRANS_OLD)
317	/** Same as SSMFIELD_ENTRY_IGN_GCPHYS, except there is no structure field. */
318	#define SSMFIELD_ENTRY_OLD_GCPHYS(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTGCPHYS), SSMFIELDTRANS_OLD_GCPHYS)
319	/** Same as SSMFIELD_ENTRY_IGN_GCPTR, except there is no structure field. */
320	#define SSMFIELD_ENTRY_OLD_GCPTR(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTGCPTR), SSMFIELDTRANS_OLD_GCPTR)
321	/** Same as SSMFIELD_ENTRY_IGN_RCPTR, except there is no structure field. */
322	#define SSMFIELD_ENTRY_OLD_RCPTR(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTRCPTR), SSMFIELDTRANS_OLD_RCPTR)
323	/** Same as SSMFIELD_ENTRY_IGN_HCPTR, except there is no structure field. */
324	#define SSMFIELD_ENTRY_OLD_HCPTR(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTHCPTR), SSMFIELDTRANS_OLD_HCPTR)
325	/** Same as SSMFIELD_ENTRY_PAD_HC, except there is no structure field. */
326	#define SSMFIELD_ENTRY_OLD_PAD_HC(Field, cb32, cb64) \
327	SSMFIELD_ENTRY_OLD_INT(Field, RT_MAKE_U32((cb32), (cb64)), SSMFIELDTRANS_OLD_PAD_HC)
328	/** Same as SSMFIELD_ENTRY_PAD_HC64, except there is no structure field. */
329	#define SSMFIELD_ENTRY_OLD_PAD_HC64(Field, cb) SSMFIELD_ENTRY_OLD_PAD_HC(Field, 0, cb)
330	/** Same as SSMFIELD_ENTRY_PAD_HC32, except there is no structure field. */
331	#define SSMFIELD_ENTRY_OLD_PAD_HC32(Field, cb) SSMFIELD_ENTRY_OLD_PAD_HC(Field, cb, 0)
332	/** Same as SSMFIELD_ENTRY_PAD_HC, except there is no structure field. */
333	#define SSMFIELD_ENTRY_OLD_PAD_MSC32(Field, cb) SSMFIELD_ENTRY_OLD_INT(Field, cb, SSMFIELDTRANS_OLD_PAD_MSC32)
334
335	/** Emit a SSMFIELD array entry for a padding that differs in size between
336	* 64-bit and 32-bit hosts. */
337	#define SSMFIELD_ENTRY_PAD_HC(Type, Field, cb32, cb64) SSMFIELD_ENTRY_PAD_INT( Type, Field, cb32, cb64, SSMFIELDTRANS_PAD_HC)
338	/** Emit a SSMFIELD array entry for a padding that is exclusive to 64-bit hosts. */
339	#if HC_ARCH_BITS == 64
340	# define SSMFIELD_ENTRY_PAD_HC64(Type, Field, cb) SSMFIELD_ENTRY_PAD_INT( Type, Field, 0, cb, SSMFIELDTRANS_PAD_HC64)
341	#else
342	# define SSMFIELD_ENTRY_PAD_HC64(Type, Field, cb) SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, 0, cb, SSMFIELDTRANS_PAD_HC64)
343	#endif
344	/** Emit a SSMFIELD array entry for a 32-bit padding for on 64-bits hosts. */
345	#if HC_ARCH_BITS == 32
346	# define SSMFIELD_ENTRY_PAD_HC32(Type, Field, cb) SSMFIELD_ENTRY_PAD_INT( Type, Field, cb, 0, SSMFIELDTRANS_PAD_HC32)
347	#else
348	# define SSMFIELD_ENTRY_PAD_HC32(Type, Field, cb) SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, cb, 0, SSMFIELDTRANS_PAD_HC32)
349	#endif
350	/** Emit a SSMFIELD array entry for an automatic compiler padding that may
351	* differ in size between 64-bit and 32-bit hosts. */
352	#if HC_ARCH_BITS == 64
353	# define SSMFIELD_ENTRY_PAD_HC_AUTO(cb32, cb64) \
354	{ \
355	(PFNSSMFIELDGETPUT)(uintptr_t)(SSMFIELDTRANS_PAD_HC_AUTO), \
356	UINT32_MAX / 2, (cb64 << 16) \| (cb32) \| ((cb64) << 8), 0, "<compiler-padding>" \
357	}
358	#else
359	# define SSMFIELD_ENTRY_PAD_HC_AUTO(cb32, cb64) \
360	{ \
361	(PFNSSMFIELDGETPUT)(uintptr_t)(SSMFIELDTRANS_PAD_HC_AUTO), \
362	UINT32_MAX / 2, (cb32 << 16) \| (cb32) \| ((cb64) << 8), 0, "<compiler-padding>" \
363	}
364	#endif
365	/** Emit a SSMFIELD array entry for an automatic compiler padding that is unique
366	* to the 32-bit microsoft compiler. This is usually used together with
367	* SSMFIELD_ENTRY_PAD_HC. /
368	#if HC_ARCH_BITS == 32 && defined(_MSC_VER)
369	# define SSMFIELD_ENTRY_PAD_MSC32_AUTO(cb) \
370	{ \
371	(PFNSSMFIELDGETPUT)(uintptr_t)(SSMFIELDTRANS_PAD_MSC32_AUTO), \
372	UINT32_MAX / 2, ((cb) << 16) \| (cb), 0, "<msc32-padding>" \
373	}
374	#else
375	# define SSMFIELD_ENTRY_PAD_MSC32_AUTO(cb) \
376	{ \
377	(PFNSSMFIELDGETPUT)(uintptr_t)(SSMFIELDTRANS_PAD_MSC32_AUTO), \
378	UINT32_MAX / 2, (cb), 0, "<msc32-padding>" \
379	}
380	#endif
381
382	/** Emit a SSMFIELD array entry for a field with a custom callback. */
383	#define SSMFIELD_ENTRY_CALLBACK(Type, Field, pfnGetPut) \
384	{ (pfnGetPut), RT_UOFFSETOF(Type, Field), RT_SIZEOFMEMB(Type, Field), 0, #Type "::" #Field }
385	/** Emit the terminating entry of a SSMFIELD array. */
386	#define SSMFIELD_ENTRY_TERM() \
387	{ (PFNSSMFIELDGETPUT)(uintptr_t)SSMFIELDTRANS_INVALID, UINT32_MAX, UINT32_MAX, UINT32_MAX, NULL }
388
389
390	/** @name SSMR3GetStructEx and SSMR3PutStructEx flags.
391	* @{ */
392	/** The field descriptors must exactly cover the entire struct, A to Z. */
393	#define SSMSTRUCT_FLAGS_FULL_STRUCT RT_BIT_32(0)
394	/** No start and end markers, just the raw bits. */
395	#define SSMSTRUCT_FLAGS_NO_MARKERS RT_BIT_32(1)
396	/** Do not ignore any ignorable fields. */
397	#define SSMSTRUCT_FLAGS_DONT_IGNORE RT_BIT_32(2)
398	/** Saved using SSMR3PutMem, don't be too strict. */
399	#define SSMSTRUCT_FLAGS_SAVED_AS_MEM RT_BIT_32(3)
400	/** No introductory structure marker. Use when splitting up structures. */
401	#define SSMSTRUCT_FLAGS_NO_LEAD_MARKER RT_BIT_32(4)
402	/** No trailing structure marker. Use when splitting up structures. */
403	#define SSMSTRUCT_FLAGS_NO_TAIL_MARKER RT_BIT_32(5)
404
405	/** Band-aid for old SSMR3PutMem/SSMR3GetMem of structurs with host pointers.
406	* @remarks This type is normally only used up to the first changes to the
407	* structures take place in order to make sure the conversion from
408	* SSMR3PutMem to field descriptors went smoothly. Replace with
409	* SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED when changing the structure. */
410	#define SSMSTRUCT_FLAGS_MEM_BAND_AID ( SSMSTRUCT_FLAGS_DONT_IGNORE \| SSMSTRUCT_FLAGS_FULL_STRUCT \
411	\| SSMSTRUCT_FLAGS_NO_MARKERS \| SSMSTRUCT_FLAGS_SAVED_AS_MEM)
412	/** Band-aid for old SSMR3PutMem/SSMR3GetMem of structurs with host
413	* pointers, with relaxed checks. */
414	#define SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED ( SSMSTRUCT_FLAGS_DONT_IGNORE \
415	\| SSMSTRUCT_FLAGS_NO_MARKERS \| SSMSTRUCT_FLAGS_SAVED_AS_MEM)
416	/** Mask of the valid bits. */
417	#define SSMSTRUCT_FLAGS_VALID_MASK UINT32_C(0x0000003f)
418	/** @} */
419
420
421	/** The PDM Device callback variants.
422	* @{
423	*/
424
425	/**
426	* Prepare state live save operation.
427	*
428	* @returns VBox status code.
429	* @param pDevIns Device instance of the device which registered the data unit.
430	* @param pSSM SSM operation handle.
431	* @remarks The caller enters the device critical section prior to the call.
432	* @thread Any.
433	*/
434	typedef DECLCALLBACKTYPE(int, FNSSMDEVLIVEPREP,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM));
435	/** Pointer to a FNSSMDEVLIVEPREP() function. */
436	typedef FNSSMDEVLIVEPREP *PFNSSMDEVLIVEPREP;
437
438	/**
439	* Execute state live save operation.
440	*
441	* This will be called repeatedly until all units vote that the live phase has
442	* been concluded.
443	*
444	* @returns VBox status code.
445	* @param pDevIns Device instance of the device which registered the data unit.
446	* @param pSSM SSM operation handle.
447	* @param uPass The pass.
448	* @remarks The caller enters the device critical section prior to the call.
449	* @thread Any.
450	*/
451	typedef DECLCALLBACKTYPE(int, FNSSMDEVLIVEEXEC,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass));
452	/** Pointer to a FNSSMDEVLIVEEXEC() function. */
453	typedef FNSSMDEVLIVEEXEC *PFNSSMDEVLIVEEXEC;
454
455	/**
456	* Vote on whether the live part of the saving has been concluded.
457	*
458	* The vote stops once a unit has vetoed the decision, so don't rely upon this
459	* being called every time.
460	*
461	* @returns VBox status code.
462	* @retval VINF_SUCCESS if done.
463	* @retval VINF_SSM_VOTE_FOR_ANOTHER_PASS if another pass is needed.
464	* @retval VINF_SSM_VOTE_DONE_DONT_CALL_AGAIN if the live saving of the unit is
465	* done and there is not need calling it again before the final pass.
466	* @retval VERR_SSM_VOTE_FOR_GIVING_UP if its time to give up.
467	*
468	* @param pDevIns Device instance of the device which registered the data unit.
469	* @param pSSM SSM operation handle.
470	* @param uPass The data pass.
471	* @remarks The caller enters the device critical section prior to the call.
472	* @thread Any.
473	*/
474	typedef DECLCALLBACKTYPE(int, FNSSMDEVLIVEVOTE,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass));
475	/** Pointer to a FNSSMDEVLIVEVOTE() function. */
476	typedef FNSSMDEVLIVEVOTE *PFNSSMDEVLIVEVOTE;
477
478	/**
479	* Prepare state save operation.
480	*
481	* @returns VBox status code.
482	* @param pDevIns Device instance of the device which registered the data unit.
483	* @param pSSM SSM operation handle.
484	* @remarks The caller enters the device critical section prior to the call.
485	*/
486	typedef DECLCALLBACKTYPE(int, FNSSMDEVSAVEPREP,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM));
487	/** Pointer to a FNSSMDEVSAVEPREP() function. */
488	typedef FNSSMDEVSAVEPREP *PFNSSMDEVSAVEPREP;
489
490	/**
491	* Execute state save operation.
492	*
493	* @returns VBox status code.
494	* @param pDevIns Device instance of the device which registered the data unit.
495	* @param pSSM SSM operation handle.
496	* @remarks The caller enters the device critical section prior to the call.
497	*/
498	typedef DECLCALLBACKTYPE(int, FNSSMDEVSAVEEXEC,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM));
499	/** Pointer to a FNSSMDEVSAVEEXEC() function. */
500	typedef FNSSMDEVSAVEEXEC *PFNSSMDEVSAVEEXEC;
501
502	/**
503	* Done state save operation.
504	*
505	* @returns VBox status code.
506	* @param pDevIns Device instance of the device which registered the data unit.
507	* @param pSSM SSM operation handle.
508	* @remarks The caller enters the device critical section prior to the call.
509	*/
510	typedef DECLCALLBACKTYPE(int, FNSSMDEVSAVEDONE,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM));
511	/** Pointer to a FNSSMDEVSAVEDONE() function. */
512	typedef FNSSMDEVSAVEDONE *PFNSSMDEVSAVEDONE;
513
514	/**
515	* Prepare state load operation.
516	*
517	* @returns VBox status code.
518	* @param pDevIns Device instance of the device which registered the data unit.
519	* @param pSSM SSM operation handle.
520	* @remarks The caller enters the device critical section prior to the call.
521	*/
522	typedef DECLCALLBACKTYPE(int, FNSSMDEVLOADPREP,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM));
523	/** Pointer to a FNSSMDEVLOADPREP() function. */
524	typedef FNSSMDEVLOADPREP *PFNSSMDEVLOADPREP;
525
526	/**
527	* Execute state load operation.
528	*
529	* @returns VBox status code.
530	* @param pDevIns Device instance of the device which registered the data unit.
531	* @param pSSM SSM operation handle.
532	* @param uVersion Data layout version.
533	* @param uPass The pass. This is always SSM_PASS_FINAL for units
534	* that doesn't specify a pfnSaveLive callback.
535	* @remarks The caller enters the device critical section prior to the call.
536	*/
537	typedef DECLCALLBACKTYPE(int, FNSSMDEVLOADEXEC,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass));
538	/** Pointer to a FNSSMDEVLOADEXEC() function. */
539	typedef FNSSMDEVLOADEXEC *PFNSSMDEVLOADEXEC;
540
541	/**
542	* Done state load operation.
543	*
544	* @returns VBox load code.
545	* @param pDevIns Device instance of the device which registered the data unit.
546	* @param pSSM SSM operation handle.
547	* @remarks The caller enters the device critical section prior to the call.
548	*/
549	typedef DECLCALLBACKTYPE(int, FNSSMDEVLOADDONE,(PPDMDEVINS pDevIns, PSSMHANDLE pSSM));
550	/** Pointer to a FNSSMDEVLOADDONE() function. */
551	typedef FNSSMDEVLOADDONE *PFNSSMDEVLOADDONE;
552
553	/** @} */
554
555
556	/** The PDM USB device callback variants.
557	* @{
558	*/
559
560	/**
561	* Prepare state live save operation.
562	*
563	* @returns VBox status code.
564	* @param pUsbIns The USB device instance of the USB device which
565	* registered the data unit.
566	* @param pSSM SSM operation handle.
567	* @thread Any.
568	*/
569	typedef DECLCALLBACKTYPE(int, FNSSMUSBLIVEPREP,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM));
570	/** Pointer to a FNSSMUSBLIVEPREP() function. */
571	typedef FNSSMUSBLIVEPREP *PFNSSMUSBLIVEPREP;
572
573	/**
574	* Execute state live save operation.
575	*
576	* This will be called repeatedly until all units vote that the live phase has
577	* been concluded.
578	*
579	* @returns VBox status code.
580	* @param pUsbIns The USB device instance of the USB device which
581	* registered the data unit.
582	* @param pSSM SSM operation handle.
583	* @param uPass The pass.
584	* @thread Any.
585	*/
586	typedef DECLCALLBACKTYPE(int, FNSSMUSBLIVEEXEC,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM, uint32_t uPass));
587	/** Pointer to a FNSSMUSBLIVEEXEC() function. */
588	typedef FNSSMUSBLIVEEXEC *PFNSSMUSBLIVEEXEC;
589
590	/**
591	* Vote on whether the live part of the saving has been concluded.
592	*
593	* The vote stops once a unit has vetoed the decision, so don't rely upon this
594	* being called every time.
595	*
596	* @returns VBox status code.
597	* @retval VINF_SUCCESS if done.
598	* @retval VINF_SSM_VOTE_FOR_ANOTHER_PASS if another pass is needed.
599	* @retval VINF_SSM_VOTE_DONE_DONT_CALL_AGAIN if the live saving of the unit is
600	* done and there is not need calling it again before the final pass.
601	* @retval VERR_SSM_VOTE_FOR_GIVING_UP if its time to give up.
602	*
603	* @param pUsbIns The USB device instance of the USB device which
604	* registered the data unit.
605	* @param pSSM SSM operation handle.
606	* @param uPass The data pass.
607	* @thread Any.
608	*/
609	typedef DECLCALLBACKTYPE(int, FNSSMUSBLIVEVOTE,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM, uint32_t uPass));
610	/** Pointer to a FNSSMUSBLIVEVOTE() function. */
611	typedef FNSSMUSBLIVEVOTE *PFNSSMUSBLIVEVOTE;
612
613	/**
614	* Prepare state save operation.
615	*
616	* @returns VBox status code.
617	* @param pUsbIns The USB device instance of the USB device which
618	* registered the data unit.
619	* @param pSSM SSM operation handle.
620	*/
621	typedef DECLCALLBACKTYPE(int, FNSSMUSBSAVEPREP,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM));
622	/** Pointer to a FNSSMUSBSAVEPREP() function. */
623	typedef FNSSMUSBSAVEPREP *PFNSSMUSBSAVEPREP;
624
625	/**
626	* Execute state save operation.
627	*
628	* @returns VBox status code.
629	* @param pUsbIns The USB device instance of the USB device which
630	* registered the data unit.
631	* @param pSSM SSM operation handle.
632	*/
633	typedef DECLCALLBACKTYPE(int, FNSSMUSBSAVEEXEC,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM));
634	/** Pointer to a FNSSMUSBSAVEEXEC() function. */
635	typedef FNSSMUSBSAVEEXEC *PFNSSMUSBSAVEEXEC;
636
637	/**
638	* Done state save operation.
639	*
640	* @returns VBox status code.
641	* @param pUsbIns The USB device instance of the USB device which
642	* registered the data unit.
643	* @param pSSM SSM operation handle.
644	*/
645	typedef DECLCALLBACKTYPE(int, FNSSMUSBSAVEDONE,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM));
646	/** Pointer to a FNSSMUSBSAVEDONE() function. */
647	typedef FNSSMUSBSAVEDONE *PFNSSMUSBSAVEDONE;
648
649	/**
650	* Prepare state load operation.
651	*
652	* @returns VBox status code.
653	* @param pUsbIns The USB device instance of the USB device which
654	* registered the data unit.
655	* @param pSSM SSM operation handle.
656	*/
657	typedef DECLCALLBACKTYPE(int, FNSSMUSBLOADPREP,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM));
658	/** Pointer to a FNSSMUSBLOADPREP() function. */
659	typedef FNSSMUSBLOADPREP *PFNSSMUSBLOADPREP;
660
661	/**
662	* Execute state load operation.
663	*
664	* @returns VBox status code.
665	* @param pUsbIns The USB device instance of the USB device which
666	* registered the data unit.
667	* @param pSSM SSM operation handle.
668	* @param uVersion Data layout version.
669	* @param uPass The pass. This is always SSM_PASS_FINAL for units
670	* that doesn't specify a pfnSaveLive callback.
671	*/
672	typedef DECLCALLBACKTYPE(int, FNSSMUSBLOADEXEC,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass));
673	/** Pointer to a FNSSMUSBLOADEXEC() function. */
674	typedef FNSSMUSBLOADEXEC *PFNSSMUSBLOADEXEC;
675
676	/**
677	* Done state load operation.
678	*
679	* @returns VBox load code.
680	* @param pUsbIns The USB device instance of the USB device which
681	* registered the data unit.
682	* @param pSSM SSM operation handle.
683	*/
684	typedef DECLCALLBACKTYPE(int, FNSSMUSBLOADDONE,(PPDMUSBINS pUsbIns, PSSMHANDLE pSSM));
685	/** Pointer to a FNSSMUSBLOADDONE() function. */
686	typedef FNSSMUSBLOADDONE *PFNSSMUSBLOADDONE;
687
688	/** @} */
689
690
691	/** The PDM Driver callback variants.
692	* @{
693	*/
694
695	/**
696	* Prepare state live save operation.
697	*
698	* @returns VBox status code.
699	* @param pDrvIns Driver instance of the driver which registered the
700	* data unit.
701	* @param pSSM SSM operation handle.
702	* @thread Any.
703	*/
704	typedef DECLCALLBACKTYPE(int, FNSSMDRVLIVEPREP,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM));
705	/** Pointer to a FNSSMDRVLIVEPREP() function. */
706	typedef FNSSMDRVLIVEPREP *PFNSSMDRVLIVEPREP;
707
708	/**
709	* Execute state live save operation.
710	*
711	* This will be called repeatedly until all units vote that the live phase has
712	* been concluded.
713	*
714	* @returns VBox status code.
715	* @param pDrvIns Driver instance of the driver which registered the
716	* data unit.
717	* @param pSSM SSM operation handle.
718	* @param uPass The data pass.
719	* @thread Any.
720	*/
721	typedef DECLCALLBACKTYPE(int, FNSSMDRVLIVEEXEC,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uPass));
722	/** Pointer to a FNSSMDRVLIVEEXEC() function. */
723	typedef FNSSMDRVLIVEEXEC *PFNSSMDRVLIVEEXEC;
724
725	/**
726	* Vote on whether the live part of the saving has been concluded.
727	*
728	* The vote stops once a unit has vetoed the decision, so don't rely upon this
729	* being called every time.
730	*
731	* @returns VBox status code.
732	* @retval VINF_SUCCESS if done.
733	* @retval VINF_SSM_VOTE_FOR_ANOTHER_PASS if another pass is needed.
734	* @retval VINF_SSM_VOTE_DONE_DONT_CALL_AGAIN if the live saving of the unit is
735	* done and there is not need calling it again before the final pass.
736	* @retval VERR_SSM_VOTE_FOR_GIVING_UP if its time to give up.
737	*
738	* @param pDrvIns Driver instance of the driver which registered the
739	* data unit.
740	* @param pSSM SSM operation handle.
741	* @param uPass The data pass.
742	* @thread Any.
743	*/
744	typedef DECLCALLBACKTYPE(int, FNSSMDRVLIVEVOTE,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uPass));
745	/** Pointer to a FNSSMDRVLIVEVOTE() function. */
746	typedef FNSSMDRVLIVEVOTE *PFNSSMDRVLIVEVOTE;
747
748
749	/**
750	* Prepare state save operation.
751	*
752	* @returns VBox status code.
753	* @param pDrvIns Driver instance of the driver which registered the data unit.
754	* @param pSSM SSM operation handle.
755	*/
756	typedef DECLCALLBACKTYPE(int, FNSSMDRVSAVEPREP,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM));
757	/** Pointer to a FNSSMDRVSAVEPREP() function. */
758	typedef FNSSMDRVSAVEPREP *PFNSSMDRVSAVEPREP;
759
760	/**
761	* Execute state save operation.
762	*
763	* @returns VBox status code.
764	* @param pDrvIns Driver instance of the driver which registered the data unit.
765	* @param pSSM SSM operation handle.
766	*/
767	typedef DECLCALLBACKTYPE(int, FNSSMDRVSAVEEXEC,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM));
768	/** Pointer to a FNSSMDRVSAVEEXEC() function. */
769	typedef FNSSMDRVSAVEEXEC *PFNSSMDRVSAVEEXEC;
770
771	/**
772	* Done state save operation.
773	*
774	* @returns VBox status code.
775	* @param pDrvIns Driver instance of the driver which registered the data unit.
776	* @param pSSM SSM operation handle.
777	*/
778	typedef DECLCALLBACKTYPE(int, FNSSMDRVSAVEDONE,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM));
779	/** Pointer to a FNSSMDRVSAVEDONE() function. */
780	typedef FNSSMDRVSAVEDONE *PFNSSMDRVSAVEDONE;
781
782	/**
783	* Prepare state load operation.
784	*
785	* @returns VBox status code.
786	* @param pDrvIns Driver instance of the driver which registered the data unit.
787	* @param pSSM SSM operation handle.
788	*/
789	typedef DECLCALLBACKTYPE(int, FNSSMDRVLOADPREP,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM));
790	/** Pointer to a FNSSMDRVLOADPREP() function. */
791	typedef FNSSMDRVLOADPREP *PFNSSMDRVLOADPREP;
792
793	/**
794	* Execute state load operation.
795	*
796	* @returns VBox status code.
797	* @param pDrvIns Driver instance of the driver which registered the data unit.
798	* @param pSSM SSM operation handle.
799	* @param uVersion Data layout version.
800	* @param uPass The pass. This is always SSM_PASS_FINAL for units
801	* that doesn't specify a pfnSaveLive callback.
802	*/
803	typedef DECLCALLBACKTYPE(int, FNSSMDRVLOADEXEC,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass));
804	/** Pointer to a FNSSMDRVLOADEXEC() function. */
805	typedef FNSSMDRVLOADEXEC *PFNSSMDRVLOADEXEC;
806
807	/**
808	* Done state load operation.
809	*
810	* @returns VBox load code.
811	* @param pDrvIns Driver instance of the driver which registered the data unit.
812	* @param pSSM SSM operation handle.
813	*/
814	typedef DECLCALLBACKTYPE(int, FNSSMDRVLOADDONE,(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM));
815	/** Pointer to a FNSSMDRVLOADDONE() function. */
816	typedef FNSSMDRVLOADDONE *PFNSSMDRVLOADDONE;
817
818	/** @} */
819
820
821	/** The internal callback variants.
822	* @{
823	*/
824
825
826	/**
827	* Prepare state live save operation.
828	*
829	* @returns VBox status code.
830	* @param pVM The cross context VM structure.
831	* @param pSSM SSM operation handle.
832	* @thread Any.
833	*/
834	typedef DECLCALLBACKTYPE(int, FNSSMINTLIVEPREP,(PVM pVM, PSSMHANDLE pSSM));
835	/** Pointer to a FNSSMINTLIVEPREP() function. */
836	typedef FNSSMINTLIVEPREP *PFNSSMINTLIVEPREP;
837
838	/**
839	* Execute state live save operation.
840	*
841	* This will be called repeatedly until all units vote that the live phase has
842	* been concluded.
843	*
844	* @returns VBox status code.
845	* @param pVM The cross context VM structure.
846	* @param pSSM SSM operation handle.
847	* @param uPass The data pass.
848	* @thread Any.
849	*/
850	typedef DECLCALLBACKTYPE(int, FNSSMINTLIVEEXEC,(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass));
851	/** Pointer to a FNSSMINTLIVEEXEC() function. */
852	typedef FNSSMINTLIVEEXEC *PFNSSMINTLIVEEXEC;
853
854	/**
855	* Vote on whether the live part of the saving has been concluded.
856	*
857	* The vote stops once a unit has vetoed the decision, so don't rely upon this
858	* being called every time.
859	*
860	* @returns VBox status code.
861	* @retval VINF_SUCCESS if done.
862	* @retval VINF_SSM_VOTE_FOR_ANOTHER_PASS if another pass is needed.
863	* @retval VINF_SSM_VOTE_DONE_DONT_CALL_AGAIN if the live saving of the unit is
864	* done and there is not need calling it again before the final pass.
865	* @retval VERR_SSM_VOTE_FOR_GIVING_UP if its time to give up.
866	*
867	* @param pVM The cross context VM structure.
868	* @param pSSM SSM operation handle.
869	* @param uPass The data pass.
870	* @thread Any.
871	*/
872	typedef DECLCALLBACKTYPE(int, FNSSMINTLIVEVOTE,(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass));
873	/** Pointer to a FNSSMINTLIVEVOTE() function. */
874	typedef FNSSMINTLIVEVOTE *PFNSSMINTLIVEVOTE;
875
876	/**
877	* Prepare state save operation.
878	*
879	* @returns VBox status code.
880	* @param pVM The cross context VM structure.
881	* @param pSSM SSM operation handle.
882	*/
883	typedef DECLCALLBACKTYPE(int, FNSSMINTSAVEPREP,(PVM pVM, PSSMHANDLE pSSM));
884	/** Pointer to a FNSSMINTSAVEPREP() function. */
885	typedef FNSSMINTSAVEPREP *PFNSSMINTSAVEPREP;
886
887	/**
888	* Execute state save operation.
889	*
890	* @returns VBox status code.
891	* @param pVM The cross context VM structure.
892	* @param pSSM SSM operation handle.
893	*/
894	typedef DECLCALLBACKTYPE(int, FNSSMINTSAVEEXEC,(PVM pVM, PSSMHANDLE pSSM));
895	/** Pointer to a FNSSMINTSAVEEXEC() function. */
896	typedef FNSSMINTSAVEEXEC *PFNSSMINTSAVEEXEC;
897
898	/**
899	* Done state save operation.
900	*
901	* @returns VBox status code.
902	* @param pVM The cross context VM structure.
903	* @param pSSM SSM operation handle.
904	*/
905	typedef DECLCALLBACKTYPE(int, FNSSMINTSAVEDONE,(PVM pVM, PSSMHANDLE pSSM));
906	/** Pointer to a FNSSMINTSAVEDONE() function. */
907	typedef FNSSMINTSAVEDONE *PFNSSMINTSAVEDONE;
908
909	/**
910	* Prepare state load operation.
911	*
912	* @returns VBox status code.
913	* @param pVM The cross context VM structure.
914	* @param pSSM SSM operation handle.
915	*/
916	typedef DECLCALLBACKTYPE(int, FNSSMINTLOADPREP,(PVM pVM, PSSMHANDLE pSSM));
917	/** Pointer to a FNSSMINTLOADPREP() function. */
918	typedef FNSSMINTLOADPREP *PFNSSMINTLOADPREP;
919
920	/**
921	* Execute state load operation.
922	*
923	* @returns VBox status code.
924	* @param pVM The cross context VM structure.
925	* @param pSSM SSM operation handle.
926	* @param uVersion Data layout version.
927	* @param uPass The pass. This is always SSM_PASS_FINAL for units
928	* that doesn't specify a pfnSaveLive callback.
929	*/
930	typedef DECLCALLBACKTYPE(int, FNSSMINTLOADEXEC,(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass));
931	/** Pointer to a FNSSMINTLOADEXEC() function. */
932	typedef FNSSMINTLOADEXEC *PFNSSMINTLOADEXEC;
933
934	/**
935	* Done state load operation.
936	*
937	* @returns VBox load code.
938	* @param pVM The cross context VM structure.
939	* @param pSSM SSM operation handle.
940	*/
941	typedef DECLCALLBACKTYPE(int, FNSSMINTLOADDONE,(PVM pVM, PSSMHANDLE pSSM));
942	/** Pointer to a FNSSMINTLOADDONE() function. */
943	typedef FNSSMINTLOADDONE *PFNSSMINTLOADDONE;
944
945	/** @} */
946
947
948	/** The External callback variants.
949	* @{
950	*/
951
952	/**
953	* Prepare state live save operation.
954	*
955	* @returns VBox status code.
956	* @param pSSM SSM operation handle.
957	* @param pVMM The VMM ring-3 vtable.
958	* @param pvUser User argument.
959	* @thread Any.
960	*/
961	typedef DECLCALLBACKTYPE(int, FNSSMEXTLIVEPREP,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser));
962	/** Pointer to a FNSSMEXTLIVEPREP() function. */
963	typedef FNSSMEXTLIVEPREP *PFNSSMEXTLIVEPREP;
964
965	/**
966	* Execute state live save operation.
967	*
968	* This will be called repeatedly until all units vote that the live phase has
969	* been concluded.
970	*
971	* @returns VBox status code.
972	* @param pSSM SSM operation handle.
973	* @param pVMM The VMM ring-3 vtable.
974	* @param pvUser User argument.
975	* @param uPass The data pass.
976	* @thread Any.
977	*/
978	typedef DECLCALLBACKTYPE(int, FNSSMEXTLIVEEXEC,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser, uint32_t uPass));
979	/** Pointer to a FNSSMEXTLIVEEXEC() function. */
980	typedef FNSSMEXTLIVEEXEC *PFNSSMEXTLIVEEXEC;
981
982	/**
983	* Vote on whether the live part of the saving has been concluded.
984	*
985	* The vote stops once a unit has vetoed the decision, so don't rely upon this
986	* being called every time.
987	*
988	* @returns VBox status code.
989	* @retval VINF_SUCCESS if done.
990	* @retval VINF_SSM_VOTE_FOR_ANOTHER_PASS if another pass is needed.
991	* @retval VINF_SSM_VOTE_DONE_DONT_CALL_AGAIN if the live saving of the unit is
992	* done and there is not need calling it again before the final pass.
993	* @retval VERR_SSM_VOTE_FOR_GIVING_UP if its time to give up.
994	*
995	* @param pSSM SSM operation handle.
996	* @param pVMM The VMM ring-3 vtable.
997	* @param pvUser User argument.
998	* @param uPass The data pass.
999	* @thread Any.
1000	*/
1001	typedef DECLCALLBACKTYPE(int, FNSSMEXTLIVEVOTE,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser, uint32_t uPass));
1002	/** Pointer to a FNSSMEXTLIVEVOTE() function. */
1003	typedef FNSSMEXTLIVEVOTE *PFNSSMEXTLIVEVOTE;
1004
1005	/**
1006	* Prepare state save operation.
1007	*
1008	* @returns VBox status code.
1009	* @param pSSM SSM operation handle.
1010	* @param pVMM The VMM ring-3 vtable.
1011	* @param pvUser User argument.
1012	*/
1013	typedef DECLCALLBACKTYPE(int, FNSSMEXTSAVEPREP,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser));
1014	/** Pointer to a FNSSMEXTSAVEPREP() function. */
1015	typedef FNSSMEXTSAVEPREP *PFNSSMEXTSAVEPREP;
1016
1017	/**
1018	* Execute state save operation.
1019	*
1020	* @returns VBox status code.
1021	* @param pSSM SSM operation handle.
1022	* @param pVMM The VMM ring-3 vtable.
1023	* @param pvUser User argument.
1024	*/
1025	typedef DECLCALLBACKTYPE(int, FNSSMEXTSAVEEXEC,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser));
1026	/** Pointer to a FNSSMEXTSAVEEXEC() function. */
1027	typedef FNSSMEXTSAVEEXEC *PFNSSMEXTSAVEEXEC;
1028
1029	/**
1030	* Done state save operation.
1031	*
1032	* @returns VBox status code.
1033	* @param pSSM SSM operation handle.
1034	* @param pVMM The VMM ring-3 vtable.
1035	* @param pvUser User argument.
1036	*/
1037	typedef DECLCALLBACKTYPE(int, FNSSMEXTSAVEDONE,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser));
1038	/** Pointer to a FNSSMEXTSAVEDONE() function. */
1039	typedef FNSSMEXTSAVEDONE *PFNSSMEXTSAVEDONE;
1040
1041	/**
1042	* Prepare state load operation.
1043	*
1044	* @returns VBox status code.
1045	* @param pSSM SSM operation handle.
1046	* @param pVMM The VMM ring-3 vtable.
1047	* @param pvUser User argument.
1048	*/
1049	typedef DECLCALLBACKTYPE(int, FNSSMEXTLOADPREP,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser));
1050	/** Pointer to a FNSSMEXTLOADPREP() function. */
1051	typedef FNSSMEXTLOADPREP *PFNSSMEXTLOADPREP;
1052
1053	/**
1054	* Execute state load operation.
1055	*
1056	* @returns VBox status code.
1057	* @param pSSM SSM operation handle.
1058	* @param pVMM The VMM ring-3 vtable.
1059	* @param pvUser User argument.
1060	* @param uVersion Data layout version.
1061	* @param uPass The pass. This is always SSM_PASS_FINAL for units
1062	* that doesn't specify a pfnSaveLive callback.
1063	* @remark The odd return value is for legacy reasons.
1064	*/
1065	typedef DECLCALLBACKTYPE(int, FNSSMEXTLOADEXEC,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
1066	uint32_t uVersion, uint32_t uPass));
1067	/** Pointer to a FNSSMEXTLOADEXEC() function. */
1068	typedef FNSSMEXTLOADEXEC *PFNSSMEXTLOADEXEC;
1069
1070	/**
1071	* Done state load operation.
1072	*
1073	* @returns VBox load code.
1074	* @param pSSM SSM operation handle.
1075	* @param pVMM The VMM ring-3 vtable.
1076	* @param pvUser User argument.
1077	*/
1078	typedef DECLCALLBACKTYPE(int, FNSSMEXTLOADDONE,(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser));
1079	/** Pointer to a FNSSMEXTLOADDONE() function. */
1080	typedef FNSSMEXTLOADDONE *PFNSSMEXTLOADDONE;
1081
1082	/** @} */
1083
1084
1085	/**
1086	* SSM stream method table.
1087	*
1088	* This is used by external parties for teleporting over TCP or any other media.
1089	* SSM also uses this internally for file access, thus the 2-3 file centric
1090	* methods.
1091	*/
1092	typedef struct SSMSTRMOPS
1093	{
1094	/** Struct magic + version (SSMSTRMOPS_VERSION). */
1095	uint32_t u32Version;
1096
1097	/**
1098	* Write bytes to the stream.
1099	*
1100	* @returns VBox status code.
1101	* @param pvUser The user argument.
1102	* @param offStream The stream offset we're (supposed to be) at.
1103	* @param pvBuf Pointer to the data.
1104	* @param cbToWrite The number of bytes to write.
1105	*/
1106	DECLCALLBACKMEMBER(int, pfnWrite,(void pvUser, uint64_t offStream, const void pvBuf, size_t cbToWrite));
1107
1108	/**
1109	* Read bytes to the stream.
1110	*
1111	* @returns VBox status code.
1112	* @param pvUser The user argument.
1113	* @param offStream The stream offset we're (supposed to be) at.
1114	* @param pvBuf Where to return the bytes.
1115	* @param cbToRead The number of bytes to read.
1116	* @param pcbRead Where to return the number of bytes actually
1117	* read. This may differ from cbToRead when the
1118	* end of the stream is encountered.
1119	*/
1120	DECLCALLBACKMEMBER(int, pfnRead,(void pvUser, uint64_t offStream, void pvBuf, size_t cbToRead, size_t *pcbRead));
1121
1122	/**
1123	* Seeks in the stream.
1124	*
1125	* @returns VBox status code.
1126	* @retval VERR_NOT_SUPPORTED if the stream doesn't support this action.
1127	*
1128	* @param pvUser The user argument.
1129	* @param offSeek The seek offset.
1130	* @param uMethod RTFILE_SEEK_BEGIN, RTFILE_SEEK_END or
1131	* RTFILE_SEEK_CURRENT.
1132	* @param poffActual Where to store the new file position. Optional.
1133	*/
1134	DECLCALLBACKMEMBER(int, pfnSeek,(void pvUser, int64_t offSeek, unsigned uMethod, uint64_t poffActual));
1135
1136	/**
1137	* Get the current stream position.
1138	*
1139	* @returns The correct stream position.
1140	* @param pvUser The user argument.
1141	*/
1142	DECLCALLBACKMEMBER(uint64_t, pfnTell,(void *pvUser));
1143
1144	/**
1145	* Get the size/length of the stream.
1146	*
1147	* @returns VBox status code.
1148	* @retval VERR_NOT_SUPPORTED if the stream doesn't support this action.
1149	*
1150	* @param pvUser The user argument.
1151	* @param pcb Where to return the size/length.
1152	*/
1153	DECLCALLBACKMEMBER(int, pfnSize,(void pvUser, uint64_t pcb));
1154
1155	/**
1156	* Check if the stream is OK or not (cancelled).
1157	*
1158	* @returns VBox status code.
1159	* @param pvUser The user argument.
1160	*
1161	* @remarks The method is expected to do a LogRel on failure.
1162	*/
1163	DECLCALLBACKMEMBER(int, pfnIsOk,(void *pvUser));
1164
1165	/**
1166	* Close the stream.
1167	*
1168	* @returns VBox status code.
1169	* @param pvUser The user argument.
1170	* @param fCancelled True if the operation was cancelled.
1171	*/
1172	DECLCALLBACKMEMBER(int, pfnClose,(void *pvUser, bool fCancelled));
1173
1174	/** Struct magic + version (SSMSTRMOPS_VERSION). */
1175	uint32_t u32EndVersion;
1176	} SSMSTRMOPS;
1177	/** Struct magic + version (SSMSTRMOPS_VERSION). */
1178	#define SSMSTRMOPS_VERSION UINT32_C(0x55aa0001)
1179
1180
1181	VMMR3DECL(void) SSMR3Term(PVM pVM);
1182	VMMR3_INT_DECL(int)
1183	SSMR3RegisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t uInstance, uint32_t uVersion,
1184	size_t cbGuess, const char *pszBefore,
1185	PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
1186	PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
1187	PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone);
1188	VMMR3_INT_DECL(int)
1189	SSMR3RegisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName, uint32_t uInstance, uint32_t uVersion, size_t cbGuess,
1190	PFNSSMDRVLIVEPREP pfnLivePrep, PFNSSMDRVLIVEEXEC pfnLiveExec, PFNSSMDRVLIVEVOTE pfnLiveVote,
1191	PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
1192	PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone);
1193	VMMR3_INT_DECL(int)
1194	SSMR3RegisterUsb(PVM pVM, PPDMUSBINS pUsbIns, const char *pszName, uint32_t uInstance, uint32_t uVersion, size_t cbGuess,
1195	PFNSSMUSBLIVEPREP pfnLivePrep, PFNSSMUSBLIVEEXEC pfnLiveExec, PFNSSMUSBLIVEVOTE pfnLiveVote,
1196	PFNSSMUSBSAVEPREP pfnSavePrep, PFNSSMUSBSAVEEXEC pfnSaveExec, PFNSSMUSBSAVEDONE pfnSaveDone,
1197	PFNSSMUSBLOADPREP pfnLoadPrep, PFNSSMUSBLOADEXEC pfnLoadExec, PFNSSMUSBLOADDONE pfnLoadDone);
1198	VMMR3DECL(int)
1199	SSMR3RegisterInternal(PVM pVM, const char *pszName, uint32_t uInstance, uint32_t uVersion, size_t cbGuess,
1200	PFNSSMINTLIVEPREP pfnLivePrep, PFNSSMINTLIVEEXEC pfnLiveExec, PFNSSMINTLIVEVOTE pfnLiveVote,
1201	PFNSSMINTSAVEPREP pfnSavePrep, PFNSSMINTSAVEEXEC pfnSaveExec, PFNSSMINTSAVEDONE pfnSaveDone,
1202	PFNSSMINTLOADPREP pfnLoadPrep, PFNSSMINTLOADEXEC pfnLoadExec, PFNSSMINTLOADDONE pfnLoadDone);
1203	VMMR3DECL(int)
1204	SSMR3RegisterExternal(PUVM pUVM, const char *pszName, uint32_t uInstance, uint32_t uVersion, size_t cbGuess,
1205	PFNSSMEXTLIVEPREP pfnLivePrep, PFNSSMEXTLIVEEXEC pfnLiveExec, PFNSSMEXTLIVEVOTE pfnLiveVote,
1206	PFNSSMEXTSAVEPREP pfnSavePrep, PFNSSMEXTSAVEEXEC pfnSaveExec, PFNSSMEXTSAVEDONE pfnSaveDone,
1207	PFNSSMEXTLOADPREP pfnLoadPrep, PFNSSMEXTLOADEXEC pfnLoadExec, PFNSSMEXTLOADDONE pfnLoadDone, void *pvUser);
1208	VMMR3DECL(int) SSMR3RegisterStub(PVM pVM, const char *pszName, uint32_t uInstance);
1209	VMMR3_INT_DECL(int) SSMR3DeregisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t uInstance);
1210	VMMR3_INT_DECL(int) SSMR3DeregisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName, uint32_t uInstance);
1211	VMMR3_INT_DECL(int) SSMR3DeregisterUsb(PVM pVM, PPDMUSBINS pUsbIns, const char *pszName, uint32_t uInstance);
1212	VMMR3DECL(int) SSMR3DeregisterInternal(PVM pVM, const char *pszName);
1213	VMMR3DECL(int) SSMR3DeregisterExternal(PUVM pUVM, const char *pszName);
1214	VMMR3DECL(int) SSMR3Save(PVM pVM, const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOpsUser, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser);
1215	VMMR3_INT_DECL(int) SSMR3LiveSave(PVM pVM, uint32_t cMsMaxDowntime,
1216	const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOps,
1217	SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser,
1218	PSSMHANDLE *ppSSM);
1219	VMMR3_INT_DECL(int) SSMR3LiveDoStep1(PSSMHANDLE pSSM);
1220	VMMR3_INT_DECL(int) SSMR3LiveDoStep2(PSSMHANDLE pSSM);
1221	VMMR3_INT_DECL(int) SSMR3LiveDone(PSSMHANDLE pSSM);
1222	VMMR3DECL(int) SSMR3Load(PVM pVM, const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOpsUser,
1223	SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser);
1224	VMMR3DECL(int) SSMR3ValidateFile(const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOps,
1225	bool fChecksumIt);
1226	VMMR3DECL(int) SSMR3Open(const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOps,
1227	unsigned fFlags, PSSMHANDLE *ppSSM);
1228	VMMR3DECL(int) SSMR3Close(PSSMHANDLE pSSM);
1229	VMMR3DECL(int) SSMR3Seek(PSSMHANDLE pSSM, const char pszUnit, uint32_t iInstance, uint32_t piVersion);
1230	VMMR3DECL(int) SSMR3HandleGetStatus(PSSMHANDLE pSSM);
1231	VMMR3DECL(int) SSMR3HandleSetStatus(PSSMHANDLE pSSM, int iStatus);
1232	VMMR3DECL(SSMAFTER) SSMR3HandleGetAfter(PSSMHANDLE pSSM);
1233	VMMR3DECL(bool) SSMR3HandleIsLiveSave(PSSMHANDLE pSSM);
1234	VMMR3DECL(uint32_t) SSMR3HandleMaxDowntime(PSSMHANDLE pSSM);
1235	VMMR3DECL(uint32_t) SSMR3HandleHostBits(PSSMHANDLE pSSM);
1236	VMMR3DECL(uint32_t) SSMR3HandleRevision(PSSMHANDLE pSSM);
1237	VMMR3DECL(uint32_t) SSMR3HandleVersion(PSSMHANDLE pSSM);
1238	VMMR3DECL(const char *) SSMR3HandleHostOSAndArch(PSSMHANDLE pSSM);
1239	VMMR3_INT_DECL(int) SSMR3HandleSetGCPtrSize(PSSMHANDLE pSSM, unsigned cbGCPtr);
1240	VMMR3DECL(void) SSMR3HandleReportLivePercent(PSSMHANDLE pSSM, unsigned uPercent);
1241	#ifdef DEBUG
1242	VMMR3DECL(uint64_t) SSMR3HandleTellInUnit(PSSMHANDLE pSSM);
1243	#endif
1244	VMMR3DECL(int) SSMR3Cancel(PUVM pUVM);
1245
1246
1247	/** Save operations.
1248	* @{
1249	*/
1250	VMMR3DECL(int) SSMR3PutStruct(PSSMHANDLE pSSM, const void *pvStruct, PCSSMFIELD paFields);
1251	VMMR3DECL(int) SSMR3PutStructEx(PSSMHANDLE pSSM, const void pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void pvUser);
1252	VMMR3DECL(int) SSMR3PutBool(PSSMHANDLE pSSM, bool fBool);
1253	VMMR3DECL(int) SSMR3PutU8(PSSMHANDLE pSSM, uint8_t u8);
1254	VMMR3DECL(int) SSMR3PutS8(PSSMHANDLE pSSM, int8_t i8);
1255	VMMR3DECL(int) SSMR3PutU16(PSSMHANDLE pSSM, uint16_t u16);
1256	VMMR3DECL(int) SSMR3PutS16(PSSMHANDLE pSSM, int16_t i16);
1257	VMMR3DECL(int) SSMR3PutU32(PSSMHANDLE pSSM, uint32_t u32);
1258	VMMR3DECL(int) SSMR3PutS32(PSSMHANDLE pSSM, int32_t i32);
1259	VMMR3DECL(int) SSMR3PutU64(PSSMHANDLE pSSM, uint64_t u64);
1260	VMMR3DECL(int) SSMR3PutS64(PSSMHANDLE pSSM, int64_t i64);
1261	VMMR3DECL(int) SSMR3PutU128(PSSMHANDLE pSSM, uint128_t u128);
1262	VMMR3DECL(int) SSMR3PutS128(PSSMHANDLE pSSM, int128_t i128);
1263	VMMR3DECL(int) SSMR3PutUInt(PSSMHANDLE pSSM, RTUINT u);
1264	VMMR3DECL(int) SSMR3PutSInt(PSSMHANDLE pSSM, RTINT i);
1265	VMMR3DECL(int) SSMR3PutGCUInt(PSSMHANDLE pSSM, RTGCUINT u);
1266	VMMR3DECL(int) SSMR3PutGCUIntReg(PSSMHANDLE pSSM, RTGCUINTREG u);
1267	VMMR3DECL(int) SSMR3PutGCPhys32(PSSMHANDLE pSSM, RTGCPHYS32 GCPhys);
1268	VMMR3DECL(int) SSMR3PutGCPhys64(PSSMHANDLE pSSM, RTGCPHYS64 GCPhys);
1269	VMMR3DECL(int) SSMR3PutGCPhys(PSSMHANDLE pSSM, RTGCPHYS GCPhys);
1270	VMMR3DECL(int) SSMR3PutGCPtr(PSSMHANDLE pSSM, RTGCPTR GCPtr);
1271	VMMR3DECL(int) SSMR3PutGCUIntPtr(PSSMHANDLE pSSM, RTGCUINTPTR GCPtr);
1272	VMMR3DECL(int) SSMR3PutRCPtr(PSSMHANDLE pSSM, RTRCPTR RCPtr);
1273	VMMR3DECL(int) SSMR3PutIOPort(PSSMHANDLE pSSM, RTIOPORT IOPort);
1274	VMMR3DECL(int) SSMR3PutSel(PSSMHANDLE pSSM, RTSEL Sel);
1275	VMMR3DECL(int) SSMR3PutMem(PSSMHANDLE pSSM, const void *pv, size_t cb);
1276	VMMR3DECL(int) SSMR3PutStrZ(PSSMHANDLE pSSM, const char *psz);
1277	/** @} */
1278
1279
1280
1281	/** Load operations.
1282	* @{
1283	*/
1284	VMMR3DECL(int) SSMR3GetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields);
1285	VMMR3DECL(int) SSMR3GetStructEx(PSSMHANDLE pSSM, void pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void pvUser);
1286	VMMR3DECL(int) SSMR3GetBool(PSSMHANDLE pSSM, bool *pfBool);
1287	VMMR3DECL(int) SSMR3GetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool);
1288	VMMR3DECL(int) SSMR3GetU8(PSSMHANDLE pSSM, uint8_t *pu8);
1289	VMMR3DECL(int) SSMR3GetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8);
1290	VMMR3DECL(int) SSMR3GetS8(PSSMHANDLE pSSM, int8_t *pi8);
1291	VMMR3DECL(int) SSMR3GetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8);
1292	VMMR3DECL(int) SSMR3GetU16(PSSMHANDLE pSSM, uint16_t *pu16);
1293	VMMR3DECL(int) SSMR3GetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16);
1294	VMMR3DECL(int) SSMR3GetS16(PSSMHANDLE pSSM, int16_t *pi16);
1295	VMMR3DECL(int) SSMR3GetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16);
1296	VMMR3DECL(int) SSMR3GetU32(PSSMHANDLE pSSM, uint32_t *pu32);
1297	VMMR3DECL(int) SSMR3GetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32);
1298	VMMR3DECL(int) SSMR3GetS32(PSSMHANDLE pSSM, int32_t *pi32);
1299	VMMR3DECL(int) SSMR3GetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32);
1300	VMMR3DECL(int) SSMR3GetU64(PSSMHANDLE pSSM, uint64_t *pu64);
1301	VMMR3DECL(int) SSMR3GetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64);
1302	VMMR3DECL(int) SSMR3GetS64(PSSMHANDLE pSSM, int64_t *pi64);
1303	VMMR3DECL(int) SSMR3GetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64);
1304	VMMR3DECL(int) SSMR3GetU128(PSSMHANDLE pSSM, uint128_t *pu128);
1305	VMMR3DECL(int) SSMR3GetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128);
1306	VMMR3DECL(int) SSMR3GetS128(PSSMHANDLE pSSM, int128_t *pi128);
1307	VMMR3DECL(int) SSMR3GetS128V(PSSMHANDLE pSSM, int128_t volatile *pi128);
1308	VMMR3DECL(int) SSMR3GetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys);
1309	VMMR3DECL(int) SSMR3GetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys);
1310	VMMR3DECL(int) SSMR3GetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys);
1311	VMMR3DECL(int) SSMR3GetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys);
1312	VMMR3DECL(int) SSMR3GetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys);
1313	VMMR3DECL(int) SSMR3GetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys);
1314	VMMR3DECL(int) SSMR3GetUInt(PSSMHANDLE pSSM, PRTUINT pu);
1315	VMMR3DECL(int) SSMR3GetSInt(PSSMHANDLE pSSM, PRTINT pi);
1316	VMMR3DECL(int) SSMR3GetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu);
1317	VMMR3DECL(int) SSMR3GetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu);
1318	VMMR3DECL(int) SSMR3GetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr);
1319	VMMR3DECL(int) SSMR3GetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr);
1320	VMMR3DECL(int) SSMR3GetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr);
1321	VMMR3DECL(int) SSMR3GetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort);
1322	VMMR3DECL(int) SSMR3GetSel(PSSMHANDLE pSSM, PRTSEL pSel);
1323	VMMR3DECL(int) SSMR3GetMem(PSSMHANDLE pSSM, void *pv, size_t cb);
1324	VMMR3DECL(int) SSMR3GetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax);
1325	VMMR3DECL(int) SSMR3GetStrZEx(PSSMHANDLE pSSM, char psz, size_t cbMax, size_t pcbStr);
1326	VMMR3DECL(int) SSMR3Skip(PSSMHANDLE pSSM, size_t cb);
1327	VMMR3DECL(int) SSMR3SkipToEndOfUnit(PSSMHANDLE pSSM);
1328	VMMR3DECL(int) SSMR3SetLoadError(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7);
1329	VMMR3DECL(int) SSMR3SetLoadErrorV(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(6, 0);
1330	VMMR3DECL(int) SSMR3SetCfgError(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(5, 6);
1331	VMMR3DECL(int) SSMR3SetCfgErrorV(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(5, 0);
1332
1333	/** Wrapper around SSMR3GetU32 for simplifying getting enum values saved as uint32_t. */
1334	# define SSM_GET_ENUM32_RET(a_pSSM, a_enmDst, a_EnumType) \
1335	do { \
1336	uint32_t u32GetEnumTmp = 0; \
1337	int rcGetEnum32Tmp = SSMR3GetU32((a_pSSM), &u32GetEnumTmp); \
1338	AssertRCReturn(rcGetEnum32Tmp, rcGetEnum32Tmp); \
1339	(a_enmDst) = (a_EnumType)u32GetEnumTmp; \
1340	AssertCompile(sizeof(a_EnumType) == sizeof(u32GetEnumTmp)); \
1341	} while (0)
1342
1343	/** @} */
1344
1345	/** @} */
1346	#endif /* IN_RING3 */
1347
1348
1349	/** @} */
1350
1351	RT_C_DECLS_END
1352
1353	#endif /* !VBOX_INCLUDED_vmm_ssm_h */
1354

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

source: vbox/trunk/include/VBox/vmm/ssm.h@ 96445

Download in other formats: