M-Labs/artiq
2
0
Fork 2
mirror of https://github.com/m-labs/artiq.git synced 2024-12-25 03:08:27 +08:00
Code Issues Projects Releases Wiki Activity

firmware: remove io::Result<T, E> in favor of Result<T, impl Fail>.

Browse Source 
This doesn't yet use impl Fail since std_artiq::io::Error doesn't
impl it.
This commit is contained in:
whitequark 2018-05-15 08:29:03 +00:00
parent 140ca729aa
commit 26faaad2b7
12 changed files with 60 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
artiq/firmware/libio/lib.rs
View File

@ -11,8 +11,6 @@ extern crate alloc;
#[cfg(feature = "byteorder")]
extern crate byteorder;
use core::result;
mod cursor;
#[cfg(feature = "byteorder")]
mod proto;
@ -21,8 +19,6 @@ pub use cursor::Cursor;
#[cfg(feature = "byteorder")]
pub use proto::{ProtoRead, ProtoWrite};
pub type Result<T, E> = result::Result<T, Error<E>>;
#[derive(Fail, Debug, Clone, PartialEq)]
pub enum Error<T> {
#[fail(display = "unexpected end of stream")]
@ -44,10 +40,10 @@ pub trait Read {
/// Pull some bytes from this source into the specified buffer, returning
/// how many bytes were read.
fn read(&mut self, buf: &mut [u8]) -> result::Result<usize, Self::ReadError>;
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::ReadError>;
/// Read the exact number of bytes required to fill `buf`.
fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), Self::ReadError> {
fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), Error<Self::ReadError>> {
while !buf.is_empty() {
let read_bytes = self.read(buf)?;
if read_bytes == 0 {
@ -64,7 +60,7 @@ 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> {
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::ReadError> {
T::read(self, buf)
}
}
@ -74,14 +70,14 @@ pub trait Write {
type FlushError;
/// Write a buffer into this object, returning how many bytes were written.
fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError>;
fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError>;
/// Flush this output stream, ensuring that all intermediately buffered contents
/// reach their destination.
fn flush(&mut self) -> result::Result<(), Self::FlushError>;
fn flush(&mut self) -> Result<(), Self::FlushError>;
/// Attempts to write an entire buffer into `self`.
fn write_all(&mut self, mut buf: &[u8]) -> Result<(), Self::WriteError> {
fn write_all(&mut self, mut buf: &[u8]) -> Result<(), Error<Self::WriteError>> {
while buf.len() > 0 {
let written_bytes = self.write(buf)?;
if written_bytes == 0 {
@ -105,11 +101,11 @@ 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> {
fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
T::write(self, buf)
}
fn flush(&mut self) -> result::Result<(), Self::FlushError> {
fn flush(&mut self) -> Result<(), Self::FlushError> {
T::flush(self)
}
@ -122,14 +118,14 @@ impl<'a> Write for &'a mut [u8] {
type WriteError = !;
type FlushError = !;
fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError> {
fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
let len = buf.len().min(self.len());
self[..len].copy_from_slice(&buf[..len]);
Ok(len)
}
#[inline]
fn flush(&mut self) -> result::Result<(), Self::FlushError> {
fn flush(&mut self) -> Result<(), Self::FlushError> {
Ok(())
}
}
@ -139,13 +135,13 @@ impl<'a> Write for alloc::Vec<u8> {
type WriteError = !;
type FlushError = !;
fn write(&mut self, buf: &[u8]) -> result::Result<usize, Self::WriteError> {
fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
self.extend_from_slice(buf);
Ok(buf.len())
}
#[inline]
fn flush(&mut self) -> result::Result<(), Self::FlushError> {
fn flush(&mut self) -> Result<(), Self::FlushError> {
Ok(())
}
}

4
artiq/firmware/libproto_artiq/analyzer_proto.rs
View File

@ -1,4 +1,4 @@
use io::{Write, ProtoWrite, Result};
use io::{Write, ProtoWrite, Error};
#[derive(Debug)]
pub struct Header {
@ -10,7 +10,7 @@ pub struct Header {
}
impl Header {
pub fn write_to<T: Write>(&self, writer: &mut T) -> Result<(), T::WriteError> {
pub fn write_to<T: Write>(&self, writer: &mut T) -> Result<(), Error<T::WriteError>> {
writer.write_u32(self.sent_bytes)?;
writer.write_u64(self.total_byte_count)?;
writer.write_u8(self.overflow_occurred as u8)?;

6
artiq/firmware/libproto_artiq/drtioaux_proto.rs
View File

@ -1,4 +1,4 @@
use io::{Read, ProtoRead, Write, ProtoWrite, Error, Result};
use io::{Read, ProtoRead, Write, ProtoWrite, Error};
#[derive(Debug)]
pub enum Packet {
@ -36,7 +36,7 @@ pub enum Packet {
}
impl Packet {
pub fn read_from<T: Read>(reader: &mut T) -> Result<Self, T::ReadError> {
pub fn read_from<T: Read>(reader: &mut T) -> Result<Self, Error<T::ReadError>> {
Ok(match reader.read_u8()? {
0x00 => Packet::EchoRequest,
0x01 => Packet::EchoReply,
@ -133,7 +133,7 @@ impl Packet {
})
}
pub fn write_to<T: Write>(&self, writer: &mut T) -> Result<(), T::WriteError> {
pub fn write_to<T: Write>(&self, writer: &mut T) -> Result<(), Error<T::WriteError>> {
match *self {
Packet::EchoRequest =>
writer.write_u8(0x00)?,

8
artiq/firmware/libproto_artiq/mgmt_proto.rs
View File

@ -2,7 +2,7 @@ use alloc::Vec;
#[cfg(feature = "log")]
use log;
use io::{Read, ProtoRead, Write, ProtoWrite, Error, Result};
use io::{Read, ProtoRead, Write, ProtoWrite, Error};
#[derive(Debug)]
pub enum Request {
@ -40,10 +40,10 @@ pub enum Reply<'a> {
}
impl Request {
pub fn read_from<T: Read + ?Sized>(reader: &mut T) -> Result<Self, T::ReadError> {
pub fn read_from<T: Read + ?Sized>(reader: &mut T) -> Result<Self, Error<T::ReadError>> {
#[cfg(feature = "log")]
fn read_log_level_filter<T: Read + ?Sized>(reader: &mut T) ->
Result<log::LevelFilter, T::ReadError> {
Result<log::LevelFilter, Error<T::ReadError>> {
Ok(match reader.read_u8()? {
0 => log::LevelFilter::Off,
1 => log::LevelFilter::Error,
@ -79,7 +79,7 @@ impl Request {
}
impl<'a> Reply<'a> {
pub fn write_to<T: Write + ?Sized>(&self, writer: &mut T) -> Result<(), T::WriteError> {
pub fn write_to<T: Write + ?Sized>(&self, writer: &mut T) -> Result<(), Error<T::WriteError>> {
match *self {
Reply::Success => {
writer.write_u8(1)?;

6
artiq/firmware/libproto_artiq/moninj_proto.rs
View File

@ -1,4 +1,4 @@
use io::{Read, ProtoRead, Write, ProtoWrite, Error, Result};
use io::{Read, ProtoRead, Write, ProtoWrite, Error};
#[derive(Debug)]
pub enum HostMessage {
@ -14,7 +14,7 @@ pub enum DeviceMessage {
}
impl HostMessage {
pub fn read_from<T: Read + ?Sized>(reader: &mut T) -> Result<Self, T::ReadError> {
pub fn read_from<T: Read + ?Sized>(reader: &mut T) -> Result<Self, Error<T::ReadError>> {
Ok(match reader.read_u8()? {
0 => HostMessage::Monitor {
enable: if reader.read_u8()? == 0 { false } else { true },
@ -36,7 +36,7 @@ impl HostMessage {
}
impl DeviceMessage {
pub fn write_to<T: Write + ?Sized>(&self, writer: &mut T) -> Result<(), T::WriteError> {
pub fn write_to<T: Write + ?Sized>(&self, writer: &mut T) -> Result<(), Error<T::WriteError>> {
match *self {
DeviceMessage::MonitorStatus { channel, probe, value } => {
writer.write_u8(0)?;

14
artiq/firmware/libproto_artiq/rpc_proto.rs
View File

@ -1,12 +1,12 @@
use core::str;
use cslice::{CSlice, CMutSlice};
use io::{ProtoRead, Read, Write, ProtoWrite, Result};
use io::{ProtoRead, Read, Write, ProtoWrite, Error};
use self::tag::{Tag, TagIterator, split_tag};
unsafe fn recv_value<T>(reader: &mut T, tag: Tag, data: &mut *mut (),
alloc: &Fn(usize) -> Result<*mut (), T::ReadError>)
-> Result<(), T::ReadError>
alloc: &Fn(usize) -> Result<*mut (), Error<T::ReadError>>)
-> Result<(), Error<T::ReadError>>
where T: Read + ?Sized
{
macro_rules! consume_value {
@ -75,8 +75,8 @@ unsafe fn recv_value<T>(reader: &mut T, tag: Tag, data: &mut *mut (),
}
pub fn recv_return<T>(reader: &mut T, tag_bytes: &[u8], data: *mut (),
alloc: &Fn(usize) -> Result<*mut (), T::ReadError>)
-> Result<(), T::ReadError>
alloc: &Fn(usize) -> Result<*mut (), Error<T::ReadError>>)
-> Result<(), Error<T::ReadError>>
where T: Read + ?Sized
{
let mut it = TagIterator::new(tag_bytes);
@ -91,7 +91,7 @@ pub fn recv_return<T>(reader: &mut T, tag_bytes: &[u8], data: *mut (),
}
unsafe fn send_value<T>(writer: &mut T, tag: Tag, data: &mut *const ())
-> Result<(), T::WriteError>
-> Result<(), Error<T::WriteError>>
where T: Write + ?Sized
{
macro_rules! consume_value {
@ -168,7 +168,7 @@ unsafe fn send_value<T>(writer: &mut T, tag: Tag, data: &mut *const ())
}
pub fn send_args<T>(writer: &mut T, service: u32, tag_bytes: &[u8], data: *const *const ())
-> Result<(), T::WriteError>
-> Result<(), Error<T::WriteError>>
where T: Write + ?Sized
{
let (arg_tags_bytes, return_tag_bytes) = split_tag(tag_bytes);

10
artiq/firmware/libproto_artiq/session_proto.rs
View File

@ -1,8 +1,8 @@
use alloc::{Vec, String};
use io::{Read, ProtoRead, Write, ProtoWrite, Error, Result};
use io::{Read, ProtoRead, Write, ProtoWrite, Error};
fn read_sync<T: Read + ?Sized>(reader: &mut T) -> Result<(), T::ReadError> {
fn read_sync<T: Read + ?Sized>(reader: &mut T) -> Result<(), Error<T::ReadError>> {
let mut sync = [0; 4];
for i in 0.. {
sync[i % 4] = reader.read_u8()?;
@ -11,7 +11,7 @@ fn read_sync<T: Read + ?Sized>(reader: &mut T) -> Result<(), T::ReadError> {
Ok(())
}
fn write_sync<T: Write + ?Sized>(writer: &mut T) -> Result<(), T::WriteError> {
fn write_sync<T: Write + ?Sized>(writer: &mut T) -> Result<(), Error<T::WriteError>> {
writer.write_all(&[0x5a; 4])
}
@ -41,7 +41,7 @@ pub enum Request {
}
impl Request {
pub fn read_from<T: Read + ?Sized>(reader: &mut T) -> Result<Self, T::ReadError> {
pub fn read_from<T: Read + ?Sized>(reader: &mut T) -> Result<Self, Error<T::ReadError>> {
read_sync(reader)?;
Ok(match reader.read_u8()? {
3 => Request::SystemInfo,
@ -114,7 +114,7 @@ pub enum Reply<'a> {
}
impl<'a> Reply<'a> {
pub fn write_to<T: Write + ?Sized>(&self, writer: &mut T) -> Result<(), T::WriteError> {
pub fn write_to<T: Write + ?Sized>(&self, writer: &mut T) -> Result<(), Error<T::WriteError>> {
write_sync(writer)?;
match *self {
Reply::SystemInfo { ident, finished_cleanly } => {

2
artiq/firmware/runtime/analyzer.rs
View File

@ -35,7 +35,7 @@ fn disarm() {
}
}
fn worker(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
fn worker(stream: &mut TcpStream) -> Result<(), io::Error<::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() };

2
artiq/firmware/runtime/kern_hwreq.rs
View File

@ -291,7 +291,7 @@ mod spi {
}
}
pub fn process_kern_hwreq(io: &Io, request: &kern::Message) -> io::Result<bool, ::std::io::Error> {
pub fn process_kern_hwreq(io: &Io, request: &kern::Message) -> Result<bool, io::Error<::std::io::Error>> {
match request {
#[cfg(has_rtio_core)]
&kern::RtioInitRequest => {

8
artiq/firmware/runtime/mgmt.rs
View File

@ -8,7 +8,7 @@ use sched::{TcpListener, TcpStream};
use mgmt_proto::*;
use profiler;
fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
fn check_magic(stream: &mut TcpStream) -> Result<(), io::Error<::std::io::Error>> {
const MAGIC: &'static [u8] = b"ARTIQ management\n";
let mut magic: [u8; 17] = [0; 17];
@ -20,7 +20,7 @@ fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
}
}
fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
fn worker(io: &Io, stream: &mut TcpStream) -> Result<(), io::Error<::std::io::Error>> {
check_magic(stream)?;
info!("new connection from {}", stream.remote_endpoint());
@ -34,7 +34,7 @@ fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
}
Request::ClearLog => {
BufferLogger::with(|logger| -> io::Result<(), ::std::io::Error> {
BufferLogger::with(|logger| -> Result<(), io::Error<::std::io::Error>> {
let mut buffer = io.until_ok(|| logger.buffer())?;
Ok(buffer.clear())
})?;
@ -43,7 +43,7 @@ fn worker(io: &Io, stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
}
Request::PullLog => {
BufferLogger::with(|logger| -> io::Result<(), ::std::io::Error> {
BufferLogger::with(|logger| -> Result<(), io::Error<::std::io::Error>> {
loop {
// Do this *before* acquiring the buffer, since that sets the log level
// to OFF.

4
artiq/firmware/runtime/moninj.rs
View File

@ -9,7 +9,7 @@ use drtioaux;
use moninj_proto::*;
fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
fn check_magic(stream: &mut TcpStream) -> Result<(), io::Error<::std::io::Error>> {
const MAGIC: &'static [u8] = b"ARTIQ moninj\n";
let mut magic: [u8; 13] = [0; 13];
@ -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<(), ::std::io::Error> {
fn connection_worker(io: &Io, mut stream: &mut TcpStream) -> Result<(), io::Error<::std::io::Error>> {
let mut watch_list = BTreeMap::new();
let mut next_check = 0;

32
artiq/firmware/runtime/session.rs
View File

@ -102,7 +102,7 @@ impl<'a> Drop for Session<'a> {
}
}
fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
fn check_magic(stream: &mut TcpStream) -> Result<(), io::Error<::std::io::Error>> {
const MAGIC: &'static [u8] = b"ARTIQ coredev\n";
let mut magic: [u8; 14] = [0; 14];
@ -114,7 +114,7 @@ fn check_magic(stream: &mut TcpStream) -> io::Result<(), ::std::io::Error> {
}
}
fn host_read(stream: &mut TcpStream) -> io::Result<host::Request, ::std::io::Error> {
fn host_read(stream: &mut TcpStream) -> Result<host::Request, io::Error<::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, ::std::io::Err
Ok(request)
}
fn host_write(stream: &mut TcpStream, reply: host::Reply) -> io::Result<(), ::std::io::Error> {
fn host_write(stream: &mut TcpStream, reply: host::Reply) -> Result<(), io::Error<::std::io::Error>> {
debug!("comm->host {:?}", reply);
reply.write_to(stream)
}
pub fn kern_send(io: &Io, request: &kern::Message) -> io::Result<(), ::std::io::Error> {
pub fn kern_send(io: &Io, request: &kern::Message) -> Result<(), io::Error<::std::io::Error>> {
match request {
&kern::LoadRequest(_) => debug!("comm->kern LoadRequest(...)"),
&kern::DmaRetrieveReply { trace, duration } => {
@ -144,8 +144,8 @@ pub fn kern_send(io: &Io, request: &kern::Message) -> io::Result<(), ::std::io::
Ok(io.until(mailbox::acknowledged)?)
}
fn kern_recv_notrace<R, F>(io: &Io, f: F) -> io::Result<R, ::std::io::Error>
where F: FnOnce(&kern::Message) -> io::Result<R, ::std::io::Error> {
fn kern_recv_notrace<R, F>(io: &Io, f: F) -> Result<R, io::Error<::std::io::Error>>
where F: FnOnce(&kern::Message) -> Result<R, io::Error<::std::io::Error>> {
io.until(|| mailbox::receive() != 0)?;
if !kernel::validate(mailbox::receive()) {
let message = format!("invalid kernel CPU pointer 0x{:x}", mailbox::receive());
@ -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, ::std::io::Error>
where F: FnOnce(&kern::Message) -> io::Result<R, ::std::io::Error> {
fn kern_recv<R, F>(io: &Io, f: F) -> Result<R, io::Error<::std::io::Error>>
where F: FnOnce(&kern::Message) -> Result<R, io::Error<::std::io::Error>> {
kern_recv_notrace(io, |reply| {
kern_recv_dotrace(reply);
f(reply)
})
}
pub fn kern_acknowledge() -> io::Result<(), ::std::io::Error> {
pub fn kern_acknowledge() -> Result<(), io::Error<::std::io::Error>> {
mailbox::acknowledge();
Ok(())
}
unsafe fn kern_load(io: &Io, session: &mut Session, library: &[u8]) -> io::Result<(), ::std::io::Error> {
unsafe fn kern_load(io: &Io, session: &mut Session, library: &[u8]) -> Result<(), io::Error<::std::io::Error>> {
if session.running() {
unexpected!("attempted to load a new kernel while a kernel was running")
}
@ -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<(), ::std::io::Error> {
fn kern_run(session: &mut Session) -> Result<(), io::Error<::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<(), ::std::io::Error> {
fn process_host_message(io: &Io,
stream: &mut TcpStream,
session: &mut Session) -> io::Result<(), ::std::io::Error> {
session: &mut Session) -> Result<(), io::Error<::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, ::std::io::Error> {
session: &mut Session) -> Result<bool, io::Error<::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<(), ::std::io::Error> {
_session: &mut Session) -> Result<(), io::Error<::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<(), ::std::io::Error> {
congress: &mut Congress) -> Result<(), io::Error<::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<(), ::std::io::Error> {
config_key: &str) -> Result<(), io::Error<::std::io::Error>> {
let mut session = Session::new(congress);
config::read(config_key, |result| {