vm.h@ 35184

Last change on this file since 35184 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.1 KB

Line
1	/** @file
2	* VM - The Virtual Machine, data. (VMM)
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*/
25
26	#ifndef ___VBox_vm_h
27	#define ___VBox_vm_h
28
29	#include <VBox/cdefs.h>
30	#include <VBox/types.h>
31	#include <VBox/cpum.h>
32	#include <VBox/stam.h>
33	#include <VBox/vmapi.h>
34	#include <VBox/sup.h>
35	#include <VBox/vmm.h>
36
37
38	/** @defgroup grp_vm The Virtual Machine
39	* @{
40	*/
41
42	/**
43	* The state of a Virtual CPU.
44	*
45	* The basic state indicated here is whether the CPU has been started or not. In
46	* addition, there are sub-states when started for assisting scheduling (GVMM
47	* mostly).
48	*
49	* The transision out of the STOPPED state is done by a vmR3PowerOn.
50	* The transision back to the STOPPED state is done by vmR3PowerOff.
51	*
52	* (Alternatively we could let vmR3PowerOn start CPU 0 only and let the SPIP
53	* handling switch on the other CPUs. Then vmR3Reset would stop all but CPU 0.)
54	*/
55	typedef enum VMCPUSTATE
56	{
57	/** The customary invalid zero. */
58	VMCPUSTATE_INVALID = 0,
59
60	/** Virtual CPU has not yet been started. */
61	VMCPUSTATE_STOPPED,
62
63	/** CPU started. */
64	VMCPUSTATE_STARTED,
65	/** Executing guest code and can be poked. */
66	VMCPUSTATE_STARTED_EXEC,
67	/** Executing guest code in the recompiler. */
68	VMCPUSTATE_STARTED_EXEC_REM,
69	/** Halted. */
70	VMCPUSTATE_STARTED_HALTED,
71
72	/** The end of valid virtual CPU states. */
73	VMCPUSTATE_END,
74
75	/** Ensure 32-bit type. */
76	VMCPUSTATE_32BIT_HACK = 0x7fffffff
77	} VMCPUSTATE;
78
79
80	/**
81	* Per virtual CPU data.
82	*/
83	typedef struct VMCPU
84	{
85	/** Per CPU forced action.
86	* See the VMCPU_FF_* \#defines. Updated atomically. */
87	uint32_t volatile fLocalForcedActions;
88	/** The CPU state. */
89	VMCPUSTATE volatile enmState;
90
91	/** Pointer to the ring-3 UVMCPU structure. */
92	PUVMCPU pUVCpu;
93	/** Ring-3 Host Context VM Pointer. */
94	PVMR3 pVMR3;
95	/** Ring-0 Host Context VM Pointer. */
96	PVMR0 pVMR0;
97	/** Alignment padding. */
98	RTR0PTR pvR0Padding;
99	/** Raw-mode Context VM Pointer. */
100	PVMRC pVMRC;
101	/** The CPU ID.
102	* This is the index into the VM::aCpu array. */
103	VMCPUID idCpu;
104	/** The native thread handle. */
105	RTNATIVETHREAD hNativeThread;
106	/** The native R0 thread handle. (different from the R3 handle!) */
107	RTNATIVETHREAD hNativeThreadR0;
108	/** Which host CPU ID is this EMT running on.
109	* Only valid when in RC or HWACCMR0 with scheduling disabled. */
110	RTCPUID volatile idHostCpu;
111	/** State data for use by ad hoc profiling. */
112	uint32_t uAdHoc;
113	/** Profiling samples for use by ad hoc profiling. */
114	STAMPROFILEADV aStatAdHoc[8];
115
116	/** Align the next bit on a 64-byte boundary and make sure it starts at the same
117	* offset in both 64-bit and 32-bit builds.
118	*
119	* @remarks The alignments of the members that are larger than 48 bytes should be
120	* 64-byte for cache line reasons. structs containing small amounts of
121	* data could be lumped together at the end with a < 64 byte padding
122	* following it (to grow into and align the struct size).
123	* */
124	uint8_t abAlignment1[HC_ARCH_BITS == 32 ? 16+64 : 56];
125
126	/** CPUM part. */
127	union
128	{
129	#ifdef ___CPUMInternal_h
130	struct CPUMCPU s;
131	#endif
132	uint8_t padding[3456]; /* multiple of 64 */
133	} cpum;
134
135	/** HWACCM part. */
136	union
137	{
138	#ifdef ___HWACCMInternal_h
139	struct HWACCMCPU s;
140	#endif
141	uint8_t padding[5312]; /* multiple of 64 */
142	} hwaccm;
143
144	/** EM part. */
145	union
146	{
147	#ifdef ___EMInternal_h
148	struct EMCPU s;
149	#endif
150	uint8_t padding[1472]; /* multiple of 64 */
151	} em;
152
153	/** TRPM part. */
154	union
155	{
156	#ifdef ___TRPMInternal_h
157	struct TRPMCPU s;
158	#endif
159	uint8_t padding[128]; /* multiple of 64 */
160	} trpm;
161
162	/** TM part. */
163	union
164	{
165	#ifdef ___TMInternal_h
166	struct TMCPU s;
167	#endif
168	uint8_t padding[384]; /* multiple of 64 */
169	} tm;
170
171	/** VMM part. */
172	union
173	{
174	#ifdef ___VMMInternal_h
175	struct VMMCPU s;
176	#endif
177	uint8_t padding[384]; /* multiple of 64 */
178	} vmm;
179
180	/** PDM part. */
181	union
182	{
183	#ifdef ___PDMInternal_h
184	struct PDMCPU s;
185	#endif
186	uint8_t padding[128]; /* multiple of 64 */
187	} pdm;
188
189	/** IOM part. */
190	union
191	{
192	#ifdef ___IOMInternal_h
193	struct IOMCPU s;
194	#endif
195	uint8_t padding[512]; /* multiple of 64 */
196	} iom;
197
198	/** DBGF part.
199	* @todo Combine this with other tiny structures. */
200	union
201	{
202	#ifdef ___DBGFInternal_h
203	struct DBGFCPU s;
204	#endif
205	uint8_t padding[64]; /* multiple of 64 */
206	} dbgf;
207
208	#if 0
209	/** Align the following members on page boundary. */
210	uint8_t abAlignment2[32];
211	#endif
212
213	/** PGM part. */
214	union
215	{
216	#ifdef ___PGMInternal_h
217	struct PGMCPU s;
218	#endif
219	uint8_t padding[4096]; /* multiple of 4096 */
220	} pgm;
221
222	} VMCPU;
223
224
225	/** @name Operations on VMCPU::enmState
226	* @{ */
227	/** Gets the VMCPU state. */
228	#define VMCPU_GET_STATE(pVCpu) ( (pVCpu)->enmState )
229	/** Sets the VMCPU state. */
230	#define VMCPU_SET_STATE(pVCpu, enmNewState) \
231	ASMAtomicWriteU32((uint32_t volatile *)&(pVCpu)->enmState, (enmNewState))
232	/** Cmpares and sets the VMCPU state. */
233	#define VMCPU_CMPXCHG_STATE(pVCpu, enmNewState, enmOldState) \
234	ASMAtomicCmpXchgU32((uint32_t volatile *)&(pVCpu)->enmState, (enmNewState), (enmOldState))
235	/** Checks the VMCPU state. */
236	#define VMCPU_ASSERT_STATE(pVCpu, enmExpectedState) \
237	do { \
238	VMCPUSTATE enmState = VMCPU_GET_STATE(pVCpu); \
239	AssertMsg(enmState == (enmExpectedState), \
240	("enmState=%d enmExpectedState=%d idCpu=%u\n", \
241	enmState, enmExpectedState, (pVCpu)->idCpu)); \
242	} while (0)
243	/** Tests if the state means that the CPU is started. */
244	#define VMCPUSTATE_IS_STARTED(enmState) ( (enmState) > VMCPUSTATE_STOPPED )
245	/** Tests if the state means that the CPU is stopped. */
246	#define VMCPUSTATE_IS_STOPPED(enmState) ( (enmState) == VMCPUSTATE_STOPPED )
247	/** @} */
248
249
250	/** The name of the Guest Context VMM Core module. */
251	#define VMMGC_MAIN_MODULE_NAME "VMMGC.gc"
252	/** The name of the Ring 0 Context VMM Core module. */
253	#define VMMR0_MAIN_MODULE_NAME "VMMR0.r0"
254
255	/** VM Forced Action Flags.
256	*
257	* Use the VM_FF_SET() and VM_FF_CLEAR() macros to change the force
258	* action mask of a VM.
259	*
260	* @{
261	*/
262	/** The virtual sync clock has been stopped, go to TM until it has been
263	* restarted... */
264	#define VM_FF_TM_VIRTUAL_SYNC RT_BIT_32(2)
265	/** PDM Queues are pending. */
266	#define VM_FF_PDM_QUEUES RT_BIT_32(VM_FF_PDM_QUEUES_BIT)
267	/** The bit number for VM_FF_PDM_QUEUES. */
268	#define VM_FF_PDM_QUEUES_BIT 3
269	/** PDM DMA transfers are pending. */
270	#define VM_FF_PDM_DMA RT_BIT_32(VM_FF_PDM_DMA_BIT)
271	/** The bit number for VM_FF_PDM_DMA. */
272	#define VM_FF_PDM_DMA_BIT 4
273	/** This action forces the VM to call DBGF so DBGF can service debugger
274	* requests in the emulation thread.
275	* This action flag stays asserted till DBGF clears it.*/
276	#define VM_FF_DBGF RT_BIT_32(VM_FF_DBGF_BIT)
277	/** The bit number for VM_FF_DBGF. */
278	#define VM_FF_DBGF_BIT 8
279	/** This action forces the VM to service pending requests from other
280	* thread or requests which must be executed in another context. */
281	#define VM_FF_REQUEST RT_BIT_32(9)
282	/** Check for VM state changes and take appropriate action. */
283	#define VM_FF_CHECK_VM_STATE RT_BIT_32(VM_FF_CHECK_VM_STATE_BIT)
284	/** The bit number for VM_FF_CHECK_VM_STATE. */
285	#define VM_FF_CHECK_VM_STATE_BIT 10
286	/** Reset the VM. (postponed) */
287	#define VM_FF_RESET RT_BIT_32(VM_FF_RESET_BIT)
288	/** The bit number for VM_FF_RESET. */
289	#define VM_FF_RESET_BIT 11
290	/** EMT rendezvous in VMM. */
291	#define VM_FF_EMT_RENDEZVOUS RT_BIT_32(VM_FF_EMT_RENDEZVOUS_BIT)
292	/** The bit number for VM_FF_EMT_RENDEZVOUS. */
293	#define VM_FF_EMT_RENDEZVOUS_BIT 12
294
295	/** PGM needs to allocate handy pages. */
296	#define VM_FF_PGM_NEED_HANDY_PAGES RT_BIT_32(18)
297	/** PGM is out of memory.
298	* Abandon all loops and code paths which can be resumed and get up to the EM
299	* loops. */
300	#define VM_FF_PGM_NO_MEMORY RT_BIT_32(19)
301	/** PGM is about to perform a lightweight pool flush
302	* Guest SMP: all EMT threads should return to ring 3
303	*/
304	#define VM_FF_PGM_POOL_FLUSH_PENDING RT_BIT_32(20)
305	/** REM needs to be informed about handler changes. */
306	#define VM_FF_REM_HANDLER_NOTIFY RT_BIT_32(VM_FF_REM_HANDLER_NOTIFY_BIT)
307	/** The bit number for VM_FF_REM_HANDLER_NOTIFY. */
308	#define VM_FF_REM_HANDLER_NOTIFY_BIT 29
309	/** Suspend the VM - debug only. */
310	#define VM_FF_DEBUG_SUSPEND RT_BIT_32(31)
311
312
313	/** This action forces the VM to check any pending interrups on the APIC. */
314	#define VMCPU_FF_INTERRUPT_APIC RT_BIT_32(0)
315	/** This action forces the VM to check any pending interrups on the PIC. */
316	#define VMCPU_FF_INTERRUPT_PIC RT_BIT_32(1)
317	/** This action forces the VM to schedule and run pending timer (TM).
318	* @remarks Don't move - PATM compatibility. */
319	#define VMCPU_FF_TIMER RT_BIT_32(2)
320	/** This action forces the VM to check any pending NMIs. */
321	#define VMCPU_FF_INTERRUPT_NMI_BIT 3
322	#define VMCPU_FF_INTERRUPT_NMI RT_BIT_32(VMCPU_FF_INTERRUPT_NMI_BIT)
323	/** This action forces the VM to check any pending SMIs. */
324	#define VMCPU_FF_INTERRUPT_SMI_BIT 4
325	#define VMCPU_FF_INTERRUPT_SMI RT_BIT_32(VMCPU_FF_INTERRUPT_SMI_BIT)
326	/** PDM critical section unlocking is pending, process promptly upon return to R3. */
327	#define VMCPU_FF_PDM_CRITSECT RT_BIT_32(5)
328	/** This action forces the VM to service pending requests from other
329	* thread or requests which must be executed in another context. */
330	#define VMCPU_FF_REQUEST RT_BIT_32(9)
331	/** This action forces the VM to resync the page tables before going
332	* back to execute guest code. (GLOBAL FLUSH) */
333	#define VMCPU_FF_PGM_SYNC_CR3 RT_BIT_32(16)
334	/** Same as VM_FF_PGM_SYNC_CR3 except that global pages can be skipped.
335	* (NON-GLOBAL FLUSH) */
336	#define VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL RT_BIT_32(17)
337	/** Check for pending TLB shootdown actions. */
338	#define VMCPU_FF_TLB_SHOOTDOWN RT_BIT_32(18)
339	/** Check for pending TLB flush action. */
340	#define VMCPU_FF_TLB_FLUSH RT_BIT_32(VMCPU_FF_TLB_FLUSH_BIT)
341	/** The bit number for VMCPU_FF_TLB_FLUSH. */
342	#define VMCPU_FF_TLB_FLUSH_BIT 19
343	/** Check the interrupt and trap gates */
344	#define VMCPU_FF_TRPM_SYNC_IDT RT_BIT_32(20)
345	/** Check Guest's TSS ring 0 stack */
346	#define VMCPU_FF_SELM_SYNC_TSS RT_BIT_32(21)
347	/** Check Guest's GDT table */
348	#define VMCPU_FF_SELM_SYNC_GDT RT_BIT_32(22)
349	/** Check Guest's LDT table */
350	#define VMCPU_FF_SELM_SYNC_LDT RT_BIT_32(23)
351	/** Inhibit interrupts pending. See EMGetInhibitInterruptsPC(). */
352	#define VMCPU_FF_INHIBIT_INTERRUPTS RT_BIT_32(24)
353	/** CSAM needs to scan the page that's being executed */
354	#define VMCPU_FF_CSAM_SCAN_PAGE RT_BIT_32(26)
355	/** CSAM needs to do some homework. */
356	#define VMCPU_FF_CSAM_PENDING_ACTION RT_BIT_32(27)
357	/** Force return to Ring-3. */
358	#define VMCPU_FF_TO_R3 RT_BIT_32(28)
359
360	/** Externally VM forced actions. Used to quit the idle/wait loop. */
361	#define VM_FF_EXTERNAL_SUSPENDED_MASK (VM_FF_CHECK_VM_STATE \| VM_FF_DBGF \| VM_FF_REQUEST \| VM_FF_EMT_RENDEZVOUS)
362	/** Externally VMCPU forced actions. Used to quit the idle/wait loop. */
363	#define VMCPU_FF_EXTERNAL_SUSPENDED_MASK (VMCPU_FF_REQUEST)
364
365	/** Externally forced VM actions. Used to quit the idle/wait loop. */
366	#define VM_FF_EXTERNAL_HALTED_MASK ( VM_FF_CHECK_VM_STATE \| VM_FF_DBGF \| VM_FF_REQUEST \
367	\| VM_FF_PDM_QUEUES \| VM_FF_PDM_DMA \| VM_FF_EMT_RENDEZVOUS)
368	/** Externally forced VMCPU actions. Used to quit the idle/wait loop. */
369	#define VMCPU_FF_EXTERNAL_HALTED_MASK (VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC \| VMCPU_FF_REQUEST \| VMCPU_FF_TIMER)
370
371	/** High priority VM pre-execution actions. */
372	#define VM_FF_HIGH_PRIORITY_PRE_MASK ( VM_FF_CHECK_VM_STATE \| VM_FF_DBGF \| VM_FF_TM_VIRTUAL_SYNC \
373	\| VM_FF_DEBUG_SUSPEND \| VM_FF_PGM_NEED_HANDY_PAGES \| VM_FF_PGM_NO_MEMORY \| VM_FF_EMT_RENDEZVOUS)
374	/** High priority VMCPU pre-execution actions. */
375	#define VMCPU_FF_HIGH_PRIORITY_PRE_MASK ( VMCPU_FF_TIMER \| VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC \| VMCPU_FF_PGM_SYNC_CR3 \
376	\| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL \| VMCPU_FF_SELM_SYNC_TSS \| VMCPU_FF_TRPM_SYNC_IDT \
377	\| VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_LDT \| VMCPU_FF_INHIBIT_INTERRUPTS)
378
379	/** High priority VM pre raw-mode execution mask. */
380	#define VM_FF_HIGH_PRIORITY_PRE_RAW_MASK (VM_FF_PGM_NEED_HANDY_PAGES \| VM_FF_PGM_NO_MEMORY)
381	/** High priority VMCPU pre raw-mode execution mask. */
382	#define VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK ( VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL \| VMCPU_FF_SELM_SYNC_TSS \| VMCPU_FF_TRPM_SYNC_IDT \
383	\| VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_LDT \| VMCPU_FF_INHIBIT_INTERRUPTS)
384
385	/** High priority post-execution actions. */
386	#define VM_FF_HIGH_PRIORITY_POST_MASK (VM_FF_PGM_NO_MEMORY)
387	/** High priority post-execution actions. */
388	#define VMCPU_FF_HIGH_PRIORITY_POST_MASK (VMCPU_FF_PDM_CRITSECT\|VMCPU_FF_CSAM_PENDING_ACTION)
389
390	/** Normal priority VM post-execution actions. */
391	#define VM_FF_NORMAL_PRIORITY_POST_MASK ( VM_FF_CHECK_VM_STATE \| VM_FF_DBGF \| VM_FF_RESET \
392	\| VM_FF_PGM_NO_MEMORY \| VM_FF_EMT_RENDEZVOUS)
393	/** Normal priority VMCPU post-execution actions. */
394	#define VMCPU_FF_NORMAL_PRIORITY_POST_MASK (VMCPU_FF_CSAM_SCAN_PAGE)
395
396	/** Normal priority VM actions. */
397	#define VM_FF_NORMAL_PRIORITY_MASK (VM_FF_REQUEST \| VM_FF_PDM_QUEUES \| VM_FF_PDM_DMA \| VM_FF_REM_HANDLER_NOTIFY \| VM_FF_EMT_RENDEZVOUS)
398	/** Normal priority VMCPU actions. */
399	#define VMCPU_FF_NORMAL_PRIORITY_MASK (VMCPU_FF_REQUEST)
400
401	/** Flags to clear before resuming guest execution. */
402	#define VMCPU_FF_RESUME_GUEST_MASK (VMCPU_FF_TO_R3)
403
404	/** VM Flags that cause the HWACCM loops to go back to ring-3. */
405	#define VM_FF_HWACCM_TO_R3_MASK (VM_FF_TM_VIRTUAL_SYNC \| VM_FF_PGM_NEED_HANDY_PAGES \| VM_FF_PGM_NO_MEMORY \| VM_FF_PDM_QUEUES \| VM_FF_EMT_RENDEZVOUS)
406	/** VMCPU Flags that cause the HWACCM loops to go back to ring-3. */
407	#define VMCPU_FF_HWACCM_TO_R3_MASK (VMCPU_FF_TO_R3 \| VMCPU_FF_TIMER)
408
409	/** All the forced VM flags. */
410	#define VM_FF_ALL_MASK (~0U)
411	/** All the forced VMCPU flags. */
412	#define VMCPU_FF_ALL_MASK (~0U)
413
414	/** All the forced VM flags. */
415	#define VM_FF_ALL_BUT_RAW_MASK (~(VM_FF_HIGH_PRIORITY_PRE_RAW_MASK) \| VM_FF_PGM_NO_MEMORY)
416	/** All the forced VMCPU flags. */
417	#define VMCPU_FF_ALL_BUT_RAW_MASK (~(VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK \| VMCPU_FF_CSAM_PENDING_ACTION \| VMCPU_FF_PDM_CRITSECT))
418
419	/** @} */
420
421	/** @def VM_FF_SET
422	* Sets a force action flag.
423	*
424	* @param pVM VM Handle.
425	* @param fFlag The flag to set.
426	*/
427	#if 1
428	# define VM_FF_SET(pVM, fFlag) ASMAtomicOrU32(&(pVM)->fGlobalForcedActions, (fFlag))
429	#else
430	# define VM_FF_SET(pVM, fFlag) \
431	do { ASMAtomicOrU32(&(pVM)->fGlobalForcedActions, (fFlag)); \
432	RTLogPrintf("VM_FF_SET : %08x %s - %s(%d) %s\n", (pVM)->fGlobalForcedActions, #fFlag, __FILE__, __LINE__, __FUNCTION__); \
433	} while (0)
434	#endif
435
436	/** @def VMCPU_FF_SET
437	* Sets a force action flag for the given VCPU.
438	*
439	* @param pVCpu VMCPU Handle.
440	* @param fFlag The flag to set.
441	*/
442	#define VMCPU_FF_SET(pVCpu, fFlag) ASMAtomicOrU32(&(pVCpu)->fLocalForcedActions, (fFlag))
443
444	/** @def VM_FF_CLEAR
445	* Clears a force action flag.
446	*
447	* @param pVM VM Handle.
448	* @param fFlag The flag to clear.
449	*/
450	#if 1
451	# define VM_FF_CLEAR(pVM, fFlag) ASMAtomicAndU32(&(pVM)->fGlobalForcedActions, ~(fFlag))
452	#else
453	# define VM_FF_CLEAR(pVM, fFlag) \
454	do { ASMAtomicAndU32(&(pVM)->fGlobalForcedActions, ~(fFlag)); \
455	RTLogPrintf("VM_FF_CLEAR: %08x %s - %s(%d) %s\n", (pVM)->fGlobalForcedActions, #fFlag, __FILE__, __LINE__, __FUNCTION__); \
456	} while (0)
457	#endif
458
459	/** @def VMCPU_FF_CLEAR
460	* Clears a force action flag for the given VCPU.
461	*
462	* @param pVCpu VMCPU Handle.
463	* @param fFlag The flag to clear.
464	*/
465	#define VMCPU_FF_CLEAR(pVCpu, fFlag) ASMAtomicAndU32(&(pVCpu)->fLocalForcedActions, ~(fFlag))
466
467	/** @def VM_FF_ISSET
468	* Checks if a force action flag is set.
469	*
470	* @param pVM VM Handle.
471	* @param fFlag The flag to check.
472	*/
473	#define VM_FF_ISSET(pVM, fFlag) (((pVM)->fGlobalForcedActions & (fFlag)) == (fFlag))
474
475	/** @def VMCPU_FF_ISSET
476	* Checks if a force action flag is set for the given VCPU.
477	*
478	* @param pVCpu VMCPU Handle.
479	* @param fFlag The flag to check.
480	*/
481	#define VMCPU_FF_ISSET(pVCpu, fFlag) (((pVCpu)->fLocalForcedActions & (fFlag)) == (fFlag))
482
483	/** @def VM_FF_ISPENDING
484	* Checks if one or more force action in the specified set is pending.
485	*
486	* @param pVM VM Handle.
487	* @param fFlags The flags to check for.
488	*/
489	#define VM_FF_ISPENDING(pVM, fFlags) ((pVM)->fGlobalForcedActions & (fFlags))
490
491	/** @def VM_FF_TESTANDCLEAR
492	* Checks if one (!) force action in the specified set is pending and clears it atomically
493	*
494	* @returns true if the bit was set.
495	* @returns false if the bit was clear.
496	* @param pVM VM Handle.
497	* @param iBit Bit position to check and clear
498	*/
499	#define VM_FF_TESTANDCLEAR(pVM, iBit) (ASMAtomicBitTestAndClear(&(pVM)->fGlobalForcedActions, iBit##_BIT))
500
501	/** @def VMCPU_FF_TESTANDCLEAR
502	* Checks if one (!) force action in the specified set is pending and clears it atomically
503	*
504	* @returns true if the bit was set.
505	* @returns false if the bit was clear.
506	* @param pVCpu VMCPU Handle.
507	* @param iBit Bit position to check and clear
508	*/
509	#define VMCPU_FF_TESTANDCLEAR(pVCpu, iBit) (ASMAtomicBitTestAndClear(&(pVCpu)->fLocalForcedActions, iBit##_BIT))
510
511	/** @def VMCPU_FF_ISPENDING
512	* Checks if one or more force action in the specified set is pending for the given VCPU.
513	*
514	* @param pVCpu VMCPU Handle.
515	* @param fFlags The flags to check for.
516	*/
517	#define VMCPU_FF_ISPENDING(pVCpu, fFlags) ((pVCpu)->fLocalForcedActions & (fFlags))
518
519	/** @def VM_FF_ISPENDING
520	* Checks if one or more force action in the specified set is pending while one
521	* or more other ones are not.
522	*
523	* @param pVM VM Handle.
524	* @param fFlags The flags to check for.
525	* @param fExcpt The flags that should not be set.
526	*/
527	#define VM_FF_IS_PENDING_EXCEPT(pVM, fFlags, fExcpt) ( ((pVM)->fGlobalForcedActions & (fFlags)) && !((pVM)->fGlobalForcedActions & (fExcpt)) )
528
529	/** @def VMCPU_FF_IS_PENDING_EXCEPT
530	* Checks if one or more force action in the specified set is pending for the given
531	* VCPU while one or more other ones are not.
532	*
533	* @param pVCpu VMCPU Handle.
534	* @param fFlags The flags to check for.
535	* @param fExcpt The flags that should not be set.
536	*/
537	#define VMCPU_FF_IS_PENDING_EXCEPT(pVCpu, fFlags, fExcpt) ( ((pVCpu)->fLocalForcedActions & (fFlags)) && !((pVCpu)->fLocalForcedActions & (fExcpt)) )
538
539	/** @def VM_IS_EMT
540	* Checks if the current thread is the emulation thread (EMT).
541	*
542	* @remark The ring-0 variation will need attention if we expand the ring-0
543	* code to let threads other than EMT mess around with the VM.
544	*/
545	#ifdef IN_RC
546	# define VM_IS_EMT(pVM) true
547	#else
548	# define VM_IS_EMT(pVM) (VMMGetCpu(pVM) != NULL)
549	#endif
550
551	/** @def VMCPU_IS_EMT
552	* Checks if the current thread is the emulation thread (EMT) for the specified
553	* virtual CPU.
554	*/
555	#ifdef IN_RC
556	# define VMCPU_IS_EMT(pVCpu) true
557	#else
558	# define VMCPU_IS_EMT(pVCpu) ((pVCpu) && ((pVCpu) == VMMGetCpu((pVCpu)->CTX_SUFF(pVM))))
559	#endif
560
561	/** @def VM_ASSERT_EMT
562	* Asserts that the current thread IS the emulation thread (EMT).
563	*/
564	#ifdef IN_RC
565	# define VM_ASSERT_EMT(pVM) Assert(VM_IS_EMT(pVM))
566	#elif defined(IN_RING0)
567	# define VM_ASSERT_EMT(pVM) Assert(VM_IS_EMT(pVM))
568	#else
569	# define VM_ASSERT_EMT(pVM) \
570	AssertMsg(VM_IS_EMT(pVM), \
571	("Not emulation thread! Thread=%RTnthrd ThreadEMT=%RTnthrd\n", RTThreadNativeSelf(), VMR3GetVMCPUNativeThread(pVM)))
572	#endif
573
574	/** @def VMCPU_ASSERT_EMT
575	* Asserts that the current thread IS the emulation thread (EMT) of the
576	* specified virtual CPU.
577	*/
578	#ifdef IN_RC
579	# define VMCPU_ASSERT_EMT(pVCpu) Assert(VMCPU_IS_EMT(pVCpu))
580	#elif defined(IN_RING0)
581	# define VMCPU_ASSERT_EMT(pVCpu) Assert(VMCPU_IS_EMT(pVCpu))
582	#else
583	# define VMCPU_ASSERT_EMT(pVCpu) \
584	AssertMsg(VMCPU_IS_EMT(pVCpu), \
585	("Not emulation thread! Thread=%RTnthrd ThreadEMT=%RTnthrd idCpu=%#x\n", \
586	RTThreadNativeSelf(), (pVCpu)->hNativeThread, (pVCpu)->idCpu))
587	#endif
588
589	/** @def VM_ASSERT_EMT_RETURN
590	* Asserts that the current thread IS the emulation thread (EMT) and returns if it isn't.
591	*/
592	#ifdef IN_RC
593	# define VM_ASSERT_EMT_RETURN(pVM, rc) AssertReturn(VM_IS_EMT(pVM), (rc))
594	#elif defined(IN_RING0)
595	# define VM_ASSERT_EMT_RETURN(pVM, rc) AssertReturn(VM_IS_EMT(pVM), (rc))
596	#else
597	# define VM_ASSERT_EMT_RETURN(pVM, rc) \
598	AssertMsgReturn(VM_IS_EMT(pVM), \
599	("Not emulation thread! Thread=%RTnthrd ThreadEMT=%RTnthrd\n", RTThreadNativeSelf(), VMR3GetVMCPUNativeThread(pVM)), \
600	(rc))
601	#endif
602
603	/** @def VMCPU_ASSERT_EMT_RETURN
604	* Asserts that the current thread IS the emulation thread (EMT) and returns if it isn't.
605	*/
606	#ifdef IN_RC
607	# define VMCPU_ASSERT_EMT_RETURN(pVCpu, rc) AssertReturn(VMCPU_IS_EMT(pVCpu), (rc))
608	#elif defined(IN_RING0)
609	# define VMCPU_ASSERT_EMT_RETURN(pVCpu, rc) AssertReturn(VMCPU_IS_EMT(pVCpu), (rc))
610	#else
611	# define VMCPU_ASSERT_EMT_RETURN(pVCpu, rc) \
612	AssertMsg(VMCPU_IS_EMT(pVCpu), \
613	("Not emulation thread! Thread=%RTnthrd ThreadEMT=%RTnthrd idCpu=%#x\n", \
614	RTThreadNativeSelf(), (pVCpu)->hNativeThread, (pVCpu)->idCpu), \
615	(rc))
616	#endif
617
618	/** @def VM_ASSERT_EMT0
619	* Asserts that the current thread IS emulation thread \#0 (EMT0).
620	*/
621	#define VM_ASSERT_EMT0(pVM) VMCPU_ASSERT_EMT(&(pVM)->aCpus[0])
622
623	/** @def VM_ASSERT_EMT0_RETURN
624	* Asserts that the current thread IS emulation thread \#0 (EMT0) and returns if
625	* it isn't.
626	*/
627	#define VM_ASSERT_EMT0_RETURN(pVM, rc) VMCPU_ASSERT_EMT_RETURN(&(pVM)->aCpus[0], (rc))
628
629
630	/**
631	* Asserts that the current thread is NOT the emulation thread.
632	*/
633	#define VM_ASSERT_OTHER_THREAD(pVM) \
634	AssertMsg(!VM_IS_EMT(pVM), ("Not other thread!!\n"))
635
636
637	/** @def VM_ASSERT_STATE_RETURN
638	* Asserts a certain VM state.
639	*/
640	#define VM_ASSERT_STATE(pVM, _enmState) \
641	AssertMsg((pVM)->enmVMState == (_enmState), \
642	("state %s, expected %s\n", VMGetStateName((pVM)->enmVMState), VMGetStateName(_enmState)))
643
644	/** @def VM_ASSERT_STATE_RETURN
645	* Asserts a certain VM state and returns if it doesn't match.
646	*/
647	#define VM_ASSERT_STATE_RETURN(pVM, _enmState, rc) \
648	AssertMsgReturn((pVM)->enmVMState == (_enmState), \
649	("state %s, expected %s\n", VMGetStateName((pVM)->enmVMState), VMGetStateName(_enmState)), \
650	(rc))
651
652	/** @def VM_ASSERT_VALID_EXT_RETURN
653	* Asserts a the VM handle is valid for external access, i.e. not being
654	* destroy or terminated.
655	*/
656	#define VM_ASSERT_VALID_EXT_RETURN(pVM, rc) \
657	AssertMsgReturn( RT_VALID_ALIGNED_PTR(pVM, PAGE_SIZE) \
658	&& ( (unsigned)(pVM)->enmVMState < (unsigned)VMSTATE_DESTROYING \
659	\|\| ( (unsigned)(pVM)->enmVMState == (unsigned)VMSTATE_DESTROYING \
660	&& VM_IS_EMT(pVM))), \
661	("pVM=%p state %s\n", (pVM), RT_VALID_ALIGNED_PTR(pVM, PAGE_SIZE) \
662	? VMGetStateName(pVM->enmVMState) : ""), \
663	(rc))
664
665	/** @def VMCPU_ASSERT_VALID_EXT_RETURN
666	* Asserts a the VMCPU handle is valid for external access, i.e. not being
667	* destroy or terminated.
668	*/
669	#define VMCPU_ASSERT_VALID_EXT_RETURN(pVCpu, rc) \
670	AssertMsgReturn( RT_VALID_ALIGNED_PTR(pVCpu, 64) \
671	&& RT_VALID_ALIGNED_PTR((pVCpu)->CTX_SUFF(pVM), PAGE_SIZE) \
672	&& (unsigned)(pVCpu)->CTX_SUFF(pVM)->enmVMState < (unsigned)VMSTATE_DESTROYING, \
673	("pVCpu=%p pVM=%p state %s\n", (pVCpu), RT_VALID_ALIGNED_PTR(pVCpu, 64) ? (pVCpu)->CTX_SUFF(pVM) : NULL, \
674	RT_VALID_ALIGNED_PTR(pVCpu, 64) && RT_VALID_ALIGNED_PTR((pVCpu)->CTX_SUFF(pVM), PAGE_SIZE) \
675	? VMGetStateName((pVCpu)->pVMR3->enmVMState) : ""), \
676	(rc))
677
678
679	/** This is the VM structure.
680	*
681	* It contains (nearly?) all the VM data which have to be available in all
682	* contexts. Even if it contains all the data the idea is to use APIs not
683	* to modify all the members all around the place. Therefore we make use of
684	* unions to hide everything which isn't local to the current source module.
685	* This means we'll have to pay a little bit of attention when adding new
686	* members to structures in the unions and make sure to keep the padding sizes
687	* up to date.
688	*
689	* Run tstVMStructSize after update!
690	*/
691	typedef struct VM
692	{
693	/** The state of the VM.
694	* This field is read only to everyone except the VM and EM. */
695	VMSTATE volatile enmVMState;
696	/** Forced action flags.
697	* See the VM_FF_* \#defines. Updated atomically.
698	*/
699	volatile uint32_t fGlobalForcedActions;
700	/** Pointer to the array of page descriptors for the VM structure allocation. */
701	R3PTRTYPE(PSUPPAGE) paVMPagesR3;
702	/** Session handle. For use when calling SUPR0 APIs. */
703	PSUPDRVSESSION pSession;
704	/** Pointer to the ring-3 VM structure. */
705	PUVM pUVM;
706	/** Ring-3 Host Context VM Pointer. */
707	R3PTRTYPE(struct VM *) pVMR3;
708	/** Ring-0 Host Context VM Pointer. */
709	R0PTRTYPE(struct VM *) pVMR0;
710	/** Raw-mode Context VM Pointer. */
711	RCPTRTYPE(struct VM *) pVMRC;
712
713	/** The GVM VM handle. Only the GVM should modify this field. */
714	uint32_t hSelf;
715	/** Number of virtual CPUs. */
716	uint32_t cCpus;
717	/** CPU excution cap (1-100) */
718	uint32_t uCpuExecutionCap;
719
720	/** Size of the VM structure including the VMCPU array. */
721	uint32_t cbSelf;
722
723	/** Offset to the VMCPU array starting from beginning of this structure. */
724	uint32_t offVMCPU;
725
726	/** Reserved; alignment. */
727	uint32_t u32Reserved[5];
728
729	/** @name Public VMM Switcher APIs
730	* @{ */
731	/**
732	* Assembly switch entry point for returning to host context.
733	* This function will clean up the stack frame.
734	*
735	* @param eax The return code, register.
736	* @param Ctx The guest core context.
737	* @remark Assume interrupts disabled.
738	*/
739	RTRCPTR pfnVMMGCGuestToHostAsmGuestCtx/(int32_t eax, CPUMCTXCORE Ctx)/;
740
741	/**
742	* Assembly switch entry point for returning to host context.
743	*
744	* This is an alternative entry point which we'll be using when the we have the
745	* hypervisor context and need to save that before going to the host.
746	*
747	* This is typically useful when abandoning the hypervisor because of a trap
748	* and want the trap state to be saved.
749	*
750	* @param eax The return code, register.
751	* @param ecx Pointer to the hypervisor core context, register.
752	* @remark Assume interrupts disabled.
753	*/
754	RTRCPTR pfnVMMGCGuestToHostAsmHyperCtx/(int32_t eax, PCPUMCTXCORE ecx)/;
755
756	/**
757	* Assembly switch entry point for returning to host context.
758	*
759	* This is an alternative to the two *Ctx APIs and implies that the context has already
760	* been saved, or that it's just a brief return to HC and that the caller intends to resume
761	* whatever it is doing upon 'return' from this call.
762	*
763	* @param eax The return code, register.
764	* @remark Assume interrupts disabled.
765	*/
766	RTRCPTR pfnVMMGCGuestToHostAsm/(int32_t eax)/;
767	/** @} */
768
769
770	/** @name Various VM data owned by VM.
771	* @{ */
772	RTTHREAD uPadding1;
773	/** The native handle of ThreadEMT. Getting the native handle
774	* is generally faster than getting the IPRT one (except on OS/2 :-). */
775	RTNATIVETHREAD uPadding2;
776	/** @} */
777
778
779	/** @name Various items that are frequently accessed.
780	* @{ */
781	/** Raw ring-3 indicator. */
782	bool fRawR3Enabled;
783	/** Raw ring-0 indicator. */
784	bool fRawR0Enabled;
785	/** PATM enabled flag.
786	* This is placed here for performance reasons. */
787	bool fPATMEnabled;
788	/** CSAM enabled flag.
789	* This is placed here for performance reasons. */
790	bool fCSAMEnabled;
791	/** Hardware VM support is available and enabled.
792	* This is placed here for performance reasons. */
793	bool fHWACCMEnabled;
794	/** Hardware VM support is required and non-optional.
795	* This is initialized together with the rest of the VM structure. */
796	bool fHwVirtExtForced;
797	/** Set when this VM is the master FT node. */
798	bool fFaultTolerantMaster;
799	/** Large page enabled flag. */
800	bool fUseLargePages;
801	/** @} */
802
803
804	/* padding to make gnuc put the StatQemuToGC where msc does. */
805	#if HC_ARCH_BITS == 32
806	uint32_t padding0;
807	#endif
808
809	/** Profiling the total time from Qemu to GC. */
810	STAMPROFILEADV StatTotalQemuToGC;
811	/** Profiling the total time from GC to Qemu. */
812	STAMPROFILEADV StatTotalGCToQemu;
813	/** Profiling the total time spent in GC. */
814	STAMPROFILEADV StatTotalInGC;
815	/** Profiling the total time spent not in Qemu. */
816	STAMPROFILEADV StatTotalInQemu;
817	/** Profiling the VMMSwitcher code for going to GC. */
818	STAMPROFILEADV StatSwitcherToGC;
819	/** Profiling the VMMSwitcher code for going to HC. */
820	STAMPROFILEADV StatSwitcherToHC;
821	STAMPROFILEADV StatSwitcherSaveRegs;
822	STAMPROFILEADV StatSwitcherSysEnter;
823	STAMPROFILEADV StatSwitcherDebug;
824	STAMPROFILEADV StatSwitcherCR0;
825	STAMPROFILEADV StatSwitcherCR4;
826	STAMPROFILEADV StatSwitcherJmpCR3;
827	STAMPROFILEADV StatSwitcherRstrRegs;
828	STAMPROFILEADV StatSwitcherLgdt;
829	STAMPROFILEADV StatSwitcherLidt;
830	STAMPROFILEADV StatSwitcherLldt;
831	STAMPROFILEADV StatSwitcherTSS;
832
833	/** Padding - the unions must be aligned on a 64 bytes boundary and the unions
834	* must start at the same offset on both 64-bit and 32-bit hosts. */
835	uint8_t abAlignment1[HC_ARCH_BITS == 32 ? 48 : 24];
836
837	/** CPUM part. */
838	union
839	{
840	#ifdef ___CPUMInternal_h
841	struct CPUM s;
842	#endif
843	uint8_t padding[1472]; /* multiple of 64 */
844	} cpum;
845
846	/** VMM part. */
847	union
848	{
849	#ifdef ___VMMInternal_h
850	struct VMM s;
851	#endif
852	uint8_t padding[1536]; /* multiple of 64 */
853	} vmm;
854
855	/** PGM part. */
856	union
857	{
858	#ifdef ___PGMInternal_h
859	struct PGM s;
860	#endif
861	uint8_t padding[40962+6080]; / multiple of 64 */
862	} pgm;
863
864	/** HWACCM part. */
865	union
866	{
867	#ifdef ___HWACCMInternal_h
868	struct HWACCM s;
869	#endif
870	uint8_t padding[5376]; /* multiple of 64 */
871	} hwaccm;
872
873	/** TRPM part. */
874	union
875	{
876	#ifdef ___TRPMInternal_h
877	struct TRPM s;
878	#endif
879	uint8_t padding[5184]; /* multiple of 64 */
880	} trpm;
881
882	/** SELM part. */
883	union
884	{
885	#ifdef ___SELMInternal_h
886	struct SELM s;
887	#endif
888	uint8_t padding[576]; /* multiple of 64 */
889	} selm;
890
891	/** MM part. */
892	union
893	{
894	#ifdef ___MMInternal_h
895	struct MM s;
896	#endif
897	uint8_t padding[192]; /* multiple of 64 */
898	} mm;
899
900	/** PDM part. */
901	union
902	{
903	#ifdef ___PDMInternal_h
904	struct PDM s;
905	#endif
906	uint8_t padding[1600]; /* multiple of 64 */
907	} pdm;
908
909	/** IOM part. */
910	union
911	{
912	#ifdef ___IOMInternal_h
913	struct IOM s;
914	#endif
915	uint8_t padding[832]; /* multiple of 64 */
916	} iom;
917
918	/** PATM part. */
919	union
920	{
921	#ifdef ___PATMInternal_h
922	struct PATM s;
923	#endif
924	uint8_t padding[768]; /* multiple of 64 */
925	} patm;
926
927	/** CSAM part. */
928	union
929	{
930	#ifdef ___CSAMInternal_h
931	struct CSAM s;
932	#endif
933	uint8_t padding[1088]; /* multiple of 64 */
934	} csam;
935
936	/** EM part. */
937	union
938	{
939	#ifdef ___EMInternal_h
940	struct EM s;
941	#endif
942	uint8_t padding[256]; /* multiple of 64 */
943	} em;
944
945	/** TM part. */
946	union
947	{
948	#ifdef ___TMInternal_h
949	struct TM s;
950	#endif
951	uint8_t padding[2176]; /* multiple of 64 */
952	} tm;
953
954	/** DBGF part. */
955	union
956	{
957	#ifdef ___DBGFInternal_h
958	struct DBGF s;
959	#endif
960	uint8_t padding[2368]; /* multiple of 64 */
961	} dbgf;
962
963	/** SSM part. */
964	union
965	{
966	#ifdef ___SSMInternal_h
967	struct SSM s;
968	#endif
969	uint8_t padding[128]; /* multiple of 64 */
970	} ssm;
971
972	/** FTM part. */
973	union
974	{
975	#ifdef ___FTMInternal_h
976	struct FTM s;
977	#endif
978	uint8_t padding[512]; /* multiple of 64 */
979	} ftm;
980
981	/** REM part. */
982	union
983	{
984	#ifdef ___REMInternal_h
985	struct REM s;
986	#endif
987	uint8_t padding[0x11100]; /* multiple of 64 */
988	} rem;
989
990	/* ---- begin small stuff ---- */
991
992	/** VM part. */
993	union
994	{
995	#ifdef ___VMInternal_h
996	struct VMINT s;
997	#endif
998	uint8_t padding[24]; /* multiple of 8 */
999	} vm;
1000
1001	/** CFGM part. */
1002	union
1003	{
1004	#ifdef ___CFGMInternal_h
1005	struct CFGM s;
1006	#endif
1007	uint8_t padding[8]; /* multiple of 8 */
1008	} cfgm;
1009
1010	/** Padding for aligning the cpu array on a page boundary. */
1011	uint8_t abAlignment2[1502];
1012
1013	/* ---- end small stuff ---- */
1014
1015	/** VMCPU array for the configured number of virtual CPUs.
1016	* Must be aligned on a page boundary for TLB hit reasons as well as
1017	* alignment of VMCPU members. */
1018	VMCPU aCpus[1];
1019	} VM;
1020
1021
1022	#ifdef IN_RC
1023	RT_C_DECLS_BEGIN
1024
1025	/** The VM structure.
1026	* This is imported from the VMMGCBuiltin module, i.e. it's a one
1027	* of those magic globals which we should avoid using.
1028	*/
1029	extern DECLIMPORT(VM) g_VM;
1030
1031	RT_C_DECLS_END
1032	#endif
1033
1034	/** @} */
1035
1036	#endif

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

source: vbox/trunk/include/VBox/vm.h@ 35184

Download in other formats: