VM.cpp@ 337

Last change on this file since 337 was 234, checked in by vboxsync, 18 years ago
VMM: Added support for runtime error notifications (VMSetRuntimeError and friends).
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 81.2 KB

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

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

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

Download in other formats: