IOMAll.cpp@ 4050

Last change on this file since 4050 was 3145, checked in by vboxsync, 17 years ago
Fixed incorrect IOM return checks.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 50.3 KB

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

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

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

Download in other formats: