VMMR0.cpp@ 53568

Last change on this file since 53568 was 53466, checked in by vboxsync, 10 years ago
VMM/MSRs: Added status codes for returning to ring-3 to service the MSR access.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 63.1 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: