1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */ 3 4 #include <assert.h> 5 #include <errno.h> 6 #include <fcntl.h> 7 #include <linux/err.h> 8 #include <linux/kernel.h> 9 #include <net/if.h> 10 #include <stdbool.h> 11 #include <stdio.h> 12 #include <stdlib.h> 13 #include <string.h> 14 #include <unistd.h> 15 #include <sys/types.h> 16 #include <sys/stat.h> 17 18 #include <bpf/bpf.h> 19 #include <bpf/btf.h> 20 #include <bpf/hashmap.h> 21 22 #include "json_writer.h" 23 #include "main.h" 24 25 const char * const map_type_name[] = { 26 [BPF_MAP_TYPE_UNSPEC] = "unspec", 27 [BPF_MAP_TYPE_HASH] = "hash", 28 [BPF_MAP_TYPE_ARRAY] = "array", 29 [BPF_MAP_TYPE_PROG_ARRAY] = "prog_array", 30 [BPF_MAP_TYPE_PERF_EVENT_ARRAY] = "perf_event_array", 31 [BPF_MAP_TYPE_PERCPU_HASH] = "percpu_hash", 32 [BPF_MAP_TYPE_PERCPU_ARRAY] = "percpu_array", 33 [BPF_MAP_TYPE_STACK_TRACE] = "stack_trace", 34 [BPF_MAP_TYPE_CGROUP_ARRAY] = "cgroup_array", 35 [BPF_MAP_TYPE_LRU_HASH] = "lru_hash", 36 [BPF_MAP_TYPE_LRU_PERCPU_HASH] = "lru_percpu_hash", 37 [BPF_MAP_TYPE_LPM_TRIE] = "lpm_trie", 38 [BPF_MAP_TYPE_ARRAY_OF_MAPS] = "array_of_maps", 39 [BPF_MAP_TYPE_HASH_OF_MAPS] = "hash_of_maps", 40 [BPF_MAP_TYPE_DEVMAP] = "devmap", 41 [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash", 42 [BPF_MAP_TYPE_SOCKMAP] = "sockmap", 43 [BPF_MAP_TYPE_CPUMAP] = "cpumap", 44 [BPF_MAP_TYPE_XSKMAP] = "xskmap", 45 [BPF_MAP_TYPE_SOCKHASH] = "sockhash", 46 [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage", 47 [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY] = "reuseport_sockarray", 48 [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE] = "percpu_cgroup_storage", 49 [BPF_MAP_TYPE_QUEUE] = "queue", 50 [BPF_MAP_TYPE_STACK] = "stack", 51 [BPF_MAP_TYPE_SK_STORAGE] = "sk_storage", 52 [BPF_MAP_TYPE_STRUCT_OPS] = "struct_ops", 53 [BPF_MAP_TYPE_RINGBUF] = "ringbuf", 54 [BPF_MAP_TYPE_INODE_STORAGE] = "inode_storage", 55 [BPF_MAP_TYPE_TASK_STORAGE] = "task_storage", 56 [BPF_MAP_TYPE_BLOOM_FILTER] = "bloom_filter", 57 }; 58 59 const size_t map_type_name_size = ARRAY_SIZE(map_type_name); 60 61 static struct hashmap *map_table; 62 63 static bool map_is_per_cpu(__u32 type) 64 { 65 return type == BPF_MAP_TYPE_PERCPU_HASH || 66 type == BPF_MAP_TYPE_PERCPU_ARRAY || 67 type == BPF_MAP_TYPE_LRU_PERCPU_HASH || 68 type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE; 69 } 70 71 static bool map_is_map_of_maps(__u32 type) 72 { 73 return type == BPF_MAP_TYPE_ARRAY_OF_MAPS || 74 type == BPF_MAP_TYPE_HASH_OF_MAPS; 75 } 76 77 static bool map_is_map_of_progs(__u32 type) 78 { 79 return type == BPF_MAP_TYPE_PROG_ARRAY; 80 } 81 82 static int map_type_from_str(const char *type) 83 { 84 unsigned int i; 85 86 for (i = 0; i < ARRAY_SIZE(map_type_name); i++) 87 /* Don't allow prefixing in case of possible future shadowing */ 88 if (map_type_name[i] && !strcmp(map_type_name[i], type)) 89 return i; 90 return -1; 91 } 92 93 static void *alloc_value(struct bpf_map_info *info) 94 { 95 if (map_is_per_cpu(info->type)) 96 return malloc(round_up(info->value_size, 8) * 97 get_possible_cpus()); 98 else 99 return malloc(info->value_size); 100 } 101 102 static int do_dump_btf(const struct btf_dumper *d, 103 struct bpf_map_info *map_info, void *key, 104 void *value) 105 { 106 __u32 value_id; 107 int ret = 0; 108 109 /* start of key-value pair */ 110 jsonw_start_object(d->jw); 111 112 if (map_info->btf_key_type_id) { 113 jsonw_name(d->jw, "key"); 114 115 ret = btf_dumper_type(d, map_info->btf_key_type_id, key); 116 if (ret) 117 goto err_end_obj; 118 } 119 120 value_id = map_info->btf_vmlinux_value_type_id ? 121 : map_info->btf_value_type_id; 122 123 if (!map_is_per_cpu(map_info->type)) { 124 jsonw_name(d->jw, "value"); 125 ret = btf_dumper_type(d, value_id, value); 126 } else { 127 unsigned int i, n, step; 128 129 jsonw_name(d->jw, "values"); 130 jsonw_start_array(d->jw); 131 n = get_possible_cpus(); 132 step = round_up(map_info->value_size, 8); 133 for (i = 0; i < n; i++) { 134 jsonw_start_object(d->jw); 135 jsonw_int_field(d->jw, "cpu", i); 136 jsonw_name(d->jw, "value"); 137 ret = btf_dumper_type(d, value_id, value + i * step); 138 jsonw_end_object(d->jw); 139 if (ret) 140 break; 141 } 142 jsonw_end_array(d->jw); 143 } 144 145 err_end_obj: 146 /* end of key-value pair */ 147 jsonw_end_object(d->jw); 148 149 return ret; 150 } 151 152 static json_writer_t *get_btf_writer(void) 153 { 154 json_writer_t *jw = jsonw_new(stdout); 155 156 if (!jw) 157 return NULL; 158 jsonw_pretty(jw, true); 159 160 return jw; 161 } 162 163 static void print_entry_json(struct bpf_map_info *info, unsigned char *key, 164 unsigned char *value, struct btf *btf) 165 { 166 jsonw_start_object(json_wtr); 167 168 if (!map_is_per_cpu(info->type)) { 169 jsonw_name(json_wtr, "key"); 170 print_hex_data_json(key, info->key_size); 171 jsonw_name(json_wtr, "value"); 172 print_hex_data_json(value, info->value_size); 173 if (btf) { 174 struct btf_dumper d = { 175 .btf = btf, 176 .jw = json_wtr, 177 .is_plain_text = false, 178 }; 179 180 jsonw_name(json_wtr, "formatted"); 181 do_dump_btf(&d, info, key, value); 182 } 183 } else { 184 unsigned int i, n, step; 185 186 n = get_possible_cpus(); 187 step = round_up(info->value_size, 8); 188 189 jsonw_name(json_wtr, "key"); 190 print_hex_data_json(key, info->key_size); 191 192 jsonw_name(json_wtr, "values"); 193 jsonw_start_array(json_wtr); 194 for (i = 0; i < n; i++) { 195 jsonw_start_object(json_wtr); 196 197 jsonw_int_field(json_wtr, "cpu", i); 198 199 jsonw_name(json_wtr, "value"); 200 print_hex_data_json(value + i * step, 201 info->value_size); 202 203 jsonw_end_object(json_wtr); 204 } 205 jsonw_end_array(json_wtr); 206 if (btf) { 207 struct btf_dumper d = { 208 .btf = btf, 209 .jw = json_wtr, 210 .is_plain_text = false, 211 }; 212 213 jsonw_name(json_wtr, "formatted"); 214 do_dump_btf(&d, info, key, value); 215 } 216 } 217 218 jsonw_end_object(json_wtr); 219 } 220 221 static void 222 print_entry_error_msg(struct bpf_map_info *info, unsigned char *key, 223 const char *error_msg) 224 { 225 int msg_size = strlen(error_msg); 226 bool single_line, break_names; 227 228 break_names = info->key_size > 16 || msg_size > 16; 229 single_line = info->key_size + msg_size <= 24 && !break_names; 230 231 printf("key:%c", break_names ? '\n' : ' '); 232 fprint_hex(stdout, key, info->key_size, " "); 233 234 printf(single_line ? " " : "\n"); 235 236 printf("value:%c%s", break_names ? '\n' : ' ', error_msg); 237 238 printf("\n"); 239 } 240 241 static void 242 print_entry_error(struct bpf_map_info *map_info, void *key, int lookup_errno) 243 { 244 /* For prog_array maps or arrays of maps, failure to lookup the value 245 * means there is no entry for that key. Do not print an error message 246 * in that case. 247 */ 248 if ((map_is_map_of_maps(map_info->type) || 249 map_is_map_of_progs(map_info->type)) && lookup_errno == ENOENT) 250 return; 251 252 if (json_output) { 253 jsonw_start_object(json_wtr); /* entry */ 254 jsonw_name(json_wtr, "key"); 255 print_hex_data_json(key, map_info->key_size); 256 jsonw_name(json_wtr, "value"); 257 jsonw_start_object(json_wtr); /* error */ 258 jsonw_string_field(json_wtr, "error", strerror(lookup_errno)); 259 jsonw_end_object(json_wtr); /* error */ 260 jsonw_end_object(json_wtr); /* entry */ 261 } else { 262 const char *msg = NULL; 263 264 if (lookup_errno == ENOENT) 265 msg = "<no entry>"; 266 else if (lookup_errno == ENOSPC && 267 map_info->type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY) 268 msg = "<cannot read>"; 269 270 print_entry_error_msg(map_info, key, 271 msg ? : strerror(lookup_errno)); 272 } 273 } 274 275 static void print_entry_plain(struct bpf_map_info *info, unsigned char *key, 276 unsigned char *value) 277 { 278 if (!map_is_per_cpu(info->type)) { 279 bool single_line, break_names; 280 281 break_names = info->key_size > 16 || info->value_size > 16; 282 single_line = info->key_size + info->value_size <= 24 && 283 !break_names; 284 285 if (info->key_size) { 286 printf("key:%c", break_names ? '\n' : ' '); 287 fprint_hex(stdout, key, info->key_size, " "); 288 289 printf(single_line ? " " : "\n"); 290 } 291 292 if (info->value_size) { 293 printf("value:%c", break_names ? '\n' : ' '); 294 fprint_hex(stdout, value, info->value_size, " "); 295 } 296 297 printf("\n"); 298 } else { 299 unsigned int i, n, step; 300 301 n = get_possible_cpus(); 302 step = round_up(info->value_size, 8); 303 304 if (info->key_size) { 305 printf("key:\n"); 306 fprint_hex(stdout, key, info->key_size, " "); 307 printf("\n"); 308 } 309 if (info->value_size) { 310 for (i = 0; i < n; i++) { 311 printf("value (CPU %02d):%c", 312 i, info->value_size > 16 ? '\n' : ' '); 313 fprint_hex(stdout, value + i * step, 314 info->value_size, " "); 315 printf("\n"); 316 } 317 } 318 } 319 } 320 321 static char **parse_bytes(char **argv, const char *name, unsigned char *val, 322 unsigned int n) 323 { 324 unsigned int i = 0, base = 0; 325 char *endptr; 326 327 if (is_prefix(*argv, "hex")) { 328 base = 16; 329 argv++; 330 } 331 332 while (i < n && argv[i]) { 333 val[i] = strtoul(argv[i], &endptr, base); 334 if (*endptr) { 335 p_err("error parsing byte: %s", argv[i]); 336 return NULL; 337 } 338 i++; 339 } 340 341 if (i != n) { 342 p_err("%s expected %d bytes got %d", name, n, i); 343 return NULL; 344 } 345 346 return argv + i; 347 } 348 349 /* on per cpu maps we must copy the provided value on all value instances */ 350 static void fill_per_cpu_value(struct bpf_map_info *info, void *value) 351 { 352 unsigned int i, n, step; 353 354 if (!map_is_per_cpu(info->type)) 355 return; 356 357 n = get_possible_cpus(); 358 step = round_up(info->value_size, 8); 359 for (i = 1; i < n; i++) 360 memcpy(value + i * step, value, info->value_size); 361 } 362 363 static int parse_elem(char **argv, struct bpf_map_info *info, 364 void *key, void *value, __u32 key_size, __u32 value_size, 365 __u32 *flags, __u32 **value_fd) 366 { 367 if (!*argv) { 368 if (!key && !value) 369 return 0; 370 p_err("did not find %s", key ? "key" : "value"); 371 return -1; 372 } 373 374 if (is_prefix(*argv, "key")) { 375 if (!key) { 376 if (key_size) 377 p_err("duplicate key"); 378 else 379 p_err("unnecessary key"); 380 return -1; 381 } 382 383 argv = parse_bytes(argv + 1, "key", key, key_size); 384 if (!argv) 385 return -1; 386 387 return parse_elem(argv, info, NULL, value, key_size, value_size, 388 flags, value_fd); 389 } else if (is_prefix(*argv, "value")) { 390 int fd; 391 392 if (!value) { 393 if (value_size) 394 p_err("duplicate value"); 395 else 396 p_err("unnecessary value"); 397 return -1; 398 } 399 400 argv++; 401 402 if (map_is_map_of_maps(info->type)) { 403 int argc = 2; 404 405 if (value_size != 4) { 406 p_err("value smaller than 4B for map in map?"); 407 return -1; 408 } 409 if (!argv[0] || !argv[1]) { 410 p_err("not enough value arguments for map in map"); 411 return -1; 412 } 413 414 fd = map_parse_fd(&argc, &argv); 415 if (fd < 0) 416 return -1; 417 418 *value_fd = value; 419 **value_fd = fd; 420 } else if (map_is_map_of_progs(info->type)) { 421 int argc = 2; 422 423 if (value_size != 4) { 424 p_err("value smaller than 4B for map of progs?"); 425 return -1; 426 } 427 if (!argv[0] || !argv[1]) { 428 p_err("not enough value arguments for map of progs"); 429 return -1; 430 } 431 if (is_prefix(*argv, "id")) 432 p_info("Warning: updating program array via MAP_ID, make sure this map is kept open\n" 433 " by some process or pinned otherwise update will be lost"); 434 435 fd = prog_parse_fd(&argc, &argv); 436 if (fd < 0) 437 return -1; 438 439 *value_fd = value; 440 **value_fd = fd; 441 } else { 442 argv = parse_bytes(argv, "value", value, value_size); 443 if (!argv) 444 return -1; 445 446 fill_per_cpu_value(info, value); 447 } 448 449 return parse_elem(argv, info, key, NULL, key_size, value_size, 450 flags, NULL); 451 } else if (is_prefix(*argv, "any") || is_prefix(*argv, "noexist") || 452 is_prefix(*argv, "exist")) { 453 if (!flags) { 454 p_err("flags specified multiple times: %s", *argv); 455 return -1; 456 } 457 458 if (is_prefix(*argv, "any")) 459 *flags = BPF_ANY; 460 else if (is_prefix(*argv, "noexist")) 461 *flags = BPF_NOEXIST; 462 else if (is_prefix(*argv, "exist")) 463 *flags = BPF_EXIST; 464 465 return parse_elem(argv + 1, info, key, value, key_size, 466 value_size, NULL, value_fd); 467 } 468 469 p_err("expected key or value, got: %s", *argv); 470 return -1; 471 } 472 473 static void show_map_header_json(struct bpf_map_info *info, json_writer_t *wtr) 474 { 475 jsonw_uint_field(wtr, "id", info->id); 476 if (info->type < ARRAY_SIZE(map_type_name)) 477 jsonw_string_field(wtr, "type", map_type_name[info->type]); 478 else 479 jsonw_uint_field(wtr, "type", info->type); 480 481 if (*info->name) 482 jsonw_string_field(wtr, "name", info->name); 483 484 jsonw_name(wtr, "flags"); 485 jsonw_printf(wtr, "%d", info->map_flags); 486 } 487 488 static int show_map_close_json(int fd, struct bpf_map_info *info) 489 { 490 char *memlock, *frozen_str; 491 int frozen = 0; 492 493 memlock = get_fdinfo(fd, "memlock"); 494 frozen_str = get_fdinfo(fd, "frozen"); 495 496 jsonw_start_object(json_wtr); 497 498 show_map_header_json(info, json_wtr); 499 500 print_dev_json(info->ifindex, info->netns_dev, info->netns_ino); 501 502 jsonw_uint_field(json_wtr, "bytes_key", info->key_size); 503 jsonw_uint_field(json_wtr, "bytes_value", info->value_size); 504 jsonw_uint_field(json_wtr, "max_entries", info->max_entries); 505 506 if (memlock) 507 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock)); 508 free(memlock); 509 510 if (info->type == BPF_MAP_TYPE_PROG_ARRAY) { 511 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type"); 512 char *owner_jited = get_fdinfo(fd, "owner_jited"); 513 514 if (owner_prog_type) { 515 unsigned int prog_type = atoi(owner_prog_type); 516 517 if (prog_type < prog_type_name_size) 518 jsonw_string_field(json_wtr, "owner_prog_type", 519 prog_type_name[prog_type]); 520 else 521 jsonw_uint_field(json_wtr, "owner_prog_type", 522 prog_type); 523 } 524 if (owner_jited) 525 jsonw_bool_field(json_wtr, "owner_jited", 526 !!atoi(owner_jited)); 527 528 free(owner_prog_type); 529 free(owner_jited); 530 } 531 close(fd); 532 533 if (frozen_str) { 534 frozen = atoi(frozen_str); 535 free(frozen_str); 536 } 537 jsonw_int_field(json_wtr, "frozen", frozen); 538 539 if (info->btf_id) 540 jsonw_int_field(json_wtr, "btf_id", info->btf_id); 541 542 if (!hashmap__empty(map_table)) { 543 struct hashmap_entry *entry; 544 545 jsonw_name(json_wtr, "pinned"); 546 jsonw_start_array(json_wtr); 547 hashmap__for_each_key_entry(map_table, entry, 548 u32_as_hash_field(info->id)) 549 jsonw_string(json_wtr, entry->value); 550 jsonw_end_array(json_wtr); 551 } 552 553 emit_obj_refs_json(refs_table, info->id, json_wtr); 554 555 jsonw_end_object(json_wtr); 556 557 return 0; 558 } 559 560 static void show_map_header_plain(struct bpf_map_info *info) 561 { 562 printf("%u: ", info->id); 563 if (info->type < ARRAY_SIZE(map_type_name)) 564 printf("%s ", map_type_name[info->type]); 565 else 566 printf("type %u ", info->type); 567 568 if (*info->name) 569 printf("name %s ", info->name); 570 571 printf("flags 0x%x", info->map_flags); 572 print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino); 573 printf("\n"); 574 } 575 576 static int show_map_close_plain(int fd, struct bpf_map_info *info) 577 { 578 char *memlock, *frozen_str; 579 int frozen = 0; 580 581 memlock = get_fdinfo(fd, "memlock"); 582 frozen_str = get_fdinfo(fd, "frozen"); 583 584 show_map_header_plain(info); 585 printf("\tkey %uB value %uB max_entries %u", 586 info->key_size, info->value_size, info->max_entries); 587 588 if (memlock) 589 printf(" memlock %sB", memlock); 590 free(memlock); 591 592 if (info->type == BPF_MAP_TYPE_PROG_ARRAY) { 593 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type"); 594 char *owner_jited = get_fdinfo(fd, "owner_jited"); 595 596 if (owner_prog_type || owner_jited) 597 printf("\n\t"); 598 if (owner_prog_type) { 599 unsigned int prog_type = atoi(owner_prog_type); 600 601 if (prog_type < prog_type_name_size) 602 printf("owner_prog_type %s ", 603 prog_type_name[prog_type]); 604 else 605 printf("owner_prog_type %d ", prog_type); 606 } 607 if (owner_jited) 608 printf("owner%s jited", 609 atoi(owner_jited) ? "" : " not"); 610 611 free(owner_prog_type); 612 free(owner_jited); 613 } 614 close(fd); 615 616 if (!hashmap__empty(map_table)) { 617 struct hashmap_entry *entry; 618 619 hashmap__for_each_key_entry(map_table, entry, 620 u32_as_hash_field(info->id)) 621 printf("\n\tpinned %s", (char *)entry->value); 622 } 623 printf("\n"); 624 625 if (frozen_str) { 626 frozen = atoi(frozen_str); 627 free(frozen_str); 628 } 629 630 if (!info->btf_id && !frozen) 631 return 0; 632 633 printf("\t"); 634 635 if (info->btf_id) 636 printf("btf_id %d", info->btf_id); 637 638 if (frozen) 639 printf("%sfrozen", info->btf_id ? " " : ""); 640 641 emit_obj_refs_plain(refs_table, info->id, "\n\tpids "); 642 643 printf("\n"); 644 return 0; 645 } 646 647 static int do_show_subset(int argc, char **argv) 648 { 649 struct bpf_map_info info = {}; 650 __u32 len = sizeof(info); 651 int *fds = NULL; 652 int nb_fds, i; 653 int err = -1; 654 655 fds = malloc(sizeof(int)); 656 if (!fds) { 657 p_err("mem alloc failed"); 658 return -1; 659 } 660 nb_fds = map_parse_fds(&argc, &argv, &fds); 661 if (nb_fds < 1) 662 goto exit_free; 663 664 if (json_output && nb_fds > 1) 665 jsonw_start_array(json_wtr); /* root array */ 666 for (i = 0; i < nb_fds; i++) { 667 err = bpf_obj_get_info_by_fd(fds[i], &info, &len); 668 if (err) { 669 p_err("can't get map info: %s", 670 strerror(errno)); 671 for (; i < nb_fds; i++) 672 close(fds[i]); 673 break; 674 } 675 676 if (json_output) 677 show_map_close_json(fds[i], &info); 678 else 679 show_map_close_plain(fds[i], &info); 680 681 close(fds[i]); 682 } 683 if (json_output && nb_fds > 1) 684 jsonw_end_array(json_wtr); /* root array */ 685 686 exit_free: 687 free(fds); 688 return err; 689 } 690 691 static int do_show(int argc, char **argv) 692 { 693 struct bpf_map_info info = {}; 694 __u32 len = sizeof(info); 695 __u32 id = 0; 696 int err; 697 int fd; 698 699 if (show_pinned) { 700 map_table = hashmap__new(hash_fn_for_key_as_id, 701 equal_fn_for_key_as_id, NULL); 702 if (IS_ERR(map_table)) { 703 p_err("failed to create hashmap for pinned paths"); 704 return -1; 705 } 706 build_pinned_obj_table(map_table, BPF_OBJ_MAP); 707 } 708 build_obj_refs_table(&refs_table, BPF_OBJ_MAP); 709 710 if (argc == 2) 711 return do_show_subset(argc, argv); 712 713 if (argc) 714 return BAD_ARG(); 715 716 if (json_output) 717 jsonw_start_array(json_wtr); 718 while (true) { 719 err = bpf_map_get_next_id(id, &id); 720 if (err) { 721 if (errno == ENOENT) 722 break; 723 p_err("can't get next map: %s%s", strerror(errno), 724 errno == EINVAL ? " -- kernel too old?" : ""); 725 break; 726 } 727 728 fd = bpf_map_get_fd_by_id(id); 729 if (fd < 0) { 730 if (errno == ENOENT) 731 continue; 732 p_err("can't get map by id (%u): %s", 733 id, strerror(errno)); 734 break; 735 } 736 737 err = bpf_obj_get_info_by_fd(fd, &info, &len); 738 if (err) { 739 p_err("can't get map info: %s", strerror(errno)); 740 close(fd); 741 break; 742 } 743 744 if (json_output) 745 show_map_close_json(fd, &info); 746 else 747 show_map_close_plain(fd, &info); 748 } 749 if (json_output) 750 jsonw_end_array(json_wtr); 751 752 delete_obj_refs_table(refs_table); 753 754 if (show_pinned) 755 delete_pinned_obj_table(map_table); 756 757 return errno == ENOENT ? 0 : -1; 758 } 759 760 static int dump_map_elem(int fd, void *key, void *value, 761 struct bpf_map_info *map_info, struct btf *btf, 762 json_writer_t *btf_wtr) 763 { 764 if (bpf_map_lookup_elem(fd, key, value)) { 765 print_entry_error(map_info, key, errno); 766 return -1; 767 } 768 769 if (json_output) { 770 print_entry_json(map_info, key, value, btf); 771 } else if (btf) { 772 struct btf_dumper d = { 773 .btf = btf, 774 .jw = btf_wtr, 775 .is_plain_text = true, 776 }; 777 778 do_dump_btf(&d, map_info, key, value); 779 } else { 780 print_entry_plain(map_info, key, value); 781 } 782 783 return 0; 784 } 785 786 static int maps_have_btf(int *fds, int nb_fds) 787 { 788 struct bpf_map_info info = {}; 789 __u32 len = sizeof(info); 790 int err, i; 791 792 for (i = 0; i < nb_fds; i++) { 793 err = bpf_obj_get_info_by_fd(fds[i], &info, &len); 794 if (err) { 795 p_err("can't get map info: %s", strerror(errno)); 796 return -1; 797 } 798 799 if (!info.btf_id) 800 return 0; 801 } 802 803 return 1; 804 } 805 806 static struct btf *btf_vmlinux; 807 808 static struct btf *get_map_kv_btf(const struct bpf_map_info *info) 809 { 810 struct btf *btf = NULL; 811 812 if (info->btf_vmlinux_value_type_id) { 813 if (!btf_vmlinux) { 814 btf_vmlinux = libbpf_find_kernel_btf(); 815 if (libbpf_get_error(btf_vmlinux)) 816 p_err("failed to get kernel btf"); 817 } 818 return btf_vmlinux; 819 } else if (info->btf_value_type_id) { 820 int err; 821 822 btf = btf__load_from_kernel_by_id(info->btf_id); 823 err = libbpf_get_error(btf); 824 if (err) { 825 p_err("failed to get btf"); 826 btf = ERR_PTR(err); 827 } 828 } 829 830 return btf; 831 } 832 833 static void free_map_kv_btf(struct btf *btf) 834 { 835 if (!libbpf_get_error(btf) && btf != btf_vmlinux) 836 btf__free(btf); 837 } 838 839 static void free_btf_vmlinux(void) 840 { 841 if (!libbpf_get_error(btf_vmlinux)) 842 btf__free(btf_vmlinux); 843 } 844 845 static int 846 map_dump(int fd, struct bpf_map_info *info, json_writer_t *wtr, 847 bool show_header) 848 { 849 void *key, *value, *prev_key; 850 unsigned int num_elems = 0; 851 struct btf *btf = NULL; 852 int err; 853 854 key = malloc(info->key_size); 855 value = alloc_value(info); 856 if (!key || !value) { 857 p_err("mem alloc failed"); 858 err = -1; 859 goto exit_free; 860 } 861 862 prev_key = NULL; 863 864 if (wtr) { 865 btf = get_map_kv_btf(info); 866 err = libbpf_get_error(btf); 867 if (err) { 868 goto exit_free; 869 } 870 871 if (show_header) { 872 jsonw_start_object(wtr); /* map object */ 873 show_map_header_json(info, wtr); 874 jsonw_name(wtr, "elements"); 875 } 876 jsonw_start_array(wtr); /* elements */ 877 } else if (show_header) { 878 show_map_header_plain(info); 879 } 880 881 if (info->type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY && 882 info->value_size != 8) 883 p_info("Warning: cannot read values from %s map with value_size != 8", 884 map_type_name[info->type]); 885 while (true) { 886 err = bpf_map_get_next_key(fd, prev_key, key); 887 if (err) { 888 if (errno == ENOENT) 889 err = 0; 890 break; 891 } 892 if (!dump_map_elem(fd, key, value, info, btf, wtr)) 893 num_elems++; 894 prev_key = key; 895 } 896 897 if (wtr) { 898 jsonw_end_array(wtr); /* elements */ 899 if (show_header) 900 jsonw_end_object(wtr); /* map object */ 901 } else { 902 printf("Found %u element%s\n", num_elems, 903 num_elems != 1 ? "s" : ""); 904 } 905 906 exit_free: 907 free(key); 908 free(value); 909 close(fd); 910 free_map_kv_btf(btf); 911 912 return err; 913 } 914 915 static int do_dump(int argc, char **argv) 916 { 917 json_writer_t *wtr = NULL, *btf_wtr = NULL; 918 struct bpf_map_info info = {}; 919 int nb_fds, i = 0; 920 __u32 len = sizeof(info); 921 int *fds = NULL; 922 int err = -1; 923 924 if (argc != 2) 925 usage(); 926 927 fds = malloc(sizeof(int)); 928 if (!fds) { 929 p_err("mem alloc failed"); 930 return -1; 931 } 932 nb_fds = map_parse_fds(&argc, &argv, &fds); 933 if (nb_fds < 1) 934 goto exit_free; 935 936 if (json_output) { 937 wtr = json_wtr; 938 } else { 939 int do_plain_btf; 940 941 do_plain_btf = maps_have_btf(fds, nb_fds); 942 if (do_plain_btf < 0) 943 goto exit_close; 944 945 if (do_plain_btf) { 946 btf_wtr = get_btf_writer(); 947 wtr = btf_wtr; 948 if (!btf_wtr) 949 p_info("failed to create json writer for btf. falling back to plain output"); 950 } 951 } 952 953 if (wtr && nb_fds > 1) 954 jsonw_start_array(wtr); /* root array */ 955 for (i = 0; i < nb_fds; i++) { 956 if (bpf_obj_get_info_by_fd(fds[i], &info, &len)) { 957 p_err("can't get map info: %s", strerror(errno)); 958 break; 959 } 960 err = map_dump(fds[i], &info, wtr, nb_fds > 1); 961 if (!wtr && i != nb_fds - 1) 962 printf("\n"); 963 964 if (err) 965 break; 966 close(fds[i]); 967 } 968 if (wtr && nb_fds > 1) 969 jsonw_end_array(wtr); /* root array */ 970 971 if (btf_wtr) 972 jsonw_destroy(&btf_wtr); 973 exit_close: 974 for (; i < nb_fds; i++) 975 close(fds[i]); 976 exit_free: 977 free(fds); 978 free_btf_vmlinux(); 979 return err; 980 } 981 982 static int alloc_key_value(struct bpf_map_info *info, void **key, void **value) 983 { 984 *key = NULL; 985 *value = NULL; 986 987 if (info->key_size) { 988 *key = malloc(info->key_size); 989 if (!*key) { 990 p_err("key mem alloc failed"); 991 return -1; 992 } 993 } 994 995 if (info->value_size) { 996 *value = alloc_value(info); 997 if (!*value) { 998 p_err("value mem alloc failed"); 999 free(*key); 1000 *key = NULL; 1001 return -1; 1002 } 1003 } 1004 1005 return 0; 1006 } 1007 1008 static int do_update(int argc, char **argv) 1009 { 1010 struct bpf_map_info info = {}; 1011 __u32 len = sizeof(info); 1012 __u32 *value_fd = NULL; 1013 __u32 flags = BPF_ANY; 1014 void *key, *value; 1015 int fd, err; 1016 1017 if (argc < 2) 1018 usage(); 1019 1020 fd = map_parse_fd_and_info(&argc, &argv, &info, &len); 1021 if (fd < 0) 1022 return -1; 1023 1024 err = alloc_key_value(&info, &key, &value); 1025 if (err) 1026 goto exit_free; 1027 1028 err = parse_elem(argv, &info, key, value, info.key_size, 1029 info.value_size, &flags, &value_fd); 1030 if (err) 1031 goto exit_free; 1032 1033 err = bpf_map_update_elem(fd, key, value, flags); 1034 if (err) { 1035 p_err("update failed: %s", strerror(errno)); 1036 goto exit_free; 1037 } 1038 1039 exit_free: 1040 if (value_fd) 1041 close(*value_fd); 1042 free(key); 1043 free(value); 1044 close(fd); 1045 1046 if (!err && json_output) 1047 jsonw_null(json_wtr); 1048 return err; 1049 } 1050 1051 static void print_key_value(struct bpf_map_info *info, void *key, 1052 void *value) 1053 { 1054 json_writer_t *btf_wtr; 1055 struct btf *btf; 1056 1057 btf = get_map_kv_btf(info); 1058 if (libbpf_get_error(btf)) 1059 return; 1060 1061 if (json_output) { 1062 print_entry_json(info, key, value, btf); 1063 } else if (btf) { 1064 /* if here json_wtr wouldn't have been initialised, 1065 * so let's create separate writer for btf 1066 */ 1067 btf_wtr = get_btf_writer(); 1068 if (!btf_wtr) { 1069 p_info("failed to create json writer for btf. falling back to plain output"); 1070 btf__free(btf); 1071 btf = NULL; 1072 print_entry_plain(info, key, value); 1073 } else { 1074 struct btf_dumper d = { 1075 .btf = btf, 1076 .jw = btf_wtr, 1077 .is_plain_text = true, 1078 }; 1079 1080 do_dump_btf(&d, info, key, value); 1081 jsonw_destroy(&btf_wtr); 1082 } 1083 } else { 1084 print_entry_plain(info, key, value); 1085 } 1086 btf__free(btf); 1087 } 1088 1089 static int do_lookup(int argc, char **argv) 1090 { 1091 struct bpf_map_info info = {}; 1092 __u32 len = sizeof(info); 1093 void *key, *value; 1094 int err; 1095 int fd; 1096 1097 if (argc < 2) 1098 usage(); 1099 1100 fd = map_parse_fd_and_info(&argc, &argv, &info, &len); 1101 if (fd < 0) 1102 return -1; 1103 1104 err = alloc_key_value(&info, &key, &value); 1105 if (err) 1106 goto exit_free; 1107 1108 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL); 1109 if (err) 1110 goto exit_free; 1111 1112 err = bpf_map_lookup_elem(fd, key, value); 1113 if (err) { 1114 if (errno == ENOENT) { 1115 if (json_output) { 1116 jsonw_null(json_wtr); 1117 } else { 1118 printf("key:\n"); 1119 fprint_hex(stdout, key, info.key_size, " "); 1120 printf("\n\nNot found\n"); 1121 } 1122 } else { 1123 p_err("lookup failed: %s", strerror(errno)); 1124 } 1125 1126 goto exit_free; 1127 } 1128 1129 /* here means bpf_map_lookup_elem() succeeded */ 1130 print_key_value(&info, key, value); 1131 1132 exit_free: 1133 free(key); 1134 free(value); 1135 close(fd); 1136 1137 return err; 1138 } 1139 1140 static int do_getnext(int argc, char **argv) 1141 { 1142 struct bpf_map_info info = {}; 1143 __u32 len = sizeof(info); 1144 void *key, *nextkey; 1145 int err; 1146 int fd; 1147 1148 if (argc < 2) 1149 usage(); 1150 1151 fd = map_parse_fd_and_info(&argc, &argv, &info, &len); 1152 if (fd < 0) 1153 return -1; 1154 1155 key = malloc(info.key_size); 1156 nextkey = malloc(info.key_size); 1157 if (!key || !nextkey) { 1158 p_err("mem alloc failed"); 1159 err = -1; 1160 goto exit_free; 1161 } 1162 1163 if (argc) { 1164 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, 1165 NULL, NULL); 1166 if (err) 1167 goto exit_free; 1168 } else { 1169 free(key); 1170 key = NULL; 1171 } 1172 1173 err = bpf_map_get_next_key(fd, key, nextkey); 1174 if (err) { 1175 p_err("can't get next key: %s", strerror(errno)); 1176 goto exit_free; 1177 } 1178 1179 if (json_output) { 1180 jsonw_start_object(json_wtr); 1181 if (key) { 1182 jsonw_name(json_wtr, "key"); 1183 print_hex_data_json(key, info.key_size); 1184 } else { 1185 jsonw_null_field(json_wtr, "key"); 1186 } 1187 jsonw_name(json_wtr, "next_key"); 1188 print_hex_data_json(nextkey, info.key_size); 1189 jsonw_end_object(json_wtr); 1190 } else { 1191 if (key) { 1192 printf("key:\n"); 1193 fprint_hex(stdout, key, info.key_size, " "); 1194 printf("\n"); 1195 } else { 1196 printf("key: None\n"); 1197 } 1198 printf("next key:\n"); 1199 fprint_hex(stdout, nextkey, info.key_size, " "); 1200 printf("\n"); 1201 } 1202 1203 exit_free: 1204 free(nextkey); 1205 free(key); 1206 close(fd); 1207 1208 return err; 1209 } 1210 1211 static int do_delete(int argc, char **argv) 1212 { 1213 struct bpf_map_info info = {}; 1214 __u32 len = sizeof(info); 1215 void *key; 1216 int err; 1217 int fd; 1218 1219 if (argc < 2) 1220 usage(); 1221 1222 fd = map_parse_fd_and_info(&argc, &argv, &info, &len); 1223 if (fd < 0) 1224 return -1; 1225 1226 key = malloc(info.key_size); 1227 if (!key) { 1228 p_err("mem alloc failed"); 1229 err = -1; 1230 goto exit_free; 1231 } 1232 1233 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL); 1234 if (err) 1235 goto exit_free; 1236 1237 err = bpf_map_delete_elem(fd, key); 1238 if (err) 1239 p_err("delete failed: %s", strerror(errno)); 1240 1241 exit_free: 1242 free(key); 1243 close(fd); 1244 1245 if (!err && json_output) 1246 jsonw_null(json_wtr); 1247 return err; 1248 } 1249 1250 static int do_pin(int argc, char **argv) 1251 { 1252 int err; 1253 1254 err = do_pin_any(argc, argv, map_parse_fd); 1255 if (!err && json_output) 1256 jsonw_null(json_wtr); 1257 return err; 1258 } 1259 1260 static int do_create(int argc, char **argv) 1261 { 1262 LIBBPF_OPTS(bpf_map_create_opts, attr); 1263 enum bpf_map_type map_type = BPF_MAP_TYPE_UNSPEC; 1264 __u32 key_size = 0, value_size = 0, max_entries = 0; 1265 const char *map_name = NULL; 1266 const char *pinfile; 1267 int err = -1, fd; 1268 1269 if (!REQ_ARGS(7)) 1270 return -1; 1271 pinfile = GET_ARG(); 1272 1273 while (argc) { 1274 if (!REQ_ARGS(2)) 1275 return -1; 1276 1277 if (is_prefix(*argv, "type")) { 1278 NEXT_ARG(); 1279 1280 if (map_type) { 1281 p_err("map type already specified"); 1282 goto exit; 1283 } 1284 1285 map_type = map_type_from_str(*argv); 1286 if ((int)map_type < 0) { 1287 p_err("unrecognized map type: %s", *argv); 1288 goto exit; 1289 } 1290 NEXT_ARG(); 1291 } else if (is_prefix(*argv, "name")) { 1292 NEXT_ARG(); 1293 map_name = GET_ARG(); 1294 } else if (is_prefix(*argv, "key")) { 1295 if (parse_u32_arg(&argc, &argv, &key_size, 1296 "key size")) 1297 goto exit; 1298 } else if (is_prefix(*argv, "value")) { 1299 if (parse_u32_arg(&argc, &argv, &value_size, 1300 "value size")) 1301 goto exit; 1302 } else if (is_prefix(*argv, "entries")) { 1303 if (parse_u32_arg(&argc, &argv, &max_entries, 1304 "max entries")) 1305 goto exit; 1306 } else if (is_prefix(*argv, "flags")) { 1307 if (parse_u32_arg(&argc, &argv, &attr.map_flags, 1308 "flags")) 1309 goto exit; 1310 } else if (is_prefix(*argv, "dev")) { 1311 NEXT_ARG(); 1312 1313 if (attr.map_ifindex) { 1314 p_err("offload device already specified"); 1315 goto exit; 1316 } 1317 1318 attr.map_ifindex = if_nametoindex(*argv); 1319 if (!attr.map_ifindex) { 1320 p_err("unrecognized netdevice '%s': %s", 1321 *argv, strerror(errno)); 1322 goto exit; 1323 } 1324 NEXT_ARG(); 1325 } else if (is_prefix(*argv, "inner_map")) { 1326 struct bpf_map_info info = {}; 1327 __u32 len = sizeof(info); 1328 int inner_map_fd; 1329 1330 NEXT_ARG(); 1331 if (!REQ_ARGS(2)) 1332 usage(); 1333 inner_map_fd = map_parse_fd_and_info(&argc, &argv, 1334 &info, &len); 1335 if (inner_map_fd < 0) 1336 return -1; 1337 attr.inner_map_fd = inner_map_fd; 1338 } else { 1339 p_err("unknown arg %s", *argv); 1340 goto exit; 1341 } 1342 } 1343 1344 if (!map_name) { 1345 p_err("map name not specified"); 1346 goto exit; 1347 } 1348 1349 set_max_rlimit(); 1350 1351 fd = bpf_map_create(map_type, map_name, key_size, value_size, max_entries, &attr); 1352 if (fd < 0) { 1353 p_err("map create failed: %s", strerror(errno)); 1354 goto exit; 1355 } 1356 1357 err = do_pin_fd(fd, pinfile); 1358 close(fd); 1359 if (err) 1360 goto exit; 1361 1362 if (json_output) 1363 jsonw_null(json_wtr); 1364 1365 exit: 1366 if (attr.inner_map_fd > 0) 1367 close(attr.inner_map_fd); 1368 1369 return err; 1370 } 1371 1372 static int do_pop_dequeue(int argc, char **argv) 1373 { 1374 struct bpf_map_info info = {}; 1375 __u32 len = sizeof(info); 1376 void *key, *value; 1377 int err; 1378 int fd; 1379 1380 if (argc < 2) 1381 usage(); 1382 1383 fd = map_parse_fd_and_info(&argc, &argv, &info, &len); 1384 if (fd < 0) 1385 return -1; 1386 1387 err = alloc_key_value(&info, &key, &value); 1388 if (err) 1389 goto exit_free; 1390 1391 err = bpf_map_lookup_and_delete_elem(fd, key, value); 1392 if (err) { 1393 if (errno == ENOENT) { 1394 if (json_output) 1395 jsonw_null(json_wtr); 1396 else 1397 printf("Error: empty map\n"); 1398 } else { 1399 p_err("pop failed: %s", strerror(errno)); 1400 } 1401 1402 goto exit_free; 1403 } 1404 1405 print_key_value(&info, key, value); 1406 1407 exit_free: 1408 free(key); 1409 free(value); 1410 close(fd); 1411 1412 return err; 1413 } 1414 1415 static int do_freeze(int argc, char **argv) 1416 { 1417 int err, fd; 1418 1419 if (!REQ_ARGS(2)) 1420 return -1; 1421 1422 fd = map_parse_fd(&argc, &argv); 1423 if (fd < 0) 1424 return -1; 1425 1426 if (argc) { 1427 close(fd); 1428 return BAD_ARG(); 1429 } 1430 1431 err = bpf_map_freeze(fd); 1432 close(fd); 1433 if (err) { 1434 p_err("failed to freeze map: %s", strerror(errno)); 1435 return err; 1436 } 1437 1438 if (json_output) 1439 jsonw_null(json_wtr); 1440 1441 return 0; 1442 } 1443 1444 static int do_help(int argc, char **argv) 1445 { 1446 if (json_output) { 1447 jsonw_null(json_wtr); 1448 return 0; 1449 } 1450 1451 fprintf(stderr, 1452 "Usage: %1$s %2$s { show | list } [MAP]\n" 1453 " %1$s %2$s create FILE type TYPE key KEY_SIZE value VALUE_SIZE \\\n" 1454 " entries MAX_ENTRIES name NAME [flags FLAGS] \\\n" 1455 " [inner_map MAP] [dev NAME]\n" 1456 " %1$s %2$s dump MAP\n" 1457 " %1$s %2$s update MAP [key DATA] [value VALUE] [UPDATE_FLAGS]\n" 1458 " %1$s %2$s lookup MAP [key DATA]\n" 1459 " %1$s %2$s getnext MAP [key DATA]\n" 1460 " %1$s %2$s delete MAP key DATA\n" 1461 " %1$s %2$s pin MAP FILE\n" 1462 " %1$s %2$s event_pipe MAP [cpu N index M]\n" 1463 " %1$s %2$s peek MAP\n" 1464 " %1$s %2$s push MAP value VALUE\n" 1465 " %1$s %2$s pop MAP\n" 1466 " %1$s %2$s enqueue MAP value VALUE\n" 1467 " %1$s %2$s dequeue MAP\n" 1468 " %1$s %2$s freeze MAP\n" 1469 " %1$s %2$s help\n" 1470 "\n" 1471 " " HELP_SPEC_MAP "\n" 1472 " DATA := { [hex] BYTES }\n" 1473 " " HELP_SPEC_PROGRAM "\n" 1474 " VALUE := { DATA | MAP | PROG }\n" 1475 " UPDATE_FLAGS := { any | exist | noexist }\n" 1476 " TYPE := { hash | array | prog_array | perf_event_array | percpu_hash |\n" 1477 " percpu_array | stack_trace | cgroup_array | lru_hash |\n" 1478 " lru_percpu_hash | lpm_trie | array_of_maps | hash_of_maps |\n" 1479 " devmap | devmap_hash | sockmap | cpumap | xskmap | sockhash |\n" 1480 " cgroup_storage | reuseport_sockarray | percpu_cgroup_storage |\n" 1481 " queue | stack | sk_storage | struct_ops | ringbuf | inode_storage |\n" 1482 " task_storage | bloom_filter }\n" 1483 " " HELP_SPEC_OPTIONS " |\n" 1484 " {-f|--bpffs} | {-n|--nomount} }\n" 1485 "", 1486 bin_name, argv[-2]); 1487 1488 return 0; 1489 } 1490 1491 static const struct cmd cmds[] = { 1492 { "show", do_show }, 1493 { "list", do_show }, 1494 { "help", do_help }, 1495 { "dump", do_dump }, 1496 { "update", do_update }, 1497 { "lookup", do_lookup }, 1498 { "getnext", do_getnext }, 1499 { "delete", do_delete }, 1500 { "pin", do_pin }, 1501 { "event_pipe", do_event_pipe }, 1502 { "create", do_create }, 1503 { "peek", do_lookup }, 1504 { "push", do_update }, 1505 { "enqueue", do_update }, 1506 { "pop", do_pop_dequeue }, 1507 { "dequeue", do_pop_dequeue }, 1508 { "freeze", do_freeze }, 1509 { 0 } 1510 }; 1511 1512 int do_map(int argc, char **argv) 1513 { 1514 return cmd_select(cmds, argc, argv, do_help); 1515 } 1516