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