implemented yield_wait_for

apis/interface/buttons/src/lib.rs

@@ -110,6 +110,13 @@ impl<S: Syscalls> Buttons<S> {
     pub fn unregister_listener() {
         S::unsubscribe(DRIVER_NUM, 0)
     }
+
+    // Wrapper for yield_wait_for
+    pub fn wait_for_button(driver_number: u32, subscribe_number: u32) -> (u32, ButtonState) {
+        let (status, raw_state, _) = S::yield_wait_for(2, driver_number, subscribe_number);
+        let state = ButtonState::from(raw_state);
+        (status, state)
+    }
 }
 
 /// A wrapper around a closure to be registered and called when

apis/net/ieee802154/src/tests.rs

@@ -20,6 +20,9 @@ unsafe impl RawSyscalls for FakeSyscalls {
         libtock_unittest::fake::Syscalls::yield2([r0, r1])
     }
 
+    unsafe fn yield3([r0, r1, r2]: [Register; 3]) -> (Register, Register, Register) {
+        libtock_unittest::fake::Syscalls::yield3([r0, r1, r2])
+    }
     unsafe fn syscall1<const CLASS: usize>([r0]: [Register; 1]) -> [Register; 2] {
         libtock_unittest::fake::Syscalls::syscall1::<CLASS>([r0])
     }

examples/buttons_wait_for.rs

@@ -0,0 +1,49 @@
+//! An extremely simple libtock-rs example. Register button events.
+#![no_main]
+#![no_std]
+
+use core::fmt::Write;
+use libtock::buttons::{ButtonListener, Buttons};
+use libtock::console::Console;
+use libtock::leds::Leds;
+use libtock::runtime::{set_main, stack_size};
+use libtock_platform::share;
+// use libtock_runtime::TockSyscalls;
+
+set_main! {main}
+stack_size! {0x1000}
+
+fn main() {
+    writeln!(Console::writer(), "main!").unwrap();
+    let listener = ButtonListener(|button, _state| {
+        let _ = Leds::toggle(button);
+        // writeln!(Console::writer(), "button {:?}: {:?}", button, state).unwrap();
+    });
+    if let Ok(buttons_count) = Buttons::count() {
+        writeln!(Console::writer(), "button count: {}", buttons_count).unwrap();
+
+        share::scope(|subscribe| {
+            Buttons::register_listener(&listener, subscribe).unwrap();
+            // Enable interrupts for each button press.
+            for i in 0..buttons_count {
+                Buttons::enable_interrupts(i).unwrap();
+            }
+
+            // Wait for buttons to be pressed.
+            loop {
+                for i in 0..buttons_count {
+                    let driver_number: u32 = 0x3;
+                    let subscribe_number: u32 = i as u32;
+                    let (status, state) = Buttons::wait_for_button(driver_number, subscribe_number);
+                    writeln!(
+                        Console::writer(),
+                        "Button pressed (yield_wait_for), status: {:?}, state: {:?}",
+                        status,
+                        state
+                    )
+                    .unwrap();
+                }
+            }
+        });
+    }
+}

platform/src/constants.rs

