VirtualBox

source: vbox/trunk/src/VBox/VMM/include/VMInternal.h@ 53349

Last change on this file since 53349 was 48528, checked in by vboxsync, 11 years ago

Change implementation for turning a reset into a power off to prevent the VM from executing while the power down thread is not running
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 17.5 KB
Line 
1/* $Id: VMInternal.h 48528 2013-09-18 20:39:01Z vboxsync $ */
2/** @file
3 * VM - Internal header file.
4 */
5
6/*
7 * Copyright (C) 2006-2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef ___VMInternal_h
19#define ___VMInternal_h
20
21#include <VBox/cdefs.h>
22#include <VBox/vmm/vmapi.h>
23#include <iprt/assert.h>
24#include <iprt/critsect.h>
25#include <setjmp.h>
26
27
28
29/** @defgroup grp_vm_int Internals
30 * @ingroup grp_vm
31 * @internal
32 * @{
33 */
34
35
36/**
37 * VM state change callback.
38 */
39typedef struct VMATSTATE
40{
41 /** Pointer to the next one. */
42 struct VMATSTATE *pNext;
43 /** Pointer to the callback. */
44 PFNVMATSTATE pfnAtState;
45 /** The user argument. */
46 void *pvUser;
47} VMATSTATE;
48/** Pointer to a VM state change callback. */
49typedef VMATSTATE *PVMATSTATE;
50
51
52/**
53 * VM error callback.
54 */
55typedef struct VMATERROR
56{
57 /** Pointer to the next one. */
58 struct VMATERROR *pNext;
59 /** Pointer to the callback. */
60 PFNVMATERROR pfnAtError;
61 /** The user argument. */
62 void *pvUser;
63} VMATERROR;
64/** Pointer to a VM error callback. */
65typedef VMATERROR *PVMATERROR;
66
67
68/**
69 * Chunk of memory allocated off the hypervisor heap in which
70 * we copy the error details.
71 */
72typedef struct VMERROR
73{
74 /** The size of the chunk. */
75 uint32_t cbAllocated;
76 /** The current offset into the chunk.
77 * We start by putting the filename and function immediately
78 * after the end of the buffer. */
79 uint32_t off;
80 /** Offset from the start of this structure to the file name. */
81 uint32_t offFile;
82 /** The line number. */
83 uint32_t iLine;
84 /** Offset from the start of this structure to the function name. */
85 uint32_t offFunction;
86 /** Offset from the start of this structure to the formatted message text. */
87 uint32_t offMessage;
88 /** The VBox status code. */
89 int32_t rc;
90} VMERROR, *PVMERROR;
91
92
93/**
94 * VM runtime error callback.
95 */
96typedef struct VMATRUNTIMEERROR
97{
98 /** Pointer to the next one. */
99 struct VMATRUNTIMEERROR *pNext;
100 /** Pointer to the callback. */
101 PFNVMATRUNTIMEERROR pfnAtRuntimeError;
102 /** The user argument. */
103 void *pvUser;
104} VMATRUNTIMEERROR;
105/** Pointer to a VM error callback. */
106typedef VMATRUNTIMEERROR *PVMATRUNTIMEERROR;
107
108
109/**
110 * Chunk of memory allocated off the hypervisor heap in which
111 * we copy the runtime error details.
112 */
113typedef struct VMRUNTIMEERROR
114{
115 /** The size of the chunk. */
116 uint32_t cbAllocated;
117 /** The current offset into the chunk.
118 * We start by putting the error ID immediately
119 * after the end of the buffer. */
120 uint32_t off;
121 /** Offset from the start of this structure to the error ID. */
122 uint32_t offErrorId;
123 /** Offset from the start of this structure to the formatted message text. */
124 uint32_t offMessage;
125 /** Error flags. */
126 uint32_t fFlags;
127} VMRUNTIMEERROR, *PVMRUNTIMEERROR;
128
129/** The halt method. */
130typedef enum
131{
132 /** The usual invalid value. */
133 VMHALTMETHOD_INVALID = 0,
134 /** Use the method used during bootstrapping. */
135 VMHALTMETHOD_BOOTSTRAP,
136 /** Use the default method. */
137 VMHALTMETHOD_DEFAULT,
138 /** The old spin/yield/block method. */
139 VMHALTMETHOD_OLD,
140 /** The first go at a block/spin method. */
141 VMHALTMETHOD_1,
142 /** The first go at a more global approach. */
143 VMHALTMETHOD_GLOBAL_1,
144 /** The end of valid methods. (not inclusive of course) */
145 VMHALTMETHOD_END,
146 /** The usual 32-bit max value. */
147 VMHALTMETHOD_32BIT_HACK = 0x7fffffff
148} VMHALTMETHOD;
149
150
151/**
152 * VM Internal Data (part of the VM structure).
153 *
154 * @todo Move this and all related things to VMM. The VM component was, to some
155 * extent at least, a bad ad hoc design which should all have been put in
156 * VMM. @see pg_vm.
157 */
158typedef struct VMINT
159{
160 /** VM Error Message. */
161 R3PTRTYPE(PVMERROR) pErrorR3;
162 /** VM Runtime Error Message. */
163 R3PTRTYPE(PVMRUNTIMEERROR) pRuntimeErrorR3;
164 /** The VM was/is-being teleported and has not yet been fully resumed. */
165 bool fTeleportedAndNotFullyResumedYet;
166 /** The VM should power off instead of reset. */
167 bool fPowerOffInsteadOfReset;
168} VMINT;
169/** Pointer to the VM Internal Data (part of the VM structure). */
170typedef VMINT *PVMINT;
171
172
173#ifdef IN_RING3
174
175/**
176 * VM internal data kept in the UVM.
177 */
178typedef struct VMINTUSERPERVM
179{
180 /** Head of the standard request queue. Atomic. */
181 volatile PVMREQ pNormalReqs;
182 /** Head of the priority request queue. Atomic. */
183 volatile PVMREQ pPriorityReqs;
184 /** The last index used during alloc/free. */
185 volatile uint32_t iReqFree;
186 /** Number of free request packets. */
187 volatile uint32_t cReqFree;
188 /** Array of pointers to lists of free request packets. Atomic. */
189 volatile PVMREQ apReqFree[16 - (HC_ARCH_BITS == 32 ? 5 : 4)];
190
191 /** The reference count of the UVM handle. */
192 volatile uint32_t cUvmRefs;
193
194# ifdef VBOX_WITH_STATISTICS
195 /** Number of VMR3ReqAlloc returning a new packet. */
196 STAMCOUNTER StatReqAllocNew;
197 /** Number of VMR3ReqAlloc causing races. */
198 STAMCOUNTER StatReqAllocRaces;
199 /** Number of VMR3ReqAlloc returning a recycled packet. */
200 STAMCOUNTER StatReqAllocRecycled;
201 /** Number of VMR3ReqFree calls. */
202 STAMCOUNTER StatReqFree;
203 /** Number of times the request was actually freed. */
204 STAMCOUNTER StatReqFreeOverflow;
205 /** Number of requests served. */
206 STAMCOUNTER StatReqProcessed;
207 /** Number of times there are more than one request and the others needed to be
208 * pushed back onto the list. */
209 STAMCOUNTER StatReqMoreThan1;
210 /** Number of times we've raced someone when pushing the other requests back
211 * onto the list. */
212 STAMCOUNTER StatReqPushBackRaces;
213# endif
214
215 /** Pointer to the support library session.
216 * Mainly for creation and destruction. */
217 PSUPDRVSESSION pSession;
218
219 /** Force EMT to terminate. */
220 bool volatile fTerminateEMT;
221
222 /** Critical section for pAtState and enmPrevVMState. */
223 RTCRITSECT AtStateCritSect;
224 /** List of registered state change callbacks. */
225 PVMATSTATE pAtState;
226 /** List of registered state change callbacks. */
227 PVMATSTATE *ppAtStateNext;
228 /** The previous VM state.
229 * This is mainly used for the 'Resetting' state, but may come in handy later
230 * and when debugging. */
231 VMSTATE enmPrevVMState;
232
233 /** Reason for the most recent suspend operation. */
234 VMSUSPENDREASON enmSuspendReason;
235 /** Reason for the most recent operation. */
236 VMRESUMEREASON enmResumeReason;
237
238 /** Critical section for pAtError and pAtRuntimeError. */
239 RTCRITSECT AtErrorCritSect;
240
241 /** List of registered error callbacks. */
242 PVMATERROR pAtError;
243 /** List of registered error callbacks. */
244 PVMATERROR *ppAtErrorNext;
245 /** The error message count.
246 * This is incremented every time an error is raised. */
247 uint32_t volatile cErrors;
248
249 /** The runtime error message count.
250 * This is incremented every time a runtime error is raised. */
251 uint32_t volatile cRuntimeErrors;
252 /** List of registered error callbacks. */
253 PVMATRUNTIMEERROR pAtRuntimeError;
254 /** List of registered error callbacks. */
255 PVMATRUNTIMEERROR *ppAtRuntimeErrorNext;
256
257 /** @name Generic Halt data
258 * @{
259 */
260 /** The current halt method.
261 * Can be selected by CFGM option 'VM/HaltMethod'. */
262 VMHALTMETHOD enmHaltMethod;
263 /** The index into g_aHaltMethods of the current halt method. */
264 uint32_t volatile iHaltMethod;
265 /** @} */
266
267 /** @todo Do NOT add new members here or reuse the current, we need to store the config for
268 * each halt method separately because we're racing on SMP guest rigs. */
269 union
270 {
271 /**
272 * Method 1 & 2 - Block whenever possible, and when lagging behind
273 * switch to spinning with regular blocking every 5-200ms (defaults)
274 * depending on the accumulated lag. The blocking interval is adjusted
275 * with the average oversleeping of the last 64 times.
276 *
277 * The difference between 1 and 2 is that we use native absolute
278 * time APIs for the blocking instead of the millisecond based IPRT
279 * interface.
280 */
281 struct
282 {
283 /** The max interval without blocking (when spinning). */
284 uint32_t u32MinBlockIntervalCfg;
285 /** The minimum interval between blocking (when spinning). */
286 uint32_t u32MaxBlockIntervalCfg;
287 /** The value to divide the current lag by to get the raw blocking interval (when spinning). */
288 uint32_t u32LagBlockIntervalDivisorCfg;
289 /** When to start spinning (lag / nano secs). */
290 uint32_t u32StartSpinningCfg;
291 /** When to stop spinning (lag / nano secs). */
292 uint32_t u32StopSpinningCfg;
293 } Method12;
294
295 /**
296 * The GVMM manages halted and waiting EMTs.
297 */
298 struct
299 {
300 /** The threshold between spinning and blocking. */
301 uint32_t cNsSpinBlockThresholdCfg;
302 } Global1;
303 } Halt;
304
305 /** Pointer to the DBGC instance data. */
306 void *pvDBGC;
307
308 /** TLS index for the VMINTUSERPERVMCPU pointer. */
309 RTTLS idxTLS;
310
311 /** The VM name. (Set after the config constructure has been called.) */
312 char *pszName;
313 /** The VM UUID. (Set after the config constructure has been called.) */
314 RTUUID Uuid;
315} VMINTUSERPERVM;
316# ifdef VBOX_WITH_STATISTICS
317AssertCompileMemberAlignment(VMINTUSERPERVM, StatReqAllocNew, 8);
318# endif
319
320/** Pointer to the VM internal data kept in the UVM. */
321typedef VMINTUSERPERVM *PVMINTUSERPERVM;
322
323
324/**
325 * VMCPU internal data kept in the UVM.
326 *
327 * Almost a copy of VMINTUSERPERVM. Separate data properly later on.
328 */
329typedef struct VMINTUSERPERVMCPU
330{
331 /** Head of the normal request queue. Atomic. */
332 volatile PVMREQ pNormalReqs;
333 /** Head of the priority request queue. Atomic. */
334 volatile PVMREQ pPriorityReqs;
335
336 /** The handle to the EMT thread. */
337 RTTHREAD ThreadEMT;
338 /** The native of the EMT thread. */
339 RTNATIVETHREAD NativeThreadEMT;
340 /** Wait event semaphore. */
341 RTSEMEVENT EventSemWait;
342 /** Wait/Idle indicator. */
343 bool volatile fWait;
344 /** Align the next bit. */
345 bool afAlignment[HC_ARCH_BITS == 32 ? 3 : 7];
346
347 /** @name Generic Halt data
348 * @{
349 */
350 /** The average time (ns) between two halts in the last second. (updated once per second) */
351 uint32_t HaltInterval;
352 /** The average halt frequency for the last second. (updated once per second) */
353 uint32_t HaltFrequency;
354 /** The number of halts in the current period. */
355 uint32_t cHalts;
356 uint32_t padding; /**< alignment padding. */
357 /** When we started counting halts in cHalts (RTTimeNanoTS). */
358 uint64_t u64HaltsStartTS;
359 /** @} */
360
361 /** Union containing data and config for the different halt algorithms. */
362 union
363 {
364 /**
365 * Method 1 & 2 - Block whenever possible, and when lagging behind
366 * switch to spinning with regular blocking every 5-200ms (defaults)
367 * depending on the accumulated lag. The blocking interval is adjusted
368 * with the average oversleeping of the last 64 times.
369 *
370 * The difference between 1 and 2 is that we use native absolute
371 * time APIs for the blocking instead of the millisecond based IPRT
372 * interface.
373 */
374 struct
375 {
376 /** How many times we've blocked while cBlockedNS and cBlockedTooLongNS has been accumulating. */
377 uint32_t cBlocks;
378 /** Align the next member. */
379 uint32_t u32Alignment;
380 /** Avg. time spend oversleeping when blocking. (Re-calculated every so often.) */
381 uint64_t cNSBlockedTooLongAvg;
382 /** Total time spend oversleeping when blocking. */
383 uint64_t cNSBlockedTooLong;
384 /** Total time spent blocking. */
385 uint64_t cNSBlocked;
386 /** The timestamp (RTTimeNanoTS) of the last block. */
387 uint64_t u64LastBlockTS;
388
389 /** When we started spinning relentlessly in order to catch up some of the oversleeping.
390 * This is 0 when we're not spinning. */
391 uint64_t u64StartSpinTS;
392 } Method12;
393
394# if 0
395 /**
396 * Method 3 & 4 - Same as method 1 & 2 respectivly, except that we
397 * sprinkle it with yields.
398 */
399 struct
400 {
401 /** How many times we've blocked while cBlockedNS and cBlockedTooLongNS has been accumulating. */
402 uint32_t cBlocks;
403 /** Avg. time spend oversleeping when blocking. (Re-calculated every so often.) */
404 uint64_t cBlockedTooLongNSAvg;
405 /** Total time spend oversleeping when blocking. */
406 uint64_t cBlockedTooLongNS;
407 /** Total time spent blocking. */
408 uint64_t cBlockedNS;
409 /** The timestamp (RTTimeNanoTS) of the last block. */
410 uint64_t u64LastBlockTS;
411
412 /** How many times we've yielded while cBlockedNS and cBlockedTooLongNS has been accumulating. */
413 uint32_t cYields;
414 /** Avg. time spend oversleeping when yielding. */
415 uint32_t cYieldTooLongNSAvg;
416 /** Total time spend oversleeping when yielding. */
417 uint64_t cYieldTooLongNS;
418 /** Total time spent yielding. */
419 uint64_t cYieldedNS;
420 /** The timestamp (RTTimeNanoTS) of the last block. */
421 uint64_t u64LastYieldTS;
422
423 /** When we started spinning relentlessly in order to catch up some of the oversleeping. */
424 uint64_t u64StartSpinTS;
425 } Method34;
426# endif
427 } Halt;
428
429 /** Profiling the halted state; yielding vs blocking.
430 * @{ */
431 STAMPROFILE StatHaltYield;
432 STAMPROFILE StatHaltBlock;
433 STAMPROFILE StatHaltBlockOverslept;
434 STAMPROFILE StatHaltBlockInsomnia;
435 STAMPROFILE StatHaltBlockOnTime;
436 STAMPROFILE StatHaltTimers;
437 STAMPROFILE StatHaltPoll;
438 /** @} */
439} VMINTUSERPERVMCPU;
440AssertCompileMemberAlignment(VMINTUSERPERVMCPU, u64HaltsStartTS, 8);
441AssertCompileMemberAlignment(VMINTUSERPERVMCPU, Halt.Method12.cNSBlockedTooLongAvg, 8);
442AssertCompileMemberAlignment(VMINTUSERPERVMCPU, StatHaltYield, 8);
443
444/** Pointer to the VM internal data kept in the UVM. */
445typedef VMINTUSERPERVMCPU *PVMINTUSERPERVMCPU;
446
447#endif /* IN_RING3 */
448
449RT_C_DECLS_BEGIN
450
451DECLCALLBACK(int) vmR3EmulationThread(RTTHREAD ThreadSelf, void *pvArg);
452int vmR3SetHaltMethodU(PUVM pUVM, VMHALTMETHOD enmHaltMethod);
453DECLCALLBACK(int) vmR3Destroy(PVM pVM);
454DECLCALLBACK(void) vmR3SetErrorUV(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list *args);
455void vmSetErrorCopy(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args);
456DECLCALLBACK(int) vmR3SetRuntimeError(PVM pVM, uint32_t fFlags, const char *pszErrorId, char *pszMessage);
457DECLCALLBACK(int) vmR3SetRuntimeErrorV(PVM pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list *pVa);
458void vmSetRuntimeErrorCopy(PVM pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va);
459void vmR3SetGuruMeditation(PVM pVM);
460void vmR3SetTerminated(PVM pVM);
461
462RT_C_DECLS_END
463
464
465/** @} */
466
467#endif
468
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