1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) 2 3 /* 4 * resolve_btfids scans Elf object for .BTF_ids section and resolves 5 * its symbols with BTF ID values. 6 * 7 * Each symbol points to 4 bytes data and is expected to have 8 * following name syntax: 9 * 10 * __BTF_ID__<type>__<symbol>[__<id>] 11 * 12 * type is: 13 * 14 * func - lookup BTF_KIND_FUNC symbol with <symbol> name 15 * and store its ID into the data: 16 * 17 * __BTF_ID__func__vfs_close__1: 18 * .zero 4 19 * 20 * struct - lookup BTF_KIND_STRUCT symbol with <symbol> name 21 * and store its ID into the data: 22 * 23 * __BTF_ID__struct__sk_buff__1: 24 * .zero 4 25 * 26 * union - lookup BTF_KIND_UNION symbol with <symbol> name 27 * and store its ID into the data: 28 * 29 * __BTF_ID__union__thread_union__1: 30 * .zero 4 31 * 32 * typedef - lookup BTF_KIND_TYPEDEF symbol with <symbol> name 33 * and store its ID into the data: 34 * 35 * __BTF_ID__typedef__pid_t__1: 36 * .zero 4 37 * 38 * set - store symbol size into first 4 bytes and sort following 39 * ID list 40 * 41 * __BTF_ID__set__list: 42 * .zero 4 43 * list: 44 * __BTF_ID__func__vfs_getattr__3: 45 * .zero 4 46 * __BTF_ID__func__vfs_fallocate__4: 47 * .zero 4 48 */ 49 50 #define _GNU_SOURCE 51 #include <stdio.h> 52 #include <string.h> 53 #include <unistd.h> 54 #include <stdlib.h> 55 #include <libelf.h> 56 #include <gelf.h> 57 #include <sys/stat.h> 58 #include <fcntl.h> 59 #include <errno.h> 60 #include <linux/rbtree.h> 61 #include <linux/zalloc.h> 62 #include <linux/err.h> 63 #include <bpf/btf.h> 64 #include <bpf/libbpf.h> 65 #include <parse-options.h> 66 67 #define BTF_IDS_SECTION ".BTF_ids" 68 #define BTF_ID "__BTF_ID__" 69 70 #define BTF_STRUCT "struct" 71 #define BTF_UNION "union" 72 #define BTF_TYPEDEF "typedef" 73 #define BTF_FUNC "func" 74 #define BTF_SET "set" 75 76 #define ADDR_CNT 100 77 78 struct btf_id { 79 struct rb_node rb_node; 80 char *name; 81 union { 82 int id; 83 int cnt; 84 }; 85 int addr_cnt; 86 bool is_set; 87 Elf64_Addr addr[ADDR_CNT]; 88 }; 89 90 struct object { 91 const char *path; 92 const char *btf; 93 const char *base_btf_path; 94 95 struct { 96 int fd; 97 Elf *elf; 98 Elf_Data *symbols; 99 Elf_Data *idlist; 100 int symbols_shndx; 101 int idlist_shndx; 102 size_t strtabidx; 103 unsigned long idlist_addr; 104 } efile; 105 106 struct rb_root sets; 107 struct rb_root structs; 108 struct rb_root unions; 109 struct rb_root typedefs; 110 struct rb_root funcs; 111 112 int nr_funcs; 113 int nr_structs; 114 int nr_unions; 115 int nr_typedefs; 116 }; 117 118 static int verbose; 119 120 static int eprintf(int level, int var, const char *fmt, ...) 121 { 122 va_list args; 123 int ret = 0; 124 125 if (var >= level) { 126 va_start(args, fmt); 127 ret = vfprintf(stderr, fmt, args); 128 va_end(args); 129 } 130 return ret; 131 } 132 133 #ifndef pr_fmt 134 #define pr_fmt(fmt) fmt 135 #endif 136 137 #define pr_debug(fmt, ...) \ 138 eprintf(1, verbose, pr_fmt(fmt), ##__VA_ARGS__) 139 #define pr_debugN(n, fmt, ...) \ 140 eprintf(n, verbose, pr_fmt(fmt), ##__VA_ARGS__) 141 #define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__) 142 #define pr_err(fmt, ...) \ 143 eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__) 144 #define pr_info(fmt, ...) \ 145 eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__) 146 147 static bool is_btf_id(const char *name) 148 { 149 return name && !strncmp(name, BTF_ID, sizeof(BTF_ID) - 1); 150 } 151 152 static struct btf_id *btf_id__find(struct rb_root *root, const char *name) 153 { 154 struct rb_node *p = root->rb_node; 155 struct btf_id *id; 156 int cmp; 157 158 while (p) { 159 id = rb_entry(p, struct btf_id, rb_node); 160 cmp = strcmp(id->name, name); 161 if (cmp < 0) 162 p = p->rb_left; 163 else if (cmp > 0) 164 p = p->rb_right; 165 else 166 return id; 167 } 168 return NULL; 169 } 170 171 static struct btf_id* 172 btf_id__add(struct rb_root *root, char *name, bool unique) 173 { 174 struct rb_node **p = &root->rb_node; 175 struct rb_node *parent = NULL; 176 struct btf_id *id; 177 int cmp; 178 179 while (*p != NULL) { 180 parent = *p; 181 id = rb_entry(parent, struct btf_id, rb_node); 182 cmp = strcmp(id->name, name); 183 if (cmp < 0) 184 p = &(*p)->rb_left; 185 else if (cmp > 0) 186 p = &(*p)->rb_right; 187 else 188 return unique ? NULL : id; 189 } 190 191 id = zalloc(sizeof(*id)); 192 if (id) { 193 pr_debug("adding symbol %s\n", name); 194 id->name = name; 195 rb_link_node(&id->rb_node, parent, p); 196 rb_insert_color(&id->rb_node, root); 197 } 198 return id; 199 } 200 201 static char *get_id(const char *prefix_end) 202 { 203 /* 204 * __BTF_ID__func__vfs_truncate__0 205 * prefix_end = ^ 206 * pos = ^ 207 */ 208 int len = strlen(prefix_end); 209 int pos = sizeof("__") - 1; 210 char *p, *id; 211 212 if (pos >= len) 213 return NULL; 214 215 id = strdup(prefix_end + pos); 216 if (id) { 217 /* 218 * __BTF_ID__func__vfs_truncate__0 219 * id = ^ 220 * 221 * cut the unique id part 222 */ 223 p = strrchr(id, '_'); 224 p--; 225 if (*p != '_') { 226 free(id); 227 return NULL; 228 } 229 *p = '\0'; 230 } 231 return id; 232 } 233 234 static struct btf_id *add_set(struct object *obj, char *name) 235 { 236 /* 237 * __BTF_ID__set__name 238 * name = ^ 239 * id = ^ 240 */ 241 char *id = name + sizeof(BTF_SET "__") - 1; 242 int len = strlen(name); 243 244 if (id >= name + len) { 245 pr_err("FAILED to parse set name: %s\n", name); 246 return NULL; 247 } 248 249 return btf_id__add(&obj->sets, id, true); 250 } 251 252 static struct btf_id *add_symbol(struct rb_root *root, char *name, size_t size) 253 { 254 char *id; 255 256 id = get_id(name + size); 257 if (!id) { 258 pr_err("FAILED to parse symbol name: %s\n", name); 259 return NULL; 260 } 261 262 return btf_id__add(root, id, false); 263 } 264 265 /* Older libelf.h and glibc elf.h might not yet define the ELF compression types. */ 266 #ifndef SHF_COMPRESSED 267 #define SHF_COMPRESSED (1 << 11) /* Section with compressed data. */ 268 #endif 269 270 /* 271 * The data of compressed section should be aligned to 4 272 * (for 32bit) or 8 (for 64 bit) bytes. The binutils ld 273 * sets sh_addralign to 1, which makes libelf fail with 274 * misaligned section error during the update: 275 * FAILED elf_update(WRITE): invalid section alignment 276 * 277 * While waiting for ld fix, we fix the compressed sections 278 * sh_addralign value manualy. 279 */ 280 static int compressed_section_fix(Elf *elf, Elf_Scn *scn, GElf_Shdr *sh) 281 { 282 int expected = gelf_getclass(elf) == ELFCLASS32 ? 4 : 8; 283 284 if (!(sh->sh_flags & SHF_COMPRESSED)) 285 return 0; 286 287 if (sh->sh_addralign == expected) 288 return 0; 289 290 pr_debug2(" - fixing wrong alignment sh_addralign %u, expected %u\n", 291 sh->sh_addralign, expected); 292 293 sh->sh_addralign = expected; 294 295 if (gelf_update_shdr(scn, sh) == 0) { 296 pr_err("FAILED cannot update section header: %s\n", 297 elf_errmsg(-1)); 298 return -1; 299 } 300 return 0; 301 } 302 303 static int elf_collect(struct object *obj) 304 { 305 Elf_Scn *scn = NULL; 306 size_t shdrstrndx; 307 int idx = 0; 308 Elf *elf; 309 int fd; 310 311 fd = open(obj->path, O_RDWR, 0666); 312 if (fd == -1) { 313 pr_err("FAILED cannot open %s: %s\n", 314 obj->path, strerror(errno)); 315 return -1; 316 } 317 318 elf_version(EV_CURRENT); 319 320 elf = elf_begin(fd, ELF_C_RDWR_MMAP, NULL); 321 if (!elf) { 322 close(fd); 323 pr_err("FAILED cannot create ELF descriptor: %s\n", 324 elf_errmsg(-1)); 325 return -1; 326 } 327 328 obj->efile.fd = fd; 329 obj->efile.elf = elf; 330 331 elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT); 332 333 if (elf_getshdrstrndx(elf, &shdrstrndx) != 0) { 334 pr_err("FAILED cannot get shdr str ndx\n"); 335 return -1; 336 } 337 338 /* 339 * Scan all the elf sections and look for save data 340 * from .BTF_ids section and symbols. 341 */ 342 while ((scn = elf_nextscn(elf, scn)) != NULL) { 343 Elf_Data *data; 344 GElf_Shdr sh; 345 char *name; 346 347 idx++; 348 if (gelf_getshdr(scn, &sh) != &sh) { 349 pr_err("FAILED get section(%d) header\n", idx); 350 return -1; 351 } 352 353 name = elf_strptr(elf, shdrstrndx, sh.sh_name); 354 if (!name) { 355 pr_err("FAILED get section(%d) name\n", idx); 356 return -1; 357 } 358 359 data = elf_getdata(scn, 0); 360 if (!data) { 361 pr_err("FAILED to get section(%d) data from %s\n", 362 idx, name); 363 return -1; 364 } 365 366 pr_debug2("section(%d) %s, size %ld, link %d, flags %lx, type=%d\n", 367 idx, name, (unsigned long) data->d_size, 368 (int) sh.sh_link, (unsigned long) sh.sh_flags, 369 (int) sh.sh_type); 370 371 if (sh.sh_type == SHT_SYMTAB) { 372 obj->efile.symbols = data; 373 obj->efile.symbols_shndx = idx; 374 obj->efile.strtabidx = sh.sh_link; 375 } else if (!strcmp(name, BTF_IDS_SECTION)) { 376 obj->efile.idlist = data; 377 obj->efile.idlist_shndx = idx; 378 obj->efile.idlist_addr = sh.sh_addr; 379 } 380 381 if (compressed_section_fix(elf, scn, &sh)) 382 return -1; 383 } 384 385 return 0; 386 } 387 388 static int symbols_collect(struct object *obj) 389 { 390 Elf_Scn *scn = NULL; 391 int n, i; 392 GElf_Shdr sh; 393 char *name; 394 395 scn = elf_getscn(obj->efile.elf, obj->efile.symbols_shndx); 396 if (!scn) 397 return -1; 398 399 if (gelf_getshdr(scn, &sh) != &sh) 400 return -1; 401 402 n = sh.sh_size / sh.sh_entsize; 403 404 /* 405 * Scan symbols and look for the ones starting with 406 * __BTF_ID__* over .BTF_ids section. 407 */ 408 for (i = 0; i < n; i++) { 409 char *prefix; 410 struct btf_id *id; 411 GElf_Sym sym; 412 413 if (!gelf_getsym(obj->efile.symbols, i, &sym)) 414 return -1; 415 416 if (sym.st_shndx != obj->efile.idlist_shndx) 417 continue; 418 419 name = elf_strptr(obj->efile.elf, obj->efile.strtabidx, 420 sym.st_name); 421 422 if (!is_btf_id(name)) 423 continue; 424 425 /* 426 * __BTF_ID__TYPE__vfs_truncate__0 427 * prefix = ^ 428 */ 429 prefix = name + sizeof(BTF_ID) - 1; 430 431 /* struct */ 432 if (!strncmp(prefix, BTF_STRUCT, sizeof(BTF_STRUCT) - 1)) { 433 obj->nr_structs++; 434 id = add_symbol(&obj->structs, prefix, sizeof(BTF_STRUCT) - 1); 435 /* union */ 436 } else if (!strncmp(prefix, BTF_UNION, sizeof(BTF_UNION) - 1)) { 437 obj->nr_unions++; 438 id = add_symbol(&obj->unions, prefix, sizeof(BTF_UNION) - 1); 439 /* typedef */ 440 } else if (!strncmp(prefix, BTF_TYPEDEF, sizeof(BTF_TYPEDEF) - 1)) { 441 obj->nr_typedefs++; 442 id = add_symbol(&obj->typedefs, prefix, sizeof(BTF_TYPEDEF) - 1); 443 /* func */ 444 } else if (!strncmp(prefix, BTF_FUNC, sizeof(BTF_FUNC) - 1)) { 445 obj->nr_funcs++; 446 id = add_symbol(&obj->funcs, prefix, sizeof(BTF_FUNC) - 1); 447 /* set */ 448 } else if (!strncmp(prefix, BTF_SET, sizeof(BTF_SET) - 1)) { 449 id = add_set(obj, prefix); 450 /* 451 * SET objects store list's count, which is encoded 452 * in symbol's size, together with 'cnt' field hence 453 * that - 1. 454 */ 455 if (id) { 456 id->cnt = sym.st_size / sizeof(int) - 1; 457 id->is_set = true; 458 } 459 } else { 460 pr_err("FAILED unsupported prefix %s\n", prefix); 461 return -1; 462 } 463 464 if (!id) 465 return -ENOMEM; 466 467 if (id->addr_cnt >= ADDR_CNT) { 468 pr_err("FAILED symbol %s crossed the number of allowed lists\n", 469 id->name); 470 return -1; 471 } 472 id->addr[id->addr_cnt++] = sym.st_value; 473 } 474 475 return 0; 476 } 477 478 static int symbols_resolve(struct object *obj) 479 { 480 int nr_typedefs = obj->nr_typedefs; 481 int nr_structs = obj->nr_structs; 482 int nr_unions = obj->nr_unions; 483 int nr_funcs = obj->nr_funcs; 484 struct btf *base_btf = NULL; 485 int err, type_id; 486 struct btf *btf; 487 __u32 nr_types; 488 489 if (obj->base_btf_path) { 490 base_btf = btf__parse(obj->base_btf_path, NULL); 491 err = libbpf_get_error(base_btf); 492 if (err) { 493 pr_err("FAILED: load base BTF from %s: %s\n", 494 obj->base_btf_path, strerror(-err)); 495 return -1; 496 } 497 } 498 499 btf = btf__parse_split(obj->btf ?: obj->path, base_btf); 500 err = libbpf_get_error(btf); 501 if (err) { 502 pr_err("FAILED: load BTF from %s: %s\n", 503 obj->btf ?: obj->path, strerror(-err)); 504 goto out; 505 } 506 507 err = -1; 508 nr_types = btf__type_cnt(btf); 509 510 /* 511 * Iterate all the BTF types and search for collected symbol IDs. 512 */ 513 for (type_id = 1; type_id < nr_types; type_id++) { 514 const struct btf_type *type; 515 struct rb_root *root; 516 struct btf_id *id; 517 const char *str; 518 int *nr; 519 520 type = btf__type_by_id(btf, type_id); 521 if (!type) { 522 pr_err("FAILED: malformed BTF, can't resolve type for ID %d\n", 523 type_id); 524 goto out; 525 } 526 527 if (btf_is_func(type) && nr_funcs) { 528 nr = &nr_funcs; 529 root = &obj->funcs; 530 } else if (btf_is_struct(type) && nr_structs) { 531 nr = &nr_structs; 532 root = &obj->structs; 533 } else if (btf_is_union(type) && nr_unions) { 534 nr = &nr_unions; 535 root = &obj->unions; 536 } else if (btf_is_typedef(type) && nr_typedefs) { 537 nr = &nr_typedefs; 538 root = &obj->typedefs; 539 } else 540 continue; 541 542 str = btf__name_by_offset(btf, type->name_off); 543 if (!str) { 544 pr_err("FAILED: malformed BTF, can't resolve name for ID %d\n", 545 type_id); 546 goto out; 547 } 548 549 id = btf_id__find(root, str); 550 if (id) { 551 if (id->id) { 552 pr_info("WARN: multiple IDs found for '%s': %d, %d - using %d\n", 553 str, id->id, type_id, id->id); 554 } else { 555 id->id = type_id; 556 (*nr)--; 557 } 558 } 559 } 560 561 err = 0; 562 out: 563 btf__free(base_btf); 564 btf__free(btf); 565 return err; 566 } 567 568 static int id_patch(struct object *obj, struct btf_id *id) 569 { 570 Elf_Data *data = obj->efile.idlist; 571 int *ptr = data->d_buf; 572 int i; 573 574 if (!id->id && !id->is_set) 575 pr_err("WARN: resolve_btfids: unresolved symbol %s\n", id->name); 576 577 for (i = 0; i < id->addr_cnt; i++) { 578 unsigned long addr = id->addr[i]; 579 unsigned long idx = addr - obj->efile.idlist_addr; 580 581 pr_debug("patching addr %5lu: ID %7d [%s]\n", 582 idx, id->id, id->name); 583 584 if (idx >= data->d_size) { 585 pr_err("FAILED patching index %lu out of bounds %lu\n", 586 idx, data->d_size); 587 return -1; 588 } 589 590 idx = idx / sizeof(int); 591 ptr[idx] = id->id; 592 } 593 594 return 0; 595 } 596 597 static int __symbols_patch(struct object *obj, struct rb_root *root) 598 { 599 struct rb_node *next; 600 struct btf_id *id; 601 602 next = rb_first(root); 603 while (next) { 604 id = rb_entry(next, struct btf_id, rb_node); 605 606 if (id_patch(obj, id)) 607 return -1; 608 609 next = rb_next(next); 610 } 611 return 0; 612 } 613 614 static int cmp_id(const void *pa, const void *pb) 615 { 616 const int *a = pa, *b = pb; 617 618 return *a - *b; 619 } 620 621 static int sets_patch(struct object *obj) 622 { 623 Elf_Data *data = obj->efile.idlist; 624 int *ptr = data->d_buf; 625 struct rb_node *next; 626 627 next = rb_first(&obj->sets); 628 while (next) { 629 unsigned long addr, idx; 630 struct btf_id *id; 631 int *base; 632 int cnt; 633 634 id = rb_entry(next, struct btf_id, rb_node); 635 addr = id->addr[0]; 636 idx = addr - obj->efile.idlist_addr; 637 638 /* sets are unique */ 639 if (id->addr_cnt != 1) { 640 pr_err("FAILED malformed data for set '%s'\n", 641 id->name); 642 return -1; 643 } 644 645 idx = idx / sizeof(int); 646 base = &ptr[idx] + 1; 647 cnt = ptr[idx]; 648 649 pr_debug("sorting addr %5lu: cnt %6d [%s]\n", 650 (idx + 1) * sizeof(int), cnt, id->name); 651 652 qsort(base, cnt, sizeof(int), cmp_id); 653 654 next = rb_next(next); 655 } 656 return 0; 657 } 658 659 static int symbols_patch(struct object *obj) 660 { 661 int err; 662 663 if (__symbols_patch(obj, &obj->structs) || 664 __symbols_patch(obj, &obj->unions) || 665 __symbols_patch(obj, &obj->typedefs) || 666 __symbols_patch(obj, &obj->funcs) || 667 __symbols_patch(obj, &obj->sets)) 668 return -1; 669 670 if (sets_patch(obj)) 671 return -1; 672 673 /* Set type to ensure endian translation occurs. */ 674 obj->efile.idlist->d_type = ELF_T_WORD; 675 676 elf_flagdata(obj->efile.idlist, ELF_C_SET, ELF_F_DIRTY); 677 678 err = elf_update(obj->efile.elf, ELF_C_WRITE); 679 if (err < 0) { 680 pr_err("FAILED elf_update(WRITE): %s\n", 681 elf_errmsg(-1)); 682 } 683 684 pr_debug("update %s for %s\n", 685 err >= 0 ? "ok" : "failed", obj->path); 686 return err < 0 ? -1 : 0; 687 } 688 689 static const char * const resolve_btfids_usage[] = { 690 "resolve_btfids [<options>] <ELF object>", 691 NULL 692 }; 693 694 int main(int argc, const char **argv) 695 { 696 struct object obj = { 697 .efile = { 698 .idlist_shndx = -1, 699 .symbols_shndx = -1, 700 }, 701 .structs = RB_ROOT, 702 .unions = RB_ROOT, 703 .typedefs = RB_ROOT, 704 .funcs = RB_ROOT, 705 .sets = RB_ROOT, 706 }; 707 struct option btfid_options[] = { 708 OPT_INCR('v', "verbose", &verbose, 709 "be more verbose (show errors, etc)"), 710 OPT_STRING(0, "btf", &obj.btf, "BTF data", 711 "BTF data"), 712 OPT_STRING('b', "btf_base", &obj.base_btf_path, "file", 713 "path of file providing base BTF"), 714 OPT_END() 715 }; 716 int err = -1; 717 718 argc = parse_options(argc, argv, btfid_options, resolve_btfids_usage, 719 PARSE_OPT_STOP_AT_NON_OPTION); 720 if (argc != 1) 721 usage_with_options(resolve_btfids_usage, btfid_options); 722 723 obj.path = argv[0]; 724 725 if (elf_collect(&obj)) 726 goto out; 727 728 /* 729 * We did not find .BTF_ids section or symbols section, 730 * nothing to do.. 731 */ 732 if (obj.efile.idlist_shndx == -1 || 733 obj.efile.symbols_shndx == -1) { 734 pr_debug("Cannot find .BTF_ids or symbols sections, nothing to do\n"); 735 return 0; 736 } 737 738 if (symbols_collect(&obj)) 739 goto out; 740 741 if (symbols_resolve(&obj)) 742 goto out; 743 744 if (symbols_patch(&obj)) 745 goto out; 746 747 err = 0; 748 out: 749 if (obj.efile.elf) { 750 elf_end(obj.efile.elf); 751 close(obj.efile.fd); 752 } 753 return err; 754 } 755