From 095055df4b7b9ed8d32b6b487fdaef269c221a8c Mon Sep 17 00:00:00 2001 From: vasilito Date: Thu, 9 Jul 2026 12:53:23 +0300 Subject: [PATCH] redbear-keymapd, redbear-ime: migrate to SchemeSync; redox-drm: test import; base bump --- .../gpu/redox-drm/source/src/scheme.rs | 2 +- .../system/redbear-ime/source/src/main.rs | 31 +++++---- .../system/redbear-ime/source/src/scheme.rs | 42 +++++++----- .../system/redbear-keymapd/source/src/main.rs | 32 +++++---- .../redbear-keymapd/source/src/scheme.rs | 67 ++++++++----------- 5 files changed, 91 insertions(+), 83 deletions(-) diff --git a/local/recipes/gpu/redox-drm/source/src/scheme.rs b/local/recipes/gpu/redox-drm/source/src/scheme.rs index 2f21c266c8..aca3cacbff 100644 --- a/local/recipes/gpu/redox-drm/source/src/scheme.rs +++ b/local/recipes/gpu/redox-drm/source/src/scheme.rs @@ -1733,7 +1733,7 @@ mod tests { use std::collections::BTreeMap; use std::sync::{Arc, Mutex}; - use redox_scheme::SchemeBlockMut; + use redox_scheme::scheme::SchemeSync; use super::*; use crate::driver::{DriverError, DriverEvent, GpuDriver}; diff --git a/local/recipes/system/redbear-ime/source/src/main.rs b/local/recipes/system/redbear-ime/source/src/main.rs index 52fd42d0f7..5a221b8546 100644 --- a/local/recipes/system/redbear-ime/source/src/main.rs +++ b/local/recipes/system/redbear-ime/source/src/main.rs @@ -3,18 +3,23 @@ mod scheme; use scheme::ImeScheme; use std::io::Write; +use redox_scheme::{RequestKind, SignalBehavior, Socket}; +use redox_scheme::scheme::{register_sync_scheme, SchemeState, SchemeSync}; + fn log_msg(level: &str, msg: &str) { let _ = writeln!(std::io::stderr(), "[ime] {} {}", level, msg); } fn main() { let mut scheme = ImeScheme::new(); + let mut state = SchemeState::new(); - let socket = redox_scheme::Socket::create("ime").expect("ime: failed to register scheme:ime"); + let socket = Socket::create().expect("ime: failed to create scheme socket"); + register_sync_scheme(&socket, "ime", &mut scheme).expect("ime: failed to register scheme:ime"); log_msg("INFO", "registered scheme:ime"); loop { - let request = match socket.next_request(redox_scheme::SignalBehavior::Restart) { + let request = match socket.next_request(SignalBehavior::Restart) { Ok(Some(r)) => r, Ok(None) => { log_msg("INFO", "scheme unmounted, exiting"); @@ -26,17 +31,19 @@ fn main() { } }; - match request.handle_scheme_block_mut(&mut scheme) { - Ok(response) => { - if let Err(e) = - socket.write_response(response, redox_scheme::SignalBehavior::Restart) - { - log_msg("ERROR", &format!("failed to write response: {}", e)); - } - } - Err(_request) => { - log_msg("ERROR", "unhandled scheme request"); + let req = match request.kind() { + RequestKind::Call(c) => c, + RequestKind::OnClose { id } => { + scheme.on_close(id); + state.on_close(id); + continue; } + _ => continue, + }; + + let response = req.handle_sync(&mut scheme, &mut state); + if let Err(e) = socket.write_response(response, SignalBehavior::Restart) { + log_msg("ERROR", &format!("failed to write response: {}", e)); } } } diff --git a/local/recipes/system/redbear-ime/source/src/scheme.rs b/local/recipes/system/redbear-ime/source/src/scheme.rs index 05a81cd612..99e69d1cff 100644 --- a/local/recipes/system/redbear-ime/source/src/scheme.rs +++ b/local/recipes/system/redbear-ime/source/src/scheme.rs @@ -1,8 +1,11 @@ use std::collections::HashMap; +use redox_scheme::{CallerCtx, OpenResult}; +use redox_scheme::scheme::SchemeSync; use syscall::data::Stat; use syscall::error::{Error, Result, EBADF, EINVAL, ENOENT}; use syscall::flag::{MODE_DIR, MODE_FILE}; +use syscall::schemev2::NewFdFlags; #[derive(Clone, Debug, Default)] struct InputState { @@ -251,8 +254,15 @@ impl ImeScheme { } } -impl redox_scheme::SchemeBlockMut for ImeScheme { - fn open(&mut self, path: &str, _flags: usize, _uid: u32, _gid: u32) -> Result> { +impl SchemeSync for ImeScheme { + fn scheme_root(&mut self) -> Result { + let id = self.next_id; + self.next_id += 1; + self.handles.insert(id, Handle { kind: HandleKind::Root, offset: 0 }); + Ok(id) + } + + fn openat(&mut self, _dirfd: usize, path: &str, _flags: usize, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result { let cleaned = path.trim_matches('/'); let kind = match cleaned { "" => HandleKind::Root, @@ -265,10 +275,10 @@ impl redox_scheme::SchemeBlockMut for ImeScheme { let id = self.next_id; self.next_id += 1; self.handles.insert(id, Handle { kind, offset: 0 }); - Ok(Some(id)) + Ok(OpenResult::ThisScheme { number: id, flags: NewFdFlags::empty() }) } - fn read(&mut self, id: usize, buf: &mut [u8]) -> Result> { + fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result { let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?; let content: Vec = match &handle.kind { @@ -288,17 +298,18 @@ impl redox_scheme::SchemeBlockMut for ImeScheme { } }; - if handle.offset >= content.len() { - return Ok(Some(0)); + let offset = offset as usize; + if offset >= content.len() { + return Ok(0); } - let remaining = &content[handle.offset..]; + let remaining = &content[offset..]; let to_copy = remaining.len().min(buf.len()); buf[..to_copy].copy_from_slice(&remaining[..to_copy]); - handle.offset += to_copy; - Ok(Some(to_copy)) + handle.offset = offset + to_copy; + Ok(to_copy) } - fn write(&mut self, id: usize, buf: &[u8]) -> Result> { + fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; match &handle.kind { HandleKind::Compose => { @@ -332,23 +343,18 @@ impl redox_scheme::SchemeBlockMut for ImeScheme { .unwrap_or(false); self.feed(scancode, pressed, shift, altgr); } - Ok(Some(buf.len())) + Ok(buf.len()) } _ => Err(Error::new(EINVAL)), } } - fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result> { + fn fstat(&mut self, id: usize, stat: &mut Stat, _ctx: &CallerCtx) -> Result<()> { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; match &handle.kind { HandleKind::Root => stat.st_mode = MODE_DIR | 0o555, _ => stat.st_mode = MODE_FILE | 0o644, } - Ok(Some(0)) - } - - fn close(&mut self, id: usize) -> Result> { - self.handles.remove(&id); - Ok(Some(0)) + Ok(()) } } diff --git a/local/recipes/system/redbear-keymapd/source/src/main.rs b/local/recipes/system/redbear-keymapd/source/src/main.rs index 4fd91f0b7e..512033064b 100644 --- a/local/recipes/system/redbear-keymapd/source/src/main.rs +++ b/local/recipes/system/redbear-keymapd/source/src/main.rs @@ -5,6 +5,8 @@ mod xkb; use std::env; use std::io::Write; +use redox_scheme::{RequestKind, SignalBehavior, Socket}; +use redox_scheme::scheme::{register_sync_scheme, SchemeState, SchemeSync}; use scheme::KeymapScheme; fn log_msg(level: &str, msg: &str) { @@ -13,6 +15,7 @@ fn log_msg(level: &str, msg: &str) { fn main() { let mut scheme = KeymapScheme::new(); + let mut state = SchemeState::new(); let builtins = keymap::BuiltinKeymaps::new(); scheme.load_builtin(&builtins); @@ -47,12 +50,13 @@ fn main() { &format!("loaded {} keymap(s)", scheme.keymap_count()), ); - let socket = - redox_scheme::Socket::create("keymap").expect("keymapd: failed to register scheme:keymap"); + let socket = Socket::create().expect("keymapd: failed to create scheme socket"); + register_sync_scheme(&socket, "keymap", &mut scheme) + .expect("keymapd: failed to register scheme:keymap"); log_msg("INFO", "registered scheme:keymap"); loop { - let request = match socket.next_request(redox_scheme::SignalBehavior::Restart) { + let request = match socket.next_request(SignalBehavior::Restart) { Ok(Some(r)) => r, Ok(None) => { log_msg("INFO", "scheme unmounted, exiting"); @@ -64,17 +68,19 @@ fn main() { } }; - match request.handle_scheme_block_mut(&mut scheme) { - Ok(response) => { - if let Err(e) = - socket.write_response(response, redox_scheme::SignalBehavior::Restart) - { - log_msg("ERROR", &format!("failed to write response: {}", e)); - } - } - Err(_request) => { - log_msg("ERROR", "unhandled scheme request"); + let req = match request.kind() { + RequestKind::Call(c) => c, + RequestKind::OnClose { id } => { + scheme.on_close(id); + state.on_close(id); + continue; } + _ => continue, + }; + + let response = req.handle_sync(&mut scheme, &mut state); + if let Err(e) = socket.write_response(response, SignalBehavior::Restart) { + log_msg("ERROR", &format!("failed to write response: {}", e)); } } } diff --git a/local/recipes/system/redbear-keymapd/source/src/scheme.rs b/local/recipes/system/redbear-keymapd/source/src/scheme.rs index f1f077a63c..f3fc8dfbf5 100644 --- a/local/recipes/system/redbear-keymapd/source/src/scheme.rs +++ b/local/recipes/system/redbear-keymapd/source/src/scheme.rs @@ -1,9 +1,12 @@ use std::collections::HashMap; use std::io; +use redox_scheme::{CallerCtx, OpenResult}; +use redox_scheme::scheme::SchemeSync; use syscall::data::Stat; use syscall::error::{Error, Result, EBADF, EINVAL, ENOENT}; -use syscall::flag::{MODE_DIR, MODE_FILE, SEEK_CUR, SEEK_END, SEEK_SET}; +use syscall::flag::{MODE_DIR, MODE_FILE}; +use syscall::schemev2::NewFdFlags; use crate::keymap::Keymap; @@ -102,8 +105,15 @@ impl KeymapScheme { } } -impl redox_scheme::SchemeBlockMut for KeymapScheme { - fn open(&mut self, path: &str, _flags: usize, _uid: u32, _gid: u32) -> Result> { +impl SchemeSync for KeymapScheme { + fn scheme_root(&mut self) -> Result { + let id = self.next_id; + self.next_id += 1; + self.handles.insert(id, Handle { kind: HandleKind::Root, offset: 0 }); + Ok(id) + } + + fn openat(&mut self, _dirfd: usize, path: &str, _flags: usize, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result { let cleaned = path.trim_matches('/'); let kind = if cleaned.is_empty() { @@ -138,14 +148,11 @@ impl redox_scheme::SchemeBlockMut for KeymapScheme { let id = self.next_id; self.next_id += 1; self.handles.insert(id, Handle { kind, offset: 0 }); - Ok(Some(id)) + Ok(OpenResult::ThisScheme { number: id, flags: NewFdFlags::empty() }) } - fn read(&mut self, id: usize, buf: &mut [u8]) -> Result> { - let (kind, offset) = { - let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; - (handle.kind.clone(), handle.offset) - }; + fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result { + let kind = { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; handle.kind.clone() }; let content: Vec = match &kind { HandleKind::Root => { @@ -190,18 +197,20 @@ impl redox_scheme::SchemeBlockMut for KeymapScheme { } }; - let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?; + let _handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?; + let offset = offset as usize; if offset >= content.len() { - return Ok(Some(0)); + return Ok(0); } let remaining = &content[offset..]; let to_copy = remaining.len().min(buf.len()); buf[..to_copy].copy_from_slice(&remaining[..to_copy]); - handle.offset += to_copy; - Ok(Some(to_copy)) + let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?; + handle.offset = offset + to_copy; + Ok(to_copy) } - fn write(&mut self, id: usize, buf: &[u8]) -> Result> { + fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; match &handle.kind { HandleKind::Active => { @@ -209,7 +218,7 @@ impl redox_scheme::SchemeBlockMut for KeymapScheme { let name = name.trim(); if self.keymaps.contains_key(name) { self.active_keymap = name.to_string(); - Ok(Some(buf.len())) + Ok(buf.len()) } else { Err(Error::new(ENOENT)) } @@ -218,22 +227,7 @@ impl redox_scheme::SchemeBlockMut for KeymapScheme { } } - fn seek(&mut self, id: usize, pos: isize, whence: usize) -> Result> { - let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?; - let new_offset = match whence { - SEEK_SET => pos as isize, - SEEK_CUR => handle.offset as isize + pos, - SEEK_END => pos, - _ => return Err(Error::new(EINVAL)), - }; - if new_offset < 0 { - return Err(Error::new(EINVAL)); - } - handle.offset = new_offset as usize; - Ok(Some(new_offset)) - } - - fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result> { + fn fstat(&mut self, id: usize, stat: &mut Stat, _ctx: &CallerCtx) -> Result<()> { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; match &handle.kind { HandleKind::Root => { @@ -243,15 +237,10 @@ impl redox_scheme::SchemeBlockMut for KeymapScheme { stat.st_mode = MODE_FILE | 0o644; } } - Ok(Some(0)) + Ok(()) } - fn close(&mut self, id: usize) -> Result> { - self.handles.remove(&id); - Ok(Some(0)) - } - - fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result> { + fn fpath(&mut self, id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> Result { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; let path = match &handle.kind { HandleKind::Root => "keymap:".to_string(), @@ -262,6 +251,6 @@ impl redox_scheme::SchemeBlockMut for KeymapScheme { let bytes = path.as_bytes(); let to_copy = bytes.len().min(buf.len()); buf[..to_copy].copy_from_slice(&bytes[..to_copy]); - Ok(Some(to_copy)) + Ok(to_copy) } }