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, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307 USA. */
19
20 #include <errno.h>
21 #include <ldsodefs.h>
22 #include <tls.h>
23 #include <unistd.h>
24 #include <stdio.h>
25 #include <sys/param.h>
26 #include <elf.h>
27 #include <link.h>
28 #include <string.h>
29 #include <stdlib.h>
30
31 #include <l4/re/env>
32 #include <l4/re/dataspace>
33 #include <l4/re/mem_alloc>
34 #include <l4/re/rm>
35
36 #ifdef SHARED
37 #error makefile bug, this file is for static only
38 #endif
39
40 #if USE_TLS
41 extern ElfW(Phdr) *_dl_phdr;
42 extern size_t _dl_phnum;
43
44 extern "C"
45 __attribute__ ((weak))
46 void *__libc_alloc_initial_tls(unsigned long size) __THROW;
47
48 static 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 dtv_slotinfo_list::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 __attribute__((weak)) = TLS_TCB_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
init_slotinfo(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
init_static_tls(size_t memsz,size_t align)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 __attribute__ ((weak))
__libc_alloc_initial_tls(unsigned long size)121 void *__libc_alloc_initial_tls(unsigned long size) __THROW
122 {
123 using namespace L4;
124 using namespace L4Re;
125 Cap<Dataspace> ds(Env::env()->first_free_cap() << L4_CAP_SHIFT);
126 ::l4re_global_env->first_free_cap += 1;
127 if (Env::env()->mem_alloc()->alloc(size, ds, 0) < 0)
128 return NULL;
129
130 void *addr = NULL;
131 if(Env::env()->rm()->attach(&addr, size, Rm::F::Search_addr | Rm::F::RW,
132 L4::Ipc::make_cap_rw(ds), 0, 0) < 0)
133 return NULL;
134
135 return addr;
136 }
137 extern "C"
138 void
__libc_setup_tls(size_t tcbsize,size_t tcbalign)139 __libc_setup_tls (size_t tcbsize, size_t tcbalign)
140 {
141 void *tlsblock;
142 size_t memsz = 0;
143 size_t filesz = 0;
144 void *initimage = NULL;
145 size_t align = 0;
146 size_t max_align = tcbalign;
147 size_t tcb_offset;
148 ElfW(Phdr) *phdr;
149 /* Look through the TLS segment if there is any. */
150 if (_dl_phdr != NULL)
151 for (phdr = _dl_phdr; phdr < &_dl_phdr[_dl_phnum]; ++phdr)
152 if (phdr->p_type == PT_TLS)
153 {
154 /* Remember the values we need. */
155 memsz = phdr->p_memsz;
156 filesz = phdr->p_filesz;
157 initimage = (void *) phdr->p_vaddr;
158 align = phdr->p_align;
159 if (phdr->p_align > max_align)
160 max_align = phdr->p_align;
161 break;
162 }
163 /* We have to set up the TCB block which also (possibly) contains
164 'errno'. Therefore we avoid 'malloc' which might touch 'errno'.
165 Instead we use 'sbrk' which would only uses 'errno' if it fails.
166 In this case we are right away out of memory and the user gets
167 what she/he deserves.
168
169 The initialized value of _dl_tls_static_size is provided by dl-open.c
170 to request some surplus that permits dynamic loading of modules with
171 IE-model TLS. */
172 # if defined(TLS_TCB_AT_TP)
173 tcb_offset = roundup (memsz + GL(dl_tls_static_size), tcbalign);
174 tlsblock = __libc_alloc_initial_tls(tcb_offset + tcbsize + max_align);
175 # elif defined(TLS_DTV_AT_TP)
176 tcb_offset = roundup (tcbsize, align ?: 1);
177 tlsblock = __libc_alloc_initial_tls(tcb_offset + memsz + max_align
178 + TLS_PRE_TCB_SIZE + GL(dl_tls_static_size));
179 //tlsblock += TLS_PRE_TCB_SIZE;
180 tlsblock = (char *)tlsblock + TLS_PRE_TCB_SIZE;
181 # else
182 /* In case a model with a different layout for the TCB and DTV
183 is defined add another #elif here and in the following #ifs. */
184 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
185 # endif
186
187 /* Align the TLS block. */
188 tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
189 & ~(max_align - 1));
190
191 /* Initialize the dtv. [0] is the length, [1] the generation counter. */
192 static_dtv[0].counter = (sizeof (static_dtv) / sizeof (static_dtv[0])) - 2;
193 // static_dtv[1].counter = 0; would be needed if not already done
194
195 /* Initialize the TLS block. */
196 # if defined(TLS_TCB_AT_TP)
197 static_dtv[2].pointer.val = ((char *) tlsblock + tcb_offset
198 - roundup (memsz, align ?: 1));
199 static_map.l_tls_offset = roundup (memsz, align ?: 1);
200 # elif defined(TLS_DTV_AT_TP)
201 static_dtv[2].pointer.val = (char *) tlsblock + tcb_offset;
202 static_map.l_tls_offset = tcb_offset;
203 # else
204 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
205 # endif
206 static_dtv[2].pointer.is_static = true;
207 /* sbrk gives us zero'd memory, so we don't need to clear the remainder. */
208 memcpy (static_dtv[2].pointer.val, initimage, filesz);
209
210 /* Install the pointer to the dtv. */
211
212 /* Initialize the thread pointer. */
213 # if defined(TLS_TCB_AT_TP)
214 INSTALL_DTV ((char *) tlsblock + tcb_offset, static_dtv);
215 const char *lossage = TLS_INIT_TP ((char *) tlsblock + tcb_offset, 0);
216 # elif defined(TLS_DTV_AT_TP)
217 INSTALL_DTV (tlsblock, static_dtv);
218 const char *lossage = (char *)TLS_INIT_TP (tlsblock, 0);
219 # else
220 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
221 # endif
222 if (__builtin_expect (lossage != NULL, 0))
223 abort();
224
225 /* We have to create a fake link map which normally would be created
226 by the dynamic linker. It just has to have enough information to
227 make the TLS routines happy. */
228 static_map.l_tls_align = align;
229 static_map.l_tls_blocksize = memsz;
230 static_map.l_tls_initimage = initimage;
231 static_map.l_tls_initimage_size = filesz;
232 static_map.l_tls_modid = 1;
233
234 init_slotinfo ();
235 // static_slotinfo.si.slotinfo[1].gen = 0; already zero
236 static_slotinfo.si.slotinfo[1].map = &static_map;
237
238 memsz = roundup (memsz, align ?: 1);
239
240 # if defined(TLS_TCB_AT_TP)
241 memsz += tcbsize;
242 # elif defined(TLS_DTV_AT_TP)
243 memsz += tcb_offset;
244 # endif
245
246 init_static_tls (memsz, MAX (TLS_TCB_ALIGN, max_align));
247 }
248
249 /* This is called only when the data structure setup was skipped at startup,
250 when there was no need for it then. Now we have dynamically loaded
251 something needing TLS, or libpthread needs it. */
252 int
253 internal_function
_dl_tls_setup(void)254 _dl_tls_setup (void)
255 {
256 init_slotinfo ();
257 init_static_tls (
258 # if defined(TLS_TCB_AT_TP)
259 TLS_TCB_SIZE,
260 # else
261 0,
262 # endif
263 TLS_TCB_ALIGN);
264 return 0;
265 }
266
267
268 /* This is the minimal initialization function used when libpthread is
269 not used. */
270 extern "C"
271 void
272 __attribute__ ((weak))
__pthread_initialize_minimal(void)273 __pthread_initialize_minimal (void)
274 {
275 __libc_setup_tls (TLS_INIT_TCB_SIZE, TLS_INIT_TCB_ALIGN);
276 }
277
278 #elif defined NONTLS_INIT_TP
279
280 /* This is the minimal initialization function used when libpthread is
281 not used. */
282 extern "C"
283 void
284 __attribute__ ((weak))
__pthread_initialize_minimal(void)285 __pthread_initialize_minimal (void)
286 {
287 NONTLS_INIT_TP;
288 }
289
290 #endif
291