firmware: eliminate uses of std_artiq::io::{Read,Write} from runtime.

artiq/firmware/Cargo.lock

@@ -111,7 +111,6 @@ name = "io"
 version = "0.0.0"
 dependencies = [
  "byteorder 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "std_artiq 0.0.0",
 ]
 
 [[package]]

artiq/firmware/libio/Cargo.toml

@@ -9,7 +9,6 @@ path = "lib.rs"
 
 [dependencies]
 byteorder = { version = "1.0", default-features = false, optional = true }
-std_artiq = { path = "../libstd_artiq", optional = true }
 
 [features]
 alloc = []

artiq/firmware/libio/lib.rs

@@ -8,9 +8,6 @@ extern crate alloc;
 #[cfg(feature = "byteorder")]
 extern crate byteorder;
 
-#[cfg(feature = "std_artiq")]
-extern crate std_artiq;
-
 use core::result;
 use core::fmt;
 
@@ -67,6 +64,14 @@ pub trait Read {
     }
 }
 
+impl<'a, T: Read> Read for &'a mut T {
+    type ReadError = T::ReadError;
+
+    fn read(&mut self, buf: &mut [u8]) -> result::Result<usize, Self::ReadError> {
+        T::read(self, buf)
+    }
+}
+
 pub trait Write {
     type WriteError;
     type FlushError;
@@ -99,7 +104,23 @@ pub trait Write {
     fn size_hint(&mut self, _min: usize, _max: Option<usize>) {}
 }
 
-#[cfg(not(feature = "std_artiq"))]
+impl<'a, T: Write> Write for &'a mut T {
+    type WriteError = T::WriteError;
+    type FlushError = T::FlushError;
+
+    fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError> {
+        T::write(self, buf)
+    }
+
+    fn flush(&mut self) -> result::Result<(), Self::FlushError> {
+        T::flush(self)
+    }
+
+    fn size_hint(&mut self, min: usize, max: Option<usize>) {
+        T::size_hint(self, min, max)
+    }
+}
+
 impl<'a> Write for &'a mut [u8] {
     type WriteError = !;
     type FlushError = !;
@@ -116,6 +137,22 @@ impl<'a> Write for &'a mut [u8] {
     }
 }
 
+#[cfg(feature = "alloc")]
+impl<'a> Write for alloc::Vec<u8> {
+    type WriteError = !;
+    type FlushError = !;
+
+    fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError> {
+        self.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> result::Result<(), Self::FlushError> {
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CursorError {
     EndOfBuffer
@@ -196,7 +233,7 @@ impl Write for Cursor<::alloc::Vec<u8>> {
 
     #[inline]
     fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError> {
-        self.inner.extend(buf);
+        self.inner.extend_from_slice(buf);
         Ok(buf.len())
     }
 
@@ -205,44 +242,3 @@ impl Write for Cursor<::alloc::Vec<u8>> {
         Ok(())
     }
 }
-
-#[cfg(feature = "std_artiq")]
-impl<T> Read for T where T: std_artiq::io::Read + ?Sized {
-    type ReadError = std_artiq::io::Error;
-
-    fn read(&mut self, buf: &mut [u8]) -> result::Result<usize, Self::ReadError> {
-        std_artiq::io::Read::read(self, buf)
-    }
-}
-
-#[cfg(feature = "std_artiq")]
-impl<T> Write for T where T: std_artiq::io::Write + ?Sized {
-    type WriteError = std_artiq::io::Error;
-    type FlushError = std_artiq::io::Error;
-
-    fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError> {
-        std_artiq::io::Write::write(self, buf)
-    }
-
-    fn flush(&mut self) -> result::Result<(), Self::WriteError> {
-        std_artiq::io::Write::flush(self)
-    }
-}
-
-#[cfg(feature = "std_artiq")]
-impl<T> From<Error<T>> for std_artiq::io::Error
-    where T: Into<std_artiq::io::Error>
-{
-    fn from(value: Error<T>) -> std_artiq::io::Error {
-        match value {
-            Error::UnexpectedEof =>
-                std_artiq::io::Error::new(std_artiq::io::ErrorKind::UnexpectedEof,
-                                          "unexpected end of stream"),
-            Error::Unrecognized =>
-                std_artiq::io::Error::new(std_artiq::io::ErrorKind::InvalidData,
-                                          "unrecognized data"),
-            Error::Other(err) =>
-                err.into()
-        }
-    }
-}

artiq/firmware/libio/proto.rs

@@ -36,21 +36,6 @@ impl<T> From<ReadStringError<IoError<T>>> for IoError<T>
     }
 }
 
-#[cfg(feature = "alloc")]
-#[cfg(feature = "std_artiq")]
-impl<T> From<ReadStringError<T>> for ::std_artiq::io::Error
-        where T: Into<::std_artiq::io::Error>
-{
-    fn from(value: ReadStringError<T>) -> ::std_artiq::io::Error {
-        match value {
-            ReadStringError::Utf8Error(_) =>
-                ::std_artiq::io::Error::new(::std_artiq::io::ErrorKind::InvalidData,
-                                            "invalid UTF-8"),
-            ReadStringError::Other(err) => err.into()
-        }
-    }
-}
-
 pub trait ProtoRead {
     type ReadError;
 

artiq/firmware/runtime/Cargo.toml

@@ -19,7 +19,7 @@ cslice = { version = "0.3" }
 log = { version = "0.4", default-features = false }
 managed = { version = "0.6", default-features = false, features = ["alloc", "map"] }
 unwind_backtrace = { path = "../libunwind_backtrace" }
-io = { path = "../libio", features = ["byteorder", "std_artiq"] }
+io = { path = "../libio", features = ["byteorder"] }
 alloc_list = { path = "../liballoc_list" }
 board_misoc = { path = "../libboard_misoc", features = ["uart_console", "smoltcp"] }
 std_artiq = { path = "../libstd_artiq", features = ["alloc", "io_error_alloc"] }

artiq/firmware/runtime/analyzer.rs

@@ -1,4 +1,4 @@
-use std::io::{self, Write};
+use io::{self, Write};
 use board_misoc::{csr, cache};
 use sched::{Io, TcpListener, TcpStream};
 use analyzer_proto::*;
@@ -35,7 +35,7 @@ fn disarm() {
     }
 }
 
-fn worker(stream: &mut TcpStream) -> io::Result<()> {
+fn worker(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
     let data = unsafe { &BUFFER.data[..] };
     let overflow_occurred = unsafe { csr::rtio_analyzer::message_encoder_overflow_read() != 0 };
     let total_byte_count = unsafe { csr::rtio_analyzer::dma_byte_count_read() };

artiq/firmware/runtime/kern_hwreq.rs

@@ -1,4 +1,4 @@
-use std::io;
+use io;
 use kernel_proto as kern;
 use sched::Io;
 use session::{kern_acknowledge, kern_send};
@@ -291,7 +291,7 @@ mod spi {
     }
 }
 
-pub fn process_kern_hwreq(io: &Io, request: &kern::Message) -> io::Result<bool> {
+pub fn process_kern_hwreq(io: &Io, request: &kern::Message) -> io::Result<bool, ::std::io::Error> {
     match request {
         #[cfg(has_rtio_core)]
         &kern::RtioInitRequest => {

artiq/firmware/runtime/mgmt.rs

@@ -1,27 +1,26 @@
-use std::io::{self, Read, Write};
 use log::{self, LevelFilter};
 
+use io::{self, Read, Write, proto::ProtoWrite};
 use board_misoc::boot;
-use io::proto::ProtoWrite;
 use logger_artiq::BufferLogger;
 use sched::Io;
 use sched::{TcpListener, TcpStream};
 use mgmt_proto::*;
 use profiler;
 
-fn check_magic(stream: &mut TcpStream) -> io::Result<()> {
+fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
     const MAGIC: &'static [u8] = b"ARTIQ management\n";
 
     let mut magic: [u8; 17] = [0; 17];
     stream.read_exact(&mut magic)?;
     if magic != MAGIC {
-        Err(io::Error::new(io::ErrorKind::InvalidData, "unrecognized magic"))
+        Err(io::Error::Unrecognized)
     } else {
         Ok(())
     }
 }
 
-fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<()> {
+fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
     check_magic(stream)?;
     info!("new connection from {}", stream.remote_endpoint());
 
@@ -35,7 +34,7 @@ fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<()> {
             }
 
             Request::ClearLog => {
-                BufferLogger::with(|logger| -> io::Result<()> {
+                BufferLogger::with(|logger| -> io::Result<(), ::std::io::Error> {
                     let mut buffer = io.until_ok(|| logger.buffer())?;
                     Ok(buffer.clear())
                 })?;
@@ -44,7 +43,7 @@ fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<()> {
             }
 
             Request::PullLog => {
-                BufferLogger::with(|logger| -> io::Result<()> {
+                BufferLogger::with(|logger| -> io::Result<(), ::std::io::Error> {
                     loop {
                         // Do this *before* acquiring the buffer, since that sets the log level
                         // to OFF.
@@ -166,8 +165,7 @@ pub fn thread(io: Io) {
             let mut stream = TcpStream::from_handle(&io, stream);
             match worker(&io, &mut stream) {
                 Ok(()) => (),
-                Err(ref err) if err.kind() == io::ErrorKind::UnexpectedEof => (),
+                Err(io::Error::UnexpectedEof) => (),
-                Err(ref err) if err.kind() == io::ErrorKind::WriteZero => (),
                 Err(err) => error!("aborted: {}", err)
             }
         });

artiq/firmware/runtime/moninj.rs

@@ -1,6 +1,6 @@
 use alloc::btree_map::BTreeMap;
 
-use std::io::{self, Read};
+use io::{self, Read};
 use sched::Io;
 use sched::{TcpListener, TcpStream};
 use board_misoc::{clock, csr};
@@ -9,13 +9,13 @@ use drtioaux;
 
 use moninj_proto::*;
 
-fn check_magic(stream: &mut TcpStream) -> io::Result<()> {
+fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
     const MAGIC: &'static [u8] = b"ARTIQ moninj\n";
 
     let mut magic: [u8; 13] = [0; 13];
     stream.read_exact(&mut magic)?;
     if magic != MAGIC {
-        Err(io::Error::new(io::ErrorKind::InvalidData, "unrecognized magic"))
+        Err(io::Error::Unrecognized)
     } else {
         Ok(())
     }
@@ -159,7 +159,7 @@ fn read_injection_status(channel: u32, probe: u8) -> u8 {
     0
 }
 
-fn connection_worker(io: &Io, mut stream: &mut TcpStream) -> io::Result<()> {
+fn connection_worker(io: &Io, mut stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
     let mut watch_list = BTreeMap::new();
     let mut next_check = 0;
 

artiq/firmware/runtime/rtio_dma.rs

@@ -1,7 +1,7 @@
 use core::mem;
 use alloc::{Vec, String, BTreeMap};
 
-use std::io::Write;
+use io::Write;
 
 const ALIGNMENT: usize = 64;
 

artiq/firmware/runtime/sched.rs

@@ -9,8 +9,9 @@ use fringe::generator::{Generator, Yielder, State as GeneratorState};
 use smoltcp::wire::IpEndpoint;
 use smoltcp::socket::{SocketHandle, SocketRef};
 
+use io::{Read, Write};
 use board_misoc::clock;
-use std::io::{Read, Write, Result, Error, ErrorKind};
+use std::io::{Result, Error, ErrorKind};
 use urc::Urc;
 
 type SocketSet = ::smoltcp::socket::SocketSet<'static, 'static, 'static>;
@@ -446,6 +447,8 @@ impl<'a> TcpStream<'a> {
 }
 
 impl<'a> Read for TcpStream<'a> {
+    type ReadError = Error;
+
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         // Only borrow the underlying socket for the span of the next statement.
         let result = self.with_lower(|mut s| s.recv_slice(buf));
@@ -470,6 +473,9 @@ impl<'a> Read for TcpStream<'a> {
 }
 
 impl<'a> Write for TcpStream<'a> {
+    type WriteError = Error;
+    type FlushError = Error;
+
     fn write(&mut self, buf: &[u8]) -> Result<usize> {
         // Only borrow the underlying socket for the span of the next statement.
         let result = self.with_lower(|mut s| s.send_slice(buf));

artiq/firmware/runtime/session.rs

@@ -2,8 +2,8 @@ use core::{mem, str, cell::{Cell, RefCell}, fmt::Write as FmtWrite};
 use alloc::{Vec, String};
 use byteorder::{ByteOrder, NetworkEndian};
 
+use io::{self, Read, Write};
 use board_misoc::{ident, cache, config};
-use std::io::{self, Read, Write};
 use {mailbox, rpc_queue, kernel};
 use urc::Urc;
 use sched::{ThreadHandle, Io};
@@ -23,13 +23,13 @@ macro_rules! unexpected {
     ($($arg:tt)*) => {
         {
             error!($($arg)*);
-            return Err(io::Error::new(io::ErrorKind::InvalidData, "protocol error"))
+            return Err(io::Error::Unrecognized)
         }
     };
 }
 
-fn io_error(msg: &str) -> io::Error {
+fn io_error(msg: &str) -> io::Error<::std::io::Error> {
-    io::Error::new(io::ErrorKind::Other, msg)
+    io::Error::Other(::std::io::Error::new(::std::io::ErrorKind::Other, msg))
 }
 
 // Persistent state
@@ -102,19 +102,19 @@ impl<'a> Drop for Session<'a> {
     }
 }
 
-fn check_magic(stream: &mut TcpStream) -> io::Result<()> {
+fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
     const MAGIC: &'static [u8] = b"ARTIQ coredev\n";
 
     let mut magic: [u8; 14] = [0; 14];
     stream.read_exact(&mut magic)?;
     if magic != MAGIC {
-        Err(io::Error::new(io::ErrorKind::InvalidData, "unrecognized magic"))
+        Err(io::Error::Unrecognized)
     } else {
         Ok(())
     }
 }
 
-fn host_read(stream: &mut TcpStream) -> io::Result<host::Request> {
+fn host_read(stream: &mut TcpStream) -> io::Result<host::Request, ::std::io::Error> {
     let request = host::Request::read_from(stream)?;
     match &request {
         &host::Request::LoadKernel(_) => debug!("comm<-host LoadLibrary(...)"),
@@ -123,12 +123,12 @@ fn host_read(stream: &mut TcpStream) -> io::Result<host::Request> {
     Ok(request)
 }
 
-fn host_write(stream: &mut Write, reply: host::Reply) -> io::Result<()> {
+fn host_write(stream: &mut TcpStream, reply: host::Reply) -> io::Result<(), ::std::io::Error> {
     debug!("comm->host {:?}", reply);
-    Ok(reply.write_to(stream)?)
+    reply.write_to(stream)
 }
 
-pub fn kern_send(io: &Io, request: &kern::Message) -> io::Result<()> {
+pub fn kern_send(io: &Io, request: &kern::Message) -> io::Result<(), ::std::io::Error> {
     match request {
         &kern::LoadRequest(_) => debug!("comm->kern LoadRequest(...)"),
         &kern::DmaRetrieveReply { trace, duration } => {
@@ -141,15 +141,15 @@ pub fn kern_send(io: &Io, request: &kern::Message) -> io::Result<()> {
         _ => debug!("comm->kern {:?}", request)
     }
     unsafe { mailbox::send(request as *const _ as usize) }
-    io.until(mailbox::acknowledged)
+    Ok(io.until(mailbox::acknowledged)?)
 }
 
-fn kern_recv_notrace<R, F>(io: &Io, f: F) -> io::Result<R>
+fn kern_recv_notrace<R, F>(io: &Io, f: F) -> io::Result<R, ::std::io::Error>
-        where F: FnOnce(&kern::Message) -> io::Result<R> {
+        where F: FnOnce(&kern::Message) -> io::Result<R, ::std::io::Error> {
     io.until(|| mailbox::receive() != 0)?;
     if !kernel::validate(mailbox::receive()) {
         let message = format!("invalid kernel CPU pointer 0x{:x}", mailbox::receive());
-        return Err(io::Error::new(io::ErrorKind::InvalidData, message))
+        return Err(io::Error::Other(::std::io::Error::new(::std::io::ErrorKind::InvalidData, message)))
     }
 
     f(unsafe { &*(mailbox::receive() as *const kern::Message) })
@@ -171,20 +171,20 @@ fn kern_recv_dotrace(reply: &kern::Message) {
 }
 
 #[inline(always)]
-fn kern_recv<R, F>(io: &Io, f: F) -> io::Result<R>
+fn kern_recv<R, F>(io: &Io, f: F) -> io::Result<R, ::std::io::Error>
-        where F: FnOnce(&kern::Message) -> io::Result<R> {
+        where F: FnOnce(&kern::Message) -> io::Result<R, ::std::io::Error> {
     kern_recv_notrace(io, |reply| {
         kern_recv_dotrace(reply);
         f(reply)
     })
 }
 
-pub fn kern_acknowledge() -> io::Result<()> {
+pub fn kern_acknowledge() -> io::Result<(), ::std::io::Error> {
     mailbox::acknowledge();
     Ok(())
 }
 
-unsafe fn kern_load(io: &Io, session: &mut Session, library: &[u8]) -> io::Result<()> {
+unsafe fn kern_load(io: &Io, session: &mut Session, library: &[u8]) -> io::Result<(), ::std::io::Error> {
     if session.running() {
         unexpected!("attempted to load a new kernel while a kernel was running")
     }
@@ -200,8 +200,8 @@ unsafe fn kern_load(io: &Io, session: &mut Session, library: &[u8]) -> io::Resul
             }
             &kern::LoadReply(Err(ref error)) => {
                 kernel::stop();
-                Err(io::Error::new(io::ErrorKind::Other,
+                Err(io::Error::Other(::std::io::Error::new(::std::io::ErrorKind::Other,
-                                   format!("cannot load kernel: {}", error)))
+                                                       format!("cannot load kernel: {}", error))))
             }
             other =>
                 unexpected!("unexpected reply from kernel CPU: {:?}", other)
@@ -209,7 +209,7 @@ unsafe fn kern_load(io: &Io, session: &mut Session, library: &[u8]) -> io::Resul
     })
 }
 
-fn kern_run(session: &mut Session) -> io::Result<()> {
+fn kern_run(session: &mut Session) -> io::Result<(), ::std::io::Error> {
     if session.kernel_state != KernelState::Loaded {
         unexpected!("attempted to run a kernel while not in Loaded state")
     }
@@ -221,7 +221,7 @@ fn kern_run(session: &mut Session) -> io::Result<()> {
 
 fn process_host_message(io: &Io,
                         stream: &mut TcpStream,
-                        session: &mut Session) -> io::Result<()> {
+                        session: &mut Session) -> io::Result<(), ::std::io::Error> {
     match host_read(stream)? {
         host::Request::SystemInfo => {
             host_write(stream, host::Reply::SystemInfo {
@@ -359,7 +359,7 @@ fn process_host_message(io: &Io,
 }
 
 fn process_kern_message(io: &Io, mut stream: Option<&mut TcpStream>,
-                        session: &mut Session) -> io::Result<bool> {
+                        session: &mut Session) -> io::Result<bool, ::std::io::Error> {
     kern_recv_notrace(io, |request| {
         match (request, session.kernel_state) {
             (&kern::LoadReply(_), KernelState::Loaded) |
@@ -516,7 +516,7 @@ fn process_kern_message(io: &Io, mut stream: Option<&mut TcpStream>,
 }
 
 fn process_kern_queued_rpc(stream: &mut TcpStream,
-                           _session: &mut Session) -> io::Result<()> {
+                           _session: &mut Session) -> io::Result<(), ::std::io::Error> {
     rpc_queue::dequeue(|slice| {
         debug!("comm<-kern (async RPC)");
         let length = NetworkEndian::read_u32(slice) as usize;
@@ -529,7 +529,7 @@ fn process_kern_queued_rpc(stream: &mut TcpStream,
 
 fn host_kernel_worker(io: &Io,
                       stream: &mut TcpStream,
-                      congress: &mut Congress) -> io::Result<()> {
+                      congress: &mut Congress) -> io::Result<(), ::std::io::Error> {
     let mut session = Session::new(congress);
 
     loop {
@@ -568,7 +568,7 @@ fn host_kernel_worker(io: &Io,
 
 fn flash_kernel_worker(io: &Io,
                        congress: &mut Congress,
-                       config_key: &str) -> io::Result<()> {
+                       config_key: &str) -> io::Result<(), ::std::io::Error> {
     let mut session = Session::new(congress);
 
     config::read(config_key, |result| {
@@ -578,7 +578,8 @@ fn flash_kernel_worker(io: &Io,
                 // so make a copy.
                 kern_load(io, &mut session, Vec::from(kernel).as_ref())
             },
-            _ => Err(io::Error::new(io::ErrorKind::NotFound, "kernel not found")),
+            _ => Err(io::Error::Other(::std::io::Error::new(::std::io::ErrorKind::NotFound,
+                                                        "kernel not found"))),
         }
     })?;
     kern_run(&mut session)?;
@@ -639,15 +640,14 @@ pub fn thread(io: Io) {
             info!("running startup kernel");
             match flash_kernel_worker(&io, &mut congress, "startup_kernel") {
                 Ok(()) => info!("startup kernel finished"),
-                Err(err) => {
+                Err(io::Error::Other(ref err)) if err.kind() == ::std::io::ErrorKind::NotFound => {
-                    if err.kind() == io::ErrorKind::NotFound {
                     info!("no startup kernel found")
-                    } else {
+                }
+                Err(err) => {
                     congress.finished_cleanly.set(false);
                     error!("startup kernel aborted: {}", err);
                 }
             }
-            }
         })
     }
 
@@ -674,17 +674,18 @@ pub fn thread(io: Io) {
                 let mut stream = TcpStream::from_handle(&io, stream);
                 match host_kernel_worker(&io, &mut stream, &mut *congress) {
                     Ok(()) => (),
-                    Err(err) => {
+                    Err(io::Error::UnexpectedEof) => {
-                        if err.kind() == io::ErrorKind::UnexpectedEof {
                         info!("connection closed");
-                        } else if err.kind() == io::ErrorKind::Interrupted {
+                    }
+                    Err(io::Error::Other(ref err))
+                            if err.kind() == ::std::io::ErrorKind::Interrupted => {
                         info!("kernel interrupted");
-                        } else {
+                    }
+                    Err(err) => {
                         congress.finished_cleanly.set(false);
                         error!("session aborted: {}", err);
                     }
                 }
-                }
             });
         }
 
@@ -697,15 +698,17 @@ pub fn thread(io: Io) {
                 match flash_kernel_worker(&io, &mut *congress, "idle_kernel") {
                     Ok(()) =>
                         info!("idle kernel finished, standing by"),
-                    Err(err) => {
+                    Err(io::Error::Other(ref err))
-                        if err.kind() == io::ErrorKind::Interrupted {
+                            if err.kind() == ::std::io::ErrorKind::Interrupted => {
                         info!("idle kernel interrupted");
-                        } else if err.kind() == io::ErrorKind::NotFound {
+                    }
+                    Err(io::Error::Other(ref err))
+                            if err.kind() == ::std::io::ErrorKind::NotFound => {
                         info!("no idle kernel found");
                         while io.relinquish().is_ok() {}
-                        } else {
-                            error!("idle kernel aborted: {}", err);
                     }
+                    Err(err) => {
+                        error!("idle kernel aborted: {}", err);
                     }
                 }
             })