tools/testing/selftests/bpf/test_maps.c

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