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       break;
  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       break;
  52
  53     case PTHREAD_MUTEX_TIMED_NP:
  54     case PTHREAD_MUTEX_ADAPTIVE_NP:
  55       /* Normal mutex.  Nothing special to do.  */
  56       break;
  57
  58     case PTHREAD_MUTEX_ROBUST_PRIVATE_RECURSIVE_NP:
  59       /* Recursive mutex.  */
  60       if (mutex->__data.__owner == -THREAD_GETMEM (THREAD_SELF, tid))
  61         {
  62           if (--mutex->__data.__count != 0)
  63             /* We still hold the mutex.  */
  64             return ENOTRECOVERABLE;
  65
  66           goto notrecoverable;
  67         }
  68
  69       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
  70         return EPERM;
  71
  72       if (--mutex->__data.__count != 0)
  73         /* We still hold the mutex.  */
  74         return 0;
  75
  76       goto robust;
  77
  78     case PTHREAD_MUTEX_ROBUST_PRIVATE_ERRORCHECK_NP:
  79     case PTHREAD_MUTEX_ROBUST_PRIVATE_NP:
  80     case PTHREAD_MUTEX_ROBUST_PRIVATE_ADAPTIVE_NP:
  81       if (abs (mutex->__data.__owner) != THREAD_GETMEM (THREAD_SELF, tid)
  82           || ! lll_mutex_islocked (mutex->__data.__lock))
  83         return EPERM;
  84
  85       /* If the previous owner died and the caller did not succeed in
  86          making the state consistent, mark the mutex as unrecoverable
  87          and make all waiters.  */
  88       if (__builtin_expect (mutex->__data.__owner
  89                             == -THREAD_GETMEM (THREAD_SELF, tid)
  90                             || (mutex->__data.__owner
  91                                 == PTHREAD_MUTEX_NOTRECOVERABLE), 0))
  92       notrecoverable:
  93         newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
  94
  95     robust:
  96       /* Remove mutex from the list.  */
  97       DEQUEUE_MUTEX (mutex);
  98       break;
  99
 100     default:
 101       /* Correct code cannot set any other type.  */
 102       return EINVAL;
 103     }
 104
 105   /* Always reset the owner field.  */
 106   mutex->__data.__owner = newowner;
 107   if (decr)
 108     /* One less user.  */
 109     --mutex->__data.__nusers;
 110
 111   /* Unlock.  */
 112   lll_mutex_unlock (mutex->__data.__lock);
 113
 114   return 0;
 115 }
 116
 117
 118 int
 119 __pthread_mutex_unlock (mutex)
 120      pthread_mutex_t *mutex;
 121 {
 122   return __pthread_mutex_unlock_usercnt (mutex, 1);
 123 }
 124 strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
 125 strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)