11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * INET An implementation of the TCP/IP protocol suite for the LINUX 31da177e4SLinus Torvalds * operating system. INET is implemented using the BSD Socket 41da177e4SLinus Torvalds * interface as the means of communication with the user level. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Definitions for the TCP module. 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Version: @(#)tcp.h 1.0.5 05/23/93 91da177e4SLinus Torvalds * 1002c30a84SJesper Juhl * Authors: Ross Biro 111da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 141da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 151da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 161da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds #ifndef _TCP_H 191da177e4SLinus Torvalds #define _TCP_H 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds #define FASTRETRANS_DEBUG 1 221da177e4SLinus Torvalds 231da177e4SLinus Torvalds #include <linux/list.h> 241da177e4SLinus Torvalds #include <linux/tcp.h> 25187f1882SPaul Gortmaker #include <linux/bug.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/cache.h> 281da177e4SLinus Torvalds #include <linux/percpu.h> 29fb286bb2SHerbert Xu #include <linux/skbuff.h> 3097fc2f08SChris Leech #include <linux/dmaengine.h> 31cfb6eeb4SYOSHIFUJI Hideaki #include <linux/crypto.h> 32c6aefafbSGlenn Griffin #include <linux/cryptohash.h> 33435cf559SWilliam Allen Simpson #include <linux/kref.h> 34740b0f18SEric Dumazet #include <linux/ktime.h> 353f421baaSArnaldo Carvalho de Melo 363f421baaSArnaldo Carvalho de Melo #include <net/inet_connection_sock.h> 37295ff7edSArnaldo Carvalho de Melo #include <net/inet_timewait_sock.h> 3877d8bf9cSArnaldo Carvalho de Melo #include <net/inet_hashtables.h> 391da177e4SLinus Torvalds #include <net/checksum.h> 402e6599cbSArnaldo Carvalho de Melo #include <net/request_sock.h> 411da177e4SLinus Torvalds #include <net/sock.h> 421da177e4SLinus Torvalds #include <net/snmp.h> 431da177e4SLinus Torvalds #include <net/ip.h> 44c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h> 45bdf1ee5dSIlpo Järvinen #include <net/inet_ecn.h> 460c266898SSatoru SATOH #include <net/dst.h> 47c752f073SArnaldo Carvalho de Melo 481da177e4SLinus Torvalds #include <linux/seq_file.h> 49180d8cd9SGlauber Costa #include <linux/memcontrol.h> 501da177e4SLinus Torvalds 510f7ff927SArnaldo Carvalho de Melo extern struct inet_hashinfo tcp_hashinfo; 521da177e4SLinus Torvalds 53dd24c001SEric Dumazet extern struct percpu_counter tcp_orphan_count; 545c9f3023SJoe Perches void tcp_time_wait(struct sock *sk, int state, int timeo); 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds #define MAX_TCP_HEADER (128 + MAX_HEADER) 5733ad798cSAdam Langley #define MAX_TCP_OPTION_SPACE 40 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds /* 601da177e4SLinus Torvalds * Never offer a window over 32767 without using window scaling. Some 611da177e4SLinus Torvalds * poor stacks do signed 16bit maths! 621da177e4SLinus Torvalds */ 631da177e4SLinus Torvalds #define MAX_TCP_WINDOW 32767U 641da177e4SLinus Torvalds 651da177e4SLinus Torvalds /* Minimal accepted MSS. It is (60+60+8) - (20+20). */ 661da177e4SLinus Torvalds #define TCP_MIN_MSS 88U 671da177e4SLinus Torvalds 685d424d5aSJohn Heffner /* The least MTU to use for probing */ 695d424d5aSJohn Heffner #define TCP_BASE_MSS 512 705d424d5aSJohn Heffner 711da177e4SLinus Torvalds /* After receiving this amount of duplicate ACKs fast retransmit starts. */ 721da177e4SLinus Torvalds #define TCP_FASTRETRANS_THRESH 3 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* Maximal reordering. */ 751da177e4SLinus Torvalds #define TCP_MAX_REORDERING 127 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* Maximal number of ACKs sent quickly to accelerate slow-start. */ 781da177e4SLinus Torvalds #define TCP_MAX_QUICKACKS 16U 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds /* urg_data states */ 811da177e4SLinus Torvalds #define TCP_URG_VALID 0x0100 821da177e4SLinus Torvalds #define TCP_URG_NOTYET 0x0200 831da177e4SLinus Torvalds #define TCP_URG_READ 0x0400 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds #define TCP_RETR1 3 /* 861da177e4SLinus Torvalds * This is how many retries it does before it 871da177e4SLinus Torvalds * tries to figure out if the gateway is 881da177e4SLinus Torvalds * down. Minimal RFC value is 3; it corresponds 891da177e4SLinus Torvalds * to ~3sec-8min depending on RTO. 901da177e4SLinus Torvalds */ 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds #define TCP_RETR2 15 /* 931da177e4SLinus Torvalds * This should take at least 941da177e4SLinus Torvalds * 90 minutes to time out. 951da177e4SLinus Torvalds * RFC1122 says that the limit is 100 sec. 961da177e4SLinus Torvalds * 15 is ~13-30min depending on RTO. 971da177e4SLinus Torvalds */ 981da177e4SLinus Torvalds 996c9ff979SAlex Bergmann #define TCP_SYN_RETRIES 6 /* This is how many retries are done 1006c9ff979SAlex Bergmann * when active opening a connection. 1016c9ff979SAlex Bergmann * RFC1122 says the minimum retry MUST 1026c9ff979SAlex Bergmann * be at least 180secs. Nevertheless 1036c9ff979SAlex Bergmann * this value is corresponding to 1046c9ff979SAlex Bergmann * 63secs of retransmission with the 1056c9ff979SAlex Bergmann * current initial RTO. 1066c9ff979SAlex Bergmann */ 1071da177e4SLinus Torvalds 1086c9ff979SAlex Bergmann #define TCP_SYNACK_RETRIES 5 /* This is how may retries are done 1096c9ff979SAlex Bergmann * when passive opening a connection. 1106c9ff979SAlex Bergmann * This is corresponding to 31secs of 1116c9ff979SAlex Bergmann * retransmission with the current 1126c9ff979SAlex Bergmann * initial RTO. 1136c9ff979SAlex Bergmann */ 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT 1161da177e4SLinus Torvalds * state, about 60 seconds */ 1171da177e4SLinus Torvalds #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN 1181da177e4SLinus Torvalds /* BSD style FIN_WAIT2 deadlock breaker. 1191da177e4SLinus Torvalds * It used to be 3min, new value is 60sec, 1201da177e4SLinus Torvalds * to combine FIN-WAIT-2 timeout with 1211da177e4SLinus Torvalds * TIME-WAIT timer. 1221da177e4SLinus Torvalds */ 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds #define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */ 1251da177e4SLinus Torvalds #if HZ >= 100 1261da177e4SLinus Torvalds #define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */ 1271da177e4SLinus Torvalds #define TCP_ATO_MIN ((unsigned)(HZ/25)) 1281da177e4SLinus Torvalds #else 1291da177e4SLinus Torvalds #define TCP_DELACK_MIN 4U 1301da177e4SLinus Torvalds #define TCP_ATO_MIN 4U 1311da177e4SLinus Torvalds #endif 1321da177e4SLinus Torvalds #define TCP_RTO_MAX ((unsigned)(120*HZ)) 1331da177e4SLinus Torvalds #define TCP_RTO_MIN ((unsigned)(HZ/5)) 134fd4f2ceaSEric Dumazet #define TCP_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC6298 2.1 initial RTO value */ 1359ad7c049SJerry Chu #define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value, now 1369ad7c049SJerry Chu * used as a fallback RTO for the 1379ad7c049SJerry Chu * initial data transmission if no 1389ad7c049SJerry Chu * valid RTT sample has been acquired, 1399ad7c049SJerry Chu * most likely due to retrans in 3WHS. 1409ad7c049SJerry Chu */ 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes 1431da177e4SLinus Torvalds * for local resources. 1441da177e4SLinus Torvalds */ 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds #define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */ 1471da177e4SLinus Torvalds #define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ 1481da177e4SLinus Torvalds #define TCP_KEEPALIVE_INTVL (75*HZ) 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds #define MAX_TCP_KEEPIDLE 32767 1511da177e4SLinus Torvalds #define MAX_TCP_KEEPINTVL 32767 1521da177e4SLinus Torvalds #define MAX_TCP_KEEPCNT 127 1531da177e4SLinus Torvalds #define MAX_TCP_SYNCNT 127 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds #define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */ 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24) 1581da177e4SLinus Torvalds #define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated 1591da177e4SLinus Torvalds * after this time. It should be equal 1601da177e4SLinus Torvalds * (or greater than) TCP_TIMEWAIT_LEN 1611da177e4SLinus Torvalds * to provide reliability equal to one 1621da177e4SLinus Torvalds * provided by timewait state. 1631da177e4SLinus Torvalds */ 1641da177e4SLinus Torvalds #define TCP_PAWS_WINDOW 1 /* Replay window for per-host 1651da177e4SLinus Torvalds * timestamps. It must be less than 1661da177e4SLinus Torvalds * minimal timewait lifetime. 1671da177e4SLinus Torvalds */ 1681da177e4SLinus Torvalds /* 1691da177e4SLinus Torvalds * TCP option 1701da177e4SLinus Torvalds */ 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds #define TCPOPT_NOP 1 /* Padding */ 1731da177e4SLinus Torvalds #define TCPOPT_EOL 0 /* End of options */ 1741da177e4SLinus Torvalds #define TCPOPT_MSS 2 /* Segment size negotiating */ 1751da177e4SLinus Torvalds #define TCPOPT_WINDOW 3 /* Window scaling */ 1761da177e4SLinus Torvalds #define TCPOPT_SACK_PERM 4 /* SACK Permitted */ 1771da177e4SLinus Torvalds #define TCPOPT_SACK 5 /* SACK Block */ 1781da177e4SLinus Torvalds #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ 179cfb6eeb4SYOSHIFUJI Hideaki #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ 1802100c8d2SYuchung Cheng #define TCPOPT_EXP 254 /* Experimental */ 1812100c8d2SYuchung Cheng /* Magic number to be after the option value for sharing TCP 1822100c8d2SYuchung Cheng * experimental options. See draft-ietf-tcpm-experimental-options-00.txt 1832100c8d2SYuchung Cheng */ 1842100c8d2SYuchung Cheng #define TCPOPT_FASTOPEN_MAGIC 0xF989 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds /* 1871da177e4SLinus Torvalds * TCP option lengths 1881da177e4SLinus Torvalds */ 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds #define TCPOLEN_MSS 4 1911da177e4SLinus Torvalds #define TCPOLEN_WINDOW 3 1921da177e4SLinus Torvalds #define TCPOLEN_SACK_PERM 2 1931da177e4SLinus Torvalds #define TCPOLEN_TIMESTAMP 10 194cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG 18 1952100c8d2SYuchung Cheng #define TCPOLEN_EXP_FASTOPEN_BASE 4 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds /* But this is what stacks really send out. */ 1981da177e4SLinus Torvalds #define TCPOLEN_TSTAMP_ALIGNED 12 1991da177e4SLinus Torvalds #define TCPOLEN_WSCALE_ALIGNED 4 2001da177e4SLinus Torvalds #define TCPOLEN_SACKPERM_ALIGNED 4 2011da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE 2 2021da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE_ALIGNED 4 2031da177e4SLinus Torvalds #define TCPOLEN_SACK_PERBLOCK 8 204cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG_ALIGNED 20 20533ad798cSAdam Langley #define TCPOLEN_MSS_ALIGNED 4 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds /* Flags in tp->nonagle */ 2081da177e4SLinus Torvalds #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */ 2091da177e4SLinus Torvalds #define TCP_NAGLE_CORK 2 /* Socket is corked */ 210caa20d9aSStephen Hemminger #define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */ 2111da177e4SLinus Torvalds 21236e31b0aSAndreas Petlund /* TCP thin-stream limits */ 21336e31b0aSAndreas Petlund #define TCP_THIN_LINEAR_RETRIES 6 /* After 6 linear retries, do exp. backoff */ 21436e31b0aSAndreas Petlund 2157eb38527SDavid S. Miller /* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */ 216442b9635SDavid S. Miller #define TCP_INIT_CWND 10 217442b9635SDavid S. Miller 218cf60af03SYuchung Cheng /* Bit Flags for sysctl_tcp_fastopen */ 219cf60af03SYuchung Cheng #define TFO_CLIENT_ENABLE 1 22010467163SJerry Chu #define TFO_SERVER_ENABLE 2 22167da22d2SYuchung Cheng #define TFO_CLIENT_NO_COOKIE 4 /* Data in SYN w/o cookie option */ 222cf60af03SYuchung Cheng 22310467163SJerry Chu /* Accept SYN data w/o any cookie option */ 22410467163SJerry Chu #define TFO_SERVER_COOKIE_NOT_REQD 0x200 22510467163SJerry Chu 22610467163SJerry Chu /* Force enable TFO on all listeners, i.e., not requiring the 22710467163SJerry Chu * TCP_FASTOPEN socket option. SOCKOPT1/2 determine how to set max_qlen. 22810467163SJerry Chu */ 22910467163SJerry Chu #define TFO_SERVER_WO_SOCKOPT1 0x400 23010467163SJerry Chu #define TFO_SERVER_WO_SOCKOPT2 0x800 23110467163SJerry Chu 232295ff7edSArnaldo Carvalho de Melo extern struct inet_timewait_death_row tcp_death_row; 233295ff7edSArnaldo Carvalho de Melo 2341da177e4SLinus Torvalds /* sysctl variables for tcp */ 2351da177e4SLinus Torvalds extern int sysctl_tcp_timestamps; 2361da177e4SLinus Torvalds extern int sysctl_tcp_window_scaling; 2371da177e4SLinus Torvalds extern int sysctl_tcp_sack; 2381da177e4SLinus Torvalds extern int sysctl_tcp_fin_timeout; 2391da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_time; 2401da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_probes; 2411da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_intvl; 2421da177e4SLinus Torvalds extern int sysctl_tcp_syn_retries; 2431da177e4SLinus Torvalds extern int sysctl_tcp_synack_retries; 2441da177e4SLinus Torvalds extern int sysctl_tcp_retries1; 2451da177e4SLinus Torvalds extern int sysctl_tcp_retries2; 2461da177e4SLinus Torvalds extern int sysctl_tcp_orphan_retries; 2471da177e4SLinus Torvalds extern int sysctl_tcp_syncookies; 2482100c8d2SYuchung Cheng extern int sysctl_tcp_fastopen; 2491da177e4SLinus Torvalds extern int sysctl_tcp_retrans_collapse; 2501da177e4SLinus Torvalds extern int sysctl_tcp_stdurg; 2511da177e4SLinus Torvalds extern int sysctl_tcp_rfc1337; 2521da177e4SLinus Torvalds extern int sysctl_tcp_abort_on_overflow; 2531da177e4SLinus Torvalds extern int sysctl_tcp_max_orphans; 2541da177e4SLinus Torvalds extern int sysctl_tcp_fack; 2551da177e4SLinus Torvalds extern int sysctl_tcp_reordering; 2561da177e4SLinus Torvalds extern int sysctl_tcp_dsack; 257a4fe34bfSEric W. Biederman extern long sysctl_tcp_mem[3]; 2581da177e4SLinus Torvalds extern int sysctl_tcp_wmem[3]; 2591da177e4SLinus Torvalds extern int sysctl_tcp_rmem[3]; 2601da177e4SLinus Torvalds extern int sysctl_tcp_app_win; 2611da177e4SLinus Torvalds extern int sysctl_tcp_adv_win_scale; 2621da177e4SLinus Torvalds extern int sysctl_tcp_tw_reuse; 2631da177e4SLinus Torvalds extern int sysctl_tcp_frto; 2641da177e4SLinus Torvalds extern int sysctl_tcp_low_latency; 26595937825SChris Leech extern int sysctl_tcp_dma_copybreak; 2661da177e4SLinus Torvalds extern int sysctl_tcp_nometrics_save; 2671da177e4SLinus Torvalds extern int sysctl_tcp_moderate_rcvbuf; 2681da177e4SLinus Torvalds extern int sysctl_tcp_tso_win_divisor; 2695d424d5aSJohn Heffner extern int sysctl_tcp_mtu_probing; 2705d424d5aSJohn Heffner extern int sysctl_tcp_base_mss; 27115d99e02SRick Jones extern int sysctl_tcp_workaround_signed_windows; 27235089bb2SDavid S. Miller extern int sysctl_tcp_slow_start_after_idle; 27336e31b0aSAndreas Petlund extern int sysctl_tcp_thin_linear_timeouts; 2747e380175SAndreas Petlund extern int sysctl_tcp_thin_dupack; 275eed530b6SYuchung Cheng extern int sysctl_tcp_early_retrans; 27646d3ceabSEric Dumazet extern int sysctl_tcp_limit_output_bytes; 277282f23c6SEric Dumazet extern int sysctl_tcp_challenge_ack_limit; 278c9bee3b7SEric Dumazet extern unsigned int sysctl_tcp_notsent_lowat; 27995bd09ebSEric Dumazet extern int sysctl_tcp_min_tso_segs; 280f54b3111SEric Dumazet extern int sysctl_tcp_autocorking; 2811da177e4SLinus Torvalds 2828d987e5cSEric Dumazet extern atomic_long_t tcp_memory_allocated; 2831748376bSEric Dumazet extern struct percpu_counter tcp_sockets_allocated; 2841da177e4SLinus Torvalds extern int tcp_memory_pressure; 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds /* 2871da177e4SLinus Torvalds * The next routines deal with comparing 32 bit unsigned ints 2881da177e4SLinus Torvalds * and worry about wraparound (automatic with unsigned arithmetic). 2891da177e4SLinus Torvalds */ 2901da177e4SLinus Torvalds 291a2a385d6SEric Dumazet static inline bool before(__u32 seq1, __u32 seq2) 2921da177e4SLinus Torvalds { 2930d630cc0SGerrit Renker return (__s32)(seq1-seq2) < 0; 2941da177e4SLinus Torvalds } 2959a036b9cSGerrit Renker #define after(seq2, seq1) before(seq1, seq2) 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds /* is s2<=s1<=s3 ? */ 298a2a385d6SEric Dumazet static inline bool between(__u32 seq1, __u32 seq2, __u32 seq3) 2991da177e4SLinus Torvalds { 3001da177e4SLinus Torvalds return seq3 - seq2 >= seq1 - seq2; 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds 303efcdbf24SArun Sharma static inline bool tcp_out_of_memory(struct sock *sk) 304efcdbf24SArun Sharma { 305efcdbf24SArun Sharma if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF && 306efcdbf24SArun Sharma sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2)) 307efcdbf24SArun Sharma return true; 308efcdbf24SArun Sharma return false; 309efcdbf24SArun Sharma } 310efcdbf24SArun Sharma 311ad1af0feSDavid S. Miller static inline bool tcp_too_many_orphans(struct sock *sk, int shift) 312e4fd5da3SPavel Emelianov { 313ad1af0feSDavid S. Miller struct percpu_counter *ocp = sk->sk_prot->orphan_count; 314ad1af0feSDavid S. Miller int orphans = percpu_counter_read_positive(ocp); 315ad1af0feSDavid S. Miller 316ad1af0feSDavid S. Miller if (orphans << shift > sysctl_tcp_max_orphans) { 317ad1af0feSDavid S. Miller orphans = percpu_counter_sum_positive(ocp); 318ad1af0feSDavid S. Miller if (orphans << shift > sysctl_tcp_max_orphans) 319ad1af0feSDavid S. Miller return true; 320ad1af0feSDavid S. Miller } 321ad1af0feSDavid S. Miller return false; 322e4fd5da3SPavel Emelianov } 3231da177e4SLinus Torvalds 3245c9f3023SJoe Perches bool tcp_check_oom(struct sock *sk, int shift); 325efcdbf24SArun Sharma 326a0f82f64SFlorian Westphal /* syncookies: remember time of last synqueue overflow */ 327a0f82f64SFlorian Westphal static inline void tcp_synq_overflow(struct sock *sk) 328a0f82f64SFlorian Westphal { 329a0f82f64SFlorian Westphal tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies; 330a0f82f64SFlorian Westphal } 331a0f82f64SFlorian Westphal 332a0f82f64SFlorian Westphal /* syncookies: no recent synqueue overflow on this listening socket? */ 333a2a385d6SEric Dumazet static inline bool tcp_synq_no_recent_overflow(const struct sock *sk) 334a0f82f64SFlorian Westphal { 335a0f82f64SFlorian Westphal unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp; 3369ad7c049SJerry Chu return time_after(jiffies, last_overflow + TCP_TIMEOUT_FALLBACK); 337a0f82f64SFlorian Westphal } 338a0f82f64SFlorian Westphal 3391da177e4SLinus Torvalds extern struct proto tcp_prot; 3401da177e4SLinus Torvalds 34157ef42d5SPavel Emelyanov #define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field) 34257ef42d5SPavel Emelyanov #define TCP_INC_STATS_BH(net, field) SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field) 34357ef42d5SPavel Emelyanov #define TCP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->mib.tcp_statistics, field) 34457ef42d5SPavel Emelyanov #define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val) 345aa2ea058STom Herbert #define TCP_ADD_STATS(net, field, val) SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val) 3461da177e4SLinus Torvalds 3475c9f3023SJoe Perches void tcp_tasklet_init(void); 34846d3ceabSEric Dumazet 3495c9f3023SJoe Perches void tcp_v4_err(struct sk_buff *skb, u32); 3501da177e4SLinus Torvalds 3515c9f3023SJoe Perches void tcp_shutdown(struct sock *sk, int how); 3521da177e4SLinus Torvalds 3535c9f3023SJoe Perches void tcp_v4_early_demux(struct sk_buff *skb); 3545c9f3023SJoe Perches int tcp_v4_rcv(struct sk_buff *skb); 3551da177e4SLinus Torvalds 3565c9f3023SJoe Perches int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw); 3575c9f3023SJoe Perches int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 3587ba42910SChangli Gao size_t size); 3595c9f3023SJoe Perches int tcp_sendpage(struct sock *sk, struct page *page, int offset, size_t size, 3605c9f3023SJoe Perches int flags); 3615c9f3023SJoe Perches void tcp_release_cb(struct sock *sk); 3625c9f3023SJoe Perches void tcp_wfree(struct sk_buff *skb); 3635c9f3023SJoe Perches void tcp_write_timer_handler(struct sock *sk); 3645c9f3023SJoe Perches void tcp_delack_timer_handler(struct sock *sk); 3655c9f3023SJoe Perches int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg); 3665c9f3023SJoe Perches int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, 367cf533ea5SEric Dumazet const struct tcphdr *th, unsigned int len); 3685c9f3023SJoe Perches void tcp_rcv_established(struct sock *sk, struct sk_buff *skb, 369cf533ea5SEric Dumazet const struct tcphdr *th, unsigned int len); 3705c9f3023SJoe Perches void tcp_rcv_space_adjust(struct sock *sk); 3715c9f3023SJoe Perches void tcp_cleanup_rbuf(struct sock *sk, int copied); 3725c9f3023SJoe Perches int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp); 3735c9f3023SJoe Perches void tcp_twsk_destructor(struct sock *sk); 3745c9f3023SJoe Perches ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos, 37553d3176bSChangli Gao struct pipe_inode_info *pipe, size_t len, 37653d3176bSChangli Gao unsigned int flags); 3779c55e01cSJens Axboe 378463c84b9SArnaldo Carvalho de Melo static inline void tcp_dec_quickack_mode(struct sock *sk, 379463c84b9SArnaldo Carvalho de Melo const unsigned int pkts) 3801da177e4SLinus Torvalds { 381463c84b9SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 382fc6415bcSDavid S. Miller 383463c84b9SArnaldo Carvalho de Melo if (icsk->icsk_ack.quick) { 384463c84b9SArnaldo Carvalho de Melo if (pkts >= icsk->icsk_ack.quick) { 385463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick = 0; 3861da177e4SLinus Torvalds /* Leaving quickack mode we deflate ATO. */ 387463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.ato = TCP_ATO_MIN; 388fc6415bcSDavid S. Miller } else 389463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick -= pkts; 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds 393bdf1ee5dSIlpo Järvinen #define TCP_ECN_OK 1 394bdf1ee5dSIlpo Järvinen #define TCP_ECN_QUEUE_CWR 2 395bdf1ee5dSIlpo Järvinen #define TCP_ECN_DEMAND_CWR 4 3967a269ffaSEric Dumazet #define TCP_ECN_SEEN 8 397bdf1ee5dSIlpo Järvinen 398fd2c3ef7SEric Dumazet enum tcp_tw_status { 3991da177e4SLinus Torvalds TCP_TW_SUCCESS = 0, 4001da177e4SLinus Torvalds TCP_TW_RST = 1, 4011da177e4SLinus Torvalds TCP_TW_ACK = 2, 4021da177e4SLinus Torvalds TCP_TW_SYN = 3 4031da177e4SLinus Torvalds }; 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds 4065c9f3023SJoe Perches enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw, 4071da177e4SLinus Torvalds struct sk_buff *skb, 4088feaf0c0SArnaldo Carvalho de Melo const struct tcphdr *th); 4095c9f3023SJoe Perches struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, 4105c9f3023SJoe Perches struct request_sock *req, struct request_sock **prev, 4118336886fSJerry Chu bool fastopen); 4125c9f3023SJoe Perches int tcp_child_process(struct sock *parent, struct sock *child, 4131da177e4SLinus Torvalds struct sk_buff *skb); 4145c9f3023SJoe Perches void tcp_enter_loss(struct sock *sk, int how); 4155c9f3023SJoe Perches void tcp_clear_retrans(struct tcp_sock *tp); 4165c9f3023SJoe Perches void tcp_update_metrics(struct sock *sk); 4175c9f3023SJoe Perches void tcp_init_metrics(struct sock *sk); 4185c9f3023SJoe Perches void tcp_metrics_init(void); 4195c9f3023SJoe Perches bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst, 4205c9f3023SJoe Perches bool paws_check); 4215c9f3023SJoe Perches bool tcp_remember_stamp(struct sock *sk); 4225c9f3023SJoe Perches bool tcp_tw_remember_stamp(struct inet_timewait_sock *tw); 4235c9f3023SJoe Perches void tcp_fetch_timewait_stamp(struct sock *sk, struct dst_entry *dst); 4245c9f3023SJoe Perches void tcp_disable_fack(struct tcp_sock *tp); 4255c9f3023SJoe Perches void tcp_close(struct sock *sk, long timeout); 4265c9f3023SJoe Perches void tcp_init_sock(struct sock *sk); 4275c9f3023SJoe Perches unsigned int tcp_poll(struct file *file, struct socket *sock, 42853d3176bSChangli Gao struct poll_table_struct *wait); 4295c9f3023SJoe Perches int tcp_getsockopt(struct sock *sk, int level, int optname, 4303fdadf7dSDmitry Mishin char __user *optval, int __user *optlen); 4315c9f3023SJoe Perches int tcp_setsockopt(struct sock *sk, int level, int optname, 43253d3176bSChangli Gao char __user *optval, unsigned int optlen); 4335c9f3023SJoe Perches int compat_tcp_getsockopt(struct sock *sk, int level, int optname, 43453d3176bSChangli Gao char __user *optval, int __user *optlen); 4355c9f3023SJoe Perches int compat_tcp_setsockopt(struct sock *sk, int level, int optname, 436b7058842SDavid S. Miller char __user *optval, unsigned int optlen); 4375c9f3023SJoe Perches void tcp_set_keepalive(struct sock *sk, int val); 4385c9f3023SJoe Perches void tcp_syn_ack_timeout(struct sock *sk, struct request_sock *req); 4395c9f3023SJoe Perches int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 44053d3176bSChangli Gao size_t len, int nonblock, int flags, int *addr_len); 4415c9f3023SJoe Perches void tcp_parse_options(const struct sk_buff *skb, 4421a2c6181SChristoph Paasch struct tcp_options_received *opt_rx, 4432100c8d2SYuchung Cheng int estab, struct tcp_fastopen_cookie *foc); 4445c9f3023SJoe Perches const u8 *tcp_parse_md5sig_option(const struct tcphdr *th); 4457d5d5525SYOSHIFUJI Hideaki 4461da177e4SLinus Torvalds /* 4471da177e4SLinus Torvalds * TCP v4 functions exported for the inet6 API 4481da177e4SLinus Torvalds */ 4491da177e4SLinus Torvalds 4505c9f3023SJoe Perches void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb); 4515c9f3023SJoe Perches int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb); 4525c9f3023SJoe Perches struct sock *tcp_create_openreq_child(struct sock *sk, 45360236fddSArnaldo Carvalho de Melo struct request_sock *req, 4541da177e4SLinus Torvalds struct sk_buff *skb); 4555c9f3023SJoe Perches struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, 45660236fddSArnaldo Carvalho de Melo struct request_sock *req, 4571da177e4SLinus Torvalds struct dst_entry *dst); 4585c9f3023SJoe Perches int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb); 4595c9f3023SJoe Perches int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len); 4605c9f3023SJoe Perches int tcp_connect(struct sock *sk); 4615c9f3023SJoe Perches struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst, 462e6b4d113SWilliam Allen Simpson struct request_sock *req, 4638336886fSJerry Chu struct tcp_fastopen_cookie *foc); 4645c9f3023SJoe Perches int tcp_disconnect(struct sock *sk, int flags); 4651da177e4SLinus Torvalds 466370816aeSPavel Emelyanov void tcp_finish_connect(struct sock *sk, struct sk_buff *skb); 467292e8d8cSPavel Emelyanov int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size); 46863d02d15SEric Dumazet void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb); 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /* From syncookies.c */ 4715c9f3023SJoe Perches int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th, 4720198230bSPatrick McHardy u32 cookie); 4735c9f3023SJoe Perches struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, 4741da177e4SLinus Torvalds struct ip_options *opt); 475e05c82d3SEric Dumazet #ifdef CONFIG_SYN_COOKIES 4768c27bd75SFlorian Westphal 47763262315SEric Dumazet /* Syncookies use a monotonic timer which increments every 60 seconds. 4788c27bd75SFlorian Westphal * This counter is used both as a hash input and partially encoded into 4798c27bd75SFlorian Westphal * the cookie value. A cookie is only validated further if the delta 4808c27bd75SFlorian Westphal * between the current counter value and the encoded one is less than this, 48163262315SEric Dumazet * i.e. a sent cookie is valid only at most for 2*60 seconds (or less if 4828c27bd75SFlorian Westphal * the counter advances immediately after a cookie is generated). 4838c27bd75SFlorian Westphal */ 4848c27bd75SFlorian Westphal #define MAX_SYNCOOKIE_AGE 2 4858c27bd75SFlorian Westphal 4868c27bd75SFlorian Westphal static inline u32 tcp_cookie_time(void) 4878c27bd75SFlorian Westphal { 48863262315SEric Dumazet u64 val = get_jiffies_64(); 48963262315SEric Dumazet 49063262315SEric Dumazet do_div(val, 60 * HZ); 49163262315SEric Dumazet return val; 4928c27bd75SFlorian Westphal } 4938c27bd75SFlorian Westphal 4945c9f3023SJoe Perches u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr *th, 4955c9f3023SJoe Perches u16 *mssp); 4965c9f3023SJoe Perches __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mss); 497e05c82d3SEric Dumazet #else 498e05c82d3SEric Dumazet static inline __u32 cookie_v4_init_sequence(struct sock *sk, 499e05c82d3SEric Dumazet struct sk_buff *skb, 500e05c82d3SEric Dumazet __u16 *mss) 501e05c82d3SEric Dumazet { 502e05c82d3SEric Dumazet return 0; 503e05c82d3SEric Dumazet } 504e05c82d3SEric Dumazet #endif 5051da177e4SLinus Torvalds 5065c9f3023SJoe Perches __u32 cookie_init_timestamp(struct request_sock *req); 5075c9f3023SJoe Perches bool cookie_check_timestamp(struct tcp_options_received *opt, struct net *net, 5085c9f3023SJoe Perches bool *ecn_ok); 5094dfc2817SFlorian Westphal 510c6aefafbSGlenn Griffin /* From net/ipv6/syncookies.c */ 5115c9f3023SJoe Perches int __cookie_v6_check(const struct ipv6hdr *iph, const struct tcphdr *th, 51281eb6a14SPatrick McHardy u32 cookie); 5135c9f3023SJoe Perches struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb); 514e05c82d3SEric Dumazet #ifdef CONFIG_SYN_COOKIES 5155c9f3023SJoe Perches u32 __cookie_v6_init_sequence(const struct ipv6hdr *iph, 51681eb6a14SPatrick McHardy const struct tcphdr *th, u16 *mssp); 5175c9f3023SJoe Perches __u32 cookie_v6_init_sequence(struct sock *sk, const struct sk_buff *skb, 518c6aefafbSGlenn Griffin __u16 *mss); 519e05c82d3SEric Dumazet #else 520e05c82d3SEric Dumazet static inline __u32 cookie_v6_init_sequence(struct sock *sk, 521e05c82d3SEric Dumazet struct sk_buff *skb, 522e05c82d3SEric Dumazet __u16 *mss) 523e05c82d3SEric Dumazet { 524e05c82d3SEric Dumazet return 0; 525e05c82d3SEric Dumazet } 526e05c82d3SEric Dumazet #endif 5271da177e4SLinus Torvalds /* tcp_output.c */ 5281da177e4SLinus Torvalds 5295c9f3023SJoe Perches void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, 5309e412ba7SIlpo Järvinen int nonagle); 5315c9f3023SJoe Perches bool tcp_may_send_now(struct sock *sk); 5325c9f3023SJoe Perches int __tcp_retransmit_skb(struct sock *, struct sk_buff *); 5335c9f3023SJoe Perches int tcp_retransmit_skb(struct sock *, struct sk_buff *); 5345c9f3023SJoe Perches void tcp_retransmit_timer(struct sock *sk); 5355c9f3023SJoe Perches void tcp_xmit_retransmit_queue(struct sock *); 5365c9f3023SJoe Perches void tcp_simple_retransmit(struct sock *); 5375c9f3023SJoe Perches int tcp_trim_head(struct sock *, struct sk_buff *, u32); 5386cc55e09SOctavian Purdila int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int, gfp_t); 5391da177e4SLinus Torvalds 5405c9f3023SJoe Perches void tcp_send_probe0(struct sock *); 5415c9f3023SJoe Perches void tcp_send_partial(struct sock *); 5425c9f3023SJoe Perches int tcp_write_wakeup(struct sock *); 5435c9f3023SJoe Perches void tcp_send_fin(struct sock *sk); 5445c9f3023SJoe Perches void tcp_send_active_reset(struct sock *sk, gfp_t priority); 5455c9f3023SJoe Perches int tcp_send_synack(struct sock *); 5465c9f3023SJoe Perches bool tcp_syn_flood_action(struct sock *sk, const struct sk_buff *skb, 547946cedccSEric Dumazet const char *proto); 5485c9f3023SJoe Perches void tcp_push_one(struct sock *, unsigned int mss_now); 5495c9f3023SJoe Perches void tcp_send_ack(struct sock *sk); 5505c9f3023SJoe Perches void tcp_send_delayed_ack(struct sock *sk); 5515c9f3023SJoe Perches void tcp_send_loss_probe(struct sock *sk); 5525c9f3023SJoe Perches bool tcp_schedule_loss_probe(struct sock *sk); 5531da177e4SLinus Torvalds 554a762a980SDavid S. Miller /* tcp_input.c */ 5555c9f3023SJoe Perches void tcp_resume_early_retransmit(struct sock *sk); 5565c9f3023SJoe Perches void tcp_rearm_rto(struct sock *sk); 5575c9f3023SJoe Perches void tcp_reset(struct sock *sk); 558a762a980SDavid S. Miller 5591da177e4SLinus Torvalds /* tcp_timer.c */ 5605c9f3023SJoe Perches void tcp_init_xmit_timers(struct sock *); 561463c84b9SArnaldo Carvalho de Melo static inline void tcp_clear_xmit_timers(struct sock *sk) 562463c84b9SArnaldo Carvalho de Melo { 563463c84b9SArnaldo Carvalho de Melo inet_csk_clear_xmit_timers(sk); 564463c84b9SArnaldo Carvalho de Melo } 5651da177e4SLinus Torvalds 5665c9f3023SJoe Perches unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu); 5675c9f3023SJoe Perches unsigned int tcp_current_mss(struct sock *sk); 5680c54b85fSIlpo Järvinen 5690c54b85fSIlpo Järvinen /* Bound MSS / TSO packet size with the half of the window */ 5700c54b85fSIlpo Järvinen static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize) 5710c54b85fSIlpo Järvinen { 57201f83d69SAlexey Kuznetsov int cutoff; 57301f83d69SAlexey Kuznetsov 57401f83d69SAlexey Kuznetsov /* When peer uses tiny windows, there is no use in packetizing 57501f83d69SAlexey Kuznetsov * to sub-MSS pieces for the sake of SWS or making sure there 57601f83d69SAlexey Kuznetsov * are enough packets in the pipe for fast recovery. 57701f83d69SAlexey Kuznetsov * 57801f83d69SAlexey Kuznetsov * On the other hand, for extremely large MSS devices, handling 57901f83d69SAlexey Kuznetsov * smaller than MSS windows in this way does make sense. 58001f83d69SAlexey Kuznetsov */ 58101f83d69SAlexey Kuznetsov if (tp->max_window >= 512) 58201f83d69SAlexey Kuznetsov cutoff = (tp->max_window >> 1); 58301f83d69SAlexey Kuznetsov else 58401f83d69SAlexey Kuznetsov cutoff = tp->max_window; 58501f83d69SAlexey Kuznetsov 58601f83d69SAlexey Kuznetsov if (cutoff && pktsize > cutoff) 58701f83d69SAlexey Kuznetsov return max_t(int, cutoff, 68U - tp->tcp_header_len); 5880c54b85fSIlpo Järvinen else 5890c54b85fSIlpo Järvinen return pktsize; 5900c54b85fSIlpo Järvinen } 5911da177e4SLinus Torvalds 59217b085eaSArnaldo Carvalho de Melo /* tcp.c */ 5935c9f3023SJoe Perches void tcp_get_info(const struct sock *, struct tcp_info *); 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds /* Read 'sendfile()'-style from a TCP socket */ 5961da177e4SLinus Torvalds typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, 5971da177e4SLinus Torvalds unsigned int, size_t); 5985c9f3023SJoe Perches int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, 5991da177e4SLinus Torvalds sk_read_actor_t recv_actor); 6001da177e4SLinus Torvalds 6015c9f3023SJoe Perches void tcp_initialize_rcv_mss(struct sock *sk); 6021da177e4SLinus Torvalds 6035c9f3023SJoe Perches int tcp_mtu_to_mss(struct sock *sk, int pmtu); 6045c9f3023SJoe Perches int tcp_mss_to_mtu(struct sock *sk, int mss); 6055c9f3023SJoe Perches void tcp_mtup_init(struct sock *sk); 6065c9f3023SJoe Perches void tcp_init_buffer_space(struct sock *sk); 6075d424d5aSJohn Heffner 608f1ecd5d9SDamian Lukowski static inline void tcp_bound_rto(const struct sock *sk) 609f1ecd5d9SDamian Lukowski { 610f1ecd5d9SDamian Lukowski if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX) 611f1ecd5d9SDamian Lukowski inet_csk(sk)->icsk_rto = TCP_RTO_MAX; 612f1ecd5d9SDamian Lukowski } 613f1ecd5d9SDamian Lukowski 614f1ecd5d9SDamian Lukowski static inline u32 __tcp_set_rto(const struct tcp_sock *tp) 615f1ecd5d9SDamian Lukowski { 616740b0f18SEric Dumazet return usecs_to_jiffies((tp->srtt_us >> 3) + tp->rttvar_us); 617f1ecd5d9SDamian Lukowski } 618f1ecd5d9SDamian Lukowski 61940efc6faSStephen Hemminger static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) 6201da177e4SLinus Torvalds { 6211da177e4SLinus Torvalds tp->pred_flags = htonl((tp->tcp_header_len << 26) | 6221da177e4SLinus Torvalds ntohl(TCP_FLAG_ACK) | 6231da177e4SLinus Torvalds snd_wnd); 6241da177e4SLinus Torvalds } 6251da177e4SLinus Torvalds 62640efc6faSStephen Hemminger static inline void tcp_fast_path_on(struct tcp_sock *tp) 6271da177e4SLinus Torvalds { 6281da177e4SLinus Torvalds __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale); 6291da177e4SLinus Torvalds } 6301da177e4SLinus Torvalds 6319e412ba7SIlpo Järvinen static inline void tcp_fast_path_check(struct sock *sk) 6321da177e4SLinus Torvalds { 6339e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 6349e412ba7SIlpo Järvinen 635b03efcfbSDavid S. Miller if (skb_queue_empty(&tp->out_of_order_queue) && 6361da177e4SLinus Torvalds tp->rcv_wnd && 6371da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf && 6381da177e4SLinus Torvalds !tp->urg_data) 6391da177e4SLinus Torvalds tcp_fast_path_on(tp); 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds 6420c266898SSatoru SATOH /* Compute the actual rto_min value */ 6430c266898SSatoru SATOH static inline u32 tcp_rto_min(struct sock *sk) 6440c266898SSatoru SATOH { 645cf533ea5SEric Dumazet const struct dst_entry *dst = __sk_dst_get(sk); 6460c266898SSatoru SATOH u32 rto_min = TCP_RTO_MIN; 6470c266898SSatoru SATOH 6480c266898SSatoru SATOH if (dst && dst_metric_locked(dst, RTAX_RTO_MIN)) 6490c266898SSatoru SATOH rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN); 6500c266898SSatoru SATOH return rto_min; 6510c266898SSatoru SATOH } 6520c266898SSatoru SATOH 653740b0f18SEric Dumazet static inline u32 tcp_rto_min_us(struct sock *sk) 654740b0f18SEric Dumazet { 655740b0f18SEric Dumazet return jiffies_to_usecs(tcp_rto_min(sk)); 656740b0f18SEric Dumazet } 657740b0f18SEric Dumazet 6581da177e4SLinus Torvalds /* Compute the actual receive window we are currently advertising. 6591da177e4SLinus Torvalds * Rcv_nxt can be after the window if our peer push more data 6601da177e4SLinus Torvalds * than the offered window. 6611da177e4SLinus Torvalds */ 66240efc6faSStephen Hemminger static inline u32 tcp_receive_window(const struct tcp_sock *tp) 6631da177e4SLinus Torvalds { 6641da177e4SLinus Torvalds s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds if (win < 0) 6671da177e4SLinus Torvalds win = 0; 6681da177e4SLinus Torvalds return (u32) win; 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds /* Choose a new window, without checks for shrinking, and without 6721da177e4SLinus Torvalds * scaling applied to the result. The caller does these things 6731da177e4SLinus Torvalds * if necessary. This is a "raw" window selection. 6741da177e4SLinus Torvalds */ 6755c9f3023SJoe Perches u32 __tcp_select_window(struct sock *sk); 6761da177e4SLinus Torvalds 677ee995283SPavel Emelyanov void tcp_send_window_probe(struct sock *sk); 678ee995283SPavel Emelyanov 6791da177e4SLinus Torvalds /* TCP timestamps are only 32-bits, this causes a slight 6801da177e4SLinus Torvalds * complication on 64-bit systems since we store a snapshot 68131f34269SStephen Hemminger * of jiffies in the buffer control blocks below. We decided 68231f34269SStephen Hemminger * to use only the low 32-bits of jiffies and hide the ugly 6831da177e4SLinus Torvalds * casts with the following macro. 6841da177e4SLinus Torvalds */ 6851da177e4SLinus Torvalds #define tcp_time_stamp ((__u32)(jiffies)) 6861da177e4SLinus Torvalds 687a3433f35SChangli Gao #define tcp_flag_byte(th) (((u_int8_t *)th)[13]) 688a3433f35SChangli Gao 689a3433f35SChangli Gao #define TCPHDR_FIN 0x01 690a3433f35SChangli Gao #define TCPHDR_SYN 0x02 691a3433f35SChangli Gao #define TCPHDR_RST 0x04 692a3433f35SChangli Gao #define TCPHDR_PSH 0x08 693a3433f35SChangli Gao #define TCPHDR_ACK 0x10 694a3433f35SChangli Gao #define TCPHDR_URG 0x20 695a3433f35SChangli Gao #define TCPHDR_ECE 0x40 696a3433f35SChangli Gao #define TCPHDR_CWR 0x80 697a3433f35SChangli Gao 698caa20d9aSStephen Hemminger /* This is what the send packet queuing engine uses to pass 699f86586faSEric Dumazet * TCP per-packet control information to the transmission code. 700f86586faSEric Dumazet * We also store the host-order sequence numbers in here too. 701f86586faSEric Dumazet * This is 44 bytes if IPV6 is enabled. 702f86586faSEric Dumazet * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately. 7031da177e4SLinus Torvalds */ 7041da177e4SLinus Torvalds struct tcp_skb_cb { 7051da177e4SLinus Torvalds union { 7061da177e4SLinus Torvalds struct inet_skb_parm h4; 707dfd56b8bSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 7081da177e4SLinus Torvalds struct inet6_skb_parm h6; 7091da177e4SLinus Torvalds #endif 7101da177e4SLinus Torvalds } header; /* For incoming frames */ 7111da177e4SLinus Torvalds __u32 seq; /* Starting sequence number */ 7121da177e4SLinus Torvalds __u32 end_seq; /* SEQ + FIN + SYN + datalen */ 7131da177e4SLinus Torvalds __u32 when; /* used to compute rtt's */ 7144de075e0SEric Dumazet __u8 tcp_flags; /* TCP header flags. (tcp[13]) */ 715f4f9f6e7SNeal Cardwell 7161da177e4SLinus Torvalds __u8 sacked; /* State flags for SACK/FACK. */ 7171da177e4SLinus Torvalds #define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ 7181da177e4SLinus Torvalds #define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ 7191da177e4SLinus Torvalds #define TCPCB_LOST 0x04 /* SKB is lost */ 7201da177e4SLinus Torvalds #define TCPCB_TAGBITS 0x07 /* All tag bits */ 7211da177e4SLinus Torvalds #define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */ 7221da177e4SLinus Torvalds #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS) 7231da177e4SLinus Torvalds 724f4f9f6e7SNeal Cardwell __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */ 725f4f9f6e7SNeal Cardwell /* 1 byte hole */ 7261da177e4SLinus Torvalds __u32 ack_seq; /* Sequence number ACK'd */ 7271da177e4SLinus Torvalds }; 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0])) 7301da177e4SLinus Torvalds 731bd14b1b2SEric Dumazet /* RFC3168 : 6.1.1 SYN packets must not have ECT/ECN bits set 732bd14b1b2SEric Dumazet * 733bd14b1b2SEric Dumazet * If we receive a SYN packet with these bits set, it means a network is 734bd14b1b2SEric Dumazet * playing bad games with TOS bits. In order to avoid possible false congestion 735bd14b1b2SEric Dumazet * notifications, we disable TCP ECN negociation. 736bd14b1b2SEric Dumazet */ 737bd14b1b2SEric Dumazet static inline void 7385d134f1cSHannes Frederic Sowa TCP_ECN_create_request(struct request_sock *req, const struct sk_buff *skb, 7395d134f1cSHannes Frederic Sowa struct net *net) 740bd14b1b2SEric Dumazet { 741bd14b1b2SEric Dumazet const struct tcphdr *th = tcp_hdr(skb); 742bd14b1b2SEric Dumazet 7435d134f1cSHannes Frederic Sowa if (net->ipv4.sysctl_tcp_ecn && th->ece && th->cwr && 744bd14b1b2SEric Dumazet INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield)) 745bd14b1b2SEric Dumazet inet_rsk(req)->ecn_ok = 1; 746bd14b1b2SEric Dumazet } 747bd14b1b2SEric Dumazet 7481da177e4SLinus Torvalds /* Due to TSO, an SKB can be composed of multiple actual 7491da177e4SLinus Torvalds * packets. To keep these tracked properly, we use this. 7501da177e4SLinus Torvalds */ 7511da177e4SLinus Torvalds static inline int tcp_skb_pcount(const struct sk_buff *skb) 7521da177e4SLinus Torvalds { 7537967168cSHerbert Xu return skb_shinfo(skb)->gso_segs; 7541da177e4SLinus Torvalds } 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds /* This is valid iff tcp_skb_pcount() > 1. */ 7571da177e4SLinus Torvalds static inline int tcp_skb_mss(const struct sk_buff *skb) 7581da177e4SLinus Torvalds { 7597967168cSHerbert Xu return skb_shinfo(skb)->gso_size; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 762317a76f9SStephen Hemminger /* Events passed to congestion control interface */ 763317a76f9SStephen Hemminger enum tcp_ca_event { 764317a76f9SStephen Hemminger CA_EVENT_TX_START, /* first transmit when no packets in flight */ 765317a76f9SStephen Hemminger CA_EVENT_CWND_RESTART, /* congestion window restart */ 766317a76f9SStephen Hemminger CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */ 767317a76f9SStephen Hemminger CA_EVENT_LOSS, /* loss timeout */ 768317a76f9SStephen Hemminger CA_EVENT_FAST_ACK, /* in sequence ack */ 769317a76f9SStephen Hemminger CA_EVENT_SLOW_ACK, /* other ack */ 770317a76f9SStephen Hemminger }; 771317a76f9SStephen Hemminger 772317a76f9SStephen Hemminger /* 773317a76f9SStephen Hemminger * Interface for adding new TCP congestion control handlers 774317a76f9SStephen Hemminger */ 775317a76f9SStephen Hemminger #define TCP_CA_NAME_MAX 16 7763ff825b2SStephen Hemminger #define TCP_CA_MAX 128 7773ff825b2SStephen Hemminger #define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX) 7783ff825b2SStephen Hemminger 779164891aaSStephen Hemminger #define TCP_CONG_NON_RESTRICTED 0x1 780164891aaSStephen Hemminger 781317a76f9SStephen Hemminger struct tcp_congestion_ops { 782317a76f9SStephen Hemminger struct list_head list; 783164891aaSStephen Hemminger unsigned long flags; 784317a76f9SStephen Hemminger 785317a76f9SStephen Hemminger /* initialize private data (optional) */ 7866687e988SArnaldo Carvalho de Melo void (*init)(struct sock *sk); 787317a76f9SStephen Hemminger /* cleanup private data (optional) */ 7886687e988SArnaldo Carvalho de Melo void (*release)(struct sock *sk); 789317a76f9SStephen Hemminger 790317a76f9SStephen Hemminger /* return slow start threshold (required) */ 7916687e988SArnaldo Carvalho de Melo u32 (*ssthresh)(struct sock *sk); 792317a76f9SStephen Hemminger /* do new cwnd calculation (required) */ 79324901551SEric Dumazet void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked); 794317a76f9SStephen Hemminger /* call before changing ca_state (optional) */ 7956687e988SArnaldo Carvalho de Melo void (*set_state)(struct sock *sk, u8 new_state); 796317a76f9SStephen Hemminger /* call when cwnd event occurs (optional) */ 7976687e988SArnaldo Carvalho de Melo void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev); 798317a76f9SStephen Hemminger /* new value of cwnd after loss (optional) */ 7996687e988SArnaldo Carvalho de Melo u32 (*undo_cwnd)(struct sock *sk); 800317a76f9SStephen Hemminger /* hook for packet ack accounting (optional) */ 80130cfd0baSStephen Hemminger void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us); 80273c1f4a0SArnaldo Carvalho de Melo /* get info for inet_diag (optional) */ 8036687e988SArnaldo Carvalho de Melo void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb); 804317a76f9SStephen Hemminger 805317a76f9SStephen Hemminger char name[TCP_CA_NAME_MAX]; 806317a76f9SStephen Hemminger struct module *owner; 807317a76f9SStephen Hemminger }; 808317a76f9SStephen Hemminger 8095c9f3023SJoe Perches int tcp_register_congestion_control(struct tcp_congestion_ops *type); 8105c9f3023SJoe Perches void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); 811317a76f9SStephen Hemminger 8125c9f3023SJoe Perches void tcp_init_congestion_control(struct sock *sk); 8135c9f3023SJoe Perches void tcp_cleanup_congestion_control(struct sock *sk); 8145c9f3023SJoe Perches int tcp_set_default_congestion_control(const char *name); 8155c9f3023SJoe Perches void tcp_get_default_congestion_control(char *name); 8165c9f3023SJoe Perches void tcp_get_available_congestion_control(char *buf, size_t len); 8175c9f3023SJoe Perches void tcp_get_allowed_congestion_control(char *buf, size_t len); 8185c9f3023SJoe Perches int tcp_set_allowed_congestion_control(char *allowed); 8195c9f3023SJoe Perches int tcp_set_congestion_control(struct sock *sk, const char *name); 8209f9843a7SYuchung Cheng int tcp_slow_start(struct tcp_sock *tp, u32 acked); 8215c9f3023SJoe Perches void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w); 822317a76f9SStephen Hemminger 8235f8ef48dSStephen Hemminger extern struct tcp_congestion_ops tcp_init_congestion_ops; 8245c9f3023SJoe Perches u32 tcp_reno_ssthresh(struct sock *sk); 82524901551SEric Dumazet void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked); 826a8acfbacSDavid S. Miller extern struct tcp_congestion_ops tcp_reno; 827317a76f9SStephen Hemminger 8286687e988SArnaldo Carvalho de Melo static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state) 829317a76f9SStephen Hemminger { 8306687e988SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 8316687e988SArnaldo Carvalho de Melo 8326687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->set_state) 8336687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->set_state(sk, ca_state); 8346687e988SArnaldo Carvalho de Melo icsk->icsk_ca_state = ca_state; 835317a76f9SStephen Hemminger } 836317a76f9SStephen Hemminger 8376687e988SArnaldo Carvalho de Melo static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) 838317a76f9SStephen Hemminger { 8396687e988SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 8406687e988SArnaldo Carvalho de Melo 8416687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->cwnd_event) 8426687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->cwnd_event(sk, event); 843317a76f9SStephen Hemminger } 844317a76f9SStephen Hemminger 845e60402d0SIlpo Järvinen /* These functions determine how the current flow behaves in respect of SACK 846e60402d0SIlpo Järvinen * handling. SACK is negotiated with the peer, and therefore it can vary 847e60402d0SIlpo Järvinen * between different flows. 848e60402d0SIlpo Järvinen * 849e60402d0SIlpo Järvinen * tcp_is_sack - SACK enabled 850e60402d0SIlpo Järvinen * tcp_is_reno - No SACK 851e60402d0SIlpo Järvinen * tcp_is_fack - FACK enabled, implies SACK enabled 852e60402d0SIlpo Järvinen */ 853e60402d0SIlpo Järvinen static inline int tcp_is_sack(const struct tcp_sock *tp) 854e60402d0SIlpo Järvinen { 855e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok; 856e60402d0SIlpo Järvinen } 857e60402d0SIlpo Järvinen 858a2a385d6SEric Dumazet static inline bool tcp_is_reno(const struct tcp_sock *tp) 859e60402d0SIlpo Järvinen { 860e60402d0SIlpo Järvinen return !tcp_is_sack(tp); 861e60402d0SIlpo Järvinen } 862e60402d0SIlpo Järvinen 863a2a385d6SEric Dumazet static inline bool tcp_is_fack(const struct tcp_sock *tp) 864e60402d0SIlpo Järvinen { 865ab56222aSVijay Subramanian return tp->rx_opt.sack_ok & TCP_FACK_ENABLED; 866e60402d0SIlpo Järvinen } 867e60402d0SIlpo Järvinen 868e60402d0SIlpo Järvinen static inline void tcp_enable_fack(struct tcp_sock *tp) 869e60402d0SIlpo Järvinen { 870ab56222aSVijay Subramanian tp->rx_opt.sack_ok |= TCP_FACK_ENABLED; 871e60402d0SIlpo Järvinen } 872e60402d0SIlpo Järvinen 873eed530b6SYuchung Cheng /* TCP early-retransmit (ER) is similar to but more conservative than 874eed530b6SYuchung Cheng * the thin-dupack feature. Enable ER only if thin-dupack is disabled. 875eed530b6SYuchung Cheng */ 876eed530b6SYuchung Cheng static inline void tcp_enable_early_retrans(struct tcp_sock *tp) 877eed530b6SYuchung Cheng { 878eed530b6SYuchung Cheng tp->do_early_retrans = sysctl_tcp_early_retrans && 8796ba8a3b1SNandita Dukkipati sysctl_tcp_early_retrans < 4 && !sysctl_tcp_thin_dupack && 8806ba8a3b1SNandita Dukkipati sysctl_tcp_reordering == 3; 881eed530b6SYuchung Cheng } 882eed530b6SYuchung Cheng 883eed530b6SYuchung Cheng static inline void tcp_disable_early_retrans(struct tcp_sock *tp) 884eed530b6SYuchung Cheng { 885eed530b6SYuchung Cheng tp->do_early_retrans = 0; 886eed530b6SYuchung Cheng } 887eed530b6SYuchung Cheng 88883ae4088SIlpo Järvinen static inline unsigned int tcp_left_out(const struct tcp_sock *tp) 88983ae4088SIlpo Järvinen { 89083ae4088SIlpo Järvinen return tp->sacked_out + tp->lost_out; 89183ae4088SIlpo Järvinen } 89283ae4088SIlpo Järvinen 8931da177e4SLinus Torvalds /* This determines how many packets are "in the network" to the best 8941da177e4SLinus Torvalds * of our knowledge. In many cases it is conservative, but where 8951da177e4SLinus Torvalds * detailed information is available from the receiver (via SACK 8961da177e4SLinus Torvalds * blocks etc.) we can make more aggressive calculations. 8971da177e4SLinus Torvalds * 8981da177e4SLinus Torvalds * Use this for decisions involving congestion control, use just 8991da177e4SLinus Torvalds * tp->packets_out to determine if the send queue is empty or not. 9001da177e4SLinus Torvalds * 9011da177e4SLinus Torvalds * Read this equation as: 9021da177e4SLinus Torvalds * 9031da177e4SLinus Torvalds * "Packets sent once on transmission queue" MINUS 9041da177e4SLinus Torvalds * "Packets left network, but not honestly ACKed yet" PLUS 9051da177e4SLinus Torvalds * "Packets fast retransmitted" 9061da177e4SLinus Torvalds */ 90740efc6faSStephen Hemminger static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) 9081da177e4SLinus Torvalds { 90983ae4088SIlpo Järvinen return tp->packets_out - tcp_left_out(tp) + tp->retrans_out; 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds 9120b6a05c1SIlpo Järvinen #define TCP_INFINITE_SSTHRESH 0x7fffffff 9130b6a05c1SIlpo Järvinen 9140b6a05c1SIlpo Järvinen static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp) 9150b6a05c1SIlpo Järvinen { 9160b6a05c1SIlpo Järvinen return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH; 9170b6a05c1SIlpo Järvinen } 9180b6a05c1SIlpo Järvinen 919684bad11SYuchung Cheng static inline bool tcp_in_cwnd_reduction(const struct sock *sk) 920684bad11SYuchung Cheng { 921684bad11SYuchung Cheng return (TCPF_CA_CWR | TCPF_CA_Recovery) & 922684bad11SYuchung Cheng (1 << inet_csk(sk)->icsk_ca_state); 923684bad11SYuchung Cheng } 924684bad11SYuchung Cheng 9251da177e4SLinus Torvalds /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd. 926684bad11SYuchung Cheng * The exception is cwnd reduction phase, when cwnd is decreasing towards 9271da177e4SLinus Torvalds * ssthresh. 9281da177e4SLinus Torvalds */ 9296687e988SArnaldo Carvalho de Melo static inline __u32 tcp_current_ssthresh(const struct sock *sk) 9301da177e4SLinus Torvalds { 9316687e988SArnaldo Carvalho de Melo const struct tcp_sock *tp = tcp_sk(sk); 932cf533ea5SEric Dumazet 933684bad11SYuchung Cheng if (tcp_in_cwnd_reduction(sk)) 9341da177e4SLinus Torvalds return tp->snd_ssthresh; 9351da177e4SLinus Torvalds else 9361da177e4SLinus Torvalds return max(tp->snd_ssthresh, 9371da177e4SLinus Torvalds ((tp->snd_cwnd >> 1) + 9381da177e4SLinus Torvalds (tp->snd_cwnd >> 2))); 9391da177e4SLinus Torvalds } 9401da177e4SLinus Torvalds 941b9c4595bSIlpo Järvinen /* Use define here intentionally to get WARN_ON location shown at the caller */ 942b9c4595bSIlpo Järvinen #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out) 9431da177e4SLinus Torvalds 9445c9f3023SJoe Perches void tcp_enter_cwr(struct sock *sk, const int set_ssthresh); 9455c9f3023SJoe Perches __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst); 9461da177e4SLinus Torvalds 9476b5a5c0dSNeal Cardwell /* The maximum number of MSS of available cwnd for which TSO defers 9486b5a5c0dSNeal Cardwell * sending if not using sysctl_tcp_tso_win_divisor. 9496b5a5c0dSNeal Cardwell */ 9506b5a5c0dSNeal Cardwell static inline __u32 tcp_max_tso_deferred_mss(const struct tcp_sock *tp) 9516b5a5c0dSNeal Cardwell { 9526b5a5c0dSNeal Cardwell return 3; 9536b5a5c0dSNeal Cardwell } 9546b5a5c0dSNeal Cardwell 9551da177e4SLinus Torvalds /* Slow start with delack produces 3 packets of burst, so that 956dd9e0ddaSJohn Heffner * it is safe "de facto". This will be the default - same as 957dd9e0ddaSJohn Heffner * the default reordering threshold - but if reordering increases, 958dd9e0ddaSJohn Heffner * we must be able to allow cwnd to burst at least this much in order 959dd9e0ddaSJohn Heffner * to not pull it back when holes are filled. 9601da177e4SLinus Torvalds */ 9611da177e4SLinus Torvalds static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp) 9621da177e4SLinus Torvalds { 963dd9e0ddaSJohn Heffner return tp->reordering; 9641da177e4SLinus Torvalds } 9651da177e4SLinus Torvalds 96690840defSIlpo Järvinen /* Returns end sequence number of the receiver's advertised window */ 96790840defSIlpo Järvinen static inline u32 tcp_wnd_end(const struct tcp_sock *tp) 96890840defSIlpo Järvinen { 96990840defSIlpo Järvinen return tp->snd_una + tp->snd_wnd; 97090840defSIlpo Järvinen } 971e114a710SEric Dumazet 972e114a710SEric Dumazet /* We follow the spirit of RFC2861 to validate cwnd but implement a more 973e114a710SEric Dumazet * flexible approach. The RFC suggests cwnd should not be raised unless 974ca8a2263SNeal Cardwell * it was fully used previously. And that's exactly what we do in 975ca8a2263SNeal Cardwell * congestion avoidance mode. But in slow start we allow cwnd to grow 976ca8a2263SNeal Cardwell * as long as the application has used half the cwnd. 977e114a710SEric Dumazet * Example : 978e114a710SEric Dumazet * cwnd is 10 (IW10), but application sends 9 frames. 979e114a710SEric Dumazet * We allow cwnd to reach 18 when all frames are ACKed. 980e114a710SEric Dumazet * This check is safe because it's as aggressive as slow start which already 981e114a710SEric Dumazet * risks 100% overshoot. The advantage is that we discourage application to 982e114a710SEric Dumazet * either send more filler packets or data to artificially blow up the cwnd 983e114a710SEric Dumazet * usage, and allow application-limited process to probe bw more aggressively. 984e114a710SEric Dumazet */ 98524901551SEric Dumazet static inline bool tcp_is_cwnd_limited(const struct sock *sk) 986e114a710SEric Dumazet { 987e114a710SEric Dumazet const struct tcp_sock *tp = tcp_sk(sk); 988e114a710SEric Dumazet 989ca8a2263SNeal Cardwell /* If in slow start, ensure cwnd grows to twice what was ACKed. */ 990ca8a2263SNeal Cardwell if (tp->snd_cwnd <= tp->snd_ssthresh) 991ca8a2263SNeal Cardwell return tp->snd_cwnd < 2 * tp->max_packets_out; 992ca8a2263SNeal Cardwell 993ca8a2263SNeal Cardwell return tp->is_cwnd_limited; 994e114a710SEric Dumazet } 995f4805edeSStephen Hemminger 9969e412ba7SIlpo Järvinen static inline void tcp_check_probe_timer(struct sock *sk) 9971da177e4SLinus Torvalds { 998cf533ea5SEric Dumazet const struct tcp_sock *tp = tcp_sk(sk); 999463c84b9SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 10009e412ba7SIlpo Järvinen 1001463c84b9SArnaldo Carvalho de Melo if (!tp->packets_out && !icsk->icsk_pending) 10023f421baaSArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0, 10033f421baaSArnaldo Carvalho de Melo icsk->icsk_rto, TCP_RTO_MAX); 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 1006ee7537b6SHantzis Fotis static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq) 10071da177e4SLinus Torvalds { 10081da177e4SLinus Torvalds tp->snd_wl1 = seq; 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds 1011ee7537b6SHantzis Fotis static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq) 10121da177e4SLinus Torvalds { 10131da177e4SLinus Torvalds tp->snd_wl1 = seq; 10141da177e4SLinus Torvalds } 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds /* 10171da177e4SLinus Torvalds * Calculate(/check) TCP checksum 10181da177e4SLinus Torvalds */ 1019ba7808eaSFrederik Deweerdt static inline __sum16 tcp_v4_check(int len, __be32 saddr, 1020ba7808eaSFrederik Deweerdt __be32 daddr, __wsum base) 10211da177e4SLinus Torvalds { 10221da177e4SLinus Torvalds return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 1025b51655b9SAl Viro static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb) 10261da177e4SLinus Torvalds { 1027fb286bb2SHerbert Xu return __skb_checksum_complete(skb); 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds 1030a2a385d6SEric Dumazet static inline bool tcp_checksum_complete(struct sk_buff *skb) 10311da177e4SLinus Torvalds { 103260476372SHerbert Xu return !skb_csum_unnecessary(skb) && 10331da177e4SLinus Torvalds __tcp_checksum_complete(skb); 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds /* Prequeue for VJ style copy to user, combined with checksumming. */ 10371da177e4SLinus Torvalds 103840efc6faSStephen Hemminger static inline void tcp_prequeue_init(struct tcp_sock *tp) 10391da177e4SLinus Torvalds { 10401da177e4SLinus Torvalds tp->ucopy.task = NULL; 10411da177e4SLinus Torvalds tp->ucopy.len = 0; 10421da177e4SLinus Torvalds tp->ucopy.memory = 0; 10431da177e4SLinus Torvalds skb_queue_head_init(&tp->ucopy.prequeue); 104497fc2f08SChris Leech #ifdef CONFIG_NET_DMA 104597fc2f08SChris Leech tp->ucopy.dma_chan = NULL; 104697fc2f08SChris Leech tp->ucopy.wakeup = 0; 104797fc2f08SChris Leech tp->ucopy.pinned_list = NULL; 104897fc2f08SChris Leech tp->ucopy.dma_cookie = 0; 104997fc2f08SChris Leech #endif 10501da177e4SLinus Torvalds } 10511da177e4SLinus Torvalds 10525c9f3023SJoe Perches bool tcp_prequeue(struct sock *sk, struct sk_buff *skb); 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds #undef STATE_TRACE 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds #ifdef STATE_TRACE 10571da177e4SLinus Torvalds static const char *statename[]={ 10581da177e4SLinus Torvalds "Unused","Established","Syn Sent","Syn Recv", 10591da177e4SLinus Torvalds "Fin Wait 1","Fin Wait 2","Time Wait", "Close", 10601da177e4SLinus Torvalds "Close Wait","Last ACK","Listen","Closing" 10611da177e4SLinus Torvalds }; 10621da177e4SLinus Torvalds #endif 10635c9f3023SJoe Perches void tcp_set_state(struct sock *sk, int state); 10641da177e4SLinus Torvalds 10655c9f3023SJoe Perches void tcp_done(struct sock *sk); 10661da177e4SLinus Torvalds 106740efc6faSStephen Hemminger static inline void tcp_sack_reset(struct tcp_options_received *rx_opt) 10681da177e4SLinus Torvalds { 10691da177e4SLinus Torvalds rx_opt->dsack = 0; 10701da177e4SLinus Torvalds rx_opt->num_sacks = 0; 10711da177e4SLinus Torvalds } 10721da177e4SLinus Torvalds 10735c9f3023SJoe Perches u32 tcp_default_init_rwnd(u32 mss); 107485f16525SYuchung Cheng 10751da177e4SLinus Torvalds /* Determine a window scaling and initial window to offer. */ 10765c9f3023SJoe Perches void tcp_select_initial_window(int __space, __u32 mss, __u32 *rcv_wnd, 10775c9f3023SJoe Perches __u32 *window_clamp, int wscale_ok, 10785c9f3023SJoe Perches __u8 *rcv_wscale, __u32 init_rcv_wnd); 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds static inline int tcp_win_from_space(int space) 10811da177e4SLinus Torvalds { 10821da177e4SLinus Torvalds return sysctl_tcp_adv_win_scale<=0 ? 10831da177e4SLinus Torvalds (space>>(-sysctl_tcp_adv_win_scale)) : 10841da177e4SLinus Torvalds space - (space>>sysctl_tcp_adv_win_scale); 10851da177e4SLinus Torvalds } 10861da177e4SLinus Torvalds 10871da177e4SLinus Torvalds /* Note: caller must be prepared to deal with negative returns */ 10881da177e4SLinus Torvalds static inline int tcp_space(const struct sock *sk) 10891da177e4SLinus Torvalds { 10901da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf - 10911da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc)); 10921da177e4SLinus Torvalds } 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds static inline int tcp_full_space(const struct sock *sk) 10951da177e4SLinus Torvalds { 10961da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf); 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds 109940efc6faSStephen Hemminger static inline void tcp_openreq_init(struct request_sock *req, 11001da177e4SLinus Torvalds struct tcp_options_received *rx_opt, 1101*e0f802fbSOctavian Purdila struct sk_buff *skb, struct sock *sk) 11021da177e4SLinus Torvalds { 11032e6599cbSArnaldo Carvalho de Melo struct inet_request_sock *ireq = inet_rsk(req); 11042e6599cbSArnaldo Carvalho de Melo 11051da177e4SLinus Torvalds req->rcv_wnd = 0; /* So that tcp_send_synack() knows! */ 11064dfc2817SFlorian Westphal req->cookie_ts = 0; 11072e6599cbSArnaldo Carvalho de Melo tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq; 110810467163SJerry Chu tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->seq + 1; 1109016818d0SNeal Cardwell tcp_rsk(req)->snt_synack = 0; 11101da177e4SLinus Torvalds req->mss = rx_opt->mss_clamp; 11111da177e4SLinus Torvalds req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0; 11122e6599cbSArnaldo Carvalho de Melo ireq->tstamp_ok = rx_opt->tstamp_ok; 11132e6599cbSArnaldo Carvalho de Melo ireq->sack_ok = rx_opt->sack_ok; 11142e6599cbSArnaldo Carvalho de Melo ireq->snd_wscale = rx_opt->snd_wscale; 11152e6599cbSArnaldo Carvalho de Melo ireq->wscale_ok = rx_opt->wscale_ok; 11162e6599cbSArnaldo Carvalho de Melo ireq->acked = 0; 11172e6599cbSArnaldo Carvalho de Melo ireq->ecn_ok = 0; 1118634fb979SEric Dumazet ireq->ir_rmt_port = tcp_hdr(skb)->source; 1119b44084c2SEric Dumazet ireq->ir_num = ntohs(tcp_hdr(skb)->dest); 1120*e0f802fbSOctavian Purdila ireq->ir_mark = inet_request_mark(sk, skb); 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 1123843f4a55SYuchung Cheng extern void tcp_openreq_init_rwin(struct request_sock *req, 1124843f4a55SYuchung Cheng struct sock *sk, struct dst_entry *dst); 1125843f4a55SYuchung Cheng 11265c9f3023SJoe Perches void tcp_enter_memory_pressure(struct sock *sk); 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds static inline int keepalive_intvl_when(const struct tcp_sock *tp) 11291da177e4SLinus Torvalds { 11301da177e4SLinus Torvalds return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl; 11311da177e4SLinus Torvalds } 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds static inline int keepalive_time_when(const struct tcp_sock *tp) 11341da177e4SLinus Torvalds { 11351da177e4SLinus Torvalds return tp->keepalive_time ? : sysctl_tcp_keepalive_time; 11361da177e4SLinus Torvalds } 11371da177e4SLinus Torvalds 1138df19a626SEric Dumazet static inline int keepalive_probes(const struct tcp_sock *tp) 1139df19a626SEric Dumazet { 1140df19a626SEric Dumazet return tp->keepalive_probes ? : sysctl_tcp_keepalive_probes; 1141df19a626SEric Dumazet } 1142df19a626SEric Dumazet 11436c37e5deSFlavio Leitner static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp) 11446c37e5deSFlavio Leitner { 11456c37e5deSFlavio Leitner const struct inet_connection_sock *icsk = &tp->inet_conn; 11466c37e5deSFlavio Leitner 11476c37e5deSFlavio Leitner return min_t(u32, tcp_time_stamp - icsk->icsk_ack.lrcvtime, 11486c37e5deSFlavio Leitner tcp_time_stamp - tp->rcv_tstamp); 11496c37e5deSFlavio Leitner } 11506c37e5deSFlavio Leitner 1151463c84b9SArnaldo Carvalho de Melo static inline int tcp_fin_time(const struct sock *sk) 11521da177e4SLinus Torvalds { 1153463c84b9SArnaldo Carvalho de Melo int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout; 1154463c84b9SArnaldo Carvalho de Melo const int rto = inet_csk(sk)->icsk_rto; 11551da177e4SLinus Torvalds 1156463c84b9SArnaldo Carvalho de Melo if (fin_timeout < (rto << 2) - (rto >> 1)) 1157463c84b9SArnaldo Carvalho de Melo fin_timeout = (rto << 2) - (rto >> 1); 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds return fin_timeout; 11601da177e4SLinus Torvalds } 11611da177e4SLinus Torvalds 1162a2a385d6SEric Dumazet static inline bool tcp_paws_check(const struct tcp_options_received *rx_opt, 1163c887e6d2SIlpo Järvinen int paws_win) 11641da177e4SLinus Torvalds { 1165c887e6d2SIlpo Järvinen if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win) 1166a2a385d6SEric Dumazet return true; 1167c887e6d2SIlpo Järvinen if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)) 1168a2a385d6SEric Dumazet return true; 1169bc2ce894SEric Dumazet /* 1170bc2ce894SEric Dumazet * Some OSes send SYN and SYNACK messages with tsval=0 tsecr=0, 1171bc2ce894SEric Dumazet * then following tcp messages have valid values. Ignore 0 value, 1172bc2ce894SEric Dumazet * or else 'negative' tsval might forbid us to accept their packets. 1173bc2ce894SEric Dumazet */ 1174bc2ce894SEric Dumazet if (!rx_opt->ts_recent) 1175a2a385d6SEric Dumazet return true; 1176a2a385d6SEric Dumazet return false; 1177c887e6d2SIlpo Järvinen } 1178c887e6d2SIlpo Järvinen 1179a2a385d6SEric Dumazet static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt, 1180c887e6d2SIlpo Järvinen int rst) 1181c887e6d2SIlpo Järvinen { 1182c887e6d2SIlpo Järvinen if (tcp_paws_check(rx_opt, 0)) 1183a2a385d6SEric Dumazet return false; 11841da177e4SLinus Torvalds 11851da177e4SLinus Torvalds /* RST segments are not recommended to carry timestamp, 11861da177e4SLinus Torvalds and, if they do, it is recommended to ignore PAWS because 11871da177e4SLinus Torvalds "their cleanup function should take precedence over timestamps." 11881da177e4SLinus Torvalds Certainly, it is mistake. It is necessary to understand the reasons 11891da177e4SLinus Torvalds of this constraint to relax it: if peer reboots, clock may go 11901da177e4SLinus Torvalds out-of-sync and half-open connections will not be reset. 11911da177e4SLinus Torvalds Actually, the problem would be not existing if all 11921da177e4SLinus Torvalds the implementations followed draft about maintaining clock 11931da177e4SLinus Torvalds via reboots. Linux-2.2 DOES NOT! 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds However, we can relax time bounds for RST segments to MSL. 11961da177e4SLinus Torvalds */ 11979d729f72SJames Morris if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL) 1198a2a385d6SEric Dumazet return false; 1199a2a385d6SEric Dumazet return true; 12001da177e4SLinus Torvalds } 12011da177e4SLinus Torvalds 1202a9c19329SPavel Emelyanov static inline void tcp_mib_init(struct net *net) 12031da177e4SLinus Torvalds { 12041da177e4SLinus Torvalds /* See RFC 2012 */ 1205cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOALGORITHM, 1); 1206cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ); 1207cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ); 1208cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_MAXCONN, -1); 12091da177e4SLinus Torvalds } 12101da177e4SLinus Torvalds 12116a438bbeSStephen Hemminger /* from STCP */ 1212ef9da47cSIlpo Järvinen static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp) 12130800f170SDavid S. Miller { 12146a438bbeSStephen Hemminger tp->lost_skb_hint = NULL; 1215ef9da47cSIlpo Järvinen } 1216ef9da47cSIlpo Järvinen 1217ef9da47cSIlpo Järvinen static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp) 1218ef9da47cSIlpo Järvinen { 1219ef9da47cSIlpo Järvinen tcp_clear_retrans_hints_partial(tp); 12206a438bbeSStephen Hemminger tp->retransmit_skb_hint = NULL; 1221b7689205SIlpo Järvinen } 1222b7689205SIlpo Järvinen 1223cfb6eeb4SYOSHIFUJI Hideaki /* MD5 Signature */ 1224cfb6eeb4SYOSHIFUJI Hideaki struct crypto_hash; 1225cfb6eeb4SYOSHIFUJI Hideaki 1226a915da9bSEric Dumazet union tcp_md5_addr { 1227a915da9bSEric Dumazet struct in_addr a4; 1228a915da9bSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 1229a915da9bSEric Dumazet struct in6_addr a6; 1230a915da9bSEric Dumazet #endif 1231a915da9bSEric Dumazet }; 1232a915da9bSEric Dumazet 1233cfb6eeb4SYOSHIFUJI Hideaki /* - key database */ 1234cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key { 1235a915da9bSEric Dumazet struct hlist_node node; 1236cfb6eeb4SYOSHIFUJI Hideaki u8 keylen; 1237a915da9bSEric Dumazet u8 family; /* AF_INET or AF_INET6 */ 1238a915da9bSEric Dumazet union tcp_md5_addr addr; 1239a915da9bSEric Dumazet u8 key[TCP_MD5SIG_MAXKEYLEN]; 1240a915da9bSEric Dumazet struct rcu_head rcu; 1241cfb6eeb4SYOSHIFUJI Hideaki }; 1242cfb6eeb4SYOSHIFUJI Hideaki 1243cfb6eeb4SYOSHIFUJI Hideaki /* - sock block */ 1244cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_info { 1245a915da9bSEric Dumazet struct hlist_head head; 1246a8afca03SEric Dumazet struct rcu_head rcu; 1247cfb6eeb4SYOSHIFUJI Hideaki }; 1248cfb6eeb4SYOSHIFUJI Hideaki 1249cfb6eeb4SYOSHIFUJI Hideaki /* - pseudo header */ 1250cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr { 1251cfb6eeb4SYOSHIFUJI Hideaki __be32 saddr; 1252cfb6eeb4SYOSHIFUJI Hideaki __be32 daddr; 1253cfb6eeb4SYOSHIFUJI Hideaki __u8 pad; 1254cfb6eeb4SYOSHIFUJI Hideaki __u8 protocol; 1255cfb6eeb4SYOSHIFUJI Hideaki __be16 len; 1256cfb6eeb4SYOSHIFUJI Hideaki }; 1257cfb6eeb4SYOSHIFUJI Hideaki 1258cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr { 1259cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr saddr; 1260cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr daddr; 1261cfb6eeb4SYOSHIFUJI Hideaki __be32 len; 1262cfb6eeb4SYOSHIFUJI Hideaki __be32 protocol; /* including padding */ 1263cfb6eeb4SYOSHIFUJI Hideaki }; 1264cfb6eeb4SYOSHIFUJI Hideaki 1265cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block { 1266cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr ip4; 1267dfd56b8bSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 1268cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr ip6; 1269cfb6eeb4SYOSHIFUJI Hideaki #endif 1270cfb6eeb4SYOSHIFUJI Hideaki }; 1271cfb6eeb4SYOSHIFUJI Hideaki 1272cfb6eeb4SYOSHIFUJI Hideaki /* - pool: digest algorithm, hash description and scratch buffer */ 1273cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool { 1274cfb6eeb4SYOSHIFUJI Hideaki struct hash_desc md5_desc; 1275cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block md5_blk; 1276cfb6eeb4SYOSHIFUJI Hideaki }; 1277cfb6eeb4SYOSHIFUJI Hideaki 1278cfb6eeb4SYOSHIFUJI Hideaki /* - functions */ 12795c9f3023SJoe Perches int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key, 12805c9f3023SJoe Perches const struct sock *sk, const struct request_sock *req, 1281318cf7aaSEric Dumazet const struct sk_buff *skb); 12825c9f3023SJoe Perches int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr, 12835c9f3023SJoe Perches int family, const u8 *newkey, u8 newkeylen, gfp_t gfp); 12845c9f3023SJoe Perches int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, 1285a915da9bSEric Dumazet int family); 12865c9f3023SJoe Perches struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk, 1287cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1288cfb6eeb4SYOSHIFUJI Hideaki 12899501f972SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 12905c9f3023SJoe Perches struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk, 12915c9f3023SJoe Perches const union tcp_md5_addr *addr, 12925c9f3023SJoe Perches int family); 1293a915da9bSEric Dumazet #define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_key) 12949501f972SYOSHIFUJI Hideaki #else 1295a915da9bSEric Dumazet static inline struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk, 1296a915da9bSEric Dumazet const union tcp_md5_addr *addr, 1297a915da9bSEric Dumazet int family) 1298a915da9bSEric Dumazet { 1299a915da9bSEric Dumazet return NULL; 1300a915da9bSEric Dumazet } 13019501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) NULL 13029501f972SYOSHIFUJI Hideaki #endif 13039501f972SYOSHIFUJI Hideaki 13045c9f3023SJoe Perches bool tcp_alloc_md5sig_pool(void); 1305cfb6eeb4SYOSHIFUJI Hideaki 13065c9f3023SJoe Perches struct tcp_md5sig_pool *tcp_get_md5sig_pool(void); 130771cea17eSEric Dumazet static inline void tcp_put_md5sig_pool(void) 130871cea17eSEric Dumazet { 130971cea17eSEric Dumazet local_bh_enable(); 131071cea17eSEric Dumazet } 131135790c04SEric Dumazet 13125c9f3023SJoe Perches int tcp_md5_hash_header(struct tcp_md5sig_pool *, const struct tcphdr *); 13135c9f3023SJoe Perches int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *, 131495c96174SEric Dumazet unsigned int header_len); 13155c9f3023SJoe Perches int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, 1316cf533ea5SEric Dumazet const struct tcp_md5sig_key *key); 1317cfb6eeb4SYOSHIFUJI Hideaki 131810467163SJerry Chu /* From tcp_fastopen.c */ 13195c9f3023SJoe Perches void tcp_fastopen_cache_get(struct sock *sk, u16 *mss, 13205c9f3023SJoe Perches struct tcp_fastopen_cookie *cookie, int *syn_loss, 13215c9f3023SJoe Perches unsigned long *last_syn_loss); 13225c9f3023SJoe Perches void tcp_fastopen_cache_set(struct sock *sk, u16 mss, 13235c9f3023SJoe Perches struct tcp_fastopen_cookie *cookie, bool syn_lost); 1324783237e8SYuchung Cheng struct tcp_fastopen_request { 1325783237e8SYuchung Cheng /* Fast Open cookie. Size 0 means a cookie request */ 1326783237e8SYuchung Cheng struct tcp_fastopen_cookie cookie; 1327783237e8SYuchung Cheng struct msghdr *data; /* data in MSG_FASTOPEN */ 1328f5ddcbbbSEric Dumazet size_t size; 1329f5ddcbbbSEric Dumazet int copied; /* queued in tcp_connect() */ 1330783237e8SYuchung Cheng }; 1331783237e8SYuchung Cheng void tcp_free_fastopen_req(struct tcp_sock *tp); 1332783237e8SYuchung Cheng 133310467163SJerry Chu extern struct tcp_fastopen_context __rcu *tcp_fastopen_ctx; 133410467163SJerry Chu int tcp_fastopen_reset_cipher(void *key, unsigned int len); 1335843f4a55SYuchung Cheng bool tcp_try_fastopen(struct sock *sk, struct sk_buff *skb, 13365b7ed089SYuchung Cheng struct request_sock *req, 1337843f4a55SYuchung Cheng struct tcp_fastopen_cookie *foc, 1338843f4a55SYuchung Cheng struct dst_entry *dst); 1339222e83d2SHannes Frederic Sowa void tcp_fastopen_init_key_once(bool publish); 134010467163SJerry Chu #define TCP_FASTOPEN_KEY_LENGTH 16 134110467163SJerry Chu 134210467163SJerry Chu /* Fastopen key context */ 134310467163SJerry Chu struct tcp_fastopen_context { 13447ae8639cSEric Dumazet struct crypto_cipher *tfm; 134510467163SJerry Chu __u8 key[TCP_FASTOPEN_KEY_LENGTH]; 134610467163SJerry Chu struct rcu_head rcu; 134710467163SJerry Chu }; 134810467163SJerry Chu 1349fe067e8aSDavid S. Miller /* write queue abstraction */ 1350fe067e8aSDavid S. Miller static inline void tcp_write_queue_purge(struct sock *sk) 1351fe067e8aSDavid S. Miller { 1352fe067e8aSDavid S. Miller struct sk_buff *skb; 1353fe067e8aSDavid S. Miller 1354fe067e8aSDavid S. Miller while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) 13553ab224beSHideo Aoki sk_wmem_free_skb(sk, skb); 13563ab224beSHideo Aoki sk_mem_reclaim(sk); 13578818a9d8SIlpo Järvinen tcp_clear_all_retrans_hints(tcp_sk(sk)); 1358fe067e8aSDavid S. Miller } 1359fe067e8aSDavid S. Miller 1360cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk) 1361fe067e8aSDavid S. Miller { 1362cd07a8eaSDavid S. Miller return skb_peek(&sk->sk_write_queue); 1363fe067e8aSDavid S. Miller } 1364fe067e8aSDavid S. Miller 1365cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk) 1366fe067e8aSDavid S. Miller { 1367cd07a8eaSDavid S. Miller return skb_peek_tail(&sk->sk_write_queue); 1368fe067e8aSDavid S. Miller } 1369fe067e8aSDavid S. Miller 1370cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_next(const struct sock *sk, 1371cf533ea5SEric Dumazet const struct sk_buff *skb) 1372fe067e8aSDavid S. Miller { 1373cd07a8eaSDavid S. Miller return skb_queue_next(&sk->sk_write_queue, skb); 1374fe067e8aSDavid S. Miller } 1375fe067e8aSDavid S. Miller 1376cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_prev(const struct sock *sk, 1377cf533ea5SEric Dumazet const struct sk_buff *skb) 1378832d11c5SIlpo Järvinen { 1379832d11c5SIlpo Järvinen return skb_queue_prev(&sk->sk_write_queue, skb); 1380832d11c5SIlpo Järvinen } 1381832d11c5SIlpo Järvinen 1382fe067e8aSDavid S. Miller #define tcp_for_write_queue(skb, sk) \ 1383cd07a8eaSDavid S. Miller skb_queue_walk(&(sk)->sk_write_queue, skb) 1384fe067e8aSDavid S. Miller 1385fe067e8aSDavid S. Miller #define tcp_for_write_queue_from(skb, sk) \ 1386cd07a8eaSDavid S. Miller skb_queue_walk_from(&(sk)->sk_write_queue, skb) 1387fe067e8aSDavid S. Miller 1388234b6860SIlpo Järvinen #define tcp_for_write_queue_from_safe(skb, tmp, sk) \ 1389cd07a8eaSDavid S. Miller skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp) 1390234b6860SIlpo Järvinen 1391cf533ea5SEric Dumazet static inline struct sk_buff *tcp_send_head(const struct sock *sk) 1392fe067e8aSDavid S. Miller { 1393fe067e8aSDavid S. Miller return sk->sk_send_head; 1394fe067e8aSDavid S. Miller } 1395fe067e8aSDavid S. Miller 1396cd07a8eaSDavid S. Miller static inline bool tcp_skb_is_last(const struct sock *sk, 1397cd07a8eaSDavid S. Miller const struct sk_buff *skb) 1398cd07a8eaSDavid S. Miller { 1399cd07a8eaSDavid S. Miller return skb_queue_is_last(&sk->sk_write_queue, skb); 1400cd07a8eaSDavid S. Miller } 1401cd07a8eaSDavid S. Miller 1402cf533ea5SEric Dumazet static inline void tcp_advance_send_head(struct sock *sk, const struct sk_buff *skb) 1403fe067e8aSDavid S. Miller { 1404cd07a8eaSDavid S. Miller if (tcp_skb_is_last(sk, skb)) 1405fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1406cd07a8eaSDavid S. Miller else 1407cd07a8eaSDavid S. Miller sk->sk_send_head = tcp_write_queue_next(sk, skb); 1408fe067e8aSDavid S. Miller } 1409fe067e8aSDavid S. Miller 1410fe067e8aSDavid S. Miller static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked) 1411fe067e8aSDavid S. Miller { 1412fe067e8aSDavid S. Miller if (sk->sk_send_head == skb_unlinked) 1413fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1414fe067e8aSDavid S. Miller } 1415fe067e8aSDavid S. Miller 1416fe067e8aSDavid S. Miller static inline void tcp_init_send_head(struct sock *sk) 1417fe067e8aSDavid S. Miller { 1418fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1419fe067e8aSDavid S. Miller } 1420fe067e8aSDavid S. Miller 1421fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1422fe067e8aSDavid S. Miller { 1423fe067e8aSDavid S. Miller __skb_queue_tail(&sk->sk_write_queue, skb); 1424fe067e8aSDavid S. Miller } 1425fe067e8aSDavid S. Miller 1426fe067e8aSDavid S. Miller static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1427fe067e8aSDavid S. Miller { 1428fe067e8aSDavid S. Miller __tcp_add_write_queue_tail(sk, skb); 1429fe067e8aSDavid S. Miller 1430fe067e8aSDavid S. Miller /* Queue it, remembering where we must start sending. */ 14316859d494SIlpo Järvinen if (sk->sk_send_head == NULL) { 1432fe067e8aSDavid S. Miller sk->sk_send_head = skb; 14336859d494SIlpo Järvinen 14346859d494SIlpo Järvinen if (tcp_sk(sk)->highest_sack == NULL) 14356859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = skb; 14366859d494SIlpo Järvinen } 1437fe067e8aSDavid S. Miller } 1438fe067e8aSDavid S. Miller 1439fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb) 1440fe067e8aSDavid S. Miller { 1441fe067e8aSDavid S. Miller __skb_queue_head(&sk->sk_write_queue, skb); 1442fe067e8aSDavid S. Miller } 1443fe067e8aSDavid S. Miller 1444fe067e8aSDavid S. Miller /* Insert buff after skb on the write queue of sk. */ 1445fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_after(struct sk_buff *skb, 1446fe067e8aSDavid S. Miller struct sk_buff *buff, 1447fe067e8aSDavid S. Miller struct sock *sk) 1448fe067e8aSDavid S. Miller { 14497de6c033SGerrit Renker __skb_queue_after(&sk->sk_write_queue, skb, buff); 1450fe067e8aSDavid S. Miller } 1451fe067e8aSDavid S. Miller 145243f59c89SDavid S. Miller /* Insert new before skb on the write queue of sk. */ 1453fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_before(struct sk_buff *new, 1454fe067e8aSDavid S. Miller struct sk_buff *skb, 1455fe067e8aSDavid S. Miller struct sock *sk) 1456fe067e8aSDavid S. Miller { 145743f59c89SDavid S. Miller __skb_queue_before(&sk->sk_write_queue, skb, new); 14586e421410SIlpo Järvinen 14596e421410SIlpo Järvinen if (sk->sk_send_head == skb) 14606e421410SIlpo Järvinen sk->sk_send_head = new; 1461fe067e8aSDavid S. Miller } 1462fe067e8aSDavid S. Miller 1463fe067e8aSDavid S. Miller static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk) 1464fe067e8aSDavid S. Miller { 1465fe067e8aSDavid S. Miller __skb_unlink(skb, &sk->sk_write_queue); 1466fe067e8aSDavid S. Miller } 1467fe067e8aSDavid S. Miller 1468a2a385d6SEric Dumazet static inline bool tcp_write_queue_empty(struct sock *sk) 1469fe067e8aSDavid S. Miller { 1470fe067e8aSDavid S. Miller return skb_queue_empty(&sk->sk_write_queue); 1471fe067e8aSDavid S. Miller } 1472fe067e8aSDavid S. Miller 147312d50c46SKrishna Kumar static inline void tcp_push_pending_frames(struct sock *sk) 147412d50c46SKrishna Kumar { 147512d50c46SKrishna Kumar if (tcp_send_head(sk)) { 147612d50c46SKrishna Kumar struct tcp_sock *tp = tcp_sk(sk); 147712d50c46SKrishna Kumar 147812d50c46SKrishna Kumar __tcp_push_pending_frames(sk, tcp_current_mss(sk), tp->nonagle); 147912d50c46SKrishna Kumar } 148012d50c46SKrishna Kumar } 148112d50c46SKrishna Kumar 1482ecb97192SNeal Cardwell /* Start sequence of the skb just after the highest skb with SACKed 1483ecb97192SNeal Cardwell * bit, valid only if sacked_out > 0 or when the caller has ensured 1484ecb97192SNeal Cardwell * validity by itself. 1485a47e5a98SIlpo Järvinen */ 1486a47e5a98SIlpo Järvinen static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp) 1487a47e5a98SIlpo Järvinen { 1488a47e5a98SIlpo Järvinen if (!tp->sacked_out) 1489a47e5a98SIlpo Järvinen return tp->snd_una; 14906859d494SIlpo Järvinen 14916859d494SIlpo Järvinen if (tp->highest_sack == NULL) 14926859d494SIlpo Järvinen return tp->snd_nxt; 14936859d494SIlpo Järvinen 1494a47e5a98SIlpo Järvinen return TCP_SKB_CB(tp->highest_sack)->seq; 1495a47e5a98SIlpo Järvinen } 1496a47e5a98SIlpo Järvinen 14976859d494SIlpo Järvinen static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb) 14986859d494SIlpo Järvinen { 14996859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_skb_is_last(sk, skb) ? NULL : 15006859d494SIlpo Järvinen tcp_write_queue_next(sk, skb); 15016859d494SIlpo Järvinen } 15026859d494SIlpo Järvinen 15036859d494SIlpo Järvinen static inline struct sk_buff *tcp_highest_sack(struct sock *sk) 15046859d494SIlpo Järvinen { 15056859d494SIlpo Järvinen return tcp_sk(sk)->highest_sack; 15066859d494SIlpo Järvinen } 15076859d494SIlpo Järvinen 15086859d494SIlpo Järvinen static inline void tcp_highest_sack_reset(struct sock *sk) 15096859d494SIlpo Järvinen { 15106859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk); 15116859d494SIlpo Järvinen } 15126859d494SIlpo Järvinen 15136859d494SIlpo Järvinen /* Called when old skb is about to be deleted (to be combined with new skb) */ 15146859d494SIlpo Järvinen static inline void tcp_highest_sack_combine(struct sock *sk, 15156859d494SIlpo Järvinen struct sk_buff *old, 15166859d494SIlpo Järvinen struct sk_buff *new) 15176859d494SIlpo Järvinen { 15186859d494SIlpo Järvinen if (tcp_sk(sk)->sacked_out && (old == tcp_sk(sk)->highest_sack)) 15196859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = new; 15206859d494SIlpo Järvinen } 15216859d494SIlpo Järvinen 15225aa4b32fSAndreas Petlund /* Determines whether this is a thin stream (which may suffer from 15235aa4b32fSAndreas Petlund * increased latency). Used to trigger latency-reducing mechanisms. 15245aa4b32fSAndreas Petlund */ 1525a2a385d6SEric Dumazet static inline bool tcp_stream_is_thin(struct tcp_sock *tp) 15265aa4b32fSAndreas Petlund { 15275aa4b32fSAndreas Petlund return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp); 15285aa4b32fSAndreas Petlund } 15295aa4b32fSAndreas Petlund 15301da177e4SLinus Torvalds /* /proc */ 15311da177e4SLinus Torvalds enum tcp_seq_states { 15321da177e4SLinus Torvalds TCP_SEQ_STATE_LISTENING, 15331da177e4SLinus Torvalds TCP_SEQ_STATE_OPENREQ, 15341da177e4SLinus Torvalds TCP_SEQ_STATE_ESTABLISHED, 15351da177e4SLinus Torvalds }; 15361da177e4SLinus Torvalds 153773cb88ecSArjan van de Ven int tcp_seq_open(struct inode *inode, struct file *file); 153873cb88ecSArjan van de Ven 15391da177e4SLinus Torvalds struct tcp_seq_afinfo { 15401da177e4SLinus Torvalds char *name; 15411da177e4SLinus Torvalds sa_family_t family; 154273cb88ecSArjan van de Ven const struct file_operations *seq_fops; 15439427c4b3SDenis V. Lunev struct seq_operations seq_ops; 15441da177e4SLinus Torvalds }; 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds struct tcp_iter_state { 1547a4146b1bSDenis V. Lunev struct seq_net_private p; 15481da177e4SLinus Torvalds sa_family_t family; 15491da177e4SLinus Torvalds enum tcp_seq_states state; 15501da177e4SLinus Torvalds struct sock *syn_wait_sk; 1551a7cb5a49SEric W. Biederman int bucket, offset, sbucket, num; 1552a7cb5a49SEric W. Biederman kuid_t uid; 1553a8b690f9STom Herbert loff_t last_pos; 15541da177e4SLinus Torvalds }; 15551da177e4SLinus Torvalds 15565c9f3023SJoe Perches int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo); 15575c9f3023SJoe Perches void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo); 15581da177e4SLinus Torvalds 155920380731SArnaldo Carvalho de Melo extern struct request_sock_ops tcp_request_sock_ops; 1560c6aefafbSGlenn Griffin extern struct request_sock_ops tcp6_request_sock_ops; 156120380731SArnaldo Carvalho de Melo 15625c9f3023SJoe Perches void tcp_v4_destroy_sock(struct sock *sk); 156320380731SArnaldo Carvalho de Melo 156428be6e07SEric Dumazet struct sk_buff *tcp_gso_segment(struct sk_buff *skb, 1565c8f44affSMichał Mirosław netdev_features_t features); 15665c9f3023SJoe Perches struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb); 15675c9f3023SJoe Perches int tcp_gro_complete(struct sk_buff *skb); 156828850dc7SDaniel Borkmann 15695c9f3023SJoe Perches void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr); 1570f4c50d99SHerbert Xu 1571c9bee3b7SEric Dumazet static inline u32 tcp_notsent_lowat(const struct tcp_sock *tp) 1572c9bee3b7SEric Dumazet { 1573c9bee3b7SEric Dumazet return tp->notsent_lowat ?: sysctl_tcp_notsent_lowat; 1574c9bee3b7SEric Dumazet } 1575c9bee3b7SEric Dumazet 1576c9bee3b7SEric Dumazet static inline bool tcp_stream_memory_free(const struct sock *sk) 1577c9bee3b7SEric Dumazet { 1578c9bee3b7SEric Dumazet const struct tcp_sock *tp = tcp_sk(sk); 1579c9bee3b7SEric Dumazet u32 notsent_bytes = tp->write_seq - tp->snd_nxt; 1580c9bee3b7SEric Dumazet 1581c9bee3b7SEric Dumazet return notsent_bytes < tcp_notsent_lowat(tp); 1582c9bee3b7SEric Dumazet } 1583c9bee3b7SEric Dumazet 158420380731SArnaldo Carvalho de Melo #ifdef CONFIG_PROC_FS 15855c9f3023SJoe Perches int tcp4_proc_init(void); 15865c9f3023SJoe Perches void tcp4_proc_exit(void); 158720380731SArnaldo Carvalho de Melo #endif 158820380731SArnaldo Carvalho de Melo 1589cfb6eeb4SYOSHIFUJI Hideaki /* TCP af-specific functions */ 1590cfb6eeb4SYOSHIFUJI Hideaki struct tcp_sock_af_ops { 1591cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1592cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1593cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1594cfb6eeb4SYOSHIFUJI Hideaki int (*calc_md5_hash) (char *location, 1595cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *md5, 1596318cf7aaSEric Dumazet const struct sock *sk, 1597318cf7aaSEric Dumazet const struct request_sock *req, 1598318cf7aaSEric Dumazet const struct sk_buff *skb); 1599cfb6eeb4SYOSHIFUJI Hideaki int (*md5_parse) (struct sock *sk, 1600cfb6eeb4SYOSHIFUJI Hideaki char __user *optval, 1601cfb6eeb4SYOSHIFUJI Hideaki int optlen); 1602cfb6eeb4SYOSHIFUJI Hideaki #endif 1603cfb6eeb4SYOSHIFUJI Hideaki }; 1604cfb6eeb4SYOSHIFUJI Hideaki 1605cfb6eeb4SYOSHIFUJI Hideaki struct tcp_request_sock_ops { 1606cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1607cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1608cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req); 1609e3afe7b7SJohn Dykstra int (*calc_md5_hash) (char *location, 1610e3afe7b7SJohn Dykstra struct tcp_md5sig_key *md5, 1611318cf7aaSEric Dumazet const struct sock *sk, 1612318cf7aaSEric Dumazet const struct request_sock *req, 1613318cf7aaSEric Dumazet const struct sk_buff *skb); 1614cfb6eeb4SYOSHIFUJI Hideaki #endif 1615cfb6eeb4SYOSHIFUJI Hideaki }; 1616cfb6eeb4SYOSHIFUJI Hideaki 16175c9f3023SJoe Perches int tcpv4_offload_init(void); 161828850dc7SDaniel Borkmann 16195c9f3023SJoe Perches void tcp_v4_init(void); 16205c9f3023SJoe Perches void tcp_init(void); 162120380731SArnaldo Carvalho de Melo 16221da177e4SLinus Torvalds #endif /* _TCP_H */ 1623