ldso/ldso/aarch64/elfinterp.c

   1 /* AARCH64 ELF shared library loader suppport
   2  *
   3  * Copyright (C) 2001-2004 Erik Andersen
   4  * Copyright (C) 2016-2017 Waldemar Brodkorb <wbx@uclibc-ng.org>
   5  *
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. The name of the above contributors may not be
  14  *    used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /* Program to load an ELF binary on a linux system, and run it.
  31    References to symbols in sharable libraries can be resolved by either
  32    an ELF sharable library or a linux style of shared library. */
  33
  34 #include "ldso.h"
  35
  36 #if defined(USE_TLS) && USE_TLS
  37 #include "dl-tls.h"
  38 #include "tlsdeschtab.h"
  39 #endif
  40
  41 extern int _dl_linux_resolve(void);
  42
  43 unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
  44 {
  45         ELF_RELOC *this_reloc;
  46         char *strtab;
  47         ElfW(Sym) *symtab;
  48         int symtab_index;
  49         char *rel_addr;
  50         char *new_addr;
  51         char **got_addr;
  52         ElfW(Addr) instr_addr;
  53         char *symname;
  54
  55         rel_addr = (char *)tpnt->dynamic_info[DT_JMPREL];
  56         this_reloc = (ELF_RELOC *)(rel_addr + reloc_entry);
  57         symtab_index = ELF_R_SYM(this_reloc->r_info);
  58
  59         symtab = (ElfW(Sym) *)tpnt->dynamic_info[DT_SYMTAB];
  60         strtab = (char *)tpnt->dynamic_info[DT_STRTAB];
  61         symname = strtab + symtab[symtab_index].st_name;
  62
  63         /* Address of jump instruction to fix up */
  64         instr_addr = (this_reloc->r_offset + tpnt->loadaddr);
  65         got_addr = (char **)instr_addr;
  66
  67         /* Get the address of the GOT entry */
  68         new_addr = _dl_find_hash(symname, &_dl_loaded_modules->symbol_scope, tpnt, ELF_RTYPE_CLASS_PLT, NULL);
  69         if (unlikely(!new_addr)) {
  70                 _dl_dprintf(2, "%s: can't resolve symbol '%s'\n", _dl_progname, symname);
  71                 _dl_exit(1);
  72         }
  73 #if defined (__SUPPORT_LD_DEBUG__)
  74         if (_dl_debug_bindings) {
  75                 _dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
  76                 if (_dl_debug_detail) _dl_dprintf(_dl_debug_file,
  77                                 "\tpatched %x ==> %x @ %x", *got_addr, new_addr, got_addr);
  78         }
  79         if (!_dl_debug_nofixups) {
  80                 *got_addr = new_addr;
  81         }
  82 #else
  83         *got_addr = new_addr;
  84 #endif
  85         return (unsigned long)new_addr;
  86 }
  87
  88 static int
  89 _dl_parse(struct elf_resolve *tpnt, struct r_scope_elem *scope,
  90           unsigned long rel_addr, unsigned long rel_size,
  91           int (*reloc_fnc) (struct elf_resolve *tpnt, struct r_scope_elem *scope,
  92                             ELF_RELOC *rpnt, ElfW(Sym) *symtab, char *strtab))
  93 {
  94         unsigned int i;
  95         char *strtab;
  96         ElfW(Sym) *symtab;
  97         ELF_RELOC *rpnt;
  98         int symtab_index;
  99
 100         /* Parse the relocation information */
 101         rpnt = (ELF_RELOC *)rel_addr;
 102         rel_size = rel_size / sizeof(ELF_RELOC);
 103
 104         symtab = (ElfW(Sym) *)tpnt->dynamic_info[DT_SYMTAB];
 105         strtab = (char *)tpnt->dynamic_info[DT_STRTAB];
 106
 107         for (i = 0; i < rel_size; i++, rpnt++) {
 108                 int res;
 109
 110                 symtab_index = ELF_R_SYM(rpnt->r_info);
 111
 112                 debug_sym(symtab, strtab, symtab_index);
 113                 debug_reloc(symtab, strtab, rpnt);
 114
 115                 res = reloc_fnc(tpnt, scope, rpnt, symtab, strtab);
 116
 117                 if (res==0)
 118                         continue;
 119
 120                 _dl_dprintf(2, "\n%s: ", _dl_progname);
 121
 122                 if (symtab_index)
 123                         _dl_dprintf(2, "symbol '%s': ",
 124                                 strtab + symtab[symtab_index].st_name);
 125
 126                 if (unlikely(res < 0)) {
 127                         int reloc_type = ELF_R_TYPE(rpnt->r_info);
 128                         _dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
 129                         _dl_exit(-res);
 130                 } else if (unlikely(res > 0)) {
 131                         _dl_dprintf(2, "can't resolve symbol\n");
 132                         return res;
 133                 }
 134           }
 135
 136           return 0;
 137 }
 138
 139 static int
 140 _dl_do_reloc (struct elf_resolve *tpnt, struct r_scope_elem *scope,
 141               ELF_RELOC *rpnt, ElfW(Sym) *symtab, char *strtab)
 142 {
 143         int reloc_type;
 144         int symtab_index;
 145         char *symname;
 146 #if defined USE_TLS && USE_TLS
 147         struct elf_resolve *tls_tpnt = NULL;
 148 #endif
 149         struct symbol_ref sym_ref;
 150         ElfW(Addr) *reloc_addr;
 151         ElfW(Addr) symbol_addr;
 152 #if defined (__SUPPORT_LD_DEBUG__)
 153         ElfW(Addr) old_val;
 154 #endif
 155
 156         reloc_addr = (ElfW(Addr)*)(tpnt->loadaddr + (unsigned long)rpnt->r_offset);
 157         reloc_type = ELF_R_TYPE(rpnt->r_info);
 158         symtab_index = ELF_R_SYM(rpnt->r_info);
 159         sym_ref.sym = &symtab[symtab_index];
 160         sym_ref.tpnt = NULL;
 161         symbol_addr = 0;
 162         symname = strtab + sym_ref.sym->st_name;
 163
 164         if (symtab_index) {
 165                 symbol_addr = (ElfW(Addr))_dl_find_hash(symname, scope, tpnt,
 166                                 elf_machine_type_class(reloc_type), &sym_ref);
 167
 168                 /*
 169                  * We want to allow undefined references to weak symbols - this might
 170                  * have been intentional.  We should not be linking local symbols
 171                  * here, so all bases should be covered.
 172                  */
 173                 if (unlikely (!symbol_addr &&
 174                         (ELF_ST_TYPE(symtab[symtab_index].st_info) != STT_TLS) &&
 175                         (ELF_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK))) {
 176                         return 1;
 177                 }
 178                 if (_dl_trace_prelink) {
 179                         _dl_debug_lookup (symname, tpnt, &symtab[symtab_index],
 180                                                 &sym_ref, elf_machine_type_class(reloc_type));
 181                 }
 182 #if defined USE_TLS && USE_TLS
 183                 tls_tpnt = sym_ref.tpnt;
 184 #endif
 185         } else {
 186                 /*
 187                  * Relocs against STN_UNDEF are usually treated as using a
 188                  * symbol value of zero, and using the module containing the
 189                  * reloc itself.
 190                  */
 191                 symbol_addr = sym_ref.sym->st_value;
 192 #if defined USE_TLS && USE_TLS
 193                 tls_tpnt = tpnt;
 194 #endif
 195         }
 196
 197 #if defined (__SUPPORT_LD_DEBUG__)
 198         old_val = *reloc_addr;
 199 #endif
 200
 201         switch (reloc_type) {
 202                 case R_AARCH64_NONE:
 203                         break;
 204                 case R_AARCH64_ABS64:           /* REL_SYMBOLIC */
 205                 case R_AARCH64_GLOB_DAT:        /* REL_GOT */
 206                 case R_AARCH64_JUMP_SLOT:       /* REL_PLT */
 207                         *reloc_addr = symbol_addr + rpnt->r_addend;
 208                         break;
 209                 case R_AARCH64_RELATIVE:
 210                         *reloc_addr += tpnt->loadaddr + rpnt->r_addend;
 211                         break;
 212                 case R_AARCH64_COPY:
 213                         _dl_memcpy((void *) reloc_addr,
 214                                    (void *) symbol_addr, sym_ref.sym->st_size);
 215                         break;
 216 #if defined USE_TLS && USE_TLS
 217                 case R_AARCH64_TLS_TPREL:
 218                         CHECK_STATIC_TLS ((struct link_map *) tls_tpnt);
 219                         *reloc_addr = (symbol_addr + tls_tpnt->l_tls_offset);
 220                         break;
 221                 case R_AARCH64_TLSDESC:
 222                                 {
 223                                         struct tlsdesc volatile *td =
 224                                                         (struct tlsdesc volatile *)reloc_addr;
 225 #ifndef SHARED
 226                                         CHECK_STATIC_TLS((struct link_map *) tls_tpnt);
 227 #else
 228                                         if (!TRY_STATIC_TLS ((struct link_map *) tls_tpnt))
 229                                         {
 230                                                 td->arg = _dl_make_tlsdesc_dynamic((struct link_map *) tls_tpnt, symbol_addr);
 231                                                 td->entry = _dl_tlsdesc_dynamic;
 232                                         }
 233                                         else
 234 #endif
 235                                         {
 236                                                 td->arg = (void*)(symbol_addr + tls_tpnt->l_tls_offset);
 237                                                 td->entry = _dl_tlsdesc_return;
 238                                         }
 239                                 }
 240                         break;
 241 #endif
 242                 default:
 243                         return -1; /*call _dl_exit(1) */
 244         }
 245
 246 #if defined (__SUPPORT_LD_DEBUG__)
 247         if (_dl_debug_reloc && _dl_debug_detail) {
 248                 _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n",
 249                                 old_val, *reloc_addr, reloc_addr);
 250         }
 251 #endif
 252
 253         return 0;
 254 }
 255
 256 static int
 257 _dl_do_lazy_reloc (struct elf_resolve *tpnt, struct r_scope_elem *scope,
 258                    ELF_RELOC *rpnt, ElfW(Sym) *symtab, char *strtab)
 259 {
 260         int reloc_type;
 261         ElfW(Addr) *reloc_addr;
 262 #if defined (__SUPPORT_LD_DEBUG__)
 263         ElfW(Addr) old_val;
 264 #endif
 265
 266         (void)scope;
 267         (void)strtab;
 268
 269         reloc_addr = (ElfW(Addr)*)(tpnt->loadaddr + rpnt->r_offset);
 270         reloc_type = ELF_R_TYPE(rpnt->r_info);
 271
 272 #if defined (__SUPPORT_LD_DEBUG__)
 273         old_val = *reloc_addr;
 274 #endif
 275
 276         switch (reloc_type) {
 277                 case R_AARCH64_NONE:
 278                         break;
 279                 case R_AARCH64_JUMP_SLOT:
 280                         *reloc_addr += tpnt->loadaddr;
 281                         break;
 282 #if defined USE_TLS && USE_TLS
 283                 case R_AARCH64_TLSDESC:
 284                         {
 285                                 struct tlsdesc volatile *td =
 286                                   (struct tlsdesc volatile *)reloc_addr;
 287
 288                                 td->arg = (void*)rpnt;
 289                                 td->entry = _dl_tlsdesc_return;
 290                         }
 291                         break;
 292 #endif
 293                 default:
 294                         return -1; /*call _dl_exit(1) */
 295         }
 296
 297 #if defined (__SUPPORT_LD_DEBUG__)
 298         if (_dl_debug_reloc && _dl_debug_detail) {
 299                 _dl_dprintf(_dl_debug_file, "\tpatched_lazy: %x ==> %x @ %x\n",
 300                             old_val, *reloc_addr, reloc_addr);
 301         }
 302 #endif
 303
 304         return 0;
 305 }
 306
 307 void _dl_parse_lazy_relocation_information(struct dyn_elf *rpnt,
 308         unsigned long rel_addr, unsigned long rel_size)
 309 {
 310         (void)_dl_parse(rpnt->dyn, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
 311 }
 312
 313 int _dl_parse_relocation_information(struct dyn_elf *rpnt,
 314         struct r_scope_elem *scope, unsigned long rel_addr, unsigned long rel_size)
 315 {
 316         return _dl_parse(rpnt->dyn, scope, rel_addr, rel_size, _dl_do_reloc);
 317 }