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 19static const struct btf_type *map_info_type; 20static __u32 map_info_alloc_len; 21static struct btf *btf_vmlinux; 22static __s32 map_info_type_id; 23 24struct res { 25 unsigned int nr_maps; 26 unsigned int nr_errs; 27}; 28 29static 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 41static 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 58static __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 */ 100static 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 */ 130static 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 170static 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 */ 179typedef 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 */ 186static 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 235static 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 (wtr) 280 jsonw_start_array(wtr); 281 282 if (func(fd, info, data, wtr)) 283 res.nr_errs++; 284 else if (!wtr && json_output) 285 /* The "func()" above is not writing any json (i.e. !wtr 286 * test here). 287 * 288 * However, "-j" is enabled and there is no errs here, 289 * so call json_null() as the current convention of 290 * other cmds. 291 */ 292 jsonw_null(json_wtr); 293 294 if (wtr) 295 jsonw_end_array(wtr); 296 297done: 298 free(info); 299 close(fd); 300 301 return res; 302} 303 304static struct res do_work_on_struct_ops(const char *search_type, 305 const char *search_term, 306 work_func func, void *data, 307 struct json_writer *wtr) 308{ 309 if (search_type) { 310 if (is_prefix(search_type, "id")) 311 return do_one_id(search_term, func, data, wtr); 312 else if (!is_prefix(search_type, "name")) 313 usage(); 314 } 315 316 return do_search(search_term, func, data, wtr); 317} 318 319static int __do_show(int fd, const struct bpf_map_info *info, void *data, 320 struct json_writer *wtr) 321{ 322 if (wtr) { 323 jsonw_start_object(wtr); 324 jsonw_uint_field(wtr, "id", info->id); 325 jsonw_string_field(wtr, "name", info->name); 326 jsonw_string_field(wtr, "kernel_struct_ops", 327 get_kern_struct_ops_name(info)); 328 jsonw_end_object(wtr); 329 } else { 330 printf("%u: %-15s %-32s\n", info->id, info->name, 331 get_kern_struct_ops_name(info)); 332 } 333 334 return 0; 335} 336 337static int do_show(int argc, char **argv) 338{ 339 const char *search_type = NULL, *search_term = NULL; 340 struct res res; 341 342 if (argc && argc != 2) 343 usage(); 344 345 if (argc == 2) { 346 search_type = GET_ARG(); 347 search_term = GET_ARG(); 348 } 349 350 res = do_work_on_struct_ops(search_type, search_term, __do_show, 351 NULL, json_wtr); 352 353 return cmd_retval(&res, !!search_term); 354} 355 356static int __do_dump(int fd, const struct bpf_map_info *info, void *data, 357 struct json_writer *wtr) 358{ 359 struct btf_dumper *d = (struct btf_dumper *)data; 360 const struct btf_type *struct_ops_type; 361 const struct btf *kern_btf = d->btf; 362 const char *struct_ops_name; 363 int zero = 0; 364 void *value; 365 366 /* note: d->jw == wtr */ 367 368 kern_btf = d->btf; 369 370 /* The kernel supporting BPF_MAP_TYPE_STRUCT_OPS must have 371 * btf_vmlinux_value_type_id. 372 */ 373 struct_ops_type = btf__type_by_id(kern_btf, 374 info->btf_vmlinux_value_type_id); 375 struct_ops_name = btf__name_by_offset(kern_btf, 376 struct_ops_type->name_off); 377 value = calloc(1, info->value_size); 378 if (!value) { 379 p_err("mem alloc failed"); 380 return -1; 381 } 382 383 if (bpf_map_lookup_elem(fd, &zero, value)) { 384 p_err("can't lookup struct_ops map %s id %u", 385 info->name, info->id); 386 free(value); 387 return -1; 388 } 389 390 jsonw_start_object(wtr); 391 jsonw_name(wtr, "bpf_map_info"); 392 btf_dumper_type(d, map_info_type_id, (void *)info); 393 jsonw_end_object(wtr); 394 395 jsonw_start_object(wtr); 396 jsonw_name(wtr, struct_ops_name); 397 btf_dumper_type(d, info->btf_vmlinux_value_type_id, value); 398 jsonw_end_object(wtr); 399 400 free(value); 401 402 return 0; 403} 404 405static int do_dump(int argc, char **argv) 406{ 407 const char *search_type = NULL, *search_term = NULL; 408 json_writer_t *wtr = json_wtr; 409 const struct btf *kern_btf; 410 struct btf_dumper d = {}; 411 struct res res; 412 413 if (argc && argc != 2) 414 usage(); 415 416 if (argc == 2) { 417 search_type = GET_ARG(); 418 search_term = GET_ARG(); 419 } 420 421 kern_btf = get_btf_vmlinux(); 422 if (!kern_btf) 423 return -1; 424 425 if (!json_output) { 426 wtr = jsonw_new(stdout); 427 if (!wtr) { 428 p_err("can't create json writer"); 429 return -1; 430 } 431 jsonw_pretty(wtr, true); 432 } 433 434 d.btf = kern_btf; 435 d.jw = wtr; 436 d.is_plain_text = !json_output; 437 d.prog_id_as_func_ptr = true; 438 439 res = do_work_on_struct_ops(search_type, search_term, __do_dump, &d, 440 wtr); 441 442 if (!json_output) 443 jsonw_destroy(&wtr); 444 445 return cmd_retval(&res, !!search_term); 446} 447 448static int __do_unregister(int fd, const struct bpf_map_info *info, void *data, 449 struct json_writer *wtr) 450{ 451 int zero = 0; 452 453 if (bpf_map_delete_elem(fd, &zero)) { 454 p_err("can't unload %s %s id %u: %s", 455 get_kern_struct_ops_name(info), info->name, 456 info->id, strerror(errno)); 457 return -1; 458 } 459 460 p_info("Unregistered %s %s id %u", 461 get_kern_struct_ops_name(info), info->name, 462 info->id); 463 464 return 0; 465} 466 467static int do_unregister(int argc, char **argv) 468{ 469 const char *search_type, *search_term; 470 struct res res; 471 472 if (argc != 2) 473 usage(); 474 475 search_type = GET_ARG(); 476 search_term = GET_ARG(); 477 478 res = do_work_on_struct_ops(search_type, search_term, 479 __do_unregister, NULL, NULL); 480 481 return cmd_retval(&res, true); 482} 483 484static int pin_link(struct bpf_link *link, const char *pindir, 485 const char *name) 486{ 487 char pinfile[PATH_MAX]; 488 int err; 489 490 err = pathname_concat(pinfile, sizeof(pinfile), pindir, name); 491 if (err) 492 return -1; 493 494 return bpf_link__pin(link, pinfile); 495} 496 497static int do_register(int argc, char **argv) 498{ 499 LIBBPF_OPTS(bpf_object_open_opts, open_opts); 500 __u32 link_info_len = sizeof(struct bpf_link_info); 501 struct bpf_link_info link_info = {}; 502 struct bpf_map_info info = {}; 503 __u32 info_len = sizeof(info); 504 int nr_errs = 0, nr_maps = 0; 505 const char *linkdir = NULL; 506 struct bpf_object *obj; 507 struct bpf_link *link; 508 struct bpf_map *map; 509 const char *file; 510 511 if (argc != 1 && argc != 2) 512 usage(); 513 514 file = GET_ARG(); 515 if (argc == 1) 516 linkdir = GET_ARG(); 517 518 if (linkdir && mount_bpffs_for_pin(linkdir, true)) { 519 p_err("can't mount bpffs for pinning"); 520 return -1; 521 } 522 523 if (verifier_logs) 524 /* log_level1 + log_level2 + stats, but not stable UAPI */ 525 open_opts.kernel_log_level = 1 + 2 + 4; 526 527 obj = bpf_object__open_file(file, &open_opts); 528 if (!obj) 529 return -1; 530 531 set_max_rlimit(); 532 533 if (bpf_object__load(obj)) { 534 bpf_object__close(obj); 535 return -1; 536 } 537 538 bpf_object__for_each_map(map, obj) { 539 if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS) 540 continue; 541 542 link = bpf_map__attach_struct_ops(map); 543 if (!link) { 544 p_err("can't register struct_ops %s: %s", 545 bpf_map__name(map), strerror(errno)); 546 nr_errs++; 547 continue; 548 } 549 nr_maps++; 550 551 if (bpf_map_get_info_by_fd(bpf_map__fd(map), &info, 552 &info_len)) { 553 /* Not p_err. The struct_ops was attached 554 * successfully. 555 */ 556 p_info("Registered %s but can't find id: %s", 557 bpf_map__name(map), strerror(errno)); 558 goto clean_link; 559 } 560 if (!(bpf_map__map_flags(map) & BPF_F_LINK)) { 561 p_info("Registered %s %s id %u", 562 get_kern_struct_ops_name(&info), 563 info.name, 564 info.id); 565 goto clean_link; 566 } 567 if (bpf_link_get_info_by_fd(bpf_link__fd(link), 568 &link_info, 569 &link_info_len)) { 570 p_err("Registered %s but can't find link id: %s", 571 bpf_map__name(map), strerror(errno)); 572 nr_errs++; 573 goto clean_link; 574 } 575 if (linkdir && pin_link(link, linkdir, info.name)) { 576 p_err("can't pin link %u for %s: %s", 577 link_info.id, info.name, 578 strerror(errno)); 579 nr_errs++; 580 goto clean_link; 581 } 582 p_info("Registered %s %s map id %u link id %u", 583 get_kern_struct_ops_name(&info), 584 info.name, info.id, link_info.id); 585 586clean_link: 587 bpf_link__disconnect(link); 588 bpf_link__destroy(link); 589 } 590 591 bpf_object__close(obj); 592 593 if (nr_errs) 594 return -1; 595 596 if (!nr_maps) { 597 p_err("no struct_ops found in %s", file); 598 return -1; 599 } 600 601 if (json_output) 602 jsonw_null(json_wtr); 603 604 return 0; 605} 606 607static int do_help(int argc, char **argv) 608{ 609 if (json_output) { 610 jsonw_null(json_wtr); 611 return 0; 612 } 613 614 fprintf(stderr, 615 "Usage: %1$s %2$s { show | list } [STRUCT_OPS_MAP]\n" 616 " %1$s %2$s dump [STRUCT_OPS_MAP]\n" 617 " %1$s %2$s register OBJ [LINK_DIR]\n" 618 " %1$s %2$s unregister STRUCT_OPS_MAP\n" 619 " %1$s %2$s help\n" 620 "\n" 621 " STRUCT_OPS_MAP := [ id STRUCT_OPS_MAP_ID | name STRUCT_OPS_MAP_NAME ]\n" 622 " " HELP_SPEC_OPTIONS " }\n" 623 "", 624 bin_name, argv[-2]); 625 626 return 0; 627} 628 629static const struct cmd cmds[] = { 630 { "show", do_show }, 631 { "list", do_show }, 632 { "register", do_register }, 633 { "unregister", do_unregister }, 634 { "dump", do_dump }, 635 { "help", do_help }, 636 { 0 } 637}; 638 639int do_struct_ops(int argc, char **argv) 640{ 641 int err; 642 643 err = cmd_select(cmds, argc, argv, do_help); 644 645 btf__free(btf_vmlinux); 646 647 return err; 648} 649