VirtualBox

source: vbox/trunk/src/VBox/VMM/VMM.cpp@ 4485

Last change on this file since 4485 was 4186, checked in by vboxsync, 17 years ago

SSMAFTER_DEBUG_IT hack.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 96.5 KB
Line 
1/* $Id: VMM.cpp 4186 2007-08-16 22:45:09Z vboxsync $ */
2/** @file
3 * VMM - The Virtual Machine Monitor Core.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek 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
18//#define NO_SUPCALLR0VMM
19
20/** @page pg_vmm VMM - The Virtual Machine Monitor
21 *
22 * !Revise this! It's already incorrect!
23 *
24 * The Virtual Machine Monitor (VMM) is the core of the virtual machine. It
25 * manages the alternate reality; controlling the virtualization, managing
26 * resources, tracking CPU state, it's resources and so on...
27 *
28 * We will split the VMM into smaller entities:
29 *
30 * - Virtual Machine Core Monitor (VMCM), which purpose it is to
31 * provide ring and world switching, that including routing
32 * interrupts to the host OS and traps to the appropriate trap
33 * handlers. It will implement an external interface for
34 * managing trap handlers.
35 *
36 * - CPU Monitor (CM), tracking the state of the CPU (in the alternate
37 * reality) and implementing external interfaces to read and change
38 * the state.
39 *
40 * - Memory Monitor (MM), which purpose it is to virtualize physical
41 * pages, segment descriptor tables, interrupt descriptor tables, task
42 * segments, and keep track of all memory providing external interfaces
43 * to access content and map pages. (Internally splitt into smaller entities!)
44 *
45 * - IO Monitor (IOM), which virtualizes in and out I/O operations. It
46 * interacts with the MM to implement memory mapped I/O. External
47 * interfaces for adding and removing I/O ranges are implemented.
48 *
49 * - External Interrupt Monitor (EIM), which purpose it is to manage
50 * interrupts generated by virtual devices. This monitor provides
51 * an interfaces for raising interrupts which is accessible at any
52 * time and from all thread.
53 * <p>
54 * A subentity of the EIM is the vitual Programmable Interrupt
55 * Controller Device (VPICD), and perhaps a virtual I/O Advanced
56 * Programmable Interrupt Controller Device (VAPICD).
57 *
58 * - Direct Memory Access Monitor (DMAM), which purpose it is to support
59 * virtual device using the DMA controller. Interfaces must be as the
60 * EIM interfaces independent and threadable.
61 * <p>
62 * A subentity of the DMAM is a virtual DMA Controller Device (VDMACD).
63 *
64 *
65 * Entities working on a higher level:
66 *
67 * - Device Manager (DM), which is a support facility for virtualized
68 * hardware. This provides generic facilities for efficient device
69 * virtualization. It will manage device attaching and detaching
70 * conversing with EIM and IOM.
71 *
72 * - Debugger Facility (DBGF) provides the basic features for
73 * debugging the alternate reality execution.
74 *
75 *
76 *
77 * @section pg_vmm_s_use_cases Use Cases
78 *
79 * @subsection pg_vmm_s_use_case_boot Bootstrap
80 *
81 * - Basic Init:
82 * - Init SUPDRV.
83 *
84 * - Init Virtual Machine Instance:
85 * - Load settings.
86 * - Check resource requirements (memory, com, stuff).
87 *
88 * - Init Host Ring 3 part:
89 * - Init Core code.
90 * - Load Pluggable Components.
91 * - Init Pluggable Components.
92 *
93 * - Init Host Ring 0 part:
94 * - Load Core (core = core components like VMM, RMI, CA, and so on) code.
95 * - Init Core code.
96 * - Load Pluggable Component code.
97 * - Init Pluggable Component code.
98 *
99 * - Allocate first chunk of memory and pin it down. This block of memory
100 * will fit the following pieces:
101 * - Virtual Machine Instance data. (Config, CPU state, VMM state, ++)
102 * (This is available from everywhere (at different addresses though)).
103 * - VMM Guest Context code.
104 * - Pluggable devices Guest Context code.
105 * - Page tables (directory and everything) for the VMM Guest
106 *
107 * - Setup Guest (Ring 0) part:
108 * - Setup initial page tables (i.e. directory all the stuff).
109 * - Load Core Guest Context code.
110 * - Load Pluggable Devices Guest Context code.
111 *
112 *
113 */
114
115
116/*******************************************************************************
117* Header Files *
118*******************************************************************************/
119#define LOG_GROUP LOG_GROUP_VMM
120#include <VBox/vmm.h>
121#include <VBox/vmapi.h>
122#include <VBox/pgm.h>
123#include <VBox/cfgm.h>
124#include <VBox/pdmqueue.h>
125#include <VBox/pdmapi.h>
126#include <VBox/cpum.h>
127#include <VBox/mm.h>
128#include <VBox/iom.h>
129#include <VBox/trpm.h>
130#include <VBox/selm.h>
131#include <VBox/em.h>
132#include <VBox/sup.h>
133#include <VBox/dbgf.h>
134#include <VBox/csam.h>
135#include <VBox/patm.h>
136#include <VBox/rem.h>
137#include <VBox/ssm.h>
138#include <VBox/tm.h>
139#include "VMMInternal.h"
140#include "VMMSwitcher/VMMSwitcher.h"
141#include <VBox/vm.h>
142#include <VBox/err.h>
143#include <VBox/param.h>
144#include <VBox/version.h>
145#include <VBox/x86.h>
146#include <VBox/hwaccm.h>
147#include <iprt/assert.h>
148#include <iprt/alloc.h>
149#include <iprt/asm.h>
150#include <iprt/time.h>
151#include <iprt/stream.h>
152#include <iprt/string.h>
153#include <iprt/stdarg.h>
154#include <iprt/ctype.h>
155
156
157
158/** The saved state version. */
159#define VMM_SAVED_STATE_VERSION 3
160
161
162/*******************************************************************************
163* Internal Functions *
164*******************************************************************************/
165static DECLCALLBACK(int) vmmR3Save(PVM pVM, PSSMHANDLE pSSM);
166static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
167static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser);
168static int vmmR3ServiceCallHostRequest(PVM pVM);
169static DECLCALLBACK(void) vmmR3InfoFF(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
170
171
172/*******************************************************************************
173* Global Variables *
174*******************************************************************************/
175/** Array of switcher defininitions.
176 * The type and index shall match!
177 */
178static PVMMSWITCHERDEF s_apSwitchers[VMMSWITCHER_MAX] =
179{
180 NULL, /* invalid entry */
181#ifndef RT_ARCH_AMD64
182 &vmmR3Switcher32BitTo32Bit_Def,
183 &vmmR3Switcher32BitToPAE_Def,
184 NULL, //&vmmR3Switcher32BitToAMD64_Def,
185 &vmmR3SwitcherPAETo32Bit_Def,
186 &vmmR3SwitcherPAEToPAE_Def,
187 NULL, //&vmmR3SwitcherPAEToAMD64_Def,
188# ifdef VBOX_WITH_HYBIRD_32BIT_KERNEL
189 &vmmR3SwitcherAMD64ToPAE_Def,
190# else
191 NULL, //&vmmR3SwitcherAMD64ToPAE_Def,
192# endif
193 NULL //&vmmR3SwitcherAMD64ToAMD64_Def,
194#else
195 NULL, //&vmmR3Switcher32BitTo32Bit_Def,
196 NULL, //&vmmR3Switcher32BitToPAE_Def,
197 NULL, //&vmmR3Switcher32BitToAMD64_Def,
198 NULL, //&vmmR3SwitcherPAETo32Bit_Def,
199 NULL, //&vmmR3SwitcherPAEToPAE_Def,
200 NULL, //&vmmR3SwitcherPAEToAMD64_Def,
201 &vmmR3SwitcherAMD64ToPAE_Def,
202 NULL //&vmmR3SwitcherAMD64ToAMD64_Def,
203#endif
204};
205
206
207
208/**
209 * Initiates the core code.
210 *
211 * This is core per VM code which might need fixups and/or for ease of use
212 * are put on linear contiguous backing.
213 *
214 * @returns VBox status code.
215 * @param pVM Pointer to VM structure.
216 */
217static int vmmR3InitCoreCode(PVM pVM)
218{
219 /*
220 * Calc the size.
221 */
222 unsigned cbCoreCode = 0;
223 for (unsigned iSwitcher = 0; iSwitcher < ELEMENTS(s_apSwitchers); iSwitcher++)
224 {
225 pVM->vmm.s.aoffSwitchers[iSwitcher] = cbCoreCode;
226 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
227 if (pSwitcher)
228 {
229 AssertRelease((unsigned)pSwitcher->enmType == iSwitcher);
230 cbCoreCode += RT_ALIGN_32(pSwitcher->cbCode + 1, 32);
231 }
232 }
233
234 /*
235 * Allocate continguous pages for switchers and deal with
236 * conflicts in the intermediate mapping of the code.
237 */
238 pVM->vmm.s.cbCoreCode = RT_ALIGN_32(cbCoreCode, PAGE_SIZE);
239 pVM->vmm.s.pvHCCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvHCCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
240 int rc = VERR_NO_MEMORY;
241 if (pVM->vmm.s.pvHCCoreCodeR3)
242 {
243 rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
244 if (rc == VERR_PGM_MAPPINGS_FIX_CONFLICT)
245 {
246 /* try more allocations. */
247 struct
248 {
249 RTR0PTR pvR0;
250 void *pvR3;
251 RTHCPHYS HCPhys;
252 RTUINT cb;
253 } aBadTries[16];
254 unsigned i = 0;
255 do
256 {
257 aBadTries[i].pvR3 = pVM->vmm.s.pvHCCoreCodeR3;
258 aBadTries[i].pvR0 = pVM->vmm.s.pvHCCoreCodeR0;
259 aBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
260 i++;
261 pVM->vmm.s.pvHCCoreCodeR0 = NIL_RTR0PTR;
262 pVM->vmm.s.HCPhysCoreCode = NIL_RTHCPHYS;
263 pVM->vmm.s.pvHCCoreCodeR3 = SUPContAlloc2(pVM->vmm.s.cbCoreCode >> PAGE_SHIFT, &pVM->vmm.s.pvHCCoreCodeR0, &pVM->vmm.s.HCPhysCoreCode);
264 if (!pVM->vmm.s.pvHCCoreCodeR3)
265 break;
266 rc = PGMR3MapIntermediate(pVM, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.HCPhysCoreCode, cbCoreCode);
267 } while ( rc == VERR_PGM_MAPPINGS_FIX_CONFLICT
268 && i < ELEMENTS(aBadTries) - 1);
269
270 /* cleanup */
271 if (VBOX_FAILURE(rc))
272 {
273 aBadTries[i].pvR3 = pVM->vmm.s.pvHCCoreCodeR3;
274 aBadTries[i].pvR0 = pVM->vmm.s.pvHCCoreCodeR0;
275 aBadTries[i].HCPhys = pVM->vmm.s.HCPhysCoreCode;
276 aBadTries[i].cb = pVM->vmm.s.cbCoreCode;
277 i++;
278 LogRel(("Failed to allocated and map core code: rc=%Vrc\n", rc));
279 }
280 while (i-- > 0)
281 {
282 LogRel(("Core code alloc attempt #%d: pvR3=%p pvR0=%p HCPhys=%VHp\n",
283 i, aBadTries[i].pvR3, aBadTries[i].pvR0, aBadTries[i].HCPhys));
284 SUPContFree(aBadTries[i].pvR3, aBadTries[i].cb >> PAGE_SHIFT);
285 }
286 }
287 }
288 if (VBOX_SUCCESS(rc))
289 {
290 /*
291 * copy the code.
292 */
293 for (unsigned iSwitcher = 0; iSwitcher < ELEMENTS(s_apSwitchers); iSwitcher++)
294 {
295 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
296 if (pSwitcher)
297 memcpy((uint8_t *)pVM->vmm.s.pvHCCoreCodeR3 + pVM->vmm.s.aoffSwitchers[iSwitcher],
298 pSwitcher->pvCode, pSwitcher->cbCode);
299 }
300
301 /*
302 * Map the code into the GC address space.
303 */
304 rc = MMR3HyperMapHCPhys(pVM, pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, "Core Code", &pVM->vmm.s.pvGCCoreCode);
305 if (VBOX_SUCCESS(rc))
306 {
307 MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
308 LogRel(("CoreCode: R3=%VHv R0=%VHv GC=%VGv Phys=%VHp cb=%#x\n",
309 pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.pvHCCoreCodeR0, pVM->vmm.s.pvGCCoreCode, pVM->vmm.s.HCPhysCoreCode, pVM->vmm.s.cbCoreCode));
310
311 /*
312 * Finally, PGM probably have selected a switcher already but we need
313 * to do get the addresses so we'll reselect it.
314 * This may legally fail so, we're ignoring the rc.
315 */
316 VMMR3SelectSwitcher(pVM, pVM->vmm.s.enmSwitcher);
317 return rc;
318 }
319
320 /* shit */
321 AssertMsgFailed(("PGMR3Map(,%VGv, %VGp, %#x, 0) failed with rc=%Vrc\n", pVM->vmm.s.pvGCCoreCode, pVM->vmm.s.HCPhysCoreCode, cbCoreCode, rc));
322 SUPContFree(pVM->vmm.s.pvHCCoreCodeR3, pVM->vmm.s.cbCoreCode >> PAGE_SHIFT);
323 }
324 else
325 VMSetError(pVM, rc, RT_SRC_POS,
326 N_("Failed to allocate %d bytes of contiguous memory for the world switcher code."),
327 cbCoreCode);
328
329 pVM->vmm.s.pvHCCoreCodeR3 = NULL;
330 pVM->vmm.s.pvHCCoreCodeR0 = NIL_RTR0PTR;
331 pVM->vmm.s.pvGCCoreCode = 0;
332 return rc;
333}
334
335
336/**
337 * Initializes the VMM.
338 *
339 * @returns VBox status code.
340 * @param pVM The VM to operate on.
341 */
342VMMR3DECL(int) VMMR3Init(PVM pVM)
343{
344 LogFlow(("VMMR3Init\n"));
345
346 /*
347 * Assert alignment, sizes and order.
348 */
349 AssertMsg(pVM->vmm.s.offVM == 0, ("Already initialized!\n"));
350 AssertMsg(sizeof(pVM->vmm.padding) >= sizeof(pVM->vmm.s),
351 ("pVM->vmm.padding is too small! vmm.padding %d while vmm.s is %d\n",
352 sizeof(pVM->vmm.padding), sizeof(pVM->vmm.s)));
353
354 /*
355 * Init basic VM VMM members.
356 */
357 pVM->vmm.s.offVM = RT_OFFSETOF(VM, vmm);
358 int rc = CFGMR3QueryU32(CFGMR3GetRoot(pVM), "YieldEMTInterval", &pVM->vmm.s.cYieldEveryMillies);
359 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
360 pVM->vmm.s.cYieldEveryMillies = 23; /* Value arrived at after experimenting with the grub boot prompt. */
361 //pVM->vmm.s.cYieldEveryMillies = 8; //debugging
362 else
363 AssertMsgRCReturn(rc, ("Configuration error. Failed to query \"YieldEMTInterval\", rc=%Vrc\n", rc), rc);
364
365 /* GC switchers are enabled by default. Turned off by HWACCM. */
366 pVM->vmm.s.fSwitcherDisabled = false;
367
368 /*
369 * Register the saved state data unit.
370 */
371 rc = SSMR3RegisterInternal(pVM, "vmm", 1, VMM_SAVED_STATE_VERSION, VMM_STACK_SIZE + sizeof(RTGCPTR),
372 NULL, vmmR3Save, NULL,
373 NULL, vmmR3Load, NULL);
374 if (VBOX_FAILURE(rc))
375 return rc;
376
377#ifdef VBOX_WITHOUT_IDT_PATCHING
378 /*
379 * Register the Ring-0 VM handle with the session for fast ioctl calls.
380 */
381 rc = SUPSetVMForFastIOCtl(pVM->pVMR0);
382 if (VBOX_FAILURE(rc))
383 return rc;
384#endif
385
386 /*
387 * Init core code.
388 */
389 rc = vmmR3InitCoreCode(pVM);
390 if (VBOX_SUCCESS(rc))
391 {
392 /*
393 * Allocate & init VMM GC stack.
394 * The stack pages are also used by the VMM R0 when VMMR0CallHost is invoked.
395 * (The page protection is modifed during R3 init completion.)
396 */
397#ifdef VBOX_STRICT_VMM_STACK
398 rc = MMHyperAlloc(pVM, VMM_STACK_SIZE + PAGE_SIZE + PAGE_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbHCStack);
399#else
400 rc = MMHyperAlloc(pVM, VMM_STACK_SIZE, PAGE_SIZE, MM_TAG_VMM, (void **)&pVM->vmm.s.pbHCStack);
401#endif
402 if (VBOX_SUCCESS(rc))
403 {
404 /* Set HC and GC stack pointers to top of stack. */
405 pVM->vmm.s.CallHostR0JmpBuf.pvSavedStack = (RTR0PTR)pVM->vmm.s.pbHCStack;
406 pVM->vmm.s.pbGCStack = MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack);
407 pVM->vmm.s.pbGCStackBottom = pVM->vmm.s.pbGCStack + VMM_STACK_SIZE;
408 AssertRelease(pVM->vmm.s.pbGCStack);
409
410 /* Set hypervisor eip. */
411 CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStack);
412
413 /*
414 * Allocate GC & R0 Logger instances (they are finalized in the relocator).
415 */
416#ifdef LOG_ENABLED
417 PRTLOGGER pLogger = RTLogDefaultInstance();
418 if (pLogger)
419 {
420 pVM->vmm.s.cbLoggerGC = RT_OFFSETOF(RTLOGGERGC, afGroups[pLogger->cGroups]);
421 rc = MMHyperAlloc(pVM, pVM->vmm.s.cbLoggerGC, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pLoggerHC);
422 if (VBOX_SUCCESS(rc))
423 {
424 pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
425
426/*
427 * Ring-0 logging isn't 100% safe yet (thread id reuse / process exit cleanup), so
428 * you have to sign up here by adding your defined(DEBUG_<userid>) to the #if.
429 *
430 * If you want to log in non-debug modes, you'll have to remember to change SUPDRvShared.c
431 * to not stub all the log functions.
432 *
433 * You might also wish to enable the AssertMsg1/2 overrides in VMMR0.cpp when enabling this.
434 */
435# if defined(DEBUG_sandervl) || defined(DEBUG_frank)
436 rc = MMHyperAlloc(pVM, RT_OFFSETOF(VMMR0LOGGER, Logger.afGroups[pLogger->cGroups]),
437 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pR0Logger);
438 if (VBOX_SUCCESS(rc))
439 {
440 pVM->vmm.s.pR0Logger->pVM = pVM;
441 //pVM->vmm.s.pR0Logger->fCreated = false;
442 pVM->vmm.s.pR0Logger->cbLogger = RT_OFFSETOF(RTLOGGER, afGroups[pLogger->cGroups]);
443 }
444# endif
445 }
446 }
447#endif /* LOG_ENABLED */
448
449#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
450 /*
451 * Allocate GC Release Logger instances (finalized in the relocator).
452 */
453 if (VBOX_SUCCESS(rc))
454 {
455 PRTLOGGER pRelLogger = RTLogRelDefaultInstance();
456 if (pRelLogger)
457 {
458 pVM->vmm.s.cbRelLoggerGC = RT_OFFSETOF(RTLOGGERGC, afGroups[pRelLogger->cGroups]);
459 rc = MMHyperAlloc(pVM, pVM->vmm.s.cbRelLoggerGC, 0, MM_TAG_VMM, (void **)&pVM->vmm.s.pRelLoggerHC);
460 if (VBOX_SUCCESS(rc))
461 pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
462 }
463 }
464#endif /* VBOX_WITH_GC_AND_R0_RELEASE_LOG */
465
466#ifdef VBOX_WITH_NMI
467 /*
468 * Allocate mapping for the host APIC.
469 */
470 if (VBOX_SUCCESS(rc))
471 {
472 rc = MMR3HyperReserve(pVM, PAGE_SIZE, "Host APIC", &pVM->vmm.s.GCPtrApicBase);
473 AssertRC(rc);
474 }
475#endif
476 if (VBOX_SUCCESS(rc))
477 {
478 rc = RTCritSectInit(&pVM->vmm.s.CritSectVMLock);
479 if (VBOX_SUCCESS(rc))
480 {
481 /*
482 * Debug info.
483 */
484 DBGFR3InfoRegisterInternal(pVM, "ff", "Displays the current Forced actions Flags.", vmmR3InfoFF);
485
486 /*
487 * Statistics.
488 */
489 STAM_REG(pVM, &pVM->vmm.s.StatRunGC, STAMTYPE_COUNTER, "/VMM/RunGC", STAMUNIT_OCCURENCES, "Number of context switches.");
490 STAM_REG(pVM, &pVM->vmm.s.StatGCRetNormal, STAMTYPE_COUNTER, "/VMM/GCRet/Normal", STAMUNIT_OCCURENCES, "Number of VINF_SUCCESS returns.");
491 STAM_REG(pVM, &pVM->vmm.s.StatGCRetInterrupt, STAMTYPE_COUNTER, "/VMM/GCRet/Interrupt", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_INTERRUPT returns.");
492 STAM_REG(pVM, &pVM->vmm.s.StatGCRetInterruptHyper, STAMTYPE_COUNTER, "/VMM/GCRet/InterruptHyper", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_INTERRUPT_HYPER returns.");
493 STAM_REG(pVM, &pVM->vmm.s.StatGCRetGuestTrap, STAMTYPE_COUNTER, "/VMM/GCRet/GuestTrap", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_GUEST_TRAP returns.");
494 STAM_REG(pVM, &pVM->vmm.s.StatGCRetRingSwitch, STAMTYPE_COUNTER, "/VMM/GCRet/RingSwitch", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_RING_SWITCH returns.");
495 STAM_REG(pVM, &pVM->vmm.s.StatGCRetRingSwitchInt, STAMTYPE_COUNTER, "/VMM/GCRet/RingSwitchInt", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_RING_SWITCH_INT returns.");
496 STAM_REG(pVM, &pVM->vmm.s.StatGCRetExceptionPrivilege, STAMTYPE_COUNTER, "/VMM/GCRet/ExceptionPrivilege", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_EXCEPTION_PRIVILEGED returns.");
497 STAM_REG(pVM, &pVM->vmm.s.StatGCRetStaleSelector, STAMTYPE_COUNTER, "/VMM/GCRet/StaleSelector", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_STALE_SELECTOR returns.");
498 STAM_REG(pVM, &pVM->vmm.s.StatGCRetIRETTrap, STAMTYPE_COUNTER, "/VMM/GCRet/IRETTrap", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_IRET_TRAP returns.");
499 STAM_REG(pVM, &pVM->vmm.s.StatGCRetEmulate, STAMTYPE_COUNTER, "/VMM/GCRet/Emulate", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION returns.");
500 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchEmulate, STAMTYPE_COUNTER, "/VMM/GCRet/PatchEmulate", STAMUNIT_OCCURENCES, "Number of VINF_PATCH_EMULATE_INSTR returns.");
501 STAM_REG(pVM, &pVM->vmm.s.StatGCRetIORead, STAMTYPE_COUNTER, "/VMM/GCRet/IORead", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_IOPORT_READ returns.");
502 STAM_REG(pVM, &pVM->vmm.s.StatGCRetIOWrite, STAMTYPE_COUNTER, "/VMM/GCRet/IOWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_IOPORT_WRITE returns.");
503 STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIORead, STAMTYPE_COUNTER, "/VMM/GCRet/MMIORead", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_READ returns.");
504 STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOWrite, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_WRITE returns.");
505 STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOReadWrite, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOReadWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_READ_WRITE returns.");
506 STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOPatchRead, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOPatchRead", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_PATCH_READ returns.");
507 STAM_REG(pVM, &pVM->vmm.s.StatGCRetMMIOPatchWrite, STAMTYPE_COUNTER, "/VMM/GCRet/MMIOPatchWrite", STAMUNIT_OCCURENCES, "Number of VINF_IOM_HC_MMIO_PATCH_WRITE returns.");
508 STAM_REG(pVM, &pVM->vmm.s.StatGCRetLDTFault, STAMTYPE_COUNTER, "/VMM/GCRet/LDTFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_GDT_FAULT returns.");
509 STAM_REG(pVM, &pVM->vmm.s.StatGCRetGDTFault, STAMTYPE_COUNTER, "/VMM/GCRet/GDTFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_LDT_FAULT returns.");
510 STAM_REG(pVM, &pVM->vmm.s.StatGCRetIDTFault, STAMTYPE_COUNTER, "/VMM/GCRet/IDTFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_IDT_FAULT returns.");
511 STAM_REG(pVM, &pVM->vmm.s.StatGCRetTSSFault, STAMTYPE_COUNTER, "/VMM/GCRet/TSSFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_TSS_FAULT returns.");
512 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPDFault, STAMTYPE_COUNTER, "/VMM/GCRet/PDFault", STAMUNIT_OCCURENCES, "Number of VINF_EM_EXECUTE_INSTRUCTION_PD_FAULT returns.");
513 STAM_REG(pVM, &pVM->vmm.s.StatGCRetCSAMTask, STAMTYPE_COUNTER, "/VMM/GCRet/CSAMTask", STAMUNIT_OCCURENCES, "Number of VINF_CSAM_PENDING_ACTION returns.");
514 STAM_REG(pVM, &pVM->vmm.s.StatGCRetSyncCR3, STAMTYPE_COUNTER, "/VMM/GCRet/SyncCR", STAMUNIT_OCCURENCES, "Number of VINF_PGM_SYNC_CR3 returns.");
515 STAM_REG(pVM, &pVM->vmm.s.StatGCRetMisc, STAMTYPE_COUNTER, "/VMM/GCRet/Misc", STAMUNIT_OCCURENCES, "Number of misc returns.");
516 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchInt3, STAMTYPE_COUNTER, "/VMM/GCRet/PatchInt3", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PATCH_INT3 returns.");
517 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchPF, STAMTYPE_COUNTER, "/VMM/GCRet/PatchPF", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PATCH_TRAP_PF returns.");
518 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchGP, STAMTYPE_COUNTER, "/VMM/GCRet/PatchGP", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PATCH_TRAP_GP returns.");
519 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPatchIretIRQ, STAMTYPE_COUNTER, "/VMM/GCRet/PatchIret", STAMUNIT_OCCURENCES, "Number of VINF_PATM_PENDING_IRQ_AFTER_IRET returns.");
520 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPageOverflow, STAMTYPE_COUNTER, "/VMM/GCRet/InvlpgOverflow", STAMUNIT_OCCURENCES, "Number of VERR_REM_FLUSHED_PAGES_OVERFLOW returns.");
521 STAM_REG(pVM, &pVM->vmm.s.StatGCRetRescheduleREM, STAMTYPE_COUNTER, "/VMM/GCRet/ScheduleREM", STAMUNIT_OCCURENCES, "Number of VINF_EM_RESCHEDULE_REM returns.");
522 STAM_REG(pVM, &pVM->vmm.s.StatGCRetToR3, STAMTYPE_COUNTER, "/VMM/GCRet/ToR3", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_TO_R3 returns.");
523 STAM_REG(pVM, &pVM->vmm.s.StatGCRetTimerPending, STAMTYPE_COUNTER, "/VMM/GCRet/TimerPending", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_TIMER_PENDING returns.");
524 STAM_REG(pVM, &pVM->vmm.s.StatGCRetInterruptPending, STAMTYPE_COUNTER, "/VMM/GCRet/InterruptPending", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_INTERRUPT_PENDING returns.");
525 STAM_REG(pVM, &pVM->vmm.s.StatGCRetCallHost, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/Misc", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
526 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMGrowRAM, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/GrowRAM", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
527 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPDMLock, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/PDMLock", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
528 STAM_REG(pVM, &pVM->vmm.s.StatGCRetLogFlush, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/LogFlush", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
529 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPDMQueueFlush, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/QueueFlush", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
530 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMPoolGrow, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/PGMPoolGrow",STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
531 STAM_REG(pVM, &pVM->vmm.s.StatGCRetRemReplay, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/REMReplay", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
532 STAM_REG(pVM, &pVM->vmm.s.StatGCRetVMSetError, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/VMSetError", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
533 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMLock, STAMTYPE_COUNTER, "/VMM/GCRet/CallHost/PGMLock", STAMUNIT_OCCURENCES, "Number of VINF_VMM_CALL_HOST returns.");
534 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPATMDuplicateFn, STAMTYPE_COUNTER, "/VMM/GCRet/PATMDuplicateFn", STAMUNIT_OCCURENCES, "Number of VINF_PATM_DUPLICATE_FUNCTION returns.");
535 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPGMChangeMode, STAMTYPE_COUNTER, "/VMM/GCRet/PGMChangeMode", STAMUNIT_OCCURENCES, "Number of VINF_PGM_CHANGE_MODE returns.");
536 STAM_REG(pVM, &pVM->vmm.s.StatGCRetEmulHlt, STAMTYPE_COUNTER, "/VMM/GCRet/EmulHlt", STAMUNIT_OCCURENCES, "Number of VINF_EM_RAW_EMULATE_INSTR_HLT returns.");
537 STAM_REG(pVM, &pVM->vmm.s.StatGCRetPendingRequest, STAMTYPE_COUNTER, "/VMM/GCRet/PendingRequest", STAMUNIT_OCCURENCES, "Number of VINF_EM_PENDING_REQUEST returns.");
538
539 return VINF_SUCCESS;
540 }
541 AssertRC(rc);
542 }
543 }
544 /** @todo: Need failure cleanup. */
545
546 //more todo in here?
547 //if (VBOX_SUCCESS(rc))
548 //{
549 //}
550 //int rc2 = vmmR3TermCoreCode(pVM);
551 //AssertRC(rc2));
552 }
553
554 return rc;
555}
556
557
558/**
559 * Ring-3 init finalizing.
560 *
561 * @returns VBox status code.
562 * @param pVM The VM handle.
563 */
564VMMR3DECL(int) VMMR3InitFinalize(PVM pVM)
565{
566#ifdef VBOX_STRICT_VMM_STACK
567 /*
568 * Two inaccessible pages at each sides of the stack to catch over/under-flows.
569 */
570 memset(pVM->vmm.s.pbHCStack - PAGE_SIZE, 0xcc, PAGE_SIZE);
571 PGMMapSetPage(pVM, MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack - PAGE_SIZE), PAGE_SIZE, 0);
572 RTMemProtect(pVM->vmm.s.pbHCStack - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
573
574 memset(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, 0xcc, PAGE_SIZE);
575 PGMMapSetPage(pVM, MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack + VMM_STACK_SIZE), PAGE_SIZE, 0);
576 RTMemProtect(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
577#endif
578
579 /*
580 * Set page attributes to r/w for stack pages.
581 */
582 int rc = PGMMapSetPage(pVM, pVM->vmm.s.pbGCStack, VMM_STACK_SIZE, X86_PTE_P | X86_PTE_A | X86_PTE_D | X86_PTE_RW);
583 AssertRC(rc);
584 if (VBOX_SUCCESS(rc))
585 {
586 /*
587 * Create the EMT yield timer.
588 */
589 rc = TMR3TimerCreateInternal(pVM, TMCLOCK_REAL, vmmR3YieldEMT, NULL, "EMT Yielder", &pVM->vmm.s.pYieldTimer);
590 if (VBOX_SUCCESS(rc))
591 rc = TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldEveryMillies);
592 }
593#ifdef VBOX_WITH_NMI
594 /*
595 * Map the host APIC into GC - This may be host os specific!
596 */
597 if (VBOX_SUCCESS(rc))
598 rc = PGMMap(pVM, pVM->vmm.s.GCPtrApicBase, 0xfee00000, PAGE_SIZE,
599 X86_PTE_P | X86_PTE_RW | X86_PTE_PWT | X86_PTE_PCD | X86_PTE_A | X86_PTE_D);
600#endif
601 return rc;
602}
603
604
605/**
606 * Initializes the R0 VMM.
607 *
608 * @returns VBox status code.
609 * @param pVM The VM to operate on.
610 */
611VMMR3DECL(int) VMMR3InitR0(PVM pVM)
612{
613 int rc;
614
615 /*
616 * Initialize the ring-0 logger if we haven't done so yet.
617 */
618 if ( pVM->vmm.s.pR0Logger
619 && !pVM->vmm.s.pR0Logger->fCreated)
620 {
621 rc = VMMR3UpdateLoggers(pVM);
622 if (VBOX_FAILURE(rc))
623 return rc;
624 }
625
626 /*
627 * Call Ring-0 entry with init code.
628 */
629 for (;;)
630 {
631#ifdef NO_SUPCALLR0VMM
632 //rc = VERR_GENERAL_FAILURE;
633 rc = VINF_SUCCESS;
634#else
635 rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_VMMR0_INIT, (void *)VBOX_VERSION);
636#endif
637 if ( pVM->vmm.s.pR0Logger
638 && pVM->vmm.s.pR0Logger->Logger.offScratch > 0)
639 RTLogFlushToLogger(&pVM->vmm.s.pR0Logger->Logger, NULL);
640 if (rc != VINF_VMM_CALL_HOST)
641 break;
642 rc = vmmR3ServiceCallHostRequest(pVM);
643 if (VBOX_FAILURE(rc) || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
644 break;
645 break; // remove this when we do setjmp for all ring-0 stuff.
646 }
647
648 if (VBOX_FAILURE(rc) || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
649 {
650 LogRel(("R0 init failed, rc=%Vra\n", rc));
651 if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
652 rc = VERR_INTERNAL_ERROR;
653 }
654 return rc;
655}
656
657
658/**
659 * Initializes the GC VMM.
660 *
661 * @returns VBox status code.
662 * @param pVM The VM to operate on.
663 */
664VMMR3DECL(int) VMMR3InitGC(PVM pVM)
665{
666 /* In VMX mode, there's no need to init GC. */
667 if (pVM->vmm.s.fSwitcherDisabled)
668 return VINF_SUCCESS;
669
670 /*
671 * Call VMMGCInit():
672 * -# resolve the address.
673 * -# setup stackframe and EIP to use the trampoline.
674 * -# do a generic hypervisor call.
675 */
676 RTGCPTR GCPtrEP;
677 int rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "VMMGCEntry", &GCPtrEP);
678 if (VBOX_SUCCESS(rc))
679 {
680 CPUMHyperSetCtxCore(pVM, NULL);
681 CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStackBottom); /* Clear the stack. */
682 uint64_t u64TS = RTTimeProgramStartNanoTS();
683#if GC_ARCH_BITS == 32
684 CPUMPushHyper(pVM, (uint32_t)(u64TS >> 32)); /* Param 3: The program startup TS - Hi. */
685 CPUMPushHyper(pVM, (uint32_t)u64TS); /* Param 3: The program startup TS - Lo. */
686#else /* 64-bit GC */
687 CPUMPushHyper(pVM, u64TS); /* Param 3: The program startup TS. */
688#endif
689 CPUMPushHyper(pVM, VBOX_VERSION); /* Param 2: Version argument. */
690 CPUMPushHyper(pVM, VMMGC_DO_VMMGC_INIT); /* Param 1: Operation. */
691 CPUMPushHyper(pVM, pVM->pVMGC); /* Param 0: pVM */
692 CPUMPushHyper(pVM, 3 * sizeof(RTGCPTR)); /* trampoline param: stacksize. */
693 CPUMPushHyper(pVM, GCPtrEP); /* Call EIP. */
694 CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
695
696 for (;;)
697 {
698#ifdef NO_SUPCALLR0VMM
699 //rc = VERR_GENERAL_FAILURE;
700 rc = VINF_SUCCESS;
701#else
702 rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_CALL_HYPERVISOR, NULL);
703#endif
704#ifdef LOG_ENABLED
705 PRTLOGGERGC pLogger = pVM->vmm.s.pLoggerHC;
706 if ( pLogger
707 && pLogger->offScratch > 0)
708 RTLogFlushGC(NULL, pLogger);
709#endif
710#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
711 PRTLOGGERGC pRelLogger = pVM->vmm.s.pRelLoggerHC;
712 if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
713 RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
714#endif
715 if (rc != VINF_VMM_CALL_HOST)
716 break;
717 rc = vmmR3ServiceCallHostRequest(pVM);
718 if (VBOX_FAILURE(rc) || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
719 break;
720 }
721
722 if (VBOX_FAILURE(rc) || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST))
723 {
724 VMMR3FatalDump(pVM, rc);
725 if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
726 rc = VERR_INTERNAL_ERROR;
727 }
728 AssertRC(rc);
729 }
730 return rc;
731}
732
733
734/**
735 * Terminate the VMM bits.
736 *
737 * @returns VINF_SUCCESS.
738 * @param pVM The VM handle.
739 */
740VMMR3DECL(int) VMMR3Term(PVM pVM)
741{
742 /** @todo must call ring-0 so the logger thread instance can be properly removed. */
743
744#ifdef VBOX_STRICT_VMM_STACK
745 /*
746 * Make the two stack guard pages present again.
747 */
748 RTMemProtect(pVM->vmm.s.pbHCStack - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
749 RTMemProtect(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
750#endif
751 return VINF_SUCCESS;
752}
753
754
755/**
756 * Applies relocations to data and code managed by this
757 * component. This function will be called at init and
758 * whenever the VMM need to relocate it self inside the GC.
759 *
760 * The VMM will need to apply relocations to the core code.
761 *
762 * @param pVM The VM handle.
763 * @param offDelta The relocation delta.
764 */
765VMMR3DECL(void) VMMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
766{
767 LogFlow(("VMMR3Relocate: offDelta=%VGv\n", offDelta));
768
769 /*
770 * Recalc the GC address.
771 */
772 pVM->vmm.s.pvGCCoreCode = MMHyperHC2GC(pVM, pVM->vmm.s.pvHCCoreCodeR3);
773
774 /*
775 * The stack.
776 */
777 CPUMSetHyperESP(pVM, CPUMGetHyperESP(pVM) + offDelta);
778 pVM->vmm.s.pbGCStack = MMHyperHC2GC(pVM, pVM->vmm.s.pbHCStack);
779 pVM->vmm.s.pbGCStackBottom = pVM->vmm.s.pbGCStack + VMM_STACK_SIZE;
780
781 /*
782 * All the switchers.
783 */
784 for (unsigned iSwitcher = 0; iSwitcher < ELEMENTS(s_apSwitchers); iSwitcher++)
785 {
786 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[iSwitcher];
787 if (pSwitcher && pSwitcher->pfnRelocate)
788 {
789 unsigned off = pVM->vmm.s.aoffSwitchers[iSwitcher];
790 pSwitcher->pfnRelocate(pVM,
791 pSwitcher,
792 (uint8_t *)pVM->vmm.s.pvHCCoreCodeR0 + off,
793 (uint8_t *)pVM->vmm.s.pvHCCoreCodeR3 + off,
794 pVM->vmm.s.pvGCCoreCode + off,
795 pVM->vmm.s.HCPhysCoreCode + off);
796 }
797 }
798
799 /*
800 * Recalc the GC address for the current switcher.
801 */
802 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[pVM->vmm.s.enmSwitcher];
803 RTGCPTR GCPtr = pVM->vmm.s.pvGCCoreCode + pVM->vmm.s.aoffSwitchers[pVM->vmm.s.enmSwitcher];
804 pVM->vmm.s.pfnGCGuestToHost = GCPtr + pSwitcher->offGCGuestToHost;
805 pVM->vmm.s.pfnGCCallTrampoline = GCPtr + pSwitcher->offGCCallTrampoline;
806 pVM->pfnVMMGCGuestToHostAsm = GCPtr + pSwitcher->offGCGuestToHostAsm;
807 pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
808 pVM->pfnVMMGCGuestToHostAsmGuestCtx = GCPtr + pSwitcher->offGCGuestToHostAsmGuestCtx;
809
810 /*
811 * Get other GC entry points.
812 */
813 int rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuest", &pVM->vmm.s.pfnCPUMGCResumeGuest);
814 AssertReleaseMsgRC(rc, ("CPUMGCResumeGuest not found! rc=%Vra\n", rc));
815
816 rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "CPUMGCResumeGuestV86", &pVM->vmm.s.pfnCPUMGCResumeGuestV86);
817 AssertReleaseMsgRC(rc, ("CPUMGCResumeGuestV86 not found! rc=%Vra\n", rc));
818
819 /*
820 * Update the logger.
821 */
822 VMMR3UpdateLoggers(pVM);
823}
824
825
826/**
827 * Updates the settings for the GC and R0 loggers.
828 *
829 * @returns VBox status code.
830 * @param pVM The VM handle.
831 */
832VMMR3DECL(int) VMMR3UpdateLoggers(PVM pVM)
833{
834 /*
835 * Simply clone the logger instance (for GC).
836 */
837 int rc = VINF_SUCCESS;
838 RTGCPTR GCPtrLoggerFlush = 0;
839
840 if (pVM->vmm.s.pLoggerHC
841#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
842 || pVM->vmm.s.pRelLoggerHC
843#endif
844 )
845 {
846 rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerFlush", &GCPtrLoggerFlush);
847 AssertReleaseMsgRC(rc, ("vmmGCLoggerFlush not found! rc=%Vra\n", rc));
848 }
849
850 if (pVM->vmm.s.pLoggerHC)
851 {
852 RTGCPTR GCPtrLoggerWrapper = 0;
853 rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCLoggerWrapper", &GCPtrLoggerWrapper);
854 AssertReleaseMsgRC(rc, ("vmmGCLoggerWrapper not found! rc=%Vra\n", rc));
855 pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
856 rc = RTLogCloneGC(NULL /* default */, pVM->vmm.s.pLoggerHC, pVM->vmm.s.cbLoggerGC,
857 GCPtrLoggerWrapper, GCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
858 AssertReleaseMsgRC(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc));
859 }
860
861#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
862 if (pVM->vmm.s.pRelLoggerHC)
863 {
864 RTGCPTR GCPtrLoggerWrapper = 0;
865 rc = PDMR3GetSymbolGC(pVM, VMMGC_MAIN_MODULE_NAME, "vmmGCRelLoggerWrapper", &GCPtrLoggerWrapper);
866 AssertReleaseMsgRC(rc, ("vmmGCRelLoggerWrapper not found! rc=%Vra\n", rc));
867 pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
868 rc = RTLogCloneGC(RTLogRelDefaultInstance(), pVM->vmm.s.pRelLoggerHC, pVM->vmm.s.cbRelLoggerGC,
869 GCPtrLoggerWrapper, GCPtrLoggerFlush, RTLOGFLAGS_BUFFERED);
870 AssertReleaseMsgRC(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc));
871 }
872#endif /* VBOX_WITH_GC_AND_R0_RELEASE_LOG */
873
874 /*
875 * For the ring-0 EMT logger, we use a per-thread logger
876 * instance in ring-0. Only initialize it once.
877 */
878 PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
879 if (pR0Logger)
880 {
881 if (!pR0Logger->fCreated)
882 {
883 RTR0PTR pfnLoggerWrapper = NIL_RTR0PTR;
884 rc = PDMR3GetSymbolR0(pVM, VMMR0_MAIN_MODULE_NAME, "vmmR0LoggerWrapper", &pfnLoggerWrapper);
885 AssertReleaseMsgRCReturn(rc, ("VMMLoggerWrapper not found! rc=%Vra\n", rc), rc);
886
887 RTR0PTR pfnLoggerFlush = NIL_RTR0PTR;
888 rc = PDMR3GetSymbolR0(pVM, VMMR0_MAIN_MODULE_NAME, "vmmR0LoggerFlush", &pfnLoggerFlush);
889 AssertReleaseMsgRCReturn(rc, ("VMMLoggerFlush not found! rc=%Vra\n", rc), rc);
890
891 rc = RTLogCreateForR0(&pR0Logger->Logger, pR0Logger->cbLogger,
892 *(PFNRTLOGGER *)&pfnLoggerWrapper, *(PFNRTLOGFLUSH *)&pfnLoggerFlush,
893 RTLOGFLAGS_BUFFERED, RTLOGDEST_DUMMY);
894 AssertReleaseMsgRCReturn(rc, ("RTLogCloneGC failed! rc=%Vra\n", rc), rc);
895 pR0Logger->fCreated = true;
896 }
897
898 rc = RTLogCopyGroupsAndFlags(&pR0Logger->Logger, NULL /* default */, RTLOGFLAGS_BUFFERED, 0);
899 AssertRC(rc);
900 }
901
902 return rc;
903}
904
905
906/**
907 * Generic switch code relocator.
908 *
909 * @param pVM The VM handle.
910 * @param pSwitcher The switcher definition.
911 * @param pu8CodeR3 Pointer to the core code block for the switcher, ring-3 mapping.
912 * @param pu8CodeR0 Pointer to the core code block for the switcher, ring-0 mapping.
913 * @param GCPtrCode The guest context address corresponding to pu8Code.
914 * @param u32IDCode The identity mapped (ID) address corresponding to pu8Code.
915 * @param SelCS The hypervisor CS selector.
916 * @param SelDS The hypervisor DS selector.
917 * @param SelTSS The hypervisor TSS selector.
918 * @param GCPtrGDT The GC address of the hypervisor GDT.
919 * @param SelCS64 The 64-bit mode hypervisor CS selector.
920 */
921static void vmmR3SwitcherGenericRelocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t *pu8CodeR0, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode,
922 RTSEL SelCS, RTSEL SelDS, RTSEL SelTSS, RTGCPTR GCPtrGDT, RTSEL SelCS64)
923{
924 union
925 {
926 const uint8_t *pu8;
927 const uint16_t *pu16;
928 const uint32_t *pu32;
929 const uint64_t *pu64;
930 const void *pv;
931 uintptr_t u;
932 } u;
933 u.pv = pSwitcher->pvFixups;
934
935 /*
936 * Process fixups.
937 */
938 uint8_t u8;
939 while ((u8 = *u.pu8++) != FIX_THE_END)
940 {
941 /*
942 * Get the source (where to write the fixup).
943 */
944 uint32_t offSrc = *u.pu32++;
945 Assert(offSrc < pSwitcher->cbCode);
946 union
947 {
948 uint8_t *pu8;
949 uint16_t *pu16;
950 uint32_t *pu32;
951 uint64_t *pu64;
952 uintptr_t u;
953 } uSrc;
954 uSrc.pu8 = pu8CodeR3 + offSrc;
955
956 /* The fixup target and method depends on the type. */
957 switch (u8)
958 {
959 /*
960 * 32-bit relative, source in HC and target in GC.
961 */
962 case FIX_HC_2_GC_NEAR_REL:
963 {
964 Assert(offSrc - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offSrc - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
965 uint32_t offTrg = *u.pu32++;
966 Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
967 *uSrc.pu32 = (uint32_t)((GCPtrCode + offTrg) - (uSrc.u + 4));
968 break;
969 }
970
971 /*
972 * 32-bit relative, source in HC and target in ID.
973 */
974 case FIX_HC_2_ID_NEAR_REL:
975 {
976 Assert(offSrc - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offSrc - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
977 uint32_t offTrg = *u.pu32++;
978 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
979 *uSrc.pu32 = (uint32_t)((u32IDCode + offTrg) - (uSrc.u + 4));
980 break;
981 }
982
983 /*
984 * 32-bit relative, source in GC and target in HC.
985 */
986 case FIX_GC_2_HC_NEAR_REL:
987 {
988 Assert(offSrc - pSwitcher->offGCCode < pSwitcher->cbGCCode);
989 uint32_t offTrg = *u.pu32++;
990 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
991 *uSrc.pu32 = (uint32_t)(((uintptr_t)pu8CodeR0 + offTrg) - (GCPtrCode + offSrc + 4));
992 break;
993 }
994
995 /*
996 * 32-bit relative, source in GC and target in ID.
997 */
998 case FIX_GC_2_ID_NEAR_REL:
999 {
1000 Assert(offSrc - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1001 uint32_t offTrg = *u.pu32++;
1002 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1003 *uSrc.pu32 = (uint32_t)((u32IDCode + offTrg) - (GCPtrCode + offSrc + 4));
1004 break;
1005 }
1006
1007 /*
1008 * 32-bit relative, source in ID and target in HC.
1009 */
1010 case FIX_ID_2_HC_NEAR_REL:
1011 {
1012 Assert(offSrc - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offSrc - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1013 uint32_t offTrg = *u.pu32++;
1014 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1015 *uSrc.pu32 = (uint32_t)(((uintptr_t)pu8CodeR0 + offTrg) - (u32IDCode + offSrc + 4));
1016 break;
1017 }
1018
1019 /*
1020 * 32-bit relative, source in ID and target in HC.
1021 */
1022 case FIX_ID_2_GC_NEAR_REL:
1023 {
1024 Assert(offSrc - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offSrc - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1025 uint32_t offTrg = *u.pu32++;
1026 Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1027 *uSrc.pu32 = (uint32_t)((GCPtrCode + offTrg) - (u32IDCode + offSrc + 4));
1028 break;
1029 }
1030
1031 /*
1032 * 16:32 far jump, target in GC.
1033 */
1034 case FIX_GC_FAR32:
1035 {
1036 uint32_t offTrg = *u.pu32++;
1037 Assert(offTrg - pSwitcher->offGCCode < pSwitcher->cbGCCode);
1038 *uSrc.pu32++ = (uint32_t)(GCPtrCode + offTrg);
1039 *uSrc.pu16++ = SelCS;
1040 break;
1041 }
1042
1043 /*
1044 * Make 32-bit GC pointer given CPUM offset.
1045 */
1046 case FIX_GC_CPUM_OFF:
1047 {
1048 uint32_t offCPUM = *u.pu32++;
1049 Assert(offCPUM < sizeof(pVM->cpum));
1050 *uSrc.pu32 = (uint32_t)(VM_GUEST_ADDR(pVM, &pVM->cpum) + offCPUM);
1051 break;
1052 }
1053
1054 /*
1055 * Make 32-bit GC pointer given VM offset.
1056 */
1057 case FIX_GC_VM_OFF:
1058 {
1059 uint32_t offVM = *u.pu32++;
1060 Assert(offVM < sizeof(VM));
1061 *uSrc.pu32 = (uint32_t)(VM_GUEST_ADDR(pVM, pVM) + offVM);
1062 break;
1063 }
1064
1065 /*
1066 * Make 32-bit HC pointer given CPUM offset.
1067 */
1068 case FIX_HC_CPUM_OFF:
1069 {
1070 uint32_t offCPUM = *u.pu32++;
1071 Assert(offCPUM < sizeof(pVM->cpum));
1072 *uSrc.pu32 = (uint32_t)pVM->pVMR0 + RT_OFFSETOF(VM, cpum) + offCPUM;
1073 break;
1074 }
1075
1076 /*
1077 * Make 32-bit R0 pointer given VM offset.
1078 */
1079 case FIX_HC_VM_OFF:
1080 {
1081 uint32_t offVM = *u.pu32++;
1082 Assert(offVM < sizeof(VM));
1083 *uSrc.pu32 = (uint32_t)pVM->pVMR0 + offVM;
1084 break;
1085 }
1086
1087 /*
1088 * Store the 32-Bit CR3 (32-bit) for the intermediate memory context.
1089 */
1090 case FIX_INTER_32BIT_CR3:
1091 {
1092
1093 *uSrc.pu32 = PGMGetInter32BitCR3(pVM);
1094 break;
1095 }
1096
1097 /*
1098 * Store the PAE CR3 (32-bit) for the intermediate memory context.
1099 */
1100 case FIX_INTER_PAE_CR3:
1101 {
1102
1103 *uSrc.pu32 = PGMGetInterPaeCR3(pVM);
1104 break;
1105 }
1106
1107 /*
1108 * Store the AMD64 CR3 (32-bit) for the intermediate memory context.
1109 */
1110 case FIX_INTER_AMD64_CR3:
1111 {
1112
1113 *uSrc.pu32 = PGMGetInterAmd64CR3(pVM);
1114 break;
1115 }
1116
1117 /*
1118 * Store the 32-Bit CR3 (32-bit) for the hypervisor (shadow) memory context.
1119 */
1120 case FIX_HYPER_32BIT_CR3:
1121 {
1122
1123 *uSrc.pu32 = PGMGetHyper32BitCR3(pVM);
1124 break;
1125 }
1126
1127 /*
1128 * Store the PAE CR3 (32-bit) for the hypervisor (shadow) memory context.
1129 */
1130 case FIX_HYPER_PAE_CR3:
1131 {
1132
1133 *uSrc.pu32 = PGMGetHyperPaeCR3(pVM);
1134 break;
1135 }
1136
1137 /*
1138 * Store the AMD64 CR3 (32-bit) for the hypervisor (shadow) memory context.
1139 */
1140 case FIX_HYPER_AMD64_CR3:
1141 {
1142
1143 *uSrc.pu32 = PGMGetHyperAmd64CR3(pVM);
1144 break;
1145 }
1146
1147 /*
1148 * Store Hypervisor CS (16-bit).
1149 */
1150 case FIX_HYPER_CS:
1151 {
1152 *uSrc.pu16 = SelCS;
1153 break;
1154 }
1155
1156 /*
1157 * Store Hypervisor DS (16-bit).
1158 */
1159 case FIX_HYPER_DS:
1160 {
1161 *uSrc.pu16 = SelDS;
1162 break;
1163 }
1164
1165 /*
1166 * Store Hypervisor TSS (16-bit).
1167 */
1168 case FIX_HYPER_TSS:
1169 {
1170 *uSrc.pu16 = SelTSS;
1171 break;
1172 }
1173
1174 /*
1175 * Store the 32-bit GC address of the 2nd dword of the TSS descriptor (in the GDT).
1176 */
1177 case FIX_GC_TSS_GDTE_DW2:
1178 {
1179 RTGCPTR GCPtr = GCPtrGDT + (SelTSS & ~7) + 4;
1180 *uSrc.pu32 = (uint32_t)GCPtr;
1181 break;
1182 }
1183
1184
1185 ///@todo case FIX_CR4_MASK:
1186 ///@todo case FIX_CR4_OSFSXR:
1187
1188 /*
1189 * Insert relative jump to specified target it FXSAVE/FXRSTOR isn't supported by the cpu.
1190 */
1191 case FIX_NO_FXSAVE_JMP:
1192 {
1193 uint32_t offTrg = *u.pu32++;
1194 Assert(offTrg < pSwitcher->cbCode);
1195 if (!CPUMSupportsFXSR(pVM))
1196 {
1197 *uSrc.pu8++ = 0xe9; /* jmp rel32 */
1198 *uSrc.pu32++ = offTrg - (offSrc + 5);
1199 }
1200 else
1201 {
1202 *uSrc.pu8++ = *((uint8_t *)pSwitcher->pvCode + offSrc);
1203 *uSrc.pu32++ = *(uint32_t *)((uint8_t *)pSwitcher->pvCode + offSrc + 1);
1204 }
1205 break;
1206 }
1207
1208 /*
1209 * Insert relative jump to specified target it SYSENTER isn't used by the host.
1210 */
1211 case FIX_NO_SYSENTER_JMP:
1212 {
1213 uint32_t offTrg = *u.pu32++;
1214 Assert(offTrg < pSwitcher->cbCode);
1215 if (!CPUMIsHostUsingSysEnter(pVM))
1216 {
1217 *uSrc.pu8++ = 0xe9; /* jmp rel32 */
1218 *uSrc.pu32++ = offTrg - (offSrc + 5);
1219 }
1220 else
1221 {
1222 *uSrc.pu8++ = *((uint8_t *)pSwitcher->pvCode + offSrc);
1223 *uSrc.pu32++ = *(uint32_t *)((uint8_t *)pSwitcher->pvCode + offSrc + 1);
1224 }
1225 break;
1226 }
1227
1228 /*
1229 * Insert relative jump to specified target it SYSENTER isn't used by the host.
1230 */
1231 case FIX_NO_SYSCALL_JMP:
1232 {
1233 uint32_t offTrg = *u.pu32++;
1234 Assert(offTrg < pSwitcher->cbCode);
1235 if (!CPUMIsHostUsingSysEnter(pVM))
1236 {
1237 *uSrc.pu8++ = 0xe9; /* jmp rel32 */
1238 *uSrc.pu32++ = offTrg - (offSrc + 5);
1239 }
1240 else
1241 {
1242 *uSrc.pu8++ = *((uint8_t *)pSwitcher->pvCode + offSrc);
1243 *uSrc.pu32++ = *(uint32_t *)((uint8_t *)pSwitcher->pvCode + offSrc + 1);
1244 }
1245 break;
1246 }
1247
1248 /*
1249 * 32-bit HC pointer fixup to (HC) target within the code (32-bit offset).
1250 */
1251 case FIX_HC_32BIT:
1252 {
1253 uint32_t offTrg = *u.pu32++;
1254 Assert(offSrc < pSwitcher->cbCode);
1255 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1256 *uSrc.pu32 = (uintptr_t)pu8CodeR0 + offTrg;
1257 break;
1258 }
1259
1260#if defined(RT_ARCH_AMD64) || defined(VBOX_WITH_HYBIRD_32BIT_KERNEL)
1261 /*
1262 * 64-bit HC pointer fixup to (HC) target within the code (32-bit offset).
1263 */
1264 case FIX_HC_64BIT:
1265 {
1266 uint32_t offTrg = *u.pu32++;
1267 Assert(offSrc < pSwitcher->cbCode);
1268 Assert(offTrg - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0 || offTrg - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1);
1269 *uSrc.pu64 = (uintptr_t)pu8CodeR0 + offTrg;
1270 break;
1271 }
1272
1273 /*
1274 * 64-bit HC Code Selector (no argument).
1275 */
1276 case FIX_HC_64BIT_CS:
1277 {
1278 Assert(offSrc < pSwitcher->cbCode);
1279#if defined(RT_OS_DARWIN) && defined(VBOX_WITH_HYBIRD_32BIT_KERNEL)
1280 *uSrc.pu16 = 0x80; /* KERNEL64_CS from i386/seg.h */
1281#else
1282 AssertFatalMsgFailed(("FIX_HC_64BIT_CS not implemented for this host\n"));
1283#endif
1284 break;
1285 }
1286
1287 /*
1288 * 64-bit HC pointer to the CPUM instance data (no argument).
1289 */
1290 case FIX_HC_64BIT_CPUM:
1291 {
1292 Assert(offSrc < pSwitcher->cbCode);
1293 *uSrc.pu64 = pVM->pVMR0 + RT_OFFSETOF(VM, cpum);
1294 break;
1295 }
1296#endif
1297
1298 /*
1299 * 32-bit ID pointer to (ID) target within the code (32-bit offset).
1300 */
1301 case FIX_ID_32BIT:
1302 {
1303 uint32_t offTrg = *u.pu32++;
1304 Assert(offSrc < pSwitcher->cbCode);
1305 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1306 *uSrc.pu32 = u32IDCode + offTrg;
1307 break;
1308 }
1309
1310 /*
1311 * 64-bit ID pointer to (ID) target within the code (32-bit offset).
1312 */
1313 case FIX_ID_64BIT:
1314 {
1315 uint32_t offTrg = *u.pu32++;
1316 Assert(offSrc < pSwitcher->cbCode);
1317 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1318 *uSrc.pu64 = u32IDCode + offTrg;
1319 break;
1320 }
1321
1322 /*
1323 * Far 16:32 ID pointer to 64-bit mode (ID) target within the code (32-bit offset).
1324 */
1325 case FIX_ID_FAR32_TO_64BIT_MODE:
1326 {
1327 uint32_t offTrg = *u.pu32++;
1328 Assert(offSrc < pSwitcher->cbCode);
1329 Assert(offTrg - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0 || offTrg - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1);
1330 *uSrc.pu32++ = u32IDCode + offTrg;
1331 *uSrc.pu16 = SelCS64;
1332 AssertRelease(SelCS64);
1333 break;
1334 }
1335
1336#ifdef VBOX_WITH_NMI
1337 /*
1338 * 32-bit address to the APIC base.
1339 */
1340 case FIX_GC_APIC_BASE_32BIT:
1341 {
1342 *uSrc.pu32 = pVM->vmm.s.GCPtrApicBase;
1343 break;
1344 }
1345#endif
1346
1347 default:
1348 AssertReleaseMsgFailed(("Unknown fixup %d in switcher %s\n", u8, pSwitcher->pszDesc));
1349 break;
1350 }
1351 }
1352
1353#ifdef LOG_ENABLED
1354 /*
1355 * If Log2 is enabled disassemble the switcher code.
1356 *
1357 * The switcher code have 1-2 HC parts, 1 GC part and 0-2 ID parts.
1358 */
1359 if (LogIs2Enabled())
1360 {
1361 RTLogPrintf("*** Disassembly of switcher %d '%s' %#x bytes ***\n"
1362 " pu8CodeR0 = %p\n"
1363 " pu8CodeR3 = %p\n"
1364 " GCPtrCode = %VGv\n"
1365 " u32IDCode = %08x\n"
1366 " pVMGC = %VGv\n"
1367 " pCPUMGC = %VGv\n"
1368 " pVMHC = %p\n"
1369 " pCPUMHC = %p\n"
1370 " GCPtrGDT = %VGv\n"
1371 " InterCR3s = %08x, %08x, %08x (32-Bit, PAE, AMD64)\n"
1372 " HyperCR3s = %08x, %08x, %08x (32-Bit, PAE, AMD64)\n"
1373 " SelCS = %04x\n"
1374 " SelDS = %04x\n"
1375 " SelCS64 = %04x\n"
1376 " SelTSS = %04x\n",
1377 pSwitcher->enmType, pSwitcher->pszDesc, pSwitcher->cbCode,
1378 pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode, VM_GUEST_ADDR(pVM, pVM),
1379 VM_GUEST_ADDR(pVM, &pVM->cpum), pVM, &pVM->cpum,
1380 GCPtrGDT,
1381 PGMGetHyper32BitCR3(pVM), PGMGetHyperPaeCR3(pVM), PGMGetHyperAmd64CR3(pVM),
1382 PGMGetInter32BitCR3(pVM), PGMGetInterPaeCR3(pVM), PGMGetInterAmd64CR3(pVM),
1383 SelCS, SelDS, SelCS64, SelTSS);
1384
1385 uint32_t offCode = 0;
1386 while (offCode < pSwitcher->cbCode)
1387 {
1388 /*
1389 * Figure out where this is.
1390 */
1391 const char *pszDesc = NULL;
1392 RTUINTPTR uBase;
1393 uint32_t cbCode;
1394 if (offCode - pSwitcher->offHCCode0 < pSwitcher->cbHCCode0)
1395 {
1396 pszDesc = "HCCode0";
1397 uBase = (RTUINTPTR)pu8CodeR0;
1398 offCode = pSwitcher->offHCCode0;
1399 cbCode = pSwitcher->cbHCCode0;
1400 }
1401 else if (offCode - pSwitcher->offHCCode1 < pSwitcher->cbHCCode1)
1402 {
1403 pszDesc = "HCCode1";
1404 uBase = (RTUINTPTR)pu8CodeR0;
1405 offCode = pSwitcher->offHCCode1;
1406 cbCode = pSwitcher->cbHCCode1;
1407 }
1408 else if (offCode - pSwitcher->offGCCode < pSwitcher->cbGCCode)
1409 {
1410 pszDesc = "GCCode";
1411 uBase = GCPtrCode;
1412 offCode = pSwitcher->offGCCode;
1413 cbCode = pSwitcher->cbGCCode;
1414 }
1415 else if (offCode - pSwitcher->offIDCode0 < pSwitcher->cbIDCode0)
1416 {
1417 pszDesc = "IDCode0";
1418 uBase = u32IDCode;
1419 offCode = pSwitcher->offIDCode0;
1420 cbCode = pSwitcher->cbIDCode0;
1421 }
1422 else if (offCode - pSwitcher->offIDCode1 < pSwitcher->cbIDCode1)
1423 {
1424 pszDesc = "IDCode1";
1425 uBase = u32IDCode;
1426 offCode = pSwitcher->offIDCode1;
1427 cbCode = pSwitcher->cbIDCode1;
1428 }
1429 else
1430 {
1431 RTLogPrintf(" %04x: %02x '%c' (nowhere)\n",
1432 offCode, pu8CodeR3[offCode], isprint(pu8CodeR3[offCode]) ? pu8CodeR3[offCode] : ' ');
1433 offCode++;
1434 continue;
1435 }
1436
1437 /*
1438 * Disassemble it.
1439 */
1440 RTLogPrintf(" %s: offCode=%#x cbCode=%#x\n", pszDesc, offCode, cbCode);
1441 DISCPUSTATE Cpu = {0};
1442 Cpu.mode = CPUMODE_32BIT;
1443 while (cbCode > 0)
1444 {
1445 /* try label it */
1446 if (pSwitcher->offR0HostToGuest == offCode)
1447 RTLogPrintf(" *R0HostToGuest:\n");
1448 if (pSwitcher->offGCGuestToHost == offCode)
1449 RTLogPrintf(" *GCGuestToHost:\n");
1450 if (pSwitcher->offGCCallTrampoline == offCode)
1451 RTLogPrintf(" *GCCallTrampoline:\n");
1452 if (pSwitcher->offGCGuestToHostAsm == offCode)
1453 RTLogPrintf(" *GCGuestToHostAsm:\n");
1454 if (pSwitcher->offGCGuestToHostAsmHyperCtx == offCode)
1455 RTLogPrintf(" *GCGuestToHostAsmHyperCtx:\n");
1456 if (pSwitcher->offGCGuestToHostAsmGuestCtx == offCode)
1457 RTLogPrintf(" *GCGuestToHostAsmGuestCtx:\n");
1458
1459 /* disas */
1460 uint32_t cbInstr = 0;
1461 char szDisas[256];
1462 if (DISInstr(&Cpu, (RTUINTPTR)pu8CodeR3 + offCode, uBase - (RTUINTPTR)pu8CodeR3, &cbInstr, szDisas))
1463 RTLogPrintf(" %04x: %s", offCode, szDisas); //for whatever reason szDisas includes '\n'.
1464 else
1465 {
1466 RTLogPrintf(" %04x: %02x '%c'\n",
1467 offCode, pu8CodeR3[offCode], isprint(pu8CodeR3[offCode]) ? pu8CodeR3[offCode] : ' ');
1468 cbInstr = 1;
1469 }
1470 offCode += cbInstr;
1471 cbCode -= RT_MIN(cbInstr, cbCode);
1472 }
1473 }
1474 }
1475#endif
1476}
1477
1478
1479/**
1480 * Relocator for the 32-Bit to 32-Bit world switcher.
1481 */
1482DECLCALLBACK(void) vmmR3Switcher32BitTo32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t *pu8CodeR0, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1483{
1484 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1485 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1486}
1487
1488
1489/**
1490 * Relocator for the 32-Bit to PAE world switcher.
1491 */
1492DECLCALLBACK(void) vmmR3Switcher32BitToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t *pu8CodeR0, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1493{
1494 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1495 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1496}
1497
1498
1499/**
1500 * Relocator for the PAE to 32-Bit world switcher.
1501 */
1502DECLCALLBACK(void) vmmR3SwitcherPAETo32Bit_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t *pu8CodeR0, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1503{
1504 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1505 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1506}
1507
1508
1509/**
1510 * Relocator for the PAE to PAE world switcher.
1511 */
1512DECLCALLBACK(void) vmmR3SwitcherPAEToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t *pu8CodeR0, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1513{
1514 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1515 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), 0);
1516}
1517
1518
1519/**
1520 * Relocator for the AMD64 to PAE world switcher.
1521 */
1522DECLCALLBACK(void) vmmR3SwitcherAMD64ToPAE_Relocate(PVM pVM, PVMMSWITCHERDEF pSwitcher, uint8_t *pu8CodeR0, uint8_t *pu8CodeR3, RTGCPTR GCPtrCode, uint32_t u32IDCode)
1523{
1524 vmmR3SwitcherGenericRelocate(pVM, pSwitcher, pu8CodeR0, pu8CodeR3, GCPtrCode, u32IDCode,
1525 SELMGetHyperCS(pVM), SELMGetHyperDS(pVM), SELMGetHyperTSS(pVM), SELMGetHyperGDT(pVM), SELMGetHyperCS64(pVM));
1526}
1527
1528
1529/**
1530 * Gets the pointer to g_szRTAssertMsg1 in GC.
1531 * @returns Pointer to VMMGC::g_szRTAssertMsg1.
1532 * Returns NULL if not present.
1533 * @param pVM The VM handle.
1534 */
1535VMMR3DECL(const char *) VMMR3GetGCAssertMsg1(PVM pVM)
1536{
1537 RTGCPTR GCPtr;
1538 int rc = PDMR3GetSymbolGC(pVM, NULL, "g_szRTAssertMsg1", &GCPtr);
1539 if (VBOX_SUCCESS(rc))
1540 return (const char *)MMHyperGC2HC(pVM, GCPtr);
1541 return NULL;
1542}
1543
1544
1545/**
1546 * Gets the pointer to g_szRTAssertMsg2 in GC.
1547 * @returns Pointer to VMMGC::g_szRTAssertMsg2.
1548 * Returns NULL if not present.
1549 * @param pVM The VM handle.
1550 */
1551VMMR3DECL(const char *) VMMR3GetGCAssertMsg2(PVM pVM)
1552{
1553 RTGCPTR GCPtr;
1554 int rc = PDMR3GetSymbolGC(pVM, NULL, "g_szRTAssertMsg2", &GCPtr);
1555 if (VBOX_SUCCESS(rc))
1556 return (const char *)MMHyperGC2HC(pVM, GCPtr);
1557 return NULL;
1558}
1559
1560
1561/**
1562 * Execute state save operation.
1563 *
1564 * @returns VBox status code.
1565 * @param pVM VM Handle.
1566 * @param pSSM SSM operation handle.
1567 */
1568static DECLCALLBACK(int) vmmR3Save(PVM pVM, PSSMHANDLE pSSM)
1569{
1570 LogFlow(("vmmR3Save:\n"));
1571
1572 /*
1573 * The hypervisor stack.
1574 */
1575 SSMR3PutGCPtr(pSSM, pVM->vmm.s.pbGCStackBottom);
1576 RTGCPTR GCPtrESP = CPUMGetHyperESP(pVM);
1577 Assert(pVM->vmm.s.pbGCStackBottom - GCPtrESP <= VMM_STACK_SIZE);
1578 SSMR3PutGCPtr(pSSM, GCPtrESP);
1579 SSMR3PutMem(pSSM, pVM->vmm.s.pbHCStack, VMM_STACK_SIZE);
1580 return SSMR3PutU32(pSSM, ~0); /* terminator */
1581}
1582
1583
1584/**
1585 * Execute state load operation.
1586 *
1587 * @returns VBox status code.
1588 * @param pVM VM Handle.
1589 * @param pSSM SSM operation handle.
1590 * @param u32Version Data layout version.
1591 */
1592static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version)
1593{
1594 LogFlow(("vmmR3Load:\n"));
1595
1596 /*
1597 * Validate version.
1598 */
1599 if (u32Version != VMM_SAVED_STATE_VERSION)
1600 {
1601 Log(("vmmR3Load: Invalid version u32Version=%d!\n", u32Version));
1602 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1603 }
1604
1605 /*
1606 * Check that the stack is in the same place, or that it's fearly empty.
1607 */
1608 RTGCPTR GCPtrStackBottom;
1609 SSMR3GetGCPtr(pSSM, &GCPtrStackBottom);
1610 RTGCPTR GCPtrESP;
1611 int rc = SSMR3GetGCPtr(pSSM, &GCPtrESP);
1612 if (VBOX_FAILURE(rc))
1613 return rc;
1614 if ( GCPtrStackBottom == pVM->vmm.s.pbGCStackBottom
1615 || (GCPtrStackBottom - GCPtrESP < 32)) /** @todo This will break if we start preemting the hypervisor. */
1616 {
1617 /*
1618 * We *must* set the ESP because the CPUM load + PGM load relocations will render
1619 * the ESP in CPUM fatally invalid.
1620 */
1621 CPUMSetHyperESP(pVM, GCPtrESP);
1622
1623 /* restore the stack. */
1624 SSMR3GetMem(pSSM, pVM->vmm.s.pbHCStack, VMM_STACK_SIZE);
1625
1626 /* terminator */
1627 uint32_t u32;
1628 rc = SSMR3GetU32(pSSM, &u32);
1629 if (VBOX_FAILURE(rc))
1630 return rc;
1631 if (u32 != ~0U)
1632 {
1633 AssertMsgFailed(("u32=%#x\n", u32));
1634 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1635 }
1636 return VINF_SUCCESS;
1637 }
1638
1639 LogRel(("The stack is not in the same place and it's not empty! GCPtrStackBottom=%VGv pbGCStackBottom=%VGv ESP=%VGv\n",
1640 GCPtrStackBottom, pVM->vmm.s.pbGCStackBottom, GCPtrESP));
1641 if (SSMR3HandleGetAfter(pSSM) == SSMAFTER_DEBUG_IT)
1642 return VINF_SUCCESS; /* ignore this */
1643 AssertFailed();
1644 return VERR_SSM_LOAD_CONFIG_MISMATCH;
1645}
1646
1647
1648/**
1649 * Selects the switcher to be used for switching to GC.
1650 *
1651 * @returns VBox status code.
1652 * @param pVM VM handle.
1653 * @param enmSwitcher The new switcher.
1654 * @remark This function may be called before the VMM is initialized.
1655 */
1656VMMR3DECL(int) VMMR3SelectSwitcher(PVM pVM, VMMSWITCHER enmSwitcher)
1657{
1658 /*
1659 * Validate input.
1660 */
1661 if ( enmSwitcher < VMMSWITCHER_INVALID
1662 || enmSwitcher >= VMMSWITCHER_MAX)
1663 {
1664 AssertMsgFailed(("Invalid input enmSwitcher=%d\n", enmSwitcher));
1665 return VERR_INVALID_PARAMETER;
1666 }
1667
1668 /*
1669 * Select the new switcher.
1670 */
1671 PVMMSWITCHERDEF pSwitcher = s_apSwitchers[enmSwitcher];
1672 if (pSwitcher)
1673 {
1674 Log(("VMMR3SelectSwitcher: enmSwitcher %d -> %d %s\n", pVM->vmm.s.enmSwitcher, enmSwitcher, pSwitcher->pszDesc));
1675 pVM->vmm.s.enmSwitcher = enmSwitcher;
1676
1677 RTR0PTR pbCodeR0 = (RTR0PTR)pVM->vmm.s.pvHCCoreCodeR0 + pVM->vmm.s.aoffSwitchers[enmSwitcher]; /** @todo fix the pvHCCoreCodeR0 type */
1678 pVM->vmm.s.pfnR0HostToGuest = pbCodeR0 + pSwitcher->offR0HostToGuest;
1679
1680 RTGCPTR GCPtr = pVM->vmm.s.pvGCCoreCode + pVM->vmm.s.aoffSwitchers[enmSwitcher];
1681 pVM->vmm.s.pfnGCGuestToHost = GCPtr + pSwitcher->offGCGuestToHost;
1682 pVM->vmm.s.pfnGCCallTrampoline = GCPtr + pSwitcher->offGCCallTrampoline;
1683 pVM->pfnVMMGCGuestToHostAsm = GCPtr + pSwitcher->offGCGuestToHostAsm;
1684 pVM->pfnVMMGCGuestToHostAsmHyperCtx = GCPtr + pSwitcher->offGCGuestToHostAsmHyperCtx;
1685 pVM->pfnVMMGCGuestToHostAsmGuestCtx = GCPtr + pSwitcher->offGCGuestToHostAsmGuestCtx;
1686 return VINF_SUCCESS;
1687 }
1688 return VERR_NOT_IMPLEMENTED;
1689}
1690
1691/**
1692 * Disable the switcher logic permanently.
1693 *
1694 * @returns VBox status code.
1695 * @param pVM VM handle.
1696 */
1697VMMR3DECL(int) VMMR3DisableSwitcher(PVM pVM)
1698{
1699/** @todo r=bird: I would suggest that we create a dummy switcher which just does something like:
1700 * @code
1701 * mov eax, VERR_INTERNAL_ERROR
1702 * ret
1703 * @endcode
1704 * And then check for fSwitcherDisabled in VMMR3SelectSwitcher() in order to prevent it from being removed.
1705 */
1706 pVM->vmm.s.fSwitcherDisabled = true;
1707 return VINF_SUCCESS;
1708}
1709
1710
1711/**
1712 * Resolve a builtin GC symbol.
1713 * Called by PDM when loading or relocating GC modules.
1714 *
1715 * @returns VBox status
1716 * @param pVM VM Handle.
1717 * @param pszSymbol Symbol to resolv
1718 * @param pGCPtrValue Where to store the symbol value.
1719 * @remark This has to work before VMMR3Relocate() is called.
1720 */
1721VMMR3DECL(int) VMMR3GetImportGC(PVM pVM, const char *pszSymbol, PRTGCPTR pGCPtrValue)
1722{
1723 if (!strcmp(pszSymbol, "g_Logger"))
1724 {
1725 if (pVM->vmm.s.pLoggerHC)
1726 pVM->vmm.s.pLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pLoggerHC);
1727 *pGCPtrValue = pVM->vmm.s.pLoggerGC;
1728 }
1729 else if (!strcmp(pszSymbol, "g_RelLogger"))
1730 {
1731#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
1732 if (pVM->vmm.s.pRelLoggerHC)
1733 pVM->vmm.s.pRelLoggerGC = MMHyperHC2GC(pVM, pVM->vmm.s.pRelLoggerHC);
1734 *pGCPtrValue = pVM->vmm.s.pRelLoggerGC;
1735#else
1736 *pGCPtrValue = NIL_RTGCPTR;
1737#endif
1738 }
1739 else
1740 return VERR_SYMBOL_NOT_FOUND;
1741 return VINF_SUCCESS;
1742}
1743
1744
1745/**
1746 * Suspends the the CPU yielder.
1747 *
1748 * @param pVM The VM handle.
1749 */
1750VMMR3DECL(void) VMMR3YieldSuspend(PVM pVM)
1751{
1752 if (!pVM->vmm.s.cYieldResumeMillies)
1753 {
1754 uint64_t u64Now = TMTimerGet(pVM->vmm.s.pYieldTimer);
1755 uint64_t u64Expire = TMTimerGetExpire(pVM->vmm.s.pYieldTimer);
1756 if (u64Now >= u64Expire || u64Expire == ~(uint64_t)0)
1757 pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
1758 else
1759 pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM->vmm.s.pYieldTimer, u64Expire - u64Now);
1760 TMTimerStop(pVM->vmm.s.pYieldTimer);
1761 }
1762 pVM->vmm.s.u64LastYield = RTTimeNanoTS();
1763}
1764
1765
1766/**
1767 * Stops the the CPU yielder.
1768 *
1769 * @param pVM The VM handle.
1770 */
1771VMMR3DECL(void) VMMR3YieldStop(PVM pVM)
1772{
1773 if (!pVM->vmm.s.cYieldResumeMillies)
1774 TMTimerStop(pVM->vmm.s.pYieldTimer);
1775 pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
1776 pVM->vmm.s.u64LastYield = RTTimeNanoTS();
1777}
1778
1779
1780/**
1781 * Resumes the CPU yielder when it has been a suspended or stopped.
1782 *
1783 * @param pVM The VM handle.
1784 */
1785VMMR3DECL(void) VMMR3YieldResume(PVM pVM)
1786{
1787 if (pVM->vmm.s.cYieldResumeMillies)
1788 {
1789 TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldResumeMillies);
1790 pVM->vmm.s.cYieldResumeMillies = 0;
1791 }
1792}
1793
1794
1795/**
1796 * Internal timer callback function.
1797 *
1798 * @param pVM The VM.
1799 * @param pTimer The timer handle.
1800 * @param pvUser User argument specified upon timer creation.
1801 */
1802static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser)
1803{
1804 /*
1805 * This really needs some careful tuning. While we shouldn't be too gready since
1806 * that'll cause the rest of the system to stop up, we shouldn't be too nice either
1807 * because that'll cause us to stop up.
1808 *
1809 * The current logic is to use the default interval when there is no lag worth
1810 * mentioning, but when we start accumulating lag we don't bother yielding at all.
1811 *
1812 * (This depends on the TMCLOCK_VIRTUAL_SYNC to be scheduled before TMCLOCK_REAL
1813 * so the lag is up to date.)
1814 */
1815 const uint64_t u64Lag = TMVirtualSyncGetLag(pVM);
1816 if ( u64Lag < 50000000 /* 50ms */
1817 || ( u64Lag < 1000000000 /* 1s */
1818 && RTTimeNanoTS() - pVM->vmm.s.u64LastYield < 500000000 /* 500 ms */)
1819 )
1820 {
1821 uint64_t u64Elapsed = RTTimeNanoTS();
1822 pVM->vmm.s.u64LastYield = u64Elapsed;
1823
1824 RTThreadYield();
1825
1826#ifdef LOG_ENABLED
1827 u64Elapsed = RTTimeNanoTS() - u64Elapsed;
1828 Log(("vmmR3YieldEMT: %RI64 ns\n", u64Elapsed));
1829#endif
1830 }
1831 TMTimerSetMillies(pTimer, pVM->vmm.s.cYieldEveryMillies);
1832}
1833
1834
1835/**
1836 * Acquire global VM lock.
1837 *
1838 * @returns VBox status code
1839 * @param pVM The VM to operate on.
1840 */
1841VMMR3DECL(int) VMMR3Lock(PVM pVM)
1842{
1843 return RTCritSectEnter(&pVM->vmm.s.CritSectVMLock);
1844}
1845
1846
1847/**
1848 * Release global VM lock.
1849 *
1850 * @returns VBox status code
1851 * @param pVM The VM to operate on.
1852 */
1853VMMR3DECL(int) VMMR3Unlock(PVM pVM)
1854{
1855 return RTCritSectLeave(&pVM->vmm.s.CritSectVMLock);
1856}
1857
1858
1859/**
1860 * Return global VM lock owner.
1861 *
1862 * @returns Thread id of owner.
1863 * @returns NIL_RTTHREAD if no owner.
1864 * @param pVM The VM to operate on.
1865 */
1866VMMR3DECL(RTNATIVETHREAD) VMMR3LockGetOwner(PVM pVM)
1867{
1868 return RTCritSectGetOwner(&pVM->vmm.s.CritSectVMLock);
1869}
1870
1871
1872/**
1873 * Checks if the current thread is the owner of the global VM lock.
1874 *
1875 * @returns true if owner.
1876 * @returns false if not owner.
1877 * @param pVM The VM to operate on.
1878 */
1879VMMR3DECL(bool) VMMR3LockIsOwner(PVM pVM)
1880{
1881 return RTCritSectIsOwner(&pVM->vmm.s.CritSectVMLock);
1882}
1883
1884
1885/**
1886 * Executes guest code.
1887 *
1888 * @param pVM VM handle.
1889 */
1890VMMR3DECL(int) VMMR3RawRunGC(PVM pVM)
1891{
1892 Log2(("VMMR3RawRunGC: (cs:eip=%04x:%08x)\n", CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1893
1894 /*
1895 * Set the EIP and ESP.
1896 */
1897 CPUMSetHyperEIP(pVM, CPUMGetGuestEFlags(pVM) & X86_EFL_VM
1898 ? pVM->vmm.s.pfnCPUMGCResumeGuestV86
1899 : pVM->vmm.s.pfnCPUMGCResumeGuest);
1900 CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStackBottom);
1901
1902 /*
1903 * We hide log flushes (outer) and hypervisor interrupts (inner).
1904 */
1905 for (;;)
1906 {
1907 int rc;
1908 do
1909 {
1910#ifdef NO_SUPCALLR0VMM
1911 rc = VERR_GENERAL_FAILURE;
1912#else
1913 rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_RAW_RUN, NULL);
1914#endif
1915 } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
1916
1917 /*
1918 * Flush the logs.
1919 */
1920#ifdef LOG_ENABLED
1921 PRTLOGGERGC pLogger = pVM->vmm.s.pLoggerHC;
1922 if ( pLogger
1923 && pLogger->offScratch > 0)
1924 RTLogFlushGC(NULL, pLogger);
1925#endif
1926#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
1927 PRTLOGGERGC pRelLogger = pVM->vmm.s.pRelLoggerHC;
1928 if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
1929 RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
1930#endif
1931 if (rc != VINF_VMM_CALL_HOST)
1932 {
1933 Log2(("VMMR3RawRunGC: returns %Vrc (cs:eip=%04x:%08x)\n", rc, CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1934 return rc;
1935 }
1936 rc = vmmR3ServiceCallHostRequest(pVM);
1937 if (VBOX_FAILURE(rc))
1938 return rc;
1939 /* Resume GC */
1940 }
1941}
1942
1943
1944/**
1945 * Executes guest code (Intel VMX and AMD SVM).
1946 *
1947 * @param pVM VM handle.
1948 */
1949VMMR3DECL(int) VMMR3HwAccRunGC(PVM pVM)
1950{
1951 Log2(("VMMR3HwAccRunGC: (cs:eip=%04x:%08x)\n", CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1952
1953 for (;;)
1954 {
1955 int rc;
1956 do
1957 {
1958#ifdef NO_SUPCALLR0VMM
1959 rc = VERR_GENERAL_FAILURE;
1960#else
1961 rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_HWACC_RUN, NULL);
1962#endif
1963 } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
1964
1965#ifdef LOG_ENABLED
1966 /*
1967 * Flush the log
1968 */
1969 PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
1970 if ( pR0Logger
1971 && pR0Logger->Logger.offScratch > 0)
1972 RTLogFlushToLogger(&pR0Logger->Logger, NULL);
1973#endif /* !LOG_ENABLED */
1974 if (rc != VINF_VMM_CALL_HOST)
1975 {
1976 Log2(("VMMR3HwAccRunGC: returns %Vrc (cs:eip=%04x:%08x)\n", rc, CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
1977 return rc;
1978 }
1979 rc = vmmR3ServiceCallHostRequest(pVM);
1980 if (VBOX_FAILURE(rc))
1981 return rc;
1982 /* Resume R0 */
1983 }
1984}
1985
1986/**
1987 * Calls GC a function.
1988 *
1989 * @param pVM The VM handle.
1990 * @param GCPtrEntry The GC function address.
1991 * @param cArgs The number of arguments in the ....
1992 * @param ... Arguments to the function.
1993 */
1994VMMR3DECL(int) VMMR3CallGC(PVM pVM, RTGCPTR GCPtrEntry, unsigned cArgs, ...)
1995{
1996 va_list args;
1997 va_start(args, cArgs);
1998 int rc = VMMR3CallGCV(pVM, GCPtrEntry, cArgs, args);
1999 va_end(args);
2000 return rc;
2001}
2002
2003
2004/**
2005 * Calls GC a function.
2006 *
2007 * @param pVM The VM handle.
2008 * @param GCPtrEntry The GC function address.
2009 * @param cArgs The number of arguments in the ....
2010 * @param args Arguments to the function.
2011 */
2012VMMR3DECL(int) VMMR3CallGCV(PVM pVM, RTGCPTR GCPtrEntry, unsigned cArgs, va_list args)
2013{
2014 Log2(("VMMR3CallGCV: GCPtrEntry=%VGv cArgs=%d\n", GCPtrEntry, cArgs));
2015
2016 /*
2017 * Setup the call frame using the trampoline.
2018 */
2019 CPUMHyperSetCtxCore(pVM, NULL);
2020 memset(pVM->vmm.s.pbHCStack, 0xaa, VMM_STACK_SIZE); /* Clear the stack. */
2021 CPUMSetHyperESP(pVM, pVM->vmm.s.pbGCStackBottom - cArgs * sizeof(RTGCUINTPTR));
2022 PRTGCUINTPTR pFrame = (PRTGCUINTPTR)(pVM->vmm.s.pbHCStack + VMM_STACK_SIZE) - cArgs;
2023 int i = cArgs;
2024 while (i-- > 0)
2025 *pFrame++ = va_arg(args, RTGCUINTPTR);
2026
2027 CPUMPushHyper(pVM, cArgs * sizeof(RTGCUINTPTR)); /* stack frame size */
2028 CPUMPushHyper(pVM, GCPtrEntry); /* what to call */
2029 CPUMSetHyperEIP(pVM, pVM->vmm.s.pfnGCCallTrampoline);
2030
2031 /*
2032 * We hide log flushes (outer) and hypervisor interrupts (inner).
2033 */
2034 for (;;)
2035 {
2036 int rc;
2037 do
2038 {
2039#ifdef NO_SUPCALLR0VMM
2040 rc = VERR_GENERAL_FAILURE;
2041#else
2042 rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_RAW_RUN, NULL);
2043#endif
2044 } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
2045
2046 /*
2047 * Flush the logs.
2048 */
2049#ifdef LOG_ENABLED
2050 PRTLOGGERGC pLogger = pVM->vmm.s.pLoggerHC;
2051 if ( pLogger
2052 && pLogger->offScratch > 0)
2053 RTLogFlushGC(NULL, pLogger);
2054#endif
2055#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
2056 PRTLOGGERGC pRelLogger = pVM->vmm.s.pRelLoggerHC;
2057 if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
2058 RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
2059#endif
2060 if (rc == VERR_TRPM_PANIC || rc == VERR_TRPM_DONT_PANIC)
2061 VMMR3FatalDump(pVM, rc);
2062 if (rc != VINF_VMM_CALL_HOST)
2063 {
2064 Log2(("VMMR3CallGCV: returns %Vrc (cs:eip=%04x:%08x)\n", rc, CPUMGetGuestCS(pVM), CPUMGetGuestEIP(pVM)));
2065 return rc;
2066 }
2067 rc = vmmR3ServiceCallHostRequest(pVM);
2068 if (VBOX_FAILURE(rc))
2069 return rc;
2070 }
2071}
2072
2073
2074/**
2075 * Resumes executing hypervisor code when interrupted
2076 * by a queue flush or a debug event.
2077 *
2078 * @returns VBox status code.
2079 * @param pVM VM handle.
2080 */
2081VMMR3DECL(int) VMMR3ResumeHyper(PVM pVM)
2082{
2083 Log(("VMMR3ResumeHyper: eip=%VGv esp=%VGv\n", CPUMGetHyperEIP(pVM), CPUMGetHyperESP(pVM)));
2084
2085 /*
2086 * We hide log flushes (outer) and hypervisor interrupts (inner).
2087 */
2088 for (;;)
2089 {
2090 int rc;
2091 do
2092 {
2093#ifdef NO_SUPCALLR0VMM
2094 rc = VERR_GENERAL_FAILURE;
2095#else
2096 rc = SUPCallVMMR0(pVM->pVMR0, VMMR0_DO_RAW_RUN, NULL);
2097#endif
2098 } while (rc == VINF_EM_RAW_INTERRUPT_HYPER);
2099
2100 /*
2101 * Flush the loggers,
2102 */
2103#ifdef LOG_ENABLED
2104 PRTLOGGERGC pLogger = pVM->vmm.s.pLoggerHC;
2105 if ( pLogger
2106 && pLogger->offScratch > 0)
2107 RTLogFlushGC(NULL, pLogger);
2108#endif
2109#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
2110 PRTLOGGERGC pRelLogger = pVM->vmm.s.pRelLoggerHC;
2111 if (RT_UNLIKELY(pRelLogger && pRelLogger->offScratch > 0))
2112 RTLogFlushGC(RTLogRelDefaultInstance(), pRelLogger);
2113#endif
2114 if (rc == VERR_TRPM_PANIC || rc == VERR_TRPM_DONT_PANIC)
2115 VMMR3FatalDump(pVM, rc);
2116 if (rc != VINF_VMM_CALL_HOST)
2117 {
2118 Log(("VMMR3ResumeHyper: returns %Vrc\n", rc));
2119 return rc;
2120 }
2121 rc = vmmR3ServiceCallHostRequest(pVM);
2122 if (VBOX_FAILURE(rc))
2123 return rc;
2124 }
2125}
2126
2127
2128/**
2129 * Service a call to the ring-3 host code.
2130 *
2131 * @returns VBox status code.
2132 * @param pVM VM handle.
2133 * @remark Careful with critsects.
2134 */
2135static int vmmR3ServiceCallHostRequest(PVM pVM)
2136{
2137 switch (pVM->vmm.s.enmCallHostOperation)
2138 {
2139 /*
2140 * Acquire the PDM lock.
2141 */
2142 case VMMCALLHOST_PDM_LOCK:
2143 {
2144 pVM->vmm.s.rcCallHost = PDMR3LockCall(pVM);
2145 break;
2146 }
2147
2148 /*
2149 * Flush a PDM queue.
2150 */
2151 case VMMCALLHOST_PDM_QUEUE_FLUSH:
2152 {
2153 PDMR3QueueFlushWorker(pVM, NULL);
2154 pVM->vmm.s.rcCallHost = VINF_SUCCESS;
2155 break;
2156 }
2157
2158 /*
2159 * Grow the PGM pool.
2160 */
2161 case VMMCALLHOST_PGM_POOL_GROW:
2162 {
2163 pVM->vmm.s.rcCallHost = PGMR3PoolGrow(pVM);
2164 break;
2165 }
2166
2167 /*
2168 * Acquire the PGM lock.
2169 */
2170 case VMMCALLHOST_PGM_LOCK:
2171 {
2172 pVM->vmm.s.rcCallHost = PGMR3LockCall(pVM);
2173 break;
2174 }
2175
2176 /*
2177 * Flush REM handler notifications.
2178 */
2179 case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
2180 {
2181 REMR3ReplayHandlerNotifications(pVM);
2182 break;
2183 }
2184
2185 case VMMCALLHOST_PGM_RAM_GROW_RANGE:
2186 {
2187 pVM->vmm.s.rcCallHost = PGM3PhysGrowRange(pVM, pVM->vmm.s.u64CallHostArg);
2188 break;
2189 }
2190
2191 /*
2192 * This is a noop. We just take this route to avoid unnecessary
2193 * tests in the loops.
2194 */
2195 case VMMCALLHOST_VMM_LOGGER_FLUSH:
2196 break;
2197
2198 /*
2199 * Set the VM error message.
2200 */
2201 case VMMCALLHOST_VM_SET_ERROR:
2202 VMR3SetErrorWorker(pVM);
2203 break;
2204
2205 /*
2206 * Set the VM runtime error message.
2207 */
2208 case VMMCALLHOST_VM_SET_RUNTIME_ERROR:
2209 VMR3SetRuntimeErrorWorker(pVM);
2210 break;
2211
2212 default:
2213 AssertMsgFailed(("enmCallHostOperation=%d\n", pVM->vmm.s.enmCallHostOperation));
2214 return VERR_INTERNAL_ERROR;
2215 }
2216
2217 pVM->vmm.s.enmCallHostOperation = VMMCALLHOST_INVALID;
2218 return VINF_SUCCESS;
2219}
2220
2221
2222
2223/**
2224 * Structure to pass to DBGFR3Info() and for doing all other
2225 * output during fatal dump.
2226 */
2227typedef struct VMMR3FATALDUMPINFOHLP
2228{
2229 /** The helper core. */
2230 DBGFINFOHLP Core;
2231 /** The release logger instance. */
2232 PRTLOGGER pRelLogger;
2233 /** The saved release logger flags. */
2234 RTUINT fRelLoggerFlags;
2235 /** The logger instance. */
2236 PRTLOGGER pLogger;
2237 /** The saved logger flags. */
2238 RTUINT fLoggerFlags;
2239 /** The saved logger destination flags. */
2240 RTUINT fLoggerDestFlags;
2241 /** Whether to output to stderr or not. */
2242 bool fStdErr;
2243} VMMR3FATALDUMPINFOHLP, *PVMMR3FATALDUMPINFOHLP;
2244typedef const VMMR3FATALDUMPINFOHLP *PCVMMR3FATALDUMPINFOHLP;
2245
2246
2247/**
2248 * Print formatted string.
2249 *
2250 * @param pHlp Pointer to this structure.
2251 * @param pszFormat The format string.
2252 * @param ... Arguments.
2253 */
2254static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
2255{
2256 va_list args;
2257 va_start(args, pszFormat);
2258 pHlp->pfnPrintfV(pHlp, pszFormat, args);
2259 va_end(args);
2260}
2261
2262
2263/**
2264 * Print formatted string.
2265 *
2266 * @param pHlp Pointer to this structure.
2267 * @param pszFormat The format string.
2268 * @param args Argument list.
2269 */
2270static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
2271{
2272 PCVMMR3FATALDUMPINFOHLP pMyHlp = (PCVMMR3FATALDUMPINFOHLP)pHlp;
2273
2274 if (pMyHlp->pRelLogger)
2275 {
2276 va_list args2;
2277 va_copy(args2, args);
2278 RTLogLoggerV(pMyHlp->pRelLogger, pszFormat, args2);
2279 va_end(args2);
2280 }
2281 if (pMyHlp->pLogger)
2282 {
2283 va_list args2;
2284 va_copy(args2, args);
2285 RTLogLoggerV(pMyHlp->pLogger, pszFormat, args);
2286 va_end(args2);
2287 }
2288 if (pMyHlp->fStdErr)
2289 {
2290 va_list args2;
2291 va_copy(args2, args);
2292 RTStrmPrintfV(g_pStdErr, pszFormat, args);
2293 va_end(args2);
2294 }
2295}
2296
2297
2298/**
2299 * Initializes the fatal dump output helper.
2300 *
2301 * @param pHlp The structure to initialize.
2302 */
2303static void vmmR3FatalDumpInfoHlpInit(PVMMR3FATALDUMPINFOHLP pHlp)
2304{
2305 memset(pHlp, 0, sizeof(*pHlp));
2306
2307 pHlp->Core.pfnPrintf = vmmR3FatalDumpInfoHlp_pfnPrintf;
2308 pHlp->Core.pfnPrintfV = vmmR3FatalDumpInfoHlp_pfnPrintfV;
2309
2310 /*
2311 * The loggers.
2312 */
2313 pHlp->pRelLogger = RTLogRelDefaultInstance();
2314#ifndef LOG_ENABLED
2315 if (!pHlp->pRelLogger)
2316#endif
2317 pHlp->pLogger = RTLogDefaultInstance();
2318
2319 if (pHlp->pRelLogger)
2320 {
2321 pHlp->fRelLoggerFlags = pHlp->pRelLogger->fFlags;
2322 pHlp->pRelLogger->fFlags &= ~(RTLOGFLAGS_BUFFERED | RTLOGFLAGS_DISABLED);
2323 }
2324
2325 if (pHlp->pLogger)
2326 {
2327 pHlp->fLoggerFlags = pHlp->pLogger->fFlags;
2328 pHlp->fLoggerDestFlags = pHlp->pLogger->fDestFlags;
2329 pHlp->pLogger->fFlags &= ~(RTLOGFLAGS_BUFFERED | RTLOGFLAGS_DISABLED);
2330#ifndef DEBUG_sandervl
2331 pHlp->pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
2332#endif
2333 }
2334
2335 /*
2336 * Check if we need write to stderr.
2337 */
2338 pHlp->fStdErr = (!pHlp->pRelLogger || !(pHlp->pRelLogger->fDestFlags & (RTLOGDEST_STDOUT | RTLOGDEST_STDERR)))
2339 && (!pHlp->pLogger || !(pHlp->pLogger->fDestFlags & (RTLOGDEST_STDOUT | RTLOGDEST_STDERR)));
2340}
2341
2342
2343/**
2344 * Deletes the fatal dump output helper.
2345 *
2346 * @param pHlp The structure to delete.
2347 */
2348static void vmmR3FatalDumpInfoHlpDelete(PVMMR3FATALDUMPINFOHLP pHlp)
2349{
2350 if (pHlp->pRelLogger)
2351 {
2352 RTLogFlush(pHlp->pRelLogger);
2353 pHlp->pRelLogger->fFlags = pHlp->fRelLoggerFlags;
2354 }
2355
2356 if (pHlp->pLogger)
2357 {
2358 RTLogFlush(pHlp->pLogger);
2359 pHlp->pLogger->fFlags = pHlp->fLoggerFlags;
2360 pHlp->pLogger->fDestFlags = pHlp->fLoggerDestFlags;
2361 }
2362}
2363
2364
2365/**
2366 * Dumps the VM state on a fatal error.
2367 *
2368 * @param pVM VM Handle.
2369 * @param rcErr VBox status code.
2370 */
2371VMMR3DECL(void) VMMR3FatalDump(PVM pVM, int rcErr)
2372{
2373 /*
2374 * Create our output helper and sync it with the log settings.
2375 * This helper will be used for all the output.
2376 */
2377 VMMR3FATALDUMPINFOHLP Hlp;
2378 PCDBGFINFOHLP pHlp = &Hlp.Core;
2379 vmmR3FatalDumpInfoHlpInit(&Hlp);
2380
2381 /*
2382 * Header.
2383 */
2384 pHlp->pfnPrintf(pHlp,
2385 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
2386 "!!\n"
2387 "!! Guru Meditation %d (%Vrc)\n"
2388 "!!\n",
2389 rcErr, rcErr);
2390
2391 /*
2392 * Continue according to context.
2393 */
2394 bool fDoneHyper = false;
2395 switch (rcErr)
2396 {
2397 /*
2398 * Hyper visor errors.
2399 */
2400 case VINF_EM_DBG_HYPER_ASSERTION:
2401 pHlp->pfnPrintf(pHlp, "%s%s!!\n", VMMR3GetGCAssertMsg1(pVM), VMMR3GetGCAssertMsg2(pVM));
2402 /* fall thru */
2403 case VERR_TRPM_DONT_PANIC:
2404 case VERR_TRPM_PANIC:
2405 case VINF_EM_RAW_STALE_SELECTOR:
2406 case VINF_EM_RAW_IRET_TRAP:
2407 case VINF_EM_DBG_HYPER_BREAKPOINT:
2408 case VINF_EM_DBG_HYPER_STEPPED:
2409 {
2410 /* Trap? */
2411 uint32_t uEIP = CPUMGetHyperEIP(pVM);
2412 TRPMEVENT enmType;
2413 uint8_t u8TrapNo = 0xce;
2414 RTGCUINT uErrorCode = 0xdeadface;
2415 RTGCUINTPTR uCR2 = 0xdeadface;
2416 int rc2 = TRPMQueryTrapAll(pVM, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
2417 if (VBOX_SUCCESS(rc2))
2418 pHlp->pfnPrintf(pHlp,
2419 "!! TRAP=%02x ERRCD=%VGv CR2=%VGv EIP=%VGv Type=%d\n",
2420 u8TrapNo, uErrorCode, uCR2, uEIP, enmType);
2421 else
2422 pHlp->pfnPrintf(pHlp,
2423 "!! EIP=%VGv NOTRAP\n",
2424 uEIP);
2425
2426 /*
2427 * Try figure out where eip is.
2428 */
2429 /** @todo make query call for core code or move this function to VMM. */
2430 /* core code? */
2431 //if (uEIP - (RTGCUINTPTR)pVM->vmm.s.pvGCCoreCode < pVM->vmm.s.cbCoreCode)
2432 // pHlp->pfnPrintf(pHlp,
2433 // "!! EIP is in CoreCode, offset %#x\n",
2434 // uEIP - (RTGCUINTPTR)pVM->vmm.s.pvGCCoreCode);
2435 //else
2436 { /* ask PDM */
2437 /** @todo ask DBGFR3Sym later. */
2438 char szModName[64];
2439 RTGCPTR GCPtrMod;
2440 char szNearSym1[260];
2441 RTGCPTR GCPtrNearSym1;
2442 char szNearSym2[260];
2443 RTGCPTR GCPtrNearSym2;
2444 int rc = PDMR3QueryModFromEIP(pVM, uEIP,
2445 &szModName[0], sizeof(szModName), &GCPtrMod,
2446 &szNearSym1[0], sizeof(szNearSym1), &GCPtrNearSym1,
2447 &szNearSym2[0], sizeof(szNearSym2), &GCPtrNearSym2);
2448 if (VBOX_SUCCESS(rc))
2449 {
2450 pHlp->pfnPrintf(pHlp,
2451 "!! EIP in %s (%p) at rva %x near symbols:\n"
2452 "!! %VGv rva %VGv off %08x %s\n"
2453 "!! %VGv rva %VGv off -%08x %s\n",
2454 szModName, GCPtrMod, (unsigned)(uEIP - GCPtrMod),
2455 GCPtrNearSym1, GCPtrNearSym1 - GCPtrMod, (unsigned)(uEIP - GCPtrNearSym1), szNearSym1,
2456 GCPtrNearSym2, GCPtrNearSym2 - GCPtrMod, (unsigned)(GCPtrNearSym2 - uEIP), szNearSym2);
2457 }
2458 else
2459 pHlp->pfnPrintf(pHlp,
2460 "!! EIP is not in any code known to VMM!\n");
2461 }
2462
2463 /* Disassemble the instruction. */
2464 char szInstr[256];
2465 rc2 = DBGFR3DisasInstrEx(pVM, 0, 0, DBGF_DISAS_FLAGS_CURRENT_HYPER, &szInstr[0], sizeof(szInstr), NULL);
2466 if (VBOX_SUCCESS(rc2))
2467 pHlp->pfnPrintf(pHlp,
2468 "!! %s\n", szInstr);
2469
2470 /* Dump the hypervisor cpu state. */
2471 pHlp->pfnPrintf(pHlp,
2472 "!!\n"
2473 "!!\n"
2474 "!!\n");
2475 rc2 = DBGFR3Info(pVM, "cpumhyper", "verbose", pHlp);
2476 fDoneHyper = true;
2477
2478 /* Callstack. */
2479 DBGFSTACKFRAME Frame = {0};
2480 rc2 = DBGFR3StackWalkBeginHyper(pVM, &Frame);
2481 if (VBOX_SUCCESS(rc2))
2482 {
2483 pHlp->pfnPrintf(pHlp,
2484 "!!\n"
2485 "!! Call Stack:\n"
2486 "!!\n"
2487 "EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP Symbol [line]\n");
2488 do
2489 {
2490 pHlp->pfnPrintf(pHlp,
2491 "%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2492 (uint32_t)Frame.AddrFrame.off,
2493 (uint32_t)Frame.AddrReturnFrame.off,
2494 (uint32_t)Frame.AddrReturnPC.Sel,
2495 (uint32_t)Frame.AddrReturnPC.off,
2496 Frame.Args.au32[0],
2497 Frame.Args.au32[1],
2498 Frame.Args.au32[2],
2499 Frame.Args.au32[3]);
2500 pHlp->pfnPrintf(pHlp, " %RTsel:%08RGv", Frame.AddrPC.Sel, Frame.AddrPC.off);
2501 if (Frame.pSymPC)
2502 {
2503 RTGCINTPTR offDisp = Frame.AddrPC.FlatPtr - Frame.pSymPC->Value;
2504 if (offDisp > 0)
2505 pHlp->pfnPrintf(pHlp, " %s+%llx", Frame.pSymPC->szName, (int64_t)offDisp);
2506 else if (offDisp < 0)
2507 pHlp->pfnPrintf(pHlp, " %s-%llx", Frame.pSymPC->szName, -(int64_t)offDisp);
2508 else
2509 pHlp->pfnPrintf(pHlp, " %s", Frame.pSymPC->szName);
2510 }
2511 if (Frame.pLinePC)
2512 pHlp->pfnPrintf(pHlp, " [%s @ 0i%d]", Frame.pLinePC->szFilename, Frame.pLinePC->uLineNo);
2513 pHlp->pfnPrintf(pHlp, "\n");
2514
2515 /* next */
2516 rc2 = DBGFR3StackWalkNext(pVM, &Frame);
2517 } while (VBOX_SUCCESS(rc2));
2518 DBGFR3StackWalkEnd(pVM, &Frame);
2519 }
2520
2521 /* raw stack */
2522 pHlp->pfnPrintf(pHlp,
2523 "!!\n"
2524 "!! Raw stack (mind the direction).\n"
2525 "!!\n"
2526 "%.*Vhxd\n",
2527 VMM_STACK_SIZE, (char *)pVM->vmm.s.pbHCStack);
2528 break;
2529 }
2530
2531 default:
2532 {
2533 break;
2534 }
2535
2536 } /* switch (rcErr) */
2537
2538
2539 /*
2540 * Dump useful state information.
2541 */
2542 /** @todo convert these dumpers to DBGFR3Info() handlers!!! */
2543 pHlp->pfnPrintf(pHlp,
2544 "!!\n"
2545 "!! PGM Access Handlers & Stuff:\n"
2546 "!!\n");
2547 PGMR3DumpMappings(pVM);
2548
2549
2550 /*
2551 * Generic info dumper loop.
2552 */
2553 static struct
2554 {
2555 const char *pszInfo;
2556 const char *pszArgs;
2557 } const aInfo[] =
2558 {
2559 { "hma", NULL },
2560 { "cpumguest", "verbose" },
2561 { "cpumhyper", "verbose" },
2562 { "cpumhost", "verbose" },
2563 { "mode", "all" },
2564 { "cpuid", "verbose" },
2565 { "gdt", NULL },
2566 { "ldt", NULL },
2567 //{ "tss", NULL },
2568 { "ioport", NULL },
2569 { "mmio", NULL },
2570 { "phys", NULL },
2571 //{ "pgmpd", NULL }, - doesn't always work at init time...
2572 { "timers", NULL },
2573 { "activetimers", NULL },
2574 { "handlers", "phys virt stats" },
2575 { "cfgm", NULL },
2576 };
2577 for (unsigned i = 0; i < ELEMENTS(aInfo); i++)
2578 {
2579 if (fDoneHyper && !strcmp(aInfo[i].pszInfo, "cpumhyper"))
2580 continue;
2581 pHlp->pfnPrintf(pHlp,
2582 "!!\n"
2583 "!! {%s, %s}\n"
2584 "!!\n",
2585 aInfo[i].pszInfo, aInfo[i].pszArgs);
2586 DBGFR3Info(pVM, aInfo[i].pszInfo, aInfo[i].pszArgs, pHlp);
2587 }
2588
2589 /* done */
2590 pHlp->pfnPrintf(pHlp,
2591 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2592
2593
2594 /*
2595 * Delete the output instance (flushing and restoring of flags).
2596 */
2597 vmmR3FatalDumpInfoHlpDelete(&Hlp);
2598}
2599
2600
2601
2602/**
2603 * Displays the Force action Flags.
2604 *
2605 * @param pVM The VM handle.
2606 * @param pHlp The output helpers.
2607 * @param pszArgs The additional arguments (ignored).
2608 */
2609static DECLCALLBACK(void) vmmR3InfoFF(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
2610{
2611 const uint32_t fForcedActions = pVM->fForcedActions;
2612
2613 pHlp->pfnPrintf(pHlp, "Forced action Flags: %#RX32", fForcedActions);
2614
2615 /* show the flag mnemonics */
2616 int c = 0;
2617 uint32_t f = fForcedActions;
2618#define PRINT_FLAG(flag) do { \
2619 if (f & (flag)) \
2620 { \
2621 static const char *s_psz = #flag; \
2622 if (!(c % 6)) \
2623 pHlp->pfnPrintf(pHlp, "%s\n %s", c ? "," : "", s_psz + 6); \
2624 else \
2625 pHlp->pfnPrintf(pHlp, ", %s", s_psz + 6); \
2626 c++; \
2627 f &= ~(flag); \
2628 } \
2629 } while (0)
2630 PRINT_FLAG(VM_FF_INTERRUPT_APIC);
2631 PRINT_FLAG(VM_FF_INTERRUPT_PIC);
2632 PRINT_FLAG(VM_FF_TIMER);
2633 PRINT_FLAG(VM_FF_PDM_QUEUES);
2634 PRINT_FLAG(VM_FF_PDM_DMA);
2635 PRINT_FLAG(VM_FF_PDM_CRITSECT);
2636 PRINT_FLAG(VM_FF_DBGF);
2637 PRINT_FLAG(VM_FF_REQUEST);
2638 PRINT_FLAG(VM_FF_TERMINATE);
2639 PRINT_FLAG(VM_FF_RESET);
2640 PRINT_FLAG(VM_FF_PGM_SYNC_CR3);
2641 PRINT_FLAG(VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
2642 PRINT_FLAG(VM_FF_TRPM_SYNC_IDT);
2643 PRINT_FLAG(VM_FF_SELM_SYNC_TSS);
2644 PRINT_FLAG(VM_FF_SELM_SYNC_GDT);
2645 PRINT_FLAG(VM_FF_SELM_SYNC_LDT);
2646 PRINT_FLAG(VM_FF_INHIBIT_INTERRUPTS);
2647 PRINT_FLAG(VM_FF_CSAM_SCAN_PAGE);
2648 PRINT_FLAG(VM_FF_CSAM_PENDING_ACTION);
2649 PRINT_FLAG(VM_FF_TO_R3);
2650 PRINT_FLAG(VM_FF_DEBUG_SUSPEND);
2651 if (f)
2652 pHlp->pfnPrintf(pHlp, "%s\n Unknown bits: %#RX32\n", c ? "," : "", f);
2653 else
2654 pHlp->pfnPrintf(pHlp, "\n");
2655#undef PRINT_FLAG
2656
2657 /* the groups */
2658 c = 0;
2659#define PRINT_GROUP(grp) do { \
2660 if (fForcedActions & (grp)) \
2661 { \
2662 static const char *s_psz = #grp; \
2663 if (!(c % 5)) \
2664 pHlp->pfnPrintf(pHlp, "%s %s", c ? ",\n" : "Groups:\n", s_psz + 6); \
2665 else \
2666 pHlp->pfnPrintf(pHlp, ", %s", s_psz + 6); \
2667 c++; \
2668 } \
2669 } while (0)
2670 PRINT_GROUP(VM_FF_EXTERNAL_SUSPENDED_MASK);
2671 PRINT_GROUP(VM_FF_EXTERNAL_HALTED_MASK);
2672 PRINT_GROUP(VM_FF_HIGH_PRIORITY_PRE_MASK);
2673 PRINT_GROUP(VM_FF_HIGH_PRIORITY_PRE_RAW_MASK);
2674 PRINT_GROUP(VM_FF_HIGH_PRIORITY_POST_MASK);
2675 PRINT_GROUP(VM_FF_NORMAL_PRIORITY_POST_MASK);
2676 PRINT_GROUP(VM_FF_NORMAL_PRIORITY_MASK);
2677 PRINT_GROUP(VM_FF_RESUME_GUEST_MASK);
2678 PRINT_GROUP(VM_FF_ALL_BUT_RAW_MASK);
2679 if (c)
2680 pHlp->pfnPrintf(pHlp, "\n");
2681#undef PRINT_GROUP
2682}
2683
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