tools/testing/selftests/net/so_incoming_cpu.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright Amazon.com Inc. or its affiliates. */
   3 #define _GNU_SOURCE
   4 #include <sched.h>
   5
   6 #include <fcntl.h>
   7
   8 #include <netinet/in.h>
   9 #include <sys/socket.h>
  10 #include <sys/sysinfo.h>
  11
  12 #include "../kselftest_harness.h"
  13
  14 FIXTURE(so_incoming_cpu)
  15 {
  16         int *servers;
  17         union {
  18                 struct sockaddr addr;
  19                 struct sockaddr_in in_addr;
  20         };
  21         socklen_t addrlen;
  22 };
  23
  24 enum when_to_set {
  25         BEFORE_REUSEPORT,
  26         BEFORE_LISTEN,
  27         AFTER_LISTEN,
  28         AFTER_ALL_LISTEN,
  29 };
  30
  31 FIXTURE_VARIANT(so_incoming_cpu)
  32 {
  33         int when_to_set;
  34 };
  35
  36 FIXTURE_VARIANT_ADD(so_incoming_cpu, before_reuseport)
  37 {
  38         .when_to_set = BEFORE_REUSEPORT,
  39 };
  40
  41 FIXTURE_VARIANT_ADD(so_incoming_cpu, before_listen)
  42 {
  43         .when_to_set = BEFORE_LISTEN,
  44 };
  45
  46 FIXTURE_VARIANT_ADD(so_incoming_cpu, after_listen)
  47 {
  48         .when_to_set = AFTER_LISTEN,
  49 };
  50
  51 FIXTURE_VARIANT_ADD(so_incoming_cpu, after_all_listen)
  52 {
  53         .when_to_set = AFTER_ALL_LISTEN,
  54 };
  55
  56 static void write_sysctl(struct __test_metadata *_metadata,
  57                          char *filename, char *string)
  58 {
  59         int fd, len, ret;
  60
  61         fd = open(filename, O_WRONLY);
  62         ASSERT_NE(fd, -1);
  63
  64         len = strlen(string);
  65         ret = write(fd, string, len);
  66         ASSERT_EQ(ret, len);
  67 }
  68
  69 static void setup_netns(struct __test_metadata *_metadata)
  70 {
  71         ASSERT_EQ(unshare(CLONE_NEWNET), 0);
  72         ASSERT_EQ(system("ip link set lo up"), 0);
  73
  74         write_sysctl(_metadata, "/proc/sys/net/ipv4/ip_local_port_range", "10000 60001");
  75         write_sysctl(_metadata, "/proc/sys/net/ipv4/tcp_tw_reuse", "0");
  76 }
  77
  78 #define NR_PORT                         (60001 - 10000 - 1)
  79 #define NR_CLIENT_PER_SERVER_DEFAULT    32
  80 static int nr_client_per_server, nr_server, nr_client;
  81
  82 FIXTURE_SETUP(so_incoming_cpu)
  83 {
  84         setup_netns(_metadata);
  85
  86         nr_server = get_nprocs();
  87         ASSERT_LE(2, nr_server);
  88
  89         if (NR_CLIENT_PER_SERVER_DEFAULT * nr_server < NR_PORT)
  90                 nr_client_per_server = NR_CLIENT_PER_SERVER_DEFAULT;
  91         else
  92                 nr_client_per_server = NR_PORT / nr_server;
  93
  94         nr_client = nr_client_per_server * nr_server;
  95
  96         self->servers = malloc(sizeof(int) * nr_server);
  97         ASSERT_NE(self->servers, NULL);
  98
  99         self->in_addr.sin_family = AF_INET;
 100         self->in_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 101         self->in_addr.sin_port = htons(0);
 102         self->addrlen = sizeof(struct sockaddr_in);
 103 }
 104
 105 FIXTURE_TEARDOWN(so_incoming_cpu)
 106 {
 107         int i;
 108
 109         for (i = 0; i < nr_server; i++)
 110                 close(self->servers[i]);
 111
 112         free(self->servers);
 113 }
 114
 115 void set_so_incoming_cpu(struct __test_metadata *_metadata, int fd, int cpu)
 116 {
 117         int ret;
 118
 119         ret = setsockopt(fd, SOL_SOCKET, SO_INCOMING_CPU, &cpu, sizeof(int));
 120         ASSERT_EQ(ret, 0);
 121 }
 122
 123 int create_server(struct __test_metadata *_metadata,
 124                   FIXTURE_DATA(so_incoming_cpu) *self,
 125                   const FIXTURE_VARIANT(so_incoming_cpu) *variant,
 126                   int cpu)
 127 {
 128         int fd, ret;
 129
 130         fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
 131         ASSERT_NE(fd, -1);
 132
 133         if (variant->when_to_set == BEFORE_REUSEPORT)
 134                 set_so_incoming_cpu(_metadata, fd, cpu);
 135
 136         ret = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &(int){1}, sizeof(int));
 137         ASSERT_EQ(ret, 0);
 138
 139         ret = bind(fd, &self->addr, self->addrlen);
 140         ASSERT_EQ(ret, 0);
 141
 142         if (variant->when_to_set == BEFORE_LISTEN)
 143                 set_so_incoming_cpu(_metadata, fd, cpu);
 144
 145         /* We don't use nr_client_per_server here not to block
 146          * this test at connect() if SO_INCOMING_CPU is broken.
 147          */
 148         ret = listen(fd, nr_client);
 149         ASSERT_EQ(ret, 0);
 150
 151         if (variant->when_to_set == AFTER_LISTEN)
 152                 set_so_incoming_cpu(_metadata, fd, cpu);
 153
 154         return fd;
 155 }
 156
 157 void create_servers(struct __test_metadata *_metadata,
 158                     FIXTURE_DATA(so_incoming_cpu) *self,
 159                     const FIXTURE_VARIANT(so_incoming_cpu) *variant)
 160 {
 161         int i, ret;
 162
 163         for (i = 0; i < nr_server; i++) {
 164                 self->servers[i] = create_server(_metadata, self, variant, i);
 165
 166                 if (i == 0) {
 167                         ret = getsockname(self->servers[i], &self->addr, &self->addrlen);
 168                         ASSERT_EQ(ret, 0);
 169                 }
 170         }
 171
 172         if (variant->when_to_set == AFTER_ALL_LISTEN) {
 173                 for (i = 0; i < nr_server; i++)
 174                         set_so_incoming_cpu(_metadata, self->servers[i], i);
 175         }
 176 }
 177
 178 void create_clients(struct __test_metadata *_metadata,
 179                     FIXTURE_DATA(so_incoming_cpu) *self)
 180 {
 181         cpu_set_t cpu_set;
 182         int i, j, fd, ret;
 183
 184         for (i = 0; i < nr_server; i++) {
 185                 CPU_ZERO(&cpu_set);
 186
 187                 CPU_SET(i, &cpu_set);
 188                 ASSERT_EQ(CPU_COUNT(&cpu_set), 1);
 189                 ASSERT_NE(CPU_ISSET(i, &cpu_set), 0);
 190
 191                 /* Make sure SYN will be processed on the i-th CPU
 192                  * and finally distributed to the i-th listener.
 193                  */
 194                 ret = sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
 195                 ASSERT_EQ(ret, 0);
 196
 197                 for (j = 0; j < nr_client_per_server; j++) {
 198                         fd  = socket(AF_INET, SOCK_STREAM, 0);
 199                         ASSERT_NE(fd, -1);
 200
 201                         ret = connect(fd, &self->addr, self->addrlen);
 202                         ASSERT_EQ(ret, 0);
 203
 204                         close(fd);
 205                 }
 206         }
 207 }
 208
 209 void verify_incoming_cpu(struct __test_metadata *_metadata,
 210                          FIXTURE_DATA(so_incoming_cpu) *self)
 211 {
 212         int i, j, fd, cpu, ret, total = 0;
 213         socklen_t len = sizeof(int);
 214
 215         for (i = 0; i < nr_server; i++) {
 216                 for (j = 0; j < nr_client_per_server; j++) {
 217                         /* If we see -EAGAIN here, SO_INCOMING_CPU is broken */
 218                         fd = accept(self->servers[i], &self->addr, &self->addrlen);
 219                         ASSERT_NE(fd, -1);
 220
 221                         ret = getsockopt(fd, SOL_SOCKET, SO_INCOMING_CPU, &cpu, &len);
 222                         ASSERT_EQ(ret, 0);
 223                         ASSERT_EQ(cpu, i);
 224
 225                         close(fd);
 226                         total++;
 227                 }
 228         }
 229
 230         ASSERT_EQ(total, nr_client);
 231         TH_LOG("SO_INCOMING_CPU is very likely to be "
 232                "working correctly with %d sockets.", total);
 233 }
 234
 235 TEST_F(so_incoming_cpu, test1)
 236 {
 237         create_servers(_metadata, self, variant);
 238         create_clients(_metadata, self);
 239         verify_incoming_cpu(_metadata, self);
 240 }
 241
 242 TEST_F(so_incoming_cpu, test2)
 243 {
 244         int server;
 245
 246         create_servers(_metadata, self, variant);
 247
 248         /* No CPU specified */
 249         server = create_server(_metadata, self, variant, -1);
 250         close(server);
 251
 252         create_clients(_metadata, self);
 253         verify_incoming_cpu(_metadata, self);
 254 }
 255
 256 TEST_F(so_incoming_cpu, test3)
 257 {
 258         int server, client;
 259
 260         create_servers(_metadata, self, variant);
 261
 262         /* No CPU specified */
 263         server = create_server(_metadata, self, variant, -1);
 264
 265         create_clients(_metadata, self);
 266
 267         /* Never receive any requests */
 268         client = accept(server, &self->addr, &self->addrlen);
 269         ASSERT_EQ(client, -1);
 270
 271         verify_incoming_cpu(_metadata, self);
 272 }
 273
 274 TEST_HARNESS_MAIN