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