1c5481f9aSAndrii Nakryiko // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2c5481f9aSAndrii Nakryiko /* Copyright (C) 2020 Facebook */
3c5481f9aSAndrii Nakryiko
4c5481f9aSAndrii Nakryiko #include <errno.h>
5622a5b58SMauricio Vásquez #include <linux/err.h>
6d0fe92fbSFlorian Westphal #include <linux/netfilter.h>
7d0fe92fbSFlorian Westphal #include <linux/netfilter_arp.h>
862b57e3dSYafang Shao #include <linux/perf_event.h>
9c5481f9aSAndrii Nakryiko #include <net/if.h>
10c5481f9aSAndrii Nakryiko #include <stdio.h>
11c5481f9aSAndrii Nakryiko #include <unistd.h>
12c5481f9aSAndrii Nakryiko
13c5481f9aSAndrii Nakryiko #include <bpf/bpf.h>
148f184732SQuentin Monnet #include <bpf/hashmap.h>
15c5481f9aSAndrii Nakryiko
16c5481f9aSAndrii Nakryiko #include "json_writer.h"
17c5481f9aSAndrii Nakryiko #include "main.h"
18edd7f49bSYafang Shao #include "xlated_dumper.h"
19c5481f9aSAndrii Nakryiko
2088d61607SYafang Shao #define PERF_HW_CACHE_LEN 128
2188d61607SYafang Shao
228f184732SQuentin Monnet static struct hashmap *link_table;
23edd7f49bSYafang Shao static struct dump_data dd;
2446241271SQuentin Monnet
2562b57e3dSYafang Shao static const char *perf_type_name[PERF_TYPE_MAX] = {
2662b57e3dSYafang Shao [PERF_TYPE_HARDWARE] = "hardware",
2762b57e3dSYafang Shao [PERF_TYPE_SOFTWARE] = "software",
2862b57e3dSYafang Shao [PERF_TYPE_TRACEPOINT] = "tracepoint",
2962b57e3dSYafang Shao [PERF_TYPE_HW_CACHE] = "hw-cache",
3062b57e3dSYafang Shao [PERF_TYPE_RAW] = "raw",
3162b57e3dSYafang Shao [PERF_TYPE_BREAKPOINT] = "breakpoint",
3262b57e3dSYafang Shao };
3362b57e3dSYafang Shao
3462b57e3dSYafang Shao const char *event_symbols_hw[PERF_COUNT_HW_MAX] = {
3562b57e3dSYafang Shao [PERF_COUNT_HW_CPU_CYCLES] = "cpu-cycles",
3662b57e3dSYafang Shao [PERF_COUNT_HW_INSTRUCTIONS] = "instructions",
3762b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_REFERENCES] = "cache-references",
3862b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_MISSES] = "cache-misses",
3962b57e3dSYafang Shao [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = "branch-instructions",
4062b57e3dSYafang Shao [PERF_COUNT_HW_BRANCH_MISSES] = "branch-misses",
4162b57e3dSYafang Shao [PERF_COUNT_HW_BUS_CYCLES] = "bus-cycles",
4262b57e3dSYafang Shao [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = "stalled-cycles-frontend",
4362b57e3dSYafang Shao [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = "stalled-cycles-backend",
4462b57e3dSYafang Shao [PERF_COUNT_HW_REF_CPU_CYCLES] = "ref-cycles",
4562b57e3dSYafang Shao };
4662b57e3dSYafang Shao
4762b57e3dSYafang Shao const char *event_symbols_sw[PERF_COUNT_SW_MAX] = {
4862b57e3dSYafang Shao [PERF_COUNT_SW_CPU_CLOCK] = "cpu-clock",
4962b57e3dSYafang Shao [PERF_COUNT_SW_TASK_CLOCK] = "task-clock",
5062b57e3dSYafang Shao [PERF_COUNT_SW_PAGE_FAULTS] = "page-faults",
5162b57e3dSYafang Shao [PERF_COUNT_SW_CONTEXT_SWITCHES] = "context-switches",
5262b57e3dSYafang Shao [PERF_COUNT_SW_CPU_MIGRATIONS] = "cpu-migrations",
5362b57e3dSYafang Shao [PERF_COUNT_SW_PAGE_FAULTS_MIN] = "minor-faults",
5462b57e3dSYafang Shao [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = "major-faults",
5562b57e3dSYafang Shao [PERF_COUNT_SW_ALIGNMENT_FAULTS] = "alignment-faults",
5662b57e3dSYafang Shao [PERF_COUNT_SW_EMULATION_FAULTS] = "emulation-faults",
5762b57e3dSYafang Shao [PERF_COUNT_SW_DUMMY] = "dummy",
5862b57e3dSYafang Shao [PERF_COUNT_SW_BPF_OUTPUT] = "bpf-output",
5962b57e3dSYafang Shao [PERF_COUNT_SW_CGROUP_SWITCHES] = "cgroup-switches",
6062b57e3dSYafang Shao };
6162b57e3dSYafang Shao
6262b57e3dSYafang Shao const char *evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX] = {
6362b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_L1D] = "L1-dcache",
6462b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_L1I] = "L1-icache",
6562b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_LL] = "LLC",
6662b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_DTLB] = "dTLB",
6762b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_ITLB] = "iTLB",
6862b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_BPU] = "branch",
6962b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_NODE] = "node",
7062b57e3dSYafang Shao };
7162b57e3dSYafang Shao
7262b57e3dSYafang Shao const char *evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX] = {
7362b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_OP_READ] = "load",
7462b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_OP_WRITE] = "store",
7562b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_OP_PREFETCH] = "prefetch",
7662b57e3dSYafang Shao };
7762b57e3dSYafang Shao
7862b57e3dSYafang Shao const char *evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX] = {
7962b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_RESULT_ACCESS] = "refs",
8062b57e3dSYafang Shao [PERF_COUNT_HW_CACHE_RESULT_MISS] = "misses",
8162b57e3dSYafang Shao };
8262b57e3dSYafang Shao
8362b57e3dSYafang Shao #define perf_event_name(array, id) ({ \
8462b57e3dSYafang Shao const char *event_str = NULL; \
8562b57e3dSYafang Shao \
866a8faf10SYafang Shao if ((id) < ARRAY_SIZE(array)) \
8762b57e3dSYafang Shao event_str = array[id]; \
8862b57e3dSYafang Shao event_str; \
8962b57e3dSYafang Shao })
9062b57e3dSYafang Shao
link_parse_fd(int * argc,char *** argv)91c5481f9aSAndrii Nakryiko static int link_parse_fd(int *argc, char ***argv)
92c5481f9aSAndrii Nakryiko {
930e8c7c07SAndrii Nakryiko int fd;
940e8c7c07SAndrii Nakryiko
95c5481f9aSAndrii Nakryiko if (is_prefix(**argv, "id")) {
96c5481f9aSAndrii Nakryiko unsigned int id;
97c5481f9aSAndrii Nakryiko char *endptr;
98c5481f9aSAndrii Nakryiko
99c5481f9aSAndrii Nakryiko NEXT_ARGP();
100c5481f9aSAndrii Nakryiko
101c5481f9aSAndrii Nakryiko id = strtoul(**argv, &endptr, 0);
102c5481f9aSAndrii Nakryiko if (*endptr) {
103c5481f9aSAndrii Nakryiko p_err("can't parse %s as ID", **argv);
104c5481f9aSAndrii Nakryiko return -1;
105c5481f9aSAndrii Nakryiko }
106c5481f9aSAndrii Nakryiko NEXT_ARGP();
107c5481f9aSAndrii Nakryiko
1080e8c7c07SAndrii Nakryiko fd = bpf_link_get_fd_by_id(id);
1090e8c7c07SAndrii Nakryiko if (fd < 0)
1100e8c7c07SAndrii Nakryiko p_err("failed to get link with ID %d: %s", id, strerror(errno));
1110e8c7c07SAndrii Nakryiko return fd;
112c5481f9aSAndrii Nakryiko } else if (is_prefix(**argv, "pinned")) {
113c5481f9aSAndrii Nakryiko char *path;
114c5481f9aSAndrii Nakryiko
115c5481f9aSAndrii Nakryiko NEXT_ARGP();
116c5481f9aSAndrii Nakryiko
117c5481f9aSAndrii Nakryiko path = **argv;
118c5481f9aSAndrii Nakryiko NEXT_ARGP();
119c5481f9aSAndrii Nakryiko
120c5481f9aSAndrii Nakryiko return open_obj_pinned_any(path, BPF_OBJ_LINK);
121c5481f9aSAndrii Nakryiko }
122c5481f9aSAndrii Nakryiko
123c5481f9aSAndrii Nakryiko p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
124c5481f9aSAndrii Nakryiko return -1;
125c5481f9aSAndrii Nakryiko }
126c5481f9aSAndrii Nakryiko
127c5481f9aSAndrii Nakryiko static void
show_link_header_json(struct bpf_link_info * info,json_writer_t * wtr)128c5481f9aSAndrii Nakryiko show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr)
129c5481f9aSAndrii Nakryiko {
130c7e7e279SDaniel Müller const char *link_type_str;
131c7e7e279SDaniel Müller
132c5481f9aSAndrii Nakryiko jsonw_uint_field(wtr, "id", info->id);
133c7e7e279SDaniel Müller link_type_str = libbpf_bpf_link_type_str(info->type);
134c7e7e279SDaniel Müller if (link_type_str)
135c7e7e279SDaniel Müller jsonw_string_field(wtr, "type", link_type_str);
136c5481f9aSAndrii Nakryiko else
137c5481f9aSAndrii Nakryiko jsonw_uint_field(wtr, "type", info->type);
138c5481f9aSAndrii Nakryiko
139c5481f9aSAndrii Nakryiko jsonw_uint_field(json_wtr, "prog_id", info->prog_id);
140c5481f9aSAndrii Nakryiko }
141c5481f9aSAndrii Nakryiko
show_link_attach_type_json(__u32 attach_type,json_writer_t * wtr)142be6e1981SJakub Sitnicki static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr)
143be6e1981SJakub Sitnicki {
1441ba5ad36SDaniel Müller const char *attach_type_str;
1451ba5ad36SDaniel Müller
1461ba5ad36SDaniel Müller attach_type_str = libbpf_bpf_attach_type_str(attach_type);
1471ba5ad36SDaniel Müller if (attach_type_str)
1481ba5ad36SDaniel Müller jsonw_string_field(wtr, "attach_type", attach_type_str);
149be6e1981SJakub Sitnicki else
150be6e1981SJakub Sitnicki jsonw_uint_field(wtr, "attach_type", attach_type);
151be6e1981SJakub Sitnicki }
152be6e1981SJakub Sitnicki
show_link_ifindex_json(__u32 ifindex,json_writer_t * wtr)153e16e6c6dSDaniel Borkmann static void show_link_ifindex_json(__u32 ifindex, json_writer_t *wtr)
154e16e6c6dSDaniel Borkmann {
155e16e6c6dSDaniel Borkmann char devname[IF_NAMESIZE] = "(unknown)";
156e16e6c6dSDaniel Borkmann
157e16e6c6dSDaniel Borkmann if (ifindex)
158e16e6c6dSDaniel Borkmann if_indextoname(ifindex, devname);
159e16e6c6dSDaniel Borkmann else
160e16e6c6dSDaniel Borkmann snprintf(devname, sizeof(devname), "(detached)");
161e16e6c6dSDaniel Borkmann jsonw_string_field(wtr, "devname", devname);
162e16e6c6dSDaniel Borkmann jsonw_uint_field(wtr, "ifindex", ifindex);
163e16e6c6dSDaniel Borkmann }
164e16e6c6dSDaniel Borkmann
is_iter_map_target(const char * target_name)165e60495eaSYonghong Song static bool is_iter_map_target(const char *target_name)
166e60495eaSYonghong Song {
167e60495eaSYonghong Song return strcmp(target_name, "bpf_map_elem") == 0 ||
168e60495eaSYonghong Song strcmp(target_name, "bpf_sk_storage_map") == 0;
169e60495eaSYonghong Song }
170e60495eaSYonghong Song
is_iter_cgroup_target(const char * target_name)1716f95de6dSHao Luo static bool is_iter_cgroup_target(const char *target_name)
1726f95de6dSHao Luo {
1736f95de6dSHao Luo return strcmp(target_name, "cgroup") == 0;
1746f95de6dSHao Luo }
1756f95de6dSHao Luo
cgroup_order_string(__u32 order)1766f95de6dSHao Luo static const char *cgroup_order_string(__u32 order)
1776f95de6dSHao Luo {
1786f95de6dSHao Luo switch (order) {
1796f95de6dSHao Luo case BPF_CGROUP_ITER_ORDER_UNSPEC:
1806f95de6dSHao Luo return "order_unspec";
1816f95de6dSHao Luo case BPF_CGROUP_ITER_SELF_ONLY:
1826f95de6dSHao Luo return "self_only";
1836f95de6dSHao Luo case BPF_CGROUP_ITER_DESCENDANTS_PRE:
1846f95de6dSHao Luo return "descendants_pre";
1856f95de6dSHao Luo case BPF_CGROUP_ITER_DESCENDANTS_POST:
1866f95de6dSHao Luo return "descendants_post";
1876f95de6dSHao Luo case BPF_CGROUP_ITER_ANCESTORS_UP:
1886f95de6dSHao Luo return "ancestors_up";
1896f95de6dSHao Luo default: /* won't happen */
1906f95de6dSHao Luo return "unknown";
1916f95de6dSHao Luo }
1926f95de6dSHao Luo }
1936f95de6dSHao Luo
is_iter_task_target(const char * target_name)1946bdb6d6bSKui-Feng Lee static bool is_iter_task_target(const char *target_name)
1956bdb6d6bSKui-Feng Lee {
1966bdb6d6bSKui-Feng Lee return strcmp(target_name, "task") == 0 ||
1976bdb6d6bSKui-Feng Lee strcmp(target_name, "task_file") == 0 ||
1986bdb6d6bSKui-Feng Lee strcmp(target_name, "task_vma") == 0;
1996bdb6d6bSKui-Feng Lee }
2006bdb6d6bSKui-Feng Lee
show_iter_json(struct bpf_link_info * info,json_writer_t * wtr)201e60495eaSYonghong Song static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr)
202e60495eaSYonghong Song {
203e60495eaSYonghong Song const char *target_name = u64_to_ptr(info->iter.target_name);
204e60495eaSYonghong Song
205e60495eaSYonghong Song jsonw_string_field(wtr, "target_name", target_name);
206e60495eaSYonghong Song
207e60495eaSYonghong Song if (is_iter_map_target(target_name))
208e60495eaSYonghong Song jsonw_uint_field(wtr, "map_id", info->iter.map.map_id);
2096bdb6d6bSKui-Feng Lee else if (is_iter_task_target(target_name)) {
2106bdb6d6bSKui-Feng Lee if (info->iter.task.tid)
2116bdb6d6bSKui-Feng Lee jsonw_uint_field(wtr, "tid", info->iter.task.tid);
2126bdb6d6bSKui-Feng Lee else if (info->iter.task.pid)
2136bdb6d6bSKui-Feng Lee jsonw_uint_field(wtr, "pid", info->iter.task.pid);
2146bdb6d6bSKui-Feng Lee }
2156f95de6dSHao Luo
2166f95de6dSHao Luo if (is_iter_cgroup_target(target_name)) {
2176f95de6dSHao Luo jsonw_lluint_field(wtr, "cgroup_id", info->iter.cgroup.cgroup_id);
2186f95de6dSHao Luo jsonw_string_field(wtr, "order",
2196f95de6dSHao Luo cgroup_order_string(info->iter.cgroup.order));
2206f95de6dSHao Luo }
221e60495eaSYonghong Song }
222e60495eaSYonghong Song
netfilter_dump_json(const struct bpf_link_info * info,json_writer_t * wtr)223d0fe92fbSFlorian Westphal void netfilter_dump_json(const struct bpf_link_info *info, json_writer_t *wtr)
224d0fe92fbSFlorian Westphal {
225d0fe92fbSFlorian Westphal jsonw_uint_field(json_wtr, "pf",
226d0fe92fbSFlorian Westphal info->netfilter.pf);
227d0fe92fbSFlorian Westphal jsonw_uint_field(json_wtr, "hook",
228d0fe92fbSFlorian Westphal info->netfilter.hooknum);
229d0fe92fbSFlorian Westphal jsonw_int_field(json_wtr, "prio",
230d0fe92fbSFlorian Westphal info->netfilter.priority);
231d0fe92fbSFlorian Westphal jsonw_uint_field(json_wtr, "flags",
232d0fe92fbSFlorian Westphal info->netfilter.flags);
233d0fe92fbSFlorian Westphal }
234d0fe92fbSFlorian Westphal
get_prog_info(int prog_id,struct bpf_prog_info * info)235c5481f9aSAndrii Nakryiko static int get_prog_info(int prog_id, struct bpf_prog_info *info)
236c5481f9aSAndrii Nakryiko {
237c5481f9aSAndrii Nakryiko __u32 len = sizeof(*info);
238c5481f9aSAndrii Nakryiko int err, prog_fd;
239c5481f9aSAndrii Nakryiko
240c5481f9aSAndrii Nakryiko prog_fd = bpf_prog_get_fd_by_id(prog_id);
241c5481f9aSAndrii Nakryiko if (prog_fd < 0)
242c5481f9aSAndrii Nakryiko return prog_fd;
243c5481f9aSAndrii Nakryiko
244c5481f9aSAndrii Nakryiko memset(info, 0, sizeof(*info));
24538f0408eSIlya Leoshkevich err = bpf_prog_get_info_by_fd(prog_fd, info, &len);
246c5481f9aSAndrii Nakryiko if (err)
247c5481f9aSAndrii Nakryiko p_err("can't get prog info: %s", strerror(errno));
248c5481f9aSAndrii Nakryiko close(prog_fd);
249c5481f9aSAndrii Nakryiko return err;
250c5481f9aSAndrii Nakryiko }
251c5481f9aSAndrii Nakryiko
252b0dc0373SJiri Olsa struct addr_cookie {
253b0dc0373SJiri Olsa __u64 addr;
254b0dc0373SJiri Olsa __u64 cookie;
255b0dc0373SJiri Olsa };
256edd7f49bSYafang Shao
cmp_addr_cookie(const void * A,const void * B)257b0dc0373SJiri Olsa static int cmp_addr_cookie(const void *A, const void *B)
258b0dc0373SJiri Olsa {
259b0dc0373SJiri Olsa const struct addr_cookie *a = A, *b = B;
260b0dc0373SJiri Olsa
261b0dc0373SJiri Olsa if (a->addr == b->addr)
262b0dc0373SJiri Olsa return 0;
263b0dc0373SJiri Olsa return a->addr < b->addr ? -1 : 1;
264b0dc0373SJiri Olsa }
265b0dc0373SJiri Olsa
266b0dc0373SJiri Olsa static struct addr_cookie *
get_addr_cookie_array(__u64 * addrs,__u64 * cookies,__u32 count)267b0dc0373SJiri Olsa get_addr_cookie_array(__u64 *addrs, __u64 *cookies, __u32 count)
268b0dc0373SJiri Olsa {
269b0dc0373SJiri Olsa struct addr_cookie *data;
270b0dc0373SJiri Olsa __u32 i;
271b0dc0373SJiri Olsa
272b0dc0373SJiri Olsa data = calloc(count, sizeof(data[0]));
273b0dc0373SJiri Olsa if (!data) {
274b0dc0373SJiri Olsa p_err("mem alloc failed");
275b0dc0373SJiri Olsa return NULL;
276b0dc0373SJiri Olsa }
277b0dc0373SJiri Olsa for (i = 0; i < count; i++) {
278b0dc0373SJiri Olsa data[i].addr = addrs[i];
279b0dc0373SJiri Olsa data[i].cookie = cookies[i];
280b0dc0373SJiri Olsa }
281b0dc0373SJiri Olsa qsort(data, count, sizeof(data[0]), cmp_addr_cookie);
282b0dc0373SJiri Olsa return data;
283edd7f49bSYafang Shao }
284edd7f49bSYafang Shao
285edd7f49bSYafang Shao static void
show_kprobe_multi_json(struct bpf_link_info * info,json_writer_t * wtr)286edd7f49bSYafang Shao show_kprobe_multi_json(struct bpf_link_info *info, json_writer_t *wtr)
287edd7f49bSYafang Shao {
288b0dc0373SJiri Olsa struct addr_cookie *data;
289edd7f49bSYafang Shao __u32 i, j = 0;
290edd7f49bSYafang Shao
291edd7f49bSYafang Shao jsonw_bool_field(json_wtr, "retprobe",
292edd7f49bSYafang Shao info->kprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN);
293edd7f49bSYafang Shao jsonw_uint_field(json_wtr, "func_cnt", info->kprobe_multi.count);
294b24fc355SJiri Olsa jsonw_uint_field(json_wtr, "missed", info->kprobe_multi.missed);
295edd7f49bSYafang Shao jsonw_name(json_wtr, "funcs");
296edd7f49bSYafang Shao jsonw_start_array(json_wtr);
297b0dc0373SJiri Olsa data = get_addr_cookie_array(u64_to_ptr(info->kprobe_multi.addrs),
298b0dc0373SJiri Olsa u64_to_ptr(info->kprobe_multi.cookies),
299b0dc0373SJiri Olsa info->kprobe_multi.count);
300b0dc0373SJiri Olsa if (!data)
301b0dc0373SJiri Olsa return;
302edd7f49bSYafang Shao
303edd7f49bSYafang Shao /* Load it once for all. */
304edd7f49bSYafang Shao if (!dd.sym_count)
305edd7f49bSYafang Shao kernel_syms_load(&dd);
306b0dc0373SJiri Olsa if (!dd.sym_count)
307b0dc0373SJiri Olsa goto error;
308b0dc0373SJiri Olsa
309edd7f49bSYafang Shao for (i = 0; i < dd.sym_count; i++) {
310b0dc0373SJiri Olsa if (dd.sym_mapping[i].address != data[j].addr)
311edd7f49bSYafang Shao continue;
312edd7f49bSYafang Shao jsonw_start_object(json_wtr);
313edd7f49bSYafang Shao jsonw_uint_field(json_wtr, "addr", dd.sym_mapping[i].address);
314edd7f49bSYafang Shao jsonw_string_field(json_wtr, "func", dd.sym_mapping[i].name);
315edd7f49bSYafang Shao /* Print null if it is vmlinux */
316edd7f49bSYafang Shao if (dd.sym_mapping[i].module[0] == '\0') {
317edd7f49bSYafang Shao jsonw_name(json_wtr, "module");
318edd7f49bSYafang Shao jsonw_null(json_wtr);
319edd7f49bSYafang Shao } else {
320edd7f49bSYafang Shao jsonw_string_field(json_wtr, "module", dd.sym_mapping[i].module);
321edd7f49bSYafang Shao }
322b0dc0373SJiri Olsa jsonw_uint_field(json_wtr, "cookie", data[j].cookie);
323edd7f49bSYafang Shao jsonw_end_object(json_wtr);
324edd7f49bSYafang Shao if (j++ == info->kprobe_multi.count)
325edd7f49bSYafang Shao break;
326edd7f49bSYafang Shao }
327edd7f49bSYafang Shao jsonw_end_array(json_wtr);
328b0dc0373SJiri Olsa error:
329b0dc0373SJiri Olsa free(data);
330edd7f49bSYafang Shao }
331edd7f49bSYafang Shao
u64_to_arr(__u64 val)332a7795698SJiri Olsa static __u64 *u64_to_arr(__u64 val)
333a7795698SJiri Olsa {
334a7795698SJiri Olsa return (__u64 *) u64_to_ptr(val);
335a7795698SJiri Olsa }
336a7795698SJiri Olsa
337a7795698SJiri Olsa static void
show_uprobe_multi_json(struct bpf_link_info * info,json_writer_t * wtr)338a7795698SJiri Olsa show_uprobe_multi_json(struct bpf_link_info *info, json_writer_t *wtr)
339a7795698SJiri Olsa {
340a7795698SJiri Olsa __u32 i;
341a7795698SJiri Olsa
342a7795698SJiri Olsa jsonw_bool_field(json_wtr, "retprobe",
343a7795698SJiri Olsa info->uprobe_multi.flags & BPF_F_UPROBE_MULTI_RETURN);
344a7795698SJiri Olsa jsonw_string_field(json_wtr, "path", (char *) u64_to_ptr(info->uprobe_multi.path));
345a7795698SJiri Olsa jsonw_uint_field(json_wtr, "func_cnt", info->uprobe_multi.count);
346a7795698SJiri Olsa jsonw_int_field(json_wtr, "pid", (int) info->uprobe_multi.pid);
347a7795698SJiri Olsa jsonw_name(json_wtr, "funcs");
348a7795698SJiri Olsa jsonw_start_array(json_wtr);
349a7795698SJiri Olsa
350a7795698SJiri Olsa for (i = 0; i < info->uprobe_multi.count; i++) {
351a7795698SJiri Olsa jsonw_start_object(json_wtr);
352a7795698SJiri Olsa jsonw_uint_field(json_wtr, "offset",
353a7795698SJiri Olsa u64_to_arr(info->uprobe_multi.offsets)[i]);
354a7795698SJiri Olsa jsonw_uint_field(json_wtr, "ref_ctr_offset",
355a7795698SJiri Olsa u64_to_arr(info->uprobe_multi.ref_ctr_offsets)[i]);
356a7795698SJiri Olsa jsonw_uint_field(json_wtr, "cookie",
357a7795698SJiri Olsa u64_to_arr(info->uprobe_multi.cookies)[i]);
358a7795698SJiri Olsa jsonw_end_object(json_wtr);
359a7795698SJiri Olsa }
360a7795698SJiri Olsa jsonw_end_array(json_wtr);
361a7795698SJiri Olsa }
362a7795698SJiri Olsa
36388d61607SYafang Shao static void
show_perf_event_kprobe_json(struct bpf_link_info * info,json_writer_t * wtr)36488d61607SYafang Shao show_perf_event_kprobe_json(struct bpf_link_info *info, json_writer_t *wtr)
36588d61607SYafang Shao {
36688d61607SYafang Shao jsonw_bool_field(wtr, "retprobe", info->perf_event.type == BPF_PERF_EVENT_KRETPROBE);
36788d61607SYafang Shao jsonw_uint_field(wtr, "addr", info->perf_event.kprobe.addr);
36888d61607SYafang Shao jsonw_string_field(wtr, "func",
36988d61607SYafang Shao u64_to_ptr(info->perf_event.kprobe.func_name));
37088d61607SYafang Shao jsonw_uint_field(wtr, "offset", info->perf_event.kprobe.offset);
371b563b9baSJiri Olsa jsonw_uint_field(wtr, "missed", info->perf_event.kprobe.missed);
37254258324SJiri Olsa jsonw_uint_field(wtr, "cookie", info->perf_event.kprobe.cookie);
37388d61607SYafang Shao }
37488d61607SYafang Shao
37588d61607SYafang Shao static void
show_perf_event_uprobe_json(struct bpf_link_info * info,json_writer_t * wtr)37688d61607SYafang Shao show_perf_event_uprobe_json(struct bpf_link_info *info, json_writer_t *wtr)
37788d61607SYafang Shao {
37888d61607SYafang Shao jsonw_bool_field(wtr, "retprobe", info->perf_event.type == BPF_PERF_EVENT_URETPROBE);
37988d61607SYafang Shao jsonw_string_field(wtr, "file",
38088d61607SYafang Shao u64_to_ptr(info->perf_event.uprobe.file_name));
38188d61607SYafang Shao jsonw_uint_field(wtr, "offset", info->perf_event.uprobe.offset);
38254258324SJiri Olsa jsonw_uint_field(wtr, "cookie", info->perf_event.uprobe.cookie);
38388d61607SYafang Shao }
38488d61607SYafang Shao
38588d61607SYafang Shao static void
show_perf_event_tracepoint_json(struct bpf_link_info * info,json_writer_t * wtr)38688d61607SYafang Shao show_perf_event_tracepoint_json(struct bpf_link_info *info, json_writer_t *wtr)
38788d61607SYafang Shao {
38888d61607SYafang Shao jsonw_string_field(wtr, "tracepoint",
38988d61607SYafang Shao u64_to_ptr(info->perf_event.tracepoint.tp_name));
39054258324SJiri Olsa jsonw_uint_field(wtr, "cookie", info->perf_event.tracepoint.cookie);
39188d61607SYafang Shao }
39288d61607SYafang Shao
perf_config_hw_cache_str(__u64 config)39388d61607SYafang Shao static char *perf_config_hw_cache_str(__u64 config)
39488d61607SYafang Shao {
39588d61607SYafang Shao const char *hw_cache, *result, *op;
39688d61607SYafang Shao char *str = malloc(PERF_HW_CACHE_LEN);
39788d61607SYafang Shao
39888d61607SYafang Shao if (!str) {
39988d61607SYafang Shao p_err("mem alloc failed");
40088d61607SYafang Shao return NULL;
40188d61607SYafang Shao }
40288d61607SYafang Shao
40388d61607SYafang Shao hw_cache = perf_event_name(evsel__hw_cache, config & 0xff);
40488d61607SYafang Shao if (hw_cache)
40588d61607SYafang Shao snprintf(str, PERF_HW_CACHE_LEN, "%s-", hw_cache);
40688d61607SYafang Shao else
40788d61607SYafang Shao snprintf(str, PERF_HW_CACHE_LEN, "%lld-", config & 0xff);
40888d61607SYafang Shao
40988d61607SYafang Shao op = perf_event_name(evsel__hw_cache_op, (config >> 8) & 0xff);
41088d61607SYafang Shao if (op)
41188d61607SYafang Shao snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
41288d61607SYafang Shao "%s-", op);
41388d61607SYafang Shao else
41488d61607SYafang Shao snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
41588d61607SYafang Shao "%lld-", (config >> 8) & 0xff);
41688d61607SYafang Shao
41788d61607SYafang Shao result = perf_event_name(evsel__hw_cache_result, config >> 16);
41888d61607SYafang Shao if (result)
41988d61607SYafang Shao snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
42088d61607SYafang Shao "%s", result);
42188d61607SYafang Shao else
42288d61607SYafang Shao snprintf(str + strlen(str), PERF_HW_CACHE_LEN - strlen(str),
42388d61607SYafang Shao "%lld", config >> 16);
42488d61607SYafang Shao return str;
42588d61607SYafang Shao }
42688d61607SYafang Shao
perf_config_str(__u32 type,__u64 config)42788d61607SYafang Shao static const char *perf_config_str(__u32 type, __u64 config)
42888d61607SYafang Shao {
42988d61607SYafang Shao const char *perf_config;
43088d61607SYafang Shao
43188d61607SYafang Shao switch (type) {
43288d61607SYafang Shao case PERF_TYPE_HARDWARE:
43388d61607SYafang Shao perf_config = perf_event_name(event_symbols_hw, config);
43488d61607SYafang Shao break;
43588d61607SYafang Shao case PERF_TYPE_SOFTWARE:
43688d61607SYafang Shao perf_config = perf_event_name(event_symbols_sw, config);
43788d61607SYafang Shao break;
43888d61607SYafang Shao case PERF_TYPE_HW_CACHE:
43988d61607SYafang Shao perf_config = perf_config_hw_cache_str(config);
44088d61607SYafang Shao break;
44188d61607SYafang Shao default:
44288d61607SYafang Shao perf_config = NULL;
44388d61607SYafang Shao break;
44488d61607SYafang Shao }
44588d61607SYafang Shao return perf_config;
44688d61607SYafang Shao }
44788d61607SYafang Shao
44888d61607SYafang Shao static void
show_perf_event_event_json(struct bpf_link_info * info,json_writer_t * wtr)44988d61607SYafang Shao show_perf_event_event_json(struct bpf_link_info *info, json_writer_t *wtr)
45088d61607SYafang Shao {
45188d61607SYafang Shao __u64 config = info->perf_event.event.config;
45288d61607SYafang Shao __u32 type = info->perf_event.event.type;
45388d61607SYafang Shao const char *perf_type, *perf_config;
45488d61607SYafang Shao
45588d61607SYafang Shao perf_type = perf_event_name(perf_type_name, type);
45688d61607SYafang Shao if (perf_type)
45788d61607SYafang Shao jsonw_string_field(wtr, "event_type", perf_type);
45888d61607SYafang Shao else
45988d61607SYafang Shao jsonw_uint_field(wtr, "event_type", type);
46088d61607SYafang Shao
46188d61607SYafang Shao perf_config = perf_config_str(type, config);
46288d61607SYafang Shao if (perf_config)
46388d61607SYafang Shao jsonw_string_field(wtr, "event_config", perf_config);
46488d61607SYafang Shao else
46588d61607SYafang Shao jsonw_uint_field(wtr, "event_config", config);
46688d61607SYafang Shao
46754258324SJiri Olsa jsonw_uint_field(wtr, "cookie", info->perf_event.event.cookie);
46854258324SJiri Olsa
46988d61607SYafang Shao if (type == PERF_TYPE_HW_CACHE && perf_config)
47088d61607SYafang Shao free((void *)perf_config);
47188d61607SYafang Shao }
47288d61607SYafang Shao
show_link_close_json(int fd,struct bpf_link_info * info)473c5481f9aSAndrii Nakryiko static int show_link_close_json(int fd, struct bpf_link_info *info)
474c5481f9aSAndrii Nakryiko {
475c5481f9aSAndrii Nakryiko struct bpf_prog_info prog_info;
476b700eeb4SDaniel Müller const char *prog_type_str;
477c5481f9aSAndrii Nakryiko int err;
478c5481f9aSAndrii Nakryiko
479c5481f9aSAndrii Nakryiko jsonw_start_object(json_wtr);
480c5481f9aSAndrii Nakryiko
481c5481f9aSAndrii Nakryiko show_link_header_json(info, json_wtr);
482c5481f9aSAndrii Nakryiko
483c5481f9aSAndrii Nakryiko switch (info->type) {
484c5481f9aSAndrii Nakryiko case BPF_LINK_TYPE_RAW_TRACEPOINT:
485c5481f9aSAndrii Nakryiko jsonw_string_field(json_wtr, "tp_name",
48609f44b75SAndrii Nakryiko u64_to_ptr(info->raw_tracepoint.tp_name));
487c5481f9aSAndrii Nakryiko break;
488c5481f9aSAndrii Nakryiko case BPF_LINK_TYPE_TRACING:
489c5481f9aSAndrii Nakryiko err = get_prog_info(info->prog_id, &prog_info);
490c5481f9aSAndrii Nakryiko if (err)
491c5481f9aSAndrii Nakryiko return err;
492c5481f9aSAndrii Nakryiko
493b700eeb4SDaniel Müller prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
494b700eeb4SDaniel Müller /* libbpf will return NULL for variants unknown to it. */
495b700eeb4SDaniel Müller if (prog_type_str)
496b700eeb4SDaniel Müller jsonw_string_field(json_wtr, "prog_type", prog_type_str);
497c5481f9aSAndrii Nakryiko else
498b700eeb4SDaniel Müller jsonw_uint_field(json_wtr, "prog_type", prog_info.type);
499c5481f9aSAndrii Nakryiko
500be6e1981SJakub Sitnicki show_link_attach_type_json(info->tracing.attach_type,
501be6e1981SJakub Sitnicki json_wtr);
502d7e45eb4SYafang Shao jsonw_uint_field(json_wtr, "target_obj_id", info->tracing.target_obj_id);
503d7e45eb4SYafang Shao jsonw_uint_field(json_wtr, "target_btf_id", info->tracing.target_btf_id);
504c5481f9aSAndrii Nakryiko break;
505c5481f9aSAndrii Nakryiko case BPF_LINK_TYPE_CGROUP:
506c5481f9aSAndrii Nakryiko jsonw_lluint_field(json_wtr, "cgroup_id",
507c5481f9aSAndrii Nakryiko info->cgroup.cgroup_id);
508be6e1981SJakub Sitnicki show_link_attach_type_json(info->cgroup.attach_type, json_wtr);
509c5481f9aSAndrii Nakryiko break;
510e60495eaSYonghong Song case BPF_LINK_TYPE_ITER:
511e60495eaSYonghong Song show_iter_json(info, json_wtr);
512e60495eaSYonghong Song break;
513e948947aSJakub Sitnicki case BPF_LINK_TYPE_NETNS:
514e948947aSJakub Sitnicki jsonw_uint_field(json_wtr, "netns_ino",
515e948947aSJakub Sitnicki info->netns.netns_ino);
516e948947aSJakub Sitnicki show_link_attach_type_json(info->netns.attach_type, json_wtr);
517e948947aSJakub Sitnicki break;
518d0fe92fbSFlorian Westphal case BPF_LINK_TYPE_NETFILTER:
519d0fe92fbSFlorian Westphal netfilter_dump_json(info, json_wtr);
520d0fe92fbSFlorian Westphal break;
521e16e6c6dSDaniel Borkmann case BPF_LINK_TYPE_TCX:
522e16e6c6dSDaniel Borkmann show_link_ifindex_json(info->tcx.ifindex, json_wtr);
523e16e6c6dSDaniel Borkmann show_link_attach_type_json(info->tcx.attach_type, json_wtr);
524e16e6c6dSDaniel Borkmann break;
52592a85e18SDaniel Borkmann case BPF_LINK_TYPE_NETKIT:
52692a85e18SDaniel Borkmann show_link_ifindex_json(info->netkit.ifindex, json_wtr);
52792a85e18SDaniel Borkmann show_link_attach_type_json(info->netkit.attach_type, json_wtr);
52892a85e18SDaniel Borkmann break;
529*1f3e2091SYonghong Song case BPF_LINK_TYPE_SOCKMAP:
530*1f3e2091SYonghong Song jsonw_uint_field(json_wtr, "map_id", info->sockmap.map_id);
531*1f3e2091SYonghong Song show_link_attach_type_json(info->sockmap.attach_type, json_wtr);
532*1f3e2091SYonghong Song break;
533053bbf9bSDaniel Borkmann case BPF_LINK_TYPE_XDP:
534053bbf9bSDaniel Borkmann show_link_ifindex_json(info->xdp.ifindex, json_wtr);
535053bbf9bSDaniel Borkmann break;
53674fc8801SKui-Feng Lee case BPF_LINK_TYPE_STRUCT_OPS:
53774fc8801SKui-Feng Lee jsonw_uint_field(json_wtr, "map_id",
53874fc8801SKui-Feng Lee info->struct_ops.map_id);
53974fc8801SKui-Feng Lee break;
540edd7f49bSYafang Shao case BPF_LINK_TYPE_KPROBE_MULTI:
541edd7f49bSYafang Shao show_kprobe_multi_json(info, json_wtr);
542edd7f49bSYafang Shao break;
543a7795698SJiri Olsa case BPF_LINK_TYPE_UPROBE_MULTI:
544a7795698SJiri Olsa show_uprobe_multi_json(info, json_wtr);
545a7795698SJiri Olsa break;
54688d61607SYafang Shao case BPF_LINK_TYPE_PERF_EVENT:
54788d61607SYafang Shao switch (info->perf_event.type) {
54888d61607SYafang Shao case BPF_PERF_EVENT_EVENT:
54988d61607SYafang Shao show_perf_event_event_json(info, json_wtr);
55088d61607SYafang Shao break;
55188d61607SYafang Shao case BPF_PERF_EVENT_TRACEPOINT:
55288d61607SYafang Shao show_perf_event_tracepoint_json(info, json_wtr);
55388d61607SYafang Shao break;
55488d61607SYafang Shao case BPF_PERF_EVENT_KPROBE:
55588d61607SYafang Shao case BPF_PERF_EVENT_KRETPROBE:
55688d61607SYafang Shao show_perf_event_kprobe_json(info, json_wtr);
55788d61607SYafang Shao break;
55888d61607SYafang Shao case BPF_PERF_EVENT_UPROBE:
55988d61607SYafang Shao case BPF_PERF_EVENT_URETPROBE:
56088d61607SYafang Shao show_perf_event_uprobe_json(info, json_wtr);
56188d61607SYafang Shao break;
56288d61607SYafang Shao default:
56388d61607SYafang Shao break;
56488d61607SYafang Shao }
56588d61607SYafang Shao break;
566c5481f9aSAndrii Nakryiko default:
567c5481f9aSAndrii Nakryiko break;
568c5481f9aSAndrii Nakryiko }
569c5481f9aSAndrii Nakryiko
5708f184732SQuentin Monnet if (!hashmap__empty(link_table)) {
5718f184732SQuentin Monnet struct hashmap_entry *entry;
572c5481f9aSAndrii Nakryiko
573c5481f9aSAndrii Nakryiko jsonw_name(json_wtr, "pinned");
574c5481f9aSAndrii Nakryiko jsonw_start_array(json_wtr);
575c302378bSEduard Zingerman hashmap__for_each_key_entry(link_table, entry, info->id)
576c302378bSEduard Zingerman jsonw_string(json_wtr, entry->pvalue);
577c5481f9aSAndrii Nakryiko jsonw_end_array(json_wtr);
578c5481f9aSAndrii Nakryiko }
579d53dee3fSAndrii Nakryiko
580d6699f8eSQuentin Monnet emit_obj_refs_json(refs_table, info->id, json_wtr);
581d53dee3fSAndrii Nakryiko
582c5481f9aSAndrii Nakryiko jsonw_end_object(json_wtr);
583c5481f9aSAndrii Nakryiko
584c5481f9aSAndrii Nakryiko return 0;
585c5481f9aSAndrii Nakryiko }
586c5481f9aSAndrii Nakryiko
show_link_header_plain(struct bpf_link_info * info)587c5481f9aSAndrii Nakryiko static void show_link_header_plain(struct bpf_link_info *info)
588c5481f9aSAndrii Nakryiko {
589c7e7e279SDaniel Müller const char *link_type_str;
590c7e7e279SDaniel Müller
591c5481f9aSAndrii Nakryiko printf("%u: ", info->id);
592c7e7e279SDaniel Müller link_type_str = libbpf_bpf_link_type_str(info->type);
593c7e7e279SDaniel Müller if (link_type_str)
594c7e7e279SDaniel Müller printf("%s ", link_type_str);
595c5481f9aSAndrii Nakryiko else
596c5481f9aSAndrii Nakryiko printf("type %u ", info->type);
597c5481f9aSAndrii Nakryiko
59874fc8801SKui-Feng Lee if (info->type == BPF_LINK_TYPE_STRUCT_OPS)
59974fc8801SKui-Feng Lee printf("map %u ", info->struct_ops.map_id);
60074fc8801SKui-Feng Lee else
601c5481f9aSAndrii Nakryiko printf("prog %u ", info->prog_id);
602c5481f9aSAndrii Nakryiko }
603c5481f9aSAndrii Nakryiko
show_link_attach_type_plain(__u32 attach_type)604be6e1981SJakub Sitnicki static void show_link_attach_type_plain(__u32 attach_type)
605be6e1981SJakub Sitnicki {
6061ba5ad36SDaniel Müller const char *attach_type_str;
6071ba5ad36SDaniel Müller
6081ba5ad36SDaniel Müller attach_type_str = libbpf_bpf_attach_type_str(attach_type);
6091ba5ad36SDaniel Müller if (attach_type_str)
6101ba5ad36SDaniel Müller printf("attach_type %s ", attach_type_str);
611be6e1981SJakub Sitnicki else
612be6e1981SJakub Sitnicki printf("attach_type %u ", attach_type);
613be6e1981SJakub Sitnicki }
614be6e1981SJakub Sitnicki
show_link_ifindex_plain(__u32 ifindex)615e16e6c6dSDaniel Borkmann static void show_link_ifindex_plain(__u32 ifindex)
616e16e6c6dSDaniel Borkmann {
617e16e6c6dSDaniel Borkmann char devname[IF_NAMESIZE * 2] = "(unknown)";
618e16e6c6dSDaniel Borkmann char tmpname[IF_NAMESIZE];
619e16e6c6dSDaniel Borkmann char *ret = NULL;
620e16e6c6dSDaniel Borkmann
621e16e6c6dSDaniel Borkmann if (ifindex)
622e16e6c6dSDaniel Borkmann ret = if_indextoname(ifindex, tmpname);
623e16e6c6dSDaniel Borkmann else
624e16e6c6dSDaniel Borkmann snprintf(devname, sizeof(devname), "(detached)");
625e16e6c6dSDaniel Borkmann if (ret)
626e16e6c6dSDaniel Borkmann snprintf(devname, sizeof(devname), "%s(%d)",
627e16e6c6dSDaniel Borkmann tmpname, ifindex);
628e16e6c6dSDaniel Borkmann printf("ifindex %s ", devname);
629e16e6c6dSDaniel Borkmann }
630e16e6c6dSDaniel Borkmann
show_iter_plain(struct bpf_link_info * info)631e60495eaSYonghong Song static void show_iter_plain(struct bpf_link_info *info)
632e60495eaSYonghong Song {
633e60495eaSYonghong Song const char *target_name = u64_to_ptr(info->iter.target_name);
634e60495eaSYonghong Song
635e60495eaSYonghong Song printf("target_name %s ", target_name);
636e60495eaSYonghong Song
637e60495eaSYonghong Song if (is_iter_map_target(target_name))
638e60495eaSYonghong Song printf("map_id %u ", info->iter.map.map_id);
6396bdb6d6bSKui-Feng Lee else if (is_iter_task_target(target_name)) {
6406bdb6d6bSKui-Feng Lee if (info->iter.task.tid)
6416bdb6d6bSKui-Feng Lee printf("tid %u ", info->iter.task.tid);
6426bdb6d6bSKui-Feng Lee else if (info->iter.task.pid)
6436bdb6d6bSKui-Feng Lee printf("pid %u ", info->iter.task.pid);
6446bdb6d6bSKui-Feng Lee }
6456f95de6dSHao Luo
6466f95de6dSHao Luo if (is_iter_cgroup_target(target_name)) {
6476f95de6dSHao Luo printf("cgroup_id %llu ", info->iter.cgroup.cgroup_id);
6486f95de6dSHao Luo printf("order %s ",
6496f95de6dSHao Luo cgroup_order_string(info->iter.cgroup.order));
6506f95de6dSHao Luo }
651e60495eaSYonghong Song }
652e60495eaSYonghong Song
653d0fe92fbSFlorian Westphal static const char * const pf2name[] = {
654d0fe92fbSFlorian Westphal [NFPROTO_INET] = "inet",
655d0fe92fbSFlorian Westphal [NFPROTO_IPV4] = "ip",
656d0fe92fbSFlorian Westphal [NFPROTO_ARP] = "arp",
657d0fe92fbSFlorian Westphal [NFPROTO_NETDEV] = "netdev",
658d0fe92fbSFlorian Westphal [NFPROTO_BRIDGE] = "bridge",
659d0fe92fbSFlorian Westphal [NFPROTO_IPV6] = "ip6",
660d0fe92fbSFlorian Westphal };
661d0fe92fbSFlorian Westphal
662d0fe92fbSFlorian Westphal static const char * const inethook2name[] = {
663d0fe92fbSFlorian Westphal [NF_INET_PRE_ROUTING] = "prerouting",
664d0fe92fbSFlorian Westphal [NF_INET_LOCAL_IN] = "input",
665d0fe92fbSFlorian Westphal [NF_INET_FORWARD] = "forward",
666d0fe92fbSFlorian Westphal [NF_INET_LOCAL_OUT] = "output",
667d0fe92fbSFlorian Westphal [NF_INET_POST_ROUTING] = "postrouting",
668d0fe92fbSFlorian Westphal };
669d0fe92fbSFlorian Westphal
670d0fe92fbSFlorian Westphal static const char * const arphook2name[] = {
671d0fe92fbSFlorian Westphal [NF_ARP_IN] = "input",
672d0fe92fbSFlorian Westphal [NF_ARP_OUT] = "output",
673d0fe92fbSFlorian Westphal };
674d0fe92fbSFlorian Westphal
netfilter_dump_plain(const struct bpf_link_info * info)675d0fe92fbSFlorian Westphal void netfilter_dump_plain(const struct bpf_link_info *info)
676d0fe92fbSFlorian Westphal {
677d0fe92fbSFlorian Westphal const char *hookname = NULL, *pfname = NULL;
678d0fe92fbSFlorian Westphal unsigned int hook = info->netfilter.hooknum;
679d0fe92fbSFlorian Westphal unsigned int pf = info->netfilter.pf;
680d0fe92fbSFlorian Westphal
681d0fe92fbSFlorian Westphal if (pf < ARRAY_SIZE(pf2name))
682d0fe92fbSFlorian Westphal pfname = pf2name[pf];
683d0fe92fbSFlorian Westphal
684d0fe92fbSFlorian Westphal switch (pf) {
685d0fe92fbSFlorian Westphal case NFPROTO_BRIDGE: /* bridge shares numbers with enum nf_inet_hooks */
686d0fe92fbSFlorian Westphal case NFPROTO_IPV4:
687d0fe92fbSFlorian Westphal case NFPROTO_IPV6:
688d0fe92fbSFlorian Westphal case NFPROTO_INET:
689d0fe92fbSFlorian Westphal if (hook < ARRAY_SIZE(inethook2name))
690d0fe92fbSFlorian Westphal hookname = inethook2name[hook];
691d0fe92fbSFlorian Westphal break;
692d0fe92fbSFlorian Westphal case NFPROTO_ARP:
693d0fe92fbSFlorian Westphal if (hook < ARRAY_SIZE(arphook2name))
694d0fe92fbSFlorian Westphal hookname = arphook2name[hook];
695d0fe92fbSFlorian Westphal default:
696d0fe92fbSFlorian Westphal break;
697d0fe92fbSFlorian Westphal }
698d0fe92fbSFlorian Westphal
699d0fe92fbSFlorian Westphal if (pfname)
700d0fe92fbSFlorian Westphal printf("\n\t%s", pfname);
701d0fe92fbSFlorian Westphal else
702d0fe92fbSFlorian Westphal printf("\n\tpf: %d", pf);
703d0fe92fbSFlorian Westphal
704d0fe92fbSFlorian Westphal if (hookname)
705d0fe92fbSFlorian Westphal printf(" %s", hookname);
706d0fe92fbSFlorian Westphal else
707d0fe92fbSFlorian Westphal printf(", hook %u,", hook);
708d0fe92fbSFlorian Westphal
709d0fe92fbSFlorian Westphal printf(" prio %d", info->netfilter.priority);
710d0fe92fbSFlorian Westphal
711d0fe92fbSFlorian Westphal if (info->netfilter.flags)
712d0fe92fbSFlorian Westphal printf(" flags 0x%x", info->netfilter.flags);
713d0fe92fbSFlorian Westphal }
714d0fe92fbSFlorian Westphal
show_kprobe_multi_plain(struct bpf_link_info * info)715edd7f49bSYafang Shao static void show_kprobe_multi_plain(struct bpf_link_info *info)
716edd7f49bSYafang Shao {
717b0dc0373SJiri Olsa struct addr_cookie *data;
718edd7f49bSYafang Shao __u32 i, j = 0;
719edd7f49bSYafang Shao
720edd7f49bSYafang Shao if (!info->kprobe_multi.count)
721edd7f49bSYafang Shao return;
722edd7f49bSYafang Shao
723edd7f49bSYafang Shao if (info->kprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN)
724edd7f49bSYafang Shao printf("\n\tkretprobe.multi ");
725edd7f49bSYafang Shao else
726edd7f49bSYafang Shao printf("\n\tkprobe.multi ");
727edd7f49bSYafang Shao printf("func_cnt %u ", info->kprobe_multi.count);
728b24fc355SJiri Olsa if (info->kprobe_multi.missed)
729b24fc355SJiri Olsa printf("missed %llu ", info->kprobe_multi.missed);
730b0dc0373SJiri Olsa data = get_addr_cookie_array(u64_to_ptr(info->kprobe_multi.addrs),
731b0dc0373SJiri Olsa u64_to_ptr(info->kprobe_multi.cookies),
732b0dc0373SJiri Olsa info->kprobe_multi.count);
733b0dc0373SJiri Olsa if (!data)
734b0dc0373SJiri Olsa return;
735edd7f49bSYafang Shao
736edd7f49bSYafang Shao /* Load it once for all. */
737edd7f49bSYafang Shao if (!dd.sym_count)
738edd7f49bSYafang Shao kernel_syms_load(&dd);
739edd7f49bSYafang Shao if (!dd.sym_count)
740b0dc0373SJiri Olsa goto error;
741edd7f49bSYafang Shao
742b0dc0373SJiri Olsa printf("\n\t%-16s %-16s %s", "addr", "cookie", "func [module]");
743edd7f49bSYafang Shao for (i = 0; i < dd.sym_count; i++) {
744b0dc0373SJiri Olsa if (dd.sym_mapping[i].address != data[j].addr)
745edd7f49bSYafang Shao continue;
746b0dc0373SJiri Olsa printf("\n\t%016lx %-16llx %s",
747b0dc0373SJiri Olsa dd.sym_mapping[i].address, data[j].cookie, dd.sym_mapping[i].name);
748edd7f49bSYafang Shao if (dd.sym_mapping[i].module[0] != '\0')
749edd7f49bSYafang Shao printf(" [%s] ", dd.sym_mapping[i].module);
750edd7f49bSYafang Shao else
751edd7f49bSYafang Shao printf(" ");
752edd7f49bSYafang Shao
753edd7f49bSYafang Shao if (j++ == info->kprobe_multi.count)
754edd7f49bSYafang Shao break;
755edd7f49bSYafang Shao }
756b0dc0373SJiri Olsa error:
757b0dc0373SJiri Olsa free(data);
758edd7f49bSYafang Shao }
759edd7f49bSYafang Shao
show_uprobe_multi_plain(struct bpf_link_info * info)760a7795698SJiri Olsa static void show_uprobe_multi_plain(struct bpf_link_info *info)
761a7795698SJiri Olsa {
762a7795698SJiri Olsa __u32 i;
763a7795698SJiri Olsa
764a7795698SJiri Olsa if (!info->uprobe_multi.count)
765a7795698SJiri Olsa return;
766a7795698SJiri Olsa
767a7795698SJiri Olsa if (info->uprobe_multi.flags & BPF_F_UPROBE_MULTI_RETURN)
768a7795698SJiri Olsa printf("\n\turetprobe.multi ");
769a7795698SJiri Olsa else
770a7795698SJiri Olsa printf("\n\tuprobe.multi ");
771a7795698SJiri Olsa
772a7795698SJiri Olsa printf("path %s ", (char *) u64_to_ptr(info->uprobe_multi.path));
773a7795698SJiri Olsa printf("func_cnt %u ", info->uprobe_multi.count);
774a7795698SJiri Olsa
775a7795698SJiri Olsa if (info->uprobe_multi.pid)
776a7795698SJiri Olsa printf("pid %d ", info->uprobe_multi.pid);
777a7795698SJiri Olsa
778a7795698SJiri Olsa printf("\n\t%-16s %-16s %-16s", "offset", "ref_ctr_offset", "cookies");
779a7795698SJiri Olsa for (i = 0; i < info->uprobe_multi.count; i++) {
780a7795698SJiri Olsa printf("\n\t0x%-16llx 0x%-16llx 0x%-16llx",
781a7795698SJiri Olsa u64_to_arr(info->uprobe_multi.offsets)[i],
782a7795698SJiri Olsa u64_to_arr(info->uprobe_multi.ref_ctr_offsets)[i],
783a7795698SJiri Olsa u64_to_arr(info->uprobe_multi.cookies)[i]);
784a7795698SJiri Olsa }
785a7795698SJiri Olsa }
786a7795698SJiri Olsa
show_perf_event_kprobe_plain(struct bpf_link_info * info)78788d61607SYafang Shao static void show_perf_event_kprobe_plain(struct bpf_link_info *info)
78888d61607SYafang Shao {
78988d61607SYafang Shao const char *buf;
79088d61607SYafang Shao
79188d61607SYafang Shao buf = u64_to_ptr(info->perf_event.kprobe.func_name);
79288d61607SYafang Shao if (buf[0] == '\0' && !info->perf_event.kprobe.addr)
79388d61607SYafang Shao return;
79488d61607SYafang Shao
79588d61607SYafang Shao if (info->perf_event.type == BPF_PERF_EVENT_KRETPROBE)
79688d61607SYafang Shao printf("\n\tkretprobe ");
79788d61607SYafang Shao else
79888d61607SYafang Shao printf("\n\tkprobe ");
79988d61607SYafang Shao if (info->perf_event.kprobe.addr)
80088d61607SYafang Shao printf("%llx ", info->perf_event.kprobe.addr);
80188d61607SYafang Shao printf("%s", buf);
80288d61607SYafang Shao if (info->perf_event.kprobe.offset)
80388d61607SYafang Shao printf("+%#x", info->perf_event.kprobe.offset);
804b563b9baSJiri Olsa if (info->perf_event.kprobe.missed)
805b563b9baSJiri Olsa printf(" missed %llu", info->perf_event.kprobe.missed);
80654258324SJiri Olsa if (info->perf_event.kprobe.cookie)
80754258324SJiri Olsa printf(" cookie %llu", info->perf_event.kprobe.cookie);
80888d61607SYafang Shao printf(" ");
80988d61607SYafang Shao }
81088d61607SYafang Shao
show_perf_event_uprobe_plain(struct bpf_link_info * info)81188d61607SYafang Shao static void show_perf_event_uprobe_plain(struct bpf_link_info *info)
81288d61607SYafang Shao {
81388d61607SYafang Shao const char *buf;
81488d61607SYafang Shao
81588d61607SYafang Shao buf = u64_to_ptr(info->perf_event.uprobe.file_name);
81688d61607SYafang Shao if (buf[0] == '\0')
81788d61607SYafang Shao return;
81888d61607SYafang Shao
81988d61607SYafang Shao if (info->perf_event.type == BPF_PERF_EVENT_URETPROBE)
82088d61607SYafang Shao printf("\n\turetprobe ");
82188d61607SYafang Shao else
82288d61607SYafang Shao printf("\n\tuprobe ");
82388d61607SYafang Shao printf("%s+%#x ", buf, info->perf_event.uprobe.offset);
82454258324SJiri Olsa if (info->perf_event.uprobe.cookie)
82554258324SJiri Olsa printf("cookie %llu ", info->perf_event.uprobe.cookie);
82688d61607SYafang Shao }
82788d61607SYafang Shao
show_perf_event_tracepoint_plain(struct bpf_link_info * info)82888d61607SYafang Shao static void show_perf_event_tracepoint_plain(struct bpf_link_info *info)
82988d61607SYafang Shao {
83088d61607SYafang Shao const char *buf;
83188d61607SYafang Shao
83288d61607SYafang Shao buf = u64_to_ptr(info->perf_event.tracepoint.tp_name);
83388d61607SYafang Shao if (buf[0] == '\0')
83488d61607SYafang Shao return;
83588d61607SYafang Shao
83688d61607SYafang Shao printf("\n\ttracepoint %s ", buf);
83754258324SJiri Olsa if (info->perf_event.tracepoint.cookie)
83854258324SJiri Olsa printf("cookie %llu ", info->perf_event.tracepoint.cookie);
83988d61607SYafang Shao }
84088d61607SYafang Shao
show_perf_event_event_plain(struct bpf_link_info * info)84188d61607SYafang Shao static void show_perf_event_event_plain(struct bpf_link_info *info)
84288d61607SYafang Shao {
84388d61607SYafang Shao __u64 config = info->perf_event.event.config;
84488d61607SYafang Shao __u32 type = info->perf_event.event.type;
84588d61607SYafang Shao const char *perf_type, *perf_config;
84688d61607SYafang Shao
84788d61607SYafang Shao printf("\n\tevent ");
84888d61607SYafang Shao perf_type = perf_event_name(perf_type_name, type);
84988d61607SYafang Shao if (perf_type)
85088d61607SYafang Shao printf("%s:", perf_type);
85188d61607SYafang Shao else
85288d61607SYafang Shao printf("%u :", type);
85388d61607SYafang Shao
85488d61607SYafang Shao perf_config = perf_config_str(type, config);
85588d61607SYafang Shao if (perf_config)
85688d61607SYafang Shao printf("%s ", perf_config);
85788d61607SYafang Shao else
85888d61607SYafang Shao printf("%llu ", config);
85988d61607SYafang Shao
86054258324SJiri Olsa if (info->perf_event.event.cookie)
86154258324SJiri Olsa printf("cookie %llu ", info->perf_event.event.cookie);
86254258324SJiri Olsa
86388d61607SYafang Shao if (type == PERF_TYPE_HW_CACHE && perf_config)
86488d61607SYafang Shao free((void *)perf_config);
86588d61607SYafang Shao }
86688d61607SYafang Shao
show_link_close_plain(int fd,struct bpf_link_info * info)867c5481f9aSAndrii Nakryiko static int show_link_close_plain(int fd, struct bpf_link_info *info)
868c5481f9aSAndrii Nakryiko {
869c5481f9aSAndrii Nakryiko struct bpf_prog_info prog_info;
870b700eeb4SDaniel Müller const char *prog_type_str;
871c5481f9aSAndrii Nakryiko int err;
872c5481f9aSAndrii Nakryiko
873c5481f9aSAndrii Nakryiko show_link_header_plain(info);
874c5481f9aSAndrii Nakryiko
875c5481f9aSAndrii Nakryiko switch (info->type) {
876c5481f9aSAndrii Nakryiko case BPF_LINK_TYPE_RAW_TRACEPOINT:
877c5481f9aSAndrii Nakryiko printf("\n\ttp '%s' ",
87809f44b75SAndrii Nakryiko (const char *)u64_to_ptr(info->raw_tracepoint.tp_name));
879c5481f9aSAndrii Nakryiko break;
880c5481f9aSAndrii Nakryiko case BPF_LINK_TYPE_TRACING:
881c5481f9aSAndrii Nakryiko err = get_prog_info(info->prog_id, &prog_info);
882c5481f9aSAndrii Nakryiko if (err)
883c5481f9aSAndrii Nakryiko return err;
884c5481f9aSAndrii Nakryiko
885b700eeb4SDaniel Müller prog_type_str = libbpf_bpf_prog_type_str(prog_info.type);
886b700eeb4SDaniel Müller /* libbpf will return NULL for variants unknown to it. */
887b700eeb4SDaniel Müller if (prog_type_str)
888b700eeb4SDaniel Müller printf("\n\tprog_type %s ", prog_type_str);
889c5481f9aSAndrii Nakryiko else
890c5481f9aSAndrii Nakryiko printf("\n\tprog_type %u ", prog_info.type);
891c5481f9aSAndrii Nakryiko
892be6e1981SJakub Sitnicki show_link_attach_type_plain(info->tracing.attach_type);
893d7e45eb4SYafang Shao if (info->tracing.target_obj_id || info->tracing.target_btf_id)
894d7e45eb4SYafang Shao printf("\n\ttarget_obj_id %u target_btf_id %u ",
895d7e45eb4SYafang Shao info->tracing.target_obj_id,
896d7e45eb4SYafang Shao info->tracing.target_btf_id);
897c5481f9aSAndrii Nakryiko break;
898c5481f9aSAndrii Nakryiko case BPF_LINK_TYPE_CGROUP:
899c5481f9aSAndrii Nakryiko printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id);
900be6e1981SJakub Sitnicki show_link_attach_type_plain(info->cgroup.attach_type);
901c5481f9aSAndrii Nakryiko break;
902e60495eaSYonghong Song case BPF_LINK_TYPE_ITER:
903e60495eaSYonghong Song show_iter_plain(info);
904e60495eaSYonghong Song break;
905e948947aSJakub Sitnicki case BPF_LINK_TYPE_NETNS:
906e948947aSJakub Sitnicki printf("\n\tnetns_ino %u ", info->netns.netns_ino);
907e948947aSJakub Sitnicki show_link_attach_type_plain(info->netns.attach_type);
908e948947aSJakub Sitnicki break;
909d0fe92fbSFlorian Westphal case BPF_LINK_TYPE_NETFILTER:
910d0fe92fbSFlorian Westphal netfilter_dump_plain(info);
911d0fe92fbSFlorian Westphal break;
912e16e6c6dSDaniel Borkmann case BPF_LINK_TYPE_TCX:
913e16e6c6dSDaniel Borkmann printf("\n\t");
914e16e6c6dSDaniel Borkmann show_link_ifindex_plain(info->tcx.ifindex);
915e16e6c6dSDaniel Borkmann show_link_attach_type_plain(info->tcx.attach_type);
916e16e6c6dSDaniel Borkmann break;
91792a85e18SDaniel Borkmann case BPF_LINK_TYPE_NETKIT:
91892a85e18SDaniel Borkmann printf("\n\t");
91992a85e18SDaniel Borkmann show_link_ifindex_plain(info->netkit.ifindex);
92092a85e18SDaniel Borkmann show_link_attach_type_plain(info->netkit.attach_type);
92192a85e18SDaniel Borkmann break;
922*1f3e2091SYonghong Song case BPF_LINK_TYPE_SOCKMAP:
923*1f3e2091SYonghong Song printf("\n\t");
924*1f3e2091SYonghong Song printf("map_id %u ", info->sockmap.map_id);
925*1f3e2091SYonghong Song show_link_attach_type_plain(info->sockmap.attach_type);
926*1f3e2091SYonghong Song break;
927053bbf9bSDaniel Borkmann case BPF_LINK_TYPE_XDP:
928053bbf9bSDaniel Borkmann printf("\n\t");
929053bbf9bSDaniel Borkmann show_link_ifindex_plain(info->xdp.ifindex);
930053bbf9bSDaniel Borkmann break;
931edd7f49bSYafang Shao case BPF_LINK_TYPE_KPROBE_MULTI:
932edd7f49bSYafang Shao show_kprobe_multi_plain(info);
933edd7f49bSYafang Shao break;
934a7795698SJiri Olsa case BPF_LINK_TYPE_UPROBE_MULTI:
935a7795698SJiri Olsa show_uprobe_multi_plain(info);
936a7795698SJiri Olsa break;
93788d61607SYafang Shao case BPF_LINK_TYPE_PERF_EVENT:
93888d61607SYafang Shao switch (info->perf_event.type) {
93988d61607SYafang Shao case BPF_PERF_EVENT_EVENT:
94088d61607SYafang Shao show_perf_event_event_plain(info);
94188d61607SYafang Shao break;
94288d61607SYafang Shao case BPF_PERF_EVENT_TRACEPOINT:
94388d61607SYafang Shao show_perf_event_tracepoint_plain(info);
94488d61607SYafang Shao break;
94588d61607SYafang Shao case BPF_PERF_EVENT_KPROBE:
94688d61607SYafang Shao case BPF_PERF_EVENT_KRETPROBE:
94788d61607SYafang Shao show_perf_event_kprobe_plain(info);
94888d61607SYafang Shao break;
94988d61607SYafang Shao case BPF_PERF_EVENT_UPROBE:
95088d61607SYafang Shao case BPF_PERF_EVENT_URETPROBE:
95188d61607SYafang Shao show_perf_event_uprobe_plain(info);
95288d61607SYafang Shao break;
95388d61607SYafang Shao default:
95488d61607SYafang Shao break;
95588d61607SYafang Shao }
95688d61607SYafang Shao break;
957c5481f9aSAndrii Nakryiko default:
958c5481f9aSAndrii Nakryiko break;
959c5481f9aSAndrii Nakryiko }
960c5481f9aSAndrii Nakryiko
9618f184732SQuentin Monnet if (!hashmap__empty(link_table)) {
9628f184732SQuentin Monnet struct hashmap_entry *entry;
963c5481f9aSAndrii Nakryiko
964c302378bSEduard Zingerman hashmap__for_each_key_entry(link_table, entry, info->id)
965c302378bSEduard Zingerman printf("\n\tpinned %s", (char *)entry->pvalue);
966c5481f9aSAndrii Nakryiko }
967d6699f8eSQuentin Monnet emit_obj_refs_plain(refs_table, info->id, "\n\tpids ");
968c5481f9aSAndrii Nakryiko
969c5481f9aSAndrii Nakryiko printf("\n");
970c5481f9aSAndrii Nakryiko
971c5481f9aSAndrii Nakryiko return 0;
972c5481f9aSAndrii Nakryiko }
973c5481f9aSAndrii Nakryiko
do_show_link(int fd)974c5481f9aSAndrii Nakryiko static int do_show_link(int fd)
975c5481f9aSAndrii Nakryiko {
976a7795698SJiri Olsa __u64 *ref_ctr_offsets = NULL, *offsets = NULL, *cookies = NULL;
977c5481f9aSAndrii Nakryiko struct bpf_link_info info;
978c5481f9aSAndrii Nakryiko __u32 len = sizeof(info);
979a7795698SJiri Olsa char path_buf[PATH_MAX];
980edd7f49bSYafang Shao __u64 *addrs = NULL;
98188d61607SYafang Shao char buf[PATH_MAX];
982edd7f49bSYafang Shao int count;
983c5481f9aSAndrii Nakryiko int err;
984c5481f9aSAndrii Nakryiko
985c5481f9aSAndrii Nakryiko memset(&info, 0, sizeof(info));
98688d61607SYafang Shao buf[0] = '\0';
987c5481f9aSAndrii Nakryiko again:
98838f0408eSIlya Leoshkevich err = bpf_link_get_info_by_fd(fd, &info, &len);
989c5481f9aSAndrii Nakryiko if (err) {
990c5481f9aSAndrii Nakryiko p_err("can't get link info: %s",
991c5481f9aSAndrii Nakryiko strerror(errno));
992c5481f9aSAndrii Nakryiko close(fd);
993c5481f9aSAndrii Nakryiko return err;
994c5481f9aSAndrii Nakryiko }
995c5481f9aSAndrii Nakryiko if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT &&
996c5481f9aSAndrii Nakryiko !info.raw_tracepoint.tp_name) {
997edd7f49bSYafang Shao info.raw_tracepoint.tp_name = ptr_to_u64(&buf);
998e60495eaSYonghong Song info.raw_tracepoint.tp_name_len = sizeof(buf);
999e60495eaSYonghong Song goto again;
1000e60495eaSYonghong Song }
1001e60495eaSYonghong Song if (info.type == BPF_LINK_TYPE_ITER &&
1002e60495eaSYonghong Song !info.iter.target_name) {
1003edd7f49bSYafang Shao info.iter.target_name = ptr_to_u64(&buf);
1004e60495eaSYonghong Song info.iter.target_name_len = sizeof(buf);
1005c5481f9aSAndrii Nakryiko goto again;
1006c5481f9aSAndrii Nakryiko }
1007edd7f49bSYafang Shao if (info.type == BPF_LINK_TYPE_KPROBE_MULTI &&
1008edd7f49bSYafang Shao !info.kprobe_multi.addrs) {
1009edd7f49bSYafang Shao count = info.kprobe_multi.count;
1010edd7f49bSYafang Shao if (count) {
1011edd7f49bSYafang Shao addrs = calloc(count, sizeof(__u64));
1012edd7f49bSYafang Shao if (!addrs) {
1013edd7f49bSYafang Shao p_err("mem alloc failed");
1014edd7f49bSYafang Shao close(fd);
1015edd7f49bSYafang Shao return -ENOMEM;
1016edd7f49bSYafang Shao }
1017edd7f49bSYafang Shao info.kprobe_multi.addrs = ptr_to_u64(addrs);
1018b0dc0373SJiri Olsa cookies = calloc(count, sizeof(__u64));
1019b0dc0373SJiri Olsa if (!cookies) {
1020b0dc0373SJiri Olsa p_err("mem alloc failed");
1021b0dc0373SJiri Olsa free(addrs);
1022b0dc0373SJiri Olsa close(fd);
1023b0dc0373SJiri Olsa return -ENOMEM;
1024b0dc0373SJiri Olsa }
1025b0dc0373SJiri Olsa info.kprobe_multi.cookies = ptr_to_u64(cookies);
1026edd7f49bSYafang Shao goto again;
1027edd7f49bSYafang Shao }
1028edd7f49bSYafang Shao }
1029a7795698SJiri Olsa if (info.type == BPF_LINK_TYPE_UPROBE_MULTI &&
1030a7795698SJiri Olsa !info.uprobe_multi.offsets) {
1031a7795698SJiri Olsa count = info.uprobe_multi.count;
1032a7795698SJiri Olsa if (count) {
1033a7795698SJiri Olsa offsets = calloc(count, sizeof(__u64));
1034a7795698SJiri Olsa if (!offsets) {
1035a7795698SJiri Olsa p_err("mem alloc failed");
1036a7795698SJiri Olsa close(fd);
1037a7795698SJiri Olsa return -ENOMEM;
1038a7795698SJiri Olsa }
1039a7795698SJiri Olsa info.uprobe_multi.offsets = ptr_to_u64(offsets);
1040a7795698SJiri Olsa ref_ctr_offsets = calloc(count, sizeof(__u64));
1041a7795698SJiri Olsa if (!ref_ctr_offsets) {
1042a7795698SJiri Olsa p_err("mem alloc failed");
1043a7795698SJiri Olsa free(offsets);
1044a7795698SJiri Olsa close(fd);
1045a7795698SJiri Olsa return -ENOMEM;
1046a7795698SJiri Olsa }
1047a7795698SJiri Olsa info.uprobe_multi.ref_ctr_offsets = ptr_to_u64(ref_ctr_offsets);
1048a7795698SJiri Olsa cookies = calloc(count, sizeof(__u64));
1049a7795698SJiri Olsa if (!cookies) {
1050a7795698SJiri Olsa p_err("mem alloc failed");
10512adb2e0fSJiri Olsa free(ref_ctr_offsets);
1052a7795698SJiri Olsa free(offsets);
1053a7795698SJiri Olsa close(fd);
1054a7795698SJiri Olsa return -ENOMEM;
1055a7795698SJiri Olsa }
1056a7795698SJiri Olsa info.uprobe_multi.cookies = ptr_to_u64(cookies);
1057a7795698SJiri Olsa info.uprobe_multi.path = ptr_to_u64(path_buf);
1058a7795698SJiri Olsa info.uprobe_multi.path_size = sizeof(path_buf);
1059a7795698SJiri Olsa goto again;
1060a7795698SJiri Olsa }
1061a7795698SJiri Olsa }
106288d61607SYafang Shao if (info.type == BPF_LINK_TYPE_PERF_EVENT) {
106388d61607SYafang Shao switch (info.perf_event.type) {
106488d61607SYafang Shao case BPF_PERF_EVENT_TRACEPOINT:
106588d61607SYafang Shao if (!info.perf_event.tracepoint.tp_name) {
106688d61607SYafang Shao info.perf_event.tracepoint.tp_name = ptr_to_u64(&buf);
106788d61607SYafang Shao info.perf_event.tracepoint.name_len = sizeof(buf);
106888d61607SYafang Shao goto again;
106988d61607SYafang Shao }
107088d61607SYafang Shao break;
107188d61607SYafang Shao case BPF_PERF_EVENT_KPROBE:
107288d61607SYafang Shao case BPF_PERF_EVENT_KRETPROBE:
107388d61607SYafang Shao if (!info.perf_event.kprobe.func_name) {
107488d61607SYafang Shao info.perf_event.kprobe.func_name = ptr_to_u64(&buf);
107588d61607SYafang Shao info.perf_event.kprobe.name_len = sizeof(buf);
107688d61607SYafang Shao goto again;
107788d61607SYafang Shao }
107888d61607SYafang Shao break;
107988d61607SYafang Shao case BPF_PERF_EVENT_UPROBE:
108088d61607SYafang Shao case BPF_PERF_EVENT_URETPROBE:
108188d61607SYafang Shao if (!info.perf_event.uprobe.file_name) {
108288d61607SYafang Shao info.perf_event.uprobe.file_name = ptr_to_u64(&buf);
108388d61607SYafang Shao info.perf_event.uprobe.name_len = sizeof(buf);
108488d61607SYafang Shao goto again;
108588d61607SYafang Shao }
108688d61607SYafang Shao break;
108788d61607SYafang Shao default:
108888d61607SYafang Shao break;
108988d61607SYafang Shao }
109088d61607SYafang Shao }
1091c5481f9aSAndrii Nakryiko
1092c5481f9aSAndrii Nakryiko if (json_output)
1093c5481f9aSAndrii Nakryiko show_link_close_json(fd, &info);
1094c5481f9aSAndrii Nakryiko else
1095c5481f9aSAndrii Nakryiko show_link_close_plain(fd, &info);
1096c5481f9aSAndrii Nakryiko
1097a7795698SJiri Olsa free(ref_ctr_offsets);
1098a7795698SJiri Olsa free(cookies);
1099a7795698SJiri Olsa free(offsets);
1100edd7f49bSYafang Shao free(addrs);
1101c5481f9aSAndrii Nakryiko close(fd);
1102c5481f9aSAndrii Nakryiko return 0;
1103c5481f9aSAndrii Nakryiko }
1104c5481f9aSAndrii Nakryiko
do_show(int argc,char ** argv)1105c5481f9aSAndrii Nakryiko static int do_show(int argc, char **argv)
1106c5481f9aSAndrii Nakryiko {
1107c5481f9aSAndrii Nakryiko __u32 id = 0;
1108c5481f9aSAndrii Nakryiko int err, fd;
1109c5481f9aSAndrii Nakryiko
111046241271SQuentin Monnet if (show_pinned) {
11118f184732SQuentin Monnet link_table = hashmap__new(hash_fn_for_key_as_id,
11128f184732SQuentin Monnet equal_fn_for_key_as_id, NULL);
1113622a5b58SMauricio Vásquez if (IS_ERR(link_table)) {
11148f184732SQuentin Monnet p_err("failed to create hashmap for pinned paths");
11158f184732SQuentin Monnet return -1;
11168f184732SQuentin Monnet }
11178f184732SQuentin Monnet build_pinned_obj_table(link_table, BPF_OBJ_LINK);
111846241271SQuentin Monnet }
1119d53dee3fSAndrii Nakryiko build_obj_refs_table(&refs_table, BPF_OBJ_LINK);
1120c5481f9aSAndrii Nakryiko
1121c5481f9aSAndrii Nakryiko if (argc == 2) {
1122c5481f9aSAndrii Nakryiko fd = link_parse_fd(&argc, &argv);
1123c5481f9aSAndrii Nakryiko if (fd < 0)
1124c5481f9aSAndrii Nakryiko return fd;
1125edd7f49bSYafang Shao do_show_link(fd);
1126edd7f49bSYafang Shao goto out;
1127c5481f9aSAndrii Nakryiko }
1128c5481f9aSAndrii Nakryiko
1129c5481f9aSAndrii Nakryiko if (argc)
1130c5481f9aSAndrii Nakryiko return BAD_ARG();
1131c5481f9aSAndrii Nakryiko
1132c5481f9aSAndrii Nakryiko if (json_output)
1133c5481f9aSAndrii Nakryiko jsonw_start_array(json_wtr);
1134c5481f9aSAndrii Nakryiko while (true) {
1135c5481f9aSAndrii Nakryiko err = bpf_link_get_next_id(id, &id);
1136c5481f9aSAndrii Nakryiko if (err) {
1137c5481f9aSAndrii Nakryiko if (errno == ENOENT)
1138c5481f9aSAndrii Nakryiko break;
1139c5481f9aSAndrii Nakryiko p_err("can't get next link: %s%s", strerror(errno),
1140c5481f9aSAndrii Nakryiko errno == EINVAL ? " -- kernel too old?" : "");
1141c5481f9aSAndrii Nakryiko break;
1142c5481f9aSAndrii Nakryiko }
1143c5481f9aSAndrii Nakryiko
1144c5481f9aSAndrii Nakryiko fd = bpf_link_get_fd_by_id(id);
1145c5481f9aSAndrii Nakryiko if (fd < 0) {
1146c5481f9aSAndrii Nakryiko if (errno == ENOENT)
1147c5481f9aSAndrii Nakryiko continue;
1148c5481f9aSAndrii Nakryiko p_err("can't get link by id (%u): %s",
1149c5481f9aSAndrii Nakryiko id, strerror(errno));
1150c5481f9aSAndrii Nakryiko break;
1151c5481f9aSAndrii Nakryiko }
1152c5481f9aSAndrii Nakryiko
1153c5481f9aSAndrii Nakryiko err = do_show_link(fd);
1154c5481f9aSAndrii Nakryiko if (err)
1155c5481f9aSAndrii Nakryiko break;
1156c5481f9aSAndrii Nakryiko }
1157c5481f9aSAndrii Nakryiko if (json_output)
1158c5481f9aSAndrii Nakryiko jsonw_end_array(json_wtr);
1159c5481f9aSAndrii Nakryiko
1160d6699f8eSQuentin Monnet delete_obj_refs_table(refs_table);
1161d53dee3fSAndrii Nakryiko
116246241271SQuentin Monnet if (show_pinned)
11638f184732SQuentin Monnet delete_pinned_obj_table(link_table);
116446241271SQuentin Monnet
1165edd7f49bSYafang Shao out:
1166edd7f49bSYafang Shao if (dd.sym_count)
1167edd7f49bSYafang Shao kernel_syms_destroy(&dd);
1168c5481f9aSAndrii Nakryiko return errno == ENOENT ? 0 : -1;
1169c5481f9aSAndrii Nakryiko }
1170c5481f9aSAndrii Nakryiko
do_pin(int argc,char ** argv)1171c5481f9aSAndrii Nakryiko static int do_pin(int argc, char **argv)
1172c5481f9aSAndrii Nakryiko {
1173c5481f9aSAndrii Nakryiko int err;
1174c5481f9aSAndrii Nakryiko
1175c5481f9aSAndrii Nakryiko err = do_pin_any(argc, argv, link_parse_fd);
1176c5481f9aSAndrii Nakryiko if (!err && json_output)
1177c5481f9aSAndrii Nakryiko jsonw_null(json_wtr);
1178c5481f9aSAndrii Nakryiko return err;
1179c5481f9aSAndrii Nakryiko }
1180c5481f9aSAndrii Nakryiko
do_detach(int argc,char ** argv)11810e8c7c07SAndrii Nakryiko static int do_detach(int argc, char **argv)
11820e8c7c07SAndrii Nakryiko {
11830e8c7c07SAndrii Nakryiko int err, fd;
11840e8c7c07SAndrii Nakryiko
11850e8c7c07SAndrii Nakryiko if (argc != 2) {
11860e8c7c07SAndrii Nakryiko p_err("link specifier is invalid or missing\n");
11870e8c7c07SAndrii Nakryiko return 1;
11880e8c7c07SAndrii Nakryiko }
11890e8c7c07SAndrii Nakryiko
11900e8c7c07SAndrii Nakryiko fd = link_parse_fd(&argc, &argv);
11910e8c7c07SAndrii Nakryiko if (fd < 0)
11920e8c7c07SAndrii Nakryiko return 1;
11930e8c7c07SAndrii Nakryiko
11940e8c7c07SAndrii Nakryiko err = bpf_link_detach(fd);
11950e8c7c07SAndrii Nakryiko if (err)
11960e8c7c07SAndrii Nakryiko err = -errno;
11970e8c7c07SAndrii Nakryiko close(fd);
11980e8c7c07SAndrii Nakryiko if (err) {
11990e8c7c07SAndrii Nakryiko p_err("failed link detach: %s", strerror(-err));
12000e8c7c07SAndrii Nakryiko return 1;
12010e8c7c07SAndrii Nakryiko }
12020e8c7c07SAndrii Nakryiko
12030e8c7c07SAndrii Nakryiko if (json_output)
12040e8c7c07SAndrii Nakryiko jsonw_null(json_wtr);
12050e8c7c07SAndrii Nakryiko
12060e8c7c07SAndrii Nakryiko return 0;
12070e8c7c07SAndrii Nakryiko }
12080e8c7c07SAndrii Nakryiko
do_help(int argc,char ** argv)1209c5481f9aSAndrii Nakryiko static int do_help(int argc, char **argv)
1210c5481f9aSAndrii Nakryiko {
1211c5481f9aSAndrii Nakryiko if (json_output) {
1212c5481f9aSAndrii Nakryiko jsonw_null(json_wtr);
1213c5481f9aSAndrii Nakryiko return 0;
1214c5481f9aSAndrii Nakryiko }
1215c5481f9aSAndrii Nakryiko
1216c5481f9aSAndrii Nakryiko fprintf(stderr,
1217c5481f9aSAndrii Nakryiko "Usage: %1$s %2$s { show | list } [LINK]\n"
1218c5481f9aSAndrii Nakryiko " %1$s %2$s pin LINK FILE\n"
12190e8c7c07SAndrii Nakryiko " %1$s %2$s detach LINK\n"
1220c5481f9aSAndrii Nakryiko " %1$s %2$s help\n"
1221c5481f9aSAndrii Nakryiko "\n"
1222c5481f9aSAndrii Nakryiko " " HELP_SPEC_LINK "\n"
1223c07ba629SQuentin Monnet " " HELP_SPEC_OPTIONS " |\n"
1224c07ba629SQuentin Monnet " {-f|--bpffs} | {-n|--nomount} }\n"
1225c5481f9aSAndrii Nakryiko "",
1226c5481f9aSAndrii Nakryiko bin_name, argv[-2]);
1227c5481f9aSAndrii Nakryiko
1228c5481f9aSAndrii Nakryiko return 0;
1229c5481f9aSAndrii Nakryiko }
1230c5481f9aSAndrii Nakryiko
1231c5481f9aSAndrii Nakryiko static const struct cmd cmds[] = {
1232c5481f9aSAndrii Nakryiko { "show", do_show },
1233c5481f9aSAndrii Nakryiko { "list", do_show },
1234c5481f9aSAndrii Nakryiko { "help", do_help },
1235c5481f9aSAndrii Nakryiko { "pin", do_pin },
12360e8c7c07SAndrii Nakryiko { "detach", do_detach },
1237c5481f9aSAndrii Nakryiko { 0 }
1238c5481f9aSAndrii Nakryiko };
1239c5481f9aSAndrii Nakryiko
do_link(int argc,char ** argv)1240c5481f9aSAndrii Nakryiko int do_link(int argc, char **argv)
1241c5481f9aSAndrii Nakryiko {
1242c5481f9aSAndrii Nakryiko return cmd_select(cmds, argc, argv, do_help);
1243c5481f9aSAndrii Nakryiko }
1244