tools/testing/selftests/bpf/test_sockmap.c

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