VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/PGMMap.cpp@ 66651

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

VMM: warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 51.7 KB
Line 
1/* $Id: PGMMap.cpp 63429 2016-08-13 23:39:36Z vboxsync $ */
2/** @file
3 * PGM - Page Manager, Guest Context Mappings.
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_PGM
23#include <VBox/vmm/dbgf.h>
24#include <VBox/vmm/pgm.h>
25#include "PGMInternal.h"
26#include <VBox/vmm/vm.h>
27#include "PGMInline.h"
28
29#include <VBox/log.h>
30#include <VBox/err.h>
31#include <iprt/asm.h>
32#include <iprt/assert.h>
33#include <iprt/string.h>
34
35
36/*********************************************************************************************************************************
37* Internal Functions *
38*********************************************************************************************************************************/
39#ifndef PGM_WITHOUT_MAPPINGS
40static void pgmR3MapClearPDEs(PVM pVM, PPGMMAPPING pMap, unsigned iOldPDE);
41static void pgmR3MapSetPDEs(PVM pVM, PPGMMAPPING pMap, unsigned iNewPDE);
42static int pgmR3MapIntermediateCheckOne(PVM pVM, uintptr_t uAddress, unsigned cPages, PX86PT pPTDefault, PX86PTPAE pPTPaeDefault);
43static void pgmR3MapIntermediateDoOne(PVM pVM, uintptr_t uAddress, RTHCPHYS HCPhys, unsigned cPages, PX86PT pPTDefault, PX86PTPAE pPTPaeDefault);
44#else
45# define pgmR3MapClearPDEs(pVM, pMap, iNewPDE) do { } while (0)
46# define pgmR3MapSetPDEs(pVM, pMap, iNewPDE) do { } while (0)
47#endif
48
49
50/**
51 * Creates a page table based mapping in GC.
52 *
53 * @returns VBox status code.
54 * @param pVM The cross context VM structure.
55 * @param GCPtr Virtual Address. (Page table aligned!)
56 * @param cb Size of the range. Must be a 4MB aligned!
57 * @param fFlags PGMR3MAPPT_FLAGS_UNMAPPABLE or 0.
58 * @param pfnRelocate Relocation callback function.
59 * @param pvUser User argument to the callback.
60 * @param pszDesc Pointer to description string. This must not be freed.
61 */
62VMMR3DECL(int) PGMR3MapPT(PVM pVM, RTGCPTR GCPtr, uint32_t cb, uint32_t fFlags, PFNPGMRELOCATE pfnRelocate, void *pvUser, const char *pszDesc)
63{
64 LogFlow(("PGMR3MapPT: GCPtr=%#x cb=%d fFlags=%#x pfnRelocate=%p pvUser=%p pszDesc=%s\n", GCPtr, cb, fFlags, pfnRelocate, pvUser, pszDesc));
65 AssertMsg(pVM->pgm.s.pInterPD, ("Paging isn't initialized, init order problems!\n"));
66
67 /*
68 * Validate input.
69 */
70 Assert(!fFlags || fFlags == PGMR3MAPPT_FLAGS_UNMAPPABLE);
71 if (cb < _2M || cb > 64 * _1M)
72 {
73 AssertMsgFailed(("Serious? cb=%d\n", cb));
74 return VERR_INVALID_PARAMETER;
75 }
76 cb = RT_ALIGN_32(cb, _4M);
77 RTGCPTR GCPtrLast = GCPtr + cb - 1;
78
79 AssertMsgReturn(GCPtrLast >= GCPtr, ("Range wraps! GCPtr=%x GCPtrLast=%x\n", GCPtr, GCPtrLast),
80 VERR_INVALID_PARAMETER);
81 AssertMsgReturn(!pVM->pgm.s.fMappingsFixed, ("Mappings are fixed! It's not possible to add new mappings at this time!\n"),
82 VERR_PGM_MAPPINGS_FIXED);
83 AssertPtrReturn(pfnRelocate, VERR_INVALID_PARAMETER);
84
85 /*
86 * Find list location.
87 */
88 PPGMMAPPING pPrev = NULL;
89 PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3;
90 while (pCur)
91 {
92 if (pCur->GCPtrLast >= GCPtr && pCur->GCPtr <= GCPtrLast)
93 {
94 AssertMsgFailed(("Address is already in use by %s. req %#x-%#x take %#x-%#x\n",
95 pCur->pszDesc, GCPtr, GCPtrLast, pCur->GCPtr, pCur->GCPtrLast));
96 LogRel(("VERR_PGM_MAPPING_CONFLICT: Address is already in use by %s. req %#x-%#x take %#x-%#x\n",
97 pCur->pszDesc, GCPtr, GCPtrLast, pCur->GCPtr, pCur->GCPtrLast));
98 return VERR_PGM_MAPPING_CONFLICT;
99 }
100 if (pCur->GCPtr > GCPtr)
101 break;
102 pPrev = pCur;
103 pCur = pCur->pNextR3;
104 }
105
106 /*
107 * Check for conflicts with intermediate mappings.
108 */
109 const unsigned iPageDir = GCPtr >> X86_PD_SHIFT;
110 const unsigned cPTs = cb >> X86_PD_SHIFT;
111 if (pVM->pgm.s.fFinalizedMappings)
112 {
113 for (unsigned i = 0; i < cPTs; i++)
114 if (pVM->pgm.s.pInterPD->a[iPageDir + i].n.u1Present)
115 {
116 AssertMsgFailed(("Address %#x is already in use by an intermediate mapping.\n", GCPtr + (i << PAGE_SHIFT)));
117 LogRel(("VERR_PGM_MAPPING_CONFLICT: Address %#x is already in use by an intermediate mapping.\n", GCPtr + (i << PAGE_SHIFT)));
118 return VERR_PGM_MAPPING_CONFLICT;
119 }
120 /** @todo AMD64: add check in PAE structures too, so we can remove all the 32-Bit paging stuff there. */
121 }
122
123 /*
124 * Allocate and initialize the new list node.
125 */
126 PPGMMAPPING pNew;
127 int rc;
128 if (fFlags & PGMR3MAPPT_FLAGS_UNMAPPABLE)
129 rc = MMHyperAlloc( pVM, RT_OFFSETOF(PGMMAPPING, aPTs[cPTs]), 0, MM_TAG_PGM_MAPPINGS, (void **)&pNew);
130 else
131 rc = MMR3HyperAllocOnceNoRel(pVM, RT_OFFSETOF(PGMMAPPING, aPTs[cPTs]), 0, MM_TAG_PGM_MAPPINGS, (void **)&pNew);
132 if (RT_FAILURE(rc))
133 return rc;
134 pNew->GCPtr = GCPtr;
135 pNew->GCPtrLast = GCPtrLast;
136 pNew->cb = cb;
137 pNew->pfnRelocate = pfnRelocate;
138 pNew->pvUser = pvUser;
139 pNew->pszDesc = pszDesc;
140 pNew->cPTs = cPTs;
141
142 /*
143 * Allocate page tables and insert them into the page directories.
144 * (One 32-bit PT and two PAE PTs.)
145 */
146 uint8_t *pbPTs;
147 if (fFlags & PGMR3MAPPT_FLAGS_UNMAPPABLE)
148 rc = MMHyperAlloc( pVM, PAGE_SIZE * 3 * cPTs, PAGE_SIZE, MM_TAG_PGM_MAPPINGS, (void **)&pbPTs);
149 else
150 rc = MMR3HyperAllocOnceNoRel(pVM, PAGE_SIZE * 3 * cPTs, PAGE_SIZE, MM_TAG_PGM_MAPPINGS, (void **)&pbPTs);
151 if (RT_FAILURE(rc))
152 {
153 MMHyperFree(pVM, pNew);
154 return VERR_NO_MEMORY;
155 }
156
157 /*
158 * Init the page tables and insert them into the page directories.
159 */
160 Log4(("PGMR3MapPT: GCPtr=%RGv cPTs=%u pbPTs=%p\n", GCPtr, cPTs, pbPTs));
161 for (unsigned i = 0; i < cPTs; i++)
162 {
163 /*
164 * 32-bit.
165 */
166 pNew->aPTs[i].pPTR3 = (PX86PT)pbPTs;
167 pNew->aPTs[i].pPTRC = MMHyperR3ToRC(pVM, pNew->aPTs[i].pPTR3);
168 pNew->aPTs[i].pPTR0 = MMHyperR3ToR0(pVM, pNew->aPTs[i].pPTR3);
169 pNew->aPTs[i].HCPhysPT = MMR3HyperHCVirt2HCPhys(pVM, pNew->aPTs[i].pPTR3);
170 pbPTs += PAGE_SIZE;
171 Log4(("PGMR3MapPT: i=%d: pPTR3=%RHv pPTRC=%RRv pPRTR0=%RHv HCPhysPT=%RHp\n",
172 i, pNew->aPTs[i].pPTR3, pNew->aPTs[i].pPTRC, pNew->aPTs[i].pPTR0, pNew->aPTs[i].HCPhysPT));
173
174 /*
175 * PAE.
176 */
177 pNew->aPTs[i].HCPhysPaePT0 = MMR3HyperHCVirt2HCPhys(pVM, pbPTs);
178 pNew->aPTs[i].HCPhysPaePT1 = MMR3HyperHCVirt2HCPhys(pVM, pbPTs + PAGE_SIZE);
179 pNew->aPTs[i].paPaePTsR3 = (PPGMSHWPTPAE)pbPTs;
180 pNew->aPTs[i].paPaePTsRC = MMHyperR3ToRC(pVM, pbPTs);
181 pNew->aPTs[i].paPaePTsR0 = MMHyperR3ToR0(pVM, pbPTs);
182 pbPTs += PAGE_SIZE * 2;
183 Log4(("PGMR3MapPT: i=%d: paPaePTsR#=%RHv paPaePTsRC=%RRv paPaePTsR#=%RHv HCPhysPaePT0=%RHp HCPhysPaePT1=%RHp\n",
184 i, pNew->aPTs[i].paPaePTsR3, pNew->aPTs[i].paPaePTsRC, pNew->aPTs[i].paPaePTsR0, pNew->aPTs[i].HCPhysPaePT0, pNew->aPTs[i].HCPhysPaePT1));
185 }
186 if (pVM->pgm.s.fFinalizedMappings)
187 pgmR3MapSetPDEs(pVM, pNew, iPageDir);
188 /* else PGMR3FinalizeMappings() */
189
190 /*
191 * Insert the new mapping.
192 */
193 pNew->pNextR3 = pCur;
194 pNew->pNextRC = pCur ? MMHyperR3ToRC(pVM, pCur) : NIL_RTRCPTR;
195 pNew->pNextR0 = pCur ? MMHyperR3ToR0(pVM, pCur) : NIL_RTR0PTR;
196 if (pPrev)
197 {
198 pPrev->pNextR3 = pNew;
199 pPrev->pNextRC = MMHyperR3ToRC(pVM, pNew);
200 pPrev->pNextR0 = MMHyperR3ToR0(pVM, pNew);
201 }
202 else
203 {
204 pVM->pgm.s.pMappingsR3 = pNew;
205 pVM->pgm.s.pMappingsRC = MMHyperR3ToRC(pVM, pNew);
206 pVM->pgm.s.pMappingsR0 = MMHyperR3ToR0(pVM, pNew);
207 }
208
209 for (VMCPUID i = 0; i < pVM->cCpus; i++)
210 {
211 PVMCPU pVCpu = &pVM->aCpus[i];
212 VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
213 }
214 return VINF_SUCCESS;
215}
216
217#ifdef VBOX_WITH_UNUSED_CODE
218
219/**
220 * Removes a page table based mapping.
221 *
222 * @returns VBox status code.
223 * @param pVM The cross context VM structure.
224 * @param GCPtr Virtual Address. (Page table aligned!)
225 *
226 * @remarks Don't call this without passing PGMR3MAPPT_FLAGS_UNMAPPABLE to
227 * PGMR3MapPT or you'll burn in the heap.
228 */
229VMMR3DECL(int) PGMR3UnmapPT(PVM pVM, RTGCPTR GCPtr)
230{
231 LogFlow(("PGMR3UnmapPT: GCPtr=%#x\n", GCPtr));
232 AssertReturn(pVM->pgm.s.fFinalizedMappings, VERR_WRONG_ORDER);
233
234 /*
235 * Find it.
236 */
237 PPGMMAPPING pPrev = NULL;
238 PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3;
239 while (pCur)
240 {
241 if (pCur->GCPtr == GCPtr)
242 {
243 /*
244 * Unlink it.
245 */
246 if (pPrev)
247 {
248 pPrev->pNextR3 = pCur->pNextR3;
249 pPrev->pNextRC = pCur->pNextRC;
250 pPrev->pNextR0 = pCur->pNextR0;
251 }
252 else
253 {
254 pVM->pgm.s.pMappingsR3 = pCur->pNextR3;
255 pVM->pgm.s.pMappingsRC = pCur->pNextRC;
256 pVM->pgm.s.pMappingsR0 = pCur->pNextR0;
257 }
258
259 /*
260 * Free the page table memory, clear page directory entries
261 * and free the page tables and node memory.
262 */
263 MMHyperFree(pVM, pCur->aPTs[0].pPTR3);
264 if (pCur->GCPtr != NIL_RTGCPTR)
265 pgmR3MapClearPDEs(pVM, pCur, pCur->GCPtr >> X86_PD_SHIFT);
266 MMHyperFree(pVM, pCur);
267
268 for (VMCPUID i = 0; i < pVM->cCpus; i++)
269 {
270 PVMCPU pVCpu = &pVM->aCpus[i];
271 VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
272 }
273 return VINF_SUCCESS;
274 }
275
276 /* done? */
277 if (pCur->GCPtr > GCPtr)
278 break;
279
280 /* next */
281 pPrev = pCur;
282 pCur = pCur->pNextR3;
283 }
284
285 AssertMsgFailed(("No mapping for %#x found!\n", GCPtr));
286 return VERR_INVALID_PARAMETER;
287}
288
289#endif /* unused */
290
291
292/**
293 * Checks whether a range of PDEs in the intermediate
294 * memory context are unused.
295 *
296 * We're talking 32-bit PDEs here.
297 *
298 * @returns true/false.
299 * @param pVM The cross context VM structure.
300 * @param iPD The first PDE in the range.
301 * @param cPTs The number of PDEs in the range.
302 */
303DECLINLINE(bool) pgmR3AreIntermediatePDEsUnused(PVM pVM, unsigned iPD, unsigned cPTs)
304{
305 if (pVM->pgm.s.pInterPD->a[iPD].n.u1Present)
306 return false;
307 while (cPTs > 1)
308 {
309 iPD++;
310 if (pVM->pgm.s.pInterPD->a[iPD].n.u1Present)
311 return false;
312 cPTs--;
313 }
314 return true;
315}
316
317
318/**
319 * Unlinks the mapping.
320 *
321 * The mapping *must* be in the list.
322 *
323 * @param pVM The cross context VM structure.
324 * @param pMapping The mapping to unlink.
325 */
326static void pgmR3MapUnlink(PVM pVM, PPGMMAPPING pMapping)
327{
328 PPGMMAPPING pAfterThis = pVM->pgm.s.pMappingsR3;
329 if (pAfterThis == pMapping)
330 {
331 /* head */
332 pVM->pgm.s.pMappingsR3 = pMapping->pNextR3;
333 pVM->pgm.s.pMappingsRC = pMapping->pNextRC;
334 pVM->pgm.s.pMappingsR0 = pMapping->pNextR0;
335 }
336 else
337 {
338 /* in the list */
339 while (pAfterThis->pNextR3 != pMapping)
340 {
341 pAfterThis = pAfterThis->pNextR3;
342 AssertReleaseReturnVoid(pAfterThis);
343 }
344
345 pAfterThis->pNextR3 = pMapping->pNextR3;
346 pAfterThis->pNextRC = pMapping->pNextRC;
347 pAfterThis->pNextR0 = pMapping->pNextR0;
348 }
349}
350
351
352/**
353 * Links the mapping.
354 *
355 * @param pVM The cross context VM structure.
356 * @param pMapping The mapping to linked.
357 */
358static void pgmR3MapLink(PVM pVM, PPGMMAPPING pMapping)
359{
360 /*
361 * Find the list location (it's sorted by GCPhys) and link it in.
362 */
363 if ( !pVM->pgm.s.pMappingsR3
364 || pVM->pgm.s.pMappingsR3->GCPtr > pMapping->GCPtr)
365 {
366 /* head */
367 pMapping->pNextR3 = pVM->pgm.s.pMappingsR3;
368 pMapping->pNextRC = pVM->pgm.s.pMappingsRC;
369 pMapping->pNextR0 = pVM->pgm.s.pMappingsR0;
370 pVM->pgm.s.pMappingsR3 = pMapping;
371 pVM->pgm.s.pMappingsRC = MMHyperR3ToRC(pVM, pMapping);
372 pVM->pgm.s.pMappingsR0 = MMHyperR3ToR0(pVM, pMapping);
373 }
374 else
375 {
376 /* in the list */
377 PPGMMAPPING pAfterThis = pVM->pgm.s.pMappingsR3;
378 PPGMMAPPING pBeforeThis = pAfterThis->pNextR3;
379 while (pBeforeThis && pBeforeThis->GCPtr <= pMapping->GCPtr)
380 {
381 pAfterThis = pBeforeThis;
382 pBeforeThis = pBeforeThis->pNextR3;
383 }
384
385 pMapping->pNextR3 = pAfterThis->pNextR3;
386 pMapping->pNextRC = pAfterThis->pNextRC;
387 pMapping->pNextR0 = pAfterThis->pNextR0;
388 pAfterThis->pNextR3 = pMapping;
389 pAfterThis->pNextRC = MMHyperR3ToRC(pVM, pMapping);
390 pAfterThis->pNextR0 = MMHyperR3ToR0(pVM, pMapping);
391 }
392}
393
394
395/**
396 * Finalizes the intermediate context.
397 *
398 * This is called at the end of the ring-3 init and will construct the
399 * intermediate paging structures, relocating all the mappings in the process.
400 *
401 * @returns VBox status code.
402 * @param pVM The cross context VM structure.
403 * @thread EMT(0)
404 */
405VMMR3DECL(int) PGMR3FinalizeMappings(PVM pVM)
406{
407 AssertReturn(!pVM->pgm.s.fFinalizedMappings, VERR_WRONG_ORDER);
408 pVM->pgm.s.fFinalizedMappings = true;
409
410 /*
411 * Loop until all mappings have been finalized.
412 */
413#if 0
414 unsigned iPDNext = UINT32_C(0xc0000000) >> X86_PD_SHIFT; /* makes CSAM/PATM freak out booting linux. :-/ */
415#elif 0
416 unsigned iPDNext = MM_HYPER_AREA_ADDRESS >> X86_PD_SHIFT;
417#else
418 unsigned iPDNext = 1 << X86_PD_SHIFT; /* no hint, map them from the top. */
419#endif
420
421 PPGMMAPPING pCur;
422 do
423 {
424 pCur = pVM->pgm.s.pMappingsR3;
425 while (pCur)
426 {
427 if (!pCur->fFinalized)
428 {
429 /*
430 * Find a suitable location.
431 */
432 RTGCPTR const GCPtrOld = pCur->GCPtr;
433 const unsigned cPTs = pCur->cPTs;
434 unsigned iPDNew = iPDNext;
435 if ( iPDNew + cPTs >= X86_PG_ENTRIES /* exclude the last PD */
436 || !pgmR3AreIntermediatePDEsUnused(pVM, iPDNew, cPTs)
437 || !pCur->pfnRelocate(pVM, GCPtrOld, (RTGCPTR)iPDNew << X86_PD_SHIFT, PGMRELOCATECALL_SUGGEST, pCur->pvUser))
438 {
439 /* No luck, just scan down from 4GB-4MB, giving up at 4MB. */
440 iPDNew = X86_PG_ENTRIES - cPTs - 1;
441 while ( iPDNew > 0
442 && ( !pgmR3AreIntermediatePDEsUnused(pVM, iPDNew, cPTs)
443 || !pCur->pfnRelocate(pVM, GCPtrOld, (RTGCPTR)iPDNew << X86_PD_SHIFT, PGMRELOCATECALL_SUGGEST, pCur->pvUser))
444 )
445 iPDNew--;
446 AssertLogRelReturn(iPDNew != 0, VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
447 }
448
449 /*
450 * Relocate it (something akin to pgmR3MapRelocate).
451 */
452 pgmR3MapSetPDEs(pVM, pCur, iPDNew);
453
454 /* unlink the mapping, update the entry and relink it. */
455 pgmR3MapUnlink(pVM, pCur);
456
457 RTGCPTR const GCPtrNew = (RTGCPTR)iPDNew << X86_PD_SHIFT;
458 pCur->GCPtr = GCPtrNew;
459 pCur->GCPtrLast = GCPtrNew + pCur->cb - 1;
460 pCur->fFinalized = true;
461
462 pgmR3MapLink(pVM, pCur);
463
464 /* Finally work the callback. */
465 pCur->pfnRelocate(pVM, GCPtrOld, GCPtrNew, PGMRELOCATECALL_RELOCATE, pCur->pvUser);
466
467 /*
468 * The list order might have changed, start from the beginning again.
469 */
470 iPDNext = iPDNew + cPTs;
471 break;
472 }
473
474 /* next */
475 pCur = pCur->pNextR3;
476 }
477 } while (pCur);
478
479 return VINF_SUCCESS;
480}
481
482
483/**
484 * Gets the size of the current guest mappings if they were to be
485 * put next to one another.
486 *
487 * @returns VBox status code.
488 * @param pVM The cross context VM structure.
489 * @param pcb Where to store the size.
490 */
491VMMR3DECL(int) PGMR3MappingsSize(PVM pVM, uint32_t *pcb)
492{
493 RTGCPTR cb = 0;
494#ifndef PGM_WITHOUT_MAPPINGS
495 for (PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3; pCur; pCur = pCur->pNextR3)
496 cb += pCur->cb;
497#else
498 RT_NOREF(pVM);
499#endif
500
501 *pcb = cb;
502 AssertReturn(*pcb == cb, VERR_NUMBER_TOO_BIG);
503 Log(("PGMR3MappingsSize: return %d (%#x) bytes\n", cb, cb));
504 return VINF_SUCCESS;
505}
506
507
508/**
509 * Fixates the guest context mappings in a range reserved from the Guest OS.
510 *
511 * @returns VBox status code.
512 * @param pVM The cross context VM structure.
513 * @param GCPtrBase The address of the reserved range of guest memory.
514 * @param cb The size of the range starting at GCPtrBase.
515 */
516VMMR3DECL(int) PGMR3MappingsFix(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb)
517{
518 Log(("PGMR3MappingsFix: GCPtrBase=%RGv cb=%#x (fMappingsFixed=%RTbool MappingEnabled=%RTbool)\n",
519 GCPtrBase, cb, pVM->pgm.s.fMappingsFixed, pgmMapAreMappingsEnabled(pVM)));
520
521#ifndef PGM_WITHOUT_MAPPINGS
522 if (pgmMapAreMappingsEnabled(pVM))
523 {
524 /*
525 * Only applies to VCPU 0 as we don't support SMP guests with raw mode.
526 */
527 Assert(pVM->cCpus == 1);
528 PVMCPU pVCpu = &pVM->aCpus[0];
529
530 /*
531 * Before we do anything we'll do a forced PD sync to try make sure any
532 * pending relocations because of these mappings have been resolved.
533 */
534 PGMSyncCR3(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR3(pVCpu), CPUMGetGuestCR4(pVCpu), true);
535
536 return pgmR3MappingsFixInternal(pVM, GCPtrBase, cb);
537 }
538
539#else /* PGM_WITHOUT_MAPPINGS */
540 RT_NOREF(pVM, GCPtrBase, cb);
541#endif /* PGM_WITHOUT_MAPPINGS */
542
543 Assert(HMIsEnabled(pVM));
544 return VINF_SUCCESS;
545}
546
547
548#ifndef PGM_WITHOUT_MAPPINGS
549/**
550 * Internal worker for PGMR3MappingsFix and pgmR3Load.
551 *
552 * (This does not perform a SyncCR3 before the fixation like PGMR3MappingsFix.)
553 *
554 * @returns VBox status code.
555 * @param pVM The cross context VM structure.
556 * @param GCPtrBase The address of the reserved range of guest memory.
557 * @param cb The size of the range starting at GCPtrBase.
558 */
559int pgmR3MappingsFixInternal(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb)
560{
561 /*
562 * Check input arguments and pre-conditions.
563 */
564 AssertMsgReturn(!(GCPtrBase & X86_PAGE_4M_OFFSET_MASK), ("GCPtrBase (%#x) has to be aligned on a 4MB address!\n", GCPtrBase),
565 VERR_INVALID_PARAMETER);
566 AssertMsgReturn(cb && !(cb & X86_PAGE_4M_OFFSET_MASK), ("cb (%#x) is 0 or not aligned on a 4MB address!\n", cb),
567 VERR_INVALID_PARAMETER);
568 AssertReturn(pgmMapAreMappingsEnabled(pVM), VERR_PGM_MAPPINGS_DISABLED);
569 AssertReturn(pVM->cCpus == 1, VERR_PGM_MAPPINGS_SMP);
570
571 /*
572 * Check that it's not conflicting with a core code mapping in the intermediate page table.
573 */
574 unsigned iPDNew = GCPtrBase >> X86_PD_SHIFT;
575 unsigned i = cb >> X86_PD_SHIFT;
576 while (i-- > 0)
577 {
578 if (pVM->pgm.s.pInterPD->a[iPDNew + i].n.u1Present)
579 {
580 /* Check that it's not one or our mappings. */
581 PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3;
582 while (pCur)
583 {
584 if (iPDNew + i - (pCur->GCPtr >> X86_PD_SHIFT) < (pCur->cb >> X86_PD_SHIFT))
585 break;
586 pCur = pCur->pNextR3;
587 }
588 if (!pCur)
589 {
590 LogRel(("PGMR3MappingsFix: Conflicts with intermediate PDE %#x (GCPtrBase=%RGv cb=%#zx). The guest should retry.\n",
591 iPDNew + i, GCPtrBase, cb));
592 return VERR_PGM_MAPPINGS_FIX_CONFLICT;
593 }
594 }
595 }
596
597 /*
598 * In PAE / PAE mode, make sure we don't cross page directories.
599 */
600 PVMCPU pVCpu = &pVM->aCpus[0];
601 if ( ( pVCpu->pgm.s.enmGuestMode == PGMMODE_PAE
602 || pVCpu->pgm.s.enmGuestMode == PGMMODE_PAE_NX)
603 && ( pVCpu->pgm.s.enmShadowMode == PGMMODE_PAE
604 || pVCpu->pgm.s.enmShadowMode == PGMMODE_PAE_NX))
605 {
606 unsigned iPdptBase = GCPtrBase >> X86_PDPT_SHIFT;
607 unsigned iPdptLast = (GCPtrBase + cb - 1) >> X86_PDPT_SHIFT;
608 if (iPdptBase != iPdptLast)
609 {
610 LogRel(("PGMR3MappingsFix: Crosses PD boundary; iPdptBase=%#x iPdptLast=%#x (GCPtrBase=%RGv cb=%#zx). The guest should retry.\n",
611 iPdptBase, iPdptLast, GCPtrBase, cb));
612 return VERR_PGM_MAPPINGS_FIX_CONFLICT;
613 }
614 }
615
616 /*
617 * Loop the mappings and check that they all agree on their new locations.
618 */
619 RTGCPTR GCPtrCur = GCPtrBase;
620 PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3;
621 while (pCur)
622 {
623 if (!pCur->pfnRelocate(pVM, pCur->GCPtr, GCPtrCur, PGMRELOCATECALL_SUGGEST, pCur->pvUser))
624 {
625 AssertMsgFailed(("The suggested fixed address %#x was rejected by '%s'!\n", GCPtrCur, pCur->pszDesc));
626 return VERR_PGM_MAPPINGS_FIX_REJECTED;
627 }
628 /* next */
629 GCPtrCur += pCur->cb;
630 pCur = pCur->pNextR3;
631 }
632 if (GCPtrCur > GCPtrBase + cb)
633 {
634 AssertMsgFailed(("cb (%#x) is less than the required range %#x!\n", cb, GCPtrCur - GCPtrBase));
635 return VERR_PGM_MAPPINGS_FIX_TOO_SMALL;
636 }
637
638 /*
639 * Loop the table assigning the mappings to the passed in memory
640 * and call their relocator callback.
641 */
642 GCPtrCur = GCPtrBase;
643 pCur = pVM->pgm.s.pMappingsR3;
644 while (pCur)
645 {
646 RTGCPTR const GCPtrOld = pCur->GCPtr;
647
648 /*
649 * Relocate the page table(s).
650 */
651 if (pCur->GCPtr != NIL_RTGCPTR)
652 pgmR3MapClearPDEs(pVM, pCur, GCPtrOld >> X86_PD_SHIFT);
653 pgmR3MapSetPDEs(pVM, pCur, GCPtrCur >> X86_PD_SHIFT);
654
655 /*
656 * Update the entry.
657 */
658 pCur->GCPtr = GCPtrCur;
659 pCur->GCPtrLast = GCPtrCur + pCur->cb - 1;
660
661 /*
662 * Callback to execute the relocation.
663 */
664 pCur->pfnRelocate(pVM, GCPtrOld, GCPtrCur, PGMRELOCATECALL_RELOCATE, pCur->pvUser);
665
666 /*
667 * Advance.
668 */
669 GCPtrCur += pCur->cb;
670 pCur = pCur->pNextR3;
671 }
672
673 /*
674 * Mark the mappings as fixed at this new location and return.
675 */
676 pVM->pgm.s.fMappingsFixed = true;
677 pVM->pgm.s.fMappingsFixedRestored = false;
678 pVM->pgm.s.GCPtrMappingFixed = GCPtrBase;
679 pVM->pgm.s.cbMappingFixed = cb;
680
681 for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
682 {
683 pVM->aCpus[idCpu].pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
684 VMCPU_FF_SET(&pVM->aCpus[idCpu], VMCPU_FF_PGM_SYNC_CR3);
685 }
686 return VINF_SUCCESS;
687}
688#endif /*!PGM_WITHOUT_MAPPINGS*/
689
690
691/**
692 * Unfixes the mappings.
693 *
694 * Unless PGMR3MappingsDisable is in effect, mapping conflict detection will be
695 * enabled after this call. If the mappings are fixed, a full CR3 resync will
696 * take place afterwards.
697 *
698 * @returns VBox status code.
699 * @param pVM The cross context VM structure.
700 */
701VMMR3DECL(int) PGMR3MappingsUnfix(PVM pVM)
702{
703 Log(("PGMR3MappingsUnfix: fMappingsFixed=%RTbool MappingsEnabled=%RTbool\n", pVM->pgm.s.fMappingsFixed, pgmMapAreMappingsEnabled(pVM)));
704 if ( pgmMapAreMappingsEnabled(pVM)
705 && ( pVM->pgm.s.fMappingsFixed
706 || pVM->pgm.s.fMappingsFixedRestored)
707 )
708 {
709 bool const fResyncCR3 = pVM->pgm.s.fMappingsFixed;
710
711 pVM->pgm.s.fMappingsFixed = false;
712 pVM->pgm.s.fMappingsFixedRestored = false;
713 pVM->pgm.s.GCPtrMappingFixed = 0;
714 pVM->pgm.s.cbMappingFixed = 0;
715
716 if (fResyncCR3)
717 for (VMCPUID i = 0; i < pVM->cCpus; i++)
718 VMCPU_FF_SET(&pVM->aCpus[i], VMCPU_FF_PGM_SYNC_CR3);
719 }
720 return VINF_SUCCESS;
721}
722
723
724/**
725 * Checks if the mappings needs re-fixing after a restore.
726 *
727 * @returns true if they need, false if not.
728 * @param pVM The cross context VM structure.
729 */
730VMMR3DECL(bool) PGMR3MappingsNeedReFixing(PVM pVM)
731{
732 VM_ASSERT_VALID_EXT_RETURN(pVM, false);
733 return pVM->pgm.s.fMappingsFixedRestored;
734}
735
736#ifndef PGM_WITHOUT_MAPPINGS
737
738/**
739 * Map pages into the intermediate context (switcher code).
740 *
741 * These pages are mapped at both the give virtual address and at the physical
742 * address (for identity mapping).
743 *
744 * @returns VBox status code.
745 * @param pVM The cross context VM structure.
746 * @param Addr Intermediate context address of the mapping.
747 * @param HCPhys Start of the range of physical pages. This must be entriely below 4GB!
748 * @param cbPages Number of bytes to map.
749 *
750 * @remark This API shall not be used to anything but mapping the switcher code.
751 */
752VMMR3DECL(int) PGMR3MapIntermediate(PVM pVM, RTUINTPTR Addr, RTHCPHYS HCPhys, unsigned cbPages)
753{
754 LogFlow(("PGMR3MapIntermediate: Addr=%RTptr HCPhys=%RHp cbPages=%#x\n", Addr, HCPhys, cbPages));
755
756 /*
757 * Adjust input.
758 */
759 cbPages += (uint32_t)HCPhys & PAGE_OFFSET_MASK;
760 cbPages = RT_ALIGN(cbPages, PAGE_SIZE);
761 HCPhys &= X86_PTE_PAE_PG_MASK;
762 Addr &= PAGE_BASE_MASK;
763 /* We only care about the first 4GB, because on AMD64 we'll be repeating them all over the address space. */
764 uint32_t uAddress = (uint32_t)Addr;
765
766 /*
767 * Assert input and state.
768 */
769 AssertMsg(pVM->pgm.s.offVM, ("Bad init order\n"));
770 AssertMsg(pVM->pgm.s.pInterPD, ("Bad init order, paging.\n"));
771 AssertMsg(cbPages <= (512 << PAGE_SHIFT), ("The mapping is too big %d bytes\n", cbPages));
772 AssertMsg(HCPhys < _4G && HCPhys + cbPages < _4G, ("Addr=%RTptr HCPhys=%RHp cbPages=%d\n", Addr, HCPhys, cbPages));
773 AssertReturn(!pVM->pgm.s.fFinalizedMappings, VERR_WRONG_ORDER);
774
775 /*
776 * Check for internal conflicts between the virtual address and the physical address.
777 * A 1:1 mapping is fine, but partial overlapping is a no-no.
778 */
779 if ( uAddress != HCPhys
780 && ( uAddress < HCPhys
781 ? HCPhys - uAddress < cbPages
782 : uAddress - HCPhys < cbPages
783 )
784 )
785 AssertLogRelMsgFailedReturn(("Addr=%RTptr HCPhys=%RHp cbPages=%d\n", Addr, HCPhys, cbPages),
786 VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
787
788 const unsigned cPages = cbPages >> PAGE_SHIFT;
789 int rc = pgmR3MapIntermediateCheckOne(pVM, uAddress, cPages, pVM->pgm.s.apInterPTs[0], pVM->pgm.s.apInterPaePTs[0]);
790 if (RT_FAILURE(rc))
791 return rc;
792 rc = pgmR3MapIntermediateCheckOne(pVM, (uintptr_t)HCPhys, cPages, pVM->pgm.s.apInterPTs[1], pVM->pgm.s.apInterPaePTs[1]);
793 if (RT_FAILURE(rc))
794 return rc;
795
796 /*
797 * Everythings fine, do the mapping.
798 */
799 pgmR3MapIntermediateDoOne(pVM, uAddress, HCPhys, cPages, pVM->pgm.s.apInterPTs[0], pVM->pgm.s.apInterPaePTs[0]);
800 pgmR3MapIntermediateDoOne(pVM, (uintptr_t)HCPhys, HCPhys, cPages, pVM->pgm.s.apInterPTs[1], pVM->pgm.s.apInterPaePTs[1]);
801
802 return VINF_SUCCESS;
803}
804
805
806/**
807 * Validates that there are no conflicts for this mapping into the intermediate context.
808 *
809 * @returns VBox status code.
810 * @param pVM The cross context VM structure.
811 * @param uAddress Address of the mapping.
812 * @param cPages Number of pages.
813 * @param pPTDefault Pointer to the default page table for this mapping.
814 * @param pPTPaeDefault Pointer to the default page table for this mapping.
815 */
816static int pgmR3MapIntermediateCheckOne(PVM pVM, uintptr_t uAddress, unsigned cPages, PX86PT pPTDefault, PX86PTPAE pPTPaeDefault)
817{
818 AssertMsg((uAddress >> X86_PD_SHIFT) + cPages <= 1024, ("64-bit fixme uAddress=%RGv cPages=%u\n", uAddress, cPages));
819
820 /*
821 * Check that the ranges are available.
822 * (This code doesn't have to be fast.)
823 */
824 while (cPages > 0)
825 {
826 /*
827 * 32-Bit.
828 */
829 unsigned iPDE = (uAddress >> X86_PD_SHIFT) & X86_PD_MASK;
830 unsigned iPTE = (uAddress >> X86_PT_SHIFT) & X86_PT_MASK;
831 PX86PT pPT = pPTDefault;
832 if (pVM->pgm.s.pInterPD->a[iPDE].u)
833 {
834 RTHCPHYS HCPhysPT = pVM->pgm.s.pInterPD->a[iPDE].u & X86_PDE_PG_MASK;
835 if (HCPhysPT == MMPage2Phys(pVM, pVM->pgm.s.apInterPTs[0]))
836 pPT = pVM->pgm.s.apInterPTs[0];
837 else if (HCPhysPT == MMPage2Phys(pVM, pVM->pgm.s.apInterPTs[1]))
838 pPT = pVM->pgm.s.apInterPTs[1];
839 else
840 {
841 /** @todo this must be handled with a relocation of the conflicting mapping!
842 * Which of course cannot be done because we're in the middle of the initialization. bad design! */
843 AssertLogRelMsgFailedReturn(("Conflict between core code and PGMR3Mapping(). uAddress=%RHv\n", uAddress),
844 VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
845 }
846 }
847 if (pPT->a[iPTE].u)
848 AssertLogRelMsgFailedReturn(("Conflict iPTE=%#x iPDE=%#x uAddress=%RHv pPT->a[iPTE].u=%RX32\n", iPTE, iPDE, uAddress, pPT->a[iPTE].u),
849 VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
850
851 /*
852 * PAE.
853 */
854 const unsigned iPDPE= (uAddress >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
855 iPDE = (uAddress >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
856 iPTE = (uAddress >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK;
857 Assert(iPDPE < 4);
858 Assert(pVM->pgm.s.apInterPaePDs[iPDPE]);
859 PX86PTPAE pPTPae = pPTPaeDefault;
860 if (pVM->pgm.s.apInterPaePDs[iPDPE]->a[iPDE].u)
861 {
862 RTHCPHYS HCPhysPT = pVM->pgm.s.apInterPaePDs[iPDPE]->a[iPDE].u & X86_PDE_PAE_PG_MASK;
863 if (HCPhysPT == MMPage2Phys(pVM, pVM->pgm.s.apInterPaePTs[0]))
864 pPTPae = pVM->pgm.s.apInterPaePTs[0];
865 else if (HCPhysPT == MMPage2Phys(pVM, pVM->pgm.s.apInterPaePTs[0]))
866 pPTPae = pVM->pgm.s.apInterPaePTs[1];
867 else
868 {
869 /** @todo this must be handled with a relocation of the conflicting mapping!
870 * Which of course cannot be done because we're in the middle of the initialization. bad design! */
871 AssertLogRelMsgFailedReturn(("Conflict between core code and PGMR3Mapping(). uAddress=%RHv\n", uAddress),
872 VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
873 }
874 }
875 if (pPTPae->a[iPTE].u)
876 AssertLogRelMsgFailedReturn(("Conflict iPTE=%#x iPDE=%#x uAddress=%RHv pPTPae->a[iPTE].u=%#RX64\n", iPTE, iPDE, uAddress, pPTPae->a[iPTE].u),
877 VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
878
879 /* next */
880 uAddress += PAGE_SIZE;
881 cPages--;
882 }
883
884 return VINF_SUCCESS;
885}
886
887
888
889/**
890 * Sets up the intermediate page tables for a verified mapping.
891 *
892 * @param pVM The cross context VM structure.
893 * @param uAddress Address of the mapping.
894 * @param HCPhys The physical address of the page range.
895 * @param cPages Number of pages.
896 * @param pPTDefault Pointer to the default page table for this mapping.
897 * @param pPTPaeDefault Pointer to the default page table for this mapping.
898 */
899static void pgmR3MapIntermediateDoOne(PVM pVM, uintptr_t uAddress, RTHCPHYS HCPhys, unsigned cPages, PX86PT pPTDefault, PX86PTPAE pPTPaeDefault)
900{
901 while (cPages > 0)
902 {
903 /*
904 * 32-Bit.
905 */
906 unsigned iPDE = (uAddress >> X86_PD_SHIFT) & X86_PD_MASK;
907 unsigned iPTE = (uAddress >> X86_PT_SHIFT) & X86_PT_MASK;
908 PX86PT pPT;
909 if (pVM->pgm.s.pInterPD->a[iPDE].u)
910 pPT = (PX86PT)MMPagePhys2Page(pVM, pVM->pgm.s.pInterPD->a[iPDE].u & X86_PDE_PG_MASK);
911 else
912 {
913 pVM->pgm.s.pInterPD->a[iPDE].u = X86_PDE_P | X86_PDE_A | X86_PDE_RW
914 | (uint32_t)MMPage2Phys(pVM, pPTDefault);
915 pPT = pPTDefault;
916 }
917 pPT->a[iPTE].u = X86_PTE_P | X86_PTE_RW | X86_PTE_A | X86_PTE_D | (uint32_t)HCPhys;
918
919 /*
920 * PAE
921 */
922 const unsigned iPDPE= (uAddress >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
923 iPDE = (uAddress >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
924 iPTE = (uAddress >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK;
925 Assert(iPDPE < 4);
926 Assert(pVM->pgm.s.apInterPaePDs[iPDPE]);
927 PX86PTPAE pPTPae;
928 if (pVM->pgm.s.apInterPaePDs[iPDPE]->a[iPDE].u)
929 pPTPae = (PX86PTPAE)MMPagePhys2Page(pVM, pVM->pgm.s.apInterPaePDs[iPDPE]->a[iPDE].u & X86_PDE_PAE_PG_MASK);
930 else
931 {
932 pPTPae = pPTPaeDefault;
933 pVM->pgm.s.apInterPaePDs[iPDPE]->a[iPDE].u = X86_PDE_P | X86_PDE_A | X86_PDE_RW
934 | MMPage2Phys(pVM, pPTPaeDefault);
935 }
936 pPTPae->a[iPTE].u = X86_PTE_P | X86_PTE_RW | X86_PTE_A | X86_PTE_D | HCPhys;
937
938 /* next */
939 cPages--;
940 HCPhys += PAGE_SIZE;
941 uAddress += PAGE_SIZE;
942 }
943}
944
945
946/**
947 * Clears all PDEs involved with the mapping in the shadow and intermediate page tables.
948 *
949 * @param pVM The cross context VM structure.
950 * @param pMap Pointer to the mapping in question.
951 * @param iOldPDE The index of the 32-bit PDE corresponding to the base of the mapping.
952 */
953static void pgmR3MapClearPDEs(PVM pVM, PPGMMAPPING pMap, unsigned iOldPDE)
954{
955 unsigned i = pMap->cPTs;
956 PVMCPU pVCpu = VMMGetCpu(pVM);
957 pgmLock(pVM); /* to avoid assertions */
958
959 pgmMapClearShadowPDEs(pVM, pVCpu->pgm.s.CTX_SUFF(pShwPageCR3), pMap, iOldPDE, false /*fDeactivateCR3*/);
960
961 iOldPDE += i;
962 while (i-- > 0)
963 {
964 iOldPDE--;
965
966 /*
967 * 32-bit.
968 */
969 pVM->pgm.s.pInterPD->a[iOldPDE].u = 0;
970
971 /*
972 * PAE.
973 */
974 const unsigned iPD = iOldPDE / 256; /* iOldPDE * 2 / 512; iOldPDE is in 4 MB pages */
975 unsigned iPDE = iOldPDE * 2 % 512;
976 pVM->pgm.s.apInterPaePDs[iPD]->a[iPDE].u = 0;
977 iPDE++;
978 AssertFatal(iPDE < 512);
979 pVM->pgm.s.apInterPaePDs[iPD]->a[iPDE].u = 0;
980 }
981
982 pgmUnlock(pVM);
983}
984
985
986/**
987 * Sets all PDEs involved with the mapping in the shadow and intermediate page tables.
988 *
989 * @param pVM The cross context VM structure.
990 * @param pMap Pointer to the mapping in question.
991 * @param iNewPDE The index of the 32-bit PDE corresponding to the base of the mapping.
992 */
993static void pgmR3MapSetPDEs(PVM pVM, PPGMMAPPING pMap, unsigned iNewPDE)
994{
995 PPGM pPGM = &pVM->pgm.s;
996#ifdef VBOX_STRICT
997 PVMCPU pVCpu = VMMGetCpu(pVM);
998#endif
999 pgmLock(pVM); /* to avoid assertions */
1000
1001 Assert(!pgmMapAreMappingsEnabled(pVM) || PGMGetGuestMode(pVCpu) <= PGMMODE_PAE_NX);
1002
1003 pgmMapSetShadowPDEs(pVM, pMap, iNewPDE);
1004
1005 /*
1006 * Init the page tables and insert them into the page directories.
1007 */
1008 unsigned i = pMap->cPTs;
1009 iNewPDE += i;
1010 while (i-- > 0)
1011 {
1012 iNewPDE--;
1013
1014 /*
1015 * 32-bit.
1016 */
1017 X86PDE Pde;
1018 /* Default mapping page directory flags are read/write and supervisor; individual page attributes determine the final flags */
1019 Pde.u = PGM_PDFLAGS_MAPPING | X86_PDE_P | X86_PDE_A | X86_PDE_RW | X86_PDE_US | (uint32_t)pMap->aPTs[i].HCPhysPT;
1020 pPGM->pInterPD->a[iNewPDE] = Pde;
1021
1022 /*
1023 * PAE.
1024 */
1025 const unsigned iPD = iNewPDE / 256;
1026 unsigned iPDE = iNewPDE * 2 % 512;
1027 X86PDEPAE PdePae0;
1028 PdePae0.u = PGM_PDFLAGS_MAPPING | X86_PDE_P | X86_PDE_A | X86_PDE_RW | X86_PDE_US | pMap->aPTs[i].HCPhysPaePT0;
1029 pPGM->apInterPaePDs[iPD]->a[iPDE] = PdePae0;
1030 iPDE++;
1031 AssertFatal(iPDE < 512);
1032 X86PDEPAE PdePae1;
1033 PdePae1.u = PGM_PDFLAGS_MAPPING | X86_PDE_P | X86_PDE_A | X86_PDE_RW | X86_PDE_US | pMap->aPTs[i].HCPhysPaePT1;
1034 pPGM->apInterPaePDs[iPD]->a[iPDE] = PdePae1;
1035 }
1036
1037 pgmUnlock(pVM);
1038}
1039
1040
1041/**
1042 * Relocates a mapping to a new address.
1043 *
1044 * @param pVM The cross context VM structure.
1045 * @param pMapping The mapping to relocate.
1046 * @param GCPtrOldMapping The address of the start of the old mapping.
1047 * NIL_RTGCPTR if not currently mapped.
1048 * @param GCPtrNewMapping The address of the start of the new mapping.
1049 */
1050static void pgmR3MapRelocate(PVM pVM, PPGMMAPPING pMapping, RTGCPTR GCPtrOldMapping, RTGCPTR GCPtrNewMapping)
1051{
1052 Log(("PGM: Relocating %s from %RGv to %RGv\n", pMapping->pszDesc, GCPtrOldMapping, GCPtrNewMapping));
1053 AssertMsg(GCPtrOldMapping == pMapping->GCPtr, ("%RGv vs %RGv\n", GCPtrOldMapping, pMapping->GCPtr));
1054 AssertMsg((GCPtrOldMapping >> X86_PD_SHIFT) < X86_PG_ENTRIES, ("%RGv\n", GCPtrOldMapping));
1055 AssertMsg((GCPtrNewMapping >> X86_PD_SHIFT) < X86_PG_ENTRIES, ("%RGv\n", GCPtrOldMapping));
1056
1057 /*
1058 * Relocate the page table(s).
1059 */
1060 if (GCPtrOldMapping != NIL_RTGCPTR)
1061 pgmR3MapClearPDEs(pVM, pMapping, GCPtrOldMapping >> X86_PD_SHIFT);
1062 pgmR3MapSetPDEs(pVM, pMapping, GCPtrNewMapping >> X86_PD_SHIFT);
1063
1064 /*
1065 * Update and resort the mapping list.
1066 */
1067
1068 /* Find previous mapping for pMapping, put result into pPrevMap. */
1069 PPGMMAPPING pPrevMap = NULL;
1070 PPGMMAPPING pCur = pVM->pgm.s.pMappingsR3;
1071 while (pCur && pCur != pMapping)
1072 {
1073 /* next */
1074 pPrevMap = pCur;
1075 pCur = pCur->pNextR3;
1076 }
1077 Assert(pCur);
1078
1079 /* Find mapping which >= than pMapping. */
1080 RTGCPTR GCPtrNew = GCPtrNewMapping;
1081 PPGMMAPPING pPrev = NULL;
1082 pCur = pVM->pgm.s.pMappingsR3;
1083 while (pCur && pCur->GCPtr < GCPtrNew)
1084 {
1085 /* next */
1086 pPrev = pCur;
1087 pCur = pCur->pNextR3;
1088 }
1089
1090 if (pCur != pMapping && pPrev != pMapping)
1091 {
1092 /*
1093 * Unlink.
1094 */
1095 if (pPrevMap)
1096 {
1097 pPrevMap->pNextR3 = pMapping->pNextR3;
1098 pPrevMap->pNextRC = pMapping->pNextRC;
1099 pPrevMap->pNextR0 = pMapping->pNextR0;
1100 }
1101 else
1102 {
1103 pVM->pgm.s.pMappingsR3 = pMapping->pNextR3;
1104 pVM->pgm.s.pMappingsRC = pMapping->pNextRC;
1105 pVM->pgm.s.pMappingsR0 = pMapping->pNextR0;
1106 }
1107
1108 /*
1109 * Link
1110 */
1111 pMapping->pNextR3 = pCur;
1112 if (pPrev)
1113 {
1114 pMapping->pNextRC = pPrev->pNextRC;
1115 pMapping->pNextR0 = pPrev->pNextR0;
1116 pPrev->pNextR3 = pMapping;
1117 pPrev->pNextRC = MMHyperR3ToRC(pVM, pMapping);
1118 pPrev->pNextR0 = MMHyperR3ToR0(pVM, pMapping);
1119 }
1120 else
1121 {
1122 pMapping->pNextRC = pVM->pgm.s.pMappingsRC;
1123 pMapping->pNextR0 = pVM->pgm.s.pMappingsR0;
1124 pVM->pgm.s.pMappingsR3 = pMapping;
1125 pVM->pgm.s.pMappingsRC = MMHyperR3ToRC(pVM, pMapping);
1126 pVM->pgm.s.pMappingsR0 = MMHyperR3ToR0(pVM, pMapping);
1127 }
1128 }
1129
1130 /*
1131 * Update the entry.
1132 */
1133 pMapping->GCPtr = GCPtrNew;
1134 pMapping->GCPtrLast = GCPtrNew + pMapping->cb - 1;
1135
1136 /*
1137 * Callback to execute the relocation.
1138 */
1139 pMapping->pfnRelocate(pVM, GCPtrOldMapping, GCPtrNewMapping, PGMRELOCATECALL_RELOCATE, pMapping->pvUser);
1140}
1141
1142
1143/**
1144 * Checks if a new mapping address wasn't previously used and caused a clash with guest mappings.
1145 *
1146 * @returns VBox status code.
1147 * @param pMapping The mapping which conflicts.
1148 * @param GCPtr New mapping address to try
1149 */
1150bool pgmR3MapIsKnownConflictAddress(PPGMMAPPING pMapping, RTGCPTR GCPtr)
1151{
1152 for (unsigned i = 0; i < RT_ELEMENTS(pMapping->aGCPtrConflicts); i++)
1153 {
1154 if (GCPtr == pMapping->aGCPtrConflicts[i])
1155 return true;
1156 }
1157 return false;
1158}
1159
1160
1161/**
1162 * Resolves a conflict between a page table based GC mapping and
1163 * the Guest OS page tables. (32 bits version)
1164 *
1165 * @returns VBox status code.
1166 * @param pVM The cross context VM structure.
1167 * @param pMapping The mapping which conflicts.
1168 * @param pPDSrc The page directory of the guest OS.
1169 * @param GCPtrOldMapping The address of the start of the current mapping.
1170 */
1171int pgmR3SyncPTResolveConflict(PVM pVM, PPGMMAPPING pMapping, PX86PD pPDSrc, RTGCPTR GCPtrOldMapping)
1172{
1173 STAM_REL_COUNTER_INC(&pVM->pgm.s.cRelocations);
1174 STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
1175
1176 /* Raw mode only which implies one VCPU. */
1177 Assert(pVM->cCpus == 1);
1178
1179 pMapping->aGCPtrConflicts[pMapping->cConflicts & (PGMMAPPING_CONFLICT_MAX-1)] = GCPtrOldMapping;
1180 pMapping->cConflicts++;
1181
1182 /*
1183 * Scan for free page directory entries.
1184 *
1185 * Note that we do not support mappings at the very end of the
1186 * address space since that will break our GCPtrEnd assumptions.
1187 */
1188 const unsigned cPTs = pMapping->cPTs;
1189 unsigned iPDNew = RT_ELEMENTS(pPDSrc->a) - cPTs; /* (+ 1 - 1) */
1190 while (iPDNew-- > 0)
1191 {
1192 if (pPDSrc->a[iPDNew].n.u1Present)
1193 continue;
1194
1195 if (pgmR3MapIsKnownConflictAddress(pMapping, iPDNew << X86_PD_SHIFT))
1196 continue;
1197
1198 if (cPTs > 1)
1199 {
1200 bool fOk = true;
1201 for (unsigned i = 1; fOk && i < cPTs; i++)
1202 if (pPDSrc->a[iPDNew + i].n.u1Present)
1203 fOk = false;
1204 if (!fOk)
1205 continue;
1206 }
1207
1208 /*
1209 * Check that it's not conflicting with an intermediate page table mapping.
1210 */
1211 bool fOk = true;
1212 unsigned i = cPTs;
1213 while (fOk && i-- > 0)
1214 fOk = !pVM->pgm.s.pInterPD->a[iPDNew + i].n.u1Present;
1215 if (!fOk)
1216 continue;
1217 /** @todo AMD64 should check the PAE directories and skip the 32bit stuff. */
1218
1219 /*
1220 * Ask for the mapping.
1221 */
1222 RTGCPTR GCPtrNewMapping = (RTGCPTR32)iPDNew << X86_PD_SHIFT;
1223
1224 if (pMapping->pfnRelocate(pVM, GCPtrOldMapping, GCPtrNewMapping, PGMRELOCATECALL_SUGGEST, pMapping->pvUser))
1225 {
1226 pgmR3MapRelocate(pVM, pMapping, GCPtrOldMapping, GCPtrNewMapping);
1227 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
1228 return VINF_SUCCESS;
1229 }
1230 }
1231
1232 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
1233#ifdef DEBUG_bird
1234 /*
1235 * Ended up here frequently recently with an NT4.0 VM (using SMP kernel).
1236 *
1237 * The problem is when enabling large pages (i.e. updating CR4) using the
1238 * _Ki386EnableCurrentLargePage@8 assembly routine (address 0x801c97ad-9).
1239 * The routine loads a sparsely popuplated page tables with identiy mappings
1240 * of its own code, most entries are whatever ExAllocatePool returned, which
1241 * is documented as undefined but all 0xffffffff in this case. Once loaded,
1242 * it jumps to the physical code address, disables paging, set CR4.PSE=1,
1243 * re-enables paging, restore the original page table and returns successfully.
1244 *
1245 * Theory: if CSAM/PATM patches the pushf;cli;mov eax,cr3; sequence, at the
1246 * start of that function we're apparently in trouble, if CSAM/PATM doesn't
1247 * we're switching back to REM and doing disabling of paging there instead.
1248 *
1249 * Normal PD: CR3=00030000; Problematic identity mapped PD: CR3=0x5fa000.
1250 */
1251 DBGFSTOP(pVM);
1252#endif
1253 AssertMsgFailed(("Failed to relocate page table mapping '%s' from %#x! (cPTs=%d)\n", pMapping->pszDesc, GCPtrOldMapping, cPTs));
1254 return VERR_PGM_NO_HYPERVISOR_ADDRESS;
1255}
1256
1257
1258/**
1259 * Resolves a conflict between a page table based GC mapping and
1260 * the Guest OS page tables. (PAE bits version)
1261 *
1262 * @returns VBox status code.
1263 * @param pVM The cross context VM structure.
1264 * @param pMapping The mapping which conflicts.
1265 * @param GCPtrOldMapping The address of the start of the current mapping.
1266 */
1267int pgmR3SyncPTResolveConflictPAE(PVM pVM, PPGMMAPPING pMapping, RTGCPTR GCPtrOldMapping)
1268{
1269 STAM_REL_COUNTER_INC(&pVM->pgm.s.cRelocations);
1270 STAM_PROFILE_START(&pVM->pgm.s.StatR3ResolveConflict, a);
1271
1272 /* Raw mode only which implies one VCPU. */
1273 Assert(pVM->cCpus == 1);
1274 PVMCPU pVCpu = VMMGetCpu(pVM);
1275
1276 pMapping->aGCPtrConflicts[pMapping->cConflicts & (PGMMAPPING_CONFLICT_MAX-1)] = GCPtrOldMapping;
1277 pMapping->cConflicts++;
1278
1279 for (int iPDPTE = X86_PG_PAE_PDPE_ENTRIES - 1; iPDPTE >= 0; iPDPTE--)
1280 {
1281 unsigned iPDSrc;
1282 PX86PDPAE pPDSrc = pgmGstGetPaePDPtr(pVCpu, (RTGCPTR32)iPDPTE << X86_PDPT_SHIFT, &iPDSrc, NULL);
1283
1284 /*
1285 * Scan for free page directory entries.
1286 *
1287 * Note that we do not support mappings at the very end of the
1288 * address space since that will break our GCPtrEnd assumptions.
1289 * Nor do we support mappings crossing page directories.
1290 */
1291 const unsigned cPTs = pMapping->cb >> X86_PD_PAE_SHIFT;
1292 unsigned iPDNew = RT_ELEMENTS(pPDSrc->a) - cPTs; /* (+ 1 - 1) */
1293
1294 while (iPDNew-- > 0)
1295 {
1296 /* Ugly assumption that mappings start on a 4 MB boundary. */
1297 if (iPDNew & 1)
1298 continue;
1299
1300 if (pgmR3MapIsKnownConflictAddress(pMapping, ((RTGCPTR32)iPDPTE << X86_PDPT_SHIFT) + (iPDNew << X86_PD_PAE_SHIFT)))
1301 continue;
1302
1303 if (pPDSrc)
1304 {
1305 if (pPDSrc->a[iPDNew].n.u1Present)
1306 continue;
1307 if (cPTs > 1)
1308 {
1309 bool fOk = true;
1310 for (unsigned i = 1; fOk && i < cPTs; i++)
1311 if (pPDSrc->a[iPDNew + i].n.u1Present)
1312 fOk = false;
1313 if (!fOk)
1314 continue;
1315 }
1316 }
1317 /*
1318 * Check that it's not conflicting with an intermediate page table mapping.
1319 */
1320 bool fOk = true;
1321 unsigned i = cPTs;
1322 while (fOk && i-- > 0)
1323 fOk = !pVM->pgm.s.apInterPaePDs[iPDPTE]->a[iPDNew + i].n.u1Present;
1324 if (!fOk)
1325 continue;
1326
1327 /*
1328 * Ask for the mapping.
1329 */
1330 RTGCPTR GCPtrNewMapping = ((RTGCPTR32)iPDPTE << X86_PDPT_SHIFT) + ((RTGCPTR32)iPDNew << X86_PD_PAE_SHIFT);
1331
1332 if (pMapping->pfnRelocate(pVM, GCPtrOldMapping, GCPtrNewMapping, PGMRELOCATECALL_SUGGEST, pMapping->pvUser))
1333 {
1334 pgmR3MapRelocate(pVM, pMapping, GCPtrOldMapping, GCPtrNewMapping);
1335 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
1336 return VINF_SUCCESS;
1337 }
1338 }
1339 }
1340 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatR3ResolveConflict, a);
1341 AssertMsgFailed(("Failed to relocate page table mapping '%s' from %#x! (cPTs=%d)\n", pMapping->pszDesc, GCPtrOldMapping, pMapping->cb >> X86_PD_PAE_SHIFT));
1342 return VERR_PGM_NO_HYPERVISOR_ADDRESS;
1343}
1344
1345#endif /* !PGM_WITHOUT_MAPPINGS */
1346
1347/**
1348 * Read memory from the guest mappings.
1349 *
1350 * This will use the page tables associated with the mappings to
1351 * read the memory. This means that not all kind of memory is readable
1352 * since we don't necessarily know how to convert that physical address
1353 * to a HC virtual one.
1354 *
1355 * @returns VBox status code.
1356 * @param pVM The cross context VM structure.
1357 * @param pvDst The destination address (HC of course).
1358 * @param GCPtrSrc The source address (GC virtual address).
1359 * @param cb Number of bytes to read.
1360 *
1361 * @remarks The is indirectly for DBGF only.
1362 * @todo Consider renaming it to indicate it's special usage, or just
1363 * reimplement it in MMR3HyperReadGCVirt.
1364 */
1365VMMR3DECL(int) PGMR3MapRead(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb)
1366{
1367 /*
1368 * Simplicity over speed... Chop the request up into chunks
1369 * which don't cross pages.
1370 */
1371 if (cb + (GCPtrSrc & PAGE_OFFSET_MASK) > PAGE_SIZE)
1372 {
1373 for (;;)
1374 {
1375 size_t cbRead = RT_MIN(cb, PAGE_SIZE - (GCPtrSrc & PAGE_OFFSET_MASK));
1376 int rc = PGMR3MapRead(pVM, pvDst, GCPtrSrc, cbRead);
1377 if (RT_FAILURE(rc))
1378 return rc;
1379 cb -= cbRead;
1380 if (!cb)
1381 break;
1382 pvDst = (char *)pvDst + cbRead;
1383 GCPtrSrc += cbRead;
1384 }
1385 return VINF_SUCCESS;
1386 }
1387
1388 /*
1389 * Find the mapping.
1390 */
1391 PPGMMAPPING pCur = pVM->pgm.s.CTX_SUFF(pMappings);
1392 while (pCur)
1393 {
1394 RTGCPTR off = GCPtrSrc - pCur->GCPtr;
1395 if (off < pCur->cb)
1396 {
1397 if (off + cb > pCur->cb)
1398 {
1399 AssertMsgFailed(("Invalid page range %RGv LB%#x. mapping '%s' %RGv to %RGv\n",
1400 GCPtrSrc, cb, pCur->pszDesc, pCur->GCPtr, pCur->GCPtrLast));
1401 return VERR_INVALID_PARAMETER;
1402 }
1403
1404 unsigned iPT = off >> X86_PD_SHIFT;
1405 unsigned iPTE = (off >> PAGE_SHIFT) & X86_PT_MASK;
1406 while (cb > 0 && iPTE < RT_ELEMENTS(CTXALLSUFF(pCur->aPTs[iPT].pPT)->a))
1407 {
1408 PCPGMSHWPTEPAE pPte = &pCur->aPTs[iPT].CTXALLSUFF(paPaePTs)[iPTE / 512].a[iPTE % 512];
1409 if (!PGMSHWPTEPAE_IS_P(*pPte))
1410 return VERR_PAGE_NOT_PRESENT;
1411 RTHCPHYS HCPhys = PGMSHWPTEPAE_GET_HCPHYS(*pPte);
1412
1413 /*
1414 * Get the virtual page from the physical one.
1415 */
1416 void *pvPage;
1417 int rc = MMR3HCPhys2HCVirt(pVM, HCPhys, &pvPage);
1418 if (RT_FAILURE(rc))
1419 return rc;
1420
1421 memcpy(pvDst, (char *)pvPage + (GCPtrSrc & PAGE_OFFSET_MASK), cb);
1422 return VINF_SUCCESS;
1423 }
1424 }
1425
1426 /* next */
1427 pCur = CTXALLSUFF(pCur->pNext);
1428 }
1429
1430 return VERR_INVALID_POINTER;
1431}
1432
1433
1434/**
1435 * Info callback for 'pgmhandlers'.
1436 *
1437 * @param pVM The cross context VM structure.
1438 * @param pHlp The output helpers.
1439 * @param pszArgs The arguments. phys or virt.
1440 */
1441DECLCALLBACK(void) pgmR3MapInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
1442{
1443 NOREF(pszArgs);
1444 if (!pgmMapAreMappingsEnabled(pVM))
1445 pHlp->pfnPrintf(pHlp, "\nThe mappings are DISABLED.\n");
1446 else if (pVM->pgm.s.fMappingsFixed)
1447 pHlp->pfnPrintf(pHlp, "\nThe mappings are FIXED: %RGv-%RGv\n",
1448 pVM->pgm.s.GCPtrMappingFixed, pVM->pgm.s.GCPtrMappingFixed + pVM->pgm.s.cbMappingFixed - 1);
1449 else if (pVM->pgm.s.fMappingsFixedRestored)
1450 pHlp->pfnPrintf(pHlp, "\nThe mappings are FLOATING-RESTORED-FIXED: %RGv-%RGv\n",
1451 pVM->pgm.s.GCPtrMappingFixed, pVM->pgm.s.GCPtrMappingFixed + pVM->pgm.s.cbMappingFixed - 1);
1452 else
1453 pHlp->pfnPrintf(pHlp, "\nThe mappings are FLOATING.\n");
1454
1455 PPGMMAPPING pCur;
1456 for (pCur = pVM->pgm.s.pMappingsR3; pCur; pCur = pCur->pNextR3)
1457 {
1458 pHlp->pfnPrintf(pHlp, "%RGv - %RGv %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->pszDesc);
1459 if (pCur->cConflicts > 0)
1460 {
1461 pHlp->pfnPrintf(pHlp, " %u conflict%s: ", pCur->cConflicts, pCur->cConflicts == 1 ? "" : "s");
1462 uint32_t cLeft = RT_MIN(pCur->cConflicts, RT_ELEMENTS(pCur->aGCPtrConflicts));
1463 uint32_t i = pCur->cConflicts;
1464 while (cLeft-- > 0)
1465 {
1466 i = (i - 1) & (PGMMAPPING_CONFLICT_MAX - 1);
1467 pHlp->pfnPrintf(pHlp, cLeft ? "%RGv, " : "%RGv\n", pCur->aGCPtrConflicts[i]);
1468 }
1469 }
1470 }
1471}
1472
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