Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2/* Copyright (C) 2020 Facebook */
3
4#include <errno.h>
5#include <net/if.h>
6#include <stdio.h>
7#include <unistd.h>
8
9#include <bpf/bpf.h>
10
11#include "json_writer.h"
12#include "main.h"
13
14static const char * const link_type_name[] = {
15 [BPF_LINK_TYPE_UNSPEC] = "unspec",
16 [BPF_LINK_TYPE_RAW_TRACEPOINT] = "raw_tracepoint",
17 [BPF_LINK_TYPE_TRACING] = "tracing",
18 [BPF_LINK_TYPE_CGROUP] = "cgroup",
19 [BPF_LINK_TYPE_ITER] = "iter",
20 [BPF_LINK_TYPE_NETNS] = "netns",
21};
22
23static int link_parse_fd(int *argc, char ***argv)
24{
25 int fd;
26
27 if (is_prefix(**argv, "id")) {
28 unsigned int id;
29 char *endptr;
30
31 NEXT_ARGP();
32
33 id = strtoul(**argv, &endptr, 0);
34 if (*endptr) {
35 p_err("can't parse %s as ID", **argv);
36 return -1;
37 }
38 NEXT_ARGP();
39
40 fd = bpf_link_get_fd_by_id(id);
41 if (fd < 0)
42 p_err("failed to get link with ID %d: %s", id, strerror(errno));
43 return fd;
44 } else if (is_prefix(**argv, "pinned")) {
45 char *path;
46
47 NEXT_ARGP();
48
49 path = **argv;
50 NEXT_ARGP();
51
52 return open_obj_pinned_any(path, BPF_OBJ_LINK);
53 }
54
55 p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
56 return -1;
57}
58
59static void
60show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)
61{
62 jsonw_uint_field(wtr, "id", info->id);
63 if (info->type < ARRAY_SIZE(link_type_name))
64 jsonw_string_field(wtr, "type", link_type_name[info->type]);
65 else
66 jsonw_uint_field(wtr, "type", info->type);
67
68 jsonw_uint_field(json_wtr, "prog_id", info->prog_id);
69}
70
71static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr)
72{
73 if (attach_type < ARRAY_SIZE(attach_type_name))
74 jsonw_string_field(wtr, "attach_type",
75 attach_type_name[attach_type]);
76 else
77 jsonw_uint_field(wtr, "attach_type", attach_type);
78}
79
80static int get_prog_info(int prog_id, struct bpf_prog_info *info)
81{
82 __u32 len = sizeof(*info);
83 int err, prog_fd;
84
85 prog_fd = bpf_prog_get_fd_by_id(prog_id);
86 if (prog_fd < 0)
87 return prog_fd;
88
89 memset(info, 0, sizeof(*info));
90 err = bpf_obj_get_info_by_fd(prog_fd, info, &len);
91 if (err)
92 p_err("can't get prog info: %s", strerror(errno));
93 close(prog_fd);
94 return err;
95}
96
97static int show_link_close_json(int fd, struct bpf_link_info *info)
98{
99 struct bpf_prog_info prog_info;
100 int err;
101
102 jsonw_start_object(json_wtr);
103
104 show_link_header_json(info, json_wtr);
105
106 switch (info->type) {
107 case BPF_LINK_TYPE_RAW_TRACEPOINT:
108 jsonw_string_field(json_wtr, "tp_name",
109 u64_to_ptr(info->raw_tracepoint.tp_name));
110 break;
111 case BPF_LINK_TYPE_TRACING:
112 err = get_prog_info(info->prog_id, &prog_info);
113 if (err)
114 return err;
115
116 if (prog_info.type < prog_type_name_size)
117 jsonw_string_field(json_wtr, "prog_type",
118 prog_type_name[prog_info.type]);
119 else
120 jsonw_uint_field(json_wtr, "prog_type",
121 prog_info.type);
122
123 show_link_attach_type_json(info->tracing.attach_type,
124 json_wtr);
125 break;
126 case BPF_LINK_TYPE_CGROUP:
127 jsonw_lluint_field(json_wtr, "cgroup_id",
128 info->cgroup.cgroup_id);
129 show_link_attach_type_json(info->cgroup.attach_type, json_wtr);
130 break;
131 case BPF_LINK_TYPE_NETNS:
132 jsonw_uint_field(json_wtr, "netns_ino",
133 info->netns.netns_ino);
134 show_link_attach_type_json(info->netns.attach_type, json_wtr);
135 break;
136 default:
137 break;
138 }
139
140 if (!hash_empty(link_table.table)) {
141 struct pinned_obj *obj;
142
143 jsonw_name(json_wtr, "pinned");
144 jsonw_start_array(json_wtr);
145 hash_for_each_possible(link_table.table, obj, hash, info->id) {
146 if (obj->id == info->id)
147 jsonw_string(json_wtr, obj->path);
148 }
149 jsonw_end_array(json_wtr);
150 }
151
152 emit_obj_refs_json(&refs_table, info->id, json_wtr);
153
154 jsonw_end_object(json_wtr);
155
156 return 0;
157}
158
159static void show_link_header_plain(struct bpf_link_info *info)
160{
161 printf("%u: ", info->id);
162 if (info->type < ARRAY_SIZE(link_type_name))
163 printf("%s ", link_type_name[info->type]);
164 else
165 printf("type %u ", info->type);
166
167 printf("prog %u ", info->prog_id);
168}
169
170static void show_link_attach_type_plain(__u32 attach_type)
171{
172 if (attach_type < ARRAY_SIZE(attach_type_name))
173 printf("attach_type %s ", attach_type_name[attach_type]);
174 else
175 printf("attach_type %u ", attach_type);
176}
177
178static int show_link_close_plain(int fd, struct bpf_link_info *info)
179{
180 struct bpf_prog_info prog_info;
181 int err;
182
183 show_link_header_plain(info);
184
185 switch (info->type) {
186 case BPF_LINK_TYPE_RAW_TRACEPOINT:
187 printf("\n\ttp '%s' ",
188 (const char *)u64_to_ptr(info->raw_tracepoint.tp_name));
189 break;
190 case BPF_LINK_TYPE_TRACING:
191 err = get_prog_info(info->prog_id, &prog_info);
192 if (err)
193 return err;
194
195 if (prog_info.type < prog_type_name_size)
196 printf("\n\tprog_type %s ",
197 prog_type_name[prog_info.type]);
198 else
199 printf("\n\tprog_type %u ", prog_info.type);
200
201 show_link_attach_type_plain(info->tracing.attach_type);
202 break;
203 case BPF_LINK_TYPE_CGROUP:
204 printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id);
205 show_link_attach_type_plain(info->cgroup.attach_type);
206 break;
207 case BPF_LINK_TYPE_NETNS:
208 printf("\n\tnetns_ino %u ", info->netns.netns_ino);
209 show_link_attach_type_plain(info->netns.attach_type);
210 break;
211 default:
212 break;
213 }
214
215 if (!hash_empty(link_table.table)) {
216 struct pinned_obj *obj;
217
218 hash_for_each_possible(link_table.table, obj, hash, info->id) {
219 if (obj->id == info->id)
220 printf("\n\tpinned %s", obj->path);
221 }
222 }
223 emit_obj_refs_plain(&refs_table, info->id, "\n\tpids ");
224
225 printf("\n");
226
227 return 0;
228}
229
230static int do_show_link(int fd)
231{
232 struct bpf_link_info info;
233 __u32 len = sizeof(info);
234 char raw_tp_name[256];
235 int err;
236
237 memset(&info, 0, sizeof(info));
238again:
239 err = bpf_obj_get_info_by_fd(fd, &info, &len);
240 if (err) {
241 p_err("can't get link info: %s",
242 strerror(errno));
243 close(fd);
244 return err;
245 }
246 if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT &&
247 !info.raw_tracepoint.tp_name) {
248 info.raw_tracepoint.tp_name = (unsigned long)&raw_tp_name;
249 info.raw_tracepoint.tp_name_len = sizeof(raw_tp_name);
250 goto again;
251 }
252
253 if (json_output)
254 show_link_close_json(fd, &info);
255 else
256 show_link_close_plain(fd, &info);
257
258 close(fd);
259 return 0;
260}
261
262static int do_show(int argc, char **argv)
263{
264 __u32 id = 0;
265 int err, fd;
266
267 if (show_pinned)
268 build_pinned_obj_table(&link_table, BPF_OBJ_LINK);
269 build_obj_refs_table(&refs_table, BPF_OBJ_LINK);
270
271 if (argc == 2) {
272 fd = link_parse_fd(&argc, &argv);
273 if (fd < 0)
274 return fd;
275 return do_show_link(fd);
276 }
277
278 if (argc)
279 return BAD_ARG();
280
281 if (json_output)
282 jsonw_start_array(json_wtr);
283 while (true) {
284 err = bpf_link_get_next_id(id, &id);
285 if (err) {
286 if (errno == ENOENT)
287 break;
288 p_err("can't get next link: %s%s", strerror(errno),
289 errno == EINVAL ? " -- kernel too old?" : "");
290 break;
291 }
292
293 fd = bpf_link_get_fd_by_id(id);
294 if (fd < 0) {
295 if (errno == ENOENT)
296 continue;
297 p_err("can't get link by id (%u): %s",
298 id, strerror(errno));
299 break;
300 }
301
302 err = do_show_link(fd);
303 if (err)
304 break;
305 }
306 if (json_output)
307 jsonw_end_array(json_wtr);
308
309 delete_obj_refs_table(&refs_table);
310
311 return errno == ENOENT ? 0 : -1;
312}
313
314static int do_pin(int argc, char **argv)
315{
316 int err;
317
318 err = do_pin_any(argc, argv, link_parse_fd);
319 if (!err && json_output)
320 jsonw_null(json_wtr);
321 return err;
322}
323
324static int do_detach(int argc, char **argv)
325{
326 int err, fd;
327
328 if (argc != 2) {
329 p_err("link specifier is invalid or missing\n");
330 return 1;
331 }
332
333 fd = link_parse_fd(&argc, &argv);
334 if (fd < 0)
335 return 1;
336
337 err = bpf_link_detach(fd);
338 if (err)
339 err = -errno;
340 close(fd);
341 if (err) {
342 p_err("failed link detach: %s", strerror(-err));
343 return 1;
344 }
345
346 if (json_output)
347 jsonw_null(json_wtr);
348
349 return 0;
350}
351
352static int do_help(int argc, char **argv)
353{
354 if (json_output) {
355 jsonw_null(json_wtr);
356 return 0;
357 }
358
359 fprintf(stderr,
360 "Usage: %1$s %2$s { show | list } [LINK]\n"
361 " %1$s %2$s pin LINK FILE\n"
362 " %1$s %2$s detach LINK\n"
363 " %1$s %2$s help\n"
364 "\n"
365 " " HELP_SPEC_LINK "\n"
366 " " HELP_SPEC_OPTIONS "\n"
367 "",
368 bin_name, argv[-2]);
369
370 return 0;
371}
372
373static const struct cmd cmds[] = {
374 { "show", do_show },
375 { "list", do_show },
376 { "help", do_help },
377 { "pin", do_pin },
378 { "detach", do_detach },
379 { 0 }
380};
381
382int do_link(int argc, char **argv)
383{
384 return cmd_select(cmds, argc, argv, do_help);
385}