Define __nptl_nthreads
[kopensolaris-gnu/glibc.git] / nptl / pthread_create.c
1 /* Copyright (C) 2002, 2003 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
29 #include <shlib-compat.h>
30
31
32 /* Local function to start thread and handle cleanup.  */
33 static int start_thread (void *arg);
34 /* Similar version used when debugging.  */
35 static int start_thread_debug (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 #define DEFINE_DEALLOC
53 #include "allocatestack.c"
54
55 /* Code to create the thread.  */
56 #include "createthread.c"
57
58
59 /* Table of the key information.  */
60 struct pthread_key_struct __pthread_keys[PTHREAD_KEYS_MAX]
61   __attribute__ ((section (".bss")));
62 hidden_def (__pthread_keys)
63
64 /* This is for libthread_db only.  */
65 const int __pthread_pthread_sizeof_descr = sizeof (struct pthread);
66
67 struct pthread *
68 __find_in_stack_list (pd)
69      struct pthread *pd;
70 {
71   list_t *entry;
72   struct pthread *result = NULL;
73
74   lll_lock (stack_cache_lock);
75
76   list_for_each (entry, &stack_used)
77     {
78       struct pthread *curp;
79
80       curp = list_entry (entry, struct pthread, header.data.list);
81       if (curp == pd)
82         {
83           result = curp;
84           break;
85         }
86     }
87
88   if (result == NULL)
89     list_for_each (entry, &__stack_user)
90       {
91         struct pthread *curp;
92
93         curp = list_entry (entry, struct pthread, header.data.list);
94         if (curp == pd)
95           {
96             result = curp;
97             break;
98           }
99       }
100
101   lll_unlock (stack_cache_lock);
102
103   return result;
104 }
105
106
107 /* Deallocate POSIX thread-local-storage.  */
108 static void
109 deallocate_tsd (struct pthread *pd)
110 {
111   /* Maybe no data was ever allocated.  This happens often so we have
112      a flag for this.  */
113   if (pd->specific_used)
114     {
115       size_t round;
116       bool found_nonzero;
117
118       for (round = 0, found_nonzero = true;
119            found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
120            ++round)
121         {
122           size_t cnt;
123           size_t idx;
124
125           for (cnt = idx = 0; cnt < PTHREAD_KEY_1STLEVEL_SIZE; ++cnt)
126             if (pd->specific[cnt] != NULL)
127               {
128                 size_t inner;
129
130                 for (inner = 0; inner < PTHREAD_KEY_2NDLEVEL_SIZE;
131                      ++inner, ++idx)
132                   {
133                     void *data = pd->specific[cnt][inner].data;
134
135                     if (data != NULL
136                         /* Make sure the data corresponds to a valid
137                            key.  This test fails if the key was
138                            deallocated and also if it was
139                            re-allocated.  It is the user's
140                            responsibility to free the memory in this
141                            case.  */
142                         && (pd->specific[cnt][inner].seq
143                             == __pthread_keys[idx].seq)
144                         /* It is not necessary to register a destructor
145                            function.  */
146                         && __pthread_keys[idx].destr != NULL)
147                       {
148                         pd->specific[cnt][inner].data = NULL;
149                         __pthread_keys[idx].destr (data);
150                         found_nonzero = true;
151                       }
152                   }
153
154                 if (cnt != 0)
155                   {
156                     /* The first block is allocated as part of the thread
157                        descriptor.  */
158                     free (pd->specific[cnt]);
159                     pd->specific[cnt] = NULL;
160                   }
161                 else
162                   /* Clear the memory of the first block for reuse.  */
163                   memset (pd->specific[0], '\0',
164                           sizeof (struct pthread_key_data));
165               }
166             else
167               idx += PTHREAD_KEY_1STLEVEL_SIZE;
168         }
169
170       pd->specific_used = false;
171     }
172 }
173
174
175 /* Deallocate a thread's stack after optionally making sure the thread
176    descriptor is still valid.  */
177 void
178 __free_tcb (struct pthread *pd)
179 {
180   /* The thread is exiting now.  */
181   if (atomic_bit_test_set (&pd->cancelhandling, TERMINATED_BIT) == 0)
182     {
183       /* Remove the descriptor from the list.  */
184       if (DEBUGGING_P && __find_in_stack_list (pd) == NULL)
185         /* Something is really wrong.  The descriptor for a still
186            running thread is gone.  */
187         abort ();
188
189       /* Run the destructor for the thread-local data.  */
190       deallocate_tsd (pd);
191
192       /* Queue the stack memory block for reuse and exit the process.  The
193          kernel will signal via writing to the address returned by
194          QUEUE-STACK when the stack is available.  */
195       __deallocate_stack (pd);
196     }
197 }
198
199
200 static int
201 start_thread (void *arg)
202 {
203   /* One more thread.  */
204   atomic_increment (&__nptl_nthreads);
205
206   struct pthread *pd = (struct pthread *) arg;
207
208 #if HP_TIMING_AVAIL
209   /* Remember the time when the thread was started.  */
210   hp_timing_t now;
211   HP_TIMING_NOW (now);
212   THREAD_SETMEM (pd, cpuclock_offset, now);
213 #endif
214
215   /* This is where the try/finally block should be created.  For
216      compilers without that support we do use setjmp.  */
217   if (setjmp (pd->cancelbuf) == 0)
218     {
219       /* Run the code the user provided.  */
220       pd->result = pd->start_routine (pd->arg);
221     }
222
223
224   /* If this is the last thread we terminate the process now.  We
225      do not notify the debugger, it might just irritate it if there
226      is no thread left.  */
227   if (atomic_decrement_and_test (&__nptl_nthreads))
228     /* This was the last thread.  */
229     exit (0);
230
231
232   /* Report the death of the thread if this is wanted.  */
233   if (__builtin_expect (pd->report_events, 0))
234     {
235       /* See whether TD_DEATH is in any of the mask.  */
236       const int idx = __td_eventword (TD_DEATH);
237       const uint32_t mask = __td_eventmask (TD_DEATH);
238
239       if ((mask & (__nptl_threads_events.event_bits[idx]
240                    | pd->eventbuf.eventmask.event_bits[idx])) != 0)
241         {
242           /* Yep, we have to signal the death.  Add the descriptor to
243              the list but only if it is not already on it.  */
244           if (pd->nextevent == NULL)
245             {
246               pd->eventbuf.eventnum = TD_DEATH;
247               pd->eventbuf.eventdata = pd;
248
249               do
250                 pd->nextevent = __nptl_last_event;
251               while (atomic_compare_and_exchange_acq (&__nptl_last_event, pd,
252                                                       pd->nextevent) != 0);
253             }
254
255           /* Now call the function to signal the event.  */
256           __nptl_death_event ();
257         }
258     }
259
260
261   /* The thread is exiting now.  */
262   atomic_bit_set (&pd->cancelhandling, EXITING_BIT);
263
264   /* If the thread is detached free the TCB.  */
265   if (IS_DETACHED (pd))
266     /* Free the TCB.  */
267     __free_tcb (pd);
268
269   /* We cannot call '_exit' here.  '_exit' will terminate the process.
270
271      The 'exit' implementation in the kernel will signal when the
272      process is really dead since 'clone' got passed the CLONE_CLEARTID
273      flag.  The 'tid' field in the TCB will be set to zero.
274
275      The exit code is zero since in case all threads exit by calling
276      'pthread_exit' the exit status must be 0 (zero).  */
277   __exit_thread_inline (0);
278
279   /* NOTREACHED */
280   return 0;
281 }
282
283
284 /* Just list start_thread but we do some more things needed for a run
285    with a debugger attached.  */
286 static int
287 start_thread_debug (void *arg)
288 {
289   struct pthread *pd = (struct pthread *) arg;
290
291   /* Get the lock the parent locked to force synchronization.  */
292   lll_lock (pd->lock);
293   /* And give it up right away.  */
294   lll_unlock (pd->lock);
295
296   /* Now do the actual startup.  */
297   return start_thread (arg);
298 }
299
300
301 /* Default thread attributes for the case when the user does not
302    provide any.  */
303 static const struct pthread_attr default_attr =
304   {
305     /* Just some value > 0 which gets rounded to the nearest page size.  */
306     .guardsize = 1,
307   };
308
309
310 int
311 __pthread_create_2_1 (newthread, attr, start_routine, arg)
312      pthread_t *newthread;
313      const pthread_attr_t *attr;
314      void *(*start_routine) (void *);
315      void *arg;
316 {
317   STACK_VARIABLES;
318   const struct pthread_attr *iattr;
319   struct pthread *pd;
320   int err;
321
322   iattr = (struct pthread_attr *) attr;
323   if (iattr == NULL)
324     /* Is this the best idea?  On NUMA machines this could mean
325        accessing far-away memory.  */
326     iattr = &default_attr;
327
328   err = ALLOCATE_STACK (iattr, &pd);
329   if (err != 0)
330     /* Something went wrong.  Maybe a parameter of the attributes is
331        invalid or we could not allocate memory.  */
332     return err;
333
334
335   /* Initialize the TCB.  All initializations with zero should be
336      performed in 'get_cached_stack'.  This way we avoid doing this if
337      the stack freshly allocated with 'mmap'.  */
338
339   /* Reference to the TCB itself.  */
340   pd->header.data.self = pd;
341
342 #ifdef TLS_TCB_AT_TP
343   /* Self-reference.  */
344   pd->header.data.tcb = pd;
345 #endif
346
347   /* Store the address of the start routine and the parameter.  Since
348      we do not start the function directly the stillborn thread will
349      get the information from its thread descriptor.  */
350   pd->start_routine = start_routine;
351   pd->arg = arg;
352
353   /* Copy the thread attribute flags.  */
354   pd->flags = iattr->flags;
355
356   /* Initialize the field for the ID of the thread which is waiting
357      for us.  This is a self-reference in case the thread is created
358      detached.  */
359   pd->joinid = iattr->flags & ATTR_FLAG_DETACHSTATE ? pd : NULL;
360
361   /* The debug events are inherited from the parent.  */
362   pd->eventbuf = THREAD_SELF->eventbuf;
363
364
365   /* Determine scheduling parameters for the thread.
366      XXX How to determine whether scheduling handling is needed?  */
367   if (0 && attr != NULL)
368     {
369       if (iattr->flags & ATTR_FLAG_NOTINHERITSCHED)
370         {
371           /* Use the scheduling parameters the user provided.  */
372           pd->schedpolicy = iattr->schedpolicy;
373           memcpy (&pd->schedparam, &iattr->schedparam,
374                   sizeof (struct sched_param));
375         }
376       else
377         {
378           /* Just store the scheduling attributes of the parent.  */
379           pd->schedpolicy = __sched_getscheduler (0);
380           __sched_getparam (0, &pd->schedparam);
381         }
382     }
383
384   /* Pass the descriptor to the caller.  */
385   *newthread = (pthread_t) pd;
386
387   /* Start the thread.  */
388   err = create_thread (pd, STACK_VARIABLES_ARGS);
389   if (err != 0)
390     {
391       /* Something went wrong.  Free the resources.  */
392       __deallocate_stack (pd);
393       return err;
394     }
395
396   return 0;
397 }
398 versioned_symbol (libpthread, __pthread_create_2_1, pthread_create, GLIBC_2_1);
399
400
401 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
402 int
403 __pthread_create_2_0 (newthread, attr, start_routine, arg)
404      pthread_t *newthread;
405      const pthread_attr_t *attr;
406      void *(*start_routine) (void *);
407      void *arg;
408 {
409   /* The ATTR attribute is not really of type `pthread_attr_t *'.  It has
410      the old size and access to the new members might crash the program.
411      We convert the struct now.  */
412   struct pthread_attr new_attr;
413
414   if (attr != NULL)
415     {
416       struct pthread_attr *iattr = (struct pthread_attr *) attr;
417       size_t ps = __getpagesize ();
418
419       /* Copy values from the user-provided attributes.  */
420       new_attr.schedparam = iattr->schedparam;
421       new_attr.schedpolicy = iattr->schedpolicy;
422       new_attr.flags = iattr->flags;
423
424       /* Fill in default values for the fields not present in the old
425          implementation.  */
426       new_attr.guardsize = ps;
427       new_attr.stackaddr = NULL;
428       new_attr.stacksize = 0;
429
430       /* We will pass this value on to the real implementation.  */
431       attr = (pthread_attr_t *) &new_attr;
432     }
433
434   return __pthread_create_2_1 (newthread, attr, start_routine, arg);
435 }
436 compat_symbol (libpthread, __pthread_create_2_0, pthread_create,
437                GLIBC_2_0);
438 #endif