VirtualBox

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

Last change on this file since 91939 was 91939, checked in by vboxsync, 3 years ago

VMM/*: Eliminated MMHyperR3ToRC, TMR3GetImportRC and few other things. bugref:9517
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 17.9 KB
Line 
1/* $Id: MMAll.cpp 91939 2021-10-21 12:43:45Z vboxsync $ */
2/** @file
3 * MM - Memory Manager - Any Context.
4 */
5
6/*
7 * Copyright (C) 2006-2020 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_MM_HYPER
23#include <VBox/vmm/mm.h>
24#include <VBox/vmm/vmm.h>
25#include "MMInternal.h"
26#include <VBox/vmm/vmcc.h>
27#include <VBox/vmm/hm.h>
28#include <VBox/log.h>
29#include <iprt/assert.h>
30#include <iprt/string.h>
31
32
33
34/**
35 * Lookup a host context ring-3 address.
36 *
37 * @returns Pointer to the corresponding lookup record.
38 * @returns NULL on failure.
39 * @param pVM The cross context VM structure.
40 * @param R3Ptr The host context ring-3 address to lookup.
41 * @param poff Where to store the offset into the HMA memory chunk.
42 */
43DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupR3(PVM pVM, RTR3PTR R3Ptr, uint32_t *poff)
44{
45 /** @todo cache last lookup, this stuff ain't cheap! */
46 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);
47 for (;;)
48 {
49 switch (pLookup->enmType)
50 {
51 case MMLOOKUPHYPERTYPE_LOCKED:
52 {
53 const RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pLookup->u.Locked.pvR3;
54 if (off < pLookup->cb)
55 {
56 *poff = off;
57 return pLookup;
58 }
59 break;
60 }
61
62 case MMLOOKUPHYPERTYPE_HCPHYS:
63 {
64 const RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pLookup->u.HCPhys.pvR3;
65 if (off < pLookup->cb)
66 {
67 *poff = off;
68 return pLookup;
69 }
70 break;
71 }
72
73 case MMLOOKUPHYPERTYPE_GCPHYS: /* (for now we'll not allow these kind of conversions) */
74 case MMLOOKUPHYPERTYPE_MMIO2:
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)((uint8_t *)pLookup + pLookup->offNext);
87 }
88
89 AssertMsgFailed(("R3Ptr=%RHv 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 cross context VM structure.
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 /** @todo cache last lookup, this stuff ain't cheap! */
108 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);
109 for (;;)
110 {
111 switch (pLookup->enmType)
112 {
113 case MMLOOKUPHYPERTYPE_LOCKED:
114 {
115 const RTR0UINTPTR off = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pLookup->u.Locked.pvR0;
116 if (off < pLookup->cb && pLookup->u.Locked.pvR0)
117 {
118 *poff = off;
119 return pLookup;
120 }
121 break;
122 }
123
124 case MMLOOKUPHYPERTYPE_HCPHYS:
125 {
126 const RTR0UINTPTR off = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pLookup->u.HCPhys.pvR0;
127 if (off < pLookup->cb && pLookup->u.HCPhys.pvR0)
128 {
129 *poff = off;
130 return pLookup;
131 }
132 break;
133 }
134
135 case MMLOOKUPHYPERTYPE_GCPHYS: /* (for now we'll not allow these kind of conversions) */
136 case MMLOOKUPHYPERTYPE_MMIO2:
137 case MMLOOKUPHYPERTYPE_DYNAMIC:
138 break;
139
140 default:
141 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
142 break;
143 }
144
145 /* next */
146 if (pLookup->offNext == (int32_t)NIL_OFFSET)
147 break;
148 pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
149 }
150
151 AssertMsgFailed(("R0Ptr=%RHv is not inside the hypervisor memory area!\n", R0Ptr));
152 return NULL;
153}
154
155
156/**
157 * Lookup a raw-mode context address.
158 *
159 * @returns Pointer to the corresponding lookup record.
160 * @returns NULL on failure.
161 * @param pVM The cross context VM structure.
162 * @param RCPtr The raw-mode context address to lookup.
163 * @param poff Where to store the offset into the HMA memory chunk.
164 */
165DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupRC(PVM pVM, RTRCPTR RCPtr, uint32_t *poff)
166{
167 /** @todo cache last lookup this stuff ain't cheap! */
168 unsigned offRC = (RTRCUINTPTR)RCPtr - (RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC;
169 PMMLOOKUPHYPER pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);
170 for (;;)
171 {
172 const uint32_t off = offRC - pLookup->off;
173 if (off < pLookup->cb)
174 {
175 switch (pLookup->enmType)
176 {
177 case MMLOOKUPHYPERTYPE_LOCKED:
178 case MMLOOKUPHYPERTYPE_HCPHYS:
179 *poff = off;
180 return pLookup;
181 default:
182 break;
183 }
184 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
185 *poff = 0; /* shut up gcc */
186 return NULL;
187 }
188
189 /* next */
190 if (pLookup->offNext == (int32_t)NIL_OFFSET)
191 break;
192 pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);
193 }
194
195 AssertMsgFailed(("RCPtr=%RRv is not inside the hypervisor memory area!\n", RCPtr));
196 *poff = 0; /* shut up gcc */
197 return NULL;
198}
199
200
201/**
202 * Lookup a current context address.
203 *
204 * @returns Pointer to the corresponding lookup record.
205 * @returns NULL on failure.
206 * @param pVM The cross context VM structure.
207 * @param pv The current context address to lookup.
208 * @param poff Where to store the offset into the HMA memory chunk.
209 */
210DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupCC(PVM pVM, void *pv, uint32_t *poff)
211{
212#ifdef IN_RING0
213 return mmHyperLookupR0(pVM, pv, poff);
214#elif defined(IN_RING3)
215 return mmHyperLookupR3(pVM, pv, poff);
216#else
217# error "Neither IN_RING0 nor IN_RING3!"
218#endif
219}
220
221
222/**
223 * Calculate the host context ring-3 address of an offset into the HMA memory chunk.
224 *
225 * @returns the host context ring-3 address.
226 * @param pLookup The HMA lookup record.
227 * @param off The offset into the HMA memory chunk.
228 */
229DECLINLINE(RTR3PTR) mmHyperLookupCalcR3(PMMLOOKUPHYPER pLookup, uint32_t off)
230{
231 switch (pLookup->enmType)
232 {
233 case MMLOOKUPHYPERTYPE_LOCKED:
234 return (RTR3PTR)((RTR3UINTPTR)pLookup->u.Locked.pvR3 + off);
235 case MMLOOKUPHYPERTYPE_HCPHYS:
236 return (RTR3PTR)((RTR3UINTPTR)pLookup->u.HCPhys.pvR3 + off);
237 default:
238 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
239 return NIL_RTR3PTR;
240 }
241}
242
243
244/**
245 * Calculate the host context ring-0 address of an offset into the HMA memory chunk.
246 *
247 * @returns the host context ring-0 address.
248 * @param pVM The cross context VM structure.
249 * @param pLookup The HMA lookup record.
250 * @param off The offset into the HMA memory chunk.
251 */
252DECLINLINE(RTR0PTR) mmHyperLookupCalcR0(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
253{
254 switch (pLookup->enmType)
255 {
256 case MMLOOKUPHYPERTYPE_LOCKED:
257 if (pLookup->u.Locked.pvR0)
258 return (RTR0PTR)((RTR0UINTPTR)pLookup->u.Locked.pvR0 + off);
259 AssertMsgFailed(("%s\n", R3STRING(pLookup->pszDesc))); NOREF(pVM);
260 return NIL_RTR0PTR;
261
262 case MMLOOKUPHYPERTYPE_HCPHYS:
263 if (pLookup->u.HCPhys.pvR0)
264 return (RTR0PTR)((RTR0UINTPTR)pLookup->u.HCPhys.pvR0 + off);
265 AssertMsgFailed(("%s\n", R3STRING(pLookup->pszDesc)));
266 return NIL_RTR0PTR;
267
268 default:
269 AssertMsgFailed(("enmType=%d\n", pLookup->enmType));
270 return NIL_RTR0PTR;
271 }
272}
273
274
275/**
276 * Calculate the raw-mode context address of an offset into the HMA memory chunk.
277 *
278 * @returns the raw-mode context base address.
279 * @param pVM The cross context VM structure.
280 * @param pLookup The HMA lookup record.
281 * @param off The offset into the HMA memory chunk.
282 */
283DECLINLINE(RTRCPTR) mmHyperLookupCalcRC(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
284{
285 return (RTRCPTR)((RTRCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
286}
287
288
289/**
290 * Calculate the guest context address of an offset into the HMA memory chunk.
291 *
292 * @returns the guest context base address.
293 * @param pVM The cross context VM structure.
294 * @param pLookup The HMA lookup record.
295 * @param off The offset into the HMA memory chunk.
296 */
297DECLINLINE(void *) mmHyperLookupCalcCC(PVM pVM, PMMLOOKUPHYPER pLookup, uint32_t off)
298{
299#ifdef IN_RING0
300 return mmHyperLookupCalcR0(pVM, pLookup, off);
301#elif defined(IN_RING3)
302 NOREF(pVM);
303 return mmHyperLookupCalcR3(pLookup, off);
304#else
305# error "Neither IN_RING0 nor IN_RING3!"
306#endif
307}
308
309
310/**
311 * Converts a ring-0 host context address in the Hypervisor memory region to a ring-3 host context address.
312 *
313 * @returns ring-3 host context address.
314 * @param pVM The cross context VM structure.
315 * @param R0Ptr The ring-0 host context address.
316 * You'll be damned if this is not in the HMA! :-)
317 * @thread The Emulation Thread.
318 */
319VMMDECL(RTR3PTR) MMHyperR0ToR3(PVM pVM, RTR0PTR R0Ptr)
320{
321 uint32_t off;
322 PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
323 if (pLookup)
324 return mmHyperLookupCalcR3(pLookup, off);
325 return NIL_RTR3PTR;
326}
327
328
329#ifndef IN_RING0
330/**
331 * Converts a ring-0 host context address in the Hypervisor memory region to a current context address.
332 *
333 * @returns current context address.
334 * @param pVM The cross context VM structure.
335 * @param R0Ptr The ring-0 host context address.
336 * You'll be damned if this is not in the HMA! :-)
337 * @thread The Emulation Thread.
338 */
339VMMDECL(void *) MMHyperR0ToCC(PVM pVM, RTR0PTR R0Ptr)
340{
341 uint32_t off;
342 PMMLOOKUPHYPER pLookup = mmHyperLookupR0(pVM, R0Ptr, &off);
343 if (pLookup)
344 return mmHyperLookupCalcCC(pVM, pLookup, off);
345 return NULL;
346}
347#endif
348
349
350/**
351 * Converts a ring-3 host context address in the Hypervisor memory region to a ring-0 host context address.
352 *
353 * @returns ring-0 host context address.
354 * @param pVM The cross context VM structure.
355 * @param R3Ptr The ring-3 host context address.
356 * You'll be damned if this is not in the HMA! :-)
357 * @thread The Emulation Thread.
358 */
359VMMDECL(RTR0PTR) MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr)
360{
361 uint32_t off;
362 PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
363 if (pLookup)
364 return mmHyperLookupCalcR0(pVM, pLookup, off);
365 AssertMsgFailed(("R3Ptr=%p is not inside the hypervisor memory area!\n", R3Ptr));
366 return NIL_RTR0PTR;
367}
368
369
370#ifndef IN_RING3
371/**
372 * Converts a ring-3 host context address in the Hypervisor memory region to a current context address.
373 *
374 * @returns current context address.
375 * @param pVM The cross context VM structure.
376 * @param R3Ptr The ring-3 host context address.
377 * You'll be damned if this is not in the HMA! :-)
378 * @thread The Emulation Thread.
379 */
380VMMDECL(void *) MMHyperR3ToCC(PVM pVM, RTR3PTR R3Ptr)
381{
382 uint32_t off;
383 PMMLOOKUPHYPER pLookup = mmHyperLookupR3(pVM, R3Ptr, &off);
384 if (pLookup)
385 return mmHyperLookupCalcCC(pVM, pLookup, off);
386 return NULL;
387}
388#endif
389
390
391/**
392 * Converts a raw-mode context address in the Hypervisor memory region to a ring-3 context address.
393 *
394 * @returns ring-3 host context address.
395 * @param pVM The cross context VM structure.
396 * @param RCPtr The raw-mode context address.
397 * You'll be damned if this is not in the HMA! :-)
398 * @thread The Emulation Thread.
399 */
400VMMDECL(RTR3PTR) MMHyperRCToR3(PVM pVM, RTRCPTR RCPtr)
401{
402 uint32_t off;
403 PMMLOOKUPHYPER pLookup = mmHyperLookupRC(pVM, RCPtr, &off);
404 if (pLookup)
405 return mmHyperLookupCalcR3(pLookup, off);
406 return NIL_RTR3PTR;
407}
408
409
410/**
411 * Converts a raw-mode context address in the Hypervisor memory region to a ring-0 host context address.
412 *
413 * @returns ring-0 host context address.
414 * @param pVM The cross context VM structure.
415 * @param RCPtr The raw-mode context address.
416 * You'll be damned if this is not in the HMA! :-)
417 * @thread The Emulation Thread.
418 */
419VMMDECL(RTR0PTR) MMHyperRCToR0(PVM pVM, RTRCPTR RCPtr)
420{
421 uint32_t off;
422 PMMLOOKUPHYPER pLookup = mmHyperLookupRC(pVM, RCPtr, &off);
423 if (pLookup)
424 return mmHyperLookupCalcR0(pVM, pLookup, off);
425 return NIL_RTR0PTR;
426}
427
428
429/**
430 * Converts a raw-mode context address in the Hypervisor memory region to a current context address.
431 *
432 * @returns current context address.
433 * @param pVM The cross context VM structure.
434 * @param RCPtr The raw-mode host context address.
435 * You'll be damned if this is not in the HMA! :-)
436 * @thread The Emulation Thread.
437 */
438VMMDECL(void *) MMHyperRCToCC(PVM pVM, RTRCPTR RCPtr)
439{
440 uint32_t off;
441 PMMLOOKUPHYPER pLookup = mmHyperLookupRC(pVM, RCPtr, &off);
442 if (pLookup)
443 return mmHyperLookupCalcCC(pVM, pLookup, off);
444 return NULL;
445}
446
447
448#ifndef IN_RING3
449/**
450 * Converts a current context address in the Hypervisor memory region to a ring-3 host context address.
451 *
452 * @returns ring-3 host context address.
453 * @param pVM The cross context VM structure.
454 * @param pv The current context address.
455 * You'll be damned if this is not in the HMA! :-)
456 * @thread The Emulation Thread.
457 */
458VMMDECL(RTR3PTR) MMHyperCCToR3(PVM pVM, void *pv)
459{
460 uint32_t off;
461 PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
462 if (pLookup)
463 return mmHyperLookupCalcR3(pLookup, off);
464 return NIL_RTR3PTR;
465}
466#endif
467
468#ifndef IN_RING0
469/**
470 * Converts a current context address in the Hypervisor memory region to a ring-0 host context address.
471 *
472 * @returns ring-0 host context address.
473 * @param pVM The cross context VM structure.
474 * @param pv The current context address.
475 * You'll be damned if this is not in the HMA! :-)
476 * @thread The Emulation Thread.
477 */
478VMMDECL(RTR0PTR) MMHyperCCToR0(PVM pVM, void *pv)
479{
480 uint32_t off;
481 PMMLOOKUPHYPER pLookup = mmHyperLookupCC(pVM, pv, &off);
482 if (pLookup)
483 return mmHyperLookupCalcR0(pVM, pLookup, off);
484 return NIL_RTR0PTR;
485}
486#endif
487
488
489/**
490 * Gets the string name of a memory tag.
491 *
492 * @returns name of enmTag.
493 * @param enmTag The tag.
494 */
495const char *mmGetTagName(MMTAG enmTag)
496{
497 switch (enmTag)
498 {
499 #define TAG2STR(tag) case MM_TAG_##tag: return #tag
500
501 TAG2STR(CFGM);
502 TAG2STR(CFGM_BYTES);
503 TAG2STR(CFGM_STRING);
504 TAG2STR(CFGM_USER);
505
506 TAG2STR(CPUM_CTX);
507 TAG2STR(CPUM_CPUID);
508 TAG2STR(CPUM_MSRS);
509
510 TAG2STR(CSAM);
511 TAG2STR(CSAM_PATCH);
512
513 TAG2STR(DBGF);
514 TAG2STR(DBGF_AS);
515 TAG2STR(DBGF_FLOWTRACE);
516 TAG2STR(DBGF_INFO);
517 TAG2STR(DBGF_LINE);
518 TAG2STR(DBGF_LINE_DUP);
519 TAG2STR(DBGF_MODULE);
520 TAG2STR(DBGF_OS);
521 TAG2STR(DBGF_REG);
522 TAG2STR(DBGF_STACK);
523 TAG2STR(DBGF_SYMBOL);
524 TAG2STR(DBGF_SYMBOL_DUP);
525 TAG2STR(DBGF_TYPE);
526 TAG2STR(DBGF_TRACER);
527
528 TAG2STR(EM);
529
530 TAG2STR(IEM);
531
532 TAG2STR(IOM);
533 TAG2STR(IOM_STATS);
534
535 TAG2STR(MM);
536 TAG2STR(MM_LOOKUP_GUEST);
537 TAG2STR(MM_LOOKUP_PHYS);
538 TAG2STR(MM_LOOKUP_VIRT);
539 TAG2STR(MM_PAGE);
540
541 TAG2STR(PARAV);
542
543 TAG2STR(PATM);
544 TAG2STR(PATM_PATCH);
545
546 TAG2STR(PDM);
547 TAG2STR(PDM_DEVICE);
548 TAG2STR(PDM_DEVICE_DESC);
549 TAG2STR(PDM_DEVICE_USER);
550 TAG2STR(PDM_DRIVER);
551 TAG2STR(PDM_DRIVER_DESC);
552 TAG2STR(PDM_DRIVER_USER);
553 TAG2STR(PDM_USB);
554 TAG2STR(PDM_USB_DESC);
555 TAG2STR(PDM_USB_USER);
556 TAG2STR(PDM_LUN);
557 TAG2STR(PDM_QUEUE);
558 TAG2STR(PDM_THREAD);
559 TAG2STR(PDM_ASYNC_COMPLETION);
560#ifdef VBOX_WITH_NETSHAPER
561 TAG2STR(PDM_NET_SHAPER);
562#endif /* VBOX_WITH_NETSHAPER */
563
564 TAG2STR(PGM);
565 TAG2STR(PGM_CHUNK_MAPPING);
566 TAG2STR(PGM_HANDLERS);
567 TAG2STR(PGM_HANDLER_TYPES);
568 TAG2STR(PGM_MAPPINGS);
569 TAG2STR(PGM_PHYS);
570 TAG2STR(PGM_POOL);
571
572 TAG2STR(REM);
573
574 TAG2STR(SELM);
575
576 TAG2STR(SSM);
577
578 TAG2STR(STAM);
579
580 TAG2STR(TM);
581
582 TAG2STR(TRPM);
583
584 TAG2STR(VM);
585 TAG2STR(VM_REQ);
586
587 TAG2STR(VMM);
588
589 TAG2STR(HM);
590
591 #undef TAG2STR
592
593 default:
594 {
595 AssertMsgFailed(("Unknown tag %d! forgot to add it to the switch?\n", enmTag));
596#ifdef IN_RING3
597 static char sz[48];
598 RTStrPrintf(sz, sizeof(sz), "%d", enmTag);
599 return sz;
600#else
601 return "unknown tag!";
602#endif
603 }
604 }
605}
606
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