replace libio with core_io

* based on https://github.com/jethrogb/rust-core_io but could not get the packaging scripts to work and the repos is unmaintained anyway, so just copied the result * more features and more up-to-date * compatible with the fatfs crate
2020-06-05 17:14:36 +08:00 · 2020-06-05 17:14:36 +08:00 · ed21457f28
commit ed21457f28
parent a915ed172a
23 changed files with 6565 additions and 295 deletions
--- a/src/Cargo.lock
+++ b/src/Cargo.lock
@ -32,9 +32,16 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 [[package]]
 name = "compiler_builtins"
-version = "0.1.28"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439a6fab343b1dab347823537734a5cd4ae6ae2000b465ab886f64cdb723bd14"
+checksum = "7bc4ac2c824d2bfc612cba57708198547e9a26943af0632aff033e0693074d5c"
 [[package]]
 name = "core_io"
 version = "0.1.20200410"
 dependencies = [
 "memchr",
 ]
 [[package]]
 name = "cslice"
@ -151,17 +158,10 @@ dependencies = [
 "proc-macro-nested",
 ]
 [[package]]
 name = "io"
 version = "0.1.0"
 dependencies = [
 "byteorder",
 ]
 [[package]]
 name = "libasync"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zc706.git#0c48dd934eb65e1cbd0124200ae2e08c7049c903"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#40d5eb8232de1bec19e8bb81ad09351537926a06"
 dependencies = [
 "embedded-hal",
 "libcortex_a9",
@ -173,7 +173,7 @@ dependencies = [
 [[package]]
 name = "libboard_zynq"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zc706.git#0c48dd934eb65e1cbd0124200ae2e08c7049c903"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#40d5eb8232de1bec19e8bb81ad09351537926a06"
 dependencies = [
 "bit_field",
 "embedded-hal",
@ -189,7 +189,7 @@ dependencies = [
 [[package]]
 name = "libcortex_a9"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zc706.git#0c48dd934eb65e1cbd0124200ae2e08c7049c903"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#40d5eb8232de1bec19e8bb81ad09351537926a06"
 dependencies = [
 "bit_field",
 "libregister",
@ -198,7 +198,7 @@ dependencies = [
 [[package]]
 name = "libregister"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zc706.git#0c48dd934eb65e1cbd0124200ae2e08c7049c903"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#40d5eb8232de1bec19e8bb81ad09351537926a06"
 dependencies = [
 "bit_field",
 "vcell",
@ -208,7 +208,7 @@ dependencies = [
 [[package]]
 name = "libsupport_zynq"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zc706.git#0c48dd934eb65e1cbd0124200ae2e08c7049c903"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#40d5eb8232de1bec19e8bb81ad09351537926a06"
 dependencies = [
 "compiler_builtins",
 "libboard_zynq",
@ -273,18 +273,18 @@ dependencies = [
 [[package]]
 name = "pin-project"
-version = "0.4.16"
+version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81d480cb4e89522ccda96d0eed9af94180b7a5f93fb28f66e1fd7d68431663d1"
+checksum = "ba3a1acf4a3e70849f8a673497ef984f043f95d2d8252dcdf74d54e6a1e47e8a"
 dependencies = [
 "pin-project-internal",
 ]
 [[package]]
 name = "pin-project-internal"
-version = "0.4.16"
+version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a82996f11efccb19b685b14b5df818de31c1edcee3daa256ab5775dd98e72feb"
+checksum = "194e88048b71a3e02eb4ee36a6995fed9b8236c11a7bb9f7247a9d9835b3f265"
 dependencies = [
 "proc-macro2",
 "quote",
@ -299,9 +299,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 [[package]]
 name = "proc-macro-hack"
-version = "0.5.15"
+version = "0.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d659fe7c6d27f25e9d80a1a094c223f5246f6a6596453e09d7229bf42750b63"
+checksum = "7e0456befd48169b9f13ef0f0ad46d492cf9d2dbb918bcf38e01eed4ce3ec5e4"
 [[package]]
 name = "proc-macro-nested"
@ -311,18 +311,18 @@ checksum = "8e946095f9d3ed29ec38de908c22f95d9ac008e424c7bcae54c75a79c527c694"
 [[package]]
 name = "proc-macro2"
-version = "1.0.12"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8872cf6f48eee44265156c111456a700ab3483686b3f96df4cf5481c89157319"
+checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa"
 dependencies = [
 "unicode-xid",
 ]
 [[package]]
 name = "quote"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42934bc9c8ab0d3b273a16d8551c8f0fcff46be73276ca083ec2414c15c4ba5e"
+checksum = "54a21852a652ad6f610c9510194f398ff6f8692e334fd1145fed931f7fbe44ea"
 dependencies = [
 "proc-macro2",
 ]
@ -337,10 +337,11 @@ checksum = "bd7a31eed1591dcbc95d92ad7161908e72f4677f8fabf2a32ca49b4237cbf211"
 name = "runtime"
 version = "0.1.0"
 dependencies = [
 "byteorder",
 "core_io",
 "cslice",
 "dyld",
 "futures",
 "io",
 "libasync",
 "libboard_zynq",
 "libcortex_a9",
@ -364,9 +365,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.21"
+version = "1.0.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4696caa4048ac7ce2bcd2e484b3cef88c1004e41b8e945a277e2c25dc0b72060"
+checksum = "93a56fabc59dce20fe48b6c832cc249c713e7ed88fa28b0ee0a3bfcaae5fe4e2"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/src/Cargo.toml
+++ b/src/Cargo.toml
@ -1,7 +1,7 @@
 [workspace]
 members = [
  "libdyld",
-  "libio",
+  "libcoreio",
  "runtime",
  "szl"
 ]
@ -17,3 +17,6 @@ debug = true
 # turn off if you get unusable debug symbols.
 lto = true
 opt-level = 'z'  # Optimize for size.
 [patch.crates-io]
 core_io = { path = "./libcoreio" }
--- a/src/Makefile
+++ b/src/Makefile
@ -9,7 +9,7 @@ all: ../build/firmware/armv7-none-eabihf/release/szl
 	mkdir -p ../build
 	python zc706.py -r ../build/pl.rs -V $(VARIANT)
-../build/firmware/armv7-none-eabihf/release/runtime: .cargo/* armv7-none-eabihf.json Cargo.lock Cargo.toml libdyld/* libdyld/src/* libio/* libio/src/* runtime/* runtime/src/* ../build/pl.rs
+../build/firmware/armv7-none-eabihf/release/runtime: .cargo/* armv7-none-eabihf.json Cargo.lock Cargo.toml libdyld/* libdyld/src/* libcoreio/* libcoreio/src/* libcoreio/src/io/* runtime/* runtime/src/* ../build/pl.rs
 	XBUILD_SYSROOT_PATH=`pwd`/../build/sysroot cargo xbuild --release -p runtime --target-dir ../build/firmware
 ../build/szl-payload.bin.lzma: ../build/firmware/armv7-none-eabihf/release/runtime
--- a/src/libcoreio/Cargo.toml
+++ b/src/libcoreio/Cargo.toml
@ -0,0 +1,14 @@
 [package]
 authors = ["M-Labs"]
 name = "core_io"
 version = "0.1.20200410"
 [lib]
 name = "core_io"
 [dependencies]
 memchr = { version = "2", default-features = false, optional = true }
 [features]
 alloc = []
 collections = ["alloc", "memchr"]
--- a/src/libcoreio/src/io/buffered.rs
+++ b/src/libcoreio/src/io/buffered.rs
--- a/src/libcoreio/src/io/cursor.rs
+++ b/src/libcoreio/src/io/cursor.rs
@ -0,0 +1,896 @@
 use crate::io::prelude::*;
 use core::cmp;
 use crate::io::{self, Error, ErrorKind, Initializer, SeekFrom};
 #[cfg(feature = "collections")]
 use core::convert::TryInto;
 #[cfg(feature="collections")] 
 use collections::vec::Vec;
 #[cfg(feature = "alloc")]
 use alloc::boxed::Box;
 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`Seek`] implementation.
 ///
 /// `Cursor`s are used with in-memory buffers, anything implementing
 /// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
 /// allowing these buffers to be used anywhere you might use a reader or writer
 /// that does actual I/O.
 ///
 /// The standard library implements some I/O traits on various types which
 /// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
 /// `Cursor<`[`&[u8]`][bytes]`>`.
 ///
 /// # Examples
 ///
 /// We may want to write bytes to a [`File`] in our production
 /// code, but use an in-memory buffer in our tests. We can do this with
 /// `Cursor`:
 ///
 /// [`Seek`]: trait.Seek.html
 /// [`Read`]: ../../std/io/trait.Read.html
 /// [`Write`]: ../../std/io/trait.Write.html
 /// [`Vec`]: ../../std/vec/struct.Vec.html
 /// [bytes]: ../../std/primitive.slice.html
 /// [`File`]: ../fs/struct.File.html
 ///
 /// ```no_run
 /// use std::io::prelude::*;
 /// use std::io::{self, SeekFrom};
 /// use std::fs::File;
 ///
 /// // a library function we've written
 /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
 ///     writer.seek(SeekFrom::End(-10))?;
 ///
 ///     for i in 0..10 {
 ///         writer.write(&[i])?;
 ///     }
 ///
 ///     // all went well
 ///     Ok(())
 /// }
 ///
 /// # fn foo() -> io::Result<()> {
 /// // Here's some code that uses this library function.
 /// //
 /// // We might want to use a BufReader here for efficiency, but let's
 /// // keep this example focused.
 /// let mut file = File::create("foo.txt")?;
 ///
 /// write_ten_bytes_at_end(&mut file)?;
 /// # Ok(())
 /// # }
 ///
 /// // now let's write a test
 /// #[test]
 /// fn test_writes_bytes() {
 ///     // setting up a real File is much slower than an in-memory buffer,
 ///     // let's use a cursor instead
 ///     use std::io::Cursor;
 ///     let mut buff = Cursor::new(vec![0; 15]);
 ///
 ///     write_ten_bytes_at_end(&mut buff).unwrap();
 ///
 ///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
 /// }
 /// ```
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct Cursor<T> {
    inner: T,
    pos: u64,
 }
 impl<T> Cursor<T> {
    /// Creates a new cursor wrapping the provided underlying in-memory buffer.
    ///
    /// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
    /// is not empty. So writing to cursor starts with overwriting `Vec`
    /// content, not with appending to it.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::Cursor;
    ///
    /// let buff = Cursor::new(Vec::new());
    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
    /// # force_inference(&buff);
    /// ```
    pub fn new(inner: T) -> Cursor<T> {
        Cursor { pos: 0, inner }
    }
    /// Consumes this cursor, returning the underlying value.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::Cursor;
    ///
    /// let buff = Cursor::new(Vec::new());
    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
    /// # force_inference(&buff);
    ///
    /// let vec = buff.into_inner();
    /// ```
    pub fn into_inner(self) -> T {
        self.inner
    }
    /// Gets a reference to the underlying value in this cursor.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::Cursor;
    ///
    /// let buff = Cursor::new(Vec::new());
    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
    /// # force_inference(&buff);
    ///
    /// let reference = buff.get_ref();
    /// ```
    pub fn get_ref(&self) -> &T {
        &self.inner
    }
    /// Gets a mutable reference to the underlying value in this cursor.
    ///
    /// Care should be taken to avoid modifying the internal I/O state of the
    /// underlying value as it may corrupt this cursor's position.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::Cursor;
    ///
    /// let mut buff = Cursor::new(Vec::new());
    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
    /// # force_inference(&buff);
    ///
    /// let reference = buff.get_mut();
    /// ```
    pub fn get_mut(&mut self) -> &mut T {
        &mut self.inner
    }
    /// Returns the current position of this cursor.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::Cursor;
    /// use std::io::prelude::*;
    /// use std::io::SeekFrom;
    ///
    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
    ///
    /// assert_eq!(buff.position(), 0);
    ///
    /// buff.seek(SeekFrom::Current(2)).unwrap();
    /// assert_eq!(buff.position(), 2);
    ///
    /// buff.seek(SeekFrom::Current(-1)).unwrap();
    /// assert_eq!(buff.position(), 1);
    /// ```
    pub fn position(&self) -> u64 {
        self.pos
    }
    /// Sets the position of this cursor.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::Cursor;
    ///
    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
    ///
    /// assert_eq!(buff.position(), 0);
    ///
    /// buff.set_position(2);
    /// assert_eq!(buff.position(), 2);
    ///
    /// buff.set_position(4);
    /// assert_eq!(buff.position(), 4);
    /// ```
    pub fn set_position(&mut self, pos: u64) {
        self.pos = pos;
    }
 }
 impl<T> io::Seek for Cursor<T>
 where
    T: AsRef<[u8]>,
 {
    fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
        let (base_pos, offset) = match style {
            SeekFrom::Start(n) => {
                self.pos = n;
                return Ok(n);
            }
            SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
            SeekFrom::Current(n) => (self.pos, n),
        };
        let new_pos = if offset >= 0 {
            base_pos.checked_add(offset as u64)
        } else {
            base_pos.checked_sub((offset.wrapping_neg()) as u64)
        };
        match new_pos {
            Some(n) => {
                self.pos = n;
                Ok(self.pos)
            }
            None => Err(Error::new(
                ErrorKind::InvalidInput,
                "invalid seek to a negative or overflowing position",
            )),
        }
    }
    fn stream_len(&mut self) -> io::Result<u64> {
        Ok(self.inner.as_ref().len() as u64)
    }
    fn stream_position(&mut self) -> io::Result<u64> {
        Ok(self.pos)
    }
 }
 impl<T> Read for Cursor<T>
 where
    T: AsRef<[u8]>,
 {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let n = Read::read(&mut self.get_ref().as_ref(), buf)?;
        self.pos += n as u64;
        Ok(n)
    }
    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
        let n = buf.len();
        Read::read_exact(&mut self.get_ref().as_ref(), buf)?;
        self.pos += n as u64;
        Ok(())
    }
    #[inline]
    unsafe fn initializer(&self) -> Initializer {
        Initializer::nop()
    }
 }
 #[cfg(feature = "collections")]
 impl<T> BufRead for Cursor<T>
 where
    T: AsRef<[u8]>,
 {
    fn fill_buf(&mut self) -> io::Result<&[u8]> {
        let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
        Ok(&self.inner.as_ref()[(amt as usize)..])
    }
    fn consume(&mut self, amt: usize) {
        self.pos += amt as u64;
    }
 }
 // Non-resizing write implementation
 #[inline]
 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
    let pos = cmp::min(*pos_mut, slice.len() as u64);
    let amt = (&mut slice[(pos as usize)..]).write(buf)?;
    *pos_mut += amt as u64;
    Ok(amt)
 }
 // Resizing write implementation
 #[cfg(feature = "collections")]
 fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
    let pos: usize = (*pos_mut).try_into().map_err(|_| {
        Error::new(
            ErrorKind::InvalidInput,
            "cursor position exceeds maximum possible vector length",
        )
    })?;
    // Make sure the internal buffer is as least as big as where we
    // currently are
    let len = vec.len();
    if len < pos {
        // use `resize` so that the zero filling is as efficient as possible
        vec.resize(pos, 0);
    }
    // Figure out what bytes will be used to overwrite what's currently
    // there (left), and what will be appended on the end (right)
    {
        let space = vec.len() - pos;
        let (left, right) = buf.split_at(cmp::min(space, buf.len()));
        vec[pos..pos + left.len()].copy_from_slice(left);
        vec.extend_from_slice(right);
    }
    // Bump us forward
    *pos_mut = (pos + buf.len()) as u64;
    Ok(buf.len())
 }
 impl Write for Cursor<&mut [u8]> {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        slice_write(&mut self.pos, self.inner, buf)
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 #[cfg(feature = "collections")]
 impl Write for Cursor<&mut Vec<u8>> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        vec_write(&mut self.pos, self.inner, buf)
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 #[cfg(feature = "collections")]
 impl Write for Cursor<Vec<u8>> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        vec_write(&mut self.pos, &mut self.inner, buf)
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 #[cfg(feature = "alloc")]
 impl Write for Cursor<Box<[u8]>> {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        slice_write(&mut self.pos, &mut self.inner, buf)
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 #[cfg(test)]
 mod tests {
    use crate::io::prelude::*;
    use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
    #[test]
    fn test_vec_writer() {
        let mut writer = Vec::new();
        assert_eq!(writer.write(&[0]).unwrap(), 1);
        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
        assert_eq!(
            writer
                .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
                .unwrap(),
            3
        );
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        assert_eq!(writer, b);
    }
    #[test]
    fn test_mem_writer() {
        let mut writer = Cursor::new(Vec::new());
        assert_eq!(writer.write(&[0]).unwrap(), 1);
        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
        assert_eq!(
            writer
                .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
                .unwrap(),
            3
        );
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        assert_eq!(&writer.get_ref()[..], b);
    }
    #[test]
    fn test_mem_mut_writer() {
        let mut vec = Vec::new();
        let mut writer = Cursor::new(&mut vec);
        assert_eq!(writer.write(&[0]).unwrap(), 1);
        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
        assert_eq!(
            writer
                .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
                .unwrap(),
            3
        );
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        assert_eq!(&writer.get_ref()[..], b);
    }
    #[test]
    fn test_box_slice_writer() {
        let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
        assert_eq!(writer.position(), 0);
        assert_eq!(writer.write(&[0]).unwrap(), 1);
        assert_eq!(writer.position(), 1);
        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
        assert_eq!(writer.position(), 8);
        assert_eq!(writer.write(&[]).unwrap(), 0);
        assert_eq!(writer.position(), 8);
        assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
        assert_eq!(writer.write(&[10]).unwrap(), 0);
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
        assert_eq!(&**writer.get_ref(), b);
    }
    #[test]
    fn test_box_slice_writer_vectored() {
        let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
        assert_eq!(writer.position(), 0);
        assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
        assert_eq!(writer.position(), 1);
        assert_eq!(
            writer
                .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),])
                .unwrap(),
            7,
        );
        assert_eq!(writer.position(), 8);
        assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
        assert_eq!(writer.position(), 8);
        assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
        assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
        assert_eq!(&**writer.get_ref(), b);
    }
    #[test]
    fn test_buf_writer() {
        let mut buf = [0 as u8; 9];
        {
            let mut writer = Cursor::new(&mut buf[..]);
            assert_eq!(writer.position(), 0);
            assert_eq!(writer.write(&[0]).unwrap(), 1);
            assert_eq!(writer.position(), 1);
            assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
            assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
            assert_eq!(writer.position(), 8);
            assert_eq!(writer.write(&[]).unwrap(), 0);
            assert_eq!(writer.position(), 8);
            assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
            assert_eq!(writer.write(&[10]).unwrap(), 0);
        }
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
        assert_eq!(buf, b);
    }
    #[test]
    fn test_buf_writer_vectored() {
        let mut buf = [0 as u8; 9];
        {
            let mut writer = Cursor::new(&mut buf[..]);
            assert_eq!(writer.position(), 0);
            assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
            assert_eq!(writer.position(), 1);
            assert_eq!(
                writer
                    .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
                    .unwrap(),
                7,
            );
            assert_eq!(writer.position(), 8);
            assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
            assert_eq!(writer.position(), 8);
            assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
            assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
        }
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
        assert_eq!(buf, b);
    }
    #[test]
    fn test_buf_writer_seek() {
        let mut buf = [0 as u8; 8];
        {
            let mut writer = Cursor::new(&mut buf[..]);
            assert_eq!(writer.position(), 0);
            assert_eq!(writer.write(&[1]).unwrap(), 1);
            assert_eq!(writer.position(), 1);
            assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
            assert_eq!(writer.position(), 2);
            assert_eq!(writer.write(&[2]).unwrap(), 1);
            assert_eq!(writer.position(), 3);
            assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
            assert_eq!(writer.position(), 1);
            assert_eq!(writer.write(&[3]).unwrap(), 1);
            assert_eq!(writer.position(), 2);
            assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
            assert_eq!(writer.position(), 7);
            assert_eq!(writer.write(&[4]).unwrap(), 1);
            assert_eq!(writer.position(), 8);
        }
        let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
        assert_eq!(buf, b);
    }
    #[test]
    fn test_buf_writer_error() {
        let mut buf = [0 as u8; 2];
        let mut writer = Cursor::new(&mut buf[..]);
        assert_eq!(writer.write(&[0]).unwrap(), 1);
        assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
        assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
    }
    #[test]
    fn test_mem_reader() {
        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
        let mut buf = [];
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
        assert_eq!(reader.position(), 0);
        let mut buf = [0];
        assert_eq!(reader.read(&mut buf).unwrap(), 1);
        assert_eq!(reader.position(), 1);
        let b: &[_] = &[0];
        assert_eq!(buf, b);
        let mut buf = [0; 4];
        assert_eq!(reader.read(&mut buf).unwrap(), 4);
        assert_eq!(reader.position(), 5);
        let b: &[_] = &[1, 2, 3, 4];
        assert_eq!(buf, b);
        assert_eq!(reader.read(&mut buf).unwrap(), 3);
        let b: &[_] = &[5, 6, 7];
        assert_eq!(&buf[..3], b);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn test_mem_reader_vectored() {
        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
        let mut buf = [];
        assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
        assert_eq!(reader.position(), 0);
        let mut buf = [0];
        assert_eq!(
            reader
                .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
                .unwrap(),
            1,
        );
        assert_eq!(reader.position(), 1);
        let b: &[_] = &[0];
        assert_eq!(buf, b);
        let mut buf1 = [0; 4];
        let mut buf2 = [0; 4];
        assert_eq!(
            reader
                .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
                .unwrap(),
            7,
        );
        let b1: &[_] = &[1, 2, 3, 4];
        let b2: &[_] = &[5, 6, 7];
        assert_eq!(buf1, b1);
        assert_eq!(&buf2[..3], b2);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn test_boxed_slice_reader() {
        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
        let mut buf = [];
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
        assert_eq!(reader.position(), 0);
        let mut buf = [0];
        assert_eq!(reader.read(&mut buf).unwrap(), 1);
        assert_eq!(reader.position(), 1);
        let b: &[_] = &[0];
        assert_eq!(buf, b);
        let mut buf = [0; 4];
        assert_eq!(reader.read(&mut buf).unwrap(), 4);
        assert_eq!(reader.position(), 5);
        let b: &[_] = &[1, 2, 3, 4];
        assert_eq!(buf, b);
        assert_eq!(reader.read(&mut buf).unwrap(), 3);
        let b: &[_] = &[5, 6, 7];
        assert_eq!(&buf[..3], b);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn test_boxed_slice_reader_vectored() {
        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
        let mut buf = [];
        assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
        assert_eq!(reader.position(), 0);
        let mut buf = [0];
        assert_eq!(
            reader
                .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
                .unwrap(),
            1,
        );
        assert_eq!(reader.position(), 1);
        let b: &[_] = &[0];
        assert_eq!(buf, b);
        let mut buf1 = [0; 4];
        let mut buf2 = [0; 4];
        assert_eq!(
            reader
                .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
                .unwrap(),
            7,
        );
        let b1: &[_] = &[1, 2, 3, 4];
        let b2: &[_] = &[5, 6, 7];
        assert_eq!(buf1, b1);
        assert_eq!(&buf2[..3], b2);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn read_to_end() {
        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
        let mut v = Vec::new();
        reader.read_to_end(&mut v).unwrap();
        assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
    }
    #[test]
    fn test_slice_reader() {
        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
        let reader = &mut &in_buf[..];
        let mut buf = [];
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
        let mut buf = [0];
        assert_eq!(reader.read(&mut buf).unwrap(), 1);
        assert_eq!(reader.len(), 7);
        let b: &[_] = &[0];
        assert_eq!(&buf[..], b);
        let mut buf = [0; 4];
        assert_eq!(reader.read(&mut buf).unwrap(), 4);
        assert_eq!(reader.len(), 3);
        let b: &[_] = &[1, 2, 3, 4];
        assert_eq!(&buf[..], b);
        assert_eq!(reader.read(&mut buf).unwrap(), 3);
        let b: &[_] = &[5, 6, 7];
        assert_eq!(&buf[..3], b);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn test_slice_reader_vectored() {
        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
        let reader = &mut &in_buf[..];
        let mut buf = [];
        assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
        let mut buf = [0];
        assert_eq!(
            reader
                .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
                .unwrap(),
            1,
        );
        assert_eq!(reader.len(), 7);
        let b: &[_] = &[0];
        assert_eq!(buf, b);
        let mut buf1 = [0; 4];
        let mut buf2 = [0; 4];
        assert_eq!(
            reader
                .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
                .unwrap(),
            7,
        );
        let b1: &[_] = &[1, 2, 3, 4];
        let b2: &[_] = &[5, 6, 7];
        assert_eq!(buf1, b1);
        assert_eq!(&buf2[..3], b2);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn test_read_exact() {
        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
        let reader = &mut &in_buf[..];
        let mut buf = [];
        assert!(reader.read_exact(&mut buf).is_ok());
        let mut buf = [8];
        assert!(reader.read_exact(&mut buf).is_ok());
        assert_eq!(buf[0], 0);
        assert_eq!(reader.len(), 7);
        let mut buf = [0, 0, 0, 0, 0, 0, 0];
        assert!(reader.read_exact(&mut buf).is_ok());
        assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
        assert_eq!(reader.len(), 0);
        let mut buf = [0];
        assert!(reader.read_exact(&mut buf).is_err());
    }
    #[test]
    fn test_buf_reader() {
        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
        let mut reader = Cursor::new(&in_buf[..]);
        let mut buf = [];
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
        assert_eq!(reader.position(), 0);
        let mut buf = [0];
        assert_eq!(reader.read(&mut buf).unwrap(), 1);
        assert_eq!(reader.position(), 1);
        let b: &[_] = &[0];
        assert_eq!(buf, b);
        let mut buf = [0; 4];
        assert_eq!(reader.read(&mut buf).unwrap(), 4);
        assert_eq!(reader.position(), 5);
        let b: &[_] = &[1, 2, 3, 4];
        assert_eq!(buf, b);
        assert_eq!(reader.read(&mut buf).unwrap(), 3);
        let b: &[_] = &[5, 6, 7];
        assert_eq!(&buf[..3], b);
        assert_eq!(reader.read(&mut buf).unwrap(), 0);
    }
    #[test]
    fn seek_past_end() {
        let buf = [0xff];
        let mut r = Cursor::new(&buf[..]);
        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
        assert_eq!(r.read(&mut [0]).unwrap(), 0);
        let mut r = Cursor::new(vec![10]);
        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
        assert_eq!(r.read(&mut [0]).unwrap(), 0);
        let mut buf = [0];
        let mut r = Cursor::new(&mut buf[..]);
        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
        assert_eq!(r.write(&[3]).unwrap(), 0);
        let mut r = Cursor::new(vec![10].into_boxed_slice());
        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
        assert_eq!(r.write(&[3]).unwrap(), 0);
    }
    #[test]
    fn seek_past_i64() {
        let buf = [0xff];
        let mut r = Cursor::new(&buf[..]);
        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
        let mut r = Cursor::new(vec![10]);
        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
        let mut buf = [0];
        let mut r = Cursor::new(&mut buf[..]);
        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
        let mut r = Cursor::new(vec![10].into_boxed_slice());
        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
    }
    #[test]
    fn seek_before_0() {
        let buf = [0xff];
        let mut r = Cursor::new(&buf[..]);
        assert!(r.seek(SeekFrom::End(-2)).is_err());
        let mut r = Cursor::new(vec![10]);
        assert!(r.seek(SeekFrom::End(-2)).is_err());
        let mut buf = [0];
        let mut r = Cursor::new(&mut buf[..]);
        assert!(r.seek(SeekFrom::End(-2)).is_err());
        let mut r = Cursor::new(vec![10].into_boxed_slice());
        assert!(r.seek(SeekFrom::End(-2)).is_err());
    }
    #[test]
    fn test_seekable_mem_writer() {
        let mut writer = Cursor::new(Vec::<u8>::new());
        assert_eq!(writer.position(), 0);
        assert_eq!(writer.write(&[0]).unwrap(), 1);
        assert_eq!(writer.position(), 1);
        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
        assert_eq!(writer.position(), 8);
        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
        assert_eq!(&writer.get_ref()[..], b);
        assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
        assert_eq!(writer.position(), 0);
        assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
        let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
        assert_eq!(&writer.get_ref()[..], b);
        assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
        assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
        assert_eq!(&writer.get_ref()[..], b);
        assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
        assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
        assert_eq!(&writer.get_ref()[..], b);
        assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
        assert_eq!(writer.write(&[1]).unwrap(), 1);
        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
        assert_eq!(&writer.get_ref()[..], b);
    }
    #[test]
    fn vec_seek_past_end() {
        let mut r = Cursor::new(Vec::new());
        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
        assert_eq!(r.write(&[3]).unwrap(), 1);
    }
    #[test]
    fn vec_seek_before_0() {
        let mut r = Cursor::new(Vec::new());
        assert!(r.seek(SeekFrom::End(-2)).is_err());
    }
    #[test]
    #[cfg(target_pointer_width = "32")]
    fn vec_seek_and_write_past_usize_max() {
        let mut c = Cursor::new(Vec::new());
        c.set_position(<usize>::max_value() as u64 + 1);
        assert!(c.write_all(&[1, 2, 3]).is_err());
    }
    #[test]
    fn test_partial_eq() {
        assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
    }
    #[test]
    fn test_eq() {
        struct AssertEq<T: Eq>(pub T);
        let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
    }
 }
--- a/src/libcoreio/src/io/error.rs
+++ b/src/libcoreio/src/io/error.rs
@ -0,0 +1,551 @@
 #[cfg(feature="alloc")] use alloc::boxed::Box;
 #[cfg(not(feature="alloc"))] use ::FakeBox as Box;
 use core::convert::Into;
 use core::fmt;
 use core::marker::{Send, Sync};
 use core::option::Option::{self, Some, None};
 use core::result;
 #[cfg(feature="collections")] use collections::string::String;
 #[cfg(not(feature="collections"))] use ::ErrorString as String;
 use core::convert::From;
 /// A specialized [`Result`](../result/enum.Result.html) type for I/O
 /// operations.
 ///
 /// This type is broadly used across [`std::io`] for any operation which may
 /// produce an error.
 ///
 /// This typedef is generally used to avoid writing out [`io::Error`] directly and
 /// is otherwise a direct mapping to [`Result`].
 ///
 /// While usual Rust style is to import types directly, aliases of [`Result`]
 /// often are not, to make it easier to distinguish between them. [`Result`] is
 /// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias
 /// will generally use `io::Result` instead of shadowing the prelude's import
 /// of [`std::result::Result`][`Result`].
 ///
 /// [`std::io`]: ../io/index.html
 /// [`io::Error`]: ../io/struct.Error.html
 /// [`Result`]: ../result/enum.Result.html
 ///
 /// # Examples
 ///
 /// A convenience function that bubbles an `io::Result` to its caller:
 ///
 /// ```
 /// use std::io;
 ///
 /// fn get_string() -> io::Result<String> {
 ///     let mut buffer = String::new();
 ///
 ///     io::stdin().read_line(&mut buffer)?;
 ///
 ///     Ok(buffer)
 /// }
 /// ```
 pub type Result<T> = result::Result<T, Error>;
 /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
 /// associated traits.
 ///
 /// Errors mostly originate from the underlying OS, but custom instances of
 /// `Error` can be created with crafted error messages and a particular value of
 /// [`ErrorKind`].
 ///
 /// [`Read`]: ../io/trait.Read.html
 /// [`Write`]: ../io/trait.Write.html
 /// [`Seek`]: ../io/trait.Seek.html
 /// [`ErrorKind`]: enum.ErrorKind.html
 pub struct Error {
    repr: Repr,
 }
 impl fmt::Debug for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.repr, f)
    }
 }
 enum Repr {
    Os(i32),
    Simple(ErrorKind),
    #[cfg(feature="alloc")]
    Custom(Box<Custom>),
    #[cfg(not(feature="alloc"))]
    Custom(Custom),
 }
 #[derive(Debug)]
 struct Custom {
    kind: ErrorKind,
    error: String,
 }
 /// A list specifying general categories of I/O error.
 ///
 /// This list is intended to grow over time and it is not recommended to
 /// exhaustively match against it.
 ///
 /// It is used with the [`io::Error`] type.
 ///
 /// [`io::Error`]: struct.Error.html
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 #[allow(deprecated)]
 #[non_exhaustive]
 pub enum ErrorKind {
    /// An entity was not found, often a file.
    NotFound,
    /// The operation lacked the necessary privileges to complete.
    PermissionDenied,
    /// The connection was refused by the remote server.
    ConnectionRefused,
    /// The connection was reset by the remote server.
    ConnectionReset,
    /// The connection was aborted (terminated) by the remote server.
    ConnectionAborted,
    /// The network operation failed because it was not connected yet.
    NotConnected,
    /// A socket address could not be bound because the address is already in
    /// use elsewhere.
    AddrInUse,
    /// A nonexistent interface was requested or the requested address was not
    /// local.
    AddrNotAvailable,
    /// The operation failed because a pipe was closed.
    BrokenPipe,
    /// An entity already exists, often a file.
    AlreadyExists,
    /// The operation needs to block to complete, but the blocking operation was
    /// requested to not occur.
    WouldBlock,
    /// A parameter was incorrect.
    InvalidInput,
    /// Data not valid for the operation were encountered.
    ///
    /// Unlike [`InvalidInput`], this typically means that the operation
    /// parameters were valid, however the error was caused by malformed
    /// input data.
    ///
    /// For example, a function that reads a file into a string will error with
    /// `InvalidData` if the file's contents are not valid UTF-8.
    ///
    /// [`InvalidInput`]: #variant.InvalidInput
    InvalidData,
    /// The I/O operation's timeout expired, causing it to be canceled.
    TimedOut,
    /// An error returned when an operation could not be completed because a
    /// call to [`write`] returned [`Ok(0)`].
    ///
    /// This typically means that an operation could only succeed if it wrote a
    /// particular number of bytes but only a smaller number of bytes could be
    /// written.
    ///
    /// [`write`]: ../../std/io/trait.Write.html#tymethod.write
    /// [`Ok(0)`]: ../../std/io/type.Result.html
    WriteZero,
    /// This operation was interrupted.
    ///
    /// Interrupted operations can typically be retried.
    Interrupted,
    /// Any I/O error not part of this list.
    Other,
    /// An error returned when an operation could not be completed because an
    /// "end of file" was reached prematurely.
    ///
    /// This typically means that an operation could only succeed if it read a
    /// particular number of bytes but only a smaller number of bytes could be
    /// read.
    UnexpectedEof,
 }
 impl ErrorKind {
    pub(crate) fn as_str(&self) -> &'static str {
        match *self {
            ErrorKind::NotFound => "entity not found",
            ErrorKind::PermissionDenied => "permission denied",
            ErrorKind::ConnectionRefused => "connection refused",
            ErrorKind::ConnectionReset => "connection reset",
            ErrorKind::ConnectionAborted => "connection aborted",
            ErrorKind::NotConnected => "not connected",
            ErrorKind::AddrInUse => "address in use",
            ErrorKind::AddrNotAvailable => "address not available",
            ErrorKind::BrokenPipe => "broken pipe",
            ErrorKind::AlreadyExists => "entity already exists",
            ErrorKind::WouldBlock => "operation would block",
            ErrorKind::InvalidInput => "invalid input parameter",
            ErrorKind::InvalidData => "invalid data",
            ErrorKind::TimedOut => "timed out",
            ErrorKind::WriteZero => "write zero",
            ErrorKind::Interrupted => "operation interrupted",
            ErrorKind::Other => "other os error",
            ErrorKind::UnexpectedEof => "unexpected end of file",
        }
    }
 }
 /// Intended for use for errors not exposed to the user, where allocating onto
 /// the heap (for normal construction via Error::new) is too costly.
 impl From<ErrorKind> for Error {
    /// Converts an [`ErrorKind`] into an [`Error`].
    ///
    /// This conversion allocates a new error with a simple representation of error kind.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    ///
    /// let not_found = ErrorKind::NotFound;
    /// let error = Error::from(not_found);
    /// assert_eq!("entity not found", format!("{}", error));
    /// ```
    ///
    /// [`ErrorKind`]: ../../std/io/enum.ErrorKind.html
    /// [`Error`]: ../../std/io/struct.Error.html
    #[inline]
    fn from(kind: ErrorKind) -> Error {
        Error { repr: Repr::Simple(kind) }
    }
 }
 impl Error {
    /// Creates a new I/O error from a known kind of error as well as an
    /// arbitrary error payload.
    ///
    /// This function is used to generically create I/O errors which do not
    /// originate from the OS itself. The `error` argument is an arbitrary
    /// payload which will be contained in this `Error`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    ///
    /// // errors can be created from strings
    /// let custom_error = Error::new(ErrorKind::Other, "oh no!");
    ///
    /// // errors can also be created from other errors
    /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
    /// ```
    pub fn new<E>(kind: ErrorKind, error: E) -> Error
    where
        E: Into<String>,
    {
        Self::_new(kind, error.into())
    }
    fn _new(kind: ErrorKind, error: String) -> Error {
        Error { repr: Repr::Custom(Box::new(Custom { kind, error })) }
    }
    /// Creates a new instance of an `Error` from a particular OS error code.
    ///
    /// # Examples
    ///
    /// On Linux:
    ///
    /// ```
    /// # if cfg!(target_os = "linux") {
    /// use std::io;
    ///
    /// let error = io::Error::from_raw_os_error(22);
    /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
    /// # }
    /// ```
    ///
    /// On Windows:
    ///
    /// ```
    /// # if cfg!(windows) {
    /// use std::io;
    ///
    /// let error = io::Error::from_raw_os_error(10022);
    /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
    /// # }
    /// ```
    pub fn from_raw_os_error(code: i32) -> Error {
        Error { repr: Repr::Os(code) }
    }
    /// Returns the OS error that this error represents (if any).
    ///
    /// If this `Error` was constructed via `last_os_error` or
    /// `from_raw_os_error`, then this function will return `Some`, otherwise
    /// it will return `None`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    ///
    /// fn print_os_error(err: &Error) {
    ///     if let Some(raw_os_err) = err.raw_os_error() {
    ///         println!("raw OS error: {:?}", raw_os_err);
    ///     } else {
    ///         println!("Not an OS error");
    ///     }
    /// }
    ///
    /// fn main() {
    ///     // Will print "raw OS error: ...".
    ///     print_os_error(&Error::last_os_error());
    ///     // Will print "Not an OS error".
    ///     print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
    /// }
    /// ```
    pub fn raw_os_error(&self) -> Option<i32> {
        match self.repr {
            Repr::Os(i) => Some(i),
            Repr::Custom(..) => None,
            Repr::Simple(..) => None,
        }
    }
    /// Returns a reference to the inner error wrapped by this error (if any).
    ///
    /// If this `Error` was constructed via `new` then this function will
    /// return `Some`, otherwise it will return `None`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    ///
    /// fn print_error(err: &Error) {
    ///     if let Some(inner_err) = err.get_ref() {
    ///         println!("Inner error: {:?}", inner_err);
    ///     } else {
    ///         println!("No inner error");
    ///     }
    /// }
    ///
    /// fn main() {
    ///     // Will print "No inner error".
    ///     print_error(&Error::last_os_error());
    ///     // Will print "Inner error: ...".
    ///     print_error(&Error::new(ErrorKind::Other, "oh no!"));
    /// }
    /// ```
    pub fn get_ref(&self) -> Option<&String> {
        match self.repr {
            Repr::Os(..) => None,
            Repr::Simple(..) => None,
            Repr::Custom(ref c) => Some(&c.error),
        }
    }
    /// Returns a mutable reference to the inner error wrapped by this error
    /// (if any).
    ///
    /// If this `Error` was constructed via `new` then this function will
    /// return `Some`, otherwise it will return `None`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    /// use std::{error, fmt};
    /// use std::fmt::Display;
    ///
    /// #[derive(Debug)]
    /// struct MyError {
    ///     v: String,
    /// }
    ///
    /// impl MyError {
    ///     fn new() -> MyError {
    ///         MyError {
    ///             v: "oh no!".to_string()
    ///         }
    ///     }
    ///
    ///     fn change_message(&mut self, new_message: &str) {
    ///         self.v = new_message.to_string();
    ///     }
    /// }
    ///
    /// impl error::Error for MyError {}
    ///
    /// impl Display for MyError {
    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    ///         write!(f, "MyError: {}", &self.v)
    ///     }
    /// }
    ///
    /// fn change_error(mut err: Error) -> Error {
    ///     if let Some(inner_err) = err.get_mut() {
    ///         inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
    ///     }
    ///     err
    /// }
    ///
    /// fn print_error(err: &Error) {
    ///     if let Some(inner_err) = err.get_ref() {
    ///         println!("Inner error: {}", inner_err);
    ///     } else {
    ///         println!("No inner error");
    ///     }
    /// }
    ///
    /// fn main() {
    ///     // Will print "No inner error".
    ///     print_error(&change_error(Error::last_os_error()));
    ///     // Will print "Inner error: ...".
    ///     print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
    /// }
    /// ```
    pub fn get_mut(&mut self) -> Option<&mut String> {
        match self.repr {
            Repr::Os(..) => None,
            Repr::Simple(..) => None,
            Repr::Custom(ref mut c) => Some(&mut c.error),
        }
    }
    /// Consumes the `Error`, returning its inner error (if any).
    ///
    /// If this `Error` was constructed via `new` then this function will
    /// return `Some`, otherwise it will return `None`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    ///
    /// fn print_error(err: Error) {
    ///     if let Some(inner_err) = err.into_inner() {
    ///         println!("Inner error: {}", inner_err);
    ///     } else {
    ///         println!("No inner error");
    ///     }
    /// }
    ///
    /// fn main() {
    ///     // Will print "No inner error".
    ///     print_error(Error::last_os_error());
    ///     // Will print "Inner error: ...".
    ///     print_error(Error::new(ErrorKind::Other, "oh no!"));
    /// }
    /// ```
    pub fn into_inner(self) -> Option<String> {
        match self.repr {
            Repr::Os(..) => None,
            Repr::Simple(..) => None,
            Repr::Custom(c) => Some(c.error),
        }
    }
    /// Returns the corresponding `ErrorKind` for this error.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io::{Error, ErrorKind};
    ///
    /// fn print_error(err: Error) {
    ///     println!("{:?}", err.kind());
    /// }
    ///
    /// fn main() {
    ///     // Will print "No inner error".
    ///     print_error(Error::last_os_error());
    ///     // Will print "Inner error: ...".
    ///     print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
    /// }
    /// ```
    pub fn kind(&self) -> ErrorKind {
        match self.repr {
            Repr::Os(_code) => ErrorKind::Other,
            Repr::Custom(ref c) => c.kind,
            Repr::Simple(kind) => kind,
        }
    }
 }
 impl fmt::Debug for Repr {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            Repr::Os(code) => fmt
                .debug_struct("Os")
                .field("code", &code)
                .finish(),
            Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
            Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
        }
    }
 }
 impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.repr {
            Repr::Os(code) => {
                write!(fmt, "os error {}", code)
            }
            Repr::Custom(ref c) => c.error.fmt(fmt),
            Repr::Simple(kind) => write!(fmt, "{}", kind.as_str()),
        }
    }
 }
 fn _assert_error_is_sync_send() {
    fn _is_sync_send<T: Sync + Send>() {}
    _is_sync_send::<Error>();
 }
 #[cfg(test)]
 mod test {
    use super::{Custom, Error, ErrorKind, Repr};
    use crate::error;
    use crate::fmt;
    use crate::sys::decode_error_kind;
    use crate::sys::os::error_string;
    #[test]
    fn test_debug_error() {
        let code = 6;
        let msg = error_string(code);
        let kind = decode_error_kind(code);
        let err = Error {
            repr: Repr::Custom(box Custom {
                kind: ErrorKind::InvalidInput,
                error: box Error { repr: super::Repr::Os(code) },
            }),
        };
        let expected = format!(
            "Custom {{ \
             kind: InvalidInput, \
             error: Os {{ \
             code: {:?}, \
             kind: {:?}, \
             message: {:?} \
             }} \
             }}",
            code, kind, msg
        );
        assert_eq!(format!("{:?}", err), expected);
    }
    #[test]
    fn test_downcasting() {
        #[derive(Debug)]
        struct TestError;
        impl fmt::Display for TestError {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                f.write_str("asdf")
            }
        }
        impl error::Error for TestError {}
        // we have to call all of these UFCS style right now since method
        // resolution won't implicitly drop the Send+Sync bounds
        let mut err = Error::new(ErrorKind::Other, TestError);
        assert!(err.get_ref().unwrap().is::<TestError>());
        assert_eq!("asdf", err.get_ref().unwrap().to_string());
        assert!(err.get_mut().unwrap().is::<TestError>());
        let extracted = err.into_inner().unwrap();
        extracted.downcast::<TestError>().unwrap();
    }
 }
--- a/src/libcoreio/src/io/impls.rs
+++ b/src/libcoreio/src/io/impls.rs
@ -0,0 +1,378 @@
 use core::cmp;
 use core::fmt;
 use crate::io::{
    self, Error, ErrorKind, Initializer, Read, Seek, SeekFrom, Write,
 };
 #[cfg(feature = "collections")] use crate::io::BufRead;
 use core::mem;
 #[cfg(feature="collections")] 
 use collections::{
    vec::Vec,
    string::String,
 };
 #[cfg(feature = "alloc")]
 use alloc::boxed::Box;
 // =============================================================================
 // Forwarding implementations
 impl<R: Read + ?Sized> Read for &mut R {
    #[inline]
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        (**self).read(buf)
    }
    #[inline]
    unsafe fn initializer(&self) -> Initializer {
        (**self).initializer()
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
        (**self).read_to_end(buf)
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
        (**self).read_to_string(buf)
    }
    #[inline]
    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
        (**self).read_exact(buf)
    }
 }
 impl<W: Write + ?Sized> Write for &mut W {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        (**self).write(buf)
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        (**self).flush()
    }
    #[inline]
    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
        (**self).write_all(buf)
    }
    #[inline]
    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        (**self).write_fmt(fmt)
    }
 }
 impl<S: Seek + ?Sized> Seek for &mut S {
    #[inline]
    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
        (**self).seek(pos)
    }
 }
 #[cfg(feature = "collections")]
 impl<B: BufRead + ?Sized> BufRead for &mut B {
    #[inline]
    fn fill_buf(&mut self) -> io::Result<&[u8]> {
        (**self).fill_buf()
    }
    #[inline]
    fn consume(&mut self, amt: usize) {
        (**self).consume(amt)
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
        (**self).read_until(byte, buf)
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
        (**self).read_line(buf)
    }
 }
 #[cfg(feature="alloc")]
 #[cfg(feature="collections")]
 impl<R: Read + ?Sized> Read for Box<R> {
    #[inline]
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        (**self).read(buf)
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
        (**self).read_to_end(buf)
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
        (**self).read_to_string(buf)
    }
    #[inline]
    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
        (**self).read_exact(buf)
    }
 }
 #[cfg(feature="alloc")]
 #[cfg(feature="collections")]
 impl<W: Write + ?Sized> Write for Box<W> {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        (**self).write(buf)
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        (**self).flush()
    }
    #[inline]
    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
        (**self).write_all(buf)
    }
    #[inline]
    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        (**self).write_fmt(fmt)
    }
 }
 #[cfg(feature="collections")]
 impl<S: Seek + ?Sized> Seek for Box<S> {
    #[inline]
    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
        (**self).seek(pos)
    }
 }
 #[cfg(feature="collections")]
 impl<B: BufRead + ?Sized> BufRead for Box<B> {
    #[inline]
    fn fill_buf(&mut self) -> io::Result<&[u8]> {
        (**self).fill_buf()
    }
    #[inline]
    fn consume(&mut self, amt: usize) {
        (**self).consume(amt)
    }
    #[inline]
    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
        (**self).read_until(byte, buf)
    }
    #[inline]
    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
        (**self).read_line(buf)
    }
 }
 // Used by panicking::default_hook
 #[cfg(test)]
 /// This impl is only used by printing logic, so any error returned is always
 /// of kind `Other`, and should be ignored.
 #[cfg(feature="collections")]
 impl Write for Box<dyn (::realstd::io::Write) + Send> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        (**self).write(buf).map_err(|_| ErrorKind::Other.into())
    }
    fn flush(&mut self) -> io::Result<()> {
        (**self).flush().map_err(|_| ErrorKind::Other.into())
    }
 }
 // =============================================================================
 // In-memory buffer implementations
 /// Read is implemented for `&[u8]` by copying from the slice.
 ///
 /// Note that reading updates the slice to point to the yet unread part.
 /// The slice will be empty when EOF is reached.
 impl Read for &[u8] {
    #[inline]
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let amt = cmp::min(buf.len(), self.len());
        let (a, b) = self.split_at(amt);
        // First check if the amount of bytes we want to read is small:
        // `copy_from_slice` will generally expand to a call to `memcpy`, and
        // for a single byte the overhead is significant.
        if amt == 1 {
            buf[0] = a[0];
        } else {
            buf[..amt].copy_from_slice(a);
        }
        *self = b;
        Ok(amt)
    }
    #[inline]
    unsafe fn initializer(&self) -> Initializer {
        Initializer::nop()
    }
    #[inline]
    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
        if buf.len() > self.len() {
            return Err(Error::new(ErrorKind::UnexpectedEof, "failed to fill whole buffer"));
        }
        let (a, b) = self.split_at(buf.len());
        // First check if the amount of bytes we want to read is small:
        // `copy_from_slice` will generally expand to a call to `memcpy`, and
        // for a single byte the overhead is significant.
        if buf.len() == 1 {
            buf[0] = a[0];
        } else {
            buf.copy_from_slice(a);
        }
        *self = b;
        Ok(())
    }
    #[cfg(feature="collections")]
    #[inline]
    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
        buf.extend_from_slice(*self);
        let len = self.len();
        *self = &self[len..];
        Ok(len)
    }
 }
 #[cfg(feature="collections")]
 impl BufRead for &[u8] {
    #[inline]
    fn fill_buf(&mut self) -> io::Result<&[u8]> {
        Ok(*self)
    }
    #[inline]
    fn consume(&mut self, amt: usize) {
        *self = &self[amt..];
    }
 }
 /// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
 /// its data.
 ///
 /// Note that writing updates the slice to point to the yet unwritten part.
 /// The slice will be empty when it has been completely overwritten.
 impl Write for &mut [u8] {
    #[inline]
    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
        let amt = cmp::min(data.len(), self.len());
        let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
        a.copy_from_slice(&data[..amt]);
        *self = b;
        Ok(amt)
    }
    #[inline]
    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
        if self.write(data)? == data.len() {
            Ok(())
        } else {
            Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"))
        }
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 /// Write is implemented for `Vec<u8>` by appending to the vector.
 /// The vector will grow as needed.
 #[cfg(feature="collections")]
 impl Write for Vec<u8> {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.extend_from_slice(buf);
        Ok(buf.len())
    }
    #[inline]
    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
        self.extend_from_slice(buf);
        Ok(())
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 #[cfg(test)]
 mod tests {
    use crate::io::prelude::*;
    #[bench]
    fn bench_read_slice(b: &mut test::Bencher) {
        let buf = [5; 1024];
        let mut dst = [0; 128];
        b.iter(|| {
            let mut rd = &buf[..];
            for _ in 0..8 {
                let _ = rd.read(&mut dst);
                test::black_box(&dst);
            }
        })
    }
    #[bench]
    fn bench_write_slice(b: &mut test::Bencher) {
        let mut buf = [0; 1024];
        let src = [5; 128];
        b.iter(|| {
            let mut wr = &mut buf[..];
            for _ in 0..8 {
                let _ = wr.write_all(&src);
                test::black_box(&wr);
            }
        })
    }
    #[bench]
    fn bench_read_vec(b: &mut test::Bencher) {
        let buf = vec![5; 1024];
        let mut dst = [0; 128];
        b.iter(|| {
            let mut rd = &buf[..];
            for _ in 0..8 {
                let _ = rd.read(&mut dst);
                test::black_box(&dst);
            }
        })
    }
    #[bench]
    fn bench_write_vec(b: &mut test::Bencher) {
        let mut buf = Vec::with_capacity(1024);
        let src = [5; 128];
        b.iter(|| {
            let mut wr = &mut buf[..];
            for _ in 0..8 {
                let _ = wr.write_all(&src);
                test::black_box(&wr);
            }
        })
    }
 }
--- a/src/libcoreio/src/io/mod.rs
+++ b/src/libcoreio/src/io/mod.rs
--- a/src/libcoreio/src/io/prelude.rs
+++ b/src/libcoreio/src/io/prelude.rs
@ -0,0 +1,13 @@
 //! The I/O Prelude
 //!
 //! The purpose of this module is to alleviate imports of many common I/O traits
 //! by adding a glob import to the top of I/O heavy modules:
 //!
 //! ```
 //! # #![allow(unused_imports)]
 //! use std::io::prelude::*;
 //! ```
 pub use super::{Read, Seek, Write};
 #[cfg(feature = "collections")] pub use super::BufRead;
--- a/src/libcoreio/src/io/util.rs
+++ b/src/libcoreio/src/io/util.rs
@ -0,0 +1,269 @@
 #![allow(missing_copy_implementations)]
 use core::fmt;
 use core::mem;
 use crate::io::{self, ErrorKind, Initializer, Read, Write};
 #[cfg(feature = "collections")] use crate::io::BufRead;
 /// Copies the entire contents of a reader into a writer.
 ///
 /// This function will continuously read data from `reader` and then
 /// write it into `writer` in a streaming fashion until `reader`
 /// returns EOF.
 ///
 /// On success, the total number of bytes that were copied from
 /// `reader` to `writer` is returned.
 ///
 /// If you’re wanting to copy the contents of one file to another and you’re
 /// working with filesystem paths, see the [`fs::copy`] function.
 ///
 /// [`fs::copy`]: ../fs/fn.copy.html
 ///
 /// # Errors
 ///
 /// This function will return an error immediately if any call to `read` or
 /// `write` returns an error. All instances of `ErrorKind::Interrupted` are
 /// handled by this function and the underlying operation is retried.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::io;
 ///
 /// fn main() -> io::Result<()> {
 ///     let mut reader: &[u8] = b"hello";
 ///     let mut writer: Vec<u8> = vec![];
 ///
 ///     io::copy(&mut reader, &mut writer)?;
 ///
 ///     assert_eq!(&b"hello"[..], &writer[..]);
 ///     Ok(())
 /// }
 /// ```
 pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
 where
    R: Read,
    W: Write,
 {
    let mut buf = unsafe {
        #[allow(deprecated)]
        let mut buf: [u8; super::DEFAULT_BUF_SIZE] = mem::uninitialized();
        reader.initializer().initialize(&mut buf);
        buf
    };
    let mut written = 0;
    loop {
        let len = match reader.read(&mut buf) {
            Ok(0) => return Ok(written),
            Ok(len) => len,
            Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
            Err(e) => return Err(e),
        };
        writer.write_all(&buf[..len])?;
        written += len as u64;
    }
 }
 /// A reader which is always at EOF.
 ///
 /// This struct is generally created by calling [`empty`]. Please see
 /// the documentation of [`empty()`][`empty`] for more details.
 ///
 /// [`empty`]: fn.empty.html
 pub struct Empty {
    _priv: (),
 }
 /// Constructs a new handle to an empty reader.
 ///
 /// All reads from the returned reader will return [`Ok`]`(0)`.
 ///
 /// [`Ok`]: ../result/enum.Result.html#variant.Ok
 ///
 /// # Examples
 ///
 /// A slightly sad example of not reading anything into a buffer:
 ///
 /// ```
 /// use std::io::{self, Read};
 ///
 /// let mut buffer = String::new();
 /// io::empty().read_to_string(&mut buffer).unwrap();
 /// assert!(buffer.is_empty());
 /// ```
 pub fn empty() -> Empty {
    Empty { _priv: () }
 }
 impl Read for Empty {
    #[inline]
    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
        Ok(0)
    }
    #[inline]
    unsafe fn initializer(&self) -> Initializer {
        Initializer::nop()
    }
 }
 #[cfg(feature="collections")]
 impl BufRead for Empty {
    #[inline]
    fn fill_buf(&mut self) -> io::Result<&[u8]> {
        Ok(&[])
    }
    #[inline]
    fn consume(&mut self, _n: usize) {}
 }
 impl fmt::Debug for Empty {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("Empty { .. }")
    }
 }
 /// A reader which yields one byte over and over and over and over and over and...
 ///
 /// This struct is generally created by calling [`repeat`][repeat]. Please
 /// see the documentation of `repeat()` for more details.
 ///
 /// [repeat]: fn.repeat.html
 pub struct Repeat {
    byte: u8,
 }
 /// Creates an instance of a reader that infinitely repeats one byte.
 ///
 /// All reads from this reader will succeed by filling the specified buffer with
 /// the given byte.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::io::{self, Read};
 ///
 /// let mut buffer = [0; 3];
 /// io::repeat(0b101).read_exact(&mut buffer).unwrap();
 /// assert_eq!(buffer, [0b101, 0b101, 0b101]);
 /// ```
 pub fn repeat(byte: u8) -> Repeat {
    Repeat { byte }
 }
 impl Read for Repeat {
    #[inline]
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        for slot in &mut *buf {
            *slot = self.byte;
        }
        Ok(buf.len())
    }
    #[inline]
    unsafe fn initializer(&self) -> Initializer {
        Initializer::nop()
    }
 }
 impl fmt::Debug for Repeat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("Repeat { .. }")
    }
 }
 /// A writer which will move data into the void.
 ///
 /// This struct is generally created by calling [`sink`][sink]. Please
 /// see the documentation of `sink()` for more details.
 ///
 /// [sink]: fn.sink.html
 pub struct Sink {
    _priv: (),
 }
 /// Creates an instance of a writer which will successfully consume all data.
 ///
 /// All calls to `write` on the returned instance will return `Ok(buf.len())`
 /// and the contents of the buffer will not be inspected.
 ///
 /// # Examples
 ///
 /// ```rust
 /// use std::io::{self, Write};
 ///
 /// let buffer = vec![1, 2, 3, 5, 8];
 /// let num_bytes = io::sink().write(&buffer).unwrap();
 /// assert_eq!(num_bytes, 5);
 /// ```
 pub fn sink() -> Sink {
    Sink { _priv: () }
 }
 impl Write for Sink {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        Ok(buf.len())
    }
    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
 }
 impl fmt::Debug for Sink {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("Sink { .. }")
    }
 }
 #[cfg(test)]
 mod tests {
    use crate::io::prelude::*;
    use crate::io::{copy, empty, repeat, sink};
    #[test]
    fn copy_copies() {
        let mut r = repeat(0).take(4);
        let mut w = sink();
        assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
        let mut r = repeat(0).take(1 << 17);
        assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17);
    }
    #[test]
    fn sink_sinks() {
        let mut s = sink();
        assert_eq!(s.write(&[]).unwrap(), 0);
        assert_eq!(s.write(&[0]).unwrap(), 1);
        assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
        assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
    }
    #[test]
    fn empty_reads() {
        let mut e = empty();
        assert_eq!(e.read(&mut []).unwrap(), 0);
        assert_eq!(e.read(&mut [0]).unwrap(), 0);
        assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
        assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
    }
    #[test]
    fn repeat_repeats() {
        let mut r = repeat(4);
        let mut b = [0; 1024];
        assert_eq!(r.read(&mut b).unwrap(), 1024);
        assert!(b.iter().all(|b| *b == 4));
    }
    #[test]
    fn take_some_bytes() {
        assert_eq!(repeat(4).take(100).bytes().count(), 100);
        assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
        assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
    }
 }
--- a/src/libcoreio/src/lib.rs
+++ b/src/libcoreio/src/lib.rs
@ -0,0 +1,51 @@
 //! <p id="core_io-show-docblock"></p>
 //! This is just a listing of the functionality available in this crate. See
 //! the [std documentation](https://doc.rust-lang.org/nightly/std/io/index.html)
 //! for a full description of the functionality.
 #![allow(stable_features,unused_features)]
 #![feature(question_mark,const_fn,copy_from_slice,try_from,str_internals,align_offset,slice_internals)]
 #![cfg_attr(any(feature="alloc",feature="collections"),feature(alloc))]
 #![cfg_attr(pattern_guards,feature(bind_by_move_pattern_guards,nll))]
 #![cfg_attr(non_exhaustive,feature(non_exhaustive))]
 #![cfg_attr(unicode,feature(str_char))]
 #![cfg_attr(unicode,feature(unicode))]
 #![no_std]
 #[cfg_attr(feature="collections",macro_use)]
 #[cfg_attr(feature="collections",allow(unused_imports))]
 #[cfg(feature="collections")] extern crate alloc as collections;
 #[cfg(feature="alloc")] extern crate alloc;
 #[cfg(rustc_unicode)]
 extern crate rustc_unicode;
 #[cfg(std_unicode)]
 extern crate std_unicode;
 #[cfg(not(feature="collections"))]
 pub type ErrorString = &'static str;
 // Provide Box::new wrapper
 #[cfg(not(feature="alloc"))]
 struct FakeBox<T>(core::marker::PhantomData<T>);
 #[cfg(not(feature="alloc"))]
 impl<T> FakeBox<T> {
 	fn new(val: T) -> T {
 		val
 	}
 }
 // Needed for older compilers, to ignore vec!/format! macros in tests
 #[cfg(not(feature="collections"))]
 #[allow(unused)]
 macro_rules! vec (
 	( $ elem : expr ; $ n : expr ) => { () };
 	( $ ( $ x : expr ) , * ) => { () };
 	( $ ( $ x : expr , ) * ) => { () };
 );
 #[cfg(not(feature="collections"))]
 #[allow(unused)]
 macro_rules! format {
 	( $ ( $ arg : tt ) * ) => { () };
 }
 mod io;
 pub use io::*;
--- a/src/libio/Cargo.toml
+++ b/src/libio/Cargo.toml
@ -1,13 +0,0 @@
 [package]
 authors = ["M-Labs"]
 name = "io"
 version = "0.1.0"
 [lib]
 name = "io"
 [dependencies]
 byteorder = { version = "1.3", default-features = false }
 [features]
 alloc = []
--- a/src/libio/src/cursor.rs
+++ b/src/libio/src/cursor.rs
@ -1,86 +0,0 @@
 use {Read, Write};
 #[derive(Debug, Clone)]
 pub struct Cursor<T> {
    inner: T,
    pos:   usize
 }
 impl<T> Cursor<T> {
    #[inline]
    pub fn new(inner: T) -> Cursor<T> {
        Cursor { inner, pos: 0 }
    }
    #[inline]
    pub fn into_inner(self) -> T {
        self.inner
    }
    #[inline]
    pub fn get_ref(&self) -> &T {
        &self.inner
    }
    #[inline]
    pub fn get_mut(&mut self) -> &mut T {
        &mut self.inner
    }
    #[inline]
    pub fn position(&self) -> usize {
        self.pos
    }
    #[inline]
    pub fn set_position(&mut self, pos: usize) {
        self.pos = pos
    }
 }
 impl<T: AsRef<[u8]>> Read for Cursor<T> {
    type ReadError = !;
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::ReadError> {
        let data = &self.inner.as_ref()[self.pos..];
        let len = buf.len().min(data.len());
        buf[..len].copy_from_slice(&data[..len]);
        self.pos += len;
        Ok(len)
    }
 }
 impl<'a> Write for Cursor<&'a mut [u8]> {
    type WriteError = !;
    type FlushError = !;
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
        let data = &mut self.inner[self.pos..];
        let len  = buf.len().min(data.len());
        data[..len].copy_from_slice(&buf[..len]);
        self.pos += len;
        Ok(len)
    }
    #[inline]
    fn flush(&mut self) -> Result<(), Self::FlushError> {
        Ok(())
    }
 }
 #[cfg(feature = "alloc")]
 impl Write for Cursor<&mut ::alloc::vec::Vec<u8>> {
    type WriteError = !;
    type FlushError = !;
    #[inline]
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
        self.inner.extend_from_slice(buf);
        Ok(buf.len())
    }
    #[inline]
    fn flush(&mut self) -> Result<(), Self::FlushError> {
        Ok(())
    }
 }
--- a/src/libio/src/lib.rs
+++ b/src/libio/src/lib.rs
@ -1,137 +0,0 @@
 #![no_std]
 #![feature(never_type)]
 #[cfg(feature = "alloc")]
 extern crate alloc;
 extern crate byteorder;
 mod cursor;
 mod proto;
 pub use cursor::Cursor;
 pub use proto::{ProtoRead, ProtoWrite};
 #[cfg(feature = "alloc")]
 pub use proto::ReadStringError;
 #[derive(Debug, Clone, PartialEq)]
 pub enum Error<T> {
    UnexpectedEnd,
    Other(T)
 }
 impl<T> From<T> for Error<T> {
    fn from(value: T) -> Error<T> {
        Error::Other(value)
    }
 }
 pub trait Read {
    type ReadError;
    /// Pull some bytes from this source into the specified buffer, returning
    /// how many bytes were read.
    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<(), Error<Self::ReadError>> {
        while !buf.is_empty() {
            let read_bytes = self.read(buf)?;
            if read_bytes == 0 {
                return Err(Error::UnexpectedEnd)
            }
            buf = &mut { buf }[read_bytes..];
        }
        Ok(())
    }
 }
 impl<'a, T: Read> Read for &'a mut T {
    type ReadError = T::ReadError;
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::ReadError> {
        T::read(self, buf)
    }
 }
 pub trait Write {
    type WriteError;
    type FlushError;
    /// Write a buffer into this object, returning how many bytes were written.
    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<(), Self::FlushError>;
    /// Attempts to write an entire buffer into `self`.
    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 {
                return Err(Error::UnexpectedEnd)
            }
            buf = &buf[written_bytes..];
        }
        Ok(())
    }
    /// Hints the writer how much bytes will be written after call to this function.
    ///
    /// At least `min` bytes should be written after the call to this function and
    /// if `max` is `Some(x)` than at most `x` bytes should be written.
    fn size_hint(&mut self, _min: usize, _max: Option<usize>) {}
 }
 impl<'a, T: Write> Write for &'a mut T {
    type WriteError = T::WriteError;
    type FlushError = T::FlushError;
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
        T::write(self, buf)
    }
    fn flush(&mut self) -> 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 = !;
    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<(), Self::FlushError> {
        Ok(())
    }
 }
 #[cfg(feature = "alloc")]
 impl<'a> Write for alloc::vec::Vec<u8> {
    type WriteError = !;
    type FlushError = !;
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::WriteError> {
        self.extend_from_slice(buf);
        Ok(buf.len())
    }
    #[inline]
    fn flush(&mut self) -> Result<(), Self::FlushError> {
        Ok(())
    }
 }
--- a/src/runtime/Cargo.toml
+++ b/src/runtime/Cargo.toml
@ -14,6 +14,8 @@ num-traits = { version = "0.2", default-features = false }
 num-derive = "0.3"
 cslice = "0.3"
 log = "0.4"
 core_io = { version = "0.1", features = ["alloc", "collections"] }
 byteorder = { version = "1.3", default-features = false }
 void = { version = "1", default-features = false }
 futures = { version = "0.3", default-features = false, features = ["async-await"] }
 libboard_zynq = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
@ -21,4 +23,3 @@ libsupport_zynq = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
 libcortex_a9 = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
 libasync = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
 dyld = { path = "../libdyld" }
 io = { path = "../libio", features = ["alloc"] }
--- a/src/runtime/src/comms.rs
+++ b/src/runtime/src/comms.rs
@ -21,7 +21,7 @@ use libsupport_zynq::alloc::{vec, vec::Vec};
 use libasync::{smoltcp::{Sockets, TcpStream}, task};
 use alloc::sync::Arc;
-use crate::proto::*;
+use crate::proto_async::*;
 use crate::kernel;
 use crate::moninj;
--- a/src/runtime/src/kernel.rs
+++ b/src/runtime/src/kernel.rs
@ -7,7 +7,6 @@ use libcortex_a9::{mutex::Mutex, sync_channel::{self, sync_channel}};
 use libsupport_zynq::boot::Core1;
 use dyld;
 use io;
 use crate::rpc;
 use crate::rtio;
@ -68,22 +67,16 @@ static mut KERNEL_CHANNEL_1TO0: *mut () = ptr::null_mut();
 extern fn rpc_send(service: u32, tag: &CSlice<u8>, data: *const *const ()) {
    let core1_rx: &mut sync_channel::Receiver<Message> = unsafe { mem::transmute(KERNEL_CHANNEL_0TO1) };
    let core1_tx: &mut sync_channel::Sender<Message> = unsafe { mem::transmute(KERNEL_CHANNEL_1TO0) };
-    let mut buffer = Arc::new(Vec::<u8>::new());
+    let mut buffer = Vec::<u8>::new();
-    {
+    rpc::send_args(&mut buffer, service, tag.as_ref(), data).expect("RPC encoding failed");
-        let mut writer = io::Cursor::new(Arc::get_mut(&mut buffer).unwrap());
+    core1_tx.send(Message::RpcSend { is_async: false, data: Arc::new(buffer) })
        rpc::send_args(&mut writer, service, tag.as_ref(), data).expect("RPC encoding failed");
    }
    core1_tx.send(Message::RpcSend { is_async: false, data: buffer })
 }
 extern fn rpc_send_async(service: u32, tag: &CSlice<u8>, data: *const *const ()) {
    let core1_tx: &mut sync_channel::Sender<Message> = unsafe { mem::transmute(KERNEL_CHANNEL_1TO0) };
-    let mut buffer = Arc::new(Vec::<u8>::new());
+    let mut buffer = Vec::<u8>::new();
-    {
+    rpc::send_args(&mut buffer, service, tag.as_ref(), data).expect("RPC encoding failed");
-        let mut writer = io::Cursor::new(Arc::get_mut(&mut buffer).unwrap());
+    core1_tx.send(Message::RpcSend { is_async: true, data: Arc::new(buffer) })
        rpc::send_args(&mut writer, service, tag.as_ref(), data).expect("RPC encoding failed");
    }
    core1_tx.send(Message::RpcSend { is_async: true, data: buffer })
 }
 extern fn rpc_recv(slot: *mut ()) -> usize {
--- a/src/runtime/src/main.rs
+++ b/src/runtime/src/main.rs
@ -10,7 +10,8 @@ use log::info;
 use libboard_zynq::{timer::GlobalTimer, logger, devc};
 use libsupport_zynq::ram;
-mod proto;
+mod proto_core_io;
 mod proto_async;
 mod comms;
 mod rpc;
 #[path = "../../../build/pl.rs"]
--- a/src/runtime/src/moninj.rs
+++ b/src/runtime/src/moninj.rs
@ -10,7 +10,7 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::{FromPrimitive, ToPrimitive};
 use futures::{pin_mut, select_biased, FutureExt};
-use crate::proto::*;
+use crate::proto_async::*;
 use crate::pl::csr;
--- a/src/runtime/src/proto_async.rs
+++ b/src/runtime/src/proto_async.rs
--- a/src/runtime/src/proto_core_io.rs
+++ b/src/runtime/src/proto_core_io.rs
@ -1,13 +1,10 @@
 #[cfg(feature = "alloc")]
 use core::str::Utf8Error;
 use byteorder::{ByteOrder, NetworkEndian};
 #[cfg(feature = "alloc")]
 use alloc::vec;
 use alloc::string::String;
-use ::{Read, Write, Error as IoError};
+use core_io::{Read, Write, Error as IoError};
 #[cfg(feature = "alloc")]
 #[derive(Debug, Clone, PartialEq)]
 pub enum ReadStringError<T> {
    Utf8(Utf8Error),
@ -52,7 +49,6 @@ pub trait ProtoRead {
        Ok(self.read_u8()? != 0)
    }
    #[cfg(feature = "alloc")]
    #[inline]
    fn read_bytes(&mut self) -> Result<::alloc::vec::Vec<u8>, Self::ReadError> {
        let length = self.read_u32()?;
@ -61,7 +57,6 @@ pub trait ProtoRead {
        Ok(value)
    }
    #[cfg(feature = "alloc")]
    #[inline]
    fn read_string(&mut self) -> Result<::alloc::string::String, ReadStringError<Self::ReadError>> {
        let bytes = self.read_bytes().map_err(ReadStringError::Other)?;
@ -146,7 +141,7 @@ pub trait ProtoWrite {
 }
 impl<T> ProtoRead for T where T: Read + ?Sized {
-    type ReadError = IoError<T::ReadError>;
+    type ReadError = IoError;
    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::ReadError> {
        T::read_exact(self, buf)
@ -154,7 +149,7 @@ impl<T> ProtoRead for T where T: Read + ?Sized {
 }
 impl<T> ProtoWrite for T where T: Write + ?Sized {
-    type WriteError = IoError<T::WriteError>;
+    type WriteError = IoError;
    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::WriteError> {
        T::write_all(self, buf)
--- a/src/runtime/src/rpc.rs
+++ b/src/runtime/src/rpc.rs
@ -1,14 +1,16 @@
 use core::str;
 use cslice::{CSlice, CMutSlice};
-use io::{ProtoRead, Read, Write, ProtoWrite, Error};
+use core_io::{Read, Write, Error};
 use crate::proto_core_io::{ProtoRead, ProtoWrite};
 use self::tag::{Tag, TagIterator, split_tag};
 unsafe fn recv_value<R, E>(reader: &mut R, tag: Tag, data: &mut *mut (),
                           alloc: &dyn Fn(usize) -> Result<*mut (), E>)
                          -> Result<(), E>
    where R: Read + ?Sized,
-          E: From<Error<R::ReadError>>
+          E: From<Error>
 {
    macro_rules! consume_value {
        ($ty:ty, |$ptr:ident| $map:expr) => ({
@ -79,7 +81,7 @@ pub fn recv_return<R, E>(reader: &mut R, tag_bytes: &[u8], data: *mut (),
                         alloc: &dyn Fn(usize) -> Result<*mut (), E>)
                        -> Result<(), E>
    where R: Read + ?Sized,
-          E: From<Error<R::ReadError>>
+          E: From<Error>
 {
    let mut it = TagIterator::new(tag_bytes);
    #[cfg(feature = "log")]
@ -93,7 +95,7 @@ pub fn recv_return<R, E>(reader: &mut R, tag_bytes: &[u8], data: *mut (),
 }
 unsafe fn send_value<W>(writer: &mut W, tag: Tag, data: &mut *const ())
-                       -> Result<(), Error<W::WriteError>>
+                       -> Result<(), Error>
    where W: Write + ?Sized
 {
    macro_rules! consume_value {
@ -170,7 +172,7 @@ unsafe fn send_value<W>(writer: &mut W, tag: Tag, data: &mut *const ())
 }
 pub fn send_args<W>(writer: &mut W, service: u32, tag_bytes: &[u8], data: *const *const ())
-                   -> Result<(), Error<W::WriteError>>
+                   -> Result<(), Error>
    where W: Write + ?Sized
 {
    let (arg_tags_bytes, return_tag_bytes) = split_tag(tag_bytes);