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