Adapt upstream patches fixing potential deadlock in tcmalloc after fork.

third_party/tcmalloc/chromium/src/maybe_threads.cc

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 29 matching lines @@
 #include <assert.h>
 #include <string.h>    // for memcmp
 #include <stdio.h>     // for __isthreaded on FreeBSD
 // We don't actually need strings. But including this header seems to
 // stop the compiler trying to short-circuit our pthreads existence
 // tests and claiming that the address of a function is always
 // non-zero. I have no idea why ...
 #include <string>
 #include "maybe_threads.h"
 #include "base/basictypes.h"
+#include "base/logging.h"
 
 // __THROW is defined in glibc systems.  It means, counter-intuitively,
 // "This function will never throw an exception."  It's an optional
 // optimization tool, but we may need to use it to match glibc prototypes.
 #ifndef __THROW    // I guess we're not on a glibc system
 # define __THROW   // __THROW is just an optimization, so ok to make it ""
 #endif
 
 // These are the methods we're going to conditionally include.
 extern "C" {
   int pthread_key_create (pthread_key_t*, void (*)(void*))
       __THROW ATTRIBUTE_WEAK;
   void *pthread_getspecific(pthread_key_t)
       __THROW ATTRIBUTE_WEAK;
   int pthread_setspecific(pthread_key_t, const void*)
       __THROW ATTRIBUTE_WEAK;
   int pthread_once(pthread_once_t *, void (*)(void))
       ATTRIBUTE_WEAK;
+  int pthread_atfork(void (*__prepare) (void),
+                     void (*__parent) (void),
+                     void (*__child) (void))
+    __THROW ATTRIBUTE_WEAK;
 }
 
 #define MAX_PERTHREAD_VALS 16
 static void *perftools_pthread_specific_vals[MAX_PERTHREAD_VALS];
 static int next_key;
 
 int perftools_pthread_key_create(pthread_key_t *key,
                                  void (*destr_function) (void *)) {
   if (pthread_key_create) {
     return pthread_key_create(key, destr_function);
@@ skipping 50 matching lines @@
     return pthread_once(ctl, init_routine);
   } else {
     if (memcmp(ctl, &pthread_once_init, sizeof(*ctl)) == 0) {
       init_routine();
       ++*(char*)(ctl);        // make it so it's no longer equal to init
     }
     return 0;
   }
 #endif
 }
+
+void perftools_pthread_atfork(void (*before)(),
+                              void (*parent_after)(),
+                              void (*child_after)()) {
+  if (pthread_atfork) {
+    int rv = pthread_atfork(before, parent_after, child_after);
+    CHECK(rv == 0);
+  }
+}