nptl/pthread_mutex_init.c

   1 /* Copyright (C) 2002-2014 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <kernel-features.h>
  23 #include "pthreadP.h"
  24
  25 #include <stap-probe.h>
  26
  27 static const struct pthread_mutexattr default_mutexattr =
  28   {
  29     /* Default is a normal mutex, not shared between processes.  */
  30     .mutexkind = PTHREAD_MUTEX_NORMAL
  31   };
  32
  33
  34 #ifndef __ASSUME_FUTEX_LOCK_PI
  35 static int tpi_supported;
  36 #endif
  37
  38
  39 int
  40 __pthread_mutex_init (mutex, mutexattr)
  41      pthread_mutex_t *mutex;
  42      const pthread_mutexattr_t *mutexattr;
  43 {
  44   const struct pthread_mutexattr *imutexattr;
  45
  46   assert (sizeof (pthread_mutex_t) <= __SIZEOF_PTHREAD_MUTEX_T);
  47
  48   imutexattr = ((const struct pthread_mutexattr *) mutexattr
  49                 ?: &default_mutexattr);
  50
  51   /* Sanity checks.  */
  52   switch (__builtin_expect (imutexattr->mutexkind
  53                             & PTHREAD_MUTEXATTR_PROTOCOL_MASK,
  54                             PTHREAD_PRIO_NONE
  55                             << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT))
  56     {
  57     case PTHREAD_PRIO_NONE << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
  58       break;
  59
  60     case PTHREAD_PRIO_INHERIT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
  61 #ifndef __ASSUME_FUTEX_LOCK_PI
  62       if (__glibc_unlikely (tpi_supported == 0))
  63         {
  64           int lock = 0;
  65           INTERNAL_SYSCALL_DECL (err);
  66           int ret = INTERNAL_SYSCALL (futex, err, 4, &lock, FUTEX_UNLOCK_PI,
  67                                       0, 0);
  68           assert (INTERNAL_SYSCALL_ERROR_P (ret, err));
  69           tpi_supported = INTERNAL_SYSCALL_ERRNO (ret, err) == ENOSYS ? -1 : 1;
  70         }
  71       if (__glibc_unlikely (tpi_supported < 0))
  72         return ENOTSUP;
  73 #endif
  74       break;
  75
  76     default:
  77       /* XXX: For now we don't support robust priority protected mutexes.  */
  78       if (imutexattr->mutexkind & PTHREAD_MUTEXATTR_FLAG_ROBUST)
  79         return ENOTSUP;
  80       break;
  81     }
  82
  83   /* Clear the whole variable.  */
  84   memset (mutex, '\0', __SIZEOF_PTHREAD_MUTEX_T);
  85
  86   /* Copy the values from the attribute.  */
  87   mutex->__data.__kind = imutexattr->mutexkind & ~PTHREAD_MUTEXATTR_FLAG_BITS;
  88
  89   if ((imutexattr->mutexkind & PTHREAD_MUTEXATTR_FLAG_ROBUST) != 0)
  90     {
  91 #ifndef __ASSUME_SET_ROBUST_LIST
  92       if ((imutexattr->mutexkind & PTHREAD_MUTEXATTR_FLAG_PSHARED) != 0
  93           && __set_robust_list_avail < 0)
  94         return ENOTSUP;
  95 #endif
  96
  97       mutex->__data.__kind |= PTHREAD_MUTEX_ROBUST_NORMAL_NP;
  98     }
  99
 100   switch (imutexattr->mutexkind & PTHREAD_MUTEXATTR_PROTOCOL_MASK)
 101     {
 102     case PTHREAD_PRIO_INHERIT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
 103       mutex->__data.__kind |= PTHREAD_MUTEX_PRIO_INHERIT_NP;
 104       break;
 105
 106     case PTHREAD_PRIO_PROTECT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
 107       mutex->__data.__kind |= PTHREAD_MUTEX_PRIO_PROTECT_NP;
 108
 109       int ceiling = (imutexattr->mutexkind
 110                      & PTHREAD_MUTEXATTR_PRIO_CEILING_MASK)
 111                     >> PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT;
 112       if (! ceiling)
 113         {
 114           if (__sched_fifo_min_prio == -1)
 115             __init_sched_fifo_prio ();
 116           if (ceiling < __sched_fifo_min_prio)
 117             ceiling = __sched_fifo_min_prio;
 118         }
 119       mutex->__data.__lock = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 120       break;
 121
 122     default:
 123       break;
 124     }
 125
 126   /* The kernel when waking robust mutexes on exit never uses
 127      FUTEX_PRIVATE_FLAG FUTEX_WAKE.  */
 128   if ((imutexattr->mutexkind & (PTHREAD_MUTEXATTR_FLAG_PSHARED
 129                                 | PTHREAD_MUTEXATTR_FLAG_ROBUST)) != 0)
 130     mutex->__data.__kind |= PTHREAD_MUTEX_PSHARED_BIT;
 131
 132   /* Default values: mutex not used yet.  */
 133   // mutex->__count = 0;        already done by memset
 134   // mutex->__owner = 0;        already done by memset
 135   // mutex->__nusers = 0;       already done by memset
 136   // mutex->__spins = 0;        already done by memset
 137   // mutex->__next = NULL;      already done by memset
 138
 139   LIBC_PROBE (mutex_init, 1, mutex);
 140
 141   return 0;
 142 }
 143 strong_alias (__pthread_mutex_init, pthread_mutex_init)
 144 hidden_def (__pthread_mutex_init)