PGMSavedState.cpp@ 65299

Last change on this file since 65299 was 64327, checked in by vboxsync, 8 years ago
PGM: Allow pre-registered MMIO regions up to 1TB in size by using multiple registration chunks (just like we do for RAM). The limits are now defined in VBox/param.h instead of being hardcoded in the sources.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 129.2 KB

Line
1	/* $Id: PGMSavedState.cpp 64327 2016-10-19 17:42:18Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager and Monitor, The Saved State Part.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PGM
23	#include <VBox/vmm/pgm.h>
24	#include <VBox/vmm/stam.h>
25	#include <VBox/vmm/ssm.h>
26	#include <VBox/vmm/pdmdrv.h>
27	#include <VBox/vmm/pdmdev.h>
28	#include "PGMInternal.h"
29	#include <VBox/vmm/vm.h>
30	#include "PGMInline.h"
31
32	#include <VBox/param.h>
33	#include <VBox/err.h>
34	#include <VBox/vmm/ftm.h>
35
36	#include <iprt/asm.h>
37	#include <iprt/assert.h>
38	#include <iprt/crc.h>
39	#include <iprt/mem.h>
40	#include <iprt/sha.h>
41	#include <iprt/string.h>
42	#include <iprt/thread.h>
43
44
45	/*********************************************************************************************************************************
46	* Defined Constants And Macros *
47	*********************************************************************************************************************************/
48	/** Saved state data unit version. */
49	#define PGM_SAVED_STATE_VERSION 14
50	/** Saved state data unit version before the PAE PDPE registers. */
51	#define PGM_SAVED_STATE_VERSION_PRE_PAE 13
52	/** Saved state data unit version after this includes ballooned page flags in
53	* the state (see @bugref{5515}). */
54	#define PGM_SAVED_STATE_VERSION_BALLOON_BROKEN 12
55	/** Saved state before the balloon change. */
56	#define PGM_SAVED_STATE_VERSION_PRE_BALLOON 11
57	/** Saved state data unit version used during 3.1 development, misses the RAM
58	* config. */
59	#define PGM_SAVED_STATE_VERSION_NO_RAM_CFG 10
60	/** Saved state data unit version for 3.0 (pre teleportation). */
61	#define PGM_SAVED_STATE_VERSION_3_0_0 9
62	/** Saved state data unit version for 2.2.2 and later. */
63	#define PGM_SAVED_STATE_VERSION_2_2_2 8
64	/** Saved state data unit version for 2.2.0. */
65	#define PGM_SAVED_STATE_VERSION_RR_DESC 7
66	/** Saved state data unit version. */
67	#define PGM_SAVED_STATE_VERSION_OLD_PHYS_CODE 6
68
69
70	/** @name Sparse state record types
71	* @{ */
72	/** Zero page. No data. */
73	#define PGM_STATE_REC_RAM_ZERO UINT8_C(0x00)
74	/** Raw page. */
75	#define PGM_STATE_REC_RAM_RAW UINT8_C(0x01)
76	/** Raw MMIO2 page. */
77	#define PGM_STATE_REC_MMIO2_RAW UINT8_C(0x02)
78	/** Zero MMIO2 page. */
79	#define PGM_STATE_REC_MMIO2_ZERO UINT8_C(0x03)
80	/** Virgin ROM page. Followed by protection (8-bit) and the raw bits. */
81	#define PGM_STATE_REC_ROM_VIRGIN UINT8_C(0x04)
82	/** Raw shadowed ROM page. The protection (8-bit) precedes the raw bits. */
83	#define PGM_STATE_REC_ROM_SHW_RAW UINT8_C(0x05)
84	/** Zero shadowed ROM page. The protection (8-bit) is the only payload. */
85	#define PGM_STATE_REC_ROM_SHW_ZERO UINT8_C(0x06)
86	/** ROM protection (8-bit). */
87	#define PGM_STATE_REC_ROM_PROT UINT8_C(0x07)
88	/** Ballooned page. No data. */
89	#define PGM_STATE_REC_RAM_BALLOONED UINT8_C(0x08)
90	/** The last record type. */
91	#define PGM_STATE_REC_LAST PGM_STATE_REC_RAM_BALLOONED
92	/** End marker. */
93	#define PGM_STATE_REC_END UINT8_C(0xff)
94	/** Flag indicating that the data is preceded by the page address.
95	* For RAW pages this is a RTGCPHYS. For MMIO2 and ROM pages this is a 8-bit
96	* range ID and a 32-bit page index.
97	*/
98	#define PGM_STATE_REC_FLAG_ADDR UINT8_C(0x80)
99	/** @} */
100
101	/** The CRC-32 for a zero page. */
102	#define PGM_STATE_CRC32_ZERO_PAGE UINT32_C(0xc71c0011)
103	/** The CRC-32 for a zero half page. */
104	#define PGM_STATE_CRC32_ZERO_HALF_PAGE UINT32_C(0xf1e8ba9e)
105
106
107
108	/** @name Old Page types used in older saved states.
109	* @{ */
110	/** Old saved state: The usual invalid zero entry. */
111	#define PGMPAGETYPE_OLD_INVALID 0
112	/** Old saved state: RAM page. (RWX) */
113	#define PGMPAGETYPE_OLD_RAM 1
114	/** Old saved state: MMIO2 page. (RWX) */
115	#define PGMPAGETYPE_OLD_MMIO2 1
116	/** Old saved state: MMIO2 page aliased over an MMIO page. (RWX)
117	* See PGMHandlerPhysicalPageAlias(). */
118	#define PGMPAGETYPE_OLD_MMIO2_ALIAS_MMIO 2
119	/** Old saved state: Shadowed ROM. (RWX) */
120	#define PGMPAGETYPE_OLD_ROM_SHADOW 3
121	/** Old saved state: ROM page. (R-X) */
122	#define PGMPAGETYPE_OLD_ROM 4
123	/** Old saved state: MMIO page. (---) */
124	#define PGMPAGETYPE_OLD_MMIO 5
125	/** @} */
126
127
128	/*********************************************************************************************************************************
129	* Structures and Typedefs *
130	*********************************************************************************************************************************/
131	/** For loading old saved states. (pre-smp) */
132	typedef struct
133	{
134	/** If set no conflict checks are required. (boolean) */
135	bool fMappingsFixed;
136	/** Size of fixed mapping */
137	uint32_t cbMappingFixed;
138	/** Base address (GC) of fixed mapping */
139	RTGCPTR GCPtrMappingFixed;
140	/** A20 gate mask.
141	* Our current approach to A20 emulation is to let REM do it and don't bother
142	* anywhere else. The interesting guests will be operating with it enabled anyway.
143	* But should the need arise, we'll subject physical addresses to this mask. */
144	RTGCPHYS GCPhysA20Mask;
145	/** A20 gate state - boolean! */
146	bool fA20Enabled;
147	/** The guest paging mode. */
148	PGMMODE enmGuestMode;
149	} PGMOLD;
150
151
152	/*********************************************************************************************************************************
153	* Global Variables *
154	*********************************************************************************************************************************/
155	/** PGM fields to save/load. */
156
157	static const SSMFIELD s_aPGMFields[] =
158	{
159	SSMFIELD_ENTRY( PGM, fMappingsFixed),
160	SSMFIELD_ENTRY_GCPTR( PGM, GCPtrMappingFixed),
161	SSMFIELD_ENTRY( PGM, cbMappingFixed),
162	SSMFIELD_ENTRY( PGM, cBalloonedPages),
163	SSMFIELD_ENTRY_TERM()
164	};
165
166	static const SSMFIELD s_aPGMFieldsPreBalloon[] =
167	{
168	SSMFIELD_ENTRY( PGM, fMappingsFixed),
169	SSMFIELD_ENTRY_GCPTR( PGM, GCPtrMappingFixed),
170	SSMFIELD_ENTRY( PGM, cbMappingFixed),
171	SSMFIELD_ENTRY_TERM()
172	};
173
174	static const SSMFIELD s_aPGMCpuFields[] =
175	{
176	SSMFIELD_ENTRY( PGMCPU, fA20Enabled),
177	SSMFIELD_ENTRY_GCPHYS( PGMCPU, GCPhysA20Mask),
178	SSMFIELD_ENTRY( PGMCPU, enmGuestMode),
179	SSMFIELD_ENTRY( PGMCPU, aGCPhysGstPaePDs[0]),
180	SSMFIELD_ENTRY( PGMCPU, aGCPhysGstPaePDs[1]),
181	SSMFIELD_ENTRY( PGMCPU, aGCPhysGstPaePDs[2]),
182	SSMFIELD_ENTRY( PGMCPU, aGCPhysGstPaePDs[3]),
183	SSMFIELD_ENTRY_TERM()
184	};
185
186	static const SSMFIELD s_aPGMCpuFieldsPrePae[] =
187	{
188	SSMFIELD_ENTRY( PGMCPU, fA20Enabled),
189	SSMFIELD_ENTRY_GCPHYS( PGMCPU, GCPhysA20Mask),
190	SSMFIELD_ENTRY( PGMCPU, enmGuestMode),
191	SSMFIELD_ENTRY_TERM()
192	};
193
194	static const SSMFIELD s_aPGMFields_Old[] =
195	{
196	SSMFIELD_ENTRY( PGMOLD, fMappingsFixed),
197	SSMFIELD_ENTRY_GCPTR( PGMOLD, GCPtrMappingFixed),
198	SSMFIELD_ENTRY( PGMOLD, cbMappingFixed),
199	SSMFIELD_ENTRY( PGMOLD, fA20Enabled),
200	SSMFIELD_ENTRY_GCPHYS( PGMOLD, GCPhysA20Mask),
201	SSMFIELD_ENTRY( PGMOLD, enmGuestMode),
202	SSMFIELD_ENTRY_TERM()
203	};
204
205
206	/**
207	* Find the ROM tracking structure for the given page.
208	*
209	* @returns Pointer to the ROM page structure. NULL if the caller didn't check
210	* that it's a ROM page.
211	* @param pVM The cross context VM structure.
212	* @param GCPhys The address of the ROM page.
213	*/
214	static PPGMROMPAGE pgmR3GetRomPage(PVM pVM, RTGCPHYS GCPhys) /** @todo change this to take a hint. */
215	{
216	for (PPGMROMRANGE pRomRange = pVM->pgm.s.CTX_SUFF(pRomRanges);
217	pRomRange;
218	pRomRange = pRomRange->CTX_SUFF(pNext))
219	{
220	RTGCPHYS off = GCPhys - pRomRange->GCPhys;
221	if (GCPhys - pRomRange->GCPhys < pRomRange->cb)
222	return &pRomRange->aPages[off >> PAGE_SHIFT];
223	}
224	return NULL;
225	}
226
227
228	/**
229	* Prepares the ROM pages for a live save.
230	*
231	* @returns VBox status code.
232	* @param pVM The cross context VM structure.
233	*/
234	static int pgmR3PrepRomPages(PVM pVM)
235	{
236	/*
237	* Initialize the live save tracking in the ROM page descriptors.
238	*/
239	pgmLock(pVM);
240	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
241	{
242	PPGMRAMRANGE pRamHint = NULL;;
243	uint32_t const cPages = pRom->cb >> PAGE_SHIFT;
244
245	for (uint32_t iPage = 0; iPage < cPages; iPage++)
246	{
247	pRom->aPages[iPage].LiveSave.u8Prot = (uint8_t)PGMROMPROT_INVALID;
248	pRom->aPages[iPage].LiveSave.fWrittenTo = false;
249	pRom->aPages[iPage].LiveSave.fDirty = true;
250	pRom->aPages[iPage].LiveSave.fDirtiedRecently = true;
251	if (!(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED))
252	{
253	if (PGMROMPROT_IS_ROM(pRom->aPages[iPage].enmProt))
254	pRom->aPages[iPage].LiveSave.fWrittenTo = !PGM_PAGE_IS_ZERO(&pRom->aPages[iPage].Shadow) && !PGM_PAGE_IS_BALLOONED(&pRom->aPages[iPage].Shadow);
255	else
256	{
257	RTGCPHYS GCPhys = pRom->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
258	PPGMPAGE pPage;
259	int rc = pgmPhysGetPageWithHintEx(pVM, GCPhys, &pPage, &pRamHint);
260	AssertLogRelMsgRC(rc, ("%Rrc GCPhys=%RGp\n", rc, GCPhys));
261	if (RT_SUCCESS(rc))
262	pRom->aPages[iPage].LiveSave.fWrittenTo = !PGM_PAGE_IS_ZERO(pPage) && !PGM_PAGE_IS_BALLOONED(pPage);
263	else
264	pRom->aPages[iPage].LiveSave.fWrittenTo = !PGM_PAGE_IS_ZERO(&pRom->aPages[iPage].Shadow) && !PGM_PAGE_IS_BALLOONED(&pRom->aPages[iPage].Shadow);
265	}
266	}
267	}
268
269	pVM->pgm.s.LiveSave.Rom.cDirtyPages += cPages;
270	if (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
271	pVM->pgm.s.LiveSave.Rom.cDirtyPages += cPages;
272	}
273	pgmUnlock(pVM);
274
275	return VINF_SUCCESS;
276	}
277
278
279	/**
280	* Assigns IDs to the ROM ranges and saves them.
281	*
282	* @returns VBox status code.
283	* @param pVM The cross context VM structure.
284	* @param pSSM Saved state handle.
285	*/
286	static int pgmR3SaveRomRanges(PVM pVM, PSSMHANDLE pSSM)
287	{
288	pgmLock(pVM);
289	uint8_t id = 1;
290	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3, id++)
291	{
292	pRom->idSavedState = id;
293	SSMR3PutU8(pSSM, id);
294	SSMR3PutStrZ(pSSM, ""); /* device name */
295	SSMR3PutU32(pSSM, 0); /* device instance */
296	SSMR3PutU8(pSSM, 0); /* region */
297	SSMR3PutStrZ(pSSM, pRom->pszDesc);
298	SSMR3PutGCPhys(pSSM, pRom->GCPhys);
299	int rc = SSMR3PutGCPhys(pSSM, pRom->cb);
300	if (RT_FAILURE(rc))
301	break;
302	}
303	pgmUnlock(pVM);
304	return SSMR3PutU8(pSSM, UINT8_MAX);
305	}
306
307
308	/**
309	* Loads the ROM range ID assignments.
310	*
311	* @returns VBox status code.
312	*
313	* @param pVM The cross context VM structure.
314	* @param pSSM The saved state handle.
315	*/
316	static int pgmR3LoadRomRanges(PVM pVM, PSSMHANDLE pSSM)
317	{
318	PGM_LOCK_ASSERT_OWNER(pVM);
319
320	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
321	pRom->idSavedState = UINT8_MAX;
322
323	for (;;)
324	{
325	/*
326	* Read the data.
327	*/
328	uint8_t id;
329	int rc = SSMR3GetU8(pSSM, &id);
330	if (RT_FAILURE(rc))
331	return rc;
332	if (id == UINT8_MAX)
333	{
334	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
335	AssertLogRelMsg(pRom->idSavedState != UINT8_MAX,
336	("The \"%s\" ROM was not found in the saved state. Probably due to some misconfiguration\n",
337	pRom->pszDesc));
338	return VINF_SUCCESS; /* the end */
339	}
340	AssertLogRelReturn(id != 0, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
341
342	char szDevName[RT_SIZEOFMEMB(PDMDEVREG, szName)];
343	rc = SSMR3GetStrZ(pSSM, szDevName, sizeof(szDevName));
344	AssertLogRelRCReturn(rc, rc);
345
346	uint32_t uInstance;
347	SSMR3GetU32(pSSM, &uInstance);
348	uint8_t iRegion;
349	SSMR3GetU8(pSSM, &iRegion);
350
351	char szDesc[64];
352	rc = SSMR3GetStrZ(pSSM, szDesc, sizeof(szDesc));
353	AssertLogRelRCReturn(rc, rc);
354
355	RTGCPHYS GCPhys;
356	SSMR3GetGCPhys(pSSM, &GCPhys);
357	RTGCPHYS cb;
358	rc = SSMR3GetGCPhys(pSSM, &cb);
359	if (RT_FAILURE(rc))
360	return rc;
361	AssertLogRelMsgReturn(!(GCPhys & PAGE_OFFSET_MASK), ("GCPhys=%RGp %s\n", GCPhys, szDesc), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
362	AssertLogRelMsgReturn(!(cb & PAGE_OFFSET_MASK), ("cb=%RGp %s\n", cb, szDesc), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
363
364	/*
365	* Locate a matching ROM range.
366	*/
367	AssertLogRelMsgReturn( uInstance == 0
368	&& iRegion == 0
369	&& szDevName[0] == '\0',
370	("GCPhys=%RGp %s\n", GCPhys, szDesc),
371	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
372	PPGMROMRANGE pRom;
373	for (pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
374	{
375	if ( pRom->idSavedState == UINT8_MAX
376	&& !strcmp(pRom->pszDesc, szDesc))
377	{
378	pRom->idSavedState = id;
379	break;
380	}
381	}
382	if (!pRom)
383	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("ROM at %RGp by the name '%s' was not found"), GCPhys, szDesc);
384	} /* forever */
385	}
386
387
388	/**
389	* Scan ROM pages.
390	*
391	* @param pVM The cross context VM structure.
392	*/
393	static void pgmR3ScanRomPages(PVM pVM)
394	{
395	/*
396	* The shadow ROMs.
397	*/
398	pgmLock(pVM);
399	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
400	{
401	if (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
402	{
403	uint32_t const cPages = pRom->cb >> PAGE_SHIFT;
404	for (uint32_t iPage = 0; iPage < cPages; iPage++)
405	{
406	PPGMROMPAGE pRomPage = &pRom->aPages[iPage];
407	if (pRomPage->LiveSave.fWrittenTo)
408	{
409	pRomPage->LiveSave.fWrittenTo = false;
410	if (!pRomPage->LiveSave.fDirty)
411	{
412	pRomPage->LiveSave.fDirty = true;
413	pVM->pgm.s.LiveSave.Rom.cReadyPages--;
414	pVM->pgm.s.LiveSave.Rom.cDirtyPages++;
415	}
416	pRomPage->LiveSave.fDirtiedRecently = true;
417	}
418	else
419	pRomPage->LiveSave.fDirtiedRecently = false;
420	}
421	}
422	}
423	pgmUnlock(pVM);
424	}
425
426
427	/**
428	* Takes care of the virgin ROM pages in the first pass.
429	*
430	* This is an attempt at simplifying the handling of ROM pages a little bit.
431	* This ASSUMES that no new ROM ranges will be added and that they won't be
432	* relinked in any way.
433	*
434	* @param pVM The cross context VM structure.
435	* @param pSSM The SSM handle.
436	* @param fLiveSave Whether we're in a live save or not.
437	*/
438	static int pgmR3SaveRomVirginPages(PVM pVM, PSSMHANDLE pSSM, bool fLiveSave)
439	{
440	if (FTMIsDeltaLoadSaveActive(pVM))
441	return VINF_SUCCESS; /* nothing to do as nothing has changed here */
442
443	pgmLock(pVM);
444	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
445	{
446	uint32_t const cPages = pRom->cb >> PAGE_SHIFT;
447	for (uint32_t iPage = 0; iPage < cPages; iPage++)
448	{
449	RTGCPHYS GCPhys = pRom->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
450	PGMROMPROT enmProt = pRom->aPages[iPage].enmProt;
451
452	/* Get the virgin page descriptor. */
453	PPGMPAGE pPage;
454	if (PGMROMPROT_IS_ROM(enmProt))
455	pPage = pgmPhysGetPage(pVM, GCPhys);
456	else
457	pPage = &pRom->aPages[iPage].Virgin;
458
459	/* Get the page bits. (Cannot use pgmPhysGCPhys2CCPtrInternalReadOnly here!) */
460	int rc = VINF_SUCCESS;
461	char abPage[PAGE_SIZE];
462	if ( !PGM_PAGE_IS_ZERO(pPage)
463	&& !PGM_PAGE_IS_BALLOONED(pPage))
464	{
465	void const *pvPage;
466	rc = pgmPhysPageMapReadOnly(pVM, pPage, GCPhys, &pvPage);
467	if (RT_SUCCESS(rc))
468	memcpy(abPage, pvPage, PAGE_SIZE);
469	}
470	else
471	ASMMemZeroPage(abPage);
472	pgmUnlock(pVM);
473	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys), rc);
474
475	/* Save it. */
476	if (iPage > 0)
477	SSMR3PutU8(pSSM, PGM_STATE_REC_ROM_VIRGIN);
478	else
479	{
480	SSMR3PutU8(pSSM, PGM_STATE_REC_ROM_VIRGIN \| PGM_STATE_REC_FLAG_ADDR);
481	SSMR3PutU8(pSSM, pRom->idSavedState);
482	SSMR3PutU32(pSSM, iPage);
483	}
484	SSMR3PutU8(pSSM, (uint8_t)enmProt);
485	rc = SSMR3PutMem(pSSM, abPage, PAGE_SIZE);
486	if (RT_FAILURE(rc))
487	return rc;
488
489	/* Update state. */
490	pgmLock(pVM);
491	pRom->aPages[iPage].LiveSave.u8Prot = (uint8_t)enmProt;
492	if (fLiveSave)
493	{
494	pVM->pgm.s.LiveSave.Rom.cDirtyPages--;
495	pVM->pgm.s.LiveSave.Rom.cReadyPages++;
496	pVM->pgm.s.LiveSave.cSavedPages++;
497	}
498	}
499	}
500	pgmUnlock(pVM);
501	return VINF_SUCCESS;
502	}
503
504
505	/**
506	* Saves dirty pages in the shadowed ROM ranges.
507	*
508	* Used by pgmR3LiveExecPart2 and pgmR3SaveExecMemory.
509	*
510	* @returns VBox status code.
511	* @param pVM The cross context VM structure.
512	* @param pSSM The SSM handle.
513	* @param fLiveSave Whether it's a live save or not.
514	* @param fFinalPass Whether this is the final pass or not.
515	*/
516	static int pgmR3SaveShadowedRomPages(PVM pVM, PSSMHANDLE pSSM, bool fLiveSave, bool fFinalPass)
517	{
518	if (FTMIsDeltaLoadSaveActive(pVM))
519	return VINF_SUCCESS; /* nothing to do as we deal with those pages separately */
520
521	/*
522	* The Shadowed ROMs.
523	*
524	* ASSUMES that the ROM ranges are fixed.
525	* ASSUMES that all the ROM ranges are mapped.
526	*/
527	pgmLock(pVM);
528	for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
529	{
530	if (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
531	{
532	uint32_t const cPages = pRom->cb >> PAGE_SHIFT;
533	uint32_t iPrevPage = cPages;
534	for (uint32_t iPage = 0; iPage < cPages; iPage++)
535	{
536	PPGMROMPAGE pRomPage = &pRom->aPages[iPage];
537	if ( !fLiveSave
538	\|\| ( pRomPage->LiveSave.fDirty
539	&& ( ( !pRomPage->LiveSave.fDirtiedRecently
540	&& !pRomPage->LiveSave.fWrittenTo)
541	\|\| fFinalPass
542	)
543	)
544	)
545	{
546	uint8_t abPage[PAGE_SIZE];
547	PGMROMPROT enmProt = pRomPage->enmProt;
548	RTGCPHYS GCPhys = pRom->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
549	PPGMPAGE pPage = PGMROMPROT_IS_ROM(enmProt) ? &pRomPage->Shadow : pgmPhysGetPage(pVM, GCPhys);
550	bool fZero = PGM_PAGE_IS_ZERO(pPage) \|\| PGM_PAGE_IS_BALLOONED(pPage); Assert(!PGM_PAGE_IS_BALLOONED(pPage)); /* Shouldn't be ballooned. */
551	int rc = VINF_SUCCESS;
552	if (!fZero)
553	{
554	void const *pvPage;
555	rc = pgmPhysPageMapReadOnly(pVM, pPage, GCPhys, &pvPage);
556	if (RT_SUCCESS(rc))
557	memcpy(abPage, pvPage, PAGE_SIZE);
558	}
559	if (fLiveSave && RT_SUCCESS(rc))
560	{
561	pRomPage->LiveSave.u8Prot = (uint8_t)enmProt;
562	pRomPage->LiveSave.fDirty = false;
563	pVM->pgm.s.LiveSave.Rom.cReadyPages++;
564	pVM->pgm.s.LiveSave.Rom.cDirtyPages--;
565	pVM->pgm.s.LiveSave.cSavedPages++;
566	}
567	pgmUnlock(pVM);
568	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys), rc);
569
570	if (iPage - 1U == iPrevPage && iPage > 0)
571	SSMR3PutU8(pSSM, (fZero ? PGM_STATE_REC_ROM_SHW_ZERO : PGM_STATE_REC_ROM_SHW_RAW));
572	else
573	{
574	SSMR3PutU8(pSSM, (fZero ? PGM_STATE_REC_ROM_SHW_ZERO : PGM_STATE_REC_ROM_SHW_RAW) \| PGM_STATE_REC_FLAG_ADDR);
575	SSMR3PutU8(pSSM, pRom->idSavedState);
576	SSMR3PutU32(pSSM, iPage);
577	}
578	rc = SSMR3PutU8(pSSM, (uint8_t)enmProt);
579	if (!fZero)
580	rc = SSMR3PutMem(pSSM, abPage, PAGE_SIZE);
581	if (RT_FAILURE(rc))
582	return rc;
583
584	pgmLock(pVM);
585	iPrevPage = iPage;
586	}
587	/*
588	* In the final pass, make sure the protection is in sync.
589	*/
590	else if ( fFinalPass
591	&& pRomPage->LiveSave.u8Prot != pRomPage->enmProt)
592	{
593	PGMROMPROT enmProt = pRomPage->enmProt;
594	pRomPage->LiveSave.u8Prot = (uint8_t)enmProt;
595	pgmUnlock(pVM);
596
597	if (iPage - 1U == iPrevPage && iPage > 0)
598	SSMR3PutU8(pSSM, PGM_STATE_REC_ROM_PROT);
599	else
600	{
601	SSMR3PutU8(pSSM, PGM_STATE_REC_ROM_PROT \| PGM_STATE_REC_FLAG_ADDR);
602	SSMR3PutU8(pSSM, pRom->idSavedState);
603	SSMR3PutU32(pSSM, iPage);
604	}
605	int rc = SSMR3PutU8(pSSM, (uint8_t)enmProt);
606	if (RT_FAILURE(rc))
607	return rc;
608
609	pgmLock(pVM);
610	iPrevPage = iPage;
611	}
612	}
613	}
614	}
615	pgmUnlock(pVM);
616	return VINF_SUCCESS;
617	}
618
619
620	/**
621	* Cleans up ROM pages after a live save.
622	*
623	* @param pVM The cross context VM structure.
624	*/
625	static void pgmR3DoneRomPages(PVM pVM)
626	{
627	NOREF(pVM);
628	}
629
630
631	/**
632	* Prepares the MMIO2 pages for a live save.
633	*
634	* @returns VBox status code.
635	* @param pVM The cross context VM structure.
636	*/
637	static int pgmR3PrepMmio2Pages(PVM pVM)
638	{
639	/*
640	* Initialize the live save tracking in the MMIO2 ranges.
641	* ASSUME nothing changes here.
642	*/
643	pgmLock(pVM);
644	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
645	{
646	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
647	{
648	uint32_t const cPages = pRegMmio->RamRange.cb >> PAGE_SHIFT;
649	pgmUnlock(pVM);
650
651	PPGMLIVESAVEMMIO2PAGE paLSPages = (PPGMLIVESAVEMMIO2PAGE)MMR3HeapAllocZ(pVM, MM_TAG_PGM, sizeof(PGMLIVESAVEMMIO2PAGE) * cPages);
652	if (!paLSPages)
653	return VERR_NO_MEMORY;
654	for (uint32_t iPage = 0; iPage < cPages; iPage++)
655	{
656	/* Initialize it as a dirty zero page. */
657	paLSPages[iPage].fDirty = true;
658	paLSPages[iPage].cUnchangedScans = 0;
659	paLSPages[iPage].fZero = true;
660	paLSPages[iPage].u32CrcH1 = PGM_STATE_CRC32_ZERO_HALF_PAGE;
661	paLSPages[iPage].u32CrcH2 = PGM_STATE_CRC32_ZERO_HALF_PAGE;
662	}
663
664	pgmLock(pVM);
665	pRegMmio->paLSPages = paLSPages;
666	pVM->pgm.s.LiveSave.Mmio2.cDirtyPages += cPages;
667	}
668	}
669	pgmUnlock(pVM);
670	return VINF_SUCCESS;
671	}
672
673
674	/**
675	* Assigns IDs to the MMIO2 ranges and saves them.
676	*
677	* @returns VBox status code.
678	* @param pVM The cross context VM structure.
679	* @param pSSM Saved state handle.
680	*/
681	static int pgmR3SaveMmio2Ranges(PVM pVM, PSSMHANDLE pSSM)
682	{
683	pgmLock(pVM);
684	uint8_t id = 1;
685	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
686	{
687	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
688	{
689	pRegMmio->idSavedState = id;
690	SSMR3PutU8(pSSM, id);
691	SSMR3PutStrZ(pSSM, pRegMmio->pDevInsR3->pReg->szName);
692	SSMR3PutU32(pSSM, pRegMmio->pDevInsR3->iInstance);
693	SSMR3PutU8(pSSM, pRegMmio->iRegion);
694	SSMR3PutStrZ(pSSM, pRegMmio->RamRange.pszDesc);
695	int rc = SSMR3PutGCPhys(pSSM, pRegMmio->RamRange.cb);
696	if (RT_FAILURE(rc))
697	break;
698	id++;
699	}
700	}
701	pgmUnlock(pVM);
702	return SSMR3PutU8(pSSM, UINT8_MAX);
703	}
704
705
706	/**
707	* Loads the MMIO2 range ID assignments.
708	*
709	* @returns VBox status code.
710	*
711	* @param pVM The cross context VM structure.
712	* @param pSSM The saved state handle.
713	*/
714	static int pgmR3LoadMmio2Ranges(PVM pVM, PSSMHANDLE pSSM)
715	{
716	PGM_LOCK_ASSERT_OWNER(pVM);
717
718	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
719	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
720	pRegMmio->idSavedState = UINT8_MAX;
721
722	for (;;)
723	{
724	/*
725	* Read the data.
726	*/
727	uint8_t id;
728	int rc = SSMR3GetU8(pSSM, &id);
729	if (RT_FAILURE(rc))
730	return rc;
731	if (id == UINT8_MAX)
732	{
733	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
734	AssertLogRelMsg( pRegMmio->idSavedState != UINT8_MAX
735	\|\| !(pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2),
736	("%s\n", pRegMmio->RamRange.pszDesc));
737	return VINF_SUCCESS; /* the end */
738	}
739	AssertLogRelReturn(id != 0, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
740
741	char szDevName[RT_SIZEOFMEMB(PDMDEVREG, szName)];
742	rc = SSMR3GetStrZ(pSSM, szDevName, sizeof(szDevName));
743	AssertLogRelRCReturn(rc, rc);
744
745	uint32_t uInstance;
746	SSMR3GetU32(pSSM, &uInstance);
747	uint8_t iRegion;
748	SSMR3GetU8(pSSM, &iRegion);
749
750	char szDesc[64];
751	rc = SSMR3GetStrZ(pSSM, szDesc, sizeof(szDesc));
752	AssertLogRelRCReturn(rc, rc);
753
754	RTGCPHYS cb;
755	rc = SSMR3GetGCPhys(pSSM, &cb);
756	AssertLogRelMsgReturn(!(cb & PAGE_OFFSET_MASK), ("cb=%RGp %s\n", cb, szDesc), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
757
758	/*
759	* Locate a matching MMIO2 range.
760	*/
761	PPGMREGMMIORANGE pRegMmio;
762	for (pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
763	{
764	if ( pRegMmio->idSavedState == UINT8_MAX
765	&& pRegMmio->iRegion == iRegion
766	&& pRegMmio->pDevInsR3->iInstance == uInstance
767	&& (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
768	&& !strcmp(pRegMmio->pDevInsR3->pReg->szName, szDevName))
769	{
770	pRegMmio->idSavedState = id;
771	break;
772	}
773	}
774	if (!pRegMmio)
775	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Failed to locate a MMIO2 range called '%s' owned by %s/%u, region %d"),
776	szDesc, szDevName, uInstance, iRegion);
777
778	/*
779	* Validate the configuration, the size of the MMIO2 region should be
780	* the same.
781	*/
782	if (cb != pRegMmio->RamRange.cb)
783	{
784	LogRel(("PGM: MMIO2 region \"%s\" size mismatch: saved=%RGp config=%RGp\n",
785	pRegMmio->RamRange.pszDesc, cb, pRegMmio->RamRange.cb));
786	if (cb > pRegMmio->RamRange.cb) /* bad idea? */
787	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("MMIO2 region \"%s\" size mismatch: saved=%RGp config=%RGp"),
788	pRegMmio->RamRange.pszDesc, cb, pRegMmio->RamRange.cb);
789	}
790	} /* forever */
791	}
792
793
794	/**
795	* Scans one MMIO2 page.
796	*
797	* @returns True if changed, false if unchanged.
798	*
799	* @param pVM The cross context VM structure.
800	* @param pbPage The page bits.
801	* @param pLSPage The live save tracking structure for the page.
802	*
803	*/
804	DECLINLINE(bool) pgmR3ScanMmio2Page(PVM pVM, uint8_t const *pbPage, PPGMLIVESAVEMMIO2PAGE pLSPage)
805	{
806	/*
807	* Special handling of zero pages.
808	*/
809	bool const fZero = pLSPage->fZero;
810	if (fZero)
811	{
812	if (ASMMemIsZeroPage(pbPage))
813	{
814	/* Not modified. */
815	if (pLSPage->fDirty)
816	pLSPage->cUnchangedScans++;
817	return false;
818	}
819
820	pLSPage->fZero = false;
821	pLSPage->u32CrcH1 = RTCrc32(pbPage, PAGE_SIZE / 2);
822	}
823	else
824	{
825	/*
826	* CRC the first half, if it doesn't match the page is dirty and
827	* we won't check the 2nd half (we'll do that next time).
828	*/
829	uint32_t u32CrcH1 = RTCrc32(pbPage, PAGE_SIZE / 2);
830	if (u32CrcH1 == pLSPage->u32CrcH1)
831	{
832	uint32_t u32CrcH2 = RTCrc32(pbPage + PAGE_SIZE / 2, PAGE_SIZE / 2);
833	if (u32CrcH2 == pLSPage->u32CrcH2)
834	{
835	/* Probably not modified. */
836	if (pLSPage->fDirty)
837	pLSPage->cUnchangedScans++;
838	return false;
839	}
840
841	pLSPage->u32CrcH2 = u32CrcH2;
842	}
843	else
844	{
845	pLSPage->u32CrcH1 = u32CrcH1;
846	if ( u32CrcH1 == PGM_STATE_CRC32_ZERO_HALF_PAGE
847	&& ASMMemIsZeroPage(pbPage))
848	{
849	pLSPage->u32CrcH2 = PGM_STATE_CRC32_ZERO_HALF_PAGE;
850	pLSPage->fZero = true;
851	}
852	}
853	}
854
855	/* dirty page path */
856	pLSPage->cUnchangedScans = 0;
857	if (!pLSPage->fDirty)
858	{
859	pLSPage->fDirty = true;
860	pVM->pgm.s.LiveSave.Mmio2.cReadyPages--;
861	pVM->pgm.s.LiveSave.Mmio2.cDirtyPages++;
862	if (fZero)
863	pVM->pgm.s.LiveSave.Mmio2.cZeroPages--;
864	}
865	return true;
866	}
867
868
869	/**
870	* Scan for MMIO2 page modifications.
871	*
872	* @param pVM The cross context VM structure.
873	* @param uPass The pass number.
874	*/
875	static void pgmR3ScanMmio2Pages(PVM pVM, uint32_t uPass)
876	{
877	/*
878	* Since this is a bit expensive we lower the scan rate after a little while.
879	*/
880	if ( ( (uPass & 3) != 0
881	&& uPass > 10)
882	\|\| uPass == SSM_PASS_FINAL)
883	return;
884
885	pgmLock(pVM); /* paranoia */
886	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
887	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
888	{
889	PPGMLIVESAVEMMIO2PAGE paLSPages = pRegMmio->paLSPages;
890	uint32_t cPages = pRegMmio->RamRange.cb >> PAGE_SHIFT;
891	pgmUnlock(pVM);
892
893	for (uint32_t iPage = 0; iPage < cPages; iPage++)
894	{
895	uint8_t const pbPage = (uint8_t const )pRegMmio->pvR3 + iPage * PAGE_SIZE;
896	pgmR3ScanMmio2Page(pVM, pbPage, &paLSPages[iPage]);
897	}
898
899	pgmLock(pVM);
900	}
901	pgmUnlock(pVM);
902
903	}
904
905
906	/**
907	* Save quiescent MMIO2 pages.
908	*
909	* @returns VBox status code.
910	* @param pVM The cross context VM structure.
911	* @param pSSM The SSM handle.
912	* @param fLiveSave Whether it's a live save or not.
913	* @param uPass The pass number.
914	*/
915	static int pgmR3SaveMmio2Pages(PVM pVM, PSSMHANDLE pSSM, bool fLiveSave, uint32_t uPass)
916	{
917	/** @todo implement live saving of MMIO2 pages. (Need some way of telling the
918	* device that we wish to know about changes.) */
919
920	int rc = VINF_SUCCESS;
921	if (uPass == SSM_PASS_FINAL)
922	{
923	/*
924	* The mop up round.
925	*/
926	pgmLock(pVM);
927	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3;
928	pRegMmio && RT_SUCCESS(rc);
929	pRegMmio = pRegMmio->pNextR3)
930	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
931	{
932	PPGMLIVESAVEMMIO2PAGE paLSPages = pRegMmio->paLSPages;
933	uint8_t const pbPage = (uint8_t const )pRegMmio->RamRange.pvR3;
934	uint32_t cPages = pRegMmio->RamRange.cb >> PAGE_SHIFT;
935	uint32_t iPageLast = cPages;
936	for (uint32_t iPage = 0; iPage < cPages; iPage++, pbPage += PAGE_SIZE)
937	{
938	uint8_t u8Type;
939	if (!fLiveSave)
940	u8Type = ASMMemIsZeroPage(pbPage) ? PGM_STATE_REC_MMIO2_ZERO : PGM_STATE_REC_MMIO2_RAW;
941	else
942	{
943	/* Try figure if it's a clean page, compare the SHA-1 to be really sure. */
944	if ( !paLSPages[iPage].fDirty
945	&& !pgmR3ScanMmio2Page(pVM, pbPage, &paLSPages[iPage]))
946	{
947	if (paLSPages[iPage].fZero)
948	continue;
949
950	uint8_t abSha1Hash[RTSHA1_HASH_SIZE];
951	RTSha1(pbPage, PAGE_SIZE, abSha1Hash);
952	if (!memcmp(abSha1Hash, paLSPages[iPage].abSha1Saved, sizeof(abSha1Hash)))
953	continue;
954	}
955	u8Type = paLSPages[iPage].fZero ? PGM_STATE_REC_MMIO2_ZERO : PGM_STATE_REC_MMIO2_RAW;
956	pVM->pgm.s.LiveSave.cSavedPages++;
957	}
958
959	if (iPage != 0 && iPage == iPageLast + 1)
960	rc = SSMR3PutU8(pSSM, u8Type);
961	else
962	{
963	SSMR3PutU8(pSSM, u8Type \| PGM_STATE_REC_FLAG_ADDR);
964	SSMR3PutU8(pSSM, pRegMmio->idSavedState);
965	rc = SSMR3PutU32(pSSM, iPage);
966	}
967	if (u8Type == PGM_STATE_REC_MMIO2_RAW)
968	rc = SSMR3PutMem(pSSM, pbPage, PAGE_SIZE);
969	if (RT_FAILURE(rc))
970	break;
971	iPageLast = iPage;
972	}
973	}
974	pgmUnlock(pVM);
975	}
976	/*
977	* Reduce the rate after a little while since the current MMIO2 approach is
978	* a bit expensive.
979	* We position it two passes after the scan pass to avoid saving busy pages.
980	*/
981	else if ( uPass <= 10
982	\|\| (uPass & 3) == 2)
983	{
984	pgmLock(pVM);
985	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3;
986	pRegMmio && RT_SUCCESS(rc);
987	pRegMmio = pRegMmio->pNextR3)
988	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
989	{
990	PPGMLIVESAVEMMIO2PAGE paLSPages = pRegMmio->paLSPages;
991	uint8_t const pbPage = (uint8_t const )pRegMmio->RamRange.pvR3;
992	uint32_t cPages = pRegMmio->RamRange.cb >> PAGE_SHIFT;
993	uint32_t iPageLast = cPages;
994	pgmUnlock(pVM);
995
996	for (uint32_t iPage = 0; iPage < cPages; iPage++, pbPage += PAGE_SIZE)
997	{
998	/* Skip clean pages and pages which hasn't quiesced. */
999	if (!paLSPages[iPage].fDirty)
1000	continue;
1001	if (paLSPages[iPage].cUnchangedScans < 3)
1002	continue;
1003	if (pgmR3ScanMmio2Page(pVM, pbPage, &paLSPages[iPage]))
1004	continue;
1005
1006	/* Save it. */
1007	bool const fZero = paLSPages[iPage].fZero;
1008	uint8_t abPage[PAGE_SIZE];
1009	if (!fZero)
1010	{
1011	memcpy(abPage, pbPage, PAGE_SIZE);
1012	RTSha1(abPage, PAGE_SIZE, paLSPages[iPage].abSha1Saved);
1013	}
1014
1015	uint8_t u8Type = paLSPages[iPage].fZero ? PGM_STATE_REC_MMIO2_ZERO : PGM_STATE_REC_MMIO2_RAW;
1016	if (iPage != 0 && iPage == iPageLast + 1)
1017	rc = SSMR3PutU8(pSSM, u8Type);
1018	else
1019	{
1020	SSMR3PutU8(pSSM, u8Type \| PGM_STATE_REC_FLAG_ADDR);
1021	SSMR3PutU8(pSSM, pRegMmio->idSavedState);
1022	rc = SSMR3PutU32(pSSM, iPage);
1023	}
1024	if (u8Type == PGM_STATE_REC_MMIO2_RAW)
1025	rc = SSMR3PutMem(pSSM, abPage, PAGE_SIZE);
1026	if (RT_FAILURE(rc))
1027	break;
1028
1029	/* Housekeeping. */
1030	paLSPages[iPage].fDirty = false;
1031	pVM->pgm.s.LiveSave.Mmio2.cDirtyPages--;
1032	pVM->pgm.s.LiveSave.Mmio2.cReadyPages++;
1033	if (u8Type == PGM_STATE_REC_MMIO2_ZERO)
1034	pVM->pgm.s.LiveSave.Mmio2.cZeroPages++;
1035	pVM->pgm.s.LiveSave.cSavedPages++;
1036	iPageLast = iPage;
1037	}
1038
1039	pgmLock(pVM);
1040	}
1041	pgmUnlock(pVM);
1042	}
1043
1044	return rc;
1045	}
1046
1047
1048	/**
1049	* Cleans up MMIO2 pages after a live save.
1050	*
1051	* @param pVM The cross context VM structure.
1052	*/
1053	static void pgmR3DoneMmio2Pages(PVM pVM)
1054	{
1055	/*
1056	* Free the tracking structures for the MMIO2 pages.
1057	* We do the freeing outside the lock in case the VM is running.
1058	*/
1059	pgmLock(pVM);
1060	for (PPGMREGMMIORANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
1061	if (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2)
1062	{
1063	void *pvMmio2ToFree = pRegMmio->paLSPages;
1064	if (pvMmio2ToFree)
1065	{
1066	pRegMmio->paLSPages = NULL;
1067	pgmUnlock(pVM);
1068	MMR3HeapFree(pvMmio2ToFree);
1069	pgmLock(pVM);
1070	}
1071	}
1072	pgmUnlock(pVM);
1073	}
1074
1075
1076	/**
1077	* Prepares the RAM pages for a live save.
1078	*
1079	* @returns VBox status code.
1080	* @param pVM The cross context VM structure.
1081	*/
1082	static int pgmR3PrepRamPages(PVM pVM)
1083	{
1084
1085	/*
1086	* Try allocating tracking structures for the ram ranges.
1087	*
1088	* To avoid lock contention, we leave the lock every time we're allocating
1089	* a new array. This means we'll have to ditch the allocation and start
1090	* all over again if the RAM range list changes in-between.
1091	*
1092	* Note! pgmR3SaveDone will always be called and it is therefore responsible
1093	* for cleaning up.
1094	*/
1095	PPGMRAMRANGE pCur;
1096	pgmLock(pVM);
1097	do
1098	{
1099	for (pCur = pVM->pgm.s.pRamRangesXR3; pCur; pCur = pCur->pNextR3)
1100	{
1101	if ( !pCur->paLSPages
1102	&& !PGM_RAM_RANGE_IS_AD_HOC(pCur))
1103	{
1104	uint32_t const idRamRangesGen = pVM->pgm.s.idRamRangesGen;
1105	uint32_t const cPages = pCur->cb >> PAGE_SHIFT;
1106	pgmUnlock(pVM);
1107	PPGMLIVESAVERAMPAGE paLSPages = (PPGMLIVESAVERAMPAGE)MMR3HeapAllocZ(pVM, MM_TAG_PGM, cPages * sizeof(PGMLIVESAVERAMPAGE));
1108	if (!paLSPages)
1109	return VERR_NO_MEMORY;
1110	pgmLock(pVM);
1111	if (pVM->pgm.s.idRamRangesGen != idRamRangesGen)
1112	{
1113	pgmUnlock(pVM);
1114	MMR3HeapFree(paLSPages);
1115	pgmLock(pVM);
1116	break; /* try again */
1117	}
1118	pCur->paLSPages = paLSPages;
1119
1120	/*
1121	* Initialize the array.
1122	*/
1123	uint32_t iPage = cPages;
1124	while (iPage-- > 0)
1125	{
1126	/** @todo yield critsect! (after moving this away from EMT0) */
1127	PCPGMPAGE pPage = &pCur->aPages[iPage];
1128	paLSPages[iPage].cDirtied = 0;
1129	paLSPages[iPage].fDirty = 1; /* everything is dirty at this time */
1130	paLSPages[iPage].fWriteMonitored = 0;
1131	paLSPages[iPage].fWriteMonitoredJustNow = 0;
1132	paLSPages[iPage].u2Reserved = 0;
1133	switch (PGM_PAGE_GET_TYPE(pPage))
1134	{
1135	case PGMPAGETYPE_RAM:
1136	if ( PGM_PAGE_IS_ZERO(pPage)
1137	\|\| PGM_PAGE_IS_BALLOONED(pPage))
1138	{
1139	paLSPages[iPage].fZero = 1;
1140	paLSPages[iPage].fShared = 0;
1141	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1142	paLSPages[iPage].u32Crc = PGM_STATE_CRC32_ZERO_PAGE;
1143	#endif
1144	}
1145	else if (PGM_PAGE_IS_SHARED(pPage))
1146	{
1147	paLSPages[iPage].fZero = 0;
1148	paLSPages[iPage].fShared = 1;
1149	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1150	paLSPages[iPage].u32Crc = UINT32_MAX;
1151	#endif
1152	}
1153	else
1154	{
1155	paLSPages[iPage].fZero = 0;
1156	paLSPages[iPage].fShared = 0;
1157	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1158	paLSPages[iPage].u32Crc = UINT32_MAX;
1159	#endif
1160	}
1161	paLSPages[iPage].fIgnore = 0;
1162	pVM->pgm.s.LiveSave.Ram.cDirtyPages++;
1163	break;
1164
1165	case PGMPAGETYPE_ROM_SHADOW:
1166	case PGMPAGETYPE_ROM:
1167	{
1168	paLSPages[iPage].fZero = 0;
1169	paLSPages[iPage].fShared = 0;
1170	paLSPages[iPage].fDirty = 0;
1171	paLSPages[iPage].fIgnore = 1;
1172	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1173	paLSPages[iPage].u32Crc = UINT32_MAX;
1174	#endif
1175	pVM->pgm.s.LiveSave.cIgnoredPages++;
1176	break;
1177	}
1178
1179	default:
1180	AssertMsgFailed(("%R[pgmpage]", pPage));
1181	case PGMPAGETYPE_MMIO2:
1182	case PGMPAGETYPE_MMIO2_ALIAS_MMIO:
1183	paLSPages[iPage].fZero = 0;
1184	paLSPages[iPage].fShared = 0;
1185	paLSPages[iPage].fDirty = 0;
1186	paLSPages[iPage].fIgnore = 1;
1187	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1188	paLSPages[iPage].u32Crc = UINT32_MAX;
1189	#endif
1190	pVM->pgm.s.LiveSave.cIgnoredPages++;
1191	break;
1192
1193	case PGMPAGETYPE_MMIO:
1194	case PGMPAGETYPE_SPECIAL_ALIAS_MMIO:
1195	paLSPages[iPage].fZero = 0;
1196	paLSPages[iPage].fShared = 0;
1197	paLSPages[iPage].fDirty = 0;
1198	paLSPages[iPage].fIgnore = 1;
1199	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1200	paLSPages[iPage].u32Crc = UINT32_MAX;
1201	#endif
1202	pVM->pgm.s.LiveSave.cIgnoredPages++;
1203	break;
1204	}
1205	}
1206	}
1207	}
1208	} while (pCur);
1209	pgmUnlock(pVM);
1210
1211	return VINF_SUCCESS;
1212	}
1213
1214
1215	/**
1216	* Saves the RAM configuration.
1217	*
1218	* @returns VBox status code.
1219	* @param pVM The cross context VM structure.
1220	* @param pSSM The saved state handle.
1221	*/
1222	static int pgmR3SaveRamConfig(PVM pVM, PSSMHANDLE pSSM)
1223	{
1224	uint32_t cbRamHole = 0;
1225	int rc = CFGMR3QueryU32Def(CFGMR3GetRoot(pVM), "RamHoleSize", &cbRamHole, MM_RAM_HOLE_SIZE_DEFAULT);
1226	AssertRCReturn(rc, rc);
1227
1228	uint64_t cbRam = 0;
1229	rc = CFGMR3QueryU64Def(CFGMR3GetRoot(pVM), "RamSize", &cbRam, 0);
1230	AssertRCReturn(rc, rc);
1231
1232	SSMR3PutU32(pSSM, cbRamHole);
1233	return SSMR3PutU64(pSSM, cbRam);
1234	}
1235
1236
1237	/**
1238	* Loads and verifies the RAM configuration.
1239	*
1240	* @returns VBox status code.
1241	* @param pVM The cross context VM structure.
1242	* @param pSSM The saved state handle.
1243	*/
1244	static int pgmR3LoadRamConfig(PVM pVM, PSSMHANDLE pSSM)
1245	{
1246	uint32_t cbRamHoleCfg = 0;
1247	int rc = CFGMR3QueryU32Def(CFGMR3GetRoot(pVM), "RamHoleSize", &cbRamHoleCfg, MM_RAM_HOLE_SIZE_DEFAULT);
1248	AssertRCReturn(rc, rc);
1249
1250	uint64_t cbRamCfg = 0;
1251	rc = CFGMR3QueryU64Def(CFGMR3GetRoot(pVM), "RamSize", &cbRamCfg, 0);
1252	AssertRCReturn(rc, rc);
1253
1254	uint32_t cbRamHoleSaved;
1255	SSMR3GetU32(pSSM, &cbRamHoleSaved);
1256
1257	uint64_t cbRamSaved;
1258	rc = SSMR3GetU64(pSSM, &cbRamSaved);
1259	AssertRCReturn(rc, rc);
1260
1261	if ( cbRamHoleCfg != cbRamHoleSaved
1262	\|\| cbRamCfg != cbRamSaved)
1263	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Ram config mismatch: saved=%RX64/%RX32 config=%RX64/%RX32 (RAM/Hole)"),
1264	cbRamSaved, cbRamHoleSaved, cbRamCfg, cbRamHoleCfg);
1265	return VINF_SUCCESS;
1266	}
1267
1268	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1269
1270	/**
1271	* Calculates the CRC-32 for a RAM page and updates the live save page tracking
1272	* info with it.
1273	*
1274	* @param pVM The cross context VM structure.
1275	* @param pCur The current RAM range.
1276	* @param paLSPages The current array of live save page tracking
1277	* structures.
1278	* @param iPage The page index.
1279	*/
1280	static void pgmR3StateCalcCrc32ForRamPage(PVM pVM, PPGMRAMRANGE pCur, PPGMLIVESAVERAMPAGE paLSPages, uint32_t iPage)
1281	{
1282	RTGCPHYS GCPhys = pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
1283	PGMPAGEMAPLOCK PgMpLck;
1284	void const *pvPage;
1285	int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, &pCur->aPages[iPage], GCPhys, &pvPage, &PgMpLck);
1286	if (RT_SUCCESS(rc))
1287	{
1288	paLSPages[iPage].u32Crc = RTCrc32(pvPage, PAGE_SIZE);
1289	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
1290	}
1291	else
1292	paLSPages[iPage].u32Crc = UINT32_MAX; /* Invalid */
1293	}
1294
1295
1296	/**
1297	* Verifies the CRC-32 for a page given it's raw bits.
1298	*
1299	* @param pvPage The page bits.
1300	* @param pCur The current RAM range.
1301	* @param paLSPages The current array of live save page tracking
1302	* structures.
1303	* @param iPage The page index.
1304	*/
1305	static void pgmR3StateVerifyCrc32ForPage(void const pvPage, PPGMRAMRANGE pCur, PPGMLIVESAVERAMPAGE paLSPages, uint32_t iPage, const char pszWhere)
1306	{
1307	if (paLSPages[iPage].u32Crc != UINT32_MAX)
1308	{
1309	uint32_t u32Crc = RTCrc32(pvPage, PAGE_SIZE);
1310	Assert( ( !PGM_PAGE_IS_ZERO(&pCur->aPages[iPage])
1311	&& !PGM_PAGE_IS_BALLOONED(&pCur->aPages[iPage]))
1312	\|\| u32Crc == PGM_STATE_CRC32_ZERO_PAGE);
1313	AssertMsg(paLSPages[iPage].u32Crc == u32Crc,
1314	("%08x != %08x for %RGp %R[pgmpage] %s\n", paLSPages[iPage].u32Crc, u32Crc,
1315	pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), &pCur->aPages[iPage], pszWhere));
1316	}
1317	}
1318
1319
1320	/**
1321	* Verifies the CRC-32 for a RAM page.
1322	*
1323	* @param pVM The cross context VM structure.
1324	* @param pCur The current RAM range.
1325	* @param paLSPages The current array of live save page tracking
1326	* structures.
1327	* @param iPage The page index.
1328	*/
1329	static void pgmR3StateVerifyCrc32ForRamPage(PVM pVM, PPGMRAMRANGE pCur, PPGMLIVESAVERAMPAGE paLSPages, uint32_t iPage, const char *pszWhere)
1330	{
1331	if (paLSPages[iPage].u32Crc != UINT32_MAX)
1332	{
1333	RTGCPHYS GCPhys = pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
1334	PGMPAGEMAPLOCK PgMpLck;
1335	void const *pvPage;
1336	int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, &pCur->aPages[iPage], GCPhys, &pvPage, &PgMpLck);
1337	if (RT_SUCCESS(rc))
1338	{
1339	pgmR3StateVerifyCrc32ForPage(pvPage, pCur, paLSPages, iPage, pszWhere);
1340	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
1341	}
1342	}
1343	}
1344
1345	#endif /* PGMLIVESAVERAMPAGE_WITH_CRC32 */
1346
1347	/**
1348	* Scan for RAM page modifications and reprotect them.
1349	*
1350	* @param pVM The cross context VM structure.
1351	* @param fFinalPass Whether this is the final pass or not.
1352	*/
1353	static void pgmR3ScanRamPages(PVM pVM, bool fFinalPass)
1354	{
1355	/*
1356	* The RAM.
1357	*/
1358	RTGCPHYS GCPhysCur = 0;
1359	PPGMRAMRANGE pCur;
1360	pgmLock(pVM);
1361	do
1362	{
1363	uint32_t const idRamRangesGen = pVM->pgm.s.idRamRangesGen;
1364	for (pCur = pVM->pgm.s.pRamRangesXR3; pCur; pCur = pCur->pNextR3)
1365	{
1366	if ( pCur->GCPhysLast > GCPhysCur
1367	&& !PGM_RAM_RANGE_IS_AD_HOC(pCur))
1368	{
1369	PPGMLIVESAVERAMPAGE paLSPages = pCur->paLSPages;
1370	uint32_t cPages = pCur->cb >> PAGE_SHIFT;
1371	uint32_t iPage = GCPhysCur <= pCur->GCPhys ? 0 : (GCPhysCur - pCur->GCPhys) >> PAGE_SHIFT;
1372	GCPhysCur = 0;
1373	for (; iPage < cPages; iPage++)
1374	{
1375	/* Do yield first. */
1376	if ( !fFinalPass
1377	#ifndef PGMLIVESAVERAMPAGE_WITH_CRC32
1378	&& (iPage & 0x7ff) == 0x100
1379	#endif
1380	&& PDMR3CritSectYield(&pVM->pgm.s.CritSectX)
1381	&& pVM->pgm.s.idRamRangesGen != idRamRangesGen)
1382	{
1383	GCPhysCur = pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
1384	break; /* restart */
1385	}
1386
1387	/* Skip already ignored pages. */
1388	if (paLSPages[iPage].fIgnore)
1389	continue;
1390
1391	if (RT_LIKELY(PGM_PAGE_GET_TYPE(&pCur->aPages[iPage]) == PGMPAGETYPE_RAM))
1392	{
1393	/*
1394	* A RAM page.
1395	*/
1396	switch (PGM_PAGE_GET_STATE(&pCur->aPages[iPage]))
1397	{
1398	case PGM_PAGE_STATE_ALLOCATED:
1399	/** @todo Optimize this: Don't always re-enable write
1400	* monitoring if the page is known to be very busy. */
1401	if (PGM_PAGE_IS_WRITTEN_TO(&pCur->aPages[iPage]))
1402	{
1403	AssertMsg(paLSPages[iPage].fWriteMonitored,
1404	("%RGp %R[pgmpage]\n", pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), &pCur->aPages[iPage]));
1405	PGM_PAGE_CLEAR_WRITTEN_TO(pVM, &pCur->aPages[iPage]);
1406	Assert(pVM->pgm.s.cWrittenToPages > 0);
1407	pVM->pgm.s.cWrittenToPages--;
1408	}
1409	else
1410	{
1411	AssertMsg(!paLSPages[iPage].fWriteMonitored,
1412	("%RGp %R[pgmpage]\n", pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), &pCur->aPages[iPage]));
1413	pVM->pgm.s.LiveSave.Ram.cMonitoredPages++;
1414	}
1415
1416	if (!paLSPages[iPage].fDirty)
1417	{
1418	pVM->pgm.s.LiveSave.Ram.cReadyPages--;
1419	if (paLSPages[iPage].fZero)
1420	pVM->pgm.s.LiveSave.Ram.cZeroPages--;
1421	pVM->pgm.s.LiveSave.Ram.cDirtyPages++;
1422	if (++paLSPages[iPage].cDirtied > PGMLIVSAVEPAGE_MAX_DIRTIED)
1423	paLSPages[iPage].cDirtied = PGMLIVSAVEPAGE_MAX_DIRTIED;
1424	}
1425
1426	pgmPhysPageWriteMonitor(pVM, &pCur->aPages[iPage],
1427	pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
1428	paLSPages[iPage].fWriteMonitored = 1;
1429	paLSPages[iPage].fWriteMonitoredJustNow = 1;
1430	paLSPages[iPage].fDirty = 1;
1431	paLSPages[iPage].fZero = 0;
1432	paLSPages[iPage].fShared = 0;
1433	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1434	paLSPages[iPage].u32Crc = UINT32_MAX; /* invalid */
1435	#endif
1436	break;
1437
1438	case PGM_PAGE_STATE_WRITE_MONITORED:
1439	Assert(paLSPages[iPage].fWriteMonitored);
1440	if (PGM_PAGE_GET_WRITE_LOCKS(&pCur->aPages[iPage]) == 0)
1441	{
1442	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1443	if (paLSPages[iPage].fWriteMonitoredJustNow)
1444	pgmR3StateCalcCrc32ForRamPage(pVM, pCur, paLSPages, iPage);
1445	else
1446	pgmR3StateVerifyCrc32ForRamPage(pVM, pCur, paLSPages, iPage, "scan");
1447	#endif
1448	paLSPages[iPage].fWriteMonitoredJustNow = 0;
1449	}
1450	else
1451	{
1452	paLSPages[iPage].fWriteMonitoredJustNow = 1;
1453	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1454	paLSPages[iPage].u32Crc = UINT32_MAX; /* invalid */
1455	#endif
1456	if (!paLSPages[iPage].fDirty)
1457	{
1458	pVM->pgm.s.LiveSave.Ram.cReadyPages--;
1459	pVM->pgm.s.LiveSave.Ram.cDirtyPages++;
1460	if (++paLSPages[iPage].cDirtied > PGMLIVSAVEPAGE_MAX_DIRTIED)
1461	paLSPages[iPage].cDirtied = PGMLIVSAVEPAGE_MAX_DIRTIED;
1462	}
1463	}
1464	break;
1465
1466	case PGM_PAGE_STATE_ZERO:
1467	case PGM_PAGE_STATE_BALLOONED:
1468	if (!paLSPages[iPage].fZero)
1469	{
1470	if (!paLSPages[iPage].fDirty)
1471	{
1472	paLSPages[iPage].fDirty = 1;
1473	pVM->pgm.s.LiveSave.Ram.cReadyPages--;
1474	pVM->pgm.s.LiveSave.Ram.cDirtyPages++;
1475	}
1476	paLSPages[iPage].fZero = 1;
1477	paLSPages[iPage].fShared = 0;
1478	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1479	paLSPages[iPage].u32Crc = PGM_STATE_CRC32_ZERO_PAGE;
1480	#endif
1481	}
1482	break;
1483
1484	case PGM_PAGE_STATE_SHARED:
1485	if (!paLSPages[iPage].fShared)
1486	{
1487	if (!paLSPages[iPage].fDirty)
1488	{
1489	paLSPages[iPage].fDirty = 1;
1490	pVM->pgm.s.LiveSave.Ram.cReadyPages--;
1491	if (paLSPages[iPage].fZero)
1492	pVM->pgm.s.LiveSave.Ram.cZeroPages--;
1493	pVM->pgm.s.LiveSave.Ram.cDirtyPages++;
1494	}
1495	paLSPages[iPage].fZero = 0;
1496	paLSPages[iPage].fShared = 1;
1497	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1498	pgmR3StateCalcCrc32ForRamPage(pVM, pCur, paLSPages, iPage);
1499	#endif
1500	}
1501	break;
1502	}
1503	}
1504	else
1505	{
1506	/*
1507	* All other types => Ignore the page.
1508	*/
1509	Assert(!paLSPages[iPage].fIgnore); /* skipped before switch */
1510	paLSPages[iPage].fIgnore = 1;
1511	if (paLSPages[iPage].fWriteMonitored)
1512	{
1513	/** @todo this doesn't hold water when we start monitoring MMIO2 and ROM shadow
1514	* pages! */
1515	if (RT_UNLIKELY(PGM_PAGE_GET_STATE(&pCur->aPages[iPage]) == PGM_PAGE_STATE_WRITE_MONITORED))
1516	{
1517	AssertMsgFailed(("%R[pgmpage]", &pCur->aPages[iPage])); /* shouldn't happen. */
1518	PGM_PAGE_SET_STATE(pVM, &pCur->aPages[iPage], PGM_PAGE_STATE_ALLOCATED);
1519	Assert(pVM->pgm.s.cMonitoredPages > 0);
1520	pVM->pgm.s.cMonitoredPages--;
1521	}
1522	if (PGM_PAGE_IS_WRITTEN_TO(&pCur->aPages[iPage]))
1523	{
1524	PGM_PAGE_CLEAR_WRITTEN_TO(pVM, &pCur->aPages[iPage]);
1525	Assert(pVM->pgm.s.cWrittenToPages > 0);
1526	pVM->pgm.s.cWrittenToPages--;
1527	}
1528	pVM->pgm.s.LiveSave.Ram.cMonitoredPages--;
1529	}
1530
1531	/** @todo the counting doesn't quite work out here. fix later? */
1532	if (paLSPages[iPage].fDirty)
1533	pVM->pgm.s.LiveSave.Ram.cDirtyPages--;
1534	else
1535	{
1536	pVM->pgm.s.LiveSave.Ram.cReadyPages--;
1537	if (paLSPages[iPage].fZero)
1538	pVM->pgm.s.LiveSave.Ram.cZeroPages--;
1539	}
1540	pVM->pgm.s.LiveSave.cIgnoredPages++;
1541	}
1542	} /* for each page in range */
1543
1544	if (GCPhysCur != 0)
1545	break; /* Yield + ramrange change */
1546	GCPhysCur = pCur->GCPhysLast;
1547	}
1548	} /* for each range */
1549	} while (pCur);
1550	pgmUnlock(pVM);
1551	}
1552
1553
1554	/**
1555	* Save quiescent RAM pages.
1556	*
1557	* @returns VBox status code.
1558	* @param pVM The cross context VM structure.
1559	* @param pSSM The SSM handle.
1560	* @param fLiveSave Whether it's a live save or not.
1561	* @param uPass The pass number.
1562	*/
1563	static int pgmR3SaveRamPages(PVM pVM, PSSMHANDLE pSSM, bool fLiveSave, uint32_t uPass)
1564	{
1565	NOREF(fLiveSave);
1566
1567	/*
1568	* The RAM.
1569	*/
1570	RTGCPHYS GCPhysLast = NIL_RTGCPHYS;
1571	RTGCPHYS GCPhysCur = 0;
1572	PPGMRAMRANGE pCur;
1573	bool fFTMDeltaSaveActive = FTMIsDeltaLoadSaveActive(pVM);
1574
1575	pgmLock(pVM);
1576	do
1577	{
1578	uint32_t const idRamRangesGen = pVM->pgm.s.idRamRangesGen;
1579	for (pCur = pVM->pgm.s.pRamRangesXR3; pCur; pCur = pCur->pNextR3)
1580	{
1581	if ( pCur->GCPhysLast > GCPhysCur
1582	&& !PGM_RAM_RANGE_IS_AD_HOC(pCur))
1583	{
1584	PPGMLIVESAVERAMPAGE paLSPages = pCur->paLSPages;
1585	uint32_t cPages = pCur->cb >> PAGE_SHIFT;
1586	uint32_t iPage = GCPhysCur <= pCur->GCPhys ? 0 : (GCPhysCur - pCur->GCPhys) >> PAGE_SHIFT;
1587	GCPhysCur = 0;
1588	for (; iPage < cPages; iPage++)
1589	{
1590	/* Do yield first. */
1591	if ( uPass != SSM_PASS_FINAL
1592	&& (iPage & 0x7ff) == 0x100
1593	&& PDMR3CritSectYield(&pVM->pgm.s.CritSectX)
1594	&& pVM->pgm.s.idRamRangesGen != idRamRangesGen)
1595	{
1596	GCPhysCur = pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
1597	break; /* restart */
1598	}
1599
1600	PPGMPAGE pCurPage = &pCur->aPages[iPage];
1601
1602	/*
1603	* Only save pages that haven't changed since last scan and are dirty.
1604	*/
1605	if ( uPass != SSM_PASS_FINAL
1606	&& paLSPages)
1607	{
1608	if (!paLSPages[iPage].fDirty)
1609	continue;
1610	if (paLSPages[iPage].fWriteMonitoredJustNow)
1611	continue;
1612	if (paLSPages[iPage].fIgnore)
1613	continue;
1614	if (PGM_PAGE_GET_TYPE(pCurPage) != PGMPAGETYPE_RAM) /* in case of recent remappings */
1615	continue;
1616	if ( PGM_PAGE_GET_STATE(pCurPage)
1617	!= ( paLSPages[iPage].fZero
1618	? PGM_PAGE_STATE_ZERO
1619	: paLSPages[iPage].fShared
1620	? PGM_PAGE_STATE_SHARED
1621	: PGM_PAGE_STATE_WRITE_MONITORED))
1622	continue;
1623	if (PGM_PAGE_GET_WRITE_LOCKS(&pCur->aPages[iPage]) > 0)
1624	continue;
1625	}
1626	else
1627	{
1628	if ( paLSPages
1629	&& !paLSPages[iPage].fDirty
1630	&& !paLSPages[iPage].fIgnore)
1631	{
1632	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1633	if (PGM_PAGE_GET_TYPE(pCurPage) != PGMPAGETYPE_RAM)
1634	pgmR3StateVerifyCrc32ForRamPage(pVM, pCur, paLSPages, iPage, "save#1");
1635	#endif
1636	continue;
1637	}
1638	if (PGM_PAGE_GET_TYPE(pCurPage) != PGMPAGETYPE_RAM)
1639	continue;
1640	}
1641
1642	/*
1643	* Do the saving outside the PGM critsect since SSM may block on I/O.
1644	*/
1645	int rc;
1646	RTGCPHYS GCPhys = pCur->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
1647	bool fZero = PGM_PAGE_IS_ZERO(pCurPage);
1648	bool fBallooned = PGM_PAGE_IS_BALLOONED(pCurPage);
1649	bool fSkipped = false;
1650
1651	if (!fZero && !fBallooned)
1652	{
1653	/*
1654	* Copy the page and then save it outside the lock (since any
1655	* SSM call may block).
1656	*/
1657	uint8_t abPage[PAGE_SIZE];
1658	PGMPAGEMAPLOCK PgMpLck;
1659	void const *pvPage;
1660	rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, pCurPage, GCPhys, &pvPage, &PgMpLck);
1661	if (RT_SUCCESS(rc))
1662	{
1663	memcpy(abPage, pvPage, PAGE_SIZE);
1664	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1665	if (paLSPages)
1666	pgmR3StateVerifyCrc32ForPage(abPage, pCur, paLSPages, iPage, "save#3");
1667	#endif
1668	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
1669	}
1670	pgmUnlock(pVM);
1671	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys), rc);
1672
1673	/* Try save some memory when restoring. */
1674	if (!ASMMemIsZeroPage(pvPage))
1675	{
1676	if (fFTMDeltaSaveActive)
1677	{
1678	if ( PGM_PAGE_IS_WRITTEN_TO(pCurPage)
1679	\|\| PGM_PAGE_IS_FT_DIRTY(pCurPage))
1680	{
1681	if (GCPhys == GCPhysLast + PAGE_SIZE)
1682	SSMR3PutU8(pSSM, PGM_STATE_REC_RAM_RAW);
1683	else
1684	{
1685	SSMR3PutU8(pSSM, PGM_STATE_REC_RAM_RAW \| PGM_STATE_REC_FLAG_ADDR);
1686	SSMR3PutGCPhys(pSSM, GCPhys);
1687	}
1688	rc = SSMR3PutMem(pSSM, abPage, PAGE_SIZE);
1689	PGM_PAGE_CLEAR_WRITTEN_TO(pVM, pCurPage);
1690	PGM_PAGE_CLEAR_FT_DIRTY(pCurPage);
1691	}
1692	/* else nothing changed, so skip it. */
1693	else
1694	fSkipped = true;
1695	}
1696	else
1697	{
1698	if (GCPhys == GCPhysLast + PAGE_SIZE)
1699	SSMR3PutU8(pSSM, PGM_STATE_REC_RAM_RAW);
1700	else
1701	{
1702	SSMR3PutU8(pSSM, PGM_STATE_REC_RAM_RAW \| PGM_STATE_REC_FLAG_ADDR);
1703	SSMR3PutGCPhys(pSSM, GCPhys);
1704	}
1705	rc = SSMR3PutMem(pSSM, abPage, PAGE_SIZE);
1706	}
1707	}
1708	else
1709	{
1710	if (GCPhys == GCPhysLast + PAGE_SIZE)
1711	rc = SSMR3PutU8(pSSM, PGM_STATE_REC_RAM_ZERO);
1712	else
1713	{
1714	SSMR3PutU8(pSSM, PGM_STATE_REC_RAM_ZERO \| PGM_STATE_REC_FLAG_ADDR);
1715	rc = SSMR3PutGCPhys(pSSM, GCPhys);
1716	}
1717	}
1718	}
1719	else
1720	{
1721	/*
1722	* Dirty zero or ballooned page.
1723	*/
1724	#ifdef PGMLIVESAVERAMPAGE_WITH_CRC32
1725	if (paLSPages)
1726	pgmR3StateVerifyCrc32ForRamPage(pVM, pCur, paLSPages, iPage, "save#2");
1727	#endif
1728	pgmUnlock(pVM);
1729
1730	uint8_t u8RecType = fBallooned ? PGM_STATE_REC_RAM_BALLOONED : PGM_STATE_REC_RAM_ZERO;
1731	if (GCPhys == GCPhysLast + PAGE_SIZE)
1732	rc = SSMR3PutU8(pSSM, u8RecType);
1733	else
1734	{
1735	SSMR3PutU8(pSSM, u8RecType \| PGM_STATE_REC_FLAG_ADDR);
1736	rc = SSMR3PutGCPhys(pSSM, GCPhys);
1737	}
1738	}
1739	if (RT_FAILURE(rc))
1740	return rc;
1741
1742	pgmLock(pVM);
1743	if (!fSkipped)
1744	GCPhysLast = GCPhys;
1745	if (paLSPages)
1746	{
1747	paLSPages[iPage].fDirty = 0;
1748	pVM->pgm.s.LiveSave.Ram.cReadyPages++;
1749	if (fZero)
1750	pVM->pgm.s.LiveSave.Ram.cZeroPages++;
1751	pVM->pgm.s.LiveSave.Ram.cDirtyPages--;
1752	pVM->pgm.s.LiveSave.cSavedPages++;
1753	}
1754	if (idRamRangesGen != pVM->pgm.s.idRamRangesGen)
1755	{
1756	GCPhysCur = GCPhys \| PAGE_OFFSET_MASK;
1757	break; /* restart */
1758	}
1759
1760	} /* for each page in range */
1761
1762	if (GCPhysCur != 0)
1763	break; /* Yield + ramrange change */
1764	GCPhysCur = pCur->GCPhysLast;
1765	}
1766	} /* for each range */
1767	} while (pCur);
1768
1769	pgmUnlock(pVM);
1770
1771	return VINF_SUCCESS;
1772	}
1773
1774
1775	/**
1776	* Cleans up RAM pages after a live save.
1777	*
1778	* @param pVM The cross context VM structure.
1779	*/
1780	static void pgmR3DoneRamPages(PVM pVM)
1781	{
1782	/*
1783	* Free the tracking arrays and disable write monitoring.
1784	*
1785	* Play nice with the PGM lock in case we're called while the VM is still
1786	* running. This means we have to delay the freeing since we wish to use
1787	* paLSPages as an indicator of which RAM ranges which we need to scan for
1788	* write monitored pages.
1789	*/
1790	void *pvToFree = NULL;
1791	PPGMRAMRANGE pCur;
1792	uint32_t cMonitoredPages = 0;
1793	pgmLock(pVM);
1794	do
1795	{
1796	for (pCur = pVM->pgm.s.pRamRangesXR3; pCur; pCur = pCur->pNextR3)
1797	{
1798	if (pCur->paLSPages)
1799	{
1800	if (pvToFree)
1801	{
1802	uint32_t idRamRangesGen = pVM->pgm.s.idRamRangesGen;
1803	pgmUnlock(pVM);
1804	MMR3HeapFree(pvToFree);
1805	pvToFree = NULL;
1806	pgmLock(pVM);
1807	if (idRamRangesGen != pVM->pgm.s.idRamRangesGen)
1808	break; /* start over again. */
1809	}
1810
1811	pvToFree = pCur->paLSPages;
1812	pCur->paLSPages = NULL;
1813
1814	uint32_t iPage = pCur->cb >> PAGE_SHIFT;
1815	while (iPage--)
1816	{
1817	PPGMPAGE pPage = &pCur->aPages[iPage];
1818	PGM_PAGE_CLEAR_WRITTEN_TO(pVM, pPage);
1819	if (PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED)
1820	{
1821	PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ALLOCATED);
1822	cMonitoredPages++;
1823	}
1824	}
1825	}
1826	}
1827	} while (pCur);
1828
1829	Assert(pVM->pgm.s.cMonitoredPages >= cMonitoredPages);
1830	if (pVM->pgm.s.cMonitoredPages < cMonitoredPages)
1831	pVM->pgm.s.cMonitoredPages = 0;
1832	else
1833	pVM->pgm.s.cMonitoredPages -= cMonitoredPages;
1834
1835	pgmUnlock(pVM);
1836
1837	MMR3HeapFree(pvToFree);
1838	pvToFree = NULL;
1839	}
1840
1841
1842	/**
1843	* @callback_method_impl{FNSSMINTLIVEEXEC}
1844	*/
1845	static DECLCALLBACK(int) pgmR3LiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass)
1846	{
1847	int rc;
1848
1849	/*
1850	* Save the MMIO2 and ROM range IDs in pass 0.
1851	*/
1852	if (uPass == 0)
1853	{
1854	rc = pgmR3SaveRamConfig(pVM, pSSM);
1855	if (RT_FAILURE(rc))
1856	return rc;
1857	rc = pgmR3SaveRomRanges(pVM, pSSM);
1858	if (RT_FAILURE(rc))
1859	return rc;
1860	rc = pgmR3SaveMmio2Ranges(pVM, pSSM);
1861	if (RT_FAILURE(rc))
1862	return rc;
1863	}
1864	/*
1865	* Reset the page-per-second estimate to avoid inflation by the initial
1866	* load of zero pages. pgmR3LiveVote ASSUMES this is done at pass 7.
1867	*/
1868	else if (uPass == 7)
1869	{
1870	pVM->pgm.s.LiveSave.cSavedPages = 0;
1871	pVM->pgm.s.LiveSave.uSaveStartNS = RTTimeNanoTS();
1872	}
1873
1874	/*
1875	* Do the scanning.
1876	*/
1877	pgmR3ScanRomPages(pVM);
1878	pgmR3ScanMmio2Pages(pVM, uPass);
1879	pgmR3ScanRamPages(pVM, false /fFinalPass/);
1880	pgmR3PoolClearAll(pVM, true /fFlushRemTlb/); /** @todo this could perhaps be optimized a bit. */
1881
1882	/*
1883	* Save the pages.
1884	*/
1885	if (uPass == 0)
1886	rc = pgmR3SaveRomVirginPages( pVM, pSSM, true /fLiveSave/);
1887	else
1888	rc = VINF_SUCCESS;
1889	if (RT_SUCCESS(rc))
1890	rc = pgmR3SaveShadowedRomPages(pVM, pSSM, true /fLiveSave/, false /fFinalPass/);
1891	if (RT_SUCCESS(rc))
1892	rc = pgmR3SaveMmio2Pages( pVM, pSSM, true /fLiveSave/, uPass);
1893	if (RT_SUCCESS(rc))
1894	rc = pgmR3SaveRamPages( pVM, pSSM, true /fLiveSave/, uPass);
1895	SSMR3PutU8(pSSM, PGM_STATE_REC_END); /* (Ignore the rc, SSM takes care of it.) */
1896
1897	return rc;
1898	}
1899
1900
1901	/**
1902	* @callback_method_impl{FNSSMINTLIVEVOTE}
1903	*/
1904	static DECLCALLBACK(int) pgmR3LiveVote(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass)
1905	{
1906	/*
1907	* Update and calculate parameters used in the decision making.
1908	*/
1909	const uint32_t cHistoryEntries = RT_ELEMENTS(pVM->pgm.s.LiveSave.acDirtyPagesHistory);
1910
1911	/* update history. */
1912	pgmLock(pVM);
1913	uint32_t const cWrittenToPages = pVM->pgm.s.cWrittenToPages;
1914	pgmUnlock(pVM);
1915	uint32_t const cDirtyNow = pVM->pgm.s.LiveSave.Rom.cDirtyPages
1916	+ pVM->pgm.s.LiveSave.Mmio2.cDirtyPages
1917	+ pVM->pgm.s.LiveSave.Ram.cDirtyPages
1918	+ cWrittenToPages;
1919	uint32_t i = pVM->pgm.s.LiveSave.iDirtyPagesHistory;
1920	pVM->pgm.s.LiveSave.acDirtyPagesHistory[i] = cDirtyNow;
1921	pVM->pgm.s.LiveSave.iDirtyPagesHistory = (i + 1) % cHistoryEntries;
1922
1923	/* calc shortterm average (4 passes). */
1924	AssertCompile(RT_ELEMENTS(pVM->pgm.s.LiveSave.acDirtyPagesHistory) > 4);
1925	uint64_t cTotal = pVM->pgm.s.LiveSave.acDirtyPagesHistory[i];
1926	cTotal += pVM->pgm.s.LiveSave.acDirtyPagesHistory[(i + cHistoryEntries - 1) % cHistoryEntries];
1927	cTotal += pVM->pgm.s.LiveSave.acDirtyPagesHistory[(i + cHistoryEntries - 2) % cHistoryEntries];
1928	cTotal += pVM->pgm.s.LiveSave.acDirtyPagesHistory[(i + cHistoryEntries - 3) % cHistoryEntries];
1929	uint32_t const cDirtyPagesShort = cTotal / 4;
1930	pVM->pgm.s.LiveSave.cDirtyPagesShort = cDirtyPagesShort;
1931
1932	/* calc longterm average. */
1933	cTotal = 0;
1934	if (uPass < cHistoryEntries)
1935	for (i = 0; i < cHistoryEntries && i <= uPass; i++)
1936	cTotal += pVM->pgm.s.LiveSave.acDirtyPagesHistory[i];
1937	else
1938	for (i = 0; i < cHistoryEntries; i++)
1939	cTotal += pVM->pgm.s.LiveSave.acDirtyPagesHistory[i];
1940	uint32_t const cDirtyPagesLong = cTotal / cHistoryEntries;
1941	pVM->pgm.s.LiveSave.cDirtyPagesLong = cDirtyPagesLong;
1942
1943	/* estimate the speed */
1944	uint64_t cNsElapsed = RTTimeNanoTS() - pVM->pgm.s.LiveSave.uSaveStartNS;
1945	uint32_t cPagesPerSecond = (uint32_t)( pVM->pgm.s.LiveSave.cSavedPages
1946	/ ((long double)cNsElapsed / 1000000000.0) );
1947	pVM->pgm.s.LiveSave.cPagesPerSecond = cPagesPerSecond;
1948
1949	/*
1950	* Try make a decision.
1951	*/
1952	if ( cDirtyPagesShort <= cDirtyPagesLong
1953	&& ( cDirtyNow <= cDirtyPagesShort
1954	\|\| cDirtyNow - cDirtyPagesShort < RT_MIN(cDirtyPagesShort / 8, 16)
1955	)
1956	)
1957	{
1958	if (uPass > 10)
1959	{
1960	uint32_t cMsLeftShort = (uint32_t)(cDirtyPagesShort / (long double)cPagesPerSecond * 1000.0);
1961	uint32_t cMsLeftLong = (uint32_t)(cDirtyPagesLong / (long double)cPagesPerSecond * 1000.0);
1962	uint32_t cMsMaxDowntime = SSMR3HandleMaxDowntime(pSSM);
1963	if (cMsMaxDowntime < 32)
1964	cMsMaxDowntime = 32;
1965	if ( ( cMsLeftLong <= cMsMaxDowntime
1966	&& cMsLeftShort < cMsMaxDowntime)
1967	\|\| cMsLeftShort < cMsMaxDowntime / 2
1968	)
1969	{
1970	Log(("pgmR3LiveVote: VINF_SUCCESS - pass=%d cDirtyPagesShort=%u\|%ums cDirtyPagesLong=%u\|%ums cMsMaxDowntime=%u\n",
1971	uPass, cDirtyPagesShort, cMsLeftShort, cDirtyPagesLong, cMsLeftLong, cMsMaxDowntime));
1972	return VINF_SUCCESS;
1973	}
1974	}
1975	else
1976	{
1977	if ( ( cDirtyPagesShort <= 128
1978	&& cDirtyPagesLong <= 1024)
1979	\|\| cDirtyPagesLong <= 256
1980	)
1981	{
1982	Log(("pgmR3LiveVote: VINF_SUCCESS - pass=%d cDirtyPagesShort=%u cDirtyPagesLong=%u\n", uPass, cDirtyPagesShort, cDirtyPagesLong));
1983	return VINF_SUCCESS;
1984	}
1985	}
1986	}
1987
1988	/*
1989	* Come up with a completion percentage. Currently this is a simple
1990	* dirty page (long term) vs. total pages ratio + some pass trickery.
1991	*/
1992	unsigned uPctDirty = (unsigned)( (long double)cDirtyPagesLong
1993	/ (pVM->pgm.s.cAllPages - pVM->pgm.s.LiveSave.cIgnoredPages - pVM->pgm.s.cZeroPages) );
1994	if (uPctDirty <= 100)
1995	SSMR3HandleReportLivePercent(pSSM, RT_MIN(100 - uPctDirty, uPass * 2));
1996	else
1997	AssertMsgFailed(("uPctDirty=%u cDirtyPagesLong=%#x cAllPages=%#x cIgnoredPages=%#x cZeroPages=%#x\n",
1998	uPctDirty, cDirtyPagesLong, pVM->pgm.s.cAllPages, pVM->pgm.s.LiveSave.cIgnoredPages, pVM->pgm.s.cZeroPages));
1999
2000	return VINF_SSM_VOTE_FOR_ANOTHER_PASS;
2001	}
2002
2003
2004	/**
2005	* @callback_method_impl{FNSSMINTLIVEPREP}
2006	*
2007	* This will attempt to allocate and initialize the tracking structures. It
2008	* will also prepare for write monitoring of pages and initialize PGM::LiveSave.
2009	* pgmR3SaveDone will do the cleanups.
2010	*/
2011	static DECLCALLBACK(int) pgmR3LivePrep(PVM pVM, PSSMHANDLE pSSM)
2012	{
2013	/*
2014	* Indicate that we will be using the write monitoring.
2015	*/
2016	pgmLock(pVM);
2017	/** @todo find a way of mediating this when more users are added. */
2018	if (pVM->pgm.s.fPhysWriteMonitoringEngaged)
2019	{
2020	pgmUnlock(pVM);
2021	AssertLogRelFailedReturn(VERR_PGM_WRITE_MONITOR_ENGAGED);
2022	}
2023	pVM->pgm.s.fPhysWriteMonitoringEngaged = true;
2024	pgmUnlock(pVM);
2025
2026	/*
2027	* Initialize the statistics.
2028	*/
2029	pVM->pgm.s.LiveSave.Rom.cReadyPages = 0;
2030	pVM->pgm.s.LiveSave.Rom.cDirtyPages = 0;
2031	pVM->pgm.s.LiveSave.Mmio2.cReadyPages = 0;
2032	pVM->pgm.s.LiveSave.Mmio2.cDirtyPages = 0;
2033	pVM->pgm.s.LiveSave.Ram.cReadyPages = 0;
2034	pVM->pgm.s.LiveSave.Ram.cDirtyPages = 0;
2035	pVM->pgm.s.LiveSave.cIgnoredPages = 0;
2036	pVM->pgm.s.LiveSave.fActive = true;
2037	for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.LiveSave.acDirtyPagesHistory); i++)
2038	pVM->pgm.s.LiveSave.acDirtyPagesHistory[i] = UINT32_MAX / 2;
2039	pVM->pgm.s.LiveSave.iDirtyPagesHistory = 0;
2040	pVM->pgm.s.LiveSave.cSavedPages = 0;
2041	pVM->pgm.s.LiveSave.uSaveStartNS = RTTimeNanoTS();
2042	pVM->pgm.s.LiveSave.cPagesPerSecond = 8192;
2043
2044	/*
2045	* Per page type.
2046	*/
2047	int rc = pgmR3PrepRomPages(pVM);
2048	if (RT_SUCCESS(rc))
2049	rc = pgmR3PrepMmio2Pages(pVM);
2050	if (RT_SUCCESS(rc))
2051	rc = pgmR3PrepRamPages(pVM);
2052
2053	NOREF(pSSM);
2054	return rc;
2055	}
2056
2057
2058	/**
2059	* @callback_method_impl{FNSSMINTSAVEEXEC}
2060	*/
2061	static DECLCALLBACK(int) pgmR3SaveExec(PVM pVM, PSSMHANDLE pSSM)
2062	{
2063	int rc = VINF_SUCCESS;
2064	PPGM pPGM = &pVM->pgm.s;
2065
2066	/*
2067	* Lock PGM and set the no-more-writes indicator.
2068	*/
2069	pgmLock(pVM);
2070	pVM->pgm.s.fNoMorePhysWrites = true;
2071
2072	/*
2073	* Save basic data (required / unaffected by relocation).
2074	*/
2075	bool const fMappingsFixed = pVM->pgm.s.fMappingsFixed;
2076	pVM->pgm.s.fMappingsFixed \|= pVM->pgm.s.fMappingsFixedRestored;
2077	SSMR3PutStruct(pSSM, pPGM, &s_aPGMFields[0]);
2078	pVM->pgm.s.fMappingsFixed = fMappingsFixed;
2079
2080	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
2081	rc = SSMR3PutStruct(pSSM, &pVM->aCpus[idCpu].pgm.s, &s_aPGMCpuFields[0]);
2082
2083	/*
2084	* Save the (remainder of the) memory.
2085	*/
2086	if (RT_SUCCESS(rc))
2087	{
2088	if (pVM->pgm.s.LiveSave.fActive)
2089	{
2090	pgmR3ScanRomPages(pVM);
2091	pgmR3ScanMmio2Pages(pVM, SSM_PASS_FINAL);
2092	pgmR3ScanRamPages(pVM, true /fFinalPass/);
2093
2094	rc = pgmR3SaveShadowedRomPages( pVM, pSSM, true /fLiveSave/, true /fFinalPass/);
2095	if (RT_SUCCESS(rc))
2096	rc = pgmR3SaveMmio2Pages( pVM, pSSM, true /fLiveSave/, SSM_PASS_FINAL);
2097	if (RT_SUCCESS(rc))
2098	rc = pgmR3SaveRamPages( pVM, pSSM, true /fLiveSave/, SSM_PASS_FINAL);
2099	}
2100	else
2101	{
2102	rc = pgmR3SaveRamConfig(pVM, pSSM);
2103	if (RT_SUCCESS(rc))
2104	rc = pgmR3SaveRomRanges(pVM, pSSM);
2105	if (RT_SUCCESS(rc))
2106	rc = pgmR3SaveMmio2Ranges(pVM, pSSM);
2107	if (RT_SUCCESS(rc))
2108	rc = pgmR3SaveRomVirginPages( pVM, pSSM, false /fLiveSave/);
2109	if (RT_SUCCESS(rc))
2110	rc = pgmR3SaveShadowedRomPages(pVM, pSSM, false /fLiveSave/, true /fFinalPass/);
2111	if (RT_SUCCESS(rc))
2112	rc = pgmR3SaveMmio2Pages( pVM, pSSM, false /fLiveSave/, SSM_PASS_FINAL);
2113	if (RT_SUCCESS(rc))
2114	rc = pgmR3SaveRamPages( pVM, pSSM, false /fLiveSave/, SSM_PASS_FINAL);
2115	}
2116	SSMR3PutU8(pSSM, PGM_STATE_REC_END); /* (Ignore the rc, SSM takes of it.) */
2117	}
2118
2119	pgmUnlock(pVM);
2120	return rc;
2121	}
2122
2123
2124	/**
2125	* @callback_method_impl{FNSSMINTSAVEDONE}
2126	*/
2127	static DECLCALLBACK(int) pgmR3SaveDone(PVM pVM, PSSMHANDLE pSSM)
2128	{
2129	/*
2130	* Do per page type cleanups first.
2131	*/
2132	if (pVM->pgm.s.LiveSave.fActive)
2133	{
2134	pgmR3DoneRomPages(pVM);
2135	pgmR3DoneMmio2Pages(pVM);
2136	pgmR3DoneRamPages(pVM);
2137	}
2138
2139	/*
2140	* Clear the live save indicator and disengage write monitoring.
2141	*/
2142	pgmLock(pVM);
2143	pVM->pgm.s.LiveSave.fActive = false;
2144	/** @todo this is blindly assuming that we're the only user of write
2145	* monitoring. Fix this when more users are added. */
2146	pVM->pgm.s.fPhysWriteMonitoringEngaged = false;
2147	pgmUnlock(pVM);
2148
2149	NOREF(pSSM);
2150	return VINF_SUCCESS;
2151	}
2152
2153
2154	/**
2155	* @callback_method_impl{FNSSMINTLOADPREP}
2156	*/
2157	static DECLCALLBACK(int) pgmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM)
2158	{
2159	/*
2160	* Call the reset function to make sure all the memory is cleared.
2161	*/
2162	PGMR3Reset(pVM);
2163	pVM->pgm.s.LiveSave.fActive = false;
2164	NOREF(pSSM);
2165	return VINF_SUCCESS;
2166	}
2167
2168
2169	/**
2170	* Load an ignored page.
2171	*
2172	* @returns VBox status code.
2173	* @param pSSM The saved state handle.
2174	*/
2175	static int pgmR3LoadPageToDevNullOld(PSSMHANDLE pSSM)
2176	{
2177	uint8_t abPage[PAGE_SIZE];
2178	return SSMR3GetMem(pSSM, &abPage[0], sizeof(abPage));
2179	}
2180
2181
2182	/**
2183	* Compares a page with an old save type value.
2184	*
2185	* @returns true if equal, false if not.
2186	* @param pPage The page to compare.
2187	* @param uOldType The old type value from the saved state.
2188	*/
2189	DECLINLINE(bool) pgmR3CompareNewAndOldPageTypes(PPGMPAGE pPage, uint8_t uOldType)
2190	{
2191	uint8_t uOldPageType;
2192	switch (PGM_PAGE_GET_TYPE(pPage))
2193	{
2194	case PGMPAGETYPE_INVALID: uOldPageType = PGMPAGETYPE_OLD_INVALID; break;
2195	case PGMPAGETYPE_RAM: uOldPageType = PGMPAGETYPE_OLD_RAM; break;
2196	case PGMPAGETYPE_MMIO2: uOldPageType = PGMPAGETYPE_OLD_MMIO2; break;
2197	case PGMPAGETYPE_MMIO2_ALIAS_MMIO: uOldPageType = PGMPAGETYPE_OLD_MMIO2_ALIAS_MMIO; break;
2198	case PGMPAGETYPE_ROM_SHADOW: uOldPageType = PGMPAGETYPE_OLD_ROM_SHADOW; break;
2199	case PGMPAGETYPE_ROM: uOldPageType = PGMPAGETYPE_OLD_ROM; break;
2200	case PGMPAGETYPE_SPECIAL_ALIAS_MMIO: /* fall thru */
2201	case PGMPAGETYPE_MMIO: uOldPageType = PGMPAGETYPE_OLD_MMIO; break;
2202	default:
2203	AssertFailed();
2204	uOldPageType = PGMPAGETYPE_OLD_INVALID;
2205	break;
2206	}
2207	return uOldPageType == uOldType;
2208	}
2209
2210
2211	/**
2212	* Loads a page without any bits in the saved state, i.e. making sure it's
2213	* really zero.
2214	*
2215	* @returns VBox status code.
2216	* @param pVM The cross context VM structure.
2217	* @param uOldType The page type or PGMPAGETYPE_OLD_INVALID (old saved
2218	* state).
2219	* @param pPage The guest page tracking structure.
2220	* @param GCPhys The page address.
2221	* @param pRam The ram range (logging).
2222	*/
2223	static int pgmR3LoadPageZeroOld(PVM pVM, uint8_t uOldType, PPGMPAGE pPage, RTGCPHYS GCPhys, PPGMRAMRANGE pRam)
2224	{
2225	if ( uOldType != PGMPAGETYPE_OLD_INVALID
2226	&& !pgmR3CompareNewAndOldPageTypes(pPage, uOldType))
2227	return VERR_SSM_UNEXPECTED_DATA;
2228
2229	/* I think this should be sufficient. */
2230	if ( !PGM_PAGE_IS_ZERO(pPage)
2231	&& !PGM_PAGE_IS_BALLOONED(pPage))
2232	return VERR_SSM_UNEXPECTED_DATA;
2233
2234	NOREF(pVM);
2235	NOREF(GCPhys);
2236	NOREF(pRam);
2237	return VINF_SUCCESS;
2238	}
2239
2240
2241	/**
2242	* Loads a page from the saved state.
2243	*
2244	* @returns VBox status code.
2245	* @param pVM The cross context VM structure.
2246	* @param pSSM The SSM handle.
2247	* @param uOldType The page type or PGMPAGETYPE_OLD_INVALID (old saved
2248	* state).
2249	* @param pPage The guest page tracking structure.
2250	* @param GCPhys The page address.
2251	* @param pRam The ram range (logging).
2252	*/
2253	static int pgmR3LoadPageBitsOld(PVM pVM, PSSMHANDLE pSSM, uint8_t uOldType, PPGMPAGE pPage, RTGCPHYS GCPhys, PPGMRAMRANGE pRam)
2254	{
2255	/*
2256	* Match up the type, dealing with MMIO2 aliases (dropped).
2257	*/
2258	AssertLogRelMsgReturn( uOldType == PGMPAGETYPE_INVALID
2259	\|\| pgmR3CompareNewAndOldPageTypes(pPage, uOldType)
2260	/* kudge for the expanded PXE bios (r67885) - @bugref{5687}: */
2261	\|\| ( uOldType == PGMPAGETYPE_OLD_RAM
2262	&& GCPhys >= 0xed000
2263	&& GCPhys <= 0xeffff
2264	&& PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_ROM)
2265	,
2266	("pPage=%R[pgmpage] GCPhys=%#x %s\n", pPage, GCPhys, pRam->pszDesc),
2267	VERR_SSM_UNEXPECTED_DATA);
2268
2269	/*
2270	* Load the page.
2271	*/
2272	PGMPAGEMAPLOCK PgMpLck;
2273	void *pvPage;
2274	int rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvPage, &PgMpLck);
2275	if (RT_SUCCESS(rc))
2276	{
2277	rc = SSMR3GetMem(pSSM, pvPage, PAGE_SIZE);
2278	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2279	}
2280
2281	return rc;
2282	}
2283
2284
2285	/**
2286	* Loads a page (counter part to pgmR3SavePage).
2287	*
2288	* @returns VBox status code, fully bitched errors.
2289	* @param pVM The cross context VM structure.
2290	* @param pSSM The SSM handle.
2291	* @param uOldType The page type.
2292	* @param pPage The page.
2293	* @param GCPhys The page address.
2294	* @param pRam The RAM range (for error messages).
2295	*/
2296	static int pgmR3LoadPageOld(PVM pVM, PSSMHANDLE pSSM, uint8_t uOldType, PPGMPAGE pPage, RTGCPHYS GCPhys, PPGMRAMRANGE pRam)
2297	{
2298	uint8_t uState;
2299	int rc = SSMR3GetU8(pSSM, &uState);
2300	AssertLogRelMsgRCReturn(rc, ("pPage=%R[pgmpage] GCPhys=%#x %s rc=%Rrc\n", pPage, GCPhys, pRam->pszDesc, rc), rc);
2301	if (uState == 0 /* zero */)
2302	rc = pgmR3LoadPageZeroOld(pVM, uOldType, pPage, GCPhys, pRam);
2303	else if (uState == 1)
2304	rc = pgmR3LoadPageBitsOld(pVM, pSSM, uOldType, pPage, GCPhys, pRam);
2305	else
2306	rc = VERR_PGM_INVALID_SAVED_PAGE_STATE;
2307	AssertLogRelMsgRCReturn(rc, ("pPage=%R[pgmpage] uState=%d uOldType=%d GCPhys=%RGp %s rc=%Rrc\n",
2308	pPage, uState, uOldType, GCPhys, pRam->pszDesc, rc),
2309	rc);
2310	return VINF_SUCCESS;
2311	}
2312
2313
2314	/**
2315	* Loads a shadowed ROM page.
2316	*
2317	* @returns VBox status code, errors are fully bitched.
2318	* @param pVM The cross context VM structure.
2319	* @param pSSM The saved state handle.
2320	* @param pPage The page.
2321	* @param GCPhys The page address.
2322	* @param pRam The RAM range (for error messages).
2323	*/
2324	static int pgmR3LoadShadowedRomPageOld(PVM pVM, PSSMHANDLE pSSM, PPGMPAGE pPage, RTGCPHYS GCPhys, PPGMRAMRANGE pRam)
2325	{
2326	/*
2327	* Load and set the protection first, then load the two pages, the first
2328	* one is the active the other is the passive.
2329	*/
2330	PPGMROMPAGE pRomPage = pgmR3GetRomPage(pVM, GCPhys);
2331	AssertLogRelMsgReturn(pRomPage, ("GCPhys=%RGp %s\n", GCPhys, pRam->pszDesc), VERR_PGM_SAVED_ROM_PAGE_NOT_FOUND);
2332
2333	uint8_t uProt;
2334	int rc = SSMR3GetU8(pSSM, &uProt);
2335	AssertLogRelMsgRCReturn(rc, ("pPage=%R[pgmpage] GCPhys=%#x %s\n", pPage, GCPhys, pRam->pszDesc), rc);
2336	PGMROMPROT enmProt = (PGMROMPROT)uProt;
2337	AssertLogRelMsgReturn( enmProt >= PGMROMPROT_INVALID
2338	&& enmProt < PGMROMPROT_END,
2339	("enmProt=%d pPage=%R[pgmpage] GCPhys=%#x %s\n", enmProt, pPage, GCPhys, pRam->pszDesc),
2340	VERR_SSM_UNEXPECTED_DATA);
2341
2342	if (pRomPage->enmProt != enmProt)
2343	{
2344	rc = PGMR3PhysRomProtect(pVM, GCPhys, PAGE_SIZE, enmProt);
2345	AssertLogRelRCReturn(rc, rc);
2346	AssertLogRelReturn(pRomPage->enmProt == enmProt, VERR_PGM_SAVED_ROM_PAGE_PROT);
2347	}
2348
2349	PPGMPAGE pPageActive = PGMROMPROT_IS_ROM(enmProt) ? &pRomPage->Virgin : &pRomPage->Shadow;
2350	PPGMPAGE pPagePassive = PGMROMPROT_IS_ROM(enmProt) ? &pRomPage->Shadow : &pRomPage->Virgin;
2351	uint8_t u8ActiveType = PGMROMPROT_IS_ROM(enmProt) ? PGMPAGETYPE_ROM : PGMPAGETYPE_ROM_SHADOW;
2352	uint8_t u8PassiveType= PGMROMPROT_IS_ROM(enmProt) ? PGMPAGETYPE_ROM_SHADOW : PGMPAGETYPE_ROM;
2353
2354	/** @todo this isn't entirely correct as long as pgmPhysGCPhys2CCPtrInternal is
2355	* used down the line (will the 2nd page will be written to the first
2356	* one because of a false TLB hit since the TLB is using GCPhys and
2357	* doesn't check the HCPhys of the desired page). */
2358	rc = pgmR3LoadPageOld(pVM, pSSM, u8ActiveType, pPage, GCPhys, pRam);
2359	if (RT_SUCCESS(rc))
2360	{
2361	pPageActive = pPage;
2362	rc = pgmR3LoadPageOld(pVM, pSSM, u8PassiveType, pPagePassive, GCPhys, pRam);
2363	}
2364	return rc;
2365	}
2366
2367	/**
2368	* Ram range flags and bits for older versions of the saved state.
2369	*
2370	* @returns VBox status code.
2371	*
2372	* @param pVM The cross context VM structure.
2373	* @param pSSM The SSM handle.
2374	* @param uVersion The saved state version.
2375	*/
2376	static int pgmR3LoadMemoryOld(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion)
2377	{
2378	PPGM pPGM = &pVM->pgm.s;
2379
2380	/*
2381	* Ram range flags and bits.
2382	*/
2383	uint32_t i = 0;
2384	for (PPGMRAMRANGE pRam = pPGM->pRamRangesXR3; ; pRam = pRam->pNextR3, i++)
2385	{
2386	/* Check the sequence number / separator. */
2387	uint32_t u32Sep;
2388	int rc = SSMR3GetU32(pSSM, &u32Sep);
2389	if (RT_FAILURE(rc))
2390	return rc;
2391	if (u32Sep == ~0U)
2392	break;
2393	if (u32Sep != i)
2394	{
2395	AssertMsgFailed(("u32Sep=%#x (last)\n", u32Sep));
2396	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
2397	}
2398	AssertLogRelReturn(pRam, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2399
2400	/* Get the range details. */
2401	RTGCPHYS GCPhys;
2402	SSMR3GetGCPhys(pSSM, &GCPhys);
2403	RTGCPHYS GCPhysLast;
2404	SSMR3GetGCPhys(pSSM, &GCPhysLast);
2405	RTGCPHYS cb;
2406	SSMR3GetGCPhys(pSSM, &cb);
2407	uint8_t fHaveBits;
2408	rc = SSMR3GetU8(pSSM, &fHaveBits);
2409	if (RT_FAILURE(rc))
2410	return rc;
2411	if (fHaveBits & ~1)
2412	{
2413	AssertMsgFailed(("u32Sep=%#x (last)\n", u32Sep));
2414	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
2415	}
2416	size_t cchDesc = 0;
2417	char szDesc[256];
2418	szDesc[0] = '\0';
2419	if (uVersion >= PGM_SAVED_STATE_VERSION_RR_DESC)
2420	{
2421	rc = SSMR3GetStrZ(pSSM, szDesc, sizeof(szDesc));
2422	if (RT_FAILURE(rc))
2423	return rc;
2424	/* Since we've modified the description strings in r45878, only compare
2425	them if the saved state is more recent. */
2426	if (uVersion != PGM_SAVED_STATE_VERSION_RR_DESC)
2427	cchDesc = strlen(szDesc);
2428	}
2429
2430	/*
2431	* Match it up with the current range.
2432	*
2433	* Note there is a hack for dealing with the high BIOS mapping
2434	* in the old saved state format, this means we might not have
2435	* a 1:1 match on success.
2436	*/
2437	if ( ( GCPhys != pRam->GCPhys
2438	\|\| GCPhysLast != pRam->GCPhysLast
2439	\|\| cb != pRam->cb
2440	\|\| ( cchDesc
2441	&& strcmp(szDesc, pRam->pszDesc)) )
2442	/* Hack for PDMDevHlpPhysReserve(pDevIns, 0xfff80000, 0x80000, "High ROM Region"); */
2443	&& ( uVersion != PGM_SAVED_STATE_VERSION_OLD_PHYS_CODE
2444	\|\| GCPhys != UINT32_C(0xfff80000)
2445	\|\| GCPhysLast != UINT32_C(0xffffffff)
2446	\|\| pRam->GCPhysLast != GCPhysLast
2447	\|\| pRam->GCPhys < GCPhys
2448	\|\| !fHaveBits)
2449	)
2450	{
2451	LogRel(("Ram range: %RGp-%RGp %RGp bytes %s %s\n"
2452	"State : %RGp-%RGp %RGp bytes %s %s\n",
2453	pRam->GCPhys, pRam->GCPhysLast, pRam->cb, pRam->pvR3 ? "bits" : "nobits", pRam->pszDesc,
2454	GCPhys, GCPhysLast, cb, fHaveBits ? "bits" : "nobits", szDesc));
2455	/*
2456	* If we're loading a state for debugging purpose, don't make a fuss if
2457	* the MMIO and ROM stuff isn't 100% right, just skip the mismatches.
2458	*/
2459	if ( SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT
2460	\|\| GCPhys < 8 * _1M)
2461	return SSMR3SetCfgError(pSSM, RT_SRC_POS,
2462	N_("RAM range mismatch; saved={%RGp-%RGp %RGp bytes %s %s} config={%RGp-%RGp %RGp bytes %s %s}"),
2463	GCPhys, GCPhysLast, cb, fHaveBits ? "bits" : "nobits", szDesc,
2464	pRam->GCPhys, pRam->GCPhysLast, pRam->cb, pRam->pvR3 ? "bits" : "nobits", pRam->pszDesc);
2465
2466	AssertMsgFailed(("debug skipping not implemented, sorry\n"));
2467	continue;
2468	}
2469
2470	uint32_t cPages = (GCPhysLast - GCPhys + 1) >> PAGE_SHIFT;
2471	if (uVersion >= PGM_SAVED_STATE_VERSION_RR_DESC)
2472	{
2473	/*
2474	* Load the pages one by one.
2475	*/
2476	for (uint32_t iPage = 0; iPage < cPages; iPage++)
2477	{
2478	RTGCPHYS const GCPhysPage = ((RTGCPHYS)iPage << PAGE_SHIFT) + pRam->GCPhys;
2479	PPGMPAGE pPage = &pRam->aPages[iPage];
2480	uint8_t uOldType;
2481	rc = SSMR3GetU8(pSSM, &uOldType);
2482	AssertLogRelMsgRCReturn(rc, ("pPage=%R[pgmpage] iPage=%#x GCPhysPage=%#x %s\n", pPage, iPage, GCPhysPage, pRam->pszDesc), rc);
2483	if (uOldType == PGMPAGETYPE_OLD_ROM_SHADOW)
2484	rc = pgmR3LoadShadowedRomPageOld(pVM, pSSM, pPage, GCPhysPage, pRam);
2485	else
2486	rc = pgmR3LoadPageOld(pVM, pSSM, uOldType, pPage, GCPhysPage, pRam);
2487	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc iPage=%#x GCPhysPage=%#x %s\n", rc, iPage, GCPhysPage, pRam->pszDesc), rc);
2488	}
2489	}
2490	else
2491	{
2492	/*
2493	* Old format.
2494	*/
2495
2496	/* Of the page flags, pick up MMIO2 and ROM/RESERVED for the !fHaveBits case.
2497	The rest is generally irrelevant and wrong since the stuff have to match registrations. */
2498	uint32_t fFlags = 0;
2499	for (uint32_t iPage = 0; iPage < cPages; iPage++)
2500	{
2501	uint16_t u16Flags;
2502	rc = SSMR3GetU16(pSSM, &u16Flags);
2503	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc iPage=%#x GCPhys=%#x %s\n", rc, iPage, pRam->GCPhys, pRam->pszDesc), rc);
2504	fFlags \|= u16Flags;
2505	}
2506
2507	/* Load the bits */
2508	if ( !fHaveBits
2509	&& GCPhysLast < UINT32_C(0xe0000000))
2510	{
2511	/*
2512	* Dynamic chunks.
2513	*/
2514	const uint32_t cPagesInChunk = (110241024) >> PAGE_SHIFT;
2515	AssertLogRelMsgReturn(cPages % cPagesInChunk == 0,
2516	("cPages=%#x cPagesInChunk=%#x GCPhys=%RGp %s\n", cPages, cPagesInChunk, pRam->GCPhys, pRam->pszDesc),
2517	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2518
2519	for (uint32_t iPage = 0; iPage < cPages; /* incremented by inner loop */ )
2520	{
2521	uint8_t fPresent;
2522	rc = SSMR3GetU8(pSSM, &fPresent);
2523	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc iPage=%#x GCPhys=%#x %s\n", rc, iPage, pRam->GCPhys, pRam->pszDesc), rc);
2524	AssertLogRelMsgReturn(fPresent == (uint8_t)true \|\| fPresent == (uint8_t)false,
2525	("fPresent=%#x iPage=%#x GCPhys=%#x %s\n", fPresent, iPage, pRam->GCPhys, pRam->pszDesc),
2526	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2527
2528	for (uint32_t iChunkPage = 0; iChunkPage < cPagesInChunk; iChunkPage++, iPage++)
2529	{
2530	RTGCPHYS const GCPhysPage = ((RTGCPHYS)iPage << PAGE_SHIFT) + pRam->GCPhys;
2531	PPGMPAGE pPage = &pRam->aPages[iPage];
2532	if (fPresent)
2533	{
2534	if ( PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO
2535	\|\| PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_SPECIAL_ALIAS_MMIO)
2536	rc = pgmR3LoadPageToDevNullOld(pSSM);
2537	else
2538	rc = pgmR3LoadPageBitsOld(pVM, pSSM, PGMPAGETYPE_INVALID, pPage, GCPhysPage, pRam);
2539	}
2540	else
2541	rc = pgmR3LoadPageZeroOld(pVM, PGMPAGETYPE_INVALID, pPage, GCPhysPage, pRam);
2542	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc iPage=%#x GCPhysPage=%#x %s\n", rc, iPage, GCPhysPage, pRam->pszDesc), rc);
2543	}
2544	}
2545	}
2546	else if (pRam->pvR3)
2547	{
2548	/*
2549	* MMIO2.
2550	*/
2551	AssertLogRelMsgReturn((fFlags & 0x0f) == RT_BIT(3) /MM_RAM_FLAGS_MMIO2/,
2552	("fFlags=%#x GCPhys=%#x %s\n", fFlags, pRam->GCPhys, pRam->pszDesc),
2553	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2554	AssertLogRelMsgReturn(pRam->pvR3,
2555	("GCPhys=%#x %s\n", pRam->GCPhys, pRam->pszDesc),
2556	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2557
2558	rc = SSMR3GetMem(pSSM, pRam->pvR3, pRam->cb);
2559	AssertLogRelMsgRCReturn(rc, ("GCPhys=%#x %s\n", pRam->GCPhys, pRam->pszDesc), rc);
2560	}
2561	else if (GCPhysLast < UINT32_C(0xfff80000))
2562	{
2563	/*
2564	* PCI MMIO, no pages saved.
2565	*/
2566	}
2567	else
2568	{
2569	/*
2570	* Load the 0xfff80000..0xffffffff BIOS range.
2571	* It starts with X reserved pages that we have to skip over since
2572	* the RAMRANGE create by the new code won't include those.
2573	*/
2574	AssertLogRelMsgReturn( !(fFlags & RT_BIT(3) /MM_RAM_FLAGS_MMIO2/)
2575	&& (fFlags & RT_BIT(0) /MM_RAM_FLAGS_RESERVED/),
2576	("fFlags=%#x GCPhys=%#x %s\n", fFlags, pRam->GCPhys, pRam->pszDesc),
2577	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2578	AssertLogRelMsgReturn(GCPhys == UINT32_C(0xfff80000),
2579	("GCPhys=%RGp pRamRange{GCPhys=%#x %s}\n", GCPhys, pRam->GCPhys, pRam->pszDesc),
2580	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2581
2582	/* Skip wasted reserved pages before the ROM. */
2583	while (GCPhys < pRam->GCPhys)
2584	{
2585	rc = pgmR3LoadPageToDevNullOld(pSSM);
2586	GCPhys += PAGE_SIZE;
2587	}
2588
2589	/* Load the bios pages. */
2590	cPages = pRam->cb >> PAGE_SHIFT;
2591	for (uint32_t iPage = 0; iPage < cPages; iPage++)
2592	{
2593	RTGCPHYS const GCPhysPage = ((RTGCPHYS)iPage << PAGE_SHIFT) + pRam->GCPhys;
2594	PPGMPAGE pPage = &pRam->aPages[iPage];
2595
2596	AssertLogRelMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_ROM,
2597	("GCPhys=%RGp pPage=%R[pgmpage]\n", GCPhys, GCPhys),
2598	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2599	rc = pgmR3LoadPageBitsOld(pVM, pSSM, PGMPAGETYPE_ROM, pPage, GCPhysPage, pRam);
2600	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc iPage=%#x GCPhys=%#x %s\n", rc, iPage, pRam->GCPhys, pRam->pszDesc), rc);
2601	}
2602	}
2603	}
2604	}
2605
2606	return VINF_SUCCESS;
2607	}
2608
2609
2610	/**
2611	* Worker for pgmR3Load and pgmR3LoadLocked.
2612	*
2613	* @returns VBox status code.
2614	*
2615	* @param pVM The cross context VM structure.
2616	* @param pSSM The SSM handle.
2617	* @param uVersion The PGM saved state unit version.
2618	* @param uPass The pass number.
2619	*
2620	* @todo This needs splitting up if more record types or code twists are
2621	* added...
2622	*/
2623	static int pgmR3LoadMemory(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2624	{
2625	NOREF(uPass);
2626
2627	/*
2628	* Process page records until we hit the terminator.
2629	*/
2630	RTGCPHYS GCPhys = NIL_RTGCPHYS;
2631	PPGMRAMRANGE pRamHint = NULL;
2632	uint8_t id = UINT8_MAX;
2633	uint32_t iPage = UINT32_MAX - 10;
2634	PPGMROMRANGE pRom = NULL;
2635	PPGMREGMMIORANGE pRegMmio = NULL;
2636
2637	/*
2638	* We batch up pages that should be freed instead of calling GMM for
2639	* each and every one of them. Note that we'll lose the pages in most
2640	* failure paths - this should probably be addressed one day.
2641	*/
2642	uint32_t cPendingPages = 0;
2643	PGMMFREEPAGESREQ pReq;
2644	int rc = GMMR3FreePagesPrepare(pVM, &pReq, 128 /* batch size */, GMMACCOUNT_BASE);
2645	AssertLogRelRCReturn(rc, rc);
2646
2647	for (;;)
2648	{
2649	/*
2650	* Get the record type and flags.
2651	*/
2652	uint8_t u8;
2653	rc = SSMR3GetU8(pSSM, &u8);
2654	if (RT_FAILURE(rc))
2655	return rc;
2656	if (u8 == PGM_STATE_REC_END)
2657	{
2658	/*
2659	* Finish off any pages pending freeing.
2660	*/
2661	if (cPendingPages)
2662	{
2663	Log(("pgmR3LoadMemory: GMMR3FreePagesPerform pVM=%p cPendingPages=%u\n", pVM, cPendingPages));
2664	rc = GMMR3FreePagesPerform(pVM, pReq, cPendingPages);
2665	AssertLogRelRCReturn(rc, rc);
2666	}
2667	GMMR3FreePagesCleanup(pReq);
2668	return VINF_SUCCESS;
2669	}
2670	AssertLogRelMsgReturn((u8 & ~PGM_STATE_REC_FLAG_ADDR) <= PGM_STATE_REC_LAST, ("%#x\n", u8), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2671	switch (u8 & ~PGM_STATE_REC_FLAG_ADDR)
2672	{
2673	/*
2674	* RAM page.
2675	*/
2676	case PGM_STATE_REC_RAM_ZERO:
2677	case PGM_STATE_REC_RAM_RAW:
2678	case PGM_STATE_REC_RAM_BALLOONED:
2679	{
2680	/*
2681	* Get the address and resolve it into a page descriptor.
2682	*/
2683	if (!(u8 & PGM_STATE_REC_FLAG_ADDR))
2684	GCPhys += PAGE_SIZE;
2685	else
2686	{
2687	rc = SSMR3GetGCPhys(pSSM, &GCPhys);
2688	if (RT_FAILURE(rc))
2689	return rc;
2690	}
2691	AssertLogRelMsgReturn(!(GCPhys & PAGE_OFFSET_MASK), ("%RGp\n", GCPhys), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
2692
2693	PPGMPAGE pPage;
2694	rc = pgmPhysGetPageWithHintEx(pVM, GCPhys, &pPage, &pRamHint);
2695	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc %RGp\n", rc, GCPhys), rc);
2696
2697	/*
2698	* Take action according to the record type.
2699	*/
2700	switch (u8 & ~PGM_STATE_REC_FLAG_ADDR)
2701	{
2702	case PGM_STATE_REC_RAM_ZERO:
2703	{
2704	if (PGM_PAGE_IS_ZERO(pPage))
2705	break;
2706
2707	/* Ballooned pages must be unmarked (live snapshot and
2708	teleportation scenarios). */
2709	if (PGM_PAGE_IS_BALLOONED(pPage))
2710	{
2711	Assert(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM);
2712	if (uVersion == PGM_SAVED_STATE_VERSION_BALLOON_BROKEN)
2713	break;
2714	PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ZERO);
2715	break;
2716	}
2717
2718	AssertLogRelMsgReturn(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED, ("GCPhys=%RGp %R[pgmpage]\n", GCPhys, pPage), VERR_PGM_UNEXPECTED_PAGE_STATE);
2719
2720	/* If this is a ROM page, we must clear it and not try to
2721	* free it. Ditto if the VM is using RamPreAlloc (see
2722	* @bugref{6318}). */
2723	if ( PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_ROM
2724	\|\| PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_ROM_SHADOW
2725	\|\| pVM->pgm.s.fRamPreAlloc)
2726	{
2727	PGMPAGEMAPLOCK PgMpLck;
2728	void *pvDstPage;
2729	rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDstPage, &PgMpLck);
2730	AssertLogRelMsgRCReturn(rc, ("GCPhys=%RGp %R[pgmpage] rc=%Rrc\n", GCPhys, pPage, rc), rc);
2731
2732	ASMMemZeroPage(pvDstPage);
2733	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2734	}
2735	/* Free it only if it's not part of a previously
2736	allocated large page (no need to clear the page). */
2737	else if ( PGM_PAGE_GET_PDE_TYPE(pPage) != PGM_PAGE_PDE_TYPE_PDE
2738	&& PGM_PAGE_GET_PDE_TYPE(pPage) != PGM_PAGE_PDE_TYPE_PDE_DISABLED)
2739	{
2740	rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, pPage, GCPhys);
2741	AssertRCReturn(rc, rc);
2742	}
2743	/** @todo handle large pages (see @bugref{5545}) */
2744	break;
2745	}
2746
2747	case PGM_STATE_REC_RAM_BALLOONED:
2748	{
2749	Assert(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM);
2750	if (PGM_PAGE_IS_BALLOONED(pPage))
2751	break;
2752
2753	/* We don't map ballooned pages in our shadow page tables, let's
2754	just free it if allocated and mark as ballooned. See @bugref{5515}. */
2755	if (PGM_PAGE_IS_ALLOCATED(pPage))
2756	{
2757	/** @todo handle large pages + ballooning when it works. (see @bugref{5515},
2758	* @bugref{5545}). */
2759	AssertLogRelMsgReturn( PGM_PAGE_GET_PDE_TYPE(pPage) != PGM_PAGE_PDE_TYPE_PDE
2760	&& PGM_PAGE_GET_PDE_TYPE(pPage) != PGM_PAGE_PDE_TYPE_PDE_DISABLED,
2761	("GCPhys=%RGp %R[pgmpage]\n", GCPhys, pPage), VERR_PGM_LOAD_UNEXPECTED_PAGE_TYPE);
2762
2763	rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, pPage, GCPhys);
2764	AssertRCReturn(rc, rc);
2765	}
2766	Assert(PGM_PAGE_IS_ZERO(pPage));
2767	PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_BALLOONED);
2768	break;
2769	}
2770
2771	case PGM_STATE_REC_RAM_RAW:
2772	{
2773	PGMPAGEMAPLOCK PgMpLck;
2774	void *pvDstPage;
2775	rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDstPage, &PgMpLck);
2776	AssertLogRelMsgRCReturn(rc, ("GCPhys=%RGp %R[pgmpage] rc=%Rrc\n", GCPhys, pPage, rc), rc);
2777	rc = SSMR3GetMem(pSSM, pvDstPage, PAGE_SIZE);
2778	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2779	if (RT_FAILURE(rc))
2780	return rc;
2781	break;
2782	}
2783
2784	default:
2785	AssertMsgFailedReturn(("%#x\n", u8), VERR_PGM_SAVED_REC_TYPE);
2786	}
2787	id = UINT8_MAX;
2788	break;
2789	}
2790
2791	/*
2792	* MMIO2 page.
2793	*/
2794	case PGM_STATE_REC_MMIO2_RAW:
2795	case PGM_STATE_REC_MMIO2_ZERO:
2796	{
2797	/*
2798	* Get the ID + page number and resolved that into a MMIO2 page.
2799	*/
2800	if (!(u8 & PGM_STATE_REC_FLAG_ADDR))
2801	iPage++;
2802	else
2803	{
2804	SSMR3GetU8(pSSM, &id);
2805	rc = SSMR3GetU32(pSSM, &iPage);
2806	if (RT_FAILURE(rc))
2807	return rc;
2808	}
2809	if ( !pRegMmio
2810	\|\| pRegMmio->idSavedState != id)
2811	{
2812	for (pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
2813	if ( pRegMmio->idSavedState == id
2814	&& (pRegMmio->fFlags & PGMREGMMIORANGE_F_MMIO2))
2815	break;
2816	AssertLogRelMsgReturn(pRegMmio, ("id=%#u iPage=%#x\n", id, iPage), VERR_PGM_SAVED_MMIO2_RANGE_NOT_FOUND);
2817	}
2818	AssertLogRelMsgReturn(iPage < (pRegMmio->RamRange.cb >> PAGE_SHIFT), ("iPage=%#x cb=%RGp %s\n", iPage, pRegMmio->RamRange.cb, pRegMmio->RamRange.pszDesc), VERR_PGM_SAVED_MMIO2_PAGE_NOT_FOUND);
2819	void pvDstPage = (uint8_t )pRegMmio->RamRange.pvR3 + ((size_t)iPage << PAGE_SHIFT);
2820
2821	/*
2822	* Load the page bits.
2823	*/
2824	if ((u8 & ~PGM_STATE_REC_FLAG_ADDR) == PGM_STATE_REC_MMIO2_ZERO)
2825	ASMMemZeroPage(pvDstPage);
2826	else
2827	{
2828	rc = SSMR3GetMem(pSSM, pvDstPage, PAGE_SIZE);
2829	if (RT_FAILURE(rc))
2830	return rc;
2831	}
2832	GCPhys = NIL_RTGCPHYS;
2833	break;
2834	}
2835
2836	/*
2837	* ROM pages.
2838	*/
2839	case PGM_STATE_REC_ROM_VIRGIN:
2840	case PGM_STATE_REC_ROM_SHW_RAW:
2841	case PGM_STATE_REC_ROM_SHW_ZERO:
2842	case PGM_STATE_REC_ROM_PROT:
2843	{
2844	/*
2845	* Get the ID + page number and resolved that into a ROM page descriptor.
2846	*/
2847	if (!(u8 & PGM_STATE_REC_FLAG_ADDR))
2848	iPage++;
2849	else
2850	{
2851	SSMR3GetU8(pSSM, &id);
2852	rc = SSMR3GetU32(pSSM, &iPage);
2853	if (RT_FAILURE(rc))
2854	return rc;
2855	}
2856	if ( !pRom
2857	\|\| pRom->idSavedState != id)
2858	{
2859	for (pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
2860	if (pRom->idSavedState == id)
2861	break;
2862	AssertLogRelMsgReturn(pRom, ("id=%#u iPage=%#x\n", id, iPage), VERR_PGM_SAVED_ROM_RANGE_NOT_FOUND);
2863	}
2864	AssertLogRelMsgReturn(iPage < (pRom->cb >> PAGE_SHIFT), ("iPage=%#x cb=%RGp %s\n", iPage, pRom->cb, pRom->pszDesc), VERR_PGM_SAVED_ROM_PAGE_NOT_FOUND);
2865	PPGMROMPAGE pRomPage = &pRom->aPages[iPage];
2866	GCPhys = pRom->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT);
2867
2868	/*
2869	* Get and set the protection.
2870	*/
2871	uint8_t u8Prot;
2872	rc = SSMR3GetU8(pSSM, &u8Prot);
2873	if (RT_FAILURE(rc))
2874	return rc;
2875	PGMROMPROT enmProt = (PGMROMPROT)u8Prot;
2876	AssertLogRelMsgReturn(enmProt > PGMROMPROT_INVALID && enmProt < PGMROMPROT_END, ("GCPhys=%RGp enmProt=%d\n", GCPhys, enmProt), VERR_PGM_SAVED_ROM_PAGE_PROT);
2877
2878	if (enmProt != pRomPage->enmProt)
2879	{
2880	if (RT_UNLIKELY(!(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)))
2881	return SSMR3SetCfgError(pSSM, RT_SRC_POS,
2882	N_("Protection change of unshadowed ROM page: GCPhys=%RGp enmProt=%d %s"),
2883	GCPhys, enmProt, pRom->pszDesc);
2884	rc = PGMR3PhysRomProtect(pVM, GCPhys, PAGE_SIZE, enmProt);
2885	AssertLogRelMsgRCReturn(rc, ("GCPhys=%RGp rc=%Rrc\n", GCPhys, rc), rc);
2886	AssertLogRelReturn(pRomPage->enmProt == enmProt, VERR_PGM_SAVED_ROM_PAGE_PROT);
2887	}
2888	if ((u8 & ~PGM_STATE_REC_FLAG_ADDR) == PGM_STATE_REC_ROM_PROT)
2889	break; /* done */
2890
2891	/*
2892	* Get the right page descriptor.
2893	*/
2894	PPGMPAGE pRealPage;
2895	switch (u8 & ~PGM_STATE_REC_FLAG_ADDR)
2896	{
2897	case PGM_STATE_REC_ROM_VIRGIN:
2898	if (!PGMROMPROT_IS_ROM(enmProt))
2899	pRealPage = &pRomPage->Virgin;
2900	else
2901	pRealPage = NULL;
2902	break;
2903
2904	case PGM_STATE_REC_ROM_SHW_RAW:
2905	case PGM_STATE_REC_ROM_SHW_ZERO:
2906	if (RT_UNLIKELY(!(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)))
2907	return SSMR3SetCfgError(pSSM, RT_SRC_POS,
2908	N_("Shadowed / non-shadowed page type mismatch: GCPhys=%RGp enmProt=%d %s"),
2909	GCPhys, enmProt, pRom->pszDesc);
2910	if (PGMROMPROT_IS_ROM(enmProt))
2911	pRealPage = &pRomPage->Shadow;
2912	else
2913	pRealPage = NULL;
2914	break;
2915
2916	default: AssertLogRelFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); /* shut up gcc */
2917	}
2918	if (!pRealPage)
2919	{
2920	rc = pgmPhysGetPageWithHintEx(pVM, GCPhys, &pRealPage, &pRamHint);
2921	AssertLogRelMsgRCReturn(rc, ("rc=%Rrc %RGp\n", rc, GCPhys), rc);
2922	}
2923
2924	/*
2925	* Make it writable and map it (if necessary).
2926	*/
2927	void *pvDstPage = NULL;
2928	switch (u8 & ~PGM_STATE_REC_FLAG_ADDR)
2929	{
2930	case PGM_STATE_REC_ROM_SHW_ZERO:
2931	if ( PGM_PAGE_IS_ZERO(pRealPage)
2932	\|\| PGM_PAGE_IS_BALLOONED(pRealPage))
2933	break;
2934	/** @todo implement zero page replacing. */
2935	/* fall thru */
2936	case PGM_STATE_REC_ROM_VIRGIN:
2937	case PGM_STATE_REC_ROM_SHW_RAW:
2938	{
2939	rc = pgmPhysPageMakeWritableAndMap(pVM, pRealPage, GCPhys, &pvDstPage);
2940	AssertLogRelMsgRCReturn(rc, ("GCPhys=%RGp rc=%Rrc\n", GCPhys, rc), rc);
2941	break;
2942	}
2943	}
2944
2945	/*
2946	* Load the bits.
2947	*/
2948	switch (u8 & ~PGM_STATE_REC_FLAG_ADDR)
2949	{
2950	case PGM_STATE_REC_ROM_SHW_ZERO:
2951	if (pvDstPage)
2952	ASMMemZeroPage(pvDstPage);
2953	break;
2954
2955	case PGM_STATE_REC_ROM_VIRGIN:
2956	case PGM_STATE_REC_ROM_SHW_RAW:
2957	rc = SSMR3GetMem(pSSM, pvDstPage, PAGE_SIZE);
2958	if (RT_FAILURE(rc))
2959	return rc;
2960	break;
2961	}
2962	GCPhys = NIL_RTGCPHYS;
2963	break;
2964	}
2965
2966	/*
2967	* Unknown type.
2968	*/
2969	default:
2970	AssertLogRelMsgFailedReturn(("%#x\n", u8), VERR_PGM_SAVED_REC_TYPE);
2971	}
2972	} /* forever */
2973	}
2974
2975
2976	/**
2977	* Worker for pgmR3Load.
2978	*
2979	* @returns VBox status code.
2980	*
2981	* @param pVM The cross context VM structure.
2982	* @param pSSM The SSM handle.
2983	* @param uVersion The saved state version.
2984	*/
2985	static int pgmR3LoadFinalLocked(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion)
2986	{
2987	PPGM pPGM = &pVM->pgm.s;
2988	int rc;
2989	uint32_t u32Sep;
2990
2991	/*
2992	* Load basic data (required / unaffected by relocation).
2993	*/
2994	if (uVersion >= PGM_SAVED_STATE_VERSION_3_0_0)
2995	{
2996	if (uVersion > PGM_SAVED_STATE_VERSION_PRE_BALLOON)
2997	rc = SSMR3GetStruct(pSSM, pPGM, &s_aPGMFields[0]);
2998	else
2999	rc = SSMR3GetStruct(pSSM, pPGM, &s_aPGMFieldsPreBalloon[0]);
3000
3001	AssertLogRelRCReturn(rc, rc);
3002
3003	for (VMCPUID i = 0; i < pVM->cCpus; i++)
3004	{
3005	if (uVersion <= PGM_SAVED_STATE_VERSION_PRE_PAE)
3006	rc = SSMR3GetStruct(pSSM, &pVM->aCpus[i].pgm.s, &s_aPGMCpuFieldsPrePae[0]);
3007	else
3008	rc = SSMR3GetStruct(pSSM, &pVM->aCpus[i].pgm.s, &s_aPGMCpuFields[0]);
3009	AssertLogRelRCReturn(rc, rc);
3010	}
3011	}
3012	else if (uVersion >= PGM_SAVED_STATE_VERSION_RR_DESC)
3013	{
3014	AssertRelease(pVM->cCpus == 1);
3015
3016	PGMOLD pgmOld;
3017	rc = SSMR3GetStruct(pSSM, &pgmOld, &s_aPGMFields_Old[0]);
3018	AssertLogRelRCReturn(rc, rc);
3019
3020	pPGM->fMappingsFixed = pgmOld.fMappingsFixed;
3021	pPGM->GCPtrMappingFixed = pgmOld.GCPtrMappingFixed;
3022	pPGM->cbMappingFixed = pgmOld.cbMappingFixed;
3023
3024	pVM->aCpus[0].pgm.s.fA20Enabled = pgmOld.fA20Enabled;
3025	pVM->aCpus[0].pgm.s.GCPhysA20Mask = pgmOld.GCPhysA20Mask;
3026	pVM->aCpus[0].pgm.s.enmGuestMode = pgmOld.enmGuestMode;
3027	}
3028	else
3029	{
3030	AssertRelease(pVM->cCpus == 1);
3031
3032	SSMR3GetBool(pSSM, &pPGM->fMappingsFixed);
3033	SSMR3GetGCPtr(pSSM, &pPGM->GCPtrMappingFixed);
3034	SSMR3GetU32(pSSM, &pPGM->cbMappingFixed);
3035
3036	uint32_t cbRamSizeIgnored;
3037	rc = SSMR3GetU32(pSSM, &cbRamSizeIgnored);
3038	if (RT_FAILURE(rc))
3039	return rc;
3040	SSMR3GetGCPhys(pSSM, &pVM->aCpus[0].pgm.s.GCPhysA20Mask);
3041
3042	uint32_t u32 = 0;
3043	SSMR3GetUInt(pSSM, &u32);
3044	pVM->aCpus[0].pgm.s.fA20Enabled = !!u32;
3045	SSMR3GetUInt(pSSM, &pVM->aCpus[0].pgm.s.fSyncFlags);
3046	RTUINT uGuestMode;
3047	SSMR3GetUInt(pSSM, &uGuestMode);
3048	pVM->aCpus[0].pgm.s.enmGuestMode = (PGMMODE)uGuestMode;
3049
3050	/* check separator. */
3051	SSMR3GetU32(pSSM, &u32Sep);
3052	if (RT_FAILURE(rc))
3053	return rc;
3054	if (u32Sep != (uint32_t)~0)
3055	{
3056	AssertMsgFailed(("u32Sep=%#x (first)\n", u32Sep));
3057	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
3058	}
3059	}
3060
3061	/*
3062	* Fix the A20 mask.
3063	*/
3064	for (VMCPUID i = 0; i < pVM->cCpus; i++)
3065	{
3066	PVMCPU pVCpu = &pVM->aCpus[i];
3067	pVCpu->pgm.s.GCPhysA20Mask = ~((RTGCPHYS)!pVCpu->pgm.s.fA20Enabled << 20);
3068	pgmR3RefreshShadowModeAfterA20Change(pVCpu);
3069	}
3070
3071	/*
3072	* The guest mappings - skipped now, see re-fixation in the caller.
3073	*/
3074	if (uVersion <= PGM_SAVED_STATE_VERSION_PRE_PAE)
3075	{
3076	for (uint32_t i = 0; ; i++)
3077	{
3078	rc = SSMR3GetU32(pSSM, &u32Sep); /* sequence number */
3079	if (RT_FAILURE(rc))
3080	return rc;
3081	if (u32Sep == ~0U)
3082	break;
3083	AssertMsgReturn(u32Sep == i, ("u32Sep=%#x i=%#x\n", u32Sep, i), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
3084
3085	char szDesc[256];
3086	rc = SSMR3GetStrZ(pSSM, szDesc, sizeof(szDesc));
3087	if (RT_FAILURE(rc))
3088	return rc;
3089	RTGCPTR GCPtrIgnore;
3090	SSMR3GetGCPtr(pSSM, &GCPtrIgnore); /* GCPtr */
3091	rc = SSMR3GetGCPtr(pSSM, &GCPtrIgnore); /* cPTs */
3092	if (RT_FAILURE(rc))
3093	return rc;
3094	}
3095	}
3096
3097	/*
3098	* Load the RAM contents.
3099	*/
3100	if (uVersion > PGM_SAVED_STATE_VERSION_3_0_0)
3101	{
3102	if (!pVM->pgm.s.LiveSave.fActive)
3103	{
3104	if (uVersion > PGM_SAVED_STATE_VERSION_NO_RAM_CFG)
3105	{
3106	rc = pgmR3LoadRamConfig(pVM, pSSM);
3107	if (RT_FAILURE(rc))
3108	return rc;
3109	}
3110	rc = pgmR3LoadRomRanges(pVM, pSSM);
3111	if (RT_FAILURE(rc))
3112	return rc;
3113	rc = pgmR3LoadMmio2Ranges(pVM, pSSM);
3114	if (RT_FAILURE(rc))
3115	return rc;
3116	}
3117
3118	rc = pgmR3LoadMemory(pVM, pSSM, uVersion, SSM_PASS_FINAL);
3119	}
3120	else
3121	rc = pgmR3LoadMemoryOld(pVM, pSSM, uVersion);
3122
3123	/* Refresh balloon accounting. */
3124	if (pVM->pgm.s.cBalloonedPages)
3125	{
3126	Log(("pgmR3LoadFinalLocked: pVM=%p cBalloonedPages=%#x\n", pVM, pVM->pgm.s.cBalloonedPages));
3127	rc = GMMR3BalloonedPages(pVM, GMMBALLOONACTION_INFLATE, pVM->pgm.s.cBalloonedPages);
3128	AssertRCReturn(rc, rc);
3129	}
3130	return rc;
3131	}
3132
3133
3134	/**
3135	* @callback_method_impl{FNSSMINTLOADEXEC}
3136	*/
3137	static DECLCALLBACK(int) pgmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
3138	{
3139	int rc;
3140
3141	/*
3142	* Validate version.
3143	*/
3144	if ( ( uPass != SSM_PASS_FINAL
3145	&& uVersion != PGM_SAVED_STATE_VERSION
3146	&& uVersion != PGM_SAVED_STATE_VERSION_PRE_PAE
3147	&& uVersion != PGM_SAVED_STATE_VERSION_BALLOON_BROKEN
3148	&& uVersion != PGM_SAVED_STATE_VERSION_PRE_BALLOON
3149	&& uVersion != PGM_SAVED_STATE_VERSION_NO_RAM_CFG)
3150	\|\| ( uVersion != PGM_SAVED_STATE_VERSION
3151	&& uVersion != PGM_SAVED_STATE_VERSION_PRE_PAE
3152	&& uVersion != PGM_SAVED_STATE_VERSION_BALLOON_BROKEN
3153	&& uVersion != PGM_SAVED_STATE_VERSION_PRE_BALLOON
3154	&& uVersion != PGM_SAVED_STATE_VERSION_NO_RAM_CFG
3155	&& uVersion != PGM_SAVED_STATE_VERSION_3_0_0
3156	&& uVersion != PGM_SAVED_STATE_VERSION_2_2_2
3157	&& uVersion != PGM_SAVED_STATE_VERSION_RR_DESC
3158	&& uVersion != PGM_SAVED_STATE_VERSION_OLD_PHYS_CODE)
3159	)
3160	{
3161	AssertMsgFailed(("pgmR3Load: Invalid version uVersion=%d (current %d)!\n", uVersion, PGM_SAVED_STATE_VERSION));
3162	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
3163	}
3164
3165	/*
3166	* Do the loading while owning the lock because a bunch of the functions
3167	* we're using requires this.
3168	*/
3169	if (uPass != SSM_PASS_FINAL)
3170	{
3171	pgmLock(pVM);
3172	if (uPass != 0)
3173	rc = pgmR3LoadMemory(pVM, pSSM, uVersion, uPass);
3174	else
3175	{
3176	pVM->pgm.s.LiveSave.fActive = true;
3177	if (uVersion > PGM_SAVED_STATE_VERSION_NO_RAM_CFG)
3178	rc = pgmR3LoadRamConfig(pVM, pSSM);
3179	else
3180	rc = VINF_SUCCESS;
3181	if (RT_SUCCESS(rc))
3182	rc = pgmR3LoadRomRanges(pVM, pSSM);
3183	if (RT_SUCCESS(rc))
3184	rc = pgmR3LoadMmio2Ranges(pVM, pSSM);
3185	if (RT_SUCCESS(rc))
3186	rc = pgmR3LoadMemory(pVM, pSSM, uVersion, uPass);
3187	}
3188	pgmUnlock(pVM);
3189	}
3190	else
3191	{
3192	pgmLock(pVM);
3193	rc = pgmR3LoadFinalLocked(pVM, pSSM, uVersion);
3194	pVM->pgm.s.LiveSave.fActive = false;
3195	pgmUnlock(pVM);
3196	if (RT_SUCCESS(rc))
3197	{
3198	/*
3199	* We require a full resync now.
3200	*/
3201	for (VMCPUID i = 0; i < pVM->cCpus; i++)
3202	{
3203	PVMCPU pVCpu = &pVM->aCpus[i];
3204	VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL);
3205	VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
3206	pVCpu->pgm.s.fSyncFlags \|= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL;
3207	/** @todo For guest PAE, we might get the wrong
3208	* aGCPhysGstPaePDs values now. We should used the
3209	* saved ones... Postponing this since it nothing new
3210	* and PAE/PDPTR needs some general readjusting, see
3211	* @bugref{5880}. */
3212	}
3213
3214	pgmR3HandlerPhysicalUpdateAll(pVM);
3215
3216	/*
3217	* Change the paging mode and restore PGMCPU::GCPhysCR3.
3218	* (The latter requires the CPUM state to be restored already.)
3219	*/
3220	if (CPUMR3IsStateRestorePending(pVM))
3221	return SSMR3SetLoadError(pSSM, VERR_WRONG_ORDER, RT_SRC_POS,
3222	N_("PGM was unexpectedly restored before CPUM"));
3223
3224	for (VMCPUID i = 0; i < pVM->cCpus; i++)
3225	{
3226	PVMCPU pVCpu = &pVM->aCpus[i];
3227
3228	rc = PGMR3ChangeMode(pVM, pVCpu, pVCpu->pgm.s.enmGuestMode);
3229	AssertLogRelRCReturn(rc, rc);
3230
3231	/* Update pVM->pgm.s.GCPhysCR3. */
3232	Assert(pVCpu->pgm.s.GCPhysCR3 == NIL_RTGCPHYS \|\| FTMIsDeltaLoadSaveActive(pVM));
3233	RTGCPHYS GCPhysCR3 = CPUMGetGuestCR3(pVCpu);
3234	if ( pVCpu->pgm.s.enmGuestMode == PGMMODE_PAE
3235	\|\| pVCpu->pgm.s.enmGuestMode == PGMMODE_PAE_NX
3236	\|\| pVCpu->pgm.s.enmGuestMode == PGMMODE_AMD64
3237	\|\| pVCpu->pgm.s.enmGuestMode == PGMMODE_AMD64_NX)
3238	GCPhysCR3 = (GCPhysCR3 & X86_CR3_PAE_PAGE_MASK);
3239	else
3240	GCPhysCR3 = (GCPhysCR3 & X86_CR3_PAGE_MASK);
3241	pVCpu->pgm.s.GCPhysCR3 = GCPhysCR3;
3242
3243	/* Update the PSE, NX flags and validity masks. */
3244	pVCpu->pgm.s.fGst32BitPageSizeExtension = CPUMIsGuestPageSizeExtEnabled(pVCpu);
3245	PGMNotifyNxeChanged(pVCpu, CPUMIsGuestNXEnabled(pVCpu));
3246	}
3247
3248	/*
3249	* Try re-fixate the guest mappings.
3250	*/
3251	pVM->pgm.s.fMappingsFixedRestored = false;
3252	if ( pVM->pgm.s.fMappingsFixed
3253	&& pgmMapAreMappingsEnabled(pVM))
3254	{
3255	#ifndef PGM_WITHOUT_MAPPINGS
3256	RTGCPTR GCPtrFixed = pVM->pgm.s.GCPtrMappingFixed;
3257	uint32_t cbFixed = pVM->pgm.s.cbMappingFixed;
3258	pVM->pgm.s.fMappingsFixed = false;
3259
3260	uint32_t cbRequired;
3261	int rc2 = PGMR3MappingsSize(pVM, &cbRequired); AssertRC(rc2);
3262	if ( RT_SUCCESS(rc2)
3263	&& cbRequired > cbFixed)
3264	rc2 = VERR_OUT_OF_RANGE;
3265	if (RT_SUCCESS(rc2))
3266	rc2 = pgmR3MappingsFixInternal(pVM, GCPtrFixed, cbFixed);
3267	if (RT_FAILURE(rc2))
3268	{
3269	LogRel(("PGM: Unable to re-fixate the guest mappings at %RGv-%RGv: rc=%Rrc (cbRequired=%#x)\n",
3270	GCPtrFixed, GCPtrFixed + cbFixed, rc2, cbRequired));
3271	pVM->pgm.s.fMappingsFixed = false;
3272	pVM->pgm.s.fMappingsFixedRestored = true;
3273	pVM->pgm.s.GCPtrMappingFixed = GCPtrFixed;
3274	pVM->pgm.s.cbMappingFixed = cbFixed;
3275	}
3276	#else
3277	AssertFailed();
3278	#endif
3279	}
3280	else
3281	{
3282	/* We used to set fixed + disabled while we only use disabled now,
3283	so wipe the state to avoid any confusion. */
3284	pVM->pgm.s.fMappingsFixed = false;
3285	pVM->pgm.s.GCPtrMappingFixed = NIL_RTGCPTR;
3286	pVM->pgm.s.cbMappingFixed = 0;
3287	}
3288
3289	/*
3290	* If we have floating mappings, do a CR3 sync now to make sure the HMA
3291	* doesn't conflict with guest code / data and thereby cause trouble
3292	* when restoring other components like PATM.
3293	*/
3294	if (pgmMapAreMappingsFloating(pVM))
3295	{
3296	PVMCPU pVCpu = &pVM->aCpus[0];
3297	rc = PGMSyncCR3(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR3(pVCpu), CPUMGetGuestCR4(pVCpu), true);
3298	if (RT_FAILURE(rc))
3299	return SSMR3SetLoadError(pSSM, VERR_WRONG_ORDER, RT_SRC_POS,
3300	N_("PGMSyncCR3 failed unexpectedly with rc=%Rrc"), rc);
3301
3302	/* Make sure to re-sync before executing code. */
3303	VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL);
3304	VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
3305	pVCpu->pgm.s.fSyncFlags \|= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL;
3306	}
3307	}
3308	}
3309
3310	return rc;
3311	}
3312
3313
3314	/**
3315	* @callback_method_impl{FNSSMINTLOADDONE}
3316	*/
3317	static DECLCALLBACK(int) pgmR3LoadDone(PVM pVM, PSSMHANDLE pSSM)
3318	{
3319	pVM->pgm.s.fRestoreRomPagesOnReset = true;
3320	NOREF(pSSM);
3321	return VINF_SUCCESS;
3322	}
3323
3324
3325	/**
3326	* Registers the saved state callbacks with SSM.
3327	*
3328	* @returns VBox status code.
3329	* @param pVM The cross context VM structure.
3330	* @param cbRam The RAM size.
3331	*/
3332	int pgmR3InitSavedState(PVM pVM, uint64_t cbRam)
3333	{
3334	return SSMR3RegisterInternal(pVM, "pgm", 1, PGM_SAVED_STATE_VERSION, (size_t)cbRam + sizeof(PGM),
3335	pgmR3LivePrep, pgmR3LiveExec, pgmR3LiveVote,
3336	NULL, pgmR3SaveExec, pgmR3SaveDone,
3337	pgmR3LoadPrep, pgmR3Load, pgmR3LoadDone);
3338	}
3339

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

source: vbox/trunk/src/VBox/VMM/VMMR3/PGMSavedState.cpp@ 65299

Download in other formats: