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