1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/* The kernel call implemented in this file:
* m_type: SYS_SDEVIO
*
* The parameters for this kernel call are:
* m_lsys_krn_sys_sdevio.request (request input or output)
* m_lsys_krn_sys_sdevio.port (port to read/ write)
* m_lsys_krn_sys_sdevio.vec_addr (virtual address of buffer, or grant ID)
* m_lsys_krn_sys_sdevio.vec_size (number of elements)
* m_lsys_krn_sys_sdevio.vec_endpt (process where buffer is)
* m_lsys_krn_sys_sdevio.offset (offset into the grant)
*/
#include "kernel/system.h"
#include <minix/devio.h>
#include <minix/endpoint.h>
#include "arch_proto.h"
#if USE_SDEVIO
/*===========================================================================*
* do_sdevio *
*===========================================================================*/
int do_sdevio(struct proc * caller, message *m_ptr)
{
vir_bytes newoffset;
endpoint_t newep;
int proc_nr;
endpoint_t proc_nr_e = m_ptr->m_lsys_krn_sys_sdevio.vec_endpt;
vir_bytes count = m_ptr->m_lsys_krn_sys_sdevio.vec_size;
long port = m_ptr->m_lsys_krn_sys_sdevio.port;
phys_bytes vir_buf;
int i, r, req_type, req_dir, size, nr_io_range;
struct priv *privp;
struct io_range *iorp;
struct proc *destproc;
int retval;
/* Allow safe copies and accesses to SELF */
if ((m_ptr->m_lsys_krn_sys_sdevio.request & _DIO_SAFEMASK) != _DIO_SAFE &&
proc_nr_e != SELF)
{
static int first= 1;
if (first)
{
first= 0;
printf("do_sdevio: for %d, req %d\n",
m_ptr->m_source, m_ptr->m_lsys_krn_sys_sdevio.request);
}
}
/* Check if process endpoint is OK.
* A driver may directly provide a pointer to a buffer at the user-process
* that initiated the device I/O. Kernel processes, of course, are denied.
*/
if (proc_nr_e == SELF)
okendpt(caller->p_endpoint, &proc_nr);
else
if(!isokendpt(proc_nr_e, &proc_nr))
return(EINVAL);
if (iskerneln(proc_nr)) return(EPERM);
/* Extract direction (in or out) and type (size). */
req_dir = m_ptr->m_lsys_krn_sys_sdevio.request & _DIO_DIRMASK;
req_type = m_ptr->m_lsys_krn_sys_sdevio.request & _DIO_TYPEMASK;
/* Check for 'safe' variants. */
if((m_ptr->m_lsys_krn_sys_sdevio.request & _DIO_SAFEMASK) == _DIO_SAFE) {
/* Map grant address to physical address. */
if((r=verify_grant(proc_nr_e, caller->p_endpoint,
m_ptr->m_lsys_krn_sys_sdevio.vec_addr, count,
req_dir == _DIO_INPUT ? CPF_WRITE : CPF_READ,
m_ptr->m_lsys_krn_sys_sdevio.offset, &newoffset, &newep,
NULL)) != OK) {
if(r == ENOTREADY) return r;
printf("do_sdevio: verify_grant failed\n");
return EPERM;
}
if(!isokendpt(newep, &proc_nr))
return(EINVAL);
destproc = proc_addr(proc_nr);
vir_buf = newoffset;
} else {
if(proc_nr != _ENDPOINT_P(caller->p_endpoint))
{
printf("do_sdevio: unsafe sdevio by %d in %d denied\n",
caller->p_endpoint, proc_nr_e);
return EPERM;
}
/* Get and check physical address. */
vir_buf = m_ptr->m_lsys_krn_sys_sdevio.vec_addr;
destproc = proc_addr(proc_nr);
}
/* current process must be target for phys_* to be OK */
switch_address_space(destproc);
switch (req_type)
{
case _DIO_BYTE: size= 1; break;
case _DIO_WORD: size= 2; break;
case _DIO_LONG: size= 4; break;
default: size= 4; break; /* Be conservative */
}
privp= priv(caller);
if (privp && privp->s_flags & CHECK_IO_PORT)
{
port= m_ptr->m_lsys_krn_sys_sdevio.port;
nr_io_range= privp->s_nr_io_range;
for (i= 0, iorp= privp->s_io_tab; i<nr_io_range; i++, iorp++)
{
if (port >= iorp->ior_base && port+size-1 <= iorp->ior_limit)
break;
}
if (i >= nr_io_range)
{
printf(
"do_sdevio: I/O port check failed for proc %d, port 0x%x\n",
m_ptr->m_source, port);
retval = EPERM;
goto return_error;
}
}
if (port & (size-1))
{
printf("do_devio: unaligned port 0x%x (size %d)\n", port, size);
retval = EPERM;
goto return_error;
}
/* Perform device I/O for bytes and words. Longs are not supported. */
if (req_dir == _DIO_INPUT) {
switch (req_type) {
case _DIO_BYTE: phys_insb(port, vir_buf, count); break;
case _DIO_WORD: phys_insw(port, vir_buf, count); break;
default:
retval = EINVAL;
goto return_error;
}
} else if (req_dir == _DIO_OUTPUT) {
switch (req_type) {
case _DIO_BYTE: phys_outsb(port, vir_buf, count); break;
case _DIO_WORD: phys_outsw(port, vir_buf, count); break;
default:
retval = EINVAL;
goto return_error;
}
}
else {
retval = EINVAL;
goto return_error;
}
retval = OK;
return_error:
/* switch back to the address of the process which made the call */
switch_address_space(caller);
return retval;
}
#endif /* USE_SDEVIO */
|
