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