nptl/pthread_mutex_unlock.c

   1 /* Copyright (C) 2002, 2003, 2005, 2006 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include "pthreadP.h"
  23 #include <lowlevellock.h>
  24
  25
  26 int
  27 internal_function attribute_hidden
  28 __pthread_mutex_unlock_usercnt (mutex, decr)
  29      pthread_mutex_t *mutex;
  30      int decr;
  31 {
  32   int newowner = 0;
  33
  34   switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
  35     {
  36     case PTHREAD_MUTEX_RECURSIVE_NP:
  37       /* Recursive mutex.  */
  38       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
  39         return EPERM;
  40
  41       if (--mutex->__data.__count != 0)
  42         /* We still hold the mutex.  */
  43         return 0;
  44       goto normal;
  45
  46     case PTHREAD_MUTEX_ERRORCHECK_NP:
  47       /* Error checking mutex.  */
  48       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
  49           || ! lll_mutex_islocked (mutex->__data.__lock))
  50         return EPERM;
  51       /* FALLTHROUGH */
  52
  53     case PTHREAD_MUTEX_TIMED_NP:
  54     case PTHREAD_MUTEX_ADAPTIVE_NP:
  55       /* Always reset the owner field.  */
  56     normal:
  57       mutex->__data.__owner = 0;
  58       if (decr)
  59         /* One less user.  */
  60         --mutex->__data.__nusers;
  61
  62       /* Unlock.  */
  63       lll_mutex_unlock (mutex->__data.__lock);
  64       break;
  65
  66     case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
  67       /* Recursive mutex.  */
  68       if ((mutex->__data.__lock & FUTEX_TID_MASK)
  69           == THREAD_GETMEM (THREAD_SELF, tid)
  70           && __builtin_expect (mutex->__data.__owner
  71                                == PTHREAD_MUTEX_INCONSISTENT, 0))
  72         {
  73           if (--mutex->__data.__count != 0)
  74             /* We still hold the mutex.  */
  75             return ENOTRECOVERABLE;
  76
  77           goto notrecoverable;
  78         }
  79
  80       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
  81         return EPERM;
  82
  83       if (--mutex->__data.__count != 0)
  84         /* We still hold the mutex.  */
  85         return 0;
  86
  87       goto robust;
  88
  89     case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
  90     case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
  91     case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
  92       if ((mutex->__data.__lock & FUTEX_TID_MASK)
  93           != THREAD_GETMEM (THREAD_SELF, tid)
  94           || ! lll_mutex_islocked (mutex->__data.__lock))
  95         return EPERM;
  96
  97       /* If the previous owner died and the caller did not succeed in
  98          making the state consistent, mark the mutex as unrecoverable
  99          and make all waiters.  */
 100       if (__builtin_expect (mutex->__data.__owner
 101                             == PTHREAD_MUTEX_INCONSISTENT, 0))
 102       notrecoverable:
 103         newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
 104
 105     robust:
 106       /* Remove mutex from the list.  */
 107       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 108                      &mutex->__data.__list.__next);
 109       DEQUEUE_MUTEX (mutex);
 110
 111       mutex->__data.__owner = newowner;
 112       if (decr)
 113         /* One less user.  */
 114         --mutex->__data.__nusers;
 115
 116       /* Unlock.  */
 117       lll_robust_mutex_unlock (mutex->__data.__lock);
 118
 119       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 120       break;
 121
 122     default:
 123       /* Correct code cannot set any other type.  */
 124       return EINVAL;
 125     }
 126
 127   return 0;
 128 }
 129
 130
 131 int
 132 __pthread_mutex_unlock (mutex)
 133      pthread_mutex_t *mutex;
 134 {
 135   return __pthread_mutex_unlock_usercnt (mutex, 1);
 136 }
 137 strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
 138 strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)