Merge branch 'main' of https://github.com/coskunergan/zephyr-lang-rust

# Conflicts:
#	zephyr-sys/wrapper.h

Author: coskunergan

CMakeLists.txt

@@ -195,6 +195,7 @@ ${config_paths}
   add_custom_target(librustapp ALL
     DEPENDS ${DUMMY_FILE}
         # The variables, defined at the top level, don't seem to be accessible here.
+        offsets_h
         syscall_list_h_target
         driver_validation_h_target
         kobj_types_h_target
@@ -237,6 +238,7 @@ ${config_paths}
   add_custom_target(rustdoc
     DEPENDS generate_rust_docs
         # The variables, defined at the top level, don't seem to be accessible here.
+        offsets_h
         syscall_list_h_target
         driver_validation_h_target
         kobj_types_h_target

dt-rust.yaml

@@ -7,13 +7,10 @@
 # few instances were we can actually just match on a property.
 - name: gpio-controller
   rules:
-  - type: has_prop
-    value: gpio-controller
+    - !HasProp gpio-controller
   actions:
-  - type: instance
-    value:
-      raw:
-        type: myself
+    - !Instance
+      raw: !Myself
       device: crate::device::gpio::Gpio
       static_type: crate::device::gpio::GpioStatic
 
@@ -22,68 +19,53 @@
 # with each gpio.
 - name: gpio-leds
   rules:
-  - type: compatible
-    value:
-      names:
-      - gpio-leds
+    - !Compatible
+      names: [gpio-leds]
       level: 1
   actions:
-  - type: instance
-    value:
-      raw:
-        type: phandle
-        value: gpios
+    - !Instance
+      raw: !Phandle gpios
       device: crate::device::gpio::GpioPin
 
 # Flash controllers don't have any particular property to identify them, so we need a list of
 # compatible values that should match.
 - name: flash-controller
   rules:
-  - type: compatible
-    value:
+    - !Compatible
       names:
-      - "nordic,nrf52-flash-controller"
-      - "nordic,nrf51-flash-controller"
-      - "raspberrypi,pico-flash-controller"
-      - "zephyr,sim-flash"
+        - "nordic,nrf52-flash-controller"
+        - "nordic,nrf51-flash-controller"
+        - "raspberrypi,pico-flash-controller"
+        - "zephyr,sim-flash"
       level: 0
   actions:
-  - type: instance
-    value:
-      raw:
-        type: myself
+    - !Instance
+      raw: !Myself
       device: crate::device::flash::FlashController
 
 # Flash partitions exist as children of a node compatible with "soc-nv-flash" that itself is a child
 # of the controller itself.
 # TODO: Get the write and erase property from the DT if present.
 - name: flash-partition
   rules:
-  - type: compatible
-    value:
+    - !Compatible
       names:
-      - "fixed-partitions"
+        - "fixed-partitions"
       level: 1
-  - type: compatible
-    value:
+    - !Compatible
       names:
-      - "soc-nv-flash"
+        - "soc-nv-flash"
       level: 2
   actions:
-  - type: instance
-    value:
-      raw:
-        type: parent
-        value:
-          level: 3
-          args:
-          - type: reg
+    - !Instance
+      raw: !Parent
+        level: 3
+        args:
+          - !Reg
       device: "crate::device::flash::FlashPartition"
 
 # Generate a pseudo node that matches all of the labels across the tree with their nodes.
 - name: labels
-  rules:
-    - type: root
+  rules: !Root
   actions:
-  - type: labels
-
+    - !Labels

samples/work-philosophers/CMakeLists.txt renamed to samples/async-philosophers/CMakeLists.txt

@@ -3,6 +3,6 @@
 cmake_minimum_required(VERSION 3.20.0)
 
 find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
-project(work_philosophers)
+project(async_philosophers)
 
 rust_cargo_application()

samples/async-philosophers/Cargo.toml

@@ -0,0 +1,36 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+# This must be rustapp for now.
+name = "rustapp"
+version = "0.1.0"
+edition = "2021"
+description = "A sample hello world application in Rust"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = { version = "0.1.0", features = ["time-driver", "executor-zephyr"] }
+static_cell = "2.1"
+
+embassy-executor = { version = "0.7.0", features = ["log", "task-arena-size-2048"] }
+embassy-sync = "0.6.2"
+
+# For real builds, you should figure out your target's tick rate and set the appropriate feature,
+# like in these examples.  Without this, embassy-time will assume a 1Mhz tick rate, and every time
+# operation will involve a conversion.
+embassy-time = "0.4.0"
+# embassy-time = { version = "0.4.0", features = ["tick-hz-10_000"] }
+# embassy-time = { version = "0.4.0", features = ["tick-hz-100"] }
+
+# Dependencies that are used by build.rs.
+[build-dependencies]
+zephyr-build = "0.1.0"
+
+[profile.release]
+debug-assertions = true
+overflow-checks = true
+debug = true

samples/work-philosophers/Kconfig renamed to samples/async-philosophers/Kconfig

@@ -7,6 +7,7 @@ CONFIG_MAIN_STACK_SIZE=8192
 CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=4096
 
 CONFIG_POLL=y
+CONFIG_STACK_CANARIES=y
 
 # CONFIG_DEBUG=y
 

samples/work-philosophers/boards/rpi_pico.conf renamed to samples/async-philosophers/boards/rpi_pico.conf

@@ -1,6 +1,6 @@
 sample:
-  description: Philosphers, in Rust
-  name: workq philosophers rust
+  description: Async Philosphers, in Rust
+  name: async philosophers rust
 common:
   harness: console
   harness_config:

samples/work-philosophers/build.rs renamed to samples/async-philosophers/build.rs

@@ -0,0 +1,98 @@
+//! Async Semaphore based demo
+//!
+//! This implementation on the dining philosopher problem uses Zephyr semaphores to represent the
+//! forks.  Each philosopher dines as per the algorithm a number of times, and when the are all
+//! finished, the test is considered successful.  Deadlock will result in the primary thread not
+//! completing.
+//!
+//! Notably, this uses Rc and RefCell along with spawn_local to demonstrate that multiple async
+//! tasks run on the same worker do not need Send.  It is just important that write operations on
+//! the RefCell do not `.await` or a panic is likely.
+
+use embassy_executor::Spawner;
+use embassy_sync::{
+    blocking_mutex::raw::CriticalSectionRawMutex,
+    mutex::Mutex,
+    semaphore::{FairSemaphore, Semaphore},
+};
+use embassy_time::Timer;
+use zephyr::{printkln, sync::Arc};
+
+use crate::{get_random_delay, ResultSignal, Stats, NUM_PHIL};
+
+type ESemaphore = FairSemaphore<CriticalSectionRawMutex, NUM_PHIL>;
+
+/// The semaphores for the forks.
+static FORKS: [ESemaphore; NUM_PHIL] = [const { ESemaphore::new(1) }; NUM_PHIL];
+
+/// The semaphore to wait for them all to finish.
+static DONE_SEM: ESemaphore = ESemaphore::new(0);
+
+/// Number of iterations of each philospher.
+///
+/// Should be long enough to exercise the test, but too
+/// long and the test will timeout.  The delay calculated will randomly be between 25 and 775, and
+/// there are two waits, so typically, each "eat" will take about a second.
+const EAT_COUNT: usize = 10;
+
+#[embassy_executor::task]
+pub async fn phil(spawner: Spawner, stats_sig: &'static ResultSignal) {
+    // Our overall stats.
+    let stats = Arc::new(Mutex::new(Stats::default()));
+
+    // Spawn off each philosopher.
+    for i in 0..NUM_PHIL {
+        let forks = if i == NUM_PHIL - 1 {
+            [&FORKS[0], &FORKS[i]]
+        } else {
+            [&FORKS[i], &FORKS[i + 1]]
+        };
+
+        spawner.spawn(one_phil(forks, i, stats.clone())).unwrap();
+    }
+
+    // Wait for them all to finish.
+    DONE_SEM.acquire(NUM_PHIL).await.unwrap();
+
+    // Send the stats back.
+    stats_sig.signal(stats);
+}
+
+/// Simulate a single philospher.
+///
+/// The forks must be ordered with the first fork having th lowest number, otherwise this will
+/// likely deadlock.
+///
+/// This will run for EAT_COUNT times, and then return.
+#[embassy_executor::task(pool_size = NUM_PHIL)]
+async fn one_phil(
+    forks: [&'static ESemaphore; 2],
+    n: usize,
+    stats: Arc<Mutex<CriticalSectionRawMutex, Stats>>,
+) {
+    for i in 0..EAT_COUNT {
+        // Acquire the forks.
+        // printkln!("Child {n} take left fork");
+        forks[0].acquire(1).await.unwrap().disarm();
+        // printkln!("Child {n} take right fork");
+        forks[1].acquire(1).await.unwrap().disarm();
+
+        // printkln!("Child {n} eating");
+        let delay = get_random_delay(n, 25);
+        Timer::after(delay).await;
+        stats.lock().await.record_eat(n, delay);
+
+        // Release the forks.
+        // printkln!("Child {n} giving up forks");
+        forks[1].release(1);
+        forks[0].release(1);
+
+        let delay = get_random_delay(n, 25);
+        Timer::after(delay).await;
+        stats.lock().await.record_think(n, delay);
+
+        printkln!("Philospher {n} finished eating time {i}");
+    }
+
+    DONE_SEM.release(1);
+}