VirtualBox

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

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

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