nptl/pthread_mutex_init.c

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