[glibc.git] / nptl / pthread_mutex_unlock.c

/* Copyright (C) 2002, 2003, 2005, 2006 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <errno.h>
#include <stdlib.h>
#include "pthreadP.h"
#include <lowlevellock.h>


int
internal_function attribute_hidden
__pthread_mutex_unlock_usercnt (mutex, decr)
     pthread_mutex_t *mutex;
     int decr;
{
  int newowner = 0;

  switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
    {
    case PTHREAD_MUTEX_RECURSIVE_NP:
      /* Recursive mutex.  */
      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	return EPERM;

      if (--mutex->__data.__count != 0)
	/* We still hold the mutex.  */
	return 0;
      goto normal;

    case PTHREAD_MUTEX_ERRORCHECK_NP:
      /* Error checking mutex.  */
      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
	  || ! lll_mutex_islocked (mutex->__data.__lock))
	return EPERM;
      /* FALLTHROUGH */

    case PTHREAD_MUTEX_TIMED_NP:
    case PTHREAD_MUTEX_ADAPTIVE_NP:
      /* Always reset the owner field.  */
    normal:
      mutex->__data.__owner = 0;
      if (decr)
	/* One less user.  */
	--mutex->__data.__nusers;

      /* Unlock.  */
      lll_mutex_unlock (mutex->__data.__lock);
      break;

    case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
      /* Recursive mutex.  */
      if ((mutex->__data.__lock & FUTEX_TID_MASK)
	  == THREAD_GETMEM (THREAD_SELF, tid)
	  && __builtin_expect (mutex->__data.__owner
			       == PTHREAD_MUTEX_INCONSISTENT, 0))
	{
	  if (--mutex->__data.__count != 0)
	    /* We still hold the mutex.  */
	    return ENOTRECOVERABLE;

	  goto notrecoverable;
	}

      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	return EPERM;

      if (--mutex->__data.__count != 0)
	/* We still hold the mutex.  */
	return 0;

      goto robust;

    case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
    case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
    case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
      if ((mutex->__data.__lock & FUTEX_TID_MASK)
	  != THREAD_GETMEM (THREAD_SELF, tid)
	  || ! lll_mutex_islocked (mutex->__data.__lock))
	return EPERM;

      /* If the previous owner died and the caller did not succeed in
	 making the state consistent, mark the mutex as unrecoverable
	 and make all waiters.  */
      if (__builtin_expect (mutex->__data.__owner
			    == PTHREAD_MUTEX_INCONSISTENT, 0))
      notrecoverable:
	newowner = PTHREAD_MUTEX_NOTRECOVERABLE;

    robust:
      /* Remove mutex from the list.  */
      THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
		     &mutex->__data.__list.__next);
      DEQUEUE_MUTEX (mutex);

      mutex->__data.__owner = newowner;
      if (decr)
	/* One less user.  */
	--mutex->__data.__nusers;

      /* Unlock.  */
      lll_robust_mutex_unlock (mutex->__data.__lock);

      THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
      break;

    case PTHREAD_MUTEX_PI_RECURSIVE_NP:
      /* Recursive mutex.  */
      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	return EPERM;

      if (--mutex->__data.__count != 0)
	/* We still hold the mutex.  */
	return 0;
      goto continue_pi;

    case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
      /* Recursive mutex.  */
      if ((mutex->__data.__lock & FUTEX_TID_MASK)
	  == THREAD_GETMEM (THREAD_SELF, tid)
	  && __builtin_expect (mutex->__data.__owner
			       == PTHREAD_MUTEX_INCONSISTENT, 0))
	{
	  if (--mutex->__data.__count != 0)
	    /* We still hold the mutex.  */
	    return ENOTRECOVERABLE;

	  goto pi_notrecoverable;
	}

      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	return EPERM;

      if (--mutex->__data.__count != 0)
	/* We still hold the mutex.  */
	return 0;

      goto continue_pi;

    case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
    case PTHREAD_MUTEX_PI_NORMAL_NP:
    case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
    case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
    case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
    case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
      if ((mutex->__data.__lock & FUTEX_TID_MASK)
	  != THREAD_GETMEM (THREAD_SELF, tid)
	  || ! lll_mutex_islocked (mutex->__data.__lock))
	return EPERM;

      /* If the previous owner died and the caller did not succeed in
	 making the state consistent, mark the mutex as unrecoverable
	 and make all waiters.  */
      if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0
	  && __builtin_expect (mutex->__data.__owner
			       == PTHREAD_MUTEX_INCONSISTENT, 0))
      pi_notrecoverable:
       newowner = PTHREAD_MUTEX_NOTRECOVERABLE;

    continue_pi:
      if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0)
	{
	  /* Remove mutex from the list.
	     Note: robust PI futexes are signaled by setting bit 0.  */
	  THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
			 (void *) (((uintptr_t) &mutex->__data.__list.__next)
				   | 1));
	  DEQUEUE_MUTEX (mutex);
	}

      mutex->__data.__owner = newowner;
      if (decr)
	/* One less user.  */
	--mutex->__data.__nusers;

      /* Unlock.  */
      if ((mutex->__data.__lock & FUTEX_WAITERS) != 0
	  || atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock, 0,
						   THREAD_GETMEM (THREAD_SELF,
								  tid)))
	{
	  INTERNAL_SYSCALL_DECL (__err);
	  INTERNAL_SYSCALL (futex, __err, 2, &mutex->__data.__lock,
			    FUTEX_UNLOCK_PI);
	}

      THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
      break;

    case PTHREAD_MUTEX_PP_RECURSIVE_NP:
      /* Recursive mutex.  */
      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	return EPERM;

      if (--mutex->__data.__count != 0)
	/* We still hold the mutex.  */
	return 0;
      goto pp;

    case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
      /* Error checking mutex.  */
      if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
	  || (mutex->__data.__lock & ~ PTHREAD_MUTEX_PRIO_CEILING_MASK) == 0)
	return EPERM;
      /* FALLTHROUGH */

    case PTHREAD_MUTEX_PP_NORMAL_NP:
    case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
      /* Always reset the owner field.  */
    pp:
      mutex->__data.__owner = 0;

      if (decr)
	/* One less user.  */
	--mutex->__data.__nusers;

      /* Unlock.  */
      int newval, oldval;
      do
	{
	  oldval = mutex->__data.__lock;
	  newval = oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK;
	}
      while (atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock,
						   newval, oldval));

      if ((oldval & ~PTHREAD_MUTEX_PRIO_CEILING_MASK) > 1)
	lll_futex_wake (&mutex->__data.__lock, 1);

      int oldprio = newval >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
      return __pthread_tpp_change_priority (oldprio, -1);

    default:
      /* Correct code cannot set any other type.  */
      return EINVAL;
    }

  return 0;
}


