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