test_maps.c

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