@@ -17,4 +17,5 @@ pub mod syscall_class {
 pub mod yield_id {
     pub const NO_WAIT: u32 = 0;
     pub const WAIT: u32 = 1;
+    pub const WAIT_FOR: u32 = 2;
 }

platform/src/raw_syscalls.rs

@@ -104,6 +104,24 @@ pub unsafe trait RawSyscalls: Sized {
     /// It has the same safety invariants as the underlying system call.
     unsafe fn yield2(_: [Register; 2]);
 
+    // yield3 can only be used to call `yield-wait-for`
+    // yield3 should:
+    //     1. Call syscall class 0
+    //     2. Pass in r0 and r1 as inlateout registers.
+    //     3. Mark all caller-saved registers as lateout clobbers.
+    //     4. NOT provide any of the following options:
+    //            pure             (yield has side effects)
+    //            nomem            (a callback can read + write globals)
+    //            readonly         (a callback can write globals)
+    //            preserves_flags  (a callback can change flags)
+    //            noreturn         (yield is expected to return)
+    //            nostack          (a callback needs the stack)
+    /// `yield3` should only be called by `libtock_platform`.
+    /// # Safety
+    /// yield3 may only be used for yield operations that do not return a value.
+    /// It has the same safety invariants as the underlying system call.
+    unsafe fn yield3(_: [Register; 3]) -> (Register, Register, Register);
+
     // syscall1 is only used to invoke Memop operations. Because there are no
     // Memop commands that set r2 or r3, raw_syscall1 only needs to return r0
     // and r1.

platform/src/syscalls.rs

@@ -20,6 +20,8 @@ pub trait Syscalls: RawSyscalls + Sized {
     /// callback, then returns.
     fn yield_wait();
 
+    fn yield_wait_for(r0: u32, driver_number: u32, subscribe_number: u32) -> (u32, u32, u32);
+
     // -------------------------------------------------------------------------
     // Subscribe
     // -------------------------------------------------------------------------

platform/src/syscalls_impl.rs

@@ -35,6 +35,25 @@ impl<S: RawSyscalls> Syscalls for S {
         }
     }
 
+    fn yield_wait_for(_r0: u32, driver_number: u32, subscribe_number: u32) -> (u32, u32, u32) {
+        // Safety: yield-wait does not return a value, which satisfies yield1's
+        // requirement. The yield-wait system call cannot trigger undefined
+        // behavior on its own in any other way.
+        unsafe {
+            let (r0, r1, r2) = Self::yield3([
+                yield_id::WAIT_FOR.into(),
+                driver_number.into(),
+                subscribe_number.into(),
+            ]);
+
+            (
+                r0.try_into().unwrap(),
+                r1.try_into().unwrap(),
+                r2.try_into().unwrap(),
+            )
+        }
+    }
+
     // -------------------------------------------------------------------------
     // Subscribe
     // -------------------------------------------------------------------------

runtime/src/syscalls_impl_arm.rs

@@ -43,6 +43,32 @@ unsafe impl RawSyscalls for crate::TockSyscalls {
         }
     }
 
+    unsafe fn yield3(
+        [Register(mut r0), Register(mut r1), Register(mut r2)]: [Register; 3],
+    ) -> (Register, Register, Register) {
+        // Safety: This matches the invariants required by the documentation on
+        // RawSyscalls::yield3
+        // the use of `clobber_abi` allows us this to run on both Thumb-1 and Thumb-2
+        #![allow(clippy::pointers_in_nomem_asm_block)]
+        unsafe {
+            asm!("svc 0",
+                 inlateout("r0") r0, // a1
+                 inlateout("r1") r1, // a2
+                 inlateout("r2") r2,
+                 // r4-r8 are callee-saved.
+                 // r9 is platform-specific. We don't use it in libtock_runtime,
+                 // so it is either unused or used as a callee-saved register.
+                 // r10 and r11 are callee-saved.
+
+                 // r13 is the stack pointer and must be restored by the callee.
+                 // r15 is the program counter.
+                 options(preserves_flags, nostack, nomem),
+                //  clobber_abi("C"), // a3, a4, ip (r12), lr (r14)
+            );
+        }
+        (Register(r0), Register(r1), Register(r2))
+    }
+
     unsafe fn syscall1<const SYSCALL_CLASS_NUMBER: usize>(
         [Register(mut r0)]: [Register; 1],
     ) -> [Register; 2] {

runtime/src/syscalls_impl_riscv.rs

@@ -68,6 +68,43 @@ unsafe impl RawSyscalls for crate::TockSyscalls {
         }
     }
 
+    #[cfg(not(any(target_feature = "d", target_feature = "f")))]
+    unsafe fn yield3(
+        [Register(mut r0), Register(mut r1), Register(mut r2)]: [Register; 3],
+    ) -> (Register, Register, Register) {
+        // Safety: This matches the invariants required by the documentation on
+        // RawSyscalls::yield2
+        #![allow(clippy::pointers_in_nomem_asm_block)]
+        unsafe {
+            asm!("ecall",
+                 // x0 is the zero register.
+                 lateout("x1") _, // Return address
+                 // x2-x4 are stack, global, and thread pointers. sp is
+                 // callee-saved.
+                 lateout("x5") _, // t0
+                 lateout("x6") _, // t1
+                 lateout("x7") _, // t2
+                 // x8 and x9 are s0 and s1 and are callee-saved.
+                 inlateout("x10") r0, // a0
+                 inlateout("x11") r1, // a1
+                 inlateout("x12") r2,         // a2
+                 lateout("x13") _,         // a3
+                 inlateout("x14") 0 => _,  // a4
+                 lateout("x15") _,         // a5
+                 lateout("x16") _,         // a6
+                 lateout("x17") _,         // a7
+                 // x18-27 are s2-s11 and are callee-saved
+                 lateout("x28") _, // t3
+                 lateout("x29") _, // t4
+                 lateout("x30") _, // t5
+                 lateout("x31") _, // t6
+                 options(preserves_flags, nostack, nomem),
+
+            );
+        }
+        (Register(r0), Register(r1), Register(r2))
+    }
+
     unsafe fn syscall1<const CLASS: usize>([Register(mut r0)]: [Register; 1]) -> [Register; 2] {
         let r1;
         // Safety: This matches the invariants required by the documentation on

unittest/src/expected_syscall.rs

@@ -21,6 +21,11 @@ pub enum ExpectedSyscall {
         skip_upcall: bool,
     },
 
+    YieldWaitFor {
+        driver: u32,
+        subscribe: u32,
+    },
+
     // -------------------------------------------------------------------------
     // Subscribe
     // -------------------------------------------------------------------------

unittest/src/fake/syscalls/raw_syscalls_impl.rs

@@ -7,6 +7,7 @@ unsafe impl RawSyscalls for crate::fake::Syscalls {
         match r0.try_into().expect("too-large Yield ID passed") {
             yield_id::NO_WAIT => panic!("yield-no-wait called without an argument"),
             yield_id::WAIT => super::yield_impl::yield_wait(),
+            yield_id::WAIT_FOR => panic!("yield-wait-for called without arguments"),
             id => panic!("unknown yield ID {}", id),
         }
     }
@@ -21,6 +22,17 @@ unsafe impl RawSyscalls for crate::fake::Syscalls {
                 // we fail the test case regardless.
                 panic!("yield-wait called with an argument");
             }
+            yield_id::WAIT_FOR => panic!("yield-wait-for called with just one argument"),
+            id => panic!("unknown yield ID {}", id),
+        }
+    }
+    unsafe fn yield3([r0, r1, r2]: [Register; 3]) -> (Register, Register, Register) {
+        crate::fake::syscalls::assert_valid((r0, r1, r2));
+        match r0.try_into().expect("too-large Yield ID passed") {
+            yield_id::NO_WAIT => panic!("yield-no-wait called with 2 arguments"),
+            yield_id::WAIT => panic!("yield-wait called with 2 arguments"),
+            yield_id::WAIT_FOR => unsafe { super::yield_impl::yield_wait_for(r0, r1, r2) },
+
             id => panic!("unknown yield ID {}", id),
         }
     }

