1 | /** @file
|
---|
2 | * MM - The Memory Manager.
|
---|
3 | */
|
---|
4 |
|
---|
5 | /*
|
---|
6 | * Copyright (C) 2006-2015 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_vmm_mm_h
|
---|
27 | #define ___VBox_vmm_mm_h
|
---|
28 |
|
---|
29 | #include <VBox/types.h>
|
---|
30 | #include <iprt/x86.h>
|
---|
31 | #include <VBox/sup.h>
|
---|
32 | #include <iprt/stdarg.h>
|
---|
33 |
|
---|
34 |
|
---|
35 | RT_C_DECLS_BEGIN
|
---|
36 |
|
---|
37 | /** @defgroup grp_mm The Memory Manager API
|
---|
38 | * @ingroup grp_vmm
|
---|
39 | * @{
|
---|
40 | */
|
---|
41 |
|
---|
42 | /**
|
---|
43 | * Memory Allocation Tags.
|
---|
44 | * For use with MMHyperAlloc(), MMR3HeapAlloc(), MMR3HeapAllocEx(),
|
---|
45 | * MMR3HeapAllocZ() and MMR3HeapAllocZEx().
|
---|
46 | *
|
---|
47 | * @remark Don't forget to update the dump command in MMHeap.cpp!
|
---|
48 | */
|
---|
49 | typedef enum MMTAG
|
---|
50 | {
|
---|
51 | MM_TAG_INVALID = 0,
|
---|
52 |
|
---|
53 | MM_TAG_CFGM,
|
---|
54 | MM_TAG_CFGM_BYTES,
|
---|
55 | MM_TAG_CFGM_STRING,
|
---|
56 | MM_TAG_CFGM_USER,
|
---|
57 |
|
---|
58 | MM_TAG_CSAM,
|
---|
59 | MM_TAG_CSAM_PATCH,
|
---|
60 |
|
---|
61 | MM_TAG_CPUM_CTX,
|
---|
62 | MM_TAG_CPUM_CPUID,
|
---|
63 | MM_TAG_CPUM_MSRS,
|
---|
64 |
|
---|
65 | MM_TAG_DBGF,
|
---|
66 | MM_TAG_DBGF_AS,
|
---|
67 | MM_TAG_DBGF_CORE_WRITE,
|
---|
68 | MM_TAG_DBGF_INFO,
|
---|
69 | MM_TAG_DBGF_LINE,
|
---|
70 | MM_TAG_DBGF_LINE_DUP,
|
---|
71 | MM_TAG_DBGF_MODULE,
|
---|
72 | MM_TAG_DBGF_OS,
|
---|
73 | MM_TAG_DBGF_REG,
|
---|
74 | MM_TAG_DBGF_STACK,
|
---|
75 | MM_TAG_DBGF_SYMBOL,
|
---|
76 | MM_TAG_DBGF_SYMBOL_DUP,
|
---|
77 |
|
---|
78 | MM_TAG_EM,
|
---|
79 |
|
---|
80 | MM_TAG_IOM,
|
---|
81 | MM_TAG_IOM_STATS,
|
---|
82 |
|
---|
83 | MM_TAG_MM,
|
---|
84 | MM_TAG_MM_LOOKUP_GUEST,
|
---|
85 | MM_TAG_MM_LOOKUP_PHYS,
|
---|
86 | MM_TAG_MM_LOOKUP_VIRT,
|
---|
87 | MM_TAG_MM_PAGE,
|
---|
88 |
|
---|
89 | MM_TAG_PARAV,
|
---|
90 |
|
---|
91 | MM_TAG_PATM,
|
---|
92 | MM_TAG_PATM_PATCH,
|
---|
93 |
|
---|
94 | MM_TAG_PDM,
|
---|
95 | MM_TAG_PDM_ASYNC_COMPLETION,
|
---|
96 | MM_TAG_PDM_DEVICE,
|
---|
97 | MM_TAG_PDM_DEVICE_DESC,
|
---|
98 | MM_TAG_PDM_DEVICE_USER,
|
---|
99 | MM_TAG_PDM_DRIVER,
|
---|
100 | MM_TAG_PDM_DRIVER_DESC,
|
---|
101 | MM_TAG_PDM_DRIVER_USER,
|
---|
102 | MM_TAG_PDM_USB,
|
---|
103 | MM_TAG_PDM_USB_DESC,
|
---|
104 | MM_TAG_PDM_USB_USER,
|
---|
105 | MM_TAG_PDM_LUN,
|
---|
106 | #ifdef VBOX_WITH_NETSHAPER
|
---|
107 | MM_TAG_PDM_NET_SHAPER,
|
---|
108 | #endif /* VBOX_WITH_NETSHAPER */
|
---|
109 | MM_TAG_PDM_QUEUE,
|
---|
110 | MM_TAG_PDM_THREAD,
|
---|
111 |
|
---|
112 | MM_TAG_PGM,
|
---|
113 | MM_TAG_PGM_CHUNK_MAPPING,
|
---|
114 | MM_TAG_PGM_HANDLERS,
|
---|
115 | MM_TAG_PGM_HANDLER_TYPES,
|
---|
116 | MM_TAG_PGM_MAPPINGS,
|
---|
117 | MM_TAG_PGM_PHYS,
|
---|
118 | MM_TAG_PGM_POOL,
|
---|
119 |
|
---|
120 | MM_TAG_REM,
|
---|
121 |
|
---|
122 | MM_TAG_SELM,
|
---|
123 |
|
---|
124 | MM_TAG_SSM,
|
---|
125 |
|
---|
126 | MM_TAG_STAM,
|
---|
127 |
|
---|
128 | MM_TAG_TM,
|
---|
129 |
|
---|
130 | MM_TAG_TRPM,
|
---|
131 |
|
---|
132 | MM_TAG_VM,
|
---|
133 | MM_TAG_VM_REQ,
|
---|
134 |
|
---|
135 | MM_TAG_VMM,
|
---|
136 |
|
---|
137 | MM_TAG_HM,
|
---|
138 |
|
---|
139 | MM_TAG_32BIT_HACK = 0x7fffffff
|
---|
140 | } MMTAG;
|
---|
141 |
|
---|
142 |
|
---|
143 |
|
---|
144 |
|
---|
145 | /** @defgroup grp_mm_hyper Hypervisor Memory Management
|
---|
146 | * @{ */
|
---|
147 |
|
---|
148 | VMMDECL(RTR3PTR) MMHyperR0ToR3(PVM pVM, RTR0PTR R0Ptr);
|
---|
149 | VMMDECL(RTRCPTR) MMHyperR0ToRC(PVM pVM, RTR0PTR R0Ptr);
|
---|
150 | #ifndef IN_RING0
|
---|
151 | VMMDECL(void *) MMHyperR0ToCC(PVM pVM, RTR0PTR R0Ptr);
|
---|
152 | #endif
|
---|
153 | VMMDECL(RTR0PTR) MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr);
|
---|
154 | VMMDECL(RTRCPTR) MMHyperR3ToRC(PVM pVM, RTR3PTR R3Ptr);
|
---|
155 | VMMDECL(RTR3PTR) MMHyperRCToR3(PVM pVM, RTRCPTR RCPtr);
|
---|
156 | VMMDECL(RTR0PTR) MMHyperRCToR0(PVM pVM, RTRCPTR RCPtr);
|
---|
157 |
|
---|
158 | #ifndef IN_RING3
|
---|
159 | VMMDECL(void *) MMHyperR3ToCC(PVM pVM, RTR3PTR R3Ptr);
|
---|
160 | #else
|
---|
161 | DECLINLINE(void *) MMHyperR3ToCC(PVM pVM, RTR3PTR R3Ptr)
|
---|
162 | {
|
---|
163 | NOREF(pVM);
|
---|
164 | return R3Ptr;
|
---|
165 | }
|
---|
166 | #endif
|
---|
167 |
|
---|
168 |
|
---|
169 | #ifndef IN_RC
|
---|
170 | VMMDECL(void *) MMHyperRCToCC(PVM pVM, RTRCPTR RCPtr);
|
---|
171 | #else
|
---|
172 | DECLINLINE(void *) MMHyperRCToCC(PVM pVM, RTRCPTR RCPtr)
|
---|
173 | {
|
---|
174 | NOREF(pVM);
|
---|
175 | return (void *)RCPtr;
|
---|
176 | }
|
---|
177 | #endif
|
---|
178 |
|
---|
179 | #ifndef IN_RING3
|
---|
180 | VMMDECL(RTR3PTR) MMHyperCCToR3(PVM pVM, void *pv);
|
---|
181 | #else
|
---|
182 | DECLINLINE(RTR3PTR) MMHyperCCToR3(PVM pVM, void *pv)
|
---|
183 | {
|
---|
184 | NOREF(pVM);
|
---|
185 | return pv;
|
---|
186 | }
|
---|
187 | #endif
|
---|
188 |
|
---|
189 | #ifndef IN_RING0
|
---|
190 | VMMDECL(RTR0PTR) MMHyperCCToR0(PVM pVM, void *pv);
|
---|
191 | #else
|
---|
192 | DECLINLINE(RTR0PTR) MMHyperCCToR0(PVM pVM, void *pv)
|
---|
193 | {
|
---|
194 | NOREF(pVM);
|
---|
195 | return pv;
|
---|
196 | }
|
---|
197 | #endif
|
---|
198 |
|
---|
199 | #ifndef IN_RC
|
---|
200 | VMMDECL(RTRCPTR) MMHyperCCToRC(PVM pVM, void *pv);
|
---|
201 | #else
|
---|
202 | DECLINLINE(RTRCPTR) MMHyperCCToRC(PVM pVM, void *pv)
|
---|
203 | {
|
---|
204 | NOREF(pVM);
|
---|
205 | return (RTRCPTR)pv;
|
---|
206 | }
|
---|
207 | #endif
|
---|
208 |
|
---|
209 |
|
---|
210 | VMMDECL(int) MMHyperAlloc(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv);
|
---|
211 | VMMDECL(int) MMHyperDupMem(PVM pVM, const void *pvSrc, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv);
|
---|
212 | VMMDECL(int) MMHyperFree(PVM pVM, void *pv);
|
---|
213 | VMMDECL(void) MMHyperHeapCheck(PVM pVM);
|
---|
214 | VMMDECL(int) MMR3LockCall(PVM pVM);
|
---|
215 | #ifdef DEBUG
|
---|
216 | VMMDECL(void) MMHyperHeapDump(PVM pVM);
|
---|
217 | #endif
|
---|
218 | VMMDECL(size_t) MMHyperHeapGetFreeSize(PVM pVM);
|
---|
219 | VMMDECL(size_t) MMHyperHeapGetSize(PVM pVM);
|
---|
220 | VMMDECL(void *) MMHyperHeapOffsetToPtr(PVM pVM, uint32_t offHeap);
|
---|
221 | VMMDECL(uint32_t) MMHyperHeapPtrToOffset(PVM pVM, void *pv);
|
---|
222 | VMMDECL(RTGCPTR) MMHyperGetArea(PVM pVM, size_t *pcb);
|
---|
223 | VMMDECL(bool) MMHyperIsInsideArea(PVM pVM, RTGCPTR GCPtr);
|
---|
224 |
|
---|
225 |
|
---|
226 | VMMDECL(RTHCPHYS) MMPage2Phys(PVM pVM, void *pvPage);
|
---|
227 | VMMDECL(void *) MMPagePhys2Page(PVM pVM, RTHCPHYS HCPhysPage);
|
---|
228 | VMMDECL(int) MMPagePhys2PageEx(PVM pVM, RTHCPHYS HCPhysPage, void **ppvPage);
|
---|
229 | VMMDECL(int) MMPagePhys2PageTry(PVM pVM, RTHCPHYS HCPhysPage, void **ppvPage);
|
---|
230 |
|
---|
231 |
|
---|
232 | /** @def MMHYPER_RC_ASSERT_RCPTR
|
---|
233 | * Asserts that an address is either NULL or inside the hypervisor memory area.
|
---|
234 | * This assertion only works while IN_RC, it's a NOP everywhere else.
|
---|
235 | * @thread The Emulation Thread.
|
---|
236 | */
|
---|
237 | #ifdef IN_RC
|
---|
238 | # define MMHYPER_RC_ASSERT_RCPTR(pVM, RCPtr) Assert(MMHyperIsInsideArea((pVM), (RTRCUINTPTR)(RCPtr)) || !(RCPtr))
|
---|
239 | #else
|
---|
240 | # define MMHYPER_RC_ASSERT_RCPTR(pVM, RCPtr) do { } while (0)
|
---|
241 | #endif
|
---|
242 |
|
---|
243 | /** @} */
|
---|
244 |
|
---|
245 |
|
---|
246 | #if defined(IN_RING3) || defined(DOXYGEN_RUNNING)
|
---|
247 | /** @defgroup grp_mm_r3 The MM Host Context Ring-3 API
|
---|
248 | * @{
|
---|
249 | */
|
---|
250 |
|
---|
251 | VMMR3DECL(int) MMR3InitUVM(PUVM pUVM);
|
---|
252 | VMMR3DECL(int) MMR3Init(PVM pVM);
|
---|
253 | VMMR3DECL(int) MMR3InitPaging(PVM pVM);
|
---|
254 | VMMR3DECL(int) MMR3HyperInitFinalize(PVM pVM);
|
---|
255 | VMMR3DECL(int) MMR3Term(PVM pVM);
|
---|
256 | VMMR3DECL(void) MMR3TermUVM(PUVM pUVM);
|
---|
257 | VMMR3_INT_DECL(bool) MMR3IsInitialized(PVM pVM);
|
---|
258 | VMMR3DECL(int) MMR3ReserveHandyPages(PVM pVM, uint32_t cHandyPages);
|
---|
259 | VMMR3DECL(int) MMR3IncreaseBaseReservation(PVM pVM, uint64_t cAddBasePages);
|
---|
260 | VMMR3DECL(int) MMR3AdjustFixedReservation(PVM pVM, int32_t cDeltaFixedPages, const char *pszDesc);
|
---|
261 | VMMR3DECL(int) MMR3UpdateShadowReservation(PVM pVM, uint32_t cShadowPages);
|
---|
262 |
|
---|
263 | VMMR3DECL(int) MMR3HCPhys2HCVirt(PVM pVM, RTHCPHYS HCPhys, void **ppv);
|
---|
264 |
|
---|
265 | /** @defgroup grp_mm_r3_hyper Hypervisor Memory Manager (HC R3 Portion)
|
---|
266 | * @{ */
|
---|
267 | VMMR3DECL(int) MMR3HyperAllocOnceNoRel(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv);
|
---|
268 | VMMR3DECL(int) MMR3HyperAllocOnceNoRelEx(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, uint32_t fFlags, void **ppv);
|
---|
269 | VMMR3DECL(int) MMR3HyperRealloc(PVM pVM, void *pv, size_t cb, unsigned uAlignmentNew, MMTAG enmTagNew, size_t cbNew, void **ppv);
|
---|
270 | /** @name MMR3HyperAllocOnceNoRelEx flags
|
---|
271 | * @{ */
|
---|
272 | /** Must have kernel mapping.
|
---|
273 | * If not specified, the R0 pointer may point to the user process mapping. */
|
---|
274 | #define MMHYPER_AONR_FLAGS_KERNEL_MAPPING RT_BIT(0)
|
---|
275 | /** @} */
|
---|
276 | VMMR3DECL(int) MMR3HyperSetGuard(PVM pVM, void *pvStart, size_t cb, bool fSet);
|
---|
277 | VMMR3DECL(int) MMR3HyperMapHCPhys(PVM pVM, void *pvR3, RTR0PTR pvR0, RTHCPHYS HCPhys, size_t cb, const char *pszDesc, PRTGCPTR pGCPtr);
|
---|
278 | VMMR3DECL(int) MMR3HyperMapGCPhys(PVM pVM, RTGCPHYS GCPhys, size_t cb, const char *pszDesc, PRTGCPTR pGCPtr);
|
---|
279 | VMMR3DECL(int) MMR3HyperMapMMIO2(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb, const char *pszDesc, PRTRCPTR pRCPtr);
|
---|
280 | VMMR3DECL(int) MMR3HyperMapPages(PVM pVM, void *pvR3, RTR0PTR pvR0, size_t cPages, PCSUPPAGE paPages, const char *pszDesc, PRTGCPTR pGCPtr);
|
---|
281 | VMMR3DECL(int) MMR3HyperReserve(PVM pVM, unsigned cb, const char *pszDesc, PRTGCPTR pGCPtr);
|
---|
282 | VMMR3DECL(RTHCPHYS) MMR3HyperHCVirt2HCPhys(PVM pVM, void *pvHC);
|
---|
283 | VMMR3DECL(int) MMR3HyperHCVirt2HCPhysEx(PVM pVM, void *pvHC, PRTHCPHYS pHCPhys);
|
---|
284 | VMMR3DECL(void *) MMR3HyperHCPhys2HCVirt(PVM pVM, RTHCPHYS HCPhys);
|
---|
285 | VMMR3DECL(int) MMR3HyperHCPhys2HCVirtEx(PVM pVM, RTHCPHYS HCPhys, void **ppv);
|
---|
286 | VMMR3_INT_DECL(int) MMR3HyperQueryInfoFromHCPhys(PVM pVM, RTHCPHYS HCPhys, char *pszWhat, size_t cbWhat, uint32_t *pcbAlloc);
|
---|
287 | VMMR3DECL(int) MMR3HyperReadGCVirt(PVM pVM, void *pvDst, RTGCPTR GCPtr, size_t cb);
|
---|
288 | /** @} */
|
---|
289 |
|
---|
290 |
|
---|
291 | /** @defgroup grp_mm_phys Guest Physical Memory Manager
|
---|
292 | * @todo retire this group, elimintating or moving MMR3PhysGetRamSize to PGMPhys.
|
---|
293 | * @{ */
|
---|
294 | VMMR3DECL(uint64_t) MMR3PhysGetRamSize(PVM pVM);
|
---|
295 | /** @} */
|
---|
296 |
|
---|
297 |
|
---|
298 | /** @defgroup grp_mm_page Physical Page Pool
|
---|
299 | * @{ */
|
---|
300 | VMMR3DECL(void *) MMR3PageAlloc(PVM pVM);
|
---|
301 | VMMR3DECL(RTHCPHYS) MMR3PageAllocPhys(PVM pVM);
|
---|
302 | VMMR3DECL(void) MMR3PageFree(PVM pVM, void *pvPage);
|
---|
303 | VMMR3DECL(void *) MMR3PageAllocLow(PVM pVM);
|
---|
304 | VMMR3DECL(void) MMR3PageFreeLow(PVM pVM, void *pvPage);
|
---|
305 | VMMR3DECL(void) MMR3PageFreeByPhys(PVM pVM, RTHCPHYS HCPhysPage);
|
---|
306 | VMMR3DECL(void *) MMR3PageDummyHCPtr(PVM pVM);
|
---|
307 | VMMR3DECL(RTHCPHYS) MMR3PageDummyHCPhys(PVM pVM);
|
---|
308 | /** @} */
|
---|
309 |
|
---|
310 |
|
---|
311 | /** @defgroup grp_mm_heap Heap Manager
|
---|
312 | * @{ */
|
---|
313 | VMMR3DECL(void *) MMR3HeapAlloc(PVM pVM, MMTAG enmTag, size_t cbSize);
|
---|
314 | VMMR3DECL(void *) MMR3HeapAllocU(PUVM pUVM, MMTAG enmTag, size_t cbSize);
|
---|
315 | VMMR3DECL(int) MMR3HeapAllocEx(PVM pVM, MMTAG enmTag, size_t cbSize, void **ppv);
|
---|
316 | VMMR3DECL(int) MMR3HeapAllocExU(PUVM pUVM, MMTAG enmTag, size_t cbSize, void **ppv);
|
---|
317 | VMMR3DECL(void *) MMR3HeapAllocZ(PVM pVM, MMTAG enmTag, size_t cbSize);
|
---|
318 | VMMR3DECL(void *) MMR3HeapAllocZU(PUVM pUVM, MMTAG enmTag, size_t cbSize);
|
---|
319 | VMMR3DECL(int) MMR3HeapAllocZEx(PVM pVM, MMTAG enmTag, size_t cbSize, void **ppv);
|
---|
320 | VMMR3DECL(int) MMR3HeapAllocZExU(PUVM pUVM, MMTAG enmTag, size_t cbSize, void **ppv);
|
---|
321 | VMMR3DECL(void *) MMR3HeapRealloc(void *pv, size_t cbNewSize);
|
---|
322 | VMMR3DECL(char *) MMR3HeapStrDup(PVM pVM, MMTAG enmTag, const char *psz);
|
---|
323 | VMMR3DECL(char *) MMR3HeapStrDupU(PUVM pUVM, MMTAG enmTag, const char *psz);
|
---|
324 | VMMR3DECL(char *) MMR3HeapAPrintf(PVM pVM, MMTAG enmTag, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
|
---|
325 | VMMR3DECL(char *) MMR3HeapAPrintfU(PUVM pUVM, MMTAG enmTag, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
|
---|
326 | VMMR3DECL(char *) MMR3HeapAPrintfV(PVM pVM, MMTAG enmTag, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(3, 0);
|
---|
327 | VMMR3DECL(char *) MMR3HeapAPrintfVU(PUVM pUVM, MMTAG enmTag, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(3, 0);
|
---|
328 | VMMR3DECL(void) MMR3HeapFree(void *pv);
|
---|
329 | /** @} */
|
---|
330 |
|
---|
331 | /** @defgroup grp_mm_ukheap User-kernel Heap Manager.
|
---|
332 | *
|
---|
333 | * The memory is safely accessible from kernel context as well as user land.
|
---|
334 | *
|
---|
335 | * @{ */
|
---|
336 | VMMR3DECL(void *) MMR3UkHeapAlloc(PVM pVM, MMTAG enmTag, size_t cbSize, PRTR0PTR pR0Ptr);
|
---|
337 | VMMR3DECL(int) MMR3UkHeapAllocEx(PVM pVM, MMTAG enmTag, size_t cbSize, void **ppv, PRTR0PTR pR0Ptr);
|
---|
338 | VMMR3DECL(void *) MMR3UkHeapAllocZ(PVM pVM, MMTAG enmTag, size_t cbSize, PRTR0PTR pR0Ptr);
|
---|
339 | VMMR3DECL(int) MMR3UkHeapAllocZEx(PVM pVM, MMTAG enmTag, size_t cbSize, void **ppv, PRTR0PTR pR0Ptr);
|
---|
340 | VMMR3DECL(void) MMR3UkHeapFree(PVM pVM, void *pv, MMTAG enmTag);
|
---|
341 | /** @} */
|
---|
342 |
|
---|
343 | /** @} */
|
---|
344 | #endif /* IN_RING3 || DOXYGEN_RUNNING */
|
---|
345 |
|
---|
346 |
|
---|
347 |
|
---|
348 | #if defined(IN_RC) || defined(DOXYGEN_RUNNING)
|
---|
349 | /** @defgroup grp_mm_rc The MM Raw-mode Context API
|
---|
350 | * @{
|
---|
351 | */
|
---|
352 |
|
---|
353 | VMMRCDECL(void) MMGCRamRegisterTrapHandler(PVM pVM);
|
---|
354 | VMMRCDECL(void) MMGCRamDeregisterTrapHandler(PVM pVM);
|
---|
355 | VMMRCDECL(int) MMGCRamReadNoTrapHandler(void *pDst, void *pSrc, size_t cb);
|
---|
356 | /**
|
---|
357 | * @deprecated Don't use this as it doesn't check the page state.
|
---|
358 | */
|
---|
359 | VMMRCDECL(int) MMGCRamWriteNoTrapHandler(void *pDst, void *pSrc, size_t cb);
|
---|
360 | VMMRCDECL(int) MMGCRamRead(PVM pVM, void *pDst, void *pSrc, size_t cb);
|
---|
361 | VMMRCDECL(int) MMGCRamWrite(PVM pVM, void *pDst, void *pSrc, size_t cb);
|
---|
362 |
|
---|
363 | /** @} */
|
---|
364 | #endif /* IN_RC || DOXYGEN_RUNNING */
|
---|
365 |
|
---|
366 | /** @} */
|
---|
367 | RT_C_DECLS_END
|
---|
368 |
|
---|
369 |
|
---|
370 | #endif
|
---|
371 |
|
---|