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
41int
42pthread_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}
176