[pixie-uefi] using log crate

Virv12 · Virv12 · commit dfd5a411d487 · 2025-04-22T15:44:54.000+02:00
diff --git a/pixie-uefi/Cargo.lock b/pixie-uefi/Cargo.lock
diff --git a/pixie-uefi/Cargo.toml b/pixie-uefi/Cargo.toml
@@ -10,10 +10,12 @@ test = false
 bench = false
 
 [dependencies]
+anstyle = { version = "1.0.10", default-features = false }
 blake3 = { version = "1.5.0", default-features = false, features = ["prefer_intrinsics", "no_avx512", "pure"] }
 core_detect = "1.0.0"
 futures = { version = "0.3.29", default-features = false, features = ["alloc", "async-await"] }
 gpt_disk_io = "0.16.0"
+log = "0.4.27"
 lz4_flex = { version = "0.11.3", default-features = false }
 managed = { version = "0.8.0", default-features = false, features = ["alloc"] }
 postcard = { version = "1.0.8", default-features = false, features = ["alloc"] }
diff --git a/pixie-uefi/src/main.rs b/pixie-uefi/src/main.rs
@@ -1,6 +1,5 @@
 #![no_main]
 #![no_std]
-#![feature(negative_impls)]
 #![feature(never_type)]
 #![deny(unused_must_use)]
 
@@ -11,13 +10,13 @@ use crate::{
     flash::flash,
     os::{
         error::{Error, Result},
-        MessageKind, TcpStream, UefiOS, PACKET_SIZE,
+        TcpStream, UefiOS, PACKET_SIZE,
     },
     reboot_to_os::reboot_to_os,
     register::register,
     store::store,
 };
-use alloc::{borrow::ToOwned, boxed::Box};
+use alloc::boxed::Box;
 use core::net::{Ipv4Addr, SocketAddrV4};
 use futures::future::{self, Either};
 use pixie_shared::{Action, TcpRequest, UdpRequest, ACTION_PORT, PING_PORT};
@@ -67,7 +66,7 @@ async fn server_discover(os: UefiOS) -> Result<SocketAddrV4> {
 }
 
 async fn shutdown(os: UefiOS) -> ! {
-    os.append_message("Shutting down...".to_owned(), MessageKind::Info);
+    log::info!("Shutting down...");
     os.sleep_us(1_000_000).await;
     os.shutdown()
 }
