VMInternal.h@ 22937

Last change on this file since 22937 was 22937, checked in by vboxsync, 16 years ago
VMInternal.h: build fix.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 17.0 KB

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

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

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

Download in other formats: