xref: /openbmc/linux/tools/bpf/bpftool/prog.c (revision 5ef12cb4)
1 /*
2  * Copyright (C) 2017 Netronome Systems, Inc.
3  *
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.
8  *
9  * The BSD 2-Clause License:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      1. Redistributions of source code must retain the above
16  *         copyright notice, this list of conditions and the following
17  *         disclaimer.
18  *
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.
23  *
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
31  * SOFTWARE.
32  */
33 
34 /* Author: Jakub Kicinski <kubakici@wp.pl> */
35 
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <stdarg.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <time.h>
43 #include <unistd.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 
47 #include <bpf.h>
48 #include <libbpf.h>
49 
50 #include "cfg.h"
51 #include "main.h"
52 #include "xlated_dumper.h"
53 
54 static const char * const prog_type_name[] = {
55 	[BPF_PROG_TYPE_UNSPEC]		= "unspec",
56 	[BPF_PROG_TYPE_SOCKET_FILTER]	= "socket_filter",
57 	[BPF_PROG_TYPE_KPROBE]		= "kprobe",
58 	[BPF_PROG_TYPE_SCHED_CLS]	= "sched_cls",
59 	[BPF_PROG_TYPE_SCHED_ACT]	= "sched_act",
60 	[BPF_PROG_TYPE_TRACEPOINT]	= "tracepoint",
61 	[BPF_PROG_TYPE_XDP]		= "xdp",
62 	[BPF_PROG_TYPE_PERF_EVENT]	= "perf_event",
63 	[BPF_PROG_TYPE_CGROUP_SKB]	= "cgroup_skb",
64 	[BPF_PROG_TYPE_CGROUP_SOCK]	= "cgroup_sock",
65 	[BPF_PROG_TYPE_LWT_IN]		= "lwt_in",
66 	[BPF_PROG_TYPE_LWT_OUT]		= "lwt_out",
67 	[BPF_PROG_TYPE_LWT_XMIT]	= "lwt_xmit",
68 	[BPF_PROG_TYPE_SOCK_OPS]	= "sock_ops",
69 	[BPF_PROG_TYPE_SK_SKB]		= "sk_skb",
70 	[BPF_PROG_TYPE_CGROUP_DEVICE]	= "cgroup_device",
71 };
72 
73 static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)
74 {
75 	struct timespec real_time_ts, boot_time_ts;
76 	time_t wallclock_secs;
77 	struct tm load_tm;
78 
79 	buf[--size] = '\0';
80 
81 	if (clock_gettime(CLOCK_REALTIME, &real_time_ts) ||
82 	    clock_gettime(CLOCK_BOOTTIME, &boot_time_ts)) {
83 		perror("Can't read clocks");
84 		snprintf(buf, size, "%llu", nsecs / 1000000000);
85 		return;
86 	}
87 
88 	wallclock_secs = (real_time_ts.tv_sec - boot_time_ts.tv_sec) +
89 		nsecs / 1000000000;
90 
91 	if (!localtime_r(&wallclock_secs, &load_tm)) {
92 		snprintf(buf, size, "%llu", nsecs / 1000000000);
93 		return;
94 	}
95 
96 	strftime(buf, size, "%b %d/%H:%M", &load_tm);
97 }
98 
99 static int prog_fd_by_tag(unsigned char *tag)
100 {
101 	struct bpf_prog_info info = {};
102 	__u32 len = sizeof(info);
103 	unsigned int id = 0;
104 	int err;
105 	int fd;
106 
107 	while (true) {
108 		err = bpf_prog_get_next_id(id, &id);
109 		if (err) {
110 			p_err("%s", strerror(errno));
111 			return -1;
112 		}
113 
114 		fd = bpf_prog_get_fd_by_id(id);
115 		if (fd < 0) {
116 			p_err("can't get prog by id (%u): %s",
117 			      id, strerror(errno));
118 			return -1;
119 		}
120 
121 		err = bpf_obj_get_info_by_fd(fd, &info, &len);
122 		if (err) {
123 			p_err("can't get prog info (%u): %s",
124 			      id, strerror(errno));
125 			close(fd);
126 			return -1;
127 		}
128 
129 		if (!memcmp(tag, info.tag, BPF_TAG_SIZE))
130 			return fd;
131 
132 		close(fd);
133 	}
134 }
135 
136 int prog_parse_fd(int *argc, char ***argv)
137 {
138 	int fd;
139 
140 	if (is_prefix(**argv, "id")) {
141 		unsigned int id;
142 		char *endptr;
143 
144 		NEXT_ARGP();
145 
146 		id = strtoul(**argv, &endptr, 0);
147 		if (*endptr) {
148 			p_err("can't parse %s as ID", **argv);
149 			return -1;
150 		}
151 		NEXT_ARGP();
152 
153 		fd = bpf_prog_get_fd_by_id(id);
154 		if (fd < 0)
155 			p_err("get by id (%u): %s", id, strerror(errno));
156 		return fd;
157 	} else if (is_prefix(**argv, "tag")) {
158 		unsigned char tag[BPF_TAG_SIZE];
159 
160 		NEXT_ARGP();
161 
162 		if (sscanf(**argv, BPF_TAG_FMT, tag, tag + 1, tag + 2,
163 			   tag + 3, tag + 4, tag + 5, tag + 6, tag + 7)
164 		    != BPF_TAG_SIZE) {
165 			p_err("can't parse tag");
166 			return -1;
167 		}
168 		NEXT_ARGP();
169 
170 		return prog_fd_by_tag(tag);
171 	} else if (is_prefix(**argv, "pinned")) {
172 		char *path;
173 
174 		NEXT_ARGP();
175 
176 		path = **argv;
177 		NEXT_ARGP();
178 
179 		return open_obj_pinned_any(path, BPF_OBJ_PROG);
180 	}
181 
182 	p_err("expected 'id', 'tag' or 'pinned', got: '%s'?", **argv);
183 	return -1;
184 }
185 
186 static void show_prog_maps(int fd, u32 num_maps)
187 {
188 	struct bpf_prog_info info = {};
189 	__u32 len = sizeof(info);
190 	__u32 map_ids[num_maps];
191 	unsigned int i;
192 	int err;
193 
194 	info.nr_map_ids = num_maps;
195 	info.map_ids = ptr_to_u64(map_ids);
196 
197 	err = bpf_obj_get_info_by_fd(fd, &info, &len);
198 	if (err || !info.nr_map_ids)
199 		return;
200 
201 	if (json_output) {
202 		jsonw_name(json_wtr, "map_ids");
203 		jsonw_start_array(json_wtr);
204 		for (i = 0; i < info.nr_map_ids; i++)
205 			jsonw_uint(json_wtr, map_ids[i]);
206 		jsonw_end_array(json_wtr);
207 	} else {
208 		printf("  map_ids ");
209 		for (i = 0; i < info.nr_map_ids; i++)
210 			printf("%u%s", map_ids[i],
211 			       i == info.nr_map_ids - 1 ? "" : ",");
212 	}
213 }
214 
215 static void print_prog_json(struct bpf_prog_info *info, int fd)
216 {
217 	char *memlock;
218 
219 	jsonw_start_object(json_wtr);
220 	jsonw_uint_field(json_wtr, "id", info->id);
221 	if (info->type < ARRAY_SIZE(prog_type_name))
222 		jsonw_string_field(json_wtr, "type",
223 				   prog_type_name[info->type]);
224 	else
225 		jsonw_uint_field(json_wtr, "type", info->type);
226 
227 	if (*info->name)
228 		jsonw_string_field(json_wtr, "name", info->name);
229 
230 	jsonw_name(json_wtr, "tag");
231 	jsonw_printf(json_wtr, "\"" BPF_TAG_FMT "\"",
232 		     info->tag[0], info->tag[1], info->tag[2], info->tag[3],
233 		     info->tag[4], info->tag[5], info->tag[6], info->tag[7]);
234 
235 	print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
236 
237 	if (info->load_time) {
238 		char buf[32];
239 
240 		print_boot_time(info->load_time, buf, sizeof(buf));
241 
242 		/* Piggy back on load_time, since 0 uid is a valid one */
243 		jsonw_string_field(json_wtr, "loaded_at", buf);
244 		jsonw_uint_field(json_wtr, "uid", info->created_by_uid);
245 	}
246 
247 	jsonw_uint_field(json_wtr, "bytes_xlated", info->xlated_prog_len);
248 
249 	if (info->jited_prog_len) {
250 		jsonw_bool_field(json_wtr, "jited", true);
251 		jsonw_uint_field(json_wtr, "bytes_jited", info->jited_prog_len);
252 	} else {
253 		jsonw_bool_field(json_wtr, "jited", false);
254 	}
255 
256 	memlock = get_fdinfo(fd, "memlock");
257 	if (memlock)
258 		jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
259 	free(memlock);
260 
261 	if (info->nr_map_ids)
262 		show_prog_maps(fd, info->nr_map_ids);
263 
264 	if (!hash_empty(prog_table.table)) {
265 		struct pinned_obj *obj;
266 
267 		jsonw_name(json_wtr, "pinned");
268 		jsonw_start_array(json_wtr);
269 		hash_for_each_possible(prog_table.table, obj, hash, info->id) {
270 			if (obj->id == info->id)
271 				jsonw_string(json_wtr, obj->path);
272 		}
273 		jsonw_end_array(json_wtr);
274 	}
275 
276 	jsonw_end_object(json_wtr);
277 }
278 
279 static void print_prog_plain(struct bpf_prog_info *info, int fd)
280 {
281 	char *memlock;
282 
283 	printf("%u: ", info->id);
284 	if (info->type < ARRAY_SIZE(prog_type_name))
285 		printf("%s  ", prog_type_name[info->type]);
286 	else
287 		printf("type %u  ", info->type);
288 
289 	if (*info->name)
290 		printf("name %s  ", info->name);
291 
292 	printf("tag ");
293 	fprint_hex(stdout, info->tag, BPF_TAG_SIZE, "");
294 	print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
295 	printf("\n");
296 
297 	if (info->load_time) {
298 		char buf[32];
299 
300 		print_boot_time(info->load_time, buf, sizeof(buf));
301 
302 		/* Piggy back on load_time, since 0 uid is a valid one */
303 		printf("\tloaded_at %s  uid %u\n", buf, info->created_by_uid);
304 	}
305 
306 	printf("\txlated %uB", info->xlated_prog_len);
307 
308 	if (info->jited_prog_len)
309 		printf("  jited %uB", info->jited_prog_len);
310 	else
311 		printf("  not jited");
312 
313 	memlock = get_fdinfo(fd, "memlock");
314 	if (memlock)
315 		printf("  memlock %sB", memlock);
316 	free(memlock);
317 
318 	if (info->nr_map_ids)
319 		show_prog_maps(fd, info->nr_map_ids);
320 
321 	if (!hash_empty(prog_table.table)) {
322 		struct pinned_obj *obj;
323 
324 		printf("\n");
325 		hash_for_each_possible(prog_table.table, obj, hash, info->id) {
326 			if (obj->id == info->id)
327 				printf("\tpinned %s\n", obj->path);
328 		}
329 	}
330 
331 	printf("\n");
332 }
333 
334 static int show_prog(int fd)
335 {
336 	struct bpf_prog_info info = {};
337 	__u32 len = sizeof(info);
338 	int err;
339 
340 	err = bpf_obj_get_info_by_fd(fd, &info, &len);
341 	if (err) {
342 		p_err("can't get prog info: %s", strerror(errno));
343 		return -1;
344 	}
345 
346 	if (json_output)
347 		print_prog_json(&info, fd);
348 	else
349 		print_prog_plain(&info, fd);
350 
351 	return 0;
352 }
353 
354 static int do_show(int argc, char **argv)
355 {
356 	__u32 id = 0;
357 	int err;
358 	int fd;
359 
360 	if (show_pinned)
361 		build_pinned_obj_table(&prog_table, BPF_OBJ_PROG);
362 
363 	if (argc == 2) {
364 		fd = prog_parse_fd(&argc, &argv);
365 		if (fd < 0)
366 			return -1;
367 
368 		return show_prog(fd);
369 	}
370 
371 	if (argc)
372 		return BAD_ARG();
373 
374 	if (json_output)
375 		jsonw_start_array(json_wtr);
376 	while (true) {
377 		err = bpf_prog_get_next_id(id, &id);
378 		if (err) {
379 			if (errno == ENOENT) {
380 				err = 0;
381 				break;
382 			}
383 			p_err("can't get next program: %s%s", strerror(errno),
384 			      errno == EINVAL ? " -- kernel too old?" : "");
385 			err = -1;
386 			break;
387 		}
388 
389 		fd = bpf_prog_get_fd_by_id(id);
390 		if (fd < 0) {
391 			if (errno == ENOENT)
392 				continue;
393 			p_err("can't get prog by id (%u): %s",
394 			      id, strerror(errno));
395 			err = -1;
396 			break;
397 		}
398 
399 		err = show_prog(fd);
400 		close(fd);
401 		if (err)
402 			break;
403 	}
404 
405 	if (json_output)
406 		jsonw_end_array(json_wtr);
407 
408 	return err;
409 }
410 
411 static int do_dump(int argc, char **argv)
412 {
413 	struct bpf_prog_info info = {};
414 	struct dump_data dd = {};
415 	__u32 len = sizeof(info);
416 	unsigned int buf_size;
417 	char *filepath = NULL;
418 	bool opcodes = false;
419 	bool visual = false;
420 	unsigned char *buf;
421 	__u32 *member_len;
422 	__u64 *member_ptr;
423 	ssize_t n;
424 	int err;
425 	int fd;
426 
427 	if (is_prefix(*argv, "jited")) {
428 		member_len = &info.jited_prog_len;
429 		member_ptr = &info.jited_prog_insns;
430 	} else if (is_prefix(*argv, "xlated")) {
431 		member_len = &info.xlated_prog_len;
432 		member_ptr = &info.xlated_prog_insns;
433 	} else {
434 		p_err("expected 'xlated' or 'jited', got: %s", *argv);
435 		return -1;
436 	}
437 	NEXT_ARG();
438 
439 	if (argc < 2)
440 		usage();
441 
442 	fd = prog_parse_fd(&argc, &argv);
443 	if (fd < 0)
444 		return -1;
445 
446 	if (is_prefix(*argv, "file")) {
447 		NEXT_ARG();
448 		if (!argc) {
449 			p_err("expected file path");
450 			return -1;
451 		}
452 
453 		filepath = *argv;
454 		NEXT_ARG();
455 	} else if (is_prefix(*argv, "opcodes")) {
456 		opcodes = true;
457 		NEXT_ARG();
458 	} else if (is_prefix(*argv, "visual")) {
459 		visual = true;
460 		NEXT_ARG();
461 	}
462 
463 	if (argc) {
464 		usage();
465 		return -1;
466 	}
467 
468 	err = bpf_obj_get_info_by_fd(fd, &info, &len);
469 	if (err) {
470 		p_err("can't get prog info: %s", strerror(errno));
471 		return -1;
472 	}
473 
474 	if (!*member_len) {
475 		p_info("no instructions returned");
476 		close(fd);
477 		return 0;
478 	}
479 
480 	buf_size = *member_len;
481 
482 	buf = malloc(buf_size);
483 	if (!buf) {
484 		p_err("mem alloc failed");
485 		close(fd);
486 		return -1;
487 	}
488 
489 	memset(&info, 0, sizeof(info));
490 
491 	*member_ptr = ptr_to_u64(buf);
492 	*member_len = buf_size;
493 
494 	err = bpf_obj_get_info_by_fd(fd, &info, &len);
495 	close(fd);
496 	if (err) {
497 		p_err("can't get prog info: %s", strerror(errno));
498 		goto err_free;
499 	}
500 
501 	if (*member_len > buf_size) {
502 		p_err("too many instructions returned");
503 		goto err_free;
504 	}
505 
506 	if ((member_len == &info.jited_prog_len &&
507 	     info.jited_prog_insns == 0) ||
508 	    (member_len == &info.xlated_prog_len &&
509 	     info.xlated_prog_insns == 0)) {
510 		p_err("error retrieving insn dump: kernel.kptr_restrict set?");
511 		goto err_free;
512 	}
513 
514 	if (filepath) {
515 		fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0600);
516 		if (fd < 0) {
517 			p_err("can't open file %s: %s", filepath,
518 			      strerror(errno));
519 			goto err_free;
520 		}
521 
522 		n = write(fd, buf, *member_len);
523 		close(fd);
524 		if (n != *member_len) {
525 			p_err("error writing output file: %s",
526 			      n < 0 ? strerror(errno) : "short write");
527 			goto err_free;
528 		}
529 
530 		if (json_output)
531 			jsonw_null(json_wtr);
532 	} else if (member_len == &info.jited_prog_len) {
533 		const char *name = NULL;
534 
535 		if (info.ifindex) {
536 			name = ifindex_to_bfd_name_ns(info.ifindex,
537 						      info.netns_dev,
538 						      info.netns_ino);
539 			if (!name)
540 				goto err_free;
541 		}
542 
543 		disasm_print_insn(buf, *member_len, opcodes, name);
544 	} else if (visual) {
545 		if (json_output)
546 			jsonw_null(json_wtr);
547 		else
548 			dump_xlated_cfg(buf, *member_len);
549 	} else {
550 		kernel_syms_load(&dd);
551 		if (json_output)
552 			dump_xlated_json(&dd, buf, *member_len, opcodes);
553 		else
554 			dump_xlated_plain(&dd, buf, *member_len, opcodes);
555 		kernel_syms_destroy(&dd);
556 	}
557 
558 	free(buf);
559 	return 0;
560 
561 err_free:
562 	free(buf);
563 	return -1;
564 }
565 
566 static int do_pin(int argc, char **argv)
567 {
568 	int err;
569 
570 	err = do_pin_any(argc, argv, bpf_prog_get_fd_by_id);
571 	if (!err && json_output)
572 		jsonw_null(json_wtr);
573 	return err;
574 }
575 
576 static int do_load(int argc, char **argv)
577 {
578 	struct bpf_object *obj;
579 	int prog_fd;
580 
581 	if (argc != 2)
582 		usage();
583 
584 	if (bpf_prog_load(argv[0], BPF_PROG_TYPE_UNSPEC, &obj, &prog_fd)) {
585 		p_err("failed to load program");
586 		return -1;
587 	}
588 
589 	if (do_pin_fd(prog_fd, argv[1])) {
590 		p_err("failed to pin program");
591 		return -1;
592 	}
593 
594 	if (json_output)
595 		jsonw_null(json_wtr);
596 
597 	return 0;
598 }
599 
600 static int do_help(int argc, char **argv)
601 {
602 	if (json_output) {
603 		jsonw_null(json_wtr);
604 		return 0;
605 	}
606 
607 	fprintf(stderr,
608 		"Usage: %s %s { show | list } [PROG]\n"
609 		"       %s %s dump xlated PROG [{ file FILE | opcodes | visual }]\n"
610 		"       %s %s dump jited  PROG [{ file FILE | opcodes }]\n"
611 		"       %s %s pin   PROG FILE\n"
612 		"       %s %s load  OBJ  FILE\n"
613 		"       %s %s help\n"
614 		"\n"
615 		"       " HELP_SPEC_PROGRAM "\n"
616 		"       " HELP_SPEC_OPTIONS "\n"
617 		"",
618 		bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
619 		bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2]);
620 
621 	return 0;
622 }
623 
624 static const struct cmd cmds[] = {
625 	{ "show",	do_show },
626 	{ "list",	do_show },
627 	{ "help",	do_help },
628 	{ "dump",	do_dump },
629 	{ "pin",	do_pin },
630 	{ "load",	do_load },
631 	{ 0 }
632 };
633 
634 int do_prog(int argc, char **argv)
635 {
636 	return cmd_select(cmds, argc, argv, do_help);
637 }
638