VM.cpp@ 79995

Last change on this file since 79995 was 79995, checked in by vboxsync, 6 years ago
VMM: Started kicking out raw-mode and 32-bit host code. bugref:9517 bugref:9511
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 168.5 KB

Line
1	/* $Id: VM.cpp 79995 2019-07-26 10:04:11Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/** @page pg_vm VM API
19	*
20	* This is the encapsulating bit. It provides the APIs that Main and VBoxBFE
21	* use to create a VMM instance for running a guest in. It also provides
22	* facilities for queuing request for execution in EMT (serialization purposes
23	* mostly) and for reporting error back to the VMM user (Main/VBoxBFE).
24	*
25	*
26	* @section sec_vm_design Design Critique / Things To Do
27	*
28	* In hindsight this component is a big design mistake, all this stuff really
29	* belongs in the VMM component. It just seemed like a kind of ok idea at a
30	* time when the VMM bit was a kind of vague. 'VM' also happened to be the name
31	* of the per-VM instance structure (see vm.h), so it kind of made sense.
32	* However as it turned out, VMM(.cpp) is almost empty all it provides in ring-3
33	* is some minor functionally and some "routing" services.
34	*
35	* Fixing this is just a matter of some more or less straight forward
36	* refactoring, the question is just when someone will get to it. Moving the EMT
37	* would be a good start.
38	*
39	*/
40
41
42	/*********************************************************************************************************************************
43	* Header Files *
44	*********************************************************************************************************************************/
45	#define LOG_GROUP LOG_GROUP_VM
46	#include <VBox/vmm/cfgm.h>
47	#include <VBox/vmm/vmm.h>
48	#include <VBox/vmm/gvmm.h>
49	#include <VBox/vmm/mm.h>
50	#include <VBox/vmm/cpum.h>
51	#include <VBox/vmm/selm.h>
52	#include <VBox/vmm/trpm.h>
53	#include <VBox/vmm/dbgf.h>
54	#include <VBox/vmm/pgm.h>
55	#include <VBox/vmm/pdmapi.h>
56	#include <VBox/vmm/pdmdev.h>
57	#include <VBox/vmm/pdmcritsect.h>
58	#include <VBox/vmm/em.h>
59	#include <VBox/vmm/iem.h>
60	#ifdef VBOX_WITH_REM
61	# include <VBox/vmm/rem.h>
62	#endif
63	#include <VBox/vmm/nem.h>
64	#include <VBox/vmm/apic.h>
65	#include <VBox/vmm/tm.h>
66	#include <VBox/vmm/stam.h>
67	#include <VBox/vmm/patm.h>
68	#include <VBox/vmm/csam.h>
69	#include <VBox/vmm/iom.h>
70	#include <VBox/vmm/ssm.h>
71	#include <VBox/vmm/ftm.h>
72	#include <VBox/vmm/hm.h>
73	#include <VBox/vmm/gim.h>
74	#include "VMInternal.h"
75	#include <VBox/vmm/vm.h>
76	#include <VBox/vmm/uvm.h>
77
78	#include <VBox/sup.h>
79	#if defined(VBOX_WITH_DTRACE_R3) && !defined(VBOX_WITH_NATIVE_DTRACE)
80	# include <VBox/VBoxTpG.h>
81	#endif
82	#include <VBox/dbg.h>
83	#include <VBox/err.h>
84	#include <VBox/param.h>
85	#include <VBox/log.h>
86	#include <iprt/assert.h>
87	#include <iprt/alloc.h>
88	#include <iprt/asm.h>
89	#include <iprt/env.h>
90	#include <iprt/string.h>
91	#include <iprt/time.h>
92	#include <iprt/semaphore.h>
93	#include <iprt/thread.h>
94	#include <iprt/uuid.h>
95
96
97	/*********************************************************************************************************************************
98	* Internal Functions *
99	*********************************************************************************************************************************/
100	static int vmR3CreateUVM(uint32_t cCpus, PCVMM2USERMETHODS pVmm2UserMethods, PUVM *ppUVM);
101	static int vmR3CreateU(PUVM pUVM, uint32_t cCpus, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM);
102	static int vmR3ReadBaseConfig(PVM pVM, PUVM pUVM, uint32_t cCpus);
103	static int vmR3InitRing3(PVM pVM, PUVM pUVM);
104	static int vmR3InitRing0(PVM pVM);
105	#ifdef VBOX_WITH_RAW_MODE
106	static int vmR3InitRC(PVM pVM);
107	#endif
108	static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat);
109	static void vmR3DestroyUVM(PUVM pUVM, uint32_t cMilliesEMTWait);
110	static bool vmR3ValidateStateTransition(VMSTATE enmStateOld, VMSTATE enmStateNew);
111	static void vmR3DoAtState(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld);
112	static int vmR3TrySetState(PVM pVM, const char *pszWho, unsigned cTransitions, ...);
113	static void vmR3SetStateLocked(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld, bool fSetRatherThanClearFF);
114	static void vmR3SetState(PVM pVM, VMSTATE enmStateNew, VMSTATE enmStateOld);
115	static int vmR3SetErrorU(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7);
116
117
118	/**
119	* Creates a virtual machine by calling the supplied configuration constructor.
120	*
121	* On successful returned the VM is powered, i.e. VMR3PowerOn() should be
122	* called to start the execution.
123	*
124	* @returns 0 on success.
125	* @returns VBox error code on failure.
126	* @param cCpus Number of virtual CPUs for the new VM.
127	* @param pVmm2UserMethods An optional method table that the VMM can use
128	* to make the user perform various action, like
129	* for instance state saving.
130	* @param pfnVMAtError Pointer to callback function for setting VM
131	* errors. This was added as an implicit call to
132	* VMR3AtErrorRegister() since there is no way the
133	* caller can get to the VM handle early enough to
134	* do this on its own.
135	* This is called in the context of an EMT.
136	* @param pvUserVM The user argument passed to pfnVMAtError.
137	* @param pfnCFGMConstructor Pointer to callback function for constructing the VM configuration tree.
138	* This is called in the context of an EMT0.
139	* @param pvUserCFGM The user argument passed to pfnCFGMConstructor.
140	* @param ppVM Where to optionally store the 'handle' of the
141	* created VM.
142	* @param ppUVM Where to optionally store the user 'handle' of
143	* the created VM, this includes one reference as
144	* if VMR3RetainUVM() was called. The caller
145	* MUST remember to pass the returned value to
146	* VMR3ReleaseUVM() once done with the handle.
147	*/
148	VMMR3DECL(int) VMR3Create(uint32_t cCpus, PCVMM2USERMETHODS pVmm2UserMethods,
149	PFNVMATERROR pfnVMAtError, void *pvUserVM,
150	PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM,
151	PVM ppVM, PUVM ppUVM)
152	{
153	LogFlow(("VMR3Create: cCpus=%RU32 pVmm2UserMethods=%p pfnVMAtError=%p pvUserVM=%p pfnCFGMConstructor=%p pvUserCFGM=%p ppVM=%p ppUVM=%p\n",
154	cCpus, pVmm2UserMethods, pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM, ppVM, ppUVM));
155
156	if (pVmm2UserMethods)
157	{
158	AssertPtrReturn(pVmm2UserMethods, VERR_INVALID_POINTER);
159	AssertReturn(pVmm2UserMethods->u32Magic == VMM2USERMETHODS_MAGIC, VERR_INVALID_PARAMETER);
160	AssertReturn(pVmm2UserMethods->u32Version == VMM2USERMETHODS_VERSION, VERR_INVALID_PARAMETER);
161	AssertPtrNullReturn(pVmm2UserMethods->pfnSaveState, VERR_INVALID_POINTER);
162	AssertPtrNullReturn(pVmm2UserMethods->pfnNotifyEmtInit, VERR_INVALID_POINTER);
163	AssertPtrNullReturn(pVmm2UserMethods->pfnNotifyEmtTerm, VERR_INVALID_POINTER);
164	AssertPtrNullReturn(pVmm2UserMethods->pfnNotifyPdmtInit, VERR_INVALID_POINTER);
165	AssertPtrNullReturn(pVmm2UserMethods->pfnNotifyPdmtTerm, VERR_INVALID_POINTER);
166	AssertPtrNullReturn(pVmm2UserMethods->pfnNotifyResetTurnedIntoPowerOff, VERR_INVALID_POINTER);
167	AssertReturn(pVmm2UserMethods->u32EndMagic == VMM2USERMETHODS_MAGIC, VERR_INVALID_PARAMETER);
168	}
169	AssertPtrNullReturn(pfnVMAtError, VERR_INVALID_POINTER);
170	AssertPtrNullReturn(pfnCFGMConstructor, VERR_INVALID_POINTER);
171	AssertPtrNullReturn(ppVM, VERR_INVALID_POINTER);
172	AssertPtrNullReturn(ppUVM, VERR_INVALID_POINTER);
173	AssertReturn(ppVM \|\| ppUVM, VERR_INVALID_PARAMETER);
174
175	/*
176	* Validate input.
177	*/
178	AssertLogRelMsgReturn(cCpus > 0 && cCpus <= VMM_MAX_CPU_COUNT, ("%RU32\n", cCpus), VERR_TOO_MANY_CPUS);
179
180	/*
181	* Create the UVM so we can register the at-error callback
182	* and consolidate a bit of cleanup code.
183	*/
184	PUVM pUVM = NULL; /* shuts up gcc */
185	int rc = vmR3CreateUVM(cCpus, pVmm2UserMethods, &pUVM);
186	if (RT_FAILURE(rc))
187	return rc;
188	if (pfnVMAtError)
189	rc = VMR3AtErrorRegister(pUVM, pfnVMAtError, pvUserVM);
190	if (RT_SUCCESS(rc))
191	{
192	/*
193	* Initialize the support library creating the session for this VM.
194	*/
195	rc = SUPR3Init(&pUVM->vm.s.pSession);
196	if (RT_SUCCESS(rc))
197	{
198	#if defined(VBOX_WITH_DTRACE_R3) && !defined(VBOX_WITH_NATIVE_DTRACE)
199	/* Now that we've opened the device, we can register trace probes. */
200	static bool s_fRegisteredProbes = false;
201	if (ASMAtomicCmpXchgBool(&s_fRegisteredProbes, true, false))
202	SUPR3TracerRegisterModule(~(uintptr_t)0, "VBoxVMM", &g_VTGObjHeader, (uintptr_t)&g_VTGObjHeader,
203	SUP_TRACER_UMOD_FLAGS_SHARED);
204	#endif
205
206	/*
207	* Call vmR3CreateU in the EMT thread and wait for it to finish.
208	*
209	* Note! VMCPUID_ANY is used here because VMR3ReqQueueU would have trouble
210	* submitting a request to a specific VCPU without a pVM. So, to make
211	* sure init is running on EMT(0), vmR3EmulationThreadWithId makes sure
212	* that only EMT(0) is servicing VMCPUID_ANY requests when pVM is NULL.
213	*/
214	PVMREQ pReq;
215	rc = VMR3ReqCallU(pUVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS,
216	(PFNRT)vmR3CreateU, 4, pUVM, cCpus, pfnCFGMConstructor, pvUserCFGM);
217	if (RT_SUCCESS(rc))
218	{
219	rc = pReq->iStatus;
220	VMR3ReqFree(pReq);
221	if (RT_SUCCESS(rc))
222	{
223	/*
224	* Success!
225	*/
226	if (ppVM)
227	*ppVM = pUVM->pVM;
228	if (ppUVM)
229	{
230	VMR3RetainUVM(pUVM);
231	*ppUVM = pUVM;
232	}
233	LogFlow(("VMR3Create: returns VINF_SUCCESS (pVM=%p, pUVM=%p\n", pUVM->pVM, pUVM));
234	return VINF_SUCCESS;
235	}
236	}
237	else
238	AssertMsgFailed(("VMR3ReqCallU failed rc=%Rrc\n", rc));
239
240	/*
241	* An error occurred during VM creation. Set the error message directly
242	* using the initial callback, as the callback list might not exist yet.
243	*/
244	const char *pszError;
245	switch (rc)
246	{
247	case VERR_VMX_IN_VMX_ROOT_MODE:
248	#ifdef RT_OS_LINUX
249	pszError = N_("VirtualBox can't operate in VMX root mode. "
250	"Please disable the KVM kernel extension, recompile your kernel and reboot");
251	#else
252	pszError = N_("VirtualBox can't operate in VMX root mode. Please close all other virtualization programs.");
253	#endif
254	break;
255
256	#ifndef RT_OS_DARWIN
257	case VERR_HM_CONFIG_MISMATCH:
258	pszError = N_("VT-x/AMD-V is either not available on your host or disabled. "
259	"This hardware extension is required by the VM configuration");
260	break;
261	#endif
262
263	case VERR_SVM_IN_USE:
264	#ifdef RT_OS_LINUX
265	pszError = N_("VirtualBox can't enable the AMD-V extension. "
266	"Please disable the KVM kernel extension, recompile your kernel and reboot");
267	#else
268	pszError = N_("VirtualBox can't enable the AMD-V extension. Please close all other virtualization programs.");
269	#endif
270	break;
271
272	#ifdef RT_OS_LINUX
273	case VERR_SUPDRV_COMPONENT_NOT_FOUND:
274	pszError = N_("One of the kernel modules was not successfully loaded. Make sure "
275	"that VirtualBox is correctly installed, and if you are using EFI "
276	"Secure Boot that the modules are signed if necessary in the right "
277	"way for your host system. Then try to recompile and reload the "
278	"kernel modules by executing "
279	"'/sbin/vboxconfig' as root");
280	break;
281	#endif
282
283	case VERR_RAW_MODE_INVALID_SMP:
284	pszError = N_("VT-x/AMD-V is either not available on your host or disabled. "
285	"VirtualBox requires this hardware extension to emulate more than one "
286	"guest CPU");
287	break;
288
289	case VERR_SUPDRV_KERNEL_TOO_OLD_FOR_VTX:
290	#ifdef RT_OS_LINUX
291	pszError = N_("Because the host kernel is too old, VirtualBox cannot enable the VT-x "
292	"extension. Either upgrade your kernel to Linux 2.6.13 or later or disable "
293	"the VT-x extension in the VM settings. Note that without VT-x you have "
294	"to reduce the number of guest CPUs to one");
295	#else
296	pszError = N_("Because the host kernel is too old, VirtualBox cannot enable the VT-x "
297	"extension. Either upgrade your kernel or disable the VT-x extension in the "
298	"VM settings. Note that without VT-x you have to reduce the number of guest "
299	"CPUs to one");
300	#endif
301	break;
302
303	case VERR_PDM_DEVICE_NOT_FOUND:
304	pszError = N_("A virtual device is configured in the VM settings but the device "
305	"implementation is missing.\n"
306	"A possible reason for this error is a missing extension pack. Note "
307	"that as of VirtualBox 4.0, certain features (for example USB 2.0 "
308	"support and remote desktop) are only available from an 'extension "
309	"pack' which must be downloaded and installed separately");
310	break;
311
312	case VERR_PCI_PASSTHROUGH_NO_HM:
313	pszError = N_("PCI passthrough requires VT-x/AMD-V");
314	break;
315
316	case VERR_PCI_PASSTHROUGH_NO_NESTED_PAGING:
317	pszError = N_("PCI passthrough requires nested paging");
318	break;
319
320	default:
321	if (VMR3GetErrorCount(pUVM) == 0)
322	pszError = RTErrGetFull(rc);
323	else
324	pszError = NULL; /* already set. */
325	break;
326	}
327	if (pszError)
328	vmR3SetErrorU(pUVM, rc, RT_SRC_POS, pszError, rc);
329	}
330	else
331	{
332	/*
333	* An error occurred at support library initialization time (before the
334	* VM could be created). Set the error message directly using the
335	* initial callback, as the callback list doesn't exist yet.
336	*/
337	const char *pszError;
338	switch (rc)
339	{
340	case VERR_VM_DRIVER_LOAD_ERROR:
341	#ifdef RT_OS_LINUX
342	pszError = N_("VirtualBox kernel driver not loaded. The vboxdrv kernel module "
343	"was either not loaded, /dev/vboxdrv is not set up properly, "
344	"or you are using EFI Secure Boot and the module is not signed "
345	"in the right way for your system. If necessary, try setting up "
346	"the kernel module again by executing "
347	"'/sbin/vboxconfig' as root");
348	#else
349	pszError = N_("VirtualBox kernel driver not loaded");
350	#endif
351	break;
352	case VERR_VM_DRIVER_OPEN_ERROR:
353	pszError = N_("VirtualBox kernel driver cannot be opened");
354	break;
355	case VERR_VM_DRIVER_NOT_ACCESSIBLE:
356	#ifdef VBOX_WITH_HARDENING
357	/* This should only happen if the executable wasn't hardened - bad code/build. */
358	pszError = N_("VirtualBox kernel driver not accessible, permission problem. "
359	"Re-install VirtualBox. If you are building it yourself, you "
360	"should make sure it installed correctly and that the setuid "
361	"bit is set on the executables calling VMR3Create.");
362	#else
363	/* This should only happen when mixing builds or with the usual /dev/vboxdrv access issues. */
364	# if defined(RT_OS_DARWIN)
365	pszError = N_("VirtualBox KEXT is not accessible, permission problem. "
366	"If you have built VirtualBox yourself, make sure that you do not "
367	"have the vboxdrv KEXT from a different build or installation loaded.");
368	# elif defined(RT_OS_LINUX)
369	pszError = N_("VirtualBox kernel driver is not accessible, permission problem. "
370	"If you have built VirtualBox yourself, make sure that you do "
371	"not have the vboxdrv kernel module from a different build or "
372	"installation loaded. Also, make sure the vboxdrv udev rule gives "
373	"you the permission you need to access the device.");
374	# elif defined(RT_OS_WINDOWS)
375	pszError = N_("VirtualBox kernel driver is not accessible, permission problem.");
376	# else /* solaris, freebsd, ++. */
377	pszError = N_("VirtualBox kernel module is not accessible, permission problem. "
378	"If you have built VirtualBox yourself, make sure that you do "
379	"not have the vboxdrv kernel module from a different install loaded.");
380	# endif
381	#endif
382	break;
383	case VERR_INVALID_HANDLE: /** @todo track down and fix this error. */
384	case VERR_VM_DRIVER_NOT_INSTALLED:
385	#ifdef RT_OS_LINUX
386	pszError = N_("VirtualBox kernel driver not Installed. The vboxdrv kernel module "
387	"was either not loaded, /dev/vboxdrv is not set up properly, "
388	"or you are using EFI Secure Boot and the module is not signed "
389	"in the right way for your system. If necessary, try setting up "
390	"the kernel module again by executing "
391	"'/sbin/vboxconfig' as root");
392	#else
393	pszError = N_("VirtualBox kernel driver not installed");
394	#endif
395	break;
396	case VERR_NO_MEMORY:
397	pszError = N_("VirtualBox support library out of memory");
398	break;
399	case VERR_VERSION_MISMATCH:
400	case VERR_VM_DRIVER_VERSION_MISMATCH:
401	pszError = N_("The VirtualBox support driver which is running is from a different "
402	"version of VirtualBox. You can correct this by stopping all "
403	"running instances of VirtualBox and reinstalling the software.");
404	break;
405	default:
406	pszError = N_("Unknown error initializing kernel driver");
407	AssertMsgFailed(("Add error message for rc=%d (%Rrc)\n", rc, rc));
408	}
409	vmR3SetErrorU(pUVM, rc, RT_SRC_POS, pszError, rc);
410	}
411	}
412
413	/* cleanup */
414	vmR3DestroyUVM(pUVM, 2000);
415	LogFlow(("VMR3Create: returns %Rrc\n", rc));
416	return rc;
417	}
418
419
420	/**
421	* Creates the UVM.
422	*
423	* This will not initialize the support library even if vmR3DestroyUVM
424	* will terminate that.
425	*
426	* @returns VBox status code.
427	* @param cCpus Number of virtual CPUs
428	* @param pVmm2UserMethods Pointer to the optional VMM -> User method
429	* table.
430	* @param ppUVM Where to store the UVM pointer.
431	*/
432	static int vmR3CreateUVM(uint32_t cCpus, PCVMM2USERMETHODS pVmm2UserMethods, PUVM *ppUVM)
433	{
434	uint32_t i;
435
436	/*
437	* Create and initialize the UVM.
438	*/
439	PUVM pUVM = (PUVM)RTMemPageAllocZ(RT_UOFFSETOF_DYN(UVM, aCpus[cCpus]));
440	AssertReturn(pUVM, VERR_NO_MEMORY);
441	pUVM->u32Magic = UVM_MAGIC;
442	pUVM->cCpus = cCpus;
443	pUVM->pVmm2UserMethods = pVmm2UserMethods;
444
445	AssertCompile(sizeof(pUVM->vm.s) <= sizeof(pUVM->vm.padding));
446
447	pUVM->vm.s.cUvmRefs = 1;
448	pUVM->vm.s.ppAtStateNext = &pUVM->vm.s.pAtState;
449	pUVM->vm.s.ppAtErrorNext = &pUVM->vm.s.pAtError;
450	pUVM->vm.s.ppAtRuntimeErrorNext = &pUVM->vm.s.pAtRuntimeError;
451
452	pUVM->vm.s.enmHaltMethod = VMHALTMETHOD_BOOTSTRAP;
453	RTUuidClear(&pUVM->vm.s.Uuid);
454
455	/* Initialize the VMCPU array in the UVM. */
456	for (i = 0; i < cCpus; i++)
457	{
458	pUVM->aCpus[i].pUVM = pUVM;
459	pUVM->aCpus[i].idCpu = i;
460	}
461
462	/* Allocate a TLS entry to store the VMINTUSERPERVMCPU pointer. */
463	int rc = RTTlsAllocEx(&pUVM->vm.s.idxTLS, NULL);
464	AssertRC(rc);
465	if (RT_SUCCESS(rc))
466	{
467	/* Allocate a halt method event semaphore for each VCPU. */
468	for (i = 0; i < cCpus; i++)
469	pUVM->aCpus[i].vm.s.EventSemWait = NIL_RTSEMEVENT;
470	for (i = 0; i < cCpus; i++)
471	{
472	rc = RTSemEventCreate(&pUVM->aCpus[i].vm.s.EventSemWait);
473	if (RT_FAILURE(rc))
474	break;
475	}
476	if (RT_SUCCESS(rc))
477	{
478	rc = RTCritSectInit(&pUVM->vm.s.AtStateCritSect);
479	if (RT_SUCCESS(rc))
480	{
481	rc = RTCritSectInit(&pUVM->vm.s.AtErrorCritSect);
482	if (RT_SUCCESS(rc))
483	{
484	/*
485	* Init fundamental (sub-)components - STAM, MMR3Heap and PDMLdr.
486	*/
487	rc = PDMR3InitUVM(pUVM);
488	if (RT_SUCCESS(rc))
489	{
490	rc = STAMR3InitUVM(pUVM);
491	if (RT_SUCCESS(rc))
492	{
493	rc = MMR3InitUVM(pUVM);
494	if (RT_SUCCESS(rc))
495	{
496	/*
497	* Start the emulation threads for all VMCPUs.
498	*/
499	for (i = 0; i < cCpus; i++)
500	{
501	rc = RTThreadCreateF(&pUVM->aCpus[i].vm.s.ThreadEMT, vmR3EmulationThread, &pUVM->aCpus[i],
502	_1M, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE,
503	cCpus > 1 ? "EMT-%u" : "EMT", i);
504	if (RT_FAILURE(rc))
505	break;
506
507	pUVM->aCpus[i].vm.s.NativeThreadEMT = RTThreadGetNative(pUVM->aCpus[i].vm.s.ThreadEMT);
508	}
509
510	if (RT_SUCCESS(rc))
511	{
512	*ppUVM = pUVM;
513	return VINF_SUCCESS;
514	}
515
516	/* bail out. */
517	while (i-- > 0)
518	{
519	/** @todo rainy day: terminate the EMTs. */
520	}
521	MMR3TermUVM(pUVM);
522	}
523	STAMR3TermUVM(pUVM);
524	}
525	PDMR3TermUVM(pUVM);
526	}
527	RTCritSectDelete(&pUVM->vm.s.AtErrorCritSect);
528	}
529	RTCritSectDelete(&pUVM->vm.s.AtStateCritSect);
530	}
531	}
532	for (i = 0; i < cCpus; i++)
533	{
534	RTSemEventDestroy(pUVM->aCpus[i].vm.s.EventSemWait);
535	pUVM->aCpus[i].vm.s.EventSemWait = NIL_RTSEMEVENT;
536	}
537	RTTlsFree(pUVM->vm.s.idxTLS);
538	}
539	RTMemPageFree(pUVM, RT_UOFFSETOF_DYN(UVM, aCpus[pUVM->cCpus]));
540	return rc;
541	}
542
543
544	/**
545	* Creates and initializes the VM.
546	*
547	* @thread EMT
548	*/
549	static int vmR3CreateU(PUVM pUVM, uint32_t cCpus, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM)
550	{
551	#if (defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)) && !defined(VBOX_WITH_OLD_CPU_SUPPORT)
552	/*
553	* Require SSE2 to be present (already checked for in supdrv, so we
554	* shouldn't ever really get here).
555	*/
556	if (!(ASMCpuId_EDX(1) & X86_CPUID_FEATURE_EDX_SSE2))
557	{
558	LogRel(("vboxdrv: Requires SSE2 (cpuid(0).EDX=%#x)\n", ASMCpuId_EDX(1)));
559	return VERR_UNSUPPORTED_CPU;
560	}
561	#endif
562
563	/*
564	* Load the VMMR0.r0 module so that we can call GVMMR0CreateVM.
565	*/
566	int rc = PDMR3LdrLoadVMMR0U(pUVM);
567	if (RT_FAILURE(rc))
568	{
569	/** @todo we need a cleaner solution for this (VERR_VMX_IN_VMX_ROOT_MODE).
570	* bird: what about moving the message down here? Main picks the first message, right? */
571	if (rc == VERR_VMX_IN_VMX_ROOT_MODE)
572	return rc; /* proper error message set later on */
573	return vmR3SetErrorU(pUVM, rc, RT_SRC_POS, N_("Failed to load VMMR0.r0"));
574	}
575
576	/*
577	* Request GVMM to create a new VM for us.
578	*/
579	GVMMCREATEVMREQ CreateVMReq;
580	CreateVMReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
581	CreateVMReq.Hdr.cbReq = sizeof(CreateVMReq);
582	CreateVMReq.pSession = pUVM->vm.s.pSession;
583	CreateVMReq.pVMR0 = NIL_RTR0PTR;
584	CreateVMReq.pVMR3 = NULL;
585	CreateVMReq.cCpus = cCpus;
586	rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_GVMM_CREATE_VM, 0, &CreateVMReq.Hdr);
587	if (RT_SUCCESS(rc))
588	{
589	PVM pVM = pUVM->pVM = CreateVMReq.pVMR3;
590	AssertRelease(VALID_PTR(pVM));
591	AssertRelease(pVM->pVMR0 == CreateVMReq.pVMR0);
592	AssertRelease(pVM->pSession == pUVM->vm.s.pSession);
593	AssertRelease(pVM->cCpus == cCpus);
594	AssertRelease(pVM->uCpuExecutionCap == 100);
595	#ifdef VBOX_WITH_RAW_MODE
596	AssertRelease(pVM->offVMCPU == RT_UOFFSETOF(VM, aCpus));
597	#endif
598	AssertCompileMemberAlignment(VM, cpum, 64);
599	AssertCompileMemberAlignment(VM, tm, 64);
600	AssertCompileMemberAlignment(VM, aCpus, PAGE_SIZE);
601
602	Log(("VMR3Create: Created pUVM=%p pVM=%p pVMR0=%p hSelf=%#x cCpus=%RU32\n",
603	pUVM, pVM, pVM->pVMR0, pVM->hSelf, pVM->cCpus));
604
605	/*
606	* Initialize the VM structure and our internal data (VMINT).
607	*/
608	pVM->pUVM = pUVM;
609
610	for (VMCPUID i = 0; i < pVM->cCpus; i++)
611	{
612	pVM->aCpus[i].pUVCpu = &pUVM->aCpus[i];
613	pVM->aCpus[i].idCpu = i;
614	pVM->aCpus[i].hNativeThread = pUVM->aCpus[i].vm.s.NativeThreadEMT;
615	Assert(pVM->aCpus[i].hNativeThread != NIL_RTNATIVETHREAD);
616	/* hNativeThreadR0 is initialized on EMT registration. */
617	pUVM->aCpus[i].pVCpu = &pVM->aCpus[i];
618	pUVM->aCpus[i].pVM = pVM;
619	}
620
621
622	/*
623	* Init the configuration.
624	*/
625	rc = CFGMR3Init(pVM, pfnCFGMConstructor, pvUserCFGM);
626	if (RT_SUCCESS(rc))
627	{
628	rc = vmR3ReadBaseConfig(pVM, pUVM, cCpus);
629	if (RT_SUCCESS(rc))
630	{
631	/*
632	* Init the ring-3 components and ring-3 per cpu data, finishing it off
633	* by a relocation round (intermediate context finalization will do this).
634	*/
635	rc = vmR3InitRing3(pVM, pUVM);
636	if (RT_SUCCESS(rc))
637	{
638	rc = PGMR3FinalizeMappings(pVM);
639	if (RT_SUCCESS(rc))
640	{
641
642	LogFlow(("Ring-3 init succeeded\n"));
643
644	/*
645	* Init the Ring-0 components.
646	*/
647	rc = vmR3InitRing0(pVM);
648	if (RT_SUCCESS(rc))
649	{
650	/* Relocate again, because some switcher fixups depends on R0 init results. */
651	VMR3Relocate(pVM, 0 /* offDelta */);
652
653	#ifdef VBOX_WITH_DEBUGGER
654	/*
655	* Init the tcp debugger console if we're building
656	* with debugger support.
657	*/
658	void *pvUser = NULL;
659	rc = DBGCTcpCreate(pUVM, &pvUser);
660	if ( RT_SUCCESS(rc)
661	\|\| rc == VERR_NET_ADDRESS_IN_USE)
662	{
663	pUVM->vm.s.pvDBGC = pvUser;
664	#endif
665	/*
666	* Init the Raw-Mode Context components.
667	*/
668	#ifdef VBOX_WITH_RAW_MODE
669	rc = vmR3InitRC(pVM);
670	if (RT_SUCCESS(rc))
671	#endif
672	{
673	/*
674	* Now we can safely set the VM halt method to default.
675	*/
676	rc = vmR3SetHaltMethodU(pUVM, VMHALTMETHOD_DEFAULT);
677	if (RT_SUCCESS(rc))
678	{
679	/*
680	* Set the state and we're done.
681	*/
682	vmR3SetState(pVM, VMSTATE_CREATED, VMSTATE_CREATING);
683	return VINF_SUCCESS;
684	}
685	}
686	#ifdef VBOX_WITH_DEBUGGER
687	DBGCTcpTerminate(pUVM, pUVM->vm.s.pvDBGC);
688	pUVM->vm.s.pvDBGC = NULL;
689	}
690	#endif
691	//..
692	}
693	}
694	vmR3Destroy(pVM);
695	}
696	}
697	//..
698
699	/* Clean CFGM. */
700	int rc2 = CFGMR3Term(pVM);
701	AssertRC(rc2);
702	}
703
704	/*
705	* Do automatic cleanups while the VM structure is still alive and all
706	* references to it are still working.
707	*/
708	PDMR3CritSectBothTerm(pVM);
709
710	/*
711	* Drop all references to VM and the VMCPU structures, then
712	* tell GVMM to destroy the VM.
713	*/
714	pUVM->pVM = NULL;
715	for (VMCPUID i = 0; i < pUVM->cCpus; i++)
716	{
717	pUVM->aCpus[i].pVM = NULL;
718	pUVM->aCpus[i].pVCpu = NULL;
719	}
720	Assert(pUVM->vm.s.enmHaltMethod == VMHALTMETHOD_BOOTSTRAP);
721
722	if (pUVM->cCpus > 1)
723	{
724	/* Poke the other EMTs since they may have stale pVM and pVCpu references
725	on the stack (see VMR3WaitU for instance) if they've been awakened after
726	VM creation. */
727	for (VMCPUID i = 1; i < pUVM->cCpus; i++)
728	VMR3NotifyCpuFFU(&pUVM->aCpus[i], 0);
729	RTThreadSleep(RT_MIN(100 + 25 (pUVM->cCpus - 1), 500)); / very sophisticated */
730	}
731
732	int rc2 = SUPR3CallVMMR0Ex(CreateVMReq.pVMR0, 0 /idCpu/, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
733	AssertRC(rc2);
734	}
735	else
736	vmR3SetErrorU(pUVM, rc, RT_SRC_POS, N_("VM creation failed (GVMM)"));
737
738	LogFlow(("vmR3CreateU: returns %Rrc\n", rc));
739	return rc;
740	}
741
742
743	/**
744	* Reads the base configuation from CFGM.
745	*
746	* @returns VBox status code.
747	* @param pVM The cross context VM structure.
748	* @param pUVM The user mode VM structure.
749	* @param cCpus The CPU count given to VMR3Create.
750	*/
751	static int vmR3ReadBaseConfig(PVM pVM, PUVM pUVM, uint32_t cCpus)
752	{
753	int rc;
754	PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
755
756	/*
757	* If executing in fake suplib mode disable RR3 and RR0 in the config.
758	*/
759	const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
760	if (psz && !strcmp(psz, "fake"))
761	{
762	CFGMR3RemoveValue(pRoot, "RawR3Enabled");
763	CFGMR3InsertInteger(pRoot, "RawR3Enabled", 0);
764	CFGMR3RemoveValue(pRoot, "RawR0Enabled");
765	CFGMR3InsertInteger(pRoot, "RawR0Enabled", 0);
766	}
767
768	/*
769	* Base EM and HM config properties.
770	*/
771	/** @todo We don't need to read any of this here. The relevant modules reads
772	* them again and will be in a better position to set them correctly. */
773	Assert(pVM->fRecompileUser == false); /* ASSUMES all zeros at this point */
774	bool fEnabled;
775	rc = CFGMR3QueryBoolDef(pRoot, "RawR3Enabled", &fEnabled, false); AssertRCReturn(rc, rc);
776	pVM->fRecompileUser = !fEnabled;
777	rc = CFGMR3QueryBoolDef(pRoot, "RawR0Enabled", &fEnabled, false); AssertRCReturn(rc, rc);
778	pVM->fRecompileSupervisor = !fEnabled;
779	#ifdef VBOX_WITH_RAW_MODE
780	# ifdef VBOX_WITH_RAW_RING1
781	rc = CFGMR3QueryBoolDef(pRoot, "RawR1Enabled", &pVM->fRawRing1Enabled, false);
782	# endif
783	rc = CFGMR3QueryBoolDef(pRoot, "PATMEnabled", &pVM->fPATMEnabled, true); AssertRCReturn(rc, rc);
784	rc = CFGMR3QueryBoolDef(pRoot, "CSAMEnabled", &pVM->fCSAMEnabled, true); AssertRCReturn(rc, rc);
785	rc = CFGMR3QueryBoolDef(pRoot, "HMEnabled", &pVM->fHMEnabled, true); AssertRCReturn(rc, rc);
786	#else
787	pVM->fHMEnabled = true;
788	#endif
789	LogRel(("VM: fHMEnabled=%RTbool (configured) fRecompileUser=%RTbool fRecompileSupervisor=%RTbool\n"
790	"VM: fRawRing1Enabled=%RTbool CSAM=%RTbool PATM=%RTbool\n",
791	pVM->fHMEnabled, pVM->fRecompileUser, pVM->fRecompileSupervisor,
792	pVM->fRawRing1Enabled, pVM->fCSAMEnabled, pVM->fPATMEnabled));
793
794	/*
795	* Make sure the CPU count in the config data matches.
796	*/
797	uint32_t cCPUsCfg;
798	rc = CFGMR3QueryU32Def(pRoot, "NumCPUs", &cCPUsCfg, 1);
799	AssertLogRelMsgRCReturn(rc, ("Configuration error: Querying \"NumCPUs\" as integer failed, rc=%Rrc\n", rc), rc);
800	AssertLogRelMsgReturn(cCPUsCfg == cCpus,
801	("Configuration error: \"NumCPUs\"=%RU32 and VMR3Create::cCpus=%RU32 does not match!\n",
802	cCPUsCfg, cCpus),
803	VERR_INVALID_PARAMETER);
804
805	/*
806	* Get the CPU execution cap.
807	*/
808	rc = CFGMR3QueryU32Def(pRoot, "CpuExecutionCap", &pVM->uCpuExecutionCap, 100);
809	AssertLogRelMsgRCReturn(rc, ("Configuration error: Querying \"CpuExecutionCap\" as integer failed, rc=%Rrc\n", rc), rc);
810
811	/*
812	* Get the VM name and UUID.
813	*/
814	rc = CFGMR3QueryStringAllocDef(pRoot, "Name", &pUVM->vm.s.pszName, "<unknown>");
815	AssertLogRelMsgRCReturn(rc, ("Configuration error: Querying \"Name\" failed, rc=%Rrc\n", rc), rc);
816
817	rc = CFGMR3QueryBytes(pRoot, "UUID", &pUVM->vm.s.Uuid, sizeof(pUVM->vm.s.Uuid));
818	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
819	rc = VINF_SUCCESS;
820	AssertLogRelMsgRCReturn(rc, ("Configuration error: Querying \"UUID\" failed, rc=%Rrc\n", rc), rc);
821
822	rc = CFGMR3QueryBoolDef(pRoot, "PowerOffInsteadOfReset", &pVM->vm.s.fPowerOffInsteadOfReset, false);
823	AssertLogRelMsgRCReturn(rc, ("Configuration error: Querying \"PowerOffInsteadOfReset\" failed, rc=%Rrc\n", rc), rc);
824
825	return VINF_SUCCESS;
826	}
827
828
829	/**
830	* Register the calling EMT with GVM.
831	*
832	* @returns VBox status code.
833	* @param pVM The cross context VM structure.
834	* @param idCpu The Virtual CPU ID.
835	*/
836	static DECLCALLBACK(int) vmR3RegisterEMT(PVM pVM, VMCPUID idCpu)
837	{
838	Assert(VMMGetCpuId(pVM) == idCpu);
839	int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, idCpu, VMMR0_DO_GVMM_REGISTER_VMCPU, 0, NULL);
840	if (RT_FAILURE(rc))
841	LogRel(("idCpu=%u rc=%Rrc\n", idCpu, rc));
842	return rc;
843	}
844
845
846	/**
847	* Initializes all R3 components of the VM
848	*/
849	static int vmR3InitRing3(PVM pVM, PUVM pUVM)
850	{
851	int rc;
852
853	/*
854	* Register the other EMTs with GVM.
855	*/
856	for (VMCPUID idCpu = 1; idCpu < pVM->cCpus; idCpu++)
857	{
858	rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)vmR3RegisterEMT, 2, pVM, idCpu);
859	if (RT_FAILURE(rc))
860	return rc;
861	}
862
863	/*
864	* Register statistics.
865	*/
866	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
867	{
868	rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltYield, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_NS_PER_CALL, "Profiling halted state yielding.", "/PROF/CPU%d/VM/Halt/Yield", idCpu);
869	AssertRC(rc);
870	rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltBlock, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_NS_PER_CALL, "Profiling halted state blocking.", "/PROF/CPU%d/VM/Halt/Block", idCpu);
871	AssertRC(rc);
872	rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltBlockOverslept, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_NS_PER_CALL, "Time wasted by blocking too long.", "/PROF/CPU%d/VM/Halt/BlockOverslept", idCpu);
873	AssertRC(rc);
874	rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltBlockInsomnia, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_NS_PER_CALL, "Time slept when returning to early.","/PROF/CPU%d/VM/Halt/BlockInsomnia", idCpu);
875	AssertRC(rc);
876	rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltBlockOnTime, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_NS_PER_CALL, "Time slept on time.", "/PROF/CPU%d/VM/Halt/BlockOnTime", idCpu);
877	AssertRC(rc);
878	rc = STAMR3RegisterF(pVM, &pUVM->aCpus[idCpu].vm.s.StatHaltTimers, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_NS_PER_CALL, "Profiling halted state timer tasks.", "/PROF/CPU%d/VM/Halt/Timers", idCpu);
879	AssertRC(rc);
880	}
881
882	STAM_REG(pVM, &pUVM->vm.s.StatReqAllocNew, STAMTYPE_COUNTER, "/VM/Req/AllocNew", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a new packet.");
883	STAM_REG(pVM, &pUVM->vm.s.StatReqAllocRaces, STAMTYPE_COUNTER, "/VM/Req/AllocRaces", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc causing races.");
884	STAM_REG(pVM, &pUVM->vm.s.StatReqAllocRecycled, STAMTYPE_COUNTER, "/VM/Req/AllocRecycled", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a recycled packet.");
885	STAM_REG(pVM, &pUVM->vm.s.StatReqFree, STAMTYPE_COUNTER, "/VM/Req/Free", STAMUNIT_OCCURENCES, "Number of VMR3ReqFree calls.");
886	STAM_REG(pVM, &pUVM->vm.s.StatReqFreeOverflow, STAMTYPE_COUNTER, "/VM/Req/FreeOverflow", STAMUNIT_OCCURENCES, "Number of times the request was actually freed.");
887	STAM_REG(pVM, &pUVM->vm.s.StatReqProcessed, STAMTYPE_COUNTER, "/VM/Req/Processed", STAMUNIT_OCCURENCES, "Number of processed requests (any queue).");
888	STAM_REG(pVM, &pUVM->vm.s.StatReqMoreThan1, STAMTYPE_COUNTER, "/VM/Req/MoreThan1", STAMUNIT_OCCURENCES, "Number of times there are more than one request on the queue when processing it.");
889	STAM_REG(pVM, &pUVM->vm.s.StatReqPushBackRaces, STAMTYPE_COUNTER, "/VM/Req/PushBackRaces", STAMUNIT_OCCURENCES, "Number of push back races.");
890
891	/*
892	* Init all R3 components, the order here might be important.
893	* NEM and HM shall be initialized first!
894	*/
895	Assert(pVM->bMainExecutionEngine == VM_EXEC_ENGINE_NOT_SET);
896	rc = NEMR3InitConfig(pVM);
897	if (RT_SUCCESS(rc))
898	rc = HMR3Init(pVM);
899	if (RT_SUCCESS(rc))
900	{
901	ASMCompilerBarrier(); /* HMR3Init will have modified bMainExecutionEngine */
902	#ifdef VBOX_WITH_RAW_MODE
903	Assert( pVM->bMainExecutionEngine == VM_EXEC_ENGINE_HW_VIRT
904	\|\| pVM->bMainExecutionEngine == VM_EXEC_ENGINE_RAW_MODE
905	\|\| pVM->bMainExecutionEngine == VM_EXEC_ENGINE_NATIVE_API);
906	#else
907	Assert( pVM->bMainExecutionEngine == VM_EXEC_ENGINE_HW_VIRT
908	\|\| pVM->bMainExecutionEngine == VM_EXEC_ENGINE_NATIVE_API);
909	#endif
910	rc = MMR3Init(pVM);
911	if (RT_SUCCESS(rc))
912	{
913	rc = CPUMR3Init(pVM);
914	if (RT_SUCCESS(rc))
915	{
916	rc = NEMR3InitAfterCPUM(pVM);
917	if (RT_SUCCESS(rc))
918	rc = PGMR3Init(pVM);
919	if (RT_SUCCESS(rc))
920	{
921	#ifdef VBOX_WITH_REM
922	rc = REMR3Init(pVM);
923	#endif
924	if (RT_SUCCESS(rc))
925	{
926	rc = MMR3InitPaging(pVM);
927	if (RT_SUCCESS(rc))
928	rc = TMR3Init(pVM);
929	if (RT_SUCCESS(rc))
930	{
931	rc = FTMR3Init(pVM);
932	if (RT_SUCCESS(rc))
933	{
934	rc = VMMR3Init(pVM);
935	if (RT_SUCCESS(rc))
936	{
937	rc = SELMR3Init(pVM);
938	if (RT_SUCCESS(rc))
939	{
940	rc = TRPMR3Init(pVM);
941	if (RT_SUCCESS(rc))
942	{
943	#ifdef VBOX_WITH_RAW_MODE
944	rc = CSAMR3Init(pVM);
945	if (RT_SUCCESS(rc))
946	{
947	rc = PATMR3Init(pVM);
948	if (RT_SUCCESS(rc))
949	{
950	#endif
951	rc = IOMR3Init(pVM);
952	if (RT_SUCCESS(rc))
953	{
954	rc = EMR3Init(pVM);
955	if (RT_SUCCESS(rc))
956	{
957	rc = IEMR3Init(pVM);
958	if (RT_SUCCESS(rc))
959	{
960	rc = DBGFR3Init(pVM);
961	if (RT_SUCCESS(rc))
962	{
963	/* GIM must be init'd before PDM, gimdevR3Construct()
964	requires GIM provider to be setup. */
965	rc = GIMR3Init(pVM);
966	if (RT_SUCCESS(rc))
967	{
968	rc = PDMR3Init(pVM);
969	if (RT_SUCCESS(rc))
970	{
971	rc = PGMR3InitDynMap(pVM);
972	if (RT_SUCCESS(rc))
973	rc = MMR3HyperInitFinalize(pVM);
974	#ifdef VBOX_WITH_RAW_MODE
975	if (RT_SUCCESS(rc))
976	rc = PATMR3InitFinalize(pVM);
977	#endif
978	if (RT_SUCCESS(rc))
979	rc = PGMR3InitFinalize(pVM);
980	if (RT_SUCCESS(rc))
981	rc = SELMR3InitFinalize(pVM);
982	if (RT_SUCCESS(rc))
983	rc = TMR3InitFinalize(pVM);
984	#ifdef VBOX_WITH_REM
985	if (RT_SUCCESS(rc))
986	rc = REMR3InitFinalize(pVM);
987	#endif
988	if (RT_SUCCESS(rc))
989	{
990	PGMR3MemSetup(pVM, false /fAtReset/);
991	PDMR3MemSetup(pVM, false /fAtReset/);
992	}
993	if (RT_SUCCESS(rc))
994	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING3);
995	if (RT_SUCCESS(rc))
996	{
997	LogFlow(("vmR3InitRing3: returns %Rrc\n", VINF_SUCCESS));
998	return VINF_SUCCESS;
999	}
1000
1001	int rc2 = PDMR3Term(pVM);
1002	AssertRC(rc2);
1003	}
1004	int rc2 = GIMR3Term(pVM);
1005	AssertRC(rc2);
1006	}
1007	int rc2 = DBGFR3Term(pVM);
1008	AssertRC(rc2);
1009	}
1010	int rc2 = IEMR3Term(pVM);
1011	AssertRC(rc2);
1012	}
1013	int rc2 = EMR3Term(pVM);
1014	AssertRC(rc2);
1015	}
1016	int rc2 = IOMR3Term(pVM);
1017	AssertRC(rc2);
1018	}
1019	#ifdef VBOX_WITH_RAW_MODE
1020	int rc2 = PATMR3Term(pVM);
1021	AssertRC(rc2);
1022	}
1023	int rc2 = CSAMR3Term(pVM);
1024	AssertRC(rc2);
1025	}
1026	#endif
1027	int rc2 = TRPMR3Term(pVM);
1028	AssertRC(rc2);
1029	}
1030	int rc2 = SELMR3Term(pVM);
1031	AssertRC(rc2);
1032	}
1033	int rc2 = VMMR3Term(pVM);
1034	AssertRC(rc2);
1035	}
1036	int rc2 = FTMR3Term(pVM);
1037	AssertRC(rc2);
1038	}
1039	int rc2 = TMR3Term(pVM);
1040	AssertRC(rc2);
1041	}
1042	#ifdef VBOX_WITH_REM
1043	int rc2 = REMR3Term(pVM);
1044	AssertRC(rc2);
1045	#endif
1046	}
1047	int rc2 = PGMR3Term(pVM);
1048	AssertRC(rc2);
1049	}
1050	//int rc2 = CPUMR3Term(pVM);
1051	//AssertRC(rc2);
1052	}
1053	/* MMR3Term is not called here because it'll kill the heap. */
1054	}
1055	int rc2 = HMR3Term(pVM);
1056	AssertRC(rc2);
1057	}
1058	NEMR3Term(pVM);
1059
1060	LogFlow(("vmR3InitRing3: returns %Rrc\n", rc));
1061	return rc;
1062	}
1063
1064
1065	/**
1066	* Initializes all R0 components of the VM.
1067	*/
1068	static int vmR3InitRing0(PVM pVM)
1069	{
1070	LogFlow(("vmR3InitRing0:\n"));
1071
1072	/*
1073	* Check for FAKE suplib mode.
1074	*/
1075	int rc = VINF_SUCCESS;
1076	const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
1077	if (!psz \|\| strcmp(psz, "fake"))
1078	{
1079	/*
1080	* Call the VMMR0 component and let it do the init.
1081	*/
1082	rc = VMMR3InitR0(pVM);
1083	}
1084	else
1085	Log(("vmR3InitRing0: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
1086
1087	/*
1088	* Do notifications and return.
1089	*/
1090	if (RT_SUCCESS(rc))
1091	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING0);
1092	if (RT_SUCCESS(rc))
1093	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_HM);
1094
1095	LogFlow(("vmR3InitRing0: returns %Rrc\n", rc));
1096	return rc;
1097	}
1098
1099
1100	#ifdef VBOX_WITH_RAW_MODE
1101	/**
1102	* Initializes all RC components of the VM
1103	*/
1104	static int vmR3InitRC(PVM pVM)
1105	{
1106	LogFlow(("vmR3InitRC:\n"));
1107
1108	/*
1109	* Check for FAKE suplib mode.
1110	*/
1111	int rc = VINF_SUCCESS;
1112	const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
1113	if (!psz \|\| strcmp(psz, "fake"))
1114	{
1115	/*
1116	* Call the VMMR0 component and let it do the init.
1117	*/
1118	rc = VMMR3InitRC(pVM);
1119	}
1120	else
1121	Log(("vmR3InitRC: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
1122
1123	/*
1124	* Do notifications and return.
1125	*/
1126	if (RT_SUCCESS(rc))
1127	rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RC);
1128	LogFlow(("vmR3InitRC: returns %Rrc\n", rc));
1129	return rc;
1130	}
1131	#endif /* VBOX_WITH_RAW_MODE */
1132
1133
1134	/**
1135	* Do init completed notifications.
1136	*
1137	* @returns VBox status code.
1138	* @param pVM The cross context VM structure.
1139	* @param enmWhat What's completed.
1140	*/
1141	static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat)
1142	{
1143	int rc = VMMR3InitCompleted(pVM, enmWhat);
1144	if (RT_SUCCESS(rc))
1145	rc = HMR3InitCompleted(pVM, enmWhat);
1146	if (RT_SUCCESS(rc))
1147	rc = NEMR3InitCompleted(pVM, enmWhat);
1148	if (RT_SUCCESS(rc))
1149	rc = PGMR3InitCompleted(pVM, enmWhat);
1150	if (RT_SUCCESS(rc))
1151	rc = CPUMR3InitCompleted(pVM, enmWhat);
1152	if (RT_SUCCESS(rc))
1153	rc = EMR3InitCompleted(pVM, enmWhat);
1154	if (enmWhat == VMINITCOMPLETED_RING3)
1155	{
1156	#ifndef VBOX_WITH_RAW_MODE
1157	if (RT_SUCCESS(rc))
1158	rc = SSMR3RegisterStub(pVM, "CSAM", 0);
1159	if (RT_SUCCESS(rc))
1160	rc = SSMR3RegisterStub(pVM, "PATM", 0);
1161	#endif
1162	#ifndef VBOX_WITH_REM
1163	if (RT_SUCCESS(rc))
1164	rc = SSMR3RegisterStub(pVM, "rem", 1);
1165	#endif
1166	}
1167	if (RT_SUCCESS(rc))
1168	rc = PDMR3InitCompleted(pVM, enmWhat);
1169	return rc;
1170	}
1171
1172
1173	/**
1174	* Calls the relocation functions for all VMM components so they can update
1175	* any GC pointers. When this function is called all the basic VM members
1176	* have been updated and the actual memory relocation have been done
1177	* by the PGM/MM.
1178	*
1179	* This is used both on init and on runtime relocations.
1180	*
1181	* @param pVM The cross context VM structure.
1182	* @param offDelta Relocation delta relative to old location.
1183	*/
1184	VMMR3_INT_DECL(void) VMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
1185	{
1186	LogFlow(("VMR3Relocate: offDelta=%RGv\n", offDelta));
1187
1188	/*
1189	* The order here is very important!
1190	*/
1191	PGMR3Relocate(pVM, offDelta);
1192	PDMR3LdrRelocateU(pVM->pUVM, offDelta);
1193	PGMR3Relocate(pVM, 0); /* Repeat after PDM relocation. */
1194	CPUMR3Relocate(pVM);
1195	HMR3Relocate(pVM);
1196	SELMR3Relocate(pVM);
1197	VMMR3Relocate(pVM, offDelta);
1198	SELMR3Relocate(pVM); /* !hack! fix stack! */
1199	TRPMR3Relocate(pVM, offDelta);
1200	#ifdef VBOX_WITH_RAW_MODE
1201	PATMR3Relocate(pVM, (RTRCINTPTR)offDelta);
1202	CSAMR3Relocate(pVM, offDelta);
1203	#endif
1204	IOMR3Relocate(pVM, offDelta);
1205	EMR3Relocate(pVM);
1206	TMR3Relocate(pVM, offDelta);
1207	IEMR3Relocate(pVM);
1208	DBGFR3Relocate(pVM, offDelta);
1209	PDMR3Relocate(pVM, offDelta);
1210	GIMR3Relocate(pVM, offDelta);
1211	}
1212
1213
1214	/**
1215	* EMT rendezvous worker for VMR3PowerOn.
1216	*
1217	* @returns VERR_VM_INVALID_VM_STATE or VINF_SUCCESS. (This is a strict return
1218	* code, see FNVMMEMTRENDEZVOUS.)
1219	*
1220	* @param pVM The cross context VM structure.
1221	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1222	* @param pvUser Ignored.
1223	*/
1224	static DECLCALLBACK(VBOXSTRICTRC) vmR3PowerOn(PVM pVM, PVMCPU pVCpu, void *pvUser)
1225	{
1226	LogFlow(("vmR3PowerOn: pVM=%p pVCpu=%p/#%u\n", pVM, pVCpu, pVCpu->idCpu));
1227	Assert(!pvUser); NOREF(pvUser);
1228
1229	/*
1230	* The first thread thru here tries to change the state. We shouldn't be
1231	* called again if this fails.
1232	*/
1233	if (pVCpu->idCpu == pVM->cCpus - 1)
1234	{
1235	int rc = vmR3TrySetState(pVM, "VMR3PowerOn", 1, VMSTATE_POWERING_ON, VMSTATE_CREATED);
1236	if (RT_FAILURE(rc))
1237	return rc;
1238	}
1239
1240	VMSTATE enmVMState = VMR3GetState(pVM);
1241	AssertMsgReturn(enmVMState == VMSTATE_POWERING_ON,
1242	("%s\n", VMR3GetStateName(enmVMState)),
1243	VERR_VM_UNEXPECTED_UNSTABLE_STATE);
1244
1245	/*
1246	* All EMTs changes their state to started.
1247	*/
1248	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
1249
1250	/*
1251	* EMT(0) is last thru here and it will make the notification calls
1252	* and advance the state.
1253	*/
1254	if (pVCpu->idCpu == 0)
1255	{
1256	PDMR3PowerOn(pVM);
1257	vmR3SetState(pVM, VMSTATE_RUNNING, VMSTATE_POWERING_ON);
1258	}
1259
1260	return VINF_SUCCESS;
1261	}
1262
1263
1264	/**
1265	* Powers on the virtual machine.
1266	*
1267	* @returns VBox status code.
1268	*
1269	* @param pUVM The VM to power on.
1270	*
1271	* @thread Any thread.
1272	* @vmstate Created
1273	* @vmstateto PoweringOn+Running
1274	*/
1275	VMMR3DECL(int) VMR3PowerOn(PUVM pUVM)
1276	{
1277	LogFlow(("VMR3PowerOn: pUVM=%p\n", pUVM));
1278	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1279	PVM pVM = pUVM->pVM;
1280	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1281
1282	/*
1283	* Gather all the EMTs to reduce the init TSC drift and keep
1284	* the state changing APIs a bit uniform.
1285	*/
1286	int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
1287	vmR3PowerOn, NULL);
1288	LogFlow(("VMR3PowerOn: returns %Rrc\n", rc));
1289	return rc;
1290	}
1291
1292
1293	/**
1294	* Does the suspend notifications.
1295	*
1296	* @param pVM The cross context VM structure.
1297	* @thread EMT(0)
1298	*/
1299	static void vmR3SuspendDoWork(PVM pVM)
1300	{
1301	PDMR3Suspend(pVM);
1302	}
1303
1304
1305	/**
1306	* EMT rendezvous worker for VMR3Suspend.
1307	*
1308	* @returns VERR_VM_INVALID_VM_STATE or VINF_EM_SUSPEND. (This is a strict
1309	* return code, see FNVMMEMTRENDEZVOUS.)
1310	*
1311	* @param pVM The cross context VM structure.
1312	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1313	* @param pvUser Ignored.
1314	*/
1315	static DECLCALLBACK(VBOXSTRICTRC) vmR3Suspend(PVM pVM, PVMCPU pVCpu, void *pvUser)
1316	{
1317	VMSUSPENDREASON enmReason = (VMSUSPENDREASON)(uintptr_t)pvUser;
1318	LogFlow(("vmR3Suspend: pVM=%p pVCpu=%p/#%u enmReason=%d\n", pVM, pVCpu, pVCpu->idCpu, enmReason));
1319
1320	/*
1321	* The first EMT switches the state to suspending. If this fails because
1322	* something was racing us in one way or the other, there will be no more
1323	* calls and thus the state assertion below is not going to annoy anyone.
1324	*/
1325	if (pVCpu->idCpu == pVM->cCpus - 1)
1326	{
1327	int rc = vmR3TrySetState(pVM, "VMR3Suspend", 2,
1328	VMSTATE_SUSPENDING, VMSTATE_RUNNING,
1329	VMSTATE_SUSPENDING_EXT_LS, VMSTATE_RUNNING_LS);
1330	if (RT_FAILURE(rc))
1331	return rc;
1332	pVM->pUVM->vm.s.enmSuspendReason = enmReason;
1333	}
1334
1335	VMSTATE enmVMState = VMR3GetState(pVM);
1336	AssertMsgReturn( enmVMState == VMSTATE_SUSPENDING
1337	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS,
1338	("%s\n", VMR3GetStateName(enmVMState)),
1339	VERR_VM_UNEXPECTED_UNSTABLE_STATE);
1340
1341	/*
1342	* EMT(0) does the actually suspending after all the other CPUs have
1343	* been thru here.
1344	*/
1345	if (pVCpu->idCpu == 0)
1346	{
1347	vmR3SuspendDoWork(pVM);
1348
1349	int rc = vmR3TrySetState(pVM, "VMR3Suspend", 2,
1350	VMSTATE_SUSPENDED, VMSTATE_SUSPENDING,
1351	VMSTATE_SUSPENDED_EXT_LS, VMSTATE_SUSPENDING_EXT_LS);
1352	if (RT_FAILURE(rc))
1353	return VERR_VM_UNEXPECTED_UNSTABLE_STATE;
1354	}
1355
1356	return VINF_EM_SUSPEND;
1357	}
1358
1359
1360	/**
1361	* Suspends a running VM.
1362	*
1363	* @returns VBox status code. When called on EMT, this will be a strict status
1364	* code that has to be propagated up the call stack.
1365	*
1366	* @param pUVM The VM to suspend.
1367	* @param enmReason The reason for suspending.
1368	*
1369	* @thread Any thread.
1370	* @vmstate Running or RunningLS
1371	* @vmstateto Suspending + Suspended or SuspendingExtLS + SuspendedExtLS
1372	*/
1373	VMMR3DECL(int) VMR3Suspend(PUVM pUVM, VMSUSPENDREASON enmReason)
1374	{
1375	LogFlow(("VMR3Suspend: pUVM=%p\n", pUVM));
1376	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1377	AssertReturn(enmReason > VMSUSPENDREASON_INVALID && enmReason < VMSUSPENDREASON_END, VERR_INVALID_PARAMETER);
1378
1379	/*
1380	* Gather all the EMTs to make sure there are no races before
1381	* changing the VM state.
1382	*/
1383	int rc = VMMR3EmtRendezvous(pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
1384	vmR3Suspend, (void *)(uintptr_t)enmReason);
1385	LogFlow(("VMR3Suspend: returns %Rrc\n", rc));
1386	return rc;
1387	}
1388
1389
1390	/**
1391	* Retrieves the reason for the most recent suspend.
1392	*
1393	* @returns Suspend reason. VMSUSPENDREASON_INVALID if no suspend has been done
1394	* or the handle is invalid.
1395	* @param pUVM The user mode VM handle.
1396	*/
1397	VMMR3DECL(VMSUSPENDREASON) VMR3GetSuspendReason(PUVM pUVM)
1398	{
1399	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VMSUSPENDREASON_INVALID);
1400	return pUVM->vm.s.enmSuspendReason;
1401	}
1402
1403
1404	/**
1405	* EMT rendezvous worker for VMR3Resume.
1406	*
1407	* @returns VERR_VM_INVALID_VM_STATE or VINF_EM_RESUME. (This is a strict
1408	* return code, see FNVMMEMTRENDEZVOUS.)
1409	*
1410	* @param pVM The cross context VM structure.
1411	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1412	* @param pvUser Reason.
1413	*/
1414	static DECLCALLBACK(VBOXSTRICTRC) vmR3Resume(PVM pVM, PVMCPU pVCpu, void *pvUser)
1415	{
1416	VMRESUMEREASON enmReason = (VMRESUMEREASON)(uintptr_t)pvUser;
1417	LogFlow(("vmR3Resume: pVM=%p pVCpu=%p/#%u enmReason=%d\n", pVM, pVCpu, pVCpu->idCpu, enmReason));
1418
1419	/*
1420	* The first thread thru here tries to change the state. We shouldn't be
1421	* called again if this fails.
1422	*/
1423	if (pVCpu->idCpu == pVM->cCpus - 1)
1424	{
1425	int rc = vmR3TrySetState(pVM, "VMR3Resume", 1, VMSTATE_RESUMING, VMSTATE_SUSPENDED);
1426	if (RT_FAILURE(rc))
1427	return rc;
1428	pVM->pUVM->vm.s.enmResumeReason = enmReason;
1429	}
1430
1431	VMSTATE enmVMState = VMR3GetState(pVM);
1432	AssertMsgReturn(enmVMState == VMSTATE_RESUMING,
1433	("%s\n", VMR3GetStateName(enmVMState)),
1434	VERR_VM_UNEXPECTED_UNSTABLE_STATE);
1435
1436	#if 0
1437	/*
1438	* All EMTs changes their state to started.
1439	*/
1440	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
1441	#endif
1442
1443	/*
1444	* EMT(0) is last thru here and it will make the notification calls
1445	* and advance the state.
1446	*/
1447	if (pVCpu->idCpu == 0)
1448	{
1449	PDMR3Resume(pVM);
1450	vmR3SetState(pVM, VMSTATE_RUNNING, VMSTATE_RESUMING);
1451	pVM->vm.s.fTeleportedAndNotFullyResumedYet = false;
1452	}
1453
1454	return VINF_EM_RESUME;
1455	}
1456
1457
1458	/**
1459	* Resume VM execution.
1460	*
1461	* @returns VBox status code. When called on EMT, this will be a strict status
1462	* code that has to be propagated up the call stack.
1463	*
1464	* @param pUVM The user mode VM handle.
1465	* @param enmReason The reason we're resuming.
1466	*
1467	* @thread Any thread.
1468	* @vmstate Suspended
1469	* @vmstateto Running
1470	*/
1471	VMMR3DECL(int) VMR3Resume(PUVM pUVM, VMRESUMEREASON enmReason)
1472	{
1473	LogFlow(("VMR3Resume: pUVM=%p\n", pUVM));
1474	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1475	PVM pVM = pUVM->pVM;
1476	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1477	AssertReturn(enmReason > VMRESUMEREASON_INVALID && enmReason < VMRESUMEREASON_END, VERR_INVALID_PARAMETER);
1478
1479	/*
1480	* Gather all the EMTs to make sure there are no races before
1481	* changing the VM state.
1482	*/
1483	int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
1484	vmR3Resume, (void *)(uintptr_t)enmReason);
1485	LogFlow(("VMR3Resume: returns %Rrc\n", rc));
1486	return rc;
1487	}
1488
1489
1490	/**
1491	* Retrieves the reason for the most recent resume.
1492	*
1493	* @returns Resume reason. VMRESUMEREASON_INVALID if no suspend has been
1494	* done or the handle is invalid.
1495	* @param pUVM The user mode VM handle.
1496	*/
1497	VMMR3DECL(VMRESUMEREASON) VMR3GetResumeReason(PUVM pUVM)
1498	{
1499	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VMRESUMEREASON_INVALID);
1500	return pUVM->vm.s.enmResumeReason;
1501	}
1502
1503
1504	/**
1505	* EMT rendezvous worker for VMR3Save and VMR3Teleport that suspends the VM
1506	* after the live step has been completed.
1507	*
1508	* @returns VERR_VM_INVALID_VM_STATE or VINF_EM_RESUME. (This is a strict
1509	* return code, see FNVMMEMTRENDEZVOUS.)
1510	*
1511	* @param pVM The cross context VM structure.
1512	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1513	* @param pvUser The pfSuspended argument of vmR3SaveTeleport.
1514	*/
1515	static DECLCALLBACK(VBOXSTRICTRC) vmR3LiveDoSuspend(PVM pVM, PVMCPU pVCpu, void *pvUser)
1516	{
1517	LogFlow(("vmR3LiveDoSuspend: pVM=%p pVCpu=%p/#%u\n", pVM, pVCpu, pVCpu->idCpu));
1518	bool pfSuspended = (bool )pvUser;
1519
1520	/*
1521	* The first thread thru here tries to change the state. We shouldn't be
1522	* called again if this fails.
1523	*/
1524	if (pVCpu->idCpu == pVM->cCpus - 1U)
1525	{
1526	PUVM pUVM = pVM->pUVM;
1527	int rc;
1528
1529	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
1530	VMSTATE enmVMState = pVM->enmVMState;
1531	switch (enmVMState)
1532	{
1533	case VMSTATE_RUNNING_LS:
1534	vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDING_LS, VMSTATE_RUNNING_LS, false /fSetRatherThanClearFF/);
1535	rc = VINF_SUCCESS;
1536	break;
1537
1538	case VMSTATE_SUSPENDED_EXT_LS:
1539	case VMSTATE_SUSPENDED_LS: /* (via reset) */
1540	rc = VINF_SUCCESS;
1541	break;
1542
1543	case VMSTATE_DEBUGGING_LS:
1544	rc = VERR_TRY_AGAIN;
1545	break;
1546
1547	case VMSTATE_OFF_LS:
1548	vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF, VMSTATE_OFF_LS, false /fSetRatherThanClearFF/);
1549	rc = VERR_SSM_LIVE_POWERED_OFF;
1550	break;
1551
1552	case VMSTATE_FATAL_ERROR_LS:
1553	vmR3SetStateLocked(pVM, pUVM, VMSTATE_FATAL_ERROR, VMSTATE_FATAL_ERROR_LS, false /fSetRatherThanClearFF/);
1554	rc = VERR_SSM_LIVE_FATAL_ERROR;
1555	break;
1556
1557	case VMSTATE_GURU_MEDITATION_LS:
1558	vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION, VMSTATE_GURU_MEDITATION_LS, false /fSetRatherThanClearFF/);
1559	rc = VERR_SSM_LIVE_GURU_MEDITATION;
1560	break;
1561
1562	case VMSTATE_POWERING_OFF_LS:
1563	case VMSTATE_SUSPENDING_EXT_LS:
1564	case VMSTATE_RESETTING_LS:
1565	default:
1566	AssertMsgFailed(("%s\n", VMR3GetStateName(enmVMState)));
1567	rc = VERR_VM_UNEXPECTED_VM_STATE;
1568	break;
1569	}
1570	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
1571	if (RT_FAILURE(rc))
1572	{
1573	LogFlow(("vmR3LiveDoSuspend: returns %Rrc (state was %s)\n", rc, VMR3GetStateName(enmVMState)));
1574	return rc;
1575	}
1576	}
1577
1578	VMSTATE enmVMState = VMR3GetState(pVM);
1579	AssertMsgReturn(enmVMState == VMSTATE_SUSPENDING_LS,
1580	("%s\n", VMR3GetStateName(enmVMState)),
1581	VERR_VM_UNEXPECTED_UNSTABLE_STATE);
1582
1583	/*
1584	* Only EMT(0) have work to do since it's last thru here.
1585	*/
1586	if (pVCpu->idCpu == 0)
1587	{
1588	vmR3SuspendDoWork(pVM);
1589	int rc = vmR3TrySetState(pVM, "VMR3Suspend", 1,
1590	VMSTATE_SUSPENDED_LS, VMSTATE_SUSPENDING_LS);
1591	if (RT_FAILURE(rc))
1592	return VERR_VM_UNEXPECTED_UNSTABLE_STATE;
1593
1594	*pfSuspended = true;
1595	}
1596
1597	return VINF_EM_SUSPEND;
1598	}
1599
1600
1601	/**
1602	* EMT rendezvous worker that VMR3Save and VMR3Teleport uses to clean up a
1603	* SSMR3LiveDoStep1 failure.
1604	*
1605	* Doing this as a rendezvous operation avoids all annoying transition
1606	* states.
1607	*
1608	* @returns VERR_VM_INVALID_VM_STATE, VINF_SUCCESS or some specific VERR_SSM_*
1609	* status code. (This is a strict return code, see FNVMMEMTRENDEZVOUS.)
1610	*
1611	* @param pVM The cross context VM structure.
1612	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
1613	* @param pvUser The pfSuspended argument of vmR3SaveTeleport.
1614	*/
1615	static DECLCALLBACK(VBOXSTRICTRC) vmR3LiveDoStep1Cleanup(PVM pVM, PVMCPU pVCpu, void *pvUser)
1616	{
1617	LogFlow(("vmR3LiveDoStep1Cleanup: pVM=%p pVCpu=%p/#%u\n", pVM, pVCpu, pVCpu->idCpu));
1618	bool pfSuspended = (bool )pvUser;
1619	NOREF(pVCpu);
1620
1621	int rc = vmR3TrySetState(pVM, "vmR3LiveDoStep1Cleanup", 8,
1622	VMSTATE_OFF, VMSTATE_OFF_LS, /* 1 */
1623	VMSTATE_FATAL_ERROR, VMSTATE_FATAL_ERROR_LS, /* 2 */
1624	VMSTATE_GURU_MEDITATION, VMSTATE_GURU_MEDITATION_LS, /* 3 */
1625	VMSTATE_SUSPENDED, VMSTATE_SUSPENDED_LS, /* 4 */
1626	VMSTATE_SUSPENDED, VMSTATE_SAVING,
1627	VMSTATE_SUSPENDED, VMSTATE_SUSPENDED_EXT_LS,
1628	VMSTATE_RUNNING, VMSTATE_RUNNING_LS,
1629	VMSTATE_DEBUGGING, VMSTATE_DEBUGGING_LS);
1630	if (rc == 1)
1631	rc = VERR_SSM_LIVE_POWERED_OFF;
1632	else if (rc == 2)
1633	rc = VERR_SSM_LIVE_FATAL_ERROR;
1634	else if (rc == 3)
1635	rc = VERR_SSM_LIVE_GURU_MEDITATION;
1636	else if (rc == 4)
1637	{
1638	*pfSuspended = true;
1639	rc = VINF_SUCCESS;
1640	}
1641	else if (rc > 0)
1642	rc = VINF_SUCCESS;
1643	return rc;
1644	}
1645
1646
1647	/**
1648	* EMT(0) worker for VMR3Save and VMR3Teleport that completes the live save.
1649	*
1650	* @returns VBox status code.
1651	* @retval VINF_SSM_LIVE_SUSPENDED if VMR3Suspend was called.
1652	*
1653	* @param pVM The cross context VM structure.
1654	* @param pSSM The handle of saved state operation.
1655	*
1656	* @thread EMT(0)
1657	*/
1658	static DECLCALLBACK(int) vmR3LiveDoStep2(PVM pVM, PSSMHANDLE pSSM)
1659	{
1660	LogFlow(("vmR3LiveDoStep2: pVM=%p pSSM=%p\n", pVM, pSSM));
1661	VM_ASSERT_EMT0(pVM);
1662
1663	/*
1664	* Advance the state and mark if VMR3Suspend was called.
1665	*/
1666	int rc = VINF_SUCCESS;
1667	VMSTATE enmVMState = VMR3GetState(pVM);
1668	if (enmVMState == VMSTATE_SUSPENDED_LS)
1669	vmR3SetState(pVM, VMSTATE_SAVING, VMSTATE_SUSPENDED_LS);
1670	else
1671	{
1672	if (enmVMState != VMSTATE_SAVING)
1673	vmR3SetState(pVM, VMSTATE_SAVING, VMSTATE_SUSPENDED_EXT_LS);
1674	rc = VINF_SSM_LIVE_SUSPENDED;
1675	}
1676
1677	/*
1678	* Finish up and release the handle. Careful with the status codes.
1679	*/
1680	int rc2 = SSMR3LiveDoStep2(pSSM);
1681	if (rc == VINF_SUCCESS \|\| (RT_FAILURE(rc2) && RT_SUCCESS(rc)))
1682	rc = rc2;
1683
1684	rc2 = SSMR3LiveDone(pSSM);
1685	if (rc == VINF_SUCCESS \|\| (RT_FAILURE(rc2) && RT_SUCCESS(rc)))
1686	rc = rc2;
1687
1688	/*
1689	* Advance to the final state and return.
1690	*/
1691	vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_SAVING);
1692	Assert(rc > VINF_EM_LAST \|\| rc < VINF_EM_FIRST);
1693	return rc;
1694	}
1695
1696
1697	/**
1698	* Worker for vmR3SaveTeleport that validates the state and calls SSMR3Save or
1699	* SSMR3LiveSave.
1700	*
1701	* @returns VBox status code.
1702	*
1703	* @param pVM The cross context VM structure.
1704	* @param cMsMaxDowntime The maximum downtime given as milliseconds.
1705	* @param pszFilename The name of the file. NULL if pStreamOps is used.
1706	* @param pStreamOps The stream methods. NULL if pszFilename is used.
1707	* @param pvStreamOpsUser The user argument to the stream methods.
1708	* @param enmAfter What to do afterwards.
1709	* @param pfnProgress Progress callback. Optional.
1710	* @param pvProgressUser User argument for the progress callback.
1711	* @param ppSSM Where to return the saved state handle in case of a
1712	* live snapshot scenario.
1713	* @param fSkipStateChanges Set if we're supposed to skip state changes (FTM delta case)
1714	*
1715	* @thread EMT
1716	*/
1717	static DECLCALLBACK(int) vmR3Save(PVM pVM, uint32_t cMsMaxDowntime, const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOpsUser,
1718	SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void pvProgressUser, PSSMHANDLE ppSSM,
1719	bool fSkipStateChanges)
1720	{
1721	int rc = VINF_SUCCESS;
1722
1723	LogFlow(("vmR3Save: pVM=%p cMsMaxDowntime=%u pszFilename=%p:{%s} pStreamOps=%p pvStreamOpsUser=%p enmAfter=%d pfnProgress=%p pvProgressUser=%p ppSSM=%p\n",
1724	pVM, cMsMaxDowntime, pszFilename, pszFilename, pStreamOps, pvStreamOpsUser, enmAfter, pfnProgress, pvProgressUser, ppSSM));
1725
1726	/*
1727	* Validate input.
1728	*/
1729	AssertPtrNull(pszFilename);
1730	AssertPtrNull(pStreamOps);
1731	AssertPtr(pVM);
1732	Assert( enmAfter == SSMAFTER_DESTROY
1733	\|\| enmAfter == SSMAFTER_CONTINUE
1734	\|\| enmAfter == SSMAFTER_TELEPORT);
1735	AssertPtr(ppSSM);
1736	*ppSSM = NULL;
1737
1738	/*
1739	* Change the state and perform/start the saving.
1740	*/
1741	if (!fSkipStateChanges)
1742	{
1743	rc = vmR3TrySetState(pVM, "VMR3Save", 2,
1744	VMSTATE_SAVING, VMSTATE_SUSPENDED,
1745	VMSTATE_RUNNING_LS, VMSTATE_RUNNING);
1746	}
1747	else
1748	{
1749	Assert(enmAfter != SSMAFTER_TELEPORT);
1750	rc = 1;
1751	}
1752
1753	if (rc == 1 && enmAfter != SSMAFTER_TELEPORT)
1754	{
1755	rc = SSMR3Save(pVM, pszFilename, pStreamOps, pvStreamOpsUser, enmAfter, pfnProgress, pvProgressUser);
1756	if (!fSkipStateChanges)
1757	vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_SAVING);
1758	}
1759	else if (rc == 2 \|\| enmAfter == SSMAFTER_TELEPORT)
1760	{
1761	Assert(!fSkipStateChanges);
1762	if (enmAfter == SSMAFTER_TELEPORT)
1763	pVM->vm.s.fTeleportedAndNotFullyResumedYet = true;
1764	rc = SSMR3LiveSave(pVM, cMsMaxDowntime, pszFilename, pStreamOps, pvStreamOpsUser,
1765	enmAfter, pfnProgress, pvProgressUser, ppSSM);
1766	/* (We're not subject to cancellation just yet.) */
1767	}
1768	else
1769	Assert(RT_FAILURE(rc));
1770	return rc;
1771	}
1772
1773
1774	/**
1775	* Common worker for VMR3Save and VMR3Teleport.
1776	*
1777	* @returns VBox status code.
1778	*
1779	* @param pVM The cross context VM structure.
1780	* @param cMsMaxDowntime The maximum downtime given as milliseconds.
1781	* @param pszFilename The name of the file. NULL if pStreamOps is used.
1782	* @param pStreamOps The stream methods. NULL if pszFilename is used.
1783	* @param pvStreamOpsUser The user argument to the stream methods.
1784	* @param enmAfter What to do afterwards.
1785	* @param pfnProgress Progress callback. Optional.
1786	* @param pvProgressUser User argument for the progress callback.
1787	* @param pfSuspended Set if we suspended the VM.
1788	* @param fSkipStateChanges Set if we're supposed to skip state changes (FTM delta case)
1789	*
1790	* @thread Non-EMT
1791	*/
1792	static int vmR3SaveTeleport(PVM pVM, uint32_t cMsMaxDowntime,
1793	const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOpsUser,
1794	SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void pvProgressUser, bool pfSuspended,
1795	bool fSkipStateChanges)
1796	{
1797	/*
1798	* Request the operation in EMT(0).
1799	*/
1800	PSSMHANDLE pSSM;
1801	int rc = VMR3ReqCallWait(pVM, 0 /idDstCpu/,
1802	(PFNRT)vmR3Save, 10, pVM, cMsMaxDowntime, pszFilename, pStreamOps, pvStreamOpsUser,
1803	enmAfter, pfnProgress, pvProgressUser, &pSSM, fSkipStateChanges);
1804	if ( RT_SUCCESS(rc)
1805	&& pSSM)
1806	{
1807	Assert(!fSkipStateChanges);
1808
1809	/*
1810	* Live snapshot.
1811	*
1812	* The state handling here is kind of tricky, doing it on EMT(0) helps
1813	* a bit. See the VMSTATE diagram for details.
1814	*/
1815	rc = SSMR3LiveDoStep1(pSSM);
1816	if (RT_SUCCESS(rc))
1817	{
1818	if (VMR3GetState(pVM) != VMSTATE_SAVING)
1819	for (;;)
1820	{
1821	/* Try suspend the VM. */
1822	rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
1823	vmR3LiveDoSuspend, pfSuspended);
1824	if (rc != VERR_TRY_AGAIN)
1825	break;
1826
1827	/* Wait for the state to change. */
1828	RTThreadSleep(250); /** @todo Live Migration: fix this polling wait by some smart use of multiple release event semaphores.. */
1829	}
1830	if (RT_SUCCESS(rc))
1831	rc = VMR3ReqCallWait(pVM, 0 /idDstCpu/, (PFNRT)vmR3LiveDoStep2, 2, pVM, pSSM);
1832	else
1833	{
1834	int rc2 = VMR3ReqCallWait(pVM, 0 /idDstCpu/, (PFNRT)SSMR3LiveDone, 1, pSSM);
1835	AssertMsg(rc2 == rc, ("%Rrc != %Rrc\n", rc2, rc)); NOREF(rc2);
1836	}
1837	}
1838	else
1839	{
1840	int rc2 = VMR3ReqCallWait(pVM, 0 /idDstCpu/, (PFNRT)SSMR3LiveDone, 1, pSSM);
1841	AssertMsg(rc2 == rc, ("%Rrc != %Rrc\n", rc2, rc));
1842
1843	rc2 = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, vmR3LiveDoStep1Cleanup, pfSuspended);
1844	if (RT_FAILURE(rc2) && rc == VERR_SSM_CANCELLED)
1845	rc = rc2;
1846	}
1847	}
1848
1849	return rc;
1850	}
1851
1852
1853	/**
1854	* Save current VM state.
1855	*
1856	* Can be used for both saving the state and creating snapshots.
1857	*
1858	* When called for a VM in the Running state, the saved state is created live
1859	* and the VM is only suspended when the final part of the saving is preformed.
1860	* The VM state will not be restored to Running in this case and it's up to the
1861	* caller to call VMR3Resume if this is desirable. (The rational is that the
1862	* caller probably wish to reconfigure the disks before resuming the VM.)
1863	*
1864	* @returns VBox status code.
1865	*
1866	* @param pUVM The VM which state should be saved.
1867	* @param pszFilename The name of the save state file.
1868	* @param fContinueAfterwards Whether continue execution afterwards or not.
1869	* When in doubt, set this to true.
1870	* @param pfnProgress Progress callback. Optional.
1871	* @param pvUser User argument for the progress callback.
1872	* @param pfSuspended Set if we suspended the VM.
1873	*
1874	* @thread Non-EMT.
1875	* @vmstate Suspended or Running
1876	* @vmstateto Saving+Suspended or
1877	* RunningLS+SuspendingLS+SuspendedLS+Saving+Suspended.
1878	*/
1879	VMMR3DECL(int) VMR3Save(PUVM pUVM, const char pszFilename, bool fContinueAfterwards, PFNVMPROGRESS pfnProgress, void pvUser,
1880	bool *pfSuspended)
1881	{
1882	LogFlow(("VMR3Save: pUVM=%p pszFilename=%p:{%s} fContinueAfterwards=%RTbool pfnProgress=%p pvUser=%p pfSuspended=%p\n",
1883	pUVM, pszFilename, pszFilename, fContinueAfterwards, pfnProgress, pvUser, pfSuspended));
1884
1885	/*
1886	* Validate input.
1887	*/
1888	AssertPtr(pfSuspended);
1889	*pfSuspended = false;
1890	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1891	PVM pVM = pUVM->pVM;
1892	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1893	VM_ASSERT_OTHER_THREAD(pVM);
1894	AssertReturn(VALID_PTR(pszFilename), VERR_INVALID_POINTER);
1895	AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
1896	AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
1897
1898	/*
1899	* Join paths with VMR3Teleport.
1900	*/
1901	SSMAFTER enmAfter = fContinueAfterwards ? SSMAFTER_CONTINUE : SSMAFTER_DESTROY;
1902	int rc = vmR3SaveTeleport(pVM, 250 /cMsMaxDowntime/,
1903	pszFilename, NULL /* pStreamOps /, NULL / pvStreamOpsUser */,
1904	enmAfter, pfnProgress, pvUser, pfSuspended,
1905	false /* fSkipStateChanges */);
1906	LogFlow(("VMR3Save: returns %Rrc (pfSuspended=%RTbool)\n", rc, pfSuspended));
1907	return rc;
1908	}
1909
1910	/**
1911	* Save current VM state (used by FTM)
1912	*
1913	*
1914	* @returns VBox status code.
1915	*
1916	* @param pUVM The user mode VM handle.
1917	* @param pStreamOps The stream methods.
1918	* @param pvStreamOpsUser The user argument to the stream methods.
1919	* @param pfSuspended Set if we suspended the VM.
1920	* @param fSkipStateChanges Set if we're supposed to skip state changes (FTM delta case)
1921	*
1922	* @thread Any
1923	* @vmstate Suspended or Running
1924	* @vmstateto Saving+Suspended or
1925	* RunningLS+SuspendingLS+SuspendedLS+Saving+Suspended.
1926	*/
1927	VMMR3_INT_DECL(int) VMR3SaveFT(PUVM pUVM, PCSSMSTRMOPS pStreamOps, void pvStreamOpsUser, bool pfSuspended, bool fSkipStateChanges)
1928	{
1929	LogFlow(("VMR3SaveFT: pUVM=%p pStreamOps=%p pvSteamOpsUser=%p pfSuspended=%p\n",
1930	pUVM, pStreamOps, pvStreamOpsUser, pfSuspended));
1931
1932	/*
1933	* Validate input.
1934	*/
1935	AssertPtr(pfSuspended);
1936	*pfSuspended = false;
1937	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1938	PVM pVM = pUVM->pVM;
1939	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1940	AssertReturn(pStreamOps, VERR_INVALID_PARAMETER);
1941
1942	/*
1943	* Join paths with VMR3Teleport.
1944	*/
1945	int rc = vmR3SaveTeleport(pVM, 250 /cMsMaxDowntime/,
1946	NULL, pStreamOps, pvStreamOpsUser,
1947	SSMAFTER_CONTINUE, NULL, NULL, pfSuspended,
1948	fSkipStateChanges);
1949	LogFlow(("VMR3SaveFT: returns %Rrc (pfSuspended=%RTbool)\n", rc, pfSuspended));
1950	return rc;
1951	}
1952
1953
1954	/**
1955	* Teleport the VM (aka live migration).
1956	*
1957	* @returns VBox status code.
1958	*
1959	* @param pUVM The VM which state should be saved.
1960	* @param cMsMaxDowntime The maximum downtime given as milliseconds.
1961	* @param pStreamOps The stream methods.
1962	* @param pvStreamOpsUser The user argument to the stream methods.
1963	* @param pfnProgress Progress callback. Optional.
1964	* @param pvProgressUser User argument for the progress callback.
1965	* @param pfSuspended Set if we suspended the VM.
1966	*
1967	* @thread Non-EMT.
1968	* @vmstate Suspended or Running
1969	* @vmstateto Saving+Suspended or
1970	* RunningLS+SuspendingLS+SuspendedLS+Saving+Suspended.
1971	*/
1972	VMMR3DECL(int) VMR3Teleport(PUVM pUVM, uint32_t cMsMaxDowntime, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
1973	PFNVMPROGRESS pfnProgress, void pvProgressUser, bool pfSuspended)
1974	{
1975	LogFlow(("VMR3Teleport: pUVM=%p cMsMaxDowntime=%u pStreamOps=%p pvStreamOps=%p pfnProgress=%p pvProgressUser=%p\n",
1976	pUVM, cMsMaxDowntime, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser));
1977
1978	/*
1979	* Validate input.
1980	*/
1981	AssertPtr(pfSuspended);
1982	*pfSuspended = false;
1983	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1984	PVM pVM = pUVM->pVM;
1985	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1986	VM_ASSERT_OTHER_THREAD(pVM);
1987	AssertPtrReturn(pStreamOps, VERR_INVALID_POINTER);
1988	AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
1989
1990	/*
1991	* Join paths with VMR3Save.
1992	*/
1993	int rc = vmR3SaveTeleport(pVM, cMsMaxDowntime,
1994	NULL /pszFilename/, pStreamOps, pvStreamOpsUser,
1995	SSMAFTER_TELEPORT, pfnProgress, pvProgressUser, pfSuspended,
1996	false /* fSkipStateChanges */);
1997	LogFlow(("VMR3Teleport: returns %Rrc (pfSuspended=%RTbool)\n", rc, pfSuspended));
1998	return rc;
1999	}
2000
2001
2002
2003	/**
2004	* EMT(0) worker for VMR3LoadFromFile and VMR3LoadFromStream.
2005	*
2006	* @returns VBox status code.
2007	*
2008	* @param pUVM Pointer to the VM.
2009	* @param pszFilename The name of the file. NULL if pStreamOps is used.
2010	* @param pStreamOps The stream methods. NULL if pszFilename is used.
2011	* @param pvStreamOpsUser The user argument to the stream methods.
2012	* @param pfnProgress Progress callback. Optional.
2013	* @param pvProgressUser User argument for the progress callback.
2014	* @param fTeleporting Indicates whether we're teleporting or not.
2015	* @param fSkipStateChanges Set if we're supposed to skip state changes (FTM delta case)
2016	*
2017	* @thread EMT.
2018	*/
2019	static DECLCALLBACK(int) vmR3Load(PUVM pUVM, const char pszFilename, PCSSMSTRMOPS pStreamOps, void pvStreamOpsUser,
2020	PFNVMPROGRESS pfnProgress, void *pvProgressUser, bool fTeleporting,
2021	bool fSkipStateChanges)
2022	{
2023	int rc = VINF_SUCCESS;
2024
2025	LogFlow(("vmR3Load: pUVM=%p pszFilename=%p:{%s} pStreamOps=%p pvStreamOpsUser=%p pfnProgress=%p pvProgressUser=%p fTeleporting=%RTbool\n",
2026	pUVM, pszFilename, pszFilename, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser, fTeleporting));
2027
2028	/*
2029	* Validate input (paranoia).
2030	*/
2031	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2032	PVM pVM = pUVM->pVM;
2033	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
2034	AssertPtrNull(pszFilename);
2035	AssertPtrNull(pStreamOps);
2036	AssertPtrNull(pfnProgress);
2037
2038	if (!fSkipStateChanges)
2039	{
2040	/*
2041	* Change the state and perform the load.
2042	*
2043	* Always perform a relocation round afterwards to make sure hypervisor
2044	* selectors and such are correct.
2045	*/
2046	rc = vmR3TrySetState(pVM, "VMR3Load", 2,
2047	VMSTATE_LOADING, VMSTATE_CREATED,
2048	VMSTATE_LOADING, VMSTATE_SUSPENDED);
2049	if (RT_FAILURE(rc))
2050	return rc;
2051	}
2052	pVM->vm.s.fTeleportedAndNotFullyResumedYet = fTeleporting;
2053
2054	uint32_t cErrorsPriorToSave = VMR3GetErrorCount(pUVM);
2055	rc = SSMR3Load(pVM, pszFilename, pStreamOps, pvStreamOpsUser, SSMAFTER_RESUME, pfnProgress, pvProgressUser);
2056	if (RT_SUCCESS(rc))
2057	{
2058	VMR3Relocate(pVM, 0 /offDelta/);
2059	if (!fSkipStateChanges)
2060	vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_LOADING);
2061	}
2062	else
2063	{
2064	pVM->vm.s.fTeleportedAndNotFullyResumedYet = false;
2065	if (!fSkipStateChanges)
2066	vmR3SetState(pVM, VMSTATE_LOAD_FAILURE, VMSTATE_LOADING);
2067
2068	if (cErrorsPriorToSave == VMR3GetErrorCount(pUVM))
2069	rc = VMSetError(pVM, rc, RT_SRC_POS,
2070	N_("Unable to restore the virtual machine's saved state from '%s'. "
2071	"It may be damaged or from an older version of VirtualBox. "
2072	"Please discard the saved state before starting the virtual machine"),
2073	pszFilename);
2074	}
2075
2076	return rc;
2077	}
2078
2079
2080	/**
2081	* Loads a VM state into a newly created VM or a one that is suspended.
2082	*
2083	* To restore a saved state on VM startup, call this function and then resume
2084	* the VM instead of powering it on.
2085	*
2086	* @returns VBox status code.
2087	*
2088	* @param pUVM The user mode VM structure.
2089	* @param pszFilename The name of the save state file.
2090	* @param pfnProgress Progress callback. Optional.
2091	* @param pvUser User argument for the progress callback.
2092	*
2093	* @thread Any thread.
2094	* @vmstate Created, Suspended
2095	* @vmstateto Loading+Suspended
2096	*/
2097	VMMR3DECL(int) VMR3LoadFromFile(PUVM pUVM, const char pszFilename, PFNVMPROGRESS pfnProgress, void pvUser)
2098	{
2099	LogFlow(("VMR3LoadFromFile: pUVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n",
2100	pUVM, pszFilename, pszFilename, pfnProgress, pvUser));
2101
2102	/*
2103	* Validate input.
2104	*/
2105	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2106	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
2107
2108	/*
2109	* Forward the request to EMT(0). No need to setup a rendezvous here
2110	* since there is no execution taking place when this call is allowed.
2111	*/
2112	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)vmR3Load, 8,
2113	pUVM, pszFilename, (uintptr_t)NULL /pStreamOps/, (uintptr_t)NULL /pvStreamOpsUser/, pfnProgress, pvUser,
2114	false /fTeleporting/, false /* fSkipStateChanges */);
2115	LogFlow(("VMR3LoadFromFile: returns %Rrc\n", rc));
2116	return rc;
2117	}
2118
2119
2120	/**
2121	* VMR3LoadFromFile for arbitrary file streams.
2122	*
2123	* @returns VBox status code.
2124	*
2125	* @param pUVM Pointer to the VM.
2126	* @param pStreamOps The stream methods.
2127	* @param pvStreamOpsUser The user argument to the stream methods.
2128	* @param pfnProgress Progress callback. Optional.
2129	* @param pvProgressUser User argument for the progress callback.
2130	*
2131	* @thread Any thread.
2132	* @vmstate Created, Suspended
2133	* @vmstateto Loading+Suspended
2134	*/
2135	VMMR3DECL(int) VMR3LoadFromStream(PUVM pUVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
2136	PFNVMPROGRESS pfnProgress, void *pvProgressUser)
2137	{
2138	LogFlow(("VMR3LoadFromStream: pUVM=%p pStreamOps=%p pvStreamOpsUser=%p pfnProgress=%p pvProgressUser=%p\n",
2139	pUVM, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser));
2140
2141	/*
2142	* Validate input.
2143	*/
2144	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2145	AssertPtrReturn(pStreamOps, VERR_INVALID_POINTER);
2146
2147	/*
2148	* Forward the request to EMT(0). No need to setup a rendezvous here
2149	* since there is no execution taking place when this call is allowed.
2150	*/
2151	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)vmR3Load, 8,
2152	pUVM, (uintptr_t)NULL /pszFilename/, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser,
2153	true /fTeleporting/, false /* fSkipStateChanges */);
2154	LogFlow(("VMR3LoadFromStream: returns %Rrc\n", rc));
2155	return rc;
2156	}
2157
2158
2159	/**
2160	* Special version for the FT component, it skips state changes.
2161	*
2162	* @returns VBox status code.
2163	*
2164	* @param pUVM The VM handle.
2165	* @param pStreamOps The stream methods.
2166	* @param pvStreamOpsUser The user argument to the stream methods.
2167	*
2168	* @thread Any thread.
2169	* @vmstate Created, Suspended
2170	* @vmstateto Loading+Suspended
2171	*/
2172	VMMR3_INT_DECL(int) VMR3LoadFromStreamFT(PUVM pUVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser)
2173	{
2174	LogFlow(("VMR3LoadFromStreamFT: pUVM=%p pStreamOps=%p pvStreamOpsUser=%p\n", pUVM, pStreamOps, pvStreamOpsUser));
2175
2176	/*
2177	* Validate input.
2178	*/
2179	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2180	AssertPtrReturn(pStreamOps, VERR_INVALID_POINTER);
2181
2182	/*
2183	* Forward the request to EMT(0). No need to setup a rendezvous here
2184	* since there is no execution taking place when this call is allowed.
2185	*/
2186	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)vmR3Load, 8,
2187	pUVM, (uintptr_t)NULL /pszFilename/, pStreamOps, pvStreamOpsUser, NULL, NULL,
2188	true /fTeleporting/, true /* fSkipStateChanges */);
2189	LogFlow(("VMR3LoadFromStream: returns %Rrc\n", rc));
2190	return rc;
2191	}
2192
2193	/**
2194	* EMT rendezvous worker for VMR3PowerOff.
2195	*
2196	* @returns VERR_VM_INVALID_VM_STATE or VINF_EM_OFF. (This is a strict
2197	* return code, see FNVMMEMTRENDEZVOUS.)
2198	*
2199	* @param pVM The cross context VM structure.
2200	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
2201	* @param pvUser Ignored.
2202	*/
2203	static DECLCALLBACK(VBOXSTRICTRC) vmR3PowerOff(PVM pVM, PVMCPU pVCpu, void *pvUser)
2204	{
2205	LogFlow(("vmR3PowerOff: pVM=%p pVCpu=%p/#%u\n", pVM, pVCpu, pVCpu->idCpu));
2206	Assert(!pvUser); NOREF(pvUser);
2207
2208	/*
2209	* The first EMT thru here will change the state to PoweringOff.
2210	*/
2211	if (pVCpu->idCpu == pVM->cCpus - 1)
2212	{
2213	int rc = vmR3TrySetState(pVM, "VMR3PowerOff", 11,
2214	VMSTATE_POWERING_OFF, VMSTATE_RUNNING, /* 1 */
2215	VMSTATE_POWERING_OFF, VMSTATE_SUSPENDED, /* 2 */
2216	VMSTATE_POWERING_OFF, VMSTATE_DEBUGGING, /* 3 */
2217	VMSTATE_POWERING_OFF, VMSTATE_LOAD_FAILURE, /* 4 */
2218	VMSTATE_POWERING_OFF, VMSTATE_GURU_MEDITATION, /* 5 */
2219	VMSTATE_POWERING_OFF, VMSTATE_FATAL_ERROR, /* 6 */
2220	VMSTATE_POWERING_OFF, VMSTATE_CREATED, /* 7 / /* @todo update the diagram! */
2221	VMSTATE_POWERING_OFF_LS, VMSTATE_RUNNING_LS, /* 8 */
2222	VMSTATE_POWERING_OFF_LS, VMSTATE_DEBUGGING_LS, /* 9 */
2223	VMSTATE_POWERING_OFF_LS, VMSTATE_GURU_MEDITATION_LS,/* 10 */
2224	VMSTATE_POWERING_OFF_LS, VMSTATE_FATAL_ERROR_LS); /* 11 */
2225	if (RT_FAILURE(rc))
2226	return rc;
2227	if (rc >= 7)
2228	SSMR3Cancel(pVM->pUVM);
2229	}
2230
2231	/*
2232	* Check the state.
2233	*/
2234	VMSTATE enmVMState = VMR3GetState(pVM);
2235	AssertMsgReturn( enmVMState == VMSTATE_POWERING_OFF
2236	\|\| enmVMState == VMSTATE_POWERING_OFF_LS,
2237	("%s\n", VMR3GetStateName(enmVMState)),
2238	VERR_VM_INVALID_VM_STATE);
2239
2240	/*
2241	* EMT(0) does the actual power off work here after all the other EMTs
2242	* have been thru and entered the STOPPED state.
2243	*/
2244	VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STOPPED);
2245	if (pVCpu->idCpu == 0)
2246	{
2247	/*
2248	* For debugging purposes, we will log a summary of the guest state at this point.
2249	*/
2250	if (enmVMState != VMSTATE_GURU_MEDITATION)
2251	{
2252	/** @todo make the state dumping at VMR3PowerOff optional. */
2253	bool fOldBuffered = RTLogRelSetBuffering(true /fBuffered/);
2254	RTLogRelPrintf("**************** Guest state at power off for VCpu %u ****************\n", pVCpu->idCpu);
2255	DBGFR3InfoEx(pVM->pUVM, pVCpu->idCpu, "cpumguest", "verbose", DBGFR3InfoLogRelHlp());
2256	RTLogRelPrintf("***\n");
2257	DBGFR3InfoEx(pVM->pUVM, pVCpu->idCpu, "cpumguesthwvirt", "verbose", DBGFR3InfoLogRelHlp());
2258	RTLogRelPrintf("***\n");
2259	DBGFR3InfoEx(pVM->pUVM, pVCpu->idCpu, "mode", NULL, DBGFR3InfoLogRelHlp());
2260	RTLogRelPrintf("***\n");
2261	DBGFR3Info(pVM->pUVM, "activetimers", NULL, DBGFR3InfoLogRelHlp());
2262	RTLogRelPrintf("***\n");
2263	DBGFR3Info(pVM->pUVM, "gdt", NULL, DBGFR3InfoLogRelHlp());
2264	/** @todo dump guest call stack. */
2265	RTLogRelSetBuffering(fOldBuffered);
2266	RTLogRelPrintf("************ End of Guest state at power off *************\n");
2267	}
2268
2269	/*
2270	* Perform the power off notifications and advance the state to
2271	* Off or OffLS.
2272	*/
2273	PDMR3PowerOff(pVM);
2274	DBGFR3PowerOff(pVM);
2275
2276	PUVM pUVM = pVM->pUVM;
2277	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
2278	enmVMState = pVM->enmVMState;
2279	if (enmVMState == VMSTATE_POWERING_OFF_LS)
2280	vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF_LS, VMSTATE_POWERING_OFF_LS, false /fSetRatherThanClearFF/);
2281	else
2282	vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF, VMSTATE_POWERING_OFF, false /fSetRatherThanClearFF/);
2283	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
2284	}
2285	else if (enmVMState != VMSTATE_GURU_MEDITATION)
2286	{
2287	/** @todo make the state dumping at VMR3PowerOff optional. */
2288	bool fOldBuffered = RTLogRelSetBuffering(true /fBuffered/);
2289	RTLogRelPrintf("**************** Guest state at power off for VCpu %u ****************\n", pVCpu->idCpu);
2290	DBGFR3InfoEx(pVM->pUVM, pVCpu->idCpu, "cpumguest", "verbose", DBGFR3InfoLogRelHlp());
2291	RTLogRelPrintf("***\n");
2292	DBGFR3InfoEx(pVM->pUVM, pVCpu->idCpu, "cpumguesthwvirt", "verbose", DBGFR3InfoLogRelHlp());
2293	RTLogRelPrintf("***\n");
2294	DBGFR3InfoEx(pVM->pUVM, pVCpu->idCpu, "mode", NULL, DBGFR3InfoLogRelHlp());
2295	RTLogRelPrintf("***\n");
2296	RTLogRelSetBuffering(fOldBuffered);
2297	RTLogRelPrintf("************ End of Guest state at power off for VCpu %u *************\n", pVCpu->idCpu);
2298	}
2299
2300	return VINF_EM_OFF;
2301	}
2302
2303
2304	/**
2305	* Power off the VM.
2306	*
2307	* @returns VBox status code. When called on EMT, this will be a strict status
2308	* code that has to be propagated up the call stack.
2309	*
2310	* @param pUVM The handle of the VM to be powered off.
2311	*
2312	* @thread Any thread.
2313	* @vmstate Suspended, Running, Guru Meditation, Load Failure
2314	* @vmstateto Off or OffLS
2315	*/
2316	VMMR3DECL(int) VMR3PowerOff(PUVM pUVM)
2317	{
2318	LogFlow(("VMR3PowerOff: pUVM=%p\n", pUVM));
2319	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2320	PVM pVM = pUVM->pVM;
2321	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
2322
2323	/*
2324	* Gather all the EMTs to make sure there are no races before
2325	* changing the VM state.
2326	*/
2327	int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
2328	vmR3PowerOff, NULL);
2329	LogFlow(("VMR3PowerOff: returns %Rrc\n", rc));
2330	return rc;
2331	}
2332
2333
2334	/**
2335	* Destroys the VM.
2336	*
2337	* The VM must be powered off (or never really powered on) to call this
2338	* function. The VM handle is destroyed and can no longer be used up successful
2339	* return.
2340	*
2341	* @returns VBox status code.
2342	*
2343	* @param pUVM The user mode VM handle.
2344	*
2345	* @thread Any none emulation thread.
2346	* @vmstate Off, Created
2347	* @vmstateto N/A
2348	*/
2349	VMMR3DECL(int) VMR3Destroy(PUVM pUVM)
2350	{
2351	LogFlow(("VMR3Destroy: pUVM=%p\n", pUVM));
2352
2353	/*
2354	* Validate input.
2355	*/
2356	if (!pUVM)
2357	return VERR_INVALID_VM_HANDLE;
2358	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2359	PVM pVM = pUVM->pVM;
2360	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
2361	AssertLogRelReturn(!VM_IS_EMT(pVM), VERR_VM_THREAD_IS_EMT);
2362
2363	/*
2364	* Change VM state to destroying and aall vmR3Destroy on each of the EMTs
2365	* ending with EMT(0) doing the bulk of the cleanup.
2366	*/
2367	int rc = vmR3TrySetState(pVM, "VMR3Destroy", 1, VMSTATE_DESTROYING, VMSTATE_OFF);
2368	if (RT_FAILURE(rc))
2369	return rc;
2370
2371	rc = VMR3ReqCallWait(pVM, VMCPUID_ALL_REVERSE, (PFNRT)vmR3Destroy, 1, pVM);
2372	AssertLogRelRC(rc);
2373
2374	/*
2375	* Wait for EMTs to quit and destroy the UVM.
2376	*/
2377	vmR3DestroyUVM(pUVM, 30000);
2378
2379	LogFlow(("VMR3Destroy: returns VINF_SUCCESS\n"));
2380	return VINF_SUCCESS;
2381	}
2382
2383
2384	/**
2385	* Internal destruction worker.
2386	*
2387	* This is either called from VMR3Destroy via VMR3ReqCallU or from
2388	* vmR3EmulationThreadWithId when EMT(0) terminates after having called
2389	* VMR3Destroy().
2390	*
2391	* When called on EMT(0), it will performed the great bulk of the destruction.
2392	* When called on the other EMTs, they will do nothing and the whole purpose is
2393	* to return VINF_EM_TERMINATE so they break out of their run loops.
2394	*
2395	* @returns VINF_EM_TERMINATE.
2396	* @param pVM The cross context VM structure.
2397	*/
2398	DECLCALLBACK(int) vmR3Destroy(PVM pVM)
2399	{
2400	PUVM pUVM = pVM->pUVM;
2401	PVMCPU pVCpu = VMMGetCpu(pVM);
2402	Assert(pVCpu);
2403	LogFlow(("vmR3Destroy: pVM=%p pUVM=%p pVCpu=%p idCpu=%u\n", pVM, pUVM, pVCpu, pVCpu->idCpu));
2404
2405	/*
2406	* Only VCPU 0 does the full cleanup (last).
2407	*/
2408	if (pVCpu->idCpu == 0)
2409	{
2410	/*
2411	* Dump statistics to the log.
2412	*/
2413	#if defined(VBOX_WITH_STATISTICS) \|\| defined(LOG_ENABLED)
2414	RTLogFlags(NULL, "nodisabled nobuffered");
2415	#endif
2416	//#ifdef VBOX_WITH_STATISTICS
2417	// STAMR3Dump(pUVM, "*");
2418	//#else
2419	LogRel(("*********************** Statistics ***********************\n"));
2420	STAMR3DumpToReleaseLog(pUVM, "*");
2421	LogRel(("******************* End of statistics ********************\n"));
2422	//#endif
2423
2424	/*
2425	* Destroy the VM components.
2426	*/
2427	int rc = TMR3Term(pVM);
2428	AssertRC(rc);
2429	#ifdef VBOX_WITH_DEBUGGER
2430	rc = DBGCTcpTerminate(pUVM, pUVM->vm.s.pvDBGC);
2431	pUVM->vm.s.pvDBGC = NULL;
2432	#endif
2433	AssertRC(rc);
2434	rc = FTMR3Term(pVM);
2435	AssertRC(rc);
2436	rc = PDMR3Term(pVM);
2437	AssertRC(rc);
2438	rc = GIMR3Term(pVM);
2439	AssertRC(rc);
2440	rc = DBGFR3Term(pVM);
2441	AssertRC(rc);
2442	rc = IEMR3Term(pVM);
2443	AssertRC(rc);
2444	rc = EMR3Term(pVM);
2445	AssertRC(rc);
2446	rc = IOMR3Term(pVM);
2447	AssertRC(rc);
2448	#ifdef VBOX_WITH_RAW_MODE
2449	rc = CSAMR3Term(pVM);
2450	AssertRC(rc);
2451	rc = PATMR3Term(pVM);
2452	AssertRC(rc);
2453	#endif
2454	rc = TRPMR3Term(pVM);
2455	AssertRC(rc);
2456	rc = SELMR3Term(pVM);
2457	AssertRC(rc);
2458	#ifdef VBOX_WITH_REM
2459	rc = REMR3Term(pVM);
2460	AssertRC(rc);
2461	#endif
2462	rc = HMR3Term(pVM);
2463	AssertRC(rc);
2464	rc = NEMR3Term(pVM);
2465	AssertRC(rc);
2466	rc = PGMR3Term(pVM);
2467	AssertRC(rc);
2468	rc = VMMR3Term(pVM); /* Terminates the ring-0 code! */
2469	AssertRC(rc);
2470	rc = CPUMR3Term(pVM);
2471	AssertRC(rc);
2472	SSMR3Term(pVM);
2473	rc = PDMR3CritSectBothTerm(pVM);
2474	AssertRC(rc);
2475	rc = MMR3Term(pVM);
2476	AssertRC(rc);
2477
2478	/*
2479	* We're done, tell the other EMTs to quit.
2480	*/
2481	ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
2482	ASMAtomicWriteU32(&pVM->fGlobalForcedActions, VM_FF_CHECK_VM_STATE); /* Can't hurt... */
2483	LogFlow(("vmR3Destroy: returning %Rrc\n", VINF_EM_TERMINATE));
2484	}
2485
2486	/*
2487	* Decrement the active EMT count here.
2488	*/
2489	PUVMCPU pUVCpu = &pUVM->aCpus[pVCpu->idCpu];
2490	if (!pUVCpu->vm.s.fBeenThruVmDestroy)
2491	{
2492	pUVCpu->vm.s.fBeenThruVmDestroy = true;
2493	ASMAtomicDecU32(&pUVM->vm.s.cActiveEmts);
2494	}
2495	else
2496	AssertFailed();
2497
2498	return VINF_EM_TERMINATE;
2499	}
2500
2501
2502	/**
2503	* Destroys the UVM portion.
2504	*
2505	* This is called as the final step in the VM destruction or as the cleanup
2506	* in case of a creation failure.
2507	*
2508	* @param pUVM The user mode VM structure.
2509	* @param cMilliesEMTWait The number of milliseconds to wait for the emulation
2510	* threads.
2511	*/
2512	static void vmR3DestroyUVM(PUVM pUVM, uint32_t cMilliesEMTWait)
2513	{
2514	/*
2515	* Signal termination of each the emulation threads and
2516	* wait for them to complete.
2517	*/
2518	/* Signal them - in reverse order since EMT(0) waits for the others. */
2519	ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
2520	if (pUVM->pVM)
2521	VM_FF_SET(pUVM->pVM, VM_FF_CHECK_VM_STATE); /* Can't hurt... */
2522	VMCPUID iCpu = pUVM->cCpus;
2523	while (iCpu-- > 0)
2524	{
2525	VMR3NotifyGlobalFFU(pUVM, VMNOTIFYFF_FLAGS_DONE_REM);
2526	RTSemEventSignal(pUVM->aCpus[iCpu].vm.s.EventSemWait);
2527	}
2528
2529	/* Wait for EMT(0), it in turn waits for the rest. */
2530	ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
2531
2532	RTTHREAD const hSelf = RTThreadSelf();
2533	RTTHREAD hThread = pUVM->aCpus[0].vm.s.ThreadEMT;
2534	if ( hThread != NIL_RTTHREAD
2535	&& hThread != hSelf)
2536	{
2537	int rc2 = RTThreadWait(hThread, RT_MAX(cMilliesEMTWait, 2000), NULL);
2538	if (rc2 == VERR_TIMEOUT) /* avoid the assertion when debugging. */
2539	rc2 = RTThreadWait(hThread, 1000, NULL);
2540	AssertLogRelMsgRC(rc2, ("iCpu=0 rc=%Rrc\n", rc2));
2541	if (RT_SUCCESS(rc2))
2542	pUVM->aCpus[0].vm.s.ThreadEMT = NIL_RTTHREAD;
2543	}
2544
2545	/* Just in case we're in a weird failure situation w/o EMT(0) to do the
2546	waiting, wait the other EMTs too. */
2547	for (iCpu = 1; iCpu < pUVM->cCpus; iCpu++)
2548	{
2549	ASMAtomicXchgHandle(&pUVM->aCpus[iCpu].vm.s.ThreadEMT, NIL_RTTHREAD, &hThread);
2550	if (hThread != NIL_RTTHREAD)
2551	{
2552	if (hThread != hSelf)
2553	{
2554	int rc2 = RTThreadWait(hThread, 250 /ms/, NULL);
2555	AssertLogRelMsgRC(rc2, ("iCpu=%u rc=%Rrc\n", iCpu, rc2));
2556	if (RT_SUCCESS(rc2))
2557	continue;
2558	}
2559	pUVM->aCpus[iCpu].vm.s.ThreadEMT = hThread;
2560	}
2561	}
2562
2563	/* Cleanup the semaphores. */
2564	iCpu = pUVM->cCpus;
2565	while (iCpu-- > 0)
2566	{
2567	RTSemEventDestroy(pUVM->aCpus[iCpu].vm.s.EventSemWait);
2568	pUVM->aCpus[iCpu].vm.s.EventSemWait = NIL_RTSEMEVENT;
2569	}
2570
2571	/*
2572	* Free the event semaphores associated with the request packets.
2573	*/
2574	unsigned cReqs = 0;
2575	for (unsigned i = 0; i < RT_ELEMENTS(pUVM->vm.s.apReqFree); i++)
2576	{
2577	PVMREQ pReq = pUVM->vm.s.apReqFree[i];
2578	pUVM->vm.s.apReqFree[i] = NULL;
2579	for (; pReq; pReq = pReq->pNext, cReqs++)
2580	{
2581	pReq->enmState = VMREQSTATE_INVALID;
2582	RTSemEventDestroy(pReq->EventSem);
2583	}
2584	}
2585	Assert(cReqs == pUVM->vm.s.cReqFree); NOREF(cReqs);
2586
2587	/*
2588	* Kill all queued requests. (There really shouldn't be any!)
2589	*/
2590	for (unsigned i = 0; i < 10; i++)
2591	{
2592	PVMREQ pReqHead = ASMAtomicXchgPtrT(&pUVM->vm.s.pPriorityReqs, NULL, PVMREQ);
2593	if (!pReqHead)
2594	{
2595	pReqHead = ASMAtomicXchgPtrT(&pUVM->vm.s.pNormalReqs, NULL, PVMREQ);
2596	if (!pReqHead)
2597	break;
2598	}
2599	AssertLogRelMsgFailed(("Requests pending! VMR3Destroy caller has to serialize this.\n"));
2600
2601	for (PVMREQ pReq = pReqHead; pReq; pReq = pReq->pNext)
2602	{
2603	ASMAtomicUoWriteS32(&pReq->iStatus, VERR_VM_REQUEST_KILLED);
2604	ASMAtomicWriteSize(&pReq->enmState, VMREQSTATE_INVALID);
2605	RTSemEventSignal(pReq->EventSem);
2606	RTThreadSleep(2);
2607	RTSemEventDestroy(pReq->EventSem);
2608	}
2609	/* give them a chance to respond before we free the request memory. */
2610	RTThreadSleep(32);
2611	}
2612
2613	/*
2614	* Now all queued VCPU requests (again, there shouldn't be any).
2615	*/
2616	for (VMCPUID idCpu = 0; idCpu < pUVM->cCpus; idCpu++)
2617	{
2618	PUVMCPU pUVCpu = &pUVM->aCpus[idCpu];
2619
2620	for (unsigned i = 0; i < 10; i++)
2621	{
2622	PVMREQ pReqHead = ASMAtomicXchgPtrT(&pUVCpu->vm.s.pPriorityReqs, NULL, PVMREQ);
2623	if (!pReqHead)
2624	{
2625	pReqHead = ASMAtomicXchgPtrT(&pUVCpu->vm.s.pNormalReqs, NULL, PVMREQ);
2626	if (!pReqHead)
2627	break;
2628	}
2629	AssertLogRelMsgFailed(("Requests pending! VMR3Destroy caller has to serialize this.\n"));
2630
2631	for (PVMREQ pReq = pReqHead; pReq; pReq = pReq->pNext)
2632	{
2633	ASMAtomicUoWriteS32(&pReq->iStatus, VERR_VM_REQUEST_KILLED);
2634	ASMAtomicWriteSize(&pReq->enmState, VMREQSTATE_INVALID);
2635	RTSemEventSignal(pReq->EventSem);
2636	RTThreadSleep(2);
2637	RTSemEventDestroy(pReq->EventSem);
2638	}
2639	/* give them a chance to respond before we free the request memory. */
2640	RTThreadSleep(32);
2641	}
2642	}
2643
2644	/*
2645	* Make sure the VMMR0.r0 module and whatever else is unloaded.
2646	*/
2647	PDMR3TermUVM(pUVM);
2648
2649	RTCritSectDelete(&pUVM->vm.s.AtErrorCritSect);
2650	RTCritSectDelete(&pUVM->vm.s.AtStateCritSect);
2651
2652	/*
2653	* Terminate the support library if initialized.
2654	*/
2655	if (pUVM->vm.s.pSession)
2656	{
2657	int rc = SUPR3Term(false /fForced/);
2658	AssertRC(rc);
2659	pUVM->vm.s.pSession = NIL_RTR0PTR;
2660	}
2661
2662	/*
2663	* Release the UVM structure reference.
2664	*/
2665	VMR3ReleaseUVM(pUVM);
2666
2667	/*
2668	* Clean up and flush logs.
2669	*/
2670	RTLogFlush(NULL);
2671	}
2672
2673
2674	/**
2675	* Worker which checks integrity of some internal structures.
2676	* This is yet another attempt to track down that AVL tree crash.
2677	*/
2678	static void vmR3CheckIntegrity(PVM pVM)
2679	{
2680	#ifdef VBOX_STRICT
2681	int rc = PGMR3CheckIntegrity(pVM);
2682	AssertReleaseRC(rc);
2683	#else
2684	RT_NOREF_PV(pVM);
2685	#endif
2686	}
2687
2688
2689	/**
2690	* EMT rendezvous worker for VMR3ResetFF for doing soft/warm reset.
2691	*
2692	* @returns VERR_VM_INVALID_VM_STATE, VINF_EM_RESCHEDULE.
2693	* (This is a strict return code, see FNVMMEMTRENDEZVOUS.)
2694	*
2695	* @param pVM The cross context VM structure.
2696	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
2697	* @param pvUser The reset flags.
2698	*/
2699	static DECLCALLBACK(VBOXSTRICTRC) vmR3SoftReset(PVM pVM, PVMCPU pVCpu, void *pvUser)
2700	{
2701	uint32_t fResetFlags = (uint32_t )pvUser;
2702
2703
2704	/*
2705	* The first EMT will try change the state to resetting. If this fails,
2706	* we won't get called for the other EMTs.
2707	*/
2708	if (pVCpu->idCpu == pVM->cCpus - 1)
2709	{
2710	int rc = vmR3TrySetState(pVM, "vmR3ResetSoft", 3,
2711	VMSTATE_SOFT_RESETTING, VMSTATE_RUNNING,
2712	VMSTATE_SOFT_RESETTING, VMSTATE_SUSPENDED,
2713	VMSTATE_SOFT_RESETTING_LS, VMSTATE_RUNNING_LS);
2714	if (RT_FAILURE(rc))
2715	return rc;
2716	pVM->vm.s.cResets++;
2717	pVM->vm.s.cSoftResets++;
2718	}
2719
2720	/*
2721	* Check the state.
2722	*/
2723	VMSTATE enmVMState = VMR3GetState(pVM);
2724	AssertLogRelMsgReturn( enmVMState == VMSTATE_SOFT_RESETTING
2725	\|\| enmVMState == VMSTATE_SOFT_RESETTING_LS,
2726	("%s\n", VMR3GetStateName(enmVMState)),
2727	VERR_VM_UNEXPECTED_UNSTABLE_STATE);
2728
2729	/*
2730	* EMT(0) does the full cleanup after all the other EMTs has been
2731	* thru here and been told to enter the EMSTATE_WAIT_SIPI state.
2732	*
2733	* Because there are per-cpu reset routines and order may/is important,
2734	* the following sequence looks a bit ugly...
2735	*/
2736
2737	/* Reset the VCpu state. */
2738	VMCPU_ASSERT_STATE(pVCpu, VMCPUSTATE_STARTED);
2739
2740	/*
2741	* Soft reset the VM components.
2742	*/
2743	if (pVCpu->idCpu == 0)
2744	{
2745	#ifdef VBOX_WITH_REM
2746	REMR3Reset(pVM);
2747	#endif
2748	PDMR3SoftReset(pVM, fResetFlags);
2749	TRPMR3Reset(pVM);
2750	CPUMR3Reset(pVM); /* This must come after PDM (due to APIC base MSR caching). */
2751	EMR3Reset(pVM);
2752	HMR3Reset(pVM); /* This must come after PATM, CSAM, CPUM, SELM and TRPM. */
2753	NEMR3Reset(pVM);
2754
2755	/*
2756	* Since EMT(0) is the last to go thru here, it will advance the state.
2757	* (Unlike vmR3HardReset we won't be doing any suspending of live
2758	* migration VMs here since memory is unchanged.)
2759	*/
2760	PUVM pUVM = pVM->pUVM;
2761	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
2762	enmVMState = pVM->enmVMState;
2763	if (enmVMState == VMSTATE_SOFT_RESETTING)
2764	{
2765	if (pUVM->vm.s.enmPrevVMState == VMSTATE_SUSPENDED)
2766	vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDED, VMSTATE_SOFT_RESETTING, false /fSetRatherThanClearFF/);
2767	else
2768	vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING, VMSTATE_SOFT_RESETTING, false /fSetRatherThanClearFF/);
2769	}
2770	else
2771	vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING_LS, VMSTATE_SOFT_RESETTING_LS, false /fSetRatherThanClearFF/);
2772	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
2773	}
2774
2775	return VINF_EM_RESCHEDULE;
2776	}
2777
2778
2779	/**
2780	* EMT rendezvous worker for VMR3Reset and VMR3ResetFF.
2781	*
2782	* This is called by the emulation threads as a response to the reset request
2783	* issued by VMR3Reset().
2784	*
2785	* @returns VERR_VM_INVALID_VM_STATE, VINF_EM_RESET or VINF_EM_SUSPEND. (This
2786	* is a strict return code, see FNVMMEMTRENDEZVOUS.)
2787	*
2788	* @param pVM The cross context VM structure.
2789	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
2790	* @param pvUser Ignored.
2791	*/
2792	static DECLCALLBACK(VBOXSTRICTRC) vmR3HardReset(PVM pVM, PVMCPU pVCpu, void *pvUser)
2793	{
2794	Assert(!pvUser); NOREF(pvUser);
2795
2796	/*
2797	* The first EMT will try change the state to resetting. If this fails,
2798	* we won't get called for the other EMTs.
2799	*/
2800	if (pVCpu->idCpu == pVM->cCpus - 1)
2801	{
2802	int rc = vmR3TrySetState(pVM, "vmR3HardReset", 3,
2803	VMSTATE_RESETTING, VMSTATE_RUNNING,
2804	VMSTATE_RESETTING, VMSTATE_SUSPENDED,
2805	VMSTATE_RESETTING_LS, VMSTATE_RUNNING_LS);
2806	if (RT_FAILURE(rc))
2807	return rc;
2808	pVM->vm.s.cResets++;
2809	pVM->vm.s.cHardResets++;
2810	}
2811
2812	/*
2813	* Check the state.
2814	*/
2815	VMSTATE enmVMState = VMR3GetState(pVM);
2816	AssertLogRelMsgReturn( enmVMState == VMSTATE_RESETTING
2817	\|\| enmVMState == VMSTATE_RESETTING_LS,
2818	("%s\n", VMR3GetStateName(enmVMState)),
2819	VERR_VM_UNEXPECTED_UNSTABLE_STATE);
2820
2821	/*
2822	* EMT(0) does the full cleanup after all the other EMTs has been
2823	* thru here and been told to enter the EMSTATE_WAIT_SIPI state.
2824	*
2825	* Because there are per-cpu reset routines and order may/is important,
2826	* the following sequence looks a bit ugly...
2827	*/
2828	if (pVCpu->idCpu == 0)
2829	vmR3CheckIntegrity(pVM);
2830
2831	/* Reset the VCpu state. */
2832	VMCPU_ASSERT_STATE(pVCpu, VMCPUSTATE_STARTED);
2833
2834	/* Clear all pending forced actions. */
2835	VMCPU_FF_CLEAR_MASK(pVCpu, VMCPU_FF_ALL_MASK & ~VMCPU_FF_REQUEST);
2836
2837	/*
2838	* Reset the VM components.
2839	*/
2840	if (pVCpu->idCpu == 0)
2841	{
2842	#ifdef VBOX_WITH_RAW_MODE
2843	PATMR3Reset(pVM);
2844	CSAMR3Reset(pVM);
2845	#endif
2846	GIMR3Reset(pVM); /* This must come before PDM and TM. */
2847	PDMR3Reset(pVM);
2848	PGMR3Reset(pVM);
2849	SELMR3Reset(pVM);
2850	TRPMR3Reset(pVM);
2851	#ifdef VBOX_WITH_REM
2852	REMR3Reset(pVM);
2853	#endif
2854	IOMR3Reset(pVM);
2855	CPUMR3Reset(pVM); /* This must come after PDM (due to APIC base MSR caching). */
2856	TMR3Reset(pVM);
2857	EMR3Reset(pVM);
2858	HMR3Reset(pVM); /* This must come after PATM, CSAM, CPUM, SELM and TRPM. */
2859	NEMR3Reset(pVM);
2860
2861	/*
2862	* Do memory setup.
2863	*/
2864	PGMR3MemSetup(pVM, true /fAtReset/);
2865	PDMR3MemSetup(pVM, true /fAtReset/);
2866
2867	/*
2868	* Since EMT(0) is the last to go thru here, it will advance the state.
2869	* When a live save is active, we will move on to SuspendingLS but
2870	* leave it for VMR3Reset to do the actual suspending due to deadlock risks.
2871	*/
2872	PUVM pUVM = pVM->pUVM;
2873	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
2874	enmVMState = pVM->enmVMState;
2875	if (enmVMState == VMSTATE_RESETTING)
2876	{
2877	if (pUVM->vm.s.enmPrevVMState == VMSTATE_SUSPENDED)
2878	vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDED, VMSTATE_RESETTING, false /fSetRatherThanClearFF/);
2879	else
2880	vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING, VMSTATE_RESETTING, false /fSetRatherThanClearFF/);
2881	}
2882	else
2883	vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDING_LS, VMSTATE_RESETTING_LS, false /fSetRatherThanClearFF/);
2884	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
2885
2886	vmR3CheckIntegrity(pVM);
2887
2888	/*
2889	* Do the suspend bit as well.
2890	* It only requires some EMT(0) work at present.
2891	*/
2892	if (enmVMState != VMSTATE_RESETTING)
2893	{
2894	vmR3SuspendDoWork(pVM);
2895	vmR3SetState(pVM, VMSTATE_SUSPENDED_LS, VMSTATE_SUSPENDING_LS);
2896	}
2897	}
2898
2899	return enmVMState == VMSTATE_RESETTING
2900	? VINF_EM_RESET
2901	: VINF_EM_SUSPEND; /** @todo VINF_EM_SUSPEND has lower priority than VINF_EM_RESET, so fix races. Perhaps add a new code for this combined case. */
2902	}
2903
2904
2905	/**
2906	* Internal worker for VMR3Reset, VMR3ResetFF, VMR3TripleFault.
2907	*
2908	* @returns VBox status code.
2909	* @param pVM The cross context VM structure.
2910	* @param fHardReset Whether it's a hard reset or not.
2911	* @param fResetFlags The reset flags (PDMVMRESET_F_XXX).
2912	*/
2913	static VBOXSTRICTRC vmR3ResetCommon(PVM pVM, bool fHardReset, uint32_t fResetFlags)
2914	{
2915	LogFlow(("vmR3ResetCommon: fHardReset=%RTbool fResetFlags=%#x\n", fHardReset, fResetFlags));
2916	int rc;
2917	if (fHardReset)
2918	{
2919	/*
2920	* Hard reset.
2921	*/
2922	/* Check whether we're supposed to power off instead of resetting. */
2923	if (pVM->vm.s.fPowerOffInsteadOfReset)
2924	{
2925	PUVM pUVM = pVM->pUVM;
2926	if ( pUVM->pVmm2UserMethods
2927	&& pUVM->pVmm2UserMethods->pfnNotifyResetTurnedIntoPowerOff)
2928	pUVM->pVmm2UserMethods->pfnNotifyResetTurnedIntoPowerOff(pUVM->pVmm2UserMethods, pUVM);
2929	return VMR3PowerOff(pUVM);
2930	}
2931
2932	/* Gather all the EMTs to make sure there are no races before changing
2933	the VM state. */
2934	rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
2935	vmR3HardReset, NULL);
2936	}
2937	else
2938	{
2939	/*
2940	* Soft reset. Since we only support this with a single CPU active,
2941	* we must be on EMT #0 here.
2942	*/
2943	VM_ASSERT_EMT0(pVM);
2944	rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
2945	vmR3SoftReset, &fResetFlags);
2946	}
2947
2948	LogFlow(("vmR3ResetCommon: returns %Rrc\n", rc));
2949	return rc;
2950	}
2951
2952
2953
2954	/**
2955	* Reset the current VM.
2956	*
2957	* @returns VBox status code.
2958	* @param pUVM The VM to reset.
2959	*/
2960	VMMR3DECL(int) VMR3Reset(PUVM pUVM)
2961	{
2962	LogFlow(("VMR3Reset:\n"));
2963	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2964	PVM pVM = pUVM->pVM;
2965	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
2966
2967	return VBOXSTRICTRC_VAL(vmR3ResetCommon(pVM, true, 0));
2968	}
2969
2970
2971	/**
2972	* Handle the reset force flag or triple fault.
2973	*
2974	* This handles both soft and hard resets (see PDMVMRESET_F_XXX).
2975	*
2976	* @returns VBox status code.
2977	* @param pVM The cross context VM structure.
2978	* @thread EMT
2979	*
2980	* @remarks Caller is expected to clear the VM_FF_RESET force flag.
2981	*/
2982	VMMR3_INT_DECL(VBOXSTRICTRC) VMR3ResetFF(PVM pVM)
2983	{
2984	LogFlow(("VMR3ResetFF:\n"));
2985
2986	/*
2987	* First consult the firmware on whether this is a hard or soft reset.
2988	*/
2989	uint32_t fResetFlags;
2990	bool fHardReset = PDMR3GetResetInfo(pVM, 0 /fOverride/, &fResetFlags);
2991	return vmR3ResetCommon(pVM, fHardReset, fResetFlags);
2992	}
2993
2994
2995	/**
2996	* For handling a CPU reset on triple fault.
2997	*
2998	* According to one mainboard manual, a CPU triple fault causes the 286 CPU to
2999	* send a SHUTDOWN signal to the chipset. The chipset responds by sending a
3000	* RESET signal to the CPU. So, it should be very similar to a soft/warm reset.
3001	*
3002	* @returns VBox status code.
3003	* @param pVM The cross context VM structure.
3004	* @thread EMT
3005	*/
3006	VMMR3_INT_DECL(VBOXSTRICTRC) VMR3ResetTripleFault(PVM pVM)
3007	{
3008	LogFlow(("VMR3ResetTripleFault:\n"));
3009
3010	/*
3011	* First consult the firmware on whether this is a hard or soft reset.
3012	*/
3013	uint32_t fResetFlags;
3014	bool fHardReset = PDMR3GetResetInfo(pVM, PDMVMRESET_F_TRIPLE_FAULT, &fResetFlags);
3015	return vmR3ResetCommon(pVM, fHardReset, fResetFlags);
3016	}
3017
3018
3019	/**
3020	* Gets the user mode VM structure pointer given Pointer to the VM.
3021	*
3022	* @returns Pointer to the user mode VM structure on success. NULL if @a pVM is
3023	* invalid (asserted).
3024	* @param pVM The cross context VM structure.
3025	* @sa VMR3GetVM, VMR3RetainUVM
3026	*/
3027	VMMR3DECL(PUVM) VMR3GetUVM(PVM pVM)
3028	{
3029	VM_ASSERT_VALID_EXT_RETURN(pVM, NULL);
3030	return pVM->pUVM;
3031	}
3032
3033
3034	/**
3035	* Gets the shared VM structure pointer given the pointer to the user mode VM
3036	* structure.
3037	*
3038	* @returns Pointer to the VM.
3039	* NULL if @a pUVM is invalid (asserted) or if no shared VM structure
3040	* is currently associated with it.
3041	* @param pUVM The user mode VM handle.
3042	* @sa VMR3GetUVM
3043	*/
3044	VMMR3DECL(PVM) VMR3GetVM(PUVM pUVM)
3045	{
3046	UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
3047	return pUVM->pVM;
3048	}
3049
3050
3051	/**
3052	* Retain the user mode VM handle.
3053	*
3054	* @returns Reference count.
3055	* UINT32_MAX if @a pUVM is invalid.
3056	*
3057	* @param pUVM The user mode VM handle.
3058	* @sa VMR3ReleaseUVM
3059	*/
3060	VMMR3DECL(uint32_t) VMR3RetainUVM(PUVM pUVM)
3061	{
3062	UVM_ASSERT_VALID_EXT_RETURN(pUVM, UINT32_MAX);
3063	uint32_t cRefs = ASMAtomicIncU32(&pUVM->vm.s.cUvmRefs);
3064	AssertMsg(cRefs > 0 && cRefs < _64K, ("%u\n", cRefs));
3065	return cRefs;
3066	}
3067
3068
3069	/**
3070	* Does the final release of the UVM structure.
3071	*
3072	* @param pUVM The user mode VM handle.
3073	*/
3074	static void vmR3DoReleaseUVM(PUVM pUVM)
3075	{
3076	/*
3077	* Free the UVM.
3078	*/
3079	Assert(!pUVM->pVM);
3080
3081	MMR3HeapFree(pUVM->vm.s.pszName);
3082	pUVM->vm.s.pszName = NULL;
3083
3084	MMR3TermUVM(pUVM);
3085	STAMR3TermUVM(pUVM);
3086
3087	ASMAtomicUoWriteU32(&pUVM->u32Magic, UINT32_MAX);
3088	RTTlsFree(pUVM->vm.s.idxTLS);
3089	RTMemPageFree(pUVM, RT_UOFFSETOF_DYN(UVM, aCpus[pUVM->cCpus]));
3090	}
3091
3092
3093	/**
3094	* Releases a refernece to the mode VM handle.
3095	*
3096	* @returns The new reference count, 0 if destroyed.
3097	* UINT32_MAX if @a pUVM is invalid.
3098	*
3099	* @param pUVM The user mode VM handle.
3100	* @sa VMR3RetainUVM
3101	*/
3102	VMMR3DECL(uint32_t) VMR3ReleaseUVM(PUVM pUVM)
3103	{
3104	if (!pUVM)
3105	return 0;
3106	UVM_ASSERT_VALID_EXT_RETURN(pUVM, UINT32_MAX);
3107	uint32_t cRefs = ASMAtomicDecU32(&pUVM->vm.s.cUvmRefs);
3108	if (!cRefs)
3109	vmR3DoReleaseUVM(pUVM);
3110	else
3111	AssertMsg(cRefs < _64K, ("%u\n", cRefs));
3112	return cRefs;
3113	}
3114
3115
3116	/**
3117	* Gets the VM name.
3118	*
3119	* @returns Pointer to a read-only string containing the name. NULL if called
3120	* too early.
3121	* @param pUVM The user mode VM handle.
3122	*/
3123	VMMR3DECL(const char *) VMR3GetName(PUVM pUVM)
3124	{
3125	UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
3126	return pUVM->vm.s.pszName;
3127	}
3128
3129
3130	/**
3131	* Gets the VM UUID.
3132	*
3133	* @returns pUuid on success, NULL on failure.
3134	* @param pUVM The user mode VM handle.
3135	* @param pUuid Where to store the UUID.
3136	*/
3137	VMMR3DECL(PRTUUID) VMR3GetUuid(PUVM pUVM, PRTUUID pUuid)
3138	{
3139	UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
3140	AssertPtrReturn(pUuid, NULL);
3141
3142	*pUuid = pUVM->vm.s.Uuid;
3143	return pUuid;
3144	}
3145
3146
3147	/**
3148	* Gets the current VM state.
3149	*
3150	* @returns The current VM state.
3151	* @param pVM The cross context VM structure.
3152	* @thread Any
3153	*/
3154	VMMR3DECL(VMSTATE) VMR3GetState(PVM pVM)
3155	{
3156	AssertMsgReturn(RT_VALID_ALIGNED_PTR(pVM, PAGE_SIZE), ("%p\n", pVM), VMSTATE_TERMINATED);
3157	VMSTATE enmVMState = pVM->enmVMState;
3158	return enmVMState >= VMSTATE_CREATING && enmVMState <= VMSTATE_TERMINATED ? enmVMState : VMSTATE_TERMINATED;
3159	}
3160
3161
3162	/**
3163	* Gets the current VM state.
3164	*
3165	* @returns The current VM state.
3166	* @param pUVM The user-mode VM handle.
3167	* @thread Any
3168	*/
3169	VMMR3DECL(VMSTATE) VMR3GetStateU(PUVM pUVM)
3170	{
3171	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VMSTATE_TERMINATED);
3172	if (RT_UNLIKELY(!pUVM->pVM))
3173	return VMSTATE_TERMINATED;
3174	return pUVM->pVM->enmVMState;
3175	}
3176
3177
3178	/**
3179	* Gets the state name string for a VM state.
3180	*
3181	* @returns Pointer to the state name. (readonly)
3182	* @param enmState The state.
3183	*/
3184	VMMR3DECL(const char *) VMR3GetStateName(VMSTATE enmState)
3185	{
3186	switch (enmState)
3187	{
3188	case VMSTATE_CREATING: return "CREATING";
3189	case VMSTATE_CREATED: return "CREATED";
3190	case VMSTATE_LOADING: return "LOADING";
3191	case VMSTATE_POWERING_ON: return "POWERING_ON";
3192	case VMSTATE_RESUMING: return "RESUMING";
3193	case VMSTATE_RUNNING: return "RUNNING";
3194	case VMSTATE_RUNNING_LS: return "RUNNING_LS";
3195	case VMSTATE_RUNNING_FT: return "RUNNING_FT";
3196	case VMSTATE_RESETTING: return "RESETTING";
3197	case VMSTATE_RESETTING_LS: return "RESETTING_LS";
3198	case VMSTATE_SOFT_RESETTING: return "SOFT_RESETTING";
3199	case VMSTATE_SOFT_RESETTING_LS: return "SOFT_RESETTING_LS";
3200	case VMSTATE_SUSPENDED: return "SUSPENDED";
3201	case VMSTATE_SUSPENDED_LS: return "SUSPENDED_LS";
3202	case VMSTATE_SUSPENDED_EXT_LS: return "SUSPENDED_EXT_LS";
3203	case VMSTATE_SUSPENDING: return "SUSPENDING";
3204	case VMSTATE_SUSPENDING_LS: return "SUSPENDING_LS";
3205	case VMSTATE_SUSPENDING_EXT_LS: return "SUSPENDING_EXT_LS";
3206	case VMSTATE_SAVING: return "SAVING";
3207	case VMSTATE_DEBUGGING: return "DEBUGGING";
3208	case VMSTATE_DEBUGGING_LS: return "DEBUGGING_LS";
3209	case VMSTATE_POWERING_OFF: return "POWERING_OFF";
3210	case VMSTATE_POWERING_OFF_LS: return "POWERING_OFF_LS";
3211	case VMSTATE_FATAL_ERROR: return "FATAL_ERROR";
3212	case VMSTATE_FATAL_ERROR_LS: return "FATAL_ERROR_LS";
3213	case VMSTATE_GURU_MEDITATION: return "GURU_MEDITATION";
3214	case VMSTATE_GURU_MEDITATION_LS:return "GURU_MEDITATION_LS";
3215	case VMSTATE_LOAD_FAILURE: return "LOAD_FAILURE";
3216	case VMSTATE_OFF: return "OFF";
3217	case VMSTATE_OFF_LS: return "OFF_LS";
3218	case VMSTATE_DESTROYING: return "DESTROYING";
3219	case VMSTATE_TERMINATED: return "TERMINATED";
3220
3221	default:
3222	AssertMsgFailed(("Unknown state %d\n", enmState));
3223	return "Unknown!\n";
3224	}
3225	}
3226
3227
3228	/**
3229	* Validates the state transition in strict builds.
3230	*
3231	* @returns true if valid, false if not.
3232	*
3233	* @param enmStateOld The old (current) state.
3234	* @param enmStateNew The proposed new state.
3235	*
3236	* @remarks The reference for this is found in doc/vp/VMM.vpp, the VMSTATE
3237	* diagram (under State Machine Diagram).
3238	*/
3239	static bool vmR3ValidateStateTransition(VMSTATE enmStateOld, VMSTATE enmStateNew)
3240	{
3241	#ifndef VBOX_STRICT
3242	RT_NOREF2(enmStateOld, enmStateNew);
3243	#else
3244	switch (enmStateOld)
3245	{
3246	case VMSTATE_CREATING:
3247	AssertMsgReturn(enmStateNew == VMSTATE_CREATED, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3248	break;
3249
3250	case VMSTATE_CREATED:
3251	AssertMsgReturn( enmStateNew == VMSTATE_LOADING
3252	\|\| enmStateNew == VMSTATE_POWERING_ON
3253	\|\| enmStateNew == VMSTATE_POWERING_OFF
3254	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3255	break;
3256
3257	case VMSTATE_LOADING:
3258	AssertMsgReturn( enmStateNew == VMSTATE_SUSPENDED
3259	\|\| enmStateNew == VMSTATE_LOAD_FAILURE
3260	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3261	break;
3262
3263	case VMSTATE_POWERING_ON:
3264	AssertMsgReturn( enmStateNew == VMSTATE_RUNNING
3265	/\|\| enmStateNew == VMSTATE_FATAL_ERROR ?/
3266	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3267	break;
3268
3269	case VMSTATE_RESUMING:
3270	AssertMsgReturn( enmStateNew == VMSTATE_RUNNING
3271	/\|\| enmStateNew == VMSTATE_FATAL_ERROR ?/
3272	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3273	break;
3274
3275	case VMSTATE_RUNNING:
3276	AssertMsgReturn( enmStateNew == VMSTATE_POWERING_OFF
3277	\|\| enmStateNew == VMSTATE_SUSPENDING
3278	\|\| enmStateNew == VMSTATE_RESETTING
3279	\|\| enmStateNew == VMSTATE_SOFT_RESETTING
3280	\|\| enmStateNew == VMSTATE_RUNNING_LS
3281	\|\| enmStateNew == VMSTATE_RUNNING_FT
3282	\|\| enmStateNew == VMSTATE_DEBUGGING
3283	\|\| enmStateNew == VMSTATE_FATAL_ERROR
3284	\|\| enmStateNew == VMSTATE_GURU_MEDITATION
3285	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3286	break;
3287
3288	case VMSTATE_RUNNING_LS:
3289	AssertMsgReturn( enmStateNew == VMSTATE_POWERING_OFF_LS
3290	\|\| enmStateNew == VMSTATE_SUSPENDING_LS
3291	\|\| enmStateNew == VMSTATE_SUSPENDING_EXT_LS
3292	\|\| enmStateNew == VMSTATE_RESETTING_LS
3293	\|\| enmStateNew == VMSTATE_SOFT_RESETTING_LS
3294	\|\| enmStateNew == VMSTATE_RUNNING
3295	\|\| enmStateNew == VMSTATE_DEBUGGING_LS
3296	\|\| enmStateNew == VMSTATE_FATAL_ERROR_LS
3297	\|\| enmStateNew == VMSTATE_GURU_MEDITATION_LS
3298	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3299	break;
3300
3301	case VMSTATE_RUNNING_FT:
3302	AssertMsgReturn( enmStateNew == VMSTATE_POWERING_OFF
3303	\|\| enmStateNew == VMSTATE_FATAL_ERROR
3304	\|\| enmStateNew == VMSTATE_GURU_MEDITATION
3305	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3306	break;
3307
3308	case VMSTATE_RESETTING:
3309	AssertMsgReturn(enmStateNew == VMSTATE_RUNNING, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3310	break;
3311
3312	case VMSTATE_SOFT_RESETTING:
3313	AssertMsgReturn(enmStateNew == VMSTATE_RUNNING, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3314	break;
3315
3316	case VMSTATE_RESETTING_LS:
3317	AssertMsgReturn( enmStateNew == VMSTATE_SUSPENDING_LS
3318	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3319	break;
3320
3321	case VMSTATE_SOFT_RESETTING_LS:
3322	AssertMsgReturn( enmStateNew == VMSTATE_RUNNING_LS
3323	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3324	break;
3325
3326	case VMSTATE_SUSPENDING:
3327	AssertMsgReturn(enmStateNew == VMSTATE_SUSPENDED, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3328	break;
3329
3330	case VMSTATE_SUSPENDING_LS:
3331	AssertMsgReturn( enmStateNew == VMSTATE_SUSPENDING
3332	\|\| enmStateNew == VMSTATE_SUSPENDED_LS
3333	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3334	break;
3335
3336	case VMSTATE_SUSPENDING_EXT_LS:
3337	AssertMsgReturn( enmStateNew == VMSTATE_SUSPENDING
3338	\|\| enmStateNew == VMSTATE_SUSPENDED_EXT_LS
3339	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3340	break;
3341
3342	case VMSTATE_SUSPENDED:
3343	AssertMsgReturn( enmStateNew == VMSTATE_POWERING_OFF
3344	\|\| enmStateNew == VMSTATE_SAVING
3345	\|\| enmStateNew == VMSTATE_RESETTING
3346	\|\| enmStateNew == VMSTATE_SOFT_RESETTING
3347	\|\| enmStateNew == VMSTATE_RESUMING
3348	\|\| enmStateNew == VMSTATE_LOADING
3349	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3350	break;
3351
3352	case VMSTATE_SUSPENDED_LS:
3353	AssertMsgReturn( enmStateNew == VMSTATE_SUSPENDED
3354	\|\| enmStateNew == VMSTATE_SAVING
3355	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3356	break;
3357
3358	case VMSTATE_SUSPENDED_EXT_LS:
3359	AssertMsgReturn( enmStateNew == VMSTATE_SUSPENDED
3360	\|\| enmStateNew == VMSTATE_SAVING
3361	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3362	break;
3363
3364	case VMSTATE_SAVING:
3365	AssertMsgReturn(enmStateNew == VMSTATE_SUSPENDED, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3366	break;
3367
3368	case VMSTATE_DEBUGGING:
3369	AssertMsgReturn( enmStateNew == VMSTATE_RUNNING
3370	\|\| enmStateNew == VMSTATE_POWERING_OFF
3371	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3372	break;
3373
3374	case VMSTATE_DEBUGGING_LS:
3375	AssertMsgReturn( enmStateNew == VMSTATE_DEBUGGING
3376	\|\| enmStateNew == VMSTATE_RUNNING_LS
3377	\|\| enmStateNew == VMSTATE_POWERING_OFF_LS
3378	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3379	break;
3380
3381	case VMSTATE_POWERING_OFF:
3382	AssertMsgReturn(enmStateNew == VMSTATE_OFF, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3383	break;
3384
3385	case VMSTATE_POWERING_OFF_LS:
3386	AssertMsgReturn( enmStateNew == VMSTATE_POWERING_OFF
3387	\|\| enmStateNew == VMSTATE_OFF_LS
3388	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3389	break;
3390
3391	case VMSTATE_OFF:
3392	AssertMsgReturn(enmStateNew == VMSTATE_DESTROYING, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3393	break;
3394
3395	case VMSTATE_OFF_LS:
3396	AssertMsgReturn(enmStateNew == VMSTATE_OFF, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3397	break;
3398
3399	case VMSTATE_FATAL_ERROR:
3400	AssertMsgReturn(enmStateNew == VMSTATE_POWERING_OFF, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3401	break;
3402
3403	case VMSTATE_FATAL_ERROR_LS:
3404	AssertMsgReturn( enmStateNew == VMSTATE_FATAL_ERROR
3405	\|\| enmStateNew == VMSTATE_POWERING_OFF_LS
3406	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3407	break;
3408
3409	case VMSTATE_GURU_MEDITATION:
3410	AssertMsgReturn( enmStateNew == VMSTATE_DEBUGGING
3411	\|\| enmStateNew == VMSTATE_POWERING_OFF
3412	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3413	break;
3414
3415	case VMSTATE_GURU_MEDITATION_LS:
3416	AssertMsgReturn( enmStateNew == VMSTATE_GURU_MEDITATION
3417	\|\| enmStateNew == VMSTATE_DEBUGGING_LS
3418	\|\| enmStateNew == VMSTATE_POWERING_OFF_LS
3419	, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3420	break;
3421
3422	case VMSTATE_LOAD_FAILURE:
3423	AssertMsgReturn(enmStateNew == VMSTATE_POWERING_OFF, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3424	break;
3425
3426	case VMSTATE_DESTROYING:
3427	AssertMsgReturn(enmStateNew == VMSTATE_TERMINATED, ("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3428	break;
3429
3430	case VMSTATE_TERMINATED:
3431	default:
3432	AssertMsgFailedReturn(("%s -> %s\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)), false);
3433	break;
3434	}
3435	#endif /* VBOX_STRICT */
3436	return true;
3437	}
3438
3439
3440	/**
3441	* Does the state change callouts.
3442	*
3443	* The caller owns the AtStateCritSect.
3444	*
3445	* @param pVM The cross context VM structure.
3446	* @param pUVM The UVM handle.
3447	* @param enmStateNew The New state.
3448	* @param enmStateOld The old state.
3449	*/
3450	static void vmR3DoAtState(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld)
3451	{
3452	LogRel(("Changing the VM state from '%s' to '%s'\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)));
3453
3454	for (PVMATSTATE pCur = pUVM->vm.s.pAtState; pCur; pCur = pCur->pNext)
3455	{
3456	pCur->pfnAtState(pUVM, enmStateNew, enmStateOld, pCur->pvUser);
3457	if ( enmStateNew != VMSTATE_DESTROYING
3458	&& pVM->enmVMState == VMSTATE_DESTROYING)
3459	break;
3460	AssertMsg(pVM->enmVMState == enmStateNew,
3461	("You are not allowed to change the state while in the change callback, except "
3462	"from destroying the VM. There are restrictions in the way the state changes "
3463	"are propagated up to the EM execution loop and it makes the program flow very "
3464	"difficult to follow. (%s, expected %s, old %s)\n",
3465	VMR3GetStateName(pVM->enmVMState), VMR3GetStateName(enmStateNew),
3466	VMR3GetStateName(enmStateOld)));
3467	}
3468	}
3469
3470
3471	/**
3472	* Sets the current VM state, with the AtStatCritSect already entered.
3473	*
3474	* @param pVM The cross context VM structure.
3475	* @param pUVM The UVM handle.
3476	* @param enmStateNew The new state.
3477	* @param enmStateOld The old state.
3478	* @param fSetRatherThanClearFF The usual behavior is to clear the
3479	* VM_FF_CHECK_VM_STATE force flag, but for
3480	* some transitions (-> guru) we need to kick
3481	* the other EMTs to stop what they're doing.
3482	*/
3483	static void vmR3SetStateLocked(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld, bool fSetRatherThanClearFF)
3484	{
3485	vmR3ValidateStateTransition(enmStateOld, enmStateNew);
3486
3487	AssertMsg(pVM->enmVMState == enmStateOld,
3488	("%s != %s\n", VMR3GetStateName(pVM->enmVMState), VMR3GetStateName(enmStateOld)));
3489
3490	pUVM->vm.s.enmPrevVMState = enmStateOld;
3491	pVM->enmVMState = enmStateNew;
3492
3493	if (!fSetRatherThanClearFF)
3494	VM_FF_CLEAR(pVM, VM_FF_CHECK_VM_STATE);
3495	else if (pVM->cCpus > 0)
3496	VM_FF_SET(pVM, VM_FF_CHECK_VM_STATE);
3497
3498	vmR3DoAtState(pVM, pUVM, enmStateNew, enmStateOld);
3499	}
3500
3501
3502	/**
3503	* Sets the current VM state.
3504	*
3505	* @param pVM The cross context VM structure.
3506	* @param enmStateNew The new state.
3507	* @param enmStateOld The old state (for asserting only).
3508	*/
3509	static void vmR3SetState(PVM pVM, VMSTATE enmStateNew, VMSTATE enmStateOld)
3510	{
3511	PUVM pUVM = pVM->pUVM;
3512	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
3513
3514	RT_NOREF_PV(enmStateOld);
3515	AssertMsg(pVM->enmVMState == enmStateOld,
3516	("%s != %s\n", VMR3GetStateName(pVM->enmVMState), VMR3GetStateName(enmStateOld)));
3517	vmR3SetStateLocked(pVM, pUVM, enmStateNew, pVM->enmVMState, false /fSetRatherThanClearFF/);
3518
3519	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
3520	}
3521
3522
3523	/**
3524	* Tries to perform a state transition.
3525	*
3526	* @returns The 1-based ordinal of the succeeding transition.
3527	* VERR_VM_INVALID_VM_STATE and Assert+LogRel on failure.
3528	*
3529	* @param pVM The cross context VM structure.
3530	* @param pszWho Who is trying to change it.
3531	* @param cTransitions The number of transitions in the ellipsis.
3532	* @param ... Transition pairs; new, old.
3533	*/
3534	static int vmR3TrySetState(PVM pVM, const char *pszWho, unsigned cTransitions, ...)
3535	{
3536	va_list va;
3537	VMSTATE enmStateNew = VMSTATE_CREATED;
3538	VMSTATE enmStateOld = VMSTATE_CREATED;
3539
3540	#ifdef VBOX_STRICT
3541	/*
3542	* Validate the input first.
3543	*/
3544	va_start(va, cTransitions);
3545	for (unsigned i = 0; i < cTransitions; i++)
3546	{
3547	enmStateNew = (VMSTATE)va_arg(va, /VMSTATE/int);
3548	enmStateOld = (VMSTATE)va_arg(va, /VMSTATE/int);
3549	vmR3ValidateStateTransition(enmStateOld, enmStateNew);
3550	}
3551	va_end(va);
3552	#endif
3553
3554	/*
3555	* Grab the lock and see if any of the proposed transitions works out.
3556	*/
3557	va_start(va, cTransitions);
3558	int rc = VERR_VM_INVALID_VM_STATE;
3559	PUVM pUVM = pVM->pUVM;
3560	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
3561
3562	VMSTATE enmStateCur = pVM->enmVMState;
3563
3564	for (unsigned i = 0; i < cTransitions; i++)
3565	{
3566	enmStateNew = (VMSTATE)va_arg(va, /VMSTATE/int);
3567	enmStateOld = (VMSTATE)va_arg(va, /VMSTATE/int);
3568	if (enmStateCur == enmStateOld)
3569	{
3570	vmR3SetStateLocked(pVM, pUVM, enmStateNew, enmStateOld, false /fSetRatherThanClearFF/);
3571	rc = i + 1;
3572	break;
3573	}
3574	}
3575
3576	if (RT_FAILURE(rc))
3577	{
3578	/*
3579	* Complain about it.
3580	*/
3581	if (cTransitions == 1)
3582	{
3583	LogRel(("%s: %s -> %s failed, because the VM state is actually %s\n",
3584	pszWho, VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew), VMR3GetStateName(enmStateCur)));
3585	VMSetError(pVM, VERR_VM_INVALID_VM_STATE, RT_SRC_POS,
3586	N_("%s failed because the VM state is %s instead of %s"),
3587	pszWho, VMR3GetStateName(enmStateCur), VMR3GetStateName(enmStateOld));
3588	AssertMsgFailed(("%s: %s -> %s failed, because the VM state is actually %s\n",
3589	pszWho, VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew), VMR3GetStateName(enmStateCur)));
3590	}
3591	else
3592	{
3593	va_end(va);
3594	va_start(va, cTransitions);
3595	LogRel(("%s:\n", pszWho));
3596	for (unsigned i = 0; i < cTransitions; i++)
3597	{
3598	enmStateNew = (VMSTATE)va_arg(va, /VMSTATE/int);
3599	enmStateOld = (VMSTATE)va_arg(va, /VMSTATE/int);
3600	LogRel(("%s%s -> %s",
3601	i ? ", " : " ", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)));
3602	}
3603	LogRel((" failed, because the VM state is actually %s\n", VMR3GetStateName(enmStateCur)));
3604	VMSetError(pVM, VERR_VM_INVALID_VM_STATE, RT_SRC_POS,
3605	N_("%s failed because the current VM state, %s, was not found in the state transition table (old state %s)"),
3606	pszWho, VMR3GetStateName(enmStateCur), VMR3GetStateName(enmStateOld));
3607	AssertMsgFailed(("%s - state=%s, see release log for full details. Check the cTransitions passed us.\n",
3608	pszWho, VMR3GetStateName(enmStateCur)));
3609	}
3610	}
3611
3612	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
3613	va_end(va);
3614	Assert(rc > 0 \|\| rc < 0);
3615	return rc;
3616	}
3617
3618
3619	/**
3620	* Interface used by EM to signal that it's entering the guru meditation state.
3621	*
3622	* This will notifying other threads.
3623	*
3624	* @returns true if the state changed to Guru, false if no state change.
3625	* @param pVM The cross context VM structure.
3626	*/
3627	VMMR3_INT_DECL(bool) VMR3SetGuruMeditation(PVM pVM)
3628	{
3629	PUVM pUVM = pVM->pUVM;
3630	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
3631
3632	VMSTATE enmStateCur = pVM->enmVMState;
3633	bool fRc = true;
3634	if (enmStateCur == VMSTATE_RUNNING)
3635	vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION, VMSTATE_RUNNING, true /fSetRatherThanClearFF/);
3636	else if (enmStateCur == VMSTATE_RUNNING_LS)
3637	{
3638	vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION_LS, VMSTATE_RUNNING_LS, true /fSetRatherThanClearFF/);
3639	SSMR3Cancel(pUVM);
3640	}
3641	else
3642	fRc = false;
3643
3644	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
3645	return fRc;
3646	}
3647
3648
3649	/**
3650	* Called by vmR3EmulationThreadWithId just before the VM structure is freed.
3651	*
3652	* @param pVM The cross context VM structure.
3653	*/
3654	void vmR3SetTerminated(PVM pVM)
3655	{
3656	vmR3SetState(pVM, VMSTATE_TERMINATED, VMSTATE_DESTROYING);
3657	}
3658
3659
3660	/**
3661	* Checks if the VM was teleported and hasn't been fully resumed yet.
3662	*
3663	* This applies to both sides of the teleportation since we may leave a working
3664	* clone behind and the user is allowed to resume this...
3665	*
3666	* @returns true / false.
3667	* @param pVM The cross context VM structure.
3668	* @thread Any thread.
3669	*/
3670	VMMR3_INT_DECL(bool) VMR3TeleportedAndNotFullyResumedYet(PVM pVM)
3671	{
3672	VM_ASSERT_VALID_EXT_RETURN(pVM, false);
3673	return pVM->vm.s.fTeleportedAndNotFullyResumedYet;
3674	}
3675
3676
3677	/**
3678	* Registers a VM state change callback.
3679	*
3680	* You are not allowed to call any function which changes the VM state from a
3681	* state callback.
3682	*
3683	* @returns VBox status code.
3684	* @param pUVM The VM handle.
3685	* @param pfnAtState Pointer to callback.
3686	* @param pvUser User argument.
3687	* @thread Any.
3688	*/
3689	VMMR3DECL(int) VMR3AtStateRegister(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser)
3690	{
3691	LogFlow(("VMR3AtStateRegister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
3692
3693	/*
3694	* Validate input.
3695	*/
3696	AssertPtrReturn(pfnAtState, VERR_INVALID_PARAMETER);
3697	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
3698
3699	/*
3700	* Allocate a new record.
3701	*/
3702	PVMATSTATE pNew = (PVMATSTATE)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
3703	if (!pNew)
3704	return VERR_NO_MEMORY;
3705
3706	/* fill */
3707	pNew->pfnAtState = pfnAtState;
3708	pNew->pvUser = pvUser;
3709
3710	/* insert */
3711	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
3712	pNew->pNext = *pUVM->vm.s.ppAtStateNext;
3713	*pUVM->vm.s.ppAtStateNext = pNew;
3714	pUVM->vm.s.ppAtStateNext = &pNew->pNext;
3715	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
3716
3717	return VINF_SUCCESS;
3718	}
3719
3720
3721	/**
3722	* Deregisters a VM state change callback.
3723	*
3724	* @returns VBox status code.
3725	* @param pUVM The VM handle.
3726	* @param pfnAtState Pointer to callback.
3727	* @param pvUser User argument.
3728	* @thread Any.
3729	*/
3730	VMMR3DECL(int) VMR3AtStateDeregister(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser)
3731	{
3732	LogFlow(("VMR3AtStateDeregister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
3733
3734	/*
3735	* Validate input.
3736	*/
3737	AssertPtrReturn(pfnAtState, VERR_INVALID_PARAMETER);
3738	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
3739
3740	RTCritSectEnter(&pUVM->vm.s.AtStateCritSect);
3741
3742	/*
3743	* Search the list for the entry.
3744	*/
3745	PVMATSTATE pPrev = NULL;
3746	PVMATSTATE pCur = pUVM->vm.s.pAtState;
3747	while ( pCur
3748	&& ( pCur->pfnAtState != pfnAtState
3749	\|\| pCur->pvUser != pvUser))
3750	{
3751	pPrev = pCur;
3752	pCur = pCur->pNext;
3753	}
3754	if (!pCur)
3755	{
3756	AssertMsgFailed(("pfnAtState=%p was not found\n", pfnAtState));
3757	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
3758	return VERR_FILE_NOT_FOUND;
3759	}
3760
3761	/*
3762	* Unlink it.
3763	*/
3764	if (pPrev)
3765	{
3766	pPrev->pNext = pCur->pNext;
3767	if (!pCur->pNext)
3768	pUVM->vm.s.ppAtStateNext = &pPrev->pNext;
3769	}
3770	else
3771	{
3772	pUVM->vm.s.pAtState = pCur->pNext;
3773	if (!pCur->pNext)
3774	pUVM->vm.s.ppAtStateNext = &pUVM->vm.s.pAtState;
3775	}
3776
3777	RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
3778
3779	/*
3780	* Free it.
3781	*/
3782	pCur->pfnAtState = NULL;
3783	pCur->pNext = NULL;
3784	MMR3HeapFree(pCur);
3785
3786	return VINF_SUCCESS;
3787	}
3788
3789
3790	/**
3791	* Registers a VM error callback.
3792	*
3793	* @returns VBox status code.
3794	* @param pUVM The VM handle.
3795	* @param pfnAtError Pointer to callback.
3796	* @param pvUser User argument.
3797	* @thread Any.
3798	*/
3799	VMMR3DECL(int) VMR3AtErrorRegister(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
3800	{
3801	LogFlow(("VMR3AtErrorRegister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
3802
3803	/*
3804	* Validate input.
3805	*/
3806	AssertPtrReturn(pfnAtError, VERR_INVALID_PARAMETER);
3807	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
3808
3809	/*
3810	* Allocate a new record.
3811	*/
3812	PVMATERROR pNew = (PVMATERROR)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
3813	if (!pNew)
3814	return VERR_NO_MEMORY;
3815
3816	/* fill */
3817	pNew->pfnAtError = pfnAtError;
3818	pNew->pvUser = pvUser;
3819
3820	/* insert */
3821	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
3822	pNew->pNext = *pUVM->vm.s.ppAtErrorNext;
3823	*pUVM->vm.s.ppAtErrorNext = pNew;
3824	pUVM->vm.s.ppAtErrorNext = &pNew->pNext;
3825	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
3826
3827	return VINF_SUCCESS;
3828	}
3829
3830
3831	/**
3832	* Deregisters a VM error callback.
3833	*
3834	* @returns VBox status code.
3835	* @param pUVM The VM handle.
3836	* @param pfnAtError Pointer to callback.
3837	* @param pvUser User argument.
3838	* @thread Any.
3839	*/
3840	VMMR3DECL(int) VMR3AtErrorDeregister(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
3841	{
3842	LogFlow(("VMR3AtErrorDeregister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
3843
3844	/*
3845	* Validate input.
3846	*/
3847	AssertPtrReturn(pfnAtError, VERR_INVALID_PARAMETER);
3848	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
3849
3850	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
3851
3852	/*
3853	* Search the list for the entry.
3854	*/
3855	PVMATERROR pPrev = NULL;
3856	PVMATERROR pCur = pUVM->vm.s.pAtError;
3857	while ( pCur
3858	&& ( pCur->pfnAtError != pfnAtError
3859	\|\| pCur->pvUser != pvUser))
3860	{
3861	pPrev = pCur;
3862	pCur = pCur->pNext;
3863	}
3864	if (!pCur)
3865	{
3866	AssertMsgFailed(("pfnAtError=%p was not found\n", pfnAtError));
3867	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
3868	return VERR_FILE_NOT_FOUND;
3869	}
3870
3871	/*
3872	* Unlink it.
3873	*/
3874	if (pPrev)
3875	{
3876	pPrev->pNext = pCur->pNext;
3877	if (!pCur->pNext)
3878	pUVM->vm.s.ppAtErrorNext = &pPrev->pNext;
3879	}
3880	else
3881	{
3882	pUVM->vm.s.pAtError = pCur->pNext;
3883	if (!pCur->pNext)
3884	pUVM->vm.s.ppAtErrorNext = &pUVM->vm.s.pAtError;
3885	}
3886
3887	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
3888
3889	/*
3890	* Free it.
3891	*/
3892	pCur->pfnAtError = NULL;
3893	pCur->pNext = NULL;
3894	MMR3HeapFree(pCur);
3895
3896	return VINF_SUCCESS;
3897	}
3898
3899
3900	/**
3901	* Ellipsis to va_list wrapper for calling pfnAtError.
3902	*/
3903	static void vmR3SetErrorWorkerDoCall(PVM pVM, PVMATERROR pCur, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
3904	{
3905	va_list va;
3906	va_start(va, pszFormat);
3907	pCur->pfnAtError(pVM->pUVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
3908	va_end(va);
3909	}
3910
3911
3912	/**
3913	* This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
3914	* The message is found in VMINT.
3915	*
3916	* @param pVM The cross context VM structure.
3917	* @thread EMT.
3918	*/
3919	VMMR3_INT_DECL(void) VMR3SetErrorWorker(PVM pVM)
3920	{
3921	VM_ASSERT_EMT(pVM);
3922	AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetErrorV! Congrats!\n"));
3923
3924	/*
3925	* Unpack the error (if we managed to format one).
3926	*/
3927	PVMERROR pErr = pVM->vm.s.pErrorR3;
3928	const char *pszFile = NULL;
3929	const char *pszFunction = NULL;
3930	uint32_t iLine = 0;
3931	const char *pszMessage;
3932	int32_t rc = VERR_MM_HYPER_NO_MEMORY;
3933	if (pErr)
3934	{
3935	AssertCompile(sizeof(const char) == sizeof(uint8_t));
3936	if (pErr->offFile)
3937	pszFile = (const char *)pErr + pErr->offFile;
3938	iLine = pErr->iLine;
3939	if (pErr->offFunction)
3940	pszFunction = (const char *)pErr + pErr->offFunction;
3941	if (pErr->offMessage)
3942	pszMessage = (const char *)pErr + pErr->offMessage;
3943	else
3944	pszMessage = "No message!";
3945	}
3946	else
3947	pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
3948
3949	/*
3950	* Call the at error callbacks.
3951	*/
3952	PUVM pUVM = pVM->pUVM;
3953	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
3954	ASMAtomicIncU32(&pUVM->vm.s.cRuntimeErrors);
3955	for (PVMATERROR pCur = pUVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
3956	vmR3SetErrorWorkerDoCall(pVM, pCur, rc, RT_SRC_POS_ARGS, "%s", pszMessage);
3957	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
3958	}
3959
3960
3961	/**
3962	* Gets the number of errors raised via VMSetError.
3963	*
3964	* This can be used avoid double error messages.
3965	*
3966	* @returns The error count.
3967	* @param pUVM The VM handle.
3968	*/
3969	VMMR3_INT_DECL(uint32_t) VMR3GetErrorCount(PUVM pUVM)
3970	{
3971	AssertPtrReturn(pUVM, 0);
3972	AssertReturn(pUVM->u32Magic == UVM_MAGIC, 0);
3973	return pUVM->vm.s.cErrors;
3974	}
3975
3976
3977	/**
3978	* Creation time wrapper for vmR3SetErrorUV.
3979	*
3980	* @returns rc.
3981	* @param pUVM Pointer to the user mode VM structure.
3982	* @param rc The VBox status code.
3983	* @param SRC_POS The source position of this error.
3984	* @param pszFormat Format string.
3985	* @param ... The arguments.
3986	* @thread Any thread.
3987	*/
3988	static int vmR3SetErrorU(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
3989	{
3990	va_list va;
3991	va_start(va, pszFormat);
3992	vmR3SetErrorUV(pUVM, rc, pszFile, iLine, pszFunction, pszFormat, &va);
3993	va_end(va);
3994	return rc;
3995	}
3996
3997
3998	/**
3999	* Worker which calls everyone listening to the VM error messages.
4000	*
4001	* @param pUVM Pointer to the user mode VM structure.
4002	* @param rc The VBox status code.
4003	* @param SRC_POS The source position of this error.
4004	* @param pszFormat Format string.
4005	* @param pArgs Pointer to the format arguments.
4006	* @thread EMT
4007	*/
4008	DECLCALLBACK(void) vmR3SetErrorUV(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list pArgs)
4009	{
4010	/*
4011	* Log the error.
4012	*/
4013	va_list va3;
4014	va_copy(va3, *pArgs);
4015	RTLogRelPrintf("VMSetError: %s(%d) %s; rc=%Rrc\n"
4016	"VMSetError: %N\n",
4017	pszFile, iLine, pszFunction, rc,
4018	pszFormat, &va3);
4019	va_end(va3);
4020
4021	#ifdef LOG_ENABLED
4022	va_copy(va3, *pArgs);
4023	RTLogPrintf("VMSetError: %s(%d) %s; rc=%Rrc\n"
4024	"%N\n",
4025	pszFile, iLine, pszFunction, rc,
4026	pszFormat, &va3);
4027	va_end(va3);
4028	#endif
4029
4030	/*
4031	* Make a copy of the message.
4032	*/
4033	if (pUVM->pVM)
4034	vmSetErrorCopy(pUVM->pVM, rc, RT_SRC_POS_ARGS, pszFormat, *pArgs);
4035
4036	/*
4037	* Call the at error callbacks.
4038	*/
4039	bool fCalledSomeone = false;
4040	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
4041	ASMAtomicIncU32(&pUVM->vm.s.cErrors);
4042	for (PVMATERROR pCur = pUVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
4043	{
4044	va_list va2;
4045	va_copy(va2, *pArgs);
4046	pCur->pfnAtError(pUVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
4047	va_end(va2);
4048	fCalledSomeone = true;
4049	}
4050	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
4051	}
4052
4053
4054	/**
4055	* Sets the error message.
4056	*
4057	* @returns rc. Meaning you can do:
4058	* @code
4059	* return VM_SET_ERROR_U(pUVM, VERR_OF_YOUR_CHOICE, "descriptive message");
4060	* @endcode
4061	* @param pUVM The user mode VM handle.
4062	* @param rc VBox status code.
4063	* @param SRC_POS Use RT_SRC_POS.
4064	* @param pszFormat Error message format string.
4065	* @param ... Error message arguments.
4066	* @thread Any
4067	*/
4068	VMMR3DECL(int) VMR3SetError(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
4069	{
4070	va_list va;
4071	va_start(va, pszFormat);
4072	int rcRet = VMR3SetErrorV(pUVM, rc, pszFile, iLine, pszFunction, pszFormat, va);
4073	va_end(va);
4074	return rcRet;
4075	}
4076
4077
4078	/**
4079	* Sets the error message.
4080	*
4081	* @returns rc. Meaning you can do:
4082	* @code
4083	* return VM_SET_ERROR_U(pUVM, VERR_OF_YOUR_CHOICE, "descriptive message");
4084	* @endcode
4085	* @param pUVM The user mode VM handle.
4086	* @param rc VBox status code.
4087	* @param SRC_POS Use RT_SRC_POS.
4088	* @param pszFormat Error message format string.
4089	* @param va Error message arguments.
4090	* @thread Any
4091	*/
4092	VMMR3DECL(int) VMR3SetErrorV(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
4093	{
4094	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4095
4096	/* Take shortcut when called on EMT, skipping VM handle requirement + validation. */
4097	if (VMR3GetVMCPUThread(pUVM) != NIL_RTTHREAD)
4098	{
4099	va_list vaCopy;
4100	va_copy(vaCopy, va);
4101	vmR3SetErrorUV(pUVM, rc, RT_SRC_POS_ARGS, pszFormat, &vaCopy);
4102	va_end(vaCopy);
4103	return rc;
4104	}
4105
4106	VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, VERR_INVALID_VM_HANDLE);
4107	return VMSetErrorV(pUVM->pVM, rc, pszFile, iLine, pszFunction, pszFormat, va);
4108	}
4109
4110
4111
4112	/**
4113	* Registers a VM runtime error callback.
4114	*
4115	* @returns VBox status code.
4116	* @param pUVM The user mode VM structure.
4117	* @param pfnAtRuntimeError Pointer to callback.
4118	* @param pvUser User argument.
4119	* @thread Any.
4120	*/
4121	VMMR3DECL(int) VMR3AtRuntimeErrorRegister(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
4122	{
4123	LogFlow(("VMR3AtRuntimeErrorRegister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
4124
4125	/*
4126	* Validate input.
4127	*/
4128	AssertPtrReturn(pfnAtRuntimeError, VERR_INVALID_PARAMETER);
4129	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4130
4131	/*
4132	* Allocate a new record.
4133	*/
4134	PVMATRUNTIMEERROR pNew = (PVMATRUNTIMEERROR)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
4135	if (!pNew)
4136	return VERR_NO_MEMORY;
4137
4138	/* fill */
4139	pNew->pfnAtRuntimeError = pfnAtRuntimeError;
4140	pNew->pvUser = pvUser;
4141
4142	/* insert */
4143	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
4144	pNew->pNext = *pUVM->vm.s.ppAtRuntimeErrorNext;
4145	*pUVM->vm.s.ppAtRuntimeErrorNext = pNew;
4146	pUVM->vm.s.ppAtRuntimeErrorNext = &pNew->pNext;
4147	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
4148
4149	return VINF_SUCCESS;
4150	}
4151
4152
4153	/**
4154	* Deregisters a VM runtime error callback.
4155	*
4156	* @returns VBox status code.
4157	* @param pUVM The user mode VM handle.
4158	* @param pfnAtRuntimeError Pointer to callback.
4159	* @param pvUser User argument.
4160	* @thread Any.
4161	*/
4162	VMMR3DECL(int) VMR3AtRuntimeErrorDeregister(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
4163	{
4164	LogFlow(("VMR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
4165
4166	/*
4167	* Validate input.
4168	*/
4169	AssertPtrReturn(pfnAtRuntimeError, VERR_INVALID_PARAMETER);
4170	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4171
4172	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
4173
4174	/*
4175	* Search the list for the entry.
4176	*/
4177	PVMATRUNTIMEERROR pPrev = NULL;
4178	PVMATRUNTIMEERROR pCur = pUVM->vm.s.pAtRuntimeError;
4179	while ( pCur
4180	&& ( pCur->pfnAtRuntimeError != pfnAtRuntimeError
4181	\|\| pCur->pvUser != pvUser))
4182	{
4183	pPrev = pCur;
4184	pCur = pCur->pNext;
4185	}
4186	if (!pCur)
4187	{
4188	AssertMsgFailed(("pfnAtRuntimeError=%p was not found\n", pfnAtRuntimeError));
4189	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
4190	return VERR_FILE_NOT_FOUND;
4191	}
4192
4193	/*
4194	* Unlink it.
4195	*/
4196	if (pPrev)
4197	{
4198	pPrev->pNext = pCur->pNext;
4199	if (!pCur->pNext)
4200	pUVM->vm.s.ppAtRuntimeErrorNext = &pPrev->pNext;
4201	}
4202	else
4203	{
4204	pUVM->vm.s.pAtRuntimeError = pCur->pNext;
4205	if (!pCur->pNext)
4206	pUVM->vm.s.ppAtRuntimeErrorNext = &pUVM->vm.s.pAtRuntimeError;
4207	}
4208
4209	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
4210
4211	/*
4212	* Free it.
4213	*/
4214	pCur->pfnAtRuntimeError = NULL;
4215	pCur->pNext = NULL;
4216	MMR3HeapFree(pCur);
4217
4218	return VINF_SUCCESS;
4219	}
4220
4221
4222	/**
4223	* EMT rendezvous worker that vmR3SetRuntimeErrorCommon uses to safely change
4224	* the state to FatalError(LS).
4225	*
4226	* @returns VERR_VM_INVALID_VM_STATE or VINF_EM_SUSPEND. (This is a strict
4227	* return code, see FNVMMEMTRENDEZVOUS.)
4228	*
4229	* @param pVM The cross context VM structure.
4230	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
4231	* @param pvUser Ignored.
4232	*/
4233	static DECLCALLBACK(VBOXSTRICTRC) vmR3SetRuntimeErrorChangeState(PVM pVM, PVMCPU pVCpu, void *pvUser)
4234	{
4235	NOREF(pVCpu);
4236	Assert(!pvUser); NOREF(pvUser);
4237
4238	/*
4239	* The first EMT thru here changes the state.
4240	*/
4241	if (pVCpu->idCpu == pVM->cCpus - 1)
4242	{
4243	int rc = vmR3TrySetState(pVM, "VMSetRuntimeError", 2,
4244	VMSTATE_FATAL_ERROR, VMSTATE_RUNNING,
4245	VMSTATE_FATAL_ERROR_LS, VMSTATE_RUNNING_LS);
4246	if (RT_FAILURE(rc))
4247	return rc;
4248	if (rc == 2)
4249	SSMR3Cancel(pVM->pUVM);
4250
4251	VM_FF_SET(pVM, VM_FF_CHECK_VM_STATE);
4252	}
4253
4254	/* This'll make sure we get out of whereever we are (e.g. REM). */
4255	return VINF_EM_SUSPEND;
4256	}
4257
4258
4259	/**
4260	* Worker for VMR3SetRuntimeErrorWorker and vmR3SetRuntimeErrorV.
4261	*
4262	* This does the common parts after the error has been saved / retrieved.
4263	*
4264	* @returns VBox status code with modifications, see VMSetRuntimeErrorV.
4265	*
4266	* @param pVM The cross context VM structure.
4267	* @param fFlags The error flags.
4268	* @param pszErrorId Error ID string.
4269	* @param pszFormat Format string.
4270	* @param pVa Pointer to the format arguments.
4271	*/
4272	static int vmR3SetRuntimeErrorCommon(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list *pVa)
4273	{
4274	LogRel(("VM: Raising runtime error '%s' (fFlags=%#x)\n", pszErrorId, fFlags));
4275	PUVM pUVM = pVM->pUVM;
4276
4277	/*
4278	* Take actions before the call.
4279	*/
4280	int rc;
4281	if (fFlags & VMSETRTERR_FLAGS_FATAL)
4282	rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING \| VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR,
4283	vmR3SetRuntimeErrorChangeState, NULL);
4284	else if (fFlags & VMSETRTERR_FLAGS_SUSPEND)
4285	rc = VMR3Suspend(pUVM, VMSUSPENDREASON_RUNTIME_ERROR);
4286	else
4287	rc = VINF_SUCCESS;
4288
4289	/*
4290	* Do the callback round.
4291	*/
4292	RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
4293	ASMAtomicIncU32(&pUVM->vm.s.cRuntimeErrors);
4294	for (PVMATRUNTIMEERROR pCur = pUVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
4295	{
4296	va_list va;
4297	va_copy(va, *pVa);
4298	pCur->pfnAtRuntimeError(pUVM, pCur->pvUser, fFlags, pszErrorId, pszFormat, va);
4299	va_end(va);
4300	}
4301	RTCritSectLeave(&pUVM->vm.s.AtErrorCritSect);
4302
4303	return rc;
4304	}
4305
4306
4307	/**
4308	* Ellipsis to va_list wrapper for calling vmR3SetRuntimeErrorCommon.
4309	*/
4310	static int vmR3SetRuntimeErrorCommonF(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
4311	{
4312	va_list va;
4313	va_start(va, pszFormat);
4314	int rc = vmR3SetRuntimeErrorCommon(pVM, fFlags, pszErrorId, pszFormat, &va);
4315	va_end(va);
4316	return rc;
4317	}
4318
4319
4320	/**
4321	* This is a worker function for RC and Ring-0 calls to VMSetError and
4322	* VMSetErrorV.
4323	*
4324	* The message is found in VMINT.
4325	*
4326	* @returns VBox status code, see VMSetRuntimeError.
4327	* @param pVM The cross context VM structure.
4328	* @thread EMT.
4329	*/
4330	VMMR3_INT_DECL(int) VMR3SetRuntimeErrorWorker(PVM pVM)
4331	{
4332	VM_ASSERT_EMT(pVM);
4333	AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetRuntimeErrorV! Congrats!\n"));
4334
4335	/*
4336	* Unpack the error (if we managed to format one).
4337	*/
4338	const char *pszErrorId = "SetRuntimeError";
4339	const char *pszMessage = "No message!";
4340	uint32_t fFlags = VMSETRTERR_FLAGS_FATAL;
4341	PVMRUNTIMEERROR pErr = pVM->vm.s.pRuntimeErrorR3;
4342	if (pErr)
4343	{
4344	AssertCompile(sizeof(const char) == sizeof(uint8_t));
4345	if (pErr->offErrorId)
4346	pszErrorId = (const char *)pErr + pErr->offErrorId;
4347	if (pErr->offMessage)
4348	pszMessage = (const char *)pErr + pErr->offMessage;
4349	fFlags = pErr->fFlags;
4350	}
4351
4352	/*
4353	* Join cause with vmR3SetRuntimeErrorV.
4354	*/
4355	return vmR3SetRuntimeErrorCommonF(pVM, fFlags, pszErrorId, "%s", pszMessage);
4356	}
4357
4358
4359	/**
4360	* Worker for VMSetRuntimeErrorV for doing the job on EMT in ring-3.
4361	*
4362	* @returns VBox status code with modifications, see VMSetRuntimeErrorV.
4363	*
4364	* @param pVM The cross context VM structure.
4365	* @param fFlags The error flags.
4366	* @param pszErrorId Error ID string.
4367	* @param pszMessage The error message residing the MM heap.
4368	*
4369	* @thread EMT
4370	*/
4371	DECLCALLBACK(int) vmR3SetRuntimeError(PVM pVM, uint32_t fFlags, const char pszErrorId, char pszMessage)
4372	{
4373	#if 0 /** @todo make copy of the error msg. */
4374	/*
4375	* Make a copy of the message.
4376	*/
4377	va_list va2;
4378	va_copy(va2, *pVa);
4379	vmSetRuntimeErrorCopy(pVM, fFlags, pszErrorId, pszFormat, va2);
4380	va_end(va2);
4381	#endif
4382
4383	/*
4384	* Join paths with VMR3SetRuntimeErrorWorker.
4385	*/
4386	int rc = vmR3SetRuntimeErrorCommonF(pVM, fFlags, pszErrorId, "%s", pszMessage);
4387	MMR3HeapFree(pszMessage);
4388	return rc;
4389	}
4390
4391
4392	/**
4393	* Worker for VMSetRuntimeErrorV for doing the job on EMT in ring-3.
4394	*
4395	* @returns VBox status code with modifications, see VMSetRuntimeErrorV.
4396	*
4397	* @param pVM The cross context VM structure.
4398	* @param fFlags The error flags.
4399	* @param pszErrorId Error ID string.
4400	* @param pszFormat Format string.
4401	* @param pVa Pointer to the format arguments.
4402	*
4403	* @thread EMT
4404	*/
4405	DECLCALLBACK(int) vmR3SetRuntimeErrorV(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list *pVa)
4406	{
4407	/*
4408	* Make a copy of the message.
4409	*/
4410	va_list va2;
4411	va_copy(va2, *pVa);
4412	vmSetRuntimeErrorCopy(pVM, fFlags, pszErrorId, pszFormat, va2);
4413	va_end(va2);
4414
4415	/*
4416	* Join paths with VMR3SetRuntimeErrorWorker.
4417	*/
4418	return vmR3SetRuntimeErrorCommon(pVM, fFlags, pszErrorId, pszFormat, pVa);
4419	}
4420
4421
4422	/**
4423	* Gets the number of runtime errors raised via VMR3SetRuntimeError.
4424	*
4425	* This can be used avoid double error messages.
4426	*
4427	* @returns The runtime error count.
4428	* @param pUVM The user mode VM handle.
4429	*/
4430	VMMR3_INT_DECL(uint32_t) VMR3GetRuntimeErrorCount(PUVM pUVM)
4431	{
4432	return pUVM->vm.s.cRuntimeErrors;
4433	}
4434
4435
4436	/**
4437	* Gets the ID virtual of the virtual CPU associated with the calling thread.
4438	*
4439	* @returns The CPU ID. NIL_VMCPUID if the thread isn't an EMT.
4440	*
4441	* @param pVM The cross context VM structure.
4442	*/
4443	VMMR3_INT_DECL(RTCPUID) VMR3GetVMCPUId(PVM pVM)
4444	{
4445	PUVMCPU pUVCpu = (PUVMCPU)RTTlsGet(pVM->pUVM->vm.s.idxTLS);
4446	return pUVCpu
4447	? pUVCpu->idCpu
4448	: NIL_VMCPUID;
4449	}
4450
4451
4452	/**
4453	* Checks if the VM is long-mode (64-bit) capable or not.
4454	*
4455	* @returns true if VM can operate in long-mode, false otherwise.
4456	* @param pVM The cross context VM structure.
4457	*/
4458	VMMR3_INT_DECL(bool) VMR3IsLongModeAllowed(PVM pVM)
4459	{
4460	switch (pVM->bMainExecutionEngine)
4461	{
4462	case VM_EXEC_ENGINE_HW_VIRT:
4463	return HMIsLongModeAllowed(pVM);
4464
4465	case VM_EXEC_ENGINE_NATIVE_API:
4466	#ifndef IN_RC
4467	return NEMHCIsLongModeAllowed(pVM);
4468	#else
4469	return false;
4470	#endif
4471
4472	case VM_EXEC_ENGINE_NOT_SET:
4473	AssertFailed();
4474	RT_FALL_THRU();
4475	default:
4476	return false;
4477	}
4478	}
4479
4480
4481	/**
4482	* Returns the native ID of the current EMT VMCPU thread.
4483	*
4484	* @returns Handle if this is an EMT thread; NIL_RTNATIVETHREAD otherwise
4485	* @param pVM The cross context VM structure.
4486	* @thread EMT
4487	*/
4488	VMMR3DECL(RTNATIVETHREAD) VMR3GetVMCPUNativeThread(PVM pVM)
4489	{
4490	PUVMCPU pUVCpu = (PUVMCPU)RTTlsGet(pVM->pUVM->vm.s.idxTLS);
4491
4492	if (!pUVCpu)
4493	return NIL_RTNATIVETHREAD;
4494
4495	return pUVCpu->vm.s.NativeThreadEMT;
4496	}
4497
4498
4499	/**
4500	* Returns the native ID of the current EMT VMCPU thread.
4501	*
4502	* @returns Handle if this is an EMT thread; NIL_RTNATIVETHREAD otherwise
4503	* @param pUVM The user mode VM structure.
4504	* @thread EMT
4505	*/
4506	VMMR3DECL(RTNATIVETHREAD) VMR3GetVMCPUNativeThreadU(PUVM pUVM)
4507	{
4508	PUVMCPU pUVCpu = (PUVMCPU)RTTlsGet(pUVM->vm.s.idxTLS);
4509
4510	if (!pUVCpu)
4511	return NIL_RTNATIVETHREAD;
4512
4513	return pUVCpu->vm.s.NativeThreadEMT;
4514	}
4515
4516
4517	/**
4518	* Returns the handle of the current EMT VMCPU thread.
4519	*
4520	* @returns Handle if this is an EMT thread; NIL_RTNATIVETHREAD otherwise
4521	* @param pUVM The user mode VM handle.
4522	* @thread EMT
4523	*/
4524	VMMR3DECL(RTTHREAD) VMR3GetVMCPUThread(PUVM pUVM)
4525	{
4526	PUVMCPU pUVCpu = (PUVMCPU)RTTlsGet(pUVM->vm.s.idxTLS);
4527
4528	if (!pUVCpu)
4529	return NIL_RTTHREAD;
4530
4531	return pUVCpu->vm.s.ThreadEMT;
4532	}
4533
4534
4535	/**
4536	* Returns the handle of the current EMT VMCPU thread.
4537	*
4538	* @returns The IPRT thread handle.
4539	* @param pUVCpu The user mode CPU handle.
4540	* @thread EMT
4541	*/
4542	VMMR3_INT_DECL(RTTHREAD) VMR3GetThreadHandle(PUVMCPU pUVCpu)
4543	{
4544	return pUVCpu->vm.s.ThreadEMT;
4545	}
4546
4547
4548	/**
4549	* Return the package and core ID of a CPU.
4550	*
4551	* @returns VBOX status code.
4552	* @param pUVM The user mode VM handle.
4553	* @param idCpu Virtual CPU to get the ID from.
4554	* @param pidCpuCore Where to store the core ID of the virtual CPU.
4555	* @param pidCpuPackage Where to store the package ID of the virtual CPU.
4556	*
4557	*/
4558	VMMR3DECL(int) VMR3GetCpuCoreAndPackageIdFromCpuId(PUVM pUVM, VMCPUID idCpu, uint32_t pidCpuCore, uint32_t pidCpuPackage)
4559	{
4560	/*
4561	* Validate input.
4562	*/
4563	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4564	PVM pVM = pUVM->pVM;
4565	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
4566	AssertPtrReturn(pidCpuCore, VERR_INVALID_POINTER);
4567	AssertPtrReturn(pidCpuPackage, VERR_INVALID_POINTER);
4568	if (idCpu >= pVM->cCpus)
4569	return VERR_INVALID_CPU_ID;
4570
4571	/*
4572	* Set return values.
4573	*/
4574	#ifdef VBOX_WITH_MULTI_CORE
4575	*pidCpuCore = idCpu;
4576	*pidCpuPackage = 0;
4577	#else
4578	*pidCpuCore = 0;
4579	*pidCpuPackage = idCpu;
4580	#endif
4581
4582	return VINF_SUCCESS;
4583	}
4584
4585
4586	/**
4587	* Worker for VMR3HotUnplugCpu.
4588	*
4589	* @returns VINF_EM_WAIT_SPIP (strict status code).
4590	* @param pVM The cross context VM structure.
4591	* @param idCpu The current CPU.
4592	*/
4593	static DECLCALLBACK(int) vmR3HotUnplugCpu(PVM pVM, VMCPUID idCpu)
4594	{
4595	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
4596	VMCPU_ASSERT_EMT(pVCpu);
4597
4598	/*
4599	* Reset per CPU resources.
4600	*
4601	* Actually only needed for VT-x because the CPU seems to be still in some
4602	* paged mode and startup fails after a new hot plug event. SVM works fine
4603	* even without this.
4604	*/
4605	Log(("vmR3HotUnplugCpu for VCPU %u\n", idCpu));
4606	PGMR3ResetCpu(pVM, pVCpu);
4607	PDMR3ResetCpu(pVCpu);
4608	TRPMR3ResetCpu(pVCpu);
4609	CPUMR3ResetCpu(pVM, pVCpu);
4610	EMR3ResetCpu(pVCpu);
4611	HMR3ResetCpu(pVCpu);
4612	NEMR3ResetCpu(pVCpu, false /fInitIpi/);
4613	return VINF_EM_WAIT_SIPI;
4614	}
4615
4616
4617	/**
4618	* Hot-unplugs a CPU from the guest.
4619	*
4620	* @returns VBox status code.
4621	* @param pUVM The user mode VM handle.
4622	* @param idCpu Virtual CPU to perform the hot unplugging operation on.
4623	*/
4624	VMMR3DECL(int) VMR3HotUnplugCpu(PUVM pUVM, VMCPUID idCpu)
4625	{
4626	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4627	PVM pVM = pUVM->pVM;
4628	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
4629	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
4630
4631	/** @todo r=bird: Don't destroy the EMT, it'll break VMMR3EmtRendezvous and
4632	* broadcast requests. Just note down somewhere that the CPU is
4633	* offline and send it to SPIP wait. Maybe modify VMCPUSTATE and push
4634	* it out of the EM loops when offline. */
4635	return VMR3ReqCallNoWaitU(pUVM, idCpu, (PFNRT)vmR3HotUnplugCpu, 2, pVM, idCpu);
4636	}
4637
4638
4639	/**
4640	* Hot-plugs a CPU on the guest.
4641	*
4642	* @returns VBox status code.
4643	* @param pUVM The user mode VM handle.
4644	* @param idCpu Virtual CPU to perform the hot plugging operation on.
4645	*/
4646	VMMR3DECL(int) VMR3HotPlugCpu(PUVM pUVM, VMCPUID idCpu)
4647	{
4648	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4649	PVM pVM = pUVM->pVM;
4650	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
4651	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
4652
4653	/** @todo r-bird: Just mark it online and make sure it waits on SPIP. */
4654	return VINF_SUCCESS;
4655	}
4656
4657
4658	/**
4659	* Changes the VMM execution cap.
4660	*
4661	* @returns VBox status code.
4662	* @param pUVM The user mode VM structure.
4663	* @param uCpuExecutionCap New CPU execution cap in precent, 1-100. Where
4664	* 100 is max performance (default).
4665	*/
4666	VMMR3DECL(int) VMR3SetCpuExecutionCap(PUVM pUVM, uint32_t uCpuExecutionCap)
4667	{
4668	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4669	PVM pVM = pUVM->pVM;
4670	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
4671	AssertReturn(uCpuExecutionCap > 0 && uCpuExecutionCap <= 100, VERR_INVALID_PARAMETER);
4672
4673	Log(("VMR3SetCpuExecutionCap: new priority = %d\n", uCpuExecutionCap));
4674	/* Note: not called from EMT. */
4675	pVM->uCpuExecutionCap = uCpuExecutionCap;
4676	return VINF_SUCCESS;
4677	}
4678
4679
4680	/**
4681	* Control whether the VM should power off when resetting.
4682	*
4683	* @returns VBox status code.
4684	* @param pUVM The user mode VM handle.
4685	* @param fPowerOffInsteadOfReset Flag whether the VM should power off when
4686	* resetting.
4687	*/
4688	VMMR3DECL(int) VMR3SetPowerOffInsteadOfReset(PUVM pUVM, bool fPowerOffInsteadOfReset)
4689	{
4690	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
4691	PVM pVM = pUVM->pVM;
4692	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
4693
4694	/* Note: not called from EMT. */
4695	pVM->vm.s.fPowerOffInsteadOfReset = fPowerOffInsteadOfReset;
4696	return VINF_SUCCESS;
4697	}
4698

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

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

Download in other formats: