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