Loading...
1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2// Copyright (C) 2017 Facebook
3// Author: Roman Gushchin <guro@fb.com>
4
5#define _XOPEN_SOURCE 500
6#include <errno.h>
7#include <fcntl.h>
8#include <ftw.h>
9#include <mntent.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13#include <sys/stat.h>
14#include <sys/types.h>
15#include <unistd.h>
16
17#include <bpf/bpf.h>
18#include <bpf/btf.h>
19
20#include "main.h"
21
22#define HELP_SPEC_ATTACH_FLAGS \
23 "ATTACH_FLAGS := { multi | override }"
24
25#define HELP_SPEC_ATTACH_TYPES \
26 " ATTACH_TYPE := { cgroup_inet_ingress | cgroup_inet_egress |\n" \
27 " cgroup_inet_sock_create | cgroup_sock_ops |\n" \
28 " cgroup_device | cgroup_inet4_bind |\n" \
29 " cgroup_inet6_bind | cgroup_inet4_post_bind |\n" \
30 " cgroup_inet6_post_bind | cgroup_inet4_connect |\n" \
31 " cgroup_inet6_connect | cgroup_unix_connect |\n" \
32 " cgroup_inet4_getpeername | cgroup_inet6_getpeername |\n" \
33 " cgroup_unix_getpeername | cgroup_inet4_getsockname |\n" \
34 " cgroup_inet6_getsockname | cgroup_unix_getsockname |\n" \
35 " cgroup_udp4_sendmsg | cgroup_udp6_sendmsg |\n" \
36 " cgroup_unix_sendmsg | cgroup_udp4_recvmsg |\n" \
37 " cgroup_udp6_recvmsg | cgroup_unix_recvmsg |\n" \
38 " cgroup_sysctl | cgroup_getsockopt |\n" \
39 " cgroup_setsockopt | cgroup_inet_sock_release }"
40
41static unsigned int query_flags;
42static struct btf *btf_vmlinux;
43static __u32 btf_vmlinux_id;
44
45static enum bpf_attach_type parse_attach_type(const char *str)
46{
47 const char *attach_type_str;
48 enum bpf_attach_type type;
49
50 for (type = 0; ; type++) {
51 attach_type_str = libbpf_bpf_attach_type_str(type);
52 if (!attach_type_str)
53 break;
54 if (!strcmp(str, attach_type_str))
55 return type;
56 }
57
58 /* Also check traditionally used attach type strings. For these we keep
59 * allowing prefixed usage.
60 */
61 for (type = 0; ; type++) {
62 attach_type_str = bpf_attach_type_input_str(type);
63 if (!attach_type_str)
64 break;
65 if (is_prefix(str, attach_type_str))
66 return type;
67 }
68
69 return __MAX_BPF_ATTACH_TYPE;
70}
71
72static void guess_vmlinux_btf_id(__u32 attach_btf_obj_id)
73{
74 struct bpf_btf_info btf_info = {};
75 __u32 btf_len = sizeof(btf_info);
76 char name[16] = {};
77 int err;
78 int fd;
79
80 btf_info.name = ptr_to_u64(name);
81 btf_info.name_len = sizeof(name);
82
83 fd = bpf_btf_get_fd_by_id(attach_btf_obj_id);
84 if (fd < 0)
85 return;
86
87 err = bpf_btf_get_info_by_fd(fd, &btf_info, &btf_len);
88 if (err)
89 goto out;
90
91 if (btf_info.kernel_btf && strncmp(name, "vmlinux", sizeof(name)) == 0)
92 btf_vmlinux_id = btf_info.id;
93
94out:
95 close(fd);
96}
97
98static int show_bpf_prog(int id, enum bpf_attach_type attach_type,
99 const char *attach_flags_str,
100 int level)
101{
102 char prog_name[MAX_PROG_FULL_NAME];
103 const char *attach_btf_name = NULL;
104 struct bpf_prog_info info = {};
105 const char *attach_type_str;
106 __u32 info_len = sizeof(info);
107 int prog_fd;
108
109 prog_fd = bpf_prog_get_fd_by_id(id);
110 if (prog_fd < 0)
111 return -1;
112
113 if (bpf_prog_get_info_by_fd(prog_fd, &info, &info_len)) {
114 close(prog_fd);
115 return -1;
116 }
117
118 attach_type_str = libbpf_bpf_attach_type_str(attach_type);
119
120 if (btf_vmlinux) {
121 if (!btf_vmlinux_id)
122 guess_vmlinux_btf_id(info.attach_btf_obj_id);
123
124 if (btf_vmlinux_id == info.attach_btf_obj_id &&
125 info.attach_btf_id < btf__type_cnt(btf_vmlinux)) {
126 const struct btf_type *t =
127 btf__type_by_id(btf_vmlinux, info.attach_btf_id);
128 attach_btf_name =
129 btf__name_by_offset(btf_vmlinux, t->name_off);
130 }
131 }
132
133 get_prog_full_name(&info, prog_fd, prog_name, sizeof(prog_name));
134 if (json_output) {
135 jsonw_start_object(json_wtr);
136 jsonw_uint_field(json_wtr, "id", info.id);
137 if (attach_type_str)
138 jsonw_string_field(json_wtr, "attach_type", attach_type_str);
139 else
140 jsonw_uint_field(json_wtr, "attach_type", attach_type);
141 if (!(query_flags & BPF_F_QUERY_EFFECTIVE))
142 jsonw_string_field(json_wtr, "attach_flags", attach_flags_str);
143 jsonw_string_field(json_wtr, "name", prog_name);
144 if (attach_btf_name)
145 jsonw_string_field(json_wtr, "attach_btf_name", attach_btf_name);
146 jsonw_uint_field(json_wtr, "attach_btf_obj_id", info.attach_btf_obj_id);
147 jsonw_uint_field(json_wtr, "attach_btf_id", info.attach_btf_id);
148 jsonw_end_object(json_wtr);
149 } else {
150 printf("%s%-8u ", level ? " " : "", info.id);
151 if (attach_type_str)
152 printf("%-15s", attach_type_str);
153 else
154 printf("type %-10u", attach_type);
155 if (query_flags & BPF_F_QUERY_EFFECTIVE)
156 printf(" %-15s", prog_name);
157 else
158 printf(" %-15s %-15s", attach_flags_str, prog_name);
159 if (attach_btf_name)
160 printf(" %-15s", attach_btf_name);
161 else if (info.attach_btf_id)
162 printf(" attach_btf_obj_id=%d attach_btf_id=%d",
163 info.attach_btf_obj_id, info.attach_btf_id);
164 printf("\n");
165 }
166
167 close(prog_fd);
168 return 0;
169}
170
171static int count_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type)
172{
173 __u32 prog_cnt = 0;
174 int ret;
175
176 ret = bpf_prog_query(cgroup_fd, type, query_flags, NULL,
177 NULL, &prog_cnt);
178 if (ret)
179 return -1;
180
181 return prog_cnt;
182}
183
184static int cgroup_has_attached_progs(int cgroup_fd)
185{
186 enum bpf_attach_type type;
187 bool no_prog = true;
188
189 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
190 int count = count_attached_bpf_progs(cgroup_fd, type);
191
192 if (count < 0 && errno != EINVAL)
193 return -1;
194
195 if (count > 0) {
196 no_prog = false;
197 break;
198 }
199 }
200
201 return no_prog ? 0 : 1;
202}
203
204static int show_effective_bpf_progs(int cgroup_fd, enum bpf_attach_type type,
205 int level)
206{
207 LIBBPF_OPTS(bpf_prog_query_opts, p);
208 __u32 prog_ids[1024] = {0};
209 __u32 iter;
210 int ret;
211
212 p.query_flags = query_flags;
213 p.prog_cnt = ARRAY_SIZE(prog_ids);
214 p.prog_ids = prog_ids;
215
216 ret = bpf_prog_query_opts(cgroup_fd, type, &p);
217 if (ret)
218 return ret;
219
220 if (p.prog_cnt == 0)
221 return 0;
222
223 for (iter = 0; iter < p.prog_cnt; iter++)
224 show_bpf_prog(prog_ids[iter], type, NULL, level);
225
226 return 0;
227}
228
229static int show_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type,
230 int level)
231{
232 LIBBPF_OPTS(bpf_prog_query_opts, p);
233 __u32 prog_attach_flags[1024] = {0};
234 const char *attach_flags_str;
235 __u32 prog_ids[1024] = {0};
236 char buf[32];
237 __u32 iter;
238 int ret;
239
240 p.query_flags = query_flags;
241 p.prog_cnt = ARRAY_SIZE(prog_ids);
242 p.prog_ids = prog_ids;
243 p.prog_attach_flags = prog_attach_flags;
244
245 ret = bpf_prog_query_opts(cgroup_fd, type, &p);
246 if (ret)
247 return ret;
248
249 if (p.prog_cnt == 0)
250 return 0;
251
252 for (iter = 0; iter < p.prog_cnt; iter++) {
253 __u32 attach_flags;
254
255 attach_flags = prog_attach_flags[iter] ?: p.attach_flags;
256
257 switch (attach_flags) {
258 case BPF_F_ALLOW_MULTI:
259 attach_flags_str = "multi";
260 break;
261 case BPF_F_ALLOW_OVERRIDE:
262 attach_flags_str = "override";
263 break;
264 case 0:
265 attach_flags_str = "";
266 break;
267 default:
268 snprintf(buf, sizeof(buf), "unknown(%x)", attach_flags);
269 attach_flags_str = buf;
270 }
271
272 show_bpf_prog(prog_ids[iter], type,
273 attach_flags_str, level);
274 }
275
276 return 0;
277}
278
279static int show_bpf_progs(int cgroup_fd, enum bpf_attach_type type,
280 int level)
281{
282 return query_flags & BPF_F_QUERY_EFFECTIVE ?
283 show_effective_bpf_progs(cgroup_fd, type, level) :
284 show_attached_bpf_progs(cgroup_fd, type, level);
285}
286
287static int do_show(int argc, char **argv)
288{
289 enum bpf_attach_type type;
290 int has_attached_progs;
291 const char *path;
292 int cgroup_fd;
293 int ret = -1;
294
295 query_flags = 0;
296
297 if (!REQ_ARGS(1))
298 return -1;
299 path = GET_ARG();
300
301 while (argc) {
302 if (is_prefix(*argv, "effective")) {
303 if (query_flags & BPF_F_QUERY_EFFECTIVE) {
304 p_err("duplicated argument: %s", *argv);
305 return -1;
306 }
307 query_flags |= BPF_F_QUERY_EFFECTIVE;
308 NEXT_ARG();
309 } else {
310 p_err("expected no more arguments, 'effective', got: '%s'?",
311 *argv);
312 return -1;
313 }
314 }
315
316 cgroup_fd = open(path, O_RDONLY);
317 if (cgroup_fd < 0) {
318 p_err("can't open cgroup %s", path);
319 goto exit;
320 }
321
322 has_attached_progs = cgroup_has_attached_progs(cgroup_fd);
323 if (has_attached_progs < 0) {
324 p_err("can't query bpf programs attached to %s: %s",
325 path, strerror(errno));
326 goto exit_cgroup;
327 } else if (!has_attached_progs) {
328 ret = 0;
329 goto exit_cgroup;
330 }
331
332 if (json_output)
333 jsonw_start_array(json_wtr);
334 else if (query_flags & BPF_F_QUERY_EFFECTIVE)
335 printf("%-8s %-15s %-15s\n", "ID", "AttachType", "Name");
336 else
337 printf("%-8s %-15s %-15s %-15s\n", "ID", "AttachType",
338 "AttachFlags", "Name");
339
340 btf_vmlinux = libbpf_find_kernel_btf();
341 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
342 /*
343 * Not all attach types may be supported, so it's expected,
344 * that some requests will fail.
345 * If we were able to get the show for at least one
346 * attach type, let's return 0.
347 */
348 if (show_bpf_progs(cgroup_fd, type, 0) == 0)
349 ret = 0;
350 }
351
352 if (json_output)
353 jsonw_end_array(json_wtr);
354
355exit_cgroup:
356 close(cgroup_fd);
357exit:
358 return ret;
359}
360
361/*
362 * To distinguish nftw() errors and do_show_tree_fn() errors
363 * and avoid duplicating error messages, let's return -2
364 * from do_show_tree_fn() in case of error.
365 */
366#define NFTW_ERR -1
367#define SHOW_TREE_FN_ERR -2
368static int do_show_tree_fn(const char *fpath, const struct stat *sb,
369 int typeflag, struct FTW *ftw)
370{
371 enum bpf_attach_type type;
372 int has_attached_progs;
373 int cgroup_fd;
374
375 if (typeflag != FTW_D)
376 return 0;
377
378 cgroup_fd = open(fpath, O_RDONLY);
379 if (cgroup_fd < 0) {
380 p_err("can't open cgroup %s: %s", fpath, strerror(errno));
381 return SHOW_TREE_FN_ERR;
382 }
383
384 has_attached_progs = cgroup_has_attached_progs(cgroup_fd);
385 if (has_attached_progs < 0) {
386 p_err("can't query bpf programs attached to %s: %s",
387 fpath, strerror(errno));
388 close(cgroup_fd);
389 return SHOW_TREE_FN_ERR;
390 } else if (!has_attached_progs) {
391 close(cgroup_fd);
392 return 0;
393 }
394
395 if (json_output) {
396 jsonw_start_object(json_wtr);
397 jsonw_string_field(json_wtr, "cgroup", fpath);
398 jsonw_name(json_wtr, "programs");
399 jsonw_start_array(json_wtr);
400 } else {
401 printf("%s\n", fpath);
402 }
403
404 btf_vmlinux = libbpf_find_kernel_btf();
405 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++)
406 show_bpf_progs(cgroup_fd, type, ftw->level);
407
408 if (errno == EINVAL)
409 /* Last attach type does not support query.
410 * Do not report an error for this, especially because batch
411 * mode would stop processing commands.
412 */
413 errno = 0;
414
415 if (json_output) {
416 jsonw_end_array(json_wtr);
417 jsonw_end_object(json_wtr);
418 }
419
420 close(cgroup_fd);
421
422 return 0;
423}
424
425static char *find_cgroup_root(void)
426{
427 struct mntent *mnt;
428 FILE *f;
429
430 f = fopen("/proc/mounts", "r");
431 if (f == NULL)
432 return NULL;
433
434 while ((mnt = getmntent(f))) {
435 if (strcmp(mnt->mnt_type, "cgroup2") == 0) {
436 fclose(f);
437 return strdup(mnt->mnt_dir);
438 }
439 }
440
441 fclose(f);
442 return NULL;
443}
444
445static int do_show_tree(int argc, char **argv)
446{
447 char *cgroup_root, *cgroup_alloced = NULL;
448 int ret;
449
450 query_flags = 0;
451
452 if (!argc) {
453 cgroup_alloced = find_cgroup_root();
454 if (!cgroup_alloced) {
455 p_err("cgroup v2 isn't mounted");
456 return -1;
457 }
458 cgroup_root = cgroup_alloced;
459 } else {
460 cgroup_root = GET_ARG();
461
462 while (argc) {
463 if (is_prefix(*argv, "effective")) {
464 if (query_flags & BPF_F_QUERY_EFFECTIVE) {
465 p_err("duplicated argument: %s", *argv);
466 return -1;
467 }
468 query_flags |= BPF_F_QUERY_EFFECTIVE;
469 NEXT_ARG();
470 } else {
471 p_err("expected no more arguments, 'effective', got: '%s'?",
472 *argv);
473 return -1;
474 }
475 }
476 }
477
478 if (json_output)
479 jsonw_start_array(json_wtr);
480 else if (query_flags & BPF_F_QUERY_EFFECTIVE)
481 printf("%s\n"
482 "%-8s %-15s %-15s\n",
483 "CgroupPath",
484 "ID", "AttachType", "Name");
485 else
486 printf("%s\n"
487 "%-8s %-15s %-15s %-15s\n",
488 "CgroupPath",
489 "ID", "AttachType", "AttachFlags", "Name");
490
491 switch (nftw(cgroup_root, do_show_tree_fn, 1024, FTW_MOUNT)) {
492 case NFTW_ERR:
493 p_err("can't iterate over %s: %s", cgroup_root,
494 strerror(errno));
495 ret = -1;
496 break;
497 case SHOW_TREE_FN_ERR:
498 ret = -1;
499 break;
500 default:
501 ret = 0;
502 }
503
504 if (json_output)
505 jsonw_end_array(json_wtr);
506
507 free(cgroup_alloced);
508
509 return ret;
510}
511
512static int do_attach(int argc, char **argv)
513{
514 enum bpf_attach_type attach_type;
515 int cgroup_fd, prog_fd;
516 int attach_flags = 0;
517 int ret = -1;
518 int i;
519
520 if (argc < 4) {
521 p_err("too few parameters for cgroup attach");
522 goto exit;
523 }
524
525 cgroup_fd = open(argv[0], O_RDONLY);
526 if (cgroup_fd < 0) {
527 p_err("can't open cgroup %s", argv[0]);
528 goto exit;
529 }
530
531 attach_type = parse_attach_type(argv[1]);
532 if (attach_type == __MAX_BPF_ATTACH_TYPE) {
533 p_err("invalid attach type");
534 goto exit_cgroup;
535 }
536
537 argc -= 2;
538 argv = &argv[2];
539 prog_fd = prog_parse_fd(&argc, &argv);
540 if (prog_fd < 0)
541 goto exit_cgroup;
542
543 for (i = 0; i < argc; i++) {
544 if (is_prefix(argv[i], "multi")) {
545 attach_flags |= BPF_F_ALLOW_MULTI;
546 } else if (is_prefix(argv[i], "override")) {
547 attach_flags |= BPF_F_ALLOW_OVERRIDE;
548 } else {
549 p_err("unknown option: %s", argv[i]);
550 goto exit_cgroup;
551 }
552 }
553
554 if (bpf_prog_attach(prog_fd, cgroup_fd, attach_type, attach_flags)) {
555 p_err("failed to attach program");
556 goto exit_prog;
557 }
558
559 if (json_output)
560 jsonw_null(json_wtr);
561
562 ret = 0;
563
564exit_prog:
565 close(prog_fd);
566exit_cgroup:
567 close(cgroup_fd);
568exit:
569 return ret;
570}
571
572static int do_detach(int argc, char **argv)
573{
574 enum bpf_attach_type attach_type;
575 int prog_fd, cgroup_fd;
576 int ret = -1;
577
578 if (argc < 4) {
579 p_err("too few parameters for cgroup detach");
580 goto exit;
581 }
582
583 cgroup_fd = open(argv[0], O_RDONLY);
584 if (cgroup_fd < 0) {
585 p_err("can't open cgroup %s", argv[0]);
586 goto exit;
587 }
588
589 attach_type = parse_attach_type(argv[1]);
590 if (attach_type == __MAX_BPF_ATTACH_TYPE) {
591 p_err("invalid attach type");
592 goto exit_cgroup;
593 }
594
595 argc -= 2;
596 argv = &argv[2];
597 prog_fd = prog_parse_fd(&argc, &argv);
598 if (prog_fd < 0)
599 goto exit_cgroup;
600
601 if (bpf_prog_detach2(prog_fd, cgroup_fd, attach_type)) {
602 p_err("failed to detach program");
603 goto exit_prog;
604 }
605
606 if (json_output)
607 jsonw_null(json_wtr);
608
609 ret = 0;
610
611exit_prog:
612 close(prog_fd);
613exit_cgroup:
614 close(cgroup_fd);
615exit:
616 return ret;
617}
618
619static int do_help(int argc, char **argv)
620{
621 if (json_output) {
622 jsonw_null(json_wtr);
623 return 0;
624 }
625
626 fprintf(stderr,
627 "Usage: %1$s %2$s { show | list } CGROUP [**effective**]\n"
628 " %1$s %2$s tree [CGROUP_ROOT] [**effective**]\n"
629 " %1$s %2$s attach CGROUP ATTACH_TYPE PROG [ATTACH_FLAGS]\n"
630 " %1$s %2$s detach CGROUP ATTACH_TYPE PROG\n"
631 " %1$s %2$s help\n"
632 "\n"
633 HELP_SPEC_ATTACH_TYPES "\n"
634 " " HELP_SPEC_ATTACH_FLAGS "\n"
635 " " HELP_SPEC_PROGRAM "\n"
636 " " HELP_SPEC_OPTIONS " |\n"
637 " {-f|--bpffs} }\n"
638 "",
639 bin_name, argv[-2]);
640
641 return 0;
642}
643
644static const struct cmd cmds[] = {
645 { "show", do_show },
646 { "list", do_show },
647 { "tree", do_show_tree },
648 { "attach", do_attach },
649 { "detach", do_detach },
650 { "help", do_help },
651 { 0 }
652};
653
654int do_cgroup(int argc, char **argv)
655{
656 return cmd_select(cmds, argc, argv, do_help);
657}
1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2// Copyright (C) 2017 Facebook
3// Author: Roman Gushchin <guro@fb.com>
4
5#define _XOPEN_SOURCE 500
6#include <errno.h>
7#include <fcntl.h>
8#include <ftw.h>
9#include <mntent.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13#include <sys/stat.h>
14#include <sys/types.h>
15#include <unistd.h>
16
17#include <bpf.h>
18
19#include "main.h"
20
21#define HELP_SPEC_ATTACH_FLAGS \
22 "ATTACH_FLAGS := { multi | override }"
23
24#define HELP_SPEC_ATTACH_TYPES \
25 " ATTACH_TYPE := { ingress | egress | sock_create |\n" \
26 " sock_ops | device | bind4 | bind6 |\n" \
27 " post_bind4 | post_bind6 | connect4 |\n" \
28 " connect6 | sendmsg4 | sendmsg6 |\n" \
29 " recvmsg4 | recvmsg6 | sysctl |\n" \
30 " getsockopt | setsockopt }"
31
32static unsigned int query_flags;
33
34static const char * const attach_type_strings[] = {
35 [BPF_CGROUP_INET_INGRESS] = "ingress",
36 [BPF_CGROUP_INET_EGRESS] = "egress",
37 [BPF_CGROUP_INET_SOCK_CREATE] = "sock_create",
38 [BPF_CGROUP_SOCK_OPS] = "sock_ops",
39 [BPF_CGROUP_DEVICE] = "device",
40 [BPF_CGROUP_INET4_BIND] = "bind4",
41 [BPF_CGROUP_INET6_BIND] = "bind6",
42 [BPF_CGROUP_INET4_CONNECT] = "connect4",
43 [BPF_CGROUP_INET6_CONNECT] = "connect6",
44 [BPF_CGROUP_INET4_POST_BIND] = "post_bind4",
45 [BPF_CGROUP_INET6_POST_BIND] = "post_bind6",
46 [BPF_CGROUP_UDP4_SENDMSG] = "sendmsg4",
47 [BPF_CGROUP_UDP6_SENDMSG] = "sendmsg6",
48 [BPF_CGROUP_SYSCTL] = "sysctl",
49 [BPF_CGROUP_UDP4_RECVMSG] = "recvmsg4",
50 [BPF_CGROUP_UDP6_RECVMSG] = "recvmsg6",
51 [BPF_CGROUP_GETSOCKOPT] = "getsockopt",
52 [BPF_CGROUP_SETSOCKOPT] = "setsockopt",
53 [__MAX_BPF_ATTACH_TYPE] = NULL,
54};
55
56static enum bpf_attach_type parse_attach_type(const char *str)
57{
58 enum bpf_attach_type type;
59
60 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
61 if (attach_type_strings[type] &&
62 is_prefix(str, attach_type_strings[type]))
63 return type;
64 }
65
66 return __MAX_BPF_ATTACH_TYPE;
67}
68
69static int show_bpf_prog(int id, const char *attach_type_str,
70 const char *attach_flags_str,
71 int level)
72{
73 struct bpf_prog_info info = {};
74 __u32 info_len = sizeof(info);
75 int prog_fd;
76
77 prog_fd = bpf_prog_get_fd_by_id(id);
78 if (prog_fd < 0)
79 return -1;
80
81 if (bpf_obj_get_info_by_fd(prog_fd, &info, &info_len)) {
82 close(prog_fd);
83 return -1;
84 }
85
86 if (json_output) {
87 jsonw_start_object(json_wtr);
88 jsonw_uint_field(json_wtr, "id", info.id);
89 jsonw_string_field(json_wtr, "attach_type",
90 attach_type_str);
91 jsonw_string_field(json_wtr, "attach_flags",
92 attach_flags_str);
93 jsonw_string_field(json_wtr, "name", info.name);
94 jsonw_end_object(json_wtr);
95 } else {
96 printf("%s%-8u %-15s %-15s %-15s\n", level ? " " : "",
97 info.id,
98 attach_type_str,
99 attach_flags_str,
100 info.name);
101 }
102
103 close(prog_fd);
104 return 0;
105}
106
107static int count_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type)
108{
109 __u32 prog_cnt = 0;
110 int ret;
111
112 ret = bpf_prog_query(cgroup_fd, type, query_flags, NULL,
113 NULL, &prog_cnt);
114 if (ret)
115 return -1;
116
117 return prog_cnt;
118}
119
120static int show_attached_bpf_progs(int cgroup_fd, enum bpf_attach_type type,
121 int level)
122{
123 const char *attach_flags_str;
124 __u32 prog_ids[1024] = {0};
125 __u32 prog_cnt, iter;
126 __u32 attach_flags;
127 char buf[32];
128 int ret;
129
130 prog_cnt = ARRAY_SIZE(prog_ids);
131 ret = bpf_prog_query(cgroup_fd, type, query_flags, &attach_flags,
132 prog_ids, &prog_cnt);
133 if (ret)
134 return ret;
135
136 if (prog_cnt == 0)
137 return 0;
138
139 switch (attach_flags) {
140 case BPF_F_ALLOW_MULTI:
141 attach_flags_str = "multi";
142 break;
143 case BPF_F_ALLOW_OVERRIDE:
144 attach_flags_str = "override";
145 break;
146 case 0:
147 attach_flags_str = "";
148 break;
149 default:
150 snprintf(buf, sizeof(buf), "unknown(%x)", attach_flags);
151 attach_flags_str = buf;
152 }
153
154 for (iter = 0; iter < prog_cnt; iter++)
155 show_bpf_prog(prog_ids[iter], attach_type_strings[type],
156 attach_flags_str, level);
157
158 return 0;
159}
160
161static int do_show(int argc, char **argv)
162{
163 enum bpf_attach_type type;
164 const char *path;
165 int cgroup_fd;
166 int ret = -1;
167
168 query_flags = 0;
169
170 if (!REQ_ARGS(1))
171 return -1;
172 path = GET_ARG();
173
174 while (argc) {
175 if (is_prefix(*argv, "effective")) {
176 if (query_flags & BPF_F_QUERY_EFFECTIVE) {
177 p_err("duplicated argument: %s", *argv);
178 return -1;
179 }
180 query_flags |= BPF_F_QUERY_EFFECTIVE;
181 NEXT_ARG();
182 } else {
183 p_err("expected no more arguments, 'effective', got: '%s'?",
184 *argv);
185 return -1;
186 }
187 }
188
189 cgroup_fd = open(path, O_RDONLY);
190 if (cgroup_fd < 0) {
191 p_err("can't open cgroup %s", path);
192 goto exit;
193 }
194
195 if (json_output)
196 jsonw_start_array(json_wtr);
197 else
198 printf("%-8s %-15s %-15s %-15s\n", "ID", "AttachType",
199 "AttachFlags", "Name");
200
201 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
202 /*
203 * Not all attach types may be supported, so it's expected,
204 * that some requests will fail.
205 * If we were able to get the show for at least one
206 * attach type, let's return 0.
207 */
208 if (show_attached_bpf_progs(cgroup_fd, type, 0) == 0)
209 ret = 0;
210 }
211
212 if (json_output)
213 jsonw_end_array(json_wtr);
214
215 close(cgroup_fd);
216exit:
217 return ret;
218}
219
220/*
221 * To distinguish nftw() errors and do_show_tree_fn() errors
222 * and avoid duplicating error messages, let's return -2
223 * from do_show_tree_fn() in case of error.
224 */
225#define NFTW_ERR -1
226#define SHOW_TREE_FN_ERR -2
227static int do_show_tree_fn(const char *fpath, const struct stat *sb,
228 int typeflag, struct FTW *ftw)
229{
230 enum bpf_attach_type type;
231 bool skip = true;
232 int cgroup_fd;
233
234 if (typeflag != FTW_D)
235 return 0;
236
237 cgroup_fd = open(fpath, O_RDONLY);
238 if (cgroup_fd < 0) {
239 p_err("can't open cgroup %s: %s", fpath, strerror(errno));
240 return SHOW_TREE_FN_ERR;
241 }
242
243 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
244 int count = count_attached_bpf_progs(cgroup_fd, type);
245
246 if (count < 0 && errno != EINVAL) {
247 p_err("can't query bpf programs attached to %s: %s",
248 fpath, strerror(errno));
249 close(cgroup_fd);
250 return SHOW_TREE_FN_ERR;
251 }
252 if (count > 0) {
253 skip = false;
254 break;
255 }
256 }
257
258 if (skip) {
259 close(cgroup_fd);
260 return 0;
261 }
262
263 if (json_output) {
264 jsonw_start_object(json_wtr);
265 jsonw_string_field(json_wtr, "cgroup", fpath);
266 jsonw_name(json_wtr, "programs");
267 jsonw_start_array(json_wtr);
268 } else {
269 printf("%s\n", fpath);
270 }
271
272 for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++)
273 show_attached_bpf_progs(cgroup_fd, type, ftw->level);
274
275 if (errno == EINVAL)
276 /* Last attach type does not support query.
277 * Do not report an error for this, especially because batch
278 * mode would stop processing commands.
279 */
280 errno = 0;
281
282 if (json_output) {
283 jsonw_end_array(json_wtr);
284 jsonw_end_object(json_wtr);
285 }
286
287 close(cgroup_fd);
288
289 return 0;
290}
291
292static char *find_cgroup_root(void)
293{
294 struct mntent *mnt;
295 FILE *f;
296
297 f = fopen("/proc/mounts", "r");
298 if (f == NULL)
299 return NULL;
300
301 while ((mnt = getmntent(f))) {
302 if (strcmp(mnt->mnt_type, "cgroup2") == 0) {
303 fclose(f);
304 return strdup(mnt->mnt_dir);
305 }
306 }
307
308 fclose(f);
309 return NULL;
310}
311
312static int do_show_tree(int argc, char **argv)
313{
314 char *cgroup_root, *cgroup_alloced = NULL;
315 int ret;
316
317 query_flags = 0;
318
319 if (!argc) {
320 cgroup_alloced = find_cgroup_root();
321 if (!cgroup_alloced) {
322 p_err("cgroup v2 isn't mounted");
323 return -1;
324 }
325 cgroup_root = cgroup_alloced;
326 } else {
327 cgroup_root = GET_ARG();
328
329 while (argc) {
330 if (is_prefix(*argv, "effective")) {
331 if (query_flags & BPF_F_QUERY_EFFECTIVE) {
332 p_err("duplicated argument: %s", *argv);
333 return -1;
334 }
335 query_flags |= BPF_F_QUERY_EFFECTIVE;
336 NEXT_ARG();
337 } else {
338 p_err("expected no more arguments, 'effective', got: '%s'?",
339 *argv);
340 return -1;
341 }
342 }
343 }
344
345 if (json_output)
346 jsonw_start_array(json_wtr);
347 else
348 printf("%s\n"
349 "%-8s %-15s %-15s %-15s\n",
350 "CgroupPath",
351 "ID", "AttachType", "AttachFlags", "Name");
352
353 switch (nftw(cgroup_root, do_show_tree_fn, 1024, FTW_MOUNT)) {
354 case NFTW_ERR:
355 p_err("can't iterate over %s: %s", cgroup_root,
356 strerror(errno));
357 ret = -1;
358 break;
359 case SHOW_TREE_FN_ERR:
360 ret = -1;
361 break;
362 default:
363 ret = 0;
364 }
365
366 if (json_output)
367 jsonw_end_array(json_wtr);
368
369 free(cgroup_alloced);
370
371 return ret;
372}
373
374static int do_attach(int argc, char **argv)
375{
376 enum bpf_attach_type attach_type;
377 int cgroup_fd, prog_fd;
378 int attach_flags = 0;
379 int ret = -1;
380 int i;
381
382 if (argc < 4) {
383 p_err("too few parameters for cgroup attach");
384 goto exit;
385 }
386
387 cgroup_fd = open(argv[0], O_RDONLY);
388 if (cgroup_fd < 0) {
389 p_err("can't open cgroup %s", argv[0]);
390 goto exit;
391 }
392
393 attach_type = parse_attach_type(argv[1]);
394 if (attach_type == __MAX_BPF_ATTACH_TYPE) {
395 p_err("invalid attach type");
396 goto exit_cgroup;
397 }
398
399 argc -= 2;
400 argv = &argv[2];
401 prog_fd = prog_parse_fd(&argc, &argv);
402 if (prog_fd < 0)
403 goto exit_cgroup;
404
405 for (i = 0; i < argc; i++) {
406 if (is_prefix(argv[i], "multi")) {
407 attach_flags |= BPF_F_ALLOW_MULTI;
408 } else if (is_prefix(argv[i], "override")) {
409 attach_flags |= BPF_F_ALLOW_OVERRIDE;
410 } else {
411 p_err("unknown option: %s", argv[i]);
412 goto exit_cgroup;
413 }
414 }
415
416 if (bpf_prog_attach(prog_fd, cgroup_fd, attach_type, attach_flags)) {
417 p_err("failed to attach program");
418 goto exit_prog;
419 }
420
421 if (json_output)
422 jsonw_null(json_wtr);
423
424 ret = 0;
425
426exit_prog:
427 close(prog_fd);
428exit_cgroup:
429 close(cgroup_fd);
430exit:
431 return ret;
432}
433
434static int do_detach(int argc, char **argv)
435{
436 enum bpf_attach_type attach_type;
437 int prog_fd, cgroup_fd;
438 int ret = -1;
439
440 if (argc < 4) {
441 p_err("too few parameters for cgroup detach");
442 goto exit;
443 }
444
445 cgroup_fd = open(argv[0], O_RDONLY);
446 if (cgroup_fd < 0) {
447 p_err("can't open cgroup %s", argv[0]);
448 goto exit;
449 }
450
451 attach_type = parse_attach_type(argv[1]);
452 if (attach_type == __MAX_BPF_ATTACH_TYPE) {
453 p_err("invalid attach type");
454 goto exit_cgroup;
455 }
456
457 argc -= 2;
458 argv = &argv[2];
459 prog_fd = prog_parse_fd(&argc, &argv);
460 if (prog_fd < 0)
461 goto exit_cgroup;
462
463 if (bpf_prog_detach2(prog_fd, cgroup_fd, attach_type)) {
464 p_err("failed to detach program");
465 goto exit_prog;
466 }
467
468 if (json_output)
469 jsonw_null(json_wtr);
470
471 ret = 0;
472
473exit_prog:
474 close(prog_fd);
475exit_cgroup:
476 close(cgroup_fd);
477exit:
478 return ret;
479}
480
481static int do_help(int argc, char **argv)
482{
483 if (json_output) {
484 jsonw_null(json_wtr);
485 return 0;
486 }
487
488 fprintf(stderr,
489 "Usage: %s %s { show | list } CGROUP [**effective**]\n"
490 " %s %s tree [CGROUP_ROOT] [**effective**]\n"
491 " %s %s attach CGROUP ATTACH_TYPE PROG [ATTACH_FLAGS]\n"
492 " %s %s detach CGROUP ATTACH_TYPE PROG\n"
493 " %s %s help\n"
494 "\n"
495 HELP_SPEC_ATTACH_TYPES "\n"
496 " " HELP_SPEC_ATTACH_FLAGS "\n"
497 " " HELP_SPEC_PROGRAM "\n"
498 " " HELP_SPEC_OPTIONS "\n"
499 "",
500 bin_name, argv[-2],
501 bin_name, argv[-2], bin_name, argv[-2],
502 bin_name, argv[-2], bin_name, argv[-2]);
503
504 return 0;
505}
506
507static const struct cmd cmds[] = {
508 { "show", do_show },
509 { "list", do_show },
510 { "tree", do_show_tree },
511 { "attach", do_attach },
512 { "detach", do_detach },
513 { "help", do_help },
514 { 0 }
515};
516
517int do_cgroup(int argc, char **argv)
518{
519 return cmd_select(cmds, argc, argv, do_help);
520}