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