unittest/src/fake/syscalls/yield_impl.rs

@@ -64,6 +64,50 @@ pub(super) fn yield_wait() {
     );
 }
 
+pub(super) unsafe fn yield_wait_for(
+    r0: libtock_platform::Register,
+    driver_number: libtock_platform::Register,
+    subscribe_number: libtock_platform::Register,
+) -> (
+    libtock_platform::Register,
+    libtock_platform::Register,
+    libtock_platform::Register,
+) {
+    let upcall_found = KERNEL_DATA.with(|refcell| {
+        let mut refmut = refcell.borrow_mut();
+        let kernel_data = refmut
+            .as_mut()
+            .expect("yield-wait-for called but no fake::Kernel exists");
+
+        kernel_data.syscall_log.push(SyscallLogEntry::YieldWaitFor);
+
+        match kernel_data.expected_syscalls.pop_front() {
+            None => false,
+            Some(ExpectedSyscall::YieldWaitFor { driver, subscribe })
+                if <libtock_platform::Register as From<u32>>::from(driver) == driver_number
+                    && <libtock_platform::Register as From<u32>>::from(subscribe)
+                        == subscribe_number =>
+            {
+                true
+            }
+            Some(expected_syscall) => {
+                kernel_data.expected_syscalls.push_front(expected_syscall);
+                false
+            }
+        }
+    });
+
+    if upcall_found {
+        return (r0, driver_number, subscribe_number);
+    }
+
+    assert!(
+        invoke_next_upcall(),
+        "yield-wait-for called with no queueued upcall"
+    );
+    (r0, driver_number, subscribe_number)
+}
+
 // Pops the next upcall off the kernel data's upcall queue and invokes it, or
 // does nothing if the upcall queue was entry. The return value indicates
 // whether an upcall was run. Panics if no kernel data is present.

