Add primitive printk-based logging

Support the `log` crate's log macros, using Zephyr's printk mechanism.
There is no filter, or deferral of messages, and it pulls in both Rust
and Zephyr's string formatting, but does allow logging to work directly.

This is intended as a stopgap until better logging support comes in, but
is also useful in its own right for builds where Zephyr logging is
disabled.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr/Cargo.toml

@@ -11,6 +11,7 @@ Functionality for Rust-based applications that run on Zephyr.
 
 [dependencies]
 zephyr-sys = { version = "3.7.0", path = "../zephyr-sys" }
+log = "0.4.22"
 
 # Although paste is brought in, it is a compile-time macro, and is not linked into the application.
 paste = "1.0"

zephyr/src/lib.rs

@@ -66,6 +66,11 @@ fn panic(info :&PanicInfo) -> ! {
     }
 }
 
+#[cfg(CONFIG_PRINTK)]
+pub fn set_logger() {
+    printk::set_printk_logger();
+}
+
 /// Re-export of zephyr-sys as `zephyr::raw`.
 pub mod raw {
     pub use zephyr_sys::*;
@@ -86,3 +91,14 @@ pub mod _export {
 // If allocation has been requested, provide the allocator.
 #[cfg(CONFIG_RUST_ALLOC)]
 pub mod alloc_impl;
+
+// If we have allocation, we can also support logging.
+#[cfg(CONFIG_RUST_ALLOC)]
+pub mod log {
+    #[cfg(CONFIG_LOG)]
+    compile_error!("Rust with CONFIG_LOG is not yet supported");
+
+    mod log_printk;
+
+    pub use log_printk::*;
+}

zephyr/src/log/log_printk.rs

@@ -0,0 +1,39 @@
+//! A very simplistic logger that allocates and uses printk.
+//!
+//! This is just a stop gap so that users of Rust can have some simple messages.  This provides a
+//! `println` macro that works similar to the one in std.
+//!
+//! This module allocates at least twice as much space as the final message, for the duration of the
+//! print call.
+//!
+//! An unfortunate caveat of this crate is that using it requires clients to have `extern crate
+//! alloc;` in each module that uses it.
+
+extern crate alloc;
+
+use alloc::ffi::CString;
+
+pub use alloc::format;
+
+// Printk, with a fixed C-string formatting argument, and one we've built here.
+extern "C" {
+    fn printk(fmt: *const i8, ...);
+}
+
+pub fn log_message(message: &str) {
+    let raw = CString::new(message).expect("CString::new failed");
+    unsafe {
+        printk(c"%s\n".as_ptr(), raw.as_ptr());
+    }
+}
+
+// We assume the log message is accessible at $crate::log::log_message.
+#[macro_export]
+macro_rules! println {
+    ($($arg:tt)+) => {
+        {
+            let message = $crate::log::format!($($arg)+);
+            $crate::log::log_message(&message);
+        }
+    };
+}

zephyr/src/printk.rs

@@ -12,6 +12,8 @@ use core::fmt::{
     write,
 };
 
+use log::{LevelFilter, Log, Metadata, Record};
+
 /// Print to Zephyr's console, without a newline.
 ///
 /// This macro uses the same syntax as std's
@@ -46,6 +48,46 @@ macro_rules! printkln {
     }};
 }
 
+/// A simple log handler built around printk.
+struct PrintkLogger;
+
+impl Log for PrintkLogger {
+    // Initially, everything is just available.
+    fn enabled(&self, _metadata: &Metadata<'_>) -> bool {
+        true
+    }
+
+    // Just print out the information.
+    fn log(&self, record: &Record<'_>) {
+        printkln!("{}:{}: {}",
+            record.level(),
+            record.target(),
+            record.args());
+    }
+
+    // Nothing to do for flush.
+    fn flush(&self) {
+    }
+}
+
+static PRINTK_LOGGER: PrintkLogger = PrintkLogger;
+
+// The cfg matches what is in the log crate, which doesn't use portable atomic, and assumes the
+// racy init when not the case.
+#[cfg(target_has_atomic = "ptr")]
+pub fn set_printk_logger() {
+    log::set_logger(&PRINTK_LOGGER).unwrap();
+    log::set_max_level(LevelFilter::Info);
+}
+
+#[cfg(not(target_has_atomic = "ptr"))]
+pub fn set_printk_logger() {
+    unsafe {
+        log::set_logger_racy(&PRINTK_LOGGER).unwrap();
+        log::set_max_level_racy(LevelFilter::Info);
+    }
+}
+
 // This could readily be optimized for the configuration where we don't have userspace, as well as
 // when we do, and are not running in userspace.  This initial implementation will always use a
 // string buffer, as it doesn't depend on static symbols in print.c.