@@ -115,7 +114,7 @@ async fn run(os: UefiOS) -> Result<!> {
         os.set_ui_drawer(|_| {});
 
         if !last_was_wait {
-            os.append_message("Sending request for command".into(), MessageKind::Debug);
+            log::debug!("Sending request for command");
         }
 
         let tcp = os.connect(server).await?;
@@ -124,18 +123,12 @@ async fn run(os: UefiOS) -> Result<!> {
         tcp.force_close().await;
 
         if let Err(e) = command {
-            os.append_message(format!("Error receiving action: {e}"), MessageKind::Warn);
+            log::warn!("Error receiving action: {e}");
         } else {
             let command = command.unwrap();
             if matches!(command, Action::Wait) {
                 if !last_was_wait {
-                    os.append_message(
-                        format!(
-                            "Started waiting for another command at {:.1}s...",
-                            os.timer().micros() as f32 * 0.000_001
-                        ),
-                        MessageKind::Warn,
-                    );
+                    log::warn!("Started waiting for another command...");
                 }
                 last_was_wait = true;
                 const WAIT_10MSECS: u64 = 50;
@@ -145,7 +138,7 @@ async fn run(os: UefiOS) -> Result<!> {
                 }
             } else {
                 last_was_wait = false;
-                os.append_message(format!("Command: {:?}", command), MessageKind::Info);
+                log::info!("Command: {:?}", command);
                 match command {
                     Action::Wait => unreachable!(),
                     Action::Reboot => reboot_to_os(os).await,
diff --git a/pixie-uefi/src/os/mod.rs b/pixie-uefi/src/os/mod.rs
@@ -78,7 +78,7 @@ struct UefiOSImpl {
     vga: ScopedProtocol<Output>,
     serial: ScopedProtocol<Serial>,
     net: Option<NetworkInterface>,
-    messages: VecDeque<(String, MessageKind)>,
+    messages: VecDeque<(f64, log::Level, String, String)>,
     ui_buf: Vec<(String, Color, Color)>,
     ui_pos: usize,
     ui_drawer: Option<Box<dyn Fn(UefiOS) + 'static>>,
@@ -149,9 +149,6 @@ pub struct UefiOS {
     cant_build: (),
 }
 
-impl !Send for UefiOS {}
-impl !Sync for UefiOS {}
-
 unsafe extern "efiapi" fn exit_boot_services(_e: Event, _ctx: Option<NonNull<c_void>>) {
     panic!("You must never exit boot services");
 }
@@ -210,13 +207,16 @@ impl UefiOS {
 
         let os = UefiOS { cant_build: () };
 
+        log::set_logger(&UefiOS { cant_build: () }).unwrap();
+        log::set_max_level(log::LevelFilter::Trace);
+
         let net = NetworkInterface::new(os);
         os.borrow_mut().net = Some(net);
 
         os.spawn("init", async move {
             loop {
                 let err = f(os).await.unwrap_err();
-                os.append_message(format!("Error: {:?}", err), MessageKind::Error);
+                log::error!("Error: {:?}", err);
             }
         });
 
@@ -226,10 +226,7 @@ impl UefiOS {
 
                 if let Err(err) = err {
                     if err.status() != Status::UNSUPPORTED {
-                        os.append_message(
-                            format!("Error disabling watchdog: {:?}", err),
-                            MessageKind::Error,
-                        );
+                        log::error!("Error disabling watchdog: {:?}", err);
                     }
 
                     break;
@@ -503,10 +500,17 @@ impl UefiOS {
             // TODO(veluca): find a better solution.
             let messages: Vec<_> = os.messages.iter().cloned().collect();
 
-            for (line, kind) in messages {
-                let fg_color = kind.color();
-                os.write_with_color(&line, fg_color, Color::Black);
-                os.write_with_color("\n", Color::Black, Color::Black);
+            for (time, level, target, msg) in messages {
+                let fg_color = match level {
+                    log::Level::Trace => Color::Cyan,
+                    log::Level::Debug => Color::Blue,
+                    log::Level::Info => Color::Green,
+                    log::Level::Warn => Color::Yellow,
+                    log::Level::Error => Color::Red,
+                };
+                os.write_with_color(&format!("[{time:.1}s "), Color::White, Color::Black);
+                os.write_with_color(&format!("{level:5}"), fg_color, Color::Black);
+                os.write_with_color(&format!(" {target}] {msg}\n"), Color::White, Color::Black);
             }
             os.write_with_color("\n", Color::Black, Color::Black);
         }
@@ -533,13 +537,24 @@ impl UefiOS {
         self.borrow_mut().ui_drawer = Some(Box::new(f));
     }
 
-    pub fn append_message(&self, msg: String, kind: MessageKind) {
+    fn append_message(&self, time: f64, level: log::Level, target: &str, msg: String) {
         {
             let mut os = self.borrow_mut();
 
-            write!(os.serial, "{:5} {}\r\n", kind.as_str(), msg).unwrap();
+            let style = match level {
+                log::Level::Trace => anstyle::AnsiColor::Cyan.on_default(),
+                log::Level::Debug => anstyle::AnsiColor::Blue.on_default(),
+                log::Level::Info => anstyle::AnsiColor::Green.on_default(),
+                log::Level::Warn => anstyle::AnsiColor::Yellow.on_default(),
+                log::Level::Error => anstyle::AnsiColor::Red.on_default().bold(),
+            };
+            write!(
+                os.serial,
+                "[{time:.1}s {style}{level:5}{style:#} {target}] {msg}\r\n"
+            )
+            .unwrap();
 
-            os.messages.push_back((msg, kind));
+            os.messages.push_back((time, level, target.into(), msg));
             const MAX_MESSAGES: usize = 5;
             if os.messages.len() > MAX_MESSAGES {
                 os.messages.pop_front();
@@ -567,30 +582,22 @@ impl UefiOS {
     }
 }
 
-#[derive(Clone, Copy)]
-pub enum MessageKind {
-    Debug,
-    Info,
-    Warn,
-    Error,
-}
+impl log::Log for UefiOS {
+    fn enabled(&self, _metadata: &log::Metadata) -> bool {
+        true
+    }
 
-impl MessageKind {
-    fn color(self) -> Color {
-        match self {
-            MessageKind::Debug => Color::LightGray,
-            MessageKind::Info => Color::White,
-            MessageKind::Warn => Color::Yellow,
-            MessageKind::Error => Color::Red,
-        }
+    fn log(&self, record: &log::Record) {
+        let now = self.timer().micros() as f64 * 0.000_001;
+        self.append_message(
+            now,
+            record.level(),
+            record.target(),
+            format!("{}", record.args()),
+        );
     }
 
-    fn as_str(self) -> &'static str {
-        match self {
-            MessageKind::Debug => "DEBUG",
-            MessageKind::Info => "INFO",
-            MessageKind::Warn => "WARN",
-            MessageKind::Error => "ERROR",
-        }
+    fn flush(&self) {
+        // no-op
     }
 }
diff --git a/pixie-uefi/src/os/net.rs b/pixie-uefi/src/os/net.rs
@@ -1,7 +1,7 @@
 use super::{
     error::{Error, Result},
     timer::Timer,
-    MessageKind, UefiOS,
+    UefiOS,
 };
 use alloc::boxed::Box;
 use core::{
@@ -161,13 +161,10 @@ impl NetworkInterface {
         let bo = os.boot_options();
         let curopt = bo.get(bo.current());
         let (descr, device) = bo.boot_entry_info(&curopt[..]);
-        os.append_message(
-            format!(
-                "Configuring network on interface used for booting ({} -- {})",
-                descr,
-                os.device_path_to_string(device),
-            ),
-            MessageKind::Info,
+        log::info!(
+            "Configuring network on interface used for booting ({} -- {})",
+            descr,
+            os.device_path_to_string(device)
         );
         let mut device = SnpDevice::new(Box::leak(Box::new(
             os.open_protocol_on_device::<SimpleNetwork>(device).unwrap(),
diff --git a/pixie-uefi/src/reboot_to_os.rs b/pixie-uefi/src/reboot_to_os.rs
@@ -1,4 +1,4 @@
-use crate::os::{MessageKind, UefiOS};
+use crate::os::UefiOS;
 
 pub async fn reboot_to_os(os: UefiOS) -> ! {
     let bo = os.boot_options();
@@ -7,14 +7,11 @@ pub async fn reboot_to_os(os: UefiOS) -> ! {
         // Reboot to next boot option.
         bo.set_next(next);
     } else {
-        os.append_message(
-            format!(
-                "Did not find a valid boot order entry! current: {}",
-                bo.current()
-            ),
-            MessageKind::Warn,
+        log::warn!(
+            "Did not find a valid boot order entry! current: {}",
+            bo.current()
         );
-        os.append_message(format!("{:?}", bo.order()), MessageKind::Warn);
+        log::warn!("{:?}", bo.order());
         os.sleep_us(100_000_000).await;
     }
     os.reset();
diff --git a/pixie-uefi/src/register.rs b/pixie-uefi/src/register.rs
@@ -1,6 +1,6 @@
 use crate::os::{
     error::{Error, Result},
-    MessageKind, UefiOS, PACKET_SIZE,
+    UefiOS, PACKET_SIZE,
 };
 use alloc::{boxed::Box, rc::Rc, vec::Vec};
 use core::{cell::RefCell, net::SocketAddrV4};
@@ -167,10 +167,7 @@ pub async fn register(os: UefiOS, server_addr: SocketAddrV4) -> Result<()> {
     // TODO(virv): this could be better
     stream.force_close().await;
 
-    os.append_message(
-        format!("Registration successful! {:?}", data.borrow().station),
-        MessageKind::Info,
-    );
+    log::info!("Registration successful! {:?}", data.borrow().station);
 
     Ok(())
 }
diff --git a/pixie-uefi/src/store.rs b/pixie-uefi/src/store.rs
@@ -1,7 +1,7 @@
 use crate::{
     os::{
         error::{Error, Result},
-        mpsc, MessageKind, TcpStream, UefiOS,
+        mpsc, TcpStream, UefiOS,
     },
     parse_disk,
 };
@@ -216,10 +216,7 @@ pub async fn store(os: UefiOS, server_address: SocketAddrV4) -> Result<()> {
     // TODO(virv): this could be better
     stream_upload_chunk.force_close().await;
 
-    os.append_message(
-        format!("image saved. Total size {total_size}, total csize {total_csize}",),
-        MessageKind::Info,
-    );
+    log::info!("image saved. Total size {total_size}, total csize {total_csize}");
 
     Ok(())
 }
