graphics/bgad: Use redox-scheme

Cargo.lock

@@ -193,6 +193,7 @@ dependencies = [
  "orbclient",
  "pcid",
  "redox-daemon",
+ "redox-scheme 0.3.0",
  "redox_syscall",
 ]
 

graphics/bgad/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "bgad"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 orbclient = "0.3.47"
 redox-daemon = "0.1"
+redox-scheme = { git = "https://gitlab.redox-os.org/redox-os/redox-scheme.git" }
 redox_syscall = "0.5"
 
 common = { path = "../../common" }

graphics/bgad/src/main.rs

@@ -1,14 +1,8 @@
-extern crate orbclient;
-extern crate syscall;
-
-use std::fs::File;
-use std::io::{Read, Write};
-
 use inputd::ProducerHandle;
 use pcid_interface::PciFunctionHandle;
+use redox_scheme::{RequestKind, Response, SignalBehavior, Socket};
 use syscall::call::iopl;
-use syscall::data::Packet;
-use syscall::scheme::SchemeMut;
+use syscall::EOPNOTSUPP;
 
 use crate::bga::Bga;
 use crate::scheme::BgaScheme;
@@ -28,7 +22,7 @@ fn main() {
     redox_daemon::Daemon::new(move |daemon| {
         unsafe { iopl(3).unwrap() };
 
-        let mut socket = File::create(":bga").expect("bgad: failed to create bga scheme");
+        let socket = Socket::create("bga").expect("bgad: failed to create bga scheme");
 
         let mut bga = Bga::new();
         println!("   - BGA {}x{}", bga.width(), bga.height());
@@ -45,20 +39,38 @@ fn main() {
         daemon.ready().expect("bgad: failed to notify parent");
 
         loop {
-            let mut packet = Packet::default();
-            if socket
-                .read(&mut packet)
-                .expect("bgad: failed to read events from bga scheme")
-                == 0
-            {
-                break;
+            let Some(request) = socket
+                .next_request(SignalBehavior::Restart)
+                .expect("bgad: failed to read scheme")
+            else {
+                // Scheme likely got unmounted
+                std::process::exit(0);
+            };
+
+            match request.kind() {
+                RequestKind::Call(call_request) => {
+                    let resp = call_request.handle_scheme(&mut scheme);
+                    socket
+                        .write_response(resp, SignalBehavior::Restart)
+                        .expect("bgad: failed to write display scheme");
+                }
+                RequestKind::SendFd(sendfd_request) => {
+                    socket
+                        .write_response(
+                            Response::for_sendfd(
+                                &sendfd_request,
+                                Err(syscall::Error::new(EOPNOTSUPP)),
+                            ),
+                            SignalBehavior::Restart,
+                        )
+                        .expect("bgad: failed to write response");
+                }
+                RequestKind::Cancellation(_cancellation_request) => {}
+                RequestKind::MsyncMsg | RequestKind::MunmapMsg | RequestKind::MmapMsg => {
+                    unreachable!()
+                }
             }
-            scheme.handle(&mut packet);
-            socket
-                .write(&packet)
-                .expect("bgad: failed to write responses to bga scheme");
         }
-        std::process::exit(0);
     })
     .expect("bgad: failed to daemonize");
 }

graphics/bgad/src/scheme.rs

@@ -1,7 +1,8 @@
 use inputd::ProducerHandle;
+use redox_scheme::Scheme;
 use std::str;
 use syscall::data::Stat;
-use syscall::{Error, Result, SchemeMut, EACCES, EINVAL, MODE_CHR};
+use syscall::{Error, Result, EACCES, EINVAL, MODE_CHR};
 
 use crate::bga::Bga;
 
@@ -24,7 +25,7 @@ impl BgaScheme {
     }
 }
 
-impl SchemeMut for BgaScheme {
+impl Scheme for BgaScheme {
     fn open(&mut self, _path: &str, _flags: usize, uid: u32, _gid: u32) -> Result<usize> {
         if uid == 0 {
             Ok(0)
@@ -33,7 +34,13 @@ impl SchemeMut for BgaScheme {
         }
     }
 
-    fn read(&mut self, _file: usize, buf: &mut [u8]) -> Result<usize> {
+    fn read(
+        &mut self,
+        _id: usize,
+        buf: &mut [u8],
+        _offset: u64,
+        _fcntl_flags: u32,
+    ) -> Result<usize> {
         let mut i = 0;
         let data = format!("{},{}\n", self.bga.width(), self.bga.height()).into_bytes();
         while i < buf.len() && i < data.len() {
@@ -43,7 +50,7 @@ impl SchemeMut for BgaScheme {
         Ok(i)
     }
 
-    fn write(&mut self, _file: usize, buf: &[u8]) -> Result<usize> {
+    fn write(&mut self, _id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32) -> Result<usize> {
         let string = str::from_utf8(buf).or(Err(Error::new(EINVAL)))?;
         let string = string.trim();