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