VirtualBox

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

Last change on this file since 1875 was 1871, checked in by vboxsync, 18 years ago

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