[glibc] 01/01: hurd-i386/tg-libpthread-gsync-mutex.diff: New patch to make mutexes use gsync too.
This is an automated email from the git hooks/post-receive script.
sthibault pushed a commit to branch sid
in repository glibc.
commit f0a819028741b56fa93406653b0a529f1ba3c686
Author: Samuel Thibault <samuel.thibault@ens-lyon.org>
Date: Tue Nov 22 19:13:02 2016 +0000
hurd-i386/tg-libpthread-gsync-mutex.diff: New patch to make mutexes use gsync too.
---
debian/changelog | 2 +
.../hurd-i386/tg-libpthread-gsync-mutex.diff | 822 +++++++++++++++++++++
debian/patches/series | 1 +
3 files changed, 825 insertions(+)
diff --git a/debian/changelog b/debian/changelog
index 8764990..a1c3a85 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -3,6 +3,8 @@ glibc (2.24-7) UNRELEASED; urgency=medium
[ Samuel Thibault ]
* hurd-i386/tg-hurdsig-SA_SIGINFO.diff: Fix passing address to legacy SIGBUS
handlers.
+ * hurd-i386/tg-libpthread-gsync-mutex.diff: New patch to make mutexes use
+ gsync too.
-- Aurelien Jarno <aurel32@debian.org> Mon, 21 Nov 2016 19:24:59 +0100
diff --git a/debian/patches/hurd-i386/tg-libpthread-gsync-mutex.diff b/debian/patches/hurd-i386/tg-libpthread-gsync-mutex.diff
new file mode 100644
index 0000000..f245153
--- /dev/null
+++ b/debian/patches/hurd-i386/tg-libpthread-gsync-mutex.diff
@@ -0,0 +1,822 @@
+commit 7343f91b7ec3487c1f0b63bfd437bb9dd82ae2a5
+Author: Agustina Arzille <avarzille@riseup.net>
+Date: Mon Oct 17 00:56:58 2016 +0200
+
+ Make pthread_mutex use gsync
+
+diff --git a/libpthread/include/pthread/pthread.h b/libpthread/include/pthread/pthread.h
+index 3aa6a93..c7742e8 100644
+--- a/libpthread/include/pthread/pthread.h
++++ b/libpthread/include/pthread/pthread.h
+@@ -271,6 +271,11 @@ extern pthread_t pthread_self (void) __THROW;
+ #define PTHREAD_MUTEX_FAST_NP PTHREAD_MUTEX_TIMED_NP
+ #endif
+
++#ifdef __USE_XOPEN2K
++#define PTHREAD_MUTEX_STALLED __PTHREAD_MUTEX_STALLED
++#define PTHREAD_MUTEX_ROBUST __PTHREAD_MUTEX_ROBUST
++#endif
++
+ #include <bits/mutex-attr.h>
+
+ /* Initialize the mutex attribute object in *ATTR to the default
+@@ -399,6 +404,18 @@ extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+ __THROW __nonnull ((1, 3));
+ #endif
+
++#ifdef __USE_XOPEN2K8
++
++/* Declare the state protected by robust mutex MTXP as consistent. */
++extern int pthread_mutex_consistent (pthread_mutex_t *__mtxp)
++ __THROW __nonnull ((1));
++
++# ifdef __USE_GNU
++extern int pthread_mutex_consistent_np (pthread_mutex_t *__mtxp)
++ __THROW __nonnull ((1));
++# endif
++#endif
++
+
+
+ /* Condition attributes. */
+diff --git a/libpthread/include/pthread/pthreadtypes.h b/libpthread/include/pthread/pthreadtypes.h
+index 33bd009..d8aed4d 100644
+--- a/libpthread/include/pthread/pthreadtypes.h
++++ b/libpthread/include/pthread/pthreadtypes.h
+@@ -77,6 +77,12 @@ enum __pthread_mutex_type
+ __PTHREAD_MUTEX_RECURSIVE
+ };
+
++enum __pthread_mutex_robustness
++ {
++ __PTHREAD_MUTEX_STALLED,
++ __PTHREAD_MUTEX_ROBUST = 0x100
++ };
++
+ #include <bits/mutex-attr.h>
+ typedef struct __pthread_mutexattr pthread_mutexattr_t;
+
+diff --git a/libpthread/sysdeps/mach/hurd/bits/mutex.h b/libpthread/sysdeps/mach/hurd/bits/mutex.h
+new file mode 100644
+index 0000000..a52a2ad
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/bits/mutex.h
+@@ -0,0 +1,64 @@
++/* Mutex type. Generic version.
++
++ Copyright (C) 2000-2016
++ Free Software Foundation, Inc.
++
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Library General Public License as
++ published by the Free Software Foundation; either version 2 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
++ Library General Public License for more details.
++
++ You should have received a copy of the GNU Library General Public
++ License along with the GNU C Library; see the file COPYING.LIB. If not,
++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
++ Boston, MA 02111-1307, USA. */
++
++#ifndef _BITS_MUTEX_H
++
++#ifndef __need_pthread_mutex
++# define _BITS_MUTEX_H 1
++#endif
++
++#ifndef __pthread_mutex_defined
++# if defined __need_pthread_mutex || defined _BITS_MUTEX_H
++# undef __need_pthread_mutex
++# define __pthread_mutex_defined
++
++# include <bits/mutex-attr.h>
++
++/* User visible part of a mutex. */
++struct __pthread_mutex
++{
++ unsigned int __lock;
++ unsigned int __owner_id;
++ unsigned int __cnt;
++ int __shpid;
++ int __type;
++ int __flags;
++ unsigned int __reserved1;
++ unsigned int __reserved2;
++};
++
++/* Static mutex initializers. */
++#define __PTHREAD_MUTEX_INITIALIZER \
++ { 0, 0, 0, 0, __PTHREAD_MUTEX_TIMED, 0, 0, 0 }
++
++/* The +1 is to mantain binary compatibility with the old
++ * libpthread implementation. */
++#define __PTHREAD_ERRORCHECK_MUTEX_INITIALIZER \
++ { 0, 0, 0, 0, __PTHREAD_MUTEX_ERRORCHECK + 1, 0, 0, 0 }
++
++#define __PTHREAD_RECURSIVE_MUTEX_INITIALIZER \
++ { 0, 0, 0, 0, __PTHREAD_MUTEX_RECURSIVE + 1, 0, 0, 0 }
++
++# endif
++#endif /* Not __pthread_mutex_defined. */
++
++#endif /* bits/mutex.h */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-destroy.c b/libpthread/sysdeps/mach/hurd/pt-mutex-destroy.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-destroy.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-getprioceiling.c b/libpthread/sysdeps/mach/hurd/pt-mutex-getprioceiling.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-getprioceiling.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-init.c b/libpthread/sysdeps/mach/hurd/pt-mutex-init.c
+new file mode 100644
+index 0000000..32010a2
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-init.c
+@@ -0,0 +1 @@
++#include "pt-mutex.c"
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-lock.c b/libpthread/sysdeps/mach/hurd/pt-mutex-lock.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-lock.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-setprioceiling.c b/libpthread/sysdeps/mach/hurd/pt-mutex-setprioceiling.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-setprioceiling.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-timedlock.c b/libpthread/sysdeps/mach/hurd/pt-mutex-timedlock.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-timedlock.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-transfer-np.c b/libpthread/sysdeps/mach/hurd/pt-mutex-transfer-np.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-transfer-np.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-trylock.c b/libpthread/sysdeps/mach/hurd/pt-mutex-trylock.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-trylock.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex-unlock.c b/libpthread/sysdeps/mach/hurd/pt-mutex-unlock.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex-unlock.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutex.c b/libpthread/sysdeps/mach/hurd/pt-mutex.c
+new file mode 100644
+index 0000000..8104fa3
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutex.c
+@@ -0,0 +1,548 @@
++/* Copyright (C) 2016 Free Software Foundation, Inc.
++ Contributed by Agustina Arzille <avarzille@riseup.net>, 2016.
++
++ This program is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Library General Public License
++ as published by the Free Software Foundation; either
++ version 2 of the license, or (at your option) any later version.
++
++ This program 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 Library General Public License for more details.
++
++ You should have received a copy of the GNU Library General Public
++ License along with this program; if not, see
++ <http://www.gnu.org/licenses/>.
++*/
++
++#include <pthread.h>
++#include <stdlib.h>
++#include <assert.h>
++#include <pt-internal.h>
++#include <hurdlock.h>
++
++static const pthread_mutexattr_t dfl_attr =
++{
++ .__prioceiling = 0,
++ .__protocol = PTHREAD_PRIO_NONE,
++ .__pshared = PTHREAD_PROCESS_PRIVATE,
++ .__mutex_type = __PTHREAD_MUTEX_TIMED
++};
++
++int pthread_mutexattr_init (pthread_mutexattr_t *attrp)
++{
++ *attrp = dfl_attr;
++ return (0);
++}
++
++int pthread_mutexattr_destroy (pthread_mutexattr_t *attrp)
++{
++ (void)attrp;
++ return (0);
++}
++
++int pthread_mutexattr_settype (pthread_mutexattr_t *attrp, int type)
++{
++ if (type < 0 || type > __PTHREAD_MUTEX_RECURSIVE)
++ return (EINVAL);
++
++ attrp->__mutex_type = type;
++ return (0);
++}
++
++int pthread_mutexattr_gettype (const pthread_mutexattr_t *attrp, int *outp)
++{
++ *outp = attrp->__mutex_type;
++ return (0);
++}
++
++int pthread_mutexattr_setpshared (pthread_mutexattr_t *attrp, int pshared)
++{
++ if (pshared != PTHREAD_PROCESS_PRIVATE &&
++ pshared != PTHREAD_PROCESS_SHARED)
++ return (EINVAL);
++
++ attrp->__pshared = pshared;
++ return (0);
++}
++
++int pthread_mutexattr_getpshared (const pthread_mutexattr_t *attrp, int *outp)
++{
++ *outp = attrp->__pshared;
++ return (0);
++}
++
++int pthread_mutexattr_setrobust (pthread_mutexattr_t *attrp, int robust)
++{
++ if (robust != PTHREAD_MUTEX_ROBUST &&
++ robust != PTHREAD_MUTEX_STALLED)
++ return (EINVAL);
++
++ attrp->__prioceiling |= robust;
++ return (0);
++}
++
++weak_alias (pthread_mutexattr_setrobust, pthread_mutexattr_setrobust_np)
++
++int pthread_mutexattr_getrobust (const pthread_mutexattr_t *attrp, int *outp)
++{
++ *outp = (attrp->__prioceiling & PTHREAD_MUTEX_ROBUST) ?
++ PTHREAD_MUTEX_ROBUST : PTHREAD_MUTEX_STALLED;
++ return (0);
++}
++
++weak_alias (pthread_mutexattr_getrobust, pthread_mutexattr_getrobust_np)
++
++int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *attrp, int cl)
++{
++ (void)attrp; (void)cl;
++ return (ENOSYS);
++}
++
++stub_warning (pthread_mutexattr_setprioceiling)
++
++int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *ap, int *clp)
++{
++ (void)ap; (void)clp;
++ return (ENOSYS);
++}
++
++stub_warning (pthread_mutexattr_getprioceiling)
++
++int pthread_mutexattr_setprotocol (pthread_mutexattr_t *attrp, int proto)
++{
++ (void)attrp;
++ return (proto == PTHREAD_PRIO_NONE ? 0 :
++ proto != PTHREAD_PRIO_INHERIT &&
++ proto != PTHREAD_PRIO_PROTECT ? EINVAL : ENOTSUP);
++}
++
++int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attrp, int *ptp)
++{
++ *ptp = attrp->__protocol;
++ return (0);
++}
++
++int _pthread_mutex_init (pthread_mutex_t *mtxp,
++ const pthread_mutexattr_t *attrp)
++{
++ if (attrp == NULL)
++ attrp = &dfl_attr;
++
++ mtxp->__flags = (attrp->__pshared == PTHREAD_PROCESS_SHARED ?
++ GSYNC_SHARED : 0) | ((attrp->__prioceiling & PTHREAD_MUTEX_ROBUST) ?
++ PTHREAD_MUTEX_ROBUST : 0);
++
++ mtxp->__type = attrp->__mutex_type +
++ (attrp->__mutex_type != __PTHREAD_MUTEX_TIMED);
++
++ mtxp->__owner_id = 0;
++ mtxp->__shpid = 0;
++ mtxp->__cnt = 0;
++ mtxp->__lock = 0;
++
++ return (0);
++}
++
++strong_alias (_pthread_mutex_init, pthread_mutex_init)
++
++/* Lock routines. */
++
++/* Special ID used to signal an unrecoverable robust mutex. */
++#define NOTRECOVERABLE_ID (1U << 31)
++
++/* Common path for robust mutexes. Assumes the variable 'ret'
++ * is bound in the function this is called from. */
++#define ROBUST_LOCK(self, mtxp, cb, ...) \
++ if (mtxp->__owner_id == NOTRECOVERABLE_ID) \
++ return (ENOTRECOVERABLE); \
++ else if (mtxp->__owner_id == self->thread && \
++ __getpid () == (int)(mtxp->__lock & LLL_OWNER_MASK)) \
++ { \
++ if (mtxp->__type == PT_MTX_RECURSIVE) \
++ { \
++ if (__glibc_unlikely (mtxp->__cnt + 1 == 0)) \
++ return (EAGAIN); \
++ \
++ ++mtxp->__cnt; \
++ return (0); \
++ } \
++ else if (mtxp->__type == PT_MTX_ERRORCHECK) \
++ return (EDEADLK); \
++ } \
++ \
++ ret = cb (&mtxp->__lock, ##__VA_ARGS__); \
++ if (ret == 0 || ret == EOWNERDEAD) \
++ { \
++ if (mtxp->__owner_id == ENOTRECOVERABLE) \
++ ret = ENOTRECOVERABLE; \
++ else \
++ { \
++ mtxp->__owner_id = self->thread; \
++ mtxp->__cnt = 1; \
++ if (ret == EOWNERDEAD) \
++ { \
++ mtxp->__lock = mtxp->__lock | LLL_DEAD_OWNER; \
++ atomic_write_barrier (); \
++ } \
++ } \
++ } \
++ (void)0
++
++/* Check that a thread owns the mutex. For non-robust, task-shared
++ * objects, we have to check the thread *and* process-id. */
++#define mtx_owned_p(mtx, pt, flags) \
++ ((mtx)->__owner_id == (pt)->thread && \
++ (((flags) & GSYNC_SHARED) == 0 || \
++ (mtx)->__shpid == __getpid ()))
++
++/* Record a thread as the owner of the mutex. */
++#define mtx_set_owner(mtx, pt, flags) \
++ (void) \
++ ({ \
++ (mtx)->__owner_id = (pt)->thread; \
++ if ((flags) & GSYNC_SHARED) \
++ (mtx)->__shpid = __getpid (); \
++ })
++
++/* Redefined mutex types. The +1 is for binary compatibility. */
++#define PT_MTX_NORMAL __PTHREAD_MUTEX_TIMED
++#define PT_MTX_RECURSIVE (__PTHREAD_MUTEX_RECURSIVE + 1)
++#define PT_MTX_ERRORCHECK (__PTHREAD_MUTEX_ERRORCHECK + 1)
++
++/* Mutex type, including robustness. */
++#define MTX_TYPE(mtxp) \
++ ((mtxp)->__type | ((mtxp)->__flags & PTHREAD_MUTEX_ROBUST))
++
++extern int __getpid (void) __attribute__ ((const));
++
++int __pthread_mutex_lock (pthread_mutex_t *mtxp)
++{
++ struct __pthread *self;
++ int flags = mtxp->__flags & GSYNC_SHARED;
++ int ret = 0;
++
++ switch (MTX_TYPE (mtxp))
++ {
++ case PT_MTX_NORMAL:
++ lll_lock (&mtxp->__lock, flags);
++ break;
++
++ case PT_MTX_RECURSIVE:
++ self = _pthread_self ();
++ if (mtx_owned_p (mtxp, self, flags))
++ {
++ if (__glibc_unlikely (mtxp->__cnt + 1 == 0))
++ return (EAGAIN);
++
++ ++mtxp->__cnt;
++ return (ret);
++ }
++
++ lll_lock (&mtxp->__lock, flags);
++ mtx_set_owner (mtxp, self, flags);
++ mtxp->__cnt = 1;
++ break;
++
++ case PT_MTX_ERRORCHECK:
++ self = _pthread_self ();
++ if (mtx_owned_p (mtxp, self, flags))
++ return (EDEADLK);
++
++ lll_lock (&mtxp->__lock, flags);
++ mtx_set_owner (mtxp, self, flags);
++ break;
++
++ case PT_MTX_NORMAL | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST:
++ self = _pthread_self ();
++ ROBUST_LOCK (self, mtxp, lll_robust_lock, flags);
++ break;
++
++ default:
++ ret = EINVAL;
++ break;
++ }
++
++ return (ret);
++}
++
++strong_alias (__pthread_mutex_lock, _pthread_mutex_lock)
++strong_alias (__pthread_mutex_lock, pthread_mutex_lock)
++
++int __pthread_mutex_trylock (pthread_mutex_t *mtxp)
++{
++ struct __pthread *self;
++ int ret;
++
++ switch (MTX_TYPE (mtxp))
++ {
++ case PT_MTX_NORMAL:
++ ret = lll_trylock (&mtxp->__lock);
++ break;
++
++ case PT_MTX_RECURSIVE:
++ self = _pthread_self ();
++ if (mtx_owned_p (mtxp, self, mtxp->__flags))
++ {
++ if (__glibc_unlikely (mtxp->__cnt + 1 == 0))
++ return (EAGAIN);
++
++ ++mtxp->__cnt;
++ ret = 0;
++ }
++ else if ((ret = lll_trylock (&mtxp->__lock)) == 0)
++ {
++ mtx_set_owner (mtxp, self, mtxp->__flags);
++ mtxp->__cnt = 1;
++ }
++
++ break;
++
++ case PT_MTX_ERRORCHECK:
++ self = _pthread_self ();
++ if ((ret = lll_trylock (&mtxp->__lock)) == 0)
++ mtx_set_owner (mtxp, self, mtxp->__flags);
++ break;
++
++ case PT_MTX_NORMAL | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST:
++ self = _pthread_self ();
++ ROBUST_LOCK (self, mtxp, lll_robust_trylock);
++ break;
++
++ default:
++ ret = EINVAL;
++ break;
++ }
++
++ return (ret);
++}
++
++strong_alias (__pthread_mutex_trylock, _pthread_mutex_trylock)
++strong_alias (__pthread_mutex_trylock, pthread_mutex_trylock)
++
++int pthread_mutex_timedlock (pthread_mutex_t *mtxp,
++ const struct timespec *tsp)
++{
++ struct __pthread *self;
++ int ret, flags = mtxp->__flags & GSYNC_SHARED;
++
++ switch (MTX_TYPE (mtxp))
++ {
++ case PT_MTX_NORMAL:
++ ret = lll_abstimed_lock (&mtxp->__lock, tsp, flags);
++ break;
++
++ case PT_MTX_RECURSIVE:
++ self = _pthread_self ();
++ if (mtx_owned_p (mtxp, self, flags))
++ {
++ if (__glibc_unlikely (mtxp->__cnt + 1 == 0))
++ return (EAGAIN);
++
++ ++mtxp->__cnt;
++ ret = 0;
++ }
++ else if ((ret = lll_abstimed_lock (&mtxp->__lock,
++ tsp, flags)) == 0)
++ {
++ mtx_set_owner (mtxp, self, flags);
++ mtxp->__cnt = 1;
++ }
++
++ break;
++
++ case PT_MTX_ERRORCHECK:
++ self = _pthread_self ();
++ if (mtx_owned_p (mtxp, self, flags))
++ ret = EDEADLK;
++ else if ((ret = lll_abstimed_lock (&mtxp->__lock,
++ tsp, flags)) == 0)
++ mtx_set_owner (mtxp, self, flags);
++
++ break;
++
++ case PT_MTX_NORMAL | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST:
++ self = _pthread_self ();
++ ROBUST_LOCK (self, mtxp, lll_robust_abstimed_lock, tsp, flags);
++ break;
++
++ default:
++ ret = EINVAL;
++ break;
++ }
++
++ return (ret);
++}
++
++int __pthread_mutex_unlock (pthread_mutex_t *mtxp)
++{
++ struct __pthread *self;
++ int ret = 0, flags = mtxp->__flags & GSYNC_SHARED;
++
++ switch (MTX_TYPE (mtxp))
++ {
++ case PT_MTX_NORMAL:
++ lll_unlock (&mtxp->__lock, flags);
++ break;
++
++ case PT_MTX_RECURSIVE:
++ self = _pthread_self ();
++ if (!mtx_owned_p (mtxp, self, flags))
++ ret = EPERM;
++ else if (--mtxp->__cnt == 0)
++ {
++ mtxp->__owner_id = mtxp->__shpid = 0;
++ lll_unlock (&mtxp->__lock, flags);
++ }
++
++ break;
++
++ case PT_MTX_ERRORCHECK:
++ self = _pthread_self ();
++ if (!mtx_owned_p (mtxp, self, flags))
++ ret = EPERM;
++ else
++ {
++ mtxp->__owner_id = mtxp->__shpid = 0;
++ lll_unlock (&mtxp->__lock, flags);
++ }
++
++ break;
++
++ case PT_MTX_NORMAL | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST:
++ self = _pthread_self ();
++ if (mtxp->__owner_id == NOTRECOVERABLE_ID)
++ ; /* Nothing to do. */
++ else if (mtxp->__owner_id != self->thread ||
++ (int)(mtxp->__lock & LLL_OWNER_MASK) != __getpid ())
++ ret = EPERM;
++ else if (--mtxp->__cnt == 0)
++ {
++ /* Release the lock. If it's in an inconsistent
++ * state, mark it as irrecoverable. */
++ mtxp->__owner_id = (mtxp->__lock & LLL_DEAD_OWNER) ?
++ NOTRECOVERABLE_ID : 0;
++ lll_robust_unlock (&mtxp->__lock, flags);
++ }
++
++ break;
++
++ default:
++ ret = EINVAL;
++ break;
++ }
++
++ return (ret);
++}
++
++strong_alias (__pthread_mutex_unlock, _pthread_mutex_unlock)
++strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
++
++int pthread_mutex_consistent (pthread_mutex_t *mtxp)
++{
++ int ret = EINVAL;
++ unsigned int val = mtxp->__lock;
++
++ if ((mtxp->__flags & PTHREAD_MUTEX_ROBUST) != 0 &&
++ (val & LLL_DEAD_OWNER) != 0 &&
++ atomic_compare_and_exchange_bool_acq (&mtxp->__lock,
++ __getpid () | LLL_WAITERS, val) == 0)
++ {
++ /* The mutex is now ours, and it's consistent. */
++ mtxp->__owner_id = _pthread_self()->thread;
++ mtxp->__cnt = 1;
++ ret = 0;
++ }
++
++ return (ret);
++}
++
++weak_alias (pthread_mutex_consistent, pthread_mutex_consistent_np)
++
++int __pthread_mutex_transfer_np (pthread_mutex_t *mtxp, pthread_t th)
++{
++ struct __pthread *self = _pthread_self ();
++ struct __pthread *pt = __pthread_getid (th);
++
++ if (!pt)
++ return (ESRCH);
++ else if (pt == self)
++ return (0);
++
++ int ret = 0;
++ int flags = mtxp->__flags & GSYNC_SHARED;
++
++ switch (MTX_TYPE (mtxp))
++ {
++ case PT_MTX_NORMAL:
++ break;
++
++ case PT_MTX_RECURSIVE:
++ case PT_MTX_ERRORCHECK:
++ if (!mtx_owned_p (mtxp, self, flags))
++ ret = EPERM;
++ else
++ mtx_set_owner (mtxp, pt, flags);
++
++ break;
++
++ case PT_MTX_NORMAL | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST:
++ case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST:
++ /* Note that this can be used to transfer an inconsistent
++ * mutex as well. The new owner will still have the same
++ * flags as the original. */
++ if (mtxp->__owner_id != self->thread ||
++ (int)(mtxp->__lock & LLL_OWNER_MASK) != __getpid ())
++ ret = EPERM;
++ else
++ mtxp->__owner_id = pt->thread;
++
++ break;
++
++ default:
++ ret = EINVAL;
++ }
++
++ return (ret);
++}
++
++strong_alias (__pthread_mutex_transfer_np, pthread_mutex_transfer_np)
++
++int pthread_mutex_setprioceiling (pthread_mutex_t *mtxp, int cl, int *prp)
++{
++ (void)mtxp; (void)cl; (void)prp;
++ return (ENOSYS);
++}
++
++stub_warning (pthread_mutex_setprioceiling)
++
++int pthread_mutex_getprioceiling (const pthread_mutex_t *mtxp, int *clp)
++{
++ (void)mtxp; (void)clp;
++ return (ENOSYS);
++}
++
++stub_warning (pthread_mutex_getprioceiling)
++
++int _pthread_mutex_destroy (pthread_mutex_t *mtxp)
++{
++ atomic_read_barrier ();
++ if (*(volatile unsigned int *)&mtxp->__lock != 0)
++ return (EBUSY);
++
++ mtxp->__type = -1;
++ return (0);
++}
++
++strong_alias (_pthread_mutex_destroy, pthread_mutex_destroy)
++
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-destroy.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-destroy.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-destroy.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-getprioceiling.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-getprioceiling.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-getprioceiling.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-getprotocol.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-getprotocol.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-getprotocol.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-getpshared.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-getpshared.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-getpshared.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-gettype.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-gettype.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-gettype.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-init.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-init.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-init.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-setprioceiling.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-setprioceiling.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-setprioceiling.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-setprotocol.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-setprotocol.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-setprotocol.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-setpshared.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-setpshared.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-setpshared.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr-settype.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr-settype.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr-settype.c
+@@ -0,0 +1 @@
++/* empty */
+diff --git a/libpthread/sysdeps/mach/hurd/pt-mutexattr.c b/libpthread/sysdeps/mach/hurd/pt-mutexattr.c
+new file mode 100644
+index 0000000..40a8c17
+--- /dev/null
++++ b/libpthread/sysdeps/mach/hurd/pt-mutexattr.c
+@@ -0,0 +1 @@
++/* empty */
diff --git a/debian/patches/series b/debian/patches/series
index a00460f..2575eea 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -135,6 +135,7 @@ hurd-i386/tg-pthread_deps.diff
hurd-i386/cvs-mallocfork.diff
hurd-i386/tg-libpthread-gsync-spin.diff
hurd-i386/tg-ONSTACK.diff
+hurd-i386/tg-libpthread-gsync-mutex.diff
i386/local-biarch.diff
i386/local-cmov.diff
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-glibc/glibc.git
Reply to: