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;
 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;
 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 retry_for_again_or_busy(int err)
 
1400{
1401	return (err == EAGAIN || err == EBUSY);
1402}
1403
1404int map_update_retriable(int map_fd, const void *key, const void *value, int flags, int attempts,
1405			 retry_for_error_fn need_retry)
1406{
1407	int delay = rand() % MIN_DELAY_RANGE_US;
1408
1409	while (bpf_map_update_elem(map_fd, key, value, flags)) {
1410		if (!attempts || !need_retry(errno))
1411			return -errno;
1412
1413		if (delay <= MAX_DELAY_US / 2)
1414			delay *= 2;
1415
1416		usleep(delay);
1417		attempts--;
1418	}
1419
1420	return 0;
1421}
1422
1423static int map_delete_retriable(int map_fd, const void *key, int attempts)
1424{
1425	int delay = rand() % MIN_DELAY_RANGE_US;
1426
1427	while (bpf_map_delete_elem(map_fd, key)) {
1428		if (!attempts || (errno != EAGAIN && errno != EBUSY))
1429			return -errno;
1430
1431		if (delay <= MAX_DELAY_US / 2)
1432			delay *= 2;
1433
1434		usleep(delay);
1435		attempts--;
1436	}
1437
1438	return 0;
1439}
1440
1441static void test_update_delete(unsigned int fn, void *data)
1442{
1443	int do_update = ((int *)data)[1];
1444	int fd = ((int *)data)[0];
1445	int i, key, value, err;
1446
1447	if (fn & 1)
1448		test_hashmap_walk(fn, NULL);
1449	for (i = fn; i < MAP_SIZE; i += TASKS) {
1450		key = value = i;
1451
1452		if (do_update) {
1453			err = map_update_retriable(fd, &key, &value, BPF_NOEXIST, MAP_RETRIES,
1454						   retry_for_again_or_busy);
1455			if (err)
1456				printf("error %d %d\n", err, errno);
1457			assert(err == 0);
1458			err = map_update_retriable(fd, &key, &value, BPF_EXIST, MAP_RETRIES,
1459						   retry_for_again_or_busy);
1460			if (err)
1461				printf("error %d %d\n", err, errno);
1462			assert(err == 0);
1463		} else {
1464			err = map_delete_retriable(fd, &key, MAP_RETRIES);
1465			if (err)
1466				printf("error %d %d\n", err, errno);
1467			assert(err == 0);
1468		}
1469	}
1470}
1471
1472static void test_map_parallel(void)
1473{
1474	int i, fd, key = 0, value = 0, j = 0;
1475	int data[2];
1476
1477	fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(key), sizeof(value),
1478			    MAP_SIZE, &map_opts);
1479	if (fd < 0) {
1480		printf("Failed to create map for parallel test '%s'!\n",
1481		       strerror(errno));
1482		exit(1);
1483	}
1484
1485again:
1486	/* Use the same fd in children to add elements to this map:
1487	 * child_0 adds key=0, key=1024, key=2048, ...
1488	 * child_1 adds key=1, key=1025, key=2049, ...
1489	 * child_1023 adds key=1023, ...
1490	 */
1491	data[0] = fd;
1492	data[1] = DO_UPDATE;
1493	run_parallel(TASKS, test_update_delete, data);
1494
1495	/* Check that key=0 is already there. */
1496	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
1497	       errno == EEXIST);
1498
1499	/* Check that all elements were inserted. */
1500	assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1501	key = -1;
1502	for (i = 0; i < MAP_SIZE; i++)
1503		assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1504	assert(bpf_map_get_next_key(fd, &key, &key) < 0 && errno == ENOENT);
1505
1506	/* Another check for all elements */
1507	for (i = 0; i < MAP_SIZE; i++) {
1508		key = MAP_SIZE - i - 1;
1509
1510		assert(bpf_map_lookup_elem(fd, &key, &value) == 0 &&
1511		       value == key);
1512	}
1513
1514	/* Now let's delete all elements in parallel. */
1515	data[1] = DO_DELETE;
1516	run_parallel(TASKS, test_update_delete, data);
1517
1518	/* Nothing should be left. */
1519	key = -1;
1520	assert(bpf_map_get_next_key(fd, NULL, &key) < 0 && errno == ENOENT);
1521	assert(bpf_map_get_next_key(fd, &key, &key) < 0 && errno == ENOENT);
1522
1523	key = 0;
1524	bpf_map_delete_elem(fd, &key);
1525	if (j++ < 5)
1526		goto again;
1527	close(fd);
1528}
1529
1530static void test_map_rdonly(void)
1531{
1532	int fd, key = 0, value = 0;
1533	__u32 old_flags;
1534
1535	old_flags = map_opts.map_flags;
1536	map_opts.map_flags |= BPF_F_RDONLY;
1537	fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(key), sizeof(value),
1538			    MAP_SIZE, &map_opts);
1539	map_opts.map_flags = old_flags;
1540	if (fd < 0) {
1541		printf("Failed to create map for read only test '%s'!\n",
1542		       strerror(errno));
1543		exit(1);
1544	}
1545
1546	key = 1;
1547	value = 1234;
1548	/* Try to insert key=1 element. */
1549	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) < 0 &&
1550	       errno == EPERM);
1551
1552	/* Check that key=1 is not found. */
1553	assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
1554	assert(bpf_map_get_next_key(fd, &key, &value) < 0 && errno == ENOENT);
1555
1556	close(fd);
1557}
1558
1559static void test_map_wronly_hash(void)
1560{
1561	int fd, key = 0, value = 0;
1562	__u32 old_flags;
1563
1564	old_flags = map_opts.map_flags;
1565	map_opts.map_flags |= BPF_F_WRONLY;
1566	fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(key), sizeof(value),
1567			    MAP_SIZE, &map_opts);
1568	map_opts.map_flags = old_flags;
1569	if (fd < 0) {
1570		printf("Failed to create map for write only test '%s'!\n",
1571		       strerror(errno));
1572		exit(1);
1573	}
1574
1575	key = 1;
1576	value = 1234;
1577	/* Insert key=1 element. */
1578	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
1579
1580	/* Check that reading elements and keys from the map is not allowed. */
1581	assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == EPERM);
1582	assert(bpf_map_get_next_key(fd, &key, &value) < 0 && errno == EPERM);
1583
1584	close(fd);
1585}
1586
1587static void test_map_wronly_stack_or_queue(enum bpf_map_type map_type)
1588{
1589	int fd, value = 0;
1590	__u32 old_flags;
1591
1592
1593	assert(map_type == BPF_MAP_TYPE_QUEUE ||
1594	       map_type == BPF_MAP_TYPE_STACK);
1595	old_flags = map_opts.map_flags;
1596	map_opts.map_flags |= BPF_F_WRONLY;
1597	fd = bpf_map_create(map_type, NULL, 0, sizeof(value), MAP_SIZE, &map_opts);
1598	map_opts.map_flags = old_flags;
1599	/* Stack/Queue maps do not support BPF_F_NO_PREALLOC */
1600	if (map_opts.map_flags & BPF_F_NO_PREALLOC) {
1601		assert(fd < 0 && errno == EINVAL);
1602		return;
1603	}
1604	if (fd < 0) {
1605		printf("Failed to create map '%s'!\n", strerror(errno));
1606		exit(1);
1607	}
1608
1609	value = 1234;
1610	assert(bpf_map_update_elem(fd, NULL, &value, BPF_ANY) == 0);
1611
1612	/* Peek element should fail */
1613	assert(bpf_map_lookup_elem(fd, NULL, &value) < 0 && errno == EPERM);
1614
1615	/* Pop element should fail */
1616	assert(bpf_map_lookup_and_delete_elem(fd, NULL, &value) < 0 &&
1617	       errno == EPERM);
1618
1619	close(fd);
1620}
1621
1622static void test_map_wronly(void)
1623{
1624	test_map_wronly_hash();
1625	test_map_wronly_stack_or_queue(BPF_MAP_TYPE_STACK);
1626	test_map_wronly_stack_or_queue(BPF_MAP_TYPE_QUEUE);
1627}
1628
1629static void prepare_reuseport_grp(int type, int map_fd, size_t map_elem_size,
1630				  __s64 *fds64, __u64 *sk_cookies,
1631				  unsigned int n)
1632{
1633	socklen_t optlen, addrlen;
1634	struct sockaddr_in6 s6;
1635	const __u32 index0 = 0;
1636	const int optval = 1;
1637	unsigned int i;
1638	u64 sk_cookie;
1639	void *value;
1640	__s32 fd32;
1641	__s64 fd64;
1642	int err;
1643
1644	s6.sin6_family = AF_INET6;
1645	s6.sin6_addr = in6addr_any;
1646	s6.sin6_port = 0;
1647	addrlen = sizeof(s6);
1648	optlen = sizeof(sk_cookie);
1649
1650	for (i = 0; i < n; i++) {
1651		fd64 = socket(AF_INET6, type, 0);
1652		CHECK(fd64 == -1, "socket()",
1653		      "sock_type:%d fd64:%lld errno:%d\n",
1654		      type, fd64, errno);
1655
1656		err = setsockopt(fd64, SOL_SOCKET, SO_REUSEPORT,
1657				 &optval, sizeof(optval));
1658		CHECK(err == -1, "setsockopt(SO_REUSEPORT)",
1659		      "err:%d errno:%d\n", err, errno);
1660
1661		/* reuseport_array does not allow unbound sk */
1662		if (map_elem_size == sizeof(__u64))
1663			value = &fd64;
1664		else {
1665			assert(map_elem_size == sizeof(__u32));
1666			fd32 = (__s32)fd64;
1667			value = &fd32;
1668		}
1669		err = bpf_map_update_elem(map_fd, &index0, value, BPF_ANY);
1670		CHECK(err >= 0 || errno != EINVAL,
1671		      "reuseport array update unbound sk",
1672		      "sock_type:%d err:%d errno:%d\n",
1673		      type, err, errno);
1674
1675		err = bind(fd64, (struct sockaddr *)&s6, sizeof(s6));
1676		CHECK(err == -1, "bind()",
1677		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1678
1679		if (i == 0) {
1680			err = getsockname(fd64, (struct sockaddr *)&s6,
1681					  &addrlen);
1682			CHECK(err == -1, "getsockname()",
1683			      "sock_type:%d err:%d errno:%d\n",
1684			      type, err, errno);
1685		}
1686
1687		err = getsockopt(fd64, SOL_SOCKET, SO_COOKIE, &sk_cookie,
1688				 &optlen);
1689		CHECK(err == -1, "getsockopt(SO_COOKIE)",
1690		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1691
1692		if (type == SOCK_STREAM) {
1693			/*
1694			 * reuseport_array does not allow
1695			 * non-listening tcp sk.
1696			 */
1697			err = bpf_map_update_elem(map_fd, &index0, value,
1698						  BPF_ANY);
1699			CHECK(err >= 0 || errno != EINVAL,
1700			      "reuseport array update non-listening sk",
1701			      "sock_type:%d err:%d errno:%d\n",
1702			      type, err, errno);
1703			err = listen(fd64, 0);
1704			CHECK(err == -1, "listen()",
1705			      "sock_type:%d, err:%d errno:%d\n",
1706			      type, err, errno);
1707		}
1708
1709		fds64[i] = fd64;
1710		sk_cookies[i] = sk_cookie;
1711	}
1712}
1713
1714static void test_reuseport_array(void)
1715{
1716#define REUSEPORT_FD_IDX(err, last) ({ (err) ? last : !last; })
1717
1718	const __u32 array_size = 4, index0 = 0, index3 = 3;
1719	int types[2] = { SOCK_STREAM, SOCK_DGRAM }, type;
1720	__u64 grpa_cookies[2], sk_cookie, map_cookie;
1721	__s64 grpa_fds64[2] = { -1, -1 }, fd64 = -1;
1722	const __u32 bad_index = array_size;
1723	int map_fd, err, t, f;
1724	__u32 fds_idx = 0;
1725	int fd;
1726
1727	map_fd = bpf_map_create(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, NULL,
1728				sizeof(__u32), sizeof(__u64), array_size, NULL);
1729	CHECK(map_fd < 0, "reuseport array create",
1730	      "map_fd:%d, errno:%d\n", map_fd, errno);
1731
1732	/* Test lookup/update/delete with invalid index */
1733	err = bpf_map_delete_elem(map_fd, &bad_index);
1734	CHECK(err >= 0 || errno != E2BIG, "reuseport array del >=max_entries",
1735	      "err:%d errno:%d\n", err, errno);
1736
1737	err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);
1738	CHECK(err >= 0 || errno != E2BIG,
1739	      "reuseport array update >=max_entries",
1740	      "err:%d errno:%d\n", err, errno);
1741
1742	err = bpf_map_lookup_elem(map_fd, &bad_index, &map_cookie);
1743	CHECK(err >= 0 || errno != ENOENT,
1744	      "reuseport array update >=max_entries",
1745	      "err:%d errno:%d\n", err, errno);
1746
1747	/* Test lookup/delete non existence elem */
1748	err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1749	CHECK(err >= 0 || errno != ENOENT,
1750	      "reuseport array lookup not-exist elem",
1751	      "err:%d errno:%d\n", err, errno);
1752	err = bpf_map_delete_elem(map_fd, &index3);
1753	CHECK(err >= 0 || errno != ENOENT,
1754	      "reuseport array del not-exist elem",
1755	      "err:%d errno:%d\n", err, errno);
1756
1757	for (t = 0; t < ARRAY_SIZE(types); t++) {
1758		type = types[t];
1759
1760		prepare_reuseport_grp(type, map_fd, sizeof(__u64), grpa_fds64,
1761				      grpa_cookies, ARRAY_SIZE(grpa_fds64));
1762
1763		/* Test BPF_* update flags */
1764		/* BPF_EXIST failure case */
1765		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1766					  BPF_EXIST);
1767		CHECK(err >= 0 || errno != ENOENT,
1768		      "reuseport array update empty elem BPF_EXIST",
1769		      "sock_type:%d err:%d errno:%d\n",
1770		      type, err, errno);
1771		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1772
1773		/* BPF_NOEXIST success case */
1774		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1775					  BPF_NOEXIST);
1776		CHECK(err < 0,
1777		      "reuseport array update empty elem BPF_NOEXIST",
1778		      "sock_type:%d err:%d errno:%d\n",
1779		      type, err, errno);
1780		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1781
1782		/* BPF_EXIST success case. */
1783		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1784					  BPF_EXIST);
1785		CHECK(err < 0,
1786		      "reuseport array update same elem BPF_EXIST",
1787		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1788		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1789
1790		/* BPF_NOEXIST failure case */
1791		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1792					  BPF_NOEXIST);
1793		CHECK(err >= 0 || errno != EEXIST,
1794		      "reuseport array update non-empty elem BPF_NOEXIST",
1795		      "sock_type:%d err:%d errno:%d\n",
1796		      type, err, errno);
1797		fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1798
1799		/* BPF_ANY case (always succeed) */
1800		err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1801					  BPF_ANY);
1802		CHECK(err < 0,
1803		      "reuseport array update same sk with BPF_ANY",
1804		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1805
1806		fd64 = grpa_fds64[fds_idx];
1807		sk_cookie = grpa_cookies[fds_idx];
1808
1809		/* The same sk cannot be added to reuseport_array twice */
1810		err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);
1811		CHECK(err >= 0 || errno != EBUSY,
1812		      "reuseport array update same sk with same index",
1813		      "sock_type:%d err:%d errno:%d\n",
1814		      type, err, errno);
1815
1816		err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);
1817		CHECK(err >= 0 || errno != EBUSY,
1818		      "reuseport array update same sk with different index",
1819		      "sock_type:%d err:%d errno:%d\n",
1820		      type, err, errno);
1821
1822		/* Test delete elem */
1823		err = bpf_map_delete_elem(map_fd, &index3);
1824		CHECK(err < 0, "reuseport array delete sk",
1825		      "sock_type:%d err:%d errno:%d\n",
1826		      type, err, errno);
1827
1828		/* Add it back with BPF_NOEXIST */
1829		err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1830		CHECK(err < 0,
1831		      "reuseport array re-add with BPF_NOEXIST after del",
1832		      "sock_type:%d err:%d errno:%d\n", type, err, errno);
1833
1834		/* Test cookie */
1835		err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1836		CHECK(err < 0 || sk_cookie != map_cookie,
1837		      "reuseport array lookup re-added sk",
1838		      "sock_type:%d err:%d errno:%d sk_cookie:0x%llx map_cookie:0x%llxn",
1839		      type, err, errno, sk_cookie, map_cookie);
1840
1841		/* Test elem removed by close() */
1842		for (f = 0; f < ARRAY_SIZE(grpa_fds64); f++)
1843			close(grpa_fds64[f]);
1844		err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1845		CHECK(err >= 0 || errno != ENOENT,
1846		      "reuseport array lookup after close()",
1847		      "sock_type:%d err:%d errno:%d\n",
1848		      type, err, errno);
1849	}
1850
1851	/* Test SOCK_RAW */
1852	fd64 = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP);
1853	CHECK(fd64 == -1, "socket(SOCK_RAW)", "err:%d errno:%d\n",
1854	      err, errno);
1855	err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1856	CHECK(err >= 0 || errno != ENOTSUPP, "reuseport array update SOCK_RAW",
1857	      "err:%d errno:%d\n", err, errno);
1858	close(fd64);
1859
1860	/* Close the 64 bit value map */
1861	close(map_fd);
1862
1863	/* Test 32 bit fd */
1864	map_fd = bpf_map_create(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, NULL,
1865				sizeof(__u32), sizeof(__u32), array_size, NULL);
1866	CHECK(map_fd < 0, "reuseport array create",
1867	      "map_fd:%d, errno:%d\n", map_fd, errno);
1868	prepare_reuseport_grp(SOCK_STREAM, map_fd, sizeof(__u32), &fd64,
1869			      &sk_cookie, 1);
1870	fd = fd64;
1871	err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);
1872	CHECK(err < 0, "reuseport array update 32 bit fd",
1873	      "err:%d errno:%d\n", err, errno);
1874	err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1875	CHECK(err >= 0 || errno != ENOSPC,
1876	      "reuseport array lookup 32 bit fd",
1877	      "err:%d errno:%d\n", err, errno);
1878	close(fd);
1879	close(map_fd);
1880}
1881
1882static void run_all_tests(void)
1883{
1884	test_hashmap(0, NULL);
1885	test_hashmap_percpu(0, NULL);
1886	test_hashmap_walk(0, NULL);
1887	test_hashmap_zero_seed();
1888
1889	test_arraymap(0, NULL);
1890	test_arraymap_percpu(0, NULL);
1891
1892	test_arraymap_percpu_many_keys();
1893
1894	test_devmap(0, NULL);
1895	test_devmap_hash(0, NULL);
1896	test_sockmap(0, NULL);
1897
1898	test_map_large();
1899	test_map_parallel();
1900	test_map_stress();
1901
1902	test_map_rdonly();
1903	test_map_wronly();
1904
1905	test_reuseport_array();
1906
1907	test_queuemap(0, NULL);
1908	test_stackmap(0, NULL);
1909
1910	test_map_in_map();
1911}
1912
1913#define DEFINE_TEST(name) extern void test_##name(void);
1914#include <map_tests/tests.h>
1915#undef DEFINE_TEST
1916
1917int main(void)
1918{
1919	srand(time(NULL));
1920
1921	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
1922
1923	map_opts.map_flags = 0;
1924	run_all_tests();
1925
1926	map_opts.map_flags = BPF_F_NO_PREALLOC;
1927	run_all_tests();
1928
1929#define DEFINE_TEST(name) test_##name();
1930#include <map_tests/tests.h>
1931#undef DEFINE_TEST
1932
1933	printf("test_maps: OK, %d SKIPPED\n", skips);
1934	return 0;
1935}