libpthread/nptl/sysdeps/generic/libc-tls.c

   1 /* Initialization code for TLS in statically linked application.
   2    Copyright (C) 2002, 2003, 2004, 2005 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, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <ldsodefs.h>
  21 #include <tls.h>
  22 #include <unistd.h>
  23 #include <stdio.h>
  24 #include <sys/param.h>
  25 #include <elf.h>
  26 #include <link.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <sys/mman.h>
  30
  31 #ifdef SHARED
  32  #error makefile bug, this file is for static only
  33 #endif
  34
  35 #if USE_TLS
  36 extern ElfW(Phdr) *_dl_phdr;
  37 extern size_t _dl_phnum;
  38
  39 #ifdef __FDPIC__
  40 /* phdr->p_vaddr is not valid in FDPIC mode. To find tdata start we
  41    use the linker script defined symbol __tdata_start.  */
  42 extern int __tdata_start;
  43 #endif
  44
  45 #ifdef SHARED
  46 static
  47 #endif
  48 dtv_t static_dtv[2 + TLS_SLOTINFO_SURPLUS];
  49
  50
  51 static struct
  52 {
  53   struct dtv_slotinfo_list si;
  54   /* The dtv_slotinfo_list data structure does not include the actual
  55      information since it is defined as an array of size zero.  We define
  56      here the necessary entries.  Note that it is not important whether
  57      there is padding or not since we will always access the information
  58      through the 'si' element.  */
  59   struct dtv_slotinfo info[2 + TLS_SLOTINFO_SURPLUS];
  60 } static_slotinfo;
  61
  62 /* Fake link map for the application.  */
  63 static struct link_map static_map;
  64
  65
  66 /* Highest dtv index currently needed.  */
  67 size_t _dl_tls_max_dtv_idx;
  68 /* Flag signalling whether there are gaps in the module ID allocation.  */
  69 bool _dl_tls_dtv_gaps;
  70 /* Information about the dtv slots.  */
  71 struct dtv_slotinfo_list *_dl_tls_dtv_slotinfo_list;
  72 /* Number of modules in the static TLS block.  */
  73 size_t _dl_tls_static_nelem;
  74 /* Size of the static TLS block.  */
  75 size_t _dl_tls_static_size;
  76 /* Size actually allocated in the static TLS block.  */
  77 size_t _dl_tls_static_used;
  78 /* Alignment requirement of the static TLS block.  */
  79 size_t _dl_tls_static_align;
  80
  81 /* Generation counter for the dtv.  */
  82 size_t _dl_tls_generation;
  83
  84
  85 /* Additional definitions needed by TLS initialization.  */
  86 #ifdef TLS_INIT_HELPER
  87 TLS_INIT_HELPER
  88 #endif
  89
  90 static inline void
  91 init_slotinfo (void)
  92 {
  93   /* Create the slotinfo list.  */
  94   static_slotinfo.si.len = (((char *) (&static_slotinfo + 1)
  95                              - (char *) &static_slotinfo.si.slotinfo[0])
  96                             / sizeof static_slotinfo.si.slotinfo[0]);
  97   // static_slotinfo.si.next = NULL;    already zero
  98
  99   /* The slotinfo list.  Will be extended by the code doing dynamic
 100      linking.  */
 101   GL(dl_tls_max_dtv_idx) = 1;
 102   GL(dl_tls_dtv_slotinfo_list) = &static_slotinfo.si;
 103 }
 104
 105 static inline void
 106 init_static_tls (size_t memsz, size_t align)
 107 {
 108   /* That is the size of the TLS memory for this object.  The initialized
 109      value of _dl_tls_static_size is provided by dl-open.c to request some
 110      surplus that permits dynamic loading of modules with IE-model TLS.  */
 111   GL(dl_tls_static_size) = roundup (memsz + GL(dl_tls_static_size),
 112                                     TLS_TCB_ALIGN);
 113   GL(dl_tls_static_used) = memsz;
 114   /* The alignment requirement for the static TLS block.  */
 115   GL(dl_tls_static_align) = align;
 116   /* Number of elements in the static TLS block.  */
 117   GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
 118 }
 119
 120 #if !defined(__FDPIC__) && !defined(SHARED) && defined(STATIC_PIE)
 121 ElfW(Addr) _dl_load_base;
 122 #endif
 123
 124 void __libc_setup_tls (size_t tcbsize, size_t tcbalign);
 125 void
 126 __libc_setup_tls (size_t tcbsize, size_t tcbalign)
 127 {
 128   void *tlsblock;
 129   size_t memsz = 0;
 130   size_t filesz = 0;
 131   void *initimage = NULL;
 132   size_t align = 0;
 133   size_t max_align = tcbalign;
 134   size_t tcb_offset;
 135   ElfW(Phdr) *phdr;
 136
 137   /* Look through the TLS segment if there is any.  */
 138   if (_dl_phdr != NULL)
 139     for (phdr = _dl_phdr; phdr < &_dl_phdr[_dl_phnum]; ++phdr)
 140       if (phdr->p_type == PT_TLS)
 141         {
 142           /* Remember the values we need.  */
 143           memsz = phdr->p_memsz;
 144           filesz = phdr->p_filesz;
 145 #ifdef __FDPIC__
 146           initimage = (void *) &__tdata_start;
 147 #else
 148           initimage = (void *) phdr->p_vaddr;
 149 #if !defined(SHARED) && defined(STATIC_PIE)
 150           initimage += _dl_load_base;
 151 #endif
 152 #endif
 153           align = phdr->p_align;
 154           if (phdr->p_align > max_align)
 155             max_align = phdr->p_align;
 156           break;
 157         }
 158
 159   /* We have to set up the TCB block which also (possibly) contains
 160      'errno'.  Therefore we avoid 'malloc' which might touch 'errno'.
 161      Instead we use 'sbrk' which would only uses 'errno' if it fails.
 162      In this case we are right away out of memory and the user gets
 163      what she/he deserves.
 164
 165      The initialized value of _dl_tls_static_size is provided by dl-open.c
 166      to request some surplus that permits dynamic loading of modules with
 167      IE-model TLS.  */
 168   /* Use mmap instead of sbrk since this commit disables sbrk area
 169      for FDPIC MMU-less platforms:
 170      fs/binfmt_elf_fdpic.c: fix brk area overlap with stack on NOMMU
 171      https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/fs/binfmt_elf_fdpic.c?id=4ac313111018cb44ecc250445de5ccb93026a980
 172      Loading static PIE ELFs on noMMU is possible since the linux kernel commit
 173      1bde925d2354 ("fs/binfmt_elf_fdpic.c: provide NOMMU loader for regular ELF binaries")
 174      and it is subject to the same brk restriction.
 175    */
 176 # if defined(TLS_TCB_AT_TP)
 177   tcb_offset = roundup (memsz + GL(dl_tls_static_size), tcbalign);
 178 #  if defined(__FDPIC__) || (!defined(__ARCH_USE_MMU__) && defined(STATIC_PIE))
 179   tlsblock = mmap (NULL, tcb_offset + tcbsize + max_align,
 180                    PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 181 #  else
 182   tlsblock = sbrk (tcb_offset + tcbsize + max_align);
 183 #  endif
 184 # elif defined(TLS_DTV_AT_TP)
 185   tcb_offset = roundup (tcbsize, align ?: 1);
 186 #  if defined(__FDPIC__) || (!defined(__ARCH_USE_MMU__) && defined(STATIC_PIE))
 187   tlsblock = mmap (NULL, tcb_offset + memsz + max_align + TLS_PRE_TCB_SIZE + GL(dl_tls_static_size),
 188                    PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 189 #  else
 190   tlsblock = sbrk (tcb_offset + memsz + max_align
 191                      + TLS_PRE_TCB_SIZE + GL(dl_tls_static_size));
 192 #  endif
 193   memset(tlsblock, '\0', tcb_offset + memsz + max_align + TLS_PRE_TCB_SIZE + GL(dl_tls_static_size));
 194   tlsblock += TLS_PRE_TCB_SIZE;
 195 # else
 196   /* In case a model with a different layout for the TCB and DTV
 197      is defined add another #elif here and in the following #ifs.  */
 198 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 199 # endif
 200
 201   /* Align the TLS block.  */
 202   tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
 203                        & ~(max_align - 1));
 204
 205   /* Initialize the dtv.  [0] is the length, [1] the generation counter.  */
 206   static_dtv[0].counter = (sizeof (static_dtv) / sizeof (static_dtv[0])) - 2;
 207   // static_dtv[1].counter = 0;         would be needed if not already done
 208
 209   /* Initialize the TLS block.  */
 210 # if defined(TLS_TCB_AT_TP)
 211   static_dtv[2].pointer.val = ((char *) tlsblock + tcb_offset
 212                                - roundup (memsz, align ?: 1));
 213   static_map.l_tls_offset = roundup (memsz, align ?: 1);
 214 # elif defined(TLS_DTV_AT_TP)
 215   static_dtv[2].pointer.val = (char *) tlsblock + tcb_offset;
 216   static_map.l_tls_offset = tcb_offset;
 217 # else
 218 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 219 # endif
 220   static_dtv[2].pointer.is_static = true;
 221   /* sbrk gives us zero'd memory, so we don't need to clear the remainder.  */
 222   memcpy (static_dtv[2].pointer.val, initimage, filesz);
 223
 224   /* Install the pointer to the dtv.  */
 225
 226   /* Initialize the thread pointer.  */
 227 # if defined(TLS_TCB_AT_TP)
 228   INSTALL_DTV ((char *) tlsblock + tcb_offset, static_dtv);
 229
 230   const char *lossage = TLS_INIT_TP ((char *) tlsblock + tcb_offset, 0);
 231 # elif defined(TLS_DTV_AT_TP)
 232   INSTALL_DTV (tlsblock, static_dtv);
 233   const char *lossage = (char *)TLS_INIT_TP (tlsblock, 0);
 234 # else
 235 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 236 # endif
 237   if (__builtin_expect (lossage != NULL, 0))
 238     abort();
 239
 240   /* We have to create a fake link map which normally would be created
 241      by the dynamic linker.  It just has to have enough information to
 242      make the TLS routines happy.  */
 243   static_map.l_tls_align = align;
 244   static_map.l_tls_blocksize = memsz;
 245   static_map.l_tls_initimage = initimage;
 246   static_map.l_tls_initimage_size = filesz;
 247   static_map.l_tls_modid = 1;
 248
 249   init_slotinfo ();
 250   // static_slotinfo.si.slotinfo[1].gen = 0; already zero
 251   static_slotinfo.si.slotinfo[1].map = &static_map;
 252
 253   memsz = roundup (memsz, align ?: 1);
 254
 255 # if defined(TLS_TCB_AT_TP)
 256   memsz += tcbsize;
 257 # elif defined(TLS_DTV_AT_TP)
 258   memsz += tcb_offset;
 259 # endif
 260
 261   init_static_tls (memsz, MAX (TLS_TCB_ALIGN, max_align));
 262 }
 263
 264 /* This is called only when the data structure setup was skipped at startup,
 265    when there was no need for it then.  Now we have dynamically loaded
 266    something needing TLS, or libpthread needs it.  */
 267 int
 268 internal_function
 269 _dl_tls_setup (void)
 270 {
 271   init_slotinfo ();
 272   init_static_tls (
 273 # if defined(TLS_TCB_AT_TP)
 274                    TLS_TCB_SIZE,
 275 # else
 276                    0,
 277 # endif
 278                    TLS_TCB_ALIGN);
 279   return 0;
 280 }
 281
 282 extern void __pthread_initialize_minimal(void) __attribute__((weak));
 283
 284 /* This is the minimal initialization function used when libpthread is
 285    not used.  */
 286 void
 287 __attribute__ ((weak))
 288 __pthread_initialize_minimal (void)
 289 {
 290   __libc_setup_tls (TLS_INIT_TCB_SIZE, TLS_INIT_TCB_ALIGN);
 291 }
 292
 293 #endif