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> */
44 #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->load_time) {
236 print_boot_time(info->load_time, buf, sizeof(buf));
238 /* Piggy back on load_time, since 0 uid is a valid one */
239 jsonw_string_field(json_wtr, "loaded_at", buf);
240 jsonw_uint_field(json_wtr, "uid", info->created_by_uid);
243 jsonw_uint_field(json_wtr, "bytes_xlated", info->xlated_prog_len);
245 if (info->jited_prog_len) {
246 jsonw_bool_field(json_wtr, "jited", true);
247 jsonw_uint_field(json_wtr, "bytes_jited", info->jited_prog_len);
249 jsonw_bool_field(json_wtr, "jited", false);
252 memlock = get_fdinfo(fd, "memlock");
254 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
257 if (info->nr_map_ids)
258 show_prog_maps(fd, info->nr_map_ids);
260 if (!hash_empty(prog_table.table)) {
261 struct pinned_obj *obj;
263 jsonw_name(json_wtr, "pinned");
264 jsonw_start_array(json_wtr);
265 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
266 if (obj->id == info->id)
267 jsonw_string(json_wtr, obj->path);
269 jsonw_end_array(json_wtr);
272 jsonw_end_object(json_wtr);
275 static void print_prog_plain(struct bpf_prog_info *info, int fd)
279 printf("%u: ", info->id);
280 if (info->type < ARRAY_SIZE(prog_type_name))
281 printf("%s ", prog_type_name[info->type]);
283 printf("type %u ", info->type);
286 printf("name %s ", info->name);
289 fprint_hex(stdout, info->tag, BPF_TAG_SIZE, "");
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;
320 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
321 if (obj->id == info->id)
322 printf("\tpinned %s\n", obj->path);
329 static int show_prog(int fd)
331 struct bpf_prog_info info = {};
332 __u32 len = sizeof(info);
335 err = bpf_obj_get_info_by_fd(fd, &info, &len);
337 p_err("can't get prog info: %s", strerror(errno));
342 print_prog_json(&info, fd);
344 print_prog_plain(&info, fd);
349 static int do_show(int argc, char **argv)
356 build_pinned_obj_table(&prog_table, BPF_OBJ_PROG);
359 fd = prog_parse_fd(&argc, &argv);
363 return show_prog(fd);
370 jsonw_start_array(json_wtr);
372 err = bpf_prog_get_next_id(id, &id);
374 if (errno == ENOENT) {
378 p_err("can't get next program: %s%s", strerror(errno),
379 errno == EINVAL ? " -- kernel too old?" : "");
384 fd = bpf_prog_get_fd_by_id(id);
386 p_err("can't get prog by id (%u): %s",
387 id, strerror(errno));
399 jsonw_end_array(json_wtr);
404 static void print_insn(struct bpf_verifier_env *env, const char *fmt, ...)
413 static void dump_xlated_plain(void *buf, unsigned int len, bool opcodes)
415 struct bpf_insn *insn = buf;
416 bool double_insn = false;
419 for (i = 0; i < len / sizeof(*insn); i++) {
425 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
428 print_bpf_insn(print_insn, NULL, insn + i, true);
432 fprint_hex(stdout, insn + i, 8, " ");
433 if (double_insn && i < len - 1) {
435 fprint_hex(stdout, insn + i + 1, 8, " ");
442 static void print_insn_json(struct bpf_verifier_env *env, const char *fmt, ...)
444 unsigned int l = strlen(fmt);
450 strncpy(chomped_fmt, fmt, l - 1);
451 chomped_fmt[l - 1] = '\0';
453 jsonw_vprintf_enquote(json_wtr, chomped_fmt, args);
457 static void dump_xlated_json(void *buf, unsigned int len, bool opcodes)
459 struct bpf_insn *insn = buf;
460 bool double_insn = false;
463 jsonw_start_array(json_wtr);
464 for (i = 0; i < len / sizeof(*insn); i++) {
469 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
471 jsonw_start_object(json_wtr);
472 jsonw_name(json_wtr, "disasm");
473 print_bpf_insn(print_insn_json, NULL, insn + i, true);
476 jsonw_name(json_wtr, "opcodes");
477 jsonw_start_object(json_wtr);
479 jsonw_name(json_wtr, "code");
480 jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code);
482 jsonw_name(json_wtr, "src_reg");
483 jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg);
485 jsonw_name(json_wtr, "dst_reg");
486 jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg);
488 jsonw_name(json_wtr, "off");
489 print_hex_data_json((uint8_t *)(&insn[i].off), 2);
491 jsonw_name(json_wtr, "imm");
492 if (double_insn && i < len - 1)
493 print_hex_data_json((uint8_t *)(&insn[i].imm),
496 print_hex_data_json((uint8_t *)(&insn[i].imm),
498 jsonw_end_object(json_wtr);
500 jsonw_end_object(json_wtr);
502 jsonw_end_array(json_wtr);
505 static int do_dump(int argc, char **argv)
507 struct bpf_prog_info info = {};
508 __u32 len = sizeof(info);
509 unsigned int buf_size;
510 char *filepath = NULL;
511 bool opcodes = false;
519 if (is_prefix(*argv, "jited")) {
520 member_len = &info.jited_prog_len;
521 member_ptr = &info.jited_prog_insns;
522 } else if (is_prefix(*argv, "xlated")) {
523 member_len = &info.xlated_prog_len;
524 member_ptr = &info.xlated_prog_insns;
526 p_err("expected 'xlated' or 'jited', got: %s", *argv);
534 fd = prog_parse_fd(&argc, &argv);
538 if (is_prefix(*argv, "file")) {
541 p_err("expected file path");
547 } else if (is_prefix(*argv, "opcodes")) {
557 err = bpf_obj_get_info_by_fd(fd, &info, &len);
559 p_err("can't get prog info: %s", strerror(errno));
564 p_info("no instructions returned");
569 buf_size = *member_len;
571 buf = malloc(buf_size);
573 p_err("mem alloc failed");
578 memset(&info, 0, sizeof(info));
580 *member_ptr = ptr_to_u64(buf);
581 *member_len = buf_size;
583 err = bpf_obj_get_info_by_fd(fd, &info, &len);
586 p_err("can't get prog info: %s", strerror(errno));
590 if (*member_len > buf_size) {
591 p_err("too many instructions returned");
596 fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0600);
598 p_err("can't open file %s: %s", filepath,
603 n = write(fd, buf, *member_len);
605 if (n != *member_len) {
606 p_err("error writing output file: %s",
607 n < 0 ? strerror(errno) : "short write");
611 if (member_len == &info.jited_prog_len)
612 disasm_print_insn(buf, *member_len, opcodes);
615 dump_xlated_json(buf, *member_len, opcodes);
617 dump_xlated_plain(buf, *member_len, opcodes);
629 static int do_pin(int argc, char **argv)
633 err = do_pin_any(argc, argv, bpf_prog_get_fd_by_id);
634 if (!err && json_output)
635 jsonw_null(json_wtr);
639 static int do_load(int argc, char **argv)
641 struct bpf_object *obj;
647 if (bpf_prog_load(argv[0], BPF_PROG_TYPE_UNSPEC, &obj, &prog_fd)) {
648 p_err("failed to load program\n");
652 if (do_pin_fd(prog_fd, argv[1])) {
653 p_err("failed to pin program\n");
658 jsonw_null(json_wtr);
663 static int do_help(int argc, char **argv)
666 jsonw_null(json_wtr);
671 "Usage: %s %s show [PROG]\n"
672 " %s %s dump xlated PROG [{ file FILE | opcodes }]\n"
673 " %s %s dump jited PROG [{ file FILE | opcodes }]\n"
674 " %s %s pin PROG FILE\n"
675 " %s %s load OBJ FILE\n"
678 " " HELP_SPEC_PROGRAM "\n"
679 " " HELP_SPEC_OPTIONS "\n"
681 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
682 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2]);
687 static const struct cmd cmds[] = {
696 int do_prog(int argc, char **argv)
698 return cmd_select(cmds, argc, argv, do_help);