libexec/rtld-elf/powerpc64/reloc.c

   1 /*      $NetBSD: ppc_reloc.c,v 1.10 2001/09/10 06:09:41 mycroft Exp $   */
   2
   3 /*-
   4  * Copyright (C) 1998   Tsubai Masanari
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/mman.h>
  34
  35 #include <errno.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40 #include <machine/cpu.h>
  41 #include <machine/md_var.h>
  42
  43 #include "debug.h"
  44 #include "rtld.h"
  45
  46 struct funcdesc {
  47         Elf_Addr addr;
  48         Elf_Addr toc;
  49         Elf_Addr env;
  50 };
  51
  52 /*
  53  * Process the R_PPC_COPY relocations
  54  */
  55 int
  56 do_copy_relocations(Obj_Entry *dstobj)
  57 {
  58         const Elf_Rela *relalim;
  59         const Elf_Rela *rela;
  60
  61         /*
  62          * COPY relocs are invalid outside of the main program
  63          */
  64         assert(dstobj->mainprog);
  65
  66         relalim = (const Elf_Rela *) ((caddr_t) dstobj->rela +
  67             dstobj->relasize);
  68         for (rela = dstobj->rela;  rela < relalim;  rela++) {
  69                 void *dstaddr;
  70                 const Elf_Sym *dstsym;
  71                 const char *name;
  72                 size_t size;
  73                 const void *srcaddr;
  74                 const Elf_Sym *srcsym = NULL;
  75                 const Obj_Entry *srcobj, *defobj;
  76                 SymLook req;
  77                 int res;
  78
  79                 if (ELF_R_TYPE(rela->r_info) != R_PPC_COPY) {
  80                         continue;
  81                 }
  82
  83                 dstaddr = (void *) (dstobj->relocbase + rela->r_offset);
  84                 dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
  85                 name = dstobj->strtab + dstsym->st_name;
  86                 size = dstsym->st_size;
  87                 symlook_init(&req, name);
  88                 req.ventry = fetch_ventry(dstobj, ELF_R_SYM(rela->r_info));
  89
  90                 for (srcobj = dstobj->next;  srcobj != NULL;
  91                      srcobj = srcobj->next) {
  92                         res = symlook_obj(&req, srcobj);
  93                         if (res == 0) {
  94                                 srcsym = req.sym_out;
  95                                 defobj = req.defobj_out;
  96                                 break;
  97                         }
  98                 }
  99
 100                 if (srcobj == NULL) {
 101                         _rtld_error("Undefined symbol \"%s\" "
 102                                     " referenced from COPY"
 103                                     " relocation in %s", name, dstobj->path);
 104                         return (-1);
 105                 }
 106
 107                 srcaddr = (const void *) (defobj->relocbase+srcsym->st_value);
 108                 memcpy(dstaddr, srcaddr, size);
 109                 dbg("copy_reloc: src=%p,dst=%p,size=%zd\n",srcaddr,dstaddr,size);
 110         }
 111
 112         return (0);
 113 }
 114
 115
 116 /*
 117  * Perform early relocation of the run-time linker image
 118  */
 119 void
 120 reloc_non_plt_self(Elf_Dyn *dynp, Elf_Addr relocbase)
 121 {
 122         const Elf_Rela *rela = 0, *relalim;
 123         Elf_Addr relasz = 0;
 124         Elf_Addr *where;
 125
 126         /*
 127          * Extract the rela/relasz values from the dynamic section
 128          */
 129         for (; dynp->d_tag != DT_NULL; dynp++) {
 130                 switch (dynp->d_tag) {
 131                 case DT_RELA:
 132                         rela = (const Elf_Rela *)(relocbase+dynp->d_un.d_ptr);
 133                         break;
 134                 case DT_RELASZ:
 135                         relasz = dynp->d_un.d_val;
 136                         break;
 137                 }
 138         }
 139
 140         /*
 141          * Relocate these values
 142          */
 143         relalim = (const Elf_Rela *)((caddr_t)rela + relasz);
 144         for (; rela < relalim; rela++) {
 145                 where = (Elf_Addr *)(relocbase + rela->r_offset);
 146                 *where = (Elf_Addr)(relocbase + rela->r_addend);
 147         }
 148 }
 149
 150
 151 /*
 152  * Relocate a non-PLT object with addend.
 153  */
 154 static int
 155 reloc_nonplt_object(Obj_Entry *obj_rtld, Obj_Entry *obj, const Elf_Rela *rela,
 156     SymCache *cache, RtldLockState *lockstate)
 157 {
 158         Elf_Addr        *where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
 159         const Elf_Sym   *def;
 160         const Obj_Entry *defobj;
 161         Elf_Addr         tmp;
 162
 163         switch (ELF_R_TYPE(rela->r_info)) {
 164
 165         case R_PPC_NONE:
 166                 break;
 167
 168         case R_PPC64_UADDR64:    /* doubleword64 S + A */
 169         case R_PPC64_ADDR64:
 170         case R_PPC_GLOB_DAT:
 171                 def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 172                     false, cache, lockstate);
 173                 if (def == NULL) {
 174                         return (-1);
 175                 }
 176
 177                 tmp = (Elf_Addr)(defobj->relocbase + def->st_value +
 178                     rela->r_addend);
 179
 180                 /* Don't issue write if unnecessary; avoid COW page fault */
 181                 if (*where != tmp) {
 182                         *where = tmp;
 183                 }
 184                 break;
 185
 186         case R_PPC_RELATIVE:  /* doubleword64 B + A */
 187                 tmp = (Elf_Addr)(obj->relocbase + rela->r_addend);
 188
 189                 /* As above, don't issue write unnecessarily */
 190                 if (*where != tmp) {
 191                         *where = tmp;
 192                 }
 193                 break;
 194
 195         case R_PPC_COPY:
 196                 /*
 197                  * These are deferred until all other relocations
 198                  * have been done.  All we do here is make sure
 199                  * that the COPY relocation is not in a shared
 200                  * library.  They are allowed only in executable
 201                  * files.
 202                  */
 203                 if (!obj->mainprog) {
 204                         _rtld_error("%s: Unexpected R_COPY "
 205                                     " relocation in shared library",
 206                                     obj->path);
 207                         return (-1);
 208                 }
 209                 break;
 210
 211         case R_PPC_JMP_SLOT:
 212                 /*
 213                  * These will be handled by the plt/jmpslot routines
 214                  */
 215                 break;
 216
 217         case R_PPC64_DTPMOD64:
 218                 def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 219                     false, cache, lockstate);
 220
 221                 if (def == NULL)
 222                         return (-1);
 223
 224                 *where = (Elf_Addr) defobj->tlsindex;
 225
 226                 break;
 227
 228         case R_PPC64_TPREL64:
 229                 def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 230                     false, cache, lockstate);
 231
 232                 if (def == NULL)
 233                         return (-1);
 234
 235                 /*
 236                  * We lazily allocate offsets for static TLS as we
 237                  * see the first relocation that references the
 238                  * TLS block. This allows us to support (small
 239                  * amounts of) static TLS in dynamically loaded
 240                  * modules. If we run out of space, we generate an
 241                  * error.
 242                  */
 243                 if (!defobj->tls_done) {
 244                         if (!allocate_tls_offset((Obj_Entry*) defobj)) {
 245                                 _rtld_error("%s: No space available for static "
 246                                     "Thread Local Storage", obj->path);
 247                                 return (-1);
 248                         }
 249                 }
 250
 251                 *(Elf_Addr **)where = *where * sizeof(Elf_Addr)
 252                     + (Elf_Addr *)(def->st_value + rela->r_addend
 253                     + defobj->tlsoffset - TLS_TP_OFFSET);
 254
 255                 break;
 256
 257         case R_PPC64_DTPREL64:
 258                 def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 259                     false, cache, lockstate);
 260
 261                 if (def == NULL)
 262                         return (-1);
 263
 264                 *where += (Elf_Addr)(def->st_value + rela->r_addend
 265                     - TLS_DTV_OFFSET);
 266
 267                 break;
 268
 269         default:
 270                 _rtld_error("%s: Unsupported relocation type %ld"
 271                             " in non-PLT relocations\n", obj->path,
 272                             ELF_R_TYPE(rela->r_info));
 273                 return (-1);
 274         }
 275         return (0);
 276 }
 277
 278
 279 /*
 280  * Process non-PLT relocations
 281  */
 282 int
 283 reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, RtldLockState *lockstate)
 284 {
 285         const Elf_Rela *relalim;
 286         const Elf_Rela *rela;
 287         SymCache *cache;
 288         int bytes = obj->nchains * sizeof(SymCache);
 289         int r = -1;
 290
 291         /*
 292          * The dynamic loader may be called from a thread, we have
 293          * limited amounts of stack available so we cannot use alloca().
 294          */
 295         if (obj != obj_rtld) {
 296                 cache = mmap(NULL, bytes, PROT_READ|PROT_WRITE, MAP_ANON,
 297                     -1, 0);
 298                 if (cache == MAP_FAILED)
 299                         cache = NULL;
 300         } else
 301                 cache = NULL;
 302
 303         /*
 304          * From the SVR4 PPC ABI:
 305          * "The PowerPC family uses only the Elf32_Rela relocation
 306          *  entries with explicit addends."
 307          */
 308         relalim = (const Elf_Rela *)((caddr_t)obj->rela + obj->relasize);
 309         for (rela = obj->rela; rela < relalim; rela++) {
 310                 if (reloc_nonplt_object(obj_rtld, obj, rela, cache, lockstate)
 311                     < 0)
 312                         goto done;
 313         }
 314         r = 0;
 315 done:
 316         if (cache)
 317                 munmap(cache, bytes);
 318
 319         /* Synchronize icache for text seg in case we made any changes */
 320         __syncicache(obj->mapbase, obj->textsize);
 321
 322         return (r);
 323 }
 324
 325
 326 /*
 327  * Initialise a PLT slot to the resolving trampoline
 328  */
 329 static int
 330 reloc_plt_object(Obj_Entry *obj, const Elf_Rela *rela)
 331 {
 332         Elf_Addr *where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
 333         Elf_Addr *glink;
 334         long reloff;
 335
 336         reloff = rela - obj->pltrela;
 337
 338         if (obj->priv == NULL)
 339                 obj->priv = malloc(obj->pltrelasize);
 340         glink = obj->priv + reloff*sizeof(Elf_Addr)*2;
 341
 342         dbg(" reloc_plt_object: where=%p,reloff=%lx,glink=%p", (void *)where, reloff, glink);
 343
 344         memcpy(where, _rtld_bind_start, sizeof(struct funcdesc));
 345         ((struct funcdesc *)(where))->env = (Elf_Addr)glink;
 346         *(glink++) = (Elf_Addr)obj;
 347         *(glink++) = reloff*sizeof(Elf_Rela);
 348
 349         return (0);
 350 }
 351
 352
 353 /*
 354  * Process the PLT relocations.
 355  */
 356 int
 357 reloc_plt(Obj_Entry *obj)
 358 {
 359         const Elf_Rela *relalim;
 360         const Elf_Rela *rela;
 361
 362         if (obj->pltrelasize != 0) {
 363                 relalim = (const Elf_Rela *)((char *)obj->pltrela +
 364                     obj->pltrelasize);
 365                 for (rela = obj->pltrela;  rela < relalim;  rela++) {
 366                         assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT);
 367
 368                         if (reloc_plt_object(obj, rela) < 0) {
 369                                 return (-1);
 370                         }
 371                 }
 372         }
 373
 374         return (0);
 375 }
 376
 377
 378 /*
 379  * LD_BIND_NOW was set - force relocation for all jump slots
 380  */
 381 int
 382 reloc_jmpslots(Obj_Entry *obj, RtldLockState *lockstate)
 383 {
 384         const Obj_Entry *defobj;
 385         const Elf_Rela *relalim;
 386         const Elf_Rela *rela;
 387         const Elf_Sym *def;
 388         Elf_Addr *where;
 389         Elf_Addr target;
 390
 391         relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
 392         for (rela = obj->pltrela; rela < relalim; rela++) {
 393                 assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT);
 394                 where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
 395                 def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 396                     true, NULL, lockstate);
 397                 if (def == NULL) {
 398                         dbg("reloc_jmpslots: sym not found");
 399                         return (-1);
 400                 }
 401
 402                 target = (Elf_Addr)(defobj->relocbase + def->st_value);
 403
 404 #if 0
 405                 /* PG XXX */
 406                 dbg("\"%s\" in \"%s\" --> %p in \"%s\"",
 407                     defobj->strtab + def->st_name, basename(obj->path),
 408                     (void *)target, basename(defobj->path));
 409 #endif
 410
 411                 if (def == &sym_zero) {
 412                         /* Zero undefined weak symbols */
 413                         bzero(where, sizeof(struct funcdesc));
 414                 } else {
 415                         reloc_jmpslot(where, target, defobj, obj,
 416                             (const Elf_Rel *) rela);
 417                 }
 418         }
 419
 420         obj->jmpslots_done = true;
 421
 422         return (0);
 423 }
 424
 425
 426 /*
 427  * Update the value of a PLT jump slot.
 428  */
 429 Elf_Addr
 430 reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *defobj,
 431               const Obj_Entry *obj, const Elf_Rel *rel)
 432 {
 433         dbg(" reloc_jmpslot: where=%p, target=%p (%#lx + %#lx)",
 434             (void *)wherep, (void *)target, *(Elf_Addr *)target,
 435             (Elf_Addr)defobj->relocbase);
 436
 437         /*
 438          * At the PLT entry pointed at by `wherep', construct
 439          * a direct transfer to the now fully resolved function
 440          * address.
 441          */
 442
 443         memcpy(wherep, (void *)target, sizeof(struct funcdesc));
 444         if (((struct funcdesc *)(wherep))->addr < (Elf_Addr)defobj->relocbase) {
 445                 /*
 446                  * XXX: It is possible (e.g. LD_BIND_NOW) that the function
 447                  * descriptor we are copying has not yet been relocated.
 448                  * If this happens, fix it.
 449                  */
 450
 451                 ((struct funcdesc *)(wherep))->addr +=
 452                     (Elf_Addr)defobj->relocbase;
 453                 ((struct funcdesc *)(wherep))->toc +=
 454                     (Elf_Addr)defobj->relocbase;
 455         }
 456
 457         __asm __volatile("dcbst 0,%0; sync" :: "r"(wherep) : "memory");
 458
 459         return (target);
 460 }
 461
 462 int
 463 reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockState *lockstate)
 464 {
 465
 466         /* XXX not implemented */
 467         return (0);
 468 }
 469
 470 int
 471 reloc_gnu_ifunc(Obj_Entry *obj, struct Struct_RtldLockState *lockstate)
 472 {
 473
 474         /* XXX not implemented */
 475         return (0);
 476 }
 477
 478 void
 479 init_pltgot(Obj_Entry *obj)
 480 {
 481 }
 482
 483 void
 484 allocate_initial_tls(Obj_Entry *list)
 485 {
 486         register Elf_Addr **tp __asm__("r13");
 487         Elf_Addr **_tp;
 488
 489         /*
 490         * Fix the size of the static TLS block by using the maximum
 491         * offset allocated so far and adding a bit for dynamic modules to
 492         * use.
 493         */
 494
 495         tls_static_space = tls_last_offset + tls_last_size + RTLD_STATIC_TLS_EXTRA;
 496
 497         _tp = (Elf_Addr **) ((char *)allocate_tls(list, NULL, TLS_TCB_SIZE, 16)
 498             + TLS_TP_OFFSET + TLS_TCB_SIZE);
 499
 500         /*
 501          * XXX gcc seems to ignore 'tp = _tp;'
 502          */
 503
 504         __asm __volatile("mr %0,%1" : "=r"(tp) : "r"(_tp));
 505 }
 506
 507 void*
 508 __tls_get_addr(tls_index* ti)
 509 {
 510         register Elf_Addr **tp __asm__("r13");
 511         char *p;
 512
 513         p = tls_get_addr_common((Elf_Addr**)((Elf_Addr)tp - TLS_TP_OFFSET
 514             - TLS_TCB_SIZE), ti->ti_module, ti->ti_offset);
 515
 516         return (p + TLS_DTV_OFFSET);
 517 }