1 /* 2 * Copyright (c) 2016 Facebook 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of version 2 of the GNU General Public 6 * License as published by the Free Software Foundation. 7 */ 8 #define _GNU_SOURCE 9 #include <stdio.h> 10 #include <unistd.h> 11 #include <errno.h> 12 #include <string.h> 13 #include <assert.h> 14 #include <sched.h> 15 #include <stdlib.h> 16 #include <time.h> 17 18 #include <sys/wait.h> 19 #include <sys/resource.h> 20 21 #include <bpf/bpf.h> 22 #include "bpf_util.h" 23 24 #define LOCAL_FREE_TARGET (128) 25 #define PERCPU_FREE_TARGET (4) 26 27 static int nr_cpus; 28 29 static int create_map(int map_type, int map_flags, unsigned int size) 30 { 31 int map_fd; 32 33 map_fd = bpf_create_map(map_type, sizeof(unsigned long long), 34 sizeof(unsigned long long), size, map_flags); 35 36 if (map_fd == -1) 37 perror("bpf_create_map"); 38 39 return map_fd; 40 } 41 42 static int map_subset(int map0, int map1) 43 { 44 unsigned long long next_key = 0; 45 unsigned long long value0[nr_cpus], value1[nr_cpus]; 46 int ret; 47 48 while (!bpf_map_get_next_key(map1, &next_key, &next_key)) { 49 assert(!bpf_map_lookup_elem(map1, &next_key, value1)); 50 ret = bpf_map_lookup_elem(map0, &next_key, value0); 51 if (ret) { 52 printf("key:%llu not found from map. %s(%d)\n", 53 next_key, strerror(errno), errno); 54 return 0; 55 } 56 if (value0[0] != value1[0]) { 57 printf("key:%llu value0:%llu != value1:%llu\n", 58 next_key, value0[0], value1[0]); 59 return 0; 60 } 61 } 62 return 1; 63 } 64 65 static int map_equal(int lru_map, int expected) 66 { 67 return map_subset(lru_map, expected) && map_subset(expected, lru_map); 68 } 69 70 static int sched_next_online(int pid, int *next_to_try) 71 { 72 cpu_set_t cpuset; 73 int next = *next_to_try; 74 int ret = -1; 75 76 while (next < nr_cpus) { 77 CPU_ZERO(&cpuset); 78 CPU_SET(next++, &cpuset); 79 if (!sched_setaffinity(pid, sizeof(cpuset), &cpuset)) { 80 ret = 0; 81 break; 82 } 83 } 84 85 *next_to_try = next; 86 return ret; 87 } 88 89 /* Size of the LRU amp is 2 90 * Add key=1 (+1 key) 91 * Add key=2 (+1 key) 92 * Lookup Key=1 93 * Add Key=3 94 * => Key=2 will be removed by LRU 95 * Iterate map. Only found key=1 and key=3 96 */ 97 static void test_lru_sanity0(int map_type, int map_flags) 98 { 99 unsigned long long key, value[nr_cpus]; 100 int lru_map_fd, expected_map_fd; 101 int next_cpu = 0; 102 103 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 104 map_flags); 105 106 assert(sched_next_online(0, &next_cpu) != -1); 107 108 if (map_flags & BPF_F_NO_COMMON_LRU) 109 lru_map_fd = create_map(map_type, map_flags, 2 * nr_cpus); 110 else 111 lru_map_fd = create_map(map_type, map_flags, 2); 112 assert(lru_map_fd != -1); 113 114 expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, 2); 115 assert(expected_map_fd != -1); 116 117 value[0] = 1234; 118 119 /* insert key=1 element */ 120 121 key = 1; 122 assert(!bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST)); 123 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 124 BPF_NOEXIST)); 125 126 /* BPF_NOEXIST means: add new element if it doesn't exist */ 127 assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST) == -1 128 /* key=1 already exists */ 129 && errno == EEXIST); 130 131 assert(bpf_map_update_elem(lru_map_fd, &key, value, -1) == -1 && 132 errno == EINVAL); 133 134 /* insert key=2 element */ 135 136 /* check that key=2 is not found */ 137 key = 2; 138 assert(bpf_map_lookup_elem(lru_map_fd, &key, value) == -1 && 139 errno == ENOENT); 140 141 /* BPF_EXIST means: update existing element */ 142 assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_EXIST) == -1 && 143 /* key=2 is not there */ 144 errno == ENOENT); 145 146 assert(!bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST)); 147 148 /* insert key=3 element */ 149 150 /* check that key=3 is not found */ 151 key = 3; 152 assert(bpf_map_lookup_elem(lru_map_fd, &key, value) == -1 && 153 errno == ENOENT); 154 155 /* check that key=1 can be found and mark the ref bit to 156 * stop LRU from removing key=1 157 */ 158 key = 1; 159 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value)); 160 assert(value[0] == 1234); 161 162 key = 3; 163 assert(!bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST)); 164 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 165 BPF_NOEXIST)); 166 167 /* key=2 has been removed from the LRU */ 168 key = 2; 169 assert(bpf_map_lookup_elem(lru_map_fd, &key, value) == -1); 170 171 assert(map_equal(lru_map_fd, expected_map_fd)); 172 173 close(expected_map_fd); 174 close(lru_map_fd); 175 176 printf("Pass\n"); 177 } 178 179 /* Size of the LRU map is 1.5*tgt_free 180 * Insert 1 to tgt_free (+tgt_free keys) 181 * Lookup 1 to tgt_free/2 182 * Insert 1+tgt_free to 2*tgt_free (+tgt_free keys) 183 * => 1+tgt_free/2 to LOCALFREE_TARGET will be removed by LRU 184 */ 185 static void test_lru_sanity1(int map_type, int map_flags, unsigned int tgt_free) 186 { 187 unsigned long long key, end_key, value[nr_cpus]; 188 int lru_map_fd, expected_map_fd; 189 unsigned int batch_size; 190 unsigned int map_size; 191 int next_cpu = 0; 192 193 if (map_flags & BPF_F_NO_COMMON_LRU) 194 /* This test is only applicable to common LRU list */ 195 return; 196 197 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 198 map_flags); 199 200 assert(sched_next_online(0, &next_cpu) != -1); 201 202 batch_size = tgt_free / 2; 203 assert(batch_size * 2 == tgt_free); 204 205 map_size = tgt_free + batch_size; 206 lru_map_fd = create_map(map_type, map_flags, map_size); 207 assert(lru_map_fd != -1); 208 209 expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size); 210 assert(expected_map_fd != -1); 211 212 value[0] = 1234; 213 214 /* Insert 1 to tgt_free (+tgt_free keys) */ 215 end_key = 1 + tgt_free; 216 for (key = 1; key < end_key; key++) 217 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 218 BPF_NOEXIST)); 219 220 /* Lookup 1 to tgt_free/2 */ 221 end_key = 1 + batch_size; 222 for (key = 1; key < end_key; key++) { 223 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value)); 224 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 225 BPF_NOEXIST)); 226 } 227 228 /* Insert 1+tgt_free to 2*tgt_free 229 * => 1+tgt_free/2 to LOCALFREE_TARGET will be 230 * removed by LRU 231 */ 232 key = 1 + tgt_free; 233 end_key = key + tgt_free; 234 for (; key < end_key; key++) { 235 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 236 BPF_NOEXIST)); 237 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 238 BPF_NOEXIST)); 239 } 240 241 assert(map_equal(lru_map_fd, expected_map_fd)); 242 243 close(expected_map_fd); 244 close(lru_map_fd); 245 246 printf("Pass\n"); 247 } 248 249 /* Size of the LRU map 1.5 * tgt_free 250 * Insert 1 to tgt_free (+tgt_free keys) 251 * Update 1 to tgt_free/2 252 * => The original 1 to tgt_free/2 will be removed due to 253 * the LRU shrink process 254 * Re-insert 1 to tgt_free/2 again and do a lookup immeidately 255 * Insert 1+tgt_free to tgt_free*3/2 256 * Insert 1+tgt_free*3/2 to tgt_free*5/2 257 * => Key 1+tgt_free to tgt_free*3/2 258 * will be removed from LRU because it has never 259 * been lookup and ref bit is not set 260 */ 261 static void test_lru_sanity2(int map_type, int map_flags, unsigned int tgt_free) 262 { 263 unsigned long long key, value[nr_cpus]; 264 unsigned long long end_key; 265 int lru_map_fd, expected_map_fd; 266 unsigned int batch_size; 267 unsigned int map_size; 268 int next_cpu = 0; 269 270 if (map_flags & BPF_F_NO_COMMON_LRU) 271 /* This test is only applicable to common LRU list */ 272 return; 273 274 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 275 map_flags); 276 277 assert(sched_next_online(0, &next_cpu) != -1); 278 279 batch_size = tgt_free / 2; 280 assert(batch_size * 2 == tgt_free); 281 282 map_size = tgt_free + batch_size; 283 lru_map_fd = create_map(map_type, map_flags, map_size); 284 assert(lru_map_fd != -1); 285 286 expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size); 287 assert(expected_map_fd != -1); 288 289 value[0] = 1234; 290 291 /* Insert 1 to tgt_free (+tgt_free keys) */ 292 end_key = 1 + tgt_free; 293 for (key = 1; key < end_key; key++) 294 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 295 BPF_NOEXIST)); 296 297 /* Any bpf_map_update_elem will require to acquire a new node 298 * from LRU first. 299 * 300 * The local list is running out of free nodes. 301 * It gets from the global LRU list which tries to 302 * shrink the inactive list to get tgt_free 303 * number of free nodes. 304 * 305 * Hence, the oldest key 1 to tgt_free/2 306 * are removed from the LRU list. 307 */ 308 key = 1; 309 if (map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH) { 310 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 311 BPF_NOEXIST)); 312 assert(!bpf_map_delete_elem(lru_map_fd, &key)); 313 } else { 314 assert(bpf_map_update_elem(lru_map_fd, &key, value, 315 BPF_EXIST)); 316 } 317 318 /* Re-insert 1 to tgt_free/2 again and do a lookup 319 * immeidately. 320 */ 321 end_key = 1 + batch_size; 322 value[0] = 4321; 323 for (key = 1; key < end_key; key++) { 324 assert(bpf_map_lookup_elem(lru_map_fd, &key, value)); 325 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 326 BPF_NOEXIST)); 327 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value)); 328 assert(value[0] == 4321); 329 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 330 BPF_NOEXIST)); 331 } 332 333 value[0] = 1234; 334 335 /* Insert 1+tgt_free to tgt_free*3/2 */ 336 end_key = 1 + tgt_free + batch_size; 337 for (key = 1 + tgt_free; key < end_key; key++) 338 /* These newly added but not referenced keys will be 339 * gone during the next LRU shrink. 340 */ 341 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 342 BPF_NOEXIST)); 343 344 /* Insert 1+tgt_free*3/2 to tgt_free*5/2 */ 345 end_key = key + tgt_free; 346 for (; key < end_key; key++) { 347 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 348 BPF_NOEXIST)); 349 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 350 BPF_NOEXIST)); 351 } 352 353 assert(map_equal(lru_map_fd, expected_map_fd)); 354 355 close(expected_map_fd); 356 close(lru_map_fd); 357 358 printf("Pass\n"); 359 } 360 361 /* Size of the LRU map is 2*tgt_free 362 * It is to test the active/inactive list rotation 363 * Insert 1 to 2*tgt_free (+2*tgt_free keys) 364 * Lookup key 1 to tgt_free*3/2 365 * Add 1+2*tgt_free to tgt_free*5/2 (+tgt_free/2 keys) 366 * => key 1+tgt_free*3/2 to 2*tgt_free are removed from LRU 367 */ 368 static void test_lru_sanity3(int map_type, int map_flags, unsigned int tgt_free) 369 { 370 unsigned long long key, end_key, value[nr_cpus]; 371 int lru_map_fd, expected_map_fd; 372 unsigned int batch_size; 373 unsigned int map_size; 374 int next_cpu = 0; 375 376 if (map_flags & BPF_F_NO_COMMON_LRU) 377 /* This test is only applicable to common LRU list */ 378 return; 379 380 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 381 map_flags); 382 383 assert(sched_next_online(0, &next_cpu) != -1); 384 385 batch_size = tgt_free / 2; 386 assert(batch_size * 2 == tgt_free); 387 388 map_size = tgt_free * 2; 389 lru_map_fd = create_map(map_type, map_flags, map_size); 390 assert(lru_map_fd != -1); 391 392 expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size); 393 assert(expected_map_fd != -1); 394 395 value[0] = 1234; 396 397 /* Insert 1 to 2*tgt_free (+2*tgt_free keys) */ 398 end_key = 1 + (2 * tgt_free); 399 for (key = 1; key < end_key; key++) 400 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 401 BPF_NOEXIST)); 402 403 /* Lookup key 1 to tgt_free*3/2 */ 404 end_key = tgt_free + batch_size; 405 for (key = 1; key < end_key; key++) { 406 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value)); 407 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 408 BPF_NOEXIST)); 409 } 410 411 /* Add 1+2*tgt_free to tgt_free*5/2 412 * (+tgt_free/2 keys) 413 */ 414 key = 2 * tgt_free + 1; 415 end_key = key + batch_size; 416 for (; key < end_key; key++) { 417 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 418 BPF_NOEXIST)); 419 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 420 BPF_NOEXIST)); 421 } 422 423 assert(map_equal(lru_map_fd, expected_map_fd)); 424 425 close(expected_map_fd); 426 close(lru_map_fd); 427 428 printf("Pass\n"); 429 } 430 431 /* Test deletion */ 432 static void test_lru_sanity4(int map_type, int map_flags, unsigned int tgt_free) 433 { 434 int lru_map_fd, expected_map_fd; 435 unsigned long long key, value[nr_cpus]; 436 unsigned long long end_key; 437 int next_cpu = 0; 438 439 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 440 map_flags); 441 442 assert(sched_next_online(0, &next_cpu) != -1); 443 444 if (map_flags & BPF_F_NO_COMMON_LRU) 445 lru_map_fd = create_map(map_type, map_flags, 446 3 * tgt_free * nr_cpus); 447 else 448 lru_map_fd = create_map(map_type, map_flags, 3 * tgt_free); 449 assert(lru_map_fd != -1); 450 451 expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, 452 3 * tgt_free); 453 assert(expected_map_fd != -1); 454 455 value[0] = 1234; 456 457 for (key = 1; key <= 2 * tgt_free; key++) 458 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 459 BPF_NOEXIST)); 460 461 key = 1; 462 assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST)); 463 464 for (key = 1; key <= tgt_free; key++) { 465 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value)); 466 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 467 BPF_NOEXIST)); 468 } 469 470 for (; key <= 2 * tgt_free; key++) { 471 assert(!bpf_map_delete_elem(lru_map_fd, &key)); 472 assert(bpf_map_delete_elem(lru_map_fd, &key)); 473 } 474 475 end_key = key + 2 * tgt_free; 476 for (; key < end_key; key++) { 477 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 478 BPF_NOEXIST)); 479 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 480 BPF_NOEXIST)); 481 } 482 483 assert(map_equal(lru_map_fd, expected_map_fd)); 484 485 close(expected_map_fd); 486 close(lru_map_fd); 487 488 printf("Pass\n"); 489 } 490 491 static void do_test_lru_sanity5(unsigned long long last_key, int map_fd) 492 { 493 unsigned long long key, value[nr_cpus]; 494 495 /* Ensure the last key inserted by previous CPU can be found */ 496 assert(!bpf_map_lookup_elem(map_fd, &last_key, value)); 497 498 value[0] = 1234; 499 500 key = last_key + 1; 501 assert(!bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST)); 502 assert(!bpf_map_lookup_elem(map_fd, &key, value)); 503 504 /* Cannot find the last key because it was removed by LRU */ 505 assert(bpf_map_lookup_elem(map_fd, &last_key, value)); 506 } 507 508 /* Test map with only one element */ 509 static void test_lru_sanity5(int map_type, int map_flags) 510 { 511 unsigned long long key, value[nr_cpus]; 512 int next_cpu = 0; 513 int map_fd; 514 515 if (map_flags & BPF_F_NO_COMMON_LRU) 516 return; 517 518 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 519 map_flags); 520 521 map_fd = create_map(map_type, map_flags, 1); 522 assert(map_fd != -1); 523 524 value[0] = 1234; 525 key = 0; 526 assert(!bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST)); 527 528 while (sched_next_online(0, &next_cpu) != -1) { 529 pid_t pid; 530 531 pid = fork(); 532 if (pid == 0) { 533 do_test_lru_sanity5(key, map_fd); 534 exit(0); 535 } else if (pid == -1) { 536 printf("couldn't spawn process to test key:%llu\n", 537 key); 538 exit(1); 539 } else { 540 int status; 541 542 assert(waitpid(pid, &status, 0) == pid); 543 assert(status == 0); 544 key++; 545 } 546 } 547 548 close(map_fd); 549 /* At least one key should be tested */ 550 assert(key > 0); 551 552 printf("Pass\n"); 553 } 554 555 /* Test list rotation for BPF_F_NO_COMMON_LRU map */ 556 static void test_lru_sanity6(int map_type, int map_flags, int tgt_free) 557 { 558 int lru_map_fd, expected_map_fd; 559 unsigned long long key, value[nr_cpus]; 560 unsigned int map_size = tgt_free * 2; 561 int next_cpu = 0; 562 563 if (!(map_flags & BPF_F_NO_COMMON_LRU)) 564 return; 565 566 printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type, 567 map_flags); 568 569 assert(sched_next_online(0, &next_cpu) != -1); 570 571 expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size); 572 assert(expected_map_fd != -1); 573 574 lru_map_fd = create_map(map_type, map_flags, map_size * nr_cpus); 575 assert(lru_map_fd != -1); 576 577 value[0] = 1234; 578 579 for (key = 1; key <= tgt_free; key++) { 580 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 581 BPF_NOEXIST)); 582 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 583 BPF_NOEXIST)); 584 } 585 586 for (; key <= tgt_free * 2; key++) { 587 unsigned long long stable_key; 588 589 /* Make ref bit sticky for key: [1, tgt_free] */ 590 for (stable_key = 1; stable_key <= tgt_free; stable_key++) { 591 /* Mark the ref bit */ 592 assert(!bpf_map_lookup_elem(lru_map_fd, &stable_key, 593 value)); 594 } 595 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 596 BPF_NOEXIST)); 597 } 598 599 for (; key <= tgt_free * 3; key++) { 600 assert(!bpf_map_update_elem(lru_map_fd, &key, value, 601 BPF_NOEXIST)); 602 assert(!bpf_map_update_elem(expected_map_fd, &key, value, 603 BPF_NOEXIST)); 604 } 605 606 assert(map_equal(lru_map_fd, expected_map_fd)); 607 608 close(expected_map_fd); 609 close(lru_map_fd); 610 611 printf("Pass\n"); 612 } 613 614 int main(int argc, char **argv) 615 { 616 struct rlimit r = {RLIM_INFINITY, RLIM_INFINITY}; 617 int map_types[] = {BPF_MAP_TYPE_LRU_HASH, 618 BPF_MAP_TYPE_LRU_PERCPU_HASH}; 619 int map_flags[] = {0, BPF_F_NO_COMMON_LRU}; 620 int t, f; 621 622 setbuf(stdout, NULL); 623 624 assert(!setrlimit(RLIMIT_MEMLOCK, &r)); 625 626 nr_cpus = bpf_num_possible_cpus(); 627 assert(nr_cpus != -1); 628 printf("nr_cpus:%d\n\n", nr_cpus); 629 630 for (f = 0; f < sizeof(map_flags) / sizeof(*map_flags); f++) { 631 unsigned int tgt_free = (map_flags[f] & BPF_F_NO_COMMON_LRU) ? 632 PERCPU_FREE_TARGET : LOCAL_FREE_TARGET; 633 634 for (t = 0; t < sizeof(map_types) / sizeof(*map_types); t++) { 635 test_lru_sanity0(map_types[t], map_flags[f]); 636 test_lru_sanity1(map_types[t], map_flags[f], tgt_free); 637 test_lru_sanity2(map_types[t], map_flags[f], tgt_free); 638 test_lru_sanity3(map_types[t], map_flags[f], tgt_free); 639 test_lru_sanity4(map_types[t], map_flags[f], tgt_free); 640 test_lru_sanity5(map_types[t], map_flags[f]); 641 test_lru_sanity6(map_types[t], map_flags[f], tgt_free); 642 643 printf("\n"); 644 } 645 } 646 647 return 0; 648 } 649
