]>
Commit | Line | Data |
---|---|---|
6882804c AS |
1 | /* Copyright (c) 2017 Facebook |
2 | * | |
3 | * This program is free software; you can redistribute it and/or | |
4 | * modify it under the terms of version 2 of the GNU General Public | |
5 | * License as published by the Free Software Foundation. | |
6 | */ | |
7 | #include <stdio.h> | |
8 | #include <unistd.h> | |
9 | #include <errno.h> | |
10 | #include <string.h> | |
11 | #include <assert.h> | |
12 | #include <stdlib.h> | |
3a8ad560 | 13 | #include <time.h> |
6882804c AS |
14 | |
15 | #include <linux/types.h> | |
16 | typedef __u16 __sum16; | |
17 | #include <arpa/inet.h> | |
18 | #include <linux/if_ether.h> | |
19 | #include <linux/if_packet.h> | |
20 | #include <linux/ip.h> | |
21 | #include <linux/ipv6.h> | |
22 | #include <linux/tcp.h> | |
3a8ad560 MKL |
23 | #include <linux/filter.h> |
24 | #include <linux/unistd.h> | |
6882804c AS |
25 | |
26 | #include <sys/wait.h> | |
27 | #include <sys/resource.h> | |
95b9afd3 | 28 | #include <sys/types.h> |
fad07430 | 29 | #include <fcntl.h> |
6882804c AS |
30 | |
31 | #include <linux/bpf.h> | |
32 | #include <linux/err.h> | |
33 | #include <bpf/bpf.h> | |
34 | #include <bpf/libbpf.h> | |
8d48f5e4 | 35 | #include "test_iptunnel_common.h" |
37821613 | 36 | #include "bpf_util.h" |
e06422c4 | 37 | #include "bpf_endian.h" |
6882804c | 38 | |
6882804c AS |
39 | static int error_cnt, pass_cnt; |
40 | ||
37821613 AS |
41 | #define MAGIC_BYTES 123 |
42 | ||
6882804c AS |
43 | /* ipv4 test vector */ |
44 | static struct { | |
45 | struct ethhdr eth; | |
46 | struct iphdr iph; | |
47 | struct tcphdr tcp; | |
48 | } __packed pkt_v4 = { | |
43bcf707 | 49 | .eth.h_proto = bpf_htons(ETH_P_IP), |
6882804c AS |
50 | .iph.ihl = 5, |
51 | .iph.protocol = 6, | |
43bcf707 | 52 | .iph.tot_len = bpf_htons(MAGIC_BYTES), |
6882804c AS |
53 | .tcp.urg_ptr = 123, |
54 | }; | |
55 | ||
56 | /* ipv6 test vector */ | |
57 | static struct { | |
58 | struct ethhdr eth; | |
59 | struct ipv6hdr iph; | |
60 | struct tcphdr tcp; | |
61 | } __packed pkt_v6 = { | |
43bcf707 | 62 | .eth.h_proto = bpf_htons(ETH_P_IPV6), |
6882804c | 63 | .iph.nexthdr = 6, |
43bcf707 | 64 | .iph.payload_len = bpf_htons(MAGIC_BYTES), |
6882804c AS |
65 | .tcp.urg_ptr = 123, |
66 | }; | |
67 | ||
68 | #define CHECK(condition, tag, format...) ({ \ | |
69 | int __ret = !!(condition); \ | |
70 | if (__ret) { \ | |
71 | error_cnt++; \ | |
72 | printf("%s:FAIL:%s ", __func__, tag); \ | |
73 | printf(format); \ | |
74 | } else { \ | |
75 | pass_cnt++; \ | |
76 | printf("%s:PASS:%s %d nsec\n", __func__, tag, duration);\ | |
77 | } \ | |
95b9afd3 | 78 | __ret; \ |
6882804c AS |
79 | }) |
80 | ||
8d48f5e4 AS |
81 | static int bpf_find_map(const char *test, struct bpf_object *obj, |
82 | const char *name) | |
83 | { | |
84 | struct bpf_map *map; | |
85 | ||
86 | map = bpf_object__find_map_by_name(obj, name); | |
87 | if (!map) { | |
88 | printf("%s:FAIL:map '%s' not found\n", test, name); | |
89 | error_cnt++; | |
90 | return -1; | |
91 | } | |
92 | return bpf_map__fd(map); | |
93 | } | |
94 | ||
6882804c AS |
95 | static void test_pkt_access(void) |
96 | { | |
97 | const char *file = "./test_pkt_access.o"; | |
98 | struct bpf_object *obj; | |
99 | __u32 duration, retval; | |
100 | int err, prog_fd; | |
101 | ||
102 | err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); | |
6f6d33f3 JF |
103 | if (err) { |
104 | error_cnt++; | |
6882804c | 105 | return; |
6f6d33f3 | 106 | } |
6882804c AS |
107 | |
108 | err = bpf_prog_test_run(prog_fd, 100000, &pkt_v4, sizeof(pkt_v4), | |
109 | NULL, NULL, &retval, &duration); | |
110 | CHECK(err || errno || retval, "ipv4", | |
111 | "err %d errno %d retval %d duration %d\n", | |
112 | err, errno, retval, duration); | |
113 | ||
114 | err = bpf_prog_test_run(prog_fd, 100000, &pkt_v6, sizeof(pkt_v6), | |
115 | NULL, NULL, &retval, &duration); | |
116 | CHECK(err || errno || retval, "ipv6", | |
117 | "err %d errno %d retval %d duration %d\n", | |
118 | err, errno, retval, duration); | |
119 | bpf_object__close(obj); | |
120 | } | |
121 | ||
8d48f5e4 AS |
122 | static void test_xdp(void) |
123 | { | |
124 | struct vip key4 = {.protocol = 6, .family = AF_INET}; | |
125 | struct vip key6 = {.protocol = 6, .family = AF_INET6}; | |
126 | struct iptnl_info value4 = {.family = AF_INET}; | |
127 | struct iptnl_info value6 = {.family = AF_INET6}; | |
128 | const char *file = "./test_xdp.o"; | |
129 | struct bpf_object *obj; | |
130 | char buf[128]; | |
131 | struct ipv6hdr *iph6 = (void *)buf + sizeof(struct ethhdr); | |
132 | struct iphdr *iph = (void *)buf + sizeof(struct ethhdr); | |
133 | __u32 duration, retval, size; | |
134 | int err, prog_fd, map_fd; | |
135 | ||
136 | err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); | |
6f6d33f3 JF |
137 | if (err) { |
138 | error_cnt++; | |
8d48f5e4 | 139 | return; |
6f6d33f3 | 140 | } |
8d48f5e4 AS |
141 | |
142 | map_fd = bpf_find_map(__func__, obj, "vip2tnl"); | |
143 | if (map_fd < 0) | |
144 | goto out; | |
145 | bpf_map_update_elem(map_fd, &key4, &value4, 0); | |
146 | bpf_map_update_elem(map_fd, &key6, &value6, 0); | |
147 | ||
148 | err = bpf_prog_test_run(prog_fd, 1, &pkt_v4, sizeof(pkt_v4), | |
149 | buf, &size, &retval, &duration); | |
150 | ||
151 | CHECK(err || errno || retval != XDP_TX || size != 74 || | |
152 | iph->protocol != IPPROTO_IPIP, "ipv4", | |
153 | "err %d errno %d retval %d size %d\n", | |
154 | err, errno, retval, size); | |
155 | ||
156 | err = bpf_prog_test_run(prog_fd, 1, &pkt_v6, sizeof(pkt_v6), | |
157 | buf, &size, &retval, &duration); | |
158 | CHECK(err || errno || retval != XDP_TX || size != 114 || | |
159 | iph6->nexthdr != IPPROTO_IPV6, "ipv6", | |
160 | "err %d errno %d retval %d size %d\n", | |
161 | err, errno, retval, size); | |
162 | out: | |
163 | bpf_object__close(obj); | |
164 | } | |
165 | ||
37821613 AS |
166 | #define MAGIC_VAL 0x1234 |
167 | #define NUM_ITER 100000 | |
168 | #define VIP_NUM 5 | |
169 | ||
170 | static void test_l4lb(void) | |
171 | { | |
172 | unsigned int nr_cpus = bpf_num_possible_cpus(); | |
173 | const char *file = "./test_l4lb.o"; | |
174 | struct vip key = {.protocol = 6}; | |
175 | struct vip_meta { | |
176 | __u32 flags; | |
177 | __u32 vip_num; | |
178 | } value = {.vip_num = VIP_NUM}; | |
179 | __u32 stats_key = VIP_NUM; | |
180 | struct vip_stats { | |
181 | __u64 bytes; | |
182 | __u64 pkts; | |
183 | } stats[nr_cpus]; | |
184 | struct real_definition { | |
185 | union { | |
186 | __be32 dst; | |
187 | __be32 dstv6[4]; | |
188 | }; | |
189 | __u8 flags; | |
190 | } real_def = {.dst = MAGIC_VAL}; | |
191 | __u32 ch_key = 11, real_num = 3; | |
192 | __u32 duration, retval, size; | |
193 | int err, i, prog_fd, map_fd; | |
194 | __u64 bytes = 0, pkts = 0; | |
195 | struct bpf_object *obj; | |
196 | char buf[128]; | |
197 | u32 *magic = (u32 *)buf; | |
198 | ||
199 | err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); | |
6f6d33f3 JF |
200 | if (err) { |
201 | error_cnt++; | |
37821613 | 202 | return; |
6f6d33f3 | 203 | } |
37821613 AS |
204 | |
205 | map_fd = bpf_find_map(__func__, obj, "vip_map"); | |
206 | if (map_fd < 0) | |
207 | goto out; | |
208 | bpf_map_update_elem(map_fd, &key, &value, 0); | |
209 | ||
210 | map_fd = bpf_find_map(__func__, obj, "ch_rings"); | |
211 | if (map_fd < 0) | |
212 | goto out; | |
213 | bpf_map_update_elem(map_fd, &ch_key, &real_num, 0); | |
214 | ||
215 | map_fd = bpf_find_map(__func__, obj, "reals"); | |
216 | if (map_fd < 0) | |
217 | goto out; | |
218 | bpf_map_update_elem(map_fd, &real_num, &real_def, 0); | |
219 | ||
220 | err = bpf_prog_test_run(prog_fd, NUM_ITER, &pkt_v4, sizeof(pkt_v4), | |
221 | buf, &size, &retval, &duration); | |
222 | CHECK(err || errno || retval != 7/*TC_ACT_REDIRECT*/ || size != 54 || | |
223 | *magic != MAGIC_VAL, "ipv4", | |
224 | "err %d errno %d retval %d size %d magic %x\n", | |
225 | err, errno, retval, size, *magic); | |
226 | ||
227 | err = bpf_prog_test_run(prog_fd, NUM_ITER, &pkt_v6, sizeof(pkt_v6), | |
228 | buf, &size, &retval, &duration); | |
229 | CHECK(err || errno || retval != 7/*TC_ACT_REDIRECT*/ || size != 74 || | |
230 | *magic != MAGIC_VAL, "ipv6", | |
231 | "err %d errno %d retval %d size %d magic %x\n", | |
232 | err, errno, retval, size, *magic); | |
233 | ||
234 | map_fd = bpf_find_map(__func__, obj, "stats"); | |
235 | if (map_fd < 0) | |
236 | goto out; | |
237 | bpf_map_lookup_elem(map_fd, &stats_key, stats); | |
238 | for (i = 0; i < nr_cpus; i++) { | |
239 | bytes += stats[i].bytes; | |
240 | pkts += stats[i].pkts; | |
241 | } | |
242 | if (bytes != MAGIC_BYTES * NUM_ITER * 2 || pkts != NUM_ITER * 2) { | |
243 | error_cnt++; | |
244 | printf("test_l4lb:FAIL:stats %lld %lld\n", bytes, pkts); | |
245 | } | |
246 | out: | |
247 | bpf_object__close(obj); | |
248 | } | |
249 | ||
6ead18fb YS |
250 | static void test_tcp_estats(void) |
251 | { | |
252 | const char *file = "./test_tcp_estats.o"; | |
253 | int err, prog_fd; | |
254 | struct bpf_object *obj; | |
255 | __u32 duration = 0; | |
256 | ||
257 | err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); | |
258 | CHECK(err, "", "err %d errno %d\n", err, errno); | |
6f6d33f3 JF |
259 | if (err) { |
260 | error_cnt++; | |
6ead18fb | 261 | return; |
6f6d33f3 | 262 | } |
6ead18fb YS |
263 | |
264 | bpf_object__close(obj); | |
265 | } | |
266 | ||
95b9afd3 MKL |
267 | static inline __u64 ptr_to_u64(const void *ptr) |
268 | { | |
269 | return (__u64) (unsigned long) ptr; | |
270 | } | |
271 | ||
272 | static void test_bpf_obj_id(void) | |
273 | { | |
274 | const __u64 array_magic_value = 0xfaceb00c; | |
275 | const __u32 array_key = 0; | |
276 | const int nr_iters = 2; | |
277 | const char *file = "./test_obj_id.o"; | |
fad07430 | 278 | const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable"; |
3a8ad560 MKL |
279 | const char *expected_prog_name = "test_obj_id"; |
280 | const char *expected_map_name = "test_map_id"; | |
281 | const __u64 nsec_per_sec = 1000000000; | |
95b9afd3 MKL |
282 | |
283 | struct bpf_object *objs[nr_iters]; | |
284 | int prog_fds[nr_iters], map_fds[nr_iters]; | |
285 | /* +1 to test for the info_len returned by kernel */ | |
286 | struct bpf_prog_info prog_infos[nr_iters + 1]; | |
287 | struct bpf_map_info map_infos[nr_iters + 1]; | |
3a8ad560 MKL |
288 | /* Each prog only uses one map. +1 to test nr_map_ids |
289 | * returned by kernel. | |
290 | */ | |
291 | __u32 map_ids[nr_iters + 1]; | |
7cadf2cb | 292 | char jited_insns[128], xlated_insns[128], zeros[128]; |
95b9afd3 | 293 | __u32 i, next_id, info_len, nr_id_found, duration = 0; |
3a8ad560 | 294 | struct timespec real_time_ts, boot_time_ts; |
fad07430 | 295 | int sysctl_fd, jit_enabled = 0, err = 0; |
95b9afd3 | 296 | __u64 array_value; |
3a8ad560 MKL |
297 | uid_t my_uid = getuid(); |
298 | time_t now, load_time; | |
95b9afd3 | 299 | |
fad07430 MKL |
300 | sysctl_fd = open(jit_sysctl, 0, O_RDONLY); |
301 | if (sysctl_fd != -1) { | |
302 | char tmpc; | |
303 | ||
304 | if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1) | |
305 | jit_enabled = (tmpc != '0'); | |
306 | close(sysctl_fd); | |
307 | } | |
308 | ||
95b9afd3 MKL |
309 | err = bpf_prog_get_fd_by_id(0); |
310 | CHECK(err >= 0 || errno != ENOENT, | |
311 | "get-fd-by-notexist-prog-id", "err %d errno %d\n", err, errno); | |
312 | ||
313 | err = bpf_map_get_fd_by_id(0); | |
314 | CHECK(err >= 0 || errno != ENOENT, | |
315 | "get-fd-by-notexist-map-id", "err %d errno %d\n", err, errno); | |
316 | ||
317 | for (i = 0; i < nr_iters; i++) | |
318 | objs[i] = NULL; | |
319 | ||
320 | /* Check bpf_obj_get_info_by_fd() */ | |
7cadf2cb | 321 | bzero(zeros, sizeof(zeros)); |
95b9afd3 | 322 | for (i = 0; i < nr_iters; i++) { |
3a8ad560 | 323 | now = time(NULL); |
95b9afd3 MKL |
324 | err = bpf_prog_load(file, BPF_PROG_TYPE_SOCKET_FILTER, |
325 | &objs[i], &prog_fds[i]); | |
326 | /* test_obj_id.o is a dumb prog. It should never fail | |
327 | * to load. | |
328 | */ | |
6f6d33f3 JF |
329 | if (err) |
330 | error_cnt++; | |
95b9afd3 MKL |
331 | assert(!err); |
332 | ||
6e525d06 MKL |
333 | /* Insert a magic value to the map */ |
334 | map_fds[i] = bpf_find_map(__func__, objs[i], "test_map_id"); | |
335 | assert(map_fds[i] >= 0); | |
336 | err = bpf_map_update_elem(map_fds[i], &array_key, | |
337 | &array_magic_value, 0); | |
338 | assert(!err); | |
339 | ||
340 | /* Check getting map info */ | |
341 | info_len = sizeof(struct bpf_map_info) * 2; | |
342 | bzero(&map_infos[i], info_len); | |
343 | err = bpf_obj_get_info_by_fd(map_fds[i], &map_infos[i], | |
344 | &info_len); | |
345 | if (CHECK(err || | |
346 | map_infos[i].type != BPF_MAP_TYPE_ARRAY || | |
347 | map_infos[i].key_size != sizeof(__u32) || | |
348 | map_infos[i].value_size != sizeof(__u64) || | |
349 | map_infos[i].max_entries != 1 || | |
350 | map_infos[i].map_flags != 0 || | |
3a8ad560 MKL |
351 | info_len != sizeof(struct bpf_map_info) || |
352 | strcmp((char *)map_infos[i].name, expected_map_name), | |
6e525d06 | 353 | "get-map-info(fd)", |
19c832ed | 354 | "err %d errno %d type %d(%d) info_len %u(%Zu) key_size %u value_size %u max_entries %u map_flags %X name %s(%s)\n", |
6e525d06 MKL |
355 | err, errno, |
356 | map_infos[i].type, BPF_MAP_TYPE_ARRAY, | |
357 | info_len, sizeof(struct bpf_map_info), | |
358 | map_infos[i].key_size, | |
359 | map_infos[i].value_size, | |
360 | map_infos[i].max_entries, | |
3a8ad560 MKL |
361 | map_infos[i].map_flags, |
362 | map_infos[i].name, expected_map_name)) | |
6e525d06 MKL |
363 | goto done; |
364 | ||
95b9afd3 MKL |
365 | /* Check getting prog info */ |
366 | info_len = sizeof(struct bpf_prog_info) * 2; | |
d777b2dd | 367 | bzero(&prog_infos[i], info_len); |
7cadf2cb JK |
368 | bzero(jited_insns, sizeof(jited_insns)); |
369 | bzero(xlated_insns, sizeof(xlated_insns)); | |
95b9afd3 MKL |
370 | prog_infos[i].jited_prog_insns = ptr_to_u64(jited_insns); |
371 | prog_infos[i].jited_prog_len = sizeof(jited_insns); | |
372 | prog_infos[i].xlated_prog_insns = ptr_to_u64(xlated_insns); | |
373 | prog_infos[i].xlated_prog_len = sizeof(xlated_insns); | |
3a8ad560 MKL |
374 | prog_infos[i].map_ids = ptr_to_u64(map_ids + i); |
375 | prog_infos[i].nr_map_ids = 2; | |
376 | err = clock_gettime(CLOCK_REALTIME, &real_time_ts); | |
377 | assert(!err); | |
378 | err = clock_gettime(CLOCK_BOOTTIME, &boot_time_ts); | |
379 | assert(!err); | |
95b9afd3 MKL |
380 | err = bpf_obj_get_info_by_fd(prog_fds[i], &prog_infos[i], |
381 | &info_len); | |
3a8ad560 MKL |
382 | load_time = (real_time_ts.tv_sec - boot_time_ts.tv_sec) |
383 | + (prog_infos[i].load_time / nsec_per_sec); | |
95b9afd3 MKL |
384 | if (CHECK(err || |
385 | prog_infos[i].type != BPF_PROG_TYPE_SOCKET_FILTER || | |
386 | info_len != sizeof(struct bpf_prog_info) || | |
fad07430 | 387 | (jit_enabled && !prog_infos[i].jited_prog_len) || |
7cadf2cb JK |
388 | (jit_enabled && |
389 | !memcmp(jited_insns, zeros, sizeof(zeros))) || | |
390 | !prog_infos[i].xlated_prog_len || | |
3a8ad560 MKL |
391 | !memcmp(xlated_insns, zeros, sizeof(zeros)) || |
392 | load_time < now - 60 || load_time > now + 60 || | |
393 | prog_infos[i].created_by_uid != my_uid || | |
394 | prog_infos[i].nr_map_ids != 1 || | |
395 | *(int *)prog_infos[i].map_ids != map_infos[i].id || | |
396 | strcmp((char *)prog_infos[i].name, expected_prog_name), | |
95b9afd3 | 397 | "get-prog-info(fd)", |
19c832ed | 398 | "err %d errno %d i %d type %d(%d) info_len %u(%Zu) jit_enabled %d jited_prog_len %u xlated_prog_len %u jited_prog %d xlated_prog %d load_time %lu(%lu) uid %u(%u) nr_map_ids %u(%u) map_id %u(%u) name %s(%s)\n", |
95b9afd3 MKL |
399 | err, errno, i, |
400 | prog_infos[i].type, BPF_PROG_TYPE_SOCKET_FILTER, | |
401 | info_len, sizeof(struct bpf_prog_info), | |
fad07430 | 402 | jit_enabled, |
95b9afd3 | 403 | prog_infos[i].jited_prog_len, |
7cadf2cb JK |
404 | prog_infos[i].xlated_prog_len, |
405 | !!memcmp(jited_insns, zeros, sizeof(zeros)), | |
3a8ad560 MKL |
406 | !!memcmp(xlated_insns, zeros, sizeof(zeros)), |
407 | load_time, now, | |
408 | prog_infos[i].created_by_uid, my_uid, | |
409 | prog_infos[i].nr_map_ids, 1, | |
410 | *(int *)prog_infos[i].map_ids, map_infos[i].id, | |
411 | prog_infos[i].name, expected_prog_name)) | |
95b9afd3 | 412 | goto done; |
95b9afd3 MKL |
413 | } |
414 | ||
415 | /* Check bpf_prog_get_next_id() */ | |
416 | nr_id_found = 0; | |
417 | next_id = 0; | |
418 | while (!bpf_prog_get_next_id(next_id, &next_id)) { | |
d777b2dd | 419 | struct bpf_prog_info prog_info = {}; |
3a8ad560 | 420 | __u32 saved_map_id; |
95b9afd3 MKL |
421 | int prog_fd; |
422 | ||
423 | info_len = sizeof(prog_info); | |
424 | ||
425 | prog_fd = bpf_prog_get_fd_by_id(next_id); | |
426 | if (prog_fd < 0 && errno == ENOENT) | |
427 | /* The bpf_prog is in the dead row */ | |
428 | continue; | |
429 | if (CHECK(prog_fd < 0, "get-prog-fd(next_id)", | |
430 | "prog_fd %d next_id %d errno %d\n", | |
431 | prog_fd, next_id, errno)) | |
432 | break; | |
433 | ||
434 | for (i = 0; i < nr_iters; i++) | |
435 | if (prog_infos[i].id == next_id) | |
436 | break; | |
437 | ||
438 | if (i == nr_iters) | |
439 | continue; | |
440 | ||
441 | nr_id_found++; | |
442 | ||
3a8ad560 MKL |
443 | /* Negative test: |
444 | * prog_info.nr_map_ids = 1 | |
445 | * prog_info.map_ids = NULL | |
446 | */ | |
447 | prog_info.nr_map_ids = 1; | |
448 | err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len); | |
449 | if (CHECK(!err || errno != EFAULT, | |
450 | "get-prog-fd-bad-nr-map-ids", "err %d errno %d(%d)", | |
451 | err, errno, EFAULT)) | |
452 | break; | |
453 | bzero(&prog_info, sizeof(prog_info)); | |
454 | info_len = sizeof(prog_info); | |
455 | ||
456 | saved_map_id = *(int *)(prog_infos[i].map_ids); | |
457 | prog_info.map_ids = prog_infos[i].map_ids; | |
458 | prog_info.nr_map_ids = 2; | |
95b9afd3 | 459 | err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len); |
d777b2dd JK |
460 | prog_infos[i].jited_prog_insns = 0; |
461 | prog_infos[i].xlated_prog_insns = 0; | |
95b9afd3 | 462 | CHECK(err || info_len != sizeof(struct bpf_prog_info) || |
3a8ad560 MKL |
463 | memcmp(&prog_info, &prog_infos[i], info_len) || |
464 | *(int *)prog_info.map_ids != saved_map_id, | |
95b9afd3 | 465 | "get-prog-info(next_id->fd)", |
19c832ed | 466 | "err %d errno %d info_len %u(%Zu) memcmp %d map_id %u(%u)\n", |
95b9afd3 | 467 | err, errno, info_len, sizeof(struct bpf_prog_info), |
3a8ad560 MKL |
468 | memcmp(&prog_info, &prog_infos[i], info_len), |
469 | *(int *)prog_info.map_ids, saved_map_id); | |
95b9afd3 MKL |
470 | close(prog_fd); |
471 | } | |
472 | CHECK(nr_id_found != nr_iters, | |
473 | "check total prog id found by get_next_id", | |
474 | "nr_id_found %u(%u)\n", | |
475 | nr_id_found, nr_iters); | |
476 | ||
477 | /* Check bpf_map_get_next_id() */ | |
478 | nr_id_found = 0; | |
479 | next_id = 0; | |
480 | while (!bpf_map_get_next_id(next_id, &next_id)) { | |
d777b2dd | 481 | struct bpf_map_info map_info = {}; |
95b9afd3 MKL |
482 | int map_fd; |
483 | ||
484 | info_len = sizeof(map_info); | |
485 | ||
486 | map_fd = bpf_map_get_fd_by_id(next_id); | |
487 | if (map_fd < 0 && errno == ENOENT) | |
488 | /* The bpf_map is in the dead row */ | |
489 | continue; | |
490 | if (CHECK(map_fd < 0, "get-map-fd(next_id)", | |
491 | "map_fd %d next_id %u errno %d\n", | |
492 | map_fd, next_id, errno)) | |
493 | break; | |
494 | ||
495 | for (i = 0; i < nr_iters; i++) | |
496 | if (map_infos[i].id == next_id) | |
497 | break; | |
498 | ||
499 | if (i == nr_iters) | |
500 | continue; | |
501 | ||
502 | nr_id_found++; | |
503 | ||
504 | err = bpf_map_lookup_elem(map_fd, &array_key, &array_value); | |
505 | assert(!err); | |
506 | ||
507 | err = bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len); | |
508 | CHECK(err || info_len != sizeof(struct bpf_map_info) || | |
509 | memcmp(&map_info, &map_infos[i], info_len) || | |
510 | array_value != array_magic_value, | |
511 | "check get-map-info(next_id->fd)", | |
19c832ed | 512 | "err %d errno %d info_len %u(%Zu) memcmp %d array_value %llu(%llu)\n", |
95b9afd3 MKL |
513 | err, errno, info_len, sizeof(struct bpf_map_info), |
514 | memcmp(&map_info, &map_infos[i], info_len), | |
515 | array_value, array_magic_value); | |
516 | ||
517 | close(map_fd); | |
518 | } | |
519 | CHECK(nr_id_found != nr_iters, | |
520 | "check total map id found by get_next_id", | |
521 | "nr_id_found %u(%u)\n", | |
522 | nr_id_found, nr_iters); | |
523 | ||
524 | done: | |
525 | for (i = 0; i < nr_iters; i++) | |
526 | bpf_object__close(objs[i]); | |
527 | } | |
528 | ||
18f3d6be YS |
529 | static void test_pkt_md_access(void) |
530 | { | |
531 | const char *file = "./test_pkt_md_access.o"; | |
532 | struct bpf_object *obj; | |
533 | __u32 duration, retval; | |
534 | int err, prog_fd; | |
535 | ||
536 | err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); | |
6f6d33f3 JF |
537 | if (err) { |
538 | error_cnt++; | |
18f3d6be | 539 | return; |
6f6d33f3 | 540 | } |
18f3d6be YS |
541 | |
542 | err = bpf_prog_test_run(prog_fd, 10, &pkt_v4, sizeof(pkt_v4), | |
543 | NULL, NULL, &retval, &duration); | |
544 | CHECK(err || retval, "", | |
545 | "err %d errno %d retval %d duration %d\n", | |
546 | err, errno, retval, duration); | |
547 | ||
548 | bpf_object__close(obj); | |
549 | } | |
550 | ||
3a8ad560 MKL |
551 | static void test_obj_name(void) |
552 | { | |
553 | struct { | |
554 | const char *name; | |
555 | int success; | |
556 | int expected_errno; | |
557 | } tests[] = { | |
558 | { "", 1, 0 }, | |
559 | { "_123456789ABCDE", 1, 0 }, | |
560 | { "_123456789ABCDEF", 0, EINVAL }, | |
561 | { "_123456789ABCD\n", 0, EINVAL }, | |
562 | }; | |
563 | struct bpf_insn prog[] = { | |
564 | BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 0), | |
565 | BPF_EXIT_INSN(), | |
566 | }; | |
567 | __u32 duration = 0; | |
568 | int i; | |
569 | ||
570 | for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { | |
571 | size_t name_len = strlen(tests[i].name) + 1; | |
572 | union bpf_attr attr; | |
573 | size_t ncopy; | |
574 | int fd; | |
575 | ||
576 | /* test different attr.prog_name during BPF_PROG_LOAD */ | |
577 | ncopy = name_len < sizeof(attr.prog_name) ? | |
578 | name_len : sizeof(attr.prog_name); | |
579 | bzero(&attr, sizeof(attr)); | |
580 | attr.prog_type = BPF_PROG_TYPE_SCHED_CLS; | |
581 | attr.insn_cnt = 2; | |
582 | attr.insns = ptr_to_u64(prog); | |
583 | attr.license = ptr_to_u64(""); | |
584 | memcpy(attr.prog_name, tests[i].name, ncopy); | |
585 | ||
586 | fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); | |
587 | CHECK((tests[i].success && fd < 0) || | |
588 | (!tests[i].success && fd != -1) || | |
589 | (!tests[i].success && errno != tests[i].expected_errno), | |
590 | "check-bpf-prog-name", | |
591 | "fd %d(%d) errno %d(%d)\n", | |
592 | fd, tests[i].success, errno, tests[i].expected_errno); | |
593 | ||
594 | if (fd != -1) | |
595 | close(fd); | |
596 | ||
597 | /* test different attr.map_name during BPF_MAP_CREATE */ | |
598 | ncopy = name_len < sizeof(attr.map_name) ? | |
599 | name_len : sizeof(attr.map_name); | |
600 | bzero(&attr, sizeof(attr)); | |
601 | attr.map_type = BPF_MAP_TYPE_ARRAY; | |
602 | attr.key_size = 4; | |
603 | attr.value_size = 4; | |
604 | attr.max_entries = 1; | |
605 | attr.map_flags = 0; | |
606 | memcpy(attr.map_name, tests[i].name, ncopy); | |
607 | fd = syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr)); | |
608 | CHECK((tests[i].success && fd < 0) || | |
609 | (!tests[i].success && fd != -1) || | |
610 | (!tests[i].success && errno != tests[i].expected_errno), | |
611 | "check-bpf-map-name", | |
612 | "fd %d(%d) errno %d(%d)\n", | |
613 | fd, tests[i].success, errno, tests[i].expected_errno); | |
614 | ||
615 | if (fd != -1) | |
616 | close(fd); | |
617 | } | |
618 | } | |
619 | ||
6882804c AS |
620 | int main(void) |
621 | { | |
622 | struct rlimit rinf = { RLIM_INFINITY, RLIM_INFINITY }; | |
623 | ||
624 | setrlimit(RLIMIT_MEMLOCK, &rinf); | |
625 | ||
626 | test_pkt_access(); | |
8d48f5e4 | 627 | test_xdp(); |
37821613 | 628 | test_l4lb(); |
6ead18fb | 629 | test_tcp_estats(); |
95b9afd3 | 630 | test_bpf_obj_id(); |
18f3d6be | 631 | test_pkt_md_access(); |
3a8ad560 | 632 | test_obj_name(); |
6882804c AS |
633 | |
634 | printf("Summary: %d PASSED, %d FAILED\n", pass_cnt, error_cnt); | |
efe5f9c0 | 635 | return error_cnt ? EXIT_FAILURE : EXIT_SUCCESS; |
6882804c | 636 | } |