4b5af82f06100d8b3ae6e347fa4f466055707afb
[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     }
622
623 #ifndef __ASSUME_CLONE_STOPPED
624   /* Initialize the lock.  We have to do this unconditionally if the
625      CLONE_STOPPED flag is not available since then the stillborn
626      thread could be canceled while the lock is taken.  */
627   pd->lock = LLL_LOCK_INITIALIZER;
628 #endif
629
630   /* We place the thread descriptor at the end of the stack.  */
631   *pdp = pd;
632
633 #if TLS_TCB_AT_TP
634   /* The stack begins before the TCB and the static TLS block.  */
635   stacktop = ((char *) (pd + 1) - __static_tls_size);
636 #elif TLS_DTV_AT_TP
637   stacktop = (char *) (pd - 1);
638 #endif
639
640 #ifdef NEED_SEPARATE_REGISTER_STACK
641   *stack = pd->stackblock;
642   *stacksize = stacktop - *stack;
643 #else
644   *stack = stacktop;
645 #endif
646
647   return 0;
648 }
649
650
651 void
652 internal_function
653 __deallocate_stack (struct pthread *pd)
654 {
655   lll_lock (stack_cache_lock);
656
657   /* Remove the thread from the list of threads with user defined
658      stacks.  */
659   list_del (&pd->list);
660
661   /* Not much to do.  Just free the mmap()ed memory.  Note that we do
662      not reset the 'used' flag in the 'tid' field.  This is done by
663      the kernel.  If no thread has been created yet this field is
664      still zero.  */
665   if (__builtin_expect (! pd->user_stack, 1))
666     (void) queue_stack (pd);
667   else
668     /* Free the memory associated with the ELF TLS.  */
669     _dl_deallocate_tls (TLS_TPADJ (pd), false);
670
671   lll_unlock (stack_cache_lock);
672 }
673
674
675 int
676 internal_function
677 __make_stacks_executable (void **stack_endp)
678 {
679   /* First the main thread's stack.  */
680   int err = _dl_make_stack_executable (stack_endp);
681   if (err != 0)
682     return err;
683
684 #ifdef NEED_SEPARATE_REGISTER_STACK
685   const size_t pagemask = ~(__getpagesize () - 1);
686 #endif
687
688   lll_lock (stack_cache_lock);
689
690   list_t *runp;
691   list_for_each (runp, &stack_used)
692     {
693       err = change_stack_perm (list_entry (runp, struct pthread, list)
694 #ifdef NEED_SEPARATE_REGISTER_STACK
695                                , pagemask
696 #endif
697                                );
698       if (err != 0)
699         break;
700     }
701
702   /* Also change the permission for the currently unused stacks.  This
703      might be wasted time but better spend it here than adding a check
704      in the fast path.  */
705   if (err == 0)
706     list_for_each (runp, &stack_cache)
707       {
708         err = change_stack_perm (list_entry (runp, struct pthread, list)
709 #ifdef NEED_SEPARATE_REGISTER_STACK
710                                  , pagemask
711 #endif
712                                  );
713         if (err != 0)
714           break;
715       }
716
717   lll_unlock (stack_cache_lock);
718
719   return err;
720 }
721
722
723 /* In case of a fork() call the memory allocation in the child will be
724    the same but only one thread is running.  All stacks except that of
725    the one running thread are not used anymore.  We have to recycle
726    them.  */
727 void
728 __reclaim_stacks (void)
729 {
730   struct pthread *self = (struct pthread *) THREAD_SELF;
731
732   /* No locking necessary.  The caller is the only stack in use.  */
733
734   /* Mark all stacks except the still running one as free.  */
735   list_t *runp;
736   list_for_each (runp, &stack_used)
737     {
738       struct pthread *curp;
739
740       curp = list_entry (runp, struct pthread, list);
741       if (curp != self)
742         {
743           /* This marks the stack as free.  */
744           curp->tid = 0;
745
746           /* The PID field must be initialized for the new process.  */
747           curp->pid = self->pid;
748
749           /* Account for the size of the stack.  */
750           stack_cache_actsize += curp->stackblock_size;
751         }
752     }
753
754   /* Add the stack of all running threads to the cache.  */
755   list_splice (&stack_used, &stack_cache);
756
757   /* Remove the entry for the current thread to from the cache list
758      and add it to the list of running threads.  Which of the two
759      lists is decided by the user_stack flag.  */
760   list_del (&self->list);
761
762   /* Re-initialize the lists for all the threads.  */
763   INIT_LIST_HEAD (&stack_used);
764   INIT_LIST_HEAD (&__stack_user);
765
766   if (__builtin_expect (THREAD_GETMEM (self, user_stack), 0))
767     list_add (&self->list, &__stack_user);
768   else
769     list_add (&self->list, &stack_used);
770
771   /* There is one thread running.  */
772   __nptl_nthreads = 1;
773
774   /* Initialize the lock.  */
775   stack_cache_lock = LLL_LOCK_INITIALIZER;
776 }
777
778
779 #if HP_TIMING_AVAIL
780 /* Find a thread given the thread ID.  */
781 struct pthread *
782 attribute_hidden
783 __find_thread_by_id (pid_t tid)
784 {
785   struct pthread *result = NULL;
786
787   lll_lock (stack_cache_lock);
788
789   /* Iterate over the list with system-allocated threads first.  */
790   list_t *runp;
791   list_for_each (runp, &stack_used)
792     {
793       struct pthread *curp;
794
795       curp = list_entry (runp, struct pthread, list);
796
797       if (curp->tid == tid)
798         {
799           result = curp;
800           goto out;
801         }
802     }
803
804   /* Now the list with threads using user-allocated stacks.  */
805   list_for_each (runp, &__stack_user)
806     {
807       struct pthread *curp;
808
809       curp = list_entry (runp, struct pthread, list);
810
811       if (curp->tid == tid)
812         {
813           result = curp;
814           goto out;
815         }
816     }
817
818  out:
819   lll_unlock (stack_cache_lock);
820
821   return result;
822 }
823 #endif
824
825 static inline void __attribute__((always_inline))
826 init_one_static_tls (struct pthread *curp, struct link_map *map)
827 {
828   dtv_t *dtv = GET_DTV (TLS_TPADJ (curp));
829 # if TLS_TCB_AT_TP
830   void *dest = (char *) curp - map->l_tls_offset;
831 # elif TLS_DTV_AT_TP
832   void *dest = (char *) curp + map->l_tls_offset + TLS_PRE_TCB_SIZE;
833 # else
834 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
835 # endif
836
837   /* Fill in the DTV slot so that a later LD/GD access will find it.  */
838   dtv[map->l_tls_modid].pointer = dest;
839
840   /* Initialize the memory.  */
841   memset (__mempcpy (dest, map->l_tls_initimage, map->l_tls_initimage_size),
842           '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
843 }
844
845 void
846 attribute_hidden
847 __pthread_init_static_tls (struct link_map *map)
848 {
849   lll_lock (stack_cache_lock);
850
851   /* Iterate over the list with system-allocated threads first.  */
852   list_t *runp;
853   list_for_each (runp, &stack_used)
854     init_one_static_tls (list_entry (runp, struct pthread, list), map);
855
856   /* Now the list with threads using user-allocated stacks.  */
857   list_for_each (runp, &__stack_user)
858     init_one_static_tls (list_entry (runp, struct pthread, list), map);
859
860   lll_unlock (stack_cache_lock);
861 }