tools/testing/selftests/bpf/test_maps.c

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