VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/PGMPool.cpp@ 62478

Last change on this file since 62478 was 62478, checked in by vboxsync, 8 years ago

(C) 2016

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 47.7 KB
Line 
1/* $Id: PGMPool.cpp 62478 2016-07-22 18:29:06Z vboxsync $ */
2/** @file
3 * PGM Shadow Page Pool.
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/** @page pg_pgm_pool PGM Shadow Page Pool
19 *
20 * Motivations:
21 * -# Relationship between shadow page tables and physical guest pages. This
22 * should allow us to skip most of the global flushes now following access
23 * handler changes. The main expense is flushing shadow pages.
24 * -# Limit the pool size if necessary (default is kind of limitless).
25 * -# Allocate shadow pages from RC. We use to only do this in SyncCR3.
26 * -# Required for 64-bit guests.
27 * -# Combining the PD cache and page pool in order to simplify caching.
28 *
29 *
30 * @section sec_pgm_pool_outline Design Outline
31 *
32 * The shadow page pool tracks pages used for shadowing paging structures (i.e.
33 * page tables, page directory, page directory pointer table and page map
34 * level-4). Each page in the pool has an unique identifier. This identifier is
35 * used to link a guest physical page to a shadow PT. The identifier is a
36 * non-zero value and has a relativly low max value - say 14 bits. This makes it
37 * possible to fit it into the upper bits of the of the aHCPhys entries in the
38 * ram range.
39 *
40 * By restricting host physical memory to the first 48 bits (which is the
41 * announced physical memory range of the K8L chip (scheduled for 2008)), we
42 * can safely use the upper 16 bits for shadow page ID and reference counting.
43 *
44 * Update: The 48 bit assumption will be lifted with the new physical memory
45 * management (PGMPAGE), so we won't have any trouble when someone stuffs 2TB
46 * into a box in some years.
47 *
48 * Now, it's possible for a page to be aliased, i.e. mapped by more than one PT
49 * or PD. This is solved by creating a list of physical cross reference extents
50 * when ever this happens. Each node in the list (extent) is can contain 3 page
51 * pool indexes. The list it self is chained using indexes into the paPhysExt
52 * array.
53 *
54 *
55 * @section sec_pgm_pool_life Life Cycle of a Shadow Page
56 *
57 * -# The SyncPT function requests a page from the pool.
58 * The request includes the kind of page it is (PT/PD, PAE/legacy), the
59 * address of the page it's shadowing, and more.
60 * -# The pool responds to the request by allocating a new page.
61 * When the cache is enabled, it will first check if it's in the cache.
62 * Should the pool be exhausted, one of two things can be done:
63 * -# Flush the whole pool and current CR3.
64 * -# Use the cache to find a page which can be flushed (~age).
65 * -# The SyncPT function will sync one or more pages and insert it into the
66 * shadow PD.
67 * -# The SyncPage function may sync more pages on a later \#PFs.
68 * -# The page is freed / flushed in SyncCR3 (perhaps) and some other cases.
69 * When caching is enabled, the page isn't flush but remains in the cache.
70 *
71 *
72 * @section sec_pgm_pool_monitoring Monitoring
73 *
74 * We always monitor PAGE_SIZE chunks of memory. When we've got multiple shadow
75 * pages for the same PAGE_SIZE of guest memory (PAE and mixed PD/PT) the pages
76 * sharing the monitor get linked using the iMonitoredNext/Prev. The head page
77 * is the pvUser to the access handlers.
78 *
79 *
80 * @section sec_pgm_pool_impl Implementation
81 *
82 * The pool will take pages from the MM page pool. The tracking data
83 * (attributes, bitmaps and so on) are allocated from the hypervisor heap. The
84 * pool content can be accessed both by using the page id and the physical
85 * address (HC). The former is managed by means of an array, the latter by an
86 * offset based AVL tree.
87 *
88 * Flushing of a pool page means that we iterate the content (we know what kind
89 * it is) and updates the link information in the ram range.
90 *
91 * ...
92 */
93
94
95/*********************************************************************************************************************************
96* Header Files *
97*********************************************************************************************************************************/
98#define LOG_GROUP LOG_GROUP_PGM_POOL
99#include <VBox/vmm/pgm.h>
100#include <VBox/vmm/mm.h>
101#include "PGMInternal.h"
102#include <VBox/vmm/vm.h>
103#include <VBox/vmm/uvm.h>
104#include "PGMInline.h"
105
106#include <VBox/log.h>
107#include <VBox/err.h>
108#include <iprt/asm.h>
109#include <iprt/string.h>
110#include <VBox/dbg.h>
111
112
113/*********************************************************************************************************************************
114* Internal Functions *
115*********************************************************************************************************************************/
116#ifdef VBOX_WITH_DEBUGGER
117static FNDBGCCMD pgmR3PoolCmdCheck;
118#endif
119
120#ifdef VBOX_WITH_DEBUGGER
121/** Command descriptors. */
122static const DBGCCMD g_aCmds[] =
123{
124 /* pszCmd, cArgsMin, cArgsMax, paArgDesc, cArgDescs, fFlags, pfnHandler pszSyntax, ....pszDescription */
125 { "pgmpoolcheck", 0, 0, NULL, 0, 0, pgmR3PoolCmdCheck, "", "Check the pgm pool pages." },
126};
127#endif
128
129/**
130 * Initializes the pool
131 *
132 * @returns VBox status code.
133 * @param pVM The cross context VM structure.
134 */
135int pgmR3PoolInit(PVM pVM)
136{
137 int rc;
138
139 AssertCompile(NIL_PGMPOOL_IDX == 0);
140 /* pPage->cLocked is an unsigned byte. */
141 AssertCompile(VMM_MAX_CPU_COUNT <= 255);
142
143 /*
144 * Query Pool config.
145 */
146 PCFGMNODE pCfg = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/PGM/Pool");
147
148 /* Default pgm pool size is 1024 pages (4MB). */
149 uint16_t cMaxPages = 1024;
150
151 /* Adjust it up relative to the RAM size, using the nested paging formula. */
152 uint64_t cbRam;
153 rc = CFGMR3QueryU64Def(CFGMR3GetRoot(pVM), "RamSize", &cbRam, 0); AssertRCReturn(rc, rc);
154 uint64_t u64MaxPages = (cbRam >> 9)
155 + (cbRam >> 18)
156 + (cbRam >> 27)
157 + 32 * PAGE_SIZE;
158 u64MaxPages >>= PAGE_SHIFT;
159 if (u64MaxPages > PGMPOOL_IDX_LAST)
160 cMaxPages = PGMPOOL_IDX_LAST;
161 else
162 cMaxPages = (uint16_t)u64MaxPages;
163
164 /** @cfgm{/PGM/Pool/MaxPages, uint16_t, \#pages, 16, 0x3fff, F(ram-size)}
165 * The max size of the shadow page pool in pages. The pool will grow dynamically
166 * up to this limit.
167 */
168 rc = CFGMR3QueryU16Def(pCfg, "MaxPages", &cMaxPages, cMaxPages);
169 AssertLogRelRCReturn(rc, rc);
170 AssertLogRelMsgReturn(cMaxPages <= PGMPOOL_IDX_LAST && cMaxPages >= RT_ALIGN(PGMPOOL_IDX_FIRST, 16),
171 ("cMaxPages=%u (%#x)\n", cMaxPages, cMaxPages), VERR_INVALID_PARAMETER);
172 cMaxPages = RT_ALIGN(cMaxPages, 16);
173 if (cMaxPages > PGMPOOL_IDX_LAST)
174 cMaxPages = PGMPOOL_IDX_LAST;
175 LogRel(("PGM: PGMPool: cMaxPages=%u (u64MaxPages=%llu)\n", cMaxPages, u64MaxPages));
176
177 /** todo:
178 * We need to be much more careful with our allocation strategy here.
179 * For nested paging we don't need pool user info nor extents at all, but
180 * we can't check for nested paging here (too early during init to get a
181 * confirmation it can be used). The default for large memory configs is a
182 * bit large for shadow paging, so I've restricted the extent maximum to 8k
183 * (8k * 16 = 128k of hyper heap).
184 *
185 * Also when large page support is enabled, we typically don't need so much,
186 * although that depends on the availability of 2 MB chunks on the host.
187 */
188
189 /** @cfgm{/PGM/Pool/MaxUsers, uint16_t, \#users, MaxUsers, 32K, MaxPages*2}
190 * The max number of shadow page user tracking records. Each shadow page has
191 * zero of other shadow pages (or CR3s) that references it, or uses it if you
192 * like. The structures describing these relationships are allocated from a
193 * fixed sized pool. This configuration variable defines the pool size.
194 */
195 uint16_t cMaxUsers;
196 rc = CFGMR3QueryU16Def(pCfg, "MaxUsers", &cMaxUsers, cMaxPages * 2);
197 AssertLogRelRCReturn(rc, rc);
198 AssertLogRelMsgReturn(cMaxUsers >= cMaxPages && cMaxPages <= _32K,
199 ("cMaxUsers=%u (%#x)\n", cMaxUsers, cMaxUsers), VERR_INVALID_PARAMETER);
200
201 /** @cfgm{/PGM/Pool/MaxPhysExts, uint16_t, \#extents, 16, MaxPages * 2, MIN(MaxPages*2\,8192)}
202 * The max number of extents for tracking aliased guest pages.
203 */
204 uint16_t cMaxPhysExts;
205 rc = CFGMR3QueryU16Def(pCfg, "MaxPhysExts", &cMaxPhysExts,
206 RT_MIN(cMaxPages * 2, 8192 /* 8Ki max as this eat too much hyper heap */));
207 AssertLogRelRCReturn(rc, rc);
208 AssertLogRelMsgReturn(cMaxPhysExts >= 16 && cMaxPhysExts <= PGMPOOL_IDX_LAST,
209 ("cMaxPhysExts=%u (%#x)\n", cMaxPhysExts, cMaxPhysExts), VERR_INVALID_PARAMETER);
210
211 /** @cfgm{/PGM/Pool/ChacheEnabled, bool, true}
212 * Enables or disabling caching of shadow pages. Caching means that we will try
213 * reuse shadow pages instead of recreating them everything SyncCR3, SyncPT or
214 * SyncPage requests one. When reusing a shadow page, we can save time
215 * reconstructing it and it's children.
216 */
217 bool fCacheEnabled;
218 rc = CFGMR3QueryBoolDef(pCfg, "CacheEnabled", &fCacheEnabled, true);
219 AssertLogRelRCReturn(rc, rc);
220
221 LogRel(("PGM: pgmR3PoolInit: cMaxPages=%#RX16 cMaxUsers=%#RX16 cMaxPhysExts=%#RX16 fCacheEnable=%RTbool\n",
222 cMaxPages, cMaxUsers, cMaxPhysExts, fCacheEnabled));
223
224 /*
225 * Allocate the data structures.
226 */
227 uint32_t cb = RT_OFFSETOF(PGMPOOL, aPages[cMaxPages]);
228 cb += cMaxUsers * sizeof(PGMPOOLUSER);
229 cb += cMaxPhysExts * sizeof(PGMPOOLPHYSEXT);
230 PPGMPOOL pPool;
231 rc = MMR3HyperAllocOnceNoRel(pVM, cb, 0, MM_TAG_PGM_POOL, (void **)&pPool);
232 if (RT_FAILURE(rc))
233 return rc;
234 pVM->pgm.s.pPoolR3 = pPool;
235 pVM->pgm.s.pPoolR0 = MMHyperR3ToR0(pVM, pPool);
236 pVM->pgm.s.pPoolRC = MMHyperR3ToRC(pVM, pPool);
237
238 /*
239 * Initialize it.
240 */
241 pPool->pVMR3 = pVM;
242 pPool->pVMR0 = pVM->pVMR0;
243 pPool->pVMRC = pVM->pVMRC;
244 pPool->cMaxPages = cMaxPages;
245 pPool->cCurPages = PGMPOOL_IDX_FIRST;
246 pPool->iUserFreeHead = 0;
247 pPool->cMaxUsers = cMaxUsers;
248 PPGMPOOLUSER paUsers = (PPGMPOOLUSER)&pPool->aPages[pPool->cMaxPages];
249 pPool->paUsersR3 = paUsers;
250 pPool->paUsersR0 = MMHyperR3ToR0(pVM, paUsers);
251 pPool->paUsersRC = MMHyperR3ToRC(pVM, paUsers);
252 for (unsigned i = 0; i < cMaxUsers; i++)
253 {
254 paUsers[i].iNext = i + 1;
255 paUsers[i].iUser = NIL_PGMPOOL_IDX;
256 paUsers[i].iUserTable = 0xfffffffe;
257 }
258 paUsers[cMaxUsers - 1].iNext = NIL_PGMPOOL_USER_INDEX;
259 pPool->iPhysExtFreeHead = 0;
260 pPool->cMaxPhysExts = cMaxPhysExts;
261 PPGMPOOLPHYSEXT paPhysExts = (PPGMPOOLPHYSEXT)&paUsers[cMaxUsers];
262 pPool->paPhysExtsR3 = paPhysExts;
263 pPool->paPhysExtsR0 = MMHyperR3ToR0(pVM, paPhysExts);
264 pPool->paPhysExtsRC = MMHyperR3ToRC(pVM, paPhysExts);
265 for (unsigned i = 0; i < cMaxPhysExts; i++)
266 {
267 paPhysExts[i].iNext = i + 1;
268 paPhysExts[i].aidx[0] = NIL_PGMPOOL_IDX;
269 paPhysExts[i].apte[0] = NIL_PGMPOOL_PHYSEXT_IDX_PTE;
270 paPhysExts[i].aidx[1] = NIL_PGMPOOL_IDX;
271 paPhysExts[i].apte[1] = NIL_PGMPOOL_PHYSEXT_IDX_PTE;
272 paPhysExts[i].aidx[2] = NIL_PGMPOOL_IDX;
273 paPhysExts[i].apte[2] = NIL_PGMPOOL_PHYSEXT_IDX_PTE;
274 }
275 paPhysExts[cMaxPhysExts - 1].iNext = NIL_PGMPOOL_PHYSEXT_INDEX;
276 for (unsigned i = 0; i < RT_ELEMENTS(pPool->aiHash); i++)
277 pPool->aiHash[i] = NIL_PGMPOOL_IDX;
278 pPool->iAgeHead = NIL_PGMPOOL_IDX;
279 pPool->iAgeTail = NIL_PGMPOOL_IDX;
280 pPool->fCacheEnabled = fCacheEnabled;
281
282 pPool->hAccessHandlerType = NIL_PGMPHYSHANDLERTYPE;
283 rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE,
284 pgmPoolAccessHandler,
285 NULL, "pgmPoolAccessHandler", "pgmPoolAccessPfHandler",
286 NULL, "pgmPoolAccessHandler", "pgmPoolAccessPfHandler",
287 "Guest Paging Access Handler",
288 &pPool->hAccessHandlerType);
289 AssertLogRelRCReturn(rc, rc);
290
291 pPool->HCPhysTree = 0;
292
293 /*
294 * The NIL entry.
295 */
296 Assert(NIL_PGMPOOL_IDX == 0);
297 pPool->aPages[NIL_PGMPOOL_IDX].enmKind = PGMPOOLKIND_INVALID;
298 pPool->aPages[NIL_PGMPOOL_IDX].idx = NIL_PGMPOOL_IDX;
299 pPool->aPages[NIL_PGMPOOL_IDX].Core.Key = NIL_RTHCPHYS;
300 pPool->aPages[NIL_PGMPOOL_IDX].GCPhys = NIL_RTGCPHYS;
301 pPool->aPages[NIL_PGMPOOL_IDX].iNext = NIL_PGMPOOL_IDX;
302 /* pPool->aPages[NIL_PGMPOOL_IDX].cLocked = INT32_MAX; - test this out... */
303 pPool->aPages[NIL_PGMPOOL_IDX].pvPageR3 = 0;
304 pPool->aPages[NIL_PGMPOOL_IDX].iUserHead = NIL_PGMPOOL_USER_INDEX;
305 pPool->aPages[NIL_PGMPOOL_IDX].iModifiedNext = NIL_PGMPOOL_IDX;
306 pPool->aPages[NIL_PGMPOOL_IDX].iModifiedPrev = NIL_PGMPOOL_IDX;
307 pPool->aPages[NIL_PGMPOOL_IDX].iMonitoredNext = NIL_PGMPOOL_IDX;
308 pPool->aPages[NIL_PGMPOOL_IDX].iMonitoredPrev = NIL_PGMPOOL_IDX;
309 pPool->aPages[NIL_PGMPOOL_IDX].iAgeNext = NIL_PGMPOOL_IDX;
310 pPool->aPages[NIL_PGMPOOL_IDX].iAgePrev = NIL_PGMPOOL_IDX;
311
312 Assert(pPool->aPages[NIL_PGMPOOL_IDX].idx == NIL_PGMPOOL_IDX);
313 Assert(pPool->aPages[NIL_PGMPOOL_IDX].GCPhys == NIL_RTGCPHYS);
314 Assert(!pPool->aPages[NIL_PGMPOOL_IDX].fSeenNonGlobal);
315 Assert(!pPool->aPages[NIL_PGMPOOL_IDX].fMonitored);
316 Assert(!pPool->aPages[NIL_PGMPOOL_IDX].fCached);
317 Assert(!pPool->aPages[NIL_PGMPOOL_IDX].fZeroed);
318 Assert(!pPool->aPages[NIL_PGMPOOL_IDX].fReusedFlushPending);
319
320#ifdef VBOX_WITH_STATISTICS
321 /*
322 * Register statistics.
323 */
324 STAM_REG(pVM, &pPool->cCurPages, STAMTYPE_U16, "/PGM/Pool/cCurPages", STAMUNIT_PAGES, "Current pool size.");
325 STAM_REG(pVM, &pPool->cMaxPages, STAMTYPE_U16, "/PGM/Pool/cMaxPages", STAMUNIT_PAGES, "Max pool size.");
326 STAM_REG(pVM, &pPool->cUsedPages, STAMTYPE_U16, "/PGM/Pool/cUsedPages", STAMUNIT_PAGES, "The number of pages currently in use.");
327 STAM_REG(pVM, &pPool->cUsedPagesHigh, STAMTYPE_U16_RESET, "/PGM/Pool/cUsedPagesHigh", STAMUNIT_PAGES, "The high watermark for cUsedPages.");
328 STAM_REG(pVM, &pPool->StatAlloc, STAMTYPE_PROFILE_ADV, "/PGM/Pool/Alloc", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolAlloc.");
329 STAM_REG(pVM, &pPool->StatClearAll, STAMTYPE_PROFILE, "/PGM/Pool/ClearAll", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmR3PoolClearAll.");
330 STAM_REG(pVM, &pPool->StatR3Reset, STAMTYPE_PROFILE, "/PGM/Pool/R3Reset", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmR3PoolReset.");
331 STAM_REG(pVM, &pPool->StatFlushPage, STAMTYPE_PROFILE, "/PGM/Pool/FlushPage", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolFlushPage.");
332 STAM_REG(pVM, &pPool->StatFree, STAMTYPE_PROFILE, "/PGM/Pool/Free", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolFree.");
333 STAM_REG(pVM, &pPool->StatForceFlushPage, STAMTYPE_COUNTER, "/PGM/Pool/FlushForce", STAMUNIT_OCCURENCES, "Counting explicit flushes by PGMPoolFlushPage().");
334 STAM_REG(pVM, &pPool->StatForceFlushDirtyPage, STAMTYPE_COUNTER, "/PGM/Pool/FlushForceDirty", STAMUNIT_OCCURENCES, "Counting explicit flushes of dirty pages by PGMPoolFlushPage().");
335 STAM_REG(pVM, &pPool->StatForceFlushReused, STAMTYPE_COUNTER, "/PGM/Pool/FlushReused", STAMUNIT_OCCURENCES, "Counting flushes for reused pages.");
336 STAM_REG(pVM, &pPool->StatZeroPage, STAMTYPE_PROFILE, "/PGM/Pool/ZeroPage", STAMUNIT_TICKS_PER_CALL, "Profiling time spent zeroing pages. Overlaps with Alloc.");
337 STAM_REG(pVM, &pPool->cMaxUsers, STAMTYPE_U16, "/PGM/Pool/Track/cMaxUsers", STAMUNIT_COUNT, "Max user tracking records.");
338 STAM_REG(pVM, &pPool->cPresent, STAMTYPE_U32, "/PGM/Pool/Track/cPresent", STAMUNIT_COUNT, "Number of present page table entries.");
339 STAM_REG(pVM, &pPool->StatTrackDeref, STAMTYPE_PROFILE, "/PGM/Pool/Track/Deref", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolTrackDeref.");
340 STAM_REG(pVM, &pPool->StatTrackFlushGCPhysPT, STAMTYPE_PROFILE, "/PGM/Pool/Track/FlushGCPhysPT", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolTrackFlushGCPhysPT.");
341 STAM_REG(pVM, &pPool->StatTrackFlushGCPhysPTs, STAMTYPE_PROFILE, "/PGM/Pool/Track/FlushGCPhysPTs", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolTrackFlushGCPhysPTs.");
342 STAM_REG(pVM, &pPool->StatTrackFlushGCPhysPTsSlow, STAMTYPE_PROFILE, "/PGM/Pool/Track/FlushGCPhysPTsSlow", STAMUNIT_TICKS_PER_CALL, "Profiling of pgmPoolTrackFlushGCPhysPTsSlow.");
343 STAM_REG(pVM, &pPool->StatTrackFlushEntry, STAMTYPE_COUNTER, "/PGM/Pool/Track/Entry/Flush", STAMUNIT_COUNT, "Nr of flushed entries.");
344 STAM_REG(pVM, &pPool->StatTrackFlushEntryKeep, STAMTYPE_COUNTER, "/PGM/Pool/Track/Entry/Update", STAMUNIT_COUNT, "Nr of updated entries.");
345 STAM_REG(pVM, &pPool->StatTrackFreeUpOneUser, STAMTYPE_COUNTER, "/PGM/Pool/Track/FreeUpOneUser", STAMUNIT_TICKS_PER_CALL, "The number of times we were out of user tracking records.");
346 STAM_REG(pVM, &pPool->StatTrackDerefGCPhys, STAMTYPE_PROFILE, "/PGM/Pool/Track/DrefGCPhys", STAMUNIT_TICKS_PER_CALL, "Profiling deref activity related tracking GC physical pages.");
347 STAM_REG(pVM, &pPool->StatTrackLinearRamSearches, STAMTYPE_COUNTER, "/PGM/Pool/Track/LinearRamSearches", STAMUNIT_OCCURENCES, "The number of times we had to do linear ram searches.");
348 STAM_REG(pVM, &pPool->StamTrackPhysExtAllocFailures,STAMTYPE_COUNTER, "/PGM/Pool/Track/PhysExtAllocFailures", STAMUNIT_OCCURENCES, "The number of failing pgmPoolTrackPhysExtAlloc calls.");
349 STAM_REG(pVM, &pPool->StatMonitorRZ, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/RZ", STAMUNIT_TICKS_PER_CALL, "Profiling the RC/R0 access handler.");
350 STAM_REG(pVM, &pPool->StatMonitorRZEmulateInstr, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/EmulateInstr", STAMUNIT_OCCURENCES, "Times we've failed interpreting the instruction.");
351 STAM_REG(pVM, &pPool->StatMonitorRZFlushPage, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/RZ/FlushPage", STAMUNIT_TICKS_PER_CALL, "Profiling the pgmPoolFlushPage calls made from the RC/R0 access handler.");
352 STAM_REG(pVM, &pPool->StatMonitorRZFlushReinit, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/FlushReinit", STAMUNIT_OCCURENCES, "Times we've detected a page table reinit.");
353 STAM_REG(pVM, &pPool->StatMonitorRZFlushModOverflow,STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/FlushOverflow", STAMUNIT_OCCURENCES, "Counting flushes for pages that are modified too often.");
354 STAM_REG(pVM, &pPool->StatMonitorRZFork, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/Fork", STAMUNIT_OCCURENCES, "Times we've detected fork().");
355 STAM_REG(pVM, &pPool->StatMonitorRZHandled, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/RZ/Handled", STAMUNIT_TICKS_PER_CALL, "Profiling the RC/R0 access we've handled (except REP STOSD).");
356 STAM_REG(pVM, &pPool->StatMonitorRZIntrFailPatch1, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/IntrFailPatch1", STAMUNIT_OCCURENCES, "Times we've failed interpreting a patch code instruction.");
357 STAM_REG(pVM, &pPool->StatMonitorRZIntrFailPatch2, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/IntrFailPatch2", STAMUNIT_OCCURENCES, "Times we've failed interpreting a patch code instruction during flushing.");
358 STAM_REG(pVM, &pPool->StatMonitorRZRepPrefix, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/RepPrefix", STAMUNIT_OCCURENCES, "The number of times we've seen rep prefixes we can't handle.");
359 STAM_REG(pVM, &pPool->StatMonitorRZRepStosd, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/RZ/RepStosd", STAMUNIT_TICKS_PER_CALL, "Profiling the REP STOSD cases we've handled.");
360 STAM_REG(pVM, &pPool->StatMonitorRZFaultPT, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/Fault/PT", STAMUNIT_OCCURENCES, "Nr of handled PT faults.");
361 STAM_REG(pVM, &pPool->StatMonitorRZFaultPD, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/Fault/PD", STAMUNIT_OCCURENCES, "Nr of handled PD faults.");
362 STAM_REG(pVM, &pPool->StatMonitorRZFaultPDPT, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/Fault/PDPT", STAMUNIT_OCCURENCES, "Nr of handled PDPT faults.");
363 STAM_REG(pVM, &pPool->StatMonitorRZFaultPML4, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/RZ/Fault/PML4", STAMUNIT_OCCURENCES, "Nr of handled PML4 faults.");
364 STAM_REG(pVM, &pPool->StatMonitorR3, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/R3", STAMUNIT_TICKS_PER_CALL, "Profiling the R3 access handler.");
365 STAM_REG(pVM, &pPool->StatMonitorR3EmulateInstr, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/EmulateInstr", STAMUNIT_OCCURENCES, "Times we've failed interpreting the instruction.");
366 STAM_REG(pVM, &pPool->StatMonitorR3FlushPage, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/R3/FlushPage", STAMUNIT_TICKS_PER_CALL, "Profiling the pgmPoolFlushPage calls made from the R3 access handler.");
367 STAM_REG(pVM, &pPool->StatMonitorR3FlushReinit, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/FlushReinit", STAMUNIT_OCCURENCES, "Times we've detected a page table reinit.");
368 STAM_REG(pVM, &pPool->StatMonitorR3FlushModOverflow,STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/FlushOverflow", STAMUNIT_OCCURENCES, "Counting flushes for pages that are modified too often.");
369 STAM_REG(pVM, &pPool->StatMonitorR3Fork, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/Fork", STAMUNIT_OCCURENCES, "Times we've detected fork().");
370 STAM_REG(pVM, &pPool->StatMonitorR3Handled, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/R3/Handled", STAMUNIT_TICKS_PER_CALL, "Profiling the R3 access we've handled (except REP STOSD).");
371 STAM_REG(pVM, &pPool->StatMonitorR3RepPrefix, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/RepPrefix", STAMUNIT_OCCURENCES, "The number of times we've seen rep prefixes we can't handle.");
372 STAM_REG(pVM, &pPool->StatMonitorR3RepStosd, STAMTYPE_PROFILE, "/PGM/Pool/Monitor/R3/RepStosd", STAMUNIT_TICKS_PER_CALL, "Profiling the REP STOSD cases we've handled.");
373 STAM_REG(pVM, &pPool->StatMonitorR3FaultPT, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/Fault/PT", STAMUNIT_OCCURENCES, "Nr of handled PT faults.");
374 STAM_REG(pVM, &pPool->StatMonitorR3FaultPD, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/Fault/PD", STAMUNIT_OCCURENCES, "Nr of handled PD faults.");
375 STAM_REG(pVM, &pPool->StatMonitorR3FaultPDPT, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/Fault/PDPT", STAMUNIT_OCCURENCES, "Nr of handled PDPT faults.");
376 STAM_REG(pVM, &pPool->StatMonitorR3FaultPML4, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/Fault/PML4", STAMUNIT_OCCURENCES, "Nr of handled PML4 faults.");
377 STAM_REG(pVM, &pPool->StatMonitorR3Async, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/R3/Async", STAMUNIT_OCCURENCES, "Times we're called in an async thread and need to flush.");
378 STAM_REG(pVM, &pPool->cModifiedPages, STAMTYPE_U16, "/PGM/Pool/Monitor/cModifiedPages", STAMUNIT_PAGES, "The current cModifiedPages value.");
379 STAM_REG(pVM, &pPool->cModifiedPagesHigh, STAMTYPE_U16_RESET, "/PGM/Pool/Monitor/cModifiedPagesHigh", STAMUNIT_PAGES, "The high watermark for cModifiedPages.");
380 STAM_REG(pVM, &pPool->StatResetDirtyPages, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/Dirty/Resets", STAMUNIT_OCCURENCES, "Times we've called pgmPoolResetDirtyPages (and there were dirty page).");
381 STAM_REG(pVM, &pPool->StatDirtyPage, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/Dirty/Pages", STAMUNIT_OCCURENCES, "Times we've called pgmPoolAddDirtyPage.");
382 STAM_REG(pVM, &pPool->StatDirtyPageDupFlush, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/Dirty/FlushDup", STAMUNIT_OCCURENCES, "Times we've had to flush duplicates for dirty page management.");
383 STAM_REG(pVM, &pPool->StatDirtyPageOverFlowFlush, STAMTYPE_COUNTER, "/PGM/Pool/Monitor/Dirty/FlushOverflow",STAMUNIT_OCCURENCES, "Times we've had to flush because of overflow.");
384 STAM_REG(pVM, &pPool->StatCacheHits, STAMTYPE_COUNTER, "/PGM/Pool/Cache/Hits", STAMUNIT_OCCURENCES, "The number of pgmPoolAlloc calls satisfied by the cache.");
385 STAM_REG(pVM, &pPool->StatCacheMisses, STAMTYPE_COUNTER, "/PGM/Pool/Cache/Misses", STAMUNIT_OCCURENCES, "The number of pgmPoolAlloc calls not statisfied by the cache.");
386 STAM_REG(pVM, &pPool->StatCacheKindMismatches, STAMTYPE_COUNTER, "/PGM/Pool/Cache/KindMismatches", STAMUNIT_OCCURENCES, "The number of shadow page kind mismatches. (Better be low, preferably 0!)");
387 STAM_REG(pVM, &pPool->StatCacheFreeUpOne, STAMTYPE_COUNTER, "/PGM/Pool/Cache/FreeUpOne", STAMUNIT_OCCURENCES, "The number of times the cache was asked to free up a page.");
388 STAM_REG(pVM, &pPool->StatCacheCacheable, STAMTYPE_COUNTER, "/PGM/Pool/Cache/Cacheable", STAMUNIT_OCCURENCES, "The number of cacheable allocations.");
389 STAM_REG(pVM, &pPool->StatCacheUncacheable, STAMTYPE_COUNTER, "/PGM/Pool/Cache/Uncacheable", STAMUNIT_OCCURENCES, "The number of uncacheable allocations.");
390#endif /* VBOX_WITH_STATISTICS */
391
392#ifdef VBOX_WITH_DEBUGGER
393 /*
394 * Debugger commands.
395 */
396 static bool s_fRegisteredCmds = false;
397 if (!s_fRegisteredCmds)
398 {
399 rc = DBGCRegisterCommands(&g_aCmds[0], RT_ELEMENTS(g_aCmds));
400 if (RT_SUCCESS(rc))
401 s_fRegisteredCmds = true;
402 }
403#endif
404
405 return VINF_SUCCESS;
406}
407
408
409/**
410 * Relocate the page pool data.
411 *
412 * @param pVM The cross context VM structure.
413 */
414void pgmR3PoolRelocate(PVM pVM)
415{
416 pVM->pgm.s.pPoolRC = MMHyperR3ToRC(pVM, pVM->pgm.s.pPoolR3);
417 pVM->pgm.s.pPoolR3->pVMRC = pVM->pVMRC;
418 pVM->pgm.s.pPoolR3->paUsersRC = MMHyperR3ToRC(pVM, pVM->pgm.s.pPoolR3->paUsersR3);
419 pVM->pgm.s.pPoolR3->paPhysExtsRC = MMHyperR3ToRC(pVM, pVM->pgm.s.pPoolR3->paPhysExtsR3);
420}
421
422
423/**
424 * Grows the shadow page pool.
425 *
426 * I.e. adds more pages to it, assuming that hasn't reached cMaxPages yet.
427 *
428 * @returns VBox status code.
429 * @param pVM The cross context VM structure.
430 */
431VMMR3DECL(int) PGMR3PoolGrow(PVM pVM)
432{
433 PPGMPOOL pPool = pVM->pgm.s.pPoolR3;
434 AssertReturn(pPool->cCurPages < pPool->cMaxPages, VERR_PGM_POOL_MAXED_OUT_ALREADY);
435
436 /* With 32-bit guests and no EPT, the CR3 limits the root pages to low
437 (below 4 GB) memory. */
438 /** @todo change the pool to handle ROOT page allocations specially when
439 * required. */
440 bool fCanUseHighMemory = HMIsNestedPagingActive(pVM)
441 && HMGetShwPagingMode(pVM) == PGMMODE_EPT;
442
443 pgmLock(pVM);
444
445 /*
446 * How much to grow it by?
447 */
448 uint32_t cPages = pPool->cMaxPages - pPool->cCurPages;
449 cPages = RT_MIN(PGMPOOL_CFG_MAX_GROW, cPages);
450 LogFlow(("PGMR3PoolGrow: Growing the pool by %d (%#x) pages. fCanUseHighMemory=%RTbool\n", cPages, cPages, fCanUseHighMemory));
451
452 for (unsigned i = pPool->cCurPages; cPages-- > 0; i++)
453 {
454 PPGMPOOLPAGE pPage = &pPool->aPages[i];
455
456 if (fCanUseHighMemory)
457 pPage->pvPageR3 = MMR3PageAlloc(pVM);
458 else
459 pPage->pvPageR3 = MMR3PageAllocLow(pVM);
460 if (!pPage->pvPageR3)
461 {
462 Log(("We're out of memory!! i=%d fCanUseHighMemory=%RTbool\n", i, fCanUseHighMemory));
463 pgmUnlock(pVM);
464 return i ? VINF_SUCCESS : VERR_NO_PAGE_MEMORY;
465 }
466 pPage->Core.Key = MMPage2Phys(pVM, pPage->pvPageR3);
467 AssertFatal(pPage->Core.Key < _4G || fCanUseHighMemory);
468 pPage->GCPhys = NIL_RTGCPHYS;
469 pPage->enmKind = PGMPOOLKIND_FREE;
470 pPage->idx = pPage - &pPool->aPages[0];
471 LogFlow(("PGMR3PoolGrow: insert page #%#x - %RHp\n", pPage->idx, pPage->Core.Key));
472 pPage->iNext = pPool->iFreeHead;
473 pPage->iUserHead = NIL_PGMPOOL_USER_INDEX;
474 pPage->iModifiedNext = NIL_PGMPOOL_IDX;
475 pPage->iModifiedPrev = NIL_PGMPOOL_IDX;
476 pPage->iMonitoredNext = NIL_PGMPOOL_IDX;
477 pPage->iMonitoredPrev = NIL_PGMPOOL_IDX;
478 pPage->iAgeNext = NIL_PGMPOOL_IDX;
479 pPage->iAgePrev = NIL_PGMPOOL_IDX;
480 /* commit it */
481 bool fRc = RTAvloHCPhysInsert(&pPool->HCPhysTree, &pPage->Core); Assert(fRc); NOREF(fRc);
482 pPool->iFreeHead = i;
483 pPool->cCurPages = i + 1;
484 }
485
486 pgmUnlock(pVM);
487 Assert(pPool->cCurPages <= pPool->cMaxPages);
488 return VINF_SUCCESS;
489}
490
491
492/**
493 * Rendezvous callback used by pgmR3PoolClearAll that clears all shadow pages
494 * and all modification counters.
495 *
496 * This is only called on one of the EMTs while the other ones are waiting for
497 * it to complete this function.
498 *
499 * @returns VINF_SUCCESS (VBox strict status code).
500 * @param pVM The cross context VM structure.
501 * @param pVCpu The cross context virtual CPU structure of the calling EMT. Unused.
502 * @param fpvFlushRemTlb When not NULL, we'll flush the REM TLB as well.
503 * (This is the pvUser, so it has to be void *.)
504 *
505 */
506DECLCALLBACK(VBOXSTRICTRC) pgmR3PoolClearAllRendezvous(PVM pVM, PVMCPU pVCpu, void *fpvFlushRemTlb)
507{
508 PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
509 STAM_PROFILE_START(&pPool->StatClearAll, c);
510 NOREF(pVCpu);
511
512 pgmLock(pVM);
513 Log(("pgmR3PoolClearAllRendezvous: cUsedPages=%d fpvFlushRemTlb=%RTbool\n", pPool->cUsedPages, !!fpvFlushRemTlb));
514
515 /*
516 * Iterate all the pages until we've encountered all that are in use.
517 * This is a simple but not quite optimal solution.
518 */
519 unsigned cModifiedPages = 0; NOREF(cModifiedPages);
520 unsigned cLeft = pPool->cUsedPages;
521 uint32_t iPage = pPool->cCurPages;
522 while (--iPage >= PGMPOOL_IDX_FIRST)
523 {
524 PPGMPOOLPAGE pPage = &pPool->aPages[iPage];
525 if (pPage->GCPhys != NIL_RTGCPHYS)
526 {
527 switch (pPage->enmKind)
528 {
529 /*
530 * We only care about shadow page tables that reference physical memory
531 */
532#ifdef PGM_WITH_LARGE_PAGES
533 case PGMPOOLKIND_EPT_PD_FOR_PHYS: /* Large pages reference 2 MB of physical memory, so we must clear them. */
534 if (pPage->cPresent)
535 {
536 PX86PDPAE pShwPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR_V2(pPool->CTX_SUFF(pVM), pVCpu, pPage);
537 for (unsigned i = 0; i < RT_ELEMENTS(pShwPD->a); i++)
538 {
539 if ( pShwPD->a[i].n.u1Present
540 && pShwPD->a[i].b.u1Size)
541 {
542 Assert(!(pShwPD->a[i].u & PGM_PDFLAGS_MAPPING));
543 pShwPD->a[i].u = 0;
544 Assert(pPage->cPresent);
545 pPage->cPresent--;
546 }
547 }
548 if (pPage->cPresent == 0)
549 pPage->iFirstPresent = NIL_PGMPOOL_PRESENT_INDEX;
550 }
551 goto default_case;
552
553 case PGMPOOLKIND_PAE_PD_PHYS: /* Large pages reference 2 MB of physical memory, so we must clear them. */
554 if (pPage->cPresent)
555 {
556 PEPTPD pShwPD = (PEPTPD)PGMPOOL_PAGE_2_PTR_V2(pPool->CTX_SUFF(pVM), pVCpu, pPage);
557 for (unsigned i = 0; i < RT_ELEMENTS(pShwPD->a); i++)
558 {
559 Assert((pShwPD->a[i].u & UINT64_C(0xfff0000000000f80)) == 0);
560 if ( pShwPD->a[i].n.u1Present
561 && pShwPD->a[i].b.u1Size)
562 {
563 Assert(!(pShwPD->a[i].u & PGM_PDFLAGS_MAPPING));
564 pShwPD->a[i].u = 0;
565 Assert(pPage->cPresent);
566 pPage->cPresent--;
567 }
568 }
569 if (pPage->cPresent == 0)
570 pPage->iFirstPresent = NIL_PGMPOOL_PRESENT_INDEX;
571 }
572 goto default_case;
573#endif /* PGM_WITH_LARGE_PAGES */
574
575 case PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT:
576 case PGMPOOLKIND_32BIT_PT_FOR_32BIT_4MB:
577 case PGMPOOLKIND_PAE_PT_FOR_32BIT_PT:
578 case PGMPOOLKIND_PAE_PT_FOR_32BIT_4MB:
579 case PGMPOOLKIND_PAE_PT_FOR_PAE_PT:
580 case PGMPOOLKIND_PAE_PT_FOR_PAE_2MB:
581 case PGMPOOLKIND_32BIT_PT_FOR_PHYS:
582 case PGMPOOLKIND_PAE_PT_FOR_PHYS:
583 case PGMPOOLKIND_EPT_PT_FOR_PHYS:
584 {
585 if (pPage->cPresent)
586 {
587 void *pvShw = PGMPOOL_PAGE_2_PTR_V2(pPool->CTX_SUFF(pVM), pVCpu, pPage);
588 STAM_PROFILE_START(&pPool->StatZeroPage, z);
589#if 0
590 /* Useful check for leaking references; *very* expensive though. */
591 switch (pPage->enmKind)
592 {
593 case PGMPOOLKIND_PAE_PT_FOR_32BIT_PT:
594 case PGMPOOLKIND_PAE_PT_FOR_32BIT_4MB:
595 case PGMPOOLKIND_PAE_PT_FOR_PAE_PT:
596 case PGMPOOLKIND_PAE_PT_FOR_PAE_2MB:
597 case PGMPOOLKIND_PAE_PT_FOR_PHYS:
598 {
599 bool fFoundFirst = false;
600 PPGMSHWPTPAE pPT = (PPGMSHWPTPAE)pvShw;
601 for (unsigned ptIndex = 0; ptIndex < RT_ELEMENTS(pPT->a); ptIndex++)
602 {
603 if (pPT->a[ptIndex].u)
604 {
605 if (!fFoundFirst)
606 {
607 AssertFatalMsg(pPage->iFirstPresent <= ptIndex, ("ptIndex = %d first present = %d\n", ptIndex, pPage->iFirstPresent));
608 if (pPage->iFirstPresent != ptIndex)
609 Log(("ptIndex = %d first present = %d\n", ptIndex, pPage->iFirstPresent));
610 fFoundFirst = true;
611 }
612 if (PGMSHWPTEPAE_IS_P(pPT->a[ptIndex]))
613 {
614 pgmPoolTracDerefGCPhysHint(pPool, pPage, PGMSHWPTEPAE_GET_HCPHYS(pPT->a[ptIndex]), NIL_RTGCPHYS);
615 if (pPage->iFirstPresent == ptIndex)
616 pPage->iFirstPresent = NIL_PGMPOOL_PRESENT_INDEX;
617 }
618 }
619 }
620 AssertFatalMsg(pPage->cPresent == 0, ("cPresent = %d pPage = %RGv\n", pPage->cPresent, pPage->GCPhys));
621 break;
622 }
623 default:
624 break;
625 }
626#endif
627 ASMMemZeroPage(pvShw);
628 STAM_PROFILE_STOP(&pPool->StatZeroPage, z);
629 pPage->cPresent = 0;
630 pPage->iFirstPresent = NIL_PGMPOOL_PRESENT_INDEX;
631 }
632 }
633 /* fall thru */
634
635#ifdef PGM_WITH_LARGE_PAGES
636 default_case:
637#endif
638 default:
639 Assert(!pPage->cModifications || ++cModifiedPages);
640 Assert(pPage->iModifiedNext == NIL_PGMPOOL_IDX || pPage->cModifications);
641 Assert(pPage->iModifiedPrev == NIL_PGMPOOL_IDX || pPage->cModifications);
642 pPage->iModifiedNext = NIL_PGMPOOL_IDX;
643 pPage->iModifiedPrev = NIL_PGMPOOL_IDX;
644 pPage->cModifications = 0;
645 break;
646
647 }
648 if (!--cLeft)
649 break;
650 }
651 }
652
653#ifndef DEBUG_michael
654 AssertMsg(cModifiedPages == pPool->cModifiedPages, ("%d != %d\n", cModifiedPages, pPool->cModifiedPages));
655#endif
656 pPool->iModifiedHead = NIL_PGMPOOL_IDX;
657 pPool->cModifiedPages = 0;
658
659 /*
660 * Clear all the GCPhys links and rebuild the phys ext free list.
661 */
662 for (PPGMRAMRANGE pRam = pPool->CTX_SUFF(pVM)->pgm.s.CTX_SUFF(pRamRangesX);
663 pRam;
664 pRam = pRam->CTX_SUFF(pNext))
665 {
666 iPage = pRam->cb >> PAGE_SHIFT;
667 while (iPage-- > 0)
668 PGM_PAGE_SET_TRACKING(pVM, &pRam->aPages[iPage], 0);
669 }
670
671 pPool->iPhysExtFreeHead = 0;
672 PPGMPOOLPHYSEXT paPhysExts = pPool->CTX_SUFF(paPhysExts);
673 const unsigned cMaxPhysExts = pPool->cMaxPhysExts;
674 for (unsigned i = 0; i < cMaxPhysExts; i++)
675 {
676 paPhysExts[i].iNext = i + 1;
677 paPhysExts[i].aidx[0] = NIL_PGMPOOL_IDX;
678 paPhysExts[i].apte[0] = NIL_PGMPOOL_PHYSEXT_IDX_PTE;
679 paPhysExts[i].aidx[1] = NIL_PGMPOOL_IDX;
680 paPhysExts[i].apte[1] = NIL_PGMPOOL_PHYSEXT_IDX_PTE;
681 paPhysExts[i].aidx[2] = NIL_PGMPOOL_IDX;
682 paPhysExts[i].apte[2] = NIL_PGMPOOL_PHYSEXT_IDX_PTE;
683 }
684 paPhysExts[cMaxPhysExts - 1].iNext = NIL_PGMPOOL_PHYSEXT_INDEX;
685
686
687#ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
688 /* Reset all dirty pages to reactivate the page monitoring. */
689 /* Note: we must do this *after* clearing all page references and shadow page tables as there might be stale references to
690 * recently removed MMIO ranges around that might otherwise end up asserting in pgmPoolTracDerefGCPhysHint
691 */
692 for (unsigned i = 0; i < RT_ELEMENTS(pPool->aDirtyPages); i++)
693 {
694 PPGMPOOLPAGE pPage;
695 unsigned idxPage;
696
697 if (pPool->aDirtyPages[i].uIdx == NIL_PGMPOOL_IDX)
698 continue;
699
700 idxPage = pPool->aDirtyPages[i].uIdx;
701 AssertRelease(idxPage != NIL_PGMPOOL_IDX);
702 pPage = &pPool->aPages[idxPage];
703 Assert(pPage->idx == idxPage);
704 Assert(pPage->iMonitoredNext == NIL_PGMPOOL_IDX && pPage->iMonitoredPrev == NIL_PGMPOOL_IDX);
705
706 AssertMsg(pPage->fDirty, ("Page %RGp (slot=%d) not marked dirty!", pPage->GCPhys, i));
707
708 Log(("Reactivate dirty page %RGp\n", pPage->GCPhys));
709
710 /* First write protect the page again to catch all write accesses. (before checking for changes -> SMP) */
711 int rc = PGMHandlerPhysicalReset(pVM, pPage->GCPhys & PAGE_BASE_GC_MASK);
712 AssertRCSuccess(rc);
713 pPage->fDirty = false;
714
715 pPool->aDirtyPages[i].uIdx = NIL_PGMPOOL_IDX;
716 }
717
718 /* Clear all dirty pages. */
719 pPool->idxFreeDirtyPage = 0;
720 pPool->cDirtyPages = 0;
721#endif
722
723 /* Clear the PGM_SYNC_CLEAR_PGM_POOL flag on all VCPUs to prevent redundant flushes. */
724 for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
725 pVM->aCpus[idCpu].pgm.s.fSyncFlags &= ~PGM_SYNC_CLEAR_PGM_POOL;
726
727 /* Flush job finished. */
728 VM_FF_CLEAR(pVM, VM_FF_PGM_POOL_FLUSH_PENDING);
729 pPool->cPresent = 0;
730 pgmUnlock(pVM);
731
732 PGM_INVL_ALL_VCPU_TLBS(pVM);
733
734 if (fpvFlushRemTlb)
735 for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
736 CPUMSetChangedFlags(&pVM->aCpus[idCpu], CPUM_CHANGED_GLOBAL_TLB_FLUSH);
737
738 STAM_PROFILE_STOP(&pPool->StatClearAll, c);
739 return VINF_SUCCESS;
740}
741
742
743/**
744 * Clears the shadow page pool.
745 *
746 * @param pVM The cross context VM structure.
747 * @param fFlushRemTlb When set, the REM TLB is scheduled for flushing as
748 * well.
749 */
750void pgmR3PoolClearAll(PVM pVM, bool fFlushRemTlb)
751{
752 int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, pgmR3PoolClearAllRendezvous, &fFlushRemTlb);
753 AssertRC(rc);
754}
755
756
757/**
758 * Protect all pgm pool page table entries to monitor writes
759 *
760 * @param pVM The cross context VM structure.
761 *
762 * @remarks ASSUMES the caller will flush all TLBs!!
763 */
764void pgmR3PoolWriteProtectPages(PVM pVM)
765{
766 PGM_LOCK_ASSERT_OWNER(pVM);
767 PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
768 unsigned cLeft = pPool->cUsedPages;
769 unsigned iPage = pPool->cCurPages;
770 while (--iPage >= PGMPOOL_IDX_FIRST)
771 {
772 PPGMPOOLPAGE pPage = &pPool->aPages[iPage];
773 if ( pPage->GCPhys != NIL_RTGCPHYS
774 && pPage->cPresent)
775 {
776 union
777 {
778 void *pv;
779 PX86PT pPT;
780 PPGMSHWPTPAE pPTPae;
781 PEPTPT pPTEpt;
782 } uShw;
783 uShw.pv = PGMPOOL_PAGE_2_PTR(pVM, pPage);
784
785 switch (pPage->enmKind)
786 {
787 /*
788 * We only care about shadow page tables.
789 */
790 case PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT:
791 case PGMPOOLKIND_32BIT_PT_FOR_32BIT_4MB:
792 case PGMPOOLKIND_32BIT_PT_FOR_PHYS:
793 for (unsigned iShw = 0; iShw < RT_ELEMENTS(uShw.pPT->a); iShw++)
794 {
795 if (uShw.pPT->a[iShw].n.u1Present)
796 uShw.pPT->a[iShw].n.u1Write = 0;
797 }
798 break;
799
800 case PGMPOOLKIND_PAE_PT_FOR_32BIT_PT:
801 case PGMPOOLKIND_PAE_PT_FOR_32BIT_4MB:
802 case PGMPOOLKIND_PAE_PT_FOR_PAE_PT:
803 case PGMPOOLKIND_PAE_PT_FOR_PAE_2MB:
804 case PGMPOOLKIND_PAE_PT_FOR_PHYS:
805 for (unsigned iShw = 0; iShw < RT_ELEMENTS(uShw.pPTPae->a); iShw++)
806 {
807 if (PGMSHWPTEPAE_IS_P(uShw.pPTPae->a[iShw]))
808 PGMSHWPTEPAE_SET_RO(uShw.pPTPae->a[iShw]);
809 }
810 break;
811
812 case PGMPOOLKIND_EPT_PT_FOR_PHYS:
813 for (unsigned iShw = 0; iShw < RT_ELEMENTS(uShw.pPTEpt->a); iShw++)
814 {
815 if (uShw.pPTEpt->a[iShw].n.u1Present)
816 uShw.pPTEpt->a[iShw].n.u1Write = 0;
817 }
818 break;
819
820 default:
821 break;
822 }
823 if (!--cLeft)
824 break;
825 }
826 }
827}
828
829#ifdef VBOX_WITH_DEBUGGER
830/**
831 * @callback_method_impl{FNDBGCCMD, The '.pgmpoolcheck' command.}
832 */
833static DECLCALLBACK(int) pgmR3PoolCmdCheck(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
834{
835 DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
836 PVM pVM = pUVM->pVM;
837 VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
838 DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs == 0);
839 uint32_t cErrors = 0;
840 NOREF(paArgs);
841
842 PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
843 for (unsigned i = 0; i < pPool->cCurPages; i++)
844 {
845 PPGMPOOLPAGE pPage = &pPool->aPages[i];
846 bool fFirstMsg = true;
847
848 /* Todo: cover other paging modes too. */
849 if (pPage->enmKind == PGMPOOLKIND_PAE_PT_FOR_PAE_PT)
850 {
851 PPGMSHWPTPAE pShwPT = (PPGMSHWPTPAE)PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
852 {
853 PX86PTPAE pGstPT;
854 PGMPAGEMAPLOCK LockPage;
855 int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, pPage->GCPhys, (const void **)&pGstPT, &LockPage); AssertReleaseRC(rc);
856
857 /* Check if any PTEs are out of sync. */
858 for (unsigned j = 0; j < RT_ELEMENTS(pShwPT->a); j++)
859 {
860 if (PGMSHWPTEPAE_IS_P(pShwPT->a[j]))
861 {
862 RTHCPHYS HCPhys = NIL_RTHCPHYS;
863 rc = PGMPhysGCPhys2HCPhys(pPool->CTX_SUFF(pVM), pGstPT->a[j].u & X86_PTE_PAE_PG_MASK, &HCPhys);
864 if ( rc != VINF_SUCCESS
865 || PGMSHWPTEPAE_GET_HCPHYS(pShwPT->a[j]) != HCPhys)
866 {
867 if (fFirstMsg)
868 {
869 DBGCCmdHlpPrintf(pCmdHlp, "Check pool page %RGp\n", pPage->GCPhys);
870 fFirstMsg = false;
871 }
872 DBGCCmdHlpPrintf(pCmdHlp, "Mismatch HCPhys: rc=%Rrc idx=%d guest %RX64 shw=%RX64 vs %RHp\n", rc, j, pGstPT->a[j].u, PGMSHWPTEPAE_GET_LOG(pShwPT->a[j]), HCPhys);
873 cErrors++;
874 }
875 else if ( PGMSHWPTEPAE_IS_RW(pShwPT->a[j])
876 && !pGstPT->a[j].n.u1Write)
877 {
878 if (fFirstMsg)
879 {
880 DBGCCmdHlpPrintf(pCmdHlp, "Check pool page %RGp\n", pPage->GCPhys);
881 fFirstMsg = false;
882 }
883 DBGCCmdHlpPrintf(pCmdHlp, "Mismatch r/w gst/shw: idx=%d guest %RX64 shw=%RX64 vs %RHp\n", j, pGstPT->a[j].u, PGMSHWPTEPAE_GET_LOG(pShwPT->a[j]), HCPhys);
884 cErrors++;
885 }
886 }
887 }
888 PGMPhysReleasePageMappingLock(pVM, &LockPage);
889 }
890
891 /* Make sure this page table can't be written to from any shadow mapping. */
892 RTHCPHYS HCPhysPT = NIL_RTHCPHYS;
893 int rc = PGMPhysGCPhys2HCPhys(pPool->CTX_SUFF(pVM), pPage->GCPhys, &HCPhysPT);
894 AssertMsgRC(rc, ("PGMPhysGCPhys2HCPhys failed with rc=%d for %RGp\n", rc, pPage->GCPhys));
895 if (rc == VINF_SUCCESS)
896 {
897 for (unsigned j = 0; j < pPool->cCurPages; j++)
898 {
899 PPGMPOOLPAGE pTempPage = &pPool->aPages[j];
900
901 if (pTempPage->enmKind == PGMPOOLKIND_PAE_PT_FOR_PAE_PT)
902 {
903 PPGMSHWPTPAE pShwPT2 = (PPGMSHWPTPAE)PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pTempPage);
904
905 for (unsigned k = 0; k < RT_ELEMENTS(pShwPT->a); k++)
906 {
907 if ( PGMSHWPTEPAE_IS_P_RW(pShwPT2->a[k])
908# ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
909 && !pPage->fDirty
910# endif
911 && PGMSHWPTEPAE_GET_HCPHYS(pShwPT2->a[k]) == HCPhysPT)
912 {
913 if (fFirstMsg)
914 {
915 DBGCCmdHlpPrintf(pCmdHlp, "Check pool page %RGp\n", pPage->GCPhys);
916 fFirstMsg = false;
917 }
918 DBGCCmdHlpPrintf(pCmdHlp, "Mismatch: r/w: GCPhys=%RGp idx=%d shw %RX64 %RX64\n", pTempPage->GCPhys, k, PGMSHWPTEPAE_GET_LOG(pShwPT->a[k]), PGMSHWPTEPAE_GET_LOG(pShwPT2->a[k]));
919 cErrors++;
920 }
921 }
922 }
923 }
924 }
925 }
926 }
927 if (cErrors > 0)
928 return DBGCCmdHlpFail(pCmdHlp, pCmd, "Found %#x errors", cErrors);
929 return VINF_SUCCESS;
930}
931#endif /* VBOX_WITH_DEBUGGER */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette