xref: /linux/tools/bpf/bpftool/struct_ops.c (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2020 Facebook */
3 
4 #include <errno.h>
5 #include <stdio.h>
6 #include <unistd.h>
7 
8 #include <linux/err.h>
9 
10 #include <bpf/bpf.h>
11 #include <bpf/btf.h>
12 #include <bpf/libbpf.h>
13 
14 #include "json_writer.h"
15 #include "main.h"
16 
17 #define STRUCT_OPS_VALUE_PREFIX "bpf_struct_ops_"
18 
19 static const struct btf_type *map_info_type;
20 static __u32 map_info_alloc_len;
21 static struct btf *btf_vmlinux;
22 static __s32 map_info_type_id;
23 
24 struct res {
25 	unsigned int nr_maps;
26 	unsigned int nr_errs;
27 };
28 
get_btf_vmlinux(void)29 static const struct btf *get_btf_vmlinux(void)
30 {
31 	if (btf_vmlinux)
32 		return btf_vmlinux;
33 
34 	btf_vmlinux = libbpf_find_kernel_btf();
35 	if (!btf_vmlinux)
36 		p_err("struct_ops requires kernel CONFIG_DEBUG_INFO_BTF=y");
37 
38 	return btf_vmlinux;
39 }
40 
get_kern_struct_ops_name(const struct bpf_map_info * info)41 static const char *get_kern_struct_ops_name(const struct bpf_map_info *info)
42 {
43 	const struct btf *kern_btf;
44 	const struct btf_type *t;
45 	const char *st_ops_name;
46 
47 	kern_btf = get_btf_vmlinux();
48 	if (!kern_btf)
49 		return "<btf_vmlinux_not_found>";
50 
51 	t = btf__type_by_id(kern_btf, info->btf_vmlinux_value_type_id);
52 	st_ops_name = btf__name_by_offset(kern_btf, t->name_off);
53 	st_ops_name += strlen(STRUCT_OPS_VALUE_PREFIX);
54 
55 	return st_ops_name;
56 }
57 
get_map_info_type_id(void)58 static __s32 get_map_info_type_id(void)
59 {
60 	const struct btf *kern_btf;
61 
62 	if (map_info_type_id)
63 		return map_info_type_id;
64 
65 	kern_btf = get_btf_vmlinux();
66 	if (!kern_btf)
67 		return 0;
68 
69 	map_info_type_id = btf__find_by_name_kind(kern_btf, "bpf_map_info",
70 						  BTF_KIND_STRUCT);
71 	if (map_info_type_id < 0) {
72 		p_err("can't find bpf_map_info from btf_vmlinux");
73 		return map_info_type_id;
74 	}
75 	map_info_type = btf__type_by_id(kern_btf, map_info_type_id);
76 
77 	/* Ensure map_info_alloc() has at least what the bpftool needs */
78 	map_info_alloc_len = map_info_type->size;
79 	if (map_info_alloc_len < sizeof(struct bpf_map_info))
80 		map_info_alloc_len = sizeof(struct bpf_map_info);
81 
82 	return map_info_type_id;
83 }
84 
85 /* If the subcmd needs to print out the bpf_map_info,
86  * it should always call map_info_alloc to allocate
87  * a bpf_map_info object instead of allocating it
88  * on the stack.
89  *
90  * map_info_alloc() will take the running kernel's btf
91  * into account.  i.e. it will consider the
92  * sizeof(struct bpf_map_info) of the running kernel.
93  *
94  * It will enable the "struct_ops" cmd to print the latest
95  * "struct bpf_map_info".
96  *
97  * [ Recall that "struct_ops" requires the kernel's btf to
98  *   be available ]
99  */
map_info_alloc(__u32 * alloc_len)100 static struct bpf_map_info *map_info_alloc(__u32 *alloc_len)
101 {
102 	struct bpf_map_info *info;
103 
104 	if (get_map_info_type_id() < 0)
105 		return NULL;
106 
107 	info = calloc(1, map_info_alloc_len);
108 	if (!info)
109 		p_err("mem alloc failed");
110 	else
111 		*alloc_len = map_info_alloc_len;
112 
113 	return info;
114 }
115 
116 /* It iterates all struct_ops maps of the system.
117  * It returns the fd in "*res_fd" and map_info in "*info".
118  * In the very first iteration, info->id should be 0.
119  * An optional map "*name" filter can be specified.
120  * The filter can be made more flexible in the future.
121  * e.g. filter by kernel-struct-ops-name, regex-name, glob-name, ...etc.
122  *
123  * Return value:
124  *     1: A struct_ops map found.  It is returned in "*res_fd" and "*info".
125  *	  The caller can continue to call get_next in the future.
126  *     0: No struct_ops map is returned.
127  *        All struct_ops map has been found.
128  *    -1: Error and the caller should abort the iteration.
129  */
get_next_struct_ops_map(const char * name,int * res_fd,struct bpf_map_info * info,__u32 info_len)130 static int get_next_struct_ops_map(const char *name, int *res_fd,
131 				   struct bpf_map_info *info, __u32 info_len)
132 {
133 	__u32 id = info->id;
134 	int err, fd;
135 
136 	while (true) {
137 		err = bpf_map_get_next_id(id, &id);
138 		if (err) {
139 			if (errno == ENOENT)
140 				return 0;
141 			p_err("can't get next map: %s", strerror(errno));
142 			return -1;
143 		}
144 
145 		fd = bpf_map_get_fd_by_id(id);
146 		if (fd < 0) {
147 			if (errno == ENOENT)
148 				continue;
149 			p_err("can't get map by id (%u): %s",
150 			      id, strerror(errno));
151 			return -1;
152 		}
153 
154 		err = bpf_map_get_info_by_fd(fd, info, &info_len);
155 		if (err) {
156 			p_err("can't get map info: %s", strerror(errno));
157 			close(fd);
158 			return -1;
159 		}
160 
161 		if (info->type == BPF_MAP_TYPE_STRUCT_OPS &&
162 		    (!name || !strcmp(name, info->name))) {
163 			*res_fd = fd;
164 			return 1;
165 		}
166 		close(fd);
167 	}
168 }
169 
cmd_retval(const struct res * res,bool must_have_one_map)170 static int cmd_retval(const struct res *res, bool must_have_one_map)
171 {
172 	if (res->nr_errs || (!res->nr_maps && must_have_one_map))
173 		return -1;
174 
175 	return 0;
176 }
177 
178 /* "data" is the work_func private storage */
179 typedef int (*work_func)(int fd, const struct bpf_map_info *info, void *data,
180 			 struct json_writer *wtr);
181 
182 /* Find all struct_ops map in the system.
183  * Filter out by "name" (if specified).
184  * Then call "func(fd, info, data, wtr)" on each struct_ops map found.
185  */
do_search(const char * name,work_func func,void * data,struct json_writer * wtr)186 static struct res do_search(const char *name, work_func func, void *data,
187 			    struct json_writer *wtr)
188 {
189 	struct bpf_map_info *info;
190 	struct res res = {};
191 	__u32 info_len;
192 	int fd, err;
193 
194 	info = map_info_alloc(&info_len);
195 	if (!info) {
196 		res.nr_errs++;
197 		return res;
198 	}
199 
200 	if (wtr)
201 		jsonw_start_array(wtr);
202 	while ((err = get_next_struct_ops_map(name, &fd, info, info_len)) == 1) {
203 		res.nr_maps++;
204 		err = func(fd, info, data, wtr);
205 		if (err)
206 			res.nr_errs++;
207 		close(fd);
208 	}
209 	if (wtr)
210 		jsonw_end_array(wtr);
211 
212 	if (err)
213 		res.nr_errs++;
214 
215 	if (!wtr && name && !res.nr_errs && !res.nr_maps)
216 		/* It is not printing empty [].
217 		 * Thus, needs to specifically say nothing found
218 		 * for "name" here.
219 		 */
220 		p_err("no struct_ops found for %s", name);
221 	else if (!wtr && json_output && !res.nr_errs)
222 		/* The "func()" above is not writing any json (i.e. !wtr
223 		 * test here).
224 		 *
225 		 * However, "-j" is enabled and there is no errs here,
226 		 * so call json_null() as the current convention of
227 		 * other cmds.
228 		 */
229 		jsonw_null(json_wtr);
230 
231 	free(info);
232 	return res;
233 }
234 
do_one_id(const char * id_str,work_func func,void * data,struct json_writer * wtr)235 static struct res do_one_id(const char *id_str, work_func func, void *data,
236 			    struct json_writer *wtr)
237 {
238 	struct bpf_map_info *info;
239 	struct res res = {};
240 	unsigned long id;
241 	__u32 info_len;
242 	char *endptr;
243 	int fd;
244 
245 	id = strtoul(id_str, &endptr, 0);
246 	if (*endptr || !id || id > UINT32_MAX) {
247 		p_err("invalid id %s", id_str);
248 		res.nr_errs++;
249 		return res;
250 	}
251 
252 	fd = bpf_map_get_fd_by_id(id);
253 	if (fd < 0) {
254 		p_err("can't get map by id (%lu): %s", id, strerror(errno));
255 		res.nr_errs++;
256 		return res;
257 	}
258 
259 	info = map_info_alloc(&info_len);
260 	if (!info) {
261 		res.nr_errs++;
262 		goto done;
263 	}
264 
265 	if (bpf_map_get_info_by_fd(fd, info, &info_len)) {
266 		p_err("can't get map info: %s", strerror(errno));
267 		res.nr_errs++;
268 		goto done;
269 	}
270 
271 	if (info->type != BPF_MAP_TYPE_STRUCT_OPS) {
272 		p_err("%s id %u is not a struct_ops map", info->name, info->id);
273 		res.nr_errs++;
274 		goto done;
275 	}
276 
277 	res.nr_maps++;
278 
279 	if (wtr)
280 		jsonw_start_array(wtr);
281 
282 	if (func(fd, info, data, wtr))
283 		res.nr_errs++;
284 	else if (!wtr && json_output)
285 		/* The "func()" above is not writing any json (i.e. !wtr
286 		 * test here).
287 		 *
288 		 * However, "-j" is enabled and there is no errs here,
289 		 * so call json_null() as the current convention of
290 		 * other cmds.
291 		 */
292 		jsonw_null(json_wtr);
293 
294 	if (wtr)
295 		jsonw_end_array(wtr);
296 
297 done:
298 	free(info);
299 	close(fd);
300 
301 	return res;
302 }
303 
do_work_on_struct_ops(const char * search_type,const char * search_term,work_func func,void * data,struct json_writer * wtr)304 static struct res do_work_on_struct_ops(const char *search_type,
305 					const char *search_term,
306 					work_func func, void *data,
307 					struct json_writer *wtr)
308 {
309 	if (search_type) {
310 		if (is_prefix(search_type, "id"))
311 			return do_one_id(search_term, func, data, wtr);
312 		else if (!is_prefix(search_type, "name"))
313 			usage();
314 	}
315 
316 	return do_search(search_term, func, data, wtr);
317 }
318 
__do_show(int fd,const struct bpf_map_info * info,void * data,struct json_writer * wtr)319 static int __do_show(int fd, const struct bpf_map_info *info, void *data,
320 		     struct json_writer *wtr)
321 {
322 	if (wtr) {
323 		jsonw_start_object(wtr);
324 		jsonw_uint_field(wtr, "id", info->id);
325 		jsonw_string_field(wtr, "name", info->name);
326 		jsonw_string_field(wtr, "kernel_struct_ops",
327 				   get_kern_struct_ops_name(info));
328 		jsonw_end_object(wtr);
329 	} else {
330 		printf("%u: %-15s %-32s\n", info->id, info->name,
331 		       get_kern_struct_ops_name(info));
332 	}
333 
334 	return 0;
335 }
336 
do_show(int argc,char ** argv)337 static int do_show(int argc, char **argv)
338 {
339 	const char *search_type = NULL, *search_term = NULL;
340 	struct res res;
341 
342 	if (argc && argc != 2)
343 		usage();
344 
345 	if (argc == 2) {
346 		search_type = GET_ARG();
347 		search_term = GET_ARG();
348 	}
349 
350 	res = do_work_on_struct_ops(search_type, search_term, __do_show,
351 				    NULL, json_wtr);
352 
353 	return cmd_retval(&res, !!search_term);
354 }
355 
__do_dump(int fd,const struct bpf_map_info * info,void * data,struct json_writer * wtr)356 static int __do_dump(int fd, const struct bpf_map_info *info, void *data,
357 		     struct json_writer *wtr)
358 {
359 	struct btf_dumper *d = (struct btf_dumper *)data;
360 	const struct btf_type *struct_ops_type;
361 	const struct btf *kern_btf = d->btf;
362 	const char *struct_ops_name;
363 	int zero = 0;
364 	void *value;
365 
366 	/* note: d->jw == wtr */
367 
368 	kern_btf = d->btf;
369 
370 	/* The kernel supporting BPF_MAP_TYPE_STRUCT_OPS must have
371 	 * btf_vmlinux_value_type_id.
372 	 */
373 	struct_ops_type = btf__type_by_id(kern_btf,
374 					  info->btf_vmlinux_value_type_id);
375 	struct_ops_name = btf__name_by_offset(kern_btf,
376 					      struct_ops_type->name_off);
377 	value = calloc(1, info->value_size);
378 	if (!value) {
379 		p_err("mem alloc failed");
380 		return -1;
381 	}
382 
383 	if (bpf_map_lookup_elem(fd, &zero, value)) {
384 		p_err("can't lookup struct_ops map %s id %u",
385 		      info->name, info->id);
386 		free(value);
387 		return -1;
388 	}
389 
390 	jsonw_start_object(wtr);
391 	jsonw_name(wtr, "bpf_map_info");
392 	btf_dumper_type(d, map_info_type_id, (void *)info);
393 	jsonw_end_object(wtr);
394 
395 	jsonw_start_object(wtr);
396 	jsonw_name(wtr, struct_ops_name);
397 	btf_dumper_type(d, info->btf_vmlinux_value_type_id, value);
398 	jsonw_end_object(wtr);
399 
400 	free(value);
401 
402 	return 0;
403 }
404 
do_dump(int argc,char ** argv)405 static int do_dump(int argc, char **argv)
406 {
407 	const char *search_type = NULL, *search_term = NULL;
408 	json_writer_t *wtr = json_wtr;
409 	const struct btf *kern_btf;
410 	struct btf_dumper d = {};
411 	struct res res;
412 
413 	if (argc && argc != 2)
414 		usage();
415 
416 	if (argc == 2) {
417 		search_type = GET_ARG();
418 		search_term = GET_ARG();
419 	}
420 
421 	kern_btf = get_btf_vmlinux();
422 	if (!kern_btf)
423 		return -1;
424 
425 	if (!json_output) {
426 		wtr = jsonw_new(stdout);
427 		if (!wtr) {
428 			p_err("can't create json writer");
429 			return -1;
430 		}
431 		jsonw_pretty(wtr, true);
432 	}
433 
434 	d.btf = kern_btf;
435 	d.jw = wtr;
436 	d.is_plain_text = !json_output;
437 	d.prog_id_as_func_ptr = true;
438 
439 	res = do_work_on_struct_ops(search_type, search_term, __do_dump, &d,
440 				    wtr);
441 
442 	if (!json_output)
443 		jsonw_destroy(&wtr);
444 
445 	return cmd_retval(&res, !!search_term);
446 }
447 
__do_unregister(int fd,const struct bpf_map_info * info,void * data,struct json_writer * wtr)448 static int __do_unregister(int fd, const struct bpf_map_info *info, void *data,
449 			   struct json_writer *wtr)
450 {
451 	int zero = 0;
452 
453 	if (bpf_map_delete_elem(fd, &zero)) {
454 		p_err("can't unload %s %s id %u: %s",
455 		      get_kern_struct_ops_name(info), info->name,
456 		      info->id, strerror(errno));
457 		return -1;
458 	}
459 
460 	p_info("Unregistered %s %s id %u",
461 	       get_kern_struct_ops_name(info), info->name,
462 	       info->id);
463 
464 	return 0;
465 }
466 
do_unregister(int argc,char ** argv)467 static int do_unregister(int argc, char **argv)
468 {
469 	const char *search_type, *search_term;
470 	struct res res;
471 
472 	if (argc != 2)
473 		usage();
474 
475 	search_type = GET_ARG();
476 	search_term = GET_ARG();
477 
478 	res = do_work_on_struct_ops(search_type, search_term,
479 				    __do_unregister, NULL, NULL);
480 
481 	return cmd_retval(&res, true);
482 }
483 
pin_link(struct bpf_link * link,const char * pindir,const char * name)484 static int pin_link(struct bpf_link *link, const char *pindir,
485 		    const char *name)
486 {
487 	char pinfile[PATH_MAX];
488 	int err;
489 
490 	err = pathname_concat(pinfile, sizeof(pinfile), pindir, name);
491 	if (err)
492 		return -1;
493 
494 	return bpf_link__pin(link, pinfile);
495 }
496 
do_register(int argc,char ** argv)497 static int do_register(int argc, char **argv)
498 {
499 	LIBBPF_OPTS(bpf_object_open_opts, open_opts);
500 	__u32 link_info_len = sizeof(struct bpf_link_info);
501 	struct bpf_link_info link_info = {};
502 	struct bpf_map_info info = {};
503 	__u32 info_len = sizeof(info);
504 	int nr_errs = 0, nr_maps = 0;
505 	const char *linkdir = NULL;
506 	struct bpf_object *obj;
507 	struct bpf_link *link;
508 	struct bpf_map *map;
509 	const char *file;
510 
511 	if (argc != 1 && argc != 2)
512 		usage();
513 
514 	file = GET_ARG();
515 	if (argc == 1)
516 		linkdir = GET_ARG();
517 
518 	if (linkdir && create_and_mount_bpffs_dir(linkdir)) {
519 		p_err("can't mount bpffs for pinning");
520 		return -1;
521 	}
522 
523 	if (verifier_logs)
524 		/* log_level1 + log_level2 + stats, but not stable UAPI */
525 		open_opts.kernel_log_level = 1 + 2 + 4;
526 
527 	obj = bpf_object__open_file(file, &open_opts);
528 	if (!obj)
529 		return -1;
530 
531 	set_max_rlimit();
532 
533 	if (bpf_object__load(obj)) {
534 		bpf_object__close(obj);
535 		return -1;
536 	}
537 
538 	bpf_object__for_each_map(map, obj) {
539 		if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS)
540 			continue;
541 
542 		link = bpf_map__attach_struct_ops(map);
543 		if (!link) {
544 			p_err("can't register struct_ops %s: %s",
545 			      bpf_map__name(map), strerror(errno));
546 			nr_errs++;
547 			continue;
548 		}
549 		nr_maps++;
550 
551 		if (bpf_map_get_info_by_fd(bpf_map__fd(map), &info,
552 					   &info_len)) {
553 			/* Not p_err.  The struct_ops was attached
554 			 * successfully.
555 			 */
556 			p_info("Registered %s but can't find id: %s",
557 			       bpf_map__name(map), strerror(errno));
558 			goto clean_link;
559 		}
560 		if (!(bpf_map__map_flags(map) & BPF_F_LINK)) {
561 			p_info("Registered %s %s id %u",
562 			       get_kern_struct_ops_name(&info),
563 			       info.name,
564 			       info.id);
565 			goto clean_link;
566 		}
567 		if (bpf_link_get_info_by_fd(bpf_link__fd(link),
568 					    &link_info,
569 					    &link_info_len)) {
570 			p_err("Registered %s but can't find link id: %s",
571 			      bpf_map__name(map), strerror(errno));
572 			nr_errs++;
573 			goto clean_link;
574 		}
575 		if (linkdir && pin_link(link, linkdir, info.name)) {
576 			p_err("can't pin link %u for %s: %s",
577 			      link_info.id, info.name,
578 			      strerror(errno));
579 			nr_errs++;
580 			goto clean_link;
581 		}
582 		p_info("Registered %s %s map id %u link id %u",
583 		       get_kern_struct_ops_name(&info),
584 		       info.name, info.id, link_info.id);
585 
586 clean_link:
587 		bpf_link__disconnect(link);
588 		bpf_link__destroy(link);
589 	}
590 
591 	bpf_object__close(obj);
592 
593 	if (nr_errs)
594 		return -1;
595 
596 	if (!nr_maps) {
597 		p_err("no struct_ops found in %s", file);
598 		return -1;
599 	}
600 
601 	if (json_output)
602 		jsonw_null(json_wtr);
603 
604 	return 0;
605 }
606 
do_help(int argc,char ** argv)607 static int do_help(int argc, char **argv)
608 {
609 	if (json_output) {
610 		jsonw_null(json_wtr);
611 		return 0;
612 	}
613 
614 	fprintf(stderr,
615 		"Usage: %1$s %2$s { show | list } [STRUCT_OPS_MAP]\n"
616 		"       %1$s %2$s dump [STRUCT_OPS_MAP]\n"
617 		"       %1$s %2$s register OBJ [LINK_DIR]\n"
618 		"       %1$s %2$s unregister STRUCT_OPS_MAP\n"
619 		"       %1$s %2$s help\n"
620 		"\n"
621 		"       STRUCT_OPS_MAP := [ id STRUCT_OPS_MAP_ID | name STRUCT_OPS_MAP_NAME ]\n"
622 		"       " HELP_SPEC_OPTIONS " }\n"
623 		"",
624 		bin_name, argv[-2]);
625 
626 	return 0;
627 }
628 
629 static const struct cmd cmds[] = {
630 	{ "show",	do_show },
631 	{ "list",	do_show },
632 	{ "register",	do_register },
633 	{ "unregister",	do_unregister },
634 	{ "dump",	do_dump },
635 	{ "help",	do_help },
636 	{ 0 }
637 };
638 
do_struct_ops(int argc,char ** argv)639 int do_struct_ops(int argc, char **argv)
640 {
641 	int err;
642 
643 	err = cmd_select(cmds, argc, argv, do_help);
644 
645 	btf__free(btf_vmlinux);
646 
647 	return err;
648 }
649