int
__pthread_mutex_unlock (mutex)
     pthread_mutex_t *mutex;
{
  return __pthread_mutex_unlock_usercnt (mutex, 1);
}
strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)
Commit	Line	Data
b007ce7c	1	/* Copyright (C) 2002, 2003, 2005, 2006 Free Software Foundation, Inc.
76a50749 UD	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>
1bcfb5a5	21	#include <stdlib.h>
76a50749 UD	22	#include "pthreadP.h"
	23	#include <lowlevellock.h>
	24
	25
	26	int
3a4f2043	27	internal_function attribute_hidden
61623643	28	__pthread_mutex_unlock_usercnt (mutex, decr)
76a50749	29	pthread_mutex_t *mutex;
8f31c0ef	30	int decr;
76a50749	31	{
1bcfb5a5 UD	32	int newowner = 0;
1bcfb5a5 UD	33
76a50749 UD	34	switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
	35	{
	36	case PTHREAD_MUTEX_RECURSIVE_NP:
	37	/* Recursive mutex. */
61623643	38	if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
76a50749 UD	39	return EPERM;
	40
	41	if (--mutex->__data.__count != 0)
	42	/* We still hold the mutex. */
	43	return 0;
683040c3	44	goto normal;
76a50749 UD	45
	46	case PTHREAD_MUTEX_ERRORCHECK_NP:
	47	/* Error checking mutex. */
61623643	48	if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
76a50749 UD	49	\|\| ! lll_mutex_islocked (mutex->__data.__lock))
76a50749 UD	50	return EPERM;
683040c3	51	/* FALLTHROUGH */
76a50749	52
76a50749 UD	53	case PTHREAD_MUTEX_TIMED_NP:
76a50749 UD	54	case PTHREAD_MUTEX_ADAPTIVE_NP:
683040c3 UD	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);
0ecb606c	64	break;
dcc73a8d	65
0f6699ea	66	case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
1bcfb5a5	67	/* Recursive mutex. */
683040c3	68	if ((mutex->__data.__lock & FUTEX_TID_MASK)
0f6699ea UD	69	== THREAD_GETMEM (THREAD_SELF, tid)
	70	&& __builtin_expect (mutex->__data.__owner
	71	== PTHREAD_MUTEX_INCONSISTENT, 0))
1bcfb5a5 UD	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
0f6699ea UD	89	case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
	90	case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
	91	case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
683040c3 UD	92	if ((mutex->__data.__lock & FUTEX_TID_MASK)
683040c3 UD	93	!= THREAD_GETMEM (THREAD_SELF, tid)
1bcfb5a5 UD	94	\|\| ! lll_mutex_islocked (mutex->__data.__lock))
	95	return EPERM;
	96
1bcfb5a5 UD	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
683040c3	101	== PTHREAD_MUTEX_INCONSISTENT, 0))
1bcfb5a5 UD	102	notrecoverable:
	103	newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
	104
	105	robust:
	106	/* Remove mutex from the list. */
