1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2017-2018 Covalent IO, Inc. http://covalent.io 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <sys/socket.h> 6 #include <sys/ioctl.h> 7 #include <sys/select.h> 8 #include <netinet/in.h> 9 #include <arpa/inet.h> 10 #include <unistd.h> 11 #include <string.h> 12 #include <errno.h> 13 #include <stdbool.h> 14 #include <signal.h> 15 #include <fcntl.h> 16 #include <sys/wait.h> 17 #include <time.h> 18 #include <sched.h> 19 20 #include <sys/time.h> 21 #include <sys/types.h> 22 #include <sys/sendfile.h> 23 24 #include <linux/netlink.h> 25 #include <linux/socket.h> 26 #include <linux/sock_diag.h> 27 #include <linux/bpf.h> 28 #include <linux/if_link.h> 29 #include <linux/tls.h> 30 #include <assert.h> 31 #include <libgen.h> 32 33 #include <getopt.h> 34 35 #include <bpf/bpf.h> 36 #include <bpf/libbpf.h> 37 38 #include "bpf_util.h" 39 #include "cgroup_helpers.h" 40 41 int running; 42 static void running_handler(int a); 43 44 #ifndef TCP_ULP 45 # define TCP_ULP 31 46 #endif 47 #ifndef SOL_TLS 48 # define SOL_TLS 282 49 #endif 50 51 /* randomly selected ports for testing on lo */ 52 #define S1_PORT 10000 53 #define S2_PORT 10001 54 55 #define BPF_SOCKMAP_FILENAME "test_sockmap_kern.bpf.o" 56 #define BPF_SOCKHASH_FILENAME "test_sockhash_kern.bpf.o" 57 #define CG_PATH "/sockmap" 58 59 #define EDATAINTEGRITY 2001 60 61 /* global sockets */ 62 int s1, s2, c1, c2, p1, p2; 63 int test_cnt; 64 int passed; 65 int failed; 66 int map_fd[9]; 67 struct bpf_map *maps[9]; 68 struct bpf_program *progs[9]; 69 struct bpf_link *links[9]; 70 71 int txmsg_pass; 72 int txmsg_redir; 73 int txmsg_drop; 74 int txmsg_apply; 75 int txmsg_cork; 76 int txmsg_start; 77 int txmsg_end; 78 int txmsg_start_push; 79 int txmsg_end_push; 80 int txmsg_start_pop; 81 int txmsg_pop; 82 int txmsg_ingress; 83 int txmsg_redir_skb; 84 int txmsg_ktls_skb; 85 int txmsg_ktls_skb_drop; 86 int txmsg_ktls_skb_redir; 87 int ktls; 88 int peek_flag; 89 int skb_use_parser; 90 int txmsg_omit_skb_parser; 91 int verify_push_start; 92 int verify_push_len; 93 int verify_pop_start; 94 int verify_pop_len; 95 96 static const struct option long_options[] = { 97 {"help", no_argument, NULL, 'h' }, 98 {"cgroup", required_argument, NULL, 'c' }, 99 {"rate", required_argument, NULL, 'r' }, 100 {"verbose", optional_argument, NULL, 'v' }, 101 {"iov_count", required_argument, NULL, 'i' }, 102 {"length", required_argument, NULL, 'l' }, 103 {"test", required_argument, NULL, 't' }, 104 {"data_test", no_argument, NULL, 'd' }, 105 {"txmsg", no_argument, &txmsg_pass, 1 }, 106 {"txmsg_redir", no_argument, &txmsg_redir, 1 }, 107 {"txmsg_drop", no_argument, &txmsg_drop, 1 }, 108 {"txmsg_apply", required_argument, NULL, 'a'}, 109 {"txmsg_cork", required_argument, NULL, 'k'}, 110 {"txmsg_start", required_argument, NULL, 's'}, 111 {"txmsg_end", required_argument, NULL, 'e'}, 112 {"txmsg_start_push", required_argument, NULL, 'p'}, 113 {"txmsg_end_push", required_argument, NULL, 'q'}, 114 {"txmsg_start_pop", required_argument, NULL, 'w'}, 115 {"txmsg_pop", required_argument, NULL, 'x'}, 116 {"txmsg_ingress", no_argument, &txmsg_ingress, 1 }, 117 {"txmsg_redir_skb", no_argument, &txmsg_redir_skb, 1 }, 118 {"ktls", no_argument, &ktls, 1 }, 119 {"peek", no_argument, &peek_flag, 1 }, 120 {"txmsg_omit_skb_parser", no_argument, &txmsg_omit_skb_parser, 1}, 121 {"whitelist", required_argument, NULL, 'n' }, 122 {"blacklist", required_argument, NULL, 'b' }, 123 {0, 0, NULL, 0 } 124 }; 125 126 struct test_env { 127 const char *type; 128 const char *subtest; 129 const char *prepend; 130 131 int test_num; 132 int subtest_num; 133 134 int succ_cnt; 135 int fail_cnt; 136 int fail_last; 137 }; 138 139 struct test_env env; 140 141 struct sockmap_options { 142 int verbose; 143 bool base; 144 bool sendpage; 145 bool data_test; 146 bool drop_expected; 147 bool check_recved_len; 148 bool tx_wait_mem; 149 int iov_count; 150 int iov_length; 151 int rate; 152 char *map; 153 char *whitelist; 154 char *blacklist; 155 char *prepend; 156 }; 157 158 struct _test { 159 char *title; 160 void (*tester)(int cg_fd, struct sockmap_options *opt); 161 }; 162 163 static void test_start(void) 164 { 165 env.subtest_num++; 166 } 167 168 static void test_fail(void) 169 { 170 env.fail_cnt++; 171 } 172 173 static void test_pass(void) 174 { 175 env.succ_cnt++; 176 } 177 178 static void test_reset(void) 179 { 180 txmsg_start = txmsg_end = 0; 181 txmsg_start_pop = txmsg_pop = 0; 182 txmsg_start_push = txmsg_end_push = 0; 183 txmsg_pass = txmsg_drop = txmsg_redir = 0; 184 txmsg_apply = txmsg_cork = 0; 185 txmsg_ingress = txmsg_redir_skb = 0; 186 txmsg_ktls_skb = txmsg_ktls_skb_drop = txmsg_ktls_skb_redir = 0; 187 txmsg_omit_skb_parser = 0; 188 skb_use_parser = 0; 189 } 190 191 static int test_start_subtest(const struct _test *t, struct sockmap_options *o) 192 { 193 env.type = o->map; 194 env.subtest = t->title; 195 env.prepend = o->prepend; 196 env.test_num++; 197 env.subtest_num = 0; 198 env.fail_last = env.fail_cnt; 199 test_reset(); 200 return 0; 201 } 202 203 static void test_end_subtest(void) 204 { 205 int error = env.fail_cnt - env.fail_last; 206 int type = strcmp(env.type, BPF_SOCKMAP_FILENAME); 207 208 if (!error) 209 test_pass(); 210 211 fprintf(stdout, "#%2d/%2d %8s:%s:%s:%s\n", 212 env.test_num, env.subtest_num, 213 !type ? "sockmap" : "sockhash", 214 env.prepend ? : "", 215 env.subtest, error ? "FAIL" : "OK"); 216 } 217 218 static void test_print_results(void) 219 { 220 fprintf(stdout, "Pass: %d Fail: %d\n", 221 env.succ_cnt, env.fail_cnt); 222 } 223 224 static void usage(char *argv[]) 225 { 226 int i; 227 228 printf(" Usage: %s --cgroup <cgroup_path>\n", argv[0]); 229 printf(" options:\n"); 230 for (i = 0; long_options[i].name != 0; i++) { 231 printf(" --%-12s", long_options[i].name); 232 if (long_options[i].flag != NULL) 233 printf(" flag (internal value:%d)\n", 234 *long_options[i].flag); 235 else 236 printf(" -%c\n", long_options[i].val); 237 } 238 printf("\n"); 239 } 240 241 char *sock_to_string(int s) 242 { 243 if (s == c1) 244 return "client1"; 245 else if (s == c2) 246 return "client2"; 247 else if (s == s1) 248 return "server1"; 249 else if (s == s2) 250 return "server2"; 251 else if (s == p1) 252 return "peer1"; 253 else if (s == p2) 254 return "peer2"; 255 else 256 return "unknown"; 257 } 258 259 static int sockmap_init_ktls(int verbose, int s) 260 { 261 struct tls12_crypto_info_aes_gcm_128 tls_tx = { 262 .info = { 263 .version = TLS_1_2_VERSION, 264 .cipher_type = TLS_CIPHER_AES_GCM_128, 265 }, 266 }; 267 struct tls12_crypto_info_aes_gcm_128 tls_rx = { 268 .info = { 269 .version = TLS_1_2_VERSION, 270 .cipher_type = TLS_CIPHER_AES_GCM_128, 271 }, 272 }; 273 int so_buf = 6553500; 274 int err; 275 276 err = setsockopt(s, 6, TCP_ULP, "tls", sizeof("tls")); 277 if (err) { 278 fprintf(stderr, "setsockopt: TCP_ULP(%s) failed with error %i\n", sock_to_string(s), err); 279 return -EINVAL; 280 } 281 err = setsockopt(s, SOL_TLS, TLS_TX, (void *)&tls_tx, sizeof(tls_tx)); 282 if (err) { 283 fprintf(stderr, "setsockopt: TLS_TX(%s) failed with error %i\n", sock_to_string(s), err); 284 return -EINVAL; 285 } 286 err = setsockopt(s, SOL_TLS, TLS_RX, (void *)&tls_rx, sizeof(tls_rx)); 287 if (err) { 288 fprintf(stderr, "setsockopt: TLS_RX(%s) failed with error %i\n", sock_to_string(s), err); 289 return -EINVAL; 290 } 291 err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, &so_buf, sizeof(so_buf)); 292 if (err) { 293 fprintf(stderr, "setsockopt: (%s) failed sndbuf with error %i\n", sock_to_string(s), err); 294 return -EINVAL; 295 } 296 err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, &so_buf, sizeof(so_buf)); 297 if (err) { 298 fprintf(stderr, "setsockopt: (%s) failed rcvbuf with error %i\n", sock_to_string(s), err); 299 return -EINVAL; 300 } 301 302 if (verbose) 303 fprintf(stdout, "socket(%s) kTLS enabled\n", sock_to_string(s)); 304 return 0; 305 } 306 static int sockmap_init_sockets(int verbose) 307 { 308 int i, err, one = 1; 309 struct sockaddr_in addr; 310 int *fds[4] = {&s1, &s2, &c1, &c2}; 311 312 s1 = s2 = p1 = p2 = c1 = c2 = 0; 313 314 /* Init sockets */ 315 for (i = 0; i < 4; i++) { 316 *fds[i] = socket(AF_INET, SOCK_STREAM, 0); 317 if (*fds[i] < 0) { 318 perror("socket s1 failed()"); 319 return errno; 320 } 321 } 322 323 /* Allow reuse */ 324 for (i = 0; i < 2; i++) { 325 err = setsockopt(*fds[i], SOL_SOCKET, SO_REUSEADDR, 326 (char *)&one, sizeof(one)); 327 if (err) { 328 perror("setsockopt failed()"); 329 return errno; 330 } 331 } 332 333 /* Non-blocking sockets */ 334 for (i = 0; i < 2; i++) { 335 err = ioctl(*fds[i], FIONBIO, (char *)&one); 336 if (err < 0) { 337 perror("ioctl s1 failed()"); 338 return errno; 339 } 340 } 341 342 /* Bind server sockets */ 343 memset(&addr, 0, sizeof(struct sockaddr_in)); 344 addr.sin_family = AF_INET; 345 addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 346 347 addr.sin_port = htons(S1_PORT); 348 err = bind(s1, (struct sockaddr *)&addr, sizeof(addr)); 349 if (err < 0) { 350 perror("bind s1 failed()"); 351 return errno; 352 } 353 354 addr.sin_port = htons(S2_PORT); 355 err = bind(s2, (struct sockaddr *)&addr, sizeof(addr)); 356 if (err < 0) { 357 perror("bind s2 failed()"); 358 return errno; 359 } 360 361 /* Listen server sockets */ 362 addr.sin_port = htons(S1_PORT); 363 err = listen(s1, 32); 364 if (err < 0) { 365 perror("listen s1 failed()"); 366 return errno; 367 } 368 369 addr.sin_port = htons(S2_PORT); 370 err = listen(s2, 32); 371 if (err < 0) { 372 perror("listen s1 failed()"); 373 return errno; 374 } 375 376 /* Initiate Connect */ 377 addr.sin_port = htons(S1_PORT); 378 err = connect(c1, (struct sockaddr *)&addr, sizeof(addr)); 379 if (err < 0 && errno != EINPROGRESS) { 380 perror("connect c1 failed()"); 381 return errno; 382 } 383 384 addr.sin_port = htons(S2_PORT); 385 err = connect(c2, (struct sockaddr *)&addr, sizeof(addr)); 386 if (err < 0 && errno != EINPROGRESS) { 387 perror("connect c2 failed()"); 388 return errno; 389 } else if (err < 0) { 390 err = 0; 391 } 392 393 /* Accept Connecrtions */ 394 p1 = accept(s1, NULL, NULL); 395 if (p1 < 0) { 396 perror("accept s1 failed()"); 397 return errno; 398 } 399 400 p2 = accept(s2, NULL, NULL); 401 if (p2 < 0) { 402 perror("accept s1 failed()"); 403 return errno; 404 } 405 406 if (verbose > 1) { 407 printf("connected sockets: c1 <-> p1, c2 <-> p2\n"); 408 printf("cgroups binding: c1(%i) <-> s1(%i) - - - c2(%i) <-> s2(%i)\n", 409 c1, s1, c2, s2); 410 } 411 return 0; 412 } 413 414 struct msg_stats { 415 size_t bytes_sent; 416 size_t bytes_recvd; 417 struct timespec start; 418 struct timespec end; 419 }; 420 421 static int msg_loop_sendpage(int fd, int iov_length, int cnt, 422 struct msg_stats *s, 423 struct sockmap_options *opt) 424 { 425 bool drop = opt->drop_expected; 426 unsigned char k = 0; 427 int i, j, fp; 428 FILE *file; 429 430 file = tmpfile(); 431 if (!file) { 432 perror("create file for sendpage"); 433 return 1; 434 } 435 for (i = 0; i < cnt; i++, k = 0) { 436 for (j = 0; j < iov_length; j++, k++) 437 fwrite(&k, sizeof(char), 1, file); 438 } 439 fflush(file); 440 fseek(file, 0, SEEK_SET); 441 442 fp = fileno(file); 443 444 clock_gettime(CLOCK_MONOTONIC, &s->start); 445 for (i = 0; i < cnt; i++) { 446 int sent; 447 448 errno = 0; 449 sent = sendfile(fd, fp, NULL, iov_length); 450 451 if (!drop && sent < 0) { 452 perror("sendpage loop error"); 453 fclose(file); 454 return sent; 455 } else if (drop && sent >= 0) { 456 printf("sendpage loop error expected: %i errno %i\n", 457 sent, errno); 458 fclose(file); 459 return -EIO; 460 } 461 462 if (sent > 0) 463 s->bytes_sent += sent; 464 } 465 clock_gettime(CLOCK_MONOTONIC, &s->end); 466 fclose(file); 467 return 0; 468 } 469 470 static void msg_free_iov(struct msghdr *msg) 471 { 472 int i; 473 474 for (i = 0; i < msg->msg_iovlen; i++) 475 free(msg->msg_iov[i].iov_base); 476 free(msg->msg_iov); 477 msg->msg_iov = NULL; 478 msg->msg_iovlen = 0; 479 } 480 481 static int msg_alloc_iov(struct msghdr *msg, 482 int iov_count, int iov_length, 483 bool data, bool xmit) 484 { 485 unsigned char k = 0; 486 struct iovec *iov; 487 int i; 488 489 iov = calloc(iov_count, sizeof(struct iovec)); 490 if (!iov) 491 return errno; 492 493 for (i = 0; i < iov_count; i++) { 494 unsigned char *d = calloc(iov_length, sizeof(char)); 495 496 if (!d) { 497 fprintf(stderr, "iov_count %i/%i OOM\n", i, iov_count); 498 goto unwind_iov; 499 } 500 iov[i].iov_base = d; 501 iov[i].iov_len = iov_length; 502 503 if (data && xmit) { 504 int j; 505 506 for (j = 0; j < iov_length; j++) 507 d[j] = k++; 508 } 509 } 510 511 msg->msg_iov = iov; 512 msg->msg_iovlen = iov_count; 513 514 return 0; 515 unwind_iov: 516 for (i--; i >= 0 ; i--) 517 free(msg->msg_iov[i].iov_base); 518 return -ENOMEM; 519 } 520 521 /* In push or pop test, we need to do some calculations for msg_verify_data */ 522 static void msg_verify_date_prep(void) 523 { 524 int push_range_end = txmsg_start_push + txmsg_end_push - 1; 525 int pop_range_end = txmsg_start_pop + txmsg_pop - 1; 526 527 if (txmsg_end_push && txmsg_pop && 528 txmsg_start_push <= pop_range_end && txmsg_start_pop <= push_range_end) { 529 /* The push range and the pop range overlap */ 530 int overlap_len; 531 532 verify_push_start = txmsg_start_push; 533 verify_pop_start = txmsg_start_pop; 534 if (txmsg_start_push < txmsg_start_pop) 535 overlap_len = min(push_range_end - txmsg_start_pop + 1, txmsg_pop); 536 else 537 overlap_len = min(pop_range_end - txmsg_start_push + 1, txmsg_end_push); 538 verify_push_len = max(txmsg_end_push - overlap_len, 0); 539 verify_pop_len = max(txmsg_pop - overlap_len, 0); 540 } else { 541 /* Otherwise */ 542 verify_push_start = txmsg_start_push; 543 verify_pop_start = txmsg_start_pop; 544 verify_push_len = txmsg_end_push; 545 verify_pop_len = txmsg_pop; 546 } 547 } 548 549 static int msg_verify_data(struct msghdr *msg, int size, int chunk_sz, 550 unsigned char *k_p, int *bytes_cnt_p, 551 int *check_cnt_p, int *push_p) 552 { 553 int bytes_cnt = *bytes_cnt_p, check_cnt = *check_cnt_p, push = *push_p; 554 unsigned char k = *k_p; 555 int i, j; 556 557 for (i = 0, j = 0; i < msg->msg_iovlen && size; i++, j = 0) { 558 unsigned char *d = msg->msg_iov[i].iov_base; 559 560 /* Special case test for skb ingress + ktls */ 561 if (i == 0 && txmsg_ktls_skb) { 562 if (msg->msg_iov[i].iov_len < 4) 563 return -EDATAINTEGRITY; 564 if (memcmp(d, "PASS", 4) != 0) { 565 fprintf(stderr, 566 "detected skb data error with skb ingress update @iov[%i]:%i \"%02x %02x %02x %02x\" != \"PASS\"\n", 567 i, 0, d[0], d[1], d[2], d[3]); 568 return -EDATAINTEGRITY; 569 } 570 j = 4; /* advance index past PASS header */ 571 } 572 573 for (; j < msg->msg_iov[i].iov_len && size; j++) { 574 if (push > 0 && 575 check_cnt == verify_push_start + verify_push_len - push) { 576 int skipped; 577 revisit_push: 578 skipped = push; 579 if (j + push >= msg->msg_iov[i].iov_len) 580 skipped = msg->msg_iov[i].iov_len - j; 581 push -= skipped; 582 size -= skipped; 583 j += skipped - 1; 584 check_cnt += skipped; 585 continue; 586 } 587 588 if (verify_pop_len > 0 && check_cnt == verify_pop_start) { 589 bytes_cnt += verify_pop_len; 590 check_cnt += verify_pop_len; 591 k += verify_pop_len; 592 593 if (bytes_cnt == chunk_sz) { 594 k = 0; 595 bytes_cnt = 0; 596 check_cnt = 0; 597 push = verify_push_len; 598 } 599 600 if (push > 0 && 601 check_cnt == verify_push_start + verify_push_len - push) 602 goto revisit_push; 603 } 604 605 if (d[j] != k++) { 606 fprintf(stderr, 607 "detected data corruption @iov[%i]:%i %02x != %02x, %02x ?= %02x\n", 608 i, j, d[j], k - 1, d[j+1], k); 609 return -EDATAINTEGRITY; 610 } 611 bytes_cnt++; 612 check_cnt++; 613 if (bytes_cnt == chunk_sz) { 614 k = 0; 615 bytes_cnt = 0; 616 check_cnt = 0; 617 push = verify_push_len; 618 } 619 size--; 620 } 621 } 622 *k_p = k; 623 *bytes_cnt_p = bytes_cnt; 624 *check_cnt_p = check_cnt; 625 *push_p = push; 626 return 0; 627 } 628 629 static int msg_loop(int fd, int iov_count, int iov_length, int cnt, 630 struct msg_stats *s, bool tx, 631 struct sockmap_options *opt) 632 { 633 struct msghdr msg = {0}, msg_peek = {0}; 634 int err, i, flags = MSG_NOSIGNAL; 635 bool drop = opt->drop_expected; 636 bool data = opt->data_test; 637 int iov_alloc_length = iov_length; 638 639 if (!tx && opt->check_recved_len) 640 iov_alloc_length *= 2; 641 642 err = msg_alloc_iov(&msg, iov_count, iov_alloc_length, data, tx); 643 if (err) 644 goto out_errno; 645 if (peek_flag) { 646 err = msg_alloc_iov(&msg_peek, iov_count, iov_length, data, tx); 647 if (err) 648 goto out_errno; 649 } 650 651 if (tx) { 652 clock_gettime(CLOCK_MONOTONIC, &s->start); 653 for (i = 0; i < cnt; i++) { 654 int sent; 655 656 errno = 0; 657 sent = sendmsg(fd, &msg, flags); 658 659 if (!drop && sent < 0) { 660 if (opt->tx_wait_mem && errno == EACCES) { 661 errno = 0; 662 goto out_errno; 663 } 664 perror("sendmsg loop error"); 665 goto out_errno; 666 } else if (drop && sent >= 0) { 667 fprintf(stderr, 668 "sendmsg loop error expected: %i errno %i\n", 669 sent, errno); 670 errno = -EIO; 671 goto out_errno; 672 } 673 if (sent > 0) 674 s->bytes_sent += sent; 675 } 676 clock_gettime(CLOCK_MONOTONIC, &s->end); 677 } else { 678 float total_bytes, txmsg_pop_total, txmsg_push_total; 679 int slct, recvp = 0, recv, max_fd = fd; 680 int fd_flags = O_NONBLOCK; 681 struct timeval timeout; 682 unsigned char k = 0; 683 int bytes_cnt = 0; 684 int check_cnt = 0; 685 int push = 0; 686 fd_set w; 687 688 fcntl(fd, fd_flags); 689 /* Account for pop bytes noting each iteration of apply will 690 * call msg_pop_data helper so we need to account for this 691 * by calculating the number of apply iterations. Note user 692 * of the tool can create cases where no data is sent by 693 * manipulating pop/push/pull/etc. For example txmsg_apply 1 694 * with txmsg_pop 1 will try to apply 1B at a time but each 695 * iteration will then pop 1B so no data will ever be sent. 696 * This is really only useful for testing edge cases in code 697 * paths. 698 */ 699 total_bytes = (float)iov_length * (float)cnt; 700 if (!opt->sendpage) 701 total_bytes *= (float)iov_count; 702 if (txmsg_apply) { 703 txmsg_push_total = txmsg_end_push * (total_bytes / txmsg_apply); 704 txmsg_pop_total = txmsg_pop * (total_bytes / txmsg_apply); 705 } else { 706 txmsg_push_total = txmsg_end_push * cnt; 707 txmsg_pop_total = txmsg_pop * cnt; 708 } 709 total_bytes += txmsg_push_total; 710 total_bytes -= txmsg_pop_total; 711 if (data) { 712 msg_verify_date_prep(); 713 push = verify_push_len; 714 } 715 err = clock_gettime(CLOCK_MONOTONIC, &s->start); 716 if (err < 0) 717 perror("recv start time"); 718 while (s->bytes_recvd < total_bytes) { 719 if (txmsg_cork) { 720 timeout.tv_sec = 0; 721 timeout.tv_usec = 300000; 722 } else { 723 timeout.tv_sec = 3; 724 timeout.tv_usec = 0; 725 } 726 727 /* FD sets */ 728 FD_ZERO(&w); 729 FD_SET(fd, &w); 730 731 slct = select(max_fd + 1, &w, NULL, NULL, &timeout); 732 if (slct == -1) { 733 perror("select()"); 734 clock_gettime(CLOCK_MONOTONIC, &s->end); 735 goto out_errno; 736 } else if (!slct) { 737 if (opt->verbose) 738 fprintf(stderr, "unexpected timeout: recved %zu/%f pop_total %f\n", s->bytes_recvd, total_bytes, txmsg_pop_total); 739 errno = -EIO; 740 clock_gettime(CLOCK_MONOTONIC, &s->end); 741 goto out_errno; 742 } 743 744 if (opt->tx_wait_mem) { 745 FD_ZERO(&w); 746 FD_SET(fd, &w); 747 slct = select(max_fd + 1, NULL, NULL, &w, &timeout); 748 errno = 0; 749 close(fd); 750 goto out_errno; 751 } 752 753 errno = 0; 754 if (peek_flag) { 755 flags |= MSG_PEEK; 756 recvp = recvmsg(fd, &msg_peek, flags); 757 if (recvp < 0) { 758 if (errno != EWOULDBLOCK) { 759 clock_gettime(CLOCK_MONOTONIC, &s->end); 760 goto out_errno; 761 } 762 } 763 flags = 0; 764 } 765 766 recv = recvmsg(fd, &msg, flags); 767 if (recv < 0) { 768 if (errno != EWOULDBLOCK) { 769 clock_gettime(CLOCK_MONOTONIC, &s->end); 770 perror("recv failed()"); 771 goto out_errno; 772 } 773 } 774 775 if (recv > 0) 776 s->bytes_recvd += recv; 777 778 if (opt->check_recved_len && s->bytes_recvd > total_bytes) { 779 errno = EMSGSIZE; 780 fprintf(stderr, "recv failed(), bytes_recvd:%zd, total_bytes:%f\n", 781 s->bytes_recvd, total_bytes); 782 goto out_errno; 783 } 784 785 if (data) { 786 int chunk_sz = opt->sendpage ? 787 iov_length : 788 iov_length * iov_count; 789 790 errno = msg_verify_data(&msg, recv, chunk_sz, &k, &bytes_cnt, 791 &check_cnt, &push); 792 if (errno) { 793 perror("data verify msg failed"); 794 goto out_errno; 795 } 796 if (recvp) { 797 errno = msg_verify_data(&msg_peek, 798 recvp, 799 chunk_sz, 800 &k, 801 &bytes_cnt, 802 &check_cnt, 803 &push); 804 if (errno) { 805 perror("data verify msg_peek failed"); 806 goto out_errno; 807 } 808 } 809 } 810 } 811 clock_gettime(CLOCK_MONOTONIC, &s->end); 812 } 813 814 msg_free_iov(&msg); 815 msg_free_iov(&msg_peek); 816 return err; 817 out_errno: 818 msg_free_iov(&msg); 819 msg_free_iov(&msg_peek); 820 return errno; 821 } 822 823 static float giga = 1000000000; 824 825 static inline float sentBps(struct msg_stats s) 826 { 827 return s.bytes_sent / (s.end.tv_sec - s.start.tv_sec); 828 } 829 830 static inline float recvdBps(struct msg_stats s) 831 { 832 return s.bytes_recvd / (s.end.tv_sec - s.start.tv_sec); 833 } 834 835 static int sendmsg_test(struct sockmap_options *opt) 836 { 837 float sent_Bps = 0, recvd_Bps = 0; 838 int rx_fd, txpid, rxpid, err = 0; 839 struct msg_stats s = {0}; 840 int iov_count = opt->iov_count; 841 int iov_buf = opt->iov_length; 842 int rx_status, tx_status; 843 int cnt = opt->rate; 844 845 errno = 0; 846 847 if (opt->base) 848 rx_fd = p1; 849 else 850 rx_fd = p2; 851 852 if (ktls) { 853 /* Redirecting into non-TLS socket which sends into a TLS 854 * socket is not a valid test. So in this case lets not 855 * enable kTLS but still run the test. 856 */ 857 if (!txmsg_redir || txmsg_ingress) { 858 err = sockmap_init_ktls(opt->verbose, rx_fd); 859 if (err) 860 return err; 861 } 862 err = sockmap_init_ktls(opt->verbose, c1); 863 if (err) 864 return err; 865 } 866 867 if (opt->tx_wait_mem) { 868 struct timeval timeout; 869 int rxtx_buf_len = 1024; 870 871 timeout.tv_sec = 3; 872 timeout.tv_usec = 0; 873 874 err = setsockopt(c2, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(struct timeval)); 875 err |= setsockopt(c2, SOL_SOCKET, SO_SNDBUFFORCE, &rxtx_buf_len, sizeof(int)); 876 err |= setsockopt(p2, SOL_SOCKET, SO_RCVBUFFORCE, &rxtx_buf_len, sizeof(int)); 877 if (err) { 878 perror("setsockopt failed()"); 879 return errno; 880 } 881 } 882 883 rxpid = fork(); 884 if (rxpid == 0) { 885 if (opt->drop_expected || txmsg_ktls_skb_drop) 886 _exit(0); 887 888 if (!iov_buf) /* zero bytes sent case */ 889 _exit(0); 890 891 if (opt->sendpage) 892 iov_count = 1; 893 err = msg_loop(rx_fd, iov_count, iov_buf, 894 cnt, &s, false, opt); 895 if (opt->verbose > 1) 896 fprintf(stderr, 897 "msg_loop_rx: iov_count %i iov_buf %i cnt %i err %i\n", 898 iov_count, iov_buf, cnt, err); 899 if (s.end.tv_sec - s.start.tv_sec) { 900 sent_Bps = sentBps(s); 901 recvd_Bps = recvdBps(s); 902 } 903 if (opt->verbose > 1) 904 fprintf(stdout, 905 "rx_sendmsg: TX: %zuB %fB/s %fGB/s RX: %zuB %fB/s %fGB/s %s\n", 906 s.bytes_sent, sent_Bps, sent_Bps/giga, 907 s.bytes_recvd, recvd_Bps, recvd_Bps/giga, 908 peek_flag ? "(peek_msg)" : ""); 909 if (err && err != -EDATAINTEGRITY && txmsg_cork) 910 err = 0; 911 exit(err ? 1 : 0); 912 } else if (rxpid == -1) { 913 perror("msg_loop_rx"); 914 return errno; 915 } 916 917 if (opt->tx_wait_mem) 918 close(c2); 919 920 txpid = fork(); 921 if (txpid == 0) { 922 if (opt->sendpage) 923 err = msg_loop_sendpage(c1, iov_buf, cnt, &s, opt); 924 else 925 err = msg_loop(c1, iov_count, iov_buf, 926 cnt, &s, true, opt); 927 928 if (err) 929 fprintf(stderr, 930 "msg_loop_tx: iov_count %i iov_buf %i cnt %i err %i\n", 931 iov_count, iov_buf, cnt, err); 932 if (s.end.tv_sec - s.start.tv_sec) { 933 sent_Bps = sentBps(s); 934 recvd_Bps = recvdBps(s); 935 } 936 if (opt->verbose > 1) 937 fprintf(stdout, 938 "tx_sendmsg: TX: %zuB %fB/s %f GB/s RX: %zuB %fB/s %fGB/s\n", 939 s.bytes_sent, sent_Bps, sent_Bps/giga, 940 s.bytes_recvd, recvd_Bps, recvd_Bps/giga); 941 exit(err ? 1 : 0); 942 } else if (txpid == -1) { 943 perror("msg_loop_tx"); 944 return errno; 945 } 946 947 assert(waitpid(rxpid, &rx_status, 0) == rxpid); 948 assert(waitpid(txpid, &tx_status, 0) == txpid); 949 if (WIFEXITED(rx_status)) { 950 err = WEXITSTATUS(rx_status); 951 if (err) { 952 fprintf(stderr, "rx thread exited with err %d.\n", err); 953 goto out; 954 } 955 } 956 if (WIFEXITED(tx_status)) { 957 err = WEXITSTATUS(tx_status); 958 if (err) 959 fprintf(stderr, "tx thread exited with err %d.\n", err); 960 } 961 out: 962 return err; 963 } 964 965 static int forever_ping_pong(int rate, struct sockmap_options *opt) 966 { 967 struct timeval timeout; 968 char buf[1024] = {0}; 969 int sc; 970 971 timeout.tv_sec = 10; 972 timeout.tv_usec = 0; 973 974 /* Ping/Pong data from client to server */ 975 sc = send(c1, buf, sizeof(buf), 0); 976 if (sc < 0) { 977 perror("send failed()"); 978 return sc; 979 } 980 981 do { 982 int s, rc, i, max_fd = p2; 983 fd_set w; 984 985 /* FD sets */ 986 FD_ZERO(&w); 987 FD_SET(c1, &w); 988 FD_SET(c2, &w); 989 FD_SET(p1, &w); 990 FD_SET(p2, &w); 991 992 s = select(max_fd + 1, &w, NULL, NULL, &timeout); 993 if (s == -1) { 994 perror("select()"); 995 break; 996 } else if (!s) { 997 fprintf(stderr, "unexpected timeout\n"); 998 break; 999 } 1000 1001 for (i = 0; i <= max_fd && s > 0; ++i) { 1002 if (!FD_ISSET(i, &w)) 1003 continue; 1004 1005 s--; 1006 1007 rc = recv(i, buf, sizeof(buf), 0); 1008 if (rc < 0) { 1009 if (errno != EWOULDBLOCK) { 1010 perror("recv failed()"); 1011 return rc; 1012 } 1013 } 1014 1015 if (rc == 0) { 1016 close(i); 1017 break; 1018 } 1019 1020 sc = send(i, buf, rc, 0); 1021 if (sc < 0) { 1022 perror("send failed()"); 1023 return sc; 1024 } 1025 } 1026 1027 if (rate) 1028 sleep(rate); 1029 1030 if (opt->verbose) { 1031 printf("."); 1032 fflush(stdout); 1033 1034 } 1035 } while (running); 1036 1037 return 0; 1038 } 1039 1040 enum { 1041 SELFTESTS, 1042 PING_PONG, 1043 SENDMSG, 1044 BASE, 1045 BASE_SENDPAGE, 1046 SENDPAGE, 1047 }; 1048 1049 static int run_options(struct sockmap_options *options, int cg_fd, int test) 1050 { 1051 int i, key, next_key, err, zero = 0; 1052 struct bpf_program *tx_prog; 1053 1054 /* If base test skip BPF setup */ 1055 if (test == BASE || test == BASE_SENDPAGE) 1056 goto run; 1057 1058 /* Attach programs to sockmap */ 1059 if (!txmsg_omit_skb_parser) { 1060 links[0] = bpf_program__attach_sockmap(progs[0], map_fd[0]); 1061 if (!links[0]) { 1062 fprintf(stderr, 1063 "ERROR: bpf_program__attach_sockmap (sockmap %i->%i): (%s)\n", 1064 bpf_program__fd(progs[0]), map_fd[0], strerror(errno)); 1065 return -1; 1066 } 1067 } 1068 1069 links[1] = bpf_program__attach_sockmap(progs[1], map_fd[0]); 1070 if (!links[1]) { 1071 fprintf(stderr, "ERROR: bpf_program__attach_sockmap (sockmap): (%s)\n", 1072 strerror(errno)); 1073 return -1; 1074 } 1075 1076 /* Attach programs to TLS sockmap */ 1077 if (txmsg_ktls_skb) { 1078 if (!txmsg_omit_skb_parser) { 1079 links[2] = bpf_program__attach_sockmap(progs[0], map_fd[8]); 1080 if (!links[2]) { 1081 fprintf(stderr, 1082 "ERROR: bpf_program__attach_sockmap (TLS sockmap %i->%i): (%s)\n", 1083 bpf_program__fd(progs[0]), map_fd[8], strerror(errno)); 1084 return -1; 1085 } 1086 } 1087 1088 links[3] = bpf_program__attach_sockmap(progs[2], map_fd[8]); 1089 if (!links[3]) { 1090 fprintf(stderr, "ERROR: bpf_program__attach_sockmap (TLS sockmap): (%s)\n", 1091 strerror(errno)); 1092 return -1; 1093 } 1094 } 1095 1096 /* Attach to cgroups */ 1097 err = bpf_prog_attach(bpf_program__fd(progs[3]), cg_fd, BPF_CGROUP_SOCK_OPS, 0); 1098 if (err) { 1099 fprintf(stderr, "ERROR: bpf_prog_attach (groups): %d (%s)\n", 1100 err, strerror(errno)); 1101 return err; 1102 } 1103 1104 run: 1105 err = sockmap_init_sockets(options->verbose); 1106 if (err) { 1107 fprintf(stderr, "ERROR: test socket failed: %d\n", err); 1108 goto out; 1109 } 1110 1111 /* Attach txmsg program to sockmap */ 1112 if (txmsg_pass) 1113 tx_prog = progs[4]; 1114 else if (txmsg_redir) 1115 tx_prog = progs[5]; 1116 else if (txmsg_apply) 1117 tx_prog = progs[6]; 1118 else if (txmsg_cork) 1119 tx_prog = progs[7]; 1120 else if (txmsg_drop) 1121 tx_prog = progs[8]; 1122 else 1123 tx_prog = NULL; 1124 1125 if (tx_prog) { 1126 int redir_fd; 1127 1128 links[4] = bpf_program__attach_sockmap(tx_prog, map_fd[1]); 1129 if (!links[4]) { 1130 fprintf(stderr, 1131 "ERROR: bpf_program__attach_sockmap (txmsg): (%s)\n", 1132 strerror(errno)); 1133 err = -1; 1134 goto out; 1135 } 1136 1137 i = 0; 1138 err = bpf_map_update_elem(map_fd[1], &i, &c1, BPF_ANY); 1139 if (err) { 1140 fprintf(stderr, 1141 "ERROR: bpf_map_update_elem (txmsg): %d (%s\n", 1142 err, strerror(errno)); 1143 goto out; 1144 } 1145 1146 if (txmsg_redir) 1147 redir_fd = c2; 1148 else 1149 redir_fd = c1; 1150 1151 err = bpf_map_update_elem(map_fd[2], &i, &redir_fd, BPF_ANY); 1152 if (err) { 1153 fprintf(stderr, 1154 "ERROR: bpf_map_update_elem (txmsg): %d (%s\n", 1155 err, strerror(errno)); 1156 goto out; 1157 } 1158 1159 if (txmsg_apply) { 1160 err = bpf_map_update_elem(map_fd[3], 1161 &i, &txmsg_apply, BPF_ANY); 1162 if (err) { 1163 fprintf(stderr, 1164 "ERROR: bpf_map_update_elem (apply_bytes): %d (%s\n", 1165 err, strerror(errno)); 1166 goto out; 1167 } 1168 } 1169 1170 if (txmsg_cork) { 1171 err = bpf_map_update_elem(map_fd[4], 1172 &i, &txmsg_cork, BPF_ANY); 1173 if (err) { 1174 fprintf(stderr, 1175 "ERROR: bpf_map_update_elem (cork_bytes): %d (%s\n", 1176 err, strerror(errno)); 1177 goto out; 1178 } 1179 } 1180 1181 if (txmsg_start) { 1182 err = bpf_map_update_elem(map_fd[5], 1183 &i, &txmsg_start, BPF_ANY); 1184 if (err) { 1185 fprintf(stderr, 1186 "ERROR: bpf_map_update_elem (txmsg_start): %d (%s)\n", 1187 err, strerror(errno)); 1188 goto out; 1189 } 1190 } 1191 1192 if (txmsg_end) { 1193 i = 1; 1194 err = bpf_map_update_elem(map_fd[5], 1195 &i, &txmsg_end, BPF_ANY); 1196 if (err) { 1197 fprintf(stderr, 1198 "ERROR: bpf_map_update_elem (txmsg_end): %d (%s)\n", 1199 err, strerror(errno)); 1200 goto out; 1201 } 1202 } 1203 1204 if (txmsg_start_push) { 1205 i = 2; 1206 err = bpf_map_update_elem(map_fd[5], 1207 &i, &txmsg_start_push, BPF_ANY); 1208 if (err) { 1209 fprintf(stderr, 1210 "ERROR: bpf_map_update_elem (txmsg_start_push): %d (%s)\n", 1211 err, strerror(errno)); 1212 goto out; 1213 } 1214 } 1215 1216 if (txmsg_end_push) { 1217 i = 3; 1218 err = bpf_map_update_elem(map_fd[5], 1219 &i, &txmsg_end_push, BPF_ANY); 1220 if (err) { 1221 fprintf(stderr, 1222 "ERROR: bpf_map_update_elem %i@%i (txmsg_end_push): %d (%s)\n", 1223 txmsg_end_push, i, err, strerror(errno)); 1224 goto out; 1225 } 1226 } 1227 1228 if (txmsg_start_pop) { 1229 i = 4; 1230 err = bpf_map_update_elem(map_fd[5], 1231 &i, &txmsg_start_pop, BPF_ANY); 1232 if (err) { 1233 fprintf(stderr, 1234 "ERROR: bpf_map_update_elem %i@%i (txmsg_start_pop): %d (%s)\n", 1235 txmsg_start_pop, i, err, strerror(errno)); 1236 goto out; 1237 } 1238 } else { 1239 i = 4; 1240 bpf_map_update_elem(map_fd[5], 1241 &i, &txmsg_start_pop, BPF_ANY); 1242 } 1243 1244 if (txmsg_pop) { 1245 i = 5; 1246 err = bpf_map_update_elem(map_fd[5], 1247 &i, &txmsg_pop, BPF_ANY); 1248 if (err) { 1249 fprintf(stderr, 1250 "ERROR: bpf_map_update_elem %i@%i (txmsg_pop): %d (%s)\n", 1251 txmsg_pop, i, err, strerror(errno)); 1252 goto out; 1253 } 1254 } else { 1255 i = 5; 1256 bpf_map_update_elem(map_fd[5], 1257 &i, &txmsg_pop, BPF_ANY); 1258 1259 } 1260 1261 if (txmsg_ingress) { 1262 int in = BPF_F_INGRESS; 1263 1264 i = 0; 1265 err = bpf_map_update_elem(map_fd[6], &i, &in, BPF_ANY); 1266 if (err) { 1267 fprintf(stderr, 1268 "ERROR: bpf_map_update_elem (txmsg_ingress): %d (%s)\n", 1269 err, strerror(errno)); 1270 } 1271 i = 1; 1272 err = bpf_map_update_elem(map_fd[1], &i, &p1, BPF_ANY); 1273 if (err) { 1274 fprintf(stderr, 1275 "ERROR: bpf_map_update_elem (p1 txmsg): %d (%s)\n", 1276 err, strerror(errno)); 1277 } 1278 err = bpf_map_update_elem(map_fd[2], &i, &p1, BPF_ANY); 1279 if (err) { 1280 fprintf(stderr, 1281 "ERROR: bpf_map_update_elem (p1 redir): %d (%s)\n", 1282 err, strerror(errno)); 1283 } 1284 1285 i = 2; 1286 err = bpf_map_update_elem(map_fd[2], &i, &p2, BPF_ANY); 1287 if (err) { 1288 fprintf(stderr, 1289 "ERROR: bpf_map_update_elem (p2 txmsg): %d (%s)\n", 1290 err, strerror(errno)); 1291 } 1292 } 1293 1294 if (txmsg_ktls_skb) { 1295 int ingress = BPF_F_INGRESS; 1296 1297 i = 0; 1298 err = bpf_map_update_elem(map_fd[8], &i, &p2, BPF_ANY); 1299 if (err) { 1300 fprintf(stderr, 1301 "ERROR: bpf_map_update_elem (c1 sockmap): %d (%s)\n", 1302 err, strerror(errno)); 1303 } 1304 1305 if (txmsg_ktls_skb_redir) { 1306 i = 1; 1307 err = bpf_map_update_elem(map_fd[7], 1308 &i, &ingress, BPF_ANY); 1309 if (err) { 1310 fprintf(stderr, 1311 "ERROR: bpf_map_update_elem (txmsg_ingress): %d (%s)\n", 1312 err, strerror(errno)); 1313 } 1314 } 1315 1316 if (txmsg_ktls_skb_drop) { 1317 i = 1; 1318 err = bpf_map_update_elem(map_fd[7], &i, &i, BPF_ANY); 1319 } 1320 } 1321 1322 if (txmsg_redir_skb) { 1323 int skb_fd = (test == SENDMSG || test == SENDPAGE) ? 1324 p2 : p1; 1325 int ingress = BPF_F_INGRESS; 1326 1327 i = 0; 1328 err = bpf_map_update_elem(map_fd[7], 1329 &i, &ingress, BPF_ANY); 1330 if (err) { 1331 fprintf(stderr, 1332 "ERROR: bpf_map_update_elem (txmsg_ingress): %d (%s)\n", 1333 err, strerror(errno)); 1334 } 1335 1336 i = 3; 1337 err = bpf_map_update_elem(map_fd[0], &i, &skb_fd, BPF_ANY); 1338 if (err) { 1339 fprintf(stderr, 1340 "ERROR: bpf_map_update_elem (c1 sockmap): %d (%s)\n", 1341 err, strerror(errno)); 1342 } 1343 } 1344 } 1345 1346 if (skb_use_parser) { 1347 i = 2; 1348 err = bpf_map_update_elem(map_fd[7], &i, &skb_use_parser, BPF_ANY); 1349 } 1350 1351 if (txmsg_drop) 1352 options->drop_expected = true; 1353 1354 if (test == PING_PONG) 1355 err = forever_ping_pong(options->rate, options); 1356 else if (test == SENDMSG) { 1357 options->base = false; 1358 options->sendpage = false; 1359 err = sendmsg_test(options); 1360 } else if (test == SENDPAGE) { 1361 options->base = false; 1362 options->sendpage = true; 1363 err = sendmsg_test(options); 1364 } else if (test == BASE) { 1365 options->base = true; 1366 options->sendpage = false; 1367 err = sendmsg_test(options); 1368 } else if (test == BASE_SENDPAGE) { 1369 options->base = true; 1370 options->sendpage = true; 1371 err = sendmsg_test(options); 1372 } else 1373 fprintf(stderr, "unknown test\n"); 1374 out: 1375 /* Detach and zero all the maps */ 1376 bpf_prog_detach2(bpf_program__fd(progs[3]), cg_fd, BPF_CGROUP_SOCK_OPS); 1377 1378 for (i = 0; i < ARRAY_SIZE(links); i++) { 1379 if (links[i]) 1380 bpf_link__detach(links[i]); 1381 } 1382 1383 for (i = 0; i < ARRAY_SIZE(map_fd); i++) { 1384 key = next_key = 0; 1385 bpf_map_update_elem(map_fd[i], &key, &zero, BPF_ANY); 1386 while (bpf_map_get_next_key(map_fd[i], &key, &next_key) == 0) { 1387 bpf_map_update_elem(map_fd[i], &key, &zero, BPF_ANY); 1388 key = next_key; 1389 } 1390 } 1391 1392 close(s1); 1393 close(s2); 1394 close(p1); 1395 close(p2); 1396 close(c1); 1397 close(c2); 1398 return err; 1399 } 1400 1401 static char *test_to_str(int test) 1402 { 1403 switch (test) { 1404 case SENDMSG: 1405 return "sendmsg"; 1406 case SENDPAGE: 1407 return "sendpage"; 1408 } 1409 return "unknown"; 1410 } 1411 1412 static void append_str(char *dst, const char *src, size_t dst_cap) 1413 { 1414 size_t avail = dst_cap - strlen(dst); 1415 1416 if (avail <= 1) /* just zero byte could be written */ 1417 return; 1418 1419 strncat(dst, src, avail - 1); /* strncat() adds + 1 for zero byte */ 1420 } 1421 1422 #define OPTSTRING 60 1423 static void test_options(char *options) 1424 { 1425 char tstr[OPTSTRING]; 1426 1427 memset(options, 0, OPTSTRING); 1428 1429 if (txmsg_pass) 1430 append_str(options, "pass,", OPTSTRING); 1431 if (txmsg_redir) 1432 append_str(options, "redir,", OPTSTRING); 1433 if (txmsg_drop) 1434 append_str(options, "drop,", OPTSTRING); 1435 if (txmsg_apply) { 1436 snprintf(tstr, OPTSTRING, "apply %d,", txmsg_apply); 1437 append_str(options, tstr, OPTSTRING); 1438 } 1439 if (txmsg_cork) { 1440 snprintf(tstr, OPTSTRING, "cork %d,", txmsg_cork); 1441 append_str(options, tstr, OPTSTRING); 1442 } 1443 if (txmsg_start) { 1444 snprintf(tstr, OPTSTRING, "start %d,", txmsg_start); 1445 append_str(options, tstr, OPTSTRING); 1446 } 1447 if (txmsg_end) { 1448 snprintf(tstr, OPTSTRING, "end %d,", txmsg_end); 1449 append_str(options, tstr, OPTSTRING); 1450 } 1451 if (txmsg_start_pop) { 1452 snprintf(tstr, OPTSTRING, "pop (%d,%d),", 1453 txmsg_start_pop, txmsg_start_pop + txmsg_pop); 1454 append_str(options, tstr, OPTSTRING); 1455 } 1456 if (txmsg_ingress) 1457 append_str(options, "ingress,", OPTSTRING); 1458 if (txmsg_redir_skb) 1459 append_str(options, "redir_skb,", OPTSTRING); 1460 if (txmsg_ktls_skb) 1461 append_str(options, "ktls_skb,", OPTSTRING); 1462 if (ktls) 1463 append_str(options, "ktls,", OPTSTRING); 1464 if (peek_flag) 1465 append_str(options, "peek,", OPTSTRING); 1466 } 1467 1468 static int __test_exec(int cgrp, int test, struct sockmap_options *opt) 1469 { 1470 char *options = calloc(OPTSTRING, sizeof(char)); 1471 int err; 1472 1473 if (test == SENDPAGE) 1474 opt->sendpage = true; 1475 else 1476 opt->sendpage = false; 1477 1478 if (txmsg_drop) 1479 opt->drop_expected = true; 1480 else 1481 opt->drop_expected = false; 1482 1483 test_options(options); 1484 1485 if (opt->verbose) { 1486 fprintf(stdout, 1487 " [TEST %i]: (%i, %i, %i, %s, %s): ", 1488 test_cnt, opt->rate, opt->iov_count, opt->iov_length, 1489 test_to_str(test), options); 1490 fflush(stdout); 1491 } 1492 err = run_options(opt, cgrp, test); 1493 if (opt->verbose) 1494 fprintf(stdout, " %s\n", !err ? "PASS" : "FAILED"); 1495 test_cnt++; 1496 !err ? passed++ : failed++; 1497 free(options); 1498 return err; 1499 } 1500 1501 static void test_exec(int cgrp, struct sockmap_options *opt) 1502 { 1503 int type = strcmp(opt->map, BPF_SOCKMAP_FILENAME); 1504 int err; 1505 1506 if (type == 0) { 1507 test_start(); 1508 err = __test_exec(cgrp, SENDMSG, opt); 1509 if (err) 1510 test_fail(); 1511 } else { 1512 test_start(); 1513 err = __test_exec(cgrp, SENDPAGE, opt); 1514 if (err) 1515 test_fail(); 1516 } 1517 } 1518 1519 static void test_send_one(struct sockmap_options *opt, int cgrp) 1520 { 1521 opt->iov_length = 1; 1522 opt->iov_count = 1; 1523 opt->rate = 1; 1524 test_exec(cgrp, opt); 1525 1526 opt->iov_length = 1; 1527 opt->iov_count = 1024; 1528 opt->rate = 1; 1529 test_exec(cgrp, opt); 1530 1531 opt->iov_length = 1024; 1532 opt->iov_count = 1; 1533 opt->rate = 1; 1534 test_exec(cgrp, opt); 1535 1536 } 1537 1538 static void test_send_many(struct sockmap_options *opt, int cgrp) 1539 { 1540 opt->iov_length = 3; 1541 opt->iov_count = 1; 1542 opt->rate = 512; 1543 test_exec(cgrp, opt); 1544 1545 opt->rate = 100; 1546 opt->iov_count = 1; 1547 opt->iov_length = 5; 1548 test_exec(cgrp, opt); 1549 } 1550 1551 static void test_send_large(struct sockmap_options *opt, int cgrp) 1552 { 1553 opt->iov_length = 8192; 1554 opt->iov_count = 32; 1555 opt->rate = 2; 1556 test_exec(cgrp, opt); 1557 } 1558 1559 static void test_send(struct sockmap_options *opt, int cgrp) 1560 { 1561 test_send_one(opt, cgrp); 1562 test_send_many(opt, cgrp); 1563 test_send_large(opt, cgrp); 1564 sched_yield(); 1565 } 1566 1567 static void test_txmsg_pass(int cgrp, struct sockmap_options *opt) 1568 { 1569 /* Test small and large iov_count values with pass/redir/apply/cork */ 1570 txmsg_pass = 1; 1571 test_send(opt, cgrp); 1572 } 1573 1574 static void test_txmsg_redir(int cgrp, struct sockmap_options *opt) 1575 { 1576 txmsg_redir = 1; 1577 test_send(opt, cgrp); 1578 } 1579 1580 static void test_txmsg_redir_wait_sndmem(int cgrp, struct sockmap_options *opt) 1581 { 1582 opt->tx_wait_mem = true; 1583 txmsg_redir = 1; 1584 test_send_large(opt, cgrp); 1585 1586 txmsg_redir = 1; 1587 txmsg_apply = 4097; 1588 test_send_large(opt, cgrp); 1589 opt->tx_wait_mem = false; 1590 } 1591 1592 static void test_txmsg_drop(int cgrp, struct sockmap_options *opt) 1593 { 1594 txmsg_drop = 1; 1595 test_send(opt, cgrp); 1596 } 1597 1598 static void test_txmsg_ingress_redir(int cgrp, struct sockmap_options *opt) 1599 { 1600 txmsg_pass = txmsg_drop = 0; 1601 txmsg_ingress = txmsg_redir = 1; 1602 test_send(opt, cgrp); 1603 } 1604 1605 static void test_txmsg_skb(int cgrp, struct sockmap_options *opt) 1606 { 1607 bool data = opt->data_test; 1608 int k = ktls; 1609 1610 opt->data_test = true; 1611 ktls = 1; 1612 1613 txmsg_pass = txmsg_drop = 0; 1614 txmsg_ingress = txmsg_redir = 0; 1615 txmsg_ktls_skb = 1; 1616 txmsg_pass = 1; 1617 1618 /* Using data verification so ensure iov layout is 1619 * expected from test receiver side. e.g. has enough 1620 * bytes to write test code. 1621 */ 1622 opt->iov_length = 100; 1623 opt->iov_count = 1; 1624 opt->rate = 1; 1625 test_exec(cgrp, opt); 1626 1627 txmsg_ktls_skb_drop = 1; 1628 test_exec(cgrp, opt); 1629 1630 txmsg_ktls_skb_drop = 0; 1631 txmsg_ktls_skb_redir = 1; 1632 test_exec(cgrp, opt); 1633 txmsg_ktls_skb_redir = 0; 1634 1635 /* Tests that omit skb_parser */ 1636 txmsg_omit_skb_parser = 1; 1637 ktls = 0; 1638 txmsg_ktls_skb = 0; 1639 test_exec(cgrp, opt); 1640 1641 txmsg_ktls_skb_drop = 1; 1642 test_exec(cgrp, opt); 1643 txmsg_ktls_skb_drop = 0; 1644 1645 txmsg_ktls_skb_redir = 1; 1646 test_exec(cgrp, opt); 1647 1648 ktls = 1; 1649 test_exec(cgrp, opt); 1650 txmsg_omit_skb_parser = 0; 1651 1652 opt->data_test = data; 1653 ktls = k; 1654 } 1655 1656 /* Test cork with hung data. This tests poor usage patterns where 1657 * cork can leave data on the ring if user program is buggy and 1658 * doesn't flush them somehow. They do take some time however 1659 * because they wait for a timeout. Test pass, redir and cork with 1660 * apply logic. Use cork size of 4097 with send_large to avoid 1661 * aligning cork size with send size. 1662 */ 1663 static void test_txmsg_cork_hangs(int cgrp, struct sockmap_options *opt) 1664 { 1665 txmsg_pass = 1; 1666 txmsg_redir = 0; 1667 txmsg_cork = 4097; 1668 txmsg_apply = 4097; 1669 test_send_large(opt, cgrp); 1670 1671 txmsg_pass = 0; 1672 txmsg_redir = 1; 1673 txmsg_apply = 0; 1674 txmsg_cork = 4097; 1675 test_send_large(opt, cgrp); 1676 1677 txmsg_pass = 0; 1678 txmsg_redir = 1; 1679 txmsg_apply = 4097; 1680 txmsg_cork = 4097; 1681 test_send_large(opt, cgrp); 1682 } 1683 1684 static void test_txmsg_pull(int cgrp, struct sockmap_options *opt) 1685 { 1686 /* Test basic start/end */ 1687 txmsg_pass = 1; 1688 txmsg_start = 1; 1689 txmsg_end = 2; 1690 test_send(opt, cgrp); 1691 1692 /* Test >4k pull */ 1693 txmsg_pass = 1; 1694 txmsg_start = 4096; 1695 txmsg_end = 9182; 1696 test_send_large(opt, cgrp); 1697 1698 /* Test pull + redirect */ 1699 txmsg_redir = 1; 1700 txmsg_start = 1; 1701 txmsg_end = 2; 1702 test_send(opt, cgrp); 1703 1704 /* Test pull + cork */ 1705 txmsg_redir = 0; 1706 txmsg_cork = 512; 1707 txmsg_start = 1; 1708 txmsg_end = 2; 1709 test_send_many(opt, cgrp); 1710 1711 /* Test pull + cork + redirect */ 1712 txmsg_redir = 1; 1713 txmsg_cork = 512; 1714 txmsg_start = 1; 1715 txmsg_end = 2; 1716 test_send_many(opt, cgrp); 1717 } 1718 1719 static void test_txmsg_pop(int cgrp, struct sockmap_options *opt) 1720 { 1721 bool data = opt->data_test; 1722 1723 /* Test basic pop */ 1724 txmsg_pass = 1; 1725 txmsg_start_pop = 1; 1726 txmsg_pop = 2; 1727 test_send_many(opt, cgrp); 1728 1729 /* Test pop with >4k */ 1730 txmsg_pass = 1; 1731 txmsg_start_pop = 4096; 1732 txmsg_pop = 4096; 1733 test_send_large(opt, cgrp); 1734 1735 /* Test pop + redirect */ 1736 txmsg_redir = 1; 1737 txmsg_start_pop = 1; 1738 txmsg_pop = 2; 1739 test_send_many(opt, cgrp); 1740 1741 /* TODO: Test for pop + cork should be different, 1742 * - It makes the layout of the received data difficult 1743 * - It makes it hard to calculate the total_bytes in the recvmsg 1744 * Temporarily skip the data integrity test for this case now. 1745 */ 1746 opt->data_test = false; 1747 /* Test pop + cork */ 1748 txmsg_redir = 0; 1749 txmsg_cork = 512; 1750 txmsg_start_pop = 1; 1751 txmsg_pop = 2; 1752 test_send_many(opt, cgrp); 1753 1754 /* Test pop + redirect + cork */ 1755 txmsg_redir = 1; 1756 txmsg_cork = 4; 1757 txmsg_start_pop = 1; 1758 txmsg_pop = 2; 1759 test_send_many(opt, cgrp); 1760 opt->data_test = data; 1761 } 1762 1763 static void test_txmsg_push(int cgrp, struct sockmap_options *opt) 1764 { 1765 bool data = opt->data_test; 1766 1767 /* Test basic push */ 1768 txmsg_pass = 1; 1769 txmsg_start_push = 1; 1770 txmsg_end_push = 1; 1771 test_send(opt, cgrp); 1772 1773 /* Test push 4kB >4k */ 1774 txmsg_pass = 1; 1775 txmsg_start_push = 4096; 1776 txmsg_end_push = 4096; 1777 test_send_large(opt, cgrp); 1778 1779 /* Test push + redirect */ 1780 txmsg_redir = 1; 1781 txmsg_start_push = 1; 1782 txmsg_end_push = 2; 1783 test_send_many(opt, cgrp); 1784 1785 /* TODO: Test for push + cork should be different, 1786 * - It makes the layout of the received data difficult 1787 * - It makes it hard to calculate the total_bytes in the recvmsg 1788 * Temporarily skip the data integrity test for this case now. 1789 */ 1790 opt->data_test = false; 1791 /* Test push + cork */ 1792 txmsg_redir = 0; 1793 txmsg_cork = 512; 1794 txmsg_start_push = 1; 1795 txmsg_end_push = 2; 1796 test_send_many(opt, cgrp); 1797 opt->data_test = data; 1798 } 1799 1800 static void test_txmsg_push_pop(int cgrp, struct sockmap_options *opt) 1801 { 1802 /* Test push/pop range overlapping */ 1803 txmsg_pass = 1; 1804 txmsg_start_push = 1; 1805 txmsg_end_push = 10; 1806 txmsg_start_pop = 5; 1807 txmsg_pop = 4; 1808 test_send_large(opt, cgrp); 1809 1810 txmsg_pass = 1; 1811 txmsg_start_push = 1; 1812 txmsg_end_push = 10; 1813 txmsg_start_pop = 5; 1814 txmsg_pop = 16; 1815 test_send_large(opt, cgrp); 1816 1817 txmsg_pass = 1; 1818 txmsg_start_push = 5; 1819 txmsg_end_push = 4; 1820 txmsg_start_pop = 1; 1821 txmsg_pop = 10; 1822 test_send_large(opt, cgrp); 1823 1824 txmsg_pass = 1; 1825 txmsg_start_push = 5; 1826 txmsg_end_push = 16; 1827 txmsg_start_pop = 1; 1828 txmsg_pop = 10; 1829 test_send_large(opt, cgrp); 1830 1831 /* Test push/pop range non-overlapping */ 1832 txmsg_pass = 1; 1833 txmsg_start_push = 1; 1834 txmsg_end_push = 10; 1835 txmsg_start_pop = 16; 1836 txmsg_pop = 4; 1837 test_send_large(opt, cgrp); 1838 1839 txmsg_pass = 1; 1840 txmsg_start_push = 16; 1841 txmsg_end_push = 10; 1842 txmsg_start_pop = 5; 1843 txmsg_pop = 4; 1844 test_send_large(opt, cgrp); 1845 } 1846 1847 static void test_txmsg_apply(int cgrp, struct sockmap_options *opt) 1848 { 1849 txmsg_pass = 1; 1850 txmsg_redir = 0; 1851 txmsg_ingress = 0; 1852 txmsg_apply = 1; 1853 txmsg_cork = 0; 1854 test_send_one(opt, cgrp); 1855 1856 txmsg_pass = 0; 1857 txmsg_redir = 1; 1858 txmsg_ingress = 0; 1859 txmsg_apply = 1; 1860 txmsg_cork = 0; 1861 test_send_one(opt, cgrp); 1862 1863 txmsg_pass = 0; 1864 txmsg_redir = 1; 1865 txmsg_ingress = 1; 1866 txmsg_apply = 1; 1867 txmsg_cork = 0; 1868 test_send_one(opt, cgrp); 1869 1870 txmsg_pass = 1; 1871 txmsg_redir = 0; 1872 txmsg_ingress = 0; 1873 txmsg_apply = 1024; 1874 txmsg_cork = 0; 1875 test_send_large(opt, cgrp); 1876 1877 txmsg_pass = 0; 1878 txmsg_redir = 1; 1879 txmsg_ingress = 0; 1880 txmsg_apply = 1024; 1881 txmsg_cork = 0; 1882 test_send_large(opt, cgrp); 1883 1884 txmsg_pass = 0; 1885 txmsg_redir = 1; 1886 txmsg_ingress = 1; 1887 txmsg_apply = 1024; 1888 txmsg_cork = 0; 1889 test_send_large(opt, cgrp); 1890 } 1891 1892 static void test_txmsg_cork(int cgrp, struct sockmap_options *opt) 1893 { 1894 txmsg_pass = 1; 1895 txmsg_redir = 0; 1896 txmsg_apply = 0; 1897 txmsg_cork = 1; 1898 test_send(opt, cgrp); 1899 1900 txmsg_pass = 1; 1901 txmsg_redir = 0; 1902 txmsg_apply = 1; 1903 txmsg_cork = 1; 1904 test_send(opt, cgrp); 1905 } 1906 1907 static void test_txmsg_ingress_parser(int cgrp, struct sockmap_options *opt) 1908 { 1909 txmsg_pass = 1; 1910 skb_use_parser = 512; 1911 if (ktls == 1) 1912 skb_use_parser = 570; 1913 opt->iov_length = 256; 1914 opt->iov_count = 1; 1915 opt->rate = 2; 1916 test_exec(cgrp, opt); 1917 } 1918 1919 static void test_txmsg_ingress_parser2(int cgrp, struct sockmap_options *opt) 1920 { 1921 if (ktls == 1) 1922 return; 1923 skb_use_parser = 10; 1924 opt->iov_length = 20; 1925 opt->iov_count = 1; 1926 opt->rate = 1; 1927 opt->check_recved_len = true; 1928 test_exec(cgrp, opt); 1929 opt->check_recved_len = false; 1930 } 1931 1932 char *map_names[] = { 1933 "sock_map", 1934 "sock_map_txmsg", 1935 "sock_map_redir", 1936 "sock_apply_bytes", 1937 "sock_cork_bytes", 1938 "sock_bytes", 1939 "sock_redir_flags", 1940 "sock_skb_opts", 1941 "tls_sock_map", 1942 }; 1943 1944 static int populate_progs(char *bpf_file) 1945 { 1946 struct bpf_program *prog; 1947 struct bpf_object *obj; 1948 int i = 0; 1949 long err; 1950 1951 obj = bpf_object__open(bpf_file); 1952 err = libbpf_get_error(obj); 1953 if (err) { 1954 char err_buf[256]; 1955 1956 libbpf_strerror(err, err_buf, sizeof(err_buf)); 1957 printf("Unable to load eBPF objects in file '%s' : %s\n", 1958 bpf_file, err_buf); 1959 return -1; 1960 } 1961 1962 i = bpf_object__load(obj); 1963 i = 0; 1964 bpf_object__for_each_program(prog, obj) { 1965 progs[i] = prog; 1966 i++; 1967 } 1968 1969 for (i = 0; i < ARRAY_SIZE(map_fd); i++) { 1970 maps[i] = bpf_object__find_map_by_name(obj, map_names[i]); 1971 map_fd[i] = bpf_map__fd(maps[i]); 1972 if (map_fd[i] < 0) { 1973 fprintf(stderr, "load_bpf_file: (%i) %s\n", 1974 map_fd[i], strerror(errno)); 1975 return -1; 1976 } 1977 } 1978 1979 for (i = 0; i < ARRAY_SIZE(links); i++) 1980 links[i] = NULL; 1981 1982 return 0; 1983 } 1984 1985 struct _test test[] = { 1986 {"txmsg test passthrough", test_txmsg_pass}, 1987 {"txmsg test redirect", test_txmsg_redir}, 1988 {"txmsg test redirect wait send mem", test_txmsg_redir_wait_sndmem}, 1989 {"txmsg test drop", test_txmsg_drop}, 1990 {"txmsg test ingress redirect", test_txmsg_ingress_redir}, 1991 {"txmsg test skb", test_txmsg_skb}, 1992 {"txmsg test apply", test_txmsg_apply}, 1993 {"txmsg test cork", test_txmsg_cork}, 1994 {"txmsg test hanging corks", test_txmsg_cork_hangs}, 1995 {"txmsg test push_data", test_txmsg_push}, 1996 {"txmsg test pull-data", test_txmsg_pull}, 1997 {"txmsg test pop-data", test_txmsg_pop}, 1998 {"txmsg test push/pop data", test_txmsg_push_pop}, 1999 {"txmsg test ingress parser", test_txmsg_ingress_parser}, 2000 {"txmsg test ingress parser2", test_txmsg_ingress_parser2}, 2001 }; 2002 2003 static int check_whitelist(struct _test *t, struct sockmap_options *opt) 2004 { 2005 char *entry, *ptr; 2006 2007 if (!opt->whitelist) 2008 return 0; 2009 ptr = strdup(opt->whitelist); 2010 if (!ptr) 2011 return -ENOMEM; 2012 entry = strtok(ptr, ","); 2013 while (entry) { 2014 if ((opt->prepend && strstr(opt->prepend, entry) != 0) || 2015 strstr(opt->map, entry) != 0 || 2016 strstr(t->title, entry) != 0) { 2017 free(ptr); 2018 return 0; 2019 } 2020 entry = strtok(NULL, ","); 2021 } 2022 free(ptr); 2023 return -EINVAL; 2024 } 2025 2026 static int check_blacklist(struct _test *t, struct sockmap_options *opt) 2027 { 2028 char *entry, *ptr; 2029 2030 if (!opt->blacklist) 2031 return -EINVAL; 2032 ptr = strdup(opt->blacklist); 2033 if (!ptr) 2034 return -ENOMEM; 2035 entry = strtok(ptr, ","); 2036 while (entry) { 2037 if ((opt->prepend && strstr(opt->prepend, entry) != 0) || 2038 strstr(opt->map, entry) != 0 || 2039 strstr(t->title, entry) != 0) { 2040 free(ptr); 2041 return 0; 2042 } 2043 entry = strtok(NULL, ","); 2044 } 2045 free(ptr); 2046 return -EINVAL; 2047 } 2048 2049 static int __test_selftests(int cg_fd, struct sockmap_options *opt) 2050 { 2051 int i, err; 2052 2053 err = populate_progs(opt->map); 2054 if (err < 0) { 2055 fprintf(stderr, "ERROR: (%i) load bpf failed\n", err); 2056 return err; 2057 } 2058 2059 /* Tests basic commands and APIs */ 2060 for (i = 0; i < ARRAY_SIZE(test); i++) { 2061 struct _test t = test[i]; 2062 2063 if (check_whitelist(&t, opt) != 0) 2064 continue; 2065 if (check_blacklist(&t, opt) == 0) 2066 continue; 2067 2068 test_start_subtest(&t, opt); 2069 t.tester(cg_fd, opt); 2070 test_end_subtest(); 2071 } 2072 2073 return err; 2074 } 2075 2076 static void test_selftests_sockmap(int cg_fd, struct sockmap_options *opt) 2077 { 2078 opt->map = BPF_SOCKMAP_FILENAME; 2079 __test_selftests(cg_fd, opt); 2080 } 2081 2082 static void test_selftests_sockhash(int cg_fd, struct sockmap_options *opt) 2083 { 2084 opt->map = BPF_SOCKHASH_FILENAME; 2085 __test_selftests(cg_fd, opt); 2086 } 2087 2088 static void test_selftests_ktls(int cg_fd, struct sockmap_options *opt) 2089 { 2090 opt->map = BPF_SOCKHASH_FILENAME; 2091 opt->prepend = "ktls"; 2092 ktls = 1; 2093 __test_selftests(cg_fd, opt); 2094 ktls = 0; 2095 } 2096 2097 static int test_selftest(int cg_fd, struct sockmap_options *opt) 2098 { 2099 test_selftests_sockmap(cg_fd, opt); 2100 test_selftests_sockhash(cg_fd, opt); 2101 test_selftests_ktls(cg_fd, opt); 2102 test_print_results(); 2103 return 0; 2104 } 2105 2106 int main(int argc, char **argv) 2107 { 2108 int iov_count = 1, length = 1024, rate = 1; 2109 struct sockmap_options options = {0}; 2110 int opt, longindex, err, cg_fd = 0; 2111 char *bpf_file = BPF_SOCKMAP_FILENAME; 2112 int test = SELFTESTS; 2113 bool cg_created = 0; 2114 2115 while ((opt = getopt_long(argc, argv, ":dhv:c:r:i:l:t:p:q:n:b:", 2116 long_options, &longindex)) != -1) { 2117 switch (opt) { 2118 case 's': 2119 txmsg_start = atoi(optarg); 2120 break; 2121 case 'e': 2122 txmsg_end = atoi(optarg); 2123 break; 2124 case 'p': 2125 txmsg_start_push = atoi(optarg); 2126 break; 2127 case 'q': 2128 txmsg_end_push = atoi(optarg); 2129 break; 2130 case 'w': 2131 txmsg_start_pop = atoi(optarg); 2132 break; 2133 case 'x': 2134 txmsg_pop = atoi(optarg); 2135 break; 2136 case 'a': 2137 txmsg_apply = atoi(optarg); 2138 break; 2139 case 'k': 2140 txmsg_cork = atoi(optarg); 2141 break; 2142 case 'c': 2143 cg_fd = open(optarg, O_DIRECTORY, O_RDONLY); 2144 if (cg_fd < 0) { 2145 fprintf(stderr, 2146 "ERROR: (%i) open cg path failed: %s\n", 2147 cg_fd, optarg); 2148 return cg_fd; 2149 } 2150 break; 2151 case 'r': 2152 rate = atoi(optarg); 2153 break; 2154 case 'v': 2155 options.verbose = 1; 2156 if (optarg) 2157 options.verbose = atoi(optarg); 2158 break; 2159 case 'i': 2160 iov_count = atoi(optarg); 2161 break; 2162 case 'l': 2163 length = atoi(optarg); 2164 break; 2165 case 'd': 2166 options.data_test = true; 2167 break; 2168 case 't': 2169 if (strcmp(optarg, "ping") == 0) { 2170 test = PING_PONG; 2171 } else if (strcmp(optarg, "sendmsg") == 0) { 2172 test = SENDMSG; 2173 } else if (strcmp(optarg, "base") == 0) { 2174 test = BASE; 2175 } else if (strcmp(optarg, "base_sendpage") == 0) { 2176 test = BASE_SENDPAGE; 2177 } else if (strcmp(optarg, "sendpage") == 0) { 2178 test = SENDPAGE; 2179 } else { 2180 usage(argv); 2181 return -1; 2182 } 2183 break; 2184 case 'n': 2185 options.whitelist = strdup(optarg); 2186 if (!options.whitelist) 2187 return -ENOMEM; 2188 break; 2189 case 'b': 2190 options.blacklist = strdup(optarg); 2191 if (!options.blacklist) 2192 return -ENOMEM; 2193 case 0: 2194 break; 2195 case 'h': 2196 default: 2197 usage(argv); 2198 return -1; 2199 } 2200 } 2201 2202 if (!cg_fd) { 2203 cg_fd = cgroup_setup_and_join(CG_PATH); 2204 if (cg_fd < 0) 2205 return cg_fd; 2206 cg_created = 1; 2207 } 2208 2209 /* Use libbpf 1.0 API mode */ 2210 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 2211 2212 if (test == SELFTESTS) { 2213 err = test_selftest(cg_fd, &options); 2214 goto out; 2215 } 2216 2217 err = populate_progs(bpf_file); 2218 if (err) { 2219 fprintf(stderr, "populate program: (%s) %s\n", 2220 bpf_file, strerror(errno)); 2221 return 1; 2222 } 2223 running = 1; 2224 2225 /* catch SIGINT */ 2226 signal(SIGINT, running_handler); 2227 2228 options.iov_count = iov_count; 2229 options.iov_length = length; 2230 options.rate = rate; 2231 2232 err = run_options(&options, cg_fd, test); 2233 out: 2234 if (options.whitelist) 2235 free(options.whitelist); 2236 if (options.blacklist) 2237 free(options.blacklist); 2238 close(cg_fd); 2239 if (cg_created) 2240 cleanup_cgroup_environment(); 2241 return err; 2242 } 2243 2244 void running_handler(int a) 2245 { 2246 running = 0; 2247 } 2248