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 return (r); 320 } 321 322 323 /* 324 * Initialise a PLT slot to the resolving trampoline 325 */ 326 static int 327 reloc_plt_object(Obj_Entry *obj, const Elf_Rela *rela) 328 { 329 Elf_Addr *where = (Elf_Addr *)(obj->relocbase + rela->r_offset); 330 Elf_Addr *glink; 331 long reloff; 332 333 reloff = rela - obj->pltrela; 334 335 if (obj->priv == NULL) 336 obj->priv = malloc(obj->pltrelasize); 337 glink = obj->priv + reloff*sizeof(Elf_Addr)*2; 338 339 dbg(" reloc_plt_object: where=%p,reloff=%lx,glink=%p", (void *)where, reloff, glink); 340 341 memcpy(where, _rtld_bind_start, sizeof(struct funcdesc)); 342 ((struct funcdesc *)(where))->env = (Elf_Addr)glink; 343 *(glink++) = (Elf_Addr)obj; 344 *(glink++) = reloff*sizeof(Elf_Rela); 345 346 return (0); 347 } 348 349 350 /* 351 * Process the PLT relocations. 352 */ 353 int 354 reloc_plt(Obj_Entry *obj) 355 { 356 const Elf_Rela *relalim; 357 const Elf_Rela *rela; 358 359 if (obj->pltrelasize != 0) { 360 relalim = (const Elf_Rela *)((char *)obj->pltrela + 361 obj->pltrelasize); 362 for (rela = obj->pltrela; rela < relalim; rela++) { 363 assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT); 364 365 if (reloc_plt_object(obj, rela) < 0) { 366 return (-1); 367 } 368 } 369 } 370 371 return (0); 372 } 373 374 375 /* 376 * LD_BIND_NOW was set - force relocation for all jump slots 377 */ 378 int 379 reloc_jmpslots(Obj_Entry *obj, RtldLockState *lockstate) 380 { 381 const Obj_Entry *defobj; 382 const Elf_Rela *relalim; 383 const Elf_Rela *rela; 384 const Elf_Sym *def; 385 Elf_Addr *where; 386 Elf_Addr target; 387 388 relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize); 389 for (rela = obj->pltrela; rela < relalim; rela++) { 390 assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT); 391 where = (Elf_Addr *)(obj->relocbase + rela->r_offset); 392 def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj, 393 true, NULL, lockstate); 394 if (def == NULL) { 395 dbg("reloc_jmpslots: sym not found"); 396 return (-1); 397 } 398 399 target = (Elf_Addr)(defobj->relocbase + def->st_value); 400 401 #if 0 402 /* PG XXX */ 403 dbg("\"%s\" in \"%s\" --> %p in \"%s\"", 404 defobj->strtab + def->st_name, basename(obj->path), 405 (void *)target, basename(defobj->path)); 406 #endif 407 408 if (def == &sym_zero) { 409 /* Zero undefined weak symbols */ 410 bzero(where, sizeof(struct funcdesc)); 411 } else { 412 reloc_jmpslot(where, target, defobj, obj, 413 (const Elf_Rel *) rela); 414 } 415 } 416 417 obj->jmpslots_done = true; 418 419 return (0); 420 } 421 422 423 /* 424 * Update the value of a PLT jump slot. 425 */ 426 Elf_Addr 427 reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *defobj, 428 const Obj_Entry *obj, const Elf_Rel *rel) 429 { 430 dbg(" reloc_jmpslot: where=%p, target=%p (%#lx + %#lx)", 431 (void *)wherep, (void *)target, *(Elf_Addr *)target, 432 (Elf_Addr)defobj->relocbase); 433 434 /* 435 * At the PLT entry pointed at by `wherep', construct 436 * a direct transfer to the now fully resolved function 437 * address. 438 */ 439 440 memcpy(wherep, (void *)target, sizeof(struct funcdesc)); 441 if (((struct funcdesc *)(wherep))->addr < (Elf_Addr)defobj->relocbase) { 442 /* 443 * XXX: It is possible (e.g. LD_BIND_NOW) that the function 444 * descriptor we are copying has not yet been relocated. 445 * If this happens, fix it. 446 */ 447 448 ((struct funcdesc *)(wherep))->addr += 449 (Elf_Addr)defobj->relocbase; 450 ((struct funcdesc *)(wherep))->toc += 451 (Elf_Addr)defobj->relocbase; 452 } 453 454 __asm __volatile("dcbst 0,%0; sync" :: "r"(wherep) : "memory"); 455 456 return (target); 457 } 458 459 void 460 init_pltgot(Obj_Entry *obj) 461 { 462 } 463 464 void 465 allocate_initial_tls(Obj_Entry *list) 466 { 467 register Elf_Addr **tp __asm__("r13"); 468 Elf_Addr **_tp; 469 470 /* 471 * Fix the size of the static TLS block by using the maximum 472 * offset allocated so far and adding a bit for dynamic modules to 473 * use. 474 */ 475 476 tls_static_space = tls_last_offset + tls_last_size + RTLD_STATIC_TLS_EXTRA; 477 478 _tp = (Elf_Addr **) ((char *)allocate_tls(list, NULL, TLS_TCB_SIZE, 16) 479 + TLS_TP_OFFSET + TLS_TCB_SIZE); 480 481 /* 482 * XXX gcc seems to ignore 'tp = _tp;' 483 */ 484 485 __asm __volatile("mr %0,%1" : "=r"(tp) : "r"(_tp)); 486 } 487 488 void* 489 __tls_get_addr(tls_index* ti) 490 { 491 register Elf_Addr **tp __asm__("r13"); 492 char *p; 493 494 p = tls_get_addr_common((Elf_Addr**)((Elf_Addr)tp - TLS_TP_OFFSET 495 - TLS_TCB_SIZE), ti->ti_module, ti->ti_offset); 496 497 return (p + TLS_DTV_OFFSET); 498 } 499