---

yaml
---
r: 110534
b: refs/heads/master
c: dc49018
h: refs/heads/master
v: v3

Author: radford

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e415c25bcd81dc1f9a5a3d25d9b48ed2d545336b
+refs/heads/master: dc49018679e75e8641c8a8bb295075ec5f247d99
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: e263ef1df7b892ed29e53313565eb05ab75e52f4
 refs/heads/try: 597a645456b55e1c886ce15d23a192abdf4d55cf

trunk/src/libnative/io/process.rs

@@ -524,37 +524,7 @@ fn spawn_process_os(config: p::ProcessConfig,
                     Ok(..) => fail!("short read on the cloexec pipe"),
                 };
             }
-            // And at this point we've reached a special time in the life of the
-            // child. The child must now be considered hamstrung and unable to
-            // do anything other than syscalls really. Consider the following
-            // scenario:
-            //
-            //      1. Thread A of process 1 grabs the malloc() mutex
-            //      2. Thread B of process 1 forks(), creating thread C
-            //      3. Thread C of process 2 then attempts to malloc()
-            //      4. The memory of process 2 is the same as the memory of
-            //         process 1, so the mutex is locked.
-            //
-            // This situation looks a lot like deadlock, right? It turns out
-            // that this is what pthread_atfork() takes care of, which is
-            // presumably implemented across platforms. The first thing that
-            // threads to *before* forking is to do things like grab the malloc
-            // mutex, and then after the fork they unlock it.
-            //
-            // Despite this information, libnative's spawn has been witnessed to
-            // deadlock on both OSX and FreeBSD. I'm not entirely sure why, but
-            // all collected backtraces point at malloc/free traffic in the
-            // child spawned process.
-            //
-            // For this reason, the block of code below should contain 0
-            // invocations of either malloc of free (or their related friends).
-            //
-            // As an example of not having malloc/free traffic, we don't close
-            // this file descriptor by dropping the FileDesc (which contains an
-            // allocation). Instead we just close it manually. This will never
-            // have the drop glue anyway because this code never returns (the
-            // child will either exec() or invoke libc::exit)
-            let _ = libc::close(input.fd());
+            drop(input);
 
             fn fail(output: &mut file::FileDesc) -> ! {
                 let errno = os::errno();

trunk/src/libsync/arc.rs

@@ -124,12 +124,10 @@ impl<T: Share + Send> Clone for Arc<T> {
     }
 }
 
-// FIXME(#13042): this should have T: Send, and use self.inner()
-impl<T> Deref<T> for Arc<T> {
+impl<T: Send + Share> Deref<T> for Arc<T> {
     #[inline]
     fn deref<'a>(&'a self) -> &'a T {
-        let inner = unsafe { &*self.x };
-        &inner.data
+        &self.inner().data
     }
 }
 

trunk/src/libsync/lock.rs

@@ -231,11 +231,10 @@ impl<T: Send> Mutex<T> {
     }
 }
 
-// FIXME(#13042): these should both have T: Send
-impl<'a, T> Deref<T> for MutexGuard<'a, T> {
+impl<'a, T: Send> Deref<T> for MutexGuard<'a, T> {
     fn deref<'a>(&'a self) -> &'a T { &*self.data }
 }
-impl<'a, T> DerefMut<T> for MutexGuard<'a, T> {
+impl<'a, T: Send> DerefMut<T> for MutexGuard<'a, T> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut T { &mut *self.data }
 }
 
@@ -363,14 +362,13 @@ impl<'a, T: Send + Share> RWLockWriteGuard<'a, T> {
     }
 }
 
-// FIXME(#13042): these should all have T: Send + Share
-impl<'a, T> Deref<T> for RWLockReadGuard<'a, T> {
+impl<'a, T: Send + Share> Deref<T> for RWLockReadGuard<'a, T> {
     fn deref<'a>(&'a self) -> &'a T { self.data }
 }
-impl<'a, T> Deref<T> for RWLockWriteGuard<'a, T> {
+impl<'a, T: Send + Share> Deref<T> for RWLockWriteGuard<'a, T> {
     fn deref<'a>(&'a self) -> &'a T { &*self.data }
 }
-impl<'a, T> DerefMut<T> for RWLockWriteGuard<'a, T> {
+impl<'a, T: Send + Share> DerefMut<T> for RWLockWriteGuard<'a, T> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut T { &mut *self.data }
 }