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