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