/*===========================================================================* * switch_to_user * *===========================================================================*/ PUBLIC void switch_to_user(void) { /* This function is called an instant before proc_ptr is * to be scheduled again. */ /* * if the current process is still runnable check the misc flags and let * it run unless it becomes not runnable in the meantime */ if (proc_is_runnable(proc_ptr)) goto check_misc_flags; /* * if a process becomes not runnable while handling the misc flags, we * need to pick a new one here and start from scratch. Also if the * current process wasn' runnable, we pick a new one here */ not_runnable_pick_new: if (proc_is_preempted(proc_ptr)) { proc_ptr->p_rts_flags &= ~RTS_PREEMPTED; if (proc_is_runnable(proc_ptr)) { if (!is_zero64(proc_ptr->p_cpu_time_left)) enqueue_head(proc_ptr); else enqueue(proc_ptr); } } /* * if we have no process to run, set IDLE as the current process for * time accounting and put the cpu in and idle state. After the next * timer interrupt the execution resumes here and we can pick another * process. If there is still nothing runnable we "schedule" IDLE again */ while (!(proc_ptr = pick_proc())) { proc_ptr = proc_addr(IDLE); if (priv(proc_ptr)->s_flags & BILLABLE) bill_ptr = proc_ptr; idle(); } switch_address_space(proc_ptr); check_misc_flags: assert(proc_ptr); assert(proc_is_runnable(proc_ptr)); while (proc_ptr->p_misc_flags & (MF_KCALL_RESUME | MF_DELIVERMSG | MF_SC_DEFER | MF_SC_TRACE | MF_SC_ACTIVE)) { assert(proc_is_runnable(proc_ptr)); if (proc_ptr->p_misc_flags & MF_KCALL_RESUME) { kernel_call_resume(proc_ptr); } else if (proc_ptr->p_misc_flags & MF_DELIVERMSG) { TRACE(VF_SCHEDULING, printf("delivering to %s / %d\n", proc_ptr->p_name, proc_ptr->p_endpoint);); delivermsg(proc_ptr); }
void segmentation2paging(struct proc * current) { /* switch to the current process page tables before turning paging on */ switch_address_space(current); vm_enable_paging(); }
/*===========================================================================* * do_sdevio * *===========================================================================*/ PUBLIC 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->DIO_VEC_ENDPT; vir_bytes 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; int retval; /* 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; printf("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, (cp_grant_id_t) 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)) { printf("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 */ 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->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) { 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, phys_buf, count); break; case _DIO_WORD: phys_insw(port, phys_buf, count); break; default: retval = EINVAL; goto return_error; } } 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: 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; }