(allocate_stack): Set reported_guardsize unconditionally.
[kopensolaris-gnu/glibc.git] / 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 }