summaryrefslogtreecommitdiff
path: root/libpthread/linuxthreads/pthread.c
diff options
context:
space:
mode:
Diffstat (limited to 'libpthread/linuxthreads/pthread.c')
-rw-r--r--libpthread/linuxthreads/pthread.c1318
1 files changed, 768 insertions, 550 deletions
diff --git a/libpthread/linuxthreads/pthread.c b/libpthread/linuxthreads/pthread.c
index 00197b158..5dccd939f 100644
--- a/libpthread/linuxthreads/pthread.c
+++ b/libpthread/linuxthreads/pthread.c
@@ -1,3 +1,4 @@
+
/* Linuxthreads - a simple clone()-based implementation of Posix */
/* threads for Linux. */
/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
@@ -15,7 +16,6 @@
/* Thread creation, initialization, and basic low-level routines */
#include <errno.h>
-#include <netdb.h> /* for h_errno */
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
@@ -24,176 +24,134 @@
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/resource.h>
+#include <sys/time.h>
#include "pthread.h"
#include "internals.h"
#include "spinlock.h"
#include "restart.h"
-#include "debug.h" /* added to linuxthreads -StS */
-
-
-/* Mods for uClibc: Some includes */
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/syscall.h>
+#include "smp.h"
+#include <not-cancel.h>
-libpthread_hidden_proto(waitpid)
-libpthread_hidden_proto(raise)
+/* Sanity check. */
+#if !defined __SIGRTMIN || (__SIGRTMAX - __SIGRTMIN) < 3
+# error "This must not happen"
+#endif
+#ifndef __UCLIBC_HAS_TLS__
/* These variables are used by the setup code. */
extern int _errno;
extern int _h_errno;
+# if defined __UCLIBC_HAS_RESOLVER_SUPPORT__
+/* We need the global/static resolver state here. */
+# include <resolv.h>
+# undef _res
+extern struct __res_state *__resp;
+# endif
+#endif
+
+#ifdef __UCLIBC_HAS_TLS__
+
+/* We need only a few variables. */
+#define manager_thread __pthread_manager_threadp
+pthread_descr __pthread_manager_threadp attribute_hidden;
+
+#else
/* Descriptor of the initial thread */
struct _pthread_descr_struct __pthread_initial_thread = {
- &__pthread_initial_thread, /* pthread_descr p_nextlive */
- &__pthread_initial_thread, /* pthread_descr p_prevlive */
- NULL, /* pthread_descr p_nextwaiting */
- NULL, /* pthread_descr p_nextlock */
- PTHREAD_THREADS_MAX, /* pthread_t p_tid */
- 0, /* int p_pid */
- 0, /* int p_priority */
- &__pthread_handles[0].h_lock, /* struct _pthread_fastlock * p_lock */
- 0, /* int p_signal */
- NULL, /* sigjmp_buf * p_signal_buf */
- NULL, /* sigjmp_buf * p_cancel_buf */
- 0, /* char p_terminated */
- 0, /* char p_detached */
- 0, /* char p_exited */
- NULL, /* void * p_retval */
- 0, /* int p_retval */
- NULL, /* pthread_descr p_joining */
- NULL, /* struct _pthread_cleanup_buffer * p_cleanup */
- 0, /* char p_cancelstate */
- 0, /* char p_canceltype */
- 0, /* char p_canceled */
- &_errno, /* int *p_errnop */
- 0, /* int p_errno */
- &_h_errno, /* int *p_h_errnop */
- 0, /* int p_h_errno */
- NULL, /* char * p_in_sighandler */
- 0, /* char p_sigwaiting */
- PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
- {NULL}, /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */
- {NULL}, /* void * p_libc_specific[_LIBC_TSD_KEY_N] */
- 0, /* int p_userstack */
- NULL, /* void * p_guardaddr */
- 0, /* size_t p_guardsize */
- &__pthread_initial_thread, /* pthread_descr p_self */
- 0, /* Always index 0 */
- 0, /* int p_report_events */
- {{{0, }}, 0, NULL}, /* td_eventbuf_t p_eventbuf */
- __ATOMIC_INITIALIZER, /* struct pthread_atomic p_resume_count */
- 0, /* char p_woken_by_cancel */
- 0, /* char p_condvar_avail */
- 0, /* char p_sem_avail */
- NULL, /* struct pthread_extricate_if *p_extricate */
- NULL, /* pthread_readlock_info *p_readlock_list; */
- NULL, /* pthread_readlock_info *p_readlock_free; */
- 0 /* int p_untracked_readlock_count; */
-#ifdef __UCLIBC_HAS_XLOCALE__
- ,
- &__global_locale_data, /* __locale_t locale; */
-#endif /* __UCLIBC_HAS_XLOCALE__ */
+ .p_header.data.self = &__pthread_initial_thread,
+ .p_nextlive = &__pthread_initial_thread,
+ .p_prevlive = &__pthread_initial_thread,
+ .p_tid = PTHREAD_THREADS_MAX,
+ .p_lock = &__pthread_handles[0].h_lock,
+ .p_start_args = PTHREAD_START_ARGS_INITIALIZER(NULL),
+#ifndef __UCLIBC_HAS_TLS__
+ .p_errnop = &_errno,
+ .p_h_errnop = &_h_errno,
+#endif
+ .p_userstack = 1,
+ .p_resume_count = __ATOMIC_INITIALIZER,
+ .p_alloca_cutoff = __MAX_ALLOCA_CUTOFF
};
/* Descriptor of the manager thread; none of this is used but the error
variables, the p_pid and p_priority fields,
and the address for identification. */
+
#define manager_thread (&__pthread_manager_thread)
struct _pthread_descr_struct __pthread_manager_thread = {
- NULL, /* pthread_descr p_nextlive */
- NULL, /* pthread_descr p_prevlive */
- NULL, /* pthread_descr p_nextwaiting */
- NULL, /* pthread_descr p_nextlock */
- 0, /* int p_tid */
- 0, /* int p_pid */
- 0, /* int p_priority */
- &__pthread_handles[1].h_lock, /* struct _pthread_fastlock * p_lock */
- 0, /* int p_signal */
- NULL, /* sigjmp_buf * p_signal_buf */
- NULL, /* sigjmp_buf * p_cancel_buf */
- 0, /* char p_terminated */
- 0, /* char p_detached */
- 0, /* char p_exited */
- NULL, /* void * p_retval */
- 0, /* int p_retval */
- NULL, /* pthread_descr p_joining */
- NULL, /* struct _pthread_cleanup_buffer * p_cleanup */
- 0, /* char p_cancelstate */
- 0, /* char p_canceltype */
- 0, /* char p_canceled */
- &__pthread_manager_thread.p_errno, /* int *p_errnop */
- 0, /* int p_errno */
- NULL, /* int *p_h_errnop */
- 0, /* int p_h_errno */
- NULL, /* char * p_in_sighandler */
- 0, /* char p_sigwaiting */
- PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
- {NULL}, /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */
- {NULL}, /* void * p_libc_specific[_LIBC_TSD_KEY_N] */
- 0, /* int p_userstack */
- NULL, /* void * p_guardaddr */
- 0, /* size_t p_guardsize */
- &__pthread_manager_thread, /* pthread_descr p_self */
- 1, /* Always index 1 */
- 0, /* int p_report_events */
- {{{0, }}, 0, NULL}, /* td_eventbuf_t p_eventbuf */
- __ATOMIC_INITIALIZER, /* struct pthread_atomic p_resume_count */
- 0, /* char p_woken_by_cancel */
- 0, /* char p_condvar_avail */
- 0, /* char p_sem_avail */
- NULL, /* struct pthread_extricate_if *p_extricate */
- NULL, /* pthread_readlock_info *p_readlock_list; */
- NULL, /* pthread_readlock_info *p_readlock_free; */
- 0 /* int p_untracked_readlock_count; */
-#ifdef __UCLIBC_HAS_XLOCALE__
- ,
- &__global_locale_data, /* __locale_t locale; */
-#endif /* __UCLIBC_HAS_XLOCALE__ */
+ .p_header.data.self = &__pthread_manager_thread,
+ .p_header.data.multiple_threads = 1,
+ .p_lock = &__pthread_handles[1].h_lock,
+ .p_start_args = PTHREAD_START_ARGS_INITIALIZER(__pthread_manager),
+#ifndef __UCLIBC_HAS_TLS__
+ .p_errnop = &__pthread_manager_thread.p_errno,
+#endif
+ .p_nr = 1,
+ .p_resume_count = __ATOMIC_INITIALIZER,
+ .p_alloca_cutoff = PTHREAD_STACK_MIN / 4
};
+#endif
/* Pointer to the main thread (the father of the thread manager thread) */
/* Originally, this is the initial thread, but this changes after fork() */
+#ifdef __UCLIBC_HAS_TLS__
+pthread_descr __pthread_main_thread;
+#else
pthread_descr __pthread_main_thread = &__pthread_initial_thread;
+#endif
/* Limit between the stack of the initial thread (above) and the
stacks of other threads (below). Aligned on a STACK_SIZE boundary. */
-char *__pthread_initial_thread_bos = NULL;
-
-#ifndef __ARCH_USE_MMU__
-/* See nommu notes in internals.h and pthread_initialize() below. */
-char *__pthread_initial_thread_tos = NULL;
-char *__pthread_initial_thread_mid = NULL;
-#endif /* __ARCH_USE_MMU__ */
+char *__pthread_initial_thread_bos;
/* File descriptor for sending requests to the thread manager. */
/* Initially -1, meaning that the thread manager is not running. */
int __pthread_manager_request = -1;
+int __pthread_multiple_threads attribute_hidden;
+
/* Other end of the pipe for sending requests to the thread manager. */
int __pthread_manager_reader;
/* Limits of the thread manager stack */
-char *__pthread_manager_thread_bos = NULL;
-char *__pthread_manager_thread_tos = NULL;
+char *__pthread_manager_thread_bos;
+char *__pthread_manager_thread_tos;
/* For process-wide exit() */
-int __pthread_exit_requested = 0;
-int __pthread_exit_code = 0;
+int __pthread_exit_requested;
+int __pthread_exit_code;
+
+/* Maximum stack size. */
+size_t __pthread_max_stacksize;
+
+/* Nozero if the machine has more than one processor. */
+int __pthread_smp_kernel;
+
+
+#if !__ASSUME_REALTIME_SIGNALS
+/* Pointers that select new or old suspend/resume functions
+ based on availability of rt signals. */
+
+void (*__pthread_restart)(pthread_descr) = __pthread_restart_old;
+void (*__pthread_suspend)(pthread_descr) = __pthread_suspend_old;
+int (*__pthread_timedsuspend)(pthread_descr, const struct timespec *) = __pthread_timedsuspend_old;
+#endif /* __ASSUME_REALTIME_SIGNALS */
/* Communicate relevant LinuxThreads constants to gdb */
const int __pthread_threads_max = PTHREAD_THREADS_MAX;
const int __pthread_sizeof_handle = sizeof(struct pthread_handle_struct);
-const int __pthread_offsetof_descr = offsetof(struct pthread_handle_struct, h_descr);
+const int __pthread_offsetof_descr = offsetof(struct pthread_handle_struct,
+ h_descr);
const int __pthread_offsetof_pid = offsetof(struct _pthread_descr_struct,
p_pid);
const int __linuxthreads_pthread_sizeof_descr
@@ -204,72 +162,53 @@ const int __linuxthreads_initial_report_events;
const char __linuxthreads_version[] = VERSION;
/* Forward declarations */
+
static void pthread_onexit_process(int retcode, void *arg);
+#ifndef HAVE_Z_NODELETE
+static void pthread_atexit_process(void *arg, int retcode);
+static void pthread_atexit_retcode(void *arg, int retcode);
+#endif
static void pthread_handle_sigcancel(int sig);
static void pthread_handle_sigrestart(int sig);
static void pthread_handle_sigdebug(int sig);
-int __pthread_timedsuspend_new(pthread_descr self, const struct timespec *abstime);
/* Signal numbers used for the communication.
In these variables we keep track of the used variables. If the
platform does not support any real-time signals we will define the
values to some unreasonable value which will signal failing of all
the functions below. */
-#ifndef __NR_rt_sigaction
-static int current_rtmin = -1;
-static int current_rtmax = -1;
-int __pthread_sig_restart = SIGUSR1;
-int __pthread_sig_cancel = SIGUSR2;
-int __pthread_sig_debug;
-#else
-
-#if __SIGRTMAX - __SIGRTMIN >= 3
-static int current_rtmin = __SIGRTMIN + 3;
-static int current_rtmax = __SIGRTMAX;
int __pthread_sig_restart = __SIGRTMIN;
int __pthread_sig_cancel = __SIGRTMIN + 1;
int __pthread_sig_debug = __SIGRTMIN + 2;
-void (*__pthread_restart)(pthread_descr) = __pthread_restart_new;
-void (*__pthread_suspend)(pthread_descr) = __pthread_wait_for_restart_signal;
-int (*__pthread_timedsuspend)(pthread_descr, const struct timespec *) = __pthread_timedsuspend_new;
-#else
-static int current_rtmin = __SIGRTMIN;
-static int current_rtmax = __SIGRTMAX;
-int __pthread_sig_restart = SIGUSR1;
-int __pthread_sig_cancel = SIGUSR2;
-int __pthread_sig_debug;
-void (*__pthread_restart)(pthread_descr) = __pthread_restart_old;
-void (*__pthread_suspend)(pthread_descr) = __pthread_suspend_old;
-int (*__pthread_timedsuspend)(pthread_descr, const struct timespec *) = __pthread_timedsuspend_old;
-#endif
+extern int __libc_current_sigrtmin_private (void);
-/* Return number of available real-time signal with highest priority. */
-int __libc_current_sigrtmin (void)
-{
- return current_rtmin;
-}
+#if !__ASSUME_REALTIME_SIGNALS
+static int rtsigs_initialized;
-/* Return number of available real-time signal with lowest priority. */
-int __libc_current_sigrtmax (void)
+static void
+init_rtsigs (void)
{
- return current_rtmax;
-}
+ if (rtsigs_initialized)
+ return;
-#if 0
-/* Allocate real-time signal with highest/lowest available
- priority. Please note that we don't use a lock since we assume
- this function to be called at program start. */
-int __libc_allocate_rtsig (int high);
-int __libc_allocate_rtsig (int high)
-{
- if (current_rtmin == -1 || current_rtmin > current_rtmax)
- /* We don't have anymore signal available. */
- return -1;
- return high ? current_rtmin++ : current_rtmax--;
+ if (__libc_current_sigrtmin_private () == -1)
+ {
+ __pthread_sig_restart = SIGUSR1;
+ __pthread_sig_cancel = SIGUSR2;
+ __pthread_sig_debug = 0;
+ }
+ else
+ {
+ __pthread_restart = __pthread_restart_new;
+ __pthread_suspend = __pthread_wait_for_restart_signal;
+ __pthread_timedsuspend = __pthread_timedsuspend_new;
+ }
+
+ rtsigs_initialized = 1;
}
#endif
-#endif
+
/* Initialize the pthread library.
Initialization is split in two functions:
@@ -280,40 +219,14 @@ int __libc_allocate_rtsig (int high)
static void pthread_initialize(void) __attribute__((constructor));
-libpthread_hidden_proto(pthread_attr_destroy)
-libpthread_hidden_proto(pthread_attr_init)
-libpthread_hidden_proto(pthread_attr_getdetachstate)
-libpthread_hidden_proto(pthread_attr_setdetachstate)
-libpthread_hidden_proto(pthread_attr_getinheritsched)
-libpthread_hidden_proto(pthread_attr_setinheritsched)
-libpthread_hidden_proto(pthread_attr_setschedparam)
-libpthread_hidden_proto(pthread_attr_getschedparam)
-libpthread_hidden_proto(pthread_attr_getschedpolicy)
-libpthread_hidden_proto(pthread_attr_setschedpolicy)
-libpthread_hidden_proto(pthread_attr_getscope)
-libpthread_hidden_proto(pthread_attr_setscope)
-
-libpthread_hidden_proto(pthread_exit)
-
-libpthread_hidden_proto(pthread_equal)
-libpthread_hidden_proto(pthread_self)
-libpthread_hidden_proto(pthread_getschedparam)
-libpthread_hidden_proto(pthread_setschedparam)
-
-libpthread_hidden_proto(pthread_setcancelstate)
-libpthread_hidden_proto(pthread_setcanceltype)
-libpthread_hidden_proto(_pthread_cleanup_push_defer)
-libpthread_hidden_proto(_pthread_cleanup_pop_restore)
-
-libpthread_hidden_proto(pthread_cond_broadcast)
-libpthread_hidden_proto(pthread_cond_destroy)
-libpthread_hidden_proto(pthread_cond_init)
-libpthread_hidden_proto(pthread_cond_signal)
-libpthread_hidden_proto(pthread_cond_wait)
-libpthread_hidden_proto(pthread_cond_timedwait)
-
-libpthread_hidden_proto(pthread_condattr_destroy)
-libpthread_hidden_proto(pthread_condattr_init)
+#ifndef HAVE_Z_NODELETE
+extern void *__dso_handle __attribute__ ((weak));
+#endif
+
+
+#if defined __UCLIBC_HAS_TLS__ && !defined SHARED
+extern void __libc_setup_tls (size_t tcbsize, size_t tcbalign);
+#endif
struct pthread_functions __pthread_functions =
{
@@ -322,53 +235,49 @@ struct pthread_functions __pthread_functions =
.ptr_pthread_internal_tsd_get = __pthread_internal_tsd_get,
.ptr_pthread_internal_tsd_address = __pthread_internal_tsd_address,
#endif
-/*
.ptr_pthread_fork = __pthread_fork,
-*/
- .ptr_pthread_attr_destroy = pthread_attr_destroy,
- .ptr_pthread_attr_init = pthread_attr_init,
- .ptr_pthread_attr_getdetachstate = pthread_attr_getdetachstate,
- .ptr_pthread_attr_setdetachstate = pthread_attr_setdetachstate,
- .ptr_pthread_attr_getinheritsched = pthread_attr_getinheritsched,
- .ptr_pthread_attr_setinheritsched = pthread_attr_setinheritsched,
- .ptr_pthread_attr_getschedparam = pthread_attr_getschedparam,
- .ptr_pthread_attr_setschedparam = pthread_attr_setschedparam,
- .ptr_pthread_attr_getschedpolicy = pthread_attr_getschedpolicy,
- .ptr_pthread_attr_setschedpolicy = pthread_attr_setschedpolicy,
- .ptr_pthread_attr_getscope = pthread_attr_getscope,
- .ptr_pthread_attr_setscope = pthread_attr_setscope,
- .ptr_pthread_condattr_destroy = pthread_condattr_destroy,
- .ptr_pthread_condattr_init = pthread_condattr_init,
- .ptr_pthread_cond_broadcast = pthread_cond_broadcast,
- .ptr_pthread_cond_destroy = pthread_cond_destroy,
- .ptr_pthread_cond_init = pthread_cond_init,
- .ptr_pthread_cond_signal = pthread_cond_signal,
- .ptr_pthread_cond_wait = pthread_cond_wait,
- .ptr_pthread_cond_timedwait = pthread_cond_timedwait,
- .ptr_pthread_equal = pthread_equal,
- .ptr___pthread_exit = pthread_exit,
- .ptr_pthread_getschedparam = pthread_getschedparam,
- .ptr_pthread_setschedparam = pthread_setschedparam,
+ .ptr_pthread_attr_destroy = __pthread_attr_destroy,
+ .ptr_pthread_attr_init = __pthread_attr_init,
+ .ptr_pthread_attr_getdetachstate = __pthread_attr_getdetachstate,
+ .ptr_pthread_attr_setdetachstate = __pthread_attr_setdetachstate,
+ .ptr_pthread_attr_getinheritsched = __pthread_attr_getinheritsched,
+ .ptr_pthread_attr_setinheritsched = __pthread_attr_setinheritsched,
+ .ptr_pthread_attr_getschedparam = __pthread_attr_getschedparam,
+ .ptr_pthread_attr_setschedparam = __pthread_attr_setschedparam,
+ .ptr_pthread_attr_getschedpolicy = __pthread_attr_getschedpolicy,
+ .ptr_pthread_attr_setschedpolicy = __pthread_attr_setschedpolicy,
+ .ptr_pthread_attr_getscope = __pthread_attr_getscope,
+ .ptr_pthread_attr_setscope = __pthread_attr_setscope,
+ .ptr_pthread_condattr_destroy = __pthread_condattr_destroy,
+ .ptr_pthread_condattr_init = __pthread_condattr_init,
+ .ptr_pthread_cond_broadcast = __pthread_cond_broadcast,
+ .ptr_pthread_cond_destroy = __pthread_cond_destroy,
+ .ptr_pthread_cond_init = __pthread_cond_init,
+ .ptr_pthread_cond_signal = __pthread_cond_signal,
+ .ptr_pthread_cond_wait = __pthread_cond_wait,
+ .ptr_pthread_cond_timedwait = __pthread_cond_timedwait,
+ .ptr_pthread_equal = __pthread_equal,
+ .ptr___pthread_exit = __pthread_exit,
+ .ptr_pthread_getschedparam = __pthread_getschedparam,
+ .ptr_pthread_setschedparam = __pthread_setschedparam,
.ptr_pthread_mutex_destroy = __pthread_mutex_destroy,
.ptr_pthread_mutex_init = __pthread_mutex_init,
.ptr_pthread_mutex_lock = __pthread_mutex_lock,
.ptr_pthread_mutex_trylock = __pthread_mutex_trylock,
.ptr_pthread_mutex_unlock = __pthread_mutex_unlock,
- .ptr_pthread_self = pthread_self,
- .ptr_pthread_setcancelstate = pthread_setcancelstate,
- .ptr_pthread_setcanceltype = pthread_setcanceltype,
-/*
- .ptr_pthread_do_exit = pthread_do_exit,
- .ptr_pthread_thread_self = pthread_thread_self,
- .ptr_pthread_cleanup_upto = pthread_cleanup_upto,
- .ptr_pthread_sigaction = pthread_sigaction,
- .ptr_pthread_sigwait = pthread_sigwait,
- .ptr_pthread_raise = pthread_raise,
+ .ptr_pthread_self = __pthread_self,
+ .ptr_pthread_setcancelstate = __pthread_setcancelstate,
+ .ptr_pthread_setcanceltype = __pthread_setcanceltype,
+ .ptr_pthread_do_exit = __pthread_do_exit,
+ .ptr_pthread_thread_self = __pthread_thread_self,
+ .ptr_pthread_cleanup_upto = __pthread_cleanup_upto,
+ .ptr_pthread_sigaction = __pthread_sigaction,
+ .ptr_pthread_sigwait = __pthread_sigwait,
+ .ptr_pthread_raise = __pthread_raise,
.ptr__pthread_cleanup_push = _pthread_cleanup_push,
+ .ptr__pthread_cleanup_push_defer = _pthread_cleanup_push_defer,
.ptr__pthread_cleanup_pop = _pthread_cleanup_pop,
-*/
- .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer,
- .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore
+ .ptr__pthread_cleanup_pop_restore = _pthread_cleanup_pop_restore,
};
#ifdef SHARED
# define ptr_pthread_functions &__pthread_functions
@@ -378,28 +287,224 @@ struct pthread_functions __pthread_functions =
static int *__libc_multiple_threads_ptr;
- /* Do some minimal initialization which has to be done during the
- startup of the C library. */
-void __pthread_initialize_minimal(void)
+/* Do some minimal initialization which has to be done during the
+ startup of the C library. */
+void
+__pthread_initialize_minimal(void)
{
- /* If we have special thread_self processing, initialize
- * that for the main thread now. */
-#ifdef INIT_THREAD_SELF
- INIT_THREAD_SELF(&__pthread_initial_thread, 0);
+#ifdef __UCLIBC_HAS_TLS__
+ pthread_descr self;
+
+ /* First of all init __pthread_handles[0] and [1] if needed. */
+# if __LT_SPINLOCK_INIT != 0
+ __pthread_handles[0].h_lock = __LOCK_INITIALIZER;
+ __pthread_handles[1].h_lock = __LOCK_INITIALIZER;
+# endif
+# ifndef SHARED
+ /* Unlike in the dynamically linked case the dynamic linker has not
+ taken care of initializing the TLS data structures. */
+ __libc_setup_tls (TLS_TCB_SIZE, TLS_TCB_ALIGN);
+# elif !defined __UCLIBC_HAS_TLS__
+ if (__builtin_expect (GL(dl_tls_dtv_slotinfo_list) == NULL, 0))
+ {
+ tcbhead_t *tcbp;
+
+ /* There is no actual TLS being used, so the thread register
+ was not initialized in the dynamic linker. */
+
+ /* We need to install special hooks so that the malloc and memalign
+ calls in _dl_tls_setup and _dl_allocate_tls won't cause full
+ malloc initialization that will try to set up its thread state. */
+
+ extern void __libc_malloc_pthread_startup (bool first_time);
+ __libc_malloc_pthread_startup (true);
+
+ if (__builtin_expect (_dl_tls_setup (), 0)
+ || __builtin_expect ((tcbp = _dl_allocate_tls (NULL)) == NULL, 0))
+ {
+ static const char msg[] = "\
+cannot allocate TLS data structures for initial thread\n";
+ TEMP_FAILURE_RETRY (write_not_cancel (STDERR_FILENO,
+ msg, sizeof msg - 1));
+ abort ();
+ }
+ const char *lossage = TLS_INIT_TP (tcbp, 0);
+ if (__builtin_expect (lossage != NULL, 0))
+ {
+ static const char msg[] = "cannot set up thread-local storage: ";
+ const char nl = '\n';
+ TEMP_FAILURE_RETRY (write_not_cancel (STDERR_FILENO,
+ msg, sizeof msg - 1));
+ TEMP_FAILURE_RETRY (write_not_cancel (STDERR_FILENO,
+ lossage, strlen (lossage)));
+ TEMP_FAILURE_RETRY (write_not_cancel (STDERR_FILENO, &nl, 1));
+ }
+
+ /* Though it was allocated with libc's malloc, that was done without
+ the user's __malloc_hook installed. A later realloc that uses
+ the hooks might not work with that block from the plain malloc.
+ So we record this block as unfreeable just as the dynamic linker
+ does when it allocates the DTV before the libc malloc exists. */
+ GL(dl_initial_dtv) = GET_DTV (tcbp);
+
+ __libc_malloc_pthread_startup (false);
+ }
+# endif
+
+ self = THREAD_SELF;
+
+ /* The memory for the thread descriptor was allocated elsewhere as
+ part of the TLS allocation. We have to initialize the data
+ structure by hand. This initialization must mirror the struct
+ definition above. */
+ self->p_nextlive = self->p_prevlive = self;
+ self->p_tid = PTHREAD_THREADS_MAX;
+ self->p_lock = &__pthread_handles[0].h_lock;
+# ifndef __UCLIBC_HAS_TLS__
+ self->p_errnop = &_errno;
+ self->p_h_errnop = &_h_errno;
+# endif
+ /* self->p_start_args need not be initialized, it's all zero. */
+ self->p_userstack = 1;
+# if __LT_SPINLOCK_INIT != 0
+ self->p_resume_count = (struct pthread_atomic) __ATOMIC_INITIALIZER;
+# endif
+ self->p_alloca_cutoff = __MAX_ALLOCA_CUTOFF;
+
+ /* Another variable which points to the thread descriptor. */
+ __pthread_main_thread = self;
+
+ /* And fill in the pointer the the thread __pthread_handles array. */
+ __pthread_handles[0].h_descr = self;
+
+#else /* __UCLIBC_HAS_TLS__ */
+
+ /* First of all init __pthread_handles[0] and [1]. */
+# if __LT_SPINLOCK_INIT != 0
+ __pthread_handles[0].h_lock = __LOCK_INITIALIZER;
+ __pthread_handles[1].h_lock = __LOCK_INITIALIZER;
+# endif
+ __pthread_handles[0].h_descr = &__pthread_initial_thread;
+ __pthread_handles[1].h_descr = &__pthread_manager_thread;
+
+ /* If we have special thread_self processing, initialize that for the
+ main thread now. */
+# ifdef INIT_THREAD_SELF
+ INIT_THREAD_SELF(&__pthread_initial_thread, 0);
+# endif
+#endif
+
+#if HP_TIMING_AVAIL
+# ifdef __UCLIBC_HAS_TLS__
+ self->p_cpuclock_offset = GL(dl_cpuclock_offset);
+# else
+ __pthread_initial_thread.p_cpuclock_offset = GL(dl_cpuclock_offset);
+# endif
#endif
- __libc_multiple_threads_ptr = __libc_pthread_init (ptr_pthread_functions);
+ __libc_multiple_threads_ptr = __libc_pthread_init (ptr_pthread_functions);
}
+void
+__pthread_init_max_stacksize(void)
+{
+ struct rlimit limit;
+ size_t max_stack;
+
+ getrlimit(RLIMIT_STACK, &limit);
+#ifdef FLOATING_STACKS
+ if (limit.rlim_cur == RLIM_INFINITY)
+ limit.rlim_cur = ARCH_STACK_MAX_SIZE;
+# ifdef NEED_SEPARATE_REGISTER_STACK
+ max_stack = limit.rlim_cur / 2;
+# else
+ max_stack = limit.rlim_cur;
+# endif
+#else
+ /* Play with the stack size limit to make sure that no stack ever grows
+ beyond STACK_SIZE minus one page (to act as a guard page). */
+# ifdef NEED_SEPARATE_REGISTER_STACK
+ /* STACK_SIZE bytes hold both the main stack and register backing
+ store. The rlimit value applies to each individually. */
+ max_stack = STACK_SIZE/2 - __getpagesize ();
+# else
+ max_stack = STACK_SIZE - __getpagesize();
+# endif
+ if (limit.rlim_cur > max_stack) {
+ limit.rlim_cur = max_stack;
+ setrlimit(RLIMIT_STACK, &limit);
+ }
+#endif
+ __pthread_max_stacksize = max_stack;
+ if (max_stack / 4 < __MAX_ALLOCA_CUTOFF)
+ {
+#ifdef __UCLIBC_HAS_TLS__
+ pthread_descr self = THREAD_SELF;
+ self->p_alloca_cutoff = max_stack / 4;
+#else
+ __pthread_initial_thread.p_alloca_cutoff = max_stack / 4;
+#endif
+ }
+}
+
+#if defined SHARED && defined __UCLIBC_HAS_TLS__
+# ifdef __UCLIBC_HAS_TLS__
+/* When using __thread for this, we do it in libc so as not
+ to give libpthread its own TLS segment just for this. */
+extern void **__libc_dl_error_tsd (void) __attribute__ ((const));
+# else
+static void ** __attribute__ ((const))
+__libc_dl_error_tsd (void)
+{
+ return &thread_self ()->p_libc_specific[_LIBC_TSD_KEY_DL_ERROR];
+}
+# endif
+#endif
+
+#ifdef __UCLIBC_HAS_TLS__
+static __inline__ void __attribute__((always_inline))
+init_one_static_tls (pthread_descr descr, struct link_map *map)
+{
+# if defined(TLS_TCB_AT_TP)
+ dtv_t *dtv = GET_DTV (descr);
+ void *dest = (char *) descr - map->l_tls_offset;
+# elif defined(TLS_DTV_AT_TP)
+ dtv_t *dtv = GET_DTV ((pthread_descr) ((char *) descr + TLS_PRE_TCB_SIZE));
+ void *dest = (char *) descr + map->l_tls_offset + TLS_PRE_TCB_SIZE;
+# else
+# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
+# endif
+
+ /* Fill in the DTV slot so that a later LD/GD access will find it. */
+ dtv[map->l_tls_modid].pointer.val = dest;
+ dtv[map->l_tls_modid].pointer.is_static = true;
+
+ /* Initialize the memory. */
+ memset (mempcpy (dest, map->l_tls_initimage, map->l_tls_initimage_size),
+ '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
+}
+
+static void
+__pthread_init_static_tls (struct link_map *map)
+{
+ size_t i;
+
+ for (i = 0; i < PTHREAD_THREADS_MAX; ++i)
+ if (__pthread_handles[i].h_descr != NULL && i != 1)
+ {
+ __pthread_lock (&__pthread_handles[i].h_lock, NULL);
+ if (__pthread_handles[i].h_descr != NULL)
+ init_one_static_tls (__pthread_handles[i].h_descr, map);
+ __pthread_unlock (&__pthread_handles[i].h_lock);
+ }
+}
+#endif
+
static void pthread_initialize(void)
{
struct sigaction sa;
sigset_t mask;
-#ifdef __ARCH_USE_MMU__
- struct rlimit limit;
- rlim_t max_stack;
-#endif
/* If already done (e.g. by a constructor called earlier!), bail out */
if (__pthread_initial_thread_bos != NULL) return;
@@ -407,70 +512,44 @@ static void pthread_initialize(void)
/* Test if compare-and-swap is available */
__pthread_has_cas = compare_and_swap_is_available();
#endif
+#ifdef FLOATING_STACKS
+ /* We don't need to know the bottom of the stack. Give the pointer some
+ value to signal that initialization happened. */
+ __pthread_initial_thread_bos = (void *) -1l;
+#else
+ /* Determine stack size limits . */
+ __pthread_init_max_stacksize ();
+# ifdef _STACK_GROWS_UP
+ /* The initial thread already has all the stack it needs */
+ __pthread_initial_thread_bos = (char *)
+ ((long)CURRENT_STACK_FRAME &~ (STACK_SIZE - 1));
+# else
/* For the initial stack, reserve at least STACK_SIZE bytes of stack
below the current stack address, and align that on a
STACK_SIZE boundary. */
__pthread_initial_thread_bos =
(char *)(((long)CURRENT_STACK_FRAME - 2 * STACK_SIZE) & ~(STACK_SIZE - 1));
- /* Update the descriptor for the initial thread. */
- __pthread_initial_thread.p_pid = getpid();
- /* If we have special thread_self processing, initialize that for the
- main thread now. */
-#ifdef INIT_THREAD_SELF
- INIT_THREAD_SELF(&__pthread_initial_thread, 0);
+# endif
#endif
- /* The errno/h_errno variable of the main thread are the global ones. */
- __pthread_initial_thread.p_errnop = &_errno;
- __pthread_initial_thread.p_h_errnop = &_h_errno;
-
-#ifdef __UCLIBC_HAS_XLOCALE__
- /* The locale of the main thread is the current locale in use. */
- __pthread_initial_thread.locale = __curlocale_var;
-#endif /* __UCLIBC_HAS_XLOCALE__ */
-
- { /* uClibc-specific stdio initialization for threads. */
- FILE *fp;
-
- _stdio_user_locking = 0; /* 2 if threading not initialized */
- for (fp = _stdio_openlist; fp != NULL; fp = fp->__nextopen) {
- if (fp->__user_locking != 1) {
- fp->__user_locking = 0;
- }
- }
- }
-
- /* Play with the stack size limit to make sure that no stack ever grows
- beyond STACK_SIZE minus two pages (one page for the thread descriptor
- immediately beyond, and one page to act as a guard page). */
-
-#ifdef __ARCH_USE_MMU__
- /* We cannot allocate a huge chunk of memory to mmap all thread stacks later
- * on a non-MMU system. Thus, we don't need the rlimit either. -StS */
- getrlimit(RLIMIT_STACK, &limit);
- max_stack = STACK_SIZE - 2 * getpagesize();
- if (limit.rlim_cur > max_stack) {
- limit.rlim_cur = max_stack;
- setrlimit(RLIMIT_STACK, &limit);
- }
+#ifdef __UCLIBC_HAS_TLS__
+ /* Update the descriptor for the initial thread. */
+ THREAD_SETMEM (((pthread_descr) NULL), p_pid, __getpid());
+# if defined __UCLIBC_HAS_RESOLVER_SUPPORT__
+ /* Likewise for the resolver state _res. */
+ THREAD_SETMEM (((pthread_descr) NULL), p_resp, __resp);
+# endif
#else
- /* For non-MMU, the initial thread stack can reside anywhere in memory.
- * We don't have a way of knowing where the kernel started things -- top
- * or bottom (well, that isn't exactly true, but the solution is fairly
- * complex and error prone). All we can determine here is an address
- * that lies within that stack. Save that address as a reference so that
- * as other thread stacks are created, we can adjust the estimated bounds
- * of the initial thread's stack appropriately.
- *
- * This checking is handled in NOMMU_INITIAL_THREAD_BOUNDS(), so see that
- * for a few more details.
- */
- __pthread_initial_thread_mid = CURRENT_STACK_FRAME;
- __pthread_initial_thread_tos = (char *) -1;
- __pthread_initial_thread_bos = (char *) 1; /* set it non-zero so we know we have been here */
- PDEBUG("initial thread stack bounds: bos=%p, tos=%p\n",
- __pthread_initial_thread_bos, __pthread_initial_thread_tos);
-#endif /* __ARCH_USE_MMU__ */
-
+ /* Update the descriptor for the initial thread. */
+ __pthread_initial_thread.p_pid = __getpid();
+# if defined __UCLIBC_HAS_RESOLVER_SUPPORT__
+ /* Likewise for the resolver state _res. */
+ __pthread_initial_thread.p_resp = __resp;
+# endif
+#endif
+#if !__ASSUME_REALTIME_SIGNALS
+ /* Initialize real-time signals. */
+ init_rtsigs ();
+#endif
/* Setup signal handlers for the initial thread.
Since signal handlers are shared between threads, these settings
will be inherited by all other threads. */
@@ -481,9 +560,9 @@ static void pthread_initialize(void)
sigaddset(&sa.sa_mask, __pthread_sig_restart);
__libc_sigaction(__pthread_sig_cancel, &sa, NULL);
if (__pthread_sig_debug > 0) {
- sa.sa_handler = pthread_handle_sigdebug;
- __sigemptyset(&sa.sa_mask);
- __libc_sigaction(__pthread_sig_debug, &sa, NULL);
+ sa.sa_handler = pthread_handle_sigdebug;
+ __sigemptyset(&sa.sa_mask);
+ __libc_sigaction(__pthread_sig_debug, &sa, NULL);
}
/* Initially, block __pthread_sig_restart. Will be unblocked on demand. */
__sigemptyset(&mask);
@@ -495,11 +574,48 @@ static void pthread_initialize(void)
sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Register an exit function to kill all other threads. */
/* Do it early so that user-registered atexit functions are called
- before pthread_onexit_process. */
- on_exit(pthread_onexit_process, NULL);
+ before pthread_*exit_process. */
+#ifndef HAVE_Z_NODELETE
+ if (__builtin_expect (&__dso_handle != NULL, 1))
+ __cxa_atexit ((void (*) (void *)) pthread_atexit_process, NULL,
+ __dso_handle);
+ else
+#endif
+ __on_exit (pthread_onexit_process, NULL);
+ /* How many processors. */
+ __pthread_smp_kernel = is_smp_system ();
+
+#if defined SHARED && defined __UCLIBC_HAS_TLS__
+ /* Transfer the old value from the dynamic linker's internal location. */
+ *__libc_dl_error_tsd () = *(*GL(dl_error_catch_tsd)) ();
+ GL(dl_error_catch_tsd) = &__libc_dl_error_tsd;
+
+ /* Make __rtld_lock_{,un}lock_recursive use pthread_mutex_{,un}lock,
+ keep the lock count from the ld.so implementation. */
+ GL(dl_rtld_lock_recursive) = (void *) __pthread_mutex_lock;
+ GL(dl_rtld_unlock_recursive) = (void *) __pthread_mutex_unlock;
+ unsigned int rtld_lock_count = GL(dl_load_lock).mutex.__m_count;
+ GL(dl_load_lock).mutex.__m_count = 0;
+ while (rtld_lock_count-- > 0)
+ __pthread_mutex_lock (&GL(dl_load_lock).mutex);
+#endif
+
+#ifdef __UCLIBC_HAS_TLS__
+ GL(dl_init_static_tls) = &__pthread_init_static_tls;
+#endif
+
+ /* uClibc-specific stdio initialization for threads. */
+ {
+ FILE *fp;
+ _stdio_user_locking = 0; /* 2 if threading not initialized */
+ for (fp = _stdio_openlist; fp != NULL; fp = fp->__nextopen) {
+ if (fp->__user_locking != 1) {
+ fp->__user_locking = 0;
+ }
+ }
+ }
}
-void __pthread_initialize(void);
void __pthread_initialize(void)
{
pthread_initialize();
@@ -509,11 +625,27 @@ int __pthread_initialize_manager(void)
{
int manager_pipe[2];
int pid;
- int report_events;
struct pthread_request request;
+ int report_events;
+ pthread_descr mgr;
+#ifdef __UCLIBC_HAS_TLS__
+ tcbhead_t *tcbp;
+#endif
+ __pthread_multiple_threads = 1;
+#if TLS_MULTIPLE_THREADS_IN_TCB || !defined __UCLIBC_HAS_TLS__ || !TLS_DTV_AT_TP
+ __pthread_main_thread->p_multiple_threads = 1;
+#endif
*__libc_multiple_threads_ptr = 1;
+#ifndef HAVE_Z_NODELETE
+ if (__builtin_expect (&__dso_handle != NULL, 1))
+ __cxa_atexit ((void (*) (void *)) pthread_atexit_retcode, NULL,
+ __dso_handle);
+#endif
+
+ if (__pthread_max_stacksize == 0)
+ __pthread_init_max_stacksize ();
/* If basic initialization not done yet (e.g. we're called from a
constructor run before our constructor), do it now */
if (__pthread_initial_thread_bos == NULL) pthread_initialize();
@@ -522,25 +654,59 @@ int __pthread_initialize_manager(void)
if (__pthread_manager_thread_bos == NULL) return -1;
__pthread_manager_thread_tos =
__pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;
-
- /* On non-MMU systems we make sure that the initial thread bounds don't overlap
- * with the manager stack frame */
- NOMMU_INITIAL_THREAD_BOUNDS(__pthread_manager_thread_tos,__pthread_manager_thread_bos);
- PDEBUG("manager stack: size=%ld, bos=%p, tos=%p\n", THREAD_MANAGER_STACK_SIZE,
- __pthread_manager_thread_bos, __pthread_manager_thread_tos);
-#if 0
- PDEBUG("initial stack: estimate bos=%p, tos=%p\n",
- __pthread_initial_thread_bos, __pthread_initial_thread_tos);
-#endif
-
/* Setup pipe to communicate with thread manager */
if (pipe(manager_pipe) == -1) {
free(__pthread_manager_thread_bos);
return -1;
}
+
+#ifdef __UCLIBC_HAS_TLS__
+ /* Allocate memory for the thread descriptor and the dtv. */
+ tcbp = _dl_allocate_tls (NULL);
+ if (tcbp == NULL) {
+ free(__pthread_manager_thread_bos);
+ close_not_cancel(manager_pipe[0]);
+ close_not_cancel(manager_pipe[1]);
+ return -1;
+ }
+
+# if defined(TLS_TCB_AT_TP)
+ mgr = (pthread_descr) tcbp;
+# elif defined(TLS_DTV_AT_TP)
+ /* pthread_descr is located right below tcbhead_t which _dl_allocate_tls
+ returns. */
+ mgr = (pthread_descr) ((char *) tcbp - TLS_PRE_TCB_SIZE);
+# endif
+ __pthread_handles[1].h_descr = manager_thread = mgr;
+
+ /* Initialize the descriptor. */
+#if !defined __UCLIBC_HAS_TLS__ || !TLS_DTV_AT_TP
+ mgr->p_header.data.tcb = tcbp;
+ mgr->p_header.data.self = mgr;
+ mgr->p_header.data.multiple_threads = 1;
+#elif TLS_MULTIPLE_THREADS_IN_TCB
+ mgr->p_multiple_threads = 1;
+#endif
+ mgr->p_lock = &__pthread_handles[1].h_lock;
+# ifndef __UCLIBC_HAS_TLS__
+ mgr->p_errnop = &mgr->p_errno;
+# endif
+ mgr->p_start_args = (struct pthread_start_args) PTHREAD_START_ARGS_INITIALIZER(__pthread_manager);
+ mgr->p_nr = 1;
+# if __LT_SPINLOCK_INIT != 0
+ self->p_resume_count = (struct pthread_atomic) __ATOMIC_INITIALIZER;
+# endif
+ mgr->p_alloca_cutoff = PTHREAD_STACK_MIN / 4;
+#else
+ mgr = &__pthread_manager_thread;
+#endif
+
+ __pthread_manager_request = manager_pipe[1]; /* writing end */
+ __pthread_manager_reader = manager_pipe[0]; /* reading end */
+
/* Start the thread manager */
pid = 0;
-#if defined(USE_TLS) && USE_TLS
+#ifdef __UCLIBC_HAS_TLS__
if (__linuxthreads_initial_report_events != 0)
THREAD_SETMEM (((pthread_descr) NULL), p_report_events,
__linuxthreads_initial_report_events);
@@ -557,25 +723,36 @@ int __pthread_initialize_manager(void)
the manager thread. */
int idx = __td_eventword (TD_CREATE);
uint32_t mask = __td_eventmask (TD_CREATE);
+ uint32_t event_bits;
- if ((mask & (__pthread_threads_events.event_bits[idx]
- | __pthread_initial_thread.p_eventbuf.eventmask.event_bits[idx]))
+#ifdef __UCLIBC_HAS_TLS__
+ event_bits = THREAD_GETMEM_NC (((pthread_descr) NULL),
+ p_eventbuf.eventmask.event_bits[idx]);
+#else
+ event_bits = __pthread_initial_thread.p_eventbuf.eventmask.event_bits[idx];
+#endif
+
+ if ((mask & (__pthread_threads_events.event_bits[idx] | event_bits))
!= 0)
{
+ __pthread_lock(mgr->p_lock, NULL);
- __pthread_lock(__pthread_manager_thread.p_lock, NULL);
-
-#ifdef __ia64__
+#ifdef NEED_SEPARATE_REGISTER_STACK
pid = __clone2(__pthread_manager_event,
- (void **) __pthread_manager_thread_tos,
- THREAD_MANAGER_STACK_SIZE,
- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
- (void *)(long)manager_pipe[0]);
+ (void **) __pthread_manager_thread_bos,
+ THREAD_MANAGER_STACK_SIZE,
+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
+ mgr);
+#elif defined _STACK_GROWS_UP
+ pid = __clone(__pthread_manager_event,
+ (void **) __pthread_manager_thread_bos,
+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
+ mgr);
#else
- pid = clone(__pthread_manager_event,
+ pid = __clone(__pthread_manager_event,
(void **) __pthread_manager_thread_tos,
- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
- (void *)(long)manager_pipe[0]);
+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
+ mgr);
#endif
if (pid != -1)
@@ -584,46 +761,48 @@ int __pthread_initialize_manager(void)
the newly created thread's data structure. We cannot let
the new thread do this since we don't know whether it was
already scheduled when we send the event. */
- __pthread_manager_thread.p_eventbuf.eventdata =
- &__pthread_manager_thread;
- __pthread_manager_thread.p_eventbuf.eventnum = TD_CREATE;
- __pthread_last_event = &__pthread_manager_thread;
- __pthread_manager_thread.p_tid = 2* PTHREAD_THREADS_MAX + 1;
- __pthread_manager_thread.p_pid = pid;
+ mgr->p_eventbuf.eventdata = mgr;
+ mgr->p_eventbuf.eventnum = TD_CREATE;
+ __pthread_last_event = mgr;
+ mgr->p_tid = 2* PTHREAD_THREADS_MAX + 1;
+ mgr->p_pid = pid;
/* Now call the function which signals the event. */
__linuxthreads_create_event ();
}
+
/* Now restart the thread. */
- __pthread_unlock(__pthread_manager_thread.p_lock);
+ __pthread_unlock(mgr->p_lock);
}
}
- if (pid == 0) {
-#ifdef __ia64__
- pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_tos,
- THREAD_MANAGER_STACK_SIZE,
- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
- (void *)(long)manager_pipe[0]);
+ if (__builtin_expect (pid, 0) == 0)
+ {
+#ifdef NEED_SEPARATE_REGISTER_STACK
+ pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos,
+ THREAD_MANAGER_STACK_SIZE,
+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr);
+#elif defined _STACK_GROWS_UP
+ pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_bos,
+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr);
#else
- pid = clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
- (void *)(long)manager_pipe[0]);
+ pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr);
+#endif
+ }
+ if (__builtin_expect (pid, 0) == -1) {
+#ifdef __UCLIBC_HAS_TLS__
+ _dl_deallocate_tls (tcbp, true);
#endif
- }
- if (pid == -1) {
free(__pthread_manager_thread_bos);
- close(manager_pipe[0]);
- close(manager_pipe[1]);
+ close_not_cancel(manager_pipe[0]);
+ close_not_cancel(manager_pipe[1]);
return -1;
}
- __pthread_manager_request = manager_pipe[1]; /* writing end */
- __pthread_manager_reader = manager_pipe[0]; /* reading end */
- __pthread_manager_thread.p_tid = 2* PTHREAD_THREADS_MAX + 1;
- __pthread_manager_thread.p_pid = pid;
-
+ mgr->p_tid = 2* PTHREAD_THREADS_MAX + 1;
+ mgr->p_pid = pid;
/* Make gdb aware of new thread manager */
- if (__pthread_threads_debug && __pthread_sig_debug > 0)
+ if (__builtin_expect (__pthread_threads_debug, 0) && __pthread_sig_debug > 0)
{
raise(__pthread_sig_debug);
/* We suspend ourself and gdb will wake us up when it is
@@ -631,21 +810,21 @@ int __pthread_initialize_manager(void)
__pthread_wait_for_restart_signal(thread_self());
}
/* Synchronize debugging of the thread manager */
- PDEBUG("send REQ_DEBUG to manager thread\n");
request.req_kind = REQ_DEBUG;
- TEMP_FAILURE_RETRY(write(__pthread_manager_request,
- (char *) &request, sizeof(request)));
+ TEMP_FAILURE_RETRY(write_not_cancel(__pthread_manager_request,
+ (char *) &request, sizeof(request)));
return 0;
}
/* Thread creation */
-int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
+int __pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void * (*start_routine)(void *), void *arg)
{
pthread_descr self = thread_self();
struct pthread_request request;
- if (__pthread_manager_request < 0) {
+ int retval;
+ if (__builtin_expect (__pthread_manager_request, 0) < 0) {
if (__pthread_initialize_manager() < 0) return EAGAIN;
}
request.req_thread = self;
@@ -654,31 +833,35 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
request.req_args.create.fn = start_routine;
request.req_args.create.arg = arg;
sigprocmask(SIG_SETMASK, NULL, &request.req_args.create.mask);
- PDEBUG("write REQ_CREATE to manager thread\n");
- TEMP_FAILURE_RETRY(write(__pthread_manager_request,
- (char *) &request, sizeof(request)));
- PDEBUG("before suspend(self)\n");
+ TEMP_FAILURE_RETRY(write_not_cancel(__pthread_manager_request,
+ (char *) &request, sizeof(request)));
suspend(self);
- PDEBUG("after suspend(self)\n");
- if (THREAD_GETMEM(self, p_retcode) == 0)
+ retval = THREAD_GETMEM(self, p_retcode);
+ if (__builtin_expect (retval, 0) == 0)
*thread = (pthread_t) THREAD_GETMEM(self, p_retval);
- return THREAD_GETMEM(self, p_retcode);
+ return retval;
}
+strong_alias (__pthread_create, pthread_create)
/* Simple operations on thread identifiers */
-pthread_t pthread_self(void)
+pthread_descr __pthread_thread_self(void)
+{
+ return thread_self();
+}
+
+pthread_t __pthread_self(void)
{
pthread_descr self = thread_self();
return THREAD_GETMEM(self, p_tid);
}
-libpthread_hidden_def (pthread_self)
+strong_alias (__pthread_self, pthread_self)
-int pthread_equal(pthread_t thread1, pthread_t thread2)
+int __pthread_equal(pthread_t thread1, pthread_t thread2)
{
return thread1 == thread2;
}
-libpthread_hidden_def (pthread_equal)
+strong_alias (__pthread_equal, pthread_equal)
/* Helper function for thread_self in the case of user-provided stacks */
@@ -692,55 +875,64 @@ pthread_descr __pthread_find_self(void)
/* __pthread_handles[0] is the initial thread, __pthread_handles[1] is
the manager threads handled specially in thread_self(), so start at 2 */
h = __pthread_handles + 2;
+# ifdef _STACK_GROWS_UP
+ while (! (sp >= (char *) h->h_descr && sp < (char *) h->h_descr->p_guardaddr)) h++;
+# else
while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom)) h++;
-
-#ifdef DEBUG_PT
- if (h->h_descr == NULL) {
- printf("*** %s ERROR descriptor is NULL!!!!! ***\n\n", __FUNCTION__);
- _exit(1);
- }
-#endif
-
+# endif
return h->h_descr;
}
+
#else
-static pthread_descr thread_self_stack(void)
+pthread_descr __pthread_self_stack(void)
{
- char *sp = CURRENT_STACK_FRAME;
- pthread_handle h;
-
- if (sp >= __pthread_manager_thread_bos && sp < __pthread_manager_thread_tos)
- return manager_thread;
- h = __pthread_handles + 2;
-# if defined(USE_TLS) && USE_TLS
- while (h->h_descr == NULL
- || ! (sp <= (char *) h->h_descr->p_stackaddr && sp >= h->h_bottom))
- h++;
+ char *sp = CURRENT_STACK_FRAME;
+ pthread_handle h;
+
+ if (sp >= __pthread_manager_thread_bos && sp < __pthread_manager_thread_tos)
+ return manager_thread;
+ h = __pthread_handles + 2;
+# ifdef __UCLIBC_HAS_TLS__
+# ifdef _STACK_GROWS_UP
+ while (h->h_descr == NULL
+ || ! (sp >= h->h_descr->p_stackaddr && sp < h->h_descr->p_guardaddr))
+ h++;
+# else
+ while (h->h_descr == NULL
+ || ! (sp <= (char *) h->h_descr->p_stackaddr && sp >= h->h_bottom))
+ h++;
+# endif
# else
- while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom))
- h++;
+# ifdef _STACK_GROWS_UP
+ while (! (sp >= (char *) h->h_descr && sp < h->h_descr->p_guardaddr))
+ h++;
+# else
+ while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom))
+ h++;
+# endif
# endif
- return h->h_descr;
+ return h->h_descr;
}
#endif
/* Thread scheduling */
-int pthread_setschedparam(pthread_t thread, int policy,
- const struct sched_param *param)
+int __pthread_setschedparam(pthread_t thread, int policy,
+ const struct sched_param *param)
{
pthread_handle handle = thread_handle(thread);
pthread_descr th;
__pthread_lock(&handle->h_lock, NULL);
- if (invalid_handle(handle, thread)) {
+ if (__builtin_expect (invalid_handle(handle, thread), 0)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
}
th = handle->h_descr;
- if (sched_setscheduler(th->p_pid, policy, param) == -1) {
+ if (__builtin_expect (__sched_setscheduler(th->p_pid, policy, param) == -1,
+ 0)) {
__pthread_unlock(&handle->h_lock);
return errno;
}
@@ -750,64 +942,96 @@ int pthread_setschedparam(pthread_t thread, int policy,
__pthread_manager_adjust_prio(th->p_priority);
return 0;
}
-libpthread_hidden_def(pthread_setschedparam)
+strong_alias (__pthread_setschedparam, pthread_setschedparam)
-int pthread_getschedparam(pthread_t thread, int *policy,
- struct sched_param *param)
+int __pthread_getschedparam(pthread_t thread, int *policy,
+ struct sched_param *param)
{
pthread_handle handle = thread_handle(thread);
int pid, pol;
__pthread_lock(&handle->h_lock, NULL);
- if (invalid_handle(handle, thread)) {
+ if (__builtin_expect (invalid_handle(handle, thread), 0)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
}
pid = handle->h_descr->p_pid;
__pthread_unlock(&handle->h_lock);
- pol = sched_getscheduler(pid);
- if (pol == -1) return errno;
- if (sched_getparam(pid, param) == -1) return errno;
+ pol = __sched_getscheduler(pid);
+ if (__builtin_expect (pol, 0) == -1) return errno;
+ if (__sched_getparam(pid, param) == -1) return errno;
*policy = pol;
return 0;
}
-libpthread_hidden_def(pthread_getschedparam)
+strong_alias (__pthread_getschedparam, pthread_getschedparam)
/* Process-wide exit() request */
-static void pthread_onexit_process(int retcode, void *arg attribute_unused)
+static void pthread_onexit_process(int retcode, void *arg)
{
+ if (__builtin_expect (__pthread_manager_request, 0) >= 0) {
struct pthread_request request;
pthread_descr self = thread_self();
- if (__pthread_manager_request >= 0) {
- request.req_thread = self;
- request.req_kind = REQ_PROCESS_EXIT;
- request.req_args.exit.code = retcode;
- TEMP_FAILURE_RETRY(write(__pthread_manager_request,
- (char *) &request, sizeof(request)));
- suspend(self);
- /* Main thread should accumulate times for thread manager and its
- children, so that timings for main thread account for all threads. */
- if (self == __pthread_main_thread) {
- waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
- /* Since all threads have been asynchronously terminated
- * (possibly holding locks), free cannot be used any more. */
- __pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
- }
- }
+ /* Make sure we come back here after suspend(), in case we entered
+ from a signal handler. */
+ THREAD_SETMEM(self, p_signal_jmp, NULL);
+
+ request.req_thread = self;
+ request.req_kind = REQ_PROCESS_EXIT;
+ request.req_args.exit.code = retcode;
+ TEMP_FAILURE_RETRY(write_not_cancel(__pthread_manager_request,
+ (char *) &request, sizeof(request)));
+ suspend(self);
+ /* Main thread should accumulate times for thread manager and its
+ children, so that timings for main thread account for all threads. */
+ if (self == __pthread_main_thread)
+ {
+#ifdef __UCLIBC_HAS_TLS__
+ waitpid(manager_thread->p_pid, NULL, __WCLONE);
+#else
+ waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
+#endif
+ /* Since all threads have been asynchronously terminated
+ (possibly holding locks), free cannot be used any more.
+ For mtrace, we'd like to print something though. */
+ /* #ifdef __UCLIBC_HAS_TLS__
+ tcbhead_t *tcbp = (tcbhead_t *) manager_thread;
+ # if defined(TLS_DTV_AT_TP)
+ tcbp = (tcbhead_t) ((char *) tcbp + TLS_PRE_TCB_SIZE);
+ # endif
+ _dl_deallocate_tls (tcbp, true);
+ #endif
+ free (__pthread_manager_thread_bos); */
+ __pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
+ }
+ }
+}
+
+#ifndef HAVE_Z_NODELETE
+static int __pthread_atexit_retcode;
+
+static void pthread_atexit_process(void *arg, int retcode)
+{
+ pthread_onexit_process (retcode ?: __pthread_atexit_retcode, arg);
}
+static void pthread_atexit_retcode(void *arg, int retcode)
+{
+ __pthread_atexit_retcode = retcode;
+}
+#endif
+
/* The handler for the RESTART signal just records the signal received
in the thread descriptor, and optionally performs a siglongjmp
(for pthread_cond_timedwait). */
static void pthread_handle_sigrestart(int sig)
{
- pthread_descr self = thread_self();
- THREAD_SETMEM(self, p_signal, sig);
- if (THREAD_GETMEM(self, p_signal_jmp) != NULL)
- siglongjmp(*THREAD_GETMEM(self, p_signal_jmp), 1);
+ pthread_descr self = check_thread_self();
+ THREAD_SETMEM(self, p_signal, sig);
+ if (THREAD_GETMEM(self, p_signal_jmp) != NULL)
+ siglongjmp(*THREAD_GETMEM(self, p_signal_jmp), 1);
}
/* The handler for the CANCEL signal checks for cancellation
@@ -817,39 +1041,20 @@ static void pthread_handle_sigrestart(int sig)
static void pthread_handle_sigcancel(int sig)
{
- pthread_descr self = thread_self();
+ pthread_descr self = check_thread_self();
sigjmp_buf * jmpbuf;
-
- if (self == &__pthread_manager_thread)
+ if (self == manager_thread)
{
-#ifdef THREAD_SELF
- /* A new thread might get a cancel signal before it is fully
- initialized, so that the thread register might still point to the
- manager thread. Double check that this is really the manager
- thread. */
- pthread_descr real_self = thread_self_stack();
- if (real_self == &__pthread_manager_thread)
- {
- __pthread_manager_sighandler(sig);
- return;
- }
- /* Oops, thread_self() isn't working yet.. */
- self = real_self;
-# ifdef INIT_THREAD_SELF
- INIT_THREAD_SELF(self, self->p_nr);
-# endif
-#else
__pthread_manager_sighandler(sig);
return;
-#endif
}
if (__builtin_expect (__pthread_exit_requested, 0)) {
/* Main thread should accumulate times for thread manager and its
children, so that timings for main thread account for all threads. */
if (self == __pthread_main_thread) {
-#if defined(USE_TLS) && USE_TLS
- waitpid(__pthread_manager_thread->p_pid, NULL, __WCLONE);
+#ifdef __UCLIBC_HAS_TLS__
+ waitpid(manager_thread->p_pid, NULL, __WCLONE);
#else
waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
#endif
@@ -878,7 +1083,7 @@ static void pthread_handle_sigcancel(int sig)
know what it is specifically done for. In the current implementation,
the thread manager simply discards it. */
-static void pthread_handle_sigdebug(int sig attribute_unused)
+static void pthread_handle_sigdebug(int sig)
{
/* Nothing */
}
@@ -898,20 +1103,39 @@ void __pthread_reset_main_thread(void)
free(__pthread_manager_thread_bos);
__pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
/* Close the two ends of the pipe */
- close(__pthread_manager_request);
- close(__pthread_manager_reader);
+ close_not_cancel(__pthread_manager_request);
+ close_not_cancel(__pthread_manager_reader);
__pthread_manager_request = __pthread_manager_reader = -1;
}
/* Update the pid of the main thread */
- THREAD_SETMEM(self, p_pid, getpid());
+ THREAD_SETMEM(self, p_pid, __getpid());
/* Make the forked thread the main thread */
__pthread_main_thread = self;
THREAD_SETMEM(self, p_nextlive, self);
THREAD_SETMEM(self, p_prevlive, self);
+#ifndef __UCLIBC_HAS_TLS__
/* Now this thread modifies the global variables. */
THREAD_SETMEM(self, p_errnop, &_errno);
THREAD_SETMEM(self, p_h_errnop, &_h_errno);
+# if defined __UCLIBC_HAS_RESOLVER_SUPPORT__
+ THREAD_SETMEM(self, p_resp, __resp);
+# endif
+#endif
+
+#ifndef FLOATING_STACKS
+ /* This is to undo the setrlimit call in __pthread_init_max_stacksize.
+ XXX This can be wrong if the user set the limit during the run. */
+ {
+ struct rlimit limit;
+ if (getrlimit (RLIMIT_STACK, &limit) == 0
+ && limit.rlim_cur != limit.rlim_max)
+ {
+ limit.rlim_cur = limit.rlim_max;
+ setrlimit(RLIMIT_STACK, &limit);
+ }
+ }
+#endif
}
/* Process-wide exec() request */
@@ -924,6 +1148,7 @@ void __pthread_kill_other_threads_np(void)
/* Make current thread the main thread in case the calling thread
changes its mind, does not exec(), and creates new threads instead. */
__pthread_reset_main_thread();
+
/* Reset the signal handlers behaviour for the signals the
implementation uses since this would be passed to the new
process. */
@@ -954,24 +1179,24 @@ int __pthread_getconcurrency(void)
}
weak_alias (__pthread_getconcurrency, pthread_getconcurrency)
-
/* Primitives for controlling thread execution */
void __pthread_wait_for_restart_signal(pthread_descr self)
{
- sigset_t mask;
+ sigset_t mask;
- sigprocmask(SIG_SETMASK, NULL, &mask); /* Get current signal mask */
- sigdelset(&mask, __pthread_sig_restart); /* Unblock the restart signal */
- THREAD_SETMEM(self, p_signal, 0);
- do {
- sigsuspend(&mask); /* Wait for signal */
- } while (THREAD_GETMEM(self, p_signal) !=__pthread_sig_restart);
+ sigprocmask(SIG_SETMASK, NULL, &mask); /* Get current signal mask */
+ sigdelset(&mask, __pthread_sig_restart); /* Unblock the restart signal */
+ THREAD_SETMEM(self, p_signal, 0);
+ do {
+ __pthread_sigsuspend(&mask); /* Wait for signal. Must not be a
+ cancellation point. */
+ } while (THREAD_GETMEM(self, p_signal) !=__pthread_sig_restart);
- READ_MEMORY_BARRIER(); /* See comment in __pthread_restart_new */
+ READ_MEMORY_BARRIER(); /* See comment in __pthread_restart_new */
}
-#ifndef __NR_rt_sigaction
+#if !__ASSUME_REALTIME_SIGNALS
/* The _old variants are for 2.0 and early 2.1 kernels which don't have RT
signals.
On these kernels, we use SIGUSR1 and SIGUSR2 for restart and cancellation.
@@ -981,14 +1206,14 @@ void __pthread_wait_for_restart_signal(pthread_descr self)
void __pthread_restart_old(pthread_descr th)
{
- if (atomic_increment(&th->p_resume_count) == -1)
- kill(th->p_pid, __pthread_sig_restart);
+ if (pthread_atomic_increment(&th->p_resume_count) == -1)
+ kill(th->p_pid, __pthread_sig_restart);
}
void __pthread_suspend_old(pthread_descr self)
{
- if (atomic_decrement(&self->p_resume_count) <= 0)
- __pthread_wait_for_restart_signal(self);
+ if (pthread_atomic_decrement(&self->p_resume_count) <= 0)
+ __pthread_wait_for_restart_signal(self);
}
int
@@ -998,7 +1223,7 @@ __pthread_timedsuspend_old(pthread_descr self, const struct timespec *abstime)
int was_signalled = 0;
sigjmp_buf jmpbuf;
- if (atomic_decrement(&self->p_resume_count) == 0) {
+ if (pthread_atomic_decrement(&self->p_resume_count) == 0) {
/* Set up a longjmp handler for the restart signal, unblock
the signal and sleep. */
@@ -1015,7 +1240,7 @@ __pthread_timedsuspend_old(pthread_descr self, const struct timespec *abstime)
struct timespec reltime;
/* Compute a time offset relative to now. */
- gettimeofday (&now, NULL);
+ __gettimeofday (&now, NULL);
reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000;
reltime.tv_sec = abstime->tv_sec - now.tv_sec;
if (reltime.tv_nsec < 0) {
@@ -1055,9 +1280,9 @@ __pthread_timedsuspend_old(pthread_descr self, const struct timespec *abstime)
being delivered. */
if (!was_signalled) {
- if (atomic_increment(&self->p_resume_count) != -1) {
+ if (pthread_atomic_increment(&self->p_resume_count) != -1) {
__pthread_wait_for_restart_signal(self);
- atomic_decrement(&self->p_resume_count); /* should be zero now! */
+ pthread_atomic_decrement(&self->p_resume_count); /* should be zero now! */
/* woke spontaneously and consumed restart signal */
return 1;
}
@@ -1067,99 +1292,92 @@ __pthread_timedsuspend_old(pthread_descr self, const struct timespec *abstime)
/* woken due to restart signal */
return 1;
}
-#endif /* __NR_rt_sigaction */
+#endif /* __ASSUME_REALTIME_SIGNALS */
-
-#ifdef __NR_rt_sigaction
void __pthread_restart_new(pthread_descr th)
{
- /* The barrier is proabably not needed, in which case it still documents
- our assumptions. The intent is to commit previous writes to shared
- memory so the woken thread will have a consistent view. Complementary
- read barriers are present to the suspend functions. */
- WRITE_MEMORY_BARRIER();
- kill(th->p_pid, __pthread_sig_restart);
+ /* The barrier is proabably not needed, in which case it still documents
+ our assumptions. The intent is to commit previous writes to shared
+ memory so the woken thread will have a consistent view. Complementary
+ read barriers are present to the suspend functions. */
+ WRITE_MEMORY_BARRIER();
+ kill(th->p_pid, __pthread_sig_restart);
}
-int __pthread_timedsuspend_new(pthread_descr self, const struct timespec *abstime)
-{
- sigset_t unblock, initial_mask;
- int was_signalled = 0;
- sigjmp_buf jmpbuf;
+/* There is no __pthread_suspend_new because it would just
+ be a wasteful wrapper for __pthread_wait_for_restart_signal */
- if (sigsetjmp(jmpbuf, 1) == 0) {
- THREAD_SETMEM(self, p_signal_jmp, &jmpbuf);
- THREAD_SETMEM(self, p_signal, 0);
- /* Unblock the restart signal */
- __sigemptyset(&unblock);
- sigaddset(&unblock, __pthread_sig_restart);
- sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask);
-
- while (1) {
- struct timeval now;
- struct timespec reltime;
-
- /* Compute a time offset relative to now. */
- gettimeofday (&now, NULL);
- reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000;
- reltime.tv_sec = abstime->tv_sec - now.tv_sec;
- if (reltime.tv_nsec < 0) {
- reltime.tv_nsec += 1000000000;
- reltime.tv_sec -= 1;
- }
+int
+__pthread_timedsuspend_new(pthread_descr self, const struct timespec *abstime)
+{
+ sigset_t unblock, initial_mask;
+ int was_signalled = 0;
+ sigjmp_buf jmpbuf;
- /* Sleep for the required duration. If woken by a signal,
- resume waiting as required by Single Unix Specification. */
- if (reltime.tv_sec < 0 || nanosleep(&reltime, NULL) == 0)
- break;
- }
+ if (sigsetjmp(jmpbuf, 1) == 0) {
+ THREAD_SETMEM(self, p_signal_jmp, &jmpbuf);
+ THREAD_SETMEM(self, p_signal, 0);
+ /* Unblock the restart signal */
+ __sigemptyset(&unblock);
+ sigaddset(&unblock, __pthread_sig_restart);
+ sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask);
+
+ while (1) {
+ struct timeval now;
+ struct timespec reltime;
+
+ /* Compute a time offset relative to now. */
+ __gettimeofday (&now, NULL);
+ reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000;
+ reltime.tv_sec = abstime->tv_sec - now.tv_sec;
+ if (reltime.tv_nsec < 0) {
+ reltime.tv_nsec += 1000000000;
+ reltime.tv_sec -= 1;
+ }
- /* Block the restart signal again */
- sigprocmask(SIG_SETMASK, &initial_mask, NULL);
- was_signalled = 0;
- } else {
- was_signalled = 1;
+ /* Sleep for the required duration. If woken by a signal,
+ resume waiting as required by Single Unix Specification. */
+ if (reltime.tv_sec < 0 || nanosleep(&reltime, NULL) == 0)
+ break;
}
- THREAD_SETMEM(self, p_signal_jmp, NULL);
- /* Now was_signalled is true if we exited the above code
- due to the delivery of a restart signal. In that case,
- everything is cool. We have been removed from whatever
- we were waiting on by the other thread, and consumed its signal.
+ /* Block the restart signal again */
+ sigprocmask(SIG_SETMASK, &initial_mask, NULL);
+ was_signalled = 0;
+ } else {
+ was_signalled = 1;
+ }
+ THREAD_SETMEM(self, p_signal_jmp, NULL);
+
+ /* Now was_signalled is true if we exited the above code
+ due to the delivery of a restart signal. In that case,
+ everything is cool. We have been removed from whatever
+ we were waiting on by the other thread, and consumed its signal.
- Otherwise we this thread woke up spontaneously, or due to a signal other
- than restart. This is an ambiguous case that must be resolved by
- the caller; the thread is still eligible for a restart wakeup
- so there is a race. */
+ Otherwise we this thread woke up spontaneously, or due to a signal other
+ than restart. This is an ambiguous case that must be resolved by
+ the caller; the thread is still eligible for a restart wakeup
+ so there is a race. */
- READ_MEMORY_BARRIER(); /* See comment in __pthread_restart_new */
- return was_signalled;
+ READ_MEMORY_BARRIER(); /* See comment in __pthread_restart_new */
+ return was_signalled;
}
-#endif
+
/* Debugging aid */
-#ifdef DEBUG_PT
+#ifdef DEBUG
#include <stdarg.h>
-void __pthread_message(char * fmt, ...)
+void __pthread_message(const char * fmt, ...)
{
char buffer[1024];
va_list args;
- sprintf(buffer, "%05d : ", getpid());
+ sprintf(buffer, "%05d : ", __getpid());
va_start(args, fmt);
vsnprintf(buffer + 8, sizeof(buffer) - 8, fmt, args);
va_end(args);
- TEMP_FAILURE_RETRY(write(2, buffer, strlen(buffer)));
+ TEMP_FAILURE_RETRY(write_not_cancel(2, buffer, strlen(buffer)));
}
#endif
-
-
-#ifndef __PIC__
-/* We need a hook to force the cancellation wrappers to be linked in when
- static libpthread is used. */
-extern const char __pthread_provide_wrappers;
-static const char *const __pthread_require_wrappers =
- &__pthread_provide_wrappers;
-#endif