From 8f319d4081920fa179084bb8802a2d88bfb1074f Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 12 Jul 2025 16:58:35 +0200
Subject: [PATCH] logd: Improve implementation of kernel log copying

I hadn't meant to upstream it yet. I accidentally added it in a commit
touching the netstack. In any case this commit integrates the kernel log
copying directly into LogScheme.

The kernel log copying is meant to show the kernel log on the fbbootlogd
rendered bootlog. Even once the kernel graphical debug has been disabled
or if it never got enabled due to the bootloader not presenting a
framebuffer.
---
 logd/src/main.rs   | 20 --------------
 logd/src/scheme.rs | 67 +++++++++++++++++++++++++++++++---------------
 2 files changed, 46 insertions(+), 41 deletions(-)

diff --git a/logd/src/main.rs b/logd/src/main.rs
index 4368d2b99b..32675921cd 100644
--- a/logd/src/main.rs
+++ b/logd/src/main.rs
@@ -1,5 +1,4 @@
 use redox_scheme::{RequestKind, SignalBehavior, Socket};
-use std::io::{Read, Write};
 use std::process;
 
 use crate::scheme::LogScheme;
@@ -9,11 +8,6 @@ mod scheme;
 fn daemon(daemon: redox_daemon::Daemon) -> ! {
     let socket = Socket::create("log").expect("logd: failed to create log scheme");
 
-    std::process::Command::new(std::env::current_exe().unwrap())
-        .arg("--internal-copy-kernel-log")
-        .spawn()
-        .unwrap();
-
     eprintln!("logd: ready for logging on log:");
 
     daemon.ready().expect("logd: failed to notify parent");
@@ -42,19 +36,5 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
 }
 
 fn main() {
-    if std::env::args().nth(1).as_deref() == Some("--internal-copy-kernel-log") {
-        let mut debug_file = std::fs::File::open("/scheme/sys/log").unwrap();
-        let mut log_file = std::fs::OpenOptions::new()
-            .write(true)
-            .open("/scheme/log/kernel")
-            .unwrap();
-        let mut buf = [0; 4096];
-        loop {
-            let n = debug_file.read(&mut buf).unwrap();
-            assert!(n != 0); // FIXME currently fails as /scheme/log/kernel presents a snapshot of the log queue
-            log_file.write_all(&buf[..n]).unwrap();
-        }
-    }
-
     redox_daemon::Daemon::new(daemon).expect("logd: failed to daemonize");
 }
diff --git a/logd/src/scheme.rs b/logd/src/scheme.rs
index 66b934da72..d772f21212 100644
--- a/logd/src/scheme.rs
+++ b/logd/src/scheme.rs
@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, VecDeque};
 use std::fs::{File, OpenOptions};
-use std::io::Write;
+use std::io::{Read, Write};
 use std::mem;
 use std::path::PathBuf;
 use std::sync::mpsc::{self, Sender};
@@ -75,12 +75,55 @@ impl LogScheme {
             }
         });
 
+        let output_tx2 = output_tx.clone();
+        std::thread::spawn(move || {
+            let mut debug_file = std::fs::File::open("/scheme/sys/log").unwrap();
+            let mut handle_buf = vec![];
+            let mut buf = [0; 4096];
+            buf[.."kernel: ".len()].copy_from_slice(b"kernel: ");
+            loop {
+                let n = debug_file.read(&mut buf["kernel: ".len()..]).unwrap();
+                if n == 0 {
+                    // FIXME currently possible as /scheme/log/kernel presents a snapshot of the log queue
+                    break;
+                }
+                Self::write_logs(&output_tx2, &mut handle_buf, "kernel", &buf);
+            }
+        });
+
         LogScheme {
             next_id: 0,
             output_tx,
             handles: BTreeMap::new(),
         }
     }
+
+    fn write_logs(
+        output_tx: &Sender<OutputCmd>,
+        handle_buf: &mut Vec<u8>,
+        context: &str,
+        buf: &[u8],
+    ) {
+        let mut i = 0;
+        while i < buf.len() {
+            let b = buf[i];
+
+            if handle_buf.is_empty() && !context.is_empty() {
+                handle_buf.extend_from_slice(context.as_bytes());
+                handle_buf.extend_from_slice(b": ");
+            }
+
+            handle_buf.push(b);
+
+            if b == b'\n' {
+                output_tx
+                    .send(OutputCmd::Log(mem::take(handle_buf)))
+                    .unwrap();
+            }
+
+            i += 1;
+        }
+    }
 }
 
 impl SchemeSync for LogScheme {
@@ -146,27 +189,9 @@ impl SchemeSync for LogScheme {
 
         let handle_buf = bufs.entry(ctx.pid).or_insert_with(|| Vec::new());
 
-        let mut i = 0;
-        while i < buf.len() {
-            let b = buf[i];
+        Self::write_logs(&self.output_tx, handle_buf, context, buf);
 
-            if handle_buf.is_empty() && !context.is_empty() {
-                handle_buf.extend_from_slice(context.as_bytes());
-                handle_buf.extend_from_slice(b": ");
-            }
-
-            handle_buf.push(b);
-
-            if b == b'\n' {
-                self.output_tx
-                    .send(OutputCmd::Log(mem::take(handle_buf)))
-                    .unwrap();
-            }
-
-            i += 1;
-        }
-
-        Ok(i)
+        Ok(buf.len())
     }
 
     fn fcntl(&mut self, id: usize, _cmd: usize, _arg: usize, _ctx: &CallerCtx) -> Result<usize> {