usr/src/uts/sparc/krtld/kobj_reloc.c

   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
  56 extern 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  */
  64 static int
  65 tnf_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
  94 static int
  95 sdt_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
 148 int
 149 /* ARGSUSED2 */
 150 do_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
 339 int
 340 do_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);
 397 bad:
 398         kobj_free((void *)rshp->sh_addr, rshp->sh_size);
 399         rshp->sh_addr = 0;
 400         return (-1);
 401 }