VM.cpp@ 4372

Last change on this file since 4372 was 4296, checked in by vboxsync, 18 years ago
vmR3SetState must accessible of course.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 84.0 KB

Line
1	/* $Id: VM.cpp 4296 2007-08-22 20:23:31Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_VM
23	#include <VBox/cfgm.h>
24	#include <VBox/vmm.h>
25	#include <VBox/mm.h>
26	#include <VBox/cpum.h>
27	#include <VBox/selm.h>
28	#include <VBox/trpm.h>
29	#include <VBox/dbgf.h>
30	#include <VBox/pgm.h>
31	#include <VBox/pdmapi.h>
32	#include <VBox/pdmcritsect.h>
33	#include <VBox/em.h>
34	#include <VBox/rem.h>
35	#include <VBox/tm.h>
36	#include <VBox/stam.h>
37	#include <VBox/patm.h>
38	#include <VBox/csam.h>
39	#include <VBox/iom.h>
40	#include <VBox/ssm.h>
41	#include <VBox/hwaccm.h>
42	#include "VMInternal.h"
43	#include <VBox/vm.h>
44
45	#include <VBox/sup.h>
46	#include <VBox/dbg.h>
47	#include <VBox/err.h>
48	#include <VBox/param.h>
49	#include <VBox/log.h>
50	#include <iprt/assert.h>
51	#include <iprt/alloc.h>
52	#include <iprt/asm.h>
53	#include <iprt/string.h>
54	#include <iprt/time.h>
55	#include <iprt/semaphore.h>
56	#include <iprt/thread.h>
57
58	#include <stdlib.h> /* getenv */
59
60
61	/*******************************************************************************
62	* Structures and Typedefs *
63	*******************************************************************************/
64	/**
65	* VM destruction callback registration record.
66	*/
67	typedef struct VMATDTOR
68	{
69	/** Pointer to the next record in the list. */
70	struct VMATDTOR *pNext;
71	/** Pointer to the callback function. */
72	PFNVMATDTOR pfnAtDtor;
73	/** The user argument. */
74	void *pvUser;
75	} VMATDTOR;
76	/** Pointer to a VM destruction callback registration record. */
77	typedef VMATDTOR *PVMATDTOR;
78
79
80	/*******************************************************************************
81	* Global Variables *
82	*******************************************************************************/
83	/** Pointer to the list of VMs. */
84	static PVM g_pVMsHead;
85
86	/** Pointer to the list of at VM destruction callbacks. */
87	static PVMATDTOR g_pVMAtDtorHead;
88	/** Lock the g_pVMAtDtorHead list. */
89	#define VM_ATDTOR_LOCK() do { } while (0)
90	/** Unlock the g_pVMAtDtorHead list. */
91	#define VM_ATDTOR_UNLOCK() do { } while (0)
92
93	/*******************************************************************************
94	* Internal Functions *
95	*******************************************************************************/
96	static int vmR3Create(PVM pVM, PFNVMATERROR pfnVMAtError, void pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void pvUserCFGM);
97	static void vmR3CallVMAtError(PFNVMATERROR pfnVMAtError, void pvUser, int rc, RT_SRC_POS_DECL, const char pszError, ...);
98	static int vmR3InitRing3(PVM pVM);
99	static int vmR3InitRing0(PVM pVM);
100	static int vmR3InitGC(PVM pVM);
101	static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat);
102	static DECLCALLBACK(int) vmR3PowerOn(PVM pVM);
103	static DECLCALLBACK(int) vmR3Suspend(PVM pVM);
104	static DECLCALLBACK(int) vmR3Resume(PVM pVM);
105	static DECLCALLBACK(int) vmR3Save(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser);
106	static DECLCALLBACK(int) vmR3Load(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser);
107	static DECLCALLBACK(int) vmR3PowerOff(PVM pVM);
108	static void vmR3AtDtor(PVM pVM);
109	static int vmR3AtReset(PVM pVM);
110	static DECLCALLBACK(int) vmR3Reset(PVM pVM);
111	static DECLCALLBACK(int) vmR3AtStateRegister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser);
112	static DECLCALLBACK(int) vmR3AtStateDeregister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser);
113	static DECLCALLBACK(int) vmR3AtErrorRegister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser);
114	static DECLCALLBACK(int) vmR3AtErrorDeregister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser);
115	static DECLCALLBACK(int) vmR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser);
116	static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser);
117
118
119	/**
120	* Do global VMM init.
121	*
122	* @returns VBox status code.
123	*/
124	VMR3DECL(int) VMR3GlobalInit(void)
125	{
126	/*
127	* Only once.
128	*/
129	static bool fDone = false;
130	if (fDone)
131	return VINF_SUCCESS;
132
133	/*
134	* We're done.
135	*/
136	fDone = true;
137	return VINF_SUCCESS;
138	}
139
140
141
142	/**
143	* Creates a virtual machine by calling the supplied configuration constructor.
144	*
145	* On successful returned the VM is powered, i.e. VMR3PowerOn() should be
146	* called to start the execution.
147	*
148	* @returns 0 on success.
149	* @returns VBox error code on failure.
150	* @param pfnVMAtError Pointer to callback function for setting VM errors.
151	* This is called in the EM.
152	* @param pvUserVM The user argument passed to pfnVMAtError.
153	* @param pfnCFGMConstructor Pointer to callback function for constructing the VM configuration tree.
154	* This is called in the EM.
155	* @param pvUserCFGM The user argument passed to pfnCFGMConstructor.
156	* @param ppVM Where to store the 'handle' of the created VM.
157	*/
158	VMR3DECL(int) VMR3Create(PFNVMATERROR pfnVMAtError, void pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void pvUserCFGM, PVM *ppVM)
159	{
160	LogFlow(("VMR3Create: pfnVMAtError=%p pvUserVM=%p pfnCFGMConstructor=%p pvUserCFGM=%p ppVM=%p\n", pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM, ppVM));
161
162	/*
163	* Because of the current hackiness of the applications
164	* we'll have to initialize global stuff from here.
165	* Later the applications will take care of this in a proper way.
166	*/
167	static bool fGlobalInitDone = false;
168	if (!fGlobalInitDone)
169	{
170	int rc = VMR3GlobalInit();
171	if (VBOX_FAILURE(rc))
172	return rc;
173	fGlobalInitDone = true;
174	}
175
176	/*
177	* Init support library.
178	*/
179	PSUPDRVSESSION pSession = 0;
180	int rc = SUPInit(&pSession, 0);
181	if (VBOX_SUCCESS(rc))
182	{
183	/*
184	* Allocate memory for the VM structure.
185	*/
186	PVMR0 pVMR0 = NIL_RTR0PTR;
187	PVM pVM = NULL;
188	const unsigned cPages = RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE) >> PAGE_SHIFT;
189	PSUPPAGE paPages = (PSUPPAGE)RTMemAllocZ(cPages * sizeof(SUPPAGE));
190	AssertReturn(paPages, VERR_NO_MEMORY);
191	rc = SUPLowAlloc(cPages, (void **)&pVM, &pVMR0, &paPages[0]);
192	if (VBOX_SUCCESS(rc))
193	{
194	Log(("VMR3Create: Allocated pVM=%p pVMR0=%p\n", pVM, pVMR0));
195
196	/*
197	* Do basic init of the VM structure.
198	*/
199	memset(pVM, 0, sizeof(*pVM));
200	pVM->pVMHC = pVM;
201	pVM->pVMR0 = pVMR0;
202	pVM->pVMR3 = pVM;
203	pVM->paVMPagesR3 = paPages;
204	pVM->pSession = pSession;
205	pVM->vm.s.offVM = RT_OFFSETOF(VM, vm.s);
206	pVM->vm.s.ppAtResetNext = &pVM->vm.s.pAtReset;
207	pVM->vm.s.ppAtStateNext = &pVM->vm.s.pAtState;
208	pVM->vm.s.ppAtErrorNext = &pVM->vm.s.pAtError;
209	pVM->vm.s.ppAtRuntimeErrorNext = &pVM->vm.s.pAtRuntimeError;
210	rc = RTSemEventCreate(&pVM->vm.s.EventSemWait);
211	AssertRCReturn(rc, rc);
212
213	/*
214	* Initialize STAM.
215	*/
216	rc = STAMR3Init(pVM);
217	if (VBOX_SUCCESS(rc))
218	{
219	/*
220	* Create the EMT thread and make it do VM initialization and go sleep
221	* in EM waiting for requests.
222	*/
223	VMEMULATIONTHREADARGS Args;
224	Args.pVM = pVM;
225	rc = RTThreadCreate(&pVM->ThreadEMT, &vmR3EmulationThread, &Args, _1M,
226	RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "EMT");
227	if (VBOX_SUCCESS(rc))
228	{
229	/*
230	* Issue a VM Create request and wait for it to complete.
231	*/
232	PVMREQ pReq;
233	rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Create, 5, pVM, pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM);
234	if (VBOX_SUCCESS(rc))
235	{
236	rc = pReq->iStatus;
237	VMR3ReqFree(pReq);
238	if (VBOX_SUCCESS(rc))
239	{
240	*ppVM = pVM;
241	LogFlow(("VMR3Create: returns VINF_SUCCESS *ppVM=%p\n", pVM));
242	return VINF_SUCCESS;
243	}
244	AssertMsgFailed(("vmR3Create failed rc=%Vrc\n", rc));
245	}
246	else
247	AssertMsgFailed(("VMR3ReqCall failed rc=%Vrc\n", rc));
248
249	const char *pszError;
250	/*
251	* An error occurred during VM creation. Set the error message directly
252	* using the initial callback, as the callback list doesn't exist yet.
253	*/
254	switch (rc)
255	{
256	case VERR_VMX_IN_VMX_ROOT_MODE:
257	#ifdef RT_OS_LINUX
258	pszError = N_("VirtualBox can't operate in VMX root mode. "
259	"Please disable the KVM kernel extension, recompile "
260	"your kernel and reboot");
261	#else
262	pszError = N_("VirtualBox can't operate in VMX root mode");
263	#endif
264	break;
265	default:
266	pszError = N_("Unknown error creating VM (%Vrc)");
267	AssertMsgFailed(("Add error message for rc=%d (%Vrc)\n", rc, rc));
268	}
269	vmR3CallVMAtError(pfnVMAtError, pvUserVM, rc, RT_SRC_POS, pszError, rc);
270
271	/* Forcefully terminate the emulation thread. */
272	VM_FF_SET(pVM, VM_FF_TERMINATE);
273	VMR3NotifyFF(pVM, false);
274	RTThreadWait(pVM->ThreadEMT, 1000, NULL);
275	}
276
277	int rc2 = STAMR3Term(pVM);
278	AssertRC(rc2);
279	}
280
281	/* cleanup the heap. */
282	int rc2 = MMR3Term(pVM);
283	AssertRC(rc2);
284
285	/* free the VM memory */
286	rc2 = SUPLowFree(pVM, cPages);
287	AssertRC(rc2);
288	}
289	else
290	{
291	rc = VERR_NO_MEMORY;
292	vmR3CallVMAtError(pfnVMAtError, pvUserVM, rc, RT_SRC_POS,
293	N_("Failed to allocate %d bytes of low memory for the VM structure"),
294	RT_ALIGN(sizeof(*pVM), PAGE_SIZE));
295	AssertMsgFailed(("Failed to allocate %d bytes of low memory for the VM structure!\n", RT_ALIGN(sizeof(*pVM), PAGE_SIZE)));
296	}
297	RTMemFree(paPages);
298
299	/* terminate SUPLib */
300	int rc2 = SUPTerm(false);
301	AssertRC(rc2);
302	}
303	else
304	{
305	const char *pszError;
306	/*
307	* An error occurred at support library initialization time (before the
308	* VM could be created). Set the error message directly using the
309	* initial callback, as the callback list doesn't exist yet.
310	*/
311	switch (rc)
312	{
313	case VERR_VM_DRIVER_LOAD_ERROR:
314	#ifdef RT_OS_LINUX
315	pszError = N_("VirtualBox kernel driver not loaded. The vboxdrv kernel module "
316	"was either not loaded or /dev/vboxdrv is not set up properly. "
317	"Re-setup the kernel module by executing "
318	"'/etc/init.d/vboxdrv setup' as root");
319	#else
320	pszError = N_("VirtualBox kernel driver not loaded.");
321	#endif
322	break;
323	case VERR_VM_DRIVER_OPEN_ERROR:
324	pszError = N_("VirtualBox kernel driver cannot be opened");
325	break;
326	case VERR_VM_DRIVER_NOT_ACCESSIBLE:
327	#ifdef RT_OS_LINUX
328	pszError = N_("The VirtualBox kernel driver is not accessible to the current "
329	"user. Make sure that the user has write permissions for "
330	"/dev/vboxdrv by adding them to the vboxusers groups. You "
331	"will need to logout for the change to take effect.");
332	#else
333	pszError = N_("VirtualBox kernel driver not accessible, permission problem");
334	#endif
335	break;
336	case VERR_VM_DRIVER_NOT_INSTALLED:
337	#ifdef RT_OS_LINUX
338	pszError = N_("VirtualBox kernel driver not installed. The vboxdrv kernel module "
339	"was either not loaded or /dev/vboxdrv was not created for some "
340	"reason. Re-setup the kernel module by executing "
341	"'/etc/init.d/vboxdrv setup' as root");
342	#else
343	pszError = N_("VirtualBox kernel driver not installed");
344	#endif
345	break;
346	case VERR_NO_MEMORY:
347	pszError = N_("VirtualBox support library out of memory");
348	break;
349	case VERR_VERSION_MISMATCH:
350	pszError = N_("The VirtualBox support driver which is running is from a different "
351	"version of VirtualBox. You can correct this by stopping all "
352	"running instances of VirtualBox and reinstalling the software.");
353	break;
354	default:
355	pszError = N_("Unknown error initializing kernel driver (%Vrc)");
356	AssertMsgFailed(("Add error message for rc=%d (%Vrc)\n", rc, rc));
357	}
358	vmR3CallVMAtError(pfnVMAtError, pvUserVM, rc, RT_SRC_POS, pszError, rc);
359	}
360
361	LogFlow(("VMR3Create: returns %Vrc\n", rc));
362	return rc;
363	}
364
365
366	/**
367	* Wrapper for getting a correct va_list.
368	*/
369	static void vmR3CallVMAtError(PFNVMATERROR pfnVMAtError, void pvUser, int rc, RT_SRC_POS_DECL, const char pszError, ...)
370	{
371	va_list va;
372	va_start(va, pszError);
373	pfnVMAtError(NULL, pvUser, rc, RT_SRC_POS_ARGS, pszError, va);
374	va_end(va);
375	}
376
377
378	/**
379	* Initializes the VM.
380	*/
381	static int vmR3Create(PVM pVM, PFNVMATERROR pfnVMAtError, void pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void pvUserCFGM)
382	{
383	int rc = VINF_SUCCESS;
384
385	/* Register error callback if specified. */
386	if (pfnVMAtError)
387	rc = VMR3AtErrorRegister(pVM, pfnVMAtError, pvUserVM);
388	if (VBOX_SUCCESS(rc))
389	{
390	/*
391	* Init the configuration.
392	*/
393	rc = CFGMR3Init(pVM, pfnCFGMConstructor, pvUserCFGM);
394	if (VBOX_SUCCESS(rc))
395	{
396	/*
397	* If executing in fake suplib mode disable RR3 and RR0 in the config.
398	*/
399	const char *psz = getenv("VBOX_SUPLIB_FAKE");
400	if (psz && !strcmp(psz, "fake"))
401	{
402	CFGMR3RemoveValue(CFGMR3GetRoot(pVM), "RawR3Enabled");
403	CFGMR3InsertInteger(CFGMR3GetRoot(pVM), "RawR3Enabled", 0);
404	CFGMR3RemoveValue(CFGMR3GetRoot(pVM), "RawR0Enabled");
405	CFGMR3InsertInteger(CFGMR3GetRoot(pVM), "RawR0Enabled", 0);
406	}
407
408	/*
409	* Check if the required minimum of resources are available.
410	*/
411	/** @todo Check if the required minimum of resources are available. */
412	if (VBOX_SUCCESS(rc))
413	{
414	/*
415	* Init the Ring-3 components and do a round of relocations with 0 delta.
416	*/
417	rc = vmR3InitRing3(pVM);
418	if (VBOX_SUCCESS(rc))
419	{
420	VMR3Relocate(pVM, 0);
421	LogFlow(("Ring-3 init succeeded\n"));
422
423	/*
424	* Init the Ring-0 components.
425	*/
426	rc = vmR3InitRing0(pVM);
427	if (VBOX_SUCCESS(rc))
428	{
429	/* Relocate again, because some switcher fixups depends on R0 init results. */
430	VMR3Relocate(pVM, 0);
431
432	/*
433	* Init the tcp debugger console if we're building
434	* with debugger support.
435	*/
436	void *pvUser = NULL;
437	rc = DBGCTcpCreate(pVM, &pvUser);
438	if ( VBOX_SUCCESS(rc)
439	\|\| rc == VERR_NET_ADDRESS_IN_USE)
440	{
441	pVM->vm.s.pvDBGC = pvUser;
442
443	/*
444	* Init the Guest Context components.
445	*/
446	rc = vmR3InitGC(pVM);
447	if (VBOX_SUCCESS(rc))
448	{
449	/*
450	* Set the state and link into the global list.
451	*/
452	vmR3SetState(pVM, VMSTATE_CREATED);
453	pVM->pNext = g_pVMsHead;
454	g_pVMsHead = pVM;
455	return VINF_SUCCESS;
456	}
457	DBGCTcpTerminate(pVM, pVM->vm.s.pvDBGC);
458	pVM->vm.s.pvDBGC = NULL;
459	}
460	//..
461	}
462	vmR3Destroy(pVM);
463	}
464	//..
465	}
466
467	/* Clean CFGM. */
468	int rc2 = CFGMR3Term(pVM);
469	AssertRC(rc2);
470	}
471	//..
472	}
473
474	LogFlow(("vmR3Create: returns %Vrc\n", rc));
475	return rc;
476	}
477
478
479
480	/**
481	* Initializes all R3 components of the VM
482	*/
483	static int vmR3InitRing3(PVM pVM)
484	{
485	int rc;
486
487	/*
488	* Init all R3 components, the order here might be important.
489	*/
490	rc = vmR3SetHaltMethod(pVM, VMHALTMETHOD_DEFAULT);
491	AssertRCReturn(rc, rc);
492
493	rc = MMR3Init(pVM);
494	if (VBOX_SUCCESS(rc))
495	{
496	STAM_REG(pVM, &pVM->StatTotalInGC, STAMTYPE_PROFILE_ADV, "/PROF/VM/InGC", STAMUNIT_TICKS_PER_CALL, "Profiling the total time spent in GC.");
497	STAM_REG(pVM, &pVM->StatSwitcherToGC, STAMTYPE_PROFILE_ADV, "/PROF/VM/SwitchToGC", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
498	STAM_REG(pVM, &pVM->StatSwitcherToHC, STAMTYPE_PROFILE_ADV, "/PROF/VM/SwitchToHC", STAMUNIT_TICKS_PER_CALL, "Profiling switching to HC.");
499
500	STAM_REL_REG(pVM, &pVM->vm.s.StatHaltYield, STAMTYPE_PROFILE, "/PROF/VM/Halt/Yield", STAMUNIT_TICKS_PER_CALL, "Profiling halted state yielding.");
501	STAM_REL_REG(pVM, &pVM->vm.s.StatHaltBlock, STAMTYPE_PROFILE, "/PROF/VM/Halt/Block", STAMUNIT_TICKS_PER_CALL, "Profiling halted state blocking.");
502	STAM_REL_REG(pVM, &pVM->vm.s.StatHaltTimers,STAMTYPE_PROFILE, "/PROF/VM/Halt/Timers", STAMUNIT_TICKS_PER_CALL, "Profiling halted state timer tasks.");
503	STAM_REL_REG(pVM, &pVM->vm.s.StatHaltPoll, STAMTYPE_PROFILE, "/PROF/VM/Halt/Poll", STAMUNIT_TICKS_PER_CALL, "Profiling halted state poll tasks.");
504
505	STAM_REG(pVM, &pVM->StatSwitcherSaveRegs, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/SaveRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
506	STAM_REG(pVM, &pVM->StatSwitcherSysEnter, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/SysEnter", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
507	STAM_REG(pVM, &pVM->StatSwitcherDebug, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Debug", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
508	STAM_REG(pVM, &pVM->StatSwitcherCR0, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/CR0", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
509	STAM_REG(pVM, &pVM->StatSwitcherCR4, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/CR4", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
510	STAM_REG(pVM, &pVM->StatSwitcherLgdt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lgdt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
511	STAM_REG(pVM, &pVM->StatSwitcherLidt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lidt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
512	STAM_REG(pVM, &pVM->StatSwitcherLldt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lldt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
513	STAM_REG(pVM, &pVM->StatSwitcherTSS, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/TSS", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
514	STAM_REG(pVM, &pVM->StatSwitcherJmpCR3, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/JmpCR3", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
515	STAM_REG(pVM, &pVM->StatSwitcherRstrRegs, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/RstrRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
516
517	STAM_REG(pVM, &pVM->vm.s.StatReqAllocNew, STAMTYPE_COUNTER, "/VM/Req/AllocNew", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a new packet.");
518	STAM_REG(pVM, &pVM->vm.s.StatReqAllocRaces, STAMTYPE_COUNTER, "/VM/Req/AllocRaces", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc causing races.");
519	STAM_REG(pVM, &pVM->vm.s.StatReqAllocRecycled, STAMTYPE_COUNTER, "/VM/Req/AllocRecycled", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a recycled packet.");
520	STAM_REG(pVM, &pVM->vm.s.StatReqFree, STAMTYPE_COUNTER, "/VM/Req/Free", STAMUNIT_OCCURENCES, "Number of VMR3ReqFree calls.");
521	STAM_REG(pVM, &pVM->vm.s.StatReqFreeOverflow, STAMTYPE_COUNTER, "/VM/Req/FreeOverflow", STAMUNIT_OCCURENCES, "Number of times the request was actually freed.");
522
523	rc = CPUMR3Init(pVM);
524	if (VBOX_SUCCESS(rc))
525	{
526	rc = HWACCMR3Init(pVM);
527	if (VBOX_SUCCESS(rc))
528	{
529	rc = PGMR3Init(pVM);
530	if (VBOX_SUCCESS(rc))
531	{
532	rc = REMR3Init(pVM);
533	if (VBOX_SUCCESS(rc))
534	{
535	rc = MMR3InitPaging(pVM);
536	if (VBOX_SUCCESS(rc))
537	rc = TMR3Init(pVM);
538	if (VBOX_SUCCESS(rc))
539	{
540	rc = VMMR3Init(pVM);
541	if (VBOX_SUCCESS(rc))
542	{
543	rc = SELMR3Init(pVM);
544	if (VBOX_SUCCESS(rc))
545	{
546	rc = TRPMR3Init(pVM);
547	if (VBOX_SUCCESS(rc))
548	{
549	rc = CSAMR3Init(pVM);
550	if (VBOX_SUCCESS(rc))
551	{
552	rc = PATMR3Init(pVM);
553	if (VBOX_SUCCESS(rc))
554	{
555	rc = IOMR3Init(pVM);
556	if (VBOX_SUCCESS(rc))
557	{
558	rc = EMR3Init(pVM);
559	if (VBOX_SUCCESS(rc))
560	{
561	rc = DBGFR3Init(pVM);
562	if (VBOX_SUCCESS(rc))
563	{
564	rc = PDMR3Init(pVM);
565	if (VBOX_SUCCESS(rc))
566	{
567	rc = PGMR3InitDynMap(pVM);
568	if (VBOX_SUCCESS(rc))
569	rc = MMR3HyperInitFinalize(pVM);
570	if (VBOX_SUCCESS(rc))
571	rc = PATMR3InitFinalize(pVM);
572	if (VBOX_SUCCESS(rc))
573	rc = PGMR3InitFinalize(pVM);
574	if (VBOX_SUCCESS(rc))
575	rc = SELMR3InitFinalize(pVM);
576	if (VBOX_SUCCESS(rc))
577	rc = VMMR3InitFinalize(pVM);
578	if (VBOX_SUCCESS(rc))
579	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING3);
580	if (VBOX_SUCCESS(rc))
581	{
582	LogFlow(("vmR3InitRing3: returns %Vrc\n", VINF_SUCCESS));
583	return VINF_SUCCESS;
584	}
585	int rc2 = PDMR3Term(pVM);
586	AssertRC(rc2);
587	}
588	int rc2 = DBGFR3Term(pVM);
589	AssertRC(rc2);
590	}
591	int rc2 = EMR3Term(pVM);
592	AssertRC(rc2);
593	}
594	int rc2 = IOMR3Term(pVM);
595	AssertRC(rc2);
596	}
597	int rc2 = PATMR3Term(pVM);
598	AssertRC(rc2);
599	}
600	int rc2 = CSAMR3Term(pVM);
601	AssertRC(rc2);
602	}
603	int rc2 = TRPMR3Term(pVM);
604	AssertRC(rc2);
605	}
606	int rc2 = SELMR3Term(pVM);
607	AssertRC(rc2);
608	}
609	int rc2 = VMMR3Term(pVM);
610	AssertRC(rc2);
611	}
612	int rc2 = TMR3Term(pVM);
613	AssertRC(rc2);
614	}
615	int rc2 = REMR3Term(pVM);
616	AssertRC(rc2);
617	}
618	int rc2 = PGMR3Term(pVM);
619	AssertRC(rc2);
620	}
621	int rc2 = HWACCMR3Term(pVM);
622	AssertRC(rc2);
623	}
624	//int rc2 = CPUMR3Term(pVM);
625	//AssertRC(rc2);
626	}
627	/* MMR3Term is not called here because it'll kill the heap. */
628	}
629
630	LogFlow(("vmR3InitRing3: returns %Vrc\n", rc));
631	return rc;
632	}
633
634
635	/**
636	* Initializes all R0 components of the VM
637	*/
638	static int vmR3InitRing0(PVM pVM)
639	{
640	LogFlow(("vmR3InitRing0:\n"));
641
642	/*
643	* Check for FAKE suplib mode.
644	*/
645	int rc = VINF_SUCCESS;
646	const char *psz = getenv("VBOX_SUPLIB_FAKE");
647	if (!psz \|\| strcmp(psz, "fake"))
648	{
649	/*
650	* Call the VMMR0 component and let it do the init.
651	*/
652	rc = VMMR3InitR0(pVM);
653	}
654	else
655	Log(("vmR3InitRing0: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
656
657	/*
658	* Do notifications and return.
659	*/
660	if (VBOX_SUCCESS(rc))
661	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING0);
662	LogFlow(("vmR3InitRing0: returns %Vrc\n", rc));
663	return rc;
664	}
665
666
667	/**
668	* Initializes all GC components of the VM
669	*/
670	static int vmR3InitGC(PVM pVM)
671	{
672	LogFlow(("vmR3InitGC:\n"));
673
674	/*
675	* Check for FAKE suplib mode.
676	*/
677	int rc = VINF_SUCCESS;
678	const char *psz = getenv("VBOX_SUPLIB_FAKE");
679	if (!psz \|\| strcmp(psz, "fake"))
680	{
681	/*
682	* Call the VMMR0 component and let it do the init.
683	*/
684	rc = VMMR3InitGC(pVM);
685	}
686	else
687	Log(("vmR3InitGC: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
688
689	/*
690	* Do notifications and return.
691	*/
692	if (VBOX_SUCCESS(rc))
693	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_GC);
694	LogFlow(("vmR3InitGC: returns %Vrc\n", rc));
695	return rc;
696	}
697
698
699	/**
700	* Do init completed notifications.
701	* This notifications can fail.
702	*
703	* @param pVM The VM handle.
704	* @param enmWhat What's completed.
705	*/
706	static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat)
707	{
708
709	return VINF_SUCCESS;
710	}
711
712
713	/**
714	* Calls the relocation functions for all VMM components so they can update
715	* any GC pointers. When this function is called all the basic VM members
716	* have been updated and the actual memory relocation have been done
717	* by the PGM/MM.
718	*
719	* This is used both on init and on runtime relocations.
720	*
721	* @param pVM VM handle.
722	* @param offDelta Relocation delta relative to old location.
723	*/
724	VMR3DECL(void) VMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
725	{
726	LogFlow(("VMR3Relocate: offDelta=%VGv\n", offDelta));
727
728	/*
729	* The order here is very important!
730	*/
731	PGMR3Relocate(pVM, offDelta);
732	PDMR3LdrRelocate(pVM, offDelta);
733	PGMR3Relocate(pVM, 0); /* Repeat after PDM relocation. */
734	CPUMR3Relocate(pVM);
735	HWACCMR3Relocate(pVM);
736	SELMR3Relocate(pVM);
737	VMMR3Relocate(pVM, offDelta);
738	SELMR3Relocate(pVM); /* !hack! fix stack! */
739	TRPMR3Relocate(pVM, offDelta);
740	PATMR3Relocate(pVM);
741	CSAMR3Relocate(pVM, offDelta);
742	IOMR3Relocate(pVM, offDelta);
743	EMR3Relocate(pVM);
744	TMR3Relocate(pVM, offDelta);
745	DBGFR3Relocate(pVM, offDelta);
746	PDMR3Relocate(pVM, offDelta);
747	}
748
749
750
751	/**
752	* Power on the virtual machine.
753	*
754	* @returns 0 on success.
755	* @returns VBox error code on failure.
756	* @param pVM VM to power on.
757	* @thread Any thread.
758	* @vmstate Created
759	* @vmstateto Running
760	*/
761	VMR3DECL(int) VMR3PowerOn(PVM pVM)
762	{
763	LogFlow(("VMR3PowerOn: pVM=%p\n", pVM));
764
765	/*
766	* Validate input.
767	*/
768	if (!pVM)
769	{
770	AssertMsgFailed(("Invalid VM pointer\n"));
771	return VERR_INVALID_PARAMETER;
772	}
773
774	/*
775	* Request the operation in EMT.
776	*/
777	PVMREQ pReq;
778	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOn, 1, pVM);
779	if (VBOX_SUCCESS(rc))
780	{
781	rc = pReq->iStatus;
782	VMR3ReqFree(pReq);
783	}
784
785	LogFlow(("VMR3PowerOn: returns %Vrc\n", rc));
786	return rc;
787	}
788
789
790	/**
791	* Power on the virtual machine.
792	*
793	* @returns 0 on success.
794	* @returns VBox error code on failure.
795	* @param pVM VM to power on.
796	* @thread EMT
797	*/
798	static DECLCALLBACK(int) vmR3PowerOn(PVM pVM)
799	{
800	LogFlow(("vmR3PowerOn: pVM=%p\n", pVM));
801
802	/*
803	* Validate input.
804	*/
805	if (pVM->enmVMState != VMSTATE_CREATED)
806	{
807	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
808	return VERR_VM_INVALID_VM_STATE;
809	}
810
811	/*
812	* Change the state, notify the components and resume the execution.
813	*/
814	vmR3SetState(pVM, VMSTATE_RUNNING);
815	PDMR3PowerOn(pVM);
816
817	return VINF_SUCCESS;
818	}
819
820
821	/**
822	* Suspends a running VM.
823	*
824	* @returns 0 on success.
825	* @returns VBox error code on failure.
826	* @param pVM VM to suspend.
827	* @thread Any thread.
828	* @vmstate Running
829	* @vmstateto Suspended
830	*/
831	VMR3DECL(int) VMR3Suspend(PVM pVM)
832	{
833	LogFlow(("VMR3Suspend: pVM=%p\n", pVM));
834
835	/*
836	* Validate input.
837	*/
838	if (!pVM)
839	{
840	AssertMsgFailed(("Invalid VM pointer\n"));
841	return VERR_INVALID_PARAMETER;
842	}
843
844	/*
845	* Request the operation in EMT.
846	*/
847	PVMREQ pReq;
848	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Suspend, 1, pVM);
849	if (VBOX_SUCCESS(rc))
850	{
851	rc = pReq->iStatus;
852	VMR3ReqFree(pReq);
853	}
854
855	LogFlow(("VMR3Suspend: returns %Vrc\n", rc));
856	return rc;
857	}
858
859
860	/**
861	* Suspends a running VM and prevent state saving until the VM is resumed or stopped.
862	*
863	* @returns 0 on success.
864	* @returns VBox error code on failure.
865	* @param pVM VM to suspend.
866	* @thread Any thread.
867	* @vmstate Running
868	* @vmstateto Suspended
869	*/
870	VMR3DECL(int) VMR3SuspendNoSave(PVM pVM)
871	{
872	pVM->vm.s.fPreventSaveState = true;
873	return VMR3Suspend(pVM);
874	}
875
876	/**
877	* Suspends a running VM.
878	*
879	* @returns 0 on success.
880	* @returns VBox error code on failure.
881	* @param pVM VM to suspend.
882	* @thread EMT
883	*/
884	static DECLCALLBACK(int) vmR3Suspend(PVM pVM)
885	{
886	LogFlow(("vmR3Suspend: pVM=%p\n", pVM));
887
888	/*
889	* Validate input.
890	*/
891	if (pVM->enmVMState != VMSTATE_RUNNING)
892	{
893	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
894	return VERR_VM_INVALID_VM_STATE;
895	}
896
897	/*
898	* Change the state, notify the components and resume the execution.
899	*/
900	vmR3SetState(pVM, VMSTATE_SUSPENDED);
901	PDMR3Suspend(pVM);
902
903	return VINF_EM_SUSPEND;
904	}
905
906
907	/**
908	* Resume VM execution.
909	*
910	* @returns 0 on success.
911	* @returns VBox error code on failure.
912	* @param pVM The VM to resume.
913	* @thread Any thread.
914	* @vmstate Suspended
915	* @vmstateto Running
916	*/
917	VMR3DECL(int) VMR3Resume(PVM pVM)
918	{
919	LogFlow(("VMR3Resume: pVM=%p\n", pVM));
920
921	/*
922	* Validate input.
923	*/
924	if (!pVM)
925	{
926	AssertMsgFailed(("Invalid VM pointer\n"));
927	return VERR_INVALID_PARAMETER;
928	}
929
930	/*
931	* Request the operation in EMT.
932	*/
933	PVMREQ pReq;
934	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Resume, 1, pVM);
935	if (VBOX_SUCCESS(rc))
936	{
937	rc = pReq->iStatus;
938	VMR3ReqFree(pReq);
939	}
940
941	LogFlow(("VMR3Resume: returns %Vrc\n", rc));
942	return rc;
943	}
944
945
946	/**
947	* Resume VM execution.
948	*
949	* @returns 0 on success.
950	* @returns VBox error code on failure.
951	* @param pVM The VM to resume.
952	* @thread EMT
953	*/
954	static DECLCALLBACK(int) vmR3Resume(PVM pVM)
955	{
956	LogFlow(("vmR3Resume: pVM=%p\n", pVM));
957
958	/*
959	* Validate input.
960	*/
961	if (pVM->enmVMState != VMSTATE_SUSPENDED)
962	{
963	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
964	return VERR_VM_INVALID_VM_STATE;
965	}
966
967	/*
968	* Change the state, notify the components and resume the execution.
969	*/
970	pVM->vm.s.fPreventSaveState = false;
971	vmR3SetState(pVM, VMSTATE_RUNNING);
972	PDMR3Resume(pVM);
973
974	return VINF_EM_RESUME;
975	}
976
977
978	/**
979	* Save current VM state.
980	*
981	* To save and terminate the VM, the VM must be suspended before the call.
982	*
983	* @returns 0 on success.
984	* @returns VBox error code on failure.
985	* @param pVM VM which state should be saved.
986	* @param pszFilename Name of the save state file.
987	* @param pfnProgress Progress callback. Optional.
988	* @param pvUser User argument for the progress callback.
989	* @thread Any thread.
990	* @vmstate Suspended
991	* @vmstateto Unchanged state.
992	*/
993	VMR3DECL(int) VMR3Save(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
994	{
995	LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
996
997	/*
998	* Validate input.
999	*/
1000	if (!pVM)
1001	{
1002	AssertMsgFailed(("Invalid VM pointer\n"));
1003	return VERR_INVALID_PARAMETER;
1004	}
1005	if (!pszFilename)
1006	{
1007	AssertMsgFailed(("Must specify a filename to save the state to, wise guy!\n"));
1008	return VERR_INVALID_PARAMETER;
1009	}
1010
1011	/*
1012	* Request the operation in EMT.
1013	*/
1014	PVMREQ pReq;
1015	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Save, 4, pVM, pszFilename, pfnProgress, pvUser);
1016	if (VBOX_SUCCESS(rc))
1017	{
1018	rc = pReq->iStatus;
1019	VMR3ReqFree(pReq);
1020	}
1021
1022	LogFlow(("VMR3Save: returns %Vrc\n", rc));
1023	return rc;
1024	}
1025
1026
1027	/**
1028	* Save current VM state.
1029	*
1030	* To save and terminate the VM, the VM must be suspended before the call.
1031	*
1032	* @returns 0 on success.
1033	* @returns VBox error code on failure.
1034	* @param pVM VM which state should be saved.
1035	* @param pszFilename Name of the save state file.
1036	* @param pfnProgress Progress callback. Optional.
1037	* @param pvUser User argument for the progress callback.
1038	* @thread EMT
1039	*/
1040	static DECLCALLBACK(int) vmR3Save(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
1041	{
1042	LogFlow(("vmR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1043
1044	/*
1045	* Validate input.
1046	*/
1047	if (pVM->enmVMState != VMSTATE_SUSPENDED)
1048	{
1049	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1050	return VERR_VM_INVALID_VM_STATE;
1051	}
1052
1053	/* If we are in an inconsistent state, then we don't allow state saving. */
1054	if (pVM->vm.s.fPreventSaveState)
1055	{
1056	LogRel(("VMM: vmR3Save: saving the VM state is not allowed at this moment\n"));
1057	return VERR_VM_SAVE_STATE_NOT_ALLOWED;
1058	}
1059
1060	/*
1061	* Change the state and perform the save.
1062	*/
1063	/** @todo implement progress support in SSM */
1064	vmR3SetState(pVM, VMSTATE_SAVING);
1065	int rc = SSMR3Save(pVM, pszFilename, SSMAFTER_CONTINUE, pfnProgress, pvUser);
1066	vmR3SetState(pVM, VMSTATE_SUSPENDED);
1067
1068	return rc;
1069	}
1070
1071
1072	/**
1073	* Loads a new VM state.
1074	*
1075	* To restore a saved state on VM startup, call this function and then
1076	* resume the VM instead of powering it on.
1077	*
1078	* @returns 0 on success.
1079	* @returns VBox error code on failure.
1080	* @param pVM VM which state should be saved.
1081	* @param pszFilename Name of the save state file.
1082	* @param pfnProgress Progress callback. Optional.
1083	* @param pvUser User argument for the progress callback.
1084	* @thread Any thread.
1085	* @vmstate Created, Suspended
1086	* @vmstateto Suspended
1087	*/
1088	VMR3DECL(int) VMR3Load(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
1089	{
1090	LogFlow(("VMR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1091
1092	/*
1093	* Validate input.
1094	*/
1095	if (!pVM)
1096	{
1097	AssertMsgFailed(("Invalid VM pointer\n"));
1098	return VERR_INVALID_PARAMETER;
1099	}
1100	if (!pszFilename)
1101	{
1102	AssertMsgFailed(("Must specify a filename to load the state from, wise guy!\n"));
1103	return VERR_INVALID_PARAMETER;
1104	}
1105
1106	/*
1107	* Request the operation in EMT.
1108	*/
1109	PVMREQ pReq;
1110	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
1111	if (VBOX_SUCCESS(rc))
1112	{
1113	rc = pReq->iStatus;
1114	VMR3ReqFree(pReq);
1115	}
1116
1117	LogFlow(("VMR3Load: returns %Vrc\n", rc));
1118	return rc;
1119	}
1120
1121
1122	/**
1123	* Loads a new VM state.
1124	*
1125	* To restore a saved state on VM startup, call this function and then
1126	* resume the VM instead of powering it on.
1127	*
1128	* @returns 0 on success.
1129	* @returns VBox error code on failure.
1130	* @param pVM VM which state should be saved.
1131	* @param pszFilename Name of the save state file.
1132	* @param pfnProgress Progress callback. Optional.
1133	* @param pvUser User argument for the progress callback.
1134	* @thread EMT.
1135	*/
1136	static DECLCALLBACK(int) vmR3Load(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
1137	{
1138	LogFlow(("vmR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1139
1140	/*
1141	* Validate input.
1142	*/
1143	if ( pVM->enmVMState != VMSTATE_SUSPENDED
1144	&& pVM->enmVMState != VMSTATE_CREATED)
1145	{
1146	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1147	return VMSetError(pVM, VERR_VM_INVALID_VM_STATE, RT_SRC_POS, N_("Invalid VM state (%s) for restoring state from '%s'"),
1148	VMR3GetStateName(pVM->enmVMState), pszFilename);
1149	}
1150
1151	/*
1152	* Change the state and perform the load.
1153	*/
1154	vmR3SetState(pVM, VMSTATE_LOADING);
1155	int rc = SSMR3Load(pVM, pszFilename, SSMAFTER_RESUME, pfnProgress, pvUser);
1156	if (VBOX_SUCCESS(rc))
1157	{
1158	/* Not paranoia anymore; the saved guest might use different hypervisor selectors. We must call VMR3Relocate. */
1159	VMR3Relocate(pVM, 0);
1160	vmR3SetState(pVM, VMSTATE_SUSPENDED);
1161	}
1162	else
1163	{
1164	vmR3SetState(pVM, VMSTATE_LOAD_FAILURE);
1165	rc = VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to restore VM state from '%s' (%Vrc)"), pszFilename, rc);
1166	}
1167
1168	return rc;
1169	}
1170
1171
1172	/**
1173	* Power Off the VM.
1174	*
1175	* @returns 0 on success.
1176	* @returns VBox error code on failure.
1177	* @param pVM VM which should be destroyed.
1178	* @thread Any thread.
1179	* @vmstate Suspended, Running, Guru Mediation, Load Failure
1180	* @vmstateto Off
1181	*/
1182	VMR3DECL(int) VMR3PowerOff(PVM pVM)
1183	{
1184	LogFlow(("VMR3PowerOff: pVM=%p\n", pVM));
1185
1186	/*
1187	* Validate input.
1188	*/
1189	if (!pVM)
1190	{
1191	AssertMsgFailed(("Invalid VM pointer\n"));
1192	return VERR_INVALID_PARAMETER;
1193	}
1194
1195	/*
1196	* Request the operation in EMT.
1197	*/
1198	PVMREQ pReq;
1199	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOff, 1, pVM);
1200	if (VBOX_SUCCESS(rc))
1201	{
1202	rc = pReq->iStatus;
1203	VMR3ReqFree(pReq);
1204	}
1205
1206	LogFlow(("VMR3PowerOff: returns %Vrc\n", rc));
1207	return rc;
1208	}
1209
1210
1211	/**
1212	* Power Off the VM.
1213	*
1214	* @returns 0 on success.
1215	* @returns VBox error code on failure.
1216	* @param pVM VM which should be destroyed.
1217	* @thread EMT.
1218	*/
1219	static DECLCALLBACK(int) vmR3PowerOff(PVM pVM)
1220	{
1221	LogFlow(("vmR3PowerOff: pVM=%p\n", pVM));
1222
1223	/*
1224	* Validate input.
1225	*/
1226	if ( pVM->enmVMState != VMSTATE_RUNNING
1227	&& pVM->enmVMState != VMSTATE_SUSPENDED
1228	&& pVM->enmVMState != VMSTATE_LOAD_FAILURE
1229	&& pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1230	{
1231	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1232	return VERR_VM_INVALID_VM_STATE;
1233	}
1234
1235	/*
1236	* For debugging purposes, we will log a summary of the guest state at this point.
1237	*/
1238	if (pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1239	{
1240	/** @todo make the state dumping at VMR3PowerOff optional. */
1241	RTLogRelPrintf("**************** Guest state at power off ****************\n");
1242	DBGFR3Info(pVM, "cpumguest", "verbose", DBGFR3InfoLogRelHlp());
1243	RTLogRelPrintf("***\n");
1244	DBGFR3Info(pVM, "mode", NULL, DBGFR3InfoLogRelHlp());
1245	RTLogRelPrintf("***\n");
1246	DBGFR3Info(pVM, "activetimers", NULL, DBGFR3InfoLogRelHlp());
1247	RTLogRelPrintf("***\n");
1248	DBGFR3Info(pVM, "gdt", NULL, DBGFR3InfoLogRelHlp());
1249	/** @todo dump guest call stack. */
1250	#if 1 // temporary while debugging #1589
1251	RTLogRelPrintf("***\n");
1252	uint32_t esp = CPUMGetGuestESP(pVM);
1253	if ( CPUMGetGuestSS(pVM) == 0
1254	&& esp < _64K)
1255	{
1256	RTLogRelPrintf("***\n"
1257	"ss:sp=0000:%04x ", esp);
1258	void *pv;
1259	int rc = PGMPhysGCPtr2HCPtr(pVM, esp, &pv);
1260	if (VBOX_SUCCESS(rc))
1261	{
1262	const uint8_t pb = (uint8_t )((uintptr_t)pv & ~(uintptr_t)0x3f);
1263	RTLogRelPrintf("pb=%p pv=%p\n"
1264	"%.*Rhxd\n", pb, pv,
1265	PAGE_SIZE - ((uintptr_t)pb & PAGE_OFFSET_MASK), pb);
1266	}
1267	else
1268	RTLogRelPrintf("rc=%Vrc\n", rc);
1269	/* grub ... */
1270	if (esp < 0x2000 && esp > 0x1fc0)
1271	{
1272	int rc = PGMPhysGCPtr2HCPtr(pVM, 0x8000, &pv);
1273	if (VBOX_SUCCESS(rc))
1274	RTLogRelPrintf("0000:8000 TO 0000:87ff: pv=%p\n"
1275	"%.*Rhxd\n", pv, 0x8000, pv);
1276	}
1277	/* microsoft cdrom hang ... */
1278	if (true)
1279	{
1280	int rc = PGMPhysGCPtr2HCPtr(pVM, 0x20000, &pv);
1281	if (VBOX_SUCCESS(rc))
1282	RTLogRelPrintf("2000:0000 TO 2000:01ff: pv=%p\n"
1283	"%.*Rhxd\n", pv, 0x200, pv);
1284	}
1285	}
1286	#endif
1287	RTLogRelPrintf("************ End of Guest state at power off *************\n");
1288	}
1289
1290	/*
1291	* Change the state to OFF and notify the components.
1292	*/
1293	vmR3SetState(pVM, VMSTATE_OFF);
1294	PDMR3PowerOff(pVM);
1295
1296	return VINF_EM_OFF;
1297	}
1298
1299
1300	/**
1301	* Destroys the VM.
1302	* The VM must be powered off (or never really powered on) to call this function.
1303	* The VM handle is destroyed and can no longer be used up successful return.
1304	*
1305	* @returns 0 on success.
1306	* @returns VBox error code on failure.
1307	* @param pVM VM which should be destroyed.
1308	* @thread Any thread but the emulation thread.
1309	* @vmstate Off, Created
1310	* @vmstateto N/A
1311	*/
1312	VMR3DECL(int) VMR3Destroy(PVM pVM)
1313	{
1314	LogFlow(("VMR3Destroy: pVM=%p\n", pVM));
1315
1316	/*
1317	* Validate input.
1318	*/
1319	if (!pVM)
1320	return VERR_INVALID_PARAMETER;
1321	if ( pVM->enmVMState != VMSTATE_OFF
1322	&& pVM->enmVMState != VMSTATE_CREATED)
1323	{
1324	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1325	return VERR_VM_INVALID_VM_STATE;
1326	}
1327
1328	/*
1329	* Unlink the VM and change it's state to destroying.
1330	*/
1331	/** @todo lock this when we start having multiple machines in a process... */
1332	PVM pPrev = NULL;
1333	PVM pCur = g_pVMsHead;
1334	while (pCur && pCur != pVM)
1335	{
1336	pPrev = pCur;
1337	pCur = pCur->pNext;
1338	}
1339	if (!pCur)
1340	{
1341	AssertMsgFailed(("pVM=%p is INVALID!\n", pVM));
1342	return VERR_INVALID_PARAMETER;
1343	}
1344	if (pPrev)
1345	pPrev->pNext = pCur->pNext;
1346	else
1347	g_pVMsHead = pCur->pNext;
1348
1349	vmR3SetState(pVM, VMSTATE_DESTROYING);
1350
1351
1352	/*
1353	* Notify registered at destruction listeners.
1354	* (That's the debugger console.)
1355	*/
1356	vmR3AtDtor(pVM);
1357
1358	pVM->pNext = g_pVMsHead;
1359	g_pVMsHead = pVM;
1360
1361	/*
1362	* If we are the EMT we'll delay the cleanup till later.
1363	*/
1364	if (VM_IS_EMT(pVM))
1365	{
1366	pVM->vm.s.fEMTDoesTheCleanup = true;
1367	VM_FF_SET(pVM, VM_FF_TERMINATE);
1368	}
1369	else
1370	{
1371	/*
1372	* Request EMT to do the larger part of the destruction.
1373	*/
1374	PVMREQ pReq = NULL;
1375	int rc = VMR3ReqCall(pVM, &pReq, 0, (PFNRT)vmR3Destroy, 1, pVM);
1376	while (rc == VERR_TIMEOUT)
1377	rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
1378	if (VBOX_SUCCESS(rc))
1379	rc = pReq->iStatus;
1380	VMR3ReqFree(pReq);
1381
1382	/*
1383	* Wait for the EMT thread to terminate.
1384	*/
1385	VM_FF_SET(pVM, VM_FF_TERMINATE);
1386	uint64_t u64Start = RTTimeMilliTS();
1387	do
1388	{
1389	VMR3NotifyFF(pVM, false);
1390	rc = RTThreadWait(pVM->ThreadEMT, 1000, NULL);
1391	} while ( RTTimeMilliTS() - u64Start < 30000 /* 30 sec */
1392	&& rc == VERR_TIMEOUT);
1393	AssertMsgRC(rc, ("EMT thread wait failed, rc=%Vrc\n", rc));
1394
1395	/*
1396	* Now do the final bit where the heap and VM structures are freed up.
1397	*/
1398	vmR3DestroyFinalBit(pVM);
1399	}
1400
1401	LogFlow(("VMR3Destroy: returns VINF_SUCCESS\n"));
1402	return VINF_SUCCESS;
1403	}
1404
1405
1406	/**
1407	* Internal destruction worker. This will do nearly all of the
1408	* job, including quitting the emulation thread.
1409	*
1410	* @returns VBox status.
1411	* @param pVM VM handle.
1412	*/
1413	DECLCALLBACK(int) vmR3Destroy(PVM pVM)
1414	{
1415	LogFlow(("vmR3Destroy: pVM=%p\n", pVM));
1416	VM_ASSERT_EMT(pVM);
1417
1418	/*
1419	* Dump statistics to the log.
1420	*/
1421	#if defined(VBOX_WITH_STATISTICS) \|\| defined(LOG_ENABLED)
1422	RTLogFlags(NULL, "nodisabled nobuffered");
1423	#endif
1424	#ifdef VBOX_WITH_STATISTICS
1425	STAMR3Dump(pVM, "*");
1426	#else
1427	LogRel(("*********************** Statistics ***********************\n"));
1428	STAMR3DumpToReleaseLog(pVM, "*");
1429	LogRel(("******************* End of statistics ********************\n"));
1430	#endif
1431
1432	/*
1433	* Destroy the VM components.
1434	*/
1435	int rc = TMR3Term(pVM);
1436	AssertRC(rc);
1437	rc = DBGCTcpTerminate(pVM, pVM->vm.s.pvDBGC);
1438	pVM->vm.s.pvDBGC = NULL;
1439	AssertRC(rc);
1440	rc = DBGFR3Term(pVM);
1441	AssertRC(rc);
1442	rc = PDMR3Term(pVM);
1443	AssertRC(rc);
1444	rc = EMR3Term(pVM);
1445	AssertRC(rc);
1446	rc = IOMR3Term(pVM);
1447	AssertRC(rc);
1448	rc = CSAMR3Term(pVM);
1449	AssertRC(rc);
1450	rc = PATMR3Term(pVM);
1451	AssertRC(rc);
1452	rc = TRPMR3Term(pVM);
1453	AssertRC(rc);
1454	rc = SELMR3Term(pVM);
1455	AssertRC(rc);
1456	rc = REMR3Term(pVM);
1457	AssertRC(rc);
1458	rc = HWACCMR3Term(pVM);
1459	AssertRC(rc);
1460	rc = VMMR3Term(pVM);
1461	AssertRC(rc);
1462	rc = PGMR3Term(pVM);
1463	AssertRC(rc);
1464	rc = CPUMR3Term(pVM);
1465	AssertRC(rc);
1466	rc = STAMR3Term(pVM);
1467	AssertRC(rc);
1468	rc = PDMR3CritSectTerm(pVM);
1469	AssertRC(rc);
1470	/* MM is destroyed later in vmR3DestroyFinalBit() for heap reasons. */
1471
1472	/*
1473	* We're done in this thread.
1474	*/
1475	pVM->fForcedActions = VM_FF_TERMINATE;
1476	LogFlow(("vmR3Destroy: returning %Vrc\n", VINF_EM_TERMINATE));
1477	return VINF_EM_TERMINATE;
1478	}
1479
1480
1481	/**
1482	* Does the final part of the VM destruction.
1483	* This is called by EMT in it's final stage or by the VMR3Destroy caller.
1484	*
1485	* @param pVM VM Handle.
1486	*/
1487	void vmR3DestroyFinalBit(PVM pVM)
1488	{
1489	/*
1490	* Free the event semaphores associated with the request packets.s
1491	*/
1492	unsigned cReqs = 0;
1493	for (unsigned i = 0; i < ELEMENTS(pVM->vm.s.apReqFree); i++)
1494	{
1495	PVMREQ pReq = pVM->vm.s.apReqFree[i];
1496	pVM->vm.s.apReqFree[i] = NULL;
1497	for (; pReq; pReq = pReq->pNext, cReqs++)
1498	{
1499	pReq->enmState = VMREQSTATE_INVALID;
1500	RTSemEventDestroy(pReq->EventSem);
1501	}
1502	}
1503	Assert(cReqs == pVM->vm.s.cReqFree); NOREF(cReqs);
1504
1505	/*
1506	* Kill all queued requests. (There really shouldn't be any!)
1507	*/
1508	for (unsigned i = 0; i < 10; i++)
1509	{
1510	PVMREQ pReqHead = (PVMREQ)ASMAtomicXchgPtr((void volatile )&pVM->vm.s.pReqs, NULL);
1511	AssertMsg(!pReqHead, ("This isn't supposed to happen! VMR3Destroy caller has to serialize this.\n"));
1512	if (!pReqHead)
1513	break;
1514	for (PVMREQ pReq = pReqHead; pReq; pReq = pReq->pNext)
1515	{
1516	ASMAtomicXchgSize(&pReq->iStatus, VERR_INTERNAL_ERROR);
1517	ASMAtomicXchgSize(&pReq->enmState, VMREQSTATE_INVALID);
1518	RTSemEventSignal(pReq->EventSem);
1519	RTThreadSleep(2);
1520	RTSemEventDestroy(pReq->EventSem);
1521	}
1522	/* give them a chance to respond before we free the request memory. */
1523	RTThreadSleep(32);
1524	}
1525
1526	/*
1527	* Modify state and then terminate MM.
1528	* (MM must be delayed until this point so we don't destroy the callbacks and the request packet.)
1529	*/
1530	vmR3SetState(pVM, VMSTATE_TERMINATED);
1531	int rc = MMR3Term(pVM);
1532	AssertRC(rc);
1533
1534	/*
1535	* Free the VM structure.
1536	*/
1537	rc = SUPLowFree(pVM, RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE) >> PAGE_SHIFT);
1538	AssertRC(rc);
1539	rc = SUPTerm();
1540	AssertRC(rc);
1541
1542	RTLogFlush(NULL);
1543	}
1544
1545
1546	/**
1547	* Enumerates the VMs in this process.
1548	*
1549	* @returns Pointer to the next VM.
1550	* @returns NULL when no more VMs.
1551	* @param pVMPrev The previous VM
1552	* Use NULL to start the enumeration.
1553	*/
1554	VMR3DECL(PVM) VMR3EnumVMs(PVM pVMPrev)
1555	{
1556	/*
1557	* This is quick and dirty. It has issues with VM being
1558	* destroyed during the enumeration.
1559	*/
1560	if (pVMPrev)
1561	return pVMPrev->pNext;
1562	return g_pVMsHead;
1563	}
1564
1565
1566	/**
1567	* Registers an at VM destruction callback.
1568	*
1569	* @returns VBox status code.
1570	* @param pfnAtDtor Pointer to callback.
1571	* @param pvUser User argument.
1572	*/
1573	VMR3DECL(int) VMR3AtDtorRegister(PFNVMATDTOR pfnAtDtor, void *pvUser)
1574	{
1575	/*
1576	* Check if already registered.
1577	*/
1578	VM_ATDTOR_LOCK();
1579	PVMATDTOR pCur = g_pVMAtDtorHead;
1580	while (pCur)
1581	{
1582	if (pfnAtDtor == pCur->pfnAtDtor)
1583	{
1584	VM_ATDTOR_UNLOCK();
1585	AssertMsgFailed(("Already registered at destruction callback %p!\n", pfnAtDtor));
1586	return VERR_INVALID_PARAMETER;
1587	}
1588
1589	/* next */
1590	pCur = pCur->pNext;
1591	}
1592	VM_ATDTOR_UNLOCK();
1593
1594	/*
1595	* Allocate new entry.
1596	*/
1597	PVMATDTOR pVMAtDtor = (PVMATDTOR)RTMemAlloc(sizeof(*pVMAtDtor));
1598	if (!pVMAtDtor)
1599	return VERR_NO_MEMORY;
1600
1601	VM_ATDTOR_LOCK();
1602	pVMAtDtor->pfnAtDtor = pfnAtDtor;
1603	pVMAtDtor->pvUser = pvUser;
1604	pVMAtDtor->pNext = g_pVMAtDtorHead;
1605	g_pVMAtDtorHead = pVMAtDtor;
1606	VM_ATDTOR_UNLOCK();
1607
1608	return VINF_SUCCESS;
1609	}
1610
1611
1612	/**
1613	* Deregisters an at VM destruction callback.
1614	*
1615	* @returns VBox status code.
1616	* @param pfnAtDtor Pointer to callback.
1617	*/
1618	VMR3DECL(int) VMR3AtDtorDeregister(PFNVMATDTOR pfnAtDtor)
1619	{
1620	/*
1621	* Find it, unlink it and free it.
1622	*/
1623	VM_ATDTOR_LOCK();
1624	PVMATDTOR pPrev = NULL;
1625	PVMATDTOR pCur = g_pVMAtDtorHead;
1626	while (pCur)
1627	{
1628	if (pfnAtDtor == pCur->pfnAtDtor)
1629	{
1630	if (pPrev)
1631	pPrev->pNext = pCur->pNext;
1632	else
1633	g_pVMAtDtorHead = pCur->pNext;
1634	pCur->pNext = NULL;
1635	VM_ATDTOR_UNLOCK();
1636
1637	RTMemFree(pCur);
1638	return VINF_SUCCESS;
1639	}
1640
1641	/* next */
1642	pPrev = pCur;
1643	pCur = pCur->pNext;
1644	}
1645	VM_ATDTOR_UNLOCK();
1646
1647	return VERR_INVALID_PARAMETER;
1648	}
1649
1650
1651	/**
1652	* Walks the list of at VM destructor callbacks.
1653	* @param pVM The VM which is about to be destroyed.
1654	*/
1655	static void vmR3AtDtor(PVM pVM)
1656	{
1657	/*
1658	* Find it, unlink it and free it.
1659	*/
1660	VM_ATDTOR_LOCK();
1661	for (PVMATDTOR pCur = g_pVMAtDtorHead; pCur; pCur = pCur->pNext)
1662	pCur->pfnAtDtor(pVM, pCur->pvUser);
1663	VM_ATDTOR_UNLOCK();
1664	}
1665
1666
1667	/**
1668	* Reset the current VM.
1669	*
1670	* @returns VBox status code.
1671	* @param pVM VM to reset.
1672	*/
1673	VMR3DECL(int) VMR3Reset(PVM pVM)
1674	{
1675	int rc = VINF_SUCCESS;
1676
1677	/*
1678	* Check the state.
1679	*/
1680	if (!pVM)
1681	return VERR_INVALID_PARAMETER;
1682	if ( pVM->enmVMState != VMSTATE_RUNNING
1683	&& pVM->enmVMState != VMSTATE_SUSPENDED)
1684	{
1685	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1686	return VERR_VM_INVALID_VM_STATE;
1687	}
1688
1689	/*
1690	* Queue reset request to the emulation thread
1691	* and wait for it to be processed.
1692	*/
1693	PVMREQ pReq = NULL;
1694	rc = VMR3ReqCall(pVM, &pReq, 0, (PFNRT)vmR3Reset, 1, pVM);
1695	while (rc == VERR_TIMEOUT)
1696	rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
1697	if (VBOX_SUCCESS(rc))
1698	rc = pReq->iStatus;
1699	VMR3ReqFree(pReq);
1700
1701	return rc;
1702	}
1703
1704
1705	/**
1706	* Worker which checks integrity of some internal structures.
1707	* This is yet another attempt to track down that AVL tree crash.
1708	*/
1709	static void vmR3CheckIntegrity(PVM pVM)
1710	{
1711	#ifdef VBOX_STRICT
1712	int rc = PGMR3CheckIntegrity(pVM);
1713	AssertReleaseRC(rc);
1714	#endif
1715	}
1716
1717
1718	/**
1719	* Reset request processor.
1720	*
1721	* This is called by the emulation thread as a response to the
1722	* reset request issued by VMR3Reset().
1723	*
1724	* @returns VBox status code.
1725	* @param pVM VM to reset.
1726	*/
1727	static DECLCALLBACK(int) vmR3Reset(PVM pVM)
1728	{
1729	/*
1730	* As a safety precaution we temporarily change the state while resetting.
1731	* (If VMR3Reset was not called from EMT we might have change state... let's ignore that fact for now.)
1732	*/
1733	VMSTATE enmVMState = pVM->enmVMState;
1734	Assert(enmVMState == VMSTATE_SUSPENDED \|\| enmVMState == VMSTATE_RUNNING);
1735	vmR3SetState(pVM, VMSTATE_RESETTING);
1736	vmR3CheckIntegrity(pVM);
1737
1738
1739	/*
1740	* Reset the VM components.
1741	*/
1742	PATMR3Reset(pVM);
1743	CSAMR3Reset(pVM);
1744	PGMR3Reset(pVM); /* We clear VM RAM in PGMR3Reset. It's vital PDMR3Reset is executed
1745	* _afterwards_. E.g. ACPI sets up RAM tables during init/reset. */
1746	PDMR3Reset(pVM);
1747	SELMR3Reset(pVM);
1748	TRPMR3Reset(pVM);
1749	vmR3AtReset(pVM);
1750	REMR3Reset(pVM);
1751	IOMR3Reset(pVM);
1752	CPUMR3Reset(pVM);
1753	TMR3Reset(pVM);
1754	EMR3Reset(pVM);
1755	HWACCMR3Reset(pVM); /* This must come after PATM, CSAM, CPUM, SELM and TRPM. */
1756
1757	#ifdef LOG_ENABLED
1758	/*
1759	* Debug logging.
1760	*/
1761	RTLogPrintf("\n\nThe VM was reset:\n");
1762	DBGFR3Info(pVM, "cpum", "verbose", NULL);
1763	#endif
1764
1765	/*
1766	* Restore the state.
1767	*/
1768	vmR3CheckIntegrity(pVM);
1769	Assert(pVM->enmVMState == VMSTATE_RESETTING);
1770	vmR3SetState(pVM, enmVMState);
1771
1772	return VINF_EM_RESET;
1773	}
1774
1775
1776	/**
1777	* Walks the list of at VM reset callbacks and calls them
1778	*
1779	* @returns VBox status code.
1780	* Any failure is fatal.
1781	* @param pVM The VM which is being reset.
1782	*/
1783	static int vmR3AtReset(PVM pVM)
1784	{
1785	/*
1786	* Walk the list and call them all.
1787	*/
1788	int rc = VINF_SUCCESS;
1789	for (PVMATRESET pCur = pVM->vm.s.pAtReset; pCur; pCur = pCur->pNext)
1790	{
1791	/* do the call */
1792	switch (pCur->enmType)
1793	{
1794	case VMATRESETTYPE_DEV:
1795	rc = pCur->u.Dev.pfnCallback(pCur->u.Dev.pDevIns, pCur->pvUser);
1796	break;
1797	case VMATRESETTYPE_INTERNAL:
1798	rc = pCur->u.Internal.pfnCallback(pVM, pCur->pvUser);
1799	break;
1800	case VMATRESETTYPE_EXTERNAL:
1801	pCur->u.External.pfnCallback(pCur->pvUser);
1802	break;
1803	default:
1804	AssertMsgFailed(("Invalid at-reset type %d!\n", pCur->enmType));
1805	return VERR_INTERNAL_ERROR;
1806	}
1807
1808	if (VBOX_FAILURE(rc))
1809	{
1810	AssertMsgFailed(("At-reset handler %s failed with rc=%d\n", pCur->pszDesc, rc));
1811	return rc;
1812	}
1813	}
1814
1815	return VINF_SUCCESS;
1816	}
1817
1818
1819	/**
1820	* Internal registration function
1821	*/
1822	static int vmr3AtResetRegister(PVM pVM, void pvUser, const char pszDesc, PVMATRESET *ppNew)
1823	{
1824	/*
1825	* Allocate restration structure.
1826	*/
1827	PVMATRESET pNew = (PVMATRESET)MMR3HeapAlloc(pVM, MM_TAG_VM, sizeof(*pNew));
1828	if (pNew)
1829	{
1830	/* fill data. */
1831	pNew->pNext = NULL;
1832	pNew->pszDesc = pszDesc;
1833	pNew->pvUser = pvUser;
1834
1835	/* insert */
1836	*pVM->vm.s.ppAtResetNext = pNew;
1837	pVM->vm.s.ppAtResetNext = &pNew->pNext;
1838
1839	return VINF_SUCCESS;
1840	}
1841	return VERR_NO_MEMORY;
1842	}
1843
1844
1845	/**
1846	* Registers an at VM reset callback.
1847	*
1848	* @returns VBox status code.
1849	* @param pVM The VM.
1850	* @param pDevInst Device instance.
1851	* @param pfnCallback Callback function.
1852	* @param pvUser User argument.
1853	* @param pszDesc Description (optional).
1854	*/
1855	VMR3DECL(int) VMR3AtResetRegister(PVM pVM, PPDMDEVINS pDevInst, PFNVMATRESET pfnCallback, void pvUser, const char pszDesc)
1856	{
1857	/*
1858	* Validate.
1859	*/
1860	if (!pDevInst)
1861	{
1862	AssertMsgFailed(("pDevIns is NULL!\n"));
1863	return VERR_INVALID_PARAMETER;
1864	}
1865
1866	/*
1867	* Create the new entry.
1868	*/
1869	PVMATRESET pNew;
1870	int rc = vmr3AtResetRegister(pVM, pvUser, pszDesc, &pNew);
1871	if (VBOX_SUCCESS(rc))
1872	{
1873	/*
1874	* Fill in type data.
1875	*/
1876	pNew->enmType = VMATRESETTYPE_DEV;
1877	pNew->u.Dev.pfnCallback = pfnCallback;
1878	pNew->u.Dev.pDevIns = pDevInst;
1879	}
1880
1881	return rc;
1882	}
1883
1884
1885	/**
1886	* Registers an at VM reset internal callback.
1887	*
1888	* @returns VBox status code.
1889	* @param pVM The VM.
1890	* @param pfnCallback Callback function.
1891	* @param pvUser User argument.
1892	* @param pszDesc Description (optional).
1893	*/
1894	VMR3DECL(int) VMR3AtResetRegisterInternal(PVM pVM, PFNVMATRESETINT pfnCallback, void pvUser, const char pszDesc)
1895	{
1896	/*
1897	* Validate.
1898	*/
1899	if (!pfnCallback)
1900	{
1901	AssertMsgFailed(("pfnCallback is NULL!\n"));
1902	return VERR_INVALID_PARAMETER;
1903	}
1904
1905	/*
1906	* Create the new entry.
1907	*/
1908	PVMATRESET pNew;
1909	int rc = vmr3AtResetRegister(pVM, pvUser, pszDesc, &pNew);
1910	if (VBOX_SUCCESS(rc))
1911	{
1912	/*
1913	* Fill in type data.
1914	*/
1915	pNew->enmType = VMATRESETTYPE_INTERNAL;
1916	pNew->u.Internal.pfnCallback = pfnCallback;
1917	}
1918
1919	return rc;
1920	}
1921
1922
1923	/**
1924	* Registers an at VM reset external callback.
1925	*
1926	* @returns VBox status code.
1927	* @param pVM The VM.
1928	* @param pfnCallback Callback function.
1929	* @param pvUser User argument.
1930	* @param pszDesc Description (optional).
1931	*/
1932	VMR3DECL(int) VMR3AtResetRegisterExternal(PVM pVM, PFNVMATRESETEXT pfnCallback, void pvUser, const char pszDesc)
1933	{
1934	/*
1935	* Validate.
1936	*/
1937	if (!pfnCallback)
1938	{
1939	AssertMsgFailed(("pfnCallback is NULL!\n"));
1940	return VERR_INVALID_PARAMETER;
1941	}
1942
1943	/*
1944	* Create the new entry.
1945	*/
1946	PVMATRESET pNew;
1947	int rc = vmr3AtResetRegister(pVM, pvUser, pszDesc, &pNew);
1948	if (VBOX_SUCCESS(rc))
1949	{
1950	/*
1951	* Fill in type data.
1952	*/
1953	pNew->enmType = VMATRESETTYPE_EXTERNAL;
1954	pNew->u.External.pfnCallback = pfnCallback;
1955	}
1956
1957	return rc;
1958	}
1959
1960
1961	/**
1962	* Unlinks and frees a callback.
1963	*
1964	* @returns Pointer to the next callback structure.
1965	* @param pVM The VM.
1966	* @param pCur The one to free.
1967	* @param pPrev The one before pCur.
1968	*/
1969	static PVMATRESET vmr3AtResetFree(PVM pVM, PVMATRESET pCur, PVMATRESET pPrev)
1970	{
1971	/*
1972	* Unlink it.
1973	*/
1974	PVMATRESET pNext = pCur->pNext;
1975	if (pPrev)
1976	{
1977	pPrev->pNext = pNext;
1978	if (!pNext)
1979	pVM->vm.s.ppAtResetNext = &pPrev->pNext;
1980	}
1981	else
1982	{
1983	pVM->vm.s.pAtReset = pNext;
1984	if (!pNext)
1985	pVM->vm.s.ppAtResetNext = &pVM->vm.s.pAtReset;
1986	}
1987
1988	/*
1989	* Free it.
1990	*/
1991	MMR3HeapFree(pCur);
1992
1993	return pNext;
1994	}
1995
1996
1997	/**
1998	* Deregisters an at VM reset callback.
1999	*
2000	* @returns VBox status code.
2001	* @param pVM The VM.
2002	* @param pDevInst Device instance.
2003	* @param pfnCallback Callback function.
2004	*/
2005	VMR3DECL(int) VMR3AtResetDeregister(PVM pVM, PPDMDEVINS pDevInst, PFNVMATRESET pfnCallback)
2006	{
2007	int rc = VERR_VM_ATRESET_NOT_FOUND;
2008	PVMATRESET pPrev = NULL;
2009	PVMATRESET pCur = pVM->vm.s.pAtReset;
2010	while (pCur)
2011	{
2012	if ( pCur->enmType == VMATRESETTYPE_DEV
2013	&& pCur->u.Dev.pDevIns == pDevInst
2014	&& (!pfnCallback \|\| pCur->u.Dev.pfnCallback == pfnCallback))
2015	{
2016	pCur = vmr3AtResetFree(pVM, pCur, pPrev);
2017	rc = VINF_SUCCESS;
2018	}
2019	else
2020	{
2021	pPrev = pCur;
2022	pCur = pCur->pNext;
2023	}
2024	}
2025
2026	AssertRC(rc);
2027	return rc;
2028	}
2029
2030
2031	/**
2032	* Deregisters an at VM reset internal callback.
2033	*
2034	* @returns VBox status code.
2035	* @param pVM The VM.
2036	* @param pfnCallback Callback function.
2037	*/
2038	VMR3DECL(int) VMR3AtResetDeregisterInternal(PVM pVM, PFNVMATRESETINT pfnCallback)
2039	{
2040	int rc = VERR_VM_ATRESET_NOT_FOUND;
2041	PVMATRESET pPrev = NULL;
2042	PVMATRESET pCur = pVM->vm.s.pAtReset;
2043	while (pCur)
2044	{
2045	if ( pCur->enmType == VMATRESETTYPE_INTERNAL
2046	&& pCur->u.Internal.pfnCallback == pfnCallback)
2047	{
2048	pCur = vmr3AtResetFree(pVM, pCur, pPrev);
2049	rc = VINF_SUCCESS;
2050	}
2051	else
2052	{
2053	pPrev = pCur;
2054	pCur = pCur->pNext;
2055	}
2056	}
2057
2058	AssertRC(rc);
2059	return rc;
2060	}
2061
2062
2063	/**
2064	* Deregisters an at VM reset external callback.
2065	*
2066	* @returns VBox status code.
2067	* @param pVM The VM.
2068	* @param pfnCallback Callback function.
2069	*/
2070	VMR3DECL(int) VMR3AtResetDeregisterExternal(PVM pVM, PFNVMATRESETEXT pfnCallback)
2071	{
2072	int rc = VERR_VM_ATRESET_NOT_FOUND;
2073	PVMATRESET pPrev = NULL;
2074	PVMATRESET pCur = pVM->vm.s.pAtReset;
2075	while (pCur)
2076	{
2077	if ( pCur->enmType == VMATRESETTYPE_INTERNAL
2078	&& pCur->u.External.pfnCallback == pfnCallback)
2079	{
2080	pCur = vmr3AtResetFree(pVM, pCur, pPrev);
2081	rc = VINF_SUCCESS;
2082	}
2083	else
2084	{
2085	pPrev = pCur;
2086	pCur = pCur->pNext;
2087	}
2088	}
2089
2090	AssertRC(rc);
2091	return rc;
2092	}
2093
2094
2095	/**
2096	* Gets the current VM state.
2097	*
2098	* @returns The current VM state.
2099	* @param pVM VM handle.
2100	* @thread Any
2101	*/
2102	VMR3DECL(VMSTATE) VMR3GetState(PVM pVM)
2103	{
2104	return pVM->enmVMState;
2105	}
2106
2107
2108	/**
2109	* Gets the state name string for a VM state.
2110	*
2111	* @returns Pointer to the state name. (readonly)
2112	* @param enmState The state.
2113	*/
2114	VMR3DECL(const char *) VMR3GetStateName(VMSTATE enmState)
2115	{
2116	switch (enmState)
2117	{
2118	case VMSTATE_CREATING: return "CREATING";
2119	case VMSTATE_CREATED: return "CREATED";
2120	case VMSTATE_RUNNING: return "RUNNING";
2121	case VMSTATE_LOADING: return "LOADING";
2122	case VMSTATE_LOAD_FAILURE: return "LOAD_FAILURE";
2123	case VMSTATE_SAVING: return "SAVING";
2124	case VMSTATE_SUSPENDED: return "SUSPENDED";
2125	case VMSTATE_RESETTING: return "RESETTING";
2126	case VMSTATE_GURU_MEDITATION: return "GURU_MEDIATION";
2127	case VMSTATE_OFF: return "OFF";
2128	case VMSTATE_DESTROYING: return "DESTROYING";
2129	case VMSTATE_TERMINATED: return "TERMINATED";
2130	default:
2131	AssertMsgFailed(("Unknown state %d\n", enmState));
2132	return "Unknown!\n";
2133	}
2134	}
2135
2136
2137	/**
2138	* Sets the current VM state.
2139	*
2140	* @returns The current VM state.
2141	* @param pVM VM handle.
2142	* @param enmStateNew The new state.
2143	*/
2144	void vmR3SetState(PVM pVM, VMSTATE enmStateNew)
2145	{
2146	VMSTATE enmStateOld = pVM->enmVMState;
2147	pVM->enmVMState = enmStateNew;
2148	LogRel(("Changing the VM state from '%s' to '%s'.\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)));
2149
2150	/*
2151	* Call the at state change callbacks.
2152	*/
2153	for (PVMATSTATE pCur = pVM->vm.s.pAtState; pCur; pCur = pCur->pNext)
2154	{
2155	pCur->pfnAtState(pVM, enmStateNew, enmStateOld, pCur->pvUser);
2156	if (pVM->enmVMState == VMSTATE_DESTROYING)
2157	break;
2158	AssertMsg(pVM->enmVMState == enmStateNew,
2159	("You are not allowed to change the state while in the change callback, except "
2160	"from destroying the VM. There are restrictions in the way the state changes "
2161	"are propagated up to the EM execution loop and it makes the program flow very "
2162	"difficult to follow.\n"));
2163	}
2164	}
2165
2166
2167	/**
2168	* Registers a VM state change callback.
2169	*
2170	* You are not allowed to call any function which changes the VM state from a
2171	* state callback, except VMR3Destroy().
2172	*
2173	* @returns VBox status code.
2174	* @param pVM VM handle.
2175	* @param pfnAtState Pointer to callback.
2176	* @param pvUser User argument.
2177	* @thread Any.
2178	*/
2179	VMR3DECL(int) VMR3AtStateRegister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2180	{
2181	LogFlow(("VMR3AtStateRegister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2182
2183	/*
2184	* Validate input.
2185	*/
2186	if (!pfnAtState)
2187	{
2188	AssertMsgFailed(("callback is required\n"));
2189	return VERR_INVALID_PARAMETER;
2190	}
2191
2192	/*
2193	* Make sure we're in EMT (to avoid the logging).
2194	*/
2195	PVMREQ pReq;
2196	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateRegister, 3, pVM, pfnAtState, pvUser);
2197	if (VBOX_FAILURE(rc))
2198	return rc;
2199	rc = pReq->iStatus;
2200	VMR3ReqFree(pReq);
2201
2202	LogFlow(("VMR3AtStateRegister: returns %Vrc\n", rc));
2203	return rc;
2204	}
2205
2206
2207	/**
2208	* Registers a VM state change callback.
2209	*
2210	* @returns VBox status code.
2211	* @param pVM VM handle.
2212	* @param pfnAtState Pointer to callback.
2213	* @param pvUser User argument.
2214	* @thread EMT
2215	*/
2216	static DECLCALLBACK(int) vmR3AtStateRegister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2217	{
2218	/*
2219	* Allocate a new record.
2220	*/
2221
2222	PVMATSTATE pNew = (PVMATSTATE)MMR3HeapAlloc(pVM, MM_TAG_VM, sizeof(*pNew));
2223	if (!pNew)
2224	return VERR_NO_MEMORY;
2225
2226	/* fill */
2227	pNew->pfnAtState = pfnAtState;
2228	pNew->pvUser = pvUser;
2229	pNew->pNext = NULL;
2230
2231	/* insert */
2232	*pVM->vm.s.ppAtStateNext = pNew;
2233	pVM->vm.s.ppAtStateNext = &pNew->pNext;
2234
2235	return VINF_SUCCESS;
2236	}
2237
2238
2239	/**
2240	* Deregisters a VM state change callback.
2241	*
2242	* @returns VBox status code.
2243	* @param pVM VM handle.
2244	* @param pfnAtState Pointer to callback.
2245	* @param pvUser User argument.
2246	* @thread Any.
2247	*/
2248	VMR3DECL(int) VMR3AtStateDeregister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2249	{
2250	LogFlow(("VMR3AtStateDeregister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2251
2252	/*
2253	* Validate input.
2254	*/
2255	if (!pfnAtState)
2256	{
2257	AssertMsgFailed(("callback is required\n"));
2258	return VERR_INVALID_PARAMETER;
2259	}
2260
2261	/*
2262	* Make sure we're in EMT (to avoid the logging).
2263	*/
2264	PVMREQ pReq;
2265	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateDeregister, 3, pVM, pfnAtState, pvUser);
2266	if (VBOX_FAILURE(rc))
2267	return rc;
2268	rc = pReq->iStatus;
2269	VMR3ReqFree(pReq);
2270
2271	LogFlow(("VMR3AtStateDeregister: returns %Vrc\n", rc));
2272	return rc;
2273	}
2274
2275
2276	/**
2277	* Deregisters a VM state change callback.
2278	*
2279	* @returns VBox status code.
2280	* @param pVM VM handle.
2281	* @param pfnAtState Pointer to callback.
2282	* @param pvUser User argument.
2283	* @thread EMT
2284	*/
2285	static DECLCALLBACK(int) vmR3AtStateDeregister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2286	{
2287	LogFlow(("vmR3AtStateDeregister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2288
2289	/*
2290	* Search the list for the entry.
2291	*/
2292	PVMATSTATE pPrev = NULL;
2293	PVMATSTATE pCur = pVM->vm.s.pAtState;
2294	while ( pCur
2295	&& pCur->pfnAtState == pfnAtState
2296	&& pCur->pvUser == pvUser)
2297	{
2298	pPrev = pCur;
2299	pCur = pCur->pNext;
2300	}
2301	if (!pCur)
2302	{
2303	AssertMsgFailed(("pfnAtState=%p was not found\n", pfnAtState));
2304	return VERR_FILE_NOT_FOUND;
2305	}
2306
2307	/*
2308	* Unlink it.
2309	*/
2310	if (pPrev)
2311	{
2312	pPrev->pNext = pCur->pNext;
2313	if (!pCur->pNext)
2314	pVM->vm.s.ppAtStateNext = &pPrev->pNext;
2315	}
2316	else
2317	{
2318	pVM->vm.s.pAtState = pCur->pNext;
2319	if (!pCur->pNext)
2320	pVM->vm.s.ppAtStateNext = &pVM->vm.s.pAtState;
2321	}
2322
2323	/*
2324	* Free it.
2325	*/
2326	pCur->pfnAtState = NULL;
2327	pCur->pNext = NULL;
2328	MMR3HeapFree(pCur);
2329
2330	return VINF_SUCCESS;
2331	}
2332
2333
2334	/**
2335	* Registers a VM error callback.
2336	*
2337	* @returns VBox status code.
2338	* @param pVM The VM handle.
2339	* @param pfnAtError Pointer to callback.
2340	* @param pvUser User argument.
2341	* @thread Any.
2342	*/
2343	VMR3DECL(int) VMR3AtErrorRegister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2344	{
2345	LogFlow(("VMR3AtErrorRegister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2346
2347	/*
2348	* Validate input.
2349	*/
2350	if (!pfnAtError)
2351	{
2352	AssertMsgFailed(("callback is required\n"));
2353	return VERR_INVALID_PARAMETER;
2354	}
2355
2356	/*
2357	* Make sure we're in EMT (to avoid the logging).
2358	*/
2359	PVMREQ pReq;
2360	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtErrorRegister, 3, pVM, pfnAtError, pvUser);
2361	if (VBOX_FAILURE(rc))
2362	return rc;
2363	rc = pReq->iStatus;
2364	VMR3ReqFree(pReq);
2365
2366	LogFlow(("VMR3AtErrorRegister: returns %Vrc\n", rc));
2367	return rc;
2368	}
2369
2370
2371	/**
2372	* Registers a VM error callback.
2373	*
2374	* @returns VBox status code.
2375	* @param pVM The VM handle.
2376	* @param pfnAtError Pointer to callback.
2377	* @param pvUser User argument.
2378	* @thread EMT
2379	*/
2380	static DECLCALLBACK(int) vmR3AtErrorRegister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2381	{
2382	/*
2383	* Allocate a new record.
2384	*/
2385
2386	PVMATERROR pNew = (PVMATERROR)MMR3HeapAlloc(pVM, MM_TAG_VM, sizeof(*pNew));
2387	if (!pNew)
2388	return VERR_NO_MEMORY;
2389
2390	/* fill */
2391	pNew->pfnAtError = pfnAtError;
2392	pNew->pvUser = pvUser;
2393	pNew->pNext = NULL;
2394
2395	/* insert */
2396	*pVM->vm.s.ppAtErrorNext = pNew;
2397	pVM->vm.s.ppAtErrorNext = &pNew->pNext;
2398
2399	return VINF_SUCCESS;
2400	}
2401
2402
2403	/**
2404	* Deregisters a VM error callback.
2405	*
2406	* @returns VBox status code.
2407	* @param pVM The VM handle.
2408	* @param pfnAtError Pointer to callback.
2409	* @param pvUser User argument.
2410	* @thread Any.
2411	*/
2412	VMR3DECL(int) VMR3AtErrorDeregister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2413	{
2414	LogFlow(("VMR3AtErrorDeregister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2415
2416	/*
2417	* Validate input.
2418	*/
2419	if (!pfnAtError)
2420	{
2421	AssertMsgFailed(("callback is required\n"));
2422	return VERR_INVALID_PARAMETER;
2423	}
2424
2425	/*
2426	* Make sure we're in EMT (to avoid the logging).
2427	*/
2428	PVMREQ pReq;
2429	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtErrorDeregister, 3, pVM, pfnAtError, pvUser);
2430	if (VBOX_FAILURE(rc))
2431	return rc;
2432	rc = pReq->iStatus;
2433	VMR3ReqFree(pReq);
2434
2435	LogFlow(("VMR3AtErrorDeregister: returns %Vrc\n", rc));
2436	return rc;
2437	}
2438
2439
2440	/**
2441	* Deregisters a VM error callback.
2442	*
2443	* @returns VBox status code.
2444	* @param pVM The VM handle.
2445	* @param pfnAtError Pointer to callback.
2446	* @param pvUser User argument.
2447	* @thread EMT
2448	*/
2449	static DECLCALLBACK(int) vmR3AtErrorDeregister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2450	{
2451	LogFlow(("vmR3AtErrorDeregister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2452
2453	/*
2454	* Search the list for the entry.
2455	*/
2456	PVMATERROR pPrev = NULL;
2457	PVMATERROR pCur = pVM->vm.s.pAtError;
2458	while ( pCur
2459	&& pCur->pfnAtError == pfnAtError
2460	&& pCur->pvUser == pvUser)
2461	{
2462	pPrev = pCur;
2463	pCur = pCur->pNext;
2464	}
2465	if (!pCur)
2466	{
2467	AssertMsgFailed(("pfnAtError=%p was not found\n", pfnAtError));
2468	return VERR_FILE_NOT_FOUND;
2469	}
2470
2471	/*
2472	* Unlink it.
2473	*/
2474	if (pPrev)
2475	{
2476	pPrev->pNext = pCur->pNext;
2477	if (!pCur->pNext)
2478	pVM->vm.s.ppAtErrorNext = &pPrev->pNext;
2479	}
2480	else
2481	{
2482	pVM->vm.s.pAtError = pCur->pNext;
2483	if (!pCur->pNext)
2484	pVM->vm.s.ppAtErrorNext = &pVM->vm.s.pAtError;
2485	}
2486
2487	/*
2488	* Free it.
2489	*/
2490	pCur->pfnAtError = NULL;
2491	pCur->pNext = NULL;
2492	MMR3HeapFree(pCur);
2493
2494	return VINF_SUCCESS;
2495	}
2496
2497
2498	/**
2499	* Ellipsis to va_list wrapper for calling pfnAtError.
2500	*/
2501	static void vmR3SetErrorWorkerDoCall(PVM pVM, PVMATERROR pCur, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2502	{
2503	va_list va;
2504	va_start(va, pszFormat);
2505	pCur->pfnAtError(pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
2506	va_end(va);
2507	}
2508
2509
2510	/**
2511	* This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2512	* The message is found in VMINT.
2513	*
2514	* @param pVM The VM handle.
2515	* @thread EMT.
2516	*/
2517	VMR3DECL(void) VMR3SetErrorWorker(PVM pVM)
2518	{
2519	VM_ASSERT_EMT(pVM);
2520	AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetErrorV! Contrats!\n"));
2521
2522	/*
2523	* Unpack the error (if we managed to format one).
2524	*/
2525	PVMERROR pErr = pVM->vm.s.pErrorR3;
2526	const char *pszFile = NULL;
2527	const char *pszFunction = NULL;
2528	uint32_t iLine = 0;
2529	const char *pszMessage;
2530	int32_t rc = VERR_MM_HYPER_NO_MEMORY;
2531	if (pErr)
2532	{
2533	AssertCompile(sizeof(const char) == sizeof(uint8_t));
2534	if (pErr->offFile)
2535	pszFile = (const char *)pErr + pErr->offFile;
2536	iLine = pErr->iLine;
2537	if (pErr->offFunction)
2538	pszFunction = (const char *)pErr + pErr->offFunction;
2539	if (pErr->offMessage)
2540	pszMessage = (const char *)pErr + pErr->offMessage;
2541	else
2542	pszMessage = "No message!";
2543	}
2544	else
2545	pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2546
2547	/*
2548	* Call the at error callbacks.
2549	*/
2550	for (PVMATERROR pCur = pVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2551	vmR3SetErrorWorkerDoCall(pVM, pCur, rc, RT_SRC_POS_ARGS, "%s", pszMessage);
2552	}
2553
2554
2555	/**
2556	* Worker which calls everyone listening to the VM error messages.
2557	*
2558	* @param pVM The VM handle.
2559	* @param rc The VBox status code.
2560	* @param RT_SRC_POS_DECL The source position of this error.
2561	* @param pszFormat Format string.
2562	* @param pArgs Pointer to the format arguments.
2563	* @thread EMT
2564	*/
2565	DECLCALLBACK(void) vmR3SetErrorV(PVM pVM, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list pArgs)
2566	{
2567	#ifdef LOG_ENABLED
2568	/*
2569	* Log the error.
2570	*/
2571	RTLogPrintf("VMSetError: %s(%d) %s\n", pszFile, iLine, pszFunction);
2572	va_list va3;
2573	va_copy(va3, *pArgs);
2574	RTLogPrintfV(pszFormat, va3);
2575	va_end(va3);
2576	#endif
2577
2578	/*
2579	* Make a copy of the message.
2580	*/
2581	vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, *pArgs);
2582
2583	/*
2584	* Call the at error callbacks.
2585	*/
2586	for (PVMATERROR pCur = pVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2587	{
2588	va_list va2;
2589	va_copy(va2, *pArgs);
2590	pCur->pfnAtError(pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
2591	va_end(va2);
2592	}
2593	}
2594
2595
2596	/**
2597	* Registers a VM runtime error callback.
2598	*
2599	* @returns VBox status code.
2600	* @param pVM The VM handle.
2601	* @param pfnAtRuntimeError Pointer to callback.
2602	* @param pvUser User argument.
2603	* @thread Any.
2604	*/
2605	VMR3DECL(int) VMR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2606	{
2607	LogFlow(("VMR3AtRuntimeErrorRegister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2608
2609	/*
2610	* Validate input.
2611	*/
2612	if (!pfnAtRuntimeError)
2613	{
2614	AssertMsgFailed(("callback is required\n"));
2615	return VERR_INVALID_PARAMETER;
2616	}
2617
2618	/*
2619	* Make sure we're in EMT (to avoid the logging).
2620	*/
2621	PVMREQ pReq;
2622	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorRegister, 3, pVM, pfnAtRuntimeError, pvUser);
2623	if (VBOX_FAILURE(rc))
2624	return rc;
2625	rc = pReq->iStatus;
2626	VMR3ReqFree(pReq);
2627
2628	LogFlow(("VMR3AtRuntimeErrorRegister: returns %Vrc\n", rc));
2629	return rc;
2630	}
2631
2632
2633	/**
2634	* Registers a VM runtime error callback.
2635	*
2636	* @returns VBox status code.
2637	* @param pVM The VM handle.
2638	* @param pfnAtRuntimeError Pointer to callback.
2639	* @param pvUser User argument.
2640	* @thread EMT
2641	*/
2642	static DECLCALLBACK(int) vmR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2643	{
2644	/*
2645	* Allocate a new record.
2646	*/
2647
2648	PVMATRUNTIMEERROR pNew = (PVMATRUNTIMEERROR)MMR3HeapAlloc(pVM, MM_TAG_VM, sizeof(*pNew));
2649	if (!pNew)
2650	return VERR_NO_MEMORY;
2651
2652	/* fill */
2653	pNew->pfnAtRuntimeError = pfnAtRuntimeError;
2654	pNew->pvUser = pvUser;
2655	pNew->pNext = NULL;
2656
2657	/* insert */
2658	*pVM->vm.s.ppAtRuntimeErrorNext = pNew;
2659	pVM->vm.s.ppAtRuntimeErrorNext = &pNew->pNext;
2660
2661	return VINF_SUCCESS;
2662	}
2663
2664
2665	/**
2666	* Deregisters a VM runtime error callback.
2667	*
2668	* @returns VBox status code.
2669	* @param pVM The VM handle.
2670	* @param pfnAtRuntimeError Pointer to callback.
2671	* @param pvUser User argument.
2672	* @thread Any.
2673	*/
2674	VMR3DECL(int) VMR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2675	{
2676	LogFlow(("VMR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2677
2678	/*
2679	* Validate input.
2680	*/
2681	if (!pfnAtRuntimeError)
2682	{
2683	AssertMsgFailed(("callback is required\n"));
2684	return VERR_INVALID_PARAMETER;
2685	}
2686
2687	/*
2688	* Make sure we're in EMT (to avoid the logging).
2689	*/
2690	PVMREQ pReq;
2691	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorDeregister, 3, pVM, pfnAtRuntimeError, pvUser);
2692	if (VBOX_FAILURE(rc))
2693	return rc;
2694	rc = pReq->iStatus;
2695	VMR3ReqFree(pReq);
2696
2697	LogFlow(("VMR3AtRuntimeErrorDeregister: returns %Vrc\n", rc));
2698	return rc;
2699	}
2700
2701
2702	/**
2703	* Deregisters a VM runtime error callback.
2704	*
2705	* @returns VBox status code.
2706	* @param pVM The VM handle.
2707	* @param pfnAtRuntimeError Pointer to callback.
2708	* @param pvUser User argument.
2709	* @thread EMT
2710	*/
2711	static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2712	{
2713	LogFlow(("vmR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2714
2715	/*
2716	* Search the list for the entry.
2717	*/
2718	PVMATRUNTIMEERROR pPrev = NULL;
2719	PVMATRUNTIMEERROR pCur = pVM->vm.s.pAtRuntimeError;
2720	while ( pCur
2721	&& pCur->pfnAtRuntimeError == pfnAtRuntimeError
2722	&& pCur->pvUser == pvUser)
2723	{
2724	pPrev = pCur;
2725	pCur = pCur->pNext;
2726	}
2727	if (!pCur)
2728	{
2729	AssertMsgFailed(("pfnAtRuntimeError=%p was not found\n", pfnAtRuntimeError));
2730	return VERR_FILE_NOT_FOUND;
2731	}
2732
2733	/*
2734	* Unlink it.
2735	*/
2736	if (pPrev)
2737	{
2738	pPrev->pNext = pCur->pNext;
2739	if (!pCur->pNext)
2740	pVM->vm.s.ppAtRuntimeErrorNext = &pPrev->pNext;
2741	}
2742	else
2743	{
2744	pVM->vm.s.pAtRuntimeError = pCur->pNext;
2745	if (!pCur->pNext)
2746	pVM->vm.s.ppAtRuntimeErrorNext = &pVM->vm.s.pAtRuntimeError;
2747	}
2748
2749	/*
2750	* Free it.
2751	*/
2752	pCur->pfnAtRuntimeError = NULL;
2753	pCur->pNext = NULL;
2754	MMR3HeapFree(pCur);
2755
2756	return VINF_SUCCESS;
2757	}
2758
2759
2760	/**
2761	* Ellipsis to va_list wrapper for calling pfnAtRuntimeError.
2762	*/
2763	static void vmR3SetRuntimeErrorWorkerDoCall(PVM pVM, PVMATRUNTIMEERROR pCur, bool fFatal,
2764	const char *pszErrorID,
2765	const char *pszFormat, ...)
2766	{
2767	va_list va;
2768	va_start(va, pszFormat);
2769	pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va);
2770	va_end(va);
2771	}
2772
2773
2774	/**
2775	* This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2776	* The message is found in VMINT.
2777	*
2778	* @param pVM The VM handle.
2779	* @thread EMT.
2780	*/
2781	VMR3DECL(void) VMR3SetRuntimeErrorWorker(PVM pVM)
2782	{
2783	VM_ASSERT_EMT(pVM);
2784	AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetRuntimeErrorV! Contrats!\n"));
2785
2786	/*
2787	* Unpack the error (if we managed to format one).
2788	*/
2789	PVMRUNTIMEERROR pErr = pVM->vm.s.pRuntimeErrorR3;
2790	const char *pszErrorID = NULL;
2791	const char *pszMessage;
2792	bool fFatal = false;
2793	if (pErr)
2794	{
2795	AssertCompile(sizeof(const char) == sizeof(uint8_t));
2796	if (pErr->offErrorID)
2797	pszErrorID = (const char *)pErr + pErr->offErrorID;
2798	if (pErr->offMessage)
2799	pszMessage = (const char *)pErr + pErr->offMessage;
2800	else
2801	pszMessage = "No message!";
2802	fFatal = pErr->fFatal;
2803	}
2804	else
2805	pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2806
2807	/*
2808	* Call the at runtime error callbacks.
2809	*/
2810	for (PVMATRUNTIMEERROR pCur = pVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2811	vmR3SetRuntimeErrorWorkerDoCall(pVM, pCur, fFatal, pszErrorID, "%s", pszMessage);
2812	}
2813
2814
2815	/**
2816	* Worker which calls everyone listening to the VM runtime error messages.
2817	*
2818	* @param pVM The VM handle.
2819	* @param fFatal Whether it is a fatal error or not.
2820	* @param pszErrorID Error ID string.
2821	* @param pszFormat Format string.
2822	* @param pArgs Pointer to the format arguments.
2823	* @thread EMT
2824	*/
2825	DECLCALLBACK(void) vmR3SetRuntimeErrorV(PVM pVM, bool fFatal,
2826	const char *pszErrorID,
2827	const char pszFormat, va_list pArgs)
2828	{
2829	/*
2830	* Make a copy of the message.
2831	*/
2832	vmSetRuntimeErrorCopy(pVM, fFatal, pszErrorID, pszFormat, *pArgs);
2833
2834	/*
2835	* Call the at error callbacks.
2836	*/
2837	for (PVMATRUNTIMEERROR pCur = pVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2838	{
2839	va_list va2;
2840	va_copy(va2, *pArgs);
2841	pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va2);
2842	va_end(va2);
2843	}
2844	}
2845

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

source: vbox/trunk/src/VBox/VMM/VM.cpp@ 4372

Download in other formats: