Remove _POSIX_MONOTONIC_CLOCK.
[kopensolaris-gnu/glibc.git] / linuxthreads / manager.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 /* The "thread manager" thread: manages creation and termination of threads */
16
17 #include <errno.h>
18 #include <sched.h>
19 #include <stddef.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <sys/poll.h>           /* for poll */
25 #include <sys/mman.h>           /* for mmap */
26 #include <sys/param.h>
27 #include <sys/time.h>
28 #include <sys/wait.h>           /* for waitpid macros */
29
30 #include "pthread.h"
31 #include "internals.h"
32 #include "spinlock.h"
33 #include "restart.h"
34 #include "semaphore.h"
35
36 /* Array of active threads. Entry 0 is reserved for the initial thread. */
37 struct pthread_handle_struct __pthread_handles[PTHREAD_THREADS_MAX] =
38 { { LOCK_INITIALIZER, &__pthread_initial_thread, 0},
39   { LOCK_INITIALIZER, &__pthread_manager_thread, 0}, /* All NULLs */ };
40
41 /* For debugging purposes put the maximum number of threads in a variable.  */
42 const int __linuxthreads_pthread_threads_max = PTHREAD_THREADS_MAX;
43
44 #ifndef THREAD_SELF
45 /* Indicate whether at least one thread has a user-defined stack (if 1),
46    or if all threads have stacks supplied by LinuxThreads (if 0). */
47 int __pthread_nonstandard_stacks;
48 #endif
49
50 /* Number of active entries in __pthread_handles (used by gdb) */
51 volatile int __pthread_handles_num = 2;
52
53 /* Whether to use debugger additional actions for thread creation
54    (set to 1 by gdb) */
55 volatile int __pthread_threads_debug;
56
57 /* Globally enabled events.  */
58 volatile td_thr_events_t __pthread_threads_events;
59
60 /* Pointer to thread descriptor with last event.  */
61 volatile pthread_descr __pthread_last_event;
62
63 /* Mapping from stack segment to thread descriptor. */
64 /* Stack segment numbers are also indices into the __pthread_handles array. */
65 /* Stack segment number 0 is reserved for the initial thread. */
66
67 #if FLOATING_STACKS
68 # define thread_segment(seq) NULL
69 #else
70 static inline pthread_descr thread_segment(int seg)
71 {
72   return (pthread_descr)(THREAD_STACK_START_ADDRESS - (seg - 1) * STACK_SIZE)
73          - 1;
74 }
75 #endif
76
77 /* Flag set in signal handler to record child termination */
78
79 static volatile int terminated_children;
80
81 /* Flag set when the initial thread is blocked on pthread_exit waiting
82    for all other threads to terminate */
83
84 static int main_thread_exiting;
85
86 /* Counter used to generate unique thread identifier.
87    Thread identifier is pthread_threads_counter + segment. */
88
89 static pthread_t pthread_threads_counter;
90
91 #ifdef NEED_SEPARATE_REGISTER_STACK
92 /* Signal masks for the manager.  These have to be global only when clone2
93    is used since it's currently borken wrt signals in the child.  */
94 static sigset_t manager_mask;           /* Manager normal signal mask   */
95 static sigset_t manager_mask_all;       /* All bits set.        */
96 #endif
97
98 /* Forward declarations */
99
100 static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
101                                  void * (*start_routine)(void *), void *arg,
102                                  sigset_t *mask, int father_pid,
103                                  int report_events,
104                                  td_thr_events_t *event_maskp);
105 static void pthread_handle_free(pthread_t th_id);
106 static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode);
107 static void pthread_reap_children(void);
108 static void pthread_kill_all_threads(int sig, int main_thread_also);
109
110 /* The server thread managing requests for thread creation and termination */
111
112 int __pthread_manager(void *arg)
113 {
114   int reqfd = (int) (long int) arg;
115   struct pollfd ufd;
116 #ifndef NEED_SEPARATE_REGISTER_STACK
117   sigset_t manager_mask;
118 #endif
119   int n;
120   struct pthread_request request;
121
122   /* If we have special thread_self processing, initialize it.  */
123 #ifdef INIT_THREAD_SELF
124   INIT_THREAD_SELF(&__pthread_manager_thread, 1);
125 #endif
126   /* Set the error variable.  */
127   __pthread_manager_thread.p_errnop = &__pthread_manager_thread.p_errno;
128   __pthread_manager_thread.p_h_errnop = &__pthread_manager_thread.p_h_errno;
129   /* Block all signals except __pthread_sig_cancel and SIGTRAP */
130   sigfillset(&manager_mask);
131   sigdelset(&manager_mask, __pthread_sig_cancel); /* for thread termination */
132   sigdelset(&manager_mask, SIGTRAP);            /* for debugging purposes */
133   if (__pthread_threads_debug && __pthread_sig_debug > 0)
134     sigdelset(&manager_mask, __pthread_sig_debug);
135   sigprocmask(SIG_SETMASK, &manager_mask, NULL);
136 #ifdef NEED_SEPARATE_REGISTER_STACK
137   sigfillset(&manager_mask_all);
138 #endif
139   /* Raise our priority to match that of main thread */
140   __pthread_manager_adjust_prio(__pthread_main_thread->p_priority);
141   /* Synchronize debugging of the thread manager */
142   n = __libc_read(reqfd, (char *)&request, sizeof(request));
143   ASSERT(n == sizeof(request) && request.req_kind == REQ_DEBUG);
144   ufd.fd = reqfd;
145   ufd.events = POLLIN;
146   /* Enter server loop */
147   while(1) {
148     n = __poll(&ufd, 1, 2000);
149
150     /* Check for termination of the main thread */
151     if (getppid() == 1) {
152       pthread_kill_all_threads(SIGKILL, 0);
153       _exit(0);
154     }
155     /* Check for dead children */
156     if (terminated_children) {
157       terminated_children = 0;
158       pthread_reap_children();
159     }
160     /* Read and execute request */
161     if (n == 1 && (ufd.revents & POLLIN)) {
162       n = __libc_read(reqfd, (char *)&request, sizeof(request));
163       ASSERT(n == sizeof(request));
164       switch(request.req_kind) {
165       case REQ_CREATE:
166         request.req_thread->p_retcode =
167           pthread_handle_create((pthread_t *) &request.req_thread->p_retval,
168                                 request.req_args.create.attr,
169                                 request.req_args.create.fn,
170                                 request.req_args.create.arg,
171                                 &request.req_args.create.mask,
172                                 request.req_thread->p_pid,
173                                 request.req_thread->p_report_events,
174                                 &request.req_thread->p_eventbuf.eventmask);
175         restart(request.req_thread);
176         break;
177       case REQ_FREE:
178         pthread_handle_free(request.req_args.free.thread_id);
179         break;
180       case REQ_PROCESS_EXIT:
181         pthread_handle_exit(request.req_thread,
182                             request.req_args.exit.code);
183         /* NOTREACHED */
184         break;
185       case REQ_MAIN_THREAD_EXIT:
186         main_thread_exiting = 1;
187         /* Reap children in case all other threads died and the signal handler
188            went off before we set main_thread_exiting to 1, and therefore did
189            not do REQ_KICK. */
190         pthread_reap_children();
191
192         if (__pthread_main_thread->p_nextlive == __pthread_main_thread) {
193           restart(__pthread_main_thread);
194           /* The main thread will now call exit() which will trigger an
195              __on_exit handler, which in turn will send REQ_PROCESS_EXIT
196              to the thread manager. In case you are wondering how the
197              manager terminates from its loop here. */
198         }
199         break;
200       case REQ_POST:
201         __new_sem_post(request.req_args.post);
202         break;
203       case REQ_DEBUG:
204         /* Make gdb aware of new thread and gdb will restart the
205            new thread when it is ready to handle the new thread. */
206         if (__pthread_threads_debug && __pthread_sig_debug > 0)
207           raise(__pthread_sig_debug);
208         break;
209       case REQ_KICK:
210         /* This is just a prod to get the manager to reap some
211            threads right away, avoiding a potential delay at shutdown. */
212         break;
213       }
214     }
215   }
216 }
217
218 int __pthread_manager_event(void *arg)
219 {
220   /* If we have special thread_self processing, initialize it.  */
221 #ifdef INIT_THREAD_SELF
222   INIT_THREAD_SELF(&__pthread_manager_thread, 1);
223 #endif
224
225   /* Get the lock the manager will free once all is correctly set up.  */
226   __pthread_lock (THREAD_GETMEM((&__pthread_manager_thread), p_lock), NULL);
227   /* Free it immediately.  */
228   __pthread_unlock (THREAD_GETMEM((&__pthread_manager_thread), p_lock));
229
230   return __pthread_manager(arg);
231 }
232
233 /* Process creation */
234
235 static int pthread_start_thread(void *arg)
236 {
237   pthread_descr self = (pthread_descr) arg;
238   struct pthread_request request;
239   void * outcome;
240   /* Initialize special thread_self processing, if any.  */
241 #ifdef INIT_THREAD_SELF
242   INIT_THREAD_SELF(self, self->p_nr);
243 #endif
244   /* Make sure our pid field is initialized, just in case we get there
245      before our father has initialized it. */
246   THREAD_SETMEM(self, p_pid, __getpid());
247   /* Initial signal mask is that of the creating thread. (Otherwise,
248      we'd just inherit the mask of the thread manager.) */
249   sigprocmask(SIG_SETMASK, &self->p_start_args.mask, NULL);
250   /* Set the scheduling policy and priority for the new thread, if needed */
251   if (THREAD_GETMEM(self, p_start_args.schedpolicy) >= 0)
252     /* Explicit scheduling attributes were provided: apply them */
253     __sched_setscheduler(THREAD_GETMEM(self, p_pid),
254                          THREAD_GETMEM(self, p_start_args.schedpolicy),
255                          &self->p_start_args.schedparam);
256   else if (__pthread_manager_thread.p_priority > 0)
257     /* Default scheduling required, but thread manager runs in realtime
258        scheduling: switch new thread to SCHED_OTHER policy */
259     {
260       struct sched_param default_params;
261       default_params.sched_priority = 0;
262       __sched_setscheduler(THREAD_GETMEM(self, p_pid),
263                            SCHED_OTHER, &default_params);
264     }
265   /* Make gdb aware of new thread */
266   if (__pthread_threads_debug && __pthread_sig_debug > 0) {
267     request.req_thread = self;
268     request.req_kind = REQ_DEBUG;
269     __libc_write(__pthread_manager_request,
270                  (char *) &request, sizeof(request));
271     suspend(self);
272   }
273   /* Run the thread code */
274   outcome = self->p_start_args.start_routine(THREAD_GETMEM(self,
275                                                            p_start_args.arg));
276   /* Exit with the given return value */
277   pthread_exit(outcome);
278   return 0;
279 }
280
281 static int pthread_start_thread_event(void *arg)
282 {
283   pthread_descr self = (pthread_descr) arg;
284
285 #ifdef INIT_THREAD_SELF
286   INIT_THREAD_SELF(self, self->p_nr);
287 #endif
288   /* Make sure our pid field is initialized, just in case we get there
289      before our father has initialized it. */
290   THREAD_SETMEM(self, p_pid, __getpid());
291   /* Get the lock the manager will free once all is correctly set up.  */
292   __pthread_lock (THREAD_GETMEM(self, p_lock), NULL);
293   /* Free it immediately.  */
294   __pthread_unlock (THREAD_GETMEM(self, p_lock));
295
296   /* Continue with the real function.  */
297   return pthread_start_thread (arg);
298 }
299
300 static int pthread_allocate_stack(const pthread_attr_t *attr,
301                                   pthread_descr default_new_thread,
302                                   int pagesize,
303                                   pthread_descr * out_new_thread,
304                                   char ** out_new_thread_bottom,
305                                   char ** out_guardaddr,
306                                   size_t * out_guardsize)
307 {
308   pthread_descr new_thread;
309   char * new_thread_bottom;
310   char * guardaddr;
311   size_t stacksize, guardsize;
312
313   if (attr != NULL && attr->__stackaddr_set)
314     {
315       /* The user provided a stack.  For now we interpret the supplied
316          address as 1 + the highest addr. in the stack segment.  If a
317          separate register stack is needed, we place it at the low end
318          of the segment, relying on the associated stacksize to
319          determine the low end of the segment.  This differs from many
320          (but not all) other pthreads implementations.  The intent is
321          that on machines with a single stack growing toward higher
322          addresses, stackaddr would be the lowest address in the stack
323          segment, so that it is consistently close to the initial sp
324          value. */
325       new_thread =
326         (pthread_descr) ((long)(attr->__stackaddr) & -sizeof(void *)) - 1;
327       new_thread_bottom = (char *) attr->__stackaddr - attr->__stacksize;
328       guardaddr = new_thread_bottom;
329       guardsize = 0;
330 #ifndef THREAD_SELF
331       __pthread_nonstandard_stacks = 1;
332 #endif
333       /* Clear the thread data structure.  */
334       memset (new_thread, '\0', sizeof (*new_thread));
335     }
336   else
337     {
338 #ifdef NEED_SEPARATE_REGISTER_STACK
339       size_t granularity = 2 * pagesize;
340       /* Try to make stacksize/2 a multiple of pagesize */
341 #else
342       size_t granularity = pagesize;
343 #endif
344       void *map_addr;
345
346       /* Allocate space for stack and thread descriptor at default address */
347 #ifdef NEED_SEPARATE_REGISTER_STACK
348       if (attr != NULL)
349         {
350           guardsize = page_roundup (attr->__guardsize, granularity);
351           stacksize = STACK_SIZE - guardsize;
352           stacksize = MIN (stacksize,
353                            page_roundup (attr->__stacksize, granularity));
354         }
355       else
356         {
357           guardsize = granularity;
358           stacksize = STACK_SIZE - granularity;
359         }
360
361       new_thread = default_new_thread;
362       new_thread_bottom = (char *) (new_thread + 1) - stacksize - guardsize;
363       /* Includes guard area, unlike the normal case.  Use the bottom
364        end of the segment as backing store for the register stack.
365        Needed on IA64.  In this case, we also map the entire stack at
366        once.  According to David Mosberger, that's cheaper.  It also
367        avoids the risk of intermittent failures due to other mappings
368        in the same region.  The cost is that we might be able to map
369        slightly fewer stacks.  */
370
371       /* XXX Fix for floating stacks with variable sizes.  */
372
373       /* First the main stack: */
374       if (mmap((caddr_t)((char *)(new_thread + 1) - stacksize / 2),
375                stacksize / 2, PROT_READ | PROT_WRITE | PROT_EXEC,
376                MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)
377           == MAP_FAILED)
378         /* Bad luck, this segment is already mapped. */
379         return -1;
380       /* Then the register stack:       */
381       if (mmap((caddr_t)new_thread_bottom, stacksize/2,
382                PROT_READ | PROT_WRITE | PROT_EXEC,
383                MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)
384           == MAP_FAILED)
385         {
386           munmap((caddr_t)((char *)(new_thread + 1) - stacksize/2),
387                  stacksize/2);
388           return -1;
389         }
390
391       guardaddr = new_thread_bottom + stacksize/2;
392       /* We leave the guard area in the middle unmapped.        */
393 #else  /* !NEED_SEPARATE_REGISTER_STACK */
394 # if FLOATING_STACKS
395       if (attr != NULL)
396         {
397           guardsize = page_roundup (attr->__guardsize, granularity);
398           stacksize = __pthread_max_stacksize - guardsize;
399           stacksize = MIN (stacksize,
400                            page_roundup (attr->__stacksize, granularity));
401         }
402       else
403         {
404           guardsize = granularity;
405           stacksize = __pthread_max_stacksize - guardsize;
406         }
407
408       map_addr = mmap(NULL, stacksize + guardsize,
409                       PROT_READ | PROT_WRITE | PROT_EXEC,
410                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
411       if (map_addr == MAP_FAILED)
412         /* No more memory available.  */
413         return -1;
414
415       guardaddr = map_addr;
416       if (guardsize > 0)
417         mprotect (guardaddr, guardsize, PROT_NONE);
418
419       new_thread_bottom = (char *) map_addr + guardsize;
420       new_thread = ((pthread_descr) (new_thread_bottom + stacksize)) - 1;
421 # else
422       if (attr != NULL)
423         {
424           guardsize = page_roundup (attr->__guardsize, granularity);
425           stacksize = STACK_SIZE - guardsize;
426           stacksize = MIN (stacksize,
427                            page_roundup (attr->__stacksize, granularity));
428         }
429       else
430         {
431           guardsize = granularity;
432           stacksize = STACK_SIZE - granularity;
433         }
434
435       new_thread = default_new_thread;
436       new_thread_bottom = (char *) (new_thread + 1) - stacksize;
437       map_addr = mmap((caddr_t)((char *)(new_thread + 1) - stacksize - guardsize),
438                       stacksize + guardsize,
439                       PROT_READ | PROT_WRITE | PROT_EXEC,
440                       MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
441       if (map_addr == MAP_FAILED)
442         /* Bad luck, this segment is already mapped. */
443         return -1;
444
445       /* We manage to get a stack.  Protect the guard area pages if
446          necessary.  */
447       guardaddr = map_addr;
448       if (guardsize > 0)
449         mprotect (guardaddr, guardsize, PROT_NONE);
450 # endif
451 #endif /* !NEED_SEPARATE_REGISTER_STACK */
452     }
453   *out_new_thread = new_thread;
454   *out_new_thread_bottom = new_thread_bottom;
455   *out_guardaddr = guardaddr;
456   *out_guardsize = guardsize;
457   return 0;
458 }
459
460 static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
461                                  void * (*start_routine)(void *), void *arg,
462                                  sigset_t * mask, int father_pid,
463                                  int report_events,
464                                  td_thr_events_t *event_maskp)
465 {
466   size_t sseg;
467   int pid;
468   pthread_descr new_thread;
469   char * new_thread_bottom;
470   pthread_t new_thread_id;
471   char *guardaddr = NULL;
472   size_t guardsize = 0;
473   int pagesize = __getpagesize();
474
475   /* First check whether we have to change the policy and if yes, whether
476      we can  do this.  Normally this should be done by examining the
477      return value of the __sched_setscheduler call in pthread_start_thread
478      but this is hard to implement.  FIXME  */
479   if (attr != NULL && attr->__schedpolicy != SCHED_OTHER && geteuid () != 0)
480     return EPERM;
481   /* Find a free segment for the thread, and allocate a stack if needed */
482   for (sseg = 2; ; sseg++)
483     {
484       if (sseg >= PTHREAD_THREADS_MAX)
485         return EAGAIN;
486       if (__pthread_handles[sseg].h_descr != NULL)
487         continue;
488       if (pthread_allocate_stack(attr, thread_segment(sseg),
489                                  pagesize,
490                                  &new_thread, &new_thread_bottom,
491                                  &guardaddr, &guardsize) == 0)
492         break;
493     }
494   __pthread_handles_num++;
495   /* Allocate new thread identifier */
496   pthread_threads_counter += PTHREAD_THREADS_MAX;
497   new_thread_id = sseg + pthread_threads_counter;
498   /* Initialize the thread descriptor.  Elements which have to be
499      initialized to zero already have this value.  */
500   new_thread->p_tid = new_thread_id;
501   new_thread->p_lock = &(__pthread_handles[sseg].h_lock);
502   new_thread->p_cancelstate = PTHREAD_CANCEL_ENABLE;
503   new_thread->p_canceltype = PTHREAD_CANCEL_DEFERRED;
504   new_thread->p_errnop = &new_thread->p_errno;
505   new_thread->p_h_errnop = &new_thread->p_h_errno;
506   new_thread->p_resp = &new_thread->p_res;
507   new_thread->p_guardaddr = guardaddr;
508   new_thread->p_guardsize = guardsize;
509   new_thread->p_header.data.self = new_thread;
510   new_thread->p_nr = sseg;
511   /* Initialize the thread handle */
512   __pthread_init_lock(&__pthread_handles[sseg].h_lock);
513   __pthread_handles[sseg].h_descr = new_thread;
514   __pthread_handles[sseg].h_bottom = new_thread_bottom;
515   /* Determine scheduling parameters for the thread */
516   new_thread->p_start_args.schedpolicy = -1;
517   if (attr != NULL) {
518     new_thread->p_detached = attr->__detachstate;
519     new_thread->p_userstack = attr->__stackaddr_set;
520
521     switch(attr->__inheritsched) {
522     case PTHREAD_EXPLICIT_SCHED:
523       new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
524       memcpy (&new_thread->p_start_args.schedparam, &attr->__schedparam,
525               sizeof (struct sched_param));
526       break;
527     case PTHREAD_INHERIT_SCHED:
528       new_thread->p_start_args.schedpolicy = __sched_getscheduler(father_pid);
529       __sched_getparam(father_pid, &new_thread->p_start_args.schedparam);
530       break;
531     }
532     new_thread->p_priority =
533       new_thread->p_start_args.schedparam.sched_priority;
534   }
535   /* Finish setting up arguments to pthread_start_thread */
536   new_thread->p_start_args.start_routine = start_routine;
537   new_thread->p_start_args.arg = arg;
538   new_thread->p_start_args.mask = *mask;
539   /* Make the new thread ID available already now.  If any of the later
540      functions fail we return an error value and the caller must not use
541      the stored thread ID.  */
542   *thread = new_thread_id;
543   /* Raise priority of thread manager if needed */
544   __pthread_manager_adjust_prio(new_thread->p_priority);
545   /* Do the cloning.  We have to use two different functions depending
546      on whether we are debugging or not.  */
547   pid = 0;      /* Note that the thread never can have PID zero.  */
548   if (report_events)
549     {
550       /* See whether the TD_CREATE event bit is set in any of the
551          masks.  */
552       int idx = __td_eventword (TD_CREATE);
553       uint32_t mask = __td_eventmask (TD_CREATE);
554
555       if ((mask & (__pthread_threads_events.event_bits[idx]
556                    | event_maskp->event_bits[idx])) != 0)
557         {
558           /* Lock the mutex the child will use now so that it will stop.  */
559           __pthread_lock(new_thread->p_lock, NULL);
560
561           /* We have to report this event.  */
562 #ifdef NEED_SEPARATE_REGISTER_STACK
563           /* Perhaps this version should be used on all platforms. But
564            this requires that __clone2 be uniformly supported
565            everywhere.
566
567            And there is some argument for changing the __clone2
568            interface to pass sp and bsp instead, making it more IA64
569            specific, but allowing stacks to grow outward from each
570            other, to get less paging and fewer mmaps.  Clone2
571            currently can't take signals in the child right after
572            process creation.  Mask them in the child.  It resets the
573            mask once it starts up.  */
574           sigprocmask(SIG_SETMASK, &manager_mask_all, NULL);
575           pid = __clone2(pthread_start_thread_event,
576                  (void **)new_thread_bottom,
577                          (char *)new_thread - new_thread_bottom,
578                          CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
579                          __pthread_sig_cancel, new_thread);
580           sigprocmask(SIG_SETMASK, &manager_mask, NULL);
581 #else
582           pid = __clone(pthread_start_thread_event, (void **) new_thread,
583                         CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
584                         __pthread_sig_cancel, new_thread);
585 #endif
586           if (pid != -1)
587             {
588               /* Now fill in the information about the new thread in
589                  the newly created thread's data structure.  We cannot let
590                  the new thread do this since we don't know whether it was
591                  already scheduled when we send the event.  */
592               new_thread->p_eventbuf.eventdata = new_thread;
593               new_thread->p_eventbuf.eventnum = TD_CREATE;
594               __pthread_last_event = new_thread;
595
596               /* We have to set the PID here since the callback function
597                  in the debug library will need it and we cannot guarantee
598                  the child got scheduled before the debugger.  */
599               new_thread->p_pid = pid;
600
601               /* Now call the function which signals the event.  */
602               __linuxthreads_create_event ();
603
604               /* Now restart the thread.  */
605               __pthread_unlock(new_thread->p_lock);
606             }
607         }
608     }
609   if (pid == 0)
610     {
611 #ifdef NEED_SEPARATE_REGISTER_STACK
612       sigprocmask(SIG_SETMASK, &manager_mask_all, NULL);
613       pid = __clone2(pthread_start_thread,
614                      (void **)new_thread_bottom,
615                      (char *)new_thread - new_thread_bottom,
616                      CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
617                      __pthread_sig_cancel, new_thread);
618       sigprocmask(SIG_SETMASK, &manager_mask, NULL);
619 #else
620       pid = __clone(pthread_start_thread, (void **) new_thread,
621                     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
622                     __pthread_sig_cancel, new_thread);
623 #endif /* !NEED_SEPARATE_REGISTER_STACK */
624     }
625   /* Check if cloning succeeded */
626   if (pid == -1) {
627     /* Free the stack if we allocated it */
628     if (attr == NULL || !attr->__stackaddr_set)
629       {
630 #ifdef NEED_SEPARATE_REGISTER_STACK
631         size_t stacksize = ((char *)(new_thread->p_guardaddr)
632                             - new_thread_bottom);
633         munmap((caddr_t)new_thread_bottom,
634                2 * stacksize + new_thread->p_guardsize);
635 #else
636         size_t stacksize = (char *)(new_thread+1) - new_thread_bottom;
637         munmap(new_thread_bottom - guardsize, guardsize + stacksize);
638 #endif
639       }
640     __pthread_handles[sseg].h_descr = NULL;
641     __pthread_handles[sseg].h_bottom = NULL;
642     __pthread_handles_num--;
643     return errno;
644   }
645   /* Insert new thread in doubly linked list of active threads */
646   new_thread->p_prevlive = __pthread_main_thread;
647   new_thread->p_nextlive = __pthread_main_thread->p_nextlive;
648   __pthread_main_thread->p_nextlive->p_prevlive = new_thread;
649   __pthread_main_thread->p_nextlive = new_thread;
650   /* Set pid field of the new thread, in case we get there before the
651      child starts. */
652   new_thread->p_pid = pid;
653   return 0;
654 }
655
656
657 /* Try to free the resources of a thread when requested by pthread_join
658    or pthread_detach on a terminated thread. */
659
660 static void pthread_free(pthread_descr th)
661 {
662   pthread_handle handle;
663   pthread_readlock_info *iter, *next;
664
665   ASSERT(th->p_exited);
666   /* Make the handle invalid */
667   handle =  thread_handle(th->p_tid);
668   __pthread_lock(&handle->h_lock, NULL);
669   handle->h_descr = NULL;
670   handle->h_bottom = (char *)(-1L);
671   __pthread_unlock(&handle->h_lock);
672 #ifdef FREE_THREAD
673   FREE_THREAD(th, th->p_nr);
674 #endif
675   /* One fewer threads in __pthread_handles */
676   __pthread_handles_num--;
677
678   /* Destroy read lock list, and list of free read lock structures.
679      If the former is not empty, it means the thread exited while
680      holding read locks! */
681
682   for (iter = th->p_readlock_list; iter != NULL; iter = next)
683     {
684       next = iter->pr_next;
685       free(iter);
686     }
687
688   for (iter = th->p_readlock_free; iter != NULL; iter = next)
689     {
690       next = iter->pr_next;
691       free(iter);
692     }
693
694   /* If initial thread, nothing to free */
695   if (!th->p_userstack)
696     {
697       size_t guardsize = th->p_guardsize;
698       /* Free the stack and thread descriptor area */
699 #ifdef NEED_SEPARATE_REGISTER_STACK
700       char *guardaddr = th->p_guardaddr;
701       /* We unmap exactly what we mapped, in case there was something
702          else in the same region.  Guardaddr is always set, eve if
703          guardsize is 0.  This allows us to compute everything else.  */
704       size_t stacksize = (char *)(th+1) - guardaddr - guardsize;
705       /* Unmap the register stack, which is below guardaddr.  */
706       munmap((caddr_t)(guardaddr-stacksize),
707              2 * stacksize + th->p_guardsize);
708 #else
709       char *guardaddr = th->p_guardaddr;
710       /* We unmap exactly what we mapped, in case there was something
711          else in the same region.  Guardaddr is always set, eve if
712          guardsize is 0.  This allows us to compute everything else.  */
713       size_t stacksize = (char *)(th+1) - guardaddr - guardsize;
714
715       munmap (guardaddr, stacksize + guardsize);
716 #endif
717     }
718 }
719
720 /* Handle threads that have exited */
721
722 static void pthread_exited(pid_t pid)
723 {
724   pthread_descr th;
725   int detached;
726   /* Find thread with that pid */
727   for (th = __pthread_main_thread->p_nextlive;
728        th != __pthread_main_thread;
729        th = th->p_nextlive) {
730     if (th->p_pid == pid) {
731       /* Remove thread from list of active threads */
732       th->p_nextlive->p_prevlive = th->p_prevlive;
733       th->p_prevlive->p_nextlive = th->p_nextlive;
734       /* Mark thread as exited, and if detached, free its resources */
735       __pthread_lock(th->p_lock, NULL);
736       th->p_exited = 1;
737       /* If we have to signal this event do it now.  */
738       if (th->p_report_events)
739         {
740           /* See whether TD_REAP is in any of the mask.  */
741           int idx = __td_eventword (TD_REAP);
742           uint32_t mask = __td_eventmask (TD_REAP);
743
744           if ((mask & (__pthread_threads_events.event_bits[idx]
745                        | th->p_eventbuf.eventmask.event_bits[idx])) != 0)
746             {
747               /* Yep, we have to signal the reapage.  */
748               th->p_eventbuf.eventnum = TD_REAP;
749               th->p_eventbuf.eventdata = th;
750               __pthread_last_event = th;
751
752               /* Now call the function to signal the event.  */
753               __linuxthreads_reap_event();
754             }
755         }
756       detached = th->p_detached;
757       __pthread_unlock(th->p_lock);
758       if (detached)
759         pthread_free(th);
760       break;
761     }
762   }
763   /* If all threads have exited and the main thread is pending on a
764      pthread_exit, wake up the main thread and terminate ourselves. */
765   if (main_thread_exiting &&
766       __pthread_main_thread->p_nextlive == __pthread_main_thread) {
767     restart(__pthread_main_thread);
768     /* Same logic as REQ_MAIN_THREAD_EXIT. */
769   }
770 }
771
772 static void pthread_reap_children(void)
773 {
774   pid_t pid;
775   int status;
776
777   while ((pid = __libc_waitpid(-1, &status, WNOHANG | __WCLONE)) > 0) {
778     pthread_exited(pid);
779     if (WIFSIGNALED(status)) {
780       /* If a thread died due to a signal, send the same signal to
781          all other threads, including the main thread. */
782       pthread_kill_all_threads(WTERMSIG(status), 1);
783       _exit(0);
784     }
785   }
786 }
787
788 /* Try to free the resources of a thread when requested by pthread_join
789    or pthread_detach on a terminated thread. */
790
791 static void pthread_handle_free(pthread_t th_id)
792 {
793   pthread_handle handle = thread_handle(th_id);
794   pthread_descr th;
795
796   __pthread_lock(&handle->h_lock, NULL);
797   if (nonexisting_handle(handle, th_id)) {
798     /* pthread_reap_children has deallocated the thread already,
799        nothing needs to be done */
800     __pthread_unlock(&handle->h_lock);
801     return;
802   }
803   th = handle->h_descr;
804   if (th->p_exited) {
805     __pthread_unlock(&handle->h_lock);
806     pthread_free(th);
807   } else {
808     /* The Unix process of the thread is still running.
809        Mark the thread as detached so that the thread manager will
810        deallocate its resources when the Unix process exits. */
811     th->p_detached = 1;
812     __pthread_unlock(&handle->h_lock);
813   }
814 }
815
816 /* Send a signal to all running threads */
817
818 static void pthread_kill_all_threads(int sig, int main_thread_also)
819 {
820   pthread_descr th;
821   for (th = __pthread_main_thread->p_nextlive;
822        th != __pthread_main_thread;
823        th = th->p_nextlive) {
824     kill(th->p_pid, sig);
825   }
826   if (main_thread_also) {
827     kill(__pthread_main_thread->p_pid, sig);
828   }
829 }
830
831 /* Process-wide exit() */
832
833 static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode)
834 {
835   pthread_descr th;
836   __pthread_exit_requested = 1;
837   __pthread_exit_code = exitcode;
838   /* Send the CANCEL signal to all running threads, including the main
839      thread, but excluding the thread from which the exit request originated
840      (that thread must complete the exit, e.g. calling atexit functions
841      and flushing stdio buffers). */
842   for (th = issuing_thread->p_nextlive;
843        th != issuing_thread;
844        th = th->p_nextlive) {
845     kill(th->p_pid, __pthread_sig_cancel);
846   }
847   /* Now, wait for all these threads, so that they don't become zombies
848      and their times are properly added to the thread manager's times. */
849   for (th = issuing_thread->p_nextlive;
850        th != issuing_thread;
851        th = th->p_nextlive) {
852     waitpid(th->p_pid, NULL, __WCLONE);
853   }
854   restart(issuing_thread);
855   _exit(0);
856 }
857
858 /* Handler for __pthread_sig_cancel in thread manager thread */
859
860 void __pthread_manager_sighandler(int sig)
861 {
862   int kick_manager = terminated_children == 0 && main_thread_exiting;
863   terminated_children = 1;
864
865   /* If the main thread is terminating, kick the thread manager loop
866      each time some threads terminate. This eliminates a two second
867      shutdown delay caused by the thread manager sleeping in the
868      call to __poll(). Instead, the thread manager is kicked into
869      action, reaps the outstanding threads and resumes the main thread
870      so that it can complete the shutdown. */
871
872   if (kick_manager) {
873     struct pthread_request request;
874     request.req_thread = 0;
875     request.req_kind = REQ_KICK;
876     __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
877   }
878 }
879
880 /* Adjust priority of thread manager so that it always run at a priority
881    higher than all threads */
882
883 void __pthread_manager_adjust_prio(int thread_prio)
884 {
885   struct sched_param param;
886
887   if (thread_prio <= __pthread_manager_thread.p_priority) return;
888   param.sched_priority =
889     thread_prio < __sched_get_priority_max(SCHED_FIFO)
890     ? thread_prio + 1 : thread_prio;
891   __sched_setscheduler(__pthread_manager_thread.p_pid, SCHED_FIFO, &param);
892   __pthread_manager_thread.p_priority = thread_prio;
893 }