1 /* $NetBSD: reloc.c,v 1.107 2014/08/25 20:40:52 joerg Exp $ */
2
3 /*
4 * Copyright 1996 John D. Polstra.
5 * Copyright 1996 Matt Thomas <matt@3am-software.com>
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by John Polstra.
19 * 4. The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 /*
35 * Dynamic linker for ELF.
36 *
37 * John Polstra <jdp@polstra.com>.
38 */
39
40 #include <sys/cdefs.h>
41 #ifndef lint
42 __RCSID("$NetBSD: reloc.c,v 1.107 2014/08/25 20:40:52 joerg Exp $");
43 #endif /* not lint */
44
45 #include <err.h>
46 #include <errno.h>
47 #include <fcntl.h>
48 #include <stdarg.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include <string.h>
52 #include <unistd.h>
53 #include <sys/types.h>
54 #include <sys/mman.h>
55 #include <sys/bitops.h>
56 #include <dirent.h>
57
58 #include "debug.h"
59 #include "rtld.h"
60
61 #ifndef RTLD_INHIBIT_COPY_RELOCS
62 static int _rtld_do_copy_relocation(const Obj_Entry *, const Elf_Rela *);
63
64 static int
_rtld_do_copy_relocation(const Obj_Entry * dstobj,const Elf_Rela * rela)65 _rtld_do_copy_relocation(const Obj_Entry *dstobj, const Elf_Rela *rela)
66 {
67 void *dstaddr = (void *)(dstobj->relocbase + rela->r_offset);
68 const Elf_Sym *dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
69 const char *name = dstobj->strtab + dstsym->st_name;
70 unsigned long hash = _rtld_elf_hash(name);
71 size_t size = dstsym->st_size;
72 const void *srcaddr;
73 const Elf_Sym *srcsym = NULL;
74 Obj_Entry *srcobj;
75
76 for (srcobj = dstobj->next; srcobj != NULL; srcobj = srcobj->next) {
77 srcsym = _rtld_symlook_obj(name, hash, srcobj, 0,
78 _rtld_fetch_ventry(dstobj, ELF_R_SYM(rela->r_info)));
79 if (srcsym != NULL)
80 break;
81 }
82
83 if (srcobj == NULL) {
84 _rtld_error("Undefined symbol \"%s\" referenced from COPY"
85 " relocation in %s", name, dstobj->path);
86 return (-1);
87 }
88 srcaddr = (const void *)(srcobj->relocbase + srcsym->st_value);
89 (void)memcpy(dstaddr, srcaddr, size);
90 rdbg(("COPY %s %s %s --> src=%p dst=%p size %ld",
91 dstobj->path, srcobj->path, name, srcaddr,
92 (void *)dstaddr, (long)size));
93 return (0);
94 }
95 #endif /* RTLD_INHIBIT_COPY_RELOCS */
96
97
98 /*
99 * Process the special R_xxx_COPY relocations in the main program. These
100 * copy data from a shared object into a region in the main program's BSS
101 * segment.
102 *
103 * Returns 0 on success, -1 on failure.
104 */
105 int
_rtld_do_copy_relocations(const Obj_Entry * dstobj)106 _rtld_do_copy_relocations(const Obj_Entry *dstobj)
107 {
108 #ifndef RTLD_INHIBIT_COPY_RELOCS
109
110 /* COPY relocations are invalid elsewhere */
111 assert(!dstobj->isdynamic);
112
113 if (dstobj->rel != NULL) {
114 const Elf_Rel *rel;
115 for (rel = dstobj->rel; rel < dstobj->rellim; ++rel) {
116 if (ELF_R_TYPE(rel->r_info) == R_TYPE(COPY)) {
117 Elf_Rela ourrela;
118 ourrela.r_info = rel->r_info;
119 ourrela.r_offset = rel->r_offset;
120 ourrela.r_addend = 0;
121 if (_rtld_do_copy_relocation(dstobj,
122 &ourrela) < 0)
123 return (-1);
124 }
125 }
126 }
127 if (dstobj->rela != NULL) {
128 const Elf_Rela *rela;
129 for (rela = dstobj->rela; rela < dstobj->relalim; ++rela) {
130 if (ELF_R_TYPE(rela->r_info) == R_TYPE(COPY)) {
131 if (_rtld_do_copy_relocation(dstobj, rela) < 0)
132 return (-1);
133 }
134 }
135 }
136 #endif /* RTLD_INHIBIT_COPY_RELOCS */
137
138 return (0);
139 }
140
141 /*
142 * Relocate newly-loaded shared objects. The argument is a pointer to
143 * the Obj_Entry for the first such object. All objects from the first
144 * to the end of the list of objects are relocated. Returns 0 on success,
145 * or -1 on failure.
146 */
147 int
_rtld_relocate_objects(Obj_Entry * first,bool bind_now)148 _rtld_relocate_objects(Obj_Entry *first, bool bind_now)
149 {
150 Obj_Entry *obj;
151 int ok = 1;
152
153 for (obj = first; obj != NULL; obj = obj->next) {
154 if (obj->nbuckets == 0 || obj->nchains == 0 ||
155 obj->buckets == NULL || obj->symtab == NULL ||
156 obj->strtab == NULL) {
157 _rtld_error("%s: Shared object has no run-time"
158 " symbol table", obj->path);
159 return -1;
160 }
161 if (obj->nbuckets == UINT32_MAX) {
162 _rtld_error("%s: Symbol table too large", obj->path);
163 return -1;
164 }
165 rdbg((" relocating %s (%ld/%ld rel/rela, %ld/%ld plt rel/rela)",
166 obj->path,
167 (long)(obj->rellim - obj->rel),
168 (long)(obj->relalim - obj->rela),
169 (long)(obj->pltrellim - obj->pltrel),
170 (long)(obj->pltrelalim - obj->pltrela)));
171
172 #if !defined(__minix)
173 if (obj->textrel) {
174 /*
175 * There are relocations to the write-protected text
176 * segment.
177 */
178 if (mprotect(obj->mapbase, obj->textsize,
179 PROT_READ | PROT_WRITE | PROT_EXEC) == -1) {
180 _rtld_error("%s: Cannot write-enable text "
181 "segment: %s", obj->path, xstrerror(errno));
182 return -1;
183 }
184 }
185 #endif /* !defined(__minix) */
186 dbg(("doing non-PLT relocations"));
187 if (_rtld_relocate_nonplt_objects(obj) < 0)
188 ok = 0;
189 #if !defined(__minix)
190 if (obj->textrel) { /* Re-protected the text segment. */
191 if (mprotect(obj->mapbase, obj->textsize,
192 PROT_READ | PROT_EXEC) == -1) {
193 _rtld_error("%s: Cannot write-protect text "
194 "segment: %s", obj->path, xstrerror(errno));
195 return -1;
196 }
197 }
198 #endif /* !defined(__minix) */
199 dbg(("doing lazy PLT binding"));
200 if (_rtld_relocate_plt_lazy(obj) < 0)
201 ok = 0;
202 if (obj->z_now || bind_now) {
203 dbg(("doing immediate PLT binding"));
204 if (_rtld_relocate_plt_objects(obj) < 0)
205 ok = 0;
206 }
207 if (!ok)
208 return -1;
209
210 /* Set some sanity-checking numbers in the Obj_Entry. */
211 obj->magic = RTLD_MAGIC;
212 obj->version = RTLD_VERSION;
213
214 /*
215 * Fill in the backwards compatibility dynamic linker entry points.
216 *
217 * DO NOT ADD TO THIS LIST
218 */
219 obj->dlopen = dlopen;
220 obj->dlsym = dlsym;
221 obj->dlerror = dlerror;
222 obj->dlclose = dlclose;
223 obj->dladdr = dladdr;
224
225 dbg(("fixing up PLTGOT"));
226 /* Set the special PLTGOT entries. */
227 if (obj->pltgot != NULL)
228 _rtld_setup_pltgot(obj);
229 }
230
231 return 0;
232 }
233
234 Elf_Addr
_rtld_resolve_ifunc(const Obj_Entry * obj,const Elf_Sym * def)235 _rtld_resolve_ifunc(const Obj_Entry *obj, const Elf_Sym *def)
236 {
237 Elf_Addr target;
238
239 _rtld_shared_exit();
240 target = _rtld_call_function_addr(obj,
241 (Elf_Addr)obj->relocbase + def->st_value);
242 _rtld_shared_enter();
243
244 return target;
245 }
246