IOMInternal.h@ 25046

Last change on this file since 25046 was 22924, checked in by vboxsync, 15 years ago
VMM: Made STAM assert on missaligned statistics. Fixed a bunch of mislignments on 32-bit darwin. (burns are expected)
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 19.8 KB

Line
1	/* $Id: IOMInternal.h 22924 2009-09-10 22:00:36Z vboxsync $ */
2	/** @file
3	* IOM - 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 ___IOMInternal_h
23	#define ___IOMInternal_h
24
25	#include <VBox/cdefs.h>
26	#include <VBox/types.h>
27	#include <VBox/iom.h>
28	#include <VBox/stam.h>
29	#include <VBox/pgm.h>
30	#include <VBox/pdmcritsect.h>
31	#include <VBox/param.h>
32	#include <iprt/assert.h>
33	#include <iprt/avl.h>
34
35
36
37	/** @defgroup grp_iom_int Internals
38	* @ingroup grp_iom
39	* @internal
40	* @{
41	*/
42
43	/**
44	* MMIO range descriptor.
45	*/
46	typedef struct IOMMMIORANGE
47	{
48	/** Avl node core with GCPhys as Key and GCPhys + cbSize - 1 as KeyLast. */
49	AVLROGCPHYSNODECORE Core;
50	/** Start physical address. */
51	RTGCPHYS GCPhys;
52	/** Size of the range. */
53	uint32_t cb;
54	uint32_t u32Alignment; /*< Alignment padding. /
55
56	/** Pointer to user argument - R3. */
57	RTR3PTR pvUserR3;
58	/** Pointer to device instance - R3. */
59	PPDMDEVINSR3 pDevInsR3;
60	/** Pointer to write callback function - R3. */
61	R3PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallbackR3;
62	/** Pointer to read callback function - R3. */
63	R3PTRTYPE(PFNIOMMMIOREAD) pfnReadCallbackR3;
64	/** Pointer to fill (memset) callback function - R3. */
65	R3PTRTYPE(PFNIOMMMIOFILL) pfnFillCallbackR3;
66
67	/** Pointer to user argument - R0. */
68	RTR0PTR pvUserR0;
69	/** Pointer to device instance - R0. */
70	PPDMDEVINSR0 pDevInsR0;
71	/** Pointer to write callback function - R0. */
72	R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallbackR0;
73	/** Pointer to read callback function - R0. */
74	R0PTRTYPE(PFNIOMMMIOREAD) pfnReadCallbackR0;
75	/** Pointer to fill (memset) callback function - R0. */
76	R0PTRTYPE(PFNIOMMMIOFILL) pfnFillCallbackR0;
77
78	/** Pointer to user argument - RC. */
79	RTRCPTR pvUserRC;
80	/** Pointer to device instance - RC. */
81	PPDMDEVINSRC pDevInsRC;
82	/** Pointer to write callback function - RC. */
83	RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallbackRC;
84	/** Pointer to read callback function - RC. */
85	RCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallbackRC;
86	/** Pointer to fill (memset) callback function - RC. */
87	RCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallbackRC;
88	/** Alignment padding. */
89	RTRCPTR RCPtrAlignment;
90
91	/** Description / Name. For easing debugging. */
92	R3PTRTYPE(const char *) pszDesc;
93	} IOMMMIORANGE;
94	/** Pointer to a MMIO range descriptor, R3 version. */
95	typedef struct IOMMMIORANGE *PIOMMMIORANGE;
96
97
98	/**
99	* MMIO address statistics. (one address)
100	*
101	* This is a simple way of making on demand statistics, however it's a
102	* bit free with the hypervisor heap memory.
103	*/
104	typedef struct IOMMMIOSTATS
105	{
106	/** Avl node core with the address as Key. */
107	AVLOGCPHYSNODECORE Core;
108
109	/** Number of reads to this address from R3. */
110	STAMCOUNTER ReadR3;
111	/** Profiling read handler overhead in R3. */
112	STAMPROFILEADV ProfReadR3;
113
114	/** Number of writes to this address from R3. */
115	STAMCOUNTER WriteR3;
116	/** Profiling write handler overhead in R3. */
117	STAMPROFILEADV ProfWriteR3;
118
119	/** Number of reads to this address from R0/RC. */
120	STAMCOUNTER ReadRZ;
121	/** Profiling read handler overhead in R0/RC. */
122	STAMPROFILEADV ProfReadRZ;
123	/** Number of reads to this address from R0/RC which was serviced in R3. */
124	STAMCOUNTER ReadRZToR3;
125
126	/** Number of writes to this address from R0/RC. */
127	STAMCOUNTER WriteRZ;
128	/** Profiling write handler overhead in R0/RC. */
129	STAMPROFILEADV ProfWriteRZ;
130	/** Number of writes to this address from R0/RC which was serviced in R3. */
131	STAMCOUNTER WriteRZToR3;
132	} IOMMMIOSTATS;
133	AssertCompileMemberAlignment(IOMMMIOSTATS, ReadR3, 8);
134	/** Pointer to I/O port statistics. */
135	typedef IOMMMIOSTATS *PIOMMMIOSTATS;
136
137
138	/**
139	* I/O port range descriptor, R3 version.
140	*/
141	typedef struct IOMIOPORTRANGER3
142	{
143	/** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
144	AVLROIOPORTNODECORE Core;
145	#if HC_ARCH_BITS == 64 && !defined(RT_OS_WINDOWS)
146	uint32_t u32Alignment; /*< The sizeof(Core) differs. /
147	#endif
148	/** Start I/O port address. */
149	RTIOPORT Port;
150	/** Size of the range. */
151	uint16_t cPorts;
152	/** Pointer to user argument. */
153	RTR3PTR pvUser;
154	/** Pointer to the associated device instance. */
155	R3PTRTYPE(PPDMDEVINS) pDevIns;
156	/** Pointer to OUT callback function. */
157	R3PTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback;
158	/** Pointer to IN callback function. */
159	R3PTRTYPE(PFNIOMIOPORTIN) pfnInCallback;
160	/** Pointer to string OUT callback function. */
161	R3PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
162	/** Pointer to string IN callback function. */
163	R3PTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
164	/** Description / Name. For easing debugging. */
165	R3PTRTYPE(const char *) pszDesc;
166	} IOMIOPORTRANGER3;
167	/** Pointer to I/O port range descriptor, R3 version. */
168	typedef IOMIOPORTRANGER3 *PIOMIOPORTRANGER3;
169
170	/**
171	* I/O port range descriptor, R0 version.
172	*/
173	typedef struct IOMIOPORTRANGER0
174	{
175	/** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
176	AVLROIOPORTNODECORE Core;
177	#if HC_ARCH_BITS == 64 && !defined(RT_OS_WINDOWS)
178	uint32_t u32Alignment; /*< The sizeof(Core) differs. /
179	#endif
180	/** Start I/O port address. */
181	RTIOPORT Port;
182	/** Size of the range. */
183	uint16_t cPorts;
184	/** Pointer to user argument. */
185	RTR0PTR pvUser;
186	/** Pointer to the associated device instance. */
187	R0PTRTYPE(PPDMDEVINS) pDevIns;
188	/** Pointer to OUT callback function. */
189	R0PTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback;
190	/** Pointer to IN callback function. */
191	R0PTRTYPE(PFNIOMIOPORTIN) pfnInCallback;
192	/** Pointer to string OUT callback function. */
193	R0PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
194	/** Pointer to string IN callback function. */
195	R0PTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
196	/** Description / Name. For easing debugging. */
197	R3PTRTYPE(const char *) pszDesc;
198	} IOMIOPORTRANGER0;
199	/** Pointer to I/O port range descriptor, R0 version. */
200	typedef IOMIOPORTRANGER0 *PIOMIOPORTRANGER0;
201
202	/**
203	* I/O port range descriptor, RC version.
204	*/
205	typedef struct IOMIOPORTRANGERC
206	{
207	/** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
208	AVLROIOPORTNODECORE Core;
209	/** Start I/O port address. */
210	RTIOPORT Port;
211	/** Size of the range. */
212	uint16_t cPorts;
213	/** Pointer to user argument. */
214	RTRCPTR pvUser;
215	/** Pointer to the associated device instance. */
216	RCPTRTYPE(PPDMDEVINS) pDevIns;
217	/** Pointer to OUT callback function. */
218	RCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback;
219	/** Pointer to IN callback function. */
220	RCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback;
221	/** Pointer to string OUT callback function. */
222	RCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
223	/** Pointer to string IN callback function. */
224	RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
225	#if HC_ARCH_BITS == 64
226	RTRCPTR RCPtrAlignment; /*< pszDesc is 8 byte aligned. /
227	#endif
228	/** Description / Name. For easing debugging. */
229	R3PTRTYPE(const char *) pszDesc;
230	} IOMIOPORTRANGERC;
231	/** Pointer to I/O port range descriptor, RC version. */
232	typedef IOMIOPORTRANGERC *PIOMIOPORTRANGERC;
233
234
235	/**
236	* I/O port statistics. (one I/O port)
237	*
238	* This is a simple way of making on demand statistics, however it's a
239	* bit free with the hypervisor heap memory.
240	*/
241	typedef struct IOMIOPORTSTATS
242	{
243	/** Avl node core with the port as Key. */
244	AVLOIOPORTNODECORE Core;
245	#if HC_ARCH_BITS != 64 \|\| !defined(RT_OS_WINDOWS)
246	uint32_t u32Alignment; /*< The sizeof(Core) differs. /
247	#endif
248	/** Number of INs to this port from R3. */
249	STAMCOUNTER InR3;
250	/** Profiling IN handler overhead in R3. */
251	STAMPROFILEADV ProfInR3;
252	/** Number of OUTs to this port from R3. */
253	STAMCOUNTER OutR3;
254	/** Profiling OUT handler overhead in R3. */
255	STAMPROFILEADV ProfOutR3;
256
257	/** Number of INs to this port from R0/RC. */
258	STAMCOUNTER InRZ;
259	/** Profiling IN handler overhead in R0/RC. */
260	STAMPROFILEADV ProfInRZ;
261	/** Number of INs to this port from R0/RC which was serviced in R3. */
262	STAMCOUNTER InRZToR3;
263
264	/** Number of OUTs to this port from R0/RC. */
265	STAMCOUNTER OutRZ;
266	/** Profiling OUT handler overhead in R0/RC. */
267	STAMPROFILEADV ProfOutRZ;
268	/** Number of OUTs to this port from R0/RC which was serviced in R3. */
269	STAMCOUNTER OutRZToR3;
270	} IOMIOPORTSTATS;
271	AssertCompileMemberAlignment(IOMIOPORTSTATS, InR3, 8);
272	/** Pointer to I/O port statistics. */
273	typedef IOMIOPORTSTATS *PIOMIOPORTSTATS;
274
275
276	/**
277	* The IOM trees.
278	* These are offset based the nodes and root must be in the same
279	* memory block in HC. The locations of IOM structure and the hypervisor heap
280	* are quite different in R3, R0 and RC.
281	*/
282	typedef struct IOMTREES
283	{
284	/** Tree containing I/O port range descriptors registered for HC (IOMIOPORTRANGEHC). */
285	AVLROIOPORTTREE IOPortTreeR3;
286	/** Tree containing I/O port range descriptors registered for R0 (IOMIOPORTRANGER0). */
287	AVLROIOPORTTREE IOPortTreeR0;
288	/** Tree containing I/O port range descriptors registered for RC (IOMIOPORTRANGERC). */
289	AVLROIOPORTTREE IOPortTreeRC;
290
291	/** Tree containing the MMIO range descriptors (IOMMMIORANGE). */
292	AVLROGCPHYSTREE MMIOTree;
293
294	/** Tree containing I/O port statistics (IOMIOPORTSTATS). */
295	AVLOIOPORTTREE IOPortStatTree;
296	/** Tree containing MMIO statistics (IOMMMIOSTATS). */
297	AVLOGCPHYSTREE MMIOStatTree;
298	} IOMTREES;
299	/** Pointer to the IOM trees. */
300	typedef IOMTREES *PIOMTREES;
301
302
303	/**
304	* Converts an IOM pointer into a VM pointer.
305	* @returns Pointer to the VM structure the PGM is part of.
306	* @param pIOM Pointer to IOM instance data.
307	*/
308	#define IOM2VM(pIOM) ( (PVM)((char*)pIOM - pIOM->offVM) )
309
310	/**
311	* IOM Data (part of VM)
312	*/
313	typedef struct IOM
314	{
315	/** Offset to the VM structure. */
316	RTINT offVM;
317
318	/** Pointer to the trees - RC ptr. */
319	RCPTRTYPE(PIOMTREES) pTreesRC;
320	/** Pointer to the trees - R3 ptr. */
321	R3PTRTYPE(PIOMTREES) pTreesR3;
322	/** Pointer to the trees - R0 ptr. */
323	R0PTRTYPE(PIOMTREES) pTreesR0;
324
325	/** The ring-0 address of IOMMMIOHandler. */
326	R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnMMIOHandlerR0;
327	/** The RC address of IOMMMIOHandler. */
328	RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnMMIOHandlerRC;
329	#if HC_ARCH_BITS == 64
330	RTRCPTR padding;
331	#endif
332
333	/** Lock serializing EMT access to IOM. */
334	PDMCRITSECT EmtLock;
335
336	/** @name Caching of I/O Port and MMIO ranges and statistics.
337	* (Saves quite some time in rep outs/ins instruction emulation.)
338	* @{ */
339	R3PTRTYPE(PIOMIOPORTRANGER3) pRangeLastReadR3;
340	R3PTRTYPE(PIOMIOPORTRANGER3) pRangeLastWriteR3;
341	R3PTRTYPE(PIOMIOPORTSTATS) pStatsLastReadR3;
342	R3PTRTYPE(PIOMIOPORTSTATS) pStatsLastWriteR3;
343	R3PTRTYPE(PIOMMMIORANGE) pMMIORangeLastR3;
344	R3PTRTYPE(PIOMMMIOSTATS) pMMIOStatsLastR3;
345
346	R0PTRTYPE(PIOMIOPORTRANGER0) pRangeLastReadR0;
347	R0PTRTYPE(PIOMIOPORTRANGER0) pRangeLastWriteR0;
348	R0PTRTYPE(PIOMIOPORTSTATS) pStatsLastReadR0;
349	R0PTRTYPE(PIOMIOPORTSTATS) pStatsLastWriteR0;
350	R0PTRTYPE(PIOMMMIORANGE) pMMIORangeLastR0;
351	R0PTRTYPE(PIOMMMIOSTATS) pMMIOStatsLastR0;
352
353	RCPTRTYPE(PIOMIOPORTRANGERC) pRangeLastReadRC;
354	RCPTRTYPE(PIOMIOPORTRANGERC) pRangeLastWriteRC;
355	RCPTRTYPE(PIOMIOPORTSTATS) pStatsLastReadRC;
356	RCPTRTYPE(PIOMIOPORTSTATS) pStatsLastWriteRC;
357	RCPTRTYPE(PIOMMMIORANGE) pMMIORangeLastRC;
358	RCPTRTYPE(PIOMMMIOSTATS) pMMIOStatsLastRC;
359	/** @} */
360
361	/** @name I/O Port statistics.
362	* @{ */
363	STAMCOUNTER StatInstIn;
364	STAMCOUNTER StatInstOut;
365	STAMCOUNTER StatInstIns;
366	STAMCOUNTER StatInstOuts;
367	/** @} */
368
369	/** @name MMIO statistics.
370	* @{ */
371	STAMPROFILE StatRZMMIOHandler;
372	STAMCOUNTER StatRZMMIOFailures;
373
374	STAMPROFILE StatRZInstMov;
375	STAMPROFILE StatRZInstCmp;
376	STAMPROFILE StatRZInstAnd;
377	STAMPROFILE StatRZInstOr;
378	STAMPROFILE StatRZInstXor;
379	STAMPROFILE StatRZInstBt;
380	STAMPROFILE StatRZInstTest;
381	STAMPROFILE StatRZInstXchg;
382	STAMPROFILE StatRZInstStos;
383	STAMPROFILE StatRZInstLods;
384	#ifdef IOM_WITH_MOVS_SUPPORT
385	STAMPROFILEADV StatRZInstMovs;
386	STAMPROFILE StatRZInstMovsToMMIO;
387	STAMPROFILE StatRZInstMovsFromMMIO;
388	STAMPROFILE StatRZInstMovsMMIO;
389	#endif
390	STAMCOUNTER StatRZInstOther;
391
392	STAMCOUNTER StatRZMMIO1Byte;
393	STAMCOUNTER StatRZMMIO2Bytes;
394	STAMCOUNTER StatRZMMIO4Bytes;
395	STAMCOUNTER StatRZMMIO8Bytes;
396
397	STAMCOUNTER StatR3MMIOHandler;
398
399	RTUINT cMovsMaxBytes;
400	RTUINT cStosMaxBytes;
401	/** @} */
402	} IOM;
403	/** Pointer to IOM instance data. */
404	typedef IOM *PIOM;
405
406
407	/**
408	* IOM per virtual CPU instance data.
409	*/
410	typedef struct IOMCPU
411	{
412	/** For saving stack space, the disassembler state is allocated here instead of
413	* on the stack.
414	* @note The DISCPUSTATE structure is not R3/R0/RZ clean! */
415	union
416	{
417	/** The disassembler scratch space. */
418	DISCPUSTATE DisState;
419	/** Padding. */
420	uint8_t abDisStatePadding[DISCPUSTATE_PADDING_SIZE];
421	};
422	uint8_t Dummy[16];
423	} IOMCPU;
424	/** Pointer to IOM per virtual CPU instance data. */
425	typedef IOMCPU *PIOMCPU;
426
427
428	RT_C_DECLS_BEGIN
429
430	#ifdef IN_RING3
431	PIOMIOPORTSTATS iomR3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc);
432	PIOMMMIOSTATS iomR3MMIOStatsCreate(PVM pVM, RTGCPHYS GCPhys, const char *pszDesc);
433	#endif /* IN_RING3 */
434
435	VMMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
436	#ifdef IN_RING3
437	DECLCALLBACK(int) IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhys, void pvPhys, void pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
438	#endif
439
440
441	/**
442	* Gets the I/O port range for the specified I/O port in the current context.
443	*
444	* @returns Pointer to I/O port range.
445	* @returns NULL if no port registered.
446	*
447	* @param pIOM IOM instance data.
448	* @param Port Port to lookup.
449	*/
450	DECLINLINE(CTX_SUFF(PIOMIOPORTRANGE)) iomIOPortGetRange(PIOM pIOM, RTIOPORT Port)
451	{
452	#ifdef IN_RING3
453	if (PDMCritSectIsInitialized(&pIOM->EmtLock))
454	#endif
455	Assert(IOMIsLockOwner(IOM2VM(pIOM)));
456	CTX_SUFF(PIOMIOPORTRANGE) pRange = (CTX_SUFF(PIOMIOPORTRANGE))RTAvlroIOPortRangeGet(&pIOM->CTX_SUFF(pTrees)->CTX_SUFF(IOPortTree), Port);
457	return pRange;
458	}
459
460
461	/**
462	* Gets the I/O port range for the specified I/O port in the HC.
463	*
464	* @returns Pointer to I/O port range.
465	* @returns NULL if no port registered.
466	*
467	* @param pIOM IOM instance data.
468	* @param Port Port to lookup.
469	*/
470	DECLINLINE(PIOMIOPORTRANGER3) iomIOPortGetRangeR3(PIOM pIOM, RTIOPORT Port)
471	{
472	#ifdef IN_RING3
473	if (PDMCritSectIsInitialized(&pIOM->EmtLock))
474	#endif
475	Assert(IOMIsLockOwner(IOM2VM(pIOM)));
476	PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pIOM->CTX_SUFF(pTrees)->IOPortTreeR3, Port);
477	return pRange;
478	}
479
480
481	/**
482	* Gets the MMIO range for the specified physical address in the current context.
483	*
484	* @returns Pointer to MMIO range.
485	* @returns NULL if address not in a MMIO range.
486	*
487	* @param pIOM IOM instance data.
488	* @param GCPhys Physical address to lookup.
489	*/
490	DECLINLINE(PIOMMMIORANGE) iomMMIOGetRange(PIOM pIOM, RTGCPHYS GCPhys)
491	{
492	#ifdef IN_RING3
493	if (PDMCritSectIsInitialized(&pIOM->EmtLock))
494	#endif
495	Assert(IOMIsLockOwner(IOM2VM(pIOM)));
496	PIOMMMIORANGE pRange = pIOM->CTX_SUFF(pMMIORangeLast);
497	if ( !pRange
498	\|\| GCPhys - pRange->GCPhys >= pRange->cb)
499	pIOM->CTX_SUFF(pMMIORangeLast) = pRange = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pIOM->CTX_SUFF(pTrees)->MMIOTree, GCPhys);
500	return pRange;
501	}
502
503	#ifdef VBOX_STRICT
504	/**
505	* Gets the MMIO range for the specified physical address in the current context.
506	*
507	* @returns Pointer to MMIO range.
508	* @returns NULL if address not in a MMIO range.
509	*
510	* @param pIOM IOM instance data.
511	* @param GCPhys Physical address to lookup.
512	*/
513	DECLINLINE(PIOMMMIORANGE) iomMMIOGetRangeUnsafe(PIOM pIOM, RTGCPHYS GCPhys)
514	{
515	PIOMMMIORANGE pRange = pIOM->CTX_SUFF(pMMIORangeLast);
516	if ( !pRange
517	\|\| GCPhys - pRange->GCPhys >= pRange->cb)
518	pIOM->CTX_SUFF(pMMIORangeLast) = pRange = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pIOM->CTX_SUFF(pTrees)->MMIOTree, GCPhys);
519	return pRange;
520	}
521	#endif
522
523
524	#ifdef VBOX_WITH_STATISTICS
525	/**
526	* Gets the MMIO statistics record.
527	*
528	* In ring-3 this will lazily create missing records, while in GC/R0 the caller has to
529	* return the appropriate status to defer the operation to ring-3.
530	*
531	* @returns Pointer to MMIO stats.
532	* @returns NULL if not found (R0/GC), or out of memory (R3).
533	*
534	* @param pIOM IOM instance data.
535	* @param GCPhys Physical address to lookup.
536	* @param pRange The MMIO range.
537	*/
538	DECLINLINE(PIOMMMIOSTATS) iomMMIOGetStats(PIOM pIOM, RTGCPHYS GCPhys, PIOMMMIORANGE pRange)
539	{
540	Assert(IOMIsLockOwner(IOM2VM(pIOM)));
541	/* For large ranges, we'll put everything on the first byte. */
542	if (pRange->cb > PAGE_SIZE)
543	GCPhys = pRange->GCPhys;
544
545	PIOMMMIOSTATS pStats = pIOM->CTX_SUFF(pMMIOStatsLast);
546	if ( !pStats
547	\|\| pStats->Core.Key != GCPhys)
548	{
549	pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pIOM->CTX_SUFF(pTrees)->MMIOStatTree, GCPhys);
550	# ifdef IN_RING3
551	if (!pStats)
552	pStats = iomR3MMIOStatsCreate(IOM2VM(pIOM), GCPhys, pRange->pszDesc);
553	# endif
554	}
555	return pStats;
556	}
557	#endif
558
559	/* IOM locking helpers. */
560	int iomLock(PVM pVM);
561	int iomTryLock(PVM pVM);
562	void iomUnlock(PVM pVM);
563
564	/* Disassembly helpers used in IOMAll.cpp & IOMAllMMIO.cpp */
565	bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint64_t pu64Data, unsigned pcbSize);
566	bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint64_t u32Data);
567
568	RT_C_DECLS_END
569
570
571	#ifdef IN_RING3
572
573	#endif
574
575	/** @} */
576
577	#endif /* ___IOMInternal_h */

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

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

Download in other formats: