LinuxThreads library.
[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 <stddef.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <sys/wait.h>
24 #include "pthread.h"
25 #include "internals.h"
26 #include "spinlock.h"
27 #include "restart.h"
28
29 /* Descriptor of the initial thread */
30
31 struct _pthread_descr_struct __pthread_initial_thread = {
32   &__pthread_initial_thread,  /* pthread_descr p_nextlive */
33   &__pthread_initial_thread,  /* pthread_descr p_prevlive */
34   NULL,                       /* pthread_descr p_nextwaiting */
35   PTHREAD_THREADS_MAX,        /* pthread_t p_tid */
36   0,                          /* int p_pid */
37   0,                          /* int p_priority */
38   &__pthread_handles[0].h_spinlock, /* int * p_spinlock */
39   0,                          /* int p_signal */
40   NULL,                       /* sigjmp_buf * p_signal_buf */
41   NULL,                       /* sigjmp_buf * p_cancel_buf */
42   0,                          /* char p_terminated */
43   0,                          /* char p_detached */
44   0,                          /* char p_exited */
45   NULL,                       /* void * p_retval */
46   0,                          /* int p_retval */
47   NULL,                       /* pthread_descr p_joining */
48   NULL,                       /* struct _pthread_cleanup_buffer * p_cleanup */
49   0,                          /* char p_cancelstate */
50   0,                          /* char p_canceltype */
51   0,                          /* char p_canceled */
52   NULL,                       /* int *p_errnop */
53   0,                          /* int p_errno */
54   NULL,                       /* int *p_h_errnop */
55   0,                          /* int p_h_errno */
56   PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
57   {NULL}                      /* void * p_specific[PTHREAD_KEYS_MAX] */
58 };
59
60 /* Descriptor of the manager thread; none of this is used but the error
61    variables and the address for identification.  */
62
63 struct _pthread_descr_struct __pthread_manager_thread = {
64   NULL,                       /* pthread_descr p_nextlive */
65   NULL,                       /* pthread_descr p_prevlive */
66   NULL,                       /* pthread_descr p_nextwaiting */
67   0,                          /* int p_tid */
68   0,                          /* int p_pid */
69   0,                          /* int p_priority */
70   NULL,                       /* int * p_spinlock */
71   0,                          /* int p_signal */
72   NULL,                       /* sigjmp_buf * p_signal_buf */
73   NULL,                       /* sigjmp_buf * p_cancel_buf */
74   0,                          /* char p_terminated */
75   0,                          /* char p_detached */
76   0,                          /* char p_exited */
77   NULL,                       /* void * p_retval */
78   0,                          /* int p_retval */
79   NULL,                       /* pthread_descr p_joining */
80   NULL,                       /* struct _pthread_cleanup_buffer * p_cleanup */
81   0,                          /* char p_cancelstate */
82   0,                          /* char p_canceltype */
83   0,                          /* char p_canceled */
84   NULL,                       /* int *p_errnop */
85   0,                          /* int p_errno */
86   NULL,                       /* int *p_h_errnop */
87   0,                          /* int p_h_errno */
88   PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
89   {NULL}                      /* void * p_specific[PTHREAD_KEYS_MAX] */
90 };
91
92 /* Pointer to the main thread (the father of the thread manager thread) */
93 /* Originally, this is the initial thread, but this changes after fork() */
94
95 pthread_descr __pthread_main_thread = &__pthread_initial_thread;
96
97 /* Limit between the stack of the initial thread (above) and the
98    stacks of other threads (below). Aligned on a STACK_SIZE boundary. */
99
100 char *__pthread_initial_thread_bos = NULL;
101
102 /* File descriptor for sending requests to the thread manager. */
103 /* Initially -1, meaning that the thread manager is not running. */
104
105 int __pthread_manager_request = -1;
106
107 /* Other end of the pipe for sending requests to the thread manager. */
108
109 int __pthread_manager_reader;
110
111 /* PID of thread manager */
112
113 static int __pthread_manager_pid;
114
115 /* Limits of the thread manager stack */
116
117 char *__pthread_manager_thread_bos = NULL;
118 char *__pthread_manager_thread_tos = NULL;
119
120 /* For process-wide exit() */
121
122 int __pthread_exit_requested = 0;
123 int __pthread_exit_code = 0;
124
125 /* Signal numbers used for the communication.  */
126 int __pthread_sig_restart;
127 int __pthread_sig_cancel;
128
129 /* These variables are used by the setup code.  */
130 extern int _errno;
131 extern int _h_errno;
132
133 /* Forward declarations */
134
135 static void pthread_exit_process(int retcode, void *arg);
136 static void pthread_handle_sigcancel(int sig);
137
138 /* Initialize the pthread library.
139    Initialization is split in two functions:
140    - a constructor function that blocks the PTHREAD_SIG_RESTART signal
141      (must do this very early, since the program could capture the signal
142       mask with e.g. sigsetjmp before creating the first thread);
143    - a regular function called from pthread_create when needed. */
144
145 static void pthread_initialize(void) __attribute__((constructor));
146
147 static void pthread_initialize(void)
148 {
149   struct sigaction sa;
150   sigset_t mask;
151
152   /* If already done (e.g. by a constructor called earlier!), bail out */
153   if (__pthread_initial_thread_bos != NULL) return;
154   /* For the initial stack, reserve at least STACK_SIZE bytes of stack
155      below the current stack address, and align that on a
156      STACK_SIZE boundary. */
157   __pthread_initial_thread_bos =
158     (char *)(((long)CURRENT_STACK_FRAME - 2 * STACK_SIZE) & ~(STACK_SIZE - 1));
159   /* Update the descriptor for the initial thread. */
160   __pthread_initial_thread.p_pid = __getpid();
161   /* If we have special thread_self processing, initialize that for the
162      main thread now.  */
163 #ifdef INIT_THREAD_SELF
164   INIT_THREAD_SELF(&__pthread_initial_thread);
165 #endif
166   /* The errno/h_errno variable of the main thread are the global ones.  */
167   __pthread_initial_thread.p_errnop = &_errno;
168   __pthread_initial_thread.p_h_errnop = &_h_errno;
169   /* Allocate the signals used.  */
170   __pthread_sig_restart = __libc_allocate_rtsig (1);
171   __pthread_sig_cancel = __libc_allocate_rtsig (1);
172   if (__pthread_sig_restart < 0 || __pthread_sig_cancel < 0)
173     {
174       /* The kernel does not support real-time signals.  Use as before
175          the available signals in the fixed set.  */
176       __pthread_sig_restart = SIGUSR1;
177       __pthread_sig_cancel = SIGUSR2;
178     }
179   /* Setup signal handlers for the initial thread.
180      Since signal handlers are shared between threads, these settings
181      will be inherited by all other threads. */
182   sa.sa_handler = __pthread_sighandler;
183   sigemptyset(&sa.sa_mask);
184   sa.sa_flags = SA_RESTART; /* does not matter for regular threads, but
185                                better for the thread manager */
186   sigaction(PTHREAD_SIG_RESTART, &sa, NULL);
187   sa.sa_handler = pthread_handle_sigcancel;
188   sa.sa_flags = 0;
189   sigaction(PTHREAD_SIG_CANCEL, &sa, NULL);
190
191   /* Initially, block PTHREAD_SIG_RESTART. Will be unblocked on demand. */
192   sigemptyset(&mask);
193   sigaddset(&mask, PTHREAD_SIG_RESTART);
194   sigprocmask(SIG_BLOCK, &mask, NULL);
195   /* Register an exit function to kill all other threads. */
196   /* Do it early so that user-registered atexit functions are called
197      before pthread_exit_process. */
198   __on_exit(pthread_exit_process, NULL);
199 }
200
201 static int pthread_initialize_manager(void)
202 {
203   int manager_pipe[2];
204
205   /* If basic initialization not done yet (e.g. we're called from a
206      constructor run before our constructor), do it now */
207   if (__pthread_initial_thread_bos == NULL) pthread_initialize();
208   /* Setup stack for thread manager */
209   __pthread_manager_thread_bos = malloc(THREAD_MANAGER_STACK_SIZE);
210   if (__pthread_manager_thread_bos == NULL) return -1;
211   __pthread_manager_thread_tos =
212     __pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;
213   /* Setup pipe to communicate with thread manager */
214   if (pipe(manager_pipe) == -1) {
215     free(__pthread_manager_thread_bos);
216     return -1;
217   }
218   __pthread_manager_request = manager_pipe[1]; /* writing end */
219   __pthread_manager_reader = manager_pipe[0]; /* reading end */
220   /* Start the thread manager */
221   __pthread_manager_pid =
222     __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
223             CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
224             (void *)(long)manager_pipe[0]);
225   if (__pthread_manager_pid == -1) {
226     free(__pthread_manager_thread_bos);
227     __libc_close(manager_pipe[0]);
228     __libc_close(manager_pipe[1]);
229     __pthread_manager_request = -1;
230     return -1;
231   }
232   return 0;
233 }
234
235 /* Thread creation */
236
237 int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
238                    void * (*start_routine)(void *), void *arg)
239 {
240   pthread_descr self = thread_self();
241   struct pthread_request request;
242   if (__pthread_manager_request < 0) {
243     if (pthread_initialize_manager() < 0) return EAGAIN;
244   }
245   request.req_thread = self;
246   request.req_kind = REQ_CREATE;
247   request.req_args.create.attr = attr;
248   request.req_args.create.fn = start_routine;
249   request.req_args.create.arg = arg;
250   sigprocmask(SIG_SETMASK, (const sigset_t *) NULL,
251               &request.req_args.create.mask);
252   __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
253   suspend(self);
254   if (self->p_retcode == 0) *thread = (pthread_t) self->p_retval;
255   return self->p_retcode;
256 }
257
258 /* Simple operations on thread identifiers */
259
260 pthread_t pthread_self(void)
261 {
262   pthread_descr self = thread_self();
263   return self->p_tid;
264 }
265
266 int pthread_equal(pthread_t thread1, pthread_t thread2)
267 {
268   return thread1 == thread2;
269 }
270
271 /* Thread scheduling */
272
273 int pthread_setschedparam(pthread_t thread, int policy,
274                           const struct sched_param *param)
275 {
276   pthread_handle handle = thread_handle(thread);
277   pthread_descr th;
278
279   acquire(&handle->h_spinlock);
280   if (invalid_handle(handle, thread)) {
281     release(&handle->h_spinlock);
282     return ESRCH;
283   }
284   th = handle->h_descr;
285   if (__sched_setscheduler(th->p_pid, policy, param) == -1) {
286     release(&handle->h_spinlock);
287     return errno;
288   }
289   th->p_priority = policy == SCHED_OTHER ? 0 : param->sched_priority;
290   release(&handle->h_spinlock);
291   return 0;
292 }
293
294 int pthread_getschedparam(pthread_t thread, int *policy,
295                           struct sched_param *param)
296 {
297   pthread_handle handle = thread_handle(thread);
298   int pid, pol;
299
300   acquire(&handle->h_spinlock);
301   if (invalid_handle(handle, thread)) {
302     release(&handle->h_spinlock);
303     return ESRCH;
304   }
305   pid = handle->h_descr->p_pid;
306   release(&handle->h_spinlock);
307   pol = __sched_getscheduler(pid);
308   if (pol == -1) return errno;
309   if (__sched_getparam(pid, param) == -1) return errno;
310   *policy = pol;
311   return 0;
312 }
313
314 /* Process-wide exit() request */
315
316 static void pthread_exit_process(int retcode, void *arg)
317 {
318   struct pthread_request request;
319   pthread_descr self = thread_self();
320
321   if (__pthread_manager_request >= 0) {
322     request.req_thread = self;
323     request.req_kind = REQ_PROCESS_EXIT;
324     request.req_args.exit.code = retcode;
325     __libc_write(__pthread_manager_request,
326                  (char *) &request, sizeof(request));
327     suspend(self);
328     /* Main thread should accumulate times for thread manager and its
329        children, so that timings for main thread account for all threads. */
330     if (self == __pthread_main_thread)
331       waitpid(__pthread_manager_pid, NULL, __WCLONE);
332   }
333 }
334
335 /* The handler for the RESTART signal just records the signal received
336    in the thread descriptor, and optionally performs a siglongjmp
337    (for pthread_cond_timedwait). Also used in sigwait.
338    For the thread manager thread, redirect the signal to
339    __pthread_manager_sighandler. */
340
341 void __pthread_sighandler(int sig)
342 {
343   pthread_descr self = thread_self();
344   if (self == &__pthread_manager_thread) {
345     __pthread_manager_sighandler(sig);
346   } else {
347     self->p_signal = sig;
348     if (self->p_signal_jmp != NULL) siglongjmp(*self->p_signal_jmp, 1);
349   }
350 }
351
352 /* The handler for the CANCEL signal checks for cancellation
353    (in asynchronous mode) and for process-wide exit and exec requests. */
354
355 static void pthread_handle_sigcancel(int sig)
356 {
357   pthread_descr self = thread_self();
358   sigjmp_buf * jmpbuf;
359
360   if (__pthread_exit_requested) {
361     /* Main thread should accumulate times for thread manager and its
362        children, so that timings for main thread account for all threads. */
363     if (self == __pthread_main_thread)
364       waitpid(__pthread_manager_pid, NULL, __WCLONE);
365     _exit(__pthread_exit_code);
366   }
367   if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
368     if (self->p_canceltype == PTHREAD_CANCEL_ASYNCHRONOUS)
369       pthread_exit(PTHREAD_CANCELED);
370     jmpbuf = self->p_cancel_jmp;
371     if (jmpbuf != NULL) {
372       self->p_cancel_jmp = NULL;
373       siglongjmp(*jmpbuf, 1);
374     }
375   }
376 }
377
378 /* Reset the state of the thread machinery after a fork().
379    Close the pipe used for requests and set the main thread to the forked
380    thread.
381    Notice that we can't free the stack segments, as the forked thread
382    may hold pointers into them. */
383
384 void __pthread_reset_main_thread()
385 {
386   pthread_descr self = thread_self();
387
388   if (__pthread_manager_request != -1) {
389     /* Free the thread manager stack */
390     free(__pthread_manager_thread_bos);
391     __pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
392     /* Close the two ends of the pipe */
393     __libc_close(__pthread_manager_request);
394     __libc_close(__pthread_manager_reader);
395     __pthread_manager_request = __pthread_manager_reader = -1;
396   }
397   /* Update the pid of the main thread */
398   self->p_pid = __getpid();
399   /* Make the forked thread the main thread */
400   __pthread_main_thread = self;
401   self->p_nextlive = self;
402   self->p_prevlive = self;
403   /* Now this thread modifies the global variables.  */
404   self->p_errnop = &_errno;
405   self->p_h_errnop = &_h_errno;
406 }
407
408 /* Process-wide exec() request */
409
410 void __pthread_kill_other_threads_np(void)
411 {
412   /* Terminate all other threads and thread manager */
413   pthread_exit_process(0, NULL);
414   /* Make current thread the main thread in case the calling thread
415      changes its mind, does not exec(), and creates new threads instead. */
416   __pthread_reset_main_thread();
417 }
418 weak_alias (__pthread_kill_other_threads_np, pthread_kill_other_threads_np)
419
420 /* Debugging aid */
421
422 #ifdef DEBUG
423 #include <stdarg.h>
424
425 void __pthread_message(char * fmt, long arg)
426 {
427   char buffer[1024];
428   va_list args;
429   sprintf(buffer, "%05d : ", __getpid());
430   va_start(args, fmt);
431   vsnprintf(buffer + 8, sizeof(buffer) - 8, fmt, args);
432   va_end(args);
433   __libc_write(2, buffer, strlen(buffer));
434 }
435
436 #endif
437
438
439 #ifndef PIC
440 /* We need a hook to force the cancelation wrappers to be linked in when
441    static libpthread is used.  */
442 extern const int __pthread_provide_wrappers;
443 static const int *const __pthread_require_wrappers =
444   &__pthread_provide_wrappers;
445 #endif