---

yaml
---
r: 148731
b: refs/heads/try2
c: 431edac
h: refs/heads/master
i:
  148729: 934189a
  148727: 72405aa
v: v3

Author: bnoordhuis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: b02b5cdcf42b4fe6b1e3ebe56ad0cd43fd907489
+refs/heads/try2: 431edacbef23e691d1b192da78b4112c35addfbf
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rt/thread.rs

@@ -221,7 +221,7 @@ mod imp {
                                                PTHREAD_CREATE_JOINABLE), 0);
 
         // Reserve room for the red zone, the runtime's stack of last resort.
-        let stack_size = cmp::max(stack, RED_ZONE + PTHREAD_STACK_MIN as uint);
+        let stack_size = cmp::max(stack, RED_ZONE + __pthread_get_minstack(&attr) as uint);
         match pthread_attr_setstacksize(&mut attr, stack_size as libc::size_t) {
             0 => {
             },
@@ -261,6 +261,51 @@ mod imp {
     #[cfg(not(target_os = "macos"), not(target_os = "android"))]
     pub unsafe fn yield_now() { assert_eq!(pthread_yield(), 0); }
 
+    #[cfg(not(target_os = "linux"))]
+    unsafe fn __pthread_get_minstack(_: *libc::pthread_attr_t) -> libc::size_t {
+        libc::PTHREAD_STACK_MIN
+    }
+
+    // glibc >= 2.15 has a __pthread_get_minstack() function that returns
+    // PTHREAD_STACK_MIN plus however many bytes are needed for thread-local
+    // storage.  We need that information to avoid blowing up when a small stack
+    // is created in an application with big thread-local storage requirements.
+    // See #6233 for rationale and details.
+    //
+    // Dynamically resolve the symbol for compatibility with older versions
+    // of glibc.  Assumes that we've been dynamically linked to libpthread
+    // but that is currently always the case.  Note that this means we take
+    // a dlopen/dlsym/dlclose hit for every new thread.  Mitigating that by
+    // caching the symbol or the function's return value has its drawbacks:
+    //
+    //  * Caching the symbol breaks when libpthread.so is reloaded because
+    //    its address changes.
+    //
+    //  * Caching the return value assumes that it's a fixed quantity.
+    //    Not very future-proof and untrue in the presence of guard pages
+    //    The reason __pthread_get_minstack() takes a *libc::pthread_attr_t
+    //    as its argument is because it takes pthread_attr_setguardsize() into
+    //    account.
+    //
+    // A better solution is to define __pthread_get_minstack() as a weak symbol
+    // but there is currently no way to express that in Rust code.
+    #[cfg(target_os = "linux")]
+    unsafe fn __pthread_get_minstack(attr: *libc::pthread_attr_t) -> libc::size_t {
+        use option::None;
+        use result::{Err, Ok};
+        use unstable::dynamic_lib;
+        match dynamic_lib::DynamicLibrary::open(None) {
+            Err(err) => fail!("DynamicLibrary::open(): {}", err),
+            Ok(handle) => {
+                match handle.symbol::<extern "C" fn(*libc::pthread_attr_t) ->
+                                     libc::size_t>("__pthread_get_minstack") {
+                    Err(_) => libc::PTHREAD_STACK_MIN,
+                    Ok(__pthread_get_minstack) => __pthread_get_minstack(attr),
+                }
+            }
+        }
+    }
+
     extern {
         fn pthread_create(native: *mut libc::pthread_t,
                           attr: *libc::pthread_attr_t,