xref: /linux/tools/bpf/bpftool/link.c (revision 84b9b44b) 
1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2020 Facebook */
3 
4 #include <errno.h>
5 #include <linux/err.h>
6 #include <linux/netfilter.h>
7 #include <linux/netfilter_arp.h>
8 #include <net/if.h>
9 #include <stdio.h>
10 #include <unistd.h>
11 
12 #include <bpf/bpf.h>
13 #include <bpf/hashmap.h>
14 
15 #include "json_writer.h"
16 #include "main.h"
17 
18 static struct hashmap *link_table;
19 
20 static int link_parse_fd(int *argc, char ***argv)
21 {
22 	int fd;
23 
24 	if (is_prefix(**argv, "id")) {
25 		unsigned int id;
26 		char *endptr;
27 
28 		NEXT_ARGP();
29 
30 		id = strtoul(**argv, &endptr, 0);
31 		if (*endptr) {
32 			p_err("can't parse %s as ID", **argv);
33 			return -1;
34 		}
35 		NEXT_ARGP();
36 
37 		fd = bpf_link_get_fd_by_id(id);
38 		if (fd < 0)
39 			p_err("failed to get link with ID %d: %s", id, strerror(errno));
40 		return fd;
41 	} else if (is_prefix(**argv, "pinned")) {
42 		char *path;
43 
44 		NEXT_ARGP();
45 
46 		path = **argv;
47 		NEXT_ARGP();
48 
49 		return open_obj_pinned_any(path, BPF_OBJ_LINK);
50 	}
51 
52 	p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
53 	return -1;
54 }
55 
56 static void
57 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)
58 {
59 	const char *link_type_str;
60 
61 	jsonw_uint_field(wtr, "id", info->id);
62 	link_type_str = libbpf_bpf_link_type_str(info->type);
63 	if (link_type_str)
64 		jsonw_string_field(wtr, "type", link_type_str);
65 	else
66 		jsonw_uint_field(wtr, "type", info->type);
67 
68 	jsonw_uint_field(json_wtr, "prog_id", info->prog_id);
69 }
70 
71 static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr)
72 {
73 	const char *attach_type_str;
74 
75 	attach_type_str = libbpf_bpf_attach_type_str(attach_type);
76 	if (attach_type_str)
77 		jsonw_string_field(wtr, "attach_type", attach_type_str);
78 	else
79 		jsonw_uint_field(wtr, "attach_type", attach_type);
80 }
81 
82 static bool is_iter_map_target(const char *target_name)
83 {
84 	return strcmp(target_name, "bpf_map_elem") == 0 ||
85 	       strcmp(target_name, "bpf_sk_storage_map") == 0;
86 }
87 
88 static bool is_iter_cgroup_target(const char *target_name)
89 {
90 	return strcmp(target_name, "cgroup") == 0;
91 }
92 
93 static const char *cgroup_order_string(__u32 order)
94 {
95 	switch (order) {
96 	case BPF_CGROUP_ITER_ORDER_UNSPEC:
97 		return "order_unspec";
98 	case BPF_CGROUP_ITER_SELF_ONLY:
99 		return "self_only";
100 	case BPF_CGROUP_ITER_DESCENDANTS_PRE:
101 		return "descendants_pre";
102 	case BPF_CGROUP_ITER_DESCENDANTS_POST:
103 		return "descendants_post";
104 	case BPF_CGROUP_ITER_ANCESTORS_UP:
105 		return "ancestors_up";
106 	default: /* won't happen */
107 		return "unknown";
108 	}
109 }
110 
111 static bool is_iter_task_target(const char *target_name)
112 {
113 	return strcmp(target_name, "task") == 0 ||
114 		strcmp(target_name, "task_file") == 0 ||
115 		strcmp(target_name, "task_vma") == 0;
116 }
117 
118 static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr)
119 {
120 	const char *target_name = u64_to_ptr(info->iter.target_name);
121 
122 	jsonw_string_field(wtr, "target_name", target_name);
123 
124 	if (is_iter_map_target(target_name))
125 		jsonw_uint_field(wtr, "map_id", info->iter.map.map_id);
126 	else if (is_iter_task_target(target_name)) {
127 		if (info->iter.task.tid)
128 			jsonw_uint_field(wtr, "tid", info->iter.task.tid);
129 		else if (info->iter.task.pid)
130 			jsonw_uint_field(wtr, "pid", info->iter.task.pid);
131 	}
132 
133 	if (is_iter_cgroup_target(target_name)) {
134 		jsonw_lluint_field(wtr, "cgroup_id", info->iter.cgroup.cgroup_id);
135 		jsonw_string_field(wtr, "order",
136 				   cgroup_order_string(info->iter.cgroup.order));
137 	}
138 }
139 
140 void netfilter_dump_json(const struct bpf_link_info *info, json_writer_t *wtr)
141 {
142 	jsonw_uint_field(json_wtr, "pf",
143 			 info->netfilter.pf);
144 	jsonw_uint_field(json_wtr, "hook",
145 			 info->netfilter.hooknum);
146 	jsonw_int_field(json_wtr, "prio",
147 			 info->netfilter.priority);
148 	jsonw_uint_field(json_wtr, "flags",
149 			 info->netfilter.flags);
150 }
151 
152 static int get_prog_info(int prog_id, struct bpf_prog_info *info)
153 {
154 	__u32 len = sizeof(*info);
155 	int err, prog_fd;
156 
157 	prog_fd = bpf_prog_get_fd_by_id(prog_id);
158 	if (prog_fd < 0)
159 		return prog_fd;
160 
161 	memset(info, 0, sizeof(*info));
162 	err = bpf_prog_get_info_by_fd(prog_fd, info, &len);
163 	if (err)
164 		p_err("can't get prog info: %s", strerror(errno));
165 	close(prog_fd);
166 	return err;
167 }
168 
169 static int show_link_close_json(int fd, struct bpf_link_info *info)
170 {
171 	struct bpf_prog_info prog_info;
172 	const char *prog_type_str;
173 	int err;
174 
175 	jsonw_start_object(json_wtr);
176 
177 	show_link_header_json(info, json_wtr);
178 
179 	switch (info->type) {
180 	case BPF_LINK_TYPE_RAW_TRACEPOINT:
181 		jsonw_string_field(json_wtr, "tp_name",
182 				   u64_to_ptr(info->raw_tracepoint.tp_name));
183 		break;
184 	case BPF_LINK_TYPE_TRACING:
185 		err = get_prog_info(info->prog_id, &prog_info);
186 		if (err)
187 			return err;
188 
189 		prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
190 		/* libbpf will return NULL for variants unknown to it. */
191 		if (prog_type_str)
192 			jsonw_string_field(json_wtr, "prog_type", prog_type_str);
193 		else
194 			jsonw_uint_field(json_wtr, "prog_type", prog_info.type);
195 
196 		show_link_attach_type_json(info->tracing.attach_type,
197 					   json_wtr);
198 		break;
199 	case BPF_LINK_TYPE_CGROUP:
200 		jsonw_lluint_field(json_wtr, "cgroup_id",
201 				   info->cgroup.cgroup_id);
202 		show_link_attach_type_json(info->cgroup.attach_type, json_wtr);
203 		break;
204 	case BPF_LINK_TYPE_ITER:
205 		show_iter_json(info, json_wtr);
206 		break;
207 	case BPF_LINK_TYPE_NETNS:
208 		jsonw_uint_field(json_wtr, "netns_ino",
209 				 info->netns.netns_ino);
210 		show_link_attach_type_json(info->netns.attach_type, json_wtr);
211 		break;
212 	case BPF_LINK_TYPE_NETFILTER:
213 		netfilter_dump_json(info, json_wtr);
214 		break;
215 
216 	default:
217 		break;
218 	}
219 
220 	if (!hashmap__empty(link_table)) {
221 		struct hashmap_entry *entry;
222 
223 		jsonw_name(json_wtr, "pinned");
224 		jsonw_start_array(json_wtr);
225 		hashmap__for_each_key_entry(link_table, entry, info->id)
226 			jsonw_string(json_wtr, entry->pvalue);
227 		jsonw_end_array(json_wtr);
228 	}
229 
230 	emit_obj_refs_json(refs_table, info->id, json_wtr);
231 
232 	jsonw_end_object(json_wtr);
233 
234 	return 0;
235 }
236 
237 static void show_link_header_plain(struct bpf_link_info *info)
238 {
239 	const char *link_type_str;
240 
241 	printf("%u: ", info->id);
242 	link_type_str = libbpf_bpf_link_type_str(info->type);
243 	if (link_type_str)
244 		printf("%s  ", link_type_str);
245 	else
246 		printf("type %u  ", info->type);
247 
248 	printf("prog %u  ", info->prog_id);
249 }
250 
251 static void show_link_attach_type_plain(__u32 attach_type)
252 {
253 	const char *attach_type_str;
254 
255 	attach_type_str = libbpf_bpf_attach_type_str(attach_type);
256 	if (attach_type_str)
257 		printf("attach_type %s  ", attach_type_str);
258 	else
259 		printf("attach_type %u  ", attach_type);
260 }
261 
262 static void show_iter_plain(struct bpf_link_info *info)
263 {
264 	const char *target_name = u64_to_ptr(info->iter.target_name);
265 
266 	printf("target_name %s  ", target_name);
267 
268 	if (is_iter_map_target(target_name))
269 		printf("map_id %u  ", info->iter.map.map_id);
270 	else if (is_iter_task_target(target_name)) {
271 		if (info->iter.task.tid)
272 			printf("tid %u ", info->iter.task.tid);
273 		else if (info->iter.task.pid)
274 			printf("pid %u ", info->iter.task.pid);
275 	}
276 
277 	if (is_iter_cgroup_target(target_name)) {
278 		printf("cgroup_id %llu  ", info->iter.cgroup.cgroup_id);
279 		printf("order %s  ",
280 		       cgroup_order_string(info->iter.cgroup.order));
281 	}
282 }
283 
284 static const char * const pf2name[] = {
285 	[NFPROTO_INET] = "inet",
286 	[NFPROTO_IPV4] = "ip",
287 	[NFPROTO_ARP] = "arp",
288 	[NFPROTO_NETDEV] = "netdev",
289 	[NFPROTO_BRIDGE] = "bridge",
290 	[NFPROTO_IPV6] = "ip6",
291 };
292 
293 static const char * const inethook2name[] = {
294 	[NF_INET_PRE_ROUTING] = "prerouting",
295 	[NF_INET_LOCAL_IN] = "input",
296 	[NF_INET_FORWARD] = "forward",
297 	[NF_INET_LOCAL_OUT] = "output",
298 	[NF_INET_POST_ROUTING] = "postrouting",
299 };
300 
301 static const char * const arphook2name[] = {
302 	[NF_ARP_IN] = "input",
303 	[NF_ARP_OUT] = "output",
304 };
305 
306 void netfilter_dump_plain(const struct bpf_link_info *info)
307 {
308 	const char *hookname = NULL, *pfname = NULL;
309 	unsigned int hook = info->netfilter.hooknum;
310 	unsigned int pf = info->netfilter.pf;
311 
312 	if (pf < ARRAY_SIZE(pf2name))
313 		pfname = pf2name[pf];
314 
315 	switch (pf) {
316 	case NFPROTO_BRIDGE: /* bridge shares numbers with enum nf_inet_hooks */
317 	case NFPROTO_IPV4:
318 	case NFPROTO_IPV6:
319 	case NFPROTO_INET:
320 		if (hook < ARRAY_SIZE(inethook2name))
321 			hookname = inethook2name[hook];
322 		break;
323 	case NFPROTO_ARP:
324 		if (hook < ARRAY_SIZE(arphook2name))
325 			hookname = arphook2name[hook];
326 	default:
327 		break;
328 	}
329 
330 	if (pfname)
331 		printf("\n\t%s", pfname);
332 	else
333 		printf("\n\tpf: %d", pf);
334 
335 	if (hookname)
336 		printf(" %s", hookname);
337 	else
338 		printf(", hook %u,", hook);
339 
340 	printf(" prio %d", info->netfilter.priority);
341 
342 	if (info->netfilter.flags)
343 		printf(" flags 0x%x", info->netfilter.flags);
344 }
345 
346 static int show_link_close_plain(int fd, struct bpf_link_info *info)
347 {
348 	struct bpf_prog_info prog_info;
349 	const char *prog_type_str;
350 	int err;
351 
352 	show_link_header_plain(info);
353 
354 	switch (info->type) {
355 	case BPF_LINK_TYPE_RAW_TRACEPOINT:
356 		printf("\n\ttp '%s'  ",
357 		       (const char *)u64_to_ptr(info->raw_tracepoint.tp_name));
358 		break;
359 	case BPF_LINK_TYPE_TRACING:
360 		err = get_prog_info(info->prog_id, &prog_info);
361 		if (err)
362 			return err;
363 
364 		prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
365 		/* libbpf will return NULL for variants unknown to it. */
366 		if (prog_type_str)
367 			printf("\n\tprog_type %s  ", prog_type_str);
368 		else
369 			printf("\n\tprog_type %u  ", prog_info.type);
370 
371 		show_link_attach_type_plain(info->tracing.attach_type);
372 		break;
373 	case BPF_LINK_TYPE_CGROUP:
374 		printf("\n\tcgroup_id %zu  ", (size_t)info->cgroup.cgroup_id);
375 		show_link_attach_type_plain(info->cgroup.attach_type);
376 		break;
377 	case BPF_LINK_TYPE_ITER:
378 		show_iter_plain(info);
379 		break;
380 	case BPF_LINK_TYPE_NETNS:
381 		printf("\n\tnetns_ino %u  ", info->netns.netns_ino);
382 		show_link_attach_type_plain(info->netns.attach_type);
383 		break;
384 	case BPF_LINK_TYPE_NETFILTER:
385 		netfilter_dump_plain(info);
386 		break;
387 	default:
388 		break;
389 	}
390 
391 	if (!hashmap__empty(link_table)) {
392 		struct hashmap_entry *entry;
393 
394 		hashmap__for_each_key_entry(link_table, entry, info->id)
395 			printf("\n\tpinned %s", (char *)entry->pvalue);
396 	}
397 	emit_obj_refs_plain(refs_table, info->id, "\n\tpids ");
398 
399 	printf("\n");
400 
401 	return 0;
402 }
403 
404 static int do_show_link(int fd)
405 {
406 	struct bpf_link_info info;
407 	__u32 len = sizeof(info);
408 	char buf[256];
409 	int err;
410 
411 	memset(&info, 0, sizeof(info));
412 again:
413 	err = bpf_link_get_info_by_fd(fd, &info, &len);
414 	if (err) {
415 		p_err("can't get link info: %s",
416 		      strerror(errno));
417 		close(fd);
418 		return err;
419 	}
420 	if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT &&
421 	    !info.raw_tracepoint.tp_name) {
422 		info.raw_tracepoint.tp_name = (unsigned long)&buf;
423 		info.raw_tracepoint.tp_name_len = sizeof(buf);
424 		goto again;
425 	}
426 	if (info.type == BPF_LINK_TYPE_ITER &&
427 	    !info.iter.target_name) {
428 		info.iter.target_name = (unsigned long)&buf;
429 		info.iter.target_name_len = sizeof(buf);
430 		goto again;
431 	}
432 
433 	if (json_output)
434 		show_link_close_json(fd, &info);
435 	else
436 		show_link_close_plain(fd, &info);
437 
438 	close(fd);
439 	return 0;
440 }
441 
442 static int do_show(int argc, char **argv)
443 {
444 	__u32 id = 0;
445 	int err, fd;
446 
447 	if (show_pinned) {
448 		link_table = hashmap__new(hash_fn_for_key_as_id,
449 					  equal_fn_for_key_as_id, NULL);
450 		if (IS_ERR(link_table)) {
451 			p_err("failed to create hashmap for pinned paths");
452 			return -1;
453 		}
454 		build_pinned_obj_table(link_table, BPF_OBJ_LINK);
455 	}
456 	build_obj_refs_table(&refs_table, BPF_OBJ_LINK);
457 
458 	if (argc == 2) {
459 		fd = link_parse_fd(&argc, &argv);
460 		if (fd < 0)
461 			return fd;
462 		return do_show_link(fd);
463 	}
464 
465 	if (argc)
466 		return BAD_ARG();
467 
468 	if (json_output)
469 		jsonw_start_array(json_wtr);
470 	while (true) {
471 		err = bpf_link_get_next_id(id, &id);
472 		if (err) {
473 			if (errno == ENOENT)
474 				break;
475 			p_err("can't get next link: %s%s", strerror(errno),
476 			      errno == EINVAL ? " -- kernel too old?" : "");
477 			break;
478 		}
479 
480 		fd = bpf_link_get_fd_by_id(id);
481 		if (fd < 0) {
482 			if (errno == ENOENT)
483 				continue;
484 			p_err("can't get link by id (%u): %s",
485 			      id, strerror(errno));
486 			break;
487 		}
488 
489 		err = do_show_link(fd);
490 		if (err)
491 			break;
492 	}
493 	if (json_output)
494 		jsonw_end_array(json_wtr);
495 
496 	delete_obj_refs_table(refs_table);
497 
498 	if (show_pinned)
499 		delete_pinned_obj_table(link_table);
500 
501 	return errno == ENOENT ? 0 : -1;
502 }
503 
504 static int do_pin(int argc, char **argv)
505 {
506 	int err;
507 
508 	err = do_pin_any(argc, argv, link_parse_fd);
509 	if (!err && json_output)
510 		jsonw_null(json_wtr);
511 	return err;
512 }
513 
514 static int do_detach(int argc, char **argv)
515 {
516 	int err, fd;
517 
518 	if (argc != 2) {
519 		p_err("link specifier is invalid or missing\n");
520 		return 1;
521 	}
522 
523 	fd = link_parse_fd(&argc, &argv);
524 	if (fd < 0)
525 		return 1;
526 
527 	err = bpf_link_detach(fd);
528 	if (err)
529 		err = -errno;
530 	close(fd);
531 	if (err) {
532 		p_err("failed link detach: %s", strerror(-err));
533 		return 1;
534 	}
535 
536 	if (json_output)
537 		jsonw_null(json_wtr);
538 
539 	return 0;
540 }
541 
542 static int do_help(int argc, char **argv)
543 {
544 	if (json_output) {
545 		jsonw_null(json_wtr);
546 		return 0;
547 	}
548 
549 	fprintf(stderr,
550 		"Usage: %1$s %2$s { show | list }   [LINK]\n"
551 		"       %1$s %2$s pin        LINK  FILE\n"
552 		"       %1$s %2$s detach     LINK\n"
553 		"       %1$s %2$s help\n"
554 		"\n"
555 		"       " HELP_SPEC_LINK "\n"
556 		"       " HELP_SPEC_OPTIONS " |\n"
557 		"                    {-f|--bpffs} | {-n|--nomount} }\n"
558 		"",
559 		bin_name, argv[-2]);
560 
561 	return 0;
562 }
563 
564 static const struct cmd cmds[] = {
565 	{ "show",	do_show },
566 	{ "list",	do_show },
567 	{ "help",	do_help },
568 	{ "pin",	do_pin },
569 	{ "detach",	do_detach },
570 	{ 0 }
571 };
572 
573 int do_link(int argc, char **argv)
574 {
575 	return cmd_select(cmds, argc, argv, do_help);
576 }
577