You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
597 lines
23 KiB
597 lines
23 KiB
//! System call
|
|
|
|
use alloc::{string::String, sync::Arc, vec::Vec};
|
|
use core::{fmt, slice, str};
|
|
|
|
use bitflags::bitflags;
|
|
use rcore_fs::vfs::{FileType, FsError, INode, Metadata};
|
|
use rcore_memory::VMError;
|
|
|
|
use crate::arch::cpu;
|
|
use crate::arch::interrupt::TrapFrame;
|
|
use crate::arch::syscall::*;
|
|
use crate::memory::{copy_from_user_u8, copy_from_user_usize, MemorySet};
|
|
use crate::process::*;
|
|
use crate::sync::{Condvar, MutexGuard, SpinNoIrq};
|
|
use crate::thread;
|
|
use crate::util;
|
|
|
|
use self::custom::*;
|
|
use self::fs::*;
|
|
use self::mem::*;
|
|
use self::misc::*;
|
|
pub use self::net::*;
|
|
use self::proc::*;
|
|
use self::time::*;
|
|
|
|
mod custom;
|
|
mod fs;
|
|
mod mem;
|
|
mod misc;
|
|
mod net;
|
|
mod proc;
|
|
mod time;
|
|
|
|
use alloc::collections::BTreeMap;
|
|
use spin::Mutex;
|
|
|
|
#[cfg(feature = "profile")]
|
|
lazy_static! {
|
|
static ref SYSCALL_TIMING: Mutex<BTreeMap<usize, i64>> = Mutex::new(BTreeMap::new());
|
|
}
|
|
|
|
/// System call dispatcher
|
|
pub fn syscall(id: usize, args: [usize; 6], tf: &mut TrapFrame) -> isize {
|
|
let thread = unsafe { current_thread() };
|
|
let mut syscall = Syscall { thread, tf };
|
|
syscall.syscall(id, args)
|
|
}
|
|
|
|
/// All context needed for syscall
|
|
struct Syscall<'a> {
|
|
thread: &'a mut Thread,
|
|
tf: &'a mut TrapFrame,
|
|
}
|
|
|
|
impl Syscall<'_> {
|
|
/// Get current process
|
|
pub fn process(&self) -> MutexGuard<'_, Process, SpinNoIrq> {
|
|
self.thread.proc.lock()
|
|
}
|
|
|
|
/// Get current virtual memory
|
|
pub fn vm(&self) -> MutexGuard<'_, MemorySet, SpinNoIrq> {
|
|
self.thread.vm.lock()
|
|
}
|
|
|
|
/// System call dispatcher
|
|
// This #[deny(unreachable_patterns)] checks if each match arm is defined
|
|
// See discussion in https://github.com/oscourse-tsinghua/rcore_plus/commit/17e644e54e494835f1a49b34b80c2c4f15ed0dbe.
|
|
#[deny(unreachable_patterns)]
|
|
fn syscall(&mut self, id: usize, args: [usize; 6]) -> isize {
|
|
#[cfg(feature = "profile")]
|
|
let begin_time = unsafe { core::arch::x86_64::_rdtsc() };
|
|
let cid = cpu::id();
|
|
let pid = self.process().pid.clone();
|
|
let tid = processor().tid();
|
|
if !pid.is_init() {
|
|
// we trust pid 0 process
|
|
debug!("{}:{}:{} syscall id {} begin", cid, pid, tid, id);
|
|
}
|
|
|
|
// use platform-specific syscal numbers
|
|
// See https://filippo.io/linux-syscall-table/
|
|
// And https://fedora.juszkiewicz.com.pl/syscalls.html.
|
|
let ret = match id {
|
|
// file
|
|
SYS_READ => self.sys_read(args[0], args[1] as *mut u8, args[2]),
|
|
SYS_WRITE => self.sys_write(args[0], args[1] as *const u8, args[2]),
|
|
SYS_OPENAT => self.sys_openat(args[0], args[1] as *const u8, args[2], args[3]),
|
|
SYS_CLOSE => self.sys_close(args[0]),
|
|
SYS_FSTAT => self.sys_fstat(args[0], args[1] as *mut Stat),
|
|
SYS_NEWFSTATAT => {
|
|
self.sys_fstatat(args[0], args[1] as *const u8, args[2] as *mut Stat, args[3])
|
|
}
|
|
SYS_LSEEK => self.sys_lseek(args[0], args[1] as i64, args[2] as u8),
|
|
SYS_IOCTL => self.sys_ioctl(args[0], args[1], args[2], args[3], args[4]),
|
|
SYS_PREAD64 => self.sys_pread(args[0], args[1] as *mut u8, args[2], args[3]),
|
|
SYS_PWRITE64 => self.sys_pwrite(args[0], args[1] as *const u8, args[2], args[3]),
|
|
SYS_READV => self.sys_readv(args[0], args[1] as *const IoVec, args[2]),
|
|
SYS_WRITEV => self.sys_writev(args[0], args[1] as *const IoVec, args[2]),
|
|
SYS_SENDFILE => self.sys_sendfile(args[0], args[1], args[2] as *mut usize, args[3]),
|
|
SYS_FCNTL => {
|
|
info!("SYS_FCNTL : {} {} {} {}", args[0], args[1], args[2], args[3]);
|
|
self.sys_fcntl(args[0], args[1], args[2])
|
|
},
|
|
SYS_FLOCK => self.unimplemented("flock", Ok(0)),
|
|
SYS_FSYNC => self.sys_fsync(args[0]),
|
|
SYS_FDATASYNC => self.sys_fdatasync(args[0]),
|
|
SYS_TRUNCATE => self.sys_truncate(args[0] as *const u8, args[1]),
|
|
SYS_FTRUNCATE => self.sys_ftruncate(args[0], args[1]),
|
|
SYS_GETDENTS64 => self.sys_getdents64(args[0], args[1] as *mut LinuxDirent64, args[2]),
|
|
SYS_GETCWD => self.sys_getcwd(args[0] as *mut u8, args[1]),
|
|
SYS_CHDIR => self.sys_chdir(args[0] as *const u8),
|
|
SYS_RENAMEAT => {
|
|
self.sys_renameat(args[0], args[1] as *const u8, args[2], args[3] as *const u8)
|
|
}
|
|
SYS_MKDIRAT => self.sys_mkdirat(args[0], args[1] as *const u8, args[2]),
|
|
SYS_LINKAT => self.sys_linkat(
|
|
args[0],
|
|
args[1] as *const u8,
|
|
args[2],
|
|
args[3] as *const u8,
|
|
args[4],
|
|
),
|
|
SYS_UNLINKAT => self.sys_unlinkat(args[0], args[1] as *const u8, args[2]),
|
|
SYS_SYMLINKAT => self.unimplemented("symlinkat", Err(SysError::EACCES)),
|
|
SYS_READLINKAT => {
|
|
self.sys_readlinkat(args[0], args[1] as *const u8, args[2] as *mut u8, args[3])
|
|
}
|
|
SYS_FCHMOD => self.unimplemented("fchmod", Ok(0)),
|
|
SYS_FCHMODAT => self.unimplemented("fchmodat", Ok(0)),
|
|
SYS_FCHOWN => self.unimplemented("fchown", Ok(0)),
|
|
SYS_FCHOWNAT => self.unimplemented("fchownat", Ok(0)),
|
|
SYS_FACCESSAT => self.sys_faccessat(args[0], args[1] as *const u8, args[2], args[3]),
|
|
SYS_DUP3 => self.sys_dup2(args[0], args[1]), // TODO: handle `flags`
|
|
SYS_PIPE2 => self.sys_pipe(args[0] as *mut u32), // TODO: handle `flags`
|
|
SYS_UTIMENSAT => self.unimplemented("utimensat", Ok(0)),
|
|
SYS_COPY_FILE_RANGE => self.sys_copy_file_range(
|
|
args[0],
|
|
args[1] as *mut usize,
|
|
args[2],
|
|
args[3] as *mut usize,
|
|
args[4],
|
|
args[5],
|
|
),
|
|
|
|
// io multiplexing
|
|
SYS_PPOLL => {
|
|
self.sys_ppoll(args[0] as *mut PollFd, args[1], args[2] as *const TimeSpec)
|
|
} // ignore sigmask
|
|
SYS_EPOLL_CREATE1 => self.unimplemented("epoll_create1", Err(SysError::ENOSYS)),
|
|
|
|
// file system
|
|
SYS_STATFS => self.unimplemented("statfs", Err(SysError::EACCES)),
|
|
SYS_FSTATFS => self.unimplemented("fstatfs", Err(SysError::EACCES)),
|
|
SYS_SYNC => self.sys_sync(),
|
|
SYS_MOUNT => self.unimplemented("mount", Err(SysError::EACCES)),
|
|
SYS_UMOUNT2 => self.unimplemented("umount2", Err(SysError::EACCES)),
|
|
|
|
// memory
|
|
SYS_BRK => self.unimplemented("brk", Err(SysError::ENOMEM)),
|
|
SYS_MMAP => self.sys_mmap(args[0], args[1], args[2], args[3], args[4], args[5]),
|
|
SYS_MPROTECT => self.sys_mprotect(args[0], args[1], args[2]),
|
|
SYS_MUNMAP => self.sys_munmap(args[0], args[1]),
|
|
SYS_MADVISE => self.unimplemented("madvise", Ok(0)),
|
|
|
|
// signal
|
|
SYS_RT_SIGACTION => self.unimplemented("sigaction", Ok(0)),
|
|
SYS_RT_SIGPROCMASK => self.unimplemented("sigprocmask", Ok(0)),
|
|
SYS_SIGALTSTACK => self.unimplemented("sigaltstack", Ok(0)),
|
|
SYS_KILL => self.sys_kill(args[0], args[1]),
|
|
|
|
// schedule
|
|
SYS_SCHED_YIELD => self.sys_yield(),
|
|
SYS_SCHED_GETAFFINITY => {
|
|
self.sys_sched_getaffinity(args[0], args[1], args[2] as *mut u32)
|
|
}
|
|
|
|
// socket
|
|
SYS_SOCKET => self.sys_socket(args[0], args[1], args[2]),
|
|
SYS_CONNECT => self.sys_connect(args[0], args[1] as *const SockAddr, args[2]),
|
|
SYS_ACCEPT => self.sys_accept(args[0], args[1] as *mut SockAddr, args[2] as *mut u32),
|
|
SYS_ACCEPT4 => self.sys_accept(args[0], args[1] as *mut SockAddr, args[2] as *mut u32), // use accept for accept4
|
|
SYS_SENDTO => self.sys_sendto(
|
|
args[0],
|
|
args[1] as *const u8,
|
|
args[2],
|
|
args[3],
|
|
args[4] as *const SockAddr,
|
|
args[5],
|
|
),
|
|
SYS_RECVFROM => self.sys_recvfrom(
|
|
args[0],
|
|
args[1] as *mut u8,
|
|
args[2],
|
|
args[3],
|
|
args[4] as *mut SockAddr,
|
|
args[5] as *mut u32,
|
|
),
|
|
// SYS_SENDMSG => self.sys_sendmsg(),
|
|
SYS_RECVMSG => self.sys_recvmsg(args[0], args[1] as *mut MsgHdr, args[2]),
|
|
SYS_SHUTDOWN => self.sys_shutdown(args[0], args[1]),
|
|
SYS_BIND => self.sys_bind(args[0], args[1] as *const SockAddr, args[2]),
|
|
SYS_LISTEN => self.sys_listen(args[0], args[1]),
|
|
SYS_GETSOCKNAME => {
|
|
self.sys_getsockname(args[0], args[1] as *mut SockAddr, args[2] as *mut u32)
|
|
}
|
|
SYS_GETPEERNAME => {
|
|
self.sys_getpeername(args[0], args[1] as *mut SockAddr, args[2] as *mut u32)
|
|
}
|
|
SYS_SETSOCKOPT => {
|
|
self.sys_setsockopt(args[0], args[1], args[2], args[3] as *const u8, args[4])
|
|
}
|
|
SYS_GETSOCKOPT => self.sys_getsockopt(
|
|
args[0],
|
|
args[1],
|
|
args[2],
|
|
args[3] as *mut u8,
|
|
args[4] as *mut u32,
|
|
),
|
|
|
|
// process
|
|
SYS_CLONE => self.sys_clone(
|
|
args[0],
|
|
args[1],
|
|
args[2] as *mut u32,
|
|
args[3] as *mut u32,
|
|
args[4],
|
|
),
|
|
SYS_EXECVE => self.sys_exec(
|
|
args[0] as *const u8,
|
|
args[1] as *const *const u8,
|
|
args[2] as *const *const u8,
|
|
),
|
|
SYS_EXIT => self.sys_exit(args[0] as usize),
|
|
SYS_EXIT_GROUP => self.sys_exit_group(args[0]),
|
|
SYS_WAIT4 => self.sys_wait4(args[0] as isize, args[1] as *mut i32), // TODO: wait4
|
|
SYS_SET_TID_ADDRESS => self.sys_set_tid_address(args[0] as *mut u32),
|
|
SYS_FUTEX => self.sys_futex(
|
|
args[0],
|
|
args[1] as u32,
|
|
args[2] as i32,
|
|
args[3] as *const TimeSpec,
|
|
),
|
|
SYS_TKILL => self.unimplemented("tkill", Ok(0)),
|
|
|
|
// time
|
|
SYS_NANOSLEEP => self.sys_nanosleep(args[0] as *const TimeSpec),
|
|
SYS_SETITIMER => self.unimplemented("setitimer", Ok(0)),
|
|
SYS_GETTIMEOFDAY => {
|
|
self.sys_gettimeofday(args[0] as *mut TimeVal, args[1] as *const u8)
|
|
}
|
|
SYS_CLOCK_GETTIME => self.sys_clock_gettime(args[0], args[1] as *mut TimeSpec),
|
|
|
|
// system
|
|
SYS_GETPID => self.sys_getpid(),
|
|
SYS_GETTID => self.sys_gettid(),
|
|
SYS_UNAME => self.sys_uname(args[0] as *mut u8),
|
|
SYS_UMASK => self.unimplemented("umask", Ok(0o777)),
|
|
// SYS_GETRLIMIT => self.sys_getrlimit(),
|
|
// SYS_SETRLIMIT => self.sys_setrlimit(),
|
|
SYS_GETRUSAGE => self.sys_getrusage(args[0], args[1] as *mut RUsage),
|
|
SYS_SYSINFO => self.sys_sysinfo(args[0] as *mut SysInfo),
|
|
SYS_TIMES => self.sys_times(args[0] as *mut Tms),
|
|
SYS_GETUID => self.unimplemented("getuid", Ok(0)),
|
|
SYS_GETGID => self.unimplemented("getgid", Ok(0)),
|
|
SYS_SETUID => self.unimplemented("setuid", Ok(0)),
|
|
SYS_GETEUID => self.unimplemented("geteuid", Ok(0)),
|
|
SYS_GETEGID => self.unimplemented("getegid", Ok(0)),
|
|
SYS_SETPGID => self.unimplemented("setpgid", Ok(0)),
|
|
SYS_GETPPID => self.sys_getppid(),
|
|
SYS_SETSID => self.unimplemented("setsid", Ok(0)),
|
|
SYS_GETPGID => self.unimplemented("getpgid", Ok(0)),
|
|
SYS_GETGROUPS => self.unimplemented("getgroups", Ok(0)),
|
|
SYS_SETGROUPS => self.unimplemented("setgroups", Ok(0)),
|
|
SYS_SETPRIORITY => self.sys_set_priority(args[0]),
|
|
SYS_PRCTL => self.unimplemented("prctl", Ok(0)),
|
|
SYS_MEMBARRIER => self.unimplemented("membarrier", Ok(0)),
|
|
SYS_PRLIMIT64 => self.sys_prlimit64(
|
|
args[0],
|
|
args[1],
|
|
args[2] as *const RLimit,
|
|
args[3] as *mut RLimit,
|
|
),
|
|
SYS_REBOOT => self.sys_reboot(
|
|
args[0] as u32,
|
|
args[1] as u32,
|
|
args[2] as u32,
|
|
args[3] as *const u8,
|
|
),
|
|
SYS_GETRANDOM => {
|
|
self.sys_getrandom(args[0] as *mut u8, args[1] as usize, args[2] as u32)
|
|
}
|
|
|
|
// custom
|
|
SYS_MAP_PCI_DEVICE => self.sys_map_pci_device(args[0], args[1]),
|
|
SYS_GET_PADDR => {
|
|
self.sys_get_paddr(args[0] as *const u64, args[1] as *mut u64, args[2])
|
|
}
|
|
_ => {
|
|
let ret = match () {
|
|
#[cfg(target_arch = "x86_64")]
|
|
() => self.x86_64_syscall(id, args),
|
|
#[cfg(target_arch = "mips")]
|
|
() => self.mips_syscall(id, args),
|
|
#[cfg(all(not(target_arch = "x86_64"), not(target_arch = "mips")))]
|
|
() => None,
|
|
};
|
|
if let Some(ret) = ret {
|
|
ret
|
|
} else {
|
|
error!("unknown syscall id: {}, args: {:x?}", id, args);
|
|
crate::trap::error(self.tf);
|
|
}
|
|
}
|
|
};
|
|
if !pid.is_init() {
|
|
// we trust pid 0 process
|
|
info!("=> {:x?}", ret);
|
|
}
|
|
#[cfg(feature = "profile")]
|
|
{
|
|
let end_time = unsafe { core::arch::x86_64::_rdtsc() };
|
|
*SYSCALL_TIMING.lock().entry(id).or_insert(0) += end_time - begin_time;
|
|
if end_time % 1000 == 0 {
|
|
let timing = SYSCALL_TIMING.lock();
|
|
let mut count_vec: Vec<(&usize, &i64)> = timing.iter().collect();
|
|
count_vec.sort_by(|a, b| b.1.cmp(a.1));
|
|
for (id, time) in count_vec.iter().take(5) {
|
|
warn!("timing {:03} time {:012}", id, time);
|
|
}
|
|
}
|
|
}
|
|
match ret {
|
|
Ok(code) => code as isize,
|
|
Err(err) => -(err as isize),
|
|
}
|
|
}
|
|
|
|
fn unimplemented(&self, name: &str, ret: SysResult) -> SysResult {
|
|
warn!("{} is unimplemented", name);
|
|
ret
|
|
}
|
|
|
|
#[cfg(target_arch = "mips")]
|
|
fn mips_syscall(&mut self, id: usize, args: [usize; 6]) -> Option<SysResult> {
|
|
let ret = match id {
|
|
SYS_OPEN => self.sys_open(args[0] as *const u8, args[1], args[2]),
|
|
SYS_POLL => self.sys_poll(args[0] as *mut PollFd, args[1], args[2]),
|
|
SYS_DUP2 => self.sys_dup2(args[0], args[1]),
|
|
SYS_FORK => self.sys_fork(),
|
|
SYS_MMAP2 => self.sys_mmap(args[0], args[1], args[2], args[3], args[4], args[5] * 4096),
|
|
SYS_FSTAT64 => self.sys_fstat(args[0], args[1] as *mut Stat),
|
|
SYS_LSTAT64 => self.sys_lstat(args[0] as *const u8, args[1] as *mut Stat),
|
|
SYS_STAT64 => self.sys_stat(args[0] as *const u8, args[1] as *mut Stat),
|
|
SYS_PIPE => {
|
|
let fd_ptr = args[0] as *mut u32;
|
|
match self.sys_pipe(fd_ptr) {
|
|
Ok(code) => {
|
|
unsafe {
|
|
self.tf.v0 = *fd_ptr as usize;
|
|
self.tf.v1 = *(fd_ptr.add(1)) as usize;
|
|
}
|
|
Ok(self.tf.v0)
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
SYS_FCNTL64 => self.unimplemented("fcntl64", Ok(0)),
|
|
SYS_SET_THREAD_AREA => {
|
|
info!("set_thread_area: tls: 0x{:x}", args[0]);
|
|
extern "C" {
|
|
fn _cur_tls();
|
|
}
|
|
|
|
unsafe {
|
|
asm!("mtc0 $0, $$4, 2": :"r"(args[0]));
|
|
*(_cur_tls as *mut usize) = args[0];
|
|
}
|
|
Ok(0)
|
|
}
|
|
_ => return None,
|
|
};
|
|
Some(ret)
|
|
}
|
|
|
|
#[cfg(target_arch = "x86_64")]
|
|
fn x86_64_syscall(&mut self, id: usize, args: [usize; 6]) -> Option<SysResult> {
|
|
let ret = match id {
|
|
SYS_OPEN => self.sys_open(args[0] as *const u8, args[1], args[2]),
|
|
SYS_STAT => self.sys_stat(args[0] as *const u8, args[1] as *mut Stat),
|
|
SYS_LSTAT => self.sys_lstat(args[0] as *const u8, args[1] as *mut Stat),
|
|
SYS_POLL => self.sys_poll(args[0] as *mut PollFd, args[1], args[2]),
|
|
SYS_ACCESS => self.sys_access(args[0] as *const u8, args[1]),
|
|
SYS_PIPE => self.sys_pipe(args[0] as *mut u32),
|
|
SYS_SELECT => self.sys_select(
|
|
args[0],
|
|
args[1] as *mut u32,
|
|
args[2] as *mut u32,
|
|
args[3] as *mut u32,
|
|
args[4] as *const TimeVal,
|
|
),
|
|
SYS_DUP2 => self.sys_dup2(args[0], args[1]),
|
|
SYS_ALARM => self.unimplemented("alarm", Ok(0)),
|
|
SYS_FORK => self.sys_fork(),
|
|
SYS_VFORK => self.sys_vfork(),
|
|
SYS_RENAME => self.sys_rename(args[0] as *const u8, args[1] as *const u8),
|
|
SYS_MKDIR => self.sys_mkdir(args[0] as *const u8, args[1]),
|
|
SYS_RMDIR => self.sys_rmdir(args[0] as *const u8),
|
|
SYS_LINK => self.sys_link(args[0] as *const u8, args[1] as *const u8),
|
|
SYS_UNLINK => self.sys_unlink(args[0] as *const u8),
|
|
SYS_READLINK => self.sys_readlink(args[0] as *const u8, args[1] as *mut u8, args[2]),
|
|
SYS_CHMOD => self.unimplemented("chmod", Ok(0)),
|
|
SYS_CHOWN => self.unimplemented("chown", Ok(0)),
|
|
SYS_ARCH_PRCTL => self.sys_arch_prctl(args[0] as i32, args[1]),
|
|
SYS_TIME => self.sys_time(args[0] as *mut u64),
|
|
SYS_EPOLL_CREATE => self.unimplemented("epoll_create", Err(SysError::ENOSYS)),
|
|
_ => return None,
|
|
};
|
|
Some(ret)
|
|
}
|
|
}
|
|
|
|
pub type SysResult = Result<usize, SysError>;
|
|
|
|
#[allow(dead_code)]
|
|
#[repr(isize)]
|
|
#[derive(Debug)]
|
|
pub enum SysError {
|
|
EUNDEF = 0,
|
|
EPERM = 1,
|
|
ENOENT = 2,
|
|
ESRCH = 3,
|
|
EINTR = 4,
|
|
EIO = 5,
|
|
ENXIO = 6,
|
|
E2BIG = 7,
|
|
ENOEXEC = 8,
|
|
EBADF = 9,
|
|
ECHILD = 10,
|
|
EAGAIN = 11,
|
|
ENOMEM = 12,
|
|
EACCES = 13,
|
|
EFAULT = 14,
|
|
ENOTBLK = 15,
|
|
EBUSY = 16,
|
|
EEXIST = 17,
|
|
EXDEV = 18,
|
|
ENODEV = 19,
|
|
ENOTDIR = 20,
|
|
EISDIR = 21,
|
|
EINVAL = 22,
|
|
ENFILE = 23,
|
|
EMFILE = 24,
|
|
ENOTTY = 25,
|
|
ETXTBSY = 26,
|
|
EFBIG = 27,
|
|
ENOSPC = 28,
|
|
ESPIPE = 29,
|
|
EROFS = 30,
|
|
EMLINK = 31,
|
|
EPIPE = 32,
|
|
EDOM = 33,
|
|
ERANGE = 34,
|
|
EDEADLK = 35,
|
|
ENAMETOOLONG = 36,
|
|
ENOLCK = 37,
|
|
ENOSYS = 38,
|
|
ENOTEMPTY = 39,
|
|
ENOTSOCK = 80,
|
|
ENOPROTOOPT = 92,
|
|
EPFNOSUPPORT = 96,
|
|
EAFNOSUPPORT = 97,
|
|
ENOBUFS = 105,
|
|
EISCONN = 106,
|
|
ENOTCONN = 107,
|
|
ECONNREFUSED = 111,
|
|
}
|
|
|
|
#[allow(non_snake_case)]
|
|
impl fmt::Display for SysError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
use self::SysError::*;
|
|
write!(
|
|
f,
|
|
"{}",
|
|
match self {
|
|
EPERM => "Operation not permitted",
|
|
ENOENT => "No such file or directory",
|
|
ESRCH => "No such process",
|
|
EINTR => "Interrupted system call",
|
|
EIO => "I/O error",
|
|
ENXIO => "No such device or address",
|
|
E2BIG => "Argument list too long",
|
|
ENOEXEC => "Exec format error",
|
|
EBADF => "Bad file number",
|
|
ECHILD => "No child processes",
|
|
EAGAIN => "Try again",
|
|
ENOMEM => "Out of memory",
|
|
EACCES => "Permission denied",
|
|
EFAULT => "Bad address",
|
|
ENOTBLK => "Block device required",
|
|
EBUSY => "Device or resource busy",
|
|
EEXIST => "File exists",
|
|
EXDEV => "Cross-device link",
|
|
ENODEV => "No such device",
|
|
ENOTDIR => "Not a directory",
|
|
EISDIR => "Is a directory",
|
|
EINVAL => "Invalid argument",
|
|
ENFILE => "File table overflow",
|
|
EMFILE => "Too many open files",
|
|
ENOTTY => "Not a typewriter",
|
|
ETXTBSY => "Text file busy",
|
|
EFBIG => "File too large",
|
|
ENOSPC => "No space left on device",
|
|
ESPIPE => "Illegal seek",
|
|
EROFS => "Read-only file system",
|
|
EMLINK => "Too many links",
|
|
EPIPE => "Broken pipe",
|
|
EDOM => "Math argument out of domain of func",
|
|
ERANGE => "Math result not representable",
|
|
EDEADLK => "Resource deadlock would occur",
|
|
ENAMETOOLONG => "File name too long",
|
|
ENOLCK => "No record locks available",
|
|
ENOSYS => "Function not implemented",
|
|
ENOTEMPTY => "Directory not empty",
|
|
ENOTSOCK => "Socket operation on non-socket",
|
|
ENOPROTOOPT => "Protocol not available",
|
|
EPFNOSUPPORT => "Protocol family not supported",
|
|
EAFNOSUPPORT => "Address family not supported by protocol",
|
|
ENOBUFS => "No buffer space available",
|
|
EISCONN => "Transport endpoint is already connected",
|
|
ENOTCONN => "Transport endpoint is not connected",
|
|
ECONNREFUSED => "Connection refused",
|
|
_ => "Unknown error",
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
impl From<VMError> for SysError {
|
|
fn from(_: VMError) -> Self {
|
|
SysError::EFAULT
|
|
}
|
|
}
|
|
|
|
const SPIN_WAIT_TIMES: usize = 100;
|
|
|
|
pub fn spin_and_wait<T>(condvars: &[&Condvar], mut action: impl FnMut() -> Option<T>) -> T {
|
|
for _i in 0..SPIN_WAIT_TIMES {
|
|
if let Some(result) = action() {
|
|
return result;
|
|
}
|
|
}
|
|
loop {
|
|
if let Some(result) = action() {
|
|
return result;
|
|
}
|
|
Condvar::wait_any(&condvars);
|
|
}
|
|
}
|
|
|
|
pub fn check_and_clone_cstr(user: *const u8) -> Result<String, SysError> {
|
|
let mut buffer = Vec::new();
|
|
for i in 0.. {
|
|
let addr = unsafe { user.add(i) };
|
|
if let Some(data) = copy_from_user_u8(addr) {
|
|
if data > 0 {
|
|
buffer.push(data);
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
return Err(SysError::EFAULT);
|
|
}
|
|
}
|
|
return String::from_utf8(buffer).map_err(|_| SysError::EFAULT);
|
|
}
|
|
|
|
pub fn check_and_clone_cstr_array(user: *const *const u8) -> Result<Vec<String>, SysError> {
|
|
let mut buffer = Vec::new();
|
|
for i in 0.. {
|
|
let addr = unsafe { user.add(i) };
|
|
if let Some(str_addr) = copy_from_user_usize(addr as *const usize) {
|
|
if str_addr > 0 {
|
|
let string = check_and_clone_cstr(str_addr as *const u8)?;
|
|
buffer.push(string);
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
return Err(SysError::EFAULT);
|
|
}
|
|
}
|
|
return Ok(buffer);
|
|
}
|