Implement fsize+ftruncate, update, and rustfmt.

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"
@@ -37,9 +37,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",
@@ -47,9 +47,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",
 ]

Cargo.toml

@@ -6,6 +6,6 @@ edition = "2021"
 
 [dependencies]
 redox_syscall = "0.5"
-redox-scheme = "0.2"
+redox-scheme = "0.2.1"
 redox-daemon = "0.1.2"
 libredox = "0.1.3"

src/main.rs

@@ -1,4 +1,4 @@
-use redox_scheme::{RequestKind, SignalBehavior, Socket};
+use redox_scheme::{RequestKind, SignalBehavior, Socket, V2};
 
 use scheme::ZeroScheme;
 
@@ -21,26 +21,31 @@ fn main() {
             Ty::Null => "null",
             Ty::Zero => "zero",
         };
-        let socket = Socket::create(name).expect("zerod: failed to create zero scheme");
-        let zero_scheme = ZeroScheme(ty);
+        let socket = Socket::<V2>::create(name).expect("zerod: failed to create zero scheme");
+        let mut zero_scheme = ZeroScheme(ty);
 
         libredox::call::setrens(0, 0).expect("zerod: failed to enter null namespace");
 
         daemon.ready().expect("zerod: failed to notify parent");
 
         loop {
-            let Some(request) = socket.next_request(SignalBehavior::Restart).expect("zerod: failed to read events from zero scheme") else {
+            let Some(request) = socket
+                .next_request(SignalBehavior::Restart)
+                .expect("zerod: failed to read events from zero scheme")
+            else {
                 std::process::exit(0);
             };
             match request.kind() {
                 RequestKind::Call(request) => {
-                    let response = request.handle_scheme(&zero_scheme);
+                    let response = request.handle_scheme_mut(&mut zero_scheme);
 
-                    socket.write_responses(&[response], SignalBehavior::Restart).expect("zerod: failed to write responses to zero scheme");
+                    socket
+                        .write_responses(&[response], SignalBehavior::Restart)
+                        .expect("zerod: failed to write responses to zero scheme");
                 }
                 _ => (),
             }
-
         }
-    }).expect("zerod: failed to daemonize");
+    })
+    .expect("zerod: failed to daemonize");
 }

src/scheme.rs

@@ -1,16 +1,16 @@
+use redox_scheme::SchemeMut;
 use syscall::{error::*, MODE_CHR};
-use redox_scheme::Scheme;
 
 use crate::Ty;
 
 pub struct ZeroScheme(pub Ty);
 
-impl Scheme for ZeroScheme {
-    fn open(&self, _path: &str, _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
+impl SchemeMut for ZeroScheme {
+    fn open(&mut self, _path: &str, _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
         Ok(0)
     }
 
-    fn dup(&self, _file: usize, buf: &[u8]) -> Result<usize> {
+    fn dup(&mut self, _file: usize, buf: &[u8]) -> Result<usize> {
         if !buf.is_empty() {
             return Err(Error::new(EINVAL));
         }
@@ -18,7 +18,7 @@ impl Scheme for ZeroScheme {
         Ok(0)
     }
 
-    fn read(&self, _file: usize, buf: &mut [u8]) -> Result<usize> {
+    fn read(&mut self, _file: usize, buf: &mut [u8], _offset: u64, _flags: u32) -> Result<usize> {
         match self.0 {
             Ty::Null => Ok(0),
             Ty::Zero => {
@@ -28,15 +28,21 @@ impl Scheme for ZeroScheme {
         }
     }
 
-    fn write(&self, _file: usize, buffer: &[u8]) -> Result<usize> {
+    fn write(&mut self, _file: usize, buffer: &[u8], _offset: u64, _flags: u32) -> Result<usize> {
         Ok(buffer.len())
     }
 
-    fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+    fn fcntl(&mut self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+        Ok(0)
+    }
+    fn fsize(&mut self, _id: usize) -> Result<u64> {
+        Ok(0)
+    }
+    fn ftruncate(&mut self, _id: usize, _len: usize) -> Result<usize> {
         Ok(0)
     }
 
-    fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+    fn fpath(&mut self, _id: usize, buf: &mut [u8]) -> Result<usize> {
         let scheme_path = b"zero:";
         let size = std::cmp::min(buf.len(), scheme_path.len());
 
@@ -45,15 +51,15 @@ impl Scheme for ZeroScheme {
         Ok(size)
     }
 
-    fn fsync(&self, _file: usize) -> Result<usize> {
+    fn fsync(&mut self, _file: usize) -> Result<usize> {
         Ok(0)
     }
 
     /// Close the file `number`
-    fn close(&self, _file: usize) -> Result<usize> {
+    fn close(&mut self, _file: usize) -> Result<usize> {
         Ok(0)
     }
-    fn fstat(&self, _: usize, stat: &mut syscall::Stat) -> Result<usize> {
+    fn fstat(&mut self, _: usize, stat: &mut syscall::Stat) -> Result<usize> {
         stat.st_mode = 0o666 | MODE_CHR;
         stat.st_size = 0;
         stat.st_blocks = 0;