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 #include "builtin.h" 19 20 #include "elf.h" 21 #include "warn.h" 22 23 #define MAX_NAME_LEN 128 24 25 static inline u32 str_hash(const char *str) 26 { 27 return jhash(str, strlen(str), 0); 28 } 29 30 static inline int elf_hash_bits(void) 31 { 32 return vmlinux ? ELF_HASH_BITS : 16; 33 } 34 35 #define elf_hash_add(hashtable, node, key) \ 36 hlist_add_head(node, &hashtable[hash_min(key, elf_hash_bits())]) 37 38 static void elf_hash_init(struct hlist_head *table) 39 { 40 __hash_init(table, 1U << elf_hash_bits()); 41 } 42 43 #define elf_hash_for_each_possible(name, obj, member, key) \ 44 hlist_for_each_entry(obj, &name[hash_min(key, elf_hash_bits())], member) 45 46 static void rb_add(struct rb_root *tree, struct rb_node *node, 47 int (*cmp)(struct rb_node *, const struct rb_node *)) 48 { 49 struct rb_node **link = &tree->rb_node; 50 struct rb_node *parent = NULL; 51 52 while (*link) { 53 parent = *link; 54 if (cmp(node, parent) < 0) 55 link = &parent->rb_left; 56 else 57 link = &parent->rb_right; 58 } 59 60 rb_link_node(node, parent, link); 61 rb_insert_color(node, tree); 62 } 63 64 static struct rb_node *rb_find_first(const struct rb_root *tree, const void *key, 65 int (*cmp)(const void *key, const struct rb_node *)) 66 { 67 struct rb_node *node = tree->rb_node; 68 struct rb_node *match = NULL; 69 70 while (node) { 71 int c = cmp(key, node); 72 if (c <= 0) { 73 if (!c) 74 match = node; 75 node = node->rb_left; 76 } else if (c > 0) { 77 node = node->rb_right; 78 } 79 } 80 81 return match; 82 } 83 84 static struct rb_node *rb_next_match(struct rb_node *node, const void *key, 85 int (*cmp)(const void *key, const struct rb_node *)) 86 { 87 node = rb_next(node); 88 if (node && cmp(key, node)) 89 node = NULL; 90 return node; 91 } 92 93 #define rb_for_each(tree, node, key, cmp) \ 94 for ((node) = rb_find_first((tree), (key), (cmp)); \ 95 (node); (node) = rb_next_match((node), (key), (cmp))) 96 97 static int symbol_to_offset(struct rb_node *a, const struct rb_node *b) 98 { 99 struct symbol *sa = rb_entry(a, struct symbol, node); 100 struct symbol *sb = rb_entry(b, struct symbol, node); 101 102 if (sa->offset < sb->offset) 103 return -1; 104 if (sa->offset > sb->offset) 105 return 1; 106 107 if (sa->len < sb->len) 108 return -1; 109 if (sa->len > sb->len) 110 return 1; 111 112 sa->alias = sb; 113 114 return 0; 115 } 116 117 static int symbol_by_offset(const void *key, const struct rb_node *node) 118 { 119 const struct symbol *s = rb_entry(node, struct symbol, node); 120 const unsigned long *o = key; 121 122 if (*o < s->offset) 123 return -1; 124 if (*o >= s->offset + s->len) 125 return 1; 126 127 return 0; 128 } 129 130 struct section *find_section_by_name(const struct elf *elf, const char *name) 131 { 132 struct section *sec; 133 134 elf_hash_for_each_possible(elf->section_name_hash, sec, name_hash, str_hash(name)) 135 if (!strcmp(sec->name, name)) 136 return sec; 137 138 return NULL; 139 } 140 141 static struct section *find_section_by_index(struct elf *elf, 142 unsigned int idx) 143 { 144 struct section *sec; 145 146 elf_hash_for_each_possible(elf->section_hash, sec, hash, idx) 147 if (sec->idx == idx) 148 return sec; 149 150 return NULL; 151 } 152 153 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx) 154 { 155 struct symbol *sym; 156 157 elf_hash_for_each_possible(elf->symbol_hash, sym, hash, idx) 158 if (sym->idx == idx) 159 return sym; 160 161 return NULL; 162 } 163 164 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset) 165 { 166 struct rb_node *node; 167 168 rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) { 169 struct symbol *s = rb_entry(node, struct symbol, node); 170 171 if (s->offset == offset && s->type != STT_SECTION) 172 return s; 173 } 174 175 return NULL; 176 } 177 178 struct symbol *find_func_by_offset(struct section *sec, unsigned long offset) 179 { 180 struct rb_node *node; 181 182 rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) { 183 struct symbol *s = rb_entry(node, struct symbol, node); 184 185 if (s->offset == offset && s->type == STT_FUNC) 186 return s; 187 } 188 189 return NULL; 190 } 191 192 struct symbol *find_symbol_containing(const struct section *sec, unsigned long offset) 193 { 194 struct rb_node *node; 195 196 rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) { 197 struct symbol *s = rb_entry(node, struct symbol, node); 198 199 if (s->type != STT_SECTION) 200 return s; 201 } 202 203 return NULL; 204 } 205 206 struct symbol *find_func_containing(struct section *sec, unsigned long offset) 207 { 208 struct rb_node *node; 209 210 rb_for_each(&sec->symbol_tree, node, &offset, symbol_by_offset) { 211 struct symbol *s = rb_entry(node, struct symbol, node); 212 213 if (s->type == STT_FUNC) 214 return s; 215 } 216 217 return NULL; 218 } 219 220 struct symbol *find_symbol_by_name(const struct elf *elf, const char *name) 221 { 222 struct symbol *sym; 223 224 elf_hash_for_each_possible(elf->symbol_name_hash, sym, name_hash, str_hash(name)) 225 if (!strcmp(sym->name, name)) 226 return sym; 227 228 return NULL; 229 } 230 231 struct reloc *find_reloc_by_dest_range(const struct elf *elf, struct section *sec, 232 unsigned long offset, unsigned int len) 233 { 234 struct reloc *reloc, *r = NULL; 235 unsigned long o; 236 237 if (!sec->reloc) 238 return NULL; 239 240 sec = sec->reloc; 241 242 for_offset_range(o, offset, offset + len) { 243 elf_hash_for_each_possible(elf->reloc_hash, reloc, hash, 244 sec_offset_hash(sec, o)) { 245 if (reloc->sec != sec) 246 continue; 247 248 if (reloc->offset >= offset && reloc->offset < offset + len) { 249 if (!r || reloc->offset < r->offset) 250 r = reloc; 251 } 252 } 253 if (r) 254 return r; 255 } 256 257 return NULL; 258 } 259 260 struct reloc *find_reloc_by_dest(const struct elf *elf, struct section *sec, unsigned long offset) 261 { 262 return find_reloc_by_dest_range(elf, sec, offset, 1); 263 } 264 265 void insn_to_reloc_sym_addend(struct section *sec, unsigned long offset, 266 struct reloc *reloc) 267 { 268 if (sec->sym) { 269 reloc->sym = sec->sym; 270 reloc->addend = offset; 271 return; 272 } 273 274 /* 275 * The Clang assembler strips section symbols, so we have to reference 276 * the function symbol instead: 277 */ 278 reloc->sym = find_symbol_containing(sec, offset); 279 if (!reloc->sym) { 280 /* 281 * Hack alert. This happens when we need to reference the NOP 282 * pad insn immediately after the function. 283 */ 284 reloc->sym = find_symbol_containing(sec, offset - 1); 285 } 286 287 if (reloc->sym) 288 reloc->addend = offset - reloc->sym->offset; 289 } 290 291 static int read_sections(struct elf *elf) 292 { 293 Elf_Scn *s = NULL; 294 struct section *sec; 295 size_t shstrndx, sections_nr; 296 int i; 297 298 if (elf_getshdrnum(elf->elf, §ions_nr)) { 299 WARN_ELF("elf_getshdrnum"); 300 return -1; 301 } 302 303 if (elf_getshdrstrndx(elf->elf, &shstrndx)) { 304 WARN_ELF("elf_getshdrstrndx"); 305 return -1; 306 } 307 308 for (i = 0; i < sections_nr; i++) { 309 sec = malloc(sizeof(*sec)); 310 if (!sec) { 311 perror("malloc"); 312 return -1; 313 } 314 memset(sec, 0, sizeof(*sec)); 315 316 INIT_LIST_HEAD(&sec->symbol_list); 317 INIT_LIST_HEAD(&sec->reloc_list); 318 319 s = elf_getscn(elf->elf, i); 320 if (!s) { 321 WARN_ELF("elf_getscn"); 322 return -1; 323 } 324 325 sec->idx = elf_ndxscn(s); 326 327 if (!gelf_getshdr(s, &sec->sh)) { 328 WARN_ELF("gelf_getshdr"); 329 return -1; 330 } 331 332 sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name); 333 if (!sec->name) { 334 WARN_ELF("elf_strptr"); 335 return -1; 336 } 337 338 if (sec->sh.sh_size != 0) { 339 sec->data = elf_getdata(s, NULL); 340 if (!sec->data) { 341 WARN_ELF("elf_getdata"); 342 return -1; 343 } 344 if (sec->data->d_off != 0 || 345 sec->data->d_size != sec->sh.sh_size) { 346 WARN("unexpected data attributes for %s", 347 sec->name); 348 return -1; 349 } 350 } 351 sec->len = sec->sh.sh_size; 352 353 list_add_tail(&sec->list, &elf->sections); 354 elf_hash_add(elf->section_hash, &sec->hash, sec->idx); 355 elf_hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name)); 356 } 357 358 if (stats) 359 printf("nr_sections: %lu\n", (unsigned long)sections_nr); 360 361 /* sanity check, one more call to elf_nextscn() should return NULL */ 362 if (elf_nextscn(elf->elf, s)) { 363 WARN("section entry mismatch"); 364 return -1; 365 } 366 367 return 0; 368 } 369 370 static int read_symbols(struct elf *elf) 371 { 372 struct section *symtab, *symtab_shndx, *sec; 373 struct symbol *sym, *pfunc; 374 struct list_head *entry; 375 struct rb_node *pnode; 376 int symbols_nr, i; 377 char *coldstr; 378 Elf_Data *shndx_data = NULL; 379 Elf32_Word shndx; 380 381 symtab = find_section_by_name(elf, ".symtab"); 382 if (!symtab) { 383 /* 384 * A missing symbol table is actually possible if it's an empty 385 * .o file. This can happen for thunk_64.o. 386 */ 387 return 0; 388 } 389 390 symtab_shndx = find_section_by_name(elf, ".symtab_shndx"); 391 if (symtab_shndx) 392 shndx_data = symtab_shndx->data; 393 394 symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize; 395 396 for (i = 0; i < symbols_nr; i++) { 397 sym = malloc(sizeof(*sym)); 398 if (!sym) { 399 perror("malloc"); 400 return -1; 401 } 402 memset(sym, 0, sizeof(*sym)); 403 sym->alias = sym; 404 405 sym->idx = i; 406 407 if (!gelf_getsymshndx(symtab->data, shndx_data, i, &sym->sym, 408 &shndx)) { 409 WARN_ELF("gelf_getsymshndx"); 410 goto err; 411 } 412 413 sym->name = elf_strptr(elf->elf, symtab->sh.sh_link, 414 sym->sym.st_name); 415 if (!sym->name) { 416 WARN_ELF("elf_strptr"); 417 goto err; 418 } 419 420 sym->type = GELF_ST_TYPE(sym->sym.st_info); 421 sym->bind = GELF_ST_BIND(sym->sym.st_info); 422 423 if ((sym->sym.st_shndx > SHN_UNDEF && 424 sym->sym.st_shndx < SHN_LORESERVE) || 425 (shndx_data && sym->sym.st_shndx == SHN_XINDEX)) { 426 if (sym->sym.st_shndx != SHN_XINDEX) 427 shndx = sym->sym.st_shndx; 428 429 sym->sec = find_section_by_index(elf, shndx); 430 if (!sym->sec) { 431 WARN("couldn't find section for symbol %s", 432 sym->name); 433 goto err; 434 } 435 if (sym->type == STT_SECTION) { 436 sym->name = sym->sec->name; 437 sym->sec->sym = sym; 438 } 439 } else 440 sym->sec = find_section_by_index(elf, 0); 441 442 sym->offset = sym->sym.st_value; 443 sym->len = sym->sym.st_size; 444 445 rb_add(&sym->sec->symbol_tree, &sym->node, symbol_to_offset); 446 pnode = rb_prev(&sym->node); 447 if (pnode) 448 entry = &rb_entry(pnode, struct symbol, node)->list; 449 else 450 entry = &sym->sec->symbol_list; 451 list_add(&sym->list, entry); 452 elf_hash_add(elf->symbol_hash, &sym->hash, sym->idx); 453 elf_hash_add(elf->symbol_name_hash, &sym->name_hash, str_hash(sym->name)); 454 455 /* 456 * Don't store empty STT_NOTYPE symbols in the rbtree. They 457 * can exist within a function, confusing the sorting. 458 */ 459 if (!sym->len) 460 rb_erase(&sym->node, &sym->sec->symbol_tree); 461 } 462 463 if (stats) 464 printf("nr_symbols: %lu\n", (unsigned long)symbols_nr); 465 466 /* Create parent/child links for any cold subfunctions */ 467 list_for_each_entry(sec, &elf->sections, list) { 468 list_for_each_entry(sym, &sec->symbol_list, list) { 469 char pname[MAX_NAME_LEN + 1]; 470 size_t pnamelen; 471 if (sym->type != STT_FUNC) 472 continue; 473 474 if (sym->pfunc == NULL) 475 sym->pfunc = sym; 476 477 if (sym->cfunc == NULL) 478 sym->cfunc = sym; 479 480 coldstr = strstr(sym->name, ".cold"); 481 if (!coldstr) 482 continue; 483 484 pnamelen = coldstr - sym->name; 485 if (pnamelen > MAX_NAME_LEN) { 486 WARN("%s(): parent function name exceeds maximum length of %d characters", 487 sym->name, MAX_NAME_LEN); 488 return -1; 489 } 490 491 strncpy(pname, sym->name, pnamelen); 492 pname[pnamelen] = '\0'; 493 pfunc = find_symbol_by_name(elf, pname); 494 495 if (!pfunc) { 496 WARN("%s(): can't find parent function", 497 sym->name); 498 return -1; 499 } 500 501 sym->pfunc = pfunc; 502 pfunc->cfunc = sym; 503 504 /* 505 * Unfortunately, -fnoreorder-functions puts the child 506 * inside the parent. Remove the overlap so we can 507 * have sane assumptions. 508 * 509 * Note that pfunc->len now no longer matches 510 * pfunc->sym.st_size. 511 */ 512 if (sym->sec == pfunc->sec && 513 sym->offset >= pfunc->offset && 514 sym->offset + sym->len == pfunc->offset + pfunc->len) { 515 pfunc->len -= sym->len; 516 } 517 } 518 } 519 520 return 0; 521 522 err: 523 free(sym); 524 return -1; 525 } 526 527 void elf_add_reloc(struct elf *elf, struct reloc *reloc) 528 { 529 struct section *sec = reloc->sec; 530 531 list_add_tail(&reloc->list, &sec->reloc_list); 532 elf_hash_add(elf->reloc_hash, &reloc->hash, reloc_hash(reloc)); 533 } 534 535 static int read_rel_reloc(struct section *sec, int i, struct reloc *reloc, unsigned int *symndx) 536 { 537 if (!gelf_getrel(sec->data, i, &reloc->rel)) { 538 WARN_ELF("gelf_getrel"); 539 return -1; 540 } 541 reloc->type = GELF_R_TYPE(reloc->rel.r_info); 542 reloc->addend = 0; 543 reloc->offset = reloc->rel.r_offset; 544 *symndx = GELF_R_SYM(reloc->rel.r_info); 545 return 0; 546 } 547 548 static int read_rela_reloc(struct section *sec, int i, struct reloc *reloc, unsigned int *symndx) 549 { 550 if (!gelf_getrela(sec->data, i, &reloc->rela)) { 551 WARN_ELF("gelf_getrela"); 552 return -1; 553 } 554 reloc->type = GELF_R_TYPE(reloc->rela.r_info); 555 reloc->addend = reloc->rela.r_addend; 556 reloc->offset = reloc->rela.r_offset; 557 *symndx = GELF_R_SYM(reloc->rela.r_info); 558 return 0; 559 } 560 561 static int read_relocs(struct elf *elf) 562 { 563 struct section *sec; 564 struct reloc *reloc; 565 int i; 566 unsigned int symndx; 567 unsigned long nr_reloc, max_reloc = 0, tot_reloc = 0; 568 569 list_for_each_entry(sec, &elf->sections, list) { 570 if ((sec->sh.sh_type != SHT_RELA) && 571 (sec->sh.sh_type != SHT_REL)) 572 continue; 573 574 sec->base = find_section_by_index(elf, sec->sh.sh_info); 575 if (!sec->base) { 576 WARN("can't find base section for reloc section %s", 577 sec->name); 578 return -1; 579 } 580 581 sec->base->reloc = sec; 582 583 nr_reloc = 0; 584 for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) { 585 reloc = malloc(sizeof(*reloc)); 586 if (!reloc) { 587 perror("malloc"); 588 return -1; 589 } 590 memset(reloc, 0, sizeof(*reloc)); 591 switch (sec->sh.sh_type) { 592 case SHT_REL: 593 if (read_rel_reloc(sec, i, reloc, &symndx)) 594 return -1; 595 break; 596 case SHT_RELA: 597 if (read_rela_reloc(sec, i, reloc, &symndx)) 598 return -1; 599 break; 600 default: return -1; 601 } 602 603 reloc->sec = sec; 604 reloc->idx = i; 605 reloc->sym = find_symbol_by_index(elf, symndx); 606 if (!reloc->sym) { 607 WARN("can't find reloc entry symbol %d for %s", 608 symndx, sec->name); 609 return -1; 610 } 611 612 elf_add_reloc(elf, reloc); 613 nr_reloc++; 614 } 615 max_reloc = max(max_reloc, nr_reloc); 616 tot_reloc += nr_reloc; 617 } 618 619 if (stats) { 620 printf("max_reloc: %lu\n", max_reloc); 621 printf("tot_reloc: %lu\n", tot_reloc); 622 } 623 624 return 0; 625 } 626 627 struct elf *elf_open_read(const char *name, int flags) 628 { 629 struct elf *elf; 630 Elf_Cmd cmd; 631 632 elf_version(EV_CURRENT); 633 634 elf = malloc(sizeof(*elf)); 635 if (!elf) { 636 perror("malloc"); 637 return NULL; 638 } 639 memset(elf, 0, offsetof(struct elf, sections)); 640 641 INIT_LIST_HEAD(&elf->sections); 642 643 elf_hash_init(elf->symbol_hash); 644 elf_hash_init(elf->symbol_name_hash); 645 elf_hash_init(elf->section_hash); 646 elf_hash_init(elf->section_name_hash); 647 elf_hash_init(elf->reloc_hash); 648 649 elf->fd = open(name, flags); 650 if (elf->fd == -1) { 651 fprintf(stderr, "objtool: Can't open '%s': %s\n", 652 name, strerror(errno)); 653 goto err; 654 } 655 656 if ((flags & O_ACCMODE) == O_RDONLY) 657 cmd = ELF_C_READ_MMAP; 658 else if ((flags & O_ACCMODE) == O_RDWR) 659 cmd = ELF_C_RDWR; 660 else /* O_WRONLY */ 661 cmd = ELF_C_WRITE; 662 663 elf->elf = elf_begin(elf->fd, cmd, NULL); 664 if (!elf->elf) { 665 WARN_ELF("elf_begin"); 666 goto err; 667 } 668 669 if (!gelf_getehdr(elf->elf, &elf->ehdr)) { 670 WARN_ELF("gelf_getehdr"); 671 goto err; 672 } 673 674 if (read_sections(elf)) 675 goto err; 676 677 if (read_symbols(elf)) 678 goto err; 679 680 if (read_relocs(elf)) 681 goto err; 682 683 return elf; 684 685 err: 686 elf_close(elf); 687 return NULL; 688 } 689 690 struct section *elf_create_section(struct elf *elf, const char *name, 691 unsigned int sh_flags, size_t entsize, int nr) 692 { 693 struct section *sec, *shstrtab; 694 size_t size = entsize * nr; 695 Elf_Scn *s; 696 Elf_Data *data; 697 698 sec = malloc(sizeof(*sec)); 699 if (!sec) { 700 perror("malloc"); 701 return NULL; 702 } 703 memset(sec, 0, sizeof(*sec)); 704 705 INIT_LIST_HEAD(&sec->symbol_list); 706 INIT_LIST_HEAD(&sec->reloc_list); 707 708 s = elf_newscn(elf->elf); 709 if (!s) { 710 WARN_ELF("elf_newscn"); 711 return NULL; 712 } 713 714 sec->name = strdup(name); 715 if (!sec->name) { 716 perror("strdup"); 717 return NULL; 718 } 719 720 sec->idx = elf_ndxscn(s); 721 sec->len = size; 722 sec->changed = true; 723 724 sec->data = elf_newdata(s); 725 if (!sec->data) { 726 WARN_ELF("elf_newdata"); 727 return NULL; 728 } 729 730 sec->data->d_size = size; 731 sec->data->d_align = 1; 732 733 if (size) { 734 sec->data->d_buf = malloc(size); 735 if (!sec->data->d_buf) { 736 perror("malloc"); 737 return NULL; 738 } 739 memset(sec->data->d_buf, 0, size); 740 } 741 742 if (!gelf_getshdr(s, &sec->sh)) { 743 WARN_ELF("gelf_getshdr"); 744 return NULL; 745 } 746 747 sec->sh.sh_size = size; 748 sec->sh.sh_entsize = entsize; 749 sec->sh.sh_type = SHT_PROGBITS; 750 sec->sh.sh_addralign = 1; 751 sec->sh.sh_flags = SHF_ALLOC | sh_flags; 752 753 754 /* Add section name to .shstrtab (or .strtab for Clang) */ 755 shstrtab = find_section_by_name(elf, ".shstrtab"); 756 if (!shstrtab) 757 shstrtab = find_section_by_name(elf, ".strtab"); 758 if (!shstrtab) { 759 WARN("can't find .shstrtab or .strtab section"); 760 return NULL; 761 } 762 763 s = elf_getscn(elf->elf, shstrtab->idx); 764 if (!s) { 765 WARN_ELF("elf_getscn"); 766 return NULL; 767 } 768 769 data = elf_newdata(s); 770 if (!data) { 771 WARN_ELF("elf_newdata"); 772 return NULL; 773 } 774 775 data->d_buf = sec->name; 776 data->d_size = strlen(name) + 1; 777 data->d_align = 1; 778 779 sec->sh.sh_name = shstrtab->len; 780 781 shstrtab->len += strlen(name) + 1; 782 shstrtab->changed = true; 783 784 list_add_tail(&sec->list, &elf->sections); 785 elf_hash_add(elf->section_hash, &sec->hash, sec->idx); 786 elf_hash_add(elf->section_name_hash, &sec->name_hash, str_hash(sec->name)); 787 788 elf->changed = true; 789 790 return sec; 791 } 792 793 static struct section *elf_create_rel_reloc_section(struct elf *elf, struct section *base) 794 { 795 char *relocname; 796 struct section *sec; 797 798 relocname = malloc(strlen(base->name) + strlen(".rel") + 1); 799 if (!relocname) { 800 perror("malloc"); 801 return NULL; 802 } 803 strcpy(relocname, ".rel"); 804 strcat(relocname, base->name); 805 806 sec = elf_create_section(elf, relocname, 0, sizeof(GElf_Rel), 0); 807 free(relocname); 808 if (!sec) 809 return NULL; 810 811 base->reloc = sec; 812 sec->base = base; 813 814 sec->sh.sh_type = SHT_REL; 815 sec->sh.sh_addralign = 8; 816 sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx; 817 sec->sh.sh_info = base->idx; 818 sec->sh.sh_flags = SHF_INFO_LINK; 819 820 return sec; 821 } 822 823 static struct section *elf_create_rela_reloc_section(struct elf *elf, struct section *base) 824 { 825 char *relocname; 826 struct section *sec; 827 828 relocname = malloc(strlen(base->name) + strlen(".rela") + 1); 829 if (!relocname) { 830 perror("malloc"); 831 return NULL; 832 } 833 strcpy(relocname, ".rela"); 834 strcat(relocname, base->name); 835 836 sec = elf_create_section(elf, relocname, 0, sizeof(GElf_Rela), 0); 837 free(relocname); 838 if (!sec) 839 return NULL; 840 841 base->reloc = sec; 842 sec->base = base; 843 844 sec->sh.sh_type = SHT_RELA; 845 sec->sh.sh_addralign = 8; 846 sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx; 847 sec->sh.sh_info = base->idx; 848 sec->sh.sh_flags = SHF_INFO_LINK; 849 850 return sec; 851 } 852 853 struct section *elf_create_reloc_section(struct elf *elf, 854 struct section *base, 855 int reltype) 856 { 857 switch (reltype) { 858 case SHT_REL: return elf_create_rel_reloc_section(elf, base); 859 case SHT_RELA: return elf_create_rela_reloc_section(elf, base); 860 default: return NULL; 861 } 862 } 863 864 static int elf_rebuild_rel_reloc_section(struct section *sec, int nr) 865 { 866 struct reloc *reloc; 867 int idx = 0, size; 868 GElf_Rel *relocs; 869 870 /* Allocate a buffer for relocations */ 871 size = nr * sizeof(*relocs); 872 relocs = malloc(size); 873 if (!relocs) { 874 perror("malloc"); 875 return -1; 876 } 877 878 sec->data->d_buf = relocs; 879 sec->data->d_size = size; 880 881 sec->sh.sh_size = size; 882 883 idx = 0; 884 list_for_each_entry(reloc, &sec->reloc_list, list) { 885 relocs[idx].r_offset = reloc->offset; 886 relocs[idx].r_info = GELF_R_INFO(reloc->sym->idx, reloc->type); 887 idx++; 888 } 889 890 return 0; 891 } 892 893 static int elf_rebuild_rela_reloc_section(struct section *sec, int nr) 894 { 895 struct reloc *reloc; 896 int idx = 0, size; 897 GElf_Rela *relocs; 898 899 /* Allocate a buffer for relocations with addends */ 900 size = nr * sizeof(*relocs); 901 relocs = malloc(size); 902 if (!relocs) { 903 perror("malloc"); 904 return -1; 905 } 906 907 sec->data->d_buf = relocs; 908 sec->data->d_size = size; 909 910 sec->sh.sh_size = size; 911 912 idx = 0; 913 list_for_each_entry(reloc, &sec->reloc_list, list) { 914 relocs[idx].r_offset = reloc->offset; 915 relocs[idx].r_addend = reloc->addend; 916 relocs[idx].r_info = GELF_R_INFO(reloc->sym->idx, reloc->type); 917 idx++; 918 } 919 920 return 0; 921 } 922 923 int elf_rebuild_reloc_section(struct elf *elf, struct section *sec) 924 { 925 struct reloc *reloc; 926 int nr; 927 928 sec->changed = true; 929 elf->changed = true; 930 931 nr = 0; 932 list_for_each_entry(reloc, &sec->reloc_list, list) 933 nr++; 934 935 switch (sec->sh.sh_type) { 936 case SHT_REL: return elf_rebuild_rel_reloc_section(sec, nr); 937 case SHT_RELA: return elf_rebuild_rela_reloc_section(sec, nr); 938 default: return -1; 939 } 940 } 941 942 int elf_write_insn(struct elf *elf, struct section *sec, 943 unsigned long offset, unsigned int len, 944 const char *insn) 945 { 946 Elf_Data *data = sec->data; 947 948 if (data->d_type != ELF_T_BYTE || data->d_off) { 949 WARN("write to unexpected data for section: %s", sec->name); 950 return -1; 951 } 952 953 memcpy(data->d_buf + offset, insn, len); 954 elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY); 955 956 elf->changed = true; 957 958 return 0; 959 } 960 961 int elf_write_reloc(struct elf *elf, struct reloc *reloc) 962 { 963 struct section *sec = reloc->sec; 964 965 if (sec->sh.sh_type == SHT_REL) { 966 reloc->rel.r_info = GELF_R_INFO(reloc->sym->idx, reloc->type); 967 reloc->rel.r_offset = reloc->offset; 968 969 if (!gelf_update_rel(sec->data, reloc->idx, &reloc->rel)) { 970 WARN_ELF("gelf_update_rel"); 971 return -1; 972 } 973 } else { 974 reloc->rela.r_info = GELF_R_INFO(reloc->sym->idx, reloc->type); 975 reloc->rela.r_addend = reloc->addend; 976 reloc->rela.r_offset = reloc->offset; 977 978 if (!gelf_update_rela(sec->data, reloc->idx, &reloc->rela)) { 979 WARN_ELF("gelf_update_rela"); 980 return -1; 981 } 982 } 983 984 elf->changed = true; 985 986 return 0; 987 } 988 989 int elf_write(struct elf *elf) 990 { 991 struct section *sec; 992 Elf_Scn *s; 993 994 /* Update section headers for changed sections: */ 995 list_for_each_entry(sec, &elf->sections, list) { 996 if (sec->changed) { 997 s = elf_getscn(elf->elf, sec->idx); 998 if (!s) { 999 WARN_ELF("elf_getscn"); 1000 return -1; 1001 } 1002 if (!gelf_update_shdr(s, &sec->sh)) { 1003 WARN_ELF("gelf_update_shdr"); 1004 return -1; 1005 } 1006 1007 sec->changed = false; 1008 } 1009 } 1010 1011 /* Make sure the new section header entries get updated properly. */ 1012 elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY); 1013 1014 /* Write all changes to the file. */ 1015 if (elf_update(elf->elf, ELF_C_WRITE) < 0) { 1016 WARN_ELF("elf_update"); 1017 return -1; 1018 } 1019 1020 elf->changed = false; 1021 1022 return 0; 1023 } 1024 1025 void elf_close(struct elf *elf) 1026 { 1027 struct section *sec, *tmpsec; 1028 struct symbol *sym, *tmpsym; 1029 struct reloc *reloc, *tmpreloc; 1030 1031 if (elf->elf) 1032 elf_end(elf->elf); 1033 1034 if (elf->fd > 0) 1035 close(elf->fd); 1036 1037 list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) { 1038 list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) { 1039 list_del(&sym->list); 1040 hash_del(&sym->hash); 1041 free(sym); 1042 } 1043 list_for_each_entry_safe(reloc, tmpreloc, &sec->reloc_list, list) { 1044 list_del(&reloc->list); 1045 hash_del(&reloc->hash); 1046 free(reloc); 1047 } 1048 list_del(&sec->list); 1049 free(sec); 1050 } 1051 1052 free(elf); 1053 } 1054