RedBear-OS/local/patches/base/P57-fbbootlogd-graceful-init.patch

diff --git a/drivers/graphics/fbbootlogd/src/main.rs b/drivers/graphics/fbbootlogd/src/main.rs
index 3e42d590..79c2119f 100644
--- a/drivers/graphics/fbbootlogd/src/main.rs
+++ b/drivers/graphics/fbbootlogd/src/main.rs
@@ -46,13 +46,17 @@ fn daemon(daemon: daemon::SchemeDaemon) -> ! {
         )
         .expect("fbbootlogd: failed to subscribe to scheme events");
 
-    event_queue
-        .subscribe(
-            scheme.input_handle.event_handle().as_raw_fd() as usize,
-            Source::Input,
-            event::EventFlags::READ,
-        )
-        .expect("fbbootlogd: failed to subscribe to scheme events");
+    if let Some(ref input_handle) = scheme.input_handle {
+        event_queue
+            .subscribe(
+                input_handle.event_handle().as_raw_fd() as usize,
+                Source::Input,
+                event::EventFlags::READ,
+            )
+            .expect("fbbootlogd: failed to subscribe to input events");
+    } else {
+        eprintln!("fbbootlogd: running without input handle (log-only mode)");
+    }
 
     {
         let log_fd = socket
@@ -76,6 +80,11 @@ fn daemon(daemon: daemon::SchemeDaemon) -> ! {
     // 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");
 
+    enum Action {
+        Input(Event),
+        Handoff,
+    }
+
     for event in event_queue {
         match event.expect("fbbootlogd: failed to get event").user_data {
             Source::Scheme => loop {
@@ -88,20 +97,31 @@ fn daemon(daemon: daemon::SchemeDaemon) -> ! {
                 }
             },
             Source::Input => {
-                let mut events = [Event::new(); 16];
-                loop {
-                    match scheme
-                        .input_handle
-                        .read_events(&mut events)
-                        .expect("fbbootlogd: error while reading events")
-                    {
-                        ConsumerHandleEvent::Events(&[]) => break,
-                        ConsumerHandleEvent::Events(events) => {
-                            for event in events {
-                                scheme.handle_input(&event);
+                let mut actions: Vec<Action> = Vec::new();
+                if let Some(ref mut input_handle) = scheme.input_handle {
+                    let mut events = [Event::new(); 16];
+                    loop {
+                        match input_handle
+                            .read_events(&mut events)
+                            .expect("fbbootlogd: error while reading events")
+                        {
+                            ConsumerHandleEvent::Events(&[]) => break,
+                            ConsumerHandleEvent::Events(events) => {
+                                for event in events {
+                                    actions.push(Action::Input(*event));
+                                }
+                            }
+                            ConsumerHandleEvent::Handoff => {
+                                actions.push(Action::Handoff);
+                                break;
                             }
                         }
-                        ConsumerHandleEvent::Handoff => {
+                    }
+                }
+                for action in actions {
+                    match action {
+                        Action::Input(event) => scheme.handle_input(&event),
+                        Action::Handoff => {
                             eprintln!("fbbootlogd: handoff requested");
                             scheme.handle_handoff();
                         }
diff --git a/drivers/graphics/fbbootlogd/src/scheme.rs b/drivers/graphics/fbbootlogd/src/scheme.rs
index 812c4a5b..53e4bc75 100644
--- a/drivers/graphics/fbbootlogd/src/scheme.rs
+++ b/drivers/graphics/fbbootlogd/src/scheme.rs
@@ -14,7 +14,7 @@ use syscall::schemev2::NewFdFlags;
 use syscall::{Error, Result, EACCES, EBADF, EINVAL, ENOENT};
 
 pub struct FbbootlogScheme {
-    pub input_handle: ConsumerHandle,
+    pub input_handle: Option<ConsumerHandle>,
     display_map: Option<V2DisplayMap>,
     text_screen: console_draw::TextScreen,
     text_buffer: console_draw::TextBuffer,
@@ -25,8 +25,16 @@ pub struct FbbootlogScheme {
 
 impl FbbootlogScheme {
     pub fn new() -> FbbootlogScheme {
+        let input_handle = match ConsumerHandle::bootlog_vt() {
+            Ok(handle) => Some(handle),
+            Err(err) => {
+                eprintln!("fbbootlogd: Failed to open vt (non-fatal): {err}");
+                None
+            }
+        };
+
         let mut scheme = FbbootlogScheme {
-            input_handle: ConsumerHandle::bootlog_vt().expect("fbbootlogd: Failed to open vt"),
+            input_handle,
             display_map: None,
             text_screen: console_draw::TextScreen::new(),
             text_buffer: console_draw::TextBuffer::new(1000),
@@ -41,8 +49,19 @@ impl FbbootlogScheme {
     }
 
     pub fn handle_handoff(&mut self) {
-        let new_display_handle = match self.input_handle.open_display_v2() {
-            Ok(display) => V2GraphicsHandle::from_file(display).unwrap(),
+        let Some(ref input_handle) = self.input_handle else {
+            eprintln!("fbbootlogd: No input handle, skipping display handoff");
+            return;
+        };
+
+        let new_display_handle = match input_handle.open_display_v2() {
+            Ok(display) => match V2GraphicsHandle::from_file(display) {
+                Ok(handle) => handle,
+                Err(err) => {
+                    eprintln!("fbbootlogd: Display v2 protocol not supported: {err}");
+                    return;
+                }
+            },
             Err(err) => {
                 eprintln!("fbbootlogd: No display present yet: {err}");
                 return;
diff --git a/drivers/graphics/fbcond/src/display.rs b/drivers/graphics/fbcond/src/display.rs
index eb09b97e..4e347475 100644
--- a/drivers/graphics/fbcond/src/display.rs
+++ b/drivers/graphics/fbcond/src/display.rs
@@ -31,7 +31,13 @@ impl Display {
                 return;
             }
         };
-        let new_display_handle = V2GraphicsHandle::from_file(display_file).unwrap();
+        let new_display_handle = match V2GraphicsHandle::from_file(display_file) {
+            Ok(handle) => handle,
+            Err(err) => {
+                log::error!("fbcond: Display v2 protocol not supported: {err}");
+                return;
+            }
+        };
 
         log::debug!("fbcond: Opened new display");
 
diff --git a/drivers/inputd/src/lib.rs b/drivers/inputd/src/lib.rs
index b68e8211..b3e8354c 100644
--- a/drivers/inputd/src/lib.rs
+++ b/drivers/inputd/src/lib.rs
@@ -77,14 +77,14 @@ impl ConsumerHandle {
         ));
         let display_path = display_path.to_str().unwrap();
 
-        let display_file =
-            libredox::call::open(display_path, (O_CLOEXEC | O_NONBLOCK | O_RDWR) as _, 0)
-                .map(|socket| unsafe { File::from_raw_fd(socket as RawFd) })
-                .unwrap_or_else(|err| {
-                    panic!("failed to open display {}: {}", display_path, err);
-                });
-
-        Ok(display_file)
+        libredox::call::open(display_path, (O_CLOEXEC | O_NONBLOCK | O_RDWR) as _, 0)
+            .map(|socket| unsafe { File::from_raw_fd(socket as RawFd) })
+            .map_err(|err| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("failed to open display {}: {}", display_path, err),
+                )
+            })
     }
 
     pub fn read_events<'a>(&self, events: &'a mut [Event]) -> io::Result<ConsumerHandleEvent<'a>> {