rust: Basic zephyr crates

This is the initial Zephyr-specific crates that provide support for Rust
on Zephyr.  Currently, what they do is fairly minimal, but important.

`zephyr-build` is a build time crate (linked against the `zephyr`
crate's build.rs) that processes the current build's Kconfig settings,
and does three things with them:

  - Boolean Kconfig values given given to the Rust toolchain so that
    conditional compilation can be based off of them.
  - Numeric Kconfig settings end up as constants in `zephyr::kconfig`.
  - String valued Kconfig settings end up as constants in
    `zephyr::kconfig`.

None of these cause code or data to be generated or allocated (but note
that if there is a reference to a string, that string will be placed in
read-only memory).

The `zephyr` crate is built for the target, and intended to be
referenced by the application.  It provides minimal support needed for a
"bare" Rust build, notably a panic handler.  At this point, the panic
handler is not implemented as we need better support for calling into
Zephyr's C code, so it just stops in an infinite loop.

It also ensures that `CONFIG_RUST` is set as a sanity check, and
includes the generated kconfig.rs file with the kconfig definitions for
the current build.

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

Author: d3zd3z

lib/rust/zephyr-build/Cargo.toml

@@ -0,0 +1,17 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "zephyr-build"
+version = "0.1.0"
+edition = "2021"
+description = """
+Build-time support for Rust-based applications that run on Zephyr.
+Provides utilities for accessing Kconfig and devicetree information.
+"""
+
+# These are needed at build time.
+# Whether these need to be vendored is an open question.  They are not
+# used by the core Zephyr tree, but are needed by zephyr applications.
+[dependencies]
+regex = "1.10.3"

lib/rust/zephyr-build/src/lib.rs

@@ -0,0 +1,77 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+// Pre-build code for zephyr module.
+
+// This module makes the values from the generated .config available as conditional compilation.
+// Note that this only applies to the zephyr module, and the user's application will not be able to
+// see these definitions.  To make that work, this will need to be moved into a support crate which
+// can be invoked by the user's build.rs.
+
+// This builds a program that is run on the compilation host before the code is compiled.  It can
+// output configuration settings that affect the compilation.
+
+use std::io::{BufRead, BufReader, Write};
+use std::env;
+use std::fs::File;
+use std::path::Path;
+
+use regex::Regex;
+
+/// Export boolean Kconfig entries.  This must happen in any crate that wishes to access the
+/// configuration settings.
+pub fn export_bool_kconfig() {
+    let dotconfig = env::var("DOTCONFIG").expect("DOTCONFIG must be set by wrapper");
+
+    // Ensure the build script is rerun when the dotconfig changes.
+    println!("cargo:rerun-if-env-changed=DOTCONFIG");
+    println!("cargo-rerun-if-changed={}", dotconfig);
+
+    let config_y = Regex::new(r"^(CONFIG_.*)=y$").unwrap();
+
+    let file = File::open(&dotconfig).expect("Unable to open dotconfig");
+    for line in BufReader::new(file).lines() {
+        let line =  line.expect("reading line from dotconfig");
+        if let Some(caps) = config_y.captures(&line) {
+            println!("cargo:rustc-cfg={}", &caps[1]);
+        }
+    }
+}
+
+/// Capture bool, numeric and string kconfig values in a 'kconfig' module.
+/// This is a little simplistic, and will make the entries numeric if they look like numbers.
+/// Ideally, this would be built on the types of the values, but that will require more
+/// introspection.
+pub fn build_kconfig_mod() {
+    let dotconfig = env::var("DOTCONFIG").expect("DOTCONFIG must be set by wrapper");
+    let outdir = env::var("OUT_DIR").expect("OUT_DIR must be set");
+
+    // The assumption is that hex values are unsigned, and decimal are signed.
+    let config_hex = Regex::new(r"^(CONFIG_.*)=(0x[0-9a-fA-F]+)$").unwrap();
+    let config_int = Regex::new(r"^(CONFIG_.*)=(-?[1-9][0-9]*)$").unwrap();
+    // It is unclear what quoting might be used in the .config.
+    let config_str = Regex::new(r#"^(CONFIG_.*)=(".*")$"#).unwrap();
+    let gen_path = Path::new(&outdir).join("kconfig.rs");
+
+    let mut f = File::create(&gen_path).unwrap();
+    writeln!(&mut f, "pub mod kconfig {{").unwrap();
+
+    let file = File::open(&dotconfig).expect("Unable to open dotconfig");
+    for line in BufReader::new(file).lines() {
+        let line = line.expect("reading line from dotconfig");
+        if let Some(caps) = config_hex.captures(&line) {
+            writeln!(&mut f, "    #[allow(dead_code)]").unwrap();
+            writeln!(&mut f, "    pub const {}: usize = {};",
+                &caps[1], &caps[2]).unwrap();
+        } else if let Some(caps) = config_int.captures(&line) {
+            writeln!(&mut f, "    #[allow(dead_code)]").unwrap();
+            writeln!(&mut f, "    pub const {}: isize = {};",
+                &caps[1], &caps[2]).unwrap();
+        } else if let Some(caps) = config_str.captures(&line) {
+            writeln!(&mut f, "    #[allow(dead_code)]").unwrap();
+            writeln!(&mut f, "    pub const {}: &'static str = {};",
+                &caps[1], &caps[2]).unwrap();
+        }
+    }
+    writeln!(&mut f, "}}").unwrap();
+}

lib/rust/zephyr/Cargo.toml

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "zephyr"
+version = "0.1.0"
+edition = "2021"
+description = """
+Functionality for Rust-based applications that run on Zephyr.
+"""
+
+# These are needed at build time.
+# Whether these need to be vendored is an open question.  They are not
+# used by the core Zephyr tree, but are needed by zephyr applications.
+[build-dependencies]
+zephyr-build = "0.1.0"

lib/rust/zephyr/build.rs

@@ -0,0 +1,17 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+// Pre-build code for zephyr module.
+
+// This module makes the values from the generated .config available as conditional compilation.
+// Note that this only applies to the zephyr module, and the user's application will not be able to
+// see these definitions.  To make that work, this will need to be moved into a support crate which
+// can be invoked by the user's build.rs.
+
+// This builds a program that is run on the compilation host before the code is compiled.  It can
+// output configuration settings that affect the compilation.
+
+fn main() {
+    zephyr_build::export_bool_kconfig();
+    zephyr_build::build_kconfig_mod();
+}

lib/rust/zephyr/src/lib.rs

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+//! Zephyr application support for Rust
+//!
+//! This crates provides the core functionality for applications written in Rust that run on top of
+//! Zephyr.
+
+#![no_std]
+
+// Bring in the generated kconfig module
+include!(concat!(env!("OUT_DIR"), "/kconfig.rs"));
+
+// Ensure that Rust is enabled.
+#[cfg(not(CONFIG_RUST))]
+compile_error!("CONFIG_RUST must be set to build Rust in Zephyr");
+
+use core::panic::PanicInfo;
+
+/// Override rust's panic.  This simplistic initial version just hangs in a loop.
+#[panic_handler]
+fn panic(_ :&PanicInfo) -> ! {
+    loop {
+    }
+}