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 | |
41 | static unsigned int query_flags; |
42 | static struct btf *btf_vmlinux; |
43 | static __u32 btf_vmlinux_id; |
44 | |
45 | static 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(t: type); |
63 | if (!attach_type_str) |
64 | break; |
65 | if (is_prefix(pfx: str, str: attach_type_str)) |
66 | return type; |
67 | } |
68 | |
69 | return __MAX_BPF_ATTACH_TYPE; |
70 | } |
71 | |
72 | static 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(ptr: 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 | |
94 | out: |
95 | close(fd); |
96 | } |
97 | |
98 | static 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(attach_btf_obj_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(prog_info: &info, prog_fd, name_buff: prog_name, buff_len: sizeof(prog_name)); |
134 | if (json_output) { |
135 | jsonw_start_object(self: json_wtr); |
136 | jsonw_uint_field(self: json_wtr, prop: "id" , num: info.id); |
137 | if (attach_type_str) |
138 | jsonw_string_field(self: json_wtr, prop: "attach_type" , val: attach_type_str); |
139 | else |
140 | jsonw_uint_field(self: json_wtr, prop: "attach_type" , num: attach_type); |
141 | if (!(query_flags & BPF_F_QUERY_EFFECTIVE)) |
142 | jsonw_string_field(self: json_wtr, prop: "attach_flags" , val: attach_flags_str); |
143 | jsonw_string_field(self: json_wtr, prop: "name" , val: prog_name); |
144 | if (attach_btf_name) |
145 | jsonw_string_field(self: json_wtr, prop: "attach_btf_name" , val: attach_btf_name); |
146 | jsonw_uint_field(self: json_wtr, prop: "attach_btf_obj_id" , num: info.attach_btf_obj_id); |
147 | jsonw_uint_field(self: json_wtr, prop: "attach_btf_id" , num: info.attach_btf_id); |
148 | jsonw_end_object(self: 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 | |
171 | static 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 | |
184 | static 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 | |
204 | static 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(id: prog_ids[iter], attach_type: type, NULL, level); |
225 | |
226 | return 0; |
227 | } |
228 | |
229 | static 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, size: sizeof(buf), fmt: "unknown(%x)" , attach_flags); |
269 | attach_flags_str = buf; |
270 | } |
271 | |
272 | show_bpf_prog(id: prog_ids[iter], attach_type: type, |
273 | attach_flags_str, level); |
274 | } |
275 | |
276 | return 0; |
277 | } |
278 | |
279 | static 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 | |
287 | static 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(pfx: *argv, str: "effective" )) { |
303 | if (query_flags & BPF_F_QUERY_EFFECTIVE) { |
304 | p_err(fmt: "duplicated argument: %s" , *argv); |
305 | return -1; |
306 | } |
307 | query_flags |= BPF_F_QUERY_EFFECTIVE; |
308 | NEXT_ARG(); |
309 | } else { |
310 | p_err(fmt: "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(fmt: "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(fmt: "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(self: 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, level: 0) == 0) |
349 | ret = 0; |
350 | } |
351 | |
352 | if (json_output) |
353 | jsonw_end_array(self: json_wtr); |
354 | |
355 | exit_cgroup: |
356 | close(cgroup_fd); |
357 | exit: |
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 |
368 | static 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(fmt: "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(fmt: "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(self: json_wtr); |
397 | jsonw_string_field(self: json_wtr, prop: "cgroup" , val: fpath); |
398 | jsonw_name(self: json_wtr, name: "programs" ); |
399 | jsonw_start_array(self: 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, level: 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(self: json_wtr); |
417 | jsonw_end_object(self: json_wtr); |
418 | } |
419 | |
420 | close(cgroup_fd); |
421 | |
422 | return 0; |
423 | } |
424 | |
425 | static 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 | |
445 | static 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(fmt: "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(pfx: *argv, str: "effective" )) { |
464 | if (query_flags & BPF_F_QUERY_EFFECTIVE) { |
465 | p_err(fmt: "duplicated argument: %s" , *argv); |
466 | return -1; |
467 | } |
468 | query_flags |= BPF_F_QUERY_EFFECTIVE; |
469 | NEXT_ARG(); |
470 | } else { |
471 | p_err(fmt: "expected no more arguments, 'effective', got: '%s'?" , |
472 | *argv); |
473 | return -1; |
474 | } |
475 | } |
476 | } |
477 | |
478 | if (json_output) |
479 | jsonw_start_array(self: 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(self: json_wtr); |
506 | |
507 | free(cgroup_alloced); |
508 | |
509 | return ret; |
510 | } |
511 | |
512 | static 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(fmt: "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(fmt: "can't open cgroup %s" , argv[0]); |
528 | goto exit; |
529 | } |
530 | |
531 | attach_type = parse_attach_type(str: argv[1]); |
532 | if (attach_type == __MAX_BPF_ATTACH_TYPE) { |
533 | p_err(fmt: "invalid attach type" ); |
534 | goto exit_cgroup; |
535 | } |
536 | |
537 | argc -= 2; |
538 | argv = &argv[2]; |
539 | prog_fd = prog_parse_fd(argc: &argc, argv: &argv); |
540 | if (prog_fd < 0) |
541 | goto exit_cgroup; |
542 | |
543 | for (i = 0; i < argc; i++) { |
544 | if (is_prefix(pfx: argv[i], str: "multi" )) { |
545 | attach_flags |= BPF_F_ALLOW_MULTI; |
546 | } else if (is_prefix(pfx: argv[i], str: "override" )) { |
547 | attach_flags |= BPF_F_ALLOW_OVERRIDE; |
548 | } else { |
549 | p_err(fmt: "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(fmt: "failed to attach program" ); |
556 | goto exit_prog; |
557 | } |
558 | |
559 | if (json_output) |
560 | jsonw_null(self: json_wtr); |
561 | |
562 | ret = 0; |
563 | |
564 | exit_prog: |
565 | close(prog_fd); |
566 | exit_cgroup: |
567 | close(cgroup_fd); |
568 | exit: |
569 | return ret; |
570 | } |
571 | |
572 | static 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(fmt: "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(fmt: "can't open cgroup %s" , argv[0]); |
586 | goto exit; |
587 | } |
588 | |
589 | attach_type = parse_attach_type(str: argv[1]); |
590 | if (attach_type == __MAX_BPF_ATTACH_TYPE) { |
591 | p_err(fmt: "invalid attach type" ); |
592 | goto exit_cgroup; |
593 | } |
594 | |
595 | argc -= 2; |
596 | argv = &argv[2]; |
597 | prog_fd = prog_parse_fd(argc: &argc, argv: &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(fmt: "failed to detach program" ); |
603 | goto exit_prog; |
604 | } |
605 | |
606 | if (json_output) |
607 | jsonw_null(self: json_wtr); |
608 | |
609 | ret = 0; |
610 | |
611 | exit_prog: |
612 | close(prog_fd); |
613 | exit_cgroup: |
614 | close(cgroup_fd); |
615 | exit: |
616 | return ret; |
617 | } |
618 | |
619 | static int do_help(int argc, char **argv) |
620 | { |
621 | if (json_output) { |
622 | jsonw_null(self: 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 | |
644 | static 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 | |
654 | int do_cgroup(int argc, char **argv) |
655 | { |
656 | return cmd_select(cmds, argc, argv, help: do_help); |
657 | } |
658 | |