VirtualBox

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

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

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