nptl/pthread_mutex_unlock.c

   1 /* Copyright (C) 2002, 2003, 2005 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       /* Error checking mutex.  */
  80       if (abs (mutex->__data.__owner) != THREAD_GETMEM (THREAD_SELF, tid)
  81           || ! lll_mutex_islocked (mutex->__data.__lock))
  82         return EPERM;
  83
  84       /* FALLTHROUGH */
  85
  86     case PTHREAD_MUTEX_ROBUST_PRIVATE_NP:
  87     case PTHREAD_MUTEX_ROBUST_PRIVATE_ADAPTIVE_NP:
  88       /* If the previous owner died and the caller did not succeed in
  89          making the state consistent, mark the mutex as unrecoverable
  90          and make all waiters.  */
  91       if (__builtin_expect (mutex->__data.__owner
  92                             == -THREAD_GETMEM (THREAD_SELF, tid)
  93                             || (mutex->__data.__owner
  94                                 == PTHREAD_MUTEX_NOTRECOVERABLE), 0))
  95       notrecoverable:
  96         newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
  97
  98     robust:
  99       /* Remove mutex from the list.  */
 100       DEQUEUE_MUTEX (mutex);
 101       break;
 102
 103     default:
 104       /* Correct code cannot set any other type.  */
 105       return EINVAL;
 106     }
 107
 108   /* Always reset the owner field.  */
 109   mutex->__data.__owner = newowner;
 110   if (decr)
 111     /* One less user.  */
 112     --mutex->__data.__nusers;
 113
 114   /* Unlock.  */
 115   lll_mutex_unlock (mutex->__data.__lock);
 116
 117   return 0;
 118 }
 119
 120
 121 int
 122 __pthread_mutex_unlock (mutex)
 123      pthread_mutex_t *mutex;
 124 {
 125   return __pthread_mutex_unlock_usercnt (mutex, 1);
 126 }
 127 strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
 128 strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)