2002-08-04 Roland McGrath <roland@redhat.com>
[kopensolaris-gnu/glibc.git] / sysdeps / generic / dl-tls.c
1 /* Thread-local storage handling in the ELF dynamic linker.  Generic version.
2    Copyright (C) 2002 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, 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 <signal.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24 #include <sys/param.h>
25
26 #include <tls.h>
27
28 /* We don't need any of this if TLS is not supported.  */
29 #ifdef USE_TLS
30
31 # include <dl-tls.h>
32 # include <ldsodefs.h>
33
34 /* Value used for dtv entries for which the allocation is delayed.  */
35 # define TLS_DTV_UNALLOCATED    ((void *) -1l)
36
37
38 /* Out-of-memory handler.  */
39 # ifdef SHARED
40 static void
41 __attribute__ ((__noreturn__))
42 oom (void)
43 {
44   _dl_fatal_printf ("cannot allocate memory for thread-local data: ABORT\n");
45 }
46 # endif
47
48
49
50 size_t
51 internal_function
52 _dl_next_tls_modid (void)
53 {
54   size_t result;
55
56   if (__builtin_expect (GL(dl_tls_dtv_gaps), false))
57     {
58       size_t disp = 0;
59       struct dtv_slotinfo_list *runp = GL(dl_tls_dtv_slotinfo_list);
60
61       /* Note that this branch will never be executed during program
62          start since there are no gaps at that time.  Therefore it
63          does not matter that the dl_tls_dtv_slotinfo is not allocated
64          yet when the function is called for the first times.  */
65       result = GL(dl_tls_static_nelem) + 1;
66       /* If the following would not be true we mustn't have assumed
67          there is a gap.  */
68       assert (result <= GL(dl_tls_max_dtv_idx));
69       do
70         {
71           while (result - disp < runp->len)
72             {
73               if (runp->slotinfo[result - disp].map == NULL)
74                 break;
75
76               ++result;
77               assert (result <= GL(dl_tls_max_dtv_idx) + 1);
78             }
79
80           if (result - disp < runp->len)
81             break;
82
83           disp += runp->len;
84         }
85       while ((runp = runp->next) != NULL);
86
87       if (result >= GL(dl_tls_max_dtv_idx))
88         {
89           /* The new index must indeed be exactly one higher than the
90              previous high.  */
91           assert (result == GL(dl_tls_max_dtv_idx));
92
93           /* There is no gap anymore.  */
94           GL(dl_tls_dtv_gaps) = false;
95
96           goto nogaps;
97         }
98     }
99   else
100     {
101       /* No gaps, allocate a new entry.  */
102     nogaps:
103       result = ++GL(dl_tls_max_dtv_idx);
104     }
105
106   return result;
107 }
108
109
110 void
111 internal_function
112 _dl_determine_tlsoffset (void)
113 {
114   struct dtv_slotinfo *slotinfo;
115   size_t max_align = __alignof__ (void *);
116   size_t offset;
117   size_t cnt;
118
119   /* The first element of the dtv slot info list is allocated.  */
120   assert (GL(dl_tls_dtv_slotinfo_list) != NULL);
121   /* There is at this point only one element in the
122      dl_tls_dtv_slotinfo_list list.  */
123   assert (GL(dl_tls_dtv_slotinfo_list)->next == NULL);
124
125 # if TLS_TCB_AT_TP
126   /* We simply start with zero.  */
127   offset = 0;
128
129   slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
130   for (cnt = 1; slotinfo[cnt].map != NULL; ++cnt)
131     {
132       assert (cnt < GL(dl_tls_dtv_slotinfo_list)->len);
133
134       max_align = MAX (max_align, slotinfo[cnt].map->l_tls_align);
135
136       /* Compute the offset of the next TLS block.  */
137       offset = roundup (offset + slotinfo[cnt].map->l_tls_blocksize,
138                         slotinfo[cnt].map->l_tls_align);
139
140       /* XXX For some architectures we perhaps should store the
141          negative offset.  */
142       slotinfo[cnt].map->l_tls_offset = offset;
143     }
144
145   /* The thread descriptor (pointed to by the thread pointer) has its
146      own alignment requirement.  Adjust the static TLS size
147      and TLS offsets appropriately.  */
148   // XXX How to deal with this.  We cannot simply add zero bytes
149   // XXX after the first (closest to the TCB) TLS block since this
150   // XXX would invalidate the offsets the linker creates for the LE
151   // XXX model.
152
153   GL(dl_tls_static_size) = offset + TLS_TCB_SIZE;
154 # elif TLS_DTV_AT_TP
155   /* The TLS blocks start right after the TCB.  */
156   offset = TLS_TCB_SIZE;
157
158   /* The first block starts right after the TCB.  */
159   slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
160   if (slotinfo[1].map != NULL)
161     {
162       size_t prev_size;
163
164       offset = roundup (offset, slotinfo[1].map->l_tls_align);
165       slotinfo[1].map->l_tls_offset = offset;
166       max_align = slotinfo[1].map->l_tls_align;
167       prev_size = slotinfo[1].map->l_tls_blocksize;
168
169       for (cnt = 2; slotinfo[cnt].map != NULL; ++cnt)
170         {
171           assert (cnt < GL(dl_tls_dtv_slotinfo_list)->len);
172
173           max_align = MAX (max_align, slotinfo[cnt].map->l_tls_align);
174
175           /* Compute the offset of the next TLS block.  */
176           offset = roundup (offset + prev_size,
177                             slotinfo[cnt].map->l_tls_align);
178
179           /* XXX For some architectures we perhaps should store the
180              negative offset.  */
181           slotinfo[cnt].map->l_tls_offset = offset;
182
183           prev_size = slotinfo[cnt].map->l_tls_blocksize;
184         }
185
186       offset += prev_size;
187     }
188
189   GL(dl_tls_static_size) = offset;
190 # else
191 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
192 # endif
193
194   /* The alignment requirement for the static TLS block.  */
195   GL(dl_tls_static_align) = MAX (TLS_TCB_ALIGN, max_align);
196 }
197
198
199 void *
200 internal_function
201 _dl_allocate_tls_storage (void)
202 {
203   void *result;
204   dtv_t *dtv;
205   size_t dtv_length;
206
207   /* Allocate a correctly aligned chunk of memory.  */
208   /* XXX For now */
209   assert (GL(dl_tls_static_align) <= GL(dl_pagesize));
210 # ifdef MAP_ANON
211 #  define _dl_zerofd (-1)
212 # else
213 #  define _dl_zerofd GL(dl_zerofd)
214   if ((dl_zerofd) == -1)
215     GL(dl_zerofd) = _dl_sysdep_open_zero_fill ();
216 #  define MAP_ANON 0
217 # endif
218   result = __mmap (0, GL(dl_tls_static_size) ?: 1, PROT_READ|PROT_WRITE,
219                    MAP_ANON|MAP_PRIVATE, _dl_zerofd, 0);
220
221   /* We allocate a few more elements in the dtv than are needed for the
222      initial set of modules.  This should avoid in most cases expansions
223      of the dtv.  */
224   dtv_length = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS;
225   dtv = (dtv_t *) malloc ((dtv_length + 2) * sizeof (dtv_t));
226   if (result != MAP_FAILED && dtv != NULL)
227     {
228 # if TLS_TCB_AT_TP
229       /* The TCB follows the TLS blocks.  */
230       result = (char *) result + GL(dl_tls_static_size) - TLS_TCB_SIZE;
231 # endif
232
233       /* This is the initial length of the dtv.  */
234       dtv[0].counter = dtv_length;
235       /* Fill in the generation number.  */
236       dtv[1].counter = GL(dl_tls_generation) = 0;
237       /* Initialize all of the rest of the dtv with zero to indicate
238          nothing there.  */
239       memset (dtv + 2, '\0', dtv_length * sizeof (dtv_t));
240
241       /* Add the dtv to the thread data structures.  */
242       INSTALL_DTV (result, dtv);
243     }
244   else if (result != NULL)
245     {
246       free (result);
247       result = NULL;
248     }
249
250   return result;
251 }
252 INTDEF(_dl_allocate_tls)
253
254 void *
255 internal_function
256 _dl_allocate_tls_init (void *result)
257 {
258   dtv_t *dtv = GET_DTV (result);
259   struct dtv_slotinfo_list *listp;
260   bool first_block = true;
261   size_t total = 0;
262
263   /* We have to look prepare the dtv for all currently loaded
264      modules using TLS.  For those which are dynamically loaded we
265      add the values indicating deferred allocation.  */
266   listp = GL(dl_tls_dtv_slotinfo_list);
267   while (1)
268     {
269       size_t cnt;
270
271       for (cnt = first_block ? 1 : 0; cnt < listp->len; ++cnt)
272         {
273           struct link_map *map;
274           void *dest;
275
276           /* Check for the total number of used slots.  */
277           if (total + cnt > GL(dl_tls_max_dtv_idx))
278             break;
279
280           map = listp->slotinfo[cnt].map;
281           if (map == NULL)
282             /* Unused entry.  */
283             continue;
284
285           if (map->l_type == lt_loaded)
286             {
287               /* For dynamically loaded modules we simply store
288                  the value indicating deferred allocation.  */
289               dtv[map->l_tls_modid].pointer = TLS_DTV_UNALLOCATED;
290               continue;
291             }
292
293           assert (map->l_tls_modid == cnt);
294           assert (map->l_tls_blocksize >= map->l_tls_initimage_size);
295 # if TLS_TCB_AT_TP
296           assert (map->l_tls_offset >= map->l_tls_blocksize);
297           dest = (char *) result - map->l_tls_offset;
298 # elif TLS_DTV_AT_TP
299           dest = (char *) result + map->l_tls_offset;
300 # else
301 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
302 # endif
303
304           /* We don't have to clear the BSS part of the TLS block
305              since mmap is used to allocate the memory which
306              guarantees it is initialized to zero.  */
307           dtv[cnt].pointer = memcpy (dest, map->l_tls_initimage,
308                                      map->l_tls_initimage_size);
309         }
310
311       total += cnt;
312       if (total > GL(dl_tls_max_dtv_idx))
313         break;
314
315       listp = listp->next;
316       assert (listp != NULL);
317     }
318
319   return result;
320 }
321
322 void *
323 internal_function
324 _dl_allocate_tls (void)
325 {
326   return _dl_allocate_tls_init (_dl_allocate_tls_storage ());
327 }
328
329 void
330 internal_function
331 _dl_deallocate_tls (void *tcb)
332 {
333   dtv_t *dtv = GET_DTV (tcb);
334
335   /* The array starts with dtv[-1].  */
336   free (dtv - 1);
337
338   munmap (tcb, GL(dl_tls_static_size));
339 }
340
341
342
343 # ifdef SHARED
344 /* The __tls_get_addr function has two basic forms which differ in the
345    arguments.  The IA-64 form takes two parameters, the module ID and
346    offset.  The form used, among others, on IA-32 takes a reference to
347    a special structure which contain the same information.  The second
348    form seems to be more often used (in the moment) so we default to
349    it.  Users of the IA-64 form have to provide adequate definitions
350    of the following macros.  */
351 #  ifndef GET_ADDR_ARGS
352 #   define GET_ADDR_ARGS tls_index *ti
353 #  endif
354 #  ifndef GET_ADDR_MODULE
355 #   define GET_ADDR_MODULE ti->ti_module
356 #  endif
357 #  ifndef GET_ADDR_OFFSET
358 #   define GET_ADDR_OFFSET ti->ti_offset
359 #  endif
360 /* Systems which do not have tls_index also probably have to define
361    DONT_USE_TLS_INDEX.  */
362
363 #  ifndef __TLS_GET_ADDR
364 #   define __TLS_GET_ADDR __tls_get_addr
365 #  endif
366
367
368 /* Return the symbol address given the map of the module it is in and
369    the symbol record.  This is used in dl-sym.c.  */
370 void *
371 internal_function
372 _dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
373 {
374 #  ifndef DONT_USE_TLS_INDEX
375   tls_index tmp =
376     {
377       .ti_module = map->l_tls_modid,
378       .ti_offset = ref->st_value
379     };
380
381   return __TLS_GET_ADDR (&tmp);
382 #  else
383   return __TLS_GET_ADDR (map->l_tls_modid, ref->st_value);
384 #  endif
385 }
386
387
388 static void *
389 allocate_and_init (struct link_map *map)
390 {
391   void *newp;
392
393   newp = __libc_memalign (map->l_tls_align, map->l_tls_blocksize);
394   if (newp == NULL)
395     oom ();
396
397   /* Initialize the memory.  */
398   memset (__mempcpy (newp, map->l_tls_initimage, map->l_tls_initimage_size),
399           '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
400
401   return newp;
402 }
403
404
405 /* The generic dynamic and local dynamic model cannot be used in
406    statically linked applications.  */
407 void *
408 __tls_get_addr (GET_ADDR_ARGS)
409 {
410   dtv_t *dtv = THREAD_DTV ();
411   struct link_map *the_map = NULL;
412   void *p;
413
414   if (__builtin_expect (dtv[0].counter != GL(dl_tls_generation), 0))
415     {
416       struct dtv_slotinfo_list *listp;
417       size_t idx;
418
419       /* The global dl_tls_dtv_slotinfo array contains for each module
420          index the generation counter current when the entry was
421          created.  This array never shrinks so that all module indices
422          which were valid at some time can be used to access it.
423          Before the first use of a new module index in this function
424          the array was extended appropriately.  Access also does not
425          have to be guarded against modifications of the array.  It is
426          assumed that pointer-size values can be read atomically even
427          in SMP environments.  It is possible that other threads at
428          the same time dynamically load code and therefore add to the
429          slotinfo list.  This is a problem since we must not pick up
430          any information about incomplete work.  The solution to this
431          is to ignore all dtv slots which were created after the one
432          we are currently interested.  We know that dynamic loading
433          for this module is completed and this is the last load
434          operation we know finished.  */
435       idx = GET_ADDR_MODULE;
436       listp = GL(dl_tls_dtv_slotinfo_list);
437       while (idx >= listp->len)
438         {
439           idx -= listp->len;
440           listp = listp->next;
441         }
442
443       if (dtv[0].counter < listp->slotinfo[idx].gen)
444         {
445           /* The generation counter for the slot is higher than what
446              the current dtv implements.  We have to update the whole
447              dtv but only those entries with a generation counter <=
448              the one for the entry we need.  */
449           size_t new_gen = listp->slotinfo[idx].gen;
450           size_t total = 0;
451
452           /* We have to look through the entire dtv slotinfo list.  */
453           listp =  GL(dl_tls_dtv_slotinfo_list);
454           do
455             {
456               size_t cnt;
457
458               for (cnt = total = 0 ? 1 : 0; cnt < listp->len; ++cnt)
459                 {
460                   size_t gen = listp->slotinfo[cnt].gen;
461                   struct link_map *map;
462                   size_t modid;
463
464                   if (gen > new_gen)
465                     /* This is a slot for a generation younger than
466                        the one we are handling now.  It might be
467                        incompletely set up so ignore it.  */
468                     continue;
469
470                   /* If the entry is older than the current dtv layout
471                      we know we don't have to handle it.  */
472                   if (gen <= dtv[0].counter)
473                     continue;
474
475                   /* If there is no map this means the entry is empty.  */
476                   map = listp->slotinfo[cnt].map;
477                   if (map == NULL)
478                     {
479                       /* If this modid was used at some point the memory
480                          might still be allocated.  */
481                       if (dtv[total + cnt].pointer != TLS_DTV_UNALLOCATED)
482                         free (dtv[total + cnt].pointer);
483
484                       continue;
485                     }
486
487                   /* Check whether the current dtv array is large enough.  */
488                   modid = map->l_tls_modid;
489                   assert (total + cnt == modid);
490                   if (dtv[-1].counter < modid)
491                     {
492                       /* Reallocate the dtv.  */
493                       dtv_t *newp;
494                       size_t newsize = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS;
495                       size_t oldsize = dtv[-1].counter;
496
497                       assert (map->l_tls_modid <= newsize);
498
499                       newp = (dtv_t *) realloc (&dtv[-1],
500                                                 (2 + newsize)
501                                                 * sizeof (dtv_t));
502                       if (newp == NULL)
503                         oom ();
504
505                       newp[0].counter = newsize;
506
507                       /* Clear the newly allocate part.  */
508                       memset (newp + 2 + oldsize, '\0',
509                               (newsize - oldsize) * sizeof (dtv_t));
510
511                       /* Point dtv to the generation counter.  */
512                       dtv = &newp[1];
513
514                       /* Install this new dtv in the thread data
515                          structures.  */
516                       INSTALL_NEW_DTV (dtv);
517                     }
518
519                   /* If there is currently memory allocate for this
520                      dtv entry free it.  */
521                   /* XXX Ideally we will at some point create a memory
522                      pool.  */
523                   if (dtv[modid].pointer != TLS_DTV_UNALLOCATED)
524                     /* Note that free is called for NULL is well.  We
525                        deallocate even if it is this dtv entry we are
526                        supposed to load.  The reason is that we call
527                        memalign and not malloc.  */
528                     free (dtv[modid].pointer);
529
530                   /* This module is loaded dynamically- We defer
531                      memory allocation.  */
532                   dtv[modid].pointer = TLS_DTV_UNALLOCATED;
533
534                   if (modid == GET_ADDR_MODULE)
535                     the_map = map;
536                 }
537
538               total += listp->len;
539             }
540           while ((listp = listp->next) != NULL);
541
542           /* This will be the new maximum generation counter.  */
543           dtv[0].counter = new_gen;
544         }
545     }
546
547   p = dtv[GET_ADDR_MODULE].pointer;
548
549   if (__builtin_expect (p == TLS_DTV_UNALLOCATED, 0))
550     {
551       /* The allocation was deferred.  Do it now.  */
552       if (the_map == NULL)
553         {
554           /* Find the link map for this module.  */
555           size_t idx = GET_ADDR_MODULE;
556           struct dtv_slotinfo_list *listp = GL(dl_tls_dtv_slotinfo_list);
557
558           while (idx >= listp->len)
559             {
560               idx -= listp->len;
561               listp = listp->next;
562             }
563
564           the_map = listp->slotinfo[idx].map;
565         }
566
567       p = dtv[GET_ADDR_MODULE].pointer = allocate_and_init (the_map);
568     }
569
570   return (char *) p + GET_ADDR_OFFSET;
571 }
572 # endif
573
574 #endif  /* use TLS */