VM.cpp@ 80080

Last change on this file since 80080 was 80080, checked in by vboxsync, 6 years ago
VMM: Kicking out raw-mode and 32-bit hosts - HM, VMMSWITCHER, ++. bugref:9517 bugref:9511
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 159.0 KB

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

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

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

Download in other formats: