VMMR0.cpp@ 10377

Last change on this file since 10377 was 8961, checked in by vboxsync, 17 years ago
Fixed amd64 debug builds. Added some TODOs.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 36.8 KB

Line
1	/* $Id: VMMR0.cpp 8961 2008-05-20 14:51:33Z vboxsync $ */
2	/** @file
3	* VMM - Host Context Ring 0.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_VMM
27	#include <VBox/vmm.h>
28	#include <VBox/sup.h>
29	#include <VBox/trpm.h>
30	#include <VBox/cpum.h>
31	#include <VBox/stam.h>
32	#include <VBox/tm.h>
33	#include "VMMInternal.h"
34	#include <VBox/vm.h>
35	#include <VBox/gvmm.h>
36	#include <VBox/gmm.h>
37	#include <VBox/intnet.h>
38	#include <VBox/hwaccm.h>
39	#include <VBox/param.h>
40
41	#include <VBox/err.h>
42	#include <VBox/version.h>
43	#include <VBox/log.h>
44	#include <iprt/assert.h>
45	#include <iprt/stdarg.h>
46	#include <iprt/mp.h>
47
48	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
49	# pragma intrinsic(_AddressOfReturnAddress)
50	#endif
51
52
53	/*******************************************************************************
54	* Internal Functions *
55	*******************************************************************************/
56	static int VMMR0Init(PVM pVM, unsigned uVersion);
57	static int VMMR0Term(PVM pVM);
58	__BEGIN_DECLS
59	VMMR0DECL(int) ModuleInit(void);
60	VMMR0DECL(void) ModuleTerm(void);
61	__END_DECLS
62
63
64	/*******************************************************************************
65	* Global Variables *
66	*******************************************************************************/
67	#ifdef VBOX_WITH_INTERNAL_NETWORKING
68	/** Pointer to the internal networking service instance. */
69	PINTNET g_pIntNet = 0;
70	#endif
71
72
73	/**
74	* Initialize the module.
75	* This is called when we're first loaded.
76	*
77	* @returns 0 on success.
78	* @returns VBox status on failure.
79	*/
80	VMMR0DECL(int) ModuleInit(void)
81	{
82	LogFlow(("ModuleInit:\n"));
83
84	/*
85	* Initialize the GVMM, GMM.& HWACCM
86	*/
87	int rc = GVMMR0Init();
88	if (RT_SUCCESS(rc))
89	{
90	rc = GMMR0Init();
91	if (RT_SUCCESS(rc))
92	{
93	rc = HWACCMR0Init();
94	if (RT_SUCCESS(rc))
95	{
96	#ifdef VBOX_WITH_INTERNAL_NETWORKING
97	LogFlow(("ModuleInit: g_pIntNet=%p\n", g_pIntNet));
98	g_pIntNet = NULL;
99	LogFlow(("ModuleInit: g_pIntNet=%p should be NULL now...\n", g_pIntNet));
100	rc = INTNETR0Create(&g_pIntNet);
101	if (VBOX_SUCCESS(rc))
102	{
103	LogFlow(("ModuleInit: returns success. g_pIntNet=%p\n", g_pIntNet));
104	return VINF_SUCCESS;
105	}
106	g_pIntNet = NULL;
107	LogFlow(("ModuleTerm: returns %Vrc\n", rc));
108	#else
109	LogFlow(("ModuleInit: returns success.\n"));
110	return VINF_SUCCESS;
111	#endif
112	}
113	}
114	}
115
116	LogFlow(("ModuleInit: failed %Rrc\n", rc));
117	return rc;
118	}
119
120
121	/**
122	* Terminate the module.
123	* This is called when we're finally unloaded.
124	*/
125	VMMR0DECL(void) ModuleTerm(void)
126	{
127	LogFlow(("ModuleTerm:\n"));
128
129	#ifdef VBOX_WITH_INTERNAL_NETWORKING
130	/*
131	* Destroy the internal networking instance.
132	*/
133	if (g_pIntNet)
134	{
135	INTNETR0Destroy(g_pIntNet);
136	g_pIntNet = NULL;
137	}
138	#endif
139
140	/* Global HWACCM cleanup */
141	HWACCMR0Term();
142
143	/*
144	* Destroy the GMM and GVMM instances.
145	*/
146	GMMR0Term();
147	GVMMR0Term();
148
149	LogFlow(("ModuleTerm: returns\n"));
150	}
151
152
153	/**
154	* Initaties the R0 driver for a particular VM instance.
155	*
156	* @returns VBox status code.
157	*
158	* @param pVM The VM instance in question.
159	* @param uVersion The minimum module version required.
160	* @thread EMT.
161	*/
162	static int VMMR0Init(PVM pVM, unsigned uVersion)
163	{
164	/*
165	* Check if compatible version.
166	*/
167	if ( uVersion != VBOX_VERSION
168	&& ( VBOX_GET_VERSION_MAJOR(uVersion) != VBOX_VERSION_MAJOR
169	\|\| VBOX_GET_VERSION_MINOR(uVersion) < VBOX_VERSION_MINOR))
170	return VERR_VERSION_MISMATCH;
171	if ( !VALID_PTR(pVM)
172	\|\| pVM->pVMR0 != pVM)
173	return VERR_INVALID_PARAMETER;
174
175	/*
176	* Register the EMT R0 logger instance.
177	*/
178	PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0Logger;
179	if (pR0Logger)
180	{
181	#if 0 /* testing of the logger. */
182	LogCom(("VMMR0Init: before %p\n", RTLogDefaultInstance()));
183	LogCom(("VMMR0Init: pfnFlush=%p actual=%p\n", pR0Logger->Logger.pfnFlush, vmmR0LoggerFlush));
184	LogCom(("VMMR0Init: pfnLogger=%p actual=%p\n", pR0Logger->Logger.pfnLogger, vmmR0LoggerWrapper));
185	LogCom(("VMMR0Init: offScratch=%d fFlags=%#x fDestFlags=%#x\n", pR0Logger->Logger.offScratch, pR0Logger->Logger.fFlags, pR0Logger->Logger.fDestFlags));
186
187	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
188	LogCom(("VMMR0Init: after %p reg\n", RTLogDefaultInstance()));
189	RTLogSetDefaultInstanceThread(NULL, 0);
190	LogCom(("VMMR0Init: after %p dereg\n", RTLogDefaultInstance()));
191
192	pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
193	LogCom(("VMMR0Init: returned succesfully from direct logger call.\n"));
194	pR0Logger->Logger.pfnFlush(&pR0Logger->Logger);
195	LogCom(("VMMR0Init: returned succesfully from direct flush call.\n"));
196
197	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
198	LogCom(("VMMR0Init: after %p reg2\n", RTLogDefaultInstance()));
199	pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
200	LogCom(("VMMR0Init: returned succesfully from direct logger call (2). offScratch=%d\n", pR0Logger->Logger.offScratch));
201	RTLogSetDefaultInstanceThread(NULL, 0);
202	LogCom(("VMMR0Init: after %p dereg2\n", RTLogDefaultInstance()));
203
204	RTLogLoggerEx(&pR0Logger->Logger, 0, ~0U, "hello ring-0 logger (RTLogLoggerEx)\n");
205	LogCom(("VMMR0Init: RTLogLoggerEx returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
206
207	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
208	RTLogPrintf("hello ring-0 logger (RTLogPrintf)\n");
209	LogCom(("VMMR0Init: RTLogPrintf returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
210	#endif
211	Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pVM->pSession));
212	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
213	}
214
215	/*
216	* Initialize the per VM data for GVMM and GMM.
217	*/
218	int rc = GVMMR0InitVM(pVM);
219	// if (RT_SUCCESS(rc))
220	// rc = GMMR0InitPerVMData(pVM);
221	if (RT_SUCCESS(rc))
222	{
223	/*
224	* Init HWACCM.
225	*/
226	rc = HWACCMR0InitVM(pVM);
227	if (RT_SUCCESS(rc))
228	{
229	/*
230	* Init CPUM.
231	*/
232	rc = CPUMR0Init(pVM);
233	if (RT_SUCCESS(rc))
234	return rc;
235	}
236	}
237
238	/* failed */
239	RTLogSetDefaultInstanceThread(NULL, 0);
240	return rc;
241	}
242
243
244	/**
245	* Terminates the R0 driver for a particular VM instance.
246	*
247	* @returns VBox status code.
248	*
249	* @param pVM The VM instance in question.
250	* @thread EMT.
251	*/
252	static int VMMR0Term(PVM pVM)
253	{
254	HWACCMR0TermVM(pVM);
255
256	/*
257	* Deregister the logger.
258	*/
259	RTLogSetDefaultInstanceThread(NULL, 0);
260	return VINF_SUCCESS;
261	}
262
263
264	/**
265	* Calls the ring-3 host code.
266	*
267	* @returns VBox status code of the ring-3 call.
268	* @param pVM The VM handle.
269	* @param enmOperation The operation.
270	* @param uArg The argument to the operation.
271	*/
272	VMMR0DECL(int) VMMR0CallHost(PVM pVM, VMMCALLHOST enmOperation, uint64_t uArg)
273	{
274	/** @todo profile this! */
275	pVM->vmm.s.enmCallHostOperation = enmOperation;
276	pVM->vmm.s.u64CallHostArg = uArg;
277	pVM->vmm.s.rcCallHost = VERR_INTERNAL_ERROR;
278	int rc = vmmR0CallHostLongJmp(&pVM->vmm.s.CallHostR0JmpBuf, VINF_VMM_CALL_HOST);
279	if (rc == VINF_SUCCESS)
280	rc = pVM->vmm.s.rcCallHost;
281	return rc;
282	}
283
284
285	#ifdef VBOX_WITH_STATISTICS
286	/**
287	* Record return code statistics
288	* @param pVM The VM handle.
289	* @param rc The status code.
290	*/
291	static void vmmR0RecordRC(PVM pVM, int rc)
292	{
293	/*
294	* Collect statistics.
295	*/
296	switch (rc)
297	{
298	case VINF_SUCCESS:
299	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetNormal);
300	break;
301	case VINF_EM_RAW_INTERRUPT:
302	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetInterrupt);
303	break;
304	case VINF_EM_RAW_INTERRUPT_HYPER:
305	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetInterruptHyper);
306	break;
307	case VINF_EM_RAW_GUEST_TRAP:
308	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetGuestTrap);
309	break;
310	case VINF_EM_RAW_RING_SWITCH:
311	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetRingSwitch);
312	break;
313	case VINF_EM_RAW_RING_SWITCH_INT:
314	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetRingSwitchInt);
315	break;
316	case VINF_EM_RAW_EXCEPTION_PRIVILEGED:
317	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetExceptionPrivilege);
318	break;
319	case VINF_EM_RAW_STALE_SELECTOR:
320	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetStaleSelector);
321	break;
322	case VINF_EM_RAW_IRET_TRAP:
323	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetIRETTrap);
324	break;
325	case VINF_IOM_HC_IOPORT_READ:
326	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetIORead);
327	break;
328	case VINF_IOM_HC_IOPORT_WRITE:
329	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetIOWrite);
330	break;
331	case VINF_IOM_HC_MMIO_READ:
332	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetMMIORead);
333	break;
334	case VINF_IOM_HC_MMIO_WRITE:
335	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetMMIOWrite);
336	break;
337	case VINF_IOM_HC_MMIO_READ_WRITE:
338	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetMMIOReadWrite);
339	break;
340	case VINF_PATM_HC_MMIO_PATCH_READ:
341	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetMMIOPatchRead);
342	break;
343	case VINF_PATM_HC_MMIO_PATCH_WRITE:
344	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetMMIOPatchWrite);
345	break;
346	case VINF_EM_RAW_EMULATE_INSTR:
347	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetEmulate);
348	break;
349	case VINF_PATCH_EMULATE_INSTR:
350	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPatchEmulate);
351	break;
352	case VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT:
353	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetLDTFault);
354	break;
355	case VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT:
356	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetGDTFault);
357	break;
358	case VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT:
359	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetIDTFault);
360	break;
361	case VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT:
362	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetTSSFault);
363	break;
364	case VINF_EM_RAW_EMULATE_INSTR_PD_FAULT:
365	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPDFault);
366	break;
367	case VINF_CSAM_PENDING_ACTION:
368	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetCSAMTask);
369	break;
370	case VINF_PGM_SYNC_CR3:
371	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetSyncCR3);
372	break;
373	case VINF_PATM_PATCH_INT3:
374	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPatchInt3);
375	break;
376	case VINF_PATM_PATCH_TRAP_PF:
377	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPatchPF);
378	break;
379	case VINF_PATM_PATCH_TRAP_GP:
380	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPatchGP);
381	break;
382	case VINF_PATM_PENDING_IRQ_AFTER_IRET:
383	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPatchIretIRQ);
384	break;
385	case VERR_REM_FLUSHED_PAGES_OVERFLOW:
386	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPageOverflow);
387	break;
388	case VINF_EM_RESCHEDULE_REM:
389	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetRescheduleREM);
390	break;
391	case VINF_EM_RAW_TO_R3:
392	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetToR3);
393	break;
394	case VINF_EM_RAW_TIMER_PENDING:
395	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetTimerPending);
396	break;
397	case VINF_EM_RAW_INTERRUPT_PENDING:
398	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetInterruptPending);
399	break;
400	case VINF_VMM_CALL_HOST:
401	switch (pVM->vmm.s.enmCallHostOperation)
402	{
403	case VMMCALLHOST_PDM_LOCK:
404	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPDMLock);
405	break;
406	case VMMCALLHOST_PDM_QUEUE_FLUSH:
407	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPDMQueueFlush);
408	break;
409	case VMMCALLHOST_PGM_POOL_GROW:
410	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPGMPoolGrow);
411	break;
412	case VMMCALLHOST_PGM_LOCK:
413	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPGMLock);
414	break;
415	case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
416	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetRemReplay);
417	break;
418	case VMMCALLHOST_PGM_RAM_GROW_RANGE:
419	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPGMGrowRAM);
420	break;
421	case VMMCALLHOST_VMM_LOGGER_FLUSH:
422	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetLogFlush);
423	break;
424	case VMMCALLHOST_VM_SET_ERROR:
425	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetVMSetError);
426	break;
427	case VMMCALLHOST_VM_SET_RUNTIME_ERROR:
428	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetVMSetRuntimeError);
429	break;
430	case VMMCALLHOST_VM_R0_HYPER_ASSERTION:
431	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetHyperAssertion);
432	break;
433	default:
434	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetCallHost);
435	break;
436	}
437	break;
438	case VINF_PATM_DUPLICATE_FUNCTION:
439	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPATMDuplicateFn);
440	break;
441	case VINF_PGM_CHANGE_MODE:
442	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPGMChangeMode);
443	break;
444	case VINF_EM_RAW_EMULATE_INSTR_HLT:
445	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetEmulHlt);
446	break;
447	case VINF_EM_PENDING_REQUEST:
448	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetPendingRequest);
449	break;
450	default:
451	STAM_COUNTER_INC(&pVM->vmm.s.StatGCRetMisc);
452	break;
453	}
454	}
455	#endif /* VBOX_WITH_STATISTICS */
456
457
458
459	/**
460	* The Ring 0 entry point, called by the interrupt gate.
461	*
462	* @returns VBox status code.
463	* @param pVM The VM to operate on.
464	* @param enmOperation Which operation to execute.
465	* @param pvArg Argument to the operation.
466	* @remarks Assume called with interrupts disabled.
467	*/
468	VMMR0DECL(int) VMMR0EntryInt(PVM pVM, VMMR0OPERATION enmOperation, void *pvArg)
469	{
470	switch (enmOperation)
471	{
472	#ifdef VBOX_WITH_IDT_PATCHING
473	/*
474	* Switch to GC.
475	* These calls return whatever the GC returns.
476	*/
477	case VMMR0_DO_RAW_RUN:
478	{
479	/* Safety precaution as VMX disables the switcher. */
480	Assert(!pVM->vmm.s.fSwitcherDisabled);
481	if (pVM->vmm.s.fSwitcherDisabled)
482	return VERR_NOT_SUPPORTED;
483
484	STAM_COUNTER_INC(&pVM->vmm.s.StatRunGC);
485	register int rc;
486	pVM->vmm.s.iLastGCRc = rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
487
488	#ifdef VBOX_WITH_STATISTICS
489	vmmR0RecordRC(pVM, rc);
490	#endif
491
492	/*
493	* We'll let TRPM change the stack frame so our return is different.
494	* Just keep in mind that after the call, things have changed!
495	*/
496	if ( rc == VINF_EM_RAW_INTERRUPT
497	\|\| rc == VINF_EM_RAW_INTERRUPT_HYPER)
498	{
499	/*
500	* Don't trust the compiler to get this right.
501	* gcc -fomit-frame-pointer screws up big time here. This works fine in 64-bit
502	* mode too because we push the arguments on the stack in the IDT patch code.
503	*/
504	# if defined(__GNUC__)
505	void pvRet = (uint8_t )__builtin_frame_address(0) + sizeof(void *);
506	# elif defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
507	void pvRet = (uint8_t )_AddressOfReturnAddress();
508	# elif defined(RT_ARCH_X86)
509	void pvRet = (uint8_t )&pVM - sizeof(pVM);
510	# else
511	# error "huh?"
512	# endif
513	if ( ((uintptr_t *)pvRet)[1] == (uintptr_t)pVM
514	&& ((uintptr_t *)pvRet)[2] == (uintptr_t)enmOperation
515	&& ((uintptr_t *)pvRet)[3] == (uintptr_t)pvArg)
516	TRPMR0SetupInterruptDispatcherFrame(pVM, pvRet);
517	else
518	{
519	# if defined(DEBUG) \|\| defined(LOG_ENABLED)
520	static bool s_fHaveWarned = false;
521	if (!s_fHaveWarned)
522	{
523	s_fHaveWarned = true;
524	RTLogPrintf("VMMR0.r0: The compiler can't find the stack frame!\n");
525	RTLogComPrintf("VMMR0.r0: The compiler can't find the stack frame!\n");
526	}
527	# endif
528	TRPMR0DispatchHostInterrupt(pVM);
529	}
530	}
531	return rc;
532	}
533
534	/*
535	* Switch to GC to execute Hypervisor function.
536	*/
537	case VMMR0_DO_CALL_HYPERVISOR:
538	{
539	/* Safety precaution as VMX disables the switcher. */
540	Assert(!pVM->vmm.s.fSwitcherDisabled);
541	if (pVM->vmm.s.fSwitcherDisabled)
542	return VERR_NOT_SUPPORTED;
543
544	RTCCUINTREG fFlags = ASMIntDisableFlags();
545	int rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
546	/** @todo dispatch interrupts? */
547	ASMSetFlags(fFlags);
548	return rc;
549	}
550
551	/*
552	* For profiling.
553	*/
554	case VMMR0_DO_NOP:
555	return VINF_SUCCESS;
556	#endif /* VBOX_WITH_IDT_PATCHING */
557
558	default:
559	/*
560	* We're returning VERR_NOT_SUPPORT here so we've got something else
561	* than -1 which the interrupt gate glue code might return.
562	*/
563	Log(("operation %#x is not supported\n", enmOperation));
564	return VERR_NOT_SUPPORTED;
565	}
566	}
567
568
569	/**
570	* The Ring 0 entry point, called by the fast-ioctl path.
571	*
572	* @returns VBox status code.
573	* @param pVM The VM to operate on.
574	* @param enmOperation Which operation to execute.
575	* @remarks Assume called with interrupts _enabled_.
576	*/
577	VMMR0DECL(int) VMMR0EntryFast(PVM pVM, VMMR0OPERATION enmOperation)
578	{
579	switch (enmOperation)
580	{
581	/*
582	* Switch to GC and run guest raw mode code.
583	* Disable interrupts before doing the world switch.
584	*/
585	case VMMR0_DO_RAW_RUN:
586	{
587	/* Safety precaution as hwaccm disables the switcher. */
588	if (RT_LIKELY(!pVM->vmm.s.fSwitcherDisabled))
589	{
590	RTCCUINTREG uFlags = ASMIntDisableFlags();
591
592	int rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
593	pVM->vmm.s.iLastGCRc = rc;
594
595	if ( rc == VINF_EM_RAW_INTERRUPT
596	\|\| rc == VINF_EM_RAW_INTERRUPT_HYPER)
597	TRPMR0DispatchHostInterrupt(pVM);
598
599	ASMSetFlags(uFlags);
600
601	#ifdef VBOX_WITH_STATISTICS
602	STAM_COUNTER_INC(&pVM->vmm.s.StatRunGC);
603	vmmR0RecordRC(pVM, rc);
604	#endif
605	return rc;
606	}
607
608	Assert(!pVM->vmm.s.fSwitcherDisabled);
609	return VERR_NOT_SUPPORTED;
610	}
611
612	/*
613	* Run guest code using the available hardware acceleration technology.
614	*
615	* Disable interrupts before we do anything interesting. On Windows we avoid
616	* this by having the support driver raise the IRQL before calling us, this way
617	* we hope to get away we page faults and later calling into the kernel.
618	*/
619	case VMMR0_DO_HWACC_RUN:
620	{
621	STAM_COUNTER_INC(&pVM->vmm.s.StatRunGC);
622
623	#ifndef RT_OS_WINDOWS /** @todo check other hosts */
624	RTCCUINTREG uFlags = ASMIntDisableFlags();
625	#endif
626	int rc = HWACCMR0Enter(pVM);
627	if (VBOX_SUCCESS(rc))
628	{
629	rc = vmmR0CallHostSetJmp(&pVM->vmm.s.CallHostR0JmpBuf, HWACCMR0RunGuestCode, pVM); /* this may resume code. */
630	int rc2 = HWACCMR0Leave(pVM);
631	AssertRC(rc2);
632	}
633	pVM->vmm.s.iLastGCRc = rc;
634	#ifndef RT_OS_WINDOWS /** @todo check other hosts */
635	ASMSetFlags(uFlags);
636	#endif
637
638	#ifdef VBOX_WITH_STATISTICS
639	vmmR0RecordRC(pVM, rc);
640	#endif
641	/* No special action required for external interrupts, just return. */
642	return rc;
643	}
644
645	/*
646	* For profiling.
647	*/
648	case VMMR0_DO_NOP:
649	return VINF_SUCCESS;
650
651	/*
652	* Impossible.
653	*/
654	default:
655	AssertMsgFailed(("%#x\n", enmOperation));
656	return VERR_NOT_SUPPORTED;
657	}
658	}
659
660
661	/**
662	* VMMR0EntryEx worker function, either called directly or when ever possible
663	* called thru a longjmp so we can exit safely on failure.
664	*
665	* @returns VBox status code.
666	* @param pVM The VM to operate on.
667	* @param enmOperation Which operation to execute.
668	* @param pReqHdr This points to a SUPVMMR0REQHDR packet. Optional.
669	* @param u64Arg Some simple constant argument.
670	* @remarks Assume called with interrupts _enabled_.
671	*/
672	static int vmmR0EntryExWorker(PVM pVM, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg)
673	{
674	/*
675	* Common VM pointer validation.
676	*/
677	if (pVM)
678	{
679	if (RT_UNLIKELY( !VALID_PTR(pVM)
680	\|\| ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
681	{
682	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p! (op=%d)\n", pVM, enmOperation);
683	return VERR_INVALID_POINTER;
684	}
685	if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
686	\|\| pVM->enmVMState > VMSTATE_TERMINATED
687	\|\| pVM->pVMR0 != pVM))
688	{
689	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{enmVMState=%d, .pVMR0=%p}! (op=%d)\n",
690	pVM, pVM->enmVMState, pVM->pVMR0, enmOperation);
691	return VERR_INVALID_POINTER;
692	}
693	}
694
695	switch (enmOperation)
696	{
697	/*
698	* GVM requests
699	*/
700	case VMMR0_DO_GVMM_CREATE_VM:
701	if (pVM \|\| u64Arg)
702	return VERR_INVALID_PARAMETER;
703	return GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr);
704
705	case VMMR0_DO_GVMM_DESTROY_VM:
706	if (pReqHdr \|\| u64Arg)
707	return VERR_INVALID_PARAMETER;
708	return GVMMR0DestroyVM(pVM);
709
710	case VMMR0_DO_GVMM_SCHED_HALT:
711	if (pReqHdr)
712	return VERR_INVALID_PARAMETER;
713	return GVMMR0SchedHalt(pVM, u64Arg);
714
715	case VMMR0_DO_GVMM_SCHED_WAKE_UP:
716	if (pReqHdr \|\| u64Arg)
717	return VERR_INVALID_PARAMETER;
718	return GVMMR0SchedWakeUp(pVM);
719
720	case VMMR0_DO_GVMM_SCHED_POLL:
721	if (pReqHdr \|\| u64Arg > 1)
722	return VERR_INVALID_PARAMETER;
723	return GVMMR0SchedPoll(pVM, (bool)u64Arg);
724
725	case VMMR0_DO_GVMM_QUERY_STATISTICS:
726	if (u64Arg)
727	return VERR_INVALID_PARAMETER;
728	return GVMMR0QueryStatisticsReq(pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr);
729
730	case VMMR0_DO_GVMM_RESET_STATISTICS:
731	if (u64Arg)
732	return VERR_INVALID_PARAMETER;
733	return GVMMR0ResetStatisticsReq(pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr);
734
735	/*
736	* Initialize the R0 part of a VM instance.
737	*/
738	case VMMR0_DO_VMMR0_INIT:
739	return VMMR0Init(pVM, (unsigned)u64Arg);
740
741	/*
742	* Terminate the R0 part of a VM instance.
743	*/
744	case VMMR0_DO_VMMR0_TERM:
745	return VMMR0Term(pVM);
746
747	/*
748	* Attempt to enable hwacc mode and check the current setting.
749	*
750	*/
751	case VMMR0_DO_HWACC_ENABLE:
752	return HWACCMR0EnableAllCpus(pVM, (HWACCMSTATE)u64Arg);
753
754	/*
755	* Setup the hardware accelerated raw-mode session.
756	*/
757	case VMMR0_DO_HWACC_SETUP_VM:
758	{
759	RTCCUINTREG fFlags = ASMIntDisableFlags();
760	int rc = HWACCMR0SetupVM(pVM);
761	ASMSetFlags(fFlags);
762	return rc;
763	}
764
765	/*
766	* Switch to GC to execute Hypervisor function.
767	*/
768	case VMMR0_DO_CALL_HYPERVISOR:
769	{
770	/* Safety precaution as HWACCM can disable the switcher. */
771	Assert(!pVM->vmm.s.fSwitcherDisabled);
772	if (RT_UNLIKELY(pVM->vmm.s.fSwitcherDisabled))
773	return VERR_NOT_SUPPORTED;
774
775	RTCCUINTREG fFlags = ASMIntDisableFlags();
776	int rc = pVM->vmm.s.pfnR0HostToGuest(pVM);
777	/** @todo dispatch interrupts? */
778	ASMSetFlags(fFlags);
779	return rc;
780	}
781
782	/*
783	* PGM wrappers.
784	*/
785	case VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES:
786	return PGMR0PhysAllocateHandyPages(pVM);
787
788	/*
789	* GMM wrappers.
790	*/
791	case VMMR0_DO_GMM_INITIAL_RESERVATION:
792	if (u64Arg)
793	return VERR_INVALID_PARAMETER;
794	return GMMR0InitialReservationReq(pVM, (PGMMINITIALRESERVATIONREQ)pReqHdr);
795	case VMMR0_DO_GMM_UPDATE_RESERVATION:
796	if (u64Arg)
797	return VERR_INVALID_PARAMETER;
798	return GMMR0UpdateReservationReq(pVM, (PGMMUPDATERESERVATIONREQ)pReqHdr);
799
800	case VMMR0_DO_GMM_ALLOCATE_PAGES:
801	if (u64Arg)
802	return VERR_INVALID_PARAMETER;
803	return GMMR0AllocatePagesReq(pVM, (PGMMALLOCATEPAGESREQ)pReqHdr);
804	case VMMR0_DO_GMM_FREE_PAGES:
805	if (u64Arg)
806	return VERR_INVALID_PARAMETER;
807	return GMMR0FreePagesReq(pVM, (PGMMFREEPAGESREQ)pReqHdr);
808	case VMMR0_DO_GMM_BALLOONED_PAGES:
809	if (u64Arg)
810	return VERR_INVALID_PARAMETER;
811	return GMMR0BalloonedPagesReq(pVM, (PGMMBALLOONEDPAGESREQ)pReqHdr);
812	case VMMR0_DO_GMM_DEFLATED_BALLOON:
813	if (pReqHdr)
814	return VERR_INVALID_PARAMETER;
815	return GMMR0DeflatedBalloon(pVM, (uint32_t)u64Arg);
816
817	case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
818	if (u64Arg)
819	return VERR_INVALID_PARAMETER;
820	return GMMR0MapUnmapChunkReq(pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
821	case VMMR0_DO_GMM_SEED_CHUNK:
822	if (pReqHdr)
823	return VERR_INVALID_PARAMETER;
824	return GMMR0SeedChunk(pVM, (RTR3PTR)u64Arg);
825
826	/*
827	* A quick GCFGM mock-up.
828	*/
829	/** @todo GCFGM with proper access control, ring-3 management interface and all that. */
830	case VMMR0_DO_GCFGM_SET_VALUE:
831	case VMMR0_DO_GCFGM_QUERY_VALUE:
832	{
833	if (pVM \|\| !pReqHdr \|\| u64Arg)
834	return VERR_INVALID_PARAMETER;
835	PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
836	if (pReq->Hdr.cbReq != sizeof(*pReq))
837	return VERR_INVALID_PARAMETER;
838	int rc;
839	if (enmOperation == VMMR0_DO_GCFGM_SET_VALUE)
840	{
841	rc = GVMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
842	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
843	// rc = GMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
844	}
845	else
846	{
847	rc = GVMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
848	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
849	// rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
850	}
851	return rc;
852	}
853
854
855	#ifdef VBOX_WITH_INTERNAL_NETWORKING
856	/*
857	* Requests to the internal networking service.
858	*/
859	case VMMR0_DO_INTNET_OPEN:
860	if (!pVM \|\| u64Arg)
861	return VERR_INVALID_PARAMETER;
862	if (!g_pIntNet)
863	return VERR_NOT_SUPPORTED;
864	return INTNETR0OpenReq(g_pIntNet, pVM->pSession, (PINTNETOPENREQ)pReqHdr);
865
866	case VMMR0_DO_INTNET_IF_CLOSE:
867	if (!pVM \|\| u64Arg)
868	return VERR_INVALID_PARAMETER;
869	if (!g_pIntNet)
870	return VERR_NOT_SUPPORTED;
871	return INTNETR0IfCloseReq(g_pIntNet, (PINTNETIFCLOSEREQ)pReqHdr);
872
873	case VMMR0_DO_INTNET_IF_GET_RING3_BUFFER:
874	if (!pVM \|\| u64Arg)
875	return VERR_INVALID_PARAMETER;
876	if (!g_pIntNet)
877	return VERR_NOT_SUPPORTED;
878	return INTNETR0IfGetRing3BufferReq(g_pIntNet, (PINTNETIFGETRING3BUFFERREQ)pReqHdr);
879
880	case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
881	if (!pVM \|\| u64Arg)
882	return VERR_INVALID_PARAMETER;
883	if (!g_pIntNet)
884	return VERR_NOT_SUPPORTED;
885	return INTNETR0IfSetPromiscuousModeReq(g_pIntNet, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
886
887	case VMMR0_DO_INTNET_IF_SEND:
888	if (!pVM \|\| u64Arg)
889	return VERR_INVALID_PARAMETER;
890	if (!g_pIntNet)
891	return VERR_NOT_SUPPORTED;
892	return INTNETR0IfSendReq(g_pIntNet, (PINTNETIFSENDREQ)pReqHdr);
893
894	case VMMR0_DO_INTNET_IF_WAIT:
895	if (!pVM \|\| u64Arg)
896	return VERR_INVALID_PARAMETER;
897	if (!g_pIntNet)
898	return VERR_NOT_SUPPORTED;
899	return INTNETR0IfWaitReq(g_pIntNet, (PINTNETIFWAITREQ)pReqHdr);
900	#endif /* VBOX_WITH_INTERNAL_NETWORKING */
901
902	/*
903	* For profiling.
904	*/
905	case VMMR0_DO_NOP:
906	return VINF_SUCCESS;
907
908	/*
909	* For testing Ring-0 APIs invoked in this environment.
910	*/
911	case VMMR0_DO_TESTS:
912	/** @todo make new test */
913	return VINF_SUCCESS;
914
915
916	default:
917	/*
918	* We're returning VERR_NOT_SUPPORT here so we've got something else
919	* than -1 which the interrupt gate glue code might return.
920	*/
921	Log(("operation %#x is not supported\n", enmOperation));
922	return VERR_NOT_SUPPORTED;
923	}
924	}
925
926
927	/**
928	* Argument for vmmR0EntryExWrapper containing the argument s ofr VMMR0EntryEx.
929	*/
930	typedef struct VMMR0ENTRYEXARGS
931	{
932	PVM pVM;
933	VMMR0OPERATION enmOperation;
934	PSUPVMMR0REQHDR pReq;
935	uint64_t u64Arg;
936	} VMMR0ENTRYEXARGS;
937	/** Pointer to a vmmR0EntryExWrapper argument package. */
938	typedef VMMR0ENTRYEXARGS *PVMMR0ENTRYEXARGS;
939
940	/**
941	* This is just a longjmp wrapper function for VMMR0EntryEx calls.
942	*
943	* @returns VBox status code.
944	* @param pvArgs The argument package
945	*/
946	static int vmmR0EntryExWrapper(void *pvArgs)
947	{
948	return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
949	((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
950	((PVMMR0ENTRYEXARGS)pvArgs)->pReq,
951	((PVMMR0ENTRYEXARGS)pvArgs)->u64Arg);
952	}
953
954
955	/**
956	* The Ring 0 entry point, called by the support library (SUP).
957	*
958	* @returns VBox status code.
959	* @param pVM The VM to operate on.
960	* @param enmOperation Which operation to execute.
961	* @param pReq This points to a SUPVMMR0REQHDR packet. Optional.
962	* @param u64Arg Some simple constant argument.
963	* @remarks Assume called with interrupts _enabled_.
964	*/
965	VMMR0DECL(int) VMMR0EntryEx(PVM pVM, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg)
966	{
967	/*
968	* Requests that should only happen on the EMT thread will be
969	* wrapped in a setjmp so we can assert without causing trouble.
970	*/
971	if ( VALID_PTR(pVM)
972	&& pVM->pVMR0)
973	{
974	switch (enmOperation)
975	{
976	case VMMR0_DO_VMMR0_INIT:
977	case VMMR0_DO_VMMR0_TERM:
978	case VMMR0_DO_GMM_INITIAL_RESERVATION:
979	case VMMR0_DO_GMM_UPDATE_RESERVATION:
980	case VMMR0_DO_GMM_ALLOCATE_PAGES:
981	case VMMR0_DO_GMM_FREE_PAGES:
982	case VMMR0_DO_GMM_BALLOONED_PAGES:
983	case VMMR0_DO_GMM_DEFLATED_BALLOON:
984	case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
985	case VMMR0_DO_GMM_SEED_CHUNK:
986	{
987	/** @todo validate this EMT claim... GVM knows. */
988	VMMR0ENTRYEXARGS Args;
989	Args.pVM = pVM;
990	Args.enmOperation = enmOperation;
991	Args.pReq = pReq;
992	Args.u64Arg = u64Arg;
993	return vmmR0CallHostSetJmpEx(&pVM->vmm.s.CallHostR0JmpBuf, vmmR0EntryExWrapper, &Args);
994	}
995
996	default:
997	break;
998	}
999	}
1000	return vmmR0EntryExWorker(pVM, enmOperation, pReq, u64Arg);
1001	}
1002
1003
1004
1005	/**
1006	* Internal R0 logger worker: Flush logger.
1007	*
1008	* @param pLogger The logger instance to flush.
1009	* @remark This function must be exported!
1010	*/
1011	VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger)
1012	{
1013	/*
1014	* Convert the pLogger into a VM handle and 'call' back to Ring-3.
1015	* (This is a bit paranoid code.)
1016	*/
1017	PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1018	if ( !VALID_PTR(pR0Logger)
1019	\|\| !VALID_PTR(pR0Logger + 1)
1020	\|\| !VALID_PTR(pLogger)
1021	\|\| pLogger->u32Magic != RTLOGGER_MAGIC)
1022	{
1023	#ifdef DEBUG
1024	SUPR0Printf("vmmR0LoggerFlush: pLogger=%p!\n", pLogger);
1025	#endif
1026	return;
1027	}
1028
1029	PVM pVM = pR0Logger->pVM;
1030	if ( !VALID_PTR(pVM)
1031	\|\| pVM->pVMR0 != pVM)
1032	{
1033	#ifdef DEBUG
1034	SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
1035	#endif
1036	return;
1037	}
1038
1039	/*
1040	* Check that the jump buffer is armed.
1041	*/
1042	#ifdef RT_ARCH_X86
1043	if (!pVM->vmm.s.CallHostR0JmpBuf.eip)
1044	#else
1045	if (!pVM->vmm.s.CallHostR0JmpBuf.rip)
1046	#endif
1047	{
1048	#ifdef DEBUG
1049	SUPR0Printf("vmmR0LoggerFlush: Jump buffer isn't armed!\n");
1050	#endif
1051	pLogger->offScratch = 0;
1052	return;
1053	}
1054	VMMR0CallHost(pVM, VMMCALLHOST_VMM_LOGGER_FLUSH, 0);
1055	}
1056
1057
1058
1059	/**
1060	* Jump back to ring-3 if we're the EMT and the longjmp is armed.
1061	*
1062	* @returns true if the breakpoint should be hit, false if it should be ignored.
1063	* @remark The RTDECL() makes this a bit difficult to override on windows. Sorry.
1064	*/
1065	DECLEXPORT(bool) RTCALL RTAssertDoBreakpoint(void)
1066	{
1067	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1068	if (pVM)
1069	{
1070	#ifdef RT_ARCH_X86
1071	if (pVM->vmm.s.CallHostR0JmpBuf.eip)
1072	#else
1073	if (pVM->vmm.s.CallHostR0JmpBuf.rip)
1074	#endif
1075	{
1076	int rc = VMMR0CallHost(pVM, VMMCALLHOST_VM_R0_HYPER_ASSERTION, 0);
1077	return RT_FAILURE_NP(rc);
1078	}
1079	}
1080	#ifdef RT_OS_LINUX
1081	return true;
1082	#else
1083	return false;
1084	#endif
1085	}
1086
1087
1088
1089	/**
1090	* Override this so we can push it up to ring-3.
1091	*
1092	* @param pszExpr Expression. Can be NULL.
1093	* @param uLine Location line number.
1094	* @param pszFile Location file name.
1095	* @param pszFunction Location function name.
1096	*/
1097	DECLEXPORT(void) RTCALL AssertMsg1(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction)
1098	{
1099	#ifndef DEBUG_sandervl
1100	SUPR0Printf("\n!!R0-Assertion Failed!!\n"
1101	"Expression: %s\n"
1102	"Location : %s(%d) %s\n",
1103	pszExpr, pszFile, uLine, pszFunction);
1104	#endif
1105	LogAlways(("\n!!R0-Assertion Failed!!\n"
1106	"Expression: %s\n"
1107	"Location : %s(%d) %s\n",
1108	pszExpr, pszFile, uLine, pszFunction));
1109	}
1110
1111
1112	/**
1113	* Callback for RTLogFormatV which writes to the ring-3 log port.
1114	* See PFNLOGOUTPUT() for details.
1115	*/
1116	static DECLCALLBACK(size_t) rtLogOutput(void pv, const char pachChars, size_t cbChars)
1117	{
1118	for (size_t i = 0; i < cbChars; i++)
1119	{
1120	#ifndef DEBUG_sandervl
1121	SUPR0Printf("%c", pachChars[i]);
1122	#endif
1123	LogAlways(("%c", pachChars[i]));
1124	}
1125
1126	return cbChars;
1127	}
1128
1129
1130	DECLEXPORT(void) RTCALL AssertMsg2(const char *pszFormat, ...)
1131	{
1132	PRTLOGGER pLog = RTLogDefaultInstance(); /** @todo we want this for release as well! */
1133	if (pLog)
1134	{
1135	va_list args;
1136
1137	va_start(args, pszFormat);
1138	RTLogFormatV(rtLogOutput, pLog, pszFormat, args);
1139	va_end(args);
1140	}
1141	}
1142
1143

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

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

Download in other formats: