From 229edcf704b78cdf22a498ee145b317721f40565 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Wed, 30 May 2018 09:16:45 -0600 Subject: [PATCH] Add new scheme traits, add generator script --- Cargo.toml | 2 +- src/scheme.rs | 302 --------------------------------- src/scheme/generate.sh | 21 +++ src/scheme/mod.rs | 9 + src/scheme/scheme.rs | 157 +++++++++++++++++ src/scheme/scheme_block.rs | 157 +++++++++++++++++ src/scheme/scheme_block_mut.rs | 157 +++++++++++++++++ src/scheme/scheme_mut.rs | 157 +++++++++++++++++ 8 files changed, 659 insertions(+), 303 deletions(-) delete mode 100644 src/scheme.rs create mode 100755 src/scheme/generate.sh create mode 100644 src/scheme/mod.rs create mode 100644 src/scheme/scheme.rs create mode 100644 src/scheme/scheme_block.rs create mode 100644 src/scheme/scheme_block_mut.rs create mode 100644 src/scheme/scheme_mut.rs diff --git a/Cargo.toml b/Cargo.toml index 705b59b..1d97ce5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "redox_syscall" -version = "0.1.38" +version = "0.1.39" description = "A Rust library to access raw Redox system calls" license = "MIT" authors = ["Jeremy Soller "] diff --git a/src/scheme.rs b/src/scheme.rs deleted file mode 100644 index ef291d2..0000000 --- a/src/scheme.rs +++ /dev/null @@ -1,302 +0,0 @@ -use core::{mem, slice}; - -use super::*; - -pub trait Scheme { - fn handle(&self, packet: &mut Packet) { - packet.a = Error::mux(match packet.a { - SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), - SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), - SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), - SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), - - SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), - SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), - SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), - SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), - SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), - SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), - SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), - SYS_FEVENT => self.fevent(packet.b, packet.c), - SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), - SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), - SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), - SYS_FSTAT => if packet.d >= mem::size_of::() { - self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FSTATVFS => if packet.d >= mem::size_of::() { - self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FSYNC => self.fsync(packet.b), - SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), - SYS_FUTIMENS => if packet.d >= mem::size_of::() { - self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::()) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_CLOSE => self.close(packet.b), - _ => Err(Error::new(ENOSYS)) - }); - } - - /* Scheme operations */ - - #[allow(unused_variables)] - fn open(&self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - #[allow(unused_variables)] - fn chmod(&self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - #[allow(unused_variables)] - fn rmdir(&self, path: &[u8], uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - #[allow(unused_variables)] - fn unlink(&self, path: &[u8], uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - /* Resource operations */ - #[allow(unused_variables)] - fn dup(&self, old_id: usize, buf: &[u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn read(&self, id: usize, buf: &mut [u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn write(&self, id: usize, buf: &[u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn seek(&self, id: usize, pos: usize, whence: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fchmod(&self, id: usize, mode: u16) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fchown(&self, id: usize, uid: u32, gid: u32) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fevent(&self, id: usize, flags: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fmap(&self, id: usize, offset: usize, size: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fpath(&self, id: usize, buf: &mut [u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn frename(&self, id: usize, path: &[u8], uid: u32, gid: u32) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fstat(&self, id: usize, stat: &mut Stat) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fsync(&self, id: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn ftruncate(&self, id: usize, len: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn futimens(&self, id: usize, times: &[TimeSpec]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn close(&self, id: usize) -> Result { - Err(Error::new(EBADF)) - } -} - -pub trait SchemeMut { - fn handle(&mut self, packet: &mut Packet) { - packet.a = Error::mux(match packet.a { - SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), - SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), - SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), - SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), - - SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), - SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), - SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), - SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), - SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), - SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), - SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), - SYS_FEVENT => self.fevent(packet.b, packet.c), - SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), - SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), - SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), - SYS_FSTAT => if packet.d >= mem::size_of::() { - self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FSTATVFS => if packet.d >= mem::size_of::() { - self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FSYNC => self.fsync(packet.b), - SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), - SYS_FUTIMENS => if packet.d >= mem::size_of::() { - self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::()) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_CLOSE => self.close(packet.b), - _ => Err(Error::new(ENOSYS)) - }); - } - - /* Scheme operations */ - #[allow(unused_variables)] - fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - #[allow(unused_variables)] - fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - #[allow(unused_variables)] - fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - #[allow(unused_variables)] - fn unlink(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { - Err(Error::new(ENOENT)) - } - - /* Resource operations */ - #[allow(unused_variables)] - fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn read(&mut self, id: usize, buf: &mut [u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn write(&mut self, id: usize, buf: &[u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn seek(&mut self, id: usize, pos: usize, whence: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fchmod(&mut self, id: usize, mode: u16) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fevent(&mut self, id: usize, flags: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fmap(&mut self, id: usize, offset: usize, size: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn frename(&mut self, id: usize, path: &[u8], uid: u32, gid: u32) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn fsync(&mut self, id: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn ftruncate(&mut self, id: usize, len: usize) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result { - Err(Error::new(EBADF)) - } - - #[allow(unused_variables)] - fn close(&mut self, id: usize) -> Result { - Err(Error::new(EBADF)) - } -} diff --git a/src/scheme/generate.sh b/src/scheme/generate.sh new file mode 100755 index 0000000..abf23a1 --- /dev/null +++ b/src/scheme/generate.sh @@ -0,0 +1,21 @@ +#!/usr/bin/env bash + +set -e + +echo "Generating SchemeMut from Scheme" +sed 's/trait Scheme/trait SchemeMut/' scheme.rs \ +| sed 's/\&self/\&mut self/g' \ +> scheme_mut.rs + +echo "Generating SchemeBlock from Scheme" +sed 's/trait Scheme/trait SchemeBlock/' scheme.rs \ +| sed 's/fn handle(\&self, packet: \&mut Packet)/fn handle(\&self, packet: \&Packet) -> Option/' \ +| sed 's/packet.a = Error::mux(res);/res.map(Error::mux)/' \ +| sed 's/Result/Option>/g' \ +| sed 's/Err(Error::new(\(.*\)))/Some(Err(Error::new(\1)))/g' \ +> scheme_block.rs + +echo "Generating SchemeBlockMut from SchemeBlock" +sed 's/trait SchemeBlock/trait SchemeBlockMut/' scheme_block.rs \ +| sed 's/\&self/\&mut self/g' \ +> scheme_block_mut.rs diff --git a/src/scheme/mod.rs b/src/scheme/mod.rs new file mode 100644 index 0000000..66f8fc7 --- /dev/null +++ b/src/scheme/mod.rs @@ -0,0 +1,9 @@ +pub use self::scheme::Scheme; +pub use self::scheme_mut::SchemeMut; +pub use self::scheme_block::SchemeBlock; +pub use self::scheme_block_mut::SchemeBlockMut; + +mod scheme; +mod scheme_mut; +mod scheme_block; +mod scheme_block_mut; diff --git a/src/scheme/scheme.rs b/src/scheme/scheme.rs new file mode 100644 index 0000000..26921d4 --- /dev/null +++ b/src/scheme/scheme.rs @@ -0,0 +1,157 @@ +use core::{mem, slice}; + +use data::*; +use error::*; +use number::*; + +pub trait Scheme { + fn handle(&self, packet: &mut Packet) { + let res = match packet.a { + SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), + SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), + SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + + SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), + SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), + SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), + SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), + SYS_FEVENT => self.fevent(packet.b, packet.c), + SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), + SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), + SYS_FSTAT => if packet.d >= mem::size_of::() { + self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) + } else { + Err(Error::new(EFAULT)) + }, + SYS_FSTATVFS => if packet.d >= mem::size_of::() { + self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) + } else { + Err(Error::new(EFAULT)) + }, + SYS_FSYNC => self.fsync(packet.b), + SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), + SYS_FUTIMENS => if packet.d >= mem::size_of::() { + self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::()) }) + } else { + Err(Error::new(EFAULT)) + }, + SYS_CLOSE => self.close(packet.b), + _ => Err(Error::new(ENOSYS)) + }; + + packet.a = Error::mux(res); + } + + /* Scheme operations */ + + #[allow(unused_variables)] + fn open(&self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + #[allow(unused_variables)] + fn chmod(&self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + #[allow(unused_variables)] + fn rmdir(&self, path: &[u8], uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + #[allow(unused_variables)] + fn unlink(&self, path: &[u8], uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + /* Resource operations */ + #[allow(unused_variables)] + fn dup(&self, old_id: usize, buf: &[u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn read(&self, id: usize, buf: &mut [u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn write(&self, id: usize, buf: &[u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn seek(&self, id: usize, pos: usize, whence: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fchmod(&self, id: usize, mode: u16) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fchown(&self, id: usize, uid: u32, gid: u32) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fevent(&self, id: usize, flags: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fmap(&self, id: usize, offset: usize, size: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fpath(&self, id: usize, buf: &mut [u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn frename(&self, id: usize, path: &[u8], uid: u32, gid: u32) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fstat(&self, id: usize, stat: &mut Stat) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fsync(&self, id: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn ftruncate(&self, id: usize, len: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn futimens(&self, id: usize, times: &[TimeSpec]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn close(&self, id: usize) -> Result { + Err(Error::new(EBADF)) + } +} diff --git a/src/scheme/scheme_block.rs b/src/scheme/scheme_block.rs new file mode 100644 index 0000000..594ce1f --- /dev/null +++ b/src/scheme/scheme_block.rs @@ -0,0 +1,157 @@ +use core::{mem, slice}; + +use data::*; +use error::*; +use number::*; + +pub trait SchemeBlock { + fn handle(&self, packet: &Packet) -> Option { + let res = match packet.a { + SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), + SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), + SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + + SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), + SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), + SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), + SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), + SYS_FEVENT => self.fevent(packet.b, packet.c), + SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), + SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), + SYS_FSTAT => if packet.d >= mem::size_of::() { + self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) + } else { + Some(Err(Error::new(EFAULT))) + }, + SYS_FSTATVFS => if packet.d >= mem::size_of::() { + self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) + } else { + Some(Err(Error::new(EFAULT))) + }, + SYS_FSYNC => self.fsync(packet.b), + SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), + SYS_FUTIMENS => if packet.d >= mem::size_of::() { + self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::()) }) + } else { + Some(Err(Error::new(EFAULT))) + }, + SYS_CLOSE => self.close(packet.b), + _ => Some(Err(Error::new(ENOSYS))) + }; + + res.map(Error::mux) + } + + /* Scheme operations */ + + #[allow(unused_variables)] + fn open(&self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + #[allow(unused_variables)] + fn chmod(&self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + #[allow(unused_variables)] + fn rmdir(&self, path: &[u8], uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + #[allow(unused_variables)] + fn unlink(&self, path: &[u8], uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + /* Resource operations */ + #[allow(unused_variables)] + fn dup(&self, old_id: usize, buf: &[u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn read(&self, id: usize, buf: &mut [u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn write(&self, id: usize, buf: &[u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn seek(&self, id: usize, pos: usize, whence: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fchmod(&self, id: usize, mode: u16) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fchown(&self, id: usize, uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fevent(&self, id: usize, flags: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fmap(&self, id: usize, offset: usize, size: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fpath(&self, id: usize, buf: &mut [u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn frename(&self, id: usize, path: &[u8], uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fstat(&self, id: usize, stat: &mut Stat) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fsync(&self, id: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn ftruncate(&self, id: usize, len: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn futimens(&self, id: usize, times: &[TimeSpec]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn close(&self, id: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } +} diff --git a/src/scheme/scheme_block_mut.rs b/src/scheme/scheme_block_mut.rs new file mode 100644 index 0000000..bc369b1 --- /dev/null +++ b/src/scheme/scheme_block_mut.rs @@ -0,0 +1,157 @@ +use core::{mem, slice}; + +use data::*; +use error::*; +use number::*; + +pub trait SchemeBlockMut { + fn handle(&mut self, packet: &Packet) -> Option { + let res = match packet.a { + SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), + SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), + SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + + SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), + SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), + SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), + SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), + SYS_FEVENT => self.fevent(packet.b, packet.c), + SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), + SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), + SYS_FSTAT => if packet.d >= mem::size_of::() { + self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) + } else { + Some(Err(Error::new(EFAULT))) + }, + SYS_FSTATVFS => if packet.d >= mem::size_of::() { + self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) + } else { + Some(Err(Error::new(EFAULT))) + }, + SYS_FSYNC => self.fsync(packet.b), + SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), + SYS_FUTIMENS => if packet.d >= mem::size_of::() { + self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::()) }) + } else { + Some(Err(Error::new(EFAULT))) + }, + SYS_CLOSE => self.close(packet.b), + _ => Some(Err(Error::new(ENOSYS))) + }; + + res.map(Error::mux) + } + + /* Scheme operations */ + + #[allow(unused_variables)] + fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + #[allow(unused_variables)] + fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + #[allow(unused_variables)] + fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + #[allow(unused_variables)] + fn unlink(&mut self, path: &[u8], uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(ENOENT))) + } + + /* Resource operations */ + #[allow(unused_variables)] + fn dup(&mut self, old_id: usize, buf: &[u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn read(&mut self, id: usize, buf: &mut [u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn write(&mut self, id: usize, buf: &[u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn seek(&mut self, id: usize, pos: usize, whence: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fchmod(&mut self, id: usize, mode: u16) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fevent(&mut self, id: usize, flags: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fmap(&mut self, id: usize, offset: usize, size: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn frename(&mut self, id: usize, path: &[u8], uid: u32, gid: u32) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fstat(&mut self, id: usize, stat: &mut Stat) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn fsync(&mut self, id: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn ftruncate(&mut self, id: usize, len: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Option> { + Some(Err(Error::new(EBADF))) + } + + #[allow(unused_variables)] + fn close(&mut self, id: usize) -> Option> { + Some(Err(Error::new(EBADF))) + } +} diff --git a/src/scheme/scheme_mut.rs b/src/scheme/scheme_mut.rs new file mode 100644 index 0000000..5b5665c --- /dev/null +++ b/src/scheme/scheme_mut.rs @@ -0,0 +1,157 @@ +use core::{mem, slice}; + +use data::*; +use error::*; +use number::*; + +pub trait SchemeMut { + fn handle(&mut self, packet: &mut Packet) { + let res = match packet.a { + SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid), + SYS_CHMOD => self.chmod(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid), + SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid), + + SYS_DUP => self.dup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }), + SYS_LSEEK => self.seek(packet.b, packet.c, packet.d), + SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16), + SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), + SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), + SYS_FEVENT => self.fevent(packet.b, packet.c), + SYS_FMAP => self.fmap(packet.b, packet.c, packet.d), + SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), + SYS_FRENAME => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), + SYS_FSTAT => if packet.d >= mem::size_of::() { + self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }) + } else { + Err(Error::new(EFAULT)) + }, + SYS_FSTATVFS => if packet.d >= mem::size_of::() { + self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) }) + } else { + Err(Error::new(EFAULT)) + }, + SYS_FSYNC => self.fsync(packet.b), + SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c), + SYS_FUTIMENS => if packet.d >= mem::size_of::() { + self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::()) }) + } else { + Err(Error::new(EFAULT)) + }, + SYS_CLOSE => self.close(packet.b), + _ => Err(Error::new(ENOSYS)) + }; + + packet.a = Error::mux(res); + } + + /* Scheme operations */ + + #[allow(unused_variables)] + fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + #[allow(unused_variables)] + fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + #[allow(unused_variables)] + fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + #[allow(unused_variables)] + fn unlink(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { + Err(Error::new(ENOENT)) + } + + /* Resource operations */ + #[allow(unused_variables)] + fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn read(&mut self, id: usize, buf: &mut [u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn write(&mut self, id: usize, buf: &[u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn seek(&mut self, id: usize, pos: usize, whence: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fchmod(&mut self, id: usize, mode: u16) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fevent(&mut self, id: usize, flags: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fmap(&mut self, id: usize, offset: usize, size: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn frename(&mut self, id: usize, path: &[u8], uid: u32, gid: u32) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn fsync(&mut self, id: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn ftruncate(&mut self, id: usize, len: usize) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result { + Err(Error::new(EBADF)) + } + + #[allow(unused_variables)] + fn close(&mut self, id: usize) -> Result { + Err(Error::new(EBADF)) + } +}