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