VMMR0.cpp@ 36315

Last change on this file since 36315 was 35959, checked in by vboxsync, 14 years ago
PCI: further R0/driver work
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 52.6 KB

Line
1	/* $Id: VMMR0.cpp 35959 2011-02-14 14:30:03Z vboxsync $ */
2	/** @file
3	* VMM - Host Context Ring 0.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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/hwaccm.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	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
56	# pragma intrinsic(_AddressOfReturnAddress)
57	#endif
58
59
60	/*******************************************************************************
61	* Internal Functions *
62	*******************************************************************************/
63	RT_C_DECLS_BEGIN
64	VMMR0DECL(int) ModuleInit(void);
65	VMMR0DECL(void) ModuleTerm(void);
66
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 // RT_ARCH_X86 && (RT_OS_SOLARIS \|\| RT_OS_FREEBSD)
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 // RT_ARCH_X86 && (RT_OS_SOLARIS \|\| RT_OS_FREEBSD)
87	NULL
88	};
89
90
91	#if defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)
92	/* Increase the size of the image to work around the refusal of Win64 to
93	* load images in the 0x80000 range.
94	*/
95	static uint64_t u64BloatImage[8192] = {0};
96	#endif
97
98	/**
99	* Initialize the module.
100	* This is called when we're first loaded.
101	*
102	* @returns 0 on success.
103	* @returns VBox status on failure.
104	*/
105	VMMR0DECL(int) ModuleInit(void)
106	{
107	LogFlow(("ModuleInit:\n"));
108
109	/*
110	* Initialize the GVMM, GMM, HWACCM, PGM (Darwin) and INTNET.
111	*/
112	int rc = GVMMR0Init();
113	if (RT_SUCCESS(rc))
114	{
115	rc = GMMR0Init();
116	if (RT_SUCCESS(rc))
117	{
118	rc = HWACCMR0Init();
119	if (RT_SUCCESS(rc))
120	{
121	rc = PGMRegisterStringFormatTypes();
122	if (RT_SUCCESS(rc))
123	{
124	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
125	rc = PGMR0DynMapInit();
126	#endif
127	if (RT_SUCCESS(rc))
128	{
129	rc = IntNetR0Init();
130	if (RT_SUCCESS(rc))
131	{
132	#ifdef VBOX_WITH_PCI_PASSTHROUGH
133	rc = PciRawR0Init();
134	#endif
135	if (RT_SUCCESS(rc))
136	{
137	rc = CPUMR0ModuleInit();
138	if (RT_SUCCESS(rc))
139	{
140	LogFlow(("ModuleInit: returns success.\n"));
141	return VINF_SUCCESS;
142	}
143
144	/*
145	* Bail out.
146	*/
147	#ifdef VBOX_WITH_PCI_PASSTHROUGH
148	PciRawR0Term();
149	#endif
150	}
151	IntNetR0Term();
152	}
153	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
154	PGMR0DynMapTerm();
155	#endif
156	}
157	PGMDeregisterStringFormatTypes();
158	}
159	HWACCMR0Term();
160	}
161	GMMR0Term();
162	}
163	GVMMR0Term();
164	}
165
166	LogFlow(("ModuleInit: failed %Rrc\n", rc));
167	return rc;
168	}
169
170
171	/**
172	* Terminate the module.
173	* This is called when we're finally unloaded.
174	*/
175	VMMR0DECL(void) ModuleTerm(void)
176	{
177	LogFlow(("ModuleTerm:\n"));
178
179	/*
180	* Terminate the CPUM module (Local APIC cleanup).
181	*/
182	CPUMR0ModuleTerm();
183
184	/*
185	* Terminate the internal network service.
186	*/
187	IntNetR0Term();
188
189	/*
190	* PGM (Darwin), HWACCM and PciRaw global cleanup.
191	*/
192	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
193	PGMR0DynMapTerm();
194	#endif
195	#ifdef VBOX_WITH_PCI_PASSTHROUGH
196	PciRawR0Term();
197	#endif
198	PGMDeregisterStringFormatTypes();
199	HWACCMR0Term();
200
201	/*
202	* Destroy the GMM and GVMM instances.
203	*/
204	GMMR0Term();
205	GVMMR0Term();
206
207	LogFlow(("ModuleTerm: returns\n"));
208	}
209
210
211	/**
212	* Initiates the R0 driver for a particular VM instance.
213	*
214	* @returns VBox status code.
215	*
216	* @param pVM The VM instance in question.
217	* @param uSvnRev The SVN revision of the ring-3 part.
218	* @thread EMT.
219	*/
220	static int vmmR0InitVM(PVM pVM, uint32_t uSvnRev)
221	{
222	/*
223	* Match the SVN revisions.
224	*/
225	if (uSvnRev != VMMGetSvnRev())
226	{
227	LogRel(("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev()));
228	SUPR0Printf("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev());
229	return VERR_VMM_R0_VERSION_MISMATCH;
230	}
231	if ( !VALID_PTR(pVM)
232	\|\| pVM->pVMR0 != pVM)
233	return VERR_INVALID_PARAMETER;
234
235	#ifdef LOG_ENABLED
236	/*
237	* Register the EMT R0 logger instance for VCPU 0.
238	*/
239	PVMCPU pVCpu = &pVM->aCpus[0];
240
241	PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
242	if (pR0Logger)
243	{
244	# if 0 /* testing of the logger. */
245	LogCom(("vmmR0InitVM: before %p\n", RTLogDefaultInstance()));
246	LogCom(("vmmR0InitVM: pfnFlush=%p actual=%p\n", pR0Logger->Logger.pfnFlush, vmmR0LoggerFlush));
247	LogCom(("vmmR0InitVM: pfnLogger=%p actual=%p\n", pR0Logger->Logger.pfnLogger, vmmR0LoggerWrapper));
248	LogCom(("vmmR0InitVM: offScratch=%d fFlags=%#x fDestFlags=%#x\n", pR0Logger->Logger.offScratch, pR0Logger->Logger.fFlags, pR0Logger->Logger.fDestFlags));
249
250	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
251	LogCom(("vmmR0InitVM: after %p reg\n", RTLogDefaultInstance()));
252	RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
253	LogCom(("vmmR0InitVM: after %p dereg\n", RTLogDefaultInstance()));
254
255	pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
256	LogCom(("vmmR0InitVM: returned successfully from direct logger call.\n"));
257	pR0Logger->Logger.pfnFlush(&pR0Logger->Logger);
258	LogCom(("vmmR0InitVM: returned successfully from direct flush call.\n"));
259
260	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
261	LogCom(("vmmR0InitVM: after %p reg2\n", RTLogDefaultInstance()));
262	pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
263	LogCom(("vmmR0InitVM: returned successfully from direct logger call (2). offScratch=%d\n", pR0Logger->Logger.offScratch));
264	RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
265	LogCom(("vmmR0InitVM: after %p dereg2\n", RTLogDefaultInstance()));
266
267	RTLogLoggerEx(&pR0Logger->Logger, 0, ~0U, "hello ring-0 logger (RTLogLoggerEx)\n");
268	LogCom(("vmmR0InitVM: RTLogLoggerEx returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
269
270	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
271	RTLogPrintf("hello ring-0 logger (RTLogPrintf)\n");
272	LogCom(("vmmR0InitVM: RTLogPrintf returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
273	# endif
274	Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pVM->pSession));
275	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
276	pR0Logger->fRegistered = true;
277	}
278	#endif /* LOG_ENABLED */
279
280	/*
281	* Check if the host supports high resolution timers or not.
282	*/
283	if ( pVM->vmm.s.fUsePeriodicPreemptionTimers
284	&& !RTTimerCanDoHighResolution())
285	pVM->vmm.s.fUsePeriodicPreemptionTimers = false;
286
287	/*
288	* Initialize the per VM data for GVMM and GMM.
289	*/
290	int rc = GVMMR0InitVM(pVM);
291	// if (RT_SUCCESS(rc))
292	// rc = GMMR0InitPerVMData(pVM);
293	if (RT_SUCCESS(rc))
294	{
295	/*
296	* Init HWACCM, CPUM and PGM (Darwin only).
297	*/
298	rc = HWACCMR0InitVM(pVM);
299	if (RT_SUCCESS(rc))
300	{
301	rc = CPUMR0Init(pVM); /** @todo rename to CPUMR0InitVM */
302	if (RT_SUCCESS(rc))
303	{
304	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
305	rc = PGMR0DynMapInitVM(pVM);
306	#endif
307	if (RT_SUCCESS(rc))
308	{
309	GVMMR0DoneInitVM(pVM);
310	return rc;
311	}
312
313	/* bail out */
314	}
315	HWACCMR0TermVM(pVM);
316	}
317	}
318	RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
319	return rc;
320	}
321
322
323	/**
324	* Terminates the R0 driver for a particular VM instance.
325	*
326	* This is normally called by ring-3 as part of the VM termination process, but
327	* may alternatively be called during the support driver session cleanup when
328	* the VM object is destroyed (see GVMM).
329	*
330	* @returns VBox status code.
331	*
332	* @param pVM The VM instance in question.
333	* @param pGVM Pointer to the global VM structure. Optional.
334	* @thread EMT or session clean up thread.
335	*/
336	VMMR0DECL(int) VMMR0TermVM(PVM pVM, PGVM pGVM)
337	{
338	/*
339	* Tell GVMM what we're up to and check that we only do this once.
340	*/
341	if (GVMMR0DoingTermVM(pVM, pGVM))
342	{
343	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
344	PGMR0DynMapTermVM(pVM);
345	#endif
346	HWACCMR0TermVM(pVM);
347	}
348
349	/*
350	* Deregister the logger.
351	*/
352	RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
353	return VINF_SUCCESS;
354	}
355
356
357	#ifdef VBOX_WITH_STATISTICS
358	/**
359	* Record return code statistics
360	* @param pVM The VM handle.
361	* @param pVCpu The VMCPU handle.
362	* @param rc The status code.
363	*/
364	static void vmmR0RecordRC(PVM pVM, PVMCPU pVCpu, int rc)
365	{
366	/*
367	* Collect statistics.
368	*/
369	switch (rc)
370	{
371	case VINF_SUCCESS:
372	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetNormal);
373	break;
374	case VINF_EM_RAW_INTERRUPT:
375	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterrupt);
376	break;
377	case VINF_EM_RAW_INTERRUPT_HYPER:
378	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptHyper);
379	break;
380	case VINF_EM_RAW_GUEST_TRAP:
381	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGuestTrap);
382	break;
383	case VINF_EM_RAW_RING_SWITCH:
384	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitch);
385	break;
386	case VINF_EM_RAW_RING_SWITCH_INT:
387	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitchInt);
388	break;
389	case VINF_EM_RAW_STALE_SELECTOR:
390	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetStaleSelector);
391	break;
392	case VINF_EM_RAW_IRET_TRAP:
393	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIRETTrap);
394	break;
395	case VINF_IOM_HC_IOPORT_READ:
396	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIORead);
397	break;
398	case VINF_IOM_HC_IOPORT_WRITE:
399	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOWrite);
400	break;
401	case VINF_IOM_HC_MMIO_READ:
402	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIORead);
403	break;
404	case VINF_IOM_HC_MMIO_WRITE:
405	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOWrite);
406	break;
407	case VINF_IOM_HC_MMIO_READ_WRITE:
408	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOReadWrite);
409	break;
410	case VINF_PATM_HC_MMIO_PATCH_READ:
411	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchRead);
412	break;
413	case VINF_PATM_HC_MMIO_PATCH_WRITE:
414	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchWrite);
415	break;
416	case VINF_EM_RAW_EMULATE_INSTR:
417	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetEmulate);
418	break;
419	case VINF_EM_RAW_EMULATE_IO_BLOCK:
420	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOBlockEmulate);
421	break;
422	case VINF_PATCH_EMULATE_INSTR:
423	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchEmulate);
424	break;
425	case VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT:
426	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetLDTFault);
427	break;
428	case VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT:
429	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGDTFault);
430	break;
431	case VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT:
432	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIDTFault);
433	break;
434	case VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT:
435	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTSSFault);
436	break;
437	case VINF_EM_RAW_EMULATE_INSTR_PD_FAULT:
438	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPDFault);
439	break;
440	case VINF_CSAM_PENDING_ACTION:
441	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCSAMTask);
442	break;
443	case VINF_PGM_SYNC_CR3:
444	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetSyncCR3);
445	break;
446	case VINF_PATM_PATCH_INT3:
447	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchInt3);
448	break;
449	case VINF_PATM_PATCH_TRAP_PF:
450	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchPF);
451	break;
452	case VINF_PATM_PATCH_TRAP_GP:
453	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchGP);
454	break;
455	case VINF_PATM_PENDING_IRQ_AFTER_IRET:
456	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchIretIRQ);
457	break;
458	case VINF_EM_RESCHEDULE_REM:
459	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRescheduleREM);
460	break;
461	case VINF_EM_RAW_TO_R3:
462	if (VM_FF_ISPENDING(pVM, VM_FF_TM_VIRTUAL_SYNC))
463	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3TMVirt);
464	else
465	if (VM_FF_ISPENDING(pVM, VM_FF_PGM_NEED_HANDY_PAGES))
466	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3HandyPages);
467	else
468	if (VM_FF_ISPENDING(pVM, VM_FF_PDM_QUEUES))
469	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3PDMQueues);
470	else
471	if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
472	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Rendezvous);
473	else
474	if (VM_FF_ISPENDING(pVM, VM_FF_PDM_DMA))
475	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3DMA);
476	else
477	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TIMER))
478	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Timer);
479	else
480	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
481	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3CritSect);
482	else
483	if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TO_R3))
484	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3);
485	else
486	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Unknown);
487	break;
488
489	case VINF_EM_RAW_TIMER_PENDING:
490	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTimerPending);
491	break;
492	case VINF_EM_RAW_INTERRUPT_PENDING:
493	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptPending);
494	break;
495	case VINF_VMM_CALL_HOST:
496	switch (pVCpu->vmm.s.enmCallRing3Operation)
497	{
498	case VMMCALLRING3_PDM_LOCK:
499	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMLock);
500	break;
501	case VMMCALLRING3_PGM_POOL_GROW:
502	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMPoolGrow);
503	break;
504	case VMMCALLRING3_PGM_LOCK:
505	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMLock);
506	break;
507	case VMMCALLRING3_PGM_MAP_CHUNK:
508	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMMapChunk);
509	break;
510	case VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES:
511	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMAllocHandy);
512	break;
513	case VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS:
514	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallRemReplay);
515	break;
516	case VMMCALLRING3_VMM_LOGGER_FLUSH:
517	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallLogFlush);
518	break;
519	case VMMCALLRING3_VM_SET_ERROR:
520	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetError);
521	break;
522	case VMMCALLRING3_VM_SET_RUNTIME_ERROR:
523	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetRuntimeError);
524	break;
525	case VMMCALLRING3_VM_R0_ASSERTION:
526	default:
527	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCallRing3);
528	break;
529	}
530	break;
531	case VINF_PATM_DUPLICATE_FUNCTION:
532	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPATMDuplicateFn);
533	break;
534	case VINF_PGM_CHANGE_MODE:
535	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMChangeMode);
536	break;
537	case VINF_PGM_POOL_FLUSH_PENDING:
538	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMFlushPending);
539	break;
540	case VINF_EM_PENDING_REQUEST:
541	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPendingRequest);
542	break;
543	case VINF_EM_HWACCM_PATCH_TPR_INSTR:
544	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchTPR);
545	break;
546	default:
547	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMisc);
548	break;
549	}
550	}
551	#endif /* VBOX_WITH_STATISTICS */
552
553
554	/**
555	* Unused ring-0 entry point that used to be called from the interrupt gate.
556	*
557	* Will be removed one of the next times we do a major SUPDrv version bump.
558	*
559	* @returns VBox status code.
560	* @param pVM The VM to operate on.
561	* @param enmOperation Which operation to execute.
562	* @param pvArg Argument to the operation.
563	* @remarks Assume called with interrupts disabled.
564	*/
565	VMMR0DECL(int) VMMR0EntryInt(PVM pVM, VMMR0OPERATION enmOperation, void *pvArg)
566	{
567	/*
568	* We're returning VERR_NOT_SUPPORT here so we've got something else
569	* than -1 which the interrupt gate glue code might return.
570	*/
571	Log(("operation %#x is not supported\n", enmOperation));
572	return VERR_NOT_SUPPORTED;
573	}
574
575
576	/**
577	* The Ring 0 entry point, called by the fast-ioctl path.
578	*
579	* @param pVM The VM to operate on.
580	* The return code is stored in pVM->vmm.s.iLastGZRc.
581	* @param idCpu The Virtual CPU ID of the calling EMT.
582	* @param enmOperation Which operation to execute.
583	* @remarks Assume called with interrupts _enabled_.
584	*/
585	VMMR0DECL(void) VMMR0EntryFast(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation)
586	{
587	if (RT_UNLIKELY(idCpu >= pVM->cCpus))
588	return;
589	PVMCPU pVCpu = &pVM->aCpus[idCpu];
590
591	switch (enmOperation)
592	{
593	/*
594	* Switch to GC and run guest raw mode code.
595	* Disable interrupts before doing the world switch.
596	*/
597	case VMMR0_DO_RAW_RUN:
598	{
599	/* Some safety precautions first. */
600	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
601	if (RT_LIKELY( !pVM->vmm.s.fSwitcherDisabled /* hwaccm */
602	&& pVM->cCpus == 1 /* !smp */
603	&& PGMGetHyperCR3(pVCpu)))
604	#else
605	if (RT_LIKELY( !pVM->vmm.s.fSwitcherDisabled
606	&& pVM->cCpus == 1))
607	#endif
608	{
609	/* Disable preemption and update the periodic preemption timer. */
610	RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
611	RTThreadPreemptDisable(&PreemptState);
612	RTCPUID idHostCpu = RTMpCpuId();
613	#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
614	CPUMR0SetLApic(pVM, idHostCpu);
615	#endif
616	ASMAtomicWriteU32(&pVCpu->idHostCpu, idHostCpu);
617	if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
618	GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
619
620	/* We might need to disable VT-x if the active switcher turns off paging. */
621	bool fVTxDisabled;
622	int rc = HWACCMR0EnterSwitcher(pVM, &fVTxDisabled);
623	if (RT_SUCCESS(rc))
624	{
625	RTCCUINTREG uFlags = ASMIntDisableFlags();
626	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC);
627
628	TMNotifyStartOfExecution(pVCpu);
629	rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
630	pVCpu->vmm.s.iLastGZRc = rc;
631	TMNotifyEndOfExecution(pVCpu);
632
633	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
634
635	/* Re-enable VT-x if previously turned off. */
636	HWACCMR0LeaveSwitcher(pVM, fVTxDisabled);
637
638	if ( rc == VINF_EM_RAW_INTERRUPT
639	\|\| rc == VINF_EM_RAW_INTERRUPT_HYPER)
640	TRPMR0DispatchHostInterrupt(pVM);
641
642	ASMSetFlags(uFlags);
643
644	#ifdef VBOX_WITH_STATISTICS
645	STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
646	vmmR0RecordRC(pVM, pVCpu, rc);
647	#endif
648	}
649	else
650	pVCpu->vmm.s.iLastGZRc = rc;
651	ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
652	RTThreadPreemptRestore(&PreemptState);
653	}
654	else
655	{
656	Assert(!pVM->vmm.s.fSwitcherDisabled);
657	pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
658	if (pVM->cCpus != 1)
659	pVCpu->vmm.s.iLastGZRc = VERR_RAW_MODE_INVALID_SMP;
660	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
661	if (!PGMGetHyperCR3(pVCpu))
662	pVCpu->vmm.s.iLastGZRc = VERR_PGM_NO_CR3_SHADOW_ROOT;
663	#endif
664	}
665	break;
666	}
667
668	/*
669	* Run guest code using the available hardware acceleration technology.
670	*
671	* Disable interrupts before we do anything interesting. On Windows we avoid
672	* this by having the support driver raise the IRQL before calling us, this way
673	* we hope to get away with page faults and later calling into the kernel.
674	*/
675	case VMMR0_DO_HWACC_RUN:
676	{
677	#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
678	RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
679	RTThreadPreemptDisable(&PreemptState);
680	#elif !defined(RT_OS_WINDOWS)
681	RTCCUINTREG uFlags = ASMIntDisableFlags();
682	#endif
683	ASMAtomicWriteU32(&pVCpu->idHostCpu, RTMpCpuId());
684	if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
685	GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
686
687	#ifdef LOG_ENABLED
688	if (pVCpu->idCpu > 0)
689	{
690	/* Lazy registration of ring 0 loggers. */
691	PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
692	if ( pR0Logger
693	&& !pR0Logger->fRegistered)
694	{
695	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
696	pR0Logger->fRegistered = true;
697	}
698	}
699	#endif
700	int rc;
701	if (!HWACCMR0SuspendPending())
702	{
703	rc = HWACCMR0Enter(pVM, pVCpu);
704	if (RT_SUCCESS(rc))
705	{
706	rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, HWACCMR0RunGuestCode, pVM, pVCpu); /* this may resume code. */
707	int rc2 = HWACCMR0Leave(pVM, pVCpu);
708	AssertRC(rc2);
709	}
710	STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
711	}
712	else
713	{
714	/* System is about to go into suspend mode; go back to ring 3. */
715	rc = VINF_EM_RAW_INTERRUPT;
716	}
717	pVCpu->vmm.s.iLastGZRc = rc;
718
719	ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
720	#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
721	RTThreadPreemptRestore(&PreemptState);
722	#elif !defined(RT_OS_WINDOWS)
723	ASMSetFlags(uFlags);
724	#endif
725
726	#ifdef VBOX_WITH_STATISTICS
727	vmmR0RecordRC(pVM, pVCpu, rc);
728	#endif
729	/* No special action required for external interrupts, just return. */
730	break;
731	}
732
733	/*
734	* For profiling.
735	*/
736	case VMMR0_DO_NOP:
737	pVCpu->vmm.s.iLastGZRc = VINF_SUCCESS;
738	break;
739
740	/*
741	* Impossible.
742	*/
743	default:
744	AssertMsgFailed(("%#x\n", enmOperation));
745	pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
746	break;
747	}
748	}
749
750
751	/**
752	* Validates a session or VM session argument.
753	*
754	* @returns true / false accordingly.
755	* @param pVM The VM argument.
756	* @param pSession The session argument.
757	*/
758	DECLINLINE(bool) vmmR0IsValidSession(PVM pVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
759	{
760	/* This must be set! */
761	if (!pSession)
762	return false;
763
764	/* Only one out of the two. */
765	if (pVM && pClaimedSession)
766	return false;
767	if (pVM)
768	pClaimedSession = pVM->pSession;
769	return pClaimedSession == pSession;
770	}
771
772
773	/**
774	* VMMR0EntryEx worker function, either called directly or when ever possible
775	* called thru a longjmp so we can exit safely on failure.
776	*
777	* @returns VBox status code.
778	* @param pVM The VM to operate on.
779	* @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
780	* is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
781	* @param enmOperation Which operation to execute.
782	* @param pReqHdr This points to a SUPVMMR0REQHDR packet. Optional.
783	* The support driver validates this if it's present.
784	* @param u64Arg Some simple constant argument.
785	* @param pSession The session of the caller.
786	* @remarks Assume called with interrupts _enabled_.
787	*/
788	static int vmmR0EntryExWorker(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg, PSUPDRVSESSION pSession)
789	{
790	/*
791	* Common VM pointer validation.
792	*/
793	if (pVM)
794	{
795	if (RT_UNLIKELY( !VALID_PTR(pVM)
796	\|\| ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
797	{
798	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p! (op=%d)\n", pVM, enmOperation);
799	return VERR_INVALID_POINTER;
800	}
801	if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
802	\|\| pVM->enmVMState > VMSTATE_TERMINATED
803	\|\| pVM->pVMR0 != pVM))
804	{
805	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{enmVMState=%d, .pVMR0=%p}! (op=%d)\n",
806	pVM, pVM->enmVMState, pVM->pVMR0, enmOperation);
807	return VERR_INVALID_POINTER;
808	}
809
810	if (RT_UNLIKELY(idCpu >= pVM->cCpus && idCpu != NIL_VMCPUID))
811	{
812	SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu (%u vs cCpus=%u)\n", idCpu, pVM->cCpus);
813	return VERR_INVALID_PARAMETER;
814	}
815	}
816	else if (RT_UNLIKELY(idCpu != NIL_VMCPUID))
817	{
818	SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu=%u\n", idCpu);
819	return VERR_INVALID_PARAMETER;
820	}
821
822
823	switch (enmOperation)
824	{
825	/*
826	* GVM requests
827	*/
828	case VMMR0_DO_GVMM_CREATE_VM:
829	if (pVM \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
830	return VERR_INVALID_PARAMETER;
831	return GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr);
832
833	case VMMR0_DO_GVMM_DESTROY_VM:
834	if (pReqHdr \|\| u64Arg)
835	return VERR_INVALID_PARAMETER;
836	return GVMMR0DestroyVM(pVM);
837
838	case VMMR0_DO_GVMM_REGISTER_VMCPU:
839	{
840	if (!pVM)
841	return VERR_INVALID_PARAMETER;
842	return GVMMR0RegisterVCpu(pVM, idCpu);
843	}
844
845	case VMMR0_DO_GVMM_SCHED_HALT:
846	if (pReqHdr)
847	return VERR_INVALID_PARAMETER;
848	return GVMMR0SchedHalt(pVM, idCpu, u64Arg);
849
850	case VMMR0_DO_GVMM_SCHED_WAKE_UP:
851	if (pReqHdr \|\| u64Arg)
852	return VERR_INVALID_PARAMETER;
853	return GVMMR0SchedWakeUp(pVM, idCpu);
854
855	case VMMR0_DO_GVMM_SCHED_POKE:
856	if (pReqHdr \|\| u64Arg)
857	return VERR_INVALID_PARAMETER;
858	return GVMMR0SchedPoke(pVM, idCpu);
859
860	case VMMR0_DO_GVMM_SCHED_WAKE_UP_AND_POKE_CPUS:
861	if (u64Arg)
862	return VERR_INVALID_PARAMETER;
863	return GVMMR0SchedWakeUpAndPokeCpusReq(pVM, (PGVMMSCHEDWAKEUPANDPOKECPUSREQ)pReqHdr);
864
865	case VMMR0_DO_GVMM_SCHED_POLL:
866	if (pReqHdr \|\| u64Arg > 1)
867	return VERR_INVALID_PARAMETER;
868	return GVMMR0SchedPoll(pVM, idCpu, !!u64Arg);
869
870	case VMMR0_DO_GVMM_QUERY_STATISTICS:
871	if (u64Arg)
872	return VERR_INVALID_PARAMETER;
873	return GVMMR0QueryStatisticsReq(pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr);
874
875	case VMMR0_DO_GVMM_RESET_STATISTICS:
876	if (u64Arg)
877	return VERR_INVALID_PARAMETER;
878	return GVMMR0ResetStatisticsReq(pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr);
879
880	/*
881	* Initialize the R0 part of a VM instance.
882	*/
883	case VMMR0_DO_VMMR0_INIT:
884	return vmmR0InitVM(pVM, (uint32_t)u64Arg);
885
886	/*
887	* Terminate the R0 part of a VM instance.
888	*/
889	case VMMR0_DO_VMMR0_TERM:
890	return VMMR0TermVM(pVM, NULL);
891
892	/*
893	* Attempt to enable hwacc mode and check the current setting.
894	*/
895	case VMMR0_DO_HWACC_ENABLE:
896	return HWACCMR0EnableAllCpus(pVM);
897
898	/*
899	* Setup the hardware accelerated session.
900	*/
901	case VMMR0_DO_HWACC_SETUP_VM:
902	{
903	RTCCUINTREG fFlags = ASMIntDisableFlags();
904	int rc = HWACCMR0SetupVM(pVM);
905	ASMSetFlags(fFlags);
906	return rc;
907	}
908
909	/*
910	* Switch to RC to execute Hypervisor function.
911	*/
912	case VMMR0_DO_CALL_HYPERVISOR:
913	{
914	int rc;
915	bool fVTxDisabled;
916
917	/* Safety precaution as HWACCM can disable the switcher. */
918	Assert(!pVM->vmm.s.fSwitcherDisabled);
919	if (RT_UNLIKELY(pVM->vmm.s.fSwitcherDisabled))
920	return VERR_NOT_SUPPORTED;
921
922	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
923	if (RT_UNLIKELY(!PGMGetHyperCR3(VMMGetCpu0(pVM))))
924	return VERR_PGM_NO_CR3_SHADOW_ROOT;
925	#endif
926
927	RTCCUINTREG fFlags = ASMIntDisableFlags();
928
929	#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
930	RTCPUID idHostCpu = RTMpCpuId();
931	CPUMR0SetLApic(pVM, idHostCpu);
932	#endif
933
934	/* We might need to disable VT-x if the active switcher turns off paging. */
935	rc = HWACCMR0EnterSwitcher(pVM, &fVTxDisabled);
936	if (RT_FAILURE(rc))
937	return rc;
938
939	rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
940
941	/* Re-enable VT-x if previously turned off. */
942	HWACCMR0LeaveSwitcher(pVM, fVTxDisabled);
943
944	/** @todo dispatch interrupts? */
945	ASMSetFlags(fFlags);
946	return rc;
947	}
948
949	/*
950	* PGM wrappers.
951	*/
952	case VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES:
953	if (idCpu == NIL_VMCPUID)
954	return VERR_INVALID_CPU_ID;
955	return PGMR0PhysAllocateHandyPages(pVM, &pVM->aCpus[idCpu]);
956
957	case VMMR0_DO_PGM_ALLOCATE_LARGE_HANDY_PAGE:
958	if (idCpu == NIL_VMCPUID)
959	return VERR_INVALID_CPU_ID;
960	return PGMR0PhysAllocateLargeHandyPage(pVM, &pVM->aCpus[idCpu]);
961
962	/*
963	* GMM wrappers.
964	*/
965	case VMMR0_DO_GMM_INITIAL_RESERVATION:
966	if (u64Arg)
967	return VERR_INVALID_PARAMETER;
968	return GMMR0InitialReservationReq(pVM, idCpu, (PGMMINITIALRESERVATIONREQ)pReqHdr);
969
970	case VMMR0_DO_GMM_UPDATE_RESERVATION:
971	if (u64Arg)
972	return VERR_INVALID_PARAMETER;
973	return GMMR0UpdateReservationReq(pVM, idCpu, (PGMMUPDATERESERVATIONREQ)pReqHdr);
974
975	case VMMR0_DO_GMM_ALLOCATE_PAGES:
976	if (u64Arg)
977	return VERR_INVALID_PARAMETER;
978	return GMMR0AllocatePagesReq(pVM, idCpu, (PGMMALLOCATEPAGESREQ)pReqHdr);
979
980	case VMMR0_DO_GMM_FREE_PAGES:
981	if (u64Arg)
982	return VERR_INVALID_PARAMETER;
983	return GMMR0FreePagesReq(pVM, idCpu, (PGMMFREEPAGESREQ)pReqHdr);
984
985	case VMMR0_DO_GMM_FREE_LARGE_PAGE:
986	if (u64Arg)
987	return VERR_INVALID_PARAMETER;
988	return GMMR0FreeLargePageReq(pVM, idCpu, (PGMMFREELARGEPAGEREQ)pReqHdr);
989
990	case VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS:
991	if (u64Arg)
992	return VERR_INVALID_PARAMETER;
993	return GMMR0QueryHypervisorMemoryStatsReq(pVM, (PGMMMEMSTATSREQ)pReqHdr);
994
995	case VMMR0_DO_GMM_QUERY_MEM_STATS:
996	if (idCpu == NIL_VMCPUID)
997	return VERR_INVALID_CPU_ID;
998	if (u64Arg)
999	return VERR_INVALID_PARAMETER;
1000	return GMMR0QueryMemoryStatsReq(pVM, idCpu, (PGMMMEMSTATSREQ)pReqHdr);
1001
1002	case VMMR0_DO_GMM_BALLOONED_PAGES:
1003	if (u64Arg)
1004	return VERR_INVALID_PARAMETER;
1005	return GMMR0BalloonedPagesReq(pVM, idCpu, (PGMMBALLOONEDPAGESREQ)pReqHdr);
1006
1007	case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
1008	if (u64Arg)
1009	return VERR_INVALID_PARAMETER;
1010	return GMMR0MapUnmapChunkReq(pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
1011
1012	case VMMR0_DO_GMM_SEED_CHUNK:
1013	if (pReqHdr)
1014	return VERR_INVALID_PARAMETER;
1015	return GMMR0SeedChunk(pVM, idCpu, (RTR3PTR)u64Arg);
1016
1017	case VMMR0_DO_GMM_REGISTER_SHARED_MODULE:
1018	if (idCpu == NIL_VMCPUID)
1019	return VERR_INVALID_CPU_ID;
1020	if (u64Arg)
1021	return VERR_INVALID_PARAMETER;
1022	return GMMR0RegisterSharedModuleReq(pVM, idCpu, (PGMMREGISTERSHAREDMODULEREQ)pReqHdr);
1023
1024	case VMMR0_DO_GMM_UNREGISTER_SHARED_MODULE:
1025	if (idCpu == NIL_VMCPUID)
1026	return VERR_INVALID_CPU_ID;
1027	if (u64Arg)
1028	return VERR_INVALID_PARAMETER;
1029	return GMMR0UnregisterSharedModuleReq(pVM, idCpu, (PGMMUNREGISTERSHAREDMODULEREQ)pReqHdr);
1030
1031	case VMMR0_DO_GMM_RESET_SHARED_MODULES:
1032	if (idCpu == NIL_VMCPUID)
1033	return VERR_INVALID_CPU_ID;
1034	if ( u64Arg
1035	\|\| pReqHdr)
1036	return VERR_INVALID_PARAMETER;
1037	return GMMR0ResetSharedModules(pVM, idCpu);
1038
1039	#ifdef VBOX_WITH_PAGE_SHARING
1040	case VMMR0_DO_GMM_CHECK_SHARED_MODULES:
1041	{
1042	if (idCpu == NIL_VMCPUID)
1043	return VERR_INVALID_CPU_ID;
1044	if ( u64Arg
1045	\|\| pReqHdr)
1046	return VERR_INVALID_PARAMETER;
1047
1048	PVMCPU pVCpu = &pVM->aCpus[idCpu];
1049	Assert(pVCpu->hNativeThreadR0 == RTThreadNativeSelf());
1050
1051	# ifdef DEBUG_sandervl
1052	/* 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). */
1053	/* Todo: this can have bad side effects for unexpected jumps back to r3. */
1054	int rc = GMMR0CheckSharedModulesStart(pVM);
1055	if (rc == VINF_SUCCESS)
1056	{
1057	rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, GMMR0CheckSharedModules, pVM, pVCpu); /* this may resume code. */
1058	Assert( rc == VINF_SUCCESS
1059	\|\| (rc == VINF_VMM_CALL_HOST && pVCpu->vmm.s.enmCallRing3Operation == VMMCALLRING3_VMM_LOGGER_FLUSH));
1060	GMMR0CheckSharedModulesEnd(pVM);
1061	}
1062	# else
1063	int rc = GMMR0CheckSharedModules(pVM, pVCpu);
1064	# endif
1065	return rc;
1066	}
1067	#endif
1068
1069	#if defined(VBOX_STRICT) && HC_ARCH_BITS == 64
1070	case VMMR0_DO_GMM_FIND_DUPLICATE_PAGE:
1071	{
1072	if (u64Arg)
1073	return VERR_INVALID_PARAMETER;
1074	return GMMR0FindDuplicatePageReq(pVM, (PGMMFINDDUPLICATEPAGEREQ)pReqHdr);
1075	}
1076	#endif
1077
1078	/*
1079	* A quick GCFGM mock-up.
1080	*/
1081	/** @todo GCFGM with proper access control, ring-3 management interface and all that. */
1082	case VMMR0_DO_GCFGM_SET_VALUE:
1083	case VMMR0_DO_GCFGM_QUERY_VALUE:
1084	{
1085	if (pVM \|\| !pReqHdr \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1086	return VERR_INVALID_PARAMETER;
1087	PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
1088	if (pReq->Hdr.cbReq != sizeof(*pReq))
1089	return VERR_INVALID_PARAMETER;
1090	int rc;
1091	if (enmOperation == VMMR0_DO_GCFGM_SET_VALUE)
1092	{
1093	rc = GVMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1094	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1095	// rc = GMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1096	}
1097	else
1098	{
1099	rc = GVMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1100	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1101	// rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1102	}
1103	return rc;
1104	}
1105
1106	/*
1107	* PDM Wrappers.
1108	*/
1109	case VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER:
1110	{
1111	if (!pVM \|\| !pReqHdr \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1112	return VERR_INVALID_PARAMETER;
1113	return PDMR0DriverCallReqHandler(pVM, (PPDMDRIVERCALLREQHANDLERREQ)pReqHdr);
1114	}
1115
1116	case VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER:
1117	{
1118	if (!pVM \|\| !pReqHdr \|\| u64Arg \|\| idCpu != NIL_VMCPUID)
1119	return VERR_INVALID_PARAMETER;
1120	return PDMR0DeviceCallReqHandler(pVM, (PPDMDEVICECALLREQHANDLERREQ)pReqHdr);
1121	}
1122
1123	/*
1124	* Requests to the internal networking service.
1125	*/
1126	case VMMR0_DO_INTNET_OPEN:
1127	{
1128	PINTNETOPENREQ pReq = (PINTNETOPENREQ)pReqHdr;
1129	if (u64Arg \|\| !pReq \|\| !vmmR0IsValidSession(pVM, pReq->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1130	return VERR_INVALID_PARAMETER;
1131	return IntNetR0OpenReq(pSession, pReq);
1132	}
1133
1134	case VMMR0_DO_INTNET_IF_CLOSE:
1135	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1136	return VERR_INVALID_PARAMETER;
1137	return IntNetR0IfCloseReq(pSession, (PINTNETIFCLOSEREQ)pReqHdr);
1138
1139	case VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS:
1140	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFGETBUFFERPTRSREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1141	return VERR_INVALID_PARAMETER;
1142	return IntNetR0IfGetBufferPtrsReq(pSession, (PINTNETIFGETBUFFERPTRSREQ)pReqHdr);
1143
1144	case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
1145	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1146	return VERR_INVALID_PARAMETER;
1147	return IntNetR0IfSetPromiscuousModeReq(pSession, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
1148
1149	case VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS:
1150	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1151	return VERR_INVALID_PARAMETER;
1152	return IntNetR0IfSetMacAddressReq(pSession, (PINTNETIFSETMACADDRESSREQ)pReqHdr);
1153
1154	case VMMR0_DO_INTNET_IF_SET_ACTIVE:
1155	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1156	return VERR_INVALID_PARAMETER;
1157	return IntNetR0IfSetActiveReq(pSession, (PINTNETIFSETACTIVEREQ)pReqHdr);
1158
1159	case VMMR0_DO_INTNET_IF_SEND:
1160	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1161	return VERR_INVALID_PARAMETER;
1162	return IntNetR0IfSendReq(pSession, (PINTNETIFSENDREQ)pReqHdr);
1163
1164	case VMMR0_DO_INTNET_IF_WAIT:
1165	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1166	return VERR_INVALID_PARAMETER;
1167	return IntNetR0IfWaitReq(pSession, (PINTNETIFWAITREQ)pReqHdr);
1168
1169	case VMMR0_DO_INTNET_IF_ABORT_WAIT:
1170	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1171	return VERR_INVALID_PARAMETER;
1172	return IntNetR0IfAbortWaitReq(pSession, (PINTNETIFABORTWAITREQ)pReqHdr);
1173
1174	#ifdef VBOX_WITH_PCI_PASSTHROUGH
1175	/*
1176	* Requests to host PCI driver service.
1177	*/
1178	case VMMR0_DO_PCIRAW_REQ:
1179	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PPCIRAWSENDREQ)pReqHdr)->pSession, pSession) \|\| idCpu != NIL_VMCPUID)
1180	return VERR_INVALID_PARAMETER;
1181	return PciRawR0ProcessReq(pSession, pVM, (PPCIRAWSENDREQ)pReqHdr);
1182	#endif
1183	/*
1184	* For profiling.
1185	*/
1186	case VMMR0_DO_NOP:
1187	case VMMR0_DO_SLOW_NOP:
1188	return VINF_SUCCESS;
1189
1190	/*
1191	* For testing Ring-0 APIs invoked in this environment.
1192	*/
1193	case VMMR0_DO_TESTS:
1194	/** @todo make new test */
1195	return VINF_SUCCESS;
1196
1197
1198	#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1199	case VMMR0_DO_TEST_SWITCHER3264:
1200	if (idCpu == NIL_VMCPUID)
1201	return VERR_INVALID_CPU_ID;
1202	return HWACCMR0TestSwitcher3264(pVM);
1203	#endif
1204	default:
1205	/*
1206	* We're returning VERR_NOT_SUPPORT here so we've got something else
1207	* than -1 which the interrupt gate glue code might return.
1208	*/
1209	Log(("operation %#x is not supported\n", enmOperation));
1210	return VERR_NOT_SUPPORTED;
1211	}
1212	}
1213
1214
1215	/**
1216	* Argument for vmmR0EntryExWrapper containing the arguments for VMMR0EntryEx.
1217	*/
1218	typedef struct VMMR0ENTRYEXARGS
1219	{
1220	PVM pVM;
1221	VMCPUID idCpu;
1222	VMMR0OPERATION enmOperation;
1223	PSUPVMMR0REQHDR pReq;
1224	uint64_t u64Arg;
1225	PSUPDRVSESSION pSession;
1226	} VMMR0ENTRYEXARGS;
1227	/** Pointer to a vmmR0EntryExWrapper argument package. */
1228	typedef VMMR0ENTRYEXARGS *PVMMR0ENTRYEXARGS;
1229
1230	/**
1231	* This is just a longjmp wrapper function for VMMR0EntryEx calls.
1232	*
1233	* @returns VBox status code.
1234	* @param pvArgs The argument package
1235	*/
1236	static int vmmR0EntryExWrapper(void *pvArgs)
1237	{
1238	return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
1239	((PVMMR0ENTRYEXARGS)pvArgs)->idCpu,
1240	((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
1241	((PVMMR0ENTRYEXARGS)pvArgs)->pReq,
1242	((PVMMR0ENTRYEXARGS)pvArgs)->u64Arg,
1243	((PVMMR0ENTRYEXARGS)pvArgs)->pSession);
1244	}
1245
1246
1247	/**
1248	* The Ring 0 entry point, called by the support library (SUP).
1249	*
1250	* @returns VBox status code.
1251	* @param pVM The VM to operate on.
1252	* @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
1253	* is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
1254	* @param enmOperation Which operation to execute.
1255	* @param pReq This points to a SUPVMMR0REQHDR packet. Optional.
1256	* @param u64Arg Some simple constant argument.
1257	* @param pSession The session of the caller.
1258	* @remarks Assume called with interrupts _enabled_.
1259	*/
1260	VMMR0DECL(int) VMMR0EntryEx(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession)
1261	{
1262	/*
1263	* Requests that should only happen on the EMT thread will be
1264	* wrapped in a setjmp so we can assert without causing trouble.
1265	*/
1266	if ( VALID_PTR(pVM)
1267	&& pVM->pVMR0
1268	&& idCpu < pVM->cCpus)
1269	{
1270	switch (enmOperation)
1271	{
1272	/* These might/will be called before VMMR3Init. */
1273	case VMMR0_DO_GMM_INITIAL_RESERVATION:
1274	case VMMR0_DO_GMM_UPDATE_RESERVATION:
1275	case VMMR0_DO_GMM_ALLOCATE_PAGES:
1276	case VMMR0_DO_GMM_FREE_PAGES:
1277	case VMMR0_DO_GMM_BALLOONED_PAGES:
1278	/* On the mac we might not have a valid jmp buf, so check these as well. */
1279	case VMMR0_DO_VMMR0_INIT:
1280	case VMMR0_DO_VMMR0_TERM:
1281	{
1282	PVMCPU pVCpu = &pVM->aCpus[idCpu];
1283
1284	if (!pVCpu->vmm.s.CallRing3JmpBufR0.pvSavedStack)
1285	break;
1286
1287	/** @todo validate this EMT claim... GVM knows. */
1288	VMMR0ENTRYEXARGS Args;
1289	Args.pVM = pVM;
1290	Args.idCpu = idCpu;
1291	Args.enmOperation = enmOperation;
1292	Args.pReq = pReq;
1293	Args.u64Arg = u64Arg;
1294	Args.pSession = pSession;
1295	return vmmR0CallRing3SetJmpEx(&pVCpu->vmm.s.CallRing3JmpBufR0, vmmR0EntryExWrapper, &Args);
1296	}
1297
1298	default:
1299	break;
1300	}
1301	}
1302	return vmmR0EntryExWorker(pVM, idCpu, enmOperation, pReq, u64Arg, pSession);
1303	}
1304
1305	/**
1306	* Internal R0 logger worker: Flush logger.
1307	*
1308	* @param pLogger The logger instance to flush.
1309	* @remark This function must be exported!
1310	*/
1311	VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger)
1312	{
1313	#ifdef LOG_ENABLED
1314	/*
1315	* Convert the pLogger into a VM handle and 'call' back to Ring-3.
1316	* (This is a bit paranoid code.)
1317	*/
1318	PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1319	if ( !VALID_PTR(pR0Logger)
1320	\|\| !VALID_PTR(pR0Logger + 1)
1321	\|\| pLogger->u32Magic != RTLOGGER_MAGIC)
1322	{
1323	# ifdef DEBUG
1324	SUPR0Printf("vmmR0LoggerFlush: pLogger=%p!\n", pLogger);
1325	# endif
1326	return;
1327	}
1328	if (pR0Logger->fFlushingDisabled)
1329	return; /* quietly */
1330
1331	PVM pVM = pR0Logger->pVM;
1332	if ( !VALID_PTR(pVM)
1333	\|\| pVM->pVMR0 != pVM)
1334	{
1335	# ifdef DEBUG
1336	SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
1337	# endif
1338	return;
1339	}
1340
1341	PVMCPU pVCpu = VMMGetCpu(pVM);
1342	if (pVCpu)
1343	{
1344	/*
1345	* Check that the jump buffer is armed.
1346	*/
1347	# ifdef RT_ARCH_X86
1348	if ( !pVCpu->vmm.s.CallRing3JmpBufR0.eip
1349	\|\| pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1350	# else
1351	if ( !pVCpu->vmm.s.CallRing3JmpBufR0.rip
1352	\|\| pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1353	# endif
1354	{
1355	# ifdef DEBUG
1356	SUPR0Printf("vmmR0LoggerFlush: Jump buffer isn't armed!\n");
1357	# endif
1358	return;
1359	}
1360	VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
1361	}
1362	# ifdef DEBUG
1363	else
1364	SUPR0Printf("vmmR0LoggerFlush: invalid VCPU context!\n");
1365	# endif
1366	#endif
1367	}
1368
1369	/**
1370	* Internal R0 logger worker: Custom prefix.
1371	*
1372	* @returns Number of chars written.
1373	*
1374	* @param pLogger The logger instance.
1375	* @param pchBuf The output buffer.
1376	* @param cchBuf The size of the buffer.
1377	* @param pvUser User argument (ignored).
1378	*/
1379	VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char pchBuf, size_t cchBuf, void pvUser)
1380	{
1381	NOREF(pvUser);
1382	#ifdef LOG_ENABLED
1383	PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1384	if ( !VALID_PTR(pR0Logger)
1385	\|\| !VALID_PTR(pR0Logger + 1)
1386	\|\| pLogger->u32Magic != RTLOGGER_MAGIC
1387	\|\| cchBuf < 2)
1388	return 0;
1389
1390	static const char s_szHex[17] = "0123456789abcdef";
1391	VMCPUID const idCpu = pR0Logger->idCpu;
1392	pchBuf[1] = s_szHex[ idCpu & 15];
1393	pchBuf[0] = s_szHex[(idCpu >> 4) & 15];
1394
1395	return 2;
1396	#else
1397	return 0;
1398	#endif
1399	}
1400
1401	#ifdef LOG_ENABLED
1402
1403	/**
1404	* Disables flushing of the ring-0 debug log.
1405	*
1406	* @param pVCpu The shared virtual cpu structure.
1407	*/
1408	VMMR0DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu)
1409	{
1410	PVM pVM = pVCpu->pVMR0;
1411	if (pVCpu->vmm.s.pR0LoggerR0)
1412	pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
1413	}
1414
1415
1416	/**
1417	* Enables flushing of the ring-0 debug log.
1418	*
1419	* @param pVCpu The shared virtual cpu structure.
1420	*/
1421	VMMR0DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu)
1422	{
1423	PVM pVM = pVCpu->pVMR0;
1424	if (pVCpu->vmm.s.pR0LoggerR0)
1425	pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = false;
1426	}
1427
1428	#endif /* LOG_ENABLED */
1429
1430	/**
1431	* Jump back to ring-3 if we're the EMT and the longjmp is armed.
1432	*
1433	* @returns true if the breakpoint should be hit, false if it should be ignored.
1434	*/
1435	DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void)
1436	{
1437	#if 0
1438	return true;
1439	#else
1440	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1441	if (pVM)
1442	{
1443	PVMCPU pVCpu = VMMGetCpu(pVM);
1444
1445	if (pVCpu)
1446	{
1447	#ifdef RT_ARCH_X86
1448	if ( pVCpu->vmm.s.CallRing3JmpBufR0.eip
1449	&& !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1450	#else
1451	if ( pVCpu->vmm.s.CallRing3JmpBufR0.rip
1452	&& !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1453	#endif
1454	{
1455	int rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_ASSERTION, 0);
1456	return RT_FAILURE_NP(rc);
1457	}
1458	}
1459	}
1460	#ifdef RT_OS_LINUX
1461	return true;
1462	#else
1463	return false;
1464	#endif
1465	#endif
1466	}
1467
1468
1469	/**
1470	* Override this so we can push it up to ring-3.
1471	*
1472	* @param pszExpr Expression. Can be NULL.
1473	* @param uLine Location line number.
1474	* @param pszFile Location file name.
1475	* @param pszFunction Location function name.
1476	*/
1477	DECLEXPORT(void) RTCALL RTAssertMsg1Weak(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction)
1478	{
1479	/*
1480	* To the log.
1481	*/
1482	LogAlways(("\n!!R0-Assertion Failed!!\n"
1483	"Expression: %s\n"
1484	"Location : %s(%d) %s\n",
1485	pszExpr, pszFile, uLine, pszFunction));
1486
1487	/*
1488	* To the global VMM buffer.
1489	*/
1490	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1491	if (pVM)
1492	RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
1493	"\n!!R0-Assertion Failed!!\n"
1494	"Expression: %s\n"
1495	"Location : %s(%d) %s\n",
1496	pszExpr, pszFile, uLine, pszFunction);
1497
1498	/*
1499	* Continue the normal way.
1500	*/
1501	RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
1502	}
1503
1504
1505	/**
1506	* Callback for RTLogFormatV which writes to the ring-3 log port.
1507	* See PFNLOGOUTPUT() for details.
1508	*/
1509	static DECLCALLBACK(size_t) rtLogOutput(void pv, const char pachChars, size_t cbChars)
1510	{
1511	for (size_t i = 0; i < cbChars; i++)
1512	LogAlways(("%c", pachChars[i]));
1513
1514	return cbChars;
1515	}
1516
1517
1518	/**
1519	* Override this so we can push it up to ring-3.
1520	*
1521	* @param pszFormat The format string.
1522	* @param va Arguments.
1523	*/
1524	DECLEXPORT(void) RTCALL RTAssertMsg2WeakV(const char *pszFormat, va_list va)
1525	{
1526	va_list vaCopy;
1527
1528	/*
1529	* Push the message to the logger.
1530	*/
1531	PRTLOGGER pLog = RTLogDefaultInstance(); /** @todo we want this for release as well! */
1532	if (pLog)
1533	{
1534	va_copy(vaCopy, va);
1535	RTLogFormatV(rtLogOutput, pLog, pszFormat, vaCopy);
1536	va_end(vaCopy);
1537	}
1538
1539	/*
1540	* Push it to the global VMM buffer.
1541	*/
1542	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1543	if (pVM)
1544	{
1545	va_copy(vaCopy, va);
1546	RTStrPrintfV(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2), pszFormat, vaCopy);
1547	va_end(vaCopy);
1548	}
1549
1550	/*
1551	* Continue the normal way.
1552	*/
1553	RTAssertMsg2V(pszFormat, va);
1554	}

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

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

Download in other formats: