lib: rust: Add simple printk support to Rust

When `CONFIG_PRINTK` is enabled, provide macros `printk` and `printkln`
within the `zephyr` crate that applications can use to print.  This
currently sends messages, with a small amount of buffering, using
`k_str_out`.

Until C functions are made generally available from the Rust side,
we use a small wrapper function to call `k_str_out`, as it is
implemented as an inline syscall.

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

Author: d3zd3z

lib/rust/main.c

@@ -4,6 +4,7 @@
  */
 
 /* This main is brought into the Rust application. */
+#include <zephyr/kernel.h>
 
 #ifdef CONFIG_RUST
 
@@ -15,4 +16,14 @@ int main(void)
 	return 0;
 }
 
+#ifdef CONFIG_PRINTK
+/*
+ * Until we have syscall support in Rust, wrap this syscall.
+ */
+void wrapped_str_out(char *c, size_t n)
+{
+	k_str_out(c, n);
+}
+#endif
+
 #endif

lib/rust/zephyr/src/lib.rs

@@ -15,6 +15,10 @@ include!(concat!(env!("OUT_DIR"), "/kconfig.rs"));
 #[cfg(not(CONFIG_RUST))]
 compile_error!("CONFIG_RUST must be set to build Rust in Zephyr");
 
+// Printk is provided if it is configured into the build.
+#[cfg(CONFIG_PRINTK)]
+pub mod printk;
+
 use core::panic::PanicInfo;
 
 /// Override rust's panic.  This simplistic initial version just hangs in a loop.
@@ -23,3 +27,9 @@ fn panic(_ :&PanicInfo) -> ! {
     loop {
     }
 }
+
+/// Provide symbols used by macros in a crate-local namespace.
+#[doc(hidden)]
+pub mod _export {
+    pub use core::format_args;
+}

lib/rust/zephyr/src/printk.rs

@@ -0,0 +1,117 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+//! Printk implementation for Rust.
+//!
+//! This uses the `k_str_out` syscall, which is part of printk to output to the console.
+
+use core::fmt::{
+    Arguments,
+    Result,
+    Write,
+    write,
+};
+
+#[macro_export]
+macro_rules! printk {
+    ($($arg:tt)*) => {{
+        $crate::printk::printk(format_args!($($arg)*));
+    }};
+}
+
+#[macro_export]
+macro_rules! printkln {
+    ($($arg:tt)*) => {{
+        $crate::printk::printkln(format_args!($($arg)*));
+    }};
+}
+
+// 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.
+//
+// A consequence is that the CONFIG_PRINTK_SYNC is enabled, the synchonization will only occur at
+// the granularity of these buffers rather than at the print message level.
+
+/// The buffer size for syscall.  This is a tradeoff between efficiency (large buffers need fewer
+/// syscalls) and needing more stack space.
+const BUF_SIZE: usize = 32;
+
+struct Context {
+    // How many characters are used in the buffer.
+    count: usize,
+    // Bytes written.
+    buf: [u8; BUF_SIZE],
+}
+
+fn utf8_byte_length(byte: u8) -> usize {
+    if byte & 0b1000_0000 == 0 {
+        // Single byte (0xxxxxxx)
+        1
+    } else if byte & 0b1110_0000 == 0b1100_0000 {
+        // Two-byte sequence (110xxxxx)
+        2
+    } else if byte & 0b1111_0000 == 0b1110_0000 {
+        // Three-byte sequence (1110xxxx)
+        3
+    } else if byte & 0b1111_1000 == 0b1111_0000 {
+        // Four-byte sequence (11110xxx)
+        4
+    } else {
+        // Continuation byte or invalid (10xxxxxx)
+        1
+    }
+}
+
+impl Context {
+    fn add_byte(&mut self, b: u8) {
+        // Ensure we have room for an entire UTF-8 sequence.
+        if self.count + utf8_byte_length(b) > self.buf.len() {
+            self.flush();
+        }
+
+        self.buf[self.count] = b;
+        self.count += 1;
+    }
+
+    fn flush(&mut self) {
+        if self.count > 0 {
+            unsafe {
+                wrapped_str_out(self.buf.as_ptr(), self.count);
+            }
+            self.count = 0;
+        }
+    }
+}
+
+impl Write for Context {
+    fn write_str(&mut self, s: &str) -> Result {
+        for b in s.bytes() {
+            self.add_byte(b);
+        }
+        Ok(())
+    }
+}
+
+pub fn printk(args: Arguments<'_>) {
+    let mut context = Context {
+        count: 0,
+        buf: [0; BUF_SIZE],
+    };
+    write(&mut context, args).unwrap();
+    context.flush();
+}
+
+pub fn printkln(args: Arguments<'_>) {
+    let mut context = Context {
+        count: 0,
+        buf: [0; BUF_SIZE],
+    };
+    write(&mut context, args).unwrap();
+    context.add_byte(b'\n');
+    context.flush();
+}
+
+extern "C" {
+    fn wrapped_str_out(buf: *const u8, len: usize);
+}