vmm.h@ 67987

Last change on this file since 67987 was 67983, checked in by vboxsync, 7 years ago
VMMR0OPERATION: Spread the enum values out so we can safely add new ones without worrying about temporary effects of skews. Hope the compilers doesn't generate too terrible switch code now...
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.8 KB

Line
1	/** @file
2	* VMM - The Virtual Machine Monitor.
3	*/
4
5	/*
6	* Copyright (C) 2006-2016 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_vmm_vmm_h
27	#define ___VBox_vmm_vmm_h
28
29	#include <VBox/types.h>
30	#include <VBox/vmm/vmapi.h>
31	#include <VBox/sup.h>
32	#include <VBox/log.h>
33	#include <iprt/stdarg.h>
34	#include <iprt/thread.h>
35
36	RT_C_DECLS_BEGIN
37
38	/** @defgroup grp_vmm The Virtual Machine Monitor
39	* @{
40	*/
41
42	/** @defgroup grp_vmm_api The Virtual Machine Monitor API
43	* @{
44	*/
45
46	/**
47	* World switcher identifiers.
48	*/
49	typedef enum VMMSWITCHER
50	{
51	/** The usual invalid 0. */
52	VMMSWITCHER_INVALID = 0,
53	/** Switcher for 32-bit host to 32-bit shadow paging. */
54	VMMSWITCHER_32_TO_32,
55	/** Switcher for 32-bit host paging to PAE shadow paging. */
56	VMMSWITCHER_32_TO_PAE,
57	/** Switcher for 32-bit host paging to AMD64 shadow paging. */
58	VMMSWITCHER_32_TO_AMD64,
59	/** Switcher for PAE host to 32-bit shadow paging. */
60	VMMSWITCHER_PAE_TO_32,
61	/** Switcher for PAE host to PAE shadow paging. */
62	VMMSWITCHER_PAE_TO_PAE,
63	/** Switcher for PAE host paging to AMD64 shadow paging. */
64	VMMSWITCHER_PAE_TO_AMD64,
65	/** Switcher for AMD64 host paging to 32-bit shadow paging. */
66	VMMSWITCHER_AMD64_TO_32,
67	/** Switcher for AMD64 host paging to PAE shadow paging. */
68	VMMSWITCHER_AMD64_TO_PAE,
69	/** Switcher for AMD64 host paging to AMD64 shadow paging. */
70	VMMSWITCHER_AMD64_TO_AMD64,
71	/** Stub switcher for 32-bit and PAE. */
72	VMMSWITCHER_X86_STUB,
73	/** Stub switcher for AMD64. */
74	VMMSWITCHER_AMD64_STUB,
75	/** Used to make a count for array declarations and suchlike. */
76	VMMSWITCHER_MAX,
77	/** The usual 32-bit paranoia. */
78	VMMSWITCHER_32BIT_HACK = 0x7fffffff
79	} VMMSWITCHER;
80
81
82	/**
83	* VMMRZCallRing3 operations.
84	*/
85	typedef enum VMMCALLRING3
86	{
87	/** Invalid operation. */
88	VMMCALLRING3_INVALID = 0,
89	/** Acquire the PDM lock. */
90	VMMCALLRING3_PDM_LOCK,
91	/** Acquire the critical section specified as argument. */
92	VMMCALLRING3_PDM_CRIT_SECT_ENTER,
93	/** Enter the R/W critical section (in argument) exclusively. */
94	VMMCALLRING3_PDM_CRIT_SECT_RW_ENTER_EXCL,
95	/** Enter the R/W critical section (in argument) shared. */
96	VMMCALLRING3_PDM_CRIT_SECT_RW_ENTER_SHARED,
97	/** Acquire the PGM lock. */
98	VMMCALLRING3_PGM_LOCK,
99	/** Grow the PGM shadow page pool. */
100	VMMCALLRING3_PGM_POOL_GROW,
101	/** Maps a chunk into ring-3. */
102	VMMCALLRING3_PGM_MAP_CHUNK,
103	/** Allocates more handy pages. */
104	VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES,
105	/** Allocates a large (2MB) page. */
106	VMMCALLRING3_PGM_ALLOCATE_LARGE_HANDY_PAGE,
107	/** Acquire the MM hypervisor heap lock. */
108	VMMCALLRING3_MMHYPER_LOCK,
109	/** Replay the REM handler notifications. */
110	VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS,
111	/** Flush the GC/R0 logger. */
112	VMMCALLRING3_VMM_LOGGER_FLUSH,
113	/** Set the VM error message. */
114	VMMCALLRING3_VM_SET_ERROR,
115	/** Set the VM runtime error message. */
116	VMMCALLRING3_VM_SET_RUNTIME_ERROR,
117	/** Signal a ring 0 assertion. */
118	VMMCALLRING3_VM_R0_ASSERTION,
119	/** Ring switch to force preemption. This is also used by PDMCritSect to
120	* handle VERR_INTERRUPTED in kernel context. */
121	VMMCALLRING3_VM_R0_PREEMPT,
122	/** Sync the FTM state with the standby node. */
123	VMMCALLRING3_FTM_SET_CHECKPOINT,
124	/** The usual 32-bit hack. */
125	VMMCALLRING3_32BIT_HACK = 0x7fffffff
126	} VMMCALLRING3;
127
128	/**
129	* VMMRZCallRing3 notification callback.
130	*
131	* @returns VBox status code.
132	* @param pVCpu The cross context virtual CPU structure.
133	* @param enmOperation The operation causing the ring-3 jump.
134	* @param pvUser The user argument.
135	*/
136	typedef DECLCALLBACK(int) FNVMMR0CALLRING3NOTIFICATION(PVMCPU pVCpu, VMMCALLRING3 enmOperation, void *pvUser);
137	/** Pointer to a FNRTMPNOTIFICATION(). */
138	typedef FNVMMR0CALLRING3NOTIFICATION *PFNVMMR0CALLRING3NOTIFICATION;
139
140	/**
141	* Rendezvous callback.
142	*
143	* @returns VBox strict status code - EM scheduling. Do not return
144	* informational status code other than the ones used by EM for
145	* scheduling.
146	*
147	* @param pVM The cross context VM structure.
148	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
149	* @param pvUser The user argument.
150	*/
151	typedef DECLCALLBACK(VBOXSTRICTRC) FNVMMEMTRENDEZVOUS(PVM pVM, PVMCPU pVCpu, void *pvUser);
152	/** Pointer to a rendezvous callback function. */
153	typedef FNVMMEMTRENDEZVOUS *PFNVMMEMTRENDEZVOUS;
154
155	/**
156	* Method table that the VMM uses to call back the user of the VMM.
157	*/
158	typedef struct VMM2USERMETHODS
159	{
160	/** Magic value (VMM2USERMETHODS_MAGIC). */
161	uint32_t u32Magic;
162	/** Structure version (VMM2USERMETHODS_VERSION). */
163	uint32_t u32Version;
164
165	/**
166	* Save the VM state.
167	*
168	* @returns VBox status code.
169	* @param pThis Pointer to the callback method table.
170	* @param pUVM The user mode VM handle.
171	*
172	* @remarks This member shall be set to NULL if the operation is not
173	* supported.
174	*/
175	DECLR3CALLBACKMEMBER(int, pfnSaveState,(PCVMM2USERMETHODS pThis, PUVM pUVM));
176	/** @todo Move pfnVMAtError and pfnCFGMConstructor here? */
177
178	/**
179	* EMT initialization notification callback.
180	*
181	* This is intended for doing per-thread initialization for EMTs (like COM
182	* init).
183	*
184	* @param pThis Pointer to the callback method table.
185	* @param pUVM The user mode VM handle.
186	* @param pUVCpu The user mode virtual CPU handle.
187	*
188	* @remarks This is optional and shall be set to NULL if not wanted.
189	*/
190	DECLR3CALLBACKMEMBER(void, pfnNotifyEmtInit,(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu));
191
192	/**
193	* EMT termination notification callback.
194	*
195	* This is intended for doing per-thread cleanups for EMTs (like COM).
196	*
197	* @param pThis Pointer to the callback method table.
198	* @param pUVM The user mode VM handle.
199	* @param pUVCpu The user mode virtual CPU handle.
200	*
201	* @remarks This is optional and shall be set to NULL if not wanted.
202	*/
203	DECLR3CALLBACKMEMBER(void, pfnNotifyEmtTerm,(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu));
204
205	/**
206	* PDM thread initialization notification callback.
207	*
208	* This is intended for doing per-thread initialization (like COM init).
209	*
210	* @param pThis Pointer to the callback method table.
211	* @param pUVM The user mode VM handle.
212	*
213	* @remarks This is optional and shall be set to NULL if not wanted.
214	*/
215	DECLR3CALLBACKMEMBER(void, pfnNotifyPdmtInit,(PCVMM2USERMETHODS pThis, PUVM pUVM));
216
217	/**
218	* EMT termination notification callback.
219	*
220	* This is intended for doing per-thread cleanups for EMTs (like COM).
221	*
222	* @param pThis Pointer to the callback method table.
223	* @param pUVM The user mode VM handle.
224	*
225	* @remarks This is optional and shall be set to NULL if not wanted.
226	*/
227	DECLR3CALLBACKMEMBER(void, pfnNotifyPdmtTerm,(PCVMM2USERMETHODS pThis, PUVM pUVM));
228
229	/**
230	* Notification callback that that a VM reset will be turned into a power off.
231	*
232	* @param pThis Pointer to the callback method table.
233	* @param pUVM The user mode VM handle.
234	*
235	* @remarks This is optional and shall be set to NULL if not wanted.
236	*/
237	DECLR3CALLBACKMEMBER(void, pfnNotifyResetTurnedIntoPowerOff,(PCVMM2USERMETHODS pThis, PUVM pUVM));
238
239	/** Magic value (VMM2USERMETHODS_MAGIC) marking the end of the structure. */
240	uint32_t u32EndMagic;
241	} VMM2USERMETHODS;
242
243	/** Magic value of the VMM2USERMETHODS (Franz Kafka). */
244	#define VMM2USERMETHODS_MAGIC UINT32_C(0x18830703)
245	/** The VMM2USERMETHODS structure version. */
246	#define VMM2USERMETHODS_VERSION UINT32_C(0x00020001)
247
248
249	/**
250	* Checks whether we've armed the ring-0 long jump machinery.
251	*
252	* @returns @c true / @c false
253	* @param a_pVCpu The caller's cross context virtual CPU structure.
254	* @thread EMT
255	* @sa VMMR0IsLongJumpArmed
256	*/
257	#ifdef IN_RING0
258	# define VMMIsLongJumpArmed(a_pVCpu) VMMR0IsLongJumpArmed(a_pVCpu)
259	#else
260	# define VMMIsLongJumpArmed(a_pVCpu) (false)
261	#endif
262
263
264	VMM_INT_DECL(RTRCPTR) VMMGetStackRC(PVMCPU pVCpu);
265	VMMDECL(VMCPUID) VMMGetCpuId(PVM pVM);
266	VMMDECL(PVMCPU) VMMGetCpu(PVM pVM);
267	VMMDECL(PVMCPU) VMMGetCpu0(PVM pVM);
268	VMMDECL(PVMCPU) VMMGetCpuById(PVM pVM, VMCPUID idCpu);
269	VMMR3DECL(PVMCPU) VMMR3GetCpuByIdU(PUVM pVM, VMCPUID idCpu);
270	VMM_INT_DECL(uint32_t) VMMGetSvnRev(void);
271	VMM_INT_DECL(VMMSWITCHER) VMMGetSwitcher(PVM pVM);
272	VMM_INT_DECL(bool) VMMIsInRing3Call(PVMCPU pVCpu);
273	VMM_INT_DECL(void) VMMTrashVolatileXMMRegs(void);
274	VMM_INT_DECL(int) VMMPatchHypercall(PVM pVM, void pvBuf, size_t cbBuf, size_t pcbWritten);
275	VMM_INT_DECL(void) VMMHypercallsEnable(PVMCPU pVCpu);
276	VMM_INT_DECL(void) VMMHypercallsDisable(PVMCPU pVCpu);
277
278
279	#if defined(IN_RING3) \|\| defined(DOXYGEN_RUNNING)
280	/** @defgroup grp_vmm_api_r3 The VMM Host Context Ring 3 API
281	* @{
282	*/
283	VMMR3_INT_DECL(int) VMMR3Init(PVM pVM);
284	VMMR3_INT_DECL(int) VMMR3InitR0(PVM pVM);
285	# ifdef VBOX_WITH_RAW_MODE
286	VMMR3_INT_DECL(int) VMMR3InitRC(PVM pVM);
287	# endif
288	VMMR3_INT_DECL(int) VMMR3InitCompleted(PVM pVM, VMINITCOMPLETED enmWhat);
289	VMMR3_INT_DECL(int) VMMR3Term(PVM pVM);
290	VMMR3_INT_DECL(void) VMMR3Relocate(PVM pVM, RTGCINTPTR offDelta);
291	VMMR3_INT_DECL(int) VMMR3UpdateLoggers(PVM pVM);
292	VMMR3DECL(const char *) VMMR3GetRZAssertMsg1(PVM pVM);
293	VMMR3DECL(const char *) VMMR3GetRZAssertMsg2(PVM pVM);
294	VMMR3_INT_DECL(int) VMMR3SelectSwitcher(PVM pVM, VMMSWITCHER enmSwitcher);
295	VMMR3_INT_DECL(RTR0PTR) VMMR3GetHostToGuestSwitcher(PVM pVM, VMMSWITCHER enmSwitcher);
296	VMMR3_INT_DECL(int) VMMR3HmRunGC(PVM pVM, PVMCPU pVCpu);
297	# ifdef VBOX_WITH_RAW_MODE
298	VMMR3_INT_DECL(int) VMMR3RawRunGC(PVM pVM, PVMCPU pVCpu);
299	VMMR3DECL(int) VMMR3ResumeHyper(PVM pVM, PVMCPU pVCpu);
300	VMMR3_INT_DECL(int) VMMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue);
301	VMMR3DECL(int) VMMR3CallRC(PVM pVM, RTRCPTR RCPtrEntry, unsigned cArgs, ...);
302	VMMR3DECL(int) VMMR3CallRCV(PVM pVM, RTRCPTR RCPtrEntry, unsigned cArgs, va_list args);
303	# endif
304	VMMR3DECL(int) VMMR3CallR0(PVM pVM, uint32_t uOperation, uint64_t u64Arg, PSUPVMMR0REQHDR pReqHdr);
305	VMMR3DECL(void) VMMR3FatalDump(PVM pVM, PVMCPU pVCpu, int rcErr);
306	VMMR3_INT_DECL(void) VMMR3YieldSuspend(PVM pVM);
307	VMMR3_INT_DECL(void) VMMR3YieldStop(PVM pVM);
308	VMMR3_INT_DECL(void) VMMR3YieldResume(PVM pVM);
309	VMMR3_INT_DECL(void) VMMR3SendStartupIpi(PVM pVM, VMCPUID idCpu, uint32_t uVector);
310	VMMR3_INT_DECL(void) VMMR3SendInitIpi(PVM pVM, VMCPUID idCpu);
311	VMMR3DECL(int) VMMR3RegisterPatchMemory(PVM pVM, RTGCPTR pPatchMem, unsigned cbPatchMem);
312	VMMR3DECL(int) VMMR3DeregisterPatchMemory(PVM pVM, RTGCPTR pPatchMem, unsigned cbPatchMem);
313	VMMR3DECL(int) VMMR3EmtRendezvous(PVM pVM, uint32_t fFlags, PFNVMMEMTRENDEZVOUS pfnRendezvous, void *pvUser);
314	/** @defgroup grp_VMMR3EmtRendezvous_fFlags VMMR3EmtRendezvous flags
315	* @{ */
316	/** Execution type mask. */
317	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK UINT32_C(0x00000007)
318	/** Invalid execution type. */
319	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_INVALID UINT32_C(0)
320	/** Let the EMTs execute the callback one by one (in no particular order).
321	* Recursion from within the callback possible. */
322	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_ONE_BY_ONE UINT32_C(1)
323	/** Let all the EMTs execute the callback at the same time.
324	* Cannot recurse from the callback. */
325	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE UINT32_C(2)
326	/** Only execute the callback on one EMT (no particular one).
327	* Recursion from within the callback possible. */
328	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE UINT32_C(3)
329	/** Let the EMTs execute the callback one by one in ascending order.
330	* Recursion from within the callback possible. */
331	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_ASCENDING UINT32_C(4)
332	/** Let the EMTs execute the callback one by one in descending order.
333	* Recursion from within the callback possible. */
334	#define VMMEMTRENDEZVOUS_FLAGS_TYPE_DESCENDING UINT32_C(5)
335	/** Stop after the first error.
336	* This is not valid for any execution type where more than one EMT is active
337	* at a time. */
338	#define VMMEMTRENDEZVOUS_FLAGS_STOP_ON_ERROR UINT32_C(0x00000008)
339	/** Use VMREQFLAGS_PRIORITY when contacting the EMTs. */
340	#define VMMEMTRENDEZVOUS_FLAGS_PRIORITY UINT32_C(0x00000010)
341	/** The valid flags. */
342	#define VMMEMTRENDEZVOUS_FLAGS_VALID_MASK UINT32_C(0x0000001f)
343	/** @} */
344	VMMR3_INT_DECL(int) VMMR3EmtRendezvousFF(PVM pVM, PVMCPU pVCpu);
345	VMMR3_INT_DECL(int) VMMR3ReadR0Stack(PVM pVM, VMCPUID idCpu, RTHCUINTPTR R0Addr, void *pvBuf, size_t cbRead);
346	/** @} */
347	#endif /* IN_RING3 */
348
349
350	/** @defgroup grp_vmm_api_r0 The VMM Host Context Ring 0 API
351	* @{
352	*/
353
354	/**
355	* The VMMR0Entry() codes.
356	*/
357	typedef enum VMMR0OPERATION
358	{
359	/** Run guest context. */
360	VMMR0_DO_RAW_RUN = SUP_VMMR0_DO_RAW_RUN,
361	/** Run guest code using the available hardware acceleration technology. */
362	VMMR0_DO_HM_RUN = SUP_VMMR0_DO_HM_RUN,
363	/** Official NOP that we use for profiling. */
364	VMMR0_DO_NOP = SUP_VMMR0_DO_NOP,
365	/** Official slow iocl NOP that we use for profiling. */
366	VMMR0_DO_SLOW_NOP,
367
368	/** Ask the GVMM to create a new VM. */
369	VMMR0_DO_GVMM_CREATE_VM = 32,
370	/** Ask the GVMM to destroy the VM. */
371	VMMR0_DO_GVMM_DESTROY_VM,
372	/** Call GVMMR0RegisterVCpu(). */
373	VMMR0_DO_GVMM_REGISTER_VMCPU,
374	/** Call GVMMR0DeregisterVCpu(). */
375	VMMR0_DO_GVMM_DEREGISTER_VMCPU,
376	/** Call GVMMR0SchedHalt(). */
377	VMMR0_DO_GVMM_SCHED_HALT,
378	/** Call GVMMR0SchedWakeUp(). */
379	VMMR0_DO_GVMM_SCHED_WAKE_UP,
380	/** Call GVMMR0SchedPoke(). */
381	VMMR0_DO_GVMM_SCHED_POKE,
382	/** Call GVMMR0SchedWakeUpAndPokeCpus(). */
383	VMMR0_DO_GVMM_SCHED_WAKE_UP_AND_POKE_CPUS,
384	/** Call GVMMR0SchedPoll(). */
385	VMMR0_DO_GVMM_SCHED_POLL,
386	/** Call GVMMR0QueryStatistics(). */
387	VMMR0_DO_GVMM_QUERY_STATISTICS,
388	/** Call GVMMR0ResetStatistics(). */
389	VMMR0_DO_GVMM_RESET_STATISTICS,
390
391	/** Call VMMR0 Per VM Init. */
392	VMMR0_DO_VMMR0_INIT = 64,
393	/** Call VMMR0 Per VM Termination. */
394	VMMR0_DO_VMMR0_TERM,
395
396	/** Setup the hardware accelerated raw-mode session. */
397	VMMR0_DO_HM_SETUP_VM = 128,
398	/** Attempt to enable or disable hardware accelerated raw-mode. */
399	VMMR0_DO_HM_ENABLE,
400
401	/** Call PGMR0PhysAllocateHandyPages(). */
402	VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES = 192,
403	/** Call PGMR0PhysFlushHandyPages(). */
404	VMMR0_DO_PGM_FLUSH_HANDY_PAGES,
405	/** Call PGMR0AllocateLargePage(). */
406	VMMR0_DO_PGM_ALLOCATE_LARGE_HANDY_PAGE,
407	/** Call PGMR0PhysSetupIommu(). */
408	VMMR0_DO_PGM_PHYS_SETUP_IOMMU,
409
410	/** Call GMMR0InitialReservation(). */
411	VMMR0_DO_GMM_INITIAL_RESERVATION = 256,
412	/** Call GMMR0UpdateReservation(). */
413	VMMR0_DO_GMM_UPDATE_RESERVATION,
414	/** Call GMMR0AllocatePages(). */
415	VMMR0_DO_GMM_ALLOCATE_PAGES,
416	/** Call GMMR0FreePages(). */
417	VMMR0_DO_GMM_FREE_PAGES,
418	/** Call GMMR0FreeLargePage(). */
419	VMMR0_DO_GMM_FREE_LARGE_PAGE,
420	/** Call GMMR0QueryHypervisorMemoryStatsReq(). */
421	VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS,
422	/** Call GMMR0QueryMemoryStatsReq(). */
423	VMMR0_DO_GMM_QUERY_MEM_STATS,
424	/** Call GMMR0BalloonedPages(). */
425	VMMR0_DO_GMM_BALLOONED_PAGES,
426	/** Call GMMR0MapUnmapChunk(). */
427	VMMR0_DO_GMM_MAP_UNMAP_CHUNK,
428	/** Call GMMR0SeedChunk(). */
429	VMMR0_DO_GMM_SEED_CHUNK,
430	/** Call GMMR0RegisterSharedModule. */
431	VMMR0_DO_GMM_REGISTER_SHARED_MODULE,
432	/** Call GMMR0UnregisterSharedModule. */
433	VMMR0_DO_GMM_UNREGISTER_SHARED_MODULE,
434	/** Call GMMR0ResetSharedModules. */
435	VMMR0_DO_GMM_RESET_SHARED_MODULES,
436	/** Call GMMR0CheckSharedModules. */
437	VMMR0_DO_GMM_CHECK_SHARED_MODULES,
438	/** Call GMMR0FindDuplicatePage. */
439	VMMR0_DO_GMM_FIND_DUPLICATE_PAGE,
440	/** Call GMMR0QueryStatistics(). */
441	VMMR0_DO_GMM_QUERY_STATISTICS,
442	/** Call GMMR0ResetStatistics(). */
443	VMMR0_DO_GMM_RESET_STATISTICS,
444
445	/** Call PDMR0DriverCallReqHandler. */
446	VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER = 320,
447	/** Call PDMR0DeviceCallReqHandler. */
448	VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER,
449
450	/** Calls function in the hypervisor.
451	* The caller must setup the hypervisor context so the call will be performed.
452	* The difference between VMMR0_DO_RUN_GC and this one is the handling of
453	* the return GC code. The return code will not be interpreted by this operation.
454	*/
455	VMMR0_DO_CALL_HYPERVISOR = 384,
456
457	/** Set a GVMM or GMM configuration value. */
458	VMMR0_DO_GCFGM_SET_VALUE = 400,
459	/** Query a GVMM or GMM configuration value. */
460	VMMR0_DO_GCFGM_QUERY_VALUE,
461
462	/** The start of the R0 service operations. */
463	VMMR0_DO_SRV_START = 448,
464	/** Call IntNetR0Open(). */
465	VMMR0_DO_INTNET_OPEN,
466	/** Call IntNetR0IfClose(). */
467	VMMR0_DO_INTNET_IF_CLOSE,
468	/** Call IntNetR0IfGetBufferPtrs(). */
469	VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS,
470	/** Call IntNetR0IfSetPromiscuousMode(). */
471	VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE,
472	/** Call IntNetR0IfSetMacAddress(). */
473	VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS,
474	/** Call IntNetR0IfSetActive(). */
475	VMMR0_DO_INTNET_IF_SET_ACTIVE,
476	/** Call IntNetR0IfSend(). */
477	VMMR0_DO_INTNET_IF_SEND,
478	/** Call IntNetR0IfWait(). */
479	VMMR0_DO_INTNET_IF_WAIT,
480	/** Call IntNetR0IfAbortWait(). */
481	VMMR0_DO_INTNET_IF_ABORT_WAIT,
482
483	/** Forward call to the PCI driver */
484	VMMR0_DO_PCIRAW_REQ = 512,
485
486	/** The end of the R0 service operations. */
487	VMMR0_DO_SRV_END,
488
489	/** Official call we use for testing Ring-0 APIs. */
490	VMMR0_DO_TESTS,
491	/** Test the 32->64 bits switcher. */
492	VMMR0_DO_TEST_SWITCHER3264,
493
494	/** The usual 32-bit type blow up. */
495	VMMR0_DO_32BIT_HACK = 0x7fffffff
496	} VMMR0OPERATION;
497
498
499	/**
500	* Request buffer for VMMR0_DO_GCFGM_SET_VALUE and VMMR0_DO_GCFGM_QUERY_VALUE.
501	* @todo Move got GCFGM.h when it's implemented.
502	*/
503	typedef struct GCFGMVALUEREQ
504	{
505	/** The request header.*/
506	SUPVMMR0REQHDR Hdr;
507	/** The support driver session handle. */
508	PSUPDRVSESSION pSession;
509	/** The value.
510	* This is input for the set request and output for the query. */
511	uint64_t u64Value;
512	/** The variable name.
513	* This is fixed sized just to make things simple for the mock-up. */
514	char szName[48];
515	} GCFGMVALUEREQ;
516	/** Pointer to a VMMR0_DO_GCFGM_SET_VALUE and VMMR0_DO_GCFGM_QUERY_VALUE request buffer.
517	* @todo Move got GCFGM.h when it's implemented.
518	*/
519	typedef GCFGMVALUEREQ *PGCFGMVALUEREQ;
520
521	#if defined(IN_RING0) \|\| defined(DOXYGEN_RUNNING)
522	VMMR0DECL(void) VMMR0EntryFast(PGVM pGVM, PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation);
523	VMMR0DECL(int) VMMR0EntryEx(PGVM pGVM, PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation,
524	PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION);
525	VMMR0_INT_DECL(int) VMMR0TermVM(PVM pVM, PGVM pGVM);
526	VMMR0_INT_DECL(bool) VMMR0IsLongJumpArmed(PVMCPU pVCpu);
527	VMMR0_INT_DECL(bool) VMMR0IsInRing3LongJump(PVMCPU pVCpu);
528	VMMR0_INT_DECL(int) VMMR0ThreadCtxHookCreateForEmt(PVMCPU pVCpu);
529	VMMR0_INT_DECL(void) VMMR0ThreadCtxHookDestroyForEmt(PVMCPU pVCpu);
530	VMMR0_INT_DECL(void) VMMR0ThreadCtxHookDisable(PVMCPU pVCpu);
531	VMMR0_INT_DECL(bool) VMMR0ThreadCtxHookIsEnabled(PVMCPU pVCpu);
532
533	# ifdef LOG_ENABLED
534	VMMR0_INT_DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu);
535	VMMR0_INT_DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu);
536	VMMR0_INT_DECL(bool) VMMR0IsLogFlushDisabled(PVMCPU pVCpu);
537	# else
538	# define VMMR0LogFlushDisable(pVCpu) do { } while(0)
539	# define VMMR0LogFlushEnable(pVCpu) do { } while(0)
540	# define VMMR0IsLogFlushDisabled(pVCpu) (true)
541	# endif /* LOG_ENABLED */
542	#endif /* IN_RING0 */
543
544	/** @} */
545
546
547	#if defined(IN_RC) \|\| defined(DOXYGEN_RUNNING)
548	/** @defgroup grp_vmm_api_rc The VMM Raw-Mode Context API
549	* @{
550	*/
551	VMMRCDECL(int) VMMRCEntry(PVM pVM, unsigned uOperation, unsigned uArg, ...);
552	VMMRCDECL(void) VMMRCGuestToHost(PVM pVM, int rc);
553	VMMRCDECL(void) VMMRCLogFlushIfFull(PVM pVM);
554	/** @} */
555	#endif /* IN_RC */
556
557	#if defined(IN_RC) \|\| defined(IN_RING0) \|\| defined(DOXYGEN_RUNNING)
558	/** @defgroup grp_vmm_api_rz The VMM Raw-Mode and Ring-0 Context API
559	* @{
560	*/
561	VMMRZDECL(int) VMMRZCallRing3(PVM pVM, PVMCPU pVCpu, VMMCALLRING3 enmOperation, uint64_t uArg);
562	VMMRZDECL(int) VMMRZCallRing3NoCpu(PVM pVM, VMMCALLRING3 enmOperation, uint64_t uArg);
563	VMMRZDECL(void) VMMRZCallRing3Disable(PVMCPU pVCpu);
564	VMMRZDECL(void) VMMRZCallRing3Enable(PVMCPU pVCpu);
565	VMMRZDECL(bool) VMMRZCallRing3IsEnabled(PVMCPU pVCpu);
566	VMMRZDECL(int) VMMRZCallRing3SetNotification(PVMCPU pVCpu, R0PTRTYPE(PFNVMMR0CALLRING3NOTIFICATION) pfnCallback, RTR0PTR pvUser);
567	VMMRZDECL(void) VMMRZCallRing3RemoveNotification(PVMCPU pVCpu);
568	VMMRZDECL(bool) VMMRZCallRing3IsNotificationSet(PVMCPU pVCpu);
569	/** @} */
570	#endif
571
572
573	/** @} */
574
575	/** @} */
576	RT_C_DECLS_END
577
578	#endif

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

source: vbox/trunk/include/VBox/vmm/vmm.h@ 67987

Download in other formats: