VirtualBox

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

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

Fixed two bugs in the VMR3Create failure path introduced in the big changeset.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 88.0 KB
Line 
1/* $Id: VM.cpp 6799 2008-02-04 19:18:10Z 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 LogFlow(("vmR3InitRing0: returns %Vrc\n", rc));
697 return rc;
698}
699
700
701/**
702 * Initializes all GC components of the VM
703 */
704static int vmR3InitGC(PVM pVM)
705{
706 LogFlow(("vmR3InitGC:\n"));
707
708 /*
709 * Check for FAKE suplib mode.
710 */
711 int rc = VINF_SUCCESS;
712 const char *psz = RTEnvGet("VBOX_SUPLIB_FAKE");
713 if (!psz || strcmp(psz, "fake"))
714 {
715 /*
716 * Call the VMMR0 component and let it do the init.
717 */
718 rc = VMMR3InitGC(pVM);
719 }
720 else
721 Log(("vmR3InitGC: skipping because of VBOX_SUPLIB_FAKE=fake\n"));
722
723 /*
724 * Do notifications and return.
725 */
726 if (VBOX_SUCCESS(rc))
727 rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_GC);
728 LogFlow(("vmR3InitGC: returns %Vrc\n", rc));
729 return rc;
730}
731
732
733/**
734 * Do init completed notifications.
735 * This notifications can fail.
736 *
737 * @param pVM The VM handle.
738 * @param enmWhat What's completed.
739 */
740static int vmR3InitDoCompleted(PVM pVM, VMINITCOMPLETED enmWhat)
741{
742
743 return VINF_SUCCESS;
744}
745
746
747/**
748 * Calls the relocation functions for all VMM components so they can update
749 * any GC pointers. When this function is called all the basic VM members
750 * have been updated and the actual memory relocation have been done
751 * by the PGM/MM.
752 *
753 * This is used both on init and on runtime relocations.
754 *
755 * @param pVM VM handle.
756 * @param offDelta Relocation delta relative to old location.
757 */
758VMR3DECL(void) VMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
759{
760 LogFlow(("VMR3Relocate: offDelta=%VGv\n", offDelta));
761
762 /*
763 * The order here is very important!
764 */
765 PGMR3Relocate(pVM, offDelta);
766 PDMR3LdrRelocateU(pVM->pUVM, offDelta);
767 PGMR3Relocate(pVM, 0); /* Repeat after PDM relocation. */
768 CPUMR3Relocate(pVM);
769 HWACCMR3Relocate(pVM);
770 SELMR3Relocate(pVM);
771 VMMR3Relocate(pVM, offDelta);
772 SELMR3Relocate(pVM); /* !hack! fix stack! */
773 TRPMR3Relocate(pVM, offDelta);
774 PATMR3Relocate(pVM);
775 CSAMR3Relocate(pVM, offDelta);
776 IOMR3Relocate(pVM, offDelta);
777 EMR3Relocate(pVM);
778 TMR3Relocate(pVM, offDelta);
779 DBGFR3Relocate(pVM, offDelta);
780 PDMR3Relocate(pVM, offDelta);
781}
782
783
784
785/**
786 * Power on the virtual machine.
787 *
788 * @returns 0 on success.
789 * @returns VBox error code on failure.
790 * @param pVM VM to power on.
791 * @thread Any thread.
792 * @vmstate Created
793 * @vmstateto Running
794 */
795VMR3DECL(int) VMR3PowerOn(PVM pVM)
796{
797 LogFlow(("VMR3PowerOn: pVM=%p\n", pVM));
798
799 /*
800 * Validate input.
801 */
802 if (!pVM)
803 {
804 AssertMsgFailed(("Invalid VM pointer\n"));
805 return VERR_INVALID_PARAMETER;
806 }
807
808 /*
809 * Request the operation in EMT.
810 */
811 PVMREQ pReq;
812 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOn, 1, pVM);
813 if (VBOX_SUCCESS(rc))
814 {
815 rc = pReq->iStatus;
816 VMR3ReqFree(pReq);
817 }
818
819 LogFlow(("VMR3PowerOn: returns %Vrc\n", rc));
820 return rc;
821}
822
823
824/**
825 * Power on the virtual machine.
826 *
827 * @returns 0 on success.
828 * @returns VBox error code on failure.
829 * @param pVM VM to power on.
830 * @thread EMT
831 */
832static DECLCALLBACK(int) vmR3PowerOn(PVM pVM)
833{
834 LogFlow(("vmR3PowerOn: pVM=%p\n", pVM));
835
836 /*
837 * Validate input.
838 */
839 if (pVM->enmVMState != VMSTATE_CREATED)
840 {
841 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
842 return VERR_VM_INVALID_VM_STATE;
843 }
844
845 /*
846 * Change the state, notify the components and resume the execution.
847 */
848 vmR3SetState(pVM, VMSTATE_RUNNING);
849 PDMR3PowerOn(pVM);
850
851 return VINF_SUCCESS;
852}
853
854
855/**
856 * Suspends a running VM.
857 *
858 * @returns 0 on success.
859 * @returns VBox error code on failure.
860 * @param pVM VM to suspend.
861 * @thread Any thread.
862 * @vmstate Running
863 * @vmstateto Suspended
864 */
865VMR3DECL(int) VMR3Suspend(PVM pVM)
866{
867 LogFlow(("VMR3Suspend: pVM=%p\n", pVM));
868
869 /*
870 * Validate input.
871 */
872 if (!pVM)
873 {
874 AssertMsgFailed(("Invalid VM pointer\n"));
875 return VERR_INVALID_PARAMETER;
876 }
877
878 /*
879 * Request the operation in EMT.
880 */
881 PVMREQ pReq;
882 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Suspend, 1, pVM);
883 if (VBOX_SUCCESS(rc))
884 {
885 rc = pReq->iStatus;
886 VMR3ReqFree(pReq);
887 }
888
889 LogFlow(("VMR3Suspend: returns %Vrc\n", rc));
890 return rc;
891}
892
893
894/**
895 * Suspends a running VM and prevent state saving until the VM is resumed or stopped.
896 *
897 * @returns 0 on success.
898 * @returns VBox error code on failure.
899 * @param pVM VM to suspend.
900 * @thread Any thread.
901 * @vmstate Running
902 * @vmstateto Suspended
903 */
904VMR3DECL(int) VMR3SuspendNoSave(PVM pVM)
905{
906 pVM->vm.s.fPreventSaveState = true;
907 return VMR3Suspend(pVM);
908}
909
910
911/**
912 * Suspends a running VM.
913 *
914 * @returns 0 on success.
915 * @returns VBox error code on failure.
916 * @param pVM VM to suspend.
917 * @thread EMT
918 */
919static DECLCALLBACK(int) vmR3Suspend(PVM pVM)
920{
921 LogFlow(("vmR3Suspend: pVM=%p\n", pVM));
922
923 /*
924 * Validate input.
925 */
926 if (pVM->enmVMState != VMSTATE_RUNNING)
927 {
928 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
929 return VERR_VM_INVALID_VM_STATE;
930 }
931
932 /*
933 * Change the state, notify the components and resume the execution.
934 */
935 vmR3SetState(pVM, VMSTATE_SUSPENDED);
936 PDMR3Suspend(pVM);
937
938 return VINF_EM_SUSPEND;
939}
940
941
942/**
943 * Resume VM execution.
944 *
945 * @returns 0 on success.
946 * @returns VBox error code on failure.
947 * @param pVM The VM to resume.
948 * @thread Any thread.
949 * @vmstate Suspended
950 * @vmstateto Running
951 */
952VMR3DECL(int) VMR3Resume(PVM pVM)
953{
954 LogFlow(("VMR3Resume: pVM=%p\n", pVM));
955
956 /*
957 * Validate input.
958 */
959 if (!pVM)
960 {
961 AssertMsgFailed(("Invalid VM pointer\n"));
962 return VERR_INVALID_PARAMETER;
963 }
964
965 /*
966 * Request the operation in EMT.
967 */
968 PVMREQ pReq;
969 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Resume, 1, pVM);
970 if (VBOX_SUCCESS(rc))
971 {
972 rc = pReq->iStatus;
973 VMR3ReqFree(pReq);
974 }
975
976 LogFlow(("VMR3Resume: returns %Vrc\n", rc));
977 return rc;
978}
979
980
981/**
982 * Resume VM execution.
983 *
984 * @returns 0 on success.
985 * @returns VBox error code on failure.
986 * @param pVM The VM to resume.
987 * @thread EMT
988 */
989static DECLCALLBACK(int) vmR3Resume(PVM pVM)
990{
991 LogFlow(("vmR3Resume: pVM=%p\n", pVM));
992
993 /*
994 * Validate input.
995 */
996 if (pVM->enmVMState != VMSTATE_SUSPENDED)
997 {
998 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
999 return VERR_VM_INVALID_VM_STATE;
1000 }
1001
1002 /*
1003 * Change the state, notify the components and resume the execution.
1004 */
1005 pVM->vm.s.fPreventSaveState = false;
1006 vmR3SetState(pVM, VMSTATE_RUNNING);
1007 PDMR3Resume(pVM);
1008
1009 return VINF_EM_RESUME;
1010}
1011
1012
1013/**
1014 * Save current VM state.
1015 *
1016 * To save and terminate the VM, the VM must be suspended before the call.
1017 *
1018 * @returns 0 on success.
1019 * @returns VBox error code on failure.
1020 * @param pVM VM which state should be saved.
1021 * @param pszFilename Name of the save state file.
1022 * @param pfnProgress Progress callback. Optional.
1023 * @param pvUser User argument for the progress callback.
1024 * @thread Any thread.
1025 * @vmstate Suspended
1026 * @vmstateto Unchanged state.
1027 */
1028VMR3DECL(int) VMR3Save(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1029{
1030 LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1031
1032 /*
1033 * Validate input.
1034 */
1035 if (!pVM)
1036 {
1037 AssertMsgFailed(("Invalid VM pointer\n"));
1038 return VERR_INVALID_PARAMETER;
1039 }
1040 if (!pszFilename)
1041 {
1042 AssertMsgFailed(("Must specify a filename to save the state to, wise guy!\n"));
1043 return VERR_INVALID_PARAMETER;
1044 }
1045
1046 /*
1047 * Request the operation in EMT.
1048 */
1049 PVMREQ pReq;
1050 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Save, 4, pVM, pszFilename, pfnProgress, pvUser);
1051 if (VBOX_SUCCESS(rc))
1052 {
1053 rc = pReq->iStatus;
1054 VMR3ReqFree(pReq);
1055 }
1056
1057 LogFlow(("VMR3Save: returns %Vrc\n", rc));
1058 return rc;
1059}
1060
1061
1062/**
1063 * Save current VM state.
1064 *
1065 * To save and terminate the VM, the VM must be suspended before the call.
1066 *
1067 * @returns 0 on success.
1068 * @returns VBox error code on failure.
1069 * @param pVM VM which state should be saved.
1070 * @param pszFilename Name of the save state file.
1071 * @param pfnProgress Progress callback. Optional.
1072 * @param pvUser User argument for the progress callback.
1073 * @thread EMT
1074 */
1075static DECLCALLBACK(int) vmR3Save(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1076{
1077 LogFlow(("vmR3Save: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1078
1079 /*
1080 * Validate input.
1081 */
1082 if (pVM->enmVMState != VMSTATE_SUSPENDED)
1083 {
1084 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1085 return VERR_VM_INVALID_VM_STATE;
1086 }
1087
1088 /* If we are in an inconsistent state, then we don't allow state saving. */
1089 if (pVM->vm.s.fPreventSaveState)
1090 {
1091 LogRel(("VMM: vmR3Save: saving the VM state is not allowed at this moment\n"));
1092 return VERR_VM_SAVE_STATE_NOT_ALLOWED;
1093 }
1094
1095 /*
1096 * Change the state and perform the save.
1097 */
1098 /** @todo implement progress support in SSM */
1099 vmR3SetState(pVM, VMSTATE_SAVING);
1100 int rc = SSMR3Save(pVM, pszFilename, SSMAFTER_CONTINUE, pfnProgress, pvUser);
1101 vmR3SetState(pVM, VMSTATE_SUSPENDED);
1102
1103 return rc;
1104}
1105
1106
1107/**
1108 * Loads a new VM state.
1109 *
1110 * To restore a saved state on VM startup, call this function and then
1111 * resume the VM instead of powering it on.
1112 *
1113 * @returns 0 on success.
1114 * @returns VBox error code on failure.
1115 * @param pVM VM which state should be saved.
1116 * @param pszFilename Name of the save state file.
1117 * @param pfnProgress Progress callback. Optional.
1118 * @param pvUser User argument for the progress callback.
1119 * @thread Any thread.
1120 * @vmstate Created, Suspended
1121 * @vmstateto Suspended
1122 */
1123VMR3DECL(int) VMR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1124{
1125 LogFlow(("VMR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1126
1127 /*
1128 * Validate input.
1129 */
1130 if (!pVM)
1131 {
1132 AssertMsgFailed(("Invalid VM pointer\n"));
1133 return VERR_INVALID_PARAMETER;
1134 }
1135 if (!pszFilename)
1136 {
1137 AssertMsgFailed(("Must specify a filename to load the state from, wise guy!\n"));
1138 return VERR_INVALID_PARAMETER;
1139 }
1140
1141 /*
1142 * Request the operation in EMT.
1143 */
1144 PVMREQ pReq;
1145 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
1146 if (VBOX_SUCCESS(rc))
1147 {
1148 rc = pReq->iStatus;
1149 VMR3ReqFree(pReq);
1150 }
1151
1152 LogFlow(("VMR3Load: returns %Vrc\n", rc));
1153 return rc;
1154}
1155
1156
1157/**
1158 * Loads a new VM state.
1159 *
1160 * To restore a saved state on VM startup, call this function and then
1161 * resume the VM instead of powering it on.
1162 *
1163 * @returns 0 on success.
1164 * @returns VBox error code on failure.
1165 * @param pVM VM which state should be saved.
1166 * @param pszFilename Name of the save state file.
1167 * @param pfnProgress Progress callback. Optional.
1168 * @param pvUser User argument for the progress callback.
1169 * @thread EMT.
1170 */
1171static DECLCALLBACK(int) vmR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
1172{
1173 LogFlow(("vmR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
1174
1175 /*
1176 * Validate input.
1177 */
1178 if ( pVM->enmVMState != VMSTATE_SUSPENDED
1179 && pVM->enmVMState != VMSTATE_CREATED)
1180 {
1181 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1182 return VMSetError(pVM, VERR_VM_INVALID_VM_STATE, RT_SRC_POS, N_("Invalid VM state (%s) for restoring state from '%s'"),
1183 VMR3GetStateName(pVM->enmVMState), pszFilename);
1184 }
1185
1186 /*
1187 * Change the state and perform the load.
1188 */
1189 vmR3SetState(pVM, VMSTATE_LOADING);
1190 int rc = SSMR3Load(pVM, pszFilename, SSMAFTER_RESUME, pfnProgress, pvUser);
1191 if (VBOX_SUCCESS(rc))
1192 {
1193 /* Not paranoia anymore; the saved guest might use different hypervisor selectors. We must call VMR3Relocate. */
1194 VMR3Relocate(pVM, 0);
1195 vmR3SetState(pVM, VMSTATE_SUSPENDED);
1196 }
1197 else
1198 {
1199 vmR3SetState(pVM, VMSTATE_LOAD_FAILURE);
1200 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);
1201 }
1202
1203 return rc;
1204}
1205
1206
1207/**
1208 * Power Off the VM.
1209 *
1210 * @returns 0 on success.
1211 * @returns VBox error code on failure.
1212 * @param pVM VM which should be destroyed.
1213 * @thread Any thread.
1214 * @vmstate Suspended, Running, Guru Mediation, Load Failure
1215 * @vmstateto Off
1216 */
1217VMR3DECL(int) VMR3PowerOff(PVM pVM)
1218{
1219 LogFlow(("VMR3PowerOff: pVM=%p\n", pVM));
1220
1221 /*
1222 * Validate input.
1223 */
1224 if (!pVM)
1225 {
1226 AssertMsgFailed(("Invalid VM pointer\n"));
1227 return VERR_INVALID_PARAMETER;
1228 }
1229
1230 /*
1231 * Request the operation in EMT.
1232 */
1233 PVMREQ pReq;
1234 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3PowerOff, 1, pVM);
1235 if (VBOX_SUCCESS(rc))
1236 {
1237 rc = pReq->iStatus;
1238 VMR3ReqFree(pReq);
1239 }
1240
1241 LogFlow(("VMR3PowerOff: returns %Vrc\n", rc));
1242 return rc;
1243}
1244
1245
1246/**
1247 * Power Off the VM.
1248 *
1249 * @returns 0 on success.
1250 * @returns VBox error code on failure.
1251 * @param pVM VM which should be destroyed.
1252 * @thread EMT.
1253 */
1254static DECLCALLBACK(int) vmR3PowerOff(PVM pVM)
1255{
1256 LogFlow(("vmR3PowerOff: pVM=%p\n", pVM));
1257
1258 /*
1259 * Validate input.
1260 */
1261 if ( pVM->enmVMState != VMSTATE_RUNNING
1262 && pVM->enmVMState != VMSTATE_SUSPENDED
1263 && pVM->enmVMState != VMSTATE_LOAD_FAILURE
1264 && pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1265 {
1266 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1267 return VERR_VM_INVALID_VM_STATE;
1268 }
1269
1270 /*
1271 * For debugging purposes, we will log a summary of the guest state at this point.
1272 */
1273 if (pVM->enmVMState != VMSTATE_GURU_MEDITATION)
1274 {
1275 /** @todo make the state dumping at VMR3PowerOff optional. */
1276 RTLogRelPrintf("****************** Guest state at power off ******************\n");
1277 DBGFR3Info(pVM, "cpumguest", "verbose", DBGFR3InfoLogRelHlp());
1278 RTLogRelPrintf("***\n");
1279 DBGFR3Info(pVM, "mode", NULL, DBGFR3InfoLogRelHlp());
1280 RTLogRelPrintf("***\n");
1281 DBGFR3Info(pVM, "activetimers", NULL, DBGFR3InfoLogRelHlp());
1282 RTLogRelPrintf("***\n");
1283 DBGFR3Info(pVM, "gdt", NULL, DBGFR3InfoLogRelHlp());
1284 /** @todo dump guest call stack. */
1285#if 1 // temporary while debugging #1589
1286 RTLogRelPrintf("***\n");
1287 uint32_t esp = CPUMGetGuestESP(pVM);
1288 if ( CPUMGetGuestSS(pVM) == 0
1289 && esp < _64K)
1290 {
1291 uint8_t abBuf[PAGE_SIZE];
1292 RTLogRelPrintf("***\n"
1293 "ss:sp=0000:%04x ", esp);
1294 uint32_t Start = esp & ~(uint32_t)63;
1295 int rc = PGMPhysReadGCPhys(pVM, abBuf, Start, 0x100);
1296 if (VBOX_SUCCESS(rc))
1297 RTLogRelPrintf("0000:%04x TO 0000:%04x:\n"
1298 "%.*Rhxd\n",
1299 Start, Start + 0x100 - 1,
1300 0x100, abBuf);
1301 else
1302 RTLogRelPrintf("rc=%Vrc\n", rc);
1303
1304 /* grub ... */
1305 if (esp < 0x2000 && esp > 0x1fc0)
1306 {
1307 rc = PGMPhysReadGCPhys(pVM, abBuf, 0x8000, 0x800);
1308 if (VBOX_SUCCESS(rc))
1309 RTLogRelPrintf("0000:8000 TO 0000:87ff:\n"
1310 "%.*Rhxd\n",
1311 0x800, abBuf);
1312 }
1313 /* microsoft cdrom hang ... */
1314 if (true)
1315 {
1316 rc = PGMPhysReadGCPhys(pVM, abBuf, 0x8000, 0x200);
1317 if (VBOX_SUCCESS(rc))
1318 RTLogRelPrintf("2000:0000 TO 2000:01ff:\n"
1319 "%.*Rhxd\n",
1320 0x200, abBuf);
1321 }
1322 }
1323#endif
1324 RTLogRelPrintf("************** End of Guest state at power off ***************\n");
1325 }
1326
1327 /*
1328 * Change the state to OFF and notify the components.
1329 */
1330 vmR3SetState(pVM, VMSTATE_OFF);
1331 PDMR3PowerOff(pVM);
1332
1333 return VINF_EM_OFF;
1334}
1335
1336
1337/**
1338 * Destroys the VM.
1339 * The VM must be powered off (or never really powered on) to call this function.
1340 * The VM handle is destroyed and can no longer be used up successful return.
1341 *
1342 * @returns VBox status code.
1343 * @param pVM VM which should be destroyed.
1344 * @thread Any thread but the emulation thread.
1345 * @vmstate Off, Created
1346 * @vmstateto N/A
1347 */
1348VMR3DECL(int) VMR3Destroy(PVM pVM)
1349{
1350 LogFlow(("VMR3Destroy: pVM=%p\n", pVM));
1351
1352 /*
1353 * Validate input.
1354 */
1355 if (!pVM)
1356 return VERR_INVALID_PARAMETER;
1357 AssertPtrReturn(pVM, VERR_INVALID_POINTER);
1358 AssertMsgReturn( pVM->enmVMState == VMSTATE_OFF
1359 || pVM->enmVMState == VMSTATE_CREATED,
1360 ("Invalid VM state %d\n", pVM->enmVMState),
1361 VERR_VM_INVALID_VM_STATE);
1362
1363 /*
1364 * Change VM state to destroying and unlink the VM.
1365 */
1366 vmR3SetState(pVM, VMSTATE_DESTROYING);
1367
1368 /** @todo lock this when we start having multiple machines in a process... */
1369 PUVM pUVM = pVM->pUVM; AssertPtr(pUVM);
1370 if (g_pUVMsHead == pUVM)
1371 g_pUVMsHead = pUVM->pNext;
1372 else
1373 {
1374 PUVM pPrev = g_pUVMsHead;
1375 while (pPrev && pPrev->pNext != pUVM)
1376 pPrev = pPrev->pNext;
1377 AssertMsgReturn(pPrev, ("pUVM=%p / pVM=%p is INVALID!\n", pUVM, pVM), VERR_INVALID_PARAMETER);
1378
1379 pPrev->pNext = pUVM->pNext;
1380 }
1381 pUVM->pNext = NULL;
1382
1383 /*
1384 * Notify registered at destruction listeners.
1385 * (That's the debugger console.)
1386 */
1387 vmR3AtDtor(pVM);
1388
1389 /*
1390 * If we are the EMT we'll delay the cleanup till later.
1391 */
1392 if (VM_IS_EMT(pVM))
1393 {
1394 pUVM->vm.s.fEMTDoesTheCleanup = true;
1395 pUVM->vm.s.fTerminateEMT = true;
1396 VM_FF_SET(pVM, VM_FF_TERMINATE);
1397 }
1398 else
1399 {
1400 /*
1401 * Request EMT to do the larger part of the destruction.
1402 */
1403 PVMREQ pReq = NULL;
1404 int rc = VMR3ReqCallU(pUVM, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3Destroy, 1, pVM);
1405 if (RT_SUCCESS(rc))
1406 rc = pReq->iStatus;
1407 AssertRC(rc);
1408 VMR3ReqFree(pReq);
1409
1410 /*
1411 * Wait for the EMT thread to terminate.
1412 */
1413 Assert(pUVM->vm.s.fTerminateEMT);
1414 rc = RTThreadWait(pUVM->vm.s.ThreadEMT, 30000, NULL);
1415 AssertMsgRC(rc, ("EMT thread wait failed, rc=%Rrc\n", rc));
1416
1417 /*
1418 * Now do the final bit where the heap and VM structures are freed up.
1419 */
1420 vmR3DestroyUVM(pUVM);
1421 }
1422
1423 LogFlow(("VMR3Destroy: returns VINF_SUCCESS\n"));
1424 return VINF_SUCCESS;
1425}
1426
1427
1428/**
1429 * Internal destruction worker.
1430 *
1431 * This will do nearly all of the job, including sacking the EMT.
1432 *
1433 * @returns VBox status.
1434 * @param pVM VM handle.
1435 */
1436DECLCALLBACK(int) vmR3Destroy(PVM pVM)
1437{
1438 PUVM pUVM = pVM->pUVM;
1439 LogFlow(("vmR3Destroy: pVM=%p pUVM=%p\n", pVM, pUVM));
1440 VM_ASSERT_EMT(pVM);
1441
1442 /*
1443 * Dump statistics to the log.
1444 */
1445#if defined(VBOX_WITH_STATISTICS) || defined(LOG_ENABLED)
1446 RTLogFlags(NULL, "nodisabled nobuffered");
1447#endif
1448#ifdef VBOX_WITH_STATISTICS
1449# ifndef DEBUG_dmik
1450 STAMR3Dump(pVM, "*");
1451# endif
1452#else
1453 LogRel(("************************* Statistics *************************\n"));
1454 STAMR3DumpToReleaseLog(pVM, "*");
1455 LogRel(("********************* End of statistics **********************\n"));
1456#endif
1457
1458 /*
1459 * Destroy the VM components.
1460 */
1461 int rc = TMR3Term(pVM);
1462 AssertRC(rc);
1463#ifdef VBOX_WITH_DEBUGGER
1464 rc = DBGCTcpTerminate(pVM, pUVM->vm.s.pvDBGC);
1465 pVM->pUVM->vm.s.pvDBGC = NULL;
1466#endif
1467 AssertRC(rc);
1468 rc = DBGFR3Term(pVM);
1469 AssertRC(rc);
1470 rc = PDMR3Term(pVM);
1471 AssertRC(rc);
1472 rc = EMR3Term(pVM);
1473 AssertRC(rc);
1474 rc = IOMR3Term(pVM);
1475 AssertRC(rc);
1476 rc = CSAMR3Term(pVM);
1477 AssertRC(rc);
1478 rc = PATMR3Term(pVM);
1479 AssertRC(rc);
1480 rc = TRPMR3Term(pVM);
1481 AssertRC(rc);
1482 rc = SELMR3Term(pVM);
1483 AssertRC(rc);
1484 rc = REMR3Term(pVM);
1485 AssertRC(rc);
1486 rc = HWACCMR3Term(pVM);
1487 AssertRC(rc);
1488 rc = PGMR3Term(pVM);
1489 AssertRC(rc);
1490 rc = VMMR3Term(pVM); /* Terminates the ring-0 code! */
1491 AssertRC(rc);
1492 rc = CPUMR3Term(pVM);
1493 AssertRC(rc);
1494 rc = PDMR3CritSectTerm(pVM);
1495 AssertRC(rc);
1496 rc = MMR3Term(pVM);
1497 AssertRC(rc);
1498
1499 /*
1500 * We're done in this thread (EMT).
1501 */
1502 ASMAtomicUoWriteBool(&pVM->pUVM->vm.s.fTerminateEMT, true);
1503 ASMAtomicWriteU32(&pVM->fForcedActions, VM_FF_TERMINATE);
1504 LogFlow(("vmR3Destroy: returning %Vrc\n", VINF_EM_TERMINATE));
1505 return VINF_EM_TERMINATE;
1506}
1507
1508
1509/**
1510 * Destroys the shared VM structure, leaving only UVM behind.
1511 *
1512 * This is called by EMT right before terminating.
1513 *
1514 * @param pUVM The UVM handle.
1515 */
1516void vmR3DestroyFinalBitFromEMT(PUVM pUVM)
1517{
1518 if (pUVM->pVM)
1519 {
1520 /*
1521 * Modify state and then terminate MM.
1522 * (MM must be delayed until this point so we don't destroy the callbacks and the request packet.)
1523 */
1524 vmR3SetState(pUVM->pVM, VMSTATE_TERMINATED);
1525
1526 /*
1527 * Tell GVMM to destroy the VM and free its resources.
1528 */
1529 int rc = SUPCallVMMR0Ex(pUVM->pVM->pVMR0, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
1530 AssertRC(rc);
1531 pUVM->pVM = NULL;
1532 }
1533
1534 /*
1535 * Did EMT call VMR3Destroy and have to do it all?
1536 */
1537 if (pUVM->vm.s.fEMTDoesTheCleanup)
1538 vmR3DestroyUVM(pUVM);
1539}
1540
1541
1542/**
1543 * Destroys the UVM portion.
1544 *
1545 * This is called as the final step in the VM destruction or as the cleanup
1546 * in case of a creation failure. If EMT called VMR3Destroy, meaning
1547 * VMINTUSERPERVM::fEMTDoesTheCleanup is true, it will call this as
1548 * vmR3DestroyFinalBitFromEMT completes.
1549 *
1550 * @param pVM VM Handle.
1551 */
1552static void vmR3DestroyUVM(PUVM pUVM)
1553{
1554 /*
1555 * Terminate the EMT if still running (creation failure only).
1556 */
1557 if (!pUVM->vm.s.fTerminateEMT)
1558 {
1559 ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
1560 if (pUVM->pVM)
1561 {
1562 VM_FF_SET(pUVM->pVM, VM_FF_TERMINATE);
1563 VMR3NotifyFF(pUVM->pVM, false);
1564 }
1565 RTSemEventSignal(pUVM->vm.s.EventSemWait);
1566
1567 int rc2 = RTThreadWait(pUVM->vm.s.ThreadEMT, 2000, NULL);
1568 AssertRC(rc2);
1569 }
1570 RTSemEventDestroy(pUVM->vm.s.EventSemWait);
1571 pUVM->vm.s.EventSemWait = NIL_RTSEMEVENT;
1572
1573 /*
1574 * Free the event semaphores associated with the request packets.
1575 */
1576 unsigned cReqs = 0;
1577 for (unsigned i = 0; i < RT_ELEMENTS(pUVM->vm.s.apReqFree); i++)
1578 {
1579 PVMREQ pReq = pUVM->vm.s.apReqFree[i];
1580 pUVM->vm.s.apReqFree[i] = NULL;
1581 for (; pReq; pReq = pReq->pNext, cReqs++)
1582 {
1583 pReq->enmState = VMREQSTATE_INVALID;
1584 RTSemEventDestroy(pReq->EventSem);
1585 }
1586 }
1587 Assert(cReqs == pUVM->vm.s.cReqFree); NOREF(cReqs);
1588
1589 /*
1590 * Kill all queued requests. (There really shouldn't be any!)
1591 */
1592 for (unsigned i = 0; i < 10; i++)
1593 {
1594 PVMREQ pReqHead = (PVMREQ)ASMAtomicXchgPtr((void *volatile *)&pUVM->vm.s.pReqs, NULL);
1595 AssertMsg(!pReqHead, ("This isn't supposed to happen! VMR3Destroy caller has to serialize this.\n"));
1596 if (!pReqHead)
1597 break;
1598 for (PVMREQ pReq = pReqHead; pReq; pReq = pReq->pNext)
1599 {
1600 ASMAtomicUoWriteSize(&pReq->iStatus, VERR_INTERNAL_ERROR);
1601 ASMAtomicWriteSize(&pReq->enmState, VMREQSTATE_INVALID);
1602 RTSemEventSignal(pReq->EventSem);
1603 RTThreadSleep(2);
1604 RTSemEventDestroy(pReq->EventSem);
1605 }
1606 /* give them a chance to respond before we free the request memory. */
1607 RTThreadSleep(32);
1608 }
1609
1610 /*
1611 * Make sure the VMMR0.r0 module and whatever else is unloaded.
1612 */
1613 PDMR3TermUVM(pUVM);
1614
1615 /*
1616 * Terminate the support library if initialized.
1617 */
1618 if (pUVM->vm.s.pSession)
1619 {
1620 int rc = SUPTerm();
1621 AssertRC(rc);
1622 pUVM->vm.s.pSession = NIL_RTR0PTR;
1623 }
1624
1625 /*
1626 * Destroy the MM heap and free the UVM structure.
1627 */
1628 MMR3TermUVM(pUVM);
1629 STAMR3TermUVM(pUVM);
1630
1631 ASMAtomicUoWriteU32(&pUVM->u32Magic, UINT32_MAX);
1632 RTMemFree(pUVM);
1633
1634 RTLogFlush(NULL);
1635}
1636
1637
1638/**
1639 * Enumerates the VMs in this process.
1640 *
1641 * @returns Pointer to the next VM.
1642 * @returns NULL when no more VMs.
1643 * @param pVMPrev The previous VM
1644 * Use NULL to start the enumeration.
1645 */
1646VMR3DECL(PVM) VMR3EnumVMs(PVM pVMPrev)
1647{
1648 /*
1649 * This is quick and dirty. It has issues with VM being
1650 * destroyed during the enumeration.
1651 */
1652 PUVM pNext;
1653 if (pVMPrev)
1654 pNext = pVMPrev->pUVM->pNext;
1655 else
1656 pNext = g_pUVMsHead;
1657 return pNext ? pNext->pVM : NULL;
1658}
1659
1660
1661/**
1662 * Registers an at VM destruction callback.
1663 *
1664 * @returns VBox status code.
1665 * @param pfnAtDtor Pointer to callback.
1666 * @param pvUser User argument.
1667 */
1668VMR3DECL(int) VMR3AtDtorRegister(PFNVMATDTOR pfnAtDtor, void *pvUser)
1669{
1670 /*
1671 * Check if already registered.
1672 */
1673 VM_ATDTOR_LOCK();
1674 PVMATDTOR pCur = g_pVMAtDtorHead;
1675 while (pCur)
1676 {
1677 if (pfnAtDtor == pCur->pfnAtDtor)
1678 {
1679 VM_ATDTOR_UNLOCK();
1680 AssertMsgFailed(("Already registered at destruction callback %p!\n", pfnAtDtor));
1681 return VERR_INVALID_PARAMETER;
1682 }
1683
1684 /* next */
1685 pCur = pCur->pNext;
1686 }
1687 VM_ATDTOR_UNLOCK();
1688
1689 /*
1690 * Allocate new entry.
1691 */
1692 PVMATDTOR pVMAtDtor = (PVMATDTOR)RTMemAlloc(sizeof(*pVMAtDtor));
1693 if (!pVMAtDtor)
1694 return VERR_NO_MEMORY;
1695
1696 VM_ATDTOR_LOCK();
1697 pVMAtDtor->pfnAtDtor = pfnAtDtor;
1698 pVMAtDtor->pvUser = pvUser;
1699 pVMAtDtor->pNext = g_pVMAtDtorHead;
1700 g_pVMAtDtorHead = pVMAtDtor;
1701 VM_ATDTOR_UNLOCK();
1702
1703 return VINF_SUCCESS;
1704}
1705
1706
1707/**
1708 * Deregisters an at VM destruction callback.
1709 *
1710 * @returns VBox status code.
1711 * @param pfnAtDtor Pointer to callback.
1712 */
1713VMR3DECL(int) VMR3AtDtorDeregister(PFNVMATDTOR pfnAtDtor)
1714{
1715 /*
1716 * Find it, unlink it and free it.
1717 */
1718 VM_ATDTOR_LOCK();
1719 PVMATDTOR pPrev = NULL;
1720 PVMATDTOR pCur = g_pVMAtDtorHead;
1721 while (pCur)
1722 {
1723 if (pfnAtDtor == pCur->pfnAtDtor)
1724 {
1725 if (pPrev)
1726 pPrev->pNext = pCur->pNext;
1727 else
1728 g_pVMAtDtorHead = pCur->pNext;
1729 pCur->pNext = NULL;
1730 VM_ATDTOR_UNLOCK();
1731
1732 RTMemFree(pCur);
1733 return VINF_SUCCESS;
1734 }
1735
1736 /* next */
1737 pPrev = pCur;
1738 pCur = pCur->pNext;
1739 }
1740 VM_ATDTOR_UNLOCK();
1741
1742 return VERR_INVALID_PARAMETER;
1743}
1744
1745
1746/**
1747 * Walks the list of at VM destructor callbacks.
1748 * @param pVM The VM which is about to be destroyed.
1749 */
1750static void vmR3AtDtor(PVM pVM)
1751{
1752 /*
1753 * Find it, unlink it and free it.
1754 */
1755 VM_ATDTOR_LOCK();
1756 for (PVMATDTOR pCur = g_pVMAtDtorHead; pCur; pCur = pCur->pNext)
1757 pCur->pfnAtDtor(pVM, pCur->pvUser);
1758 VM_ATDTOR_UNLOCK();
1759}
1760
1761
1762/**
1763 * Reset the current VM.
1764 *
1765 * @returns VBox status code.
1766 * @param pVM VM to reset.
1767 */
1768VMR3DECL(int) VMR3Reset(PVM pVM)
1769{
1770 int rc = VINF_SUCCESS;
1771
1772 /*
1773 * Check the state.
1774 */
1775 if (!pVM)
1776 return VERR_INVALID_PARAMETER;
1777 if ( pVM->enmVMState != VMSTATE_RUNNING
1778 && pVM->enmVMState != VMSTATE_SUSPENDED)
1779 {
1780 AssertMsgFailed(("Invalid VM state %d\n", pVM->enmVMState));
1781 return VERR_VM_INVALID_VM_STATE;
1782 }
1783
1784 /*
1785 * Queue reset request to the emulation thread
1786 * and wait for it to be processed.
1787 */
1788 PVMREQ pReq = NULL;
1789 rc = VMR3ReqCall(pVM, &pReq, 0, (PFNRT)vmR3Reset, 1, pVM);
1790 while (rc == VERR_TIMEOUT)
1791 rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
1792 if (VBOX_SUCCESS(rc))
1793 rc = pReq->iStatus;
1794 VMR3ReqFree(pReq);
1795
1796 return rc;
1797}
1798
1799
1800/**
1801 * Worker which checks integrity of some internal structures.
1802 * This is yet another attempt to track down that AVL tree crash.
1803 */
1804static void vmR3CheckIntegrity(PVM pVM)
1805{
1806#ifdef VBOX_STRICT
1807 int rc = PGMR3CheckIntegrity(pVM);
1808 AssertReleaseRC(rc);
1809#endif
1810}
1811
1812
1813/**
1814 * Reset request processor.
1815 *
1816 * This is called by the emulation thread as a response to the
1817 * reset request issued by VMR3Reset().
1818 *
1819 * @returns VBox status code.
1820 * @param pVM VM to reset.
1821 */
1822static DECLCALLBACK(int) vmR3Reset(PVM pVM)
1823{
1824 /*
1825 * As a safety precaution we temporarily change the state while resetting.
1826 * (If VMR3Reset was not called from EMT we might have change state... let's ignore that fact for now.)
1827 */
1828 VMSTATE enmVMState = pVM->enmVMState;
1829 Assert(enmVMState == VMSTATE_SUSPENDED || enmVMState == VMSTATE_RUNNING);
1830 vmR3SetState(pVM, VMSTATE_RESETTING);
1831 vmR3CheckIntegrity(pVM);
1832
1833
1834 /*
1835 * Reset the VM components.
1836 */
1837 PATMR3Reset(pVM);
1838 CSAMR3Reset(pVM);
1839 PGMR3Reset(pVM); /* We clear VM RAM in PGMR3Reset. It's vital PDMR3Reset is executed
1840 * _afterwards_. E.g. ACPI sets up RAM tables during init/reset. */
1841 MMR3Reset(pVM);
1842 PDMR3Reset(pVM);
1843 SELMR3Reset(pVM);
1844 TRPMR3Reset(pVM);
1845 vmR3AtResetU(pVM->pUVM);
1846 REMR3Reset(pVM);
1847 IOMR3Reset(pVM);
1848 CPUMR3Reset(pVM);
1849 TMR3Reset(pVM);
1850 EMR3Reset(pVM);
1851 HWACCMR3Reset(pVM); /* This must come *after* PATM, CSAM, CPUM, SELM and TRPM. */
1852
1853#ifdef LOG_ENABLED
1854 /*
1855 * Debug logging.
1856 */
1857 RTLogPrintf("\n\nThe VM was reset:\n");
1858 DBGFR3Info(pVM, "cpum", "verbose", NULL);
1859#endif
1860
1861 /*
1862 * Restore the state.
1863 */
1864 vmR3CheckIntegrity(pVM);
1865 Assert(pVM->enmVMState == VMSTATE_RESETTING);
1866 vmR3SetState(pVM, enmVMState);
1867
1868 return VINF_EM_RESET;
1869}
1870
1871
1872/**
1873 * Walks the list of at VM reset callbacks and calls them
1874 *
1875 * @returns VBox status code.
1876 * Any failure is fatal.
1877 * @param pUVM Pointe to the user mode VM structure.
1878 */
1879static int vmR3AtResetU(PUVM pUVM)
1880{
1881 /*
1882 * Walk the list and call them all.
1883 */
1884 int rc = VINF_SUCCESS;
1885 for (PVMATRESET pCur = pUVM->vm.s.pAtReset; pCur; pCur = pCur->pNext)
1886 {
1887 /* do the call */
1888 switch (pCur->enmType)
1889 {
1890 case VMATRESETTYPE_DEV:
1891 rc = pCur->u.Dev.pfnCallback(pCur->u.Dev.pDevIns, pCur->pvUser);
1892 break;
1893 case VMATRESETTYPE_INTERNAL:
1894 rc = pCur->u.Internal.pfnCallback(pUVM->pVM, pCur->pvUser);
1895 break;
1896 case VMATRESETTYPE_EXTERNAL:
1897 pCur->u.External.pfnCallback(pCur->pvUser);
1898 break;
1899 default:
1900 AssertMsgFailed(("Invalid at-reset type %d!\n", pCur->enmType));
1901 return VERR_INTERNAL_ERROR;
1902 }
1903
1904 if (VBOX_FAILURE(rc))
1905 {
1906 AssertMsgFailed(("At-reset handler %s failed with rc=%d\n", pCur->pszDesc, rc));
1907 return rc;
1908 }
1909 }
1910
1911 return VINF_SUCCESS;
1912}
1913
1914
1915/**
1916 * Internal registration function
1917 */
1918static int vmr3AtResetRegisterU(PUVM pUVM, void *pvUser, const char *pszDesc, PVMATRESET *ppNew)
1919{
1920 /*
1921 * Allocate restration structure.
1922 */
1923 PVMATRESET pNew = (PVMATRESET)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
1924 if (pNew)
1925 {
1926 /* fill data. */
1927 pNew->pNext = NULL;
1928 pNew->pszDesc = pszDesc;
1929 pNew->pvUser = pvUser;
1930
1931 /* insert */
1932 *pUVM->vm.s.ppAtResetNext = pNew;
1933 pUVM->vm.s.ppAtResetNext = &pNew->pNext;
1934
1935 *ppNew = pNew;
1936 return VINF_SUCCESS;
1937 }
1938 return VERR_NO_MEMORY;
1939}
1940
1941
1942/**
1943 * Registers an at VM reset callback.
1944 *
1945 * @returns VBox status code.
1946 * @param pVM The VM.
1947 * @param pDevInst Device instance.
1948 * @param pfnCallback Callback function.
1949 * @param pvUser User argument.
1950 * @param pszDesc Description (optional).
1951 */
1952VMR3DECL(int) VMR3AtResetRegister(PVM pVM, PPDMDEVINS pDevInst, PFNVMATRESET pfnCallback, void *pvUser, const char *pszDesc)
1953{
1954 /*
1955 * Validate.
1956 */
1957 if (!pDevInst)
1958 {
1959 AssertMsgFailed(("pDevIns is NULL!\n"));
1960 return VERR_INVALID_PARAMETER;
1961 }
1962
1963 /*
1964 * Create the new entry.
1965 */
1966 PVMATRESET pNew;
1967 int rc = vmr3AtResetRegisterU(pVM->pUVM, pvUser, pszDesc, &pNew);
1968 if (VBOX_SUCCESS(rc))
1969 {
1970 /*
1971 * Fill in type data.
1972 */
1973 pNew->enmType = VMATRESETTYPE_DEV;
1974 pNew->u.Dev.pfnCallback = pfnCallback;
1975 pNew->u.Dev.pDevIns = pDevInst;
1976 }
1977
1978 return rc;
1979}
1980
1981
1982/**
1983 * Registers an at VM reset internal callback.
1984 *
1985 * @returns VBox status code.
1986 * @param pVM The VM.
1987 * @param pfnCallback Callback function.
1988 * @param pvUser User argument.
1989 * @param pszDesc Description (optional).
1990 */
1991VMR3DECL(int) VMR3AtResetRegisterInternal(PVM pVM, PFNVMATRESETINT pfnCallback, void *pvUser, const char *pszDesc)
1992{
1993 /*
1994 * Validate.
1995 */
1996 if (!pfnCallback)
1997 {
1998 AssertMsgFailed(("pfnCallback is NULL!\n"));
1999 return VERR_INVALID_PARAMETER;
2000 }
2001
2002 /*
2003 * Create the new entry.
2004 */
2005 PVMATRESET pNew;
2006 int rc = vmr3AtResetRegisterU(pVM->pUVM, pvUser, pszDesc, &pNew);
2007 if (VBOX_SUCCESS(rc))
2008 {
2009 /*
2010 * Fill in type data.
2011 */
2012 pNew->enmType = VMATRESETTYPE_INTERNAL;
2013 pNew->u.Internal.pfnCallback = pfnCallback;
2014 }
2015
2016 return rc;
2017}
2018
2019
2020/**
2021 * Registers an at VM reset external callback.
2022 *
2023 * @returns VBox status code.
2024 * @param pVM The VM.
2025 * @param pfnCallback Callback function.
2026 * @param pvUser User argument.
2027 * @param pszDesc Description (optional).
2028 */
2029VMR3DECL(int) VMR3AtResetRegisterExternal(PVM pVM, PFNVMATRESETEXT pfnCallback, void *pvUser, const char *pszDesc)
2030{
2031 /*
2032 * Validate.
2033 */
2034 if (!pfnCallback)
2035 {
2036 AssertMsgFailed(("pfnCallback is NULL!\n"));
2037 return VERR_INVALID_PARAMETER;
2038 }
2039
2040 /*
2041 * Create the new entry.
2042 */
2043 PVMATRESET pNew;
2044 int rc = vmr3AtResetRegisterU(pVM->pUVM, pvUser, pszDesc, &pNew);
2045 if (VBOX_SUCCESS(rc))
2046 {
2047 /*
2048 * Fill in type data.
2049 */
2050 pNew->enmType = VMATRESETTYPE_EXTERNAL;
2051 pNew->u.External.pfnCallback = pfnCallback;
2052 }
2053
2054 return rc;
2055}
2056
2057
2058/**
2059 * Unlinks and frees a callback.
2060 *
2061 * @returns Pointer to the next callback structure.
2062 * @param pUVM Pointer to the user mode VM structure.
2063 * @param pCur The one to free.
2064 * @param pPrev The one before pCur.
2065 */
2066static PVMATRESET vmr3AtResetFreeU(PUVM pUVM, PVMATRESET pCur, PVMATRESET pPrev)
2067{
2068 /*
2069 * Unlink it.
2070 */
2071 PVMATRESET pNext = pCur->pNext;
2072 if (pPrev)
2073 {
2074 pPrev->pNext = pNext;
2075 if (!pNext)
2076 pUVM->vm.s.ppAtResetNext = &pPrev->pNext;
2077 }
2078 else
2079 {
2080 pUVM->vm.s.pAtReset = pNext;
2081 if (!pNext)
2082 pUVM->vm.s.ppAtResetNext = &pUVM->vm.s.pAtReset;
2083 }
2084
2085 /*
2086 * Free it.
2087 */
2088 MMR3HeapFree(pCur);
2089
2090 return pNext;
2091}
2092
2093
2094/**
2095 * Deregisters an at VM reset callback.
2096 *
2097 * @returns VBox status code.
2098 * @param pVM The VM.
2099 * @param pDevInst Device instance.
2100 * @param pfnCallback Callback function.
2101 */
2102VMR3DECL(int) VMR3AtResetDeregister(PVM pVM, PPDMDEVINS pDevInst, PFNVMATRESET pfnCallback)
2103{
2104 int rc = VERR_VM_ATRESET_NOT_FOUND;
2105 PVMATRESET pPrev = NULL;
2106 PVMATRESET pCur = pVM->pUVM->vm.s.pAtReset;
2107 while (pCur)
2108 {
2109 if ( pCur->enmType == VMATRESETTYPE_DEV
2110 && pCur->u.Dev.pDevIns == pDevInst
2111 && (!pfnCallback || pCur->u.Dev.pfnCallback == pfnCallback))
2112 {
2113 pCur = vmr3AtResetFreeU(pVM->pUVM, pCur, pPrev);
2114 rc = VINF_SUCCESS;
2115 }
2116 else
2117 {
2118 pPrev = pCur;
2119 pCur = pCur->pNext;
2120 }
2121 }
2122
2123 AssertRC(rc);
2124 return rc;
2125}
2126
2127
2128/**
2129 * Deregisters an at VM reset internal callback.
2130 *
2131 * @returns VBox status code.
2132 * @param pVM The VM.
2133 * @param pfnCallback Callback function.
2134 */
2135VMR3DECL(int) VMR3AtResetDeregisterInternal(PVM pVM, PFNVMATRESETINT pfnCallback)
2136{
2137 int rc = VERR_VM_ATRESET_NOT_FOUND;
2138 PVMATRESET pPrev = NULL;
2139 PVMATRESET pCur = pVM->pUVM->vm.s.pAtReset;
2140 while (pCur)
2141 {
2142 if ( pCur->enmType == VMATRESETTYPE_INTERNAL
2143 && pCur->u.Internal.pfnCallback == pfnCallback)
2144 {
2145 pCur = vmr3AtResetFreeU(pVM->pUVM, pCur, pPrev);
2146 rc = VINF_SUCCESS;
2147 }
2148 else
2149 {
2150 pPrev = pCur;
2151 pCur = pCur->pNext;
2152 }
2153 }
2154
2155 AssertRC(rc);
2156 return rc;
2157}
2158
2159
2160/**
2161 * Deregisters an at VM reset external callback.
2162 *
2163 * @returns VBox status code.
2164 * @param pVM The VM.
2165 * @param pfnCallback Callback function.
2166 */
2167VMR3DECL(int) VMR3AtResetDeregisterExternal(PVM pVM, PFNVMATRESETEXT pfnCallback)
2168{
2169 int rc = VERR_VM_ATRESET_NOT_FOUND;
2170 PVMATRESET pPrev = NULL;
2171 PVMATRESET pCur = pVM->pUVM->vm.s.pAtReset;
2172 while (pCur)
2173 {
2174 if ( pCur->enmType == VMATRESETTYPE_INTERNAL
2175 && pCur->u.External.pfnCallback == pfnCallback)
2176 {
2177 pCur = vmr3AtResetFreeU(pVM->pUVM, pCur, pPrev);
2178 rc = VINF_SUCCESS;
2179 }
2180 else
2181 {
2182 pPrev = pCur;
2183 pCur = pCur->pNext;
2184 }
2185 }
2186
2187 AssertRC(rc);
2188 return rc;
2189}
2190
2191
2192/**
2193 * Gets the current VM state.
2194 *
2195 * @returns The current VM state.
2196 * @param pVM VM handle.
2197 * @thread Any
2198 */
2199VMR3DECL(VMSTATE) VMR3GetState(PVM pVM)
2200{
2201 return pVM->enmVMState;
2202}
2203
2204
2205/**
2206 * Gets the state name string for a VM state.
2207 *
2208 * @returns Pointer to the state name. (readonly)
2209 * @param enmState The state.
2210 */
2211VMR3DECL(const char *) VMR3GetStateName(VMSTATE enmState)
2212{
2213 switch (enmState)
2214 {
2215 case VMSTATE_CREATING: return "CREATING";
2216 case VMSTATE_CREATED: return "CREATED";
2217 case VMSTATE_RUNNING: return "RUNNING";
2218 case VMSTATE_LOADING: return "LOADING";
2219 case VMSTATE_LOAD_FAILURE: return "LOAD_FAILURE";
2220 case VMSTATE_SAVING: return "SAVING";
2221 case VMSTATE_SUSPENDED: return "SUSPENDED";
2222 case VMSTATE_RESETTING: return "RESETTING";
2223 case VMSTATE_GURU_MEDITATION: return "GURU_MEDIATION";
2224 case VMSTATE_OFF: return "OFF";
2225 case VMSTATE_DESTROYING: return "DESTROYING";
2226 case VMSTATE_TERMINATED: return "TERMINATED";
2227 default:
2228 AssertMsgFailed(("Unknown state %d\n", enmState));
2229 return "Unknown!\n";
2230 }
2231}
2232
2233
2234/**
2235 * Sets the current VM state.
2236 *
2237 * @returns The current VM state.
2238 * @param pVM VM handle.
2239 * @param enmStateNew The new state.
2240 */
2241void vmR3SetState(PVM pVM, VMSTATE enmStateNew)
2242{
2243 VMSTATE enmStateOld = pVM->enmVMState;
2244 pVM->enmVMState = enmStateNew;
2245 LogRel(("Changing the VM state from '%s' to '%s'.\n", VMR3GetStateName(enmStateOld), VMR3GetStateName(enmStateNew)));
2246
2247 /*
2248 * Call the at state change callbacks.
2249 */
2250 for (PVMATSTATE pCur = pVM->pUVM->vm.s.pAtState; pCur; pCur = pCur->pNext)
2251 {
2252 pCur->pfnAtState(pVM, enmStateNew, enmStateOld, pCur->pvUser);
2253 if (pVM->enmVMState == VMSTATE_DESTROYING)
2254 break;
2255 AssertMsg(pVM->enmVMState == enmStateNew,
2256 ("You are not allowed to change the state while in the change callback, except "
2257 "from destroying the VM. There are restrictions in the way the state changes "
2258 "are propagated up to the EM execution loop and it makes the program flow very "
2259 "difficult to follow.\n"));
2260 }
2261}
2262
2263
2264/**
2265 * Registers a VM state change callback.
2266 *
2267 * You are not allowed to call any function which changes the VM state from a
2268 * state callback, except VMR3Destroy().
2269 *
2270 * @returns VBox status code.
2271 * @param pVM VM handle.
2272 * @param pfnAtState Pointer to callback.
2273 * @param pvUser User argument.
2274 * @thread Any.
2275 */
2276VMR3DECL(int) VMR3AtStateRegister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2277{
2278 LogFlow(("VMR3AtStateRegister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2279
2280 /*
2281 * Validate input.
2282 */
2283 if (!pfnAtState)
2284 {
2285 AssertMsgFailed(("callback is required\n"));
2286 return VERR_INVALID_PARAMETER;
2287 }
2288
2289 /*
2290 * Make sure we're in EMT (to avoid the logging).
2291 */
2292 PVMREQ pReq;
2293 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateRegisterU, 3, pVM->pUVM, pfnAtState, pvUser);
2294 if (VBOX_FAILURE(rc))
2295 return rc;
2296 rc = pReq->iStatus;
2297 VMR3ReqFree(pReq);
2298
2299 LogFlow(("VMR3AtStateRegister: returns %Vrc\n", rc));
2300 return rc;
2301}
2302
2303
2304/**
2305 * Registers a VM state change callback.
2306 *
2307 * @returns VBox status code.
2308 * @param pUVM Pointer to the user mode VM structure.
2309 * @param pfnAtState Pointer to callback.
2310 * @param pvUser User argument.
2311 * @thread EMT
2312 */
2313static DECLCALLBACK(int) vmR3AtStateRegisterU(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser)
2314{
2315 /*
2316 * Allocate a new record.
2317 */
2318
2319 PVMATSTATE pNew = (PVMATSTATE)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
2320 if (!pNew)
2321 return VERR_NO_MEMORY;
2322
2323 /* fill */
2324 pNew->pfnAtState = pfnAtState;
2325 pNew->pvUser = pvUser;
2326 pNew->pNext = NULL;
2327
2328 /* insert */
2329 *pUVM->vm.s.ppAtStateNext = pNew;
2330 pUVM->vm.s.ppAtStateNext = &pNew->pNext;
2331
2332 return VINF_SUCCESS;
2333}
2334
2335
2336/**
2337 * Deregisters a VM state change callback.
2338 *
2339 * @returns VBox status code.
2340 * @param pVM VM handle.
2341 * @param pfnAtState Pointer to callback.
2342 * @param pvUser User argument.
2343 * @thread Any.
2344 */
2345VMR3DECL(int) VMR3AtStateDeregister(PVM pVM, PFNVMATSTATE pfnAtState, void *pvUser)
2346{
2347 LogFlow(("VMR3AtStateDeregister: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2348
2349 /*
2350 * Validate input.
2351 */
2352 if (!pfnAtState)
2353 {
2354 AssertMsgFailed(("callback is required\n"));
2355 return VERR_INVALID_PARAMETER;
2356 }
2357
2358 /*
2359 * Make sure we're in EMT (to avoid the logging).
2360 */
2361 PVMREQ pReq;
2362 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtStateDeregisterU, 3, pVM->pUVM, pfnAtState, pvUser);
2363 if (VBOX_FAILURE(rc))
2364 return rc;
2365 rc = pReq->iStatus;
2366 VMR3ReqFree(pReq);
2367
2368 LogFlow(("VMR3AtStateDeregister: returns %Vrc\n", rc));
2369 return rc;
2370}
2371
2372
2373/**
2374 * Deregisters a VM state change callback.
2375 *
2376 * @returns VBox status code.
2377 * @param pUVM Pointer to the user mode VM structure.
2378 * @param pfnAtState Pointer to callback.
2379 * @param pvUser User argument.
2380 * @thread EMT
2381 */
2382static DECLCALLBACK(int) vmR3AtStateDeregisterU(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser)
2383{
2384 LogFlow(("vmR3AtStateDeregisterU: pfnAtState=%p pvUser=%p\n", pfnAtState, pvUser));
2385
2386 /*
2387 * Search the list for the entry.
2388 */
2389 PVMATSTATE pPrev = NULL;
2390 PVMATSTATE pCur = pUVM->vm.s.pAtState;
2391 while ( pCur
2392 && pCur->pfnAtState == pfnAtState
2393 && pCur->pvUser == pvUser)
2394 {
2395 pPrev = pCur;
2396 pCur = pCur->pNext;
2397 }
2398 if (!pCur)
2399 {
2400 AssertMsgFailed(("pfnAtState=%p was not found\n", pfnAtState));
2401 return VERR_FILE_NOT_FOUND;
2402 }
2403
2404 /*
2405 * Unlink it.
2406 */
2407 if (pPrev)
2408 {
2409 pPrev->pNext = pCur->pNext;
2410 if (!pCur->pNext)
2411 pUVM->vm.s.ppAtStateNext = &pPrev->pNext;
2412 }
2413 else
2414 {
2415 pUVM->vm.s.pAtState = pCur->pNext;
2416 if (!pCur->pNext)
2417 pUVM->vm.s.ppAtStateNext = &pUVM->vm.s.pAtState;
2418 }
2419
2420 /*
2421 * Free it.
2422 */
2423 pCur->pfnAtState = NULL;
2424 pCur->pNext = NULL;
2425 MMR3HeapFree(pCur);
2426
2427 return VINF_SUCCESS;
2428}
2429
2430
2431/**
2432 * Registers a VM error callback.
2433 *
2434 * @returns VBox status code.
2435 * @param pVM The VM handle.
2436 * @param pfnAtError Pointer to callback.
2437 * @param pvUser User argument.
2438 * @thread Any.
2439 */
2440VMR3DECL(int) VMR3AtErrorRegister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2441{
2442 return VMR3AtErrorRegisterU(pVM->pUVM, pfnAtError, pvUser);
2443}
2444
2445
2446/**
2447 * Registers a VM error callback.
2448 *
2449 * @returns VBox status code.
2450 * @param pUVM The VM handle.
2451 * @param pfnAtError Pointer to callback.
2452 * @param pvUser User argument.
2453 * @thread Any.
2454 */
2455VMR3DECL(int) VMR3AtErrorRegisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
2456{
2457 LogFlow(("VMR3AtErrorRegister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2458 AssertPtrReturn(pfnAtError, VERR_INVALID_PARAMETER);
2459
2460 /*
2461 * Make sure we're in EMT (to avoid the logging).
2462 */
2463 PVMREQ pReq;
2464 int rc = VMR3ReqCallU(pUVM, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3AtErrorRegisterU, 3, pUVM, pfnAtError, pvUser);
2465 if (VBOX_FAILURE(rc))
2466 return rc;
2467 rc = pReq->iStatus;
2468 VMR3ReqFree(pReq);
2469
2470 LogFlow(("VMR3AtErrorRegister: returns %Vrc\n", rc));
2471 return rc;
2472}
2473
2474
2475/**
2476 * Registers a VM error callback.
2477 *
2478 * @returns VBox status code.
2479 * @param pUVM Pointer to the user mode VM structure.
2480 * @param pfnAtError Pointer to callback.
2481 * @param pvUser User argument.
2482 * @thread EMT
2483 */
2484static DECLCALLBACK(int) vmR3AtErrorRegisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
2485{
2486 /*
2487 * Allocate a new record.
2488 */
2489
2490 PVMATERROR pNew = (PVMATERROR)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
2491 if (!pNew)
2492 return VERR_NO_MEMORY;
2493
2494 /* fill */
2495 pNew->pfnAtError = pfnAtError;
2496 pNew->pvUser = pvUser;
2497 pNew->pNext = NULL;
2498
2499 /* insert */
2500 *pUVM->vm.s.ppAtErrorNext = pNew;
2501 pUVM->vm.s.ppAtErrorNext = &pNew->pNext;
2502
2503 return VINF_SUCCESS;
2504}
2505
2506
2507/**
2508 * Deregisters a VM error callback.
2509 *
2510 * @returns VBox status code.
2511 * @param pVM The VM handle.
2512 * @param pfnAtError Pointer to callback.
2513 * @param pvUser User argument.
2514 * @thread Any.
2515 */
2516VMR3DECL(int) VMR3AtErrorDeregister(PVM pVM, PFNVMATERROR pfnAtError, void *pvUser)
2517{
2518 LogFlow(("VMR3AtErrorDeregister: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2519
2520 /*
2521 * Validate input.
2522 */
2523 if (!pfnAtError)
2524 {
2525 AssertMsgFailed(("callback is required\n"));
2526 return VERR_INVALID_PARAMETER;
2527 }
2528
2529 /*
2530 * Make sure we're in EMT (to avoid the logging).
2531 */
2532 PVMREQ pReq;
2533 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtErrorDeregisterU, 3, pVM->pUVM, pfnAtError, pvUser);
2534 if (VBOX_FAILURE(rc))
2535 return rc;
2536 rc = pReq->iStatus;
2537 VMR3ReqFree(pReq);
2538
2539 LogFlow(("VMR3AtErrorDeregister: returns %Vrc\n", rc));
2540 return rc;
2541}
2542
2543
2544/**
2545 * Deregisters a VM error callback.
2546 *
2547 * @returns VBox status code.
2548 * @param pUVM Pointer to the user mode VM structure.
2549 * @param pfnAtError Pointer to callback.
2550 * @param pvUser User argument.
2551 * @thread EMT
2552 */
2553static DECLCALLBACK(int) vmR3AtErrorDeregisterU(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser)
2554{
2555 LogFlow(("vmR3AtErrorDeregisterU: pfnAtError=%p pvUser=%p\n", pfnAtError, pvUser));
2556
2557 /*
2558 * Search the list for the entry.
2559 */
2560 PVMATERROR pPrev = NULL;
2561 PVMATERROR pCur = pUVM->vm.s.pAtError;
2562 while ( pCur
2563 && pCur->pfnAtError == pfnAtError
2564 && pCur->pvUser == pvUser)
2565 {
2566 pPrev = pCur;
2567 pCur = pCur->pNext;
2568 }
2569 if (!pCur)
2570 {
2571 AssertMsgFailed(("pfnAtError=%p was not found\n", pfnAtError));
2572 return VERR_FILE_NOT_FOUND;
2573 }
2574
2575 /*
2576 * Unlink it.
2577 */
2578 if (pPrev)
2579 {
2580 pPrev->pNext = pCur->pNext;
2581 if (!pCur->pNext)
2582 pUVM->vm.s.ppAtErrorNext = &pPrev->pNext;
2583 }
2584 else
2585 {
2586 pUVM->vm.s.pAtError = pCur->pNext;
2587 if (!pCur->pNext)
2588 pUVM->vm.s.ppAtErrorNext = &pUVM->vm.s.pAtError;
2589 }
2590
2591 /*
2592 * Free it.
2593 */
2594 pCur->pfnAtError = NULL;
2595 pCur->pNext = NULL;
2596 MMR3HeapFree(pCur);
2597
2598 return VINF_SUCCESS;
2599}
2600
2601
2602/**
2603 * Ellipsis to va_list wrapper for calling pfnAtError.
2604 */
2605static void vmR3SetErrorWorkerDoCall(PVM pVM, PVMATERROR pCur, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2606{
2607 va_list va;
2608 va_start(va, pszFormat);
2609 pCur->pfnAtError(pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
2610 va_end(va);
2611}
2612
2613
2614/**
2615 * This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2616 * The message is found in VMINT.
2617 *
2618 * @param pVM The VM handle.
2619 * @thread EMT.
2620 */
2621VMR3DECL(void) VMR3SetErrorWorker(PVM pVM)
2622{
2623 VM_ASSERT_EMT(pVM);
2624 AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetErrorV! Contrats!\n"));
2625
2626 /*
2627 * Unpack the error (if we managed to format one).
2628 */
2629 PVMERROR pErr = pVM->vm.s.pErrorR3;
2630 const char *pszFile = NULL;
2631 const char *pszFunction = NULL;
2632 uint32_t iLine = 0;
2633 const char *pszMessage;
2634 int32_t rc = VERR_MM_HYPER_NO_MEMORY;
2635 if (pErr)
2636 {
2637 AssertCompile(sizeof(const char) == sizeof(uint8_t));
2638 if (pErr->offFile)
2639 pszFile = (const char *)pErr + pErr->offFile;
2640 iLine = pErr->iLine;
2641 if (pErr->offFunction)
2642 pszFunction = (const char *)pErr + pErr->offFunction;
2643 if (pErr->offMessage)
2644 pszMessage = (const char *)pErr + pErr->offMessage;
2645 else
2646 pszMessage = "No message!";
2647 }
2648 else
2649 pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2650
2651 /*
2652 * Call the at error callbacks.
2653 */
2654 for (PVMATERROR pCur = pVM->pUVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2655 vmR3SetErrorWorkerDoCall(pVM, pCur, rc, RT_SRC_POS_ARGS, "%s", pszMessage);
2656}
2657
2658
2659/**
2660 * Creation time wrapper for vmR3SetErrorUV.
2661 *
2662 * @returns rc.
2663 * @param pUVM Pointer to the user mode VM structure.
2664 * @param rc The VBox status code.
2665 * @param RT_SRC_POS_DECL The source position of this error.
2666 * @param pszFormat Format string.
2667 * @param ... The arguments.
2668 * @thread Any thread.
2669 */
2670static int vmR3SetErrorU(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2671{
2672 va_list va;
2673 va_start(va, pszFormat);
2674 vmR3SetErrorUV(pUVM, rc, pszFile, iLine, pszFunction, pszFormat, &va);
2675 va_end(va);
2676 return rc;
2677}
2678
2679
2680/**
2681 * Worker which calls everyone listening to the VM error messages.
2682 *
2683 * @param pUVM Pointer to the user mode VM structure.
2684 * @param rc The VBox status code.
2685 * @param RT_SRC_POS_DECL The source position of this error.
2686 * @param pszFormat Format string.
2687 * @param pArgs Pointer to the format arguments.
2688 * @thread EMT
2689 */
2690DECLCALLBACK(void) vmR3SetErrorUV(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list *pArgs)
2691{
2692#ifdef LOG_ENABLED
2693 /*
2694 * Log the error.
2695 */
2696 RTLogPrintf("VMSetError: %s(%d) %s\n", pszFile, iLine, pszFunction);
2697 va_list va3;
2698 va_copy(va3, *pArgs);
2699 RTLogPrintfV(pszFormat, va3);
2700 va_end(va3);
2701 RTLogPrintf("\n");
2702#endif
2703
2704 /*
2705 * Make a copy of the message.
2706 */
2707 if (pUVM->pVM)
2708 vmSetErrorCopy(pUVM->pVM, rc, RT_SRC_POS_ARGS, pszFormat, *pArgs);
2709
2710 /*
2711 * Call the at error callbacks.
2712 */
2713 for (PVMATERROR pCur = pUVM->vm.s.pAtError; pCur; pCur = pCur->pNext)
2714 {
2715 va_list va2;
2716 va_copy(va2, *pArgs);
2717 pCur->pfnAtError(pUVM->pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
2718 va_end(va2);
2719 }
2720}
2721
2722
2723/**
2724 * Registers a VM runtime error callback.
2725 *
2726 * @returns VBox status code.
2727 * @param pVM The VM handle.
2728 * @param pfnAtRuntimeError Pointer to callback.
2729 * @param pvUser User argument.
2730 * @thread Any.
2731 */
2732VMR3DECL(int) VMR3AtRuntimeErrorRegister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2733{
2734 LogFlow(("VMR3AtRuntimeErrorRegister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2735
2736 /*
2737 * Validate input.
2738 */
2739 if (!pfnAtRuntimeError)
2740 {
2741 AssertMsgFailed(("callback is required\n"));
2742 return VERR_INVALID_PARAMETER;
2743 }
2744
2745 /*
2746 * Make sure we're in EMT (to avoid the logging).
2747 */
2748 PVMREQ pReq;
2749 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorRegisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser);
2750 if (VBOX_FAILURE(rc))
2751 return rc;
2752 rc = pReq->iStatus;
2753 VMR3ReqFree(pReq);
2754
2755 LogFlow(("VMR3AtRuntimeErrorRegister: returns %Vrc\n", rc));
2756 return rc;
2757}
2758
2759
2760/**
2761 * Registers a VM runtime error callback.
2762 *
2763 * @returns VBox status code.
2764 * @param pUVM Pointer to the user mode VM structure.
2765 * @param pfnAtRuntimeError Pointer to callback.
2766 * @param pvUser User argument.
2767 * @thread EMT
2768 */
2769static DECLCALLBACK(int) vmR3AtRuntimeErrorRegisterU(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2770{
2771 /*
2772 * Allocate a new record.
2773 */
2774
2775 PVMATRUNTIMEERROR pNew = (PVMATRUNTIMEERROR)MMR3HeapAllocU(pUVM, MM_TAG_VM, sizeof(*pNew));
2776 if (!pNew)
2777 return VERR_NO_MEMORY;
2778
2779 /* fill */
2780 pNew->pfnAtRuntimeError = pfnAtRuntimeError;
2781 pNew->pvUser = pvUser;
2782 pNew->pNext = NULL;
2783
2784 /* insert */
2785 *pUVM->vm.s.ppAtRuntimeErrorNext = pNew;
2786 pUVM->vm.s.ppAtRuntimeErrorNext = &pNew->pNext;
2787
2788 return VINF_SUCCESS;
2789}
2790
2791
2792/**
2793 * Deregisters a VM runtime error callback.
2794 *
2795 * @returns VBox status code.
2796 * @param pVM The VM handle.
2797 * @param pfnAtRuntimeError Pointer to callback.
2798 * @param pvUser User argument.
2799 * @thread Any.
2800 */
2801VMR3DECL(int) VMR3AtRuntimeErrorDeregister(PVM pVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2802{
2803 LogFlow(("VMR3AtRuntimeErrorDeregister: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2804
2805 /*
2806 * Validate input.
2807 */
2808 if (!pfnAtRuntimeError)
2809 {
2810 AssertMsgFailed(("callback is required\n"));
2811 return VERR_INVALID_PARAMETER;
2812 }
2813
2814 /*
2815 * Make sure we're in EMT (to avoid the logging).
2816 */
2817 PVMREQ pReq;
2818 int rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3AtRuntimeErrorDeregisterU, 3, pVM->pUVM, pfnAtRuntimeError, pvUser);
2819 if (VBOX_FAILURE(rc))
2820 return rc;
2821 rc = pReq->iStatus;
2822 VMR3ReqFree(pReq);
2823
2824 LogFlow(("VMR3AtRuntimeErrorDeregister: returns %Vrc\n", rc));
2825 return rc;
2826}
2827
2828
2829/**
2830 * Deregisters a VM runtime error callback.
2831 *
2832 * @returns VBox status code.
2833 * @param pUVM Pointer to the user mode VM structure.
2834 * @param pfnAtRuntimeError Pointer to callback.
2835 * @param pvUser User argument.
2836 * @thread EMT
2837 */
2838static DECLCALLBACK(int) vmR3AtRuntimeErrorDeregisterU(PUVM pUVM, PFNVMATRUNTIMEERROR pfnAtRuntimeError, void *pvUser)
2839{
2840 LogFlow(("vmR3AtRuntimeErrorDeregisterU: pfnAtRuntimeError=%p pvUser=%p\n", pfnAtRuntimeError, pvUser));
2841
2842 /*
2843 * Search the list for the entry.
2844 */
2845 PVMATRUNTIMEERROR pPrev = NULL;
2846 PVMATRUNTIMEERROR pCur = pUVM->vm.s.pAtRuntimeError;
2847 while ( pCur
2848 && pCur->pfnAtRuntimeError == pfnAtRuntimeError
2849 && pCur->pvUser == pvUser)
2850 {
2851 pPrev = pCur;
2852 pCur = pCur->pNext;
2853 }
2854 if (!pCur)
2855 {
2856 AssertMsgFailed(("pfnAtRuntimeError=%p was not found\n", pfnAtRuntimeError));
2857 return VERR_FILE_NOT_FOUND;
2858 }
2859
2860 /*
2861 * Unlink it.
2862 */
2863 if (pPrev)
2864 {
2865 pPrev->pNext = pCur->pNext;
2866 if (!pCur->pNext)
2867 pUVM->vm.s.ppAtRuntimeErrorNext = &pPrev->pNext;
2868 }
2869 else
2870 {
2871 pUVM->vm.s.pAtRuntimeError = pCur->pNext;
2872 if (!pCur->pNext)
2873 pUVM->vm.s.ppAtRuntimeErrorNext = &pUVM->vm.s.pAtRuntimeError;
2874 }
2875
2876 /*
2877 * Free it.
2878 */
2879 pCur->pfnAtRuntimeError = NULL;
2880 pCur->pNext = NULL;
2881 MMR3HeapFree(pCur);
2882
2883 return VINF_SUCCESS;
2884}
2885
2886
2887/**
2888 * Ellipsis to va_list wrapper for calling pfnAtRuntimeError.
2889 */
2890static void vmR3SetRuntimeErrorWorkerDoCall(PVM pVM, PVMATRUNTIMEERROR pCur, bool fFatal,
2891 const char *pszErrorID,
2892 const char *pszFormat, ...)
2893{
2894 va_list va;
2895 va_start(va, pszFormat);
2896 pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va);
2897 va_end(va);
2898}
2899
2900
2901/**
2902 * This is a worker function for GC and Ring-0 calls to VMSetError and VMSetErrorV.
2903 * The message is found in VMINT.
2904 *
2905 * @param pVM The VM handle.
2906 * @thread EMT.
2907 */
2908VMR3DECL(void) VMR3SetRuntimeErrorWorker(PVM pVM)
2909{
2910 VM_ASSERT_EMT(pVM);
2911 AssertReleaseMsgFailed(("And we have a winner! You get to implement Ring-0 and GC VMSetRuntimeErrorV! Contrats!\n"));
2912
2913 /*
2914 * Unpack the error (if we managed to format one).
2915 */
2916 PVMRUNTIMEERROR pErr = pVM->vm.s.pRuntimeErrorR3;
2917 const char *pszErrorID = NULL;
2918 const char *pszMessage;
2919 bool fFatal = false;
2920 if (pErr)
2921 {
2922 AssertCompile(sizeof(const char) == sizeof(uint8_t));
2923 if (pErr->offErrorID)
2924 pszErrorID = (const char *)pErr + pErr->offErrorID;
2925 if (pErr->offMessage)
2926 pszMessage = (const char *)pErr + pErr->offMessage;
2927 else
2928 pszMessage = "No message!";
2929 fFatal = pErr->fFatal;
2930 }
2931 else
2932 pszMessage = "No message! (Failed to allocate memory to put the error message in!)";
2933
2934 /*
2935 * Call the at runtime error callbacks.
2936 */
2937 for (PVMATRUNTIMEERROR pCur = pVM->pUVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2938 vmR3SetRuntimeErrorWorkerDoCall(pVM, pCur, fFatal, pszErrorID, "%s", pszMessage);
2939}
2940
2941
2942/**
2943 * Worker which calls everyone listening to the VM runtime error messages.
2944 *
2945 * @param pVM The VM handle.
2946 * @param fFatal Whether it is a fatal error or not.
2947 * @param pszErrorID Error ID string.
2948 * @param pszFormat Format string.
2949 * @param pArgs Pointer to the format arguments.
2950 * @thread EMT
2951 */
2952DECLCALLBACK(void) vmR3SetRuntimeErrorV(PVM pVM, bool fFatal,
2953 const char *pszErrorID,
2954 const char *pszFormat, va_list *pArgs)
2955{
2956 /*
2957 * Make a copy of the message.
2958 */
2959 vmSetRuntimeErrorCopy(pVM, fFatal, pszErrorID, pszFormat, *pArgs);
2960
2961 /*
2962 * Call the at error callbacks.
2963 */
2964 for (PVMATRUNTIMEERROR pCur = pVM->pUVM->vm.s.pAtRuntimeError; pCur; pCur = pCur->pNext)
2965 {
2966 va_list va2;
2967 va_copy(va2, *pArgs);
2968 pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFatal, pszErrorID, pszFormat, va2);
2969 va_end(va2);
2970 }
2971}
2972
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