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