2 * Copyright (C) 2017 Netronome Systems, Inc.
4 * This software is dual licensed under the GNU General License Version 2,
5 * June 1991 as shown in the file COPYING in the top-level directory of this
6 * source tree or the BSD 2-Clause License provided below. You have the
7 * option to license this software under the complete terms of either license.
9 * The BSD 2-Clause License:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * 1. Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * 2. Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 /* Author: Jakub Kicinski <kubakici@wp.pl> */
45 #include <sys/types.h>
53 static const char * const prog_type_name
[] = {
54 [BPF_PROG_TYPE_UNSPEC
] = "unspec",
55 [BPF_PROG_TYPE_SOCKET_FILTER
] = "socket_filter",
56 [BPF_PROG_TYPE_KPROBE
] = "kprobe",
57 [BPF_PROG_TYPE_SCHED_CLS
] = "sched_cls",
58 [BPF_PROG_TYPE_SCHED_ACT
] = "sched_act",
59 [BPF_PROG_TYPE_TRACEPOINT
] = "tracepoint",
60 [BPF_PROG_TYPE_XDP
] = "xdp",
61 [BPF_PROG_TYPE_PERF_EVENT
] = "perf_event",
62 [BPF_PROG_TYPE_CGROUP_SKB
] = "cgroup_skb",
63 [BPF_PROG_TYPE_CGROUP_SOCK
] = "cgroup_sock",
64 [BPF_PROG_TYPE_LWT_IN
] = "lwt_in",
65 [BPF_PROG_TYPE_LWT_OUT
] = "lwt_out",
66 [BPF_PROG_TYPE_LWT_XMIT
] = "lwt_xmit",
67 [BPF_PROG_TYPE_SOCK_OPS
] = "sock_ops",
68 [BPF_PROG_TYPE_SK_SKB
] = "sk_skb",
71 static void print_boot_time(__u64 nsecs
, char *buf
, unsigned int size
)
73 struct timespec real_time_ts
, boot_time_ts
;
74 time_t wallclock_secs
;
79 if (clock_gettime(CLOCK_REALTIME
, &real_time_ts
) ||
80 clock_gettime(CLOCK_BOOTTIME
, &boot_time_ts
)) {
81 perror("Can't read clocks");
82 snprintf(buf
, size
, "%llu", nsecs
/ 1000000000);
86 wallclock_secs
= (real_time_ts
.tv_sec
- boot_time_ts
.tv_sec
) +
89 if (!localtime_r(&wallclock_secs
, &load_tm
)) {
90 snprintf(buf
, size
, "%llu", nsecs
/ 1000000000);
94 strftime(buf
, size
, "%b %d/%H:%M", &load_tm
);
97 static int prog_fd_by_tag(unsigned char *tag
)
99 struct bpf_prog_info info
= {};
100 __u32 len
= sizeof(info
);
106 err
= bpf_prog_get_next_id(id
, &id
);
108 p_err("%s", strerror(errno
));
112 fd
= bpf_prog_get_fd_by_id(id
);
114 p_err("can't get prog by id (%u): %s",
115 id
, strerror(errno
));
119 err
= bpf_obj_get_info_by_fd(fd
, &info
, &len
);
121 p_err("can't get prog info (%u): %s",
122 id
, strerror(errno
));
127 if (!memcmp(tag
, info
.tag
, BPF_TAG_SIZE
))
134 int prog_parse_fd(int *argc
, char ***argv
)
138 if (is_prefix(**argv
, "id")) {
144 id
= strtoul(**argv
, &endptr
, 0);
146 p_err("can't parse %s as ID", **argv
);
151 fd
= bpf_prog_get_fd_by_id(id
);
153 p_err("get by id (%u): %s", id
, strerror(errno
));
155 } else if (is_prefix(**argv
, "tag")) {
156 unsigned char tag
[BPF_TAG_SIZE
];
160 if (sscanf(**argv
, BPF_TAG_FMT
, tag
, tag
+ 1, tag
+ 2,
161 tag
+ 3, tag
+ 4, tag
+ 5, tag
+ 6, tag
+ 7)
163 p_err("can't parse tag");
168 return prog_fd_by_tag(tag
);
169 } else if (is_prefix(**argv
, "pinned")) {
177 return open_obj_pinned_any(path
, BPF_OBJ_PROG
);
180 p_err("expected 'id', 'tag' or 'pinned', got: '%s'?", **argv
);
184 static void show_prog_maps(int fd
, u32 num_maps
)
186 struct bpf_prog_info info
= {};
187 __u32 len
= sizeof(info
);
188 __u32 map_ids
[num_maps
];
192 info
.nr_map_ids
= num_maps
;
193 info
.map_ids
= ptr_to_u64(map_ids
);
195 err
= bpf_obj_get_info_by_fd(fd
, &info
, &len
);
196 if (err
|| !info
.nr_map_ids
)
200 jsonw_name(json_wtr
, "map_ids");
201 jsonw_start_array(json_wtr
);
202 for (i
= 0; i
< info
.nr_map_ids
; i
++)
203 jsonw_uint(json_wtr
, map_ids
[i
]);
204 jsonw_end_array(json_wtr
);
207 for (i
= 0; i
< info
.nr_map_ids
; i
++)
208 printf("%u%s", map_ids
[i
],
209 i
== info
.nr_map_ids
- 1 ? "" : ",");
213 static void print_prog_json(struct bpf_prog_info
*info
, int fd
)
217 jsonw_start_object(json_wtr
);
218 jsonw_uint_field(json_wtr
, "id", info
->id
);
219 if (info
->type
< ARRAY_SIZE(prog_type_name
))
220 jsonw_string_field(json_wtr
, "type",
221 prog_type_name
[info
->type
]);
223 jsonw_uint_field(json_wtr
, "type", info
->type
);
226 jsonw_string_field(json_wtr
, "name", info
->name
);
228 jsonw_name(json_wtr
, "tag");
229 jsonw_printf(json_wtr
, "\"" BPF_TAG_FMT
"\"",
230 info
->tag
[0], info
->tag
[1], info
->tag
[2], info
->tag
[3],
231 info
->tag
[4], info
->tag
[5], info
->tag
[6], info
->tag
[7]);
233 if (info
->status
& BPF_PROG_STATUS_DEV_BOUND
) {
234 jsonw_name(json_wtr
, "dev");
236 char name
[IF_NAMESIZE
];
238 if (!if_indextoname(info
->ifindex
, name
))
239 jsonw_printf(json_wtr
, "\"ifindex:%d\"",
242 jsonw_printf(json_wtr
, "\"%s\"", name
);
244 jsonw_printf(json_wtr
, "\"unknown\"");
248 if (info
->load_time
) {
251 print_boot_time(info
->load_time
, buf
, sizeof(buf
));
253 /* Piggy back on load_time, since 0 uid is a valid one */
254 jsonw_string_field(json_wtr
, "loaded_at", buf
);
255 jsonw_uint_field(json_wtr
, "uid", info
->created_by_uid
);
258 jsonw_uint_field(json_wtr
, "bytes_xlated", info
->xlated_prog_len
);
260 if (info
->jited_prog_len
) {
261 jsonw_bool_field(json_wtr
, "jited", true);
262 jsonw_uint_field(json_wtr
, "bytes_jited", info
->jited_prog_len
);
264 jsonw_bool_field(json_wtr
, "jited", false);
267 memlock
= get_fdinfo(fd
, "memlock");
269 jsonw_int_field(json_wtr
, "bytes_memlock", atoi(memlock
));
272 if (info
->nr_map_ids
)
273 show_prog_maps(fd
, info
->nr_map_ids
);
275 if (!hash_empty(prog_table
.table
)) {
276 struct pinned_obj
*obj
;
278 jsonw_name(json_wtr
, "pinned");
279 jsonw_start_array(json_wtr
);
280 hash_for_each_possible(prog_table
.table
, obj
, hash
, info
->id
) {
281 if (obj
->id
== info
->id
)
282 jsonw_string(json_wtr
, obj
->path
);
284 jsonw_end_array(json_wtr
);
287 jsonw_end_object(json_wtr
);
290 static void print_prog_plain(struct bpf_prog_info
*info
, int fd
)
294 printf("%u: ", info
->id
);
295 if (info
->type
< ARRAY_SIZE(prog_type_name
))
296 printf("%s ", prog_type_name
[info
->type
]);
298 printf("type %u ", info
->type
);
301 printf("name %s ", info
->name
);
304 fprint_hex(stdout
, info
->tag
, BPF_TAG_SIZE
, "");
307 if (info
->status
& BPF_PROG_STATUS_DEV_BOUND
) {
310 char name
[IF_NAMESIZE
];
312 if (!if_indextoname(info
->ifindex
, name
))
313 printf("ifindex:%d ", info
->ifindex
);
322 if (info
->load_time
) {
325 print_boot_time(info
->load_time
, buf
, sizeof(buf
));
327 /* Piggy back on load_time, since 0 uid is a valid one */
328 printf("\tloaded_at %s uid %u\n", buf
, info
->created_by_uid
);
331 printf("\txlated %uB", info
->xlated_prog_len
);
333 if (info
->jited_prog_len
)
334 printf(" jited %uB", info
->jited_prog_len
);
336 printf(" not jited");
338 memlock
= get_fdinfo(fd
, "memlock");
340 printf(" memlock %sB", memlock
);
343 if (info
->nr_map_ids
)
344 show_prog_maps(fd
, info
->nr_map_ids
);
346 if (!hash_empty(prog_table
.table
)) {
347 struct pinned_obj
*obj
;
350 hash_for_each_possible(prog_table
.table
, obj
, hash
, info
->id
) {
351 if (obj
->id
== info
->id
)
352 printf("\tpinned %s\n", obj
->path
);
359 static int show_prog(int fd
)
361 struct bpf_prog_info info
= {};
362 __u32 len
= sizeof(info
);
365 err
= bpf_obj_get_info_by_fd(fd
, &info
, &len
);
367 p_err("can't get prog info: %s", strerror(errno
));
372 print_prog_json(&info
, fd
);
374 print_prog_plain(&info
, fd
);
379 static int do_show(int argc
, char **argv
)
386 build_pinned_obj_table(&prog_table
, BPF_OBJ_PROG
);
389 fd
= prog_parse_fd(&argc
, &argv
);
393 return show_prog(fd
);
400 jsonw_start_array(json_wtr
);
402 err
= bpf_prog_get_next_id(id
, &id
);
404 if (errno
== ENOENT
) {
408 p_err("can't get next program: %s%s", strerror(errno
),
409 errno
== EINVAL
? " -- kernel too old?" : "");
414 fd
= bpf_prog_get_fd_by_id(id
);
416 p_err("can't get prog by id (%u): %s",
417 id
, strerror(errno
));
429 jsonw_end_array(json_wtr
);
434 static void print_insn(struct bpf_verifier_env
*env
, const char *fmt
, ...)
443 static void dump_xlated_plain(void *buf
, unsigned int len
, bool opcodes
)
445 struct bpf_insn
*insn
= buf
;
446 bool double_insn
= false;
449 for (i
= 0; i
< len
/ sizeof(*insn
); i
++) {
455 double_insn
= insn
[i
].code
== (BPF_LD
| BPF_IMM
| BPF_DW
);
458 print_bpf_insn(print_insn
, NULL
, insn
+ i
, true);
462 fprint_hex(stdout
, insn
+ i
, 8, " ");
463 if (double_insn
&& i
< len
- 1) {
465 fprint_hex(stdout
, insn
+ i
+ 1, 8, " ");
472 static void print_insn_json(struct bpf_verifier_env
*env
, const char *fmt
, ...)
474 unsigned int l
= strlen(fmt
);
480 strncpy(chomped_fmt
, fmt
, l
- 1);
481 chomped_fmt
[l
- 1] = '\0';
483 jsonw_vprintf_enquote(json_wtr
, chomped_fmt
, args
);
487 static void dump_xlated_json(void *buf
, unsigned int len
, bool opcodes
)
489 struct bpf_insn
*insn
= buf
;
490 bool double_insn
= false;
493 jsonw_start_array(json_wtr
);
494 for (i
= 0; i
< len
/ sizeof(*insn
); i
++) {
499 double_insn
= insn
[i
].code
== (BPF_LD
| BPF_IMM
| BPF_DW
);
501 jsonw_start_object(json_wtr
);
502 jsonw_name(json_wtr
, "disasm");
503 print_bpf_insn(print_insn_json
, NULL
, insn
+ i
, true);
506 jsonw_name(json_wtr
, "opcodes");
507 jsonw_start_object(json_wtr
);
509 jsonw_name(json_wtr
, "code");
510 jsonw_printf(json_wtr
, "\"0x%02hhx\"", insn
[i
].code
);
512 jsonw_name(json_wtr
, "src_reg");
513 jsonw_printf(json_wtr
, "\"0x%hhx\"", insn
[i
].src_reg
);
515 jsonw_name(json_wtr
, "dst_reg");
516 jsonw_printf(json_wtr
, "\"0x%hhx\"", insn
[i
].dst_reg
);
518 jsonw_name(json_wtr
, "off");
519 print_hex_data_json((uint8_t *)(&insn
[i
].off
), 2);
521 jsonw_name(json_wtr
, "imm");
522 if (double_insn
&& i
< len
- 1)
523 print_hex_data_json((uint8_t *)(&insn
[i
].imm
),
526 print_hex_data_json((uint8_t *)(&insn
[i
].imm
),
528 jsonw_end_object(json_wtr
);
530 jsonw_end_object(json_wtr
);
532 jsonw_end_array(json_wtr
);
535 static int do_dump(int argc
, char **argv
)
537 struct bpf_prog_info info
= {};
538 __u32 len
= sizeof(info
);
539 unsigned int buf_size
;
540 char *filepath
= NULL
;
541 bool opcodes
= false;
549 if (is_prefix(*argv
, "jited")) {
550 member_len
= &info
.jited_prog_len
;
551 member_ptr
= &info
.jited_prog_insns
;
552 } else if (is_prefix(*argv
, "xlated")) {
553 member_len
= &info
.xlated_prog_len
;
554 member_ptr
= &info
.xlated_prog_insns
;
556 p_err("expected 'xlated' or 'jited', got: %s", *argv
);
564 fd
= prog_parse_fd(&argc
, &argv
);
568 if (is_prefix(*argv
, "file")) {
571 p_err("expected file path");
577 } else if (is_prefix(*argv
, "opcodes")) {
587 err
= bpf_obj_get_info_by_fd(fd
, &info
, &len
);
589 p_err("can't get prog info: %s", strerror(errno
));
594 p_info("no instructions returned");
599 buf_size
= *member_len
;
601 buf
= malloc(buf_size
);
603 p_err("mem alloc failed");
608 memset(&info
, 0, sizeof(info
));
610 *member_ptr
= ptr_to_u64(buf
);
611 *member_len
= buf_size
;
613 err
= bpf_obj_get_info_by_fd(fd
, &info
, &len
);
616 p_err("can't get prog info: %s", strerror(errno
));
620 if (*member_len
> buf_size
) {
621 p_err("too many instructions returned");
626 fd
= open(filepath
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600);
628 p_err("can't open file %s: %s", filepath
,
633 n
= write(fd
, buf
, *member_len
);
635 if (n
!= *member_len
) {
636 p_err("error writing output file: %s",
637 n
< 0 ? strerror(errno
) : "short write");
641 if (member_len
== &info
.jited_prog_len
)
642 disasm_print_insn(buf
, *member_len
, opcodes
);
645 dump_xlated_json(buf
, *member_len
, opcodes
);
647 dump_xlated_plain(buf
, *member_len
, opcodes
);
659 static int do_pin(int argc
, char **argv
)
663 err
= do_pin_any(argc
, argv
, bpf_prog_get_fd_by_id
);
664 if (!err
&& json_output
)
665 jsonw_null(json_wtr
);
669 static int do_help(int argc
, char **argv
)
672 jsonw_null(json_wtr
);
677 "Usage: %s %s show [PROG]\n"
678 " %s %s dump xlated PROG [{ file FILE | opcodes }]\n"
679 " %s %s dump jited PROG [{ file FILE | opcodes }]\n"
680 " %s %s pin PROG FILE\n"
683 " " HELP_SPEC_PROGRAM
"\n"
684 " " HELP_SPEC_OPTIONS
"\n"
686 bin_name
, argv
[-2], bin_name
, argv
[-2], bin_name
, argv
[-2],
687 bin_name
, argv
[-2], bin_name
, argv
[-2]);
692 static const struct cmd cmds
[] = {
700 int do_prog(int argc
, char **argv
)
702 return cmd_select(cmds
, argc
, argv
, do_help
);