VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMSwitcher.cpp@ 15653

Last change on this file since 15653 was 15414, checked in by vboxsync, 16 years ago

Corrected VBOX_WITH_HYBIRD_32BIT_KERNEL to VBOX_WITH_HYBRID_32BIT_KERNEL and moved it into src/VBox/VMM.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 37.1 KB
Line 
1/* $Id: VMMSwitcher.cpp 15414 2008-12-13 04:33:30Z vboxsync $ */
2/** @file
3 * VMM - The Virtual Machine Monitor, World Switcher(s).
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22/*******************************************************************************
23* Header Files *
24*******************************************************************************/
25#define LOG_GROUP LOG_GROUP_VMM
26#include <VBox/vmm.h>
27#include <VBox/pgm.h>
28#include <VBox/selm.h>
29#include <VBox/mm.h>
30#include <VBox/sup.h>
31#include "VMMInternal.h"
32#include "VMMSwitcher/VMMSwitcher.h"
33#include <VBox/vm.h>
34#include <VBox/dis.h>
35
36#include <VBox/err.h>
37#include <VBox/param.h>
38#include <iprt/assert.h>
39#include <iprt/alloc.h>
40#include <iprt/asm.h>
41#include <iprt/string.h>
42#include <iprt/ctype.h>
43
44
45/*******************************************************************************
46* Global Variables *
47*******************************************************************************/
48/** Array of switcher defininitions.
49 * The type and index shall match!
50 */
51static PVMMSWITCHERDEF s_apSwitchers[VMMSWITCHER_MAX] =
52{
53 NULL, /* invalid entry */
54#ifndef RT_ARCH_AMD64
55 &vmmR3Switcher32BitTo32Bit_Def,
56 &vmmR3Switcher32BitToPAE_Def,
57 &vmmR3Switcher32BitToAMD64_Def,
58 &vmmR3SwitcherPAETo32Bit_Def,
59 &vmmR3SwitcherPAEToPAE_Def,
60 &vmmR3SwitcherPAEToAMD64_Def,
61 NULL, //&vmmR3SwitcherPAETo32Bit_Def,
62# ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
63 &vmmR3SwitcherAMD64ToPAE_Def,
64# else
65 NULL, //&vmmR3SwitcherAMD64ToPAE_Def,
66# endif
67 NULL //&vmmR3SwitcherAMD64ToAMD64_Def,
68#else /* RT_ARCH_AMD64 */
69 NULL, //&vmmR3Switcher32BitTo32Bit_Def,
70 NULL, //&vmmR3Switcher32BitToPAE_Def,
71 NULL, //&vmmR3Switcher32BitToAMD64_Def,
72 NULL, //&vmmR3SwitcherPAETo32Bit_Def,
73 NULL, //&vmmR3SwitcherPAEToPAE_Def,
74 NULL, //&vmmR3SwitcherPAEToAMD64_Def,
75 &vmmR3SwitcherAMD64To32Bit_Def,
76 &vmmR3SwitcherAMD64ToPAE_Def,
77 NULL //&vmmR3SwitcherAMD64ToAMD64_Def,
78#endif /* RT_ARCH_AMD64 */
79};
80
81
82/**
83 * VMMR3Init worker that initiates the switcher code (aka core code).
84 *
85 * This is core per VM code which might need fixups and/or for ease of use are
86 * put on linear contiguous backing.
87 *
88 * @returns VBox status code.
89 * @param pVM Pointer to the shared VM structure.
90 */
91int vmmR3SwitcherInit(PVM pVM)
92{
93 /*
94 * Calc the size.
95 */
96 unsigned cbCoreCode = 0;
97 for (unsigned iSwitcher = 0; iSwitcher < RT_ELEMENTS(s_apSwitchers); iSwitcher++)
98 {
99 pVM->vmm.s.aoffSwitchers[iSwitcher] = cbCoreCode;
100 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
101 if (pSwitcher)
102 {
103 AssertRelease((unsigned)pSwitcher->enmType == iSwitcher);
104 cbCoreCode += RT_ALIGN_32(pSwitcher->cbCode + 1, 32);
105 }
106 }
107
108 /*
109 * Allocate continguous pages for switchers and deal with
110 * conflicts in the intermediate mapping of the code.
111 */
112 pVM->vmm.s.cbCoreCode = RT_ALIGN_32(cbCoreCode, PAGE_SIZE);
113 pVM->vmm.s.pvCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
114 int rc = VERR_NO_MEMORY;
115 if (pVM->vmm.s.pvCoreCodeR3)
116 {
117 rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
118 if (rc == VERR_PGM_INTERMEDIATE_PAGING_CONFLICT)
119 {
120 /* try more allocations - Solaris, Linux. */
121 const unsigned cTries = 8234;
122 struct VMMInitBadTry
123 {
124 RTR0PTR pvR0;
125 void *pvR3;
126 RTHCPHYS HCPhys;
127 RTUINT cb;
128 } *paBadTries = (struct VMMInitBadTry *)RTMemTmpAlloc(sizeof(*paBadTries) * cTries);
129 AssertReturn(paBadTries, VERR_NO_TMP_MEMORY);
130 unsigned i = 0;
131 do
132 {
133 paBadTries[i].pvR3 = pVM->vmm.s.pvCoreCodeR3;
134 paBadTries[i].pvR0 = pVM->vmm.s.pvCoreCodeR0;
135 paBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
136 i++;
137 pVM->vmm.s.pvCoreCodeR0 = NIL_RTR0PTR;
138 pVM->vmm.s.HCPhysCoreCode = NIL_RTHCPHYS;
139 pVM->vmm.s.pvCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
140 if (!pVM->vmm.s.pvCoreCodeR3)
141 break;
142 rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
143 } while ( rc == VERR_PGM_INTERMEDIATE_PAGING_CONFLICT
144 && i < cTries - 1);
145
146 /* cleanup */
147 if (RT_FAILURE(rc))
148 {
149 paBadTries[i].pvR3 = pVM->vmm.s.pvCoreCodeR3;
150 paBadTries[i].pvR0 = pVM->vmm.s.pvCoreCodeR0;
151 paBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
152 paBadTries[i].cb = pVM->vmm.s.cbCoreCode;
153 i++;
154 LogRel(("Failed to allocated and map core code: rc=%Rrc\n", rc));
155 }
156 while (i-- > 0)
157 {
158 LogRel(("Core code alloc attempt #%d: pvR3=%p pvR0=%p HCPhys=%RHp\n",
159 i, paBadTries[i].pvR3, paBadTries[i].pvR0, paBadTries[i].HCPhys));
160 SUPContFree(paBadTries[i].pvR3, paBadTries[i].cb >> PAGE_SHIFT);
161 }
162 RTMemTmpFree(paBadTries);
163 }
164 }
165 if (RT_SUCCESS(rc))
166 {
167 /*
168 * copy the code.
169 */
170 for (unsigned iSwitcher = 0; iSwitcher < RT_ELEMENTS(s_apSwitchers); iSwitcher++)
171 {
172 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
173 if (pSwitcher)
174 memcpy((uint8_t *)pVM->vmm.s.pvCoreCodeR3 + pVM->vmm.s.aoffSwitchers[iSwitcher],
175 pSwitcher->pvCode, pSwitcher->cbCode);
176 }
177
178 /*
179 * Map the code into the GC address space.
180 */
181 RTGCPTR GCPtr;
182 rc = MMR3HyperMapHCPhys(pVM, pVM->vmm.s.pvCoreCodeR3, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.HCPhysCoreCode,
183 cbCoreCode, "Core Code", &GCPtr);
184 if (RT_SUCCESS(rc))
185 {
186 pVM->vmm.s.pvCoreCodeRC = GCPtr;
187 MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
188 LogRel(("CoreCode: R3=%RHv R0=%RHv RC=%RRv Phys=%RHp cb=%#x\n",
189 pVM->vmm.s.pvCoreCodeR3, pVM->vmm.s.pvCoreCodeR0, pVM->vmm.s.pvCoreCodeRC, pVM->vmm.s.HCPhysCoreCode, pVM->vmm.s.cbCoreCode));
190
191 /*
192 * Finally, PGM probably has selected a switcher already but we need
193 * to get the routine addresses, so we'll reselect it.
194 * This may legally fail so, we're ignoring the rc.
195 */
196 VMMR3SelectSwitcher(pVM, pVM->vmm.s.enmSwitcher);
197 return rc;
198 }
199
200 /* shit */
201 AssertMsgFailed(("PGMR3Map(,%RRv, %RHp, %#x, 0) failed with rc=%Rrc\n", pVM->vmm.s.pvCoreCodeRC, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, rc));
202 SUPContFree(pVM->vmm.s.pvCoreCodeR3, pVM->vmm.s.cbCoreCode >> PAGE_SHIFT);
203 }
204 else
205 VMSetError(pVM, rc, RT_SRC_POS,
206 N_("Failed to allocate %d bytes of contiguous memory for the world switcher code"),
207 cbCoreCode);
208
209 pVM->vmm.s.pvCoreCodeR3 = NULL;
210 pVM->vmm.s.pvCoreCodeR0 = NIL_RTR0PTR;
211 pVM->vmm.s.pvCoreCodeRC = 0;
212 return rc;
213}
214
215/**
216 * Relocate the switchers, called by VMMR#Relocate.
217 *
218 * @param pVM Pointer to the shared VM structure.
219 * @param offDelta The relocation delta.
220 */
221void vmmR3SwitcherRelocate(PVM pVM, RTGCINTPTR offDelta)
222{
223 /*
224 * Relocate all the switchers.
225 */
226 for (unsigned iSwitcher = 0; iSwitcher < RT_ELEMENTS(s_apSwitchers); iSwitcher++)
227 {
228 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
229 if (pSwitcher && pSwitcher->pfnRelocate)
230 {
231 unsigned off = pVM->vmm.s.aoffSwitchers[iSwitcher];
232 pSwitcher->pfnRelocate(pVM,
233 pSwitcher,
234 pVM->vmm.s.pvCoreCodeR0 + off,
235 (uint8_t *)pVM->vmm.s.pvCoreCodeR3 + off,
236 pVM->vmm.s.pvCoreCodeRC + off,
237 pVM->vmm.s.HCPhysCoreCode + off);
238 }
239 }
240
241 /*
242 * Recalc the RC address for the current switcher.
243 */
244 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[pVM->vmm.s.enmSwitcher];
245 RTRCPTR RCPtr = pVM->vmm.s.pvCoreCodeRC + pVM->vmm.s.aoffSwitchers[pVM->vmm.s.enmSwitcher];
246 pVM->vmm.s.pfnGuestToHostRC = RCPtr + pSwitcher->offGCGuestToHost;
247 pVM->vmm.s.pfnCallTrampolineRC = RCPtr + pSwitcher->offGCCallTrampoline;
248 pVM->pfnVMMGCGuestToHostAsm = RCPtr + pSwitcher->offGCGuestToHostAsm;
249 pVM->pfnVMMGCGuestToHostAsmHyperCtx = RCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
250 pVM->pfnVMMGCGuestToHostAsmGuestCtx = RCPtr + pSwitcher->offGCGuestToHostAsmGuestCtx;
251
252// AssertFailed();
253}
254
255
256/**
257 * Generic switcher code relocator.
258 *
259 * @param pVM The VM handle.
260 * @param pSwitcher The switcher definition.
261 * @param pu8CodeR3 Pointer to the core code block for the switcher, ring-3 mapping.
262 * @param R0PtrCode Pointer to the core code block for the switcher, ring-0 mapping.
263 * @param GCPtrCode The guest context address corresponding to pu8Code.
264 * @param u32IDCode The identity mapped (ID) address corresponding to pu8Code.
265 * @param SelCS The hypervisor CS selector.
266 * @param SelDS The hypervisor DS selector.
267 * @param SelTSS The hypervisor TSS selector.
268 * @param GCPtrGDT The GC address of the hypervisor GDT.
269 * @param SelCS64 The 64-bit mode hypervisor CS selector.
270 */
271static void vmmR3SwitcherGenericRelocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode,
272 RTSEL SelCS, RTSEL SelDS, RTSEL SelTSS, RTGCPTR GCPtrGDT, RTSEL SelCS64)
273{
274 union
275 {
276 const uint8_t *pu8;
277 const uint16_t *pu16;
278 const uint32_t *pu32;
279 const uint64_t *pu64;
280 const void *pv;
281 uintptr_t u;
282 } u;
283 u.pv = pSwitcher->pvFixups;
284
285 /*
286 * Process fixups.
287 */
288 uint8_t u8;
289 while ((u8 = *u.pu8++) != FIX_THE_END)
290 {
291 /*
292 * Get the source (where to write the fixup).
293 */
294 uint32_t offSrc = *u.pu32++;
295 Assert(offSrc < pSwitcher->cbCode);
296 union
297 {
298 uint8_t *pu8;
299 uint16_t *pu16;
300 uint32_t *pu32;
301 uint64_t *pu64;
302 uintptr_t u;
303 } uSrc;
304 uSrc.pu8 = pu8CodeR3 + offSrc;
305
306 /* The fixup target and method depends on the type. */
307 switch (u8)
308 {
309 /*
310 * 32-bit relative, source in HC and target in GC.
311 */
312 case FIX_HC_2_GC_NEAR_REL:
313 {
314 Assert(offSrc - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offSrc - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
315 uint32_t offTrg = *u.pu32++;
316 Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
317 *uSrc.pu32 = (uint32_t)((GCPtrCode + offTrg) - (uSrc.u + 4));
318 break;
319 }
320
321 /*
322 * 32-bit relative, source in HC and target in ID.
323 */
324 case FIX_HC_2_ID_NEAR_REL:
325 {
326 Assert(offSrc - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offSrc - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
327 uint32_t offTrg = *u.pu32++;
328 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
329 *uSrc.pu32 = (uint32_t)((u32IDCode + offTrg) - (R0PtrCode + offSrc + 4));
330 break;
331 }
332
333 /*
334 * 32-bit relative, source in GC and target in HC.
335 */
336 case FIX_GC_2_HC_NEAR_REL:
337 {
338 Assert(offSrc - pSwitcher->offGCCode < pSwitcher->cbGCCode);
339 uint32_t offTrg = *u.pu32++;
340 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
341 *uSrc.pu32 = (uint32_t)((R0PtrCode + offTrg) - (GCPtrCode + offSrc + 4));
342 break;
343 }
344
345 /*
346 * 32-bit relative, source in GC and target in ID.
347 */
348 case FIX_GC_2_ID_NEAR_REL:
349 {
350 AssertMsg(offSrc - pSwitcher->offGCCode < pSwitcher->cbGCCode, ("%x - %x < %x\n", offSrc, pSwitcher->offGCCode, pSwitcher->cbGCCode));
351 uint32_t offTrg = *u.pu32++;
352 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
353 *uSrc.pu32 = (uint32_t)((u32IDCode + offTrg) - (GCPtrCode + offSrc + 4));
354 break;
355 }
356
357 /*
358 * 32-bit relative, source in ID and target in HC.
359 */
360 case FIX_ID_2_HC_NEAR_REL:
361 {
362 Assert(offSrc - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offSrc - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
363 uint32_t offTrg = *u.pu32++;
364 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
365 *uSrc.pu32 = (uint32_t)((R0PtrCode + offTrg) - (u32IDCode + offSrc + 4));
366 break;
367 }
368
369 /*
370 * 32-bit relative, source in ID and target in HC.
371 */
372 case FIX_ID_2_GC_NEAR_REL:
373 {
374 Assert(offSrc - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offSrc - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
375 uint32_t offTrg = *u.pu32++;
376 Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
377 *uSrc.pu32 = (uint32_t)((GCPtrCode + offTrg) - (u32IDCode + offSrc + 4));
378 break;
379 }
380
381 /*
382 * 16:32 far jump, target in GC.
383 */
384 case FIX_GC_FAR32:
385 {
386 uint32_t offTrg = *u.pu32++;
387 Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
388 *uSrc.pu32++ = (uint32_t)(GCPtrCode + offTrg);
389 *uSrc.pu16++ = SelCS;
390 break;
391 }
392
393 /*
394 * Make 32-bit GC pointer given CPUM offset.
395 */
396 case FIX_GC_CPUM_OFF:
397 {
398 uint32_t offCPUM = *u.pu32++;
399 Assert(offCPUM < sizeof(pVM->cpum));
400 *uSrc.pu32 = (uint32_t)(VM_RC_ADDR(pVM, &pVM->cpum) + offCPUM);
401 break;
402 }
403
404 /*
405 * Make 32-bit GC pointer given VM offset.
406 */
407 case FIX_GC_VM_OFF:
408 {
409 uint32_t offVM = *u.pu32++;
410 Assert(offVM < sizeof(VM));
411 *uSrc.pu32 = (uint32_t)(VM_RC_ADDR(pVM, pVM) + offVM);
412 break;
413 }
414
415 /*
416 * Make 32-bit HC pointer given CPUM offset.
417 */
418 case FIX_HC_CPUM_OFF:
419 {
420 uint32_t offCPUM = *u.pu32++;
421 Assert(offCPUM < sizeof(pVM->cpum));
422 *uSrc.pu32 = (uint32_t)pVM->pVMR0 + RT_OFFSETOF(VM, cpum) + offCPUM;
423 break;
424 }
425
426 /*
427 * Make 32-bit R0 pointer given VM offset.
428 */
429 case FIX_HC_VM_OFF:
430 {
431 uint32_t offVM = *u.pu32++;
432 Assert(offVM < sizeof(VM));
433 *uSrc.pu32 = (uint32_t)pVM->pVMR0 + offVM;
434 break;
435 }
436
437 /*
438 * Store the 32-Bit CR3 (32-bit) for the intermediate memory context.
439 */
440 case FIX_INTER_32BIT_CR3:
441 {
442
443 *uSrc.pu32 = PGMGetInter32BitCR3(pVM);
444 break;
445 }
446
447 /*
448 * Store the PAE CR3 (32-bit) for the intermediate memory context.
449 */
450 case FIX_INTER_PAE_CR3:
451 {
452
453 *uSrc.pu32 = PGMGetInterPaeCR3(pVM);
454 break;
455 }
456
457 /*
458 * Store the AMD64 CR3 (32-bit) for the intermediate memory context.
459 */
460 case FIX_INTER_AMD64_CR3:
461 {
462
463 *uSrc.pu32 = PGMGetInterAmd64CR3(pVM);
464 break;
465 }
466
467 /*
468 * Store the 32-Bit CR3 (32-bit) for the hypervisor (shadow) memory context.
469 */
470 case FIX_HYPER_32BIT_CR3:
471 {
472
473 *uSrc.pu32 = PGMGetHyper32BitCR3(pVM);
474 break;
475 }
476
477 /*
478 * Store the PAE CR3 (32-bit) for the hypervisor (shadow) memory context.
479 */
480 case FIX_HYPER_PAE_CR3:
481 {
482
483 *uSrc.pu32 = PGMGetHyperPaeCR3(pVM);
484 break;
485 }
486
487 /*
488 * Store the AMD64 CR3 (32-bit) for the hypervisor (shadow) memory context.
489 */
490 case FIX_HYPER_AMD64_CR3:
491 {
492
493 *uSrc.pu32 = PGMGetHyperAmd64CR3(pVM);
494 break;
495 }
496
497 /*
498 * Store Hypervisor CS (16-bit).
499 */
500 case FIX_HYPER_CS:
501 {
502 *uSrc.pu16 = SelCS;
503 break;
504 }
505
506 /*
507 * Store Hypervisor DS (16-bit).
508 */
509 case FIX_HYPER_DS:
510 {
511 *uSrc.pu16 = SelDS;
512 break;
513 }
514
515 /*
516 * Store Hypervisor TSS (16-bit).
517 */
518 case FIX_HYPER_TSS:
519 {
520 *uSrc.pu16 = SelTSS;
521 break;
522 }
523
524 /*
525 * Store the 32-bit GC address of the 2nd dword of the TSS descriptor (in the GDT).
526 */
527 case FIX_GC_TSS_GDTE_DW2:
528 {
529 RTGCPTR GCPtr = GCPtrGDT + (SelTSS & ~7) + 4;
530 *uSrc.pu32 = (uint32_t)GCPtr;
531 break;
532 }
533
534
535 ///@todo case FIX_CR4_MASK:
536 ///@todo case FIX_CR4_OSFSXR:
537
538 /*
539 * Insert relative jump to specified target it FXSAVE/FXRSTOR isn't supported by the cpu.
540 */
541 case FIX_NO_FXSAVE_JMP:
542 {
543 uint32_t offTrg = *u.pu32++;
544 Assert(offTrg < pSwitcher->cbCode);
545 if (!CPUMSupportsFXSR(pVM))
546 {
547 *uSrc.pu8++ = 0xe9; /* jmp rel32 */
548 *uSrc.pu32++ = offTrg - (offSrc + 5);
549 }
550 else
551 {
552 *uSrc.pu8++ = *((uint8_t *)pSwitcher->pvCode + offSrc);
553 *uSrc.pu32++ = *(uint32_t *)((uint8_t *)pSwitcher->pvCode + offSrc + 1);
554 }
555 break;
556 }
557
558 /*
559 * Insert relative jump to specified target it SYSENTER isn't used by the host.
560 */
561 case FIX_NO_SYSENTER_JMP:
562 {
563 uint32_t offTrg = *u.pu32++;
564 Assert(offTrg < pSwitcher->cbCode);
565 if (!CPUMIsHostUsingSysEnter(pVM))
566 {
567 *uSrc.pu8++ = 0xe9; /* jmp rel32 */
568 *uSrc.pu32++ = offTrg - (offSrc + 5);
569 }
570 else
571 {
572 *uSrc.pu8++ = *((uint8_t *)pSwitcher->pvCode + offSrc);
573 *uSrc.pu32++ = *(uint32_t *)((uint8_t *)pSwitcher->pvCode + offSrc + 1);
574 }
575 break;
576 }
577
578 /*
579 * Insert relative jump to specified target it SYSENTER isn't used by the host.
580 */
581 case FIX_NO_SYSCALL_JMP:
582 {
583 uint32_t offTrg = *u.pu32++;
584 Assert(offTrg < pSwitcher->cbCode);
585 if (!CPUMIsHostUsingSysEnter(pVM))
586 {
587 *uSrc.pu8++ = 0xe9; /* jmp rel32 */
588 *uSrc.pu32++ = offTrg - (offSrc + 5);
589 }
590 else
591 {
592 *uSrc.pu8++ = *((uint8_t *)pSwitcher->pvCode + offSrc);
593 *uSrc.pu32++ = *(uint32_t *)((uint8_t *)pSwitcher->pvCode + offSrc + 1);
594 }
595 break;
596 }
597
598 /*
599 * 32-bit HC pointer fixup to (HC) target within the code (32-bit offset).
600 */
601 case FIX_HC_32BIT:
602 {
603 uint32_t offTrg = *u.pu32++;
604 Assert(offSrc < pSwitcher->cbCode);
605 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
606 *uSrc.pu32 = R0PtrCode + offTrg;
607 break;
608 }
609
610#if defined(RT_ARCH_AMD64) || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
611 /*
612 * 64-bit HC Code Selector (no argument).
613 */
614 case FIX_HC_64BIT_CS:
615 {
616 Assert(offSrc < pSwitcher->cbCode);
617# if defined(RT_OS_DARWIN) && defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
618 *uSrc.pu16 = 0x80; /* KERNEL64_CS from i386/seg.h */
619# else
620 AssertFatalMsgFailed(("FIX_HC_64BIT_CS not implemented for this host\n"));
621# endif
622 break;
623 }
624
625 /*
626 * 64-bit HC pointer to the CPUM instance data (no argument).
627 */
628 case FIX_HC_64BIT_CPUM:
629 {
630 Assert(offSrc < pSwitcher->cbCode);
631 *uSrc.pu64 = pVM->pVMR0 + RT_OFFSETOF(VM, cpum);
632 break;
633 }
634#endif
635 /*
636 * 64-bit HC pointer fixup to (HC) target within the code (32-bit offset).
637 */
638 case FIX_HC_64BIT:
639 {
640 uint32_t offTrg = *u.pu32++;
641 Assert(offSrc < pSwitcher->cbCode);
642 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
643 *uSrc.pu64 = R0PtrCode + offTrg;
644 break;
645 }
646
647#ifdef RT_ARCH_X86
648 case FIX_GC_64_BIT_CPUM_OFF:
649 {
650 uint32_t offCPUM = *u.pu32++;
651 Assert(offCPUM < sizeof(pVM->cpum));
652 *uSrc.pu64 = (uint32_t)(VM_RC_ADDR(pVM, &pVM->cpum) + offCPUM);
653 break;
654 }
655#endif
656
657 /*
658 * 32-bit ID pointer to (ID) target within the code (32-bit offset).
659 */
660 case FIX_ID_32BIT:
661 {
662 uint32_t offTrg = *u.pu32++;
663 Assert(offSrc < pSwitcher->cbCode);
664 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
665 *uSrc.pu32 = u32IDCode + offTrg;
666 break;
667 }
668
669 /*
670 * 64-bit ID pointer to (ID) target within the code (32-bit offset).
671 */
672 case FIX_ID_64BIT:
673 case FIX_HC_64BIT_NOCHECK:
674 {
675 uint32_t offTrg = *u.pu32++;
676 Assert(offSrc < pSwitcher->cbCode);
677 Assert(u8 == FIX_HC_64BIT_NOCHECK || offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
678 *uSrc.pu64 = u32IDCode + offTrg;
679 break;
680 }
681
682 /*
683 * Far 16:32 ID pointer to 64-bit mode (ID) target within the code (32-bit offset).
684 */
685 case FIX_ID_FAR32_TO_64BIT_MODE:
686 {
687 uint32_t offTrg = *u.pu32++;
688 Assert(offSrc < pSwitcher->cbCode);
689 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
690 *uSrc.pu32++ = u32IDCode + offTrg;
691 *uSrc.pu16 = SelCS64;
692 AssertRelease(SelCS64);
693 break;
694 }
695
696#ifdef VBOX_WITH_NMI
697 /*
698 * 32-bit address to the APIC base.
699 */
700 case FIX_GC_APIC_BASE_32BIT:
701 {
702 *uSrc.pu32 = pVM->vmm.s.GCPtrApicBase;
703 break;
704 }
705#endif
706
707 default:
708 AssertReleaseMsgFailed(("Unknown fixup %d in switcher %s\n", u8, pSwitcher->pszDesc));
709 break;
710 }
711 }
712
713#ifdef LOG_ENABLED
714 /*
715 * If Log2 is enabled disassemble the switcher code.
716 *
717 * The switcher code have 1-2 HC parts, 1 GC part and 0-2 ID parts.
718 */
719 if (LogIs2Enabled())
720 {
721 RTLogPrintf("*** Disassembly of switcher %d '%s' %#x bytes ***\n"
722 " R0PtrCode = %p\n"
723 " pu8CodeR3 = %p\n"
724 " GCPtrCode = %RGv\n"
725 " u32IDCode = %08x\n"
726 " pVMRC = %RRv\n"
727 " pCPUMRC = %RRv\n"
728 " pVMR3 = %p\n"
729 " pCPUMR3 = %p\n"
730 " GCPtrGDT = %RGv\n"
731 " InterCR3s = %08RHp, %08RHp, %08RHp (32-Bit, PAE, AMD64)\n"
732 " HyperCR3s = %08RHp, %08RHp, %08RHp (32-Bit, PAE, AMD64)\n"
733 " SelCS = %04x\n"
734 " SelDS = %04x\n"
735 " SelCS64 = %04x\n"
736 " SelTSS = %04x\n",
737 pSwitcher->enmType, pSwitcher->pszDesc, pSwitcher->cbCode,
738 R0PtrCode,
739 pu8CodeR3,
740 GCPtrCode,
741 u32IDCode,
742 VM_RC_ADDR(pVM, pVM),
743 VM_RC_ADDR(pVM, &pVM->cpum),
744 pVM,
745 &pVM->cpum,
746 GCPtrGDT,
747 PGMGetInter32BitCR3(pVM), PGMGetInterPaeCR3(pVM), PGMGetInterAmd64CR3(pVM),
748 PGMGetHyper32BitCR3(pVM), PGMGetHyperPaeCR3(pVM), PGMGetHyperAmd64CR3(pVM),
749 SelCS, SelDS, SelCS64, SelTSS);
750
751 uint32_t offCode = 0;
752 while (offCode < pSwitcher->cbCode)
753 {
754 /*
755 * Figure out where this is.
756 */
757 const char *pszDesc = NULL;
758 RTUINTPTR uBase;
759 uint32_t cbCode;
760 if (offCode - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0)
761 {
762 pszDesc = "HCCode0";
763 uBase = R0PtrCode;
764 offCode = pSwitcher->offHCCode0;
765 cbCode = pSwitcher->cbHCCode0;
766 }
767 else if (offCode - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1)
768 {
769 pszDesc = "HCCode1";
770 uBase = R0PtrCode;
771 offCode = pSwitcher->offHCCode1;
772 cbCode = pSwitcher->cbHCCode1;
773 }
774 else if (offCode - pSwitcher->offGCCode < pSwitcher->cbGCCode)
775 {
776 pszDesc = "GCCode";
777 uBase = GCPtrCode;
778 offCode = pSwitcher->offGCCode;
779 cbCode = pSwitcher->cbGCCode;
780 }
781 else if (offCode - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0)
782 {
783 pszDesc = "IDCode0";
784 uBase = u32IDCode;
785 offCode = pSwitcher->offIDCode0;
786 cbCode = pSwitcher->cbIDCode0;
787 }
788 else if (offCode - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1)
789 {
790 pszDesc = "IDCode1";
791 uBase = u32IDCode;
792 offCode = pSwitcher->offIDCode1;
793 cbCode = pSwitcher->cbIDCode1;
794 }
795 else
796 {
797 RTLogPrintf(" %04x: %02x '%c' (nowhere)\n",
798 offCode, pu8CodeR3[offCode], isprint(pu8CodeR3[offCode]) ? pu8CodeR3[offCode] : ' ');
799 offCode++;
800 continue;
801 }
802
803 /*
804 * Disassemble it.
805 */
806 RTLogPrintf(" %s: offCode=%#x cbCode=%#x\n", pszDesc, offCode, cbCode);
807 DISCPUSTATE Cpu;
808
809 memset(&Cpu, 0, sizeof(Cpu));
810 Cpu.mode = CPUMODE_32BIT;
811 while (cbCode > 0)
812 {
813 /* try label it */
814 if (pSwitcher->offR0HostToGuest == offCode)
815 RTLogPrintf(" *R0HostToGuest:\n");
816 if (pSwitcher->offGCGuestToHost == offCode)
817 RTLogPrintf(" *GCGuestToHost:\n");
818 if (pSwitcher->offGCCallTrampoline == offCode)
819 RTLogPrintf(" *GCCallTrampoline:\n");
820 if (pSwitcher->offGCGuestToHostAsm == offCode)
821 RTLogPrintf(" *GCGuestToHostAsm:\n");
822 if (pSwitcher->offGCGuestToHostAsmHyperCtx == offCode)
823 RTLogPrintf(" *GCGuestToHostAsmHyperCtx:\n");
824 if (pSwitcher->offGCGuestToHostAsmGuestCtx == offCode)
825 RTLogPrintf(" *GCGuestToHostAsmGuestCtx:\n");
826
827 /* disas */
828 uint32_t cbInstr = 0;
829 char szDisas[256];
830 if (RT_SUCCESS(DISInstr(&Cpu, (RTUINTPTR)pu8CodeR3 + offCode, uBase - (RTUINTPTR)pu8CodeR3, &cbInstr, szDisas)))
831 RTLogPrintf(" %04x: %s", offCode, szDisas); //for whatever reason szDisas includes '\n'.
832 else
833 {
834 RTLogPrintf(" %04x: %02x '%c'\n",
835 offCode, pu8CodeR3[offCode], isprint(pu8CodeR3[offCode]) ? pu8CodeR3[offCode] : ' ');
836 cbInstr = 1;
837 }
838 offCode += cbInstr;
839 cbCode -= RT_MIN(cbInstr, cbCode);
840 }
841 }
842 }
843#endif
844}
845
846
847/**
848 * Relocator for the 32-Bit to 32-Bit world switcher.
849 */
850DECLCALLBACK(void) vmmR3Switcher32BitTo32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
851{
852 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
853 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
854}
855
856
857/**
858 * Relocator for the 32-Bit to PAE world switcher.
859 */
860DECLCALLBACK(void) vmmR3Switcher32BitToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
861{
862 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
863 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
864}
865
866
867/**
868 * Relocator for the 32-Bit to AMD64 world switcher.
869 */
870DECLCALLBACK(void) vmmR3Switcher32BitToAMD64_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
871{
872 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
873 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), SELMGetHyperCS64(pVM));
874}
875
876
877/**
878 * Relocator for the PAE to 32-Bit world switcher.
879 */
880DECLCALLBACK(void) vmmR3SwitcherPAETo32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
881{
882 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
883 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
884}
885
886
887/**
888 * Relocator for the PAE to PAE world switcher.
889 */
890DECLCALLBACK(void) vmmR3SwitcherPAEToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
891{
892 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
893 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
894}
895
896/**
897 * Relocator for the PAE to AMD64 world switcher.
898 */
899DECLCALLBACK(void) vmmR3SwitcherPAEToAMD64_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
900{
901 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
902 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), SELMGetHyperCS64(pVM));
903}
904
905
906/**
907 * Relocator for the AMD64 to 32-bit world switcher.
908 */
909DECLCALLBACK(void) vmmR3SwitcherAMD64To32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
910{
911 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
912 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), SELMGetHyperCS64(pVM));
913}
914
915
916/**
917 * Relocator for the AMD64 to PAE world switcher.
918 */
919DECLCALLBACK(void) vmmR3SwitcherAMD64ToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, RTR0PTR R0PtrCode, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
920{
921 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, R0PtrCode, pu8CodeR3, GCPtrCode, u32IDCode,
922 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), SELMGetHyperCS64(pVM));
923}
924
925
926/**
927 * Selects the switcher to be used for switching to GC.
928 *
929 * @returns VBox status code.
930 * @param pVM VM handle.
931 * @param enmSwitcher The new switcher.
932 * @remark This function may be called before the VMM is initialized.
933 */
934VMMR3DECL(int) VMMR3SelectSwitcher(PVM pVM, VMMSWITCHER enmSwitcher)
935{
936 /*
937 * Validate input.
938 */
939 if ( enmSwitcher < VMMSWITCHER_INVALID
940 || enmSwitcher >= VMMSWITCHER_MAX)
941 {
942 AssertMsgFailed(("Invalid input enmSwitcher=%d\n", enmSwitcher));
943 return VERR_INVALID_PARAMETER;
944 }
945
946 /* Do nothing if the switcher is disabled. */
947 if (pVM->vmm.s.fSwitcherDisabled)
948 return VINF_SUCCESS;
949
950 /*
951 * Select the new switcher.
952 */
953 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[enmSwitcher];
954 if (pSwitcher)
955 {
956 Log(("VMMR3SelectSwitcher: enmSwitcher %d -> %d %s\n", pVM->vmm.s.enmSwitcher, enmSwitcher, pSwitcher->pszDesc));
957 pVM->vmm.s.enmSwitcher = enmSwitcher;
958
959 RTR0PTR pbCodeR0 = (RTR0PTR)pVM->vmm.s.pvCoreCodeR0 + pVM->vmm.s.aoffSwitchers[enmSwitcher]; /** @todo fix the pvCoreCodeR0 type */
960 pVM->vmm.s.pfnHostToGuestR0 = pbCodeR0 + pSwitcher->offR0HostToGuest;
961
962 RTGCPTR GCPtr = pVM->vmm.s.pvCoreCodeRC + pVM->vmm.s.aoffSwitchers[enmSwitcher];
963 pVM->vmm.s.pfnGuestToHostRC = GCPtr + pSwitcher->offGCGuestToHost;
964 pVM->vmm.s.pfnCallTrampolineRC = GCPtr + pSwitcher->offGCCallTrampoline;
965 pVM->pfnVMMGCGuestToHostAsm = GCPtr + pSwitcher->offGCGuestToHostAsm;
966 pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
967 pVM->pfnVMMGCGuestToHostAsmGuestCtx = GCPtr + pSwitcher->offGCGuestToHostAsmGuestCtx;
968 return VINF_SUCCESS;
969 }
970
971 return VERR_NOT_IMPLEMENTED;
972}
973
974
975/**
976 * Disable the switcher logic permanently.
977 *
978 * @returns VBox status code.
979 * @param pVM VM handle.
980 */
981VMMR3DECL(int) VMMR3DisableSwitcher(PVM pVM)
982{
983/** @todo r=bird: I would suggest that we create a dummy switcher which just does something like:
984 * @code
985 * mov eax, VERR_INTERNAL_ERROR
986 * ret
987 * @endcode
988 * And then check for fSwitcherDisabled in VMMR3SelectSwitcher() in order to prevent it from being removed.
989 */
990 pVM->vmm.s.fSwitcherDisabled = true;
991 return VINF_SUCCESS;
992}
993
994/**
995 * Gets the switcher to be used for switching to GC.
996 *
997 * @returns host to guest ring 0 switcher entrypoint
998 * @param pVM VM handle.
999 * @param enmSwitcher The new switcher.
1000 */
1001VMMR3DECL(RTR0PTR) VMMR3GetHostToGuestSwitcher(PVM pVM, VMMSWITCHER enmSwitcher)
1002{
1003 /*
1004 * Validate input.
1005 */
1006 if ( enmSwitcher < VMMSWITCHER_INVALID
1007 || enmSwitcher >= VMMSWITCHER_MAX)
1008 {
1009 AssertMsgFailed(("Invalid input enmSwitcher=%d\n", enmSwitcher));
1010 return VERR_INVALID_PARAMETER;
1011 }
1012
1013 /*
1014 * Select the new switcher.
1015 */
1016 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[enmSwitcher];
1017 if (pSwitcher)
1018 {
1019 RTR0PTR pbCodeR0 = (RTR0PTR)pVM->vmm.s.pvCoreCodeR0 + pVM->vmm.s.aoffSwitchers[enmSwitcher]; /** @todo fix the pvCoreCodeR0 type */
1020 return pbCodeR0 + pSwitcher->offR0HostToGuest;
1021 }
1022 return (RTR0PTR)0;
1023}
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