nptl/allocatestack.c

   1 /* Copyright (C) 2002, 2003, 2004 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 <assert.h>
  21 #include <errno.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <sys/mman.h>
  26 #include <sys/param.h>
  27 #include <dl-sysdep.h>
  28 #include <tls.h>
  29
  30
  31
  32 #ifndef NEED_SEPARATE_REGISTER_STACK
  33
  34 /* Most architectures have exactly one stack pointer.  Some have more.  */
  35 # define STACK_VARIABLES void *stackaddr
  36
  37 /* How to pass the values to the 'create_thread' function.  */
  38 # define STACK_VARIABLES_ARGS stackaddr
  39
  40 /* How to declare function which gets there parameters.  */
  41 # define STACK_VARIABLES_PARMS void *stackaddr
  42
  43 /* How to declare allocate_stack.  */
  44 # define ALLOCATE_STACK_PARMS void **stack
  45
  46 /* This is how the function is called.  We do it this way to allow
  47    other variants of the function to have more parameters.  */
  48 # define ALLOCATE_STACK(attr, pd) allocate_stack (attr, pd, &stackaddr)
  49
  50 #else
  51
  52 /* We need two stacks.  The kernel will place them but we have to tell
  53    the kernel about the size of the reserved address space.  */
  54 # define STACK_VARIABLES void *stackaddr; size_t stacksize
  55
  56 /* How to pass the values to the 'create_thread' function.  */
  57 # define STACK_VARIABLES_ARGS stackaddr, stacksize
  58
  59 /* How to declare function which gets there parameters.  */
  60 # define STACK_VARIABLES_PARMS void *stackaddr, size_t stacksize
  61
  62 /* How to declare allocate_stack.  */
  63 # define ALLOCATE_STACK_PARMS void **stack, size_t *stacksize
  64
  65 /* This is how the function is called.  We do it this way to allow
  66    other variants of the function to have more parameters.  */
  67 # define ALLOCATE_STACK(attr, pd) \
  68   allocate_stack (attr, pd, &stackaddr, &stacksize)
  69
  70 #endif
  71
  72
  73 /* Default alignment of stack.  */
  74 #ifndef STACK_ALIGN
  75 # define STACK_ALIGN __alignof__ (long double)
  76 #endif
  77
  78 /* Default value for minimal stack size after allocating thread
  79    descriptor and guard.  */
  80 #ifndef MINIMAL_REST_STACK
  81 # define MINIMAL_REST_STACK     4096
  82 #endif
  83
  84
  85 /* Let the architecture add some flags to the mmap() call used to
  86    allocate stacks.  */
  87 #ifndef ARCH_MAP_FLAGS
  88 # define ARCH_MAP_FLAGS 0
  89 #endif
  90
  91 /* This yields the pointer that TLS support code calls the thread pointer.  */
  92 #if TLS_TCB_AT_TP
  93 # define TLS_TPADJ(pd) (pd)
  94 #elif TLS_DTV_AT_TP
  95 # define TLS_TPADJ(pd) ((struct pthread *)((char *) (pd) + TLS_PRE_TCB_SIZE))
  96 #endif
  97
  98 /* Cache handling for not-yet free stacks.  */
  99
 100 /* Maximum size in kB of cache.  */
 101 static size_t stack_cache_maxsize = 40 * 1024 * 1024; /* 40MiBi by default.  */
 102 static size_t stack_cache_actsize;
 103
 104 /* Mutex protecting this variable.  */
 105 static lll_lock_t stack_cache_lock = LLL_LOCK_INITIALIZER;
 106
 107 /* List of queued stack frames.  */
 108 static LIST_HEAD (stack_cache);
 109
 110 /* List of the stacks in use.  */
 111 static LIST_HEAD (stack_used);
 112
 113 /* List of the threads with user provided stacks in use.  No need to
 114    initialize this, since it's done in __pthread_initialize_minimal.  */
 115 list_t __stack_user __attribute__ ((nocommon));
 116 hidden_data_def (__stack_user)
 117
 118 #if COLORING_INCREMENT != 0
 119 /* Number of threads created.  */
 120 static unsigned int nptl_ncreated;
 121 #endif
 122
 123
 124 /* Check whether the stack is still used or not.  */
 125 #define FREE_P(descr) ((descr)->tid <= 0)
 126
 127
 128 /* We create a double linked list of all cache entries.  Double linked
 129    because this allows removing entries from the end.  */
 130
 131
 132 /* Get a stack frame from the cache.  We have to match by size since
 133    some blocks might be too small or far too large.  */
 134 static struct pthread *
 135 get_cached_stack (size_t *sizep, void **memp)
 136 {
 137   size_t size = *sizep;
 138   struct pthread *result = NULL;
 139   list_t *entry;
 140
 141   lll_lock (stack_cache_lock);
 142
 143   /* Search the cache for a matching entry.  We search for the
 144      smallest stack which has at least the required size.  Note that
 145      in normal situations the size of all allocated stacks is the
 146      same.  As the very least there are only a few different sizes.
 147      Therefore this loop will exit early most of the time with an
 148      exact match.  */
 149   list_for_each (entry, &stack_cache)
 150     {
 151       struct pthread *curr;
 152
 153       curr = list_entry (entry, struct pthread, list);
 154       if (FREE_P (curr) && curr->stackblock_size >= size)
 155         {
 156           if (curr->stackblock_size == size)
 157             {
 158               result = curr;
 159               break;
 160             }
 161
 162           if (result == NULL
 163               || result->stackblock_size > curr->stackblock_size)
 164             result = curr;
 165         }
 166     }
 167
 168   if (__builtin_expect (result == NULL, 0)
 169       /* Make sure the size difference is not too excessive.  In that
 170          case we do not use the block.  */
 171       || __builtin_expect (result->stackblock_size > 4 * size, 0))
 172     {
 173       /* Release the lock.  */
 174       lll_unlock (stack_cache_lock);
 175
 176       return NULL;
 177     }
 178
 179   /* Dequeue the entry.  */
 180   list_del (&result->list);
 181
 182   /* And add to the list of stacks in use.  */
 183   list_add (&result->list, &stack_used);
 184
 185   /* And decrease the cache size.  */
 186   stack_cache_actsize -= result->stackblock_size;
 187
 188   /* Release the lock early.  */
 189   lll_unlock (stack_cache_lock);
 190
 191   /* Report size and location of the stack to the caller.  */
 192   *sizep = result->stackblock_size;
 193   *memp = result->stackblock;
 194
 195   /* Cancellation handling is back to the default.  */
 196   result->cancelhandling = 0;
 197   result->cleanup = NULL;
 198
 199   /* No pending event.  */
 200   result->nextevent = NULL;
 201
 202   /* Clear the DTV.  */
 203   dtv_t *dtv = GET_DTV (TLS_TPADJ (result));
 204   memset (dtv, '\0', (dtv[-1].counter + 1) * sizeof (dtv_t));
 205
 206   /* Re-initialize the TLS.  */
 207   _dl_allocate_tls_init (TLS_TPADJ (result));
 208
 209   return result;
 210 }
 211
 212
 213 /* Add a stack frame which is not used anymore to the stack.  Must be
 214    called with the cache lock held.  */
 215 static inline void
 216 __attribute ((always_inline))
 217 queue_stack (struct pthread *stack)
 218 {
 219   /* We unconditionally add the stack to the list.  The memory may
 220      still be in use but it will not be reused until the kernel marks
 221      the stack as not used anymore.  */
 222   list_add (&stack->list, &stack_cache);
 223
 224   stack_cache_actsize += stack->stackblock_size;
 225   if (__builtin_expect (stack_cache_actsize > stack_cache_maxsize, 0))
 226     {
 227       /* We reduce the size of the cache.  Remove the last entries
 228          until the size is below the limit.  */
 229       list_t *entry;
 230       list_t *prev;
 231
 232       /* Search from the end of the list.  */
 233       list_for_each_prev_safe (entry, prev, &stack_cache)
 234         {
 235           struct pthread *curr;
 236
 237           curr = list_entry (entry, struct pthread, list);
 238           if (FREE_P (curr))
 239             {
 240               /* Unlink the block.  */
 241               list_del (entry);
 242
 243               /* Account for the freed memory.  */
 244               stack_cache_actsize -= curr->stackblock_size;
 245
 246               /* Free the memory associated with the ELF TLS.  */
 247               _dl_deallocate_tls (TLS_TPADJ (curr), false);
 248
 249               /* Remove this block.  This should never fail.  If it
 250                  does something is really wrong.  */
 251               if (munmap (curr->stackblock, curr->stackblock_size) != 0)
 252                 abort ();
 253
 254               /* Maybe we have freed enough.  */
 255               if (stack_cache_actsize <= stack_cache_maxsize)
 256                 break;
 257             }
 258         }
 259     }
 260 }
 261
 262
 263 static int
 264 internal_function
 265 change_stack_perm (struct pthread *pd
 266 #ifdef NEED_SEPARATE_REGISTER_STACK
 267                    , size_t pagemask
 268 #endif
 269                    )
 270 {
 271 #ifdef NEED_SEPARATE_REGISTER_STACK
 272   void *stack = (pd->stackblock
 273                  + (((((pd->stackblock_size - pd->guardsize) / 2)
 274                       & pagemask) + pd->guardsize) & pagemask));
 275   size_t len = pd->stackblock + pd->stackblock_size - stack;
 276 #else
 277   void *stack = pd->stackblock + pd->guardsize;
 278   size_t len = pd->stackblock_size - pd->guardsize;
 279 #endif
 280   if (mprotect (stack, len, PROT_READ | PROT_WRITE | PROT_EXEC) != 0)
 281     return errno;
 282
 283   return 0;
 284 }
 285
 286
 287 static int
 288 allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
 289                 ALLOCATE_STACK_PARMS)
 290 {
 291   struct pthread *pd;
 292   size_t size;
 293   size_t pagesize_m1 = __getpagesize () - 1;
 294   void *stacktop;
 295
 296   assert (attr != NULL);
 297   assert (powerof2 (pagesize_m1 + 1));
 298   assert (TCB_ALIGNMENT >= STACK_ALIGN);
 299
 300   /* Get the stack size from the attribute if it is set.  Otherwise we
 301      use the default we determined at start time.  */
 302   size = attr->stacksize ?: __default_stacksize;
 303
 304   /* Get memory for the stack.  */
 305   if (__builtin_expect (attr->flags & ATTR_FLAG_STACKADDR, 0))
 306     {
 307       uintptr_t adj;
 308
 309       /* If the user also specified the size of the stack make sure it
 310          is large enough.  */
 311       if (attr->stacksize != 0
 312           && attr->stacksize < (__static_tls_size + MINIMAL_REST_STACK))
 313         return EINVAL;
 314
 315       /* Adjust stack size for alignment of the TLS block.  */
 316 #if TLS_TCB_AT_TP
 317       adj = ((uintptr_t) attr->stackaddr - TLS_TCB_SIZE)
 318             & __static_tls_align_m1;
 319       assert (size > adj + TLS_TCB_SIZE);
 320 #elif TLS_DTV_AT_TP
 321       adj = ((uintptr_t) attr->stackaddr - __static_tls_size)
 322             & __static_tls_align_m1;
 323       assert (size > adj);
 324 #endif
 325
 326       /* The user provided some memory.  Let's hope it matches the
 327          size...  We do not allocate guard pages if the user provided
 328          the stack.  It is the user's responsibility to do this if it
 329          is wanted.  */
 330 #if TLS_TCB_AT_TP
 331       pd = (struct pthread *) ((uintptr_t) attr->stackaddr
 332                                - TLS_TCB_SIZE - adj);
 333 #elif TLS_DTV_AT_TP
 334       pd = (struct pthread *) (((uintptr_t) attr->stackaddr
 335                                 - __static_tls_size - adj)
 336                                - TLS_PRE_TCB_SIZE);
 337 #endif
 338
 339       /* The user provided stack memory needs to be cleared.  */
 340       memset (pd, '\0', sizeof (struct pthread));
 341
 342       /* The first TSD block is included in the TCB.  */
 343       pd->specific[0] = pd->specific_1stblock;
 344
 345 #if defined __ASSUME_CLONE_STOPPED && LLL_LOCK_INITIALIZER != 0
 346       /* Initialize the lock.  */
 347       pd->lock = LLL_LOCK_INITIALIZER;
 348 #endif
 349
 350       /* Remember the stack-related values.  */
 351       pd->stackblock = (char *) attr->stackaddr - size;
 352       pd->stackblock_size = size;
 353
 354       /* This is a user-provided stack.  It will not be queued in the
 355          stack cache nor will the memory (except the TLS memory) be freed.  */
 356       pd->user_stack = true;
 357
 358       /* This is at least the second thread.  */
 359       pd->header.multiple_threads = 1;
 360 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
 361       __pthread_multiple_threads = *__libc_multiple_threads_ptr = 1;
 362 #endif
 363
 364 #ifdef NEED_DL_SYSINFO
 365       /* Copy the sysinfo value from the parent.  */
 366       THREAD_SYSINFO(pd) = THREAD_SELF_SYSINFO;
 367 #endif
 368
 369       /* The process ID is also the same as that of the caller.  */
 370       pd->pid = THREAD_GETMEM (THREAD_SELF, pid);
 371
 372       /* Allocate the DTV for this thread.  */
 373       if (_dl_allocate_tls (TLS_TPADJ (pd)) == NULL)
 374         /* Something went wrong.  */
 375         return errno;
 376
 377
 378       /* Prepare to modify global data.  */
 379       lll_lock (stack_cache_lock);
 380
 381       /* And add to the list of stacks in use.  */
 382       list_add (&pd->list, &__stack_user);
 383
 384       lll_unlock (stack_cache_lock);
 385     }
 386   else
 387     {
 388       /* Allocate some anonymous memory.  If possible use the cache.  */
 389       size_t guardsize;
 390       size_t reqsize;
 391       void *mem;
 392       const int prot = (PROT_READ | PROT_WRITE
 393                         | ((GL(dl_stack_flags) & PF_X) ? PROT_EXEC : 0));
 394
 395 #if COLORING_INCREMENT != 0
 396       /* Add one more page for stack coloring.  Don't do it for stacks
 397          with 16 times pagesize or larger.  This might just cause
 398          unnecessary misalignment.  */
 399       if (size <= 16 * pagesize_m1)
 400         size += pagesize_m1 + 1;
 401 #endif
 402
 403       /* Adjust the stack size for alignment.  */
 404       size &= ~__static_tls_align_m1;
 405       assert (size != 0);
 406
 407       /* Make sure the size of the stack is enough for the guard and
 408          eventually the thread descriptor.  */
 409       guardsize = (attr->guardsize + pagesize_m1) & ~pagesize_m1;
 410       if (__builtin_expect (size < (guardsize + __static_tls_size
 411                                     + MINIMAL_REST_STACK + pagesize_m1 + 1),
 412                             0))
 413         /* The stack is too small (or the guard too large).  */
 414         return EINVAL;
 415
 416       /* Try to get a stack from the cache.  */
 417       reqsize = size;
 418       pd = get_cached_stack (&size, &mem);
 419       if (pd == NULL)
 420         {
 421           /* To avoid aliasing effects on a larger scale then pages we
 422              adjust the allocated stack size if necessary.  This way
 423              allocations directly following each other will not have
 424              aliasing problems.  */
 425 #if MULTI_PAGE_ALIASING != 0
 426           if ((size % MULTI_PAGE_ALIASING) == 0)
 427             size += pagesize_m1 + 1;
 428 #endif
 429
 430           mem = mmap (NULL, size, prot,
 431                       MAP_PRIVATE | MAP_ANONYMOUS | ARCH_MAP_FLAGS, -1, 0);
 432
 433           if (__builtin_expect (mem == MAP_FAILED, 0))
 434             {
 435 #ifdef ARCH_RETRY_MMAP
 436               mem = ARCH_RETRY_MMAP (size);
 437               if (__builtin_expect (mem == MAP_FAILED, 0))
 438 #endif
 439                 return errno;
 440             }
 441
 442           /* SIZE is guaranteed to be greater than zero.
 443              So we can never get a null pointer back from mmap.  */
 444           assert (mem != NULL);
 445
 446 #if COLORING_INCREMENT != 0
 447           /* Atomically increment NCREATED.  */
 448           unsigned int ncreated = (atomic_exchange_and_add (&nptl_ncreated, 1)
 449                                    + 1);
 450
 451           /* We chose the offset for coloring by incrementing it for
 452              every new thread by a fixed amount.  The offset used
 453              module the page size.  Even if coloring would be better
 454              relative to higher alignment values it makes no sense to
 455              do it since the mmap() interface does not allow us to
 456              specify any alignment for the returned memory block.  */
 457           size_t coloring = (ncreated * COLORING_INCREMENT) & pagesize_m1;
 458
 459           /* Make sure the coloring offsets does not disturb the alignment
 460              of the TCB and static TLS block.  */
 461           if (__builtin_expect ((coloring & __static_tls_align_m1) != 0, 0))
 462             coloring = (((coloring + __static_tls_align_m1)
 463                          & ~(__static_tls_align_m1))
 464                         & ~pagesize_m1);
 465 #else
 466           /* Unless specified we do not make any adjustments.  */
 467 # define coloring 0
 468 #endif
 469
 470           /* Place the thread descriptor at the end of the stack.  */
 471 #if TLS_TCB_AT_TP
 472           pd = (struct pthread *) ((char *) mem + size - coloring) - 1;
 473 #elif TLS_DTV_AT_TP
 474           pd = (struct pthread *) ((((uintptr_t) mem + size - coloring
 475                                     - __static_tls_size)
 476                                     & ~__static_tls_align_m1)
 477                                    - TLS_PRE_TCB_SIZE);
 478 #endif
 479
 480           /* Remember the stack-related values.  */
 481           pd->stackblock = mem;
 482           pd->stackblock_size = size;
 483
 484           /* We allocated the first block thread-specific data array.
 485              This address will not change for the lifetime of this
 486              descriptor.  */
 487           pd->specific[0] = pd->specific_1stblock;
 488
 489 #if defined __ASSUME_CLONE_STOPPED && LLL_LOCK_INITIALIZER != 0
 490           /* Initialize the lock.  */
 491           pd->lock = LLL_LOCK_INITIALIZER;
 492 #endif
 493
 494           /* This is at least the second thread.  */
 495           pd->header.multiple_threads = 1;
 496 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
 497           __pthread_multiple_threads = *__libc_multiple_threads_ptr = 1;
 498 #endif
 499
 500 #ifdef NEED_DL_SYSINFO
 501           /* Copy the sysinfo value from the parent.  */
 502           THREAD_SYSINFO(pd) = THREAD_SELF_SYSINFO;
 503 #endif
 504
 505           /* The process ID is also the same as that of the caller.  */
 506           pd->pid = THREAD_GETMEM (THREAD_SELF, pid);
 507
 508           /* Allocate the DTV for this thread.  */
 509           if (_dl_allocate_tls (TLS_TPADJ (pd)) == NULL)
 510             {
 511               /* Something went wrong.  */
 512               int err = errno;
 513
 514               /* Free the stack memory we just allocated.  */
 515               (void) munmap (mem, size);
 516
 517               return err;
 518             }
 519
 520
 521           /* Prepare to modify global data.  */
 522           lll_lock (stack_cache_lock);
 523
 524           /* And add to the list of stacks in use.  */
 525           list_add (&pd->list, &stack_used);
 526
 527           lll_unlock (stack_cache_lock);
 528
 529
 530           /* There might have been a race.  Another thread might have
 531              caused the stacks to get exec permission while this new
 532              stack was prepared.  Detect if this was possible and
 533              change the permission if necessary.  */
 534           if (__builtin_expect ((GL(dl_stack_flags) & PF_X) != 0
 535                                 && (prot & PROT_EXEC) == 0, 0))
 536             {
 537               int err = change_stack_perm (pd
 538 #ifdef NEED_SEPARATE_REGISTER_STACK
 539                                            , ~pagesize_m1
 540 #endif
 541                                            );
 542               if (err != 0)
 543                 {
 544                   /* Free the stack memory we just allocated.  */
 545                   (void) munmap (mem, size);
 546
 547                   return err;
 548                 }
 549             }
 550
 551
 552           /* Note that all of the stack and the thread descriptor is
 553              zeroed.  This means we do not have to initialize fields
 554              with initial value zero.  This is specifically true for
 555              the 'tid' field which is always set back to zero once the
 556              stack is not used anymore and for the 'guardsize' field
 557              which will be read next.  */
 558         }
 559
 560       /* Create or resize the guard area if necessary.  */
 561       if (__builtin_expect (guardsize > pd->guardsize, 0))
 562         {
 563 #ifdef NEED_SEPARATE_REGISTER_STACK
 564           char *guard = mem + (((size - guardsize) / 2) & ~pagesize_m1);
 565 #else
 566           char *guard = mem;
 567 #endif
 568           if (mprotect (guard, guardsize, PROT_NONE) != 0)
 569             {
 570               int err;
 571             mprot_error:
 572               err = errno;
 573
 574               lll_lock (stack_cache_lock);
 575
 576               /* Remove the thread from the list.  */
 577               list_del (&pd->list);
 578
 579               lll_unlock (stack_cache_lock);
 580
 581               /* Get rid of the TLS block we allocated.  */
 582               _dl_deallocate_tls (TLS_TPADJ (pd), false);
 583
 584               /* Free the stack memory regardless of whether the size
 585                  of the cache is over the limit or not.  If this piece
 586                  of memory caused problems we better do not use it
 587                  anymore.  Uh, and we ignore possible errors.  There
 588                  is nothing we could do.  */
 589               (void) munmap (mem, size);
 590
 591               return err;
 592             }
 593
 594           pd->guardsize = guardsize;
 595         }
 596       else if (__builtin_expect (pd->guardsize - guardsize > size - reqsize,
 597                                  0))
 598         {
 599           /* The old guard area is too large.  */
 600
 601 #ifdef NEED_SEPARATE_REGISTER_STACK
 602           char *guard = mem + (((size - guardsize) / 2) & ~pagesize_m1);
 603           char *oldguard = mem + (((size - pd->guardsize) / 2) & ~pagesize_m1);
 604
 605           if (oldguard < guard
 606               && mprotect (oldguard, guard - oldguard, prot) != 0)
 607             goto mprot_error;
 608
 609           if (mprotect (guard + guardsize,
 610                         oldguard + pd->guardsize - guard - guardsize,
 611                         prot) != 0)
 612             goto mprot_error;
 613 #else
 614           if (mprotect ((char *) mem + guardsize, pd->guardsize - guardsize,
 615                         prot) != 0)
 616             goto mprot_error;
 617 #endif
 618
 619           pd->guardsize = guardsize;
 620         }
 621       /* The pthread_getattr_np() calls need to get passed the size
 622          requested in the attribute, regardless of how large the
 623          actually used guardsize is.  */
 624       pd->reported_guardsize = guardsize;
 625     }
 626
 627 #ifndef __ASSUME_CLONE_STOPPED
 628   /* Initialize the lock.  We have to do this unconditionally if the
 629      CLONE_STOPPED flag is not available since then the stillborn
 630      thread could be canceled while the lock is taken.  */
 631   pd->lock = LLL_LOCK_INITIALIZER;
 632 #endif
 633
 634   /* We place the thread descriptor at the end of the stack.  */
 635   *pdp = pd;
 636
 637 #if TLS_TCB_AT_TP
 638   /* The stack begins before the TCB and the static TLS block.  */
 639   stacktop = ((char *) (pd + 1) - __static_tls_size);
 640 #elif TLS_DTV_AT_TP
 641   stacktop = (char *) (pd - 1);
 642 #endif
 643
 644 #ifdef NEED_SEPARATE_REGISTER_STACK
 645   *stack = pd->stackblock;
 646   *stacksize = stacktop - *stack;
 647 #else
 648   *stack = stacktop;
 649 #endif
 650
 651   return 0;
 652 }
 653
 654
 655 void
 656 internal_function
 657 __deallocate_stack (struct pthread *pd)
 658 {
 659   lll_lock (stack_cache_lock);
 660
 661   /* Remove the thread from the list of threads with user defined
 662      stacks.  */
 663   list_del (&pd->list);
 664
 665   /* Not much to do.  Just free the mmap()ed memory.  Note that we do
 666      not reset the 'used' flag in the 'tid' field.  This is done by
 667      the kernel.  If no thread has been created yet this field is
 668      still zero.  */
 669   if (__builtin_expect (! pd->user_stack, 1))
 670     (void) queue_stack (pd);
 671   else
 672     /* Free the memory associated with the ELF TLS.  */
 673     _dl_deallocate_tls (TLS_TPADJ (pd), false);
 674
 675   lll_unlock (stack_cache_lock);
 676 }
 677
 678
 679 int
 680 internal_function
 681 __make_stacks_executable (void **stack_endp)
 682 {
 683   /* First the main thread's stack.  */
 684   int err = _dl_make_stack_executable (stack_endp);
 685   if (err != 0)
 686     return err;
 687
 688 #ifdef NEED_SEPARATE_REGISTER_STACK
 689   const size_t pagemask = ~(__getpagesize () - 1);
 690 #endif
 691
 692   lll_lock (stack_cache_lock);
 693
 694   list_t *runp;
 695   list_for_each (runp, &stack_used)
 696     {
 697       err = change_stack_perm (list_entry (runp, struct pthread, list)
 698 #ifdef NEED_SEPARATE_REGISTER_STACK
 699                                , pagemask
 700 #endif
 701                                );
 702       if (err != 0)
 703         break;
 704     }
 705
 706   /* Also change the permission for the currently unused stacks.  This
 707      might be wasted time but better spend it here than adding a check
 708      in the fast path.  */
 709   if (err == 0)
 710     list_for_each (runp, &stack_cache)
 711       {
 712         err = change_stack_perm (list_entry (runp, struct pthread, list)
 713 #ifdef NEED_SEPARATE_REGISTER_STACK
 714                                  , pagemask
 715 #endif
 716                                  );
 717         if (err != 0)
 718           break;
 719       }
 720
 721   lll_unlock (stack_cache_lock);
 722
 723   return err;
 724 }
 725
 726
 727 /* In case of a fork() call the memory allocation in the child will be
 728    the same but only one thread is running.  All stacks except that of
 729    the one running thread are not used anymore.  We have to recycle
 730    them.  */
 731 void
 732 __reclaim_stacks (void)
 733 {
 734   struct pthread *self = (struct pthread *) THREAD_SELF;
 735
 736   /* No locking necessary.  The caller is the only stack in use.  */
 737
 738   /* Mark all stacks except the still running one as free.  */
 739   list_t *runp;
 740   list_for_each (runp, &stack_used)
 741     {
 742       struct pthread *curp;
 743
 744       curp = list_entry (runp, struct pthread, list);
 745       if (curp != self)
 746         {
 747           /* This marks the stack as free.  */
 748           curp->tid = 0;
 749
 750           /* The PID field must be initialized for the new process.  */
 751           curp->pid = self->pid;
 752
 753           /* Account for the size of the stack.  */
 754           stack_cache_actsize += curp->stackblock_size;
 755         }
 756     }
 757
 758   /* Add the stack of all running threads to the cache.  */
 759   list_splice (&stack_used, &stack_cache);
 760
 761   /* Remove the entry for the current thread to from the cache list
 762      and add it to the list of running threads.  Which of the two
 763      lists is decided by the user_stack flag.  */
 764   list_del (&self->list);
 765
 766   /* Re-initialize the lists for all the threads.  */
 767   INIT_LIST_HEAD (&stack_used);
 768   INIT_LIST_HEAD (&__stack_user);
 769
 770   if (__builtin_expect (THREAD_GETMEM (self, user_stack), 0))
 771     list_add (&self->list, &__stack_user);
 772   else
 773     list_add (&self->list, &stack_used);
 774
 775   /* There is one thread running.  */
 776   __nptl_nthreads = 1;
 777
 778   /* Initialize the lock.  */
 779   stack_cache_lock = LLL_LOCK_INITIALIZER;
 780 }
 781
 782
 783 #if HP_TIMING_AVAIL
 784 /* Find a thread given the thread ID.  */
 785 struct pthread *
 786 attribute_hidden
 787 __find_thread_by_id (pid_t tid)
 788 {
 789   struct pthread *result = NULL;
 790
 791   lll_lock (stack_cache_lock);
 792
 793   /* Iterate over the list with system-allocated threads first.  */
 794   list_t *runp;
 795   list_for_each (runp, &stack_used)
 796     {
 797       struct pthread *curp;
 798
 799       curp = list_entry (runp, struct pthread, list);
 800
 801       if (curp->tid == tid)
 802         {
 803           result = curp;
 804           goto out;
 805         }
 806     }
 807
 808   /* Now the list with threads using user-allocated stacks.  */
 809   list_for_each (runp, &__stack_user)
 810     {
 811       struct pthread *curp;
 812
 813       curp = list_entry (runp, struct pthread, list);
 814
 815       if (curp->tid == tid)
 816         {
 817           result = curp;
 818           goto out;
 819         }
 820     }
 821
 822  out:
 823   lll_unlock (stack_cache_lock);
 824
 825   return result;
 826 }
 827 #endif
 828
 829 static inline void __attribute__((always_inline))
 830 init_one_static_tls (struct pthread *curp, struct link_map *map)
 831 {
 832   dtv_t *dtv = GET_DTV (TLS_TPADJ (curp));
 833 # if TLS_TCB_AT_TP
 834   void *dest = (char *) curp - map->l_tls_offset;
 835 # elif TLS_DTV_AT_TP
 836   void *dest = (char *) curp + map->l_tls_offset + TLS_PRE_TCB_SIZE;
 837 # else
 838 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 839 # endif
 840
 841   /* Fill in the DTV slot so that a later LD/GD access will find it.  */
 842   dtv[map->l_tls_modid].pointer = dest;
 843
 844   /* Initialize the memory.  */
 845   memset (__mempcpy (dest, map->l_tls_initimage, map->l_tls_initimage_size),
 846           '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
 847 }
 848
 849 void
 850 attribute_hidden
 851 __pthread_init_static_tls (struct link_map *map)
 852 {
 853   lll_lock (stack_cache_lock);
 854
 855   /* Iterate over the list with system-allocated threads first.  */
 856   list_t *runp;
 857   list_for_each (runp, &stack_used)
 858     init_one_static_tls (list_entry (runp, struct pthread, list), map);
 859
 860   /* Now the list with threads using user-allocated stacks.  */
 861   list_for_each (runp, &__stack_user)
 862     init_one_static_tls (list_entry (runp, struct pthread, list), map);
 863
 864   lll_unlock (stack_cache_lock);
 865 }