VMInternal.h@ 27866

Last change on this file since 27866 was 24738, checked in by vboxsync, 15 years ago
VMReq.cpp: Made VMR3ReqProcessU re-entrant.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 16.6 KB

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

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

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

Download in other formats: