VirtualBox

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

Last change on this file since 76553 was 76553, checked in by vboxsync, 5 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use