1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/* $Id: IOMInline.h $ */
/** @file
* IOM - Inlined functions.
*/
/*
* Copyright (C) 2006-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#ifndef ___IOMInline_h
#define ___IOMInline_h
/** @addtogroup grp_iom_int Internals
* @internal
* @{
*/
/**
* Gets the I/O port range for the specified I/O port in the current context.
*
* @returns Pointer to I/O port range.
* @returns NULL if no port registered.
*
* @param pVM Pointer to the VM.
* @param Port The I/O port lookup.
*/
DECLINLINE(CTX_SUFF(PIOMIOPORTRANGE)) iomIOPortGetRange(PVM pVM, RTIOPORT Port)
{
Assert(IOM_IS_SHARED_LOCK_OWNER(pVM));
return (CTX_SUFF(PIOMIOPORTRANGE))RTAvlroIOPortRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->CTX_SUFF(IOPortTree), Port);
}
/**
* Gets the I/O port range for the specified I/O port in the HC.
*
* @returns Pointer to I/O port range.
* @returns NULL if no port registered.
*
* @param pVM Pointer to the VM.
* @param Port The I/O port to lookup.
*/
DECLINLINE(PIOMIOPORTRANGER3) iomIOPortGetRangeR3(PVM pVM, RTIOPORT Port)
{
Assert(IOM_IS_SHARED_LOCK_OWNER(pVM));
return (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeR3, Port);
}
/**
* Gets the MMIO range for the specified physical address in the current context.
*
* @returns Pointer to MMIO range.
* @returns NULL if address not in a MMIO range.
*
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the virtual CPU structure of the caller.
* @param GCPhys Physical address to lookup.
*/
DECLINLINE(PIOMMMIORANGE) iomMmioGetRange(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
{
Assert(IOM_IS_SHARED_LOCK_OWNER(pVM));
PIOMMMIORANGE pRange = pVCpu->iom.s.CTX_SUFF(pMMIORangeLast);
if ( !pRange
|| GCPhys - pRange->GCPhys >= pRange->cb)
pVCpu->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
= (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->MMIOTree, GCPhys);
return pRange;
}
/**
* Retain a MMIO range.
*
* @param pRange The range to release.
*/
DECLINLINE(void) iomMmioRetainRange(PIOMMMIORANGE pRange)
{
uint32_t cRefs = ASMAtomicIncU32(&pRange->cRefs);
Assert(cRefs > 1);
Assert(cRefs < _1M);
NOREF(cRefs);
}
/**
* Gets the referenced MMIO range for the specified physical address in the
* current context.
*
* @returns Pointer to MMIO range.
* @returns NULL if address not in a MMIO range.
*
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the virtual CPU structure of the caller.
* @param GCPhys Physical address to lookup.
*/
DECLINLINE(PIOMMMIORANGE) iomMmioGetRangeWithRef(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
{
int rc = IOM_LOCK_SHARED_EX(pVM, VINF_SUCCESS);
AssertRCReturn(rc, NULL);
PIOMMMIORANGE pRange = pVCpu->iom.s.CTX_SUFF(pMMIORangeLast);
if ( !pRange
|| GCPhys - pRange->GCPhys >= pRange->cb)
pVCpu->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
= (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->MMIOTree, GCPhys);
if (pRange)
iomMmioRetainRange(pRange);
IOM_UNLOCK_SHARED(pVM);
return pRange;
}
/**
* Releases a MMIO range.
*
* @param pVM Pointer to the VM.
* @param pRange The range to release.
*/
DECLINLINE(void) iomMmioReleaseRange(PVM pVM, PIOMMMIORANGE pRange)
{
uint32_t cRefs = ASMAtomicDecU32(&pRange->cRefs);
if (!cRefs)
iomMmioFreeRange(pVM, pRange);
}
#ifdef VBOX_STRICT
/**
* Gets the MMIO range for the specified physical address in the current context.
*
* @returns Pointer to MMIO range.
* @returns NULL if address not in a MMIO range.
*
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the virtual CPU structure of the caller.
* @param GCPhys Physical address to lookup.
*/
DECLINLINE(PIOMMMIORANGE) iomMMIOGetRangeUnsafe(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
{
PIOMMMIORANGE pRange = pVCpu->iom.s.CTX_SUFF(pMMIORangeLast);
if ( !pRange
|| GCPhys - pRange->GCPhys >= pRange->cb)
pVCpu->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
= (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->MMIOTree, GCPhys);
return pRange;
}
#endif /* VBOX_STRICT */
#ifdef VBOX_WITH_STATISTICS
/**
* Gets the MMIO statistics record.
*
* In ring-3 this will lazily create missing records, while in GC/R0 the caller has to
* return the appropriate status to defer the operation to ring-3.
*
* @returns Pointer to MMIO stats.
* @returns NULL if not found (R0/GC), or out of memory (R3).
*
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the virtual CPU structure of the caller.
* @param GCPhys Physical address to lookup.
* @param pRange The MMIO range.
*
* @remarks The caller holds the IOM critical section with shared access prior
* to calling this method. Upon return, the lock has been released!
* This is ugly, but it's a necessary evil since we cannot upgrade read
* locks to write locks and the whole purpose here is calling
* iomR3MMIOStatsCreate.
*/
DECLINLINE(PIOMMMIOSTATS) iomMmioGetStats(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, PIOMMMIORANGE pRange)
{
Assert(IOM_IS_SHARED_LOCK_OWNER(pVM));
/* For large ranges, we'll put everything on the first byte. */
if (pRange->cb > PAGE_SIZE)
GCPhys = pRange->GCPhys;
PIOMMMIOSTATS pStats = pVCpu->iom.s.CTX_SUFF(pMMIOStatsLast);
if ( !pStats
|| pStats->Core.Key != GCPhys)
{
pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pVM->iom.s.CTX_SUFF(pTrees)->MmioStatTree, GCPhys);
# ifdef IN_RING3
if (!pStats)
{
IOM_UNLOCK_SHARED(pVM);
return iomR3MMIOStatsCreate(pVM, GCPhys, pRange->pszDesc);
}
# endif
}
IOM_UNLOCK_SHARED(pVM);
return pStats;
}
#endif /* VBOX_WITH_STATISTICS */
/** @} */
#endif
|
