OpenSolaris_b135/uts/sparc/krtld/kobj_reloc.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* SPARC relocation code.
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/bootconf.h>
#include <sys/modctl.h>
#include <sys/elf.h>
#include <sys/kobj.h>
#include <sys/kobj_impl.h>
#include <sys/tnf.h>
#include <sys/tnf_probe.h>
#include <sys/sdt.h>
#include "krtld/reloc.h"
/*
* Probe discovery support
*/
#define PROBE_MARKER_SYMBOL "__tnf_probe_version_1"
#define TAG_MARKER_SYMBOL "__tnf_tag_version_1"
extern int tnf_splice_probes(int, tnf_probe_control_t *, tnf_tag_data_t *);
/*
* The kernel run-time linker calls this to try to resolve a reference
* it can't otherwise resolve. We see if it's marking a probe control
* block or a probe tag block; if so, we do the resolution and return 0.
* If not, we return 1 to show that we can't resolve it, either.
*/
static int
tnf_reloc_resolve(char *symname, Addr *value_p,
Elf64_Sxword *addend_p,
long offset,
tnf_probe_control_t **probelist,
tnf_tag_data_t **taglist)
{
if (strcmp(symname, PROBE_MARKER_SYMBOL) == 0) {
*addend_p = 0;
((tnf_probe_control_t *)offset)->next = *probelist;
*probelist = (tnf_probe_control_t *)offset;
return (0);
}
if (strcmp(symname, TAG_MARKER_SYMBOL) == 0) {
*addend_p = 0;
*value_p = (Addr)*taglist;
*taglist = (tnf_tag_data_t *)offset;
return (0);
}
return (1);
}
#define SDT_RESTORE_MASK 0xc1f80000
#define SDT_RESTORE 0x81e80000
#define SDT_NOP 0x01000000
#define SDT_RET 0x81c7e008
#define SDT_RETL 0x81c3e008
#define SDT_RDO7_MASK 0xbf000000
#define SDT_RDO7 0x9e000000
static int
sdt_reloc_resolve(struct module *mp, char *symname, uint32_t *instr, long roff)
{
sdt_probedesc_t *sdp;
/*
* The "statically defined tracing" (SDT) provider for DTrace uses
* a mechanism similar to TNF, but somewhat simpler. (Surprise,
* surprise.) The SDT mechanism works by replacing calls to the
* undefined routine __dtrace_probe_[name] with nop instructions.
* The relocations are logged, and SDT itself will later patch the
* running binary appropriately.
*/
if (strncmp(symname, sdt_prefix, strlen(sdt_prefix)) != 0)
return (1);
symname += strlen(sdt_prefix);
sdp = kobj_alloc(sizeof (sdt_probedesc_t), KM_WAIT);
sdp->sdpd_name = kobj_alloc(strlen(symname) + 1, KM_WAIT);
bcopy(symname, sdp->sdpd_name, strlen(symname) + 1);
if ((uint32_t *)roff == instr) {
/*
* This isn't an offset -- it's an absolute value. (This is
* typically only true for "unix".) We need to convert the
* value into an offset from mp->text.
*/
roff -= (uintptr_t)mp->text;
}
sdp->sdpd_offset = roff;
sdp->sdpd_next = mp->sdt_probes;
mp->sdt_probes = sdp;
/*
* If the next instruction is a restore (any variant), then the probe
* point is being tail-called. Instead of patching the call to be a
* NOP, we must patch it to be a ret. If the next instruction is
* writing to %o7, it must be a tail call from a leaf; we must patch
* the instruction to be a retl.
*/
if ((*(instr + 1) & SDT_RESTORE_MASK) == SDT_RESTORE) {
*instr = SDT_RET;
} else if ((*(instr + 1) & SDT_RDO7_MASK) == SDT_RDO7) {
*instr = SDT_RETL;
} else {
*instr = SDT_NOP;
}
return (0);
}
int
/* ARGSUSED2 */
do_relocate(
struct module *mp,
char *reltbl,
Word relshtype,
int nreloc,
int relocsize,
Addr baseaddr)
{
Word stndx;
long off, roff;
uintptr_t reladdr, rend;
uint_t rtype;
Elf64_Sxword addend;
Addr value, destination;
Sym *symref;
int symnum;
int err = 0;
tnf_probe_control_t *probelist = NULL;
tnf_tag_data_t *taglist = NULL;
reladdr = (uintptr_t)reltbl;
rend = reladdr + nreloc * relocsize;
#ifdef KOBJ_DEBUG
if (kobj_debug & D_RELOCATIONS) {
_kobj_printf(ops, "krtld:\ttype\t\t\toffset\t addend"
" symbol\n");
_kobj_printf(ops, "krtld:\t\t\t\t\t value\n");
}
#endif
destination = baseaddr;
/*
* If this machine is loading a module through an alternate address
* we need to compute the spot where the actual relocation will
* take place.
*/
if (mp->destination) {
int i;
Shdr * shp;
shp = (Shdr *)mp->shdrs;
for (i = 0; i < mp->hdr.e_shnum; i++, shp++) {
if (shp->sh_addr == baseaddr) {
if ((shp->sh_flags & SHF_ALLOC) &&
!(shp->sh_flags & SHF_WRITE))
destination = (Addr)mp->destination +
(baseaddr - (Addr)mp->text);
break;
}
}
}
symnum = -1;
/* loop through relocations */
while (reladdr < rend) {
symnum++;
rtype = ELF_R_TYPE(((Rela *)reladdr)->r_info);
roff = off = ((Rela *)reladdr)->r_offset;
stndx = ELF_R_SYM(((Rela *)reladdr)->r_info);
if (stndx >= mp->nsyms) {
_kobj_printf(ops,
"do_relocate: bad strndx %d\n", symnum);
return (-1);
}
if ((rtype > R_SPARC_NUM) || IS_TLS_INS(rtype)) {
_kobj_printf(ops, "krtld: invalid relocation type %d",
rtype);
_kobj_printf(ops, " at 0x%llx:", off);
_kobj_printf(ops, " file=%s\n", mp->filename);
err = 1;
continue;
}
addend = (long)(((Rela *)reladdr)->r_addend);
reladdr += relocsize;
#ifdef KOBJ_DEBUG
if (kobj_debug & D_RELOCATIONS) {
Sym *symp;
symp = (Sym *)
(mp->symtbl+(stndx * mp->symhdr->sh_entsize));
_kobj_printf(ops, "krtld:\t%s",
conv_reloc_SPARC_type(rtype));
_kobj_printf(ops, "\t0x%8llx", off);
_kobj_printf(ops, " 0x%8llx", addend);
_kobj_printf(ops, " %s\n",
(const char *)mp->strings + symp->st_name);
}
#endif
if (rtype == R_SPARC_NONE)
continue;
if (!(mp->flags & KOBJ_EXEC))
off += destination;
/*
* if R_SPARC_RELATIVE, simply add base addr
* to reloc location
*/
if (rtype == R_SPARC_RELATIVE) {
value = baseaddr;
} else {
/*
* get symbol table entry - if symbol is local
* value is base address of this object
*/
symref = (Sym *)
(mp->symtbl+(stndx * mp->symhdr->sh_entsize));
if (ELF_ST_BIND(symref->st_info) == STB_LOCAL) {
/* *** this is different for .o and .so */
value = symref->st_value;
} else {
/*
* It's global. Allow weak references. If
* the symbol is undefined, give TNF (the
* kernel probes facility) a chance to see
* if it's a probe site, and fix it up if so.
*/
if (symref->st_shndx == SHN_UNDEF &&
sdt_reloc_resolve(mp, mp->strings +
symref->st_name, (uint32_t *)off,
roff + ((uintptr_t)baseaddr -
(uintptr_t)mp->text)) == 0)
continue;
if (symref->st_shndx == SHN_UNDEF &&
tnf_reloc_resolve(mp->strings +
symref->st_name, &symref->st_value,
&addend, off, &probelist, &taglist) != 0) {
if (ELF_ST_BIND(symref->st_info)
!= STB_WEAK) {
_kobj_printf(ops,
"not found: %s\n",
mp->strings +
symref->st_name);
err = 1;
}
continue;
} else { /* symbol found - relocate */
/*
* calculate location of definition
* - symbol value plus base address of
* containing shared object
*/
value = symref->st_value;
} /* end else symbol found */
}
} /* end not R_SPARC_RELATIVE */
value += addend;
if (IS_EXTOFFSET(rtype)) {
value +=
(Word) ELF_R_TYPE_DATA(((Rela *)reladdr)->r_info);
}
/*
* calculate final value -
* if PC-relative, subtract ref addr
*/
if (IS_PC_RELATIVE(rtype)) {
if (mp->destination)
value -= (baseaddr + roff);
else
value -= off;
}
#ifdef KOBJ_DEBUG
if (kobj_debug & D_RELOCATIONS) {
_kobj_printf(ops, "krtld:\t\t\t\t0x%8llx", off);
_kobj_printf(ops, " 0x%8llx\n", value);
}
#endif
if (do_reloc_krtld(rtype, (unsigned char *)off, (Xword *)&value,
(const char *)mp->strings + symref->st_name,
mp->filename) == 0)
err = 1;
} /* end of while loop */
if (err)
return (-1);
if (tnf_splice_probes(mp->flags & KOBJ_PRIM, probelist, taglist))
mp->flags |= KOBJ_TNF_PROBE;
return (0);
}
int
do_relocations(struct module *mp)
{
uint_t shn;
Shdr *shp, *rshp;
uint_t nreloc;
/* do the relocations */
for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
rshp = (Shdr *)
(mp->shdrs + shn * mp->hdr.e_shentsize);
if (rshp->sh_type == SHT_REL) {
_kobj_printf(ops, "%s can't process type SHT_REL\n",
mp->filename);
return (-1);
}
if (rshp->sh_type != SHT_RELA)
continue;
if (rshp->sh_link != mp->symtbl_section) {
_kobj_printf(ops, "%s reloc for non-default symtab\n",
mp->filename);
return (-1);
}
if (rshp->sh_info >= mp->hdr.e_shnum) {
_kobj_printf(ops, "do_relocations: %s ", mp->filename);
_kobj_printf(ops, " sh_info out of range %lld\n", shn);
goto bad;
}
nreloc = rshp->sh_size / rshp->sh_entsize;
/* get the section header that this reloc table refers to */
shp = (Shdr *)
(mp->shdrs + rshp->sh_info * mp->hdr.e_shentsize);
/*
* Do not relocate any section that isn't loaded into memory.
* Most commonly this will skip over the .rela.stab* sections
*/
if (!(shp->sh_flags & SHF_ALLOC))
continue;
#ifdef KOBJ_DEBUG
if (kobj_debug & D_RELOCATIONS) {
_kobj_printf(ops, "krtld: relocating: file=%s ",
mp->filename);
_kobj_printf(ops, " section=%d\n", shn);
}
#endif
if (do_relocate(mp, (char *)rshp->sh_addr, rshp->sh_type,
nreloc, rshp->sh_entsize, shp->sh_addr) < 0) {
_kobj_printf(ops,
"do_relocations: %s do_relocate failed\n",
mp->filename);
goto bad;
}
kobj_free((void *)rshp->sh_addr, rshp->sh_size);
rshp->sh_addr = 0;
}
mp->flags |= KOBJ_RELOCATED;
return (0);
bad:
kobj_free((void *)rshp->sh_addr, rshp->sh_size);
rshp->sh_addr = 0;
return (-1);
}