From 3bfa5a4889ac5789afa7be0e2f19fff262ec504d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 13 Dec 2025 12:57:41 +0100
Subject: [PATCH] zerod: Update to redox-scheme 0.8

---
 Cargo.lock          | 12 +---------
 zerod/Cargo.toml    |  2 +-
 zerod/src/main.rs   | 10 +++++----
 zerod/src/scheme.rs | 53 ++++++++++++++++++++++++++++++---------------
 4 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 967e94379a..7dec46fcb9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1621,16 +1621,6 @@ dependencies = [
  "redox_syscall",
 ]
 
-[[package]]
-name = "redox-scheme"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6143c4d307e1c99ac14f60b5b07b2dccaf9d17137f7cee4e4e29977dd8014a1b"
-dependencies = [
- "libredox",
- "redox_syscall",
-]
-
 [[package]]
 name = "redox-scheme"
 version = "0.3.0"
@@ -2676,6 +2666,6 @@ version = "0.1.0"
 dependencies = [
  "daemon",
  "libredox",
- "redox-scheme 0.2.4",
+ "redox-scheme 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "redox_syscall",
 ]
diff --git a/zerod/Cargo.toml b/zerod/Cargo.toml
index 552979929c..94f8780326 100644
--- a/zerod/Cargo.toml
+++ b/zerod/Cargo.toml
@@ -6,6 +6,6 @@ edition = "2021"
 
 [dependencies]
 redox_syscall = "0.5"
-redox-scheme = "0.2.1"
+redox-scheme = "0.8.2"
 daemon = { path = "../daemon" }
 libredox = "0.1.3"
diff --git a/zerod/src/main.rs b/zerod/src/main.rs
index f34ec93bc3..5e884d2cd3 100644
--- a/zerod/src/main.rs
+++ b/zerod/src/main.rs
@@ -1,4 +1,5 @@
-use redox_scheme::{RequestKind, SignalBehavior, Socket, V2};
+use redox_scheme::scheme::SchemeSync;
+use redox_scheme::{RequestKind, SignalBehavior, Socket};
 
 use scheme::ZeroScheme;
 
@@ -24,7 +25,7 @@ fn daemon(daemon: daemon::Daemon) -> ! {
         Ty::Null => "null",
         Ty::Zero => "zero",
     };
-    let socket = Socket::<V2>::create(name).expect("zerod: failed to create zero scheme");
+    let socket = Socket::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");
@@ -40,12 +41,13 @@ fn daemon(daemon: daemon::Daemon) -> ! {
         };
         match request.kind() {
             RequestKind::Call(request) => {
-                let response = request.handle_scheme_mut(&mut zero_scheme);
+                let response = request.handle_sync(&mut zero_scheme);
 
                 socket
-                    .write_responses(&[response], SignalBehavior::Restart)
+                    .write_response(response, SignalBehavior::Restart)
                     .expect("zerod: failed to write responses to zero scheme");
             }
+            RequestKind::OnClose { id } => zero_scheme.on_close(id),
             _ => (),
         }
     }
diff --git a/zerod/src/scheme.rs b/zerod/src/scheme.rs
index 2071d816bf..dc13043aa3 100644
--- a/zerod/src/scheme.rs
+++ b/zerod/src/scheme.rs
@@ -1,16 +1,28 @@
-use redox_scheme::SchemeMut;
+use redox_scheme::scheme::SchemeSync;
+use redox_scheme::{CallerCtx, OpenResult};
+use syscall::schemev2::NewFdFlags;
 use syscall::{error::*, MODE_CHR};
 
 use crate::Ty;
 
 pub struct ZeroScheme(pub Ty);
 
-impl SchemeMut for ZeroScheme {
-    fn open(&mut self, _path: &str, _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
-        Ok(0)
+impl SchemeSync for ZeroScheme {
+    fn open(&mut self, _path: &str, _flags: usize, _ctx: &CallerCtx) -> Result<OpenResult> {
+        Ok(OpenResult::ThisScheme {
+            number: 0,
+            flags: NewFdFlags::empty(),
+        })
     }
 
-    fn read(&mut self, _file: usize, buf: &mut [u8], _offset: u64, _flags: u32) -> Result<usize> {
+    fn read(
+        &mut self,
+        _file: usize,
+        buf: &mut [u8],
+        _offset: u64,
+        _flags: u32,
+        _ctx: &CallerCtx,
+    ) -> Result<usize> {
         match self.0 {
             Ty::Null => Ok(0),
             Ty::Zero => {
@@ -20,21 +32,28 @@ impl SchemeMut for ZeroScheme {
         }
     }
 
-    fn write(&mut self, _file: usize, buffer: &[u8], _offset: u64, _flags: u32) -> Result<usize> {
+    fn write(
+        &mut self,
+        _file: usize,
+        buffer: &[u8],
+        _offset: u64,
+        _flags: u32,
+        _ctx: &CallerCtx,
+    ) -> Result<usize> {
         Ok(buffer.len())
     }
 
-    fn fcntl(&mut self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+    fn fcntl(&mut self, _id: usize, _cmd: usize, _arg: usize, _ctx: &CallerCtx) -> Result<usize> {
         Ok(0)
     }
-    fn fsize(&mut self, _id: usize) -> Result<u64> {
+    fn fsize(&mut self, _id: usize, _ctx: &CallerCtx) -> Result<u64> {
         Ok(0)
     }
-    fn ftruncate(&mut self, _id: usize, _len: usize) -> Result<usize> {
-        Ok(0)
+    fn ftruncate(&mut self, _id: usize, _len: u64, _ctx: &CallerCtx) -> Result<()> {
+        Ok(())
     }
 
-    fn fpath(&mut self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+    fn fpath(&mut self, _id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> Result<usize> {
         let scheme_path = b"zero:";
         let size = std::cmp::min(buf.len(), scheme_path.len());
 
@@ -43,21 +62,19 @@ impl SchemeMut for ZeroScheme {
         Ok(size)
     }
 
-    fn fsync(&mut self, _file: usize) -> Result<usize> {
-        Ok(0)
+    fn fsync(&mut self, _file: usize, _ctx: &CallerCtx) -> Result<()> {
+        Ok(())
     }
 
     /// Close the file `number`
-    fn close(&mut self, _file: usize) -> Result<usize> {
-        Ok(0)
-    }
-    fn fstat(&mut self, _: usize, stat: &mut syscall::Stat) -> Result<usize> {
+    fn on_close(&mut self, _file: usize) {}
+    fn fstat(&mut self, _: usize, stat: &mut syscall::Stat, _ctx: &CallerCtx) -> Result<()> {
         stat.st_mode = 0o666 | MODE_CHR;
         stat.st_size = 0;
         stat.st_blocks = 0;
         stat.st_blksize = 4096;
         stat.st_nlink = 1;
 
-        Ok(0)
+        Ok(())
     }
 }