htl/pt-alloc.c

   1 /* Allocate a new thread structure.
   2    Copyright (C) 2000-2021 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   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, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <pthread.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <pt-internal.h>
  26
  27 /* This braindamage is necessary because the standard says that some
  28    of the threads functions "shall fail" if "No thread could be found
  29    corresponding to that specified by the given thread ID."  */
  30
  31 /* The size of the thread ID lookup table.  */
  32 int __pthread_max_threads;
  33
  34 /* List of thread structures corresponding to free thread IDs.  */
  35 struct __pthread *__pthread_free_threads;
  36 pthread_mutex_t __pthread_free_threads_lock;
  37
  38 static inline error_t
  39 initialize_pthread (struct __pthread *new)
  40 {
  41   error_t err;
  42
  43   err = __pthread_init_specific (new);
  44   if (err)
  45     return err;
  46
  47   new->nr_refs = 1;
  48   new->cancel_lock = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
  49   new->cancel_hook = NULL;
  50   new->cancel_hook_arg = NULL;
  51   new->cancel_state = PTHREAD_CANCEL_ENABLE;
  52   new->cancel_type = PTHREAD_CANCEL_DEFERRED;
  53   new->cancel_pending = 0;
  54
  55   new->state_lock = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
  56   new->state_cond = (pthread_cond_t) PTHREAD_COND_INITIALIZER;
  57
  58   memset (&new->res_state, '\0', sizeof (new->res_state));
  59
  60   new->tcb = NULL;
  61
  62   new->next = 0;
  63   new->prevp = 0;
  64
  65   return 0;
  66 }
  67
  68
  69 /* Allocate a new thread structure and its pthread thread ID (but not
  70    a kernel thread).  */
  71 int
  72 __pthread_alloc (struct __pthread **pthread)
  73 {
  74   error_t err;
  75
  76   struct __pthread *new;
  77   struct __pthread **threads;
  78   struct __pthread **old_threads;
  79   int max_threads;
  80   int new_max_threads;
  81
  82   __pthread_mutex_lock (&__pthread_free_threads_lock);
  83   for (new = __pthread_free_threads; new; new = new->next)
  84     {
  85       /* There is no need to take NEW->STATE_LOCK: if NEW is on this
  86          list, then it is protected by __PTHREAD_FREE_THREADS_LOCK
  87          except in __pthread_dealloc where after it is added to the
  88          list (with the lock held), it drops the lock and then sets
  89          NEW->STATE and immediately stops using NEW.  */
  90       if (new->state == PTHREAD_TERMINATED)
  91         {
  92           __pthread_dequeue (new);
  93           break;
  94         }
  95     }
  96   __pthread_mutex_unlock (&__pthread_free_threads_lock);
  97
  98   if (new)
  99     {
 100       if (new->tcb)
 101         {
 102           /* Drop old values */
 103           _dl_deallocate_tls (new->tcb, 1);
 104         }
 105
 106       err = initialize_pthread (new);
 107       if (!err)
 108         *pthread = new;
 109       return err;
 110     }
 111
 112   /* Allocate a new thread structure.  */
 113   new = malloc (sizeof (struct __pthread));
 114   if (new == NULL)
 115     return ENOMEM;
 116
 117   err = initialize_pthread (new);
 118   if (err)
 119     {
 120       free (new);
 121       return err;
 122     }
 123
 124 retry:
 125   __libc_rwlock_wrlock (GL (dl_pthread_threads_lock));
 126
 127   if (GL (dl_pthread_num_threads) < __pthread_max_threads)
 128     {
 129       /* We have a free slot.  Use the slot number plus one as the
 130          thread ID for the new thread.  */
 131       new->thread = 1 + GL (dl_pthread_num_threads)++;
 132       GL (dl_pthread_threads)[new->thread - 1] = NULL;
 133
 134       __libc_rwlock_unlock (GL (dl_pthread_threads_lock));
 135
 136       *pthread = new;
 137       return 0;
 138     }
 139 #ifdef PTHREAD_THREADS_MAX
 140   else if (GL (dl_pthread_num_threads) >= PTHREAD_THREADS_MAX)
 141     {
 142       /* We have reached the limit on the number of threads per process.  */
 143       __libc_rwlock_unlock (GL (dl_pthread_threads_lock));
 144
 145       free (new);
 146       return EAGAIN;
 147     }
 148 #endif
 149
 150   /* We are going to enlarge the threads table.  Save its current
 151      size.  We're going to release the lock before doing the necessary
 152      memory allocation, since that's a potentially blocking operation.  */
 153   max_threads = __pthread_max_threads;
 154
 155   __libc_rwlock_unlock (GL (dl_pthread_threads_lock));
 156
 157   /* Allocate a new lookup table that's twice as large.  */
 158   new_max_threads
 159       = max_threads > 0 ? max_threads * 2 : _POSIX_THREAD_THREADS_MAX;
 160   threads = malloc (new_max_threads * sizeof (struct __pthread *));
 161   if (threads == NULL)
 162     {
 163       free (new);
 164       return ENOMEM;
 165     }
 166
 167   __libc_rwlock_wrlock (GL (dl_pthread_threads_lock));
 168
 169   /* Check if nobody else has already enlarged the table.  */
 170   if (max_threads != __pthread_max_threads)
 171     {
 172       /* Yep, they did.  */
 173       __libc_rwlock_unlock (GL (dl_pthread_threads_lock));
 174
 175       /* Free the newly allocated table and try again to allocate a slot.  */
 176       free (threads);
 177       goto retry;
 178     }
 179
 180   /* Copy over the contents of the old table.  */
 181   memcpy (threads, GL (dl_pthread_threads),
 182           __pthread_max_threads * sizeof (struct __pthread *));
 183
 184   /* Save the location of the old table.  We want to deallocate its
 185      storage after we released the lock.  */
 186   old_threads = GL (dl_pthread_threads);
 187
 188   /* Replace the table with the new one.  */
 189   __pthread_max_threads = new_max_threads;
 190   GL (dl_pthread_threads) = threads;
 191
 192   /* And allocate ourselves one of the newly created slots.  */
 193   new->thread = 1 + GL (dl_pthread_num_threads)++;
 194   GL (dl_pthread_threads)[new->thread - 1] = NULL;
 195
 196   __libc_rwlock_unlock (GL (dl_pthread_threads_lock));
 197
 198   free (old_threads);
 199
 200   *pthread = new;
 201   return 0;
 202 }
 203
 204 void
 205 attribute_hidden
 206 __pthread_init_static_tls (struct link_map *map)
 207 {
 208   int i;
 209
 210   __libc_rwlock_wrlock (GL (dl_pthread_threads_lock));
 211   for (i = 0; i < GL (dl_pthread_num_threads); ++i)
 212     {
 213       struct __pthread *t = GL (dl_pthread_threads)[i];
 214
 215       if (t == NULL)
 216         continue;
 217
 218 # if TLS_TCB_AT_TP
 219       void *dest = (char *) t->tcb - map->l_tls_offset;
 220 # elif TLS_DTV_AT_TP
 221       void *dest = (char *) t->tcb + map->l_tls_offset + TLS_PRE_TCB_SIZE;
 222 # else
 223 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 224 # endif
 225
 226       /* Initialize the memory.  */
 227       memset (__mempcpy (dest, map->l_tls_initimage, map->l_tls_initimage_size),
 228               '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
 229     }
 230   __libc_rwlock_unlock (GL (dl_pthread_threads_lock));
 231 }