Add support for RTT through rust

This commit introduces a new `log` macro that calls `rprintln` in case
the `rtt` feature is enabled. It also creates a new c function called
`util_log` that reuses the rust RTT machinery.

The rust `log` macro is used the same way `println` is used. `util_log`
is used the same way `printf` is used.

Author: NickeZ

src/CMakeLists.txt

@@ -370,7 +370,7 @@ foreach(type ${RUST_LIBS})
       FIRMWARE_VERSION_SHORT=${FIRMWARE_VERSION}
       $<$<BOOL:${SCCACHE_PROGRAM}>:RUSTC_WRAPPER=${SCCACHE_PROGRAM}>
       RUSTC_BOOTSTRAP=1
-      ${CARGO} build $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-vv> --offline --features target-${type} --target-dir ${RUST_BINARY_DIR}/feature-${type} ${RUST_CARGO_FLAGS} ${RUST_TARGET_ARCH_ARG}
+      ${CARGO} build $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-vv> --offline --features target-${type}$<$<STREQUAL:${CMAKE_BUILD_TYPE},DEBUG>:,rtt> --target-dir ${RUST_BINARY_DIR}/feature-${type} ${RUST_CARGO_FLAGS} ${RUST_TARGET_ARCH_ARG}
     COMMAND
       ${CMAKE_COMMAND} -E copy_if_different ${lib} ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/lib${type}_rust_c.a
     # DEPFILES are only supported with the Ninja build tool

src/platform/platform_init.c

@@ -18,11 +18,18 @@
 #if !defined(BOOTLOADER)
 #include "sd_mmc/sd_mmc_start.h"
 #endif
+#include "rust/rust.h"
 
 void platform_init(void)
 {
     oled_init();
 #if !defined(BOOTLOADER)
+// The factory setup image already has a c implementation of RTT.
+#if FACTORYSETUP != 1
+    // these two functions are noops if "rtt" feature isn't enabled in rust
+    rust_rtt_init();
+    util_log("platform_init");
+#endif
     sd_mmc_start();
 #endif
 }

src/rust/bitbox02-rust-c/Cargo.toml

@@ -97,3 +97,5 @@ app-cardano = [
  # enable this feature in the deps
   "bitbox02-rust/app-cardano",
 ]
+
+rtt = [ "util/rtt" ]

src/rust/bitbox02-rust-c/src/lib.rs

@@ -36,14 +36,37 @@ mod sha2;
 mod workflow;
 
 // Whenever execution reaches somewhere it isn't supposed to rust code will "panic". Our panic
-// handler will print the available information on the screen. If we compile with `panic=abort`
-// this code will never get executed.
+// handler will print the available information on the screen and over RTT. If we compile with
+// `panic=abort` this code will never get executed.
 #[cfg(not(test))]
 #[cfg(not(feature = "testing"))]
 #[cfg_attr(feature = "bootloader", allow(unused_variables))]
 #[panic_handler]
 fn panic(info: &core::panic::PanicInfo) -> ! {
+    ::util::log::log!("{}", info);
     #[cfg(feature = "firmware")]
     bitbox02_rust::print_debug!(0, "Error: {}", info);
     loop {}
 }
+
+#[no_mangle]
+pub extern "C" fn rust_rtt_init() {
+    ::util::log::rtt_init();
+}
+
+/// # Safety
+///
+/// The pointer `ptr` must point to a null terminated string
+#[no_mangle]
+#[cfg_attr(not(feature = "rtt"), allow(unused))]
+pub unsafe extern "C" fn rust_log(ptr: *const ::util::c_types::c_char) {
+    #[cfg(feature = "rtt")]
+    {
+        if ptr.is_null() {
+            panic!("`ptr` must be a valid pointer");
+        }
+        let s = unsafe { core::ffi::CStr::from_ptr(ptr as _) };
+        let s = unsafe { core::str::from_utf8_unchecked(s.to_bytes()) };
+        ::util::log::rtt_target::rprintln!("{}", s);
+    }
+}

src/rust/util/Cargo.toml

@@ -24,3 +24,6 @@ license = "Apache-2.0"
 num-bigint = { workspace = true, default-features = false }
 rtt-target = { version = "0.5.0", optional = true }
 cortex-m = { version = "0.7.7", features = ["critical-section-single-core"], optional = true }
+
+[features]
+rtt = ["dep:rtt-target", "dep:cortex-m"]

src/rust/util/src/lib.rs

@@ -17,12 +17,17 @@ pub mod ascii;
 pub mod bip32;
 pub mod c_types;
 pub mod decimal;
+pub mod log;
 pub mod name;
 
 // for `format!`
 #[macro_use]
 extern crate alloc;
 
+// include critical section implementation, needed by rtt-target
+#[cfg(feature = "rtt")]
+extern crate cortex_m;
+
 /// Guaranteed to wipe the provided buffer
 pub fn zero(dst: &mut [u8]) {
     for p in dst {

src/rust/util/src/log.rs

@@ -0,0 +1,18 @@
+// Re-export rtt_target so that it is available to the macro user
+#[cfg(feature = "rtt")]
+pub use ::rtt_target;
+
+/// Macro to log over RTT if `rtt` feature is set, otherwise noop
+#[macro_export]
+macro_rules! log {
+    ($($arg:tt)*) => { #[cfg(feature="rtt")] {$crate::log::rtt_target::rprintln!($($arg)*) }};
+}
+
+// Make log macro usable in crate
+pub use log;
+
+pub fn rtt_init() {
+    #[cfg(feature = "rtt")]
+    rtt_target::rtt_init_print!();
+    log!("RTT Initialized");
+}

src/util.c

@@ -66,3 +66,25 @@ void util_cleanup_64(uint8_t** buf)
 {
     util_zero(*buf, 64);
 }
+
+// Max message size is MAX_LOG_LENGTH-1, becuase vsnprintf will always print a null character
+#define MAX_LOG_LENGTH 101
+
+void util_log(const char* fmt, ...)
+{
+#if !defined(NDEBUG)
+    char buf[MAX_LOG_LENGTH] = "";
+
+    va_list va;
+    va_start(va, fmt);
+    int res = vsnprintf(buf, MAX_LOG_LENGTH, fmt, va);
+    va_end(va);
+
+    rust_log(buf);
+    if (res > MAX_LOG_LENGTH - 1) {
+        rust_log("The complete log line didn't fit\n");
+    }
+#else
+    (void)fmt;
+#endif
+}

src/util.h

@@ -109,4 +109,6 @@ typedef struct {
  */
 typedef enum { ASYNC_OP_TRUE, ASYNC_OP_FALSE, ASYNC_OP_NOT_READY } async_op_result_t;
 
+void util_log(const char* fmt, ...) __attribute__((format(printf, 1, 2)));
+
 #endif