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