]>
Commit | Line | Data |
---|---|---|
1bf4b058 QM |
1 | // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) |
2 | /* Copyright (c) 2019 Netronome Systems, Inc. */ | |
3 | ||
4 | #include <errno.h> | |
2d3ea5e8 QM |
5 | #include <fcntl.h> |
6 | #include <string.h> | |
7 | #include <stdlib.h> | |
1bf4b058 | 8 | #include <unistd.h> |
2d3ea5e8 | 9 | #include <net/if.h> |
1bf4b058 QM |
10 | #include <sys/utsname.h> |
11 | ||
a19f89f3 | 12 | #include <linux/btf.h> |
1bf4b058 QM |
13 | #include <linux/filter.h> |
14 | #include <linux/kernel.h> | |
15 | ||
16 | #include "bpf.h" | |
17 | #include "libbpf.h" | |
d7c4b398 | 18 | #include "libbpf_internal.h" |
1bf4b058 | 19 | |
2d3ea5e8 QM |
20 | static bool grep(const char *buffer, const char *pattern) |
21 | { | |
22 | return !!strstr(buffer, pattern); | |
23 | } | |
24 | ||
25 | static int get_vendor_id(int ifindex) | |
26 | { | |
27 | char ifname[IF_NAMESIZE], path[64], buf[8]; | |
28 | ssize_t len; | |
29 | int fd; | |
30 | ||
31 | if (!if_indextoname(ifindex, ifname)) | |
32 | return -1; | |
33 | ||
34 | snprintf(path, sizeof(path), "/sys/class/net/%s/device/vendor", ifname); | |
35 | ||
36 | fd = open(path, O_RDONLY); | |
37 | if (fd < 0) | |
38 | return -1; | |
39 | ||
40 | len = read(fd, buf, sizeof(buf)); | |
41 | close(fd); | |
42 | if (len < 0) | |
43 | return -1; | |
44 | if (len >= (ssize_t)sizeof(buf)) | |
45 | return -1; | |
46 | buf[len] = '\0'; | |
47 | ||
48 | return strtol(buf, NULL, 0); | |
49 | } | |
50 | ||
1bf4b058 QM |
51 | static int get_kernel_version(void) |
52 | { | |
53 | int version, subversion, patchlevel; | |
54 | struct utsname utsn; | |
55 | ||
56 | /* Return 0 on failure, and attempt to probe with empty kversion */ | |
57 | if (uname(&utsn)) | |
58 | return 0; | |
59 | ||
60 | if (sscanf(utsn.release, "%d.%d.%d", | |
61 | &version, &subversion, &patchlevel) != 3) | |
62 | return 0; | |
63 | ||
64 | return (version << 16) + (subversion << 8) + patchlevel; | |
65 | } | |
66 | ||
67 | static void | |
68 | probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, | |
69 | size_t insns_cnt, char *buf, size_t buf_len, __u32 ifindex) | |
70 | { | |
71 | struct bpf_load_program_attr xattr = {}; | |
72 | int fd; | |
73 | ||
74 | switch (prog_type) { | |
75 | case BPF_PROG_TYPE_CGROUP_SOCK_ADDR: | |
76 | xattr.expected_attach_type = BPF_CGROUP_INET4_CONNECT; | |
77 | break; | |
78 | case BPF_PROG_TYPE_KPROBE: | |
79 | xattr.kern_version = get_kernel_version(); | |
80 | break; | |
81 | case BPF_PROG_TYPE_UNSPEC: | |
82 | case BPF_PROG_TYPE_SOCKET_FILTER: | |
83 | case BPF_PROG_TYPE_SCHED_CLS: | |
84 | case BPF_PROG_TYPE_SCHED_ACT: | |
85 | case BPF_PROG_TYPE_TRACEPOINT: | |
86 | case BPF_PROG_TYPE_XDP: | |
87 | case BPF_PROG_TYPE_PERF_EVENT: | |
88 | case BPF_PROG_TYPE_CGROUP_SKB: | |
89 | case BPF_PROG_TYPE_CGROUP_SOCK: | |
90 | case BPF_PROG_TYPE_LWT_IN: | |
91 | case BPF_PROG_TYPE_LWT_OUT: | |
92 | case BPF_PROG_TYPE_LWT_XMIT: | |
93 | case BPF_PROG_TYPE_SOCK_OPS: | |
94 | case BPF_PROG_TYPE_SK_SKB: | |
95 | case BPF_PROG_TYPE_CGROUP_DEVICE: | |
96 | case BPF_PROG_TYPE_SK_MSG: | |
97 | case BPF_PROG_TYPE_RAW_TRACEPOINT: | |
4635b0ae | 98 | case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE: |
1bf4b058 QM |
99 | case BPF_PROG_TYPE_LWT_SEG6LOCAL: |
100 | case BPF_PROG_TYPE_LIRC_MODE2: | |
101 | case BPF_PROG_TYPE_SK_REUSEPORT: | |
102 | case BPF_PROG_TYPE_FLOW_DISSECTOR: | |
063cc9f0 | 103 | case BPF_PROG_TYPE_CGROUP_SYSCTL: |
1bf4b058 QM |
104 | default: |
105 | break; | |
106 | } | |
107 | ||
108 | xattr.prog_type = prog_type; | |
109 | xattr.insns = insns; | |
110 | xattr.insns_cnt = insns_cnt; | |
111 | xattr.license = "GPL"; | |
112 | xattr.prog_ifindex = ifindex; | |
113 | ||
114 | fd = bpf_load_program_xattr(&xattr, buf, buf_len); | |
115 | if (fd >= 0) | |
116 | close(fd); | |
117 | } | |
118 | ||
119 | bool bpf_probe_prog_type(enum bpf_prog_type prog_type, __u32 ifindex) | |
120 | { | |
121 | struct bpf_insn insns[2] = { | |
122 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
123 | BPF_EXIT_INSN() | |
124 | }; | |
125 | ||
126 | if (ifindex && prog_type == BPF_PROG_TYPE_SCHED_CLS) | |
127 | /* nfp returns -EINVAL on exit(0) with TC offload */ | |
128 | insns[0].imm = 2; | |
129 | ||
130 | errno = 0; | |
131 | probe_load(prog_type, insns, ARRAY_SIZE(insns), NULL, 0, ifindex); | |
132 | ||
133 | return errno != EINVAL && errno != EOPNOTSUPP; | |
134 | } | |
f99e1663 | 135 | |
cfd49210 MR |
136 | int libbpf__load_raw_btf(const char *raw_types, size_t types_len, |
137 | const char *str_sec, size_t str_len) | |
a19f89f3 | 138 | { |
d7c4b398 AN |
139 | struct btf_header hdr = { |
140 | .magic = BTF_MAGIC, | |
141 | .version = BTF_VERSION, | |
142 | .hdr_len = sizeof(struct btf_header), | |
143 | .type_len = types_len, | |
144 | .str_off = types_len, | |
145 | .str_len = str_len, | |
146 | }; | |
147 | int btf_fd, btf_len; | |
148 | __u8 *raw_btf; | |
149 | ||
150 | btf_len = hdr.hdr_len + hdr.type_len + hdr.str_len; | |
151 | raw_btf = malloc(btf_len); | |
152 | if (!raw_btf) | |
153 | return -ENOMEM; | |
154 | ||
155 | memcpy(raw_btf, &hdr, sizeof(hdr)); | |
156 | memcpy(raw_btf + hdr.hdr_len, raw_types, hdr.type_len); | |
157 | memcpy(raw_btf + hdr.hdr_len + hdr.type_len, str_sec, hdr.str_len); | |
158 | ||
159 | btf_fd = bpf_load_btf(raw_btf, btf_len, NULL, 0, false); | |
d7c4b398 | 160 | |
d7c4b398 | 161 | free(raw_btf); |
cfd49210 | 162 | return btf_fd; |
d7c4b398 AN |
163 | } |
164 | ||
165 | static int load_sk_storage_btf(void) | |
166 | { | |
167 | const char strs[] = "\0bpf_spin_lock\0val\0cnt\0l"; | |
a19f89f3 MKL |
168 | /* struct bpf_spin_lock { |
169 | * int val; | |
170 | * }; | |
171 | * struct val { | |
172 | * int cnt; | |
173 | * struct bpf_spin_lock l; | |
174 | * }; | |
175 | */ | |
d7c4b398 | 176 | __u32 types[] = { |
a19f89f3 MKL |
177 | /* int */ |
178 | BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */ | |
179 | /* struct bpf_spin_lock */ /* [2] */ | |
180 | BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4), | |
181 | BTF_MEMBER_ENC(15, 1, 0), /* int val; */ | |
182 | /* struct val */ /* [3] */ | |
183 | BTF_TYPE_ENC(15, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8), | |
184 | BTF_MEMBER_ENC(19, 1, 0), /* int cnt; */ | |
185 | BTF_MEMBER_ENC(23, 2, 32),/* struct bpf_spin_lock l; */ | |
186 | }; | |
a19f89f3 | 187 | |
cfd49210 | 188 | return libbpf__load_raw_btf((char *)types, sizeof(types), |
d7c4b398 | 189 | strs, sizeof(strs)); |
a19f89f3 MKL |
190 | } |
191 | ||
f99e1663 QM |
192 | bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) |
193 | { | |
194 | int key_size, value_size, max_entries, map_flags; | |
a19f89f3 | 195 | __u32 btf_key_type_id = 0, btf_value_type_id = 0; |
f99e1663 | 196 | struct bpf_create_map_attr attr = {}; |
a19f89f3 | 197 | int fd = -1, btf_fd = -1, fd_inner; |
f99e1663 QM |
198 | |
199 | key_size = sizeof(__u32); | |
200 | value_size = sizeof(__u32); | |
201 | max_entries = 1; | |
202 | map_flags = 0; | |
203 | ||
204 | switch (map_type) { | |
205 | case BPF_MAP_TYPE_STACK_TRACE: | |
206 | value_size = sizeof(__u64); | |
207 | break; | |
208 | case BPF_MAP_TYPE_LPM_TRIE: | |
209 | key_size = sizeof(__u64); | |
210 | value_size = sizeof(__u64); | |
211 | map_flags = BPF_F_NO_PREALLOC; | |
212 | break; | |
213 | case BPF_MAP_TYPE_CGROUP_STORAGE: | |
214 | case BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE: | |
215 | key_size = sizeof(struct bpf_cgroup_storage_key); | |
216 | value_size = sizeof(__u64); | |
217 | max_entries = 0; | |
218 | break; | |
219 | case BPF_MAP_TYPE_QUEUE: | |
220 | case BPF_MAP_TYPE_STACK: | |
221 | key_size = 0; | |
222 | break; | |
a19f89f3 MKL |
223 | case BPF_MAP_TYPE_SK_STORAGE: |
224 | btf_key_type_id = 1; | |
225 | btf_value_type_id = 3; | |
226 | value_size = 8; | |
227 | max_entries = 0; | |
228 | map_flags = BPF_F_NO_PREALLOC; | |
d7c4b398 | 229 | btf_fd = load_sk_storage_btf(); |
a19f89f3 MKL |
230 | if (btf_fd < 0) |
231 | return false; | |
232 | break; | |
f99e1663 QM |
233 | case BPF_MAP_TYPE_UNSPEC: |
234 | case BPF_MAP_TYPE_HASH: | |
235 | case BPF_MAP_TYPE_ARRAY: | |
236 | case BPF_MAP_TYPE_PROG_ARRAY: | |
237 | case BPF_MAP_TYPE_PERF_EVENT_ARRAY: | |
238 | case BPF_MAP_TYPE_PERCPU_HASH: | |
239 | case BPF_MAP_TYPE_PERCPU_ARRAY: | |
240 | case BPF_MAP_TYPE_CGROUP_ARRAY: | |
241 | case BPF_MAP_TYPE_LRU_HASH: | |
242 | case BPF_MAP_TYPE_LRU_PERCPU_HASH: | |
243 | case BPF_MAP_TYPE_ARRAY_OF_MAPS: | |
244 | case BPF_MAP_TYPE_HASH_OF_MAPS: | |
245 | case BPF_MAP_TYPE_DEVMAP: | |
246 | case BPF_MAP_TYPE_SOCKMAP: | |
247 | case BPF_MAP_TYPE_CPUMAP: | |
248 | case BPF_MAP_TYPE_XSKMAP: | |
249 | case BPF_MAP_TYPE_SOCKHASH: | |
250 | case BPF_MAP_TYPE_REUSEPORT_SOCKARRAY: | |
251 | default: | |
252 | break; | |
253 | } | |
254 | ||
255 | if (map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS || | |
256 | map_type == BPF_MAP_TYPE_HASH_OF_MAPS) { | |
257 | /* TODO: probe for device, once libbpf has a function to create | |
258 | * map-in-map for offload | |
259 | */ | |
260 | if (ifindex) | |
261 | return false; | |
262 | ||
263 | fd_inner = bpf_create_map(BPF_MAP_TYPE_HASH, | |
264 | sizeof(__u32), sizeof(__u32), 1, 0); | |
265 | if (fd_inner < 0) | |
266 | return false; | |
267 | fd = bpf_create_map_in_map(map_type, NULL, sizeof(__u32), | |
268 | fd_inner, 1, 0); | |
269 | close(fd_inner); | |
270 | } else { | |
271 | /* Note: No other restriction on map type probes for offload */ | |
272 | attr.map_type = map_type; | |
273 | attr.key_size = key_size; | |
274 | attr.value_size = value_size; | |
275 | attr.max_entries = max_entries; | |
276 | attr.map_flags = map_flags; | |
277 | attr.map_ifindex = ifindex; | |
a19f89f3 MKL |
278 | if (btf_fd >= 0) { |
279 | attr.btf_fd = btf_fd; | |
280 | attr.btf_key_type_id = btf_key_type_id; | |
281 | attr.btf_value_type_id = btf_value_type_id; | |
282 | } | |
f99e1663 QM |
283 | |
284 | fd = bpf_create_map_xattr(&attr); | |
285 | } | |
286 | if (fd >= 0) | |
287 | close(fd); | |
a19f89f3 MKL |
288 | if (btf_fd >= 0) |
289 | close(btf_fd); | |
f99e1663 QM |
290 | |
291 | return fd >= 0; | |
292 | } | |
2d3ea5e8 QM |
293 | |
294 | bool bpf_probe_helper(enum bpf_func_id id, enum bpf_prog_type prog_type, | |
295 | __u32 ifindex) | |
296 | { | |
297 | struct bpf_insn insns[2] = { | |
298 | BPF_EMIT_CALL(id), | |
299 | BPF_EXIT_INSN() | |
300 | }; | |
301 | char buf[4096] = {}; | |
302 | bool res; | |
303 | ||
304 | probe_load(prog_type, insns, ARRAY_SIZE(insns), buf, sizeof(buf), | |
305 | ifindex); | |
306 | res = !grep(buf, "invalid func ") && !grep(buf, "unknown func "); | |
307 | ||
308 | if (ifindex) { | |
309 | switch (get_vendor_id(ifindex)) { | |
310 | case 0x19ee: /* Netronome specific */ | |
311 | res = res && !grep(buf, "not supported by FW") && | |
312 | !grep(buf, "unsupported function id"); | |
313 | break; | |
314 | default: | |
315 | break; | |
316 | } | |
317 | } | |
318 | ||
319 | return res; | |
320 | } |