1 /* 2 * Copyright (c) 2014-2016 Oracle and/or its affiliates. All Rights Reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation; either version 2 of 7 * the License, or (at your option) any later version. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program. If not, see <http://www.gnu.org/licenses/>. 16 * 17 * Author: Alexey Kodanev <alexey.kodanev (at) oracle.com> 18 * 19 */ 20 21 #include <pthread.h> 22 #include <stdlib.h> 23 #include <limits.h> 24 #include <linux/dccp.h> 25 #include <sys/types.h> 26 #include <sys/socket.h> 27 #include <netdb.h> 28 #include <netinet/in.h> 29 #include <netinet/tcp.h> 30 #include <arpa/inet.h> 31 #include <poll.h> 32 #include <time.h> 33 #include <string.h> 34 #include <unistd.h> 35 #include <errno.h> 36 37 #include "lapi/udp.h" 38 #include "lapi/dccp.h" 39 #include "lapi/netinet_in.h" 40 #include "lapi/posix_clocks.h" 41 #include "lapi/socket.h" 42 #include "lapi/tcp.h" 43 #include "tst_safe_stdio.h" 44 #include "tst_safe_pthread.h" 45 #include "tst_test.h" 46 47 static const int max_msg_len = (1 << 16) - 1; 48 static const int min_msg_len = 5; 49 50 enum { 51 SERVER_HOST = 0, 52 CLIENT_HOST, 53 }; 54 static char *client_mode; 55 56 enum { 57 TFO_DISABLED = 0, 58 TFO_ENABLED, 59 }; 60 static int tfo_value = -1; 61 static char *fastopen_api, *fastopen_sapi; 62 63 static const char tfo_cfg[] = "/proc/sys/net/ipv4/tcp_fastopen"; 64 static const char tcp_tw_reuse[] = "/proc/sys/net/ipv4/tcp_tw_reuse"; 65 static int tw_reuse_changed; 66 static int tfo_cfg_value; 67 static int tfo_cfg_changed; 68 static int tfo_queue_size = 100; 69 static int max_queue_len = 100; 70 static const int client_byte = 0x43; 71 static const int server_byte = 0x53; 72 static const int start_byte = 0x24; 73 static const int start_fin_byte = 0x25; 74 static const int end_byte = 0x0a; 75 static int init_cln_msg_len = 32; 76 static int init_srv_msg_len = 128; 77 static int max_rand_msg_len; 78 79 /* 80 * The number of requests from client after 81 * which server has to close the connection. 82 */ 83 static int server_max_requests = 3; 84 static int client_max_requests = 10; 85 static int clients_num; 86 static char *tcp_port; 87 static char *server_addr = "localhost"; 88 static char *source_addr; 89 static char *server_bg; 90 static int busy_poll = -1; 91 static int max_etime_cnt = 12; /* ~30 sec max timeout if no connection */ 92 static int max_pmtu_err = 10; 93 94 enum { 95 TYPE_TCP = 0, 96 TYPE_UDP, 97 TYPE_UDP_LITE, 98 TYPE_DCCP, 99 TYPE_SCTP 100 }; 101 static uint proto_type; 102 static char *type; 103 static char *dev; 104 static int sock_type = SOCK_STREAM; 105 static int protocol; 106 static int family = AF_INET6; 107 108 static uint32_t service_code = 0xffff; 109 110 /* server socket */ 111 static int sfd; 112 113 /* how long a client must wait for the server's reply */ 114 static int wait_timeout = 60000; 115 116 /* in the end test will save time result in this file */ 117 static char *rpath = "tfo_result"; 118 static char *port_path = "netstress_port"; 119 static char *log_path = "netstress.log"; 120 121 static char *narg, *Narg, *qarg, *rarg, *Rarg, *aarg, *Targ, *barg, *targ, 122 *Aarg; 123 124 /* common structure for TCP/UDP server and TCP/UDP client */ 125 struct net_func { 126 void (*init)(void); 127 void (*run)(void); 128 void (*cleanup)(void); 129 }; 130 static struct net_func net; 131 132 #define MAX_THREADS 10000 133 static pthread_attr_t attr; 134 static pthread_t *thread_ids; 135 136 static struct addrinfo *remote_addrinfo; 137 static struct addrinfo *local_addrinfo; 138 139 struct sock_info { 140 int fd; 141 struct sockaddr_storage raddr; 142 socklen_t raddr_len; 143 int etime_cnt; 144 int pmtu_err_cnt; 145 int timeout; 146 }; 147 148 static char *zcopy; 149 static int send_flags = MSG_NOSIGNAL; 150 151 static void init_socket_opts(int sd) 152 { 153 if (busy_poll >= 0) 154 SAFE_SETSOCKOPT_INT(sd, SOL_SOCKET, SO_BUSY_POLL, busy_poll); 155 156 if (dev) 157 SAFE_SETSOCKOPT(sd, SOL_SOCKET, SO_BINDTODEVICE, dev, 158 strlen(dev) + 1); 159 160 switch (proto_type) { 161 case TYPE_TCP: 162 if (client_mode && fastopen_sapi) { 163 SAFE_SETSOCKOPT_INT(sd, IPPROTO_TCP, 164 TCP_FASTOPEN_CONNECT, 1); 165 } 166 if (client_mode && zcopy) 167 SAFE_SETSOCKOPT_INT(sd, SOL_SOCKET, SO_ZEROCOPY, 1); 168 break; 169 case TYPE_DCCP: 170 SAFE_SETSOCKOPT_INT(sd, SOL_DCCP, DCCP_SOCKOPT_SERVICE, 171 service_code); 172 break; 173 case TYPE_UDP_LITE: { 174 int cscov = init_srv_msg_len >> 1; 175 176 if (cscov < 8) 177 cscov = 8; 178 tst_res(TINFO, "UDP-Lite send cscov is %d", cscov); 179 /* set checksum for header and partially for payload */ 180 SAFE_SETSOCKOPT_INT(sd, SOL_UDPLITE, UDPLITE_SEND_CSCOV, cscov); 181 SAFE_SETSOCKOPT_INT(sd, SOL_UDPLITE, UDPLITE_RECV_CSCOV, 8); 182 } break; 183 } 184 } 185 186 static void do_cleanup(void) 187 { 188 if (net.cleanup) 189 net.cleanup(); 190 191 if (tfo_cfg_changed) { 192 tst_res(TINFO, "unset '%s' back to '%d'", 193 tfo_cfg, tfo_cfg_value); 194 SAFE_FILE_PRINTF(tfo_cfg, "%d", tfo_cfg_value); 195 } 196 197 if (tw_reuse_changed) { 198 SAFE_FILE_PRINTF(tcp_tw_reuse, "0"); 199 tst_res(TINFO, "unset '%s' back to '0'", tcp_tw_reuse); 200 } 201 } 202 TST_DECLARE_ONCE_FN(cleanup, do_cleanup) 203 204 static int sock_recv_poll(char *buf, int size, struct sock_info *i) 205 { 206 struct pollfd pfd; 207 pfd.fd = i->fd; 208 pfd.events = POLLIN; 209 int len = -1; 210 211 while (1) { 212 errno = 0; 213 int ret = poll(&pfd, 1, i->timeout); 214 if (ret == -1) { 215 if (errno == EINTR) 216 continue; 217 break; 218 } 219 220 if (ret != 1) { 221 if (!errno) 222 errno = ETIME; 223 break; 224 } 225 226 if (!(pfd.revents & POLLIN)) { 227 if (pfd.revents & POLLERR) { 228 int err = 0; 229 socklen_t err_len = sizeof(err); 230 231 getsockopt(i->fd, SOL_SOCKET, SO_ERROR, 232 &err, &err_len); 233 if (!err) 234 continue; 235 errno = err; 236 } 237 break; 238 } 239 240 errno = 0; 241 len = recvfrom(i->fd, buf, size, MSG_DONTWAIT, 242 (struct sockaddr *)&i->raddr, 243 &i->raddr_len); 244 245 if (len == -1 && errno == EINTR) 246 continue; 247 248 if (len == 0) 249 errno = ESHUTDOWN; 250 251 break; 252 } 253 254 return len; 255 } 256 257 static int client_recv(char *buf, int srv_msg_len, struct sock_info *i) 258 { 259 int len, offset = 0; 260 261 while (1) { 262 errno = 0; 263 len = sock_recv_poll(buf + offset, srv_msg_len - offset, i); 264 265 /* socket closed or msg is not valid */ 266 if (len < 1 || (offset + len) > srv_msg_len || 267 (buf[0] != start_byte && buf[0] != start_fin_byte)) { 268 /* packet too big message, resend with new pmtu */ 269 if (errno == EMSGSIZE) { 270 if (++(i->pmtu_err_cnt) < max_pmtu_err) 271 return 0; 272 tst_brk(TFAIL, "too many pmtu errors %d", 273 i->pmtu_err_cnt); 274 } else if (!errno) { 275 errno = ENOMSG; 276 } 277 break; 278 } 279 offset += len; 280 if (buf[offset - 1] != end_byte) 281 continue; 282 283 /* recv last msg, close socket */ 284 if (buf[0] == start_fin_byte) 285 break; 286 return 0; 287 } 288 289 if (errno == ETIME && sock_type != SOCK_STREAM) { 290 if (++(i->etime_cnt) > max_etime_cnt) 291 tst_brk(TFAIL, "client requests timeout %d times, last timeout %dms", 292 i->etime_cnt, i->timeout); 293 /* Increase timeout in poll up to 3.2 sec */ 294 if (i->timeout < 3000) 295 i->timeout <<= 1; 296 return 0; 297 } 298 299 SAFE_CLOSE(i->fd); 300 return (errno) ? -1 : 0; 301 } 302 303 static int bind_no_port; 304 static void bind_before_connect(int sd) 305 { 306 if (!local_addrinfo) 307 return; 308 309 if (bind_no_port) 310 SAFE_SETSOCKOPT_INT(sd, SOL_IP, IP_BIND_ADDRESS_NO_PORT, 1); 311 312 SAFE_BIND(sd, local_addrinfo->ai_addr, local_addrinfo->ai_addrlen); 313 314 if (bind_no_port && proto_type != TYPE_SCTP) { 315 int port = TST_GETSOCKPORT(sd); 316 317 if (port) 318 tst_brk(TFAIL, "port not zero after bind(): %d", port); 319 } 320 } 321 322 static int client_connect_send(const char *msg, int size) 323 { 324 int cfd = SAFE_SOCKET(family, sock_type, protocol); 325 326 init_socket_opts(cfd); 327 328 if (fastopen_api) { 329 /* Replaces connect() + send()/write() */ 330 SAFE_SENDTO(1, cfd, msg, size, send_flags | MSG_FASTOPEN, 331 remote_addrinfo->ai_addr, remote_addrinfo->ai_addrlen); 332 } else { 333 bind_before_connect(cfd); 334 /* old TCP API */ 335 SAFE_CONNECT(cfd, remote_addrinfo->ai_addr, 336 remote_addrinfo->ai_addrlen); 337 SAFE_SEND(1, cfd, msg, size, send_flags); 338 } 339 return cfd; 340 } 341 342 union net_size_field { 343 char bytes[2]; 344 uint16_t value; 345 }; 346 347 static void make_client_request(char client_msg[], int *cln_len, int *srv_len) 348 { 349 if (max_rand_msg_len) 350 *cln_len = *srv_len = min_msg_len + rand() % max_rand_msg_len; 351 352 memset(client_msg, client_byte, *cln_len); 353 client_msg[0] = start_byte; 354 355 /* set size for reply */ 356 union net_size_field net_size; 357 358 net_size.value = htons(*srv_len); 359 client_msg[1] = net_size.bytes[0]; 360 client_msg[2] = net_size.bytes[1]; 361 362 client_msg[*cln_len - 1] = end_byte; 363 } 364 365 void *client_fn(LTP_ATTRIBUTE_UNUSED void *arg) 366 { 367 int cln_len = init_cln_msg_len, 368 srv_len = init_srv_msg_len; 369 struct sock_info inf; 370 char buf[max_msg_len]; 371 char client_msg[max_msg_len]; 372 int i = 0; 373 intptr_t err = 0; 374 375 inf.raddr_len = sizeof(inf.raddr); 376 inf.etime_cnt = 0; 377 inf.timeout = wait_timeout; 378 inf.pmtu_err_cnt = 0; 379 380 make_client_request(client_msg, &cln_len, &srv_len); 381 382 /* connect & send requests */ 383 inf.fd = client_connect_send(client_msg, cln_len); 384 if (inf.fd == -1) { 385 err = errno; 386 goto out; 387 } 388 389 if (client_recv(buf, srv_len, &inf)) { 390 err = errno; 391 goto out; 392 } 393 394 for (i = 1; i < client_max_requests; ++i) { 395 if (inf.fd == -1) { 396 inf.fd = client_connect_send(client_msg, cln_len); 397 if (inf.fd == -1) { 398 err = errno; 399 goto out; 400 } 401 402 if (client_recv(buf, srv_len, &inf)) { 403 err = errno; 404 break; 405 } 406 continue; 407 } 408 409 if (max_rand_msg_len) 410 make_client_request(client_msg, &cln_len, &srv_len); 411 412 SAFE_SEND(1, inf.fd, client_msg, cln_len, send_flags); 413 414 if (client_recv(buf, srv_len, &inf)) { 415 err = errno; 416 break; 417 } 418 } 419 420 if (inf.fd != -1) 421 SAFE_CLOSE(inf.fd); 422 423 out: 424 if (i != client_max_requests) 425 tst_res(TWARN, "client exit on '%d' request", i); 426 427 return (void *) err; 428 } 429 430 static int parse_client_request(const char *msg) 431 { 432 union net_size_field net_size; 433 net_size.bytes[0] = msg[1]; 434 net_size.bytes[1] = msg[2]; 435 int size = ntohs(net_size.value); 436 if (size < 2 || size > max_msg_len) 437 return -1; 438 439 return size; 440 } 441 442 static struct timespec tv_client_start; 443 static struct timespec tv_client_end; 444 445 static void setup_addrinfo(const char *src_addr, const char *port, 446 const struct addrinfo *hints, 447 struct addrinfo **addr_info) 448 { 449 int err = getaddrinfo(src_addr, port, hints, addr_info); 450 451 if (err) 452 tst_brk(TBROK, "getaddrinfo failed, %s", gai_strerror(err)); 453 454 if (!*addr_info) 455 tst_brk(TBROK, "failed to get the address"); 456 } 457 458 static void client_init(void) 459 { 460 if (clients_num >= MAX_THREADS) { 461 tst_brk(TBROK, "Unexpected num of clients '%d'", 462 clients_num); 463 } 464 465 thread_ids = SAFE_MALLOC(sizeof(pthread_t) * clients_num); 466 467 struct addrinfo hints; 468 memset(&hints, 0, sizeof(struct addrinfo)); 469 hints.ai_family = AF_UNSPEC; 470 hints.ai_socktype = sock_type; 471 hints.ai_flags = 0; 472 hints.ai_protocol = 0; 473 474 if (source_addr) 475 setup_addrinfo(source_addr, NULL, &hints, &local_addrinfo); 476 setup_addrinfo(server_addr, tcp_port, &hints, &remote_addrinfo); 477 478 tst_res(TINFO, "Running the test over IPv%s", 479 (remote_addrinfo->ai_family == AF_INET6) ? "6" : "4"); 480 481 family = remote_addrinfo->ai_family; 482 483 clock_gettime(CLOCK_MONOTONIC_RAW, &tv_client_start); 484 int i; 485 for (i = 0; i < clients_num; ++i) 486 SAFE_PTHREAD_CREATE(&thread_ids[i], 0, client_fn, NULL); 487 } 488 489 static void client_run(void) 490 { 491 void *res = NULL; 492 long clnt_time = 0; 493 int i; 494 for (i = 0; i < clients_num; ++i) { 495 pthread_join(thread_ids[i], &res); 496 if (res) { 497 tst_brk(TBROK, "client[%d] failed: %s", 498 i, strerror((intptr_t)res)); 499 } 500 } 501 502 clock_gettime(CLOCK_MONOTONIC_RAW, &tv_client_end); 503 clnt_time = (tv_client_end.tv_sec - tv_client_start.tv_sec) * 1000 + 504 (tv_client_end.tv_nsec - tv_client_start.tv_nsec) / 1000000; 505 506 tst_res(TINFO, "total time '%ld' ms", clnt_time); 507 508 char client_msg[min_msg_len]; 509 int msg_len = min_msg_len; 510 511 max_rand_msg_len = 0; 512 make_client_request(client_msg, &msg_len, &msg_len); 513 /* ask server to terminate */ 514 client_msg[0] = start_fin_byte; 515 int cfd = client_connect_send(client_msg, msg_len); 516 if (cfd != -1) { 517 shutdown(cfd, SHUT_WR); 518 SAFE_CLOSE(cfd); 519 } 520 /* the script tcp_fastopen_run.sh will remove it */ 521 SAFE_FILE_PRINTF(rpath, "%ld", clnt_time); 522 523 tst_res(TPASS, "test completed"); 524 } 525 526 static void client_cleanup(void) 527 { 528 free(thread_ids); 529 530 if (remote_addrinfo) 531 freeaddrinfo(remote_addrinfo); 532 } 533 534 static void make_server_reply(char *send_msg, int size) 535 { 536 memset(send_msg, server_byte, size - 1); 537 send_msg[0] = start_byte; 538 send_msg[size - 1] = end_byte; 539 } 540 541 void *server_fn(void *cfd) 542 { 543 int num_requests = 0, offset = 0; 544 char send_msg[max_msg_len], end[] = { end_byte }; 545 int start_send_type = (sock_type == SOCK_DGRAM) ? 1 : 0; 546 int send_msg_len, send_type = start_send_type; 547 char recv_msg[max_msg_len]; 548 struct sock_info inf; 549 ssize_t recv_len; 550 struct iovec iov[2]; 551 struct msghdr msg; 552 553 inf.fd = (intptr_t) cfd; 554 inf.raddr_len = sizeof(inf.raddr); 555 inf.timeout = wait_timeout; 556 557 iov[0].iov_base = send_msg; 558 iov[1].iov_base = end; 559 iov[1].iov_len = 1; 560 memset(&msg, 0, sizeof(msg)); 561 msg.msg_name = &inf.raddr; 562 msg.msg_iov = iov; 563 msg.msg_iovlen = 2; 564 565 init_socket_opts(inf.fd); 566 567 while (1) { 568 recv_len = sock_recv_poll(recv_msg + offset, 569 max_msg_len - offset, &inf); 570 571 if (recv_len == 0) 572 break; 573 574 if (recv_len < 0 || (offset + recv_len) > max_msg_len || 575 (recv_msg[0] != start_byte && 576 recv_msg[0] != start_fin_byte)) { 577 tst_res(TFAIL, "recv failed, sock '%d'", inf.fd); 578 goto out; 579 } 580 581 offset += recv_len; 582 583 if (recv_msg[offset - 1] != end_byte) { 584 /* msg is not complete, continue recv */ 585 continue; 586 } 587 588 /* client asks to terminate */ 589 if (recv_msg[0] == start_fin_byte) 590 goto out; 591 592 send_msg_len = parse_client_request(recv_msg); 593 if (send_msg_len < 0) { 594 tst_res(TFAIL, "wrong msg size '%d'", 595 send_msg_len); 596 goto out; 597 } 598 make_server_reply(send_msg, send_msg_len); 599 600 offset = 0; 601 602 /* 603 * It will tell client that server is going 604 * to close this connection. 605 */ 606 if (sock_type == SOCK_STREAM && 607 ++num_requests >= server_max_requests) 608 send_msg[0] = start_fin_byte; 609 610 switch (send_type) { 611 case 0: 612 SAFE_SEND(1, inf.fd, send_msg, send_msg_len, 613 send_flags); 614 if (proto_type != TYPE_SCTP) 615 ++send_type; 616 break; 617 case 1: 618 SAFE_SENDTO(1, inf.fd, send_msg, send_msg_len, 619 send_flags, (struct sockaddr *)&inf.raddr, 620 inf.raddr_len); 621 ++send_type; 622 break; 623 default: 624 iov[0].iov_len = send_msg_len - 1; 625 msg.msg_namelen = inf.raddr_len; 626 SAFE_SENDMSG(send_msg_len, inf.fd, &msg, send_flags); 627 send_type = start_send_type; 628 break; 629 } 630 631 if (sock_type == SOCK_STREAM && 632 num_requests >= server_max_requests) { 633 /* max reqs, close socket */ 634 shutdown(inf.fd, SHUT_WR); 635 break; 636 } 637 } 638 639 SAFE_CLOSE(inf.fd); 640 return NULL; 641 642 out: 643 SAFE_CLOSE(inf.fd); 644 tst_brk(TBROK, "Server closed"); 645 return NULL; 646 } 647 648 static pthread_t server_thread_add(intptr_t client_fd) 649 { 650 pthread_t id; 651 SAFE_PTHREAD_CREATE(&id, &attr, server_fn, (void *) client_fd); 652 return id; 653 } 654 655 static void server_init(void) 656 { 657 char *src_addr = NULL; 658 struct addrinfo hints; 659 660 memset(&hints, 0, sizeof(struct addrinfo)); 661 hints.ai_family = AF_INET6; 662 hints.ai_socktype = sock_type; 663 hints.ai_flags = AI_PASSIVE; 664 665 if (!source_addr && !tcp_port) 666 tcp_port = "0"; 667 668 if (source_addr && !strchr(source_addr, ':')) 669 SAFE_ASPRINTF(&src_addr, "::ffff:%s", source_addr); 670 setup_addrinfo(src_addr ? src_addr : source_addr, tcp_port, 671 &hints, &local_addrinfo); 672 free(src_addr); 673 674 /* IPv6 socket is also able to access IPv4 protocol stack */ 675 sfd = SAFE_SOCKET(family, sock_type, protocol); 676 SAFE_SETSOCKOPT_INT(sfd, SOL_SOCKET, SO_REUSEADDR, 1); 677 678 tst_res(TINFO, "assigning a name to the server socket..."); 679 SAFE_BIND(sfd, local_addrinfo->ai_addr, local_addrinfo->ai_addrlen); 680 681 freeaddrinfo(local_addrinfo); 682 683 int port = TST_GETSOCKPORT(sfd); 684 685 tst_res(TINFO, "bind to port %d", port); 686 if (server_bg) { 687 SAFE_CHDIR(server_bg); 688 SAFE_FILE_PRINTF(port_path, "%d", port); 689 } 690 691 if (sock_type == SOCK_DGRAM) 692 return; 693 694 init_socket_opts(sfd); 695 696 if (fastopen_api || fastopen_sapi) { 697 SAFE_SETSOCKOPT_INT(sfd, IPPROTO_TCP, TCP_FASTOPEN, 698 tfo_queue_size); 699 } 700 701 if (zcopy) 702 SAFE_SETSOCKOPT_INT(sfd, SOL_SOCKET, SO_ZEROCOPY, 1); 703 704 SAFE_LISTEN(sfd, max_queue_len); 705 706 tst_res(TINFO, "Listen on the socket '%d'", sfd); 707 } 708 709 static void server_cleanup(void) 710 { 711 SAFE_CLOSE(sfd); 712 } 713 714 static void move_to_background(void) 715 { 716 if (SAFE_FORK()) 717 exit(0); 718 719 SAFE_SETSID(); 720 721 close(STDIN_FILENO); 722 SAFE_OPEN("/dev/null", O_RDONLY); 723 close(STDOUT_FILENO); 724 close(STDERR_FILENO); 725 726 int fd = SAFE_OPEN(log_path, O_CREAT | O_TRUNC | O_RDONLY, 00444); 727 728 SAFE_DUP(fd); 729 } 730 731 static void server_run_udp(void) 732 { 733 if (server_bg) 734 move_to_background(); 735 736 pthread_t p_id = server_thread_add(sfd); 737 738 SAFE_PTHREAD_JOIN(p_id, NULL); 739 } 740 741 static void server_run(void) 742 { 743 if (server_bg) 744 move_to_background(); 745 746 /* IPv4 source address will be mapped to IPv6 address */ 747 struct sockaddr_in6 addr6; 748 socklen_t addr_size = sizeof(addr6); 749 750 pthread_attr_init(&attr); 751 752 /* 753 * detaching threads allow to reclaim thread's resources 754 * once a thread finishes its work. 755 */ 756 if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0) 757 tst_brk(TBROK | TERRNO, "setdetachstate failed"); 758 759 while (1) { 760 int client_fd = accept(sfd, (struct sockaddr *)&addr6, 761 &addr_size); 762 763 if (client_fd == -1) 764 tst_brk(TBROK, "Can't create client socket"); 765 766 server_thread_add(client_fd); 767 } 768 } 769 770 static void require_root(const char *file) 771 { 772 if (!geteuid()) 773 return; 774 tst_brk(TCONF, "Test needs to be run as root to change %s", file); 775 } 776 777 static void check_tfo_value(void) 778 { 779 /* Check if we can write to tcp_fastopen knob. We might be 780 * inside netns and either have read-only permission or 781 * doesn't have the knob at all. 782 */ 783 if (access(tfo_cfg, W_OK) < 0) { 784 /* TODO check /proc/self/ns/ or TST_USE_NETNS env var */ 785 tst_res(TINFO, "can't read %s, assume server runs in netns", 786 tfo_cfg); 787 return; 788 } 789 790 SAFE_FILE_SCANF(tfo_cfg, "%d", &tfo_cfg_value); 791 tst_res(TINFO, "'%s' is %d", tfo_cfg, tfo_cfg_value); 792 793 /* The check can be the first in this function but set here 794 * to allow to print information about the currently set config 795 */ 796 if (tfo_value < 0) 797 return; 798 799 if (tfo_cfg_value == tfo_value) 800 return; 801 802 require_root(tfo_cfg); 803 804 tst_res(TINFO, "set '%s' to '%d'", tfo_cfg, tfo_value); 805 806 SAFE_FILE_PRINTF(tfo_cfg, "%d", tfo_value); 807 tfo_cfg_changed = 1; 808 } 809 810 static void check_tw_reuse(void) 811 { 812 if (access(tcp_tw_reuse, W_OK) < 0) 813 return; 814 815 int reuse_value = 0; 816 817 SAFE_FILE_SCANF(tcp_tw_reuse, "%d", &reuse_value); 818 if (reuse_value) { 819 tst_res(TINFO, "tcp_tw_reuse is already set"); 820 return; 821 } 822 823 require_root(tfo_cfg); 824 825 SAFE_FILE_PRINTF(tcp_tw_reuse, "1"); 826 tw_reuse_changed = 1; 827 tst_res(TINFO, "set '%s' to '1'", tcp_tw_reuse); 828 } 829 830 static void set_protocol_type(void) 831 { 832 if (!type || !strcmp(type, "tcp")) 833 proto_type = TYPE_TCP; 834 else if (!strcmp(type, "udp")) 835 proto_type = TYPE_UDP; 836 else if (!strcmp(type, "udp_lite")) 837 proto_type = TYPE_UDP_LITE; 838 else if (!strcmp(type, "dccp")) 839 proto_type = TYPE_DCCP; 840 else if (!strcmp(type, "sctp")) 841 proto_type = TYPE_SCTP; 842 else 843 tst_brk(TBROK, "Invalid proto_type: '%s'", type); 844 } 845 846 static void setup(void) 847 { 848 if (tst_parse_int(aarg, &clients_num, 1, INT_MAX)) 849 tst_brk(TBROK, "Invalid client number '%s'", aarg); 850 if (tst_parse_int(rarg, &client_max_requests, 1, INT_MAX)) 851 tst_brk(TBROK, "Invalid client max requests '%s'", rarg); 852 if (tst_parse_int(Rarg, &server_max_requests, 1, INT_MAX)) 853 tst_brk(TBROK, "Invalid server max requests '%s'", Rarg); 854 if (tst_parse_int(narg, &init_cln_msg_len, min_msg_len, max_msg_len)) 855 tst_brk(TBROK, "Invalid client msg size '%s'", narg); 856 if (tst_parse_int(Narg, &init_srv_msg_len, min_msg_len, max_msg_len)) 857 tst_brk(TBROK, "Invalid server msg size '%s'", Narg); 858 if (tst_parse_int(qarg, &tfo_queue_size, 1, INT_MAX)) 859 tst_brk(TBROK, "Invalid TFO queue size '%s'", qarg); 860 if (tst_parse_int(Targ, &wait_timeout, 0, INT_MAX)) 861 tst_brk(TBROK, "Invalid wait timeout '%s'", Targ); 862 if (tst_parse_int(barg, &busy_poll, 0, INT_MAX)) 863 tst_brk(TBROK, "Invalid busy poll timeout'%s'", barg); 864 if (tst_parse_int(targ, &tfo_value, 0, INT_MAX)) 865 tst_brk(TBROK, "Invalid net.ipv4.tcp_fastopen '%s'", targ); 866 if (tst_parse_int(Aarg, &max_rand_msg_len, 10, max_msg_len)) 867 tst_brk(TBROK, "Invalid max random payload size '%s'", Aarg); 868 869 if (max_rand_msg_len) { 870 max_rand_msg_len -= min_msg_len; 871 unsigned int seed = max_rand_msg_len ^ client_max_requests; 872 873 srand(seed); 874 tst_res(TINFO, "srand() seed 0x%x", seed); 875 } 876 877 /* if client_num is not set, use num of processors */ 878 if (!clients_num) 879 clients_num = sysconf(_SC_NPROCESSORS_ONLN); 880 881 if (tfo_value > 0 && tst_kvercmp(3, 7, 0) < 0) 882 tst_brk(TCONF, "Test must be run with kernel 3.7 or newer"); 883 884 if (busy_poll >= 0 && tst_kvercmp(3, 11, 0) < 0) 885 tst_brk(TCONF, "Test must be run with kernel 3.11 or newer"); 886 887 set_protocol_type(); 888 889 if (client_mode) { 890 if (source_addr && tst_kvercmp(4, 2, 0) >= 0) { 891 bind_no_port = 1; 892 tst_res(TINFO, "IP_BIND_ADDRESS_NO_PORT is used"); 893 } 894 tst_res(TINFO, "connection: addr '%s', port '%s'", 895 server_addr, tcp_port); 896 tst_res(TINFO, "client max req: %d", client_max_requests); 897 tst_res(TINFO, "clients num: %d", clients_num); 898 if (max_rand_msg_len) { 899 tst_res(TINFO, "random msg size [%d %d]", 900 min_msg_len, max_rand_msg_len); 901 } else { 902 tst_res(TINFO, "client msg size: %d", init_cln_msg_len); 903 tst_res(TINFO, "server msg size: %d", init_srv_msg_len); 904 } 905 net.init = client_init; 906 net.run = client_run; 907 net.cleanup = client_cleanup; 908 909 switch (proto_type) { 910 case TYPE_TCP: 911 check_tw_reuse(); 912 break; 913 case TYPE_DCCP: 914 case TYPE_UDP: 915 case TYPE_UDP_LITE: 916 if (max_etime_cnt >= client_max_requests) 917 max_etime_cnt = client_max_requests - 1; 918 tst_res(TINFO, "maximum allowed timeout errors %d", max_etime_cnt); 919 wait_timeout = 100; 920 } 921 } else { 922 tst_res(TINFO, "max requests '%d'", 923 server_max_requests); 924 net.init = server_init; 925 switch (proto_type) { 926 case TYPE_TCP: 927 case TYPE_DCCP: 928 case TYPE_SCTP: 929 net.run = server_run; 930 net.cleanup = server_cleanup; 931 break; 932 case TYPE_UDP: 933 case TYPE_UDP_LITE: 934 net.run = server_run_udp; 935 net.cleanup = NULL; 936 break; 937 } 938 } 939 940 switch (proto_type) { 941 case TYPE_TCP: 942 tst_res(TINFO, "TCP %s is using %s TCP API.", 943 (client_mode) ? "client" : "server", 944 (fastopen_api) ? "Fastopen" : "old"); 945 if (zcopy) 946 send_flags |= MSG_ZEROCOPY; 947 check_tfo_value(); 948 break; 949 case TYPE_UDP: 950 tst_res(TINFO, "using UDP"); 951 fastopen_api = fastopen_sapi = NULL; 952 sock_type = SOCK_DGRAM; 953 break; 954 case TYPE_UDP_LITE: 955 tst_res(TINFO, "using UDP Lite"); 956 fastopen_api = fastopen_sapi = NULL; 957 sock_type = SOCK_DGRAM; 958 protocol = IPPROTO_UDPLITE; 959 break; 960 case TYPE_DCCP: { 961 /* dccp* modules can be blacklisted, load them manually */ 962 const char * const argv[] = {"modprobe", "dccp_ipv6", NULL}; 963 964 if (tst_run_cmd(argv, NULL, NULL, 1)) 965 tst_brk(TCONF, "Failed to load dccp_ipv6 module"); 966 967 tst_res(TINFO, "DCCP %s", (client_mode) ? "client" : "server"); 968 fastopen_api = fastopen_sapi = NULL; 969 sock_type = SOCK_DCCP; 970 protocol = IPPROTO_DCCP; 971 service_code = htonl(service_code); 972 } break; 973 case TYPE_SCTP: 974 tst_res(TINFO, "SCTP %s", (client_mode) ? "client" : "server"); 975 fastopen_api = fastopen_sapi = NULL; 976 protocol = IPPROTO_SCTP; 977 break; 978 } 979 980 net.init(); 981 } 982 983 static void do_test(void) 984 { 985 net.run(); 986 } 987 988 static struct tst_option options[] = { 989 {"f", &fastopen_api, "-f Use TFO API, default is old API"}, 990 {"F", &fastopen_sapi, 991 "-F TCP_FASTOPEN_CONNECT socket option and standard API"}, 992 {"t:", &targ, "-t x Set tcp_fastopen value"}, 993 994 {"S:", &source_addr, "-S x Source address to bind"}, 995 {"g:", &tcp_port, "-g x x - server port"}, 996 {"b:", &barg, "-b x x - low latency busy poll timeout"}, 997 {"T:", &type, "-T x tcp (default), udp, udp_lite, dccp, sctp"}, 998 {"z", &zcopy, "-z enable SO_ZEROCOPY"}, 999 {"D:", &dev, "-d x bind to device x\n"}, 1000 1001 {"H:", &server_addr, "Client:\n-H x Server name or IP address"}, 1002 {"l", &client_mode, "-l Become client, default is server"}, 1003 {"a:", &aarg, "-a x Number of clients running in parallel"}, 1004 {"r:", &rarg, "-r x Number of client requests"}, 1005 {"n:", &narg, "-n x Client message size"}, 1006 {"N:", &Narg, "-N x Server message size"}, 1007 {"m:", &Targ, "-m x Receive timeout in milliseconds (not used by UDP/DCCP client)"}, 1008 {"d:", &rpath, "-d x x is a path to file where result is saved"}, 1009 {"A:", &Aarg, "-A x x max payload length (generated randomly)\n"}, 1010 1011 {"R:", &Rarg, "Server:\n-R x x requests after which conn.closed"}, 1012 {"q:", &qarg, "-q x x - TFO queue"}, 1013 {"B:", &server_bg, "-B x run in background, x - process directory"}, 1014 {NULL, NULL, NULL} 1015 }; 1016 1017 static struct tst_test test = { 1018 .test_all = do_test, 1019 .forks_child = 1, 1020 .setup = setup, 1021 .cleanup = cleanup, 1022 .options = options 1023 }; 1024
