LXR linux/samples/bpf/test

   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#include <stdio.h>
  12#include <unistd.h>
  13#include <linux/bpf.h>
  14#include <errno.h>
  15#include <string.h>
  16#include <assert.h>
  17#include <sys/wait.h>
  18#include <stdlib.h>
  19#include "libbpf.h"
  20
  21static int map_flags;
  22
  23/* sanity tests for map API */
  24static void test_hashmap_sanity(int i, void *data)
  25{
  26        long long key, next_key, value;
  27        int map_fd;
  28
  29        map_fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
  30                                2, map_flags);
  31        if (map_fd < 0) {
  32                printf("failed to create hashmap '%s'\n", strerror(errno));
  33                exit(1);
  34        }
  35
  36        key = 1;
  37        value = 1234;
  38        /* insert key=1 element */
  39        assert(bpf_update_elem(map_fd, &key, &value, BPF_ANY) == 0);
  40
  41        value = 0;
  42        /* BPF_NOEXIST means: add new element if it doesn't exist */
  43        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == -1 &&
  44               /* key=1 already exists */
  45               errno == EEXIST);
  46
  47        assert(bpf_update_elem(map_fd, &key, &value, -1) == -1 && errno == EINVAL);
  48
  49        /* check that key=1 can be found */
  50        assert(bpf_lookup_elem(map_fd, &key, &value) == 0 && value == 1234);
  51
  52        key = 2;
  53        /* check that key=2 is not found */
  54        assert(bpf_lookup_elem(map_fd, &key, &value) == -1 && errno == ENOENT);
  55
  56        /* BPF_EXIST means: update existing element */
  57        assert(bpf_update_elem(map_fd, &key, &value, BPF_EXIST) == -1 &&
  58               /* key=2 is not there */
  59               errno == ENOENT);
  60
  61        /* insert key=2 element */
  62        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == 0);
  63
  64        /* key=1 and key=2 were inserted, check that key=0 cannot be inserted
  65         * due to max_entries limit
  66         */
  67        key = 0;
  68        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == -1 &&
  69               errno == E2BIG);
  70
  71        /* check that key = 0 doesn't exist */
  72        assert(bpf_delete_elem(map_fd, &key) == -1 && errno == ENOENT);
  73
  74        /* iterate over two elements */
  75        assert(bpf_get_next_key(map_fd, &key, &next_key) == 0 &&
  76               (next_key == 1 || next_key == 2));
  77        assert(bpf_get_next_key(map_fd, &next_key, &next_key) == 0 &&
  78               (next_key == 1 || next_key == 2));
  79        assert(bpf_get_next_key(map_fd, &next_key, &next_key) == -1 &&
  80               errno == ENOENT);
  81
  82        /* delete both elements */
  83        key = 1;
  84        assert(bpf_delete_elem(map_fd, &key) == 0);
  85        key = 2;
  86        assert(bpf_delete_elem(map_fd, &key) == 0);
  87        assert(bpf_delete_elem(map_fd, &key) == -1 && errno == ENOENT);
  88
  89        key = 0;
  90        /* check that map is empty */
  91        assert(bpf_get_next_key(map_fd, &key, &next_key) == -1 &&
  92               errno == ENOENT);
  93        close(map_fd);
  94}
  95
  96/* sanity tests for percpu map API */
  97static void test_percpu_hashmap_sanity(int task, void *data)
  98{
  99        long long key, next_key;
 100        int expected_key_mask = 0;
 101        unsigned int nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
 102        long long value[nr_cpus];
 103        int map_fd, i;
 104
 105        map_fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_HASH, sizeof(key),
 106                                sizeof(value[0]), 2, map_flags);
 107        if (map_fd < 0) {
 108                printf("failed to create hashmap '%s'\n", strerror(errno));
 109                exit(1);
 110        }
 111
 112        for (i = 0; i < nr_cpus; i++)
 113                value[i] = i + 100;
 114        key = 1;
 115        /* insert key=1 element */
 116        assert(!(expected_key_mask & key));
 117        assert(bpf_update_elem(map_fd, &key, value, BPF_ANY) == 0);
 118        expected_key_mask |= key;
 119
 120        /* BPF_NOEXIST means: add new element if it doesn't exist */
 121        assert(bpf_update_elem(map_fd, &key, value, BPF_NOEXIST) == -1 &&
 122               /* key=1 already exists */
 123               errno == EEXIST);
 124
 125        /* -1 is an invalid flag */
 126        assert(bpf_update_elem(map_fd, &key, value, -1) == -1 &&
 127               errno == EINVAL);
 128
 129        /* check that key=1 can be found. value could be 0 if the lookup
 130         * was run from a different cpu.
 131         */
 132        value[0] = 1;
 133        assert(bpf_lookup_elem(map_fd, &key, value) == 0 && value[0] == 100);
 134
 135        key = 2;
 136        /* check that key=2 is not found */
 137        assert(bpf_lookup_elem(map_fd, &key, value) == -1 && errno == ENOENT);
 138
 139        /* BPF_EXIST means: update existing element */
 140        assert(bpf_update_elem(map_fd, &key, value, BPF_EXIST) == -1 &&
 141               /* key=2 is not there */
 142               errno == ENOENT);
 143
 144        /* insert key=2 element */
 145        assert(!(expected_key_mask & key));
 146        assert(bpf_update_elem(map_fd, &key, value, BPF_NOEXIST) == 0);
 147        expected_key_mask |= key;
 148
 149        /* key=1 and key=2 were inserted, check that key=0 cannot be inserted
 150         * due to max_entries limit
 151         */
 152        key = 0;
 153        assert(bpf_update_elem(map_fd, &key, value, BPF_NOEXIST) == -1 &&
 154               errno == E2BIG);
 155
 156        /* check that key = 0 doesn't exist */
 157        assert(bpf_delete_elem(map_fd, &key) == -1 && errno == ENOENT);
 158
 159        /* iterate over two elements */
 160        while (!bpf_get_next_key(map_fd, &key, &next_key)) {
 161                assert((expected_key_mask & next_key) == next_key);
 162                expected_key_mask &= ~next_key;
 163
 164                assert(bpf_lookup_elem(map_fd, &next_key, value) == 0);
 165                for (i = 0; i < nr_cpus; i++)
 166                        assert(value[i] == i + 100);
 167
 168                key = next_key;
 169        }
 170        assert(errno == ENOENT);
 171
 172        /* Update with BPF_EXIST */
 173        key = 1;
 174        assert(bpf_update_elem(map_fd, &key, value, BPF_EXIST) == 0);
 175
 176        /* delete both elements */
 177        key = 1;
 178        assert(bpf_delete_elem(map_fd, &key) == 0);
 179        key = 2;
 180        assert(bpf_delete_elem(map_fd, &key) == 0);
 181        assert(bpf_delete_elem(map_fd, &key) == -1 && errno == ENOENT);
 182
 183        key = 0;
 184        /* check that map is empty */
 185        assert(bpf_get_next_key(map_fd, &key, &next_key) == -1 &&
 186               errno == ENOENT);
 187        close(map_fd);
 188}
 189
 190static void test_arraymap_sanity(int i, void *data)
 191{
 192        int key, next_key, map_fd;
 193        long long value;
 194
 195        map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(key), sizeof(value),
 196                                2, 0);
 197        if (map_fd < 0) {
 198                printf("failed to create arraymap '%s'\n", strerror(errno));
 199                exit(1);
 200        }
 201
 202        key = 1;
 203        value = 1234;
 204        /* insert key=1 element */
 205        assert(bpf_update_elem(map_fd, &key, &value, BPF_ANY) == 0);
 206
 207        value = 0;
 208        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == -1 &&
 209               errno == EEXIST);
 210
 211        /* check that key=1 can be found */
 212        assert(bpf_lookup_elem(map_fd, &key, &value) == 0 && value == 1234);
 213
 214        key = 0;
 215        /* check that key=0 is also found and zero initialized */
 216        assert(bpf_lookup_elem(map_fd, &key, &value) == 0 && value == 0);
 217
 218
 219        /* key=0 and key=1 were inserted, check that key=2 cannot be inserted
 220         * due to max_entries limit
 221         */
 222        key = 2;
 223        assert(bpf_update_elem(map_fd, &key, &value, BPF_EXIST) == -1 &&
 224               errno == E2BIG);
 225
 226        /* check that key = 2 doesn't exist */
 227        assert(bpf_lookup_elem(map_fd, &key, &value) == -1 && errno == ENOENT);
 228
 229        /* iterate over two elements */
 230        assert(bpf_get_next_key(map_fd, &key, &next_key) == 0 &&
 231               next_key == 0);
 232        assert(bpf_get_next_key(map_fd, &next_key, &next_key) == 0 &&
 233               next_key == 1);
 234        assert(bpf_get_next_key(map_fd, &next_key, &next_key) == -1 &&
 235               errno == ENOENT);
 236
 237        /* delete shouldn't succeed */
 238        key = 1;
 239        assert(bpf_delete_elem(map_fd, &key) == -1 && errno == EINVAL);
 240
 241        close(map_fd);
 242}
 243
 244static void test_percpu_arraymap_many_keys(void)
 245{
 246        unsigned nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
 247        unsigned nr_keys = 20000;
 248        long values[nr_cpus];
 249        int key, map_fd, i;
 250
 251        map_fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
 252                                sizeof(values[0]), nr_keys, 0);
 253        if (map_fd < 0) {
 254                printf("failed to create per-cpu arraymap '%s'\n",
 255                       strerror(errno));
 256                exit(1);
 257        }
 258
 259        for (i = 0; i < nr_cpus; i++)
 260                values[i] = i + 10;
 261
 262        for (key = 0; key < nr_keys; key++)
 263                assert(bpf_update_elem(map_fd, &key, values, BPF_ANY) == 0);
 264
 265        for (key = 0; key < nr_keys; key++) {
 266                for (i = 0; i < nr_cpus; i++)
 267                        values[i] = 0;
 268                assert(bpf_lookup_elem(map_fd, &key, values) == 0);
 269                for (i = 0; i < nr_cpus; i++)
 270                        assert(values[i] == i + 10);
 271        }
 272
 273        close(map_fd);
 274}
 275
 276static void test_percpu_arraymap_sanity(int i, void *data)
 277{
 278        unsigned nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
 279        long values[nr_cpus];
 280        int key, next_key, map_fd;
 281
 282        map_fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
 283                                sizeof(values[0]), 2, 0);
 284        if (map_fd < 0) {
 285                printf("failed to create arraymap '%s'\n", strerror(errno));
 286                exit(1);
 287        }
 288
 289        for (i = 0; i < nr_cpus; i++)
 290                values[i] = i + 100;
 291
 292        key = 1;
 293        /* insert key=1 element */
 294        assert(bpf_update_elem(map_fd, &key, values, BPF_ANY) == 0);
 295
 296        values[0] = 0;
 297        assert(bpf_update_elem(map_fd, &key, values, BPF_NOEXIST) == -1 &&
 298               errno == EEXIST);
 299
 300        /* check that key=1 can be found */
 301        assert(bpf_lookup_elem(map_fd, &key, values) == 0 && values[0] == 100);
 302
 303        key = 0;
 304        /* check that key=0 is also found and zero initialized */
 305        assert(bpf_lookup_elem(map_fd, &key, values) == 0 &&
 306               values[0] == 0 && values[nr_cpus - 1] == 0);
 307
 308
 309        /* check that key=2 cannot be inserted due to max_entries limit */
 310        key = 2;
 311        assert(bpf_update_elem(map_fd, &key, values, BPF_EXIST) == -1 &&
 312               errno == E2BIG);
 313
 314        /* check that key = 2 doesn't exist */
 315        assert(bpf_lookup_elem(map_fd, &key, values) == -1 && errno == ENOENT);
 316
 317        /* iterate over two elements */
 318        assert(bpf_get_next_key(map_fd, &key, &next_key) == 0 &&
 319               next_key == 0);
 320        assert(bpf_get_next_key(map_fd, &next_key, &next_key) == 0 &&
 321               next_key == 1);
 322        assert(bpf_get_next_key(map_fd, &next_key, &next_key) == -1 &&
 323               errno == ENOENT);
 324
 325        /* delete shouldn't succeed */
 326        key = 1;
 327        assert(bpf_delete_elem(map_fd, &key) == -1 && errno == EINVAL);
 328
 329        close(map_fd);
 330}
 331
 332#define MAP_SIZE (32 * 1024)
 333static void test_map_large(void)
 334{
 335        struct bigkey {
 336                int a;
 337                char b[116];
 338                long long c;
 339        } key;
 340        int map_fd, i, value;
 341
 342        /* allocate 4Mbyte of memory */
 343        map_fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
 344                                MAP_SIZE, map_flags);
 345        if (map_fd < 0) {
 346                printf("failed to create large map '%s'\n", strerror(errno));
 347                exit(1);
 348        }
 349
 350        for (i = 0; i < MAP_SIZE; i++) {
 351                key = (struct bigkey) {.c = i};
 352                value = i;
 353                assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == 0);
 354        }
 355        key.c = -1;
 356        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == -1 &&
 357               errno == E2BIG);
 358
 359        /* iterate through all elements */
 360        for (i = 0; i < MAP_SIZE; i++)
 361                assert(bpf_get_next_key(map_fd, &key, &key) == 0);
 362        assert(bpf_get_next_key(map_fd, &key, &key) == -1 && errno == ENOENT);
 363
 364        key.c = 0;
 365        assert(bpf_lookup_elem(map_fd, &key, &value) == 0 && value == 0);
 366        key.a = 1;
 367        assert(bpf_lookup_elem(map_fd, &key, &value) == -1 && errno == ENOENT);
 368
 369        close(map_fd);
 370}
 371
 372/* fork N children and wait for them to complete */
 373static void run_parallel(int tasks, void (*fn)(int i, void *data), void *data)
 374{
 375        pid_t pid[tasks];
 376        int i;
 377
 378        for (i = 0; i < tasks; i++) {
 379                pid[i] = fork();
 380                if (pid[i] == 0) {
 381                        fn(i, data);
 382                        exit(0);
 383                } else if (pid[i] == -1) {
 384                        printf("couldn't spawn #%d process\n", i);
 385                        exit(1);
 386                }
 387        }
 388        for (i = 0; i < tasks; i++) {
 389                int status;
 390
 391                assert(waitpid(pid[i], &status, 0) == pid[i]);
 392                assert(status == 0);
 393        }
 394}
 395
 396static void test_map_stress(void)
 397{
 398        run_parallel(100, test_hashmap_sanity, NULL);
 399        run_parallel(100, test_percpu_hashmap_sanity, NULL);
 400        run_parallel(100, test_arraymap_sanity, NULL);
 401        run_parallel(100, test_percpu_arraymap_sanity, NULL);
 402}
 403
 404#define TASKS 1024
 405#define DO_UPDATE 1
 406#define DO_DELETE 0
 407static void do_work(int fn, void *data)
 408{
 409        int map_fd = ((int *)data)[0];
 410        int do_update = ((int *)data)[1];
 411        int i;
 412        int key, value;
 413
 414        for (i = fn; i < MAP_SIZE; i += TASKS) {
 415                key = value = i;
 416                if (do_update)
 417                        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == 0);
 418                else
 419                        assert(bpf_delete_elem(map_fd, &key) == 0);
 420        }
 421}
 422
 423static void test_map_parallel(void)
 424{
 425        int i, map_fd, key = 0, value = 0;
 426        int data[2];
 427
 428        map_fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
 429                                MAP_SIZE, map_flags);
 430        if (map_fd < 0) {
 431                printf("failed to create map for parallel test '%s'\n",
 432                       strerror(errno));
 433                exit(1);
 434        }
 435
 436        data[0] = map_fd;
 437        data[1] = DO_UPDATE;
 438        /* use the same map_fd in children to add elements to this map
 439         * child_0 adds key=0, key=1024, key=2048, ...
 440         * child_1 adds key=1, key=1025, key=2049, ...
 441         * child_1023 adds key=1023, ...
 442         */
 443        run_parallel(TASKS, do_work, data);
 444
 445        /* check that key=0 is already there */
 446        assert(bpf_update_elem(map_fd, &key, &value, BPF_NOEXIST) == -1 &&
 447               errno == EEXIST);
 448
 449        /* check that all elements were inserted */
 450        key = -1;
 451        for (i = 0; i < MAP_SIZE; i++)
 452                assert(bpf_get_next_key(map_fd, &key, &key) == 0);
 453        assert(bpf_get_next_key(map_fd, &key, &key) == -1 && errno == ENOENT);
 454
 455        /* another check for all elements */
 456        for (i = 0; i < MAP_SIZE; i++) {
 457                key = MAP_SIZE - i - 1;
 458                assert(bpf_lookup_elem(map_fd, &key, &value) == 0 &&
 459                       value == key);
 460        }
 461
 462        /* now let's delete all elemenets in parallel */
 463        data[1] = DO_DELETE;
 464        run_parallel(TASKS, do_work, data);
 465
 466        /* nothing should be left */
 467        key = -1;
 468        assert(bpf_get_next_key(map_fd, &key, &key) == -1 && errno == ENOENT);
 469}
 470
 471static void run_all_tests(void)
 472{
 473        test_hashmap_sanity(0, NULL);
 474        test_percpu_hashmap_sanity(0, NULL);
 475        test_arraymap_sanity(0, NULL);
 476        test_percpu_arraymap_sanity(0, NULL);
 477        test_percpu_arraymap_many_keys();
 478
 479        test_map_large();
 480        test_map_parallel();
 481        test_map_stress();
 482}
 483
 484int main(void)
 485{
 486        map_flags = 0;
 487        run_all_tests();
 488        map_flags = BPF_F_NO_PREALLOC;
 489        run_all_tests();
 490        printf("test_maps: OK\n");
 491        return 0;
 492}
 493