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/socket.h>
 637 #include <sys/ioctl.h>
 638 #include <arpa/inet.h>
 639 #include <sys/select.h>
 640 #include <linux/err.h>
 641 #define SOCKMAP_PARSE_PROG "./sockmap_parse_prog.o"
 642 #define SOCKMAP_VERDICT_PROG "./sockmap_verdict_prog.o"
 643 #define SOCKMAP_TCP_MSG_PROG "./sockmap_tcp_msg_prog.o"
 644 static void test_sockmap(int tasks, void *data)
 645 {
 646         struct bpf_map *bpf_map_rx, *bpf_map_tx, *bpf_map_msg, *bpf_map_break;
 647         int map_fd_msg = 0, map_fd_rx = 0, map_fd_tx = 0, map_fd_break;
 648         int ports[] = {50200, 50201, 50202, 50204};
 649         int err, i, fd, udp, sfd[6] = {0xdeadbeef};
 650         u8 buf[20] = {0x0, 0x5, 0x3, 0x2, 0x1, 0x0};
 651         int parse_prog, verdict_prog, msg_prog;
 652         struct sockaddr_in addr;
 653         int one = 1, s, sc, rc;
 654         struct bpf_object *obj;
 655         struct timeval to;
 656         __u32 key, value;
 657         pid_t pid[tasks];
 658         fd_set w;
 659
 660         /* Create some sockets to use with sockmap */
 661         for (i = 0; i < 2; i++) {
 662                 sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
 663                 if (sfd[i] < 0)
 664                         goto out;
 665                 err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
 666                                  (char *)&one, sizeof(one));
 667                 if (err) {
 668                         printf("failed to setsockopt\n");
 669                         goto out;
 670                 }
 671                 err = ioctl(sfd[i], FIONBIO, (char *)&one);
 672                 if (err < 0) {
 673                         printf("failed to ioctl\n");
 674                         goto out;
 675                 }
 676                 memset(&addr, 0, sizeof(struct sockaddr_in));
 677                 addr.sin_family = AF_INET;
 678                 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 679                 addr.sin_port = htons(ports[i]);
 680                 err = bind(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
 681                 if (err < 0) {
 682                         printf("failed to bind: err %i: %i:%i\n",
 683                                err, i, sfd[i]);
 684                         goto out;
 685                 }
 686                 err = listen(sfd[i], 32);
 687                 if (err < 0) {
 688                         printf("failed to listen\n");
 689                         goto out;
 690                 }
 691         }
 692
 693         for (i = 2; i < 4; i++) {
 694                 sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
 695                 if (sfd[i] < 0)
 696                         goto out;
 697                 err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
 698                                  (char *)&one, sizeof(one));
 699                 if (err) {
 700                         printf("set sock opt\n");
 701                         goto out;
 702                 }
 703                 memset(&addr, 0, sizeof(struct sockaddr_in));
 704                 addr.sin_family = AF_INET;
 705                 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 706                 addr.sin_port = htons(ports[i - 2]);
 707                 err = connect(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
 708                 if (err) {
 709                         printf("failed to connect\n");
 710                         goto out;
 711                 }
 712         }
 713
 714
 715         for (i = 4; i < 6; i++) {
 716                 sfd[i] = accept(sfd[i - 4], NULL, NULL);
 717                 if (sfd[i] < 0) {
 718                         printf("accept failed\n");
 719                         goto out;
 720                 }
 721         }
 722
 723         /* Test sockmap with connected sockets */
 724         fd = bpf_create_map(BPF_MAP_TYPE_SOCKMAP,
 725                             sizeof(key), sizeof(value),
 726                             6, 0);
 727         if (fd < 0) {
 728                 printf("Failed to create sockmap %i\n", fd);
 729                 goto out_sockmap;
 730         }
 731
 732         /* Test update with unsupported UDP socket */
 733         udp = socket(AF_INET, SOCK_DGRAM, 0);
 734         i = 0;
 735         err = bpf_map_update_elem(fd, &i, &udp, BPF_ANY);
 736         if (!err) {
 737                 printf("Failed socket SOCK_DGRAM allowed '%i:%i'\n",
 738                        i, udp);
 739                 goto out_sockmap;
 740         }
 741
 742         /* Test update without programs */
 743         for (i = 0; i < 6; i++) {
 744                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
 745                 if (i < 2 && !err) {
 746                         printf("Allowed update sockmap '%i:%i' not in ESTABLISHED\n",
 747                                i, sfd[i]);
 748                         goto out_sockmap;
 749                 } else if (i >= 2 && err) {
 750                         printf("Failed noprog update sockmap '%i:%i'\n",
 751                                i, sfd[i]);
 752                         goto out_sockmap;
 753                 }
 754         }
 755
 756         /* Test attaching/detaching bad fds */
 757         err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_PARSER, 0);
 758         if (!err) {
 759                 printf("Failed invalid parser prog attach\n");
 760                 goto out_sockmap;
 761         }
 762
 763         err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_VERDICT, 0);
 764         if (!err) {
 765                 printf("Failed invalid verdict prog attach\n");
 766                 goto out_sockmap;
 767         }
 768
 769         err = bpf_prog_attach(-1, fd, BPF_SK_MSG_VERDICT, 0);
 770         if (!err) {
 771                 printf("Failed invalid msg verdict prog attach\n");
 772                 goto out_sockmap;
 773         }
 774
 775         err = bpf_prog_attach(-1, fd, __MAX_BPF_ATTACH_TYPE, 0);
 776         if (!err) {
 777                 printf("Failed unknown prog attach\n");
 778                 goto out_sockmap;
 779         }
 780
 781         err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_PARSER);
 782         if (err) {
 783                 printf("Failed empty parser prog detach\n");
 784                 goto out_sockmap;
 785         }
 786
 787         err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_VERDICT);
 788         if (err) {
 789                 printf("Failed empty verdict prog detach\n");
 790                 goto out_sockmap;
 791         }
 792
 793         err = bpf_prog_detach(fd, BPF_SK_MSG_VERDICT);
 794         if (err) {
 795                 printf("Failed empty msg verdict prog detach\n");
 796                 goto out_sockmap;
 797         }
 798
 799         err = bpf_prog_detach(fd, __MAX_BPF_ATTACH_TYPE);
 800         if (!err) {
 801                 printf("Detach invalid prog successful\n");
 802                 goto out_sockmap;
 803         }
 804
 805         /* Load SK_SKB program and Attach */
 806         err = bpf_prog_load(SOCKMAP_PARSE_PROG,
 807                             BPF_PROG_TYPE_SK_SKB, &obj, &parse_prog);
 808         if (err) {
 809                 printf("Failed to load SK_SKB parse prog\n");
 810                 goto out_sockmap;
 811         }
 812
 813         err = bpf_prog_load(SOCKMAP_TCP_MSG_PROG,
 814                             BPF_PROG_TYPE_SK_MSG, &obj, &msg_prog);
 815         if (err) {
 816                 printf("Failed to load SK_SKB msg prog\n");
 817                 goto out_sockmap;
 818         }
 819
 820         err = bpf_prog_load(SOCKMAP_VERDICT_PROG,
 821                             BPF_PROG_TYPE_SK_SKB, &obj, &verdict_prog);
 822         if (err) {
 823                 printf("Failed to load SK_SKB verdict prog\n");
 824                 goto out_sockmap;
 825         }
 826
 827         bpf_map_rx = bpf_object__find_map_by_name(obj, "sock_map_rx");
 828         if (IS_ERR(bpf_map_rx)) {
 829                 printf("Failed to load map rx from verdict prog\n");
 830                 goto out_sockmap;
 831         }
 832
 833         map_fd_rx = bpf_map__fd(bpf_map_rx);
 834         if (map_fd_rx < 0) {
 835                 printf("Failed to get map rx fd\n");
 836                 goto out_sockmap;
 837         }
 838
 839         bpf_map_tx = bpf_object__find_map_by_name(obj, "sock_map_tx");
 840         if (IS_ERR(bpf_map_tx)) {
 841                 printf("Failed to load map tx from verdict prog\n");
 842                 goto out_sockmap;
 843         }
 844
 845         map_fd_tx = bpf_map__fd(bpf_map_tx);
 846         if (map_fd_tx < 0) {
 847                 printf("Failed to get map tx fd\n");
 848                 goto out_sockmap;
 849         }
 850
 851         bpf_map_msg = bpf_object__find_map_by_name(obj, "sock_map_msg");
 852         if (IS_ERR(bpf_map_msg)) {
 853                 printf("Failed to load map msg from msg_verdict prog\n");
 854                 goto out_sockmap;
 855         }
 856
 857         map_fd_msg = bpf_map__fd(bpf_map_msg);
 858         if (map_fd_msg < 0) {
 859                 printf("Failed to get map msg fd\n");
 860                 goto out_sockmap;
 861         }
 862
 863         bpf_map_break = bpf_object__find_map_by_name(obj, "sock_map_break");
 864         if (IS_ERR(bpf_map_break)) {
 865                 printf("Failed to load map tx from verdict prog\n");
 866                 goto out_sockmap;
 867         }
 868
 869         map_fd_break = bpf_map__fd(bpf_map_break);
 870         if (map_fd_break < 0) {
 871                 printf("Failed to get map tx fd\n");
 872                 goto out_sockmap;
 873         }
 874
 875         err = bpf_prog_attach(parse_prog, map_fd_break,
 876                               BPF_SK_SKB_STREAM_PARSER, 0);
 877         if (!err) {
 878                 printf("Allowed attaching SK_SKB program to invalid map\n");
 879                 goto out_sockmap;
 880         }
 881
 882         err = bpf_prog_attach(parse_prog, map_fd_rx,
 883                       BPF_SK_SKB_STREAM_PARSER, 0);
 884         if (err) {
 885                 printf("Failed stream parser bpf prog attach\n");
 886                 goto out_sockmap;
 887         }
 888
 889         err = bpf_prog_attach(verdict_prog, map_fd_rx,
 890                               BPF_SK_SKB_STREAM_VERDICT, 0);
 891         if (err) {
 892                 printf("Failed stream verdict bpf prog attach\n");
 893                 goto out_sockmap;
 894         }
 895
 896         err = bpf_prog_attach(msg_prog, map_fd_msg, BPF_SK_MSG_VERDICT, 0);
 897         if (err) {
 898                 printf("Failed msg verdict bpf prog attach\n");
 899                 goto out_sockmap;
 900         }
 901
 902         err = bpf_prog_attach(verdict_prog, map_fd_rx,
 903                               __MAX_BPF_ATTACH_TYPE, 0);
 904         if (!err) {
 905                 printf("Attached unknown bpf prog\n");
 906                 goto out_sockmap;
 907         }
 908
 909         /* Test map update elem afterwards fd lives in fd and map_fd */
 910         for (i = 2; i < 6; i++) {
 911                 err = bpf_map_update_elem(map_fd_rx, &i, &sfd[i], BPF_ANY);
 912                 if (err) {
 913                         printf("Failed map_fd_rx update sockmap %i '%i:%i'\n",
 914                                err, i, sfd[i]);
 915                         goto out_sockmap;
 916                 }
 917                 err = bpf_map_update_elem(map_fd_tx, &i, &sfd[i], BPF_ANY);
 918                 if (err) {
 919                         printf("Failed map_fd_tx update sockmap %i '%i:%i'\n",
 920                                err, i, sfd[i]);
 921                         goto out_sockmap;
 922                 }
 923         }
 924
 925         /* Test map delete elem and remove send/recv sockets */
 926         for (i = 2; i < 4; i++) {
 927                 err = bpf_map_delete_elem(map_fd_rx, &i);
 928                 if (err) {
 929                         printf("Failed delete sockmap rx %i '%i:%i'\n",
 930                                err, i, sfd[i]);
 931                         goto out_sockmap;
 932                 }
 933                 err = bpf_map_delete_elem(map_fd_tx, &i);
 934                 if (err) {
 935                         printf("Failed delete sockmap tx %i '%i:%i'\n",
 936                                err, i, sfd[i]);
 937                         goto out_sockmap;
 938                 }
 939         }
 940
 941         /* Put sfd[2] (sending fd below) into msg map to test sendmsg bpf */
 942         i = 0;
 943         err = bpf_map_update_elem(map_fd_msg, &i, &sfd[2], BPF_ANY);
 944         if (err) {
 945                 printf("Failed map_fd_msg update sockmap %i\n", err);
 946                 goto out_sockmap;
 947         }
 948
 949         /* Test map send/recv */
 950         for (i = 0; i < 2; i++) {
 951                 buf[0] = i;
 952                 buf[1] = 0x5;
 953                 sc = send(sfd[2], buf, 20, 0);
 954                 if (sc < 0) {
 955                         printf("Failed sockmap send\n");
 956                         goto out_sockmap;
 957                 }
 958
 959                 FD_ZERO(&w);
 960                 FD_SET(sfd[3], &w);
 961                 to.tv_sec = 1;
 962                 to.tv_usec = 0;
 963                 s = select(sfd[3] + 1, &w, NULL, NULL, &to);
 964                 if (s == -1) {
 965                         perror("Failed sockmap select()");
 966                         goto out_sockmap;
 967                 } else if (!s) {
 968                         printf("Failed sockmap unexpected timeout\n");
 969                         goto out_sockmap;
 970                 }
 971
 972                 if (!FD_ISSET(sfd[3], &w)) {
 973                         printf("Failed sockmap select/recv\n");
 974                         goto out_sockmap;
 975                 }
 976
 977                 rc = recv(sfd[3], buf, sizeof(buf), 0);
 978                 if (rc < 0) {
 979                         printf("Failed sockmap recv\n");
 980                         goto out_sockmap;
 981                 }
 982         }
 983
 984         /* Negative null entry lookup from datapath should be dropped */
 985         buf[0] = 1;
 986         buf[1] = 12;
 987         sc = send(sfd[2], buf, 20, 0);
 988         if (sc < 0) {
 989                 printf("Failed sockmap send\n");
 990                 goto out_sockmap;
 991         }
 992
 993         /* Push fd into same slot */
 994         i = 2;
 995         err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
 996         if (!err) {
 997                 printf("Failed allowed sockmap dup slot BPF_NOEXIST\n");
 998                 goto out_sockmap;
 999         }
