Merge pull request #123 from flipperzero-rs/basic-miri-support

flipperzero: Enable Miri to start running the tests

Author: str4d

crates/.cargo/config.toml

@@ -1,6 +1,9 @@
+# Equivalent to [target.thumbv7em-none-eabihf] but also disabing the runner for Miri.
+[target.'cfg(all(target_arch = "arm", target_feature = "thumb2", target_feature = "v7", target_feature = "dsp", target_os = "none", target_abi = "eabihf", not(miri)))']
+runner = "python3 ../cargo-runner.py"
+
 [target.thumbv7em-none-eabihf]
 linker = "./fap-lld.py"
-runner = "python3 ../cargo-runner.py"
 rustflags = [
     # CPU is Cortex-M4 (STM32WB55)
     "-C", "target-cpu=cortex-m4",

crates/flipperzero/src/furi/thread.rs

@@ -206,6 +206,7 @@ pub fn sleep(duration: core::time::Duration) {
 /// A unique identifier for a running thread.
 #[cfg(feature = "alloc")]
 #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+#[allow(dead_code)]
 pub struct ThreadId(sys::FuriThreadId);
 
 /// A handle to a thread.

crates/flipperzero/src/gpio/i2c.rs

@@ -1,6 +1,7 @@
 //! I2C interface for the Flipper Zero.
 
 use core::fmt;
+use core::ptr::addr_of_mut;
 
 use flipperzero_sys as sys;
 
@@ -99,9 +100,12 @@ impl Bus {
     ///
     /// Blocks indefinitely until the bus is available.
     pub fn acquire(self) -> BusHandle {
+        // SAFETY: We block until we acquire a handle to the selected bus, so nothing else
+        // will be using it while we have a raw pointer to it. We don't convert this to a
+        // `&'static mut` reference because this will be disallowed in Rust 2024 edition.
         BusHandle::acquire(match self.0 {
-            BusKind::Internal => unsafe { &mut sys::furi_hal_i2c_handle_power },
-            BusKind::External => unsafe { &mut sys::furi_hal_i2c_handle_external },
+            BusKind::Internal => unsafe { addr_of_mut!(sys::furi_hal_i2c_handle_power) },
+            BusKind::External => unsafe { addr_of_mut!(sys::furi_hal_i2c_handle_external) },
         })
     }
 
@@ -115,7 +119,7 @@ impl Bus {
 
 /// A handle to an I2C bus on the Flipper Zero.
 pub struct BusHandle {
-    handle: &'static mut sys::FuriHalI2cBusHandle,
+    handle: *mut sys::FuriHalI2cBusHandle,
 }
 
 impl Drop for BusHandle {
@@ -128,7 +132,7 @@ impl BusHandle {
     /// Acquires a handle to the given I2C bus.
     ///
     /// Blocks indefinitely until the Flipper Zero bus is locally available.
-    fn acquire(handle: &'static mut sys::FuriHalI2cBusHandle) -> Self {
+    fn acquire(handle: *mut sys::FuriHalI2cBusHandle) -> Self {
         unsafe { sys::furi_hal_i2c_acquire(handle) };
         Self { handle }
     }

crates/flipperzero/src/lib.rs

@@ -5,7 +5,8 @@
 //!
 
 #![no_std]
-#![cfg_attr(test, no_main)]
+#![cfg_attr(all(test, not(miri)), no_main)]
+#![cfg_attr(all(test, miri), feature(start))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![deny(rustdoc::broken_intra_doc_links)]
 

crates/flipperzero/src/storage.rs

@@ -146,6 +146,7 @@ impl OpenOptions {
 }
 
 /// Basic, unbuffered file handle
+#[allow(dead_code)]
 pub struct File(NonNull<sys::File>, UnsafeRecord<sys::Storage>);
 
 impl File {

crates/rt/src/lib.rs

@@ -34,6 +34,7 @@ macro_rules! entry {
     ($path:path) => {
         // Force the section to `.text` instead of `.text.main`.
         // lld seems not to automatically rename `.rel.text.main` properly.
+        #[cfg(not(miri))]
         #[export_name = "main"]
         pub unsafe fn __main(args: *mut u8) -> i32 {
             // type check the entry function

crates/rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2023-12-09"
+channel = "nightly-2024-04-16"
 targets = [ "thumbv7em-none-eabihf" ]
 components = [ "clippy", "rustfmt" ]

crates/sys/src/lib.rs

@@ -4,14 +4,16 @@
 #![deny(rustdoc::broken_intra_doc_links)]
 
 // Features that identify thumbv7em-none-eabihf.
-// Until target_abi is stable, this also permits thumbv7em-none-eabi.
-#[cfg(not(all(
-    target_arch = "arm",
-    target_feature = "thumb2",
-    target_feature = "v7",
-    target_feature = "dsp",
-    target_os = "none",
-    //target_abi = "eabihf",
+#[cfg(not(any(
+    all(
+        target_arch = "arm",
+        target_feature = "thumb2",
+        target_feature = "v7",
+        target_feature = "dsp",
+        target_os = "none",
+        target_abi = "eabihf",
+    ),
+    miri
 )))]
 core::compile_error!("This crate requires `--target thumbv7em-none-eabihf`");
 

crates/test/macros/src/lib.rs

@@ -131,14 +131,27 @@ fn tests_runner_impl(args: TokenStream) -> parse::Result<TokenStream> {
             }
 
             // Test runner entry point
-            fn main(args: Option<&::core::ffi::CStr>) -> i32 {
+            pub(super) fn main(args: Option<&::core::ffi::CStr>) -> i32 {
                 let args = ::flipperzero_test::__macro_support::Args::parse(args);
                 match ::flipperzero_test::__macro_support::run_tests(test_count(), test_list(), args) {
                     Ok(()) => 0,
                     Err(e) => e,
                 }
             }
         }
+
+        #[cfg(all(test, miri))]
+        #[start]
+        fn main(argc: isize, argv: *const *const u8) -> isize {
+            // TODO: Is there any benefit to Miri in hooking up the binary arguments to
+            // the test runner?
+            let ret = __test_runner::main(None);
+
+            // Clean up app state.
+            ::flipperzero_rt::__macro_support::__wait_for_thread_completion();
+
+            ret.try_into().unwrap_or(isize::MAX)
+        }
     )
     .into())
 }