From c06edb232b48024a7a8e468dd5316d5b28a3eac9 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Wed, 5 Oct 2016 14:07:31 -0600 Subject: [PATCH] Lookup uid, gid, and mode from block for stat --- fuse/main.rs | 4 +- scheme/resource.rs | 99 ++++++++++++++++++++++++++-------------------- scheme/scheme.rs | 18 ++++----- 3 files changed, 66 insertions(+), 55 deletions(-) diff --git a/fuse/main.rs b/fuse/main.rs index b31d02cd2f..adcb11ca08 100644 --- a/fuse/main.rs +++ b/fuse/main.rs @@ -198,7 +198,7 @@ impl Filesystem for RedoxFS { fn create(&mut self, _req: &Request, parent_block: u64, name: &Path, mode: u32, flags: u32, reply: ReplyCreate) { match self.fs.create_node(redoxfs::Node::MODE_FILE | (mode as u16 & redoxfs::Node::MODE_PERM), name.to_str().unwrap(), parent_block) { Ok(node) => { - println!("Create {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode); + //println!("Create {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode); reply.created(&TTL, &node_attr(&node), 0, 0, flags); }, Err(error) => { @@ -210,7 +210,7 @@ impl Filesystem for RedoxFS { fn mkdir(&mut self, _req: &Request, parent_block: u64, name: &Path, mode: u32, reply: ReplyEntry) { match self.fs.create_node(redoxfs::Node::MODE_DIR | (mode as u16 & redoxfs::Node::MODE_PERM), name.to_str().unwrap(), parent_block) { Ok(node) => { - println!("Mkdir {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode); + //println!("Mkdir {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode); reply.entry(&TTL, &node_attr(&node), 0); }, Err(error) => { diff --git a/scheme/resource.rs b/scheme/resource.rs index f506c018f7..1276515419 100644 --- a/scheme/resource.rs +++ b/scheme/resource.rs @@ -3,29 +3,31 @@ use redoxfs::FileSystem; use std::cmp::{min, max}; use syscall::error::{Error, Result, EINVAL}; -use syscall::{Stat, SEEK_SET, SEEK_CUR, SEEK_END, MODE_DIR, MODE_FILE}; +use syscall::{Stat, SEEK_SET, SEEK_CUR, SEEK_END}; pub trait Resource { fn dup(&self) -> Result>; fn read(&mut self, buf: &mut [u8], fs: &mut FileSystem) -> Result; fn write(&mut self, buf: &[u8], fs: &mut FileSystem) -> Result; - fn seek(&mut self, offset: usize, whence: usize) -> Result; + fn seek(&mut self, offset: usize, whence: usize, fs: &mut FileSystem) -> Result; fn path(&self, buf: &mut [u8]) -> Result; - fn stat(&self, _stat: &mut Stat) -> Result; + fn stat(&self, _stat: &mut Stat, fs: &mut FileSystem) -> Result; fn sync(&mut self) -> Result; fn truncate(&mut self, len: usize, fs: &mut FileSystem) -> Result; } pub struct DirResource { - path: Vec, + path: String, + block: u64, data: Vec, seek: usize, } impl DirResource { - pub fn new(path: &[u8], data: Vec) -> DirResource { + pub fn new(path: String, block: u64, data: Vec) -> DirResource { DirResource { - path: path.to_vec(), + path: path, + block: block, data: data, seek: 0, } @@ -36,6 +38,7 @@ impl Resource for DirResource { fn dup(&self) -> Result> { Ok(Box::new(DirResource { path: self.path.clone(), + block: self.block, data: self.data.clone(), seek: self.seek })) @@ -55,28 +58,37 @@ impl Resource for DirResource { Err(Error::new(EINVAL)) } - fn seek(&mut self, offset: usize, whence: usize) -> Result { - match whence { - SEEK_SET => self.seek = min(0, max(self.data.len() as isize, offset as isize)) as usize, - SEEK_CUR => self.seek = min(0, max(self.data.len() as isize, self.seek as isize + offset as isize)) as usize, - SEEK_END => self.seek = min(0, max(self.data.len() as isize, self.data.len() as isize + offset as isize)) as usize, + fn seek(&mut self, offset: usize, whence: usize, _fs: &mut FileSystem) -> Result { + self.seek = match whence { + SEEK_SET => min(0, max(self.data.len() as isize, offset as isize)) as usize, + SEEK_CUR => min(0, max(self.data.len() as isize, self.seek as isize + offset as isize)) as usize, + SEEK_END => min(0, max(self.data.len() as isize, self.data.len() as isize + offset as isize)) as usize, _ => return Err(Error::new(EINVAL)) - } + }; + Ok(self.seek) } fn path(&self, buf: &mut [u8]) -> Result { + let path = self.path.as_bytes(); + let mut i = 0; - while i < buf.len() && i < self.path.len() { - buf[i] = self.path[i]; + while i < buf.len() && i < path.len() { + buf[i] = path[i]; i += 1; } + Ok(i) } - fn stat(&self, stat: &mut Stat) -> Result { - stat.st_mode = MODE_DIR; - stat.st_size = self.data.len() as u64; + fn stat(&self, stat: &mut Stat, fs: &mut FileSystem) -> Result { + let node = try!(fs.node(self.block)); + + stat.st_mode = node.1.mode; + stat.st_uid = node.1.uid; + stat.st_gid = node.1.gid; + stat.st_size = try!(fs.node_len(self.block)); + Ok(0) } @@ -90,19 +102,17 @@ impl Resource for DirResource { } pub struct FileResource { - path: Vec, + path: String, block: u64, seek: u64, - size: u64, } impl FileResource { - pub fn new(path: &[u8], block: u64, size: u64) -> FileResource { + pub fn new(path: String, block: u64) -> FileResource { FileResource { - path: path.to_vec(), + path: path, block: block, seek: 0, - size: size, } } } @@ -113,7 +123,6 @@ impl Resource for FileResource { path: self.path.clone(), block: self.block, seek: self.seek, - size: self.size })) } @@ -126,35 +135,42 @@ impl Resource for FileResource { fn write(&mut self, buf: &[u8], fs: &mut FileSystem) -> Result { let count = try!(fs.write_node(self.block, self.seek, buf)); self.seek += count as u64; - if self.seek > self.size { - self.size = self.seek; - } Ok(count) } - fn seek(&mut self, offset: usize, whence: usize) -> Result { - match whence { - SEEK_SET => self.seek = min(0, max(self.size as i64, offset as i64)) as u64, - SEEK_CUR => self.seek = min(0, max(self.size as i64, self.seek as i64 + offset as i64)) as u64, - SEEK_END => self.seek = min(0, max(self.size as i64, self.size as i64 + offset as i64)) as u64, + fn seek(&mut self, offset: usize, whence: usize, fs: &mut FileSystem) -> Result { + let size = try!(fs.node_len(self.block)); + + self.seek = match whence { + SEEK_SET => min(0, max(size as i64, offset as i64)) as u64, + SEEK_CUR => min(0, max(size as i64, self.seek as i64 + offset as i64)) as u64, + SEEK_END => min(0, max(size as i64, size as i64 + offset as i64)) as u64, _ => return Err(Error::new(EINVAL)) - } + }; Ok(self.seek as usize) } fn path(&self, buf: &mut [u8]) -> Result { + let path = self.path.as_bytes(); + let mut i = 0; - while i < buf.len() && i < self.path.len() { - buf[i] = self.path[i]; + while i < buf.len() && i < path.len() { + buf[i] = path[i]; i += 1; } + Ok(i) } - fn stat(&self, stat: &mut Stat) -> Result { - stat.st_mode = MODE_FILE; - stat.st_size = self.size as u64; + fn stat(&self, stat: &mut Stat, fs: &mut FileSystem) -> Result { + let node = try!(fs.node(self.block)); + + stat.st_mode = node.1.mode; + stat.st_uid = node.1.uid; + stat.st_gid = node.1.gid; + stat.st_size = try!(fs.node_len(self.block)); + Ok(0) } @@ -163,11 +179,8 @@ impl Resource for FileResource { } fn truncate(&mut self, len: usize, fs: &mut FileSystem) -> Result { - if let Err(err) = fs.node_set_len(self.block, len as u64) { - Err(err) - } else { - self.size = len as u64; - Ok(0) - } + try!(fs.node_set_len(self.block, len as u64)); + + Ok(0) } } diff --git a/scheme/scheme.rs b/scheme/scheme.rs index f284f35b62..879715b2c5 100644 --- a/scheme/scheme.rs +++ b/scheme/scheme.rs @@ -51,14 +51,13 @@ impl FileScheme { data.extend_from_slice(&name.as_bytes()); } } - return Ok(Box::new(DirResource::new(path.as_bytes(), data))); + return Ok(Box::new(DirResource::new(path.to_string(), node.0, data))); } else { if flags & O_TRUNC == O_TRUNC { // println!("Truncate {}", path); try!(fs.node_set_len(node.0, 0)); } - let size = try!(fs.node_len(node.0)); - return Ok(Box::new(FileResource::new(url, node.0, size))); + return Ok(Box::new(FileResource::new(path.to_string(), node.0))); }, Err(err) => if err.errno == ENOENT && flags & O_CREAT == O_CREAT { let mut last_part = String::new(); @@ -70,7 +69,7 @@ impl FileScheme { if ! last_part.is_empty() { if let Some(parent) = nodes.last() { let node = try!(fs.create_node(Node::MODE_FILE, &last_part, parent.0)); - return Ok(Box::new(FileResource::new(path.as_bytes(), node.0, 0))); + return Ok(Box::new(FileResource::new(path.to_string(), node.0))); } else { return Err(Error::new(EPERM)); } @@ -217,7 +216,7 @@ impl Scheme for FileScheme { // println!("Seek {}, {} {}", id, pos, whence); let mut files = self.files.lock(); if let Some(mut file) = files.get_mut(&id) { - file.seek(pos, whence) + file.seek(pos, whence, &mut self.fs.borrow_mut()) } else { Err(Error::new(EBADF)) } @@ -228,6 +227,7 @@ impl Scheme for FileScheme { let files = self.files.lock(); if let Some(file) = files.get(&id) { let name = self.name.as_bytes(); + let mut i = 0; while i < buf.len() && i < name.len() { buf[i] = name[i]; @@ -237,10 +237,8 @@ impl Scheme for FileScheme { buf[i] = b':'; i += 1; } - match file.path(&mut buf[i..]) { - Ok(count) => Ok(i + count), - Err(err) => Err(err) - } + + file.path(&mut buf[i..]).map(|count| i + count) } else { Err(Error::new(EBADF)) } @@ -250,7 +248,7 @@ impl Scheme for FileScheme { // println!("Fstat {}, {:X}", id, stat as *mut Stat as usize); let files = self.files.lock(); if let Some(file) = files.get(&id) { - file.stat(stat) + file.stat(stat, &mut self.fs.borrow_mut()) } else { Err(Error::new(EBADF)) }