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 <sys/types.h> 18 #include <sys/stat.h> 19 #include <sys/mman.h> 20 #include <bpf/btf.h> 21 22 #include "json_writer.h" 23 #include "main.h" 24 25 #define MAX_OBJ_NAME_LEN 64 26 27 static void sanitize_identifier(char *name) 28 { 29 int i; 30 31 for (i = 0; name[i]; i++) 32 if (!isalnum(name[i]) && name[i] != '_') 33 name[i] = '_'; 34 } 35 36 static bool str_has_suffix(const char *str, const char *suffix) 37 { 38 size_t i, n1 = strlen(str), n2 = strlen(suffix); 39 40 if (n1 < n2) 41 return false; 42 43 for (i = 0; i < n2; i++) { 44 if (str[n1 - i - 1] != suffix[n2 - i - 1]) 45 return false; 46 } 47 48 return true; 49 } 50 51 static void get_obj_name(char *name, const char *file) 52 { 53 /* Using basename() GNU version which doesn't modify arg. */ 54 strncpy(name, basename(file), MAX_OBJ_NAME_LEN - 1); 55 name[MAX_OBJ_NAME_LEN - 1] = '\0'; 56 if (str_has_suffix(name, ".o")) 57 name[strlen(name) - 2] = '\0'; 58 sanitize_identifier(name); 59 } 60 61 static void get_header_guard(char *guard, const char *obj_name) 62 { 63 int i; 64 65 sprintf(guard, "__%s_SKEL_H__", obj_name); 66 for (i = 0; guard[i]; i++) 67 guard[i] = toupper(guard[i]); 68 } 69 70 static const char *get_map_ident(const struct bpf_map *map) 71 { 72 const char *name = bpf_map__name(map); 73 74 if (!bpf_map__is_internal(map)) 75 return name; 76 77 if (str_has_suffix(name, ".data")) 78 return "data"; 79 else if (str_has_suffix(name, ".rodata")) 80 return "rodata"; 81 else if (str_has_suffix(name, ".bss")) 82 return "bss"; 83 else if (str_has_suffix(name, ".kconfig")) 84 return "kconfig"; 85 else 86 return NULL; 87 } 88 89 static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args) 90 { 91 vprintf(fmt, args); 92 } 93 94 static int codegen_datasec_def(struct bpf_object *obj, 95 struct btf *btf, 96 struct btf_dump *d, 97 const struct btf_type *sec, 98 const char *obj_name) 99 { 100 const char *sec_name = btf__name_by_offset(btf, sec->name_off); 101 const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec); 102 int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec); 103 const char *sec_ident; 104 char var_ident[256]; 105 bool strip_mods = false; 106 107 if (strcmp(sec_name, ".data") == 0) { 108 sec_ident = "data"; 109 } else if (strcmp(sec_name, ".bss") == 0) { 110 sec_ident = "bss"; 111 } else if (strcmp(sec_name, ".rodata") == 0) { 112 sec_ident = "rodata"; 113 strip_mods = true; 114 } else if (strcmp(sec_name, ".kconfig") == 0) { 115 sec_ident = "kconfig"; 116 } else { 117 return 0; 118 } 119 120 printf(" struct %s__%s {\n", obj_name, sec_ident); 121 for (i = 0; i < vlen; i++, sec_var++) { 122 const struct btf_type *var = btf__type_by_id(btf, sec_var->type); 123 const char *var_name = btf__name_by_offset(btf, var->name_off); 124 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts, 125 .field_name = var_ident, 126 .indent_level = 2, 127 .strip_mods = strip_mods, 128 ); 129 int need_off = sec_var->offset, align_off, align; 130 __u32 var_type_id = var->type; 131 132 if (off > need_off) { 133 p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n", 134 sec_name, i, need_off, off); 135 return -EINVAL; 136 } 137 138 align = btf__align_of(btf, var->type); 139 if (align <= 0) { 140 p_err("Failed to determine alignment of variable '%s': %d", 141 var_name, align); 142 return -EINVAL; 143 } 144 /* Assume 32-bit architectures when generating data section 145 * struct memory layout. Given bpftool can't know which target 146 * host architecture it's emitting skeleton for, we need to be 147 * conservative and assume 32-bit one to ensure enough padding 148 * bytes are generated for pointer and long types. This will 149 * still work correctly for 64-bit architectures, because in 150 * the worst case we'll generate unnecessary padding field, 151 * which on 64-bit architectures is not strictly necessary and 152 * would be handled by natural 8-byte alignment. But it still 153 * will be a correct memory layout, based on recorded offsets 154 * in BTF. 155 */ 156 if (align > 4) 157 align = 4; 158 159 align_off = (off + align - 1) / align * align; 160 if (align_off != need_off) { 161 printf("\t\tchar __pad%d[%d];\n", 162 pad_cnt, need_off - off); 163 pad_cnt++; 164 } 165 166 /* sanitize variable name, e.g., for static vars inside 167 * a function, it's name is '<function name>.<variable name>', 168 * which we'll turn into a '<function name>_<variable name>' 169 */ 170 var_ident[0] = '\0'; 171 strncat(var_ident, var_name, sizeof(var_ident) - 1); 172 sanitize_identifier(var_ident); 173 174 printf("\t\t"); 175 err = btf_dump__emit_type_decl(d, var_type_id, &opts); 176 if (err) 177 return err; 178 printf(";\n"); 179 180 off = sec_var->offset + sec_var->size; 181 } 182 printf(" } *%s;\n", sec_ident); 183 return 0; 184 } 185 186 static int codegen_datasecs(struct bpf_object *obj, const char *obj_name) 187 { 188 struct btf *btf = bpf_object__btf(obj); 189 int n = btf__get_nr_types(btf); 190 struct btf_dump *d; 191 int i, err = 0; 192 193 d = btf_dump__new(btf, NULL, NULL, codegen_btf_dump_printf); 194 if (IS_ERR(d)) 195 return PTR_ERR(d); 196 197 for (i = 1; i <= n; i++) { 198 const struct btf_type *t = btf__type_by_id(btf, i); 199 200 if (!btf_is_datasec(t)) 201 continue; 202 203 err = codegen_datasec_def(obj, btf, d, t, obj_name); 204 if (err) 205 goto out; 206 } 207 out: 208 btf_dump__free(d); 209 return err; 210 } 211 212 static void codegen(const char *template, ...) 213 { 214 const char *src, *end; 215 int skip_tabs = 0, n; 216 char *s, *dst; 217 va_list args; 218 char c; 219 220 n = strlen(template); 221 s = malloc(n + 1); 222 if (!s) 223 exit(-1); 224 src = template; 225 dst = s; 226 227 /* find out "baseline" indentation to skip */ 228 while ((c = *src++)) { 229 if (c == '\t') { 230 skip_tabs++; 231 } else if (c == '\n') { 232 break; 233 } else { 234 p_err("unrecognized character at pos %td in template '%s'", 235 src - template - 1, template); 236 free(s); 237 exit(-1); 238 } 239 } 240 241 while (*src) { 242 /* skip baseline indentation tabs */ 243 for (n = skip_tabs; n > 0; n--, src++) { 244 if (*src != '\t') { 245 p_err("not enough tabs at pos %td in template '%s'", 246 src - template - 1, template); 247 free(s); 248 exit(-1); 249 } 250 } 251 /* trim trailing whitespace */ 252 end = strchrnul(src, '\n'); 253 for (n = end - src; n > 0 && isspace(src[n - 1]); n--) 254 ; 255 memcpy(dst, src, n); 256 dst += n; 257 if (*end) 258 *dst++ = '\n'; 259 src = *end ? end + 1 : end; 260 } 261 *dst++ = '\0'; 262 263 /* print out using adjusted template */ 264 va_start(args, template); 265 n = vprintf(s, args); 266 va_end(args); 267 268 free(s); 269 } 270 271 static int do_skeleton(int argc, char **argv) 272 { 273 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")]; 274 size_t i, map_cnt = 0, prog_cnt = 0, file_sz, mmap_sz; 275 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts); 276 char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data; 277 struct bpf_object *obj = NULL; 278 const char *file, *ident; 279 struct bpf_program *prog; 280 int fd, len, err = -1; 281 struct bpf_map *map; 282 struct btf *btf; 283 struct stat st; 284 285 if (!REQ_ARGS(1)) { 286 usage(); 287 return -1; 288 } 289 file = GET_ARG(); 290 291 while (argc) { 292 if (!REQ_ARGS(2)) 293 return -1; 294 295 if (is_prefix(*argv, "name")) { 296 NEXT_ARG(); 297 298 if (obj_name[0] != '\0') { 299 p_err("object name already specified"); 300 return -1; 301 } 302 303 strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1); 304 obj_name[MAX_OBJ_NAME_LEN - 1] = '\0'; 305 } else { 306 p_err("unknown arg %s", *argv); 307 return -1; 308 } 309 310 NEXT_ARG(); 311 } 312 313 if (argc) { 314 p_err("extra unknown arguments"); 315 return -1; 316 } 317 318 if (stat(file, &st)) { 319 p_err("failed to stat() %s: %s", file, strerror(errno)); 320 return -1; 321 } 322 file_sz = st.st_size; 323 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE)); 324 fd = open(file, O_RDONLY); 325 if (fd < 0) { 326 p_err("failed to open() %s: %s", file, strerror(errno)); 327 return -1; 328 } 329 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0); 330 if (obj_data == MAP_FAILED) { 331 obj_data = NULL; 332 p_err("failed to mmap() %s: %s", file, strerror(errno)); 333 goto out; 334 } 335 if (obj_name[0] == '\0') 336 get_obj_name(obj_name, file); 337 opts.object_name = obj_name; 338 obj = bpf_object__open_mem(obj_data, file_sz, &opts); 339 if (IS_ERR(obj)) { 340 char err_buf[256]; 341 342 libbpf_strerror(PTR_ERR(obj), err_buf, sizeof(err_buf)); 343 p_err("failed to open BPF object file: %s", err_buf); 344 obj = NULL; 345 goto out; 346 } 347 348 bpf_object__for_each_map(map, obj) { 349 ident = get_map_ident(map); 350 if (!ident) { 351 p_err("ignoring unrecognized internal map '%s'...", 352 bpf_map__name(map)); 353 continue; 354 } 355 map_cnt++; 356 } 357 bpf_object__for_each_program(prog, obj) { 358 prog_cnt++; 359 } 360 361 get_header_guard(header_guard, obj_name); 362 codegen("\ 363 \n\ 364 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\ 365 \n\ 366 /* THIS FILE IS AUTOGENERATED! */ \n\ 367 #ifndef %2$s \n\ 368 #define %2$s \n\ 369 \n\ 370 #include <stdlib.h> \n\ 371 #include <bpf/libbpf.h> \n\ 372 \n\ 373 struct %1$s { \n\ 374 struct bpf_object_skeleton *skeleton; \n\ 375 struct bpf_object *obj; \n\ 376 ", 377 obj_name, header_guard 378 ); 379 380 if (map_cnt) { 381 printf("\tstruct {\n"); 382 bpf_object__for_each_map(map, obj) { 383 ident = get_map_ident(map); 384 if (!ident) 385 continue; 386 printf("\t\tstruct bpf_map *%s;\n", ident); 387 } 388 printf("\t} maps;\n"); 389 } 390 391 if (prog_cnt) { 392 printf("\tstruct {\n"); 393 bpf_object__for_each_program(prog, obj) { 394 printf("\t\tstruct bpf_program *%s;\n", 395 bpf_program__name(prog)); 396 } 397 printf("\t} progs;\n"); 398 printf("\tstruct {\n"); 399 bpf_object__for_each_program(prog, obj) { 400 printf("\t\tstruct bpf_link *%s;\n", 401 bpf_program__name(prog)); 402 } 403 printf("\t} links;\n"); 404 } 405 406 btf = bpf_object__btf(obj); 407 if (btf) { 408 err = codegen_datasecs(obj, obj_name); 409 if (err) 410 goto out; 411 } 412 413 codegen("\ 414 \n\ 415 }; \n\ 416 \n\ 417 static void \n\ 418 %1$s__destroy(struct %1$s *obj) \n\ 419 { \n\ 420 if (!obj) \n\ 421 return; \n\ 422 if (obj->skeleton) \n\ 423 bpf_object__destroy_skeleton(obj->skeleton);\n\ 424 free(obj); \n\ 425 } \n\ 426 \n\ 427 static inline int \n\ 428 %1$s__create_skeleton(struct %1$s *obj); \n\ 429 \n\ 430 static inline struct %1$s * \n\ 431 %1$s__open_opts(const struct bpf_object_open_opts *opts) \n\ 432 { \n\ 433 struct %1$s *obj; \n\ 434 \n\ 435 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\ 436 if (!obj) \n\ 437 return NULL; \n\ 438 if (%1$s__create_skeleton(obj)) \n\ 439 goto err; \n\ 440 if (bpf_object__open_skeleton(obj->skeleton, opts)) \n\ 441 goto err; \n\ 442 \n\ 443 return obj; \n\ 444 err: \n\ 445 %1$s__destroy(obj); \n\ 446 return NULL; \n\ 447 } \n\ 448 \n\ 449 static inline struct %1$s * \n\ 450 %1$s__open(void) \n\ 451 { \n\ 452 return %1$s__open_opts(NULL); \n\ 453 } \n\ 454 \n\ 455 static inline int \n\ 456 %1$s__load(struct %1$s *obj) \n\ 457 { \n\ 458 return bpf_object__load_skeleton(obj->skeleton); \n\ 459 } \n\ 460 \n\ 461 static inline struct %1$s * \n\ 462 %1$s__open_and_load(void) \n\ 463 { \n\ 464 struct %1$s *obj; \n\ 465 \n\ 466 obj = %1$s__open(); \n\ 467 if (!obj) \n\ 468 return NULL; \n\ 469 if (%1$s__load(obj)) { \n\ 470 %1$s__destroy(obj); \n\ 471 return NULL; \n\ 472 } \n\ 473 return obj; \n\ 474 } \n\ 475 \n\ 476 static inline int \n\ 477 %1$s__attach(struct %1$s *obj) \n\ 478 { \n\ 479 return bpf_object__attach_skeleton(obj->skeleton); \n\ 480 } \n\ 481 \n\ 482 static inline void \n\ 483 %1$s__detach(struct %1$s *obj) \n\ 484 { \n\ 485 return bpf_object__detach_skeleton(obj->skeleton); \n\ 486 } \n\ 487 ", 488 obj_name 489 ); 490 491 codegen("\ 492 \n\ 493 \n\ 494 static inline int \n\ 495 %1$s__create_skeleton(struct %1$s *obj) \n\ 496 { \n\ 497 struct bpf_object_skeleton *s; \n\ 498 \n\ 499 s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\ 500 if (!s) \n\ 501 return -1; \n\ 502 obj->skeleton = s; \n\ 503 \n\ 504 s->sz = sizeof(*s); \n\ 505 s->name = \"%1$s\"; \n\ 506 s->obj = &obj->obj; \n\ 507 ", 508 obj_name 509 ); 510 if (map_cnt) { 511 codegen("\ 512 \n\ 513 \n\ 514 /* maps */ \n\ 515 s->map_cnt = %zu; \n\ 516 s->map_skel_sz = sizeof(*s->maps); \n\ 517 s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz);\n\ 518 if (!s->maps) \n\ 519 goto err; \n\ 520 ", 521 map_cnt 522 ); 523 i = 0; 524 bpf_object__for_each_map(map, obj) { 525 ident = get_map_ident(map); 526 527 if (!ident) 528 continue; 529 530 codegen("\ 531 \n\ 532 \n\ 533 s->maps[%zu].name = \"%s\"; \n\ 534 s->maps[%zu].map = &obj->maps.%s; \n\ 535 ", 536 i, bpf_map__name(map), i, ident); 537 /* memory-mapped internal maps */ 538 if (bpf_map__is_internal(map) && 539 (bpf_map__def(map)->map_flags & BPF_F_MMAPABLE)) { 540 printf("\ts->maps[%zu].mmaped = (void **)&obj->%s;\n", 541 i, ident); 542 } 543 i++; 544 } 545 } 546 if (prog_cnt) { 547 codegen("\ 548 \n\ 549 \n\ 550 /* programs */ \n\ 551 s->prog_cnt = %zu; \n\ 552 s->prog_skel_sz = sizeof(*s->progs); \n\ 553 s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\ 554 if (!s->progs) \n\ 555 goto err; \n\ 556 ", 557 prog_cnt 558 ); 559 i = 0; 560 bpf_object__for_each_program(prog, obj) { 561 codegen("\ 562 \n\ 563 \n\ 564 s->progs[%1$zu].name = \"%2$s\"; \n\ 565 s->progs[%1$zu].prog = &obj->progs.%2$s;\n\ 566 s->progs[%1$zu].link = &obj->links.%2$s;\n\ 567 ", 568 i, bpf_program__name(prog)); 569 i++; 570 } 571 } 572 codegen("\ 573 \n\ 574 \n\ 575 s->data_sz = %d; \n\ 576 s->data = (void *)\"\\ \n\ 577 ", 578 file_sz); 579 580 /* embed contents of BPF object file */ 581 for (i = 0, len = 0; i < file_sz; i++) { 582 int w = obj_data[i] ? 4 : 2; 583 584 len += w; 585 if (len > 78) { 586 printf("\\\n"); 587 len = w; 588 } 589 if (!obj_data[i]) 590 printf("\\0"); 591 else 592 printf("\\x%02x", (unsigned char)obj_data[i]); 593 } 594 595 codegen("\ 596 \n\ 597 \"; \n\ 598 \n\ 599 return 0; \n\ 600 err: \n\ 601 bpf_object__destroy_skeleton(s); \n\ 602 return -1; \n\ 603 } \n\ 604 \n\ 605 #endif /* %s */ \n\ 606 ", 607 header_guard); 608 err = 0; 609 out: 610 bpf_object__close(obj); 611 if (obj_data) 612 munmap(obj_data, mmap_sz); 613 close(fd); 614 return err; 615 } 616 617 static int do_object(int argc, char **argv) 618 { 619 struct bpf_linker *linker; 620 const char *output_file, *file; 621 int err = 0; 622 623 if (!REQ_ARGS(2)) { 624 usage(); 625 return -1; 626 } 627 628 output_file = GET_ARG(); 629 630 linker = bpf_linker__new(output_file, NULL); 631 if (!linker) { 632 p_err("failed to create BPF linker instance"); 633 return -1; 634 } 635 636 while (argc) { 637 file = GET_ARG(); 638 639 err = bpf_linker__add_file(linker, file); 640 if (err) { 641 p_err("failed to link '%s': %s (%d)", file, strerror(err), err); 642 goto out; 643 } 644 } 645 646 err = bpf_linker__finalize(linker); 647 if (err) { 648 p_err("failed to finalize ELF file: %s (%d)", strerror(err), err); 649 goto out; 650 } 651 652 err = 0; 653 out: 654 bpf_linker__free(linker); 655 return err; 656 } 657 658 static int do_help(int argc, char **argv) 659 { 660 if (json_output) { 661 jsonw_null(json_wtr); 662 return 0; 663 } 664 665 fprintf(stderr, 666 "Usage: %1$s %2$s object OUTPUT_FILE INPUT_FILE [INPUT_FILE...]\n" 667 " %1$s %2$s skeleton FILE [name OBJECT_NAME]\n" 668 " %1$s %2$s help\n" 669 "\n" 670 " " HELP_SPEC_OPTIONS "\n" 671 "", 672 bin_name, "gen"); 673 674 return 0; 675 } 676 677 static const struct cmd cmds[] = { 678 { "object", do_object }, 679 { "skeleton", do_skeleton }, 680 { "help", do_help }, 681 { 0 } 682 }; 683 684 int do_gen(int argc, char **argv) 685 { 686 return cmd_select(cmds, argc, argv, do_help); 687 } 688