1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Testsuite for eBPF maps
   4 *
   5 * Copyright (c) 2014 PLUMgrid, http://plumgrid.com
   6 * Copyright (c) 2016 Facebook
   7 */
   8
   9#include <stdio.h>
  10#include <unistd.h>
  11#include <errno.h>
  12#include <string.h>
  13#include <assert.h>
  14#include <stdlib.h>
  15#include <time.h>
  16
  17#include <sys/wait.h>
  18#include <sys/socket.h>
  19#include <netinet/in.h>
  20#include <linux/bpf.h>
  21
  22#include <bpf/bpf.h>
  23#include <bpf/libbpf.h>
  24
  25#include "bpf_util.h"
 
  26#include "test_maps.h"
  27#include "testing_helpers.h"
  28
  29#ifndef ENOTSUPP
  30#define ENOTSUPP 524
  31#endif
  32
  33int skips;
  34
  35static struct bpf_map_create_opts map_opts = { .sz = sizeof(map_opts) };
  36
  37static void test_hashmap(unsigned int task, void *data)
  38{
  39	long long key, next_key, first_key, value;
  40	int fd;
  41
  42	fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(key), sizeof(value), 2, &map_opts);
 
  43	if (fd < 0) {
  44		printf("Failed to create hashmap '%s'!\n", strerror(errno));
  45		exit(1);
  46	}
  47
  48	key = 1;
  49	value = 1234;
  50	/* Insert key=1 element. */
  51	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
  52
  53	value = 0;
  54	/* BPF_NOEXIST means add new element if it doesn't exist. */
  55	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
  56	       /* key=1 already exists. */
  57	       errno == EEXIST);
  58
  59	/* -1 is an invalid flag. */
  60	assert(bpf_map_update_elem(fd, &key, &value, -1) < 0 &&
  61	       errno == EINVAL);
  62
  63	/* Check that key=1 can be found. */
  64	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
  65
  66	key = 2;
  67	value = 1234;
  68	/* Insert key=2 element. */
  69	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
  70
  71	/* Check that key=2 matches the value and delete it */
  72	assert(bpf_map_lookup_and_delete_elem(fd, &key, &value) == 0 && value == 1234);
  73
  74	/* Check that key=2 is not found. */
  75	assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
  76
  77	/* BPF_EXIST means update existing element. */
  78	assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) < 0 &&
  79	       /* key=2 is not there. */
  80	       errno == ENOENT);
  81
  82	/* Insert key=2 element. */
  83	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
  84
  85	/* key=1 and key=2 were inserted, check that key=0 cannot be
  86	 * inserted due to max_entries limit.
  87	 */
  88	key = 0;
  89	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
  90	       errno == E2BIG);
  91
  92	/* Update existing element, though the map is full. */
  93	key = 1;
  94	assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == 0);
  95	key = 2;
  96	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
  97	key = 3;
  98	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
  99	       errno == E2BIG);
 100
 101	/* Check that key = 0 doesn't exist. */
 102	key = 0;
 103	assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
 104
 105	/* Iterate over two elements. */
 106	assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
 107	       (first_key == 1 || first_key == 2));
 108	assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
 109	       (next_key == first_key));
 110	assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
 111	       (next_key == 1 || next_key == 2) &&
 112	       (next_key != first_key));
 113	assert(bpf_map_get_next_key(fd, &next_key, &next_key) < 0 &&
 114	       errno == ENOENT);
 115
 116	/* Delete both elements. */
 117	key = 1;
 118	assert(bpf_map_delete_elem(fd, &key) == 0);
 119	key = 2;
 120	assert(bpf_map_delete_elem(fd, &key) == 0);
 121	assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
 122
 123	key = 0;
 124	/* Check that map is empty. */
 125	assert(bpf_map_get_next_key(fd, NULL, &next_key) < 0 &&
 126	       errno == ENOENT);
 127	assert(bpf_map_get_next_key(fd, &key, &next_key) < 0 &&
 128	       errno == ENOENT);
 129
 130	close(fd);
 131}
 132
 133static void test_hashmap_sizes(unsigned int task, void *data)
 134{
 135	int fd, i, j;
 136
 137	for (i = 1; i <= 512; i <<= 1)
 138		for (j = 1; j <= 1 << 18; j <<= 1) {
 139			fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, i, j, 2, &map_opts);
 
 140			if (fd < 0) {
 141				if (errno == ENOMEM)
 142					return;
 143				printf("Failed to create hashmap key=%d value=%d '%s'\n",
 144				       i, j, strerror(errno));
 145				exit(1);
 146			}
 147			close(fd);
 148			usleep(10); /* give kernel time to destroy */
 149		}
 150}
 151
 152static void test_hashmap_percpu(unsigned int task, void *data)
 153{
 154	unsigned int nr_cpus = bpf_num_possible_cpus();
 155	BPF_DECLARE_PERCPU(long, value);
 156	long long key, next_key, first_key;
 157	int expected_key_mask = 0;
 158	int fd, i;
 159
 160	fd = bpf_map_create(BPF_MAP_TYPE_PERCPU_HASH, NULL, sizeof(key),
 161			    sizeof(bpf_percpu(value, 0)), 2, &map_opts);
 162	if (fd < 0) {
 163		printf("Failed to create hashmap '%s'!\n", strerror(errno));
 164		exit(1);
 165	}
 166
 167	for (i = 0; i < nr_cpus; i++)
 168		bpf_percpu(value, i) = i + 100;
 169
 170	key = 1;
 171	/* Insert key=1 element. */
 172	assert(!(expected_key_mask & key));
 173	assert(bpf_map_update_elem(fd, &key, value, BPF_ANY) == 0);
 174
 175	/* Lookup and delete elem key=1 and check value. */
 176	assert(bpf_map_lookup_and_delete_elem(fd, &key, value) == 0 &&
 177	       bpf_percpu(value,0) == 100);
 178
 179	for (i = 0; i < nr_cpus; i++)
 180		bpf_percpu(value,i) = i + 100;
 181
 182	/* Insert key=1 element which should not exist. */
 183	assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == 0);
 184	expected_key_mask |= key;
 185
 186	/* BPF_NOEXIST means add new element if it doesn't exist. */
 187	assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) < 0 &&
 188	       /* key=1 already exists. */
 189	       errno == EEXIST);
 190
 191	/* -1 is an invalid flag. */
 192	assert(bpf_map_update_elem(fd, &key, value, -1) < 0 &&
 193	       errno == EINVAL);
 194
 195	/* Check that key=1 can be found. Value could be 0 if the lookup
 196	 * was run from a different CPU.
 197	 */
 198	bpf_percpu(value, 0) = 1;
 199	assert(bpf_map_lookup_elem(fd, &key, value) == 0 &&
 200	       bpf_percpu(value, 0) == 100);
 201
 202	key = 2;
 203	/* Check that key=2 is not found. */
 204	assert(bpf_map_lookup_elem(fd, &key, value) < 0 && errno == ENOENT);
 205
 206	/* BPF_EXIST means update existing element. */
 207	assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) < 0 &&
 208	       /* key=2 is not there. */
 209	       errno == ENOENT);
 210
 211	/* Insert key=2 element. */
 212	assert(!(expected_key_mask & key));
 213	assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == 0);
 214	expected_key_mask |= key;
 215
 216	/* key=1 and key=2 were inserted, check that key=0 cannot be
 217	 * inserted due to max_entries limit.
 218	 */
 219	key = 0;
 220	assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) < 0 &&
 221	       errno == E2BIG);
 222
 223	/* Check that key = 0 doesn't exist. */
 224	assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
 225
 226	/* Iterate over two elements. */
 227	assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
 228	       ((expected_key_mask & first_key) == first_key));
 229	while (!bpf_map_get_next_key(fd, &key, &next_key)) {
 230		if (first_key) {
 231			assert(next_key == first_key);
 232			first_key = 0;
 233		}
 234		assert((expected_key_mask & next_key) == next_key);
 235		expected_key_mask &= ~next_key;
 236
 237		assert(bpf_map_lookup_elem(fd, &next_key, value) == 0);
 238
 239		for (i = 0; i < nr_cpus; i++)
 240			assert(bpf_percpu(value, i) == i + 100);
 241
 242		key = next_key;
 243	}
 244	assert(errno == ENOENT);
 245
 246	/* Update with BPF_EXIST. */
 247	key = 1;
 248	assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);
 249
 250	/* Delete both elements. */
 251	key = 1;
 252	assert(bpf_map_delete_elem(fd, &key) == 0);
 253	key = 2;
 254	assert(bpf_map_delete_elem(fd, &key) == 0);
 255	assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
 256
 257	key = 0;
 258	/* Check that map is empty. */
 259	assert(bpf_map_get_next_key(fd, NULL, &next_key) < 0 &&
 260	       errno == ENOENT);
 261	assert(bpf_map_get_next_key(fd, &key, &next_key) < 0 &&
 262	       errno == ENOENT);
 263
 264	close(fd);
 265}
 266
 267#define VALUE_SIZE 3
 268static int helper_fill_hashmap(int max_entries)
 269{
 270	int i, fd, ret;
 271	long long key, value[VALUE_SIZE] = {};
 272
 273	fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(key), sizeof(value),
 274			    max_entries, &map_opts);
 275	CHECK(fd < 0,
 276	      "failed to create hashmap",
 277	      "err: %s, flags: 0x%x\n", strerror(errno), map_opts.map_flags);
 278
 279	for (i = 0; i < max_entries; i++) {
 280		key = i; value[0] = key;
 281		ret = bpf_map_update_elem(fd, &key, value, BPF_NOEXIST);
 282		CHECK(ret != 0,
 283		      "can't update hashmap",
 284		      "err: %s\n", strerror(ret));
 285	}
 286
 287	return fd;
 288}
 289
 290static void test_hashmap_walk(unsigned int task, void *data)
 291{
 292	int fd, i, max_entries = 10000;
 293	long long key, value[VALUE_SIZE], next_key;
 294	bool next_key_valid = true;
 295
 296	fd = helper_fill_hashmap(max_entries);
 297
 298	for (i = 0; bpf_map_get_next_key(fd, !i ? NULL : &key,
 299					 &next_key) == 0; i++) {
 300		key = next_key;
 301		assert(bpf_map_lookup_elem(fd, &key, value) == 0);
 302	}
 303
 304	assert(i == max_entries);
 305
 306	assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
 307	for (i = 0; next_key_valid; i++) {
 308		next_key_valid = bpf_map_get_next_key(fd, &key, &next_key) == 0;
 309		assert(bpf_map_lookup_elem(fd, &key, value) == 0);
 310		value[0]++;
 311		assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);
 312		key = next_key;
 313	}
 314
 315	assert(i == max_entries);
 316
 317	for (i = 0; bpf_map_get_next_key(fd, !i ? NULL : &key,
 318					 &next_key) == 0; i++) {
 319		key = next_key;
 320		assert(bpf_map_lookup_elem(fd, &key, value) == 0);
 321		assert(value[0] - 1 == key);
 322	}
 323
 324	assert(i == max_entries);
 325	close(fd);
 326}
 327
 328static void test_hashmap_zero_seed(void)
 329{
 330	int i, first, second, old_flags;
 331	long long key, next_first, next_second;
 332
 333	old_flags = map_opts.map_flags;
 334	map_opts.map_flags |= BPF_F_ZERO_SEED;
 335
 336	first = helper_fill_hashmap(3);
 337	second = helper_fill_hashmap(3);
 338
 339	for (i = 0; ; i++) {
 340		void *key_ptr = !i ? NULL : &key;
 341
 342		if (bpf_map_get_next_key(first, key_ptr, &next_first) != 0)
 343			break;
 344
 345		CHECK(bpf_map_get_next_key(second, key_ptr, &next_second) != 0,
 346		      "next_key for second map must succeed",
 347		      "key_ptr: %p", key_ptr);
 348		CHECK(next_first != next_second,
 349		      "keys must match",
 350		      "i: %d first: %lld second: %lld\n", i,
 351		      next_first, next_second);
 352
 353		key = next_first;
 354	}
 355
 356	map_opts.map_flags = old_flags;
 357	close(first);
 358	close(second);
 359}
 360
 361static void test_arraymap(unsigned int task, void *data)
 362{
 363	int key, next_key, fd;
 364	long long value;
 365
 366	fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, sizeof(key), sizeof(value), 2, NULL);
 
 367	if (fd < 0) {
 368		printf("Failed to create arraymap '%s'!\n", strerror(errno));
 369		exit(1);
 370	}
 371
 372	key = 1;
 373	value = 1234;
 374	/* Insert key=1 element. */
 375	assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
 376
 377	value = 0;
 378	assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
 379	       errno == EEXIST);
 380
 381	/* Check that key=1 can be found. */
 382	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
 383
 384	key = 0;
 385	/* Check that key=0 is also found and zero initialized. */
 386	assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
 387
 388	/* key=0 and key=1 were inserted, check that key=2 cannot be inserted
 389	 * due to max_entries limit.
 390	 */
 391	key = 2;
 392	assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) < 0 &&
 393	       errno == E2BIG);
 394
 395	/* Check that key = 2 doesn't exist. */
 396	assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
 397
 398	/* Iterate over two elements. */
 399	assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
 400	       next_key == 0);
 401	assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
 402	       next_key == 0);
 403	assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
 404	       next_key == 1);
 405	assert(bpf_map_get_next_key(fd, &next_key, &next_key) < 0 &&
 406	       errno == ENOENT);
 407
 408	/* Delete shouldn't succeed. */
 409	key = 1;
 410	assert(bpf_map_delete_elem(fd, &key) < 0 && errno == EINVAL);
 411
 412	close(fd);
 413}
 414
 415static void test_arraymap_percpu(unsigned int task, void *data)
 416{
 417	unsigned int nr_cpus = bpf_num_possible_cpus();
 418	BPF_DECLARE_PERCPU(long, values);
 419	int key, next_key, fd, i;
 420
 421	fd = bpf_map_create(BPF_MAP_TYPE_PERCPU_ARRAY, NULL, sizeof(key),
 422			    sizeof(bpf_percpu(values, 0)), 2, NULL);
 423	if (fd < 0) {
 424		printf("Failed to create arraymap '%s'!\n", strerror(errno));
 425		exit(1);
 426	}
 427
 428	for (i = 0; i < nr_cpus; i++)
 429		bpf_percpu(values, i) = i + 100;
 430
 431	key = 1;
 432	/* Insert key=1 element. */
 433	assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
 434
 435	bpf_percpu(values, 0) = 0;
 436	assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) < 0 &&
 437	       errno == EEXIST);
 438
 439	/* Check that key=1 can be found. */
 440	assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
 441	       bpf_percpu(values, 0) == 100);
 442
 443	key = 0;
 444	/* Check that key=0 is also found and zero initialized. */
 445	assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
 446	       bpf_percpu(values, 0) == 0 &&
 447	       bpf_percpu(values, nr_cpus - 1) == 0);
 448
 449	/* Check that key=2 cannot be inserted due to max_entries limit. */
 450	key = 2;
 451	assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) < 0 &&
 452	       errno == E2BIG);
 453
 454	/* Check that key = 2 doesn't exist. */
 455	assert(bpf_map_lookup_elem(fd, &key, values) < 0 && errno == ENOENT);
 456
 457	/* Iterate over two elements. */
 458	assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
 459	       next_key == 0);
 460	assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
 461	       next_key == 0);
 462	assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
 463	       next_key == 1);
 464	assert(bpf_map_get_next_key(fd, &next_key, &next_key) < 0 &&
 465	       errno == ENOENT);
 466
 467	/* Delete shouldn't succeed. */
 468	key = 1;
 469	assert(bpf_map_delete_elem(fd, &key) < 0 && errno == EINVAL);
 470
 471	close(fd);
 472}
 473
 474static void test_arraymap_percpu_many_keys(void)
 475{
 476	unsigned int nr_cpus = bpf_num_possible_cpus();
 477	BPF_DECLARE_PERCPU(long, values);
 478	/* nr_keys is not too large otherwise the test stresses percpu
 479	 * allocator more than anything else
 480	 */
 481	unsigned int nr_keys = 2000;
 482	int key, fd, i;
 483
 484	fd = bpf_map_create(BPF_MAP_TYPE_PERCPU_ARRAY, NULL, sizeof(key),
 485			    sizeof(bpf_percpu(values, 0)), nr_keys, NULL);
 486	if (fd < 0) {
 487		printf("Failed to create per-cpu arraymap '%s'!\n",
 488		       strerror(errno));
 489		exit(1);
 490	}
 491
 492	for (i = 0; i < nr_cpus; i++)
 493		bpf_percpu(values, i) = i + 10;
 494
 495	for (key = 0; key < nr_keys; key++)
 496		assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
 497
 498	for (key = 0; key < nr_keys; key++) {
 499		for (i = 0; i < nr_cpus; i++)
 500			bpf_percpu(values, i) = 0;
 501
 502		assert(bpf_map_lookup_elem(fd, &key, values) == 0);
 503
 504		for (i = 0; i < nr_cpus; i++)
 505			assert(bpf_percpu(values, i) == i + 10);
 506	}
 507
 508	close(fd);
 509}
 510
 511static void test_devmap(unsigned int task, void *data)
 512{
 513	int fd;
 514	__u32 key, value;
 515
 516	fd = bpf_map_create(BPF_MAP_TYPE_DEVMAP, NULL, sizeof(key), sizeof(value), 2, NULL);
 
 517	if (fd < 0) {
 518		printf("Failed to create devmap '%s'!\n", strerror(errno));
 519		exit(1);
 520	}
 521
 522	close(fd);
 523}
 524
 525static void test_devmap_hash(unsigned int task, void *data)
 526{
 527	int fd;
 528	__u32 key, value;
 529
 530	fd = bpf_map_create(BPF_MAP_TYPE_DEVMAP_HASH, NULL, sizeof(key), sizeof(value), 2, NULL);
 
 531	if (fd < 0) {
 532		printf("Failed to create devmap_hash '%s'!\n", strerror(errno));
 533		exit(1);
 534	}
 535
 536	close(fd);
 537}
 538
 539static void test_queuemap(unsigned int task, void *data)
 540{
 541	const int MAP_SIZE = 32;
 542	__u32 vals[MAP_SIZE + MAP_SIZE/2], val;
 543	int fd, i;
 544
 545	/* Fill test values to be used */
 546	for (i = 0; i < MAP_SIZE + MAP_SIZE/2; i++)
 547		vals[i] = rand();
 548
 549	/* Invalid key size */
 550	fd = bpf_map_create(BPF_MAP_TYPE_QUEUE, NULL, 4, sizeof(val), MAP_SIZE, &map_opts);
 
 551	assert(fd < 0 && errno == EINVAL);
 552
 553	fd = bpf_map_create(BPF_MAP_TYPE_QUEUE, NULL, 0, sizeof(val), MAP_SIZE, &map_opts);
 
 554	/* Queue map does not support BPF_F_NO_PREALLOC */
 555	if (map_opts.map_flags & BPF_F_NO_PREALLOC) {
 556		assert(fd < 0 && errno == EINVAL);
 557		return;
 558	}
 559	if (fd < 0) {
 560		printf("Failed to create queuemap '%s'!\n", strerror(errno));
 561		exit(1);
 562	}
 563
 564	/* Push MAP_SIZE elements */
 565	for (i = 0; i < MAP_SIZE; i++)
 566		assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
 567
 568	/* Check that element cannot be pushed due to max_entries limit */
 569	assert(bpf_map_update_elem(fd, NULL, &val, 0) < 0 &&
 570	       errno == E2BIG);
 571
 572	/* Peek element */
 573	assert(bpf_map_lookup_elem(fd, NULL, &val) == 0 && val == vals[0]);
 574
 575	/* Replace half elements */
 576	for (i = MAP_SIZE; i < MAP_SIZE + MAP_SIZE/2; i++)
 577		assert(bpf_map_update_elem(fd, NULL, &vals[i], BPF_EXIST) == 0);
 578
 579	/* Pop all elements */
 580	for (i = MAP_SIZE/2; i < MAP_SIZE + MAP_SIZE/2; i++)
 581		assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == 0 &&
 582		       val == vals[i]);
 583
 584	/* Check that there are not elements left */
 585	assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) < 0 &&
 586	       errno == ENOENT);
 587
 588	/* Check that non supported functions set errno to EINVAL */
 589	assert(bpf_map_delete_elem(fd, NULL) < 0 && errno == EINVAL);
 590	assert(bpf_map_get_next_key(fd, NULL, NULL) < 0 && errno == EINVAL);
 591
 592	close(fd);
 593}
 594
 595static void test_stackmap(unsigned int task, void *data)
 596{
 597	const int MAP_SIZE = 32;
 598	__u32 vals[MAP_SIZE + MAP_SIZE/2], val;
 599	int fd, i;
 600
 601	/* Fill test values to be used */
 602	for (i = 0; i < MAP_SIZE + MAP_SIZE/2; i++)
 603		vals[i] = rand();
 604
 605	/* Invalid key size */
 606	fd = bpf_map_create(BPF_MAP_TYPE_STACK, NULL, 4, sizeof(val), MAP_SIZE, &map_opts);
 
 607	assert(fd < 0 && errno == EINVAL);
 608
 609	fd = bpf_map_create(BPF_MAP_TYPE_STACK, NULL, 0, sizeof(val), MAP_SIZE, &map_opts);
 
 610	/* Stack map does not support BPF_F_NO_PREALLOC */
 611	if (map_opts.map_flags & BPF_F_NO_PREALLOC) {
 612		assert(fd < 0 && errno == EINVAL);
 613		return;
 614	}
 615	if (fd < 0) {
 616		printf("Failed to create stackmap '%s'!\n", strerror(errno));
 617		exit(1);
 618	}
 619
 620	/* Push MAP_SIZE elements */
 621	for (i = 0; i < MAP_SIZE; i++)
 622		assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
 623
 624	/* Check that element cannot be pushed due to max_entries limit */
 625	assert(bpf_map_update_elem(fd, NULL, &val, 0) < 0 &&
 626	       errno == E2BIG);
 627
 628	/* Peek element */
 629	assert(bpf_map_lookup_elem(fd, NULL, &val) == 0 && val == vals[i - 1]);
 630
 631	/* Replace half elements */
 632	for (i = MAP_SIZE; i < MAP_SIZE + MAP_SIZE/2; i++)
 633		assert(bpf_map_update_elem(fd, NULL, &vals[i], BPF_EXIST) == 0);
 634
 635	/* Pop all elements */
 636	for (i = MAP_SIZE + MAP_SIZE/2 - 1; i >= MAP_SIZE/2; i--)
 637		assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == 0 &&
 638		       val == vals[i]);
 639
 640	/* Check that there are not elements left */
 641	assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) < 0 &&
 642	       errno == ENOENT);
 643
 644	/* Check that non supported functions set errno to EINVAL */
 645	assert(bpf_map_delete_elem(fd, NULL) < 0 && errno == EINVAL);
 646	assert(bpf_map_get_next_key(fd, NULL, NULL) < 0 && errno == EINVAL);
 647
 648	close(fd);
 649}
 650
 651#include <sys/ioctl.h>
 652#include <arpa/inet.h>
 653#include <sys/select.h>
 654#include <linux/err.h>
 655#define SOCKMAP_PARSE_PROG "./sockmap_parse_prog.bpf.o"
 656#define SOCKMAP_VERDICT_PROG "./sockmap_verdict_prog.bpf.o"
 657#define SOCKMAP_TCP_MSG_PROG "./sockmap_tcp_msg_prog.bpf.o"
 658static void test_sockmap(unsigned int tasks, void *data)
 659{
 660	struct bpf_map *bpf_map_rx, *bpf_map_tx, *bpf_map_msg, *bpf_map_break;
 661	int map_fd_msg = 0, map_fd_rx = 0, map_fd_tx = 0, map_fd_break;
 662	struct bpf_object *parse_obj, *verdict_obj, *msg_obj;
 663	int ports[] = {50200, 50201, 50202, 50204};
 664	int err, i, fd, udp, sfd[6] = {0xdeadbeef};
 665	u8 buf[20] = {0x0, 0x5, 0x3, 0x2, 0x1, 0x0};
 666	int parse_prog, verdict_prog, msg_prog;
 667	struct sockaddr_in addr;
 668	int one = 1, s, sc, rc;
 
 669	struct timeval to;
 670	__u32 key, value;
 671	pid_t pid[tasks];
 672	fd_set w;
 673
 674	/* Create some sockets to use with sockmap */
 675	for (i = 0; i < 2; i++) {
 676		sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
 677		if (sfd[i] < 0)
 678			goto out;
 679		err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
 680				 (char *)&one, sizeof(one));
 681		if (err) {
 682			printf("failed to setsockopt\n");
 683			goto out;
 684		}
 685		err = ioctl(sfd[i], FIONBIO, (char *)&one);
 686		if (err < 0) {
 687			printf("failed to ioctl\n");
 688			goto out;
 689		}
 690		memset(&addr, 0, sizeof(struct sockaddr_in));
 691		addr.sin_family = AF_INET;
 692		addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 693		addr.sin_port = htons(ports[i]);
 694		err = bind(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
 695		if (err < 0) {
 696			printf("failed to bind: err %i: %i:%i\n",
 697			       err, i, sfd[i]);
 698			goto out;
 699		}
 700		err = listen(sfd[i], 32);
 701		if (err < 0) {
 702			printf("failed to listen\n");
 703			goto out;
 704		}
 705	}
 706
 707	for (i = 2; i < 4; i++) {
 708		sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
 709		if (sfd[i] < 0)
 710			goto out;
 711		err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
 712				 (char *)&one, sizeof(one));
 713		if (err) {
 714			printf("set sock opt\n");
 715			goto out;
 716		}
 717		memset(&addr, 0, sizeof(struct sockaddr_in));
 718		addr.sin_family = AF_INET;
 719		addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 720		addr.sin_port = htons(ports[i - 2]);
 721		err = connect(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
 722		if (err) {
 723			printf("failed to connect\n");
 724			goto out;
 725		}
 726	}
 727
 728
 729	for (i = 4; i < 6; i++) {
 730		sfd[i] = accept(sfd[i - 4], NULL, NULL);
 731		if (sfd[i] < 0) {
 732			printf("accept failed\n");
 733			goto out;
 734		}
 735	}
 736
 737	/* Test sockmap with connected sockets */
 738	fd = bpf_map_create(BPF_MAP_TYPE_SOCKMAP, NULL,
 739			    sizeof(key), sizeof(value),
 740			    6, NULL);
 741	if (fd < 0) {
 742		if (!libbpf_probe_bpf_map_type(BPF_MAP_TYPE_SOCKMAP, NULL)) {
 743			printf("%s SKIP (unsupported map type BPF_MAP_TYPE_SOCKMAP)\n",
 744			       __func__);
 745			skips++;
 746			for (i = 0; i < 6; i++)
 747				close(sfd[i]);
 748			return;
 749		}
 750
 751		printf("Failed to create sockmap %i\n", fd);
 752		goto out_sockmap;
 753	}
 754
 755	/* Test update with unsupported UDP socket */
 756	udp = socket(AF_INET, SOCK_DGRAM, 0);
 757	i = 0;
 758	err = bpf_map_update_elem(fd, &i, &udp, BPF_ANY);
 759	if (err) {
 760		printf("Failed socket update SOCK_DGRAM '%i:%i'\n",
 761		       i, udp);
 762		goto out_sockmap;
 763	}
 764	close(udp);
 765
 766	/* Test update without programs */
 767	for (i = 0; i < 6; i++) {
 768		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
 769		if (err) {
 770			printf("Failed noprog update sockmap '%i:%i'\n",
 771			       i, sfd[i]);
 772			goto out_sockmap;
 773		}
 774	}
 775
 776	/* Test attaching/detaching bad fds */
 777	err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_PARSER, 0);
 778	if (!err) {
 779		printf("Failed invalid parser prog attach\n");
 780		goto out_sockmap;
 781	}
 782
 783	err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_VERDICT, 0);
 784	if (!err) {
 785		printf("Failed invalid verdict prog attach\n");
 786		goto out_sockmap;
 787	}
 788
 789	err = bpf_prog_attach(-1, fd, BPF_SK_MSG_VERDICT, 0);
 790	if (!err) {
 791		printf("Failed invalid msg verdict prog attach\n");
 792		goto out_sockmap;
 793	}
 794
 795	err = bpf_prog_attach(-1, fd, __MAX_BPF_ATTACH_TYPE, 0);
 796	if (!err) {
 797		printf("Failed unknown prog attach\n");
 798		goto out_sockmap;
 799	}
 800
 801	err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_PARSER);
 802	if (!err) {
 803		printf("Failed empty parser prog detach\n");
 804		goto out_sockmap;
 805	}
 806
 807	err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_VERDICT);
 808	if (!err) {
 809		printf("Failed empty verdict prog detach\n");
 810		goto out_sockmap;
 811	}
 812
 813	err = bpf_prog_detach(fd, BPF_SK_MSG_VERDICT);
 814	if (!err) {
 815		printf("Failed empty msg verdict prog detach\n");
 816		goto out_sockmap;
 817	}
 818
 819	err = bpf_prog_detach(fd, __MAX_BPF_ATTACH_TYPE);
 820	if (!err) {
 821		printf("Detach invalid prog successful\n");
 822		goto out_sockmap;
 823	}
 824
 825	/* Load SK_SKB program and Attach */
 826	err = bpf_prog_test_load(SOCKMAP_PARSE_PROG,
 827			    BPF_PROG_TYPE_SK_SKB, &parse_obj, &parse_prog);
 828	if (err) {
 829		printf("Failed to load SK_SKB parse prog\n");
 830		goto out_sockmap;
 831	}
 832
 833	err = bpf_prog_test_load(SOCKMAP_TCP_MSG_PROG,
 834			    BPF_PROG_TYPE_SK_MSG, &msg_obj, &msg_prog);
 835	if (err) {
 836		printf("Failed to load SK_SKB msg prog\n");
 837		goto out_sockmap;
 838	}
 839
 840	err = bpf_prog_test_load(SOCKMAP_VERDICT_PROG,
 841			    BPF_PROG_TYPE_SK_SKB, &verdict_obj, &verdict_prog);
 842	if (err) {
 843		printf("Failed to load SK_SKB verdict prog\n");
 844		goto out_sockmap;
 845	}
 846
 847	bpf_map_rx = bpf_object__find_map_by_name(verdict_obj, "sock_map_rx");
 848	if (!bpf_map_rx) {
 849		printf("Failed to load map rx from verdict prog\n");
 850		goto out_sockmap;
 851	}
 852
 853	map_fd_rx = bpf_map__fd(bpf_map_rx);
 854	if (map_fd_rx < 0) {
 855		printf("Failed to get map rx fd\n");
 856		goto out_sockmap;
 857	}
 858
 859	bpf_map_tx = bpf_object__find_map_by_name(verdict_obj, "sock_map_tx");
 860	if (!bpf_map_tx) {
 861		printf("Failed to load map tx from verdict prog\n");
 862		goto out_sockmap;
 863	}
 864
 865	map_fd_tx = bpf_map__fd(bpf_map_tx);
 866	if (map_fd_tx < 0) {
 867		printf("Failed to get map tx fd\n");
 868		goto out_sockmap;
 869	}
 870
 871	bpf_map_msg = bpf_object__find_map_by_name(verdict_obj, "sock_map_msg");
 872	if (!bpf_map_msg) {
 873		printf("Failed to load map msg from msg_verdict prog\n");
 874		goto out_sockmap;
 875	}
 876
 877	map_fd_msg = bpf_map__fd(bpf_map_msg);
 878	if (map_fd_msg < 0) {
 879		printf("Failed to get map msg fd\n");
 880		goto out_sockmap;
 881	}
 882
 883	bpf_map_break = bpf_object__find_map_by_name(verdict_obj, "sock_map_break");
 884	if (!bpf_map_break) {
 885		printf("Failed to load map tx from verdict prog\n");
 886		goto out_sockmap;
 887	}
 888
 889	map_fd_break = bpf_map__fd(bpf_map_break);
 890	if (map_fd_break < 0) {
 891		printf("Failed to get map tx fd\n");
 892		goto out_sockmap;
 893	}
 894
 895	err = bpf_prog_attach(parse_prog, map_fd_break,
 896			      BPF_SK_SKB_STREAM_PARSER, 0);
 897	if (!err) {
 898		printf("Allowed attaching SK_SKB program to invalid map\n");
 899		goto out_sockmap;
 900	}
 901
 902	err = bpf_prog_attach(parse_prog, map_fd_rx,
 903		      BPF_SK_SKB_STREAM_PARSER, 0);
 904	if (err) {
 905		printf("Failed stream parser bpf prog attach\n");
 906		goto out_sockmap;
 907	}
 908
 909	err = bpf_prog_attach(verdict_prog, map_fd_rx,
 910			      BPF_SK_SKB_STREAM_VERDICT, 0);
 911	if (err) {
 912		printf("Failed stream verdict bpf prog attach\n");
 913		goto out_sockmap;
 914	}
 915
 916	err = bpf_prog_attach(msg_prog, map_fd_msg, BPF_SK_MSG_VERDICT, 0);
 917	if (err) {
 918		printf("Failed msg verdict bpf prog attach\n");
 919		goto out_sockmap;
 920	}
 921
 922	err = bpf_prog_attach(verdict_prog, map_fd_rx,
 923			      __MAX_BPF_ATTACH_TYPE, 0);
 924	if (!err) {
 925		printf("Attached unknown bpf prog\n");
 926		goto out_sockmap;
 927	}
 928
 929	/* Test map update elem afterwards fd lives in fd and map_fd */
 930	for (i = 2; i < 6; i++) {
 931		err = bpf_map_update_elem(map_fd_rx, &i, &sfd[i], BPF_ANY);
 932		if (err) {
 933			printf("Failed map_fd_rx update sockmap %i '%i:%i'\n",
 934			       err, i, sfd[i]);
 935			goto out_sockmap;
 936		}
 937		err = bpf_map_update_elem(map_fd_tx, &i, &sfd[i], BPF_ANY);
 938		if (err) {
 939			printf("Failed map_fd_tx update sockmap %i '%i:%i'\n",
 940			       err, i, sfd[i]);
 941			goto out_sockmap;
 942		}
 943	}
 944
 945	/* Test map delete elem and remove send/recv sockets */
 946	for (i = 2; i < 4; i++) {
 947		err = bpf_map_delete_elem(map_fd_rx, &i);
 948		if (err) {
 949			printf("Failed delete sockmap rx %i '%i:%i'\n",
 950			       err, i, sfd[i]);
 951			goto out_sockmap;
 952		}
 953		err = bpf_map_delete_elem(map_fd_tx, &i);
 954		if (err) {
 955			printf("Failed delete sockmap tx %i '%i:%i'\n",
 956			       err, i, sfd[i]);
 957			goto out_sockmap;
 958		}
 959	}
 960
 961	/* Put sfd[2] (sending fd below) into msg map to test sendmsg bpf */
 962	i = 0;
 963	err = bpf_map_update_elem(map_fd_msg, &i, &sfd[2], BPF_ANY);
 964	if (err) {
 965		printf("Failed map_fd_msg update sockmap %i\n", err);
 966		goto out_sockmap;
 967	}
 968
 969	/* Test map send/recv */
 970	for (i = 0; i < 2; i++) {
 971		buf[0] = i;
 972		buf[1] = 0x5;
 973		sc = send(sfd[2], buf, 20, 0);
 974		if (sc < 0) {
 975			printf("Failed sockmap send\n");
 976			goto out_sockmap;
 977		}
 978
 979		FD_ZERO(&w);
 980		FD_SET(sfd[3], &w);
 981		to.tv_sec = 30;
 982		to.tv_usec = 0;
 983		s = select(sfd[3] + 1, &w, NULL, NULL, &to);
 984		if (s == -1) {
 985			perror("Failed sockmap select()");
 986			goto out_sockmap;
 987		} else if (!s) {
 988			printf("Failed sockmap unexpected timeout\n");
 989			goto out_sockmap;
 990		}
 991
 992		if (!FD_ISSET(sfd[3], &w)) {
 993			printf("Failed sockmap select/recv\n");
 994			goto out_sockmap;
 995		}
 996
 997		rc = recv(sfd[3], buf, sizeof(buf), 0);
 998		if (rc < 0) {
 999			printf("Failed sockmap recv\n");
1000			goto out_sockmap;
1001		}
1002	}
1003
1004	/* Negative null entry lookup from datapath should be dropped */
1005	buf[0] = 1;
1006	buf[1] = 12;
1007	sc = send(sfd[2], buf, 20, 0);
1008	if (sc < 0) {
1009		printf("Failed sockmap send\n");
1010		goto out_sockmap;
1011	}
1012
1013	/* Push fd into same slot */
1014	i = 2;
1015	err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1016	if (!err) {
1017		printf("Failed allowed sockmap dup slot BPF_NOEXIST\n");
1018		goto out_sockmap;
1019	}
1020
1021	err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1022	if (err) {
1023		printf("Failed sockmap update new slot BPF_ANY\n");
1024		goto out_sockmap;
1025	}
1026
1027	err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1028	if (err) {
1029		printf("Failed sockmap update new slot BPF_EXIST\n");
1030		goto out_sockmap;
1031	}
1032
1033	/* Delete the elems without programs */
1034	for (i = 2; i < 6; i++) {
1035		err = bpf_map_delete_elem(fd, &i);
1036		if (err) {
1037			printf("Failed delete sockmap %i '%i:%i'\n",
1038			       err, i, sfd[i]);
1039		}
1040	}
1041
1042	/* Test having multiple maps open and set with programs on same fds */
1043	err = bpf_prog_attach(parse_prog, fd,
1044			      BPF_SK_SKB_STREAM_PARSER, 0);
1045	if (err) {
1046		printf("Failed fd bpf parse prog attach\n");
1047		goto out_sockmap;
1048	}
1049	err = bpf_prog_attach(verdict_prog, fd,
1050			      BPF_SK_SKB_STREAM_VERDICT, 0);
1051	if (err) {
1052		printf("Failed fd bpf verdict prog attach\n");
1053		goto out_sockmap;
1054	}
1055
1056	for (i = 4; i < 6; i++) {
1057		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1058		if (!err) {
1059			printf("Failed allowed duplicate programs in update ANY sockmap %i '%i:%i'\n",
1060			       err, i, sfd[i]);
1061			goto out_sockmap;
1062		}
1063		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1064		if (!err) {
1065			printf("Failed allowed duplicate program in update NOEXIST sockmap  %i '%i:%i'\n",
1066			       err, i, sfd[i]);
1067			goto out_sockmap;
1068		}
1069		err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1070		if (!err) {
1071			printf("Failed allowed duplicate program in update EXIST sockmap  %i '%i:%i'\n",
1072			       err, i, sfd[i]);
1073			goto out_sockmap;
1074		}
1075	}
1076
1077	/* Test tasks number of forked operations */
1078	for (i = 0; i < tasks; i++) {
1079		pid[i] = fork();
1080		if (pid[i] == 0) {
1081			for (i = 0; i < 6; i++) {
1082				bpf_map_delete_elem(map_fd_tx, &i);
1083				bpf_map_delete_elem(map_fd_rx, &i);
1084				bpf_map_update_elem(map_fd_tx, &i,
1085						    &sfd[i], BPF_ANY);
1086				bpf_map_update_elem(map_fd_rx, &i,
1087						    &sfd[i], BPF_ANY);
1088			}
1089			exit(0);
1090		} else if (pid[i] == -1) {
1091			printf("Couldn't spawn #%d process!\n", i);
1092			exit(1);
1093		}
1094	}
1095
1096	for (i = 0; i < tasks; i++) {
1097		int status;
1098
1099		assert(waitpid(pid[i], &status, 0) == pid[i]);
1100		assert(status == 0);
1101	}
1102
1103	err = bpf_prog_detach2(parse_prog, map_fd_rx, __MAX_BPF_ATTACH_TYPE);
1104	if (!err) {
1105		printf("Detached an invalid prog type.\n");
1106		goto out_sockmap;
1107	}
1108
1109	err = bpf_prog_detach2(parse_prog, map_fd_rx, BPF_SK_SKB_STREAM_PARSER);
1110	if (err) {
1111		printf("Failed parser prog detach\n");
1112		goto out_sockmap;
1113	}
1114
1115	err = bpf_prog_detach2(verdict_prog, map_fd_rx, BPF_SK_SKB_STREAM_VERDICT);
1116	if (err) {
1117		printf("Failed parser prog detach\n");
1118		goto out_sockmap;
1119	}
1120
1121	/* Test map close sockets and empty maps */
1122	for (i = 0; i < 6; i++) {
1123		bpf_map_delete_elem(map_fd_tx, &i);
1124		bpf_map_delete_elem(map_fd_rx, &i);
1125		close(sfd[i]);
1126	}
1127	close(fd);
1128	close(map_fd_rx);
1129	bpf_object__close(parse_obj);
1130	bpf_object__close(msg_obj);
1131	bpf_object__close(verdict_obj);
1132	return;
1133out:
1134	for (i = 0; i < 6; i++)
1135		close(sfd[i]);
1136	printf("Failed to create sockmap '%i:%s'!\n", i, strerror(errno));
1137	exit(1);
1138out_sockmap:
1139	for (i = 0; i < 6; i++) {
1140		if (map_fd_tx)
1141			bpf_map_delete_elem(map_fd_tx, &i);
1142		if (map_fd_rx)
1143			bpf_map_delete_elem(map_fd_rx, &i);
1144		close(sfd[i]);
1145	}
1146	close(fd);
1147	exit(1);
1148}
1149
1150#define MAPINMAP_PROG "./test_map_in_map.bpf.o"
1151#define MAPINMAP_INVALID_PROG "./test_map_in_map_invalid.bpf.o"
1152static void test_map_in_map(void)
1153{
1154	struct bpf_object *obj;
1155	struct bpf_map *map;
1156	int mim_fd, fd, err;
1157	int pos = 0;
1158	struct bpf_map_info info = {};
1159	__u32 len = sizeof(info);
1160	__u32 id = 0;
1161	libbpf_print_fn_t old_print_fn;
1162
1163	obj = bpf_object__open(MAPINMAP_PROG);
1164
1165	fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(int), sizeof(int), 2, NULL);
 
1166	if (fd < 0) {
1167		printf("Failed to create hashmap '%s'!\n", strerror(errno));
1168		exit(1);
1169	}
1170
1171	map = bpf_object__find_map_by_name(obj, "mim_array");
1172	if (!map) {
1173		printf("Failed to load array of maps from test prog\n");
1174		goto out_map_in_map;
1175	}
1176	err = bpf_map__set_inner_map_fd(map, fd);
1177	if (err) {
1178		printf("Failed to set inner_map_fd for array of maps\n");
1179		goto out_map_in_map;
1180	}
1181
1182	map = bpf_object__find_map_by_name(obj, "mim_hash");
1183	if (!map) {
1184		printf("Failed to load hash of maps from test prog\n");
1185		goto out_map_in_map;
1186	}
1187	err = bpf_map__set_inner_map_fd(map, fd);
1188	if (err) {
1189		printf("Failed to set inner_map_fd for hash of maps\n");
1190		goto out_map_in_map;
1191	}
1192
1193	bpf_object__load(obj);
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 elemenets 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}