Remove the async-support crate

Author: Woyten

Cargo.toml

@@ -12,7 +12,6 @@ custom_alloc_error_handler = ["libtock-core/custom_alloc_error_handler"]
 __internal_disable_gpio_in_integration_test = []
 
 [dependencies]
-core = { package = "async-support", path = "async-support" }
 libtock-core = { path = "core" }
 libtock_codegen = { path = "codegen" }
 futures = { version = "0.3.1", default-features = false, features = ["unstable", "cfg-target-has-atomic"] }
@@ -58,7 +57,6 @@ lto = true
 
 [workspace]
 members = [
-    "async-support",
     "codegen",
     "core",
     "test-runner"

async-support/Cargo.toml

@@ -98,7 +98,7 @@ fn try_generate_main_wrapped(
                 MAIN_INVOKED = true;
             }
             let _block = async #block;
-            unsafe {::core::executor::block_on(_block) }
+            unsafe { ::libtock::executor::block_on(_block) }
         }
     ))
 }

async-support/src/lib.rs

@@ -10,23 +10,7 @@ use crate::result::SubscribeError;
 use crate::shared_memory::SharedMemory;
 
 pub mod raw {
-    use super::platform;
-
-    pub use platform::*;
-
-    /// # Safety
-    ///
-    /// Yielding in the main function should be safe. Nevertheless, yielding manually is not required as this is already achieved by the `async` runtime.
-    ///
-    /// When yielding in callbacks, two problems can arise:
-    /// - The guarantees of `FnMut` are violated. In this case, make sure your callback has `Fn` behavior.
-    /// - Callbacks can get executed in a nested manner and overflow the stack quickly.
-    ///
-    /// This function is exported as `libtock::syscalls::raw::yieldk`. Do not reference this name directly. Its only purpose is to establish a back-channel from `async-support`, a patched version of `core` to `libtock-rs` via linking. This workaround has been chosen to keep the `core` crate free of dependencies on platform-specific syscall implementations and is expected to get removed as soon as possible.
-    #[export_name = "libtock::syscalls::raw::yieldk"]
-    pub unsafe fn yieldk() {
-        platform::yieldk()
-    }
+    pub use super::platform::*;
 }
 
 pub fn subscribe<C: Consumer<T>, T>(

codegen/src/lib.rs

@@ -3,9 +3,14 @@ use core::cell::RefCell;
 use std::vec::Vec;
 
 /// yield for a callback fired by the kernel
+///
 /// # Safety
-/// Yielding inside a callback conflicts with Rust's safety guarantees. For example,
-/// a FnMut closure could be triggered multiple times making a &mut a shared reference.
+///
+/// Yielding in the main function should be safe. Nevertheless, yielding manually is not required as this is already achieved by the `async` runtime.
+///
+/// When yielding in callbacks, two problems can arise:
+/// - The guarantees of `FnMut` are violated. In this case, make sure your callback has `Fn` behavior.
+/// - Callbacks can get executed in a nested manner and overflow the stack quickly.
 pub unsafe fn yieldk() {
     EVENTS.with(|e| e.borrow_mut().push(Event::YieldK));
 }

core/src/syscalls/mod.rs

@@ -1,9 +1,9 @@
 use crate::callback::Identity0Consumer;
+use crate::executor;
 use crate::futures;
 use crate::result::TockResult;
 use crate::syscalls;
 use core::cell::Cell;
-use core::executor;
 use core::fmt;
 use core::mem;
 

core/src/syscalls/platform.rs

@@ -0,0 +1,50 @@
+use futures::Future;
+use core::task::Waker;
+use core::task::Poll;
+use core::task::Context;
+use core::task::RawWaker;
+use core::task::RawWakerVTable;
+use core::pin::Pin;
+use core::ptr;
+use crate::syscalls;
+
+/// # Safety
+///
+/// [[block_on]] yields whenever a future cannot make any progress at present. Yielding is considered unsafe.
+pub unsafe fn block_on<T>(mut future: impl Future<Output = T>) -> T {
+    // Contract described in the Rustdoc: "A value, once pinned, must remain pinned forever (...).".
+    // IOW calling Pin::new_unchecked is safe as long as no &mut future is leaked after pinning.
+    let mut pinned_future = Pin::new_unchecked(&mut future);
+
+    loop {
+        match poll(pinned_future.as_mut()) {
+            Poll::Pending => syscalls::raw::yieldk(),
+            Poll::Ready(value) => {
+                return value;
+            }
+        }
+    }
+}
+
+fn poll<F: Future>(pinned_future: Pin<&mut F>) -> Poll<F::Output> {
+    let waker = unsafe { Waker::from_raw(get_dummy_waker()) };
+    let mut context = Context::from_waker(&waker);
+    pinned_future.poll(&mut context)
+}
+
+// Since Tock OS comes with waking-up functionality built-in, we use dummy wakers that do nothing at all.
+fn get_dummy_waker() -> RawWaker {
+    fn clone(_x: *const ()) -> RawWaker {
+        get_dummy_waker()
+    }
+
+    fn do_nothing(_x: *const ()) {}
+
+    // This vtable implements the methods required for managing the lifecycle of the wakers.
+    // Our wakers are dummies, so those functions don't do anything.
+    static DUMMY_WAKER_VTABLE: RawWakerVTable =
+        RawWakerVTable::new(clone, do_nothing, do_nothing, do_nothing);
+
+    // The wakers don't have any implementation, so the instance can simply be null.
+    RawWaker::new(ptr::null(), &DUMMY_WAKER_VTABLE)
+}

src/console.rs

@@ -8,6 +8,7 @@ pub mod console;
 pub mod debug;
 pub mod drivers;
 pub mod electronics;
+pub mod executor;
 pub mod futures;
 pub mod gpio;
 pub mod leds;

src/executor.rs

@@ -1,9 +1,9 @@
+use crate::executor;
 use crate::futures;
 use crate::result::TockResult;
 use crate::syscalls;
 use core::cell::Cell;
 use core::convert::From;
-use core::executor;
 use core::fmt;
 use core::mem;