(_SC_IOV_MAX): New definition.
[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       void *res_addr;
349
350       if (attr != NULL)
351         {
352           guardsize = page_roundup (attr->__guardsize, granularity);
353           stacksize = STACK_SIZE - guardsize;
354           stacksize = MIN (stacksize,
355                            page_roundup (attr->__stacksize, granularity));
356         }
357       else
358         {
359           guardsize = granularity;
360           stacksize = STACK_SIZE - granularity;
361         }
362
363       new_thread = default_new_thread;
364       new_thread_bottom = (char *) (new_thread + 1) - stacksize - guardsize;
365       /* Includes guard area, unlike the normal case.  Use the bottom
366        end of the segment as backing store for the register stack.
367        Needed on IA64.  In this case, we also map the entire stack at
368        once.  According to David Mosberger, that's cheaper.  It also
369        avoids the risk of intermittent failures due to other mappings
370        in the same region.  The cost is that we might be able to map
371        slightly fewer stacks.  */
372
373       /* XXX Fix for floating stacks with variable sizes.  */
374
375       /* First the main stack: */
376       map_addr = (caddr_t)((char *)(new_thread + 1) - stacksize / 2);
377       res_addr = mmap(map_addr, stacksize / 2,
378                       PROT_READ | PROT_WRITE | PROT_EXEC,
379                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
380       if (res_addr != map_addr)
381         {
382           /* Bad luck, this segment is already mapped. */
383           if (res_addr != MAP_FAILED)
384             munmap(res_addr, stacksize / 2);
385           return -1;
386         }
387       /* Then the register stack:       */
388       map_addr = (caddr_t)new_thread_bottom;
389       res_addr = mmap(map_addr, stacksize/2,
390                       PROT_READ | PROT_WRITE | PROT_EXEC,
391                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
392       if (res_addr != map_addr)
393         {
394           if (res_addr != MAP_FAILED)
395             munmap(res_addr, stacksize / 2);
396           munmap((caddr_t)((char *)(new_thread + 1) - stacksize/2),
397                  stacksize/2);
398           return -1;
399         }
400
401       guardaddr = new_thread_bottom + stacksize/2;
402       /* We leave the guard area in the middle unmapped.        */
403 #else  /* !NEED_SEPARATE_REGISTER_STACK */
404 # if FLOATING_STACKS
405       if (attr != NULL)
406         {
407           guardsize = page_roundup (attr->__guardsize, granularity);
408           stacksize = __pthread_max_stacksize - guardsize;
409           stacksize = MIN (stacksize,
410                            page_roundup (attr->__stacksize, granularity));
411         }
412       else
413         {
414           guardsize = granularity;
415           stacksize = __pthread_max_stacksize - guardsize;
416         }
417
418       map_addr = mmap(NULL, stacksize + guardsize,
419                       PROT_READ | PROT_WRITE | PROT_EXEC,
420                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
421       if (map_addr == MAP_FAILED)
422         /* No more memory available.  */
423         return -1;
424
425       guardaddr = map_addr;
426       if (guardsize > 0)
427         mprotect (guardaddr, guardsize, PROT_NONE);
428
429       new_thread_bottom = (char *) map_addr + guardsize;
430       new_thread = ((pthread_descr) (new_thread_bottom + stacksize)) - 1;
431 # else /* !FLOATING_STACKS */
432       void *res_addr;
433
434       if (attr != NULL)
435         {
436           guardsize = page_roundup (attr->__guardsize, granularity);
437           stacksize = STACK_SIZE - guardsize;
438           stacksize = MIN (stacksize,
439                            page_roundup (attr->__stacksize, granularity));
440         }
441       else
442         {
443           guardsize = granularity;
444           stacksize = STACK_SIZE - granularity;
445         }
446
447       new_thread = default_new_thread;
448       new_thread_bottom = (char *) (new_thread + 1) - stacksize;
449       map_addr = new_thread_bottom - guardsize;
450       res_addr = mmap(map_addr, stacksize + guardsize,
451                       PROT_READ | PROT_WRITE | PROT_EXEC,
452                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
453       if (res_addr != map_addr)
454         {
455           /* Bad luck, this segment is already mapped. */
456           if (res_addr != MAP_FAILED)
457             munmap (res_addr, stacksize + guardsize);
458           return -1;
459         }
460
461       /* We manage to get a stack.  Protect the guard area pages if
462          necessary.  */
463       guardaddr = map_addr;
464       if (guardsize > 0)
465         mprotect (guardaddr, guardsize, PROT_NONE);
466 # endif
467 #endif /* !NEED_SEPARATE_REGISTER_STACK */
468     }
469   *out_new_thread = new_thread;
470   *out_new_thread_bottom = new_thread_bottom;
471   *out_guardaddr = guardaddr;
472   *out_guardsize = guardsize;
473   return 0;
474 }
475
476 static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
477                                  void * (*start_routine)(void *), void *arg,
478                                  sigset_t * mask, int father_pid,
479                                  int report_events,
480                                  td_thr_events_t *event_maskp)
481 {
482   size_t sseg;
483   int pid;
484   pthread_descr new_thread;
485   char * new_thread_bottom;
486   pthread_t new_thread_id;
487   char *guardaddr = NULL;
488   size_t guardsize = 0;
489   int pagesize = __getpagesize();
490
491   /* First check whether we have to change the policy and if yes, whether
492      we can  do this.  Normally this should be done by examining the
493      return value of the __sched_setscheduler call in pthread_start_thread
494      but this is hard to implement.  FIXME  */
495   if (attr != NULL && attr->__schedpolicy != SCHED_OTHER && geteuid () != 0)
496     return EPERM;
497   /* Find a free segment for the thread, and allocate a stack if needed */
498   for (sseg = 2; ; sseg++)
499     {
500       if (sseg >= PTHREAD_THREADS_MAX)
501         return EAGAIN;
502       if (__pthread_handles[sseg].h_descr != NULL)
503         continue;
504       if (pthread_allocate_stack(attr, thread_segment(sseg),
505                                  pagesize,
506                                  &new_thread, &new_thread_bottom,
507                                  &guardaddr, &guardsize) == 0)
508         break;
509     }
510   __pthread_handles_num++;
511   /* Allocate new thread identifier */
512   pthread_threads_counter += PTHREAD_THREADS_MAX;
513   new_thread_id = sseg + pthread_threads_counter;
514   /* Initialize the thread descriptor.  Elements which have to be
515      initialized to zero already have this value.  */
516   new_thread->p_tid = new_thread_id;
517   new_thread->p_lock = &(__pthread_handles[sseg].h_lock);
518   new_thread->p_cancelstate = PTHREAD_CANCEL_ENABLE;
519   new_thread->p_canceltype = PTHREAD_CANCEL_DEFERRED;
520   new_thread->p_errnop = &new_thread->p_errno;
521   new_thread->p_h_errnop = &new_thread->p_h_errno;
522   new_thread->p_resp = &new_thread->p_res;
523   new_thread->p_guardaddr = guardaddr;
524   new_thread->p_guardsize = guardsize;
525   new_thread->p_header.data.self = new_thread;
526   new_thread->p_nr = sseg;
527   /* Initialize the thread handle */
528   __pthread_init_lock(&__pthread_handles[sseg].h_lock);
529   __pthread_handles[sseg].h_descr = new_thread;
530   __pthread_handles[sseg].h_bottom = new_thread_bottom;
531   /* Determine scheduling parameters for the thread */
532   new_thread->p_start_args.schedpolicy = -1;
533   if (attr != NULL) {
534     new_thread->p_detached = attr->__detachstate;
535     new_thread->p_userstack = attr->__stackaddr_set;
536
537     switch(attr->__inheritsched) {
538     case PTHREAD_EXPLICIT_SCHED:
539       new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
540       memcpy (&new_thread->p_start_args.schedparam, &attr->__schedparam,
541               sizeof (struct sched_param));
542       break;
543     case PTHREAD_INHERIT_SCHED:
544       new_thread->p_start_args.schedpolicy = __sched_getscheduler(father_pid);
545       __sched_getparam(father_pid, &new_thread->p_start_args.schedparam);
546       break;
547     }
548     new_thread->p_priority =
549       new_thread->p_start_args.schedparam.sched_priority;
550   }
551   /* Finish setting up arguments to pthread_start_thread */
552   new_thread->p_start_args.start_routine = start_routine;
553   new_thread->p_start_args.arg = arg;
554   new_thread->p_start_args.mask = *mask;
555   /* Make the new thread ID available already now.  If any of the later
556      functions fail we return an error value and the caller must not use
557      the stored thread ID.  */
558   *thread = new_thread_id;
559   /* Raise priority of thread manager if needed */
560   __pthread_manager_adjust_prio(new_thread->p_priority);
561   /* Do the cloning.  We have to use two different functions depending
562      on whether we are debugging or not.  */
563   pid = 0;      /* Note that the thread never can have PID zero.  */
564   if (report_events)
565     {
566       /* See whether the TD_CREATE event bit is set in any of the
567          masks.  */
568       int idx = __td_eventword (TD_CREATE);
569       uint32_t mask = __td_eventmask (TD_CREATE);
570
571       if ((mask & (__pthread_threads_events.event_bits[idx]
572                    | event_maskp->event_bits[idx])) != 0)
573         {
574           /* Lock the mutex the child will use now so that it will stop.  */
575           __pthread_lock(new_thread->p_lock, NULL);
576
577           /* We have to report this event.  */
578 #ifdef NEED_SEPARATE_REGISTER_STACK
579           /* Perhaps this version should be used on all platforms. But
580            this requires that __clone2 be uniformly supported
581            everywhere.
582
583            And there is some argument for changing the __clone2
584            interface to pass sp and bsp instead, making it more IA64
585            specific, but allowing stacks to grow outward from each
586            other, to get less paging and fewer mmaps.  Clone2
587            currently can't take signals in the child right after
588            process creation.  Mask them in the child.  It resets the
589            mask once it starts up.  */
590           sigprocmask(SIG_SETMASK, &manager_mask_all, NULL);
591           pid = __clone2(pthread_start_thread_event,
592                  (void **)new_thread_bottom,
593                          (char *)new_thread - new_thread_bottom,
594                          CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
595                          __pthread_sig_cancel, new_thread);
596           sigprocmask(SIG_SETMASK, &manager_mask, NULL);
597 #else
598           pid = __clone(pthread_start_thread_event, (void **) new_thread,
599                         CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
600                         __pthread_sig_cancel, new_thread);
601 #endif
602           if (pid != -1)
603             {
604               /* Now fill in the information about the new thread in
605                  the newly created thread's data structure.  We cannot let
606                  the new thread do this since we don't know whether it was
607                  already scheduled when we send the event.  */
608               new_thread->p_eventbuf.eventdata = new_thread;
609               new_thread->p_eventbuf.eventnum = TD_CREATE;
610               __pthread_last_event = new_thread;
611
612               /* We have to set the PID here since the callback function
613                  in the debug library will need it and we cannot guarantee
614                  the child got scheduled before the debugger.  */
615               new_thread->p_pid = pid;
616
617               /* Now call the function which signals the event.  */
618               __linuxthreads_create_event ();
619
620               /* Now restart the thread.  */
621               __pthread_unlock(new_thread->p_lock);
622             }
623         }
624     }
625   if (pid == 0)
626     {
627 #ifdef NEED_SEPARATE_REGISTER_STACK
628       sigprocmask(SIG_SETMASK, &manager_mask_all, NULL);
629       pid = __clone2(pthread_start_thread,
630                      (void **)new_thread_bottom,
631                      (char *)new_thread - new_thread_bottom,
632                      CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
633                      __pthread_sig_cancel, new_thread);
634       sigprocmask(SIG_SETMASK, &manager_mask, NULL);
635 #else
636       pid = __clone(pthread_start_thread, (void **) new_thread,
637                     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
638                     __pthread_sig_cancel, new_thread);
639 #endif /* !NEED_SEPARATE_REGISTER_STACK */
640     }
641   /* Check if cloning succeeded */
642   if (pid == -1) {
643     /* Free the stack if we allocated it */
644     if (attr == NULL || !attr->__stackaddr_set)
645       {
646 #ifdef NEED_SEPARATE_REGISTER_STACK
647         size_t stacksize = ((char *)(new_thread->p_guardaddr)
648                             - new_thread_bottom);
649         munmap((caddr_t)new_thread_bottom,
650                2 * stacksize + new_thread->p_guardsize);
651 #else
652         size_t stacksize = (char *)(new_thread+1) - new_thread_bottom;
653         munmap(new_thread_bottom - guardsize, guardsize + stacksize);
654 #endif
655       }
656     __pthread_handles[sseg].h_descr = NULL;
657     __pthread_handles[sseg].h_bottom = NULL;
658     __pthread_handles_num--;
659     return errno;
660   }
661   /* Insert new thread in doubly linked list of active threads */
662   new_thread->p_prevlive = __pthread_main_thread;
663   new_thread->p_nextlive = __pthread_main_thread->p_nextlive;
664   __pthread_main_thread->p_nextlive->p_prevlive = new_thread;
665   __pthread_main_thread->p_nextlive = new_thread;
666   /* Set pid field of the new thread, in case we get there before the
667      child starts. */
668   new_thread->p_pid = pid;
669   return 0;
670 }
671
672
673 /* Try to free the resources of a thread when requested by pthread_join
674    or pthread_detach on a terminated thread. */
675
676 static void pthread_free(pthread_descr th)
677 {
678   pthread_handle handle;
679   pthread_readlock_info *iter, *next;
680
681   ASSERT(th->p_exited);
682   /* Make the handle invalid */
683   handle =  thread_handle(th->p_tid);
684   __pthread_lock(&handle->h_lock, NULL);
685   handle->h_descr = NULL;
686   handle->h_bottom = (char *)(-1L);
687   __pthread_unlock(&handle->h_lock);
688 #ifdef FREE_THREAD
689   FREE_THREAD(th, th->p_nr);
690 #endif
691   /* One fewer threads in __pthread_handles */
692   __pthread_handles_num--;
693
694   /* Destroy read lock list, and list of free read lock structures.
695      If the former is not empty, it means the thread exited while
696      holding read locks! */
697
698   for (iter = th->p_readlock_list; iter != NULL; iter = next)
699     {
700       next = iter->pr_next;
701       free(iter);
702     }
703
704   for (iter = th->p_readlock_free; iter != NULL; iter = next)
705     {
706       next = iter->pr_next;
707       free(iter);
708     }
709
710   /* If initial thread, nothing to free */
711   if (!th->p_userstack)
712     {
713       size_t guardsize = th->p_guardsize;
714       /* Free the stack and thread descriptor area */
715       char *guardaddr = th->p_guardaddr;
716       /* Guardaddr is always set, even if guardsize is 0.  This allows
717          us to compute everything else.  */
718       size_t stacksize = (char *)(th+1) - guardaddr - guardsize;
719 #ifdef NEED_SEPARATE_REGISTER_STACK
720       /* Take account of the register stack, which is below guardaddr.  */
721       guardaddr -= stacksize;
722       stacksize *= 2;
723 #endif
724       /* Unmap the stack.  */
725       munmap(guardaddr, stacksize + guardsize);
726     }
727 }
728
729 /* Handle threads that have exited */
730
731 static void pthread_exited(pid_t pid)
732 {
733   pthread_descr th;
734   int detached;
735   /* Find thread with that pid */
736   for (th = __pthread_main_thread->p_nextlive;
737        th != __pthread_main_thread;
738        th = th->p_nextlive) {
739     if (th->p_pid == pid) {
740       /* Remove thread from list of active threads */
741       th->p_nextlive->p_prevlive = th->p_prevlive;
742       th->p_prevlive->p_nextlive = th->p_nextlive;
743       /* Mark thread as exited, and if detached, free its resources */
744       __pthread_lock(th->p_lock, NULL);
745       th->p_exited = 1;
746       /* If we have to signal this event do it now.  */
747       if (th->p_report_events)
748         {
749           /* See whether TD_REAP is in any of the mask.  */
750           int idx = __td_eventword (TD_REAP);
751           uint32_t mask = __td_eventmask (TD_REAP);
752
753           if ((mask & (__pthread_threads_events.event_bits[idx]
754                        | th->p_eventbuf.eventmask.event_bits[idx])) != 0)
755             {
756               /* Yep, we have to signal the reapage.  */
757               th->p_eventbuf.eventnum = TD_REAP;
758               th->p_eventbuf.eventdata = th;
759               __pthread_last_event = th;
760
761               /* Now call the function to signal the event.  */
762               __linuxthreads_reap_event();
763             }
764         }
765       detached = th->p_detached;
766       __pthread_unlock(th->p_lock);
767       if (detached)
768         pthread_free(th);
769       break;
770     }
771   }
772   /* If all threads have exited and the main thread is pending on a
773      pthread_exit, wake up the main thread and terminate ourselves. */
774   if (main_thread_exiting &&
775       __pthread_main_thread->p_nextlive == __pthread_main_thread) {
776     restart(__pthread_main_thread);
777     /* Same logic as REQ_MAIN_THREAD_EXIT. */
778   }
779 }
780
781 static void pthread_reap_children(void)
782 {
783   pid_t pid;
784   int status;
785
786   while ((pid = __libc_waitpid(-1, &status, WNOHANG | __WCLONE)) > 0) {
787     pthread_exited(pid);
788     if (WIFSIGNALED(status)) {
789       /* If a thread died due to a signal, send the same signal to
790          all other threads, including the main thread. */
791       pthread_kill_all_threads(WTERMSIG(status), 1);
792       _exit(0);
793     }
794   }
795 }
796
797 /* Try to free the resources of a thread when requested by pthread_join
798    or pthread_detach on a terminated thread. */
799
800 static void pthread_handle_free(pthread_t th_id)
801 {
802   pthread_handle handle = thread_handle(th_id);
803   pthread_descr th;
804
805   __pthread_lock(&handle->h_lock, NULL);
806   if (nonexisting_handle(handle, th_id)) {
807     /* pthread_reap_children has deallocated the thread already,
808        nothing needs to be done */
809     __pthread_unlock(&handle->h_lock);
810     return;
811   }
812   th = handle->h_descr;
813   if (th->p_exited) {
814     __pthread_unlock(&handle->h_lock);
815     pthread_free(th);
816   } else {
817     /* The Unix process of the thread is still running.
818        Mark the thread as detached so that the thread manager will
819        deallocate its resources when the Unix process exits. */
820     th->p_detached = 1;
821     __pthread_unlock(&handle->h_lock);
822   }
823 }
824
825 /* Send a signal to all running threads */
826
827 static void pthread_kill_all_threads(int sig, int main_thread_also)
828 {
829   pthread_descr th;
830   for (th = __pthread_main_thread->p_nextlive;
831        th != __pthread_main_thread;
832        th = th->p_nextlive) {
833     kill(th->p_pid, sig);
834   }
835   if (main_thread_also) {
836     kill(__pthread_main_thread->p_pid, sig);
837   }
838 }
839
840 /* Process-wide exit() */
841
842 static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode)
843 {
844   pthread_descr th;
845   __pthread_exit_requested = 1;
846   __pthread_exit_code = exitcode;
847   /* Send the CANCEL signal to all running threads, including the main
848      thread, but excluding the thread from which the exit request originated
849      (that thread must complete the exit, e.g. calling atexit functions
850      and flushing stdio buffers). */
851   for (th = issuing_thread->p_nextlive;
852        th != issuing_thread;
853        th = th->p_nextlive) {
854     kill(th->p_pid, __pthread_sig_cancel);
855   }
856   /* Now, wait for all these threads, so that they don't become zombies
857      and their times are properly added to the thread manager's times. */
858   for (th = issuing_thread->p_nextlive;
859        th != issuing_thread;
860        th = th->p_nextlive) {
861     waitpid(th->p_pid, NULL, __WCLONE);
862   }
863   restart(issuing_thread);
864   _exit(0);
865 }
866
867 /* Handler for __pthread_sig_cancel in thread manager thread */
868
869 void __pthread_manager_sighandler(int sig)
870 {
871   int kick_manager = terminated_children == 0 && main_thread_exiting;
872   terminated_children = 1;
873
874   /* If the main thread is terminating, kick the thread manager loop
875      each time some threads terminate. This eliminates a two second
876      shutdown delay caused by the thread manager sleeping in the
877      call to __poll(). Instead, the thread manager is kicked into
878      action, reaps the outstanding threads and resumes the main thread
879      so that it can complete the shutdown. */
880
881   if (kick_manager) {
882     struct pthread_request request;
883     request.req_thread = 0;
884     request.req_kind = REQ_KICK;
885     __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
886   }
887 }
888
889 /* Adjust priority of thread manager so that it always run at a priority
890    higher than all threads */
891
892 void __pthread_manager_adjust_prio(int thread_prio)
893 {
894   struct sched_param param;
895
896   if (thread_prio <= __pthread_manager_thread.p_priority) return;
897   param.sched_priority =
898     thread_prio < __sched_get_priority_max(SCHED_FIFO)
899     ? thread_prio + 1 : thread_prio;
900   __sched_setscheduler(__pthread_manager_thread.p_pid, SCHED_FIFO, &param);
901   __pthread_manager_thread.p_priority = thread_prio;
902 }