VirtualBox

source: vbox/trunk/include/VBox/pgm.h@ 34801

Last change on this file since 34801 was 34326, checked in by vboxsync, 14 years ago

VMM: Removed the XXXInitCPU and XXXTermCPU methods since all but the HWACCM ones where stubs and the XXXTermCPU bits was not called in all expected paths. The HWACCMR3InitCPU was hooked up as a VMINITCOMPLETED_RING3 hook, essentially leaving it's position in the order of things unchanged, while the HWACCMR3TermCPU call was made static without changing its position at the end of HWACCMR3Term.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.5 KB
Line 
1/** @file
2 * PGM - Page Monitor / Monitor. (VMM)
3 */
4
5/*
6 * Copyright (C) 2006-2010 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___VBox_pgm_h
27#define ___VBox_pgm_h
28
29#include <VBox/cdefs.h>
30#include <VBox/types.h>
31#include <VBox/sup.h>
32#include <VBox/vmapi.h>
33#include <VBox/x86.h>
34#include <VBox/VMMDev.h> /* for VMMDEVSHAREDREGIONDESC */
35#include <VBox/gmm.h> /* for PGMMREGISTERSHAREDMODULEREQ */
36#include <VBox/param.h>
37
38RT_C_DECLS_BEGIN
39
40/** @defgroup grp_pgm The Page Monitor / Manager API
41 * @{
42 */
43
44/**
45 * FNPGMRELOCATE callback mode.
46 */
47typedef enum PGMRELOCATECALL
48{
49 /** The callback is for checking if the suggested address is suitable. */
50 PGMRELOCATECALL_SUGGEST = 1,
51 /** The callback is for executing the relocation. */
52 PGMRELOCATECALL_RELOCATE
53} PGMRELOCATECALL;
54
55
56/**
57 * Callback function which will be called when PGM is trying to find
58 * a new location for the mapping.
59 *
60 * The callback is called in two modes, 1) the check mode and 2) the relocate mode.
61 * In 1) the callback should say if it objects to a suggested new location. If it
62 * accepts the new location, it is called again for doing it's relocation.
63 *
64 *
65 * @returns true if the location is ok.
66 * @returns false if another location should be found.
67 * @param GCPtrOld The old virtual address.
68 * @param GCPtrNew The new virtual address.
69 * @param enmMode Used to indicate the callback mode.
70 * @param pvUser User argument.
71 * @remark The return value is no a failure indicator, it's an acceptance
72 * indicator. Relocation can not fail!
73 */
74typedef DECLCALLBACK(bool) FNPGMRELOCATE(PVM pVM, RTGCPTR GCPtrOld, RTGCPTR GCPtrNew, PGMRELOCATECALL enmMode, void *pvUser);
75/** Pointer to a relocation callback function. */
76typedef FNPGMRELOCATE *PFNPGMRELOCATE;
77
78
79/**
80 * Physical page access handler type.
81 */
82typedef enum PGMPHYSHANDLERTYPE
83{
84 /** MMIO range. Pages are not present, all access is done in interpreter or recompiler. */
85 PGMPHYSHANDLERTYPE_MMIO = 1,
86 /** Handler all write access to a physical page range. */
87 PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
88 /** Handler all access to a physical page range. */
89 PGMPHYSHANDLERTYPE_PHYSICAL_ALL
90
91} PGMPHYSHANDLERTYPE;
92
93/**
94 * \#PF Handler callback for physical access handler ranges in RC.
95 *
96 * @returns VBox status code (appropriate for RC return).
97 * @param pVM VM Handle.
98 * @param uErrorCode CPU Error code.
99 * @param pRegFrame Trap register frame.
100 * NULL on DMA and other non CPU access.
101 * @param pvFault The fault address (cr2).
102 * @param GCPhysFault The GC physical address corresponding to pvFault.
103 * @param pvUser User argument.
104 */
105typedef DECLCALLBACK(int) FNPGMRCPHYSHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
106/** Pointer to PGM access callback. */
107typedef FNPGMRCPHYSHANDLER *PFNPGMRCPHYSHANDLER;
108
109/**
110 * \#PF Handler callback for physical access handler ranges in R0.
111 *
112 * @returns VBox status code (appropriate for R0 return).
113 * @param pVM VM Handle.
114 * @param uErrorCode CPU Error code.
115 * @param pRegFrame Trap register frame.
116 * NULL on DMA and other non CPU access.
117 * @param pvFault The fault address (cr2).
118 * @param GCPhysFault The GC physical address corresponding to pvFault.
119 * @param pvUser User argument.
120 */
121typedef DECLCALLBACK(int) FNPGMR0PHYSHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
122/** Pointer to PGM access callback. */
123typedef FNPGMR0PHYSHANDLER *PFNPGMR0PHYSHANDLER;
124
125/**
126 * Guest Access type
127 */
128typedef enum PGMACCESSTYPE
129{
130 /** Read access. */
131 PGMACCESSTYPE_READ = 1,
132 /** Write access. */
133 PGMACCESSTYPE_WRITE
134} PGMACCESSTYPE;
135
136/**
137 * \#PF Handler callback for physical access handler ranges (MMIO among others) in HC.
138 *
139 * The handler can not raise any faults, it's mainly for monitoring write access
140 * to certain pages.
141 *
142 * @returns VINF_SUCCESS if the handler have carried out the operation.
143 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
144 * @param pVM VM Handle.
145 * @param GCPhys The physical address the guest is writing to.
146 * @param pvPhys The HC mapping of that address.
147 * @param pvBuf What the guest is reading/writing.
148 * @param cbBuf How much it's reading/writing.
149 * @param enmAccessType The access type.
150 * @param pvUser User argument.
151 */
152typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
153/** Pointer to PGM access callback. */
154typedef FNPGMR3PHYSHANDLER *PFNPGMR3PHYSHANDLER;
155
156
157/**
158 * Virtual access handler type.
159 */
160typedef enum PGMVIRTHANDLERTYPE
161{
162 /** Write access handled. */
163 PGMVIRTHANDLERTYPE_WRITE = 1,
164 /** All access handled. */
165 PGMVIRTHANDLERTYPE_ALL,
166 /** Hypervisor write access handled.
167 * This is used to catch the guest trying to write to LDT, TSS and any other
168 * system structure which the brain dead intel guys let unprivilegde code find. */
169 PGMVIRTHANDLERTYPE_HYPERVISOR
170} PGMVIRTHANDLERTYPE;
171
172/**
173 * \#PF Handler callback for virtual access handler ranges, RC.
174 *
175 * Important to realize that a physical page in a range can have aliases, and
176 * for ALL and WRITE handlers these will also trigger.
177 *
178 * @returns VBox status code (appropriate for GC return).
179 * @param pVM VM Handle.
180 * @param uErrorCode CPU Error code.
181 * @param pRegFrame Trap register frame.
182 * @param pvFault The fault address (cr2).
183 * @param pvRange The base address of the handled virtual range.
184 * @param offRange The offset of the access into this range.
185 * (If it's a EIP range this is the EIP, if not it's pvFault.)
186 */
187typedef DECLCALLBACK(int) FNPGMRCVIRTHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
188/** Pointer to PGM access callback. */
189typedef FNPGMRCVIRTHANDLER *PFNPGMRCVIRTHANDLER;
190
191/**
192 * \#PF Handler callback for virtual access handler ranges, R3.
193 *
194 * Important to realize that a physical page in a range can have aliases, and
195 * for ALL and WRITE handlers these will also trigger.
196 *
197 * @returns VINF_SUCCESS if the handler have carried out the operation.
198 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
199 * @param pVM VM Handle.
200 * @param GCPtr The virtual address the guest is writing to. (not correct if it's an alias!)
201 * @param pvPtr The HC mapping of that address.
202 * @param pvBuf What the guest is reading/writing.
203 * @param cbBuf How much it's reading/writing.
204 * @param enmAccessType The access type.
205 * @param pvUser User argument.
206 */
207typedef DECLCALLBACK(int) FNPGMR3VIRTHANDLER(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
208/** Pointer to PGM access callback. */
209typedef FNPGMR3VIRTHANDLER *PFNPGMR3VIRTHANDLER;
210
211
212/**
213 * \#PF Handler callback for invalidation of virtual access handler ranges.
214 *
215 * @param pVM VM Handle.
216 * @param GCPtr The virtual address the guest has changed.
217 */
218typedef DECLCALLBACK(int) FNPGMR3VIRTINVALIDATE(PVM pVM, RTGCPTR GCPtr);
219/** Pointer to PGM invalidation callback. */
220typedef FNPGMR3VIRTINVALIDATE *PFNPGMR3VIRTINVALIDATE;
221
222/**
223 * PGMR3PhysEnumDirtyFTPages callback for syncing dirty physical pages
224 *
225 * @param pVM VM Handle.
226 * @param GCPhys GC physical address
227 * @param pRange HC virtual address of the page(s)
228 * @param cbRange Size of the dirty range in bytes.
229 * @param pvUser User argument.
230 */
231typedef DECLCALLBACK(int) FNPGMENUMDIRTYFTPAGES(PVM pVM, RTGCPHYS GCPhys, uint8_t *pRange, unsigned cbRange, void *pvUser);
232/** Pointer to PGMR3PhysEnumDirtyFTPages callback. */
233typedef FNPGMENUMDIRTYFTPAGES *PFNPGMENUMDIRTYFTPAGES;
234
235/**
236 * Paging mode.
237 */
238typedef enum PGMMODE
239{
240 /** The usual invalid value. */
241 PGMMODE_INVALID = 0,
242 /** Real mode. */
243 PGMMODE_REAL,
244 /** Protected mode, no paging. */
245 PGMMODE_PROTECTED,
246 /** 32-bit paging. */
247 PGMMODE_32_BIT,
248 /** PAE paging. */
249 PGMMODE_PAE,
250 /** PAE paging with NX enabled. */
251 PGMMODE_PAE_NX,
252 /** 64-bit AMD paging (long mode). */
253 PGMMODE_AMD64,
254 /** 64-bit AMD paging (long mode) with NX enabled. */
255 PGMMODE_AMD64_NX,
256 /** Nested paging mode (shadow only; guest physical to host physical). */
257 PGMMODE_NESTED,
258 /** Extended paging (Intel) mode. */
259 PGMMODE_EPT,
260 /** The max number of modes */
261 PGMMODE_MAX,
262 /** 32bit hackishness. */
263 PGMMODE_32BIT_HACK = 0x7fffffff
264} PGMMODE;
265
266/** Macro for checking if the guest is using paging.
267 * @param enmMode PGMMODE_*.
268 * @remark ASSUMES certain order of the PGMMODE_* values.
269 */
270#define PGMMODE_WITH_PAGING(enmMode) ((enmMode) >= PGMMODE_32_BIT)
271
272/** Macro for checking if it's one of the long mode modes.
273 * @param enmMode PGMMODE_*.
274 */
275#define PGMMODE_IS_LONG_MODE(enmMode) ((enmMode) == PGMMODE_AMD64_NX || (enmMode) == PGMMODE_AMD64)
276
277/**
278 * Is the ROM mapped (true) or is the shadow RAM mapped (false).
279 *
280 * @returns boolean.
281 * @param enmProt The PGMROMPROT value, must be valid.
282 */
283#define PGMROMPROT_IS_ROM(enmProt) \
284 ( (enmProt) == PGMROMPROT_READ_ROM_WRITE_IGNORE \
285 || (enmProt) == PGMROMPROT_READ_ROM_WRITE_RAM )
286
287
288
289VMMDECL(bool) PGMIsLocked(PVM pVM);
290VMMDECL(bool) PGMIsLockOwner(PVM pVM);
291
292VMMDECL(int) PGMRegisterStringFormatTypes(void);
293VMMDECL(void) PGMDeregisterStringFormatTypes(void);
294VMMDECL(RTHCPHYS) PGMGetHyperCR3(PVMCPU pVCpu);
295VMMDECL(RTHCPHYS) PGMGetNestedCR3(PVMCPU pVCpu, PGMMODE enmShadowMode);
296VMMDECL(RTHCPHYS) PGMGetInterHCCR3(PVM pVM);
297VMMDECL(RTHCPHYS) PGMGetInterRCCR3(PVM pVM, PVMCPU pVCpu);
298VMMDECL(RTHCPHYS) PGMGetInter32BitCR3(PVM pVM);
299VMMDECL(RTHCPHYS) PGMGetInterPaeCR3(PVM pVM);
300VMMDECL(RTHCPHYS) PGMGetInterAmd64CR3(PVM pVM);
301VMMDECL(int) PGMTrap0eHandler(PVMCPU pVCpu, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault);
302VMMDECL(int) PGMPrefetchPage(PVMCPU pVCpu, RTGCPTR GCPtrPage);
303VMMDECL(int) PGMVerifyAccess(PVMCPU pVCpu, RTGCPTR Addr, uint32_t cbSize, uint32_t fAccess);
304VMMDECL(int) PGMIsValidAccess(PVMCPU pVCpu, RTGCPTR Addr, uint32_t cbSize, uint32_t fAccess);
305VMMDECL(VBOXSTRICTRC) PGMInterpretInstruction(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault);
306VMMDECL(int) PGMMap(PVM pVM, RTGCPTR GCPtr, RTHCPHYS HCPhys, uint32_t cbPages, unsigned fFlags);
307VMMDECL(int) PGMMapGetPage(PVM pVM, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys);
308VMMDECL(int) PGMMapSetPage(PVM pVM, RTGCPTR GCPtr, uint64_t cb, uint64_t fFlags);
309VMMDECL(int) PGMMapModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask);
310#ifndef IN_RING0
311VMMDECL(bool) PGMMapHasConflicts(PVM pVM);
312#endif
313#ifdef VBOX_STRICT
314VMMDECL(void) PGMMapCheck(PVM pVM);
315#endif
316VMMDECL(int) PGMShwGetPage(PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys);
317VMMDECL(int) PGMShwMakePageReadonly(PVMCPU pVCpu, RTGCPTR GCPtr, uint32_t fFlags);
318VMMDECL(int) PGMShwMakePageWritable(PVMCPU pVCpu, RTGCPTR GCPtr, uint32_t fFlags);
319VMMDECL(int) PGMShwMakePageNotPresent(PVMCPU pVCpu, RTGCPTR GCPtr, uint32_t fFlags);
320/** @name Flags for PGMShwMakePageReadonly, PGMShwMakePageWritable and
321 * PGMShwMakePageNotPresent
322 * @{ */
323/** The call is from an access handler for dealing with the a faulting write
324 * operation. The virtual address is within the same page. */
325#define PGM_MK_PG_IS_WRITE_FAULT RT_BIT(0)
326/** The page is an MMIO2. */
327#define PGM_MK_PG_IS_MMIO2 RT_BIT(1)
328/** @}*/
329VMMDECL(int) PGMGstGetPage(PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys);
330VMMDECL(bool) PGMGstIsPagePresent(PVMCPU pVCpu, RTGCPTR GCPtr);
331VMMDECL(int) PGMGstSetPage(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags);
332VMMDECL(int) PGMGstModifyPage(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask);
333VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVMCPU pVCpu, unsigned iPdPt);
334
335VMMDECL(int) PGMInvalidatePage(PVMCPU pVCpu, RTGCPTR GCPtrPage);
336VMMDECL(int) PGMFlushTLB(PVMCPU pVCpu, uint64_t cr3, bool fGlobal);
337VMMDECL(int) PGMSyncCR3(PVMCPU pVCpu, uint64_t cr0, uint64_t cr3, uint64_t cr4, bool fGlobal);
338VMMDECL(int) PGMUpdateCR3(PVMCPU pVCpu, uint64_t cr3);
339VMMDECL(int) PGMChangeMode(PVMCPU pVCpu, uint64_t cr0, uint64_t cr4, uint64_t efer);
340VMMDECL(PGMMODE) PGMGetGuestMode(PVMCPU pVCpu);
341VMMDECL(PGMMODE) PGMGetShadowMode(PVMCPU pVCpu);
342VMMDECL(PGMMODE) PGMGetHostMode(PVM pVM);
343VMMDECL(const char *) PGMGetModeName(PGMMODE enmMode);
344VMM_INT_DECL(void) PGMNotifyNxeChanged(PVMCPU pVCpu, bool fNxe);
345VMMDECL(bool) PGMHasDirtyPages(PVM pVM);
346VMMDECL(int) PGMHandlerPhysicalRegisterEx(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
347 R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
348 R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
349 RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, RTRCPTR pvUserRC,
350 R3PTRTYPE(const char *) pszDesc);
351VMMDECL(int) PGMHandlerPhysicalModify(PVM pVM, RTGCPHYS GCPhysCurrent, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast);
352VMMDECL(int) PGMHandlerPhysicalDeregister(PVM pVM, RTGCPHYS GCPhys);
353VMMDECL(int) PGMHandlerPhysicalChangeCallbacks(PVM pVM, RTGCPHYS GCPhys,
354 R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
355 R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
356 RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, RTRCPTR pvUserRC,
357 R3PTRTYPE(const char *) pszDesc);
358VMMDECL(int) PGMHandlerPhysicalSplit(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysSplit);
359VMMDECL(int) PGMHandlerPhysicalJoin(PVM pVM, RTGCPHYS GCPhys1, RTGCPHYS GCPhys2);
360VMMDECL(int) PGMHandlerPhysicalPageTempOff(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage);
361VMMDECL(int) PGMHandlerPhysicalPageAlias(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage, RTGCPHYS GCPhysPageRemap);
362VMMDECL(int) PGMHandlerPhysicalPageAliasHC(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage, RTHCPHYS HCPhysPageRemap);
363VMMDECL(int) PGMHandlerPhysicalReset(PVM pVM, RTGCPHYS GCPhys);
364VMMDECL(bool) PGMHandlerPhysicalIsRegistered(PVM pVM, RTGCPHYS GCPhys);
365VMMDECL(bool) PGMHandlerVirtualIsRegistered(PVM pVM, RTGCPTR GCPtr);
366VMMDECL(bool) PGMPhysIsA20Enabled(PVMCPU pVCpu);
367VMMDECL(bool) PGMPhysIsGCPhysValid(PVM pVM, RTGCPHYS GCPhys);
368VMMDECL(bool) PGMPhysIsGCPhysNormal(PVM pVM, RTGCPHYS GCPhys);
369VMMDECL(int) PGMPhysGCPtr2GCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTGCPHYS pGCPhys);
370VMMDECL(void) PGMPhysInvalidatePageMapTLB(PVM pVM);
371VMMDECL(void) PGMPhysInvalidatePageMapTLBEntry(PVM pVM, RTGCPHYS GCPhys);
372VMMDECL(void) PGMPhysReleasePageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock);
373VMMDECL(int) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead);
374VMMDECL(int) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite);
375VMMDECL(int) PGMPhysSimpleReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb);
376VMMDECL(int) PGMPhysSimpleWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void *pvSrc, size_t cb);
377VMMDECL(int) PGMPhysSimpleReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb);
378VMMDECL(int) PGMPhysSimpleWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb);
379VMMDECL(int) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb);
380VMMDECL(int) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb);
381VMMDECL(int) PGMPhysSimpleDirtyWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb);
382VMMDECL(int) PGMPhysInterpretedRead(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCPTR GCPtrSrc, size_t cb);
383VMMDECL(int) PGMPhysInterpretedReadNoHandlers(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCUINTPTR GCPtrSrc, size_t cb, bool fRaiseTrap);
384VMMDECL(int) PGMPhysInterpretedWriteNoHandlers(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, void const *pvSrc, size_t cb, bool fRaiseTrap);
385#ifdef VBOX_STRICT
386VMMDECL(unsigned) PGMAssertHandlerAndFlagsInSync(PVM pVM);
387VMMDECL(unsigned) PGMAssertNoMappingConflicts(PVM pVM);
388VMMDECL(unsigned) PGMAssertCR3(PVM pVM, PVMCPU pVCpu, uint64_t cr3, uint64_t cr4);
389#endif /* VBOX_STRICT */
390
391#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE)
392VMMDECL(void) PGMRZDynMapStartAutoSet(PVMCPU pVCpu);
393VMMDECL(void) PGMRZDynMapReleaseAutoSet(PVMCPU pVCpu);
394VMMDECL(void) PGMRZDynMapFlushAutoSet(PVMCPU pVCpu);
395VMMDECL(uint32_t) PGMRZDynMapPushAutoSubset(PVMCPU pVCpu);
396VMMDECL(void) PGMRZDynMapPopAutoSubset(PVMCPU pVCpu, uint32_t iPrevSubset);
397#endif
398
399VMMDECL(void) PGMSetLargePageUsage(PVM pVM, bool fUseLargePages);
400
401/**
402 * Query large page usage state
403 *
404 * @returns 0 - disabled, 1 - enabled
405 * @param pVM The VM to operate on.
406 */
407#define PGMIsUsingLargePages(pVM) ((pVM)->fUseLargePages)
408
409
410#ifdef IN_RC
411/** @defgroup grp_pgm_gc The PGM Guest Context API
412 * @ingroup grp_pgm
413 * @{
414 */
415VMMRCDECL(int) PGMRCDynMapInit(PVM pVM);
416/** @} */
417#endif /* IN_RC */
418
419
420#ifdef IN_RING0
421/** @defgroup grp_pgm_r0 The PGM Host Context Ring-0 API
422 * @ingroup grp_pgm
423 * @{
424 */
425VMMR0DECL(int) PGMR0PhysAllocateHandyPages(PVM pVM, PVMCPU pVCpu);
426VMMR0DECL(int) PGMR0PhysAllocateLargeHandyPage(PVM pVM, PVMCPU pVCpu);
427VMMR0DECL(int) PGMR0SharedModuleCheck(PVM pVM, PGVM pGVM, VMCPUID idCpu, PGMMSHAREDMODULE pModule, uint32_t cRegions, PGMMSHAREDREGIONDESC pRegions);
428VMMR0DECL(int) PGMR0Trap0eHandlerNestedPaging(PVM pVM, PVMCPU pVCpu, PGMMODE enmShwPagingMode, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPHYS pvFault);
429VMMR0DECL(VBOXSTRICTRC) PGMR0Trap0eHandlerNPMisconfig(PVM pVM, PVMCPU pVCpu, PGMMODE enmShwPagingMode, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, uint32_t uErr);
430# ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
431VMMR0DECL(int) PGMR0DynMapInit(void);
432VMMR0DECL(void) PGMR0DynMapTerm(void);
433VMMR0DECL(int) PGMR0DynMapInitVM(PVM pVM);
434VMMR0DECL(void) PGMR0DynMapTermVM(PVM pVM);
435VMMR0DECL(int) PGMR0DynMapAssertIntegrity(void);
436VMMR0DECL(bool) PGMR0DynMapStartOrMigrateAutoSet(PVMCPU pVCpu);
437VMMR0DECL(void) PGMR0DynMapMigrateAutoSet(PVMCPU pVCpu);
438# endif
439/** @} */
440#endif /* IN_RING0 */
441
442
443
444#ifdef IN_RING3
445/** @defgroup grp_pgm_r3 The PGM Host Context Ring-3 API
446 * @ingroup grp_pgm
447 * @{
448 */
449VMMR3DECL(int) PGMR3Init(PVM pVM);
450VMMR3DECL(int) PGMR3InitDynMap(PVM pVM);
451VMMR3DECL(int) PGMR3InitFinalize(PVM pVM);
452VMMR3DECL(void) PGMR3Relocate(PVM pVM, RTGCINTPTR offDelta);
453VMMR3DECL(void) PGMR3ResetUnpluggedCpu(PVM pVM, PVMCPU pVCpu);
454VMMR3DECL(void) PGMR3Reset(PVM pVM);
455VMMR3DECL(int) PGMR3Term(PVM pVM);
456VMMR3DECL(int) PGMR3LockCall(PVM pVM);
457VMMR3DECL(int) PGMR3ChangeMode(PVM pVM, PVMCPU pVCpu, PGMMODE enmGuestMode);
458
459VMMR3DECL(int) PGMR3PhysRegisterRam(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, const char *pszDesc);
460VMMR3DECL(int) PGMR3PhysChangeMemBalloon(PVM pVM, bool fInflate, unsigned cPages, RTGCPHYS *paPhysPage);
461VMMR3DECL(int) PGMR3PhysWriteProtectRAM(PVM pVM);
462VMMR3DECL(int) PGMR3PhysEnumDirtyFTPages(PVM pVM, PFNPGMENUMDIRTYFTPAGES pfnEnum, void *pvUser);
463VMMR3DECL(uint32_t) PGMR3PhysGetRamRangeCount(PVM pVM);
464VMMR3DECL(int) PGMR3PhysGetRange(PVM pVM, uint32_t iRange, PRTGCPHYS pGCPhysStart, PRTGCPHYS pGCPhysLast,
465 const char **ppszDesc, bool *pfIsMmio);
466VMMR3DECL(int) PGMR3QueryVMMMemoryStats(PVM pVM, uint64_t *puTotalAllocSize, uint64_t *puTotalFreeSize, uint64_t *puTotalBalloonSize, uint64_t *puTotalSharedSize);
467VMMR3DECL(int) PGMR3QueryMemoryStats(PVM pVM, uint64_t *pulTotalMem, uint64_t *pulPrivateMem, uint64_t *puTotalSharedMem, uint64_t *puTotalZeroMem);
468VMMR3DECL(int) PGMR3PhysMMIORegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb,
469 R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
470 R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
471 RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, RTRCPTR pvUserRC,
472 R3PTRTYPE(const char *) pszDesc);
473VMMR3DECL(int) PGMR3PhysMMIODeregister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb);
474VMMR3DECL(int) PGMR3PhysMMIO2Register(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, uint32_t fFlags, void **ppv, const char *pszDesc);
475VMMR3DECL(int) PGMR3PhysMMIO2Deregister(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion);
476VMMR3DECL(int) PGMR3PhysMMIO2Map(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys);
477VMMR3DECL(int) PGMR3PhysMMIO2Unmap(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys);
478VMMR3DECL(bool) PGMR3PhysMMIO2IsBase(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys);
479VMMR3DECL(int) PGMR3PhysMMIO2GetHCPhys(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, PRTHCPHYS pHCPhys);
480VMMR3DECL(int) PGMR3PhysMMIO2MapKernel(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb, const char *pszDesc, PRTR0PTR pR0Ptr);
481
482/** @name PGMR3PhysRegisterRom flags.
483 * @{ */
484/** Inidicates that ROM shadowing should be enabled. */
485#define PGMPHYS_ROM_FLAGS_SHADOWED RT_BIT_32(0)
486/** Indicates that what pvBinary points to won't go away
487 * and can be used for strictness checks. */
488#define PGMPHYS_ROM_FLAGS_PERMANENT_BINARY RT_BIT_32(1)
489/** @} */
490
491VMMR3DECL(int) PGMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cb,
492 const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc);
493VMMR3DECL(int) PGMR3PhysRomProtect(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, PGMROMPROT enmProt);
494VMMR3DECL(int) PGMR3PhysRegister(PVM pVM, void *pvRam, RTGCPHYS GCPhys, size_t cb, unsigned fFlags, const SUPPAGE *paPages, const char *pszDesc);
495VMMDECL(void) PGMR3PhysSetA20(PVMCPU pVCpu, bool fEnable);
496/** @name PGMR3MapPT flags.
497 * @{ */
498/** The mapping may be unmapped later. The default is permanent mappings. */
499#define PGMR3MAPPT_FLAGS_UNMAPPABLE RT_BIT(0)
500/** @} */
501VMMR3DECL(int) PGMR3MapPT(PVM pVM, RTGCPTR GCPtr, uint32_t cb, uint32_t fFlags, PFNPGMRELOCATE pfnRelocate, void *pvUser, const char *pszDesc);
502VMMR3DECL(int) PGMR3UnmapPT(PVM pVM, RTGCPTR GCPtr);
503VMMR3DECL(int) PGMR3FinalizeMappings(PVM pVM);
504VMMR3DECL(int) PGMR3MappingsDisable(PVM pVM);
505VMMR3DECL(int) PGMR3MappingsSize(PVM pVM, uint32_t *pcb);
506VMMR3DECL(int) PGMR3MappingsFix(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb);
507VMMR3DECL(int) PGMR3MappingsUnfix(PVM pVM);
508VMMR3DECL(bool) PGMR3MappingsNeedReFixing(PVM pVM);
509VMMR3DECL(int) PGMR3MapIntermediate(PVM pVM, RTUINTPTR Addr, RTHCPHYS HCPhys, unsigned cbPages);
510VMMR3DECL(int) PGMR3MapRead(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb);
511
512VMMR3DECL(int) PGMR3HandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
513 PFNPGMR3PHYSHANDLER pfnHandlerR3, void *pvUserR3,
514 const char *pszModR0, const char *pszHandlerR0, RTR0PTR pvUserR0,
515 const char *pszModRC, const char *pszHandlerRC, RTRCPTR pvUserRC, const char *pszDesc);
516VMMDECL(int) PGMR3HandlerVirtualRegisterEx(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
517 R3PTRTYPE(PFNPGMR3VIRTINVALIDATE) pfnInvalidateR3,
518 R3PTRTYPE(PFNPGMR3VIRTHANDLER) pfnHandlerR3,
519 RCPTRTYPE(PFNPGMRCVIRTHANDLER) pfnHandlerRC,
520 R3PTRTYPE(const char *) pszDesc);
521VMMR3DECL(int) PGMR3HandlerVirtualRegister(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
522 PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
523 PFNPGMR3VIRTHANDLER pfnHandlerR3,
524 const char *pszHandlerRC, const char *pszModRC, const char *pszDesc);
525VMMDECL(int) PGMHandlerVirtualChangeInvalidateCallback(PVM pVM, RTGCPTR GCPtr, R3PTRTYPE(PFNPGMR3VIRTINVALIDATE) pfnInvalidateR3);
526VMMDECL(int) PGMHandlerVirtualDeregister(PVM pVM, RTGCPTR GCPtr);
527VMMR3DECL(int) PGMR3PoolGrow(PVM pVM);
528
529VMMR3DECL(int) PGMR3PhysTlbGCPhys2Ptr(PVM pVM, RTGCPHYS GCPhys, bool fWritable, void **ppv);
530VMMR3DECL(uint8_t) PGMR3PhysReadU8(PVM pVM, RTGCPHYS GCPhys);
531VMMR3DECL(uint16_t) PGMR3PhysReadU16(PVM pVM, RTGCPHYS GCPhys);
532VMMR3DECL(uint32_t) PGMR3PhysReadU32(PVM pVM, RTGCPHYS GCPhys);
533VMMR3DECL(uint64_t) PGMR3PhysReadU64(PVM pVM, RTGCPHYS GCPhys);
534VMMR3DECL(void) PGMR3PhysWriteU8(PVM pVM, RTGCPHYS GCPhys, uint8_t Value);
535VMMR3DECL(void) PGMR3PhysWriteU16(PVM pVM, RTGCPHYS GCPhys, uint16_t Value);
536VMMR3DECL(void) PGMR3PhysWriteU32(PVM pVM, RTGCPHYS GCPhys, uint32_t Value);
537VMMR3DECL(void) PGMR3PhysWriteU64(PVM pVM, RTGCPHYS GCPhys, uint64_t Value);
538VMMR3DECL(int) PGMR3PhysReadExternal(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead);
539VMMR3DECL(int) PGMR3PhysWriteExternal(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, const char *pszWho);
540VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrExternal(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock);
541VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrReadOnlyExternal(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock);
542VMMR3DECL(int) PGMR3PhysChunkMap(PVM pVM, uint32_t idChunk);
543VMMR3DECL(void) PGMR3PhysChunkInvalidateTLB(PVM pVM);
544VMMR3DECL(int) PGMR3PhysAllocateHandyPages(PVM pVM);
545VMMR3DECL(int) PGMR3PhysAllocateLargeHandyPage(PVM pVM, RTGCPHYS GCPhys);
546
547VMMR3DECL(int) PGMR3CheckIntegrity(PVM pVM);
548
549VMMR3DECL(int) PGMR3DbgR3Ptr2GCPhys(PVM pVM, RTR3PTR R3Ptr, PRTGCPHYS pGCPhys);
550VMMR3DECL(int) PGMR3DbgR3Ptr2HCPhys(PVM pVM, RTR3PTR R3Ptr, PRTHCPHYS pHCPhys);
551VMMR3DECL(int) PGMR3DbgHCPhys2GCPhys(PVM pVM, RTHCPHYS HCPhys, PRTGCPHYS pGCPhys);
552VMMR3DECL(int) PGMR3DbgReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb, uint32_t fFlags, size_t *pcbRead);
553VMMR3DECL(int) PGMR3DbgWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void *pvSrc, size_t cb, uint32_t fFlags, size_t *pcbWritten);
554VMMR3DECL(int) PGMR3DbgReadGCPtr(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb, uint32_t fFlags, size_t *pcbRead);
555VMMR3DECL(int) PGMR3DbgWriteGCPtr(PVM pVM, RTGCPTR GCPtrDst, void const *pvSrc, size_t cb, uint32_t fFlags, size_t *pcbWritten);
556VMMR3DECL(int) PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, RTGCPHYS GCPhysAlign, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit);
557VMMR3DECL(int) PGMR3DbgScanVirtual(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, RTGCPTR cbRange, RTGCPTR GCPtrAlign, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPhysHit);
558VMMR3_INT_DECL(int) PGMR3DumpHierarchyShw(PVM pVM, uint64_t cr3, uint32_t fFlags, uint64_t u64FirstAddr, uint64_t u64LastAddr, uint32_t cMaxDepth, PCDBGFINFOHLP pHlp);
559VMMR3_INT_DECL(int) PGMR3DumpHierarchyGst(PVM pVM, uint64_t cr3, uint32_t fFlags, RTGCPTR FirstAddr, RTGCPTR LastAddr, uint32_t cMaxDepth, PCDBGFINFOHLP pHlp);
560
561
562/** @name Page sharing
563 * @{ */
564VMMR3DECL(int) PGMR3SharedModuleRegister(PVM pVM, VBOXOSFAMILY enmGuestOS, char *pszModuleName, char *pszVersion, RTGCPTR GCBaseAddr, uint32_t cbModule, unsigned cRegions, VMMDEVSHAREDREGIONDESC *pRegions);
565VMMR3DECL(int) PGMR3SharedModuleUnregister(PVM pVM, char *pszModuleName, char *pszVersion, RTGCPTR GCBaseAddr, uint32_t cbModule);
566VMMR3DECL(int) PGMR3SharedModuleCheckAll(PVM pVM);
567VMMR3DECL(int) PGMR3SharedModuleGetPageState(PVM pVM, RTGCPTR GCPtrPage, bool *pfShared, uint64_t *puPageFlags);
568/** @} */
569
570/** @} */
571#endif /* IN_RING3 */
572
573RT_C_DECLS_END
574
575/** @} */
576#endif
577
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