Back to index

glibc  2.9
Defines | Functions | Variables
pthread.c File Reference
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <shlib-compat.h>
#include "pthread.h"
#include "internals.h"
#include "spinlock.h"
#include "restart.h"
#include "smp.h"
#include <ldsodefs.h>
#include <tls.h>
#include <version.h>
#include <not-cancel.h>
#include <resolv.h>

Go to the source code of this file.

Defines

#define manager_thread   (&__pthread_manager_thread)
#define ptr_pthread_functions   NULL

Functions

static void pthread_onexit_process (int retcode, void *arg)
static void pthread_atexit_process (void *arg, int retcode)
static void pthread_atexit_retcode (void *arg, int retcode)
static void pthread_handle_sigcancel (int sig)
static void pthread_handle_sigrestart (int sig)
static void pthread_handle_sigdebug (int sig)
int __libc_current_sigrtmin_private (void)
static void init_rtsigs (void)
static void pthread_initialize (void)
void __pthread_initialize_minimal (void)
void __pthread_init_max_stacksize (void)
void __pthread_initialize (void)
int __pthread_initialize_manager (void)
int __pthread_create_2_1 (pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
 versioned_symbol (libpthread, __pthread_create_2_1, pthread_create, GLIBC_2_1)
pthread_descr __pthread_thread_self (void)
pthread_t __pthread_self (void)
 strong_alias (__pthread_self, pthread_self)
int __pthread_equal (pthread_t thread1, pthread_t thread2)
 strong_alias (__pthread_equal, pthread_equal)
pthread_descr __pthread_find_self (void)
int __pthread_setschedparam (pthread_t thread, int policy, const struct sched_param *param)
 strong_alias (__pthread_setschedparam, pthread_setschedparam)
int __pthread_getschedparam (pthread_t thread, int *policy, struct sched_param *param)
 strong_alias (__pthread_getschedparam, pthread_getschedparam)
int __pthread_yield (void)
 weak_alias (__pthread_yield, pthread_yield)
void __pthread_reset_main_thread (void)
void __pthread_kill_other_threads_np (void)
 weak_alias (__pthread_kill_other_threads_np, pthread_kill_other_threads_np)
 weak_alias (__pthread_setconcurrency, pthread_setconcurrency)
 weak_alias (__pthread_getconcurrency, pthread_getconcurrency)
void __pthread_restart_old (pthread_descr th)
void __pthread_suspend_old (pthread_descr self)
int __pthread_timedsuspend_old (pthread_descr self, const struct timespec *abstime)
void __pthread_restart_new (pthread_descr th)
int __pthread_timedsuspend_new (pthread_descr self, const struct timespec *abstime)

Variables

int _errno
int _h_errno
pthread_descr __pthread_main_thread = &__pthread_initial_thread
char * __pthread_initial_thread_bos
int __pthread_manager_request = -1
int __pthread_multiple_threads attribute_hidden
int __pthread_manager_reader
char * __pthread_manager_thread_bos
char * __pthread_manager_thread_tos
int __pthread_exit_requested
int __pthread_exit_code
size_t __pthread_max_stacksize
int __pthread_smp_kernel
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
const int __pthread_threads_max = PTHREAD_THREADS_MAX
const int __pthread_sizeof_handle = sizeof(struct pthread_handle_struct)
const int __pthread_offsetof_descr
const int __pthread_offsetof_pid
const int __linuxthreads_pthread_sizeof_descr = sizeof(struct _pthread_descr_struct)
const int __linuxthreads_initial_report_events
const char __linuxthreads_version [] = VERSION
int __pthread_sig_restart = __SIGRTMIN
int __pthread_sig_cancel = __SIGRTMIN + 1
int __pthread_sig_debug = __SIGRTMIN + 2
static int rtsigs_initialized
static int__libc_multiple_threads_ptr
static int __pthread_atexit_retcode

Define Documentation

#define manager_thread   (&__pthread_manager_thread)

Definition at line 87 of file pthread.c.

Definition at line 298 of file pthread.c.


Function Documentation

int __pthread_create_2_1 ( pthread_t thread,
const pthread_attr_t attr,
void *(*)(void *)  start_routine,
void *  arg 
)

Definition at line 834 of file pthread.c.

{
  pthread_descr self = thread_self();
  struct pthread_request request;
  int retval;
  if (__builtin_expect (__pthread_manager_request, 0) < 0) {
    if (__pthread_initialize_manager() < 0) return EAGAIN;
  }
  request.req_thread = self;
  request.req_kind = REQ_CREATE;
  request.req_args.create.attr = attr;
  request.req_args.create.fn = start_routine;
  request.req_args.create.arg = arg;
  sigprocmask(SIG_SETMASK, (const sigset_t *) NULL,
              &request.req_args.create.mask);
  TEMP_FAILURE_RETRY(write_not_cancel(__pthread_manager_request,
                                  (char *) &request, sizeof(request)));
  suspend(self);
  retval = THREAD_GETMEM(self, p_retcode);
  if (__builtin_expect (retval, 0) == 0)
    *thread = (pthread_t) THREAD_GETMEM(self, p_retval);
  return retval;
}
int __pthread_equal ( pthread_t  thread1,
pthread_t  thread2 
)

Definition at line 902 of file pthread.c.

{
  return thread1 == thread2;
}

Definition at line 912 of file pthread.c.

{
  char * sp = CURRENT_STACK_FRAME;
  pthread_handle h;

  /* __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 < h->h_descr->p_guardaddr)) h++;
# else
  while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom)) h++;
# endif
  return h->h_descr;
}
int __pthread_getschedparam ( pthread_t  thread,
int policy,
struct sched_param param 
)

Definition at line 989 of file pthread.c.

{
  pthread_handle handle = thread_handle(thread);
  int pid, pol;

  __pthread_lock(&handle->h_lock, NULL);
  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 (__builtin_expect (pol, 0) == -1) return errno;
  if (__sched_getparam(pid, param) == -1) return errno;
  *policy = pol;
  return 0;
}

Definition at line 423 of file pthread.c.

{
  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 USE_TLS
      pthread_descr self = THREAD_SELF;
      self->p_alloca_cutoff = max_stack / 4;
#else
      __pthread_initial_thread.p_alloca_cutoff = max_stack / 4;
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void __pthread_initialize ( void  )

Definition at line 622 of file pthread.c.

Here is the call graph for this function:

Definition at line 627 of file pthread.c.

{
  int manager_pipe[2];
  int pid;
  struct pthread_request request;
  int report_events;
  pthread_descr mgr;
#ifdef USE_TLS
  tcbhead_t *tcbp;
#endif

  __pthread_multiple_threads = 1;
#if TLS_MULTIPLE_THREADS_IN_TCB || !defined USE_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();
  /* Setup stack for thread manager */
  __pthread_manager_thread_bos = malloc(THREAD_MANAGER_STACK_SIZE);
  if (__pthread_manager_thread_bos == NULL) return -1;
  __pthread_manager_thread_tos =
    __pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;
  /* Setup pipe to communicate with thread manager */
  if (pipe(manager_pipe) == -1) {
    free(__pthread_manager_thread_bos);
    return -1;
  }

#ifdef USE_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 TLS_TCB_AT_TP
  mgr = (pthread_descr) tcbp;
# elif 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 USE_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 HAVE___THREAD
  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

  /* Copy the stack guard canary.  */
#ifdef THREAD_COPY_STACK_GUARD
  THREAD_COPY_STACK_GUARD (mgr);
#endif

  /* Copy the pointer guard value.  */
#ifdef THREAD_COPY_POINTER_GUARD
  THREAD_COPY_POINTER_GUARD (mgr);
#endif

  __pthread_manager_request = manager_pipe[1]; /* writing end */
  __pthread_manager_reader = manager_pipe[0]; /* reading end */

  /* Start the thread manager */
  pid = 0;
#ifdef USE_TLS
  if (__linuxthreads_initial_report_events != 0)
    THREAD_SETMEM (((pthread_descr) NULL), p_report_events,
                 __linuxthreads_initial_report_events);
  report_events = THREAD_GETMEM (((pthread_descr) NULL), p_report_events);
#else
  if (__linuxthreads_initial_report_events != 0)
    __pthread_initial_thread.p_report_events
      = __linuxthreads_initial_report_events;
  report_events = __pthread_initial_thread.p_report_events;
#endif
  if (__builtin_expect (report_events, 0))
    {
      /* It's a bit more complicated.  We have to report the creation of
        the manager thread.  */
      int idx = __td_eventword (TD_CREATE);
      uint32_t mask = __td_eventmask (TD_CREATE);
      uint32_t event_bits;

#ifdef USE_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);

#ifdef NEED_SEPARATE_REGISTER_STACK
         pid = __clone2(__pthread_manager_event,
                      (void **) __pthread_manager_thread_bos,
                      THREAD_MANAGER_STACK_SIZE,
                      CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
                      mgr);
#elif _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,
                     (void **) __pthread_manager_thread_tos,
                     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
                     mgr);
#endif

         if (pid != -1)
           {
             /* Now fill in the information about the new thread in
                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.  */
             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(mgr->p_lock);
       }
    }

  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 _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 | CLONE_SYSVSEM, mgr);
#endif
    }
  if (__builtin_expect (pid, 0) == -1) {
#ifdef USE_TLS
    _dl_deallocate_tls (tcbp, true);
#endif
    free(__pthread_manager_thread_bos);
    close_not_cancel(manager_pipe[0]);
    close_not_cancel(manager_pipe[1]);
    return -1;
  }
  mgr->p_tid = 2* PTHREAD_THREADS_MAX + 1;
  mgr->p_pid = pid;
  /* Make gdb aware of new thread manager */
  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
        ready to handle us. */
      __pthread_wait_for_restart_signal(thread_self());
    }
  /* Synchronize debugging of the thread manager */
  request.req_kind = REQ_DEBUG;
  TEMP_FAILURE_RETRY(write_not_cancel(__pthread_manager_request,
                                  (char *) &request, sizeof(request)));
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 306 of file pthread.c.

{
#ifdef USE_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 !USE___THREAD
  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 HAVE___THREAD
  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  /* USE_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 USE_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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1190 of file pthread.c.

{
  struct sigaction sa;
  /* Terminate all other threads and thread manager */
  pthread_onexit_process(0, NULL);
  /* 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.  */
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;
  sa.sa_handler = SIG_DFL;
  __libc_sigaction(__pthread_sig_restart, &sa, NULL);
  __libc_sigaction(__pthread_sig_cancel, &sa, NULL);
  if (__pthread_sig_debug > 0)
    __libc_sigaction(__pthread_sig_debug, &sa, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void __pthread_reset_main_thread ( void  )

Definition at line 1146 of file pthread.c.

{
  pthread_descr self = thread_self();

  if (__pthread_manager_request != -1) {
    /* Free the thread manager stack */
    free(__pthread_manager_thread_bos);
    __pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
    /* Close the two ends of the pipe */
    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());
  /* Make the forked thread the main thread */
  __pthread_main_thread = self;
  THREAD_SETMEM(self, p_nextlive, self);
  THREAD_SETMEM(self, p_prevlive, self);
#if !(USE_TLS && HAVE___THREAD)
  /* Now this thread modifies the global variables.  */
  THREAD_SETMEM(self, p_errnop, &_errno);
  THREAD_SETMEM(self, p_h_errnop, &_h_errno);
  THREAD_SETMEM(self, p_resp, &_res);
#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
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1344 of file pthread.c.

{
  /* 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);
}

Here is the caller graph for this function:

Definition at line 1254 of file pthread.c.

{
  if (pthread_atomic_increment(&th->p_resume_count) == -1)
    kill(th->p_pid, __pthread_sig_restart);
}

Here is the call graph for this function:

Definition at line 895 of file pthread.c.

{
  pthread_descr self = thread_self();
  return THREAD_GETMEM(self, p_tid);
}
int __pthread_setschedparam ( pthread_t  thread,
int  policy,
const struct sched_param param 
)

Definition at line 964 of file pthread.c.

{
  pthread_handle handle = thread_handle(thread);
  pthread_descr th;

  __pthread_lock(&handle->h_lock, NULL);
  if (__builtin_expect (invalid_handle(handle, thread), 0)) {
    __pthread_unlock(&handle->h_lock);
    return ESRCH;
  }
  th = handle->h_descr;
  if (__builtin_expect (__sched_setscheduler(th->p_pid, policy, param) == -1,
                     0)) {
    __pthread_unlock(&handle->h_lock);
    return errno;
  }
  th->p_priority = policy == SCHED_OTHER ? 0 : param->sched_priority;
  __pthread_unlock(&handle->h_lock);
  if (__pthread_manager_request >= 0)
    __pthread_manager_adjust_prio(th->p_priority);
  return 0;
}

Definition at line 1260 of file pthread.c.

{
  if (pthread_atomic_decrement(&self->p_resume_count) <= 0)
    __pthread_wait_for_restart_signal(self);
}

Here is the call graph for this function:

Definition at line 890 of file pthread.c.

{
  return thread_self();
}
int __pthread_timedsuspend_new ( pthread_descr  self,
const struct timespec abstime 
)

Definition at line 1358 of file pthread.c.

{
  sigset_t unblock, initial_mask;
  int was_signalled = 0;
  sigjmp_buf jmpbuf;

  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;
      }

      /* Sleep for the required duration. If woken by a signal,
        resume waiting as required by Single Unix Specification.  */
      if (reltime.tv_sec < 0 || __libc_nanosleep(&reltime, NULL) == 0)
       break;
    }

    /* 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. */

  READ_MEMORY_BARRIER(); /* See comment in __pthread_restart_new */
  return was_signalled;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int __pthread_timedsuspend_old ( pthread_descr  self,
const struct timespec abstime 
)

Definition at line 1267 of file pthread.c.

{
  sigset_t unblock, initial_mask;
  int was_signalled = 0;
  sigjmp_buf jmpbuf;

  if (pthread_atomic_decrement(&self->p_resume_count) == 0) {
    /* Set up a longjmp handler for the restart signal, unblock
       the signal and sleep. */

    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;
       }

       /* Sleep for the required duration. If woken by a signal,
          resume waiting as required by Single Unix Specification.  */
       if (reltime.tv_sec < 0 || __libc_nanosleep(&reltime, NULL) == 0)
         break;
      }

      /* 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,
     we know we have been dequeued and resumed and that the
     resume count is balanced.  Otherwise, there are some
     cases to consider. First, try to bump up the resume count
     back to zero. If it goes to 1, it means restart() was
     invoked on this thread. The signal must be consumed
     and the count bumped down and everything is cool. We
     can return a 1 to the caller.
     Otherwise, no restart was delivered yet, so a potential
     race exists; we return a 0 to the caller which must deal
     with this race in an appropriate way; for example by
     atomically removing the thread from consideration for a
     wakeup---if such a thing fails, it means a restart is
     being delivered. */

  if (!was_signalled) {
    if (pthread_atomic_increment(&self->p_resume_count) != -1) {
      __pthread_wait_for_restart_signal(self);
      pthread_atomic_decrement(&self->p_resume_count); /* should be zero now! */
      /* woke spontaneously and consumed restart signal */
      return 1;
    }
    /* woke spontaneously but did not consume restart---caller must resolve */
    return 0;
  }
  /* woken due to restart signal */
  return 1;
}

Here is the call graph for this function:

int __pthread_yield ( void  )

Definition at line 1010 of file pthread.c.

{
  /* For now this is equivalent with the POSIX call.  */
  return sched_yield ();
}

Here is the call graph for this function:

static void init_rtsigs ( void  ) [static]

Definition at line 200 of file pthread.c.

Here is the call graph for this function:

static void pthread_atexit_process ( void *  arg,
int  retcode 
) [static]

Definition at line 1063 of file pthread.c.

Here is the call graph for this function:

static void pthread_atexit_retcode ( void *  arg,
int  retcode 
) [static]

Definition at line 1068 of file pthread.c.

{
  __pthread_atexit_retcode = retcode;
}

Here is the caller graph for this function:

static void pthread_handle_sigcancel ( int  sig) [static]

Definition at line 1091 of file pthread.c.

{
  pthread_descr self = check_thread_self();
  sigjmp_buf * jmpbuf;

  if (self == manager_thread)
    {
      __pthread_manager_sighandler(sig);
      return;
    }
  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) {
#ifdef USE_TLS
      waitpid(manager_thread->p_pid, NULL, __WCLONE);
#else
      waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
#endif
    }
    _exit(__pthread_exit_code);
  }
  if (__builtin_expect (THREAD_GETMEM(self, p_canceled), 0)
      && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
    if (THREAD_GETMEM(self, p_canceltype) == PTHREAD_CANCEL_ASYNCHRONOUS)
      __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
    jmpbuf = THREAD_GETMEM(self, p_cancel_jmp);
    if (jmpbuf != NULL) {
      THREAD_SETMEM(self, p_cancel_jmp, NULL);
      siglongjmp(*jmpbuf, 1);
    }
  }
}

Here is the call graph for this function:

static void pthread_handle_sigdebug ( int  sig) [static]

Definition at line 1135 of file pthread.c.

{
  /* Nothing */
}
static void pthread_handle_sigrestart ( int  sig) [static]

Definition at line 1078 of file pthread.c.

{
  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);
}
static void pthread_initialize ( void  ) [static]

Definition at line 232 of file pthread.c.

  {
#if !(USE_TLS && HAVE___THREAD)
    .ptr_pthread_internal_tsd_set = __pthread_internal_tsd_set,
    .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,
#if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
    .ptr___pthread_attr_init_2_0 = __pthread_attr_init_2_0,
#endif
    .ptr___pthread_attr_init_2_1 = __pthread_attr_init_2_1,
    .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_cleanup_push = _pthread_cleanup_push,
    .ptr__pthread_cleanup_pop = _pthread_cleanup_pop
  };

Here is the caller graph for this function:

static void pthread_onexit_process ( int  retcode,
void *  arg 
) [static]

Here is the caller graph for this function:

versioned_symbol ( libpthread  ,
__pthread_create_2_1  ,
pthread_create  ,
GLIBC_2_1   
)

Definition at line 1015 of file pthread.c.

{
  if (__builtin_expect (__pthread_manager_request, 0) >= 0) {
    struct pthread_request request;
    pthread_descr self = thread_self();

    /* 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 USE_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 USE_TLS
          tcbhead_t *tcbp = (tcbhead_t *) manager_thread;
          # if 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;
      }
  }
}

Here is the call graph for this function:

Definition at line 1210 of file pthread.c.

{
  /* We don't do anything unless we have found a useful interpretation.  */
  current_level = level;
  return 0;
}

Definition at line 1221 of file pthread.c.

{
  return current_level;
}

Definition at line 1227 of file pthread.c.

{
  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 {
    __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 */
}

Here is the call graph for this function:


Variable Documentation

Definition at line 301 of file pthread.c.

Definition at line 164 of file pthread.c.

Definition at line 162 of file pthread.c.

Definition at line 166 of file pthread.c.

Definition at line 1061 of file pthread.c.

Definition at line 135 of file pthread.c.

Definition at line 134 of file pthread.c.

Definition at line 114 of file pthread.c.

pthread_descr __pthread_main_thread = &__pthread_initial_thread

Definition at line 108 of file pthread.c.

Definition at line 125 of file pthread.c.

Definition at line 119 of file pthread.c.

Definition at line 129 of file pthread.c.

Definition at line 130 of file pthread.c.

Definition at line 138 of file pthread.c.

Initial value:
 offsetof(struct pthread_handle_struct,
                                              h_descr)

Definition at line 157 of file pthread.c.

Initial value:

Definition at line 159 of file pthread.c.

Definition at line 148 of file pthread.c.

int __pthread_sig_cancel = __SIGRTMIN + 1

Definition at line 190 of file pthread.c.

int __pthread_sig_debug = __SIGRTMIN + 2

Definition at line 191 of file pthread.c.

int __pthread_sig_restart = __SIGRTMIN

Definition at line 189 of file pthread.c.

Definition at line 156 of file pthread.c.

Definition at line 141 of file pthread.c.

Definition at line 149 of file pthread.c.

Definition at line 155 of file pthread.c.

Definition at line 150 of file pthread.c.

Definition at line 30 of file libc-tsd.c.

Definition at line 31 of file libc-tsd.c.

int __pthread_multiple_threads attribute_hidden

Definition at line 121 of file pthread.c.

Definition at line 197 of file pthread.c.