1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * SPARC relocation code.
29 */
30
31 #include <sys/types.h>
32 #include <sys/param.h>
33 #include <sys/sysmacros.h>
34 #include <sys/systm.h>
35 #include <sys/user.h>
36 #include <sys/bootconf.h>
37 #include <sys/modctl.h>
38 #include <sys/elf.h>
39 #include <sys/kobj.h>
40 #include <sys/kobj_impl.h>
41 #include <sys/sdt.h>
42
43 #include "krtld/reloc.h"
44
45 #define SDT_RESTORE_MASK 0xc1f80000
46 #define SDT_RESTORE 0x81e80000
47 #define SDT_NOP 0x01000000
48 #define SDT_RET 0x81c7e008
49 #define SDT_RETL 0x81c3e008
50 #define SDT_RDO7_MASK 0xbf000000
51 #define SDT_RDO7 0x9e000000
52
53 static int
sdt_reloc_resolve(struct module * mp,char * symname,uint32_t * instr,long roff)54 sdt_reloc_resolve(struct module *mp, char *symname, uint32_t *instr, long roff)
55 {
56 sdt_probedesc_t *sdp;
57
58 /*
59 * The "statically defined tracing" (SDT) provider for DTrace.
60 * The SDT mechanism works by replacing calls to the
61 * undefined routine __dtrace_probe_[name] with nop instructions.
62 * The relocations are logged, and SDT itself will later patch the
63 * running binary appropriately.
64 */
65 if (strncmp(symname, sdt_prefix, strlen(sdt_prefix)) != 0)
66 return (1);
67
68 symname += strlen(sdt_prefix);
69
70 sdp = kobj_alloc(sizeof (sdt_probedesc_t), KM_WAIT);
71 sdp->sdpd_name = kobj_alloc(strlen(symname) + 1, KM_WAIT);
72 bcopy(symname, sdp->sdpd_name, strlen(symname) + 1);
73
74 if ((uint32_t *)roff == instr) {
75 /*
76 * This isn't an offset -- it's an absolute value. (This is
77 * typically only true for "unix".) We need to convert the
78 * value into an offset from mp->text.
79 */
80 roff -= (uintptr_t)mp->text;
81 }
82
83 sdp->sdpd_offset = roff;
84
85 sdp->sdpd_next = mp->sdt_probes;
86 mp->sdt_probes = sdp;
87
88 /*
89 * If the next instruction is a restore (any variant), then the probe
90 * point is being tail-called. Instead of patching the call to be a
91 * NOP, we must patch it to be a ret. If the next instruction is
92 * writing to %o7, it must be a tail call from a leaf; we must patch
93 * the instruction to be a retl.
94 */
95 if ((*(instr + 1) & SDT_RESTORE_MASK) == SDT_RESTORE) {
96 *instr = SDT_RET;
97 } else if ((*(instr + 1) & SDT_RDO7_MASK) == SDT_RDO7) {
98 *instr = SDT_RETL;
99 } else {
100 *instr = SDT_NOP;
101 }
102
103 return (0);
104 }
105
106 int
do_relocate(struct module * mp,char * reltbl,int nreloc,int relocsize,Addr baseaddr)107 do_relocate(struct module *mp, char *reltbl, int nreloc, int relocsize,
108 Addr baseaddr)
109 {
110 Word stndx;
111 long off, roff;
112 uintptr_t reladdr, rend;
113 uint_t rtype;
114 Elf64_Sxword addend;
115 Addr value, destination;
116 Sym *symref;
117 int symnum;
118 int err = 0;
119
120 reladdr = (uintptr_t)reltbl;
121 rend = reladdr + nreloc * relocsize;
122
123 #ifdef KOBJ_DEBUG
124 if (kobj_debug & D_RELOCATIONS) {
125 _kobj_printf(ops, "krtld:\ttype\t\t\toffset\t addend"
126 " symbol\n");
127 _kobj_printf(ops, "krtld:\t\t\t\t\t value\n");
128 }
129 #endif
130 destination = baseaddr;
131
132 /*
133 * If this machine is loading a module through an alternate address
134 * we need to compute the spot where the actual relocation will
135 * take place.
136 */
137 if (mp->destination) {
138 int i;
139 Shdr * shp;
140 shp = (Shdr *)mp->shdrs;
141 for (i = 0; i < mp->hdr.e_shnum; i++, shp++) {
142 if (shp->sh_addr == baseaddr) {
143 if ((shp->sh_flags & SHF_ALLOC) &&
144 !(shp->sh_flags & SHF_WRITE))
145 destination = (Addr)mp->destination +
146 (baseaddr - (Addr)mp->text);
147 break;
148 }
149 }
150 }
151
152 symnum = -1;
153 /* loop through relocations */
154 while (reladdr < rend) {
155
156 symnum++;
157 rtype = ELF_R_TYPE(((Rela *)reladdr)->r_info);
158 roff = off = ((Rela *)reladdr)->r_offset;
159 stndx = ELF_R_SYM(((Rela *)reladdr)->r_info);
160 if (stndx >= mp->nsyms) {
161 _kobj_printf(ops,
162 "do_relocate: bad strndx %d\n", symnum);
163 return (-1);
164 }
165 if ((rtype > R_SPARC_NUM) || IS_TLS_INS(rtype)) {
166 _kobj_printf(ops, "krtld: invalid relocation type %d",
167 rtype);
168 _kobj_printf(ops, " at 0x%llx:", (u_longlong_t)off);
169 _kobj_printf(ops, " file=%s\n", mp->filename);
170 err = 1;
171 continue;
172 }
173 addend = (long)(((Rela *)reladdr)->r_addend);
174 reladdr += relocsize;
175
176
177 #ifdef KOBJ_DEBUG
178 if (kobj_debug & D_RELOCATIONS) {
179 Sym *symp;
180 symp = (Sym *)
181 (mp->symtbl+(stndx * mp->symhdr->sh_entsize));
182 _kobj_printf(ops, "krtld:\t%s",
183 conv_reloc_SPARC_type(rtype));
184 _kobj_printf(ops, "\t0x%8llx", (u_longlong_t)off);
185 _kobj_printf(ops, " 0x%8llx", (u_longlong_t)addend);
186 _kobj_printf(ops, " %s\n",
187 (const char *)mp->strings + symp->st_name);
188 }
189 #endif
190
191 if (rtype == R_SPARC_NONE)
192 continue;
193
194 if (!(mp->flags & KOBJ_EXEC))
195 off += destination;
196
197 /*
198 * if R_SPARC_RELATIVE, simply add base addr
199 * to reloc location
200 */
201 if (rtype == R_SPARC_RELATIVE) {
202 value = baseaddr;
203 } else {
204 /*
205 * get symbol table entry - if symbol is local
206 * value is base address of this object
207 */
208 symref = (Sym *)
209 (mp->symtbl+(stndx * mp->symhdr->sh_entsize));
210 if (ELF_ST_BIND(symref->st_info) == STB_LOCAL) {
211 /* *** this is different for .o and .so */
212 value = symref->st_value;
213 } else {
214 /*
215 * It's global. Allow weak references. If
216 * the symbol is undefined, give dtrace
217 * a chance to see if it's a probe site,
218 * and fix it up if so.
219 */
220 if (symref->st_shndx == SHN_UNDEF &&
221 sdt_reloc_resolve(mp, mp->strings +
222 symref->st_name, (uint32_t *)off,
223 roff + ((uintptr_t)baseaddr -
224 (uintptr_t)mp->text)) == 0)
225 continue;
226
227 if (symref->st_shndx == SHN_UNDEF) {
228 if (ELF_ST_BIND(symref->st_info)
229 != STB_WEAK) {
230 _kobj_printf(ops,
231 "not found: %s\n",
232 mp->strings +
233 symref->st_name);
234 err = 1;
235 }
236 continue;
237 } else { /* symbol found - relocate */
238 /*
239 * calculate location of definition
240 * - symbol value plus base address of
241 * containing shared object
242 */
243 value = symref->st_value;
244 } /* end else symbol found */
245 }
246 } /* end not R_SPARC_RELATIVE */
247
248 value += addend;
249 if (IS_EXTOFFSET(rtype)) {
250 value +=
251 (Word) ELF_R_TYPE_DATA(((Rela *)reladdr)->r_info);
252 }
253
254 /*
255 * calculate final value -
256 * if PC-relative, subtract ref addr
257 */
258 if (IS_PC_RELATIVE(rtype)) {
259 if (mp->destination)
260 value -= (baseaddr + roff);
261 else
262 value -= off;
263 }
264
265 #ifdef KOBJ_DEBUG
266 if (kobj_debug & D_RELOCATIONS) {
267 _kobj_printf(ops, "krtld:\t\t\t\t0x%8llx",
268 (u_longlong_t)off);
269 _kobj_printf(ops, " 0x%8llx\n", (u_longlong_t)value);
270 }
271 #endif
272 if (do_reloc_krtld(rtype, (unsigned char *)off, (Xword *)&value,
273 (const char *)mp->strings + symref->st_name,
274 mp->filename) == 0)
275 err = 1;
276 } /* end of while loop */
277
278 if (err)
279 return (-1);
280
281 return (0);
282 }
283
284 int
do_relocations(struct module * mp)285 do_relocations(struct module *mp)
286 {
287 uint_t shn;
288 Shdr *shp, *rshp;
289 uint_t nreloc;
290
291 /* do the relocations */
292 for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
293 rshp = (Shdr *)
294 (mp->shdrs + shn * mp->hdr.e_shentsize);
295 if (rshp->sh_type == SHT_REL) {
296 _kobj_printf(ops, "%s can't process type SHT_REL\n",
297 mp->filename);
298 return (-1);
299 }
300 if (rshp->sh_type != SHT_RELA)
301 continue;
302 if (rshp->sh_link != mp->symtbl_section) {
303 _kobj_printf(ops, "%s reloc for non-default symtab\n",
304 mp->filename);
305 return (-1);
306 }
307 if (rshp->sh_info >= mp->hdr.e_shnum) {
308 _kobj_printf(ops, "do_relocations: %s ", mp->filename);
309 _kobj_printf(ops, " sh_info out of range %d\n", shn);
310 goto bad;
311 }
312 nreloc = rshp->sh_size / rshp->sh_entsize;
313
314 /* get the section header that this reloc table refers to */
315 shp = (Shdr *)
316 (mp->shdrs + rshp->sh_info * mp->hdr.e_shentsize);
317 /*
318 * Do not relocate any section that isn't loaded into memory.
319 * Most commonly this will skip over the .rela.stab* sections
320 */
321 if (!(shp->sh_flags & SHF_ALLOC))
322 continue;
323 #ifdef KOBJ_DEBUG
324 if (kobj_debug & D_RELOCATIONS) {
325 _kobj_printf(ops, "krtld: relocating: file=%s ",
326 mp->filename);
327 _kobj_printf(ops, " section=%d\n", shn);
328 }
329 #endif
330 if (do_relocate(mp, (char *)rshp->sh_addr, nreloc,
331 rshp->sh_entsize, shp->sh_addr) < 0) {
332 _kobj_printf(ops,
333 "do_relocations: %s do_relocate failed\n",
334 mp->filename);
335 goto bad;
336 }
337 kobj_free((void *)rshp->sh_addr, rshp->sh_size);
338 rshp->sh_addr = 0;
339 }
340 mp->flags |= KOBJ_RELOCATED;
341 return (0);
342 bad:
343 kobj_free((void *)rshp->sh_addr, rshp->sh_size);
344 rshp->sh_addr = 0;
345 return (-1);
346 }
347