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