Add per-thread cache to malloc

[thirdparty/glibc.git] / nptl / pthread_mutex_init.c

diff --git a/nptl/pthread_mutex_init.c b/nptl/pthread_mutex_init.c
index a013ca83fefd753e497c80a9898a8f00207f9648..6f2fc808ff1b140af98b197bf241eb3ec8866b2a 100644 (file)
--- a/nptl/pthread_mutex_init.c
+++ b/nptl/pthread_mutex_init.c
@@ -1,5 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
-   Free Software Foundation, Inc.
+/* Copyright (C) 2002-2017 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -14,37 +13,54 @@
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
 
 #include <assert.h>
 #include <errno.h>
+#include <stdbool.h>
 #include <string.h>
+#include <kernel-features.h>
 #include "pthreadP.h"
+#include <atomic.h>
 
-static const struct pthread_mutexattr default_attr =
+#include <stap-probe.h>
+
+static const struct pthread_mutexattr default_mutexattr =
   {
     /* Default is a normal mutex, not shared between processes.  */
     .mutexkind = PTHREAD_MUTEX_NORMAL
   };
 
 
-#ifndef __ASSUME_FUTEX_LOCK_PI
-static int tpi_supported;
+static bool
+prio_inherit_missing (void)
+{
+#ifdef __NR_futex
+  static int tpi_supported;
+  if (__glibc_unlikely (tpi_supported == 0))
+    {
+      int lock = 0;
+      INTERNAL_SYSCALL_DECL (err);
+      int ret = INTERNAL_SYSCALL (futex, err, 4, &lock, FUTEX_UNLOCK_PI, 0, 0);
+      assert (INTERNAL_SYSCALL_ERROR_P (ret, err));
+      tpi_supported = INTERNAL_SYSCALL_ERRNO (ret, err) == ENOSYS ? -1 : 1;
+    }
+  return __glibc_unlikely (tpi_supported < 0);
 #endif
-
+  return true;
+}
 
 int
-__pthread_mutex_init (mutex, mutexattr)
-     pthread_mutex_t *mutex;
-     const pthread_mutexattr_t *mutexattr;
+__pthread_mutex_init (pthread_mutex_t *mutex,
+                     const pthread_mutexattr_t *mutexattr)
 {
   const struct pthread_mutexattr *imutexattr;
 
   assert (sizeof (pthread_mutex_t) <= __SIZEOF_PTHREAD_MUTEX_T);
 
-  imutexattr = (const struct pthread_mutexattr *) mutexattr ?: &default_attr;
+  imutexattr = ((const struct pthread_mutexattr *) mutexattr
+               ?: &default_mutexattr);
 
   /* Sanity checks.  */
   switch (__builtin_expect (imutexattr->mutexkind
@@ -56,19 +72,8 @@ __pthread_mutex_init (mutex, mutexattr)
       break;
 
     case PTHREAD_PRIO_INHERIT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
-#ifndef __ASSUME_FUTEX_LOCK_PI
-      if (__builtin_expect (tpi_supported == 0, 0))
-       {
-         int lock = 0;
-         INTERNAL_SYSCALL_DECL (err);
-         int ret = INTERNAL_SYSCALL (futex, err, 4, &lock, FUTEX_UNLOCK_PI,
-                                     0, 0);
-         assert (INTERNAL_SYSCALL_ERROR_P (ret, err));
-         tpi_supported = INTERNAL_SYSCALL_ERRNO (ret, err) == ENOSYS ? -1 : 1;
-       }
-      if (__builtin_expect (tpi_supported < 0, 0))
+      if (__glibc_unlikely (prio_inherit_missing ()))
        return ENOTSUP;
-#endif
       break;
 
     default:
@@ -109,10 +114,11 @@ __pthread_mutex_init (mutex, mutexattr)
                    >> PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT;
       if (! ceiling)
        {
-         if (__sched_fifo_min_prio == -1)
+         /* See __init_sched_fifo_prio.  */
+         if (atomic_load_relaxed (&__sched_fifo_min_prio) == -1)
            __init_sched_fifo_prio ();
-         if (ceiling < __sched_fifo_min_prio)
-           ceiling = __sched_fifo_min_prio;
+         if (ceiling < atomic_load_relaxed (&__sched_fifo_min_prio))
+           ceiling = atomic_load_relaxed (&__sched_fifo_min_prio);
        }
       mutex->__data.__lock = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
       break;
@@ -134,7 +140,9 @@ __pthread_mutex_init (mutex, mutexattr)
   // mutex->__spins = 0;       already done by memset
   // mutex->__next = NULL;     already done by memset
 
+  LIBC_PROBE (mutex_init, 1, mutex);
+
   return 0;
 }
-strong_alias (__pthread_mutex_init, pthread_mutex_init)
-INTDEF(__pthread_mutex_init)
+weak_alias (__pthread_mutex_init, pthread_mutex_init)
+hidden_def (__pthread_mutex_init)