VMMR0.cpp@ 35855

Last change on this file since 35855 was 35855, checked in by vboxsync, 14 years ago
PCI: start of driver communication infrastructure
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 52.6 KB

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

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

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

Download in other formats: