From fcbc8951da11ad4c8378598c156edead3c8edba4 Mon Sep 17 00:00:00 2001
From: Jeremy Soller <jackpot51@gmail.com>
Date: Mon, 19 Sep 2016 18:29:28 -0600
Subject: [PATCH] Minimize locking in schemes. Reenable pcid and ion launch in
init. WIP: Userspace schemes
---
scheme/debug.rs | 12 +--
scheme/env.rs | 40 +++++----
scheme/initfs.rs | 42 ++++-----
scheme/irq.rs | 12 +--
scheme/mod.rs | 33 +++----
scheme/user.rs | 217 +++++++++++++++++++++++++++++++++++++++++++++
syscall/error.rs | 6 ++
syscall/fs.rs | 109 ++++++++++++++---------
syscall/process.rs | 9 +-
9 files changed, 367 insertions(+), 113 deletions(-)
create mode 100644 scheme/user.rs
diff --git a/scheme/debug.rs b/scheme/debug.rs
index c3b77d88..a2821916 100644
--- a/scheme/debug.rs
+++ b/scheme/debug.rs
@@ -23,18 +23,18 @@ pub extern fn debug_input(b: u8) {
pub struct DebugScheme;
impl Scheme for DebugScheme {
- fn open(&mut self, _path: &[u8], _flags: usize) -> Result<usize> {
+ fn open(&self, _path: &[u8], _flags: usize) -> Result<usize> {
Ok(0)
}
- fn dup(&mut self, _file: usize) -> Result<usize> {
+ fn dup(&self, _file: usize) -> Result<usize> {
Ok(0)
}
/// Read the file `number` into the `buffer`
///
/// Returns the number of bytes read
- fn read(&mut self, _file: usize, buf: &mut [u8]) -> Result<usize> {
+ fn read(&self, _file: usize, buf: &mut [u8]) -> Result<usize> {
loop {
let mut i = 0;
{
@@ -56,18 +56,18 @@ impl Scheme for DebugScheme {
/// Write the `buffer` to the `file`
///
/// Returns the number of bytes written
- fn write(&mut self, _file: usize, buffer: &[u8]) -> Result<usize> {
+ fn write(&self, _file: usize, buffer: &[u8]) -> Result<usize> {
//TODO: Write bytes, do not convert to str
print!("{}", unsafe { str::from_utf8_unchecked(buffer) });
Ok(buffer.len())
}
- fn fsync(&mut self, _file: usize) -> Result<()> {
+ fn fsync(&self, _file: usize) -> Result<()> {
Ok(())
}
/// Close the file `number`
- fn close(&mut self, _file: usize) -> Result<()> {
+ fn close(&self, _file: usize) -> Result<()> {
Ok(())
}
}
diff --git a/scheme/env.rs b/scheme/env.rs
index 6e577833..98c0948b 100644
--- a/scheme/env.rs
+++ b/scheme/env.rs
@@ -1,4 +1,6 @@
use collections::BTreeMap;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use spin::RwLock;
use syscall::{Error, Result};
use super::Scheme;
@@ -9,9 +11,9 @@ struct Handle {
}
pub struct EnvScheme {
- next_id: usize,
+ next_id: AtomicUsize,
files: BTreeMap<&'static [u8], &'static [u8]>,
- handles: BTreeMap<usize, Handle>
+ handles: RwLock<BTreeMap<usize, Handle>>
}
impl EnvScheme {
@@ -24,20 +26,19 @@ impl EnvScheme {
files.insert(b"LINES", b"30");
EnvScheme {
- next_id: 0,
+ next_id: AtomicUsize::new(0),
files: files,
- handles: BTreeMap::new()
+ handles: RwLock::new(BTreeMap::new())
}
}
}
impl Scheme for EnvScheme {
- fn open(&mut self, path: &[u8], _flags: usize) -> Result<usize> {
+ fn open(&self, path: &[u8], _flags: usize) -> Result<usize> {
let data = self.files.get(path).ok_or(Error::NoEntry)?;
- let id = self.next_id;
- self.next_id += 1;
- self.handles.insert(id, Handle {
+ let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+ self.handles.write().insert(id, Handle {
data: data,
seek: 0
});
@@ -45,15 +46,15 @@ impl Scheme for EnvScheme {
Ok(id)
}
- fn dup(&mut self, file: usize) -> Result<usize> {
+ fn dup(&self, file: usize) -> Result<usize> {
let (data, seek) = {
- let handle = self.handles.get(&file).ok_or(Error::BadFile)?;
+ let handles = self.handles.read();
+ let handle = handles.get(&file).ok_or(Error::BadFile)?;
(handle.data, handle.seek)
};
- let id = self.next_id;
- self.next_id += 1;
- self.handles.insert(id, Handle {
+ let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+ self.handles.write().insert(id, Handle {
data: data,
seek: seek
});
@@ -61,8 +62,9 @@ impl Scheme for EnvScheme {
Ok(id)
}
- fn read(&mut self, file: usize, buffer: &mut [u8]) -> Result<usize> {
- let mut handle = self.handles.get_mut(&file).ok_or(Error::BadFile)?;
+ fn read(&self, file: usize, buffer: &mut [u8]) -> Result<usize> {
+ let mut handles = self.handles.write();
+ let mut handle = handles.get_mut(&file).ok_or(Error::BadFile)?;
let mut i = 0;
while i < buffer.len() && handle.seek < handle.data.len() {
@@ -74,15 +76,15 @@ impl Scheme for EnvScheme {
Ok(i)
}
- fn write(&mut self, _file: usize, _buffer: &[u8]) -> Result<usize> {
+ fn write(&self, _file: usize, _buffer: &[u8]) -> Result<usize> {
Err(Error::NotPermitted)
}
- fn fsync(&mut self, _file: usize) -> Result<()> {
+ fn fsync(&self, _file: usize) -> Result<()> {
Ok(())
}
- fn close(&mut self, file: usize) -> Result<()> {
- self.handles.remove(&file).ok_or(Error::BadFile).and(Ok(()))
+ fn close(&self, file: usize) -> Result<()> {
+ self.handles.write().remove(&file).ok_or(Error::BadFile).and(Ok(()))
}
}
diff --git a/scheme/initfs.rs b/scheme/initfs.rs
index 96d7d35d..186d89d0 100644
--- a/scheme/initfs.rs
+++ b/scheme/initfs.rs
@@ -1,4 +1,6 @@
use collections::BTreeMap;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use spin::RwLock;
use syscall::{Error, Result};
use super::Scheme;
@@ -9,9 +11,9 @@ struct Handle {
}
pub struct InitFsScheme {
- next_id: usize,
+ next_id: AtomicUsize,
files: BTreeMap<&'static [u8], &'static [u8]>,
- handles: BTreeMap<usize, Handle>
+ handles: RwLock<BTreeMap<usize, Handle>>
}
impl InitFsScheme {
@@ -22,23 +24,22 @@ impl InitFsScheme {
files.insert(b"bin/ion", include_bytes!("../../build/userspace/ion"));
files.insert(b"bin/pcid", include_bytes!("../../build/userspace/pcid"));
files.insert(b"bin/ps2d", include_bytes!("../../build/userspace/ps2d"));
- files.insert(b"etc/init.rc", b"#initfs:bin/pcid\ninitfs:bin/ps2d\n#initfs:bin/ion");
+ files.insert(b"etc/init.rc", b"initfs:bin/pcid\ninitfs:bin/ps2d\ninitfs:bin/ion");
InitFsScheme {
- next_id: 0,
+ next_id: AtomicUsize::new(0),
files: files,
- handles: BTreeMap::new()
+ handles: RwLock::new(BTreeMap::new())
}
}
}
impl Scheme for InitFsScheme {
- fn open(&mut self, path: &[u8], _flags: usize) -> Result<usize> {
+ fn open(&self, path: &[u8], _flags: usize) -> Result<usize> {
let data = self.files.get(path).ok_or(Error::NoEntry)?;
- let id = self.next_id;
- self.next_id += 1;
- self.handles.insert(id, Handle {
+ let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+ self.handles.write().insert(id, Handle {
data: data,
seek: 0
});
@@ -46,15 +47,15 @@ impl Scheme for InitFsScheme {
Ok(id)
}
- fn dup(&mut self, file: usize) -> Result<usize> {
+ fn dup(&self, file: usize) -> Result<usize> {
let (data, seek) = {
- let handle = self.handles.get(&file).ok_or(Error::BadFile)?;
+ let handles = self.handles.read();
+ let handle = handles.get(&file).ok_or(Error::BadFile)?;
(handle.data, handle.seek)
};
- let id = self.next_id;
- self.next_id += 1;
- self.handles.insert(id, Handle {
+ let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+ self.handles.write().insert(id, Handle {
data: data,
seek: seek
});
@@ -62,8 +63,9 @@ impl Scheme for InitFsScheme {
Ok(id)
}
- fn read(&mut self, file: usize, buffer: &mut [u8]) -> Result<usize> {
- let mut handle = self.handles.get_mut(&file).ok_or(Error::BadFile)?;
+ fn read(&self, file: usize, buffer: &mut [u8]) -> Result<usize> {
+ let mut handles = self.handles.write();
+ let mut handle = handles.get_mut(&file).ok_or(Error::BadFile)?;
let mut i = 0;
while i < buffer.len() && handle.seek < handle.data.len() {
@@ -75,15 +77,15 @@ impl Scheme for InitFsScheme {
Ok(i)
}
- fn write(&mut self, _file: usize, _buffer: &[u8]) -> Result<usize> {
+ fn write(&self, _file: usize, _buffer: &[u8]) -> Result<usize> {
Err(Error::NotPermitted)
}
- fn fsync(&mut self, _file: usize) -> Result<()> {
+ fn fsync(&self, _file: usize) -> Result<()> {
Ok(())
}
- fn close(&mut self, file: usize) -> Result<()> {
- self.handles.remove(&file).ok_or(Error::BadFile).and(Ok(()))
+ fn close(&self, file: usize) -> Result<()> {
+ self.handles.write().remove(&file).ok_or(Error::BadFile).and(Ok(()))
}
}
diff --git a/scheme/irq.rs b/scheme/irq.rs
index 2e762d44..41928b00 100644
--- a/scheme/irq.rs
+++ b/scheme/irq.rs
@@ -7,7 +7,7 @@ use super::Scheme;
pub struct IrqScheme;
impl Scheme for IrqScheme {
- fn open(&mut self, path: &[u8], _flags: usize) -> Result<usize> {
+ fn open(&self, path: &[u8], _flags: usize) -> Result<usize> {
let path_str = str::from_utf8(path).or(Err(Error::NoEntry))?;
let id = path_str.parse::<usize>().or(Err(Error::NoEntry))?;
@@ -19,11 +19,11 @@ impl Scheme for IrqScheme {
}
}
- fn dup(&mut self, file: usize) -> Result<usize> {
+ fn dup(&self, file: usize) -> Result<usize> {
Ok(file)
}
- fn read(&mut self, file: usize, buffer: &mut [u8]) -> Result<usize> {
+ fn read(&self, file: usize, buffer: &mut [u8]) -> Result<usize> {
// Ensures that the length of the buffer is larger than the size of a usize
if buffer.len() >= mem::size_of::<usize>() {
let ack = ACKS.lock()[file];
@@ -41,7 +41,7 @@ impl Scheme for IrqScheme {
}
}
- fn write(&mut self, file: usize, buffer: &[u8]) -> Result<usize> {
+ fn write(&self, file: usize, buffer: &[u8]) -> Result<usize> {
if buffer.len() >= mem::size_of::<usize>() {
assert!(buffer.len() >= mem::size_of::<usize>());
let ack = unsafe { *(buffer.as_ptr() as *const usize) };
@@ -58,11 +58,11 @@ impl Scheme for IrqScheme {
}
}
- fn fsync(&mut self, _file: usize) -> Result<()> {
+ fn fsync(&self, _file: usize) -> Result<()> {
Ok(())
}
- fn close(&mut self, _file: usize) -> Result<()> {
+ fn close(&self, _file: usize) -> Result<()> {
Ok(())
}
}
diff --git a/scheme/mod.rs b/scheme/mod.rs
index 6ca5c135..41e79781 100644
--- a/scheme/mod.rs
+++ b/scheme/mod.rs
@@ -11,7 +11,7 @@ use alloc::boxed::Box;
use collections::BTreeMap;
-use spin::{Once, Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use spin::{Once, RwLock, RwLockReadGuard, RwLockWriteGuard};
use syscall::{Error, Result};
@@ -32,12 +32,15 @@ pub mod initfs;
/// IRQ handling
pub mod irq;
+/// Userspace schemes
+//pub mod user;
+
/// Limit on number of schemes
pub const SCHEME_MAX_SCHEMES: usize = 65536;
/// Scheme list type
pub struct SchemeList {
- map: BTreeMap<usize, Arc<Mutex<Box<Scheme + Send>>>>,
+ map: BTreeMap<usize, Arc<Box<Scheme + Send + Sync>>>,
names: BTreeMap<Box<[u8]>, usize>,
next_id: usize
}
@@ -53,11 +56,11 @@ impl SchemeList {
}
/// Get the nth scheme.
- pub fn get(&self, id: usize) -> Option<&Arc<Mutex<Box<Scheme + Send>>>> {
+ pub fn get(&self, id: usize) -> Option<&Arc<Box<Scheme + Send + Sync>>> {
self.map.get(&id)
}
- pub fn get_name(&self, name: &[u8]) -> Option<(usize, &Arc<Mutex<Box<Scheme + Send>>>)> {
+ pub fn get_name(&self, name: &[u8]) -> Option<(usize, &Arc<Box<Scheme + Send + Sync>>)> {
if let Some(&id) = self.names.get(name) {
self.get(id).map(|scheme| (id, scheme))
} else {
@@ -66,7 +69,7 @@ impl SchemeList {
}
/// Create a new scheme.
- pub fn insert(&mut self, name: Box<[u8]>, scheme: Arc<Mutex<Box<Scheme + Send>>>) -> Result<&Arc<Mutex<Box<Scheme + Send>>>> {
+ pub fn insert(&mut self, name: Box<[u8]>, scheme: Arc<Box<Scheme + Send + Sync>>) -> Result<&Arc<Box<Scheme + Send + Sync>>> {
if self.names.contains_key(&name) {
return Err(Error::FileExists);
}
@@ -99,10 +102,10 @@ static SCHEMES: Once<RwLock<SchemeList>> = Once::new();
/// Initialize schemes, called if needed
fn init_schemes() -> RwLock<SchemeList> {
let mut list: SchemeList = SchemeList::new();
- list.insert(Box::new(*b"debug"), Arc::new(Mutex::new(Box::new(DebugScheme)))).expect("failed to insert debug: scheme");
- list.insert(Box::new(*b"env"), Arc::new(Mutex::new(Box::new(EnvScheme::new())))).expect("failed to insert env: scheme");
- list.insert(Box::new(*b"initfs"), Arc::new(Mutex::new(Box::new(InitFsScheme::new())))).expect("failed to insert initfs: scheme");
- list.insert(Box::new(*b"irq"), Arc::new(Mutex::new(Box::new(IrqScheme)))).expect("failed to insert irq: scheme");
+ list.insert(Box::new(*b"debug"), Arc::new(Box::new(DebugScheme))).expect("failed to insert debug: scheme");
+ list.insert(Box::new(*b"env"), Arc::new(Box::new(EnvScheme::new()))).expect("failed to insert env: scheme");
+ list.insert(Box::new(*b"initfs"), Arc::new(Box::new(InitFsScheme::new()))).expect("failed to insert initfs: scheme");
+ list.insert(Box::new(*b"irq"), Arc::new(Box::new(IrqScheme))).expect("failed to insert irq: scheme");
RwLock::new(list)
}
@@ -121,26 +124,26 @@ pub trait Scheme {
/// Open the file at `path` with `flags`.
///
/// Returns a file descriptor or an error
- fn open(&mut self, path: &[u8], flags: usize) -> Result<usize>;
+ fn open(&self, path: &[u8], flags: usize) -> Result<usize>;
/// Duplicate an open file descriptor
///
/// Returns a file descriptor or an error
- fn dup(&mut self, file: usize) -> Result<usize>;
+ fn dup(&self, file: usize) -> Result<usize>;
/// Read from some file descriptor into the `buffer`
///
/// Returns the number of bytes read
- fn read(&mut self, file: usize, buffer: &mut [u8]) -> Result<usize>;
+ fn read(&self, file: usize, buffer: &mut [u8]) -> Result<usize>;
/// Write the `buffer` to the file descriptor
///
/// Returns the number of bytes written
- fn write(&mut self, file: usize, buffer: &[u8]) -> Result<usize>;
+ fn write(&self, file: usize, buffer: &[u8]) -> Result<usize>;
/// Sync the file descriptor
- fn fsync(&mut self, file: usize) -> Result<()>;
+ fn fsync(&self, file: usize) -> Result<()>;
/// Close the file descriptor
- fn close(&mut self, file: usize) -> Result<()>;
+ fn close(&self, file: usize) -> Result<()>;
}
diff --git a/scheme/user.rs b/scheme/user.rs
new file mode 100644
index 00000000..23b9c719
--- /dev/null
+++ b/scheme/user.rs
@@ -0,0 +1,217 @@
+use alloc::arc::{Arc, Weak};
+use alloc::boxed::Box;
+
+use collections::{BTreeMap, VecDeque};
+
+use core::cell::Cell;
+use core::mem::size_of;
+use core::ops::DerefMut;
+use core::{ptr, slice};
+
+use syscall::{Call, Error, Result};
+
+use super::Scheme;
+
+/// UserScheme has to be wrapped
+pub struct UserScheme {
+ next_id: Cell<usize>,
+ todo: VecDeque<(usize, (usize, usize, usize, usize))>,
+ done: BTreeMap<usize, (usize, usize, usize, usize)>,
+}
+
+impl UserScheme {
+ fn call(&self, a: Call, b: usize, c: usize, d: usize) -> Result<usize> {
+ let id = self.next_id.get();
+
+ //TODO: What should be done about collisions in self.todo or self.done?
+ let mut next_id = id + 1;
+ if next_id <= 0 {
+ next_id = 1;
+ }
+ self.next_id.set(next_id);
+
+ // println!("{} {}: {} {} {:X} {:X} {:X}", UserScheme.name, id, a, ::syscall::name(a), b, c, d);
+
+ Ok(0)
+ }
+
+ fn capture(&self, mut physical_address: usize, size: usize, writeable: bool) -> Result<usize> {
+ Ok(0)
+ }
+
+ fn release(&self, virtual_address: usize) {
+
+ }
+}
+
+impl Scheme for UserScheme {
+ fn open(&mut self, path: &[u8], flags: usize) -> Result<usize> {
+ let virtual_address = try!(self.capture(path.as_ptr() as usize, path.len(), false));
+
+ let result = self.call(Call::Open, virtual_address, path.len(), flags);
+
+ self.release(virtual_address);
+
+ result
+ }
+
+ /*
+ fn mkdir(&mut self, path: &str, flags: usize) -> Result<()> {
+ let virtual_address = try!(self.capture(path.as_ptr() as usize, path.len(), false));
+
+ let result = self.call(Call::MkDir, virtual_address, path.len(), flags);
+
+ self.release(virtual_address);
+
+ result.and(Ok(()))
+ }
+
+ fn rmdir(&mut self, path: &str) -> Result<()> {
+ let virtual_address = try!(self.capture(path.as_ptr() as usize, path.len(), false));
+
+ let result = self.call(SYS_RMDIR, virtual_address, path.len(), 0);
+
+ self.release(virtual_address);
+
+ result.and(Ok(()))
+ }
+
+ fn unlink(&mut self, path: &str) -> Result<()> {
+ let virtual_address = try!(self.capture(path.as_ptr() as usize, path.len(), false));
+
+ let result = self.call(SYS_UNLINK, virtual_address, path.len(), 0);
+
+ self.release(virtual_address);
+
+ result.and(Ok(()))
+ }
+ */
+
+ /// Duplicate the resource
+ fn dup(&mut self, file: usize) -> Result<usize> {
+ self.call(Call::Dup, file, 0, 0)
+ }
+
+ /*
+ /// Return the URL of this resource
+ fn path(&self, file: usize, buf: &mut [u8]) -> Result <usize> {
+ let contexts = unsafe { & *::env().contexts.get() };
+ let current = try!(contexts.current());
+ if let Ok(physical_address) = current.translate(buf.as_mut_ptr() as usize, buf.len()) {
+ let offset = physical_address % 4096;
+
+ let virtual_address = try!(self.capture(physical_address - offset, buf.len() + offset, true));
+
+ let result = self.call(SYS_FPATH, file, virtual_address + offset, buf.len());
+
+ //println!("Read {:X} mapped from {:X} to {:X} offset {} length {} size {} result {:?}", physical_address, buf.as_ptr() as usize, virtual_address + offset, offset, buf.len(), virtual_size, result);
+
+ self.release(virtual_address);
+
+ result
+ } else {
+ println!("{}:{} fault {:X} {}", file!(), line!(), buf.as_ptr() as usize, buf.len());
+ Err(Error::Fault)
+ }
+ }
+ */
+
+ /// Read data to buffer
+ fn read(&mut self, file: usize, buf: &mut [u8]) -> Result<usize> {
+ /*
+ let contexts = unsafe { & *::env().contexts.get() };
+ let current = try!(contexts.current());
+ if let Ok(physical_address) = current.translate(buf.as_mut_ptr() as usize, buf.len()) {
+ let offset = physical_address % 4096;
+
+ let virtual_address = try!(self.capture(physical_address - offset, buf.len() + offset, true));
+
+ let result = self.call(Call::Read, file, virtual_address + offset, buf.len());
+
+ //println!("Read {:X} mapped from {:X} to {:X} offset {} length {} size {} result {:?}", physical_address, buf.as_ptr() as usize, virtual_address + offset, offset, buf.len(), virtual_size, result);
+
+ self.release(virtual_address);
+
+ result
+ } else */
+ {
+ println!("{}:{} fault {:X} {}", file!(), line!(), buf.as_ptr() as usize, buf.len());
+ Err(Error::Fault)
+ }
+ }
+
+ /// Write to resource
+ fn write(&mut self, file: usize, buf: &[u8]) -> Result<usize> {
+ /*
+ let contexts = unsafe { & *::env().contexts.get() };
+ let current = try!(contexts.current());
+ if let Ok(physical_address) = current.translate(buf.as_ptr() as usize, buf.len()) {
+ let offset = physical_address % 4096;
+
+ let virtual_address = try!(self.capture(physical_address - offset, buf.len() + offset, false));
+
+ let result = self.call(Call::Write, file, virtual_address + offset, buf.len());
+
+ // println!("Write {:X} mapped from {:X} to {:X} offset {} length {} result {:?}", physical_address, buf.as_ptr() as usize, virtual_address + offset, offset, buf.len(), result);
+
+ self.release(virtual_address);
+
+ result
+ } else */
+ {
+ println!("{}:{} fault {:X} {}", file!(), line!(), buf.as_ptr() as usize, buf.len());
+ Err(Error::Fault)
+ }
+ }
+
+ /*
+ /// Seek
+ fn seek(&mut self, file: usize, pos: ResourceSeek) -> Result<usize> {
+ let (whence, offset) = match pos {
+ ResourceSeek::Start(offset) => (SEEK_SET, offset as usize),
+ ResourceSeek::Current(offset) => (SEEK_CUR, offset as usize),
+ ResourceSeek::End(offset) => (SEEK_END, offset as usize)
+ };
+
+ self.call(SYS_LSEEK, file, offset, whence)
+ }
+
+ /// Stat the resource
+ fn stat(&self, file: usize, stat: &mut Stat) -> Result<()> {
+ let buf = unsafe { slice::from_raw_parts_mut(stat as *mut Stat as *mut u8, size_of::<Stat>()) };
+
+ let contexts = unsafe { & *::env().contexts.get() };
+ let current = try!(contexts.current());
+ if let Ok(physical_address) = current.translate(buf.as_mut_ptr() as usize, buf.len()) {
+ let offset = physical_address % 4096;
+
+ let virtual_address = try!(self.capture(physical_address - offset, buf.len() + offset, true));
+
+ let result = self.call(SYS_FSTAT, file, virtual_address + offset, 0);
+
+ self.release(virtual_address);
+
+ result.and(Ok(()))
+ } else {
+ println!("{}:{} fault {:X} {}", file!(), line!(), buf.as_ptr() as usize, buf.len());
+ Err(Error::Fault)
+ }
+ }
+ */
+
+ /// Sync the resource
+ fn fsync(&mut self, file: usize) -> Result<()> {
+ self.call(Call::FSync, file, 0, 0).and(Ok(()))
+ }
+
+ /*
+ /// Truncate the resource
+ fn truncate(&mut self, file: usize, len: usize) -> Result<()> {
+ self.call(SYS_FTRUNCATE, file, len, 0).and(Ok(()))
+ }
+ */
+
+ fn close(&mut self, file: usize) -> Result<()> {
+ self.call(Call::Close, file, 0, 0).and(Ok(()))
+ }
+}
diff --git a/syscall/error.rs b/syscall/error.rs
index ad37b336..e71a8ca8 100644
--- a/syscall/error.rs
+++ b/syscall/error.rs
@@ -15,12 +15,18 @@ pub enum Error {
BadFile = 9,
/// Try again
TryAgain = 11,
+ /// Bad address
+ Fault = 14,
/// File exists
FileExists = 17,
+ /// No such device
+ NoDevice = 19,
/// Invalid argument
InvalidValue = 22,
/// Too many open files
TooManyFiles = 24,
+ /// Illegal seek
+ IllegalSeek = 29,
/// Syscall not implemented
NoCall = 38
}
diff --git a/syscall/fs.rs b/syscall/fs.rs
index d68727d5..15a24539 100644
--- a/syscall/fs.rs
+++ b/syscall/fs.rs
@@ -5,6 +5,7 @@ use scheme;
use super::{Error, Result};
+/// Change the current working directory
pub fn chdir(path: &[u8]) -> Result<usize> {
let contexts = context::contexts();
let context_lock = contexts.current().ok_or(Error::NoProcess)?;
@@ -14,6 +15,7 @@ pub fn chdir(path: &[u8]) -> Result<usize> {
Ok(0)
}
+/// Get the current working directory
pub fn getcwd(buf: &mut [u8]) -> Result<usize> {
let contexts = context::contexts();
let context_lock = contexts.current().ok_or(Error::NoProcess)?;
@@ -27,38 +29,6 @@ pub fn getcwd(buf: &mut [u8]) -> Result<usize> {
Ok(i)
}
-/// Read syscall
-pub fn read(fd: usize, buf: &mut [u8]) -> Result<usize> {
- let file = {
- let contexts = context::contexts();
- let context_lock = contexts.current().ok_or(Error::NoProcess)?;
- let context = context_lock.read();
- let file = context.get_file(fd).ok_or(Error::BadFile)?;
- file
- };
-
- let schemes = scheme::schemes();
- let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
- let result = scheme_mutex.lock().read(file.number, buf);
- result
-}
-
-/// Write syscall
-pub fn write(fd: usize, buf: &[u8]) -> Result<usize> {
- let file = {
- let contexts = context::contexts();
- let context_lock = contexts.current().ok_or(Error::NoProcess)?;
- let context = context_lock.read();
- let file = context.get_file(fd).ok_or(Error::BadFile)?;
- file
- };
-
- let schemes = scheme::schemes();
- let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
- let result = scheme_mutex.lock().write(file.number, buf);
- result
-}
-
/// Open syscall
pub fn open(path: &[u8], flags: usize) -> Result<usize> {
let path_canon = {
@@ -74,9 +44,12 @@ pub fn open(path: &[u8], flags: usize) -> Result<usize> {
let (scheme_id, file_id) = {
let namespace = namespace_opt.ok_or(Error::NoEntry)?;
- let schemes = scheme::schemes();
- let (scheme_id, scheme_mutex) = schemes.get_name(namespace).ok_or(Error::NoEntry)?;
- let file_id = scheme_mutex.lock().open(reference_opt.unwrap_or(b""), flags)?;
+ let (scheme_id, scheme) = {
+ let schemes = scheme::schemes();
+ let (scheme_id, scheme) = schemes.get_name(namespace).ok_or(Error::NoEntry)?;
+ (scheme_id, scheme.clone())
+ };
+ let file_id = scheme.open(reference_opt.unwrap_or(b""), flags)?;
(scheme_id, file_id)
};
@@ -99,9 +72,12 @@ pub fn close(fd: usize) -> Result<usize> {
file
};
- let schemes = scheme::schemes();
- let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
- let result = scheme_mutex.lock().close(file.number).and(Ok(0));
+ let scheme = {
+ let schemes = scheme::schemes();
+ let scheme = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+ scheme.clone()
+ };
+ let result = scheme.close(file.number).and(Ok(0));
result
}
@@ -115,12 +91,16 @@ pub fn dup(fd: usize) -> Result<usize> {
file
};
- let schemes = scheme::schemes();
- let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
- let result = scheme_mutex.lock().dup(file.number);
+ let scheme = {
+ let schemes = scheme::schemes();
+ let scheme = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+ scheme.clone()
+ };
+ let result = scheme.dup(file.number);
result
}
+/// Sync the file descriptor
pub fn fsync(fd: usize) -> Result<usize> {
let file = {
let contexts = context::contexts();
@@ -130,8 +110,49 @@ pub fn fsync(fd: usize) -> Result<usize> {
file
};
- let schemes = scheme::schemes();
- let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
- let result = scheme_mutex.lock().fsync(file.number).and(Ok(0));
+ let scheme = {
+ let schemes = scheme::schemes();
+ let scheme = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+ scheme.clone()
+ };
+ let result = scheme.fsync(file.number).and(Ok(0));
+ result
+}
+
+/// Read syscall
+pub fn read(fd: usize, buf: &mut [u8]) -> Result<usize> {
+ let file = {
+ let contexts = context::contexts();
+ let context_lock = contexts.current().ok_or(Error::NoProcess)?;
+ let context = context_lock.read();
+ let file = context.get_file(fd).ok_or(Error::BadFile)?;
+ file
+ };
+
+ let scheme = {
+ let schemes = scheme::schemes();
+ let scheme = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+ scheme.clone()
+ };
+ let result = scheme.read(file.number, buf);
+ result
+}
+
+/// Write syscall
+pub fn write(fd: usize, buf: &[u8]) -> Result<usize> {
+ let file = {
+ let contexts = context::contexts();
+ let context_lock = contexts.current().ok_or(Error::NoProcess)?;
+ let context = context_lock.read();
+ let file = context.get_file(fd).ok_or(Error::BadFile)?;
+ file
+ };
+
+ let scheme = {
+ let schemes = scheme::schemes();
+ let scheme = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+ scheme.clone()
+ };
+ let result = scheme.write(file.number, buf);
result
}
diff --git a/syscall/process.rs b/syscall/process.rs
index f05271a9..081b5870 100644
--- a/syscall/process.rs
+++ b/syscall/process.rs
@@ -178,9 +178,12 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<usize> {
for (fd, file_option) in context.files.lock().iter().enumerate() {
if let Some(file) = *file_option {
let result = {
- let schemes = scheme::schemes();
- let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
- let result = scheme_mutex.lock().dup(file.number);
+ let scheme = {
+ let schemes = scheme::schemes();
+ let scheme = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+ scheme.clone()
+ };
+ let result = scheme.dup(file.number);
result
};
match result {
--
GitLab