Make ahcid compile.

storage/ahcid/src/ahci/disk_ata.rs

@@ -144,6 +144,7 @@ impl DiskATA {
 
                 self.request_opt = Some(request);
 
+                // TODO: support async internally
                 return Ok(None);
             } else {
                 // Done
@@ -162,21 +163,21 @@ impl Disk for DiskATA {
         self.size
     }
 
-    fn read(&mut self, block: u64, buffer: &mut [u8]) -> Result<Option<usize>> {
+    async fn read(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
         //TODO: FIGURE OUT WHY INTERRUPTS CAUSE HANGS
         loop {
             match self.request(block, BufferKind::Read(buffer))? {
-                Some(count) => return Ok(Some(count)),
+                Some(count) => return Ok(count),
                 None => std::thread::yield_now(),
             }
         }
     }
 
-    fn write(&mut self, block: u64, buffer: &[u8]) -> Result<Option<usize>> {
+    async fn write(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
         //TODO: FIGURE OUT WHY INTERRUPTS CAUSE HANGS
         loop {
             match self.request(block, BufferKind::Write(buffer))? {
-                Some(count) => return Ok(Some(count)),
+                Some(count) => return Ok(count),
                 None => std::thread::yield_now(),
             }
         }

storage/ahcid/src/ahci/disk_atapi.rs

@@ -77,7 +77,7 @@ impl Disk for DiskATAPI {
         u64::from(self.blk_count) * u64::from(self.blk_size)
     }
 
-    fn read(&mut self, block: u64, buffer: &mut [u8]) -> Result<Option<usize>> {
+    async fn read(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
         // TODO: Handle audio CDs, which use special READ CD command
 
         let blk_len = self.blk_size;
@@ -139,10 +139,10 @@ impl Disk for DiskATAPI {
             sector += sectors - sector;
         }
 
-        Ok(Some((sector * blk_len) as usize))
+        Ok((sector * blk_len) as usize)
     }
 
-    fn write(&mut self, _block: u64, _buffer: &[u8]) -> Result<Option<usize>> {
+    async fn write(&mut self, _block: u64, _buffer: &[u8]) -> Result<usize> {
         Err(Error::new(EBADF)) // TODO: Implement writing
     }
 }

storage/ahcid/src/ahci/mod.rs

@@ -11,27 +11,58 @@ pub mod disk_atapi;
 pub mod fis;
 pub mod hba;
 
-pub fn disks(base: usize, name: &str) -> (&'static mut HbaMem, Vec<Box<dyn Disk>>) {
+pub enum AnyDisk {
+    Ata(DiskATA),
+    Atapi(DiskATAPI),
+}
+impl Disk for AnyDisk {
+    fn block_size(&self) -> u32 {
+        match self {
+            Self::Ata(a) => a.block_size(),
+            Self::Atapi(a) => a.block_size(),
+        }
+    }
+    fn size(&self) -> u64 {
+        match self {
+            Self::Ata(a) => a.size(),
+            Self::Atapi(a) => a.size(),
+        }
+    }
+    async fn read(&mut self, base: u64, buffer: &mut [u8]) -> syscall::Result<usize> {
+        match self {
+            Self::Ata(a) => a.read(base, buffer).await,
+            Self::Atapi(a) => a.read(base, buffer).await,
+        }
+    }
+    async fn write(&mut self, base: u64, buffer: &[u8]) -> syscall::Result<usize> {
+        match self {
+            Self::Ata(a) => a.write(base, buffer).await,
+            Self::Atapi(a) => a.write(base, buffer).await,
+        }
+    }
+}
+
+pub fn disks(base: usize, name: &str) -> (&'static mut HbaMem, Vec<AnyDisk>) {
     let hba_mem = unsafe { &mut *(base as *mut HbaMem) };
     hba_mem.init();
     let pi = hba_mem.pi.read();
-    let disks: Vec<Box<dyn Disk>> = (0..hba_mem.ports.len())
+    let disks: Vec<AnyDisk> = (0..hba_mem.ports.len())
         .filter(|&i| pi & 1 << i as i32 == 1 << i as i32)
         .filter_map(|i| {
             let port = unsafe { &mut *hba_mem.ports.as_mut_ptr().add(i) };
             let port_type = port.probe();
             info!("{}-{}: {:?}", name, i, port_type);
 
-            let disk: Option<Box<dyn Disk>> = match port_type {
+            let disk: Option<AnyDisk> = match port_type {
                 HbaPortType::SATA => match DiskATA::new(i, port) {
-                    Ok(disk) => Some(Box::new(disk)),
+                    Ok(disk) => Some(AnyDisk::Ata(disk)),
                     Err(err) => {
                         error!("{}: {}", i, err);
                         None
                     }
                 },
                 HbaPortType::SATAPI => match DiskATAPI::new(i, port) {
-                    Ok(disk) => Some(Box::new(disk)),
+                    Ok(disk) => Some(AnyDisk::Atapi(disk)),
                     Err(err) => {
                         error!("{}: {}", i, err);
                         None

storage/ahcid/src/main.rs

@@ -1,14 +1,11 @@
 #![cfg_attr(target_arch = "aarch64", feature(stdsimd))] // Required for yield instruction
 
-extern crate byteorder;
-extern crate syscall;
-
 use std::io::{Read, Write};
 use std::os::fd::AsRawFd;
 use std::usize;
 
 use common::io::Io;
-use driver_block::DiskScheme;
+use driver_block::{DiskScheme, ExecutorTrait, FuturesExecutor};
 use event::{EventFlags, RawEventQueue};
 use pcid_interface::PciFunctionHandle;
 
@@ -54,6 +51,7 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
                 .enumerate()
                 .map(|(i, disk)| (i as u32, disk))
                 .collect(),
+            &FuturesExecutor,
         );
 
         let mut irq_file = irq.irq_handle("ahcid");
@@ -75,7 +73,7 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
         for event in event_queue {
             let event = event.unwrap();
             if event.fd == scheme.event_handle().raw() {
-                scheme.tick().unwrap();
+                FuturesExecutor.block_on(scheme.tick()).unwrap();
             } else if event.fd == irq_fd {
                 let mut irq = [0; 8];
                 if irq_file
@@ -100,7 +98,7 @@ fn daemon(daemon: redox_daemon::Daemon) -> ! {
                             .write(&irq)
                             .expect("ahcid: failed to write irq file");
 
-                        scheme.tick().unwrap();
+                        FuturesExecutor.block_on(scheme.tick()).unwrap();
                     }
                 }
             } else {