tools/testing/vsock/vsock_test.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vsock_test - vsock.ko test suite
   4  *
   5  * Copyright (C) 2017 Red Hat, Inc.
   6  *
   7  * Author: Stefan Hajnoczi <[email protected]>
   8  */
   9
  10 #include <getopt.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <errno.h>
  15 #include <unistd.h>
  16 #include <linux/kernel.h>
  17 #include <sys/types.h>
  18 #include <sys/socket.h>
  19 #include <time.h>
  20 #include <sys/mman.h>
  21 #include <poll.h>
  22
  23 #include "timeout.h"
  24 #include "control.h"
  25 #include "util.h"
  26
  27 static void test_stream_connection_reset(const struct test_opts *opts)
  28 {
  29         union {
  30                 struct sockaddr sa;
  31                 struct sockaddr_vm svm;
  32         } addr = {
  33                 .svm = {
  34                         .svm_family = AF_VSOCK,
  35                         .svm_port = 1234,
  36                         .svm_cid = opts->peer_cid,
  37                 },
  38         };
  39         int ret;
  40         int fd;
  41
  42         fd = socket(AF_VSOCK, SOCK_STREAM, 0);
  43
  44         timeout_begin(TIMEOUT);
  45         do {
  46                 ret = connect(fd, &addr.sa, sizeof(addr.svm));
  47                 timeout_check("connect");
  48         } while (ret < 0 && errno == EINTR);
  49         timeout_end();
  50
  51         if (ret != -1) {
  52                 fprintf(stderr, "expected connect(2) failure, got %d\n", ret);
  53                 exit(EXIT_FAILURE);
  54         }
  55         if (errno != ECONNRESET) {
  56                 fprintf(stderr, "unexpected connect(2) errno %d\n", errno);
  57                 exit(EXIT_FAILURE);
  58         }
  59
  60         close(fd);
  61 }
  62
  63 static void test_stream_bind_only_client(const struct test_opts *opts)
  64 {
  65         union {
  66                 struct sockaddr sa;
  67                 struct sockaddr_vm svm;
  68         } addr = {
  69                 .svm = {
  70                         .svm_family = AF_VSOCK,
  71                         .svm_port = 1234,
  72                         .svm_cid = opts->peer_cid,
  73                 },
  74         };
  75         int ret;
  76         int fd;
  77
  78         /* Wait for the server to be ready */
  79         control_expectln("BIND");
  80
  81         fd = socket(AF_VSOCK, SOCK_STREAM, 0);
  82
  83         timeout_begin(TIMEOUT);
  84         do {
  85                 ret = connect(fd, &addr.sa, sizeof(addr.svm));
  86                 timeout_check("connect");
  87         } while (ret < 0 && errno == EINTR);
  88         timeout_end();
  89
  90         if (ret != -1) {
  91                 fprintf(stderr, "expected connect(2) failure, got %d\n", ret);
  92                 exit(EXIT_FAILURE);
  93         }
  94         if (errno != ECONNRESET) {
  95                 fprintf(stderr, "unexpected connect(2) errno %d\n", errno);
  96                 exit(EXIT_FAILURE);
  97         }
  98
  99         /* Notify the server that the client has finished */
 100         control_writeln("DONE");
 101
 102         close(fd);
 103 }
 104
 105 static void test_stream_bind_only_server(const struct test_opts *opts)
 106 {
 107         union {
 108                 struct sockaddr sa;
 109                 struct sockaddr_vm svm;
 110         } addr = {
 111                 .svm = {
 112                         .svm_family = AF_VSOCK,
 113                         .svm_port = 1234,
 114                         .svm_cid = VMADDR_CID_ANY,
 115                 },
 116         };
 117         int fd;
 118
 119         fd = socket(AF_VSOCK, SOCK_STREAM, 0);
 120
 121         if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) {
 122                 perror("bind");
 123                 exit(EXIT_FAILURE);
 124         }
 125
 126         /* Notify the client that the server is ready */
 127         control_writeln("BIND");
 128
 129         /* Wait for the client to finish */
 130         control_expectln("DONE");
 131
 132         close(fd);
 133 }
 134
 135 static void test_stream_client_close_client(const struct test_opts *opts)
 136 {
 137         int fd;
 138
 139         fd = vsock_stream_connect(opts->peer_cid, 1234);
 140         if (fd < 0) {
 141                 perror("connect");
 142                 exit(EXIT_FAILURE);
 143         }
 144
 145         send_byte(fd, 1, 0);
 146         close(fd);
 147 }
 148
 149 static void test_stream_client_close_server(const struct test_opts *opts)
 150 {
 151         int fd;
 152
 153         fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
 154         if (fd < 0) {
 155                 perror("accept");
 156                 exit(EXIT_FAILURE);
 157         }
 158
 159         /* Wait for the remote to close the connection, before check
 160          * -EPIPE error on send.
 161          */
 162         vsock_wait_remote_close(fd);
 163
 164         send_byte(fd, -EPIPE, 0);
 165         recv_byte(fd, 1, 0);
 166         recv_byte(fd, 0, 0);
 167         close(fd);
 168 }
 169
 170 static void test_stream_server_close_client(const struct test_opts *opts)
 171 {
 172         int fd;
 173
 174         fd = vsock_stream_connect(opts->peer_cid, 1234);
 175         if (fd < 0) {
 176                 perror("connect");
 177                 exit(EXIT_FAILURE);
 178         }
 179
 180         /* Wait for the remote to close the connection, before check
 181          * -EPIPE error on send.
 182          */
 183         vsock_wait_remote_close(fd);
 184
 185         send_byte(fd, -EPIPE, 0);
 186         recv_byte(fd, 1, 0);
 187         recv_byte(fd, 0, 0);
 188         close(fd);
 189 }
 190
 191 static void test_stream_server_close_server(const struct test_opts *opts)
 192 {
 193         int fd;
 194
 195         fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
 196         if (fd < 0) {
 197                 perror("accept");
 198                 exit(EXIT_FAILURE);
 199         }
 200
 201         send_byte(fd, 1, 0);
 202         close(fd);
 203 }
 204
 205 /* With the standard socket sizes, VMCI is able to support about 100
 206  * concurrent stream connections.
 207  */
 208 #define MULTICONN_NFDS 100
 209
 210 static void test_stream_multiconn_client(const struct test_opts *opts)
 211 {
 212         int fds[MULTICONN_NFDS];
 213         int i;
 214
 215         for (i = 0; i < MULTICONN_NFDS; i++) {
 216                 fds[i] = vsock_stream_connect(opts->peer_cid, 1234);
 217                 if (fds[i] < 0) {
 218                         perror("connect");
 219                         exit(EXIT_FAILURE);
 220                 }
 221         }
 222
 223         for (i = 0; i < MULTICONN_NFDS; i++) {
 224                 if (i % 2)
 225                         recv_byte(fds[i], 1, 0);
 226                 else
 227                         send_byte(fds[i], 1, 0);
 228         }
 229
 230         for (i = 0; i < MULTICONN_NFDS; i++)
 231                 close(fds[i]);
 232 }
 233
 234 static void test_stream_multiconn_server(const struct test_opts *opts)
 235 {
 236         int fds[MULTICONN_NFDS];
 237         int i;
 238
 239         for (i = 0; i < MULTICONN_NFDS; i++) {
 240                 fds[i] = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
 241                 if (fds[i] < 0) {
 242                         perror("accept");
 243                         exit(EXIT_FAILURE);
 244                 }
 245         }
 246
 247         for (i = 0; i < MULTICONN_NFDS; i++) {
 248                 if (i % 2)
 249                         send_byte(fds[i], 1, 0);
 250                 else
 251                         recv_byte(fds[i], 1, 0);
 252         }
 253
 254         for (i = 0; i < MULTICONN_NFDS; i++)
 255                 close(fds[i]);
 256 }
 257
 258 static void test_stream_msg_peek_client(const struct test_opts *opts)
 259 {
 260         int fd;
 261
 262         fd = vsock_stream_connect(opts->peer_cid, 1234);
 263         if (fd < 0) {
 264                 perror("connect");
 265                 exit(EXIT_FAILURE);
 266         }
 267
 268         send_byte(fd, 1, 0);
 269         close(fd);
 270 }
 271
 272 static void test_stream_msg_peek_server(const struct test_opts *opts)
 273 {
 274         int fd;
 275
 276         fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
 277         if (fd < 0) {
 278                 perror("accept");
 279                 exit(EXIT_FAILURE);
 280         }
 281
 282         recv_byte(fd, 1, MSG_PEEK);
 283         recv_byte(fd, 1, 0);
 284         close(fd);
 285 }
 286
 287 #define SOCK_BUF_SIZE (2 * 1024 * 1024)
 288 #define MAX_MSG_SIZE (32 * 1024)
 289
 290 static void test_seqpacket_msg_bounds_client(const struct test_opts *opts)
 291 {
 292         unsigned long curr_hash;
 293         int page_size;
 294         int msg_count;
 295         int fd;
 296
 297         fd = vsock_seqpacket_connect(opts->peer_cid, 1234);
 298         if (fd < 0) {
 299                 perror("connect");
 300                 exit(EXIT_FAILURE);
 301         }
 302
 303         /* Wait, until receiver sets buffer size. */
 304         control_expectln("SRVREADY");
 305
 306         curr_hash = 0;
 307         page_size = getpagesize();
 308         msg_count = SOCK_BUF_SIZE / MAX_MSG_SIZE;
 309
 310         for (int i = 0; i < msg_count; i++) {
 311                 ssize_t send_size;
 312                 size_t buf_size;
 313                 int flags;
 314                 void *buf;
 315
 316                 /* Use "small" buffers and "big" buffers. */
 317                 if (i & 1)
 318                         buf_size = page_size +
 319                                         (rand() % (MAX_MSG_SIZE - page_size));
 320                 else
 321                         buf_size = 1 + (rand() % page_size);
 322
 323                 buf = malloc(buf_size);
 324
 325                 if (!buf) {
 326                         perror("malloc");
 327                         exit(EXIT_FAILURE);
 328                 }
 329
 330                 memset(buf, rand() & 0xff, buf_size);
 331                 /* Set at least one MSG_EOR + some random. */
 332                 if (i == (msg_count / 2) || (rand() & 1)) {
 333                         flags = MSG_EOR;
 334                         curr_hash++;
 335                 } else {
 336                         flags = 0;
 337                 }
 338
 339                 send_size = send(fd, buf, buf_size, flags);
 340
 341                 if (send_size < 0) {
 342                         perror("send");
 343                         exit(EXIT_FAILURE);
 344                 }
 345
 346                 if (send_size != buf_size) {
 347                         fprintf(stderr, "Invalid send size\n");
 348                         exit(EXIT_FAILURE);
 349                 }
 350
 351                 /*
 352                  * Hash sum is computed at both client and server in
 353                  * the same way:
 354                  * H += hash('message data')
 355                  * Such hash "controls" both data integrity and message
 356                  * bounds. After data exchange, both sums are compared
 357                  * using control socket, and if message bounds wasn't
 358                  * broken - two values must be equal.
 359                  */
 360                 curr_hash += hash_djb2(buf, buf_size);
 361                 free(buf);
 362         }
 363
 364         control_writeln("SENDDONE");
 365         control_writeulong(curr_hash);
 366         close(fd);
 367 }
 368
 369 static void test_seqpacket_msg_bounds_server(const struct test_opts *opts)
 370 {
 371         unsigned long sock_buf_size;
 372         unsigned long remote_hash;
 373         unsigned long curr_hash;
 374         int fd;
 375         char buf[MAX_MSG_SIZE];
 376         struct msghdr msg = {0};
 377         struct iovec iov = {0};
 378
 379         fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL);
 380         if (fd < 0) {
 381                 perror("accept");
 382                 exit(EXIT_FAILURE);
 383         }
 384
 385         sock_buf_size = SOCK_BUF_SIZE;
 386
 387         if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_MAX_SIZE,
 388                        &sock_buf_size, sizeof(sock_buf_size))) {
 389                 perror("setsockopt(SO_VM_SOCKETS_BUFFER_MAX_SIZE)");
 390                 exit(EXIT_FAILURE);
 391         }
 392
 393         if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE,
 394                        &sock_buf_size, sizeof(sock_buf_size))) {
 395                 perror("setsockopt(SO_VM_SOCKETS_BUFFER_SIZE)");
 396                 exit(EXIT_FAILURE);
 397         }
 398
 399         /* Ready to receive data. */
 400         control_writeln("SRVREADY");
 401         /* Wait, until peer sends whole data. */
 402         control_expectln("SENDDONE");
 403         iov.iov_base = buf;
 404         iov.iov_len = sizeof(buf);
 405         msg.msg_iov = &iov;
 406         msg.msg_iovlen = 1;
 407
 408         curr_hash = 0;
 409
 410         while (1) {
 411                 ssize_t recv_size;
 412
 413                 recv_size = recvmsg(fd, &msg, 0);
 414
 415                 if (!recv_size)
 416                         break;
 417
 418                 if (recv_size < 0) {
 419                         perror("recvmsg");
 420                         exit(EXIT_FAILURE);
 421                 }
 422
 423                 if (msg.msg_flags & MSG_EOR)
 424                         curr_hash++;
 425
 426                 curr_hash += hash_djb2(msg.msg_iov[0].iov_base, recv_size);
 427         }
 428
 429         close(fd);
 430         remote_hash = control_readulong();
 431
 432         if (curr_hash != remote_hash) {
 433                 fprintf(stderr, "Message bounds broken\n");
 434                 exit(EXIT_FAILURE);
 435         }
 436 }
 437
 438 #define MESSAGE_TRUNC_SZ 32
 439 static void test_seqpacket_msg_trunc_client(const struct test_opts *opts)
 440 {
 441         int fd;
 442         char buf[MESSAGE_TRUNC_SZ];
 443
 444         fd = vsock_seqpacket_connect(opts->peer_cid, 1234);
 445         if (fd < 0) {
 446                 perror("connect");
 447                 exit(EXIT_FAILURE);
 448         }
 449
 450         if (send(fd, buf, sizeof(buf), 0) != sizeof(buf)) {
 451                 perror("send failed");
 452                 exit(EXIT_FAILURE);
 453         }
 454
 455         control_writeln("SENDDONE");
 456         close(fd);
 457 }
 458
 459 static void test_seqpacket_msg_trunc_server(const struct test_opts *opts)
 460 {
 461         int fd;
 462         char buf[MESSAGE_TRUNC_SZ / 2];
 463         struct msghdr msg = {0};
 464         struct iovec iov = {0};
 465
 466         fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL);
 467         if (fd < 0) {
 468                 perror("accept");
 469                 exit(EXIT_FAILURE);
 470         }
 471
 472         control_expectln("SENDDONE");
 473         iov.iov_base = buf;
 474         iov.iov_len = sizeof(buf);
 475         msg.msg_iov = &iov;
 476         msg.msg_iovlen = 1;
 477
 478         ssize_t ret = recvmsg(fd, &msg, MSG_TRUNC);
 479
 480         if (ret != MESSAGE_TRUNC_SZ) {
 481                 printf("%zi\n", ret);
 482                 perror("MSG_TRUNC doesn't work");
 483                 exit(EXIT_FAILURE);
 484         }
 485
 486         if (!(msg.msg_flags & MSG_TRUNC)) {
 487                 fprintf(stderr, "MSG_TRUNC expected\n");
 488                 exit(EXIT_FAILURE);
 489         }
 490
 491         close(fd);
 492 }
 493
 494 static time_t current_nsec(void)
 495 {
 496         struct timespec ts;
 497
 498         if (clock_gettime(CLOCK_REALTIME, &ts)) {
 499                 perror("clock_gettime(3) failed");
 500                 exit(EXIT_FAILURE);
 501         }
 502
 503         return (ts.tv_sec * 1000000000ULL) + ts.tv_nsec;
 504 }
 505
 506 #define RCVTIMEO_TIMEOUT_SEC 1
 507 #define READ_OVERHEAD_NSEC 250000000 /* 0.25 sec */
 508
 509 static void test_seqpacket_timeout_client(const struct test_opts *opts)
 510 {
 511         int fd;
 512         struct timeval tv;
 513         char dummy;
 514         time_t read_enter_ns;
 515         time_t read_overhead_ns;
 516
 517         fd = vsock_seqpacket_connect(opts->peer_cid, 1234);
 518         if (fd < 0) {
 519                 perror("connect");
 520                 exit(EXIT_FAILURE);
 521         }
 522
 523         tv.tv_sec = RCVTIMEO_TIMEOUT_SEC;
 524         tv.tv_usec = 0;
 525
 526         if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv)) == -1) {
 527                 perror("setsockopt(SO_RCVTIMEO)");
 528                 exit(EXIT_FAILURE);
 529         }
 530
 531         read_enter_ns = current_nsec();
 532
 533         if (read(fd, &dummy, sizeof(dummy)) != -1) {
 534                 fprintf(stderr,
 535                         "expected 'dummy' read(2) failure\n");
 536                 exit(EXIT_FAILURE);
 537         }
 538
 539         if (errno != EAGAIN) {
 540                 perror("EAGAIN expected");
 541                 exit(EXIT_FAILURE);
 542         }
 543
 544         read_overhead_ns = current_nsec() - read_enter_ns -
 545                         1000000000ULL * RCVTIMEO_TIMEOUT_SEC;
 546
 547         if (read_overhead_ns > READ_OVERHEAD_NSEC) {
 548                 fprintf(stderr,
 549                         "too much time in read(2), %lu > %i ns\n",
 550                         read_overhead_ns, READ_OVERHEAD_NSEC);
 551                 exit(EXIT_FAILURE);
 552         }
 553
 554         control_writeln("WAITDONE");
 555         close(fd);
 556 }
 557
 558 static void test_seqpacket_timeout_server(const struct test_opts *opts)
 559 {
 560         int fd;
 561
 562         fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL);
 563         if (fd < 0) {
 564                 perror("accept");
 565                 exit(EXIT_FAILURE);
 566         }
 567
 568         control_expectln("WAITDONE");
 569         close(fd);
 570 }
 571
 572 static void test_seqpacket_bigmsg_client(const struct test_opts *opts)
 573 {
 574         unsigned long sock_buf_size;
 575         ssize_t send_size;
 576         socklen_t len;
 577         void *data;
 578         int fd;
 579
 580         len = sizeof(sock_buf_size);
 581
 582         fd = vsock_seqpacket_connect(opts->peer_cid, 1234);
 583         if (fd < 0) {
 584                 perror("connect");
 585                 exit(EXIT_FAILURE);
 586         }
 587
 588         if (getsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE,
 589                        &sock_buf_size, &len)) {
 590                 perror("getsockopt");
 591                 exit(EXIT_FAILURE);
 592         }
 593
 594         sock_buf_size++;
 595
 596         data = malloc(sock_buf_size);
 597         if (!data) {
 598                 perror("malloc");
 599                 exit(EXIT_FAILURE);
 600         }
 601
 602         send_size = send(fd, data, sock_buf_size, 0);
 603         if (send_size != -1) {
 604                 fprintf(stderr, "expected 'send(2)' failure, got %zi\n",
 605                         send_size);
 606                 exit(EXIT_FAILURE);
 607         }
 608
 609         if (errno != EMSGSIZE) {
 610                 fprintf(stderr, "expected EMSGSIZE in 'errno', got %i\n",
 611                         errno);
 612                 exit(EXIT_FAILURE);
 613         }
 614
 615         control_writeln("CLISENT");
 616
 617         free(data);
 618         close(fd);
 619 }
 620
 621 static void test_seqpacket_bigmsg_server(const struct test_opts *opts)
 622 {
 623         int fd;
 624
 625         fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL);
 626         if (fd < 0) {
 627                 perror("accept");
 628                 exit(EXIT_FAILURE);
 629         }
 630
 631         control_expectln("CLISENT");
 632
 633         close(fd);
 634 }
 635
 636 #define BUF_PATTERN_1 'a'
 637 #define BUF_PATTERN_2 'b'
 638
 639 static void test_seqpacket_invalid_rec_buffer_client(const struct test_opts *opts)
 640 {
 641         int fd;
 642         unsigned char *buf1;
 643         unsigned char *buf2;
 644         int buf_size = getpagesize() * 3;
 645
 646         fd = vsock_seqpacket_connect(opts->peer_cid, 1234);
 647         if (fd < 0) {
 648                 perror("connect");
 649                 exit(EXIT_FAILURE);
 650         }
 651
 652         buf1 = malloc(buf_size);
 653         if (!buf1) {
 654                 perror("'malloc()' for 'buf1'");
 655                 exit(EXIT_FAILURE);
 656         }
 657
 658         buf2 = malloc(buf_size);
 659         if (!buf2) {
 660                 perror("'malloc()' for 'buf2'");
 661                 exit(EXIT_FAILURE);
 662         }
 663
 664         memset(buf1, BUF_PATTERN_1, buf_size);
 665         memset(buf2, BUF_PATTERN_2, buf_size);
 666
 667         if (send(fd, buf1, buf_size, 0) != buf_size) {
 668                 perror("send failed");
 669                 exit(EXIT_FAILURE);
 670         }
 671
 672         if (send(fd, buf2, buf_size, 0) != buf_size) {
 673                 perror("send failed");
 674                 exit(EXIT_FAILURE);
 675         }
 676
 677         close(fd);
 678 }
 679
 680 static void test_seqpacket_invalid_rec_buffer_server(const struct test_opts *opts)
 681 {
 682         int fd;
 683         unsigned char *broken_buf;
 684         unsigned char *valid_buf;
 685         int page_size = getpagesize();
 686         int buf_size = page_size * 3;
 687         ssize_t res;
 688         int prot = PROT_READ | PROT_WRITE;
 689         int flags = MAP_PRIVATE | MAP_ANONYMOUS;
 690         int i;
 691
 692         fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL);
 693         if (fd < 0) {
 694                 perror("accept");
 695                 exit(EXIT_FAILURE);
 696         }
 697
 698         /* Setup first buffer. */
 699         broken_buf = mmap(NULL, buf_size, prot, flags, -1, 0);
 700         if (broken_buf == MAP_FAILED) {
 701                 perror("mmap for 'broken_buf'");
 702                 exit(EXIT_FAILURE);
 703         }
 704
 705         /* Unmap "hole" in buffer. */
 706         if (munmap(broken_buf + page_size, page_size)) {
 707                 perror("'broken_buf' setup");
 708                 exit(EXIT_FAILURE);
 709         }
 710
 711         valid_buf = mmap(NULL, buf_size, prot, flags, -1, 0);
 712         if (valid_buf == MAP_FAILED) {
 713                 perror("mmap for 'valid_buf'");
 714                 exit(EXIT_FAILURE);
 715         }
 716
 717         /* Try to fill buffer with unmapped middle. */
 718         res = read(fd, broken_buf, buf_size);
 719         if (res != -1) {
 720                 fprintf(stderr,
 721                         "expected 'broken_buf' read(2) failure, got %zi\n",
 722                         res);
 723                 exit(EXIT_FAILURE);
 724         }
 725
 726         if (errno != EFAULT) {
 727                 perror("unexpected errno of 'broken_buf'");
 728                 exit(EXIT_FAILURE);
 729         }
 730
 731         /* Try to fill valid buffer. */
 732         res = read(fd, valid_buf, buf_size);
 733         if (res < 0) {
 734                 perror("unexpected 'valid_buf' read(2) failure");
 735                 exit(EXIT_FAILURE);
 736         }
 737
 738         if (res != buf_size) {
 739                 fprintf(stderr,
 740                         "invalid 'valid_buf' read(2), expected %i, got %zi\n",
 741                         buf_size, res);
 742                 exit(EXIT_FAILURE);
 743         }
 744
 745         for (i = 0; i < buf_size; i++) {
 746                 if (valid_buf[i] != BUF_PATTERN_2) {
 747                         fprintf(stderr,
 748                                 "invalid pattern for 'valid_buf' at %i, expected %hhX, got %hhX\n",
 749                                 i, BUF_PATTERN_2, valid_buf[i]);
 750                         exit(EXIT_FAILURE);
 751                 }
 752         }
 753
 754         /* Unmap buffers. */
 755         munmap(broken_buf, page_size);
 756         munmap(broken_buf + page_size * 2, page_size);
 757         munmap(valid_buf, buf_size);
 758         close(fd);
 759 }
 760
 761 #define RCVLOWAT_BUF_SIZE 128
 762
 763 static void test_stream_poll_rcvlowat_server(const struct test_opts *opts)
 764 {
 765         int fd;
 766         int i;
 767
 768         fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
 769         if (fd < 0) {
 770                 perror("accept");
 771                 exit(EXIT_FAILURE);
 772         }
 773
 774         /* Send 1 byte. */
 775         send_byte(fd, 1, 0);
 776
 777         control_writeln("SRVSENT");
 778
 779         /* Wait until client is ready to receive rest of data. */
 780         control_expectln("CLNSENT");
 781
 782         for (i = 0; i < RCVLOWAT_BUF_SIZE - 1; i++)
 783                 send_byte(fd, 1, 0);
 784
 785         /* Keep socket in active state. */
 786         control_expectln("POLLDONE");
 787
 788         close(fd);
 789 }
 790
 791 static void test_stream_poll_rcvlowat_client(const struct test_opts *opts)
 792 {
 793         unsigned long lowat_val = RCVLOWAT_BUF_SIZE;
 794         char buf[RCVLOWAT_BUF_SIZE];
 795         struct pollfd fds;
 796         ssize_t read_res;
 797         short poll_flags;
 798         int fd;
 799
 800         fd = vsock_stream_connect(opts->peer_cid, 1234);
 801         if (fd < 0) {
 802                 perror("connect");
 803                 exit(EXIT_FAILURE);
 804         }
 805
 806         if (setsockopt(fd, SOL_SOCKET, SO_RCVLOWAT,
 807                        &lowat_val, sizeof(lowat_val))) {
 808                 perror("setsockopt(SO_RCVLOWAT)");
 809                 exit(EXIT_FAILURE);
 810         }
 811
 812         control_expectln("SRVSENT");
 813
 814         /* At this point, server sent 1 byte. */
 815         fds.fd = fd;
 816         poll_flags = POLLIN | POLLRDNORM;
 817         fds.events = poll_flags;
 818
 819         /* Try to wait for 1 sec. */
 820         if (poll(&fds, 1, 1000) < 0) {
 821                 perror("poll");
 822                 exit(EXIT_FAILURE);
 823         }
 824
 825         /* poll() must return nothing. */
 826         if (fds.revents) {
 827                 fprintf(stderr, "Unexpected poll result %hx\n",
 828                         fds.revents);
 829                 exit(EXIT_FAILURE);
 830         }
 831
 832         /* Tell server to send rest of data. */
 833         control_writeln("CLNSENT");
 834
 835         /* Poll for data. */
 836         if (poll(&fds, 1, 10000) < 0) {
 837                 perror("poll");
 838                 exit(EXIT_FAILURE);
 839         }
 840
 841         /* Only these two bits are expected. */
 842         if (fds.revents != poll_flags) {
 843                 fprintf(stderr, "Unexpected poll result %hx\n",
 844                         fds.revents);
 845                 exit(EXIT_FAILURE);
 846         }
 847
 848         /* Use MSG_DONTWAIT, if call is going to wait, EAGAIN
 849          * will be returned.
 850          */
 851         read_res = recv(fd, buf, sizeof(buf), MSG_DONTWAIT);
 852         if (read_res != RCVLOWAT_BUF_SIZE) {
 853                 fprintf(stderr, "Unexpected recv result %zi\n",
 854                         read_res);
 855                 exit(EXIT_FAILURE);
 856         }
 857
 858         control_writeln("POLLDONE");
 859
 860         close(fd);
 861 }
 862
 863 #define INV_BUF_TEST_DATA_LEN 512
 864
 865 static void test_inv_buf_client(const struct test_opts *opts, bool stream)
 866 {
 867         unsigned char data[INV_BUF_TEST_DATA_LEN] = {0};
 868         ssize_t ret;
 869         int fd;
 870
 871         if (stream)
 872                 fd = vsock_stream_connect(opts->peer_cid, 1234);
 873         else
 874                 fd = vsock_seqpacket_connect(opts->peer_cid, 1234);
 875
 876         if (fd < 0) {
 877                 perror("connect");
 878                 exit(EXIT_FAILURE);
 879         }
 880
 881         control_expectln("SENDDONE");
 882
 883         /* Use invalid buffer here. */
 884         ret = recv(fd, NULL, sizeof(data), 0);
 885         if (ret != -1) {
 886                 fprintf(stderr, "expected recv(2) failure, got %zi\n", ret);
 887                 exit(EXIT_FAILURE);
 888         }
 889
 890         if (errno != EFAULT) {
 891                 fprintf(stderr, "unexpected recv(2) errno %d\n", errno);
 892                 exit(EXIT_FAILURE);
 893         }
 894
 895         ret = recv(fd, data, sizeof(data), MSG_DONTWAIT);
 896
 897         if (stream) {
 898                 /* For SOCK_STREAM we must continue reading. */
 899                 if (ret != sizeof(data)) {
 900                         fprintf(stderr, "expected recv(2) success, got %zi\n", ret);
 901                         exit(EXIT_FAILURE);
 902                 }
 903                 /* Don't check errno in case of success. */
 904         } else {
 905                 /* For SOCK_SEQPACKET socket's queue must be empty. */
 906                 if (ret != -1) {
 907                         fprintf(stderr, "expected recv(2) failure, got %zi\n", ret);
 908                         exit(EXIT_FAILURE);
 909                 }
 910
 911                 if (errno != EAGAIN) {
 912                         fprintf(stderr, "unexpected recv(2) errno %d\n", errno);
 913                         exit(EXIT_FAILURE);
 914                 }
 915         }
 916
 917         control_writeln("DONE");
 918
 919         close(fd);
 920 }
 921
 922 static void test_inv_buf_server(const struct test_opts *opts, bool stream)
 923 {
 924         unsigned char data[INV_BUF_TEST_DATA_LEN] = {0};
 925         ssize_t res;
 926         int fd;
 927
 928         if (stream)
 929                 fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
 930         else
 931                 fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL);
 932
 933         if (fd < 0) {
 934                 perror("accept");
 935                 exit(EXIT_FAILURE);
 936         }
 937
 938         res = send(fd, data, sizeof(data), 0);
 939         if (res != sizeof(data)) {
 940                 fprintf(stderr, "unexpected send(2) result %zi\n", res);
 941                 exit(EXIT_FAILURE);
 942         }
 943
 944         control_writeln("SENDDONE");
 945
 946         control_expectln("DONE");
 947
 948         close(fd);
 949 }
 950
 951 static void test_stream_inv_buf_client(const struct test_opts *opts)
 952 {
 953         test_inv_buf_client(opts, true);
 954 }
 955
 956 static void test_stream_inv_buf_server(const struct test_opts *opts)
 957 {
 958         test_inv_buf_server(opts, true);
 959 }
 960
 961 static void test_seqpacket_inv_buf_client(const struct test_opts *opts)
 962 {
 963         test_inv_buf_client(opts, false);
 964 }
 965
 966 static void test_seqpacket_inv_buf_server(const struct test_opts *opts)
 967 {
 968         test_inv_buf_server(opts, false);
 969 }
 970
 971 #define HELLO_STR "HELLO"
 972 #define WORLD_STR "WORLD"
 973
 974 static void test_stream_virtio_skb_merge_client(const struct test_opts *opts)
 975 {
 976         ssize_t res;
 977         int fd;
 978
 979         fd = vsock_stream_connect(opts->peer_cid, 1234);
 980         if (fd < 0) {
 981                 perror("connect");
 982                 exit(EXIT_FAILURE);
 983         }
 984
 985         /* Send first skbuff. */
 986         res = send(fd, HELLO_STR, strlen(HELLO_STR), 0);
 987         if (res != strlen(HELLO_STR)) {
 988                 fprintf(stderr, "unexpected send(2) result %zi\n", res);
 989                 exit(EXIT_FAILURE);
 990         }
 991
 992         control_writeln("SEND0");
 993         /* Peer reads part of first skbuff. */
 994         control_expectln("REPLY0");
 995
 996         /* Send second skbuff, it will be appended to the first. */
 997         res = send(fd, WORLD_STR, strlen(WORLD_STR), 0);
 998         if (res != strlen(WORLD_STR)) {
 999                 fprintf(stderr, "unexpected send(2) result %zi\n", res);
1000                 exit(EXIT_FAILURE);
1001         }
1002
1003         control_writeln("SEND1");
1004         /* Peer reads merged skbuff packet. */
1005         control_expectln("REPLY1");
1006
1007         close(fd);
1008 }
1009
1010 static void test_stream_virtio_skb_merge_server(const struct test_opts *opts)
1011 {
1012         unsigned char buf[64];
1013         ssize_t res;
1014         int fd;
1015
1016         fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL);
1017         if (fd < 0) {
1018                 perror("accept");
1019                 exit(EXIT_FAILURE);
1020         }
1021
1022         control_expectln("SEND0");
1023
1024         /* Read skbuff partially. */
1025         res = recv(fd, buf, 2, 0);
1026         if (res != 2) {
1027                 fprintf(stderr, "expected recv(2) returns 2 bytes, got %zi\n", res);
1028                 exit(EXIT_FAILURE);
1029         }
1030
1031         control_writeln("REPLY0");
1032         control_expectln("SEND1");
1033
1034         res = recv(fd, buf + 2, sizeof(buf) - 2, 0);
1035         if (res != 8) {
1036                 fprintf(stderr, "expected recv(2) returns 8 bytes, got %zi\n", res);
1037                 exit(EXIT_FAILURE);
1038         }
1039
1040         res = recv(fd, buf, sizeof(buf) - 8 - 2, MSG_DONTWAIT);
1041         if (res != -1) {
1042                 fprintf(stderr, "expected recv(2) failure, got %zi\n", res);
1043                 exit(EXIT_FAILURE);
1044         }
1045
1046         if (memcmp(buf, HELLO_STR WORLD_STR, strlen(HELLO_STR WORLD_STR))) {
1047                 fprintf(stderr, "pattern mismatch\n");
1048                 exit(EXIT_FAILURE);
1049         }
1050
1051         control_writeln("REPLY1");
1052
1053         close(fd);
1054 }
1055
1056 static struct test_case test_cases[] = {
1057         {
1058                 .name = "SOCK_STREAM connection reset",
1059                 .run_client = test_stream_connection_reset,
1060         },
1061         {
1062                 .name = "SOCK_STREAM bind only",
1063                 .run_client = test_stream_bind_only_client,
1064                 .run_server = test_stream_bind_only_server,
1065         },
1066         {
1067                 .name = "SOCK_STREAM client close",
1068                 .run_client = test_stream_client_close_client,
1069                 .run_server = test_stream_client_close_server,
1070         },
1071         {
1072                 .name = "SOCK_STREAM server close",
1073                 .run_client = test_stream_server_close_client,
1074                 .run_server = test_stream_server_close_server,
1075         },
1076         {
1077                 .name = "SOCK_STREAM multiple connections",
1078                 .run_client = test_stream_multiconn_client,
1079                 .run_server = test_stream_multiconn_server,
1080         },
1081         {
1082                 .name = "SOCK_STREAM MSG_PEEK",
1083                 .run_client = test_stream_msg_peek_client,
1084                 .run_server = test_stream_msg_peek_server,
1085         },
1086         {
1087                 .name = "SOCK_SEQPACKET msg bounds",
1088                 .run_client = test_seqpacket_msg_bounds_client,
1089                 .run_server = test_seqpacket_msg_bounds_server,
1090         },
1091         {
1092                 .name = "SOCK_SEQPACKET MSG_TRUNC flag",
1093                 .run_client = test_seqpacket_msg_trunc_client,
1094                 .run_server = test_seqpacket_msg_trunc_server,
1095         },
1096         {
1097                 .name = "SOCK_SEQPACKET timeout",
1098                 .run_client = test_seqpacket_timeout_client,
1099                 .run_server = test_seqpacket_timeout_server,
1100         },
1101         {
1102                 .name = "SOCK_SEQPACKET invalid receive buffer",
1103                 .run_client = test_seqpacket_invalid_rec_buffer_client,
1104                 .run_server = test_seqpacket_invalid_rec_buffer_server,
1105         },
1106         {
1107                 .name = "SOCK_STREAM poll() + SO_RCVLOWAT",
1108                 .run_client = test_stream_poll_rcvlowat_client,
1109                 .run_server = test_stream_poll_rcvlowat_server,
1110         },
1111         {
1112                 .name = "SOCK_SEQPACKET big message",
1113                 .run_client = test_seqpacket_bigmsg_client,
1114                 .run_server = test_seqpacket_bigmsg_server,
1115         },
1116         {
1117                 .name = "SOCK_STREAM test invalid buffer",
1118                 .run_client = test_stream_inv_buf_client,
1119                 .run_server = test_stream_inv_buf_server,
1120         },
1121         {
1122                 .name = "SOCK_SEQPACKET test invalid buffer",
1123                 .run_client = test_seqpacket_inv_buf_client,
1124                 .run_server = test_seqpacket_inv_buf_server,
1125         },
1126         {
1127                 .name = "SOCK_STREAM virtio skb merge",
1128                 .run_client = test_stream_virtio_skb_merge_client,
1129                 .run_server = test_stream_virtio_skb_merge_server,
1130         },
1131         {},
1132 };
1133
1134 static const char optstring[] = "";
1135 static const struct option longopts[] = {
1136         {
1137                 .name = "control-host",
1138                 .has_arg = required_argument,
1139                 .val = 'H',
1140         },
1141         {
1142                 .name = "control-port",
1143                 .has_arg = required_argument,
1144                 .val = 'P',
1145         },
1146         {
1147                 .name = "mode",
1148                 .has_arg = required_argument,
1149                 .val = 'm',
1150         },
1151         {
1152                 .name = "peer-cid",
1153                 .has_arg = required_argument,
1154                 .val = 'p',
1155         },
1156         {
1157                 .name = "list",
1158                 .has_arg = no_argument,
1159                 .val = 'l',
1160         },
1161         {
1162                 .name = "skip",
1163                 .has_arg = required_argument,
1164                 .val = 's',
1165         },
1166         {
1167                 .name = "help",
1168                 .has_arg = no_argument,
1169                 .val = '?',
1170         },
1171         {},
1172 };
1173
1174 static void usage(void)
1175 {
1176         fprintf(stderr, "Usage: vsock_test [--help] [--control-host=<host>] --control-port=<port> --mode=client|server --peer-cid=<cid> [--list] [--skip=<test_id>]\n"
1177                 "\n"
1178                 "  Server: vsock_test --control-port=1234 --mode=server --peer-cid=3\n"
1179                 "  Client: vsock_test --control-host=192.168.0.1 --control-port=1234 --mode=client --peer-cid=2\n"
1180                 "\n"
1181                 "Run vsock.ko tests.  Must be launched in both guest\n"
1182                 "and host.  One side must use --mode=client and\n"
1183                 "the other side must use --mode=server.\n"
1184                 "\n"
1185                 "A TCP control socket connection is used to coordinate tests\n"
1186                 "between the client and the server.  The server requires a\n"
1187                 "listen address and the client requires an address to\n"
1188                 "connect to.\n"
1189                 "\n"
1190                 "The CID of the other side must be given with --peer-cid=<cid>.\n"
1191                 "\n"
1192                 "Options:\n"
1193                 "  --help                 This help message\n"
1194                 "  --control-host <host>  Server IP address to connect to\n"
1195                 "  --control-port <port>  Server port to listen on/connect to\n"
1196                 "  --mode client|server   Server or client mode\n"
1197                 "  --peer-cid <cid>       CID of the other side\n"
1198                 "  --list                 List of tests that will be executed\n"
1199                 "  --skip <test_id>       Test ID to skip;\n"
1200                 "                         use multiple --skip options to skip more tests\n"
1201                 );
1202         exit(EXIT_FAILURE);
1203 }
1204
1205 int main(int argc, char **argv)
1206 {
1207         const char *control_host = NULL;
1208         const char *control_port = NULL;
1209         struct test_opts opts = {
1210                 .mode = TEST_MODE_UNSET,
1211                 .peer_cid = VMADDR_CID_ANY,
1212         };
1213
1214         srand(time(NULL));
1215         init_signals();
1216
1217         for (;;) {
1218                 int opt = getopt_long(argc, argv, optstring, longopts, NULL);
1219
1220                 if (opt == -1)
1221                         break;
1222
1223                 switch (opt) {
1224                 case 'H':
1225                         control_host = optarg;
1226                         break;
1227                 case 'm':
1228                         if (strcmp(optarg, "client") == 0)
1229                                 opts.mode = TEST_MODE_CLIENT;
1230                         else if (strcmp(optarg, "server") == 0)
1231                                 opts.mode = TEST_MODE_SERVER;
1232                         else {
1233                                 fprintf(stderr, "--mode must be \"client\" or \"server\"\n");
1234                                 return EXIT_FAILURE;
1235                         }
1236                         break;
1237                 case 'p':
1238                         opts.peer_cid = parse_cid(optarg);
1239                         break;
1240                 case 'P':
1241                         control_port = optarg;
1242                         break;
1243                 case 'l':
1244                         list_tests(test_cases);
1245                         break;
1246                 case 's':
1247                         skip_test(test_cases, ARRAY_SIZE(test_cases) - 1,
1248                                   optarg);
1249                         break;
1250                 case '?':
1251                 default:
1252                         usage();
1253                 }
1254         }
1255
1256         if (!control_port)
1257                 usage();
1258         if (opts.mode == TEST_MODE_UNSET)
1259                 usage();
1260         if (opts.peer_cid == VMADDR_CID_ANY)
1261                 usage();
1262
1263         if (!control_host) {
1264                 if (opts.mode != TEST_MODE_SERVER)
1265                         usage();
1266                 control_host = "0.0.0.0";
1267         }
1268
1269         control_init(control_host, control_port,
1270                      opts.mode == TEST_MODE_SERVER);
1271
1272         run_tests(test_cases, &opts);
1273
1274         control_cleanup();
1275         return EXIT_SUCCESS;
1276 }