VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR0/VMMR0.cpp@ 50653

Last change on this file since 50653 was 49481, checked in by vboxsync, 11 years ago

VMM: Warnings.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 62.7 KB
Line 
1/* $Id: VMMR0.cpp 49481 2013-11-14 15:18:56Z vboxsync $ */
2/** @file
3 * VMM - Host Context Ring 0.
4 */
5
6/*
7 * Copyright (C) 2006-2012 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#define LOG_GROUP LOG_GROUP_VMM
22#include <VBox/vmm/vmm.h>
23#include <VBox/sup.h>
24#include <VBox/vmm/trpm.h>
25#include <VBox/vmm/cpum.h>
26#include <VBox/vmm/pdmapi.h>
27#include <VBox/vmm/pgm.h>
28#include <VBox/vmm/stam.h>
29#include <VBox/vmm/tm.h>
30#include "VMMInternal.h"
31#include <VBox/vmm/vm.h>
32#ifdef VBOX_WITH_PCI_PASSTHROUGH
33# include <VBox/vmm/pdmpci.h>
34#endif
35
36#include <VBox/vmm/gvmm.h>
37#include <VBox/vmm/gmm.h>
38#include <VBox/intnet.h>
39#include <VBox/vmm/hm.h>
40#include <VBox/param.h>
41#include <VBox/err.h>
42#include <VBox/version.h>
43#include <VBox/log.h>
44
45#include <iprt/asm-amd64-x86.h>
46#include <iprt/assert.h>
47#include <iprt/crc.h>
48#include <iprt/mp.h>
49#include <iprt/once.h>
50#include <iprt/stdarg.h>
51#include <iprt/string.h>
52#include <iprt/thread.h>
53#include <iprt/timer.h>
54
55#include "dtrace/VBoxVMM.h"
56
57
58#if defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
59# pragma intrinsic(_AddressOfReturnAddress)
60#endif
61
62
63/*******************************************************************************
64* Internal Functions *
65*******************************************************************************/
66RT_C_DECLS_BEGIN
67#if defined(RT_ARCH_X86) && (defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD))
68extern uint64_t __udivdi3(uint64_t, uint64_t);
69extern uint64_t __umoddi3(uint64_t, uint64_t);
70#endif
71RT_C_DECLS_END
72
73
74/*******************************************************************************
75* Global Variables *
76*******************************************************************************/
77/** Drag in necessary library bits.
78 * The runtime lives here (in VMMR0.r0) and VBoxDD*R0.r0 links against us. */
79PFNRT g_VMMGCDeps[] =
80{
81 (PFNRT)RTCrc32,
82 (PFNRT)RTOnce,
83#if defined(RT_ARCH_X86) && (defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD))
84 (PFNRT)__udivdi3,
85 (PFNRT)__umoddi3,
86#endif
87 NULL
88};
89
90#ifdef RT_OS_SOLARIS
91/* Dependency information for the native solaris loader. */
92extern "C" { char _depends_on[] = "vboxdrv"; }
93#endif
94
95
96
97/**
98 * Initialize the module.
99 * This is called when we're first loaded.
100 *
101 * @returns 0 on success.
102 * @returns VBox status on failure.
103 * @param hMod Image handle for use in APIs.
104 */
105DECLEXPORT(int) ModuleInit(void *hMod)
106{
107#ifdef VBOX_WITH_DTRACE_R0
108 /*
109 * The first thing to do is register the static tracepoints.
110 * (Deregistration is automatic.)
111 */
112 int rc2 = SUPR0TracerRegisterModule(hMod, &g_VTGObjHeader);
113 if (RT_FAILURE(rc2))
114 return rc2;
115#endif
116 LogFlow(("ModuleInit:\n"));
117
118#ifdef VBOX_WITH_64ON32_CMOS_DEBUG
119 /*
120 * Display the CMOS debug code.
121 */
122 ASMOutU8(0x72, 0x03);
123 uint8_t bDebugCode = ASMInU8(0x73);
124 LogRel(("CMOS Debug Code: %#x (%d)\n", bDebugCode, bDebugCode));
125 RTLogComPrintf("CMOS Debug Code: %#x (%d)\n", bDebugCode, bDebugCode);
126#endif
127
128 /*
129 * Initialize the VMM, GVMM, GMM, HM, PGM (Darwin) and INTNET.
130 */
131 int rc = vmmInitFormatTypes();
132 if (RT_SUCCESS(rc))
133 {
134 rc = GVMMR0Init();
135 if (RT_SUCCESS(rc))
136 {
137 rc = GMMR0Init();
138 if (RT_SUCCESS(rc))
139 {
140 rc = HMR0Init();
141 if (RT_SUCCESS(rc))
142 {
143 rc = PGMRegisterStringFormatTypes();
144 if (RT_SUCCESS(rc))
145 {
146#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
147 rc = PGMR0DynMapInit();
148#endif
149 if (RT_SUCCESS(rc))
150 {
151 rc = IntNetR0Init();
152 if (RT_SUCCESS(rc))
153 {
154#ifdef VBOX_WITH_PCI_PASSTHROUGH
155 rc = PciRawR0Init();
156#endif
157 if (RT_SUCCESS(rc))
158 {
159 rc = CPUMR0ModuleInit();
160 if (RT_SUCCESS(rc))
161 {
162#ifdef VBOX_WITH_TRIPLE_FAULT_HACK
163 rc = vmmR0TripleFaultHackInit();
164 if (RT_SUCCESS(rc))
165#endif
166 {
167 LogFlow(("ModuleInit: returns success.\n"));
168 return VINF_SUCCESS;
169 }
170
171 /*
172 * Bail out.
173 */
174#ifdef VBOX_WITH_TRIPLE_FAULT_HACK
175 vmmR0TripleFaultHackTerm();
176#endif
177 }
178 else
179 LogRel(("ModuleInit: CPUMR0ModuleInit -> %Rrc\n", rc));
180#ifdef VBOX_WITH_PCI_PASSTHROUGH
181 PciRawR0Term();
182#endif
183 }
184 else
185 LogRel(("ModuleInit: PciRawR0Init -> %Rrc\n", rc));
186 IntNetR0Term();
187 }
188 else
189 LogRel(("ModuleInit: IntNetR0Init -> %Rrc\n", rc));
190#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
191 PGMR0DynMapTerm();
192#endif
193 }
194 else
195 LogRel(("ModuleInit: PGMR0DynMapInit -> %Rrc\n", rc));
196 PGMDeregisterStringFormatTypes();
197 }
198 else
199 LogRel(("ModuleInit: PGMRegisterStringFormatTypes -> %Rrc\n", rc));
200 HMR0Term();
201 }
202 else
203 LogRel(("ModuleInit: HMR0Init -> %Rrc\n", rc));
204 GMMR0Term();
205 }
206 else
207 LogRel(("ModuleInit: GMMR0Init -> %Rrc\n", rc));
208 GVMMR0Term();
209 }
210 else
211 LogRel(("ModuleInit: GVMMR0Init -> %Rrc\n", rc));
212 vmmTermFormatTypes();
213 }
214 else
215 LogRel(("ModuleInit: vmmInitFormatTypes -> %Rrc\n", rc));
216
217 LogFlow(("ModuleInit: failed %Rrc\n", rc));
218 return rc;
219}
220
221
222/**
223 * Terminate the module.
224 * This is called when we're finally unloaded.
225 *
226 * @param hMod Image handle for use in APIs.
227 */
228DECLEXPORT(void) ModuleTerm(void *hMod)
229{
230 NOREF(hMod);
231 LogFlow(("ModuleTerm:\n"));
232
233 /*
234 * Terminate the CPUM module (Local APIC cleanup).
235 */
236 CPUMR0ModuleTerm();
237
238 /*
239 * Terminate the internal network service.
240 */
241 IntNetR0Term();
242
243 /*
244 * PGM (Darwin), HM and PciRaw global cleanup.
245 */
246#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
247 PGMR0DynMapTerm();
248#endif
249#ifdef VBOX_WITH_PCI_PASSTHROUGH
250 PciRawR0Term();
251#endif
252 PGMDeregisterStringFormatTypes();
253 HMR0Term();
254#ifdef VBOX_WITH_TRIPLE_FAULT_HACK
255 vmmR0TripleFaultHackTerm();
256#endif
257
258 /*
259 * Destroy the GMM and GVMM instances.
260 */
261 GMMR0Term();
262 GVMMR0Term();
263
264 vmmTermFormatTypes();
265
266 LogFlow(("ModuleTerm: returns\n"));
267}
268
269
270/**
271 * Initiates the R0 driver for a particular VM instance.
272 *
273 * @returns VBox status code.
274 *
275 * @param pVM Pointer to the VM.
276 * @param uSvnRev The SVN revision of the ring-3 part.
277 * @param uBuildType Build type indicator.
278 * @thread EMT.
279 */
280static int vmmR0InitVM(PVM pVM, uint32_t uSvnRev, uint32_t uBuildType)
281{
282 /*
283 * Match the SVN revisions and build type.
284 */
285 if (uSvnRev != VMMGetSvnRev())
286 {
287 LogRel(("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev()));
288 SUPR0Printf("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev());
289 return VERR_VMM_R0_VERSION_MISMATCH;
290 }
291 if (uBuildType != vmmGetBuildType())
292 {
293 LogRel(("VMMR0InitVM: Build type mismatch, r3=%#x r0=%#x\n", uBuildType, vmmGetBuildType()));
294 SUPR0Printf("VMMR0InitVM: Build type mismatch, r3=%#x r0=%#x\n", uBuildType, vmmGetBuildType());
295 return VERR_VMM_R0_VERSION_MISMATCH;
296 }
297 if ( !VALID_PTR(pVM)
298 || pVM->pVMR0 != pVM)
299 return VERR_INVALID_PARAMETER;
300
301
302#ifdef LOG_ENABLED
303 /*
304 * Register the EMT R0 logger instance for VCPU 0.
305 */
306 PVMCPU pVCpu = &pVM->aCpus[0];
307
308 PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
309 if (pR0Logger)
310 {
311# if 0 /* testing of the logger. */
312 LogCom(("vmmR0InitVM: before %p\n", RTLogDefaultInstance()));
313 LogCom(("vmmR0InitVM: pfnFlush=%p actual=%p\n", pR0Logger->Logger.pfnFlush, vmmR0LoggerFlush));
314 LogCom(("vmmR0InitVM: pfnLogger=%p actual=%p\n", pR0Logger->Logger.pfnLogger, vmmR0LoggerWrapper));
315 LogCom(("vmmR0InitVM: offScratch=%d fFlags=%#x fDestFlags=%#x\n", pR0Logger->Logger.offScratch, pR0Logger->Logger.fFlags, pR0Logger->Logger.fDestFlags));
316
317 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
318 LogCom(("vmmR0InitVM: after %p reg\n", RTLogDefaultInstance()));
319 RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
320 LogCom(("vmmR0InitVM: after %p dereg\n", RTLogDefaultInstance()));
321
322 pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
323 LogCom(("vmmR0InitVM: returned successfully from direct logger call.\n"));
324 pR0Logger->Logger.pfnFlush(&pR0Logger->Logger);
325 LogCom(("vmmR0InitVM: returned successfully from direct flush call.\n"));
326
327 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
328 LogCom(("vmmR0InitVM: after %p reg2\n", RTLogDefaultInstance()));
329 pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
330 LogCom(("vmmR0InitVM: returned successfully from direct logger call (2). offScratch=%d\n", pR0Logger->Logger.offScratch));
331 RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
332 LogCom(("vmmR0InitVM: after %p dereg2\n", RTLogDefaultInstance()));
333
334 RTLogLoggerEx(&pR0Logger->Logger, 0, ~0U, "hello ring-0 logger (RTLogLoggerEx)\n");
335 LogCom(("vmmR0InitVM: RTLogLoggerEx returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
336
337 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
338 RTLogPrintf("hello ring-0 logger (RTLogPrintf)\n");
339 LogCom(("vmmR0InitVM: RTLogPrintf returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
340# endif
341 Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pVM->pSession));
342 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
343 pR0Logger->fRegistered = true;
344 }
345#endif /* LOG_ENABLED */
346
347 /*
348 * Check if the host supports high resolution timers or not.
349 */
350 if ( pVM->vmm.s.fUsePeriodicPreemptionTimers
351 && !RTTimerCanDoHighResolution())
352 pVM->vmm.s.fUsePeriodicPreemptionTimers = false;
353
354 /*
355 * Initialize the per VM data for GVMM and GMM.
356 */
357 int rc = GVMMR0InitVM(pVM);
358// if (RT_SUCCESS(rc))
359// rc = GMMR0InitPerVMData(pVM);
360 if (RT_SUCCESS(rc))
361 {
362 /*
363 * Init HM, CPUM and PGM (Darwin only).
364 */
365 rc = HMR0InitVM(pVM);
366 if (RT_SUCCESS(rc))
367 {
368 rc = CPUMR0InitVM(pVM);
369 if (RT_SUCCESS(rc))
370 {
371#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
372 rc = PGMR0DynMapInitVM(pVM);
373#endif
374 if (RT_SUCCESS(rc))
375 {
376#ifdef VBOX_WITH_PCI_PASSTHROUGH
377 rc = PciRawR0InitVM(pVM);
378#endif
379 if (RT_SUCCESS(rc))
380 {
381 GVMMR0DoneInitVM(pVM);
382 return rc;
383 }
384 }
385
386 /* bail out */
387 }
388#ifdef VBOX_WITH_PCI_PASSTHROUGH
389 PciRawR0TermVM(pVM);
390#endif
391 HMR0TermVM(pVM);
392 }
393 }
394
395
396 RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
397 return rc;
398}
399
400
401/**
402 * Terminates the R0 bits for a particular VM instance.
403 *
404 * This is normally called by ring-3 as part of the VM termination process, but
405 * may alternatively be called during the support driver session cleanup when
406 * the VM object is destroyed (see GVMM).
407 *
408 * @returns VBox status code.
409 *
410 * @param pVM Pointer to the VM.
411 * @param pGVM Pointer to the global VM structure. Optional.
412 * @thread EMT or session clean up thread.
413 */
414VMMR0DECL(int) VMMR0TermVM(PVM pVM, PGVM pGVM)
415{
416#ifdef VBOX_WITH_PCI_PASSTHROUGH
417 PciRawR0TermVM(pVM);
418#endif
419
420 /*
421 * Tell GVMM what we're up to and check that we only do this once.
422 */
423 if (GVMMR0DoingTermVM(pVM, pGVM))
424 {
425 /** @todo I wish to call PGMR0PhysFlushHandyPages(pVM, &pVM->aCpus[idCpu])
426 * here to make sure we don't leak any shared pages if we crash... */
427#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
428 PGMR0DynMapTermVM(pVM);
429#endif
430 HMR0TermVM(pVM);
431 }
432
433 /*
434 * Deregister the logger.
435 */
436 RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
437 return VINF_SUCCESS;
438}
439
440
441/**
442 * Creates R0 thread-context hooks for the current EMT thread.
443 *
444 * @returns VBox status code.
445 * @param pVCpu Pointer to the VMCPU.
446 *
447 * @thread EMT(pVCpu)
448 */
449VMMR0DECL(int) VMMR0ThreadCtxHooksCreate(PVMCPU pVCpu)
450{
451 VMCPU_ASSERT_EMT(pVCpu);
452 Assert(pVCpu->vmm.s.hR0ThreadCtx == NIL_RTTHREADCTX);
453#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS)
454 int rc = RTThreadCtxHooksCreate(&pVCpu->vmm.s.hR0ThreadCtx);
455 if ( RT_FAILURE(rc)
456 && rc != VERR_NOT_SUPPORTED)
457 {
458 Log(("RTThreadCtxHooksCreate failed! rc=%Rrc pVCpu=%p idCpu=%RU32\n", rc, pVCpu, pVCpu->idCpu));
459 return rc;
460 }
461#endif
462
463 return VINF_SUCCESS;
464}
465
466
467/**
468 * Releases the object reference for the thread-context hook.
469 *
470 * @param pVCpu Pointer to the VMCPU.
471 * @remarks Can be called from any thread.
472 */
473VMMR0DECL(void) VMMR0ThreadCtxHooksRelease(PVMCPU pVCpu)
474{
475 RTThreadCtxHooksRelease(pVCpu->vmm.s.hR0ThreadCtx);
476}
477
478
479/**
480 * Registers the thread-context hook for this VCPU.
481 *
482 * @returns VBox status code.
483 * @param pVCpu Pointer to the VMCPU.
484 * @param pfnThreadHook Pointer to the thread-context callback.
485 *
486 * @thread EMT(pVCpu)
487 */
488VMMR0DECL(int) VMMR0ThreadCtxHooksRegister(PVMCPU pVCpu, PFNRTTHREADCTXHOOK pfnThreadHook)
489{
490 VMCPU_ASSERT_EMT(pVCpu);
491 return RTThreadCtxHooksRegister(pVCpu->vmm.s.hR0ThreadCtx, pfnThreadHook, pVCpu);
492}
493
494
495/**
496 * Deregisters the thread-context hook for this VCPU.
497 *
498 * @returns VBox status code.
499 * @param pVCpu Pointer to the VMCPU.
500 *
501 * @thread EMT(pVCpu)
502 */
503VMMR0DECL(int) VMMR0ThreadCtxHooksDeregister(PVMCPU pVCpu)
504{
505 return RTThreadCtxHooksDeregister(pVCpu->vmm.s.hR0ThreadCtx);
506}
507
508
509/**
510 * Whether thread-context hooks are created (implying they're supported) on this
511 * platform.
512 *
513 * @returns true if the hooks are created, false otherwise.
514 * @param pVCpu Pointer to the VMCPU.
515 */
516VMMR0DECL(bool) VMMR0ThreadCtxHooksAreCreated(PVMCPU pVCpu)
517{
518 return pVCpu->vmm.s.hR0ThreadCtx != NIL_RTTHREADCTX;
519}
520
521
522/**
523 * Whether thread-context hooks are registered for this VCPU.
524 *
525 * @returns true if registered, false otherwise.
526 * @param pVCpu Pointer to the VMCPU.
527 */
528VMMR0DECL(bool) VMMR0ThreadCtxHooksAreRegistered(PVMCPU pVCpu)
529{
530 return RTThreadCtxHooksAreRegistered(pVCpu->vmm.s.hR0ThreadCtx);
531}
532
533
534/**
535 * VMM ring-0 thread-context callback.
536 *
537 * This does common HM state updating and calls the HM-specific thread-context
538 * callback.
539 *
540 * @param enmEvent The thread-context event.
541 * @param pvUser Opaque pointer to the VMCPU.
542 *
543 * @thread EMT(pvUser)
544 */
545static DECLCALLBACK(void) vmmR0ThreadCtxCallback(RTTHREADCTXEVENT enmEvent, void *pvUser)
546{
547 PVMCPU pVCpu = (PVMCPU)pvUser;
548
549 switch (enmEvent)
550 {
551 case RTTHREADCTXEVENT_RESUMED:
552 {
553 /** @todo Linux may call us with preemption enabled (really!) but technically we
554 * cannot get preempted here, otherwise we end up in an infinite recursion
555 * scenario (i.e. preempted in resume hook -> preempt hook -> resume hook... ad
556 * infinitum). Let's just disable preemption for now...
557 */
558 HM_DISABLE_PREEMPT_IF_NEEDED();
559
560 /* We need to update the VCPU <-> host CPU mapping. */
561 RTCPUID idHostCpu = RTMpCpuId();
562 ASMAtomicWriteU32(&pVCpu->idHostCpu, idHostCpu);
563
564 /* Invoke the HM-specific thread-context callback. */
565 HMR0ThreadCtxCallback(enmEvent, pvUser);
566
567 /* Restore preemption. */
568 HM_RESTORE_PREEMPT_IF_NEEDED();
569 break;
570 }
571
572 case RTTHREADCTXEVENT_PREEMPTING:
573 {
574 /* Invoke the HM-specific thread-context callback. */
575 HMR0ThreadCtxCallback(enmEvent, pvUser);
576
577 /*
578 * Sigh. See VMMGetCpu() used by VMCPU_ASSERT_EMT(). We cannot let several VCPUs
579 * have the same host CPU associated with it.
580 */
581 ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
582 break;
583 }
584
585 default:
586 /* Invoke the HM-specific thread-context callback. */
587 HMR0ThreadCtxCallback(enmEvent, pvUser);
588 break;
589 }
590}
591
592
593#ifdef VBOX_WITH_STATISTICS
594/**
595 * Record return code statistics
596 * @param pVM Pointer to the VM.
597 * @param pVCpu Pointer to the VMCPU.
598 * @param rc The status code.
599 */
600static void vmmR0RecordRC(PVM pVM, PVMCPU pVCpu, int rc)
601{
602 /*
603 * Collect statistics.
604 */
605 switch (rc)
606 {
607 case VINF_SUCCESS:
608 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetNormal);
609 break;
610 case VINF_EM_RAW_INTERRUPT:
611 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterrupt);
612 break;
613 case VINF_EM_RAW_INTERRUPT_HYPER:
614 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptHyper);
615 break;
616 case VINF_EM_RAW_GUEST_TRAP:
617 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGuestTrap);
618 break;
619 case VINF_EM_RAW_RING_SWITCH:
620 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitch);
621 break;
622 case VINF_EM_RAW_RING_SWITCH_INT:
623 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitchInt);
624 break;
625 case VINF_EM_RAW_STALE_SELECTOR:
626 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetStaleSelector);
627 break;
628 case VINF_EM_RAW_IRET_TRAP:
629 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIRETTrap);
630 break;
631 case VINF_IOM_R3_IOPORT_READ:
632 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIORead);
633 break;
634 case VINF_IOM_R3_IOPORT_WRITE:
635 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOWrite);
636 break;
637 case VINF_IOM_R3_MMIO_READ:
638 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIORead);
639 break;
640 case VINF_IOM_R3_MMIO_WRITE:
641 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOWrite);
642 break;
643 case VINF_IOM_R3_MMIO_READ_WRITE:
644 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOReadWrite);
645 break;
646 case VINF_PATM_HC_MMIO_PATCH_READ:
647 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchRead);
648 break;
649 case VINF_PATM_HC_MMIO_PATCH_WRITE:
650 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchWrite);
651 break;
652 case VINF_EM_RAW_EMULATE_INSTR:
653 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetEmulate);
654 break;
655 case VINF_EM_RAW_EMULATE_IO_BLOCK:
656 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOBlockEmulate);
657 break;
658 case VINF_PATCH_EMULATE_INSTR:
659 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchEmulate);
660 break;
661 case VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT:
662 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetLDTFault);
663 break;
664 case VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT:
665 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGDTFault);
666 break;
667 case VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT:
668 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIDTFault);
669 break;
670 case VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT:
671 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTSSFault);
672 break;
673 case VINF_EM_RAW_EMULATE_INSTR_PD_FAULT:
674 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPDFault);
675 break;
676 case VINF_CSAM_PENDING_ACTION:
677 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCSAMTask);
678 break;
679 case VINF_PGM_SYNC_CR3:
680 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetSyncCR3);
681 break;
682 case VINF_PATM_PATCH_INT3:
683 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchInt3);
684 break;
685 case VINF_PATM_PATCH_TRAP_PF:
686 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchPF);
687 break;
688 case VINF_PATM_PATCH_TRAP_GP:
689 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchGP);
690 break;
691 case VINF_PATM_PENDING_IRQ_AFTER_IRET:
692 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchIretIRQ);
693 break;
694 case VINF_EM_RESCHEDULE_REM:
695 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRescheduleREM);
696 break;
697 case VINF_EM_RAW_TO_R3:
698 if (VM_FF_IS_PENDING(pVM, VM_FF_TM_VIRTUAL_SYNC))
699 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3TMVirt);
700 else if (VM_FF_IS_PENDING(pVM, VM_FF_PGM_NEED_HANDY_PAGES))
701 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3HandyPages);
702 else if (VM_FF_IS_PENDING(pVM, VM_FF_PDM_QUEUES))
703 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3PDMQueues);
704 else if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
705 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Rendezvous);
706 else if (VM_FF_IS_PENDING(pVM, VM_FF_PDM_DMA))
707 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3DMA);
708 else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER))
709 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Timer);
710 else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
711 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3CritSect);
712 else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TO_R3))
713 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3);
714 else
715 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Unknown);
716 break;
717
718 case VINF_EM_RAW_TIMER_PENDING:
719 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTimerPending);
720 break;
721 case VINF_EM_RAW_INTERRUPT_PENDING:
722 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptPending);
723 break;
724 case VINF_VMM_CALL_HOST:
725 switch (pVCpu->vmm.s.enmCallRing3Operation)
726 {
727 case VMMCALLRING3_PDM_CRIT_SECT_ENTER:
728 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMCritSectEnter);
729 break;
730 case VMMCALLRING3_PDM_LOCK:
731 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMLock);
732 break;
733 case VMMCALLRING3_PGM_POOL_GROW:
734 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMPoolGrow);
735 break;
736 case VMMCALLRING3_PGM_LOCK:
737 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMLock);
738 break;
739 case VMMCALLRING3_PGM_MAP_CHUNK:
740 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMMapChunk);
741 break;
742 case VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES:
743 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMAllocHandy);
744 break;
745 case VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS:
746 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallRemReplay);
747 break;
748 case VMMCALLRING3_VMM_LOGGER_FLUSH:
749 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallLogFlush);
750 break;
751 case VMMCALLRING3_VM_SET_ERROR:
752 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetError);
753 break;
754 case VMMCALLRING3_VM_SET_RUNTIME_ERROR:
755 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetRuntimeError);
756 break;
757 case VMMCALLRING3_VM_R0_ASSERTION:
758 default:
759 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCallRing3);
760 break;
761 }
762 break;
763 case VINF_PATM_DUPLICATE_FUNCTION:
764 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPATMDuplicateFn);
765 break;
766 case VINF_PGM_CHANGE_MODE:
767 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMChangeMode);
768 break;
769 case VINF_PGM_POOL_FLUSH_PENDING:
770 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMFlushPending);
771 break;
772 case VINF_EM_PENDING_REQUEST:
773 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPendingRequest);
774 break;
775 case VINF_EM_HM_PATCH_TPR_INSTR:
776 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchTPR);
777 break;
778 default:
779 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMisc);
780 break;
781 }
782}
783#endif /* VBOX_WITH_STATISTICS */
784
785
786/**
787 * Unused ring-0 entry point that used to be called from the interrupt gate.
788 *
789 * Will be removed one of the next times we do a major SUPDrv version bump.
790 *
791 * @returns VBox status code.
792 * @param pVM Pointer to the VM.
793 * @param enmOperation Which operation to execute.
794 * @param pvArg Argument to the operation.
795 * @remarks Assume called with interrupts disabled.
796 */
797VMMR0DECL(int) VMMR0EntryInt(PVM pVM, VMMR0OPERATION enmOperation, void *pvArg)
798{
799 /*
800 * We're returning VERR_NOT_SUPPORT here so we've got something else
801 * than -1 which the interrupt gate glue code might return.
802 */
803 Log(("operation %#x is not supported\n", enmOperation));
804 NOREF(enmOperation); NOREF(pvArg); NOREF(pVM);
805 return VERR_NOT_SUPPORTED;
806}
807
808
809/**
810 * The Ring 0 entry point, called by the fast-ioctl path.
811 *
812 * @param pVM Pointer to the VM.
813 * The return code is stored in pVM->vmm.s.iLastGZRc.
814 * @param idCpu The Virtual CPU ID of the calling EMT.
815 * @param enmOperation Which operation to execute.
816 * @remarks Assume called with interrupts _enabled_.
817 */
818VMMR0DECL(void) VMMR0EntryFast(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation)
819{
820 /*
821 * Validation.
822 */
823 if (RT_UNLIKELY(idCpu >= pVM->cCpus))
824 return;
825 PVMCPU pVCpu = &pVM->aCpus[idCpu];
826 if (RT_UNLIKELY(pVCpu->hNativeThreadR0 != RTThreadNativeSelf()))
827 return;
828
829 /*
830 * Perform requested operation.
831 */
832 switch (enmOperation)
833 {
834 /*
835 * Switch to GC and run guest raw mode code.
836 * Disable interrupts before doing the world switch.
837 */
838 case VMMR0_DO_RAW_RUN:
839 {
840#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
841 /* Some safety precautions first. */
842 if (RT_UNLIKELY(!PGMGetHyperCR3(pVCpu)))
843 {
844 pVCpu->vmm.s.iLastGZRc = VERR_PGM_NO_CR3_SHADOW_ROOT;
845 break;
846 }
847#endif
848
849 /* Disable preemption and update the periodic preemption timer. */
850 RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
851 RTThreadPreemptDisable(&PreemptState);
852 RTCPUID idHostCpu = RTMpCpuId();
853#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
854 CPUMR0SetLApic(pVCpu, idHostCpu);
855#endif
856 ASMAtomicWriteU32(&pVCpu->idHostCpu, idHostCpu);
857 if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
858 GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
859
860 /* We might need to disable VT-x if the active switcher turns off paging. */
861 bool fVTxDisabled;
862 int rc = HMR0EnterSwitcher(pVM, pVM->vmm.s.enmSwitcher, &fVTxDisabled);
863 if (RT_SUCCESS(rc))
864 {
865 RTCCUINTREG uFlags = ASMIntDisableFlags();
866
867 for (;;)
868 {
869 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC);
870 TMNotifyStartOfExecution(pVCpu);
871
872 rc = pVM->vmm.s.pfnR0ToRawMode(pVM);
873 pVCpu->vmm.s.iLastGZRc = rc;
874
875 TMNotifyEndOfExecution(pVCpu);
876 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
877
878 if (rc != VINF_VMM_CALL_TRACER)
879 break;
880 SUPR0TracerUmodProbeFire(pVM->pSession, &pVCpu->vmm.s.TracerCtx);
881 }
882
883 /* Re-enable VT-x if previously turned off. */
884 HMR0LeaveSwitcher(pVM, fVTxDisabled);
885
886 if ( rc == VINF_EM_RAW_INTERRUPT
887 || rc == VINF_EM_RAW_INTERRUPT_HYPER)
888 TRPMR0DispatchHostInterrupt(pVM);
889
890 ASMSetFlags(uFlags);
891
892#ifdef VBOX_WITH_STATISTICS
893 STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
894 vmmR0RecordRC(pVM, pVCpu, rc);
895#endif
896 }
897 else
898 pVCpu->vmm.s.iLastGZRc = rc;
899 ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
900 RTThreadPreemptRestore(&PreemptState);
901 break;
902 }
903
904 /*
905 * Run guest code using the available hardware acceleration technology.
906 */
907 case VMMR0_DO_HM_RUN:
908 {
909 Assert(!VMMR0ThreadCtxHooksAreRegistered(pVCpu));
910 RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
911 RTThreadPreemptDisable(&PreemptState);
912
913 /* Update the VCPU <-> host CPU mapping before doing anything else. */
914 ASMAtomicWriteU32(&pVCpu->idHostCpu, RTMpCpuId());
915 if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
916 GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
917#ifdef LOG_ENABLED
918 if (pVCpu->idCpu > 0)
919 {
920 /* Lazy registration of ring 0 loggers. */
921 PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
922 if ( pR0Logger
923 && !pR0Logger->fRegistered)
924 {
925 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
926 pR0Logger->fRegistered = true;
927 }
928 }
929#endif
930
931 int rc;
932 bool fPreemptRestored = false;
933 if (!HMR0SuspendPending())
934 {
935 /* Register thread-context hooks if required. */
936 if ( VMMR0ThreadCtxHooksAreCreated(pVCpu)
937 && !VMMR0ThreadCtxHooksAreRegistered(pVCpu))
938 {
939 rc = VMMR0ThreadCtxHooksRegister(pVCpu, vmmR0ThreadCtxCallback);
940 AssertRC(rc);
941 }
942
943 /* Enter HM context. */
944 rc = HMR0Enter(pVM, pVCpu);
945 if (RT_SUCCESS(rc))
946 {
947 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_HM);
948
949 /* When preemption hooks are in place, enable preemption now that we're in HM context. */
950 if (VMMR0ThreadCtxHooksAreRegistered(pVCpu))
951 {
952 fPreemptRestored = true;
953 RTThreadPreemptRestore(&PreemptState);
954 }
955
956 /* Setup the longjmp machinery and execute guest code. */
957 rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, HMR0RunGuestCode, pVM, pVCpu);
958
959 /* Manual assert as normal assertions are going to crash in this case. */
960 if (RT_UNLIKELY( VMCPU_GET_STATE(pVCpu) != VMCPUSTATE_STARTED_HM
961 && RT_SUCCESS_NP(rc) && rc != VINF_VMM_CALL_HOST ))
962 {
963 pVM->vmm.s.szRing0AssertMsg1[0] = '\0';
964 RTStrPrintf(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2),
965 "Got VMCPU state %d expected %d.\n", VMCPU_GET_STATE(pVCpu), VMCPUSTATE_STARTED_HM);
966 rc = VERR_VMM_WRONG_HM_VMCPU_STATE;
967 }
968 else if (RT_UNLIKELY(VMMR0ThreadCtxHooksAreRegistered(pVCpu)))
969 {
970 pVM->vmm.s.szRing0AssertMsg1[0] = '\0';
971 RTStrPrintf(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2),
972 "Thread-context hooks still registered! VCPU=%p Id=%u rc=%d.\n", pVCpu, pVCpu->idCpu, rc);
973 rc = VERR_INVALID_STATE;
974 }
975
976 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
977 }
978 STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
979 }
980 else
981 {
982 /* System is about to go into suspend mode; go back to ring 3. */
983 rc = VINF_EM_RAW_INTERRUPT;
984 }
985 pVCpu->vmm.s.iLastGZRc = rc;
986
987 /* Clear the VCPU <-> host CPU mapping as we've left HM context. */
988 ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
989
990 if (!fPreemptRestored)
991 RTThreadPreemptRestore(&PreemptState);
992
993#ifdef VBOX_WITH_STATISTICS
994 vmmR0RecordRC(pVM, pVCpu, rc);
995#endif
996 /* No special action required for external interrupts, just return. */
997 break;
998 }
999
1000 /*
1001 * For profiling.
1002 */
1003 case VMMR0_DO_NOP:
1004 pVCpu->vmm.s.iLastGZRc = VINF_SUCCESS;
1005 break;
1006
1007 /*
1008 * Impossible.
1009 */
1010 default:
1011 AssertMsgFailed(("%#x\n", enmOperation));
1012 pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
1013 break;
1014 }
1015}
1016
1017
1018/**
1019 * Validates a session or VM session argument.
1020 *
1021 * @returns true / false accordingly.
1022 * @param pVM Pointer to the VM.
1023 * @param pSession The session argument.
1024 */
1025DECLINLINE(bool) vmmR0IsValidSession(PVM pVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
1026{
1027 /* This must be set! */
1028 if (!pSession)
1029 return false;
1030
1031 /* Only one out of the two. */
1032 if (pVM && pClaimedSession)
1033 return false;
1034 if (pVM)
1035 pClaimedSession = pVM->pSession;
1036 return pClaimedSession == pSession;
1037}
1038
1039
1040/**
1041 * VMMR0EntryEx worker function, either called directly or when ever possible
1042 * called thru a longjmp so we can exit safely on failure.
1043 *
1044 * @returns VBox status code.
1045 * @param pVM Pointer to the VM.
1046 * @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
1047 * is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
1048 * @param enmOperation Which operation to execute.
1049 * @param pReqHdr This points to a SUPVMMR0REQHDR packet. Optional.
1050 * The support driver validates this if it's present.
1051 * @param u64Arg Some simple constant argument.
1052 * @param pSession The session of the caller.
1053 * @remarks Assume called with interrupts _enabled_.
1054 */
1055static int vmmR0EntryExWorker(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg, PSUPDRVSESSION pSession)
1056{
1057 /*
1058 * Common VM pointer validation.
1059 */
1060 if (pVM)
1061 {
1062 if (RT_UNLIKELY( !VALID_PTR(pVM)
1063 || ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
1064 {
1065 SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p! (op=%d)\n", pVM, enmOperation);
1066 return VERR_INVALID_POINTER;
1067 }
1068 if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
1069 || pVM->enmVMState > VMSTATE_TERMINATED
1070 || pVM->pVMR0 != pVM))
1071 {
1072 SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{enmVMState=%d, .pVMR0=%p}! (op=%d)\n",
1073 pVM, pVM->enmVMState, pVM->pVMR0, enmOperation);
1074 return VERR_INVALID_POINTER;
1075 }
1076
1077 if (RT_UNLIKELY(idCpu >= pVM->cCpus && idCpu != NIL_VMCPUID))
1078 {
1079 SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu (%u vs cCpus=%u)\n", idCpu, pVM->cCpus);
1080 return VERR_INVALID_PARAMETER;
1081 }
1082 }
1083 else if (RT_UNLIKELY(idCpu != NIL_VMCPUID))
1084 {
1085 SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu=%u\n", idCpu);
1086 return VERR_INVALID_PARAMETER;
1087 }
1088
1089
1090 switch (enmOperation)
1091 {
1092 /*
1093 * GVM requests
1094 */
1095 case VMMR0_DO_GVMM_CREATE_VM:
1096 if (pVM || u64Arg || idCpu != NIL_VMCPUID)
1097 return VERR_INVALID_PARAMETER;
1098 return GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr);
1099
1100 case VMMR0_DO_GVMM_DESTROY_VM:
1101 if (pReqHdr || u64Arg)
1102 return VERR_INVALID_PARAMETER;
1103 return GVMMR0DestroyVM(pVM);
1104
1105 case VMMR0_DO_GVMM_REGISTER_VMCPU:
1106 {
1107 if (!pVM)
1108 return VERR_INVALID_PARAMETER;
1109 return GVMMR0RegisterVCpu(pVM, idCpu);
1110 }
1111
1112 case VMMR0_DO_GVMM_SCHED_HALT:
1113 if (pReqHdr)
1114 return VERR_INVALID_PARAMETER;
1115 return GVMMR0SchedHalt(pVM, idCpu, u64Arg);
1116
1117 case VMMR0_DO_GVMM_SCHED_WAKE_UP:
1118 if (pReqHdr || u64Arg)
1119 return VERR_INVALID_PARAMETER;
1120 return GVMMR0SchedWakeUp(pVM, idCpu);
1121
1122 case VMMR0_DO_GVMM_SCHED_POKE:
1123 if (pReqHdr || u64Arg)
1124 return VERR_INVALID_PARAMETER;
1125 return GVMMR0SchedPoke(pVM, idCpu);
1126
1127 case VMMR0_DO_GVMM_SCHED_WAKE_UP_AND_POKE_CPUS:
1128 if (u64Arg)
1129 return VERR_INVALID_PARAMETER;
1130 return GVMMR0SchedWakeUpAndPokeCpusReq(pVM, (PGVMMSCHEDWAKEUPANDPOKECPUSREQ)pReqHdr);
1131
1132 case VMMR0_DO_GVMM_SCHED_POLL:
1133 if (pReqHdr || u64Arg > 1)
1134 return VERR_INVALID_PARAMETER;
1135 return GVMMR0SchedPoll(pVM, idCpu, !!u64Arg);
1136
1137 case VMMR0_DO_GVMM_QUERY_STATISTICS:
1138 if (u64Arg)
1139 return VERR_INVALID_PARAMETER;
1140 return GVMMR0QueryStatisticsReq(pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr);
1141
1142 case VMMR0_DO_GVMM_RESET_STATISTICS:
1143 if (u64Arg)
1144 return VERR_INVALID_PARAMETER;
1145 return GVMMR0ResetStatisticsReq(pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr);
1146
1147 /*
1148 * Initialize the R0 part of a VM instance.
1149 */
1150 case VMMR0_DO_VMMR0_INIT:
1151 return vmmR0InitVM(pVM, RT_LODWORD(u64Arg), RT_HIDWORD(u64Arg));
1152
1153 /*
1154 * Terminate the R0 part of a VM instance.
1155 */
1156 case VMMR0_DO_VMMR0_TERM:
1157 return VMMR0TermVM(pVM, NULL);
1158
1159 /*
1160 * Attempt to enable hm mode and check the current setting.
1161 */
1162 case VMMR0_DO_HM_ENABLE:
1163 return HMR0EnableAllCpus(pVM);
1164
1165 /*
1166 * Setup the hardware accelerated session.
1167 */
1168 case VMMR0_DO_HM_SETUP_VM:
1169 return HMR0SetupVM(pVM);
1170
1171 /*
1172 * Switch to RC to execute Hypervisor function.
1173 */
1174 case VMMR0_DO_CALL_HYPERVISOR:
1175 {
1176 int rc;
1177 bool fVTxDisabled;
1178
1179#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
1180 if (RT_UNLIKELY(!PGMGetHyperCR3(VMMGetCpu0(pVM))))
1181 return VERR_PGM_NO_CR3_SHADOW_ROOT;
1182#endif
1183
1184 RTCCUINTREG fFlags = ASMIntDisableFlags();
1185
1186#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
1187 RTCPUID idHostCpu = RTMpCpuId();
1188 CPUMR0SetLApic(&pVM->aCpus[0], idHostCpu);
1189#endif
1190
1191 /* We might need to disable VT-x if the active switcher turns off paging. */
1192 rc = HMR0EnterSwitcher(pVM, pVM->vmm.s.enmSwitcher, &fVTxDisabled);
1193 if (RT_FAILURE(rc))
1194 return rc;
1195
1196 rc = pVM->vmm.s.pfnR0ToRawMode(pVM);
1197
1198 /* Re-enable VT-x if previously turned off. */
1199 HMR0LeaveSwitcher(pVM, fVTxDisabled);
1200
1201 /** @todo dispatch interrupts? */
1202 ASMSetFlags(fFlags);
1203 return rc;
1204 }
1205
1206 /*
1207 * PGM wrappers.
1208 */
1209 case VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES:
1210 if (idCpu == NIL_VMCPUID)
1211 return VERR_INVALID_CPU_ID;
1212 return PGMR0PhysAllocateHandyPages(pVM, &pVM->aCpus[idCpu]);
1213
1214 case VMMR0_DO_PGM_FLUSH_HANDY_PAGES:
1215 if (idCpu == NIL_VMCPUID)
1216 return VERR_INVALID_CPU_ID;
1217 return PGMR0PhysFlushHandyPages(pVM, &pVM->aCpus[idCpu]);
1218
1219 case VMMR0_DO_PGM_ALLOCATE_LARGE_HANDY_PAGE:
1220 if (idCpu == NIL_VMCPUID)
1221 return VERR_INVALID_CPU_ID;
1222 return PGMR0PhysAllocateLargeHandyPage(pVM, &pVM->aCpus[idCpu]);
1223
1224 case VMMR0_DO_PGM_PHYS_SETUP_IOMMU:
1225 if (idCpu != 0)
1226 return VERR_INVALID_CPU_ID;
1227 return PGMR0PhysSetupIommu(pVM);
1228
1229 /*
1230 * GMM wrappers.
1231 */
1232 case VMMR0_DO_GMM_INITIAL_RESERVATION:
1233 if (u64Arg)
1234 return VERR_INVALID_PARAMETER;
1235 return GMMR0InitialReservationReq(pVM, idCpu, (PGMMINITIALRESERVATIONREQ)pReqHdr);
1236
1237 case VMMR0_DO_GMM_UPDATE_RESERVATION:
1238 if (u64Arg)
1239 return VERR_INVALID_PARAMETER;
1240 return GMMR0UpdateReservationReq(pVM, idCpu, (PGMMUPDATERESERVATIONREQ)pReqHdr);
1241
1242 case VMMR0_DO_GMM_ALLOCATE_PAGES:
1243 if (u64Arg)
1244 return VERR_INVALID_PARAMETER;
1245 return GMMR0AllocatePagesReq(pVM, idCpu, (PGMMALLOCATEPAGESREQ)pReqHdr);
1246
1247 case VMMR0_DO_GMM_FREE_PAGES:
1248 if (u64Arg)
1249 return VERR_INVALID_PARAMETER;
1250 return GMMR0FreePagesReq(pVM, idCpu, (PGMMFREEPAGESREQ)pReqHdr);
1251
1252 case VMMR0_DO_GMM_FREE_LARGE_PAGE:
1253 if (u64Arg)
1254 return VERR_INVALID_PARAMETER;
1255 return GMMR0FreeLargePageReq(pVM, idCpu, (PGMMFREELARGEPAGEREQ)pReqHdr);
1256
1257 case VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS:
1258 if (u64Arg)
1259 return VERR_INVALID_PARAMETER;
1260 return GMMR0QueryHypervisorMemoryStatsReq(pVM, (PGMMMEMSTATSREQ)pReqHdr);
1261
1262 case VMMR0_DO_GMM_QUERY_MEM_STATS:
1263 if (idCpu == NIL_VMCPUID)
1264 return VERR_INVALID_CPU_ID;
1265 if (u64Arg)
1266 return VERR_INVALID_PARAMETER;
1267 return GMMR0QueryMemoryStatsReq(pVM, idCpu, (PGMMMEMSTATSREQ)pReqHdr);
1268
1269 case VMMR0_DO_GMM_BALLOONED_PAGES:
1270 if (u64Arg)
1271 return VERR_INVALID_PARAMETER;
1272 return GMMR0BalloonedPagesReq(pVM, idCpu, (PGMMBALLOONEDPAGESREQ)pReqHdr);
1273
1274 case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
1275 if (u64Arg)
1276 return VERR_INVALID_PARAMETER;
1277 return GMMR0MapUnmapChunkReq(pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
1278
1279 case VMMR0_DO_GMM_SEED_CHUNK:
1280 if (pReqHdr)
1281 return VERR_INVALID_PARAMETER;
1282 return GMMR0SeedChunk(pVM, idCpu, (RTR3PTR)u64Arg);
1283
1284 case VMMR0_DO_GMM_REGISTER_SHARED_MODULE:
1285 if (idCpu == NIL_VMCPUID)
1286 return VERR_INVALID_CPU_ID;
1287 if (u64Arg)
1288 return VERR_INVALID_PARAMETER;
1289 return GMMR0RegisterSharedModuleReq(pVM, idCpu, (PGMMREGISTERSHAREDMODULEREQ)pReqHdr);
1290
1291 case VMMR0_DO_GMM_UNREGISTER_SHARED_MODULE:
1292 if (idCpu == NIL_VMCPUID)
1293 return VERR_INVALID_CPU_ID;
1294 if (u64Arg)
1295 return VERR_INVALID_PARAMETER;
1296 return GMMR0UnregisterSharedModuleReq(pVM, idCpu, (PGMMUNREGISTERSHAREDMODULEREQ)pReqHdr);
1297
1298 case VMMR0_DO_GMM_RESET_SHARED_MODULES:
1299 if (idCpu == NIL_VMCPUID)
1300 return VERR_INVALID_CPU_ID;
1301 if ( u64Arg
1302 || pReqHdr)
1303 return VERR_INVALID_PARAMETER;
1304 return GMMR0ResetSharedModules(pVM, idCpu);
1305
1306#ifdef VBOX_WITH_PAGE_SHARING
1307 case VMMR0_DO_GMM_CHECK_SHARED_MODULES:
1308 {
1309 if (idCpu == NIL_VMCPUID)
1310 return VERR_INVALID_CPU_ID;
1311 if ( u64Arg
1312 || pReqHdr)
1313 return VERR_INVALID_PARAMETER;
1314
1315 PVMCPU pVCpu = &pVM->aCpus[idCpu];
1316 Assert(pVCpu->hNativeThreadR0 == RTThreadNativeSelf());
1317
1318# ifdef DEBUG_sandervl
1319 /* Make sure that log flushes can jump back to ring-3; annoying to get an incomplete log (this is risky though as the code doesn't take this into account). */
1320 /* Todo: this can have bad side effects for unexpected jumps back to r3. */
1321 int rc = GMMR0CheckSharedModulesStart(pVM);
1322 if (rc == VINF_SUCCESS)
1323 {
1324 rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, GMMR0CheckSharedModules, pVM, pVCpu); /* this may resume code. */
1325 Assert( rc == VINF_SUCCESS
1326 || (rc == VINF_VMM_CALL_HOST && pVCpu->vmm.s.enmCallRing3Operation == VMMCALLRING3_VMM_LOGGER_FLUSH));
1327 GMMR0CheckSharedModulesEnd(pVM);
1328 }
1329# else
1330 int rc = GMMR0CheckSharedModules(pVM, pVCpu);
1331# endif
1332 return rc;
1333 }
1334#endif
1335
1336#if defined(VBOX_STRICT) && HC_ARCH_BITS == 64
1337 case VMMR0_DO_GMM_FIND_DUPLICATE_PAGE:
1338 if (u64Arg)
1339 return VERR_INVALID_PARAMETER;
1340 return GMMR0FindDuplicatePageReq(pVM, (PGMMFINDDUPLICATEPAGEREQ)pReqHdr);
1341#endif
1342
1343 case VMMR0_DO_GMM_QUERY_STATISTICS:
1344 if (u64Arg)
1345 return VERR_INVALID_PARAMETER;
1346 return GMMR0QueryStatisticsReq(pVM, (PGMMQUERYSTATISTICSSREQ)pReqHdr);
1347
1348 case VMMR0_DO_GMM_RESET_STATISTICS:
1349 if (u64Arg)
1350 return VERR_INVALID_PARAMETER;
1351 return GMMR0ResetStatisticsReq(pVM, (PGMMRESETSTATISTICSSREQ)pReqHdr);
1352
1353 /*
1354 * A quick GCFGM mock-up.
1355 */
1356 /** @todo GCFGM with proper access control, ring-3 management interface and all that. */
1357 case VMMR0_DO_GCFGM_SET_VALUE:
1358 case VMMR0_DO_GCFGM_QUERY_VALUE:
1359 {
1360 if (pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
1361 return VERR_INVALID_PARAMETER;
1362 PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
1363 if (pReq->Hdr.cbReq != sizeof(*pReq))
1364 return VERR_INVALID_PARAMETER;
1365 int rc;
1366 if (enmOperation == VMMR0_DO_GCFGM_SET_VALUE)
1367 {
1368 rc = GVMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1369 //if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1370 // rc = GMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1371 }
1372 else
1373 {
1374 rc = GVMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1375 //if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1376 // rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1377 }
1378 return rc;
1379 }
1380
1381 /*
1382 * PDM Wrappers.
1383 */
1384 case VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER:
1385 {
1386 if (!pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
1387 return VERR_INVALID_PARAMETER;
1388 return PDMR0DriverCallReqHandler(pVM, (PPDMDRIVERCALLREQHANDLERREQ)pReqHdr);
1389 }
1390
1391 case VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER:
1392 {
1393 if (!pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
1394 return VERR_INVALID_PARAMETER;
1395 return PDMR0DeviceCallReqHandler(pVM, (PPDMDEVICECALLREQHANDLERREQ)pReqHdr);
1396 }
1397
1398 /*
1399 * Requests to the internal networking service.
1400 */
1401 case VMMR0_DO_INTNET_OPEN:
1402 {
1403 PINTNETOPENREQ pReq = (PINTNETOPENREQ)pReqHdr;
1404 if (u64Arg || !pReq || !vmmR0IsValidSession(pVM, pReq->pSession, pSession) || idCpu != NIL_VMCPUID)
1405 return VERR_INVALID_PARAMETER;
1406 return IntNetR0OpenReq(pSession, pReq);
1407 }
1408
1409 case VMMR0_DO_INTNET_IF_CLOSE:
1410 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1411 return VERR_INVALID_PARAMETER;
1412 return IntNetR0IfCloseReq(pSession, (PINTNETIFCLOSEREQ)pReqHdr);
1413
1414 case VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS:
1415 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFGETBUFFERPTRSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1416 return VERR_INVALID_PARAMETER;
1417 return IntNetR0IfGetBufferPtrsReq(pSession, (PINTNETIFGETBUFFERPTRSREQ)pReqHdr);
1418
1419 case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
1420 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1421 return VERR_INVALID_PARAMETER;
1422 return IntNetR0IfSetPromiscuousModeReq(pSession, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
1423
1424 case VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS:
1425 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1426 return VERR_INVALID_PARAMETER;
1427 return IntNetR0IfSetMacAddressReq(pSession, (PINTNETIFSETMACADDRESSREQ)pReqHdr);
1428
1429 case VMMR0_DO_INTNET_IF_SET_ACTIVE:
1430 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1431 return VERR_INVALID_PARAMETER;
1432 return IntNetR0IfSetActiveReq(pSession, (PINTNETIFSETACTIVEREQ)pReqHdr);
1433
1434 case VMMR0_DO_INTNET_IF_SEND:
1435 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1436 return VERR_INVALID_PARAMETER;
1437 return IntNetR0IfSendReq(pSession, (PINTNETIFSENDREQ)pReqHdr);
1438
1439 case VMMR0_DO_INTNET_IF_WAIT:
1440 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1441 return VERR_INVALID_PARAMETER;
1442 return IntNetR0IfWaitReq(pSession, (PINTNETIFWAITREQ)pReqHdr);
1443
1444 case VMMR0_DO_INTNET_IF_ABORT_WAIT:
1445 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1446 return VERR_INVALID_PARAMETER;
1447 return IntNetR0IfAbortWaitReq(pSession, (PINTNETIFABORTWAITREQ)pReqHdr);
1448
1449#ifdef VBOX_WITH_PCI_PASSTHROUGH
1450 /*
1451 * Requests to host PCI driver service.
1452 */
1453 case VMMR0_DO_PCIRAW_REQ:
1454 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PPCIRAWSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1455 return VERR_INVALID_PARAMETER;
1456 return PciRawR0ProcessReq(pSession, pVM, (PPCIRAWSENDREQ)pReqHdr);
1457#endif
1458 /*
1459 * For profiling.
1460 */
1461 case VMMR0_DO_NOP:
1462 case VMMR0_DO_SLOW_NOP:
1463 return VINF_SUCCESS;
1464
1465 /*
1466 * For testing Ring-0 APIs invoked in this environment.
1467 */
1468 case VMMR0_DO_TESTS:
1469 /** @todo make new test */
1470 return VINF_SUCCESS;
1471
1472
1473#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1474 case VMMR0_DO_TEST_SWITCHER3264:
1475 if (idCpu == NIL_VMCPUID)
1476 return VERR_INVALID_CPU_ID;
1477 return HMR0TestSwitcher3264(pVM);
1478#endif
1479 default:
1480 /*
1481 * We're returning VERR_NOT_SUPPORT here so we've got something else
1482 * than -1 which the interrupt gate glue code might return.
1483 */
1484 Log(("operation %#x is not supported\n", enmOperation));
1485 return VERR_NOT_SUPPORTED;
1486 }
1487}
1488
1489
1490/**
1491 * Argument for vmmR0EntryExWrapper containing the arguments for VMMR0EntryEx.
1492 */
1493typedef struct VMMR0ENTRYEXARGS
1494{
1495 PVM pVM;
1496 VMCPUID idCpu;
1497 VMMR0OPERATION enmOperation;
1498 PSUPVMMR0REQHDR pReq;
1499 uint64_t u64Arg;
1500 PSUPDRVSESSION pSession;
1501} VMMR0ENTRYEXARGS;
1502/** Pointer to a vmmR0EntryExWrapper argument package. */
1503typedef VMMR0ENTRYEXARGS *PVMMR0ENTRYEXARGS;
1504
1505/**
1506 * This is just a longjmp wrapper function for VMMR0EntryEx calls.
1507 *
1508 * @returns VBox status code.
1509 * @param pvArgs The argument package
1510 */
1511static DECLCALLBACK(int) vmmR0EntryExWrapper(void *pvArgs)
1512{
1513 return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
1514 ((PVMMR0ENTRYEXARGS)pvArgs)->idCpu,
1515 ((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
1516 ((PVMMR0ENTRYEXARGS)pvArgs)->pReq,
1517 ((PVMMR0ENTRYEXARGS)pvArgs)->u64Arg,
1518 ((PVMMR0ENTRYEXARGS)pvArgs)->pSession);
1519}
1520
1521
1522/**
1523 * The Ring 0 entry point, called by the support library (SUP).
1524 *
1525 * @returns VBox status code.
1526 * @param pVM Pointer to the VM.
1527 * @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
1528 * is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
1529 * @param enmOperation Which operation to execute.
1530 * @param pReq Pointer to the SUPVMMR0REQHDR packet. Optional.
1531 * @param u64Arg Some simple constant argument.
1532 * @param pSession The session of the caller.
1533 * @remarks Assume called with interrupts _enabled_.
1534 */
1535VMMR0DECL(int) VMMR0EntryEx(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession)
1536{
1537 /*
1538 * Requests that should only happen on the EMT thread will be
1539 * wrapped in a setjmp so we can assert without causing trouble.
1540 */
1541 if ( VALID_PTR(pVM)
1542 && pVM->pVMR0
1543 && idCpu < pVM->cCpus)
1544 {
1545 switch (enmOperation)
1546 {
1547 /* These might/will be called before VMMR3Init. */
1548 case VMMR0_DO_GMM_INITIAL_RESERVATION:
1549 case VMMR0_DO_GMM_UPDATE_RESERVATION:
1550 case VMMR0_DO_GMM_ALLOCATE_PAGES:
1551 case VMMR0_DO_GMM_FREE_PAGES:
1552 case VMMR0_DO_GMM_BALLOONED_PAGES:
1553 /* On the mac we might not have a valid jmp buf, so check these as well. */
1554 case VMMR0_DO_VMMR0_INIT:
1555 case VMMR0_DO_VMMR0_TERM:
1556 {
1557 PVMCPU pVCpu = &pVM->aCpus[idCpu];
1558
1559 if (!pVCpu->vmm.s.CallRing3JmpBufR0.pvSavedStack)
1560 break;
1561
1562 /** @todo validate this EMT claim... GVM knows. */
1563 VMMR0ENTRYEXARGS Args;
1564 Args.pVM = pVM;
1565 Args.idCpu = idCpu;
1566 Args.enmOperation = enmOperation;
1567 Args.pReq = pReq;
1568 Args.u64Arg = u64Arg;
1569 Args.pSession = pSession;
1570 return vmmR0CallRing3SetJmpEx(&pVCpu->vmm.s.CallRing3JmpBufR0, vmmR0EntryExWrapper, &Args);
1571 }
1572
1573 default:
1574 break;
1575 }
1576 }
1577 return vmmR0EntryExWorker(pVM, idCpu, enmOperation, pReq, u64Arg, pSession);
1578}
1579
1580
1581/**
1582 * Checks whether we've armed the ring-0 long jump machinery.
1583 *
1584 * @returns @c true / @c false
1585 * @param pVCpu Pointer to the VMCPU.
1586 * @thread EMT
1587 * @sa VMMIsLongJumpArmed
1588 */
1589VMMR0_INT_DECL(bool) VMMR0IsLongJumpArmed(PVMCPU pVCpu)
1590{
1591#ifdef RT_ARCH_X86
1592 return pVCpu->vmm.s.CallRing3JmpBufR0.eip
1593 && !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call;
1594#else
1595 return pVCpu->vmm.s.CallRing3JmpBufR0.rip
1596 && !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call;
1597#endif
1598}
1599
1600
1601/**
1602 * Checks whether we've done a ring-3 long jump.
1603 *
1604 * @returns @c true / @c false
1605 * @param pVCpu Pointer to the VMCPU.
1606 * @thread EMT
1607 */
1608VMMR0_INT_DECL(bool) VMMR0IsInRing3LongJump(PVMCPU pVCpu)
1609{
1610 return pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call;
1611}
1612
1613
1614/**
1615 * Internal R0 logger worker: Flush logger.
1616 *
1617 * @param pLogger The logger instance to flush.
1618 * @remark This function must be exported!
1619 */
1620VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger)
1621{
1622#ifdef LOG_ENABLED
1623 /*
1624 * Convert the pLogger into a VM handle and 'call' back to Ring-3.
1625 * (This is a bit paranoid code.)
1626 */
1627 PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1628 if ( !VALID_PTR(pR0Logger)
1629 || !VALID_PTR(pR0Logger + 1)
1630 || pLogger->u32Magic != RTLOGGER_MAGIC)
1631 {
1632# ifdef DEBUG
1633 SUPR0Printf("vmmR0LoggerFlush: pLogger=%p!\n", pLogger);
1634# endif
1635 return;
1636 }
1637 if (pR0Logger->fFlushingDisabled)
1638 return; /* quietly */
1639
1640 PVM pVM = pR0Logger->pVM;
1641 if ( !VALID_PTR(pVM)
1642 || pVM->pVMR0 != pVM)
1643 {
1644# ifdef DEBUG
1645 SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
1646# endif
1647 return;
1648 }
1649
1650 PVMCPU pVCpu = VMMGetCpu(pVM);
1651 if (pVCpu)
1652 {
1653 /*
1654 * Check that the jump buffer is armed.
1655 */
1656# ifdef RT_ARCH_X86
1657 if ( !pVCpu->vmm.s.CallRing3JmpBufR0.eip
1658 || pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1659# else
1660 if ( !pVCpu->vmm.s.CallRing3JmpBufR0.rip
1661 || pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1662# endif
1663 {
1664# ifdef DEBUG
1665 SUPR0Printf("vmmR0LoggerFlush: Jump buffer isn't armed!\n");
1666# endif
1667 return;
1668 }
1669 VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
1670 }
1671# ifdef DEBUG
1672 else
1673 SUPR0Printf("vmmR0LoggerFlush: invalid VCPU context!\n");
1674# endif
1675#endif
1676}
1677
1678/**
1679 * Internal R0 logger worker: Custom prefix.
1680 *
1681 * @returns Number of chars written.
1682 *
1683 * @param pLogger The logger instance.
1684 * @param pchBuf The output buffer.
1685 * @param cchBuf The size of the buffer.
1686 * @param pvUser User argument (ignored).
1687 */
1688VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char *pchBuf, size_t cchBuf, void *pvUser)
1689{
1690 NOREF(pvUser);
1691#ifdef LOG_ENABLED
1692 PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1693 if ( !VALID_PTR(pR0Logger)
1694 || !VALID_PTR(pR0Logger + 1)
1695 || pLogger->u32Magic != RTLOGGER_MAGIC
1696 || cchBuf < 2)
1697 return 0;
1698
1699 static const char s_szHex[17] = "0123456789abcdef";
1700 VMCPUID const idCpu = pR0Logger->idCpu;
1701 pchBuf[1] = s_szHex[ idCpu & 15];
1702 pchBuf[0] = s_szHex[(idCpu >> 4) & 15];
1703
1704 return 2;
1705#else
1706 return 0;
1707#endif
1708}
1709
1710#ifdef LOG_ENABLED
1711
1712/**
1713 * Disables flushing of the ring-0 debug log.
1714 *
1715 * @param pVCpu Pointer to the VMCPU.
1716 */
1717VMMR0DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu)
1718{
1719 if (pVCpu->vmm.s.pR0LoggerR0)
1720 pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
1721}
1722
1723
1724/**
1725 * Enables flushing of the ring-0 debug log.
1726 *
1727 * @param pVCpu Pointer to the VMCPU.
1728 */
1729VMMR0DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu)
1730{
1731 if (pVCpu->vmm.s.pR0LoggerR0)
1732 pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = false;
1733}
1734
1735
1736/**
1737 * Checks if log flushing is disabled or not.
1738 *
1739 * @param pVCpu Pointer to the VMCPU.
1740 */
1741VMMR0DECL(bool) VMMR0IsLogFlushDisabled(PVMCPU pVCpu)
1742{
1743 if (pVCpu->vmm.s.pR0LoggerR0)
1744 return pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled;
1745 return true;
1746}
1747#endif /* LOG_ENABLED */
1748
1749/**
1750 * Jump back to ring-3 if we're the EMT and the longjmp is armed.
1751 *
1752 * @returns true if the breakpoint should be hit, false if it should be ignored.
1753 */
1754DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void)
1755{
1756#if 0
1757 return true;
1758#else
1759 PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1760 if (pVM)
1761 {
1762 PVMCPU pVCpu = VMMGetCpu(pVM);
1763
1764 if (pVCpu)
1765 {
1766#ifdef RT_ARCH_X86
1767 if ( pVCpu->vmm.s.CallRing3JmpBufR0.eip
1768 && !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1769#else
1770 if ( pVCpu->vmm.s.CallRing3JmpBufR0.rip
1771 && !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1772#endif
1773 {
1774 int rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_ASSERTION, 0);
1775 return RT_FAILURE_NP(rc);
1776 }
1777 }
1778 }
1779#ifdef RT_OS_LINUX
1780 return true;
1781#else
1782 return false;
1783#endif
1784#endif
1785}
1786
1787
1788/**
1789 * Override this so we can push it up to ring-3.
1790 *
1791 * @param pszExpr Expression. Can be NULL.
1792 * @param uLine Location line number.
1793 * @param pszFile Location file name.
1794 * @param pszFunction Location function name.
1795 */
1796DECLEXPORT(void) RTCALL RTAssertMsg1Weak(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)
1797{
1798 /*
1799 * To the log.
1800 */
1801 LogAlways(("\n!!R0-Assertion Failed!!\n"
1802 "Expression: %s\n"
1803 "Location : %s(%d) %s\n",
1804 pszExpr, pszFile, uLine, pszFunction));
1805
1806 /*
1807 * To the global VMM buffer.
1808 */
1809 PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1810 if (pVM)
1811 RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
1812 "\n!!R0-Assertion Failed!!\n"
1813 "Expression: %s\n"
1814 "Location : %s(%d) %s\n",
1815 pszExpr, pszFile, uLine, pszFunction);
1816
1817 /*
1818 * Continue the normal way.
1819 */
1820 RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
1821}
1822
1823
1824/**
1825 * Callback for RTLogFormatV which writes to the ring-3 log port.
1826 * See PFNLOGOUTPUT() for details.
1827 */
1828static DECLCALLBACK(size_t) rtLogOutput(void *pv, const char *pachChars, size_t cbChars)
1829{
1830 for (size_t i = 0; i < cbChars; i++)
1831 LogAlways(("%c", pachChars[i]));
1832
1833 NOREF(pv);
1834 return cbChars;
1835}
1836
1837
1838/**
1839 * Override this so we can push it up to ring-3.
1840 *
1841 * @param pszFormat The format string.
1842 * @param va Arguments.
1843 */
1844DECLEXPORT(void) RTCALL RTAssertMsg2WeakV(const char *pszFormat, va_list va)
1845{
1846 va_list vaCopy;
1847
1848 /*
1849 * Push the message to the loggers.
1850 */
1851 PRTLOGGER pLog = RTLogGetDefaultInstance(); /* Don't initialize it here... */
1852 if (pLog)
1853 {
1854 va_copy(vaCopy, va);
1855 RTLogFormatV(rtLogOutput, pLog, pszFormat, vaCopy);
1856 va_end(vaCopy);
1857 }
1858 pLog = RTLogRelDefaultInstance();
1859 if (pLog)
1860 {
1861 va_copy(vaCopy, va);
1862 RTLogFormatV(rtLogOutput, pLog, pszFormat, vaCopy);
1863 va_end(vaCopy);
1864 }
1865
1866 /*
1867 * Push it to the global VMM buffer.
1868 */
1869 PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1870 if (pVM)
1871 {
1872 va_copy(vaCopy, va);
1873 RTStrPrintfV(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2), pszFormat, vaCopy);
1874 va_end(vaCopy);
1875 }
1876
1877 /*
1878 * Continue the normal way.
1879 */
1880 RTAssertMsg2V(pszFormat, va);
1881}
1882
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use