Updated to fedora-glibc-20060907T0853
[kopensolaris-gnu/glibc.git] / nptl / pthread_create.c
1 /* Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library 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 GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <errno.h>
21 #include <stdbool.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include "pthreadP.h"
25 #include <hp-timing.h>
26 #include <ldsodefs.h>
27 #include <atomic.h>
28 #include <libc-internal.h>
29 #include <resolv.h>
30
31 #include <shlib-compat.h>
32
33
34 /* Local function to start thread and handle cleanup.  */
35 static int start_thread (void *arg);
36
37
38 /* Nozero if debugging mode is enabled.  */
39 int __pthread_debug;
40
41 /* Globally enabled events.  */
42 static td_thr_events_t __nptl_threads_events;
43
44 /* Pointer to descriptor with the last event.  */
45 static struct pthread *__nptl_last_event;
46
47 /* Number of threads running.  */
48 unsigned int __nptl_nthreads = 1;
49
50
51 /* Code to allocate and deallocate a stack.  */
52 #include "allocatestack.c"
53
54 /* Code to create the thread.  */
55 #include <createthread.c>
56
57
58 struct pthread *
59 internal_function
60 __find_in_stack_list (pd)
61      struct pthread *pd;
62 {
63   list_t *entry;
64   struct pthread *result = NULL;
65
66   lll_lock (stack_cache_lock);
67
68   list_for_each (entry, &stack_used)
69     {
70       struct pthread *curp;
71
72       curp = list_entry (entry, struct pthread, list);
73       if (curp == pd)
74         {
75           result = curp;
76           break;
77         }
78     }
79
80   if (result == NULL)
81     list_for_each (entry, &__stack_user)
82       {
83         struct pthread *curp;
84
85         curp = list_entry (entry, struct pthread, list);
86         if (curp == pd)
87           {
88             result = curp;
89             break;
90           }
91       }
92
93   lll_unlock (stack_cache_lock);
94
95   return result;
96 }
97
98
99 /* Deallocate POSIX thread-local-storage.  */
100 void
101 attribute_hidden
102 __nptl_deallocate_tsd (void)
103 {
104   struct pthread *self = THREAD_SELF;
105
106   /* Maybe no data was ever allocated.  This happens often so we have
107      a flag for this.  */
108   if (THREAD_GETMEM (self, specific_used))
109     {
110       size_t round;
111       size_t cnt;
112
113       round = 0;
114       do
115         {
116           size_t idx;
117
118           /* So far no new nonzero data entry.  */
119           THREAD_SETMEM (self, specific_used, false);
120
121           for (cnt = idx = 0; cnt < PTHREAD_KEY_1STLEVEL_SIZE; ++cnt)
122             {
123               struct pthread_key_data *level2;
124
125               level2 = THREAD_GETMEM_NC (self, specific, cnt);
126
127               if (level2 != NULL)
128                 {
129                   size_t inner;
130
131                   for (inner = 0; inner < PTHREAD_KEY_2NDLEVEL_SIZE;
132                        ++inner, ++idx)
133                     {
134                       void *data = level2[inner].data;
135
136                       if (data != NULL)
137                         {
138                           /* Always clear the data.  */
139                           level2[inner].data = NULL;
140
141                           /* Make sure the data corresponds to a valid
142                              key.  This test fails if the key was
143                              deallocated and also if it was
144                              re-allocated.  It is the user's
145                              responsibility to free the memory in this
146                              case.  */
147                           if (level2[inner].seq
148                               == __pthread_keys[idx].seq
149                               /* It is not necessary to register a destructor
150                                  function.  */
151                               && __pthread_keys[idx].destr != NULL)
152                             /* Call the user-provided destructor.  */
153                             __pthread_keys[idx].destr (data);
154                         }
155                     }
156                 }
157               else
158                 idx += PTHREAD_KEY_1STLEVEL_SIZE;
159             }
160
161           if (THREAD_GETMEM (self, specific_used) == 0)
162             /* No data has been modified.  */
163             goto just_free;
164         }
165       /* We only repeat the process a fixed number of times.  */
166       while (__builtin_expect (++round < PTHREAD_DESTRUCTOR_ITERATIONS, 0));
167
168       /* Just clear the memory of the first block for reuse.  */
169       memset (&THREAD_SELF->specific_1stblock, '\0',
170               sizeof (self->specific_1stblock));
171
172     just_free:
173       /* Free the memory for the other blocks.  */
174       for (cnt = 1; cnt < PTHREAD_KEY_1STLEVEL_SIZE; ++cnt)
175         {
176           struct pthread_key_data *level2;
177
178           level2 = THREAD_GETMEM_NC (self, specific, cnt);
179           if (level2 != NULL)
180             {
181               /* The first block is allocated as part of the thread
182                  descriptor.  */
183               free (level2);
184               THREAD_SETMEM_NC (self, specific, cnt, NULL);
185             }
186         }
187
188       THREAD_SETMEM (self, specific_used, false);
189     }
190 }
191
192
193 /* Deallocate a thread's stack after optionally making sure the thread
194    descriptor is still valid.  */
195 void
196 internal_function
197 __free_tcb (struct pthread *pd)
198 {
199   /* The thread is exiting now.  */
200   if (__builtin_expect (atomic_bit_test_set (&pd->cancelhandling,
201                                              TERMINATED_BIT) == 0, 1))
202     {
203       /* Remove the descriptor from the list.  */
204       if (DEBUGGING_P && __find_in_stack_list (pd) == NULL)
205         /* Something is really wrong.  The descriptor for a still
206            running thread is gone.  */
207         abort ();
208
209       /* Free TPP data.  */
210       if (__builtin_expect (pd->tpp != NULL, 0))
211         {
212           struct priority_protection_data *tpp = pd->tpp;
213
214           pd->tpp = NULL;
215           free (tpp);
216         }
217
218       /* Queue the stack memory block for reuse and exit the process.  The
219          kernel will signal via writing to the address returned by
220          QUEUE-STACK when the stack is available.  */
221       __deallocate_stack (pd);
222     }
223 }
224
225
226 static int
227 start_thread (void *arg)
228 {
229   struct pthread *pd = (struct pthread *) arg;
230
231 #if HP_TIMING_AVAIL
232   /* Remember the time when the thread was started.  */
233   hp_timing_t now;
234   HP_TIMING_NOW (now);
235   THREAD_SETMEM (pd, cpuclock_offset, now);
236 #endif
237
238   /* Initialize resolver state pointer.  */
239   __resp = &pd->res;
240
241 #ifdef __NR_set_robust_list
242 # ifndef __ASSUME_SET_ROBUST_LIST
243   if (__set_robust_list_avail >= 0)
244 # endif
245     {
246       INTERNAL_SYSCALL_DECL (err);
247       /* This call should never fail because the initial call in init.c
248          succeeded.  */
249       INTERNAL_SYSCALL (set_robust_list, err, 2, &pd->robust_head,
250                         sizeof (struct robust_list_head));
251     }
252 #endif
253
254   /* If the parent was running cancellation handlers while creating
255      the thread the new thread inherited the signal mask.  Reset the
256      cancellation signal mask.  */
257   if (__builtin_expect (pd->parent_cancelhandling & CANCELING_BITMASK, 0))
258     {
259       INTERNAL_SYSCALL_DECL (err);
260       sigset_t mask;
261       __sigemptyset (&mask);
262       __sigaddset (&mask, SIGCANCEL);
263       (void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &mask,
264                                NULL, _NSIG / 8);
265     }
266
267   /* This is where the try/finally block should be created.  For
268      compilers without that support we do use setjmp.  */
269   struct pthread_unwind_buf unwind_buf;
270
271   /* No previous handlers.  */
272   unwind_buf.priv.data.prev = NULL;
273   unwind_buf.priv.data.cleanup = NULL;
274
275   int not_first_call;
276   not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
277   if (__builtin_expect (! not_first_call, 1))
278     {
279       /* Store the new cleanup handler info.  */
280       THREAD_SETMEM (pd, cleanup_jmp_buf, &unwind_buf);
281
282       if (__builtin_expect (pd->stopped_start, 0))
283         {
284           int oldtype = CANCEL_ASYNC ();
285
286           /* Get the lock the parent locked to force synchronization.  */
287           lll_lock (pd->lock);
288           /* And give it up right away.  */
289           lll_unlock (pd->lock);
290
291           CANCEL_RESET (oldtype);
292         }
293
294       /* Run the code the user provided.  */
295 #ifdef CALL_THREAD_FCT
296       THREAD_SETMEM (pd, result, CALL_THREAD_FCT (pd));
297 #else
298       THREAD_SETMEM (pd, result, pd->start_routine (pd->arg));
299 #endif
300     }
301
302   /* Run the destructor for the thread-local data.  */
303   __nptl_deallocate_tsd ();
304
305   /* Clean up any state libc stored in thread-local variables.  */
306   __libc_thread_freeres ();
307
308   /* If this is the last thread we terminate the process now.  We
309      do not notify the debugger, it might just irritate it if there
310      is no thread left.  */
311   if (__builtin_expect (atomic_decrement_and_test (&__nptl_nthreads), 0))
312     /* This was the last thread.  */
313     exit (0);
314
315   /* Report the death of the thread if this is wanted.  */
316   if (__builtin_expect (pd->report_events, 0))
317     {
318       /* See whether TD_DEATH is in any of the mask.  */
319       const int idx = __td_eventword (TD_DEATH);
320       const uint32_t mask = __td_eventmask (TD_DEATH);
321
322       if ((mask & (__nptl_threads_events.event_bits[idx]
323                    | pd->eventbuf.eventmask.event_bits[idx])) != 0)
324         {
325           /* Yep, we have to signal the death.  Add the descriptor to
326              the list but only if it is not already on it.  */
327           if (pd->nextevent == NULL)
328             {
329               pd->eventbuf.eventnum = TD_DEATH;
330               pd->eventbuf.eventdata = pd;
331
332               do
333                 pd->nextevent = __nptl_last_event;
334               while (atomic_compare_and_exchange_bool_acq (&__nptl_last_event,
335                                                            pd, pd->nextevent));
336             }
337
338           /* Now call the function to signal the event.  */
339           __nptl_death_event ();
340         }
341     }
342
343   /* The thread is exiting now.  Don't set this bit until after we've hit
344      the event-reporting breakpoint, so that td_thr_get_info on us while at
345      the breakpoint reports TD_THR_RUN state rather than TD_THR_ZOMBIE.  */
346   atomic_bit_set (&pd->cancelhandling, EXITING_BIT);
347
348 #ifndef __ASSUME_SET_ROBUST_LIST
349   /* If this thread has any robust mutexes locked, handle them now.  */
350 # if __WORDSIZE == 64
351   void *robust = pd->robust_head.list;
352 # else
353   __pthread_slist_t *robust = pd->robust_list.__next;
354 # endif
355   /* We let the kernel do the notification if it is able to do so.
356      If we have to do it here there for sure are no PI mutexes involved
357      since the kernel support for them is even more recent.  */
358   if (__set_robust_list_avail < 0
359       && __builtin_expect (robust != (void *) &pd->robust_head, 0))
360     {
361       do
362         {
363           struct __pthread_mutex_s *this = (struct __pthread_mutex_s *)
364             ((char *) robust - offsetof (struct __pthread_mutex_s,
365                                          __list.__next));
366           robust = *((void **) robust);
367
368 # ifdef __PTHREAD_MUTEX_HAVE_PREV
369           this->__list.__prev = NULL;
370 # endif
371           this->__list.__next = NULL;
372
373           lll_robust_mutex_dead (this->__lock);
374         }
375       while (robust != (void *) &pd->robust_head);
376     }
377 #endif
378
379   /* If the thread is detached free the TCB.  */
380   if (IS_DETACHED (pd))
381     /* Free the TCB.  */
382     __free_tcb (pd);
383   else if (__builtin_expect (pd->cancelhandling & SETXID_BITMASK, 0))
384     {
385       /* Some other thread might call any of the setXid functions and expect
386          us to reply.  In this case wait until we did that.  */
387       do
388         lll_futex_wait (&pd->setxid_futex, 0);
389       while (pd->cancelhandling & SETXID_BITMASK);
390
391       /* Reset the value so that the stack can be reused.  */
392       pd->setxid_futex = 0;
393     }
394
395   /* We cannot call '_exit' here.  '_exit' will terminate the process.
396
397      The 'exit' implementation in the kernel will signal when the
398      process is really dead since 'clone' got passed the CLONE_CLEARTID
399      flag.  The 'tid' field in the TCB will be set to zero.
400
401      The exit code is zero since in case all threads exit by calling
402      'pthread_exit' the exit status must be 0 (zero).  */
403   __exit_thread_inline (0);
404
405   /* NOTREACHED */
406   return 0;
407 }
408
409
410 /* Default thread attributes for the case when the user does not
411    provide any.  */
412 static const struct pthread_attr default_attr =
413   {
414     /* Just some value > 0 which gets rounded to the nearest page size.  */
415     .guardsize = 1,
416   };
417
418
419 int
420 __pthread_create_2_1 (newthread, attr, start_routine, arg)
421      pthread_t *newthread;
422      const pthread_attr_t *attr;
423      void *(*start_routine) (void *);
424      void *arg;
425 {
426   STACK_VARIABLES;
427
428   const struct pthread_attr *iattr = (struct pthread_attr *) attr;
429   if (iattr == NULL)
430     /* Is this the best idea?  On NUMA machines this could mean
431        accessing far-away memory.  */
432     iattr = &default_attr;
433
434   struct pthread *pd = NULL;
435   int err = ALLOCATE_STACK (iattr, &pd);
436   if (__builtin_expect (err != 0, 0))
437     /* Something went wrong.  Maybe a parameter of the attributes is
438        invalid or we could not allocate memory.  */
439     return err;
440
441
442   /* Initialize the TCB.  All initializations with zero should be
443      performed in 'get_cached_stack'.  This way we avoid doing this if
444      the stack freshly allocated with 'mmap'.  */
445
446 #ifdef TLS_TCB_AT_TP
447   /* Reference to the TCB itself.  */
448   pd->header.self = pd;
449
450   /* Self-reference for TLS.  */
451   pd->header.tcb = pd;
452 #endif
453
454   /* Store the address of the start routine and the parameter.  Since
455      we do not start the function directly the stillborn thread will
456      get the information from its thread descriptor.  */
457   pd->start_routine = start_routine;
458   pd->arg = arg;
459
460   /* Copy the thread attribute flags.  */
461   struct pthread *self = THREAD_SELF;
462   pd->flags = ((iattr->flags & ~(ATTR_FLAG_SCHED_SET | ATTR_FLAG_POLICY_SET))
463                | (self->flags & (ATTR_FLAG_SCHED_SET | ATTR_FLAG_POLICY_SET)));
464
465   /* Initialize the field for the ID of the thread which is waiting
466      for us.  This is a self-reference in case the thread is created
467      detached.  */
468   pd->joinid = iattr->flags & ATTR_FLAG_DETACHSTATE ? pd : NULL;
469
470   /* The debug events are inherited from the parent.  */
471   pd->eventbuf = self->eventbuf;
472
473
474   /* Copy the parent's scheduling parameters.  The flags will say what
475      is valid and what is not.  */
476   pd->schedpolicy = self->schedpolicy;
477   pd->schedparam = self->schedparam;
478
479   /* Copy the stack guard canary.  */
480 #ifdef THREAD_COPY_STACK_GUARD
481   THREAD_COPY_STACK_GUARD (pd);
482 #endif
483
484   /* Copy the pointer guard value.  */
485 #ifdef THREAD_COPY_POINTER_GUARD
486   THREAD_COPY_POINTER_GUARD (pd);
487 #endif
488
489   /* Determine scheduling parameters for the thread.  */
490   if (attr != NULL
491       && __builtin_expect ((iattr->flags & ATTR_FLAG_NOTINHERITSCHED) != 0, 0)
492       && (iattr->flags & (ATTR_FLAG_SCHED_SET | ATTR_FLAG_POLICY_SET)) != 0)
493     {
494       INTERNAL_SYSCALL_DECL (scerr);
495
496       /* Use the scheduling parameters the user provided.  */
497       if (iattr->flags & ATTR_FLAG_POLICY_SET)
498         pd->schedpolicy = iattr->schedpolicy;
499       else if ((pd->flags & ATTR_FLAG_POLICY_SET) == 0)
500         {
501           pd->schedpolicy = INTERNAL_SYSCALL (sched_getscheduler, scerr, 1, 0);
502           pd->flags |= ATTR_FLAG_POLICY_SET;
503         }
504
505       if (iattr->flags & ATTR_FLAG_SCHED_SET)
506         memcpy (&pd->schedparam, &iattr->schedparam,
507                 sizeof (struct sched_param));
508       else if ((pd->flags & ATTR_FLAG_SCHED_SET) == 0)
509         {
510           INTERNAL_SYSCALL (sched_getparam, scerr, 2, 0, &pd->schedparam);
511           pd->flags |= ATTR_FLAG_SCHED_SET;
512         }
513
514       /* Check for valid priorities.  */
515       int minprio = INTERNAL_SYSCALL (sched_get_priority_min, scerr, 1,
516                                       iattr->schedpolicy);
517       int maxprio = INTERNAL_SYSCALL (sched_get_priority_max, scerr, 1,
518                                       iattr->schedpolicy);
519       if (pd->schedparam.sched_priority < minprio
520           || pd->schedparam.sched_priority > maxprio)
521         {
522           err = EINVAL;
523           goto errout;
524         }
525     }
526
527   /* Pass the descriptor to the caller.  */
528   *newthread = (pthread_t) pd;
529
530   /* Remember whether the thread is detached or not.  In case of an
531      error we have to free the stacks of non-detached stillborn
532      threads.  */
533   bool is_detached = IS_DETACHED (pd);
534
535   /* Start the thread.  */
536   err = create_thread (pd, iattr, STACK_VARIABLES_ARGS);
537   if (err != 0)
538     {
539       /* Something went wrong.  Free the resources.  */
540       if (!is_detached)
541         {
542         errout:
543           __deallocate_stack (pd);
544         }
545       return err;
546     }
547
548   return 0;
549 }
550 versioned_symbol (libpthread, __pthread_create_2_1, pthread_create, GLIBC_2_1);
551
552
553 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
554 int
555 __pthread_create_2_0 (newthread, attr, start_routine, arg)
556      pthread_t *newthread;
557      const pthread_attr_t *attr;
558      void *(*start_routine) (void *);
559      void *arg;
560 {
561   /* The ATTR attribute is not really of type `pthread_attr_t *'.  It has
562      the old size and access to the new members might crash the program.
563      We convert the struct now.  */
564   struct pthread_attr new_attr;
565
566   if (attr != NULL)
567     {
568       struct pthread_attr *iattr = (struct pthread_attr *) attr;
569       size_t ps = __getpagesize ();
570
571       /* Copy values from the user-provided attributes.  */
572       new_attr.schedparam = iattr->schedparam;
573       new_attr.schedpolicy = iattr->schedpolicy;
574       new_attr.flags = iattr->flags;
575
576       /* Fill in default values for the fields not present in the old
577          implementation.  */
578       new_attr.guardsize = ps;
579       new_attr.stackaddr = NULL;
580       new_attr.stacksize = 0;
581       new_attr.cpuset = NULL;
582
583       /* We will pass this value on to the real implementation.  */
584       attr = (pthread_attr_t *) &new_attr;
585     }
586
587   return __pthread_create_2_1 (newthread, attr, start_routine, arg);
588 }
589 compat_symbol (libpthread, __pthread_create_2_0, pthread_create,
590                GLIBC_2_0);
591 #endif
592 \f
593 /* Information for libthread_db.  */
594
595 #include "../nptl_db/db_info.c"
596 \f
597 /* If pthread_create is present, libgcc_eh.a and libsupc++.a expects some other POSIX thread
598    functions to be present as well.  */
599 PTHREAD_STATIC_FN_REQUIRE (pthread_mutex_lock)
600 PTHREAD_STATIC_FN_REQUIRE (pthread_mutex_unlock)
601
602 PTHREAD_STATIC_FN_REQUIRE (pthread_once)
603 PTHREAD_STATIC_FN_REQUIRE (pthread_cancel)
604
605 PTHREAD_STATIC_FN_REQUIRE (pthread_key_create)
606 PTHREAD_STATIC_FN_REQUIRE (pthread_setspecific)
607 PTHREAD_STATIC_FN_REQUIRE (pthread_getspecific)