1
2
3
4
5
6
7
8
9#include <stdio.h>
10#include <unistd.h>
11#include <errno.h>
12#include <string.h>
13#include <assert.h>
14#include <stdlib.h>
15#include <time.h>
16
17#include <sys/wait.h>
18#include <sys/socket.h>
19#include <netinet/in.h>
20#include <linux/bpf.h>
21
22#include <bpf/bpf.h>
23#include <bpf/libbpf.h>
24
25#include "bpf_util.h"
26#include "bpf_rlimit.h"
27#include "test_maps.h"
28
29#ifndef ENOTSUPP
30#define ENOTSUPP 524
31#endif
32
33static int skips;
34
35static int map_flags;
36
37static void test_hashmap(unsigned int task, void *data)
38{
39 long long key, next_key, first_key, value;
40 int fd;
41
42 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
43 2, map_flags);
44 if (fd < 0) {
45 printf("Failed to create hashmap '%s'!\n", strerror(errno));
46 exit(1);
47 }
48
49 key = 1;
50 value = 1234;
51
52 assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
53
54 value = 0;
55
56 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
57
58 errno == EEXIST);
59
60
61 assert(bpf_map_update_elem(fd, &key, &value, -1) == -1 &&
62 errno == EINVAL);
63
64
65 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
66
67 key = 2;
68
69 assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
70
71
72 assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
73
74 errno == ENOENT);
75
76
77 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
78
79
80
81
82 key = 0;
83 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
84 errno == E2BIG);
85
86
87 key = 1;
88 assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == 0);
89 key = 2;
90 assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
91 key = 3;
92 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
93 errno == E2BIG);
94
95
96 key = 0;
97 assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
98
99
100 assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
101 (first_key == 1 || first_key == 2));
102 assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
103 (next_key == first_key));
104 assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
105 (next_key == 1 || next_key == 2) &&
106 (next_key != first_key));
107 assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
108 errno == ENOENT);
109
110
111 key = 1;
112 assert(bpf_map_delete_elem(fd, &key) == 0);
113 key = 2;
114 assert(bpf_map_delete_elem(fd, &key) == 0);
115 assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
116
117 key = 0;
118
119 assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
120 errno == ENOENT);
121 assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
122 errno == ENOENT);
123
124 close(fd);
125}
126
127static void test_hashmap_sizes(unsigned int task, void *data)
128{
129 int fd, i, j;
130
131 for (i = 1; i <= 512; i <<= 1)
132 for (j = 1; j <= 1 << 18; j <<= 1) {
133 fd = bpf_create_map(BPF_MAP_TYPE_HASH, i, j,
134 2, map_flags);
135 if (fd < 0) {
136 if (errno == ENOMEM)
137 return;
138 printf("Failed to create hashmap key=%d value=%d '%s'\n",
139 i, j, strerror(errno));
140 exit(1);
141 }
142 close(fd);
143 usleep(10);
144 }
145}
146
147static void test_hashmap_percpu(unsigned int task, void *data)
148{
149 unsigned int nr_cpus = bpf_num_possible_cpus();
150 BPF_DECLARE_PERCPU(long, value);
151 long long key, next_key, first_key;
152 int expected_key_mask = 0;
153 int fd, i;
154
155 fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_HASH, sizeof(key),
156 sizeof(bpf_percpu(value, 0)), 2, map_flags);
157 if (fd < 0) {
158 printf("Failed to create hashmap '%s'!\n", strerror(errno));
159 exit(1);
160 }
161
162 for (i = 0; i < nr_cpus; i++)
163 bpf_percpu(value, i) = i + 100;
164
165 key = 1;
166
167 assert(!(expected_key_mask & key));
168 assert(bpf_map_update_elem(fd, &key, value, BPF_ANY) == 0);
169 expected_key_mask |= key;
170
171
172 assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
173
174 errno == EEXIST);
175
176
177 assert(bpf_map_update_elem(fd, &key, value, -1) == -1 &&
178 errno == EINVAL);
179
180
181
182
183 bpf_percpu(value, 0) = 1;
184 assert(bpf_map_lookup_elem(fd, &key, value) == 0 &&
185 bpf_percpu(value, 0) == 100);
186
187 key = 2;
188
189 assert(bpf_map_lookup_elem(fd, &key, value) == -1 && errno == ENOENT);
190
191
192 assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == -1 &&
193
194 errno == ENOENT);
195
196
197 assert(!(expected_key_mask & key));
198 assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == 0);
199 expected_key_mask |= key;
200
201
202
203
204 key = 0;
205 assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
206 errno == E2BIG);
207
208
209 assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
210
211
212 assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
213 ((expected_key_mask & first_key) == first_key));
214 while (!bpf_map_get_next_key(fd, &key, &next_key)) {
215 if (first_key) {
216 assert(next_key == first_key);
217 first_key = 0;
218 }
219 assert((expected_key_mask & next_key) == next_key);
220 expected_key_mask &= ~next_key;
221
222 assert(bpf_map_lookup_elem(fd, &next_key, value) == 0);
223
224 for (i = 0; i < nr_cpus; i++)
225 assert(bpf_percpu(value, i) == i + 100);
226
227 key = next_key;
228 }
229 assert(errno == ENOENT);
230
231
232 key = 1;
233 assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);
234
235
236 key = 1;
237 assert(bpf_map_delete_elem(fd, &key) == 0);
238 key = 2;
239 assert(bpf_map_delete_elem(fd, &key) == 0);
240 assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
241
242 key = 0;
243
244 assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
245 errno == ENOENT);
246 assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
247 errno == ENOENT);
248
249 close(fd);
250}
251
252static int helper_fill_hashmap(int max_entries)
253{
254 int i, fd, ret;
255 long long key, value;
256
257 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
258 max_entries, map_flags);
259 CHECK(fd < 0,
260 "failed to create hashmap",
261 "err: %s, flags: 0x%x\n", strerror(errno), map_flags);
262
263 for (i = 0; i < max_entries; i++) {
264 key = i; value = key;
265 ret = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);
266 CHECK(ret != 0,
267 "can't update hashmap",
268 "err: %s\n", strerror(ret));
269 }
270
271 return fd;
272}
273
274static void test_hashmap_walk(unsigned int task, void *data)
275{
276 int fd, i, max_entries = 1000;
277 long long key, value, next_key;
278 bool next_key_valid = true;
279
280 fd = helper_fill_hashmap(max_entries);
281
282 for (i = 0; bpf_map_get_next_key(fd, !i ? NULL : &key,
283 &next_key) == 0; i++) {
284 key = next_key;
285 assert(bpf_map_lookup_elem(fd, &key, &value) == 0);
286 }
287
288 assert(i == max_entries);
289
290 assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
291 for (i = 0; next_key_valid; i++) {
292 next_key_valid = bpf_map_get_next_key(fd, &key, &next_key) == 0;
293 assert(bpf_map_lookup_elem(fd, &key, &value) == 0);
294 value++;
295 assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == 0);
296 key = next_key;
297 }
298
299 assert(i == max_entries);
300
301 for (i = 0; bpf_map_get_next_key(fd, !i ? NULL : &key,
302 &next_key) == 0; i++) {
303 key = next_key;
304 assert(bpf_map_lookup_elem(fd, &key, &value) == 0);
305 assert(value - 1 == key);
306 }
307
308 assert(i == max_entries);
309 close(fd);
310}
311
312static void test_hashmap_zero_seed(void)
313{
314 int i, first, second, old_flags;
315 long long key, next_first, next_second;
316
317 old_flags = map_flags;
318 map_flags |= BPF_F_ZERO_SEED;
319
320 first = helper_fill_hashmap(3);
321 second = helper_fill_hashmap(3);
322
323 for (i = 0; ; i++) {
324 void *key_ptr = !i ? NULL : &key;
325
326 if (bpf_map_get_next_key(first, key_ptr, &next_first) != 0)
327 break;
328
329 CHECK(bpf_map_get_next_key(second, key_ptr, &next_second) != 0,
330 "next_key for second map must succeed",
331 "key_ptr: %p", key_ptr);
332 CHECK(next_first != next_second,
333 "keys must match",
334 "i: %d first: %lld second: %lld\n", i,
335 next_first, next_second);
336
337 key = next_first;
338 }
339
340 map_flags = old_flags;
341 close(first);
342 close(second);
343}
344
345static void test_arraymap(unsigned int task, void *data)
346{
347 int key, next_key, fd;
348 long long value;
349
350 fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(key), sizeof(value),
351 2, 0);
352 if (fd < 0) {
353 printf("Failed to create arraymap '%s'!\n", strerror(errno));
354 exit(1);
355 }
356
357 key = 1;
358 value = 1234;
359
360 assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
361
362 value = 0;
363 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
364 errno == EEXIST);
365
366
367 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
368
369 key = 0;
370
371 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
372
373
374
375
376 key = 2;
377 assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
378 errno == E2BIG);
379
380
381 assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
382
383
384 assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
385 next_key == 0);
386 assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
387 next_key == 0);
388 assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
389 next_key == 1);
390 assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
391 errno == ENOENT);
392
393
394 key = 1;
395 assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
396
397 close(fd);
398}
399
400static void test_arraymap_percpu(unsigned int task, void *data)
401{
402 unsigned int nr_cpus = bpf_num_possible_cpus();
403 BPF_DECLARE_PERCPU(long, values);
404 int key, next_key, fd, i;
405
406 fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
407 sizeof(bpf_percpu(values, 0)), 2, 0);
408 if (fd < 0) {
409 printf("Failed to create arraymap '%s'!\n", strerror(errno));
410 exit(1);
411 }
412
413 for (i = 0; i < nr_cpus; i++)
414 bpf_percpu(values, i) = i + 100;
415
416 key = 1;
417
418 assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
419
420 bpf_percpu(values, 0) = 0;
421 assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) == -1 &&
422 errno == EEXIST);
423
424
425 assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
426 bpf_percpu(values, 0) == 100);
427
428 key = 0;
429
430 assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
431 bpf_percpu(values, 0) == 0 &&
432 bpf_percpu(values, nr_cpus - 1) == 0);
433
434
435 key = 2;
436 assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) == -1 &&
437 errno == E2BIG);
438
439
440 assert(bpf_map_lookup_elem(fd, &key, values) == -1 && errno == ENOENT);
441
442
443 assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
444 next_key == 0);
445 assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
446 next_key == 0);
447 assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
448 next_key == 1);
449 assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
450 errno == ENOENT);
451
452
453 key = 1;
454 assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
455
456 close(fd);
457}
458
459static void test_arraymap_percpu_many_keys(void)
460{
461 unsigned int nr_cpus = bpf_num_possible_cpus();
462 BPF_DECLARE_PERCPU(long, values);
463
464
465
466 unsigned int nr_keys = 2000;
467 int key, fd, i;
468
469 fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
470 sizeof(bpf_percpu(values, 0)), nr_keys, 0);
471 if (fd < 0) {
472 printf("Failed to create per-cpu arraymap '%s'!\n",
473 strerror(errno));
474 exit(1);
475 }
476
477 for (i = 0; i < nr_cpus; i++)
478 bpf_percpu(values, i) = i + 10;
479
480 for (key = 0; key < nr_keys; key++)
481 assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
482
483 for (key = 0; key < nr_keys; key++) {
484 for (i = 0; i < nr_cpus; i++)
485 bpf_percpu(values, i) = 0;
486
487 assert(bpf_map_lookup_elem(fd, &key, values) == 0);
488
489 for (i = 0; i < nr_cpus; i++)
490 assert(bpf_percpu(values, i) == i + 10);
491 }
492
493 close(fd);
494}
495
496static void test_devmap(unsigned int task, void *data)
497{
498 int fd;
499 __u32 key, value;
500
501 fd = bpf_create_map(BPF_MAP_TYPE_DEVMAP, sizeof(key), sizeof(value),
502 2, 0);
503 if (fd < 0) {
504 printf("Failed to create devmap '%s'!\n", strerror(errno));
505 exit(1);
506 }
507
508 close(fd);
509}
510
511static void test_devmap_hash(unsigned int task, void *data)
512{
513 int fd;
514 __u32 key, value;
515
516 fd = bpf_create_map(BPF_MAP_TYPE_DEVMAP_HASH, sizeof(key), sizeof(value),
517 2, 0);
518 if (fd < 0) {
519 printf("Failed to create devmap_hash '%s'!\n", strerror(errno));
520 exit(1);
521 }
522
523 close(fd);
524}
525
526static void test_queuemap(unsigned int task, void *data)
527{
528 const int MAP_SIZE = 32;
529 __u32 vals[MAP_SIZE + MAP_SIZE/2], val;
530 int fd, i;
531
532
533 for (i = 0; i < MAP_SIZE + MAP_SIZE/2; i++)
534 vals[i] = rand();
535
536
537 fd = bpf_create_map(BPF_MAP_TYPE_QUEUE, 4, sizeof(val), MAP_SIZE,
538 map_flags);
539 assert(fd < 0 && errno == EINVAL);
540
541 fd = bpf_create_map(BPF_MAP_TYPE_QUEUE, 0, sizeof(val), MAP_SIZE,
542 map_flags);
543
544 if (map_flags & BPF_F_NO_PREALLOC) {
545 assert(fd < 0 && errno == EINVAL);
546 return;
547 }
548 if (fd < 0) {
549 printf("Failed to create queuemap '%s'!\n", strerror(errno));
550 exit(1);
551 }
552
553
554 for (i = 0; i < MAP_SIZE; i++)
555 assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
556
557
558 assert(bpf_map_update_elem(fd, NULL, &val, 0) == -1 &&
559 errno == E2BIG);
560
561
562 assert(bpf_map_lookup_elem(fd, NULL, &val) == 0 && val == vals[0]);
563
564
565 for (i = MAP_SIZE; i < MAP_SIZE + MAP_SIZE/2; i++)
566 assert(bpf_map_update_elem(fd, NULL, &vals[i], BPF_EXIST) == 0);
567
568
569 for (i = MAP_SIZE/2; i < MAP_SIZE + MAP_SIZE/2; i++)
570 assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == 0 &&
571 val == vals[i]);
572
573
574 assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == -1 &&
575 errno == ENOENT);
576
577
578 assert(bpf_map_delete_elem(fd, NULL) == -1 && errno == EINVAL);
579 assert(bpf_map_get_next_key(fd, NULL, NULL) == -1 && errno == EINVAL);
580
581 close(fd);
582}
583
584static void test_stackmap(unsigned int task, void *data)
585{
586 const int MAP_SIZE = 32;
587 __u32 vals[MAP_SIZE + MAP_SIZE/2], val;
588 int fd, i;
589
590
591 for (i = 0; i < MAP_SIZE + MAP_SIZE/2; i++)
592 vals[i] = rand();
593
594
595 fd = bpf_create_map(BPF_MAP_TYPE_STACK, 4, sizeof(val), MAP_SIZE,
596 map_flags);
597 assert(fd < 0 && errno == EINVAL);
598
599 fd = bpf_create_map(BPF_MAP_TYPE_STACK, 0, sizeof(val), MAP_SIZE,
600 map_flags);
601
602 if (map_flags & BPF_F_NO_PREALLOC) {
603 assert(fd < 0 && errno == EINVAL);
604 return;
605 }
606 if (fd < 0) {
607 printf("Failed to create stackmap '%s'!\n", strerror(errno));
608 exit(1);
609 }
610
611
612 for (i = 0; i < MAP_SIZE; i++)
613 assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
614
615
616 assert(bpf_map_update_elem(fd, NULL, &val, 0) == -1 &&
617 errno == E2BIG);
618
619
620 assert(bpf_map_lookup_elem(fd, NULL, &val) == 0 && val == vals[i - 1]);
621
622
623 for (i = MAP_SIZE; i < MAP_SIZE + MAP_SIZE/2; i++)
624 assert(bpf_map_update_elem(fd, NULL, &vals[i], BPF_EXIST) == 0);
625
626
627 for (i = MAP_SIZE + MAP_SIZE/2 - 1; i >= MAP_SIZE/2; i--)
628 assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == 0 &&
629 val == vals[i]);
630
631
632 assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == -1 &&
633 errno == ENOENT);
634
635
636 assert(bpf_map_delete_elem(fd, NULL) == -1 && errno == EINVAL);
637 assert(bpf_map_get_next_key(fd, NULL, NULL) == -1 && errno == EINVAL);
638
639 close(fd);
640}
641
642#include <sys/ioctl.h>
643#include <arpa/inet.h>
644#include <sys/select.h>
645#include <linux/err.h>
646#define SOCKMAP_PARSE_PROG "./sockmap_parse_prog.o"
647#define SOCKMAP_VERDICT_PROG "./sockmap_verdict_prog.o"
648#define SOCKMAP_TCP_MSG_PROG "./sockmap_tcp_msg_prog.o"
649static void test_sockmap(unsigned int tasks, void *data)
650{
651 struct bpf_map *bpf_map_rx, *bpf_map_tx, *bpf_map_msg, *bpf_map_break;
652 int map_fd_msg = 0, map_fd_rx = 0, map_fd_tx = 0, map_fd_break;
653 int ports[] = {50200, 50201, 50202, 50204};
654 int err, i, fd, udp, sfd[6] = {0xdeadbeef};
655 u8 buf[20] = {0x0, 0x5, 0x3, 0x2, 0x1, 0x0};
656 int parse_prog, verdict_prog, msg_prog;
657 struct sockaddr_in addr;
658 int one = 1, s, sc, rc;
659 struct bpf_object *obj;
660 struct timeval to;
661 __u32 key, value;
662 pid_t pid[tasks];
663 fd_set w;
664
665
666 for (i = 0; i < 2; i++) {
667 sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
668 if (sfd[i] < 0)
669 goto out;
670 err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
671 (char *)&one, sizeof(one));
672 if (err) {
673 printf("failed to setsockopt\n");
674 goto out;
675 }
676 err = ioctl(sfd[i], FIONBIO, (char *)&one);
677 if (err < 0) {
678 printf("failed to ioctl\n");
679 goto out;
680 }
681 memset(&addr, 0, sizeof(struct sockaddr_in));
682 addr.sin_family = AF_INET;
683 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
684 addr.sin_port = htons(ports[i]);
685 err = bind(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
686 if (err < 0) {
687 printf("failed to bind: err %i: %i:%i\n",
688 err, i, sfd[i]);
689 goto out;
690 }
691 err = listen(sfd[i], 32);
692 if (err < 0) {
693 printf("failed to listen\n");
694 goto out;
695 }
696 }
697
698 for (i = 2; i < 4; i++) {
699 sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
700 if (sfd[i] < 0)
701 goto out;
702 err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
703 (char *)&one, sizeof(one));
704 if (err) {
705 printf("set sock opt\n");
706 goto out;
707 }
708 memset(&addr, 0, sizeof(struct sockaddr_in));
709 addr.sin_family = AF_INET;
710 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
711 addr.sin_port = htons(ports[i - 2]);
712 err = connect(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
713 if (err) {
714 printf("failed to connect\n");
715 goto out;
716 }
717 }
718
719
720 for (i = 4; i < 6; i++) {
721 sfd[i] = accept(sfd[i - 4], NULL, NULL);
722 if (sfd[i] < 0) {
723 printf("accept failed\n");
724 goto out;
725 }
726 }
727
728
729 fd = bpf_create_map(BPF_MAP_TYPE_SOCKMAP,
730 sizeof(key), sizeof(value),
731 6, 0);
732 if (fd < 0) {
733 if (!bpf_probe_map_type(BPF_MAP_TYPE_SOCKMAP, 0)) {
734 printf("%s SKIP (unsupported map type BPF_MAP_TYPE_SOCKMAP)\n",
735 __func__);
736 skips++;
737 for (i = 0; i < 6; i++)
738 close(sfd[i]);
739 return;
740 }
741
742 printf("Failed to create sockmap %i\n", fd);
743 goto out_sockmap;
744 }
745
746
747 udp = socket(AF_INET, SOCK_DGRAM, 0);
748 i = 0;
749 err = bpf_map_update_elem(fd, &i, &udp, BPF_ANY);
750 if (!err) {
751 printf("Failed socket SOCK_DGRAM allowed '%i:%i'\n",
752 i, udp);
753 goto out_sockmap;
754 }
755
756
757 for (i = 0; i < 6; i++) {
758 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
759 if (i < 2 && !err) {
760 printf("Allowed update sockmap '%i:%i' not in ESTABLISHED\n",
761 i, sfd[i]);
762 goto out_sockmap;
763 } else if (i >= 2 && err) {
764 printf("Failed noprog update sockmap '%i:%i'\n",
765 i, sfd[i]);
766 goto out_sockmap;
767 }
768 }
769
770
771 err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_PARSER, 0);
772 if (!err) {
773 printf("Failed invalid parser prog attach\n");
774 goto out_sockmap;
775 }
776
777 err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_VERDICT, 0);
778 if (!err) {
779 printf("Failed invalid verdict prog attach\n");
780 goto out_sockmap;
781 }
782
783 err = bpf_prog_attach(-1, fd, BPF_SK_MSG_VERDICT, 0);
784 if (!err) {
785 printf("Failed invalid msg verdict prog attach\n");
786 goto out_sockmap;
787 }
788
789 err = bpf_prog_attach(-1, fd, __MAX_BPF_ATTACH_TYPE, 0);
790 if (!err) {
791 printf("Failed unknown prog attach\n");
792 goto out_sockmap;
793 }
794
795 err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_PARSER);
796 if (err) {
797 printf("Failed empty parser prog detach\n");
798 goto out_sockmap;
799 }
800
801 err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_VERDICT);
802 if (err) {
803 printf("Failed empty verdict prog detach\n");
804 goto out_sockmap;
805 }
806
807 err = bpf_prog_detach(fd, BPF_SK_MSG_VERDICT);
808 if (err) {
809 printf("Failed empty msg verdict prog detach\n");
810 goto out_sockmap;
811 }
812
813 err = bpf_prog_detach(fd, __MAX_BPF_ATTACH_TYPE);
814 if (!err) {
815 printf("Detach invalid prog successful\n");
816 goto out_sockmap;
817 }
818
819
820 err = bpf_prog_load(SOCKMAP_PARSE_PROG,
821 BPF_PROG_TYPE_SK_SKB, &obj, &parse_prog);
822 if (err) {
823 printf("Failed to load SK_SKB parse prog\n");
824 goto out_sockmap;
825 }
826
827 err = bpf_prog_load(SOCKMAP_TCP_MSG_PROG,
828 BPF_PROG_TYPE_SK_MSG, &obj, &msg_prog);
829 if (err) {
830 printf("Failed to load SK_SKB msg prog\n");
831 goto out_sockmap;
832 }
833
834 err = bpf_prog_load(SOCKMAP_VERDICT_PROG,
835 BPF_PROG_TYPE_SK_SKB, &obj, &verdict_prog);
836 if (err) {
837 printf("Failed to load SK_SKB verdict prog\n");
838 goto out_sockmap;
839 }
840
841 bpf_map_rx = bpf_object__find_map_by_name(obj, "sock_map_rx");
842 if (IS_ERR(bpf_map_rx)) {
843 printf("Failed to load map rx from verdict prog\n");
844 goto out_sockmap;
845 }
846
847 map_fd_rx = bpf_map__fd(bpf_map_rx);
848 if (map_fd_rx < 0) {
849 printf("Failed to get map rx fd\n");
850 goto out_sockmap;
851 }
852
853 bpf_map_tx = bpf_object__find_map_by_name(obj, "sock_map_tx");
854 if (IS_ERR(bpf_map_tx)) {
855 printf("Failed to load map tx from verdict prog\n");
856 goto out_sockmap;
857 }
858
859 map_fd_tx = bpf_map__fd(bpf_map_tx);
860 if (map_fd_tx < 0) {
861 printf("Failed to get map tx fd\n");
862 goto out_sockmap;
863 }
864
865 bpf_map_msg = bpf_object__find_map_by_name(obj, "sock_map_msg");
866 if (IS_ERR(bpf_map_msg)) {
867 printf("Failed to load map msg from msg_verdict prog\n");
868 goto out_sockmap;
869 }
870
871 map_fd_msg = bpf_map__fd(bpf_map_msg);
872 if (map_fd_msg < 0) {
873 printf("Failed to get map msg fd\n");
874 goto out_sockmap;
875 }
876
877 bpf_map_break = bpf_object__find_map_by_name(obj, "sock_map_break");
878 if (IS_ERR(bpf_map_break)) {
879 printf("Failed to load map tx from verdict prog\n");
880 goto out_sockmap;
881 }
882
883 map_fd_break = bpf_map__fd(bpf_map_break);
884 if (map_fd_break < 0) {
885 printf("Failed to get map tx fd\n");
886 goto out_sockmap;
887 }
888
889 err = bpf_prog_attach(parse_prog, map_fd_break,
890 BPF_SK_SKB_STREAM_PARSER, 0);
891 if (!err) {
892 printf("Allowed attaching SK_SKB program to invalid map\n");
893 goto out_sockmap;
894 }
895
896 err = bpf_prog_attach(parse_prog, map_fd_rx,
897 BPF_SK_SKB_STREAM_PARSER, 0);
898 if (err) {
899 printf("Failed stream parser bpf prog attach\n");
900 goto out_sockmap;
901 }
902
903 err = bpf_prog_attach(verdict_prog, map_fd_rx,
904 BPF_SK_SKB_STREAM_VERDICT, 0);
905 if (err) {
906 printf("Failed stream verdict bpf prog attach\n");
907 goto out_sockmap;
908 }
909
910 err = bpf_prog_attach(msg_prog, map_fd_msg, BPF_SK_MSG_VERDICT, 0);
911 if (err) {
912 printf("Failed msg verdict bpf prog attach\n");
913 goto out_sockmap;
914 }
915
916 err = bpf_prog_attach(verdict_prog, map_fd_rx,
917 __MAX_BPF_ATTACH_TYPE, 0);
918 if (!err) {
919 printf("Attached unknown bpf prog\n");
920 goto out_sockmap;
921 }
922
923
924 for (i = 2; i < 6; i++) {
925 err = bpf_map_update_elem(map_fd_rx, &i, &sfd[i], BPF_ANY);
926 if (err) {
927 printf("Failed map_fd_rx update sockmap %i '%i:%i'\n",
928 err, i, sfd[i]);
929 goto out_sockmap;
930 }
931 err = bpf_map_update_elem(map_fd_tx, &i, &sfd[i], BPF_ANY);
932 if (err) {
933 printf("Failed map_fd_tx update sockmap %i '%i:%i'\n",
934 err, i, sfd[i]);
935 goto out_sockmap;
936 }
937 }
938
939
940 for (i = 2; i < 4; i++) {
941 err = bpf_map_delete_elem(map_fd_rx, &i);
942 if (err) {
943 printf("Failed delete sockmap rx %i '%i:%i'\n",
944 err, i, sfd[i]);
945 goto out_sockmap;
946 }
947 err = bpf_map_delete_elem(map_fd_tx, &i);
948 if (err) {
949 printf("Failed delete sockmap tx %i '%i:%i'\n",
950 err, i, sfd[i]);
951 goto out_sockmap;
952 }
953 }
954
955
956 i = 0;
957 err = bpf_map_update_elem(map_fd_msg, &i, &sfd[2], BPF_ANY);
958 if (err) {
959 printf("Failed map_fd_msg update sockmap %i\n", err);
960 goto out_sockmap;
961 }
962
963
964 for (i = 0; i < 2; i++) {
965 buf[0] = i;
966 buf[1] = 0x5;
967 sc = send(sfd[2], buf, 20, 0);
968 if (sc < 0) {
969 printf("Failed sockmap send\n");
970 goto out_sockmap;
971 }
972
973 FD_ZERO(&w);
974 FD_SET(sfd[3], &w);
975 to.tv_sec = 1;
976 to.tv_usec = 0;
977 s = select(sfd[3] + 1, &w, NULL, NULL, &to);
978 if (s == -1) {
979 perror("Failed sockmap select()");
980 goto out_sockmap;
981 } else if (!s) {
982 printf("Failed sockmap unexpected timeout\n");
983 goto out_sockmap;
984 }
985
986 if (!FD_ISSET(sfd[3], &w)) {
987 printf("Failed sockmap select/recv\n");
988 goto out_sockmap;
989 }
990
991 rc = recv(sfd[3], buf, sizeof(buf), 0);
992 if (rc < 0) {
993 printf("Failed sockmap recv\n");
994 goto out_sockmap;
995 }
996 }
997
998
999 buf[0] = 1;
1000 buf[1] = 12;
1001 sc = send(sfd[2], buf, 20, 0);
1002 if (sc < 0) {
1003 printf("Failed sockmap send\n");
1004 goto out_sockmap;
1005 }
1006
1007
1008 i = 2;
1009 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1010 if (!err) {
1011 printf("Failed allowed sockmap dup slot BPF_NOEXIST\n");
1012 goto out_sockmap;
1013 }
1014
1015 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1016 if (err) {
1017 printf("Failed sockmap update new slot BPF_ANY\n");
1018 goto out_sockmap;
1019 }
1020
1021 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1022 if (err) {
1023 printf("Failed sockmap update new slot BPF_EXIST\n");
1024 goto out_sockmap;
1025 }
1026
1027
1028 for (i = 2; i < 6; i++) {
1029 err = bpf_map_delete_elem(fd, &i);
1030 if (err) {
1031 printf("Failed delete sockmap %i '%i:%i'\n",
1032 err, i, sfd[i]);
1033 }
1034 }
1035
1036
1037 err = bpf_prog_attach(parse_prog, fd,
1038 BPF_SK_SKB_STREAM_PARSER, 0);
1039 if (err) {
1040 printf("Failed fd bpf parse prog attach\n");
1041 goto out_sockmap;
1042 }
1043 err = bpf_prog_attach(verdict_prog, fd,
1044 BPF_SK_SKB_STREAM_VERDICT, 0);
1045 if (err) {
1046 printf("Failed fd bpf verdict prog attach\n");
1047 goto out_sockmap;
1048 }
1049
1050 for (i = 4; i < 6; i++) {
1051 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1052 if (!err) {
1053 printf("Failed allowed duplicate programs in update ANY sockmap %i '%i:%i'\n",
1054 err, i, sfd[i]);
1055 goto out_sockmap;
1056 }
1057 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1058 if (!err) {
1059 printf("Failed allowed duplicate program in update NOEXIST sockmap %i '%i:%i'\n",
1060 err, i, sfd[i]);
1061 goto out_sockmap;
1062 }
1063 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1064 if (!err) {
1065 printf("Failed allowed duplicate program in update EXIST sockmap %i '%i:%i'\n",
1066 err, i, sfd[i]);
1067 goto out_sockmap;
1068 }
1069 }
1070
1071
1072 for (i = 0; i < tasks; i++) {
1073 pid[i] = fork();
1074 if (pid[i] == 0) {
1075 for (i = 0; i < 6; i++) {
1076 bpf_map_delete_elem(map_fd_tx, &i);
1077 bpf_map_delete_elem(map_fd_rx, &i);
1078 bpf_map_update_elem(map_fd_tx, &i,
1079 &sfd[i], BPF_ANY);
1080 bpf_map_update_elem(map_fd_rx, &i,
1081 &sfd[i], BPF_ANY);
1082 }
1083 exit(0);
1084 } else if (pid[i] == -1) {
1085 printf("Couldn't spawn #%d process!\n", i);
1086 exit(1);
1087 }
1088 }
1089
1090 for (i = 0; i < tasks; i++) {
1091 int status;
1092
1093 assert(waitpid(pid[i], &status, 0) == pid[i]);
1094 assert(status == 0);
1095 }
1096
1097 err = bpf_prog_detach(map_fd_rx, __MAX_BPF_ATTACH_TYPE);
1098 if (!err) {
1099 printf("Detached an invalid prog type.\n");
1100 goto out_sockmap;
1101 }
1102
1103 err = bpf_prog_detach(map_fd_rx, BPF_SK_SKB_STREAM_PARSER);
1104 if (err) {
1105 printf("Failed parser prog detach\n");
1106 goto out_sockmap;
1107 }
1108
1109 err = bpf_prog_detach(map_fd_rx, BPF_SK_SKB_STREAM_VERDICT);
1110 if (err) {
1111 printf("Failed parser prog detach\n");
1112 goto out_sockmap;
1113 }
1114
1115
1116 for (i = 0; i < 6; i++) {
1117 bpf_map_delete_elem(map_fd_tx, &i);
1118 bpf_map_delete_elem(map_fd_rx, &i);
1119 close(sfd[i]);
1120 }
1121 close(fd);
1122 close(map_fd_rx);
1123 bpf_object__close(obj);
1124 return;
1125out:
1126 for (i = 0; i < 6; i++)
1127 close(sfd[i]);
1128 printf("Failed to create sockmap '%i:%s'!\n", i, strerror(errno));
1129 exit(1);
1130out_sockmap:
1131 for (i = 0; i < 6; i++) {
1132 if (map_fd_tx)
1133 bpf_map_delete_elem(map_fd_tx, &i);
1134 if (map_fd_rx)
1135 bpf_map_delete_elem(map_fd_rx, &i);
1136 close(sfd[i]);
1137 }
1138 close(fd);
1139 exit(1);
1140}
1141
1142#define MAPINMAP_PROG "./test_map_in_map.o"
1143static void test_map_in_map(void)
1144{
1145 struct bpf_program *prog;
1146 struct bpf_object *obj;
1147 struct bpf_map *map;
1148 int mim_fd, fd, err;
1149 int pos = 0;
1150
1151 obj = bpf_object__open(MAPINMAP_PROG);
1152
1153 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(int), sizeof(int),
1154 2, 0);
1155 if (fd < 0) {
1156 printf("Failed to create hashmap '%s'!\n", strerror(errno));
1157 exit(1);
1158 }
1159
1160 map = bpf_object__find_map_by_name(obj, "mim_array");
1161 if (IS_ERR(map)) {
1162 printf("Failed to load array of maps from test prog\n");
1163 goto out_map_in_map;
1164 }
1165 err = bpf_map__set_inner_map_fd(map, fd);
1166 if (err) {
1167 printf("Failed to set inner_map_fd for array of maps\n");
1168 goto out_map_in_map;
1169 }
1170
1171 map = bpf_object__find_map_by_name(obj, "mim_hash");
1172 if (IS_ERR(map)) {
1173 printf("Failed to load hash of maps from test prog\n");
1174 goto out_map_in_map;
1175 }
1176 err = bpf_map__set_inner_map_fd(map, fd);
1177 if (err) {
1178 printf("Failed to set inner_map_fd for hash of maps\n");
1179 goto out_map_in_map;
1180 }
1181
1182 bpf_object__for_each_program(prog, obj) {
1183 bpf_program__set_xdp(prog);
1184 }
1185 bpf_object__load(obj);
1186
1187 map = bpf_object__find_map_by_name(obj, "mim_array");
1188 if (IS_ERR(map)) {
1189 printf("Failed to load array of maps from test prog\n");
1190 goto out_map_in_map;
1191 }
1192 mim_fd = bpf_map__fd(map);
1193 if (mim_fd < 0) {
1194 printf("Failed to get descriptor for array of maps\n");
1195 goto out_map_in_map;
1196 }
1197
1198 err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);
1199 if (err) {
1200 printf("Failed to update array of maps\n");
1201 goto out_map_in_map;
1202 }
1203
1204 map = bpf_object__find_map_by_name(obj, "mim_hash");
1205 if (IS_ERR(map)) {
1206 printf("Failed to load hash of maps from test prog\n");
1207 goto out_map_in_map;
1208 }
1209 mim_fd = bpf_map__fd(map);
1210 if (mim_fd < 0) {
1211 printf("Failed to get descriptor for hash of maps\n");
1212 goto out_map_in_map;
1213 }
1214
1215 err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);
1216 if (err) {
1217 printf("Failed to update hash of maps\n");
1218 goto out_map_in_map;
1219 }
1220
1221 close(fd);
1222 bpf_object__close(obj);
1223 return;
1224
1225out_map_in_map:
1226 close(fd);
1227 exit(1);
1228}
1229
1230#define MAP_SIZE (32 * 1024)
1231
1232static void test_map_large(void)
1233{
1234 struct bigkey {
1235 int a;
1236 char b[116];
1237 long long c;
1238 } key;
1239 int fd, i, value;
1240
1241 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1242 MAP_SIZE, map_flags);
1243 if (fd < 0) {
1244 printf("Failed to create large map '%s'!\n", strerror(errno));
1245 exit(1);
1246 }
1247
1248 for (i = 0; i < MAP_SIZE; i++) {
1249 key = (struct bigkey) { .c = i };
1250 value = i;
1251
1252 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
1253 }
1254
1255 key.c = -1;
1256 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1257 errno == E2BIG);
1258
1259
1260 assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1261 key.c = -1;
1262 for (i = 0; i < MAP_SIZE; i++)
1263 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1264 assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1265
1266 key.c = 0;
1267 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
1268 key.a = 1;
1269 assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1270
1271 close(fd);
1272}
1273
1274#define run_parallel(N, FN, DATA) \
1275 printf("Fork %u tasks to '" #FN "'\n", N); \
1276 __run_parallel(N, FN, DATA)
1277
1278static void __run_parallel(unsigned int tasks,
1279 void (*fn)(unsigned int task, void *data),
1280 void *data)
1281{
1282 pid_t pid[tasks];
1283 int i;
1284
1285 for (i = 0; i < tasks; i++) {
1286 pid[i] = fork();
1287 if (pid[i] == 0) {
1288 fn(i, data);
1289 exit(0);
1290 } else if (pid[i] == -1) {
1291 printf("Couldn't spawn #%d process!\n", i);
1292 exit(1);
1293 }
1294 }
1295
1296 for (i = 0; i < tasks; i++) {
1297 int status;
1298
1299 assert(waitpid(pid[i], &status, 0) == pid[i]);
1300 assert(status == 0);
1301 }
1302}
1303
1304static void test_map_stress(void)
1305{
1306 run_parallel(100, test_hashmap, NULL);
1307 run_parallel(100, test_hashmap_percpu, NULL);
1308 run_parallel(100, test_hashmap_sizes, NULL);
1309 run_parallel(100, test_hashmap_walk, NULL);
1310
1311 run_parallel(100, test_arraymap, NULL);
1312 run_parallel(100, test_arraymap_percpu, NULL);
1313}
1314
1315#define TASKS 1024
1316
1317#define DO_UPDATE 1
1318#define DO_DELETE 0
1319
1320static void test_update_delete(unsigned int fn, void *data)
1321{
1322 int do_update = ((int *)data)[1];
1323 int fd = ((int *)data)[0];
1324 int i, key, value;
1325
1326 for (i = fn; i < MAP_SIZE; i += TASKS) {
1327 key = value = i;
1328
1329 if (do_update) {
1330 assert(bpf_map_update_elem(fd, &key, &value,
1331 BPF_NOEXIST) == 0);
1332 assert(bpf_map_update_elem(fd, &key, &value,
1333 BPF_EXIST) == 0);
1334 } else {
1335 assert(bpf_map_delete_elem(fd, &key) == 0);
1336 }
1337 }
1338}
1339
1340static void test_map_parallel(void)
1341{
1342 int i, fd, key = 0, value = 0;
1343 int data[2];
1344
1345 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1346 MAP_SIZE, map_flags);
1347 if (fd < 0) {
1348 printf("Failed to create map for parallel test '%s'!\n",
1349 strerror(errno));
1350 exit(1);
1351 }
1352
1353
1354
1355
1356
1357
1358 data[0] = fd;
1359 data[1] = DO_UPDATE;
1360 run_parallel(TASKS, test_update_delete, data);
1361
1362
1363 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1364 errno == EEXIST);
1365
1366
1367 assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1368 key = -1;
1369 for (i = 0; i < MAP_SIZE; i++)
1370 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1371 assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1372
1373
1374 for (i = 0; i < MAP_SIZE; i++) {
1375 key = MAP_SIZE - i - 1;
1376
1377 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 &&
1378 value == key);
1379 }
1380
1381
1382 data[1] = DO_DELETE;
1383 run_parallel(TASKS, test_update_delete, data);
1384
1385
1386 key = -1;
1387 assert(bpf_map_get_next_key(fd, NULL, &key) == -1 && errno == ENOENT);
1388 assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1389}
1390
1391static void test_map_rdonly(void)
1392{
1393 int fd, key = 0, value = 0;
1394
1395 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1396 MAP_SIZE, map_flags | BPF_F_RDONLY);
1397 if (fd < 0) {
1398 printf("Failed to create map for read only test '%s'!\n",
1399 strerror(errno));
1400 exit(1);
1401 }
1402
1403 key = 1;
1404 value = 1234;
1405
1406 assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == -1 &&
1407 errno == EPERM);
1408
1409
1410 assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1411 assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == ENOENT);
1412}
1413
1414static void test_map_wronly(void)
1415{
1416 int fd, key = 0, value = 0;
1417
1418 fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1419 MAP_SIZE, map_flags | BPF_F_WRONLY);
1420 if (fd < 0) {
1421 printf("Failed to create map for read only test '%s'!\n",
1422 strerror(errno));
1423 exit(1);
1424 }
1425
1426 key = 1;
1427 value = 1234;
1428
1429 assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
1430
1431
1432 assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == EPERM);
1433 assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == EPERM);
1434}
1435
1436static void prepare_reuseport_grp(int type, int map_fd, size_t map_elem_size,
1437 __s64 *fds64, __u64 *sk_cookies,
1438 unsigned int n)
1439{
1440 socklen_t optlen, addrlen;
1441 struct sockaddr_in6 s6;
1442 const __u32 index0 = 0;
1443 const int optval = 1;
1444 unsigned int i;
1445 u64 sk_cookie;
1446 void *value;
1447 __s32 fd32;
1448 __s64 fd64;
1449 int err;
1450
1451 s6.sin6_family = AF_INET6;
1452 s6.sin6_addr = in6addr_any;
1453 s6.sin6_port = 0;
1454 addrlen = sizeof(s6);
1455 optlen = sizeof(sk_cookie);
1456
1457 for (i = 0; i < n; i++) {
1458 fd64 = socket(AF_INET6, type, 0);
1459 CHECK(fd64 == -1, "socket()",
1460 "sock_type:%d fd64:%lld errno:%d\n",
1461 type, fd64, errno);
1462
1463 err = setsockopt(fd64, SOL_SOCKET, SO_REUSEPORT,
1464 &optval, sizeof(optval));
1465 CHECK(err == -1, "setsockopt(SO_REUSEPORT)",
1466 "err:%d errno:%d\n", err, errno);
1467
1468
1469 if (map_elem_size == sizeof(__u64))
1470 value = &fd64;
1471 else {
1472 assert(map_elem_size == sizeof(__u32));
1473 fd32 = (__s32)fd64;
1474 value = &fd32;
1475 }
1476 err = bpf_map_update_elem(map_fd, &index0, value, BPF_ANY);
1477 CHECK(err != -1 || errno != EINVAL,
1478 "reuseport array update unbound sk",
1479 "sock_type:%d err:%d errno:%d\n",
1480 type, err, errno);
1481
1482 err = bind(fd64, (struct sockaddr *)&s6, sizeof(s6));
1483 CHECK(err == -1, "bind()",
1484 "sock_type:%d err:%d errno:%d\n", type, err, errno);
1485
1486 if (i == 0) {
1487 err = getsockname(fd64, (struct sockaddr *)&s6,
1488 &addrlen);
1489 CHECK(err == -1, "getsockname()",
1490 "sock_type:%d err:%d errno:%d\n",
1491 type, err, errno);
1492 }
1493
1494 err = getsockopt(fd64, SOL_SOCKET, SO_COOKIE, &sk_cookie,
1495 &optlen);
1496 CHECK(err == -1, "getsockopt(SO_COOKIE)",
1497 "sock_type:%d err:%d errno:%d\n", type, err, errno);
1498
1499 if (type == SOCK_STREAM) {
1500
1501
1502
1503
1504 err = bpf_map_update_elem(map_fd, &index0, value,
1505 BPF_ANY);
1506 CHECK(err != -1 || errno != EINVAL,
1507 "reuseport array update non-listening sk",
1508 "sock_type:%d err:%d errno:%d\n",
1509 type, err, errno);
1510 err = listen(fd64, 0);
1511 CHECK(err == -1, "listen()",
1512 "sock_type:%d, err:%d errno:%d\n",
1513 type, err, errno);
1514 }
1515
1516 fds64[i] = fd64;
1517 sk_cookies[i] = sk_cookie;
1518 }
1519}
1520
1521static void test_reuseport_array(void)
1522{
1523#define REUSEPORT_FD_IDX(err, last) ({ (err) ? last : !last; })
1524
1525 const __u32 array_size = 4, index0 = 0, index3 = 3;
1526 int types[2] = { SOCK_STREAM, SOCK_DGRAM }, type;
1527 __u64 grpa_cookies[2], sk_cookie, map_cookie;
1528 __s64 grpa_fds64[2] = { -1, -1 }, fd64 = -1;
1529 const __u32 bad_index = array_size;
1530 int map_fd, err, t, f;
1531 __u32 fds_idx = 0;
1532 int fd;
1533
1534 map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1535 sizeof(__u32), sizeof(__u64), array_size, 0);
1536 CHECK(map_fd == -1, "reuseport array create",
1537 "map_fd:%d, errno:%d\n", map_fd, errno);
1538
1539
1540 err = bpf_map_delete_elem(map_fd, &bad_index);
1541 CHECK(err != -1 || errno != E2BIG, "reuseport array del >=max_entries",
1542 "err:%d errno:%d\n", err, errno);
1543
1544 err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);
1545 CHECK(err != -1 || errno != E2BIG,
1546 "reuseport array update >=max_entries",
1547 "err:%d errno:%d\n", err, errno);
1548
1549 err = bpf_map_lookup_elem(map_fd, &bad_index, &map_cookie);
1550 CHECK(err != -1 || errno != ENOENT,
1551 "reuseport array update >=max_entries",
1552 "err:%d errno:%d\n", err, errno);
1553
1554
1555 err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1556 CHECK(err != -1 || errno != ENOENT,
1557 "reuseport array lookup not-exist elem",
1558 "err:%d errno:%d\n", err, errno);
1559 err = bpf_map_delete_elem(map_fd, &index3);
1560 CHECK(err != -1 || errno != ENOENT,
1561 "reuseport array del not-exist elem",
1562 "err:%d errno:%d\n", err, errno);
1563
1564 for (t = 0; t < ARRAY_SIZE(types); t++) {
1565 type = types[t];
1566
1567 prepare_reuseport_grp(type, map_fd, sizeof(__u64), grpa_fds64,
1568 grpa_cookies, ARRAY_SIZE(grpa_fds64));
1569
1570
1571
1572 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1573 BPF_EXIST);
1574 CHECK(err != -1 || errno != ENOENT,
1575 "reuseport array update empty elem BPF_EXIST",
1576 "sock_type:%d err:%d errno:%d\n",
1577 type, err, errno);
1578 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1579
1580
1581 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1582 BPF_NOEXIST);
1583 CHECK(err == -1,
1584 "reuseport array update empty elem BPF_NOEXIST",
1585 "sock_type:%d err:%d errno:%d\n",
1586 type, err, errno);
1587 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1588
1589
1590 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1591 BPF_EXIST);
1592 CHECK(err == -1,
1593 "reuseport array update same elem BPF_EXIST",
1594 "sock_type:%d err:%d errno:%d\n", type, err, errno);
1595 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1596
1597
1598 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1599 BPF_NOEXIST);
1600 CHECK(err != -1 || errno != EEXIST,
1601 "reuseport array update non-empty elem BPF_NOEXIST",
1602 "sock_type:%d err:%d errno:%d\n",
1603 type, err, errno);
1604 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1605
1606
1607 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1608 BPF_ANY);
1609 CHECK(err == -1,
1610 "reuseport array update same sk with BPF_ANY",
1611 "sock_type:%d err:%d errno:%d\n", type, err, errno);
1612
1613 fd64 = grpa_fds64[fds_idx];
1614 sk_cookie = grpa_cookies[fds_idx];
1615
1616
1617 err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);
1618 CHECK(err != -1 || errno != EBUSY,
1619 "reuseport array update same sk with same index",
1620 "sock_type:%d err:%d errno:%d\n",
1621 type, err, errno);
1622
1623 err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);
1624 CHECK(err != -1 || errno != EBUSY,
1625 "reuseport array update same sk with different index",
1626 "sock_type:%d err:%d errno:%d\n",
1627 type, err, errno);
1628
1629
1630 err = bpf_map_delete_elem(map_fd, &index3);
1631 CHECK(err == -1, "reuseport array delete sk",
1632 "sock_type:%d err:%d errno:%d\n",
1633 type, err, errno);
1634
1635
1636 err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1637 CHECK(err == -1,
1638 "reuseport array re-add with BPF_NOEXIST after del",
1639 "sock_type:%d err:%d errno:%d\n", type, err, errno);
1640
1641
1642 err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1643 CHECK(err == -1 || sk_cookie != map_cookie,
1644 "reuseport array lookup re-added sk",
1645 "sock_type:%d err:%d errno:%d sk_cookie:0x%llx map_cookie:0x%llxn",
1646 type, err, errno, sk_cookie, map_cookie);
1647
1648
1649 for (f = 0; f < ARRAY_SIZE(grpa_fds64); f++)
1650 close(grpa_fds64[f]);
1651 err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1652 CHECK(err != -1 || errno != ENOENT,
1653 "reuseport array lookup after close()",
1654 "sock_type:%d err:%d errno:%d\n",
1655 type, err, errno);
1656 }
1657
1658
1659 fd64 = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP);
1660 CHECK(fd64 == -1, "socket(SOCK_RAW)", "err:%d errno:%d\n",
1661 err, errno);
1662 err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1663 CHECK(err != -1 || errno != ENOTSUPP, "reuseport array update SOCK_RAW",
1664 "err:%d errno:%d\n", err, errno);
1665 close(fd64);
1666
1667
1668 close(map_fd);
1669
1670
1671 map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1672 sizeof(__u32), sizeof(__u32), array_size, 0);
1673 CHECK(map_fd == -1, "reuseport array create",
1674 "map_fd:%d, errno:%d\n", map_fd, errno);
1675 prepare_reuseport_grp(SOCK_STREAM, map_fd, sizeof(__u32), &fd64,
1676 &sk_cookie, 1);
1677 fd = fd64;
1678 err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);
1679 CHECK(err == -1, "reuseport array update 32 bit fd",
1680 "err:%d errno:%d\n", err, errno);
1681 err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1682 CHECK(err != -1 || errno != ENOSPC,
1683 "reuseport array lookup 32 bit fd",
1684 "err:%d errno:%d\n", err, errno);
1685 close(fd);
1686 close(map_fd);
1687}
1688
1689static void run_all_tests(void)
1690{
1691 test_hashmap(0, NULL);
1692 test_hashmap_percpu(0, NULL);
1693 test_hashmap_walk(0, NULL);
1694 test_hashmap_zero_seed();
1695
1696 test_arraymap(0, NULL);
1697 test_arraymap_percpu(0, NULL);
1698
1699 test_arraymap_percpu_many_keys();
1700
1701 test_devmap(0, NULL);
1702 test_devmap_hash(0, NULL);
1703 test_sockmap(0, NULL);
1704
1705 test_map_large();
1706 test_map_parallel();
1707 test_map_stress();
1708
1709 test_map_rdonly();
1710 test_map_wronly();
1711
1712 test_reuseport_array();
1713
1714 test_queuemap(0, NULL);
1715 test_stackmap(0, NULL);
1716
1717 test_map_in_map();
1718}
1719
1720#define DECLARE
1721#include <map_tests/tests.h>
1722#undef DECLARE
1723
1724int main(void)
1725{
1726 srand(time(NULL));
1727
1728 map_flags = 0;
1729 run_all_tests();
1730
1731 map_flags = BPF_F_NO_PREALLOC;
1732 run_all_tests();
1733
1734#define CALL
1735#include <map_tests/tests.h>
1736#undef CALL
1737
1738 printf("test_maps: OK, %d SKIPPED\n", skips);
1739 return 0;
1740}
1741