unittest/src/fake/syscalls/yield_impl_tests.rs

@@ -223,8 +223,16 @@ fn yield1() {
     }
     assert_eq!(kernel.take_syscall_log(), [SyscallLogEntry::YieldWait]);
 
-    // Call yield1 with a yield ID that is unknown but which fits in a u32.
+    // Call yield-no-wait through yield1, which is not valid.
     let result = catch_unwind(|| unsafe { fake::Syscalls::yield1([2u32.into()]) });
+    assert!(result
+        .expect_err("failed to catch yield-no-wait without arg")
+        .downcast_ref::<&'static str>()
+        .expect("wrong panic payload type")
+        .contains("yield-wait-for called without arguments"));
+
+    // Call yield1 with a yield ID that is unknown but which fits in a u32.
+    let result = catch_unwind(|| unsafe { fake::Syscalls::yield1([3u32.into()]) });
     assert!(result
         .expect_err("failed to catch incorrect yield ID -- new ID added?")
         .downcast_ref::<String>()
@@ -262,6 +270,14 @@ fn yield2() {
     assert_eq!(kernel.take_syscall_log(), [SyscallLogEntry::YieldNoWait]);
     assert_eq!(return_value, YieldNoWaitReturn::Upcall);
 
+    // // Call yield-no-wait through yield2, which should be rejected.
+    // let result = catch_unwind(|| unsafe { fake::Syscalls::yield2([0u32.into(), 0u32.into()]) });
+    // assert!(result
+    //     .expect_err("failed to catch yield-wait with arg")
+    //     .downcast_ref::<&'static str>()
+    //     .expect("wrong panic payload type")
+    //     .contains("yield-no-wait called with an argument"));
+
     // Call yield-wait through yield2, which should be rejected.
     let result = catch_unwind(|| unsafe { fake::Syscalls::yield2([1u32.into(), 0u32.into()]) });
     assert!(result
@@ -270,8 +286,15 @@ fn yield2() {
         .expect("wrong panic payload type")
         .contains("yield-wait called with an argument"));
 
-    // Call yield2 with a yield ID that is unknown but which fits in a u32.
+    // Call yield-wait-for through yield2, which should be rejected.
     let result = catch_unwind(|| unsafe { fake::Syscalls::yield2([2u32.into(), 0u32.into()]) });
+    assert!(result
+        .expect_err("failed to catch yield-wait-for with arg")
+        .downcast_ref::<&'static str>()
+        .expect("wrong panic payload type")
+        .contains("yield-wait-for called with just one argument"));
+    // Call yield2 with a yield ID that is unknown but which fits in a u32.
+    let result = catch_unwind(|| unsafe { fake::Syscalls::yield2([3u32.into(), 0u32.into()]) });
     assert!(result
         .expect_err("failed to catch incorrect yield ID -- new ID added?")
         .downcast_ref::<String>()

unittest/src/syscall_log.rs

@@ -10,6 +10,7 @@ pub enum SyscallLogEntry {
 
     YieldWait,
 
+    YieldWaitFor,
     // -------------------------------------------------------------------------
     // Subscribe
     // -------------------------------------------------------------------------