xref: /openbmc/linux/tools/bpf/bpftool/link.c (revision fe7498ef)
1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2020 Facebook */
3 
4 #include <errno.h>
5 #include <net/if.h>
6 #include <stdio.h>
7 #include <unistd.h>
8 
9 #include <bpf/bpf.h>
10 #include <bpf/hashmap.h>
11 
12 #include "json_writer.h"
13 #include "main.h"
14 
15 static const char * const link_type_name[] = {
16 	[BPF_LINK_TYPE_UNSPEC]			= "unspec",
17 	[BPF_LINK_TYPE_RAW_TRACEPOINT]		= "raw_tracepoint",
18 	[BPF_LINK_TYPE_TRACING]			= "tracing",
19 	[BPF_LINK_TYPE_CGROUP]			= "cgroup",
20 	[BPF_LINK_TYPE_ITER]			= "iter",
21 	[BPF_LINK_TYPE_NETNS]			= "netns",
22 };
23 
24 static struct hashmap *link_table;
25 
26 static int link_parse_fd(int *argc, char ***argv)
27 {
28 	int fd;
29 
30 	if (is_prefix(**argv, "id")) {
31 		unsigned int id;
32 		char *endptr;
33 
34 		NEXT_ARGP();
35 
36 		id = strtoul(**argv, &endptr, 0);
37 		if (*endptr) {
38 			p_err("can't parse %s as ID", **argv);
39 			return -1;
40 		}
41 		NEXT_ARGP();
42 
43 		fd = bpf_link_get_fd_by_id(id);
44 		if (fd < 0)
45 			p_err("failed to get link with ID %d: %s", id, strerror(errno));
46 		return fd;
47 	} else if (is_prefix(**argv, "pinned")) {
48 		char *path;
49 
50 		NEXT_ARGP();
51 
52 		path = **argv;
53 		NEXT_ARGP();
54 
55 		return open_obj_pinned_any(path, BPF_OBJ_LINK);
56 	}
57 
58 	p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
59 	return -1;
60 }
61 
62 static void
63 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)
64 {
65 	jsonw_uint_field(wtr, "id", info->id);
66 	if (info->type < ARRAY_SIZE(link_type_name))
67 		jsonw_string_field(wtr, "type", link_type_name[info->type]);
68 	else
69 		jsonw_uint_field(wtr, "type", info->type);
70 
71 	jsonw_uint_field(json_wtr, "prog_id", info->prog_id);
72 }
73 
74 static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr)
75 {
76 	if (attach_type < ARRAY_SIZE(attach_type_name))
77 		jsonw_string_field(wtr, "attach_type",
78 				   attach_type_name[attach_type]);
79 	else
80 		jsonw_uint_field(wtr, "attach_type", attach_type);
81 }
82 
83 static bool is_iter_map_target(const char *target_name)
84 {
85 	return strcmp(target_name, "bpf_map_elem") == 0 ||
86 	       strcmp(target_name, "bpf_sk_storage_map") == 0;
87 }
88 
89 static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr)
90 {
91 	const char *target_name = u64_to_ptr(info->iter.target_name);
92 
93 	jsonw_string_field(wtr, "target_name", target_name);
94 
95 	if (is_iter_map_target(target_name))
96 		jsonw_uint_field(wtr, "map_id", info->iter.map.map_id);
97 }
98 
99 static int get_prog_info(int prog_id, struct bpf_prog_info *info)
100 {
101 	__u32 len = sizeof(*info);
102 	int err, prog_fd;
103 
104 	prog_fd = bpf_prog_get_fd_by_id(prog_id);
105 	if (prog_fd < 0)
106 		return prog_fd;
107 
108 	memset(info, 0, sizeof(*info));
109 	err = bpf_obj_get_info_by_fd(prog_fd, info, &len);
110 	if (err)
111 		p_err("can't get prog info: %s", strerror(errno));
112 	close(prog_fd);
113 	return err;
114 }
115 
116 static int show_link_close_json(int fd, struct bpf_link_info *info)
117 {
118 	struct bpf_prog_info prog_info;
119 	int err;
120 
121 	jsonw_start_object(json_wtr);
122 
123 	show_link_header_json(info, json_wtr);
124 
125 	switch (info->type) {
126 	case BPF_LINK_TYPE_RAW_TRACEPOINT:
127 		jsonw_string_field(json_wtr, "tp_name",
128 				   u64_to_ptr(info->raw_tracepoint.tp_name));
129 		break;
130 	case BPF_LINK_TYPE_TRACING:
131 		err = get_prog_info(info->prog_id, &prog_info);
132 		if (err)
133 			return err;
134 
135 		if (prog_info.type < prog_type_name_size)
136 			jsonw_string_field(json_wtr, "prog_type",
137 					   prog_type_name[prog_info.type]);
138 		else
139 			jsonw_uint_field(json_wtr, "prog_type",
140 					 prog_info.type);
141 
142 		show_link_attach_type_json(info->tracing.attach_type,
143 					   json_wtr);
144 		break;
145 	case BPF_LINK_TYPE_CGROUP:
146 		jsonw_lluint_field(json_wtr, "cgroup_id",
147 				   info->cgroup.cgroup_id);
148 		show_link_attach_type_json(info->cgroup.attach_type, json_wtr);
149 		break;
150 	case BPF_LINK_TYPE_ITER:
151 		show_iter_json(info, json_wtr);
152 		break;
153 	case BPF_LINK_TYPE_NETNS:
154 		jsonw_uint_field(json_wtr, "netns_ino",
155 				 info->netns.netns_ino);
156 		show_link_attach_type_json(info->netns.attach_type, json_wtr);
157 		break;
158 	default:
159 		break;
160 	}
161 
162 	if (!hashmap__empty(link_table)) {
163 		struct hashmap_entry *entry;
164 
165 		jsonw_name(json_wtr, "pinned");
166 		jsonw_start_array(json_wtr);
167 		hashmap__for_each_key_entry(link_table, entry,
168 					    u32_as_hash_field(info->id))
169 			jsonw_string(json_wtr, entry->value);
170 		jsonw_end_array(json_wtr);
171 	}
172 
173 	emit_obj_refs_json(refs_table, info->id, json_wtr);
174 
175 	jsonw_end_object(json_wtr);
176 
177 	return 0;
178 }
179 
180 static void show_link_header_plain(struct bpf_link_info *info)
181 {
182 	printf("%u: ", info->id);
183 	if (info->type < ARRAY_SIZE(link_type_name))
184 		printf("%s  ", link_type_name[info->type]);
185 	else
186 		printf("type %u  ", info->type);
187 
188 	printf("prog %u  ", info->prog_id);
189 }
190 
191 static void show_link_attach_type_plain(__u32 attach_type)
192 {
193 	if (attach_type < ARRAY_SIZE(attach_type_name))
194 		printf("attach_type %s  ", attach_type_name[attach_type]);
195 	else
196 		printf("attach_type %u  ", attach_type);
197 }
198 
199 static void show_iter_plain(struct bpf_link_info *info)
200 {
201 	const char *target_name = u64_to_ptr(info->iter.target_name);
202 
203 	printf("target_name %s  ", target_name);
204 
205 	if (is_iter_map_target(target_name))
206 		printf("map_id %u  ", info->iter.map.map_id);
207 }
208 
209 static int show_link_close_plain(int fd, struct bpf_link_info *info)
210 {
211 	struct bpf_prog_info prog_info;
212 	int err;
213 
214 	show_link_header_plain(info);
215 
216 	switch (info->type) {
217 	case BPF_LINK_TYPE_RAW_TRACEPOINT:
218 		printf("\n\ttp '%s'  ",
219 		       (const char *)u64_to_ptr(info->raw_tracepoint.tp_name));
220 		break;
221 	case BPF_LINK_TYPE_TRACING:
222 		err = get_prog_info(info->prog_id, &prog_info);
223 		if (err)
224 			return err;
225 
226 		if (prog_info.type < prog_type_name_size)
227 			printf("\n\tprog_type %s  ",
228 			       prog_type_name[prog_info.type]);
229 		else
230 			printf("\n\tprog_type %u  ", prog_info.type);
231 
232 		show_link_attach_type_plain(info->tracing.attach_type);
233 		break;
234 	case BPF_LINK_TYPE_CGROUP:
235 		printf("\n\tcgroup_id %zu  ", (size_t)info->cgroup.cgroup_id);
236 		show_link_attach_type_plain(info->cgroup.attach_type);
237 		break;
238 	case BPF_LINK_TYPE_ITER:
239 		show_iter_plain(info);
240 		break;
241 	case BPF_LINK_TYPE_NETNS:
242 		printf("\n\tnetns_ino %u  ", info->netns.netns_ino);
243 		show_link_attach_type_plain(info->netns.attach_type);
244 		break;
245 	default:
246 		break;
247 	}
248 
249 	if (!hashmap__empty(link_table)) {
250 		struct hashmap_entry *entry;
251 
252 		hashmap__for_each_key_entry(link_table, entry,
253 					    u32_as_hash_field(info->id))
254 			printf("\n\tpinned %s", (char *)entry->value);
255 	}
256 	emit_obj_refs_plain(refs_table, info->id, "\n\tpids ");
257 
258 	printf("\n");
259 
260 	return 0;
261 }
262 
263 static int do_show_link(int fd)
264 {
265 	struct bpf_link_info info;
266 	__u32 len = sizeof(info);
267 	char buf[256];
268 	int err;
269 
270 	memset(&info, 0, sizeof(info));
271 again:
272 	err = bpf_obj_get_info_by_fd(fd, &info, &len);
273 	if (err) {
274 		p_err("can't get link info: %s",
275 		      strerror(errno));
276 		close(fd);
277 		return err;
278 	}
279 	if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT &&
280 	    !info.raw_tracepoint.tp_name) {
281 		info.raw_tracepoint.tp_name = (unsigned long)&buf;
282 		info.raw_tracepoint.tp_name_len = sizeof(buf);
283 		goto again;
284 	}
285 	if (info.type == BPF_LINK_TYPE_ITER &&
286 	    !info.iter.target_name) {
287 		info.iter.target_name = (unsigned long)&buf;
288 		info.iter.target_name_len = sizeof(buf);
289 		goto again;
290 	}
291 
292 	if (json_output)
293 		show_link_close_json(fd, &info);
294 	else
295 		show_link_close_plain(fd, &info);
296 
297 	close(fd);
298 	return 0;
299 }
300 
301 static int do_show(int argc, char **argv)
302 {
303 	__u32 id = 0;
304 	int err, fd;
305 
306 	if (show_pinned) {
307 		link_table = hashmap__new(hash_fn_for_key_as_id,
308 					  equal_fn_for_key_as_id, NULL);
309 		if (!link_table) {
310 			p_err("failed to create hashmap for pinned paths");
311 			return -1;
312 		}
313 		build_pinned_obj_table(link_table, BPF_OBJ_LINK);
314 	}
315 	build_obj_refs_table(&refs_table, BPF_OBJ_LINK);
316 
317 	if (argc == 2) {
318 		fd = link_parse_fd(&argc, &argv);
319 		if (fd < 0)
320 			return fd;
321 		return do_show_link(fd);
322 	}
323 
324 	if (argc)
325 		return BAD_ARG();
326 
327 	if (json_output)
328 		jsonw_start_array(json_wtr);
329 	while (true) {
330 		err = bpf_link_get_next_id(id, &id);
331 		if (err) {
332 			if (errno == ENOENT)
333 				break;
334 			p_err("can't get next link: %s%s", strerror(errno),
335 			      errno == EINVAL ? " -- kernel too old?" : "");
336 			break;
337 		}
338 
339 		fd = bpf_link_get_fd_by_id(id);
340 		if (fd < 0) {
341 			if (errno == ENOENT)
342 				continue;
343 			p_err("can't get link by id (%u): %s",
344 			      id, strerror(errno));
345 			break;
346 		}
347 
348 		err = do_show_link(fd);
349 		if (err)
350 			break;
351 	}
352 	if (json_output)
353 		jsonw_end_array(json_wtr);
354 
355 	delete_obj_refs_table(refs_table);
356 
357 	if (show_pinned)
358 		delete_pinned_obj_table(link_table);
359 
360 	return errno == ENOENT ? 0 : -1;
361 }
362 
363 static int do_pin(int argc, char **argv)
364 {
365 	int err;
366 
367 	err = do_pin_any(argc, argv, link_parse_fd);
368 	if (!err && json_output)
369 		jsonw_null(json_wtr);
370 	return err;
371 }
372 
373 static int do_detach(int argc, char **argv)
374 {
375 	int err, fd;
376 
377 	if (argc != 2) {
378 		p_err("link specifier is invalid or missing\n");
379 		return 1;
380 	}
381 
382 	fd = link_parse_fd(&argc, &argv);
383 	if (fd < 0)
384 		return 1;
385 
386 	err = bpf_link_detach(fd);
387 	if (err)
388 		err = -errno;
389 	close(fd);
390 	if (err) {
391 		p_err("failed link detach: %s", strerror(-err));
392 		return 1;
393 	}
394 
395 	if (json_output)
396 		jsonw_null(json_wtr);
397 
398 	return 0;
399 }
400 
401 static int do_help(int argc, char **argv)
402 {
403 	if (json_output) {
404 		jsonw_null(json_wtr);
405 		return 0;
406 	}
407 
408 	fprintf(stderr,
409 		"Usage: %1$s %2$s { show | list }   [LINK]\n"
410 		"       %1$s %2$s pin        LINK  FILE\n"
411 		"       %1$s %2$s detach     LINK\n"
412 		"       %1$s %2$s help\n"
413 		"\n"
414 		"       " HELP_SPEC_LINK "\n"
415 		"       " HELP_SPEC_OPTIONS " |\n"
416 		"                    {-f|--bpffs} | {-n|--nomount} }\n"
417 		"",
418 		bin_name, argv[-2]);
419 
420 	return 0;
421 }
422 
423 static const struct cmd cmds[] = {
424 	{ "show",	do_show },
425 	{ "list",	do_show },
426 	{ "help",	do_help },
427 	{ "pin",	do_pin },
428 	{ "detach",	do_detach },
429 	{ 0 }
430 };
431 
432 int do_link(int argc, char **argv)
433 {
434 	return cmd_select(cmds, argc, argv, do_help);
435 }
436