VMMInternal.h@ 93392

Last change on this file since 93392 was 93115, checked in by vboxsync, 3 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 27.5 KB

Line
1	/* $Id: VMMInternal.h 93115 2022-01-01 11:31:46Z vboxsync $ */
2	/** @file
3	* VMM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 Oracle Corporation
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
18	#ifndef VMM_INCLUDED_SRC_include_VMMInternal_h
19	#define VMM_INCLUDED_SRC_include_VMMInternal_h
20	#ifndef RT_WITHOUT_PRAGMA_ONCE
21	# pragma once
22	#endif
23
24	#include <VBox/cdefs.h>
25	#include <VBox/sup.h>
26	#include <VBox/vmm/stam.h>
27	#include <VBox/vmm/vmm.h>
28	#include <VBox/param.h>
29	#include <VBox/log.h>
30	#include <iprt/critsect.h>
31
32	#if !defined(IN_VMM_R3) && !defined(IN_VMM_R0) && !defined(IN_VMM_RC)
33	# error "Not in VMM! This is an internal header!"
34	#endif
35	#if HC_ARCH_BITS == 32
36	# error "32-bit hosts are no longer supported. Go back to 6.0 or earlier!"
37	#endif
38
39
40
41	/** @defgroup grp_vmm_int Internals
42	* @ingroup grp_vmm
43	* @internal
44	* @{
45	*/
46
47	/** @def VBOX_WITH_RC_RELEASE_LOGGING
48	* Enables RC release logging. */
49	#define VBOX_WITH_RC_RELEASE_LOGGING
50
51	/** @def VBOX_WITH_R0_LOGGING
52	* Enables Ring-0 logging (non-release).
53	*
54	* Ring-0 logging isn't 100% safe yet (thread id reuse / process exit cleanup),
55	* so you have to sign up here by adding your defined(DEBUG_<userid>) to the
56	* \#if, or by adding VBOX_WITH_R0_LOGGING to your LocalConfig.kmk.
57	*/
58	#if defined(DEBUG_sandervl) \|\| defined(DEBUG_frank) \|\| defined(DEBUG_ramshankar) \|\| defined(DOXYGEN_RUNNING)
59	# define VBOX_WITH_R0_LOGGING
60	#endif
61
62	/** @def VBOX_STRICT_VMM_STACK
63	* Enables VMM stack guard pages to catch stack over- and underruns. */
64	#if defined(VBOX_STRICT) \|\| defined(DOXYGEN_RUNNING)
65	# define VBOX_STRICT_VMM_STACK
66	#endif
67
68
69	/** Number of buffers per logger. */
70	#define VMMLOGGER_BUFFER_COUNT 4
71
72	/**
73	* R0 logger data (ring-0 only data).
74	*/
75	typedef struct VMMR0PERVCPULOGGER
76	{
77	/** Pointer to the logger instance.
78	* The RTLOGGER::u32UserValue1 member is used for flags and magic, while the
79	* RTLOGGER::u64UserValue2 member is the corresponding PGVMCPU value.
80	* RTLOGGER::u64UserValue3 is currently and set to the PGVMCPU value too. */
81	R0PTRTYPE(PRTLOGGER) pLogger;
82	/** Log buffer descriptor.
83	* The buffer is allocated in a common block for all VCpus, see VMMR0PERVM. */
84	RTLOGBUFFERDESC aBufDescs[VMMLOGGER_BUFFER_COUNT];
85	/** Flag indicating whether we've registered the instance already. */
86	bool fRegistered;
87	/** Set if the EMT is waiting on hEventFlushWait. */
88	bool fEmtWaiting;
89	/** Set while we're inside vmmR0LoggerFlushCommon to prevent recursion. */
90	bool fFlushing;
91	bool afPadding[1];
92	/** Number of buffers currently queued for flushing. */
93	uint32_t volatile cFlushing;
94	/** The event semaphore the EMT waits on while the buffer is being flushed. */
95	RTSEMEVENT hEventFlushWait;
96	} VMMR0PERVCPULOGGER;
97	/** Pointer to the R0 logger data (ring-0 only). */
98	typedef VMMR0PERVCPULOGGER *PVMMR0PERVCPULOGGER;
99
100
101	/**
102	* R0 logger data shared with ring-3 (per CPU).
103	*/
104	typedef struct VMMR3CPULOGGER
105	{
106	/** Buffer info. */
107	struct
108	{
109	/** Auxiliary buffer descriptor. */
110	RTLOGBUFFERAUXDESC AuxDesc;
111	/** Ring-3 mapping of the logging buffer. */
112	R3PTRTYPE(char *) pchBufR3;
113	} aBufs[VMMLOGGER_BUFFER_COUNT];
114	/** The current buffer. */
115	uint32_t idxBuf;
116	/** Number of buffers currently queued for flushing (copy of
117	* VMMR0PERVCPULOGGER::cFlushing). */
118	uint32_t volatile cFlushing;
119	/** The buffer size. */
120	uint32_t cbBuf;
121	/** Number of bytes dropped because the flush context didn't allow waiting. */
122	uint32_t cbDropped;
123	STAMCOUNTER StatFlushes;
124	STAMCOUNTER StatCannotBlock;
125	STAMPROFILE StatWait;
126	STAMPROFILE StatRaces;
127	STAMCOUNTER StatRacesToR0;
128	} VMMR3CPULOGGER;
129	/** Pointer to r0 logger data shared with ring-3. */
130	typedef VMMR3CPULOGGER *PVMMR3CPULOGGER;
131
132	/** @name Logger indexes for VMMR0PERVCPU::u.aLoggers and VMMCPU::u.aLoggers.
133	* @{ */
134	#define VMMLOGGER_IDX_REGULAR 0
135	#define VMMLOGGER_IDX_RELEASE 1
136	#define VMMLOGGER_IDX_MAX 2
137	/** @} */
138
139
140	/** Pointer to a ring-0 jump buffer. */
141	typedef struct VMMR0JMPBUF *PVMMR0JMPBUF;
142	/**
143	* Jump buffer for the setjmp/longjmp like constructs used to
144	* quickly 'call' back into Ring-3.
145	*/
146	typedef struct VMMR0JMPBUF
147	{
148	/** Traditional jmp_buf stuff
149	* @{ */
150	#if HC_ARCH_BITS == 32
151	uint32_t ebx;
152	uint32_t esi;
153	uint32_t edi;
154	uint32_t ebp;
155	uint32_t esp;
156	uint32_t eip;
157	uint32_t eflags;
158	#endif
159	#if HC_ARCH_BITS == 64
160	uint64_t rbx;
161	# ifdef RT_OS_WINDOWS
162	uint64_t rsi;
163	uint64_t rdi;
164	# endif
165	uint64_t rbp;
166	uint64_t r12;
167	uint64_t r13;
168	uint64_t r14;
169	uint64_t r15;
170	uint64_t rsp;
171	uint64_t rip;
172	# ifdef RT_OS_WINDOWS
173	uint128_t xmm6;
174	uint128_t xmm7;
175	uint128_t xmm8;
176	uint128_t xmm9;
177	uint128_t xmm10;
178	uint128_t xmm11;
179	uint128_t xmm12;
180	uint128_t xmm13;
181	uint128_t xmm14;
182	uint128_t xmm15;
183	# endif
184	uint64_t rflags;
185	#endif
186	/** @} */
187
188	/** RSP/ESP at the time of the stack mirroring (what pvStackBuf starts with). */
189	RTHCUINTREG UnwindSp;
190	/** RSP/ESP at the time of the long jump call. */
191	RTHCUINTREG UnwindRetSp;
192	/** RBP/EBP inside the vmmR0CallRing3LongJmp frame. */
193	RTHCUINTREG UnwindBp;
194	/** RIP/EIP within vmmR0CallRing3LongJmp for assisting unwinding. */
195	RTHCUINTREG UnwindPc;
196	/** Unwind: The vmmR0CallRing3SetJmp return address value. */
197	RTHCUINTREG UnwindRetPcValue;
198	/** Unwind: The vmmR0CallRing3SetJmp return address stack location. */
199	RTHCUINTREG UnwindRetPcLocation;
200
201	/** The function last being executed here. */
202	RTHCUINTREG pfn;
203	/** The first argument to the function. */
204	RTHCUINTREG pvUser1;
205	/** The second argument to the function. */
206	RTHCUINTREG pvUser2;
207
208	/** Number of valid bytes in pvStackBuf. */
209	uint32_t cbStackValid;
210	/** Size of buffer pvStackBuf points to. */
211	uint32_t cbStackBuf;
212	/** Pointer to buffer for mirroring the stack. Optional. */
213	RTR0PTR pvStackBuf;
214	/** Pointer to a ring-3 accessible jump buffer structure for automatic
215	* mirroring on longjmp. Optional. */
216	R0PTRTYPE(PVMMR0JMPBUF) pMirrorBuf;
217	} VMMR0JMPBUF;
218
219
220	/**
221	* Log flusher job.
222	*
223	* There is a ring buffer of these in ring-0 (VMMR0PERVM::aLogFlushRing) and a
224	* copy of the current one in the shared VM structure (VMM::LogFlusherItem).
225	*/
226	typedef union VMMLOGFLUSHERENTRY
227	{
228	struct
229	{
230	/** The virtual CPU ID. */
231	uint32_t idCpu : 16;
232	/** The logger: 0 for release, 1 for debug. */
233	uint32_t idxLogger : 8;
234	/** The buffer to be flushed. */
235	uint32_t idxBuffer : 7;
236	/** Set by the flusher thread once it fetched the entry and started
237	* processing it. */
238	uint32_t fProcessing : 1;
239	} s;
240	uint32_t u32;
241	} VMMLOGFLUSHERENTRY;
242
243
244	/**
245	* VMM Data (part of VM)
246	*/
247	typedef struct VMM
248	{
249	/** Whether we should use the periodic preemption timers. */
250	bool fUsePeriodicPreemptionTimers;
251	/** Alignment padding. */
252	bool afPadding0[7];
253
254	#if 0 /* pointless when timers doesn't run on EMT */
255	/** The EMT yield timer. */
256	TMTIMERHANDLE hYieldTimer;
257	/** The period to the next timeout when suspended or stopped.
258	* This is 0 when running. */
259	uint32_t cYieldResumeMillies;
260	/** The EMT yield timer interval (milliseconds). */
261	uint32_t cYieldEveryMillies;
262	/** The timestamp of the previous yield. (nano) */
263	uint64_t u64LastYield;
264	#endif
265
266	/** @name EMT Rendezvous
267	* @{ */
268	/** Semaphore to wait on upon entering ordered execution. */
269	R3PTRTYPE(PRTSEMEVENT) pahEvtRendezvousEnterOrdered;
270	/** Semaphore to wait on upon entering for one-by-one execution. */
271	RTSEMEVENT hEvtRendezvousEnterOneByOne;
272	/** Semaphore to wait on upon entering for all-at-once execution. */
273	RTSEMEVENTMULTI hEvtMulRendezvousEnterAllAtOnce;
274	/** Semaphore to wait on when done. */
275	RTSEMEVENTMULTI hEvtMulRendezvousDone;
276	/** Semaphore the VMMR3EmtRendezvous caller waits on at the end. */
277	RTSEMEVENT hEvtRendezvousDoneCaller;
278	/** Semaphore to wait on upon recursing. */
279	RTSEMEVENTMULTI hEvtMulRendezvousRecursionPush;
280	/** Semaphore to wait on after done with recursion (caller restoring state). */
281	RTSEMEVENTMULTI hEvtMulRendezvousRecursionPop;
282	/** Semaphore the initiator waits on while the EMTs are getting into position
283	* on hEvtMulRendezvousRecursionPush. */
284	RTSEMEVENT hEvtRendezvousRecursionPushCaller;
285	/** Semaphore the initiator waits on while the EMTs sitting on
286	* hEvtMulRendezvousRecursionPop wakes up and leave. */
287	RTSEMEVENT hEvtRendezvousRecursionPopCaller;
288	/** Callback. */
289	R3PTRTYPE(PFNVMMEMTRENDEZVOUS) volatile pfnRendezvous;
290	/** The user argument for the callback. */
291	RTR3PTR volatile pvRendezvousUser;
292	/** Flags. */
293	volatile uint32_t fRendezvousFlags;
294	/** The number of EMTs that has entered. */
295	volatile uint32_t cRendezvousEmtsEntered;
296	/** The number of EMTs that has done their job. */
297	volatile uint32_t cRendezvousEmtsDone;
298	/** The number of EMTs that has returned. */
299	volatile uint32_t cRendezvousEmtsReturned;
300	/** The status code. */
301	volatile int32_t i32RendezvousStatus;
302	/** Spin lock. */
303	volatile uint32_t u32RendezvousLock;
304	/** The recursion depth. */
305	volatile uint32_t cRendezvousRecursions;
306	/** The number of EMTs that have entered the recursion routine. */
307	volatile uint32_t cRendezvousEmtsRecursingPush;
308	/** The number of EMTs that have leaft the recursion routine. */
309	volatile uint32_t cRendezvousEmtsRecursingPop;
310	/** Triggers rendezvous recursion in the other threads. */
311	volatile bool fRendezvousRecursion;
312
313	/** @} */
314
315	/** RTThreadPreemptIsPendingTrusty() result, set by vmmR0InitVM() for
316	* release logging purposes. */
317	bool fIsPreemptPendingApiTrusty : 1;
318	/** The RTThreadPreemptIsPossible() result, set by vmmR0InitVM() for
319	* release logging purposes. */
320	bool fIsPreemptPossible : 1;
321	/** Set if ring-0 uses context hooks. */
322	bool fIsUsingContextHooks : 1;
323
324	bool afAlignment2[2]; /*< Alignment padding. /
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	/** @name Logging
334	* @{ */
335	/** Used when setting up ring-0 logger. */
336	uint64_t nsProgramStart;
337	/** Log flusher thread. */
338	RTTHREAD hLogFlusherThread;
339	/** Copy of the current work log flusher work item. */
340	VMMLOGFLUSHERENTRY volatile LogFlusherItem;
341	STAMCOUNTER StatLogFlusherFlushes;
342	STAMCOUNTER StatLogFlusherNoWakeUp;
343	/** @} */
344
345	/** Number of VMMR0_DO_HM_RUN or VMMR0_DO_NEM_RUN calls. */
346	STAMCOUNTER StatRunGC;
347
348	/** Statistics for each of the RC/R0 return codes.
349	* @{ */
350	STAMCOUNTER StatRZRetNormal;
351	STAMCOUNTER StatRZRetInterrupt;
352	STAMCOUNTER StatRZRetInterruptHyper;
353	STAMCOUNTER StatRZRetGuestTrap;
354	STAMCOUNTER StatRZRetRingSwitch;
355	STAMCOUNTER StatRZRetRingSwitchInt;
356	STAMCOUNTER StatRZRetStaleSelector;
357	STAMCOUNTER StatRZRetIRETTrap;
358	STAMCOUNTER StatRZRetEmulate;
359	STAMCOUNTER StatRZRetPatchEmulate;
360	STAMCOUNTER StatRZRetIORead;
361	STAMCOUNTER StatRZRetIOWrite;
362	STAMCOUNTER StatRZRetIOCommitWrite;
363	STAMCOUNTER StatRZRetMMIORead;
364	STAMCOUNTER StatRZRetMMIOWrite;
365	STAMCOUNTER StatRZRetMMIOCommitWrite;
366	STAMCOUNTER StatRZRetMMIOPatchRead;
367	STAMCOUNTER StatRZRetMMIOPatchWrite;
368	STAMCOUNTER StatRZRetMMIOReadWrite;
369	STAMCOUNTER StatRZRetMSRRead;
370	STAMCOUNTER StatRZRetMSRWrite;
371	STAMCOUNTER StatRZRetLDTFault;
372	STAMCOUNTER StatRZRetGDTFault;
373	STAMCOUNTER StatRZRetIDTFault;
374	STAMCOUNTER StatRZRetTSSFault;
375	STAMCOUNTER StatRZRetCSAMTask;
376	STAMCOUNTER StatRZRetSyncCR3;
377	STAMCOUNTER StatRZRetMisc;
378	STAMCOUNTER StatRZRetPatchInt3;
379	STAMCOUNTER StatRZRetPatchPF;
380	STAMCOUNTER StatRZRetPatchGP;
381	STAMCOUNTER StatRZRetPatchIretIRQ;
382	STAMCOUNTER StatRZRetRescheduleREM;
383	STAMCOUNTER StatRZRetToR3Total;
384	STAMCOUNTER StatRZRetToR3FF;
385	STAMCOUNTER StatRZRetToR3Unknown;
386	STAMCOUNTER StatRZRetToR3TMVirt;
387	STAMCOUNTER StatRZRetToR3HandyPages;
388	STAMCOUNTER StatRZRetToR3PDMQueues;
389	STAMCOUNTER StatRZRetToR3Rendezvous;
390	STAMCOUNTER StatRZRetToR3Timer;
391	STAMCOUNTER StatRZRetToR3DMA;
392	STAMCOUNTER StatRZRetToR3CritSect;
393	STAMCOUNTER StatRZRetToR3Iem;
394	STAMCOUNTER StatRZRetToR3Iom;
395	STAMCOUNTER StatRZRetTimerPending;
396	STAMCOUNTER StatRZRetInterruptPending;
397	STAMCOUNTER StatRZRetPATMDuplicateFn;
398	STAMCOUNTER StatRZRetPendingRequest;
399	STAMCOUNTER StatRZRetPGMFlushPending;
400	STAMCOUNTER StatRZRetPatchTPR;
401	/** @} */
402	} VMM;
403	/** Pointer to VMM. */
404	typedef VMM *PVMM;
405
406
407	/**
408	* VMMCPU Data (part of VMCPU)
409	*/
410	typedef struct VMMCPU
411	{
412	/** The last RC/R0 return code. */
413	int32_t iLastGZRc;
414	/** Alignment padding. */
415	uint32_t u32Padding0;
416
417	/** @name Rendezvous
418	* @{ */
419	/** Whether the EMT is executing a rendezvous right now. For detecting
420	* attempts at recursive rendezvous. */
421	bool volatile fInRendezvous;
422	bool afPadding1[2];
423	/** @} */
424
425	/** Whether we can HLT in VMMR0 rather than having to return to EM.
426	* Updated by vmR3SetHaltMethodU(). */
427	bool fMayHaltInRing0;
428	/** The minimum delta for which we can HLT in ring-0 for.
429	* The deadlines we can calculate are from TM, so, if it's too close
430	* we should just return to ring-3 and run the timer wheel, no point
431	* in spinning in ring-0.
432	* Updated by vmR3SetHaltMethodU(). */
433	uint32_t cNsSpinBlockThreshold;
434	/** Number of ring-0 halts (used for depreciating following values). */
435	uint32_t cR0Halts;
436	/** Number of ring-0 halts succeeding (VINF_SUCCESS) recently. */
437	uint32_t cR0HaltsSucceeded;
438	/** Number of ring-0 halts failing (VINF_EM_HALT) recently. */
439	uint32_t cR0HaltsToRing3;
440	/** Padding */
441	uint32_t u32Padding2;
442
443	/** @name Raw-mode context tracing data.
444	* @{ */
445	SUPDRVTRACERUSRCTX TracerCtx;
446	/** @} */
447
448	/** @name Ring-0 assertion info for this EMT.
449	* @{ */
450	/** Copy of the ring-0 jmp buffer after an assertion. */
451	VMMR0JMPBUF AssertJmpBuf;
452	/** Copy of the assertion stack. */
453	uint8_t abAssertStack[8192];
454	/** @} */
455
456	/**
457	* Loggers.
458	*/
459	union
460	{
461	struct
462	{
463	/** The R0 logger data shared with ring-3. */
464	VMMR3CPULOGGER Logger;
465	/** The R0 release logger data shared with ring-3. */
466	VMMR3CPULOGGER RelLogger;
467	} s;
468	/** Array view. */
469	VMMR3CPULOGGER aLoggers[VMMLOGGER_IDX_MAX];
470	} u;
471
472	STAMPROFILE StatR0HaltBlock;
473	STAMPROFILE StatR0HaltBlockOnTime;
474	STAMPROFILE StatR0HaltBlockOverslept;
475	STAMPROFILE StatR0HaltBlockInsomnia;
476	STAMCOUNTER StatR0HaltExec;
477	STAMCOUNTER StatR0HaltExecFromBlock;
478	STAMCOUNTER StatR0HaltExecFromSpin;
479	STAMCOUNTER StatR0HaltToR3;
480	STAMCOUNTER StatR0HaltToR3FromSpin;
481	STAMCOUNTER StatR0HaltToR3Other;
482	STAMCOUNTER StatR0HaltToR3PendingFF;
483	STAMCOUNTER StatR0HaltToR3SmallDelta;
484	STAMCOUNTER StatR0HaltToR3PostNoInt;
485	STAMCOUNTER StatR0HaltToR3PostPendingFF;
486	} VMMCPU;
487	AssertCompileMemberAlignment(VMMCPU, TracerCtx, 8);
488	AssertCompile( RTASSERT_OFFSET_OF(VMMCPU, u.s.Logger)
489	== RTASSERT_OFFSET_OF(VMMCPU, u.aLoggers) + sizeof(VMMR3CPULOGGER) * VMMLOGGER_IDX_REGULAR);
490	AssertCompile(RTASSERT_OFFSET_OF(VMMCPU, u.s.RelLogger)
491	== RTASSERT_OFFSET_OF(VMMCPU, u.aLoggers) + sizeof(VMMR3CPULOGGER) * VMMLOGGER_IDX_RELEASE);
492
493	/** Pointer to VMMCPU. */
494	typedef VMMCPU *PVMMCPU;
495
496	/**
497	* VMM per-VCpu ring-0 only instance data.
498	*/
499	typedef struct VMMR0PERVCPU
500	{
501	/** The EMT hash table index. */
502	uint16_t idxEmtHash;
503	/** Flag indicating whether we've disabled flushing (world switch) or not. */
504	bool fLogFlushingDisabled;
505	bool afPadding1[5];
506	/** Pointer to the VMMR0EntryFast preemption state structure.
507	* This is used to temporarily restore preemption before blocking. */
508	R0PTRTYPE(PRTTHREADPREEMPTSTATE) pPreemptState;
509	/** Thread context switching hook (ring-0). */
510	RTTHREADCTXHOOK hCtxHook;
511
512	/** @name Arguments passed by VMMR0EntryEx via vmmR0CallRing3SetJmpEx.
513	* @note Cannot be put on the stack as the location may change and upset the
514	* validation of resume-after-ring-3-call logic.
515	* @todo This no longer needs to be here now that we don't call ring-3 and mess
516	* around with stack restoring/switching.
517	* @{ */
518	PGVM pGVM;
519	VMCPUID idCpu;
520	VMMR0OPERATION enmOperation;
521	PSUPVMMR0REQHDR pReq;
522	uint64_t u64Arg;
523	PSUPDRVSESSION pSession;
524	/** @} */
525
526	/** @name Ring-0 setjmp / assertion handling.
527	* @{ */
528	/** The ring-0 setjmp buffer. */
529	VMMR0JMPBUF AssertJmpBuf;
530	/** The disable counter. */
531	uint32_t cCallRing3Disabled;
532	uint32_t u32Padding3;
533	/** Ring-0 assertion notification callback. */
534	R0PTRTYPE(PFNVMMR0ASSERTIONNOTIFICATION) pfnAssertCallback;
535	/** Argument for pfnRing0AssertionNotificationCallback. */
536	R0PTRTYPE(void *) pvAssertCallbackUser;
537	/** @} */
538
539	/**
540	* Loggers
541	*/
542	union
543	{
544	struct
545	{
546	/** The R0 logger data. */
547	VMMR0PERVCPULOGGER Logger;
548	/** The R0 release logger data. */
549	VMMR0PERVCPULOGGER RelLogger;
550	} s;
551	/** Array view. */
552	VMMR0PERVCPULOGGER aLoggers[VMMLOGGER_IDX_MAX];
553	} u;
554	} VMMR0PERVCPU;
555	AssertCompile( RTASSERT_OFFSET_OF(VMMR0PERVCPU, u.s.Logger)
556	== RTASSERT_OFFSET_OF(VMMR0PERVCPU, u.aLoggers) + sizeof(VMMR0PERVCPULOGGER) * VMMLOGGER_IDX_REGULAR);
557	AssertCompile(RTASSERT_OFFSET_OF(VMMR0PERVCPU, u.s.RelLogger)
558	== RTASSERT_OFFSET_OF(VMMR0PERVCPU, u.aLoggers) + sizeof(VMMR0PERVCPULOGGER) * VMMLOGGER_IDX_RELEASE);
559	AssertCompileMemberAlignment(VMMR0PERVCPU, AssertJmpBuf, 64);
560	/** Pointer to VMM ring-0 VMCPU instance data. */
561	typedef VMMR0PERVCPU *PVMMR0PERVCPU;
562
563	/** @name RTLOGGER::u32UserValue1 Flags
564	* @{ */
565	/** The magic value. */
566	#define VMMR0_LOGGER_FLAGS_MAGIC_VALUE UINT32_C(0x7d297f05)
567	/** Part of the flags value used for the magic. */
568	#define VMMR0_LOGGER_FLAGS_MAGIC_MASK UINT32_C(0xffffff0f)
569	/** @} */
570
571
572	/**
573	* VMM data kept in the ring-0 GVM.
574	*/
575	typedef struct VMMR0PERVM
576	{
577	/** Set if vmmR0InitVM has been called. */
578	bool fCalledInitVm;
579	bool afPadding1[7];
580
581	/** @name Logging
582	* @{ */
583	/** Logger (debug) buffer allocation.
584	* This covers all CPUs. */
585	RTR0MEMOBJ hMemObjLogger;
586	/** The ring-3 mapping object for hMemObjLogger. */
587	RTR0MEMOBJ hMapObjLogger;
588
589	/** Release logger buffer allocation.
590	* This covers all CPUs. */
591	RTR0MEMOBJ hMemObjReleaseLogger;
592	/** The ring-3 mapping object for hMemObjReleaseLogger. */
593	RTR0MEMOBJ hMapObjReleaseLogger;
594
595	struct
596	{
597	/** Spinlock protecting the logger ring buffer and associated variables. */
598	R0PTRTYPE(RTSPINLOCK) hSpinlock;
599	/** The log flusher thread handle to make sure there is only one. */
600	RTNATIVETHREAD hThread;
601	/** The handle to the event semaphore the log flusher waits on. */
602	RTSEMEVENT hEvent;
603	/** The index of the log flusher queue head (flusher thread side). */
604	uint32_t volatile idxRingHead;
605	/** The index of the log flusher queue tail (EMT side). */
606	uint32_t volatile idxRingTail;
607	/** Set if the log flusher thread is waiting for work and needs poking. */
608	bool volatile fThreadWaiting;
609	/** Set when the log flusher thread should shut down. */
610	bool volatile fThreadShutdown;
611	/** Indicates that the log flusher thread is running. */
612	bool volatile fThreadRunning;
613	bool afPadding2[5];
614	STAMCOUNTER StatFlushes;
615	STAMCOUNTER StatNoWakeUp;
616	/** Logger ring buffer.
617	* This is for communicating with the log flusher thread. */
618	VMMLOGFLUSHERENTRY aRing[VMM_MAX_CPU_COUNT * 2 /loggers/ * 1 /buffer/ + 16 /fudge/];
619	} LogFlusher;
620	/** @} */
621	} VMMR0PERVM;
622
623	RT_C_DECLS_BEGIN
624
625	int vmmInitFormatTypes(void);
626	void vmmTermFormatTypes(void);
627	uint32_t vmmGetBuildType(void);
628
629	#ifdef IN_RING3
630	int vmmR3SwitcherInit(PVM pVM);
631	void vmmR3SwitcherRelocate(PVM pVM, RTGCINTPTR offDelta);
632	#endif /* IN_RING3 */
633
634	#ifdef IN_RING0
635
636	/**
637	* World switcher assembly routine.
638	* It will call VMMRCEntry().
639	*
640	* @returns return code from VMMRCEntry().
641	* @param pVM The cross context VM structure.
642	* @param uArg See VMMRCEntry().
643	* @internal
644	*/
645	DECLASM(int) vmmR0WorldSwitch(PVM pVM, unsigned uArg);
646
647	/**
648	* Callback function for vmmR0CallRing3SetJmp.
649	*
650	* @returns VBox status code.
651	* @param pVM The cross context VM structure.
652	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
653	*/
654	typedef DECLCALLBACKTYPE(int, FNVMMR0SETJMP,(PVMCC pVM, PVMCPUCC pVCpu));
655	/** Pointer to FNVMMR0SETJMP(). */
656	typedef FNVMMR0SETJMP *PFNVMMR0SETJMP;
657
658	/**
659	* The setjmp variant used for calling Ring-3.
660	*
661	* This differs from the normal setjmp in that it will resume VMMRZCallRing3 if we're
662	* in the middle of a ring-3 call. Another differences is the function pointer and
663	* argument. This has to do with resuming code and the stack frame of the caller.
664	*
665	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
666	* @param pJmpBuf The jmp_buf to set.
667	* @param pfn The function to be called when not resuming.
668	* @param pVM The cross context VM structure.
669	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
670	*/
671	DECLASM(int) vmmR0CallRing3SetJmp(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMP pfn, PVM pVM, PVMCPU pVCpu);
672
673
674	/**
675	* Callback function for vmmR0CallRing3SetJmp2.
676	*
677	* @returns VBox status code.
678	* @param pGVM The ring-0 VM structure.
679	* @param idCpu The ID of the calling EMT.
680	*/
681	typedef DECLCALLBACKTYPE(int, FNVMMR0SETJMP2,(PGVM pGVM, VMCPUID idCpu));
682	/** Pointer to FNVMMR0SETJMP2(). */
683	typedef FNVMMR0SETJMP2 *PFNVMMR0SETJMP2;
684
685	/**
686	* Same as vmmR0CallRing3SetJmp except for the function signature.
687	*
688	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
689	* @param pJmpBuf The jmp_buf to set.
690	* @param pfn The function to be called when not resuming.
691	* @param pGVM The ring-0 VM structure.
692	* @param idCpu The ID of the calling EMT.
693	*/
694	DECLASM(int) vmmR0CallRing3SetJmp2(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMP2 pfn, PGVM pGVM, VMCPUID idCpu);
695
696
697	/**
698	* Callback function for vmmR0CallRing3SetJmpEx.
699	*
700	* @returns VBox status code.
701	* @param pvUser The user argument.
702	*/
703	typedef DECLCALLBACKTYPE(int, FNVMMR0SETJMPEX,(void *pvUser));
704	/** Pointer to FNVMMR0SETJMPEX(). */
705	typedef FNVMMR0SETJMPEX *PFNVMMR0SETJMPEX;
706
707	/**
708	* Same as vmmR0CallRing3SetJmp except for the function signature.
709	*
710	* @returns VINF_SUCCESS on success or whatever is passed to vmmR0CallRing3LongJmp.
711	* @param pJmpBuf The jmp_buf to set.
712	* @param pfn The function to be called when not resuming.
713	* @param pvUser The argument of that function.
714	* @param uCallKey Unused call parameter that should be used to help
715	* uniquely identify the call.
716	*/
717	DECLASM(int) vmmR0CallRing3SetJmpEx(PVMMR0JMPBUF pJmpBuf, PFNVMMR0SETJMPEX pfn, void *pvUser, uintptr_t uCallKey);
718
719
720	/**
721	* Worker for VMMRZCallRing3.
722	* This will save the stack and registers.
723	*
724	* @returns rc.
725	* @param pJmpBuf Pointer to the jump buffer.
726	* @param rc The return code.
727	*/
728	DECLASM(int) vmmR0CallRing3LongJmp(PVMMR0JMPBUF pJmpBuf, int rc);
729
730	# ifdef VBOX_WITH_TRIPLE_FAULT_HACK
731	int vmmR0TripleFaultHackInit(void);
732	void vmmR0TripleFaultHackTerm(void);
733	# endif
734
735	#endif /* IN_RING0 */
736
737	RT_C_DECLS_END
738
739	/** @} */
740
741	#endif /* !VMM_INCLUDED_SRC_include_VMMInternal_h */

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

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

Download in other formats: