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