VirtualBox

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

Last change on this file since 10840 was 10840, checked in by vboxsync, 16 years ago

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