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