VMMR0.cpp@ 48083

Last change on this file since 48083 was 48083, checked in by vboxsync, 12 years ago
VMM: wrong calling convention
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 62.7 KB

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

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

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

Download in other formats: