IOMInternal.h@ 13299

Last change on this file since 13299 was 13042, checked in by vboxsync, 16 years ago
#1865: More PGM changes.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 18.8 KB

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

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

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

Download in other formats: