VMMR0.cpp@ 47996

Last change on this file since 47996 was 47989, checked in by vboxsync, 12 years ago
VMM/VMMR0: Preemption hooks implemented and enabled for Solaris and Linux hosts.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 62.5 KB

Line
1	/* $Id: VMMR0.cpp 47989 2013-08-22 13:56:52Z vboxsync $ */
2	/** @file
3	* VMM - Host Context Ring 0.
4	*/
5
6	/*
7	* Copyright (C) 2006-2012 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/*******************************************************************************
19	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_VMM
22	#include <VBox/vmm/vmm.h>
23	#include <VBox/sup.h>
24	#include <VBox/vmm/trpm.h>
25	#include <VBox/vmm/cpum.h>
26	#include <VBox/vmm/pdmapi.h>
27	#include <VBox/vmm/pgm.h>
28	#include <VBox/vmm/stam.h>
29	#include <VBox/vmm/tm.h>
30	#include "VMMInternal.h"
31	#include <VBox/vmm/vm.h>
32	#ifdef VBOX_WITH_PCI_PASSTHROUGH
33	# include <VBox/vmm/pdmpci.h>
34	#endif
35
36	#include <VBox/vmm/gvmm.h>
37	#include <VBox/vmm/gmm.h>
38	#include <VBox/intnet.h>
39	#include <VBox/vmm/hm.h>
40	#include <VBox/param.h>
41	#include <VBox/err.h>
42	#include <VBox/version.h>
43	#include <VBox/log.h>
44
45	#include <iprt/asm-amd64-x86.h>
46	#include <iprt/assert.h>
47	#include <iprt/crc.h>
48	#include <iprt/mp.h>
49	#include <iprt/once.h>
50	#include <iprt/stdarg.h>
51	#include <iprt/string.h>
52	#include <iprt/thread.h>
53	#include <iprt/timer.h>
54
55	#include "dtrace/VBoxVMM.h"
56
57
58	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
59	# pragma intrinsic(_AddressOfReturnAddress)
60	#endif
61
62
63	/*******************************************************************************
64	* Internal Functions *
65	*******************************************************************************/
66	RT_C_DECLS_BEGIN
67	#if defined(RT_ARCH_X86) && (defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD))
68	extern uint64_t __udivdi3(uint64_t, uint64_t);
69	extern uint64_t __umoddi3(uint64_t, uint64_t);
70	#endif
71	RT_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 VBoxDDR0.r0 links against us. /
79	PFNRT 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. */
92	extern "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	*/
105	DECLEXPORT(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	*/
218	DECLEXPORT(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	*/
269	static 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 = CPUMR0Init(pVM); /** @todo rename to CPUMR0InitVM */
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	*/
403	VMMR0DECL(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	*/
439	VMMR0DECL(int) VMMR0ThreadCtxHooksCreate(PVMCPU pVCpu)
440	{
441	VMCPU_ASSERT_EMT(pVCpu);
442	Assert(pVCpu->vmm.s.hR0ThreadCtx == NIL_RTTHREADCTX);
443	int rc = RTThreadCtxHooksCreate(&pVCpu->vmm.s.hR0ThreadCtx);
444	if ( RT_SUCCESS(rc)
445	\|\| rc == VERR_NOT_SUPPORTED)
446	{
447	return VINF_SUCCESS;
448	}
449
450	Log(("RTThreadCtxHooksCreate failed! rc=%Rrc pVCpu=%p idCpu=%RU32\n", rc, pVCpu, pVCpu->idCpu));
451	return rc;
452	}
453
454
455	/**
456	* Releases the object reference for the thread-context hook.
457	*
458	* @param pVCpu Pointer to the VMCPU.
459	* @remarks Can be called from any thread.
460	*/
461	VMMR0DECL(void) VMMR0ThreadCtxHooksRelease(PVMCPU pVCpu)
462	{
463	RTThreadCtxHooksRelease(pVCpu->vmm.s.hR0ThreadCtx);
464	}
465
466
467	/**
468	* Registers the thread-context hook for this VCPU.
469	*
470	* @returns VBox status code.
471	* @param pVCpu Pointer to the VMCPU.
472	* @param pfnThreadHook Pointer to the thread-context callback.
473	*
474	* @thread EMT.
475	*/
476	VMMR0DECL(int) VMMR0ThreadCtxHooksRegister(PVMCPU pVCpu, PFNRTTHREADCTXHOOK pfnThreadHook)
477	{
478	VMCPU_ASSERT_EMT(pVCpu);
479	return RTThreadCtxHooksRegister(pVCpu->vmm.s.hR0ThreadCtx, pfnThreadHook, pVCpu);
480	}
481
482
483	/**
484	* Deregisters the thread-context hook for this VCPU.
485	*
486	* @returns VBox status code.
487	* @param pVCpu Pointer to the VMCPU.
488	*
489	* @thread EMT.
490	*/
491	VMMR0DECL(int) VMMR0ThreadCtxHooksDeregister(PVMCPU pVCpu)
492	{
493	return RTThreadCtxHooksDeregister(pVCpu->vmm.s.hR0ThreadCtx);
494	}
495
496
497	/**
498	* Whether thread-context hooks are created (implying they're supported) on this
499	* platform.
500	*
501	* @returns true if the hooks are created, false otherwise.
502	* @param pVCpu Pointer to the VMCPU.
503	*
504	* @remarks Can be called from any thread.
505	*/
506	VMMR0DECL(bool) VMMR0ThreadCtxHooksAreCreated(PVMCPU pVCpu)
507	{
508	return pVCpu->vmm.s.hR0ThreadCtx != NIL_RTTHREADCTX;
509	}
510
511
512	/**
513	* Whether thread-context hooks are registered for this VCPU.
514	*
515	* @returns true if registered, false otherwise.
516	* @param pVCpu Pointer to the VMCPU.
517	*/
518	VMMR0DECL(bool) VMMR0ThreadCtxHooksAreRegistered(PVMCPU pVCpu)
519	{
520	return RTThreadCtxHooksAreRegistered(pVCpu->vmm.s.hR0ThreadCtx);
521	}
522
523
524	/**
525	* VMM ring-0 thread-context callback.
526	*
527	* This does common HM state updating and calls the HM-specific thread-context
528	* callback.
529	*
530	* @param enmEvent The thread-context event.
531	* @param pvUser Opaque pointer to the VMCPU.
532	*/
533	static void vmmR0ThreadCtxCallback(RTTHREADCTXEVENT enmEvent, void *pvUser)
534	{
535	PVMCPU pVCpu = (PVMCPU)pvUser;
536
537	switch (enmEvent)
538	{
539	case RTTHREADCTXEVENT_RESUMED:
540	{
541	/** @todo Linux may call us with preemption enabled (really!) but technically we
542	* cannot get preempted here, otherwise we end up in an infinite recursion
543	* scenario (i.e. preempted in resume hook -> preempt hook -> resume hook... ad
544	* infinitum). Let's just disable preemption for now...
545	*/
546	bool fPreemptDisabled = false;
547	RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
548	if (RTThreadPreemptIsEnabled(NIL_RTTHREAD))
549	{
550	RTThreadPreemptDisable(&PreemptState);
551	fPreemptDisabled = true;
552	}
553
554	/* We need to update the VCPU <-> host CPU mapping. */
555	RTCPUID idHostCpu = RTMpCpuId();
556	ASMAtomicWriteU32(&pVCpu->idHostCpu, idHostCpu);
557
558	/* Invoke the HM-specific thread-context callback. */
559	HMR0ThreadCtxCallback(enmEvent, pvUser);
560
561	/* Restore preemption. */
562	if (fPreemptDisabled)
563	RTThreadPreemptRestore(&PreemptState);
564	break;
565	}
566
567	case RTTHREADCTXEVENT_PREEMPTING:
568	/*
569	* Sigh. See VMMGetCpu() used by VMCPU_ASSERT_EMT(). We cannot let several VCPUs
570	* have the same host CPU associated with it.
571	*/
572	ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
573	/* fallthru, no break! */
574	default:
575	/* Invoke the HM-specific thread-context callback. */
576	HMR0ThreadCtxCallback(enmEvent, pvUser);
577	break;
578	}
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	*/
590	static 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	*/
787	VMMR0DECL(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	*/
808	VMMR0DECL(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	* Disable interrupts before we do anything interesting. On Windows we avoid
890	* this by having the support driver raise the IRQL before calling us, this way
891	* we hope to get away with page faults and later calling into the kernel.
892	*/
893	case VMMR0_DO_HM_RUN:
894	{
895	#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
896	RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
897	RTThreadPreemptDisable(&PreemptState);
898	#elif !defined(RT_OS_WINDOWS)
899	RTCCUINTREG uFlags = ASMIntDisableFlags();
900	#endif
901	/* Update the VCPU <-> host CPU mapping before doing anything else. */
902	ASMAtomicWriteU32(&pVCpu->idHostCpu, RTMpCpuId());
903	if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
904	GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
905	#ifdef LOG_ENABLED
906	if (pVCpu->idCpu > 0)
907	{
908	/* Lazy registration of ring 0 loggers. */
909	PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
910	if ( pR0Logger
911	&& !pR0Logger->fRegistered)
912	{
913	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
914	pR0Logger->fRegistered = true;
915	}
916	}
917	#endif
918
919	int rc;
920	bool fPreemptRestored = false;
921	if (!HMR0SuspendPending())
922	{
923	/* Register thread-context hooks if required. */
924	#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
925	if ( VMMR0ThreadCtxHooksAreCreated(pVCpu)
926	&& !VMMR0ThreadCtxHooksAreRegistered(pVCpu))
927	{
928	rc = VMMR0ThreadCtxHooksRegister(pVCpu, vmmR0ThreadCtxCallback);
929	AssertRC(rc);
930	}
931	#endif
932
933	/* Enter HM context. */
934	rc = HMR0Enter(pVM, pVCpu);
935
936	/* When preemption hooks are in place, enable preemption now that we're in HM context. */
937	if (VMMR0ThreadCtxHooksAreRegistered(pVCpu))
938	{
939	fPreemptRestored = true;
940	RTThreadPreemptRestore(&PreemptState);
941	}
942
943	if (RT_SUCCESS(rc))
944	{
945	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_HM);
946
947	/* Setup the longjmp machinery and execute guest code. */
948	rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, HMR0RunGuestCode, pVM, pVCpu);
949
950	/* Leave HM context. This deregisters thread-context hooks if any. */
951	int rc2 = HMR0Leave(pVM, pVCpu);
952	AssertRC(rc2);
953
954	if (RT_UNLIKELY( VMCPU_GET_STATE(pVCpu) != VMCPUSTATE_STARTED_HM
955	&& RT_SUCCESS_NP(rc) && rc != VINF_VMM_CALL_HOST ))
956	{
957	/* Manual assert as normal assertions are going to crash in this case. */
958	pVM->vmm.s.szRing0AssertMsg1[0] = '\0';
959	RTStrPrintf(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2),
960	"Got VMCPU state %d expected %d.\n", VMCPU_GET_STATE(pVCpu), VMCPUSTATE_STARTED_HM);
961	rc = VERR_VMM_WRONG_HM_VMCPU_STATE;
962	}
963	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
964	}
965	STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
966	}
967	else
968	{
969	/* System is about to go into suspend mode; go back to ring 3. */
970	rc = VINF_EM_RAW_INTERRUPT;
971	}
972	pVCpu->vmm.s.iLastGZRc = rc;
973
974	/* Clear the VCPU <-> host CPU mapping as we've left HM context. */
975	ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
976
977	#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
978	if (!fPreemptRestored)
979	RTThreadPreemptRestore(&PreemptState);
980	#elif !defined(RT_OS_WINDOWS)
981	ASMSetFlags(uFlags);
982	#endif
983
984	#ifdef VBOX_WITH_STATISTICS
985	vmmR0RecordRC(pVM, pVCpu, rc);
986	#endif
987	/* No special action required for external interrupts, just return. */
988	break;
989	}
990
991	/*
992	* For profiling.
993	*/
994	case VMMR0_DO_NOP:
995	pVCpu->vmm.s.iLastGZRc = VINF_SUCCESS;
996	break;
997
998	/*
999	* Impossible.
1000	*/
1001	default:
1002	AssertMsgFailed(("%#x\n", enmOperation));
1003	pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
1004	break;
1005	}
1006	}
1007
1008
1009	/**
1010	* Validates a session or VM session argument.
1011	*
1012	* @returns true / false accordingly.
1013	* @param pVM Pointer to the VM.
1014	* @param pSession The session argument.
1015	*/
1016	DECLINLINE(bool) vmmR0IsValidSession(PVM pVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
1017	{
1018	/* This must be set! */
1019	if (!pSession)
1020	return false;
1021
1022	/* Only one out of the two. */
1023	if (pVM && pClaimedSession)
1024	return false;
1025	if (pVM)
1026	pClaimedSession = pVM->pSession;
1027	return pClaimedSession == pSession;
1028	}
1029
1030
1031	/**
1032	* VMMR0EntryEx worker function, either called directly or when ever possible
1033	* called thru a longjmp so we can exit safely on failure.
1034	*
1035	* @returns VBox status code.
1036	* @param pVM Pointer to the VM.
1037	* @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
1038	* is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
1039	* @param enmOperation Which operation to execute.
1040	* @param pReqHdr This points to a SUPVMMR0REQHDR packet. Optional.
1041	* The support driver validates this if it's present.
1042	* @param u64Arg Some simple constant argument.
1043	* @param pSession The session of the caller.
1044	* @remarks Assume called with interrupts _enabled_.
1045	*/
1046	static int vmmR0EntryExWorker(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg, PSUPDRVSESSION pSession)
1047	{
1048	/*
1049	* Common VM pointer validation.
1050	*/
1051	if (pVM)
1052	{
1053	if (RT_UNLIKELY( !VALID_PTR(pVM)
1054	\|\| ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
1055	{
1056	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p! (op=%d)\n", pVM, enmOperation);
1057	return VERR_INVALID_POINTER;
1058	}
1059	if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
1060	\|\| pVM->enmVMState > VMSTATE_TERMINATED
1061	\|\| pVM->pVMR0 != pVM))
1062	{
1063	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{enmVMState=%d, .pVMR0=%p}! (op=%d)\n",
1064	pVM, pVM->enmVMState, pVM->pVMR0, enmOperation);
1065	return VERR_INVALID_POINTER;
1066	}
1067
1068	if (RT_UNLIKELY(idCpu >= pVM->cCpus && idCpu != NIL_VMCPUID))
1069	{
1070	SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu (%u vs cCpus=%u)\n", idCpu, pVM->cCpus);
1071	return VERR_INVALID_PARAMETER;
1072	}
1073	}
1074	else if (RT_UNLIKELY(idCpu != NIL_VMCPUID))
1075	{
1076	SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu=%u\n", idCpu);
1077	return VERR_INVALID_PARAMETER;
1078	}
1079
1080
1081	switch (enmOperation)
1082	{
1083	/*
1084	* GVM requests
1085	*/
1086	case VMMR0_DO_GVMM_CREATE_VM:
1087	if (pVM \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1088	return VERR_INVALID_PARAMETER;
1089	return GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr);
1090
1091	case VMMR0_DO_GVMM_DESTROY_VM:
1092	if (pReqHdr \|\| u64Arg)
1093	return VERR_INVALID_PARAMETER;
1094	return GVMMR0DestroyVM(pVM);
1095
1096	case VMMR0_DO_GVMM_REGISTER_VMCPU:
1097	{
1098	if (!pVM)
1099	return VERR_INVALID_PARAMETER;
1100	return GVMMR0RegisterVCpu(pVM, idCpu);
1101	}
1102
1103	case VMMR0_DO_GVMM_SCHED_HALT:
1104	if (pReqHdr)
1105	return VERR_INVALID_PARAMETER;
1106	return GVMMR0SchedHalt(pVM, idCpu, u64Arg);
1107
1108	case VMMR0_DO_GVMM_SCHED_WAKE_UP:
1109	if (pReqHdr \|\| u64Arg)
1110	return VERR_INVALID_PARAMETER;
1111	return GVMMR0SchedWakeUp(pVM, idCpu);
1112
1113	case VMMR0_DO_GVMM_SCHED_POKE:
1114	if (pReqHdr \|\| u64Arg)
1115	return VERR_INVALID_PARAMETER;
1116	return GVMMR0SchedPoke(pVM, idCpu);
1117
1118	case VMMR0_DO_GVMM_SCHED_WAKE_UP_AND_POKE_CPUS:
1119	if (u64Arg)
1120	return VERR_INVALID_PARAMETER;
1121	return GVMMR0SchedWakeUpAndPokeCpusReq(pVM, (PGVMMSCHEDWAKEUPANDPOKECPUSREQ)pReqHdr);
1122
1123	case VMMR0_DO_GVMM_SCHED_POLL:
1124	if (pReqHdr \|\| u64Arg > 1)
1125	return VERR_INVALID_PARAMETER;
1126	return GVMMR0SchedPoll(pVM, idCpu, !!u64Arg);
1127
1128	case VMMR0_DO_GVMM_QUERY_STATISTICS:
1129	if (u64Arg)
1130	return VERR_INVALID_PARAMETER;
1131	return GVMMR0QueryStatisticsReq(pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr);
1132
1133	case VMMR0_DO_GVMM_RESET_STATISTICS:
1134	if (u64Arg)
1135	return VERR_INVALID_PARAMETER;
1136	return GVMMR0ResetStatisticsReq(pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr);
1137
1138	/*
1139	* Initialize the R0 part of a VM instance.
1140	*/
1141	case VMMR0_DO_VMMR0_INIT:
1142	return vmmR0InitVM(pVM, RT_LODWORD(u64Arg), RT_HIDWORD(u64Arg));
1143
1144	/*
1145	* Terminate the R0 part of a VM instance.
1146	*/
1147	case VMMR0_DO_VMMR0_TERM:
1148	return VMMR0TermVM(pVM, NULL);
1149
1150	/*
1151	* Attempt to enable hm mode and check the current setting.
1152	*/
1153	case VMMR0_DO_HM_ENABLE:
1154	return HMR0EnableAllCpus(pVM);
1155
1156	/*
1157	* Setup the hardware accelerated session.
1158	*/
1159	case VMMR0_DO_HM_SETUP_VM:
1160	return HMR0SetupVM(pVM);
1161
1162	/*
1163	* Switch to RC to execute Hypervisor function.
1164	*/
1165	case VMMR0_DO_CALL_HYPERVISOR:
1166	{
1167	int rc;
1168	bool fVTxDisabled;
1169
1170	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
1171	if (RT_UNLIKELY(!PGMGetHyperCR3(VMMGetCpu0(pVM))))
1172	return VERR_PGM_NO_CR3_SHADOW_ROOT;
1173	#endif
1174
1175	RTCCUINTREG fFlags = ASMIntDisableFlags();
1176
1177	#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
1178	RTCPUID idHostCpu = RTMpCpuId();
1179	CPUMR0SetLApic(&pVM->aCpus[0], idHostCpu);
1180	#endif
1181
1182	/* We might need to disable VT-x if the active switcher turns off paging. */
1183	rc = HMR0EnterSwitcher(pVM, pVM->vmm.s.enmSwitcher, &fVTxDisabled);
1184	if (RT_FAILURE(rc))
1185	return rc;
1186
1187	rc = pVM->vmm.s.pfnR0ToRawMode(pVM);
1188
1189	/* Re-enable VT-x if previously turned off. */
1190	HMR0LeaveSwitcher(pVM, fVTxDisabled);
1191
1192	/** @todo dispatch interrupts? */
1193	ASMSetFlags(fFlags);
1194	return rc;
1195	}
1196
1197	/*
1198	* PGM wrappers.
1199	*/
1200	case VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES:
1201	if (idCpu == NIL_VMCPUID)
1202	return VERR_INVALID_CPU_ID;
1203	return PGMR0PhysAllocateHandyPages(pVM, &pVM->aCpus[idCpu]);
1204
1205	case VMMR0_DO_PGM_FLUSH_HANDY_PAGES:
1206	if (idCpu == NIL_VMCPUID)
1207	return VERR_INVALID_CPU_ID;
1208	return PGMR0PhysFlushHandyPages(pVM, &pVM->aCpus[idCpu]);
1209
1210	case VMMR0_DO_PGM_ALLOCATE_LARGE_HANDY_PAGE:
1211	if (idCpu == NIL_VMCPUID)
1212	return VERR_INVALID_CPU_ID;
1213	return PGMR0PhysAllocateLargeHandyPage(pVM, &pVM->aCpus[idCpu]);
1214
1215	case VMMR0_DO_PGM_PHYS_SETUP_IOMMU:
1216	if (idCpu != 0)
1217	return VERR_INVALID_CPU_ID;
1218	return PGMR0PhysSetupIommu(pVM);
1219
1220	/*
1221	* GMM wrappers.
1222	*/
1223	case VMMR0_DO_GMM_INITIAL_RESERVATION:
1224	if (u64Arg)
1225	return VERR_INVALID_PARAMETER;
1226	return GMMR0InitialReservationReq(pVM, idCpu, (PGMMINITIALRESERVATIONREQ)pReqHdr);
1227
1228	case VMMR0_DO_GMM_UPDATE_RESERVATION:
1229	if (u64Arg)
1230	return VERR_INVALID_PARAMETER;
1231	return GMMR0UpdateReservationReq(pVM, idCpu, (PGMMUPDATERESERVATIONREQ)pReqHdr);
1232
1233	case VMMR0_DO_GMM_ALLOCATE_PAGES:
1234	if (u64Arg)
1235	return VERR_INVALID_PARAMETER;
1236	return GMMR0AllocatePagesReq(pVM, idCpu, (PGMMALLOCATEPAGESREQ)pReqHdr);
1237
1238	case VMMR0_DO_GMM_FREE_PAGES:
1239	if (u64Arg)
1240	return VERR_INVALID_PARAMETER;
1241	return GMMR0FreePagesReq(pVM, idCpu, (PGMMFREEPAGESREQ)pReqHdr);
1242
1243	case VMMR0_DO_GMM_FREE_LARGE_PAGE:
1244	if (u64Arg)
1245	return VERR_INVALID_PARAMETER;
1246	return GMMR0FreeLargePageReq(pVM, idCpu, (PGMMFREELARGEPAGEREQ)pReqHdr);
1247
1248	case VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS:
1249	if (u64Arg)
1250	return VERR_INVALID_PARAMETER;
1251	return GMMR0QueryHypervisorMemoryStatsReq(pVM, (PGMMMEMSTATSREQ)pReqHdr);
1252
1253	case VMMR0_DO_GMM_QUERY_MEM_STATS:
1254	if (idCpu == NIL_VMCPUID)
1255	return VERR_INVALID_CPU_ID;
1256	if (u64Arg)
1257	return VERR_INVALID_PARAMETER;
1258	return GMMR0QueryMemoryStatsReq(pVM, idCpu, (PGMMMEMSTATSREQ)pReqHdr);
1259
1260	case VMMR0_DO_GMM_BALLOONED_PAGES:
1261	if (u64Arg)
1262	return VERR_INVALID_PARAMETER;
1263	return GMMR0BalloonedPagesReq(pVM, idCpu, (PGMMBALLOONEDPAGESREQ)pReqHdr);
1264
1265	case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
1266	if (u64Arg)
1267	return VERR_INVALID_PARAMETER;
1268	return GMMR0MapUnmapChunkReq(pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
1269
1270	case VMMR0_DO_GMM_SEED_CHUNK:
1271	if (pReqHdr)
1272	return VERR_INVALID_PARAMETER;
1273	return GMMR0SeedChunk(pVM, idCpu, (RTR3PTR)u64Arg);
1274
1275	case VMMR0_DO_GMM_REGISTER_SHARED_MODULE:
1276	if (idCpu == NIL_VMCPUID)
1277	return VERR_INVALID_CPU_ID;
1278	if (u64Arg)
1279	return VERR_INVALID_PARAMETER;
1280	return GMMR0RegisterSharedModuleReq(pVM, idCpu, (PGMMREGISTERSHAREDMODULEREQ)pReqHdr);
1281
1282	case VMMR0_DO_GMM_UNREGISTER_SHARED_MODULE:
1283	if (idCpu == NIL_VMCPUID)
1284	return VERR_INVALID_CPU_ID;
1285	if (u64Arg)
1286	return VERR_INVALID_PARAMETER;
1287	return GMMR0UnregisterSharedModuleReq(pVM, idCpu, (PGMMUNREGISTERSHAREDMODULEREQ)pReqHdr);
1288
1289	case VMMR0_DO_GMM_RESET_SHARED_MODULES:
1290	if (idCpu == NIL_VMCPUID)
1291	return VERR_INVALID_CPU_ID;
1292	if ( u64Arg
1293	\|\| pReqHdr)
1294	return VERR_INVALID_PARAMETER;
1295	return GMMR0ResetSharedModules(pVM, idCpu);
1296
1297	#ifdef VBOX_WITH_PAGE_SHARING
1298	case VMMR0_DO_GMM_CHECK_SHARED_MODULES:
1299	{
1300	if (idCpu == NIL_VMCPUID)
1301	return VERR_INVALID_CPU_ID;
1302	if ( u64Arg
1303	\|\| pReqHdr)
1304	return VERR_INVALID_PARAMETER;
1305
1306	PVMCPU pVCpu = &pVM->aCpus[idCpu];
1307	Assert(pVCpu->hNativeThreadR0 == RTThreadNativeSelf());
1308
1309	# ifdef DEBUG_sandervl
1310	/* 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). */
1311	/* Todo: this can have bad side effects for unexpected jumps back to r3. */
1312	int rc = GMMR0CheckSharedModulesStart(pVM);
1313	if (rc == VINF_SUCCESS)
1314	{
1315	rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, GMMR0CheckSharedModules, pVM, pVCpu); /* this may resume code. */
1316	Assert( rc == VINF_SUCCESS
1317	\|\| (rc == VINF_VMM_CALL_HOST && pVCpu->vmm.s.enmCallRing3Operation == VMMCALLRING3_VMM_LOGGER_FLUSH));
1318	GMMR0CheckSharedModulesEnd(pVM);
1319	}
1320	# else
1321	int rc = GMMR0CheckSharedModules(pVM, pVCpu);
1322	# endif
1323	return rc;
1324	}
1325	#endif
1326
1327	#if defined(VBOX_STRICT) && HC_ARCH_BITS == 64
1328	case VMMR0_DO_GMM_FIND_DUPLICATE_PAGE:
1329	if (u64Arg)
1330	return VERR_INVALID_PARAMETER;
1331	return GMMR0FindDuplicatePageReq(pVM, (PGMMFINDDUPLICATEPAGEREQ)pReqHdr);
1332	#endif
1333
1334	case VMMR0_DO_GMM_QUERY_STATISTICS:
1335	if (u64Arg)
1336	return VERR_INVALID_PARAMETER;
1337	return GMMR0QueryStatisticsReq(pVM, (PGMMQUERYSTATISTICSSREQ)pReqHdr);
1338
1339	case VMMR0_DO_GMM_RESET_STATISTICS:
1340	if (u64Arg)
1341	return VERR_INVALID_PARAMETER;
1342	return GMMR0ResetStatisticsReq(pVM, (PGMMRESETSTATISTICSSREQ)pReqHdr);
1343
1344	/*
1345	* A quick GCFGM mock-up.
1346	*/
1347	/** @todo GCFGM with proper access control, ring-3 management interface and all that. */
1348	case VMMR0_DO_GCFGM_SET_VALUE:
1349	case VMMR0_DO_GCFGM_QUERY_VALUE:
1350	{
1351	if (pVM \|\| !pReqHdr \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1352	return VERR_INVALID_PARAMETER;
1353	PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
1354	if (pReq->Hdr.cbReq != sizeof(*pReq))
1355	return VERR_INVALID_PARAMETER;
1356	int rc;
1357	if (enmOperation == VMMR0_DO_GCFGM_SET_VALUE)
1358	{
1359	rc = GVMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1360	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1361	// rc = GMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1362	}
1363	else
1364	{
1365	rc = GVMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1366	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1367	// rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1368	}
1369	return rc;
1370	}
1371
1372	/*
1373	* PDM Wrappers.
1374	*/
1375	case VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER:
1376	{
1377	if (!pVM \|\| !pReqHdr \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1378	return VERR_INVALID_PARAMETER;
1379	return PDMR0DriverCallReqHandler(pVM, (PPDMDRIVERCALLREQHANDLERREQ)pReqHdr);
1380	}
1381
1382	case VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER:
1383	{
1384	if (!pVM \|\| !pReqHdr \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1385	return VERR_INVALID_PARAMETER;
1386	return PDMR0DeviceCallReqHandler(pVM, (PPDMDEVICECALLREQHANDLERREQ)pReqHdr);
1387	}
1388
1389	/*
1390	* Requests to the internal networking service.
1391	*/
1392	case VMMR0_DO_INTNET_OPEN:
1393	{
1394	PINTNETOPENREQ pReq = (PINTNETOPENREQ)pReqHdr;
1395	if (u64Arg \|\| !pReq \|\| !vmmR0IsValidSession(pVM, pReq->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1396	return VERR_INVALID_PARAMETER;
1397	return IntNetR0OpenReq(pSession, pReq);
1398	}
1399
1400	case VMMR0_DO_INTNET_IF_CLOSE:
1401	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1402	return VERR_INVALID_PARAMETER;
1403	return IntNetR0IfCloseReq(pSession, (PINTNETIFCLOSEREQ)pReqHdr);
1404
1405	case VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS:
1406	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFGETBUFFERPTRSREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1407	return VERR_INVALID_PARAMETER;
1408	return IntNetR0IfGetBufferPtrsReq(pSession, (PINTNETIFGETBUFFERPTRSREQ)pReqHdr);
1409
1410	case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
1411	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1412	return VERR_INVALID_PARAMETER;
1413	return IntNetR0IfSetPromiscuousModeReq(pSession, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
1414
1415	case VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS:
1416	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1417	return VERR_INVALID_PARAMETER;
1418	return IntNetR0IfSetMacAddressReq(pSession, (PINTNETIFSETMACADDRESSREQ)pReqHdr);
1419
1420	case VMMR0_DO_INTNET_IF_SET_ACTIVE:
1421	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1422	return VERR_INVALID_PARAMETER;
1423	return IntNetR0IfSetActiveReq(pSession, (PINTNETIFSETACTIVEREQ)pReqHdr);
1424
1425	case VMMR0_DO_INTNET_IF_SEND:
1426	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1427	return VERR_INVALID_PARAMETER;
1428	return IntNetR0IfSendReq(pSession, (PINTNETIFSENDREQ)pReqHdr);
1429
1430	case VMMR0_DO_INTNET_IF_WAIT:
1431	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1432	return VERR_INVALID_PARAMETER;
1433	return IntNetR0IfWaitReq(pSession, (PINTNETIFWAITREQ)pReqHdr);
1434
1435	case VMMR0_DO_INTNET_IF_ABORT_WAIT:
1436	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1437	return VERR_INVALID_PARAMETER;
1438	return IntNetR0IfAbortWaitReq(pSession, (PINTNETIFABORTWAITREQ)pReqHdr);
1439
1440	#ifdef VBOX_WITH_PCI_PASSTHROUGH
1441	/*
1442	* Requests to host PCI driver service.
1443	*/
1444	case VMMR0_DO_PCIRAW_REQ:
1445	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PPCIRAWSENDREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1446	return VERR_INVALID_PARAMETER;
1447	return PciRawR0ProcessReq(pSession, pVM, (PPCIRAWSENDREQ)pReqHdr);
1448	#endif
1449	/*
1450	* For profiling.
1451	*/
1452	case VMMR0_DO_NOP:
1453	case VMMR0_DO_SLOW_NOP:
1454	return VINF_SUCCESS;
1455
1456	/*
1457	* For testing Ring-0 APIs invoked in this environment.
1458	*/
1459	case VMMR0_DO_TESTS:
1460	/** @todo make new test */
1461	return VINF_SUCCESS;
1462
1463
1464	#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1465	case VMMR0_DO_TEST_SWITCHER3264:
1466	if (idCpu == NIL_VMCPUID)
1467	return VERR_INVALID_CPU_ID;
1468	return HMR0TestSwitcher3264(pVM);
1469	#endif
1470	default:
1471	/*
1472	* We're returning VERR_NOT_SUPPORT here so we've got something else
1473	* than -1 which the interrupt gate glue code might return.
1474	*/
1475	Log(("operation %#x is not supported\n", enmOperation));
1476	return VERR_NOT_SUPPORTED;
1477	}
1478	}
1479
1480
1481	/**
1482	* Argument for vmmR0EntryExWrapper containing the arguments for VMMR0EntryEx.
1483	*/
1484	typedef struct VMMR0ENTRYEXARGS
1485	{
1486	PVM pVM;
1487	VMCPUID idCpu;
1488	VMMR0OPERATION enmOperation;
1489	PSUPVMMR0REQHDR pReq;
1490	uint64_t u64Arg;
1491	PSUPDRVSESSION pSession;
1492	} VMMR0ENTRYEXARGS;
1493	/** Pointer to a vmmR0EntryExWrapper argument package. */
1494	typedef VMMR0ENTRYEXARGS *PVMMR0ENTRYEXARGS;
1495
1496	/**
1497	* This is just a longjmp wrapper function for VMMR0EntryEx calls.
1498	*
1499	* @returns VBox status code.
1500	* @param pvArgs The argument package
1501	*/
1502	static DECLCALLBACK(int) vmmR0EntryExWrapper(void *pvArgs)
1503	{
1504	return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
1505	((PVMMR0ENTRYEXARGS)pvArgs)->idCpu,
1506	((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
1507	((PVMMR0ENTRYEXARGS)pvArgs)->pReq,
1508	((PVMMR0ENTRYEXARGS)pvArgs)->u64Arg,
1509	((PVMMR0ENTRYEXARGS)pvArgs)->pSession);
1510	}
1511
1512
1513	/**
1514	* The Ring 0 entry point, called by the support library (SUP).
1515	*
1516	* @returns VBox status code.
1517	* @param pVM Pointer to the VM.
1518	* @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
1519	* is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
1520	* @param enmOperation Which operation to execute.
1521	* @param pReq Pointer to the SUPVMMR0REQHDR packet. Optional.
1522	* @param u64Arg Some simple constant argument.
1523	* @param pSession The session of the caller.
1524	* @remarks Assume called with interrupts _enabled_.
1525	*/
1526	VMMR0DECL(int) VMMR0EntryEx(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession)
1527	{
1528	/*
1529	* Requests that should only happen on the EMT thread will be
1530	* wrapped in a setjmp so we can assert without causing trouble.
1531	*/
1532	if ( VALID_PTR(pVM)
1533	&& pVM->pVMR0
1534	&& idCpu < pVM->cCpus)
1535	{
1536	switch (enmOperation)
1537	{
1538	/* These might/will be called before VMMR3Init. */
1539	case VMMR0_DO_GMM_INITIAL_RESERVATION:
1540	case VMMR0_DO_GMM_UPDATE_RESERVATION:
1541	case VMMR0_DO_GMM_ALLOCATE_PAGES:
1542	case VMMR0_DO_GMM_FREE_PAGES:
1543	case VMMR0_DO_GMM_BALLOONED_PAGES:
1544	/* On the mac we might not have a valid jmp buf, so check these as well. */
1545	case VMMR0_DO_VMMR0_INIT:
1546	case VMMR0_DO_VMMR0_TERM:
1547	{
1548	PVMCPU pVCpu = &pVM->aCpus[idCpu];
1549
1550	if (!pVCpu->vmm.s.CallRing3JmpBufR0.pvSavedStack)
1551	break;
1552
1553	/** @todo validate this EMT claim... GVM knows. */
1554	VMMR0ENTRYEXARGS Args;
1555	Args.pVM = pVM;
1556	Args.idCpu = idCpu;
1557	Args.enmOperation = enmOperation;
1558	Args.pReq = pReq;
1559	Args.u64Arg = u64Arg;
1560	Args.pSession = pSession;
1561	return vmmR0CallRing3SetJmpEx(&pVCpu->vmm.s.CallRing3JmpBufR0, vmmR0EntryExWrapper, &Args);
1562	}
1563
1564	default:
1565	break;
1566	}
1567	}
1568	return vmmR0EntryExWorker(pVM, idCpu, enmOperation, pReq, u64Arg, pSession);
1569	}
1570
1571
1572	/**
1573	* Checks whether we've armed the ring-0 long jump machinery.
1574	*
1575	* @returns @c true / @c false
1576	* @param pVCpu Pointer to the VMCPU.
1577	* @thread EMT
1578	* @sa VMMIsLongJumpArmed
1579	*/
1580	VMMR0_INT_DECL(bool) VMMR0IsLongJumpArmed(PVMCPU pVCpu)
1581	{
1582	#ifdef RT_ARCH_X86
1583	return pVCpu->vmm.s.CallRing3JmpBufR0.eip
1584	&& !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call;
1585	#else
1586	return pVCpu->vmm.s.CallRing3JmpBufR0.rip
1587	&& !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call;
1588	#endif
1589	}
1590
1591
1592	/**
1593	* Checks whether we've done a ring-3 long jump.
1594	*
1595	* @returns @c true / @c false
1596	* @param pVCpu Pointer to the VMCPU.
1597	* @thread EMT
1598	*/
1599	VMMR0_INT_DECL(bool) VMMR0IsInRing3LongJump(PVMCPU pVCpu)
1600	{
1601	return pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call;
1602	}
1603
1604
1605	/**
1606	* Internal R0 logger worker: Flush logger.
1607	*
1608	* @param pLogger The logger instance to flush.
1609	* @remark This function must be exported!
1610	*/
1611	VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger)
1612	{
1613	#ifdef LOG_ENABLED
1614	/*
1615	* Convert the pLogger into a VM handle and 'call' back to Ring-3.
1616	* (This is a bit paranoid code.)
1617	*/
1618	PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1619	if ( !VALID_PTR(pR0Logger)
1620	\|\| !VALID_PTR(pR0Logger + 1)
1621	\|\| pLogger->u32Magic != RTLOGGER_MAGIC)
1622	{
1623	# ifdef DEBUG
1624	SUPR0Printf("vmmR0LoggerFlush: pLogger=%p!\n", pLogger);
1625	# endif
1626	return;
1627	}
1628	if (pR0Logger->fFlushingDisabled)
1629	return; /* quietly */
1630
1631	PVM pVM = pR0Logger->pVM;
1632	if ( !VALID_PTR(pVM)
1633	\|\| pVM->pVMR0 != pVM)
1634	{
1635	# ifdef DEBUG
1636	SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
1637	# endif
1638	return;
1639	}
1640
1641	PVMCPU pVCpu = VMMGetCpu(pVM);
1642	if (pVCpu)
1643	{
1644	/*
1645	* Check that the jump buffer is armed.
1646	*/
1647	# ifdef RT_ARCH_X86
1648	if ( !pVCpu->vmm.s.CallRing3JmpBufR0.eip
1649	\|\| pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1650	# else
1651	if ( !pVCpu->vmm.s.CallRing3JmpBufR0.rip
1652	\|\| pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1653	# endif
1654	{
1655	# ifdef DEBUG
1656	SUPR0Printf("vmmR0LoggerFlush: Jump buffer isn't armed!\n");
1657	# endif
1658	return;
1659	}
1660	VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
1661	}
1662	# ifdef DEBUG
1663	else
1664	SUPR0Printf("vmmR0LoggerFlush: invalid VCPU context!\n");
1665	# endif
1666	#endif
1667	}
1668
1669	/**
1670	* Internal R0 logger worker: Custom prefix.
1671	*
1672	* @returns Number of chars written.
1673	*
1674	* @param pLogger The logger instance.
1675	* @param pchBuf The output buffer.
1676	* @param cchBuf The size of the buffer.
1677	* @param pvUser User argument (ignored).
1678	*/
1679	VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char pchBuf, size_t cchBuf, void pvUser)
1680	{
1681	NOREF(pvUser);
1682	#ifdef LOG_ENABLED
1683	PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1684	if ( !VALID_PTR(pR0Logger)
1685	\|\| !VALID_PTR(pR0Logger + 1)
1686	\|\| pLogger->u32Magic != RTLOGGER_MAGIC
1687	\|\| cchBuf < 2)
1688	return 0;
1689
1690	static const char s_szHex[17] = "0123456789abcdef";
1691	VMCPUID const idCpu = pR0Logger->idCpu;
1692	pchBuf[1] = s_szHex[ idCpu & 15];
1693	pchBuf[0] = s_szHex[(idCpu >> 4) & 15];
1694
1695	return 2;
1696	#else
1697	return 0;
1698	#endif
1699	}
1700
1701	#ifdef LOG_ENABLED
1702
1703	/**
1704	* Disables flushing of the ring-0 debug log.
1705	*
1706	* @param pVCpu Pointer to the VMCPU.
1707	*/
1708	VMMR0DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu)
1709	{
1710	if (pVCpu->vmm.s.pR0LoggerR0)
1711	pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
1712	}
1713
1714
1715	/**
1716	* Enables flushing of the ring-0 debug log.
1717	*
1718	* @param pVCpu Pointer to the VMCPU.
1719	*/
1720	VMMR0DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu)
1721	{
1722	if (pVCpu->vmm.s.pR0LoggerR0)
1723	pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = false;
1724	}
1725
1726
1727	/**
1728	* Checks if log flushing is disabled or not.
1729	*
1730	* @param pVCpu Pointer to the VMCPU.
1731	*/
1732	VMMR0DECL(bool) VMMR0IsLogFlushDisabled(PVMCPU pVCpu)
1733	{
1734	if (pVCpu->vmm.s.pR0LoggerR0)
1735	return pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled;
1736	return true;
1737	}
1738	#endif /* LOG_ENABLED */
1739
1740	/**
1741	* Jump back to ring-3 if we're the EMT and the longjmp is armed.
1742	*
1743	* @returns true if the breakpoint should be hit, false if it should be ignored.
1744	*/
1745	DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void)
1746	{
1747	#if 0
1748	return true;
1749	#else
1750	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1751	if (pVM)
1752	{
1753	PVMCPU pVCpu = VMMGetCpu(pVM);
1754
1755	if (pVCpu)
1756	{
1757	#ifdef RT_ARCH_X86
1758	if ( pVCpu->vmm.s.CallRing3JmpBufR0.eip
1759	&& !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1760	#else
1761	if ( pVCpu->vmm.s.CallRing3JmpBufR0.rip
1762	&& !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1763	#endif
1764	{
1765	int rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_ASSERTION, 0);
1766	return RT_FAILURE_NP(rc);
1767	}
1768	}
1769	}
1770	#ifdef RT_OS_LINUX
1771	return true;
1772	#else
1773	return false;
1774	#endif
1775	#endif
1776	}
1777
1778
1779	/**
1780	* Override this so we can push it up to ring-3.
1781	*
1782	* @param pszExpr Expression. Can be NULL.
1783	* @param uLine Location line number.
1784	* @param pszFile Location file name.
1785	* @param pszFunction Location function name.
1786	*/
1787	DECLEXPORT(void) RTCALL RTAssertMsg1Weak(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction)
1788	{
1789	/*
1790	* To the log.
1791	*/
1792	LogAlways(("\n!!R0-Assertion Failed!!\n"
1793	"Expression: %s\n"
1794	"Location : %s(%d) %s\n",
1795	pszExpr, pszFile, uLine, pszFunction));
1796
1797	/*
1798	* To the global VMM buffer.
1799	*/
1800	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1801	if (pVM)
1802	RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
1803	"\n!!R0-Assertion Failed!!\n"
1804	"Expression: %s\n"
1805	"Location : %s(%d) %s\n",
1806	pszExpr, pszFile, uLine, pszFunction);
1807
1808	/*
1809	* Continue the normal way.
1810	*/
1811	RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
1812	}
1813
1814
1815	/**
1816	* Callback for RTLogFormatV which writes to the ring-3 log port.
1817	* See PFNLOGOUTPUT() for details.
1818	*/
1819	static DECLCALLBACK(size_t) rtLogOutput(void pv, const char pachChars, size_t cbChars)
1820	{
1821	for (size_t i = 0; i < cbChars; i++)
1822	LogAlways(("%c", pachChars[i]));
1823
1824	NOREF(pv);
1825	return cbChars;
1826	}
1827
1828
1829	/**
1830	* Override this so we can push it up to ring-3.
1831	*
1832	* @param pszFormat The format string.
1833	* @param va Arguments.
1834	*/
1835	DECLEXPORT(void) RTCALL RTAssertMsg2WeakV(const char *pszFormat, va_list va)
1836	{
1837	va_list vaCopy;
1838
1839	/*
1840	* Push the message to the loggers.
1841	*/
1842	PRTLOGGER pLog = RTLogGetDefaultInstance(); /* Don't initialize it here... */
1843	if (pLog)
1844	{
1845	va_copy(vaCopy, va);
1846	RTLogFormatV(rtLogOutput, pLog, pszFormat, vaCopy);
1847	va_end(vaCopy);
1848	}
1849	pLog = RTLogRelDefaultInstance();
1850	if (pLog)
1851	{
1852	va_copy(vaCopy, va);
1853	RTLogFormatV(rtLogOutput, pLog, pszFormat, vaCopy);
1854	va_end(vaCopy);
1855	}
1856
1857	/*
1858	* Push it to the global VMM buffer.
1859	*/
1860	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1861	if (pVM)
1862	{
1863	va_copy(vaCopy, va);
1864	RTStrPrintfV(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2), pszFormat, vaCopy);
1865	va_end(vaCopy);
1866	}
1867
1868	/*
1869	* Continue the normal way.
1870	*/
1871	RTAssertMsg2V(pszFormat, va);
1872	}
1873

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

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

Download in other formats: