1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2020 Facebook */ 3 4 #include <errno.h> 5 #include <stdio.h> 6 #include <unistd.h> 7 8 #include <linux/err.h> 9 10 #include <bpf/bpf.h> 11 #include <bpf/btf.h> 12 #include <bpf/libbpf.h> 13 14 #include "json_writer.h" 15 #include "main.h" 16 17 #define STRUCT_OPS_VALUE_PREFIX "bpf_struct_ops_" 18 19 static const struct btf_type *map_info_type; 20 static __u32 map_info_alloc_len; 21 static struct btf *btf_vmlinux; 22 static __s32 map_info_type_id; 23 24 struct res { 25 unsigned int nr_maps; 26 unsigned int nr_errs; 27 }; 28 29 static const struct btf *get_btf_vmlinux(void) 30 { 31 if (btf_vmlinux) 32 return btf_vmlinux; 33 34 btf_vmlinux = libbpf_find_kernel_btf(); 35 if (!btf_vmlinux) 36 p_err("struct_ops requires kernel CONFIG_DEBUG_INFO_BTF=y"); 37 38 return btf_vmlinux; 39 } 40 41 static const char *get_kern_struct_ops_name(const struct bpf_map_info *info) 42 { 43 const struct btf *kern_btf; 44 const struct btf_type *t; 45 const char *st_ops_name; 46 47 kern_btf = get_btf_vmlinux(); 48 if (!kern_btf) 49 return "<btf_vmlinux_not_found>"; 50 51 t = btf__type_by_id(kern_btf, info->btf_vmlinux_value_type_id); 52 st_ops_name = btf__name_by_offset(kern_btf, t->name_off); 53 st_ops_name += strlen(STRUCT_OPS_VALUE_PREFIX); 54 55 return st_ops_name; 56 } 57 58 static __s32 get_map_info_type_id(void) 59 { 60 const struct btf *kern_btf; 61 62 if (map_info_type_id) 63 return map_info_type_id; 64 65 kern_btf = get_btf_vmlinux(); 66 if (!kern_btf) 67 return 0; 68 69 map_info_type_id = btf__find_by_name_kind(kern_btf, "bpf_map_info", 70 BTF_KIND_STRUCT); 71 if (map_info_type_id < 0) { 72 p_err("can't find bpf_map_info from btf_vmlinux"); 73 return map_info_type_id; 74 } 75 map_info_type = btf__type_by_id(kern_btf, map_info_type_id); 76 77 /* Ensure map_info_alloc() has at least what the bpftool needs */ 78 map_info_alloc_len = map_info_type->size; 79 if (map_info_alloc_len < sizeof(struct bpf_map_info)) 80 map_info_alloc_len = sizeof(struct bpf_map_info); 81 82 return map_info_type_id; 83 } 84 85 /* If the subcmd needs to print out the bpf_map_info, 86 * it should always call map_info_alloc to allocate 87 * a bpf_map_info object instead of allocating it 88 * on the stack. 89 * 90 * map_info_alloc() will take the running kernel's btf 91 * into account. i.e. it will consider the 92 * sizeof(struct bpf_map_info) of the running kernel. 93 * 94 * It will enable the "struct_ops" cmd to print the latest 95 * "struct bpf_map_info". 96 * 97 * [ Recall that "struct_ops" requires the kernel's btf to 98 * be available ] 99 */ 100 static struct bpf_map_info *map_info_alloc(__u32 *alloc_len) 101 { 102 struct bpf_map_info *info; 103 104 if (get_map_info_type_id() < 0) 105 return NULL; 106 107 info = calloc(1, map_info_alloc_len); 108 if (!info) 109 p_err("mem alloc failed"); 110 else 111 *alloc_len = map_info_alloc_len; 112 113 return info; 114 } 115 116 /* It iterates all struct_ops maps of the system. 117 * It returns the fd in "*res_fd" and map_info in "*info". 118 * In the very first iteration, info->id should be 0. 119 * An optional map "*name" filter can be specified. 120 * The filter can be made more flexible in the future. 121 * e.g. filter by kernel-struct-ops-name, regex-name, glob-name, ...etc. 122 * 123 * Return value: 124 * 1: A struct_ops map found. It is returned in "*res_fd" and "*info". 125 * The caller can continue to call get_next in the future. 126 * 0: No struct_ops map is returned. 127 * All struct_ops map has been found. 128 * -1: Error and the caller should abort the iteration. 129 */ 130 static int get_next_struct_ops_map(const char *name, int *res_fd, 131 struct bpf_map_info *info, __u32 info_len) 132 { 133 __u32 id = info->id; 134 int err, fd; 135 136 while (true) { 137 err = bpf_map_get_next_id(id, &id); 138 if (err) { 139 if (errno == ENOENT) 140 return 0; 141 p_err("can't get next map: %s", strerror(errno)); 142 return -1; 143 } 144 145 fd = bpf_map_get_fd_by_id(id); 146 if (fd < 0) { 147 if (errno == ENOENT) 148 continue; 149 p_err("can't get map by id (%u): %s", 150 id, strerror(errno)); 151 return -1; 152 } 153 154 err = bpf_map_get_info_by_fd(fd, info, &info_len); 155 if (err) { 156 p_err("can't get map info: %s", strerror(errno)); 157 close(fd); 158 return -1; 159 } 160 161 if (info->type == BPF_MAP_TYPE_STRUCT_OPS && 162 (!name || !strcmp(name, info->name))) { 163 *res_fd = fd; 164 return 1; 165 } 166 close(fd); 167 } 168 } 169 170 static int cmd_retval(const struct res *res, bool must_have_one_map) 171 { 172 if (res->nr_errs || (!res->nr_maps && must_have_one_map)) 173 return -1; 174 175 return 0; 176 } 177 178 /* "data" is the work_func private storage */ 179 typedef int (*work_func)(int fd, const struct bpf_map_info *info, void *data, 180 struct json_writer *wtr); 181 182 /* Find all struct_ops map in the system. 183 * Filter out by "name" (if specified). 184 * Then call "func(fd, info, data, wtr)" on each struct_ops map found. 185 */ 186 static struct res do_search(const char *name, work_func func, void *data, 187 struct json_writer *wtr) 188 { 189 struct bpf_map_info *info; 190 struct res res = {}; 191 __u32 info_len; 192 int fd, err; 193 194 info = map_info_alloc(&info_len); 195 if (!info) { 196 res.nr_errs++; 197 return res; 198 } 199 200 if (wtr) 201 jsonw_start_array(wtr); 202 while ((err = get_next_struct_ops_map(name, &fd, info, info_len)) == 1) { 203 res.nr_maps++; 204 err = func(fd, info, data, wtr); 205 if (err) 206 res.nr_errs++; 207 close(fd); 208 } 209 if (wtr) 210 jsonw_end_array(wtr); 211 212 if (err) 213 res.nr_errs++; 214 215 if (!wtr && name && !res.nr_errs && !res.nr_maps) 216 /* It is not printing empty []. 217 * Thus, needs to specifically say nothing found 218 * for "name" here. 219 */ 220 p_err("no struct_ops found for %s", name); 221 else if (!wtr && json_output && !res.nr_errs) 222 /* The "func()" above is not writing any json (i.e. !wtr 223 * test here). 224 * 225 * However, "-j" is enabled and there is no errs here, 226 * so call json_null() as the current convention of 227 * other cmds. 228 */ 229 jsonw_null(json_wtr); 230 231 free(info); 232 return res; 233 } 234 235 static struct res do_one_id(const char *id_str, work_func func, void *data, 236 struct json_writer *wtr) 237 { 238 struct bpf_map_info *info; 239 struct res res = {}; 240 unsigned long id; 241 __u32 info_len; 242 char *endptr; 243 int fd; 244 245 id = strtoul(id_str, &endptr, 0); 246 if (*endptr || !id || id > UINT32_MAX) { 247 p_err("invalid id %s", id_str); 248 res.nr_errs++; 249 return res; 250 } 251 252 fd = bpf_map_get_fd_by_id(id); 253 if (fd < 0) { 254 p_err("can't get map by id (%lu): %s", id, strerror(errno)); 255 res.nr_errs++; 256 return res; 257 } 258 259 info = map_info_alloc(&info_len); 260 if (!info) { 261 res.nr_errs++; 262 goto done; 263 } 264 265 if (bpf_map_get_info_by_fd(fd, info, &info_len)) { 266 p_err("can't get map info: %s", strerror(errno)); 267 res.nr_errs++; 268 goto done; 269 } 270 271 if (info->type != BPF_MAP_TYPE_STRUCT_OPS) { 272 p_err("%s id %u is not a struct_ops map", info->name, info->id); 273 res.nr_errs++; 274 goto done; 275 } 276 277 res.nr_maps++; 278 279 if (func(fd, info, data, wtr)) 280 res.nr_errs++; 281 else if (!wtr && json_output) 282 /* The "func()" above is not writing any json (i.e. !wtr 283 * test here). 284 * 285 * However, "-j" is enabled and there is no errs here, 286 * so call json_null() as the current convention of 287 * other cmds. 288 */ 289 jsonw_null(json_wtr); 290 291 done: 292 free(info); 293 close(fd); 294 295 return res; 296 } 297 298 static struct res do_work_on_struct_ops(const char *search_type, 299 const char *search_term, 300 work_func func, void *data, 301 struct json_writer *wtr) 302 { 303 if (search_type) { 304 if (is_prefix(search_type, "id")) 305 return do_one_id(search_term, func, data, wtr); 306 else if (!is_prefix(search_type, "name")) 307 usage(); 308 } 309 310 return do_search(search_term, func, data, wtr); 311 } 312 313 static int __do_show(int fd, const struct bpf_map_info *info, void *data, 314 struct json_writer *wtr) 315 { 316 if (wtr) { 317 jsonw_start_object(wtr); 318 jsonw_uint_field(wtr, "id", info->id); 319 jsonw_string_field(wtr, "name", info->name); 320 jsonw_string_field(wtr, "kernel_struct_ops", 321 get_kern_struct_ops_name(info)); 322 jsonw_end_object(wtr); 323 } else { 324 printf("%u: %-15s %-32s\n", info->id, info->name, 325 get_kern_struct_ops_name(info)); 326 } 327 328 return 0; 329 } 330 331 static int do_show(int argc, char **argv) 332 { 333 const char *search_type = NULL, *search_term = NULL; 334 struct res res; 335 336 if (argc && argc != 2) 337 usage(); 338 339 if (argc == 2) { 340 search_type = GET_ARG(); 341 search_term = GET_ARG(); 342 } 343 344 res = do_work_on_struct_ops(search_type, search_term, __do_show, 345 NULL, json_wtr); 346 347 return cmd_retval(&res, !!search_term); 348 } 349 350 static int __do_dump(int fd, const struct bpf_map_info *info, void *data, 351 struct json_writer *wtr) 352 { 353 struct btf_dumper *d = (struct btf_dumper *)data; 354 const struct btf_type *struct_ops_type; 355 const struct btf *kern_btf = d->btf; 356 const char *struct_ops_name; 357 int zero = 0; 358 void *value; 359 360 /* note: d->jw == wtr */ 361 362 kern_btf = d->btf; 363 364 /* The kernel supporting BPF_MAP_TYPE_STRUCT_OPS must have 365 * btf_vmlinux_value_type_id. 366 */ 367 struct_ops_type = btf__type_by_id(kern_btf, 368 info->btf_vmlinux_value_type_id); 369 struct_ops_name = btf__name_by_offset(kern_btf, 370 struct_ops_type->name_off); 371 value = calloc(1, info->value_size); 372 if (!value) { 373 p_err("mem alloc failed"); 374 return -1; 375 } 376 377 if (bpf_map_lookup_elem(fd, &zero, value)) { 378 p_err("can't lookup struct_ops map %s id %u", 379 info->name, info->id); 380 free(value); 381 return -1; 382 } 383 384 jsonw_start_object(wtr); 385 jsonw_name(wtr, "bpf_map_info"); 386 btf_dumper_type(d, map_info_type_id, (void *)info); 387 jsonw_end_object(wtr); 388 389 jsonw_start_object(wtr); 390 jsonw_name(wtr, struct_ops_name); 391 btf_dumper_type(d, info->btf_vmlinux_value_type_id, value); 392 jsonw_end_object(wtr); 393 394 free(value); 395 396 return 0; 397 } 398 399 static int do_dump(int argc, char **argv) 400 { 401 const char *search_type = NULL, *search_term = NULL; 402 json_writer_t *wtr = json_wtr; 403 const struct btf *kern_btf; 404 struct btf_dumper d = {}; 405 struct res res; 406 407 if (argc && argc != 2) 408 usage(); 409 410 if (argc == 2) { 411 search_type = GET_ARG(); 412 search_term = GET_ARG(); 413 } 414 415 kern_btf = get_btf_vmlinux(); 416 if (!kern_btf) 417 return -1; 418 419 if (!json_output) { 420 wtr = jsonw_new(stdout); 421 if (!wtr) { 422 p_err("can't create json writer"); 423 return -1; 424 } 425 jsonw_pretty(wtr, true); 426 } 427 428 d.btf = kern_btf; 429 d.jw = wtr; 430 d.is_plain_text = !json_output; 431 d.prog_id_as_func_ptr = true; 432 433 res = do_work_on_struct_ops(search_type, search_term, __do_dump, &d, 434 wtr); 435 436 if (!json_output) 437 jsonw_destroy(&wtr); 438 439 return cmd_retval(&res, !!search_term); 440 } 441 442 static int __do_unregister(int fd, const struct bpf_map_info *info, void *data, 443 struct json_writer *wtr) 444 { 445 int zero = 0; 446 447 if (bpf_map_delete_elem(fd, &zero)) { 448 p_err("can't unload %s %s id %u: %s", 449 get_kern_struct_ops_name(info), info->name, 450 info->id, strerror(errno)); 451 return -1; 452 } 453 454 p_info("Unregistered %s %s id %u", 455 get_kern_struct_ops_name(info), info->name, 456 info->id); 457 458 return 0; 459 } 460 461 static int do_unregister(int argc, char **argv) 462 { 463 const char *search_type, *search_term; 464 struct res res; 465 466 if (argc != 2) 467 usage(); 468 469 search_type = GET_ARG(); 470 search_term = GET_ARG(); 471 472 res = do_work_on_struct_ops(search_type, search_term, 473 __do_unregister, NULL, NULL); 474 475 return cmd_retval(&res, true); 476 } 477 478 static int pin_link(struct bpf_link *link, const char *pindir, 479 const char *name) 480 { 481 char pinfile[PATH_MAX]; 482 int err; 483 484 err = pathname_concat(pinfile, sizeof(pinfile), pindir, name); 485 if (err) 486 return -1; 487 488 return bpf_link__pin(link, pinfile); 489 } 490 491 static int do_register(int argc, char **argv) 492 { 493 LIBBPF_OPTS(bpf_object_open_opts, open_opts); 494 __u32 link_info_len = sizeof(struct bpf_link_info); 495 struct bpf_link_info link_info = {}; 496 struct bpf_map_info info = {}; 497 __u32 info_len = sizeof(info); 498 int nr_errs = 0, nr_maps = 0; 499 const char *linkdir = NULL; 500 struct bpf_object *obj; 501 struct bpf_link *link; 502 struct bpf_map *map; 503 const char *file; 504 505 if (argc != 1 && argc != 2) 506 usage(); 507 508 file = GET_ARG(); 509 if (argc == 1) 510 linkdir = GET_ARG(); 511 512 if (linkdir && mount_bpffs_for_pin(linkdir)) { 513 p_err("can't mount bpffs for pinning"); 514 return -1; 515 } 516 517 if (verifier_logs) 518 /* log_level1 + log_level2 + stats, but not stable UAPI */ 519 open_opts.kernel_log_level = 1 + 2 + 4; 520 521 obj = bpf_object__open_file(file, &open_opts); 522 if (!obj) 523 return -1; 524 525 set_max_rlimit(); 526 527 if (bpf_object__load(obj)) { 528 bpf_object__close(obj); 529 return -1; 530 } 531 532 bpf_object__for_each_map(map, obj) { 533 if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS) 534 continue; 535 536 link = bpf_map__attach_struct_ops(map); 537 if (!link) { 538 p_err("can't register struct_ops %s: %s", 539 bpf_map__name(map), strerror(errno)); 540 nr_errs++; 541 continue; 542 } 543 nr_maps++; 544 545 if (bpf_map_get_info_by_fd(bpf_map__fd(map), &info, 546 &info_len)) { 547 /* Not p_err. The struct_ops was attached 548 * successfully. 549 */ 550 p_info("Registered %s but can't find id: %s", 551 bpf_map__name(map), strerror(errno)); 552 goto clean_link; 553 } 554 if (!(bpf_map__map_flags(map) & BPF_F_LINK)) { 555 p_info("Registered %s %s id %u", 556 get_kern_struct_ops_name(&info), 557 info.name, 558 info.id); 559 goto clean_link; 560 } 561 if (bpf_link_get_info_by_fd(bpf_link__fd(link), 562 &link_info, 563 &link_info_len)) { 564 p_err("Registered %s but can't find link id: %s", 565 bpf_map__name(map), strerror(errno)); 566 nr_errs++; 567 goto clean_link; 568 } 569 if (linkdir && pin_link(link, linkdir, info.name)) { 570 p_err("can't pin link %u for %s: %s", 571 link_info.id, info.name, 572 strerror(errno)); 573 nr_errs++; 574 goto clean_link; 575 } 576 p_info("Registered %s %s map id %u link id %u", 577 get_kern_struct_ops_name(&info), 578 info.name, info.id, link_info.id); 579 580 clean_link: 581 bpf_link__disconnect(link); 582 bpf_link__destroy(link); 583 } 584 585 bpf_object__close(obj); 586 587 if (nr_errs) 588 return -1; 589 590 if (!nr_maps) { 591 p_err("no struct_ops found in %s", file); 592 return -1; 593 } 594 595 if (json_output) 596 jsonw_null(json_wtr); 597 598 return 0; 599 } 600 601 static int do_help(int argc, char **argv) 602 { 603 if (json_output) { 604 jsonw_null(json_wtr); 605 return 0; 606 } 607 608 fprintf(stderr, 609 "Usage: %1$s %2$s { show | list } [STRUCT_OPS_MAP]\n" 610 " %1$s %2$s dump [STRUCT_OPS_MAP]\n" 611 " %1$s %2$s register OBJ [LINK_DIR]\n" 612 " %1$s %2$s unregister STRUCT_OPS_MAP\n" 613 " %1$s %2$s help\n" 614 "\n" 615 " STRUCT_OPS_MAP := [ id STRUCT_OPS_MAP_ID | name STRUCT_OPS_MAP_NAME ]\n" 616 " " HELP_SPEC_OPTIONS " }\n" 617 "", 618 bin_name, argv[-2]); 619 620 return 0; 621 } 622 623 static const struct cmd cmds[] = { 624 { "show", do_show }, 625 { "list", do_show }, 626 { "register", do_register }, 627 { "unregister", do_unregister }, 628 { "dump", do_dump }, 629 { "help", do_help }, 630 { 0 } 631 }; 632 633 int do_struct_ops(int argc, char **argv) 634 { 635 int err; 636 637 err = cmd_select(cmds, argc, argv, do_help); 638 639 btf__free(btf_vmlinux); 640 641 return err; 642 } 643