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
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
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
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 */
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 */
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
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.