VM.cpp@ 768

Last change on this file since 768 was 451, checked in by vboxsync, 18 years ago
drop the AMD64 protection.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 80.9 KB

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

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

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

Download in other formats: