VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/MMAll.cpp@ 2128

Last change on this file since 2128 was 1480, checked in by vboxsync, 18 years ago

No longer require contiguous memory for the VM structure.
Did long overdue IOCtl cleanup wrt R3/R0 pointers.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 19.5 KB
Line 
1/* $Id: MMAll.cpp 1480 2007-03-14 18:27:47Z vboxsync $ */
2/** @file
3 * MM - Memory Monitor(/Manager) - Any Context.
4 */
5
6/*
7 * Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_MM_HYPER
27#include <VBox/mm.h>
28#include "MMInternal.h"
29#include <VBox/vm.h>
30#include <VBox/log.h>
31#include <iprt/assert.h>
32
33
34
35/**
36 * Lookup a host context ring-3 address.
37 *
38 * @returns Pointer to the corresponding lookup record.
39 * @returns NULL on failure.
40 * @param pVM The VM handle.
41 * @param R3Ptr The host context ring-3 address to lookup.
42 * @param poff Where to store the offset into the HMA memory chunk.
43 */
44DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupR3(PVM pVM, RTR3PTR R3Ptr, uint32_t *poff)
45{
46 /** @todo cache last lookup this stuff ain't cheap! */
47 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((char*)CTXSUFF(pVM->mm.s.pHyperHeap) + pVM->mm.s.offLookupHyper);
48 for (;;)
49 {
50 switch (pLookup->enmType)
51 {
52 case MMLOOKUPHYPERTYPE_LOCKED:
53 {
54 const uint32_t off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pLookup->u.Locked.pvHC;
55 if (off < pLookup->cb)
56 {
57 *poff = off;
58 return pLookup;
59 }
60 break;
61 }
62
63 case MMLOOKUPHYPERTYPE_HCPHYS:
64 {
65 const uint32_t off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pLookup->u.HCPhys.pvHC;
66 if (off < pLookup->cb)
67 {
68 *poff = off;
69 return pLookup;
70 }
71 break;
72 }
73
74 case MMLOOKUPHYPERTYPE_GCPHYS: /* (for now we'll not allow these kind of conversions) */
75 case MMLOOKUPHYPERTYPE_DYNAMIC:
76 break;
77
78 default:
79 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
80 break;
81 }
82
83 /* next */
84 if (pLookup->offNext == (int32_t)NIL_OFFSET)
85 break;
86 pLookup = (PMMLOOKUPHYPER)((char *)pLookup + pLookup->offNext);
87 }
88
89 AssertMsgFailed(("R3Ptr=%p is not inside the hypervisor memory area!\n", R3Ptr));
90 return NULL;
91}
92
93
94/**
95 * Lookup a host context ring-0 address.
96 *
97 * @returns Pointer to the corresponding lookup record.
98 * @returns NULL on failure.
99 * @param pVM The VM handle.
100 * @param R0Ptr The host context ring-0 address to lookup.
101 * @param poff Where to store the offset into the HMA memory chunk.
102 */
103DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupR0(PVM pVM, RTR0PTR R0Ptr, uint32_t *poff)
104{
105 AssertCompile(sizeof(RTR0PTR) == sizeof(RTR3PTR));
106
107 /*
108 * Translate Ring-0 VM addresses into Ring-3 VM addresses before feeding it to mmHyperLookupR3.
109 */
110 /** @todo fix this properly; the ring 0 pVM address differs from the R3 one. (#1865) */
111 RTR0UINTPTR offVM = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pVM->pVMR0;
112 RTR3PTR R3Ptr = offVM < sizeof(*pVM)
113 ? (RTR3PTR)((RTR3UINTPTR)pVM->pVMR3 + offVM)
114 : (RTR3PTR)R0Ptr;
115
116 return mmHyperLookupR3(pVM, R3Ptr, poff);
117}
118
119
120/**
121 * Lookup a guest context address.
122 *
123 * @returns Pointer to the corresponding lookup record.
124 * @returns NULL on failure.
125 * @param pVM The VM handle.
126 * @param GCPtr The guest context address to lookup.
127 * @param poff Where to store the offset into the HMA memory chunk.
128 */
129DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupGC(PVM pVM, RTGCPTR GCPtr, uint32_t *poff)
130{
131 /** @todo cache last lookup this stuff ain't cheap! */
132 unsigned offGC = (RTGCUINTPTR)GCPtr - (RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC;
133 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((char*)CTXSUFF(pVM->mm.s.pHyperHeap) + pVM->mm.s.offLookupHyper);
134 for (;;)
135 {
136 const uint32_t off = offGC - pLookup->off;
137 if (off < pLookup->cb)
138 {
139 switch (pLookup->enmType)
140 {
141 case MMLOOKUPHYPERTYPE_LOCKED:
142 case MMLOOKUPHYPERTYPE_HCPHYS:
143 *poff = off;
144 return pLookup;
145 default:
146 break;
147 }
148 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
149 return NULL;
150 }
151
152 /* next */
153 if (pLookup->offNext == (int32_t)NIL_OFFSET)
154 break;
155 pLookup = (PMMLOOKUPHYPER)((char *)pLookup + pLookup->offNext);
156 }
157
158 AssertMsgFailed(("GCPtr=%p is not inside the hypervisor memory area!\n", GCPtr));
159 return NULL;
160}
161
162
163/**
164 * Lookup a current context address.
165 *
166 * @returns Pointer to the corresponding lookup record.
167 * @returns NULL on failure.
168 * @param pVM The VM handle.
169 * @param pv The current context address to lookup.
170 * @param poff Where to store the offset into the HMA memory chunk.
171 */
172DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupCC(PVM pVM, void *pv, uint32_t *poff)
173{
174#ifdef IN_GC
175 return mmHyperLookupGC(pVM, pv, poff);
176#elif defined(IN_RING0)
177 return mmHyperLookupR0(pVM, pv, poff);
178#else
179 return mmHyperLookupR3(pVM, pv, poff);
180#endif
181}
182
183
184/**
185 * Calculate the host context ring-3 address of an offset into the HMA memory chunk.
186 *
187 * @returns the host context ring-3 address.
188 * @param pLookup The HMA lookup record.
189 * @param off The offset into the HMA memory chunk.
190 */
191DECLINLINE(RTR3PTR) mmHyperLookupCalcR3(PMMLOOKUPHYPER pLookup, uint32_t off)
192{
193 switch (pLookup->enmType)
194 {
195 case MMLOOKUPHYPERTYPE_LOCKED:
196 return (RTR3PTR)((RTR3UINTPTR)pLookup->u.Locked.pvHC + off);
197 case MMLOOKUPHYPERTYPE_HCPHYS:
198 return (RTR3PTR)((RTR3UINTPTR)pLookup->u.HCPhys.pvHC + off);
199 default:
200 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
201 return NIL_RTR3PTR;
202 }
203}
204
205
206/**
207 * Calculate the host context ring-0 address of an offset into the HMA memory chunk.
208 *
209 * @returns the host context ring-0 address.
210 * @param pLookup The HMA lookup record.
211 * @param off The offset into the HMA memory chunk.
212 */
213DECLINLINE(RTR0PTR) mmHyperLookupCalcR0(PMMLOOKUPHYPER pLookup, uint32_t off)
214{
215 switch (pLookup->enmType)
216 {
217 case MMLOOKUPHYPERTYPE_LOCKED:
218 if (pLookup->u.Locked.pvR0)
219 return (RTR0PTR)((RTR0UINTPTR)pLookup->u.Locked.pvR0 + off);
220 return (RTR0PTR)((RTR3UINTPTR)pLookup->u.Locked.pvHC + off);
221 case MMLOOKUPHYPERTYPE_HCPHYS:
222 return (RTR0PTR)((RTR3UINTPTR)pLookup->u.HCPhys.pvHC + off);
223 default:
224 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
225 return NIL_RTR0PTR;
226 }
227}
228
229
230/**
231 * Calculate the guest context address of an offset into the HMA memory chunk.
232 *
233 * @returns the guest context base address.
234 * @param pVM The the VM handle.
235 * @param pLookup The HMA lookup record.
236 * @param off The offset into the HMA memory chunk.
237 */
238DECLINLINE(RTGCPTR) mmHyperLookupCalcGC(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
239{
240 return (RTGCPTR)((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
241}
242
243
244/**
245 * Calculate the guest context address of an offset into the HMA memory chunk.
246 *
247 * @returns the guest context base address.
248 * @param pVM The the VM handle.
249 * @param pLookup The HMA lookup record.
250 * @param off The offset into the HMA memory chunk.
251 */
252DECLINLINE(void *) mmHyperLookupCalcCC(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
253{
254#ifdef IN_GC
255 return mmHyperLookupCalcGC(pVM, pLookup, off);
256#elif defined(IN_RING0)
257 return mmHyperLookupCalcR0(pLookup, off);
258#else
259 return mmHyperLookupCalcR3(pLookup, off);
260#endif
261}
262
263
264/**
265 * Converts a ring-0 host context address in the Hypervisor memory region to a ring-3 host context address.
266 *
267 * @returns ring-3 host context address.
268 * @param pVM The VM to operate on.
269 * @param R0Ptr The ring-0 host context address.
270 * You'll be damned if this is not in the HMA! :-)
271 * @thread The Emulation Thread.
272 */
273MMDECL(RTR3PTR) MMHyperR0ToR3(PVM pVM, RTR0PTR R0Ptr)
274{
275 uint32_t off;
276 PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
277 if (pLookup)
278 return mmHyperLookupCalcR3(pLookup, off);
279 return NIL_RTR3PTR;
280}
281
282
283/**
284 * Converts a ring-0 host context address in the Hypervisor memory region to a guest context address.
285 *
286 * @returns guest context address.
287 * @param pVM The VM to operate on.
288 * @param R0Ptr The ring-0 host context address.
289 * You'll be damned if this is not in the HMA! :-)
290 * @thread The Emulation Thread.
291 */
292MMDECL(RTGCPTR) MMHyperR0ToGC(PVM pVM, RTR0PTR R0Ptr)
293{
294 uint32_t off;
295 PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
296 if (pLookup)
297 return mmHyperLookupCalcGC(pVM, pLookup, off);
298 return NIL_RTGCPTR;
299}
300
301
302/**
303 * Converts a ring-0 host context address in the Hypervisor memory region to a current context address.
304 *
305 * @returns current context address.
306 * @param pVM The VM to operate on.
307 * @param R0Ptr The ring-0 host context address.
308 * You'll be damned if this is not in the HMA! :-)
309 * @thread The Emulation Thread.
310 */
311#ifndef IN_RING0
312MMDECL(void *) MMHyperR0ToCC(PVM pVM, RTR0PTR R0Ptr)
313{
314 uint32_t off;
315 PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
316 if (pLookup)
317 return mmHyperLookupCalcCC(pVM, pLookup, off);
318 return NULL;
319}
320#endif
321
322
323/**
324 * Converts a ring-3 host context address in the Hypervisor memory region to a ring-0 host context address.
325 *
326 * @returns ring-0 host context address.
327 * @param pVM The VM to operate on.
328 * @param R3Ptr The ring-3 host context address.
329 * You'll be damned if this is not in the HMA! :-)
330 * @thread The Emulation Thread.
331 */
332MMDECL(RTR0PTR) MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr)
333{
334 uint32_t off;
335 PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
336 if (pLookup)
337 return mmHyperLookupCalcR0(pLookup, off);
338 return NIL_RTR0PTR;
339}
340
341
342/**
343 * Converts a ring-3 host context address in the Hypervisor memory region to a guest context address.
344 *
345 * @returns guest context address.
346 * @param pVM The VM to operate on.
347 * @param R3Ptr The ring-3 host context address.
348 * You'll be damned if this is not in the HMA! :-)
349 * @thread The Emulation Thread.
350 */
351MMDECL(RTGCPTR) MMHyperR3ToGC(PVM pVM, RTR3PTR R3Ptr)
352{
353 uint32_t off;
354 PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
355 if (pLookup)
356 return mmHyperLookupCalcGC(pVM, pLookup, off);
357 return NIL_RTGCPTR;
358}
359
360
361/**
362 * Converts a ring-3 host context address in the Hypervisor memory region to a current context address.
363 *
364 * @returns current context address.
365 * @param pVM The VM to operate on.
366 * @param R3Ptr The ring-3 host context address.
367 * You'll be damned if this is not in the HMA! :-)
368 * @thread The Emulation Thread.
369 */
370#ifndef IN_RING3
371MMDECL(void *) MMHyperR3ToCC(PVM pVM, RTR3PTR R3Ptr)
372{
373 uint32_t off;
374 PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
375 if (pLookup)
376 return mmHyperLookupCalcCC(pVM, pLookup, off);
377 return NULL;
378}
379#endif
380
381
382/**
383 * Converts a guest context address in the Hypervisor memory region to a ring-3 context address.
384 *
385 * @returns ring-3 host context address.
386 * @param pVM The VM to operate on.
387 * @param GCPtr The guest context address.
388 * You'll be damned if this is not in the HMA! :-)
389 * @thread The Emulation Thread.
390 */
391MMDECL(RTR3PTR) MMHyperGCToR3(PVM pVM, RTGCPTR GCPtr)
392{
393 uint32_t off;
394 PMMLOOKUPHYPER pLookup = mmHyperLookupGC(pVM, GCPtr, &off);
395 if (pLookup)
396 return mmHyperLookupCalcR3(pLookup, off);
397 return NIL_RTR3PTR;
398}
399
400
401/**
402 * Converts a guest context address in the Hypervisor memory region to a ring-0 host context address.
403 *
404 * @returns ring-0 host context address.
405 * @param pVM The VM to operate on.
406 * @param GCPtr The guest context address.
407 * You'll be damned if this is not in the HMA! :-)
408 * @thread The Emulation Thread.
409 */
410MMDECL(RTR0PTR) MMHyperGCToR0(PVM pVM, RTGCPTR GCPtr)
411{
412 uint32_t off;
413 PMMLOOKUPHYPER pLookup = mmHyperLookupGC(pVM, GCPtr, &off);
414 if (pLookup)
415 return mmHyperLookupCalcR0(pLookup, off);
416 return NIL_RTR0PTR;
417}
418
419
420/**
421 * Converts a guest context address in the Hypervisor memory region to a current context address.
422 *
423 * @returns current context address.
424 * @param pVM The VM to operate on.
425 * @param GCPtr The guest host context address.
426 * You'll be damned if this is not in the HMA! :-)
427 * @thread The Emulation Thread.
428 */
429#ifndef IN_GC
430MMDECL(void *) MMHyperGCToCC(PVM pVM, RTGCPTR GCPtr)
431{
432 uint32_t off;
433 PMMLOOKUPHYPER pLookup = mmHyperLookupGC(pVM, GCPtr, &off);
434 if (pLookup)
435 return mmHyperLookupCalcCC(pVM, pLookup, off);
436 return NULL;
437}
438#endif
439
440
441
442/**
443 * Converts a current context address in the Hypervisor memory region to a ring-3 host context address.
444 *
445 * @returns ring-3 host context address.
446 * @param pVM The VM to operate on.
447 * @param pv The current context address.
448 * You'll be damned if this is not in the HMA! :-)
449 * @thread The Emulation Thread.
450 */
451#ifndef IN_RING3
452MMDECL(RTR3PTR) MMHyperCCToR3(PVM pVM, void *pv)
453{
454 uint32_t off;
455 PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
456 if (pLookup)
457 return mmHyperLookupCalcR3(pLookup, off);
458 return NIL_RTR3PTR;
459}
460#endif
461
462/**
463 * Converts a current context address in the Hypervisor memory region to a ring-0 host context address.
464 *
465 * @returns ring-0 host context address.
466 * @param pVM The VM to operate on.
467 * @param pv The current context address.
468 * You'll be damned if this is not in the HMA! :-)
469 * @thread The Emulation Thread.
470 */
471#ifndef IN_RING0
472MMDECL(RTR0PTR) MMHyperCCToR0(PVM pVM, void *pv)
473{
474 uint32_t off;
475 PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
476 if (pLookup)
477 return mmHyperLookupCalcR0(pLookup, off);
478 return NIL_RTR0PTR;
479}
480#endif
481
482
483/**
484 * Converts a current context address in the Hypervisor memory region to a guest context address.
485 *
486 * @returns guest context address.
487 * @param pVM The VM to operate on.
488 * @param pv The current context address.
489 * You'll be damned if this is not in the HMA! :-)
490 * @thread The Emulation Thread.
491 */
492#ifndef IN_GC
493MMDECL(RTGCPTR) MMHyperCCToGC(PVM pVM, void *pv)
494{
495 uint32_t off;
496 PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
497 if (pLookup)
498 return mmHyperLookupCalcGC(pVM, pLookup, off);
499 return NIL_RTGCPTR;
500}
501#endif
502
503
504
505/**
506 * Converts a HC address in the Hypervisor memory region to a GC address.
507 * The memory must have been allocated with MMGCHyperAlloc() or MMR3HyperAlloc().
508 *
509 * @returns GC address.
510 * @param pVM The VM to operate on.
511 * @param HCPtr The host context address.
512 * You'll be damed if this is not in the hypervisor region! :-)
513 * @deprecated
514 */
515MMDECL(RTGCPTR) MMHyperHC2GC(PVM pVM, RTHCPTR HCPtr)
516{
517 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((char*)CTXSUFF(pVM->mm.s.pHyperHeap) + pVM->mm.s.offLookupHyper);
518 for (;;)
519 {
520 switch (pLookup->enmType)
521 {
522 case MMLOOKUPHYPERTYPE_LOCKED:
523 {
524 unsigned off = (RTHCUINTPTR)HCPtr - (RTHCUINTPTR)pLookup->u.Locked.pvHC;
525 if (off < pLookup->cb)
526 return (RTGCPTR)((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
527 break;
528 }
529
530 case MMLOOKUPHYPERTYPE_HCPHYS:
531 {
532 unsigned off = (RTHCUINTPTR)HCPtr - (RTHCUINTPTR)pLookup->u.HCPhys.pvHC;
533 if (off < pLookup->cb)
534 return (RTGCPTR)((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
535 break;
536 }
537
538 case MMLOOKUPHYPERTYPE_GCPHYS: /* (for now we'll not allow these kind of conversions) */
539 case MMLOOKUPHYPERTYPE_DYNAMIC:
540 break;
541
542 default:
543 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
544 break;
545 }
546
547 /* next */
548 if ((unsigned)pLookup->offNext == NIL_OFFSET)
549 break;
550 pLookup = (PMMLOOKUPHYPER)((char *)pLookup + pLookup->offNext);
551 }
552
553 AssertMsgFailed(("HCPtr=%p is not inside the hypervisor memory area!\n", HCPtr));
554 return (RTGCPTR)0;
555}
556
557
558/**
559 * Converts a GC address in the Hypervisor memory region to a HC address.
560 * The memory must have been allocated with MMHyperAlloc().
561 *
562 * @returns HC address.
563 * @param pVM The VM to operate on.
564 * @param GCPtr The guest context address.
565 * You'll be damed if this is not in the hypervisor region! :-)
566 * @deprecated
567 */
568MMDECL(RTHCPTR) MMHyperGC2HC(PVM pVM, RTGCPTR GCPtr)
569{
570 unsigned offGC = (RTGCUINTPTR)GCPtr - (RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC;
571 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((char*)CTXSUFF(pVM->mm.s.pHyperHeap) + pVM->mm.s.offLookupHyper);
572 for (;;)
573 {
574 unsigned off = offGC - pLookup->off;
575 if (off < pLookup->cb)
576 {
577 switch (pLookup->enmType)
578 {
579 case MMLOOKUPHYPERTYPE_LOCKED:
580 return (RTHCPTR)((RTHCUINTPTR)pLookup->u.Locked.pvHC + off);
581 case MMLOOKUPHYPERTYPE_HCPHYS:
582 return (RTHCPTR)((RTHCUINTPTR)pLookup->u.HCPhys.pvHC + off);
583 default:
584 break;
585 }
586 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
587 return (RTHCPTR)0;
588 }
589
590 /* next */
591 if ((unsigned)pLookup->offNext == NIL_OFFSET)
592 break;
593 pLookup = (PMMLOOKUPHYPER)((char *)pLookup + pLookup->offNext);
594 }
595
596 AssertMsgFailed(("GCPtr=%p is not inside the hypervisor memory area!\n", GCPtr));
597 return (RTHCPTR)0;
598}
599
600
601#ifdef IN_GC
602/**
603 * Converts a current context address in the Hypervisor memory region to a HC address.
604 * The memory must have been allocated with MMGCHyperAlloc() or MMR3HyperAlloc().
605 *
606 * @returns HC address.
607 * @param pVM The VM to operate on.
608 * @param Ptr The current context address.
609 * @deprecated
610 */
611MMDECL(RTHCPTR) MMHyper2HC(PVM pVM, uintptr_t Ptr)
612{
613 return MMHyperGC2HC(pVM, (RTGCPTR)Ptr);
614}
615
616#else /* !IN_GC */
617
618/**
619 * Converts a current context address in the Hypervisor memory region to a GC address.
620 * The memory must have been allocated with MMHyperAlloc().
621 *
622 * @returns HC address.
623 * @param pVM The VM to operate on.
624 * @param Ptr The current context address.
625 * @thread The Emulation Thread.
626 * @deprecated
627 */
628MMDECL(RTGCPTR) MMHyper2GC(PVM pVM, uintptr_t Ptr)
629{
630 return MMHyperHC2GC(pVM, (RTHCPTR)Ptr);
631}
632#endif /* !IN_GC */
633
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