IOMAll.cpp@ 5999

Last change on this file since 5999 was 5999, checked in by vboxsync, 17 years ago
The Giant CDDL Dual-License Header Change.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 50.1 KB

Line
1	/* $Id: IOMAll.cpp 5999 2007-12-07 15:05:06Z vboxsync $ */
2	/** @file
3	* IOM - Input / Output Monitor - Any Context.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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	/*******************************************************************************
19	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_IOM
22	#include <VBox/iom.h>
23	#include <VBox/mm.h>
24	#include <VBox/param.h>
25	#include "IOMInternal.h"
26	#include <VBox/vm.h>
27	#include <VBox/selm.h>
28	#include <VBox/trpm.h>
29	#include <VBox/pgm.h>
30	#include <VBox/cpum.h>
31	#include <VBox/err.h>
32	#include <VBox/log.h>
33	#include <iprt/assert.h>
34
35
36	/*******************************************************************************
37	* Global Variables *
38	*******************************************************************************/
39
40	/**
41	* Array for fast recode of the operand size (1/2/4/8 bytes) to bit shift value.
42	*/
43	static const unsigned g_aSize2Shift[] =
44	{
45	~0, /* 0 - invalid */
46	0, /* 1 == 2^0 /
47	1, /* 2 == 2^1 /
48	~0, /* 3 - invalid */
49	2, /* 4 == 2^2 /
50	~0, /* 5 - invalid */
51	~0, /* 6 - invalid */
52	~0, /* 7 - invalid */
53	3 /* 8 == 2^3 /
54	};
55
56	/**
57	* Macro for fast recode of the operand size (1/2/4/8 bytes) to bit shift value.
58	*/
59	#define SIZE2SHIFT(cb) (g_aSize2Shift[cb])
60
61	/**
62	* Calculates the size of register parameter.
63	*
64	* @returns 1, 2, 4 on success.
65	* @returns 0 if non-register parameter.
66	* @param pCpu Pointer to current disassembler context.
67	* @param pParam Pointer to parameter of instruction to proccess.
68	*/
69	static unsigned iomGCGetRegSize(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam)
70	{
71	if (pParam->flags & (USE_BASE \| USE_INDEX \| USE_SCALE \| USE_DISPLACEMENT8 \| USE_DISPLACEMENT16 \| USE_DISPLACEMENT32 \| USE_IMMEDIATE8 \| USE_IMMEDIATE16 \| USE_IMMEDIATE32 \| USE_IMMEDIATE16_SX8 \| USE_IMMEDIATE32_SX8))
72	return 0;
73
74	if (pParam->flags & USE_REG_GEN32)
75	return 4;
76
77	if (pParam->flags & USE_REG_GEN16)
78	return 2;
79
80	if (pParam->flags & USE_REG_GEN8)
81	return 1;
82
83	if (pParam->flags & USE_REG_SEG)
84	return 2;
85	return 0;
86	}
87
88	/**
89	* Returns the contents of register or immediate data of instruction's parameter.
90	*
91	* @returns true on success.
92	*
93	* @param pCpu Pointer to current disassembler context.
94	* @param pParam Pointer to parameter of instruction to proccess.
95	* @param pRegFrame Pointer to CPUMCTXCORE guest structure.
96	* @param pu32Data Where to store retrieved data.
97	* @param pcbSize Where to store the size of data (1, 2, 4).
98	*/
99	static bool iomGCGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t pu32Data, unsigned pcbSize)
100	{
101	if (pParam->flags & (USE_BASE \| USE_INDEX \| USE_SCALE \| USE_DISPLACEMENT8 \| USE_DISPLACEMENT16 \| USE_DISPLACEMENT32))
102	{
103	*pcbSize = 0;
104	*pu32Data = 0;
105	return false;
106	}
107
108	if (pParam->flags & USE_REG_GEN32)
109	{
110	*pcbSize = 4;
111	DISFetchReg32(pRegFrame, pParam->base.reg_gen32, pu32Data);
112	return true;
113	}
114
115	if (pParam->flags & USE_REG_GEN16)
116	{
117	*pcbSize = 2;
118	DISFetchReg16(pRegFrame, pParam->base.reg_gen16, (uint16_t *)pu32Data);
119	return true;
120	}
121
122	if (pParam->flags & USE_REG_GEN8)
123	{
124	*pcbSize = 1;
125	DISFetchReg8(pRegFrame, pParam->base.reg_gen8, (uint8_t *)pu32Data);
126	return true;
127	}
128
129	if (pParam->flags & (USE_IMMEDIATE32\|USE_IMMEDIATE32_SX8))
130	{
131	*pcbSize = 4;
132	*pu32Data = (uint32_t)pParam->parval;
133	return true;
134	}
135
136	if (pParam->flags & (USE_IMMEDIATE16\|USE_IMMEDIATE16_SX8))
137	{
138	*pcbSize = 2;
139	*pu32Data = (uint16_t)pParam->parval;
140	return true;
141	}
142
143	if (pParam->flags & USE_IMMEDIATE8)
144	{
145	*pcbSize = 1;
146	*pu32Data = (uint8_t)pParam->parval;
147	return true;
148	}
149
150	if (pParam->flags & USE_REG_SEG)
151	{
152	*pcbSize = 2;
153	DISFetchRegSeg(pRegFrame, pParam->base.reg_seg, (RTSEL *)pu32Data);
154	return true;
155	} /* Else - error. */
156
157	*pcbSize = 0;
158	*pu32Data = 0;
159	return false;
160	}
161
162
163	/**
164	* Saves data to 8/16/32 general purpose or segment register defined by
165	* instruction's parameter.
166	*
167	* @returns true on success.
168	* @param pCpu Pointer to current disassembler context.
169	* @param pParam Pointer to parameter of instruction to proccess.
170	* @param pRegFrame Pointer to CPUMCTXCORE guest structure.
171	* @param u32Data 8/16/32 bit data to store.
172	*/
173	static bool iomGCSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
174	{
175	if (pParam->flags & (USE_BASE \| USE_INDEX \| USE_SCALE \| USE_DISPLACEMENT8 \| USE_DISPLACEMENT16 \| USE_DISPLACEMENT32 \| USE_IMMEDIATE8 \| USE_IMMEDIATE16 \| USE_IMMEDIATE32 \| USE_IMMEDIATE32_SX8 \| USE_IMMEDIATE16_SX8))
176	{
177	return false;
178	}
179
180	if (pParam->flags & USE_REG_GEN32)
181	{
182	DISWriteReg32(pRegFrame, pParam->base.reg_gen32, u32Data);
183	return true;
184	}
185
186	if (pParam->flags & USE_REG_GEN16)
187	{
188	DISWriteReg16(pRegFrame, pParam->base.reg_gen16, (uint16_t)u32Data);
189	return true;
190	}
191
192	if (pParam->flags & USE_REG_GEN8)
193	{
194	DISWriteReg8(pRegFrame, pParam->base.reg_gen8, (uint8_t)u32Data);
195	return true;
196	}
197
198	if (pParam->flags & USE_REG_SEG)
199	{
200	DISWriteRegSeg(pRegFrame, pParam->base.reg_seg, (RTSEL)u32Data);
201	return true;
202	}
203
204	/* Else - error. */
205	return false;
206	}
207
208	/*
209	* Internal - statistics only.
210	*/
211	inline void iomGCMMIOStatLength(PVM pVM, unsigned cb)
212	{
213	#ifdef VBOX_WITH_STATISTICS
214	switch (cb)
215	{
216	case 1:
217	STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO1Byte);
218	break;
219	case 2:
220	STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO2Bytes);
221	break;
222	case 4:
223	STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO4Bytes);
224	break;
225	default:
226	/* No way. */
227	AssertMsgFailed(("Invalid data length %d\n", cb));
228	break;
229	}
230	#else
231	NOREF(pVM); NOREF(cb);
232	#endif
233	}
234
235	#ifndef IN_RING0
236	/**
237	* Registers a Port IO GC handler.
238	*
239	* This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
240	* using IOMIOPortRegisterR3() before calling this function.
241	*
242	*
243	* @returns VBox status code.
244	*
245	* @param pVM VM handle.
246	* @param pDevIns PDM device instance owning the port range.
247	* @param PortStart First port number in the range.
248	* @param cPorts Number of ports to register.
249	* @param pvUser User argument for the callbacks.
250	* @param pfnOutCallback Pointer to function which is gonna handle OUT operations in GC.
251	* @param pfnInCallback Pointer to function which is gonna handle IN operations in GC.
252	* @param pfnOutStrCallback Pointer to function which is gonna handle string OUT operations in GC.
253	* @param pfnInStrCallback Pointer to function which is gonna handle string IN operations in GC.
254	* @param pszDesc Pointer to description string. This must not be freed.
255	*/
256	IOMDECL(int) IOMIOPortRegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTGCPTR pvUser,
257	GCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, GCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
258	GCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, GCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback, const char *pszDesc)
259	{
260	LogFlow(("IOMIOPortRegisterGC: pDevIns=%p PortStart=%#x cPorts=%#x pvUser=%VGv pfnOutCallback=%VGv pfnInCallback=%VGv pfnOutStrCallback=%VGv pfnInStrCallback=%VGv pszDesc=%s\n",
261	pDevIns, PortStart, cPorts, pvUser, pfnOutCallback, pfnInCallback, pfnOutStrCallback, pfnInStrCallback, pszDesc));
262
263	/*
264	* Validate input.
265	*/
266	if ( (RTUINT)PortStart + cPorts <= (RTUINT)PortStart
267	\|\| (RTUINT)PortStart + cPorts > 0x10000)
268	{
269	AssertMsgFailed(("Invalid port range %#x-%#x! (%s)\n", PortStart, (RTUINT)PortStart + (cPorts - 1), pszDesc));
270	return VERR_IOM_INVALID_IOPORT_RANGE;
271	}
272	RTIOPORT PortLast = PortStart + (cPorts - 1);
273	if (!pfnOutCallback && !pfnInCallback)
274	{
275	AssertMsgFailed(("Invalid port range %#x-%#x! No callbacks! (%s)\n", PortStart, PortLast, pszDesc));
276	return VERR_INVALID_PARAMETER;
277	}
278
279	/*
280	* Validate that there are ring-3 ranges for the ports.
281	*/
282	RTIOPORT Port = PortStart;
283	while (Port <= PortLast && Port >= PortStart)
284	{
285	PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeR3, Port);
286	if (!pRange)
287	{
288	AssertMsgFailed(("No R3! Port=#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
289	return VERR_IOM_NO_HC_IOPORT_RANGE;
290	}
291	#ifndef IOM_NO_PDMINS_CHECKS
292	#ifndef IN_GC
293	if (pRange->pDevIns != pDevIns)
294	#else
295	if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
296	#endif
297	{
298	AssertMsgFailed(("Not owner! Port=%#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
299	return VERR_IOM_NOT_IOPORT_RANGE_OWNER;
300	}
301	#endif
302	Port = pRange->Core.KeyLast + 1;
303	}
304
305	/* Flush the IO port lookup cache */
306	IOMFlushCache(pVM);
307
308	/*
309	* Allocate new range record and initialize it.
310	*/
311	PIOMIOPORTRANGEGC pRange;
312	int rc = MMHyperAlloc(pVM, sizeof(pRange), 0, MM_TAG_IOM, (void *)&pRange);
313	if (VBOX_SUCCESS(rc))
314	{
315	pRange->Core.Key = PortStart;
316	pRange->Core.KeyLast = PortLast;
317	pRange->Port = PortStart;
318	pRange->cPorts = cPorts;
319	pRange->pvUser = pvUser;
320	pRange->pfnOutCallback = pfnOutCallback;
321	pRange->pfnInCallback = pfnInCallback;
322	pRange->pfnOutStrCallback = pfnOutStrCallback;
323	pRange->pfnInStrCallback = pfnInStrCallback;
324	#ifdef IN_GC
325	pRange->pDevIns = pDevIns;
326	pRange->pszDesc = MMHyperGC2HC(pVM, (void *)pszDesc);
327	#else
328	pRange->pDevIns = MMHyperHC2GC(pVM, pDevIns);
329	pRange->pszDesc = pszDesc;
330	#endif
331
332	/*
333	* Insert it.
334	*/
335	if (RTAvlroIOPortInsert(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeGC, &pRange->Core))
336	return VINF_SUCCESS;
337
338	/* conflict. */
339	AssertMsgFailed(("Port range %#x-%#x (%s) conflicts with existing range(s)!\n", PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
340	MMHyperFree(pVM, pRange);
341	rc = VERR_IOM_IOPORT_RANGE_CONFLICT;
342	}
343
344	return rc;
345	}
346
347
348	/**
349	* Registers a Memory Mapped I/O GC handler range.
350	*
351	* This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
352	* using IOMMMIORegisterR3() before calling this function.
353	*
354	*
355	* @returns VBox status code.
356	*
357	* @param pVM VM handle.
358	* @param pDevIns PDM device instance owning the MMIO range.
359	* @param GCPhysStart First physical address in the range.
360	* @param cbRange The size of the range (in bytes).
361	* @param pvUser User argument for the callbacks.
362	* @param pfnWriteCallback Pointer to function which is gonna handle Write operations.
363	* @param pfnReadCallback Pointer to function which is gonna handle Read operations.
364	* @param pfnFillCallback Pointer to function which is gonna handle Fill/memset operations.
365	* @param pszDesc Pointer to description string. This must not be freed.
366	*/
367	IOMDECL(int) IOMMMIORegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
368	GCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, GCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
369	GCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
370	{
371	LogFlow(("IOMMMIORegisterGC: pDevIns=%p GCPhysStart=%#x cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
372	pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
373
374	/*
375	* Validate input.
376	*/
377	if (!pfnWriteCallback && !pfnReadCallback)
378	{
379	AssertMsgFailed(("No callbacks! %#x LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
380	return VERR_INVALID_PARAMETER;
381	}
382	RTGCPHYS GCPhysLast = GCPhysStart + (cbRange - 1);
383	if (GCPhysLast < GCPhysStart)
384	{
385	AssertMsgFailed(("Wrapped! %#x LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
386	return VERR_IOM_INVALID_MMIO_RANGE;
387	}
388
389	/*
390	* Check that a ring-3 MMIO range exists.
391	*/
392	RTGCPHYS GCPhys = GCPhysStart;
393	while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
394	{
395	PIOMMMIORANGER3 pRange = (PIOMMMIORANGER3)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeR3, GCPhys);
396	if (!pRange)
397	{
398	AssertMsgFailed(("No R3 range! GCPhys=%#x %#x LB%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc));
399	return VERR_IOM_NO_HC_MMIO_RANGE;
400	}
401	#ifndef IOM_NO_PDMINS_CHECKS
402	#ifndef IN_GC
403	if (pRange->pDevIns != pDevIns)
404	#else
405	if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
406	#endif
407	{
408	AssertMsgFailed(("Not owner! GCPhys=%#x %#x LB%#x %s / %#x-%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc,
409	pRange->Core.Key, pRange->Core.KeyLast, MMHyper2HC(pVM, (uintptr_t)pRange->pszDesc)));
410	return VERR_IOM_NOT_MMIO_RANGE_OWNER;
411	}
412	#endif /* !IOM_NO_PDMINS_CHECKS */
413	/* next */
414	Assert(GCPhys <= pRange->Core.KeyLast);
415	GCPhys = pRange->Core.KeyLast + 1;
416	}
417
418
419	/*
420	* Allocate new range record and initialize it.
421	*/
422	PIOMMMIORANGEGC pRange;
423	int rc = MMHyperAlloc(pVM, sizeof(pRange), 0, MM_TAG_IOM, (void *)&pRange);
424	if (VBOX_SUCCESS(rc))
425	{
426	pRange->Core.Key = GCPhysStart;
427	pRange->Core.KeyLast = GCPhysStart + (cbRange - 1);
428	pRange->GCPhys = GCPhysStart;
429	pRange->cbSize = cbRange;
430	pRange->pvUser = pvUser;
431	pRange->pfnReadCallback = pfnReadCallback;
432	pRange->pfnWriteCallback= pfnWriteCallback;
433	pRange->pfnFillCallback = pfnFillCallback;
434	#ifdef IN_GC
435	pRange->pDevIns = pDevIns;
436	pRange->pszDesc = MMHyperGC2HC(pVM, (void *)pszDesc);
437	#else
438	pRange->pDevIns = MMHyperHC2GC(pVM, pDevIns);
439	pRange->pszDesc = pszDesc;
440	#endif
441
442	/*
443	* Try insert it.
444	*/
445	if (RTAvlroGCPhysInsert(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeGC, &pRange->Core))
446	return VINF_SUCCESS;
447
448	AssertMsgFailed(("Conflict! %#x LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
449	MMHyperFree(pVM, pRange);
450	rc = VERR_IOM_MMIO_RANGE_CONFLICT;
451	}
452
453	return rc;
454	}
455	#endif
456
457	/**
458	* Registers a Port IO R0 handler.
459	*
460	* This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
461	* using IOMR3IOPortRegisterR3() before calling this function.
462	*
463	*
464	* @returns VBox status code.
465	*
466	* @param pVM VM handle.
467	* @param pDevIns PDM device instance owning the port range.
468	* @param PortStart First port number in the range.
469	* @param cPorts Number of ports to register.
470	* @param pvUser User argument for the callbacks.
471	* @param pfnOutCallback Pointer to function which is gonna handle OUT operations in GC.
472	* @param pfnInCallback Pointer to function which is gonna handle IN operations in GC.
473	* @param pfnOutStrCallback Pointer to function which is gonna handle OUT operations in GC.
474	* @param pfnInStrCallback Pointer to function which is gonna handle IN operations in GC.
475	* @param pszDesc Pointer to description string. This must not be freed.
476	*/
477	IOMDECL(int) IOMIOPortRegisterR0(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTR0PTR pvUser,
478	R0PTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, R0PTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
479	R0PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, R0PTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback,
480	const char *pszDesc)
481	{
482	LogFlow(("IOMIOPortRegisterR0: pDevIns=%p PortStart=%#x cPorts=%#x pvUser=%VHv pfnOutCallback=%VGv pfnInCallback=%VGv pfnOutStrCallback=%VGv pfnInStrCallback=%VGv pszDesc=%s\n",
483	pDevIns, PortStart, cPorts, pvUser, pfnOutCallback, pfnInCallback, pfnOutStrCallback, pfnInStrCallback, pszDesc));
484
485	/*
486	* Validate input.
487	*/
488	if ( (RTUINT)PortStart + cPorts <= (RTUINT)PortStart
489	\|\| (RTUINT)PortStart + cPorts > 0x10000)
490	{
491	AssertMsgFailed(("Invalid port range %#x-%#x! (%s)\n", PortStart, (RTUINT)PortStart + (cPorts - 1), pszDesc));
492	return VERR_IOM_INVALID_IOPORT_RANGE;
493	}
494	RTIOPORT PortLast = PortStart + (cPorts - 1);
495	if (!pfnOutCallback && !pfnInCallback)
496	{
497	AssertMsgFailed(("Invalid port range %#x-%#x! No callbacks! (%s)\n", PortStart, PortLast, pszDesc));
498	return VERR_INVALID_PARAMETER;
499	}
500
501	/*
502	* Validate that there are ring-3 ranges for the ports.
503	*/
504	RTIOPORT Port = PortStart;
505	while (Port <= PortLast && Port >= PortStart)
506	{
507	PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeR3, Port);
508	if (!pRange)
509	{
510	AssertMsgFailed(("No R3! Port=#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
511	return VERR_IOM_NO_HC_IOPORT_RANGE;
512	}
513	#ifndef IOM_NO_PDMINS_CHECKS
514	# ifndef IN_GC
515	if (pRange->pDevIns != pDevIns)
516	# else
517	if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
518	# endif
519	{
520	AssertMsgFailed(("Not owner! Port=%#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
521	return VERR_IOM_NOT_IOPORT_RANGE_OWNER;
522	}
523	#endif
524	Port = pRange->Core.KeyLast + 1;
525	}
526
527	/* Flush the IO port lookup cache */
528	IOMFlushCache(pVM);
529
530	/*
531	* Allocate new range record and initialize it.
532	*/
533	PIOMIOPORTRANGER0 pRange;
534	int rc = MMHyperAlloc(pVM, sizeof(pRange), 0, MM_TAG_IOM, (void *)&pRange);
535	if (VBOX_SUCCESS(rc))
536	{
537	pRange->Core.Key = PortStart;
538	pRange->Core.KeyLast = PortLast;
539	pRange->Port = PortStart;
540	pRange->cPorts = cPorts;
541	pRange->pvUser = pvUser;
542	pRange->pfnOutCallback = pfnOutCallback;
543	pRange->pfnInCallback = pfnInCallback;
544	pRange->pfnOutStrCallback = pfnOutStrCallback;
545	pRange->pfnInStrCallback = pfnInStrCallback;
546	#ifdef IN_GC
547	pRange->pDevIns = MMHyperGCToR0(pVM, pDevIns);
548	pRange->pszDesc = MMHyperGCToR3(pVM, (void *)pszDesc);
549	#elif defined(IN_RING3)
550	pRange->pDevIns = MMHyperR3ToR0(pVM, pDevIns);
551	pRange->pszDesc = pszDesc;
552	#else
553	pRange->pDevIns = pDevIns;
554	pRange->pszDesc = MMHyperR0ToR3(pVM, (RTR0PTR)pszDesc);
555	#endif
556
557	/*
558	* Insert it.
559	*/
560	if (RTAvlroIOPortInsert(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeR0, &pRange->Core))
561	return VINF_SUCCESS;
562
563	/* conflict. */
564	AssertMsgFailed(("Port range %#x-%#x (%s) conflicts with existing range(s)!\n", PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
565	MMHyperFree(pVM, pRange);
566	rc = VERR_IOM_IOPORT_RANGE_CONFLICT;
567	}
568
569	return rc;
570	}
571
572
573	/**
574	* Registers a Memory Mapped I/O R0 handler range.
575	*
576	* This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
577	* using IOMMR3MIORegisterHC() before calling this function.
578	*
579	*
580	* @returns VBox status code.
581	*
582	* @param pVM VM handle.
583	* @param pDevIns PDM device instance owning the MMIO range.
584	* @param GCPhysStart First physical address in the range.
585	* @param cbRange The size of the range (in bytes).
586	* @param pvUser User argument for the callbacks.
587	* @param pfnWriteCallback Pointer to function which is gonna handle Write operations.
588	* @param pfnReadCallback Pointer to function which is gonna handle Read operations.
589	* @param pfnFillCallback Pointer to function which is gonna handle Fill/memset operations.
590	* @param pszDesc Pointer to description string. This must not be freed.
591	*/
592	IOMDECL(int) IOMMMIORegisterR0(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
593	R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, R0PTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
594	R0PTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
595	{
596	LogFlow(("IOMMMIORegisterR0: pDevIns=%p GCPhysStart=%#x cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
597	pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
598
599	/*
600	* Validate input.
601	*/
602	if (!pfnWriteCallback && !pfnReadCallback)
603	{
604	AssertMsgFailed(("No callbacks! %#x LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
605	return VERR_INVALID_PARAMETER;
606	}
607	RTGCPHYS GCPhysLast = GCPhysStart + (cbRange - 1);
608	if (GCPhysLast < GCPhysStart)
609	{
610	AssertMsgFailed(("Wrapped! %#x LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
611	return VERR_IOM_INVALID_MMIO_RANGE;
612	}
613
614	/*
615	* Check that a ring-3 MMIO range exists.
616	*/
617	RTGCPHYS GCPhys = GCPhysStart;
618	while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
619	{
620	PIOMMMIORANGER3 pRange = (PIOMMMIORANGER3)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeR3, GCPhys);
621	if (!pRange)
622	{
623	AssertMsgFailed(("No R3 range! GCPhys=%#x %#x LB%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc));
624	return VERR_IOM_NO_HC_MMIO_RANGE;
625	}
626	#ifndef IOM_NO_PDMINS_CHECKS
627	# ifndef IN_GC
628	if (pRange->pDevIns != pDevIns)
629	# else
630	if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
631	# endif
632	{
633	AssertMsgFailed(("Not owner! GCPhys=%#x %#x LB%#x %s / %#x-%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc,
634	pRange->Core.Key, pRange->Core.KeyLast, MMHyper2HC(pVM, (uintptr_t)pRange->pszDesc)));
635	return VERR_IOM_NOT_MMIO_RANGE_OWNER;
636	}
637	#endif /* !IOM_NO_PDMINS_CHECKS */
638	/* next */
639	Assert(GCPhys <= pRange->Core.KeyLast);
640	GCPhys = pRange->Core.KeyLast + 1;
641	}
642
643
644	/*
645	* Allocate new range record and initialize it.
646	*/
647	PIOMMMIORANGER0 pRange;
648	int rc = MMHyperAlloc(pVM, sizeof(pRange), 0, MM_TAG_IOM, (void *)&pRange);
649	if (VBOX_SUCCESS(rc))
650	{
651	pRange->Core.Key = GCPhysStart;
652	pRange->Core.KeyLast = GCPhysStart + (cbRange - 1);
653	pRange->GCPhys = GCPhysStart;
654	pRange->cbSize = cbRange;
655	pRange->pvUser = pvUser;
656	pRange->pfnReadCallback = pfnReadCallback;
657	pRange->pfnWriteCallback= pfnWriteCallback;
658	pRange->pfnFillCallback = pfnFillCallback;
659	#ifdef IN_GC
660	pRange->pDevIns = MMHyperGCToR0(pVM, pDevIns);
661	pRange->pszDesc = MMHyperGCToR3(pVM, (void *)pszDesc);
662	#elif defined(IN_RING3)
663	pRange->pDevIns = MMHyperR3ToR0(pVM, pDevIns);
664	pRange->pszDesc = pszDesc;
665	#else
666	pRange->pDevIns = pDevIns;
667	pRange->pszDesc = MMHyperR0ToR3(pVM, (RTR0PTR)pszDesc);
668	#endif
669
670	/*
671	* Try insert it.
672	*/
673	if (RTAvlroGCPhysInsert(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeR0, &pRange->Core))
674	return VINF_SUCCESS;
675
676	AssertMsgFailed(("Conflict! %#x LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
677	MMHyperFree(pVM, pRange);
678	rc = VERR_IOM_MMIO_RANGE_CONFLICT;
679	}
680
681	return rc;
682	}
683
684
685	/**
686	* Flushes the IOM port & statistics lookup cache
687	*
688	* @param pVM The VM.
689	*/
690	IOMDECL(void) IOMFlushCache(PVM pVM)
691	{
692	/*
693	* Caching of port and statistics (saves some time in rep outs/ins instruction emulation)
694	*/
695	pVM->iom.s.pRangeLastReadGC = 0;
696	pVM->iom.s.pRangeLastWriteGC = 0;
697	pVM->iom.s.pStatsLastReadGC = 0;
698	pVM->iom.s.pStatsLastWriteGC = 0;
699
700	pVM->iom.s.pRangeLastReadR3 = 0;
701	pVM->iom.s.pRangeLastWriteR3 = 0;
702	pVM->iom.s.pStatsLastReadR3 = 0;
703	pVM->iom.s.pStatsLastWriteR3 = 0;
704
705	pVM->iom.s.pRangeLastReadR0 = 0;
706	pVM->iom.s.pRangeLastWriteR0 = 0;
707	pVM->iom.s.pStatsLastReadR0 = 0;
708	pVM->iom.s.pStatsLastWriteR0 = 0;
709	}
710
711
712	//#undef LOG_GROUP
713	//#define LOG_GROUP LOG_GROUP_IOM_IOPORT
714
715	/**
716	* Reads an I/O port register.
717	*
718	* @returns Strict VBox status code. Informational status codes other than the one documented
719	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
720	* @retval VINF_SUCCESS Success.
721	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
722	* status code must be passed on to EM.
723	* @retval VINF_IOM_HC_IOPORT_READ Defer the read to ring-3. (R0/GC only)
724	*
725	* @param pVM VM handle.
726	* @param Port The port to read.
727	* @param pu32Value Where to store the value read.
728	* @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
729	*/
730	IOMDECL(int) IOMIOPortRead(PVM pVM, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue)
731	{
732	#ifdef VBOX_WITH_STATISTICS
733	/*
734	* Get the statistics record.
735	*/
736	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastRead);
737	if (!pStats \|\| pStats->Core.Key != Port)
738	{
739	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
740	if (pStats)
741	CTXALLSUFF(pVM->iom.s.pStatsLastRead) = pStats;
742	}
743	#endif
744
745	/*
746	* Get handler for current context.
747	*/
748	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastRead);
749	if ( !pRange
750	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
751	{
752	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
753	if (pRange)
754	CTXALLSUFF(pVM->iom.s.pRangeLastRead) = pRange;
755	}
756	#ifdef IN_GC
757	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
758	#endif
759
760	if (pRange)
761	{
762	/*
763	* Found a range.
764	*/
765	#ifndef IN_RING3
766	if (!pRange->pfnInCallback)
767	{
768	# ifdef VBOX_WITH_STATISTICS
769	if (pStats)
770	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
771	# endif
772	return VINF_IOM_HC_IOPORT_READ;
773	}
774	#endif
775	/* call the device. */
776	#ifdef VBOX_WITH_STATISTICS
777	if (pStats)
778	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfIn), a);
779	#endif
780	int rc = pRange->pfnInCallback(pRange->pDevIns, pRange->pvUser, Port, pu32Value, cbValue);
781	#ifdef VBOX_WITH_STATISTICS
782	if (pStats)
783	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfIn), a);
784	if (rc == VINF_SUCCESS && pStats)
785	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
786	# ifndef IN_RING3
787	else if (rc == VINF_IOM_HC_IOPORT_READ && pStats)
788	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
789	# endif
790	#endif
791	if (rc == VERR_IOM_IOPORT_UNUSED)
792	{
793	/* make return value */
794	rc = VINF_SUCCESS;
795	switch (cbValue)
796	{
797	case 1: (uint8_t )pu32Value = 0xff; break;
798	case 2: (uint16_t )pu32Value = 0xffff; break;
799	case 4: (uint32_t )pu32Value = 0xffffffff; break;
800	default:
801	AssertMsgFailed(("Invalid I/O port size %d. Port=%d\n", cbValue, Port));
802	return VERR_IOM_INVALID_IOPORT_SIZE;
803	}
804	}
805	Log3(("IOMIOPortRead: Port=%RTiop pu32=%08RX32 cb=%d rc=%Vrc\n", Port, pu32Value, cbValue, rc));
806	return rc;
807	}
808
809	#ifndef IN_RING3
810	/*
811	* Handler in ring-3?
812	*/
813	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
814	if (pRangeR3)
815	{
816	# ifdef VBOX_WITH_STATISTICS
817	if (pStats)
818	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
819	# endif
820	return VINF_IOM_HC_IOPORT_READ;
821	}
822	#endif
823
824	/*
825	* Ok, no handler for this port.
826	*/
827	#ifdef VBOX_WITH_STATISTICS
828	if (pStats)
829	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
830	else
831	{
832	# ifndef IN_RING3
833	/* Ring-3 will have to create the statistics record. */
834	return VINF_IOM_HC_IOPORT_READ;
835	# else
836	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
837	if (pStats)
838	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
839	# endif
840	}
841	#endif
842
843	/* make return value */
844	switch (cbValue)
845	{
846	case 1: (uint8_t )pu32Value = 0xff; break;
847	case 2: (uint16_t )pu32Value = 0xffff; break;
848	case 4: (uint32_t )pu32Value = 0xffffffff; break;
849	default:
850	AssertMsgFailed(("Invalid I/O port size %d. Port=%d\n", cbValue, Port));
851	return VERR_IOM_INVALID_IOPORT_SIZE;
852	}
853	Log3(("IOMIOPortRead: Port=%RTiop pu32=%08RX32 cb=%d rc=VINF_SUCCESS\n", Port, pu32Value, cbValue));
854	return VINF_SUCCESS;
855	}
856
857
858	/**
859	* Reads the string buffer of an I/O port register.
860	*
861	* @returns Strict VBox status code. Informational status codes other than the one documented
862	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
863	* @retval VINF_SUCCESS Success.
864	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
865	* status code must be passed on to EM.
866	* @retval VINF_IOM_HC_IOPORT_READ Defer the read to ring-3. (R0/GC only)
867	*
868	* @param pVM VM handle.
869	* @param Port The port to read.
870	* @param pGCPtrDst Pointer to the destination buffer (GC, incremented appropriately).
871	* @param pcTransfers Pointer to the number of transfer units to read, on return remaining transfer units.
872	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
873	* */
874	IOMDECL(int) IOMIOPortReadString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfers, unsigned cb)
875	{
876	#ifdef LOG_ENABLED
877	const RTGCUINTREG cTransfers = *pcTransfers;
878	#endif
879	#ifdef VBOX_WITH_STATISTICS
880	/*
881	* Get the statistics record.
882	*/
883	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastRead);
884	if (!pStats \|\| pStats->Core.Key != Port)
885	{
886	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
887	if (pStats)
888	CTXALLSUFF(pVM->iom.s.pStatsLastRead) = pStats;
889	}
890	#endif
891
892	/*
893	* Get handler for current context.
894	*/
895	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastRead);
896	if ( !pRange
897	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
898	{
899	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
900	if (pRange)
901	CTXALLSUFF(pVM->iom.s.pRangeLastRead) = pRange;
902	}
903	#ifdef IN_GC
904	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
905	#endif
906
907	if (pRange)
908	{
909	/*
910	* Found a range.
911	*/
912	#ifndef IN_RING3
913	if (!pRange->pfnInStrCallback)
914	{
915	# ifdef VBOX_WITH_STATISTICS
916	if (pStats)
917	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
918	# endif
919	return VINF_IOM_HC_IOPORT_READ;
920	}
921	#endif
922	/* call the device. */
923	#ifdef VBOX_WITH_STATISTICS
924	if (pStats)
925	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfIn), a);
926	#endif
927
928	int rc = pRange->pfnInStrCallback(pRange->pDevIns, pRange->pvUser, Port, pGCPtrDst, pcTransfers, cb);
929	#ifdef VBOX_WITH_STATISTICS
930	if (pStats)
931	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfIn), a);
932	if (rc == VINF_SUCCESS && pStats)
933	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
934	# ifndef IN_RING3
935	else if (rc == VINF_IOM_HC_IOPORT_READ && pStats)
936	STAM_COUNTER_INC(&pStats->CTXALLMID(In, ToR3));
937	# endif
938	#endif
939	Log3(("IOMIOPortReadStr: Port=%RTiop pGCPtrDst=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=%Vrc\n",
940	Port, pGCPtrDst, pcTransfers, cTransfers, *pcTransfers, cb, rc));
941	return rc;
942	}
943
944	#ifndef IN_RING3
945	/*
946	* Handler in ring-3?
947	*/
948	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
949	if (pRangeR3)
950	{
951	# ifdef VBOX_WITH_STATISTICS
952	if (pStats)
953	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
954	# endif
955	return VINF_IOM_HC_IOPORT_READ;
956	}
957	#endif
958
959	/*
960	* Ok, no handler for this port.
961	*/
962	#ifdef VBOX_WITH_STATISTICS
963	if (pStats)
964	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
965	else
966	{
967	# ifndef IN_RING3
968	/* Ring-3 will have to create the statistics record. */
969	return VINF_IOM_HC_IOPORT_READ;
970	# else
971	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
972	if (pStats)
973	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
974	# endif
975	}
976	#endif
977
978	Log3(("IOMIOPortReadStr: Port=%RTiop pGCPtrDst=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=VINF_SUCCESS\n",
979	Port, pGCPtrDst, pcTransfers, cTransfers, *pcTransfers, cb));
980	return VINF_SUCCESS;
981	}
982
983
984	/**
985	* Writes to an I/O port register.
986	*
987	* @returns Strict VBox status code. Informational status codes other than the one documented
988	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
989	* @retval VINF_SUCCESS Success.
990	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
991	* status code must be passed on to EM.
992	* @retval VINF_IOM_HC_IOPORT_WRITE Defer the write to ring-3. (R0/GC only)
993	*
994	* @param pVM VM handle.
995	* @param Port The port to write to.
996	* @param u32Value The value to write.
997	* @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
998	*/
999	IOMDECL(int) IOMIOPortWrite(PVM pVM, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
1000	{
1001	/** @todo bird: When I get time, I'll remove the GC tree and link the GC entries to the ring-3 node. */
1002	#ifdef VBOX_WITH_STATISTICS
1003	/*
1004	* Find the statistics record.
1005	*/
1006	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastWrite);
1007	if (!pStats \|\| pStats->Core.Key != Port)
1008	{
1009	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
1010	if (pStats)
1011	CTXALLSUFF(pVM->iom.s.pStatsLastWrite) = pStats;
1012	}
1013	#endif
1014
1015	/*
1016	* Get handler for current context.
1017	*/
1018	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastWrite);
1019	if ( !pRange
1020	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
1021	{
1022	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
1023	if (pRange)
1024	CTXALLSUFF(pVM->iom.s.pRangeLastWrite) = pRange;
1025	}
1026	#ifdef IN_GC
1027	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange));
1028	#endif
1029
1030	if (pRange)
1031	{
1032	/*
1033	* Found a range.
1034	*/
1035	#ifndef IN_RING3
1036	if (!pRange->pfnOutCallback)
1037	{
1038	# ifdef VBOX_WITH_STATISTICS
1039	if (pStats)
1040	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1041	# endif
1042	return VINF_IOM_HC_IOPORT_WRITE;
1043	}
1044	#endif
1045	/* call the device. */
1046	#ifdef VBOX_WITH_STATISTICS
1047	if (pStats)
1048	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfOut), a);
1049	#endif
1050	int rc = pRange->pfnOutCallback(pRange->pDevIns, pRange->pvUser, Port, u32Value, cbValue);
1051
1052	#ifdef VBOX_WITH_STATISTICS
1053	if (pStats)
1054	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfOut), a);
1055	if (rc == VINF_SUCCESS && pStats)
1056	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1057	# ifndef IN_RING3
1058	else if (rc == VINF_IOM_HC_IOPORT_WRITE && pStats)
1059	STAM_COUNTER_INC(&pStats->CTXALLMID(Out, ToR3));
1060	# endif
1061	#endif
1062	Log3(("IOMIOPortWrite: Port=%RTiop u32=%08RX32 cb=%d rc=%Vrc\n", Port, u32Value, cbValue, rc));
1063	return rc;
1064	}
1065
1066	#ifndef IN_RING3
1067	/*
1068	* Handler in ring-3?
1069	*/
1070	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
1071	if (pRangeR3)
1072	{
1073	# ifdef VBOX_WITH_STATISTICS
1074	if (pStats)
1075	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1076	# endif
1077	return VINF_IOM_HC_IOPORT_WRITE;
1078	}
1079	#endif
1080
1081	/*
1082	* Ok, no handler for that port.
1083	*/
1084	#ifdef VBOX_WITH_STATISTICS
1085	/* statistics. */
1086	if (pStats)
1087	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1088	else
1089	{
1090	# ifndef IN_RING3
1091	/* R3 will have to create the statistics record. */
1092	return VINF_IOM_HC_IOPORT_WRITE;
1093	# else
1094	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
1095	if (pStats)
1096	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1097	# endif
1098	}
1099	#endif
1100	Log3(("IOMIOPortWrite: Port=%RTiop u32=%08RX32 cb=%d nop\n", Port, u32Value, cbValue));
1101	return VINF_SUCCESS;
1102	}
1103
1104
1105	/**
1106	* Writes the string buffer of an I/O port register.
1107	*
1108	* @returns Strict VBox status code. Informational status codes other than the one documented
1109	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
1110	* @retval VINF_SUCCESS Success.
1111	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
1112	* status code must be passed on to EM.
1113	* @retval VINF_IOM_HC_IOPORT_WRITE Defer the write to ring-3. (R0/GC only)
1114	*
1115	* @param pVM VM handle.
1116	* @param Port The port to write.
1117	* @param pGCPtrSrc Pointer to the source buffer (GC, incremented appropriately).
1118	* @param pcTransfers Pointer to the number of transfer units to write, on return remaining transfer units.
1119	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
1120	* */
1121	IOMDECL(int) IOMIOPortWriteString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfers, unsigned cb)
1122	{
1123	#ifdef LOG_ENABLED
1124	const RTGCUINTREG cTransfers = *pcTransfers;
1125	#endif
1126	#ifdef VBOX_WITH_STATISTICS
1127	/*
1128	* Get the statistics record.
1129	*/
1130	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastWrite);
1131	if (!pStats \|\| pStats->Core.Key != Port)
1132	{
1133	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
1134	if (pStats)
1135	CTXALLSUFF(pVM->iom.s.pStatsLastWrite) = pStats;
1136	}
1137	#endif
1138
1139	/*
1140	* Get handler for current context.
1141	*/
1142	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastWrite);
1143	if ( !pRange
1144	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
1145	{
1146	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
1147	if (pRange)
1148	CTXALLSUFF(pVM->iom.s.pRangeLastWrite) = pRange;
1149	}
1150	#ifdef IN_GC
1151	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
1152	#endif
1153
1154	if (pRange)
1155	{
1156	/*
1157	* Found a range.
1158	*/
1159	#ifndef IN_RING3
1160	if (!pRange->pfnOutStrCallback)
1161	{
1162	# ifdef VBOX_WITH_STATISTICS
1163	if (pStats)
1164	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1165	# endif
1166	return VINF_IOM_HC_IOPORT_WRITE;
1167	}
1168	#endif
1169	/* call the device. */
1170	#ifdef VBOX_WITH_STATISTICS
1171	if (pStats)
1172	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfOut), a);
1173	#endif
1174	int rc = pRange->pfnOutStrCallback(pRange->pDevIns, pRange->pvUser, Port, pGCPtrSrc, pcTransfers, cb);
1175	#ifdef VBOX_WITH_STATISTICS
1176	if (pStats)
1177	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfOut), a);
1178	if (rc == VINF_SUCCESS && pStats)
1179	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1180	# ifndef IN_RING3
1181	else if (rc == VINF_IOM_HC_IOPORT_WRITE && pStats)
1182	STAM_COUNTER_INC(&pStats->CTXALLMID(Out, ToR3));
1183	# endif
1184	#endif
1185	Log3(("IOMIOPortWriteStr: Port=%RTiop pGCPtrSrc=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=%Vrc\n",
1186	Port, pGCPtrSrc, pcTransfers, cTransfers, *pcTransfers, cb, rc));
1187	return rc;
1188	}
1189
1190	#ifndef IN_RING3
1191	/*
1192	* Handler in ring-3?
1193	*/
1194	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
1195	if (pRangeR3)
1196	{
1197	# ifdef VBOX_WITH_STATISTICS
1198	if (pStats)
1199	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1200	# endif
1201	return VINF_IOM_HC_IOPORT_WRITE;
1202	}
1203	#endif
1204
1205	/*
1206	* Ok, no handler for this port.
1207	*/
1208	#ifdef VBOX_WITH_STATISTICS
1209	if (pStats)
1210	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1211	else
1212	{
1213	# ifndef IN_RING3
1214	/* Ring-3 will have to create the statistics record. */
1215	return VINF_IOM_HC_IOPORT_WRITE;
1216	# else
1217	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
1218	if (pStats)
1219	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1220	# endif
1221	}
1222	#endif
1223
1224	Log3(("IOMIOPortWriteStr: Port=%RTiop pGCPtrSrc=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=VINF_SUCCESS\n",
1225	Port, pGCPtrSrc, pcTransfers, cTransfers, *pcTransfers, cb));
1226	return VINF_SUCCESS;
1227	}
1228
1229
1230	/**
1231	* Checks that the operation is allowed according to the IOPL
1232	* level and I/O bitmap.
1233	*
1234	* @returns Strict VBox status code. Informational status codes other than the one documented
1235	* here are to be treated as internal failure.
1236	* @retval VINF_SUCCESS Success.
1237	* @retval VINF_EM_RAW_GUEST_TRAP The exception was left pending. (TRPMRaiseXcptErr)
1238	* @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
1239	* @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
1240	*
1241	* @param pVM VM handle.
1242	* @param pCtxCore Pointer to register frame.
1243	* @param Port The I/O port number.
1244	* @param cb The access size.
1245	*/
1246	IOMDECL(int) IOMInterpretCheckPortIOAccess(PVM pVM, PCPUMCTXCORE pCtxCore, RTIOPORT Port, unsigned cb)
1247	{
1248	/*
1249	* If this isn't ring-0, we have to check for I/O privileges.
1250	*/
1251	uint32_t efl = CPUMRawGetEFlags(pVM, pCtxCore);
1252	uint32_t cpl = CPUMGetGuestCPL(pVM, pCtxCore);
1253
1254	if ( ( cpl > 0
1255	&& X86_EFL_GET_IOPL(efl) < cpl)
1256	\|\| pCtxCore->eflags.Bits.u1VM /* IOPL is ignored in V86 mode; always check TSS bitmap */
1257	)
1258	{
1259	/*
1260	* Get TSS location and check if there can be a I/O bitmap.
1261	*/
1262	RTGCUINTPTR GCPtrTss;
1263	RTGCUINTPTR cbTss;
1264	bool fCanHaveIOBitmap;
1265	int rc = SELMGetTSSInfo(pVM, &GCPtrTss, &cbTss, &fCanHaveIOBitmap);
1266	if (VBOX_FAILURE(rc))
1267	{
1268	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d %Vrc -> #GP(0)\n", Port, cb, rc));
1269	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1270	}
1271
1272	if ( !fCanHaveIOBitmap
1273	\|\| cbTss <= sizeof(VBOXTSS))
1274	{
1275	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d cbTss=%#x fCanHaveIOBitmap=%RTbool -> #GP(0)\n",
1276	Port, cb, cbTss, fCanHaveIOBitmap));
1277	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1278	}
1279
1280	/*
1281	* Fetch the I/O bitmap offset.
1282	*/
1283	uint16_t offIOPB;
1284	rc = PGMPhysInterpretedRead(pVM, pCtxCore, &offIOPB, GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap), sizeof(offIOPB));
1285	if (rc != VINF_SUCCESS)
1286	{
1287	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d GCPtrTss=%VGv %Vrc\n",
1288	Port, cb, GCPtrTss, rc));
1289	return rc;
1290	}
1291
1292	/*
1293	* Check the limit and read the two bitmap bytes.
1294	*/
1295	uint32_t offTss = offIOPB + (Port >> 3);
1296	if (offTss + 1 >= cbTss)
1297	{
1298	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d offTss=%#x cbTss=%#x -> #GP(0)\n",
1299	Port, cb, offTss, cbTss));
1300	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1301	}
1302	uint16_t u16;
1303	rc = PGMPhysInterpretedRead(pVM, pCtxCore, &u16, GCPtrTss + offTss, sizeof(u16));
1304	if (rc != VINF_SUCCESS)
1305	{
1306	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d GCPtrTss=%VGv offTss=%#x -> %Vrc\n",
1307	Port, cb, GCPtrTss, offTss, rc));
1308	return rc;
1309	}
1310
1311	/*
1312	* All the bits must be clear.
1313	*/
1314	if ((u16 >> (Port & 7)) & ((1 << cb) - 1))
1315	{
1316	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d u16=%#x -> #GP(0)\n",
1317	Port, cb, u16, offTss));
1318	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1319	}
1320	LogFlow(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d offTss=%#x cbTss=%#x u16=%#x -> OK\n",
1321	Port, cb, u16, offTss, cbTss));
1322	}
1323	return VINF_SUCCESS;
1324	}
1325
1326	/**
1327	* IN <AL\|AX\|EAX>, <DX\|imm16>
1328	*
1329	* @returns Strict VBox status code. Informational status codes other than the one documented
1330	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
1331	* @retval VINF_SUCCESS Success.
1332	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
1333	* status code must be passed on to EM.
1334	* @retval VINF_IOM_HC_IOPORT_READ Defer the read to ring-3. (R0/GC only)
1335	* @retval VINF_EM_RAW_GUEST_TRAP The exception was left pending. (TRPMRaiseXcptErr)
1336	* @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
1337	* @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
1338	*
1339	* @param pVM The virtual machine (GC pointer ofcourse).
1340	* @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
1341	* @param pCpu Disassembler CPU state.
1342	*/
1343	IOMDECL(int) IOMInterpretIN(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
1344	{
1345	#ifdef IN_GC
1346	STAM_COUNTER_INC(&pVM->iom.s.StatGCInstIn);
1347	#endif
1348
1349	/*
1350	* Get port number from second parameter.
1351	* And get the register size from the first parameter.
1352	*/
1353	uint32_t uPort = 0;
1354	unsigned cbSize = 0;
1355	bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uPort, &cbSize);
1356	AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
1357
1358	cbSize = iomGCGetRegSize(pCpu, &pCpu->param1);
1359	Assert(cbSize > 0);
1360	int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
1361	if (rc == VINF_SUCCESS)
1362	{
1363	/*
1364	* Attemp to read the port.
1365	*/
1366	uint32_t u32Data = ~0U;
1367	rc = IOMIOPortRead(pVM, uPort, &u32Data, cbSize);
1368	if (IOM_SUCCESS(rc))
1369	{
1370	/*
1371	* Store the result in the AL\|AX\|EAX register.
1372	*/
1373	fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
1374	AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
1375	}
1376	else
1377	AssertMsg(rc == VINF_IOM_HC_IOPORT_READ \|\| VBOX_FAILURE(rc), ("%Vrc\n", rc));
1378	}
1379	else
1380	AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP \|\| rc == VINF_TRPM_XCPT_DISPATCHED \|\| rc == VINF_TRPM_XCPT_DISPATCHED \|\| VBOX_FAILURE(rc), ("%Vrc\n", rc));
1381	return rc;
1382	}
1383
1384
1385	/**
1386	* OUT <DX\|imm16>, <AL\|AX\|EAX>
1387	*
1388	* @returns Strict VBox status code. Informational status codes other than the one documented
1389	* here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
1390	* @retval VINF_SUCCESS Success.
1391	* @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
1392	* status code must be passed on to EM.
1393	* @retval VINF_IOM_HC_IOPORT_WRITE Defer the write to ring-3. (R0/GC only)
1394	* @retval VINF_EM_RAW_GUEST_TRAP The exception was left pending. (TRPMRaiseXcptErr)
1395	* @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
1396	* @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
1397	*
1398	* @param pVM The virtual machine (GC pointer ofcourse).
1399	* @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
1400	* @param pCpu Disassembler CPU state.
1401	*/
1402	IOMDECL(int) IOMInterpretOUT(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
1403	{
1404	#ifdef IN_GC
1405	STAM_COUNTER_INC(&pVM->iom.s.StatGCInstOut);
1406	#endif
1407
1408	/*
1409	* Get port number from first parameter.
1410	* And get the register size and value from the second parameter.
1411	*/
1412	uint32_t uPort = 0;
1413	unsigned cbSize = 0;
1414	bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
1415	AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
1416
1417	int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
1418	if (rc == VINF_SUCCESS)
1419	{
1420	uint32_t u32Data = 0;
1421	fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
1422	AssertMsg(fRc, ("Failed to get reg value!\n")); NOREF(fRc);
1423
1424	/*
1425	* Attempt to write to the port.
1426	*/
1427	rc = IOMIOPortWrite(pVM, uPort, u32Data, cbSize);
1428	AssertMsg(rc == VINF_SUCCESS \|\| rc == VINF_IOM_HC_IOPORT_WRITE \|\| (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) \|\| VBOX_FAILURE(rc), ("%Vrc\n", rc));
1429	}
1430	else
1431	AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP \|\| rc == VINF_TRPM_XCPT_DISPATCHED \|\| rc == VINF_TRPM_XCPT_DISPATCHED \|\| VBOX_FAILURE(rc), ("%Vrc\n", rc));
1432	return rc;
1433	}

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

source: vbox/trunk/src/VBox/VMM/VMMAll/IOMAll.cpp@ 5999

Download in other formats: