auto merge of #10603 : alexcrichton/rust/no-linked-failure, r=brson

The reasons for doing this are:

* The model on which linked failure is based is inherently complex
* The implementation is also very complex, and there are few remaining who
  fully understand the implementation
* There are existing race conditions in the core context switching function of
  the scheduler, and possibly others.
* It's unclear whether this model of linked failure maps well to a 1:1 threading
  model

Linked failure is often a desired aspect of tasks, but we would like to take a
much more conservative approach in re-implementing linked failure if at all.

Closes #8674
Closes #8318
Closes #8863

Author: bors

doc/rust.md

@@ -2349,9 +2349,9 @@ Indices are zero-based, and may be of any integral type. Vector access
 is bounds-checked at run-time. When the check fails, it will put the
 task in a _failing state_.
 
-~~~~
+~~~~ {.xfail-test}
 # use std::task;
-# do task::spawn_unlinked {
+# do task::spawn {
 
 ([1, 2, 3, 4])[0];
 (["a", "b"])[10]; // fails

doc/tutorial-tasks.md

@@ -402,22 +402,6 @@ freeing memory along the way---and then exits. Unlike exceptions in C++,
 exceptions in Rust are unrecoverable within a single task: once a task fails,
 there is no way to "catch" the exception.
 
-All tasks are, by default, _linked_ to each other. That means that the fates
-of all tasks are intertwined: if one fails, so do all the others.
-
-~~~{.xfail-test .linked-failure}
-# use std::task::spawn;
-# use std::task;
-# fn do_some_work() { loop { task::yield() } }
-# do task::try {
-// Create a child task that fails
-do spawn { fail!() }
-
-// This will also fail because the task we spawned failed
-do_some_work();
-# };
-~~~
-
 While it isn't possible for a task to recover from failure, tasks may notify
 each other of failure. The simplest way of handling task failure is with the
 `try` function, which is similar to `spawn`, but immediately blocks waiting
@@ -464,101 +448,7 @@ it trips, indicates an unrecoverable logic error); in other cases you
 might want to contain the failure at a certain boundary (perhaps a
 small piece of input from the outside world, which you happen to be
 processing in parallel, is malformed and its processing task can't
-proceed). Hence, you will need different _linked failure modes_.
-
-## Failure modes
-
-By default, task failure is _bidirectionally linked_, which means that if
-either task fails, it kills the other one.
-
-~~~{.xfail-test .linked-failure}
-# use std::task;
-# use std::comm::oneshot;
-# fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
-# do task::try {
-do spawn {
-    do spawn {
-        fail!();  // All three tasks will fail.
-    }
-    sleep_forever();  // Will get woken up by force, then fail
-}
-sleep_forever();  // Will get woken up by force, then fail
-# };
-~~~
-
-If you want parent tasks to be able to kill their children, but do not want a
-parent to fail automatically if one of its child task fails, you can call
-`task::spawn_supervised` for _unidirectionally linked_ failure. The
-function `task::try`, which we saw previously, uses `spawn_supervised`
-internally, with additional logic to wait for the child task to finish
-before returning. Hence:
-
-~~~{.xfail-test .linked-failure}
-# use std::comm::{stream, Chan, Port};
-# use std::comm::oneshot;
-# use std::task::{spawn, try};
-# use std::task;
-# fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
-# do task::try {
-let (receiver, sender): (Port<int>, Chan<int>) = stream();
-do spawn {  // Bidirectionally linked
-    // Wait for the supervised child task to exist.
-    let message = receiver.recv();
-    // Kill both it and the parent task.
-    assert!(message != 42);
-}
-do try {  // Unidirectionally linked
-    sender.send(42);
-    sleep_forever();  // Will get woken up by force
-}
-// Flow never reaches here -- parent task was killed too.
-# };
-~~~
-
-Supervised failure is useful in any situation where one task manages
-multiple fallible child tasks, and the parent task can recover
-if any child fails. On the other hand, if the _parent_ (supervisor) fails,
-then there is nothing the children can do to recover, so they should
-also fail.
-
-Supervised task failure propagates across multiple generations even if
-an intermediate generation has already exited:
-
-~~~{.xfail-test .linked-failure}
-# use std::task;
-# use std::comm::oneshot;
-# fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
-# fn wait_for_a_while() { for _ in range(0, 1000u) { task::yield() } }
-# do task::try::<int> {
-do task::spawn_supervised {
-    do task::spawn_supervised {
-        sleep_forever();  // Will get woken up by force, then fail
-    }
-    // Intermediate task immediately exits
-}
-wait_for_a_while();
-fail!();  // Will kill grandchild even if child has already exited
-# };
-~~~
-
-Finally, tasks can be configured to not propagate failure to each
-other at all, using `task::spawn_unlinked` for _isolated failure_.
-
-~~~{.xfail-test .linked-failure}
-# use std::task;
-# fn random() -> uint { 100 }
-# fn sleep_for(i: uint) { for _ in range(0, i) { task::yield() } }
-# do task::try::<()> {
-let (time1, time2) = (random(), random());
-do task::spawn_unlinked {
-    sleep_for(time2);  // Won't get forced awake
-    fail!();
-}
-sleep_for(time1);  // Won't get forced awake
-fail!();
-// It will take MAX(time1,time2) for the program to finish.
-# };
-~~~
+proceed).
 
 ## Creating a task with a bi-directional communication path
 

src/libextra/arc.rs

@@ -655,7 +655,7 @@ mod tests {
         let arc2 = ~arc.clone();
         let (p, c) = comm::stream();
 
-        do task::spawn_unlinked || {
+        do spawn {
             let _ = p.recv();
             do arc2.access_cond |one, cond| {
                 cond.signal();

src/libextra/comm.rs

@@ -137,7 +137,6 @@ pub fn rendezvous<T: Send>() -> (SyncPort<T>, SyncChan<T>) {
 mod test {
     use comm::{DuplexStream, rendezvous};
     use std::rt::test::run_in_uv_task;
-    use std::task::spawn_unlinked;
 
 
     #[test]
@@ -177,7 +176,7 @@ mod test {
     #[test]
     fn send_and_fail_and_try_recv() {
         let (port, chan) = rendezvous();
-        do spawn_unlinked {
+        do spawn {
             chan.duplex_stream.send(()); // Can't access this field outside this module
             fail!()
         }
@@ -187,7 +186,7 @@ mod test {
     #[test]
     fn try_send_and_recv_then_fail_before_ack() {
         let (port, chan) = rendezvous();
-        do spawn_unlinked {
+        do spawn {
             port.duplex_stream.recv();
             fail!()
         }
@@ -198,7 +197,7 @@ mod test {
     #[should_fail]
     fn send_and_recv_then_fail_before_ack() {
         let (port, chan) = rendezvous();
-        do spawn_unlinked {
+        do spawn {
             port.duplex_stream.recv();
             fail!()
         }

src/libextra/future.rs

@@ -27,7 +27,6 @@
 
 use std::cell::Cell;
 use std::comm::{PortOne, oneshot};
-use std::task;
 use std::util::replace;
 
 /// A type encapsulating the result of a computation which may not be complete
@@ -130,29 +129,12 @@ impl<A:Send> Future<A> {
 
         let (port, chan) = oneshot();
 
-        do task::spawn_with(chan) |chan| {
+        do spawn {
             chan.send(blk());
         }
 
         Future::from_port(port)
     }
-
-    pub fn spawn_with<B: Send>(v: B, blk: proc(B) -> A) -> Future<A> {
-        /*!
-         * Create a future from a unique closure taking one argument.
-         *
-         * The closure and its argument will be moved into a new task. The
-         * closure will be run and its result used as the value of the future.
-         */
-
-         let (port, chan) = oneshot();
-
-         do task::spawn_with((v, chan)) |(v, chan)| {
-            chan.send(blk(v));
-         }
-
-         Future::from_port(port)
-    }
 }
 
 #[cfg(test)]
@@ -207,12 +189,6 @@ mod test {
         assert_eq!(f.get(), ~"bale");
     }
 
-    #[test]
-    fn test_spawn_with() {
-        let mut f = Future::spawn_with(~"gale", |s| { s });
-        assert_eq!(f.get(), ~"gale");
-    }
-
     #[test]
     #[should_fail]
     fn test_futurefail() {

src/libextra/sync.rs

@@ -22,7 +22,6 @@ use std::borrow;
 use std::comm;
 use std::comm::SendDeferred;
 use std::comm::{GenericPort, Peekable};
-use std::task;
 use std::unstable::sync::{Exclusive, UnsafeArc};
 use std::unstable::atomics;
 use std::unstable::finally::Finally;
@@ -134,13 +133,11 @@ impl<Q:Send> Sem<Q> {
     }
 
     pub fn access<U>(&self, blk: || -> U) -> U {
-        do task::unkillable {
-            do (|| {
-                self.acquire();
-                do task::rekillable { blk() }
-            }).finally {
-                self.release();
-            }
+        do (|| {
+            self.acquire();
+            blk()
+        }).finally {
+            self.release();
         }
     }
 }
@@ -206,48 +203,41 @@ impl<'self> Condvar<'self> {
     pub fn wait_on(&self, condvar_id: uint) {
         let mut WaitEnd = None;
         let mut out_of_bounds = None;
-        do task::unkillable {
-            // Release lock, 'atomically' enqueuing ourselves in so doing.
-            unsafe {
-                do (**self.sem).with |state| {
-                    if condvar_id < state.blocked.len() {
-                        // Drop the lock.
-                        state.count += 1;
-                        if state.count <= 0 {
-                            state.waiters.signal();
-                        }
-                        // Create waiter nobe, and enqueue ourself to
-                        // be woken up by a signaller.
-                        WaitEnd = Some(state.blocked[condvar_id].wait_end());
-                    } else {
-                        out_of_bounds = Some(state.blocked.len());
+        // Release lock, 'atomically' enqueuing ourselves in so doing.
+        unsafe {
+            do (**self.sem).with |state| {
+                if condvar_id < state.blocked.len() {
+                    // Drop the lock.
+                    state.count += 1;
+                    if state.count <= 0 {
+                        state.waiters.signal();
                     }
+                    // Create waiter nobe, and enqueue ourself to
+                    // be woken up by a signaller.
+                    WaitEnd = Some(state.blocked[condvar_id].wait_end());
+                } else {
+                    out_of_bounds = Some(state.blocked.len());
                 }
             }
+        }
 
-            // If deschedule checks start getting inserted anywhere, we can be
-            // killed before or after enqueueing. Deciding whether to
-            // unkillably reacquire the lock needs to happen atomically
-            // wrt enqueuing.
-            do check_cvar_bounds(out_of_bounds, condvar_id, "cond.wait_on()") {
-                // Unconditionally "block". (Might not actually block if a
-                // signaller already sent -- I mean 'unconditionally' in contrast
-                // with acquire().)
-                do (|| {
-                    do task::rekillable {
-                        let _ = WaitEnd.take_unwrap().recv();
-                    }
-                }).finally {
-                    // Reacquire the condvar. Note this is back in the unkillable
-                    // section; it needs to succeed, instead of itself dying.
-                    match self.order {
-                        Just(lock) => do lock.access {
-                            self.sem.acquire();
-                        },
-                        Nothing => {
-                            self.sem.acquire();
-                        },
-                    }
+        // If deschedule checks start getting inserted anywhere, we can be
+        // killed before or after enqueueing.
+        do check_cvar_bounds(out_of_bounds, condvar_id, "cond.wait_on()") {
+            // Unconditionally "block". (Might not actually block if a
+            // signaller already sent -- I mean 'unconditionally' in contrast
+            // with acquire().)
+            do (|| {
+                let _ = WaitEnd.take_unwrap().recv();
+            }).finally {
+                // Reacquire the condvar.
+                match self.order {
+                    Just(lock) => do lock.access {
+                        self.sem.acquire();
+                    },
+                    Nothing => {
+                        self.sem.acquire();
+                    },
                 }
             }
         }
@@ -484,30 +474,28 @@ impl RWLock {
      */
     pub fn read<U>(&self, blk: || -> U) -> U {
         unsafe {
-            do task::unkillable {
-                do (&self.order_lock).access {
-                    let state = &mut *self.state.get();
-                    let old_count = state.read_count.fetch_add(1, atomics::Acquire);
-                    if old_count == 0 {
-                        (&self.access_lock).acquire();
-                        state.read_mode = true;
-                    }
+            do (&self.order_lock).access {
+                let state = &mut *self.state.get();
+                let old_count = state.read_count.fetch_add(1, atomics::Acquire);
+                if old_count == 0 {
+                    (&self.access_lock).acquire();
+                    state.read_mode = true;
                 }
-                do (|| {
-                    do task::rekillable { blk() }
-                }).finally {
-                    let state = &mut *self.state.get();
-                    assert!(state.read_mode);
-                    let old_count = state.read_count.fetch_sub(1, atomics::Release);
-                    assert!(old_count > 0);
-                    if old_count == 1 {
-                        state.read_mode = false;
-                        // Note: this release used to be outside of a locked access
-                        // to exclusive-protected state. If this code is ever
-                        // converted back to such (instead of using atomic ops),
-                        // this access MUST NOT go inside the exclusive access.
-                        (&self.access_lock).release();
-                    }
+            }
+            do (|| {
+                blk()
+            }).finally {
+                let state = &mut *self.state.get();
+                assert!(state.read_mode);
+                let old_count = state.read_count.fetch_sub(1, atomics::Release);
+                assert!(old_count > 0);
+                if old_count == 1 {
+                    state.read_mode = false;
+                    // Note: this release used to be outside of a locked access
+                    // to exclusive-protected state. If this code is ever
+                    // converted back to such (instead of using atomic ops),
+                    // this access MUST NOT go inside the exclusive access.
+                    (&self.access_lock).release();
                 }
             }
         }
@@ -518,14 +506,10 @@ impl RWLock {
      * 'write' from other tasks will run concurrently with this one.
      */
     pub fn write<U>(&self, blk: || -> U) -> U {
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            do (&self.access_lock).access {
-                (&self.order_lock).release();
-                do task::rekillable {
-                    blk()
-                }
-            }
+        (&self.order_lock).acquire();
+        do (&self.access_lock).access {
+            (&self.order_lock).release();
+            blk()
         }
     }
 
@@ -562,16 +546,12 @@ impl RWLock {
         // which can't happen until T2 finishes the downgrade-read entirely.
         // The astute reader will also note that making waking writers use the
         // order_lock is better for not starving readers.
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            do (&self.access_lock).access_cond |cond| {
-                (&self.order_lock).release();
-                do task::rekillable {
-                    let opt_lock = Just(&self.order_lock);
-                    blk(&Condvar { sem: cond.sem, order: opt_lock,
-                                   token: NonCopyable })
-                }
-            }
+        (&self.order_lock).acquire();
+        do (&self.access_lock).access_cond |cond| {
+            (&self.order_lock).release();
+            let opt_lock = Just(&self.order_lock);
+            blk(&Condvar { sem: cond.sem, order: opt_lock,
+                           token: NonCopyable })
         }
     }
 
@@ -599,39 +579,35 @@ impl RWLock {
     pub fn write_downgrade<U>(&self, blk: |v: RWLockWriteMode| -> U) -> U {
         // Implementation slightly different from the slicker 'write's above.
         // The exit path is conditional on whether the caller downgrades.
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            (&self.access_lock).acquire();
-            (&self.order_lock).release();
-            do (|| {
-                do task::rekillable {
-                    blk(RWLockWriteMode { lock: self, token: NonCopyable })
-                }
-            }).finally {
-                let writer_or_last_reader;
-                // Check if we're releasing from read mode or from write mode.
-                let state = unsafe { &mut *self.state.get() };
-                if state.read_mode {
-                    // Releasing from read mode.
-                    let old_count = state.read_count.fetch_sub(1, atomics::Release);
-                    assert!(old_count > 0);
-                    // Check if other readers remain.
-                    if old_count == 1 {
-                        // Case 1: Writer downgraded & was the last reader
-                        writer_or_last_reader = true;
-                        state.read_mode = false;
-                    } else {
-                        // Case 2: Writer downgraded & was not the last reader
-                        writer_or_last_reader = false;
-                    }
-                } else {
-                    // Case 3: Writer did not downgrade
+        (&self.order_lock).acquire();
+        (&self.access_lock).acquire();
+        (&self.order_lock).release();
+        do (|| {
+            blk(RWLockWriteMode { lock: self, token: NonCopyable })
+        }).finally {
+            let writer_or_last_reader;
+            // Check if we're releasing from read mode or from write mode.
+            let state = unsafe { &mut *self.state.get() };
+            if state.read_mode {
+                // Releasing from read mode.
+                let old_count = state.read_count.fetch_sub(1, atomics::Release);
+                assert!(old_count > 0);
+                // Check if other readers remain.
+                if old_count == 1 {
+                    // Case 1: Writer downgraded & was the last reader
                     writer_or_last_reader = true;
+                    state.read_mode = false;
+                } else {
+                    // Case 2: Writer downgraded & was not the last reader
+                    writer_or_last_reader = false;
                 }
-                if writer_or_last_reader {
-                    // Nobody left inside; release the "reader cloud" lock.
-                    (&self.access_lock).release();
-                }
+            } else {
+                // Case 3: Writer did not downgrade
+                writer_or_last_reader = true;
+            }
+            if writer_or_last_reader {
+                // Nobody left inside; release the "reader cloud" lock.
+                (&self.access_lock).release();
             }
         }
     }
@@ -643,23 +619,21 @@ impl RWLock {
             fail!("Can't downgrade() with a different rwlock's write_mode!");
         }
         unsafe {
-            do task::unkillable {
-                let state = &mut *self.state.get();
-                assert!(!state.read_mode);
-                state.read_mode = true;
-                // If a reader attempts to enter at this point, both the
-                // downgrader and reader will set the mode flag. This is fine.
-                let old_count = state.read_count.fetch_add(1, atomics::Release);
-                // If another reader was already blocking, we need to hand-off
-                // the "reader cloud" access lock to them.
-                if old_count != 0 {
-                    // Guaranteed not to let another writer in, because
-                    // another reader was holding the order_lock. Hence they
-                    // must be the one to get the access_lock (because all
-                    // access_locks are acquired with order_lock held). See
-                    // the comment in write_cond for more justification.
-                    (&self.access_lock).release();
-                }
+            let state = &mut *self.state.get();
+            assert!(!state.read_mode);
+            state.read_mode = true;
+            // If a reader attempts to enter at this point, both the
+            // downgrader and reader will set the mode flag. This is fine.
+            let old_count = state.read_count.fetch_add(1, atomics::Release);
+            // If another reader was already blocking, we need to hand-off
+            // the "reader cloud" access lock to them.
+            if old_count != 0 {
+                // Guaranteed not to let another writer in, because
+                // another reader was holding the order_lock. Hence they
+                // must be the one to get the access_lock (because all
+                // access_locks are acquired with order_lock held). See
+                // the comment in write_cond for more justification.
+                (&self.access_lock).release();
             }
         }
         RWLockReadMode { lock: token.lock, token: NonCopyable }

src/libextra/test.rs

@@ -875,7 +875,6 @@ pub fn run_test(force_ignore: bool,
         let testfn_cell = ::std::cell::Cell::new(testfn);
         do task::spawn {
             let mut task = task::task();
-            task.unlinked();
             task.name(match desc.name {
                 DynTestName(ref name) => SendStrOwned(name.clone()),
                 StaticTestName(name) => SendStrStatic(name),

src/libextra/time.rs

@@ -954,10 +954,10 @@ mod tests {
 
     use std::f64;
     use std::result::{Err, Ok};
-    use std::libc;
 
     #[cfg(windows)]
     fn set_time_zone() {
+        use std::libc;
         // Windows crt doesn't see any environment variable set by
         // `SetEnvironmentVariable`, which `os::setenv` internally uses.
         // It is why we use `putenv` here.

src/librustc/lib.rs

@@ -338,7 +338,6 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
     let ch_capture = ch.clone();
     let mut task_builder = task::task();
     task_builder.name("rustc");
-    task_builder.supervised();
 
     // XXX: Hacks on hacks. If the env is trying to override the stack size
     // then *don't* set it explicitly.

src/librustdoc/html/render.rs

@@ -709,10 +709,11 @@ impl Context {
             let prog_chan = prog_chan.clone();
 
             let mut task = task::task();
-            task.unlinked(); // we kill things manually
             task.name(format!("worker{}", i));
-            task.spawn_with(cache.clone(),
-                            |cache| worker(cache, &port, &chan, &prog_chan));
+            let cache = cache.clone();
+            do task.spawn {
+                worker(cache, &port, &chan, &prog_chan);
+            }
 
             fn worker(cache: RWArc<Cache>,
                       port: &SharedPort<Work>,

src/librustuv/file.rs

@@ -20,7 +20,6 @@ use std::io;
 use std::rt::local::Local;
 use std::rt::rtio;
 use std::rt::sched::{Scheduler, SchedHandle};
-use std::task;
 use std::vec;
 
 use super::{Loop, UvError, uv_error_to_io_error, wait_until_woken_after};
@@ -298,26 +297,24 @@ impl Drop for FsRequest {
 fn execute(f: &fn(*uvll::uv_fs_t, uvll::uv_fs_cb) -> c_int)
     -> Result<FsRequest, UvError>
 {
-    return do task::unkillable {
-        let mut req = FsRequest {
-            fired: false,
-            req: unsafe { uvll::malloc_req(uvll::UV_FS) }
-        };
-        match f(req.req, fs_cb) {
-            0 => {
-                req.fired = true;
-                let mut slot = None;
-                do wait_until_woken_after(&mut slot) {
-                    unsafe { uvll::set_data_for_req(req.req, &slot) }
-                }
-                match req.get_result() {
-                    n if n < 0 => Err(UvError(n)),
-                    _ => Ok(req),
-                }
+    let mut req = FsRequest {
+        fired: false,
+        req: unsafe { uvll::malloc_req(uvll::UV_FS) }
+    };
+    return match f(req.req, fs_cb) {
+        0 => {
+            req.fired = true;
+            let mut slot = None;
+            do wait_until_woken_after(&mut slot) {
+                unsafe { uvll::set_data_for_req(req.req, &slot) }
+            }
+            match req.get_result() {
+                n if n < 0 => Err(UvError(n)),
+                _ => Ok(req),
             }
-            n => Err(UvError(n))
-
         }
+        n => Err(UvError(n))
+
     };
 
     extern fn fs_cb(req: *uvll::uv_fs_t) {

src/librustuv/net.rs

@@ -20,7 +20,6 @@ use std::rt::rtio;
 use std::rt::sched::{Scheduler, SchedHandle};
 use std::rt::tube::Tube;
 use std::str;
-use std::task;
 use std::vec;
 
 use stream::StreamWatcher;
@@ -176,36 +175,34 @@ impl TcpWatcher {
     {
         struct Ctx { status: c_int, task: Option<BlockedTask> }
 
-        return do task::unkillable {
-            let tcp = TcpWatcher::new(loop_);
-            let ret = do socket_addr_as_sockaddr(address) |addr| {
-                let mut req = Request::new(uvll::UV_CONNECT);
-                let result = unsafe {
-                    uvll::uv_tcp_connect(req.handle, tcp.handle, addr,
-                                         connect_cb)
-                };
-                match result {
-                    0 => {
-                        req.defuse(); // uv callback now owns this request
-                        let mut cx = Ctx { status: 0, task: None };
-                        do wait_until_woken_after(&mut cx.task) {
-                            req.set_data(&cx);
-                        }
-                        match cx.status {
-                            0 => Ok(()),
-                            n => Err(UvError(n)),
-                        }
+        let tcp = TcpWatcher::new(loop_);
+        let ret = do socket_addr_as_sockaddr(address) |addr| {
+            let mut req = Request::new(uvll::UV_CONNECT);
+            let result = unsafe {
+                uvll::uv_tcp_connect(req.handle, tcp.handle, addr,
+                                     connect_cb)
+            };
+            match result {
+                0 => {
+                    req.defuse(); // uv callback now owns this request
+                    let mut cx = Ctx { status: 0, task: None };
+                    do wait_until_woken_after(&mut cx.task) {
+                        req.set_data(&cx);
+                    }
+                    match cx.status {
+                        0 => Ok(()),
+                        n => Err(UvError(n)),
                     }
-                    n => Err(UvError(n))
                 }
-            };
-
-            match ret {
-                Ok(()) => Ok(tcp),
-                Err(e) => Err(e),
+                n => Err(UvError(n))
             }
         };
 
+        return match ret {
+            Ok(()) => Ok(tcp),
+            Err(e) => Err(e),
+        };
+
         extern fn connect_cb(req: *uvll::uv_connect_t, status: c_int) {
             let req = Request::wrap(req);
             assert!(status != uvll::ECANCELED);
@@ -291,25 +288,23 @@ impl TcpListener {
     pub fn bind(loop_: &mut Loop, address: SocketAddr)
         -> Result<~TcpListener, UvError>
     {
-        do task::unkillable {
-            let handle = unsafe { uvll::malloc_handle(uvll::UV_TCP) };
-            assert_eq!(unsafe {
-                uvll::uv_tcp_init(loop_.handle, handle)
-            }, 0);
-            let l = ~TcpListener {
-                home: get_handle_to_current_scheduler!(),
-                handle: handle,
-                closing_task: None,
-                outgoing: Tube::new(),
-            };
-            let res = socket_addr_as_sockaddr(address, |addr| unsafe {
-                uvll::uv_tcp_bind(l.handle, addr)
-            });
-            match res {
-                0 => Ok(l.install()),
-                n => Err(UvError(n))
-            }
-        }
+        let handle = unsafe { uvll::malloc_handle(uvll::UV_TCP) };
+        assert_eq!(unsafe {
+            uvll::uv_tcp_init(loop_.handle, handle)
+        }, 0);
+        let l = ~TcpListener {
+            home: get_handle_to_current_scheduler!(),
+            handle: handle,
+            closing_task: None,
+            outgoing: Tube::new(),
+        };
+        let res = socket_addr_as_sockaddr(address, |addr| unsafe {
+            uvll::uv_tcp_bind(l.handle, addr)
+        });
+        return match res {
+            0 => Ok(l.install()),
+            n => Err(UvError(n))
+        };
     }
 }
 
@@ -426,22 +421,20 @@ impl UdpWatcher {
     pub fn bind(loop_: &Loop, address: SocketAddr)
         -> Result<UdpWatcher, UvError>
     {
-        do task::unkillable {
-            let udp = UdpWatcher {
-                handle: unsafe { uvll::malloc_handle(uvll::UV_UDP) },
-                home: get_handle_to_current_scheduler!(),
-            };
-            assert_eq!(unsafe {
-                uvll::uv_udp_init(loop_.handle, udp.handle)
-            }, 0);
-            let result = socket_addr_as_sockaddr(address, |addr| unsafe {
-                uvll::uv_udp_bind(udp.handle, addr, 0u32)
-            });
-            match result {
-                0 => Ok(udp),
-                n => Err(UvError(n)),
-            }
-        }
+        let udp = UdpWatcher {
+            handle: unsafe { uvll::malloc_handle(uvll::UV_UDP) },
+            home: get_handle_to_current_scheduler!(),
+        };
+        assert_eq!(unsafe {
+            uvll::uv_udp_init(loop_.handle, udp.handle)
+        }, 0);
+        let result = socket_addr_as_sockaddr(address, |addr| unsafe {
+            uvll::uv_udp_bind(udp.handle, addr, 0u32)
+        });
+        return match result {
+            0 => Ok(udp),
+            n => Err(UvError(n)),
+        };
     }
 }
 
@@ -1123,16 +1116,14 @@ mod test {
                 assert!(maybe_socket.is_ok());
 
                 // block self on sched1
-                do task::unkillable { // FIXME(#8674)
-                    let scheduler: ~Scheduler = Local::take();
-                    do scheduler.deschedule_running_task_and_then |_, task| {
-                        // unblock task
-                        do task.wake().map |task| {
-                            // send self to sched2
-                            tasksFriendHandle.take().send(TaskFromFriend(task));
-                        };
-                        // sched1 should now sleep since it has nothing else to do
-                    }
+                let scheduler: ~Scheduler = Local::take();
+                do scheduler.deschedule_running_task_and_then |_, task| {
+                    // unblock task
+                    do task.wake().map |task| {
+                        // send self to sched2
+                        tasksFriendHandle.take().send(TaskFromFriend(task));
+                    };
+                    // sched1 should now sleep since it has nothing else to do
                 }
                 // sched2 will wake up and get the task as we do nothing else,
                 // the function ends and the socket goes out of scope sched2
@@ -1180,7 +1171,7 @@ mod test {
         let chan = Cell::new(chan);
         let addr = next_test_ip4();
 
-        do task::spawn_unlinked { // please no linked failure
+        do spawn {
             let w = TcpListener::bind(local_loop(), addr).unwrap();
             let mut w = w.listen().unwrap();
             chan.take().send(());

src/librustuv/pipe.rs

@@ -16,7 +16,6 @@ use std::rt::local::Local;
 use std::rt::rtio::{RtioPipe, RtioUnixListener, RtioUnixAcceptor};
 use std::rt::sched::{Scheduler, SchedHandle};
 use std::rt::tube::Tube;
-use std::task;
 
 use stream::StreamWatcher;
 use super::{Loop, UvError, UvHandle, Request, uv_error_to_io_error,
@@ -74,26 +73,23 @@ impl PipeWatcher {
     pub fn connect(loop_: &Loop, name: &CString) -> Result<PipeWatcher, UvError>
     {
         struct Ctx { task: Option<BlockedTask>, result: libc::c_int, }
-        return do task::unkillable {
-            let mut cx = Ctx { task: None, result: 0 };
-            let mut req = Request::new(uvll::UV_CONNECT);
-            let pipe = PipeWatcher::new(loop_, false);
-
-            do wait_until_woken_after(&mut cx.task) {
-                unsafe {
-                    uvll::uv_pipe_connect(req.handle,
-                                          pipe.handle(),
-                                          name.with_ref(|p| p),
-                                          connect_cb)
-                }
-                req.set_data(&cx);
-                req.defuse(); // uv callback now owns this request
-            }
-            match cx.result {
-                0 => Ok(pipe),
-                n => Err(UvError(n))
-            }
+        let mut cx = Ctx { task: None, result: 0 };
+        let mut req = Request::new(uvll::UV_CONNECT);
+        let pipe = PipeWatcher::new(loop_, false);
 
+        do wait_until_woken_after(&mut cx.task) {
+            unsafe {
+                uvll::uv_pipe_connect(req.handle,
+                                      pipe.handle(),
+                                      name.with_ref(|p| p),
+                                      connect_cb)
+            }
+            req.set_data(&cx);
+            req.defuse(); // uv callback now owns this request
+        }
+        return match cx.result {
+            0 => Ok(pipe),
+            n => Err(UvError(n))
         };
 
         extern fn connect_cb(req: *uvll::uv_connect_t, status: libc::c_int) {;
@@ -153,24 +149,22 @@ extern fn pipe_close_cb(handle: *uvll::uv_handle_t) {
 
 impl PipeListener {
     pub fn bind(loop_: &Loop, name: &CString) -> Result<~PipeListener, UvError> {
-        do task::unkillable {
-            let pipe = PipeWatcher::new(loop_, false);
-            match unsafe {
-                uvll::uv_pipe_bind(pipe.handle(), name.with_ref(|p| p))
-            } {
-                0 => {
-                    // If successful, unwrap the PipeWatcher because we control how
-                    // we close the pipe differently. We can't rely on
-                    // StreamWatcher's default close method.
-                    let p = ~PipeListener {
-                        home: get_handle_to_current_scheduler!(),
-                        pipe: pipe.unwrap(),
-                        outgoing: Tube::new(),
-                    };
-                    Ok(p.install())
-                }
-                n => Err(UvError(n))
+        let pipe = PipeWatcher::new(loop_, false);
+        match unsafe {
+            uvll::uv_pipe_bind(pipe.handle(), name.with_ref(|p| p))
+        } {
+            0 => {
+                // If successful, unwrap the PipeWatcher because we control how
+                // we close the pipe differently. We can't rely on
+                // StreamWatcher's default close method.
+                let p = ~PipeListener {
+                    home: get_handle_to_current_scheduler!(),
+                    pipe: pipe.unwrap(),
+                    outgoing: Tube::new(),
+                };
+                Ok(p.install())
             }
+            n => Err(UvError(n))
         }
     }
 }
@@ -245,7 +239,6 @@ mod tests {
     use std::comm::oneshot;
     use std::rt::rtio::{RtioUnixListener, RtioUnixAcceptor, RtioPipe};
     use std::rt::test::next_test_unix;
-    use std::task;
 
     use super::*;
     use super::super::local_loop;
@@ -314,7 +307,7 @@ mod tests {
         let (port, chan) = oneshot();
         let chan = Cell::new(chan);
 
-        do task::spawn_unlinked { // plz no linked failure
+        do spawn {
             let p = PipeListener::bind(local_loop(), &path2.to_c_str()).unwrap();
             let mut p = p.listen().unwrap();
             chan.take().send(());

src/librustuv/uvio.rs

@@ -44,11 +44,6 @@ pub trait HomingIO {
     fn go_to_IO_home(&mut self) -> uint {
         use std::rt::sched::RunOnce;
 
-        unsafe {
-            let task: *mut Task = Local::unsafe_borrow();
-            (*task).death.inhibit_kill((*task).unwinder.unwinding);
-        }
-
         let _f = ForbidUnwind::new("going home");
 
         let current_sched_id = do Local::borrow |sched: &mut Scheduler| {
@@ -127,11 +122,6 @@ impl Drop for HomingMissile {
         }
 
         util::ignore(f);
-
-        unsafe {
-            let task: *mut Task = Local::unsafe_borrow();
-            (*task).death.allow_kill((*task).unwinder.unwinding);
-        }
     }
 }
 

src/libstd/path/posix.rs

@@ -565,7 +565,6 @@ mod tests {
             ($name:expr => $code:block) => (
                 {
                     let mut t = task::task();
-                    t.supervised();
                     t.name($name);
                     let res = do t.try $code;
                     assert!(res.is_err());

src/libstd/path/windows.rs

@@ -1290,7 +1290,6 @@ mod tests {
             ($name:expr => $code:block) => (
                 {
                     let mut t = task::task();
-                    t.supervised();
                     t.name($name);
                     let res = do t.try $code;
                     assert!(res.is_err());

src/libstd/rand/os.rs

@@ -162,7 +162,7 @@ mod test {
         for _ in range(0, 20) {
             let (p, c) = comm::stream();
             chans.push(c);
-            do task::spawn_with(p) |p| {
+            do task::spawn {
                 // wait until all the tasks are ready to go.
                 p.recv();
 

src/libstd/rt/kill.rs

@@ -88,7 +88,7 @@ pub use self::util::set_exit_status;
 pub use self::util::default_sched_threads;
 
 // Re-export of the functionality in the kill module
-pub use self::kill::{KillHandle, BlockedTask};
+pub use self::kill::BlockedTask;
 
 // XXX: these probably shouldn't be public...
 #[doc(hidden)]

src/libstd/rt/mod.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use either::{Left, Right};
 use option::{Option, Some, None};
 use cast::{transmute, transmute_mut_region, transmute_mut_unsafe};
 use clone::Clone;
@@ -621,9 +620,6 @@ impl Scheduler {
         unsafe {
             let task: *mut Task = Local::unsafe_borrow();
             (*task).sched.get_mut_ref().run_cleanup_job();
-
-            // Must happen after running the cleanup job (of course).
-            (*task).death.check_killed((*task).unwinder.unwinding);
         }
     }
 
@@ -689,14 +685,9 @@ impl Scheduler {
     pub fn switch_running_tasks_and_then(~self, next_task: ~Task,
                                          f: |&mut Scheduler, BlockedTask|) {
         // This is where we convert the BlockedTask-taking closure into one
-        // that takes just a Task, and is aware of the block-or-killed protocol.
+        // that takes just a Task
         do self.change_task_context(next_task) |sched, task| {
-            // Task might need to receive a kill signal instead of blocking.
-            // We can call the "and_then" only if it blocks successfully.
-            match BlockedTask::try_block(task) {
-                Left(killed_task) => sched.enqueue_task(killed_task),
-                Right(blocked_task) => f(sched, blocked_task),
-            }
+            f(sched, BlockedTask::block(task))
         }
     }
 

src/libstd/rt/sched.rs

@@ -36,8 +36,6 @@ use rt::logging::StdErrLogger;
 use rt::sched::{Scheduler, SchedHandle};
 use rt::stack::{StackSegment, StackPool};
 use send_str::SendStr;
-use task::LinkedFailure;
-use task::spawn::Taskgroup;
 use unstable::finally::Finally;
 
 // The Task struct represents all state associated with a rust
@@ -52,7 +50,6 @@ pub struct Task {
     storage: LocalStorage,
     logger: Option<StdErrLogger>,
     unwinder: Unwinder,
-    taskgroup: Option<Taskgroup>,
     death: Death,
     destroyed: bool,
     name: Option<SendStr>,
@@ -188,7 +185,6 @@ impl Task {
             storage: LocalStorage(None),
             logger: None,
             unwinder: Unwinder { unwinding: false, cause: None },
-            taskgroup: None,
             death: Death::new(),
             destroyed: false,
             coroutine: Some(Coroutine::empty()),
@@ -223,7 +219,6 @@ impl Task {
             storage: LocalStorage(None),
             logger: None,
             unwinder: Unwinder { unwinding: false, cause: None },
-            taskgroup: None,
             death: Death::new(),
             destroyed: false,
             name: None,
@@ -246,9 +241,7 @@ impl Task {
             storage: LocalStorage(None),
             logger: None,
             unwinder: Unwinder { unwinding: false, cause: None },
-            taskgroup: None,
-            // FIXME(#7544) make watching optional
-            death: self.death.new_child(),
+            death: Death::new(),
             destroyed: false,
             name: None,
             coroutine: Some(Coroutine::new(stack_pool, stack_size, start)),
@@ -333,11 +326,7 @@ impl Task {
         // Cleanup the dynamic borrowck debugging info
         borrowck::clear_task_borrow_list();
 
-        // NB. We pass the taskgroup into death so that it can be dropped while
-        // the unkillable counter is set. This is necessary for when the
-        // taskgroup destruction code drops references on KillHandles, which
-        // might require using unkillable (to synchronize with an unwrapper).
-        self.death.collect_failure(self.unwinder.to_unwind_result(), self.taskgroup.take());
+        self.death.collect_failure(self.unwinder.to_unwind_result());
         self.destroyed = true;
     }
 
@@ -660,10 +649,7 @@ pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> !
                 Some(s) => *s,
                 None => match msg.as_ref::<~str>() {
                     Some(s) => s.as_slice(),
-                    None => match msg.as_ref::<LinkedFailure>() {
-                        Some(*) => "linked failure",
-                        None => "~Any",
-                    }
+                    None => "~Any",
                 }
             };
 
@@ -785,16 +771,6 @@ mod test {
         }
     }
 
-    #[test]
-    fn linked_failure() {
-        do run_in_newsched_task() {
-            let res = do spawntask_try {
-                spawntask_random(|| fail!());
-            };
-            assert!(res.is_err());
-        }
-    }
-
     #[test]
     fn heap_cycles() {
         use option::{Option, Some, None};

src/libstd/rt/task.rs

@@ -21,7 +21,6 @@ use io;
 use libc::{pid_t, c_int};
 use libc;
 use prelude::*;
-use task;
 
 /**
  * A value representing a child process.
@@ -221,21 +220,15 @@ impl Process {
         let ch = SharedChan::new(ch);
         let ch_clone = ch.clone();
 
-        // FIXME(#910, #8674): right now I/O is incredibly brittle when it comes
-        //      to linked failure, so these tasks must be spawn so they're not
-        //      affected by linked failure. If these are removed, then the
-        //      runtime may never exit because linked failure will cause some
-        //      SchedHandle structures to not get destroyed, meaning that
-        //      there's always an async watcher available.
-        do task::spawn_unlinked {
+        do spawn {
             do io::ignore_io_error {
                 match error.take() {
                     Some(ref mut e) => ch.send((2, e.read_to_end())),
                     None => ch.send((2, ~[]))
                 }
             }
         }
-        do task::spawn_unlinked {
+        do spawn {
             do io::ignore_io_error {
                 match output.take() {
                     Some(ref mut e) => ch_clone.send((1, e.read_to_end())),

src/libstd/run.rs

@@ -21,7 +21,6 @@ use rt::local::Local;
 use rt::rtio::EventLoop;
 use rt::sched::Scheduler;
 use rt::shouldnt_be_public::{SelectInner, SelectPortInner};
-use task;
 use unstable::finally::Finally;
 use vec::{OwnedVector, MutableVector};
 
@@ -79,11 +78,10 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint {
             do sched.event_loop.callback { c.take().send_deferred(()) }
         }
     }).finally {
-        let p = Cell::new(p.take());
         // Unkillable is necessary not because getting killed is dangerous here,
         // but to force the recv not to use the same kill-flag that we used for
         // selecting. Otherwise a user-sender could spuriously wakeup us here.
-        do task::unkillable { p.take().recv(); }
+        p.take().recv();
     }
 
     // Task resumes. Now unblock ourselves from all the ports we blocked on.
@@ -230,63 +228,50 @@ mod test {
     }
 
     #[test]
-    fn select_unkillable() {
+    fn select_simple() {
         do run_in_uv_task {
-            do task::unkillable { select_helper(2, [1]) }
+            select_helper(2, [1])
         }
     }
 
     /* blocking select tests */
 
     #[test]
     fn select_blocking() {
-        select_blocking_helper(true);
-        select_blocking_helper(false);
-
-        fn select_blocking_helper(killable: bool) {
-            do run_in_uv_task {
-                let (p1,_c) = oneshot();
-                let (p2,c2) = oneshot();
-                let mut ports = [p1,p2];
-
-                let (p3,c3) = oneshot();
-                let (p4,c4) = oneshot();
-
-                let x = Cell::new((c2, p3, c4));
-                do task::spawn {
-                    let (c2, p3, c4) = x.take();
-                    p3.recv();   // handshake parent
-                    c4.send(()); // normal receive
-                    task::deschedule();
-                    c2.send(()); // select receive
-                }
-
-                // Try to block before child sends on c2.
-                c3.send(());
-                p4.recv();
-                if killable {
-                    assert!(select(ports) == 1);
-                } else {
-                    do task::unkillable { assert!(select(ports) == 1); }
-                }
+        do run_in_uv_task {
+            let (p1,_c) = oneshot();
+            let (p2,c2) = oneshot();
+            let mut ports = [p1,p2];
+
+            let (p3,c3) = oneshot();
+            let (p4,c4) = oneshot();
+
+            let x = Cell::new((c2, p3, c4));
+            do task::spawn {
+                let (c2, p3, c4) = x.take();
+                p3.recv();   // handshake parent
+                c4.send(()); // normal receive
+                task::deschedule();
+                c2.send(()); // select receive
             }
+
+            // Try to block before child sends on c2.
+            c3.send(());
+            p4.recv();
+            assert!(select(ports) == 1);
         }
     }
 
     #[test]
     fn select_racing_senders() {
         static NUM_CHANS: uint = 10;
 
-        select_racing_senders_helper(true,  ~[0,1,2,3,4,5,6,7,8,9]);
-        select_racing_senders_helper(false, ~[0,1,2,3,4,5,6,7,8,9]);
-        select_racing_senders_helper(true,  ~[0,1,2]);
-        select_racing_senders_helper(false, ~[0,1,2]);
-        select_racing_senders_helper(true,  ~[3,4,5,6]);
-        select_racing_senders_helper(false, ~[3,4,5,6]);
-        select_racing_senders_helper(true,  ~[7,8,9]);
-        select_racing_senders_helper(false, ~[7,8,9]);
+        select_racing_senders_helper(~[0,1,2,3,4,5,6,7,8,9]);
+        select_racing_senders_helper(~[0,1,2]);
+        select_racing_senders_helper(~[3,4,5,6]);
+        select_racing_senders_helper(~[7,8,9]);
 
-        fn select_racing_senders_helper(killable: bool, send_on_chans: ~[uint]) {
+        fn select_racing_senders_helper(send_on_chans: ~[uint]) {
             use rt::test::spawntask_random;
 
             do run_in_uv_task {
@@ -307,45 +292,10 @@ mod test {
                             }
                         }
                         // nondeterministic result, but should succeed
-                        if killable {
-                            select(ports);
-                        } else {
-                            do task::unkillable { select(ports); }
-                        }
+                        select(ports);
                     }
                 }
             }
         }
     }
-
-    #[test]
-    fn select_killed() {
-        do run_in_uv_task {
-            let (success_p, success_c) = oneshot::<bool>();
-            let success_c = Cell::new(success_c);
-            do task::try {
-                let success_c = Cell::new(success_c.take());
-                do task::unkillable {
-                    let (p,c) = oneshot();
-                    let c = Cell::new(c);
-                    do task::spawn {
-                        let (dead_ps, dead_cs) = unzip(range(0u, 5).map(|_| oneshot::<()>()));
-                        let mut ports = dead_ps;
-                        select(ports); // should get killed; nothing should leak
-                        c.take().send(()); // must not happen
-                        // Make sure dead_cs doesn't get closed until after select.
-                        let _ = dead_cs;
-                    }
-                    do task::spawn {
-                        fail!(); // should kill sibling awake
-                    }
-
-                    // wait for killed selector to close (NOT send on) its c.
-                    // hope to send 'true'.
-                    success_c.take().send(p.try_recv().is_none());
-                }
-            };
-            assert!(success_p.recv());
-        }
-    }
 }

src/libstd/select.rs

@@ -25,7 +25,7 @@ do || {
 
 use ops::Drop;
 
-#[cfg(test)] use task::{failing, spawn};
+#[cfg(test)] use task::failing;
 
 pub trait Finally<T> {
     fn finally(&self, dtor: ||) -> T;

src/libstd/task/mod.rs

@@ -135,65 +135,63 @@ impl<T: Send> UnsafeArc<T> {
     /// block; otherwise, an unwrapping task can be killed by linked failure.
     pub fn unwrap(self) -> T {
         let this = Cell::new(self); // argh
-        do task::unkillable {
-            unsafe {
-                let mut this = this.take();
-                // The ~ dtor needs to run if this code succeeds.
-                let mut data: ~ArcData<T> = cast::transmute(this.data);
-                // Set up the unwrap protocol.
-                let (p1,c1) = comm::oneshot(); // ()
-                let (p2,c2) = comm::oneshot(); // bool
-                // Try to put our server end in the unwrapper slot.
-                // This needs no barrier -- it's protected by the release barrier on
-                // the xadd, and the acquire+release barrier in the destructor's xadd.
-                if data.unwrapper.fill(~(c1,p2), Relaxed).is_none() {
-                    // Got in. Tell this handle's destructor not to run (we are now it).
-                    this.data = ptr::mut_null();
-                    // Drop our own reference.
-                    let old_count = data.count.fetch_sub(1, Release);
-                    assert!(old_count >= 1);
-                    if old_count == 1 {
-                        // We were the last owner. Can unwrap immediately.
-                        // AtomicOption's destructor will free the server endpoint.
+        unsafe {
+            let mut this = this.take();
+            // The ~ dtor needs to run if this code succeeds.
+            let mut data: ~ArcData<T> = cast::transmute(this.data);
+            // Set up the unwrap protocol.
+            let (p1,c1) = comm::oneshot(); // ()
+            let (p2,c2) = comm::oneshot(); // bool
+            // Try to put our server end in the unwrapper slot.
+            // This needs no barrier -- it's protected by the release barrier on
+            // the xadd, and the acquire+release barrier in the destructor's xadd.
+            if data.unwrapper.fill(~(c1,p2), Relaxed).is_none() {
+                // Got in. Tell this handle's destructor not to run (we are now it).
+                this.data = ptr::mut_null();
+                // Drop our own reference.
+                let old_count = data.count.fetch_sub(1, Release);
+                assert!(old_count >= 1);
+                if old_count == 1 {
+                    // We were the last owner. Can unwrap immediately.
+                    // AtomicOption's destructor will free the server endpoint.
+                    // FIXME(#3224): it should be like this
+                    // let ~ArcData { data: user_data, _ } = data;
+                    // user_data
+                    data.data.take_unwrap()
+                } else {
+                    // The *next* person who sees the refcount hit 0 will wake us.
+                    let p1 = Cell::new(p1); // argh
+                    // Unlike the above one, this cell is necessary. It will get
+                    // taken either in the do block or in the finally block.
+                    let c2_and_data = Cell::new((c2,data));
+                    do (|| {
+                        p1.take().recv();
+                        // Got here. Back in the 'unkillable' without getting killed.
+                        let (c2, data) = c2_and_data.take();
+                        c2.send(true);
                         // FIXME(#3224): it should be like this
                         // let ~ArcData { data: user_data, _ } = data;
                         // user_data
+                        let mut data = data;
                         data.data.take_unwrap()
-                    } else {
-                        // The *next* person who sees the refcount hit 0 will wake us.
-                        let p1 = Cell::new(p1); // argh
-                        // Unlike the above one, this cell is necessary. It will get
-                        // taken either in the do block or in the finally block.
-                        let c2_and_data = Cell::new((c2,data));
-                        do (|| {
-                            do task::rekillable { p1.take().recv(); }
-                            // Got here. Back in the 'unkillable' without getting killed.
+                    }).finally {
+                        if task::failing() {
+                            // Killed during wait. Because this might happen while
+                            // someone else still holds a reference, we can't free
+                            // the data now; the "other" last refcount will free it.
                             let (c2, data) = c2_and_data.take();
-                            c2.send(true);
-                            // FIXME(#3224): it should be like this
-                            // let ~ArcData { data: user_data, _ } = data;
-                            // user_data
-                            let mut data = data;
-                            data.data.take_unwrap()
-                        }).finally {
-                            if task::failing() {
-                                // Killed during wait. Because this might happen while
-                                // someone else still holds a reference, we can't free
-                                // the data now; the "other" last refcount will free it.
-                                let (c2, data) = c2_and_data.take();
-                                c2.send(false);
-                                cast::forget(data);
-                            } else {
-                                assert!(c2_and_data.is_empty());
-                            }
+                            c2.send(false);
+                            cast::forget(data);
+                        } else {
+                            assert!(c2_and_data.is_empty());
                         }
                     }
-                } else {
-                    // If 'put' returns the server end back to us, we were rejected;
-                    // someone else was trying to unwrap. Avoid guaranteed deadlock.
-                    cast::forget(data);
-                    fail!("Another task is already unwrapping this Arc!");
                 }
+            } else {
+                // If 'put' returns the server end back to us, we were rejected;
+                // someone else was trying to unwrap. Avoid guaranteed deadlock.
+                cast::forget(data);
+                fail!("Another task is already unwrapping this Arc!");
             }
         }
     }
@@ -259,17 +257,15 @@ impl<T> Drop for UnsafeArc<T>{
                 match data.unwrapper.take(Acquire) {
                     Some(~(message,response)) => {
                         let cell = Cell::new((message, response, data));
-                        do task::unkillable {
-                            let (message, response, data) = cell.take();
-                            // Send 'ready' and wait for a response.
-                            message.send(());
-                            // Unkillable wait. Message guaranteed to come.
-                            if response.recv() {
-                                // Other task got the data.
-                                cast::forget(data);
-                            } else {
-                                // Other task was killed. drop glue takes over.
-                            }
+                        let (message, response, data) = cell.take();
+                        // Send 'ready' and wait for a response.
+                        message.send(());
+                        // Unkillable wait. Message guaranteed to come.
+                        if response.recv() {
+                            // Other task got the data.
+                            cast::forget(data);
+                        } else {
+                            // Other task was killed. drop glue takes over.
                         }
                     }
                     None => {
@@ -678,24 +674,4 @@ mod tests {
         assert!(x.unwrap() == ~~"hello");
         assert!(res.recv().is_ok());
     }
-
-    #[test]
-    fn exclusive_new_unwrap_deadlock() {
-        // This is not guaranteed to get to the deadlock before being killed,
-        // but it will show up sometimes, and if the deadlock were not there,
-        // the test would nondeterministically fail.
-        let result = do task::try {
-            // a task that has two references to the same Exclusive::new will
-            // deadlock when it unwraps. nothing to be done about that.
-            let x = Exclusive::new(~~"hello");
-            let x2 = x.clone();
-            do task::spawn {
-                do 10.times { task::deschedule(); } // try to let the unwrapper go
-                fail!(); // punt it awake from its deadlock
-            }
-            let _z = x.unwrap();
-            unsafe { do x2.with |_hello| { } }
-        };
-        assert!(result.is_err());
-    }
 }

src/libstd/task/spawn.rs

@@ -179,9 +179,9 @@ fn main() {
 
         let (from_parent, to_child) = comm::stream();
 
-        do task::spawn_with(from_parent) |from_parent| {
+        do spawn {
             make_sequence_processor(sz, &from_parent, &to_parent_);
-        };
+        }
 
         to_child
     }.collect::<~[Chan<~[u8]>]>();

src/libstd/unstable/finally.rs

@@ -28,7 +28,7 @@ fn child_generation(gens_left: uint, c: comm::Chan<()>) {
     // With this code, only as many generations are alive at a time as tasks
     // alive at a time,
     let c = Cell::new(c);
-    do task::spawn_supervised {
+    do spawn {
         let c = c.take();
         if gens_left & 1 == 1 {
             task::deschedule(); // shake things up a bit

src/libstd/unstable/sync.rs

@@ -1,4 +1,5 @@
 // xfail-pretty
+// xfail-test linked failure
 
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
@@ -35,8 +36,6 @@ fn grandchild_group(num_tasks: uint) {
     for _ in range(0, num_tasks) {
         let ch = ch.clone();
         let mut t = task::task();
-        t.linked();
-        t.unwatched();
         do t.spawn { // linked
             ch.send(());
             let (p, _c) = stream::<()>();

src/test/bench/shootout-k-nucleotide-pipes.rs

@@ -10,8 +10,11 @@
 
 // error-pattern:task '<unnamed>' failed at 'test'
 
+use std::task;
+
 fn main() {
-    do spawn {
+    do task::try {
         fail!("test");
-    }
+        1
+    }.unwrap()
 }

src/test/bench/task-perf-jargon-metal-smoke.rs

@@ -10,10 +10,13 @@
 
 // error-pattern:task 'owned name' failed at 'test'
 
+use std::task;
+
 fn main() {
-    let mut t = ::std::task::task();
+    let mut t = task::task();
     t.name(~"owned name");
-    do t.spawn {
+    do t.try {
         fail!("test");
-    }
+        1
+    }.unwrap()
 }

src/test/bench/task-perf-linked-failure.rs

@@ -13,7 +13,8 @@
 fn main() {
     let mut t = ::std::task::task();
     t.name("send name".to_send_str());
-    do t.spawn {
+    do t.try {
         fail!("test");
-    }
+        3
+    }.unwrap()
 }

src/test/run-fail/fail-task-name-none.rs

@@ -13,7 +13,7 @@
 fn main() {
     let mut t = ::std::task::task();
     t.name("static name");
-    do t.spawn {
+    do t.try {
         fail!("test");
-    }
+    }.unwrap()
 }

src/test/run-fail/fail-task-name-owned.rs

@@ -15,7 +15,7 @@ use std::task;
 fn main() {
     // the purpose of this test is to make sure that task::spawn()
     // works when provided with a bare function:
-    task::spawn(startfn);
+    task::try(startfn).unwrap();
 }
 
 fn startfn() {

src/test/run-fail/fail-task-name-send-str.rs

@@ -18,5 +18,5 @@ fn f() {
 }
 
 pub fn main() {
-    task::spawn_unlinked(f);
+    task::spawn(f);
 }

src/test/run-fail/fail-task-name-static.rs

@@ -42,7 +42,7 @@ fn f(c: SharedChan<bool>) {
 pub fn main() {
     let (p, c) = stream();
     let c = SharedChan::new(c);
-    task::spawn_unlinked(|| f(c.clone()) );
+    task::spawn(|| f(c.clone()) );
     error!("hiiiiiiiii");
     assert!(p.recv());
 }

src/test/run-fail/task-spawn-barefn.rs

@@ -35,5 +35,5 @@ fn f() {
 }
 
 pub fn main() {
-    task::spawn_unlinked(f);
+    task::spawn(f);
 }

src/test/run-pass/unwind-box.rs

@@ -18,5 +18,5 @@ fn f() {
 }
 
 pub fn main() {
-    task::spawn_unlinked(f);
+    task::spawn(f);
 }