1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2020 Facebook */
3
4 #include <errno.h>
5 #include <linux/err.h>
6 #include <netinet/in.h>
7 #include <linux/netfilter.h>
8 #include <linux/netfilter_arp.h>
9 #include <linux/perf_event.h>
10 #include <net/if.h>
11 #include <stdio.h>
12 #include <unistd.h>
13
14 #include <bpf/bpf.h>
15 #include <bpf/hashmap.h>
16
17 #include "json_writer.h"
18 #include "main.h"
19 #include "xlated_dumper.h"
20
21 #define PERF_HW_CACHE_LEN 128
22
23 static struct hashmap *link_table;
24 static struct dump_data dd;
25
26 static const char *perf_type_name[PERF_TYPE_MAX] = {
27 [PERF_TYPE_HARDWARE] = "hardware",
28 [PERF_TYPE_SOFTWARE] = "software",
29 [PERF_TYPE_TRACEPOINT] = "tracepoint",
30 [PERF_TYPE_HW_CACHE] = "hw-cache",
31 [PERF_TYPE_RAW] = "raw",
32 [PERF_TYPE_BREAKPOINT] = "breakpoint",
33 };
34
35 const char *event_symbols_hw[PERF_COUNT_HW_MAX] = {
36 [PERF_COUNT_HW_CPU_CYCLES] = "cpu-cycles",
37 [PERF_COUNT_HW_INSTRUCTIONS] = "instructions",
38 [PERF_COUNT_HW_CACHE_REFERENCES] = "cache-references",
39 [PERF_COUNT_HW_CACHE_MISSES] = "cache-misses",
40 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = "branch-instructions",
41 [PERF_COUNT_HW_BRANCH_MISSES] = "branch-misses",
42 [PERF_COUNT_HW_BUS_CYCLES] = "bus-cycles",
43 [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = "stalled-cycles-frontend",
44 [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = "stalled-cycles-backend",
45 [PERF_COUNT_HW_REF_CPU_CYCLES] = "ref-cycles",
46 };
47
48 const char *event_symbols_sw[PERF_COUNT_SW_MAX] = {
49 [PERF_COUNT_SW_CPU_CLOCK] = "cpu-clock",
50 [PERF_COUNT_SW_TASK_CLOCK] = "task-clock",
51 [PERF_COUNT_SW_PAGE_FAULTS] = "page-faults",
52 [PERF_COUNT_SW_CONTEXT_SWITCHES] = "context-switches",
53 [PERF_COUNT_SW_CPU_MIGRATIONS] = "cpu-migrations",
54 [PERF_COUNT_SW_PAGE_FAULTS_MIN] = "minor-faults",
55 [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = "major-faults",
56 [PERF_COUNT_SW_ALIGNMENT_FAULTS] = "alignment-faults",
57 [PERF_COUNT_SW_EMULATION_FAULTS] = "emulation-faults",
58 [PERF_COUNT_SW_DUMMY] = "dummy",
59 [PERF_COUNT_SW_BPF_OUTPUT] = "bpf-output",
60 [PERF_COUNT_SW_CGROUP_SWITCHES] = "cgroup-switches",
61 };
62
63 const char *evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX] = {
64 [PERF_COUNT_HW_CACHE_L1D] = "L1-dcache",
65 [PERF_COUNT_HW_CACHE_L1I] = "L1-icache",
66 [PERF_COUNT_HW_CACHE_LL] = "LLC",
67 [PERF_COUNT_HW_CACHE_DTLB] = "dTLB",
68 [PERF_COUNT_HW_CACHE_ITLB] = "iTLB",
69 [PERF_COUNT_HW_CACHE_BPU] = "branch",
70 [PERF_COUNT_HW_CACHE_NODE] = "node",
71 };
72
73 const char *evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX] = {
74 [PERF_COUNT_HW_CACHE_OP_READ] = "load",
75 [PERF_COUNT_HW_CACHE_OP_WRITE] = "store",
76 [PERF_COUNT_HW_CACHE_OP_PREFETCH] = "prefetch",
77 };
78
79 const char *evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX] = {
80 [PERF_COUNT_HW_CACHE_RESULT_ACCESS] = "refs",
81 [PERF_COUNT_HW_CACHE_RESULT_MISS] = "misses",
82 };
83
84 #define perf_event_name(array, id) ({ \
85 const char *event_str = NULL; \
86 \
87 if ((id) < ARRAY_SIZE(array)) \
88 event_str = array[id]; \
89 event_str; \
90 })
91
link_parse_fd(int * argc,char *** argv)92 static int link_parse_fd(int *argc, char ***argv)
93 {
94 int fd;
95
96 if (is_prefix(**argv, "id")) {
97 unsigned int id;
98 char *endptr;
99
100 NEXT_ARGP();
101
102 id = strtoul(**argv, &endptr, 0);
103 if (*endptr) {
104 p_err("can't parse %s as ID", **argv);
105 return -1;
106 }
107 NEXT_ARGP();
108
109 fd = bpf_link_get_fd_by_id(id);
110 if (fd < 0)
111 p_err("failed to get link with ID %d: %s", id, strerror(errno));
112 return fd;
113 } else if (is_prefix(**argv, "pinned")) {
114 char *path;
115
116 NEXT_ARGP();
117
118 path = **argv;
119 NEXT_ARGP();
120
121 return open_obj_pinned_any(path, BPF_OBJ_LINK);
122 }
123
124 p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
125 return -1;
126 }
127
128 static void
show_link_header_json(struct bpf_link_info * info,json_writer_t * wtr)129 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)
130 {
131 const char *link_type_str;
132
133 jsonw_uint_field(wtr, "id", info->id);
134 link_type_str = libbpf_bpf_link_type_str(info->type);
135 if (link_type_str)
136 jsonw_string_field(wtr, "type", link_type_str);
137 else
138 jsonw_uint_field(wtr, "type", info->type);
139
140 jsonw_uint_field(json_wtr, "prog_id", info->prog_id);
141 }
142
show_link_attach_type_json(__u32 attach_type,json_writer_t * wtr)143 static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr)
144 {
145 const char *attach_type_str;
146
147 attach_type_str = libbpf_bpf_attach_type_str(attach_type);
148 if (attach_type_str)
149 jsonw_string_field(wtr, "attach_type", attach_type_str);
150 else
151 jsonw_uint_field(wtr, "attach_type", attach_type);
152 }
153
show_link_ifindex_json(__u32 ifindex,json_writer_t * wtr)154 static void show_link_ifindex_json(__u32 ifindex, json_writer_t *wtr)
155 {
156 char devname[IF_NAMESIZE] = "(unknown)";
157
158 if (ifindex)
159 if_indextoname(ifindex, devname);
160 else
161 snprintf(devname, sizeof(devname), "(detached)");
162 jsonw_string_field(wtr, "devname", devname);
163 jsonw_uint_field(wtr, "ifindex", ifindex);
164 }
165
is_iter_map_target(const char * target_name)166 static bool is_iter_map_target(const char *target_name)
167 {
168 return strcmp(target_name, "bpf_map_elem") == 0 ||
169 strcmp(target_name, "bpf_sk_storage_map") == 0;
170 }
171
is_iter_cgroup_target(const char * target_name)172 static bool is_iter_cgroup_target(const char *target_name)
173 {
174 return strcmp(target_name, "cgroup") == 0;
175 }
176
cgroup_order_string(__u32 order)177 static const char *cgroup_order_string(__u32 order)
178 {
179 switch (order) {
180 case BPF_CGROUP_ITER_ORDER_UNSPEC:
181 return "order_unspec";
182 case BPF_CGROUP_ITER_SELF_ONLY:
183 return "self_only";
184 case BPF_CGROUP_ITER_DESCENDANTS_PRE:
185 return "descendants_pre";
186 case BPF_CGROUP_ITER_DESCENDANTS_POST:
187 return "descendants_post";
188 case BPF_CGROUP_ITER_ANCESTORS_UP:
189 return "ancestors_up";
190 default: /* won't happen */
191 return "unknown";
192 }
193 }
194
is_iter_task_target(const char * target_name)195 static bool is_iter_task_target(const char *target_name)
196 {
197 return strcmp(target_name, "task") == 0 ||
198 strcmp(target_name, "task_file") == 0 ||
199 strcmp(target_name, "task_vma") == 0;
200 }
201
show_iter_json(struct bpf_link_info * info,json_writer_t * wtr)202 static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr)
203 {
204 const char *target_name = u64_to_ptr(info->iter.target_name);
205
206 jsonw_string_field(wtr, "target_name", target_name);
207
208 if (is_iter_map_target(target_name))
209 jsonw_uint_field(wtr, "map_id", info->iter.map.map_id);
210 else if (is_iter_task_target(target_name)) {
211 if (info->iter.task.tid)
212 jsonw_uint_field(wtr, "tid", info->iter.task.tid);
213 else if (info->iter.task.pid)
214 jsonw_uint_field(wtr, "pid", info->iter.task.pid);
215 }
216
217 if (is_iter_cgroup_target(target_name)) {
218 jsonw_lluint_field(wtr, "cgroup_id", info->iter.cgroup.cgroup_id);
219 jsonw_string_field(wtr, "order",
220 cgroup_order_string(info->iter.cgroup.order));
221 }
222 }
223
netfilter_dump_json(const struct bpf_link_info * info,json_writer_t * wtr)224 void netfilter_dump_json(const struct bpf_link_info *info, json_writer_t *wtr)
225 {
226 jsonw_uint_field(json_wtr, "pf",
227 info->netfilter.pf);
228 jsonw_uint_field(json_wtr, "hook",
229 info->netfilter.hooknum);
230 jsonw_int_field(json_wtr, "prio",
231 info->netfilter.priority);
232 jsonw_uint_field(json_wtr, "flags",
233 info->netfilter.flags);
234 }
235
get_prog_info(int prog_id,struct bpf_prog_info * info)236 static int get_prog_info(int prog_id, struct bpf_prog_info *info)
237 {
238 __u32 len = sizeof(*info);
239 int err, prog_fd;
240
241 prog_fd = bpf_prog_get_fd_by_id(prog_id);
242 if (prog_fd < 0)
243 return prog_fd;
244
245 memset(info, 0, sizeof(*info));
246 err = bpf_prog_get_info_by_fd(prog_fd, info, &len);
247 if (err)
248 p_err("can't get prog info: %s", strerror(errno));
249 close(prog_fd);
250 return err;
251 }
252
253 struct addr_cookie {
254 __u64 addr;
255 __u64 cookie;
256 };
257
cmp_addr_cookie(const void * A,const void * B)258 static int cmp_addr_cookie(const void *A, const void *B)
259 {
260 const struct addr_cookie *a = A, *b = B;
261
262 if (a->addr == b->addr)
263 return 0;
264 return a->addr < b->addr ? -1 : 1;
265 }
266
267 static struct addr_cookie *
get_addr_cookie_array(__u64 * addrs,__u64 * cookies,__u32 count)268 get_addr_cookie_array(__u64 *addrs, __u64 *cookies, __u32 count)
269 {
270 struct addr_cookie *data;
271 __u32 i;
272
273 data = calloc(count, sizeof(data[0]));
274 if (!data) {
275 p_err("mem alloc failed");
276 return NULL;
277 }
278 for (i = 0; i < count; i++) {
279 data[i].addr = addrs[i];
280 data[i].cookie = cookies[i];
281 }
282 qsort(data, count, sizeof(data[0]), cmp_addr_cookie);
283 return data;
284 }
285
286 static void
show_kprobe_multi_json(struct bpf_link_info * info,json_writer_t * wtr)287 show_kprobe_multi_json(struct bpf_link_info *info, json_writer_t *wtr)
288 {
289 struct addr_cookie *data;
290 __u32 i, j = 0;
291
292 jsonw_bool_field(json_wtr, "retprobe",
293 info->kprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN);
294 jsonw_uint_field(json_wtr, "func_cnt", info->kprobe_multi.count);
295 jsonw_uint_field(json_wtr, "missed", info->kprobe_multi.missed);
296 jsonw_name(json_wtr, "funcs");
297 jsonw_start_array(json_wtr);
298 data = get_addr_cookie_array(u64_to_ptr(info->kprobe_multi.addrs),
299 u64_to_ptr(info->kprobe_multi.cookies),
300 info->kprobe_multi.count);
301 if (!data)
302 return;
303
304 /* Load it once for all. */
305 if (!dd.sym_count)
306 kernel_syms_load(&dd);
307 if (!dd.sym_count)
308 goto error;
309
310 for (i = 0; i < dd.sym_count; i++) {
311 if (dd.sym_mapping[i].address != data[j].addr)
312 continue;
313 jsonw_start_object(json_wtr);
314 jsonw_uint_field(json_wtr, "addr", dd.sym_mapping[i].address);
315 jsonw_string_field(json_wtr, "func", dd.sym_mapping[i].name);
316 /* Print null if it is vmlinux */
317 if (dd.sym_mapping[i].module[0] == '\0') {
318 jsonw_name(json_wtr, "module");
319 jsonw_null(json_wtr);
320 } else {
321 jsonw_string_field(json_wtr, "module", dd.sym_mapping[i].module);
322 }
323 jsonw_uint_field(json_wtr, "cookie", data[j].cookie);
324 jsonw_end_object(json_wtr);
325 if (j++ == info->kprobe_multi.count)
326 break;
327 }
328 jsonw_end_array(json_wtr);
329 error:
330 free(data);
331 }
332
u64_to_arr(__u64 val)333 static __u64 *u64_to_arr(__u64 val)
334 {
335 return (__u64 *) u64_to_ptr(val);
336 }
337
338 static void
show_uprobe_multi_json(struct bpf_link_info * info,json_writer_t * wtr)339 show_uprobe_multi_json(struct bpf_link_info *info, json_writer_t *wtr)
340 {
341 __u32 i;
342
343 jsonw_bool_field(json_wtr, "retprobe",
344 info->uprobe_multi.flags & BPF_F_UPROBE_MULTI_RETURN);
345 jsonw_string_field(json_wtr, "path", (char *) u64_to_ptr(info->uprobe_multi.path));
346 jsonw_uint_field(json_wtr, "func_cnt", info->uprobe_multi.count);
347 jsonw_int_field(json_wtr, "pid", (int) info->uprobe_multi.pid);
348 jsonw_name(json_wtr, "funcs");
349 jsonw_start_array(json_wtr);
350
351 for (i = 0; i < info->uprobe_multi.count; i++) {
352 jsonw_start_object(json_wtr);
353 jsonw_uint_field(json_wtr, "offset",
354 u64_to_arr(info->uprobe_multi.offsets)[i]);
355 jsonw_uint_field(json_wtr, "ref_ctr_offset",
356 u64_to_arr(info->uprobe_multi.ref_ctr_offsets)[i]);
357 jsonw_uint_field(json_wtr, "cookie",
358 u64_to_arr(info->uprobe_multi.cookies)[i]);
359 jsonw_end_object(json_wtr);
360 }
361 jsonw_end_array(json_wtr);
362 }
363
364 static void
show_perf_event_kprobe_json(struct bpf_link_info * info,json_writer_t * wtr)365 show_perf_event_kprobe_json(struct bpf_link_info *info, json_writer_t *wtr)
366 {
367 jsonw_bool_field(wtr, "retprobe", info->perf_event.type == BPF_PERF_EVENT_KRETPROBE);
368 jsonw_uint_field(wtr, "addr", info->perf_event.kprobe.addr);
369 jsonw_string_field(wtr, "func",
370 u64_to_ptr(info->perf_event.kprobe.func_name));
371 jsonw_uint_field(wtr, "offset", info->perf_event.kprobe.offset);
372 jsonw_uint_field(wtr, "missed", info->perf_event.kprobe.missed);
373 jsonw_uint_field(wtr, "cookie", info->perf_event.kprobe.cookie);
374 }
375
376 static void
show_perf_event_uprobe_json(struct bpf_link_info * info,json_writer_t * wtr)377 show_perf_event_uprobe_json(struct bpf_link_info *info, json_writer_t *wtr)
378 {
379 jsonw_bool_field(wtr, "retprobe", info->perf_event.type == BPF_PERF_EVENT_URETPROBE);
380 jsonw_string_field(wtr, "file",
381 u64_to_ptr(info->perf_event.uprobe.file_name));
382 jsonw_uint_field(wtr, "offset", info->perf_event.uprobe.offset);
383 jsonw_uint_field(wtr, "cookie", info->perf_event.uprobe.cookie);
384 }
385
386 static void
show_perf_event_tracepoint_json(struct bpf_link_info * info,json_writer_t * wtr)387 show_perf_event_tracepoint_json(struct bpf_link_info *info, json_writer_t *wtr)
388 {
389 jsonw_string_field(wtr, "tracepoint",
390 u64_to_ptr(info->perf_event.tracepoint.tp_name));
391 jsonw_uint_field(wtr, "cookie", info->perf_event.tracepoint.cookie);
392 }
393
perf_config_hw_cache_str(__u64 config)394 static char *perf_config_hw_cache_str(__u64 config)
395 {
396 const char *hw_cache, *result, *op;
397 char *str = malloc(PERF_HW_CACHE_LEN);
398
399 if (!str) {
400 p_err("mem alloc failed");
401 return NULL;
402 }
403
404 hw_cache = perf_event_name(evsel__hw_cache, config & 0xff);
405 if (hw_cache)
406 snprintf(str, PERF_HW_CACHE_LEN, "%s-", hw_cache);
407 else
408 snprintf(str, PERF_HW_CACHE_LEN, "%lld-", config & 0xff);
409
410 op = perf_event_name(evsel__hw_cache_op, (config >> 8) & 0xff);
411 if (op)
412 snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
413 "%s-", op);
414 else
415 snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
416 "%lld-", (config >> 8) & 0xff);
417
418 result = perf_event_name(evsel__hw_cache_result, config >> 16);
419 if (result)
420 snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
421 "%s", result);
422 else
423 snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
424 "%lld", config >> 16);
425 return str;
426 }
427
perf_config_str(__u32 type,__u64 config)428 static const char *perf_config_str(__u32 type, __u64 config)
429 {
430 const char *perf_config;
431
432 switch (type) {
433 case PERF_TYPE_HARDWARE:
434 perf_config = perf_event_name(event_symbols_hw, config);
435 break;
436 case PERF_TYPE_SOFTWARE:
437 perf_config = perf_event_name(event_symbols_sw, config);
438 break;
439 case PERF_TYPE_HW_CACHE:
440 perf_config = perf_config_hw_cache_str(config);
441 break;
442 default:
443 perf_config = NULL;
444 break;
445 }
446 return perf_config;
447 }
448
449 static void
show_perf_event_event_json(struct bpf_link_info * info,json_writer_t * wtr)450 show_perf_event_event_json(struct bpf_link_info *info, json_writer_t *wtr)
451 {
452 __u64 config = info->perf_event.event.config;
453 __u32 type = info->perf_event.event.type;
454 const char *perf_type, *perf_config;
455
456 perf_type = perf_event_name(perf_type_name, type);
457 if (perf_type)
458 jsonw_string_field(wtr, "event_type", perf_type);
459 else
460 jsonw_uint_field(wtr, "event_type", type);
461
462 perf_config = perf_config_str(type, config);
463 if (perf_config)
464 jsonw_string_field(wtr, "event_config", perf_config);
465 else
466 jsonw_uint_field(wtr, "event_config", config);
467
468 jsonw_uint_field(wtr, "cookie", info->perf_event.event.cookie);
469
470 if (type == PERF_TYPE_HW_CACHE && perf_config)
471 free((void *)perf_config);
472 }
473
show_link_close_json(int fd,struct bpf_link_info * info)474 static int show_link_close_json(int fd, struct bpf_link_info *info)
475 {
476 struct bpf_prog_info prog_info;
477 const char *prog_type_str;
478 int err;
479
480 jsonw_start_object(json_wtr);
481
482 show_link_header_json(info, json_wtr);
483
484 switch (info->type) {
485 case BPF_LINK_TYPE_RAW_TRACEPOINT:
486 jsonw_string_field(json_wtr, "tp_name",
487 u64_to_ptr(info->raw_tracepoint.tp_name));
488 break;
489 case BPF_LINK_TYPE_TRACING:
490 err = get_prog_info(info->prog_id, &prog_info);
491 if (err)
492 return err;
493
494 prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
495 /* libbpf will return NULL for variants unknown to it. */
496 if (prog_type_str)
497 jsonw_string_field(json_wtr, "prog_type", prog_type_str);
498 else
499 jsonw_uint_field(json_wtr, "prog_type", prog_info.type);
500
501 show_link_attach_type_json(info->tracing.attach_type,
502 json_wtr);
503 jsonw_uint_field(json_wtr, "target_obj_id", info->tracing.target_obj_id);
504 jsonw_uint_field(json_wtr, "target_btf_id", info->tracing.target_btf_id);
505 break;
506 case BPF_LINK_TYPE_CGROUP:
507 jsonw_lluint_field(json_wtr, "cgroup_id",
508 info->cgroup.cgroup_id);
509 show_link_attach_type_json(info->cgroup.attach_type, json_wtr);
510 break;
511 case BPF_LINK_TYPE_ITER:
512 show_iter_json(info, json_wtr);
513 break;
514 case BPF_LINK_TYPE_NETNS:
515 jsonw_uint_field(json_wtr, "netns_ino",
516 info->netns.netns_ino);
517 show_link_attach_type_json(info->netns.attach_type, json_wtr);
518 break;
519 case BPF_LINK_TYPE_NETFILTER:
520 netfilter_dump_json(info, json_wtr);
521 break;
522 case BPF_LINK_TYPE_TCX:
523 show_link_ifindex_json(info->tcx.ifindex, json_wtr);
524 show_link_attach_type_json(info->tcx.attach_type, json_wtr);
525 break;
526 case BPF_LINK_TYPE_NETKIT:
527 show_link_ifindex_json(info->netkit.ifindex, json_wtr);
528 show_link_attach_type_json(info->netkit.attach_type, json_wtr);
529 break;
530 case BPF_LINK_TYPE_XDP:
531 show_link_ifindex_json(info->xdp.ifindex, json_wtr);
532 break;
533 case BPF_LINK_TYPE_STRUCT_OPS:
534 jsonw_uint_field(json_wtr, "map_id",
535 info->struct_ops.map_id);
536 break;
537 case BPF_LINK_TYPE_KPROBE_MULTI:
538 show_kprobe_multi_json(info, json_wtr);
539 break;
540 case BPF_LINK_TYPE_UPROBE_MULTI:
541 show_uprobe_multi_json(info, json_wtr);
542 break;
543 case BPF_LINK_TYPE_PERF_EVENT:
544 switch (info->perf_event.type) {
545 case BPF_PERF_EVENT_EVENT:
546 show_perf_event_event_json(info, json_wtr);
547 break;
548 case BPF_PERF_EVENT_TRACEPOINT:
549 show_perf_event_tracepoint_json(info, json_wtr);
550 break;
551 case BPF_PERF_EVENT_KPROBE:
552 case BPF_PERF_EVENT_KRETPROBE:
553 show_perf_event_kprobe_json(info, json_wtr);
554 break;
555 case BPF_PERF_EVENT_UPROBE:
556 case BPF_PERF_EVENT_URETPROBE:
557 show_perf_event_uprobe_json(info, json_wtr);
558 break;
559 default:
560 break;
561 }
562 break;
563 default:
564 break;
565 }
566
567 if (!hashmap__empty(link_table)) {
568 struct hashmap_entry *entry;
569
570 jsonw_name(json_wtr, "pinned");
571 jsonw_start_array(json_wtr);
572 hashmap__for_each_key_entry(link_table, entry, info->id)
573 jsonw_string(json_wtr, entry->pvalue);
574 jsonw_end_array(json_wtr);
575 }
576
577 emit_obj_refs_json(refs_table, info->id, json_wtr);
578
579 jsonw_end_object(json_wtr);
580
581 return 0;
582 }
583
show_link_header_plain(struct bpf_link_info * info)584 static void show_link_header_plain(struct bpf_link_info *info)
585 {
586 const char *link_type_str;
587
588 printf("%u: ", info->id);
589 link_type_str = libbpf_bpf_link_type_str(info->type);
590 if (link_type_str)
591 printf("%s ", link_type_str);
592 else
593 printf("type %u ", info->type);
594
595 if (info->type == BPF_LINK_TYPE_STRUCT_OPS)
596 printf("map %u ", info->struct_ops.map_id);
597 else
598 printf("prog %u ", info->prog_id);
599 }
600
show_link_attach_type_plain(__u32 attach_type)601 static void show_link_attach_type_plain(__u32 attach_type)
602 {
603 const char *attach_type_str;
604
605 attach_type_str = libbpf_bpf_attach_type_str(attach_type);
606 if (attach_type_str)
607 printf("attach_type %s ", attach_type_str);
608 else
609 printf("attach_type %u ", attach_type);
610 }
611
show_link_ifindex_plain(__u32 ifindex)612 static void show_link_ifindex_plain(__u32 ifindex)
613 {
614 char devname[IF_NAMESIZE * 2] = "(unknown)";
615 char tmpname[IF_NAMESIZE];
616 char *ret = NULL;
617
618 if (ifindex)
619 ret = if_indextoname(ifindex, tmpname);
620 else
621 snprintf(devname, sizeof(devname), "(detached)");
622 if (ret)
623 snprintf(devname, sizeof(devname), "%s(%d)",
624 tmpname, ifindex);
625 printf("ifindex %s ", devname);
626 }
627
show_iter_plain(struct bpf_link_info * info)628 static void show_iter_plain(struct bpf_link_info *info)
629 {
630 const char *target_name = u64_to_ptr(info->iter.target_name);
631
632 printf("target_name %s ", target_name);
633
634 if (is_iter_map_target(target_name))
635 printf("map_id %u ", info->iter.map.map_id);
636 else if (is_iter_task_target(target_name)) {
637 if (info->iter.task.tid)
638 printf("tid %u ", info->iter.task.tid);
639 else if (info->iter.task.pid)
640 printf("pid %u ", info->iter.task.pid);
641 }
642
643 if (is_iter_cgroup_target(target_name)) {
644 printf("cgroup_id %llu ", info->iter.cgroup.cgroup_id);
645 printf("order %s ",
646 cgroup_order_string(info->iter.cgroup.order));
647 }
648 }
649
650 static const char * const pf2name[] = {
651 [NFPROTO_INET] = "inet",
652 [NFPROTO_IPV4] = "ip",
653 [NFPROTO_ARP] = "arp",
654 [NFPROTO_NETDEV] = "netdev",
655 [NFPROTO_BRIDGE] = "bridge",
656 [NFPROTO_IPV6] = "ip6",
657 };
658
659 static const char * const inethook2name[] = {
660 [NF_INET_PRE_ROUTING] = "prerouting",
661 [NF_INET_LOCAL_IN] = "input",
662 [NF_INET_FORWARD] = "forward",
663 [NF_INET_LOCAL_OUT] = "output",
664 [NF_INET_POST_ROUTING] = "postrouting",
665 };
666
667 static const char * const arphook2name[] = {
668 [NF_ARP_IN] = "input",
669 [NF_ARP_OUT] = "output",
670 };
671
netfilter_dump_plain(const struct bpf_link_info * info)672 void netfilter_dump_plain(const struct bpf_link_info *info)
673 {
674 const char *hookname = NULL, *pfname = NULL;
675 unsigned int hook = info->netfilter.hooknum;
676 unsigned int pf = info->netfilter.pf;
677
678 if (pf < ARRAY_SIZE(pf2name))
679 pfname = pf2name[pf];
680
681 switch (pf) {
682 case NFPROTO_BRIDGE: /* bridge shares numbers with enum nf_inet_hooks */
683 case NFPROTO_IPV4:
684 case NFPROTO_IPV6:
685 case NFPROTO_INET:
686 if (hook < ARRAY_SIZE(inethook2name))
687 hookname = inethook2name[hook];
688 break;
689 case NFPROTO_ARP:
690 if (hook < ARRAY_SIZE(arphook2name))
691 hookname = arphook2name[hook];
692 default:
693 break;
694 }
695
696 if (pfname)
697 printf("\n\t%s", pfname);
698 else
699 printf("\n\tpf: %d", pf);
700
701 if (hookname)
702 printf(" %s", hookname);
703 else
704 printf(", hook %u,", hook);
705
706 printf(" prio %d", info->netfilter.priority);
707
708 if (info->netfilter.flags)
709 printf(" flags 0x%x", info->netfilter.flags);
710 }
711
show_kprobe_multi_plain(struct bpf_link_info * info)712 static void show_kprobe_multi_plain(struct bpf_link_info *info)
713 {
714 struct addr_cookie *data;
715 __u32 i, j = 0;
716
717 if (!info->kprobe_multi.count)
718 return;
719
720 if (info->kprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN)
721 printf("\n\tkretprobe.multi ");
722 else
723 printf("\n\tkprobe.multi ");
724 printf("func_cnt %u ", info->kprobe_multi.count);
725 if (info->kprobe_multi.missed)
726 printf("missed %llu ", info->kprobe_multi.missed);
727 data = get_addr_cookie_array(u64_to_ptr(info->kprobe_multi.addrs),
728 u64_to_ptr(info->kprobe_multi.cookies),
729 info->kprobe_multi.count);
730 if (!data)
731 return;
732
733 /* Load it once for all. */
734 if (!dd.sym_count)
735 kernel_syms_load(&dd);
736 if (!dd.sym_count)
737 goto error;
738
739 printf("\n\t%-16s %-16s %s", "addr", "cookie", "func [module]");
740 for (i = 0; i < dd.sym_count; i++) {
741 if (dd.sym_mapping[i].address != data[j].addr)
742 continue;
743 printf("\n\t%016lx %-16llx %s",
744 dd.sym_mapping[i].address, data[j].cookie, dd.sym_mapping[i].name);
745 if (dd.sym_mapping[i].module[0] != '\0')
746 printf(" [%s] ", dd.sym_mapping[i].module);
747 else
748 printf(" ");
749
750 if (j++ == info->kprobe_multi.count)
751 break;
752 }
753 error:
754 free(data);
755 }
756
show_uprobe_multi_plain(struct bpf_link_info * info)757 static void show_uprobe_multi_plain(struct bpf_link_info *info)
758 {
759 __u32 i;
760
761 if (!info->uprobe_multi.count)
762 return;
763
764 if (info->uprobe_multi.flags & BPF_F_UPROBE_MULTI_RETURN)
765 printf("\n\turetprobe.multi ");
766 else
767 printf("\n\tuprobe.multi ");
768
769 printf("path %s ", (char *) u64_to_ptr(info->uprobe_multi.path));
770 printf("func_cnt %u ", info->uprobe_multi.count);
771
772 if (info->uprobe_multi.pid)
773 printf("pid %d ", info->uprobe_multi.pid);
774
775 printf("\n\t%-16s %-16s %-16s", "offset", "ref_ctr_offset", "cookies");
776 for (i = 0; i < info->uprobe_multi.count; i++) {
777 printf("\n\t0x%-16llx 0x%-16llx 0x%-16llx",
778 u64_to_arr(info->uprobe_multi.offsets)[i],
779 u64_to_arr(info->uprobe_multi.ref_ctr_offsets)[i],
780 u64_to_arr(info->uprobe_multi.cookies)[i]);
781 }
782 }
783
show_perf_event_kprobe_plain(struct bpf_link_info * info)784 static void show_perf_event_kprobe_plain(struct bpf_link_info *info)
785 {
786 const char *buf;
787
788 buf = u64_to_ptr(info->perf_event.kprobe.func_name);
789 if (buf[0] == '\0' && !info->perf_event.kprobe.addr)
790 return;
791
792 if (info->perf_event.type == BPF_PERF_EVENT_KRETPROBE)
793 printf("\n\tkretprobe ");
794 else
795 printf("\n\tkprobe ");
796 if (info->perf_event.kprobe.addr)
797 printf("%llx ", info->perf_event.kprobe.addr);
798 printf("%s", buf);
799 if (info->perf_event.kprobe.offset)
800 printf("+%#x", info->perf_event.kprobe.offset);
801 if (info->perf_event.kprobe.missed)
802 printf(" missed %llu", info->perf_event.kprobe.missed);
803 if (info->perf_event.kprobe.cookie)
804 printf(" cookie %llu", info->perf_event.kprobe.cookie);
805 printf(" ");
806 }
807
show_perf_event_uprobe_plain(struct bpf_link_info * info)808 static void show_perf_event_uprobe_plain(struct bpf_link_info *info)
809 {
810 const char *buf;
811
812 buf = u64_to_ptr(info->perf_event.uprobe.file_name);
813 if (buf[0] == '\0')
814 return;
815
816 if (info->perf_event.type == BPF_PERF_EVENT_URETPROBE)
817 printf("\n\turetprobe ");
818 else
819 printf("\n\tuprobe ");
820 printf("%s+%#x ", buf, info->perf_event.uprobe.offset);
821 if (info->perf_event.uprobe.cookie)
822 printf("cookie %llu ", info->perf_event.uprobe.cookie);
823 }
824
show_perf_event_tracepoint_plain(struct bpf_link_info * info)825 static void show_perf_event_tracepoint_plain(struct bpf_link_info *info)
826 {
827 const char *buf;
828
829 buf = u64_to_ptr(info->perf_event.tracepoint.tp_name);
830 if (buf[0] == '\0')
831 return;
832
833 printf("\n\ttracepoint %s ", buf);
834 if (info->perf_event.tracepoint.cookie)
835 printf("cookie %llu ", info->perf_event.tracepoint.cookie);
836 }
837
show_perf_event_event_plain(struct bpf_link_info * info)838 static void show_perf_event_event_plain(struct bpf_link_info *info)
839 {
840 __u64 config = info->perf_event.event.config;
841 __u32 type = info->perf_event.event.type;
842 const char *perf_type, *perf_config;
843
844 printf("\n\tevent ");
845 perf_type = perf_event_name(perf_type_name, type);
846 if (perf_type)
847 printf("%s:", perf_type);
848 else
849 printf("%u :", type);
850
851 perf_config = perf_config_str(type, config);
852 if (perf_config)
853 printf("%s ", perf_config);
854 else
855 printf("%llu ", config);
856
857 if (info->perf_event.event.cookie)
858 printf("cookie %llu ", info->perf_event.event.cookie);
859
860 if (type == PERF_TYPE_HW_CACHE && perf_config)
861 free((void *)perf_config);
862 }
863
show_link_close_plain(int fd,struct bpf_link_info * info)864 static int show_link_close_plain(int fd, struct bpf_link_info *info)
865 {
866 struct bpf_prog_info prog_info;
867 const char *prog_type_str;
868 int err;
869
870 show_link_header_plain(info);
871
872 switch (info->type) {
873 case BPF_LINK_TYPE_RAW_TRACEPOINT:
874 printf("\n\ttp '%s' ",
875 (const char *)u64_to_ptr(info->raw_tracepoint.tp_name));
876 break;
877 case BPF_LINK_TYPE_TRACING:
878 err = get_prog_info(info->prog_id, &prog_info);
879 if (err)
880 return err;
881
882 prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
883 /* libbpf will return NULL for variants unknown to it. */
884 if (prog_type_str)
885 printf("\n\tprog_type %s ", prog_type_str);
886 else
887 printf("\n\tprog_type %u ", prog_info.type);
888
889 show_link_attach_type_plain(info->tracing.attach_type);
890 if (info->tracing.target_obj_id || info->tracing.target_btf_id)
891 printf("\n\ttarget_obj_id %u target_btf_id %u ",
892 info->tracing.target_obj_id,
893 info->tracing.target_btf_id);
894 break;
895 case BPF_LINK_TYPE_CGROUP:
896 printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id);
897 show_link_attach_type_plain(info->cgroup.attach_type);
898 break;
899 case BPF_LINK_TYPE_ITER:
900 show_iter_plain(info);
901 break;
902 case BPF_LINK_TYPE_NETNS:
903 printf("\n\tnetns_ino %u ", info->netns.netns_ino);
904 show_link_attach_type_plain(info->netns.attach_type);
905 break;
906 case BPF_LINK_TYPE_NETFILTER:
907 netfilter_dump_plain(info);
908 break;
909 case BPF_LINK_TYPE_TCX:
910 printf("\n\t");
911 show_link_ifindex_plain(info->tcx.ifindex);
912 show_link_attach_type_plain(info->tcx.attach_type);
913 break;
914 case BPF_LINK_TYPE_NETKIT:
915 printf("\n\t");
916 show_link_ifindex_plain(info->netkit.ifindex);
917 show_link_attach_type_plain(info->netkit.attach_type);
918 break;
919 case BPF_LINK_TYPE_XDP:
920 printf("\n\t");
921 show_link_ifindex_plain(info->xdp.ifindex);
922 break;
923 case BPF_LINK_TYPE_KPROBE_MULTI:
924 show_kprobe_multi_plain(info);
925 break;
926 case BPF_LINK_TYPE_UPROBE_MULTI:
927 show_uprobe_multi_plain(info);
928 break;
929 case BPF_LINK_TYPE_PERF_EVENT:
930 switch (info->perf_event.type) {
931 case BPF_PERF_EVENT_EVENT:
932 show_perf_event_event_plain(info);
933 break;
934 case BPF_PERF_EVENT_TRACEPOINT:
935 show_perf_event_tracepoint_plain(info);
936 break;
937 case BPF_PERF_EVENT_KPROBE:
938 case BPF_PERF_EVENT_KRETPROBE:
939 show_perf_event_kprobe_plain(info);
940 break;
941 case BPF_PERF_EVENT_UPROBE:
942 case BPF_PERF_EVENT_URETPROBE:
943 show_perf_event_uprobe_plain(info);
944 break;
945 default:
946 break;
947 }
948 break;
949 default:
950 break;
951 }
952
953 if (!hashmap__empty(link_table)) {
954 struct hashmap_entry *entry;
955
956 hashmap__for_each_key_entry(link_table, entry, info->id)
957 printf("\n\tpinned %s", (char *)entry->pvalue);
958 }
959 emit_obj_refs_plain(refs_table, info->id, "\n\tpids ");
960
961 printf("\n");
962
963 return 0;
964 }
965
do_show_link(int fd)966 static int do_show_link(int fd)
967 {
968 __u64 *ref_ctr_offsets = NULL, *offsets = NULL, *cookies = NULL;
969 struct bpf_link_info info;
970 __u32 len = sizeof(info);
971 char path_buf[PATH_MAX];
972 __u64 *addrs = NULL;
973 char buf[PATH_MAX];
974 int count;
975 int err;
976
977 memset(&info, 0, sizeof(info));
978 buf[0] = '\0';
979 again:
980 err = bpf_link_get_info_by_fd(fd, &info, &len);
981 if (err) {
982 p_err("can't get link info: %s",
983 strerror(errno));
984 close(fd);
985 return err;
986 }
987 if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT &&
988 !info.raw_tracepoint.tp_name) {
989 info.raw_tracepoint.tp_name = ptr_to_u64(&buf);
990 info.raw_tracepoint.tp_name_len = sizeof(buf);
991 goto again;
992 }
993 if (info.type == BPF_LINK_TYPE_ITER &&
994 !info.iter.target_name) {
995 info.iter.target_name = ptr_to_u64(&buf);
996 info.iter.target_name_len = sizeof(buf);
997 goto again;
998 }
999 if (info.type == BPF_LINK_TYPE_KPROBE_MULTI &&
1000 !info.kprobe_multi.addrs) {
1001 count = info.kprobe_multi.count;
1002 if (count) {
1003 addrs = calloc(count, sizeof(__u64));
1004 if (!addrs) {
1005 p_err("mem alloc failed");
1006 close(fd);
1007 return -ENOMEM;
1008 }
1009 info.kprobe_multi.addrs = ptr_to_u64(addrs);
1010 cookies = calloc(count, sizeof(__u64));
1011 if (!cookies) {
1012 p_err("mem alloc failed");
1013 free(addrs);
1014 close(fd);
1015 return -ENOMEM;
1016 }
1017 info.kprobe_multi.cookies = ptr_to_u64(cookies);
1018 goto again;
1019 }
1020 }
1021 if (info.type == BPF_LINK_TYPE_UPROBE_MULTI &&
1022 !info.uprobe_multi.offsets) {
1023 count = info.uprobe_multi.count;
1024 if (count) {
1025 offsets = calloc(count, sizeof(__u64));
1026 if (!offsets) {
1027 p_err("mem alloc failed");
1028 close(fd);
1029 return -ENOMEM;
1030 }
1031 info.uprobe_multi.offsets = ptr_to_u64(offsets);
1032 ref_ctr_offsets = calloc(count, sizeof(__u64));
1033 if (!ref_ctr_offsets) {
1034 p_err("mem alloc failed");
1035 free(offsets);
1036 close(fd);
1037 return -ENOMEM;
1038 }
1039 info.uprobe_multi.ref_ctr_offsets = ptr_to_u64(ref_ctr_offsets);
1040 cookies = calloc(count, sizeof(__u64));
1041 if (!cookies) {
1042 p_err("mem alloc failed");
1043 free(ref_ctr_offsets);
1044 free(offsets);
1045 close(fd);
1046 return -ENOMEM;
1047 }
1048 info.uprobe_multi.cookies = ptr_to_u64(cookies);
1049 info.uprobe_multi.path = ptr_to_u64(path_buf);
1050 info.uprobe_multi.path_size = sizeof(path_buf);
1051 goto again;
1052 }
1053 }
1054 if (info.type == BPF_LINK_TYPE_PERF_EVENT) {
1055 switch (info.perf_event.type) {
1056 case BPF_PERF_EVENT_TRACEPOINT:
1057 if (!info.perf_event.tracepoint.tp_name) {
1058 info.perf_event.tracepoint.tp_name = ptr_to_u64(&buf);
1059 info.perf_event.tracepoint.name_len = sizeof(buf);
1060 goto again;
1061 }
1062 break;
1063 case BPF_PERF_EVENT_KPROBE:
1064 case BPF_PERF_EVENT_KRETPROBE:
1065 if (!info.perf_event.kprobe.func_name) {
1066 info.perf_event.kprobe.func_name = ptr_to_u64(&buf);
1067 info.perf_event.kprobe.name_len = sizeof(buf);
1068 goto again;
1069 }
1070 break;
1071 case BPF_PERF_EVENT_UPROBE:
1072 case BPF_PERF_EVENT_URETPROBE:
1073 if (!info.perf_event.uprobe.file_name) {
1074 info.perf_event.uprobe.file_name = ptr_to_u64(&buf);
1075 info.perf_event.uprobe.name_len = sizeof(buf);
1076 goto again;
1077 }
1078 break;
1079 default:
1080 break;
1081 }
1082 }
1083
1084 if (json_output)
1085 show_link_close_json(fd, &info);
1086 else
1087 show_link_close_plain(fd, &info);
1088
1089 free(ref_ctr_offsets);
1090 free(cookies);
1091 free(offsets);
1092 free(addrs);
1093 close(fd);
1094 return 0;
1095 }
1096
do_show(int argc,char ** argv)1097 static int do_show(int argc, char **argv)
1098 {
1099 __u32 id = 0;
1100 int err, fd;
1101
1102 if (show_pinned) {
1103 link_table = hashmap__new(hash_fn_for_key_as_id,
1104 equal_fn_for_key_as_id, NULL);
1105 if (IS_ERR(link_table)) {
1106 p_err("failed to create hashmap for pinned paths");
1107 return -1;
1108 }
1109 build_pinned_obj_table(link_table, BPF_OBJ_LINK);
1110 }
1111 build_obj_refs_table(&refs_table, BPF_OBJ_LINK);
1112
1113 if (argc == 2) {
1114 fd = link_parse_fd(&argc, &argv);
1115 if (fd < 0)
1116 return fd;
1117 do_show_link(fd);
1118 goto out;
1119 }
1120
1121 if (argc)
1122 return BAD_ARG();
1123
1124 if (json_output)
1125 jsonw_start_array(json_wtr);
1126 while (true) {
1127 err = bpf_link_get_next_id(id, &id);
1128 if (err) {
1129 if (errno == ENOENT)
1130 break;
1131 p_err("can't get next link: %s%s", strerror(errno),
1132 errno == EINVAL ? " -- kernel too old?" : "");
1133 break;
1134 }
1135
1136 fd = bpf_link_get_fd_by_id(id);
1137 if (fd < 0) {
1138 if (errno == ENOENT)
1139 continue;
1140 p_err("can't get link by id (%u): %s",
1141 id, strerror(errno));
1142 break;
1143 }
1144
1145 err = do_show_link(fd);
1146 if (err)
1147 break;
1148 }
1149 if (json_output)
1150 jsonw_end_array(json_wtr);
1151
1152 delete_obj_refs_table(refs_table);
1153
1154 if (show_pinned)
1155 delete_pinned_obj_table(link_table);
1156
1157 out:
1158 if (dd.sym_count)
1159 kernel_syms_destroy(&dd);
1160 return errno == ENOENT ? 0 : -1;
1161 }
1162
do_pin(int argc,char ** argv)1163 static int do_pin(int argc, char **argv)
1164 {
1165 int err;
1166
1167 err = do_pin_any(argc, argv, link_parse_fd);
1168 if (!err && json_output)
1169 jsonw_null(json_wtr);
1170 return err;
1171 }
1172
do_detach(int argc,char ** argv)1173 static int do_detach(int argc, char **argv)
1174 {
1175 int err, fd;
1176
1177 if (argc != 2) {
1178 p_err("link specifier is invalid or missing\n");
1179 return 1;
1180 }
1181
1182 fd = link_parse_fd(&argc, &argv);
1183 if (fd < 0)
1184 return 1;
1185
1186 err = bpf_link_detach(fd);
1187 if (err)
1188 err = -errno;
1189 close(fd);
1190 if (err) {
1191 p_err("failed link detach: %s", strerror(-err));
1192 return 1;
1193 }
1194
1195 if (json_output)
1196 jsonw_null(json_wtr);
1197
1198 return 0;
1199 }
1200
do_help(int argc,char ** argv)1201 static int do_help(int argc, char **argv)
1202 {
1203 if (json_output) {
1204 jsonw_null(json_wtr);
1205 return 0;
1206 }
1207
1208 fprintf(stderr,
1209 "Usage: %1$s %2$s { show | list } [LINK]\n"
1210 " %1$s %2$s pin LINK FILE\n"
1211 " %1$s %2$s detach LINK\n"
1212 " %1$s %2$s help\n"
1213 "\n"
1214 " " HELP_SPEC_LINK "\n"
1215 " " HELP_SPEC_OPTIONS " |\n"
1216 " {-f|--bpffs} | {-n|--nomount} }\n"
1217 "",
1218 bin_name, argv[-2]);
1219
1220 return 0;
1221 }
1222
1223 static const struct cmd cmds[] = {
1224 { "show", do_show },
1225 { "list", do_show },
1226 { "help", do_help },
1227 { "pin", do_pin },
1228 { "detach", do_detach },
1229 { 0 }
1230 };
1231
do_link(int argc,char ** argv)1232 int do_link(int argc, char **argv)
1233 {
1234 return cmd_select(cmds, argc, argv, do_help);
1235 }
1236