VirtualBox

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

Last change on this file since 48135 was 48135, checked in by vboxsync, 12 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette