1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
8 #include <linux/kernel.h>
15 #include <sys/types.h>
21 #include "json_writer.h"
24 const char * const map_type_name[] = {
25 [BPF_MAP_TYPE_UNSPEC] = "unspec",
26 [BPF_MAP_TYPE_HASH] = "hash",
27 [BPF_MAP_TYPE_ARRAY] = "array",
28 [BPF_MAP_TYPE_PROG_ARRAY] = "prog_array",
29 [BPF_MAP_TYPE_PERF_EVENT_ARRAY] = "perf_event_array",
30 [BPF_MAP_TYPE_PERCPU_HASH] = "percpu_hash",
31 [BPF_MAP_TYPE_PERCPU_ARRAY] = "percpu_array",
32 [BPF_MAP_TYPE_STACK_TRACE] = "stack_trace",
33 [BPF_MAP_TYPE_CGROUP_ARRAY] = "cgroup_array",
34 [BPF_MAP_TYPE_LRU_HASH] = "lru_hash",
35 [BPF_MAP_TYPE_LRU_PERCPU_HASH] = "lru_percpu_hash",
36 [BPF_MAP_TYPE_LPM_TRIE] = "lpm_trie",
37 [BPF_MAP_TYPE_ARRAY_OF_MAPS] = "array_of_maps",
38 [BPF_MAP_TYPE_HASH_OF_MAPS] = "hash_of_maps",
39 [BPF_MAP_TYPE_DEVMAP] = "devmap",
40 [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash",
41 [BPF_MAP_TYPE_SOCKMAP] = "sockmap",
42 [BPF_MAP_TYPE_CPUMAP] = "cpumap",
43 [BPF_MAP_TYPE_XSKMAP] = "xskmap",
44 [BPF_MAP_TYPE_SOCKHASH] = "sockhash",
45 [BPF_MAP_TYPE_CGROUP_STORAGE] = "cgroup_storage",
46 [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY] = "reuseport_sockarray",
47 [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE] = "percpu_cgroup_storage",
48 [BPF_MAP_TYPE_QUEUE] = "queue",
49 [BPF_MAP_TYPE_STACK] = "stack",
50 [BPF_MAP_TYPE_SK_STORAGE] = "sk_storage",
51 [BPF_MAP_TYPE_STRUCT_OPS] = "struct_ops",
52 [BPF_MAP_TYPE_RINGBUF] = "ringbuf",
55 const size_t map_type_name_size = ARRAY_SIZE(map_type_name);
57 static bool map_is_per_cpu(__u32 type)
59 return type == BPF_MAP_TYPE_PERCPU_HASH ||
60 type == BPF_MAP_TYPE_PERCPU_ARRAY ||
61 type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
62 type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE;
65 static bool map_is_map_of_maps(__u32 type)
67 return type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
68 type == BPF_MAP_TYPE_HASH_OF_MAPS;
71 static bool map_is_map_of_progs(__u32 type)
73 return type == BPF_MAP_TYPE_PROG_ARRAY;
76 static int map_type_from_str(const char *type)
80 for (i = 0; i < ARRAY_SIZE(map_type_name); i++)
81 /* Don't allow prefixing in case of possible future shadowing */
82 if (map_type_name[i] && !strcmp(map_type_name[i], type))
87 static void *alloc_value(struct bpf_map_info *info)
89 if (map_is_per_cpu(info->type))
90 return malloc(round_up(info->value_size, 8) *
93 return malloc(info->value_size);
96 static int map_fd_by_name(char *name, int **fds)
104 struct bpf_map_info info = {};
105 __u32 len = sizeof(info);
107 err = bpf_map_get_next_id(id, &id);
109 if (errno != ENOENT) {
110 p_err("%s", strerror(errno));
116 fd = bpf_map_get_fd_by_id(id);
118 p_err("can't get map by id (%u): %s",
119 id, strerror(errno));
123 err = bpf_obj_get_info_by_fd(fd, &info, &len);
125 p_err("can't get map info (%u): %s",
126 id, strerror(errno));
130 if (strncmp(name, info.name, BPF_OBJ_NAME_LEN)) {
136 tmp = realloc(*fds, (nb_fds + 1) * sizeof(int));
138 p_err("failed to realloc");
143 (*fds)[nb_fds++] = fd;
149 while (--nb_fds >= 0)
150 close((*fds)[nb_fds]);
154 static int map_parse_fds(int *argc, char ***argv, int **fds)
156 if (is_prefix(**argv, "id")) {
162 id = strtoul(**argv, &endptr, 0);
164 p_err("can't parse %s as ID", **argv);
169 (*fds)[0] = bpf_map_get_fd_by_id(id);
171 p_err("get map by id (%u): %s", id, strerror(errno));
175 } else if (is_prefix(**argv, "name")) {
181 if (strlen(name) > BPF_OBJ_NAME_LEN - 1) {
182 p_err("can't parse name");
187 return map_fd_by_name(name, fds);
188 } else if (is_prefix(**argv, "pinned")) {
196 (*fds)[0] = open_obj_pinned_any(path, BPF_OBJ_MAP);
202 p_err("expected 'id', 'name' or 'pinned', got: '%s'?", **argv);
206 int map_parse_fd(int *argc, char ***argv)
211 fds = malloc(sizeof(int));
213 p_err("mem alloc failed");
216 nb_fds = map_parse_fds(argc, argv, &fds);
219 p_err("several maps match this handle");
233 int map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len)
238 fd = map_parse_fd(argc, argv);
242 err = bpf_obj_get_info_by_fd(fd, info, info_len);
244 p_err("can't get map info: %s", strerror(errno));
252 static int do_dump_btf(const struct btf_dumper *d,
253 struct bpf_map_info *map_info, void *key,
259 /* start of key-value pair */
260 jsonw_start_object(d->jw);
262 if (map_info->btf_key_type_id) {
263 jsonw_name(d->jw, "key");
265 ret = btf_dumper_type(d, map_info->btf_key_type_id, key);
270 value_id = map_info->btf_vmlinux_value_type_id ?
271 : map_info->btf_value_type_id;
273 if (!map_is_per_cpu(map_info->type)) {
274 jsonw_name(d->jw, "value");
275 ret = btf_dumper_type(d, value_id, value);
277 unsigned int i, n, step;
279 jsonw_name(d->jw, "values");
280 jsonw_start_array(d->jw);
281 n = get_possible_cpus();
282 step = round_up(map_info->value_size, 8);
283 for (i = 0; i < n; i++) {
284 jsonw_start_object(d->jw);
285 jsonw_int_field(d->jw, "cpu", i);
286 jsonw_name(d->jw, "value");
287 ret = btf_dumper_type(d, value_id, value + i * step);
288 jsonw_end_object(d->jw);
292 jsonw_end_array(d->jw);
296 /* end of key-value pair */
297 jsonw_end_object(d->jw);
302 static json_writer_t *get_btf_writer(void)
304 json_writer_t *jw = jsonw_new(stdout);
308 jsonw_pretty(jw, true);
313 static void print_entry_json(struct bpf_map_info *info, unsigned char *key,
314 unsigned char *value, struct btf *btf)
316 jsonw_start_object(json_wtr);
318 if (!map_is_per_cpu(info->type)) {
319 jsonw_name(json_wtr, "key");
320 print_hex_data_json(key, info->key_size);
321 jsonw_name(json_wtr, "value");
322 print_hex_data_json(value, info->value_size);
324 struct btf_dumper d = {
327 .is_plain_text = false,
330 jsonw_name(json_wtr, "formatted");
331 do_dump_btf(&d, info, key, value);
334 unsigned int i, n, step;
336 n = get_possible_cpus();
337 step = round_up(info->value_size, 8);
339 jsonw_name(json_wtr, "key");
340 print_hex_data_json(key, info->key_size);
342 jsonw_name(json_wtr, "values");
343 jsonw_start_array(json_wtr);
344 for (i = 0; i < n; i++) {
345 jsonw_start_object(json_wtr);
347 jsonw_int_field(json_wtr, "cpu", i);
349 jsonw_name(json_wtr, "value");
350 print_hex_data_json(value + i * step,
353 jsonw_end_object(json_wtr);
355 jsonw_end_array(json_wtr);
357 struct btf_dumper d = {
360 .is_plain_text = false,
363 jsonw_name(json_wtr, "formatted");
364 do_dump_btf(&d, info, key, value);
368 jsonw_end_object(json_wtr);
371 static void print_entry_error(struct bpf_map_info *info, unsigned char *key,
372 const char *error_msg)
374 int msg_size = strlen(error_msg);
375 bool single_line, break_names;
377 break_names = info->key_size > 16 || msg_size > 16;
378 single_line = info->key_size + msg_size <= 24 && !break_names;
380 printf("key:%c", break_names ? '\n' : ' ');
381 fprint_hex(stdout, key, info->key_size, " ");
383 printf(single_line ? " " : "\n");
385 printf("value:%c%s", break_names ? '\n' : ' ', error_msg);
390 static void print_entry_plain(struct bpf_map_info *info, unsigned char *key,
391 unsigned char *value)
393 if (!map_is_per_cpu(info->type)) {
394 bool single_line, break_names;
396 break_names = info->key_size > 16 || info->value_size > 16;
397 single_line = info->key_size + info->value_size <= 24 &&
400 if (info->key_size) {
401 printf("key:%c", break_names ? '\n' : ' ');
402 fprint_hex(stdout, key, info->key_size, " ");
404 printf(single_line ? " " : "\n");
407 if (info->value_size) {
408 printf("value:%c", break_names ? '\n' : ' ');
409 fprint_hex(stdout, value, info->value_size, " ");
414 unsigned int i, n, step;
416 n = get_possible_cpus();
417 step = round_up(info->value_size, 8);
419 if (info->key_size) {
421 fprint_hex(stdout, key, info->key_size, " ");
424 if (info->value_size) {
425 for (i = 0; i < n; i++) {
426 printf("value (CPU %02d):%c",
427 i, info->value_size > 16 ? '\n' : ' ');
428 fprint_hex(stdout, value + i * step,
429 info->value_size, " ");
436 static char **parse_bytes(char **argv, const char *name, unsigned char *val,
439 unsigned int i = 0, base = 0;
442 if (is_prefix(*argv, "hex")) {
447 while (i < n && argv[i]) {
448 val[i] = strtoul(argv[i], &endptr, base);
450 p_err("error parsing byte: %s", argv[i]);
457 p_err("%s expected %d bytes got %d", name, n, i);
464 /* on per cpu maps we must copy the provided value on all value instances */
465 static void fill_per_cpu_value(struct bpf_map_info *info, void *value)
467 unsigned int i, n, step;
469 if (!map_is_per_cpu(info->type))
472 n = get_possible_cpus();
473 step = round_up(info->value_size, 8);
474 for (i = 1; i < n; i++)
475 memcpy(value + i * step, value, info->value_size);
478 static int parse_elem(char **argv, struct bpf_map_info *info,
479 void *key, void *value, __u32 key_size, __u32 value_size,
480 __u32 *flags, __u32 **value_fd)
485 p_err("did not find %s", key ? "key" : "value");
489 if (is_prefix(*argv, "key")) {
492 p_err("duplicate key");
494 p_err("unnecessary key");
498 argv = parse_bytes(argv + 1, "key", key, key_size);
502 return parse_elem(argv, info, NULL, value, key_size, value_size,
504 } else if (is_prefix(*argv, "value")) {
509 p_err("duplicate value");
511 p_err("unnecessary value");
517 if (map_is_map_of_maps(info->type)) {
520 if (value_size != 4) {
521 p_err("value smaller than 4B for map in map?");
524 if (!argv[0] || !argv[1]) {
525 p_err("not enough value arguments for map in map");
529 fd = map_parse_fd(&argc, &argv);
535 } else if (map_is_map_of_progs(info->type)) {
538 if (value_size != 4) {
539 p_err("value smaller than 4B for map of progs?");
542 if (!argv[0] || !argv[1]) {
543 p_err("not enough value arguments for map of progs");
546 if (is_prefix(*argv, "id"))
547 p_info("Warning: updating program array via MAP_ID, make sure this map is kept open\n"
548 " by some process or pinned otherwise update will be lost");
550 fd = prog_parse_fd(&argc, &argv);
557 argv = parse_bytes(argv, "value", value, value_size);
561 fill_per_cpu_value(info, value);
564 return parse_elem(argv, info, key, NULL, key_size, value_size,
566 } else if (is_prefix(*argv, "any") || is_prefix(*argv, "noexist") ||
567 is_prefix(*argv, "exist")) {
569 p_err("flags specified multiple times: %s", *argv);
573 if (is_prefix(*argv, "any"))
575 else if (is_prefix(*argv, "noexist"))
576 *flags = BPF_NOEXIST;
577 else if (is_prefix(*argv, "exist"))
580 return parse_elem(argv + 1, info, key, value, key_size,
581 value_size, NULL, value_fd);
584 p_err("expected key or value, got: %s", *argv);
588 static void show_map_header_json(struct bpf_map_info *info, json_writer_t *wtr)
590 jsonw_uint_field(wtr, "id", info->id);
591 if (info->type < ARRAY_SIZE(map_type_name))
592 jsonw_string_field(wtr, "type", map_type_name[info->type]);
594 jsonw_uint_field(wtr, "type", info->type);
597 jsonw_string_field(wtr, "name", info->name);
599 jsonw_name(wtr, "flags");
600 jsonw_printf(wtr, "%d", info->map_flags);
603 static int show_map_close_json(int fd, struct bpf_map_info *info)
605 char *memlock, *frozen_str;
608 memlock = get_fdinfo(fd, "memlock");
609 frozen_str = get_fdinfo(fd, "frozen");
611 jsonw_start_object(json_wtr);
613 show_map_header_json(info, json_wtr);
615 print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
617 jsonw_uint_field(json_wtr, "bytes_key", info->key_size);
618 jsonw_uint_field(json_wtr, "bytes_value", info->value_size);
619 jsonw_uint_field(json_wtr, "max_entries", info->max_entries);
622 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
625 if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
626 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
627 char *owner_jited = get_fdinfo(fd, "owner_jited");
629 if (owner_prog_type) {
630 unsigned int prog_type = atoi(owner_prog_type);
632 if (prog_type < ARRAY_SIZE(prog_type_name))
633 jsonw_string_field(json_wtr, "owner_prog_type",
634 prog_type_name[prog_type]);
636 jsonw_uint_field(json_wtr, "owner_prog_type",
640 jsonw_bool_field(json_wtr, "owner_jited",
641 !!atoi(owner_jited));
643 free(owner_prog_type);
649 frozen = atoi(frozen_str);
652 jsonw_int_field(json_wtr, "frozen", frozen);
655 jsonw_int_field(json_wtr, "btf_id", info->btf_id);
657 if (!hash_empty(map_table.table)) {
658 struct pinned_obj *obj;
660 jsonw_name(json_wtr, "pinned");
661 jsonw_start_array(json_wtr);
662 hash_for_each_possible(map_table.table, obj, hash, info->id) {
663 if (obj->id == info->id)
664 jsonw_string(json_wtr, obj->path);
666 jsonw_end_array(json_wtr);
669 jsonw_end_object(json_wtr);
674 static void show_map_header_plain(struct bpf_map_info *info)
676 printf("%u: ", info->id);
677 if (info->type < ARRAY_SIZE(map_type_name))
678 printf("%s ", map_type_name[info->type]);
680 printf("type %u ", info->type);
683 printf("name %s ", info->name);
685 printf("flags 0x%x", info->map_flags);
686 print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
690 static int show_map_close_plain(int fd, struct bpf_map_info *info)
692 char *memlock, *frozen_str;
695 memlock = get_fdinfo(fd, "memlock");
696 frozen_str = get_fdinfo(fd, "frozen");
698 show_map_header_plain(info);
699 printf("\tkey %uB value %uB max_entries %u",
700 info->key_size, info->value_size, info->max_entries);
703 printf(" memlock %sB", memlock);
706 if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
707 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
708 char *owner_jited = get_fdinfo(fd, "owner_jited");
710 if (owner_prog_type || owner_jited)
712 if (owner_prog_type) {
713 unsigned int prog_type = atoi(owner_prog_type);
715 if (prog_type < ARRAY_SIZE(prog_type_name))
716 printf("owner_prog_type %s ",
717 prog_type_name[prog_type]);
719 printf("owner_prog_type %d ", prog_type);
722 printf("owner%s jited",
723 atoi(owner_jited) ? "" : " not");
725 free(owner_prog_type);
730 if (!hash_empty(map_table.table)) {
731 struct pinned_obj *obj;
733 hash_for_each_possible(map_table.table, obj, hash, info->id) {
734 if (obj->id == info->id)
735 printf("\n\tpinned %s", obj->path);
741 frozen = atoi(frozen_str);
745 if (!info->btf_id && !frozen)
751 printf("btf_id %d", info->btf_id);
754 printf("%sfrozen", info->btf_id ? " " : "");
760 static int do_show_subset(int argc, char **argv)
762 struct bpf_map_info info = {};
763 __u32 len = sizeof(info);
768 fds = malloc(sizeof(int));
770 p_err("mem alloc failed");
773 nb_fds = map_parse_fds(&argc, &argv, &fds);
777 if (json_output && nb_fds > 1)
778 jsonw_start_array(json_wtr); /* root array */
779 for (i = 0; i < nb_fds; i++) {
780 err = bpf_obj_get_info_by_fd(fds[i], &info, &len);
782 p_err("can't get map info: %s",
784 for (; i < nb_fds; i++)
790 show_map_close_json(fds[i], &info);
792 show_map_close_plain(fds[i], &info);
796 if (json_output && nb_fds > 1)
797 jsonw_end_array(json_wtr); /* root array */
804 static int do_show(int argc, char **argv)
806 struct bpf_map_info info = {};
807 __u32 len = sizeof(info);
813 build_pinned_obj_table(&map_table, BPF_OBJ_MAP);
816 return do_show_subset(argc, argv);
822 jsonw_start_array(json_wtr);
824 err = bpf_map_get_next_id(id, &id);
828 p_err("can't get next map: %s%s", strerror(errno),
829 errno == EINVAL ? " -- kernel too old?" : "");
833 fd = bpf_map_get_fd_by_id(id);
837 p_err("can't get map by id (%u): %s",
838 id, strerror(errno));
842 err = bpf_obj_get_info_by_fd(fd, &info, &len);
844 p_err("can't get map info: %s", strerror(errno));
850 show_map_close_json(fd, &info);
852 show_map_close_plain(fd, &info);
855 jsonw_end_array(json_wtr);
857 return errno == ENOENT ? 0 : -1;
860 static int dump_map_elem(int fd, void *key, void *value,
861 struct bpf_map_info *map_info, struct btf *btf,
862 json_writer_t *btf_wtr)
867 if (!bpf_map_lookup_elem(fd, key, value)) {
869 print_entry_json(map_info, key, value, btf);
872 struct btf_dumper d = {
875 .is_plain_text = true,
878 do_dump_btf(&d, map_info, key, value);
880 print_entry_plain(map_info, key, value);
887 /* lookup error handling */
888 lookup_errno = errno;
890 if (map_is_map_of_maps(map_info->type) ||
891 map_is_map_of_progs(map_info->type))
895 jsonw_start_object(json_wtr);
896 jsonw_name(json_wtr, "key");
897 print_hex_data_json(key, map_info->key_size);
898 jsonw_name(json_wtr, "value");
899 jsonw_start_object(json_wtr);
900 jsonw_string_field(json_wtr, "error", strerror(lookup_errno));
901 jsonw_end_object(json_wtr);
902 jsonw_end_object(json_wtr);
904 const char *msg = NULL;
906 if (lookup_errno == ENOENT)
908 else if (lookup_errno == ENOSPC &&
909 map_info->type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY)
910 msg = "<cannot read>";
912 print_entry_error(map_info, key,
913 msg ? : strerror(lookup_errno));
919 static int maps_have_btf(int *fds, int nb_fds)
921 struct bpf_map_info info = {};
922 __u32 len = sizeof(info);
925 for (i = 0; i < nb_fds; i++) {
926 err = bpf_obj_get_info_by_fd(fds[i], &info, &len);
928 p_err("can't get map info: %s", strerror(errno));
939 static struct btf *btf_vmlinux;
941 static struct btf *get_map_kv_btf(const struct bpf_map_info *info)
943 struct btf *btf = NULL;
945 if (info->btf_vmlinux_value_type_id) {
947 btf_vmlinux = libbpf_find_kernel_btf();
948 if (IS_ERR(btf_vmlinux))
949 p_err("failed to get kernel btf");
952 } else if (info->btf_value_type_id) {
955 err = btf__get_from_id(info->btf_id, &btf);
957 p_err("failed to get btf");
958 btf = err ? ERR_PTR(err) : ERR_PTR(-ESRCH);
965 static void free_map_kv_btf(struct btf *btf)
967 if (!IS_ERR(btf) && btf != btf_vmlinux)
971 static void free_btf_vmlinux(void)
973 if (!IS_ERR(btf_vmlinux))
974 btf__free(btf_vmlinux);
978 map_dump(int fd, struct bpf_map_info *info, json_writer_t *wtr,
981 void *key, *value, *prev_key;
982 unsigned int num_elems = 0;
983 struct btf *btf = NULL;
986 key = malloc(info->key_size);
987 value = alloc_value(info);
988 if (!key || !value) {
989 p_err("mem alloc failed");
997 btf = get_map_kv_btf(info);
1004 jsonw_start_object(wtr); /* map object */
1005 show_map_header_json(info, wtr);
1006 jsonw_name(wtr, "elements");
1008 jsonw_start_array(wtr); /* elements */
1009 } else if (show_header) {
1010 show_map_header_plain(info);
1013 if (info->type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY &&
1014 info->value_size != 8)
1015 p_info("Warning: cannot read values from %s map with value_size != 8",
1016 map_type_name[info->type]);
1018 err = bpf_map_get_next_key(fd, prev_key, key);
1020 if (errno == ENOENT)
1024 num_elems += dump_map_elem(fd, key, value, info, btf, wtr);
1029 jsonw_end_array(wtr); /* elements */
1031 jsonw_end_object(wtr); /* map object */
1033 printf("Found %u element%s\n", num_elems,
1034 num_elems != 1 ? "s" : "");
1041 free_map_kv_btf(btf);
1046 static int do_dump(int argc, char **argv)
1048 json_writer_t *wtr = NULL, *btf_wtr = NULL;
1049 struct bpf_map_info info = {};
1051 __u32 len = sizeof(info);
1058 fds = malloc(sizeof(int));
1060 p_err("mem alloc failed");
1063 nb_fds = map_parse_fds(&argc, &argv, &fds);
1072 do_plain_btf = maps_have_btf(fds, nb_fds);
1073 if (do_plain_btf < 0)
1077 btf_wtr = get_btf_writer();
1080 p_info("failed to create json writer for btf. falling back to plain output");
1084 if (wtr && nb_fds > 1)
1085 jsonw_start_array(wtr); /* root array */
1086 for (i = 0; i < nb_fds; i++) {
1087 if (bpf_obj_get_info_by_fd(fds[i], &info, &len)) {
1088 p_err("can't get map info: %s", strerror(errno));
1091 err = map_dump(fds[i], &info, wtr, nb_fds > 1);
1092 if (!wtr && i != nb_fds - 1)
1099 if (wtr && nb_fds > 1)
1100 jsonw_end_array(wtr); /* root array */
1103 jsonw_destroy(&btf_wtr);
1105 for (; i < nb_fds; i++)
1113 static int alloc_key_value(struct bpf_map_info *info, void **key, void **value)
1118 if (info->key_size) {
1119 *key = malloc(info->key_size);
1121 p_err("key mem alloc failed");
1126 if (info->value_size) {
1127 *value = alloc_value(info);
1129 p_err("value mem alloc failed");
1139 static int do_update(int argc, char **argv)
1141 struct bpf_map_info info = {};
1142 __u32 len = sizeof(info);
1143 __u32 *value_fd = NULL;
1144 __u32 flags = BPF_ANY;
1151 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1155 err = alloc_key_value(&info, &key, &value);
1159 err = parse_elem(argv, &info, key, value, info.key_size,
1160 info.value_size, &flags, &value_fd);
1164 err = bpf_map_update_elem(fd, key, value, flags);
1166 p_err("update failed: %s", strerror(errno));
1177 if (!err && json_output)
1178 jsonw_null(json_wtr);
1182 static void print_key_value(struct bpf_map_info *info, void *key,
1185 json_writer_t *btf_wtr;
1186 struct btf *btf = NULL;
1189 err = btf__get_from_id(info->btf_id, &btf);
1191 p_err("failed to get btf");
1196 print_entry_json(info, key, value, btf);
1198 /* if here json_wtr wouldn't have been initialised,
1199 * so let's create separate writer for btf
1201 btf_wtr = get_btf_writer();
1203 p_info("failed to create json writer for btf. falling back to plain output");
1206 print_entry_plain(info, key, value);
1208 struct btf_dumper d = {
1211 .is_plain_text = true,
1214 do_dump_btf(&d, info, key, value);
1215 jsonw_destroy(&btf_wtr);
1218 print_entry_plain(info, key, value);
1223 static int do_lookup(int argc, char **argv)
1225 struct bpf_map_info info = {};
1226 __u32 len = sizeof(info);
1234 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1238 err = alloc_key_value(&info, &key, &value);
1242 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
1246 err = bpf_map_lookup_elem(fd, key, value);
1248 if (errno == ENOENT) {
1250 jsonw_null(json_wtr);
1253 fprint_hex(stdout, key, info.key_size, " ");
1254 printf("\n\nNot found\n");
1257 p_err("lookup failed: %s", strerror(errno));
1263 /* here means bpf_map_lookup_elem() succeeded */
1264 print_key_value(&info, key, value);
1274 static int do_getnext(int argc, char **argv)
1276 struct bpf_map_info info = {};
1277 __u32 len = sizeof(info);
1278 void *key, *nextkey;
1285 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1289 key = malloc(info.key_size);
1290 nextkey = malloc(info.key_size);
1291 if (!key || !nextkey) {
1292 p_err("mem alloc failed");
1298 err = parse_elem(argv, &info, key, NULL, info.key_size, 0,
1307 err = bpf_map_get_next_key(fd, key, nextkey);
1309 p_err("can't get next key: %s", strerror(errno));
1314 jsonw_start_object(json_wtr);
1316 jsonw_name(json_wtr, "key");
1317 print_hex_data_json(key, info.key_size);
1319 jsonw_null_field(json_wtr, "key");
1321 jsonw_name(json_wtr, "next_key");
1322 print_hex_data_json(nextkey, info.key_size);
1323 jsonw_end_object(json_wtr);
1327 fprint_hex(stdout, key, info.key_size, " ");
1330 printf("key: None\n");
1332 printf("next key:\n");
1333 fprint_hex(stdout, nextkey, info.key_size, " ");
1345 static int do_delete(int argc, char **argv)
1347 struct bpf_map_info info = {};
1348 __u32 len = sizeof(info);
1356 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1360 key = malloc(info.key_size);
1362 p_err("mem alloc failed");
1367 err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
1371 err = bpf_map_delete_elem(fd, key);
1373 p_err("delete failed: %s", strerror(errno));
1379 if (!err && json_output)
1380 jsonw_null(json_wtr);
1384 static int do_pin(int argc, char **argv)
1388 err = do_pin_any(argc, argv, map_parse_fd);
1389 if (!err && json_output)
1390 jsonw_null(json_wtr);
1394 static int do_create(int argc, char **argv)
1396 struct bpf_create_map_attr attr = { NULL, };
1397 const char *pinfile;
1402 pinfile = GET_ARG();
1408 if (is_prefix(*argv, "type")) {
1411 if (attr.map_type) {
1412 p_err("map type already specified");
1416 attr.map_type = map_type_from_str(*argv);
1417 if ((int)attr.map_type < 0) {
1418 p_err("unrecognized map type: %s", *argv);
1422 } else if (is_prefix(*argv, "name")) {
1424 attr.name = GET_ARG();
1425 } else if (is_prefix(*argv, "key")) {
1426 if (parse_u32_arg(&argc, &argv, &attr.key_size,
1429 } else if (is_prefix(*argv, "value")) {
1430 if (parse_u32_arg(&argc, &argv, &attr.value_size,
1433 } else if (is_prefix(*argv, "entries")) {
1434 if (parse_u32_arg(&argc, &argv, &attr.max_entries,
1437 } else if (is_prefix(*argv, "flags")) {
1438 if (parse_u32_arg(&argc, &argv, &attr.map_flags,
1441 } else if (is_prefix(*argv, "dev")) {
1444 if (attr.map_ifindex) {
1445 p_err("offload device already specified");
1449 attr.map_ifindex = if_nametoindex(*argv);
1450 if (!attr.map_ifindex) {
1451 p_err("unrecognized netdevice '%s': %s",
1452 *argv, strerror(errno));
1457 p_err("unknown arg %s", *argv);
1463 p_err("map name not specified");
1469 fd = bpf_create_map_xattr(&attr);
1471 p_err("map create failed: %s", strerror(errno));
1475 err = do_pin_fd(fd, pinfile);
1481 jsonw_null(json_wtr);
1485 static int do_pop_dequeue(int argc, char **argv)
1487 struct bpf_map_info info = {};
1488 __u32 len = sizeof(info);
1496 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1500 err = alloc_key_value(&info, &key, &value);
1504 err = bpf_map_lookup_and_delete_elem(fd, key, value);
1506 if (errno == ENOENT) {
1508 jsonw_null(json_wtr);
1510 printf("Error: empty map\n");
1512 p_err("pop failed: %s", strerror(errno));
1518 print_key_value(&info, key, value);
1528 static int do_freeze(int argc, char **argv)
1535 fd = map_parse_fd(&argc, &argv);
1544 err = bpf_map_freeze(fd);
1547 p_err("failed to freeze map: %s", strerror(errno));
1552 jsonw_null(json_wtr);
1557 static int do_help(int argc, char **argv)
1560 jsonw_null(json_wtr);
1565 "Usage: %1$s %2$s { show | list } [MAP]\n"
1566 " %1$s %2$s create FILE type TYPE key KEY_SIZE value VALUE_SIZE \\\n"
1567 " entries MAX_ENTRIES name NAME [flags FLAGS] \\\n"
1569 " %1$s %2$s dump MAP\n"
1570 " %1$s %2$s update MAP [key DATA] [value VALUE] [UPDATE_FLAGS]\n"
1571 " %1$s %2$s lookup MAP [key DATA]\n"
1572 " %1$s %2$s getnext MAP [key DATA]\n"
1573 " %1$s %2$s delete MAP key DATA\n"
1574 " %1$s %2$s pin MAP FILE\n"
1575 " %1$s %2$s event_pipe MAP [cpu N index M]\n"
1576 " %1$s %2$s peek MAP\n"
1577 " %1$s %2$s push MAP value VALUE\n"
1578 " %1$s %2$s pop MAP\n"
1579 " %1$s %2$s enqueue MAP value VALUE\n"
1580 " %1$s %2$s dequeue MAP\n"
1581 " %1$s %2$s freeze MAP\n"
1584 " " HELP_SPEC_MAP "\n"
1585 " DATA := { [hex] BYTES }\n"
1586 " " HELP_SPEC_PROGRAM "\n"
1587 " VALUE := { DATA | MAP | PROG }\n"
1588 " UPDATE_FLAGS := { any | exist | noexist }\n"
1589 " TYPE := { hash | array | prog_array | perf_event_array | percpu_hash |\n"
1590 " percpu_array | stack_trace | cgroup_array | lru_hash |\n"
1591 " lru_percpu_hash | lpm_trie | array_of_maps | hash_of_maps |\n"
1592 " devmap | devmap_hash | sockmap | cpumap | xskmap | sockhash |\n"
1593 " cgroup_storage | reuseport_sockarray | percpu_cgroup_storage |\n"
1594 " queue | stack | sk_storage | struct_ops | ringbuf }\n"
1595 " " HELP_SPEC_OPTIONS "\n"
1597 bin_name, argv[-2]);
1602 static const struct cmd cmds[] = {
1603 { "show", do_show },
1604 { "list", do_show },
1605 { "help", do_help },
1606 { "dump", do_dump },
1607 { "update", do_update },
1608 { "lookup", do_lookup },
1609 { "getnext", do_getnext },
1610 { "delete", do_delete },
1612 { "event_pipe", do_event_pipe },
1613 { "create", do_create },
1614 { "peek", do_lookup },
1615 { "push", do_update },
1616 { "enqueue", do_update },
1617 { "pop", do_pop_dequeue },
1618 { "dequeue", do_pop_dequeue },
1619 { "freeze", do_freeze },
1623 int do_map(int argc, char **argv)
1625 return cmd_select(cmds, argc, argv, do_help);