1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2/* Copyright (C) 2019 Facebook */ 3 4#ifndef _GNU_SOURCE 5#define _GNU_SOURCE 6#endif 7#include <ctype.h> 8#include <errno.h> 9#include <fcntl.h> 10#include <linux/err.h> 11#include <stdbool.h> 12#include <stdio.h> 13#include <string.h> 14#include <unistd.h> 15#include <bpf/bpf.h> 16#include <bpf/libbpf.h> 17#include <bpf/libbpf_internal.h> 18#include <sys/types.h> 19#include <sys/stat.h> 20#include <sys/mman.h> 21#include <bpf/btf.h> 22 23#include "json_writer.h" 24#include "main.h" 25 26#define MAX_OBJ_NAME_LEN 64 27 28static void sanitize_identifier(char *name) 29{ 30 int i; 31 32 for (i = 0; name[i]; i++) 33 if (!isalnum(name[i]) && name[i] != '_') 34 name[i] = '_'; 35} 36 37static bool str_has_prefix(const char *str, const char *prefix) 38{ 39 return strncmp(str, prefix, strlen(prefix)) == 0; 40} 41 42static bool str_has_suffix(const char *str, const char *suffix) 43{ 44 size_t i, n1 = strlen(str), n2 = strlen(suffix); 45 46 if (n1 < n2) 47 return false; 48 49 for (i = 0; i < n2; i++) { 50 if (str[n1 - i - 1] != suffix[n2 - i - 1]) 51 return false; 52 } 53 54 return true; 55} 56 57static void get_obj_name(char *name, const char *file) 58{ 59 /* Using basename() GNU version which doesn't modify arg. */ 60 strncpy(name, basename(file), MAX_OBJ_NAME_LEN - 1); 61 name[MAX_OBJ_NAME_LEN - 1] = '\0'; 62 if (str_has_suffix(name, ".o")) 63 name[strlen(name) - 2] = '\0'; 64 sanitize_identifier(name); 65} 66 67static void get_header_guard(char *guard, const char *obj_name, const char *suffix) 68{ 69 int i; 70 71 sprintf(guard, "__%s_%s__", obj_name, suffix); 72 for (i = 0; guard[i]; i++) 73 guard[i] = toupper(guard[i]); 74} 75 76static bool get_map_ident(const struct bpf_map *map, char *buf, size_t buf_sz) 77{ 78 static const char *sfxs[] = { ".data", ".rodata", ".bss", ".kconfig" }; 79 const char *name = bpf_map__name(map); 80 int i, n; 81 82 if (!bpf_map__is_internal(map)) { 83 snprintf(buf, buf_sz, "%s", name); 84 return true; 85 } 86 87 for (i = 0, n = ARRAY_SIZE(sfxs); i < n; i++) { 88 const char *sfx = sfxs[i], *p; 89 90 p = strstr(name, sfx); 91 if (p) { 92 snprintf(buf, buf_sz, "%s", p + 1); 93 sanitize_identifier(buf); 94 return true; 95 } 96 } 97 98 return false; 99} 100 101static bool get_datasec_ident(const char *sec_name, char *buf, size_t buf_sz) 102{ 103 static const char *pfxs[] = { ".data", ".rodata", ".bss", ".kconfig" }; 104 int i, n; 105 106 for (i = 0, n = ARRAY_SIZE(pfxs); i < n; i++) { 107 const char *pfx = pfxs[i]; 108 109 if (str_has_prefix(sec_name, pfx)) { 110 snprintf(buf, buf_sz, "%s", sec_name + 1); 111 sanitize_identifier(buf); 112 return true; 113 } 114 } 115 116 return false; 117} 118 119static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args) 120{ 121 vprintf(fmt, args); 122} 123 124static int codegen_datasec_def(struct bpf_object *obj, 125 struct btf *btf, 126 struct btf_dump *d, 127 const struct btf_type *sec, 128 const char *obj_name) 129{ 130 const char *sec_name = btf__name_by_offset(btf, sec->name_off); 131 const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec); 132 int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec); 133 char var_ident[256], sec_ident[256]; 134 bool strip_mods = false; 135 136 if (!get_datasec_ident(sec_name, sec_ident, sizeof(sec_ident))) 137 return 0; 138 139 if (strcmp(sec_name, ".kconfig") != 0) 140 strip_mods = true; 141 142 printf(" struct %s__%s {\n", obj_name, sec_ident); 143 for (i = 0; i < vlen; i++, sec_var++) { 144 const struct btf_type *var = btf__type_by_id(btf, sec_var->type); 145 const char *var_name = btf__name_by_offset(btf, var->name_off); 146 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts, 147 .field_name = var_ident, 148 .indent_level = 2, 149 .strip_mods = strip_mods, 150 ); 151 int need_off = sec_var->offset, align_off, align; 152 __u32 var_type_id = var->type; 153 154 /* static variables are not exposed through BPF skeleton */ 155 if (btf_var(var)->linkage == BTF_VAR_STATIC) 156 continue; 157 158 if (off > need_off) { 159 p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n", 160 sec_name, i, need_off, off); 161 return -EINVAL; 162 } 163 164 align = btf__align_of(btf, var->type); 165 if (align <= 0) { 166 p_err("Failed to determine alignment of variable '%s': %d", 167 var_name, align); 168 return -EINVAL; 169 } 170 /* Assume 32-bit architectures when generating data section 171 * struct memory layout. Given bpftool can't know which target 172 * host architecture it's emitting skeleton for, we need to be 173 * conservative and assume 32-bit one to ensure enough padding 174 * bytes are generated for pointer and long types. This will 175 * still work correctly for 64-bit architectures, because in 176 * the worst case we'll generate unnecessary padding field, 177 * which on 64-bit architectures is not strictly necessary and 178 * would be handled by natural 8-byte alignment. But it still 179 * will be a correct memory layout, based on recorded offsets 180 * in BTF. 181 */ 182 if (align > 4) 183 align = 4; 184 185 align_off = (off + align - 1) / align * align; 186 if (align_off != need_off) { 187 printf("\t\tchar __pad%d[%d];\n", 188 pad_cnt, need_off - off); 189 pad_cnt++; 190 } 191 192 /* sanitize variable name, e.g., for static vars inside 193 * a function, it's name is '<function name>.<variable name>', 194 * which we'll turn into a '<function name>_<variable name>' 195 */ 196 var_ident[0] = '\0'; 197 strncat(var_ident, var_name, sizeof(var_ident) - 1); 198 sanitize_identifier(var_ident); 199 200 printf("\t\t"); 201 err = btf_dump__emit_type_decl(d, var_type_id, &opts); 202 if (err) 203 return err; 204 printf(";\n"); 205 206 off = sec_var->offset + sec_var->size; 207 } 208 printf(" } *%s;\n", sec_ident); 209 return 0; 210} 211 212static const struct btf_type *find_type_for_map(struct btf *btf, const char *map_ident) 213{ 214 int n = btf__type_cnt(btf), i; 215 char sec_ident[256]; 216 217 for (i = 1; i < n; i++) { 218 const struct btf_type *t = btf__type_by_id(btf, i); 219 const char *name; 220 221 if (!btf_is_datasec(t)) 222 continue; 223 224 name = btf__str_by_offset(btf, t->name_off); 225 if (!get_datasec_ident(name, sec_ident, sizeof(sec_ident))) 226 continue; 227 228 if (strcmp(sec_ident, map_ident) == 0) 229 return t; 230 } 231 return NULL; 232} 233 234static bool is_internal_mmapable_map(const struct bpf_map *map, char *buf, size_t sz) 235{ 236 if (!bpf_map__is_internal(map) || !(bpf_map__map_flags(map) & BPF_F_MMAPABLE)) 237 return false; 238 239 if (!get_map_ident(map, buf, sz)) 240 return false; 241 242 return true; 243} 244 245static int codegen_datasecs(struct bpf_object *obj, const char *obj_name) 246{ 247 struct btf *btf = bpf_object__btf(obj); 248 struct btf_dump *d; 249 struct bpf_map *map; 250 const struct btf_type *sec; 251 char map_ident[256]; 252 int err = 0; 253 254 d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL); 255 if (!d) 256 return -errno; 257 258 bpf_object__for_each_map(map, obj) { 259 /* only generate definitions for memory-mapped internal maps */ 260 if (!is_internal_mmapable_map(map, map_ident, sizeof(map_ident))) 261 continue; 262 263 sec = find_type_for_map(btf, map_ident); 264 265 /* In some cases (e.g., sections like .rodata.cst16 containing 266 * compiler allocated string constants only) there will be 267 * special internal maps with no corresponding DATASEC BTF 268 * type. In such case, generate empty structs for each such 269 * map. It will still be memory-mapped and its contents 270 * accessible from user-space through BPF skeleton. 271 */ 272 if (!sec) { 273 printf(" struct %s__%s {\n", obj_name, map_ident); 274 printf(" } *%s;\n", map_ident); 275 } else { 276 err = codegen_datasec_def(obj, btf, d, sec, obj_name); 277 if (err) 278 goto out; 279 } 280 } 281 282 283out: 284 btf_dump__free(d); 285 return err; 286} 287 288static bool btf_is_ptr_to_func_proto(const struct btf *btf, 289 const struct btf_type *v) 290{ 291 return btf_is_ptr(v) && btf_is_func_proto(btf__type_by_id(btf, v->type)); 292} 293 294static int codegen_subskel_datasecs(struct bpf_object *obj, const char *obj_name) 295{ 296 struct btf *btf = bpf_object__btf(obj); 297 struct btf_dump *d; 298 struct bpf_map *map; 299 const struct btf_type *sec, *var; 300 const struct btf_var_secinfo *sec_var; 301 int i, err = 0, vlen; 302 char map_ident[256], sec_ident[256]; 303 bool strip_mods = false, needs_typeof = false; 304 const char *sec_name, *var_name; 305 __u32 var_type_id; 306 307 d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL); 308 if (!d) 309 return -errno; 310 311 bpf_object__for_each_map(map, obj) { 312 /* only generate definitions for memory-mapped internal maps */ 313 if (!is_internal_mmapable_map(map, map_ident, sizeof(map_ident))) 314 continue; 315 316 sec = find_type_for_map(btf, map_ident); 317 if (!sec) 318 continue; 319 320 sec_name = btf__name_by_offset(btf, sec->name_off); 321 if (!get_datasec_ident(sec_name, sec_ident, sizeof(sec_ident))) 322 continue; 323 324 strip_mods = strcmp(sec_name, ".kconfig") != 0; 325 printf(" struct %s__%s {\n", obj_name, sec_ident); 326 327 sec_var = btf_var_secinfos(sec); 328 vlen = btf_vlen(sec); 329 for (i = 0; i < vlen; i++, sec_var++) { 330 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts, 331 .indent_level = 2, 332 .strip_mods = strip_mods, 333 /* we'll print the name separately */ 334 .field_name = "", 335 ); 336 337 var = btf__type_by_id(btf, sec_var->type); 338 var_name = btf__name_by_offset(btf, var->name_off); 339 var_type_id = var->type; 340 341 /* static variables are not exposed through BPF skeleton */ 342 if (btf_var(var)->linkage == BTF_VAR_STATIC) 343 continue; 344 345 /* The datasec member has KIND_VAR but we want the 346 * underlying type of the variable (e.g. KIND_INT). 347 */ 348 var = skip_mods_and_typedefs(btf, var->type, NULL); 349 350 printf("\t\t"); 351 /* Func and array members require special handling. 352 * Instead of producing `typename *var`, they produce 353 * `typeof(typename) *var`. This allows us to keep a 354 * similar syntax where the identifier is just prefixed 355 * by *, allowing us to ignore C declaration minutiae. 356 */ 357 needs_typeof = btf_is_array(var) || btf_is_ptr_to_func_proto(btf, var); 358 if (needs_typeof) 359 printf("typeof("); 360 361 err = btf_dump__emit_type_decl(d, var_type_id, &opts); 362 if (err) 363 goto out; 364 365 if (needs_typeof) 366 printf(")"); 367 368 printf(" *%s;\n", var_name); 369 } 370 printf(" } %s;\n", sec_ident); 371 } 372 373out: 374 btf_dump__free(d); 375 return err; 376} 377 378static void codegen(const char *template, ...) 379{ 380 const char *src, *end; 381 int skip_tabs = 0, n; 382 char *s, *dst; 383 va_list args; 384 char c; 385 386 n = strlen(template); 387 s = malloc(n + 1); 388 if (!s) 389 exit(-1); 390 src = template; 391 dst = s; 392 393 /* find out "baseline" indentation to skip */ 394 while ((c = *src++)) { 395 if (c == '\t') { 396 skip_tabs++; 397 } else if (c == '\n') { 398 break; 399 } else { 400 p_err("unrecognized character at pos %td in template '%s': '%c'", 401 src - template - 1, template, c); 402 free(s); 403 exit(-1); 404 } 405 } 406 407 while (*src) { 408 /* skip baseline indentation tabs */ 409 for (n = skip_tabs; n > 0; n--, src++) { 410 if (*src != '\t') { 411 p_err("not enough tabs at pos %td in template '%s'", 412 src - template - 1, template); 413 free(s); 414 exit(-1); 415 } 416 } 417 /* trim trailing whitespace */ 418 end = strchrnul(src, '\n'); 419 for (n = end - src; n > 0 && isspace(src[n - 1]); n--) 420 ; 421 memcpy(dst, src, n); 422 dst += n; 423 if (*end) 424 *dst++ = '\n'; 425 src = *end ? end + 1 : end; 426 } 427 *dst++ = '\0'; 428 429 /* print out using adjusted template */ 430 va_start(args, template); 431 n = vprintf(s, args); 432 va_end(args); 433 434 free(s); 435} 436 437static void print_hex(const char *data, int data_sz) 438{ 439 int i, len; 440 441 for (i = 0, len = 0; i < data_sz; i++) { 442 int w = data[i] ? 4 : 2; 443 444 len += w; 445 if (len > 78) { 446 printf("\\\n"); 447 len = w; 448 } 449 if (!data[i]) 450 printf("\\0"); 451 else 452 printf("\\x%02x", (unsigned char)data[i]); 453 } 454} 455 456static size_t bpf_map_mmap_sz(const struct bpf_map *map) 457{ 458 long page_sz = sysconf(_SC_PAGE_SIZE); 459 size_t map_sz; 460 461 map_sz = (size_t)roundup(bpf_map__value_size(map), 8) * bpf_map__max_entries(map); 462 map_sz = roundup(map_sz, page_sz); 463 return map_sz; 464} 465 466/* Emit type size asserts for all top-level fields in memory-mapped internal maps. */ 467static void codegen_asserts(struct bpf_object *obj, const char *obj_name) 468{ 469 struct btf *btf = bpf_object__btf(obj); 470 struct bpf_map *map; 471 struct btf_var_secinfo *sec_var; 472 int i, vlen; 473 const struct btf_type *sec; 474 char map_ident[256], var_ident[256]; 475 476 if (!btf) 477 return; 478 479 codegen("\ 480 \n\ 481 __attribute__((unused)) static void \n\ 482 %1$s__assert(struct %1$s *s __attribute__((unused))) \n\ 483 { \n\ 484 #ifdef __cplusplus \n\ 485 #define _Static_assert static_assert \n\ 486 #endif \n\ 487 ", obj_name); 488 489 bpf_object__for_each_map(map, obj) { 490 if (!is_internal_mmapable_map(map, map_ident, sizeof(map_ident))) 491 continue; 492 493 sec = find_type_for_map(btf, map_ident); 494 if (!sec) { 495 /* best effort, couldn't find the type for this map */ 496 continue; 497 } 498 499 sec_var = btf_var_secinfos(sec); 500 vlen = btf_vlen(sec); 501 502 for (i = 0; i < vlen; i++, sec_var++) { 503 const struct btf_type *var = btf__type_by_id(btf, sec_var->type); 504 const char *var_name = btf__name_by_offset(btf, var->name_off); 505 long var_size; 506 507 /* static variables are not exposed through BPF skeleton */ 508 if (btf_var(var)->linkage == BTF_VAR_STATIC) 509 continue; 510 511 var_size = btf__resolve_size(btf, var->type); 512 if (var_size < 0) 513 continue; 514 515 var_ident[0] = '\0'; 516 strncat(var_ident, var_name, sizeof(var_ident) - 1); 517 sanitize_identifier(var_ident); 518 519 printf("\t_Static_assert(sizeof(s->%s->%s) == %ld, \"unexpected size of '%s'\");\n", 520 map_ident, var_ident, var_size, var_ident); 521 } 522 } 523 codegen("\ 524 \n\ 525 #ifdef __cplusplus \n\ 526 #undef _Static_assert \n\ 527 #endif \n\ 528 } \n\ 529 "); 530} 531 532static void codegen_attach_detach(struct bpf_object *obj, const char *obj_name) 533{ 534 struct bpf_program *prog; 535 536 bpf_object__for_each_program(prog, obj) { 537 const char *tp_name; 538 539 codegen("\ 540 \n\ 541 \n\ 542 static inline int \n\ 543 %1$s__%2$s__attach(struct %1$s *skel) \n\ 544 { \n\ 545 int prog_fd = skel->progs.%2$s.prog_fd; \n\ 546 ", obj_name, bpf_program__name(prog)); 547 548 switch (bpf_program__type(prog)) { 549 case BPF_PROG_TYPE_RAW_TRACEPOINT: 550 tp_name = strchr(bpf_program__section_name(prog), '/') + 1; 551 printf("\tint fd = skel_raw_tracepoint_open(\"%s\", prog_fd);\n", tp_name); 552 break; 553 case BPF_PROG_TYPE_TRACING: 554 case BPF_PROG_TYPE_LSM: 555 if (bpf_program__expected_attach_type(prog) == BPF_TRACE_ITER) 556 printf("\tint fd = skel_link_create(prog_fd, 0, BPF_TRACE_ITER);\n"); 557 else 558 printf("\tint fd = skel_raw_tracepoint_open(NULL, prog_fd);\n"); 559 break; 560 default: 561 printf("\tint fd = ((void)prog_fd, 0); /* auto-attach not supported */\n"); 562 break; 563 } 564 codegen("\ 565 \n\ 566 \n\ 567 if (fd > 0) \n\ 568 skel->links.%1$s_fd = fd; \n\ 569 return fd; \n\ 570 } \n\ 571 ", bpf_program__name(prog)); 572 } 573 574 codegen("\ 575 \n\ 576 \n\ 577 static inline int \n\ 578 %1$s__attach(struct %1$s *skel) \n\ 579 { \n\ 580 int ret = 0; \n\ 581 \n\ 582 ", obj_name); 583 584 bpf_object__for_each_program(prog, obj) { 585 codegen("\ 586 \n\ 587 ret = ret < 0 ? ret : %1$s__%2$s__attach(skel); \n\ 588 ", obj_name, bpf_program__name(prog)); 589 } 590 591 codegen("\ 592 \n\ 593 return ret < 0 ? ret : 0; \n\ 594 } \n\ 595 \n\ 596 static inline void \n\ 597 %1$s__detach(struct %1$s *skel) \n\ 598 { \n\ 599 ", obj_name); 600 601 bpf_object__for_each_program(prog, obj) { 602 codegen("\ 603 \n\ 604 skel_closenz(skel->links.%1$s_fd); \n\ 605 ", bpf_program__name(prog)); 606 } 607 608 codegen("\ 609 \n\ 610 } \n\ 611 "); 612} 613 614static void codegen_destroy(struct bpf_object *obj, const char *obj_name) 615{ 616 struct bpf_program *prog; 617 struct bpf_map *map; 618 char ident[256]; 619 620 codegen("\ 621 \n\ 622 static void \n\ 623 %1$s__destroy(struct %1$s *skel) \n\ 624 { \n\ 625 if (!skel) \n\ 626 return; \n\ 627 %1$s__detach(skel); \n\ 628 ", 629 obj_name); 630 631 bpf_object__for_each_program(prog, obj) { 632 codegen("\ 633 \n\ 634 skel_closenz(skel->progs.%1$s.prog_fd); \n\ 635 ", bpf_program__name(prog)); 636 } 637 638 bpf_object__for_each_map(map, obj) { 639 if (!get_map_ident(map, ident, sizeof(ident))) 640 continue; 641 if (bpf_map__is_internal(map) && 642 (bpf_map__map_flags(map) & BPF_F_MMAPABLE)) 643 printf("\tskel_free_map_data(skel->%1$s, skel->maps.%1$s.initial_value, %2$zd);\n", 644 ident, bpf_map_mmap_sz(map)); 645 codegen("\ 646 \n\ 647 skel_closenz(skel->maps.%1$s.map_fd); \n\ 648 ", ident); 649 } 650 codegen("\ 651 \n\ 652 skel_free(skel); \n\ 653 } \n\ 654 ", 655 obj_name); 656} 657 658static int gen_trace(struct bpf_object *obj, const char *obj_name, const char *header_guard) 659{ 660 DECLARE_LIBBPF_OPTS(gen_loader_opts, opts); 661 struct bpf_map *map; 662 char ident[256]; 663 int err = 0; 664 665 err = bpf_object__gen_loader(obj, &opts); 666 if (err) 667 return err; 668 669 err = bpf_object__load(obj); 670 if (err) { 671 p_err("failed to load object file"); 672 goto out; 673 } 674 /* If there was no error during load then gen_loader_opts 675 * are populated with the loader program. 676 */ 677 678 /* finish generating 'struct skel' */ 679 codegen("\ 680 \n\ 681 }; \n\ 682 ", obj_name); 683 684 685 codegen_attach_detach(obj, obj_name); 686 687 codegen_destroy(obj, obj_name); 688 689 codegen("\ 690 \n\ 691 static inline struct %1$s * \n\ 692 %1$s__open(void) \n\ 693 { \n\ 694 struct %1$s *skel; \n\ 695 \n\ 696 skel = skel_alloc(sizeof(*skel)); \n\ 697 if (!skel) \n\ 698 goto cleanup; \n\ 699 skel->ctx.sz = (void *)&skel->links - (void *)skel; \n\ 700 ", 701 obj_name, opts.data_sz); 702 bpf_object__for_each_map(map, obj) { 703 const void *mmap_data = NULL; 704 size_t mmap_size = 0; 705 706 if (!is_internal_mmapable_map(map, ident, sizeof(ident))) 707 continue; 708 709 codegen("\ 710 \n\ 711 skel->%1$s = skel_prep_map_data((void *)\"\\ \n\ 712 ", ident); 713 mmap_data = bpf_map__initial_value(map, &mmap_size); 714 print_hex(mmap_data, mmap_size); 715 codegen("\ 716 \n\ 717 \", %1$zd, %2$zd); \n\ 718 if (!skel->%3$s) \n\ 719 goto cleanup; \n\ 720 skel->maps.%3$s.initial_value = (__u64) (long) skel->%3$s;\n\ 721 ", bpf_map_mmap_sz(map), mmap_size, ident); 722 } 723 codegen("\ 724 \n\ 725 return skel; \n\ 726 cleanup: \n\ 727 %1$s__destroy(skel); \n\ 728 return NULL; \n\ 729 } \n\ 730 \n\ 731 static inline int \n\ 732 %1$s__load(struct %1$s *skel) \n\ 733 { \n\ 734 struct bpf_load_and_run_opts opts = {}; \n\ 735 int err; \n\ 736 \n\ 737 opts.ctx = (struct bpf_loader_ctx *)skel; \n\ 738 opts.data_sz = %2$d; \n\ 739 opts.data = (void *)\"\\ \n\ 740 ", 741 obj_name, opts.data_sz); 742 print_hex(opts.data, opts.data_sz); 743 codegen("\ 744 \n\ 745 \"; \n\ 746 "); 747 748 codegen("\ 749 \n\ 750 opts.insns_sz = %d; \n\ 751 opts.insns = (void *)\"\\ \n\ 752 ", 753 opts.insns_sz); 754 print_hex(opts.insns, opts.insns_sz); 755 codegen("\ 756 \n\ 757 \"; \n\ 758 err = bpf_load_and_run(&opts); \n\ 759 if (err < 0) \n\ 760 return err; \n\ 761 ", obj_name); 762 bpf_object__for_each_map(map, obj) { 763 const char *mmap_flags; 764 765 if (!is_internal_mmapable_map(map, ident, sizeof(ident))) 766 continue; 767 768 if (bpf_map__map_flags(map) & BPF_F_RDONLY_PROG) 769 mmap_flags = "PROT_READ"; 770 else 771 mmap_flags = "PROT_READ | PROT_WRITE"; 772 773 codegen("\ 774 \n\ 775 skel->%1$s = skel_finalize_map_data(&skel->maps.%1$s.initial_value, \n\ 776 %2$zd, %3$s, skel->maps.%1$s.map_fd);\n\ 777 if (!skel->%1$s) \n\ 778 return -ENOMEM; \n\ 779 ", 780 ident, bpf_map_mmap_sz(map), mmap_flags); 781 } 782 codegen("\ 783 \n\ 784 return 0; \n\ 785 } \n\ 786 \n\ 787 static inline struct %1$s * \n\ 788 %1$s__open_and_load(void) \n\ 789 { \n\ 790 struct %1$s *skel; \n\ 791 \n\ 792 skel = %1$s__open(); \n\ 793 if (!skel) \n\ 794 return NULL; \n\ 795 if (%1$s__load(skel)) { \n\ 796 %1$s__destroy(skel); \n\ 797 return NULL; \n\ 798 } \n\ 799 return skel; \n\ 800 } \n\ 801 \n\ 802 ", obj_name); 803 804 codegen_asserts(obj, obj_name); 805 806 codegen("\ 807 \n\ 808 \n\ 809 #endif /* %s */ \n\ 810 ", 811 header_guard); 812 err = 0; 813out: 814 return err; 815} 816 817static void 818codegen_maps_skeleton(struct bpf_object *obj, size_t map_cnt, bool mmaped) 819{ 820 struct bpf_map *map; 821 char ident[256]; 822 size_t i; 823 824 if (!map_cnt) 825 return; 826 827 codegen("\ 828 \n\ 829 \n\ 830 /* maps */ \n\ 831 s->map_cnt = %zu; \n\ 832 s->map_skel_sz = sizeof(*s->maps); \n\ 833 s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz);\n\ 834 if (!s->maps) { \n\ 835 err = -ENOMEM; \n\ 836 goto err; \n\ 837 } \n\ 838 ", 839 map_cnt 840 ); 841 i = 0; 842 bpf_object__for_each_map(map, obj) { 843 if (!get_map_ident(map, ident, sizeof(ident))) 844 continue; 845 846 codegen("\ 847 \n\ 848 \n\ 849 s->maps[%zu].name = \"%s\"; \n\ 850 s->maps[%zu].map = &obj->maps.%s; \n\ 851 ", 852 i, bpf_map__name(map), i, ident); 853 /* memory-mapped internal maps */ 854 if (mmaped && is_internal_mmapable_map(map, ident, sizeof(ident))) { 855 printf("\ts->maps[%zu].mmaped = (void **)&obj->%s;\n", 856 i, ident); 857 } 858 i++; 859 } 860} 861 862static void 863codegen_progs_skeleton(struct bpf_object *obj, size_t prog_cnt, bool populate_links) 864{ 865 struct bpf_program *prog; 866 int i; 867 868 if (!prog_cnt) 869 return; 870 871 codegen("\ 872 \n\ 873 \n\ 874 /* programs */ \n\ 875 s->prog_cnt = %zu; \n\ 876 s->prog_skel_sz = sizeof(*s->progs); \n\ 877 s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\ 878 if (!s->progs) { \n\ 879 err = -ENOMEM; \n\ 880 goto err; \n\ 881 } \n\ 882 ", 883 prog_cnt 884 ); 885 i = 0; 886 bpf_object__for_each_program(prog, obj) { 887 codegen("\ 888 \n\ 889 \n\ 890 s->progs[%1$zu].name = \"%2$s\"; \n\ 891 s->progs[%1$zu].prog = &obj->progs.%2$s;\n\ 892 ", 893 i, bpf_program__name(prog)); 894 895 if (populate_links) { 896 codegen("\ 897 \n\ 898 s->progs[%1$zu].link = &obj->links.%2$s;\n\ 899 ", 900 i, bpf_program__name(prog)); 901 } 902 i++; 903 } 904} 905 906static int do_skeleton(int argc, char **argv) 907{ 908 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")]; 909 size_t map_cnt = 0, prog_cnt = 0, file_sz, mmap_sz; 910 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts); 911 char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data; 912 struct bpf_object *obj = NULL; 913 const char *file; 914 char ident[256]; 915 struct bpf_program *prog; 916 int fd, err = -1; 917 struct bpf_map *map; 918 struct btf *btf; 919 struct stat st; 920 921 if (!REQ_ARGS(1)) { 922 usage(); 923 return -1; 924 } 925 file = GET_ARG(); 926 927 while (argc) { 928 if (!REQ_ARGS(2)) 929 return -1; 930 931 if (is_prefix(*argv, "name")) { 932 NEXT_ARG(); 933 934 if (obj_name[0] != '\0') { 935 p_err("object name already specified"); 936 return -1; 937 } 938 939 strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1); 940 obj_name[MAX_OBJ_NAME_LEN - 1] = '\0'; 941 } else { 942 p_err("unknown arg %s", *argv); 943 return -1; 944 } 945 946 NEXT_ARG(); 947 } 948 949 if (argc) { 950 p_err("extra unknown arguments"); 951 return -1; 952 } 953 954 if (stat(file, &st)) { 955 p_err("failed to stat() %s: %s", file, strerror(errno)); 956 return -1; 957 } 958 file_sz = st.st_size; 959 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE)); 960 fd = open(file, O_RDONLY); 961 if (fd < 0) { 962 p_err("failed to open() %s: %s", file, strerror(errno)); 963 return -1; 964 } 965 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0); 966 if (obj_data == MAP_FAILED) { 967 obj_data = NULL; 968 p_err("failed to mmap() %s: %s", file, strerror(errno)); 969 goto out; 970 } 971 if (obj_name[0] == '\0') 972 get_obj_name(obj_name, file); 973 opts.object_name = obj_name; 974 if (verifier_logs) 975 /* log_level1 + log_level2 + stats, but not stable UAPI */ 976 opts.kernel_log_level = 1 + 2 + 4; 977 obj = bpf_object__open_mem(obj_data, file_sz, &opts); 978 if (!obj) { 979 char err_buf[256]; 980 981 err = -errno; 982 libbpf_strerror(err, err_buf, sizeof(err_buf)); 983 p_err("failed to open BPF object file: %s", err_buf); 984 goto out; 985 } 986 987 bpf_object__for_each_map(map, obj) { 988 if (!get_map_ident(map, ident, sizeof(ident))) { 989 p_err("ignoring unrecognized internal map '%s'...", 990 bpf_map__name(map)); 991 continue; 992 } 993 map_cnt++; 994 } 995 bpf_object__for_each_program(prog, obj) { 996 prog_cnt++; 997 } 998 999 get_header_guard(header_guard, obj_name, "SKEL_H"); 1000 if (use_loader) { 1001 codegen("\ 1002 \n\ 1003 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\ 1004 /* THIS FILE IS AUTOGENERATED BY BPFTOOL! */ \n\ 1005 #ifndef %2$s \n\ 1006 #define %2$s \n\ 1007 \n\ 1008 #include <bpf/skel_internal.h> \n\ 1009 \n\ 1010 struct %1$s { \n\ 1011 struct bpf_loader_ctx ctx; \n\ 1012 ", 1013 obj_name, header_guard 1014 ); 1015 } else { 1016 codegen("\ 1017 \n\ 1018 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\ 1019 \n\ 1020 /* THIS FILE IS AUTOGENERATED BY BPFTOOL! */ \n\ 1021 #ifndef %2$s \n\ 1022 #define %2$s \n\ 1023 \n\ 1024 #include <errno.h> \n\ 1025 #include <stdlib.h> \n\ 1026 #include <bpf/libbpf.h> \n\ 1027 \n\ 1028 struct %1$s { \n\ 1029 struct bpf_object_skeleton *skeleton; \n\ 1030 struct bpf_object *obj; \n\ 1031 ", 1032 obj_name, header_guard 1033 ); 1034 } 1035 1036 if (map_cnt) { 1037 printf("\tstruct {\n"); 1038 bpf_object__for_each_map(map, obj) { 1039 if (!get_map_ident(map, ident, sizeof(ident))) 1040 continue; 1041 if (use_loader) 1042 printf("\t\tstruct bpf_map_desc %s;\n", ident); 1043 else 1044 printf("\t\tstruct bpf_map *%s;\n", ident); 1045 } 1046 printf("\t} maps;\n"); 1047 } 1048 1049 if (prog_cnt) { 1050 printf("\tstruct {\n"); 1051 bpf_object__for_each_program(prog, obj) { 1052 if (use_loader) 1053 printf("\t\tstruct bpf_prog_desc %s;\n", 1054 bpf_program__name(prog)); 1055 else 1056 printf("\t\tstruct bpf_program *%s;\n", 1057 bpf_program__name(prog)); 1058 } 1059 printf("\t} progs;\n"); 1060 printf("\tstruct {\n"); 1061 bpf_object__for_each_program(prog, obj) { 1062 if (use_loader) 1063 printf("\t\tint %s_fd;\n", 1064 bpf_program__name(prog)); 1065 else 1066 printf("\t\tstruct bpf_link *%s;\n", 1067 bpf_program__name(prog)); 1068 } 1069 printf("\t} links;\n"); 1070 } 1071 1072 btf = bpf_object__btf(obj); 1073 if (btf) { 1074 err = codegen_datasecs(obj, obj_name); 1075 if (err) 1076 goto out; 1077 } 1078 if (use_loader) { 1079 err = gen_trace(obj, obj_name, header_guard); 1080 goto out; 1081 } 1082 1083 codegen("\ 1084 \n\ 1085 \n\ 1086 #ifdef __cplusplus \n\ 1087 static inline struct %1$s *open(const struct bpf_object_open_opts *opts = nullptr);\n\ 1088 static inline struct %1$s *open_and_load(); \n\ 1089 static inline int load(struct %1$s *skel); \n\ 1090 static inline int attach(struct %1$s *skel); \n\ 1091 static inline void detach(struct %1$s *skel); \n\ 1092 static inline void destroy(struct %1$s *skel); \n\ 1093 static inline const void *elf_bytes(size_t *sz); \n\ 1094 #endif /* __cplusplus */ \n\ 1095 }; \n\ 1096 \n\ 1097 static void \n\ 1098 %1$s__destroy(struct %1$s *obj) \n\ 1099 { \n\ 1100 if (!obj) \n\ 1101 return; \n\ 1102 if (obj->skeleton) \n\ 1103 bpf_object__destroy_skeleton(obj->skeleton);\n\ 1104 free(obj); \n\ 1105 } \n\ 1106 \n\ 1107 static inline int \n\ 1108 %1$s__create_skeleton(struct %1$s *obj); \n\ 1109 \n\ 1110 static inline struct %1$s * \n\ 1111 %1$s__open_opts(const struct bpf_object_open_opts *opts) \n\ 1112 { \n\ 1113 struct %1$s *obj; \n\ 1114 int err; \n\ 1115 \n\ 1116 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\ 1117 if (!obj) { \n\ 1118 errno = ENOMEM; \n\ 1119 return NULL; \n\ 1120 } \n\ 1121 \n\ 1122 err = %1$s__create_skeleton(obj); \n\ 1123 if (err) \n\ 1124 goto err_out; \n\ 1125 \n\ 1126 err = bpf_object__open_skeleton(obj->skeleton, opts);\n\ 1127 if (err) \n\ 1128 goto err_out; \n\ 1129 \n\ 1130 return obj; \n\ 1131 err_out: \n\ 1132 %1$s__destroy(obj); \n\ 1133 errno = -err; \n\ 1134 return NULL; \n\ 1135 } \n\ 1136 \n\ 1137 static inline struct %1$s * \n\ 1138 %1$s__open(void) \n\ 1139 { \n\ 1140 return %1$s__open_opts(NULL); \n\ 1141 } \n\ 1142 \n\ 1143 static inline int \n\ 1144 %1$s__load(struct %1$s *obj) \n\ 1145 { \n\ 1146 return bpf_object__load_skeleton(obj->skeleton); \n\ 1147 } \n\ 1148 \n\ 1149 static inline struct %1$s * \n\ 1150 %1$s__open_and_load(void) \n\ 1151 { \n\ 1152 struct %1$s *obj; \n\ 1153 int err; \n\ 1154 \n\ 1155 obj = %1$s__open(); \n\ 1156 if (!obj) \n\ 1157 return NULL; \n\ 1158 err = %1$s__load(obj); \n\ 1159 if (err) { \n\ 1160 %1$s__destroy(obj); \n\ 1161 errno = -err; \n\ 1162 return NULL; \n\ 1163 } \n\ 1164 return obj; \n\ 1165 } \n\ 1166 \n\ 1167 static inline int \n\ 1168 %1$s__attach(struct %1$s *obj) \n\ 1169 { \n\ 1170 return bpf_object__attach_skeleton(obj->skeleton); \n\ 1171 } \n\ 1172 \n\ 1173 static inline void \n\ 1174 %1$s__detach(struct %1$s *obj) \n\ 1175 { \n\ 1176 bpf_object__detach_skeleton(obj->skeleton); \n\ 1177 } \n\ 1178 ", 1179 obj_name 1180 ); 1181 1182 codegen("\ 1183 \n\ 1184 \n\ 1185 static inline const void *%1$s__elf_bytes(size_t *sz); \n\ 1186 \n\ 1187 static inline int \n\ 1188 %1$s__create_skeleton(struct %1$s *obj) \n\ 1189 { \n\ 1190 struct bpf_object_skeleton *s; \n\ 1191 int err; \n\ 1192 \n\ 1193 s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\ 1194 if (!s) { \n\ 1195 err = -ENOMEM; \n\ 1196 goto err; \n\ 1197 } \n\ 1198 \n\ 1199 s->sz = sizeof(*s); \n\ 1200 s->name = \"%1$s\"; \n\ 1201 s->obj = &obj->obj; \n\ 1202 ", 1203 obj_name 1204 ); 1205 1206 codegen_maps_skeleton(obj, map_cnt, true /*mmaped*/); 1207 codegen_progs_skeleton(obj, prog_cnt, true /*populate_links*/); 1208 1209 codegen("\ 1210 \n\ 1211 \n\ 1212 s->data = %1$s__elf_bytes(&s->data_sz); \n\ 1213 \n\ 1214 obj->skeleton = s; \n\ 1215 return 0; \n\ 1216 err: \n\ 1217 bpf_object__destroy_skeleton(s); \n\ 1218 return err; \n\ 1219 } \n\ 1220 \n\ 1221 static inline const void *%1$s__elf_bytes(size_t *sz) \n\ 1222 { \n\ 1223 static const char data[] __attribute__((__aligned__(8))) = \"\\\n\ 1224 ", 1225 obj_name 1226 ); 1227 1228 /* embed contents of BPF object file */ 1229 print_hex(obj_data, file_sz); 1230 1231 codegen("\ 1232 \n\ 1233 \"; \n\ 1234 \n\ 1235 *sz = sizeof(data) - 1; \n\ 1236 return (const void *)data; \n\ 1237 } \n\ 1238 \n\ 1239 #ifdef __cplusplus \n\ 1240 struct %1$s *%1$s::open(const struct bpf_object_open_opts *opts) { return %1$s__open_opts(opts); }\n\ 1241 struct %1$s *%1$s::open_and_load() { return %1$s__open_and_load(); } \n\ 1242 int %1$s::load(struct %1$s *skel) { return %1$s__load(skel); } \n\ 1243 int %1$s::attach(struct %1$s *skel) { return %1$s__attach(skel); } \n\ 1244 void %1$s::detach(struct %1$s *skel) { %1$s__detach(skel); } \n\ 1245 void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); } \n\ 1246 const void *%1$s::elf_bytes(size_t *sz) { return %1$s__elf_bytes(sz); } \n\ 1247 #endif /* __cplusplus */ \n\ 1248 \n\ 1249 ", 1250 obj_name); 1251 1252 codegen_asserts(obj, obj_name); 1253 1254 codegen("\ 1255 \n\ 1256 \n\ 1257 #endif /* %1$s */ \n\ 1258 ", 1259 header_guard); 1260 err = 0; 1261out: 1262 bpf_object__close(obj); 1263 if (obj_data) 1264 munmap(obj_data, mmap_sz); 1265 close(fd); 1266 return err; 1267} 1268 1269/* Subskeletons are like skeletons, except they don't own the bpf_object, 1270 * associated maps, links, etc. Instead, they know about the existence of 1271 * variables, maps, programs and are able to find their locations 1272 * _at runtime_ from an already loaded bpf_object. 1273 * 1274 * This allows for library-like BPF objects to have userspace counterparts 1275 * with access to their own items without having to know anything about the 1276 * final BPF object that the library was linked into. 1277 */ 1278static int do_subskeleton(int argc, char **argv) 1279{ 1280 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SUBSKEL_H__")]; 1281 size_t i, len, file_sz, map_cnt = 0, prog_cnt = 0, mmap_sz, var_cnt = 0, var_idx = 0; 1282 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts); 1283 char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data; 1284 struct bpf_object *obj = NULL; 1285 const char *file, *var_name; 1286 char ident[256]; 1287 int fd, err = -1, map_type_id; 1288 const struct bpf_map *map; 1289 struct bpf_program *prog; 1290 struct btf *btf; 1291 const struct btf_type *map_type, *var_type; 1292 const struct btf_var_secinfo *var; 1293 struct stat st; 1294 1295 if (!REQ_ARGS(1)) { 1296 usage(); 1297 return -1; 1298 } 1299 file = GET_ARG(); 1300 1301 while (argc) { 1302 if (!REQ_ARGS(2)) 1303 return -1; 1304 1305 if (is_prefix(*argv, "name")) { 1306 NEXT_ARG(); 1307 1308 if (obj_name[0] != '\0') { 1309 p_err("object name already specified"); 1310 return -1; 1311 } 1312 1313 strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1); 1314 obj_name[MAX_OBJ_NAME_LEN - 1] = '\0'; 1315 } else { 1316 p_err("unknown arg %s", *argv); 1317 return -1; 1318 } 1319 1320 NEXT_ARG(); 1321 } 1322 1323 if (argc) { 1324 p_err("extra unknown arguments"); 1325 return -1; 1326 } 1327 1328 if (use_loader) { 1329 p_err("cannot use loader for subskeletons"); 1330 return -1; 1331 } 1332 1333 if (stat(file, &st)) { 1334 p_err("failed to stat() %s: %s", file, strerror(errno)); 1335 return -1; 1336 } 1337 file_sz = st.st_size; 1338 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE)); 1339 fd = open(file, O_RDONLY); 1340 if (fd < 0) { 1341 p_err("failed to open() %s: %s", file, strerror(errno)); 1342 return -1; 1343 } 1344 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0); 1345 if (obj_data == MAP_FAILED) { 1346 obj_data = NULL; 1347 p_err("failed to mmap() %s: %s", file, strerror(errno)); 1348 goto out; 1349 } 1350 if (obj_name[0] == '\0') 1351 get_obj_name(obj_name, file); 1352 1353 /* The empty object name allows us to use bpf_map__name and produce 1354 * ELF section names out of it. (".data" instead of "obj.data") 1355 */ 1356 opts.object_name = ""; 1357 obj = bpf_object__open_mem(obj_data, file_sz, &opts); 1358 if (!obj) { 1359 char err_buf[256]; 1360 1361 libbpf_strerror(errno, err_buf, sizeof(err_buf)); 1362 p_err("failed to open BPF object file: %s", err_buf); 1363 obj = NULL; 1364 goto out; 1365 } 1366 1367 btf = bpf_object__btf(obj); 1368 if (!btf) { 1369 err = -1; 1370 p_err("need btf type information for %s", obj_name); 1371 goto out; 1372 } 1373 1374 bpf_object__for_each_program(prog, obj) { 1375 prog_cnt++; 1376 } 1377 1378 /* First, count how many variables we have to find. 1379 * We need this in advance so the subskel can allocate the right 1380 * amount of storage. 1381 */ 1382 bpf_object__for_each_map(map, obj) { 1383 if (!get_map_ident(map, ident, sizeof(ident))) 1384 continue; 1385 1386 /* Also count all maps that have a name */ 1387 map_cnt++; 1388 1389 if (!is_internal_mmapable_map(map, ident, sizeof(ident))) 1390 continue; 1391 1392 map_type_id = bpf_map__btf_value_type_id(map); 1393 if (map_type_id <= 0) { 1394 err = map_type_id; 1395 goto out; 1396 } 1397 map_type = btf__type_by_id(btf, map_type_id); 1398 1399 var = btf_var_secinfos(map_type); 1400 len = btf_vlen(map_type); 1401 for (i = 0; i < len; i++, var++) { 1402 var_type = btf__type_by_id(btf, var->type); 1403 1404 if (btf_var(var_type)->linkage == BTF_VAR_STATIC) 1405 continue; 1406 1407 var_cnt++; 1408 } 1409 } 1410 1411 get_header_guard(header_guard, obj_name, "SUBSKEL_H"); 1412 codegen("\ 1413 \n\ 1414 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\ 1415 \n\ 1416 /* THIS FILE IS AUTOGENERATED! */ \n\ 1417 #ifndef %2$s \n\ 1418 #define %2$s \n\ 1419 \n\ 1420 #include <errno.h> \n\ 1421 #include <stdlib.h> \n\ 1422 #include <bpf/libbpf.h> \n\ 1423 \n\ 1424 struct %1$s { \n\ 1425 struct bpf_object *obj; \n\ 1426 struct bpf_object_subskeleton *subskel; \n\ 1427 ", obj_name, header_guard); 1428 1429 if (map_cnt) { 1430 printf("\tstruct {\n"); 1431 bpf_object__for_each_map(map, obj) { 1432 if (!get_map_ident(map, ident, sizeof(ident))) 1433 continue; 1434 printf("\t\tstruct bpf_map *%s;\n", ident); 1435 } 1436 printf("\t} maps;\n"); 1437 } 1438 1439 if (prog_cnt) { 1440 printf("\tstruct {\n"); 1441 bpf_object__for_each_program(prog, obj) { 1442 printf("\t\tstruct bpf_program *%s;\n", 1443 bpf_program__name(prog)); 1444 } 1445 printf("\t} progs;\n"); 1446 } 1447 1448 err = codegen_subskel_datasecs(obj, obj_name); 1449 if (err) 1450 goto out; 1451 1452 /* emit code that will allocate enough storage for all symbols */ 1453 codegen("\ 1454 \n\ 1455 \n\ 1456 #ifdef __cplusplus \n\ 1457 static inline struct %1$s *open(const struct bpf_object *src);\n\ 1458 static inline void destroy(struct %1$s *skel); \n\ 1459 #endif /* __cplusplus */ \n\ 1460 }; \n\ 1461 \n\ 1462 static inline void \n\ 1463 %1$s__destroy(struct %1$s *skel) \n\ 1464 { \n\ 1465 if (!skel) \n\ 1466 return; \n\ 1467 if (skel->subskel) \n\ 1468 bpf_object__destroy_subskeleton(skel->subskel);\n\ 1469 free(skel); \n\ 1470 } \n\ 1471 \n\ 1472 static inline struct %1$s * \n\ 1473 %1$s__open(const struct bpf_object *src) \n\ 1474 { \n\ 1475 struct %1$s *obj; \n\ 1476 struct bpf_object_subskeleton *s; \n\ 1477 int err; \n\ 1478 \n\ 1479 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\ 1480 if (!obj) { \n\ 1481 err = -ENOMEM; \n\ 1482 goto err; \n\ 1483 } \n\ 1484 s = (struct bpf_object_subskeleton *)calloc(1, sizeof(*s));\n\ 1485 if (!s) { \n\ 1486 err = -ENOMEM; \n\ 1487 goto err; \n\ 1488 } \n\ 1489 s->sz = sizeof(*s); \n\ 1490 s->obj = src; \n\ 1491 s->var_skel_sz = sizeof(*s->vars); \n\ 1492 obj->subskel = s; \n\ 1493 \n\ 1494 /* vars */ \n\ 1495 s->var_cnt = %2$d; \n\ 1496 s->vars = (struct bpf_var_skeleton *)calloc(%2$d, sizeof(*s->vars));\n\ 1497 if (!s->vars) { \n\ 1498 err = -ENOMEM; \n\ 1499 goto err; \n\ 1500 } \n\ 1501 ", 1502 obj_name, var_cnt 1503 ); 1504 1505 /* walk through each symbol and emit the runtime representation */ 1506 bpf_object__for_each_map(map, obj) { 1507 if (!is_internal_mmapable_map(map, ident, sizeof(ident))) 1508 continue; 1509 1510 map_type_id = bpf_map__btf_value_type_id(map); 1511 if (map_type_id <= 0) 1512 /* skip over internal maps with no type*/ 1513 continue; 1514 1515 map_type = btf__type_by_id(btf, map_type_id); 1516 var = btf_var_secinfos(map_type); 1517 len = btf_vlen(map_type); 1518 for (i = 0; i < len; i++, var++) { 1519 var_type = btf__type_by_id(btf, var->type); 1520 var_name = btf__name_by_offset(btf, var_type->name_off); 1521 1522 if (btf_var(var_type)->linkage == BTF_VAR_STATIC) 1523 continue; 1524 1525 /* Note that we use the dot prefix in .data as the 1526 * field access operator i.e. maps%s becomes maps.data 1527 */ 1528 codegen("\ 1529 \n\ 1530 \n\ 1531 s->vars[%3$d].name = \"%1$s\"; \n\ 1532 s->vars[%3$d].map = &obj->maps.%2$s; \n\ 1533 s->vars[%3$d].addr = (void **) &obj->%2$s.%1$s;\n\ 1534 ", var_name, ident, var_idx); 1535 1536 var_idx++; 1537 } 1538 } 1539 1540 codegen_maps_skeleton(obj, map_cnt, false /*mmaped*/); 1541 codegen_progs_skeleton(obj, prog_cnt, false /*links*/); 1542 1543 codegen("\ 1544 \n\ 1545 \n\ 1546 err = bpf_object__open_subskeleton(s); \n\ 1547 if (err) \n\ 1548 goto err; \n\ 1549 \n\ 1550 return obj; \n\ 1551 err: \n\ 1552 %1$s__destroy(obj); \n\ 1553 errno = -err; \n\ 1554 return NULL; \n\ 1555 } \n\ 1556 \n\ 1557 #ifdef __cplusplus \n\ 1558 struct %1$s *%1$s::open(const struct bpf_object *src) { return %1$s__open(src); }\n\ 1559 void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); }\n\ 1560 #endif /* __cplusplus */ \n\ 1561 \n\ 1562 #endif /* %2$s */ \n\ 1563 ", 1564 obj_name, header_guard); 1565 err = 0; 1566out: 1567 bpf_object__close(obj); 1568 if (obj_data) 1569 munmap(obj_data, mmap_sz); 1570 close(fd); 1571 return err; 1572} 1573 1574static int do_object(int argc, char **argv) 1575{ 1576 struct bpf_linker *linker; 1577 const char *output_file, *file; 1578 int err = 0; 1579 1580 if (!REQ_ARGS(2)) { 1581 usage(); 1582 return -1; 1583 } 1584 1585 output_file = GET_ARG(); 1586 1587 linker = bpf_linker__new(output_file, NULL); 1588 if (!linker) { 1589 p_err("failed to create BPF linker instance"); 1590 return -1; 1591 } 1592 1593 while (argc) { 1594 file = GET_ARG(); 1595 1596 err = bpf_linker__add_file(linker, file, NULL); 1597 if (err) { 1598 p_err("failed to link '%s': %s (%d)", file, strerror(errno), errno); 1599 goto out; 1600 } 1601 } 1602 1603 err = bpf_linker__finalize(linker); 1604 if (err) { 1605 p_err("failed to finalize ELF file: %s (%d)", strerror(errno), errno); 1606 goto out; 1607 } 1608 1609 err = 0; 1610out: 1611 bpf_linker__free(linker); 1612 return err; 1613} 1614 1615static int do_help(int argc, char **argv) 1616{ 1617 if (json_output) { 1618 jsonw_null(json_wtr); 1619 return 0; 1620 } 1621 1622 fprintf(stderr, 1623 "Usage: %1$s %2$s object OUTPUT_FILE INPUT_FILE [INPUT_FILE...]\n" 1624 " %1$s %2$s skeleton FILE [name OBJECT_NAME]\n" 1625 " %1$s %2$s subskeleton FILE [name OBJECT_NAME]\n" 1626 " %1$s %2$s min_core_btf INPUT OUTPUT OBJECT [OBJECT...]\n" 1627 " %1$s %2$s help\n" 1628 "\n" 1629 " " HELP_SPEC_OPTIONS " |\n" 1630 " {-L|--use-loader} }\n" 1631 "", 1632 bin_name, "gen"); 1633 1634 return 0; 1635} 1636 1637static int btf_save_raw(const struct btf *btf, const char *path) 1638{ 1639 const void *data; 1640 FILE *f = NULL; 1641 __u32 data_sz; 1642 int err = 0; 1643 1644 data = btf__raw_data(btf, &data_sz); 1645 if (!data) 1646 return -ENOMEM; 1647 1648 f = fopen(path, "wb"); 1649 if (!f) 1650 return -errno; 1651 1652 if (fwrite(data, 1, data_sz, f) != data_sz) 1653 err = -errno; 1654 1655 fclose(f); 1656 return err; 1657} 1658 1659struct btfgen_info { 1660 struct btf *src_btf; 1661 struct btf *marked_btf; /* btf structure used to mark used types */ 1662}; 1663 1664static size_t btfgen_hash_fn(long key, void *ctx) 1665{ 1666 return key; 1667} 1668 1669static bool btfgen_equal_fn(long k1, long k2, void *ctx) 1670{ 1671 return k1 == k2; 1672} 1673 1674static void btfgen_free_info(struct btfgen_info *info) 1675{ 1676 if (!info) 1677 return; 1678 1679 btf__free(info->src_btf); 1680 btf__free(info->marked_btf); 1681 1682 free(info); 1683} 1684 1685static struct btfgen_info * 1686btfgen_new_info(const char *targ_btf_path) 1687{ 1688 struct btfgen_info *info; 1689 int err; 1690 1691 info = calloc(1, sizeof(*info)); 1692 if (!info) 1693 return NULL; 1694 1695 info->src_btf = btf__parse(targ_btf_path, NULL); 1696 if (!info->src_btf) { 1697 err = -errno; 1698 p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno)); 1699 goto err_out; 1700 } 1701 1702 info->marked_btf = btf__parse(targ_btf_path, NULL); 1703 if (!info->marked_btf) { 1704 err = -errno; 1705 p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno)); 1706 goto err_out; 1707 } 1708 1709 return info; 1710 1711err_out: 1712 btfgen_free_info(info); 1713 errno = -err; 1714 return NULL; 1715} 1716 1717#define MARKED UINT32_MAX 1718 1719static void btfgen_mark_member(struct btfgen_info *info, int type_id, int idx) 1720{ 1721 const struct btf_type *t = btf__type_by_id(info->marked_btf, type_id); 1722 struct btf_member *m = btf_members(t) + idx; 1723 1724 m->name_off = MARKED; 1725} 1726 1727static int 1728btfgen_mark_type(struct btfgen_info *info, unsigned int type_id, bool follow_pointers) 1729{ 1730 const struct btf_type *btf_type = btf__type_by_id(info->src_btf, type_id); 1731 struct btf_type *cloned_type; 1732 struct btf_param *param; 1733 struct btf_array *array; 1734 int err, i; 1735 1736 if (type_id == 0) 1737 return 0; 1738 1739 /* mark type on cloned BTF as used */ 1740 cloned_type = (struct btf_type *) btf__type_by_id(info->marked_btf, type_id); 1741 cloned_type->name_off = MARKED; 1742 1743 /* recursively mark other types needed by it */ 1744 switch (btf_kind(btf_type)) { 1745 case BTF_KIND_UNKN: 1746 case BTF_KIND_INT: 1747 case BTF_KIND_FLOAT: 1748 case BTF_KIND_ENUM: 1749 case BTF_KIND_ENUM64: 1750 case BTF_KIND_STRUCT: 1751 case BTF_KIND_UNION: 1752 break; 1753 case BTF_KIND_PTR: 1754 if (follow_pointers) { 1755 err = btfgen_mark_type(info, btf_type->type, follow_pointers); 1756 if (err) 1757 return err; 1758 } 1759 break; 1760 case BTF_KIND_CONST: 1761 case BTF_KIND_RESTRICT: 1762 case BTF_KIND_VOLATILE: 1763 case BTF_KIND_TYPEDEF: 1764 err = btfgen_mark_type(info, btf_type->type, follow_pointers); 1765 if (err) 1766 return err; 1767 break; 1768 case BTF_KIND_ARRAY: 1769 array = btf_array(btf_type); 1770 1771 /* mark array type */ 1772 err = btfgen_mark_type(info, array->type, follow_pointers); 1773 /* mark array's index type */ 1774 err = err ? : btfgen_mark_type(info, array->index_type, follow_pointers); 1775 if (err) 1776 return err; 1777 break; 1778 case BTF_KIND_FUNC_PROTO: 1779 /* mark ret type */ 1780 err = btfgen_mark_type(info, btf_type->type, follow_pointers); 1781 if (err) 1782 return err; 1783 1784 /* mark parameters types */ 1785 param = btf_params(btf_type); 1786 for (i = 0; i < btf_vlen(btf_type); i++) { 1787 err = btfgen_mark_type(info, param->type, follow_pointers); 1788 if (err) 1789 return err; 1790 param++; 1791 } 1792 break; 1793 /* tells if some other type needs to be handled */ 1794 default: 1795 p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id); 1796 return -EINVAL; 1797 } 1798 1799 return 0; 1800} 1801 1802static int btfgen_record_field_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec) 1803{ 1804 struct btf *btf = info->src_btf; 1805 const struct btf_type *btf_type; 1806 struct btf_member *btf_member; 1807 struct btf_array *array; 1808 unsigned int type_id = targ_spec->root_type_id; 1809 int idx, err; 1810 1811 /* mark root type */ 1812 btf_type = btf__type_by_id(btf, type_id); 1813 err = btfgen_mark_type(info, type_id, false); 1814 if (err) 1815 return err; 1816 1817 /* mark types for complex types (arrays, unions, structures) */ 1818 for (int i = 1; i < targ_spec->raw_len; i++) { 1819 /* skip typedefs and mods */ 1820 while (btf_is_mod(btf_type) || btf_is_typedef(btf_type)) { 1821 type_id = btf_type->type; 1822 btf_type = btf__type_by_id(btf, type_id); 1823 } 1824 1825 switch (btf_kind(btf_type)) { 1826 case BTF_KIND_STRUCT: 1827 case BTF_KIND_UNION: 1828 idx = targ_spec->raw_spec[i]; 1829 btf_member = btf_members(btf_type) + idx; 1830 1831 /* mark member */ 1832 btfgen_mark_member(info, type_id, idx); 1833 1834 /* mark member's type */ 1835 type_id = btf_member->type; 1836 btf_type = btf__type_by_id(btf, type_id); 1837 err = btfgen_mark_type(info, type_id, false); 1838 if (err) 1839 return err; 1840 break; 1841 case BTF_KIND_ARRAY: 1842 array = btf_array(btf_type); 1843 type_id = array->type; 1844 btf_type = btf__type_by_id(btf, type_id); 1845 break; 1846 default: 1847 p_err("unsupported kind: %s (%d)", 1848 btf_kind_str(btf_type), btf_type->type); 1849 return -EINVAL; 1850 } 1851 } 1852 1853 return 0; 1854} 1855 1856/* Mark types, members, and member types. Compared to btfgen_record_field_relo, 1857 * this function does not rely on the target spec for inferring members, but 1858 * uses the associated BTF. 1859 * 1860 * The `behind_ptr` argument is used to stop marking of composite types reached 1861 * through a pointer. This way, we can keep BTF size in check while providing 1862 * reasonable match semantics. 1863 */ 1864static int btfgen_mark_type_match(struct btfgen_info *info, __u32 type_id, bool behind_ptr) 1865{ 1866 const struct btf_type *btf_type; 1867 struct btf *btf = info->src_btf; 1868 struct btf_type *cloned_type; 1869 int i, err; 1870 1871 if (type_id == 0) 1872 return 0; 1873 1874 btf_type = btf__type_by_id(btf, type_id); 1875 /* mark type on cloned BTF as used */ 1876 cloned_type = (struct btf_type *)btf__type_by_id(info->marked_btf, type_id); 1877 cloned_type->name_off = MARKED; 1878 1879 switch (btf_kind(btf_type)) { 1880 case BTF_KIND_UNKN: 1881 case BTF_KIND_INT: 1882 case BTF_KIND_FLOAT: 1883 case BTF_KIND_ENUM: 1884 case BTF_KIND_ENUM64: 1885 break; 1886 case BTF_KIND_STRUCT: 1887 case BTF_KIND_UNION: { 1888 struct btf_member *m = btf_members(btf_type); 1889 __u16 vlen = btf_vlen(btf_type); 1890 1891 if (behind_ptr) 1892 break; 1893 1894 for (i = 0; i < vlen; i++, m++) { 1895 /* mark member */ 1896 btfgen_mark_member(info, type_id, i); 1897 1898 /* mark member's type */ 1899 err = btfgen_mark_type_match(info, m->type, false); 1900 if (err) 1901 return err; 1902 } 1903 break; 1904 } 1905 case BTF_KIND_CONST: 1906 case BTF_KIND_FWD: 1907 case BTF_KIND_RESTRICT: 1908 case BTF_KIND_TYPEDEF: 1909 case BTF_KIND_VOLATILE: 1910 return btfgen_mark_type_match(info, btf_type->type, behind_ptr); 1911 case BTF_KIND_PTR: 1912 return btfgen_mark_type_match(info, btf_type->type, true); 1913 case BTF_KIND_ARRAY: { 1914 struct btf_array *array; 1915 1916 array = btf_array(btf_type); 1917 /* mark array type */ 1918 err = btfgen_mark_type_match(info, array->type, false); 1919 /* mark array's index type */ 1920 err = err ? : btfgen_mark_type_match(info, array->index_type, false); 1921 if (err) 1922 return err; 1923 break; 1924 } 1925 case BTF_KIND_FUNC_PROTO: { 1926 __u16 vlen = btf_vlen(btf_type); 1927 struct btf_param *param; 1928 1929 /* mark ret type */ 1930 err = btfgen_mark_type_match(info, btf_type->type, false); 1931 if (err) 1932 return err; 1933 1934 /* mark parameters types */ 1935 param = btf_params(btf_type); 1936 for (i = 0; i < vlen; i++) { 1937 err = btfgen_mark_type_match(info, param->type, false); 1938 if (err) 1939 return err; 1940 param++; 1941 } 1942 break; 1943 } 1944 /* tells if some other type needs to be handled */ 1945 default: 1946 p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id); 1947 return -EINVAL; 1948 } 1949 1950 return 0; 1951} 1952 1953/* Mark types, members, and member types. Compared to btfgen_record_field_relo, 1954 * this function does not rely on the target spec for inferring members, but 1955 * uses the associated BTF. 1956 */ 1957static int btfgen_record_type_match_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec) 1958{ 1959 return btfgen_mark_type_match(info, targ_spec->root_type_id, false); 1960} 1961 1962static int btfgen_record_type_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec) 1963{ 1964 return btfgen_mark_type(info, targ_spec->root_type_id, true); 1965} 1966 1967static int btfgen_record_enumval_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec) 1968{ 1969 return btfgen_mark_type(info, targ_spec->root_type_id, false); 1970} 1971 1972static int btfgen_record_reloc(struct btfgen_info *info, struct bpf_core_spec *res) 1973{ 1974 switch (res->relo_kind) { 1975 case BPF_CORE_FIELD_BYTE_OFFSET: 1976 case BPF_CORE_FIELD_BYTE_SIZE: 1977 case BPF_CORE_FIELD_EXISTS: 1978 case BPF_CORE_FIELD_SIGNED: 1979 case BPF_CORE_FIELD_LSHIFT_U64: 1980 case BPF_CORE_FIELD_RSHIFT_U64: 1981 return btfgen_record_field_relo(info, res); 1982 case BPF_CORE_TYPE_ID_LOCAL: /* BPF_CORE_TYPE_ID_LOCAL doesn't require kernel BTF */ 1983 return 0; 1984 case BPF_CORE_TYPE_ID_TARGET: 1985 case BPF_CORE_TYPE_EXISTS: 1986 case BPF_CORE_TYPE_SIZE: 1987 return btfgen_record_type_relo(info, res); 1988 case BPF_CORE_TYPE_MATCHES: 1989 return btfgen_record_type_match_relo(info, res); 1990 case BPF_CORE_ENUMVAL_EXISTS: 1991 case BPF_CORE_ENUMVAL_VALUE: 1992 return btfgen_record_enumval_relo(info, res); 1993 default: 1994 return -EINVAL; 1995 } 1996} 1997 1998static struct bpf_core_cand_list * 1999btfgen_find_cands(const struct btf *local_btf, const struct btf *targ_btf, __u32 local_id) 2000{ 2001 const struct btf_type *local_type; 2002 struct bpf_core_cand_list *cands = NULL; 2003 struct bpf_core_cand local_cand = {}; 2004 size_t local_essent_len; 2005 const char *local_name; 2006 int err; 2007 2008 local_cand.btf = local_btf; 2009 local_cand.id = local_id; 2010 2011 local_type = btf__type_by_id(local_btf, local_id); 2012 if (!local_type) { 2013 err = -EINVAL; 2014 goto err_out; 2015 } 2016 2017 local_name = btf__name_by_offset(local_btf, local_type->name_off); 2018 if (!local_name) { 2019 err = -EINVAL; 2020 goto err_out; 2021 } 2022 local_essent_len = bpf_core_essential_name_len(local_name); 2023 2024 cands = calloc(1, sizeof(*cands)); 2025 if (!cands) 2026 return NULL; 2027 2028 err = bpf_core_add_cands(&local_cand, local_essent_len, targ_btf, "vmlinux", 1, cands); 2029 if (err) 2030 goto err_out; 2031 2032 return cands; 2033 2034err_out: 2035 bpf_core_free_cands(cands); 2036 errno = -err; 2037 return NULL; 2038} 2039 2040/* Record relocation information for a single BPF object */ 2041static int btfgen_record_obj(struct btfgen_info *info, const char *obj_path) 2042{ 2043 const struct btf_ext_info_sec *sec; 2044 const struct bpf_core_relo *relo; 2045 const struct btf_ext_info *seg; 2046 struct hashmap_entry *entry; 2047 struct hashmap *cand_cache = NULL; 2048 struct btf_ext *btf_ext = NULL; 2049 unsigned int relo_idx; 2050 struct btf *btf = NULL; 2051 size_t i; 2052 int err; 2053 2054 btf = btf__parse(obj_path, &btf_ext); 2055 if (!btf) { 2056 err = -errno; 2057 p_err("failed to parse BPF object '%s': %s", obj_path, strerror(errno)); 2058 return err; 2059 } 2060 2061 if (!btf_ext) { 2062 p_err("failed to parse BPF object '%s': section %s not found", 2063 obj_path, BTF_EXT_ELF_SEC); 2064 err = -EINVAL; 2065 goto out; 2066 } 2067 2068 if (btf_ext->core_relo_info.len == 0) { 2069 err = 0; 2070 goto out; 2071 } 2072 2073 cand_cache = hashmap__new(btfgen_hash_fn, btfgen_equal_fn, NULL); 2074 if (IS_ERR(cand_cache)) { 2075 err = PTR_ERR(cand_cache); 2076 goto out; 2077 } 2078 2079 seg = &btf_ext->core_relo_info; 2080 for_each_btf_ext_sec(seg, sec) { 2081 for_each_btf_ext_rec(seg, sec, relo_idx, relo) { 2082 struct bpf_core_spec specs_scratch[3] = {}; 2083 struct bpf_core_relo_res targ_res = {}; 2084 struct bpf_core_cand_list *cands = NULL; 2085 const char *sec_name = btf__name_by_offset(btf, sec->sec_name_off); 2086 2087 if (relo->kind != BPF_CORE_TYPE_ID_LOCAL && 2088 !hashmap__find(cand_cache, relo->type_id, &cands)) { 2089 cands = btfgen_find_cands(btf, info->src_btf, relo->type_id); 2090 if (!cands) { 2091 err = -errno; 2092 goto out; 2093 } 2094 2095 err = hashmap__set(cand_cache, relo->type_id, cands, 2096 NULL, NULL); 2097 if (err) 2098 goto out; 2099 } 2100 2101 err = bpf_core_calc_relo_insn(sec_name, relo, relo_idx, btf, cands, 2102 specs_scratch, &targ_res); 2103 if (err) 2104 goto out; 2105 2106 /* specs_scratch[2] is the target spec */ 2107 err = btfgen_record_reloc(info, &specs_scratch[2]); 2108 if (err) 2109 goto out; 2110 } 2111 } 2112 2113out: 2114 btf__free(btf); 2115 btf_ext__free(btf_ext); 2116 2117 if (!IS_ERR_OR_NULL(cand_cache)) { 2118 hashmap__for_each_entry(cand_cache, entry, i) { 2119 bpf_core_free_cands(entry->pvalue); 2120 } 2121 hashmap__free(cand_cache); 2122 } 2123 2124 return err; 2125} 2126 2127static int btfgen_remap_id(__u32 *type_id, void *ctx) 2128{ 2129 unsigned int *ids = ctx; 2130 2131 *type_id = ids[*type_id]; 2132 2133 return 0; 2134} 2135 2136/* Generate BTF from relocation information previously recorded */ 2137static struct btf *btfgen_get_btf(struct btfgen_info *info) 2138{ 2139 struct btf *btf_new = NULL; 2140 unsigned int *ids = NULL; 2141 unsigned int i, n = btf__type_cnt(info->marked_btf); 2142 int err = 0; 2143 2144 btf_new = btf__new_empty(); 2145 if (!btf_new) { 2146 err = -errno; 2147 goto err_out; 2148 } 2149 2150 ids = calloc(n, sizeof(*ids)); 2151 if (!ids) { 2152 err = -errno; 2153 goto err_out; 2154 } 2155 2156 /* first pass: add all marked types to btf_new and add their new ids to the ids map */ 2157 for (i = 1; i < n; i++) { 2158 const struct btf_type *cloned_type, *type; 2159 const char *name; 2160 int new_id; 2161 2162 cloned_type = btf__type_by_id(info->marked_btf, i); 2163 2164 if (cloned_type->name_off != MARKED) 2165 continue; 2166 2167 type = btf__type_by_id(info->src_btf, i); 2168 2169 /* add members for struct and union */ 2170 if (btf_is_composite(type)) { 2171 struct btf_member *cloned_m, *m; 2172 unsigned short vlen; 2173 int idx_src; 2174 2175 name = btf__str_by_offset(info->src_btf, type->name_off); 2176 2177 if (btf_is_struct(type)) 2178 err = btf__add_struct(btf_new, name, type->size); 2179 else 2180 err = btf__add_union(btf_new, name, type->size); 2181 2182 if (err < 0) 2183 goto err_out; 2184 new_id = err; 2185 2186 cloned_m = btf_members(cloned_type); 2187 m = btf_members(type); 2188 vlen = btf_vlen(cloned_type); 2189 for (idx_src = 0; idx_src < vlen; idx_src++, cloned_m++, m++) { 2190 /* add only members that are marked as used */ 2191 if (cloned_m->name_off != MARKED) 2192 continue; 2193 2194 name = btf__str_by_offset(info->src_btf, m->name_off); 2195 err = btf__add_field(btf_new, name, m->type, 2196 btf_member_bit_offset(cloned_type, idx_src), 2197 btf_member_bitfield_size(cloned_type, idx_src)); 2198 if (err < 0) 2199 goto err_out; 2200 } 2201 } else { 2202 err = btf__add_type(btf_new, info->src_btf, type); 2203 if (err < 0) 2204 goto err_out; 2205 new_id = err; 2206 } 2207 2208 /* add ID mapping */ 2209 ids[i] = new_id; 2210 } 2211 2212 /* second pass: fix up type ids */ 2213 for (i = 1; i < btf__type_cnt(btf_new); i++) { 2214 struct btf_type *btf_type = (struct btf_type *) btf__type_by_id(btf_new, i); 2215 2216 err = btf_type_visit_type_ids(btf_type, btfgen_remap_id, ids); 2217 if (err) 2218 goto err_out; 2219 } 2220 2221 free(ids); 2222 return btf_new; 2223 2224err_out: 2225 btf__free(btf_new); 2226 free(ids); 2227 errno = -err; 2228 return NULL; 2229} 2230 2231/* Create minimized BTF file for a set of BPF objects. 2232 * 2233 * The BTFGen algorithm is divided in two main parts: (1) collect the 2234 * BTF types that are involved in relocations and (2) generate the BTF 2235 * object using the collected types. 2236 * 2237 * In order to collect the types involved in the relocations, we parse 2238 * the BTF and BTF.ext sections of the BPF objects and use 2239 * bpf_core_calc_relo_insn() to get the target specification, this 2240 * indicates how the types and fields are used in a relocation. 2241 * 2242 * Types are recorded in different ways according to the kind of the 2243 * relocation. For field-based relocations only the members that are 2244 * actually used are saved in order to reduce the size of the generated 2245 * BTF file. For type-based relocations empty struct / unions are 2246 * generated and for enum-based relocations the whole type is saved. 2247 * 2248 * The second part of the algorithm generates the BTF object. It creates 2249 * an empty BTF object and fills it with the types recorded in the 2250 * previous step. This function takes care of only adding the structure 2251 * and union members that were marked as used and it also fixes up the 2252 * type IDs on the generated BTF object. 2253 */ 2254static int minimize_btf(const char *src_btf, const char *dst_btf, const char *objspaths[]) 2255{ 2256 struct btfgen_info *info; 2257 struct btf *btf_new = NULL; 2258 int err, i; 2259 2260 info = btfgen_new_info(src_btf); 2261 if (!info) { 2262 err = -errno; 2263 p_err("failed to allocate info structure: %s", strerror(errno)); 2264 goto out; 2265 } 2266 2267 for (i = 0; objspaths[i] != NULL; i++) { 2268 err = btfgen_record_obj(info, objspaths[i]); 2269 if (err) { 2270 p_err("error recording relocations for %s: %s", objspaths[i], 2271 strerror(errno)); 2272 goto out; 2273 } 2274 } 2275 2276 btf_new = btfgen_get_btf(info); 2277 if (!btf_new) { 2278 err = -errno; 2279 p_err("error generating BTF: %s", strerror(errno)); 2280 goto out; 2281 } 2282 2283 err = btf_save_raw(btf_new, dst_btf); 2284 if (err) { 2285 p_err("error saving btf file: %s", strerror(errno)); 2286 goto out; 2287 } 2288 2289out: 2290 btf__free(btf_new); 2291 btfgen_free_info(info); 2292 2293 return err; 2294} 2295 2296static int do_min_core_btf(int argc, char **argv) 2297{ 2298 const char *input, *output, **objs; 2299 int i, err; 2300 2301 if (!REQ_ARGS(3)) { 2302 usage(); 2303 return -1; 2304 } 2305 2306 input = GET_ARG(); 2307 output = GET_ARG(); 2308 2309 objs = (const char **) calloc(argc + 1, sizeof(*objs)); 2310 if (!objs) { 2311 p_err("failed to allocate array for object names"); 2312 return -ENOMEM; 2313 } 2314 2315 i = 0; 2316 while (argc) 2317 objs[i++] = GET_ARG(); 2318 2319 err = minimize_btf(input, output, objs); 2320 free(objs); 2321 return err; 2322} 2323 2324static const struct cmd cmds[] = { 2325 { "object", do_object }, 2326 { "skeleton", do_skeleton }, 2327 { "subskeleton", do_subskeleton }, 2328 { "min_core_btf", do_min_core_btf}, 2329 { "help", do_help }, 2330 { 0 } 2331}; 2332 2333int do_gen(int argc, char **argv) 2334{ 2335 return cmd_select(cmds, argc, argv, do_help); 2336} 2337