tools/testing/selftests/net/rxtimestamp.c

   1 #include <errno.h>
   2 #include <error.h>
   3 #include <getopt.h>
   4 #include <stdbool.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <unistd.h>
   9
  10 #include <sys/time.h>
  11 #include <sys/socket.h>
  12 #include <sys/select.h>
  13 #include <sys/ioctl.h>
  14 #include <arpa/inet.h>
  15 #include <net/if.h>
  16
  17 #include <asm/types.h>
  18 #include <linux/net_tstamp.h>
  19 #include <linux/errqueue.h>
  20
  21 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
  22
  23 struct options {
  24         int so_timestamp;
  25         int so_timestampns;
  26         int so_timestamping;
  27 };
  28
  29 struct tstamps {
  30         bool tstamp;
  31         bool tstampns;
  32         bool swtstamp;
  33         bool hwtstamp;
  34 };
  35
  36 struct socket_type {
  37         char *friendly_name;
  38         int type;
  39         int protocol;
  40         bool enabled;
  41 };
  42
  43 struct test_case {
  44         struct options sockopt;
  45         struct tstamps expected;
  46         bool enabled;
  47 };
  48
  49 struct sof_flag {
  50         int mask;
  51         char *name;
  52 };
  53
  54 static struct sof_flag sof_flags[] = {
  55 #define SOF_FLAG(f) { f, #f }
  56         SOF_FLAG(SOF_TIMESTAMPING_SOFTWARE),
  57         SOF_FLAG(SOF_TIMESTAMPING_RX_SOFTWARE),
  58         SOF_FLAG(SOF_TIMESTAMPING_RX_HARDWARE),
  59 };
  60
  61 static struct socket_type socket_types[] = {
  62         { "ip",         SOCK_RAW,       IPPROTO_EGP },
  63         { "udp",        SOCK_DGRAM,     IPPROTO_UDP },
  64         { "tcp",        SOCK_STREAM,    IPPROTO_TCP },
  65 };
  66
  67 static struct test_case test_cases[] = {
  68         { {}, {} },
  69         {
  70                 { so_timestamp: 1 },
  71                 { tstamp: true }
  72         },
  73         {
  74                 { so_timestampns: 1 },
  75                 { tstampns: true }
  76         },
  77         {
  78                 { so_timestamp: 1, so_timestampns: 1 },
  79                 { tstampns: true }
  80         },
  81         {
  82                 { so_timestamping: SOF_TIMESTAMPING_RX_SOFTWARE },
  83                 {}
  84         },
  85         {
  86                 /* Loopback device does not support hw timestamps. */
  87                 { so_timestamping: SOF_TIMESTAMPING_RX_HARDWARE },
  88                 {}
  89         },
  90         {
  91                 { so_timestamping: SOF_TIMESTAMPING_SOFTWARE },
  92                 {}
  93         },
  94         {
  95                 { so_timestamping: SOF_TIMESTAMPING_RX_SOFTWARE
  96                         | SOF_TIMESTAMPING_RX_HARDWARE },
  97                 {}
  98         },
  99         {
 100                 { so_timestamping: SOF_TIMESTAMPING_SOFTWARE
 101                         | SOF_TIMESTAMPING_RX_SOFTWARE },
 102                 { swtstamp: true }
 103         },
 104         {
 105                 { so_timestamp: 1, so_timestamping: SOF_TIMESTAMPING_SOFTWARE
 106                         | SOF_TIMESTAMPING_RX_SOFTWARE },
 107                 { tstamp: true, swtstamp: true }
 108         },
 109 };
 110
 111 static struct option long_options[] = {
 112         { "list_tests", no_argument, 0, 'l' },
 113         { "test_num", required_argument, 0, 'n' },
 114         { "op_size", required_argument, 0, 's' },
 115         { "tcp", no_argument, 0, 't' },
 116         { "udp", no_argument, 0, 'u' },
 117         { "ip", no_argument, 0, 'i' },
 118         { NULL, 0, NULL, 0 },
 119 };
 120
 121 static int next_port = 19999;
 122 static int op_size = 10 * 1024;
 123
 124 void print_test_case(struct test_case *t)
 125 {
 126         int f = 0;
 127
 128         printf("sockopts {");
 129         if (t->sockopt.so_timestamp)
 130                 printf(" SO_TIMESTAMP ");
 131         if (t->sockopt.so_timestampns)
 132                 printf(" SO_TIMESTAMPNS ");
 133         if (t->sockopt.so_timestamping) {
 134                 printf(" SO_TIMESTAMPING: {");
 135                 for (f = 0; f < ARRAY_SIZE(sof_flags); f++)
 136                         if (t->sockopt.so_timestamping & sof_flags[f].mask)
 137                                 printf(" %s |", sof_flags[f].name);
 138                 printf("}");
 139         }
 140         printf("} expected cmsgs: {");
 141         if (t->expected.tstamp)
 142                 printf(" SCM_TIMESTAMP ");
 143         if (t->expected.tstampns)
 144                 printf(" SCM_TIMESTAMPNS ");
 145         if (t->expected.swtstamp || t->expected.hwtstamp) {
 146                 printf(" SCM_TIMESTAMPING {");
 147                 if (t->expected.swtstamp)
 148                         printf("0");
 149                 if (t->expected.swtstamp && t->expected.hwtstamp)
 150                         printf(",");
 151                 if (t->expected.hwtstamp)
 152                         printf("2");
 153                 printf("}");
 154         }
 155         printf("}\n");
 156 }
 157
 158 void do_send(int src)
 159 {
 160         int r;
 161         char *buf = malloc(op_size);
 162
 163         memset(buf, 'z', op_size);
 164         r = write(src, buf, op_size);
 165         if (r < 0)
 166                 error(1, errno, "Failed to sendmsg");
 167
 168         free(buf);
 169 }
 170
 171 bool do_recv(int rcv, int read_size, struct tstamps expected)
 172 {
 173         const int CMSG_SIZE = 1024;
 174
 175         struct scm_timestamping *ts;
 176         struct tstamps actual = {};
 177         char cmsg_buf[CMSG_SIZE];
 178         struct iovec recv_iov;
 179         struct cmsghdr *cmsg;
 180         bool failed = false;
 181         struct msghdr hdr;
 182         int flags = 0;
 183         int r;
 184
 185         memset(&hdr, 0, sizeof(hdr));
 186         hdr.msg_iov = &recv_iov;
 187         hdr.msg_iovlen = 1;
 188         recv_iov.iov_base = malloc(read_size);
 189         recv_iov.iov_len = read_size;
 190
 191         hdr.msg_control = cmsg_buf;
 192         hdr.msg_controllen = sizeof(cmsg_buf);
 193
 194         r = recvmsg(rcv, &hdr, flags);
 195         if (r < 0)
 196                 error(1, errno, "Failed to recvmsg");
 197         if (r != read_size)
 198                 error(1, 0, "Only received %d bytes of payload.", r);
 199
 200         if (hdr.msg_flags & (MSG_TRUNC | MSG_CTRUNC))
 201                 error(1, 0, "Message was truncated.");
 202
 203         for (cmsg = CMSG_FIRSTHDR(&hdr); cmsg != NULL;
 204              cmsg = CMSG_NXTHDR(&hdr, cmsg)) {
 205                 if (cmsg->cmsg_level != SOL_SOCKET)
 206                         error(1, 0, "Unexpected cmsg_level %d",
 207                               cmsg->cmsg_level);
 208                 switch (cmsg->cmsg_type) {
 209                 case SCM_TIMESTAMP:
 210                         actual.tstamp = true;
 211                         break;
 212                 case SCM_TIMESTAMPNS:
 213                         actual.tstampns = true;
 214                         break;
 215                 case SCM_TIMESTAMPING:
 216                         ts = (struct scm_timestamping *)CMSG_DATA(cmsg);
 217                         actual.swtstamp = !!ts->ts[0].tv_sec;
 218                         if (ts->ts[1].tv_sec != 0)
 219                                 error(0, 0, "ts[1] should not be set.");
 220                         actual.hwtstamp = !!ts->ts[2].tv_sec;
 221                         break;
 222                 default:
 223                         error(1, 0, "Unexpected cmsg_type %d", cmsg->cmsg_type);
 224                 }
 225         }
 226
 227 #define VALIDATE(field) \
 228         do { \
 229                 if (expected.field != actual.field) { \
 230                         if (expected.field) \
 231                                 error(0, 0, "Expected " #field " to be set."); \
 232                         else \
 233                                 error(0, 0, \
 234                                       "Expected " #field " to not be set."); \
 235                         failed = true; \
 236                 } \
 237         } while (0)
 238
 239         VALIDATE(tstamp);
 240         VALIDATE(tstampns);
 241         VALIDATE(swtstamp);
 242         VALIDATE(hwtstamp);
 243 #undef VALIDATE
 244
 245         free(recv_iov.iov_base);
 246
 247         return failed;
 248 }
 249
 250 void config_so_flags(int rcv, struct options o)
 251 {
 252         int on = 1;
 253
 254         if (setsockopt(rcv, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
 255                 error(1, errno, "Failed to enable SO_REUSEADDR");
 256
 257         if (o.so_timestamp &&
 258             setsockopt(rcv, SOL_SOCKET, SO_TIMESTAMP,
 259                        &o.so_timestamp, sizeof(o.so_timestamp)) < 0)
 260                 error(1, errno, "Failed to enable SO_TIMESTAMP");
 261
 262         if (o.so_timestampns &&
 263             setsockopt(rcv, SOL_SOCKET, SO_TIMESTAMPNS,
 264                        &o.so_timestampns, sizeof(o.so_timestampns)) < 0)
 265                 error(1, errno, "Failed to enable SO_TIMESTAMPNS");
 266
 267         if (o.so_timestamping &&
 268             setsockopt(rcv, SOL_SOCKET, SO_TIMESTAMPING,
 269                        &o.so_timestamping, sizeof(o.so_timestamping)) < 0)
 270                 error(1, errno, "Failed to set SO_TIMESTAMPING");
 271 }
 272
 273 bool run_test_case(struct socket_type s, struct test_case t)
 274 {
 275         int port = (s.type == SOCK_RAW) ? 0 : next_port++;
 276         int read_size = op_size;
 277         struct sockaddr_in addr;
 278         bool failed = false;
 279         int src, dst, rcv;
 280
 281         src = socket(AF_INET, s.type, s.protocol);
 282         if (src < 0)
 283                 error(1, errno, "Failed to open src socket");
 284
 285         dst = socket(AF_INET, s.type, s.protocol);
 286         if (dst < 0)
 287                 error(1, errno, "Failed to open dst socket");
 288
 289         memset(&addr, 0, sizeof(addr));
 290         addr.sin_family = AF_INET;
 291         addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 292         addr.sin_port = htons(port);
 293
 294         if (bind(dst, (struct sockaddr *)&addr, sizeof(addr)) < 0)
 295                 error(1, errno, "Failed to bind to port %d", port);
 296
 297         if (s.type == SOCK_STREAM && (listen(dst, 1) < 0))
 298                 error(1, errno, "Failed to listen");
 299
 300         if (connect(src, (struct sockaddr *)&addr, sizeof(addr)) < 0)
 301                 error(1, errno, "Failed to connect");
 302
 303         if (s.type == SOCK_STREAM) {
 304                 rcv = accept(dst, NULL, NULL);
 305                 if (rcv < 0)
 306                         error(1, errno, "Failed to accept");
 307                 close(dst);
 308         } else {
 309                 rcv = dst;
 310         }
 311
 312         config_so_flags(rcv, t.sockopt);
 313         usleep(20000); /* setsockopt for SO_TIMESTAMPING is asynchronous */
 314         do_send(src);
 315
 316         if (s.type == SOCK_RAW)
 317                 read_size += 20;  /* for IP header */
 318         failed = do_recv(rcv, read_size, t.expected);
 319
 320         close(rcv);
 321         close(src);
 322
 323         return failed;
 324 }
 325
 326 int main(int argc, char **argv)
 327 {
 328         bool all_protocols = true;
 329         bool all_tests = true;
 330         int arg_index = 0;
 331         int failures = 0;
 332         int s, t;
 333         char opt;
 334
 335         while ((opt = getopt_long(argc, argv, "", long_options,
 336                                   &arg_index)) != -1) {
 337                 switch (opt) {
 338                 case 'l':
 339                         for (t = 0; t < ARRAY_SIZE(test_cases); t++) {
 340                                 printf("%d\t", t);
 341                                 print_test_case(&test_cases[t]);
 342                         }
 343                         return 0;
 344                 case 'n':
 345                         t = atoi(optarg);
 346                         if (t >= ARRAY_SIZE(test_cases))
 347                                 error(1, 0, "Invalid test case: %d", t);
 348                         all_tests = false;
 349                         test_cases[t].enabled = true;
 350                         break;
 351                 case 's':
 352                         op_size = atoi(optarg);
 353                         break;
 354                 case 't':
 355                         all_protocols = false;
 356                         socket_types[2].enabled = true;
 357                         break;
 358                 case 'u':
 359                         all_protocols = false;
 360                         socket_types[1].enabled = true;
 361                         break;
 362                 case 'i':
 363                         all_protocols = false;
 364                         socket_types[0].enabled = true;
 365                         break;
 366                 default:
 367                         error(1, 0, "Failed to parse parameters.");
 368                 }
 369         }
 370
 371         for (s = 0; s < ARRAY_SIZE(socket_types); s++) {
 372                 if (!all_protocols && !socket_types[s].enabled)
 373                         continue;
 374
 375                 printf("Testing %s...\n", socket_types[s].friendly_name);
 376                 for (t = 0; t < ARRAY_SIZE(test_cases); t++) {
 377                         if (!all_tests && !test_cases[t].enabled)
 378                                 continue;
 379
 380                         printf("Starting testcase %d...\n", t);
 381                         if (run_test_case(socket_types[s], test_cases[t])) {
 382                                 failures++;
 383                                 printf("FAILURE in test case ");
 384                                 print_test_case(&test_cases[t]);
 385                         }
 386                 }
 387         }
 388         if (!failures)
 389                 printf("PASSED.\n");
 390         return failures;
 391 }