1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
14 #include <sys/types.h>
17 #include <linux/err.h>
25 #include "xlated_dumper.h"
27 static const char * const attach_type_strings[] = {
28 [BPF_SK_SKB_STREAM_PARSER] = "stream_parser",
29 [BPF_SK_SKB_STREAM_VERDICT] = "stream_verdict",
30 [BPF_SK_MSG_VERDICT] = "msg_verdict",
31 [BPF_FLOW_DISSECTOR] = "flow_dissector",
32 [__MAX_BPF_ATTACH_TYPE] = NULL,
35 static enum bpf_attach_type parse_attach_type(const char *str)
37 enum bpf_attach_type type;
39 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
40 if (attach_type_strings[type] &&
41 is_prefix(str, attach_type_strings[type]))
45 return __MAX_BPF_ATTACH_TYPE;
48 static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)
50 struct timespec real_time_ts, boot_time_ts;
51 time_t wallclock_secs;
56 if (clock_gettime(CLOCK_REALTIME, &real_time_ts) ||
57 clock_gettime(CLOCK_BOOTTIME, &boot_time_ts)) {
58 perror("Can't read clocks");
59 snprintf(buf, size, "%llu", nsecs / 1000000000);
63 wallclock_secs = (real_time_ts.tv_sec - boot_time_ts.tv_sec) +
64 (real_time_ts.tv_nsec - boot_time_ts.tv_nsec + nsecs) /
68 if (!localtime_r(&wallclock_secs, &load_tm)) {
69 snprintf(buf, size, "%llu", nsecs / 1000000000);
74 strftime(buf, size, "%s", &load_tm);
76 strftime(buf, size, "%FT%T%z", &load_tm);
79 static int prog_fd_by_tag(unsigned char *tag)
86 struct bpf_prog_info info = {};
87 __u32 len = sizeof(info);
89 err = bpf_prog_get_next_id(id, &id);
91 p_err("%s", strerror(errno));
95 fd = bpf_prog_get_fd_by_id(id);
97 p_err("can't get prog by id (%u): %s",
102 err = bpf_obj_get_info_by_fd(fd, &info, &len);
104 p_err("can't get prog info (%u): %s",
105 id, strerror(errno));
110 if (!memcmp(tag, info.tag, BPF_TAG_SIZE))
117 int prog_parse_fd(int *argc, char ***argv)
121 if (is_prefix(**argv, "id")) {
127 id = strtoul(**argv, &endptr, 0);
129 p_err("can't parse %s as ID", **argv);
134 fd = bpf_prog_get_fd_by_id(id);
136 p_err("get by id (%u): %s", id, strerror(errno));
138 } else if (is_prefix(**argv, "tag")) {
139 unsigned char tag[BPF_TAG_SIZE];
143 if (sscanf(**argv, BPF_TAG_FMT, tag, tag + 1, tag + 2,
144 tag + 3, tag + 4, tag + 5, tag + 6, tag + 7)
146 p_err("can't parse tag");
151 return prog_fd_by_tag(tag);
152 } else if (is_prefix(**argv, "pinned")) {
160 return open_obj_pinned_any(path, BPF_OBJ_PROG);
163 p_err("expected 'id', 'tag' or 'pinned', got: '%s'?", **argv);
167 static void show_prog_maps(int fd, u32 num_maps)
169 struct bpf_prog_info info = {};
170 __u32 len = sizeof(info);
171 __u32 map_ids[num_maps];
175 info.nr_map_ids = num_maps;
176 info.map_ids = ptr_to_u64(map_ids);
178 err = bpf_obj_get_info_by_fd(fd, &info, &len);
179 if (err || !info.nr_map_ids)
183 jsonw_name(json_wtr, "map_ids");
184 jsonw_start_array(json_wtr);
185 for (i = 0; i < info.nr_map_ids; i++)
186 jsonw_uint(json_wtr, map_ids[i]);
187 jsonw_end_array(json_wtr);
190 for (i = 0; i < info.nr_map_ids; i++)
191 printf("%u%s", map_ids[i],
192 i == info.nr_map_ids - 1 ? "" : ",");
196 static void print_prog_json(struct bpf_prog_info *info, int fd)
200 jsonw_start_object(json_wtr);
201 jsonw_uint_field(json_wtr, "id", info->id);
202 if (info->type < ARRAY_SIZE(prog_type_name))
203 jsonw_string_field(json_wtr, "type",
204 prog_type_name[info->type]);
206 jsonw_uint_field(json_wtr, "type", info->type);
209 jsonw_string_field(json_wtr, "name", info->name);
211 jsonw_name(json_wtr, "tag");
212 jsonw_printf(json_wtr, "\"" BPF_TAG_FMT "\"",
213 info->tag[0], info->tag[1], info->tag[2], info->tag[3],
214 info->tag[4], info->tag[5], info->tag[6], info->tag[7]);
216 jsonw_bool_field(json_wtr, "gpl_compatible", info->gpl_compatible);
217 if (info->run_time_ns) {
218 jsonw_uint_field(json_wtr, "run_time_ns", info->run_time_ns);
219 jsonw_uint_field(json_wtr, "run_cnt", info->run_cnt);
222 print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
224 if (info->load_time) {
227 print_boot_time(info->load_time, buf, sizeof(buf));
229 /* Piggy back on load_time, since 0 uid is a valid one */
230 jsonw_name(json_wtr, "loaded_at");
231 jsonw_printf(json_wtr, "%s", buf);
232 jsonw_uint_field(json_wtr, "uid", info->created_by_uid);
235 jsonw_uint_field(json_wtr, "bytes_xlated", info->xlated_prog_len);
237 if (info->jited_prog_len) {
238 jsonw_bool_field(json_wtr, "jited", true);
239 jsonw_uint_field(json_wtr, "bytes_jited", info->jited_prog_len);
241 jsonw_bool_field(json_wtr, "jited", false);
244 memlock = get_fdinfo(fd, "memlock");
246 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
249 if (info->nr_map_ids)
250 show_prog_maps(fd, info->nr_map_ids);
253 jsonw_int_field(json_wtr, "btf_id", info->btf_id);
255 if (!hash_empty(prog_table.table)) {
256 struct pinned_obj *obj;
258 jsonw_name(json_wtr, "pinned");
259 jsonw_start_array(json_wtr);
260 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
261 if (obj->id == info->id)
262 jsonw_string(json_wtr, obj->path);
264 jsonw_end_array(json_wtr);
267 jsonw_end_object(json_wtr);
270 static void print_prog_plain(struct bpf_prog_info *info, int fd)
274 printf("%u: ", info->id);
275 if (info->type < ARRAY_SIZE(prog_type_name))
276 printf("%s ", prog_type_name[info->type]);
278 printf("type %u ", info->type);
281 printf("name %s ", info->name);
284 fprint_hex(stdout, info->tag, BPF_TAG_SIZE, "");
285 print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
286 printf("%s", info->gpl_compatible ? " gpl" : "");
287 if (info->run_time_ns)
288 printf(" run_time_ns %lld run_cnt %lld",
289 info->run_time_ns, info->run_cnt);
292 if (info->load_time) {
295 print_boot_time(info->load_time, buf, sizeof(buf));
297 /* Piggy back on load_time, since 0 uid is a valid one */
298 printf("\tloaded_at %s uid %u\n", buf, info->created_by_uid);
301 printf("\txlated %uB", info->xlated_prog_len);
303 if (info->jited_prog_len)
304 printf(" jited %uB", info->jited_prog_len);
306 printf(" not jited");
308 memlock = get_fdinfo(fd, "memlock");
310 printf(" memlock %sB", memlock);
313 if (info->nr_map_ids)
314 show_prog_maps(fd, info->nr_map_ids);
316 if (!hash_empty(prog_table.table)) {
317 struct pinned_obj *obj;
319 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
320 if (obj->id == info->id)
321 printf("\n\tpinned %s", obj->path);
326 printf("\n\tbtf_id %d", info->btf_id);
331 static int show_prog(int fd)
333 struct bpf_prog_info info = {};
334 __u32 len = sizeof(info);
337 err = bpf_obj_get_info_by_fd(fd, &info, &len);
339 p_err("can't get prog info: %s", strerror(errno));
344 print_prog_json(&info, fd);
346 print_prog_plain(&info, fd);
351 static int do_show(int argc, char **argv)
358 build_pinned_obj_table(&prog_table, BPF_OBJ_PROG);
361 fd = prog_parse_fd(&argc, &argv);
365 return show_prog(fd);
372 jsonw_start_array(json_wtr);
374 err = bpf_prog_get_next_id(id, &id);
376 if (errno == ENOENT) {
380 p_err("can't get next program: %s%s", strerror(errno),
381 errno == EINVAL ? " -- kernel too old?" : "");
386 fd = bpf_prog_get_fd_by_id(id);
390 p_err("can't get prog by id (%u): %s",
391 id, strerror(errno));
403 jsonw_end_array(json_wtr);
408 static int do_dump(int argc, char **argv)
410 struct bpf_prog_info_linear *info_linear;
411 struct bpf_prog_linfo *prog_linfo = NULL;
412 enum {DUMP_JITED, DUMP_XLATED} mode;
413 const char *disasm_opt = NULL;
414 struct bpf_prog_info *info;
415 struct dump_data dd = {};
416 void *func_info = NULL;
417 struct btf *btf = NULL;
418 char *filepath = NULL;
419 bool opcodes = false;
429 if (is_prefix(*argv, "jited")) {
433 } else if (is_prefix(*argv, "xlated")) {
436 p_err("expected 'xlated' or 'jited', got: %s", *argv);
444 fd = prog_parse_fd(&argc, &argv);
448 if (is_prefix(*argv, "file")) {
451 p_err("expected file path");
457 } else if (is_prefix(*argv, "opcodes")) {
460 } else if (is_prefix(*argv, "visual")) {
463 } else if (is_prefix(*argv, "linum")) {
473 if (mode == DUMP_JITED)
474 arrays = 1UL << BPF_PROG_INFO_JITED_INSNS;
476 arrays = 1UL << BPF_PROG_INFO_XLATED_INSNS;
478 arrays |= 1UL << BPF_PROG_INFO_JITED_KSYMS;
479 arrays |= 1UL << BPF_PROG_INFO_JITED_FUNC_LENS;
480 arrays |= 1UL << BPF_PROG_INFO_FUNC_INFO;
481 arrays |= 1UL << BPF_PROG_INFO_LINE_INFO;
482 arrays |= 1UL << BPF_PROG_INFO_JITED_LINE_INFO;
484 info_linear = bpf_program__get_prog_info_linear(fd, arrays);
486 if (IS_ERR_OR_NULL(info_linear)) {
487 p_err("can't get prog info: %s", strerror(errno));
491 info = &info_linear->info;
492 if (mode == DUMP_JITED) {
493 if (info->jited_prog_len == 0) {
494 p_info("no instructions returned");
497 buf = (unsigned char *)(info->jited_prog_insns);
498 member_len = info->jited_prog_len;
499 } else { /* DUMP_XLATED */
500 if (info->xlated_prog_len == 0) {
501 p_err("error retrieving insn dump: kernel.kptr_restrict set?");
504 buf = (unsigned char *)info->xlated_prog_insns;
505 member_len = info->xlated_prog_len;
508 if (info->btf_id && btf__get_from_id(info->btf_id, &btf)) {
509 p_err("failed to get btf");
513 func_info = (void *)info->func_info;
515 if (info->nr_line_info) {
516 prog_linfo = bpf_prog_linfo__new(info);
518 p_info("error in processing bpf_line_info. continue without it.");
522 fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0600);
524 p_err("can't open file %s: %s", filepath,
529 n = write(fd, buf, member_len);
531 if (n != member_len) {
532 p_err("error writing output file: %s",
533 n < 0 ? strerror(errno) : "short write");
538 jsonw_null(json_wtr);
539 } else if (mode == DUMP_JITED) {
540 const char *name = NULL;
543 name = ifindex_to_bfd_params(info->ifindex,
551 if (info->nr_jited_func_lens && info->jited_func_lens) {
552 struct kernel_sym *sym = NULL;
553 struct bpf_func_info *record;
554 char sym_name[SYM_MAX_NAME];
555 unsigned char *img = buf;
559 if (info->nr_jited_ksyms) {
560 kernel_syms_load(&dd);
561 ksyms = (__u64 *) info->jited_ksyms;
565 jsonw_start_array(json_wtr);
567 lens = (__u32 *) info->jited_func_lens;
568 for (i = 0; i < info->nr_jited_func_lens; i++) {
570 sym = kernel_syms_search(&dd, ksyms[i]);
572 sprintf(sym_name, "%s", sym->name);
574 sprintf(sym_name, "0x%016llx", ksyms[i]);
576 strcpy(sym_name, "unknown");
580 record = func_info + i * info->func_info_rec_size;
581 btf_dumper_type_only(btf, record->type_id,
587 jsonw_start_object(json_wtr);
588 if (func_info && func_sig[0] != '\0') {
589 jsonw_name(json_wtr, "proto");
590 jsonw_string(json_wtr, func_sig);
592 jsonw_name(json_wtr, "name");
593 jsonw_string(json_wtr, sym_name);
594 jsonw_name(json_wtr, "insns");
596 if (func_info && func_sig[0] != '\0')
597 printf("%s:\n", func_sig);
598 printf("%s:\n", sym_name);
601 disasm_print_insn(img, lens[i], opcodes,
602 name, disasm_opt, btf,
603 prog_linfo, ksyms[i], i,
609 jsonw_end_object(json_wtr);
615 jsonw_end_array(json_wtr);
617 disasm_print_insn(buf, member_len, opcodes, name,
618 disasm_opt, btf, NULL, 0, 0, false);
622 jsonw_null(json_wtr);
624 dump_xlated_cfg(buf, member_len);
626 kernel_syms_load(&dd);
627 dd.nr_jited_ksyms = info->nr_jited_ksyms;
628 dd.jited_ksyms = (__u64 *) info->jited_ksyms;
630 dd.func_info = func_info;
631 dd.finfo_rec_size = info->func_info_rec_size;
632 dd.prog_linfo = prog_linfo;
635 dump_xlated_json(&dd, buf, member_len, opcodes,
638 dump_xlated_plain(&dd, buf, member_len, opcodes,
640 kernel_syms_destroy(&dd);
651 static int do_pin(int argc, char **argv)
655 err = do_pin_any(argc, argv, bpf_prog_get_fd_by_id);
656 if (!err && json_output)
657 jsonw_null(json_wtr);
667 static int map_replace_compar(const void *p1, const void *p2)
669 const struct map_replace *a = p1, *b = p2;
671 return a->idx - b->idx;
674 static int parse_attach_detach_args(int argc, char **argv, int *progfd,
675 enum bpf_attach_type *attach_type,
681 *progfd = prog_parse_fd(&argc, &argv);
685 *attach_type = parse_attach_type(*argv);
686 if (*attach_type == __MAX_BPF_ATTACH_TYPE) {
687 p_err("invalid attach/detach type");
691 if (*attach_type == BPF_FLOW_DISSECTOR) {
700 *mapfd = map_parse_fd(&argc, &argv);
707 static int do_attach(int argc, char **argv)
709 enum bpf_attach_type attach_type;
713 err = parse_attach_detach_args(argc, argv,
714 &progfd, &attach_type, &mapfd);
718 err = bpf_prog_attach(progfd, mapfd, attach_type, 0);
720 p_err("failed prog attach to map");
725 jsonw_null(json_wtr);
729 static int do_detach(int argc, char **argv)
731 enum bpf_attach_type attach_type;
735 err = parse_attach_detach_args(argc, argv,
736 &progfd, &attach_type, &mapfd);
740 err = bpf_prog_detach2(progfd, mapfd, attach_type);
742 p_err("failed prog detach from map");
747 jsonw_null(json_wtr);
751 static int load_with_options(int argc, char **argv, bool first_prog_only)
753 enum bpf_attach_type expected_attach_type;
754 struct bpf_object_open_attr attr = {
755 .prog_type = BPF_PROG_TYPE_UNSPEC,
757 struct map_replace *map_replace = NULL;
758 struct bpf_program *prog = NULL, *pos;
759 unsigned int old_map_fds = 0;
760 const char *pinmaps = NULL;
761 struct bpf_object *obj;
770 attr.file = GET_ARG();
774 if (is_prefix(*argv, "type")) {
779 if (attr.prog_type != BPF_PROG_TYPE_UNSPEC) {
780 p_err("program type already specified");
781 goto err_free_reuse_maps;
784 goto err_free_reuse_maps;
786 /* Put a '/' at the end of type to appease libbpf */
787 type = malloc(strlen(*argv) + 2);
789 p_err("mem alloc failed");
790 goto err_free_reuse_maps;
796 err = libbpf_prog_type_by_name(type, &attr.prog_type,
797 &expected_attach_type);
800 goto err_free_reuse_maps;
803 } else if (is_prefix(*argv, "map")) {
804 void *new_map_replace;
811 goto err_free_reuse_maps;
813 if (is_prefix(*argv, "idx")) {
816 idx = strtoul(*argv, &endptr, 0);
818 p_err("can't parse %s as IDX", *argv);
819 goto err_free_reuse_maps;
822 } else if (is_prefix(*argv, "name")) {
828 p_err("expected 'idx' or 'name', got: '%s'?",
830 goto err_free_reuse_maps;
834 fd = map_parse_fd(&argc, &argv);
836 goto err_free_reuse_maps;
838 new_map_replace = reallocarray(map_replace,
840 sizeof(*map_replace));
841 if (!new_map_replace) {
842 p_err("mem alloc failed");
843 goto err_free_reuse_maps;
845 map_replace = new_map_replace;
847 map_replace[old_map_fds].idx = idx;
848 map_replace[old_map_fds].name = name;
849 map_replace[old_map_fds].fd = fd;
851 } else if (is_prefix(*argv, "dev")) {
855 p_err("offload device already specified");
856 goto err_free_reuse_maps;
859 goto err_free_reuse_maps;
861 ifindex = if_nametoindex(*argv);
863 p_err("unrecognized netdevice '%s': %s",
864 *argv, strerror(errno));
865 goto err_free_reuse_maps;
868 } else if (is_prefix(*argv, "pinmaps")) {
872 goto err_free_reuse_maps;
876 p_err("expected no more arguments, 'type', 'map' or 'dev', got: '%s'?",
878 goto err_free_reuse_maps;
882 obj = __bpf_object__open_xattr(&attr, bpf_flags);
883 if (IS_ERR_OR_NULL(obj)) {
884 p_err("failed to open object file");
885 goto err_free_reuse_maps;
888 bpf_object__for_each_program(pos, obj) {
889 enum bpf_prog_type prog_type = attr.prog_type;
891 if (attr.prog_type == BPF_PROG_TYPE_UNSPEC) {
892 const char *sec_name = bpf_program__title(pos, false);
894 err = libbpf_prog_type_by_name(sec_name, &prog_type,
895 &expected_attach_type);
900 bpf_program__set_ifindex(pos, ifindex);
901 bpf_program__set_type(pos, prog_type);
902 bpf_program__set_expected_attach_type(pos, expected_attach_type);
905 qsort(map_replace, old_map_fds, sizeof(*map_replace),
908 /* After the sort maps by name will be first on the list, because they
909 * have idx == -1. Resolve them.
912 while (j < old_map_fds && map_replace[j].name) {
914 bpf_object__for_each_map(map, obj) {
915 if (!strcmp(bpf_map__name(map), map_replace[j].name)) {
916 map_replace[j].idx = i;
921 if (map_replace[j].idx == -1) {
922 p_err("unable to find map '%s'", map_replace[j].name);
927 /* Resort if any names were resolved */
929 qsort(map_replace, old_map_fds, sizeof(*map_replace),
932 /* Set ifindex and name reuse */
935 bpf_object__for_each_map(map, obj) {
936 if (!bpf_map__is_offload_neutral(map))
937 bpf_map__set_ifindex(map, ifindex);
939 if (j < old_map_fds && idx == map_replace[j].idx) {
940 err = bpf_map__reuse_fd(map, map_replace[j++].fd);
942 p_err("unable to set up map reuse: %d", err);
946 /* Next reuse wants to apply to the same map */
947 if (j < old_map_fds && map_replace[j].idx == idx) {
948 p_err("replacement for map idx %d specified more than once",
956 if (j < old_map_fds) {
957 p_err("map idx '%d' not used", map_replace[j].idx);
963 err = bpf_object__load(obj);
965 p_err("failed to load object file");
969 err = mount_bpffs_for_pin(pinfile);
973 if (first_prog_only) {
974 prog = bpf_program__next(NULL, obj);
976 p_err("object file doesn't contain any bpf program");
980 err = bpf_obj_pin(bpf_program__fd(prog), pinfile);
982 p_err("failed to pin program %s",
983 bpf_program__title(prog, false));
987 err = bpf_object__pin_programs(obj, pinfile);
989 p_err("failed to pin all programs");
995 err = bpf_object__pin_maps(obj, pinmaps);
997 p_err("failed to pin all maps");
1003 jsonw_null(json_wtr);
1005 bpf_object__close(obj);
1006 for (i = 0; i < old_map_fds; i++)
1007 close(map_replace[i].fd);
1013 if (first_prog_only)
1016 bpf_object__unpin_programs(obj, pinfile);
1018 bpf_object__close(obj);
1019 err_free_reuse_maps:
1020 for (i = 0; i < old_map_fds; i++)
1021 close(map_replace[i].fd);
1026 static int do_load(int argc, char **argv)
1028 return load_with_options(argc, argv, true);
1031 static int do_loadall(int argc, char **argv)
1033 return load_with_options(argc, argv, false);
1036 static int do_help(int argc, char **argv)
1039 jsonw_null(json_wtr);
1044 "Usage: %s %s { show | list } [PROG]\n"
1045 " %s %s dump xlated PROG [{ file FILE | opcodes | visual | linum }]\n"
1046 " %s %s dump jited PROG [{ file FILE | opcodes | linum }]\n"
1047 " %s %s pin PROG FILE\n"
1048 " %s %s { load | loadall } OBJ PATH \\\n"
1049 " [type TYPE] [dev NAME] \\\n"
1050 " [map { idx IDX | name NAME } MAP]\\\n"
1051 " [pinmaps MAP_DIR]\n"
1052 " %s %s attach PROG ATTACH_TYPE [MAP]\n"
1053 " %s %s detach PROG ATTACH_TYPE [MAP]\n"
1057 " " HELP_SPEC_MAP "\n"
1058 " " HELP_SPEC_PROGRAM "\n"
1059 " TYPE := { socket | kprobe | kretprobe | classifier | action |\n"
1060 " tracepoint | raw_tracepoint | xdp | perf_event | cgroup/skb |\n"
1061 " cgroup/sock | cgroup/dev | lwt_in | lwt_out | lwt_xmit |\n"
1062 " lwt_seg6local | sockops | sk_skb | sk_msg | lirc_mode2 |\n"
1063 " sk_reuseport | flow_dissector |\n"
1064 " cgroup/bind4 | cgroup/bind6 | cgroup/post_bind4 |\n"
1065 " cgroup/post_bind6 | cgroup/connect4 | cgroup/connect6 |\n"
1066 " cgroup/sendmsg4 | cgroup/sendmsg6 }\n"
1067 " ATTACH_TYPE := { msg_verdict | stream_verdict | stream_parser |\n"
1068 " flow_dissector }\n"
1069 " " HELP_SPEC_OPTIONS "\n"
1071 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1072 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1073 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2]);
1078 static const struct cmd cmds[] = {
1079 { "show", do_show },
1080 { "list", do_show },
1081 { "help", do_help },
1082 { "dump", do_dump },
1084 { "load", do_load },
1085 { "loadall", do_loadall },
1086 { "attach", do_attach },
1087 { "detach", do_detach },
1088 { "tracelog", do_tracelog },
1092 int do_prog(int argc, char **argv)
1094 return cmd_select(cmds, argc, argv, do_help);