VirtualBox

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

Last change on this file since 24911 was 24874, checked in by vboxsync, 15 years ago

Main,VMM,VBoxManage: Added a parameter to IConsole::Teleport for specifying a max downtime and made PGM compare this against a rough estimate of the time it would take to deal with the rest of the pages.

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette