Remove _POSIX_MONOTONIC_CLOCK.
[kopensolaris-gnu/glibc.git] / linuxthreads / pthread.c
1
2 /* Linuxthreads - a simple clone()-based implementation of Posix        */
3 /* threads for Linux.                                                   */
4 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
5 /*                                                                      */
6 /* This program is free software; you can redistribute it and/or        */
7 /* modify it under the terms of the GNU Library General Public License  */
8 /* as published by the Free Software Foundation; either version 2       */
9 /* of the License, or (at your option) any later version.               */
10 /*                                                                      */
11 /* This program is distributed in the hope that it will be useful,      */
12 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
13 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
14 /* GNU Library General Public License for more details.                 */
15
16 /* Thread creation, initialization, and basic low-level routines */
17
18 #include <errno.h>
19 #include <stddef.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <fcntl.h>
25 #include <sys/wait.h>
26 #include <sys/resource.h>
27 #include <sys/sysctl.h>
28 #include <shlib-compat.h>
29 #include "pthread.h"
30 #include "internals.h"
31 #include "spinlock.h"
32 #include "restart.h"
33
34 /* We need the global/static resolver state here.  */
35 #include <resolv.h>
36 #undef _res
37
38 extern struct __res_state _res;
39
40 /* Sanity check.  */
41 #if __ASSUME_REALTIME_SIGNALS && !defined __SIGRTMIN
42 # error "This must not happen; new kernel assumed but old headers"
43 #endif
44
45 /* These variables are used by the setup code.  */
46 extern int _errno;
47 extern int _h_errno;
48
49 /* Descriptor of the initial thread */
50
51 struct _pthread_descr_struct __pthread_initial_thread = {
52   {
53     {
54       &__pthread_initial_thread /* pthread_descr self */
55     }
56   },
57   &__pthread_initial_thread,  /* pthread_descr p_nextlive */
58   &__pthread_initial_thread,  /* pthread_descr p_prevlive */
59   NULL,                       /* pthread_descr p_nextwaiting */
60   NULL,                       /* pthread_descr p_nextlock */
61   PTHREAD_THREADS_MAX,        /* pthread_t p_tid */
62   0,                          /* int p_pid */
63   0,                          /* int p_priority */
64   &__pthread_handles[0].h_lock, /* struct _pthread_fastlock * p_lock */
65   0,                          /* int p_signal */
66   NULL,                       /* sigjmp_buf * p_signal_buf */
67   NULL,                       /* sigjmp_buf * p_cancel_buf */
68   0,                          /* char p_terminated */
69   0,                          /* char p_detached */
70   0,                          /* char p_exited */
71   NULL,                       /* void * p_retval */
72   0,                          /* int p_retval */
73   NULL,                       /* pthread_descr p_joining */
74   NULL,                       /* struct _pthread_cleanup_buffer * p_cleanup */
75   0,                          /* char p_cancelstate */
76   0,                          /* char p_canceltype */
77   0,                          /* char p_canceled */
78   &_errno,                    /* int *p_errnop */
79   0,                          /* int p_errno */
80   &_h_errno,                  /* int *p_h_errnop */
81   0,                          /* int p_h_errno */
82   NULL,                       /* char * p_in_sighandler */
83   0,                          /* char p_sigwaiting */
84   PTHREAD_START_ARGS_INITIALIZER(NULL),
85                               /* struct pthread_start_args p_start_args */
86   {NULL},                     /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */
87   {NULL},                     /* void * p_libc_specific[_LIBC_TSD_KEY_N] */
88   1,                          /* int p_userstack */
89   NULL,                       /* void * p_guardaddr */
90   0,                          /* size_t p_guardsize */
91   0,                          /* Always index 0 */
92   0,                          /* int p_report_events */
93   {{{0, }}, 0, NULL},         /* td_eventbuf_t p_eventbuf */
94   ATOMIC_INITIALIZER,         /* struct pthread_atomic p_resume_count */
95   0,                          /* char p_woken_by_cancel */
96   0,                          /* char p_condvar_avail */
97   0,                          /* char p_sem_avail */
98   NULL,                       /* struct pthread_extricate_if *p_extricate */
99   NULL,                       /* pthread_readlock_info *p_readlock_list; */
100   NULL,                       /* pthread_readlock_info *p_readlock_free; */
101   0                           /* int p_untracked_readlock_count; */
102 };
103
104 /* Descriptor of the manager thread; none of this is used but the error
105    variables, the p_pid and p_priority fields,
106    and the address for identification.  */
107
108 struct _pthread_descr_struct __pthread_manager_thread = {
109   {
110     {
111       &__pthread_manager_thread /* pthread_descr self */
112     }
113   },
114   NULL,                       /* pthread_descr p_nextlive */
115   NULL,                       /* pthread_descr p_prevlive */
116   NULL,                       /* pthread_descr p_nextwaiting */
117   NULL,                       /* pthread_descr p_nextlock */
118   0,                          /* int p_tid */
119   0,                          /* int p_pid */
120   0,                          /* int p_priority */
121   &__pthread_handles[1].h_lock, /* struct _pthread_fastlock * p_lock */
122   0,                          /* int p_signal */
123   NULL,                       /* sigjmp_buf * p_signal_buf */
124   NULL,                       /* sigjmp_buf * p_cancel_buf */
125   0,                          /* char p_terminated */
126   0,                          /* char p_detached */
127   0,                          /* char p_exited */
128   NULL,                       /* void * p_retval */
129   0,                          /* int p_retval */
130   NULL,                       /* pthread_descr p_joining */
131   NULL,                       /* struct _pthread_cleanup_buffer * p_cleanup */
132   0,                          /* char p_cancelstate */
133   0,                          /* char p_canceltype */
134   0,                          /* char p_canceled */
135   &__pthread_manager_thread.p_errno, /* int *p_errnop */
136   0,                          /* int p_errno */
137   NULL,                       /* int *p_h_errnop */
138   0,                          /* int p_h_errno */
139   NULL,                       /* char * p_in_sighandler */
140   0,                          /* char p_sigwaiting */
141   PTHREAD_START_ARGS_INITIALIZER(__pthread_manager),
142                               /* struct pthread_start_args p_start_args */
143   {NULL},                     /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */
144   {NULL},                     /* void * p_libc_specific[_LIBC_TSD_KEY_N] */
145   0,                          /* int p_userstack */
146   NULL,                       /* void * p_guardaddr */
147   0,                          /* size_t p_guardsize */
148   1,                          /* Always index 1 */
149   0,                          /* int p_report_events */
150   {{{0, }}, 0, NULL},         /* td_eventbuf_t p_eventbuf */
151   ATOMIC_INITIALIZER,         /* struct pthread_atomic p_resume_count */
152   0,                          /* char p_woken_by_cancel */
153   0,                          /* char p_condvar_avail */
154   0,                          /* char p_sem_avail */
155   NULL,                       /* struct pthread_extricate_if *p_extricate */
156   NULL,                       /* pthread_readlock_info *p_readlock_list; */
157   NULL,                       /* pthread_readlock_info *p_readlock_free; */
158   0                           /* int p_untracked_readlock_count; */
159 };
160
161 /* Pointer to the main thread (the father of the thread manager thread) */
162 /* Originally, this is the initial thread, but this changes after fork() */
163
164 pthread_descr __pthread_main_thread = &__pthread_initial_thread;
165
166 /* Limit between the stack of the initial thread (above) and the
167    stacks of other threads (below). Aligned on a STACK_SIZE boundary. */
168
169 char *__pthread_initial_thread_bos;
170
171 /* File descriptor for sending requests to the thread manager. */
172 /* Initially -1, meaning that the thread manager is not running. */
173
174 int __pthread_manager_request = -1;
175
176 /* Other end of the pipe for sending requests to the thread manager. */
177
178 int __pthread_manager_reader;
179
180 /* Limits of the thread manager stack */
181
182 char *__pthread_manager_thread_bos;
183 char *__pthread_manager_thread_tos;
184
185 /* For process-wide exit() */
186
187 int __pthread_exit_requested;
188 int __pthread_exit_code;
189
190 /* Maximum stack size.  */
191 size_t __pthread_max_stacksize;
192
193 /* Nozero if the machine has more than one processor.  */
194 int __pthread_smp_kernel;
195
196
197 #if !__ASSUME_REALTIME_SIGNALS
198 /* Pointers that select new or old suspend/resume functions
199    based on availability of rt signals. */
200
201 void (*__pthread_restart)(pthread_descr) = __pthread_restart_old;
202 void (*__pthread_suspend)(pthread_descr) = __pthread_suspend_old;
203 int (*__pthread_timedsuspend)(pthread_descr, const struct timespec *) = __pthread_timedsuspend_old;
204 #endif  /* __ASSUME_REALTIME_SIGNALS */
205
206 /* Communicate relevant LinuxThreads constants to gdb */
207
208 const int __pthread_threads_max = PTHREAD_THREADS_MAX;
209 const int __pthread_sizeof_handle = sizeof(struct pthread_handle_struct);
210 const int __pthread_offsetof_descr = offsetof(struct pthread_handle_struct,
211                                               h_descr);
212 const int __pthread_offsetof_pid = offsetof(struct _pthread_descr_struct,
213                                             p_pid);
214 const int __linuxthread_pthread_sizeof_descr
215   = sizeof(struct _pthread_descr_struct);
216
217 /* Forward declarations */
218
219 static void pthread_exit_process(int retcode, void *arg);
220 static void pthread_handle_sigcancel(int sig);
221 static void pthread_handle_sigrestart(int sig);
222 static void pthread_handle_sigdebug(int sig);
223
224 /* Signal numbers used for the communication.
225    In these variables we keep track of the used variables.  If the
226    platform does not support any real-time signals we will define the
227    values to some unreasonable value which will signal failing of all
228    the functions below.  */
229 #ifndef __SIGRTMIN
230 static int current_rtmin = -1;
231 static int current_rtmax = -1;
232 int __pthread_sig_restart = SIGUSR1;
233 int __pthread_sig_cancel = SIGUSR2;
234 int __pthread_sig_debug;
235 #else
236 static int current_rtmin;
237 static int current_rtmax;
238
239 #if __SIGRTMAX - __SIGRTMIN >= 3
240 int __pthread_sig_restart = __SIGRTMIN;
241 int __pthread_sig_cancel = __SIGRTMIN + 1;
242 int __pthread_sig_debug = __SIGRTMIN + 2;
243 #else
244 int __pthread_sig_restart = SIGUSR1;
245 int __pthread_sig_cancel = SIGUSR2;
246 int __pthread_sig_debug;
247 #endif
248
249 static int rtsigs_initialized;
250
251 #if !__ASSUME_REALTIME_SIGNALS
252 # include "testrtsig.h"
253 #endif
254
255 static void
256 init_rtsigs (void)
257 {
258 #if !__ASSUME_REALTIME_SIGNALS
259   if (__builtin_expect (!kernel_has_rtsig (), 0))
260     {
261       current_rtmin = -1;
262       current_rtmax = -1;
263 # if __SIGRTMAX - __SIGRTMIN >= 3
264       __pthread_sig_restart = SIGUSR1;
265       __pthread_sig_cancel = SIGUSR2;
266       __pthread_sig_debug = 0;
267 # endif
268     }
269   else
270 #endif  /* __ASSUME_REALTIME_SIGNALS */
271     {
272 #if __SIGRTMAX - __SIGRTMIN >= 3
273       current_rtmin = __SIGRTMIN + 3;
274 # if !__ASSUME_REALTIME_SIGNALS
275       __pthread_restart = __pthread_restart_new;
276       __pthread_suspend = __pthread_wait_for_restart_signal;
277       __pthread_timedsuspend = __pthread_timedsuspend_new;
278 # endif /* __ASSUME_REALTIME_SIGNALS */
279 #else
280       current_rtmin = __SIGRTMIN;
281 #endif
282
283       current_rtmax = __SIGRTMAX;
284     }
285
286   rtsigs_initialized = 1;
287 }
288 #endif
289
290 /* Return number of available real-time signal with highest priority.  */
291 int
292 __libc_current_sigrtmin (void)
293 {
294 #ifdef __SIGRTMIN
295   if (__builtin_expect (!rtsigs_initialized, 0))
296     init_rtsigs ();
297 #endif
298   return current_rtmin;
299 }
300
301 /* Return number of available real-time signal with lowest priority.  */
302 int
303 __libc_current_sigrtmax (void)
304 {
305 #ifdef __SIGRTMIN
306   if (__builtin_expect (!rtsigs_initialized, 0))
307     init_rtsigs ();
308 #endif
309   return current_rtmax;
310 }
311
312 /* Allocate real-time signal with highest/lowest available
313    priority.  Please note that we don't use a lock since we assume
314    this function to be called at program start.  */
315 int
316 __libc_allocate_rtsig (int high)
317 {
318 #ifndef __SIGRTMIN
319   return -1;
320 #else
321   if (__builtin_expect (!rtsigs_initialized, 0))
322     init_rtsigs ();
323   if (__builtin_expect (current_rtmin == -1, 0)
324       || __builtin_expect (current_rtmin > current_rtmax, 0))
325     /* We don't have anymore signal available.  */
326     return -1;
327
328   return high ? current_rtmin++ : current_rtmax--;
329 #endif
330 }
331
332 /* The function we use to get the kernel revision.  */
333 extern int __sysctl (int *name, int nlen, void *oldval, size_t *oldlenp,
334                      void *newval, size_t newlen);
335
336 /* Test whether the machine has more than one processor.  This is not the
337    best test but good enough.  More complicated tests would require `malloc'
338    which is not available at that time.  */
339 static int
340 is_smp_system (void)
341 {
342   static const int sysctl_args[] = { CTL_KERN, KERN_VERSION };
343   char buf[512];
344   size_t reslen = sizeof (buf);
345
346   /* Try reading the number using `sysctl' first.  */
347   if (__sysctl ((int *) sysctl_args,
348                 sizeof (sysctl_args) / sizeof (sysctl_args[0]),
349                 buf, &reslen, NULL, 0) < 0)
350     {
351       /*This was not successful.  Now try reading the /proc filesystem.  */
352       int fd = __open ("/proc/sys/kernel/version", O_RDONLY);
353       if (__builtin_expect (fd, 0) == -1
354           || (reslen = __read (fd, buf, sizeof (buf))) <= 0)
355         /* This also didn't work.  We give up and say it's a UP machine.  */
356         buf[0] = '\0';
357
358       __close (fd);
359     }
360
361   return strstr (buf, "SMP") != NULL;
362 }
363
364
365 /* Initialize the pthread library.
366    Initialization is split in two functions:
367    - a constructor function that blocks the __pthread_sig_restart signal
368      (must do this very early, since the program could capture the signal
369       mask with e.g. sigsetjmp before creating the first thread);
370    - a regular function called from pthread_create when needed. */
371
372 static void pthread_initialize(void) __attribute__((constructor));
373
374 extern void *__dso_handle __attribute__ ((weak));
375
376
377 /* Do some minimal initialization which has to be done during the
378    startup of the C library.  */
379 void
380 __pthread_initialize_minimal(void)
381 {
382   /* If we have special thread_self processing, initialize that for the
383      main thread now.  */
384 #ifdef INIT_THREAD_SELF
385   INIT_THREAD_SELF(&__pthread_initial_thread, 0);
386 #endif
387 }
388
389
390 static void pthread_initialize(void)
391 {
392   struct sigaction sa;
393   sigset_t mask;
394
395   /* If already done (e.g. by a constructor called earlier!), bail out */
396   if (__pthread_initial_thread_bos != NULL) return;
397 #ifdef TEST_FOR_COMPARE_AND_SWAP
398   /* Test if compare-and-swap is available */
399   __pthread_has_cas = compare_and_swap_is_available();
400 #endif
401   /* For the initial stack, reserve at least STACK_SIZE bytes of stack
402      below the current stack address, and align that on a
403      STACK_SIZE boundary. */
404   __pthread_initial_thread_bos =
405     (char *)(((long)CURRENT_STACK_FRAME - 2 * STACK_SIZE) & ~(STACK_SIZE - 1));
406   /* Update the descriptor for the initial thread. */
407   __pthread_initial_thread.p_pid = __getpid();
408   /* Likewise for the resolver state _res.  */
409   __pthread_initial_thread.p_resp = &_res;
410 #ifdef __SIGRTMIN
411   /* Initialize real-time signals. */
412   init_rtsigs ();
413 #endif
414   /* Setup signal handlers for the initial thread.
415      Since signal handlers are shared between threads, these settings
416      will be inherited by all other threads. */
417   sa.sa_handler = pthread_handle_sigrestart;
418   sigemptyset(&sa.sa_mask);
419   sa.sa_flags = 0;
420   __libc_sigaction(__pthread_sig_restart, &sa, NULL);
421   sa.sa_handler = pthread_handle_sigcancel;
422   // sa.sa_flags = 0;
423   __libc_sigaction(__pthread_sig_cancel, &sa, NULL);
424   if (__pthread_sig_debug > 0) {
425     sa.sa_handler = pthread_handle_sigdebug;
426     sigemptyset(&sa.sa_mask);
427     // sa.sa_flags = 0;
428     __libc_sigaction(__pthread_sig_debug, &sa, NULL);
429   }
430   /* Initially, block __pthread_sig_restart. Will be unblocked on demand. */
431   sigemptyset(&mask);
432   sigaddset(&mask, __pthread_sig_restart);
433   sigprocmask(SIG_BLOCK, &mask, NULL);
434   /* Register an exit function to kill all other threads. */
435   /* Do it early so that user-registered atexit functions are called
436      before pthread_exit_process. */
437   if (__builtin_expect (&__dso_handle != NULL, 1))
438     /* The cast is a bit unclean.  The function expects two arguments but
439        we can only pass one.  Fortunately this is not a problem since the
440        second argument of `pthread_exit_process' is simply ignored.  */
441     __cxa_atexit((void (*) (void *)) pthread_exit_process, NULL, __dso_handle);
442   else
443     __on_exit (pthread_exit_process, NULL);
444   /* How many processors.  */
445   __pthread_smp_kernel = is_smp_system ();
446 }
447
448 void __pthread_initialize(void)
449 {
450   pthread_initialize();
451 }
452
453 int __pthread_initialize_manager(void)
454 {
455   int manager_pipe[2];
456   int pid;
457   struct pthread_request request;
458   struct rlimit limit;
459   int max_stack;
460
461   getrlimit(RLIMIT_STACK, &limit);
462 #ifdef FLOATING_STACKS
463   if (limit.rlim_cur == RLIM_INFINITY)
464     limit.rlim_cur = ARCH_STACK_MAX_SIZE;
465 # ifdef NEED_SEPARATE_REGISTER_STACK
466   max_stack = limit.rlim_cur / 2;
467 # else
468   max_stack = limit.rlim_cur;
469 #endif
470
471   __pthread_max_stacksize = max_stack;
472 #else
473   /* Play with the stack size limit to make sure that no stack ever grows
474      beyond STACK_SIZE minus one page (to act as a guard page). */
475 # ifdef NEED_SEPARATE_REGISTER_STACK
476   /* STACK_SIZE bytes hold both the main stack and register backing
477      store. The rlimit value applies to each individually.  */
478   max_stack = STACK_SIZE/2 - __getpagesize ();
479 # else
480   max_stack = STACK_SIZE - __getpagesize();
481 # endif
482   if (limit.rlim_cur > max_stack) {
483     limit.rlim_cur = max_stack;
484     setrlimit(RLIMIT_STACK, &limit);
485   }
486 #endif
487   /* If basic initialization not done yet (e.g. we're called from a
488      constructor run before our constructor), do it now */
489   if (__pthread_initial_thread_bos == NULL) pthread_initialize();
490   /* Setup stack for thread manager */
491   __pthread_manager_thread_bos = malloc(THREAD_MANAGER_STACK_SIZE);
492   if (__pthread_manager_thread_bos == NULL) return -1;
493   __pthread_manager_thread_tos =
494     __pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;
495   /* Setup pipe to communicate with thread manager */
496   if (pipe(manager_pipe) == -1) {
497     free(__pthread_manager_thread_bos);
498     return -1;
499   }
500   /* Start the thread manager */
501   pid = 0;
502   if (__builtin_expect (__pthread_initial_thread.p_report_events, 0))
503     {
504       /* It's a bit more complicated.  We have to report the creation of
505          the manager thread.  */
506       int idx = __td_eventword (TD_CREATE);
507       uint32_t mask = __td_eventmask (TD_CREATE);
508
509       if ((mask & (__pthread_threads_events.event_bits[idx]
510                    | __pthread_initial_thread.p_eventbuf.eventmask.event_bits[idx]))
511           != 0)
512         {
513           __pthread_lock(__pthread_manager_thread.p_lock, NULL);
514
515 #ifdef NEED_SEPARATE_REGISTER_STACK
516           pid = __clone2(__pthread_manager_event,
517                          (void **) __pthread_manager_thread_bos,
518                          THREAD_MANAGER_STACK_SIZE,
519                          CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
520                          (void *)(long)manager_pipe[0]);
521 #else
522           pid = __clone(__pthread_manager_event,
523                         (void **) __pthread_manager_thread_tos,
524                         CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
525                         (void *)(long)manager_pipe[0]);
526 #endif
527
528           if (pid != -1)
529             {
530               /* Now fill in the information about the new thread in
531                  the newly created thread's data structure.  We cannot let
532                  the new thread do this since we don't know whether it was
533                  already scheduled when we send the event.  */
534               __pthread_manager_thread.p_eventbuf.eventdata =
535                 &__pthread_manager_thread;
536               __pthread_manager_thread.p_eventbuf.eventnum = TD_CREATE;
537               __pthread_last_event = &__pthread_manager_thread;
538               __pthread_manager_thread.p_tid = 2* PTHREAD_THREADS_MAX + 1;
539               __pthread_manager_thread.p_pid = pid;
540
541               /* Now call the function which signals the event.  */
542               __linuxthreads_create_event ();
543             }
544
545           /* Now restart the thread.  */
546           __pthread_unlock(__pthread_manager_thread.p_lock);
547         }
548     }
549
550   if (__builtin_expect (pid, 0) == 0)
551     {
552 #ifdef NEED_SEPARATE_REGISTER_STACK
553       pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos,
554                      THREAD_MANAGER_STACK_SIZE,
555                      CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
556                      (void *)(long)manager_pipe[0]);
557 #else
558       pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
559                     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
560                     (void *)(long)manager_pipe[0]);
561 #endif
562     }
563   if (__builtin_expect (pid, 0) == -1) {
564     free(__pthread_manager_thread_bos);
565     __libc_close(manager_pipe[0]);
566     __libc_close(manager_pipe[1]);
567     return -1;
568   }
569   __pthread_manager_request = manager_pipe[1]; /* writing end */
570   __pthread_manager_reader = manager_pipe[0]; /* reading end */
571   __pthread_manager_thread.p_tid = 2* PTHREAD_THREADS_MAX + 1;
572   __pthread_manager_thread.p_pid = pid;
573   /* Make gdb aware of new thread manager */
574   if (__builtin_expect (__pthread_threads_debug, 0) && __pthread_sig_debug > 0)
575     {
576       raise(__pthread_sig_debug);
577       /* We suspend ourself and gdb will wake us up when it is
578          ready to handle us. */
579       __pthread_wait_for_restart_signal(thread_self());
580     }
581   /* Synchronize debugging of the thread manager */
582   request.req_kind = REQ_DEBUG;
583   __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
584   return 0;
585 }
586
587 /* Thread creation */
588
589 int __pthread_create_2_1(pthread_t *thread, const pthread_attr_t *attr,
590                          void * (*start_routine)(void *), void *arg)
591 {
592   pthread_descr self = thread_self();
593   struct pthread_request request;
594   int retval;
595   if (__builtin_expect (__pthread_manager_request, 0) < 0) {
596     if (__pthread_initialize_manager() < 0) return EAGAIN;
597   }
598   request.req_thread = self;
599   request.req_kind = REQ_CREATE;
600   request.req_args.create.attr = attr;
601   request.req_args.create.fn = start_routine;
602   request.req_args.create.arg = arg;
603   sigprocmask(SIG_SETMASK, (const sigset_t *) NULL,
604               &request.req_args.create.mask);
605   __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
606   suspend(self);
607   retval = THREAD_GETMEM(self, p_retcode);
608   if (__builtin_expect (retval, 0) == 0)
609     *thread = (pthread_t) THREAD_GETMEM(self, p_retval);
610   return retval;
611 }
612
613 versioned_symbol (libpthread, __pthread_create_2_1, pthread_create, GLIBC_2_1);
614
615 #if SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_1)
616
617 int __pthread_create_2_0(pthread_t *thread, const pthread_attr_t *attr,
618                          void * (*start_routine)(void *), void *arg)
619 {
620   /* The ATTR attribute is not really of type `pthread_attr_t *'.  It has
621      the old size and access to the new members might crash the program.
622      We convert the struct now.  */
623   pthread_attr_t new_attr;
624
625   if (attr != NULL)
626     {
627       size_t ps = __getpagesize ();
628
629       memcpy (&new_attr, attr,
630               (size_t) &(((pthread_attr_t*)NULL)->__guardsize));
631       new_attr.__guardsize = ps;
632       new_attr.__stackaddr_set = 0;
633       new_attr.__stackaddr = NULL;
634       new_attr.__stacksize = STACK_SIZE - ps;
635       attr = &new_attr;
636     }
637   return __pthread_create_2_1 (thread, attr, start_routine, arg);
638 }
639 compat_symbol (libpthread, __pthread_create_2_0, pthread_create, GLIBC_2_0);
640 #endif
641
642 /* Simple operations on thread identifiers */
643
644 pthread_t pthread_self(void)
645 {
646   pthread_descr self = thread_self();
647   return THREAD_GETMEM(self, p_tid);
648 }
649
650 int pthread_equal(pthread_t thread1, pthread_t thread2)
651 {
652   return thread1 == thread2;
653 }
654
655 /* Helper function for thread_self in the case of user-provided stacks */
656
657 #ifndef THREAD_SELF
658
659 pthread_descr __pthread_find_self()
660 {
661   char * sp = CURRENT_STACK_FRAME;
662   pthread_handle h;
663
664   /* __pthread_handles[0] is the initial thread, __pthread_handles[1] is
665      the manager threads handled specially in thread_self(), so start at 2 */
666   h = __pthread_handles + 2;
667   while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom)) h++;
668   return h->h_descr;
669 }
670
671 #endif
672
673 /* Thread scheduling */
674
675 int pthread_setschedparam(pthread_t thread, int policy,
676                           const struct sched_param *param)
677 {
678   pthread_handle handle = thread_handle(thread);
679   pthread_descr th;
680
681   __pthread_lock(&handle->h_lock, NULL);
682   if (__builtin_expect (invalid_handle(handle, thread), 0)) {
683     __pthread_unlock(&handle->h_lock);
684     return ESRCH;
685   }
686   th = handle->h_descr;
687   if (__builtin_expect (__sched_setscheduler(th->p_pid, policy, param) == -1,
688                         0)) {
689     __pthread_unlock(&handle->h_lock);
690     return errno;
691   }
692   th->p_priority = policy == SCHED_OTHER ? 0 : param->sched_priority;
693   __pthread_unlock(&handle->h_lock);
694   if (__pthread_manager_request >= 0)
695     __pthread_manager_adjust_prio(th->p_priority);
696   return 0;
697 }
698
699 int pthread_getschedparam(pthread_t thread, int *policy,
700                           struct sched_param *param)
701 {
702   pthread_handle handle = thread_handle(thread);
703   int pid, pol;
704
705   __pthread_lock(&handle->h_lock, NULL);
706   if (__builtin_expect (invalid_handle(handle, thread), 0)) {
707     __pthread_unlock(&handle->h_lock);
708     return ESRCH;
709   }
710   pid = handle->h_descr->p_pid;
711   __pthread_unlock(&handle->h_lock);
712   pol = __sched_getscheduler(pid);
713   if (__builtin_expect (pol, 0) == -1) return errno;
714   if (__sched_getparam(pid, param) == -1) return errno;
715   *policy = pol;
716   return 0;
717 }
718
719 int __pthread_yield ()
720 {
721   /* For now this is equivalent with the POSIX call.  */
722   return sched_yield ();
723 }
724 weak_alias (__pthread_yield, pthread_yield)
725
726 /* Process-wide exit() request */
727
728 static void pthread_exit_process(int retcode, void *arg)
729 {
730   if (__builtin_expect (__pthread_manager_request, 0) >= 0) {
731     struct pthread_request request;
732     pthread_descr self = thread_self();
733
734     request.req_thread = self;
735     request.req_kind = REQ_PROCESS_EXIT;
736     request.req_args.exit.code = retcode;
737     __libc_write(__pthread_manager_request,
738                  (char *) &request, sizeof(request));
739     suspend(self);
740     /* Main thread should accumulate times for thread manager and its
741        children, so that timings for main thread account for all threads. */
742     if (self == __pthread_main_thread)
743       waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
744   }
745 }
746
747 /* The handler for the RESTART signal just records the signal received
748    in the thread descriptor, and optionally performs a siglongjmp
749    (for pthread_cond_timedwait). */
750
751 static void pthread_handle_sigrestart(int sig)
752 {
753   pthread_descr self = thread_self();
754   THREAD_SETMEM(self, p_signal, sig);
755   if (THREAD_GETMEM(self, p_signal_jmp) != NULL)
756     siglongjmp(*THREAD_GETMEM(self, p_signal_jmp), 1);
757 }
758
759 /* The handler for the CANCEL signal checks for cancellation
760    (in asynchronous mode), for process-wide exit and exec requests.
761    For the thread manager thread, redirect the signal to
762    __pthread_manager_sighandler. */
763
764 static void pthread_handle_sigcancel(int sig)
765 {
766   pthread_descr self = thread_self();
767   sigjmp_buf * jmpbuf;
768
769   if (self == &__pthread_manager_thread)
770     {
771       __pthread_manager_sighandler(sig);
772       return;
773     }
774   if (__builtin_expect (__pthread_exit_requested, 0)) {
775     /* Main thread should accumulate times for thread manager and its
776        children, so that timings for main thread account for all threads. */
777     if (self == __pthread_main_thread)
778       waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
779     _exit(__pthread_exit_code);
780   }
781   if (__builtin_expect (THREAD_GETMEM(self, p_canceled), 0)
782       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
783     if (THREAD_GETMEM(self, p_canceltype) == PTHREAD_CANCEL_ASYNCHRONOUS)
784       pthread_exit(PTHREAD_CANCELED);
785     jmpbuf = THREAD_GETMEM(self, p_cancel_jmp);
786     if (jmpbuf != NULL) {
787       THREAD_SETMEM(self, p_cancel_jmp, NULL);
788       siglongjmp(*jmpbuf, 1);
789     }
790   }
791 }
792
793 /* Handler for the DEBUG signal.
794    The debugging strategy is as follows:
795    On reception of a REQ_DEBUG request (sent by new threads created to
796    the thread manager under debugging mode), the thread manager throws
797    __pthread_sig_debug to itself. The debugger (if active) intercepts
798    this signal, takes into account new threads and continue execution
799    of the thread manager by propagating the signal because it doesn't
800    know what it is specifically done for. In the current implementation,
801    the thread manager simply discards it. */
802
803 static void pthread_handle_sigdebug(int sig)
804 {
805   /* Nothing */
806 }
807
808 /* Reset the state of the thread machinery after a fork().
809    Close the pipe used for requests and set the main thread to the forked
810    thread.
811    Notice that we can't free the stack segments, as the forked thread
812    may hold pointers into them. */
813
814 void __pthread_reset_main_thread()
815 {
816   pthread_descr self = thread_self();
817   struct rlimit limit;
818
819   if (__pthread_manager_request != -1) {
820     /* Free the thread manager stack */
821     free(__pthread_manager_thread_bos);
822     __pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
823     /* Close the two ends of the pipe */
824     __libc_close(__pthread_manager_request);
825     __libc_close(__pthread_manager_reader);
826     __pthread_manager_request = __pthread_manager_reader = -1;
827   }
828
829   /* Update the pid of the main thread */
830   THREAD_SETMEM(self, p_pid, __getpid());
831   /* Make the forked thread the main thread */
832   __pthread_main_thread = self;
833   THREAD_SETMEM(self, p_nextlive, self);
834   THREAD_SETMEM(self, p_prevlive, self);
835   /* Now this thread modifies the global variables.  */
836   THREAD_SETMEM(self, p_errnop, &_errno);
837   THREAD_SETMEM(self, p_h_errnop, &_h_errno);
838   THREAD_SETMEM(self, p_resp, &_res);
839
840   if (getrlimit (RLIMIT_STACK, &limit) == 0
841       && limit.rlim_cur != limit.rlim_max) {
842     limit.rlim_cur = limit.rlim_max;
843     setrlimit (STACK_SIZE, &limit);
844   }
845 }
846
847 /* Process-wide exec() request */
848
849 void __pthread_kill_other_threads_np(void)
850 {
851   struct sigaction sa;
852   /* Terminate all other threads and thread manager */
853   pthread_exit_process(0, NULL);
854   /* Make current thread the main thread in case the calling thread
855      changes its mind, does not exec(), and creates new threads instead. */
856   __pthread_reset_main_thread();
857
858   /* Reset the signal handlers behaviour for the signals the
859      implementation uses since this would be passed to the new
860      process.  */
861   sigemptyset(&sa.sa_mask);
862   sa.sa_flags = 0;
863   sa.sa_handler = SIG_DFL;
864   __libc_sigaction(__pthread_sig_restart, &sa, NULL);
865   __libc_sigaction(__pthread_sig_cancel, &sa, NULL);
866   if (__pthread_sig_debug > 0)
867     __libc_sigaction(__pthread_sig_debug, &sa, NULL);
868 }
869 weak_alias (__pthread_kill_other_threads_np, pthread_kill_other_threads_np)
870
871 /* Concurrency symbol level.  */
872 static int current_level;
873
874 int __pthread_setconcurrency(int level)
875 {
876   /* We don't do anything unless we have found a useful interpretation.  */
877   current_level = level;
878   return 0;
879 }
880 weak_alias (__pthread_setconcurrency, pthread_setconcurrency)
881
882 int __pthread_getconcurrency(void)
883 {
884   return current_level;
885 }
886 weak_alias (__pthread_getconcurrency, pthread_getconcurrency)
887
888 /* Primitives for controlling thread execution */
889
890 void __pthread_wait_for_restart_signal(pthread_descr self)
891 {
892   sigset_t mask;
893
894   sigprocmask(SIG_SETMASK, NULL, &mask); /* Get current signal mask */
895   sigdelset(&mask, __pthread_sig_restart); /* Unblock the restart signal */
896   THREAD_SETMEM(self, p_signal, 0);
897   do {
898     sigsuspend(&mask);                   /* Wait for signal */
899   } while (THREAD_GETMEM(self, p_signal) !=__pthread_sig_restart);
900 }
901
902 #if !__ASSUME_REALTIME_SIGNALS
903 /* The _old variants are for 2.0 and early 2.1 kernels which don't have RT
904    signals.
905    On these kernels, we use SIGUSR1 and SIGUSR2 for restart and cancellation.
906    Since the restart signal does not queue, we use an atomic counter to create
907    queuing semantics. This is needed to resolve a rare race condition in
908    pthread_cond_timedwait_relative. */
909
910 void __pthread_restart_old(pthread_descr th)
911 {
912   if (atomic_increment(&th->p_resume_count) == -1)
913     kill(th->p_pid, __pthread_sig_restart);
914 }
915
916 void __pthread_suspend_old(pthread_descr self)
917 {
918   if (atomic_decrement(&self->p_resume_count) <= 0)
919     __pthread_wait_for_restart_signal(self);
920 }
921
922 int
923 __pthread_timedsuspend_old(pthread_descr self, const struct timespec *abstime)
924 {
925   sigset_t unblock, initial_mask;
926   int was_signalled = 0;
927   sigjmp_buf jmpbuf;
928
929   if (atomic_decrement(&self->p_resume_count) == 0) {
930     /* Set up a longjmp handler for the restart signal, unblock
931        the signal and sleep. */
932
933     if (sigsetjmp(jmpbuf, 1) == 0) {
934       THREAD_SETMEM(self, p_signal_jmp, &jmpbuf);
935       THREAD_SETMEM(self, p_signal, 0);
936       /* Unblock the restart signal */
937       sigemptyset(&unblock);
938       sigaddset(&unblock, __pthread_sig_restart);
939       sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask);
940
941       while (1) {
942         struct timeval now;
943         struct timespec reltime;
944
945         /* Compute a time offset relative to now.  */
946         __gettimeofday (&now, NULL);
947         reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000;
948         reltime.tv_sec = abstime->tv_sec - now.tv_sec;
949         if (reltime.tv_nsec < 0) {
950           reltime.tv_nsec += 1000000000;
951           reltime.tv_sec -= 1;
952         }
953
954         /* Sleep for the required duration. If woken by a signal,
955            resume waiting as required by Single Unix Specification.  */
956         if (reltime.tv_sec < 0 || __libc_nanosleep(&reltime, NULL) == 0)
957           break;
958       }
959
960       /* Block the restart signal again */
961       sigprocmask(SIG_SETMASK, &initial_mask, NULL);
962       was_signalled = 0;
963     } else {
964       was_signalled = 1;
965     }
966     THREAD_SETMEM(self, p_signal_jmp, NULL);
967   }
968
969   /* Now was_signalled is true if we exited the above code
970      due to the delivery of a restart signal.  In that case,
971      we know we have been dequeued and resumed and that the
972      resume count is balanced.  Otherwise, there are some
973      cases to consider. First, try to bump up the resume count
974      back to zero. If it goes to 1, it means restart() was
975      invoked on this thread. The signal must be consumed
976      and the count bumped down and everything is cool. We
977      can return a 1 to the caller.
978      Otherwise, no restart was delivered yet, so a potential
979      race exists; we return a 0 to the caller which must deal
980      with this race in an appropriate way; for example by
981      atomically removing the thread from consideration for a
982      wakeup---if such a thing fails, it means a restart is
983      being delivered. */
984
985   if (!was_signalled) {
986     if (atomic_increment(&self->p_resume_count) != -1) {
987       __pthread_wait_for_restart_signal(self);
988       atomic_decrement(&self->p_resume_count); /* should be zero now! */
989       /* woke spontaneously and consumed restart signal */
990       return 1;
991     }
992     /* woke spontaneously but did not consume restart---caller must resolve */
993     return 0;
994   }
995   /* woken due to restart signal */
996   return 1;
997 }
998 #endif /* __ASSUME_REALTIME_SIGNALS */
999
1000 void __pthread_restart_new(pthread_descr th)
1001 {
1002     kill(th->p_pid, __pthread_sig_restart);
1003 }
1004
1005 /* There is no __pthread_suspend_new because it would just
1006    be a wasteful wrapper for __pthread_wait_for_restart_signal */
1007
1008 int
1009 __pthread_timedsuspend_new(pthread_descr self, const struct timespec *abstime)
1010 {
1011   sigset_t unblock, initial_mask;
1012   int was_signalled = 0;
1013   sigjmp_buf jmpbuf;
1014
1015   if (sigsetjmp(jmpbuf, 1) == 0) {
1016     THREAD_SETMEM(self, p_signal_jmp, &jmpbuf);
1017     THREAD_SETMEM(self, p_signal, 0);
1018     /* Unblock the restart signal */
1019     sigemptyset(&unblock);
1020     sigaddset(&unblock, __pthread_sig_restart);
1021     sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask);
1022
1023     while (1) {
1024       struct timeval now;
1025       struct timespec reltime;
1026
1027       /* Compute a time offset relative to now.  */
1028       __gettimeofday (&now, NULL);
1029       reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000;
1030       reltime.tv_sec = abstime->tv_sec - now.tv_sec;
1031       if (reltime.tv_nsec < 0) {
1032         reltime.tv_nsec += 1000000000;
1033         reltime.tv_sec -= 1;
1034       }
1035
1036       /* Sleep for the required duration. If woken by a signal,
1037          resume waiting as required by Single Unix Specification.  */
1038       if (reltime.tv_sec < 0 || __libc_nanosleep(&reltime, NULL) == 0)
1039         break;
1040     }
1041
1042     /* Block the restart signal again */
1043     sigprocmask(SIG_SETMASK, &initial_mask, NULL);
1044     was_signalled = 0;
1045   } else {
1046     was_signalled = 1;
1047   }
1048   THREAD_SETMEM(self, p_signal_jmp, NULL);
1049
1050   /* Now was_signalled is true if we exited the above code
1051      due to the delivery of a restart signal.  In that case,
1052      everything is cool. We have been removed from whatever
1053      we were waiting on by the other thread, and consumed its signal.
1054
1055      Otherwise we this thread woke up spontaneously, or due to a signal other
1056      than restart. This is an ambiguous case  that must be resolved by
1057      the caller; the thread is still eligible for a restart wakeup
1058      so there is a race. */
1059
1060   return was_signalled;
1061 }
1062
1063
1064 /* Debugging aid */
1065
1066 #ifdef DEBUG
1067 #include <stdarg.h>
1068
1069 void __pthread_message(char * fmt, ...)
1070 {
1071   char buffer[1024];
1072   va_list args;
1073   sprintf(buffer, "%05d : ", __getpid());
1074   va_start(args, fmt);
1075   vsnprintf(buffer + 8, sizeof(buffer) - 8, fmt, args);
1076   va_end(args);
1077   __libc_write(2, buffer, strlen(buffer));
1078 }
1079
1080 #endif
1081
1082
1083 #ifndef SHARED
1084 /* We need a hook to force the cancelation wrappers to be linked in when
1085    static libpthread is used.  */
1086 extern const int __pthread_provide_wrappers;
1087 static const int *const __pthread_require_wrappers =
1088   &__pthread_provide_wrappers;
1089 #endif