1000
1001         err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1002         if (err) {
1003                 printf("Failed sockmap update new slot BPF_ANY\n");
1004                 goto out_sockmap;
1005         }
1006
1007         err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1008         if (err) {
1009                 printf("Failed sockmap update new slot BPF_EXIST\n");
1010                 goto out_sockmap;
1011         }
1012
1013         /* Delete the elems without programs */
1014         for (i = 2; i < 6; i++) {
1015                 err = bpf_map_delete_elem(fd, &i);
1016                 if (err) {
1017                         printf("Failed delete sockmap %i '%i:%i'\n",
1018                                err, i, sfd[i]);
1019                 }
1020         }
1021
1022         /* Test having multiple maps open and set with programs on same fds */
1023         err = bpf_prog_attach(parse_prog, fd,
1024                               BPF_SK_SKB_STREAM_PARSER, 0);
1025         if (err) {
1026                 printf("Failed fd bpf parse prog attach\n");
1027                 goto out_sockmap;
1028         }
1029         err = bpf_prog_attach(verdict_prog, fd,
1030                               BPF_SK_SKB_STREAM_VERDICT, 0);
1031         if (err) {
1032                 printf("Failed fd bpf verdict prog attach\n");
1033                 goto out_sockmap;
1034         }
1035
1036         for (i = 4; i < 6; i++) {
1037                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
1038                 if (!err) {
1039                         printf("Failed allowed duplicate programs in update ANY sockmap %i '%i:%i'\n",
1040                                err, i, sfd[i]);
1041                         goto out_sockmap;
1042                 }
1043                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
1044                 if (!err) {
1045                         printf("Failed allowed duplicate program in update NOEXIST sockmap  %i '%i:%i'\n",
1046                                err, i, sfd[i]);
1047                         goto out_sockmap;
1048                 }
1049                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
1050                 if (!err) {
1051                         printf("Failed allowed duplicate program in update EXIST sockmap  %i '%i:%i'\n",
1052                                err, i, sfd[i]);
1053                         goto out_sockmap;
1054                 }
1055         }
1056
1057         /* Test tasks number of forked operations */
1058         for (i = 0; i < tasks; i++) {
1059                 pid[i] = fork();
1060                 if (pid[i] == 0) {
1061                         for (i = 0; i < 6; i++) {
1062                                 bpf_map_delete_elem(map_fd_tx, &i);
1063                                 bpf_map_delete_elem(map_fd_rx, &i);
1064                                 bpf_map_update_elem(map_fd_tx, &i,
1065                                                     &sfd[i], BPF_ANY);
1066                                 bpf_map_update_elem(map_fd_rx, &i,
1067                                                     &sfd[i], BPF_ANY);
1068                         }
1069                         exit(0);
1070                 } else if (pid[i] == -1) {
1071                         printf("Couldn't spawn #%d process!\n", i);
1072                         exit(1);
1073                 }
1074         }
1075
1076         for (i = 0; i < tasks; i++) {
1077                 int status;
1078
1079                 assert(waitpid(pid[i], &status, 0) == pid[i]);
1080                 assert(status == 0);
1081         }
1082
1083         err = bpf_prog_detach(map_fd_rx, __MAX_BPF_ATTACH_TYPE);
1084         if (!err) {
1085                 printf("Detached an invalid prog type.\n");
1086                 goto out_sockmap;
1087         }
1088
1089         err = bpf_prog_detach(map_fd_rx, BPF_SK_SKB_STREAM_PARSER);
1090         if (err) {
1091                 printf("Failed parser prog detach\n");
1092                 goto out_sockmap;
1093         }
1094
1095         err = bpf_prog_detach(map_fd_rx, BPF_SK_SKB_STREAM_VERDICT);
1096         if (err) {
1097                 printf("Failed parser prog detach\n");
1098                 goto out_sockmap;
1099         }
1100
1101         /* Test map close sockets and empty maps */
1102         for (i = 0; i < 6; i++) {
1103                 bpf_map_delete_elem(map_fd_tx, &i);
1104                 bpf_map_delete_elem(map_fd_rx, &i);
1105                 close(sfd[i]);
1106         }
1107         close(fd);
1108         close(map_fd_rx);
1109         bpf_object__close(obj);
1110         return;
1111 out:
1112         for (i = 0; i < 6; i++)
1113                 close(sfd[i]);
1114         printf("Failed to create sockmap '%i:%s'!\n", i, strerror(errno));
1115         exit(1);
1116 out_sockmap:
1117         for (i = 0; i < 6; i++) {
1118                 if (map_fd_tx)
1119                         bpf_map_delete_elem(map_fd_tx, &i);
1120                 if (map_fd_rx)
1121                         bpf_map_delete_elem(map_fd_rx, &i);
1122                 close(sfd[i]);
1123         }
1124         close(fd);
1125         exit(1);
1126 }
1127
1128 #define MAPINMAP_PROG "./test_map_in_map.o"
1129 static void test_map_in_map(void)
1130 {
1131         struct bpf_program *prog;
1132         struct bpf_object *obj;
1133         struct bpf_map *map;
1134         int mim_fd, fd, err;
1135         int pos = 0;
1136
1137         obj = bpf_object__open(MAPINMAP_PROG);
1138
1139         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(int), sizeof(int),
1140                             2, 0);
1141         if (fd < 0) {
1142                 printf("Failed to create hashmap '%s'!\n", strerror(errno));
1143                 exit(1);
1144         }
1145
1146         map = bpf_object__find_map_by_name(obj, "mim_array");
1147         if (IS_ERR(map)) {
1148                 printf("Failed to load array of maps from test prog\n");
1149                 goto out_map_in_map;
1150         }
1151         err = bpf_map__set_inner_map_fd(map, fd);
1152         if (err) {
1153                 printf("Failed to set inner_map_fd for array of maps\n");
1154                 goto out_map_in_map;
1155         }
1156
1157         map = bpf_object__find_map_by_name(obj, "mim_hash");
1158         if (IS_ERR(map)) {
1159                 printf("Failed to load hash of maps from test prog\n");
1160                 goto out_map_in_map;
1161         }
1162         err = bpf_map__set_inner_map_fd(map, fd);
1163         if (err) {
1164                 printf("Failed to set inner_map_fd for hash of maps\n");
1165                 goto out_map_in_map;
1166         }
1167
1168         bpf_object__for_each_program(prog, obj) {
1169                 bpf_program__set_xdp(prog);
1170         }
1171         bpf_object__load(obj);
1172
1173         map = bpf_object__find_map_by_name(obj, "mim_array");
1174         if (IS_ERR(map)) {
1175                 printf("Failed to load array of maps from test prog\n");
1176                 goto out_map_in_map;
1177         }
1178         mim_fd = bpf_map__fd(map);
1179         if (mim_fd < 0) {
1180                 printf("Failed to get descriptor for array of maps\n");
1181                 goto out_map_in_map;
1182         }
1183
1184         err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);
1185         if (err) {
1186                 printf("Failed to update array of maps\n");
1187                 goto out_map_in_map;
1188         }
1189
1190         map = bpf_object__find_map_by_name(obj, "mim_hash");
1191         if (IS_ERR(map)) {
1192                 printf("Failed to load hash of maps from test prog\n");
1193                 goto out_map_in_map;
1194         }
1195         mim_fd = bpf_map__fd(map);
1196         if (mim_fd < 0) {
1197                 printf("Failed to get descriptor for hash of maps\n");
1198                 goto out_map_in_map;
1199         }
1200
1201         err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);
1202         if (err) {
1203                 printf("Failed to update hash of maps\n");
1204                 goto out_map_in_map;
1205         }
1206
1207         close(fd);
1208         bpf_object__close(obj);
1209         return;
1210
1211 out_map_in_map:
1212         close(fd);
1213         exit(1);
1214 }
1215
1216 #define MAP_SIZE (32 * 1024)
1217
1218 static void test_map_large(void)
1219 {
1220         struct bigkey {
1221                 int a;
1222                 char b[116];
1223                 long long c;
1224         } key;
1225         int fd, i, value;
1226
1227         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1228                             MAP_SIZE, map_flags);
1229         if (fd < 0) {
1230                 printf("Failed to create large map '%s'!\n", strerror(errno));
1231                 exit(1);
1232         }
1233
1234         for (i = 0; i < MAP_SIZE; i++) {
1235                 key = (struct bigkey) { .c = i };
1236                 value = i;
1237
1238                 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
1239         }
1240
1241         key.c = -1;
1242         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1243                errno == E2BIG);
1244
1245         /* Iterate through all elements. */
1246         assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1247         key.c = -1;
1248         for (i = 0; i < MAP_SIZE; i++)
1249                 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1250         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1251
1252         key.c = 0;
1253         assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
1254         key.a = 1;
1255         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1256
1257         close(fd);
1258 }
1259
1260 #define run_parallel(N, FN, DATA) \
1261         printf("Fork %d tasks to '" #FN "'\n", N); \
1262         __run_parallel(N, FN, DATA)
1263
1264 static void __run_parallel(int tasks, void (*fn)(int task, void *data),
1265                            void *data)
1266 {
1267         pid_t pid[tasks];
1268         int i;
1269
1270         for (i = 0; i < tasks; i++) {
1271                 pid[i] = fork();
1272                 if (pid[i] == 0) {
1273                         fn(i, data);
1274                         exit(0);
1275                 } else if (pid[i] == -1) {
1276                         printf("Couldn't spawn #%d process!\n", i);
1277                         exit(1);
1278                 }
1279         }
1280
1281         for (i = 0; i < tasks; i++) {
1282                 int status;
1283
1284                 assert(waitpid(pid[i], &status, 0) == pid[i]);
1285                 assert(status == 0);
1286         }
1287 }
1288
1289 static void test_map_stress(void)
1290 {
1291         run_parallel(100, test_hashmap, NULL);
1292         run_parallel(100, test_hashmap_percpu, NULL);
1293         run_parallel(100, test_hashmap_sizes, NULL);
1294         run_parallel(100, test_hashmap_walk, NULL);
1295
1296         run_parallel(100, test_arraymap, NULL);
1297         run_parallel(100, test_arraymap_percpu, NULL);
1298 }
1299
1300 #define TASKS 1024
1301
1302 #define DO_UPDATE 1
1303 #define DO_DELETE 0
1304
1305 static void test_update_delete(int fn, void *data)
1306 {
1307         int do_update = ((int *)data)[1];
1308         int fd = ((int *)data)[0];
1309         int i, key, value;
1310
1311         for (i = fn; i < MAP_SIZE; i += TASKS) {
1312                 key = value = i;
1313
1314                 if (do_update) {
1315                         assert(bpf_map_update_elem(fd, &key, &value,
1316                                                    BPF_NOEXIST) == 0);
1317                         assert(bpf_map_update_elem(fd, &key, &value,
1318                                                    BPF_EXIST) == 0);
1319                 } else {
1320                         assert(bpf_map_delete_elem(fd, &key) == 0);
1321                 }
1322         }
1323 }
1324
1325 static void test_map_parallel(void)
1326 {
1327         int i, fd, key = 0, value = 0;
1328         int data[2];
1329
1330         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1331                             MAP_SIZE, map_flags);
1332         if (fd < 0) {
1333                 printf("Failed to create map for parallel test '%s'!\n",
1334                        strerror(errno));
1335                 exit(1);
1336         }
1337
1338         /* Use the same fd in children to add elements to this map:
1339          * child_0 adds key=0, key=1024, key=2048, ...
1340          * child_1 adds key=1, key=1025, key=2049, ...
1341          * child_1023 adds key=1023, ...
1342          */
1343         data[0] = fd;
1344         data[1] = DO_UPDATE;
1345         run_parallel(TASKS, test_update_delete, data);
1346
1347         /* Check that key=0 is already there. */
1348         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1349                errno == EEXIST);
1350
1351         /* Check that all elements were inserted. */
1352         assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1353         key = -1;
1354         for (i = 0; i < MAP_SIZE; i++)
1355                 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1356         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1357
1358         /* Another check for all elements */
1359         for (i = 0; i < MAP_SIZE; i++) {
1360                 key = MAP_SIZE - i - 1;
1361
1362                 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 &&
1363                        value == key);
1364         }
1365
1366         /* Now let's delete all elemenets in parallel. */
1367         data[1] = DO_DELETE;
1368         run_parallel(TASKS, test_update_delete, data);
1369
1370         /* Nothing should be left. */
1371         key = -1;
1372         assert(bpf_map_get_next_key(fd, NULL, &key) == -1 && errno == ENOENT);
1373         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1374 }
1375
1376 static void test_map_rdonly(void)
1377 {
1378         int fd, key = 0, value = 0;
1379
1380         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1381                             MAP_SIZE, map_flags | BPF_F_RDONLY);
1382         if (fd < 0) {
1383                 printf("Failed to create map for read only test '%s'!\n",
1384                        strerror(errno));
1385                 exit(1);
1386         }
1387
1388         key = 1;
1389         value = 1234;
1390         /* Insert key=1 element. */
1391         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == -1 &&
1392                errno == EPERM);
1393
1394         /* Check that key=2 is not found. */
1395         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1396         assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == ENOENT);
1397 }
1398
1399 static void test_map_wronly(void)
1400 {
1401         int fd, key = 0, value = 0;
1402
1403         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1404                             MAP_SIZE, map_flags | BPF_F_WRONLY);
1405         if (fd < 0) {
1406                 printf("Failed to create map for read only test '%s'!\n",
1407                        strerror(errno));
1408                 exit(1);
1409         }
1410
1411         key = 1;
1412         value = 1234;
1413         /* Insert key=1 element. */
1414         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
1415
1416         /* Check that key=2 is not found. */
1417         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == EPERM);
1418         assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == EPERM);
1419 }
1420
1421 static void prepare_reuseport_grp(int type, int map_fd,
1422                                   __s64 *fds64, __u64 *sk_cookies,
1423                                   unsigned int n)
1424 {
1425         socklen_t optlen, addrlen;
1426         struct sockaddr_in6 s6;
1427         const __u32 index0 = 0;
1428         const int optval = 1;
1429         unsigned int i;
1430         u64 sk_cookie;
1431         __s64 fd64;
1432         int err;
1433
1434         s6.sin6_family = AF_INET6;
1435         s6.sin6_addr = in6addr_any;
1436         s6.sin6_port = 0;
1437         addrlen = sizeof(s6);
1438         optlen = sizeof(sk_cookie);
1439
1440         for (i = 0; i < n; i++) {
1441                 fd64 = socket(AF_INET6, type, 0);
1442                 CHECK(fd64 == -1, "socket()",
1443                       "sock_type:%d fd64:%lld errno:%d\n",
1444                       type, fd64, errno);
1445
1446                 err = setsockopt(fd64, SOL_SOCKET, SO_REUSEPORT,
1447                                  &optval, sizeof(optval));
1448                 CHECK(err == -1, "setsockopt(SO_REUSEPORT)",
1449                       "err:%d errno:%d\n", err, errno);
1450
1451                 /* reuseport_array does not allow unbound sk */
1452                 err = bpf_map_update_elem(map_fd, &index0, &fd64,
1453                                           BPF_ANY);
1454                 CHECK(err != -1 || errno != EINVAL,
1455                       "reuseport array update unbound sk",
1456                       "sock_type:%d err:%d errno:%d\n",
1457                       type, err, errno);
1458
1459                 err = bind(fd64, (struct sockaddr *)&s6, sizeof(s6));
1460                 CHECK(err == -1, "bind()",
1461                       "sock_type:%d err:%d errno:%d\n", type, err, errno);
1462
1463                 if (i == 0) {
1464                         err = getsockname(fd64, (struct sockaddr *)&s6,
1465                                           &addrlen);
1466                         CHECK(err == -1, "getsockname()",
1467                               "sock_type:%d err:%d errno:%d\n",
1468                               type, err, errno);
1469                 }
1470
1471                 err = getsockopt(fd64, SOL_SOCKET, SO_COOKIE, &sk_cookie,
1472                                  &optlen);
1473                 CHECK(err == -1, "getsockopt(SO_COOKIE)",
1474                       "sock_type:%d err:%d errno:%d\n", type, err, errno);
1475
1476                 if (type == SOCK_STREAM) {
1477                         /*
1478                          * reuseport_array does not allow
1479                          * non-listening tcp sk.
1480                          */
1481                         err = bpf_map_update_elem(map_fd, &index0, &fd64,
1482                                                   BPF_ANY);
1483                         CHECK(err != -1 || errno != EINVAL,
1484                               "reuseport array update non-listening sk",
1485                               "sock_type:%d err:%d errno:%d\n",
1486                               type, err, errno);
1487                         err = listen(fd64, 0);
1488                         CHECK(err == -1, "listen()",
1489                               "sock_type:%d, err:%d errno:%d\n",
1490                               type, err, errno);
1491                 }
1492
1493                 fds64[i] = fd64;
1494                 sk_cookies[i] = sk_cookie;
1495         }
1496 }
1497
1498 static void test_reuseport_array(void)
1499 {
1500 #define REUSEPORT_FD_IDX(err, last) ({ (err) ? last : !last; })
1501
1502         const __u32 array_size = 4, index0 = 0, index3 = 3;
1503         int types[2] = { SOCK_STREAM, SOCK_DGRAM }, type;
1504         __u64 grpa_cookies[2], sk_cookie, map_cookie;
1505         __s64 grpa_fds64[2] = { -1, -1 }, fd64 = -1;
1506         const __u32 bad_index = array_size;
1507         int map_fd, err, t, f;
1508         __u32 fds_idx = 0;
1509         int fd;
1510
1511         map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1512                                 sizeof(__u32), sizeof(__u64), array_size, 0);
1513         CHECK(map_fd == -1, "reuseport array create",
1514               "map_fd:%d, errno:%d\n", map_fd, errno);
1515
1516         /* Test lookup/update/delete with invalid index */
1517         err = bpf_map_delete_elem(map_fd, &bad_index);
1518         CHECK(err != -1 || errno != E2BIG, "reuseport array del >=max_entries",
1519               "err:%d errno:%d\n", err, errno);
1520
1521         err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);
1522         CHECK(err != -1 || errno != E2BIG,
1523               "reuseport array update >=max_entries",
1524               "err:%d errno:%d\n", err, errno);
1525
1526         err = bpf_map_lookup_elem(map_fd, &bad_index, &map_cookie);
1527         CHECK(err != -1 || errno != ENOENT,
1528               "reuseport array update >=max_entries",
1529               "err:%d errno:%d\n", err, errno);
1530
1531         /* Test lookup/delete non existence elem */
1532         err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1533         CHECK(err != -1 || errno != ENOENT,
1534               "reuseport array lookup not-exist elem",
1535               "err:%d errno:%d\n", err, errno);
1536         err = bpf_map_delete_elem(map_fd, &index3);
1537         CHECK(err != -1 || errno != ENOENT,
1538               "reuseport array del not-exist elem",
1539               "err:%d errno:%d\n", err, errno);
1540
1541         for (t = 0; t < ARRAY_SIZE(types); t++) {
1542                 type = types[t];
1543
1544                 prepare_reuseport_grp(type, map_fd, grpa_fds64,
1545                                       grpa_cookies, ARRAY_SIZE(grpa_fds64));
1546
1547                 /* Test BPF_* update flags */
1548                 /* BPF_EXIST failure case */
1549                 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1550                                           BPF_EXIST);
1551                 CHECK(err != -1 || errno != ENOENT,
1552                       "reuseport array update empty elem BPF_EXIST",
1553                       "sock_type:%d err:%d errno:%d\n",
1554                       type, err, errno);
1555                 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1556
1557                 /* BPF_NOEXIST success case */
1558                 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1559                                           BPF_NOEXIST);
1560                 CHECK(err == -1,
1561                       "reuseport array update empty elem BPF_NOEXIST",
1562                       "sock_type:%d err:%d errno:%d\n",
1563                       type, err, errno);
1564                 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1565
1566                 /* BPF_EXIST success case. */
1567                 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1568                                           BPF_EXIST);
1569                 CHECK(err == -1,
1570                       "reuseport array update same elem BPF_EXIST",
1571                       "sock_type:%d err:%d errno:%d\n", type, err, errno);
1572                 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1573
1574                 /* BPF_NOEXIST failure case */
1575                 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1576                                           BPF_NOEXIST);
1577                 CHECK(err != -1 || errno != EEXIST,
1578                       "reuseport array update non-empty elem BPF_NOEXIST",
1579                       "sock_type:%d err:%d errno:%d\n",
1580                       type, err, errno);
1581                 fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
1582
1583                 /* BPF_ANY case (always succeed) */
1584                 err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1585                                           BPF_ANY);
1586                 CHECK(err == -1,
1587                       "reuseport array update same sk with BPF_ANY",
1588                       "sock_type:%d err:%d errno:%d\n", type, err, errno);
1589
1590                 fd64 = grpa_fds64[fds_idx];
1591                 sk_cookie = grpa_cookies[fds_idx];
1592
1593                 /* The same sk cannot be added to reuseport_array twice */
1594                 err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);
1595                 CHECK(err != -1 || errno != EBUSY,
1596                       "reuseport array update same sk with same index",
1597                       "sock_type:%d err:%d errno:%d\n",
1598                       type, err, errno);
1599
1600                 err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);
1601                 CHECK(err != -1 || errno != EBUSY,
1602                       "reuseport array update same sk with different index",
1603                       "sock_type:%d err:%d errno:%d\n",
1604                       type, err, errno);
1605
1606                 /* Test delete elem */
1607                 err = bpf_map_delete_elem(map_fd, &index3);
1608                 CHECK(err == -1, "reuseport array delete sk",
1609                       "sock_type:%d err:%d errno:%d\n",
1610                       type, err, errno);
1611
1612                 /* Add it back with BPF_NOEXIST */
1613                 err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1614                 CHECK(err == -1,
1615                       "reuseport array re-add with BPF_NOEXIST after del",
1616                       "sock_type:%d err:%d errno:%d\n", type, err, errno);
1617
1618                 /* Test cookie */
1619                 err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1620                 CHECK(err == -1 || sk_cookie != map_cookie,
1621                       "reuseport array lookup re-added sk",
1622                       "sock_type:%d err:%d errno:%d sk_cookie:0x%llx map_cookie:0x%llxn",
1623                       type, err, errno, sk_cookie, map_cookie);
1624
1625                 /* Test elem removed by close() */
1626                 for (f = 0; f < ARRAY_SIZE(grpa_fds64); f++)
1627                         close(grpa_fds64[f]);
1628                 err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1629                 CHECK(err != -1 || errno != ENOENT,
1630                       "reuseport array lookup after close()",
1631                       "sock_type:%d err:%d errno:%d\n",
1632                       type, err, errno);
1633         }
1634
1635         /* Test SOCK_RAW */
1636         fd64 = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP);
1637         CHECK(fd64 == -1, "socket(SOCK_RAW)", "err:%d errno:%d\n",
1638               err, errno);
1639         err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1640         CHECK(err != -1 || errno != ENOTSUPP, "reuseport array update SOCK_RAW",
1641               "err:%d errno:%d\n", err, errno);
1642         close(fd64);
1643
1644         /* Close the 64 bit value map */
1645         close(map_fd);
1646
1647         /* Test 32 bit fd */
1648         map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1649                                 sizeof(__u32), sizeof(__u32), array_size, 0);
1650         CHECK(map_fd == -1, "reuseport array create",
1651               "map_fd:%d, errno:%d\n", map_fd, errno);
1652         prepare_reuseport_grp(SOCK_STREAM, map_fd, &fd64, &sk_cookie, 1);
1653         fd = fd64;
1654         err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);
1655         CHECK(err == -1, "reuseport array update 32 bit fd",
1656               "err:%d errno:%d\n", err, errno);
1657         err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1658         CHECK(err != -1 || errno != ENOSPC,
1659               "reuseport array lookup 32 bit fd",
1660               "err:%d errno:%d\n", err, errno);
1661         close(fd);
1662         close(map_fd);
1663 }
1664
1665 static void run_all_tests(void)
1666 {
1667         test_hashmap(0, NULL);
1668         test_hashmap_percpu(0, NULL);
1669         test_hashmap_walk(0, NULL);
1670         test_hashmap_zero_seed();
1671
1672         test_arraymap(0, NULL);
1673         test_arraymap_percpu(0, NULL);
1674
1675         test_arraymap_percpu_many_keys();
1676
1677         test_devmap(0, NULL);
1678         test_sockmap(0, NULL);
1679
1680         test_map_large();
1681         test_map_parallel();
1682         test_map_stress();
1683
1684         test_map_rdonly();
1685         test_map_wronly();
1686
1687         test_reuseport_array();
1688
1689         test_queuemap(0, NULL);
1690         test_stackmap(0, NULL);
1691
1692         test_map_in_map();
1693 }
1694
1695 int main(void)
1696 {
1697         srand(time(NULL));
1698
1699         map_flags = 0;
1700         run_all_tests();
1701
1702         map_flags = BPF_F_NO_PREALLOC;
1703         run_all_tests();
1704
1705         printf("test_maps: OK\n");
1706         return 0;
1707 }