VMInternal.h@ 22980

Last change on this file since 22980 was 22980, checked in by vboxsync, 16 years ago
VM: added critsects around the At[State\|Reset\|Error\|RuntimeError] lists, one for the first two and one for the latter two. Will simplify the interfaces for registering / deregistering these in a bit and then move onto the state machinery.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 17.2 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: