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