nptl/pthread_mutex_setprioceiling.c

   1 /* Set current priority ceiling of pthread_mutex_t.
   2    Copyright (C) 2006-2021 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2006.
   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    <https://www.gnu.org/licenses/>.  */
  19
  20 #include <stdbool.h>
  21 #include <errno.h>
  22 #include <pthreadP.h>
  23 #include <atomic.h>
  24 #include <futex-internal.h>
  25 #include <shlib-compat.h>
  26
  27 int
  28 __pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prioceiling,
  29                                 int *old_ceiling)
  30 {
  31   /* See concurrency notes regarding __kind in struct __pthread_mutex_s
  32      in sysdeps/nptl/bits/thread-shared-types.h.  */
  33   if ((atomic_load_relaxed (&(mutex->__data.__kind))
  34        & PTHREAD_MUTEX_PRIO_PROTECT_NP) == 0)
  35     return EINVAL;
  36
  37   /* See __init_sched_fifo_prio.  */
  38   if (atomic_load_relaxed (&__sched_fifo_min_prio) == -1
  39       || atomic_load_relaxed (&__sched_fifo_max_prio) == -1)
  40     __init_sched_fifo_prio ();
  41
  42   if (__glibc_unlikely (prioceiling
  43                         < atomic_load_relaxed (&__sched_fifo_min_prio))
  44       || __glibc_unlikely (prioceiling
  45                            > atomic_load_relaxed (&__sched_fifo_max_prio))
  46       || __glibc_unlikely ((prioceiling
  47                             & (PTHREAD_MUTEXATTR_PRIO_CEILING_MASK
  48                                >> PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT))
  49                            != prioceiling))
  50     return EINVAL;
  51
  52   /* Check whether we already hold the mutex.  */
  53   bool locked = false;
  54   int kind = PTHREAD_MUTEX_TYPE (mutex);
  55   if (mutex->__data.__owner == THREAD_GETMEM (THREAD_SELF, tid))
  56     {
  57       if (kind == PTHREAD_MUTEX_PP_ERRORCHECK_NP)
  58         return EDEADLK;
  59
  60       if (kind == PTHREAD_MUTEX_PP_RECURSIVE_NP)
  61         locked = true;
  62     }
  63
  64   int oldval = mutex->__data.__lock;
  65   if (! locked)
  66     do
  67       {
  68         /* Need to lock the mutex, but without obeying the priority
  69            protect protocol.  */
  70         int ceilval = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK);
  71
  72         oldval = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
  73                                                       ceilval | 1, ceilval);
  74         if (oldval == ceilval)
  75           break;
  76
  77         do
  78           {
  79             oldval
  80               = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
  81                                                      ceilval | 2,
  82                                                      ceilval | 1);
  83
  84             if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
  85               break;
  86
  87             if (oldval != ceilval)
  88               futex_wait ((unsigned int *) &mutex->__data.__lock, ceilval | 2,
  89                           PTHREAD_MUTEX_PSHARED (mutex));
  90           }
  91         while (atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
  92                                                     ceilval | 2, ceilval)
  93                != ceilval);
  94
  95         if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
  96           continue;
  97       }
  98     while (0);
  99
 100   int oldprio = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
 101                 >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 102   if (locked)
 103     {
 104       int ret = __pthread_tpp_change_priority (oldprio, prioceiling);
 105       if (ret)
 106         return ret;
 107     }
 108
 109   if (old_ceiling != NULL)
 110     *old_ceiling = oldprio;
 111
 112   int newlock = 0;
 113   if (locked)
 114     newlock = (mutex->__data.__lock & ~PTHREAD_MUTEX_PRIO_CEILING_MASK);
 115   mutex->__data.__lock = newlock
 116                          | (prioceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT);
 117   atomic_full_barrier ();
 118
 119   futex_wake ((unsigned int *)&mutex->__data.__lock, INT_MAX,
 120               PTHREAD_MUTEX_PSHARED (mutex));
 121
 122   return 0;
 123 }
 124 versioned_symbol (libc, __pthread_mutex_setprioceiling,
 125                   pthread_mutex_setprioceiling, GLIBC_2_34);
 126
 127 #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_4, GLIBC_2_34)
 128 compat_symbol (libpthread, __pthread_mutex_setprioceiling,
 129                pthread_mutex_setprioceiling, GLIBC_2_4);
 130 #endif