1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2020 Facebook */
11 #include <bpf/hashmap.h>
13 #include "json_writer.h"
16 static struct hashmap *link_table;
18 static int link_parse_fd(int *argc, char ***argv)
22 if (is_prefix(**argv, "id")) {
28 id = strtoul(**argv, &endptr, 0);
30 p_err("can't parse %s as ID", **argv);
35 fd = bpf_link_get_fd_by_id(id);
37 p_err("failed to get link with ID %d: %s", id, strerror(errno));
39 } else if (is_prefix(**argv, "pinned")) {
47 return open_obj_pinned_any(path, BPF_OBJ_LINK);
50 p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
55 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)
57 const char *link_type_str;
59 jsonw_uint_field(wtr, "id", info->id);
60 link_type_str = libbpf_bpf_link_type_str(info->type);
62 jsonw_string_field(wtr, "type", link_type_str);
64 jsonw_uint_field(wtr, "type", info->type);
66 jsonw_uint_field(json_wtr, "prog_id", info->prog_id);
69 static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr)
71 const char *attach_type_str;
73 attach_type_str = libbpf_bpf_attach_type_str(attach_type);
75 jsonw_string_field(wtr, "attach_type", attach_type_str);
77 jsonw_uint_field(wtr, "attach_type", attach_type);
80 static bool is_iter_map_target(const char *target_name)
82 return strcmp(target_name, "bpf_map_elem") == 0 ||
83 strcmp(target_name, "bpf_sk_storage_map") == 0;
86 static bool is_iter_cgroup_target(const char *target_name)
88 return strcmp(target_name, "cgroup") == 0;
91 static const char *cgroup_order_string(__u32 order)
94 case BPF_CGROUP_ITER_ORDER_UNSPEC:
95 return "order_unspec";
96 case BPF_CGROUP_ITER_SELF_ONLY:
98 case BPF_CGROUP_ITER_DESCENDANTS_PRE:
99 return "descendants_pre";
100 case BPF_CGROUP_ITER_DESCENDANTS_POST:
101 return "descendants_post";
102 case BPF_CGROUP_ITER_ANCESTORS_UP:
103 return "ancestors_up";
104 default: /* won't happen */
109 static bool is_iter_task_target(const char *target_name)
111 return strcmp(target_name, "task") == 0 ||
112 strcmp(target_name, "task_file") == 0 ||
113 strcmp(target_name, "task_vma") == 0;
116 static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr)
118 const char *target_name = u64_to_ptr(info->iter.target_name);
120 jsonw_string_field(wtr, "target_name", target_name);
122 if (is_iter_map_target(target_name))
123 jsonw_uint_field(wtr, "map_id", info->iter.map.map_id);
124 else if (is_iter_task_target(target_name)) {
125 if (info->iter.task.tid)
126 jsonw_uint_field(wtr, "tid", info->iter.task.tid);
127 else if (info->iter.task.pid)
128 jsonw_uint_field(wtr, "pid", info->iter.task.pid);
131 if (is_iter_cgroup_target(target_name)) {
132 jsonw_lluint_field(wtr, "cgroup_id", info->iter.cgroup.cgroup_id);
133 jsonw_string_field(wtr, "order",
134 cgroup_order_string(info->iter.cgroup.order));
138 static int get_prog_info(int prog_id, struct bpf_prog_info *info)
140 __u32 len = sizeof(*info);
143 prog_fd = bpf_prog_get_fd_by_id(prog_id);
147 memset(info, 0, sizeof(*info));
148 err = bpf_prog_get_info_by_fd(prog_fd, info, &len);
150 p_err("can't get prog info: %s", strerror(errno));
155 static int show_link_close_json(int fd, struct bpf_link_info *info)
157 struct bpf_prog_info prog_info;
158 const char *prog_type_str;
161 jsonw_start_object(json_wtr);
163 show_link_header_json(info, json_wtr);
165 switch (info->type) {
166 case BPF_LINK_TYPE_RAW_TRACEPOINT:
167 jsonw_string_field(json_wtr, "tp_name",
168 u64_to_ptr(info->raw_tracepoint.tp_name));
170 case BPF_LINK_TYPE_TRACING:
171 err = get_prog_info(info->prog_id, &prog_info);
175 prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
176 /* libbpf will return NULL for variants unknown to it. */
178 jsonw_string_field(json_wtr, "prog_type", prog_type_str);
180 jsonw_uint_field(json_wtr, "prog_type", prog_info.type);
182 show_link_attach_type_json(info->tracing.attach_type,
185 case BPF_LINK_TYPE_CGROUP:
186 jsonw_lluint_field(json_wtr, "cgroup_id",
187 info->cgroup.cgroup_id);
188 show_link_attach_type_json(info->cgroup.attach_type, json_wtr);
190 case BPF_LINK_TYPE_ITER:
191 show_iter_json(info, json_wtr);
193 case BPF_LINK_TYPE_NETNS:
194 jsonw_uint_field(json_wtr, "netns_ino",
195 info->netns.netns_ino);
196 show_link_attach_type_json(info->netns.attach_type, json_wtr);
202 if (!hashmap__empty(link_table)) {
203 struct hashmap_entry *entry;
205 jsonw_name(json_wtr, "pinned");
206 jsonw_start_array(json_wtr);
207 hashmap__for_each_key_entry(link_table, entry, info->id)
208 jsonw_string(json_wtr, entry->pvalue);
209 jsonw_end_array(json_wtr);
212 emit_obj_refs_json(refs_table, info->id, json_wtr);
214 jsonw_end_object(json_wtr);
219 static void show_link_header_plain(struct bpf_link_info *info)
221 const char *link_type_str;
223 printf("%u: ", info->id);
224 link_type_str = libbpf_bpf_link_type_str(info->type);
226 printf("%s ", link_type_str);
228 printf("type %u ", info->type);
230 printf("prog %u ", info->prog_id);
233 static void show_link_attach_type_plain(__u32 attach_type)
235 const char *attach_type_str;
237 attach_type_str = libbpf_bpf_attach_type_str(attach_type);
239 printf("attach_type %s ", attach_type_str);
241 printf("attach_type %u ", attach_type);
244 static void show_iter_plain(struct bpf_link_info *info)
246 const char *target_name = u64_to_ptr(info->iter.target_name);
248 printf("target_name %s ", target_name);
250 if (is_iter_map_target(target_name))
251 printf("map_id %u ", info->iter.map.map_id);
252 else if (is_iter_task_target(target_name)) {
253 if (info->iter.task.tid)
254 printf("tid %u ", info->iter.task.tid);
255 else if (info->iter.task.pid)
256 printf("pid %u ", info->iter.task.pid);
259 if (is_iter_cgroup_target(target_name)) {
260 printf("cgroup_id %llu ", info->iter.cgroup.cgroup_id);
262 cgroup_order_string(info->iter.cgroup.order));
266 static int show_link_close_plain(int fd, struct bpf_link_info *info)
268 struct bpf_prog_info prog_info;
269 const char *prog_type_str;
272 show_link_header_plain(info);
274 switch (info->type) {
275 case BPF_LINK_TYPE_RAW_TRACEPOINT:
276 printf("\n\ttp '%s' ",
277 (const char *)u64_to_ptr(info->raw_tracepoint.tp_name));
279 case BPF_LINK_TYPE_TRACING:
280 err = get_prog_info(info->prog_id, &prog_info);
284 prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
285 /* libbpf will return NULL for variants unknown to it. */
287 printf("\n\tprog_type %s ", prog_type_str);
289 printf("\n\tprog_type %u ", prog_info.type);
291 show_link_attach_type_plain(info->tracing.attach_type);
293 case BPF_LINK_TYPE_CGROUP:
294 printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id);
295 show_link_attach_type_plain(info->cgroup.attach_type);
297 case BPF_LINK_TYPE_ITER:
298 show_iter_plain(info);
300 case BPF_LINK_TYPE_NETNS:
301 printf("\n\tnetns_ino %u ", info->netns.netns_ino);
302 show_link_attach_type_plain(info->netns.attach_type);
308 if (!hashmap__empty(link_table)) {
309 struct hashmap_entry *entry;
311 hashmap__for_each_key_entry(link_table, entry, info->id)
312 printf("\n\tpinned %s", (char *)entry->pvalue);
314 emit_obj_refs_plain(refs_table, info->id, "\n\tpids ");
321 static int do_show_link(int fd)
323 struct bpf_link_info info;
324 __u32 len = sizeof(info);
328 memset(&info, 0, sizeof(info));
330 err = bpf_link_get_info_by_fd(fd, &info, &len);
332 p_err("can't get link info: %s",
337 if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT &&
338 !info.raw_tracepoint.tp_name) {
339 info.raw_tracepoint.tp_name = (unsigned long)&buf;
340 info.raw_tracepoint.tp_name_len = sizeof(buf);
343 if (info.type == BPF_LINK_TYPE_ITER &&
344 !info.iter.target_name) {
345 info.iter.target_name = (unsigned long)&buf;
346 info.iter.target_name_len = sizeof(buf);
351 show_link_close_json(fd, &info);
353 show_link_close_plain(fd, &info);
359 static int do_show(int argc, char **argv)
365 link_table = hashmap__new(hash_fn_for_key_as_id,
366 equal_fn_for_key_as_id, NULL);
367 if (IS_ERR(link_table)) {
368 p_err("failed to create hashmap for pinned paths");
371 build_pinned_obj_table(link_table, BPF_OBJ_LINK);
373 build_obj_refs_table(&refs_table, BPF_OBJ_LINK);
376 fd = link_parse_fd(&argc, &argv);
379 return do_show_link(fd);
386 jsonw_start_array(json_wtr);
388 err = bpf_link_get_next_id(id, &id);
392 p_err("can't get next link: %s%s", strerror(errno),
393 errno == EINVAL ? " -- kernel too old?" : "");
397 fd = bpf_link_get_fd_by_id(id);
401 p_err("can't get link by id (%u): %s",
402 id, strerror(errno));
406 err = do_show_link(fd);
411 jsonw_end_array(json_wtr);
413 delete_obj_refs_table(refs_table);
416 delete_pinned_obj_table(link_table);
418 return errno == ENOENT ? 0 : -1;
421 static int do_pin(int argc, char **argv)
425 err = do_pin_any(argc, argv, link_parse_fd);
426 if (!err && json_output)
427 jsonw_null(json_wtr);
431 static int do_detach(int argc, char **argv)
436 p_err("link specifier is invalid or missing\n");
440 fd = link_parse_fd(&argc, &argv);
444 err = bpf_link_detach(fd);
449 p_err("failed link detach: %s", strerror(-err));
454 jsonw_null(json_wtr);
459 static int do_help(int argc, char **argv)
462 jsonw_null(json_wtr);
467 "Usage: %1$s %2$s { show | list } [LINK]\n"
468 " %1$s %2$s pin LINK FILE\n"
469 " %1$s %2$s detach LINK\n"
472 " " HELP_SPEC_LINK "\n"
473 " " HELP_SPEC_OPTIONS " |\n"
474 " {-f|--bpffs} | {-n|--nomount} }\n"
481 static const struct cmd cmds[] = {
486 { "detach", do_detach },
490 int do_link(int argc, char **argv)
492 return cmd_select(cmds, argc, argv, do_help);