Author: sthibault Date: 2015-12-06 00:34:38 +0000 (Sun, 06 Dec 2015) New Revision: 6777
Added: glibc-package/trunk/debian/patches/hurd-i386/cvs-libpthread-api.diff Modified: glibc-package/trunk/debian/changelog glibc-package/trunk/debian/patches/series Log: * patches/hurd-i386/cvs-libpthread-api.diff: New patch, cleans libpthread API. Fixes conflicting declarations between pthread.h and sigthread.h. Modified: glibc-package/trunk/debian/changelog =================================================================== --- glibc-package/trunk/debian/changelog 2015-12-05 14:47:32 UTC (rev 6776) +++ glibc-package/trunk/debian/changelog 2015-12-06 00:34:38 UTC (rev 6777) @@ -5,6 +5,10 @@ upgrade from squeeze to wheezy, as we don't support squeeze to stretch upgrades. + [ Samuel Thibault ] + * patches/hurd-i386/cvs-libpthread-api.diff: New patch, cleans libpthread + API. Fixes conflicting declarations between pthread.h and sigthread.h. + -- Aurelien Jarno <aure...@debian.org> Fri, 04 Dec 2015 00:24:29 +0100 glibc (2.21-3) unstable; urgency=medium Added: glibc-package/trunk/debian/patches/hurd-i386/cvs-libpthread-api.diff =================================================================== --- glibc-package/trunk/debian/patches/hurd-i386/cvs-libpthread-api.diff (rev 0) +++ glibc-package/trunk/debian/patches/hurd-i386/cvs-libpthread-api.diff 2015-12-06 00:34:38 UTC (rev 6777) @@ -0,0 +1,834 @@ +commit 577a738522d34a64cb3cd5bb8368c8b1a344f38e +Author: Samuel Thibault <samuel.thiba...@ens-lyon.org> +Date: Sun Dec 6 01:22:01 2015 +0100 + + Add __THROW and __nonnull attributes + + * include/pthread/pthread.h: Add __THROW and __nonnull attributes to + functions. + +commit 86c3dbc6445ff1bbd72c43ce46dd9f84d80e890e +Author: Samuel Thibault <samuel.thiba...@ens-lyon.org> +Date: Sat Oct 31 11:20:52 2015 +0100 + + Do not use __thread as parameter name + + That is the TLS qualifier. + + * include/pthread/pthread.h (pthread_getattr_np, pthread_cancel, + pthread_kill, pthread_getcpuclockid, pthread_getschedparam, + pthread_setschedparam, pthread_setschedprio): Use __thr as parameter name + instead of __thread. + +commit 46211ef0b82e6db1d62021fadfdd2be8cf78e729 +Author: Samuel Thibault <samuel.thiba...@ens-lyon.org> +Date: Tue Sep 22 02:54:11 2015 +0200 + + Avoid exposing function prototype parameter names + + * include/pthread/pthread.h (pthread_mutex_setprioceiling): Prepend '__' + to prio parameter name. + +commit 02ca56841e7fc3d016b948b29421619408a18227 +Author: Samuel Thibault <samuel.thiba...@ens-lyon.org> +Date: Tue Sep 22 02:52:13 2015 +0200 + + Do not expose "noreturn" name + + * ./include/pthread/pthread.h (pthread_exit): Use __noreturn__ attribute + instead of noreturn. + +commit 40f99833334b930762f957763d9db06e2f5dc7bb +Author: Samuel Thibault <samuel.thiba...@ens-lyon.org> +Date: Mon Sep 21 00:04:15 2015 +0200 + + Avoid exposing function prototype parameter names + + * include/pthread/pthread.h: Prepend '__' to parameter names. + * sysdeps/mach/hurd/bits/pthread-np.h: Likewise. + +--- a/libpthread/include/pthread/pthread.h ++++ b/libpthread/include/pthread/pthread.h +@@ -79,112 +79,132 @@ __BEGIN_DECLS + + /* Initialize the thread attribute object in *ATTR to the default + values. */ +-extern int pthread_attr_init (pthread_attr_t *attr); ++extern int pthread_attr_init (pthread_attr_t *__attr) __THROW __nonnull ((1)); + + /* Destroy the thread attribute object in *ATTR. */ +-extern int pthread_attr_destroy (pthread_attr_t *attr); ++extern int pthread_attr_destroy (pthread_attr_t *__attr) ++ __THROW __nonnull ((1)); + + + /* Return the value of the inheritsched attribute in *ATTR in + *INHERITSCHED. */ +-extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict attr, +- int *__restrict inheritsched); ++extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict __attr, ++ int *__restrict __inheritsched) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the inheritsched attribute in *ATTR to + INHERITSCHED. */ +-extern int pthread_attr_setinheritsched (pthread_attr_t *attr, +- int inheritsched); ++extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, ++ int __inheritsched) ++ __THROW __nonnull ((1)); + + + /* Return the value of the schedparam attribute in *ATTR in *PARAM. */ +-extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict attr, +- struct sched_param *__restrict param); ++extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, ++ struct sched_param *__restrict __param) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the schedparam attribute in *ATTR to PARAM. */ +-extern int pthread_attr_setschedparam (pthread_attr_t *__restrict attr, +- const struct sched_param *__restrict param); ++extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, ++ const struct sched_param *__restrict ++ __param) __THROW __nonnull ((1, 2)); + + + /* Return the value of the schedpolicy attribute in *ATTR to *POLICY. */ +-extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict attr, +- int *__restrict policy); ++extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict __attr, ++ int *__restrict __policy) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the schedpolicy attribute in *ATTR to POLICY. */ +-extern int pthread_attr_setschedpolicy (pthread_attr_t *attr, +- int policy); ++extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, ++ int __policy) ++ __THROW __nonnull ((1)); + + + /* Return the value of the contentionscope attribute in *ATTR in + *CONTENTIONSCOPE. */ +-extern int pthread_attr_getscope (const pthread_attr_t *__restrict attr, +- int *__restrict contentionscope); ++extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, ++ int *__restrict __contentionscope) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the contentionscope attribute in *ATTR to + CONTENTIONSCOPE. */ +-extern int pthread_attr_setscope (pthread_attr_t *attr, +- int contentionscope); ++extern int pthread_attr_setscope (pthread_attr_t *__attr, ++ int __contentionscope) ++ __THROW __nonnull ((1)); + + + /* Return the value of the stackaddr attribute in *ATTR in + *STACKADDR. */ +-extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict attr, +- void **__restrict stackaddr); ++extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr, ++ void **__restrict __stackaddr) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the stackaddr attribute in *ATTR to STACKADDR. */ +-extern int pthread_attr_setstackaddr (pthread_attr_t *attr, +- void *stackaddr); ++extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, ++ void *__stackaddr) ++ __THROW __nonnull ((1)); + + + #ifdef __USE_XOPEN2K + /* Return the value of the stackaddr and stacksize attributes in *ATTR + in *STACKADDR and *STACKSIZE respectively. */ +-extern int pthread_attr_getstack (const pthread_attr_t *__restrict attr, +- void **__restrict stackaddr, +- size_t *__restrict stacksize); ++extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, ++ void **__restrict __stackaddr, ++ size_t *__restrict __stacksize) ++ __THROW __nonnull ((1, 2, 3)); + + /* Set the value of the stackaddr and stacksize attributes in *ATTR to + STACKADDR and STACKSIZE respectively. */ +-extern int pthread_attr_setstack (pthread_attr_t *attr, +- void *stackaddr, +- size_t stacksize); ++extern int pthread_attr_setstack (pthread_attr_t *__attr, ++ void *__stackaddr, ++ size_t __stacksize) ++ __THROW __nonnull ((1)); + #endif + + + /* Return the value of the detachstate attribute in *ATTR in + *DETACHSTATE. */ +-extern int pthread_attr_getdetachstate (const pthread_attr_t *attr, +- int *detachstate); ++extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, ++ int *__detachstate) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the detachstate attribute in *ATTR to + DETACHSTATE. */ +-extern int pthread_attr_setdetachstate (pthread_attr_t *attr, +- int detachstate); ++extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, ++ int __detachstate) ++ __THROW __nonnull ((1)); + + + /* Return the value of the guardsize attribute in *ATTR in + *GUARDSIZE. */ +-extern int pthread_attr_getguardsize (const pthread_attr_t *__restrict attr, +- size_t *__restrict guardsize); ++extern int pthread_attr_getguardsize (const pthread_attr_t *__restrict __attr, ++ size_t *__restrict __guardsize) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the guardsize attribute in *ATTR to GUARDSIZE. */ +-extern int pthread_attr_setguardsize (pthread_attr_t *attr, +- size_t guardsize); ++extern int pthread_attr_setguardsize (pthread_attr_t *__attr, ++ size_t __guardsize) ++ __THROW __nonnull ((1)); + + + /* Return the value of the stacksize attribute in *ATTR in + *STACKSIZE. */ +-extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict attr, +- size_t *__restrict stacksize); ++extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr, ++ size_t *__restrict __stacksize) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the stacksize attribute in *ATTR to STACKSIZE. */ +-extern int pthread_attr_setstacksize (pthread_attr_t *attr, +- size_t stacksize); ++extern int pthread_attr_setstacksize (pthread_attr_t *__attr, ++ size_t __stacksize) ++ __THROW __nonnull ((1)); + + #ifdef __USE_GNU + /* Initialize thread attribute *ATTR with attributes corresponding to the + already running thread THREAD. It shall be called on an uninitialized ATTR + and destroyed with pthread_attr_destroy when no longer needed. */ +-extern int pthread_getattr_np (pthread_t thread, pthread_attr_t *attr); ++extern int pthread_getattr_np (pthread_t __thr, pthread_attr_t *__attr) ++ __THROW __nonnull ((2)); + #endif + + +@@ -193,11 +213,11 @@ extern int pthread_getattr_np (pthread_t + extern int pthread_create (pthread_t *__restrict __threadp, + __const pthread_attr_t *__restrict __attr, + void *(*__start_routine)(void *), +- void *__restrict __arg); ++ void *__restrict __arg) __THROWNL __nonnull ((1, 3)); + + /* Terminate the current thread and make STATUS available to any + thread that might join us. */ +-extern void pthread_exit (void *__status) __attribute__ ((noreturn)); ++extern void pthread_exit (void *__status) __attribute__ ((__noreturn__)); + + /* Make calling thread wait for termination of thread THREAD. Return + the exit status of the thread in *STATUS. */ +@@ -209,7 +229,7 @@ extern int pthread_detach (pthread_t __t + + /* Compare thread IDs T1 and T2. Return nonzero if they are equal, 0 + if they are not. */ +-extern int pthread_equal (pthread_t __t1, pthread_t __t2); ++extern int pthread_equal (pthread_t __t1, pthread_t __t2) __THROW; + + # ifdef __USE_EXTERN_INLINES + +@@ -223,7 +243,7 @@ pthread_equal (pthread_t __t1, pthread_t + + + /* Return the thread ID of the calling thread. */ +-extern pthread_t pthread_self (void); ++extern pthread_t pthread_self (void) __THROW; + + + /* Mutex attributes. */ +@@ -255,54 +275,64 @@ extern pthread_t pthread_self (void); + + /* Initialize the mutex attribute object in *ATTR to the default + values. */ +-extern int pthread_mutexattr_init(pthread_mutexattr_t *attr); ++extern int pthread_mutexattr_init(pthread_mutexattr_t *__attr) ++ __THROW __nonnull ((1)); + + /* Destroy the mutex attribute structure in *ATTR. */ +-extern int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); ++extern int pthread_mutexattr_destroy(pthread_mutexattr_t *__attr) ++ __THROW __nonnull ((1)); + + + #ifdef __USE_UNIX98 + /* Return the value of the prioceiling attribute in *ATTR in + *PRIOCEILING. */ +-extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict attr, +- int *__restrict prioceiling); ++extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict __attr, ++ int *__restrict __prioceiling) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the prioceiling attribute in *ATTR to + PRIOCEILING. */ +-extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, +- int prioceiling); ++extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *__attr, ++ int __prioceiling) ++ __THROW __nonnull ((1)); + + + /* Return the value of the protocol attribute in *ATTR in + *PROTOCOL. */ +-extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict attr, +- int *__restrict protocol); ++extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict __attr, ++ int *__restrict __protocol) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the protocol attribute in *ATTR to PROTOCOL. */ +-extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, +- int protocol); ++extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *__attr, ++ int __protocol) ++ __THROW __nonnull ((1)); + #endif + + + /* Return the value of the process shared attribute in *ATTR in + *PSHARED. */ +-extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict attr, +- int *__restrict pshared); ++extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict __attr, ++ int *__restrict __pshared) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the process shared attribute in *ATTR to + PSHARED. */ +-extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, +- int pshared); ++extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *__attr, ++ int __pshared) ++ __THROW __nonnull ((1)); + + + #if defined __USE_UNIX98 || defined __USE_XOPEN2K8 + /* Return the value of the type attribute in *ATTR in *TYPE. */ +-extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict attr, +- int *__restrict type); ++extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict __attr, ++ int *__restrict __type) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the type attribute in *ATTR to TYPE. */ +-extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, +- int type); ++extern int pthread_mutexattr_settype(pthread_mutexattr_t *__attr, ++ int __type) ++ __THROW __nonnull ((1)); + #endif + + +@@ -323,42 +353,50 @@ extern int pthread_mutexattr_settype(pth + /* Create a mutex with attributes given by ATTR and store it in + *__MUTEX. */ + extern int pthread_mutex_init (struct __pthread_mutex *__restrict __mutex, +- const pthread_mutexattr_t *__restrict attr); ++ const pthread_mutexattr_t *__restrict __attr) ++ __THROW __nonnull ((1)); + + /* Destroy the mutex __MUTEX. */ +-extern int pthread_mutex_destroy (struct __pthread_mutex *__mutex); ++extern int pthread_mutex_destroy (struct __pthread_mutex *__mutex) ++ __THROW __nonnull ((1)); + + /* Wait until lock for MUTEX becomes available and lock it. */ + extern int pthread_mutex_lock (pthread_mutex_t *__mutex); + + /* Try to lock MUTEX. */ +-extern int pthread_mutex_trylock (pthread_mutex_t *__mutex); ++extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) ++ __THROWNL __nonnull ((1)); + + #ifdef __USE_XOPEN2K + /* Try to lock MUTEX, block until *ABSTIME if it is already held. */ +-extern int pthread_mutex_timedlock (struct __pthread_mutex *__restrict mutex, +- const struct timespec *__restrict abstime); ++extern int pthread_mutex_timedlock (struct __pthread_mutex *__restrict __mutex, ++ const struct timespec *__restrict __abstime) ++ __THROWNL __nonnull ((1, 2)); + #endif + + /* Unlock MUTEX. */ +-extern int pthread_mutex_unlock (pthread_mutex_t *__mutex); ++extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) ++ __THROWNL __nonnull ((1)); + + /* Transfer ownership of the mutex MUTEX to the thread TID. The + caller must own the lock. */ +-extern int __pthread_mutex_transfer_np (struct __pthread_mutex *mutex, +- pthread_t tid); ++extern int __pthread_mutex_transfer_np (struct __pthread_mutex *__mutex, ++ pthread_t __tid) ++ __THROWNL __nonnull ((1)); + + + #ifdef __USE_UNIX98 + /* Return the priority ceiling of mutex *MUTEX in *PRIOCEILING. */ +-extern int pthread_mutex_getprioceiling (const pthread_mutex_t *__restrict mutex, +- int *__restrict prioceiling); ++extern int pthread_mutex_getprioceiling (const pthread_mutex_t *__restrict __mutex, ++ int *__restrict __prioceiling) ++ __THROW __nonnull ((1, 2)); + + /* After acquiring the mutex *MUTEX, set its priority ceiling to PRIO + and return the old priority ceiling in *OLDPRIO. Before returning, + release the mutex. */ +-extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict mutex, +- int prio, int *__restrict oldprio); ++extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, ++ int __prio, int *__restrict __oldprio) ++ __THROW __nonnull ((1, 3)); + #endif + + +@@ -369,32 +407,38 @@ extern int pthread_mutex_setprioceiling + + /* Initialize the condition attribute in *ATTR to the default + values. */ +-extern int pthread_condattr_init (pthread_condattr_t *attr); ++extern int pthread_condattr_init (pthread_condattr_t *__attr) ++ __THROW __nonnull ((1)); + + /* Destroy the condition attribute structure in *ATTR. */ +-extern int pthread_condattr_destroy (pthread_condattr_t *attr); ++extern int pthread_condattr_destroy (pthread_condattr_t *__attr) ++ __THROW __nonnull ((1)); + + + #ifdef __USE_XOPEN2K + /* Return the value of the clock attribute in *ATTR in *CLOCK_ID. */ +-extern int pthread_condattr_getclock (const pthread_condattr_t *__restrict attr, +- __clockid_t *__restrict clock_id); ++extern int pthread_condattr_getclock (const pthread_condattr_t *__restrict __attr, ++ __clockid_t *__restrict __clock_id) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the clock attribute in *ATTR to CLOCK_ID. */ +-extern int pthread_condattr_setclock (pthread_condattr_t *attr, +- __clockid_t clock_id); ++extern int pthread_condattr_setclock (pthread_condattr_t *__attr, ++ __clockid_t __clock_id) ++ __THROW __nonnull ((1)); + #endif + + + /* Return the value of the process shared attribute in *ATTR in + *PSHARED. */ +-extern int pthread_condattr_getpshared (const pthread_condattr_t *__restrict attr, +- int *__restrict pshared); ++extern int pthread_condattr_getpshared (const pthread_condattr_t *__restrict __attr, ++ int *__restrict __pshared) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the process shared attribute in *ATTR to + PSHARED. */ +-extern int pthread_condattr_setpshared (pthread_condattr_t *attr, +- int pshared); ++extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, ++ int __pshared) ++ __THROW __nonnull ((1)); + + + /* Condition variables. */ +@@ -403,23 +447,28 @@ extern int pthread_condattr_setpshared ( + + #define PTHREAD_COND_INITIALIZER __PTHREAD_COND_INITIALIZER + +-extern int pthread_cond_init (pthread_cond_t *__restrict cond, +- const pthread_condattr_t *__restrict attr); ++extern int pthread_cond_init (pthread_cond_t *__restrict __cond, ++ const pthread_condattr_t *__restrict __attr) ++ __THROW __nonnull ((1)); + +-extern int pthread_cond_destroy (pthread_cond_t *cond); ++extern int pthread_cond_destroy (pthread_cond_t *__cond) ++ __THROW __nonnull ((1)); + + /* Unblock at least one of the threads that are blocked on condition + variable COND. */ +-extern int pthread_cond_signal (pthread_cond_t *__cond); ++extern int pthread_cond_signal (pthread_cond_t *__cond) ++ __THROWNL __nonnull ((1)); + + /* Unblock all threads that are blocked on condition variable COND. */ +-extern int pthread_cond_broadcast (pthread_cond_t *__cond); ++extern int pthread_cond_broadcast (pthread_cond_t *__cond) ++ __THROWNL __nonnull ((1)); + + /* Block on condition variable COND. MUTEX should be held by the + calling thread. On success, MUTEX will be held by the calling + thread. */ + extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, +- pthread_mutex_t *__restrict __mutex); ++ pthread_mutex_t *__restrict __mutex) ++ __nonnull ((1, 2)); + + /* Block on condition variable COND. MUTEX should be held by the + calling thread. On success, MUTEX will be held by the calling +@@ -427,7 +476,8 @@ extern int pthread_cond_wait (pthread_co + returned, and MUTEX will nevertheless be held. */ + extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, +- __const struct timespec *__restrict __abstime); ++ __const struct timespec *__restrict __abstime) ++ __nonnull ((1, 2, 3)); + + + /* Spin locks. */ +@@ -439,22 +489,27 @@ extern int pthread_cond_timedwait (pthre + #define PTHREAD_SPINLOCK_INITIALIZER __PTHREAD_SPIN_LOCK_INITIALIZER + + /* Destroy the spin lock object LOCK. */ +-extern int pthread_spin_destroy (pthread_spinlock_t *__lock); ++extern int pthread_spin_destroy (pthread_spinlock_t *__lock) ++ __THROW __nonnull ((1)); + + /* Initialize the spin lock object LOCK. PSHARED determines whether + the spin lock can be operated upon by multiple processes. */ +-extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared); ++extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) ++ __THROW __nonnull ((1)); + + /* Lock the spin lock object LOCK. If the lock is held by another + thread spin until it becomes available. */ +-extern int pthread_spin_lock (pthread_spinlock_t *__lock); ++extern int pthread_spin_lock (pthread_spinlock_t *__lock) ++ __THROWNL __nonnull ((1)); + + /* Lock the spin lock object LOCK. Fail if the lock is held by + another thread. */ +-extern int pthread_spin_trylock (pthread_spinlock_t *__lock); ++extern int pthread_spin_trylock (pthread_spinlock_t *__lock) ++ __THROWNL __nonnull ((1)); + + /* Unlock the spin lock object LOCK. */ +-extern int pthread_spin_unlock (pthread_spinlock_t *__lock); ++extern int pthread_spin_unlock (pthread_spinlock_t *__lock) ++ __THROWNL __nonnull ((1)); + + # ifdef __USE_EXTERN_INLINES + +@@ -503,21 +558,25 @@ pthread_spin_unlock (pthread_spinlock_t + + /* Initialize rwlock attribute object in *ATTR to the default + values. */ +-extern int pthread_rwlockattr_init (pthread_rwlockattr_t *attr); ++extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) ++ __THROW __nonnull ((1)); + + /* Destroy the rwlock attribute object in *ATTR. */ +-extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr); ++extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) ++ __THROW __nonnull ((1)); + + + /* Return the value of the process shared attribute in *ATTR in + *PSHARED. */ +-extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *__restrict attr, +- int *__restrict pshared); ++extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *__restrict __attr, ++ int *__restrict __pshared) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the process shared atrribute in *ATTR to + PSHARED. */ +-extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, +- int pshared); ++extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, ++ int __pshared) ++ __THROW __nonnull ((1)); + + + /* rwlocks. */ +@@ -527,40 +586,49 @@ extern int pthread_rwlockattr_setpshared + #define PTHREAD_RWLOCK_INITIALIZER __PTHREAD_RWLOCK_INITIALIZER + /* Create a rwlock object with attributes given by ATTR and strore the + result in *RWLOCK. */ +-extern int pthread_rwlock_init (pthread_rwlock_t *__restrict rwlock, +- const pthread_rwlockattr_t *__restrict attr); ++extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, ++ const pthread_rwlockattr_t *__restrict __attr) ++ __THROW __nonnull ((1)); + + /* Destroy the rwlock *RWLOCK. */ +-extern int pthread_rwlock_destroy (pthread_rwlock_t *rwlock); ++extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) ++ __THROW __nonnull ((1)); + + /* Acquire the rwlock *RWLOCK for reading. */ +-extern int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock); ++extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) ++ __THROWNL __nonnull ((1)); + + /* Acquire the rwlock *RWLOCK for reading. */ +-extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock); ++extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) ++ __THROWNL __nonnull ((1)); + + # ifdef __USE_XOPEN2K + /* Acquire the rwlock *RWLOCK for reading blocking until *ABSTIME if + it is already held. */ +-extern int pthread_rwlock_timedrdlock (struct __pthread_rwlock *__restrict rwlock, +- const struct timespec *__restrict abstime); ++extern int pthread_rwlock_timedrdlock (struct __pthread_rwlock *__restrict __rwlock, ++ const struct timespec *__restrict __abstime) ++ __THROWNL __nonnull ((1, 2)); + # endif + + /* Acquire the rwlock *RWLOCK for writing. */ +-extern int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock); ++extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) ++ __THROWNL __nonnull ((1)); + + /* Try to acquire the rwlock *RWLOCK for writing. */ +-extern int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock); ++extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) ++ __THROWNL __nonnull ((1)); + + # ifdef __USE_XOPEN2K + /* Acquire the rwlock *RWLOCK for writing blocking until *ABSTIME if + it is already held. */ +-extern int pthread_rwlock_timedwrlock (struct __pthread_rwlock *__restrict rwlock, +- const struct timespec *__restrict abstime); ++extern int pthread_rwlock_timedwrlock (struct __pthread_rwlock *__restrict __rwlock, ++ const struct timespec *__restrict __abstime) ++ __THROWNL __nonnull ((1, 2)); + # endif + + /* Release the lock held by the current thread on *RWLOCK. */ +-extern int pthread_rwlock_unlock (pthread_rwlock_t *rwlock); ++extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) ++ __THROWNL __nonnull ((1)); + + #endif /* __USE_UNIX98 || __USE_XOPEN2K */ + +@@ -569,10 +637,10 @@ extern int pthread_rwlock_unlock (pthrea + /* Cancelation. */ + + /* Register a cleanup handler. */ +-extern void pthread_cleanup_push (void (*routine) (void *), void *arg); ++extern void pthread_cleanup_push (void (*__routine) (void *), void *__arg); + + /* Unregister a cleanup handler. */ +-extern void pthread_cleanup_pop (int execute); ++extern void pthread_cleanup_pop (int __execute); + + #include <bits/cancelation.h> + +@@ -584,21 +652,21 @@ extern void pthread_cleanup_pop (int exe + + /* Return the calling thread's cancelation state in *OLDSTATE and set + its state to STATE. */ +-extern int pthread_setcancelstate (int state, int *oldstate); ++extern int pthread_setcancelstate (int __state, int *__oldstate); + + #define PTHREAD_CANCEL_DEFERRED 0 + #define PTHREAD_CANCEL_ASYNCHRONOUS 1 + + /* Return the calling thread's cancelation type in *OLDTYPE and set + its type to TYPE. */ +-extern int pthread_setcanceltype (int type, int *oldtype); ++extern int pthread_setcanceltype (int __type, int *__oldtype); + + /* Value returned by pthread_join if the target thread was + canceled. */ + #define PTHREAD_CANCELED ((void *) -1) + + /* Cancel THEAD. */ +-extern int pthread_cancel (pthread_t thread); ++extern int pthread_cancel (pthread_t __thr); + + /* Add an explicit cancelation point. */ + extern void pthread_testcancel (void); +@@ -612,21 +680,25 @@ extern void pthread_testcancel (void); + + /* Initialize barrier attribute object in *ATTR to the default + values. */ +-extern int pthread_barrierattr_init (pthread_barrierattr_t *attr); ++extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) ++ __THROW __nonnull ((1)); + + /* Destroy the barrier attribute object in *ATTR. */ +-extern int pthread_barrierattr_destroy (pthread_barrierattr_t *attr); ++extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) ++ __THROW __nonnull ((1)); + + + /* Return the value of the process shared attribute in *ATTR in + *PSHARED. */ +-extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *__restrict attr, +- int *__restrict pshared); ++extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *__restrict __attr, ++ int *__restrict __pshared) ++ __THROW __nonnull ((1, 2)); + + /* Set the value of the process shared atrribute in *ATTR to + PSHARED. */ +-extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *attr, +- int pshared); ++extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, ++ int __pshared) ++ __THROW __nonnull ((1)); + + + /* Barriers. */ +@@ -638,15 +710,18 @@ extern int pthread_barrierattr_setpshare + #define PTHREAD_BARRIER_SERIAL_THREAD -1 + + /* Initialize barrier BARRIER. */ +-extern int pthread_barrier_init (pthread_barrier_t *__restrict barrier, +- const pthread_barrierattr_t *__restrict attr, +- unsigned count); ++extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, ++ const pthread_barrierattr_t *__restrict __attr, ++ unsigned __count) ++ __THROW __nonnull ((1)); + + /* Destroy barrier BARRIER. */ +-extern int pthread_barrier_destroy (pthread_barrier_t *barrier); ++extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) ++ __THROW __nonnull ((1)); + + /* Wait on barrier BARRIER. */ +-extern int pthread_barrier_wait (pthread_barrier_t *barrier); ++extern int pthread_barrier_wait (pthread_barrier_t *__barrier) ++ __THROWNL __nonnull ((1)); + + #endif /* __USE_XOPEN2K */ + +@@ -659,18 +734,20 @@ extern int pthread_barrier_wait (pthread + /* Create a thread specific data key in KEY visible to all threads. + On thread destruction, DESTRUCTOR shall be called with the thread + specific data associate with KEY if it is not NULL. */ +-extern int pthread_key_create (pthread_key_t *key, +- void (*destructor) (void *)); ++extern int pthread_key_create (pthread_key_t *__key, ++ void (*__destructor) (void *)) ++ __THROW __nonnull ((1)); + + /* Delete the thread specific data key KEY. The associated destructor + function is not called. */ +-extern int pthread_key_delete (pthread_key_t key); ++extern int pthread_key_delete (pthread_key_t __key) __THROW; + + /* Return the caller thread's thread specific value of KEY. */ +-extern void *pthread_getspecific (pthread_key_t key); ++extern void *pthread_getspecific (pthread_key_t __key) __THROW; + + /* Set the caller thread's thread specific value of KEY to VALUE. */ +-extern int pthread_setspecific (pthread_key_t key, const void *value); ++extern int pthread_setspecific (pthread_key_t __key, const void *__value) ++ __THROW; + + + /* Dynamic package initialization. */ +@@ -681,18 +758,18 @@ extern int pthread_setspecific (pthread_ + + /* Call INIT_ROUTINE if this function has never been called with + *ONCE_CONTROL, otherwise do nothing. */ +-extern int pthread_once (pthread_once_t *once_control, +- void (*init_routine) (void)); ++extern int pthread_once (pthread_once_t *__once_control, ++ void (*__init_routine) (void)) __nonnull ((1, 2)); + + + /* Concurrency. */ + + #ifdef __USE_UNIX98 + /* Set the desired concurrency level to NEW_LEVEL. */ +-extern int pthread_setconcurrency (int new_level); ++extern int pthread_setconcurrency (int __new_level) __THROW; + + /* Get the current concurrency level. */ +-extern int pthread_getconcurrency (void); ++extern int pthread_getconcurrency (void) __THROW; + #endif + + +@@ -705,43 +782,46 @@ extern int pthread_getconcurrency (void) + NULL. The prepare handles will be called in the reverse order + which they were registered and the parent and child handlers in the + order in which they were registered. */ +-extern int pthread_atfork (void (*prepare) (void), void (*parent) (void), +- void (*child) (void)); ++extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void), ++ void (*__child) (void)) __THROW; + + + /* Signals (should be in <signal.h>). */ + + /* Send signal SIGNO to thread THREAD. */ +-extern int pthread_kill (pthread_t thread, int signo); ++extern int pthread_kill (pthread_t __thr, int __signo) __THROW; + + + /* Time. */ + + #ifdef __USE_XOPEN2K + /* Return the thread cpu clock. */ +-extern int pthread_getcpuclockid (pthread_t thread, __clockid_t *clock); ++extern int pthread_getcpuclockid (pthread_t __thr, __clockid_t *__clock) ++ __THROW __nonnull ((2)); + #endif + + + /* Scheduling. */ + + /* Return thread THREAD's scheduling paramters. */ +-extern int pthread_getschedparam (pthread_t thread, int *__restrict policy, +- struct sched_param *__restrict param); ++extern int pthread_getschedparam (pthread_t __thr, int *__restrict __policy, ++ struct sched_param *__restrict __param) ++ __THROW __nonnull ((2, 3)); + + /* Set thread THREAD's scheduling paramters. */ +-extern int pthread_setschedparam (pthread_t thread, int policy, +- const struct sched_param *param); ++extern int pthread_setschedparam (pthread_t __thr, int __policy, ++ const struct sched_param *__param) ++ __THROW __nonnull ((3)); + + /* Set thread THREAD's scheduling priority. */ +-extern int pthread_setschedprio (pthread_t thread, int prio); ++extern int pthread_setschedprio (pthread_t __thr, int __prio) __THROW; + + #ifdef __USE_GNU + /* Yield the processor to another thread or process. + This function is similar to the POSIX `sched_yield' function but + might be differently implemented in the case of a m-on-n thread + implementation. */ +-extern int pthread_yield (void); ++extern int pthread_yield (void) __THROW; + #endif + + +--- a/libpthread/sysdeps/mach/hurd/bits/pthread-np.h ++++ b/libpthread/sysdeps/mach/hurd/bits/pthread-np.h +@@ -33,6 +33,6 @@ extern int pthread_hurd_cond_wait_np (pt + See hurd_thread_cancel. */ + extern int pthread_hurd_cond_timedwait_np (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, +- const struct timespec *abstime); ++ const struct timespec *__abstime); + + #endif /* bits/pthread-np.h */ Modified: glibc-package/trunk/debian/patches/series =================================================================== --- glibc-package/trunk/debian/patches/series 2015-12-05 14:47:32 UTC (rev 6776) +++ glibc-package/trunk/debian/patches/series 2015-12-06 00:34:38 UTC (rev 6777) @@ -166,6 +166,7 @@ hurd-i386/cvs-cache-mach_host_self.diff hurd-i386/local-mach_print.diff hurd-i386/cvs-hidden.diff +hurd-i386/cvs-libpthread-api.diff i386/local-biarch.diff i386/local-cmov.diff