cca24d06d8
kernel (sys task). The main reason is that these would have to become cpu local variables on SMP. Once the system task is not a task but a genuine part of the kernel there is even less reason to have these extra variables as proc_ptr will already contain all neccessary information. In addition converting who_e to the process pointer and back again all the time will be avoided. Although proc_ptr will contain all important information, accessing it as a cpu local variable will be fairly expensive, hence the value would be assigned to some on stack local variable. Therefore it is better to add the 'caller' argument to the syscall handlers to pass the value on stack anyway. It also clearly denotes on who's behalf is the syscall being executed. This patch also ANSIfies the syscall function headers. Last but not least, it also fixes a potential bug in virtual_copy_f() in case the check is disabled. So far the function in case of a failure could possible reuse an old who_p in case this function had not been called from the system task. virtual_copy_f() takes the caller as a parameter too. In case the checking is disabled, the caller must be NULL and non NULL if it is enabled as we must be able to suspend the caller.
156 lines
4.3 KiB
C
156 lines
4.3 KiB
C
/* The kernel call implemented in this file:
|
|
* m_type: SYS_SDEVIO
|
|
*
|
|
* The parameters for this kernel call are:
|
|
* m2_i3: DIO_REQUEST (request input or output)
|
|
* m2_l1: DIO_PORT (port to read/ write)
|
|
* m2_p1: DIO_VEC_ADDR (virtual address of buffer, or grant ID)
|
|
* m2_l2: DIO_VEC_SIZE (number of elements)
|
|
* m2_i2: DIO_VEC_PROC (process where buffer is)
|
|
* m2_i1: DIO_OFFSET (offset into the grant)
|
|
*/
|
|
|
|
#include "../../system.h"
|
|
#include <minix/devio.h>
|
|
#include <minix/endpoint.h>
|
|
|
|
#include "proto.h"
|
|
|
|
#if USE_SDEVIO
|
|
|
|
/*===========================================================================*
|
|
* do_sdevio *
|
|
*===========================================================================*/
|
|
PUBLIC int do_sdevio(struct proc * caller, message *m_ptr)
|
|
{
|
|
vir_bytes newoffset;
|
|
endpoint_t newep;
|
|
int proc_nr, proc_nr_e = m_ptr->DIO_VEC_ENDPT;
|
|
int count = m_ptr->DIO_VEC_SIZE;
|
|
long port = m_ptr->DIO_PORT;
|
|
phys_bytes phys_buf;
|
|
int i, req_type, req_dir, size, nr_io_range;
|
|
struct priv *privp;
|
|
struct io_range *iorp;
|
|
struct proc *destproc;
|
|
|
|
/* Allow safe copies and accesses to SELF */
|
|
if ((m_ptr->DIO_REQUEST & _DIO_SAFEMASK) != _DIO_SAFE &&
|
|
proc_nr_e != SELF)
|
|
{
|
|
static int first= 1;
|
|
if (first)
|
|
{
|
|
first= 0;
|
|
kprintf("do_sdevio: for %d, req %d\n",
|
|
m_ptr->m_source, m_ptr->DIO_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)
|
|
proc_nr = _ENDPOINT_P(caller->p_endpoint);
|
|
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->DIO_REQUEST & _DIO_DIRMASK;
|
|
req_type = m_ptr->DIO_REQUEST & _DIO_TYPEMASK;
|
|
|
|
/* Check for 'safe' variants. */
|
|
if((m_ptr->DIO_REQUEST & _DIO_SAFEMASK) == _DIO_SAFE) {
|
|
/* Map grant address to physical address. */
|
|
if(verify_grant(proc_nr_e, caller->p_endpoint,
|
|
(vir_bytes) m_ptr->DIO_VEC_ADDR,
|
|
count,
|
|
req_dir == _DIO_INPUT ? CPF_WRITE : CPF_READ,
|
|
(vir_bytes) m_ptr->DIO_OFFSET,
|
|
&newoffset, &newep) != OK) {
|
|
printf("do_sdevio: verify_grant failed\n");
|
|
return EPERM;
|
|
}
|
|
if(!isokendpt(newep, &proc_nr))
|
|
return(EINVAL);
|
|
destproc = proc_addr(proc_nr);
|
|
if ((phys_buf = umap_local(destproc, D,
|
|
(vir_bytes) newoffset, count)) == 0) {
|
|
printf("do_sdevio: umap_local failed\n");
|
|
return(EFAULT);
|
|
}
|
|
} else {
|
|
if(proc_nr != _ENDPOINT_P(caller->p_endpoint))
|
|
{
|
|
kprintf("do_sdevio: unsafe sdevio by %d in %d denied\n",
|
|
caller->p_endpoint, proc_nr_e);
|
|
return EPERM;
|
|
}
|
|
/* Get and check physical address. */
|
|
if ((phys_buf = umap_local(proc_addr(proc_nr), D,
|
|
(vir_bytes) m_ptr->DIO_VEC_ADDR, count)) == 0)
|
|
return(EFAULT);
|
|
destproc = proc_addr(proc_nr);
|
|
}
|
|
/* current process must be target for phys_* to be OK */
|
|
|
|
vm_set_cr3(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->DIO_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)
|
|
{
|
|
kprintf(
|
|
"do_sdevio: I/O port check failed for proc %d, port 0x%x\n",
|
|
m_ptr->m_source, port);
|
|
return EPERM;
|
|
}
|
|
}
|
|
|
|
if (port & (size-1))
|
|
{
|
|
kprintf("do_devio: unaligned port 0x%x (size %d)\n", port, size);
|
|
return EPERM;
|
|
}
|
|
|
|
/* 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, phys_buf, count); break;
|
|
case _DIO_WORD: phys_insw(port, phys_buf, count); break;
|
|
default: return(EINVAL);
|
|
}
|
|
} else if (req_dir == _DIO_OUTPUT) {
|
|
switch (req_type) {
|
|
case _DIO_BYTE: phys_outsb(port, phys_buf, count); break;
|
|
case _DIO_WORD: phys_outsw(port, phys_buf, count); break;
|
|
default: return(EINVAL);
|
|
}
|
|
}
|
|
else {
|
|
return(EINVAL);
|
|
}
|
|
return(OK);
|
|
}
|
|
|
|
#endif /* USE_SDEVIO */
|