1 /* $NetBSD: mdreloc.c,v 1.23 2003/07/26 15:04:38 mrg Exp $ */ 2 3 #include <sys/cdefs.h> 4 __FBSDID("$FreeBSD$"); 5 #include <sys/param.h> 6 #include <sys/stat.h> 7 #include <sys/mman.h> 8 9 #include <errno.h> 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <string.h> 13 #include <unistd.h> 14 15 #include "machine/sysarch.h" 16 17 #include "debug.h" 18 #include "rtld.h" 19 #include "paths.h" 20 21 void 22 arm_abi_variant_hook(Elf_Auxinfo **aux_info) 23 { 24 Elf_Word ehdr; 25 struct stat sb; 26 27 /* 28 * If we're running an old kernel that doesn't provide any data fail 29 * safe by doing nothing. 30 */ 31 if (aux_info[AT_EHDRFLAGS] == NULL) 32 return; 33 ehdr = aux_info[AT_EHDRFLAGS]->a_un.a_val; 34 35 /* 36 * Hard float ABI binaries are the default, and use the default paths 37 * and such. 38 */ 39 if ((ehdr & EF_ARM_VFP_FLOAT) != 0) 40 return; 41 42 /* 43 * If there's no /usr/libsoft, then we don't have a system with both 44 * hard and soft float. In that case, hope for the best and just 45 * return. Such systems are required to have all soft or all hard 46 * float ABI binaries and libraries. This is, at best, a transition 47 * compatibility hack. Once we're fully hard-float, this should 48 * be removed. 49 */ 50 if (stat("/usr/libsoft", &sb) != 0 || !S_ISDIR(sb.st_mode)) 51 return; 52 53 /* 54 * This is a soft float ABI binary. We need to use the soft float 55 * settings. 56 */ 57 ld_elf_hints_default = _PATH_SOFT_ELF_HINTS; 58 ld_path_libmap_conf = _PATH_SOFT_LIBMAP_CONF; 59 ld_path_rtld = _PATH_SOFT_RTLD; 60 ld_standard_library_path = SOFT_STANDARD_LIBRARY_PATH; 61 ld_env_prefix = LD_SOFT_; 62 } 63 64 void 65 init_pltgot(Obj_Entry *obj) 66 { 67 if (obj->pltgot != NULL) { 68 obj->pltgot[1] = (Elf_Addr) obj; 69 obj->pltgot[2] = (Elf_Addr) &_rtld_bind_start; 70 } 71 } 72 73 int 74 do_copy_relocations(Obj_Entry *dstobj) 75 { 76 const Elf_Rel *rellim; 77 const Elf_Rel *rel; 78 79 assert(dstobj->mainprog); /* COPY relocations are invalid elsewhere */ 80 81 rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize); 82 for (rel = dstobj->rel; rel < rellim; rel++) { 83 if (ELF_R_TYPE(rel->r_info) == R_ARM_COPY) { 84 void *dstaddr; 85 const Elf_Sym *dstsym; 86 const char *name; 87 size_t size; 88 const void *srcaddr; 89 const Elf_Sym *srcsym; 90 const Obj_Entry *srcobj, *defobj; 91 SymLook req; 92 int res; 93 94 dstaddr = (void *) (dstobj->relocbase + rel->r_offset); 95 dstsym = dstobj->symtab + ELF_R_SYM(rel->r_info); 96 name = dstobj->strtab + dstsym->st_name; 97 size = dstsym->st_size; 98 99 symlook_init(&req, name); 100 req.ventry = fetch_ventry(dstobj, 101 ELF_R_SYM(rel->r_info)); 102 req.flags = SYMLOOK_EARLY; 103 104 for (srcobj = globallist_next(dstobj); srcobj != NULL; 105 srcobj = globallist_next(srcobj)) { 106 res = symlook_obj(&req, srcobj); 107 if (res == 0) { 108 srcsym = req.sym_out; 109 defobj = req.defobj_out; 110 break; 111 } 112 } 113 if (srcobj == NULL) { 114 _rtld_error( 115 "Undefined symbol \"%s\" referenced from COPY relocation in %s", 116 name, dstobj->path); 117 return (-1); 118 } 119 120 srcaddr = (const void *)(defobj->relocbase + 121 srcsym->st_value); 122 memcpy(dstaddr, srcaddr, size); 123 } 124 } 125 return 0; 126 } 127 128 void _rtld_bind_start(void); 129 void _rtld_relocate_nonplt_self(Elf_Dyn *, Elf_Addr); 130 131 int open(); 132 int _open(); 133 void 134 _rtld_relocate_nonplt_self(Elf_Dyn *dynp, Elf_Addr relocbase) 135 { 136 const Elf_Rel *rel = NULL, *rellim; 137 Elf_Addr relsz = 0; 138 Elf_Addr *where; 139 uint32_t size; 140 141 for (; dynp->d_tag != DT_NULL; dynp++) { 142 switch (dynp->d_tag) { 143 case DT_REL: 144 rel = (const Elf_Rel *)(relocbase + dynp->d_un.d_ptr); 145 break; 146 case DT_RELSZ: 147 relsz = dynp->d_un.d_val; 148 break; 149 } 150 } 151 rellim = (const Elf_Rel *)((caddr_t)rel + relsz); 152 size = (rellim - 1)->r_offset - rel->r_offset; 153 for (; rel < rellim; rel++) { 154 where = (Elf_Addr *)(relocbase + rel->r_offset); 155 156 *where += (Elf_Addr)relocbase; 157 } 158 } 159 /* 160 * It is possible for the compiler to emit relocations for unaligned data. 161 * We handle this situation with these inlines. 162 */ 163 #define RELOC_ALIGNED_P(x) \ 164 (((uintptr_t)(x) & (sizeof(void *) - 1)) == 0) 165 166 static __inline Elf_Addr 167 load_ptr(void *where) 168 { 169 Elf_Addr res; 170 171 memcpy(&res, where, sizeof(res)); 172 173 return (res); 174 } 175 176 static __inline void 177 store_ptr(void *where, Elf_Addr val) 178 { 179 180 memcpy(where, &val, sizeof(val)); 181 } 182 183 static int 184 reloc_nonplt_object(Obj_Entry *obj, const Elf_Rel *rel, SymCache *cache, 185 int flags, RtldLockState *lockstate) 186 { 187 Elf_Addr *where; 188 const Elf_Sym *def; 189 const Obj_Entry *defobj; 190 Elf_Addr tmp; 191 unsigned long symnum; 192 193 where = (Elf_Addr *)(obj->relocbase + rel->r_offset); 194 symnum = ELF_R_SYM(rel->r_info); 195 196 switch (ELF_R_TYPE(rel->r_info)) { 197 case R_ARM_NONE: 198 break; 199 200 #if 1 /* XXX should not occur */ 201 case R_ARM_PC24: { /* word32 S - P + A */ 202 Elf32_Sword addend; 203 204 /* 205 * Extract addend and sign-extend if needed. 206 */ 207 addend = *where; 208 if (addend & 0x00800000) 209 addend |= 0xff000000; 210 211 def = find_symdef(symnum, obj, &defobj, flags, cache, 212 lockstate); 213 if (def == NULL) 214 return -1; 215 tmp = (Elf_Addr)obj->relocbase + def->st_value 216 - (Elf_Addr)where + (addend << 2); 217 if ((tmp & 0xfe000000) != 0xfe000000 && 218 (tmp & 0xfe000000) != 0) { 219 _rtld_error( 220 "%s: R_ARM_PC24 relocation @ %p to %s failed " 221 "(displacement %ld (%#lx) out of range)", 222 obj->path, where, 223 obj->strtab + obj->symtab[symnum].st_name, 224 (long) tmp, (long) tmp); 225 return -1; 226 } 227 tmp >>= 2; 228 *where = (*where & 0xff000000) | (tmp & 0x00ffffff); 229 dbg("PC24 %s in %s --> %p @ %p in %s", 230 obj->strtab + obj->symtab[symnum].st_name, 231 obj->path, (void *)*where, where, defobj->path); 232 break; 233 } 234 #endif 235 236 case R_ARM_ABS32: /* word32 B + S + A */ 237 case R_ARM_GLOB_DAT: /* word32 B + S */ 238 def = find_symdef(symnum, obj, &defobj, flags, cache, 239 lockstate); 240 if (def == NULL) 241 return -1; 242 if (__predict_true(RELOC_ALIGNED_P(where))) { 243 tmp = *where + (Elf_Addr)defobj->relocbase + 244 def->st_value; 245 *where = tmp; 246 } else { 247 tmp = load_ptr(where) + 248 (Elf_Addr)defobj->relocbase + 249 def->st_value; 250 store_ptr(where, tmp); 251 } 252 dbg("ABS32/GLOB_DAT %s in %s --> %p @ %p in %s", 253 obj->strtab + obj->symtab[symnum].st_name, 254 obj->path, (void *)tmp, where, defobj->path); 255 break; 256 257 case R_ARM_RELATIVE: /* word32 B + A */ 258 if (__predict_true(RELOC_ALIGNED_P(where))) { 259 tmp = *where + (Elf_Addr)obj->relocbase; 260 *where = tmp; 261 } else { 262 tmp = load_ptr(where) + 263 (Elf_Addr)obj->relocbase; 264 store_ptr(where, tmp); 265 } 266 dbg("RELATIVE in %s --> %p", obj->path, 267 (void *)tmp); 268 break; 269 270 case R_ARM_COPY: 271 /* 272 * These are deferred until all other relocations have 273 * been done. All we do here is make sure that the 274 * COPY relocation is not in a shared library. They 275 * are allowed only in executable files. 276 */ 277 if (!obj->mainprog) { 278 _rtld_error( 279 "%s: Unexpected R_COPY relocation in shared library", 280 obj->path); 281 return -1; 282 } 283 dbg("COPY (avoid in main)"); 284 break; 285 286 case R_ARM_TLS_DTPOFF32: 287 def = find_symdef(symnum, obj, &defobj, flags, cache, 288 lockstate); 289 if (def == NULL) 290 return -1; 291 292 tmp = (Elf_Addr)(def->st_value); 293 if (__predict_true(RELOC_ALIGNED_P(where))) 294 *where = tmp; 295 else 296 store_ptr(where, tmp); 297 298 dbg("TLS_DTPOFF32 %s in %s --> %p", 299 obj->strtab + obj->symtab[symnum].st_name, 300 obj->path, (void *)tmp); 301 302 break; 303 case R_ARM_TLS_DTPMOD32: 304 def = find_symdef(symnum, obj, &defobj, flags, cache, 305 lockstate); 306 if (def == NULL) 307 return -1; 308 309 tmp = (Elf_Addr)(defobj->tlsindex); 310 if (__predict_true(RELOC_ALIGNED_P(where))) 311 *where = tmp; 312 else 313 store_ptr(where, tmp); 314 315 dbg("TLS_DTPMOD32 %s in %s --> %p", 316 obj->strtab + obj->symtab[symnum].st_name, 317 obj->path, (void *)tmp); 318 319 break; 320 321 case R_ARM_TLS_TPOFF32: 322 def = find_symdef(symnum, obj, &defobj, flags, cache, 323 lockstate); 324 if (def == NULL) 325 return -1; 326 327 if (!defobj->tls_done && allocate_tls_offset(obj)) 328 return -1; 329 330 /* XXX: FIXME */ 331 tmp = (Elf_Addr)def->st_value + defobj->tlsoffset + 332 TLS_TCB_SIZE; 333 if (__predict_true(RELOC_ALIGNED_P(where))) 334 *where = tmp; 335 else 336 store_ptr(where, tmp); 337 dbg("TLS_TPOFF32 %s in %s --> %p", 338 obj->strtab + obj->symtab[symnum].st_name, 339 obj->path, (void *)tmp); 340 break; 341 342 343 default: 344 dbg("sym = %lu, type = %lu, offset = %p, " 345 "contents = %p, symbol = %s", 346 symnum, (u_long)ELF_R_TYPE(rel->r_info), 347 (void *)rel->r_offset, (void *)load_ptr(where), 348 obj->strtab + obj->symtab[symnum].st_name); 349 _rtld_error("%s: Unsupported relocation type %ld " 350 "in non-PLT relocations\n", 351 obj->path, (u_long) ELF_R_TYPE(rel->r_info)); 352 return -1; 353 } 354 return 0; 355 } 356 357 /* 358 * * Process non-PLT relocations 359 * */ 360 int 361 reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int flags, 362 RtldLockState *lockstate) 363 { 364 const Elf_Rel *rellim; 365 const Elf_Rel *rel; 366 SymCache *cache; 367 int r = -1; 368 369 /* The relocation for the dynamic loader has already been done. */ 370 if (obj == obj_rtld) 371 return (0); 372 if ((flags & SYMLOOK_IFUNC) != 0) 373 /* XXX not implemented */ 374 return (0); 375 376 /* 377 * The dynamic loader may be called from a thread, we have 378 * limited amounts of stack available so we cannot use alloca(). 379 */ 380 cache = calloc(obj->dynsymcount, sizeof(SymCache)); 381 /* No need to check for NULL here */ 382 383 rellim = (const Elf_Rel *)((caddr_t)obj->rel + obj->relsize); 384 for (rel = obj->rel; rel < rellim; rel++) { 385 if (reloc_nonplt_object(obj, rel, cache, flags, lockstate) < 0) 386 goto done; 387 } 388 r = 0; 389 done: 390 if (cache != NULL) 391 free(cache); 392 return (r); 393 } 394 395 /* 396 * * Process the PLT relocations. 397 * */ 398 int 399 reloc_plt(Obj_Entry *obj) 400 { 401 const Elf_Rel *rellim; 402 const Elf_Rel *rel; 403 404 rellim = (const Elf_Rel *)((char *)obj->pltrel + 405 obj->pltrelsize); 406 for (rel = obj->pltrel; rel < rellim; rel++) { 407 Elf_Addr *where; 408 409 assert(ELF_R_TYPE(rel->r_info) == R_ARM_JUMP_SLOT); 410 411 where = (Elf_Addr *)(obj->relocbase + rel->r_offset); 412 *where += (Elf_Addr )obj->relocbase; 413 } 414 415 return (0); 416 } 417 418 /* 419 * * LD_BIND_NOW was set - force relocation for all jump slots 420 * */ 421 int 422 reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockState *lockstate) 423 { 424 const Obj_Entry *defobj; 425 const Elf_Rel *rellim; 426 const Elf_Rel *rel; 427 const Elf_Sym *def; 428 Elf_Addr *where; 429 Elf_Addr target; 430 431 rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize); 432 for (rel = obj->pltrel; rel < rellim; rel++) { 433 assert(ELF_R_TYPE(rel->r_info) == R_ARM_JUMP_SLOT); 434 where = (Elf_Addr *)(obj->relocbase + rel->r_offset); 435 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, 436 SYMLOOK_IN_PLT | flags, NULL, lockstate); 437 if (def == NULL) { 438 dbg("reloc_jmpslots: sym not found"); 439 return (-1); 440 } 441 442 target = (Elf_Addr)(defobj->relocbase + def->st_value); 443 reloc_jmpslot(where, target, defobj, obj, 444 (const Elf_Rel *) rel); 445 } 446 447 obj->jmpslots_done = true; 448 449 return (0); 450 } 451 452 int 453 reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockState *lockstate) 454 { 455 456 /* XXX not implemented */ 457 return (0); 458 } 459 460 int 461 reloc_gnu_ifunc(Obj_Entry *obj, int flags, 462 struct Struct_RtldLockState *lockstate) 463 { 464 465 /* XXX not implemented */ 466 return (0); 467 } 468 469 Elf_Addr 470 reloc_jmpslot(Elf_Addr *where, Elf_Addr target, const Obj_Entry *defobj, 471 const Obj_Entry *obj, const Elf_Rel *rel) 472 { 473 474 assert(ELF_R_TYPE(rel->r_info) == R_ARM_JUMP_SLOT); 475 476 if (*where != target && !ld_bind_not) 477 *where = target; 478 return (target); 479 } 480 481 void 482 ifunc_init(Elf_Auxinfo aux_info[__min_size(AT_COUNT)] __unused) 483 { 484 } 485 486 void 487 allocate_initial_tls(Obj_Entry *objs) 488 { 489 #ifdef ARM_TP_ADDRESS 490 void **_tp = (void **)ARM_TP_ADDRESS; 491 #endif 492 493 /* 494 * Fix the size of the static TLS block by using the maximum 495 * offset allocated so far and adding a bit for dynamic modules to 496 * use. 497 */ 498 499 tls_static_space = tls_last_offset + tls_last_size + RTLD_STATIC_TLS_EXTRA; 500 501 #ifdef ARM_TP_ADDRESS 502 (*_tp) = (void *) allocate_tls(objs, NULL, TLS_TCB_SIZE, 8); 503 #else 504 sysarch(ARM_SET_TP, allocate_tls(objs, NULL, TLS_TCB_SIZE, 8)); 505 #endif 506 } 507 508 void * 509 __tls_get_addr(tls_index* ti) 510 { 511 char *p; 512 #ifdef ARM_TP_ADDRESS 513 void **_tp = (void **)ARM_TP_ADDRESS; 514 515 p = tls_get_addr_common((Elf_Addr **)(*_tp), ti->ti_module, ti->ti_offset); 516 #else 517 void *_tp; 518 __asm __volatile("mrc p15, 0, %0, c13, c0, 3" \ 519 : "=r" (_tp)); 520 p = tls_get_addr_common((Elf_Addr **)(_tp), ti->ti_module, ti->ti_offset); 521 #endif 522 523 return (p); 524 } 525