1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Testsuite for eBPF maps
4  *
5  * Copyright (c) 2014 PLUMgrid, http://plumgrid.com
6  * Copyright (c) 2016 Facebook
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 
33 static int skips;
34 
35 static int map_flags;
36 
37 static 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 	/* Insert key=1 element. */
52 	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
53 
54 	value = 0;
55 	/* BPF_NOEXIST means add new element if it doesn't exist. */
56 	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
57 	       /* key=1 already exists. */
58 	       errno == EEXIST);
59 
60 	/* -1 is an invalid flag. */
61 	assert(bpf_map_update_elem(fd, &key, &value, -1) == -1 &&
62 	       errno == EINVAL);
63 
64 	/* Check that key=1 can be found. */
65 	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
66 
67 	key = 2;
68 	/* Check that key=2 is not found. */
69 	assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
70 
71 	/* BPF_EXIST means update existing element. */
72 	assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
73 	       /* key=2 is not there. */
74 	       errno == ENOENT);
75 
76 	/* Insert key=2 element. */
77 	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
78 
79 	/* key=1 and key=2 were inserted, check that key=0 cannot be
80 	 * inserted due to max_entries limit.
81 	 */
82 	key = 0;
83 	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
84 	       errno == E2BIG);
85 
86 	/* Update existing element, though the map is full. */
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 	/* Check that key = 0 doesn't exist. */
96 	key = 0;
97 	assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
98 
99 	/* Iterate over two elements. */
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 	/* Delete both elements. */
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 	/* Check that map is empty. */
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 
127 static 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); /* give kernel time to destroy */
144 		}
145 }
146 
147 static 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 	/* Insert key=1 element. */
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 	/* BPF_NOEXIST means add new element if it doesn't exist. */
172 	assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
173 	       /* key=1 already exists. */
174 	       errno == EEXIST);
175 
176 	/* -1 is an invalid flag. */
177 	assert(bpf_map_update_elem(fd, &key, value, -1) == -1 &&
178 	       errno == EINVAL);
179 
180 	/* Check that key=1 can be found. Value could be 0 if the lookup
181 	 * was run from a different CPU.
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 	/* Check that key=2 is not found. */
189 	assert(bpf_map_lookup_elem(fd, &key, value) == -1 && errno == ENOENT);
190 
191 	/* BPF_EXIST means update existing element. */
192 	assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == -1 &&
193 	       /* key=2 is not there. */
194 	       errno == ENOENT);
195 
196 	/* Insert key=2 element. */
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 	/* key=1 and key=2 were inserted, check that key=0 cannot be
202 	 * inserted due to max_entries limit.
203 	 */
204 	key = 0;
205 	assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
206 	       errno == E2BIG);
207 
208 	/* Check that key = 0 doesn't exist. */
209 	assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
210 
211 	/* Iterate over two elements. */
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 	/* Update with BPF_EXIST. */
232 	key = 1;
233 	assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);
234 
235 	/* Delete both elements. */
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 	/* Check that map is empty. */
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 
252 static 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 
274 static 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 
312 static 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 
345 static 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 	/* Insert key=1 element. */
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 	/* Check that key=1 can be found. */
367 	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
368 
369 	key = 0;
370 	/* Check that key=0 is also found and zero initialized. */
371 	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
372 
373 	/* key=0 and key=1 were inserted, check that key=2 cannot be inserted
374 	 * due to max_entries limit.
375 	 */
376 	key = 2;
377 	assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
378 	       errno == E2BIG);
379 
380 	/* Check that key = 2 doesn't exist. */
381 	assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
382 
383 	/* Iterate over two elements. */
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 	/* Delete shouldn't succeed. */
394 	key = 1;
395 	assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
396 
397 	close(fd);
398 }
399 
400 static 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 	/* Insert key=1 element. */
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 	/* Check that key=1 can be found. */
425 	assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
426 	       bpf_percpu(values, 0) == 100);
427 
428 	key = 0;
429 	/* Check that key=0 is also found and zero initialized. */
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 	/* Check that key=2 cannot be inserted due to max_entries limit. */
435 	key = 2;
436 	assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) == -1 &&
437 	       errno == E2BIG);
438 
439 	/* Check that key = 2 doesn't exist. */
440 	assert(bpf_map_lookup_elem(fd, &key, values) == -1 && errno == ENOENT);
441 
442 	/* Iterate over two elements. */
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 	/* Delete shouldn't succeed. */
453 	key = 1;
454 	assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
455 
456 	close(fd);
457 }
458 
459 static void test_arraymap_percpu_many_keys(void)
460 {
461 	unsigned int nr_cpus = bpf_num_possible_cpus();
462 	BPF_DECLARE_PERCPU(long, values);
463 	/* nr_keys is not too large otherwise the test stresses percpu
464 	 * allocator more than anything else
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 
496 static 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 
511 static 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 
526 static 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 	/* Fill test values to be used */
533 	for (i = 0; i < MAP_SIZE + MAP_SIZE/2; i++)
534 		vals[i] = rand();
535 
536 	/* Invalid key size */
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 	/* Queue map does not support BPF_F_NO_PREALLOC */
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 	/* Push MAP_SIZE elements */
554 	for (i = 0; i < MAP_SIZE; i++)
555 		assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
556 
557 	/* Check that element cannot be pushed due to max_entries limit */
558 	assert(bpf_map_update_elem(fd, NULL, &val, 0) == -1 &&
559 	       errno == E2BIG);
560 
561 	/* Peek element */
562 	assert(bpf_map_lookup_elem(fd, NULL, &val) == 0 && val == vals[0]);
563 
564 	/* Replace half elements */
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 	/* Pop all elements */
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 	/* Check that there are not elements left */
574 	assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == -1 &&
575 	       errno == ENOENT);
576 
577 	/* Check that non supported functions set errno to EINVAL */
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 
584 static 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 	/* Fill test values to be used */
591 	for (i = 0; i < MAP_SIZE + MAP_SIZE/2; i++)
592 		vals[i] = rand();
593 
594 	/* Invalid key size */
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 	/* Stack map does not support BPF_F_NO_PREALLOC */
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 	/* Push MAP_SIZE elements */
612 	for (i = 0; i < MAP_SIZE; i++)
613 		assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
614 
615 	/* Check that element cannot be pushed due to max_entries limit */
616 	assert(bpf_map_update_elem(fd, NULL, &val, 0) == -1 &&
617 	       errno == E2BIG);
618 
619 	/* Peek element */
620 	assert(bpf_map_lookup_elem(fd, NULL, &val) == 0 && val == vals[i - 1]);
621 
622 	/* Replace half elements */
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 	/* Pop all elements */
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 	/* Check that there are not elements left */
632 	assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == -1 &&
633 	       errno == ENOENT);
634 
635 	/* Check that non supported functions set errno to EINVAL */
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"
649 static 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 	/* Create some sockets to use with sockmap */
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 	/* Test sockmap with connected sockets */
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 	/* Test update with unsupported UDP socket */
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 	/* Test update without programs */
757 	for (i = 0; i < 6; i++) {
758 		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
759 		if (err) {
760 			printf("Failed noprog update sockmap '%i:%i'\n",
761 			       i, sfd[i]);
762 			goto out_sockmap;
763 		}
764 	}
765 
766 	/* Test attaching/detaching bad fds */
767 	err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_PARSER, 0);
768 	if (!err) {
769 		printf("Failed invalid parser prog attach\n");
770 		goto out_sockmap;
771 	}
772 
773 	err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_VERDICT, 0);
774 	if (!err) {
775 		printf("Failed invalid verdict prog attach\n");
776 		goto out_sockmap;
777 	}
778 
779 	err = bpf_prog_attach(-1, fd, BPF_SK_MSG_VERDICT, 0);
780 	if (!err) {
781 		printf("Failed invalid msg verdict prog attach\n");
782 		goto out_sockmap;
783 	}
784 
785 	err = bpf_prog_attach(-1, fd, __MAX_BPF_ATTACH_TYPE, 0);
786 	if (!err) {
787 		printf("Failed unknown prog attach\n");
788 		goto out_sockmap;
789 	}
790 
791 	err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_PARSER);
792 	if (!err) {
793 		printf("Failed empty parser prog detach\n");
794 		goto out_sockmap;
795 	}
796 
797 	err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_VERDICT);
798 	if (!err) {
799 		printf("Failed empty verdict prog detach\n");
800 		goto out_sockmap;
801 	}
802 
803 	err = bpf_prog_detach(fd, BPF_SK_MSG_VERDICT);
804 	if (!err) {
805 		printf("Failed empty msg verdict prog detach\n");
806 		goto out_sockmap;
807 	}
808 
809 	err = bpf_prog_detach(fd, __MAX_BPF_ATTACH_TYPE);
810 	if (!err) {
811 		printf("Detach invalid prog successful\n");
812 		goto out_sockmap;
813 	}
814 
815 	/* Load SK_SKB program and Attach */
816 	err = bpf_prog_load(SOCKMAP_PARSE_PROG,
817 			    BPF_PROG_TYPE_SK_SKB, &obj, &parse_prog);
818 	if (err) {
819 		printf("Failed to load SK_SKB parse prog\n");
820 		goto out_sockmap;
821 	}
822 
823 	err = bpf_prog_load(SOCKMAP_TCP_MSG_PROG,
824 			    BPF_PROG_TYPE_SK_MSG, &obj, &msg_prog);
825 	if (err) {
826 		printf("Failed to load SK_SKB msg prog\n");
827 		goto out_sockmap;
828 	}
829 
830 	err = bpf_prog_load(SOCKMAP_VERDICT_PROG,
831 			    BPF_PROG_TYPE_SK_SKB, &obj, &verdict_prog);
832 	if (err) {
833 		printf("Failed to load SK_SKB verdict prog\n");
834 		goto out_sockmap;
835 	}
836 
837 	bpf_map_rx = bpf_object__find_map_by_name(obj, "sock_map_rx");
838 	if (IS_ERR(bpf_map_rx)) {
839 		printf("Failed to load map rx from verdict prog\n");
840 		goto out_sockmap;
841 	}
842 
843 	map_fd_rx = bpf_map__fd(bpf_map_rx);
844 	if (map_fd_rx < 0) {
845 		printf("Failed to get map rx fd\n");
846 		goto out_sockmap;
847 	}
848 
849 	bpf_map_tx = bpf_object__find_map_by_name(obj, "sock_map_tx");
850 	if (IS_ERR(bpf_map_tx)) {
851 		printf("Failed to load map tx from verdict prog\n");
852 		goto out_sockmap;
853 	}
854 
855 	map_fd_tx = bpf_map__fd(bpf_map_tx);
856 	if (map_fd_tx < 0) {
857 		printf("Failed to get map tx fd\n");
858 		goto out_sockmap;
859 	}
860 
861 	bpf_map_msg = bpf_object__find_map_by_name(obj, "sock_map_msg");
862 	if (IS_ERR(bpf_map_msg)) {
863 		printf("Failed to load map msg from msg_verdict prog\n");
864 		goto out_sockmap;
865 	}
866 
867 	map_fd_msg = bpf_map__fd(bpf_map_msg);
868 	if (map_fd_msg < 0) {
869 		printf("Failed to get map msg fd\n");
870 		goto out_sockmap;
871 	}
872 
873 	bpf_map_break = bpf_object__find_map_by_name(obj, "sock_map_break");
874 	if (IS_ERR(bpf_map_break)) {
875 		printf("Failed to load map tx from verdict prog\n");
876 		goto out_sockmap;
877 	}
878 
879 	map_fd_break = bpf_map__fd(bpf_map_break);
880 	if (map_fd_break < 0) {
881 		printf("Failed to get map tx fd\n");
882 		goto out_sockmap;
883 	}
884 
885 	err = bpf_prog_attach(parse_prog, map_fd_break,
886 			      BPF_SK_SKB_STREAM_PARSER, 0);
887 	if (!err) {
888 		printf("Allowed attaching SK_SKB program to invalid map\n");
889 		goto out_sockmap;
890 	}
891 
892 	err = bpf_prog_attach(parse_prog, map_fd_rx,
893 		      BPF_SK_SKB_STREAM_PARSER, 0);
894 	if (err) {
895 		printf("Failed stream parser bpf prog attach\n");
896 		goto out_sockmap;
897 	}
898 
899 	err = bpf_prog_attach(verdict_prog, map_fd_rx,
900 			      BPF_SK_SKB_STREAM_VERDICT, 0);
901 	if (err) {
902 		printf("Failed stream verdict bpf prog attach\n");
903 		goto out_sockmap;
904 	}
905 
906 	err = bpf_prog_attach(msg_prog, map_fd_msg, BPF_SK_MSG_VERDICT, 0);
907 	if (err) {
908 		printf("Failed msg verdict bpf prog attach\n");
909 		goto out_sockmap;
910 	}
911 
912 	err = bpf_prog_attach(verdict_prog, map_fd_rx,
913 			      __MAX_BPF_ATTACH_TYPE, 0);
914 	if (!err) {
915 		printf("Attached unknown bpf prog\n");
916 		goto out_sockmap;
917 	}
918 
919 	/* Test map update elem afterwards fd lives in fd and map_fd */
920 	for (i = 2; i < 6; i++) {
921 		err = bpf_map_update_elem(map_fd_rx, &i, &sfd[i], BPF_ANY);
922 		if (err) {
923 			printf("Failed map_fd_rx update sockmap %i '%i:%i'\n",
924 			       err, i, sfd[i]);
925 			goto out_sockmap;
926 		}
927 		err = bpf_map_update_elem(map_fd_tx, &i, &sfd[i], BPF_ANY);
928 		if (err) {
929 			printf("Failed map_fd_tx update sockmap %i '%i:%i'\n",
930 			       err, i, sfd[i]);
931 			goto out_sockmap;
932 		}
933 	}
934 
935 	/* Test map delete elem and remove send/recv sockets */
936 	for (i = 2; i < 4; i++) {
937 		err = bpf_map_delete_elem(map_fd_rx, &i);
938 		if (err) {
939 			printf("Failed delete sockmap rx %i '%i:%i'\n",
940 			       err, i, sfd[i]);
941 			goto out_sockmap;
942 		}
943 		err = bpf_map_delete_elem(map_fd_tx, &i);
944 		if (err) {
945 			printf("Failed delete sockmap tx %i '%i:%i'\n",
946 			       err, i, sfd[i]);
947 			goto out_sockmap;
948 		}
949 	}
950 
951 	/* Put sfd[2] (sending fd below) into msg map to test sendmsg bpf */
952 	i = 0;
953 	err = bpf_map_update_elem(map_fd_msg, &i, &sfd[2], BPF_ANY);
954 	if (err) {
955 		printf("Failed map_fd_msg update sockmap %i\n", err);
956 		goto out_sockmap;
957 	}
958 
959 	/* Test map send/recv */
960 	for (i = 0; i < 2; i++) {
961 		buf[0] = i;
962 		buf[1] = 0x5;
963 		sc = send(sfd[2], buf, 20, 0);
964 		if (sc < 0) {
965 			printf("Failed sockmap send\n");
966 			goto out_sockmap;
967 		}
968 
969 		FD_ZERO(&w);
970 		FD_SET(sfd[3], &w);
971 		to.tv_sec = 1;
972 		to.tv_usec = 0;
973 		s = select(sfd[3] + 1, &w, NULL, NULL, &to);
974 		if (s == -1) {
975 			perror("Failed sockmap select()");
976 			goto out_sockmap;
977 		} else if (!s) {
978 			printf("Failed sockmap unexpected timeout\n");
979 			goto out_sockmap;
980 		}
981 
982 		if (!FD_ISSET(sfd[3], &w)) {
983 			printf("Failed sockmap select/recv\n");
984 			goto out_sockmap;
985 		}
986 
987 		rc = recv(sfd[3], buf, sizeof(buf), 0);
988 		if (rc < 0) {
989 			printf("Failed sockmap recv\n");
990 			goto out_sockmap;
991 		}
992 	}
993 
994 	/* Negative null entry lookup from datapath should be dropped */
995 	buf[0] = 1;
996 	buf[1] = 12;
997 	sc = send(sfd[2], buf, 20, 0);
998 	if (sc < 0) {
999 		printf("Failed sockmap send\n");
1000 		goto out_sockmap;
1001 	}
1002 
1003 	/* Push fd into same slot */
1004 	i = 2;
1005 	err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1006 	if (!err) {
1007 		printf("Failed allowed sockmap dup slot BPF_NOEXIST\n");
1008 		goto out_sockmap;
1009 	}
1010 
1011 	err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1012 	if (err) {
1013 		printf("Failed sockmap update new slot BPF_ANY\n");
1014 		goto out_sockmap;
1015 	}
1016 
1017 	err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1018 	if (err) {
1019 		printf("Failed sockmap update new slot BPF_EXIST\n");
1020 		goto out_sockmap;
1021 	}
1022 
1023 	/* Delete the elems without programs */
1024 	for (i = 2; i < 6; i++) {
1025 		err = bpf_map_delete_elem(fd, &i);
1026 		if (err) {
1027 			printf("Failed delete sockmap %i '%i:%i'\n",
1028 			       err, i, sfd[i]);
1029 		}
1030 	}
1031 
1032 	/* Test having multiple maps open and set with programs on same fds */
1033 	err = bpf_prog_attach(parse_prog, fd,
1034 			      BPF_SK_SKB_STREAM_PARSER, 0);
1035 	if (err) {
1036 		printf("Failed fd bpf parse prog attach\n");
1037 		goto out_sockmap;
1038 	}
1039 	err = bpf_prog_attach(verdict_prog, fd,
1040 			      BPF_SK_SKB_STREAM_VERDICT, 0);
1041 	if (err) {
1042 		printf("Failed fd bpf verdict prog attach\n");
1043 		goto out_sockmap;
1044 	}
1045 
1046 	for (i = 4; i < 6; i++) {
1047 		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1048 		if (!err) {
1049 			printf("Failed allowed duplicate programs in update ANY sockmap %i '%i:%i'\n",
1050 			       err, i, sfd[i]);
1051 			goto out_sockmap;
1052 		}
1053 		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1054 		if (!err) {
1055 			printf("Failed allowed duplicate program in update NOEXIST sockmap  %i '%i:%i'\n",
1056 			       err, i, sfd[i]);
1057 			goto out_sockmap;
1058 		}
1059 		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1060 		if (!err) {
1061 			printf("Failed allowed duplicate program in update EXIST sockmap  %i '%i:%i'\n",
1062 			       err, i, sfd[i]);
1063 			goto out_sockmap;
1064 		}
1065 	}
1066 
1067 	/* Test tasks number of forked operations */
1068 	for (i = 0; i < tasks; i++) {
1069 		pid[i] = fork();
1070 		if (pid[i] == 0) {
1071 			for (i = 0; i < 6; i++) {
1072 				bpf_map_delete_elem(map_fd_tx, &i);
1073 				bpf_map_delete_elem(map_fd_rx, &i);
1074 				bpf_map_update_elem(map_fd_tx, &i,
1075 						    &sfd[i], BPF_ANY);
1076 				bpf_map_update_elem(map_fd_rx, &i,
1077 						    &sfd[i], BPF_ANY);
1078 			}
1079 			exit(0);
1080 		} else if (pid[i] == -1) {
1081 			printf("Couldn't spawn #%d process!\n", i);
1082 			exit(1);
1083 		}
1084 	}
1085 
1086 	for (i = 0; i < tasks; i++) {
1087 		int status;
1088 
1089 		assert(waitpid(pid[i], &status, 0) == pid[i]);
1090 		assert(status == 0);
1091 	}
1092 
1093 	err = bpf_prog_detach2(parse_prog, map_fd_rx, __MAX_BPF_ATTACH_TYPE);
1094 	if (!err) {
1095 		printf("Detached an invalid prog type.\n");
1096 		goto out_sockmap;
1097 	}
1098 
1099 	err = bpf_prog_detach2(parse_prog, map_fd_rx, BPF_SK_SKB_STREAM_PARSER);
1100 	if (err) {
1101 		printf("Failed parser prog detach\n");
1102 		goto out_sockmap;
1103 	}
1104 
1105 	err = bpf_prog_detach2(verdict_prog, map_fd_rx, BPF_SK_SKB_STREAM_VERDICT);
1106 	if (err) {
1107 		printf("Failed parser prog detach\n");
1108 		goto out_sockmap;
1109 	}
1110 
1111 	/* Test map close sockets and empty maps */
1112 	for (i = 0; i < 6; i++) {
1113 		bpf_map_delete_elem(map_fd_tx, &i);
1114 		bpf_map_delete_elem(map_fd_rx, &i);
1115 		close(sfd[i]);
1116 	}
1117 	close(fd);
1118 	close(map_fd_rx);
1119 	bpf_object__close(obj);
1120 	return;
1121 out:
1122 	for (i = 0; i < 6; i++)
1123 		close(sfd[i]);
1124 	printf("Failed to create sockmap '%i:%s'!\n", i, strerror(errno));
1125 	exit(1);
1126 out_sockmap:
1127 	for (i = 0; i < 6; i++) {
1128 		if (map_fd_tx)
1129 			bpf_map_delete_elem(map_fd_tx, &i);
1130 		if (map_fd_rx)
1131 			bpf_map_delete_elem(map_fd_rx, &i);
1132 		close(sfd[i]);
1133 	}
1134 	close(fd);
1135 	exit(1);
1136 }
1137 
1138 #define MAPINMAP_PROG "./test_map_in_map.o"
1139 static void test_map_in_map(void)
1140 {
1141 	struct bpf_object *obj;
1142 	struct bpf_map *map;
1143 	int mim_fd, fd, err;
1144 	int pos = 0;
1145 
1146 	obj = bpf_object__open(MAPINMAP_PROG);
1147 
1148 	fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(int), sizeof(int),
1149 			    2, 0);
1150 	if (fd < 0) {
1151 		printf("Failed to create hashmap '%s'!\n", strerror(errno));
1152 		exit(1);
1153 	}
1154 
1155 	map = bpf_object__find_map_by_name(obj, "mim_array");
1156 	if (IS_ERR(map)) {
1157 		printf("Failed to load array of maps from test prog\n");
1158 		goto out_map_in_map;
1159 	}
1160 	err = bpf_map__set_inner_map_fd(map, fd);
1161 	if (err) {
1162 		printf("Failed to set inner_map_fd for array of maps\n");
1163 		goto out_map_in_map;
1164 	}
1165 
1166 	map = bpf_object__find_map_by_name(obj, "mim_hash");
1167 	if (IS_ERR(map)) {
1168 		printf("Failed to load hash of maps from test prog\n");
1169 		goto out_map_in_map;
1170 	}
1171 	err = bpf_map__set_inner_map_fd(map, fd);
1172 	if (err) {
1173 		printf("Failed to set inner_map_fd for hash of maps\n");
1174 		goto out_map_in_map;
1175 	}
1176 
1177 	bpf_object__load(obj);
1178 
1179 	map = bpf_object__find_map_by_name(obj, "mim_array");
1180 	if (IS_ERR(map)) {
1181 		printf("Failed to load array of maps from test prog\n");
1182 		goto out_map_in_map;
1183 	}
1184 	mim_fd = bpf_map__fd(map);
1185 	if (mim_fd < 0) {
1186 		printf("Failed to get descriptor for array of maps\n");
1187 		goto out_map_in_map;
1188 	}
1189 
1190 	err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);
1191 	if (err) {
1192 		printf("Failed to update array of maps\n");
1193 		goto out_map_in_map;
1194 	}
1195 
1196 	map = bpf_object__find_map_by_name(obj, "mim_hash");
1197 	if (IS_ERR(map)) {
1198 		printf("Failed to load hash of maps from test prog\n");
1199 		goto out_map_in_map;
1200 	}
1201 	mim_fd = bpf_map__fd(map);
1202 	if (mim_fd < 0) {
1203 		printf("Failed to get descriptor for hash of maps\n");
1204 		goto out_map_in_map;
1205 	}
1206 
1207 	err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);
1208 	if (err) {
1209 		printf("Failed to update hash of maps\n");
1210 		goto out_map_in_map;
1211 	}
1212 
1213 	close(fd);
1214 	bpf_object__close(obj);
1215 	return;
1216 
1217 out_map_in_map:
1218 	close(fd);
1219 	exit(1);
1220 }
1221 
1222 #define MAP_SIZE (32 * 1024)
1223 
1224 static void test_map_large(void)
1225 {
1226 
1227 	struct bigkey {
1228 		int a;
1229 		char b[4096];
1230 		long long c;
1231 	} key;
1232 	int fd, i, value;
1233 
1234 	fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1235 			    MAP_SIZE, map_flags);
1236 	if (fd < 0) {
1237 		printf("Failed to create large map '%s'!\n", strerror(errno));
1238 		exit(1);
1239 	}
1240 
1241 	for (i = 0; i < MAP_SIZE; i++) {
1242 		key = (struct bigkey) { .c = i };
1243 		value = i;
1244 
1245 		assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
1246 	}
1247 
1248 	key.c = -1;
1249 	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1250 	       errno == E2BIG);
1251 
1252 	/* Iterate through all elements. */
1253 	assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1254 	key.c = -1;
1255 	for (i = 0; i < MAP_SIZE; i++)
1256 		assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1257 	assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1258 
1259 	key.c = 0;
1260 	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
1261 	key.a = 1;
1262 	assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1263 
1264 	close(fd);
1265 }
1266 
1267 #define run_parallel(N, FN, DATA) \
1268 	printf("Fork %u tasks to '" #FN "'\n", N); \
1269 	__run_parallel(N, FN, DATA)
1270 
1271 static void __run_parallel(unsigned int tasks,
1272 			   void (*fn)(unsigned int task, void *data),
1273 			   void *data)
1274 {
1275 	pid_t pid[tasks];
1276 	int i;
1277 
1278 	fflush(stdout);
1279 
1280 	for (i = 0; i < tasks; i++) {
1281 		pid[i] = fork();
1282 		if (pid[i] == 0) {
1283 			fn(i, data);
1284 			exit(0);
1285 		} else if (pid[i] == -1) {
1286 			printf("Couldn't spawn #%d process!\n", i);
1287 			exit(1);
1288 		}
1289 	}
1290 
1291 	for (i = 0; i < tasks; i++) {
1292 		int status;
1293 
1294 		assert(waitpid(pid[i], &status, 0) == pid[i]);
1295 		assert(status == 0);
1296 	}
1297 }
1298 
1299 static void test_map_stress(void)
1300 {
1301 	run_parallel(100, test_hashmap, NULL);
1302 	run_parallel(100, test_hashmap_percpu, NULL);
1303 	run_parallel(100, test_hashmap_sizes, NULL);
1304 	run_parallel(100, test_hashmap_walk, NULL);
1305 
1306 	run_parallel(100, test_arraymap, NULL);
1307 	run_parallel(100, test_arraymap_percpu, NULL);
1308 }
1309 
1310 #define TASKS 1024
1311 
1312 #define DO_UPDATE 1
1313 #define DO_DELETE 0
1314 
1315 #define MAP_RETRIES 20
1316 
1317 static int map_update_retriable(int map_fd, const void *key, const void *value,
1318 				int flags, int attempts)
1319 {
1320 	while (bpf_map_update_elem(map_fd, key, value, flags)) {
1321 		if (!attempts || (errno != EAGAIN && errno != EBUSY))
1322 			return -errno;
1323 
1324 		usleep(1);
1325 		attempts--;
1326 	}
1327 
1328 	return 0;
1329 }
1330 
1331 static int map_delete_retriable(int map_fd, const void *key, int attempts)
1332 {
1333 	while (bpf_map_delete_elem(map_fd, key)) {
1334 		if (!attempts || (errno != EAGAIN && errno != EBUSY))
1335 			return -errno;
1336 
1337 		usleep(1);
1338 		attempts--;
1339 	}
1340 
1341 	return 0;
1342 }
1343 
1344 static void test_update_delete(unsigned int fn, void *data)
1345 {
1346 	int do_update = ((int *)data)[1];
1347 	int fd = ((int *)data)[0];
1348 	int i, key, value, err;
1349 
1350 	for (i = fn; i < MAP_SIZE; i += TASKS) {
1351 		key = value = i;
1352 
1353 		if (do_update) {
1354 			err = map_update_retriable(fd, &key, &value, BPF_NOEXIST, MAP_RETRIES);
1355 			if (err)
1356 				printf("error %d %d\n", err, errno);
1357 			assert(err == 0);
1358 			err = map_update_retriable(fd, &key, &value, BPF_EXIST, MAP_RETRIES);
1359 			if (err)
1360 				printf("error %d %d\n", err, errno);
1361 			assert(err == 0);
1362 		} else {
1363 			err = map_delete_retriable(fd, &key, MAP_RETRIES);
1364 			if (err)
1365 				printf("error %d %d\n", err, errno);
1366 			assert(err == 0);
1367 		}
1368 	}
1369 }
1370 
1371 static void test_map_parallel(void)
1372 {
1373 	int i, fd, key = 0, value = 0;
1374 	int data[2];
1375 
1376 	fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1377 			    MAP_SIZE, map_flags);
1378 	if (fd < 0) {
1379 		printf("Failed to create map for parallel test '%s'!\n",
1380 		       strerror(errno));
1381 		exit(1);
1382 	}
1383 
1384 	/* Use the same fd in children to add elements to this map:
1385 	 * child_0 adds key=0, key=1024, key=2048, ...
1386 	 * child_1 adds key=1, key=1025, key=2049, ...
1387 	 * child_1023 adds key=1023, ...
1388 	 */
1389 	data[0] = fd;
1390 	data[1] = DO_UPDATE;
1391 	run_parallel(TASKS, test_update_delete, data);
1392 
1393 	/* Check that key=0 is already there. */
1394 	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1395 	       errno == EEXIST);
1396 
1397 	/* Check that all elements were inserted. */
1398 	assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1399 	key = -1;
1400 	for (i = 0; i < MAP_SIZE; i++)
1401 		assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1402 	assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1403 
1404 	/* Another check for all elements */
1405 	for (i = 0; i < MAP_SIZE; i++) {
1406 		key = MAP_SIZE - i - 1;
1407 
1408 		assert(bpf_map_lookup_elem(fd, &key, &value) == 0 &&
1409 		       value == key);
1410 	}
1411 
1412 	/* Now let's delete all elemenets in parallel. */
1413 	data[1] = DO_DELETE;
1414 	run_parallel(TASKS, test_update_delete, data);
1415 
1416 	/* Nothing should be left. */
1417 	key = -1;
1418 	assert(bpf_map_get_next_key(fd, NULL, &key) == -1 && errno == ENOENT);
1419 	assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1420 }
1421 
1422 static void test_map_rdonly(void)
1423 {
1424 	int fd, key = 0, value = 0;
1425 
1426 	fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1427 			    MAP_SIZE, map_flags | BPF_F_RDONLY);
1428 	if (fd < 0) {
1429 		printf("Failed to create map for read only test '%s'!\n",
1430 		       strerror(errno));
1431 		exit(1);
1432 	}
1433 
1434 	key = 1;
1435 	value = 1234;
1436 	/* Try to insert key=1 element. */
1437 	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == -1 &&
1438 	       errno == EPERM);
1439 
1440 	/* Check that key=1 is not found. */
1441 	assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1442 	assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == ENOENT);
1443 
1444 	close(fd);
1445 }
1446 
1447 static void test_map_wronly_hash(void)
1448 {
1449 	int fd, key = 0, value = 0;
1450 
1451 	fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1452 			    MAP_SIZE, map_flags | BPF_F_WRONLY);
1453 	if (fd < 0) {
1454 		printf("Failed to create map for write only test '%s'!\n",
1455 		       strerror(errno));
1456 		exit(1);
1457 	}
1458 
1459 	key = 1;
1460 	value = 1234;
1461 	/* Insert key=1 element. */
1462 	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
1463 
1464 	/* Check that reading elements and keys from the map is not allowed. */
1465 	assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == EPERM);
1466 	assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == EPERM);
1467 
1468 	close(fd);
1469 }
1470 
1471 static void test_map_wronly_stack_or_queue(enum bpf_map_type map_type)
1472 {
1473 	int fd, value = 0;
1474 
1475 	assert(map_type == BPF_MAP_TYPE_QUEUE ||
1476 	       map_type == BPF_MAP_TYPE_STACK);
1477 	fd = bpf_create_map(map_type, 0, sizeof(value), MAP_SIZE,
1478 			    map_flags | BPF_F_WRONLY);
1479 	/* Stack/Queue maps do not support BPF_F_NO_PREALLOC */
1480 	if (map_flags & BPF_F_NO_PREALLOC) {
1481 		assert(fd < 0 && errno == EINVAL);
1482 		return;
1483 	}
1484 	if (fd < 0) {
1485 		printf("Failed to create map '%s'!\n", strerror(errno));
1486 		exit(1);
1487 	}
1488 
1489 	value = 1234;
1490 	assert(bpf_map_update_elem(fd, NULL, &value, BPF_ANY) == 0);
1491 
1492 	/* Peek element should fail */
1493 	assert(bpf_map_lookup_elem(fd, NULL, &value) == -1 && errno == EPERM);
1494 
1495 	/* Pop element should fail */
1496 	assert(bpf_map_lookup_and_delete_elem(fd, NULL, &value) == -1 &&
1497 	       errno == EPERM);
1498 
1499 	close(fd);
1500 }
1501 
1502 static void test_map_wronly(void)
1503 {
1504 	test_map_wronly_hash();
1505 	test_map_wronly_stack_or_queue(BPF_MAP_TYPE_STACK);
1506 	test_map_wronly_stack_or_queue(BPF_MAP_TYPE_QUEUE);
1507 }
1508 
1509 static void prepare_reuseport_grp(int type, int map_fd, size_t map_elem_size,
1510 				  __s64 *fds64, __u64 *sk_cookies,
1511 				  unsigned int n)
1512 {
1513 	socklen_t optlen, addrlen;
1514 	struct sockaddr_in6 s6;
1515 	const __u32 index0 = 0;
1516 	const int optval = 1;
1517 	unsigned int i;
1518 	u64 sk_cookie;
1519 	void *value;
1520 	__s32 fd32;
1521 	__s64 fd64;
1522 	int err;
1523 
1524 	s6.sin6_family = AF_INET6;
1525 	s6.sin6_addr = in6addr_any;
1526 	s6.sin6_port = 0;
1527 	addrlen = sizeof(s6);
1528 	optlen = sizeof(sk_cookie);
1529 
1530 	for (i = 0; i < n; i++) {
1531 		fd64 = socket(AF_INET6, type, 0);
1532 		CHECK(fd64 == -1, "socket()",
1533 		      "sock_type:%d fd64:%lld errno:%d\n",
1534 		      type, fd64, errno);
1535 
1536 		err = setsockopt(fd64, SOL_SOCKET, SO_REUSEPORT,
1537 				 &optval, sizeof(optval));
1538 		CHECK(err == -1, "setsockopt(SO_REUSEPORT)",
1539 		      "err:%d errno:%d\n", err, errno);
1540 
1541 		/* reuseport_array does not allow unbound sk */
1542 		if (map_elem_size == sizeof(__u64))
1543 			value = &fd64;
1544 		else {
1545 			assert(map_elem_size == sizeof(__u32));
1546 			fd32 = (__s32)fd64;
1547 			value = &fd32;
1548 		}
1549 		err = bpf_map_update_elem(map_fd, &index0, value, BPF_ANY);
1550 		CHECK(err != -1 || errno != EINVAL,
1551 		      "reuseport array update unbound sk",
1552 		      "sock_type:%d err:%d errno:%d\n",
1553 		      type, err, errno);
1554 
1555 		err = bind(fd64, (struct sockaddr *)&s6, sizeof(s6));
1556 		CHECK(err == -1, "bind()",
1557 		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1558 
1559 		if (i == 0) {
1560 			err = getsockname(fd64, (struct sockaddr *)&s6,
1561 					  &addrlen);
1562 			CHECK(err == -1, "getsockname()",
1563 			      "sock_type:%d err:%d errno:%d\n",
1564 			      type, err, errno);
1565 		}
1566 
1567 		err = getsockopt(fd64, SOL_SOCKET, SO_COOKIE, &sk_cookie,
1568 				 &optlen);
1569 		CHECK(err == -1, "getsockopt(SO_COOKIE)",
1570 		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1571 
1572 		if (type == SOCK_STREAM) {
1573 			/*
1574 			 * reuseport_array does not allow
1575 			 * non-listening tcp sk.
1576 			 */
1577 			err = bpf_map_update_elem(map_fd, &index0, value,
1578 						  BPF_ANY);
1579 			CHECK(err != -1 || errno != EINVAL,
1580 			      "reuseport array update non-listening sk",
1581 			      "sock_type:%d err:%d errno:%d\n",
1582 			      type, err, errno);
1583 			err = listen(fd64, 0);
1584 			CHECK(err == -1, "listen()",
1585 			      "sock_type:%d, err:%d errno:%d\n",
1586 			      type, err, errno);
1587 		}
1588 
1589 		fds64[i] = fd64;
1590 		sk_cookies[i] = sk_cookie;
1591 	}
1592 }
1593 
1594 static void test_reuseport_array(void)
1595 {
1596 #define REUSEPORT_FD_IDX(err, last) ({ (err) ? last : !last; })
1597 
1598 	const __u32 array_size = 4, index0 = 0, index3 = 3;
1599 	int types[2] = { SOCK_STREAM, SOCK_DGRAM }, type;
1600 	__u64 grpa_cookies[2], sk_cookie, map_cookie;
1601 	__s64 grpa_fds64[2] = { -1, -1 }, fd64 = -1;
1602 	const __u32 bad_index = array_size;
1603 	int map_fd, err, t, f;
1604 	__u32 fds_idx = 0;
1605 	int fd;
1606 
1607 	map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1608 				sizeof(__u32), sizeof(__u64), array_size, 0);
1609 	CHECK(map_fd == -1, "reuseport array create",
1610 	      "map_fd:%d, errno:%d\n", map_fd, errno);
1611 
1612 	/* Test lookup/update/delete with invalid index */
1613 	err = bpf_map_delete_elem(map_fd, &bad_index);
1614 	CHECK(err != -1 || errno != E2BIG, "reuseport array del >=max_entries",
1615 	      "err:%d errno:%d\n", err, errno);
1616 
1617 	err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);
1618 	CHECK(err != -1 || errno != E2BIG,
1619 	      "reuseport array update >=max_entries",
1620 	      "err:%d errno:%d\n", err, errno);
1621 
1622 	err = bpf_map_lookup_elem(map_fd, &bad_index, &map_cookie);
1623 	CHECK(err != -1 || errno != ENOENT,
1624 	      "reuseport array update >=max_entries",
1625 	      "err:%d errno:%d\n", err, errno);
1626 
1627 	/* Test lookup/delete non existence elem */
1628 	err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1629 	CHECK(err != -1 || errno != ENOENT,
1630 	      "reuseport array lookup not-exist elem",
1631 	      "err:%d errno:%d\n", err, errno);
1632 	err = bpf_map_delete_elem(map_fd, &index3);
1633 	CHECK(err != -1 || errno != ENOENT,
1634 	      "reuseport array del not-exist elem",
1635 	      "err:%d errno:%d\n", err, errno);
1636 
1637 	for (t = 0; t < ARRAY_SIZE(types); t++) {
1638 		type = types[t];
1639 
1640 		prepare_reuseport_grp(type, map_fd, sizeof(__u64), grpa_fds64,
1641 				      grpa_cookies, ARRAY_SIZE(grpa_fds64));
1642 
1643 		/* Test BPF_* update flags */
1644 		/* BPF_EXIST failure case */
1645 		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1646 					  BPF_EXIST);
1647 		CHECK(err != -1 || errno != ENOENT,
1648 		      "reuseport array update empty elem BPF_EXIST",
1649 		      "sock_type:%d err:%d errno:%d\n",
1650 		      type, err, errno);
1651 		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1652 
1653 		/* BPF_NOEXIST success case */
1654 		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1655 					  BPF_NOEXIST);
1656 		CHECK(err == -1,
1657 		      "reuseport array update empty elem BPF_NOEXIST",
1658 		      "sock_type:%d err:%d errno:%d\n",
1659 		      type, err, errno);
1660 		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1661 
1662 		/* BPF_EXIST success case. */
1663 		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1664 					  BPF_EXIST);
1665 		CHECK(err == -1,
1666 		      "reuseport array update same elem BPF_EXIST",
1667 		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1668 		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1669 
1670 		/* BPF_NOEXIST failure case */
1671 		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1672 					  BPF_NOEXIST);
1673 		CHECK(err != -1 || errno != EEXIST,
1674 		      "reuseport array update non-empty elem BPF_NOEXIST",
1675 		      "sock_type:%d err:%d errno:%d\n",
1676 		      type, err, errno);
1677 		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1678 
1679 		/* BPF_ANY case (always succeed) */
1680 		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1681 					  BPF_ANY);
1682 		CHECK(err == -1,
1683 		      "reuseport array update same sk with BPF_ANY",
1684 		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1685 
1686 		fd64 = grpa_fds64[fds_idx];
1687 		sk_cookie = grpa_cookies[fds_idx];
1688 
1689 		/* The same sk cannot be added to reuseport_array twice */
1690 		err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);
1691 		CHECK(err != -1 || errno != EBUSY,
1692 		      "reuseport array update same sk with same index",
1693 		      "sock_type:%d err:%d errno:%d\n",
1694 		      type, err, errno);
1695 
1696 		err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);
1697 		CHECK(err != -1 || errno != EBUSY,
1698 		      "reuseport array update same sk with different index",
1699 		      "sock_type:%d err:%d errno:%d\n",
1700 		      type, err, errno);
1701 
1702 		/* Test delete elem */
1703 		err = bpf_map_delete_elem(map_fd, &index3);
1704 		CHECK(err == -1, "reuseport array delete sk",
1705 		      "sock_type:%d err:%d errno:%d\n",
1706 		      type, err, errno);
1707 
1708 		/* Add it back with BPF_NOEXIST */
1709 		err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1710 		CHECK(err == -1,
1711 		      "reuseport array re-add with BPF_NOEXIST after del",
1712 		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1713 
1714 		/* Test cookie */
1715 		err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1716 		CHECK(err == -1 || sk_cookie != map_cookie,
1717 		      "reuseport array lookup re-added sk",
1718 		      "sock_type:%d err:%d errno:%d sk_cookie:0x%llx map_cookie:0x%llxn",
1719 		      type, err, errno, sk_cookie, map_cookie);
1720 
1721 		/* Test elem removed by close() */
1722 		for (f = 0; f < ARRAY_SIZE(grpa_fds64); f++)
1723 			close(grpa_fds64[f]);
1724 		err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1725 		CHECK(err != -1 || errno != ENOENT,
1726 		      "reuseport array lookup after close()",
1727 		      "sock_type:%d err:%d errno:%d\n",
1728 		      type, err, errno);
1729 	}
1730 
1731 	/* Test SOCK_RAW */
1732 	fd64 = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP);
1733 	CHECK(fd64 == -1, "socket(SOCK_RAW)", "err:%d errno:%d\n",
1734 	      err, errno);
1735 	err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1736 	CHECK(err != -1 || errno != ENOTSUPP, "reuseport array update SOCK_RAW",
1737 	      "err:%d errno:%d\n", err, errno);
1738 	close(fd64);
1739 
1740 	/* Close the 64 bit value map */
1741 	close(map_fd);
1742 
1743 	/* Test 32 bit fd */
1744 	map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1745 				sizeof(__u32), sizeof(__u32), array_size, 0);
1746 	CHECK(map_fd == -1, "reuseport array create",
1747 	      "map_fd:%d, errno:%d\n", map_fd, errno);
1748 	prepare_reuseport_grp(SOCK_STREAM, map_fd, sizeof(__u32), &fd64,
1749 			      &sk_cookie, 1);
1750 	fd = fd64;
1751 	err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);
1752 	CHECK(err == -1, "reuseport array update 32 bit fd",
1753 	      "err:%d errno:%d\n", err, errno);
1754 	err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1755 	CHECK(err != -1 || errno != ENOSPC,
1756 	      "reuseport array lookup 32 bit fd",
1757 	      "err:%d errno:%d\n", err, errno);
1758 	close(fd);
1759 	close(map_fd);
1760 }
1761 
1762 static void run_all_tests(void)
1763 {
1764 	test_hashmap(0, NULL);
1765 	test_hashmap_percpu(0, NULL);
1766 	test_hashmap_walk(0, NULL);
1767 	test_hashmap_zero_seed();
1768 
1769 	test_arraymap(0, NULL);
1770 	test_arraymap_percpu(0, NULL);
1771 
1772 	test_arraymap_percpu_many_keys();
1773 
1774 	test_devmap(0, NULL);
1775 	test_devmap_hash(0, NULL);
1776 	test_sockmap(0, NULL);
1777 
1778 	test_map_large();
1779 	test_map_parallel();
1780 	test_map_stress();
1781 
1782 	test_map_rdonly();
1783 	test_map_wronly();
1784 
1785 	test_reuseport_array();
1786 
1787 	test_queuemap(0, NULL);
1788 	test_stackmap(0, NULL);
1789 
1790 	test_map_in_map();
1791 }
1792 
1793 #define DEFINE_TEST(name) extern void test_##name(void);
1794 #include <map_tests/tests.h>
1795 #undef DEFINE_TEST
1796 
1797 int main(void)
1798 {
1799 	srand(time(NULL));
1800 
1801 	map_flags = 0;
1802 	run_all_tests();
1803 
1804 	map_flags = BPF_F_NO_PREALLOC;
1805 	run_all_tests();
1806 
1807 #define DEFINE_TEST(name) test_##name();
1808 #include <map_tests/tests.h>
1809 #undef DEFINE_TEST
1810 
1811 	printf("test_maps: OK, %d SKIPPED\n", skips);
1812 	return 0;
1813 }
1814