diff --git a/src/event_loop.rs b/src/event_loop.rs
index 693c8330f..d81a2265e 100644
--- a/src/event_loop.rs
+++ b/src/event_loop.rs
@@ -107,7 +107,7 @@ impl<H: Handler> EventLoop<H> {
 
     fn configured(config: Config) -> io::Result<EventLoop<H>> {
         // Create the IO poller
-        let mut poll = try!(Poll::new());
+        let poll = try!(Poll::new());
 
         // Create the timer
         let mut timer = Timer::new(
diff --git a/src/io.rs b/src/io.rs
index 5c2e85097..6983aad59 100644
--- a/src/io.rs
+++ b/src/io.rs
@@ -6,11 +6,11 @@ pub use std::io::{Read, Write, Result, Error, ErrorKind};
 
 /// A value that may be registered with an `EventLoop`
 pub trait Evented {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> Result<()>;
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> Result<()>;
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> Result<()>;
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> Result<()>;
 
-    fn deregister(&self, poll: &mut Poll) -> Result<()>;
+    fn deregister(&self, poll: &Poll) -> Result<()>;
 }
 
 pub trait TryRead {
diff --git a/src/net/tcp.rs b/src/net/tcp.rs
index 1159eb559..e4630448e 100644
--- a/src/net/tcp.rs
+++ b/src/net/tcp.rs
@@ -126,17 +126,17 @@ impl Write for TcpStream {
 }
 
 impl Evented for TcpStream {
-    fn register(&self, poll: &mut Poll, token: Token,
+    fn register(&self, poll: &Poll, token: Token,
                 interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token,
+    fn reregister(&self, poll: &Poll, token: Token,
                   interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }
@@ -224,17 +224,17 @@ impl TcpListener {
 }
 
 impl Evented for TcpListener {
-    fn register(&self, poll: &mut Poll, token: Token,
+    fn register(&self, poll: &Poll, token: Token,
                 interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token,
+    fn reregister(&self, poll: &Poll, token: Token,
                   interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }
diff --git a/src/net/udp.rs b/src/net/udp.rs
index 862586875..966c9c147 100644
--- a/src/net/udp.rs
+++ b/src/net/udp.rs
@@ -77,15 +77,15 @@ impl UdpSocket {
 }
 
 impl Evented for UdpSocket {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }
diff --git a/src/net/unix.rs b/src/net/unix.rs
index 0fbf16442..f36143edd 100644
--- a/src/net/unix.rs
+++ b/src/net/unix.rs
@@ -40,15 +40,15 @@ impl UnixSocket {
 }
 
 impl Evented for UnixSocket {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }
@@ -132,15 +132,15 @@ impl Write for UnixStream {
 }
 
 impl Evented for UnixStream {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }
@@ -182,15 +182,15 @@ impl UnixListener {
 }
 
 impl Evented for UnixListener {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.sys.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }
@@ -238,15 +238,15 @@ impl<'a> Read for &'a PipeReader {
 }
 
 impl Evented for PipeReader {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.io.deregister(poll)
     }
 }
@@ -283,15 +283,15 @@ impl<'a> Write for &'a PipeWriter {
 }
 
 impl Evented for PipeWriter {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.io.deregister(poll)
     }
 }
diff --git a/src/notify.rs b/src/notify.rs
index 188561531..8cc14ce9a 100644
--- a/src/notify.rs
+++ b/src/notify.rs
@@ -187,16 +187,16 @@ impl<M> NotifyInner<M> {
 }
 
 impl<M> Evented for Notify<M> {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         assert!(opts.is_edge(), "awakener can only be registered using edge-triggered events");
         self.inner.awaken.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, _: &mut Poll, _: Token, _: EventSet, _: PollOpt) -> io::Result<()> {
+    fn reregister(&self, _: &Poll, _: Token, _: EventSet, _: PollOpt) -> io::Result<()> {
         panic!("awakener is never reregistered");
     }
 
-    fn deregister(&self, _: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, _: &Poll) -> io::Result<()> {
         panic!("awakener is never deregistered");
     }
 }
diff --git a/src/poll.rs b/src/poll.rs
index 8e9334dd0..d59a3a7f1 100644
--- a/src/poll.rs
+++ b/src/poll.rs
@@ -180,19 +180,19 @@ impl Poll {
         // TODO: Allow config to be passed in
         let config = Config::default();
 
-        let mut poll = Poll {
+        let poll = Poll {
             selector: try!(sys::Selector::new()),
             readiness_queue: try!(ReadinessQueue::new(&config)),
             events: sys::Events::new(),
         };
 
         // Register the notification wakeup FD with the IO poller
-        // try!(poll.register(&poll.readiness_queue.inner().awakener, AWAKEN, EventSet::readable() | EventSet::writable() , PollOpt::edge()));
+        try!(poll.register(&poll.readiness_queue.inner().awakener, AWAKEN, EventSet::readable(), PollOpt::edge()));
 
         Ok(poll)
     }
 
-    pub fn register<E: ?Sized>(&mut self, io: &E, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()>
+    pub fn register<E: ?Sized>(&self, io: &E, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()>
         where E: Evented
     {
         /*
@@ -208,7 +208,7 @@ impl Poll {
         Ok(())
     }
 
-    pub fn reregister<E: ?Sized>(&mut self, io: &E, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()>
+    pub fn reregister<E: ?Sized>(&self, io: &E, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()>
         where E: Evented
     {
         trace!("registering with poller");
@@ -219,7 +219,7 @@ impl Poll {
         Ok(())
     }
 
-    pub fn deregister<E: ?Sized>(&mut self, io: &E) -> io::Result<()>
+    pub fn deregister<E: ?Sized>(&self, io: &E) -> io::Result<()>
         where E: Evented
     {
         trace!("deregistering IO with poller");
@@ -303,10 +303,6 @@ pub fn selector(poll: &Poll) -> &sys::Selector {
     &poll.selector
 }
 
-pub fn selector_mut(poll: &mut Poll) -> &mut sys::Selector {
-    &mut poll.selector
-}
-
 /*
  *
  * ===== Registration =====
diff --git a/src/sys/unix/awakener.rs b/src/sys/unix/awakener.rs
index 0704fa8f2..0e9c13a15 100644
--- a/src/sys/unix/awakener.rs
+++ b/src/sys/unix/awakener.rs
@@ -48,15 +48,15 @@ mod pipe {
     }
 
     impl Evented for Awakener {
-        fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+        fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
             self.reader().register(poll, token, interest, opts)
         }
 
-        fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+        fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
             self.reader().reregister(poll, token, interest, opts)
         }
 
-        fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+        fn deregister(&self, poll: &Poll) -> io::Result<()> {
             self.reader().deregister(poll)
         }
     }
diff --git a/src/sys/unix/eventedfd.rs b/src/sys/unix/eventedfd.rs
index b13237b39..75558f63c 100644
--- a/src/sys/unix/eventedfd.rs
+++ b/src/sys/unix/eventedfd.rs
@@ -12,15 +12,15 @@ use std::os::unix::io::RawFd;
 pub struct EventedFd<'a>(pub &'a RawFd);
 
 impl<'a> Evented for EventedFd<'a> {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
-        poll::selector_mut(poll).register(*self.0, token, interest, opts)
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+        poll::selector(poll).register(*self.0, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
-        poll::selector_mut(poll).reregister(*self.0, token, interest, opts)
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+        poll::selector(poll).reregister(*self.0, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
-        poll::selector_mut(poll).deregister(*self.0)
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
+        poll::selector(poll).deregister(*self.0)
     }
 }
diff --git a/src/sys/unix/io.rs b/src/sys/unix/io.rs
index a811da2a6..18b73e23c 100644
--- a/src/sys/unix/io.rs
+++ b/src/sys/unix/io.rs
@@ -44,16 +44,16 @@ impl AsRawFd for Io {
 }
 
 impl Evented for Io {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
-        poll::selector_mut(poll).register(self.fd, token, interest, opts)
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+        poll::selector(poll).register(self.fd, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
-        poll::selector_mut(poll).reregister(self.fd, token, interest, opts)
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+        poll::selector(poll).reregister(self.fd, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
-        poll::selector_mut(poll).deregister(self.fd)
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
+        poll::selector(poll).deregister(self.fd)
     }
 }
 
diff --git a/src/sys/unix/kqueue.rs b/src/sys/unix/kqueue.rs
index 67171b482..8b0035d8c 100644
--- a/src/sys/unix/kqueue.rs
+++ b/src/sys/unix/kqueue.rs
@@ -5,6 +5,7 @@ use nix::sys::event::{EventFilter, EventFlag, FilterFlag, KEvent, kqueue, kevent
 use nix::sys::event::{EV_ADD, EV_CLEAR, EV_DELETE, EV_DISABLE, EV_ENABLE, EV_EOF, EV_ERROR, EV_ONESHOT};
 use libc::{timespec, time_t, c_long};
 use std::{fmt, slice};
+use std::cell::UnsafeCell;
 use std::os::unix::io::RawFd;
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
@@ -16,13 +17,18 @@ use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 /// operation will return with an error. This matches windows behavior.
 static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
 
-#[derive(Debug)]
 pub struct Selector {
     id: usize,
     kq: RawFd,
-    changes: Events
+    changes: UnsafeCell<Vec<KEvent>>,
 }
 
+#[cfg(not(target_os = "netbsd"))]
+type UData = usize;
+
+#[cfg(target_os = "netbsd")]
+type UData = i64;
+
 impl Selector {
     pub fn new() -> io::Result<Selector> {
         let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
@@ -31,7 +37,7 @@ impl Selector {
         Ok(Selector {
             id: id,
             kq: kq,
-            changes: Events::new()
+            changes: UnsafeCell::new(vec![]),
         })
     }
 
@@ -48,7 +54,7 @@ impl Selector {
         let cnt = try!(kevent_ts(self.kq, &[], evts.as_mut_slice(), timeout)
                                   .map_err(super::from_nix_error));
 
-        self.changes.sys_events.clear();
+        self.mut_changes().clear();
 
         unsafe {
             evts.sys_events.set_len(cnt);
@@ -59,7 +65,7 @@ impl Selector {
         Ok(())
     }
 
-    pub fn register(&mut self, fd: RawFd, token: Token, interests: EventSet, opts: PollOpt) -> io::Result<()> {
+    pub fn register(&self, fd: RawFd, token: Token, interests: EventSet, opts: PollOpt) -> io::Result<()> {
         trace!("registering; token={:?}; interests={:?}", token, interests);
 
         self.ev_register(fd, token.as_usize(), EventFilter::EVFILT_READ, interests.contains(EventSet::readable()), opts);
@@ -68,20 +74,20 @@ impl Selector {
         self.flush_changes()
     }
 
-    pub fn reregister(&mut self, fd: RawFd, token: Token, interests: EventSet, opts: PollOpt) -> io::Result<()> {
+    pub fn reregister(&self, fd: RawFd, token: Token, interests: EventSet, opts: PollOpt) -> io::Result<()> {
         // Just need to call register here since EV_ADD is a mod if already
         // registered
         self.register(fd, token, interests, opts)
     }
 
-    pub fn deregister(&mut self, fd: RawFd) -> io::Result<()> {
+    pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
         self.ev_push(fd, 0, EventFilter::EVFILT_READ, EV_DELETE);
         self.ev_push(fd, 0, EventFilter::EVFILT_WRITE, EV_DELETE);
 
         self.flush_changes()
     }
 
-    fn ev_register(&mut self, fd: RawFd, token: usize, filter: EventFilter, enable: bool, opts: PollOpt) {
+    fn ev_register(&self, fd: RawFd, token: usize, filter: EventFilter, enable: bool, opts: PollOpt) {
         let mut flags = EV_ADD;
 
         if enable {
@@ -101,39 +107,43 @@ impl Selector {
         self.ev_push(fd, token, filter, flags);
     }
 
-    #[cfg(not(target_os = "netbsd"))]
-    fn ev_push(&mut self, fd: RawFd, token: usize, filter: EventFilter, flags: EventFlag) {
-        self.changes.sys_events.push(
-            KEvent {
-                ident: fd as ::libc::uintptr_t,
-                filter: filter,
-                flags: flags,
-                fflags: FilterFlag::empty(),
-                data: 0,
-                udata: token
-            });
-    }
-
-    #[cfg(target_os = "netbsd")]
-    fn ev_push(&mut self, fd: RawFd, token: usize, filter: EventFilter, flags: EventFlag) {
-        self.changes.sys_events.push(
+    fn ev_push(&self, fd: RawFd, token: usize, filter: EventFilter, flags: EventFlag) {
+        self.mut_changes().push(
             KEvent {
                 ident: fd as ::libc::uintptr_t,
                 filter: filter,
                 flags: flags,
                 fflags: FilterFlag::empty(),
                 data: 0,
-                udata: token as i64
+                udata: token as UData,
             });
     }
 
-    fn flush_changes(&mut self) -> io::Result<()> {
-        let result = kevent(self.kq, self.changes.as_slice(), &mut [], 0).map(|_| ())
+    fn flush_changes(&self) -> io::Result<()> {
+        let result = kevent(self.kq, self.changes(), &mut [], 0).map(|_| ())
             .map_err(super::from_nix_error).map(|_| ());
 
-        self.changes.sys_events.clear();
+        self.mut_changes().clear();
         result
     }
+
+    fn changes(&self) -> &[KEvent] {
+        unsafe { &(*self.changes.get())[..] }
+    }
+
+    fn mut_changes(&self) -> &mut Vec<KEvent> {
+        unsafe { &mut *self.changes.get() }
+    }
+}
+
+impl fmt::Debug for Selector {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Selector")
+            .field("id", &self.id)
+            .field("kq", &self.kq)
+            .field("changes", &self.changes().len())
+            .finish()
+    }
 }
 
 impl Drop for Selector {
@@ -210,6 +220,10 @@ impl Events {
         }
     }
 
+    fn push_sys_event(&mut self, event: KEvent) {
+        self.sys_events.push(event);
+    }
+
     pub fn push_event(&mut self, event: Event) {
         self.events.push(event);
     }
diff --git a/src/sys/unix/tcp.rs b/src/sys/unix/tcp.rs
index 2272a5bc8..02ba3a781 100644
--- a/src/sys/unix/tcp.rs
+++ b/src/sys/unix/tcp.rs
@@ -112,18 +112,18 @@ impl Write for TcpStream {
 }
 
 impl Evented for TcpStream {
-    fn register(&self, poll: &mut Poll, token: Token,
+    fn register(&self, poll: &Poll, token: Token,
                 interest: EventSet, opts: PollOpt) -> io::Result<()> {
         try!(self.associate_selector(poll));
         EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token,
+    fn reregister(&self, poll: &Poll, token: Token,
                   interest: EventSet, opts: PollOpt) -> io::Result<()> {
         EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         EventedFd(&self.as_raw_fd()).deregister(poll)
     }
 }
@@ -203,18 +203,18 @@ impl TcpListener {
 }
 
 impl Evented for TcpListener {
-    fn register(&self, poll: &mut Poll, token: Token,
+    fn register(&self, poll: &Poll, token: Token,
                 interest: EventSet, opts: PollOpt) -> io::Result<()> {
         try!(self.associate_selector(poll));
         EventedFd(&self.as_raw_fd()).register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token,
+    fn reregister(&self, poll: &Poll, token: Token,
                   interest: EventSet, opts: PollOpt) -> io::Result<()> {
         EventedFd(&self.as_raw_fd()).reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         EventedFd(&self.as_raw_fd()).deregister(poll)
     }
 }
diff --git a/src/sys/unix/udp.rs b/src/sys/unix/udp.rs
index 3f68c5a19..6a455634b 100644
--- a/src/sys/unix/udp.rs
+++ b/src/sys/unix/udp.rs
@@ -143,16 +143,16 @@ impl UdpSocket {
 }
 
 impl Evented for UdpSocket {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         try!(self.associate_selector(poll));
         self.io.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.io.deregister(poll)
     }
 }
diff --git a/src/sys/unix/uds.rs b/src/sys/unix/uds.rs
index 474d8a41e..1daa282f0 100644
--- a/src/sys/unix/uds.rs
+++ b/src/sys/unix/uds.rs
@@ -91,15 +91,15 @@ impl Write for UnixSocket {
 }
 
 impl Evented for UnixSocket {
-    fn register(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn register(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.register(poll, token, interest, opts)
     }
 
-    fn reregister(&self, poll: &mut Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
+    fn reregister(&self, poll: &Poll, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
         self.io.reregister(poll, token, interest, opts)
     }
 
-    fn deregister(&self, poll: &mut Poll) -> io::Result<()> {
+    fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.io.deregister(poll)
     }
 }
diff --git a/src/sys/windows/awakener.rs b/src/sys/windows/awakener.rs
index 13eb97a2e..314887749 100644
--- a/src/sys/windows/awakener.rs
+++ b/src/sys/windows/awakener.rs
@@ -43,7 +43,7 @@ impl Awakener {
 impl Evented for Awakener {
     fn register(&self, poll: &mut Poll, token: Token, _events: EventSet,
                 opts: PollOpt) -> io::Result<()> {
-        try!(self.iocp().associate(poll::selector_mut(poll), token, opts));
+        try!(self.iocp().associate(poll::selector(poll), token, opts));
         Ok(())
     }
 
diff --git a/src/sys/windows/tcp.rs b/src/sys/windows/tcp.rs
index b2b032acb..70d96c8ee 100644
--- a/src/sys/windows/tcp.rs
+++ b/src/sys/windows/tcp.rs
@@ -385,7 +385,7 @@ impl Evented for TcpStream {
                 interest: EventSet, opts: PollOpt) -> io::Result<()> {
         let mut me = self.inner();
         let me = &mut *me;
-        try!(me.iocp.register_socket(&me.socket, poll::selector_mut(poll), token, interest,
+        try!(me.iocp.register_socket(&me.socket, poll::selector(poll), token, interest,
                                      opts));
 
         // If we were connected before being registered process that request
@@ -404,7 +404,7 @@ impl Evented for TcpStream {
         let mut me = self.inner();
         {
             let me = &mut *me;
-            try!(me.iocp.reregister_socket(&me.socket, poll::selector_mut(poll), token,
+            try!(me.iocp.reregister_socket(&me.socket, poll::selector(poll), token,
                                            interest, opts));
         }
         self.post_register(interest, &mut me);
@@ -579,7 +579,7 @@ impl Evented for TcpListener {
                 interest: EventSet, opts: PollOpt) -> io::Result<()> {
         let mut me = self.inner();
         let me = &mut *me;
-        try!(me.iocp.register_socket(&me.socket, poll::selector_mut(poll), token, interest,
+        try!(me.iocp.register_socket(&me.socket, poll::selector(poll), token, interest,
                                      opts));
         self.imp.schedule_accept(me, false);
         Ok(())
@@ -589,7 +589,7 @@ impl Evented for TcpListener {
                   interest: EventSet, opts: PollOpt) -> io::Result<()> {
         let mut me = self.inner();
         let me = &mut *me;
-        try!(me.iocp.reregister_socket(&me.socket, poll::selector_mut(poll), token,
+        try!(me.iocp.reregister_socket(&me.socket, poll::selector(poll), token,
                                        interest, opts));
         self.imp.schedule_accept(me, false);
         Ok(())
diff --git a/src/sys/windows/udp.rs b/src/sys/windows/udp.rs
index 9a44d2114..6db066921 100644
--- a/src/sys/windows/udp.rs
+++ b/src/sys/windows/udp.rs
@@ -296,7 +296,7 @@ impl Evented for UdpSocket {
                 Socket::Building(ref b) => b as &AsRawSocket,
                 Socket::Empty => return Err(bad_state()),
             };
-            try!(me.iocp.register_socket(socket, poll::selector_mut(poll), token, interest,
+            try!(me.iocp.register_socket(socket, poll::selector(poll), token, interest,
                                          opts));
         }
         self.post_register(interest, &mut me);
@@ -313,7 +313,7 @@ impl Evented for UdpSocket {
                 Socket::Building(ref b) => b as &AsRawSocket,
                 Socket::Empty => return Err(bad_state()),
             };
-            try!(me.iocp.reregister_socket(socket, poll::selector_mut(poll), token, interest,
+            try!(me.iocp.reregister_socket(socket, poll::selector(poll), token, interest,
                                            opts));
         }
         self.post_register(interest, &mut me);