VirtualBox

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

Last change on this file since 24912 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 */
81typedef DECLASMTYPE(int) FNVMMSWITCHERHC(PVM pVM);
82/** Pointer to switcher function. */
83typedef FNVMMSWITCHERHC *PFNVMMSWITCHERHC;
84
85/**
86 * Switcher function, RC to HC.
87 *
88 * @param rc VBox status code.
89 */
90typedef DECLASMTYPE(void) FNVMMSWITCHERRC(int rc);
91/** Pointer to switcher function. */
92typedef 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 */
101typedef 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. */
123typedef VMMR0LOGGER *PVMMR0LOGGER;
124
125
126/**
127 * Jump buffer for the setjmp/longjmp like constructs used to
128 * quickly 'call' back into Ring-3.
129 */
130typedef 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. */
198typedef VMMR0JMPBUF *PVMMR0JMPBUF;
199
200
201/**
202 * VMM Data (part of VM)
203 */
204typedef 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. */
390typedef VMM *PVMM;
391
392
393/**
394 * VMMCPU Data (part of VMCPU)
395 */
396typedef 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. */
443typedef VMMCPU *PVMMCPU;
444
445
446/**
447 * The VMMGCEntry() codes.
448 */
449typedef 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
502RT_C_DECLS_BEGIN
503
504#ifdef IN_RING3
505int vmmR3SwitcherInit(PVM pVM);
506void 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 */
519DECLASM(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 */
527typedef DECLCALLBACK(int) FNVMMR0SETJMP(PVM pVM, PVMCPU pVCpu);
528/** Pointer to FNVMMR0SETJMP(). */
529typedef 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 */
543DECLASM(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 */
551typedef DECLCALLBACK(int) FNVMMR0SETJMPEX(void *pvUser);
552/** Pointer to FNVMMR0SETJMP(). */
553typedef 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 */
563DECLASM(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 */
574DECLASM(int) vmmR0CallRing3LongJmp(PVMMR0JMPBUF pJmpBuf, int rc);
575
576/**
577 * Internal R0 logger worker: Logger wrapper.
578 */
579VMMR0DECL(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 */
587VMMR0DECL(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 */
599VMMR0DECL(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 */
607VMMRCDECL(void) vmmGCLoggerWrapper(const char *pszFormat, ...);
608
609/**
610 * Internal GC release logger worker: Logger wrapper.
611 */
612VMMRCDECL(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 */
621VMMRCDECL(int) vmmGCLoggerFlush(PRTLOGGERRC pLogger);
622
623/** @name Trap testcases and related labels.
624 * @{ */
625DECLASM(void) vmmGCEnableWP(void);
626DECLASM(void) vmmGCDisableWP(void);
627DECLASM(int) vmmGCTestTrap3(void);
628DECLASM(int) vmmGCTestTrap8(void);
629DECLASM(int) vmmGCTestTrap0d(void);
630DECLASM(int) vmmGCTestTrap0e(void);
631DECLASM(int) vmmGCTestTrap0e_FaultEIP(void); /**< a label */
632DECLASM(int) vmmGCTestTrap0e_ResumeEIP(void); /**< a label */
633/** @} */
634
635#endif /* IN_RC */
636
637RT_C_DECLS_END
638
639/** @} */
640
641#endif
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use