1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * vsock_diag_test - vsock_diag.ko test suite 4 * 5 * Copyright (C) 2017 Red Hat, Inc. 6 * 7 * Author: Stefan Hajnoczi <stefanha@redhat.com> 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 <sys/stat.h> 17 #include <sys/types.h> 18 #include <linux/list.h> 19 #include <linux/net.h> 20 #include <linux/netlink.h> 21 #include <linux/sock_diag.h> 22 #include <linux/vm_sockets_diag.h> 23 #include <netinet/tcp.h> 24 25 #include "timeout.h" 26 #include "control.h" 27 #include "util.h" 28 29 /* Per-socket status */ 30 struct vsock_stat { 31 struct list_head list; 32 struct vsock_diag_msg msg; 33 }; 34 35 static const char *sock_type_str(int type) 36 { 37 switch (type) { 38 case SOCK_DGRAM: 39 return "DGRAM"; 40 case SOCK_STREAM: 41 return "STREAM"; 42 default: 43 return "INVALID TYPE"; 44 } 45 } 46 47 static const char *sock_state_str(int state) 48 { 49 switch (state) { 50 case TCP_CLOSE: 51 return "UNCONNECTED"; 52 case TCP_SYN_SENT: 53 return "CONNECTING"; 54 case TCP_ESTABLISHED: 55 return "CONNECTED"; 56 case TCP_CLOSING: 57 return "DISCONNECTING"; 58 case TCP_LISTEN: 59 return "LISTEN"; 60 default: 61 return "INVALID STATE"; 62 } 63 } 64 65 static const char *sock_shutdown_str(int shutdown) 66 { 67 switch (shutdown) { 68 case 1: 69 return "RCV_SHUTDOWN"; 70 case 2: 71 return "SEND_SHUTDOWN"; 72 case 3: 73 return "RCV_SHUTDOWN | SEND_SHUTDOWN"; 74 default: 75 return "0"; 76 } 77 } 78 79 static void print_vsock_addr(FILE *fp, unsigned int cid, unsigned int port) 80 { 81 if (cid == VMADDR_CID_ANY) 82 fprintf(fp, "*:"); 83 else 84 fprintf(fp, "%u:", cid); 85 86 if (port == VMADDR_PORT_ANY) 87 fprintf(fp, "*"); 88 else 89 fprintf(fp, "%u", port); 90 } 91 92 static void print_vsock_stat(FILE *fp, struct vsock_stat *st) 93 { 94 print_vsock_addr(fp, st->msg.vdiag_src_cid, st->msg.vdiag_src_port); 95 fprintf(fp, " "); 96 print_vsock_addr(fp, st->msg.vdiag_dst_cid, st->msg.vdiag_dst_port); 97 fprintf(fp, " %s %s %s %u\n", 98 sock_type_str(st->msg.vdiag_type), 99 sock_state_str(st->msg.vdiag_state), 100 sock_shutdown_str(st->msg.vdiag_shutdown), 101 st->msg.vdiag_ino); 102 } 103 104 static void print_vsock_stats(FILE *fp, struct list_head *head) 105 { 106 struct vsock_stat *st; 107 108 list_for_each_entry(st, head, list) 109 print_vsock_stat(fp, st); 110 } 111 112 static struct vsock_stat *find_vsock_stat(struct list_head *head, int fd) 113 { 114 struct vsock_stat *st; 115 struct stat stat; 116 117 if (fstat(fd, &stat) < 0) { 118 perror("fstat"); 119 exit(EXIT_FAILURE); 120 } 121 122 list_for_each_entry(st, head, list) 123 if (st->msg.vdiag_ino == stat.st_ino) 124 return st; 125 126 fprintf(stderr, "cannot find fd %d\n", fd); 127 exit(EXIT_FAILURE); 128 } 129 130 static void check_no_sockets(struct list_head *head) 131 { 132 if (!list_empty(head)) { 133 fprintf(stderr, "expected no sockets\n"); 134 print_vsock_stats(stderr, head); 135 exit(1); 136 } 137 } 138 139 static void check_num_sockets(struct list_head *head, int expected) 140 { 141 struct list_head *node; 142 int n = 0; 143 144 list_for_each(node, head) 145 n++; 146 147 if (n != expected) { 148 fprintf(stderr, "expected %d sockets, found %d\n", 149 expected, n); 150 print_vsock_stats(stderr, head); 151 exit(EXIT_FAILURE); 152 } 153 } 154 155 static void check_socket_state(struct vsock_stat *st, __u8 state) 156 { 157 if (st->msg.vdiag_state != state) { 158 fprintf(stderr, "expected socket state %#x, got %#x\n", 159 state, st->msg.vdiag_state); 160 exit(EXIT_FAILURE); 161 } 162 } 163 164 static void send_req(int fd) 165 { 166 struct sockaddr_nl nladdr = { 167 .nl_family = AF_NETLINK, 168 }; 169 struct { 170 struct nlmsghdr nlh; 171 struct vsock_diag_req vreq; 172 } req = { 173 .nlh = { 174 .nlmsg_len = sizeof(req), 175 .nlmsg_type = SOCK_DIAG_BY_FAMILY, 176 .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP, 177 }, 178 .vreq = { 179 .sdiag_family = AF_VSOCK, 180 .vdiag_states = ~(__u32)0, 181 }, 182 }; 183 struct iovec iov = { 184 .iov_base = &req, 185 .iov_len = sizeof(req), 186 }; 187 struct msghdr msg = { 188 .msg_name = &nladdr, 189 .msg_namelen = sizeof(nladdr), 190 .msg_iov = &iov, 191 .msg_iovlen = 1, 192 }; 193 194 for (;;) { 195 if (sendmsg(fd, &msg, 0) < 0) { 196 if (errno == EINTR) 197 continue; 198 199 perror("sendmsg"); 200 exit(EXIT_FAILURE); 201 } 202 203 return; 204 } 205 } 206 207 static ssize_t recv_resp(int fd, void *buf, size_t len) 208 { 209 struct sockaddr_nl nladdr = { 210 .nl_family = AF_NETLINK, 211 }; 212 struct iovec iov = { 213 .iov_base = buf, 214 .iov_len = len, 215 }; 216 struct msghdr msg = { 217 .msg_name = &nladdr, 218 .msg_namelen = sizeof(nladdr), 219 .msg_iov = &iov, 220 .msg_iovlen = 1, 221 }; 222 ssize_t ret; 223 224 do { 225 ret = recvmsg(fd, &msg, 0); 226 } while (ret < 0 && errno == EINTR); 227 228 if (ret < 0) { 229 perror("recvmsg"); 230 exit(EXIT_FAILURE); 231 } 232 233 return ret; 234 } 235 236 static void add_vsock_stat(struct list_head *sockets, 237 const struct vsock_diag_msg *resp) 238 { 239 struct vsock_stat *st; 240 241 st = malloc(sizeof(*st)); 242 if (!st) { 243 perror("malloc"); 244 exit(EXIT_FAILURE); 245 } 246 247 st->msg = *resp; 248 list_add_tail(&st->list, sockets); 249 } 250 251 /* 252 * Read vsock stats into a list. 253 */ 254 static void read_vsock_stat(struct list_head *sockets) 255 { 256 long buf[8192 / sizeof(long)]; 257 int fd; 258 259 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_SOCK_DIAG); 260 if (fd < 0) { 261 perror("socket"); 262 exit(EXIT_FAILURE); 263 } 264 265 send_req(fd); 266 267 for (;;) { 268 const struct nlmsghdr *h; 269 ssize_t ret; 270 271 ret = recv_resp(fd, buf, sizeof(buf)); 272 if (ret == 0) 273 goto done; 274 if (ret < sizeof(*h)) { 275 fprintf(stderr, "short read of %zd bytes\n", ret); 276 exit(EXIT_FAILURE); 277 } 278 279 h = (struct nlmsghdr *)buf; 280 281 while (NLMSG_OK(h, ret)) { 282 if (h->nlmsg_type == NLMSG_DONE) 283 goto done; 284 285 if (h->nlmsg_type == NLMSG_ERROR) { 286 const struct nlmsgerr *err = NLMSG_DATA(h); 287 288 if (h->nlmsg_len < NLMSG_LENGTH(sizeof(*err))) 289 fprintf(stderr, "NLMSG_ERROR\n"); 290 else { 291 errno = -err->error; 292 perror("NLMSG_ERROR"); 293 } 294 295 exit(EXIT_FAILURE); 296 } 297 298 if (h->nlmsg_type != SOCK_DIAG_BY_FAMILY) { 299 fprintf(stderr, "unexpected nlmsg_type %#x\n", 300 h->nlmsg_type); 301 exit(EXIT_FAILURE); 302 } 303 if (h->nlmsg_len < 304 NLMSG_LENGTH(sizeof(struct vsock_diag_msg))) { 305 fprintf(stderr, "short vsock_diag_msg\n"); 306 exit(EXIT_FAILURE); 307 } 308 309 add_vsock_stat(sockets, NLMSG_DATA(h)); 310 311 h = NLMSG_NEXT(h, ret); 312 } 313 } 314 315 done: 316 close(fd); 317 } 318 319 static void free_sock_stat(struct list_head *sockets) 320 { 321 struct vsock_stat *st; 322 struct vsock_stat *next; 323 324 list_for_each_entry_safe(st, next, sockets, list) 325 free(st); 326 } 327 328 static void test_no_sockets(const struct test_opts *opts) 329 { 330 LIST_HEAD(sockets); 331 332 read_vsock_stat(&sockets); 333 334 check_no_sockets(&sockets); 335 336 free_sock_stat(&sockets); 337 } 338 339 static void test_listen_socket_server(const struct test_opts *opts) 340 { 341 union { 342 struct sockaddr sa; 343 struct sockaddr_vm svm; 344 } addr = { 345 .svm = { 346 .svm_family = AF_VSOCK, 347 .svm_port = 1234, 348 .svm_cid = VMADDR_CID_ANY, 349 }, 350 }; 351 LIST_HEAD(sockets); 352 struct vsock_stat *st; 353 int fd; 354 355 fd = socket(AF_VSOCK, SOCK_STREAM, 0); 356 357 if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) { 358 perror("bind"); 359 exit(EXIT_FAILURE); 360 } 361 362 if (listen(fd, 1) < 0) { 363 perror("listen"); 364 exit(EXIT_FAILURE); 365 } 366 367 read_vsock_stat(&sockets); 368 369 check_num_sockets(&sockets, 1); 370 st = find_vsock_stat(&sockets, fd); 371 check_socket_state(st, TCP_LISTEN); 372 373 close(fd); 374 free_sock_stat(&sockets); 375 } 376 377 static void test_connect_client(const struct test_opts *opts) 378 { 379 int fd; 380 LIST_HEAD(sockets); 381 struct vsock_stat *st; 382 383 fd = vsock_stream_connect(opts->peer_cid, 1234); 384 if (fd < 0) { 385 perror("connect"); 386 exit(EXIT_FAILURE); 387 } 388 389 read_vsock_stat(&sockets); 390 391 check_num_sockets(&sockets, 1); 392 st = find_vsock_stat(&sockets, fd); 393 check_socket_state(st, TCP_ESTABLISHED); 394 395 control_expectln("DONE"); 396 control_writeln("DONE"); 397 398 close(fd); 399 free_sock_stat(&sockets); 400 } 401 402 static void test_connect_server(const struct test_opts *opts) 403 { 404 struct vsock_stat *st; 405 LIST_HEAD(sockets); 406 int client_fd; 407 408 client_fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL); 409 if (client_fd < 0) { 410 perror("accept"); 411 exit(EXIT_FAILURE); 412 } 413 414 read_vsock_stat(&sockets); 415 416 check_num_sockets(&sockets, 1); 417 st = find_vsock_stat(&sockets, client_fd); 418 check_socket_state(st, TCP_ESTABLISHED); 419 420 control_writeln("DONE"); 421 control_expectln("DONE"); 422 423 close(client_fd); 424 free_sock_stat(&sockets); 425 } 426 427 static struct test_case test_cases[] = { 428 { 429 .name = "No sockets", 430 .run_server = test_no_sockets, 431 }, 432 { 433 .name = "Listen socket", 434 .run_server = test_listen_socket_server, 435 }, 436 { 437 .name = "Connect", 438 .run_client = test_connect_client, 439 .run_server = test_connect_server, 440 }, 441 {}, 442 }; 443 444 static const char optstring[] = ""; 445 static const struct option longopts[] = { 446 { 447 .name = "control-host", 448 .has_arg = required_argument, 449 .val = 'H', 450 }, 451 { 452 .name = "control-port", 453 .has_arg = required_argument, 454 .val = 'P', 455 }, 456 { 457 .name = "mode", 458 .has_arg = required_argument, 459 .val = 'm', 460 }, 461 { 462 .name = "peer-cid", 463 .has_arg = required_argument, 464 .val = 'p', 465 }, 466 { 467 .name = "list", 468 .has_arg = no_argument, 469 .val = 'l', 470 }, 471 { 472 .name = "skip", 473 .has_arg = required_argument, 474 .val = 's', 475 }, 476 { 477 .name = "help", 478 .has_arg = no_argument, 479 .val = '?', 480 }, 481 {}, 482 }; 483 484 static void usage(void) 485 { 486 fprintf(stderr, "Usage: vsock_diag_test [--help] [--control-host=<host>] --control-port=<port> --mode=client|server --peer-cid=<cid> [--list] [--skip=<test_id>]\n" 487 "\n" 488 " Server: vsock_diag_test --control-port=1234 --mode=server --peer-cid=3\n" 489 " Client: vsock_diag_test --control-host=192.168.0.1 --control-port=1234 --mode=client --peer-cid=2\n" 490 "\n" 491 "Run vsock_diag.ko tests. Must be launched in both\n" 492 "guest and host. One side must use --mode=client and\n" 493 "the other side must use --mode=server.\n" 494 "\n" 495 "A TCP control socket connection is used to coordinate tests\n" 496 "between the client and the server. The server requires a\n" 497 "listen address and the client requires an address to\n" 498 "connect to.\n" 499 "\n" 500 "The CID of the other side must be given with --peer-cid=<cid>.\n" 501 "\n" 502 "Options:\n" 503 " --help This help message\n" 504 " --control-host <host> Server IP address to connect to\n" 505 " --control-port <port> Server port to listen on/connect to\n" 506 " --mode client|server Server or client mode\n" 507 " --peer-cid <cid> CID of the other side\n" 508 " --list List of tests that will be executed\n" 509 " --skip <test_id> Test ID to skip;\n" 510 " use multiple --skip options to skip more tests\n" 511 ); 512 exit(EXIT_FAILURE); 513 } 514 515 int main(int argc, char **argv) 516 { 517 const char *control_host = NULL; 518 const char *control_port = NULL; 519 struct test_opts opts = { 520 .mode = TEST_MODE_UNSET, 521 .peer_cid = VMADDR_CID_ANY, 522 }; 523 524 init_signals(); 525 526 for (;;) { 527 int opt = getopt_long(argc, argv, optstring, longopts, NULL); 528 529 if (opt == -1) 530 break; 531 532 switch (opt) { 533 case 'H': 534 control_host = optarg; 535 break; 536 case 'm': 537 if (strcmp(optarg, "client") == 0) 538 opts.mode = TEST_MODE_CLIENT; 539 else if (strcmp(optarg, "server") == 0) 540 opts.mode = TEST_MODE_SERVER; 541 else { 542 fprintf(stderr, "--mode must be \"client\" or \"server\"\n"); 543 return EXIT_FAILURE; 544 } 545 break; 546 case 'p': 547 opts.peer_cid = parse_cid(optarg); 548 break; 549 case 'P': 550 control_port = optarg; 551 break; 552 case 'l': 553 list_tests(test_cases); 554 break; 555 case 's': 556 skip_test(test_cases, ARRAY_SIZE(test_cases) - 1, 557 optarg); 558 break; 559 case '?': 560 default: 561 usage(); 562 } 563 } 564 565 if (!control_port) 566 usage(); 567 if (opts.mode == TEST_MODE_UNSET) 568 usage(); 569 if (opts.peer_cid == VMADDR_CID_ANY) 570 usage(); 571 572 if (!control_host) { 573 if (opts.mode != TEST_MODE_SERVER) 574 usage(); 575 control_host = "0.0.0.0"; 576 } 577 578 control_init(control_host, control_port, 579 opts.mode == TEST_MODE_SERVER); 580 581 run_tests(test_cases, &opts); 582 583 control_cleanup(); 584 return EXIT_SUCCESS; 585 } 586