0f6699ea UD	107	THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
0f6699ea UD	108	&mutex->__data.__list.__next);
1bcfb5a5	109	DEQUEUE_MUTEX (mutex);
683040c3 UD	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);
0f6699ea UD	118
0f6699ea UD	119	THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
1bcfb5a5 UD	120	break;
1bcfb5a5 UD	121
df47504c UD	122	case PTHREAD_MUTEX_PI_RECURSIVE_NP:
	123	/* Recursive mutex. */
	124	if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	125	return EPERM;
	126
	127	if (--mutex->__data.__count != 0)
	128	/* We still hold the mutex. */
	129	return 0;
	130	goto continue_pi;
	131
	132	case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
	133	/* Recursive mutex. */
	134	if ((mutex->__data.__lock & FUTEX_TID_MASK)
	135	== THREAD_GETMEM (THREAD_SELF, tid)
	136	&& __builtin_expect (mutex->__data.__owner
	137	== PTHREAD_MUTEX_INCONSISTENT, 0))
	138	{
	139	if (--mutex->__data.__count != 0)
	140	/* We still hold the mutex. */
	141	return ENOTRECOVERABLE;
	142
	143	goto pi_notrecoverable;
	144	}
	145
	146	if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	147	return EPERM;
	148
	149	if (--mutex->__data.__count != 0)
	150	/* We still hold the mutex. */
	151	return 0;
	152
	153	goto continue_pi;
	154
	155	case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
	156	case PTHREAD_MUTEX_PI_NORMAL_NP:
	157	case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
	158	case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
	159	case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
	160	case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
	161	if ((mutex->__data.__lock & FUTEX_TID_MASK)
	162	!= THREAD_GETMEM (THREAD_SELF, tid)
	163	\|\| ! lll_mutex_islocked (mutex->__data.__lock))
	164	return EPERM;
	165
	166	/* If the previous owner died and the caller did not succeed in
	167	making the state consistent, mark the mutex as unrecoverable
	168	and make all waiters. */
	169	if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0
	170	&& __builtin_expect (mutex->__data.__owner
	171	== PTHREAD_MUTEX_INCONSISTENT, 0))
	172	pi_notrecoverable:
	173	newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
	174
	175	continue_pi:
	176	if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0)
	177	{
	178	/* Remove mutex from the list.
	179	Note: robust PI futexes are signaled by setting bit 0. */
	180	THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
	181	(void *) (((uintptr_t) &mutex->__data.__list.__next)
	182	\| 1));
	183	DEQUEUE_MUTEX (mutex);
	184	}
	185
186	mutex->__data.__owner = newowner;
187	if (decr)
188	/* One less user. */
189	--mutex->__data.__nusers;
190
191	/* Unlock. */
192	if ((mutex->__data.__lock & FUTEX_WAITERS) != 0
193	\|\| atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock, 0,
194	THREAD_GETMEM (THREAD_SELF,
195	tid)))
196	{
197	INTERNAL_SYSCALL_DECL (__err);
198	INTERNAL_SYSCALL (futex, __err, 2, &mutex->__data.__lock,
199	FUTEX_UNLOCK_PI);
200	}
201
202	THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
203	break;
204
f17efcb4 UD	205	case PTHREAD_MUTEX_PP_RECURSIVE_NP:
	206	/* Recursive mutex. */
	207	if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
	208	return EPERM;
	209
	210	if (--mutex->__data.__count != 0)
	211	/* We still hold the mutex. */
	212	return 0;
	213	goto pp;
	214
	215	case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
	216	/* Error checking mutex. */
	217	if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
	218	\|\| (mutex->__data.__lock & ~ PTHREAD_MUTEX_PRIO_CEILING_MASK) == 0)
	219	return EPERM;
	220	/* FALLTHROUGH */
	221
	222	case PTHREAD_MUTEX_PP_NORMAL_NP:
	223	case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
	224	/* Always reset the owner field. */
	225	pp:
	226	mutex->__data.__owner = 0;
	227
	228	if (decr)
	229	/* One less user. */
	230	--mutex->__data.__nusers;
	231
	232	/* Unlock. */
	233	int newval, oldval;
	234	do
	235	{
	236	oldval = mutex->__data.__lock;
	237	newval = oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK;
	238	}
	239	while (atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock,
	240	newval, oldval));
	241
	242	if ((oldval & ~PTHREAD_MUTEX_PRIO_CEILING_MASK) > 1)
	243	lll_futex_wake (&mutex->__data.__lock, 1);
	244
	245	int oldprio = newval >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
	246	return __pthread_tpp_change_priority (oldprio, -1);
	247
dcc73a8d UD	248	default:
	249	/* Correct code cannot set any other type. */
	250	return EINVAL;
a334319f	251	}
0ecb606c	252
76a50749 UD	253	return 0;
76a50749 UD	254	}
61623643 UD	255
	256
	257	int
	258	__pthread_mutex_unlock (mutex)
	259	pthread_mutex_t *mutex;
	260	{
8f31c0ef	261	return __pthread_mutex_unlock_usercnt (mutex, 1);
61623643	262	}
76a50749	263	strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
db0a052c	264	strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)