Sync with Fuchsia (#741)
* Rename Magenta to Zircon
* Update package dependencies to zircon
* Use zircon's status-to-error conversion
* Bump fuchsia-zircon version
diff --git a/Cargo.toml b/Cargo.toml
index 258dc34..d136824 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,8 +29,8 @@
iovec = "0.1.0"
[target.'cfg(target_os = "fuchsia")'.dependencies]
-magenta = "0.2.0"
-magenta-sys = "0.2.0"
+fuchsia-zircon = "0.2.1"
+fuchsia-zircon-sys = "0.2.0"
[target.'cfg(unix)'.dependencies]
libc = "0.2.19"
diff --git a/src/lib.rs b/src/lib.rs
index 4858b45..beac3a9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -85,9 +85,9 @@
extern crate iovec;
#[cfg(target_os = "fuchsia")]
-extern crate magenta;
+extern crate fuchsia_zircon as zircon;
#[cfg(target_os = "fuchsia")]
-extern crate magenta_sys;
+extern crate fuchsia_zircon_sys as zircon_sys;
#[cfg(unix)]
extern crate libc;
@@ -203,7 +203,7 @@
pub use sys::{
EventedHandle,
};
- pub use sys::fuchsia::{FuchsiaReady, mx_signals_t};
+ pub use sys::fuchsia::{FuchsiaReady, zx_signals_t};
}
/// Windows-only extensions to the mio crate.
diff --git a/src/sys/fuchsia/awakener.rs b/src/sys/fuchsia/awakener.rs
index 553e373..19bc762 100644
--- a/src/sys/fuchsia/awakener.rs
+++ b/src/sys/fuchsia/awakener.rs
@@ -1,13 +1,12 @@
use {io, poll, Evented, Ready, Poll, PollOpt, Token};
-use sys::fuchsia::status_to_io_err;
-use magenta;
+use zircon;
use std::sync::{Arc, Mutex, Weak};
pub struct Awakener {
/// Token and weak reference to the port on which Awakener was registered.
///
/// When `Awakener::wakeup` is called, these are used to send a wakeup message to the port.
- inner: Mutex<Option<(Token, Weak<magenta::Port>)>>,
+ inner: Mutex<Option<(Token, Weak<zircon::Port>)>>,
}
impl Awakener {
@@ -27,10 +26,10 @@
let port = weak_port.upgrade().expect("Tried to wakeup a closed port.");
let status = 0; // arbitrary
- let packet = magenta::Packet::from_user_packet(
- token.0 as u64, status, magenta::UserPacket::from_u8_array([0; 32]));
+ let packet = zircon::Packet::from_user_packet(
+ token.0 as u64, status, zircon::UserPacket::from_u8_array([0; 32]));
- port.queue(&packet).map_err(status_to_io_err)
+ Ok(port.queue(&packet)?)
}
pub fn cleanup(&self) {}
diff --git a/src/sys/fuchsia/eventedfd.rs b/src/sys/fuchsia/eventedfd.rs
index e337666..641fc18 100644
--- a/src/sys/fuchsia/eventedfd.rs
+++ b/src/sys/fuchsia/eventedfd.rs
@@ -1,7 +1,7 @@
use {io, poll, Evented, Ready, Poll, PollOpt, Token};
use libc;
-use magenta;
-use magenta::AsHandleRef;
+use zircon;
+use zircon::AsHandleRef;
use sys::fuchsia::{DontDrop, poll_opts_to_wait_async, sys};
use std::mem;
use std::os::unix::io::RawFd;
@@ -11,24 +11,24 @@
#[derive(Debug)]
pub struct EventedFdRegistration {
token: Token,
- handle: DontDrop<magenta::Handle>,
- rereg_signals: Option<(magenta::Signals, magenta::WaitAsyncOpts)>,
+ handle: DontDrop<zircon::Handle>,
+ rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>,
}
impl EventedFdRegistration {
unsafe fn new(token: Token,
- raw_handle: sys::mx_handle_t,
- rereg_signals: Option<(magenta::Signals, magenta::WaitAsyncOpts)>,
+ raw_handle: sys::zx_handle_t,
+ rereg_signals: Option<(zircon::Signals, zircon::WaitAsyncOpts)>,
) -> Self
{
EventedFdRegistration {
token: token,
- handle: DontDrop::new(magenta::Handle::from_raw(raw_handle)),
+ handle: DontDrop::new(zircon::Handle::from_raw(raw_handle)),
rereg_signals: rereg_signals
}
}
- pub fn rereg_signals(&self) -> Option<(magenta::Signals, magenta::WaitAsyncOpts)> {
+ pub fn rereg_signals(&self) -> Option<(zircon::Signals, zircon::WaitAsyncOpts)> {
self.rereg_signals
}
}
@@ -44,12 +44,12 @@
/// `fd` is closed on `Drop`, so modifying `fd` is a memory-unsafe operation.
fd: RawFd,
- /// Owned `mxio_t` ponter.
- mxio: *const sys::mxio_t,
+ /// Owned `fdio_t` ponter.
+ fdio: *const sys::fdio_t,
}
impl EventedFdInner {
- pub fn rereg_for_level(&self, port: &magenta::Port) {
+ pub fn rereg_for_level(&self, port: &zircon::Port) {
let registration_opt = self.registration.lock().unwrap();
if let Some(ref registration) = *registration_opt {
if let Some((rereg_signals, rereg_opts)) = registration.rereg_signals {
@@ -69,25 +69,25 @@
&self.registration
}
- pub fn mxio(&self) -> &sys::mxio_t {
- unsafe { &*self.mxio }
+ pub fn fdio(&self) -> &sys::fdio_t {
+ unsafe { &*self.fdio }
}
}
impl Drop for EventedFdInner {
fn drop(&mut self) {
unsafe {
- sys::__mxio_release(self.mxio);
+ sys::__fdio_release(self.fdio);
let _ = libc::close(self.fd);
}
}
}
// `EventedInner` must be manually declared `Send + Sync` because it contains a `RawFd` and a
-// `*const sys::mxio_t`. These are only used to make thread-safe system calls, so accessing
+// `*const sys::fdio_t`. These are only used to make thread-safe system calls, so accessing
// them is entirely thread-safe.
//
-// Note: one minor exception to this are the calls to `libc::close` and `__mxio_release`, which
+// Note: one minor exception to this are the calls to `libc::close` and `__fdio_release`, which
// happen on `Drop`. These accesses are safe because `drop` can only be called at most once from
// a single thread, and after it is called no other functions can be called on the `EventedFdInner`.
unsafe impl Sync for EventedFdInner {}
@@ -100,27 +100,27 @@
impl EventedFd {
pub unsafe fn new(fd: RawFd) -> Self {
- let mxio = sys::__mxio_fd_to_io(fd);
- assert!(mxio != ::std::ptr::null(), "FileDescriptor given to EventedFd must be valid.");
+ let fdio = sys::__fdio_fd_to_io(fd);
+ assert!(fdio != ::std::ptr::null(), "FileDescriptor given to EventedFd must be valid.");
EventedFd {
inner: Arc::new(EventedFdInner {
registration: Mutex::new(None),
fd: fd,
- mxio: mxio,
+ fdio: fdio,
})
}
}
fn handle_and_signals_for_events(&self, interest: Ready, opts: PollOpt)
- -> (sys::mx_handle_t, magenta::Signals)
+ -> (sys::zx_handle_t, zircon::Signals)
{
let epoll_events = ioevent_to_epoll(interest, opts);
unsafe {
- let mut raw_handle: sys::mx_handle_t = mem::uninitialized();
- let mut signals: sys::mx_signals_t = mem::uninitialized();
- sys::__mxio_wait_begin(self.inner.mxio, epoll_events, &mut raw_handle, &mut signals);
+ let mut raw_handle: sys::zx_handle_t = mem::uninitialized();
+ let mut signals: sys::zx_signals_t = mem::uninitialized();
+ sys::__fdio_wait_begin(self.inner.fdio, epoll_events, &mut raw_handle, &mut signals);
(raw_handle, signals)
}
@@ -158,7 +158,7 @@
);
// We don't have ownership of the handle, so we can't drop it
- let handle = DontDrop::new(unsafe { magenta::Handle::from_raw(raw_handle) });
+ let handle = DontDrop::new(unsafe { zircon::Handle::from_raw(raw_handle) });
let registered = poll::selector(poll)
.register_fd(handle.inner_ref(), self, token, signals, opts);
diff --git a/src/sys/fuchsia/handles.rs b/src/sys/fuchsia/handles.rs
index 269e272..ae6f07f 100644
--- a/src/sys/fuchsia/handles.rs
+++ b/src/sys/fuchsia/handles.rs
@@ -1,12 +1,12 @@
use {io, poll, Evented, Ready, Poll, PollOpt, Token};
-use magenta_sys::mx_handle_t;
+use zircon_sys::zx_handle_t;
use std::sync::Mutex;
/// Wrapper for registering a `HandleBase` type with mio.
#[derive(Debug)]
pub struct EventedHandle {
/// The handle to be registered.
- handle: mx_handle_t,
+ handle: zx_handle_t,
/// The current `Token` with which the handle is registered with mio.
token: Mutex<Option<Token>>,
@@ -18,7 +18,7 @@
///
/// The underlying handle must not be dropped while the
/// `EventedHandle` still exists.
- pub unsafe fn new(handle: mx_handle_t) -> Self {
+ pub unsafe fn new(handle: zx_handle_t) -> Self {
EventedHandle {
handle: handle,
token: Mutex::new(None),
@@ -26,7 +26,7 @@
}
/// Get the underlying handle being registered.
- pub fn get_handle(&self) -> mx_handle_t {
+ pub fn get_handle(&self) -> zx_handle_t {
self.handle
}
}
diff --git a/src/sys/fuchsia/mod.rs b/src/sys/fuchsia/mod.rs
index 5e6b639..10728fc 100644
--- a/src/sys/fuchsia/mod.rs
+++ b/src/sys/fuchsia/mod.rs
@@ -1,6 +1,6 @@
use {io, Ready, PollOpt};
use libc;
-use magenta;
+use zircon;
use std::mem;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::ops::{Deref, DerefMut};
@@ -20,7 +20,7 @@
pub use self::handles::EventedHandle;
pub use self::net::{TcpListener, TcpStream, UdpSocket};
pub use self::selector::{Events, Selector};
-pub use self::ready::{FuchsiaReady, mx_signals_t};
+pub use self::ready::{FuchsiaReady, zx_signals_t};
// Set non-blocking (workaround since the std version doesn't work in fuchsia)
// TODO: fix the std version and replace this
@@ -47,92 +47,41 @@
mod sys {
#![allow(non_camel_case_types)]
use std::os::unix::io::RawFd;
- pub use magenta_sys::{mx_handle_t, mx_signals_t};
+ pub use zircon_sys::{zx_handle_t, zx_signals_t};
// 17 fn pointers we don't need for mio :)
- pub type mxio_ops_t = [usize; 17];
+ pub type fdio_ops_t = [usize; 17];
pub type atomic_int_fast32_t = usize; // TODO: https://github.com/rust-lang/libc/issues/631
#[repr(C)]
- pub struct mxio_t {
- pub ops: *const mxio_ops_t,
+ pub struct fdio_t {
+ pub ops: *const fdio_ops_t,
pub magic: u32,
pub refcount: atomic_int_fast32_t,
pub dupcount: u32,
pub flags: u32,
}
- #[link(name="mxio")]
+ #[link(name="fdio")]
extern {
- pub fn __mxio_fd_to_io(fd: RawFd) -> *const mxio_t;
- pub fn __mxio_release(io: *const mxio_t);
+ pub fn __fdio_fd_to_io(fd: RawFd) -> *const fdio_t;
+ pub fn __fdio_release(io: *const fdio_t);
- pub fn __mxio_wait_begin(
- io: *const mxio_t,
+ pub fn __fdio_wait_begin(
+ io: *const fdio_t,
events: u32,
- handle_out: &mut mx_handle_t,
- signals_out: &mut mx_signals_t,
+ handle_out: &mut zx_handle_t,
+ signals_out: &mut zx_signals_t,
);
- pub fn __mxio_wait_end(
- io: *const mxio_t,
- signals: mx_signals_t,
+ pub fn __fdio_wait_end(
+ io: *const fdio_t,
+ signals: zx_signals_t,
events_out: &mut u32,
);
}
}
-/// Convert from magenta::Status to io::Error.
-///
-/// Note: these conversions are done on a "best-effort" basis and may not necessarily reflect
-/// exactly equivalent error types.
-fn status_to_io_err(status: magenta::Status) -> io::Error {
- use magenta::Status;
-
- let err_kind: io::ErrorKind = match status {
- Status::ErrInterruptedRetry => io::ErrorKind::Interrupted,
- Status::ErrBadHandle => io::ErrorKind::BrokenPipe,
- Status::ErrTimedOut => io::ErrorKind::TimedOut,
- Status::ErrShouldWait => io::ErrorKind::WouldBlock,
- Status::ErrPeerClosed => io::ErrorKind::ConnectionAborted,
- Status::ErrNotFound => io::ErrorKind::NotFound,
- Status::ErrAlreadyExists => io::ErrorKind::AlreadyExists,
- Status::ErrAlreadyBound => io::ErrorKind::AddrInUse,
- Status::ErrUnavailable => io::ErrorKind::AddrNotAvailable,
- Status::ErrAccessDenied => io::ErrorKind::PermissionDenied,
- Status::ErrIoRefused => io::ErrorKind::ConnectionRefused,
- Status::ErrIoDataIntegrity => io::ErrorKind::InvalidData,
-
- Status::ErrBadPath |
- Status::ErrInvalidArgs |
- Status::ErrOutOfRange |
- Status::ErrWrongType => io::ErrorKind::InvalidInput,
-
- Status::UnknownOther |
- Status::ErrNext |
- Status::ErrStop |
- Status::ErrNoSpace |
- Status::ErrFileBig |
- Status::ErrNotFile |
- Status::ErrNotDir |
- Status::ErrIoDataLoss |
- Status::ErrIo |
- Status::ErrCanceled |
- Status::ErrBadState |
- Status::ErrBufferTooSmall |
- Status::ErrBadSyscall |
- Status::NoError |
- Status::ErrInternal |
- Status::ErrNotSupported |
- Status::ErrNoResources |
- Status::ErrNoMemory |
- Status::ErrCallFailed
- => io::ErrorKind::Other
- }.into();
-
- err_kind.into()
-}
-
fn epoll_event_to_ready(epoll: u32) -> Ready {
let epoll = epoll as i32; // casts the bits directly
let mut kind = Ready::empty();
@@ -159,11 +108,11 @@
*/
}
-fn poll_opts_to_wait_async(poll_opts: PollOpt) -> magenta::WaitAsyncOpts {
+fn poll_opts_to_wait_async(poll_opts: PollOpt) -> zircon::WaitAsyncOpts {
if poll_opts.is_oneshot() {
- magenta::WaitAsyncOpts::Once
+ zircon::WaitAsyncOpts::Once
} else {
- magenta::WaitAsyncOpts::Repeating
+ zircon::WaitAsyncOpts::Repeating
}
}
diff --git a/src/sys/fuchsia/ready.rs b/src/sys/fuchsia/ready.rs
index 05126d3..97854f8 100644
--- a/src/sys/fuchsia/ready.rs
+++ b/src/sys/fuchsia/ready.rs
@@ -1,8 +1,8 @@
use event_imp::{Ready, ready_as_usize, ready_from_usize};
-pub use magenta_sys::{
- mx_signals_t,
- MX_OBJECT_READABLE,
- MX_OBJECT_WRITABLE,
+pub use zircon_sys::{
+ zx_signals_t,
+ ZX_OBJECT_READABLE,
+ ZX_OBJECT_WRITABLE,
};
use std::ops;
@@ -14,12 +14,12 @@
#[inline]
pub fn assert_fuchsia_ready_repr() {
debug_assert!(
- MX_OBJECT_READABLE.bits() as usize == ready_as_usize(Ready::readable()),
- "Magenta MX_OBJECT_READABLE should have the same repr as Ready::readable()"
+ ZX_OBJECT_READABLE.bits() as usize == ready_as_usize(Ready::readable()),
+ "Zircon ZX_OBJECT_READABLE should have the same repr as Ready::readable()"
);
debug_assert!(
- MX_OBJECT_WRITABLE.bits() as usize == ready_as_usize(Ready::writable()),
- "Magenta MX_OBJECT_WRITABLE should have the same repr as Ready::writable()"
+ ZX_OBJECT_WRITABLE.bits() as usize == ready_as_usize(Ready::writable()),
+ "Zircon ZX_OBJECT_WRITABLE should have the same repr as Ready::writable()"
);
}
@@ -36,32 +36,32 @@
pub struct FuchsiaReady(Ready);
impl FuchsiaReady {
- /// Returns the `FuchsiaReady` as raw magenta signals.
+ /// Returns the `FuchsiaReady` as raw zircon signals.
/// This function is just a more explicit, non-generic version of
/// `FuchsiaReady::into`.
#[inline]
- pub fn into_mx_signals(self) -> mx_signals_t {
- mx_signals_t::from_bits_truncate(ready_as_usize(self.0) as u32)
+ pub fn into_zx_signals(self) -> zx_signals_t {
+ zx_signals_t::from_bits_truncate(ready_as_usize(self.0) as u32)
}
}
-impl Into<mx_signals_t> for FuchsiaReady {
+impl Into<zx_signals_t> for FuchsiaReady {
#[inline]
- fn into(self) -> mx_signals_t {
- self.into_mx_signals()
+ fn into(self) -> zx_signals_t {
+ self.into_zx_signals()
}
}
-impl From<mx_signals_t> for FuchsiaReady {
+impl From<zx_signals_t> for FuchsiaReady {
#[inline]
- fn from(src: mx_signals_t) -> Self {
+ fn from(src: zx_signals_t) -> Self {
FuchsiaReady(src.into())
}
}
-impl From<mx_signals_t> for Ready {
+impl From<zx_signals_t> for Ready {
#[inline]
- fn from(src: mx_signals_t) -> Self {
+ fn from(src: zx_signals_t) -> Self {
ready_from_usize(src.bits() as usize)
}
}
@@ -144,38 +144,38 @@
}
}
-impl ops::BitOr<mx_signals_t> for FuchsiaReady {
+impl ops::BitOr<zx_signals_t> for FuchsiaReady {
type Output = FuchsiaReady;
#[inline]
- fn bitor(self, other: mx_signals_t) -> FuchsiaReady {
+ fn bitor(self, other: zx_signals_t) -> FuchsiaReady {
self | FuchsiaReady::from(other)
}
}
-impl ops::BitXor<mx_signals_t> for FuchsiaReady {
+impl ops::BitXor<zx_signals_t> for FuchsiaReady {
type Output = FuchsiaReady;
#[inline]
- fn bitxor(self, other: mx_signals_t) -> FuchsiaReady {
+ fn bitxor(self, other: zx_signals_t) -> FuchsiaReady {
self ^ FuchsiaReady::from(other)
}
}
-impl ops::BitAnd<mx_signals_t> for FuchsiaReady {
+impl ops::BitAnd<zx_signals_t> for FuchsiaReady {
type Output = FuchsiaReady;
#[inline]
- fn bitand(self, other: mx_signals_t) -> FuchsiaReady {
+ fn bitand(self, other: zx_signals_t) -> FuchsiaReady {
self & FuchsiaReady::from(other)
}
}
-impl ops::Sub<mx_signals_t> for FuchsiaReady {
+impl ops::Sub<zx_signals_t> for FuchsiaReady {
type Output = FuchsiaReady;
#[inline]
- fn sub(self, other: mx_signals_t) -> FuchsiaReady {
+ fn sub(self, other: zx_signals_t) -> FuchsiaReady {
self - FuchsiaReady::from(other)
}
}
diff --git a/src/sys/fuchsia/selector.rs b/src/sys/fuchsia/selector.rs
index caba672..f15c8eb 100644
--- a/src/sys/fuchsia/selector.rs
+++ b/src/sys/fuchsia/selector.rs
@@ -3,14 +3,13 @@
assert_fuchsia_ready_repr,
epoll_event_to_ready,
poll_opts_to_wait_async,
- status_to_io_err,
EventedFd,
EventedFdInner,
FuchsiaReady,
};
-use magenta;
-use magenta::AsHandleRef;
-use magenta_sys::mx_handle_t;
+use zircon;
+use zircon::AsHandleRef;
+use zircon_sys::zx_handle_t;
use std::collections::hash_map;
use std::fmt;
use std::mem;
@@ -65,8 +64,8 @@
pub struct Selector {
id: usize,
- /// Magenta object on which the handles have been registered, and on which events occur
- port: Arc<magenta::Port>,
+ /// Zircon object on which the handles have been registered, and on which events occur
+ port: Arc<zircon::Port>,
/// Whether or not `tokens_to_rereg` contains any elements. This is a best-effort attempt
/// used to prevent having to lock `tokens_to_rereg` when it is empty.
@@ -85,7 +84,7 @@
tokens_to_rereg: Mutex<Vec<Token>>,
/// Map from tokens to weak references to `EventedFdInner`-- a structure describing a
- /// file handle, its associated `mxio` object, and its current registration.
+ /// file handle, its associated `fdio` object, and its current registration.
token_to_fd: Mutex<hash_map::HashMap<Token, Weak<EventedFdInner>>>,
}
@@ -96,8 +95,7 @@
assert_fuchsia_ready_repr();
let port = Arc::new(
- magenta::Port::create(magenta::PortOpts::Default)
- .map_err(status_to_io_err)?
+ zircon::Port::create(zircon::PortOpts::Default)?
);
// offset by 1 to avoid choosing 0 as the id of a selector
@@ -121,7 +119,7 @@
}
/// Returns a reference to the underlying port `Arc`.
- pub fn port(&self) -> &Arc<magenta::Port> { &self.port }
+ pub fn port(&self) -> &Arc<zircon::Port> { &self.port }
/// Reregisters all registrations pointed to by the `tokens_to_rereg` list
/// if `has_tokens_to_rereg`.
@@ -156,25 +154,25 @@
let nanos = duration.as_secs().saturating_mul(1_000_000_000)
.saturating_add(duration.subsec_nanos() as u64);
- magenta::deadline_after(nanos)
+ zircon::deadline_after(nanos)
}
- None => magenta::MX_TIME_INFINITE,
+ None => zircon::ZX_TIME_INFINITE,
};
let packet = match self.port.wait(deadline) {
Ok(packet) => packet,
- Err(magenta::Status::ErrTimedOut) => return Ok(false),
- Err(e) => return Err(status_to_io_err(e)),
+ Err(zircon::Status::ErrTimedOut) => return Ok(false),
+ Err(e) => Err(e)?,
};
let observed_signals = match packet.contents() {
- magenta::PacketContents::SignalOne(signal_packet) => {
+ zircon::PacketContents::SignalOne(signal_packet) => {
signal_packet.observed()
}
- magenta::PacketContents::SignalRep(signal_packet) => {
+ zircon::PacketContents::SignalRep(signal_packet) => {
signal_packet.observed()
}
- magenta::PacketContents::User(_user_packet) => {
+ zircon::PacketContents::User(_user_packet) => {
// User packets are only ever sent by an Awakener
return Ok(true);
}
@@ -190,7 +188,7 @@
Ok(false)
},
RegType::Fd => {
- // Convert the signals to epoll events using __mxio_wait_end,
+ // Convert the signals to epoll events using __fdio_wait_end,
// and add to reregistration list if necessary.
let events: u32;
{
@@ -207,7 +205,7 @@
events = unsafe {
let mut events: u32 = mem::uninitialized();
- sys::fuchsia::sys::__mxio_wait_end(handle.mxio(), observed_signals, &mut events);
+ sys::fuchsia::sys::__fdio_wait_end(handle.fdio(), observed_signals, &mut events);
events
};
@@ -238,10 +236,10 @@
/// Register event interests for the given IO handle with the OS
pub fn register_fd(&self,
- handle: &magenta::Handle,
+ handle: &zircon::Handle,
fd: &EventedFd,
token: Token,
- signals: magenta::Signals,
+ signals: zircon::Signals,
poll_opts: PollOpt) -> io::Result<()>
{
{
@@ -256,24 +254,23 @@
let wait_async_opts = poll_opts_to_wait_async(poll_opts);
- let wait_res = handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts)
- .map_err(status_to_io_err);
+ let wait_res = handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts);
if wait_res.is_err() {
self.token_to_fd.lock().unwrap().remove(&token);
}
- wait_res
+ Ok(wait_res?)
}
/// Deregister event interests for the given IO handle with the OS
- pub fn deregister_fd(&self, handle: &magenta::Handle, token: Token) -> io::Result<()> {
+ pub fn deregister_fd(&self, handle: &zircon::Handle, token: Token) -> io::Result<()> {
self.token_to_fd.lock().unwrap().remove(&token);
// We ignore NotFound errors since oneshots are automatically deregistered,
// but mio will attempt to deregister them manually.
self.port.cancel(&*handle, token.0 as u64)
- .map_err(status_to_io_err)
+ .map_err(io::Error::from)
.or_else(|e| if e.kind() == io::ErrorKind::NotFound {
Ok(())
} else {
@@ -282,7 +279,7 @@
}
pub fn register_handle(&self,
- handle: mx_handle_t,
+ handle: zx_handle_t,
token: Token,
interests: Ready,
poll_opts: PollOpt) -> io::Result<()>
@@ -292,30 +289,28 @@
"Repeated level-triggered events are not supported on Fuchsia handles."));
}
- let temp_handle = unsafe { magenta::Handle::from_raw(handle) };
+ let temp_handle = unsafe { zircon::Handle::from_raw(handle) };
let res = temp_handle.wait_async_handle(
&self.port,
key_from_token_and_type(token, RegType::Handle)?,
- FuchsiaReady::from(interests).into_mx_signals(),
- poll_opts_to_wait_async(poll_opts))
- .map_err(status_to_io_err);
+ FuchsiaReady::from(interests).into_zx_signals(),
+ poll_opts_to_wait_async(poll_opts));
mem::forget(temp_handle);
- res
+ Ok(res?)
}
- pub fn deregister_handle(&self, handle: mx_handle_t, token: Token) -> io::Result<()>
+ pub fn deregister_handle(&self, handle: zx_handle_t, token: Token) -> io::Result<()>
{
- let temp_handle = unsafe { magenta::Handle::from_raw(handle) };
- let res = self.port.cancel(&temp_handle, key_from_token_and_type(token, RegType::Handle)?)
- .map_err(status_to_io_err);
+ let temp_handle = unsafe { zircon::Handle::from_raw(handle) };
+ let res = self.port.cancel(&temp_handle, key_from_token_and_type(token, RegType::Handle)?);
mem::forget(temp_handle);
- res
+ Ok(res?)
}
}
diff --git a/test/mod.rs b/test/mod.rs
index ad79234..75cda53 100644
--- a/test/mod.rs
+++ b/test/mod.rs
@@ -12,7 +12,7 @@
extern crate tempdir;
#[cfg(target_os = "fuchsia")]
-extern crate magenta;
+extern crate fuchsia_zircon as zircon;
pub use ports::localhost;
diff --git a/test/test_fuchsia_handles.rs b/test/test_fuchsia_handles.rs
index 589471f..85a1432 100644
--- a/test/test_fuchsia_handles.rs
+++ b/test/test_fuchsia_handles.rs
@@ -1,6 +1,6 @@
use mio::*;
use mio::fuchsia::EventedHandle;
-use magenta::{self, AsHandleRef};
+use zircon::{self, AsHandleRef};
use std::time::Duration;
const MS: u64 = 1_000;
@@ -11,7 +11,7 @@
let mut event_buffer = Events::with_capacity(1);
let event_buffer = &mut event_buffer;
- let (channel0, channel1) = magenta::Channel::create(magenta::ChannelOpts::Normal).unwrap();
+ let (channel0, channel1) = zircon::Channel::create(zircon::ChannelOpts::Normal).unwrap();
let channel1_evented = unsafe { EventedHandle::new(channel1.raw_handle()) };
poll.register(&channel1_evented, Token(1), Ready::readable(), PollOpt::edge()).unwrap();
