Update.
[glibc.git] / elf / dl-reloc.c
blob4004316c5a3e5fa49b8011a194bd7b83ca9eb8d5
1 /* Relocate a shared object and resolve its references to other loaded objects.
2 Copyright (C) 1995-2002, 2003, 2004 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
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. */
20 #include <errno.h>
21 #include <libintl.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24 #include <ldsodefs.h>
25 #include <sys/mman.h>
26 #include <sys/param.h>
27 #include <sys/types.h>
28 #include "dynamic-link.h"
30 /* Statistics function. */
31 #ifdef SHARED
32 # define bump_num_cache_relocations() ++GL(dl_num_cache_relocations)
33 #else
34 # define bump_num_cache_relocations() ((void) 0)
35 #endif
38 #ifdef USE_TLS
39 /* We are trying to perform a static TLS relocation in MAP, but it was
40 dynamically loaded. This can only work if there is enough surplus in
41 the static TLS area already allocated for each running thread. If this
42 object's TLS segment is too big to fit, we fail. If it fits,
43 we set MAP->l_tls_offset and return.
44 This function intentionally does not return any value but signals error
45 directly, as static TLS should be rare and code handling it should
46 not be inlined as much as possible. */
47 void
48 internal_function __attribute_noinline__
49 _dl_allocate_static_tls (struct link_map *map)
51 size_t offset;
53 /* If the alignment requirements are too high fail. */
54 if (map->l_tls_align > GL(dl_tls_static_align))
56 fail:
57 _dl_signal_error (0, map->l_name, NULL, N_("\
58 cannot allocate memory in static TLS block"));
61 # if TLS_TCB_AT_TP
62 size_t freebytes;
63 size_t n;
64 size_t blsize;
66 freebytes = GL(dl_tls_static_size) - GL(dl_tls_static_used) - TLS_TCB_SIZE;
68 blsize = map->l_tls_blocksize + map->l_tls_firstbyte_offset;
69 if (freebytes < blsize)
70 goto fail;
72 n = (freebytes - blsize) / map->l_tls_align;
74 offset = GL(dl_tls_static_used) + (freebytes - n * map->l_tls_align
75 - map->l_tls_firstbyte_offset);
77 map->l_tls_offset = GL(dl_tls_static_used) = offset;
78 # elif TLS_DTV_AT_TP
79 size_t used;
80 size_t check;
82 offset = roundup (GL(dl_tls_static_used), map->l_tls_align);
83 used = offset + map->l_tls_blocksize;
84 check = used;
85 /* dl_tls_static_used includes the TCB at the beginning. */
87 if (check > GL(dl_tls_static_size))
88 goto fail;
90 map->l_tls_offset = offset;
91 GL(dl_tls_static_used) = used;
92 # else
93 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
94 # endif
96 if (map->l_relocated)
97 GL(dl_init_static_tls) (map);
98 else
99 map->l_need_tls_init = 1;
102 /* Initialize static TLS area and DTV for current (only) thread.
103 libpthread implementations should provide their own hook
104 to handle all threads. */
105 void
106 _dl_nothread_init_static_tls (struct link_map *map)
108 # if TLS_TCB_AT_TP
109 void *dest = (char *) THREAD_SELF - map->l_tls_offset;
110 # elif TLS_DTV_AT_TP
111 void *dest = (char *) THREAD_SELF + map->l_tls_offset + TLS_PRE_TCB_SIZE;
112 # else
113 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
114 # endif
116 /* Fill in the DTV slot so that a later LD/GD access will find it. */
117 THREAD_DTV ()[map->l_tls_modid].pointer = dest;
119 /* Initialize the memory. */
120 memset (__mempcpy (dest, map->l_tls_initimage, map->l_tls_initimage_size),
121 '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
123 #endif
126 void
127 _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
128 int lazy, int consider_profiling)
130 struct textrels
132 caddr_t start;
133 size_t len;
134 int prot;
135 struct textrels *next;
136 } *textrels = NULL;
137 /* Initialize it to make the compiler happy. */
138 const char *errstring = NULL;
140 if (l->l_relocated)
141 return;
143 /* If DT_BIND_NOW is set relocate all references in this object. We
144 do not do this if we are profiling, of course. */
145 if (!consider_profiling
146 && __builtin_expect (l->l_info[DT_BIND_NOW] != NULL, 0))
147 lazy = 0;
149 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_RELOC, 0))
150 _dl_debug_printf ("\nrelocation processing: %s%s\n",
151 l->l_name[0] ? l->l_name : rtld_progname,
152 lazy ? " (lazy)" : "");
154 /* DT_TEXTREL is now in level 2 and might phase out at some time.
155 But we rewrite the DT_FLAGS entry to a DT_TEXTREL entry to make
156 testing easier and therefore it will be available at all time. */
157 if (__builtin_expect (l->l_info[DT_TEXTREL] != NULL, 0))
159 /* Bletch. We must make read-only segments writable
160 long enough to relocate them. */
161 const ElfW(Phdr) *ph;
162 for (ph = l->l_phdr; ph < &l->l_phdr[l->l_phnum]; ++ph)
163 if (ph->p_type == PT_LOAD && (ph->p_flags & PF_W) == 0)
165 struct textrels *newp;
167 newp = (struct textrels *) alloca (sizeof (*newp));
168 newp->len = (((ph->p_vaddr + ph->p_memsz + GLRO(dl_pagesize) - 1)
169 & ~(GLRO(dl_pagesize) - 1))
170 - (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
171 newp->start = ((ph->p_vaddr & ~(GLRO(dl_pagesize) - 1))
172 + (caddr_t) l->l_addr);
174 if (__mprotect (newp->start, newp->len, PROT_READ|PROT_WRITE) < 0)
176 errstring = N_("cannot make segment writable for relocation");
177 call_error:
178 _dl_signal_error (errno, l->l_name, NULL, errstring);
181 #if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
182 newp->prot = (PF_TO_PROT
183 >> ((ph->p_flags & (PF_R | PF_W | PF_X)) * 4)) & 0xf;
184 #else
185 newp->prot = 0;
186 if (ph->p_flags & PF_R)
187 newp->prot |= PROT_READ;
188 if (ph->p_flags & PF_W)
189 newp->prot |= PROT_WRITE;
190 if (ph->p_flags & PF_X)
191 newp->prot |= PROT_EXEC;
192 #endif
193 newp->next = textrels;
194 textrels = newp;
199 /* Do the actual relocation of the object's GOT and other data. */
201 /* String table object symbols. */
202 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
204 /* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code. */
205 #define RESOLVE_MAP(ref, version, r_type) \
206 (ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL \
207 ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0) \
208 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class) \
209 ? (bump_num_cache_relocations (), \
210 (*ref) = l->l_lookup_cache.ret, \
211 l->l_lookup_cache.value) \
212 : ({ lookup_t _lr; \
213 int _tc = elf_machine_type_class (r_type); \
214 l->l_lookup_cache.type_class = _tc; \
215 l->l_lookup_cache.sym = (*ref); \
216 const struct r_found_version *v = NULL; \
217 int flags = DL_LOOKUP_ADD_DEPENDENCY; \
218 if ((version) != NULL && (version)->hash != 0) \
220 v = (version); \
221 flags = 0; \
223 _lr = _dl_lookup_symbol_x (strtab + (*ref)->st_name, l, (ref), \
224 scope, v, _tc, flags, NULL); \
225 l->l_lookup_cache.ret = (*ref); \
226 l->l_lookup_cache.value = _lr; })) \
227 : l)
228 #define RESOLVE(ref, version, r_type) \
229 (ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL \
230 ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0) \
231 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class) \
232 ? (bump_num_cache_relocations (), \
233 (*ref) = l->l_lookup_cache.ret, \
234 l->l_lookup_cache.value) \
235 : ({ lookup_t _lr; \
236 int _tc = elf_machine_type_class (r_type); \
237 l->l_lookup_cache.type_class = _tc; \
238 l->l_lookup_cache.sym = (*ref); \
239 const struct r_found_version *v = NULL; \
240 int flags = DL_LOOKUP_ADD_DEPENDENCY; \
241 if ((version) != NULL && (version)->hash != 0) \
243 v = (version); \
244 flags = 0; \
246 _lr = _dl_lookup_symbol_x (strtab + (*ref)->st_name, l, (ref), \
247 scope, v, _tc, flags, NULL); \
248 l->l_lookup_cache.ret = (*ref); \
249 l->l_lookup_cache.value = _lr; })) \
250 : l->l_addr)
252 /* This macro is used as a callback from elf_machine_rel{a,} when a
253 static TLS reloc is about to be performed. Since (in dl-load.c) we
254 permit dynamic loading of objects that might use such relocs, we
255 have to check whether each use is actually doable. If the object
256 whose TLS segment the reference resolves to was allocated space in
257 the static TLS block at startup, then it's ok. Otherwise, we make
258 an attempt to allocate it in surplus space on the fly. If that
259 can't be done, we fall back to the error that DF_STATIC_TLS is
260 intended to produce. */
261 #define CHECK_STATIC_TLS(map, sym_map) \
262 do { \
263 if (__builtin_expect ((sym_map)->l_tls_offset == NO_TLS_OFFSET, 0)) \
264 _dl_allocate_static_tls (sym_map); \
265 } while (0)
267 #include "dynamic-link.h"
269 ELF_DYNAMIC_RELOCATE (l, lazy, consider_profiling);
271 if (__builtin_expect (consider_profiling, 0))
273 /* Allocate the array which will contain the already found
274 relocations. If the shared object lacks a PLT (for example
275 if it only contains lead function) the l_info[DT_PLTRELSZ]
276 will be NULL. */
277 if (l->l_info[DT_PLTRELSZ] == NULL)
279 errstring = N_("%s: profiler found no PLTREL in object %s\n");
280 fatal:
281 _dl_fatal_printf (errstring,
282 rtld_progname ?: "<program name unknown>",
283 l->l_name);
286 l->l_reloc_result =
287 (ElfW(Addr) *) calloc (sizeof (ElfW(Addr)),
288 l->l_info[DT_PLTRELSZ]->d_un.d_val);
289 if (l->l_reloc_result == NULL)
291 errstring = N_("\
292 %s: profiler out of memory shadowing PLTREL of %s\n");
293 goto fatal;
298 /* Mark the object so we know this work has been done. */
299 l->l_relocated = 1;
301 /* Undo the segment protection changes. */
302 while (__builtin_expect (textrels != NULL, 0))
304 if (__mprotect (textrels->start, textrels->len, textrels->prot) < 0)
306 errstring = N_("cannot restore segment prot after reloc");
307 goto call_error;
310 textrels = textrels->next;
313 /* In case we can protect the data now that the relocations are
314 done, do it. */
315 if (l->l_relro_size != 0)
316 _dl_protect_relro (l);
320 void internal_function
321 _dl_protect_relro (struct link_map *l)
323 ElfW(Addr) start = ((l->l_addr + l->l_relro_addr)
324 & ~(GLRO(dl_pagesize) - 1));
325 ElfW(Addr) end = ((l->l_addr + l->l_relro_addr + l->l_relro_size)
326 & ~(GLRO(dl_pagesize) - 1));
328 if (start != end
329 && __mprotect ((void *) start, end - start, PROT_READ) < 0)
331 static const char errstring[] = N_("\
332 cannot apply additional memory protection after relocation");
333 _dl_signal_error (errno, l->l_name, NULL, errstring);
337 void
338 internal_function __attribute_noinline__
339 _dl_reloc_bad_type (struct link_map *map, unsigned int type, int plt)
341 extern const char INTUSE(_itoa_lower_digits)[] attribute_hidden;
342 #define DIGIT(b) INTUSE(_itoa_lower_digits)[(b) & 0xf];
344 /* XXX We cannot translate these messages. */
345 static const char msg[2][32
346 #if __ELF_NATIVE_CLASS == 64
348 #endif
349 ] = { "unexpected reloc type 0x",
350 "unexpected PLT reloc type 0x" };
351 char msgbuf[sizeof (msg[0])];
352 char *cp;
354 cp = __stpcpy (msgbuf, msg[plt]);
355 #if __ELF_NATIVE_CLASS == 64
356 if (__builtin_expect(type > 0xff, 0))
358 *cp++ = DIGIT (type >> 28);
359 *cp++ = DIGIT (type >> 24);
360 *cp++ = DIGIT (type >> 20);
361 *cp++ = DIGIT (type >> 16);
362 *cp++ = DIGIT (type >> 12);
363 *cp++ = DIGIT (type >> 8);
365 #endif
366 *cp++ = DIGIT (type >> 4);
367 *cp++ = DIGIT (type);
368 *cp = '\0';
370 _dl_signal_error (0, map->l_name, NULL, msgbuf);