PGMSavedState.cpp@ 25659

Last change on this file since 25659 was 25231, checked in by vboxsync, 15 years ago
PGMSavedState.cpp: -Wshadow.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 110.8 KB

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

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

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

Download in other formats: