tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2019 Facebook */
   3
   4 #include <linux/err.h>
   5 #include <netinet/tcp.h>
   6 #include <test_progs.h>
   7 #include "bpf_dctcp.skel.h"
   8 #include "bpf_cubic.skel.h"
   9 #include "bpf_tcp_nogpl.skel.h"
  10
  11 #define min(a, b) ((a) < (b) ? (a) : (b))
  12
  13 static const unsigned int total_bytes = 10 * 1024 * 1024;
  14 static const struct timeval timeo_sec = { .tv_sec = 10 };
  15 static const size_t timeo_optlen = sizeof(timeo_sec);
  16 static int expected_stg = 0xeB9F;
  17 static int stop, duration;
  18
  19 static int settimeo(int fd)
  20 {
  21         int err;
  22
  23         err = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo_sec,
  24                          timeo_optlen);
  25         if (CHECK(err == -1, "setsockopt(fd, SO_RCVTIMEO)", "errno:%d\n",
  26                   errno))
  27                 return -1;
  28
  29         err = setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo_sec,
  30                          timeo_optlen);
  31         if (CHECK(err == -1, "setsockopt(fd, SO_SNDTIMEO)", "errno:%d\n",
  32                   errno))
  33                 return -1;
  34
  35         return 0;
  36 }
  37
  38 static int settcpca(int fd, const char *tcp_ca)
  39 {
  40         int err;
  41
  42         err = setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, tcp_ca, strlen(tcp_ca));
  43         if (CHECK(err == -1, "setsockopt(fd, TCP_CONGESTION)", "errno:%d\n",
  44                   errno))
  45                 return -1;
  46
  47         return 0;
  48 }
  49
  50 static void *server(void *arg)
  51 {
  52         int lfd = (int)(long)arg, err = 0, fd;
  53         ssize_t nr_sent = 0, bytes = 0;
  54         char batch[1500];
  55
  56         fd = accept(lfd, NULL, NULL);
  57         while (fd == -1) {
  58                 if (errno == EINTR)
  59                         continue;
  60                 err = -errno;
  61                 goto done;
  62         }
  63
  64         if (settimeo(fd)) {
  65                 err = -errno;
  66                 goto done;
  67         }
  68
  69         while (bytes < total_bytes && !READ_ONCE(stop)) {
  70                 nr_sent = send(fd, &batch,
  71                                min(total_bytes - bytes, sizeof(batch)), 0);
  72                 if (nr_sent == -1 && errno == EINTR)
  73                         continue;
  74                 if (nr_sent == -1) {
  75                         err = -errno;
  76                         break;
  77                 }
  78                 bytes += nr_sent;
  79         }
  80
  81         CHECK(bytes != total_bytes, "send", "%zd != %u nr_sent:%zd errno:%d\n",
  82               bytes, total_bytes, nr_sent, errno);
  83
  84 done:
  85         if (fd >= 0)
  86                 close(fd);
  87         if (err) {
  88                 WRITE_ONCE(stop, 1);
  89                 return ERR_PTR(err);
  90         }
  91         return NULL;
  92 }
  93
  94 static void do_test(const char *tcp_ca, const struct bpf_map *sk_stg_map)
  95 {
  96         struct sockaddr_in6 sa6 = {};
  97         ssize_t nr_recv = 0, bytes = 0;
  98         int lfd = -1, fd = -1;
  99         pthread_t srv_thread;
 100         socklen_t addrlen = sizeof(sa6);
 101         void *thread_ret;
 102         char batch[1500];
 103         int err;
 104
 105         WRITE_ONCE(stop, 0);
 106
 107         lfd = socket(AF_INET6, SOCK_STREAM, 0);
 108         if (CHECK(lfd == -1, "socket", "errno:%d\n", errno))
 109                 return;
 110         fd = socket(AF_INET6, SOCK_STREAM, 0);
 111         if (CHECK(fd == -1, "socket", "errno:%d\n", errno)) {
 112                 close(lfd);
 113                 return;
 114         }
 115
 116         if (settcpca(lfd, tcp_ca) || settcpca(fd, tcp_ca) ||
 117             settimeo(lfd) || settimeo(fd))
 118                 goto done;
 119
 120         /* bind, listen and start server thread to accept */
 121         sa6.sin6_family = AF_INET6;
 122         sa6.sin6_addr = in6addr_loopback;
 123         err = bind(lfd, (struct sockaddr *)&sa6, addrlen);
 124         if (CHECK(err == -1, "bind", "errno:%d\n", errno))
 125                 goto done;
 126         err = getsockname(lfd, (struct sockaddr *)&sa6, &addrlen);
 127         if (CHECK(err == -1, "getsockname", "errno:%d\n", errno))
 128                 goto done;
 129         err = listen(lfd, 1);
 130         if (CHECK(err == -1, "listen", "errno:%d\n", errno))
 131                 goto done;
 132
 133         if (sk_stg_map) {
 134                 err = bpf_map_update_elem(bpf_map__fd(sk_stg_map), &fd,
 135                                           &expected_stg, BPF_NOEXIST);
 136                 if (CHECK(err, "bpf_map_update_elem(sk_stg_map)",
 137                           "err:%d errno:%d\n", err, errno))
 138                         goto done;
 139         }
 140
 141         /* connect to server */
 142         err = connect(fd, (struct sockaddr *)&sa6, addrlen);
 143         if (CHECK(err == -1, "connect", "errno:%d\n", errno))
 144                 goto done;
 145
 146         if (sk_stg_map) {
 147                 int tmp_stg;
 148
 149                 err = bpf_map_lookup_elem(bpf_map__fd(sk_stg_map), &fd,
 150                                           &tmp_stg);
 151                 if (CHECK(!err || errno != ENOENT,
 152                           "bpf_map_lookup_elem(sk_stg_map)",
 153                           "err:%d errno:%d\n", err, errno))
 154                         goto done;
 155         }
 156
 157         err = pthread_create(&srv_thread, NULL, server, (void *)(long)lfd);
 158         if (CHECK(err != 0, "pthread_create", "err:%d errno:%d\n", err, errno))
 159                 goto done;
 160
 161         /* recv total_bytes */
 162         while (bytes < total_bytes && !READ_ONCE(stop)) {
 163                 nr_recv = recv(fd, &batch,
 164                                min(total_bytes - bytes, sizeof(batch)), 0);
 165                 if (nr_recv == -1 && errno == EINTR)
 166                         continue;
 167                 if (nr_recv == -1)
 168                         break;
 169                 bytes += nr_recv;
 170         }
 171
 172         CHECK(bytes != total_bytes, "recv", "%zd != %u nr_recv:%zd errno:%d\n",
 173               bytes, total_bytes, nr_recv, errno);
 174
 175         WRITE_ONCE(stop, 1);
 176         pthread_join(srv_thread, &thread_ret);
 177         CHECK(IS_ERR(thread_ret), "pthread_join", "thread_ret:%ld",
 178               PTR_ERR(thread_ret));
 179 done:
 180         close(lfd);
 181         close(fd);
 182 }
 183
 184 static void test_cubic(void)
 185 {
 186         struct bpf_cubic *cubic_skel;
 187         struct bpf_link *link;
 188
 189         cubic_skel = bpf_cubic__open_and_load();
 190         if (CHECK(!cubic_skel, "bpf_cubic__open_and_load", "failed\n"))
 191                 return;
 192
 193         link = bpf_map__attach_struct_ops(cubic_skel->maps.cubic);
 194         if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) {
 195                 bpf_cubic__destroy(cubic_skel);
 196                 return;
 197         }
 198
 199         do_test("bpf_cubic", NULL);
 200
 201         bpf_link__destroy(link);
 202         bpf_cubic__destroy(cubic_skel);
 203 }
 204
 205 static void test_dctcp(void)
 206 {
 207         struct bpf_dctcp *dctcp_skel;
 208         struct bpf_link *link;
 209
 210         dctcp_skel = bpf_dctcp__open_and_load();
 211         if (CHECK(!dctcp_skel, "bpf_dctcp__open_and_load", "failed\n"))
 212                 return;
 213
 214         link = bpf_map__attach_struct_ops(dctcp_skel->maps.dctcp);
 215         if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) {
 216                 bpf_dctcp__destroy(dctcp_skel);
 217                 return;
 218         }
 219
 220         do_test("bpf_dctcp", dctcp_skel->maps.sk_stg_map);
 221         CHECK(dctcp_skel->bss->stg_result != expected_stg,
 222               "Unexpected stg_result", "stg_result (%x) != expected_stg (%x)\n",
 223               dctcp_skel->bss->stg_result, expected_stg);
 224
 225         bpf_link__destroy(link);
 226         bpf_dctcp__destroy(dctcp_skel);
 227 }
 228
 229 static char *err_str;
 230 static bool found;
 231
 232 static int libbpf_debug_print(enum libbpf_print_level level,
 233                               const char *format, va_list args)
 234 {
 235         char *log_buf;
 236
 237         if (level != LIBBPF_WARN ||
 238             strcmp(format, "libbpf: \n%s\n")) {
 239                 vprintf(format, args);
 240                 return 0;
 241         }
 242
 243         log_buf = va_arg(args, char *);
 244         if (!log_buf)
 245                 goto out;
 246         if (err_str && strstr(log_buf, err_str) != NULL)
 247                 found = true;
 248 out:
 249         printf(format, log_buf);
 250         return 0;
 251 }
 252
 253 static void test_invalid_license(void)
 254 {
 255         libbpf_print_fn_t old_print_fn;
 256         struct bpf_tcp_nogpl *skel;
 257
 258         err_str = "struct ops programs must have a GPL compatible license";
 259         found = false;
 260         old_print_fn = libbpf_set_print(libbpf_debug_print);
 261
 262         skel = bpf_tcp_nogpl__open_and_load();
 263         ASSERT_NULL(skel, "bpf_tcp_nogpl");
 264         ASSERT_EQ(found, true, "expected_err_msg");
 265
 266         bpf_tcp_nogpl__destroy(skel);
 267         libbpf_set_print(old_print_fn);
 268 }
 269
 270 void test_bpf_tcp_ca(void)
 271 {
 272         if (test__start_subtest("dctcp"))
 273                 test_dctcp();
 274         if (test__start_subtest("cubic"))
 275                 test_cubic();
 276         if (test__start_subtest("invalid_license"))
 277                 test_invalid_license();
 278 }