vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

redbear-keymapd, redbear-ime: migrate to SchemeSync; redox-drm: test import; base bump

Browse Source
This commit is contained in:
vasilito
2026-07-09 12:53:23 +03:00
parent 8de5ae5184
commit 095055df4b
5 changed files with 91 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files
local/recipes/gpu/redox-drm/source/src/scheme.rs
+1 -1
View File
@@ -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};
local/recipes/system/redbear-ime/source/src/main.rs
+19 -12
View File
@@ -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));
}
}
}
local/recipes/system/redbear-ime/source/src/scheme.rs
+24 -18
View File
@@ -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<Option<usize>> {
impl SchemeSync for ImeScheme {
fn scheme_root(&mut self) -> Result<usize> {
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<OpenResult> {
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<Option<usize>> {
fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result<usize> {
let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?;
let content: Vec<u8> = 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<Option<usize>> {
fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result<usize> {
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<Option<usize>> {
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<Option<usize>> {
self.handles.remove(&id);
Ok(Some(0))
Ok(())
}
}
local/recipes/system/redbear-keymapd/source/src/main.rs
+19 -13
View File
@@ -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));
}
}
}
local/recipes/system/redbear-keymapd/source/src/scheme.rs
+28 -39
View File
@@ -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<Option<usize>> {
impl SchemeSync for KeymapScheme {
fn scheme_root(&mut self) -> Result<usize> {
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<OpenResult> {
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<Option<usize>> {
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<usize> {
let kind = { let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; handle.kind.clone() };
let content: Vec<u8> = 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<Option<usize>> {
fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32, _ctx: &CallerCtx) -> Result<usize> {
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<Option<isize>> {
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<Option<usize>> {
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<Option<usize>> {
self.handles.remove(&id);
Ok(Some(0))
}
fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<Option<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 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)
}
}