VMMInternal.h@ 23794

Last change on this file since 23794 was 23487, checked in by vboxsync, 15 years ago
VMM: Saved and restore the [R\|E]FLAGS register in the cmmR3CallRing3SetJmp/Long code.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 22.1 KB

Line
1	/* $Id: VMMInternal.h 23487 2009-10-01 14:57:14Z 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[7]; /*< Alignment padding. /
272	/** @} */
273
274	/** The EMT yield timer. */
275	PTMTIMERR3 pYieldTimer;
276	/** The period to the next timeout when suspended or stopped.
277	* This is 0 when running. */
278	uint32_t cYieldResumeMillies;
279	/** The EMT yield timer interval (milliseconds). */
280	uint32_t cYieldEveryMillies;
281	/** The timestamp of the previous yield. (nano) */
282	uint64_t u64LastYield;
283
284	/** Critical section.
285	* Use for synchronizing all VCPUs
286	*/
287	RTCRITSECT CritSectSync;
288
289	/** @name EMT Rendezvous
290	* @{ */
291	/** Semaphore to wait on upon entering ordered execution. */
292	R3PTRTYPE(PRTSEMEVENT) pahEvtRendezvousEnterOrdered;
293	/** Semaphore to wait on upon entering for one-by-one execution. */
294	RTSEMEVENT hEvtRendezvousEnterOneByOne;
295	/** Semaphore to wait on upon entering for all-at-once execution. */
296	RTSEMEVENTMULTI hEvtMulRendezvousEnterAllAtOnce;
297	/** Semaphore to wait on when done. */
298	RTSEMEVENTMULTI hEvtMulRendezvousDone;
299	/** Semaphore the VMMR3EmtRendezvous caller waits on at the end. */
300	RTSEMEVENT hEvtRendezvousDoneCaller;
301	/** Callback. */
302	R3PTRTYPE(PFNVMMEMTRENDEZVOUS) volatile pfnRendezvous;
303	/** The user argument for the callback. */
304	RTR3PTR volatile pvRendezvousUser;
305	/** Flags. */
306	volatile uint32_t fRendezvousFlags;
307	/** The number of EMTs that has entered. */
308	volatile uint32_t cRendezvousEmtsEntered;
309	/** The number of EMTs that has done their job. */
310	volatile uint32_t cRendezvousEmtsDone;
311	/** The number of EMTs that has returned. */
312	volatile uint32_t cRendezvousEmtsReturned;
313	/** The status code. */
314	volatile int32_t i32RendezvousStatus;
315	/** Spin lock. */
316	volatile uint32_t u32RendezvousLock;
317	/** @} */
318
319	#if HC_ARCH_BITS == 32
320	uint32_t u32Alignment; /*< Alignment padding. /
321	#endif
322
323	/** Buffer for storing the standard assertion message for a ring-0 assertion.
324	* Used for saving the assertion message text for the release log and guru
325	* meditation dump. */
326	char szRing0AssertMsg1[512];
327	/** Buffer for storing the custom message for a ring-0 assertion. */
328	char szRing0AssertMsg2[256];
329
330	/** Number of VMMR0_DO_RUN_GC calls. */
331	STAMCOUNTER StatRunRC;
332
333	/** Statistics for each of the RC/R0 return codes.
334	* @{ */
335	STAMCOUNTER StatRZRetNormal;
336	STAMCOUNTER StatRZRetInterrupt;
337	STAMCOUNTER StatRZRetInterruptHyper;
338	STAMCOUNTER StatRZRetGuestTrap;
339	STAMCOUNTER StatRZRetRingSwitch;
340	STAMCOUNTER StatRZRetRingSwitchInt;
341	STAMCOUNTER StatRZRetStaleSelector;
342	STAMCOUNTER StatRZRetIRETTrap;
343	STAMCOUNTER StatRZRetEmulate;
344	STAMCOUNTER StatRZRetIOBlockEmulate;
345	STAMCOUNTER StatRZRetPatchEmulate;
346	STAMCOUNTER StatRZRetIORead;
347	STAMCOUNTER StatRZRetIOWrite;
348	STAMCOUNTER StatRZRetMMIORead;
349	STAMCOUNTER StatRZRetMMIOWrite;
350	STAMCOUNTER StatRZRetMMIOPatchRead;
351	STAMCOUNTER StatRZRetMMIOPatchWrite;
352	STAMCOUNTER StatRZRetMMIOReadWrite;
353	STAMCOUNTER StatRZRetLDTFault;
354	STAMCOUNTER StatRZRetGDTFault;
355	STAMCOUNTER StatRZRetIDTFault;
356	STAMCOUNTER StatRZRetTSSFault;
357	STAMCOUNTER StatRZRetPDFault;
358	STAMCOUNTER StatRZRetCSAMTask;
359	STAMCOUNTER StatRZRetSyncCR3;
360	STAMCOUNTER StatRZRetMisc;
361	STAMCOUNTER StatRZRetPatchInt3;
362	STAMCOUNTER StatRZRetPatchPF;
363	STAMCOUNTER StatRZRetPatchGP;
364	STAMCOUNTER StatRZRetPatchIretIRQ;
365	STAMCOUNTER StatRZRetRescheduleREM;
366	STAMCOUNTER StatRZRetToR3;
367	STAMCOUNTER StatRZRetTimerPending;
368	STAMCOUNTER StatRZRetInterruptPending;
369	STAMCOUNTER StatRZRetCallRing3;
370	STAMCOUNTER StatRZRetPATMDuplicateFn;
371	STAMCOUNTER StatRZRetPGMChangeMode;
372	STAMCOUNTER StatRZRetPendingRequest;
373	STAMCOUNTER StatRZRetPatchTPR;
374	STAMCOUNTER StatRZCallPDMLock;
375	STAMCOUNTER StatRZCallLogFlush;
376	STAMCOUNTER StatRZCallPDMQueueFlush;
377	STAMCOUNTER StatRZCallPGMPoolGrow;
378	STAMCOUNTER StatRZCallPGMMapChunk;
379	STAMCOUNTER StatRZCallPGMAllocHandy;
380	STAMCOUNTER StatRZCallRemReplay;
381	STAMCOUNTER StatRZCallVMSetError;
382	STAMCOUNTER StatRZCallVMSetRuntimeError;
383	STAMCOUNTER StatRZCallPGMLock;
384	/** @} */
385	} VMM;
386	/** Pointer to VMM. */
387	typedef VMM *PVMM;
388
389
390	/**
391	* VMMCPU Data (part of VMCPU)
392	*/
393	typedef struct VMMCPU
394	{
395	/** Offset to the VMCPU structure.
396	* See VMM2VMCPU(). */
397	RTINT offVMCPU;
398
399	/** The last RC/R0 return code. */
400	int32_t iLastGZRc;
401
402	/** VMM stack, pointer to the top of the stack in R3.
403	* Stack is allocated from the hypervisor heap and is page aligned
404	* and always writable in RC. */
405	R3PTRTYPE(uint8_t *) pbEMTStackR3;
406	/** Pointer to the bottom of the stack - needed for doing relocations. */
407	RCPTRTYPE(uint8_t *) pbEMTStackRC;
408	/** Pointer to the bottom of the stack - needed for doing relocations. */
409	RCPTRTYPE(uint8_t *) pbEMTStackBottomRC;
410
411	#ifdef LOG_ENABLED
412	/** Pointer to the R0 logger instance - R3 Ptr.
413	* This is NULL if logging is disabled. */
414	R3PTRTYPE(PVMMR0LOGGER) pR0LoggerR3;
415	/** Pointer to the R0 logger instance - R0 Ptr.
416	* This is NULL if logging is disabled. */
417	R0PTRTYPE(PVMMR0LOGGER) pR0LoggerR0;
418	#endif
419
420	/** @name Call Ring-3
421	* Formerly known as host calls.
422	* @{ */
423	/** The disable counter. */
424	uint32_t cCallRing3Disabled;
425	/** The pending operation. */
426	VMMCALLRING3 enmCallRing3Operation;
427	/** The result of the last operation. */
428	int32_t rcCallRing3;
429	#if HC_ARCH_BITS == 64
430	uint32_t padding;
431	#endif
432	/** The argument to the operation. */
433	uint64_t u64CallRing3Arg;
434	/** The Ring-0 jmp buffer. */
435	VMMR0JMPBUF CallRing3JmpBufR0;
436	/** @} */
437
438	} VMMCPU;
439	/** Pointer to VMMCPU. */
440	typedef VMMCPU *PVMMCPU;
441
442
443	/**
444	* The VMMGCEntry() codes.
445	*/
446	typedef enum VMMGCOPERATION
447	{
448	/** Do GC module init. */
449	VMMGC_DO_VMMGC_INIT = 1,
450
451	/** The first Trap testcase. */
452	VMMGC_DO_TESTCASE_TRAP_FIRST = 0x0dead000,
453	/** Trap 0 testcases, uArg selects the variation. */
454	VMMGC_DO_TESTCASE_TRAP_0 = VMMGC_DO_TESTCASE_TRAP_FIRST,
455	/** Trap 1 testcases, uArg selects the variation. */
456	VMMGC_DO_TESTCASE_TRAP_1,
457	/** Trap 2 testcases, uArg selects the variation. */
458	VMMGC_DO_TESTCASE_TRAP_2,
459	/** Trap 3 testcases, uArg selects the variation. */
460	VMMGC_DO_TESTCASE_TRAP_3,
461	/** Trap 4 testcases, uArg selects the variation. */
462	VMMGC_DO_TESTCASE_TRAP_4,
463	/** Trap 5 testcases, uArg selects the variation. */
464	VMMGC_DO_TESTCASE_TRAP_5,
465	/** Trap 6 testcases, uArg selects the variation. */
466	VMMGC_DO_TESTCASE_TRAP_6,
467	/** Trap 7 testcases, uArg selects the variation. */
468	VMMGC_DO_TESTCASE_TRAP_7,
469	/** Trap 8 testcases, uArg selects the variation. */
470	VMMGC_DO_TESTCASE_TRAP_8,
471	/** Trap 9 testcases, uArg selects the variation. */
472	VMMGC_DO_TESTCASE_TRAP_9,
473	/** Trap 0a testcases, uArg selects the variation. */
474	VMMGC_DO_TESTCASE_TRAP_0A,
475	/** Trap 0b testcases, uArg selects the variation. */
476	VMMGC_DO_TESTCASE_TRAP_0B,
477	/** Trap 0c testcases, uArg selects the variation. */
478	VMMGC_DO_TESTCASE_TRAP_0C,
479	/** Trap 0d testcases, uArg selects the variation. */
480	VMMGC_DO_TESTCASE_TRAP_0D,
481	/** Trap 0e testcases, uArg selects the variation. */
482	VMMGC_DO_TESTCASE_TRAP_0E,
483	/** The last trap testcase (exclusive). */
484	VMMGC_DO_TESTCASE_TRAP_LAST,
485	/** Testcase for checking interrupt forwarding. */
486	VMMGC_DO_TESTCASE_HYPER_INTERRUPT,
487	/** Switching testing and profiling stub. */
488	VMMGC_DO_TESTCASE_NOP,
489	/** Testcase for checking interrupt masking.. */
490	VMMGC_DO_TESTCASE_INTERRUPT_MASKING,
491	/** Switching testing and profiling stub. */
492	VMMGC_DO_TESTCASE_HWACCM_NOP,
493
494	/** The usual 32-bit hack. */
495	VMMGC_DO_32_BIT_HACK = 0x7fffffff
496	} VMMGCOPERATION;
497
498
499	RT_C_DECLS_BEGIN
500
501	#ifdef IN_RING3
502	int vmmR3SwitcherInit(PVM pVM);
503	void vmmR3SwitcherRelocate(PVM pVM, RTGCINTPTR offDelta);
504	#endif /* IN_RING3 */
505
506	#ifdef IN_RING0
507	/**
508	* World switcher assembly routine.
509	* It will call VMMGCEntry().
510	*
511	* @returns return code from VMMGCEntry().
512	* @param pVM The VM in question.
513	* @param uArg See VMMGCEntry().
514	* @internal
515	*/
516	DECLASM(int) vmmR0WorldSwitch(PVM pVM, unsigned uArg);
517
518	/**
519	* Callback function for vmmR0CallRing3SetJmp.
520	*
521	* @returns VBox status code.
522	* @param pVM The VM handle.
523	*/
524	typedef DECLCALLBACK(int) FNVMMR0SETJMP(PVM pVM, PVMCPU pVCpu);
525	/** Pointer to FNVMMR0SETJMP(). */
526	typedef FNVMMR0SETJMP *PFNVMMR0SETJMP;
527
528	/**
529	* The setjmp variant used for calling Ring-3.
530	*
531	* This differs from the normal setjmp in that it will resume VMMRZCallRing3 if we're
532	* in the middle of a ring-3 call. Another differences is the function pointer and
533	* argument. This has to do with resuming code and the stack frame of the caller.
534	*
535	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
536	* @param pJmpBuf The jmp_buf to set.
537	* @param pfn The function to be called when not resuming..
538	* @param pVM The argument of that function.
539	*/
540	DECLASM(int) vmmR0CallRing3SetJmp(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMP pfn, PVM pVM, PVMCPU pVCpu);
541
542	/**
543	* Callback function for vmmR0CallRing3SetJmpEx.
544	*
545	* @returns VBox status code.
546	* @param pvUser The user argument.
547	*/
548	typedef DECLCALLBACK(int) FNVMMR0SETJMPEX(void *pvUser);
549	/** Pointer to FNVMMR0SETJMP(). */
550	typedef FNVMMR0SETJMPEX *PFNVMMR0SETJMPEX;
551
552	/**
553	* Same as vmmR0CallRing3SetJmp except for the function signature.
554	*
555	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
556	* @param pJmpBuf The jmp_buf to set.
557	* @param pfn The function to be called when not resuming..
558	* @param pvUser The argument of that function.
559	*/
560	DECLASM(int) vmmR0CallRing3SetJmpEx(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMPEX pfn, void *pvUser);
561
562
563	/**
564	* Worker for VMMRZCallRing3.
565	* This will save the stack and registers.
566	*
567	* @returns rc.
568	* @param pJmpBuf Pointer to the jump buffer.
569	* @param rc The return code.
570	*/
571	DECLASM(int) vmmR0CallRing3LongJmp(PVMMR0JMPBUF pJmpBuf, int rc);
572
573	/**
574	* Internal R0 logger worker: Logger wrapper.
575	*/
576	VMMR0DECL(void) vmmR0LoggerWrapper(const char *pszFormat, ...);
577
578	/**
579	* Internal R0 logger worker: Flush logger.
580	*
581	* @param pLogger The logger instance to flush.
582	* @remark This function must be exported!
583	*/
584	VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger);
585
586	/**
587	* Interal R0 logger worker: Custom prefix.
588	*
589	* @returns Number of chars written.
590	*
591	* @param pLogger The logger instance.
592	* @param pchBuf The output buffer.
593	* @param cchBuf The size of the buffer.
594	* @param pvUser User argument (ignored).
595	*/
596	VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char pchBuf, size_t cchBuf, void pvUser);
597
598	#endif /* IN_RING0 */
599	#ifdef IN_RC
600
601	/**
602	* Internal GC logger worker: Logger wrapper.
603	*/
604	VMMRCDECL(void) vmmGCLoggerWrapper(const char *pszFormat, ...);
605
606	/**
607	* Internal GC release logger worker: Logger wrapper.
608	*/
609	VMMRCDECL(void) vmmGCRelLoggerWrapper(const char *pszFormat, ...);
610
611	/**
612	* Internal GC logger worker: Flush logger.
613	*
614	* @returns VINF_SUCCESS.
615	* @param pLogger The logger instance to flush.
616	* @remark This function must be exported!
617	*/
618	VMMRCDECL(int) vmmGCLoggerFlush(PRTLOGGERRC pLogger);
619
620	/** @name Trap testcases and related labels.
621	* @{ */
622	DECLASM(void) vmmGCEnableWP(void);
623	DECLASM(void) vmmGCDisableWP(void);
624	DECLASM(int) vmmGCTestTrap3(void);
625	DECLASM(int) vmmGCTestTrap8(void);
626	DECLASM(int) vmmGCTestTrap0d(void);
627	DECLASM(int) vmmGCTestTrap0e(void);
628	DECLASM(int) vmmGCTestTrap0e_FaultEIP(void); /*< a label /
629	DECLASM(int) vmmGCTestTrap0e_ResumeEIP(void); /*< a label /
630	/** @} */
631
632	#endif /* IN_RC */
633
634	RT_C_DECLS_END
635
636	/** @} */
637
638	#endif

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

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

Download in other formats: