Auto merge of #58 - japaric:init-resources, r=japaric

safe `&'static mut` references via init.resources

see RFC #59 for details

Author: homunkulus

.gitignore

@@ -1,5 +1,6 @@
 **/*.rs.bk
 *.org
+.#*
 .gdb_history
 Cargo.lock
 target/

Cargo.toml

@@ -15,11 +15,13 @@ version = "0.3.0"
 [dependencies]
 cortex-m = { git = "https://github.com/japaric/cortex-m" }
 untagged-option = "0.1.1"
-rtfm-core = "0.1.0"
+# rtfm-core = "0.2.0"
+rtfm-core = { git = "https://github.com/japaric/rtfm-core" }
 cortex-m-rtfm-macros = { path = "macros" }
 
 [target.'cfg(target_arch = "x86_64")'.dev-dependencies]
-compiletest_rs = "0.3.3"
+# compiletest_rs = "0.3.4"
+compiletest_rs = { git = "https://github.com/dwrensha/compiletest-rs", branch = "rustup" }
 
 [dev-dependencies.cortex-m-rt]
 features = ["abort-on-panic"]

examples/custom-type.rs

@@ -0,0 +1,50 @@
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![feature(proc_macro)]
+#![no_std]
+
+extern crate cortex_m_rtfm as rtfm;
+extern crate stm32f103xx;
+
+use rtfm::{app, Threshold};
+
+pub struct Foo;
+
+app! {
+    device: stm32f103xx,
+
+    resources: {
+        static CO_OWNED: Foo = Foo;
+        static ON: Foo = Foo;
+        static OWNED: Foo = Foo;
+        static SHARED: Foo = Foo;
+    },
+
+    idle: {
+        resources: [OWNED, SHARED],
+    },
+
+    tasks: {
+        SYS_TICK: {
+            path: sys_tick,
+            resources: [CO_OWNED, ON, SHARED],
+        },
+
+        TIM2: {
+            enabled: false,
+            path: tim2,
+            priority: 1,
+            resources: [CO_OWNED],
+        },
+    },
+}
+
+fn init(_p: ::init::Peripherals, _r: ::init::Resources) {}
+
+fn idle(_t: &mut Threshold, _r: ::idle::Resources) -> ! {
+    loop {}
+}
+
+fn sys_tick(_t: &mut Threshold, _r: SYS_TICK::Resources) {}
+
+fn tim2(_t: &mut Threshold, _r: TIM2::Resources) {}

examples/full-syntax.rs

@@ -63,22 +63,22 @@ mod main {
             *r.OWNED != *r.OWNED;
 
             if *r.OWNED {
-                if r.SHARED.claim(t, |shared, _| **shared) {
+                if r.SHARED.claim(t, |shared, _| *shared) {
                     rtfm::wfi();
                 }
             } else {
-                r.SHARED.claim_mut(t, |shared, _| **shared = !**shared);
+                r.SHARED.claim_mut(t, |shared, _| *shared = !*shared);
             }
         }
     }
 }
 
-fn sys_tick(_t: &mut Threshold, r: SYS_TICK::Resources) {
-    **r.ON = !**r.ON;
+fn sys_tick(_t: &mut Threshold, mut r: SYS_TICK::Resources) {
+    *r.ON = !*r.ON;
 
-    **r.CO_OWNED += 1;
+    *r.CO_OWNED += 1;
 }
 
-fn tim2(_t: &mut Threshold, r: TIM2::Resources) {
-    **r.CO_OWNED += 1;
+fn tim2(_t: &mut Threshold, mut r: TIM2::Resources) {
+    *r.CO_OWNED += 1;
 }

examples/generics.rs

@@ -70,5 +70,5 @@ fn exti0(t: &mut Threshold, r: EXTI0::Resources) {
 
 // This task has direct access to the resources
 fn exti1(t: &mut Threshold, r: EXTI1::Resources) {
-    work(t, r.GPIOA, r.SPI1);
+    work(t, &r.GPIOA, &r.SPI1);
 }

examples/late-resources.rs

@@ -1,5 +1,4 @@
 //! Demonstrates initialization of resources in `init`.
-
 #![deny(unsafe_code)]
 #![deny(warnings)]
 #![feature(proc_macro)]

examples/one-task.rs

@@ -77,11 +77,11 @@ fn idle() -> ! {
 // `r` is the set of resources this task has access to. `SYS_TICK::Resources`
 // has one field per resource declared in `app!`.
 #[allow(unsafe_code)]
-fn sys_tick(_t: &mut Threshold, r: SYS_TICK::Resources) {
+fn sys_tick(_t: &mut Threshold, mut r: SYS_TICK::Resources) {
     // toggle state
-    **r.ON = !**r.ON;
+    *r.ON = !*r.ON;
 
-    if **r.ON {
+    if *r.ON {
         // set the pin PC13 high
         // NOTE(unsafe) atomic write to a stateless register
         unsafe {

examples/preemption.rs

@@ -42,12 +42,12 @@ fn idle() -> ! {
     }
 }
 
-fn sys_tick(_t: &mut Threshold, r: SYS_TICK::Resources) {
+fn sys_tick(_t: &mut Threshold, mut r: SYS_TICK::Resources) {
     // ..
 
     // This task can't be preempted by `tim2` so it has direct access to the
     // resource data
-    **r.COUNTER += 1;
+    *r.COUNTER += 1;
 
     // ..
 }
@@ -61,7 +61,7 @@ fn tim2(t: &mut Threshold, mut r: TIM2::Resources) {
     // lead to undefined behavior.
     r.COUNTER.claim_mut(t, |counter, _t| {
         // `claim_mut` creates a critical section
-        **counter += 1;
+        *counter += 1;
     });
 
     // ..

examples/safe-static-mut-ref.rs

@@ -0,0 +1,32 @@
+//! Safe creation of `&'static mut` references
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![feature(proc_macro)]
+#![no_std]
+
+extern crate cortex_m_rtfm as rtfm;
+extern crate stm32f103xx;
+
+use rtfm::app;
+
+app! {
+    device: stm32f103xx,
+
+    resources: {
+        static BUFFER: [u8; 16] = [0; 16];
+    },
+
+    init: {
+        resources: [BUFFER],
+    },
+}
+
+fn init(_p: init::Peripherals, r: init::Resources) {
+    let _buf: &'static mut [u8] = r.BUFFER;
+}
+
+fn idle() -> ! {
+    loop {
+        rtfm::wfi();
+    }
+}

examples/two-tasks.rs

@@ -42,18 +42,18 @@ fn idle() -> ! {
 
 // As both tasks are running at the same priority one can't preempt the other.
 // Thus both tasks have direct access to the resource
-fn sys_tick(_t: &mut Threshold, r: SYS_TICK::Resources) {
+fn sys_tick(_t: &mut Threshold, mut r: SYS_TICK::Resources) {
     // ..
 
-    **r.COUNTER += 1;
+    *r.COUNTER += 1;
 
     // ..
 }
 
-fn tim2(_t: &mut Threshold, r: TIM2::Resources) {
+fn tim2(_t: &mut Threshold, mut r: TIM2::Resources) {
     // ..
 
-    **r.COUNTER += 1;
+    *r.COUNTER += 1;
 
     // ..
 }

macros/Cargo.toml

@@ -12,7 +12,8 @@ version = "0.2.1"
 [dependencies]
 error-chain = "0.10.0"
 quote = "0.3.15"
-rtfm-syntax = "0.2.0"
+# rtfm-syntax = "0.2.0"
+rtfm-syntax = { git = "https://github.com/japaric/rtfm-syntax" }
 syn = "0.11.11"
 
 [lib]

macros/src/analyze.rs

@@ -17,6 +17,13 @@ pub enum Ownership {
 }
 
 impl Ownership {
+    pub fn ceiling(&self) -> u8 {
+        match *self {
+            Ownership::Owned { priority } => priority,
+            Ownership::Shared { ceiling } => ceiling,
+        }
+    }
+
     pub fn is_owned(&self) -> bool {
         match *self {
             Ownership::Owned { .. } => true,

macros/src/check.rs

@@ -77,7 +77,38 @@ pub fn app(app: check::App) -> Result<App> {
 }
 
 fn resources(app: &App) -> Result<()> {
+    for name in &app.init.resources {
+        if let Some(resource) = app.resources.get(name) {
+            ensure!(
+                resource.expr.is_some(),
+                "resource `{}`, allocated to `init`, must have an initial value",
+                name
+            );
+        } else {
+            bail!(
+                "resource `{}`, allocated to `init`, must be a data resource",
+                name
+            );
+        }
+
+        ensure!(
+            !app.idle.resources.contains(name),
+            "resources assigned to `init` can't be shared with `idle`"
+        );
+
+        ensure!(
+            app.tasks
+                .iter()
+                .all(|(_, task)| !task.resources.contains(name)),
+            "resources assigned to `init` can't be shared with tasks"
+        )
+    }
+
     for resource in app.resources.keys() {
+        if app.init.resources.contains(resource) {
+            continue;
+        }
+
         if app.idle.resources.contains(resource) {
             continue;
         }