1/*-
2 * Copyright 1996, 1997, 1998, 1999 John D. Polstra.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
|
25 * $FreeBSD: head/libexec/rtld-elf/i386/reloc.c 208256 2010-05-18 08:55:23Z rdivacky $
|
| 25 * $FreeBSD: head/libexec/rtld-elf/i386/reloc.c 216695 2010-12-25 08:51:20Z kib $ |
26 */
27
28/*
29 * Dynamic linker for ELF.
30 *
31 * John Polstra <jdp@polstra.com>.
32 */
33
34#include <sys/param.h>
35#include <sys/mman.h>
36#include <machine/segments.h>
37#include <machine/sysarch.h>
38
39#include <dlfcn.h>
40#include <err.h>
41#include <errno.h>
42#include <fcntl.h>
43#include <stdarg.h>
44#include <stdio.h>
45#include <stdlib.h>
46#include <string.h>
47#include <unistd.h>
48
49#include "debug.h"
50#include "rtld.h"
51
52/*
53 * Process the special R_386_COPY relocations in the main program. These
54 * copy data from a shared object into a region in the main program's BSS
55 * segment.
56 *
57 * Returns 0 on success, -1 on failure.
58 */
59int
60do_copy_relocations(Obj_Entry *dstobj)
61{
62 const Elf_Rel *rellim;
63 const Elf_Rel *rel;
64
65 assert(dstobj->mainprog); /* COPY relocations are invalid elsewhere */
66
67 rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize);
68 for (rel = dstobj->rel; rel < rellim; rel++) {
69 if (ELF_R_TYPE(rel->r_info) == R_386_COPY) {
70 void *dstaddr;
71 const Elf_Sym *dstsym;
72 const char *name;
|
73 unsigned long hash;
|
73 size_t size;
74 const void *srcaddr;
75 const Elf_Sym *srcsym;
|
77 const Ver_Entry *ve;
78 Obj_Entry *srcobj;
|
76 const Obj_Entry *srcobj, *defobj;
77 SymLook req;
78 int res; |
79
80 dstaddr = (void *) (dstobj->relocbase + rel->r_offset);
81 dstsym = dstobj->symtab + ELF_R_SYM(rel->r_info);
82 name = dstobj->strtab + dstsym->st_name;
|
83 hash = elf_hash(name);
|
83 size = dstsym->st_size;
|
85 ve = fetch_ventry(dstobj, ELF_R_SYM(rel->r_info));
|
84 symlook_init(&req, name);
85 req.ventry = fetch_ventry(dstobj, ELF_R_SYM(rel->r_info)); |
86
|
87 for (srcobj = dstobj->next; srcobj != NULL; srcobj = srcobj->next)
88 if ((srcsym = symlook_obj(name, hash, srcobj, ve, 0)) != NULL)
|
87 for (srcobj = dstobj->next; srcobj != NULL; srcobj = srcobj->next) {
88 res = symlook_obj(&req, srcobj);
89 if (res == 0) {
90 srcsym = req.sym_out;
91 defobj = req.defobj_out; |
92 break;
|
93 }
94 } |
95
96 if (srcobj == NULL) {
97 _rtld_error("Undefined symbol \"%s\" referenced from COPY"
98 " relocation in %s", name, dstobj->path);
99 return -1;
100 }
101
|
97 srcaddr = (const void *) (srcobj->relocbase + srcsym->st_value);
|
| 102 srcaddr = (const void *) (defobj->relocbase + srcsym->st_value); |
103 memcpy(dstaddr, srcaddr, size);
104 }
105 }
106
107 return 0;
108}
109
110/* Initialize the special GOT entries. */
111void
112init_pltgot(Obj_Entry *obj)
113{
114 if (obj->pltgot != NULL) {
115 obj->pltgot[1] = (Elf_Addr) obj;
116 obj->pltgot[2] = (Elf_Addr) &_rtld_bind_start;
117 }
118}
119
120/* Process the non-PLT relocations. */
121int
|
117reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
|
| 122reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, RtldLockState *lockstate) |
123{
124 const Elf_Rel *rellim;
125 const Elf_Rel *rel;
126 SymCache *cache;
127 int r = -1;
128
129 /*
130 * The dynamic loader may be called from a thread, we have
131 * limited amounts of stack available so we cannot use alloca().
132 */
133 if (obj != obj_rtld) {
134 cache = calloc(obj->nchains, sizeof(SymCache));
135 /* No need to check for NULL here */
136 } else
137 cache = NULL;
138
139 rellim = (const Elf_Rel *) ((caddr_t) obj->rel + obj->relsize);
140 for (rel = obj->rel; rel < rellim; rel++) {
141 Elf_Addr *where = (Elf_Addr *) (obj->relocbase + rel->r_offset);
142
143 switch (ELF_R_TYPE(rel->r_info)) {
144
145 case R_386_NONE:
146 break;
147
148 case R_386_32:
149 {
150 const Elf_Sym *def;
151 const Obj_Entry *defobj;
152
153 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
|
149 false, cache);
|
| 154 false, cache, lockstate); |
155 if (def == NULL)
156 goto done;
157
158 *where += (Elf_Addr) (defobj->relocbase + def->st_value);
159 }
160 break;
161
162 case R_386_PC32:
163 /*
164 * I don't think the dynamic linker should ever see this
165 * type of relocation. But the binutils-2.6 tools sometimes
166 * generate it.
167 */
168 {
169 const Elf_Sym *def;
170 const Obj_Entry *defobj;
171
172 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
|
168 false, cache);
|
| 173 false, cache, lockstate); |
174 if (def == NULL)
175 goto done;
176
177 *where +=
178 (Elf_Addr) (defobj->relocbase + def->st_value) -
179 (Elf_Addr) where;
180 }
181 break;
182
183 case R_386_COPY:
184 /*
185 * These are deferred until all other relocations have
186 * been done. All we do here is make sure that the COPY
187 * relocation is not in a shared library. They are allowed
188 * only in executable files.
189 */
190 if (!obj->mainprog) {
191 _rtld_error("%s: Unexpected R_386_COPY relocation"
192 " in shared library", obj->path);
193 goto done;
194 }
195 break;
196
197 case R_386_GLOB_DAT:
198 {
199 const Elf_Sym *def;
200 const Obj_Entry *defobj;
201
202 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
|
198 false, cache);
|
| 203 false, cache, lockstate); |
204 if (def == NULL)
205 goto done;
206
207 *where = (Elf_Addr) (defobj->relocbase + def->st_value);
208 }
209 break;
210
211 case R_386_RELATIVE:
212 *where += (Elf_Addr) obj->relocbase;
213 break;
214
215 case R_386_TLS_TPOFF:
216 {
217 const Elf_Sym *def;
218 const Obj_Entry *defobj;
219
220 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
|
216 false, cache);
|
| 221 false, cache, lockstate); |
222 if (def == NULL)
223 goto done;
224
225 /*
226 * We lazily allocate offsets for static TLS as we
227 * see the first relocation that references the
228 * TLS block. This allows us to support (small
229 * amounts of) static TLS in dynamically loaded
230 * modules. If we run out of space, we generate an
231 * error.
232 */
233 if (!defobj->tls_done) {
234 if (!allocate_tls_offset((Obj_Entry*) defobj)) {
235 _rtld_error("%s: No space available for static "
236 "Thread Local Storage", obj->path);
237 goto done;
238 }
239 }
240
241 *where += (Elf_Addr) (def->st_value - defobj->tlsoffset);
242 }
243 break;
244
245 case R_386_TLS_DTPMOD32:
246 {
247 const Elf_Sym *def;
248 const Obj_Entry *defobj;
249
250 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
|
246 false, cache);
|
| 251 false, cache, lockstate); |
252 if (def == NULL)
253 goto done;
254
255 *where += (Elf_Addr) defobj->tlsindex;
256 }
257 break;
258
259 case R_386_TLS_DTPOFF32:
260 {
261 const Elf_Sym *def;
262 const Obj_Entry *defobj;
263
264 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
|
260 false, cache);
|
| 265 false, cache, lockstate); |
266 if (def == NULL)
267 goto done;
268
269 *where += (Elf_Addr) def->st_value;
270 }
271 break;
272
273 default:
274 _rtld_error("%s: Unsupported relocation type %d"
275 " in non-PLT relocations\n", obj->path,
276 ELF_R_TYPE(rel->r_info));
277 goto done;
278 }
279 }
280 r = 0;
281done:
282 if (cache != NULL)
283 free(cache);
284 return(r);
285}
286
287/* Process the PLT relocations. */
288int
289reloc_plt(Obj_Entry *obj)
290{
291 const Elf_Rel *rellim;
292 const Elf_Rel *rel;
293
294 rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
295 for (rel = obj->pltrel; rel < rellim; rel++) {
296 Elf_Addr *where;
297
298 assert(ELF_R_TYPE(rel->r_info) == R_386_JMP_SLOT);
299
300 /* Relocate the GOT slot pointing into the PLT. */
301 where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
302 *where += (Elf_Addr)obj->relocbase;
303 }
304 return 0;
305}
306
307/* Relocate the jump slots in an object. */
308int
|
304reloc_jmpslots(Obj_Entry *obj)
|
| 309reloc_jmpslots(Obj_Entry *obj, RtldLockState *lockstate) |
310{
311 const Elf_Rel *rellim;
312 const Elf_Rel *rel;
313
314 if (obj->jmpslots_done)
315 return 0;
316 rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
317 for (rel = obj->pltrel; rel < rellim; rel++) {
318 Elf_Addr *where, target;
319 const Elf_Sym *def;
320 const Obj_Entry *defobj;
321
322 assert(ELF_R_TYPE(rel->r_info) == R_386_JMP_SLOT);
323 where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
|
319 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, true, NULL);
|
324 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, true, NULL,
325 lockstate); |
326 if (def == NULL)
327 return -1;
328 target = (Elf_Addr)(defobj->relocbase + def->st_value);
329 reloc_jmpslot(where, target, defobj, obj, rel);
330 }
331 obj->jmpslots_done = true;
332 return 0;
333}
334
335void
336allocate_initial_tls(Obj_Entry *objs)
337{
338 void* tls;
339
340 /*
341 * Fix the size of the static TLS block by using the maximum
342 * offset allocated so far and adding a bit for dynamic modules to
343 * use.
344 */
345 tls_static_space = tls_last_offset + RTLD_STATIC_TLS_EXTRA;
346 tls = allocate_tls(objs, NULL, 3*sizeof(Elf_Addr), sizeof(Elf_Addr));
347 i386_set_gsbase(tls);
348}
349
350/* GNU ABI */
351__attribute__((__regparm__(1)))
352void *___tls_get_addr(tls_index *ti)
353{
354 Elf_Addr** segbase;
355 Elf_Addr* dtv;
356
357 __asm __volatile("movl %%gs:0, %0" : "=r" (segbase));
358 dtv = segbase[1];
359
360 return tls_get_addr_common(&segbase[1], ti->ti_module, ti->ti_offset);
361}
362
363/* Sun ABI */
364void *__tls_get_addr(tls_index *ti)
365{
366 Elf_Addr** segbase;
367 Elf_Addr* dtv;
368
369 __asm __volatile("movl %%gs:0, %0" : "=r" (segbase));
370 dtv = segbase[1];
371
372 return tls_get_addr_common(&segbase[1], ti->ti_module, ti->ti_offset);
373}
|