Merge pull request #384 from roblabla/futures

IPC Server based on future executor

ahci/Cargo.toml

@@ -11,6 +11,7 @@ sunrise-libutils = { path = "../libutils" }
 spin = "0.5"
 log = "0.4.6"
 bitfield = "0.13.1"
+futures-preview = { version = "0.3.0-alpha.16", default-features = false, features = ["nightly", "alloc"] }
 
 [dependencies.lazy_static]
 features = ["spin_no_std"]

ahci/src/disk.rs

@@ -9,7 +9,7 @@ use sunrise_libuser::error::{Error, AhciError};
 use sunrise_libuser::types::SharedMemory;
 use sunrise_libuser::syscalls::MemoryPermissions;
 use sunrise_libuser::ahci::IDisk as IDiskInterface;
-use sunrise_libuser::ipc::server::WaitableManager;
+use sunrise_libuser::futures::WorkQueue;
 use sunrise_libuser::zero_box::ZeroBox;
 
 use crate::hba::*;
@@ -167,7 +167,7 @@ impl IDisk {
 
 impl IDiskInterface for IDisk {
     /// Returns the number of addressable 512-octet sectors for this disk.
-    fn sector_count(&mut self, _manager: &WaitableManager) -> Result<u64, Error> {
+    fn sector_count(&mut self, _work_queue: WorkQueue<'static>) -> Result<u64, Error> {
         Ok(self.0.lock().sectors)
     }
 
@@ -186,7 +186,7 @@ impl IDiskInterface for IDisk {
     ///     - The passed handle points to memory that is so physically scattered it overflows
     ///       the PRDT. This can only happen for read/writes of 1985 sectors or more.
     ///       You should consider retrying with a smaller `sector_count`.
-    fn read_dma(&mut self, _manager: &WaitableManager, sharedmem: SharedMemory, mapping_size: u64, lba: u64, sector_count: u64) -> Result<(), Error> {
+    fn read_dma(&mut self, _manager: WorkQueue<'static>, sharedmem: SharedMemory, mapping_size: u64, lba: u64, sector_count: u64) -> Result<(), Error> {
         let addr = sunrise_libuser::mem::find_free_address(mapping_size as _, 0x1000)?;
         let mapped = sharedmem.map(addr, mapping_size as _, MemoryPermissions::empty())
         // no need for permission, only the disk will dma to it.
@@ -209,7 +209,7 @@ impl IDiskInterface for IDisk {
     ///     - The passed handle points to memory that is so physically scattered it overflows
     ///       the PRDT. This can only happen for read/writes of 1985 sectors or more.
     ///       You should consider retrying with a smaller `sector_count`.
-    fn write_dma(&mut self, _manager: &WaitableManager, sharedmem: SharedMemory, mapping_size: u64, lba: u64, sector_count: u64) -> Result<(), Error> {
+    fn write_dma(&mut self, _manager: WorkQueue<'static>, sharedmem: SharedMemory, mapping_size: u64, lba: u64, sector_count: u64) -> Result<(), Error> {
         let addr = sunrise_libuser::mem::find_free_address(mapping_size as _, 0x1000)?;
         let mapped = sharedmem.map(addr, mapping_size as _, MemoryPermissions::empty())
         // no need for permission, only the disk will dma to it.

ahci/src/main.rs

@@ -75,11 +75,12 @@ use alloc::boxed::Box;
 use alloc::vec::Vec;
 use alloc::sync::Arc;
 use sunrise_libuser::error::{Error, AhciError};
-use sunrise_libuser::ipc::server::{WaitableManager, PortHandler, IWaitable};
+use sunrise_libuser::futures::{WaitableManager, WorkQueue};
+use sunrise_libuser::ipc::server::{port_handler, new_session_wrapper};
 use spin::Mutex;
 use sunrise_libuser::syscalls;
-use sunrise_libuser::ipc::server::SessionWrapper;
 use sunrise_libuser::ahci::{AhciInterface as IAhciInterface, IDiskProxy, IDisk as _};
+use futures::future::FutureObj;
 
 /// Array of discovered disk.
 ///
@@ -112,9 +113,9 @@ fn main() {
     debug!("AHCI initialised disks : {:#x?}", DISKS);
 
     // event loop
-    let man = WaitableManager::new();
-    let handler = Box::new(PortHandler::new("ahci:\0", AhciInterface::dispatch).unwrap());
-    man.add_waitable(handler as Box<dyn IWaitable>);
+    let mut man = WaitableManager::new();
+    let handler = port_handler(man.work_queue(), "ahci:\0", AhciInterface::dispatch).unwrap();
+    man.work_queue().spawn(FutureObj::new(Box::new(handler)));
     man.run();
 }
 
@@ -134,7 +135,7 @@ impl IAhciInterface for AhciInterface {
     /// Returns the number of discovered disks.
     ///
     /// Any number in the range `0..disk_count()` is considered a valid disk id.
-    fn discovered_disks_count(&mut self, _manager: &WaitableManager) -> Result<u32, Error> {
+    fn discovered_disks_count(&mut self, _manager: WorkQueue<'static>) -> Result<u32, Error> {
         Ok(DISKS.lock().len() as u32)
     }
 
@@ -145,14 +146,14 @@ impl IAhciInterface for AhciInterface {
     /// # Error
     ///
     /// - InvalidArg: `disk_id` is not a valid disk id.
-    fn get_disk(&mut self, manager: &WaitableManager, disk_id: u32,) -> Result<IDiskProxy, Error> {
+    fn get_disk(&mut self, work_queue: WorkQueue<'static>, disk_id: u32,) -> Result<IDiskProxy, Error> {
         let idisk = IDisk::new(Arc::clone(
             DISKS.lock().get(disk_id as usize)
             .ok_or(AhciError::InvalidArg)?
         ));
         let (server, client) = syscalls::create_session(false, 0)?;
-        let wrapper = SessionWrapper::new(server, idisk, IDisk::dispatch);
-        manager.add_waitable(Box::new(wrapper) as Box<dyn IWaitable>);
+        let wrapper = new_session_wrapper(work_queue.clone(), server, idisk, IDisk::dispatch);
+        work_queue.spawn(FutureObj::new(Box::new(wrapper)));
         Ok(IDiskProxy::from(client))
     }
 }