IOMAll.cpp@ 2368

Last change on this file since 2368 was 2270, checked in by vboxsync, 18 years ago
Stricter pointer typechecking. (R0 vs R3)
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 45.9 KB

Line
1	/* $Id: IOMAll.cpp 2270 2007-04-20 12:58:15Z vboxsync $ */
2	/** @file
3	* IOM - Input / Output Monitor - Any Context.
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung 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 VBox status code.
722	*
723	* @param pVM VM handle.
724	* @param Port The port to read.
725	* @param pu32Value Where to store the value read.
726	* @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
727	*/
728	IOMDECL(int) IOMIOPortRead(PVM pVM, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue)
729	{
730	#ifdef VBOX_WITH_STATISTICS
731	/*
732	* Get the statistics record.
733	*/
734	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastRead);
735	if (!pStats \|\| pStats->Core.Key != Port)
736	{
737	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
738	if (pStats)
739	CTXALLSUFF(pVM->iom.s.pStatsLastRead) = pStats;
740	}
741	#endif
742
743	/*
744	* Get handler for current context.
745	*/
746	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastRead);
747	if ( !pRange
748	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
749	{
750	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
751	if (pRange)
752	CTXALLSUFF(pVM->iom.s.pRangeLastRead) = pRange;
753	}
754	#ifdef IN_GC
755	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
756	#endif
757
758	if (pRange)
759	{
760	/*
761	* Found a range.
762	*/
763	#ifndef IN_RING3
764	if (!pRange->pfnInCallback)
765	{
766	# ifdef VBOX_WITH_STATISTICS
767	if (pStats)
768	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
769	# endif
770	return VINF_IOM_HC_IOPORT_READ;
771	}
772	#endif
773	/* call the device. */
774	#ifdef VBOX_WITH_STATISTICS
775	if (pStats)
776	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfIn), a);
777	#endif
778	int rc = pRange->pfnInCallback(pRange->pDevIns, pRange->pvUser, Port, pu32Value, cbValue);
779	#ifdef VBOX_WITH_STATISTICS
780	if (pStats)
781	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfIn), a);
782	if (rc == VINF_SUCCESS && pStats)
783	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
784	# ifndef IN_RING3
785	else if (rc == VINF_IOM_HC_IOPORT_READ && pStats)
786	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
787	# endif
788	#endif
789	if (rc == VERR_IOM_IOPORT_UNUSED)
790	{
791	/* make return value */
792	rc = VINF_SUCCESS;
793	switch (cbValue)
794	{
795	case 1: (uint8_t )pu32Value = 0xff; break;
796	case 2: (uint16_t )pu32Value = 0xffff; break;
797	case 4: (uint32_t )pu32Value = 0xffffffff; break;
798	default:
799	AssertMsgFailed(("Invalid I/O port size %d. Port=%d\n", cbValue, Port));
800	return VERR_IOM_INVALID_IOPORT_SIZE;
801	}
802	}
803	Log3(("IOMIOPortRead: Port=%RTiop pu32=%08RX32 cb=%d rc=%Vrc\n", Port, pu32Value, cbValue, rc));
804	return rc;
805	}
806
807	#ifndef IN_RING3
808	/*
809	* Handler in ring-3?
810	*/
811	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
812	if (pRangeR3)
813	{
814	# ifdef VBOX_WITH_STATISTICS
815	if (pStats)
816	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
817	# endif
818	return VINF_IOM_HC_IOPORT_READ;
819	}
820	#endif
821
822	/*
823	* Ok, no handler for this port.
824	*/
825	#ifdef VBOX_WITH_STATISTICS
826	if (pStats)
827	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
828	else
829	{
830	# ifndef IN_RING3
831	/* Ring-3 will have to create the statistics record. */
832	return VINF_IOM_HC_IOPORT_READ;
833	# else
834	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
835	if (pStats)
836	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
837	# endif
838	}
839	#endif
840
841	/* make return value */
842	switch (cbValue)
843	{
844	case 1: (uint8_t )pu32Value = 0xff; break;
845	case 2: (uint16_t )pu32Value = 0xffff; break;
846	case 4: (uint32_t )pu32Value = 0xffffffff; break;
847	default:
848	AssertMsgFailed(("Invalid I/O port size %d. Port=%d\n", cbValue, Port));
849	return VERR_IOM_INVALID_IOPORT_SIZE;
850	}
851	Log3(("IOMIOPortRead: Port=%RTiop pu32=%08RX32 cb=%d rc=VINF_SUCCESS\n", Port, pu32Value, cbValue));
852	return VINF_SUCCESS;
853	}
854
855
856	/**
857	* Reads the string buffer of an I/O port register.
858	*
859	* @returns VBox status code.
860	*
861	* @param pVM VM handle.
862	* @param Port The port to read.
863	* @param pGCPtrDst Pointer to the destination buffer (GC, incremented appropriately).
864	* @param pcTransfers Pointer to the number of transfer units to read, on return remaining transfer units.
865	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
866	* */
867	IOMDECL(int) IOMIOPortReadString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfers, unsigned cb)
868	{
869	#ifdef LOG_ENABLED
870	const RTGCUINTREG cTransfers = *pcTransfers;
871	#endif
872	#ifdef VBOX_WITH_STATISTICS
873	/*
874	* Get the statistics record.
875	*/
876	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastRead);
877	if (!pStats \|\| pStats->Core.Key != Port)
878	{
879	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
880	if (pStats)
881	CTXALLSUFF(pVM->iom.s.pStatsLastRead) = pStats;
882	}
883	#endif
884
885	/*
886	* Get handler for current context.
887	*/
888	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastRead);
889	if ( !pRange
890	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
891	{
892	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
893	if (pRange)
894	CTXALLSUFF(pVM->iom.s.pRangeLastRead) = pRange;
895	}
896	#ifdef IN_GC
897	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
898	#endif
899
900	if (pRange)
901	{
902	/*
903	* Found a range.
904	*/
905	#ifndef IN_RING3
906	if (!pRange->pfnInStrCallback)
907	{
908	# ifdef VBOX_WITH_STATISTICS
909	if (pStats)
910	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
911	# endif
912	return VINF_IOM_HC_IOPORT_READ;
913	}
914	#endif
915	/* call the device. */
916	#ifdef VBOX_WITH_STATISTICS
917	if (pStats)
918	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfIn), a);
919	#endif
920
921	int rc = pRange->pfnInStrCallback(pRange->pDevIns, pRange->pvUser, Port, pGCPtrDst, pcTransfers, cb);
922	#ifdef VBOX_WITH_STATISTICS
923	if (pStats)
924	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfIn), a);
925	if (rc == VINF_SUCCESS && pStats)
926	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
927	# ifndef IN_RING3
928	else if (rc == VINF_IOM_HC_IOPORT_READ && pStats)
929	STAM_COUNTER_INC(&pStats->CTXALLMID(In, ToR3));
930	# endif
931	#endif
932	Log3(("IOMIOPortReadStr: Port=%RTiop pGCPtrDst=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=%Vrc\n",
933	Port, pGCPtrDst, pcTransfers, cTransfers, *pcTransfers, cb, rc));
934	return rc;
935	}
936
937	#ifndef IN_RING3
938	/*
939	* Handler in ring-3?
940	*/
941	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
942	if (pRangeR3)
943	{
944	# ifdef VBOX_WITH_STATISTICS
945	if (pStats)
946	STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
947	# endif
948	return VINF_IOM_HC_IOPORT_READ;
949	}
950	#endif
951
952	/*
953	* Ok, no handler for this port.
954	*/
955	#ifdef VBOX_WITH_STATISTICS
956	if (pStats)
957	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
958	else
959	{
960	# ifndef IN_RING3
961	/* Ring-3 will have to create the statistics record. */
962	return VINF_IOM_HC_IOPORT_READ;
963	# else
964	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
965	if (pStats)
966	STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
967	# endif
968	}
969	#endif
970
971	Log3(("IOMIOPortReadStr: Port=%RTiop pGCPtrDst=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=VINF_SUCCESS\n",
972	Port, pGCPtrDst, pcTransfers, cTransfers, *pcTransfers, cb));
973	return VINF_SUCCESS;
974	}
975
976
977	/**
978	* Writes to an I/O port register.
979	*
980	* @returns VBox status code.
981	*
982	* @param pVM VM handle.
983	* @param Port The port to write to.
984	* @param u32Value The value to write.
985	* @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
986	*/
987	IOMDECL(int) IOMIOPortWrite(PVM pVM, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
988	{
989	/** @todo bird: When I get time, I'll remove the GC tree and link the GC entries to the ring-3 node. */
990	#ifdef VBOX_WITH_STATISTICS
991	/*
992	* Find the statistics record.
993	*/
994	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastWrite);
995	if (!pStats \|\| pStats->Core.Key != Port)
996	{
997	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
998	if (pStats)
999	CTXALLSUFF(pVM->iom.s.pStatsLastWrite) = pStats;
1000	}
1001	#endif
1002
1003	/*
1004	* Get handler for current context.
1005	*/
1006	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastWrite);
1007	if ( !pRange
1008	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
1009	{
1010	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
1011	if (pRange)
1012	CTXALLSUFF(pVM->iom.s.pRangeLastWrite) = pRange;
1013	}
1014	#ifdef IN_GC
1015	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange));
1016	#endif
1017
1018	if (pRange)
1019	{
1020	/*
1021	* Found a range.
1022	*/
1023	#ifndef IN_RING3
1024	if (!pRange->pfnOutCallback)
1025	{
1026	# ifdef VBOX_WITH_STATISTICS
1027	if (pStats)
1028	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1029	# endif
1030	return VINF_IOM_HC_IOPORT_WRITE;
1031	}
1032	#endif
1033	/* call the device. */
1034	#ifdef VBOX_WITH_STATISTICS
1035	if (pStats)
1036	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfOut), a);
1037	#endif
1038	int rc = pRange->pfnOutCallback(pRange->pDevIns, pRange->pvUser, Port, u32Value, cbValue);
1039
1040	#ifdef VBOX_WITH_STATISTICS
1041	if (pStats)
1042	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfOut), a);
1043	if (rc == VINF_SUCCESS && pStats)
1044	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1045	# ifndef IN_RING3
1046	else if (rc == VINF_IOM_HC_IOPORT_WRITE && pStats)
1047	STAM_COUNTER_INC(&pStats->CTXALLMID(Out, ToR3));
1048	# endif
1049	#endif
1050	Log3(("IOMIOPortWrite: Port=%RTiop u32=%08RX32 cb=%d rc=%Vrc\n", Port, u32Value, cbValue, rc));
1051	return rc;
1052	}
1053
1054	#ifndef IN_RING3
1055	/*
1056	* Handler in ring-3?
1057	*/
1058	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
1059	if (pRangeR3)
1060	{
1061	# ifdef VBOX_WITH_STATISTICS
1062	if (pStats)
1063	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1064	# endif
1065	return VINF_IOM_HC_IOPORT_WRITE;
1066	}
1067	#endif
1068
1069	/*
1070	* Ok, no handler for that port.
1071	*/
1072	#ifdef VBOX_WITH_STATISTICS
1073	/* statistics. */
1074	if (pStats)
1075	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1076	else
1077	{
1078	# ifndef IN_RING3
1079	/* R3 will have to create the statistics record. */
1080	return VINF_IOM_HC_IOPORT_WRITE;
1081	# else
1082	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
1083	if (pStats)
1084	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1085	# endif
1086	}
1087	#endif
1088	Log3(("IOMIOPortWrite: Port=%RTiop u32=%08RX32 cb=%d nop\n", Port, u32Value, cbValue));
1089	return VINF_SUCCESS;
1090	}
1091	/**
1092	* Writes the string buffer of an I/O port register.
1093	*
1094	* @returns VBox status code.
1095	*
1096	* @param pVM VM handle.
1097	* @param Port The port to write.
1098	* @param pGCPtrSrc Pointer to the source buffer (GC, incremented appropriately).
1099	* @param pcTransfers Pointer to the number of transfer units to write, on return remaining transfer units.
1100	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
1101	* */
1102	IOMDECL(int) IOMIOPortWriteString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfers, unsigned cb)
1103	{
1104	#ifdef LOG_ENABLED
1105	const RTGCUINTREG cTransfers = *pcTransfers;
1106	#endif
1107	#ifdef VBOX_WITH_STATISTICS
1108	/*
1109	* Get the statistics record.
1110	*/
1111	PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastWrite);
1112	if (!pStats \|\| pStats->Core.Key != Port)
1113	{
1114	pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
1115	if (pStats)
1116	CTXALLSUFF(pVM->iom.s.pStatsLastWrite) = pStats;
1117	}
1118	#endif
1119
1120	/*
1121	* Get handler for current context.
1122	*/
1123	CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastWrite);
1124	if ( !pRange
1125	\|\| (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
1126	{
1127	pRange = iomIOPortGetRange(&pVM->iom.s, Port);
1128	if (pRange)
1129	CTXALLSUFF(pVM->iom.s.pRangeLastWrite) = pRange;
1130	}
1131	#ifdef IN_GC
1132	Assert(!pRange \|\| MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
1133	#endif
1134
1135	if (pRange)
1136	{
1137	/*
1138	* Found a range.
1139	*/
1140	#ifndef IN_RING3
1141	if (!pRange->pfnOutStrCallback)
1142	{
1143	# ifdef VBOX_WITH_STATISTICS
1144	if (pStats)
1145	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1146	# endif
1147	return VINF_IOM_HC_IOPORT_WRITE;
1148	}
1149	#endif
1150	/* call the device. */
1151	#ifdef VBOX_WITH_STATISTICS
1152	if (pStats)
1153	STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfOut), a);
1154	#endif
1155	int rc = pRange->pfnOutStrCallback(pRange->pDevIns, pRange->pvUser, Port, pGCPtrSrc, pcTransfers, cb);
1156	#ifdef VBOX_WITH_STATISTICS
1157	if (pStats)
1158	STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfOut), a);
1159	if (rc == VINF_SUCCESS && pStats)
1160	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1161	# ifndef IN_RING3
1162	else if (rc == VINF_IOM_HC_IOPORT_WRITE && pStats)
1163	STAM_COUNTER_INC(&pStats->CTXALLMID(Out, ToR3));
1164	# endif
1165	#endif
1166	Log3(("IOMIOPortWriteStr: Port=%RTiop pGCPtrSrc=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=%Vrc\n",
1167	Port, pGCPtrSrc, pcTransfers, cTransfers, *pcTransfers, cb, rc));
1168	return rc;
1169	}
1170
1171	#ifndef IN_RING3
1172	/*
1173	* Handler in ring-3?
1174	*/
1175	PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
1176	if (pRangeR3)
1177	{
1178	# ifdef VBOX_WITH_STATISTICS
1179	if (pStats)
1180	STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
1181	# endif
1182	return VINF_IOM_HC_IOPORT_WRITE;
1183	}
1184	#endif
1185
1186	/*
1187	* Ok, no handler for this port.
1188	*/
1189	#ifdef VBOX_WITH_STATISTICS
1190	if (pStats)
1191	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1192	else
1193	{
1194	# ifndef IN_RING3
1195	/* Ring-3 will have to create the statistics record. */
1196	return VINF_IOM_HC_IOPORT_WRITE;
1197	# else
1198	pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
1199	if (pStats)
1200	STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
1201	# endif
1202	}
1203	#endif
1204
1205	Log3(("IOMIOPortWriteStr: Port=%RTiop pGCPtrSrc=%p pcTransfer=%p:{%#x->%#x} cb=%d rc=VINF_SUCCESS\n",
1206	Port, pGCPtrSrc, pcTransfers, cTransfers, *pcTransfers, cb));
1207	return VINF_SUCCESS;
1208	}
1209
1210	/**
1211	* Checks that the operation is allowed according to the IOPL
1212	* level and I/O bitmap.
1213	*
1214	* @returns VBox status code.
1215	* If not VINF_SUCCESS a \#GP(0) was raised or an error occured.
1216	*
1217	* @param pVM VM handle.
1218	* @param pCtxCore Pointer to register frame.
1219	* @param Port The I/O port number.
1220	* @param cb The access size.
1221	*/
1222	IOMDECL(int) IOMInterpretCheckPortIOAccess(PVM pVM, PCPUMCTXCORE pCtxCore, RTIOPORT Port, unsigned cb)
1223	{
1224	/*
1225	* If this isn't ring-0, we have to check for I/O privileges.
1226	*/
1227	uint32_t efl = CPUMRawGetEFlags(pVM, pCtxCore);
1228	uint32_t cpl = CPUMGetGuestCPL(pVM, pCtxCore);
1229
1230	if ( ( cpl > 0
1231	&& X86_EFL_GET_IOPL(efl) < cpl)
1232	\|\| pCtxCore->eflags.Bits.u1VM /* IOPL is ignored in V86 mode; always check TSS bitmap */
1233	)
1234	{
1235	/*
1236	* Get TSS location and check if there can be a I/O bitmap.
1237	*/
1238	RTGCUINTPTR GCPtrTss;
1239	RTGCUINTPTR cbTss;
1240	bool fCanHaveIOBitmap;
1241	int rc = SELMGetTSSInfo(pVM, &GCPtrTss, &cbTss, &fCanHaveIOBitmap);
1242	if (VBOX_FAILURE(rc))
1243	{
1244	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d %Vrc -> #GP(0)\n", Port, cb, rc));
1245	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1246	}
1247
1248	if ( !fCanHaveIOBitmap
1249	\|\| cbTss <= sizeof(VBOXTSS))
1250	{
1251	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d cbTss=%#x fCanHaveIOBitmap=%RTbool -> #GP(0)\n",
1252	Port, cb, cbTss, fCanHaveIOBitmap));
1253	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1254	}
1255
1256	/*
1257	* Fetch the I/O bitmap offset.
1258	*/
1259	uint16_t offIOPB;
1260	rc = PGMPhysInterpretedRead(pVM, pCtxCore, &offIOPB, GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap), sizeof(offIOPB));
1261	if (rc != VINF_SUCCESS)
1262	{
1263	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d GCPtrTss=%VGv %Vrc\n",
1264	Port, cb, GCPtrTss, rc));
1265	return rc;
1266	}
1267
1268	/*
1269	* Check the limit and read the two bitmap bytes.
1270	*/
1271	uint32_t offTss = offIOPB + (Port >> 3);
1272	if (offTss + 1 >= cbTss)
1273	{
1274	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d offTss=%#x cbTss=%#x -> #GP(0)\n",
1275	Port, cb, offTss, cbTss));
1276	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1277	}
1278	uint16_t u16;
1279	rc = PGMPhysInterpretedRead(pVM, pCtxCore, &u16, GCPtrTss + offTss, sizeof(u16));
1280	if (rc != VINF_SUCCESS)
1281	{
1282	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d GCPtrTss=%VGv offTss=%#x -> %Vrc\n",
1283	Port, cb, GCPtrTss, offTss, rc));
1284	return rc;
1285	}
1286
1287	/*
1288	* All the bits must be clear.
1289	*/
1290	if ((u16 >> (Port & 7)) & ((1 << cb) - 1))
1291	{
1292	Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d u16=%#x -> #GP(0)\n",
1293	Port, cb, u16, offTss));
1294	return TRPMRaiseXcptErr(pVM, pCtxCore, X86_XCPT_GP, 0);
1295	}
1296	LogFlow(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d offTss=%#x cbTss=%#x u16=%#x -> OK\n",
1297	Port, cb, u16, offTss, cbTss));
1298	}
1299	return VINF_SUCCESS;
1300	}
1301
1302	/**
1303	* IN <AL\|AX\|EAX>, <DX\|imm16>
1304	*
1305	* @returns VBox status code.
1306	*
1307	* @param pVM The virtual machine (GC pointer ofcourse).
1308	* @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
1309	* @param pCpu Disassembler CPU state.
1310	*/
1311	IOMDECL(int) IOMInterpretIN(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
1312	{
1313	#ifdef IN_GC
1314	STAM_COUNTER_INC(&pVM->iom.s.StatGCInstIn);
1315	#endif
1316
1317	/*
1318	* Get port number from second parameter.
1319	* And get the register size from the first parameter.
1320	*/
1321	uint32_t uPort = 0;
1322	unsigned cbSize = 0;
1323	bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uPort, &cbSize);
1324	AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
1325
1326	cbSize = iomGCGetRegSize(pCpu, &pCpu->param1);
1327	Assert(cbSize > 0);
1328	int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
1329	if (rc == VINF_SUCCESS)
1330	{
1331	/*
1332	* Attemp to read the port.
1333	*/
1334	uint32_t u32Data = ~0U;
1335	rc = IOMIOPortRead(pVM, uPort, &u32Data, cbSize);
1336	if (rc == VINF_SUCCESS)
1337	{
1338	/*
1339	* Store the result in the AL\|AX\|EAX register.
1340	*/
1341	fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
1342	AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
1343	}
1344	}
1345	return rc;
1346	}
1347
1348
1349	/**
1350	* OUT <DX\|imm16>, <AL\|AX\|EAX>
1351	*
1352	* @returns VBox status code.
1353	*
1354	* @param pVM The virtual machine (GC pointer ofcourse).
1355	* @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
1356	* @param pCpu Disassembler CPU state.
1357	*/
1358	IOMDECL(int) IOMInterpretOUT(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
1359	{
1360	#ifdef IN_GC
1361	STAM_COUNTER_INC(&pVM->iom.s.StatGCInstOut);
1362	#endif
1363
1364	/*
1365	* Get port number from first parameter.
1366	* And get the register size and value from the second parameter.
1367	*/
1368	uint32_t uPort = 0;
1369	unsigned cbSize = 0;
1370	bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
1371	AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
1372
1373	int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
1374	if (rc == VINF_SUCCESS)
1375	{
1376	uint32_t u32Data = 0;
1377	fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
1378	AssertMsg(fRc, ("Failed to get reg value!\n")); NOREF(fRc);
1379
1380	/*
1381	* Attemp to write to the port.
1382	*/
1383	rc = IOMIOPortWrite(pVM, uPort, u32Data, cbSize);
1384	}
1385	return rc;
1386	}

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

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

Download in other formats: