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