VMMR0.cpp@ 19015

Last change on this file since 19015 was 18927, checked in by vboxsync, 16 years ago
Big step to separate VMM data structures for guest SMP. (pgm, em)
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 41.5 KB

Line
1	/* $Id: VMMR0.cpp 18927 2009-04-16 11:41:38Z 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	* Header Files *
24	*******************************************************************************/
25	#define LOG_GROUP LOG_GROUP_VMM
26	#include <VBox/vmm.h>
27	#include <VBox/sup.h>
28	#include <VBox/trpm.h>
29	#include <VBox/cpum.h>
30	#include <VBox/pgm.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	#include <iprt/string.h>
48
49	#if defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
50	# pragma intrinsic(_AddressOfReturnAddress)
51	#endif
52
53
54	/*******************************************************************************
55	* Internal Functions *
56	*******************************************************************************/
57	__BEGIN_DECLS
58	VMMR0DECL(int) ModuleInit(void);
59	VMMR0DECL(void) ModuleTerm(void);
60	__END_DECLS
61
62
63	/*******************************************************************************
64	* Global Variables *
65	*******************************************************************************/
66	/** Pointer to the internal networking service instance. */
67	PINTNET g_pIntNet = 0;
68
69
70	/**
71	* Initialize the module.
72	* This is called when we're first loaded.
73	*
74	* @returns 0 on success.
75	* @returns VBox status on failure.
76	*/
77	VMMR0DECL(int) ModuleInit(void)
78	{
79	LogFlow(("ModuleInit:\n"));
80
81	/*
82	* Initialize the GVMM, GMM, HWACCM, PGM (Darwin) and INTNET.
83	*/
84	int rc = GVMMR0Init();
85	if (RT_SUCCESS(rc))
86	{
87	rc = GMMR0Init();
88	if (RT_SUCCESS(rc))
89	{
90	rc = HWACCMR0Init();
91	if (RT_SUCCESS(rc))
92	{
93	rc = PGMRegisterStringFormatTypes();
94	if (RT_SUCCESS(rc))
95	{
96	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
97	rc = PGMR0DynMapInit();
98	#endif
99	if (RT_SUCCESS(rc))
100	{
101	LogFlow(("ModuleInit: g_pIntNet=%p\n", g_pIntNet));
102	g_pIntNet = NULL;
103	LogFlow(("ModuleInit: g_pIntNet=%p should be NULL now...\n", g_pIntNet));
104	rc = INTNETR0Create(&g_pIntNet);
105	if (RT_SUCCESS(rc))
106	{
107	LogFlow(("ModuleInit: returns success. g_pIntNet=%p\n", g_pIntNet));
108	return VINF_SUCCESS;
109	}
110
111	/* bail out */
112	g_pIntNet = NULL;
113	LogFlow(("ModuleTerm: returns %Rrc\n", rc));
114	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
115	PGMR0DynMapTerm();
116	#endif
117	}
118	PGMDeregisterStringFormatTypes();
119	}
120	HWACCMR0Term();
121	}
122	GMMR0Term();
123	}
124	GVMMR0Term();
125	}
126
127	LogFlow(("ModuleInit: failed %Rrc\n", rc));
128	return rc;
129	}
130
131
132	/**
133	* Terminate the module.
134	* This is called when we're finally unloaded.
135	*/
136	VMMR0DECL(void) ModuleTerm(void)
137	{
138	LogFlow(("ModuleTerm:\n"));
139
140	/*
141	* Destroy the internal networking instance.
142	*/
143	if (g_pIntNet)
144	{
145	INTNETR0Destroy(g_pIntNet);
146	g_pIntNet = NULL;
147	}
148
149	/*
150	* PGM (Darwin) and HWACCM global cleanup.
151	* Destroy the GMM and GVMM instances.
152	*/
153	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
154	PGMR0DynMapTerm();
155	#endif
156	PGMDeregisterStringFormatTypes();
157	HWACCMR0Term();
158
159	GMMR0Term();
160	GVMMR0Term();
161
162	LogFlow(("ModuleTerm: returns\n"));
163	}
164
165
166	/**
167	* Initaties the R0 driver for a particular VM instance.
168	*
169	* @returns VBox status code.
170	*
171	* @param pVM The VM instance in question.
172	* @param uSvnRev The SVN revision of the ring-3 part.
173	* @thread EMT.
174	*/
175	static int vmmR0InitVM(PVM pVM, uint32_t uSvnRev)
176	{
177	/*
178	* Match the SVN revisions.
179	*/
180	if (uSvnRev != VMMGetSvnRev())
181	{
182	LogRel(("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev()));
183	SUPR0Printf("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev());
184	return VERR_VERSION_MISMATCH;
185	}
186	if ( !VALID_PTR(pVM)
187	\|\| pVM->pVMR0 != pVM)
188	return VERR_INVALID_PARAMETER;
189
190	/*
191	* Register the EMT R0 logger instance.
192	*/
193	PVMMR0LOGGER pR0Logger = pVM->vmm.s.pR0LoggerR0;
194	if (pR0Logger)
195	{
196	#if 0 /* testing of the logger. */
197	LogCom(("vmmR0InitVM: before %p\n", RTLogDefaultInstance()));
198	LogCom(("vmmR0InitVM: pfnFlush=%p actual=%p\n", pR0Logger->Logger.pfnFlush, vmmR0LoggerFlush));
199	LogCom(("vmmR0InitVM: pfnLogger=%p actual=%p\n", pR0Logger->Logger.pfnLogger, vmmR0LoggerWrapper));
200	LogCom(("vmmR0InitVM: offScratch=%d fFlags=%#x fDestFlags=%#x\n", pR0Logger->Logger.offScratch, pR0Logger->Logger.fFlags, pR0Logger->Logger.fDestFlags));
201
202	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
203	LogCom(("vmmR0InitVM: after %p reg\n", RTLogDefaultInstance()));
204	RTLogSetDefaultInstanceThread(NULL, 0);
205	LogCom(("vmmR0InitVM: after %p dereg\n", RTLogDefaultInstance()));
206
207	pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
208	LogCom(("vmmR0InitVM: returned succesfully from direct logger call.\n"));
209	pR0Logger->Logger.pfnFlush(&pR0Logger->Logger);
210	LogCom(("vmmR0InitVM: returned succesfully from direct flush call.\n"));
211
212	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
213	LogCom(("vmmR0InitVM: after %p reg2\n", RTLogDefaultInstance()));
214	pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
215	LogCom(("vmmR0InitVM: returned succesfully from direct logger call (2). offScratch=%d\n", pR0Logger->Logger.offScratch));
216	RTLogSetDefaultInstanceThread(NULL, 0);
217	LogCom(("vmmR0InitVM: after %p dereg2\n", RTLogDefaultInstance()));
218
219	RTLogLoggerEx(&pR0Logger->Logger, 0, ~0U, "hello ring-0 logger (RTLogLoggerEx)\n");
220	LogCom(("vmmR0InitVM: RTLogLoggerEx returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
221
222	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
223	RTLogPrintf("hello ring-0 logger (RTLogPrintf)\n");
224	LogCom(("vmmR0InitVM: RTLogPrintf returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
225	#endif
226	Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pVM->pSession));
227	RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
228	}
229
230	/*
231	* Initialize the per VM data for GVMM and GMM.
232	*/
233	int rc = GVMMR0InitVM(pVM);
234	// if (RT_SUCCESS(rc))
235	// rc = GMMR0InitPerVMData(pVM);
236	if (RT_SUCCESS(rc))
237	{
238	/*
239	* Init HWACCM, CPUM and PGM (Darwin only).
240	*/
241	rc = HWACCMR0InitVM(pVM);
242	if (RT_SUCCESS(rc))
243	{
244	rc = CPUMR0Init(pVM); /** @todo rename to CPUMR0InitVM */
245	if (RT_SUCCESS(rc))
246	{
247	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
248	rc = PGMR0DynMapInitVM(pVM);
249	#endif
250	if (RT_SUCCESS(rc))
251	{
252	GVMMR0DoneInitVM(pVM);
253	return rc;
254	}
255
256	/* bail out */
257	}
258	HWACCMR0TermVM(pVM);
259	}
260	}
261	RTLogSetDefaultInstanceThread(NULL, 0);
262	return rc;
263	}
264
265
266	/**
267	* Terminates the R0 driver for a particular VM instance.
268	*
269	* This is normally called by ring-3 as part of the VM termination process, but
270	* may alternatively be called during the support driver session cleanup when
271	* the VM object is destroyed (see GVMM).
272	*
273	* @returns VBox status code.
274	*
275	* @param pVM The VM instance in question.
276	* @param pGVM Pointer to the global VM structure. Optional.
277	* @thread EMT or session clean up thread.
278	*/
279	VMMR0DECL(int) VMMR0TermVM(PVM pVM, PGVM pGVM)
280	{
281	/*
282	* Tell GVMM what we're up to and check that we only do this once.
283	*/
284	if (GVMMR0DoingTermVM(pVM, pGVM))
285	{
286	#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
287	PGMR0DynMapTermVM(pVM);
288	#endif
289	HWACCMR0TermVM(pVM);
290	}
291
292	/*
293	* Deregister the logger.
294	*/
295	RTLogSetDefaultInstanceThread(NULL, 0);
296	return VINF_SUCCESS;
297	}
298
299
300	/**
301	* Calls the ring-3 host code.
302	*
303	* @returns VBox status code of the ring-3 call.
304	* @param pVM The VM handle.
305	* @param enmOperation The operation.
306	* @param uArg The argument to the operation.
307	*/
308	VMMR0DECL(int) VMMR0CallHost(PVM pVM, VMMCALLHOST enmOperation, uint64_t uArg)
309	{
310	/** @todo profile this! */
311	pVM->vmm.s.enmCallHostOperation = enmOperation;
312	pVM->vmm.s.u64CallHostArg = uArg;
313	pVM->vmm.s.rcCallHost = VERR_INTERNAL_ERROR;
314	int rc = vmmR0CallHostLongJmp(&pVM->vmm.s.CallHostR0JmpBuf, VINF_VMM_CALL_HOST);
315	if (rc == VINF_SUCCESS)
316	rc = pVM->vmm.s.rcCallHost;
317	return rc;
318	}
319
320
321	#ifdef VBOX_WITH_STATISTICS
322	/**
323	* Record return code statistics
324	* @param pVM The VM handle.
325	* @param rc The status code.
326	*/
327	static void vmmR0RecordRC(PVM pVM, int rc)
328	{
329	/*
330	* Collect statistics.
331	*/
332	switch (rc)
333	{
334	case VINF_SUCCESS:
335	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetNormal);
336	break;
337	case VINF_EM_RAW_INTERRUPT:
338	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterrupt);
339	break;
340	case VINF_EM_RAW_INTERRUPT_HYPER:
341	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptHyper);
342	break;
343	case VINF_EM_RAW_GUEST_TRAP:
344	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGuestTrap);
345	break;
346	case VINF_EM_RAW_RING_SWITCH:
347	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitch);
348	break;
349	case VINF_EM_RAW_RING_SWITCH_INT:
350	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitchInt);
351	break;
352	case VINF_EM_RAW_EXCEPTION_PRIVILEGED:
353	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetExceptionPrivilege);
354	break;
355	case VINF_EM_RAW_STALE_SELECTOR:
356	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetStaleSelector);
357	break;
358	case VINF_EM_RAW_IRET_TRAP:
359	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIRETTrap);
360	break;
361	case VINF_IOM_HC_IOPORT_READ:
362	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIORead);
363	break;
364	case VINF_IOM_HC_IOPORT_WRITE:
365	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOWrite);
366	break;
367	case VINF_IOM_HC_MMIO_READ:
368	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIORead);
369	break;
370	case VINF_IOM_HC_MMIO_WRITE:
371	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOWrite);
372	break;
373	case VINF_IOM_HC_MMIO_READ_WRITE:
374	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOReadWrite);
375	break;
376	case VINF_PATM_HC_MMIO_PATCH_READ:
377	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchRead);
378	break;
379	case VINF_PATM_HC_MMIO_PATCH_WRITE:
380	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchWrite);
381	break;
382	case VINF_EM_RAW_EMULATE_INSTR:
383	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetEmulate);
384	break;
385	case VINF_EM_RAW_EMULATE_IO_BLOCK:
386	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOBlockEmulate);
387	break;
388	case VINF_PATCH_EMULATE_INSTR:
389	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchEmulate);
390	break;
391	case VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT:
392	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetLDTFault);
393	break;
394	case VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT:
395	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGDTFault);
396	break;
397	case VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT:
398	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIDTFault);
399	break;
400	case VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT:
401	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTSSFault);
402	break;
403	case VINF_EM_RAW_EMULATE_INSTR_PD_FAULT:
404	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPDFault);
405	break;
406	case VINF_CSAM_PENDING_ACTION:
407	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCSAMTask);
408	break;
409	case VINF_PGM_SYNC_CR3:
410	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetSyncCR3);
411	break;
412	case VINF_PATM_PATCH_INT3:
413	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchInt3);
414	break;
415	case VINF_PATM_PATCH_TRAP_PF:
416	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchPF);
417	break;
418	case VINF_PATM_PATCH_TRAP_GP:
419	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchGP);
420	break;
421	case VINF_PATM_PENDING_IRQ_AFTER_IRET:
422	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchIretIRQ);
423	break;
424	case VERR_REM_FLUSHED_PAGES_OVERFLOW:
425	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPageOverflow);
426	break;
427	case VINF_EM_RESCHEDULE_REM:
428	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRescheduleREM);
429	break;
430	case VINF_EM_RAW_TO_R3:
431	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3);
432	break;
433	case VINF_EM_RAW_TIMER_PENDING:
434	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTimerPending);
435	break;
436	case VINF_EM_RAW_INTERRUPT_PENDING:
437	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptPending);
438	break;
439	case VINF_VMM_CALL_HOST:
440	switch (pVM->vmm.s.enmCallHostOperation)
441	{
442	case VMMCALLHOST_PDM_LOCK:
443	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMLock);
444	break;
445	case VMMCALLHOST_PDM_QUEUE_FLUSH:
446	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMQueueFlush);
447	break;
448	case VMMCALLHOST_PGM_POOL_GROW:
449	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMPoolGrow);
450	break;
451	case VMMCALLHOST_PGM_LOCK:
452	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMLock);
453	break;
454	case VMMCALLHOST_PGM_MAP_CHUNK:
455	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMMapChunk);
456	break;
457	case VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES:
458	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMAllocHandy);
459	break;
460	case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
461	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallRemReplay);
462	break;
463	case VMMCALLHOST_VMM_LOGGER_FLUSH:
464	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallLogFlush);
465	break;
466	case VMMCALLHOST_VM_SET_ERROR:
467	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetError);
468	break;
469	case VMMCALLHOST_VM_SET_RUNTIME_ERROR:
470	STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetRuntimeError);
471	break;
472	case VMMCALLHOST_VM_R0_ASSERTION:
473	default:
474	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCallHost);
475	break;
476	}
477	break;
478	case VINF_PATM_DUPLICATE_FUNCTION:
479	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPATMDuplicateFn);
480	break;
481	case VINF_PGM_CHANGE_MODE:
482	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMChangeMode);
483	break;
484	case VINF_EM_RAW_EMULATE_INSTR_HLT:
485	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetEmulHlt);
486	break;
487	case VINF_EM_PENDING_REQUEST:
488	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPendingRequest);
489	break;
490	default:
491	STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMisc);
492	break;
493	}
494	}
495	#endif /* VBOX_WITH_STATISTICS */
496
497
498	/**
499	* Unused ring-0 entry point that used to be called from the interrupt gate.
500	*
501	* Will be removed one of the next times we do a major SUPDrv version bump.
502	*
503	* @returns VBox status code.
504	* @param pVM The VM to operate on.
505	* @param enmOperation Which operation to execute.
506	* @param pvArg Argument to the operation.
507	* @remarks Assume called with interrupts disabled.
508	*/
509	VMMR0DECL(int) VMMR0EntryInt(PVM pVM, VMMR0OPERATION enmOperation, void *pvArg)
510	{
511	/*
512	* We're returning VERR_NOT_SUPPORT here so we've got something else
513	* than -1 which the interrupt gate glue code might return.
514	*/
515	Log(("operation %#x is not supported\n", enmOperation));
516	return VERR_NOT_SUPPORTED;
517	}
518
519
520	/**
521	* The Ring 0 entry point, called by the fast-ioctl path.
522	*
523	* @param pVM The VM to operate on.
524	* The return code is stored in pVM->vmm.s.iLastGZRc.
525	* @param idCpu VMCPU id.
526	* @param enmOperation Which operation to execute.
527	* @remarks Assume called with interrupts _enabled_.
528	*/
529	VMMR0DECL(void) VMMR0EntryFast(PVM pVM, unsigned idCpu, VMMR0OPERATION enmOperation)
530	{
531	PVMCPU pVCpu = &pVM->aCpus[idCpu];
532
533	if (RT_UNLIKELY(idCpu >= pVM->cCPUs))
534	{
535	pVM->vmm.s.iLastGZRc = VERR_INVALID_PARAMETER;
536	return;
537	}
538
539	switch (enmOperation)
540	{
541	/*
542	* Switch to GC and run guest raw mode code.
543	* Disable interrupts before doing the world switch.
544	*/
545	case VMMR0_DO_RAW_RUN:
546	{
547	/* Safety precaution as hwaccm disables the switcher. */
548	if (RT_LIKELY(!pVM->vmm.s.fSwitcherDisabled))
549	{
550	RTCCUINTREG uFlags = ASMIntDisableFlags();
551	int rc;
552	bool fVTxDisabled;
553
554	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
555	if (RT_UNLIKELY(!PGMGetHyperCR3(pVCpu)))
556	{
557	pVM->vmm.s.iLastGZRc = VERR_PGM_NO_CR3_SHADOW_ROOT;
558	return;
559	}
560	#endif
561
562	/* We might need to disable VT-x if the active switcher turns off paging. */
563	rc = HWACCMR0EnterSwitcher(pVM, &fVTxDisabled);
564	if (RT_FAILURE(rc))
565	{
566	pVM->vmm.s.iLastGZRc = rc;
567	return;
568	}
569
570	TMNotifyStartOfExecution(pVM);
571	rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
572	pVM->vmm.s.iLastGZRc = rc;
573	TMNotifyEndOfExecution(pVM);
574
575	/* Re-enable VT-x if previously turned off. */
576	HWACCMR0LeaveSwitcher(pVM, fVTxDisabled);
577
578	if ( rc == VINF_EM_RAW_INTERRUPT
579	\|\| rc == VINF_EM_RAW_INTERRUPT_HYPER)
580	TRPMR0DispatchHostInterrupt(pVM);
581
582	ASMSetFlags(uFlags);
583
584	#ifdef VBOX_WITH_STATISTICS
585	STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
586	vmmR0RecordRC(pVM, rc);
587	#endif
588	}
589	else
590	{
591	Assert(!pVM->vmm.s.fSwitcherDisabled);
592	pVM->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
593	}
594	break;
595	}
596
597	/*
598	* Run guest code using the available hardware acceleration technology.
599	*
600	* Disable interrupts before we do anything interesting. On Windows we avoid
601	* this by having the support driver raise the IRQL before calling us, this way
602	* we hope to get away with page faults and later calling into the kernel.
603	*/
604	case VMMR0_DO_HWACC_RUN:
605	{
606	int rc;
607	PVMCPU pVCpu = &pVM->aCpus[idCpu];
608
609	STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
610
611	#ifndef RT_OS_WINDOWS /** @todo check other hosts */
612	RTCCUINTREG uFlags = ASMIntDisableFlags();
613	#endif
614	if (!HWACCMR0SuspendPending())
615	{
616	rc = HWACCMR0Enter(pVM, pVCpu);
617	if (RT_SUCCESS(rc))
618	{
619	rc = vmmR0CallHostSetJmp(&pVM->vmm.s.CallHostR0JmpBuf, HWACCMR0RunGuestCode, pVM, pVCpu); /* this may resume code. */
620	int rc2 = HWACCMR0Leave(pVM, pVCpu);
621	AssertRC(rc2);
622	}
623	}
624	else
625	{
626	/* System is about to go into suspend mode; go back to ring 3. */
627	rc = VINF_EM_RAW_INTERRUPT;
628	}
629	pVM->vmm.s.iLastGZRc = rc;
630	#ifndef RT_OS_WINDOWS /** @todo check other hosts */
631	ASMSetFlags(uFlags);
632	#endif
633
634	#ifdef VBOX_WITH_STATISTICS
635	vmmR0RecordRC(pVM, rc);
636	#endif
637	/* No special action required for external interrupts, just return. */
638	break;
639	}
640
641	/*
642	* For profiling.
643	*/
644	case VMMR0_DO_NOP:
645	pVM->vmm.s.iLastGZRc = VINF_SUCCESS;
646	break;
647
648	/*
649	* Impossible.
650	*/
651	default:
652	AssertMsgFailed(("%#x\n", enmOperation));
653	pVM->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
654	break;
655	}
656	}
657
658
659	/**
660	* Validates a session or VM session argument.
661	*
662	* @returns true / false accordingly.
663	* @param pVM The VM argument.
664	* @param pSession The session argument.
665	*/
666	DECLINLINE(bool) vmmR0IsValidSession(PVM pVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
667	{
668	/* This must be set! */
669	if (!pSession)
670	return false;
671
672	/* Only one out of the two. */
673	if (pVM && pClaimedSession)
674	return false;
675	if (pVM)
676	pClaimedSession = pVM->pSession;
677	return pClaimedSession == pSession;
678	}
679
680
681	/**
682	* VMMR0EntryEx worker function, either called directly or when ever possible
683	* called thru a longjmp so we can exit safely on failure.
684	*
685	* @returns VBox status code.
686	* @param pVM The VM to operate on.
687	* @param enmOperation Which operation to execute.
688	* @param pReqHdr This points to a SUPVMMR0REQHDR packet. Optional.
689	* The support driver validates this if it's present.
690	* @param u64Arg Some simple constant argument.
691	* @param pSession The session of the caller.
692	* @remarks Assume called with interrupts _enabled_.
693	*/
694	static int vmmR0EntryExWorker(PVM pVM, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg, PSUPDRVSESSION pSession)
695	{
696	/*
697	* Common VM pointer validation.
698	*/
699	if (pVM)
700	{
701	if (RT_UNLIKELY( !VALID_PTR(pVM)
702	\|\| ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
703	{
704	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p! (op=%d)\n", pVM, enmOperation);
705	return VERR_INVALID_POINTER;
706	}
707	if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
708	\|\| pVM->enmVMState > VMSTATE_TERMINATED
709	\|\| pVM->pVMR0 != pVM))
710	{
711	SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{enmVMState=%d, .pVMR0=%p}! (op=%d)\n",
712	pVM, pVM->enmVMState, pVM->pVMR0, enmOperation);
713	return VERR_INVALID_POINTER;
714	}
715	}
716
717	switch (enmOperation)
718	{
719	/*
720	* GVM requests
721	*/
722	case VMMR0_DO_GVMM_CREATE_VM:
723	if (pVM \|\| u64Arg)
724	return VERR_INVALID_PARAMETER;
725	return GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr);
726
727	case VMMR0_DO_GVMM_DESTROY_VM:
728	if (pReqHdr \|\| u64Arg)
729	return VERR_INVALID_PARAMETER;
730	return GVMMR0DestroyVM(pVM);
731
732	case VMMR0_DO_GVMM_SCHED_HALT:
733	if (pReqHdr)
734	return VERR_INVALID_PARAMETER;
735	return GVMMR0SchedHalt(pVM, u64Arg);
736
737	case VMMR0_DO_GVMM_SCHED_WAKE_UP:
738	if (pReqHdr \|\| u64Arg)
739	return VERR_INVALID_PARAMETER;
740	return GVMMR0SchedWakeUp(pVM);
741
742	case VMMR0_DO_GVMM_SCHED_POLL:
743	if (pReqHdr \|\| u64Arg > 1)
744	return VERR_INVALID_PARAMETER;
745	return GVMMR0SchedPoll(pVM, !!u64Arg);
746
747	case VMMR0_DO_GVMM_QUERY_STATISTICS:
748	if (u64Arg)
749	return VERR_INVALID_PARAMETER;
750	return GVMMR0QueryStatisticsReq(pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr);
751
752	case VMMR0_DO_GVMM_RESET_STATISTICS:
753	if (u64Arg)
754	return VERR_INVALID_PARAMETER;
755	return GVMMR0ResetStatisticsReq(pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr);
756
757	/*
758	* Initialize the R0 part of a VM instance.
759	*/
760	case VMMR0_DO_VMMR0_INIT:
761	return vmmR0InitVM(pVM, (uint32_t)u64Arg);
762
763	/*
764	* Terminate the R0 part of a VM instance.
765	*/
766	case VMMR0_DO_VMMR0_TERM:
767	return VMMR0TermVM(pVM, NULL);
768
769	/*
770	* Attempt to enable hwacc mode and check the current setting.
771	*
772	*/
773	case VMMR0_DO_HWACC_ENABLE:
774	return HWACCMR0EnableAllCpus(pVM);
775
776	/*
777	* Setup the hardware accelerated raw-mode session.
778	*/
779	case VMMR0_DO_HWACC_SETUP_VM:
780	{
781	RTCCUINTREG fFlags = ASMIntDisableFlags();
782	int rc = HWACCMR0SetupVM(pVM);
783	ASMSetFlags(fFlags);
784	return rc;
785	}
786
787	/*
788	* Switch to GC to execute Hypervisor function.
789	*/
790	case VMMR0_DO_CALL_HYPERVISOR:
791	{
792	int rc;
793	bool fVTxDisabled;
794
795	/* Safety precaution as HWACCM can disable the switcher. */
796	Assert(!pVM->vmm.s.fSwitcherDisabled);
797	if (RT_UNLIKELY(pVM->vmm.s.fSwitcherDisabled))
798	return VERR_NOT_SUPPORTED;
799
800	#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
801	if (RT_UNLIKELY(!PGMGetHyperCR3(VMMGetCpu0(pVM))))
802	return VERR_PGM_NO_CR3_SHADOW_ROOT;
803	#endif
804
805	RTCCUINTREG fFlags = ASMIntDisableFlags();
806
807	/* We might need to disable VT-x if the active switcher turns off paging. */
808	rc = HWACCMR0EnterSwitcher(pVM, &fVTxDisabled);
809	if (RT_FAILURE(rc))
810	return rc;
811
812	rc = pVM->vmm.s.pfnHostToGuestR0(pVM);
813
814	/* Re-enable VT-x if previously turned off. */
815	HWACCMR0LeaveSwitcher(pVM, fVTxDisabled);
816
817	/** @todo dispatch interrupts? */
818	ASMSetFlags(fFlags);
819	return rc;
820	}
821
822	/*
823	* PGM wrappers.
824	*/
825	case VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES:
826	return PGMR0PhysAllocateHandyPages(pVM);
827
828	/*
829	* GMM wrappers.
830	*/
831	case VMMR0_DO_GMM_INITIAL_RESERVATION:
832	if (u64Arg)
833	return VERR_INVALID_PARAMETER;
834	return GMMR0InitialReservationReq(pVM, (PGMMINITIALRESERVATIONREQ)pReqHdr);
835	case VMMR0_DO_GMM_UPDATE_RESERVATION:
836	if (u64Arg)
837	return VERR_INVALID_PARAMETER;
838	return GMMR0UpdateReservationReq(pVM, (PGMMUPDATERESERVATIONREQ)pReqHdr);
839
840	case VMMR0_DO_GMM_ALLOCATE_PAGES:
841	if (u64Arg)
842	return VERR_INVALID_PARAMETER;
843	return GMMR0AllocatePagesReq(pVM, (PGMMALLOCATEPAGESREQ)pReqHdr);
844	case VMMR0_DO_GMM_FREE_PAGES:
845	if (u64Arg)
846	return VERR_INVALID_PARAMETER;
847	return GMMR0FreePagesReq(pVM, (PGMMFREEPAGESREQ)pReqHdr);
848	case VMMR0_DO_GMM_BALLOONED_PAGES:
849	if (u64Arg)
850	return VERR_INVALID_PARAMETER;
851	return GMMR0BalloonedPagesReq(pVM, (PGMMBALLOONEDPAGESREQ)pReqHdr);
852	case VMMR0_DO_GMM_DEFLATED_BALLOON:
853	if (pReqHdr)
854	return VERR_INVALID_PARAMETER;
855	return GMMR0DeflatedBalloon(pVM, (uint32_t)u64Arg);
856
857	case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
858	if (u64Arg)
859	return VERR_INVALID_PARAMETER;
860	return GMMR0MapUnmapChunkReq(pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
861	case VMMR0_DO_GMM_SEED_CHUNK:
862	if (pReqHdr)
863	return VERR_INVALID_PARAMETER;
864	return GMMR0SeedChunk(pVM, (RTR3PTR)u64Arg);
865
866	/*
867	* A quick GCFGM mock-up.
868	*/
869	/** @todo GCFGM with proper access control, ring-3 management interface and all that. */
870	case VMMR0_DO_GCFGM_SET_VALUE:
871	case VMMR0_DO_GCFGM_QUERY_VALUE:
872	{
873	if (pVM \|\| !pReqHdr \|\| u64Arg)
874	return VERR_INVALID_PARAMETER;
875	PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
876	if (pReq->Hdr.cbReq != sizeof(*pReq))
877	return VERR_INVALID_PARAMETER;
878	int rc;
879	if (enmOperation == VMMR0_DO_GCFGM_SET_VALUE)
880	{
881	rc = GVMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
882	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
883	// rc = GMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
884	}
885	else
886	{
887	rc = GVMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
888	//if (rc == VERR_CFGM_VALUE_NOT_FOUND)
889	// rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
890	}
891	return rc;
892	}
893
894
895	/*
896	* Requests to the internal networking service.
897	*/
898	case VMMR0_DO_INTNET_OPEN:
899	{
900	PINTNETOPENREQ pReq = (PINTNETOPENREQ)pReqHdr;
901	if (u64Arg \|\| !pReq \|\| !vmmR0IsValidSession(pVM, pReq->pSession, pSession))
902	return VERR_INVALID_PARAMETER;
903	if (!g_pIntNet)
904	return VERR_NOT_SUPPORTED;
905	return INTNETR0OpenReq(g_pIntNet, pSession, pReq);
906	}
907
908	case VMMR0_DO_INTNET_IF_CLOSE:
909	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession))
910	return VERR_INVALID_PARAMETER;
911	if (!g_pIntNet)
912	return VERR_NOT_SUPPORTED;
913	return INTNETR0IfCloseReq(g_pIntNet, pSession, (PINTNETIFCLOSEREQ)pReqHdr);
914
915	case VMMR0_DO_INTNET_IF_GET_RING3_BUFFER:
916	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFGETRING3BUFFERREQ)pReqHdr)->pSession, pSession))
917	return VERR_INVALID_PARAMETER;
918	if (!g_pIntNet)
919	return VERR_NOT_SUPPORTED;
920	return INTNETR0IfGetRing3BufferReq(g_pIntNet, pSession, (PINTNETIFGETRING3BUFFERREQ)pReqHdr);
921
922	case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
923	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession))
924	return VERR_INVALID_PARAMETER;
925	if (!g_pIntNet)
926	return VERR_NOT_SUPPORTED;
927	return INTNETR0IfSetPromiscuousModeReq(g_pIntNet, pSession, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
928
929	case VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS:
930	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession))
931	return VERR_INVALID_PARAMETER;
932	if (!g_pIntNet)
933	return VERR_NOT_SUPPORTED;
934	return INTNETR0IfSetMacAddressReq(g_pIntNet, pSession, (PINTNETIFSETMACADDRESSREQ)pReqHdr);
935
936	case VMMR0_DO_INTNET_IF_SET_ACTIVE:
937	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession))
938	return VERR_INVALID_PARAMETER;
939	if (!g_pIntNet)
940	return VERR_NOT_SUPPORTED;
941	return INTNETR0IfSetActiveReq(g_pIntNet, pSession, (PINTNETIFSETACTIVEREQ)pReqHdr);
942
943	case VMMR0_DO_INTNET_IF_SEND:
944	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession))
945	return VERR_INVALID_PARAMETER;
946	if (!g_pIntNet)
947	return VERR_NOT_SUPPORTED;
948	return INTNETR0IfSendReq(g_pIntNet, pSession, (PINTNETIFSENDREQ)pReqHdr);
949
950	case VMMR0_DO_INTNET_IF_WAIT:
951	if (u64Arg \|\| !pReqHdr \|\| !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession))
952	return VERR_INVALID_PARAMETER;
953	if (!g_pIntNet)
954	return VERR_NOT_SUPPORTED;
955	return INTNETR0IfWaitReq(g_pIntNet, pSession, (PINTNETIFWAITREQ)pReqHdr);
956
957	/*
958	* For profiling.
959	*/
960	case VMMR0_DO_NOP:
961	case VMMR0_DO_SLOW_NOP:
962	return VINF_SUCCESS;
963
964	/*
965	* For testing Ring-0 APIs invoked in this environment.
966	*/
967	case VMMR0_DO_TESTS:
968	/** @todo make new test */
969	return VINF_SUCCESS;
970
971
972	#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
973	case VMMR0_DO_TEST_SWITCHER3264:
974	return HWACCMR0TestSwitcher3264(pVM);
975	#endif
976	default:
977	/*
978	* We're returning VERR_NOT_SUPPORT here so we've got something else
979	* than -1 which the interrupt gate glue code might return.
980	*/
981	Log(("operation %#x is not supported\n", enmOperation));
982	return VERR_NOT_SUPPORTED;
983	}
984	}
985
986
987	/**
988	* Argument for vmmR0EntryExWrapper containing the argument s ofr VMMR0EntryEx.
989	*/
990	typedef struct VMMR0ENTRYEXARGS
991	{
992	PVM pVM;
993	VMMR0OPERATION enmOperation;
994	PSUPVMMR0REQHDR pReq;
995	uint64_t u64Arg;
996	PSUPDRVSESSION pSession;
997	} VMMR0ENTRYEXARGS;
998	/** Pointer to a vmmR0EntryExWrapper argument package. */
999	typedef VMMR0ENTRYEXARGS *PVMMR0ENTRYEXARGS;
1000
1001	/**
1002	* This is just a longjmp wrapper function for VMMR0EntryEx calls.
1003	*
1004	* @returns VBox status code.
1005	* @param pvArgs The argument package
1006	*/
1007	static int vmmR0EntryExWrapper(void *pvArgs)
1008	{
1009	return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
1010	((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
1011	((PVMMR0ENTRYEXARGS)pvArgs)->pReq,
1012	((PVMMR0ENTRYEXARGS)pvArgs)->u64Arg,
1013	((PVMMR0ENTRYEXARGS)pvArgs)->pSession);
1014	}
1015
1016
1017	/**
1018	* The Ring 0 entry point, called by the support library (SUP).
1019	*
1020	* @returns VBox status code.
1021	* @param pVM The VM to operate on.
1022	* @param enmOperation Which operation to execute.
1023	* @param pReq This points to a SUPVMMR0REQHDR packet. Optional.
1024	* @param u64Arg Some simple constant argument.
1025	* @param pSession The session of the caller.
1026	* @remarks Assume called with interrupts _enabled_.
1027	*/
1028	VMMR0DECL(int) VMMR0EntryEx(PVM pVM, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession)
1029	{
1030	/*
1031	* Requests that should only happen on the EMT thread will be
1032	* wrapped in a setjmp so we can assert without causing trouble.
1033	*/
1034	if ( VALID_PTR(pVM)
1035	&& pVM->pVMR0)
1036	{
1037	switch (enmOperation)
1038	{
1039	/* These might/will be called before VMMR3Init. */
1040	case VMMR0_DO_GMM_INITIAL_RESERVATION:
1041	case VMMR0_DO_GMM_UPDATE_RESERVATION:
1042	case VMMR0_DO_GMM_ALLOCATE_PAGES:
1043	case VMMR0_DO_GMM_FREE_PAGES:
1044	case VMMR0_DO_GMM_BALLOONED_PAGES:
1045	case VMMR0_DO_GMM_DEFLATED_BALLOON:
1046	/* On the mac we might not have a valid jmp buf, so check these as well. */
1047	case VMMR0_DO_VMMR0_INIT:
1048	case VMMR0_DO_VMMR0_TERM:
1049	{
1050	if (!pVM->vmm.s.CallHostR0JmpBuf.pvSavedStack)
1051	break;
1052
1053	/** @todo validate this EMT claim... GVM knows. */
1054	VMMR0ENTRYEXARGS Args;
1055	Args.pVM = pVM;
1056	Args.enmOperation = enmOperation;
1057	Args.pReq = pReq;
1058	Args.u64Arg = u64Arg;
1059	Args.pSession = pSession;
1060	return vmmR0CallHostSetJmpEx(&pVM->vmm.s.CallHostR0JmpBuf, vmmR0EntryExWrapper, &Args);
1061	}
1062
1063	default:
1064	break;
1065	}
1066	}
1067	return vmmR0EntryExWorker(pVM, enmOperation, pReq, u64Arg, pSession);
1068	}
1069
1070
1071	/**
1072	* Internal R0 logger worker: Flush logger.
1073	*
1074	* @param pLogger The logger instance to flush.
1075	* @remark This function must be exported!
1076	*/
1077	VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger)
1078	{
1079	/*
1080	* Convert the pLogger into a VM handle and 'call' back to Ring-3.
1081	* (This is a bit paranoid code.)
1082	*/
1083	PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1084	if ( !VALID_PTR(pR0Logger)
1085	\|\| !VALID_PTR(pR0Logger + 1)
1086	\|\| pLogger->u32Magic != RTLOGGER_MAGIC)
1087	{
1088	#ifdef DEBUG
1089	SUPR0Printf("vmmR0LoggerFlush: pLogger=%p!\n", pLogger);
1090	#endif
1091	return;
1092	}
1093	if (pR0Logger->fFlushingDisabled)
1094	return; /* quietly */
1095
1096	PVM pVM = pR0Logger->pVM;
1097	if ( !VALID_PTR(pVM)
1098	\|\| pVM->pVMR0 != pVM)
1099	{
1100	#ifdef DEBUG
1101	SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
1102	#endif
1103	return;
1104	}
1105
1106	/*
1107	* Check that the jump buffer is armed.
1108	*/
1109	#ifdef RT_ARCH_X86
1110	if ( !pVM->vmm.s.CallHostR0JmpBuf.eip
1111	\|\| pVM->vmm.s.CallHostR0JmpBuf.fInRing3Call)
1112	#else
1113	if ( !pVM->vmm.s.CallHostR0JmpBuf.rip
1114	\|\| pVM->vmm.s.CallHostR0JmpBuf.fInRing3Call)
1115	#endif
1116	{
1117	#ifdef DEBUG
1118	SUPR0Printf("vmmR0LoggerFlush: Jump buffer isn't armed!\n");
1119	#endif
1120	return;
1121	}
1122	VMMR0CallHost(pVM, VMMCALLHOST_VMM_LOGGER_FLUSH, 0);
1123	}
1124
1125
1126	/**
1127	* Disables flushing of the ring-0 debug log.
1128	*
1129	* @param pVCpu The shared virtual cpu structure.
1130	*/
1131	VMMR0DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu)
1132	{
1133	PVM pVM = pVCpu->pVMR0;
1134	if (pVM->vmm.s.pR0LoggerR0)
1135	pVM->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
1136	}
1137
1138
1139	/**
1140	* Enables flushing of the ring-0 debug log.
1141	*
1142	* @param pVCpu The shared virtual cpu structure.
1143	*/
1144	VMMR0DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu)
1145	{
1146	PVM pVM = pVCpu->pVMR0;
1147	if (pVM->vmm.s.pR0LoggerR0)
1148	pVM->vmm.s.pR0LoggerR0->fFlushingDisabled = false;
1149	}
1150
1151
1152	/**
1153	* Jump back to ring-3 if we're the EMT and the longjmp is armed.
1154	*
1155	* @returns true if the breakpoint should be hit, false if it should be ignored.
1156	*/
1157	DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void)
1158	{
1159	#if 0
1160	return true;
1161	#else
1162	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1163	if (pVM)
1164	{
1165	#ifdef RT_ARCH_X86
1166	if ( pVM->vmm.s.CallHostR0JmpBuf.eip
1167	&& !pVM->vmm.s.CallHostR0JmpBuf.fInRing3Call)
1168	#else
1169	if ( pVM->vmm.s.CallHostR0JmpBuf.rip
1170	&& !pVM->vmm.s.CallHostR0JmpBuf.fInRing3Call)
1171	#endif
1172	{
1173	int rc = VMMR0CallHost(pVM, VMMCALLHOST_VM_R0_ASSERTION, 0);
1174	return RT_FAILURE_NP(rc);
1175	}
1176	}
1177	#ifdef RT_OS_LINUX
1178	return true;
1179	#else
1180	return false;
1181	#endif
1182	#endif
1183	}
1184
1185
1186	/**
1187	* Override this so we can push it up to ring-3.
1188	*
1189	* @param pszExpr Expression. Can be NULL.
1190	* @param uLine Location line number.
1191	* @param pszFile Location file name.
1192	* @param pszFunction Location function name.
1193	*/
1194	DECLEXPORT(void) RTCALL AssertMsg1(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction)
1195	{
1196	#if !defined(DEBUG_sandervl) && !defined(RT_OS_DARWIN)
1197	SUPR0Printf("\n!!R0-Assertion Failed!!\n"
1198	"Expression: %s\n"
1199	"Location : %s(%d) %s\n",
1200	pszExpr, pszFile, uLine, pszFunction);
1201	#endif
1202	LogAlways(("\n!!R0-Assertion Failed!!\n"
1203	"Expression: %s\n"
1204	"Location : %s(%d) %s\n",
1205	pszExpr, pszFile, uLine, pszFunction));
1206
1207	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1208	if (pVM)
1209	RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
1210	"\n!!R0-Assertion Failed!!\n"
1211	"Expression: %s\n"
1212	"Location : %s(%d) %s\n",
1213	pszExpr, pszFile, uLine, pszFunction);
1214	#ifdef RT_OS_DARWIN
1215	RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
1216	#endif
1217	}
1218
1219
1220	/**
1221	* Callback for RTLogFormatV which writes to the ring-3 log port.
1222	* See PFNLOGOUTPUT() for details.
1223	*/
1224	static DECLCALLBACK(size_t) rtLogOutput(void pv, const char pachChars, size_t cbChars)
1225	{
1226	for (size_t i = 0; i < cbChars; i++)
1227	{
1228	#if !defined(DEBUG_sandervl) && !defined(RT_OS_DARWIN)
1229	SUPR0Printf("%c", pachChars[i]);
1230	#endif
1231	LogAlways(("%c", pachChars[i]));
1232	}
1233
1234	return cbChars;
1235	}
1236
1237
1238	DECLEXPORT(void) RTCALL AssertMsg2(const char *pszFormat, ...)
1239	{
1240	va_list va;
1241
1242	PRTLOGGER pLog = RTLogDefaultInstance(); /** @todo we want this for release as well! */
1243	if (pLog)
1244	{
1245	va_start(va, pszFormat);
1246	RTLogFormatV(rtLogOutput, pLog, pszFormat, va);
1247	va_end(va);
1248
1249	PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1250	if (pVM)
1251	{
1252	va_start(va, pszFormat);
1253	RTStrPrintfV(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2), pszFormat, va);
1254	va_end(va);
1255	}
1256	}
1257
1258	#ifdef RT_OS_DARWIN
1259	va_start(va, pszFormat);
1260	RTAssertMsg2V(pszFormat, va);
1261	va_end(va);
1262	#endif
1263	}
1264

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

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

Download in other formats: