tools/objtool/elf.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * elf.c - ELF access library
   4  *
   5  * Adapted from kpatch (https://github.com/dynup/kpatch):
   6  * Copyright (C) 2013-2015 Josh Poimboeuf <jpoimboe@redhat.com>
   7  * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
   8  */
   9
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18
  19 #include "elf.h"
  20 #include "warn.h"
  21
  22 #define MAX_NAME_LEN 128
  23
  24 struct section *find_section_by_name(struct elf *elf, const char *name)
  25 {
  26         struct section *sec;
  27
  28         list_for_each_entry(sec, &elf->sections, list)
  29                 if (!strcmp(sec->name, name))
  30                         return sec;
  31
  32         return NULL;
  33 }
  34
  35 static struct section *find_section_by_index(struct elf *elf,
  36                                              unsigned int idx)
  37 {
  38         struct section *sec;
  39
  40         list_for_each_entry(sec, &elf->sections, list)
  41                 if (sec->idx == idx)
  42                         return sec;
  43
  44         return NULL;
  45 }
  46
  47 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
  48 {
  49         struct section *sec;
  50         struct symbol *sym;
  51
  52         list_for_each_entry(sec, &elf->sections, list)
  53                 hash_for_each_possible(sec->symbol_hash, sym, hash, idx)
  54                         if (sym->idx == idx)
  55                                 return sym;
  56
  57         return NULL;
  58 }
  59
  60 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
  61 {
  62         struct symbol *sym;
  63
  64         list_for_each_entry(sym, &sec->symbol_list, list)
  65                 if (sym->type != STT_SECTION &&
  66                     sym->offset == offset)
  67                         return sym;
  68
  69         return NULL;
  70 }
  71
  72 struct symbol *find_symbol_by_name(struct elf *elf, const char *name)
  73 {
  74         struct section *sec;
  75         struct symbol *sym;
  76
  77         list_for_each_entry(sec, &elf->sections, list)
  78                 list_for_each_entry(sym, &sec->symbol_list, list)
  79                         if (!strcmp(sym->name, name))
  80                                 return sym;
  81
  82         return NULL;
  83 }
  84
  85 struct symbol *find_symbol_containing(struct section *sec, unsigned long offset)
  86 {
  87         struct symbol *sym;
  88
  89         list_for_each_entry(sym, &sec->symbol_list, list)
  90                 if (sym->type != STT_SECTION &&
  91                     offset >= sym->offset && offset < sym->offset + sym->len)
  92                         return sym;
  93
  94         return NULL;
  95 }
  96
  97 struct rela *find_rela_by_dest_range(struct section *sec, unsigned long offset,
  98                                      unsigned int len)
  99 {
 100         struct rela *rela;
 101         unsigned long o;
 102
 103         if (!sec->rela)
 104                 return NULL;
 105
 106         for (o = offset; o < offset + len; o++)
 107                 hash_for_each_possible(sec->rela->rela_hash, rela, hash, o)
 108                         if (rela->offset == o)
 109                                 return rela;
 110
 111         return NULL;
 112 }
 113
 114 struct rela *find_rela_by_dest(struct section *sec, unsigned long offset)
 115 {
 116         return find_rela_by_dest_range(sec, offset, 1);
 117 }
 118
 119 struct symbol *find_containing_func(struct section *sec, unsigned long offset)
 120 {
 121         struct symbol *func;
 122
 123         list_for_each_entry(func, &sec->symbol_list, list)
 124                 if (func->type == STT_FUNC && offset >= func->offset &&
 125                     offset < func->offset + func->len)
 126                         return func;
 127
 128         return NULL;
 129 }
 130
 131 static int read_sections(struct elf *elf)
 132 {
 133         Elf_Scn *s = NULL;
 134         struct section *sec;
 135         size_t shstrndx, sections_nr;
 136         int i;
 137
 138         if (elf_getshdrnum(elf->elf, &sections_nr)) {
 139                 WARN_ELF("elf_getshdrnum");
 140                 return -1;
 141         }
 142
 143         if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
 144                 WARN_ELF("elf_getshdrstrndx");
 145                 return -1;
 146         }
 147
 148         for (i = 0; i < sections_nr; i++) {
 149                 sec = malloc(sizeof(*sec));
 150                 if (!sec) {
 151                         perror("malloc");
 152                         return -1;
 153                 }
 154                 memset(sec, 0, sizeof(*sec));
 155
 156                 INIT_LIST_HEAD(&sec->symbol_list);
 157                 INIT_LIST_HEAD(&sec->rela_list);
 158                 hash_init(sec->rela_hash);
 159                 hash_init(sec->symbol_hash);
 160
 161                 list_add_tail(&sec->list, &elf->sections);
 162
 163                 s = elf_getscn(elf->elf, i);
 164                 if (!s) {
 165                         WARN_ELF("elf_getscn");
 166                         return -1;
 167                 }
 168
 169                 sec->idx = elf_ndxscn(s);
 170
 171                 if (!gelf_getshdr(s, &sec->sh)) {
 172                         WARN_ELF("gelf_getshdr");
 173                         return -1;
 174                 }
 175
 176                 sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
 177                 if (!sec->name) {
 178                         WARN_ELF("elf_strptr");
 179                         return -1;
 180                 }
 181
 182                 if (sec->sh.sh_size != 0) {
 183                         sec->data = elf_getdata(s, NULL);
 184                         if (!sec->data) {
 185                                 WARN_ELF("elf_getdata");
 186                                 return -1;
 187                         }
 188                         if (sec->data->d_off != 0 ||
 189                             sec->data->d_size != sec->sh.sh_size) {
 190                                 WARN("unexpected data attributes for %s",
 191                                      sec->name);
 192                                 return -1;
 193                         }
 194                 }
 195                 sec->len = sec->sh.sh_size;
 196         }
 197
 198         /* sanity check, one more call to elf_nextscn() should return NULL */
 199         if (elf_nextscn(elf->elf, s)) {
 200                 WARN("section entry mismatch");
 201                 return -1;
 202         }
 203
 204         return 0;
 205 }
 206
 207 static int read_symbols(struct elf *elf)
 208 {
 209         struct section *symtab, *sec;
 210         struct symbol *sym, *pfunc, *alias;
 211         struct list_head *entry, *tmp;
 212         int symbols_nr, i;
 213         char *coldstr;
 214
 215         symtab = find_section_by_name(elf, ".symtab");
 216         if (!symtab) {
 217                 WARN("missing symbol table");
 218                 return -1;
 219         }
 220
 221         symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
 222
 223         for (i = 0; i < symbols_nr; i++) {
 224                 sym = malloc(sizeof(*sym));
 225                 if (!sym) {
 226                         perror("malloc");
 227                         return -1;
 228                 }
 229                 memset(sym, 0, sizeof(*sym));
 230                 alias = sym;
 231
 232                 sym->idx = i;
 233
 234                 if (!gelf_getsym(symtab->data, i, &sym->sym)) {
 235                         WARN_ELF("gelf_getsym");
 236                         goto err;
 237                 }
 238
 239                 sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
 240                                        sym->sym.st_name);
 241                 if (!sym->name) {
 242                         WARN_ELF("elf_strptr");
 243                         goto err;
 244                 }
 245
 246                 sym->type = GELF_ST_TYPE(sym->sym.st_info);
 247                 sym->bind = GELF_ST_BIND(sym->sym.st_info);
 248
 249                 if (sym->sym.st_shndx > SHN_UNDEF &&
 250                     sym->sym.st_shndx < SHN_LORESERVE) {
 251                         sym->sec = find_section_by_index(elf,
 252                                                          sym->sym.st_shndx);
 253                         if (!sym->sec) {
 254                                 WARN("couldn't find section for symbol %s",
 255                                      sym->name);
 256                                 goto err;
 257                         }
 258                         if (sym->type == STT_SECTION) {
 259                                 sym->name = sym->sec->name;
 260                                 sym->sec->sym = sym;
 261                         }
 262                 } else
 263                         sym->sec = find_section_by_index(elf, 0);
 264
 265                 sym->offset = sym->sym.st_value;
 266                 sym->len = sym->sym.st_size;
 267
 268                 /* sorted insert into a per-section list */
 269                 entry = &sym->sec->symbol_list;
 270                 list_for_each_prev(tmp, &sym->sec->symbol_list) {
 271                         struct symbol *s;
 272
 273                         s = list_entry(tmp, struct symbol, list);
 274
 275                         if (sym->offset > s->offset) {
 276                                 entry = tmp;
 277                                 break;
 278                         }
 279
 280                         if (sym->offset == s->offset) {
 281                                 if (sym->len && sym->len == s->len && alias == sym)
 282                                         alias = s;
 283
 284                                 if (sym->len >= s->len) {
 285                                         entry = tmp;
 286                                         break;
 287                                 }
 288                         }
 289                 }
 290                 sym->alias = alias;
 291                 list_add(&sym->list, entry);
 292                 hash_add(sym->sec->symbol_hash, &sym->hash, sym->idx);
 293         }
 294
 295         /* Create parent/child links for any cold subfunctions */
 296         list_for_each_entry(sec, &elf->sections, list) {
 297                 list_for_each_entry(sym, &sec->symbol_list, list) {
 298                         char pname[MAX_NAME_LEN + 1];
 299                         size_t pnamelen;
 300                         if (sym->type != STT_FUNC)
 301                                 continue;
 302                         sym->pfunc = sym->cfunc = sym;
 303                         coldstr = strstr(sym->name, ".cold");
 304                         if (!coldstr)
 305                                 continue;
 306
 307                         pnamelen = coldstr - sym->name;
 308                         if (pnamelen > MAX_NAME_LEN) {
 309                                 WARN("%s(): parent function name exceeds maximum length of %d characters",
 310                                      sym->name, MAX_NAME_LEN);
 311                                 return -1;
 312                         }
 313
 314                         strncpy(pname, sym->name, pnamelen);
 315                         pname[pnamelen] = '\0';
 316                         pfunc = find_symbol_by_name(elf, pname);
 317
 318                         if (!pfunc) {
 319                                 WARN("%s(): can't find parent function",
 320                                      sym->name);
 321                                 return -1;
 322                         }
 323
 324                         sym->pfunc = pfunc;
 325                         pfunc->cfunc = sym;
 326
 327                         /*
 328                          * Unfortunately, -fnoreorder-functions puts the child
 329                          * inside the parent.  Remove the overlap so we can
 330                          * have sane assumptions.
 331                          *
 332                          * Note that pfunc->len now no longer matches
 333                          * pfunc->sym.st_size.
 334                          */
 335                         if (sym->sec == pfunc->sec &&
 336                             sym->offset >= pfunc->offset &&
 337                             sym->offset + sym->len == pfunc->offset + pfunc->len) {
 338                                 pfunc->len -= sym->len;
 339                         }
 340                 }
 341         }
 342
 343         return 0;
 344
 345 err:
 346         free(sym);
 347         return -1;
 348 }
 349
 350 static int read_relas(struct elf *elf)
 351 {
 352         struct section *sec;
 353         struct rela *rela;
 354         int i;
 355         unsigned int symndx;
 356
 357         list_for_each_entry(sec, &elf->sections, list) {
 358                 if (sec->sh.sh_type != SHT_RELA)
 359                         continue;
 360
 361                 sec->base = find_section_by_name(elf, sec->name + 5);
 362                 if (!sec->base) {
 363                         WARN("can't find base section for rela section %s",
 364                              sec->name);
 365                         return -1;
 366                 }
 367
 368                 sec->base->rela = sec;
 369
 370                 for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
 371                         rela = malloc(sizeof(*rela));
 372                         if (!rela) {
 373                                 perror("malloc");
 374                                 return -1;
 375                         }
 376                         memset(rela, 0, sizeof(*rela));
 377
 378                         if (!gelf_getrela(sec->data, i, &rela->rela)) {
 379                                 WARN_ELF("gelf_getrela");
 380                                 return -1;
 381                         }
 382
 383                         rela->type = GELF_R_TYPE(rela->rela.r_info);
 384                         rela->addend = rela->rela.r_addend;
 385                         rela->offset = rela->rela.r_offset;
 386                         symndx = GELF_R_SYM(rela->rela.r_info);
 387                         rela->sym = find_symbol_by_index(elf, symndx);
 388                         rela->sec = sec;
 389                         if (!rela->sym) {
 390                                 WARN("can't find rela entry symbol %d for %s",
 391                                      symndx, sec->name);
 392                                 return -1;
 393                         }
 394
 395                         list_add_tail(&rela->list, &sec->rela_list);
 396                         hash_add(sec->rela_hash, &rela->hash, rela->offset);
 397
 398                 }
 399         }
 400
 401         return 0;
 402 }
 403
 404 struct elf *elf_read(const char *name, int flags)
 405 {
 406         struct elf *elf;
 407         Elf_Cmd cmd;
 408
 409         elf_version(EV_CURRENT);
 410
 411         elf = malloc(sizeof(*elf));
 412         if (!elf) {
 413                 perror("malloc");
 414                 return NULL;
 415         }
 416         memset(elf, 0, sizeof(*elf));
 417
 418         INIT_LIST_HEAD(&elf->sections);
 419
 420         elf->fd = open(name, flags);
 421         if (elf->fd == -1) {
 422                 fprintf(stderr, "objtool: Can't open '%s': %s\n",
 423                         name, strerror(errno));
 424                 goto err;
 425         }
 426
 427         if ((flags & O_ACCMODE) == O_RDONLY)
 428                 cmd = ELF_C_READ_MMAP;
 429         else if ((flags & O_ACCMODE) == O_RDWR)
 430                 cmd = ELF_C_RDWR;
 431         else /* O_WRONLY */
 432                 cmd = ELF_C_WRITE;
 433
 434         elf->elf = elf_begin(elf->fd, cmd, NULL);
 435         if (!elf->elf) {
 436                 WARN_ELF("elf_begin");
 437                 goto err;
 438         }
 439
 440         if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
 441                 WARN_ELF("gelf_getehdr");
 442                 goto err;
 443         }
 444
 445         if (read_sections(elf))
 446                 goto err;
 447
 448         if (read_symbols(elf))
 449                 goto err;
 450
 451         if (read_relas(elf))
 452                 goto err;
 453
 454         return elf;
 455
 456 err:
 457         elf_close(elf);
 458         return NULL;
 459 }
 460
 461 struct section *elf_create_section(struct elf *elf, const char *name,
 462                                    size_t entsize, int nr)
 463 {
 464         struct section *sec, *shstrtab;
 465         size_t size = entsize * nr;
 466         Elf_Scn *s;
 467         Elf_Data *data;
 468
 469         sec = malloc(sizeof(*sec));
 470         if (!sec) {
 471                 perror("malloc");
 472                 return NULL;
 473         }
 474         memset(sec, 0, sizeof(*sec));
 475
 476         INIT_LIST_HEAD(&sec->symbol_list);
 477         INIT_LIST_HEAD(&sec->rela_list);
 478         hash_init(sec->rela_hash);
 479         hash_init(sec->symbol_hash);
 480
 481         list_add_tail(&sec->list, &elf->sections);
 482
 483         s = elf_newscn(elf->elf);
 484         if (!s) {
 485                 WARN_ELF("elf_newscn");
 486                 return NULL;
 487         }
 488
 489         sec->name = strdup(name);
 490         if (!sec->name) {
 491                 perror("strdup");
 492                 return NULL;
 493         }
 494
 495         sec->idx = elf_ndxscn(s);
 496         sec->len = size;
 497         sec->changed = true;
 498
 499         sec->data = elf_newdata(s);
 500         if (!sec->data) {
 501                 WARN_ELF("elf_newdata");
 502                 return NULL;
 503         }
 504
 505         sec->data->d_size = size;
 506         sec->data->d_align = 1;
 507
 508         if (size) {
 509                 sec->data->d_buf = malloc(size);
 510                 if (!sec->data->d_buf) {
 511                         perror("malloc");
 512                         return NULL;
 513                 }
 514                 memset(sec->data->d_buf, 0, size);
 515         }
 516
 517         if (!gelf_getshdr(s, &sec->sh)) {
 518                 WARN_ELF("gelf_getshdr");
 519                 return NULL;
 520         }
 521
 522         sec->sh.sh_size = size;
 523         sec->sh.sh_entsize = entsize;
 524         sec->sh.sh_type = SHT_PROGBITS;
 525         sec->sh.sh_addralign = 1;
 526         sec->sh.sh_flags = SHF_ALLOC;
 527
 528
 529         /* Add section name to .shstrtab (or .strtab for Clang) */
 530         shstrtab = find_section_by_name(elf, ".shstrtab");
 531         if (!shstrtab)
 532                 shstrtab = find_section_by_name(elf, ".strtab");
 533         if (!shstrtab) {
 534                 WARN("can't find .shstrtab or .strtab section");
 535                 return NULL;
 536         }
 537
 538         s = elf_getscn(elf->elf, shstrtab->idx);
 539         if (!s) {
 540                 WARN_ELF("elf_getscn");
 541                 return NULL;
 542         }
 543
 544         data = elf_newdata(s);
 545         if (!data) {
 546                 WARN_ELF("elf_newdata");
 547                 return NULL;
 548         }
 549
 550         data->d_buf = sec->name;
 551         data->d_size = strlen(name) + 1;
 552         data->d_align = 1;
 553
 554         sec->sh.sh_name = shstrtab->len;
 555
 556         shstrtab->len += strlen(name) + 1;
 557         shstrtab->changed = true;
 558
 559         return sec;
 560 }
 561
 562 struct section *elf_create_rela_section(struct elf *elf, struct section *base)
 563 {
 564         char *relaname;
 565         struct section *sec;
 566
 567         relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
 568         if (!relaname) {
 569                 perror("malloc");
 570                 return NULL;
 571         }
 572         strcpy(relaname, ".rela");
 573         strcat(relaname, base->name);
 574
 575         sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
 576         free(relaname);
 577         if (!sec)
 578                 return NULL;
 579
 580         base->rela = sec;
 581         sec->base = base;
 582
 583         sec->sh.sh_type = SHT_RELA;
 584         sec->sh.sh_addralign = 8;
 585         sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
 586         sec->sh.sh_info = base->idx;
 587         sec->sh.sh_flags = SHF_INFO_LINK;
 588
 589         return sec;
 590 }
 591
 592 int elf_rebuild_rela_section(struct section *sec)
 593 {
 594         struct rela *rela;
 595         int nr, idx = 0, size;
 596         GElf_Rela *relas;
 597
 598         nr = 0;
 599         list_for_each_entry(rela, &sec->rela_list, list)
 600                 nr++;
 601
 602         size = nr * sizeof(*relas);
 603         relas = malloc(size);
 604         if (!relas) {
 605                 perror("malloc");
 606                 return -1;
 607         }
 608
 609         sec->data->d_buf = relas;
 610         sec->data->d_size = size;
 611
 612         sec->sh.sh_size = size;
 613
 614         idx = 0;
 615         list_for_each_entry(rela, &sec->rela_list, list) {
 616                 relas[idx].r_offset = rela->offset;
 617                 relas[idx].r_addend = rela->addend;
 618                 relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
 619                 idx++;
 620         }
 621
 622         return 0;
 623 }
 624
 625 int elf_write(struct elf *elf)
 626 {
 627         struct section *sec;
 628         Elf_Scn *s;
 629
 630         /* Update section headers for changed sections: */
 631         list_for_each_entry(sec, &elf->sections, list) {
 632                 if (sec->changed) {
 633                         s = elf_getscn(elf->elf, sec->idx);
 634                         if (!s) {
 635                                 WARN_ELF("elf_getscn");
 636                                 return -1;
 637                         }
 638                         if (!gelf_update_shdr(s, &sec->sh)) {
 639                                 WARN_ELF("gelf_update_shdr");
 640                                 return -1;
 641                         }
 642                 }
 643         }
 644
 645         /* Make sure the new section header entries get updated properly. */
 646         elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
 647
 648         /* Write all changes to the file. */
 649         if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
 650                 WARN_ELF("elf_update");
 651                 return -1;
 652         }
 653
 654         return 0;
 655 }
 656
 657 void elf_close(struct elf *elf)
 658 {
 659         struct section *sec, *tmpsec;
 660         struct symbol *sym, *tmpsym;
 661         struct rela *rela, *tmprela;
 662
 663         if (elf->elf)
 664                 elf_end(elf->elf);
 665
 666         if (elf->fd > 0)
 667                 close(elf->fd);
 668
 669         list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
 670                 list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
 671                         list_del(&sym->list);
 672                         hash_del(&sym->hash);
 673                         free(sym);
 674                 }
 675                 list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
 676                         list_del(&rela->list);
 677                         hash_del(&rela->hash);
 678                         free(rela);
 679                 }
 680                 list_del(&sec->list);
 681                 free(sec);
 682         }
 683
 684         free(elf);
 685 }