VM.cpp@ 2018

Last change on this file since 2018 was 1890, checked in by vboxsync, 18 years ago
Attempt to fix ALSA on Linux kernels <= 2.6.17: use mmap not memalign for allocating pages. Use madvise or mprotect to separater VM area structs inside the kernel. Most SUP* functions work on cPages now (not cBytes anymore). The free functions take a cPages parameter which is used for munmap on Linux.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 84.0 KB

Line
1	/* $Id: VM.cpp 1890 2007-04-03 16:04:19Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung 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	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_VM
27	#include <VBox/cfgm.h>
28	#include <VBox/vmm.h>
29	#include <VBox/mm.h>
30	#include <VBox/cpum.h>
31	#include <VBox/selm.h>
32	#include <VBox/trpm.h>
33	#include <VBox/dbgf.h>
34	#include <VBox/pgm.h>
35	#include <VBox/pdm.h>
36	#include <VBox/em.h>
37	#include <VBox/rem.h>
38	#include <VBox/tm.h>
39	#include <VBox/stam.h>
40	#include <VBox/patm.h>
41	#include <VBox/csam.h>
42	#include <VBox/iom.h>
43	#include <VBox/hwaccm.h>
44	#include "VMInternal.h"
45	#include <VBox/vm.h>
46
47	#include <VBox/sup.h>
48	#include <VBox/dbg.h>
49	#include <VBox/err.h>
50	#include <VBox/param.h>
51	#include <VBox/log.h>
52	#include <iprt/assert.h>
53	#include <iprt/alloc.h>
54	#include <iprt/asm.h>
55	#include <iprt/string.h>
56	#include <iprt/time.h>
57	#include <iprt/semaphore.h>
58	#include <iprt/thread.h>
59
60	#include <stdlib.h> /* getenv */
61
62
63	/*******************************************************************************
64	* Structures and Typedefs *
65	*******************************************************************************/
66	/**
67	* VM destruction callback registration record.
68	*/
69	typedef struct VMATDTOR
70	{
71	/** Pointer to the next record in the list. */
72	struct VMATDTOR *pNext;
73	/** Pointer to the callback function. */
74	PFNVMATDTOR pfnAtDtor;
75	/** The user argument. */
76	void *pvUser;
77	} VMATDTOR;
78	/** Pointer to a VM destruction callback registration record. */
79	typedef VMATDTOR *PVMATDTOR;
80
81
82	/*******************************************************************************
83	* Global Variables *
84	*******************************************************************************/
85	/** Pointer to the list of VMs. */
86	static PVM g_pVMsHead;
87
88	/** Pointer to the list of at VM destruction callbacks. */
89	static PVMATDTOR g_pVMAtDtorHead;
90	/** Lock the g_pVMAtDtorHead list. */
91	#define VM_ATDTOR_LOCK() do { } while (0)
92	/** Unlock the g_pVMAtDtorHead list. */
93	#define VM_ATDTOR_UNLOCK() do { } while (0)
94
95	/*******************************************************************************
96	* Internal Functions *
97	*******************************************************************************/
98	static int vmR3Create(PVM pVM, PFNVMATERROR pfnVMAtError, void pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void pvUserCFGM);
99	static void vmR3CallVMAtError(PFNVMATERROR pfnVMAtError, void pvUser, int rc, RT_SRC_POS_DECL, const char pszError, ...);
100	static int vmR3InitRing3(PVM pVM);
101	static int vmR3InitRing0(PVM pVM);
102	static int vmR3InitGC(PVM pVM);
103	static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat);
104	static DECLCALLBACK(int) vmR3PowerOn(PVM pVM);
105	static DECLCALLBACK(int) vmR3Suspend(PVM pVM);
106	static DECLCALLBACK(int) vmR3Resume(PVM pVM);
107	static DECLCALLBACK(int) vmR3Save(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser);
108	static DECLCALLBACK(int) vmR3Load(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser);
109	static DECLCALLBACK(int) vmR3PowerOff(PVM pVM);
110	static void vmR3AtDtor(PVM pVM);
111	static void vmR3SetState(PVM pVM, VMSTATE enmStateNew);
112	static int vmR3AtReset(PVM pVM);
113	static DECLCALLBACK(int) vmR3Reset(PVM pVM);
114	static DECLCALLBACK(int) vmR3AtStateRegister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser);
115	static DECLCALLBACK(int) vmR3AtStateDeregister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser);
116	static DECLCALLBACK(int) vmR3AtErrorRegister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser);
117	static DECLCALLBACK(int) vmR3AtErrorDeregister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser);
118	static DECLCALLBACK(int) vmR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser);
119	static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser);
120
121
122	/**
123	* Do global VMM init.
124	*
125	* @returns VBox status code.
126	*/
127	VMR3DECL(int) VMR3GlobalInit(void)
128	{
129	/*
130	* Only once.
131	*/
132	static bool fDone = false;
133	if (fDone)
134	return VINF_SUCCESS;
135
136	/*
137	* We're done.
138	*/
139	fDone = true;
140	return VINF_SUCCESS;
141	}
142
143
144
145	/**
146	* Creates a virtual machine by calling the supplied configuration constructor.
147	*
148	* On successful returned the VM is powered, i.e. VMR3PowerOn() should be
149	* called to start the execution.
150	*
151	* @returns 0 on success.
152	* @returns VBox error code on failure.
153	* @param pfnVMAtError Pointer to callback function for setting VM errors.
154	* This is called in the EM.
155	* @param pvUserVM The user argument passed to pfnVMAtError.
156	* @param pfnCFGMConstructor Pointer to callback function for constructing the VM configuration tree.
157	* This is called in the EM.
158	* @param pvUserCFGM The user argument passed to pfnCFGMConstructor.
159	* @param ppVM Where to store the 'handle' of the created VM.
160	*/
161	VMR3DECL(int) VMR3Create(PFNVMATERROR pfnVMAtError, void pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void pvUserCFGM, PVM *ppVM)
162	{
163	LogFlow(("VMR3Create: pfnVMAtError=%p pvUserVM=%p pfnCFGMConstructor=%p pvUserCFGM=%p ppVM=%p\n", pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM, ppVM));
164
165	/*
166	* Because of the current hackiness of the applications
167	* we'll have to initialize global stuff from here.
168	* Later the applications will take care of this in a proper way.
169	*/
170	static bool fGlobalInitDone = false;
171	if (!fGlobalInitDone)
172	{
173	int rc = VMR3GlobalInit();
174	if (VBOX_FAILURE(rc))
175	return rc;
176	fGlobalInitDone = true;
177	}
178
179	/*
180	* Init support library.
181	*/
182	PSUPDRVSESSION pSession = 0;
183	int rc = SUPInit(&pSession, 0);
184	if (VBOX_SUCCESS(rc))
185	{
186	/*
187	* Allocate memory for the VM structure.
188	*/
189	PVMR0 pVMR0 = NIL_RTR0PTR;
190	PVM pVM = NULL;
191	const unsigned cPages = RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE) >> PAGE_SHIFT;
192	PSUPPAGE paPages = (PSUPPAGE)RTMemAllocZ(cPages * sizeof(SUPPAGE));
193	AssertReturn(paPages, VERR_NO_MEMORY);
194	rc = SUPLowAlloc(cPages, (void **)&pVM, &pVMR0, &paPages[0]);
195	if (VBOX_SUCCESS(rc))
196	{
197	Log(("VMR3Create: Allocated pVM=%p pVMR0=%p\n", pVM, pVMR0));
198
199	/*
200	* Do basic init of the VM structure.
201	*/
202	memset(pVM, 0, sizeof(*pVM));
203	pVM->pVMHC = pVM;
204	pVM->pVMR0 = pVMR0;
205	pVM->pVMR3 = pVM;
206	pVM->paVMPagesR3 = paPages;
207	pVM->pSession = pSession;
208	pVM->vm.s.offVM = RT_OFFSETOF(VM, vm.s);
209	pVM->vm.s.ppAtResetNext = &pVM->vm.s.pAtReset;
210	pVM->vm.s.ppAtStateNext = &pVM->vm.s.pAtState;
211	pVM->vm.s.ppAtErrorNext = &pVM->vm.s.pAtError;
212	pVM->vm.s.ppAtRuntimeErrorNext = &pVM->vm.s.pAtRuntimeError;
213	rc = RTSemEventCreate(&pVM->vm.s.EventSemWait);
214	AssertRCReturn(rc, rc);
215
216	/*
217	* Initialize STAM.
218	*/
219	rc = STAMR3Init(pVM);
220	if (VBOX_SUCCESS(rc))
221	{
222	/*
223	* Create the EMT thread and make it do VM initialization and go sleep
224	* in EM waiting for requests.
225	*/
226	VMEMULATIONTHREADARGS Args;
227	Args.pVM = pVM;
228	rc = RTThreadCreate(&pVM->ThreadEMT, &vmR3EmulationThread, &Args, _1M,
229	RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "EMT");
230	if (VBOX_SUCCESS(rc))
231	{
232	/*
233	* Issue a VM Create request and wait for it to complete.
234	*/
235	PVMREQ pReq;
236	rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Create, 5, pVM, pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM);
237	if (VBOX_SUCCESS(rc))
238	{
239	rc = pReq->iStatus;
240	VMR3ReqFree(pReq);
241	if (VBOX_SUCCESS(rc))
242	{
243	*ppVM = pVM;
244	LogFlow(("VMR3Create: returns VINF_SUCCESS *ppVM=%p\n", pVM));
245	return VINF_SUCCESS;
246	}
247	AssertMsgFailed(("vmR3Create failed rc=%Vrc\n", rc));
248	}
249	else
250	AssertMsgFailed(("VMR3ReqCall failed rc=%Vrc\n", rc));
251
252	/* Forcefully terminate the emulation thread. */
253	VM_FF_SET(pVM, VM_FF_TERMINATE);
254	VMR3NotifyFF(pVM, false);
255	RTThreadWait(pVM->ThreadEMT, 1000, NULL);
256	}
257
258	int rc2 = STAMR3Term(pVM);
259	AssertRC(rc2);
260	}
261
262	/* cleanup the heap. */
263	int rc2 = MMR3Term(pVM);
264	AssertRC(rc2);
265
266	/* free the VM memory */
267	rc2 = SUPLowFree(pVM, cPages);
268	AssertRC(rc2);
269	}
270	else
271	{
272	rc = VERR_NO_MEMORY;
273	vmR3CallVMAtError(pfnVMAtError, pvUserVM, rc, RT_SRC_POS,
274	N_("Failed to allocate %d bytes of contiguous memory for the VM structure!\n"),
275	RT_ALIGN(sizeof(*pVM), PAGE_SIZE));
276	AssertMsgFailed(("Failed to allocate %d bytes of contiguous memory for the VM structure!\n", RT_ALIGN(sizeof(*pVM), PAGE_SIZE)));
277	}
278	RTMemFree(paPages);
279
280	/* terminate SUPLib */
281	int rc2 = SUPTerm(false);
282	AssertRC(rc2);
283	}
284	else
285	{
286	const char *pszError;
287	/*
288	* An error occurred at support library initialization time (before the
289	* VM could be created). Set the error message directly using the
290	* initial callback, as the callback list doesn't exist yet.
291	*/
292	switch (rc)
293	{
294	case VERR_VM_DRIVER_LOAD_ERROR:
295	#ifdef __LINUX
296	pszError = N_("VirtualBox kernel driver not loaded. The vboxdrv kernel module "
297	"was either not loaded or /dev/vboxdrv is not set up properly. "
298	"Re-setup the kernel module by executing "
299	"'/etc/init.d/vboxdrv setup' as root");
300	#else
301	pszError = N_("VirtualBox kernel driver not loaded.");
302	#endif
303	break;
304	case VERR_VM_DRIVER_OPEN_ERROR:
305	pszError = N_("VirtualBox kernel driver cannot be opened");
306	break;
307	case VERR_VM_DRIVER_NOT_ACCESSIBLE:
308	#ifdef __LINUX__
309	pszError = N_("VirtualBox kernel driver not accessible, permission problem. "
310	"Make sure that the current user has write permissions to "
311	"/dev/vboxdrv by adding him to the vboxusers groups. Don't "
312	"forget to logout to take the change effect");
313	#else
314	pszError = N_("VirtualBox kernel driver not accessible, permission problem");
315	#endif
316	break;
317	case VERR_VM_DRIVER_NOT_INSTALLED:
318	#ifdef __LINUX__
319	pszError = N_("VirtualBox kernel driver not installed. The vboxdrv kernel module "
320	"was either not loaded or /dev/vboxdrv was not created for some "
321	"reason. Re-setup the kernel module by executing "
322	"'/etc/init.d/vboxdrv setup' as root");
323	#else
324	pszError = N_("VirtualBox kernel driver not installed");
325	#endif
326	break;
327	case VERR_NO_MEMORY:
328	pszError = N_("VirtualBox support library out of memory");
329	break;
330	case VERR_VERSION_MISMATCH:
331	pszError = N_("VirtualBox support driver version mismatch");
332	break;
333	default:
334	pszError = N_("Unknown error initializing kernel driver (%Vrc)");
335	AssertMsgFailed(("Add error message for rc=%d (%Vrc)\n", rc, rc));
336	}
337	vmR3CallVMAtError(pfnVMAtError, pvUserVM, rc, RT_SRC_POS, pszError, rc);
338	}
339
340	LogFlow(("VMR3Create: returns %Vrc\n", rc));
341	return rc;
342	}
343
344
345	/**
346	* Wrapper for getting a correct va_list.
347	*/
348	static void vmR3CallVMAtError(PFNVMATERROR pfnVMAtError, void pvUser, int rc, RT_SRC_POS_DECL, const char pszError, ...)
349	{
350	va_list va;
351	va_start(va, pszError);
352	pfnVMAtError(NULL, pvUser, rc, RT_SRC_POS_ARGS, pszError, va);
353	va_end(va);
354	}
355
356
357	/**
358	* Initializes the VM.
359	*/
360	static int vmR3Create(PVM pVM, PFNVMATERROR pfnVMAtError, void pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void pvUserCFGM)
361	{
362	int rc = VINF_SUCCESS;
363
364	/* Register error callback if specified. */
365	if (pfnVMAtError)
366	rc = VMR3AtErrorRegister(pVM, pfnVMAtError, pvUserVM);
367	if (VBOX_SUCCESS(rc))
368	{
369	/*
370	* Init the configuration.
371	*/
372	rc = CFGMR3Init(pVM, pfnCFGMConstructor, pvUserCFGM);
373	if (VBOX_SUCCESS(rc))
374	{
375	/*
376	* If executing in fake suplib mode disable RR3 and RR0 in the config.
377	*/
378	const char *psz = getenv("VBOX_SUPLIB_FAKE");
379	if (psz && !strcmp(psz, "fake"))
380	{
381	CFGMR3RemoveValue(CFGMR3GetRoot(pVM), "RawR3Enabled");
382	CFGMR3InsertInteger(CFGMR3GetRoot(pVM), "RawR3Enabled", 0);
383	CFGMR3RemoveValue(CFGMR3GetRoot(pVM), "RawR0Enabled");
384	CFGMR3InsertInteger(CFGMR3GetRoot(pVM), "RawR0Enabled", 0);
385	}
386
387	/*
388	* Check if the required minimum of resources are available.
389	*/
390	/** @todo Check if the required minimum of resources are available. */
391	if (VBOX_SUCCESS(rc))
392	{
393	/*
394	* Init the Ring-3 components and do a round of relocations with 0 delta.
395	*/
396	rc = vmR3InitRing3(pVM);
397	if (VBOX_SUCCESS(rc))
398	{
399	VMR3Relocate(pVM, 0);
400	LogFlow(("Ring-3 init succeeded\n"));
401
402	/*
403	* Init the Ring-0 components.
404	*/
405	rc = vmR3InitRing0(pVM);
406	if (VBOX_SUCCESS(rc))
407	{
408	/* Relocate again, because some switcher fixups depends on R0 init results. */
409	VMR3Relocate(pVM, 0);
410
411	/*
412	* Init the tcp debugger console if we're building
413	* with debugger support.
414	*/
415	void *pvUser = NULL;
416	rc = DBGCTcpCreate(pVM, &pvUser);
417	if ( VBOX_SUCCESS(rc)
418	\|\| rc == VERR_NET_ADDRESS_IN_USE)
419	{
420	pVM->vm.s.pvDBGC = pvUser;
421
422	/*
423	* Init the Guest Context components.
424	*/
425	rc = vmR3InitGC(pVM);
426	if (VBOX_SUCCESS(rc))
427	{
428	/*
429	* Set the state and link into the global list.
430	*/
431	vmR3SetState(pVM, VMSTATE_CREATED);
432	pVM->pNext = g_pVMsHead;
433	g_pVMsHead = pVM;
434	return VINF_SUCCESS;
435	}
436	DBGCTcpTerminate(pVM, pVM->vm.s.pvDBGC);
437	pVM->vm.s.pvDBGC = NULL;
438	}
439	//..
440	}
441	//..
442	}
443	//..
444	}
445
446	/* Clean CFGM. */
447	int rc2 = CFGMR3Term(pVM);
448	AssertRC(rc2);
449	}
450	//..
451	}
452
453	LogFlow(("vmR3Create: returns %Vrc\n", rc));
454	return rc;
455	}
456
457
458
459	/**
460	* Initializes all R3 components of the VM
461	*/
462	static int vmR3InitRing3(PVM pVM)
463	{
464	int rc;
465
466	/*
467	* Init all R3 components, the order here might be important.
468	*/
469	rc = MMR3Init(pVM);
470	if (VBOX_SUCCESS(rc))
471	{
472	STAM_REG(pVM, &pVM->StatTotalInGC, STAMTYPE_PROFILE_ADV, "/PROF/VM/InGC", STAMUNIT_TICKS_PER_CALL, "Profiling the total time spent in GC.");
473	STAM_REG(pVM, &pVM->StatSwitcherToGC, STAMTYPE_PROFILE_ADV, "/PROF/VM/SwitchToGC", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
474	STAM_REG(pVM, &pVM->StatSwitcherToHC, STAMTYPE_PROFILE_ADV, "/PROF/VM/SwitchToHC", STAMUNIT_TICKS_PER_CALL, "Profiling switching to HC.");
475	STAM_REG(pVM, &pVM->vm.s.StatHaltYield, STAMTYPE_PROFILE_ADV, "/PROF/VM/Halt/Yield", STAMUNIT_TICKS_PER_CALL, "Profiling halted state yielding.");
476	STAM_REG(pVM, &pVM->vm.s.StatHaltBlock, STAMTYPE_PROFILE_ADV, "/PROF/VM/Halt/Block", STAMUNIT_TICKS_PER_CALL, "Profiling halted state blocking.");
477	STAM_REG(pVM, &pVM->vm.s.StatHaltTimers, STAMTYPE_PROFILE_ADV, "/PROF/VM/Halt/Timers", STAMUNIT_TICKS_PER_CALL, "Profiling halted state timer tasks.");
478	STAM_REG(pVM, &pVM->vm.s.StatHaltPoll, STAMTYPE_PROFILE_ADV, "/PROF/VM/Halt/Poll", STAMUNIT_TICKS_PER_CALL, "Profiling halted state poll tasks.");
479
480	STAM_REG(pVM, &pVM->StatSwitcherSaveRegs, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/SaveRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
481	STAM_REG(pVM, &pVM->StatSwitcherSysEnter, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/SysEnter", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
482	STAM_REG(pVM, &pVM->StatSwitcherDebug, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Debug", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
483	STAM_REG(pVM, &pVM->StatSwitcherCR0, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/CR0", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
484	STAM_REG(pVM, &pVM->StatSwitcherCR4, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/CR4", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
485	STAM_REG(pVM, &pVM->StatSwitcherLgdt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lgdt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
486	STAM_REG(pVM, &pVM->StatSwitcherLidt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lidt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
487	STAM_REG(pVM, &pVM->StatSwitcherLldt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lldt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
488	STAM_REG(pVM, &pVM->StatSwitcherTSS, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/TSS", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
489	STAM_REG(pVM, &pVM->StatSwitcherJmpCR3, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/JmpCR3", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
490	STAM_REG(pVM, &pVM->StatSwitcherRstrRegs, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/RstrRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
491
492	STAM_REG(pVM, &pVM->vm.s.StatReqAllocNew, STAMTYPE_COUNTER, "/VM/Req/AllocNew", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a new packet.");
493	STAM_REG(pVM, &pVM->vm.s.StatReqAllocRaces, STAMTYPE_COUNTER, "/VM/Req/AllocRaces", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc causing races.");
494	STAM_REG(pVM, &pVM->vm.s.StatReqAllocRecycled, STAMTYPE_COUNTER, "/VM/Req/AllocRecycled", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a recycled packet.");
495	STAM_REG(pVM, &pVM->vm.s.StatReqFree, STAMTYPE_COUNTER, "/VM/Req/Free", STAMUNIT_OCCURENCES, "Number of VMR3ReqFree calls.");
496	STAM_REG(pVM, &pVM->vm.s.StatReqFreeOverflow, STAMTYPE_COUNTER, "/VM/Req/FreeOverflow", STAMUNIT_OCCURENCES, "Number of times the request was actually freed.");
497
498	rc = CPUMR3Init(pVM);
499	if (VBOX_SUCCESS(rc))
500	{
501	rc = HWACCMR3Init(pVM);
502	if (VBOX_SUCCESS(rc))
503	{
504	rc = PGMR3Init(pVM);
505	if (VBOX_SUCCESS(rc))
506	{
507	rc = REMR3Init(pVM);
508	if (VBOX_SUCCESS(rc))
509	{
510	rc = MMR3InitPaging(pVM);
511	if (VBOX_SUCCESS(rc))
512	rc = TMR3Init(pVM);
513	if (VBOX_SUCCESS(rc))
514	{
515	rc = VMMR3Init(pVM);
516	if (VBOX_SUCCESS(rc))
517	{
518	rc = SELMR3Init(pVM);
519	if (VBOX_SUCCESS(rc))
520	{
521	rc = TRPMR3Init(pVM);
522	if (VBOX_SUCCESS(rc))
523	{
524	rc = CSAMR3Init(pVM);
525	if (VBOX_SUCCESS(rc))
526	{
527	rc = PATMR3Init(pVM);
528	if (VBOX_SUCCESS(rc))
529	{
530	rc = IOMR3Init(pVM);
531	if (VBOX_SUCCESS(rc))
532	{
533	rc = EMR3Init(pVM);
534	if (VBOX_SUCCESS(rc))
535	{
536	rc = DBGFR3Init(pVM);
537	if (VBOX_SUCCESS(rc))
538	{
539	rc = PDMR3Init(pVM);
540	if (VBOX_SUCCESS(rc))
541	{
542	rc = PGMR3InitDynMap(pVM);
543	if (VBOX_SUCCESS(rc))
544	rc = MMR3HyperInitFinalize(pVM);
545	if (VBOX_SUCCESS(rc))
546	rc = PATMR3InitFinalize(pVM);
547	if (VBOX_SUCCESS(rc))
548	rc = PGMR3InitFinalize(pVM);
549	if (VBOX_SUCCESS(rc))
550	rc = SELMR3InitFinalize(pVM);
551	if (VBOX_SUCCESS(rc))
552	rc = VMMR3InitFinalize(pVM);
553	if (VBOX_SUCCESS(rc))
554	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING3);
555	if (VBOX_SUCCESS(rc))
556	{
557	LogFlow(("vmR3InitRing3: returns %Vrc\n", VINF_SUCCESS));
558	return VINF_SUCCESS;
559	}
560	int rc2 = PDMR3Term(pVM);
561	AssertRC(rc2);
562	}
563	int rc2 = DBGFR3Term(pVM);
564	AssertRC(rc2);
565	}
566	int rc2 = EMR3Term(pVM);
567	AssertRC(rc2);
568	}
569	int rc2 = IOMR3Term(pVM);
570	AssertRC(rc2);
571	}
572	int rc2 = PATMR3Term(pVM);
573	AssertRC(rc2);
574	}
575	int rc2 = CSAMR3Term(pVM);
576	AssertRC(rc2);
577	}
578	int rc2 = TRPMR3Term(pVM);
579	AssertRC(rc2);
580	}
581	int rc2 = SELMR3Term(pVM);
582	AssertRC(rc2);
583	}
584	int rc2 = VMMR3Term(pVM);
585	AssertRC(rc2);
586	}
587	int rc2 = TMR3Term(pVM);
588	AssertRC(rc2);
589	}
590	int rc2 = REMR3Term(pVM);
591	AssertRC(rc2);
592	}
593	int rc2 = PGMR3Term(pVM);
594	AssertRC(rc2);
595	}
596	int rc2 = HWACCMR3Term(pVM);
597	AssertRC(rc2);
598	}
599	//int rc2 = CPUMR3Term(pVM);
600	//AssertRC(rc2);
601	}
602	/* MMR3Term is not called here because it'll kill the heap. */
603	}
604
605	LogFlow(("vmR3InitRing3: returns %Vrc\n", rc));
606	return rc;
607	}
608
609
610	/**
611	* Initializes all R0 components of the VM
612	*/
613	static int vmR3InitRing0(PVM pVM)
614	{
615	LogFlow(("vmR3InitRing0:\n"));
616
617	/*
618	* Check for FAKE suplib mode.
619	*/
620	int rc = VINF_SUCCESS;
621	const char *psz = getenv("VBOX_SUPLIB_FAKE");
622	if (!psz \|\| strcmp(psz, "fake"))
623	{
624	/*
625	* Call the VMMR0 component and let it do the init.
626	*/
627	rc = VMMR3InitR0(pVM);
628	}
629	else
630	Log(("vmR3InitRing0: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
631
632	/*
633	* Do notifications and return.
634	*/
635	if (VBOX_SUCCESS(rc))
636	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING0);
637	LogFlow(("vmR3InitRing0: returns %Vrc\n", rc));
638	return rc;
639	}
640
641
642	/**
643	* Initializes all GC components of the VM
644	*/
645	static int vmR3InitGC(PVM pVM)
646	{
647	LogFlow(("vmR3InitGC:\n"));
648
649	/*
650	* Check for FAKE suplib mode.
651	*/
652	int rc = VINF_SUCCESS;
653	const char *psz = getenv("VBOX_SUPLIB_FAKE");
654	if (!psz \|\| strcmp(psz, "fake"))
655	{
656	/*
657	* Call the VMMR0 component and let it do the init.
658	*/
659	rc = VMMR3InitGC(pVM);
660	}
661	else
662	Log(("vmR3InitGC: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
663
664	/*
665	* Do notifications and return.
666	*/
667	if (VBOX_SUCCESS(rc))
668	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_GC);
669	LogFlow(("vmR3InitGC: returns %Vrc\n", rc));
670	return rc;
671	}
672
673
674	/**
675	* Do init completed notifications.
676	* This notifications can fail.
677	*
678	* @param pVM The VM handle.
679	* @param enmWhat What's completed.
680	*/
681	static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat)
682	{
683
684	return VINF_SUCCESS;
685	}
686
687
688	/**
689	* Calls the relocation functions for all VMM components so they can update
690	* any GC pointers. When this function is called all the basic VM members
691	* have been updated and the actual memory relocation have been done
692	* by the PGM/MM.
693	*
694	* This is used both on init and on runtime relocations.
695	*
696	* @param pVM VM handle.
697	* @param offDelta Relocation delta relative to old location.
698	*/
699	VMR3DECL(void) VMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
700	{
701	LogFlow(("VMR3Relocate: offDelta=%VGv\n", offDelta));
702
703	/*
704	* The order here is very important!
705	*/
706	PGMR3Relocate(pVM, offDelta);
707	PDMR3LdrRelocate(pVM, offDelta);
708	PGMR3Relocate(pVM, 0); /* Repeat after PDM relocation. */
709	CPUMR3Relocate(pVM);
710	HWACCMR3Relocate(pVM);
711	SELMR3Relocate(pVM);
712	VMMR3Relocate(pVM, offDelta);
713	SELMR3Relocate(pVM); /* !hack! fix stack! */
714	TRPMR3Relocate(pVM, offDelta);
715	PATMR3Relocate(pVM);
716	CSAMR3Relocate(pVM, offDelta);
717	IOMR3Relocate(pVM, offDelta);
718	EMR3Relocate(pVM);
719	TMR3Relocate(pVM, offDelta);
720	DBGFR3Relocate(pVM, offDelta);
721	PDMR3Relocate(pVM, offDelta);
722	}
723
724
725
726	/**
727	* Power on the virtual machine.
728	*
729	* @returns 0 on success.
730	* @returns VBox error code on failure.
731	* @param pVM VM to power on.
732	* @thread Any thread.
733	* @vmstate Created
734	* @vmstateto Running
735	*/
736	VMR3DECL(int) VMR3PowerOn(PVM pVM)
737	{
738	LogFlow(("VMR3PowerOn: pVM=%p\n", pVM));
739
740	/*
741	* Validate input.
742	*/
743	if (!pVM)
744	{
745	AssertMsgFailed(("Invalid VM pointer\n"));
746	return VERR_INVALID_PARAMETER;
747	}
748
749	/*
750	* Request the operation in EMT.
751	*/
752	PVMREQ pReq;
753	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOn, 1, pVM);
754	if (VBOX_SUCCESS(rc))
755	{
756	rc = pReq->iStatus;
757	VMR3ReqFree(pReq);
758	}
759
760	LogFlow(("VMR3PowerOn: returns %Vrc\n", rc));
761	return rc;
762	}
763
764
765	/**
766	* Power on the virtual machine.
767	*
768	* @returns 0 on success.
769	* @returns VBox error code on failure.
770	* @param pVM VM to power on.
771	* @thread EMT
772	*/
773	static DECLCALLBACK(int) vmR3PowerOn(PVM pVM)
774	{
775	LogFlow(("vmR3PowerOn: pVM=%p\n", pVM));
776
777	/*
778	* Validate input.
779	*/
780	if (pVM->enmVMState != VMSTATE_CREATED)
781	{
782	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
783	return VERR_VM_INVALID_VM_STATE;
784	}
785
786	/*
787	* Change the state, notify the components and resume the execution.
788	*/
789	vmR3SetState(pVM, VMSTATE_RUNNING);
790	PDMR3PowerOn(pVM);
791
792	return VINF_SUCCESS;
793	}
794
795
796	/**
797	* Suspends a running VM.
798	*
799	* @returns 0 on success.
800	* @returns VBox error code on failure.
801	* @param pVM VM to suspend.
802	* @thread Any thread.
803	* @vmstate Running
804	* @vmstateto Suspended
805	*/
806	VMR3DECL(int) VMR3Suspend(PVM pVM)
807	{
808	LogFlow(("VMR3Suspend: pVM=%p\n", pVM));
809
810	/*
811	* Validate input.
812	*/
813	if (!pVM)
814	{
815	AssertMsgFailed(("Invalid VM pointer\n"));
816	return VERR_INVALID_PARAMETER;
817	}
818
819	/*
820	* Request the operation in EMT.
821	*/
822	PVMREQ pReq;
823	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Suspend, 1, pVM);
824	if (VBOX_SUCCESS(rc))
825	{
826	rc = pReq->iStatus;
827	VMR3ReqFree(pReq);
828	}
829
830	LogFlow(("VMR3Suspend: returns %Vrc\n", rc));
831	return rc;
832	}
833
834
835	/**
836	* Suspends a running VM and prevent state saving until the VM is resumed or stopped.
837	*
838	* @returns 0 on success.
839	* @returns VBox error code on failure.
840	* @param pVM VM to suspend.
841	* @thread Any thread.
842	* @vmstate Running
843	* @vmstateto Suspended
844	*/
845	VMR3DECL(int) VMR3SuspendNoSave(PVM pVM)
846	{
847	pVM->vm.s.fPreventSaveState = true;
848	return VMR3Suspend(pVM);
849	}
850
851	/**
852	* Suspends a running VM.
853	*
854	* @returns 0 on success.
855	* @returns VBox error code on failure.
856	* @param pVM VM to suspend.
857	* @thread EMT
858	*/
859	static DECLCALLBACK(int) vmR3Suspend(PVM pVM)
860	{
861	LogFlow(("vmR3Suspend: pVM=%p\n", pVM));
862
863	/*
864	* Validate input.
865	*/
866	if (pVM->enmVMState != VMSTATE_RUNNING)
867	{
868	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
869	return VERR_VM_INVALID_VM_STATE;
870	}
871
872	/*
873	* Change the state, notify the components and resume the execution.
874	*/
875	vmR3SetState(pVM, VMSTATE_SUSPENDED);
876	PDMR3Suspend(pVM);
877
878	return VINF_EM_SUSPEND;
879	}
880
881
882	/**
883	* Resume VM execution.
884	*
885	* @returns 0 on success.
886	* @returns VBox error code on failure.
887	* @param pVM The VM to resume.
888	* @thread Any thread.
889	* @vmstate Suspended
890	* @vmstateto Running
891	*/
892	VMR3DECL(int) VMR3Resume(PVM pVM)
893	{
894	LogFlow(("VMR3Resume: pVM=%p\n", pVM));
895
896	/*
897	* Validate input.
898	*/
899	if (!pVM)
900	{
901	AssertMsgFailed(("Invalid VM pointer\n"));
902	return VERR_INVALID_PARAMETER;
903	}
904
905	/*
906	* Request the operation in EMT.
907	*/
908	PVMREQ pReq;
909	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Resume, 1, pVM);
910	if (VBOX_SUCCESS(rc))
911	{
912	rc = pReq->iStatus;
913	VMR3ReqFree(pReq);
914	}
915
916	LogFlow(("VMR3Resume: returns %Vrc\n", rc));
917	return rc;
918	}
919
920
921	/**
922	* Resume VM execution.
923	*
924	* @returns 0 on success.
925	* @returns VBox error code on failure.
926	* @param pVM The VM to resume.
927	* @thread EMT
928	*/
929	static DECLCALLBACK(int) vmR3Resume(PVM pVM)
930	{
931	LogFlow(("vmR3Resume: pVM=%p\n", pVM));
932
933	/*
934	* Validate input.
935	*/
936	if (pVM->enmVMState != VMSTATE_SUSPENDED)
937	{
938	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
939	return VERR_VM_INVALID_VM_STATE;
940	}
941
942	/*
943	* Change the state, notify the components and resume the execution.
944	*/
945	pVM->vm.s.fPreventSaveState = false;
946	vmR3SetState(pVM, VMSTATE_RUNNING);
947	PDMR3Resume(pVM);
948
949	return VINF_EM_RESUME;
950	}
951
952
953	/**
954	* Save current VM state.
955	*
956	* To save and terminate the VM, the VM must be suspended before the call.
957	*
958	* @returns 0 on success.
959	* @returns VBox error code on failure.
960	* @param pVM VM which state should be saved.
961	* @param pszFilename Name of the save state file.
962	* @param pfnProgress Progress callback. Optional.
963	* @param pvUser User argument for the progress callback.
964	* @thread Any thread.
965	* @vmstate Suspended
966	* @vmstateto Unchanged state.
967	*/
968	VMR3DECL(int) VMR3Save(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
969	{
970	LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
971
972	/*
973	* Validate input.
974	*/
975	if (!pVM)
976	{
977	AssertMsgFailed(("Invalid VM pointer\n"));
978	return VERR_INVALID_PARAMETER;
979	}
980	if (!pszFilename)
981	{
982	AssertMsgFailed(("Must specify a filename to save the state to, wise guy!\n"));
983	return VERR_INVALID_PARAMETER;
984	}
985
986	/*
987	* Request the operation in EMT.
988	*/
989	PVMREQ pReq;
990	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Save, 4, pVM, pszFilename, pfnProgress, pvUser);
991	if (VBOX_SUCCESS(rc))
992	{
993	rc = pReq->iStatus;
994	VMR3ReqFree(pReq);
995	}
996
997	LogFlow(("VMR3Save: returns %Vrc\n", rc));
998	return rc;
999	}
1000
1001
1002	/**
1003	* Save current VM state.
1004	*
1005	* To save and terminate the VM, the VM must be suspended before the call.
1006	*
1007	* @returns 0 on success.
1008	* @returns VBox error code on failure.
1009	* @param pVM VM which state should be saved.
1010	* @param pszFilename Name of the save state file.
1011	* @param pfnProgress Progress callback. Optional.
1012	* @param pvUser User argument for the progress callback.
1013	* @thread EMT
1014	*/
1015	static DECLCALLBACK(int) vmR3Save(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
1016	{
1017	LogFlow(("vmR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1018
1019	/*
1020	* Validate input.
1021	*/
1022	if (pVM->enmVMState != VMSTATE_SUSPENDED)
1023	{
1024	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1025	return VERR_VM_INVALID_VM_STATE;
1026	}
1027
1028	/* If we are in an inconsistent state, then we don't allow state saving. */
1029	if (pVM->vm.s.fPreventSaveState)
1030	{
1031	LogRel(("VMM: vmR3Save: saving the VM state is not allowed at this moment\n"));
1032	return VERR_VM_SAVE_STATE_NOT_ALLOWED;
1033	}
1034
1035	/*
1036	* Change the state and perform the save.
1037	*/
1038	/** @todo implement progress support in SSM */
1039	vmR3SetState(pVM, VMSTATE_SAVING);
1040	int rc = SSMR3Save(pVM, pszFilename, SSMAFTER_CONTINUE, pfnProgress, pvUser);
1041	vmR3SetState(pVM, VMSTATE_SUSPENDED);
1042
1043	return rc;
1044	}
1045
1046
1047	/**
1048	* Loads a new VM state.
1049	*
1050	* To restore a saved state on VM startup, call this function and then
1051	* resume the VM instead of powering it on.
1052	*
1053	* @returns 0 on success.
1054	* @returns VBox error code on failure.
1055	* @param pVM VM which state should be saved.
1056	* @param pszFilename Name of the save state file.
1057	* @param pfnProgress Progress callback. Optional.
1058	* @param pvUser User argument for the progress callback.
1059	* @thread Any thread.
1060	* @vmstate Created, Suspended
1061	* @vmstateto Suspended
1062	*/
1063	VMR3DECL(int) VMR3Load(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
1064	{
1065	LogFlow(("VMR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1066
1067	/*
1068	* Validate input.
1069	*/
1070	if (!pVM)
1071	{
1072	AssertMsgFailed(("Invalid VM pointer\n"));
1073	return VERR_INVALID_PARAMETER;
1074	}
1075	if (!pszFilename)
1076	{
1077	AssertMsgFailed(("Must specify a filename to load the state from, wise guy!\n"));
1078	return VERR_INVALID_PARAMETER;
1079	}
1080
1081	/*
1082	* Request the operation in EMT.
1083	*/
1084	PVMREQ pReq;
1085	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
1086	if (VBOX_SUCCESS(rc))
1087	{
1088	rc = pReq->iStatus;
1089	VMR3ReqFree(pReq);
1090	}
1091
1092	LogFlow(("VMR3Load: returns %Vrc\n", rc));
1093	return rc;
1094	}
1095
1096
1097	/**
1098	* Loads a new VM state.
1099	*
1100	* To restore a saved state on VM startup, call this function and then
1101	* resume the VM instead of powering it on.
1102	*
1103	* @returns 0 on success.
1104	* @returns VBox error code on failure.
1105	* @param pVM VM which state should be saved.
1106	* @param pszFilename Name of the save state file.
1107	* @param pfnProgress Progress callback. Optional.
1108	* @param pvUser User argument for the progress callback.
1109	* @thread EMT.
1110	*/
1111	static DECLCALLBACK(int) vmR3Load(PVM pVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
1112	{
1113	LogFlow(("vmR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1114
1115	/*
1116	* Validate input.
1117	*/
1118	if ( pVM->enmVMState != VMSTATE_SUSPENDED
1119	&& pVM->enmVMState != VMSTATE_CREATED)
1120	{
1121	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1122	return VMSetError(pVM, VERR_VM_INVALID_VM_STATE, RT_SRC_POS, N_("Invalid VM state (%s) for restoring state from '%s'"),
1123	VMR3GetStateName(pVM->enmVMState), pszFilename);
1124	}
1125
1126	/*
1127	* Change the state and perform the load.
1128	*/
1129	vmR3SetState(pVM, VMSTATE_LOADING);
1130	int rc = SSMR3Load(pVM, pszFilename, SSMAFTER_RESUME, pfnProgress, pvUser);
1131	if (VBOX_SUCCESS(rc))
1132	{
1133	/* Not paranoia anymore; the saved guest might use different hypervisor selectors. We must call VMR3Relocate. */
1134	VMR3Relocate(pVM, 0);
1135	vmR3SetState(pVM, VMSTATE_SUSPENDED);
1136	}
1137	else
1138	{
1139	vmR3SetState(pVM, VMSTATE_LOAD_FAILURE);
1140	rc = VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to restore VM state from '%s' (%Vrc)"), pszFilename, rc);
1141	}
1142
1143	return rc;
1144	}
1145
1146
1147	/**
1148	* Power Off the VM.
1149	*
1150	* @returns 0 on success.
1151	* @returns VBox error code on failure.
1152	* @param pVM VM which should be destroyed.
1153	* @thread Any thread.
1154	* @vmstate Suspended, Running, Guru Mediation, Load Failure
1155	* @vmstateto Off
1156	*/
1157	VMR3DECL(int) VMR3PowerOff(PVM pVM)
1158	{
1159	LogFlow(("VMR3PowerOff: pVM=%p\n", pVM));
1160
1161	/*
1162	* Validate input.
1163	*/
1164	if (!pVM)
1165	{
1166	AssertMsgFailed(("Invalid VM pointer\n"));
1167	return VERR_INVALID_PARAMETER;
1168	}
1169
1170	/*
1171	* Request the operation in EMT.
1172	*/
1173	PVMREQ pReq;
1174	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOff, 1, pVM);
1175	if (VBOX_SUCCESS(rc))
1176	{
1177	rc = pReq->iStatus;
1178	VMR3ReqFree(pReq);
1179	}
1180
1181	LogFlow(("VMR3PowerOff: returns %Vrc\n", rc));
1182	return rc;
1183	}
1184
1185
1186	/**
1187	* Power Off the VM.
1188	*
1189	* @returns 0 on success.
1190	* @returns VBox error code on failure.
1191	* @param pVM VM which should be destroyed.
1192	* @thread EMT.
1193	*/
1194	static DECLCALLBACK(int) vmR3PowerOff(PVM pVM)
1195	{
1196	LogFlow(("vmR3PowerOff: pVM=%p\n", pVM));
1197
1198	/*
1199	* The Windows guest additions might have performed a VMMDevPowerState_PowerOff()
1200	* request which was not completed yet. Later, the Windows guest shuts down via
1201	* ACPI and we find the VMSTATE_OFF. Just ignore the second power-off request.
1202	*/
1203	/** @todo r=bird: We should find a proper solution to this problem. This is just a workaround.
1204	* Guest code should really run after we've entered VMSTATE_OFF really... */
1205	if (pVM->enmVMState == VMSTATE_OFF)
1206	return VINF_EM_OFF;
1207
1208	/*
1209	* Validate input.
1210	*/
1211	if ( pVM->enmVMState != VMSTATE_RUNNING
1212	&& pVM->enmVMState != VMSTATE_SUSPENDED
1213	&& pVM->enmVMState != VMSTATE_LOAD_FAILURE
1214	&& pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1215	{
1216	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1217	return VERR_VM_INVALID_VM_STATE;
1218	}
1219
1220	/*
1221	* For debugging purposes, we will log a summary of the guest state at this point.
1222	*/
1223	if (pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1224	{
1225	/** @todo make the state dumping at VMR3PowerOff optional. */
1226	RTLogRelPrintf("**************** Guest state at power off ****************\n");
1227	DBGFR3Info(pVM, "cpumguest", "verbose", DBGFR3InfoLogRelHlp());
1228	RTLogRelPrintf("***\n");
1229	DBGFR3Info(pVM, "mode", NULL, DBGFR3InfoLogRelHlp());
1230	RTLogRelPrintf("***\n");
1231	DBGFR3Info(pVM, "activetimers", NULL, DBGFR3InfoLogRelHlp());
1232	RTLogRelPrintf("***\n");
1233	DBGFR3Info(pVM, "gdt", NULL, DBGFR3InfoLogRelHlp());
1234	/** @todo dump guest call stack. */
1235	#if 1 // temporary while debugging #1589
1236	RTLogRelPrintf("***\n");
1237	DBGFR3Info(pVM, "pit", NULL, DBGFR3InfoLogRelHlp());
1238	//RTLogRelPrintf("***\n");
1239	//DBGFR3Info(pVM, "handlers", NULL, DBGFR3InfoLogRelHlp());
1240	uint32_t esp = CPUMGetGuestESP(pVM);
1241	if ( CPUMGetGuestSS(pVM) == 0
1242	&& esp < _64K)
1243	{
1244	RTLogRelPrintf("***\n"
1245	"ss:sp=0000:%04x ", esp);
1246	void *pv;
1247	int rc = PGMPhysGCPtr2HCPtr(pVM, esp, &pv);
1248	if (VBOX_SUCCESS(rc))
1249	{
1250	const uint8_t pb = (uint8_t )((uintptr_t)pv & ~(uintptr_t)0x3f);
1251	RTLogRelPrintf("pb=%p pv=%p\n"
1252	"%.*Rhxd\n", pb, pv,
1253	PAGE_SIZE - ((uintptr_t)pb & PAGE_OFFSET_MASK), pb);
1254	}
1255	else
1256	RTLogRelPrintf("rc=%Vrc\n", rc);
1257	/* grub ... */
1258	if (esp < 0x2000 && esp > 0x1fc0)
1259	{
1260	int rc = PGMPhysGCPtr2HCPtr(pVM, 0x8000, &pv);
1261	if (VBOX_SUCCESS(rc))
1262	RTLogRelPrintf("0000:8000 TO 0000:87ff: pv=%p\n"
1263	"%.*Rhxd\n", pv, 0x8000, pv);
1264	}
1265	/* microsoft cdrom hang ... */
1266	if (true)
1267	{
1268	int rc = PGMPhysGCPtr2HCPtr(pVM, 0x20000, &pv);
1269	if (VBOX_SUCCESS(rc))
1270	RTLogRelPrintf("2000:0000 TO 2000:01ff: pv=%p\n"
1271	"%.*Rhxd\n", pv, 0x200, pv);
1272	}
1273	}
1274	#endif
1275	#if 1 /* for debugging problems with the async GIP code on linux */
1276	if ( g_pSUPGlobalInfoPage
1277	&& g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_ASYNC_TSC)
1278	{
1279	RTLogRelPrintf("** Async GIP (the values should be somewhat similar) **\n");
1280	SUPGLOBALINFOPAGE GipCopy = *g_pSUPGlobalInfoPage;
1281	for (unsigned i = 0; i < RT_ELEMENTS(GipCopy.aCPUs); i++)
1282	if (GipCopy.aCPUs[i].u64CpuHz != 0 && GipCopy.aCPUs[i].u64CpuHz < _1T)
1283	RTLogRelPrintf("%#d: u64CpuHz=%RU64Hz u32TransactionId=%#x u64TSC=%RX64 u64NanoTS=%RX64\n",
1284	i,
1285	GipCopy.aCPUs[i].u64CpuHz,
1286	GipCopy.aCPUs[i].u32TransactionId,
1287	GipCopy.aCPUs[i].u64TSC,
1288	GipCopy.aCPUs[i].u64NanoTS);
1289	}
1290	#endif
1291	RTLogRelPrintf("************ End of Guest state at power off *************\n");
1292	}
1293
1294	/*
1295	* Change the state to OFF and notify the components.
1296	*/
1297	vmR3SetState(pVM, VMSTATE_OFF);
1298	PDMR3PowerOff(pVM);
1299
1300	return VINF_EM_OFF;
1301	}
1302
1303
1304	/**
1305	* Destroys the VM.
1306	* The VM must be powered off (or never really powered on) to call this function.
1307	* The VM handle is destroyed and can no longer be used up successful return.
1308	*
1309	* @returns 0 on success.
1310	* @returns VBox error code on failure.
1311	* @param pVM VM which should be destroyed.
1312	* @thread Any thread but the emulation thread.
1313	* @vmstate Off, Created
1314	* @vmstateto N/A
1315	*/
1316	VMR3DECL(int) VMR3Destroy(PVM pVM)
1317	{
1318	LogFlow(("VMR3Destroy: pVM=%p\n", pVM));
1319
1320	/*
1321	* Validate input.
1322	*/
1323	if (!pVM)
1324	return VERR_INVALID_PARAMETER;
1325	if ( pVM->enmVMState != VMSTATE_OFF
1326	&& pVM->enmVMState != VMSTATE_CREATED)
1327	{
1328	AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1329	return VERR_VM_INVALID_VM_STATE;
1330	}
1331
1332	/*
1333	* Unlink the VM and change it's state to destroying.
1334	*/
1335	/** @todo lock this when we start having multiple machines in a process... */
1336	PVM pPrev = NULL;
1337	PVM pCur = g_pVMsHead;
1338	while (pCur && pCur != pVM)
1339	{
1340	pPrev = pCur;
1341	pCur = pCur->pNext;
1342	}
1343	if (!pCur)
1344	{
1345	AssertMsgFailed(("pVM=%p is INVALID!\n", pVM));
1346	return VERR_INVALID_PARAMETER;
1347	}
1348	if (pPrev)
1349	pPrev->pNext = pCur->pNext;
1350	else
1351	g_pVMsHead = pCur->pNext;
1352
1353	vmR3SetState(pVM, VMSTATE_DESTROYING);
1354
1355
1356	/*
1357	* Notify registered at destruction listeners.
1358	* (That's the debugger console.)
1359	*/
1360	vmR3AtDtor(pVM);
1361
1362	pVM->pNext = g_pVMsHead;
1363	g_pVMsHead = pVM;
1364
1365	/*
1366	* If we are the EMT we'll delay the cleanup till later.
1367	*/
1368	if (VM_IS_EMT(pVM))
1369	{
1370	pVM->vm.s.fEMTDoesTheCleanup = true;
1371	VM_FF_SET(pVM, VM_FF_TERMINATE);
1372	}
1373	else
1374	{
1375	/*
1376	* Request EMT to do the larger part of the destruction.
1377	*/
1378	PVMREQ pReq = NULL;
1379	int rc = VMR3ReqCall(pVM, &pReq, 0, (PFNRT)vmR3Destroy, 1, pVM);
1380	while (rc == VERR_TIMEOUT)
1381	rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
1382	if (VBOX_SUCCESS(rc))
1383	rc = pReq->iStatus;
1384	VMR3ReqFree(pReq);
1385
1386	/*
1387	* Wait for the EMT thread to terminate.
1388	*/
1389	VM_FF_SET(pVM, VM_FF_TERMINATE);
1390	uint64_t u64Start = RTTimeMilliTS();
1391	do
1392	{
1393	VMR3NotifyFF(pVM, false);
1394	rc = RTThreadWait(pVM->ThreadEMT, 1000, NULL);
1395	} while ( RTTimeMilliTS() - u64Start < 30000 /* 30 sec */
1396	&& rc == VERR_TIMEOUT);
1397	AssertMsgRC(rc, ("EMT thread wait failed, rc=%Vrc\n", rc));
1398
1399	/*
1400	* Now do the final bit where the heap and VM structures are freed up.
1401	*/
1402	vmR3DestroyFinalBit(pVM);
1403	}
1404
1405	LogFlow(("VMR3Destroy: returns VINF_SUCCESS\n"));
1406	return VINF_SUCCESS;
1407	}
1408
1409
1410	/**
1411	* Internal destruction worker. This will do nearly all of the
1412	* job, including quitting the emulation thread.
1413	*
1414	* @returns VBox status.
1415	* @param pVM VM handle.
1416	*/
1417	DECLCALLBACK(int) vmR3Destroy(PVM pVM)
1418	{
1419	LogFlow(("vmR3Destroy: pVM=%p\n", pVM));
1420	VM_ASSERT_EMT(pVM);
1421
1422	/*
1423	* Dump statistics to the log.
1424	*/
1425	#if defined(VBOX_WITH_STATISTICS) \|\| defined(LOG_ENABLED)
1426	RTLogFlags(NULL, "nodisabled nobuffered");
1427	#endif
1428	#ifdef VBOX_WITH_STATISTICS
1429	STAMR3Dump(pVM, "*");
1430	#endif /* VBOX_WITH_STATISTICS */
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	static 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	/*
2568	* Make a copy of the message.
2569	*/
2570	vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, *pArgs);
2571
2572	/*
2573	* Call the at error callbacks.
2574	*/
2575	for (PVMATERROR pCur = pVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2576	{
2577	va_list va2;
2578	va_copy(va2, *pArgs);
2579	pCur->pfnAtError(pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
2580	va_end(va2);
2581	}
2582	}
2583
2584
2585	/**
2586	* Registers a VM runtime error callback.
2587	*
2588	* @returns VBox status code.
2589	* @param pVM The VM handle.
2590	* @param pfnAtRuntimeError Pointer to callback.
2591	* @param pvUser User argument.
2592	* @thread Any.
2593	*/
2594	VMR3DECL(int) VMR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2595	{
2596	LogFlow(("VMR3AtRuntimeErrorRegister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2597
2598	/*
2599	* Validate input.
2600	*/
2601	if (!pfnAtRuntimeError)
2602	{
2603	AssertMsgFailed(("callback is required\n"));
2604	return VERR_INVALID_PARAMETER;
2605	}
2606
2607	/*
2608	* Make sure we're in EMT (to avoid the logging).
2609	*/
2610	PVMREQ pReq;
2611	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorRegister, 3, pVM, pfnAtRuntimeError, pvUser);
2612	if (VBOX_FAILURE(rc))
2613	return rc;
2614	rc = pReq->iStatus;
2615	VMR3ReqFree(pReq);
2616
2617	LogFlow(("VMR3AtRuntimeErrorRegister: returns %Vrc\n", rc));
2618	return rc;
2619	}
2620
2621
2622	/**
2623	* Registers a VM runtime error callback.
2624	*
2625	* @returns VBox status code.
2626	* @param pVM The VM handle.
2627	* @param pfnAtRuntimeError Pointer to callback.
2628	* @param pvUser User argument.
2629	* @thread EMT
2630	*/
2631	static DECLCALLBACK(int) vmR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2632	{
2633	/*
2634	* Allocate a new record.
2635	*/
2636
2637	PVMATRUNTIMEERROR pNew = (PVMATRUNTIMEERROR)MMR3HeapAlloc(pVM, MM_TAG_VM, sizeof(*pNew));
2638	if (!pNew)
2639	return VERR_NO_MEMORY;
2640
2641	/* fill */
2642	pNew->pfnAtRuntimeError = pfnAtRuntimeError;
2643	pNew->pvUser = pvUser;
2644	pNew->pNext = NULL;
2645
2646	/* insert */
2647	*pVM->vm.s.ppAtRuntimeErrorNext = pNew;
2648	pVM->vm.s.ppAtRuntimeErrorNext = &pNew->pNext;
2649
2650	return VINF_SUCCESS;
2651	}
2652
2653
2654	/**
2655	* Deregisters a VM runtime error callback.
2656	*
2657	* @returns VBox status code.
2658	* @param pVM The VM handle.
2659	* @param pfnAtRuntimeError Pointer to callback.
2660	* @param pvUser User argument.
2661	* @thread Any.
2662	*/
2663	VMR3DECL(int) VMR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2664	{
2665	LogFlow(("VMR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2666
2667	/*
2668	* Validate input.
2669	*/
2670	if (!pfnAtRuntimeError)
2671	{
2672	AssertMsgFailed(("callback is required\n"));
2673	return VERR_INVALID_PARAMETER;
2674	}
2675
2676	/*
2677	* Make sure we're in EMT (to avoid the logging).
2678	*/
2679	PVMREQ pReq;
2680	int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorDeregister, 3, pVM, pfnAtRuntimeError, pvUser);
2681	if (VBOX_FAILURE(rc))
2682	return rc;
2683	rc = pReq->iStatus;
2684	VMR3ReqFree(pReq);
2685
2686	LogFlow(("VMR3AtRuntimeErrorDeregister: returns %Vrc\n", rc));
2687	return rc;
2688	}
2689
2690
2691	/**
2692	* Deregisters a VM runtime error callback.
2693	*
2694	* @returns VBox status code.
2695	* @param pVM The VM handle.
2696	* @param pfnAtRuntimeError Pointer to callback.
2697	* @param pvUser User argument.
2698	* @thread EMT
2699	*/
2700	static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2701	{
2702	LogFlow(("vmR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2703
2704	/*
2705	* Search the list for the entry.
2706	*/
2707	PVMATRUNTIMEERROR pPrev = NULL;
2708	PVMATRUNTIMEERROR pCur = pVM->vm.s.pAtRuntimeError;
2709	while ( pCur
2710	&& pCur->pfnAtRuntimeError == pfnAtRuntimeError
2711	&& pCur->pvUser == pvUser)
2712	{
2713	pPrev = pCur;
2714	pCur = pCur->pNext;
2715	}
2716	if (!pCur)
2717	{
2718	AssertMsgFailed(("pfnAtRuntimeError=%p was not found\n", pfnAtRuntimeError));
2719	return VERR_FILE_NOT_FOUND;
2720	}
2721
2722	/*
2723	* Unlink it.
2724	*/
2725	if (pPrev)
2726	{
2727	pPrev->pNext = pCur->pNext;
2728	if (!pCur->pNext)
2729	pVM->vm.s.ppAtRuntimeErrorNext = &pPrev->pNext;
2730	}
2731	else
2732	{
2733	pVM->vm.s.pAtRuntimeError = pCur->pNext;
2734	if (!pCur->pNext)
2735	pVM->vm.s.ppAtRuntimeErrorNext = &pVM->vm.s.pAtRuntimeError;
2736	}
2737
2738	/*
2739	* Free it.
2740	*/
2741	pCur->pfnAtRuntimeError = NULL;
2742	pCur->pNext = NULL;
2743	MMR3HeapFree(pCur);
2744
2745	return VINF_SUCCESS;
2746	}
2747
2748
2749	/**
2750	* Ellipsis to va_list wrapper for calling pfnAtRuntimeError.
2751	*/
2752	static void vmR3SetRuntimeErrorWorkerDoCall(PVM pVM, PVMATRUNTIMEERROR pCur, bool fFatal,
2753	const char *pszErrorID,
2754	const char *pszFormat, ...)
2755	{
2756	va_list va;
2757	va_start(va, pszFormat);
2758	pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va);
2759	va_end(va);
2760	}
2761
2762
2763	/**
2764	* This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2765	* The message is found in VMINT.
2766	*
2767	* @param pVM The VM handle.
2768	* @thread EMT.
2769	*/
2770	VMR3DECL(void) VMR3SetRuntimeErrorWorker(PVM pVM)
2771	{
2772	VM_ASSERT_EMT(pVM);
2773	AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetRuntimeErrorV! Contrats!\n"));
2774
2775	/*
2776	* Unpack the error (if we managed to format one).
2777	*/
2778	PVMRUNTIMEERROR pErr = pVM->vm.s.pRuntimeErrorR3;
2779	const char *pszErrorID = NULL;
2780	const char *pszMessage;
2781	bool fFatal = false;
2782	if (pErr)
2783	{
2784	AssertCompile(sizeof(const char) == sizeof(uint8_t));
2785	if (pErr->offErrorID)
2786	pszErrorID = (const char *)pErr + pErr->offErrorID;
2787	if (pErr->offMessage)
2788	pszMessage = (const char *)pErr + pErr->offMessage;
2789	else
2790	pszMessage = "No message!";
2791	fFatal = pErr->fFatal;
2792	}
2793	else
2794	pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2795
2796	/*
2797	* Call the at runtime error callbacks.
2798	*/
2799	for (PVMATRUNTIMEERROR pCur = pVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2800	vmR3SetRuntimeErrorWorkerDoCall(pVM, pCur, fFatal, pszErrorID, "%s", pszMessage);
2801	}
2802
2803
2804	/**
2805	* Worker which calls everyone listening to the VM runtime error messages.
2806	*
2807	* @param pVM The VM handle.
2808	* @param fFatal Whether it is a fatal error or not.
2809	* @param pszErrorID Error ID string.
2810	* @param pszFormat Format string.
2811	* @param pArgs Pointer to the format arguments.
2812	* @thread EMT
2813	*/
2814	DECLCALLBACK(void) vmR3SetRuntimeErrorV(PVM pVM, bool fFatal,
2815	const char *pszErrorID,
2816	const char pszFormat, va_list pArgs)
2817	{
2818	/*
2819	* Make a copy of the message.
2820	*/
2821	vmSetRuntimeErrorCopy(pVM, fFatal, pszErrorID, pszFormat, *pArgs);
2822
2823	/*
2824	* Call the at error callbacks.
2825	*/
2826	for (PVMATRUNTIMEERROR pCur = pVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2827	{
2828	va_list va2;
2829	va_copy(va2, *pArgs);
2830	pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va2);
2831	va_end(va2);
2832	}
2833	}
2834

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

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

Download in other formats: