VirtualBox

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

Last change on this file since 7559 was 7559, checked in by vboxsync, 17 years ago

warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 88.1 KB
Line 
1/* $Id: VM.cpp 7559 2008-03-25 17:08:42Z vboxsync $ */
2/** @file
3 * VM - Virtual Machine
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#define LOG_GROUP LOG_GROUP_VM
23#include <VBox/cfgm.h>
24#include <VBox/vmm.h>
25#include <VBox/gvmm.h>
26#include <VBox/mm.h>
27#include <VBox/cpum.h>
28#include <VBox/selm.h>
29#include <VBox/trpm.h>
30#include <VBox/dbgf.h>
31#include <VBox/pgm.h>
32#include <VBox/pdmapi.h>
33#include <VBox/pdmcritsect.h>
34#include <VBox/em.h>
35#include <VBox/rem.h>
36#include <VBox/tm.h>
37#include <VBox/stam.h>
38#include <VBox/patm.h>
39#include <VBox/csam.h>
40#include <VBox/iom.h>
41#include <VBox/ssm.h>
42#include <VBox/hwaccm.h>
43#include "VMInternal.h"
44#include <VBox/vm.h>
45#include <VBox/uvm.h>
46
47#include <VBox/sup.h>
48#include <VBox/dbg.h>
49#include <VBox/err.h>
50#include <VBox/param.h>
51#include <VBox/log.h>
52#include <iprt/assert.h>
53#include <iprt/alloc.h>
54#include <iprt/asm.h>
55#include <iprt/env.h>
56#include <iprt/string.h>
57#include <iprt/time.h>
58#include <iprt/semaphore.h>
59#include <iprt/thread.h>
60
61
62/*******************************************************************************
63* Structures and Typedefs *
64*******************************************************************************/
65/**
66 * VM destruction callback registration record.
67 */
68typedef struct VMATDTOR
69{
70 /** Pointer to the next record in the list. */
71 struct VMATDTOR *pNext;
72 /** Pointer to the callback function. */
73 PFNVMATDTOR pfnAtDtor;
74 /** The user argument. */
75 void *pvUser;
76} VMATDTOR;
77/** Pointer to a VM destruction callback registration record. */
78typedef VMATDTOR *PVMATDTOR;
79
80
81/*******************************************************************************
82* Global Variables *
83*******************************************************************************/
84/** Pointer to the list of VMs. */
85static PUVM g_pUVMsHead = NULL;
86
87/** Pointer to the list of at VM destruction callbacks. */
88static PVMATDTOR g_pVMAtDtorHead = NULL;
89/** Lock the g_pVMAtDtorHead list. */
90#define VM_ATDTOR_LOCK() do { } while (0)
91/** Unlock the g_pVMAtDtorHead list. */
92#define VM_ATDTOR_UNLOCK() do { } while (0)
93
94
95/*******************************************************************************
96* Internal Functions *
97*******************************************************************************/
98static int vmR3CreateUVM(PUVM *ppUVM);
99static int vmR3CreateU(PUVM pUVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM);
100static int vmR3InitRing3(PVM pVM, PUVM pUVM);
101static int vmR3InitRing0(PVM pVM);
102static int vmR3InitGC(PVM pVM);
103static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat);
104static DECLCALLBACK(int) vmR3PowerOn(PVM pVM);
105static DECLCALLBACK(int) vmR3Suspend(PVM pVM);
106static DECLCALLBACK(int) vmR3Resume(PVM pVM);
107static DECLCALLBACK(int) vmR3Save(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser);
108static DECLCALLBACK(int) vmR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser);
109static DECLCALLBACK(int) vmR3PowerOff(PVM pVM);
110static void vmR3DestroyUVM(PUVM pUVM);
111static void vmR3AtDtor(PVM pVM);
112static int vmR3AtResetU(PUVM pUVM);
113static DECLCALLBACK(int) vmR3Reset(PVM pVM);
114static DECLCALLBACK(int) vmR3AtStateRegisterU(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser);
115static DECLCALLBACK(int) vmR3AtStateDeregisterU(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser);
116static DECLCALLBACK(int) vmR3AtErrorRegisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser);
117static DECLCALLBACK(int) vmR3AtErrorDeregisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser);
118static int vmR3SetErrorU(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...);
119static DECLCALLBACK(int) vmR3AtRuntimeErrorRegisterU(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser);
120static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregisterU(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser);
121
122
123/**
124 * Do global VMM init.
125 *
126 * @returns VBox status code.
127 */
128VMR3DECL(int) VMR3GlobalInit(void)
129{
130 /*
131 * Only once.
132 */
133 static bool volatile s_fDone = false;
134 if (s_fDone)
135 return VINF_SUCCESS;
136
137 /*
138 * We're done.
139 */
140 s_fDone = true;
141 return VINF_SUCCESS;
142}
143
144
145
146/**
147 * Creates a virtual machine by calling the supplied configuration constructor.
148 *
149 * On successful returned the VM is powered, i.e. VMR3PowerOn() should be
150 * called to start the execution.
151 *
152 * @returns 0 on success.
153 * @returns VBox error code on failure.
154 * @param pfnVMAtError Pointer to callback function for setting VM errors.
155 * This is called in the EM.
156 * @param pvUserVM The user argument passed to pfnVMAtError.
157 * @param pfnCFGMConstructor Pointer to callback function for constructing the VM configuration tree.
158 * This is called in the EM.
159 * @param pvUserCFGM The user argument passed to pfnCFGMConstructor.
160 * @param ppVM Where to store the 'handle' of the created VM.
161 */
162VMR3DECL(int) VMR3Create(PFNVMATERROR pfnVMAtError, void *pvUserVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM, PVM *ppVM)
163{
164 LogFlow(("VMR3Create: pfnVMAtError=%p pvUserVM=%p pfnCFGMConstructor=%p pvUserCFGM=%p ppVM=%p\n", pfnVMAtError, pvUserVM, pfnCFGMConstructor, pvUserCFGM, ppVM));
165
166 /*
167 * Because of the current hackiness of the applications
168 * we'll have to initialize global stuff from here.
169 * Later the applications will take care of this in a proper way.
170 */
171 static bool fGlobalInitDone = false;
172 if (!fGlobalInitDone)
173 {
174 int rc = VMR3GlobalInit();
175 if (VBOX_FAILURE(rc))
176 return rc;
177 fGlobalInitDone = true;
178 }
179
180 /*
181 * Create the UVM so we can register the at-error callback
182 * and consoliate a bit of cleanup code.
183 */
184 PUVM pUVM;
185 int rc = vmR3CreateUVM(&pUVM);
186 if (RT_FAILURE(rc))
187 return rc;
188 if (pfnVMAtError)
189 rc = VMR3AtErrorRegisterU(pUVM, pfnVMAtError, pvUserVM);
190 if (RT_SUCCESS(rc))
191 {
192 /*
193 * Initialize the support library creating the session for this v
194 */
195 rc = SUPInit(&pUVM->vm.s.pSession, 0);
196 if (RT_SUCCESS(rc))
197 {
198 /*
199 * Call vmR3CreateU in the EMT thread and wait for it to finish.
200 */
201 PVMREQ pReq;
202 rc = VMR3ReqCallU(pUVM, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3CreateU,
203 3, pUVM, pfnCFGMConstructor, pvUserCFGM);
204 if (RT_SUCCESS(rc))
205 {
206 rc = pReq->iStatus;
207 VMR3ReqFree(pReq);
208 if (RT_SUCCESS(rc))
209 {
210 /*
211 * Success!
212 */
213 *ppVM = pUVM->pVM;
214 LogFlow(("VMR3Create: returns VINF_SUCCESS *ppVM=%p\n", *ppVM));
215 return VINF_SUCCESS;
216 }
217 }
218 else
219 AssertMsgFailed(("VMR3ReqCall failed rc=%Vrc\n", rc));
220
221 /*
222 * An error occurred during VM creation. Set the error message directly
223 * using the initial callback, as the callback list doesn't exist yet.
224 */
225 const char *pszError = NULL;
226 switch (rc)
227 {
228 case VERR_VMX_IN_VMX_ROOT_MODE:
229#ifdef RT_OS_LINUX
230 pszError = N_("VirtualBox can't operate in VMX root mode. "
231 "Please disable the KVM kernel extension, recompile your kernel and reboot");
232#else
233 pszError = N_("VirtualBox can't operate in VMX root mode");
234#endif
235 break;
236
237 default:
238 pszError = N_("Unknown error creating VM");
239 NoDmik(AssertMsgFailed(("Add error message for rc=%d (%Vrc)\n", rc, rc)));
240 break;
241 }
242 vmR3SetErrorU(pUVM, rc, RT_SRC_POS, pszError, rc);
243 }
244 else
245 {
246 /*
247 * An error occurred at support library initialization time (before the
248 * VM could be created). Set the error message directly using the
249 * initial callback, as the callback list doesn't exist yet.
250 */
251 const char *pszError;
252 switch (rc)
253 {
254 case VERR_VM_DRIVER_LOAD_ERROR:
255#ifdef RT_OS_LINUX
256 pszError = N_("VirtualBox kernel driver not loaded. The vboxdrv kernel module "
257 "was either not loaded or /dev/vboxdrv is not set up properly. "
258 "Re-setup the kernel module by executing "
259 "'/etc/init.d/vboxdrv setup' as root");
260#else
261 pszError = N_("VirtualBox kernel driver not loaded");
262#endif
263 break;
264 case VERR_VM_DRIVER_OPEN_ERROR:
265 pszError = N_("VirtualBox kernel driver cannot be opened");
266 break;
267 case VERR_VM_DRIVER_NOT_ACCESSIBLE:
268#ifdef RT_OS_LINUX
269 pszError = N_("The VirtualBox kernel driver is not accessible to the current "
270 "user. Make sure that the user has write permissions for "
271 "/dev/vboxdrv by adding them to the vboxusers groups. You "
272 "will need to logout for the change to take effect.");
273#else
274 pszError = N_("VirtualBox kernel driver not accessible, permission problem");
275#endif
276 break;
277 case VERR_VM_DRIVER_NOT_INSTALLED:
278#ifdef RT_OS_LINUX
279 pszError = N_("VirtualBox kernel driver not installed. The vboxdrv kernel module "
280 "was either not loaded or /dev/vboxdrv was not created for some "
281 "reason. Re-setup the kernel module by executing "
282 "'/etc/init.d/vboxdrv setup' as root");
283#else
284 pszError = N_("VirtualBox kernel driver not installed");
285#endif
286 break;
287 case VERR_NO_MEMORY:
288 pszError = N_("VirtualBox support library out of memory");
289 break;
290 case VERR_VERSION_MISMATCH:
291 case VERR_VM_DRIVER_VERSION_MISMATCH:
292 pszError = N_("The VirtualBox support driver which is running is from a different "
293 "version of VirtualBox. You can correct this by stopping all "
294 "running instances of VirtualBox and reinstalling the software.");
295 break;
296 default:
297 pszError = N_("Unknown error initializing kernel driver");
298 AssertMsgFailed(("Add error message for rc=%d (%Vrc)\n", rc, rc));
299 }
300 vmR3SetErrorU(pUVM, rc, RT_SRC_POS, pszError, rc);
301 }
302 }
303
304 /* cleanup */
305 vmR3DestroyUVM(pUVM);
306 LogFlow(("VMR3Create: returns %Vrc\n", rc));
307 return rc;
308}
309
310
311/**
312 * Creates the UVM.
313 *
314 * This will not initialize the support library even if vmR3DestroyUVM
315 * will terminate that.
316 *
317 * @returns VBox status code.
318 * @param ppUVM Where to store the UVM pointer.
319 */
320static int vmR3CreateUVM(PUVM *ppUVM)
321{
322 /*
323 * Create the UVM, initialize the fundamental stuff (VM+MMR3Heap+STAM)
324 * and start the emulation thread (EMT).
325 */
326 PUVM pUVM = (PUVM)RTMemAllocZ(sizeof(*pUVM));
327 AssertReturn(pUVM, VERR_NO_MEMORY);
328 pUVM->u32Magic = UVM_MAGIC;
329
330 AssertCompile(sizeof(pUVM->vm.s) <= sizeof(pUVM->vm.padding));
331 AssertRelease(sizeof(pUVM->vm.s) <= sizeof(pUVM->vm.padding));
332
333 pUVM->vm.s.ppAtResetNext = &pUVM->vm.s.pAtReset;
334 pUVM->vm.s.ppAtStateNext = &pUVM->vm.s.pAtState;
335 pUVM->vm.s.ppAtErrorNext = &pUVM->vm.s.pAtError;
336 pUVM->vm.s.ppAtRuntimeErrorNext = &pUVM->vm.s.pAtRuntimeError;
337 pUVM->vm.s.enmHaltMethod = VMHALTMETHOD_BOOTSTRAP;
338 int rc = RTSemEventCreate(&pUVM->vm.s.EventSemWait);
339 if (RT_SUCCESS(rc))
340 {
341 rc = STAMR3InitUVM(pUVM);
342 if (RT_SUCCESS(rc))
343 {
344 rc = MMR3InitUVM(pUVM);
345 if (RT_SUCCESS(rc))
346 {
347 rc = PDMR3InitUVM(pUVM);
348 if (RT_SUCCESS(rc))
349 {
350
351 rc = RTThreadCreate(&pUVM->vm.s.ThreadEMT, vmR3EmulationThread, pUVM, _1M,
352 RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "EMT");
353 if (RT_SUCCESS(rc))
354 {
355 *ppUVM = pUVM;
356 return VINF_SUCCESS;
357 }
358
359 /* bail out. */
360 PDMR3TermUVM(pUVM);
361 }
362 MMR3TermUVM(pUVM);
363 }
364 STAMR3TermUVM(pUVM);
365 }
366 RTSemEventDestroy(pUVM->vm.s.EventSemWait);
367 }
368 RTMemFree(pUVM);
369 return rc;
370}
371
372
373/**
374 * Creates and initializes the VM.
375 *
376 * @thread EMT
377 */
378static int vmR3CreateU(PUVM pUVM, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM)
379{
380 int rc = VINF_SUCCESS;
381
382 /*
383 * Load the VMMR0.r0 module so that we can call GVMMR0CreateVM.
384 */
385 rc = PDMR3LdrLoadVMMR0U(pUVM);
386 if (RT_FAILURE(rc))
387 return vmR3SetErrorU(pUVM, rc, RT_SRC_POS, N_("Failed to load VMMR0.r0"));
388
389 /*
390 * Request GVMM to create a new VM for us.
391 */
392 GVMMCREATEVMREQ CreateVMReq;
393 CreateVMReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
394 CreateVMReq.Hdr.cbReq = sizeof(CreateVMReq);
395 CreateVMReq.pSession = pUVM->vm.s.pSession;
396 CreateVMReq.pVMR0 = NIL_RTR0PTR;
397 CreateVMReq.pVMR3 = NULL;
398 rc = SUPCallVMMR0Ex(NIL_RTR0PTR, VMMR0_DO_GVMM_CREATE_VM, 0, &CreateVMReq.Hdr);
399 if (RT_SUCCESS(rc))
400 {
401 PVM pVM = pUVM->pVM = CreateVMReq.pVMR3;
402 AssertRelease(VALID_PTR(pVM));
403 AssertRelease(pVM->pVMR0 == CreateVMReq.pVMR0);
404 AssertRelease(pVM->pSession == pUVM->vm.s.pSession);
405
406 Log(("VMR3Create: Created pUVM=%p pVM=%p pVMR0=%p hSelf=%#x \n", pUVM, pVM, pVM->pVMR0, pVM->hSelf));
407
408 /*
409 * Initialize the VM structure and our internal data (VMINT).
410 */
411 pVM->pUVM = pUVM;
412 pVM->ThreadEMT = pUVM->vm.s.ThreadEMT;
413 pVM->NativeThreadEMT = pUVM->vm.s.NativeThreadEMT;
414
415 pVM->vm.s.offVM = RT_OFFSETOF(VM, vm.s);
416
417 /*
418 * Init the configuration.
419 */
420 rc = CFGMR3Init(pVM, pfnCFGMConstructor, pvUserCFGM);
421 if (VBOX_SUCCESS(rc))
422 {
423 /*
424 * If executing in fake suplib mode disable RR3 and RR0 in the config.
425 */
426 const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
427 if (psz && !strcmp(psz, "fake"))
428 {
429 CFGMR3RemoveValue(CFGMR3GetRoot(pVM), "RawR3Enabled");
430 CFGMR3InsertInteger(CFGMR3GetRoot(pVM), "RawR3Enabled", 0);
431 CFGMR3RemoveValue(CFGMR3GetRoot(pVM), "RawR0Enabled");
432 CFGMR3InsertInteger(CFGMR3GetRoot(pVM), "RawR0Enabled", 0);
433 }
434
435 /*
436 * Init the Ring-3 components and do a round of relocations with 0 delta.
437 */
438 rc = vmR3InitRing3(pVM, pUVM);
439 if (VBOX_SUCCESS(rc))
440 {
441 VMR3Relocate(pVM, 0);
442 LogFlow(("Ring-3 init succeeded\n"));
443
444 /*
445 * Init the Ring-0 components.
446 */
447 rc = vmR3InitRing0(pVM);
448 if (VBOX_SUCCESS(rc))
449 {
450 /* Relocate again, because some switcher fixups depends on R0 init results. */
451 VMR3Relocate(pVM, 0);
452
453#ifdef VBOX_WITH_DEBUGGER
454 /*
455 * Init the tcp debugger console if we're building
456 * with debugger support.
457 */
458 void *pvUser = NULL;
459 rc = DBGCTcpCreate(pVM, &pvUser);
460 if ( VBOX_SUCCESS(rc)
461 || rc == VERR_NET_ADDRESS_IN_USE)
462 {
463 pUVM->vm.s.pvDBGC = pvUser;
464#endif
465 /*
466 * Init the Guest Context components.
467 */
468 rc = vmR3InitGC(pVM);
469 if (VBOX_SUCCESS(rc))
470 {
471 /*
472 * Now we can safely set the VM halt method to default.
473 */
474 rc = vmR3SetHaltMethodU(pUVM, VMHALTMETHOD_DEFAULT);
475 if (RT_SUCCESS(rc))
476 {
477 /*
478 * Set the state and link into the global list.
479 */
480 vmR3SetState(pVM, VMSTATE_CREATED);
481 pUVM->pNext = g_pUVMsHead;
482 g_pUVMsHead = pUVM;
483 return VINF_SUCCESS;
484 }
485 }
486#ifdef VBOX_WITH_DEBUGGER
487 DBGCTcpTerminate(pVM, pUVM->vm.s.pvDBGC);
488 pUVM->vm.s.pvDBGC = NULL;
489 }
490#endif
491 //..
492 }
493 vmR3Destroy(pVM);
494 }
495 //..
496
497 /* Clean CFGM. */
498 int rc2 = CFGMR3Term(pVM);
499 AssertRC(rc2);
500 }
501
502 /* Tell GVMM that it can destroy the VM now. */
503 int rc2 = SUPCallVMMR0Ex(CreateVMReq.pVMR0, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
504 AssertRC(rc2);
505 pUVM->pVM = NULL;
506 }
507 else
508 vmR3SetErrorU(pUVM, rc, RT_SRC_POS, N_("VM creation failed (GVMM)"));
509
510 LogFlow(("vmR3Create: returns %Rrc\n", rc));
511 return rc;
512}
513
514
515
516/**
517 * Initializes all R3 components of the VM
518 */
519static int vmR3InitRing3(PVM pVM, PUVM pUVM)
520{
521 int rc;
522
523 /*
524 * Init all R3 components, the order here might be important.
525 */
526 rc = MMR3Init(pVM);
527 if (VBOX_SUCCESS(rc))
528 {
529 STAM_REG(pVM, &pVM->StatTotalInGC, STAMTYPE_PROFILE_ADV, "/PROF/VM/InGC", STAMUNIT_TICKS_PER_CALL, "Profiling the total time spent in GC.");
530 STAM_REG(pVM, &pVM->StatSwitcherToGC, STAMTYPE_PROFILE_ADV, "/PROF/VM/SwitchToGC", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
531 STAM_REG(pVM, &pVM->StatSwitcherToHC, STAMTYPE_PROFILE_ADV, "/PROF/VM/SwitchToHC", STAMUNIT_TICKS_PER_CALL, "Profiling switching to HC.");
532 STAM_REG(pVM, &pVM->StatSwitcherSaveRegs, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/SaveRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
533 STAM_REG(pVM, &pVM->StatSwitcherSysEnter, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/SysEnter", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
534 STAM_REG(pVM, &pVM->StatSwitcherDebug, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Debug", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
535 STAM_REG(pVM, &pVM->StatSwitcherCR0, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/CR0", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
536 STAM_REG(pVM, &pVM->StatSwitcherCR4, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/CR4", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
537 STAM_REG(pVM, &pVM->StatSwitcherLgdt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lgdt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
538 STAM_REG(pVM, &pVM->StatSwitcherLidt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lidt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
539 STAM_REG(pVM, &pVM->StatSwitcherLldt, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/Lldt", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
540 STAM_REG(pVM, &pVM->StatSwitcherTSS, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/TSS", STAMUNIT_TICKS_PER_CALL, "Profiling switching to GC.");
541 STAM_REG(pVM, &pVM->StatSwitcherJmpCR3, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/JmpCR3", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
542 STAM_REG(pVM, &pVM->StatSwitcherRstrRegs, STAMTYPE_PROFILE_ADV, "/VM/Switcher/ToGC/RstrRegs", STAMUNIT_TICKS_PER_CALL,"Profiling switching to GC.");
543
544 STAM_REL_REG(pVM, &pUVM->vm.s.StatHaltYield, STAMTYPE_PROFILE, "/PROF/VM/Halt/Yield", STAMUNIT_TICKS_PER_CALL, "Profiling halted state yielding.");
545 STAM_REL_REG(pVM, &pUVM->vm.s.StatHaltBlock, STAMTYPE_PROFILE, "/PROF/VM/Halt/Block", STAMUNIT_TICKS_PER_CALL, "Profiling halted state blocking.");
546 STAM_REL_REG(pVM, &pUVM->vm.s.StatHaltTimers,STAMTYPE_PROFILE, "/PROF/VM/Halt/Timers", STAMUNIT_TICKS_PER_CALL, "Profiling halted state timer tasks.");
547 STAM_REL_REG(pVM, &pUVM->vm.s.StatHaltPoll, STAMTYPE_PROFILE, "/PROF/VM/Halt/Poll", STAMUNIT_TICKS_PER_CALL, "Profiling halted state poll tasks.");
548
549 STAM_REG(pVM, &pUVM->vm.s.StatReqAllocNew, STAMTYPE_COUNTER, "/VM/Req/AllocNew", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a new packet.");
550 STAM_REG(pVM, &pUVM->vm.s.StatReqAllocRaces, STAMTYPE_COUNTER, "/VM/Req/AllocRaces", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc causing races.");
551 STAM_REG(pVM, &pUVM->vm.s.StatReqAllocRecycled, STAMTYPE_COUNTER, "/VM/Req/AllocRecycled", STAMUNIT_OCCURENCES, "Number of VMR3ReqAlloc returning a recycled packet.");
552 STAM_REG(pVM, &pUVM->vm.s.StatReqFree, STAMTYPE_COUNTER, "/VM/Req/Free", STAMUNIT_OCCURENCES, "Number of VMR3ReqFree calls.");
553 STAM_REG(pVM, &pUVM->vm.s.StatReqFreeOverflow, STAMTYPE_COUNTER, "/VM/Req/FreeOverflow", STAMUNIT_OCCURENCES, "Number of times the request was actually freed.");
554
555 rc = CPUMR3Init(pVM);
556 if (VBOX_SUCCESS(rc))
557 {
558 rc = HWACCMR3Init(pVM);
559 if (VBOX_SUCCESS(rc))
560 {
561 rc = PGMR3Init(pVM);
562 if (VBOX_SUCCESS(rc))
563 {
564 rc = REMR3Init(pVM);
565 if (VBOX_SUCCESS(rc))
566 {
567 rc = MMR3InitPaging(pVM);
568 if (VBOX_SUCCESS(rc))
569 rc = TMR3Init(pVM);
570 if (VBOX_SUCCESS(rc))
571 {
572 rc = VMMR3Init(pVM);
573 if (VBOX_SUCCESS(rc))
574 {
575 rc = SELMR3Init(pVM);
576 if (VBOX_SUCCESS(rc))
577 {
578 rc = TRPMR3Init(pVM);
579 if (VBOX_SUCCESS(rc))
580 {
581 rc = CSAMR3Init(pVM);
582 if (VBOX_SUCCESS(rc))
583 {
584 rc = PATMR3Init(pVM);
585 if (VBOX_SUCCESS(rc))
586 {
587 rc = IOMR3Init(pVM);
588 if (VBOX_SUCCESS(rc))
589 {
590 rc = EMR3Init(pVM);
591 if (VBOX_SUCCESS(rc))
592 {
593 rc = DBGFR3Init(pVM);
594 if (VBOX_SUCCESS(rc))
595 {
596 rc = PDMR3Init(pVM);
597 if (VBOX_SUCCESS(rc))
598 {
599 rc = PGMR3InitDynMap(pVM);
600 if (VBOX_SUCCESS(rc))
601 rc = MMR3HyperInitFinalize(pVM);
602 if (VBOX_SUCCESS(rc))
603 rc = PATMR3InitFinalize(pVM);
604 if (VBOX_SUCCESS(rc))
605 rc = PGMR3InitFinalize(pVM);
606 if (VBOX_SUCCESS(rc))
607 rc = SELMR3InitFinalize(pVM);
608 if (VBOX_SUCCESS(rc))
609 rc = TMR3InitFinalize(pVM);
610 if (VBOX_SUCCESS(rc))
611 rc = VMMR3InitFinalize(pVM);
612 if (VBOX_SUCCESS(rc))
613 rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING3);
614 if (VBOX_SUCCESS(rc))
615 {
616 LogFlow(("vmR3InitRing3: returns %Vrc\n", VINF_SUCCESS));
617 return VINF_SUCCESS;
618 }
619 int rc2 = PDMR3Term(pVM);
620 AssertRC(rc2);
621 }
622 int rc2 = DBGFR3Term(pVM);
623 AssertRC(rc2);
624 }
625 int rc2 = EMR3Term(pVM);
626 AssertRC(rc2);
627 }
628 int rc2 = IOMR3Term(pVM);
629 AssertRC(rc2);
630 }
631 int rc2 = PATMR3Term(pVM);
632 AssertRC(rc2);
633 }
634 int rc2 = CSAMR3Term(pVM);
635 AssertRC(rc2);
636 }
637 int rc2 = TRPMR3Term(pVM);
638 AssertRC(rc2);
639 }
640 int rc2 = SELMR3Term(pVM);
641 AssertRC(rc2);
642 }
643 int rc2 = VMMR3Term(pVM);
644 AssertRC(rc2);
645 }
646 int rc2 = TMR3Term(pVM);
647 AssertRC(rc2);
648 }
649 int rc2 = REMR3Term(pVM);
650 AssertRC(rc2);
651 }
652 int rc2 = PGMR3Term(pVM);
653 AssertRC(rc2);
654 }
655 int rc2 = HWACCMR3Term(pVM);
656 AssertRC(rc2);
657 }
658 //int rc2 = CPUMR3Term(pVM);
659 //AssertRC(rc2);
660 }
661 /* MMR3Term is not called here because it'll kill the heap. */
662 }
663
664 LogFlow(("vmR3InitRing3: returns %Vrc\n", rc));
665 return rc;
666}
667
668
669/**
670 * Initializes all R0 components of the VM
671 */
672static int vmR3InitRing0(PVM pVM)
673{
674 LogFlow(("vmR3InitRing0:\n"));
675
676 /*
677 * Check for FAKE suplib mode.
678 */
679 int rc = VINF_SUCCESS;
680 const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
681 if (!psz || strcmp(psz, "fake"))
682 {
683 /*
684 * Call the VMMR0 component and let it do the init.
685 */
686 rc = VMMR3InitR0(pVM);
687 }
688 else
689 Log(("vmR3InitRing0: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
690
691 /*
692 * Do notifications and return.
693 */
694 if (VBOX_SUCCESS(rc))
695 rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING0);
696
697 /** todo: move this to the VMINITCOMPLETED_RING0 notification handler once implemented */
698 if (VBOX_SUCCESS(rc))
699 rc = HWACCMR3InitFinalizeR0(pVM);
700
701 LogFlow(("vmR3InitRing0: returns %Vrc\n", rc));
702 return rc;
703}
704
705
706/**
707 * Initializes all GC components of the VM
708 */
709static int vmR3InitGC(PVM pVM)
710{
711 LogFlow(("vmR3InitGC:\n"));
712
713 /*
714 * Check for FAKE suplib mode.
715 */
716 int rc = VINF_SUCCESS;
717 const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
718 if (!psz || strcmp(psz, "fake"))
719 {
720 /*
721 * Call the VMMR0 component and let it do the init.
722 */
723 rc = VMMR3InitGC(pVM);
724 }
725 else
726 Log(("vmR3InitGC: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
727
728 /*
729 * Do notifications and return.
730 */
731 if (VBOX_SUCCESS(rc))
732 rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_GC);
733 LogFlow(("vmR3InitGC: returns %Vrc\n", rc));
734 return rc;
735}
736
737
738/**
739 * Do init completed notifications.
740 * This notifications can fail.
741 *
742 * @param pVM The VM handle.
743 * @param enmWhat What's completed.
744 */
745static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat)
746{
747
748 return VINF_SUCCESS;
749}
750
751
752/**
753 * Calls the relocation functions for all VMM components so they can update
754 * any GC pointers. When this function is called all the basic VM members
755 * have been updated and the actual memory relocation have been done
756 * by the PGM/MM.
757 *
758 * This is used both on init and on runtime relocations.
759 *
760 * @param pVM VM handle.
761 * @param offDelta Relocation delta relative to old location.
762 */
763VMR3DECL(void) VMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
764{
765 LogFlow(("VMR3Relocate: offDelta=%VGv\n", offDelta));
766
767 /*
768 * The order here is very important!
769 */
770 PGMR3Relocate(pVM, offDelta);
771 PDMR3LdrRelocateU(pVM->pUVM, offDelta);
772 PGMR3Relocate(pVM, 0); /* Repeat after PDM relocation. */
773 CPUMR3Relocate(pVM);
774 HWACCMR3Relocate(pVM);
775 SELMR3Relocate(pVM);
776 VMMR3Relocate(pVM, offDelta);
777 SELMR3Relocate(pVM); /* !hack! fix stack! */
778 TRPMR3Relocate(pVM, offDelta);
779 PATMR3Relocate(pVM);
780 CSAMR3Relocate(pVM, offDelta);
781 IOMR3Relocate(pVM, offDelta);
782 EMR3Relocate(pVM);
783 TMR3Relocate(pVM, offDelta);
784 DBGFR3Relocate(pVM, offDelta);
785 PDMR3Relocate(pVM, offDelta);
786}
787
788
789
790/**
791 * Power on the virtual machine.
792 *
793 * @returns 0 on success.
794 * @returns VBox error code on failure.
795 * @param pVM VM to power on.
796 * @thread Any thread.
797 * @vmstate Created
798 * @vmstateto Running
799 */
800VMR3DECL(int) VMR3PowerOn(PVM pVM)
801{
802 LogFlow(("VMR3PowerOn: pVM=%p\n", pVM));
803
804 /*
805 * Validate input.
806 */
807 if (!pVM)
808 {
809 AssertMsgFailed(("Invalid VM pointer\n"));
810 return VERR_INVALID_PARAMETER;
811 }
812
813 /*
814 * Request the operation in EMT.
815 */
816 PVMREQ pReq;
817 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOn, 1, pVM);
818 if (VBOX_SUCCESS(rc))
819 {
820 rc = pReq->iStatus;
821 VMR3ReqFree(pReq);
822 }
823
824 LogFlow(("VMR3PowerOn: returns %Vrc\n", rc));
825 return rc;
826}
827
828
829/**
830 * Power on the virtual machine.
831 *
832 * @returns 0 on success.
833 * @returns VBox error code on failure.
834 * @param pVM VM to power on.
835 * @thread EMT
836 */
837static DECLCALLBACK(int) vmR3PowerOn(PVM pVM)
838{
839 LogFlow(("vmR3PowerOn: pVM=%p\n", pVM));
840
841 /*
842 * Validate input.
843 */
844 if (pVM->enmVMState != VMSTATE_CREATED)
845 {
846 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
847 return VERR_VM_INVALID_VM_STATE;
848 }
849
850 /*
851 * Change the state, notify the components and resume the execution.
852 */
853 vmR3SetState(pVM, VMSTATE_RUNNING);
854 PDMR3PowerOn(pVM);
855
856 return VINF_SUCCESS;
857}
858
859
860/**
861 * Suspends a running VM.
862 *
863 * @returns 0 on success.
864 * @returns VBox error code on failure.
865 * @param pVM VM to suspend.
866 * @thread Any thread.
867 * @vmstate Running
868 * @vmstateto Suspended
869 */
870VMR3DECL(int) VMR3Suspend(PVM pVM)
871{
872 LogFlow(("VMR3Suspend: pVM=%p\n", pVM));
873
874 /*
875 * Validate input.
876 */
877 if (!pVM)
878 {
879 AssertMsgFailed(("Invalid VM pointer\n"));
880 return VERR_INVALID_PARAMETER;
881 }
882
883 /*
884 * Request the operation in EMT.
885 */
886 PVMREQ pReq;
887 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Suspend, 1, pVM);
888 if (VBOX_SUCCESS(rc))
889 {
890 rc = pReq->iStatus;
891 VMR3ReqFree(pReq);
892 }
893
894 LogFlow(("VMR3Suspend: returns %Vrc\n", rc));
895 return rc;
896}
897
898
899/**
900 * Suspends a running VM and prevent state saving until the VM is resumed or stopped.
901 *
902 * @returns 0 on success.
903 * @returns VBox error code on failure.
904 * @param pVM VM to suspend.
905 * @thread Any thread.
906 * @vmstate Running
907 * @vmstateto Suspended
908 */
909VMR3DECL(int) VMR3SuspendNoSave(PVM pVM)
910{
911 pVM->vm.s.fPreventSaveState = true;
912 return VMR3Suspend(pVM);
913}
914
915
916/**
917 * Suspends a running VM.
918 *
919 * @returns 0 on success.
920 * @returns VBox error code on failure.
921 * @param pVM VM to suspend.
922 * @thread EMT
923 */
924static DECLCALLBACK(int) vmR3Suspend(PVM pVM)
925{
926 LogFlow(("vmR3Suspend: pVM=%p\n", pVM));
927
928 /*
929 * Validate input.
930 */
931 if (pVM->enmVMState != VMSTATE_RUNNING)
932 {
933 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
934 return VERR_VM_INVALID_VM_STATE;
935 }
936
937 /*
938 * Change the state, notify the components and resume the execution.
939 */
940 vmR3SetState(pVM, VMSTATE_SUSPENDED);
941 PDMR3Suspend(pVM);
942
943 return VINF_EM_SUSPEND;
944}
945
946
947/**
948 * Resume VM execution.
949 *
950 * @returns 0 on success.
951 * @returns VBox error code on failure.
952 * @param pVM The VM to resume.
953 * @thread Any thread.
954 * @vmstate Suspended
955 * @vmstateto Running
956 */
957VMR3DECL(int) VMR3Resume(PVM pVM)
958{
959 LogFlow(("VMR3Resume: pVM=%p\n", pVM));
960
961 /*
962 * Validate input.
963 */
964 if (!pVM)
965 {
966 AssertMsgFailed(("Invalid VM pointer\n"));
967 return VERR_INVALID_PARAMETER;
968 }
969
970 /*
971 * Request the operation in EMT.
972 */
973 PVMREQ pReq;
974 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Resume, 1, pVM);
975 if (VBOX_SUCCESS(rc))
976 {
977 rc = pReq->iStatus;
978 VMR3ReqFree(pReq);
979 }
980
981 LogFlow(("VMR3Resume: returns %Vrc\n", rc));
982 return rc;
983}
984
985
986/**
987 * Resume VM execution.
988 *
989 * @returns 0 on success.
990 * @returns VBox error code on failure.
991 * @param pVM The VM to resume.
992 * @thread EMT
993 */
994static DECLCALLBACK(int) vmR3Resume(PVM pVM)
995{
996 LogFlow(("vmR3Resume: pVM=%p\n", pVM));
997
998 /*
999 * Validate input.
1000 */
1001 if (pVM->enmVMState != VMSTATE_SUSPENDED)
1002 {
1003 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1004 return VERR_VM_INVALID_VM_STATE;
1005 }
1006
1007 /*
1008 * Change the state, notify the components and resume the execution.
1009 */
1010 pVM->vm.s.fPreventSaveState = false;
1011 vmR3SetState(pVM, VMSTATE_RUNNING);
1012 PDMR3Resume(pVM);
1013
1014 return VINF_EM_RESUME;
1015}
1016
1017
1018/**
1019 * Save current VM state.
1020 *
1021 * To save and terminate the VM, the VM must be suspended before the call.
1022 *
1023 * @returns 0 on success.
1024 * @returns VBox error code on failure.
1025 * @param pVM VM which state should be saved.
1026 * @param pszFilename Name of the save state file.
1027 * @param pfnProgress Progress callback. Optional.
1028 * @param pvUser User argument for the progress callback.
1029 * @thread Any thread.
1030 * @vmstate Suspended
1031 * @vmstateto Unchanged state.
1032 */
1033VMR3DECL(int) VMR3Save(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1034{
1035 LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1036
1037 /*
1038 * Validate input.
1039 */
1040 if (!pVM)
1041 {
1042 AssertMsgFailed(("Invalid VM pointer\n"));
1043 return VERR_INVALID_PARAMETER;
1044 }
1045 if (!pszFilename)
1046 {
1047 AssertMsgFailed(("Must specify a filename to save the state to, wise guy!\n"));
1048 return VERR_INVALID_PARAMETER;
1049 }
1050
1051 /*
1052 * Request the operation in EMT.
1053 */
1054 PVMREQ pReq;
1055 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Save, 4, pVM, pszFilename, pfnProgress, pvUser);
1056 if (VBOX_SUCCESS(rc))
1057 {
1058 rc = pReq->iStatus;
1059 VMR3ReqFree(pReq);
1060 }
1061
1062 LogFlow(("VMR3Save: returns %Vrc\n", rc));
1063 return rc;
1064}
1065
1066
1067/**
1068 * Save current VM state.
1069 *
1070 * To save and terminate the VM, the VM must be suspended before the call.
1071 *
1072 * @returns 0 on success.
1073 * @returns VBox error code on failure.
1074 * @param pVM VM which state should be saved.
1075 * @param pszFilename Name of the save state file.
1076 * @param pfnProgress Progress callback. Optional.
1077 * @param pvUser User argument for the progress callback.
1078 * @thread EMT
1079 */
1080static DECLCALLBACK(int) vmR3Save(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1081{
1082 LogFlow(("vmR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1083
1084 /*
1085 * Validate input.
1086 */
1087 if (pVM->enmVMState != VMSTATE_SUSPENDED)
1088 {
1089 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1090 return VERR_VM_INVALID_VM_STATE;
1091 }
1092
1093 /* If we are in an inconsistent state, then we don't allow state saving. */
1094 if (pVM->vm.s.fPreventSaveState)
1095 {
1096 LogRel(("VMM: vmR3Save: saving the VM state is not allowed at this moment\n"));
1097 return VERR_VM_SAVE_STATE_NOT_ALLOWED;
1098 }
1099
1100 /*
1101 * Change the state and perform the save.
1102 */
1103 /** @todo implement progress support in SSM */
1104 vmR3SetState(pVM, VMSTATE_SAVING);
1105 int rc = SSMR3Save(pVM, pszFilename, SSMAFTER_CONTINUE, pfnProgress, pvUser);
1106 vmR3SetState(pVM, VMSTATE_SUSPENDED);
1107
1108 return rc;
1109}
1110
1111
1112/**
1113 * Loads a new VM state.
1114 *
1115 * To restore a saved state on VM startup, call this function and then
1116 * resume the VM instead of powering it on.
1117 *
1118 * @returns 0 on success.
1119 * @returns VBox error code on failure.
1120 * @param pVM VM which state should be saved.
1121 * @param pszFilename Name of the save state file.
1122 * @param pfnProgress Progress callback. Optional.
1123 * @param pvUser User argument for the progress callback.
1124 * @thread Any thread.
1125 * @vmstate Created, Suspended
1126 * @vmstateto Suspended
1127 */
1128VMR3DECL(int) VMR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1129{
1130 LogFlow(("VMR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1131
1132 /*
1133 * Validate input.
1134 */
1135 if (!pVM)
1136 {
1137 AssertMsgFailed(("Invalid VM pointer\n"));
1138 return VERR_INVALID_PARAMETER;
1139 }
1140 if (!pszFilename)
1141 {
1142 AssertMsgFailed(("Must specify a filename to load the state from, wise guy!\n"));
1143 return VERR_INVALID_PARAMETER;
1144 }
1145
1146 /*
1147 * Request the operation in EMT.
1148 */
1149 PVMREQ pReq;
1150 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
1151 if (VBOX_SUCCESS(rc))
1152 {
1153 rc = pReq->iStatus;
1154 VMR3ReqFree(pReq);
1155 }
1156
1157 LogFlow(("VMR3Load: returns %Vrc\n", rc));
1158 return rc;
1159}
1160
1161
1162/**
1163 * Loads a new VM state.
1164 *
1165 * To restore a saved state on VM startup, call this function and then
1166 * resume the VM instead of powering it on.
1167 *
1168 * @returns 0 on success.
1169 * @returns VBox error code on failure.
1170 * @param pVM VM which state should be saved.
1171 * @param pszFilename Name of the save state file.
1172 * @param pfnProgress Progress callback. Optional.
1173 * @param pvUser User argument for the progress callback.
1174 * @thread EMT.
1175 */
1176static DECLCALLBACK(int) vmR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1177{
1178 LogFlow(("vmR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1179
1180 /*
1181 * Validate input.
1182 */
1183 if ( pVM->enmVMState != VMSTATE_SUSPENDED
1184 && pVM->enmVMState != VMSTATE_CREATED)
1185 {
1186 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1187 return VMSetError(pVM, VERR_VM_INVALID_VM_STATE, RT_SRC_POS, N_("Invalid VM state (%s) for restoring state from '%s'"),
1188 VMR3GetStateName(pVM->enmVMState), pszFilename);
1189 }
1190
1191 /*
1192 * Change the state and perform the load.
1193 */
1194 vmR3SetState(pVM, VMSTATE_LOADING);
1195 int rc = SSMR3Load(pVM, pszFilename, SSMAFTER_RESUME, pfnProgress, pvUser);
1196 if (VBOX_SUCCESS(rc))
1197 {
1198 /* Not paranoia anymore; the saved guest might use different hypervisor selectors. We must call VMR3Relocate. */
1199 VMR3Relocate(pVM, 0);
1200 vmR3SetState(pVM, VMSTATE_SUSPENDED);
1201 }
1202 else
1203 {
1204 vmR3SetState(pVM, VMSTATE_LOAD_FAILURE);
1205 rc = VMSetError(pVM, rc, RT_SRC_POS, N_("Unable to restore the virtual machine's saved state from '%s'. It may be damaged or from an older version of VirtualBox. Please discard the saved state before starting the virtual machine"), pszFilename);
1206 }
1207
1208 return rc;
1209}
1210
1211
1212/**
1213 * Power Off the VM.
1214 *
1215 * @returns 0 on success.
1216 * @returns VBox error code on failure.
1217 * @param pVM VM which should be destroyed.
1218 * @thread Any thread.
1219 * @vmstate Suspended, Running, Guru Mediation, Load Failure
1220 * @vmstateto Off
1221 */
1222VMR3DECL(int) VMR3PowerOff(PVM pVM)
1223{
1224 LogFlow(("VMR3PowerOff: pVM=%p\n", pVM));
1225
1226 /*
1227 * Validate input.
1228 */
1229 if (!pVM)
1230 {
1231 AssertMsgFailed(("Invalid VM pointer\n"));
1232 return VERR_INVALID_PARAMETER;
1233 }
1234
1235 /*
1236 * Request the operation in EMT.
1237 */
1238 PVMREQ pReq;
1239 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOff, 1, pVM);
1240 if (VBOX_SUCCESS(rc))
1241 {
1242 rc = pReq->iStatus;
1243 VMR3ReqFree(pReq);
1244 }
1245
1246 LogFlow(("VMR3PowerOff: returns %Vrc\n", rc));
1247 return rc;
1248}
1249
1250
1251/**
1252 * Power Off the VM.
1253 *
1254 * @returns 0 on success.
1255 * @returns VBox error code on failure.
1256 * @param pVM VM which should be destroyed.
1257 * @thread EMT.
1258 */
1259static DECLCALLBACK(int) vmR3PowerOff(PVM pVM)
1260{
1261 LogFlow(("vmR3PowerOff: pVM=%p\n", pVM));
1262
1263 /*
1264 * Validate input.
1265 */
1266 if ( pVM->enmVMState != VMSTATE_RUNNING
1267 && pVM->enmVMState != VMSTATE_SUSPENDED
1268 && pVM->enmVMState != VMSTATE_LOAD_FAILURE
1269 && pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1270 {
1271 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1272 return VERR_VM_INVALID_VM_STATE;
1273 }
1274
1275 /*
1276 * For debugging purposes, we will log a summary of the guest state at this point.
1277 */
1278 if (pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1279 {
1280 /** @todo make the state dumping at VMR3PowerOff optional. */
1281 RTLogRelPrintf("****************** Guest state at power off ******************\n");
1282 DBGFR3Info(pVM, "cpumguest", "verbose", DBGFR3InfoLogRelHlp());
1283 RTLogRelPrintf("***\n");
1284 DBGFR3Info(pVM, "mode", NULL, DBGFR3InfoLogRelHlp());
1285 RTLogRelPrintf("***\n");
1286 DBGFR3Info(pVM, "activetimers", NULL, DBGFR3InfoLogRelHlp());
1287 RTLogRelPrintf("***\n");
1288 DBGFR3Info(pVM, "gdt", NULL, DBGFR3InfoLogRelHlp());
1289 /** @todo dump guest call stack. */
1290#if 1 // temporary while debugging #1589
1291 RTLogRelPrintf("***\n");
1292 uint32_t esp = CPUMGetGuestESP(pVM);
1293 if ( CPUMGetGuestSS(pVM) == 0
1294 && esp < _64K)
1295 {
1296 uint8_t abBuf[PAGE_SIZE];
1297 RTLogRelPrintf("***\n"
1298 "ss:sp=0000:%04x ", esp);
1299 uint32_t Start = esp & ~(uint32_t)63;
1300 int rc = PGMPhysReadGCPhys(pVM, abBuf, Start, 0x100);
1301 if (VBOX_SUCCESS(rc))
1302 RTLogRelPrintf("0000:%04x TO 0000:%04x:\n"
1303 "%.*Rhxd\n",
1304 Start, Start + 0x100 - 1,
1305 0x100, abBuf);
1306 else
1307 RTLogRelPrintf("rc=%Vrc\n", rc);
1308
1309 /* grub ... */
1310 if (esp < 0x2000 && esp > 0x1fc0)
1311 {
1312 rc = PGMPhysReadGCPhys(pVM, abBuf, 0x8000, 0x800);
1313 if (VBOX_SUCCESS(rc))
1314 RTLogRelPrintf("0000:8000 TO 0000:87ff:\n"
1315 "%.*Rhxd\n",
1316 0x800, abBuf);
1317 }
1318 /* microsoft cdrom hang ... */
1319 if (true)
1320 {
1321 rc = PGMPhysReadGCPhys(pVM, abBuf, 0x8000, 0x200);
1322 if (VBOX_SUCCESS(rc))
1323 RTLogRelPrintf("2000:0000 TO 2000:01ff:\n"
1324 "%.*Rhxd\n",
1325 0x200, abBuf);
1326 }
1327 }
1328#endif
1329 RTLogRelPrintf("************** End of Guest state at power off ***************\n");
1330 }
1331
1332 /*
1333 * Change the state to OFF and notify the components.
1334 */
1335 vmR3SetState(pVM, VMSTATE_OFF);
1336 PDMR3PowerOff(pVM);
1337
1338 return VINF_EM_OFF;
1339}
1340
1341
1342/**
1343 * Destroys the VM.
1344 * The VM must be powered off (or never really powered on) to call this function.
1345 * The VM handle is destroyed and can no longer be used up successful return.
1346 *
1347 * @returns VBox status code.
1348 * @param pVM VM which should be destroyed.
1349 * @thread Any thread but the emulation thread.
1350 * @vmstate Off, Created
1351 * @vmstateto N/A
1352 */
1353VMR3DECL(int) VMR3Destroy(PVM pVM)
1354{
1355 LogFlow(("VMR3Destroy: pVM=%p\n", pVM));
1356
1357 /*
1358 * Validate input.
1359 */
1360 if (!pVM)
1361 return VERR_INVALID_PARAMETER;
1362 AssertPtrReturn(pVM, VERR_INVALID_POINTER);
1363 AssertMsgReturn( pVM->enmVMState == VMSTATE_OFF
1364 || pVM->enmVMState == VMSTATE_CREATED,
1365 ("Invalid VM state %d\n", pVM->enmVMState),
1366 VERR_VM_INVALID_VM_STATE);
1367
1368 /*
1369 * Change VM state to destroying and unlink the VM.
1370 */
1371 vmR3SetState(pVM, VMSTATE_DESTROYING);
1372
1373 /** @todo lock this when we start having multiple machines in a process... */
1374 PUVM pUVM = pVM->pUVM; AssertPtr(pUVM);
1375 if (g_pUVMsHead == pUVM)
1376 g_pUVMsHead = pUVM->pNext;
1377 else
1378 {
1379 PUVM pPrev = g_pUVMsHead;
1380 while (pPrev && pPrev->pNext != pUVM)
1381 pPrev = pPrev->pNext;
1382 AssertMsgReturn(pPrev, ("pUVM=%p / pVM=%p is INVALID!\n", pUVM, pVM), VERR_INVALID_PARAMETER);
1383
1384 pPrev->pNext = pUVM->pNext;
1385 }
1386 pUVM->pNext = NULL;
1387
1388 /*
1389 * Notify registered at destruction listeners.
1390 * (That's the debugger console.)
1391 */
1392 vmR3AtDtor(pVM);
1393
1394 /*
1395 * If we are the EMT we'll delay the cleanup till later.
1396 */
1397 if (VM_IS_EMT(pVM))
1398 {
1399 pUVM->vm.s.fEMTDoesTheCleanup = true;
1400 pUVM->vm.s.fTerminateEMT = true;
1401 VM_FF_SET(pVM, VM_FF_TERMINATE);
1402 }
1403 else
1404 {
1405 /*
1406 * Request EMT to do the larger part of the destruction.
1407 */
1408 PVMREQ pReq = NULL;
1409 int rc = VMR3ReqCallU(pUVM, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3Destroy, 1, pVM);
1410 if (RT_SUCCESS(rc))
1411 rc = pReq->iStatus;
1412 AssertRC(rc);
1413 VMR3ReqFree(pReq);
1414
1415 /*
1416 * Wait for the EMT thread to terminate.
1417 */
1418 Assert(pUVM->vm.s.fTerminateEMT);
1419 rc = RTThreadWait(pUVM->vm.s.ThreadEMT, 30000, NULL);
1420 AssertMsgRC(rc, ("EMT thread wait failed, rc=%Rrc\n", rc));
1421
1422 /*
1423 * Now do the final bit where the heap and VM structures are freed up.
1424 */
1425 vmR3DestroyUVM(pUVM);
1426 }
1427
1428 LogFlow(("VMR3Destroy: returns VINF_SUCCESS\n"));
1429 return VINF_SUCCESS;
1430}
1431
1432
1433/**
1434 * Internal destruction worker.
1435 *
1436 * This will do nearly all of the job, including sacking the EMT.
1437 *
1438 * @returns VBox status.
1439 * @param pVM VM handle.
1440 */
1441DECLCALLBACK(int) vmR3Destroy(PVM pVM)
1442{
1443 PUVM pUVM = pVM->pUVM;
1444 NOREF(pUVM);
1445 LogFlow(("vmR3Destroy: pVM=%p pUVM=%p\n", pVM, pUVM));
1446 VM_ASSERT_EMT(pVM);
1447
1448 /*
1449 * Dump statistics to the log.
1450 */
1451#if defined(VBOX_WITH_STATISTICS) || defined(LOG_ENABLED)
1452 RTLogFlags(NULL, "nodisabled nobuffered");
1453#endif
1454#ifdef VBOX_WITH_STATISTICS
1455# ifndef DEBUG_dmik
1456 STAMR3Dump(pVM, "*");
1457# endif
1458#else
1459 LogRel(("************************* Statistics *************************\n"));
1460 STAMR3DumpToReleaseLog(pVM, "*");
1461 LogRel(("********************* End of statistics **********************\n"));
1462#endif
1463
1464 /*
1465 * Destroy the VM components.
1466 */
1467 int rc = TMR3Term(pVM);
1468 AssertRC(rc);
1469#ifdef VBOX_WITH_DEBUGGER
1470 rc = DBGCTcpTerminate(pVM, pUVM->vm.s.pvDBGC);
1471 pVM->pUVM->vm.s.pvDBGC = NULL;
1472#endif
1473 AssertRC(rc);
1474 rc = DBGFR3Term(pVM);
1475 AssertRC(rc);
1476 rc = PDMR3Term(pVM);
1477 AssertRC(rc);
1478 rc = EMR3Term(pVM);
1479 AssertRC(rc);
1480 rc = IOMR3Term(pVM);
1481 AssertRC(rc);
1482 rc = CSAMR3Term(pVM);
1483 AssertRC(rc);
1484 rc = PATMR3Term(pVM);
1485 AssertRC(rc);
1486 rc = TRPMR3Term(pVM);
1487 AssertRC(rc);
1488 rc = SELMR3Term(pVM);
1489 AssertRC(rc);
1490 rc = REMR3Term(pVM);
1491 AssertRC(rc);
1492 rc = HWACCMR3Term(pVM);
1493 AssertRC(rc);
1494 rc = PGMR3Term(pVM);
1495 AssertRC(rc);
1496 rc = VMMR3Term(pVM); /* Terminates the ring-0 code! */
1497 AssertRC(rc);
1498 rc = CPUMR3Term(pVM);
1499 AssertRC(rc);
1500 rc = PDMR3CritSectTerm(pVM);
1501 AssertRC(rc);
1502 rc = MMR3Term(pVM);
1503 AssertRC(rc);
1504
1505 /*
1506 * We're done in this thread (EMT).
1507 */
1508 ASMAtomicUoWriteBool(&pVM->pUVM->vm.s.fTerminateEMT, true);
1509 ASMAtomicWriteU32(&pVM->fForcedActions, VM_FF_TERMINATE);
1510 LogFlow(("vmR3Destroy: returning %Vrc\n", VINF_EM_TERMINATE));
1511 return VINF_EM_TERMINATE;
1512}
1513
1514
1515/**
1516 * Destroys the shared VM structure, leaving only UVM behind.
1517 *
1518 * This is called by EMT right before terminating.
1519 *
1520 * @param pUVM The UVM handle.
1521 */
1522void vmR3DestroyFinalBitFromEMT(PUVM pUVM)
1523{
1524 if (pUVM->pVM)
1525 {
1526 /*
1527 * Modify state and then terminate MM.
1528 * (MM must be delayed until this point so we don't destroy the callbacks and the request packet.)
1529 */
1530 vmR3SetState(pUVM->pVM, VMSTATE_TERMINATED);
1531
1532 /*
1533 * Tell GVMM to destroy the VM and free its resources.
1534 */
1535 int rc = SUPCallVMMR0Ex(pUVM->pVM->pVMR0, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
1536 AssertRC(rc);
1537 pUVM->pVM = NULL;
1538 }
1539
1540 /*
1541 * Did EMT call VMR3Destroy and have to do it all?
1542 */
1543 if (pUVM->vm.s.fEMTDoesTheCleanup)
1544 vmR3DestroyUVM(pUVM);
1545}
1546
1547
1548/**
1549 * Destroys the UVM portion.
1550 *
1551 * This is called as the final step in the VM destruction or as the cleanup
1552 * in case of a creation failure. If EMT called VMR3Destroy, meaning
1553 * VMINTUSERPERVM::fEMTDoesTheCleanup is true, it will call this as
1554 * vmR3DestroyFinalBitFromEMT completes.
1555 *
1556 * @param pVM VM Handle.
1557 */
1558static void vmR3DestroyUVM(PUVM pUVM)
1559{
1560 /*
1561 * Terminate the EMT if still running (creation failure only).
1562 */
1563 if (!pUVM->vm.s.fTerminateEMT)
1564 {
1565 ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
1566 if (pUVM->pVM)
1567 {
1568 VM_FF_SET(pUVM->pVM, VM_FF_TERMINATE);
1569 VMR3NotifyFF(pUVM->pVM, false);
1570 }
1571 RTSemEventSignal(pUVM->vm.s.EventSemWait);
1572
1573 int rc2 = RTThreadWait(pUVM->vm.s.ThreadEMT, 2000, NULL);
1574 AssertRC(rc2);
1575 }
1576 RTSemEventDestroy(pUVM->vm.s.EventSemWait);
1577 pUVM->vm.s.EventSemWait = NIL_RTSEMEVENT;
1578
1579 /*
1580 * Free the event semaphores associated with the request packets.
1581 */
1582 unsigned cReqs = 0;
1583 for (unsigned i = 0; i < RT_ELEMENTS(pUVM->vm.s.apReqFree); i++)
1584 {
1585 PVMREQ pReq = pUVM->vm.s.apReqFree[i];
1586 pUVM->vm.s.apReqFree[i] = NULL;
1587 for (; pReq; pReq = pReq->pNext, cReqs++)
1588 {
1589 pReq->enmState = VMREQSTATE_INVALID;
1590 RTSemEventDestroy(pReq->EventSem);
1591 }
1592 }
1593 Assert(cReqs == pUVM->vm.s.cReqFree); NOREF(cReqs);
1594
1595 /*
1596 * Kill all queued requests. (There really shouldn't be any!)
1597 */
1598 for (unsigned i = 0; i < 10; i++)
1599 {
1600 PVMREQ pReqHead = (PVMREQ)ASMAtomicXchgPtr((void *volatile *)&pUVM->vm.s.pReqs, NULL);
1601 AssertMsg(!pReqHead, ("This isn't supposed to happen! VMR3Destroy caller has to serialize this.\n"));
1602 if (!pReqHead)
1603 break;
1604 for (PVMREQ pReq = pReqHead; pReq; pReq = pReq->pNext)
1605 {
1606 ASMAtomicUoWriteSize(&pReq->iStatus, VERR_INTERNAL_ERROR);
1607 ASMAtomicWriteSize(&pReq->enmState, VMREQSTATE_INVALID);
1608 RTSemEventSignal(pReq->EventSem);
1609 RTThreadSleep(2);
1610 RTSemEventDestroy(pReq->EventSem);
1611 }
1612 /* give them a chance to respond before we free the request memory. */
1613 RTThreadSleep(32);
1614 }
1615
1616 /*
1617 * Make sure the VMMR0.r0 module and whatever else is unloaded.
1618 */
1619 PDMR3TermUVM(pUVM);
1620
1621 /*
1622 * Terminate the support library if initialized.
1623 */
1624 if (pUVM->vm.s.pSession)
1625 {
1626 int rc = SUPTerm();
1627 AssertRC(rc);
1628 pUVM->vm.s.pSession = NIL_RTR0PTR;
1629 }
1630
1631 /*
1632 * Destroy the MM heap and free the UVM structure.
1633 */
1634 MMR3TermUVM(pUVM);
1635 STAMR3TermUVM(pUVM);
1636
1637 ASMAtomicUoWriteU32(&pUVM->u32Magic, UINT32_MAX);
1638 RTMemFree(pUVM);
1639
1640 RTLogFlush(NULL);
1641}
1642
1643
1644/**
1645 * Enumerates the VMs in this process.
1646 *
1647 * @returns Pointer to the next VM.
1648 * @returns NULL when no more VMs.
1649 * @param pVMPrev The previous VM
1650 * Use NULL to start the enumeration.
1651 */
1652VMR3DECL(PVM) VMR3EnumVMs(PVM pVMPrev)
1653{
1654 /*
1655 * This is quick and dirty. It has issues with VM being
1656 * destroyed during the enumeration.
1657 */
1658 PUVM pNext;
1659 if (pVMPrev)
1660 pNext = pVMPrev->pUVM->pNext;
1661 else
1662 pNext = g_pUVMsHead;
1663 return pNext ? pNext->pVM : NULL;
1664}
1665
1666
1667/**
1668 * Registers an at VM destruction callback.
1669 *
1670 * @returns VBox status code.
1671 * @param pfnAtDtor Pointer to callback.
1672 * @param pvUser User argument.
1673 */
1674VMR3DECL(int) VMR3AtDtorRegister(PFNVMATDTOR pfnAtDtor, void *pvUser)
1675{
1676 /*
1677 * Check if already registered.
1678 */
1679 VM_ATDTOR_LOCK();
1680 PVMATDTOR pCur = g_pVMAtDtorHead;
1681 while (pCur)
1682 {
1683 if (pfnAtDtor == pCur->pfnAtDtor)
1684 {
1685 VM_ATDTOR_UNLOCK();
1686 AssertMsgFailed(("Already registered at destruction callback %p!\n", pfnAtDtor));
1687 return VERR_INVALID_PARAMETER;
1688 }
1689
1690 /* next */
1691 pCur = pCur->pNext;
1692 }
1693 VM_ATDTOR_UNLOCK();
1694
1695 /*
1696 * Allocate new entry.
1697 */
1698 PVMATDTOR pVMAtDtor = (PVMATDTOR)RTMemAlloc(sizeof(*pVMAtDtor));
1699 if (!pVMAtDtor)
1700 return VERR_NO_MEMORY;
1701
1702 VM_ATDTOR_LOCK();
1703 pVMAtDtor->pfnAtDtor = pfnAtDtor;
1704 pVMAtDtor->pvUser = pvUser;
1705 pVMAtDtor->pNext = g_pVMAtDtorHead;
1706 g_pVMAtDtorHead = pVMAtDtor;
1707 VM_ATDTOR_UNLOCK();
1708
1709 return VINF_SUCCESS;
1710}
1711
1712
1713/**
1714 * Deregisters an at VM destruction callback.
1715 *
1716 * @returns VBox status code.
1717 * @param pfnAtDtor Pointer to callback.
1718 */
1719VMR3DECL(int) VMR3AtDtorDeregister(PFNVMATDTOR pfnAtDtor)
1720{
1721 /*
1722 * Find it, unlink it and free it.
1723 */
1724 VM_ATDTOR_LOCK();
1725 PVMATDTOR pPrev = NULL;
1726 PVMATDTOR pCur = g_pVMAtDtorHead;
1727 while (pCur)
1728 {
1729 if (pfnAtDtor == pCur->pfnAtDtor)
1730 {
1731 if (pPrev)
1732 pPrev->pNext = pCur->pNext;
1733 else
1734 g_pVMAtDtorHead = pCur->pNext;
1735 pCur->pNext = NULL;
1736 VM_ATDTOR_UNLOCK();
1737
1738 RTMemFree(pCur);
1739 return VINF_SUCCESS;
1740 }
1741
1742 /* next */
1743 pPrev = pCur;
1744 pCur = pCur->pNext;
1745 }
1746 VM_ATDTOR_UNLOCK();
1747
1748 return VERR_INVALID_PARAMETER;
1749}
1750
1751
1752/**
1753 * Walks the list of at VM destructor callbacks.
1754 * @param pVM The VM which is about to be destroyed.
1755 */
1756static void vmR3AtDtor(PVM pVM)
1757{
1758 /*
1759 * Find it, unlink it and free it.
1760 */
1761 VM_ATDTOR_LOCK();
1762 for (PVMATDTOR pCur = g_pVMAtDtorHead; pCur; pCur = pCur->pNext)
1763 pCur->pfnAtDtor(pVM, pCur->pvUser);
1764 VM_ATDTOR_UNLOCK();
1765}
1766
1767
1768/**
1769 * Reset the current VM.
1770 *
1771 * @returns VBox status code.
1772 * @param pVM VM to reset.
1773 */
1774VMR3DECL(int) VMR3Reset(PVM pVM)
1775{
1776 int rc = VINF_SUCCESS;
1777
1778 /*
1779 * Check the state.
1780 */
1781 if (!pVM)
1782 return VERR_INVALID_PARAMETER;
1783 if ( pVM->enmVMState != VMSTATE_RUNNING
1784 && pVM->enmVMState != VMSTATE_SUSPENDED)
1785 {
1786 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1787 return VERR_VM_INVALID_VM_STATE;
1788 }
1789
1790 /*
1791 * Queue reset request to the emulation thread
1792 * and wait for it to be processed.
1793 */
1794 PVMREQ pReq = NULL;
1795 rc = VMR3ReqCall(pVM, &pReq, 0, (PFNRT)vmR3Reset, 1, pVM);
1796 while (rc == VERR_TIMEOUT)
1797 rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
1798 if (VBOX_SUCCESS(rc))
1799 rc = pReq->iStatus;
1800 VMR3ReqFree(pReq);
1801
1802 return rc;
1803}
1804
1805
1806/**
1807 * Worker which checks integrity of some internal structures.
1808 * This is yet another attempt to track down that AVL tree crash.
1809 */
1810static void vmR3CheckIntegrity(PVM pVM)
1811{
1812#ifdef VBOX_STRICT
1813 int rc = PGMR3CheckIntegrity(pVM);
1814 AssertReleaseRC(rc);
1815#endif
1816}
1817
1818
1819/**
1820 * Reset request processor.
1821 *
1822 * This is called by the emulation thread as a response to the
1823 * reset request issued by VMR3Reset().
1824 *
1825 * @returns VBox status code.
1826 * @param pVM VM to reset.
1827 */
1828static DECLCALLBACK(int) vmR3Reset(PVM pVM)
1829{
1830 /*
1831 * As a safety precaution we temporarily change the state while resetting.
1832 * (If VMR3Reset was not called from EMT we might have change state... let's ignore that fact for now.)
1833 */
1834 VMSTATE enmVMState = pVM->enmVMState;
1835 Assert(enmVMState == VMSTATE_SUSPENDED || enmVMState == VMSTATE_RUNNING);
1836 vmR3SetState(pVM, VMSTATE_RESETTING);
1837 vmR3CheckIntegrity(pVM);
1838
1839
1840 /*
1841 * Reset the VM components.
1842 */
1843 PATMR3Reset(pVM);
1844 CSAMR3Reset(pVM);
1845 PGMR3Reset(pVM); /* We clear VM RAM in PGMR3Reset. It's vital PDMR3Reset is executed
1846 * _afterwards_. E.g. ACPI sets up RAM tables during init/reset. */
1847 MMR3Reset(pVM);
1848 PDMR3Reset(pVM);
1849 SELMR3Reset(pVM);
1850 TRPMR3Reset(pVM);
1851 vmR3AtResetU(pVM->pUVM);
1852 REMR3Reset(pVM);
1853 IOMR3Reset(pVM);
1854 CPUMR3Reset(pVM);
1855 TMR3Reset(pVM);
1856 EMR3Reset(pVM);
1857 HWACCMR3Reset(pVM); /* This must come *after* PATM, CSAM, CPUM, SELM and TRPM. */
1858
1859#ifdef LOG_ENABLED
1860 /*
1861 * Debug logging.
1862 */
1863 RTLogPrintf("\n\nThe VM was reset:\n");
1864 DBGFR3Info(pVM, "cpum", "verbose", NULL);
1865#endif
1866
1867 /*
1868 * Restore the state.
1869 */
1870 vmR3CheckIntegrity(pVM);
1871 Assert(pVM->enmVMState == VMSTATE_RESETTING);
1872 vmR3SetState(pVM, enmVMState);
1873
1874 return VINF_EM_RESET;
1875}
1876
1877
1878/**
1879 * Walks the list of at VM reset callbacks and calls them
1880 *
1881 * @returns VBox status code.
1882 * Any failure is fatal.
1883 * @param pUVM Pointe to the user mode VM structure.
1884 */
1885static int vmR3AtResetU(PUVM pUVM)
1886{
1887 /*
1888 * Walk the list and call them all.
1889 */
1890 int rc = VINF_SUCCESS;
1891 for (PVMATRESET pCur = pUVM->vm.s.pAtReset; pCur; pCur = pCur->pNext)
1892 {
1893 /* do the call */
1894 switch (pCur->enmType)
1895 {
1896 case VMATRESETTYPE_DEV:
1897 rc = pCur->u.Dev.pfnCallback(pCur->u.Dev.pDevIns, pCur->pvUser);
1898 break;
1899 case VMATRESETTYPE_INTERNAL:
1900 rc = pCur->u.Internal.pfnCallback(pUVM->pVM, pCur->pvUser);
1901 break;
1902 case VMATRESETTYPE_EXTERNAL:
1903 pCur->u.External.pfnCallback(pCur->pvUser);
1904 break;
1905 default:
1906 AssertMsgFailed(("Invalid at-reset type %d!\n", pCur->enmType));
1907 return VERR_INTERNAL_ERROR;
1908 }
1909
1910 if (VBOX_FAILURE(rc))
1911 {
1912 AssertMsgFailed(("At-reset handler %s failed with rc=%d\n", pCur->pszDesc, rc));
1913 return rc;
1914 }
1915 }
1916
1917 return VINF_SUCCESS;
1918}
1919
1920
1921/**
1922 * Internal registration function
1923 */
1924static int vmr3AtResetRegisterU(PUVM pUVM, void *pvUser, const char *pszDesc, PVMATRESET *ppNew)
1925{
1926 /*
1927 * Allocate restration structure.
1928 */
1929 PVMATRESET pNew = (PVMATRESET)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
1930 if (pNew)
1931 {
1932 /* fill data. */
1933 pNew->pNext = NULL;
1934 pNew->pszDesc = pszDesc;
1935 pNew->pvUser = pvUser;
1936
1937 /* insert */
1938 *pUVM->vm.s.ppAtResetNext = pNew;
1939 pUVM->vm.s.ppAtResetNext = &pNew->pNext;
1940
1941 *ppNew = pNew;
1942 return VINF_SUCCESS;
1943 }
1944 return VERR_NO_MEMORY;
1945}
1946
1947
1948/**
1949 * Registers an at VM reset callback.
1950 *
1951 * @returns VBox status code.
1952 * @param pVM The VM.
1953 * @param pDevInst Device instance.
1954 * @param pfnCallback Callback function.
1955 * @param pvUser User argument.
1956 * @param pszDesc Description (optional).
1957 */
1958VMR3DECL(int) VMR3AtResetRegister(PVM pVM, PPDMDEVINS pDevInst, PFNVMATRESET pfnCallback, void *pvUser, const char *pszDesc)
1959{
1960 /*
1961 * Validate.
1962 */
1963 if (!pDevInst)
1964 {
1965 AssertMsgFailed(("pDevIns is NULL!\n"));
1966 return VERR_INVALID_PARAMETER;
1967 }
1968
1969 /*
1970 * Create the new entry.
1971 */
1972 PVMATRESET pNew;
1973 int rc = vmr3AtResetRegisterU(pVM->pUVM, pvUser, pszDesc, &pNew);
1974 if (VBOX_SUCCESS(rc))
1975 {
1976 /*
1977 * Fill in type data.
1978 */
1979 pNew->enmType = VMATRESETTYPE_DEV;
1980 pNew->u.Dev.pfnCallback = pfnCallback;
1981 pNew->u.Dev.pDevIns = pDevInst;
1982 }
1983
1984 return rc;
1985}
1986
1987
1988/**
1989 * Registers an at VM reset internal callback.
1990 *
1991 * @returns VBox status code.
1992 * @param pVM The VM.
1993 * @param pfnCallback Callback function.
1994 * @param pvUser User argument.
1995 * @param pszDesc Description (optional).
1996 */
1997VMR3DECL(int) VMR3AtResetRegisterInternal(PVM pVM, PFNVMATRESETINT pfnCallback, void *pvUser, const char *pszDesc)
1998{
1999 /*
2000 * Validate.
2001 */
2002 if (!pfnCallback)
2003 {
2004 AssertMsgFailed(("pfnCallback is NULL!\n"));
2005 return VERR_INVALID_PARAMETER;
2006 }
2007
2008 /*
2009 * Create the new entry.
2010 */
2011 PVMATRESET pNew;
2012 int rc = vmr3AtResetRegisterU(pVM->pUVM, pvUser, pszDesc, &pNew);
2013 if (VBOX_SUCCESS(rc))
2014 {
2015 /*
2016 * Fill in type data.
2017 */
2018 pNew->enmType = VMATRESETTYPE_INTERNAL;
2019 pNew->u.Internal.pfnCallback = pfnCallback;
2020 }
2021
2022 return rc;
2023}
2024
2025
2026/**
2027 * Registers an at VM reset external callback.
2028 *
2029 * @returns VBox status code.
2030 * @param pVM The VM.
2031 * @param pfnCallback Callback function.
2032 * @param pvUser User argument.
2033 * @param pszDesc Description (optional).
2034 */
2035VMR3DECL(int) VMR3AtResetRegisterExternal(PVM pVM, PFNVMATRESETEXT pfnCallback, void *pvUser, const char *pszDesc)
2036{
2037 /*
2038 * Validate.
2039 */
2040 if (!pfnCallback)
2041 {
2042 AssertMsgFailed(("pfnCallback is NULL!\n"));
2043 return VERR_INVALID_PARAMETER;
2044 }
2045
2046 /*
2047 * Create the new entry.
2048 */
2049 PVMATRESET pNew;
2050 int rc = vmr3AtResetRegisterU(pVM->pUVM, pvUser, pszDesc, &pNew);
2051 if (VBOX_SUCCESS(rc))
2052 {
2053 /*
2054 * Fill in type data.
2055 */
2056 pNew->enmType = VMATRESETTYPE_EXTERNAL;
2057 pNew->u.External.pfnCallback = pfnCallback;
2058 }
2059
2060 return rc;
2061}
2062
2063
2064/**
2065 * Unlinks and frees a callback.
2066 *
2067 * @returns Pointer to the next callback structure.
2068 * @param pUVM Pointer to the user mode VM structure.
2069 * @param pCur The one to free.
2070 * @param pPrev The one before pCur.
2071 */
2072static PVMATRESET vmr3AtResetFreeU(PUVM pUVM, PVMATRESET pCur, PVMATRESET pPrev)
2073{
2074 /*
2075 * Unlink it.
2076 */
2077 PVMATRESET pNext = pCur->pNext;
2078 if (pPrev)
2079 {
2080 pPrev->pNext = pNext;
2081 if (!pNext)
2082 pUVM->vm.s.ppAtResetNext = &pPrev->pNext;
2083 }
2084 else
2085 {
2086 pUVM->vm.s.pAtReset = pNext;
2087 if (!pNext)
2088 pUVM->vm.s.ppAtResetNext = &pUVM->vm.s.pAtReset;
2089 }
2090
2091 /*
2092 * Free it.
2093 */
2094 MMR3HeapFree(pCur);
2095
2096 return pNext;
2097}
2098
2099
2100/**
2101 * Deregisters an at VM reset callback.
2102 *
2103 * @returns VBox status code.
2104 * @param pVM The VM.
2105 * @param pDevInst Device instance.
2106 * @param pfnCallback Callback function.
2107 */
2108VMR3DECL(int) VMR3AtResetDeregister(PVM pVM, PPDMDEVINS pDevInst, PFNVMATRESET pfnCallback)
2109{
2110 int rc = VERR_VM_ATRESET_NOT_FOUND;
2111 PVMATRESET pPrev = NULL;
2112 PVMATRESET pCur = pVM->pUVM->vm.s.pAtReset;
2113 while (pCur)
2114 {
2115 if ( pCur->enmType == VMATRESETTYPE_DEV
2116 && pCur->u.Dev.pDevIns == pDevInst
2117 && (!pfnCallback || pCur->u.Dev.pfnCallback == pfnCallback))
2118 {
2119 pCur = vmr3AtResetFreeU(pVM->pUVM, pCur, pPrev);
2120 rc = VINF_SUCCESS;
2121 }
2122 else
2123 {
2124 pPrev = pCur;
2125 pCur = pCur->pNext;
2126 }
2127 }
2128
2129 AssertRC(rc);
2130 return rc;
2131}
2132
2133
2134/**
2135 * Deregisters an at VM reset internal callback.
2136 *
2137 * @returns VBox status code.
2138 * @param pVM The VM.
2139 * @param pfnCallback Callback function.
2140 */
2141VMR3DECL(int) VMR3AtResetDeregisterInternal(PVM pVM, PFNVMATRESETINT pfnCallback)
2142{
2143 int rc = VERR_VM_ATRESET_NOT_FOUND;
2144 PVMATRESET pPrev = NULL;
2145 PVMATRESET pCur = pVM->pUVM->vm.s.pAtReset;
2146 while (pCur)
2147 {
2148 if ( pCur->enmType == VMATRESETTYPE_INTERNAL
2149 && pCur->u.Internal.pfnCallback == pfnCallback)
2150 {
2151 pCur = vmr3AtResetFreeU(pVM->pUVM, pCur, pPrev);
2152 rc = VINF_SUCCESS;
2153 }
2154 else
2155 {
2156 pPrev = pCur;
2157 pCur = pCur->pNext;
2158 }
2159 }
2160
2161 AssertRC(rc);
2162 return rc;
2163}
2164
2165
2166/**
2167 * Deregisters an at VM reset external callback.
2168 *
2169 * @returns VBox status code.
2170 * @param pVM The VM.
2171 * @param pfnCallback Callback function.
2172 */
2173VMR3DECL(int) VMR3AtResetDeregisterExternal(PVM pVM, PFNVMATRESETEXT pfnCallback)
2174{
2175 int rc = VERR_VM_ATRESET_NOT_FOUND;
2176 PVMATRESET pPrev = NULL;
2177 PVMATRESET pCur = pVM->pUVM->vm.s.pAtReset;
2178 while (pCur)
2179 {
2180 if ( pCur->enmType == VMATRESETTYPE_INTERNAL
2181 && pCur->u.External.pfnCallback == pfnCallback)
2182 {
2183 pCur = vmr3AtResetFreeU(pVM->pUVM, pCur, pPrev);
2184 rc = VINF_SUCCESS;
2185 }
2186 else
2187 {
2188 pPrev = pCur;
2189 pCur = pCur->pNext;
2190 }
2191 }
2192
2193 AssertRC(rc);
2194 return rc;
2195}
2196
2197
2198/**
2199 * Gets the current VM state.
2200 *
2201 * @returns The current VM state.
2202 * @param pVM VM handle.
2203 * @thread Any
2204 */
2205VMR3DECL(VMSTATE) VMR3GetState(PVM pVM)
2206{
2207 return pVM->enmVMState;
2208}
2209
2210
2211/**
2212 * Gets the state name string for a VM state.
2213 *
2214 * @returns Pointer to the state name. (readonly)
2215 * @param enmState The state.
2216 */
2217VMR3DECL(const char *) VMR3GetStateName(VMSTATE enmState)
2218{
2219 switch (enmState)
2220 {
2221 case VMSTATE_CREATING: return "CREATING";
2222 case VMSTATE_CREATED: return "CREATED";
2223 case VMSTATE_RUNNING: return "RUNNING";
2224 case VMSTATE_LOADING: return "LOADING";
2225 case VMSTATE_LOAD_FAILURE: return "LOAD_FAILURE";
2226 case VMSTATE_SAVING: return "SAVING";
2227 case VMSTATE_SUSPENDED: return "SUSPENDED";
2228 case VMSTATE_RESETTING: return "RESETTING";
2229 case VMSTATE_GURU_MEDITATION: return "GURU_MEDIATION";
2230 case VMSTATE_OFF: return "OFF";
2231 case VMSTATE_DESTROYING: return "DESTROYING";
2232 case VMSTATE_TERMINATED: return "TERMINATED";
2233 default:
2234 AssertMsgFailed(("Unknown state %d\n", enmState));
2235 return "Unknown!\n";
2236 }
2237}
2238
2239
2240/**
2241 * Sets the current VM state.
2242 *
2243 * @returns The current VM state.
2244 * @param pVM VM handle.
2245 * @param enmStateNew The new state.
2246 */
2247void vmR3SetState(PVM pVM, VMSTATE enmStateNew)
2248{
2249 VMSTATE enmStateOld = pVM->enmVMState;
2250 pVM->enmVMState = enmStateNew;
2251 LogRel(("Changing the VM state from '%s' to '%s'.\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)));
2252
2253 /*
2254 * Call the at state change callbacks.
2255 */
2256 for (PVMATSTATE pCur = pVM->pUVM->vm.s.pAtState; pCur; pCur = pCur->pNext)
2257 {
2258 pCur->pfnAtState(pVM, enmStateNew, enmStateOld, pCur->pvUser);
2259 if (pVM->enmVMState == VMSTATE_DESTROYING)
2260 break;
2261 AssertMsg(pVM->enmVMState == enmStateNew,
2262 ("You are not allowed to change the state while in the change callback, except "
2263 "from destroying the VM. There are restrictions in the way the state changes "
2264 "are propagated up to the EM execution loop and it makes the program flow very "
2265 "difficult to follow.\n"));
2266 }
2267}
2268
2269
2270/**
2271 * Registers a VM state change callback.
2272 *
2273 * You are not allowed to call any function which changes the VM state from a
2274 * state callback, except VMR3Destroy().
2275 *
2276 * @returns VBox status code.
2277 * @param pVM VM handle.
2278 * @param pfnAtState Pointer to callback.
2279 * @param pvUser User argument.
2280 * @thread Any.
2281 */
2282VMR3DECL(int) VMR3AtStateRegister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2283{
2284 LogFlow(("VMR3AtStateRegister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2285
2286 /*
2287 * Validate input.
2288 */
2289 if (!pfnAtState)
2290 {
2291 AssertMsgFailed(("callback is required\n"));
2292 return VERR_INVALID_PARAMETER;
2293 }
2294
2295 /*
2296 * Make sure we're in EMT (to avoid the logging).
2297 */
2298 PVMREQ pReq;
2299 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateRegisterU, 3, pVM->pUVM, pfnAtState, pvUser);
2300 if (VBOX_FAILURE(rc))
2301 return rc;
2302 rc = pReq->iStatus;
2303 VMR3ReqFree(pReq);
2304
2305 LogFlow(("VMR3AtStateRegister: returns %Vrc\n", rc));
2306 return rc;
2307}
2308
2309
2310/**
2311 * Registers a VM state change callback.
2312 *
2313 * @returns VBox status code.
2314 * @param pUVM Pointer to the user mode VM structure.
2315 * @param pfnAtState Pointer to callback.
2316 * @param pvUser User argument.
2317 * @thread EMT
2318 */
2319static DECLCALLBACK(int) vmR3AtStateRegisterU(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser)
2320{
2321 /*
2322 * Allocate a new record.
2323 */
2324
2325 PVMATSTATE pNew = (PVMATSTATE)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
2326 if (!pNew)
2327 return VERR_NO_MEMORY;
2328
2329 /* fill */
2330 pNew->pfnAtState = pfnAtState;
2331 pNew->pvUser = pvUser;
2332 pNew->pNext = NULL;
2333
2334 /* insert */
2335 *pUVM->vm.s.ppAtStateNext = pNew;
2336 pUVM->vm.s.ppAtStateNext = &pNew->pNext;
2337
2338 return VINF_SUCCESS;
2339}
2340
2341
2342/**
2343 * Deregisters a VM state change callback.
2344 *
2345 * @returns VBox status code.
2346 * @param pVM VM handle.
2347 * @param pfnAtState Pointer to callback.
2348 * @param pvUser User argument.
2349 * @thread Any.
2350 */
2351VMR3DECL(int) VMR3AtStateDeregister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2352{
2353 LogFlow(("VMR3AtStateDeregister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2354
2355 /*
2356 * Validate input.
2357 */
2358 if (!pfnAtState)
2359 {
2360 AssertMsgFailed(("callback is required\n"));
2361 return VERR_INVALID_PARAMETER;
2362 }
2363
2364 /*
2365 * Make sure we're in EMT (to avoid the logging).
2366 */
2367 PVMREQ pReq;
2368 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateDeregisterU, 3, pVM->pUVM, pfnAtState, pvUser);
2369 if (VBOX_FAILURE(rc))
2370 return rc;
2371 rc = pReq->iStatus;
2372 VMR3ReqFree(pReq);
2373
2374 LogFlow(("VMR3AtStateDeregister: returns %Vrc\n", rc));
2375 return rc;
2376}
2377
2378
2379/**
2380 * Deregisters a VM state change callback.
2381 *
2382 * @returns VBox status code.
2383 * @param pUVM Pointer to the user mode VM structure.
2384 * @param pfnAtState Pointer to callback.
2385 * @param pvUser User argument.
2386 * @thread EMT
2387 */
2388static DECLCALLBACK(int) vmR3AtStateDeregisterU(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser)
2389{
2390 LogFlow(("vmR3AtStateDeregisterU: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2391
2392 /*
2393 * Search the list for the entry.
2394 */
2395 PVMATSTATE pPrev = NULL;
2396 PVMATSTATE pCur = pUVM->vm.s.pAtState;
2397 while ( pCur
2398 && pCur->pfnAtState == pfnAtState
2399 && pCur->pvUser == pvUser)
2400 {
2401 pPrev = pCur;
2402 pCur = pCur->pNext;
2403 }
2404 if (!pCur)
2405 {
2406 AssertMsgFailed(("pfnAtState=%p was not found\n", pfnAtState));
2407 return VERR_FILE_NOT_FOUND;
2408 }
2409
2410 /*
2411 * Unlink it.
2412 */
2413 if (pPrev)
2414 {
2415 pPrev->pNext = pCur->pNext;
2416 if (!pCur->pNext)
2417 pUVM->vm.s.ppAtStateNext = &pPrev->pNext;
2418 }
2419 else
2420 {
2421 pUVM->vm.s.pAtState = pCur->pNext;
2422 if (!pCur->pNext)
2423 pUVM->vm.s.ppAtStateNext = &pUVM->vm.s.pAtState;
2424 }
2425
2426 /*
2427 * Free it.
2428 */
2429 pCur->pfnAtState = NULL;
2430 pCur->pNext = NULL;
2431 MMR3HeapFree(pCur);
2432
2433 return VINF_SUCCESS;
2434}
2435
2436
2437/**
2438 * Registers a VM error callback.
2439 *
2440 * @returns VBox status code.
2441 * @param pVM The VM handle.
2442 * @param pfnAtError Pointer to callback.
2443 * @param pvUser User argument.
2444 * @thread Any.
2445 */
2446VMR3DECL(int) VMR3AtErrorRegister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2447{
2448 return VMR3AtErrorRegisterU(pVM->pUVM, pfnAtError, pvUser);
2449}
2450
2451
2452/**
2453 * Registers a VM error callback.
2454 *
2455 * @returns VBox status code.
2456 * @param pUVM The VM handle.
2457 * @param pfnAtError Pointer to callback.
2458 * @param pvUser User argument.
2459 * @thread Any.
2460 */
2461VMR3DECL(int) VMR3AtErrorRegisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
2462{
2463 LogFlow(("VMR3AtErrorRegister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2464 AssertPtrReturn(pfnAtError, VERR_INVALID_PARAMETER);
2465
2466 /*
2467 * Make sure we're in EMT (to avoid the logging).
2468 */
2469 PVMREQ pReq;
2470 int rc = VMR3ReqCallU(pUVM, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3AtErrorRegisterU, 3, pUVM, pfnAtError, pvUser);
2471 if (VBOX_FAILURE(rc))
2472 return rc;
2473 rc = pReq->iStatus;
2474 VMR3ReqFree(pReq);
2475
2476 LogFlow(("VMR3AtErrorRegister: returns %Vrc\n", rc));
2477 return rc;
2478}
2479
2480
2481/**
2482 * Registers a VM error callback.
2483 *
2484 * @returns VBox status code.
2485 * @param pUVM Pointer to the user mode VM structure.
2486 * @param pfnAtError Pointer to callback.
2487 * @param pvUser User argument.
2488 * @thread EMT
2489 */
2490static DECLCALLBACK(int) vmR3AtErrorRegisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
2491{
2492 /*
2493 * Allocate a new record.
2494 */
2495
2496 PVMATERROR pNew = (PVMATERROR)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
2497 if (!pNew)
2498 return VERR_NO_MEMORY;
2499
2500 /* fill */
2501 pNew->pfnAtError = pfnAtError;
2502 pNew->pvUser = pvUser;
2503 pNew->pNext = NULL;
2504
2505 /* insert */
2506 *pUVM->vm.s.ppAtErrorNext = pNew;
2507 pUVM->vm.s.ppAtErrorNext = &pNew->pNext;
2508
2509 return VINF_SUCCESS;
2510}
2511
2512
2513/**
2514 * Deregisters a VM error callback.
2515 *
2516 * @returns VBox status code.
2517 * @param pVM The VM handle.
2518 * @param pfnAtError Pointer to callback.
2519 * @param pvUser User argument.
2520 * @thread Any.
2521 */
2522VMR3DECL(int) VMR3AtErrorDeregister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2523{
2524 LogFlow(("VMR3AtErrorDeregister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2525
2526 /*
2527 * Validate input.
2528 */
2529 if (!pfnAtError)
2530 {
2531 AssertMsgFailed(("callback is required\n"));
2532 return VERR_INVALID_PARAMETER;
2533 }
2534
2535 /*
2536 * Make sure we're in EMT (to avoid the logging).
2537 */
2538 PVMREQ pReq;
2539 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtErrorDeregisterU, 3, pVM->pUVM, pfnAtError, pvUser);
2540 if (VBOX_FAILURE(rc))
2541 return rc;
2542 rc = pReq->iStatus;
2543 VMR3ReqFree(pReq);
2544
2545 LogFlow(("VMR3AtErrorDeregister: returns %Vrc\n", rc));
2546 return rc;
2547}
2548
2549
2550/**
2551 * Deregisters a VM error callback.
2552 *
2553 * @returns VBox status code.
2554 * @param pUVM Pointer to the user mode VM structure.
2555 * @param pfnAtError Pointer to callback.
2556 * @param pvUser User argument.
2557 * @thread EMT
2558 */
2559static DECLCALLBACK(int) vmR3AtErrorDeregisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
2560{
2561 LogFlow(("vmR3AtErrorDeregisterU: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2562
2563 /*
2564 * Search the list for the entry.
2565 */
2566 PVMATERROR pPrev = NULL;
2567 PVMATERROR pCur = pUVM->vm.s.pAtError;
2568 while ( pCur
2569 && pCur->pfnAtError == pfnAtError
2570 && pCur->pvUser == pvUser)
2571 {
2572 pPrev = pCur;
2573 pCur = pCur->pNext;
2574 }
2575 if (!pCur)
2576 {
2577 AssertMsgFailed(("pfnAtError=%p was not found\n", pfnAtError));
2578 return VERR_FILE_NOT_FOUND;
2579 }
2580
2581 /*
2582 * Unlink it.
2583 */
2584 if (pPrev)
2585 {
2586 pPrev->pNext = pCur->pNext;
2587 if (!pCur->pNext)
2588 pUVM->vm.s.ppAtErrorNext = &pPrev->pNext;
2589 }
2590 else
2591 {
2592 pUVM->vm.s.pAtError = pCur->pNext;
2593 if (!pCur->pNext)
2594 pUVM->vm.s.ppAtErrorNext = &pUVM->vm.s.pAtError;
2595 }
2596
2597 /*
2598 * Free it.
2599 */
2600 pCur->pfnAtError = NULL;
2601 pCur->pNext = NULL;
2602 MMR3HeapFree(pCur);
2603
2604 return VINF_SUCCESS;
2605}
2606
2607
2608/**
2609 * Ellipsis to va_list wrapper for calling pfnAtError.
2610 */
2611static void vmR3SetErrorWorkerDoCall(PVM pVM, PVMATERROR pCur, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2612{
2613 va_list va;
2614 va_start(va, pszFormat);
2615 pCur->pfnAtError(pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
2616 va_end(va);
2617}
2618
2619
2620/**
2621 * This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2622 * The message is found in VMINT.
2623 *
2624 * @param pVM The VM handle.
2625 * @thread EMT.
2626 */
2627VMR3DECL(void) VMR3SetErrorWorker(PVM pVM)
2628{
2629 VM_ASSERT_EMT(pVM);
2630 AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetErrorV! Contrats!\n"));
2631
2632 /*
2633 * Unpack the error (if we managed to format one).
2634 */
2635 PVMERROR pErr = pVM->vm.s.pErrorR3;
2636 const char *pszFile = NULL;
2637 const char *pszFunction = NULL;
2638 uint32_t iLine = 0;
2639 const char *pszMessage;
2640 int32_t rc = VERR_MM_HYPER_NO_MEMORY;
2641 if (pErr)
2642 {
2643 AssertCompile(sizeof(const char) == sizeof(uint8_t));
2644 if (pErr->offFile)
2645 pszFile = (const char *)pErr + pErr->offFile;
2646 iLine = pErr->iLine;
2647 if (pErr->offFunction)
2648 pszFunction = (const char *)pErr + pErr->offFunction;
2649 if (pErr->offMessage)
2650 pszMessage = (const char *)pErr + pErr->offMessage;
2651 else
2652 pszMessage = "No message!";
2653 }
2654 else
2655 pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2656
2657 /*
2658 * Call the at error callbacks.
2659 */
2660 for (PVMATERROR pCur = pVM->pUVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2661 vmR3SetErrorWorkerDoCall(pVM, pCur, rc, RT_SRC_POS_ARGS, "%s", pszMessage);
2662}
2663
2664
2665/**
2666 * Creation time wrapper for vmR3SetErrorUV.
2667 *
2668 * @returns rc.
2669 * @param pUVM Pointer to the user mode VM structure.
2670 * @param rc The VBox status code.
2671 * @param RT_SRC_POS_DECL The source position of this error.
2672 * @param pszFormat Format string.
2673 * @param ... The arguments.
2674 * @thread Any thread.
2675 */
2676static int vmR3SetErrorU(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2677{
2678 va_list va;
2679 va_start(va, pszFormat);
2680 vmR3SetErrorUV(pUVM, rc, pszFile, iLine, pszFunction, pszFormat, &va);
2681 va_end(va);
2682 return rc;
2683}
2684
2685
2686/**
2687 * Worker which calls everyone listening to the VM error messages.
2688 *
2689 * @param pUVM Pointer to the user mode VM structure.
2690 * @param rc The VBox status code.
2691 * @param RT_SRC_POS_DECL The source position of this error.
2692 * @param pszFormat Format string.
2693 * @param pArgs Pointer to the format arguments.
2694 * @thread EMT
2695 */
2696DECLCALLBACK(void) vmR3SetErrorUV(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list *pArgs)
2697{
2698#ifdef LOG_ENABLED
2699 /*
2700 * Log the error.
2701 */
2702 RTLogPrintf("VMSetError: %s(%d) %s\n", pszFile, iLine, pszFunction);
2703 va_list va3;
2704 va_copy(va3, *pArgs);
2705 RTLogPrintfV(pszFormat, va3);
2706 va_end(va3);
2707 RTLogPrintf("\n");
2708#endif
2709
2710 /*
2711 * Make a copy of the message.
2712 */
2713 if (pUVM->pVM)
2714 vmSetErrorCopy(pUVM->pVM, rc, RT_SRC_POS_ARGS, pszFormat, *pArgs);
2715
2716 /*
2717 * Call the at error callbacks.
2718 */
2719 for (PVMATERROR pCur = pUVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2720 {
2721 va_list va2;
2722 va_copy(va2, *pArgs);
2723 pCur->pfnAtError(pUVM->pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
2724 va_end(va2);
2725 }
2726}
2727
2728
2729/**
2730 * Registers a VM runtime error callback.
2731 *
2732 * @returns VBox status code.
2733 * @param pVM The VM handle.
2734 * @param pfnAtRuntimeError Pointer to callback.
2735 * @param pvUser User argument.
2736 * @thread Any.
2737 */
2738VMR3DECL(int) VMR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2739{
2740 LogFlow(("VMR3AtRuntimeErrorRegister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2741
2742 /*
2743 * Validate input.
2744 */
2745 if (!pfnAtRuntimeError)
2746 {
2747 AssertMsgFailed(("callback is required\n"));
2748 return VERR_INVALID_PARAMETER;
2749 }
2750
2751 /*
2752 * Make sure we're in EMT (to avoid the logging).
2753 */
2754 PVMREQ pReq;
2755 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorRegisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser);
2756 if (VBOX_FAILURE(rc))
2757 return rc;
2758 rc = pReq->iStatus;
2759 VMR3ReqFree(pReq);
2760
2761 LogFlow(("VMR3AtRuntimeErrorRegister: returns %Vrc\n", rc));
2762 return rc;
2763}
2764
2765
2766/**
2767 * Registers a VM runtime error callback.
2768 *
2769 * @returns VBox status code.
2770 * @param pUVM Pointer to the user mode VM structure.
2771 * @param pfnAtRuntimeError Pointer to callback.
2772 * @param pvUser User argument.
2773 * @thread EMT
2774 */
2775static DECLCALLBACK(int) vmR3AtRuntimeErrorRegisterU(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2776{
2777 /*
2778 * Allocate a new record.
2779 */
2780
2781 PVMATRUNTIMEERROR pNew = (PVMATRUNTIMEERROR)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
2782 if (!pNew)
2783 return VERR_NO_MEMORY;
2784
2785 /* fill */
2786 pNew->pfnAtRuntimeError = pfnAtRuntimeError;
2787 pNew->pvUser = pvUser;
2788 pNew->pNext = NULL;
2789
2790 /* insert */
2791 *pUVM->vm.s.ppAtRuntimeErrorNext = pNew;
2792 pUVM->vm.s.ppAtRuntimeErrorNext = &pNew->pNext;
2793
2794 return VINF_SUCCESS;
2795}
2796
2797
2798/**
2799 * Deregisters a VM runtime error callback.
2800 *
2801 * @returns VBox status code.
2802 * @param pVM The VM handle.
2803 * @param pfnAtRuntimeError Pointer to callback.
2804 * @param pvUser User argument.
2805 * @thread Any.
2806 */
2807VMR3DECL(int) VMR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2808{
2809 LogFlow(("VMR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2810
2811 /*
2812 * Validate input.
2813 */
2814 if (!pfnAtRuntimeError)
2815 {
2816 AssertMsgFailed(("callback is required\n"));
2817 return VERR_INVALID_PARAMETER;
2818 }
2819
2820 /*
2821 * Make sure we're in EMT (to avoid the logging).
2822 */
2823 PVMREQ pReq;
2824 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorDeregisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser);
2825 if (VBOX_FAILURE(rc))
2826 return rc;
2827 rc = pReq->iStatus;
2828 VMR3ReqFree(pReq);
2829
2830 LogFlow(("VMR3AtRuntimeErrorDeregister: returns %Vrc\n", rc));
2831 return rc;
2832}
2833
2834
2835/**
2836 * Deregisters a VM runtime error callback.
2837 *
2838 * @returns VBox status code.
2839 * @param pUVM Pointer to the user mode VM structure.
2840 * @param pfnAtRuntimeError Pointer to callback.
2841 * @param pvUser User argument.
2842 * @thread EMT
2843 */
2844static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregisterU(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2845{
2846 LogFlow(("vmR3AtRuntimeErrorDeregisterU: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2847
2848 /*
2849 * Search the list for the entry.
2850 */
2851 PVMATRUNTIMEERROR pPrev = NULL;
2852 PVMATRUNTIMEERROR pCur = pUVM->vm.s.pAtRuntimeError;
2853 while ( pCur
2854 && pCur->pfnAtRuntimeError == pfnAtRuntimeError
2855 && pCur->pvUser == pvUser)
2856 {
2857 pPrev = pCur;
2858 pCur = pCur->pNext;
2859 }
2860 if (!pCur)
2861 {
2862 AssertMsgFailed(("pfnAtRuntimeError=%p was not found\n", pfnAtRuntimeError));
2863 return VERR_FILE_NOT_FOUND;
2864 }
2865
2866 /*
2867 * Unlink it.
2868 */
2869 if (pPrev)
2870 {
2871 pPrev->pNext = pCur->pNext;
2872 if (!pCur->pNext)
2873 pUVM->vm.s.ppAtRuntimeErrorNext = &pPrev->pNext;
2874 }
2875 else
2876 {
2877 pUVM->vm.s.pAtRuntimeError = pCur->pNext;
2878 if (!pCur->pNext)
2879 pUVM->vm.s.ppAtRuntimeErrorNext = &pUVM->vm.s.pAtRuntimeError;
2880 }
2881
2882 /*
2883 * Free it.
2884 */
2885 pCur->pfnAtRuntimeError = NULL;
2886 pCur->pNext = NULL;
2887 MMR3HeapFree(pCur);
2888
2889 return VINF_SUCCESS;
2890}
2891
2892
2893/**
2894 * Ellipsis to va_list wrapper for calling pfnAtRuntimeError.
2895 */
2896static void vmR3SetRuntimeErrorWorkerDoCall(PVM pVM, PVMATRUNTIMEERROR pCur, bool fFatal,
2897 const char *pszErrorID,
2898 const char *pszFormat, ...)
2899{
2900 va_list va;
2901 va_start(va, pszFormat);
2902 pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va);
2903 va_end(va);
2904}
2905
2906
2907/**
2908 * This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2909 * The message is found in VMINT.
2910 *
2911 * @param pVM The VM handle.
2912 * @thread EMT.
2913 */
2914VMR3DECL(void) VMR3SetRuntimeErrorWorker(PVM pVM)
2915{
2916 VM_ASSERT_EMT(pVM);
2917 AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetRuntimeErrorV! Contrats!\n"));
2918
2919 /*
2920 * Unpack the error (if we managed to format one).
2921 */
2922 PVMRUNTIMEERROR pErr = pVM->vm.s.pRuntimeErrorR3;
2923 const char *pszErrorID = NULL;
2924 const char *pszMessage;
2925 bool fFatal = false;
2926 if (pErr)
2927 {
2928 AssertCompile(sizeof(const char) == sizeof(uint8_t));
2929 if (pErr->offErrorID)
2930 pszErrorID = (const char *)pErr + pErr->offErrorID;
2931 if (pErr->offMessage)
2932 pszMessage = (const char *)pErr + pErr->offMessage;
2933 else
2934 pszMessage = "No message!";
2935 fFatal = pErr->fFatal;
2936 }
2937 else
2938 pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2939
2940 /*
2941 * Call the at runtime error callbacks.
2942 */
2943 for (PVMATRUNTIMEERROR pCur = pVM->pUVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2944 vmR3SetRuntimeErrorWorkerDoCall(pVM, pCur, fFatal, pszErrorID, "%s", pszMessage);
2945}
2946
2947
2948/**
2949 * Worker which calls everyone listening to the VM runtime error messages.
2950 *
2951 * @param pVM The VM handle.
2952 * @param fFatal Whether it is a fatal error or not.
2953 * @param pszErrorID Error ID string.
2954 * @param pszFormat Format string.
2955 * @param pArgs Pointer to the format arguments.
2956 * @thread EMT
2957 */
2958DECLCALLBACK(void) vmR3SetRuntimeErrorV(PVM pVM, bool fFatal,
2959 const char *pszErrorID,
2960 const char *pszFormat, va_list *pArgs)
2961{
2962 /*
2963 * Make a copy of the message.
2964 */
2965 vmSetRuntimeErrorCopy(pVM, fFatal, pszErrorID, pszFormat, *pArgs);
2966
2967 /*
2968 * Call the at error callbacks.
2969 */
2970 for (PVMATRUNTIMEERROR pCur = pVM->pUVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2971 {
2972 va_list va2;
2973 va_copy(va2, *pArgs);
2974 pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va2);
2975 va_end(va2);
2976 }
2977}
2978
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