Move logd to redox-scheme 0.5

Cargo.lock

@@ -486,7 +486,7 @@ version = "0.1.0"
 dependencies = [
  "libredox 0.1.3",
  "redox-daemon",
- "redox-scheme 0.2.4",
+ "redox-scheme 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "redox_syscall 0.5.11",
 ]
 

logd/Cargo.toml

@@ -8,4 +8,4 @@ edition = "2021"
 redox_syscall = "0.5"
 redox-daemon = "0.1.2"
 libredox = "0.1.3"
-redox-scheme = "0.2.1"
+redox-scheme = "0.5"

logd/src/main.rs

@@ -1,4 +1,4 @@
-use redox_scheme::{RequestKind, SignalBehavior, Socket, V2};
+use redox_scheme::{RequestKind, SignalBehavior, Socket};
 use std::env;
 use std::fs::OpenOptions;
 use std::process;
@@ -17,7 +17,7 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
         }
     }
 
-    let socket = Socket::<V2>::create("log").expect("logd: failed to create log scheme");
+    let socket = Socket::create("log").expect("logd: failed to create log scheme");
 
     libredox::call::setrens(0, 0).expect("logd: failed to enter null namespace");
 
@@ -31,13 +31,16 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
         .next_request(SignalBehavior::Restart)
         .expect("logd: failed to read events from log scheme")
     {
-        scheme.current_pid = request.context_id();
-
-        let RequestKind::Call(request) = request.kind() else {
-            continue;
+        let request = match request.kind() {
+            RequestKind::Call(call) => call,
+            RequestKind::OnClose { id } => {
+                scheme.on_close(id);
+                continue;
+            }
+            _ => continue,
         };
 
-        let response = request.handle_scheme_mut(&mut scheme);
+        let response = request.handle_sync(&mut scheme);
         socket
             .write_responses(&[response], SignalBehavior::Restart)
             .expect("logd: failed to write responses to log scheme");

logd/src/scheme.rs

@@ -4,8 +4,10 @@ use std::io::Write;
 use std::mem;
 use std::sync::mpsc::{self, Sender};
 
-use redox_scheme::SchemeMut;
+use redox_scheme::scheme::SchemeSync;
+use redox_scheme::{CallerCtx, OpenResult};
 use syscall::error::*;
+use syscall::schemev2::NewFdFlags;
 
 pub struct LogHandle {
     context: Box<str>,
@@ -16,7 +18,6 @@ pub struct LogScheme {
     next_id: usize,
     output_tx: Sender<Vec<u8>>,
     handles: BTreeMap<usize, LogHandle>,
-    pub current_pid: usize,
 }
 
 impl LogScheme {
@@ -36,13 +37,12 @@ impl LogScheme {
             next_id: 0,
             output_tx,
             handles: BTreeMap::new(),
-            current_pid: 0,
         }
     }
 }
 
-impl SchemeMut for LogScheme {
-    fn open(&mut self, path: &str, _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
+impl SchemeSync for LogScheme {
+    fn open(&mut self, path: &str, _flags: usize, _ctx: &CallerCtx) -> Result<OpenResult> {
         let id = self.next_id;
         self.next_id += 1;
 
@@ -54,10 +54,20 @@ impl SchemeMut for LogScheme {
             },
         );
 
-        Ok(id)
+        Ok(OpenResult::ThisScheme {
+            number: id,
+            flags: NewFdFlags::empty(),
+        })
     }
 
-    fn read(&mut self, id: usize, _buf: &mut [u8], _offset: u64, _flags: u32) -> Result<usize> {
+    fn read(
+        &mut self,
+        id: usize,
+        _buf: &mut [u8],
+        _offset: u64,
+        _flags: u32,
+        _ctx: &CallerCtx,
+    ) -> Result<usize> {
         let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
         // TODO
@@ -65,13 +75,17 @@ impl SchemeMut for LogScheme {
         Ok(0)
     }
 
-    fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _flags: u32) -> Result<usize> {
+    fn write(
+        &mut self,
+        id: usize,
+        buf: &[u8],
+        _offset: u64,
+        _flags: u32,
+        ctx: &CallerCtx,
+    ) -> Result<usize> {
         let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?;
 
-        let handle_buf = handle
-            .bufs
-            .entry(self.current_pid)
-            .or_insert_with(|| Vec::new());
+        let handle_buf = handle.bufs.entry(ctx.pid).or_insert_with(|| Vec::new());
 
         let mut i = 0;
         while i < buf.len() {
@@ -94,13 +108,13 @@ impl SchemeMut for LogScheme {
         Ok(i)
     }
 
-    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> {
         let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
         Ok(0)
     }
 
-    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 handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
         let scheme_path = b"log:";
@@ -122,19 +136,17 @@ impl SchemeMut for LogScheme {
         Ok(i)
     }
 
-    fn fsync(&mut self, id: usize) -> Result<usize> {
+    fn fsync(&mut self, id: usize, _ctx: &CallerCtx) -> Result<()> {
         let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
         //TODO: flush remaining data?
 
-        Ok(0)
-    }
-
-    fn close(&mut self, id: usize) -> Result<usize> {
-        self.handles.remove(&id).ok_or(Error::new(EBADF))?;
-
-        //TODO: flush remaining data?
-
-        Ok(0)
+        Ok(())
+    }
+}
+
+impl LogScheme {
+    pub fn on_close(&mut self, id: usize) {
+        self.handles.remove(&id);
     }
 }