VirtualBox

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

Last change on this file since 24912 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 */
46typedef 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. */
95typedef 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 */
104typedef 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;
133AssertCompileMemberAlignment(IOMMMIOSTATS, ReadR3, 8);
134/** Pointer to I/O port statistics. */
135typedef IOMMMIOSTATS *PIOMMMIOSTATS;
136
137
138/**
139 * I/O port range descriptor, R3 version.
140 */
141typedef 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. */
168typedef IOMIOPORTRANGER3 *PIOMIOPORTRANGER3;
169
170/**
171 * I/O port range descriptor, R0 version.
172 */
173typedef 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. */
200typedef IOMIOPORTRANGER0 *PIOMIOPORTRANGER0;
201
202/**
203 * I/O port range descriptor, RC version.
204 */
205typedef 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. */
232typedef 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 */
241typedef 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;
271AssertCompileMemberAlignment(IOMIOPORTSTATS, InR3, 8);
272/** Pointer to I/O port statistics. */
273typedef 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 */
282typedef 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. */
300typedef 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 */
313typedef 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. */
404typedef IOM *PIOM;
405
406
407/**
408 * IOM per virtual CPU instance data.
409 */
410typedef 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. */
425typedef IOMCPU *PIOMCPU;
426
427
428RT_C_DECLS_BEGIN
429
430#ifdef IN_RING3
431PIOMIOPORTSTATS iomR3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc);
432PIOMMMIOSTATS iomR3MMIOStatsCreate(PVM pVM, RTGCPHYS GCPhys, const char *pszDesc);
433#endif /* IN_RING3 */
434
435VMMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
436#ifdef IN_RING3
437DECLCALLBACK(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 */
450DECLINLINE(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 */
470DECLINLINE(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 */
490DECLINLINE(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 */
513DECLINLINE(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 */
538DECLINLINE(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. */
560int iomLock(PVM pVM);
561int iomTryLock(PVM pVM);
562void iomUnlock(PVM pVM);
563
564/* Disassembly helpers used in IOMAll.cpp & IOMAllMMIO.cpp */
565bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint64_t *pu64Data, unsigned *pcbSize);
566bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint64_t u32Data);
567
568RT_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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use