diff --git a/src/libstd/rt/io/file.rs b/src/libstd/rt/io/file.rs
index ad21dfea3cd18..3bc0e74c7822a 100644
--- a/src/libstd/rt/io/file.rs
+++ b/src/libstd/rt/io/file.rs
@@ -146,7 +146,7 @@ impl Seek for FileStream {
 }
 
 fn file_test_smoke_test_impl() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let message = "it's alright. have a good time";
         let filename = &Path("./tmp/file_rt_io_file_test.txt");
         {
@@ -174,7 +174,7 @@ fn file_test_io_smoke_test() {
 }
 
 fn file_test_invalid_path_opened_without_create_should_raise_condition_impl() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let filename = &Path("./tmp/file_that_does_not_exist.txt");
         let mut called = false;
         do io_error::cond.trap(|_| {
@@ -192,7 +192,7 @@ fn file_test_io_invalid_path_opened_without_create_should_raise_condition() {
 }
 
 fn file_test_unlinking_invalid_path_should_raise_condition_impl() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let filename = &Path("./tmp/file_another_file_that_does_not_exist.txt");
         let mut called = false;
         do io_error::cond.trap(|_| {
@@ -209,7 +209,7 @@ fn file_test_iounlinking_invalid_path_should_raise_condition() {
 }
 
 fn file_test_io_non_positional_read_impl() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         use str;
         let message = "ten-four";
         let mut read_mem = [0, .. 8];
@@ -242,7 +242,7 @@ fn file_test_io_non_positional_read() {
 }
 
 fn file_test_io_seeking_impl() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         use str;
         let message = "ten-four";
         let mut read_mem = [0, .. 4];
@@ -276,7 +276,7 @@ fn file_test_io_seek_and_tell_smoke_test() {
 
 fn file_test_io_seek_and_write_impl() {
     use io;
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         use str;
         let initial_msg =   "food-is-yummy";
         let overwrite_msg =    "-the-bar!!";
@@ -307,7 +307,7 @@ fn file_test_io_seek_and_write() {
 }
 
 fn file_test_io_seek_shakedown_impl() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         use str;          // 01234567890123
         let initial_msg =   "qwer-asdf-zxcv";
         let chunk_one = "qwer";
diff --git a/src/libstd/rt/io/net/tcp.rs b/src/libstd/rt/io/net/tcp.rs
index b533ebe923b7c..9f8b680b83f77 100644
--- a/src/libstd/rt/io/net/tcp.rs
+++ b/src/libstd/rt/io/net/tcp.rs
@@ -159,10 +159,11 @@ mod test {
     use rt::io::net::ip::{Ipv4Addr, SocketAddr};
     use rt::io::*;
     use prelude::*;
+    use rt::comm::oneshot;
 
     #[test] #[ignore]
     fn bind_error() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut called = false;
             do io_error::cond.trap(|e| {
                 assert!(e.kind == PermissionDenied);
@@ -179,7 +180,7 @@ mod test {
     #[test]
     #[ignore(cfg(windows))] // FIXME #8811
     fn connect_error() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut called = false;
             do io_error::cond.trap(|e| {
                 assert_eq!(e.kind, ConnectionRefused);
@@ -195,11 +196,15 @@ mod test {
 
     #[test]
     fn smoke_test_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 stream.read(buf);
@@ -207,6 +212,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             }
@@ -215,11 +221,15 @@ mod test {
 
     #[test]
     fn smoke_test_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 stream.read(buf);
@@ -227,6 +237,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             }
@@ -235,11 +246,15 @@ mod test {
 
     #[test]
     fn read_eof_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -247,6 +262,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -255,11 +271,15 @@ mod test {
 
     #[test]
     fn read_eof_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -267,6 +287,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -276,11 +297,15 @@ mod test {
     #[test]
     #[ignore(cfg(windows))] // FIXME #8811
     fn read_eof_twice_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -290,6 +315,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -299,11 +325,15 @@ mod test {
     #[test]
     #[ignore(cfg(windows))] // FIXME #8811
     fn read_eof_twice_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -313,6 +343,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -322,11 +353,15 @@ mod test {
     #[test]
     #[ignore(cfg(windows))] // FIXME #8811
     fn write_close_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let buf = [0];
                 loop {
@@ -343,6 +378,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -352,11 +388,15 @@ mod test {
     #[test]
     #[ignore(cfg(windows))] // FIXME #8811
     fn write_close_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 let mut stream = acceptor.accept();
                 let buf = [0];
                 loop {
@@ -373,6 +413,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -381,12 +422,16 @@ mod test {
 
     #[test]
     fn multiple_connect_serial_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let max = 10;
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 for ref mut stream in acceptor.incoming().take(max) {
                     let mut buf = [0];
                     stream.read(buf);
@@ -395,6 +440,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 do max.times {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
@@ -405,12 +451,16 @@ mod test {
 
     #[test]
     fn multiple_connect_serial_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let max = 10;
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 for ref mut stream in acceptor.incoming().take(max) {
                     let mut buf = [0];
                     stream.read(buf);
@@ -419,6 +469,7 @@ mod test {
             }
 
             do spawntask {
+                port.take().recv();
                 do max.times {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
@@ -429,12 +480,15 @@ mod test {
 
     #[test]
     fn multiple_connect_interleaved_greedy_schedule_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             static MAX: int = 10;
+            let (port, chan) = oneshot();
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
                     let stream = Cell::new(stream);
                     // Start another task to handle the connection
@@ -448,6 +502,7 @@ mod test {
                 }
             }
 
+            port.recv();
             connect(0, addr);
 
             fn connect(i: int, addr: SocketAddr) {
@@ -467,12 +522,15 @@ mod test {
 
     #[test]
     fn multiple_connect_interleaved_greedy_schedule_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             static MAX: int = 10;
+            let (port, chan) = oneshot();
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
                     let stream = Cell::new(stream);
                     // Start another task to handle the connection
@@ -486,6 +544,7 @@ mod test {
                 }
             }
 
+            port.recv();
             connect(0, addr);
 
             fn connect(i: int, addr: SocketAddr) {
@@ -505,12 +564,15 @@ mod test {
 
     #[test]
     fn multiple_connect_interleaved_lazy_schedule_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             static MAX: int = 10;
+            let (port, chan) = oneshot();
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 for stream in acceptor.incoming().take(MAX as uint) {
                     let stream = Cell::new(stream);
                     // Start another task to handle the connection
@@ -524,6 +586,7 @@ mod test {
                 }
             }
 
+            port.recv();
             connect(0, addr);
 
             fn connect(i: int, addr: SocketAddr) {
@@ -542,12 +605,15 @@ mod test {
     }
     #[test]
     fn multiple_connect_interleaved_lazy_schedule_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             static MAX: int = 10;
+            let (port, chan) = oneshot();
+            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
                 for stream in acceptor.incoming().take(MAX as uint) {
                     let stream = Cell::new(stream);
                     // Start another task to handle the connection
@@ -561,6 +627,7 @@ mod test {
                 }
             }
 
+            port.recv();
             connect(0, addr);
 
             fn connect(i: int, addr: SocketAddr) {
@@ -580,7 +647,7 @@ mod test {
 
     #[cfg(test)]
     fn socket_name(addr: SocketAddr) {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             do spawntask {
                 let mut listener = TcpListener::bind(addr).unwrap();
 
@@ -596,14 +663,20 @@ mod test {
 
     #[cfg(test)]
     fn peer_name(addr: SocketAddr) {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
+
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
+                chan.take().send(());
 
                 acceptor.accept();
             }
 
             do spawntask {
+                port.take().recv();
                 let stream = TcpStream::connect(addr);
 
                 assert!(stream.is_some());
diff --git a/src/libstd/rt/io/net/udp.rs b/src/libstd/rt/io/net/udp.rs
index 132ca064515c1..a65c918351ad9 100644
--- a/src/libstd/rt/io/net/udp.rs
+++ b/src/libstd/rt/io/net/udp.rs
@@ -112,10 +112,12 @@ mod test {
     use rt::io::net::ip::{Ipv4Addr, SocketAddr};
     use rt::io::*;
     use option::{Some, None};
+    use rt::comm::oneshot;
+    use cell::Cell;
 
     #[test]  #[ignore]
     fn bind_error() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut called = false;
             do io_error::cond.trap(|e| {
                 assert!(e.kind == PermissionDenied);
@@ -131,13 +133,17 @@ mod test {
 
     #[test]
     fn socket_smoke_test_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let server_ip = next_test_ip4();
             let client_ip = next_test_ip4();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(ref mut server) => {
+                        chan.take().send(());
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -154,7 +160,10 @@ mod test {
 
             do spawntask {
                 match UdpSocket::bind(client_ip) {
-                    Some(ref mut client) => client.sendto([99], server_ip),
+                    Some(ref mut client) => {
+                        port.take().recv();
+                        client.sendto([99], server_ip)
+                    }
                     None => fail!()
                 }
             }
@@ -163,13 +172,17 @@ mod test {
 
     #[test]
     fn socket_smoke_test_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let server_ip = next_test_ip6();
             let client_ip = next_test_ip6();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(ref mut server) => {
+                        chan.take().send(());
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -186,7 +199,10 @@ mod test {
 
             do spawntask {
                 match UdpSocket::bind(client_ip) {
-                    Some(ref mut client) => client.sendto([99], server_ip),
+                    Some(ref mut client) => {
+                        port.take().recv();
+                        client.sendto([99], server_ip)
+                    }
                     None => fail!()
                 }
             }
@@ -195,15 +211,19 @@ mod test {
 
     #[test]
     fn stream_smoke_test_ip4() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let server_ip = next_test_ip4();
             let client_ip = next_test_ip4();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(server) => {
                         let server = ~server;
                         let mut stream = server.connect(client_ip);
+                        chan.take().send(());
                         let mut buf = [0];
                         match stream.read(buf) {
                             Some(nread) => {
@@ -222,6 +242,7 @@ mod test {
                     Some(client) => {
                         let client = ~client;
                         let mut stream = client.connect(server_ip);
+                        port.take().recv();
                         stream.write([99]);
                     }
                     None => fail!()
@@ -232,15 +253,19 @@ mod test {
 
     #[test]
     fn stream_smoke_test_ip6() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let server_ip = next_test_ip6();
             let client_ip = next_test_ip6();
+            let (port, chan) = oneshot();
+            let port = Cell::new(port);
+            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(server) => {
                         let server = ~server;
                         let mut stream = server.connect(client_ip);
+                        chan.take().send(());
                         let mut buf = [0];
                         match stream.read(buf) {
                             Some(nread) => {
@@ -259,6 +284,7 @@ mod test {
                     Some(client) => {
                         let client = ~client;
                         let mut stream = client.connect(server_ip);
+                        port.take().recv();
                         stream.write([99]);
                     }
                     None => fail!()
@@ -269,7 +295,7 @@ mod test {
 
     #[cfg(test)]
     fn socket_name(addr: SocketAddr) {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             do spawntask {
                 let server = UdpSocket::bind(addr);
 
diff --git a/src/libstd/rt/io/option.rs b/src/libstd/rt/io/option.rs
index 098433f299c17..2ea1b6154830a 100644
--- a/src/libstd/rt/io/option.rs
+++ b/src/libstd/rt/io/option.rs
@@ -95,7 +95,7 @@ mod test {
 
     #[test]
     fn test_option_writer() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut writer: Option<MemWriter> = Some(MemWriter::new());
             writer.write([0, 1, 2]);
             writer.flush();
@@ -105,7 +105,7 @@ mod test {
 
     #[test]
     fn test_option_writer_error() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut writer: Option<MemWriter> = None;
 
             let mut called = false;
@@ -130,7 +130,7 @@ mod test {
 
     #[test]
     fn test_option_reader() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut reader: Option<MemReader> = Some(MemReader::new(~[0, 1, 2, 3]));
             let mut buf = [0, 0];
             reader.read(buf);
diff --git a/src/libstd/rt/io/timer.rs b/src/libstd/rt/io/timer.rs
index 7f2d88f994d8c..6754511b03811 100644
--- a/src/libstd/rt/io/timer.rs
+++ b/src/libstd/rt/io/timer.rs
@@ -47,7 +47,7 @@ mod test {
     use rt::test::*;
     #[test]
     fn test_io_timer_sleep_simple() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let timer = Timer::new();
             do timer.map_move |mut t| { t.sleep(1) };
         }
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index 65910e5ad086c..e8af0c749a04d 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -43,8 +43,9 @@ use task;
 #[cfg(test)] use unstable::run_in_bare_thread;
 #[cfg(test)] use rt::test::{spawntask,
                             next_test_ip4,
-                            run_in_newsched_task};
+                            run_in_mt_newsched_task};
 #[cfg(test)] use iter::{Iterator, range};
+#[cfg(test)] use rt::comm::oneshot;
 
 // XXX we should not be calling uvll functions in here.
 
@@ -377,7 +378,7 @@ mod test_remote {
 
     #[test]
     fn test_uv_remote() {
-        do run_in_newsched_task {
+        do run_in_mt_newsched_task {
             let mut tube = Tube::new();
             let tube_clone = tube.clone();
             let remote_cell = Cell::new_empty();
@@ -719,7 +720,9 @@ impl RtioSocket for UvTcpAcceptor {
 
 impl RtioTcpAcceptor for UvTcpAcceptor {
     fn accept(&mut self) -> Result<~RtioTcpStreamObject, IoError> {
-        self.incoming.recv()
+        do self.home_for_io |self_| {
+            self_.incoming.recv()
+        }
     }
 
     fn accept_simultaneously(&mut self) -> Result<(), IoError> {
@@ -1301,7 +1304,7 @@ impl RtioFileStream for UvFileStream {
 
 #[test]
 fn test_simple_io_no_connect() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         unsafe {
             let io: *mut IoFactoryObject = Local::unsafe_borrow();
             let addr = next_test_ip4();
@@ -1313,7 +1316,7 @@ fn test_simple_io_no_connect() {
 
 #[test]
 fn test_simple_udp_io_bind_only() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         unsafe {
             let io: *mut IoFactoryObject = Local::unsafe_borrow();
             let addr = next_test_ip4();
@@ -1477,8 +1480,11 @@ fn test_simple_homed_udp_io_bind_then_move_handle_then_home_and_close() {
 
 #[test]
 fn test_simple_tcp_server_and_client() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let addr = next_test_ip4();
+        let (port, chan) = oneshot();
+        let port = Cell::new(port);
+        let chan = Cell::new(chan);
 
         // Start the server first so it's listening when we connect
         do spawntask {
@@ -1486,6 +1492,7 @@ fn test_simple_tcp_server_and_client() {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let listener = (*io).tcp_bind(addr).unwrap();
                 let mut acceptor = listener.listen().unwrap();
+                chan.take().send(());
                 let mut stream = acceptor.accept().unwrap();
                 let mut buf = [0, .. 2048];
                 let nread = stream.read(buf).unwrap();
@@ -1499,6 +1506,7 @@ fn test_simple_tcp_server_and_client() {
 
         do spawntask {
             unsafe {
+                port.take().recv();
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut stream = (*io).tcp_connect(addr).unwrap();
                 stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
@@ -1591,14 +1599,18 @@ fn test_simple_tcp_server_and_client_on_diff_threads() {
 
 #[test]
 fn test_simple_udp_server_and_client() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let server_addr = next_test_ip4();
         let client_addr = next_test_ip4();
+        let (port, chan) = oneshot();
+        let port = Cell::new(port);
+        let chan = Cell::new(chan);
 
         do spawntask {
             unsafe {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut server_socket = (*io).udp_bind(server_addr).unwrap();
+                chan.take().send(());
                 let mut buf = [0, .. 2048];
                 let (nread,src) = server_socket.recvfrom(buf).unwrap();
                 assert_eq!(nread, 8);
@@ -1614,6 +1626,7 @@ fn test_simple_udp_server_and_client() {
             unsafe {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut client_socket = (*io).udp_bind(client_addr).unwrap();
+                port.take().recv();
                 client_socket.sendto([0, 1, 2, 3, 4, 5, 6, 7], server_addr);
             }
         }
@@ -1622,13 +1635,17 @@ fn test_simple_udp_server_and_client() {
 
 #[test] #[ignore(reason = "busted")]
 fn test_read_and_block() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let addr = next_test_ip4();
+        let (port, chan) = oneshot();
+        let port = Cell::new(port);
+        let chan = Cell::new(chan);
 
         do spawntask {
             let io: *mut IoFactoryObject = unsafe { Local::unsafe_borrow() };
             let listener = unsafe { (*io).tcp_bind(addr).unwrap() };
             let mut acceptor = listener.listen().unwrap();
+            chan.take().send(());
             let mut stream = acceptor.accept().unwrap();
             let mut buf = [0, .. 2048];
 
@@ -1663,6 +1680,7 @@ fn test_read_and_block() {
 
         do spawntask {
             unsafe {
+                port.take().recv();
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut stream = (*io).tcp_connect(addr).unwrap();
                 stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
@@ -1677,15 +1695,19 @@ fn test_read_and_block() {
 
 #[test]
 fn test_read_read_read() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let addr = next_test_ip4();
         static MAX: uint = 500000;
+        let (port, chan) = oneshot();
+        let port = Cell::new(port);
+        let chan = Cell::new(chan);
 
         do spawntask {
             unsafe {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let listener = (*io).tcp_bind(addr).unwrap();
                 let mut acceptor = listener.listen().unwrap();
+                chan.take().send(());
                 let mut stream = acceptor.accept().unwrap();
                 let buf = [1, .. 2048];
                 let mut total_bytes_written = 0;
@@ -1698,6 +1720,7 @@ fn test_read_read_read() {
 
         do spawntask {
             unsafe {
+                port.take().recv();
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut stream = (*io).tcp_connect(addr).unwrap();
                 let mut buf = [0, .. 2048];
@@ -1719,14 +1742,18 @@ fn test_read_read_read() {
 #[test]
 #[ignore(cfg(windows))] // FIXME #8816
 fn test_udp_twice() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let server_addr = next_test_ip4();
         let client_addr = next_test_ip4();
+        let (port, chan) = oneshot();
+        let port = Cell::new(port);
+        let chan = Cell::new(chan);
 
         do spawntask {
             unsafe {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut client = (*io).udp_bind(client_addr).unwrap();
+                port.take().recv();
                 assert!(client.sendto([1], server_addr).is_ok());
                 assert!(client.sendto([2], server_addr).is_ok());
             }
@@ -1736,6 +1763,7 @@ fn test_udp_twice() {
             unsafe {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut server = (*io).udp_bind(server_addr).unwrap();
+                chan.take().send(());
                 let mut buf1 = [0];
                 let mut buf2 = [0];
                 let (nread1, src1) = server.recvfrom(buf1).unwrap();
@@ -1753,18 +1781,27 @@ fn test_udp_twice() {
 
 #[test]
 fn test_udp_many_read() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         let server_out_addr = next_test_ip4();
         let server_in_addr = next_test_ip4();
         let client_out_addr = next_test_ip4();
         let client_in_addr = next_test_ip4();
         static MAX: uint = 500_000;
 
+        let (p1, c1) = oneshot();
+        let (p2, c2) = oneshot();
+
+        let first = Cell::new((p1, c2));
+        let second = Cell::new((p2, c1));
+
         do spawntask {
             unsafe {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut server_out = (*io).udp_bind(server_out_addr).unwrap();
                 let mut server_in = (*io).udp_bind(server_in_addr).unwrap();
+                let (port, chan) = first.take();
+                chan.send(());
+                port.recv();
                 let msg = [1, .. 2048];
                 let mut total_bytes_sent = 0;
                 let mut buf = [1];
@@ -1788,6 +1825,9 @@ fn test_udp_many_read() {
                 let io: *mut IoFactoryObject = Local::unsafe_borrow();
                 let mut client_out = (*io).udp_bind(client_out_addr).unwrap();
                 let mut client_in = (*io).udp_bind(client_in_addr).unwrap();
+                let (port, chan) = second.take();
+                port.recv();
+                chan.send(());
                 let mut total_bytes_recv = 0;
                 let mut buf = [0, .. 2048];
                 while total_bytes_recv < MAX {
@@ -1812,7 +1852,7 @@ fn test_udp_many_read() {
 
 #[test]
 fn test_timer_sleep_simple() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         unsafe {
             let io: *mut IoFactoryObject = Local::unsafe_borrow();
             let timer = (*io).timer_init();
@@ -1854,7 +1894,7 @@ fn file_test_uvio_full_simple_impl() {
 #[test]
 #[ignore(cfg(windows))] // FIXME #8816
 fn file_test_uvio_full_simple() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         file_test_uvio_full_simple_impl();
     }
 }
@@ -1874,7 +1914,7 @@ fn uvio_naive_print(input: &str) {
 
 #[test]
 fn file_test_uvio_write_to_stdout() {
-    do run_in_newsched_task {
+    do run_in_mt_newsched_task {
         uvio_naive_print("jubilation\n");
     }
 }