drop `lock` methods, add `raise_to` function

5 files changed, 48 insertions, 22 deletions

diff --git a/tests/cfail/borrow.rs b/tests/cfail/borrow.rs
index ca246e7..d72402d 100644
--- a/tests/cfail/borrow.rs
+++ b/tests/cfail/borrow.rs
@@ -10,22 +10,24 @@ static R5: Resource<i32, C1> = Resource::new(0);
 static R6: Resource<i32, C2> = Resource::new(0);
 
 fn j1(prio: P2) {
-    R1.lock(&prio, |r1, c3| {
-        // CAN borrow a resource with ceiling C when the system ceiling SC > C
-        let r2 = R2.borrow(&prio, &c3);
+    let ceil = prio.as_ceiling();
 
-        // CAN borrow a resource with ceiling C when the system ceiling SC == C
-        let r3 = R3.borrow(&prio, &c3);
+    rtfm::raise_to(ceil, &R1, |ceil| {
+        // CAN borrow a resource with ceiling C when the current ceiling SC > C
+        let r2 = R2.borrow(&prio, ceil);
 
-        // CAN'T borrow a resource with ceiling C when the system ceiling SC < C
-        let r4 = R4.borrow(&prio, &c3);
+        // CAN borrow a resource with ceiling C when the current ceiling SC == C
+        let r3 = R3.borrow(&prio, ceil);
+
+        // CAN'T borrow a resource with ceiling C when the current ceiling SC < C
+        let r4 = R4.borrow(&prio, ceil);
         //~^ error
 
         // CAN'T borrow a resource with ceiling C < P (task priority)
-        let r5 = R5.borrow(&prio, &c3);
+        let r5 = R5.borrow(&prio, ceil);
         //~^ error
 
         // CAN borrow a resource with ceiling C == P (task priority)
-        let r6 = R6.borrow(&prio, &c3);
+        let r6 = R6.borrow(&prio, ceil);
     });
 }
diff --git a/tests/cfail/ceiling.rs b/tests/cfail/ceiling.rs
index a10aee9..bd6e296 100644
--- a/tests/cfail/ceiling.rs
+++ b/tests/cfail/ceiling.rs
@@ -5,9 +5,11 @@ use rtfm::{C3, P0, P2, Resource};
 static R1: Resource<(), C3> = Resource::new(());
 
 fn j1(prio: P2) {
-    let c3 = R1.lock(&prio, |r1, c3| {
+    let ceil = prio.as_ceiling();
+
+    let c3 = rtfm::raise_to(ceil, &R1, |ceil| {
         // forbidden: ceiling token can't outlive critical section
-        c3  //~ error
+        ceil  //~ error
     });
 
     // Would be bad: lockless access to a resource with ceiling = 3
diff --git a/tests/cfail/lock.rs b/tests/cfail/lock.rs
index c69c0df..60a441c 100644
--- a/tests/cfail/lock.rs
+++ b/tests/cfail/lock.rs
@@ -6,32 +6,44 @@ static R1: Resource<i32, C2> = Resource::new(0);
 
 // You CAN'T lock a resource with ceiling C from a task with priority P if P > C
 fn j1(prio: P3) {
-    R1.lock(&prio, |_, _| {});
-    //~^ error
+    let ceil = prio.as_ceiling();
+
+    rtfm::raise_to(ceil, &R1, |ceil| {
+        //~^ error
+    });
 }
 
 // DON'T lock a resource with ceiling equal to the task priority.
 // Instead use `borrow`
 fn j2(prio: P2) {
-    R1.lock(&prio, |_, _| {});
+    let ceil = prio.as_ceiling();
+
+    rtfm::raise_to(ceil, &R1, |_| {});
     //~^ error
 
     // OK
-    let r1 = R1.borrow(&prio, prio.as_ceiling());
+    let r1 = R1.borrow(&prio, ceil);
 }
 
 // You CAN lock a resource with ceiling C from a task with priority P if C > P
 fn j3(prio: P1) {
+    let ceil = prio.as_ceiling();
+
     // OK
-    R1.lock(&prio, |r1, _| {});
+    rtfm::raise_to(ceil, &R1, |ceil| {
+        let r1 = R1.borrow(&prio, ceil);
+    })
 }
 
 static R2: Resource<i32, C16> = Resource::new(0);
 
 // Tasks with priority less than P16 can't lock a resource with ceiling C16
 fn j4(prio: P1) {
-    R2.lock(&prio, |_, _| {});
-    //~^ error
+    let ceil = prio.as_ceiling();
+
+    rtfm::raise_to(ceil, &R2, |ceil| {
+        //~^ error
+    });
 }
 
 // Only tasks with priority P16 can claim a resource with ceiling C16
diff --git a/tests/cfail/race-1.rs b/tests/cfail/race-1.rs
index 35a476d..0b32c5e 100644
--- a/tests/cfail/race-1.rs
+++ b/tests/cfail/race-1.rs
@@ -5,7 +5,11 @@ use rtfm::{C2, C4, P1, P3, Resource};
 static R1: Resource<i32, C2> = Resource::new(0);
 
 fn j1(prio: P1) {
-    R1.lock(&prio, |r1, _| {
+    let ceil = prio.as_ceiling();
+
+    rtfm::raise_to(&ceil, &R1, |ceil| {
+        let r1 = R1.borrow(&prio, ceil);
+
         // Would preempt this critical section
         // rtfm::request(j2);
     });
diff --git a/tests/cfail/race-2.rs b/tests/cfail/race-2.rs
index 23d7dd4..7f3504d 100644
--- a/tests/cfail/race-2.rs
+++ b/tests/cfail/race-2.rs
@@ -6,17 +6,23 @@ static R1: Resource<i32, C2> = Resource::new(0);
 static R2: Resource<i32, C4> = Resource::new(0);
 
 fn j1(prio: P1) {
-    R1.lock(&prio, |r1, _| {
+    let ceil = prio.as_ceiling();
+
+    rtfm::raise_to(ceil, &R1, |ceil| {
+        let r1 = R1.borrow(&prio, ceil);
+
         // Would preempt this critical section
         // rtfm::request(j2);
     });
 }
 
 fn j2(prio: P3) {
-    R2.lock(&prio, |r2, c4| {
+    let ceil = prio.as_ceiling();
+
+    rtfm::raise_to(ceil, &R2, |ceil| {
         // OK  C2 (R1's ceiling) <= C4 (system ceiling)
         // BAD C2 (R1's ceiling) <  P3 (j2's priority)
-        let r1 = R1.borrow(&prio, &c4);
+        let r1 = R1.borrow(&prio, ceil);
         //~^ error
     });
 }