VMMInternal.h@ 25046

Last change on this file since 25046 was 24582, checked in by vboxsync, 15 years ago
VMM.cpp: Fix cleanup of the stack's guard pages so that we don't assert in PGM if VM creation fails before VMMR3InitFinalize.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 22.2 KB

Line
1	/* $Id: VMMInternal.h 24582 2009-11-11 14:38:34Z vboxsync $ */
2	/** @file
3	* VMM - 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 ___VMMInternal_h
23	#define ___VMMInternal_h
24
25	#include <VBox/cdefs.h>
26	#include <VBox/stam.h>
27	#include <VBox/log.h>
28	#include <iprt/critsect.h>
29
30
31	#if !defined(IN_VMM_R3) && !defined(IN_VMM_R0) && !defined(IN_VMM_RC)
32	# error "Not in VMM! This is an internal header!"
33	#endif
34
35
36	/** @defgroup grp_vmm_int Internals
37	* @ingroup grp_vmm
38	* @internal
39	* @{
40	*/
41
42	/** @def VBOX_WITH_RC_RELEASE_LOGGING
43	* Enables RC release logging. */
44	#define VBOX_WITH_RC_RELEASE_LOGGING
45
46	/** @def VBOX_WITH_R0_LOGGING
47	* Enables Ring-0 logging (non-release).
48	*
49	* Ring-0 logging isn't 100% safe yet (thread id reuse / process exit cleanup),
50	* so you have to sign up here by adding your defined(DEBUG_<userid>) to the
51	* #if, or by adding VBOX_WITH_R0_LOGGING to your LocalConfig.kmk.
52	*
53	* You might also wish to enable the AssertMsg1/2 overrides in VMMR0.cpp when
54	* enabling this.
55	*/
56	#if defined(DEBUG_sandervl) \|\| defined(DEBUG_frank) \|\| defined(DOXYGEN_RUNNING)
57	# define VBOX_WITH_R0_LOGGING
58	#endif
59
60	/** @def VBOX_STRICT_VMM_STACK
61	* Enables VMM stack guard pages to catch stack over- and underruns. */
62	#if defined(VBOX_STRICT) \|\| defined(DOXYGEN_RUNNING)
63	# define VBOX_STRICT_VMM_STACK
64	#endif
65
66
67	/**
68	* Converts a VMM pointer into a VM pointer.
69	* @returns Pointer to the VM structure the VMM is part of.
70	* @param pVMM Pointer to VMM instance data.
71	*/
72	#define VMM2VM(pVMM) ( (PVM)((char*)pVMM - pVMM->offVM) )
73
74
75	/**
76	* Switcher function, HC to RC.
77	*
78	* @param pVM The VM handle.
79	* @returns Return code indicating the action to take.
80	*/
81	typedef DECLASMTYPE(int) FNVMMSWITCHERHC(PVM pVM);
82	/** Pointer to switcher function. */
83	typedef FNVMMSWITCHERHC *PFNVMMSWITCHERHC;
84
85	/**
86	* Switcher function, RC to HC.
87	*
88	* @param rc VBox status code.
89	*/
90	typedef DECLASMTYPE(void) FNVMMSWITCHERRC(int rc);
91	/** Pointer to switcher function. */
92	typedef FNVMMSWITCHERRC *PFNVMMSWITCHERRC;
93
94
95	/**
96	* The ring-0 logger instance wrapper.
97	*
98	* We need to be able to find the VM handle from the logger instance, so we wrap
99	* it in this structure.
100	*/
101	typedef struct VMMR0LOGGER
102	{
103	/** Pointer to the VM handle. */
104	R0PTRTYPE(PVM) pVM;
105	/** Size of the allocated logger instance (Logger). */
106	uint32_t cbLogger;
107	/** Flag indicating whether we've create the logger Ring-0 instance yet. */
108	bool fCreated;
109	/** Flag indicating whether we've disabled flushing (world switch) or not. */
110	bool fFlushingDisabled;
111	/** Flag indicating whether we've registered the instance already. */
112	bool fRegistered;
113	bool a8Alignment;
114	/** The CPU ID. */
115	VMCPUID idCpu;
116	#if HC_ARCH_BITS == 64
117	uint32_t u32Alignment;
118	#endif
119	/** The ring-0 logger instance. This extends beyond the size. */
120	RTLOGGER Logger;
121	} VMMR0LOGGER;
122	/** Pointer to a ring-0 logger instance wrapper. */
123	typedef VMMR0LOGGER *PVMMR0LOGGER;
124
125
126	/**
127	* Jump buffer for the setjmp/longjmp like constructs used to
128	* quickly 'call' back into Ring-3.
129	*/
130	typedef struct VMMR0JMPBUF
131	{
132	/** Traditional jmp_buf stuff
133	* @{ */
134	#if HC_ARCH_BITS == 32
135	uint32_t ebx;
136	uint32_t esi;
137	uint32_t edi;
138	uint32_t ebp;
139	uint32_t esp;
140	uint32_t eip;
141	uint32_t eflags;
142	#endif
143	#if HC_ARCH_BITS == 64
144	uint64_t rbx;
145	# ifdef RT_OS_WINDOWS
146	uint64_t rsi;
147	uint64_t rdi;
148	# endif
149	uint64_t rbp;
150	uint64_t r12;
151	uint64_t r13;
152	uint64_t r14;
153	uint64_t r15;
154	uint64_t rsp;
155	uint64_t rip;
156	# ifdef RT_OS_WINDOWS
157	uint128_t xmm6;
158	uint128_t xmm7;
159	uint128_t xmm8;
160	uint128_t xmm9;
161	uint128_t xmm10;
162	uint128_t xmm11;
163	uint128_t xmm12;
164	uint128_t xmm13;
165	uint128_t xmm14;
166	uint128_t xmm15;
167	# endif
168	uint64_t rflags;
169	#endif
170	/** @} */
171
172	/** Flag that indicates that we've done a ring-3 call. */
173	bool fInRing3Call;
174	/** The number of bytes we've saved. */
175	uint32_t cbSavedStack;
176	/** Pointer to the buffer used to save the stack.
177	* This is assumed to be 8KB. */
178	RTR0PTR pvSavedStack;
179	/** Esp we we match against esp on resume to make sure the stack wasn't relocated. */
180	RTHCUINTREG SpCheck;
181	/** The esp we should resume execution with after the restore. */
182	RTHCUINTREG SpResume;
183	/** ESP/RSP at the time of the jump to ring 3. */
184	RTHCUINTREG SavedEsp;
185	/** EBP/RBP at the time of the jump to ring 3. */
186	RTHCUINTREG SavedEbp;
187
188	/** Stats: Max amount of stack used. */
189	uint32_t cbUsedMax;
190	/** Stats: Average stack usage. (Avg = cbUsedTotal / cUsedTotal) */
191	uint32_t cbUsedAvg;
192	/** Stats: Total amount of stack used. */
193	uint64_t cbUsedTotal;
194	/** Stats: Number of stack usages. */
195	uint64_t cUsedTotal;
196	} VMMR0JMPBUF;
197	/** Pointer to a ring-0 jump buffer. */
198	typedef VMMR0JMPBUF *PVMMR0JMPBUF;
199
200
201	/**
202	* VMM Data (part of VM)
203	*/
204	typedef struct VMM
205	{
206	/** Offset to the VM structure.
207	* See VMM2VM(). */
208	RTINT offVM;
209
210	/** @name World Switcher and Related
211	* @{
212	*/
213	/** Size of the core code. */
214	RTUINT cbCoreCode;
215	/** Physical address of core code. */
216	RTHCPHYS HCPhysCoreCode;
217	/** Pointer to core code ring-3 mapping - contiguous memory.
218	* At present this only means the context switcher code. */
219	RTR3PTR pvCoreCodeR3;
220	/** Pointer to core code ring-0 mapping - contiguous memory.
221	* At present this only means the context switcher code. */
222	RTR0PTR pvCoreCodeR0;
223	/** Pointer to core code guest context mapping. */
224	RTRCPTR pvCoreCodeRC;
225	RTRCPTR pRCPadding0; /*< Alignment padding /
226	#ifdef VBOX_WITH_NMI
227	/** The guest context address of the APIC (host) mapping. */
228	RTRCPTR GCPtrApicBase;
229	RTRCPTR pRCPadding1; /*< Alignment padding /
230	#endif
231	/** The current switcher.
232	* This will be set before the VMM is fully initialized. */
233	VMMSWITCHER enmSwitcher;
234	/** Flag to disable the switcher permanently (VMX) (boolean) */
235	bool fSwitcherDisabled;
236	/** Array of offsets to the different switchers within the core code. */
237	RTUINT aoffSwitchers[VMMSWITCHER_MAX];
238
239	/** Resume Guest Execution. See CPUMGCResumeGuest(). */
240	RTRCPTR pfnCPUMRCResumeGuest;
241	/** Resume Guest Execution in V86 mode. See CPUMGCResumeGuestV86(). */
242	RTRCPTR pfnCPUMRCResumeGuestV86;
243	/** Call Trampoline. See vmmGCCallTrampoline(). */
244	RTRCPTR pfnCallTrampolineRC;
245	/** Guest to host switcher entry point. */
246	RCPTRTYPE(PFNVMMSWITCHERRC) pfnGuestToHostRC;
247	/** Host to guest switcher entry point. */
248	R0PTRTYPE(PFNVMMSWITCHERHC) pfnHostToGuestR0;
249	/** @} */
250
251	/** @name Logging
252	* @{
253	*/
254	/** Size of the allocated logger instance (pRCLoggerRC/pRCLoggerR3). */
255	uint32_t cbRCLogger;
256	/** Pointer to the RC logger instance - RC Ptr.
257	* This is NULL if logging is disabled. */
258	RCPTRTYPE(PRTLOGGERRC) pRCLoggerRC;
259	/** Pointer to the GC logger instance - R3 Ptr.
260	* This is NULL if logging is disabled. */
261	R3PTRTYPE(PRTLOGGERRC) pRCLoggerR3;
262	/** Pointer to the GC release logger instance - R3 Ptr. */
263	R3PTRTYPE(PRTLOGGERRC) pRCRelLoggerR3;
264	/** Pointer to the GC release logger instance - RC Ptr. */
265	RCPTRTYPE(PRTLOGGERRC) pRCRelLoggerRC;
266	/** Size of the allocated release logger instance (pRCRelLoggerRC/pRCRelLoggerR3).
267	* This may differ from cbRCLogger. */
268	uint32_t cbRCRelLogger;
269	/** Whether log flushing has been disabled or not. */
270	bool fRCLoggerFlushingDisabled;
271	bool afAlignment[6]; /*< Alignment padding. /
272	/** @} */
273
274	/** Whether the stack guard pages have been stationed or not. */
275	bool fStackGuardsStationed;
276
277	/** The EMT yield timer. */
278	PTMTIMERR3 pYieldTimer;
279	/** The period to the next timeout when suspended or stopped.
280	* This is 0 when running. */
281	uint32_t cYieldResumeMillies;
282	/** The EMT yield timer interval (milliseconds). */
283	uint32_t cYieldEveryMillies;
284	/** The timestamp of the previous yield. (nano) */
285	uint64_t u64LastYield;
286
287	/** Critical section.
288	* Use for synchronizing all VCPUs
289	*/
290	RTCRITSECT CritSectSync;
291
292	/** @name EMT Rendezvous
293	* @{ */
294	/** Semaphore to wait on upon entering ordered execution. */
295	R3PTRTYPE(PRTSEMEVENT) pahEvtRendezvousEnterOrdered;
296	/** Semaphore to wait on upon entering for one-by-one execution. */
297	RTSEMEVENT hEvtRendezvousEnterOneByOne;
298	/** Semaphore to wait on upon entering for all-at-once execution. */
299	RTSEMEVENTMULTI hEvtMulRendezvousEnterAllAtOnce;
300	/** Semaphore to wait on when done. */
301	RTSEMEVENTMULTI hEvtMulRendezvousDone;
302	/** Semaphore the VMMR3EmtRendezvous caller waits on at the end. */
303	RTSEMEVENT hEvtRendezvousDoneCaller;
304	/** Callback. */
305	R3PTRTYPE(PFNVMMEMTRENDEZVOUS) volatile pfnRendezvous;
306	/** The user argument for the callback. */
307	RTR3PTR volatile pvRendezvousUser;
308	/** Flags. */
309	volatile uint32_t fRendezvousFlags;
310	/** The number of EMTs that has entered. */
311	volatile uint32_t cRendezvousEmtsEntered;
312	/** The number of EMTs that has done their job. */
313	volatile uint32_t cRendezvousEmtsDone;
314	/** The number of EMTs that has returned. */
315	volatile uint32_t cRendezvousEmtsReturned;
316	/** The status code. */
317	volatile int32_t i32RendezvousStatus;
318	/** Spin lock. */
319	volatile uint32_t u32RendezvousLock;
320	/** @} */
321
322	#if HC_ARCH_BITS == 32
323	uint32_t u32Alignment; /*< Alignment padding. /
324	#endif
325
326	/** Buffer for storing the standard assertion message for a ring-0 assertion.
327	* Used for saving the assertion message text for the release log and guru
328	* meditation dump. */
329	char szRing0AssertMsg1[512];
330	/** Buffer for storing the custom message for a ring-0 assertion. */
331	char szRing0AssertMsg2[256];
332
333	/** Number of VMMR0_DO_RUN_GC calls. */
334	STAMCOUNTER StatRunRC;
335
336	/** Statistics for each of the RC/R0 return codes.
337	* @{ */
338	STAMCOUNTER StatRZRetNormal;
339	STAMCOUNTER StatRZRetInterrupt;
340	STAMCOUNTER StatRZRetInterruptHyper;
341	STAMCOUNTER StatRZRetGuestTrap;
342	STAMCOUNTER StatRZRetRingSwitch;
343	STAMCOUNTER StatRZRetRingSwitchInt;
344	STAMCOUNTER StatRZRetStaleSelector;
345	STAMCOUNTER StatRZRetIRETTrap;
346	STAMCOUNTER StatRZRetEmulate;
347	STAMCOUNTER StatRZRetIOBlockEmulate;
348	STAMCOUNTER StatRZRetPatchEmulate;
349	STAMCOUNTER StatRZRetIORead;
350	STAMCOUNTER StatRZRetIOWrite;
351	STAMCOUNTER StatRZRetMMIORead;
352	STAMCOUNTER StatRZRetMMIOWrite;
353	STAMCOUNTER StatRZRetMMIOPatchRead;
354	STAMCOUNTER StatRZRetMMIOPatchWrite;
355	STAMCOUNTER StatRZRetMMIOReadWrite;
356	STAMCOUNTER StatRZRetLDTFault;
357	STAMCOUNTER StatRZRetGDTFault;
358	STAMCOUNTER StatRZRetIDTFault;
359	STAMCOUNTER StatRZRetTSSFault;
360	STAMCOUNTER StatRZRetPDFault;
361	STAMCOUNTER StatRZRetCSAMTask;
362	STAMCOUNTER StatRZRetSyncCR3;
363	STAMCOUNTER StatRZRetMisc;
364	STAMCOUNTER StatRZRetPatchInt3;
365	STAMCOUNTER StatRZRetPatchPF;
366	STAMCOUNTER StatRZRetPatchGP;
367	STAMCOUNTER StatRZRetPatchIretIRQ;
368	STAMCOUNTER StatRZRetRescheduleREM;
369	STAMCOUNTER StatRZRetToR3;
370	STAMCOUNTER StatRZRetTimerPending;
371	STAMCOUNTER StatRZRetInterruptPending;
372	STAMCOUNTER StatRZRetCallRing3;
373	STAMCOUNTER StatRZRetPATMDuplicateFn;
374	STAMCOUNTER StatRZRetPGMChangeMode;
375	STAMCOUNTER StatRZRetPendingRequest;
376	STAMCOUNTER StatRZRetPatchTPR;
377	STAMCOUNTER StatRZCallPDMLock;
378	STAMCOUNTER StatRZCallLogFlush;
379	STAMCOUNTER StatRZCallPDMQueueFlush;
380	STAMCOUNTER StatRZCallPGMPoolGrow;
381	STAMCOUNTER StatRZCallPGMMapChunk;
382	STAMCOUNTER StatRZCallPGMAllocHandy;
383	STAMCOUNTER StatRZCallRemReplay;
384	STAMCOUNTER StatRZCallVMSetError;
385	STAMCOUNTER StatRZCallVMSetRuntimeError;
386	STAMCOUNTER StatRZCallPGMLock;
387	/** @} */
388	} VMM;
389	/** Pointer to VMM. */
390	typedef VMM *PVMM;
391
392
393	/**
394	* VMMCPU Data (part of VMCPU)
395	*/
396	typedef struct VMMCPU
397	{
398	/** Offset to the VMCPU structure.
399	* See VMM2VMCPU(). */
400	RTINT offVMCPU;
401
402	/** The last RC/R0 return code. */
403	int32_t iLastGZRc;
404
405	/** VMM stack, pointer to the top of the stack in R3.
406	* Stack is allocated from the hypervisor heap and is page aligned
407	* and always writable in RC. */
408	R3PTRTYPE(uint8_t *) pbEMTStackR3;
409	/** Pointer to the bottom of the stack - needed for doing relocations. */
410	RCPTRTYPE(uint8_t *) pbEMTStackRC;
411	/** Pointer to the bottom of the stack - needed for doing relocations. */
412	RCPTRTYPE(uint8_t *) pbEMTStackBottomRC;
413
414	#ifdef LOG_ENABLED
415	/** Pointer to the R0 logger instance - R3 Ptr.
416	* This is NULL if logging is disabled. */
417	R3PTRTYPE(PVMMR0LOGGER) pR0LoggerR3;
418	/** Pointer to the R0 logger instance - R0 Ptr.
419	* This is NULL if logging is disabled. */
420	R0PTRTYPE(PVMMR0LOGGER) pR0LoggerR0;
421	#endif
422
423	/** @name Call Ring-3
424	* Formerly known as host calls.
425	* @{ */
426	/** The disable counter. */
427	uint32_t cCallRing3Disabled;
428	/** The pending operation. */
429	VMMCALLRING3 enmCallRing3Operation;
430	/** The result of the last operation. */
431	int32_t rcCallRing3;
432	#if HC_ARCH_BITS == 64
433	uint32_t padding;
434	#endif
435	/** The argument to the operation. */
436	uint64_t u64CallRing3Arg;
437	/** The Ring-0 jmp buffer. */
438	VMMR0JMPBUF CallRing3JmpBufR0;
439	/** @} */
440
441	} VMMCPU;
442	/** Pointer to VMMCPU. */
443	typedef VMMCPU *PVMMCPU;
444
445
446	/**
447	* The VMMGCEntry() codes.
448	*/
449	typedef enum VMMGCOPERATION
450	{
451	/** Do GC module init. */
452	VMMGC_DO_VMMGC_INIT = 1,
453
454	/** The first Trap testcase. */
455	VMMGC_DO_TESTCASE_TRAP_FIRST = 0x0dead000,
456	/** Trap 0 testcases, uArg selects the variation. */
457	VMMGC_DO_TESTCASE_TRAP_0 = VMMGC_DO_TESTCASE_TRAP_FIRST,
458	/** Trap 1 testcases, uArg selects the variation. */
459	VMMGC_DO_TESTCASE_TRAP_1,
460	/** Trap 2 testcases, uArg selects the variation. */
461	VMMGC_DO_TESTCASE_TRAP_2,
462	/** Trap 3 testcases, uArg selects the variation. */
463	VMMGC_DO_TESTCASE_TRAP_3,
464	/** Trap 4 testcases, uArg selects the variation. */
465	VMMGC_DO_TESTCASE_TRAP_4,
466	/** Trap 5 testcases, uArg selects the variation. */
467	VMMGC_DO_TESTCASE_TRAP_5,
468	/** Trap 6 testcases, uArg selects the variation. */
469	VMMGC_DO_TESTCASE_TRAP_6,
470	/** Trap 7 testcases, uArg selects the variation. */
471	VMMGC_DO_TESTCASE_TRAP_7,
472	/** Trap 8 testcases, uArg selects the variation. */
473	VMMGC_DO_TESTCASE_TRAP_8,
474	/** Trap 9 testcases, uArg selects the variation. */
475	VMMGC_DO_TESTCASE_TRAP_9,
476	/** Trap 0a testcases, uArg selects the variation. */
477	VMMGC_DO_TESTCASE_TRAP_0A,
478	/** Trap 0b testcases, uArg selects the variation. */
479	VMMGC_DO_TESTCASE_TRAP_0B,
480	/** Trap 0c testcases, uArg selects the variation. */
481	VMMGC_DO_TESTCASE_TRAP_0C,
482	/** Trap 0d testcases, uArg selects the variation. */
483	VMMGC_DO_TESTCASE_TRAP_0D,
484	/** Trap 0e testcases, uArg selects the variation. */
485	VMMGC_DO_TESTCASE_TRAP_0E,
486	/** The last trap testcase (exclusive). */
487	VMMGC_DO_TESTCASE_TRAP_LAST,
488	/** Testcase for checking interrupt forwarding. */
489	VMMGC_DO_TESTCASE_HYPER_INTERRUPT,
490	/** Switching testing and profiling stub. */
491	VMMGC_DO_TESTCASE_NOP,
492	/** Testcase for checking interrupt masking.. */
493	VMMGC_DO_TESTCASE_INTERRUPT_MASKING,
494	/** Switching testing and profiling stub. */
495	VMMGC_DO_TESTCASE_HWACCM_NOP,
496
497	/** The usual 32-bit hack. */
498	VMMGC_DO_32_BIT_HACK = 0x7fffffff
499	} VMMGCOPERATION;
500
501
502	RT_C_DECLS_BEGIN
503
504	#ifdef IN_RING3
505	int vmmR3SwitcherInit(PVM pVM);
506	void vmmR3SwitcherRelocate(PVM pVM, RTGCINTPTR offDelta);
507	#endif /* IN_RING3 */
508
509	#ifdef IN_RING0
510	/**
511	* World switcher assembly routine.
512	* It will call VMMGCEntry().
513	*
514	* @returns return code from VMMGCEntry().
515	* @param pVM The VM in question.
516	* @param uArg See VMMGCEntry().
517	* @internal
518	*/
519	DECLASM(int) vmmR0WorldSwitch(PVM pVM, unsigned uArg);
520
521	/**
522	* Callback function for vmmR0CallRing3SetJmp.
523	*
524	* @returns VBox status code.
525	* @param pVM The VM handle.
526	*/
527	typedef DECLCALLBACK(int) FNVMMR0SETJMP(PVM pVM, PVMCPU pVCpu);
528	/** Pointer to FNVMMR0SETJMP(). */
529	typedef FNVMMR0SETJMP *PFNVMMR0SETJMP;
530
531	/**
532	* The setjmp variant used for calling Ring-3.
533	*
534	* This differs from the normal setjmp in that it will resume VMMRZCallRing3 if we're
535	* in the middle of a ring-3 call. Another differences is the function pointer and
536	* argument. This has to do with resuming code and the stack frame of the caller.
537	*
538	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
539	* @param pJmpBuf The jmp_buf to set.
540	* @param pfn The function to be called when not resuming..
541	* @param pVM The argument of that function.
542	*/
543	DECLASM(int) vmmR0CallRing3SetJmp(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMP pfn, PVM pVM, PVMCPU pVCpu);
544
545	/**
546	* Callback function for vmmR0CallRing3SetJmpEx.
547	*
548	* @returns VBox status code.
549	* @param pvUser The user argument.
550	*/
551	typedef DECLCALLBACK(int) FNVMMR0SETJMPEX(void *pvUser);
552	/** Pointer to FNVMMR0SETJMP(). */
553	typedef FNVMMR0SETJMPEX *PFNVMMR0SETJMPEX;
554
555	/**
556	* Same as vmmR0CallRing3SetJmp except for the function signature.
557	*
558	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
559	* @param pJmpBuf The jmp_buf to set.
560	* @param pfn The function to be called when not resuming..
561	* @param pvUser The argument of that function.
562	*/
563	DECLASM(int) vmmR0CallRing3SetJmpEx(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMPEX pfn, void *pvUser);
564
565
566	/**
567	* Worker for VMMRZCallRing3.
568	* This will save the stack and registers.
569	*
570	* @returns rc.
571	* @param pJmpBuf Pointer to the jump buffer.
572	* @param rc The return code.
573	*/
574	DECLASM(int) vmmR0CallRing3LongJmp(PVMMR0JMPBUF pJmpBuf, int rc);
575
576	/**
577	* Internal R0 logger worker: Logger wrapper.
578	*/
579	VMMR0DECL(void) vmmR0LoggerWrapper(const char *pszFormat, ...);
580
581	/**
582	* Internal R0 logger worker: Flush logger.
583	*
584	* @param pLogger The logger instance to flush.
585	* @remark This function must be exported!
586	*/
587	VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger);
588
589	/**
590	* Interal R0 logger worker: Custom prefix.
591	*
592	* @returns Number of chars written.
593	*
594	* @param pLogger The logger instance.
595	* @param pchBuf The output buffer.
596	* @param cchBuf The size of the buffer.
597	* @param pvUser User argument (ignored).
598	*/
599	VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char pchBuf, size_t cchBuf, void pvUser);
600
601	#endif /* IN_RING0 */
602	#ifdef IN_RC
603
604	/**
605	* Internal GC logger worker: Logger wrapper.
606	*/
607	VMMRCDECL(void) vmmGCLoggerWrapper(const char *pszFormat, ...);
608
609	/**
610	* Internal GC release logger worker: Logger wrapper.
611	*/
612	VMMRCDECL(void) vmmGCRelLoggerWrapper(const char *pszFormat, ...);
613
614	/**
615	* Internal GC logger worker: Flush logger.
616	*
617	* @returns VINF_SUCCESS.
618	* @param pLogger The logger instance to flush.
619	* @remark This function must be exported!
620	*/
621	VMMRCDECL(int) vmmGCLoggerFlush(PRTLOGGERRC pLogger);
622
623	/** @name Trap testcases and related labels.
624	* @{ */
625	DECLASM(void) vmmGCEnableWP(void);
626	DECLASM(void) vmmGCDisableWP(void);
627	DECLASM(int) vmmGCTestTrap3(void);
628	DECLASM(int) vmmGCTestTrap8(void);
629	DECLASM(int) vmmGCTestTrap0d(void);
630	DECLASM(int) vmmGCTestTrap0e(void);
631	DECLASM(int) vmmGCTestTrap0e_FaultEIP(void); /*< a label /
632	DECLASM(int) vmmGCTestTrap0e_ResumeEIP(void); /*< a label /
633	/** @} */
634
635	#endif /* IN_RC */
636
637	RT_C_DECLS_END
638
639	/** @} */
640
641	#endif

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

source: vbox/trunk/src/VBox/VMM/VMMInternal.h@ 25046

Download in other formats: