graphics: Introduce a separate daemon for the boot log

The daemon responsible for the boot log must never ever block to avoid deadlocks, but doing so while still accepting keyboard input is non-trivial. This commit splits the boot log out from fbcond into a separate daemon to make this a lot easier to implement. This will also allow making fbcond blocking again, which will simplify some things.
2024-12-24 21:05:26 +01:00
parent 911f966e15
commit 4e2f1a730c
13 changed files with 744 additions and 210 deletions
@@ -0,0 +1,202 @@
+use event::{user_data, EventQueue};
+use inputd::{ConsumerHandle, Damage};
+use libredox::errno::ESTALE;
+use libredox::flag;
+use orbclient::Event;
+use std::mem;
+use std::os::fd::BorrowedFd;
+use std::sync::mpsc::{self, Receiver, Sender};
+use std::sync::{Arc, Mutex};
+use std::{fs::File, io, os::unix::io::AsRawFd, slice};
+
+fn read_to_slice<T: Copy>(
+    file: BorrowedFd,
+    buf: &mut [T],
+) -> Result<usize, libredox::error::Error> {
+    unsafe {
+        libredox::call::read(
+            file.as_raw_fd() as usize,
+            slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len() * mem::size_of::<T>()),
+        )
+        .map(|count| count / mem::size_of::<T>())
+    }
+}
+
+fn display_fd_map(width: usize, height: usize, display_file: File) -> syscall::Result<DisplayMap> {
+    unsafe {
+        let display_ptr = libredox::call::mmap(libredox::call::MmapArgs {
+            fd: display_file.as_raw_fd() as usize,
+            offset: 0,
+            length: (width * height * 4),
+            prot: flag::PROT_READ | flag::PROT_WRITE,
+            flags: flag::MAP_SHARED,
+            addr: core::ptr::null_mut(),
+        })?;
+        let display_slice = slice::from_raw_parts_mut(display_ptr as *mut u32, width * height);
+        Ok(DisplayMap {
+            display_file: Arc::new(display_file),
+            offscreen: display_slice,
+            width,
+            height,
+        })
+    }
+}
+
+unsafe fn display_fd_unmap(image: *mut [u32]) {
+    let _ = libredox::call::munmap(image as *mut (), image.len());
+}
+
+pub struct DisplayMap {
+    display_file: Arc<File>,
+    pub offscreen: *mut [u32],
+    pub width: usize,
+    pub height: usize,
+}
+
+unsafe impl Send for DisplayMap {}
+unsafe impl Sync for DisplayMap {}
+
+impl Drop for DisplayMap {
+    fn drop(&mut self) {
+        unsafe {
+            display_fd_unmap(self.offscreen);
+        }
+    }
+}
+
+enum DisplayCommand {
+    SyncRects(Vec<Damage>),
+}
+
+pub struct Display {
+    cmd_tx: Sender<DisplayCommand>,
+    pub map: Arc<Mutex<DisplayMap>>,
+}
+
+impl Display {
+    pub fn open_first_vt() -> io::Result<Self> {
+        let input_handle = ConsumerHandle::for_vt(1)?;
+
+        let (display_file, width, height) = Self::open_display(&input_handle)?;
+
+        let map = Arc::new(Mutex::new(
+            display_fd_map(width, height, display_file)
+                .unwrap_or_else(|e| panic!("failed to map display: {e}")),
+        ));
+
+        let map_clone = map.clone();
+        std::thread::spawn(move || {
+            Self::handle_input_events(map_clone, input_handle);
+        });
+
+        let (cmd_tx, cmd_rx) = mpsc::channel();
+        let map_clone = map.clone();
+        std::thread::spawn(move || {
+            Self::handle_sync_rect(map_clone, cmd_rx);
+        });
+
+        Ok(Self { cmd_tx, map })
+    }
+
+    fn open_display(input_handle: &ConsumerHandle) -> io::Result<(File, usize, usize)> {
+        let display_file = input_handle.open_display()?;
+
+        let mut buf: [u8; 4096] = [0; 4096];
+        let count = libredox::call::fpath(display_file.as_raw_fd() as usize, &mut buf)
+            .unwrap_or_else(|e| {
+                panic!("Could not read display path with fpath(): {e}");
+            });
+
+        let url =
+            String::from_utf8(Vec::from(&buf[..count])).expect("Could not create Utf8 Url String");
+        let path = url.split(':').nth(1).expect("Could not get path from url");
+
+        let mut path_parts = path.split('/').skip(1);
+        let width = path_parts
+            .next()
+            .unwrap_or("")
+            .parse::<usize>()
+            .unwrap_or(0);
+        let height = path_parts
+            .next()
+            .unwrap_or("")
+            .parse::<usize>()
+            .unwrap_or(0);
+
+        Ok((display_file, width, height))
+    }
+
+    fn handle_input_events(map: Arc<Mutex<DisplayMap>>, input_handle: ConsumerHandle) {
+        let event_queue = EventQueue::new().expect("fbbootlogd: failed to create event queue");
+
+        user_data! {
+            enum Source {
+                Input,
+            }
+        }
+
+        // FIXME listen for resize events from inputd and handle them
+
+        event_queue
+            .subscribe(
+                input_handle.inner().as_raw_fd() as usize,
+                Source::Input,
+                event::EventFlags::READ,
+            )
+            .expect("fbbootlogd: failed to subscribe to scheme events");
+
+        let mut events = [Event::new(); 16];
+        for Source::Input in event_queue.map(|event| event.unwrap().user_data) {
+            match read_to_slice(input_handle.inner(), &mut events) {
+                Err(err) if err.errno() == ESTALE => {
+                    eprintln!("fbbootlogd: handoff requested");
+
+                    let (new_display_file, width, height) =
+                        Self::open_display(&input_handle).unwrap();
+
+                    match display_fd_map(width, height, new_display_file) {
+                        Ok(ok) => {
+                            *map.lock().unwrap() = ok;
+
+                            eprintln!("fbbootlogd: handoff finished");
+                        }
+                        Err(err) => {
+                            eprintln!("fbbootlogd: failed to open display: {}", err);
+                        }
+                    }
+                }
+
+                Ok(_count) => {}
+                Err(err) => {
+                    panic!("fbbootlogd: error while reading events: {err}");
+                }
+            }
+        }
+    }
+
+    fn handle_sync_rect(map: Arc<Mutex<DisplayMap>>, cmd_rx: Receiver<DisplayCommand>) {
+        while let Ok(cmd) = cmd_rx.recv() {
+            match cmd {
+                DisplayCommand::SyncRects(sync_rects) => unsafe {
+                    // We may not hold this lock across the write call to avoid deadlocking if the
+                    // graphics driver tries to write to the bootlog.
+                    let display_file = map.lock().unwrap().display_file.clone();
+                    libredox::call::write(
+                        display_file.as_raw_fd() as usize,
+                        slice::from_raw_parts(
+                            sync_rects.as_ptr() as *const u8,
+                            sync_rects.len() * mem::size_of::<Damage>(),
+                        ),
+                    )
+                    .unwrap();
+                },
+            }
+        }
+    }
+
+    pub fn sync_rects(&mut self, sync_rects: Vec<Damage>) {
+        self.cmd_tx
+            .send(DisplayCommand::SyncRects(sync_rects))
+            .unwrap();
+    }
+}
@@ -0,0 +1,68 @@
+//! Fbbootlogd renders the boot log and presents it on VT1.
+//!
+//! While fbbootlogd is superficially similar to fbcond, there are two major differences:
+//!
+//! * Fbbootlogd doesn't accept input coming from the keyboard. It only allows getting written to.
+//! * Writing to fbbootlogd will never block. Not even on the graphics driver or inputd. This makes
+//!   it safe for graphics drivers and inputd to write to the boot log without risking deadlocks.
+//!   Fbcond will block on the graphics driver during handoff and will continously block on inputd
+//!   to get new input. Fbbootlogd does all blocking operations in background threads such that the
+//!   main thread will always keep accepting new input and writing it to the framebuffer.
+
+#![feature(io_error_more)]
+
+use redox_scheme::{RequestKind, SignalBehavior, Socket, V2};
+
+use crate::scheme::FbbootlogScheme;
+
+mod display;
+mod scheme;
+mod text;
+
+fn main() {
+    redox_daemon::Daemon::new(|daemon| inner(daemon)).expect("failed to create daemon");
+}
+fn inner(daemon: redox_daemon::Daemon) -> ! {
+    let socket: Socket<V2> =
+        Socket::create("fbbootlog").expect("fbbootlogd: failed to create fbbootlog scheme");
+
+    let mut scheme = FbbootlogScheme::new();
+
+    let mut inputd_control_handle = inputd::ControlHandle::new().unwrap();
+
+    // This is not possible for now as fbbootlogd needs to open new displays at runtime for graphics
+    // driver handoff. In the future inputd may directly pass a handle to the display instead.
+    //libredox::call::setrens(0, 0).expect("fbbootlogd: failed to enter null namespace");
+
+    daemon.ready().expect("failed to notify parent");
+
+    inputd_control_handle.activate_vt(1).unwrap();
+
+    loop {
+        let request = match socket
+            .next_request(SignalBehavior::Restart)
+            .expect("fbbootlogd: failed to read display scheme")
+        {
+            Some(request) => request,
+            None => {
+                // Scheme likely got unmounted
+                std::process::exit(0);
+            }
+        };
+
+        match request.kind() {
+            RequestKind::Call(call_request) => {
+                socket
+                    .write_response(
+                        call_request.handle_scheme_mut(&mut scheme),
+                        SignalBehavior::Restart,
+                    )
+                    .expect("fbbootlogd: failed to write display scheme");
+            }
+            RequestKind::Cancellation(_cancellation_request) => {}
+            RequestKind::MsyncMsg | RequestKind::MunmapMsg | RequestKind::MmapMsg => {
+                unreachable!()
+            }
+        }
+    }
+}
@@ -0,0 +1,124 @@
+use std::collections::BTreeMap;
+
+use redox_scheme::SchemeMut;
+use syscall::{Error, EventFlags, Result, EBADF, EINVAL, ENOENT};
+
+use crate::display::Display;
+use crate::text::TextScreen;
+
+#[derive(Clone)]
+pub struct Handle {
+    pub events: EventFlags,
+    pub notified_read: bool,
+}
+
+pub struct FbbootlogScheme {
+    pub screen: TextScreen,
+    next_id: usize,
+    pub handles: BTreeMap<usize, Handle>,
+}
+
+impl FbbootlogScheme {
+    pub fn new() -> FbbootlogScheme {
+        let display = Display::open_first_vt().expect("Failed to open display for vt");
+        let screen = TextScreen::new(display);
+
+        FbbootlogScheme {
+            screen,
+            next_id: 0,
+            handles: BTreeMap::new(),
+        }
+    }
+}
+
+impl SchemeMut for FbbootlogScheme {
+    fn open(&mut self, path_str: &str, _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
+        if !path_str.is_empty() {
+            return Err(Error::new(ENOENT));
+        }
+
+        let id = self.next_id;
+        self.next_id += 1;
+
+        self.handles.insert(
+            id,
+            Handle {
+                events: EventFlags::empty(),
+                notified_read: false,
+            },
+        );
+
+        Ok(id)
+    }
+
+    fn dup(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
+        if !buf.is_empty() {
+            return Err(Error::new(EINVAL));
+        }
+
+        let handle = self
+            .handles
+            .get(&id)
+            .map(|handle| handle.clone())
+            .ok_or(Error::new(EBADF))?;
+
+        let new_id = self.next_id;
+        self.next_id += 1;
+
+        self.handles.insert(new_id, handle);
+
+        Ok(new_id)
+    }
+
+    fn fevent(&mut self, id: usize, flags: syscall::EventFlags) -> Result<syscall::EventFlags> {
+        let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?;
+
+        handle.notified_read = false;
+
+        handle.events = flags;
+        Ok(syscall::EventFlags::empty())
+    }
+
+    fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        let path = b"fbbootlog:";
+
+        let mut i = 0;
+        while i < buf.len() && i < path.len() {
+            buf[i] = path[i];
+            i += 1;
+        }
+
+        Ok(i)
+    }
+
+    fn fsync(&mut self, id: usize) -> Result<usize> {
+        let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        return Ok(0);
+    }
+
+    fn read(
+        &mut self,
+        id: usize,
+        _buf: &mut [u8],
+        _offset: u64,
+        _fcntl_flags: u32,
+    ) -> Result<usize> {
+        let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        Err(Error::new(EINVAL))
+    }
+
+    fn write(&mut self, id: usize, buf: &[u8], _offset: u64, _fcntl_flags: u32) -> Result<usize> {
+        let _handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        self.screen.write(buf)
+    }
+
+    fn close(&mut self, id: usize) -> Result<usize> {
+        self.handles.remove(&id).ok_or(Error::new(EBADF))?;
+        Ok(0)
+    }
+}
@@ -0,0 +1,41 @@
+extern crate ransid;
+
+use std::collections::VecDeque;
+
+use syscall::error::*;
+
+use crate::display::Display;
+
+pub struct TextScreen {
+    pub display: Display,
+    inner: console_draw::TextScreen,
+}
+
+impl TextScreen {
+    pub fn new(display: Display) -> TextScreen {
+        TextScreen {
+            display,
+            inner: console_draw::TextScreen::new(),
+        }
+    }
+}
+
+impl TextScreen {
+    pub fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        let map = self.display.map.lock().unwrap();
+        let damage = self.inner.write(
+            &mut console_draw::DisplayMap {
+                offscreen: map.offscreen,
+                width: map.width,
+                height: map.height,
+            },
+            buf,
+            &mut VecDeque::new(),
+        );
+        drop(map);
+
+        self.display.sync_rects(damage);
+
+        Ok(buf.len())
+    }
+}