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