native_client_sdk/src/libraries/third_party/pthreads-win32/pthread_mutex_unlock.c

   1 /*
   2  * pthread_mutex_unlock.c
   3  *
   4  * Description:
   5  * This translation unit implements mutual exclusion (mutex) primitives.
   6  *
   7  * --------------------------------------------------------------------------
   8  *
   9  *      Pthreads-win32 - POSIX Threads Library for Win32
  10  *      Copyright(C) 1998 John E. Bossom
  11  *      Copyright(C) 1999,2005 Pthreads-win32 contributors
  12  *
  13  *      Contact Email: rpj@callisto.canberra.edu.au
  14  *
  15  *      The current list of contributors is contained
  16  *      in the file CONTRIBUTORS included with the source
  17  *      code distribution. The list can also be seen at the
  18  *      following World Wide Web location:
  19  *      http://sources.redhat.com/pthreads-win32/contributors.html
  20  *
  21  *      This library is free software; you can redistribute it and/or
  22  *      modify it under the terms of the GNU Lesser General Public
  23  *      License as published by the Free Software Foundation; either
  24  *      version 2 of the License, or (at your option) any later version.
  25  *
  26  *      This library is distributed in the hope that it will be useful,
  27  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  29  *      Lesser General Public License for more details.
  30  *
  31  *      You should have received a copy of the GNU Lesser General Public
  32  *      License along with this library in the file COPYING.LIB;
  33  *      if not, write to the Free Software Foundation, Inc.,
  34  *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  35  */
  36
  37 #include "pthread.h"
  38 #include "implement.h"
  39
  40
  41 int
  42 pthread_mutex_unlock (pthread_mutex_t * mutex)
  43 {
  44   int result = 0;
  45   int kind;
  46   pthread_mutex_t mx;
  47
  48   /*
  49    * Let the system deal with invalid pointers.
  50    */
  51
  52   mx = *mutex;
  53
  54   /*
  55    * If the thread calling us holds the mutex then there is no
  56    * race condition. If another thread holds the
  57    * lock then we shouldn't be in here.
  58    */
  59   if (mx < PTHREAD_ERRORCHECK_MUTEX_INITIALIZER)
  60     {
  61       kind = mx->kind;
  62
  63       if (kind >= 0)
  64         {
  65           if (kind == PTHREAD_MUTEX_NORMAL)
  66             {
  67               LONG idx;
  68
  69               idx = (LONG) PTW32_INTERLOCKED_EXCHANGE_LONG ((PTW32_INTERLOCKED_LONGPTR)&mx->lock_idx,
  70                                                             (PTW32_INTERLOCKED_LONG)0);
  71               if (idx != 0)
  72                 {
  73                   if (idx < 0)
  74                     {
  75                       /*
  76                        * Someone may be waiting on that mutex.
  77                        */
  78                       if (SetEvent (mx->event) == 0)
  79                         {
  80                           result = EINVAL;
  81                         }
  82                     }
  83                 }
  84             }
  85           else
  86             {
  87               if (pthread_equal (mx->ownerThread, pthread_self()))
  88                 {
  89                   if (kind != PTHREAD_MUTEX_RECURSIVE
  90                       || 0 == --mx->recursive_count)
  91                     {
  92                       mx->ownerThread.p = NULL;
  93
  94                       if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG ((PTW32_INTERLOCKED_LONGPTR)&mx->lock_idx,
  95                                                                   (PTW32_INTERLOCKED_LONG)0) < 0L)
  96                         {
  97                           /* Someone may be waiting on that mutex */
  98                           if (SetEvent (mx->event) == 0)
  99                             {
 100                               result = EINVAL;
 101                             }
 102                         }
 103                     }
 104                 }
 105               else
 106                 {
 107                   result = EPERM;
 108                 }
 109             }
 110         }
 111       else
 112         {
 113           /* Robust types */
 114           pthread_t self = pthread_self();
 115           kind = -kind - 1; /* Convert to non-robust range */
 116
 117           /*
 118            * The thread must own the lock regardless of type if the mutex
 119            * is robust.
 120            */
 121           if (pthread_equal (mx->ownerThread, self))
 122             {
 123               PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->robustNode->stateInconsistent,
 124                                                       (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_NOTRECOVERABLE,
 125                                                       (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_INCONSISTENT);
 126               if (PTHREAD_MUTEX_NORMAL == kind)
 127                 {
 128                   ptw32_robust_mutex_remove(mutex, NULL);
 129
 130                   if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
 131                                                              (PTW32_INTERLOCKED_LONG) 0) < 0)
 132                     {
 133                       /*
 134                        * Someone may be waiting on that mutex.
 135                        */
 136                       if (SetEvent (mx->event) == 0)
 137                         {
 138                           result = EINVAL;
 139                         }
 140                     }
 141                 }
 142               else
 143                 {
 144                   if (kind != PTHREAD_MUTEX_RECURSIVE
 145                       || 0 == --mx->recursive_count)
 146                     {
 147                       ptw32_robust_mutex_remove(mutex, NULL);
 148
 149                       if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
 150                                                                  (PTW32_INTERLOCKED_LONG) 0) < 0)
 151                         {
 152                           /*
 153                            * Someone may be waiting on that mutex.
 154                            */
 155                           if (SetEvent (mx->event) == 0)
 156                             {
 157                               result = EINVAL;
 158                             }
 159                         }
 160                     }
 161                 }
 162             }
 163           else
 164             {
 165               result = EPERM;
 166             }
 167         }
 168     }
 169   else if (mx != PTHREAD_MUTEX_INITIALIZER)
 170     {
 171       result = EINVAL;
 172     }
 173
 174   return (result);
 175 }