From 4736a526392e3206b1d592221912618f86ccf864 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Sun, 29 Mar 2020 11:22:21 +0200 Subject: [PATCH 01/30] Initial commit. --- .gitignore | 1 + Cargo.lock | 5 +++++ Cargo.toml | 9 +++++++++ README.md | 2 ++ src/main.rs | 3 +++ 5 files changed, 20 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 README.md create mode 100644 src/main.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000..ea8c4bf7f3 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000000..dced6a0507 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,5 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "ramfs" +version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000000..67e63c6704 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "ramfs" +version = "0.1.0" +authors = ["4lDO2 <4lDO2@protonmail.com>"] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/README.md b/README.md new file mode 100644 index 0000000000..d1c0773204 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# ramfs +A mountable filesystem, which contents is stored in RAM. Useful for early logging, before `redoxfs` has been started. The `initfs:` scheme seems to lack read-write support, and thus this ramfs driver allows logs to be written in initfs drivers. diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000000..e7a11a969c --- /dev/null +++ b/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} From 4b83d5834e5cba1d2ca27de417eb5f8f60103cb8 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Sun, 29 Mar 2020 21:42:32 +0200 Subject: [PATCH 02/30] Implement most of the scheme. --- Cargo.lock | 17 +++ Cargo.toml | 1 + src/filesystem.rs | 68 ++++++++++ src/main.rs | 38 +++++- src/scheme.rs | 319 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 442 insertions(+), 1 deletion(-) create mode 100644 src/filesystem.rs create mode 100644 src/scheme.rs diff --git a/Cargo.lock b/Cargo.lock index dced6a0507..da530d426e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,5 +1,22 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +[[package]] +name = "bitflags" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" + [[package]] name = "ramfs" version = "0.1.0" +dependencies = [ + "redox_syscall", +] + +[[package]] +name = "redox_syscall" +version = "0.1.56" +source = "git+https://gitlab.redox-os.org/redox-os/syscall.git#8d0015be8693a81c2a4459f3c09fb47b98ff07b1" +dependencies = [ + "bitflags", +] diff --git a/Cargo.toml b/Cargo.toml index 67e63c6704..af4002d300 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,3 +7,4 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] +redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git" } diff --git a/src/filesystem.rs b/src/filesystem.rs new file mode 100644 index 0000000000..90dde31672 --- /dev/null +++ b/src/filesystem.rs @@ -0,0 +1,68 @@ +use std::collections::BTreeMap; +use std::os::unix::io::AsRawFd; +use std::fs; + +use syscall::{Error, Result, StatVfs, TimeSpec}; +use syscall::error::EIO; +use syscall::flag::{O_RDONLY, O_STAT}; + +pub struct File { + pub mode: u16, + pub uid: u32, + pub gid: u32, + pub ino: usize, + pub nlink: usize, + + pub atime: TimeSpec, + pub ctime: TimeSpec, + pub mtime: TimeSpec, + pub crtime: TimeSpec, + + pub data: FileData, +} + +pub enum FileData { + File(Vec), + Directory(Vec>), +} +impl FileData { + pub fn size(&self) -> usize { + match self { + &Self::File(ref data) => data.len(), + &Self::Directory(ref names) => names.iter().map(|name| name.len()).sum(), + } + } +} + +pub struct Filesystem { + pub files: BTreeMap, + pub tree: BTreeMap, usize>, + pub memory_file: fs::File, +} +impl Filesystem { + pub const DEFAULT_BLOCK_SIZE: u32 = 4096; + + pub fn new() -> Result { + Ok(Self { + files: BTreeMap::new(), + tree: BTreeMap::new(), + memory_file: fs::File::open("memory:").or(Err(Error::new(EIO)))?, + }) + } + pub fn get_block_size(&self) -> Result { + let mut statvfs = StatVfs::default(); + syscall::fstatvfs(self.memory_file.as_raw_fd() as usize, &mut statvfs)?; + Ok(statvfs.f_bsize) + } + pub fn block_size(&self) -> u32 { + self.get_block_size().unwrap_or(Self::DEFAULT_BLOCK_SIZE) + } + pub fn resolve(&self, mut path: &[u8], uid: u32, gid: u32) -> Option { + // TODO: CoW + let mut path = path.to_owned(); + // TODO: Replace follow symlinks, and replace double slashes with single slashes. + + // TODO: Check that every directory in the path grant the user the search permission. + self.tree.get(&path).copied() + } +} diff --git a/src/main.rs b/src/main.rs index e7a11a969c..8879cd7985 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,39 @@ +#![feature(try_reserve)] + +use std::fs::File; +use std::io::prelude::*; +use std::env; + +use syscall::{CloneFlags, Packet, SchemeMut}; + +mod filesystem; +mod scheme; + +use self::scheme::Scheme; + fn main() { - println!("Hello, world!"); + let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); + let mut socket = File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); + + if unsafe { syscall::clone(CloneFlags::empty()) }.expect("ramfs: failed to fork") != 0 { + return; + } + + let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); + + loop { + let mut packet = Packet::default(); + match socket.read(&mut packet) { + Ok(0) => break, + Ok(_) => (), + Err(error) => panic!("ramfs: failed to read from socket: {:?}", error), + } + scheme.handle(&mut packet); + + match socket.write(&packet) { + Ok(0) => break, + Ok(_) => (), + Err(error) => panic!("ramfs: failed to write to socket: {:?}", error), + } + } } diff --git a/src/scheme.rs b/src/scheme.rs new file mode 100644 index 0000000000..f458750294 --- /dev/null +++ b/src/scheme.rs @@ -0,0 +1,319 @@ +use std::collections::BTreeMap; +use std::convert::{TryFrom, TryInto}; +use std::os::unix::io::AsRawFd; +use std::{cmp, ops}; + +use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; +use syscall::flag::{O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; +use syscall::{MODE_DIR, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; +use syscall::error::{EACCES, EBADF, EBADFD, EFBIG, EINVAL, EISDIR, ENOENT, ENOMEM, ENOSYS, ENOTDIR, EOPNOTSUPP, EOVERFLOW}; + +use crate::filesystem::{FileData, Filesystem}; + +#[derive(Clone)] +struct Handle { + inode: usize, + offset: usize, +} + +pub struct Scheme { + scheme_name: String, + handles: BTreeMap, + next_fd: usize, + filesystem: Filesystem, +} +impl Scheme { + pub fn new(scheme_name: String) -> Result { + Ok(Self { + scheme_name, + handles: BTreeMap::new(), + filesystem: Filesystem::new()?, + next_fd: 0, + }) + } +} + +impl SchemeMut for Scheme { + fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { + let inode = self.filesystem.resolve(path, uid, gid).ok_or(Error::new(ENOENT))?; + let file = self.filesystem.files.get(&inode).ok_or(Error::new(ENOENT))?; + + if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { + return Err(Error::new(ENOTDIR)); + } + if flags & O_STAT == 0 && flags & O_DIRECTORY == 0 && file.mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EISDIR)); + } + + let perm = file.mode & MODE_PERM; + + if uid == file.uid { + check_permissions(flags, (perm & 0o700) >> 6)?; + } else if gid == file.gid { + check_permissions(flags, (perm & 0o70) >> 3)?; + } else { + check_permissions(flags, perm & 0o7)?; + } + + let handle = Handle { + inode, + offset: 0, + }; + + let fd = self.next_fd; + self.next_fd += 1; + + self.handles.insert(fd, handle); + + Ok(fd) + } + fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { + // TODO + Err(Error::new(ENOSYS)) + } + fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { + // TODO + Err(Error::new(ENOSYS)) + } + fn unlink(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { + // TODO + Err(Error::new(ENOSYS)) + } + fn dup(&mut self, old_fd: usize, _buf: &[u8]) -> Result { + let handle = self.handles.get_mut(&old_fd).ok_or(Error::new(EBADF))?.clone(); + + let fd = self.next_fd; + self.next_fd += 1; + + self.handles.insert(fd, handle); + Ok(fd) + } + fn read(&mut self, fd: usize, buf: &mut [u8]) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + match file.data { + FileData::File(ref bytes) => { + if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EBADFD)) } + if handle.offset >= bytes.len() { + return Ok(0); + } + let bytes_to_read = cmp::min(bytes.len(), buf.len() + handle.offset) - handle.offset; + buf[..bytes_to_read].copy_from_slice(&bytes[handle.offset..handle.offset + bytes_to_read]); + Ok(bytes_to_read) + } + FileData::Directory(ref entries) => { + if file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(EBADFD)) } + + let mut bytes_to_skip = handle.offset; + let mut bytes_left_to_read = buf.len(); + let mut bytes_read = 0; + + for entry_bytes in entries { + // skip the whole entry if it fits + if bytes_to_skip >= entry_bytes.len() { + bytes_to_skip -= entry_bytes.len(); + continue; + } + + let bytes_to_read = cmp::min(entry_bytes.len() - bytes_to_skip, bytes_left_to_read); + + let entry_bytes = &entry_bytes[bytes_to_skip..bytes_to_skip + bytes_to_read]; + bytes_to_skip -= bytes_to_skip; + + buf[handle.offset..handle.offset + bytes_to_read].copy_from_slice(&entry_bytes[..bytes_to_read]); + bytes_left_to_read -= bytes_to_read; + bytes_read += bytes_to_read; + } + Ok(bytes_read) + } + } + } + fn write(&mut self, fd: usize, buf: &[u8]) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + if let &mut FileData::File(ref mut bytes) = &mut file.data { + if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EBADFD)) } + + // if there's a seek hole, fill it with 0 and continue writing. + if handle.offset > bytes.len() { + let additional = handle.offset - bytes.len(); + bytes.try_reserve(additional).or(Err(Error::new(ENOMEM)))?; + bytes.resize(handle.offset, 0u8); + } + bytes.extend(buf); + Ok(buf.len()) + } else { + Err(Error::new(EISDIR)) + } + } + fn seek(&mut self, fd: usize, pos: usize, whence: usize) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + // cast to isize, possibly making the offset negative + let pos = pos as isize; + + handle.offset = match whence { + SEEK_SET => cmp::max(0, pos) as usize, + SEEK_CUR => cmp::max(0, pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?) as usize, + SEEK_END => cmp::max(0, pos + isize::try_from(file.data.size()).or(Err(Error::new(EOVERFLOW)))?) as usize, + _ => return Err(Error::new(EINVAL)), + }; + Ok(handle.offset) + } + fn fchmod(&mut self, fd: usize, mode: u16) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + // TODO: Check that no file becomes a directory etc. + file.mode = mode; + + Ok(0) + } + fn fchown(&mut self, fd: usize, uid: u32, gid: u32) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + file.uid = uid; + file.gid = gid; + + Ok(0) + } + fn fcntl(&mut self, fd: usize, _cmd: usize, _arg: usize) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + Ok(0) + } + fn fevent(&mut self, fd: usize, _flags: EventFlags) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + Err(Error::new(ENOSYS)) + } + fn fmap(&mut self, fd: usize, _map: &Map) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + // TODO + Err(Error::new(ENOSYS)) + } + fn funmap(&mut self, _address: usize) -> Result { + // TODO + Err(Error::new(ENOSYS)) + } + fn fpath(&mut self, fd: usize, buf: &mut [u8]) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + // TODO + Err(Error::new(ENOSYS)) + } + fn frename(&mut self, fd: usize, path: &[u8], uid: u32, gid: u32) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + // TODO + Err(Error::new(ENOSYS)) + } + fn fstat(&mut self, fd: usize, stat: &mut Stat) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let block_size = self.filesystem.block_size(); + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + *stat = Stat { + st_mode: file.mode, + st_uid: file.uid, + st_gid: file.gid, + st_ino: handle.inode.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_nlink: file.nlink.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_dev: 0, + + st_size: file.data.size().try_into().or(Err(Error::new(EOVERFLOW)))?, + st_blksize: block_size, + st_blocks: div_round_up(stat.st_size, u64::from(stat.st_blksize)), + + st_atime: file.atime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_atime_nsec: file.atime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, + + st_ctime: file.ctime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_ctime_nsec: file.ctime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, + + st_mtime: file.mtime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_mtime_nsec: file.mtime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, + }; + + Ok(0) + } + fn fstatvfs(&mut self, fd: usize, stat: &mut StatVfs) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + syscall::fstatvfs(self.filesystem.memory_file.as_raw_fd() as usize, stat)?; + + Ok(0) + } + fn fsync(&mut self, fd: usize) -> Result { + if ! self.handles.contains_key(&fd) { + return Err(Error::new(EBADF)); + } + Ok(0) + } + fn ftruncate(&mut self, fd: usize, size: usize) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + if file.mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EISDIR)); + } + match &mut file.data { + &mut FileData::File(ref mut bytes) => { + if size > bytes.len() { + let additional = size - bytes.len(); + bytes.try_reserve(additional).or(Err(Error::new(ENOMEM)))?; + bytes.resize(size, 0u8) + } else { + bytes.resize(size, 0u8) + } + } + &mut FileData::Directory(_) => return Err(Error::new(EBADFD)), + } + Ok(0) + } + fn futimens(&mut self, fd: usize, times: &[TimeSpec]) -> Result { + let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + + let new_atime = *times.get(0).ok_or(Error::new(EINVAL))?; + let new_mtime = *times.get(1).ok_or(Error::new(EINVAL))?; + + file.atime = new_atime; + file.mtime = new_mtime; + + Ok(0) + } + fn close(&mut self, fd: usize) -> Result { + if self.handles.remove(&fd).is_none() { + return Err(Error::new(EBADF)); + } + Ok(0) + } +} +fn div_round_up(numer: T, denom: T) -> T +where + T: Copy + ops::Add + ops::Sub + ops::Div + From, +{ + (numer + (denom - T::from(1u8))) / denom +} +fn check_permissions(flags: usize, single_mode: u16) -> Result<()> { + if flags & O_RDWR == O_RDONLY && single_mode & 0o4 == 0 { + return Err(Error::new(EACCES)); + } else if flags & O_RDWR == O_WRONLY && single_mode & 0o2 == 0 { + return Err(Error::new(EACCES)); + } else if flags & O_RDWR == O_RDWR && single_mode & 0o6 != 0o6 { + return Err(Error::new(EACCES)); + } + Ok(()) +} From 931aa86ba89d208fcc14a43259ad36947e7c200f Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Wed, 1 Apr 2020 17:14:23 +0200 Subject: [PATCH 03/30] Support some path operations. --- Cargo.lock | 39 ++++++++ Cargo.toml | 1 + src/filesystem.rs | 97 +++++++++++++++--- src/scheme.rs | 243 +++++++++++++++++++++++++++++++++++++++------- 4 files changed, 334 insertions(+), 46 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index da530d426e..0da68764e6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6,10 +6,40 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" +[[package]] +name = "bstr" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2889e6d50f394968c8bf4240dc3f2a7eb4680844d27308f798229ac9d4725f41" +dependencies = [ + "lazy_static", + "memchr", + "regex-automata", +] + +[[package]] +name = "byteorder" +version = "1.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "memchr" +version = "2.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" + [[package]] name = "ramfs" version = "0.1.0" dependencies = [ + "bstr", "redox_syscall", ] @@ -20,3 +50,12 @@ source = "git+https://gitlab.redox-os.org/redox-os/syscall.git#8d0015be8693a81c2 dependencies = [ "bitflags", ] + +[[package]] +name = "regex-automata" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae1ded71d66a4a97f5e961fd0cb25a5f366a42a41570d16a763a69c092c26ae4" +dependencies = [ + "byteorder", +] diff --git a/Cargo.toml b/Cargo.toml index af4002d300..f26c92450d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,3 +8,4 @@ edition = "2018" [dependencies] redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git" } +bstr = "0.2" diff --git a/src/filesystem.rs b/src/filesystem.rs index 90dde31672..7b7ab61a7a 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -1,11 +1,18 @@ use std::collections::BTreeMap; -use std::os::unix::io::AsRawFd; +use std::ffi::OsStr; use std::fs; +use std::os::unix::io::AsRawFd; +use std::os::unix::ffi::OsStrExt; + +use bstr::ByteSlice; + use syscall::{Error, Result, StatVfs, TimeSpec}; -use syscall::error::EIO; +use syscall::error::{EACCES, EIO, ENFILE, ENOENT}; use syscall::flag::{O_RDONLY, O_STAT}; +use super::scheme::current_perm; + pub struct File { pub mode: u16, pub uid: u32, @@ -13,6 +20,8 @@ pub struct File { pub ino: usize, pub nlink: usize, + pub open_handles: usize, + pub atime: TimeSpec, pub ctime: TimeSpec, pub mtime: TimeSpec, @@ -21,32 +30,50 @@ pub struct File { pub data: FileData, } +pub struct DirEntry { + pub name: Vec, + pub inode: usize, +} + pub enum FileData { File(Vec), - Directory(Vec>), + Directory(Vec), } impl FileData { pub fn size(&self) -> usize { match self { &Self::File(ref data) => data.len(), - &Self::Directory(ref names) => names.iter().map(|name| name.len()).sum(), + &Self::Directory(ref names) => names.iter().map(|dentry| dentry.name.len()).sum(), + } + } + pub fn as_directory(&self) -> Option<&[DirEntry]> { + match self { + &Self::Directory(ref inner) => Some(inner), + _ => None, + } + } + pub fn as_directory_mut(&mut self) -> Option<&mut Vec> { + match self { + &mut Self::Directory(ref mut inner) => Some(inner), + _ => None, } } } pub struct Filesystem { pub files: BTreeMap, - pub tree: BTreeMap, usize>, pub memory_file: fs::File, + pub last_inode_number: usize, } impl Filesystem { pub const DEFAULT_BLOCK_SIZE: u32 = 4096; + pub const ROOT_INODE: usize = 1; pub fn new() -> Result { Ok(Self { files: BTreeMap::new(), - tree: BTreeMap::new(), memory_file: fs::File::open("memory:").or(Err(Error::new(EIO)))?, + last_inode_number: Self::ROOT_INODE, }) } pub fn get_block_size(&self) -> Result { @@ -57,12 +84,58 @@ impl Filesystem { pub fn block_size(&self) -> u32 { self.get_block_size().unwrap_or(Self::DEFAULT_BLOCK_SIZE) } - pub fn resolve(&self, mut path: &[u8], uid: u32, gid: u32) -> Option { - // TODO: CoW - let mut path = path.to_owned(); - // TODO: Replace follow symlinks, and replace double slashes with single slashes. + pub fn next_inode_number(&mut self) -> Result { + let next = self.last_inode_number.checked_add(1).ok_or(Error::new(ENFILE))?; + self.last_inode_number = next; + Ok(next) + } + fn resolve_generic(&self, parts: Vec<&[u8]>, uid: u32, gid: u32) -> Result { + let mut current_file = self.files.get(&Self::ROOT_INODE).ok_or(Error::new(ENOENT))?; + let mut current_inode = Self::ROOT_INODE; - // TODO: Check that every directory in the path grant the user the search permission. - self.tree.get(&path).copied() + let mut i = 0; + + while let Some(part) = parts.get(i) { + let dentries = match current_file.data { + FileData::Directory(ref dentries) => dentries, + FileData::File(_) => return Err(Error::new(ENOENT)), + }; + let perm = current_perm(¤t_file, uid, gid); + if perm & 0o1 == 0 { return Err(Error::new(EACCES)) } + + if part == b"." || part == b".." { + parts.remove(i); + } + if part == b".." { + if i > 0 { + i -= 1; + parts.remove(i); + } + } + + let entry = dentries.iter().find(|dentry| &dentry.name == part).ok_or(Error::new(ENOENT))?; + current_file = self.files.get(&entry.inode).ok_or(Error::new(EIO))?; + current_inode = entry.inode; + + i += 1; + } + Ok(current_inode) + } + pub fn resolve_except_last<'a>(&self, mut path_bytes: &'a [u8], uid: u32, gid: u32) -> Result<(usize, &'a [u8])> { + if path_bytes.first() == Some(&b'/') { path_bytes = &path_bytes[1..] } + let parts = path_components_iter(path_bytes).collect::>(); + let last = parts.pop().ok_or(Error::new(ENOENT))?; + + Ok((self.resolve_generic(parts, uid, gid)?, last)) + } + pub fn resolve(&self, mut path_bytes: &[u8], uid: u32, gid: u32) -> Result { + if path_bytes.first() == Some(&b'/') { path_bytes = &path_bytes[1..] } + let parts = path_components_iter(path_bytes).collect::>(); + + self.resolve_generic(parts, uid, gid) } } +pub fn path_components_iter(bytes: &[u8]) -> impl Iterator + '_ { + let components_iter = bytes.split(|c| c == &b'/'); + components_iter.filter(|item| !item.is_empty()) +} diff --git a/src/scheme.rs b/src/scheme.rs index f458750294..655ed207e7 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -1,19 +1,26 @@ use std::collections::BTreeMap; use std::convert::{TryFrom, TryInto}; use std::os::unix::io::AsRawFd; -use std::{cmp, ops}; +use std::{cmp, ops, time}; use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; -use syscall::flag::{O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; +use syscall::flag::{O_CREAT, O_EXCL, O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; use syscall::{MODE_DIR, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; -use syscall::error::{EACCES, EBADF, EBADFD, EFBIG, EINVAL, EISDIR, ENOENT, ENOMEM, ENOSYS, ENOTDIR, EOPNOTSUPP, EOVERFLOW}; +use syscall::error::{EACCES, EBADF, EBADFD, EEXIST, EFBIG, EINVAL, EISDIR, EIO, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOPNOTSUPP, EOVERFLOW}; -use crate::filesystem::{FileData, Filesystem}; +use crate::filesystem::{DirEntry, File, FileData, Filesystem}; #[derive(Clone)] struct Handle { inode: usize, offset: usize, + + opened_as_read: bool, // opened with O_RDONLY or O_RDWR + opened_as_write: bool, // opened with O_WRONLY or O_RDWR + + // the three first bits of mode >> 6 if uid matched, mode >> 3 if gid matched, otherwise mode + // >> 0. + current_perm: u8, } pub struct Scheme { @@ -23,6 +30,7 @@ pub struct Scheme { filesystem: Filesystem, } impl Scheme { + /// Create the scheme, with the name being used for `fpath`. pub fn new(scheme_name: String) -> Result { Ok(Self { scheme_name, @@ -31,33 +39,166 @@ impl Scheme { next_fd: 0, }) } + /// Remove a directory entry, where the entry can be both a file or a directory. Used by both + /// `unlink` and `rmdir`. + pub fn remove_dentry(&mut self, path: &[u8], uid: u32, gid: u32, directory: bool) -> Result { + let removed_entry = { + let (parent_dir_inode, name_to_delete) = self.filesystem.resolve_except_last(path, uid, gid)?; + let parent = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + + let mode = current_perm(parent, uid, gid); + if mode & 0o2 != 0 { + return Err(Error::new(EACCES)); + } + + let dentries = parent.data.as_directory_mut().ok_or(Error::new(EBADF))?; + + let (position, entry_inode) = dentries.iter().enumerate().find(|(_, d)| d.name == name_to_delete).unwrap(); + let entry_inode = entry_inode.inode; + + let removed_entry = dentries.remove(position); + + if let Some(File { data: FileData::Directory(ref data), .. }) = self.filesystem.files.get(&entry_inode) { + if !directory { + return Err(Error::new(EISDIR)); + } else if !data.is_empty() { + return Err(Error::new(ENOTEMPTY)); + } + let parent = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + parent.nlink -= 1; // '..' of subdirectory + } + + removed_entry + }; + + let removed_inode = self.filesystem.files.get_mut(&removed_entry.inode).ok_or(Error::new(EIO))?; + + if let FileData::File(_) = removed_inode.data { + if directory { return Err(Error::new(EISDIR)) } + removed_inode.nlink -= 1; // only the parent entry + } else { + if !directory { return Err(Error::new(ENOTDIR)) } + removed_inode.nlink -= 2; // both the parent entry and '.' + } + + if removed_inode.nlink == 0 && removed_inode.open_handles == 0 { + self.filesystem.files.remove(&removed_entry.inode); + } + + Ok(0) + } +} + +pub fn current_time() -> TimeSpec { + let sys_time = time::SystemTime::now(); + + let duration = match sys_time.duration_since(time::SystemTime::UNIX_EPOCH) { + Ok(d) => d, + Err(e) => { + eprintln!("Apparently the signed 32-bit integer has overflowed; the time is now before the Unix epoch..."); + + let negative_duration = e.duration(); + + return TimeSpec { + tv_sec: negative_duration.as_secs().try_into().unwrap_or(i64::min_value()), + tv_nsec: negative_duration.subsec_nanos().try_into().unwrap_or(i32::min_value()), + }; + } + }; + + TimeSpec { + tv_sec: duration.as_secs().try_into().unwrap_or(i64::max_value()), + tv_nsec: duration.subsec_nanos().try_into().unwrap_or(i32::max_value()), + } } impl SchemeMut for Scheme { fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { - let inode = self.filesystem.resolve(path, uid, gid).ok_or(Error::new(ENOENT))?; - let file = self.filesystem.files.get(&inode).ok_or(Error::new(ENOENT))?; + let handle = if flags & O_CREAT != 0 { + if flags & O_EXCL != 0 && self.filesystem.resolve(path, 0, 0).is_ok() { + return Err(Error::new(EEXIST)) + } + if flags & O_STAT != 0 { return Err(Error::new(EINVAL)) } - if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { - return Err(Error::new(ENOTDIR)); - } - if flags & O_STAT == 0 && flags & O_DIRECTORY == 0 && file.mode & MODE_TYPE == MODE_DIR { - return Err(Error::new(EISDIR)); - } + let (parent_dir_inode, new_name) = self.filesystem.resolve_except_last(path, uid, gid)?; - let perm = file.mode & MODE_PERM; - - if uid == file.uid { - check_permissions(flags, (perm & 0o700) >> 6)?; - } else if gid == file.gid { - check_permissions(flags, (perm & 0o70) >> 3)?; + let current_time = current_time(); + + let new_inode_number = self.filesystem.next_inode_number()?; + let new_inode = if flags & O_DIRECTORY != 0 { + File { + atime: current_time, + crtime: current_time, + ctime: current_time, + mtime: current_time, + gid, + uid, + ino: new_inode_number, + mode: 0o755, + nlink: 2, // parent entry, "." + data: FileData::Directory(Vec::new()), + open_handles: 1, + } + } else { + File { + atime: current_time, + crtime: current_time, + ctime: current_time, + mtime: current_time, + gid, + uid, + ino: new_inode_number, + mode: 0o644, + nlink: 1, + data: FileData::File(Vec::new()), + open_handles: 1, + } + }; + let current_perm = current_perm(&new_inode, uid, gid); + check_permissions(flags, current_perm)?; + + self.filesystem.files.insert(new_inode_number, new_inode); + + let parent_file = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + match parent_file.data { + FileData::File(_) => return Err(Error::new(EIO)), + FileData::Directory(ref mut entries) => entries.push(DirEntry { name: new_name.to_owned(), inode: new_inode_number }), + } + + Handle { + inode: new_inode_number, + offset: 0, + opened_as_read: flags & O_RDWR == O_RDONLY || flags & O_RDWR == O_RDWR, + opened_as_write: flags & O_RDWR == O_WRONLY || flags & O_RDWR == O_RDWR, + current_perm, + } } else { - check_permissions(flags, perm & 0o7)?; - } + let inode = self.filesystem.resolve(path, uid, gid)?; + let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(ENOENT))?; - let handle = Handle { - inode, - offset: 0, + if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { + return Err(Error::new(ENOTDIR)); + } + // Unlike on Linux, which allows directories to be opened without O_DIRECTORY, Redox has no + // getdents(2) syscall, and thus it adds the additional restriction that directories have + // to be opened with O_DIRECTORY, if they aren't opened with O_STAT to check whether it's a + // directory. + if flags & O_STAT == 0 && flags & O_DIRECTORY == 0 && file.mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EISDIR)); + } + + let current_perm = current_perm(file, uid, gid); + check_permissions(flags, current_perm)?; + + file.open_handles += 1; + + Handle { + inode, + offset: 0, + opened_as_read: flags & O_RDWR == O_RDONLY || flags & O_RDWR == O_RDWR, + opened_as_write: flags & O_RDWR == O_WRONLY || flags & O_RDWR == O_RDWR, + current_perm, + } }; let fd = self.next_fd; @@ -68,16 +209,23 @@ impl SchemeMut for Scheme { Ok(fd) } fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { - // TODO - Err(Error::new(ENOSYS)) + let inode_num = self.filesystem.resolve(path, uid, gid)?; + let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; + + if inode.uid != uid && uid != 0 { + return Err(Error::new(EACCES)); + } + if mode & MODE_TYPE != 0 { + return Err(Error::new(EINVAL)); + } + inode.mode = mode; + Ok(0) } fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { - // TODO - Err(Error::new(ENOSYS)) + self.remove_dentry(path, uid, gid, true) } fn unlink(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { - // TODO - Err(Error::new(ENOSYS)) + self.remove_dentry(path, uid, gid, false) } fn dup(&mut self, old_fd: usize, _buf: &[u8]) -> Result { let handle = self.handles.get_mut(&old_fd).ok_or(Error::new(EBADF))?.clone(); @@ -92,9 +240,12 @@ impl SchemeMut for Scheme { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + if !handle.opened_as_read { return Err(Error::new(EBADF)) } + match file.data { FileData::File(ref bytes) => { if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EBADFD)) } + if handle.offset >= bytes.len() { return Ok(0); } @@ -104,12 +255,14 @@ impl SchemeMut for Scheme { } FileData::Directory(ref entries) => { if file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(EBADFD)) } + // directories require the execute permission to be listed + if handle.current_perm & 0o1 == 0 { return Err(Error::new(EBADF)) } let mut bytes_to_skip = handle.offset; let mut bytes_left_to_read = buf.len(); let mut bytes_read = 0; - for entry_bytes in entries { + for DirEntry { name: entry_bytes, .. } in entries { // skip the whole entry if it fits if bytes_to_skip >= entry_bytes.len() { bytes_to_skip -= entry_bytes.len(); @@ -167,7 +320,10 @@ impl SchemeMut for Scheme { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; - // TODO: Check that no file becomes a directory etc. + if mode & MODE_TYPE != 0 { + return Err(Error::new(EINVAL)); + } + file.mode = mode; Ok(0) @@ -295,8 +451,13 @@ impl SchemeMut for Scheme { Ok(0) } fn close(&mut self, fd: usize) -> Result { - if self.handles.remove(&fd).is_none() { - return Err(Error::new(EBADF)); + let inode_num = self.handles.remove(&fd).ok_or(Error::new(EBADF))?.inode; + let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; + + inode.open_handles -= 1; + + if inode.nlink == 0 && inode.open_handles == 0 { + self.filesystem.files.remove(&inode_num); } Ok(0) } @@ -307,7 +468,21 @@ where { (numer + (denom - T::from(1u8))) / denom } -fn check_permissions(flags: usize, single_mode: u16) -> Result<()> { +pub fn current_perm(file: &crate::filesystem::File, uid: u32, gid: u32) -> u8 { + let perm = file.mode & MODE_PERM; + + if uid == 0 { + // root doesn't have to be checked + 0o7 + } else if uid == file.uid { + ((perm & 0o700) >> 6) as u8 + } else if gid == file.gid { + ((perm & 0o70) >> 3) as u8 + } else { + (perm & 0o7) as u8 + } +} +fn check_permissions(flags: usize, single_mode: u8) -> Result<()> { if flags & O_RDWR == O_RDONLY && single_mode & 0o4 == 0 { return Err(Error::new(EACCES)); } else if flags & O_RDWR == O_WRONLY && single_mode & 0o2 == 0 { From 6b005a02f4fec8ed4e393dc483e390e45ffea241 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Sat, 4 Apr 2020 10:26:43 +0200 Subject: [PATCH 04/30] Make most of the scheme work, except for deletion. --- Cargo.lock | 39 ------------------- Cargo.toml | 1 - src/filesystem.rs | 77 +++++++++++++++++++++++++++++++++----- src/main.rs | 13 ++++--- src/scheme.rs | 95 +++++++++++++++++++++++------------------------ 5 files changed, 121 insertions(+), 104 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0da68764e6..da530d426e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6,40 +6,10 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" -[[package]] -name = "bstr" -version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2889e6d50f394968c8bf4240dc3f2a7eb4680844d27308f798229ac9d4725f41" -dependencies = [ - "lazy_static", - "memchr", - "regex-automata", -] - -[[package]] -name = "byteorder" -version = "1.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "memchr" -version = "2.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" - [[package]] name = "ramfs" version = "0.1.0" dependencies = [ - "bstr", "redox_syscall", ] @@ -50,12 +20,3 @@ source = "git+https://gitlab.redox-os.org/redox-os/syscall.git#8d0015be8693a81c2 dependencies = [ "bitflags", ] - -[[package]] -name = "regex-automata" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae1ded71d66a4a97f5e961fd0cb25a5f366a42a41570d16a763a69c092c26ae4" -dependencies = [ - "byteorder", -] diff --git a/Cargo.toml b/Cargo.toml index f26c92450d..af4002d300 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,4 +8,3 @@ edition = "2018" [dependencies] redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git" } -bstr = "0.2" diff --git a/src/filesystem.rs b/src/filesystem.rs index 7b7ab61a7a..6a776f3906 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -1,18 +1,18 @@ use std::collections::BTreeMap; +use std::convert::TryInto; use std::ffi::OsStr; -use std::fs; +use std::{iter, fs, time}; use std::os::unix::io::AsRawFd; use std::os::unix::ffi::OsStrExt; -use bstr::ByteSlice; - -use syscall::{Error, Result, StatVfs, TimeSpec}; +use syscall::{Error, Result, StatVfs, TimeSpec, MODE_DIR}; use syscall::error::{EACCES, EIO, ENFILE, ENOENT}; use syscall::flag::{O_RDONLY, O_STAT}; use super::scheme::current_perm; +#[derive(Debug)] pub struct File { pub mode: u16, pub uid: u32, @@ -30,11 +30,13 @@ pub struct File { pub data: FileData, } +#[derive(Clone, Debug)] pub struct DirEntry { pub name: Vec, pub inode: usize, } +#[derive(Debug)] pub enum FileData { File(Vec), Directory(Vec), @@ -71,11 +73,30 @@ impl Filesystem { pub fn new() -> Result { Ok(Self { - files: BTreeMap::new(), + files: iter::once((Self::ROOT_INODE, Self::create_root_inode())).collect(), memory_file: fs::File::open("memory:").or(Err(Error::new(EIO)))?, last_inode_number: Self::ROOT_INODE, }) } + fn create_root_inode() -> File { + let cur_time = current_time(); + File { + atime: cur_time, + crtime: cur_time, + ctime: cur_time, + mtime: cur_time, + + mode: MODE_DIR | 0o755, + ino: Self::ROOT_INODE, + nlink: 1, + open_handles: 0, + + uid: 0, + gid: 0, + + data: FileData::Directory(Vec::new()), + } + } pub fn get_block_size(&self) -> Result { let mut statvfs = StatVfs::default(); syscall::fstatvfs(self.memory_file.as_raw_fd() as usize, &mut statvfs)?; @@ -89,13 +110,19 @@ impl Filesystem { self.last_inode_number = next; Ok(next) } - fn resolve_generic(&self, parts: Vec<&[u8]>, uid: u32, gid: u32) -> Result { + fn resolve_generic(&self, mut parts: Vec<&[u8]>, uid: u32, gid: u32) -> Result { let mut current_file = self.files.get(&Self::ROOT_INODE).ok_or(Error::new(ENOENT))?; + dbg!(); let mut current_inode = Self::ROOT_INODE; let mut i = 0; - while let Some(part) = parts.get(i) { + loop { + let part = match parts.get(i) { + Some(p) => p, + None => break, + }; + dbg!(current_inode, part); let dentries = match current_file.data { FileData::Directory(ref dentries) => dentries, FileData::File(_) => return Err(Error::new(ENOENT)), @@ -106,12 +133,15 @@ impl Filesystem { if part == b"." || part == b".." { parts.remove(i); } + + let part = parts.get(i).unwrap(); if part == b".." { if i > 0 { i -= 1; parts.remove(i); } } + let part = parts.get(i).unwrap(); let entry = dentries.iter().find(|dentry| &dentry.name == part).ok_or(Error::new(ENOENT))?; current_file = self.files.get(&entry.inode).ok_or(Error::new(EIO))?; @@ -121,10 +151,15 @@ impl Filesystem { } Ok(current_inode) } - pub fn resolve_except_last<'a>(&self, mut path_bytes: &'a [u8], uid: u32, gid: u32) -> Result<(usize, &'a [u8])> { + pub fn resolve_except_last<'a>(&self, mut path_bytes: &'a [u8], uid: u32, gid: u32) -> Result<(usize, Option<&'a [u8]>)> { if path_bytes.first() == Some(&b'/') { path_bytes = &path_bytes[1..] } - let parts = path_components_iter(path_bytes).collect::>(); - let last = parts.pop().ok_or(Error::new(ENOENT))?; + let mut parts = path_components_iter(path_bytes).collect::>(); + + let last = if parts.len() >= 1 { + Some(parts.pop().unwrap()) + } else { + None + }; Ok((self.resolve_generic(parts, uid, gid)?, last)) } @@ -139,3 +174,25 @@ pub fn path_components_iter(bytes: &[u8]) -> impl Iterator + '_ { let components_iter = bytes.split(|c| c == &b'/'); components_iter.filter(|item| !item.is_empty()) } +pub fn current_time() -> TimeSpec { + let sys_time = time::SystemTime::now(); + + let duration = match sys_time.duration_since(time::SystemTime::UNIX_EPOCH) { + Ok(d) => d, + Err(e) => { + eprintln!("Apparently the signed 32-bit integer has overflowed; the time is now before the Unix epoch..."); + + let negative_duration = e.duration(); + + return TimeSpec { + tv_sec: negative_duration.as_secs().try_into().unwrap_or(i64::min_value()), + tv_nsec: negative_duration.subsec_nanos().try_into().unwrap_or(i32::min_value()), + }; + } + }; + + TimeSpec { + tv_sec: duration.as_secs().try_into().unwrap_or(i64::max_value()), + tv_nsec: duration.subsec_nanos().try_into().unwrap_or(i32::max_value()), + } +} diff --git a/src/main.rs b/src/main.rs index 8879cd7985..dc73ff138c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,7 +2,7 @@ use std::fs::File; use std::io::prelude::*; -use std::env; +use std::{env, io}; use syscall::{CloneFlags, Packet, SchemeMut}; @@ -13,26 +13,29 @@ use self::scheme::Scheme; fn main() { let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); - let mut socket = File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); if unsafe { syscall::clone(CloneFlags::empty()) }.expect("ramfs: failed to fork") != 0 { return; } + let mut socket = File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); - loop { + 'packet_loop: loop { let mut packet = Packet::default(); + match socket.read(&mut packet) { - Ok(0) => break, + Ok(0) => break 'packet_loop, Ok(_) => (), + Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, Err(error) => panic!("ramfs: failed to read from socket: {:?}", error), } + scheme.handle(&mut packet); match socket.write(&packet) { - Ok(0) => break, Ok(_) => (), + Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, Err(error) => panic!("ramfs: failed to write to socket: {:?}", error), } } diff --git a/src/scheme.rs b/src/scheme.rs index 655ed207e7..7f17cfcb58 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -1,14 +1,14 @@ use std::collections::BTreeMap; use std::convert::{TryFrom, TryInto}; use std::os::unix::io::AsRawFd; -use std::{cmp, ops, time}; +use std::{cmp, ops}; use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; -use syscall::flag::{O_CREAT, O_EXCL, O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; -use syscall::{MODE_DIR, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; -use syscall::error::{EACCES, EBADF, EBADFD, EEXIST, EFBIG, EINVAL, EISDIR, EIO, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOPNOTSUPP, EOVERFLOW}; +use syscall::flag::{O_ACCMODE, O_CREAT, O_EXCL, O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; +use syscall::{MODE_FILE, MODE_DIR, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; +use syscall::error::{EACCES, EBADF, EBADFD, EEXIST, EINVAL, EISDIR, EIO, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW}; -use crate::filesystem::{DirEntry, File, FileData, Filesystem}; +use crate::filesystem::{self, DirEntry, File, FileData, Filesystem}; #[derive(Clone)] struct Handle { @@ -44,10 +44,11 @@ impl Scheme { pub fn remove_dentry(&mut self, path: &[u8], uid: u32, gid: u32, directory: bool) -> Result { let removed_entry = { let (parent_dir_inode, name_to_delete) = self.filesystem.resolve_except_last(path, uid, gid)?; + let name_to_delete = name_to_delete.ok_or(Error::new(EINVAL))?; // can't remove root let parent = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; let mode = current_perm(parent, uid, gid); - if mode & 0o2 != 0 { + if mode & 0o2 == 0 { return Err(Error::new(EACCES)); } @@ -89,43 +90,27 @@ impl Scheme { } } -pub fn current_time() -> TimeSpec { - let sys_time = time::SystemTime::now(); - - let duration = match sys_time.duration_since(time::SystemTime::UNIX_EPOCH) { - Ok(d) => d, - Err(e) => { - eprintln!("Apparently the signed 32-bit integer has overflowed; the time is now before the Unix epoch..."); - - let negative_duration = e.duration(); - - return TimeSpec { - tv_sec: negative_duration.as_secs().try_into().unwrap_or(i64::min_value()), - tv_nsec: negative_duration.subsec_nanos().try_into().unwrap_or(i32::min_value()), - }; - } - }; - - TimeSpec { - tv_sec: duration.as_secs().try_into().unwrap_or(i64::max_value()), - tv_nsec: duration.subsec_nanos().try_into().unwrap_or(i32::max_value()), - } -} - impl SchemeMut for Scheme { fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { let handle = if flags & O_CREAT != 0 { if flags & O_EXCL != 0 && self.filesystem.resolve(path, 0, 0).is_ok() { - return Err(Error::new(EEXIST)) + return Err(Error::new(EEXIST)); } if flags & O_STAT != 0 { return Err(Error::new(EINVAL)) } let (parent_dir_inode, new_name) = self.filesystem.resolve_except_last(path, uid, gid)?; + let new_name = new_name.ok_or(Error::new(EINVAL))?; // cannot mkdir / - let current_time = current_time(); + let current_time = filesystem::current_time(); let new_inode_number = self.filesystem.next_inode_number()?; + + let mut mode = (flags & 0xFFFF) as u16; + let new_inode = if flags & O_DIRECTORY != 0 { + if mode & MODE_TYPE == 0 { mode |= MODE_DIR } + if mode & MODE_TYPE != MODE_DIR { return Err(Error::new(EINVAL)) } + File { atime: current_time, crtime: current_time, @@ -134,12 +119,15 @@ impl SchemeMut for Scheme { gid, uid, ino: new_inode_number, - mode: 0o755, + mode, nlink: 2, // parent entry, "." data: FileData::Directory(Vec::new()), open_handles: 1, } } else { + if mode & MODE_TYPE == 0 { mode |= MODE_FILE } + if mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EINVAL)) } + File { atime: current_time, crtime: current_time, @@ -148,7 +136,7 @@ impl SchemeMut for Scheme { gid, uid, ino: new_inode_number, - mode: 0o644, + mode, nlink: 1, data: FileData::File(Vec::new()), open_handles: 1, @@ -168,14 +156,13 @@ impl SchemeMut for Scheme { Handle { inode: new_inode_number, offset: 0, - opened_as_read: flags & O_RDWR == O_RDONLY || flags & O_RDWR == O_RDWR, - opened_as_write: flags & O_RDWR == O_WRONLY || flags & O_RDWR == O_RDWR, + opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, + opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, current_perm, } } else { let inode = self.filesystem.resolve(path, uid, gid)?; - let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(ENOENT))?; - + let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(EIO))?; if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(ENOTDIR)); } @@ -195,8 +182,8 @@ impl SchemeMut for Scheme { Handle { inode, offset: 0, - opened_as_read: flags & O_RDWR == O_RDONLY || flags & O_RDWR == O_RDWR, - opened_as_write: flags & O_RDWR == O_WRONLY || flags & O_RDWR == O_RDWR, + opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, + opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, current_perm, } }; @@ -212,13 +199,15 @@ impl SchemeMut for Scheme { let inode_num = self.filesystem.resolve(path, uid, gid)?; let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; + let cur_mode = inode.mode & MODE_TYPE; + if inode.uid != uid && uid != 0 { return Err(Error::new(EACCES)); } if mode & MODE_TYPE != 0 { return Err(Error::new(EINVAL)); } - inode.mode = mode; + inode.mode = mode | cur_mode; Ok(0) } fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { @@ -251,6 +240,7 @@ impl SchemeMut for Scheme { } let bytes_to_read = cmp::min(bytes.len(), buf.len() + handle.offset) - handle.offset; buf[..bytes_to_read].copy_from_slice(&bytes[handle.offset..handle.offset + bytes_to_read]); + handle.offset += bytes_to_read; Ok(bytes_to_read) } FileData::Directory(ref entries) => { @@ -269,14 +259,16 @@ impl SchemeMut for Scheme { continue; } - let bytes_to_read = cmp::min(entry_bytes.len() - bytes_to_skip, bytes_left_to_read); + let bytes_to_read = cmp::min(entry_bytes.len() + 1 - bytes_to_skip, bytes_left_to_read); - let entry_bytes = &entry_bytes[bytes_to_skip..bytes_to_skip + bytes_to_read]; + let entry_bytes = &entry_bytes[bytes_to_skip..bytes_to_skip + bytes_to_read - 1]; bytes_to_skip -= bytes_to_skip; - buf[handle.offset..handle.offset + bytes_to_read].copy_from_slice(&entry_bytes[..bytes_to_read]); + buf[bytes_read..bytes_read + bytes_to_read - 1].copy_from_slice(&entry_bytes[..bytes_to_read - 1]); + buf[bytes_read + bytes_to_read - 1] = b'\n'; bytes_left_to_read -= bytes_to_read; bytes_read += bytes_to_read; + handle.offset += bytes_read; } Ok(bytes_read) } @@ -308,6 +300,7 @@ impl SchemeMut for Scheme { // cast to isize, possibly making the offset negative let pos = pos as isize; + let old = handle.offset; handle.offset = match whence { SEEK_SET => cmp::max(0, pos) as usize, SEEK_CUR => cmp::max(0, pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?) as usize, @@ -320,11 +313,13 @@ impl SchemeMut for Scheme { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let cur_type = file.mode & MODE_TYPE; + if mode & MODE_TYPE != 0 { return Err(Error::new(EINVAL)); } - file.mode = mode; + file.mode = mode | cur_type; Ok(0) } @@ -379,6 +374,8 @@ impl SchemeMut for Scheme { let block_size = self.filesystem.block_size(); let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let size = file.data.size().try_into().or(Err(Error::new(EOVERFLOW)))?; + *stat = Stat { st_mode: file.mode, st_uid: file.uid, @@ -387,9 +384,9 @@ impl SchemeMut for Scheme { st_nlink: file.nlink.try_into().or(Err(Error::new(EOVERFLOW)))?, st_dev: 0, - st_size: file.data.size().try_into().or(Err(Error::new(EOVERFLOW)))?, + st_size: size, st_blksize: block_size, - st_blocks: div_round_up(stat.st_size, u64::from(stat.st_blksize)), + st_blocks: div_round_up(size, u64::from(block_size)), st_atime: file.atime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, st_atime_nsec: file.atime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, @@ -483,11 +480,11 @@ pub fn current_perm(file: &crate::filesystem::File, uid: u32, gid: u32) -> u8 { } } fn check_permissions(flags: usize, single_mode: u8) -> Result<()> { - if flags & O_RDWR == O_RDONLY && single_mode & 0o4 == 0 { + if flags & O_ACCMODE == O_RDONLY && single_mode & 0o4 == 0 { return Err(Error::new(EACCES)); - } else if flags & O_RDWR == O_WRONLY && single_mode & 0o2 == 0 { + } else if flags & O_ACCMODE == O_WRONLY && single_mode & 0o2 == 0 { return Err(Error::new(EACCES)); - } else if flags & O_RDWR == O_RDWR && single_mode & 0o6 != 0o6 { + } else if flags & O_ACCMODE == O_RDWR && single_mode & 0o6 != 0o6 { return Err(Error::new(EACCES)); } Ok(()) From ec847e309dfda3426a9b6292bac9ceaf18bc712e Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 18 Jun 2020 10:30:23 +0200 Subject: [PATCH 05/30] Remove all dbg! statements. --- src/filesystem.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/filesystem.rs b/src/filesystem.rs index 6a776f3906..eda69381f2 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -112,7 +112,6 @@ impl Filesystem { } fn resolve_generic(&self, mut parts: Vec<&[u8]>, uid: u32, gid: u32) -> Result { let mut current_file = self.files.get(&Self::ROOT_INODE).ok_or(Error::new(ENOENT))?; - dbg!(); let mut current_inode = Self::ROOT_INODE; let mut i = 0; @@ -122,7 +121,6 @@ impl Filesystem { Some(p) => p, None => break, }; - dbg!(current_inode, part); let dentries = match current_file.data { FileData::Directory(ref dentries) => dentries, FileData::File(_) => return Err(Error::new(ENOENT)), From 4343ac6b5491f479067d94255fc3555fd9d0b924 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Sun, 2 Aug 2020 15:31:42 -0600 Subject: [PATCH 06/30] Update to newer syscall --- Cargo.lock | 5 +++-- Cargo.toml | 2 +- src/scheme.rs | 15 ++++++--------- 3 files changed, 10 insertions(+), 12 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index da530d426e..72c0886741 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -15,8 +15,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.1.56" -source = "git+https://gitlab.redox-os.org/redox-os/syscall.git#8d0015be8693a81c2a4459f3c09fb47b98ff07b1" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bac5c4ce99d34f37ce30e45606946fcd6331223f1c98af4d29c5b6c4977d675b" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index af4002d300..8bc887c896 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,4 +7,4 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git" } +redox_syscall = "0.2" diff --git a/src/scheme.rs b/src/scheme.rs index 7f17cfcb58..972b5ba786 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -293,21 +293,18 @@ impl SchemeMut for Scheme { Err(Error::new(EISDIR)) } } - fn seek(&mut self, fd: usize, pos: usize, whence: usize) -> Result { + fn seek(&mut self, fd: usize, pos: isize, whence: usize) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; - // cast to isize, possibly making the offset negative - let pos = pos as isize; - let old = handle.offset; handle.offset = match whence { - SEEK_SET => cmp::max(0, pos) as usize, - SEEK_CUR => cmp::max(0, pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?) as usize, - SEEK_END => cmp::max(0, pos + isize::try_from(file.data.size()).or(Err(Error::new(EOVERFLOW)))?) as usize, + SEEK_SET => cmp::max(0, pos), + SEEK_CUR => cmp::max(0, pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?), + SEEK_END => cmp::max(0, pos + isize::try_from(file.data.size()).or(Err(Error::new(EOVERFLOW)))?), _ => return Err(Error::new(EINVAL)), - }; - Ok(handle.offset) + } as usize; + Ok(handle.offset as isize) } fn fchmod(&mut self, fd: usize, mode: u16) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; From c177f71b21631731badd97d9728955dd4ccef48a Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Fri, 15 Jan 2021 13:00:21 -0700 Subject: [PATCH 07/30] Update redox_syscall --- Cargo.lock | 4 ++-- Cargo.toml | 2 +- src/scheme.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 72c0886741..7d1abdf502 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -15,9 +15,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.0" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bac5c4ce99d34f37ce30e45606946fcd6331223f1c98af4d29c5b6c4977d675b" +checksum = "05ec8ca9416c5ea37062b502703cd7fcb207736bc294f6e0cf367ac6fc234570" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index 8bc887c896..5a0f8f7e33 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,4 +7,4 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox_syscall = "0.2" +redox_syscall = "0.2.4" diff --git a/src/scheme.rs b/src/scheme.rs index 972b5ba786..75f6676c91 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -348,7 +348,7 @@ impl SchemeMut for Scheme { // TODO Err(Error::new(ENOSYS)) } - fn funmap(&mut self, _address: usize) -> Result { + fn funmap(&mut self, _address: usize, _len: usize) -> Result { // TODO Err(Error::new(ENOSYS)) } From 4523d80c24bc6e86dde751159af5fd113b0d7313 Mon Sep 17 00:00:00 2001 From: Joshua Abraham Date: Mon, 29 Mar 2021 20:38:52 -0500 Subject: [PATCH 08/30] ramfs: SchemeMut: return ENOENT in filesystem calls when file does not exist --- src/scheme.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scheme.rs b/src/scheme.rs index 75f6676c91..d1defe2537 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -147,7 +147,7 @@ impl SchemeMut for Scheme { self.filesystem.files.insert(new_inode_number, new_inode); - let parent_file = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + let parent_file = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(ENOENT))?; match parent_file.data { FileData::File(_) => return Err(Error::new(EIO)), FileData::Directory(ref mut entries) => entries.push(DirEntry { name: new_name.to_owned(), inode: new_inode_number }), @@ -162,7 +162,7 @@ impl SchemeMut for Scheme { } } else { let inode = self.filesystem.resolve(path, uid, gid)?; - let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(EIO))?; + let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(ENOENT))?; if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(ENOTDIR)); } @@ -197,7 +197,7 @@ impl SchemeMut for Scheme { } fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { let inode_num = self.filesystem.resolve(path, uid, gid)?; - let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; + let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(ENOENT))?; let cur_mode = inode.mode & MODE_TYPE; From 737a41854d2001d4dcdf6b59656da5a7913b750b Mon Sep 17 00:00:00 2001 From: James Graves Date: Tue, 30 Mar 2021 09:16:06 +0000 Subject: [PATCH 09/30] Fix missing 'use ENOENT' --- src/scheme.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scheme.rs b/src/scheme.rs index d1defe2537..4cada7effd 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -6,7 +6,7 @@ use std::{cmp, ops}; use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; use syscall::flag::{O_ACCMODE, O_CREAT, O_EXCL, O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; use syscall::{MODE_FILE, MODE_DIR, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; -use syscall::error::{EACCES, EBADF, EBADFD, EEXIST, EINVAL, EISDIR, EIO, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW}; +use syscall::error::{EACCES, EBADF, EBADFD, EEXIST, EINVAL, EISDIR, EIO, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW}; use crate::filesystem::{self, DirEntry, File, FileData, Filesystem}; From a4fdf5ea300cabb74a3a494d7d6ef5b7afff9126 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Tue, 30 Mar 2021 12:41:40 +0000 Subject: [PATCH 10/30] Revert "Merge branch 'ramfs-nofile' into 'master'" This reverts merge request !1 --- src/scheme.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scheme.rs b/src/scheme.rs index 4cada7effd..13bc4b512a 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -147,7 +147,7 @@ impl SchemeMut for Scheme { self.filesystem.files.insert(new_inode_number, new_inode); - let parent_file = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(ENOENT))?; + let parent_file = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; match parent_file.data { FileData::File(_) => return Err(Error::new(EIO)), FileData::Directory(ref mut entries) => entries.push(DirEntry { name: new_name.to_owned(), inode: new_inode_number }), @@ -162,7 +162,7 @@ impl SchemeMut for Scheme { } } else { let inode = self.filesystem.resolve(path, uid, gid)?; - let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(ENOENT))?; + let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(EIO))?; if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(ENOTDIR)); } @@ -197,7 +197,7 @@ impl SchemeMut for Scheme { } fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { let inode_num = self.filesystem.resolve(path, uid, gid)?; - let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(ENOENT))?; + let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; let cur_mode = inode.mode & MODE_TYPE; From 70e52d4ec9fc252990a79226dae2b275b24a4c9a Mon Sep 17 00:00:00 2001 From: Joshua Abraham Date: Wed, 31 Mar 2021 19:16:32 -0500 Subject: [PATCH 11/30] ramfs: Fix duplicated files bug Previously ramfs allowed identical filenames to be created if the O_CREAT flag was used. This patch fixes the behavior and instead opens the existing file as long as O_EXCL is not specified. --- src/scheme.rs | 68 +++++++++++++++++++++++++++++---------------------- 1 file changed, 39 insertions(+), 29 deletions(-) diff --git a/src/scheme.rs b/src/scheme.rs index 13bc4b512a..722da6a467 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -88,14 +88,48 @@ impl Scheme { Ok(0) } + + pub fn open_existing(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { + let inode = self.filesystem.resolve(path, uid, gid)?; + let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(EIO))?; + if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { + return Err(Error::new(ENOTDIR)); + } + // Unlike on Linux, which allows directories to be opened without O_DIRECTORY, Redox has no + // getdents(2) syscall, and thus it adds the additional restriction that directories have + // to be opened with O_DIRECTORY, if they aren't opened with O_STAT to check whether it's a + // directory. + if flags & O_STAT == 0 && flags & O_DIRECTORY == 0 && file.mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EISDIR)); + } + + let current_perm = current_perm(file, uid, gid); + check_permissions(flags, current_perm)?; + + file.open_handles += 1; + + Ok(Handle { + inode, + offset: 0, + opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, + opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, + current_perm, + }) + } } impl SchemeMut for Scheme { fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { - let handle = if flags & O_CREAT != 0 { - if flags & O_EXCL != 0 && self.filesystem.resolve(path, 0, 0).is_ok() { - return Err(Error::new(EEXIST)); - } + let exists = self.filesystem.resolve(path, 0, 0).is_ok(); + if flags & O_CREAT != 0 && flags & O_EXCL != 0 && exists { + return Err(Error::new(EEXIST)); + } + + let handle = + if flags & O_CREAT != 0 && exists { + self.open_existing(path, flags, uid, gid)? + } else if flags & O_CREAT != 0 { + if flags & O_STAT != 0 { return Err(Error::new(EINVAL)) } let (parent_dir_inode, new_name) = self.filesystem.resolve_except_last(path, uid, gid)?; @@ -161,31 +195,7 @@ impl SchemeMut for Scheme { current_perm, } } else { - let inode = self.filesystem.resolve(path, uid, gid)?; - let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(EIO))?; - if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { - return Err(Error::new(ENOTDIR)); - } - // Unlike on Linux, which allows directories to be opened without O_DIRECTORY, Redox has no - // getdents(2) syscall, and thus it adds the additional restriction that directories have - // to be opened with O_DIRECTORY, if they aren't opened with O_STAT to check whether it's a - // directory. - if flags & O_STAT == 0 && flags & O_DIRECTORY == 0 && file.mode & MODE_TYPE == MODE_DIR { - return Err(Error::new(EISDIR)); - } - - let current_perm = current_perm(file, uid, gid); - check_permissions(flags, current_perm)?; - - file.open_handles += 1; - - Handle { - inode, - offset: 0, - opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, - opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, - current_perm, - } + self.open_existing(path, flags, uid, gid)? }; let fd = self.next_fd; From eaf78bb51b0482ad0c5ac1eaa2e23dc0e27d7795 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 1 Apr 2021 09:46:17 +0200 Subject: [PATCH 12/30] Run rustfmt. In the future we should add CI with a rustfmt check, making correct formatting a hard requirement. --- src/filesystem.rs | 55 ++++++--- src/main.rs | 3 +- src/scheme.rs | 288 +++++++++++++++++++++++++++++++++++----------- 3 files changed, 266 insertions(+), 80 deletions(-) diff --git a/src/filesystem.rs b/src/filesystem.rs index eda69381f2..eb60779e71 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -1,14 +1,14 @@ use std::collections::BTreeMap; use std::convert::TryInto; use std::ffi::OsStr; -use std::{iter, fs, time}; +use std::{fs, iter, time}; -use std::os::unix::io::AsRawFd; use std::os::unix::ffi::OsStrExt; +use std::os::unix::io::AsRawFd; -use syscall::{Error, Result, StatVfs, TimeSpec, MODE_DIR}; use syscall::error::{EACCES, EIO, ENFILE, ENOENT}; use syscall::flag::{O_RDONLY, O_STAT}; +use syscall::{Error, Result, StatVfs, TimeSpec, MODE_DIR}; use super::scheme::current_perm; @@ -106,12 +106,18 @@ impl Filesystem { self.get_block_size().unwrap_or(Self::DEFAULT_BLOCK_SIZE) } pub fn next_inode_number(&mut self) -> Result { - let next = self.last_inode_number.checked_add(1).ok_or(Error::new(ENFILE))?; + let next = self + .last_inode_number + .checked_add(1) + .ok_or(Error::new(ENFILE))?; self.last_inode_number = next; Ok(next) } fn resolve_generic(&self, mut parts: Vec<&[u8]>, uid: u32, gid: u32) -> Result { - let mut current_file = self.files.get(&Self::ROOT_INODE).ok_or(Error::new(ENOENT))?; + let mut current_file = self + .files + .get(&Self::ROOT_INODE) + .ok_or(Error::new(ENOENT))?; let mut current_inode = Self::ROOT_INODE; let mut i = 0; @@ -126,7 +132,9 @@ impl Filesystem { FileData::File(_) => return Err(Error::new(ENOENT)), }; let perm = current_perm(¤t_file, uid, gid); - if perm & 0o1 == 0 { return Err(Error::new(EACCES)) } + if perm & 0o1 == 0 { + return Err(Error::new(EACCES)); + } if part == b"." || part == b".." { parts.remove(i); @@ -141,7 +149,10 @@ impl Filesystem { } let part = parts.get(i).unwrap(); - let entry = dentries.iter().find(|dentry| &dentry.name == part).ok_or(Error::new(ENOENT))?; + let entry = dentries + .iter() + .find(|dentry| &dentry.name == part) + .ok_or(Error::new(ENOENT))?; current_file = self.files.get(&entry.inode).ok_or(Error::new(EIO))?; current_inode = entry.inode; @@ -149,8 +160,15 @@ impl Filesystem { } Ok(current_inode) } - pub fn resolve_except_last<'a>(&self, mut path_bytes: &'a [u8], uid: u32, gid: u32) -> Result<(usize, Option<&'a [u8]>)> { - if path_bytes.first() == Some(&b'/') { path_bytes = &path_bytes[1..] } + pub fn resolve_except_last<'a>( + &self, + mut path_bytes: &'a [u8], + uid: u32, + gid: u32, + ) -> Result<(usize, Option<&'a [u8]>)> { + if path_bytes.first() == Some(&b'/') { + path_bytes = &path_bytes[1..] + } let mut parts = path_components_iter(path_bytes).collect::>(); let last = if parts.len() >= 1 { @@ -162,7 +180,9 @@ impl Filesystem { Ok((self.resolve_generic(parts, uid, gid)?, last)) } pub fn resolve(&self, mut path_bytes: &[u8], uid: u32, gid: u32) -> Result { - if path_bytes.first() == Some(&b'/') { path_bytes = &path_bytes[1..] } + if path_bytes.first() == Some(&b'/') { + path_bytes = &path_bytes[1..] + } let parts = path_components_iter(path_bytes).collect::>(); self.resolve_generic(parts, uid, gid) @@ -183,14 +203,23 @@ pub fn current_time() -> TimeSpec { let negative_duration = e.duration(); return TimeSpec { - tv_sec: negative_duration.as_secs().try_into().unwrap_or(i64::min_value()), - tv_nsec: negative_duration.subsec_nanos().try_into().unwrap_or(i32::min_value()), + tv_sec: negative_duration + .as_secs() + .try_into() + .unwrap_or(i64::min_value()), + tv_nsec: negative_duration + .subsec_nanos() + .try_into() + .unwrap_or(i32::min_value()), }; } }; TimeSpec { tv_sec: duration.as_secs().try_into().unwrap_or(i64::max_value()), - tv_nsec: duration.subsec_nanos().try_into().unwrap_or(i32::max_value()), + tv_nsec: duration + .subsec_nanos() + .try_into() + .unwrap_or(i32::max_value()), } } diff --git a/src/main.rs b/src/main.rs index dc73ff138c..308cf6b538 100644 --- a/src/main.rs +++ b/src/main.rs @@ -18,7 +18,8 @@ fn main() { return; } - let mut socket = File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); + let mut socket = + File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); 'packet_loop: loop { diff --git a/src/scheme.rs b/src/scheme.rs index 722da6a467..2b4e480ee1 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -3,10 +3,13 @@ use std::convert::{TryFrom, TryInto}; use std::os::unix::io::AsRawFd; use std::{cmp, ops}; +use syscall::error::{ + EACCES, EBADF, EBADFD, EEXIST, EINVAL, EIO, EISDIR, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, + EOVERFLOW, +}; +use syscall::flag::{O_ACCMODE, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY, O_RDWR, O_STAT, O_WRONLY}; use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; -use syscall::flag::{O_ACCMODE, O_CREAT, O_EXCL, O_RDWR, O_RDONLY, O_WRONLY, O_DIRECTORY, O_STAT}; -use syscall::{MODE_FILE, MODE_DIR, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; -use syscall::error::{EACCES, EBADF, EBADFD, EEXIST, EINVAL, EISDIR, EIO, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW}; +use syscall::{MODE_DIR, MODE_FILE, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; use crate::filesystem::{self, DirEntry, File, FileData, Filesystem}; @@ -15,7 +18,7 @@ struct Handle { inode: usize, offset: usize, - opened_as_read: bool, // opened with O_RDONLY or O_RDWR + opened_as_read: bool, // opened with O_RDONLY or O_RDWR opened_as_write: bool, // opened with O_WRONLY or O_RDWR // the three first bits of mode >> 6 if uid matched, mode >> 3 if gid matched, otherwise mode @@ -41,11 +44,22 @@ impl Scheme { } /// Remove a directory entry, where the entry can be both a file or a directory. Used by both /// `unlink` and `rmdir`. - pub fn remove_dentry(&mut self, path: &[u8], uid: u32, gid: u32, directory: bool) -> Result { + pub fn remove_dentry( + &mut self, + path: &[u8], + uid: u32, + gid: u32, + directory: bool, + ) -> Result { let removed_entry = { - let (parent_dir_inode, name_to_delete) = self.filesystem.resolve_except_last(path, uid, gid)?; + let (parent_dir_inode, name_to_delete) = + self.filesystem.resolve_except_last(path, uid, gid)?; let name_to_delete = name_to_delete.ok_or(Error::new(EINVAL))?; // can't remove root - let parent = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + let parent = self + .filesystem + .files + .get_mut(&parent_dir_inode) + .ok_or(Error::new(EIO))?; let mode = current_perm(parent, uid, gid); if mode & 0o2 == 0 { @@ -54,31 +68,51 @@ impl Scheme { let dentries = parent.data.as_directory_mut().ok_or(Error::new(EBADF))?; - let (position, entry_inode) = dentries.iter().enumerate().find(|(_, d)| d.name == name_to_delete).unwrap(); + let (position, entry_inode) = dentries + .iter() + .enumerate() + .find(|(_, d)| d.name == name_to_delete) + .unwrap(); let entry_inode = entry_inode.inode; let removed_entry = dentries.remove(position); - if let Some(File { data: FileData::Directory(ref data), .. }) = self.filesystem.files.get(&entry_inode) { + if let Some(File { + data: FileData::Directory(ref data), + .. + }) = self.filesystem.files.get(&entry_inode) + { if !directory { return Err(Error::new(EISDIR)); } else if !data.is_empty() { return Err(Error::new(ENOTEMPTY)); } - let parent = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + let parent = self + .filesystem + .files + .get_mut(&parent_dir_inode) + .ok_or(Error::new(EIO))?; parent.nlink -= 1; // '..' of subdirectory } removed_entry }; - let removed_inode = self.filesystem.files.get_mut(&removed_entry.inode).ok_or(Error::new(EIO))?; + let removed_inode = self + .filesystem + .files + .get_mut(&removed_entry.inode) + .ok_or(Error::new(EIO))?; if let FileData::File(_) = removed_inode.data { - if directory { return Err(Error::new(EISDIR)) } + if directory { + return Err(Error::new(EISDIR)); + } removed_inode.nlink -= 1; // only the parent entry } else { - if !directory { return Err(Error::new(ENOTDIR)) } + if !directory { + return Err(Error::new(ENOTDIR)); + } removed_inode.nlink -= 2; // both the parent entry and '.' } @@ -89,9 +123,19 @@ impl Scheme { Ok(0) } - pub fn open_existing(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { + pub fn open_existing( + &mut self, + path: &[u8], + flags: usize, + uid: u32, + gid: u32, + ) -> Result { let inode = self.filesystem.resolve(path, uid, gid)?; - let file = self.filesystem.files.get_mut(&inode).ok_or(Error::new(EIO))?; + let file = self + .filesystem + .files + .get_mut(&inode) + .ok_or(Error::new(EIO))?; if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(ENOTDIR)); } @@ -125,14 +169,15 @@ impl SchemeMut for Scheme { return Err(Error::new(EEXIST)); } - let handle = - if flags & O_CREAT != 0 && exists { - self.open_existing(path, flags, uid, gid)? - } else if flags & O_CREAT != 0 { + let handle = if flags & O_CREAT != 0 && exists { + self.open_existing(path, flags, uid, gid)? + } else if flags & O_CREAT != 0 { + if flags & O_STAT != 0 { + return Err(Error::new(EINVAL)); + } - if flags & O_STAT != 0 { return Err(Error::new(EINVAL)) } - - let (parent_dir_inode, new_name) = self.filesystem.resolve_except_last(path, uid, gid)?; + let (parent_dir_inode, new_name) = + self.filesystem.resolve_except_last(path, uid, gid)?; let new_name = new_name.ok_or(Error::new(EINVAL))?; // cannot mkdir / let current_time = filesystem::current_time(); @@ -142,8 +187,12 @@ impl SchemeMut for Scheme { let mut mode = (flags & 0xFFFF) as u16; let new_inode = if flags & O_DIRECTORY != 0 { - if mode & MODE_TYPE == 0 { mode |= MODE_DIR } - if mode & MODE_TYPE != MODE_DIR { return Err(Error::new(EINVAL)) } + if mode & MODE_TYPE == 0 { + mode |= MODE_DIR + } + if mode & MODE_TYPE != MODE_DIR { + return Err(Error::new(EINVAL)); + } File { atime: current_time, @@ -159,8 +208,12 @@ impl SchemeMut for Scheme { open_handles: 1, } } else { - if mode & MODE_TYPE == 0 { mode |= MODE_FILE } - if mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EINVAL)) } + if mode & MODE_TYPE == 0 { + mode |= MODE_FILE + } + if mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EINVAL)); + } File { atime: current_time, @@ -181,10 +234,17 @@ impl SchemeMut for Scheme { self.filesystem.files.insert(new_inode_number, new_inode); - let parent_file = self.filesystem.files.get_mut(&parent_dir_inode).ok_or(Error::new(EIO))?; + let parent_file = self + .filesystem + .files + .get_mut(&parent_dir_inode) + .ok_or(Error::new(EIO))?; match parent_file.data { FileData::File(_) => return Err(Error::new(EIO)), - FileData::Directory(ref mut entries) => entries.push(DirEntry { name: new_name.to_owned(), inode: new_inode_number }), + FileData::Directory(ref mut entries) => entries.push(DirEntry { + name: new_name.to_owned(), + inode: new_inode_number, + }), } Handle { @@ -207,7 +267,11 @@ impl SchemeMut for Scheme { } fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { let inode_num = self.filesystem.resolve(path, uid, gid)?; - let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; + let inode = self + .filesystem + .files + .get_mut(&inode_num) + .ok_or(Error::new(EIO))?; let cur_mode = inode.mode & MODE_TYPE; @@ -227,7 +291,11 @@ impl SchemeMut for Scheme { self.remove_dentry(path, uid, gid, false) } fn dup(&mut self, old_fd: usize, _buf: &[u8]) -> Result { - let handle = self.handles.get_mut(&old_fd).ok_or(Error::new(EBADF))?.clone(); + let handle = self + .handles + .get_mut(&old_fd) + .ok_or(Error::new(EBADF))? + .clone(); let fd = self.next_fd; self.next_fd += 1; @@ -237,44 +305,64 @@ impl SchemeMut for Scheme { } fn read(&mut self, fd: usize, buf: &mut [u8]) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; - if !handle.opened_as_read { return Err(Error::new(EBADF)) } + if !handle.opened_as_read { + return Err(Error::new(EBADF)); + } match file.data { FileData::File(ref bytes) => { - if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EBADFD)) } + if file.mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EBADFD)); + } if handle.offset >= bytes.len() { return Ok(0); } - let bytes_to_read = cmp::min(bytes.len(), buf.len() + handle.offset) - handle.offset; - buf[..bytes_to_read].copy_from_slice(&bytes[handle.offset..handle.offset + bytes_to_read]); + let bytes_to_read = + cmp::min(bytes.len(), buf.len() + handle.offset) - handle.offset; + buf[..bytes_to_read] + .copy_from_slice(&bytes[handle.offset..handle.offset + bytes_to_read]); handle.offset += bytes_to_read; Ok(bytes_to_read) } FileData::Directory(ref entries) => { - if file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(EBADFD)) } + if file.mode & MODE_TYPE != MODE_DIR { + return Err(Error::new(EBADFD)); + } // directories require the execute permission to be listed - if handle.current_perm & 0o1 == 0 { return Err(Error::new(EBADF)) } + if handle.current_perm & 0o1 == 0 { + return Err(Error::new(EBADF)); + } let mut bytes_to_skip = handle.offset; let mut bytes_left_to_read = buf.len(); let mut bytes_read = 0; - for DirEntry { name: entry_bytes, .. } in entries { + for DirEntry { + name: entry_bytes, .. + } in entries + { // skip the whole entry if it fits if bytes_to_skip >= entry_bytes.len() { bytes_to_skip -= entry_bytes.len(); continue; } - let bytes_to_read = cmp::min(entry_bytes.len() + 1 - bytes_to_skip, bytes_left_to_read); + let bytes_to_read = + cmp::min(entry_bytes.len() + 1 - bytes_to_skip, bytes_left_to_read); - let entry_bytes = &entry_bytes[bytes_to_skip..bytes_to_skip + bytes_to_read - 1]; + let entry_bytes = + &entry_bytes[bytes_to_skip..bytes_to_skip + bytes_to_read - 1]; bytes_to_skip -= bytes_to_skip; - buf[bytes_read..bytes_read + bytes_to_read - 1].copy_from_slice(&entry_bytes[..bytes_to_read - 1]); + buf[bytes_read..bytes_read + bytes_to_read - 1] + .copy_from_slice(&entry_bytes[..bytes_to_read - 1]); buf[bytes_read + bytes_to_read - 1] = b'\n'; bytes_left_to_read -= bytes_to_read; bytes_read += bytes_to_read; @@ -286,10 +374,16 @@ impl SchemeMut for Scheme { } fn write(&mut self, fd: usize, buf: &[u8]) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; if let &mut FileData::File(ref mut bytes) = &mut file.data { - if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EBADFD)) } + if file.mode & MODE_TYPE == MODE_DIR { + return Err(Error::new(EBADFD)); + } // if there's a seek hole, fill it with 0 and continue writing. if handle.offset > bytes.len() { @@ -305,20 +399,34 @@ impl SchemeMut for Scheme { } fn seek(&mut self, fd: usize, pos: isize, whence: usize) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; let old = handle.offset; handle.offset = match whence { SEEK_SET => cmp::max(0, pos), - SEEK_CUR => cmp::max(0, pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?), - SEEK_END => cmp::max(0, pos + isize::try_from(file.data.size()).or(Err(Error::new(EOVERFLOW)))?), + SEEK_CUR => cmp::max( + 0, + pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?, + ), + SEEK_END => cmp::max( + 0, + pos + isize::try_from(file.data.size()).or(Err(Error::new(EOVERFLOW)))?, + ), _ => return Err(Error::new(EINVAL)), } as usize; Ok(handle.offset as isize) } fn fchmod(&mut self, fd: usize, mode: u16) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; let cur_type = file.mode & MODE_TYPE; @@ -332,7 +440,11 @@ impl SchemeMut for Scheme { } fn fchown(&mut self, fd: usize, uid: u32, gid: u32) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; file.uid = uid; file.gid = gid; @@ -340,19 +452,19 @@ impl SchemeMut for Scheme { Ok(0) } fn fcntl(&mut self, fd: usize, _cmd: usize, _arg: usize) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } Ok(0) } fn fevent(&mut self, fd: usize, _flags: EventFlags) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } Err(Error::new(ENOSYS)) } fn fmap(&mut self, fd: usize, _map: &Map) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } // TODO @@ -363,14 +475,14 @@ impl SchemeMut for Scheme { Err(Error::new(ENOSYS)) } fn fpath(&mut self, fd: usize, buf: &mut [u8]) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } // TODO Err(Error::new(ENOSYS)) } fn frename(&mut self, fd: usize, path: &[u8], uid: u32, gid: u32) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } // TODO @@ -379,7 +491,11 @@ impl SchemeMut for Scheme { fn fstat(&mut self, fd: usize, stat: &mut Stat) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; let block_size = self.filesystem.block_size(); - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; let size = file.data.size().try_into().or(Err(Error::new(EOVERFLOW)))?; @@ -395,20 +511,44 @@ impl SchemeMut for Scheme { st_blksize: block_size, st_blocks: div_round_up(size, u64::from(block_size)), - st_atime: file.atime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, - st_atime_nsec: file.atime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_atime: file + .atime + .tv_sec + .try_into() + .or(Err(Error::new(EOVERFLOW)))?, + st_atime_nsec: file + .atime + .tv_nsec + .try_into() + .or(Err(Error::new(EOVERFLOW)))?, - st_ctime: file.ctime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, - st_ctime_nsec: file.ctime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_ctime: file + .ctime + .tv_sec + .try_into() + .or(Err(Error::new(EOVERFLOW)))?, + st_ctime_nsec: file + .ctime + .tv_nsec + .try_into() + .or(Err(Error::new(EOVERFLOW)))?, - st_mtime: file.mtime.tv_sec.try_into().or(Err(Error::new(EOVERFLOW)))?, - st_mtime_nsec: file.mtime.tv_nsec.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_mtime: file + .mtime + .tv_sec + .try_into() + .or(Err(Error::new(EOVERFLOW)))?, + st_mtime_nsec: file + .mtime + .tv_nsec + .try_into() + .or(Err(Error::new(EOVERFLOW)))?, }; Ok(0) } fn fstatvfs(&mut self, fd: usize, stat: &mut StatVfs) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } syscall::fstatvfs(self.filesystem.memory_file.as_raw_fd() as usize, stat)?; @@ -416,14 +556,18 @@ impl SchemeMut for Scheme { Ok(0) } fn fsync(&mut self, fd: usize) -> Result { - if ! self.handles.contains_key(&fd) { + if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } Ok(0) } fn ftruncate(&mut self, fd: usize, size: usize) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EISDIR)); @@ -444,7 +588,11 @@ impl SchemeMut for Scheme { } fn futimens(&mut self, fd: usize, times: &[TimeSpec]) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self.filesystem.files.get_mut(&handle.inode).ok_or(Error::new(EBADFD))?; + let file = self + .filesystem + .files + .get_mut(&handle.inode) + .ok_or(Error::new(EBADFD))?; let new_atime = *times.get(0).ok_or(Error::new(EINVAL))?; let new_mtime = *times.get(1).ok_or(Error::new(EINVAL))?; @@ -456,7 +604,11 @@ impl SchemeMut for Scheme { } fn close(&mut self, fd: usize) -> Result { let inode_num = self.handles.remove(&fd).ok_or(Error::new(EBADF))?.inode; - let inode = self.filesystem.files.get_mut(&inode_num).ok_or(Error::new(EIO))?; + let inode = self + .filesystem + .files + .get_mut(&inode_num) + .ok_or(Error::new(EIO))?; inode.open_handles -= 1; @@ -468,7 +620,11 @@ impl SchemeMut for Scheme { } fn div_round_up(numer: T, denom: T) -> T where - T: Copy + ops::Add + ops::Sub + ops::Div + From, + T: Copy + + ops::Add + + ops::Sub + + ops::Div + + From, { (numer + (denom - T::from(1u8))) / denom } From 7206288e72a13c7180db0cd6a3bfa702bda140aa Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 1 Apr 2021 19:08:44 +0200 Subject: [PATCH 13/30] Handle O_TRUNC properly. This ensures that files that were replaced due to O_CREAT, will now be emptied when O_TRUNC is passed (which is the default). --- src/scheme.rs | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/src/scheme.rs b/src/scheme.rs index 2b4e480ee1..7dbc5ca956 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -7,7 +7,9 @@ use syscall::error::{ EACCES, EBADF, EBADFD, EEXIST, EINVAL, EIO, EISDIR, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW, }; -use syscall::flag::{O_ACCMODE, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY, O_RDWR, O_STAT, O_WRONLY}; +use syscall::flag::{ + O_ACCMODE, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY, O_RDWR, O_STAT, O_TRUNC, O_WRONLY, +}; use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; use syscall::{MODE_DIR, MODE_FILE, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; @@ -123,22 +125,18 @@ impl Scheme { Ok(0) } - pub fn open_existing( - &mut self, - path: &[u8], - flags: usize, - uid: u32, - gid: u32, - ) -> Result { + fn open_existing(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { let inode = self.filesystem.resolve(path, uid, gid)?; let file = self .filesystem .files .get_mut(&inode) .ok_or(Error::new(EIO))?; + if flags & O_STAT == 0 && flags & O_DIRECTORY != 0 && file.mode & MODE_TYPE != MODE_DIR { return Err(Error::new(ENOTDIR)); } + // Unlike on Linux, which allows directories to be opened without O_DIRECTORY, Redox has no // getdents(2) syscall, and thus it adds the additional restriction that directories have // to be opened with O_DIRECTORY, if they aren't opened with O_STAT to check whether it's a @@ -150,13 +148,26 @@ impl Scheme { let current_perm = current_perm(file, uid, gid); check_permissions(flags, current_perm)?; + let opened_as_read = flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR; + let opened_as_write = flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR; + + if flags & O_TRUNC == O_TRUNC && opened_as_write { + match file.data { + // file.data and file.mode should match + FileData::Directory(_) => return Err(Error::new(EBADFD)), + + // If we opened an existing file with O_CREAT and O_TRUNC + FileData::File(ref mut data) => data.clear(), + } + } + file.open_handles += 1; Ok(Handle { inode, offset: 0, - opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, - opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, + opened_as_read, + opened_as_write, current_perm, }) } From fd83cd3ac7bd6e00dec5984a773877c2bafb9be4 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 1 Apr 2021 19:11:37 +0200 Subject: [PATCH 14/30] Add license. --- Cargo.toml | 2 ++ LICENSE | 21 +++++++++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 LICENSE diff --git a/Cargo.toml b/Cargo.toml index 5a0f8f7e33..9e1671da11 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,8 @@ name = "ramfs" version = "0.1.0" authors = ["4lDO2 <4lDO2@protonmail.com>"] edition = "2018" +license = "MIT" +description = "In-memory filesystem for Redox, which is useful for early logging" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000..23382b1c1d --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-2021 4lDO2 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. From 0ed497fe23cd7864c11b50cf06d7eaed364a311c Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 17 Jun 2021 14:38:58 +0200 Subject: [PATCH 15/30] Update syscall. --- Cargo.lock | 4 ++-- Cargo.toml | 2 +- src/scheme.rs | 25 +++++++++++++------------ 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7d1abdf502..633c9f1ae7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -15,9 +15,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.4" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05ec8ca9416c5ea37062b502703cd7fcb207736bc294f6e0cf367ac6fc234570" +checksum = "5ab49abadf3f9e1c4bc499e8845e152ad87d2ad2d30371841171169e9d75feee" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index 9e1671da11..f228eacfbf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,4 +9,4 @@ description = "In-memory filesystem for Redox, which is useful for early logging # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox_syscall = "0.2.4" +redox_syscall = "0.2.9" diff --git a/src/scheme.rs b/src/scheme.rs index 7dbc5ca956..fd0c2f7231 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -174,21 +174,22 @@ impl Scheme { } impl SchemeMut for Scheme { - fn open(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { - let exists = self.filesystem.resolve(path, 0, 0).is_ok(); + fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result { + let exists = self.filesystem.resolve(path.as_bytes(), 0, 0).is_ok(); if flags & O_CREAT != 0 && flags & O_EXCL != 0 && exists { return Err(Error::new(EEXIST)); } let handle = if flags & O_CREAT != 0 && exists { - self.open_existing(path, flags, uid, gid)? + self.open_existing(path.as_bytes(), flags, uid, gid)? } else if flags & O_CREAT != 0 { if flags & O_STAT != 0 { return Err(Error::new(EINVAL)); } let (parent_dir_inode, new_name) = - self.filesystem.resolve_except_last(path, uid, gid)?; + self.filesystem + .resolve_except_last(path.as_bytes(), uid, gid)?; let new_name = new_name.ok_or(Error::new(EINVAL))?; // cannot mkdir / let current_time = filesystem::current_time(); @@ -266,7 +267,7 @@ impl SchemeMut for Scheme { current_perm, } } else { - self.open_existing(path, flags, uid, gid)? + self.open_existing(path.as_bytes(), flags, uid, gid)? }; let fd = self.next_fd; @@ -276,8 +277,8 @@ impl SchemeMut for Scheme { Ok(fd) } - fn chmod(&mut self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result { - let inode_num = self.filesystem.resolve(path, uid, gid)?; + fn chmod(&mut self, path: &str, mode: u16, uid: u32, gid: u32) -> Result { + let inode_num = self.filesystem.resolve(path.as_bytes(), uid, gid)?; let inode = self .filesystem .files @@ -295,11 +296,11 @@ impl SchemeMut for Scheme { inode.mode = mode | cur_mode; Ok(0) } - fn rmdir(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { - self.remove_dentry(path, uid, gid, true) + fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result { + self.remove_dentry(path.as_bytes(), uid, gid, true) } - fn unlink(&mut self, path: &[u8], uid: u32, gid: u32) -> Result { - self.remove_dentry(path, uid, gid, false) + fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result { + self.remove_dentry(path.as_bytes(), uid, gid, false) } fn dup(&mut self, old_fd: usize, _buf: &[u8]) -> Result { let handle = self @@ -492,7 +493,7 @@ impl SchemeMut for Scheme { // TODO Err(Error::new(ENOSYS)) } - fn frename(&mut self, fd: usize, path: &[u8], uid: u32, gid: u32) -> Result { + fn frename(&mut self, fd: usize, path: &str, uid: u32, gid: u32) -> Result { if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } From 04ceace6a9ad092414785ab7a803501e8db934e6 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Tue, 1 Mar 2022 07:19:33 -0700 Subject: [PATCH 16/30] Use syscall::Daemon, enter null namespace --- Cargo.lock | 10 ++++++---- Cargo.toml | 2 +- src/main.rs | 51 ++++++++++++++++++++++++++++----------------------- 3 files changed, 35 insertions(+), 28 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 633c9f1ae7..bef79c848c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,10 +1,12 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +version = 3 + [[package]] name = "bitflags" -version = "1.2.1" +version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "ramfs" @@ -15,9 +17,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.9" +version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ab49abadf3f9e1c4bc499e8845e152ad87d2ad2d30371841171169e9d75feee" +checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index f228eacfbf..b33eca49eb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,4 +9,4 @@ description = "In-memory filesystem for Redox, which is useful for early logging # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox_syscall = "0.2.9" +redox_syscall = "0.2.11" diff --git a/src/main.rs b/src/main.rs index 308cf6b538..c67450c308 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,9 +2,9 @@ use std::fs::File; use std::io::prelude::*; -use std::{env, io}; +use std::{env, io, process}; -use syscall::{CloneFlags, Packet, SchemeMut}; +use syscall::{Daemon, Packet, SchemeMut}; mod filesystem; mod scheme; @@ -14,30 +14,35 @@ use self::scheme::Scheme; fn main() { let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); - if unsafe { syscall::clone(CloneFlags::empty()) }.expect("ramfs: failed to fork") != 0 { - return; - } + Daemon::new(move |daemon| { + let mut socket = + File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); - let mut socket = - File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); - let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); + let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); - 'packet_loop: loop { - let mut packet = Packet::default(); + syscall::setrens(0, 0).expect("ramfs: failed to enter null namespace"); - match socket.read(&mut packet) { - Ok(0) => break 'packet_loop, - Ok(_) => (), - Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, - Err(error) => panic!("ramfs: failed to read from socket: {:?}", error), + daemon.ready().expect("ramfs: failed to mark daemon as ready"); + + 'packet_loop: loop { + let mut packet = Packet::default(); + + match socket.read(&mut packet) { + Ok(0) => break 'packet_loop, + Ok(_) => (), + Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, + Err(error) => panic!("ramfs: failed to read from socket: {:?}", error), + } + + scheme.handle(&mut packet); + + match socket.write(&packet) { + Ok(_) => (), + Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, + Err(error) => panic!("ramfs: failed to write to socket: {:?}", error), + } } - scheme.handle(&mut packet); - - match socket.write(&packet) { - Ok(_) => (), - Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, - Err(error) => panic!("ramfs: failed to write to socket: {:?}", error), - } - } + process::exit(0); + }).expect("ramfs: failed to create daemon"); } From 1af1a597f2ba1bbb3c925ba4a0c1647b9dcf404a Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Fri, 25 Mar 2022 15:27:52 +0100 Subject: [PATCH 17/30] Update syscall --- Cargo.lock | 4 ++-- Cargo.toml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bef79c848c..69a72d7336 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,9 +17,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.11" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c" +checksum = "8ae183fc1b06c149f0c1793e1eb447c8b04bfe46d48e9e48bfb8d2d7ed64ecf0" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index b33eca49eb..89293b57e5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,4 +9,4 @@ description = "In-memory filesystem for Redox, which is useful for early logging # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox_syscall = "0.2.11" +redox_syscall = "0.2.12" From 4e8083eb608961eea7a0cc6c50df0173a4776796 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Tue, 26 Jul 2022 16:14:06 -0600 Subject: [PATCH 18/30] Update Cargo.lock --- Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 69a72d7336..483dc6d271 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,9 +17,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.12" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ae183fc1b06c149f0c1793e1eb447c8b04bfe46d48e9e48bfb8d2d7ed64ecf0" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" dependencies = [ "bitflags", ] From d3fd7f2dbe2f7f3e092d8e5ef2115bf091d9c106 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Tue, 19 Jul 2022 10:37:16 +0200 Subject: [PATCH 19/30] Use redox-daemon --- Cargo.lock | 15 +++++++++++++++ Cargo.toml | 1 + src/main.rs | 4 ++-- 3 files changed, 18 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 483dc6d271..8ff4b3a696 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,10 +8,25 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" +[[package]] +name = "libc" +version = "0.2.126" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836" + [[package]] name = "ramfs" version = "0.1.0" dependencies = [ + "redox-daemon", + "redox_syscall", +] + +[[package]] +name = "redox-daemon" +version = "0.1.0" +dependencies = [ + "libc", "redox_syscall", ] diff --git a/Cargo.toml b/Cargo.toml index 89293b57e5..920c051e87 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,4 +9,5 @@ description = "In-memory filesystem for Redox, which is useful for early logging # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] +redox-daemon = "0.1" redox_syscall = "0.2.12" diff --git a/src/main.rs b/src/main.rs index c67450c308..5dd86b979e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,7 +4,7 @@ use std::fs::File; use std::io::prelude::*; use std::{env, io, process}; -use syscall::{Daemon, Packet, SchemeMut}; +use syscall::{Packet, SchemeMut}; mod filesystem; mod scheme; @@ -14,7 +14,7 @@ use self::scheme::Scheme; fn main() { let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); - Daemon::new(move |daemon| { + redox_daemon::Daemon::new(move |daemon| { let mut socket = File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); From 111cae7362d8b4e40443d5fa552a66870f62d44b Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Sat, 11 Feb 2023 14:41:54 -0700 Subject: [PATCH 20/30] Update libc crate --- Cargo.lock | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8ff4b3a696..d20ef93b94 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10,9 +10,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "libc" -version = "0.2.126" +version = "0.2.139" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836" +checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79" [[package]] name = "ramfs" @@ -25,6 +25,8 @@ dependencies = [ [[package]] name = "redox-daemon" version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21e31c834277709c7ff3eb74959fe62be4b45b1189ba9d41fd3744cd3a9c554f" dependencies = [ "libc", "redox_syscall", From 5ce5de2db5bcbde496274613aaded434b0349dfa Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 31 Aug 2023 20:51:14 +0200 Subject: [PATCH 21/30] Update dependencies. --- Cargo.lock | 12 ++++++------ Cargo.toml | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d20ef93b94..985155bf52 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10,9 +10,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "libc" -version = "0.2.139" +version = "0.2.147" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79" +checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3" [[package]] name = "ramfs" @@ -24,9 +24,9 @@ dependencies = [ [[package]] name = "redox-daemon" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21e31c834277709c7ff3eb74959fe62be4b45b1189ba9d41fd3744cd3a9c554f" +checksum = "811fd0d382a70c9e9192166ee794567b65ef34cc7309c86a49b071779ca9b5f3" dependencies = [ "libc", "redox_syscall", @@ -34,9 +34,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.16" +version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index 920c051e87..3ab8a9abe7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,5 +9,5 @@ description = "In-memory filesystem for Redox, which is useful for early logging # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox-daemon = "0.1" -redox_syscall = "0.2.12" +redox-daemon = "0.1.1" +redox_syscall = "0.3" From 83a73ca48e2ad43c174fab1738bf51f92bdea4f9 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Wed, 15 Nov 2023 21:32:12 +0100 Subject: [PATCH 22/30] Migrate to libredox and redox-scheme. --- Cargo.lock | 73 ++++++++++++++++++++++++++++++++++++----------- Cargo.toml | 4 ++- src/filesystem.rs | 4 +-- src/main.rs | 36 +++++++---------------- src/scheme.rs | 25 +++++++++------- 5 files changed, 86 insertions(+), 56 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 985155bf52..7a4335729b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,35 +8,74 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" +[[package]] +name = "bitflags" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" + [[package]] name = "libc" -version = "0.2.147" +version = "0.2.150" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3" +checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c" [[package]] -name = "ramfs" -version = "0.1.0" -dependencies = [ - "redox-daemon", - "redox_syscall", -] - -[[package]] -name = "redox-daemon" -version = "0.1.1" +name = "libredox" +version = "0.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "811fd0d382a70c9e9192166ee794567b65ef34cc7309c86a49b071779ca9b5f3" +checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8" dependencies = [ + "bitflags 2.4.1", "libc", "redox_syscall", ] [[package]] -name = "redox_syscall" -version = "0.3.5" +name = "libredox" +version = "0.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" +checksum = "962b650e6b934f95cec493e1464e0f5cba98dd9ba9ef2b1c42cdfdb7864cab5a" dependencies = [ - "bitflags", + "bitflags 2.4.1", + "libc", + "redox_syscall", +] + +[[package]] +name = "ramfs" +version = "0.1.0" +dependencies = [ + "libredox 0.0.3", + "redox-daemon", + "redox-scheme", + "redox_syscall", +] + +[[package]] +name = "redox-daemon" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "353178b5771a301b9d2b318914ab5dfeb21dd6e65930faedde19248cfceca5a7" +dependencies = [ + "libc", + "libredox 0.0.1", +] + +[[package]] +name = "redox-scheme" +version = "0.1.0" +source = "git+https://gitlab.redox-os.org/redox-os/redox-scheme.git#afd3fa573f0a7c03b762ac23daaf06966afecc75" +dependencies = [ + "libredox 0.0.3", + "redox_syscall", +] + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", ] diff --git a/Cargo.toml b/Cargo.toml index 3ab8a9abe7..a98c8c1c79 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,4 +10,6 @@ description = "In-memory filesystem for Redox, which is useful for early logging [dependencies] redox-daemon = "0.1.1" -redox_syscall = "0.3" +redox_syscall = "0.4.1" +redox-scheme = { git = "https://gitlab.redox-os.org/redox-os/redox-scheme.git" } +libredox = "0.0.3" diff --git a/src/filesystem.rs b/src/filesystem.rs index eb60779e71..84fe175f81 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -98,9 +98,7 @@ impl Filesystem { } } pub fn get_block_size(&self) -> Result { - let mut statvfs = StatVfs::default(); - syscall::fstatvfs(self.memory_file.as_raw_fd() as usize, &mut statvfs)?; - Ok(statvfs.f_bsize) + Ok(libredox::call::fstatvfs(self.memory_file.as_raw_fd() as usize)?.f_bsize as u32) } pub fn block_size(&self) -> u32 { self.get_block_size().unwrap_or(Self::DEFAULT_BLOCK_SIZE) diff --git a/src/main.rs b/src/main.rs index 5dd86b979e..a9b587e224 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,46 +1,32 @@ -#![feature(try_reserve)] - -use std::fs::File; -use std::io::prelude::*; -use std::{env, io, process}; - -use syscall::{Packet, SchemeMut}; +use std::{env, process}; mod filesystem; mod scheme; +use redox_scheme::SignalBehavior; + use self::scheme::Scheme; fn main() { let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); redox_daemon::Daemon::new(move |daemon| { - let mut socket = - File::create(format!(":{}", scheme_name)).expect("ramfs: failed to create socket"); + let socket = redox_scheme::Socket::create(&scheme_name).expect("ramfs: failed to create socket"); let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); - syscall::setrens(0, 0).expect("ramfs: failed to enter null namespace"); + libredox::call::setrens(0, 0).expect("ramfs: failed to enter null namespace"); daemon.ready().expect("ramfs: failed to mark daemon as ready"); - 'packet_loop: loop { - let mut packet = Packet::default(); + loop { + let Some(request) = socket.next_request(SignalBehavior::Restart).expect("ramfs: failed to get next scheme request") else { + break; + }; - match socket.read(&mut packet) { - Ok(0) => break 'packet_loop, - Ok(_) => (), - Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, - Err(error) => panic!("ramfs: failed to read from socket: {:?}", error), - } + let response = request.handle_scheme_mut(&mut scheme); - scheme.handle(&mut packet); - - match socket.write(&packet) { - Ok(_) => (), - Err(error) if error.kind() == io::ErrorKind::Interrupted => continue 'packet_loop, - Err(error) => panic!("ramfs: failed to write to socket: {:?}", error), - } + socket.write_responses(&[response], SignalBehavior::Restart).expect("ramfs: failed to write next scheme response"); } process::exit(0); diff --git a/src/scheme.rs b/src/scheme.rs index fd0c2f7231..7791c707c9 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -4,15 +4,17 @@ use std::os::unix::io::AsRawFd; use std::{cmp, ops}; use syscall::error::{ - EACCES, EBADF, EBADFD, EEXIST, EINVAL, EIO, EISDIR, ENOENT, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, + EACCES, EBADF, EBADFD, EEXIST, EINVAL, EIO, EISDIR, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW, }; use syscall::flag::{ O_ACCMODE, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY, O_RDWR, O_STAT, O_TRUNC, O_WRONLY, }; -use syscall::{Error, EventFlags, Map, Result, SchemeMut, Stat, StatVfs, TimeSpec}; +use syscall::{Error, EventFlags, Map, Result, Stat, StatVfs, TimeSpec}; use syscall::{MODE_DIR, MODE_FILE, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; +use redox_scheme::SchemeMut; + use crate::filesystem::{self, DirEntry, File, FileData, Filesystem}; #[derive(Clone)] @@ -475,25 +477,21 @@ impl SchemeMut for Scheme { } Err(Error::new(ENOSYS)) } - fn fmap(&mut self, fd: usize, _map: &Map) -> Result { + fn mmap_prep(&mut self, fd: usize, _offset: u64, _size: usize, _flags: syscall::MapFlags) -> Result { if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } // TODO Err(Error::new(ENOSYS)) } - fn funmap(&mut self, _address: usize, _len: usize) -> Result { - // TODO - Err(Error::new(ENOSYS)) - } - fn fpath(&mut self, fd: usize, buf: &mut [u8]) -> Result { + fn fpath(&mut self, fd: usize, _buf: &mut [u8]) -> Result { if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } // TODO Err(Error::new(ENOSYS)) } - fn frename(&mut self, fd: usize, path: &str, uid: u32, gid: u32) -> Result { + fn frename(&mut self, fd: usize, _path: &str, _uid: u32, _gid: u32) -> Result { if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } @@ -563,7 +561,14 @@ impl SchemeMut for Scheme { if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } - syscall::fstatvfs(self.filesystem.memory_file.as_raw_fd() as usize, stat)?; + let abi_stat = libredox::call::fstatvfs(self.filesystem.memory_file.as_raw_fd() as usize)?; + // TODO: From impl + *stat = StatVfs { + f_bavail: abi_stat.f_bavail, + f_bfree: abi_stat.f_bfree, + f_blocks: abi_stat.f_blocks, + f_bsize: abi_stat.f_bsize as u32, + }; Ok(0) } From b48a8c830e97ec0c56403b0eeddf388c81c69de5 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Mon, 11 Dec 2023 10:11:21 -0700 Subject: [PATCH 23/30] Fix build on 32-bit systems --- src/scheme.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scheme.rs b/src/scheme.rs index 7791c707c9..bfb1d41312 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -564,9 +564,9 @@ impl SchemeMut for Scheme { let abi_stat = libredox::call::fstatvfs(self.filesystem.memory_file.as_raw_fd() as usize)?; // TODO: From impl *stat = StatVfs { - f_bavail: abi_stat.f_bavail, - f_bfree: abi_stat.f_bfree, - f_blocks: abi_stat.f_blocks, + f_bavail: abi_stat.f_bavail as u64, + f_bfree: abi_stat.f_bfree as u64, + f_blocks: abi_stat.f_blocks as u64, f_bsize: abi_stat.f_bsize as u32, }; From 53dcb4af72683c89074d28cc200341d8fe4f21fe Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Sat, 23 Mar 2024 14:48:42 +0100 Subject: [PATCH 24/30] Fix non-append writes and cancellation. --- Cargo.lock | 52 ++++++++++++++++++--------------------------------- Cargo.toml | 8 ++++---- src/main.rs | 11 ++++++++--- src/scheme.rs | 33 +++++++++----------------------- 4 files changed, 39 insertions(+), 65 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7a4335729b..525c58454a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,40 +4,23 @@ version = 3 [[package]] name = "bitflags" -version = "1.3.2" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" +checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" [[package]] name = "libc" -version = "0.2.150" +version = "0.2.153" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c" +checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" [[package]] name = "libredox" -version = "0.0.1" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8" +checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.4.1", - "libc", - "redox_syscall", -] - -[[package]] -name = "libredox" -version = "0.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "962b650e6b934f95cec493e1464e0f5cba98dd9ba9ef2b1c42cdfdb7864cab5a" -dependencies = [ - "bitflags 2.4.1", + "bitflags", "libc", "redox_syscall", ] @@ -46,7 +29,7 @@ dependencies = [ name = "ramfs" version = "0.1.0" dependencies = [ - "libredox 0.0.3", + "libredox", "redox-daemon", "redox-scheme", "redox_syscall", @@ -54,28 +37,29 @@ dependencies = [ [[package]] name = "redox-daemon" -version = "0.1.2" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "353178b5771a301b9d2b318914ab5dfeb21dd6e65930faedde19248cfceca5a7" +checksum = "7fbdeffdb03cf2961b211a2023e683d71f2c225ea93404da5dc34b0dc94f0341" dependencies = [ "libc", - "libredox 0.0.1", + "libredox", ] [[package]] name = "redox-scheme" -version = "0.1.0" -source = "git+https://gitlab.redox-os.org/redox-os/redox-scheme.git#afd3fa573f0a7c03b762ac23daaf06966afecc75" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a4d4161697395d7cc9b182a14a753b2ba0243dcf622e278e644c6e7f74904c1" dependencies = [ - "libredox 0.0.3", + "libredox", "redox_syscall", ] [[package]] name = "redox_syscall" -version = "0.4.1" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e" dependencies = [ - "bitflags 1.3.2", + "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index a98c8c1c79..d5fa4b92fd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ description = "In-memory filesystem for Redox, which is useful for early logging # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -redox-daemon = "0.1.1" -redox_syscall = "0.4.1" -redox-scheme = { git = "https://gitlab.redox-os.org/redox-os/redox-scheme.git" } -libredox = "0.0.3" +redox-daemon = "0.1.2" +redox_syscall = "0.5.1" +redox-scheme = "0.2" +libredox = "0.1.3" diff --git a/src/main.rs b/src/main.rs index a9b587e224..dd86c3d48f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,7 +3,7 @@ use std::{env, process}; mod filesystem; mod scheme; -use redox_scheme::SignalBehavior; +use redox_scheme::{RequestKind, SignalBehavior}; use self::scheme::Scheme; @@ -23,10 +23,15 @@ fn main() { let Some(request) = socket.next_request(SignalBehavior::Restart).expect("ramfs: failed to get next scheme request") else { break; }; + match request.kind() { + RequestKind::Call(call) => { + let response = call.handle_scheme_mut(&mut scheme); - let response = request.handle_scheme_mut(&mut scheme); + socket.write_responses(&[response], SignalBehavior::Restart).expect("ramfs: failed to write next scheme response"); + } + _ => (), + } - socket.write_responses(&[response], SignalBehavior::Restart).expect("ramfs: failed to write next scheme response"); } process::exit(0); diff --git a/src/scheme.rs b/src/scheme.rs index bfb1d41312..b0069bf77c 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -279,25 +279,6 @@ impl SchemeMut for Scheme { Ok(fd) } - fn chmod(&mut self, path: &str, mode: u16, uid: u32, gid: u32) -> Result { - let inode_num = self.filesystem.resolve(path.as_bytes(), uid, gid)?; - let inode = self - .filesystem - .files - .get_mut(&inode_num) - .ok_or(Error::new(EIO))?; - - let cur_mode = inode.mode & MODE_TYPE; - - if inode.uid != uid && uid != 0 { - return Err(Error::new(EACCES)); - } - if mode & MODE_TYPE != 0 { - return Err(Error::new(EINVAL)); - } - inode.mode = mode | cur_mode; - Ok(0) - } fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result { self.remove_dentry(path.as_bytes(), uid, gid, true) } @@ -400,12 +381,15 @@ impl SchemeMut for Scheme { } // if there's a seek hole, fill it with 0 and continue writing. - if handle.offset > bytes.len() { - let additional = handle.offset - bytes.len(); + let end_off = handle.offset.checked_add(buf.len()).ok_or(Error::new(EOVERFLOW))?; + if end_off > bytes.len() { + let additional = end_off - bytes.len(); bytes.try_reserve(additional).or(Err(Error::new(ENOMEM)))?; - bytes.resize(handle.offset, 0u8); + bytes.resize(end_off, 0u8); } - bytes.extend(buf); + bytes[handle.offset..][..buf.len()].copy_from_slice(buf); + handle.offset = end_off; + Ok(buf.len()) } else { Err(Error::new(EISDIR)) @@ -419,7 +403,6 @@ impl SchemeMut for Scheme { .get_mut(&handle.inode) .ok_or(Error::new(EBADFD))?; - let old = handle.offset; handle.offset = match whence { SEEK_SET => cmp::max(0, pos), SEEK_CUR => cmp::max( @@ -444,9 +427,11 @@ impl SchemeMut for Scheme { let cur_type = file.mode & MODE_TYPE; + /* if mode & MODE_TYPE != 0 { return Err(Error::new(EINVAL)); } + */ file.mode = mode | cur_type; From 6f076cd905970ab4e13a328c3a4d13c4acabd685 Mon Sep 17 00:00:00 2001 From: bjorn3 <17426603+bjorn3@users.noreply.github.com> Date: Mon, 19 Aug 2024 18:36:45 +0200 Subject: [PATCH 25/30] Remove all usages of the legacy scheme syntax --- src/filesystem.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/filesystem.rs b/src/filesystem.rs index 84fe175f81..29ac216817 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -74,7 +74,7 @@ impl Filesystem { pub fn new() -> Result { Ok(Self { files: iter::once((Self::ROOT_INODE, Self::create_root_inode())).collect(), - memory_file: fs::File::open("memory:").or(Err(Error::new(EIO)))?, + memory_file: fs::File::open("/scheme/memory").or(Err(Error::new(EIO)))?, last_inode_number: Self::ROOT_INODE, }) } From 8faf1278947e54c5e6c9e7bad48eff96b07543ed Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Fri, 30 Aug 2024 21:22:00 +0200 Subject: [PATCH 26/30] Replace seek() with fsize(). --- Cargo.lock | 16 +++++----- Cargo.toml | 2 +- src/main.rs | 20 ++++++++---- src/scheme.rs | 87 ++++++++++++++++++++++++++------------------------- 4 files changed, 67 insertions(+), 58 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 525c58454a..cdeae99868 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,15 +4,15 @@ version = 3 [[package]] name = "bitflags" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "libc" -version = "0.2.153" +version = "0.2.158" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" +checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439" [[package]] name = "libredox" @@ -47,9 +47,9 @@ dependencies = [ [[package]] name = "redox-scheme" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a4d4161697395d7cc9b182a14a753b2ba0243dcf622e278e644c6e7f74904c1" +checksum = "2148c23b7ed5bf1cc3919b4830e4bf2a674a5d3691c619317624ccd78d13a3ac" dependencies = [ "libredox", "redox_syscall", @@ -57,9 +57,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.1" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e" +checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" dependencies = [ "bitflags", ] diff --git a/Cargo.toml b/Cargo.toml index d5fa4b92fd..517251bc61 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,5 +11,5 @@ description = "In-memory filesystem for Redox, which is useful for early logging [dependencies] redox-daemon = "0.1.2" redox_syscall = "0.5.1" -redox-scheme = "0.2" +redox-scheme = "0.2.1" libredox = "0.1.3" diff --git a/src/main.rs b/src/main.rs index dd86c3d48f..20ad47d17f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -11,29 +11,37 @@ fn main() { let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); redox_daemon::Daemon::new(move |daemon| { - let socket = redox_scheme::Socket::create(&scheme_name).expect("ramfs: failed to create socket"); + let socket = redox_scheme::Socket::::create(&scheme_name) + .expect("ramfs: failed to create socket"); let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); libredox::call::setrens(0, 0).expect("ramfs: failed to enter null namespace"); - daemon.ready().expect("ramfs: failed to mark daemon as ready"); + daemon + .ready() + .expect("ramfs: failed to mark daemon as ready"); loop { - let Some(request) = socket.next_request(SignalBehavior::Restart).expect("ramfs: failed to get next scheme request") else { + let Some(request) = socket + .next_request(SignalBehavior::Restart) + .expect("ramfs: failed to get next scheme request") + else { break; }; match request.kind() { RequestKind::Call(call) => { let response = call.handle_scheme_mut(&mut scheme); - socket.write_responses(&[response], SignalBehavior::Restart).expect("ramfs: failed to write next scheme response"); + socket + .write_responses(&[response], SignalBehavior::Restart) + .expect("ramfs: failed to write next scheme response"); } _ => (), } - } process::exit(0); - }).expect("ramfs: failed to create daemon"); + }) + .expect("ramfs: failed to create daemon"); } diff --git a/src/scheme.rs b/src/scheme.rs index b0069bf77c..2a24c850e1 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -10,18 +10,19 @@ use syscall::error::{ use syscall::flag::{ O_ACCMODE, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY, O_RDWR, O_STAT, O_TRUNC, O_WRONLY, }; +use syscall::schemev2::NewFdFlags; use syscall::{Error, EventFlags, Map, Result, Stat, StatVfs, TimeSpec}; use syscall::{MODE_DIR, MODE_FILE, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; -use redox_scheme::SchemeMut; +use redox_scheme::{CallerCtx, OpenResult, SchemeMut}; use crate::filesystem::{self, DirEntry, File, FileData, Filesystem}; #[derive(Clone)] struct Handle { inode: usize, - offset: usize, + // TODO: fcntl_flags? opened_as_read: bool, // opened with O_RDONLY or O_RDWR opened_as_write: bool, // opened with O_WRONLY or O_RDWR @@ -167,7 +168,6 @@ impl Scheme { Ok(Handle { inode, - offset: 0, opened_as_read, opened_as_write, current_perm, @@ -176,14 +176,14 @@ impl Scheme { } impl SchemeMut for Scheme { - fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result { + fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result { let exists = self.filesystem.resolve(path.as_bytes(), 0, 0).is_ok(); if flags & O_CREAT != 0 && flags & O_EXCL != 0 && exists { return Err(Error::new(EEXIST)); } let handle = if flags & O_CREAT != 0 && exists { - self.open_existing(path.as_bytes(), flags, uid, gid)? + self.open_existing(path.as_bytes(), flags, ctx.uid, ctx.gid)? } else if flags & O_CREAT != 0 { if flags & O_STAT != 0 { return Err(Error::new(EINVAL)); @@ -191,7 +191,7 @@ impl SchemeMut for Scheme { let (parent_dir_inode, new_name) = self.filesystem - .resolve_except_last(path.as_bytes(), uid, gid)?; + .resolve_except_last(path.as_bytes(), ctx.uid, ctx.gid)?; let new_name = new_name.ok_or(Error::new(EINVAL))?; // cannot mkdir / let current_time = filesystem::current_time(); @@ -213,8 +213,8 @@ impl SchemeMut for Scheme { crtime: current_time, ctime: current_time, mtime: current_time, - gid, - uid, + gid: ctx.gid, + uid: ctx.uid, ino: new_inode_number, mode, nlink: 2, // parent entry, "." @@ -234,8 +234,8 @@ impl SchemeMut for Scheme { crtime: current_time, ctime: current_time, mtime: current_time, - gid, - uid, + gid: ctx.gid, + uid: ctx.uid, ino: new_inode_number, mode, nlink: 1, @@ -243,7 +243,7 @@ impl SchemeMut for Scheme { open_handles: 1, } }; - let current_perm = current_perm(&new_inode, uid, gid); + let current_perm = current_perm(&new_inode, ctx.uid, ctx.gid); check_permissions(flags, current_perm)?; self.filesystem.files.insert(new_inode_number, new_inode); @@ -263,13 +263,12 @@ impl SchemeMut for Scheme { Handle { inode: new_inode_number, - offset: 0, opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, current_perm, } } else { - self.open_existing(path.as_bytes(), flags, uid, gid)? + self.open_existing(path.as_bytes(), flags, ctx.uid, ctx.gid)? }; let fd = self.next_fd; @@ -277,7 +276,10 @@ impl SchemeMut for Scheme { self.handles.insert(fd, handle); - Ok(fd) + Ok(OpenResult::ThisScheme { + number: fd, + flags: NewFdFlags::POSITIONED, + }) } fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result { self.remove_dentry(path.as_bytes(), uid, gid, true) @@ -298,8 +300,11 @@ impl SchemeMut for Scheme { self.handles.insert(fd, handle); Ok(fd) } - fn read(&mut self, fd: usize, buf: &mut [u8]) -> Result { + fn read(&mut self, fd: usize, buf: &mut [u8], offset: u64, _fcntl_flags: u32) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let Ok(offset) = usize::try_from(offset) else { + return Ok(0); + }; let file = self .filesystem .files @@ -316,15 +321,13 @@ impl SchemeMut for Scheme { return Err(Error::new(EBADFD)); } - if handle.offset >= bytes.len() { + if offset >= bytes.len() { return Ok(0); } - let bytes_to_read = - cmp::min(bytes.len(), buf.len() + handle.offset) - handle.offset; - buf[..bytes_to_read] - .copy_from_slice(&bytes[handle.offset..handle.offset + bytes_to_read]); - handle.offset += bytes_to_read; - Ok(bytes_to_read) + let src = buf.get(..offset).unwrap_or(&[]); + let to_copy = src.len().min(buf.len()); + buf[..to_copy].copy_from_slice(&bytes[offset..][..to_copy]); + Ok(to_copy) } FileData::Directory(ref entries) => { if file.mode & MODE_TYPE != MODE_DIR { @@ -335,7 +338,7 @@ impl SchemeMut for Scheme { return Err(Error::new(EBADF)); } - let mut bytes_to_skip = handle.offset; + let mut bytes_to_skip = offset; let mut bytes_left_to_read = buf.len(); let mut bytes_read = 0; @@ -361,14 +364,16 @@ impl SchemeMut for Scheme { buf[bytes_read + bytes_to_read - 1] = b'\n'; bytes_left_to_read -= bytes_to_read; bytes_read += bytes_to_read; - handle.offset += bytes_read; } Ok(bytes_read) } } } - fn write(&mut self, fd: usize, buf: &[u8]) -> Result { + fn write(&mut self, fd: usize, buf: &[u8], offset: u64, _fcntl_flags: u32) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + let Ok(offset) = usize::try_from(offset) else { + return Ok(0); + }; let file = self .filesystem .files @@ -381,21 +386,20 @@ impl SchemeMut for Scheme { } // if there's a seek hole, fill it with 0 and continue writing. - let end_off = handle.offset.checked_add(buf.len()).ok_or(Error::new(EOVERFLOW))?; + let end_off = offset.checked_add(buf.len()).ok_or(Error::new(EOVERFLOW))?; if end_off > bytes.len() { let additional = end_off - bytes.len(); bytes.try_reserve(additional).or(Err(Error::new(ENOMEM)))?; bytes.resize(end_off, 0u8); } - bytes[handle.offset..][..buf.len()].copy_from_slice(buf); - handle.offset = end_off; + bytes[offset..][..buf.len()].copy_from_slice(buf); Ok(buf.len()) } else { Err(Error::new(EISDIR)) } } - fn seek(&mut self, fd: usize, pos: isize, whence: usize) -> Result { + fn fsize(&mut self, fd: usize) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; let file = self .filesystem @@ -403,19 +407,10 @@ impl SchemeMut for Scheme { .get_mut(&handle.inode) .ok_or(Error::new(EBADFD))?; - handle.offset = match whence { - SEEK_SET => cmp::max(0, pos), - SEEK_CUR => cmp::max( - 0, - pos + isize::try_from(handle.offset).or(Err(Error::new(EOVERFLOW)))?, - ), - SEEK_END => cmp::max( - 0, - pos + isize::try_from(file.data.size()).or(Err(Error::new(EOVERFLOW)))?, - ), - _ => return Err(Error::new(EINVAL)), - } as usize; - Ok(handle.offset as isize) + file.data + .size() + .try_into() + .map_err(|_| Error::new(EOVERFLOW)) } fn fchmod(&mut self, fd: usize, mode: u16) -> Result { let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; @@ -462,7 +457,13 @@ impl SchemeMut for Scheme { } Err(Error::new(ENOSYS)) } - fn mmap_prep(&mut self, fd: usize, _offset: u64, _size: usize, _flags: syscall::MapFlags) -> Result { + fn mmap_prep( + &mut self, + fd: usize, + _offset: u64, + _size: usize, + _flags: syscall::MapFlags, + ) -> Result { if !self.handles.contains_key(&fd) { return Err(Error::new(EBADF)); } From 8ab2ebb6f0713403b10bfc0cf2bc107fe0bc80d4 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Fri, 13 Sep 2024 13:53:13 +0200 Subject: [PATCH 27/30] Make scheme fully stateless. Stateless in this case means the inode number is sufficient for describing an open file handle. --- Cargo.lock | 47 ++++++- Cargo.toml | 6 +- src/filesystem.rs | 82 ++++-------- src/main.rs | 5 +- src/scheme.rs | 327 ++++++++++++++-------------------------------- 5 files changed, 174 insertions(+), 293 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cdeae99868..0fed4b0899 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,12 +2,40 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "autocfg" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" + [[package]] name = "bitflags" version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "hashbrown" +version = "0.14.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" + +[[package]] +name = "indexmap" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5" +dependencies = [ + "equivalent", + "hashbrown", +] + [[package]] name = "libc" version = "0.2.158" @@ -29,10 +57,12 @@ dependencies = [ name = "ramfs" version = "0.1.0" dependencies = [ + "indexmap", "libredox", "redox-daemon", "redox-scheme", "redox_syscall", + "slab", ] [[package]] @@ -47,9 +77,9 @@ dependencies = [ [[package]] name = "redox-scheme" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2148c23b7ed5bf1cc3919b4830e4bf2a674a5d3691c619317624ccd78d13a3ac" +checksum = "98d040cfa6370d9c6b1a5987247272f19ea4722f1064e66ad2e077c152b82ea3" dependencies = [ "libredox", "redox_syscall", @@ -57,9 +87,18 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.3" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" +checksum = "0884ad60e090bf1345b93da0a5de8923c93884cd03f40dfcfddd3b4bee661853" dependencies = [ "bitflags", ] + +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] diff --git a/Cargo.toml b/Cargo.toml index 517251bc61..b720c682ec 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,6 +10,8 @@ description = "In-memory filesystem for Redox, which is useful for early logging [dependencies] redox-daemon = "0.1.2" -redox_syscall = "0.5.1" -redox-scheme = "0.2.1" +redox_syscall = "0.5.3" +redox-scheme = "0.2.2" libredox = "0.1.3" +indexmap = "2.5.0" +slab = "0.4.9" diff --git a/src/filesystem.rs b/src/filesystem.rs index 29ac216817..ed180bd618 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -1,14 +1,12 @@ use std::collections::BTreeMap; use std::convert::TryInto; -use std::ffi::OsStr; use std::{fs, iter, time}; -use std::os::unix::ffi::OsStrExt; use std::os::unix::io::AsRawFd; +use indexmap::IndexMap; use syscall::error::{EACCES, EIO, ENFILE, ENOENT}; -use syscall::flag::{O_RDONLY, O_STAT}; -use syscall::{Error, Result, StatVfs, TimeSpec, MODE_DIR}; +use syscall::{Error, Result, TimeSpec, MODE_DIR}; use super::scheme::current_perm; @@ -17,7 +15,6 @@ pub struct File { pub mode: u16, pub uid: u32, pub gid: u32, - pub ino: usize, pub nlink: usize, pub open_handles: usize, @@ -31,33 +28,18 @@ pub struct File { } #[derive(Clone, Debug)] -pub struct DirEntry { - pub name: Vec, - pub inode: usize, -} +pub struct Inode(pub usize); #[derive(Debug)] pub enum FileData { File(Vec), - Directory(Vec), + Directory(IndexMap), } impl FileData { pub fn size(&self) -> usize { match self { &Self::File(ref data) => data.len(), - &Self::Directory(ref names) => names.iter().map(|dentry| dentry.name.len()).sum(), - } - } - pub fn as_directory(&self) -> Option<&[DirEntry]> { - match self { - &Self::Directory(ref inner) => Some(inner), - _ => None, - } - } - pub fn as_directory_mut(&mut self) -> Option<&mut Vec> { - match self { - &mut Self::Directory(ref mut inner) => Some(inner), - _ => None, + &Self::Directory(_) => 0, } } } @@ -87,14 +69,13 @@ impl Filesystem { mtime: cur_time, mode: MODE_DIR | 0o755, - ino: Self::ROOT_INODE, nlink: 1, open_handles: 0, uid: 0, gid: 0, - data: FileData::Directory(Vec::new()), + data: FileData::Directory(IndexMap::new()), } } pub fn get_block_size(&self) -> Result { @@ -111,7 +92,7 @@ impl Filesystem { self.last_inode_number = next; Ok(next) } - fn resolve_generic(&self, mut parts: Vec<&[u8]>, uid: u32, gid: u32) -> Result { + fn resolve_generic(&self, mut parts: Vec<&str>, uid: u32, gid: u32) -> Result { let mut current_file = self .files .get(&Self::ROOT_INODE) @@ -121,9 +102,8 @@ impl Filesystem { let mut i = 0; loop { - let part = match parts.get(i) { - Some(p) => p, - None => break, + let Some(&part) = parts.get(i) else { + break; }; let dentries = match current_file.data { FileData::Directory(ref dentries) => dentries, @@ -134,25 +114,19 @@ impl Filesystem { return Err(Error::new(EACCES)); } - if part == b"." || part == b".." { + if part == "." || part == ".." { parts.remove(i); } - let part = parts.get(i).unwrap(); - if part == b".." { - if i > 0 { - i -= 1; - parts.remove(i); - } + let part = *parts.get(i).unwrap(); + if part == ".." && i > 0 { + i -= 1; + parts.remove(i); } - let part = parts.get(i).unwrap(); + let part = *parts.get(i).unwrap(); - let entry = dentries - .iter() - .find(|dentry| &dentry.name == part) - .ok_or(Error::new(ENOENT))?; - current_file = self.files.get(&entry.inode).ok_or(Error::new(EIO))?; - current_inode = entry.inode; + current_inode = dentries.get(part).ok_or(Error::new(ENOENT))?.0; + current_file = self.files.get(¤t_inode).ok_or(Error::new(EIO))?; i += 1; } @@ -160,14 +134,11 @@ impl Filesystem { } pub fn resolve_except_last<'a>( &self, - mut path_bytes: &'a [u8], + path_bytes: &'a str, uid: u32, gid: u32, - ) -> Result<(usize, Option<&'a [u8]>)> { - if path_bytes.first() == Some(&b'/') { - path_bytes = &path_bytes[1..] - } - let mut parts = path_components_iter(path_bytes).collect::>(); + ) -> Result<(usize, Option<&'a str>)> { + let mut parts = path_components_iter(path_bytes.trim_start_matches('/')).collect::>(); let last = if parts.len() >= 1 { Some(parts.pop().unwrap()) @@ -177,17 +148,14 @@ impl Filesystem { Ok((self.resolve_generic(parts, uid, gid)?, last)) } - pub fn resolve(&self, mut path_bytes: &[u8], uid: u32, gid: u32) -> Result { - if path_bytes.first() == Some(&b'/') { - path_bytes = &path_bytes[1..] - } - let parts = path_components_iter(path_bytes).collect::>(); + pub fn resolve(&self, path: &str, uid: u32, gid: u32) -> Result { + let parts = path_components_iter(path.trim_start_matches('/')).collect::>(); self.resolve_generic(parts, uid, gid) } } -pub fn path_components_iter(bytes: &[u8]) -> impl Iterator + '_ { - let components_iter = bytes.split(|c| c == &b'/'); +pub fn path_components_iter(bytes: &str) -> impl Iterator + '_ { + let components_iter = bytes.split(|c| c == '/'); components_iter.filter(|item| !item.is_empty()) } pub fn current_time() -> TimeSpec { @@ -196,7 +164,7 @@ pub fn current_time() -> TimeSpec { let duration = match sys_time.duration_since(time::SystemTime::UNIX_EPOCH) { Ok(d) => d, Err(e) => { - eprintln!("Apparently the signed 32-bit integer has overflowed; the time is now before the Unix epoch..."); + eprintln!("The time is apparently now before the Unix epoch..."); let negative_duration = e.duration(); diff --git a/src/main.rs b/src/main.rs index 20ad47d17f..b95ec68d9a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,7 +3,7 @@ use std::{env, process}; mod filesystem; mod scheme; -use redox_scheme::{RequestKind, SignalBehavior}; +use redox_scheme::{RequestKind, SignalBehavior, V2}; use self::scheme::Scheme; @@ -11,8 +11,7 @@ fn main() { let scheme_name = env::args().nth(1).expect("Usage:\n\tramfs SCHEME_NAME"); redox_daemon::Daemon::new(move |daemon| { - let socket = redox_scheme::Socket::::create(&scheme_name) - .expect("ramfs: failed to create socket"); + let socket = redox_scheme::Socket::::create(&scheme_name).expect("ramfs: failed to create socket"); let mut scheme = Scheme::new(scheme_name).expect("ramfs: failed to initialize scheme"); diff --git a/src/scheme.rs b/src/scheme.rs index 2a24c850e1..c103abb74a 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -1,8 +1,8 @@ -use std::collections::BTreeMap; use std::convert::{TryFrom, TryInto}; use std::os::unix::io::AsRawFd; -use std::{cmp, ops}; +use indexmap::IndexMap; +use syscall::dirent::{DirEntry, DirentBuf, DirentKind}; use syscall::error::{ EACCES, EBADF, EBADFD, EEXIST, EINVAL, EIO, EISDIR, ENOMEM, ENOSYS, ENOTDIR, ENOTEMPTY, EOVERFLOW, @@ -11,30 +11,15 @@ use syscall::flag::{ O_ACCMODE, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY, O_RDWR, O_STAT, O_TRUNC, O_WRONLY, }; use syscall::schemev2::NewFdFlags; -use syscall::{Error, EventFlags, Map, Result, Stat, StatVfs, TimeSpec}; -use syscall::{MODE_DIR, MODE_FILE, MODE_PERM, MODE_TYPE, SEEK_CUR, SEEK_END, SEEK_SET}; +use syscall::{Error, EventFlags, Result, Stat, StatVfs, TimeSpec, ENOENT}; +use syscall::{MODE_DIR, MODE_FILE, MODE_PERM, MODE_TYPE}; use redox_scheme::{CallerCtx, OpenResult, SchemeMut}; -use crate::filesystem::{self, DirEntry, File, FileData, Filesystem}; - -#[derive(Clone)] -struct Handle { - inode: usize, - - // TODO: fcntl_flags? - opened_as_read: bool, // opened with O_RDONLY or O_RDWR - opened_as_write: bool, // opened with O_WRONLY or O_RDWR - - // the three first bits of mode >> 6 if uid matched, mode >> 3 if gid matched, otherwise mode - // >> 0. - current_perm: u8, -} +use crate::filesystem::{self, File, FileData, Filesystem, Inode}; pub struct Scheme { scheme_name: String, - handles: BTreeMap, - next_fd: usize, filesystem: Filesystem, } impl Scheme { @@ -42,21 +27,19 @@ impl Scheme { pub fn new(scheme_name: String) -> Result { Ok(Self { scheme_name, - handles: BTreeMap::new(), filesystem: Filesystem::new()?, - next_fd: 0, }) } /// Remove a directory entry, where the entry can be both a file or a directory. Used by both /// `unlink` and `rmdir`. pub fn remove_dentry( &mut self, - path: &[u8], + path: &str, uid: u32, gid: u32, directory: bool, ) -> Result { - let removed_entry = { + let removed_inode = { let (parent_dir_inode, name_to_delete) = self.filesystem.resolve_except_last(path, uid, gid)?; let name_to_delete = name_to_delete.ok_or(Error::new(EINVAL))?; // can't remove root @@ -71,16 +54,11 @@ impl Scheme { return Err(Error::new(EACCES)); } - let dentries = parent.data.as_directory_mut().ok_or(Error::new(EBADF))?; + let FileData::Directory(ref mut dentries) = parent.data else { + return Err(Error::new(ENOTDIR)); + }; - let (position, entry_inode) = dentries - .iter() - .enumerate() - .find(|(_, d)| d.name == name_to_delete) - .unwrap(); - let entry_inode = entry_inode.inode; - - let removed_entry = dentries.remove(position); + let Inode(entry_inode) = dentries.shift_remove(name_to_delete).ok_or(Error::new(ENOENT))?; if let Some(File { data: FileData::Directory(ref data), @@ -100,35 +78,35 @@ impl Scheme { parent.nlink -= 1; // '..' of subdirectory } - removed_entry + entry_inode }; - let removed_inode = self + let removed_inode_info = self .filesystem .files - .get_mut(&removed_entry.inode) + .get_mut(&removed_inode) .ok_or(Error::new(EIO))?; - if let FileData::File(_) = removed_inode.data { + if let FileData::File(_) = removed_inode_info.data { if directory { return Err(Error::new(EISDIR)); } - removed_inode.nlink -= 1; // only the parent entry + removed_inode_info.nlink -= 1; // only the parent entry } else { if !directory { return Err(Error::new(ENOTDIR)); } - removed_inode.nlink -= 2; // both the parent entry and '.' + removed_inode_info.nlink -= 2; // both the parent entry and '.' } - if removed_inode.nlink == 0 && removed_inode.open_handles == 0 { - self.filesystem.files.remove(&removed_entry.inode); + if removed_inode_info.nlink == 0 && removed_inode_info.open_handles == 0 { + self.filesystem.files.remove(&removed_inode); } Ok(0) } - fn open_existing(&mut self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result { + fn open_existing(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result { let inode = self.filesystem.resolve(path, uid, gid)?; let file = self .filesystem @@ -151,7 +129,6 @@ impl Scheme { let current_perm = current_perm(file, uid, gid); check_permissions(flags, current_perm)?; - let opened_as_read = flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR; let opened_as_write = flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR; if flags & O_TRUNC == O_TRUNC && opened_as_write { @@ -166,24 +143,19 @@ impl Scheme { file.open_handles += 1; - Ok(Handle { - inode, - opened_as_read, - opened_as_write, - current_perm, - }) + Ok(Inode(inode)) } } impl SchemeMut for Scheme { fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result { - let exists = self.filesystem.resolve(path.as_bytes(), 0, 0).is_ok(); + let exists = self.filesystem.resolve(path, 0, 0).is_ok(); if flags & O_CREAT != 0 && flags & O_EXCL != 0 && exists { return Err(Error::new(EEXIST)); } - let handle = if flags & O_CREAT != 0 && exists { - self.open_existing(path.as_bytes(), flags, ctx.uid, ctx.gid)? + let inode = if flags & O_CREAT != 0 && exists { + self.open_existing(path, flags, ctx.uid, ctx.gid)?.0 } else if flags & O_CREAT != 0 { if flags & O_STAT != 0 { return Err(Error::new(EINVAL)); @@ -191,7 +163,7 @@ impl SchemeMut for Scheme { let (parent_dir_inode, new_name) = self.filesystem - .resolve_except_last(path.as_bytes(), ctx.uid, ctx.gid)?; + .resolve_except_last(path, ctx.uid, ctx.gid)?; let new_name = new_name.ok_or(Error::new(EINVAL))?; // cannot mkdir / let current_time = filesystem::current_time(); @@ -215,10 +187,9 @@ impl SchemeMut for Scheme { mtime: current_time, gid: ctx.gid, uid: ctx.uid, - ino: new_inode_number, mode, nlink: 2, // parent entry, "." - data: FileData::Directory(Vec::new()), + data: FileData::Directory(IndexMap::new()), open_handles: 1, } } else { @@ -236,7 +207,6 @@ impl SchemeMut for Scheme { mtime: current_time, gid: ctx.gid, uid: ctx.uid, - ino: new_inode_number, mode, nlink: 1, data: FileData::File(Vec::new()), @@ -255,63 +225,38 @@ impl SchemeMut for Scheme { .ok_or(Error::new(EIO))?; match parent_file.data { FileData::File(_) => return Err(Error::new(EIO)), - FileData::Directory(ref mut entries) => entries.push(DirEntry { - name: new_name.to_owned(), - inode: new_inode_number, - }), + FileData::Directory(ref mut entries) => { + entries.insert(new_name.to_owned(), Inode(new_inode_number)); + } } - Handle { - inode: new_inode_number, - opened_as_read: flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR, - opened_as_write: flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR, - current_perm, - } + new_inode_number } else { - self.open_existing(path.as_bytes(), flags, ctx.uid, ctx.gid)? + self.open_existing(path, flags, ctx.uid, ctx.gid)?.0 }; - - let fd = self.next_fd; - self.next_fd += 1; - - self.handles.insert(fd, handle); - - Ok(OpenResult::ThisScheme { - number: fd, - flags: NewFdFlags::POSITIONED, - }) + Ok(OpenResult::ThisScheme { number: inode, flags: NewFdFlags::POSITIONED }) } fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result { - self.remove_dentry(path.as_bytes(), uid, gid, true) + self.remove_dentry(path, uid, gid, true) } fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result { - self.remove_dentry(path.as_bytes(), uid, gid, false) + self.remove_dentry(path, uid, gid, false) } - fn dup(&mut self, old_fd: usize, _buf: &[u8]) -> Result { - let handle = self - .handles - .get_mut(&old_fd) - .ok_or(Error::new(EBADF))? - .clone(); - - let fd = self.next_fd; - self.next_fd += 1; - - self.handles.insert(fd, handle); - Ok(fd) + fn dup(&mut self, old_inode: usize, _buf: &[u8]) -> Result { + Ok(old_inode) } - fn read(&mut self, fd: usize, buf: &mut [u8], offset: u64, _fcntl_flags: u32) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + fn read(&mut self, inode: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result { let Ok(offset) = usize::try_from(offset) else { return Ok(0); }; + let file = self .filesystem .files - .get_mut(&handle.inode) + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; - if !handle.opened_as_read { + if !matches!((fcntl_flags as usize) & O_ACCMODE, O_RDONLY | O_RDWR) { return Err(Error::new(EBADF)); } @@ -320,64 +265,47 @@ impl SchemeMut for Scheme { if file.mode & MODE_TYPE == MODE_DIR { return Err(Error::new(EBADFD)); } - - if offset >= bytes.len() { - return Ok(0); - } - let src = buf.get(..offset).unwrap_or(&[]); - let to_copy = src.len().min(buf.len()); - buf[..to_copy].copy_from_slice(&bytes[offset..][..to_copy]); - Ok(to_copy) - } - FileData::Directory(ref entries) => { - if file.mode & MODE_TYPE != MODE_DIR { - return Err(Error::new(EBADFD)); - } - // directories require the execute permission to be listed - if handle.current_perm & 0o1 == 0 { - return Err(Error::new(EBADF)); - } - - let mut bytes_to_skip = offset; - let mut bytes_left_to_read = buf.len(); - let mut bytes_read = 0; - - for DirEntry { - name: entry_bytes, .. - } in entries - { - // skip the whole entry if it fits - if bytes_to_skip >= entry_bytes.len() { - bytes_to_skip -= entry_bytes.len(); - continue; - } - - let bytes_to_read = - cmp::min(entry_bytes.len() + 1 - bytes_to_skip, bytes_left_to_read); - - let entry_bytes = - &entry_bytes[bytes_to_skip..bytes_to_skip + bytes_to_read - 1]; - bytes_to_skip -= bytes_to_skip; - - buf[bytes_read..bytes_read + bytes_to_read - 1] - .copy_from_slice(&entry_bytes[..bytes_to_read - 1]); - buf[bytes_read + bytes_to_read - 1] = b'\n'; - bytes_left_to_read -= bytes_to_read; - bytes_read += bytes_to_read; - } - Ok(bytes_read) + let src_bytes = bytes.get(offset..).unwrap_or(&[]); + let bytes_to_read = src_bytes.len().min(buf.len()); + buf[..bytes_to_read].copy_from_slice(&src_bytes[..bytes_to_read]); + Ok(bytes_to_read) } + FileData::Directory(_) => return Err(Error::new(EISDIR)), } } - fn write(&mut self, fd: usize, buf: &[u8], offset: u64, _fcntl_flags: u32) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let Ok(offset) = usize::try_from(offset) else { - return Ok(0); + fn getdents<'buf>(&mut self, inode: usize, mut buf: DirentBuf<&'buf mut [u8]>, opaque_offset: u64) -> Result> { + let Ok(offset) = usize::try_from(opaque_offset) else { + return Ok(buf); }; let file = self .filesystem .files - .get_mut(&handle.inode) + .get_mut(&inode) + .ok_or(Error::new(EBADFD))?; + + let FileData::Directory(ref dir) = file.data else { + return Err(Error::new(ENOTDIR)); + }; + + for (i, (dent_name, Inode(dent_inode))) in dir.iter().enumerate().skip(offset) { + buf.entry(DirEntry { + inode: *dent_inode as u64, + name: dent_name, + kind: DirentKind::Unspecified, + next_opaque_id: i as u64 + 1, + })?; + } + Ok(buf) + } + fn write(&mut self, inode: usize, buf: &[u8], offset: u64, _fcntl_flags: u32) -> Result { + let Ok(offset) = usize::try_from(offset) else { + return Ok(0); + }; + + let file = self + .filesystem + .files + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; if let &mut FileData::File(ref mut bytes) = &mut file.data { @@ -399,25 +327,11 @@ impl SchemeMut for Scheme { Err(Error::new(EISDIR)) } } - fn fsize(&mut self, fd: usize) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + fn fchmod(&mut self, inode: usize, mode: u16) -> Result { let file = self .filesystem .files - .get_mut(&handle.inode) - .ok_or(Error::new(EBADFD))?; - - file.data - .size() - .try_into() - .map_err(|_| Error::new(EOVERFLOW)) - } - fn fchmod(&mut self, fd: usize, mode: u16) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; - let file = self - .filesystem - .files - .get_mut(&handle.inode) + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; let cur_type = file.mode & MODE_TYPE; @@ -432,12 +346,11 @@ impl SchemeMut for Scheme { Ok(0) } - fn fchown(&mut self, fd: usize, uid: u32, gid: u32) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + fn fchown(&mut self, inode: usize, uid: u32, gid: u32) -> Result { let file = self .filesystem .files - .get_mut(&handle.inode) + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; file.uid = uid; @@ -445,52 +358,31 @@ impl SchemeMut for Scheme { Ok(0) } - fn fcntl(&mut self, fd: usize, _cmd: usize, _arg: usize) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn fcntl(&mut self, _inode: usize, _cmd: usize, _arg: usize) -> Result { Ok(0) } - fn fevent(&mut self, fd: usize, _flags: EventFlags) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn fevent(&mut self, _inode: usize, _flags: EventFlags) -> Result { + // TODO? Err(Error::new(ENOSYS)) } - fn mmap_prep( - &mut self, - fd: usize, - _offset: u64, - _size: usize, - _flags: syscall::MapFlags, - ) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn mmap_prep(&mut self, _inode: usize, _offset: u64, _size: usize, _flags: syscall::MapFlags) -> Result { // TODO Err(Error::new(ENOSYS)) } - fn fpath(&mut self, fd: usize, _buf: &mut [u8]) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn fpath(&mut self, _inode: usize, _buf: &mut [u8]) -> Result { // TODO Err(Error::new(ENOSYS)) } - fn frename(&mut self, fd: usize, _path: &str, _uid: u32, _gid: u32) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn frename(&mut self, _inode: usize, _path: &str, _uid: u32, _gid: u32) -> Result { // TODO Err(Error::new(ENOSYS)) } - fn fstat(&mut self, fd: usize, stat: &mut Stat) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + fn fstat(&mut self, inode: usize, stat: &mut Stat) -> Result { let block_size = self.filesystem.block_size(); let file = self .filesystem .files - .get_mut(&handle.inode) + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; let size = file.data.size().try_into().or(Err(Error::new(EOVERFLOW)))?; @@ -499,13 +391,13 @@ impl SchemeMut for Scheme { st_mode: file.mode, st_uid: file.uid, st_gid: file.gid, - st_ino: handle.inode.try_into().or(Err(Error::new(EOVERFLOW)))?, + st_ino: inode.try_into().map_err(|_| Error::new(EOVERFLOW))?, st_nlink: file.nlink.try_into().or(Err(Error::new(EOVERFLOW)))?, st_dev: 0, st_size: size, st_blksize: block_size, - st_blocks: div_round_up(size, u64::from(block_size)), + st_blocks: size.next_multiple_of(u64::from(block_size)), st_atime: file .atime @@ -543,10 +435,7 @@ impl SchemeMut for Scheme { Ok(0) } - fn fstatvfs(&mut self, fd: usize, stat: &mut StatVfs) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn fstatvfs(&mut self, _inode: usize, stat: &mut StatVfs) -> Result { let abi_stat = libredox::call::fstatvfs(self.filesystem.memory_file.as_raw_fd() as usize)?; // TODO: From impl *stat = StatVfs { @@ -558,18 +447,14 @@ impl SchemeMut for Scheme { Ok(0) } - fn fsync(&mut self, fd: usize) -> Result { - if !self.handles.contains_key(&fd) { - return Err(Error::new(EBADF)); - } + fn fsync(&mut self, _inode: usize) -> Result { Ok(0) } - fn ftruncate(&mut self, fd: usize, size: usize) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + fn ftruncate(&mut self, inode: usize, size: usize) -> Result { let file = self .filesystem .files - .get_mut(&handle.inode) + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; if file.mode & MODE_TYPE == MODE_DIR { @@ -589,12 +474,11 @@ impl SchemeMut for Scheme { } Ok(0) } - fn futimens(&mut self, fd: usize, times: &[TimeSpec]) -> Result { - let handle = self.handles.get_mut(&fd).ok_or(Error::new(EBADF))?; + fn futimens(&mut self, inode: usize, times: &[TimeSpec]) -> Result { let file = self .filesystem .files - .get_mut(&handle.inode) + .get_mut(&inode) .ok_or(Error::new(EBADFD))?; let new_atime = *times.get(0).ok_or(Error::new(EINVAL))?; @@ -605,32 +489,21 @@ impl SchemeMut for Scheme { Ok(0) } - fn close(&mut self, fd: usize) -> Result { - let inode_num = self.handles.remove(&fd).ok_or(Error::new(EBADF))?.inode; - let inode = self + fn close(&mut self, inode: usize) -> Result { + let inode_info = self .filesystem .files - .get_mut(&inode_num) + .get_mut(&inode) .ok_or(Error::new(EIO))?; - inode.open_handles -= 1; + inode_info.open_handles -= 1; - if inode.nlink == 0 && inode.open_handles == 0 { - self.filesystem.files.remove(&inode_num); + if inode_info.nlink == 0 && inode_info.open_handles == 0 { + self.filesystem.files.remove(&inode); } Ok(0) } } -fn div_round_up(numer: T, denom: T) -> T -where - T: Copy - + ops::Add - + ops::Sub - + ops::Div - + From, -{ - (numer + (denom - T::from(1u8))) / denom -} pub fn current_perm(file: &crate::filesystem::File, uid: u32, gid: u32) -> u8 { let perm = file.mode & MODE_PERM; From e553969a71d4da5fc70e0b1f87e7edcd3cc0d9bd Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Fri, 13 Sep 2024 14:38:52 +0200 Subject: [PATCH 28/30] Implement fpath. --- src/filesystem.rs | 2 ++ src/scheme.rs | 41 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 40 insertions(+), 3 deletions(-) diff --git a/src/filesystem.rs b/src/filesystem.rs index ed180bd618..2848b4c7b7 100644 --- a/src/filesystem.rs +++ b/src/filesystem.rs @@ -16,6 +16,7 @@ pub struct File { pub uid: u32, pub gid: u32, pub nlink: usize, + pub parent: Inode, pub open_handles: usize, @@ -76,6 +77,7 @@ impl Filesystem { gid: 0, data: FileData::Directory(IndexMap::new()), + parent: Inode(Self::ROOT_INODE), } } pub fn get_block_size(&self) -> Result { diff --git a/src/scheme.rs b/src/scheme.rs index c103abb74a..0318c009b9 100644 --- a/src/scheme.rs +++ b/src/scheme.rs @@ -1,4 +1,6 @@ use std::convert::{TryFrom, TryInto}; +use std::io::{Cursor, Seek}; +use std::iter; use std::os::unix::io::AsRawFd; use indexmap::IndexMap; @@ -191,6 +193,7 @@ impl SchemeMut for Scheme { nlink: 2, // parent entry, "." data: FileData::Directory(IndexMap::new()), open_handles: 1, + parent: Inode(parent_dir_inode), } } else { if mode & MODE_TYPE == 0 { @@ -211,6 +214,7 @@ impl SchemeMut for Scheme { nlink: 1, data: FileData::File(Vec::new()), open_handles: 1, + parent: Inode(parent_dir_inode), } }; let current_perm = current_perm(&new_inode, ctx.uid, ctx.gid); @@ -369,9 +373,40 @@ impl SchemeMut for Scheme { // TODO Err(Error::new(ENOSYS)) } - fn fpath(&mut self, _inode: usize, _buf: &mut [u8]) -> Result { - // TODO - Err(Error::new(ENOSYS)) + fn fpath(&mut self, mut current_inode: usize, buf: &mut [u8]) -> Result { + let mut chain = Vec::new(); + + let mut current_info = self + .filesystem + .files + .get(¤t_inode) + .ok_or(Error::new(EBADFD))?; + + while current_inode != Filesystem::ROOT_INODE { + let parent_info = self + .filesystem + .files + .get(¤t_info.parent.0) + .ok_or(Error::new(EBADFD))?; + + let FileData::Directory(ref dir) = parent_info.data else { + return Err(Error::new(EBADFD)); + }; + // TODO: error handling? + let (name, _) = dir.iter().find(|(_name, inode)| inode.0 == current_inode).ok_or(Error::new(ENOENT))?; + chain.push(&**name); + + current_inode = current_info.parent.0; + current_info = parent_info; + } + + let mut cursor = Cursor::new(buf); + for component in iter::once(self.scheme_name.trim_start_matches('/')).chain(chain.iter().copied().rev()) { + use std::io::Write; + + write!(cursor, "/{component}").unwrap(); + } + Ok(cursor.stream_position().unwrap() as usize) } fn frename(&mut self, _inode: usize, _path: &str, _uid: u32, _gid: u32) -> Result { // TODO From 662615b32d38e9f7a0160cf0eea65aee887e436b Mon Sep 17 00:00:00 2001 From: Andrey Turkin Date: Thu, 17 Oct 2024 08:45:24 +0300 Subject: [PATCH 29/30] Bump dependencies --- Cargo.lock | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0fed4b0899..3b1bfd4799 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,9 +4,9 @@ version = 3 [[package]] name = "autocfg" -version = "1.3.0" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" [[package]] name = "bitflags" @@ -22,15 +22,15 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "hashbrown" -version = "0.14.5" +version = "0.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb" [[package]] name = "indexmap" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5" +checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da" dependencies = [ "equivalent", "hashbrown", @@ -38,9 +38,9 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.158" +version = "0.2.160" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439" +checksum = "f0b21006cd1874ae9e650973c565615676dc4a274c965bb0a73796dac838ce4f" [[package]] name = "libredox" @@ -77,9 +77,9 @@ dependencies = [ [[package]] name = "redox-scheme" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98d040cfa6370d9c6b1a5987247272f19ea4722f1064e66ad2e077c152b82ea3" +checksum = "95624e20d2c1808f7ca0820720d30aad9f5d2fc404e1ef379431ad7a790c3f7e" dependencies = [ "libredox", "redox_syscall", @@ -87,9 +87,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.4" +version = "0.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0884ad60e090bf1345b93da0a5de8923c93884cd03f40dfcfddd3b4bee661853" +checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" dependencies = [ "bitflags", ] From 306433d0a553bbea81c7ef92a233d215dff1cf62 Mon Sep 17 00:00:00 2001 From: Ribbon Date: Thu, 9 Jan 2025 12:06:21 +0000 Subject: [PATCH 30/30] Document how to contribute and do development in the README --- README.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/README.md b/README.md index d1c0773204..16f2102005 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,18 @@ # ramfs A mountable filesystem, which contents is stored in RAM. Useful for early logging, before `redoxfs` has been started. The `initfs:` scheme seems to lack read-write support, and thus this ramfs driver allows logs to be written in initfs drivers. + +## How To Contribute + +To learn how to contribute to this system component you need to read the following document: + +- [CONTRIBUTING.md](https://gitlab.redox-os.org/redox-os/redox/-/blob/master/CONTRIBUTING.md) + +## Development + +To learn how to do development with this system component inside the Redox build system you need to read the [Build System](https://doc.redox-os.org/book/build-system-reference.html) and [Coding and Building](https://doc.redox-os.org/book/coding-and-building.html) pages. + +### How To Build + +To build this system component you need to download the Redox build system, you can learn how to do it on the [Building Redox](https://doc.redox-os.org/book/podman-build.html) page. + +This is necessary because they only work with cross-compilation to a Redox virtual machine, but you can do some testing from Linux.