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#pragma ident	"%Z%%M%	%I%	%E% SMI"
28
29/*
30 * SPARC relocation code.
31 */
32
33#include <sys/types.h>
34#include <sys/param.h>
35#include <sys/sysmacros.h>
36#include <sys/systm.h>
37#include <sys/user.h>
38#include <sys/bootconf.h>
39#include <sys/modctl.h>
40#include <sys/elf.h>
41#include <sys/kobj.h>
42#include <sys/kobj_impl.h>
43#include <sys/tnf.h>
44#include <sys/tnf_probe.h>
45#include <sys/sdt.h>
46
47#include "krtld/reloc.h"
48
49
50/*
51 * Probe discovery support
52 */
53#define	PROBE_MARKER_SYMBOL	"__tnf_probe_version_1"
54#define	TAG_MARKER_SYMBOL	"__tnf_tag_version_1"
55
56extern int tnf_splice_probes(int, tnf_probe_control_t *, tnf_tag_data_t *);
57
58/*
59 * The kernel run-time linker calls this to try to resolve a reference
60 * it can't otherwise resolve.  We see if it's marking a probe control
61 * block or a probe tag block; if so, we do the resolution and return 0.
62 * If not, we return 1 to show that we can't resolve it, either.
63 */
64static int
65tnf_reloc_resolve(char *symname, Addr *value_p,
66    Elf64_Sxword *addend_p,
67    long offset,
68    tnf_probe_control_t **probelist,
69    tnf_tag_data_t **taglist)
70{
71	if (strcmp(symname, PROBE_MARKER_SYMBOL) == 0) {
72		*addend_p = 0;
73		((tnf_probe_control_t *)offset)->next = *probelist;
74		*probelist = (tnf_probe_control_t *)offset;
75		return (0);
76	}
77	if (strcmp(symname, TAG_MARKER_SYMBOL) == 0) {
78		*addend_p = 0;
79		*value_p = (Addr)*taglist;
80		*taglist = (tnf_tag_data_t *)offset;
81		return (0);
82	}
83	return (1);
84}
85
86#define	SDT_RESTORE_MASK	0xc1f80000
87#define	SDT_RESTORE		0x81e80000
88#define	SDT_NOP			0x01000000
89#define	SDT_RET			0x81c7e008
90#define	SDT_RETL		0x81c3e008
91#define	SDT_RDO7_MASK		0xbf000000
92#define	SDT_RDO7		0x9e000000
93
94static int
95sdt_reloc_resolve(struct module *mp, char *symname, uint32_t *instr, long roff)
96{
97	sdt_probedesc_t *sdp;
98
99	/*
100	 * The "statically defined tracing" (SDT) provider for DTrace uses
101	 * a mechanism similar to TNF, but somewhat simpler.  (Surprise,
102	 * surprise.)  The SDT mechanism works by replacing calls to the
103	 * undefined routine __dtrace_probe_[name] with nop instructions.
104	 * The relocations are logged, and SDT itself will later patch the
105	 * running binary appropriately.
106	 */
107	if (strncmp(symname, sdt_prefix, strlen(sdt_prefix)) != 0)
108		return (1);
109
110	symname += strlen(sdt_prefix);
111
112	sdp = kobj_alloc(sizeof (sdt_probedesc_t), KM_WAIT);
113	sdp->sdpd_name = kobj_alloc(strlen(symname) + 1, KM_WAIT);
114	bcopy(symname, sdp->sdpd_name, strlen(symname) + 1);
115
116	if ((uint32_t *)roff == instr) {
117		/*
118		 * This isn't an offset -- it's an absolute value.  (This is
119		 * typically only true for "unix".)  We need to convert the
120		 * value into an offset from mp->text.
121		 */
122		roff -= (uintptr_t)mp->text;
123	}
124
125	sdp->sdpd_offset = roff;
126
127	sdp->sdpd_next = mp->sdt_probes;
128	mp->sdt_probes = sdp;
129
130	/*
131	 * If the next instruction is a restore (any variant), then the probe
132	 * point is being tail-called.  Instead of patching the call to be a
133	 * NOP, we must patch it to be a ret.  If the next instruction is
134	 * writing to %o7, it must be a tail call from a leaf; we must patch
135	 * the instruction to be a retl.
136	 */
137	if ((*(instr + 1) & SDT_RESTORE_MASK) == SDT_RESTORE) {
138		*instr = SDT_RET;
139	} else if ((*(instr + 1) & SDT_RDO7_MASK) == SDT_RDO7) {
140		*instr = SDT_RETL;
141	} else {
142		*instr = SDT_NOP;
143	}
144
145	return (0);
146}
147
148int
149/* ARGSUSED2 */
150do_relocate(
151	struct module *mp,
152	char *reltbl,
153	Word relshtype,
154	int nreloc,
155	int relocsize,
156	Addr baseaddr)
157{
158	Word stndx;
159	long off, roff;
160	uintptr_t reladdr, rend;
161	uint_t rtype;
162	Elf64_Sxword addend;
163	Addr value, destination;
164	Sym *symref;
165	int symnum;
166	int err = 0;
167	tnf_probe_control_t *probelist = NULL;
168	tnf_tag_data_t *taglist = NULL;
169
170	reladdr = (uintptr_t)reltbl;
171	rend = reladdr + nreloc * relocsize;
172
173#ifdef	KOBJ_DEBUG
174	if (kobj_debug & D_RELOCATIONS) {
175		_kobj_printf(ops, "krtld:\ttype\t\t\toffset\t   addend"
176		    "      symbol\n");
177		_kobj_printf(ops, "krtld:\t\t\t\t\t   value\n");
178	}
179#endif
180	destination = baseaddr;
181
182	/*
183	 * If this machine is loading a module through an alternate address
184	 * we need to compute the spot where the actual relocation will
185	 * take place.
186	 */
187	if (mp->destination) {
188		int i;
189		Shdr * shp;
190		shp = (Shdr *)mp->shdrs;
191		for (i = 0; i < mp->hdr.e_shnum; i++, shp++) {
192			if (shp->sh_addr == baseaddr) {
193				if ((shp->sh_flags & SHF_ALLOC) &&
194				    !(shp->sh_flags & SHF_WRITE))
195					destination = (Addr)mp->destination +
196					    (baseaddr - (Addr)mp->text);
197				break;
198			}
199		}
200	}
201
202	symnum = -1;
203	/* loop through relocations */
204	while (reladdr < rend) {
205
206		symnum++;
207		rtype = ELF_R_TYPE(((Rela *)reladdr)->r_info);
208		roff = off = ((Rela *)reladdr)->r_offset;
209		stndx = ELF_R_SYM(((Rela *)reladdr)->r_info);
210		if (stndx >= mp->nsyms) {
211			_kobj_printf(ops,
212			    "do_relocate: bad strndx %d\n", symnum);
213			return (-1);
214		}
215		if ((rtype > R_SPARC_NUM) || IS_TLS_INS(rtype)) {
216			_kobj_printf(ops, "krtld: invalid relocation type %d",
217			    rtype);
218			_kobj_printf(ops, " at 0x%llx:", off);
219			_kobj_printf(ops, " file=%s\n", mp->filename);
220			err = 1;
221			continue;
222		}
223		addend = (long)(((Rela *)reladdr)->r_addend);
224		reladdr += relocsize;
225
226
227#ifdef	KOBJ_DEBUG
228		if (kobj_debug & D_RELOCATIONS) {
229			Sym *symp;
230			symp = (Sym *)
231			    (mp->symtbl+(stndx * mp->symhdr->sh_entsize));
232			_kobj_printf(ops, "krtld:\t%s",
233			    conv_reloc_SPARC_type(rtype));
234			_kobj_printf(ops, "\t0x%8llx", off);
235			_kobj_printf(ops, " 0x%8llx", addend);
236			_kobj_printf(ops, "  %s\n",
237			    (const char *)mp->strings + symp->st_name);
238		}
239#endif
240
241		if (rtype == R_SPARC_NONE)
242			continue;
243
244		if (!(mp->flags & KOBJ_EXEC))
245			off += destination;
246
247		/*
248		 * if R_SPARC_RELATIVE, simply add base addr
249		 * to reloc location
250		 */
251		if (rtype == R_SPARC_RELATIVE) {
252			value = baseaddr;
253		} else {
254			/*
255			 * get symbol table entry - if symbol is local
256			 * value is base address of this object
257			 */
258			symref = (Sym *)
259			    (mp->symtbl+(stndx * mp->symhdr->sh_entsize));
260			if (ELF_ST_BIND(symref->st_info) == STB_LOCAL) {
261				/* *** this is different for .o and .so */
262				value = symref->st_value;
263			} else {
264				/*
265				 * It's global. Allow weak references.  If
266				 * the symbol is undefined, give TNF (the
267				 * kernel probes facility) a chance to see
268				 * if it's a probe site, and fix it up if so.
269				 */
270				if (symref->st_shndx == SHN_UNDEF &&
271				    sdt_reloc_resolve(mp, mp->strings +
272				    symref->st_name, (uint32_t *)off,
273				    roff + ((uintptr_t)baseaddr -
274				    (uintptr_t)mp->text)) == 0)
275					continue;
276
277				if (symref->st_shndx == SHN_UNDEF &&
278				    tnf_reloc_resolve(mp->strings +
279				    symref->st_name, &symref->st_value,
280				    &addend, off, &probelist, &taglist) != 0) {
281					if (ELF_ST_BIND(symref->st_info)
282					    != STB_WEAK) {
283						_kobj_printf(ops,
284						    "not found: %s\n",
285						    mp->strings +
286						    symref->st_name);
287						err = 1;
288					}
289					continue;
290				} else { /* symbol found  - relocate */
291					/*
292					 * calculate location of definition
293					 * - symbol value plus base address of
294					 * containing shared object
295					 */
296					value = symref->st_value;
297				} /* end else symbol found */
298			}
299		} /* end not R_SPARC_RELATIVE */
300
301		value += addend;
302		if (IS_EXTOFFSET(rtype)) {
303			value +=
304			    (Word) ELF_R_TYPE_DATA(((Rela *)reladdr)->r_info);
305		}
306
307		/*
308		 * calculate final value -
309		 * if PC-relative, subtract ref addr
310		 */
311		if (IS_PC_RELATIVE(rtype)) {
312			if (mp->destination)
313				value -= (baseaddr + roff);
314			else
315				value -= off;
316		}
317
318#ifdef	KOBJ_DEBUG
319		if (kobj_debug & D_RELOCATIONS) {
320			_kobj_printf(ops, "krtld:\t\t\t\t0x%8llx", off);
321			_kobj_printf(ops, " 0x%8llx\n", value);
322		}
323#endif
324		if (do_reloc_krtld(rtype, (unsigned char *)off, (Xword *)&value,
325		    (const char *)mp->strings + symref->st_name,
326		    mp->filename) == 0)
327			err = 1;
328	} /* end of while loop */
329
330	if (err)
331		return (-1);
332
333	if (tnf_splice_probes(mp->flags & KOBJ_PRIM, probelist, taglist))
334		mp->flags |= KOBJ_TNF_PROBE;
335
336	return (0);
337}
338
339int
340do_relocations(struct module *mp)
341{
342	uint_t shn;
343	Shdr *shp, *rshp;
344	uint_t nreloc;
345
346	/* do the relocations */
347	for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
348		rshp = (Shdr *)
349		    (mp->shdrs + shn * mp->hdr.e_shentsize);
350		if (rshp->sh_type == SHT_REL) {
351			_kobj_printf(ops, "%s can't process type SHT_REL\n",
352			    mp->filename);
353			return (-1);
354		}
355		if (rshp->sh_type != SHT_RELA)
356			continue;
357		if (rshp->sh_link != mp->symtbl_section) {
358			_kobj_printf(ops, "%s reloc for non-default symtab\n",
359			    mp->filename);
360			return (-1);
361		}
362		if (rshp->sh_info >= mp->hdr.e_shnum) {
363			_kobj_printf(ops, "do_relocations: %s ", mp->filename);
364			_kobj_printf(ops, " sh_info out of range %lld\n", shn);
365			goto bad;
366		}
367		nreloc = rshp->sh_size / rshp->sh_entsize;
368
369		/* get the section header that this reloc table refers to */
370		shp = (Shdr *)
371		    (mp->shdrs + rshp->sh_info * mp->hdr.e_shentsize);
372		/*
373		 * Do not relocate any section that isn't loaded into memory.
374		 * Most commonly this will skip over the .rela.stab* sections
375		 */
376		if (!(shp->sh_flags & SHF_ALLOC))
377			continue;
378#ifdef	KOBJ_DEBUG
379		if (kobj_debug & D_RELOCATIONS) {
380			_kobj_printf(ops, "krtld: relocating: file=%s ",
381			    mp->filename);
382			_kobj_printf(ops, " section=%d\n", shn);
383		}
384#endif
385		if (do_relocate(mp, (char *)rshp->sh_addr, rshp->sh_type,
386		    nreloc, rshp->sh_entsize, shp->sh_addr) < 0) {
387			_kobj_printf(ops,
388			    "do_relocations: %s do_relocate failed\n",
389			    mp->filename);
390			goto bad;
391		}
392		kobj_free((void *)rshp->sh_addr, rshp->sh_size);
393		rshp->sh_addr = 0;
394	}
395	mp->flags |= KOBJ_RELOCATED;
396	return (0);
397bad:
398	kobj_free((void *)rshp->sh_addr, rshp->sh_size);
399	rshp->sh_addr = 0;
400	return (-1);
401}
402