VirtualBox

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

Last change on this file since 768 was 451, checked in by vboxsync, 18 years ago

drop the AMD64 protection.

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