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> 30cfb6eeb4SYOSHIFUJI Hideaki #include <linux/crypto.h> 31c6aefafbSGlenn Griffin #include <linux/cryptohash.h> 32435cf559SWilliam Allen Simpson #include <linux/kref.h> 33740b0f18SEric Dumazet #include <linux/ktime.h> 343f421baaSArnaldo Carvalho de Melo 353f421baaSArnaldo Carvalho de Melo #include <net/inet_connection_sock.h> 36295ff7edSArnaldo Carvalho de Melo #include <net/inet_timewait_sock.h> 3777d8bf9cSArnaldo Carvalho de Melo #include <net/inet_hashtables.h> 381da177e4SLinus Torvalds #include <net/checksum.h> 392e6599cbSArnaldo Carvalho de Melo #include <net/request_sock.h> 401da177e4SLinus Torvalds #include <net/sock.h> 411da177e4SLinus Torvalds #include <net/snmp.h> 421da177e4SLinus Torvalds #include <net/ip.h> 43c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h> 44bdf1ee5dSIlpo Järvinen #include <net/inet_ecn.h> 450c266898SSatoru SATOH #include <net/dst.h> 46c752f073SArnaldo Carvalho de Melo 471da177e4SLinus Torvalds #include <linux/seq_file.h> 48180d8cd9SGlauber Costa #include <linux/memcontrol.h> 491da177e4SLinus Torvalds 500f7ff927SArnaldo Carvalho de Melo extern struct inet_hashinfo tcp_hashinfo; 511da177e4SLinus Torvalds 52dd24c001SEric Dumazet extern struct percpu_counter tcp_orphan_count; 535c9f3023SJoe Perches void tcp_time_wait(struct sock *sk, int state, int timeo); 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds #define MAX_TCP_HEADER (128 + MAX_HEADER) 5633ad798cSAdam Langley #define MAX_TCP_OPTION_SPACE 40 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds /* 591da177e4SLinus Torvalds * Never offer a window over 32767 without using window scaling. Some 601da177e4SLinus Torvalds * poor stacks do signed 16bit maths! 611da177e4SLinus Torvalds */ 621da177e4SLinus Torvalds #define MAX_TCP_WINDOW 32767U 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* Minimal accepted MSS. It is (60+60+8) - (20+20). */ 651da177e4SLinus Torvalds #define TCP_MIN_MSS 88U 661da177e4SLinus Torvalds 675d424d5aSJohn Heffner /* The least MTU to use for probing */ 68dcd8fb85SFan Du #define TCP_BASE_MSS 1024 695d424d5aSJohn Heffner 7005cbc0dbSFan Du /* probing interval, default to 10 minutes as per RFC4821 */ 7105cbc0dbSFan Du #define TCP_PROBE_INTERVAL 600 7205cbc0dbSFan Du 736b58e0a5SFan Du /* Specify interval when tcp mtu probing will stop */ 746b58e0a5SFan Du #define TCP_PROBE_THRESHOLD 8 756b58e0a5SFan Du 761da177e4SLinus Torvalds /* After receiving this amount of duplicate ACKs fast retransmit starts. */ 771da177e4SLinus Torvalds #define TCP_FASTRETRANS_THRESH 3 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds /* Maximal number of ACKs sent quickly to accelerate slow-start. */ 801da177e4SLinus Torvalds #define TCP_MAX_QUICKACKS 16U 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds /* urg_data states */ 831da177e4SLinus Torvalds #define TCP_URG_VALID 0x0100 841da177e4SLinus Torvalds #define TCP_URG_NOTYET 0x0200 851da177e4SLinus Torvalds #define TCP_URG_READ 0x0400 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds #define TCP_RETR1 3 /* 881da177e4SLinus Torvalds * This is how many retries it does before it 891da177e4SLinus Torvalds * tries to figure out if the gateway is 901da177e4SLinus Torvalds * down. Minimal RFC value is 3; it corresponds 911da177e4SLinus Torvalds * to ~3sec-8min depending on RTO. 921da177e4SLinus Torvalds */ 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds #define TCP_RETR2 15 /* 951da177e4SLinus Torvalds * This should take at least 961da177e4SLinus Torvalds * 90 minutes to time out. 971da177e4SLinus Torvalds * RFC1122 says that the limit is 100 sec. 981da177e4SLinus Torvalds * 15 is ~13-30min depending on RTO. 991da177e4SLinus Torvalds */ 1001da177e4SLinus Torvalds 1016c9ff979SAlex Bergmann #define TCP_SYN_RETRIES 6 /* This is how many retries are done 1026c9ff979SAlex Bergmann * when active opening a connection. 1036c9ff979SAlex Bergmann * RFC1122 says the minimum retry MUST 1046c9ff979SAlex Bergmann * be at least 180secs. Nevertheless 1056c9ff979SAlex Bergmann * this value is corresponding to 1066c9ff979SAlex Bergmann * 63secs of retransmission with the 1076c9ff979SAlex Bergmann * current initial RTO. 1086c9ff979SAlex Bergmann */ 1091da177e4SLinus Torvalds 1106c9ff979SAlex Bergmann #define TCP_SYNACK_RETRIES 5 /* This is how may retries are done 1116c9ff979SAlex Bergmann * when passive opening a connection. 1126c9ff979SAlex Bergmann * This is corresponding to 31secs of 1136c9ff979SAlex Bergmann * retransmission with the current 1146c9ff979SAlex Bergmann * initial RTO. 1156c9ff979SAlex Bergmann */ 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT 1181da177e4SLinus Torvalds * state, about 60 seconds */ 1191da177e4SLinus Torvalds #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN 1201da177e4SLinus Torvalds /* BSD style FIN_WAIT2 deadlock breaker. 1211da177e4SLinus Torvalds * It used to be 3min, new value is 60sec, 1221da177e4SLinus Torvalds * to combine FIN-WAIT-2 timeout with 1231da177e4SLinus Torvalds * TIME-WAIT timer. 1241da177e4SLinus Torvalds */ 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds #define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */ 1271da177e4SLinus Torvalds #if HZ >= 100 1281da177e4SLinus Torvalds #define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */ 1291da177e4SLinus Torvalds #define TCP_ATO_MIN ((unsigned)(HZ/25)) 1301da177e4SLinus Torvalds #else 1311da177e4SLinus Torvalds #define TCP_DELACK_MIN 4U 1321da177e4SLinus Torvalds #define TCP_ATO_MIN 4U 1331da177e4SLinus Torvalds #endif 1341da177e4SLinus Torvalds #define TCP_RTO_MAX ((unsigned)(120*HZ)) 1351da177e4SLinus Torvalds #define TCP_RTO_MIN ((unsigned)(HZ/5)) 136fd4f2ceaSEric Dumazet #define TCP_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC6298 2.1 initial RTO value */ 1379ad7c049SJerry Chu #define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value, now 1389ad7c049SJerry Chu * used as a fallback RTO for the 1399ad7c049SJerry Chu * initial data transmission if no 1409ad7c049SJerry Chu * valid RTT sample has been acquired, 1419ad7c049SJerry Chu * most likely due to retrans in 3WHS. 1429ad7c049SJerry Chu */ 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes 1451da177e4SLinus Torvalds * for local resources. 1461da177e4SLinus Torvalds */ 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds #define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */ 1491da177e4SLinus Torvalds #define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ 1501da177e4SLinus Torvalds #define TCP_KEEPALIVE_INTVL (75*HZ) 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds #define MAX_TCP_KEEPIDLE 32767 1531da177e4SLinus Torvalds #define MAX_TCP_KEEPINTVL 32767 1541da177e4SLinus Torvalds #define MAX_TCP_KEEPCNT 127 1551da177e4SLinus Torvalds #define MAX_TCP_SYNCNT 127 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds #define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */ 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24) 1601da177e4SLinus Torvalds #define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated 1611da177e4SLinus Torvalds * after this time. It should be equal 1621da177e4SLinus Torvalds * (or greater than) TCP_TIMEWAIT_LEN 1631da177e4SLinus Torvalds * to provide reliability equal to one 1641da177e4SLinus Torvalds * provided by timewait state. 1651da177e4SLinus Torvalds */ 1661da177e4SLinus Torvalds #define TCP_PAWS_WINDOW 1 /* Replay window for per-host 1671da177e4SLinus Torvalds * timestamps. It must be less than 1681da177e4SLinus Torvalds * minimal timewait lifetime. 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds /* 1711da177e4SLinus Torvalds * TCP option 1721da177e4SLinus Torvalds */ 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds #define TCPOPT_NOP 1 /* Padding */ 1751da177e4SLinus Torvalds #define TCPOPT_EOL 0 /* End of options */ 1761da177e4SLinus Torvalds #define TCPOPT_MSS 2 /* Segment size negotiating */ 1771da177e4SLinus Torvalds #define TCPOPT_WINDOW 3 /* Window scaling */ 1781da177e4SLinus Torvalds #define TCPOPT_SACK_PERM 4 /* SACK Permitted */ 1791da177e4SLinus Torvalds #define TCPOPT_SACK 5 /* SACK Block */ 1801da177e4SLinus Torvalds #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ 181cfb6eeb4SYOSHIFUJI Hideaki #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ 1827f9b838bSDaniel Lee #define TCPOPT_FASTOPEN 34 /* Fast open (RFC7413) */ 1832100c8d2SYuchung Cheng #define TCPOPT_EXP 254 /* Experimental */ 1842100c8d2SYuchung Cheng /* Magic number to be after the option value for sharing TCP 1852100c8d2SYuchung Cheng * experimental options. See draft-ietf-tcpm-experimental-options-00.txt 1862100c8d2SYuchung Cheng */ 1872100c8d2SYuchung Cheng #define TCPOPT_FASTOPEN_MAGIC 0xF989 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds /* 1901da177e4SLinus Torvalds * TCP option lengths 1911da177e4SLinus Torvalds */ 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds #define TCPOLEN_MSS 4 1941da177e4SLinus Torvalds #define TCPOLEN_WINDOW 3 1951da177e4SLinus Torvalds #define TCPOLEN_SACK_PERM 2 1961da177e4SLinus Torvalds #define TCPOLEN_TIMESTAMP 10 197cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG 18 1987f9b838bSDaniel Lee #define TCPOLEN_FASTOPEN_BASE 2 1992100c8d2SYuchung Cheng #define TCPOLEN_EXP_FASTOPEN_BASE 4 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds /* But this is what stacks really send out. */ 2021da177e4SLinus Torvalds #define TCPOLEN_TSTAMP_ALIGNED 12 2031da177e4SLinus Torvalds #define TCPOLEN_WSCALE_ALIGNED 4 2041da177e4SLinus Torvalds #define TCPOLEN_SACKPERM_ALIGNED 4 2051da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE 2 2061da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE_ALIGNED 4 2071da177e4SLinus Torvalds #define TCPOLEN_SACK_PERBLOCK 8 208cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG_ALIGNED 20 20933ad798cSAdam Langley #define TCPOLEN_MSS_ALIGNED 4 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds /* Flags in tp->nonagle */ 2121da177e4SLinus Torvalds #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */ 2131da177e4SLinus Torvalds #define TCP_NAGLE_CORK 2 /* Socket is corked */ 214caa20d9aSStephen Hemminger #define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */ 2151da177e4SLinus Torvalds 21636e31b0aSAndreas Petlund /* TCP thin-stream limits */ 21736e31b0aSAndreas Petlund #define TCP_THIN_LINEAR_RETRIES 6 /* After 6 linear retries, do exp. backoff */ 21836e31b0aSAndreas Petlund 2197eb38527SDavid S. Miller /* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */ 220442b9635SDavid S. Miller #define TCP_INIT_CWND 10 221442b9635SDavid S. Miller 222cf60af03SYuchung Cheng /* Bit Flags for sysctl_tcp_fastopen */ 223cf60af03SYuchung Cheng #define TFO_CLIENT_ENABLE 1 22410467163SJerry Chu #define TFO_SERVER_ENABLE 2 22567da22d2SYuchung Cheng #define TFO_CLIENT_NO_COOKIE 4 /* Data in SYN w/o cookie option */ 226cf60af03SYuchung Cheng 22710467163SJerry Chu /* Accept SYN data w/o any cookie option */ 22810467163SJerry Chu #define TFO_SERVER_COOKIE_NOT_REQD 0x200 22910467163SJerry Chu 23010467163SJerry Chu /* Force enable TFO on all listeners, i.e., not requiring the 23110467163SJerry Chu * TCP_FASTOPEN socket option. SOCKOPT1/2 determine how to set max_qlen. 23210467163SJerry Chu */ 23310467163SJerry Chu #define TFO_SERVER_WO_SOCKOPT1 0x400 23410467163SJerry Chu #define TFO_SERVER_WO_SOCKOPT2 0x800 23510467163SJerry Chu 236295ff7edSArnaldo Carvalho de Melo extern struct inet_timewait_death_row tcp_death_row; 237295ff7edSArnaldo Carvalho de Melo 2381da177e4SLinus Torvalds /* sysctl variables for tcp */ 2391da177e4SLinus Torvalds extern int sysctl_tcp_timestamps; 2401da177e4SLinus Torvalds extern int sysctl_tcp_window_scaling; 2411da177e4SLinus Torvalds extern int sysctl_tcp_sack; 2421da177e4SLinus Torvalds extern int sysctl_tcp_fin_timeout; 2431da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_time; 2441da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_probes; 2451da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_intvl; 2461da177e4SLinus Torvalds extern int sysctl_tcp_syn_retries; 2471da177e4SLinus Torvalds extern int sysctl_tcp_synack_retries; 2481da177e4SLinus Torvalds extern int sysctl_tcp_retries1; 2491da177e4SLinus Torvalds extern int sysctl_tcp_retries2; 2501da177e4SLinus Torvalds extern int sysctl_tcp_orphan_retries; 2511da177e4SLinus Torvalds extern int sysctl_tcp_syncookies; 2522100c8d2SYuchung Cheng extern int sysctl_tcp_fastopen; 2531da177e4SLinus Torvalds extern int sysctl_tcp_retrans_collapse; 2541da177e4SLinus Torvalds extern int sysctl_tcp_stdurg; 2551da177e4SLinus Torvalds extern int sysctl_tcp_rfc1337; 2561da177e4SLinus Torvalds extern int sysctl_tcp_abort_on_overflow; 2571da177e4SLinus Torvalds extern int sysctl_tcp_max_orphans; 2581da177e4SLinus Torvalds extern int sysctl_tcp_fack; 2591da177e4SLinus Torvalds extern int sysctl_tcp_reordering; 260dca145ffSEric Dumazet extern int sysctl_tcp_max_reordering; 2611da177e4SLinus Torvalds extern int sysctl_tcp_dsack; 262a4fe34bfSEric W. Biederman extern long sysctl_tcp_mem[3]; 2631da177e4SLinus Torvalds extern int sysctl_tcp_wmem[3]; 2641da177e4SLinus Torvalds extern int sysctl_tcp_rmem[3]; 2651da177e4SLinus Torvalds extern int sysctl_tcp_app_win; 2661da177e4SLinus Torvalds extern int sysctl_tcp_adv_win_scale; 2671da177e4SLinus Torvalds extern int sysctl_tcp_tw_reuse; 2681da177e4SLinus Torvalds extern int sysctl_tcp_frto; 2691da177e4SLinus Torvalds extern int sysctl_tcp_low_latency; 2701da177e4SLinus Torvalds extern int sysctl_tcp_nometrics_save; 2711da177e4SLinus Torvalds extern int sysctl_tcp_moderate_rcvbuf; 2721da177e4SLinus Torvalds extern int sysctl_tcp_tso_win_divisor; 27315d99e02SRick Jones extern int sysctl_tcp_workaround_signed_windows; 27435089bb2SDavid S. Miller extern int sysctl_tcp_slow_start_after_idle; 27536e31b0aSAndreas Petlund extern int sysctl_tcp_thin_linear_timeouts; 2767e380175SAndreas Petlund extern int sysctl_tcp_thin_dupack; 277eed530b6SYuchung Cheng extern int sysctl_tcp_early_retrans; 27846d3ceabSEric Dumazet extern int sysctl_tcp_limit_output_bytes; 279282f23c6SEric Dumazet extern int sysctl_tcp_challenge_ack_limit; 280c9bee3b7SEric Dumazet extern unsigned int sysctl_tcp_notsent_lowat; 28195bd09ebSEric Dumazet extern int sysctl_tcp_min_tso_segs; 282f54b3111SEric Dumazet extern int sysctl_tcp_autocorking; 283032ee423SNeal Cardwell extern int sysctl_tcp_invalid_ratelimit; 2841da177e4SLinus Torvalds 2858d987e5cSEric Dumazet extern atomic_long_t tcp_memory_allocated; 2861748376bSEric Dumazet extern struct percpu_counter tcp_sockets_allocated; 2871da177e4SLinus Torvalds extern int tcp_memory_pressure; 2881da177e4SLinus Torvalds 289b8da51ebSEric Dumazet /* optimized version of sk_under_memory_pressure() for TCP sockets */ 290b8da51ebSEric Dumazet static inline bool tcp_under_memory_pressure(const struct sock *sk) 291b8da51ebSEric Dumazet { 292b8da51ebSEric Dumazet if (mem_cgroup_sockets_enabled && sk->sk_cgrp) 293b8da51ebSEric Dumazet return !!sk->sk_cgrp->memory_pressure; 294b8da51ebSEric Dumazet 295b8da51ebSEric Dumazet return tcp_memory_pressure; 296b8da51ebSEric Dumazet } 2971da177e4SLinus Torvalds /* 2981da177e4SLinus Torvalds * The next routines deal with comparing 32 bit unsigned ints 2991da177e4SLinus Torvalds * and worry about wraparound (automatic with unsigned arithmetic). 3001da177e4SLinus Torvalds */ 3011da177e4SLinus Torvalds 302a2a385d6SEric Dumazet static inline bool before(__u32 seq1, __u32 seq2) 3031da177e4SLinus Torvalds { 3040d630cc0SGerrit Renker return (__s32)(seq1-seq2) < 0; 3051da177e4SLinus Torvalds } 3069a036b9cSGerrit Renker #define after(seq2, seq1) before(seq1, seq2) 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds /* is s2<=s1<=s3 ? */ 309a2a385d6SEric Dumazet static inline bool between(__u32 seq1, __u32 seq2, __u32 seq3) 3101da177e4SLinus Torvalds { 3111da177e4SLinus Torvalds return seq3 - seq2 >= seq1 - seq2; 3121da177e4SLinus Torvalds } 3131da177e4SLinus Torvalds 314efcdbf24SArun Sharma static inline bool tcp_out_of_memory(struct sock *sk) 315efcdbf24SArun Sharma { 316efcdbf24SArun Sharma if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF && 317efcdbf24SArun Sharma sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2)) 318efcdbf24SArun Sharma return true; 319efcdbf24SArun Sharma return false; 320efcdbf24SArun Sharma } 321efcdbf24SArun Sharma 322a6c5ea4cSEric Dumazet void sk_forced_mem_schedule(struct sock *sk, int size); 323a6c5ea4cSEric Dumazet 324ad1af0feSDavid S. Miller static inline bool tcp_too_many_orphans(struct sock *sk, int shift) 325e4fd5da3SPavel Emelianov { 326ad1af0feSDavid S. Miller struct percpu_counter *ocp = sk->sk_prot->orphan_count; 327ad1af0feSDavid S. Miller int orphans = percpu_counter_read_positive(ocp); 328ad1af0feSDavid S. Miller 329ad1af0feSDavid S. Miller if (orphans << shift > sysctl_tcp_max_orphans) { 330ad1af0feSDavid S. Miller orphans = percpu_counter_sum_positive(ocp); 331ad1af0feSDavid S. Miller if (orphans << shift > sysctl_tcp_max_orphans) 332ad1af0feSDavid S. Miller return true; 333ad1af0feSDavid S. Miller } 334ad1af0feSDavid S. Miller return false; 335e4fd5da3SPavel Emelianov } 3361da177e4SLinus Torvalds 3375c9f3023SJoe Perches bool tcp_check_oom(struct sock *sk, int shift); 338efcdbf24SArun Sharma 339a0f82f64SFlorian Westphal 3401da177e4SLinus Torvalds extern struct proto tcp_prot; 3411da177e4SLinus Torvalds 34257ef42d5SPavel Emelyanov #define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field) 34357ef42d5SPavel Emelyanov #define TCP_INC_STATS_BH(net, field) SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field) 34457ef42d5SPavel Emelyanov #define TCP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->mib.tcp_statistics, field) 34557ef42d5SPavel Emelyanov #define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val) 346aa2ea058STom Herbert #define TCP_ADD_STATS(net, field, val) SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val) 3471da177e4SLinus Torvalds 3485c9f3023SJoe Perches void tcp_tasklet_init(void); 34946d3ceabSEric Dumazet 3505c9f3023SJoe Perches void tcp_v4_err(struct sk_buff *skb, u32); 3511da177e4SLinus Torvalds 3525c9f3023SJoe Perches void tcp_shutdown(struct sock *sk, int how); 3531da177e4SLinus Torvalds 3545c9f3023SJoe Perches void tcp_v4_early_demux(struct sk_buff *skb); 3555c9f3023SJoe Perches int tcp_v4_rcv(struct sk_buff *skb); 3561da177e4SLinus Torvalds 3575c9f3023SJoe Perches int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw); 3581b784140SYing Xue int tcp_sendmsg(struct sock *sk, struct msghdr *msg, 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 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp); 3725c9f3023SJoe Perches void tcp_twsk_destructor(struct sock *sk); 3735c9f3023SJoe Perches ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos, 37453d3176bSChangli Gao struct pipe_inode_info *pipe, size_t len, 37553d3176bSChangli Gao unsigned int flags); 3769c55e01cSJens Axboe 377463c84b9SArnaldo Carvalho de Melo static inline void tcp_dec_quickack_mode(struct sock *sk, 378463c84b9SArnaldo Carvalho de Melo const unsigned int pkts) 3791da177e4SLinus Torvalds { 380463c84b9SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 381fc6415bcSDavid S. Miller 382463c84b9SArnaldo Carvalho de Melo if (icsk->icsk_ack.quick) { 383463c84b9SArnaldo Carvalho de Melo if (pkts >= icsk->icsk_ack.quick) { 384463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick = 0; 3851da177e4SLinus Torvalds /* Leaving quickack mode we deflate ATO. */ 386463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.ato = TCP_ATO_MIN; 387fc6415bcSDavid S. Miller } else 388463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick -= pkts; 3891da177e4SLinus Torvalds } 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds 392bdf1ee5dSIlpo Järvinen #define TCP_ECN_OK 1 393bdf1ee5dSIlpo Järvinen #define TCP_ECN_QUEUE_CWR 2 394bdf1ee5dSIlpo Järvinen #define TCP_ECN_DEMAND_CWR 4 3957a269ffaSEric Dumazet #define TCP_ECN_SEEN 8 396bdf1ee5dSIlpo Järvinen 397fd2c3ef7SEric Dumazet enum tcp_tw_status { 3981da177e4SLinus Torvalds TCP_TW_SUCCESS = 0, 3991da177e4SLinus Torvalds TCP_TW_RST = 1, 4001da177e4SLinus Torvalds TCP_TW_ACK = 2, 4011da177e4SLinus Torvalds TCP_TW_SYN = 3 4021da177e4SLinus Torvalds }; 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds 4055c9f3023SJoe Perches enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw, 4061da177e4SLinus Torvalds struct sk_buff *skb, 4078feaf0c0SArnaldo Carvalho de Melo const struct tcphdr *th); 4085c9f3023SJoe Perches struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, 40952452c54SEric Dumazet struct request_sock *req, bool fastopen); 4105c9f3023SJoe Perches int tcp_child_process(struct sock *parent, struct sock *child, 4111da177e4SLinus Torvalds struct sk_buff *skb); 4125ae344c9SNeal Cardwell void tcp_enter_loss(struct sock *sk); 4135c9f3023SJoe Perches void tcp_clear_retrans(struct tcp_sock *tp); 4145c9f3023SJoe Perches void tcp_update_metrics(struct sock *sk); 4155c9f3023SJoe Perches void tcp_init_metrics(struct sock *sk); 4165c9f3023SJoe Perches void tcp_metrics_init(void); 4175c9f3023SJoe Perches bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst, 418a26552afSHannes Frederic Sowa bool paws_check, bool timestamps); 4195c9f3023SJoe Perches bool tcp_remember_stamp(struct sock *sk); 4205c9f3023SJoe Perches bool tcp_tw_remember_stamp(struct inet_timewait_sock *tw); 4215c9f3023SJoe Perches void tcp_fetch_timewait_stamp(struct sock *sk, struct dst_entry *dst); 4225c9f3023SJoe Perches void tcp_disable_fack(struct tcp_sock *tp); 4235c9f3023SJoe Perches void tcp_close(struct sock *sk, long timeout); 4245c9f3023SJoe Perches void tcp_init_sock(struct sock *sk); 4255c9f3023SJoe Perches unsigned int tcp_poll(struct file *file, struct socket *sock, 42653d3176bSChangli Gao struct poll_table_struct *wait); 4275c9f3023SJoe Perches int tcp_getsockopt(struct sock *sk, int level, int optname, 4283fdadf7dSDmitry Mishin char __user *optval, int __user *optlen); 4295c9f3023SJoe Perches int tcp_setsockopt(struct sock *sk, int level, int optname, 43053d3176bSChangli Gao char __user *optval, unsigned int optlen); 4315c9f3023SJoe Perches int compat_tcp_getsockopt(struct sock *sk, int level, int optname, 43253d3176bSChangli Gao char __user *optval, int __user *optlen); 4335c9f3023SJoe Perches int compat_tcp_setsockopt(struct sock *sk, int level, int optname, 434b7058842SDavid S. Miller char __user *optval, unsigned int optlen); 4355c9f3023SJoe Perches void tcp_set_keepalive(struct sock *sk, int val); 43642cb80a2SEric Dumazet void tcp_syn_ack_timeout(const struct request_sock *req); 4371b784140SYing Xue int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, 4381b784140SYing Xue int flags, int *addr_len); 4395c9f3023SJoe Perches void tcp_parse_options(const struct sk_buff *skb, 4401a2c6181SChristoph Paasch struct tcp_options_received *opt_rx, 4412100c8d2SYuchung Cheng int estab, struct tcp_fastopen_cookie *foc); 4425c9f3023SJoe Perches const u8 *tcp_parse_md5sig_option(const struct tcphdr *th); 4437d5d5525SYOSHIFUJI Hideaki 4441da177e4SLinus Torvalds /* 4451da177e4SLinus Torvalds * TCP v4 functions exported for the inet6 API 4461da177e4SLinus Torvalds */ 4471da177e4SLinus Torvalds 4485c9f3023SJoe Perches void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb); 4494fab9071SNeal Cardwell void tcp_v4_mtu_reduced(struct sock *sk); 45026e37360SEric Dumazet void tcp_req_err(struct sock *sk, u32 seq); 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); 45581164413SDaniel Borkmann void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst); 4565c9f3023SJoe Perches struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, 45760236fddSArnaldo Carvalho de Melo struct request_sock *req, 4581da177e4SLinus Torvalds struct dst_entry *dst); 4595c9f3023SJoe Perches int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb); 4605c9f3023SJoe Perches int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len); 4615c9f3023SJoe Perches int tcp_connect(struct sock *sk); 4625c9f3023SJoe Perches struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst, 463e6b4d113SWilliam Allen Simpson struct request_sock *req, 4648336886fSJerry Chu struct tcp_fastopen_cookie *foc); 4655c9f3023SJoe Perches int tcp_disconnect(struct sock *sk, int flags); 4661da177e4SLinus Torvalds 467370816aeSPavel Emelyanov void tcp_finish_connect(struct sock *sk, struct sk_buff *skb); 468292e8d8cSPavel Emelyanov int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size); 46963d02d15SEric Dumazet void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb); 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds /* From syncookies.c */ 472b80c0e78SEric Dumazet struct sock *tcp_get_cookie_sock(struct sock *sk, struct sk_buff *skb, 473b80c0e78SEric Dumazet struct request_sock *req, 474b80c0e78SEric Dumazet struct dst_entry *dst); 4755c9f3023SJoe Perches int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th, 4760198230bSPatrick McHardy u32 cookie); 477461b74c3SCong Wang struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb); 478e05c82d3SEric Dumazet #ifdef CONFIG_SYN_COOKIES 4798c27bd75SFlorian Westphal 48063262315SEric Dumazet /* Syncookies use a monotonic timer which increments every 60 seconds. 4818c27bd75SFlorian Westphal * This counter is used both as a hash input and partially encoded into 4828c27bd75SFlorian Westphal * the cookie value. A cookie is only validated further if the delta 4838c27bd75SFlorian Westphal * between the current counter value and the encoded one is less than this, 48463262315SEric Dumazet * i.e. a sent cookie is valid only at most for 2*60 seconds (or less if 4858c27bd75SFlorian Westphal * the counter advances immediately after a cookie is generated). 4868c27bd75SFlorian Westphal */ 4878c27bd75SFlorian Westphal #define MAX_SYNCOOKIE_AGE 2 488264ea103SEric Dumazet #define TCP_SYNCOOKIE_PERIOD (60 * HZ) 489264ea103SEric Dumazet #define TCP_SYNCOOKIE_VALID (MAX_SYNCOOKIE_AGE * TCP_SYNCOOKIE_PERIOD) 490264ea103SEric Dumazet 491264ea103SEric Dumazet /* syncookies: remember time of last synqueue overflow 492264ea103SEric Dumazet * But do not dirty this field too often (once per second is enough) 493264ea103SEric Dumazet */ 494264ea103SEric Dumazet static inline void tcp_synq_overflow(struct sock *sk) 495264ea103SEric Dumazet { 496264ea103SEric Dumazet unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp; 497264ea103SEric Dumazet unsigned long now = jiffies; 498264ea103SEric Dumazet 499264ea103SEric Dumazet if (time_after(now, last_overflow + HZ)) 500264ea103SEric Dumazet tcp_sk(sk)->rx_opt.ts_recent_stamp = now; 501264ea103SEric Dumazet } 502264ea103SEric Dumazet 503264ea103SEric Dumazet /* syncookies: no recent synqueue overflow on this listening socket? */ 504264ea103SEric Dumazet static inline bool tcp_synq_no_recent_overflow(const struct sock *sk) 505264ea103SEric Dumazet { 506264ea103SEric Dumazet unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp; 507264ea103SEric Dumazet 508264ea103SEric Dumazet return time_after(jiffies, last_overflow + TCP_SYNCOOKIE_VALID); 509264ea103SEric Dumazet } 5108c27bd75SFlorian Westphal 5118c27bd75SFlorian Westphal static inline u32 tcp_cookie_time(void) 5128c27bd75SFlorian Westphal { 51363262315SEric Dumazet u64 val = get_jiffies_64(); 51463262315SEric Dumazet 515264ea103SEric Dumazet do_div(val, TCP_SYNCOOKIE_PERIOD); 51663262315SEric Dumazet return val; 5178c27bd75SFlorian Westphal } 5188c27bd75SFlorian Westphal 5195c9f3023SJoe Perches u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr *th, 5205c9f3023SJoe Perches u16 *mssp); 52157b47553SOctavian Purdila __u32 cookie_v4_init_sequence(struct sock *sk, const struct sk_buff *skb, 52257b47553SOctavian Purdila __u16 *mss); 5235c9f3023SJoe Perches __u32 cookie_init_timestamp(struct request_sock *req); 524f1673381SFlorian Westphal bool cookie_timestamp_decode(struct tcp_options_received *opt); 525f1673381SFlorian Westphal bool cookie_ecn_ok(const struct tcp_options_received *opt, 526f7b3bec6SFlorian Westphal const struct net *net, const struct dst_entry *dst); 5274dfc2817SFlorian Westphal 528c6aefafbSGlenn Griffin /* From net/ipv6/syncookies.c */ 5295c9f3023SJoe Perches int __cookie_v6_check(const struct ipv6hdr *iph, const struct tcphdr *th, 53081eb6a14SPatrick McHardy u32 cookie); 5315c9f3023SJoe Perches struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb); 532f1673381SFlorian Westphal 5335c9f3023SJoe Perches u32 __cookie_v6_init_sequence(const struct ipv6hdr *iph, 53481eb6a14SPatrick McHardy const struct tcphdr *th, u16 *mssp); 5355c9f3023SJoe Perches __u32 cookie_v6_init_sequence(struct sock *sk, const struct sk_buff *skb, 536c6aefafbSGlenn Griffin __u16 *mss); 537e05c82d3SEric Dumazet #endif 5381da177e4SLinus Torvalds /* tcp_output.c */ 5391da177e4SLinus Torvalds 5405c9f3023SJoe Perches void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, 5419e412ba7SIlpo Järvinen int nonagle); 5425c9f3023SJoe Perches bool tcp_may_send_now(struct sock *sk); 5435c9f3023SJoe Perches int __tcp_retransmit_skb(struct sock *, struct sk_buff *); 5445c9f3023SJoe Perches int tcp_retransmit_skb(struct sock *, struct sk_buff *); 5455c9f3023SJoe Perches void tcp_retransmit_timer(struct sock *sk); 5465c9f3023SJoe Perches void tcp_xmit_retransmit_queue(struct sock *); 5475c9f3023SJoe Perches void tcp_simple_retransmit(struct sock *); 5485c9f3023SJoe Perches int tcp_trim_head(struct sock *, struct sk_buff *, u32); 5496cc55e09SOctavian Purdila int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int, gfp_t); 5501da177e4SLinus Torvalds 5515c9f3023SJoe Perches void tcp_send_probe0(struct sock *); 5525c9f3023SJoe Perches void tcp_send_partial(struct sock *); 553e520af48SEric Dumazet int tcp_write_wakeup(struct sock *, int mib); 5545c9f3023SJoe Perches void tcp_send_fin(struct sock *sk); 5555c9f3023SJoe Perches void tcp_send_active_reset(struct sock *sk, gfp_t priority); 5565c9f3023SJoe Perches int tcp_send_synack(struct sock *); 5575c9f3023SJoe Perches void tcp_push_one(struct sock *, unsigned int mss_now); 5585c9f3023SJoe Perches void tcp_send_ack(struct sock *sk); 5595c9f3023SJoe Perches void tcp_send_delayed_ack(struct sock *sk); 5605c9f3023SJoe Perches void tcp_send_loss_probe(struct sock *sk); 5615c9f3023SJoe Perches bool tcp_schedule_loss_probe(struct sock *sk); 5621da177e4SLinus Torvalds 563a762a980SDavid S. Miller /* tcp_input.c */ 5645c9f3023SJoe Perches void tcp_resume_early_retransmit(struct sock *sk); 5655c9f3023SJoe Perches void tcp_rearm_rto(struct sock *sk); 5665c9f3023SJoe Perches void tcp_reset(struct sock *sk); 567a762a980SDavid S. Miller 5681da177e4SLinus Torvalds /* tcp_timer.c */ 5695c9f3023SJoe Perches void tcp_init_xmit_timers(struct sock *); 570463c84b9SArnaldo Carvalho de Melo static inline void tcp_clear_xmit_timers(struct sock *sk) 571463c84b9SArnaldo Carvalho de Melo { 572463c84b9SArnaldo Carvalho de Melo inet_csk_clear_xmit_timers(sk); 573463c84b9SArnaldo Carvalho de Melo } 5741da177e4SLinus Torvalds 5755c9f3023SJoe Perches unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu); 5765c9f3023SJoe Perches unsigned int tcp_current_mss(struct sock *sk); 5770c54b85fSIlpo Järvinen 5780c54b85fSIlpo Järvinen /* Bound MSS / TSO packet size with the half of the window */ 5790c54b85fSIlpo Järvinen static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize) 5800c54b85fSIlpo Järvinen { 58101f83d69SAlexey Kuznetsov int cutoff; 58201f83d69SAlexey Kuznetsov 58301f83d69SAlexey Kuznetsov /* When peer uses tiny windows, there is no use in packetizing 58401f83d69SAlexey Kuznetsov * to sub-MSS pieces for the sake of SWS or making sure there 58501f83d69SAlexey Kuznetsov * are enough packets in the pipe for fast recovery. 58601f83d69SAlexey Kuznetsov * 58701f83d69SAlexey Kuznetsov * On the other hand, for extremely large MSS devices, handling 58801f83d69SAlexey Kuznetsov * smaller than MSS windows in this way does make sense. 58901f83d69SAlexey Kuznetsov */ 59001f83d69SAlexey Kuznetsov if (tp->max_window >= 512) 59101f83d69SAlexey Kuznetsov cutoff = (tp->max_window >> 1); 59201f83d69SAlexey Kuznetsov else 59301f83d69SAlexey Kuznetsov cutoff = tp->max_window; 59401f83d69SAlexey Kuznetsov 59501f83d69SAlexey Kuznetsov if (cutoff && pktsize > cutoff) 59601f83d69SAlexey Kuznetsov return max_t(int, cutoff, 68U - tp->tcp_header_len); 5970c54b85fSIlpo Järvinen else 5980c54b85fSIlpo Järvinen return pktsize; 5990c54b85fSIlpo Järvinen } 6001da177e4SLinus Torvalds 60117b085eaSArnaldo Carvalho de Melo /* tcp.c */ 6020df48c26SEric Dumazet void tcp_get_info(struct sock *, struct tcp_info *); 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds /* Read 'sendfile()'-style from a TCP socket */ 6051da177e4SLinus Torvalds typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, 6061da177e4SLinus Torvalds unsigned int, size_t); 6075c9f3023SJoe Perches int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, 6081da177e4SLinus Torvalds sk_read_actor_t recv_actor); 6091da177e4SLinus Torvalds 6105c9f3023SJoe Perches void tcp_initialize_rcv_mss(struct sock *sk); 6111da177e4SLinus Torvalds 6125c9f3023SJoe Perches int tcp_mtu_to_mss(struct sock *sk, int pmtu); 6135c9f3023SJoe Perches int tcp_mss_to_mtu(struct sock *sk, int mss); 6145c9f3023SJoe Perches void tcp_mtup_init(struct sock *sk); 6155c9f3023SJoe Perches void tcp_init_buffer_space(struct sock *sk); 6165d424d5aSJohn Heffner 617f1ecd5d9SDamian Lukowski static inline void tcp_bound_rto(const struct sock *sk) 618f1ecd5d9SDamian Lukowski { 619f1ecd5d9SDamian Lukowski if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX) 620f1ecd5d9SDamian Lukowski inet_csk(sk)->icsk_rto = TCP_RTO_MAX; 621f1ecd5d9SDamian Lukowski } 622f1ecd5d9SDamian Lukowski 623f1ecd5d9SDamian Lukowski static inline u32 __tcp_set_rto(const struct tcp_sock *tp) 624f1ecd5d9SDamian Lukowski { 625740b0f18SEric Dumazet return usecs_to_jiffies((tp->srtt_us >> 3) + tp->rttvar_us); 626f1ecd5d9SDamian Lukowski } 627f1ecd5d9SDamian Lukowski 62840efc6faSStephen Hemminger static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) 6291da177e4SLinus Torvalds { 6301da177e4SLinus Torvalds tp->pred_flags = htonl((tp->tcp_header_len << 26) | 6311da177e4SLinus Torvalds ntohl(TCP_FLAG_ACK) | 6321da177e4SLinus Torvalds snd_wnd); 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 63540efc6faSStephen Hemminger static inline void tcp_fast_path_on(struct tcp_sock *tp) 6361da177e4SLinus Torvalds { 6371da177e4SLinus Torvalds __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale); 6381da177e4SLinus Torvalds } 6391da177e4SLinus Torvalds 6409e412ba7SIlpo Järvinen static inline void tcp_fast_path_check(struct sock *sk) 6411da177e4SLinus Torvalds { 6429e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 6439e412ba7SIlpo Järvinen 644b03efcfbSDavid S. Miller if (skb_queue_empty(&tp->out_of_order_queue) && 6451da177e4SLinus Torvalds tp->rcv_wnd && 6461da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf && 6471da177e4SLinus Torvalds !tp->urg_data) 6481da177e4SLinus Torvalds tcp_fast_path_on(tp); 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6510c266898SSatoru SATOH /* Compute the actual rto_min value */ 6520c266898SSatoru SATOH static inline u32 tcp_rto_min(struct sock *sk) 6530c266898SSatoru SATOH { 654cf533ea5SEric Dumazet const struct dst_entry *dst = __sk_dst_get(sk); 6550c266898SSatoru SATOH u32 rto_min = TCP_RTO_MIN; 6560c266898SSatoru SATOH 6570c266898SSatoru SATOH if (dst && dst_metric_locked(dst, RTAX_RTO_MIN)) 6580c266898SSatoru SATOH rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN); 6590c266898SSatoru SATOH return rto_min; 6600c266898SSatoru SATOH } 6610c266898SSatoru SATOH 662740b0f18SEric Dumazet static inline u32 tcp_rto_min_us(struct sock *sk) 663740b0f18SEric Dumazet { 664740b0f18SEric Dumazet return jiffies_to_usecs(tcp_rto_min(sk)); 665740b0f18SEric Dumazet } 666740b0f18SEric Dumazet 66781164413SDaniel Borkmann static inline bool tcp_ca_dst_locked(const struct dst_entry *dst) 66881164413SDaniel Borkmann { 66981164413SDaniel Borkmann return dst_metric_locked(dst, RTAX_CC_ALGO); 67081164413SDaniel Borkmann } 67181164413SDaniel Borkmann 6721da177e4SLinus Torvalds /* Compute the actual receive window we are currently advertising. 6731da177e4SLinus Torvalds * Rcv_nxt can be after the window if our peer push more data 6741da177e4SLinus Torvalds * than the offered window. 6751da177e4SLinus Torvalds */ 67640efc6faSStephen Hemminger static inline u32 tcp_receive_window(const struct tcp_sock *tp) 6771da177e4SLinus Torvalds { 6781da177e4SLinus Torvalds s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds if (win < 0) 6811da177e4SLinus Torvalds win = 0; 6821da177e4SLinus Torvalds return (u32) win; 6831da177e4SLinus Torvalds } 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds /* Choose a new window, without checks for shrinking, and without 6861da177e4SLinus Torvalds * scaling applied to the result. The caller does these things 6871da177e4SLinus Torvalds * if necessary. This is a "raw" window selection. 6881da177e4SLinus Torvalds */ 6895c9f3023SJoe Perches u32 __tcp_select_window(struct sock *sk); 6901da177e4SLinus Torvalds 691ee995283SPavel Emelyanov void tcp_send_window_probe(struct sock *sk); 692ee995283SPavel Emelyanov 6931da177e4SLinus Torvalds /* TCP timestamps are only 32-bits, this causes a slight 6941da177e4SLinus Torvalds * complication on 64-bit systems since we store a snapshot 69531f34269SStephen Hemminger * of jiffies in the buffer control blocks below. We decided 69631f34269SStephen Hemminger * to use only the low 32-bits of jiffies and hide the ugly 6971da177e4SLinus Torvalds * casts with the following macro. 6981da177e4SLinus Torvalds */ 6991da177e4SLinus Torvalds #define tcp_time_stamp ((__u32)(jiffies)) 7001da177e4SLinus Torvalds 7017faee5c0SEric Dumazet static inline u32 tcp_skb_timestamp(const struct sk_buff *skb) 7027faee5c0SEric Dumazet { 7037faee5c0SEric Dumazet return skb->skb_mstamp.stamp_jiffies; 7047faee5c0SEric Dumazet } 7057faee5c0SEric Dumazet 7067faee5c0SEric Dumazet 707a3433f35SChangli Gao #define tcp_flag_byte(th) (((u_int8_t *)th)[13]) 708a3433f35SChangli Gao 709a3433f35SChangli Gao #define TCPHDR_FIN 0x01 710a3433f35SChangli Gao #define TCPHDR_SYN 0x02 711a3433f35SChangli Gao #define TCPHDR_RST 0x04 712a3433f35SChangli Gao #define TCPHDR_PSH 0x08 713a3433f35SChangli Gao #define TCPHDR_ACK 0x10 714a3433f35SChangli Gao #define TCPHDR_URG 0x20 715a3433f35SChangli Gao #define TCPHDR_ECE 0x40 716a3433f35SChangli Gao #define TCPHDR_CWR 0x80 717a3433f35SChangli Gao 71849213555SDaniel Borkmann #define TCPHDR_SYN_ECN (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR) 71949213555SDaniel Borkmann 720caa20d9aSStephen Hemminger /* This is what the send packet queuing engine uses to pass 721f86586faSEric Dumazet * TCP per-packet control information to the transmission code. 722f86586faSEric Dumazet * We also store the host-order sequence numbers in here too. 723f86586faSEric Dumazet * This is 44 bytes if IPV6 is enabled. 724f86586faSEric Dumazet * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately. 7251da177e4SLinus Torvalds */ 7261da177e4SLinus Torvalds struct tcp_skb_cb { 7271da177e4SLinus Torvalds __u32 seq; /* Starting sequence number */ 7281da177e4SLinus Torvalds __u32 end_seq; /* SEQ + FIN + SYN + datalen */ 729cd7d8498SEric Dumazet union { 730cd7d8498SEric Dumazet /* Note : tcp_tw_isn is used in input path only 731cd7d8498SEric Dumazet * (isn chosen by tcp_timewait_state_process()) 732cd7d8498SEric Dumazet * 733f69ad292SEric Dumazet * tcp_gso_segs/size are used in write queue only, 734f69ad292SEric Dumazet * cf tcp_skb_pcount()/tcp_skb_mss() 735cd7d8498SEric Dumazet */ 736cd7d8498SEric Dumazet __u32 tcp_tw_isn; 737f69ad292SEric Dumazet struct { 738f69ad292SEric Dumazet u16 tcp_gso_segs; 739f69ad292SEric Dumazet u16 tcp_gso_size; 740f69ad292SEric Dumazet }; 741cd7d8498SEric Dumazet }; 7424de075e0SEric Dumazet __u8 tcp_flags; /* TCP header flags. (tcp[13]) */ 743f4f9f6e7SNeal Cardwell 7441da177e4SLinus Torvalds __u8 sacked; /* State flags for SACK/FACK. */ 7451da177e4SLinus Torvalds #define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ 7461da177e4SLinus Torvalds #define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ 7471da177e4SLinus Torvalds #define TCPCB_LOST 0x04 /* SKB is lost */ 7481da177e4SLinus Torvalds #define TCPCB_TAGBITS 0x07 /* All tag bits */ 7499d186cacSAndrey Vagin #define TCPCB_REPAIRED 0x10 /* SKB repaired (no skb_mstamp) */ 7501da177e4SLinus Torvalds #define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */ 7519d186cacSAndrey Vagin #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS| \ 7529d186cacSAndrey Vagin TCPCB_REPAIRED) 7531da177e4SLinus Torvalds 754f4f9f6e7SNeal Cardwell __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */ 755f4f9f6e7SNeal Cardwell /* 1 byte hole */ 7561da177e4SLinus Torvalds __u32 ack_seq; /* Sequence number ACK'd */ 757971f10ecSEric Dumazet union { 758971f10ecSEric Dumazet struct inet_skb_parm h4; 759971f10ecSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 760971f10ecSEric Dumazet struct inet6_skb_parm h6; 761971f10ecSEric Dumazet #endif 762971f10ecSEric Dumazet } header; /* For incoming frames */ 7631da177e4SLinus Torvalds }; 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0])) 7661da177e4SLinus Torvalds 767870c3151SEric Dumazet 768815afe17SEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 769870c3151SEric Dumazet /* This is the variant of inet6_iif() that must be used by TCP, 770870c3151SEric Dumazet * as TCP moves IP6CB into a different location in skb->cb[] 771870c3151SEric Dumazet */ 772870c3151SEric Dumazet static inline int tcp_v6_iif(const struct sk_buff *skb) 773870c3151SEric Dumazet { 774870c3151SEric Dumazet return TCP_SKB_CB(skb)->header.h6.iif; 775870c3151SEric Dumazet } 776815afe17SEric Dumazet #endif 777870c3151SEric Dumazet 7781da177e4SLinus Torvalds /* Due to TSO, an SKB can be composed of multiple actual 7791da177e4SLinus Torvalds * packets. To keep these tracked properly, we use this. 7801da177e4SLinus Torvalds */ 7811da177e4SLinus Torvalds static inline int tcp_skb_pcount(const struct sk_buff *skb) 7821da177e4SLinus Torvalds { 783cd7d8498SEric Dumazet return TCP_SKB_CB(skb)->tcp_gso_segs; 784cd7d8498SEric Dumazet } 785cd7d8498SEric Dumazet 786cd7d8498SEric Dumazet static inline void tcp_skb_pcount_set(struct sk_buff *skb, int segs) 787cd7d8498SEric Dumazet { 788cd7d8498SEric Dumazet TCP_SKB_CB(skb)->tcp_gso_segs = segs; 789cd7d8498SEric Dumazet } 790cd7d8498SEric Dumazet 791cd7d8498SEric Dumazet static inline void tcp_skb_pcount_add(struct sk_buff *skb, int segs) 792cd7d8498SEric Dumazet { 793cd7d8498SEric Dumazet TCP_SKB_CB(skb)->tcp_gso_segs += segs; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 796f69ad292SEric Dumazet /* This is valid iff skb is in write queue and tcp_skb_pcount() > 1. */ 7971da177e4SLinus Torvalds static inline int tcp_skb_mss(const struct sk_buff *skb) 7981da177e4SLinus Torvalds { 799f69ad292SEric Dumazet return TCP_SKB_CB(skb)->tcp_gso_size; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds 802317a76f9SStephen Hemminger /* Events passed to congestion control interface */ 803317a76f9SStephen Hemminger enum tcp_ca_event { 804317a76f9SStephen Hemminger CA_EVENT_TX_START, /* first transmit when no packets in flight */ 805317a76f9SStephen Hemminger CA_EVENT_CWND_RESTART, /* congestion window restart */ 806317a76f9SStephen Hemminger CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */ 807317a76f9SStephen Hemminger CA_EVENT_LOSS, /* loss timeout */ 8089890092eSFlorian Westphal CA_EVENT_ECN_NO_CE, /* ECT set, but not CE marked */ 8099890092eSFlorian Westphal CA_EVENT_ECN_IS_CE, /* received CE marked IP packet */ 8109890092eSFlorian Westphal CA_EVENT_DELAYED_ACK, /* Delayed ack is sent */ 8119890092eSFlorian Westphal CA_EVENT_NON_DELAYED_ACK, 8127354c8c3SFlorian Westphal }; 8137354c8c3SFlorian Westphal 8149890092eSFlorian Westphal /* Information about inbound ACK, passed to cong_ops->in_ack_event() */ 8157354c8c3SFlorian Westphal enum tcp_ca_ack_event_flags { 8169890092eSFlorian Westphal CA_ACK_SLOWPATH = (1 << 0), /* In slow path processing */ 8179890092eSFlorian Westphal CA_ACK_WIN_UPDATE = (1 << 1), /* ACK updated window */ 8189890092eSFlorian Westphal CA_ACK_ECE = (1 << 2), /* ECE bit is set on ack */ 819317a76f9SStephen Hemminger }; 820317a76f9SStephen Hemminger 821317a76f9SStephen Hemminger /* 822317a76f9SStephen Hemminger * Interface for adding new TCP congestion control handlers 823317a76f9SStephen Hemminger */ 824317a76f9SStephen Hemminger #define TCP_CA_NAME_MAX 16 8253ff825b2SStephen Hemminger #define TCP_CA_MAX 128 8263ff825b2SStephen Hemminger #define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX) 8273ff825b2SStephen Hemminger 828c5c6a8abSDaniel Borkmann #define TCP_CA_UNSPEC 0 829c5c6a8abSDaniel Borkmann 83030e502a3SDaniel Borkmann /* Algorithm can be set on socket without CAP_NET_ADMIN privileges */ 831164891aaSStephen Hemminger #define TCP_CONG_NON_RESTRICTED 0x1 83230e502a3SDaniel Borkmann /* Requires ECN/ECT set on all packets */ 83330e502a3SDaniel Borkmann #define TCP_CONG_NEEDS_ECN 0x2 834164891aaSStephen Hemminger 83564f40ff5SEric Dumazet union tcp_cc_info; 83664f40ff5SEric Dumazet 837317a76f9SStephen Hemminger struct tcp_congestion_ops { 838317a76f9SStephen Hemminger struct list_head list; 839c5c6a8abSDaniel Borkmann u32 key; 840c5c6a8abSDaniel Borkmann u32 flags; 841317a76f9SStephen Hemminger 842317a76f9SStephen Hemminger /* initialize private data (optional) */ 8436687e988SArnaldo Carvalho de Melo void (*init)(struct sock *sk); 844317a76f9SStephen Hemminger /* cleanup private data (optional) */ 8456687e988SArnaldo Carvalho de Melo void (*release)(struct sock *sk); 846317a76f9SStephen Hemminger 847317a76f9SStephen Hemminger /* return slow start threshold (required) */ 8486687e988SArnaldo Carvalho de Melo u32 (*ssthresh)(struct sock *sk); 849317a76f9SStephen Hemminger /* do new cwnd calculation (required) */ 85024901551SEric Dumazet void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked); 851317a76f9SStephen Hemminger /* call before changing ca_state (optional) */ 8526687e988SArnaldo Carvalho de Melo void (*set_state)(struct sock *sk, u8 new_state); 853317a76f9SStephen Hemminger /* call when cwnd event occurs (optional) */ 8546687e988SArnaldo Carvalho de Melo void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev); 8557354c8c3SFlorian Westphal /* call when ack arrives (optional) */ 8567354c8c3SFlorian Westphal void (*in_ack_event)(struct sock *sk, u32 flags); 857317a76f9SStephen Hemminger /* new value of cwnd after loss (optional) */ 8586687e988SArnaldo Carvalho de Melo u32 (*undo_cwnd)(struct sock *sk); 859317a76f9SStephen Hemminger /* hook for packet ack accounting (optional) */ 86030cfd0baSStephen Hemminger void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us); 86173c1f4a0SArnaldo Carvalho de Melo /* get info for inet_diag (optional) */ 86264f40ff5SEric Dumazet size_t (*get_info)(struct sock *sk, u32 ext, int *attr, 86364f40ff5SEric Dumazet union tcp_cc_info *info); 864317a76f9SStephen Hemminger 865317a76f9SStephen Hemminger char name[TCP_CA_NAME_MAX]; 866317a76f9SStephen Hemminger struct module *owner; 867317a76f9SStephen Hemminger }; 868317a76f9SStephen Hemminger 8695c9f3023SJoe Perches int tcp_register_congestion_control(struct tcp_congestion_ops *type); 8705c9f3023SJoe Perches void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); 871317a76f9SStephen Hemminger 87255d8694fSFlorian Westphal void tcp_assign_congestion_control(struct sock *sk); 8735c9f3023SJoe Perches void tcp_init_congestion_control(struct sock *sk); 8745c9f3023SJoe Perches void tcp_cleanup_congestion_control(struct sock *sk); 8755c9f3023SJoe Perches int tcp_set_default_congestion_control(const char *name); 8765c9f3023SJoe Perches void tcp_get_default_congestion_control(char *name); 8775c9f3023SJoe Perches void tcp_get_available_congestion_control(char *buf, size_t len); 8785c9f3023SJoe Perches void tcp_get_allowed_congestion_control(char *buf, size_t len); 8795c9f3023SJoe Perches int tcp_set_allowed_congestion_control(char *allowed); 8805c9f3023SJoe Perches int tcp_set_congestion_control(struct sock *sk, const char *name); 881e73ebb08SNeal Cardwell u32 tcp_slow_start(struct tcp_sock *tp, u32 acked); 882e73ebb08SNeal Cardwell void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w, u32 acked); 883317a76f9SStephen Hemminger 8845c9f3023SJoe Perches u32 tcp_reno_ssthresh(struct sock *sk); 88524901551SEric Dumazet void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked); 886a8acfbacSDavid S. Miller extern struct tcp_congestion_ops tcp_reno; 887317a76f9SStephen Hemminger 888c5c6a8abSDaniel Borkmann struct tcp_congestion_ops *tcp_ca_find_key(u32 key); 889c5c6a8abSDaniel Borkmann u32 tcp_ca_get_key_by_name(const char *name); 890ea697639SDaniel Borkmann #ifdef CONFIG_INET 891c5c6a8abSDaniel Borkmann char *tcp_ca_get_name_by_key(u32 key, char *buffer); 892ea697639SDaniel Borkmann #else 893ea697639SDaniel Borkmann static inline char *tcp_ca_get_name_by_key(u32 key, char *buffer) 894ea697639SDaniel Borkmann { 895ea697639SDaniel Borkmann return NULL; 896ea697639SDaniel Borkmann } 897ea697639SDaniel Borkmann #endif 898c5c6a8abSDaniel Borkmann 89930e502a3SDaniel Borkmann static inline bool tcp_ca_needs_ecn(const struct sock *sk) 90030e502a3SDaniel Borkmann { 90130e502a3SDaniel Borkmann const struct inet_connection_sock *icsk = inet_csk(sk); 90230e502a3SDaniel Borkmann 90330e502a3SDaniel Borkmann return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ECN; 90430e502a3SDaniel Borkmann } 90530e502a3SDaniel Borkmann 9066687e988SArnaldo Carvalho de Melo static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state) 907317a76f9SStephen Hemminger { 9086687e988SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 9096687e988SArnaldo Carvalho de Melo 9106687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->set_state) 9116687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->set_state(sk, ca_state); 9126687e988SArnaldo Carvalho de Melo icsk->icsk_ca_state = ca_state; 913317a76f9SStephen Hemminger } 914317a76f9SStephen Hemminger 9156687e988SArnaldo Carvalho de Melo static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) 916317a76f9SStephen Hemminger { 9176687e988SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 9186687e988SArnaldo Carvalho de Melo 9196687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->cwnd_event) 9206687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->cwnd_event(sk, event); 921317a76f9SStephen Hemminger } 922317a76f9SStephen Hemminger 923e60402d0SIlpo Järvinen /* These functions determine how the current flow behaves in respect of SACK 924e60402d0SIlpo Järvinen * handling. SACK is negotiated with the peer, and therefore it can vary 925e60402d0SIlpo Järvinen * between different flows. 926e60402d0SIlpo Järvinen * 927e60402d0SIlpo Järvinen * tcp_is_sack - SACK enabled 928e60402d0SIlpo Järvinen * tcp_is_reno - No SACK 929e60402d0SIlpo Järvinen * tcp_is_fack - FACK enabled, implies SACK enabled 930e60402d0SIlpo Järvinen */ 931e60402d0SIlpo Järvinen static inline int tcp_is_sack(const struct tcp_sock *tp) 932e60402d0SIlpo Järvinen { 933e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok; 934e60402d0SIlpo Järvinen } 935e60402d0SIlpo Järvinen 936a2a385d6SEric Dumazet static inline bool tcp_is_reno(const struct tcp_sock *tp) 937e60402d0SIlpo Järvinen { 938e60402d0SIlpo Järvinen return !tcp_is_sack(tp); 939e60402d0SIlpo Järvinen } 940e60402d0SIlpo Järvinen 941a2a385d6SEric Dumazet static inline bool tcp_is_fack(const struct tcp_sock *tp) 942e60402d0SIlpo Järvinen { 943ab56222aSVijay Subramanian return tp->rx_opt.sack_ok & TCP_FACK_ENABLED; 944e60402d0SIlpo Järvinen } 945e60402d0SIlpo Järvinen 946e60402d0SIlpo Järvinen static inline void tcp_enable_fack(struct tcp_sock *tp) 947e60402d0SIlpo Järvinen { 948ab56222aSVijay Subramanian tp->rx_opt.sack_ok |= TCP_FACK_ENABLED; 949e60402d0SIlpo Järvinen } 950e60402d0SIlpo Järvinen 951eed530b6SYuchung Cheng /* TCP early-retransmit (ER) is similar to but more conservative than 952eed530b6SYuchung Cheng * the thin-dupack feature. Enable ER only if thin-dupack is disabled. 953eed530b6SYuchung Cheng */ 954eed530b6SYuchung Cheng static inline void tcp_enable_early_retrans(struct tcp_sock *tp) 955eed530b6SYuchung Cheng { 956eed530b6SYuchung Cheng tp->do_early_retrans = sysctl_tcp_early_retrans && 9576ba8a3b1SNandita Dukkipati sysctl_tcp_early_retrans < 4 && !sysctl_tcp_thin_dupack && 9586ba8a3b1SNandita Dukkipati sysctl_tcp_reordering == 3; 959eed530b6SYuchung Cheng } 960eed530b6SYuchung Cheng 961eed530b6SYuchung Cheng static inline void tcp_disable_early_retrans(struct tcp_sock *tp) 962eed530b6SYuchung Cheng { 963eed530b6SYuchung Cheng tp->do_early_retrans = 0; 964eed530b6SYuchung Cheng } 965eed530b6SYuchung Cheng 96683ae4088SIlpo Järvinen static inline unsigned int tcp_left_out(const struct tcp_sock *tp) 96783ae4088SIlpo Järvinen { 96883ae4088SIlpo Järvinen return tp->sacked_out + tp->lost_out; 96983ae4088SIlpo Järvinen } 97083ae4088SIlpo Järvinen 9711da177e4SLinus Torvalds /* This determines how many packets are "in the network" to the best 9721da177e4SLinus Torvalds * of our knowledge. In many cases it is conservative, but where 9731da177e4SLinus Torvalds * detailed information is available from the receiver (via SACK 9741da177e4SLinus Torvalds * blocks etc.) we can make more aggressive calculations. 9751da177e4SLinus Torvalds * 9761da177e4SLinus Torvalds * Use this for decisions involving congestion control, use just 9771da177e4SLinus Torvalds * tp->packets_out to determine if the send queue is empty or not. 9781da177e4SLinus Torvalds * 9791da177e4SLinus Torvalds * Read this equation as: 9801da177e4SLinus Torvalds * 9811da177e4SLinus Torvalds * "Packets sent once on transmission queue" MINUS 9821da177e4SLinus Torvalds * "Packets left network, but not honestly ACKed yet" PLUS 9831da177e4SLinus Torvalds * "Packets fast retransmitted" 9841da177e4SLinus Torvalds */ 98540efc6faSStephen Hemminger static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) 9861da177e4SLinus Torvalds { 98783ae4088SIlpo Järvinen return tp->packets_out - tcp_left_out(tp) + tp->retrans_out; 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds 9900b6a05c1SIlpo Järvinen #define TCP_INFINITE_SSTHRESH 0x7fffffff 9910b6a05c1SIlpo Järvinen 992071d5080SYuchung Cheng static inline bool tcp_in_slow_start(const struct tcp_sock *tp) 993071d5080SYuchung Cheng { 994*76174004SYuchung Cheng return tp->snd_cwnd < tp->snd_ssthresh; 995071d5080SYuchung Cheng } 996071d5080SYuchung Cheng 9970b6a05c1SIlpo Järvinen static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp) 9980b6a05c1SIlpo Järvinen { 9990b6a05c1SIlpo Järvinen return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH; 10000b6a05c1SIlpo Järvinen } 10010b6a05c1SIlpo Järvinen 1002684bad11SYuchung Cheng static inline bool tcp_in_cwnd_reduction(const struct sock *sk) 1003684bad11SYuchung Cheng { 1004684bad11SYuchung Cheng return (TCPF_CA_CWR | TCPF_CA_Recovery) & 1005684bad11SYuchung Cheng (1 << inet_csk(sk)->icsk_ca_state); 1006684bad11SYuchung Cheng } 1007684bad11SYuchung Cheng 10081da177e4SLinus Torvalds /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd. 1009684bad11SYuchung Cheng * The exception is cwnd reduction phase, when cwnd is decreasing towards 10101da177e4SLinus Torvalds * ssthresh. 10111da177e4SLinus Torvalds */ 10126687e988SArnaldo Carvalho de Melo static inline __u32 tcp_current_ssthresh(const struct sock *sk) 10131da177e4SLinus Torvalds { 10146687e988SArnaldo Carvalho de Melo const struct tcp_sock *tp = tcp_sk(sk); 1015cf533ea5SEric Dumazet 1016684bad11SYuchung Cheng if (tcp_in_cwnd_reduction(sk)) 10171da177e4SLinus Torvalds return tp->snd_ssthresh; 10181da177e4SLinus Torvalds else 10191da177e4SLinus Torvalds return max(tp->snd_ssthresh, 10201da177e4SLinus Torvalds ((tp->snd_cwnd >> 1) + 10211da177e4SLinus Torvalds (tp->snd_cwnd >> 2))); 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds 1024b9c4595bSIlpo Järvinen /* Use define here intentionally to get WARN_ON location shown at the caller */ 1025b9c4595bSIlpo Järvinen #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out) 10261da177e4SLinus Torvalds 10275ee2c941SChristoph Paasch void tcp_enter_cwr(struct sock *sk); 10285c9f3023SJoe Perches __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst); 10291da177e4SLinus Torvalds 10306b5a5c0dSNeal Cardwell /* The maximum number of MSS of available cwnd for which TSO defers 10316b5a5c0dSNeal Cardwell * sending if not using sysctl_tcp_tso_win_divisor. 10326b5a5c0dSNeal Cardwell */ 10336b5a5c0dSNeal Cardwell static inline __u32 tcp_max_tso_deferred_mss(const struct tcp_sock *tp) 10346b5a5c0dSNeal Cardwell { 10356b5a5c0dSNeal Cardwell return 3; 10366b5a5c0dSNeal Cardwell } 10376b5a5c0dSNeal Cardwell 10381da177e4SLinus Torvalds /* Slow start with delack produces 3 packets of burst, so that 1039dd9e0ddaSJohn Heffner * it is safe "de facto". This will be the default - same as 1040dd9e0ddaSJohn Heffner * the default reordering threshold - but if reordering increases, 1041dd9e0ddaSJohn Heffner * we must be able to allow cwnd to burst at least this much in order 1042dd9e0ddaSJohn Heffner * to not pull it back when holes are filled. 10431da177e4SLinus Torvalds */ 10441da177e4SLinus Torvalds static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp) 10451da177e4SLinus Torvalds { 1046dd9e0ddaSJohn Heffner return tp->reordering; 10471da177e4SLinus Torvalds } 10481da177e4SLinus Torvalds 104990840defSIlpo Järvinen /* Returns end sequence number of the receiver's advertised window */ 105090840defSIlpo Järvinen static inline u32 tcp_wnd_end(const struct tcp_sock *tp) 105190840defSIlpo Järvinen { 105290840defSIlpo Järvinen return tp->snd_una + tp->snd_wnd; 105390840defSIlpo Järvinen } 1054e114a710SEric Dumazet 1055e114a710SEric Dumazet /* We follow the spirit of RFC2861 to validate cwnd but implement a more 1056e114a710SEric Dumazet * flexible approach. The RFC suggests cwnd should not be raised unless 1057ca8a2263SNeal Cardwell * it was fully used previously. And that's exactly what we do in 1058ca8a2263SNeal Cardwell * congestion avoidance mode. But in slow start we allow cwnd to grow 1059ca8a2263SNeal Cardwell * as long as the application has used half the cwnd. 1060e114a710SEric Dumazet * Example : 1061e114a710SEric Dumazet * cwnd is 10 (IW10), but application sends 9 frames. 1062e114a710SEric Dumazet * We allow cwnd to reach 18 when all frames are ACKed. 1063e114a710SEric Dumazet * This check is safe because it's as aggressive as slow start which already 1064e114a710SEric Dumazet * risks 100% overshoot. The advantage is that we discourage application to 1065e114a710SEric Dumazet * either send more filler packets or data to artificially blow up the cwnd 1066e114a710SEric Dumazet * usage, and allow application-limited process to probe bw more aggressively. 1067e114a710SEric Dumazet */ 106824901551SEric Dumazet static inline bool tcp_is_cwnd_limited(const struct sock *sk) 1069e114a710SEric Dumazet { 1070e114a710SEric Dumazet const struct tcp_sock *tp = tcp_sk(sk); 1071e114a710SEric Dumazet 1072ca8a2263SNeal Cardwell /* If in slow start, ensure cwnd grows to twice what was ACKed. */ 1073071d5080SYuchung Cheng if (tcp_in_slow_start(tp)) 1074ca8a2263SNeal Cardwell return tp->snd_cwnd < 2 * tp->max_packets_out; 1075ca8a2263SNeal Cardwell 1076ca8a2263SNeal Cardwell return tp->is_cwnd_limited; 1077e114a710SEric Dumazet } 1078f4805edeSStephen Hemminger 107921c8fe99SEric Dumazet /* Something is really bad, we could not queue an additional packet, 108021c8fe99SEric Dumazet * because qdisc is full or receiver sent a 0 window. 108121c8fe99SEric Dumazet * We do not want to add fuel to the fire, or abort too early, 108221c8fe99SEric Dumazet * so make sure the timer we arm now is at least 200ms in the future, 108321c8fe99SEric Dumazet * regardless of current icsk_rto value (as it could be ~2ms) 108421c8fe99SEric Dumazet */ 108521c8fe99SEric Dumazet static inline unsigned long tcp_probe0_base(const struct sock *sk) 108621c8fe99SEric Dumazet { 108721c8fe99SEric Dumazet return max_t(unsigned long, inet_csk(sk)->icsk_rto, TCP_RTO_MIN); 108821c8fe99SEric Dumazet } 108921c8fe99SEric Dumazet 109021c8fe99SEric Dumazet /* Variant of inet_csk_rto_backoff() used for zero window probes */ 109121c8fe99SEric Dumazet static inline unsigned long tcp_probe0_when(const struct sock *sk, 109221c8fe99SEric Dumazet unsigned long max_when) 109321c8fe99SEric Dumazet { 109421c8fe99SEric Dumazet u64 when = (u64)tcp_probe0_base(sk) << inet_csk(sk)->icsk_backoff; 109521c8fe99SEric Dumazet 109621c8fe99SEric Dumazet return (unsigned long)min_t(u64, when, max_when); 109721c8fe99SEric Dumazet } 109821c8fe99SEric Dumazet 10999e412ba7SIlpo Järvinen static inline void tcp_check_probe_timer(struct sock *sk) 11001da177e4SLinus Torvalds { 110121c8fe99SEric Dumazet if (!tcp_sk(sk)->packets_out && !inet_csk(sk)->icsk_pending) 11023f421baaSArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0, 110321c8fe99SEric Dumazet tcp_probe0_base(sk), TCP_RTO_MAX); 11041da177e4SLinus Torvalds } 11051da177e4SLinus Torvalds 1106ee7537b6SHantzis Fotis static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq) 11071da177e4SLinus Torvalds { 11081da177e4SLinus Torvalds tp->snd_wl1 = seq; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds 1111ee7537b6SHantzis Fotis static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq) 11121da177e4SLinus Torvalds { 11131da177e4SLinus Torvalds tp->snd_wl1 = seq; 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds /* 11171da177e4SLinus Torvalds * Calculate(/check) TCP checksum 11181da177e4SLinus Torvalds */ 1119ba7808eaSFrederik Deweerdt static inline __sum16 tcp_v4_check(int len, __be32 saddr, 1120ba7808eaSFrederik Deweerdt __be32 daddr, __wsum base) 11211da177e4SLinus Torvalds { 11221da177e4SLinus Torvalds return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); 11231da177e4SLinus Torvalds } 11241da177e4SLinus Torvalds 1125b51655b9SAl Viro static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb) 11261da177e4SLinus Torvalds { 1127fb286bb2SHerbert Xu return __skb_checksum_complete(skb); 11281da177e4SLinus Torvalds } 11291da177e4SLinus Torvalds 1130a2a385d6SEric Dumazet static inline bool tcp_checksum_complete(struct sk_buff *skb) 11311da177e4SLinus Torvalds { 113260476372SHerbert Xu return !skb_csum_unnecessary(skb) && 11331da177e4SLinus Torvalds __tcp_checksum_complete(skb); 11341da177e4SLinus Torvalds } 11351da177e4SLinus Torvalds 11361da177e4SLinus Torvalds /* Prequeue for VJ style copy to user, combined with checksumming. */ 11371da177e4SLinus Torvalds 113840efc6faSStephen Hemminger static inline void tcp_prequeue_init(struct tcp_sock *tp) 11391da177e4SLinus Torvalds { 11401da177e4SLinus Torvalds tp->ucopy.task = NULL; 11411da177e4SLinus Torvalds tp->ucopy.len = 0; 11421da177e4SLinus Torvalds tp->ucopy.memory = 0; 11431da177e4SLinus Torvalds skb_queue_head_init(&tp->ucopy.prequeue); 11441da177e4SLinus Torvalds } 11451da177e4SLinus Torvalds 11465c9f3023SJoe Perches bool tcp_prequeue(struct sock *sk, struct sk_buff *skb); 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds #undef STATE_TRACE 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds #ifdef STATE_TRACE 11511da177e4SLinus Torvalds static const char *statename[]={ 11521da177e4SLinus Torvalds "Unused","Established","Syn Sent","Syn Recv", 11531da177e4SLinus Torvalds "Fin Wait 1","Fin Wait 2","Time Wait", "Close", 11541da177e4SLinus Torvalds "Close Wait","Last ACK","Listen","Closing" 11551da177e4SLinus Torvalds }; 11561da177e4SLinus Torvalds #endif 11575c9f3023SJoe Perches void tcp_set_state(struct sock *sk, int state); 11581da177e4SLinus Torvalds 11595c9f3023SJoe Perches void tcp_done(struct sock *sk); 11601da177e4SLinus Torvalds 116140efc6faSStephen Hemminger static inline void tcp_sack_reset(struct tcp_options_received *rx_opt) 11621da177e4SLinus Torvalds { 11631da177e4SLinus Torvalds rx_opt->dsack = 0; 11641da177e4SLinus Torvalds rx_opt->num_sacks = 0; 11651da177e4SLinus Torvalds } 11661da177e4SLinus Torvalds 11675c9f3023SJoe Perches u32 tcp_default_init_rwnd(u32 mss); 116885f16525SYuchung Cheng 11691da177e4SLinus Torvalds /* Determine a window scaling and initial window to offer. */ 11705c9f3023SJoe Perches void tcp_select_initial_window(int __space, __u32 mss, __u32 *rcv_wnd, 11715c9f3023SJoe Perches __u32 *window_clamp, int wscale_ok, 11725c9f3023SJoe Perches __u8 *rcv_wscale, __u32 init_rcv_wnd); 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds static inline int tcp_win_from_space(int space) 11751da177e4SLinus Torvalds { 11761da177e4SLinus Torvalds return sysctl_tcp_adv_win_scale<=0 ? 11771da177e4SLinus Torvalds (space>>(-sysctl_tcp_adv_win_scale)) : 11781da177e4SLinus Torvalds space - (space>>sysctl_tcp_adv_win_scale); 11791da177e4SLinus Torvalds } 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds /* Note: caller must be prepared to deal with negative returns */ 11821da177e4SLinus Torvalds static inline int tcp_space(const struct sock *sk) 11831da177e4SLinus Torvalds { 11841da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf - 11851da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc)); 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds static inline int tcp_full_space(const struct sock *sk) 11891da177e4SLinus Torvalds { 11901da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf); 11911da177e4SLinus Torvalds } 11921da177e4SLinus Torvalds 1193843f4a55SYuchung Cheng extern void tcp_openreq_init_rwin(struct request_sock *req, 1194843f4a55SYuchung Cheng struct sock *sk, struct dst_entry *dst); 1195843f4a55SYuchung Cheng 11965c9f3023SJoe Perches void tcp_enter_memory_pressure(struct sock *sk); 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds static inline int keepalive_intvl_when(const struct tcp_sock *tp) 11991da177e4SLinus Torvalds { 12001da177e4SLinus Torvalds return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl; 12011da177e4SLinus Torvalds } 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds static inline int keepalive_time_when(const struct tcp_sock *tp) 12041da177e4SLinus Torvalds { 12051da177e4SLinus Torvalds return tp->keepalive_time ? : sysctl_tcp_keepalive_time; 12061da177e4SLinus Torvalds } 12071da177e4SLinus Torvalds 1208df19a626SEric Dumazet static inline int keepalive_probes(const struct tcp_sock *tp) 1209df19a626SEric Dumazet { 1210df19a626SEric Dumazet return tp->keepalive_probes ? : sysctl_tcp_keepalive_probes; 1211df19a626SEric Dumazet } 1212df19a626SEric Dumazet 12136c37e5deSFlavio Leitner static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp) 12146c37e5deSFlavio Leitner { 12156c37e5deSFlavio Leitner const struct inet_connection_sock *icsk = &tp->inet_conn; 12166c37e5deSFlavio Leitner 12176c37e5deSFlavio Leitner return min_t(u32, tcp_time_stamp - icsk->icsk_ack.lrcvtime, 12186c37e5deSFlavio Leitner tcp_time_stamp - tp->rcv_tstamp); 12196c37e5deSFlavio Leitner } 12206c37e5deSFlavio Leitner 1221463c84b9SArnaldo Carvalho de Melo static inline int tcp_fin_time(const struct sock *sk) 12221da177e4SLinus Torvalds { 1223463c84b9SArnaldo Carvalho de Melo int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout; 1224463c84b9SArnaldo Carvalho de Melo const int rto = inet_csk(sk)->icsk_rto; 12251da177e4SLinus Torvalds 1226463c84b9SArnaldo Carvalho de Melo if (fin_timeout < (rto << 2) - (rto >> 1)) 1227463c84b9SArnaldo Carvalho de Melo fin_timeout = (rto << 2) - (rto >> 1); 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds return fin_timeout; 12301da177e4SLinus Torvalds } 12311da177e4SLinus Torvalds 1232a2a385d6SEric Dumazet static inline bool tcp_paws_check(const struct tcp_options_received *rx_opt, 1233c887e6d2SIlpo Järvinen int paws_win) 12341da177e4SLinus Torvalds { 1235c887e6d2SIlpo Järvinen if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win) 1236a2a385d6SEric Dumazet return true; 1237c887e6d2SIlpo Järvinen if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)) 1238a2a385d6SEric Dumazet return true; 1239bc2ce894SEric Dumazet /* 1240bc2ce894SEric Dumazet * Some OSes send SYN and SYNACK messages with tsval=0 tsecr=0, 1241bc2ce894SEric Dumazet * then following tcp messages have valid values. Ignore 0 value, 1242bc2ce894SEric Dumazet * or else 'negative' tsval might forbid us to accept their packets. 1243bc2ce894SEric Dumazet */ 1244bc2ce894SEric Dumazet if (!rx_opt->ts_recent) 1245a2a385d6SEric Dumazet return true; 1246a2a385d6SEric Dumazet return false; 1247c887e6d2SIlpo Järvinen } 1248c887e6d2SIlpo Järvinen 1249a2a385d6SEric Dumazet static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt, 1250c887e6d2SIlpo Järvinen int rst) 1251c887e6d2SIlpo Järvinen { 1252c887e6d2SIlpo Järvinen if (tcp_paws_check(rx_opt, 0)) 1253a2a385d6SEric Dumazet return false; 12541da177e4SLinus Torvalds 12551da177e4SLinus Torvalds /* RST segments are not recommended to carry timestamp, 12561da177e4SLinus Torvalds and, if they do, it is recommended to ignore PAWS because 12571da177e4SLinus Torvalds "their cleanup function should take precedence over timestamps." 12581da177e4SLinus Torvalds Certainly, it is mistake. It is necessary to understand the reasons 12591da177e4SLinus Torvalds of this constraint to relax it: if peer reboots, clock may go 12601da177e4SLinus Torvalds out-of-sync and half-open connections will not be reset. 12611da177e4SLinus Torvalds Actually, the problem would be not existing if all 12621da177e4SLinus Torvalds the implementations followed draft about maintaining clock 12631da177e4SLinus Torvalds via reboots. Linux-2.2 DOES NOT! 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds However, we can relax time bounds for RST segments to MSL. 12661da177e4SLinus Torvalds */ 12679d729f72SJames Morris if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL) 1268a2a385d6SEric Dumazet return false; 1269a2a385d6SEric Dumazet return true; 12701da177e4SLinus Torvalds } 12711da177e4SLinus Torvalds 12727970ddc8SEric Dumazet bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb, 12737970ddc8SEric Dumazet int mib_idx, u32 *last_oow_ack_time); 1274032ee423SNeal Cardwell 1275a9c19329SPavel Emelyanov static inline void tcp_mib_init(struct net *net) 12761da177e4SLinus Torvalds { 12771da177e4SLinus Torvalds /* See RFC 2012 */ 1278cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOALGORITHM, 1); 1279cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ); 1280cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ); 1281cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_MAXCONN, -1); 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds 12846a438bbeSStephen Hemminger /* from STCP */ 1285ef9da47cSIlpo Järvinen static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp) 12860800f170SDavid S. Miller { 12876a438bbeSStephen Hemminger tp->lost_skb_hint = NULL; 1288ef9da47cSIlpo Järvinen } 1289ef9da47cSIlpo Järvinen 1290ef9da47cSIlpo Järvinen static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp) 1291ef9da47cSIlpo Järvinen { 1292ef9da47cSIlpo Järvinen tcp_clear_retrans_hints_partial(tp); 12936a438bbeSStephen Hemminger tp->retransmit_skb_hint = NULL; 1294b7689205SIlpo Järvinen } 1295b7689205SIlpo Järvinen 1296cfb6eeb4SYOSHIFUJI Hideaki /* MD5 Signature */ 1297cfb6eeb4SYOSHIFUJI Hideaki struct crypto_hash; 1298cfb6eeb4SYOSHIFUJI Hideaki 1299a915da9bSEric Dumazet union tcp_md5_addr { 1300a915da9bSEric Dumazet struct in_addr a4; 1301a915da9bSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 1302a915da9bSEric Dumazet struct in6_addr a6; 1303a915da9bSEric Dumazet #endif 1304a915da9bSEric Dumazet }; 1305a915da9bSEric Dumazet 1306cfb6eeb4SYOSHIFUJI Hideaki /* - key database */ 1307cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key { 1308a915da9bSEric Dumazet struct hlist_node node; 1309cfb6eeb4SYOSHIFUJI Hideaki u8 keylen; 1310a915da9bSEric Dumazet u8 family; /* AF_INET or AF_INET6 */ 1311a915da9bSEric Dumazet union tcp_md5_addr addr; 1312a915da9bSEric Dumazet u8 key[TCP_MD5SIG_MAXKEYLEN]; 1313a915da9bSEric Dumazet struct rcu_head rcu; 1314cfb6eeb4SYOSHIFUJI Hideaki }; 1315cfb6eeb4SYOSHIFUJI Hideaki 1316cfb6eeb4SYOSHIFUJI Hideaki /* - sock block */ 1317cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_info { 1318a915da9bSEric Dumazet struct hlist_head head; 1319a8afca03SEric Dumazet struct rcu_head rcu; 1320cfb6eeb4SYOSHIFUJI Hideaki }; 1321cfb6eeb4SYOSHIFUJI Hideaki 1322cfb6eeb4SYOSHIFUJI Hideaki /* - pseudo header */ 1323cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr { 1324cfb6eeb4SYOSHIFUJI Hideaki __be32 saddr; 1325cfb6eeb4SYOSHIFUJI Hideaki __be32 daddr; 1326cfb6eeb4SYOSHIFUJI Hideaki __u8 pad; 1327cfb6eeb4SYOSHIFUJI Hideaki __u8 protocol; 1328cfb6eeb4SYOSHIFUJI Hideaki __be16 len; 1329cfb6eeb4SYOSHIFUJI Hideaki }; 1330cfb6eeb4SYOSHIFUJI Hideaki 1331cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr { 1332cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr saddr; 1333cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr daddr; 1334cfb6eeb4SYOSHIFUJI Hideaki __be32 len; 1335cfb6eeb4SYOSHIFUJI Hideaki __be32 protocol; /* including padding */ 1336cfb6eeb4SYOSHIFUJI Hideaki }; 1337cfb6eeb4SYOSHIFUJI Hideaki 1338cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block { 1339cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr ip4; 1340dfd56b8bSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 1341cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr ip6; 1342cfb6eeb4SYOSHIFUJI Hideaki #endif 1343cfb6eeb4SYOSHIFUJI Hideaki }; 1344cfb6eeb4SYOSHIFUJI Hideaki 1345cfb6eeb4SYOSHIFUJI Hideaki /* - pool: digest algorithm, hash description and scratch buffer */ 1346cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool { 1347cfb6eeb4SYOSHIFUJI Hideaki struct hash_desc md5_desc; 1348cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block md5_blk; 1349cfb6eeb4SYOSHIFUJI Hideaki }; 1350cfb6eeb4SYOSHIFUJI Hideaki 1351cfb6eeb4SYOSHIFUJI Hideaki /* - functions */ 135239f8e58eSEric Dumazet int tcp_v4_md5_hash_skb(char *md5_hash, const struct tcp_md5sig_key *key, 135339f8e58eSEric Dumazet const struct sock *sk, const struct sk_buff *skb); 13545c9f3023SJoe Perches int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr, 13555c9f3023SJoe Perches int family, const u8 *newkey, u8 newkeylen, gfp_t gfp); 13565c9f3023SJoe Perches int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, 1357a915da9bSEric Dumazet int family); 13585c9f3023SJoe Perches struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk, 1359fd3a154aSEric Dumazet const struct sock *addr_sk); 1360cfb6eeb4SYOSHIFUJI Hideaki 13619501f972SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 13625c9f3023SJoe Perches struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk, 13635c9f3023SJoe Perches const union tcp_md5_addr *addr, 13645c9f3023SJoe Perches int family); 1365a915da9bSEric Dumazet #define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_key) 13669501f972SYOSHIFUJI Hideaki #else 1367a915da9bSEric Dumazet static inline struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk, 1368a915da9bSEric Dumazet const union tcp_md5_addr *addr, 1369a915da9bSEric Dumazet int family) 1370a915da9bSEric Dumazet { 1371a915da9bSEric Dumazet return NULL; 1372a915da9bSEric Dumazet } 13739501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) NULL 13749501f972SYOSHIFUJI Hideaki #endif 13759501f972SYOSHIFUJI Hideaki 13765c9f3023SJoe Perches bool tcp_alloc_md5sig_pool(void); 1377cfb6eeb4SYOSHIFUJI Hideaki 13785c9f3023SJoe Perches struct tcp_md5sig_pool *tcp_get_md5sig_pool(void); 137971cea17eSEric Dumazet static inline void tcp_put_md5sig_pool(void) 138071cea17eSEric Dumazet { 138171cea17eSEric Dumazet local_bh_enable(); 138271cea17eSEric Dumazet } 138335790c04SEric Dumazet 13845c9f3023SJoe Perches int tcp_md5_hash_header(struct tcp_md5sig_pool *, const struct tcphdr *); 13855c9f3023SJoe Perches int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *, 138695c96174SEric Dumazet unsigned int header_len); 13875c9f3023SJoe Perches int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, 1388cf533ea5SEric Dumazet const struct tcp_md5sig_key *key); 1389cfb6eeb4SYOSHIFUJI Hideaki 139010467163SJerry Chu /* From tcp_fastopen.c */ 13915c9f3023SJoe Perches void tcp_fastopen_cache_get(struct sock *sk, u16 *mss, 13925c9f3023SJoe Perches struct tcp_fastopen_cookie *cookie, int *syn_loss, 13935c9f3023SJoe Perches unsigned long *last_syn_loss); 13945c9f3023SJoe Perches void tcp_fastopen_cache_set(struct sock *sk, u16 mss, 13952646c831SDaniel Lee struct tcp_fastopen_cookie *cookie, bool syn_lost, 13962646c831SDaniel Lee u16 try_exp); 1397783237e8SYuchung Cheng struct tcp_fastopen_request { 1398783237e8SYuchung Cheng /* Fast Open cookie. Size 0 means a cookie request */ 1399783237e8SYuchung Cheng struct tcp_fastopen_cookie cookie; 1400783237e8SYuchung Cheng struct msghdr *data; /* data in MSG_FASTOPEN */ 1401f5ddcbbbSEric Dumazet size_t size; 1402f5ddcbbbSEric Dumazet int copied; /* queued in tcp_connect() */ 1403783237e8SYuchung Cheng }; 1404783237e8SYuchung Cheng void tcp_free_fastopen_req(struct tcp_sock *tp); 1405783237e8SYuchung Cheng 140610467163SJerry Chu extern struct tcp_fastopen_context __rcu *tcp_fastopen_ctx; 140710467163SJerry Chu int tcp_fastopen_reset_cipher(void *key, unsigned int len); 1408843f4a55SYuchung Cheng bool tcp_try_fastopen(struct sock *sk, struct sk_buff *skb, 14095b7ed089SYuchung Cheng struct request_sock *req, 1410843f4a55SYuchung Cheng struct tcp_fastopen_cookie *foc, 1411843f4a55SYuchung Cheng struct dst_entry *dst); 1412222e83d2SHannes Frederic Sowa void tcp_fastopen_init_key_once(bool publish); 141310467163SJerry Chu #define TCP_FASTOPEN_KEY_LENGTH 16 141410467163SJerry Chu 141510467163SJerry Chu /* Fastopen key context */ 141610467163SJerry Chu struct tcp_fastopen_context { 14177ae8639cSEric Dumazet struct crypto_cipher *tfm; 141810467163SJerry Chu __u8 key[TCP_FASTOPEN_KEY_LENGTH]; 141910467163SJerry Chu struct rcu_head rcu; 142010467163SJerry Chu }; 142110467163SJerry Chu 1422fe067e8aSDavid S. Miller /* write queue abstraction */ 1423fe067e8aSDavid S. Miller static inline void tcp_write_queue_purge(struct sock *sk) 1424fe067e8aSDavid S. Miller { 1425fe067e8aSDavid S. Miller struct sk_buff *skb; 1426fe067e8aSDavid S. Miller 1427fe067e8aSDavid S. Miller while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) 14283ab224beSHideo Aoki sk_wmem_free_skb(sk, skb); 14293ab224beSHideo Aoki sk_mem_reclaim(sk); 14308818a9d8SIlpo Järvinen tcp_clear_all_retrans_hints(tcp_sk(sk)); 1431fe067e8aSDavid S. Miller } 1432fe067e8aSDavid S. Miller 1433cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk) 1434fe067e8aSDavid S. Miller { 1435cd07a8eaSDavid S. Miller return skb_peek(&sk->sk_write_queue); 1436fe067e8aSDavid S. Miller } 1437fe067e8aSDavid S. Miller 1438cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk) 1439fe067e8aSDavid S. Miller { 1440cd07a8eaSDavid S. Miller return skb_peek_tail(&sk->sk_write_queue); 1441fe067e8aSDavid S. Miller } 1442fe067e8aSDavid S. Miller 1443cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_next(const struct sock *sk, 1444cf533ea5SEric Dumazet const struct sk_buff *skb) 1445fe067e8aSDavid S. Miller { 1446cd07a8eaSDavid S. Miller return skb_queue_next(&sk->sk_write_queue, skb); 1447fe067e8aSDavid S. Miller } 1448fe067e8aSDavid S. Miller 1449cf533ea5SEric Dumazet static inline struct sk_buff *tcp_write_queue_prev(const struct sock *sk, 1450cf533ea5SEric Dumazet const struct sk_buff *skb) 1451832d11c5SIlpo Järvinen { 1452832d11c5SIlpo Järvinen return skb_queue_prev(&sk->sk_write_queue, skb); 1453832d11c5SIlpo Järvinen } 1454832d11c5SIlpo Järvinen 1455fe067e8aSDavid S. Miller #define tcp_for_write_queue(skb, sk) \ 1456cd07a8eaSDavid S. Miller skb_queue_walk(&(sk)->sk_write_queue, skb) 1457fe067e8aSDavid S. Miller 1458fe067e8aSDavid S. Miller #define tcp_for_write_queue_from(skb, sk) \ 1459cd07a8eaSDavid S. Miller skb_queue_walk_from(&(sk)->sk_write_queue, skb) 1460fe067e8aSDavid S. Miller 1461234b6860SIlpo Järvinen #define tcp_for_write_queue_from_safe(skb, tmp, sk) \ 1462cd07a8eaSDavid S. Miller skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp) 1463234b6860SIlpo Järvinen 1464cf533ea5SEric Dumazet static inline struct sk_buff *tcp_send_head(const struct sock *sk) 1465fe067e8aSDavid S. Miller { 1466fe067e8aSDavid S. Miller return sk->sk_send_head; 1467fe067e8aSDavid S. Miller } 1468fe067e8aSDavid S. Miller 1469cd07a8eaSDavid S. Miller static inline bool tcp_skb_is_last(const struct sock *sk, 1470cd07a8eaSDavid S. Miller const struct sk_buff *skb) 1471cd07a8eaSDavid S. Miller { 1472cd07a8eaSDavid S. Miller return skb_queue_is_last(&sk->sk_write_queue, skb); 1473cd07a8eaSDavid S. Miller } 1474cd07a8eaSDavid S. Miller 1475cf533ea5SEric Dumazet static inline void tcp_advance_send_head(struct sock *sk, const struct sk_buff *skb) 1476fe067e8aSDavid S. Miller { 1477cd07a8eaSDavid S. Miller if (tcp_skb_is_last(sk, skb)) 1478fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1479cd07a8eaSDavid S. Miller else 1480cd07a8eaSDavid S. Miller sk->sk_send_head = tcp_write_queue_next(sk, skb); 1481fe067e8aSDavid S. Miller } 1482fe067e8aSDavid S. Miller 1483fe067e8aSDavid S. Miller static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked) 1484fe067e8aSDavid S. Miller { 1485fe067e8aSDavid S. Miller if (sk->sk_send_head == skb_unlinked) 1486fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1487fe067e8aSDavid S. Miller } 1488fe067e8aSDavid S. Miller 1489fe067e8aSDavid S. Miller static inline void tcp_init_send_head(struct sock *sk) 1490fe067e8aSDavid S. Miller { 1491fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1492fe067e8aSDavid S. Miller } 1493fe067e8aSDavid S. Miller 1494fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1495fe067e8aSDavid S. Miller { 1496fe067e8aSDavid S. Miller __skb_queue_tail(&sk->sk_write_queue, skb); 1497fe067e8aSDavid S. Miller } 1498fe067e8aSDavid S. Miller 1499fe067e8aSDavid S. Miller static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1500fe067e8aSDavid S. Miller { 1501fe067e8aSDavid S. Miller __tcp_add_write_queue_tail(sk, skb); 1502fe067e8aSDavid S. Miller 1503fe067e8aSDavid S. Miller /* Queue it, remembering where we must start sending. */ 15046859d494SIlpo Järvinen if (sk->sk_send_head == NULL) { 1505fe067e8aSDavid S. Miller sk->sk_send_head = skb; 15066859d494SIlpo Järvinen 15076859d494SIlpo Järvinen if (tcp_sk(sk)->highest_sack == NULL) 15086859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = skb; 15096859d494SIlpo Järvinen } 1510fe067e8aSDavid S. Miller } 1511fe067e8aSDavid S. Miller 1512fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb) 1513fe067e8aSDavid S. Miller { 1514fe067e8aSDavid S. Miller __skb_queue_head(&sk->sk_write_queue, skb); 1515fe067e8aSDavid S. Miller } 1516fe067e8aSDavid S. Miller 1517fe067e8aSDavid S. Miller /* Insert buff after skb on the write queue of sk. */ 1518fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_after(struct sk_buff *skb, 1519fe067e8aSDavid S. Miller struct sk_buff *buff, 1520fe067e8aSDavid S. Miller struct sock *sk) 1521fe067e8aSDavid S. Miller { 15227de6c033SGerrit Renker __skb_queue_after(&sk->sk_write_queue, skb, buff); 1523fe067e8aSDavid S. Miller } 1524fe067e8aSDavid S. Miller 152543f59c89SDavid S. Miller /* Insert new before skb on the write queue of sk. */ 1526fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_before(struct sk_buff *new, 1527fe067e8aSDavid S. Miller struct sk_buff *skb, 1528fe067e8aSDavid S. Miller struct sock *sk) 1529fe067e8aSDavid S. Miller { 153043f59c89SDavid S. Miller __skb_queue_before(&sk->sk_write_queue, skb, new); 15316e421410SIlpo Järvinen 15326e421410SIlpo Järvinen if (sk->sk_send_head == skb) 15336e421410SIlpo Järvinen sk->sk_send_head = new; 1534fe067e8aSDavid S. Miller } 1535fe067e8aSDavid S. Miller 1536fe067e8aSDavid S. Miller static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk) 1537fe067e8aSDavid S. Miller { 1538fe067e8aSDavid S. Miller __skb_unlink(skb, &sk->sk_write_queue); 1539fe067e8aSDavid S. Miller } 1540fe067e8aSDavid S. Miller 1541a2a385d6SEric Dumazet static inline bool tcp_write_queue_empty(struct sock *sk) 1542fe067e8aSDavid S. Miller { 1543fe067e8aSDavid S. Miller return skb_queue_empty(&sk->sk_write_queue); 1544fe067e8aSDavid S. Miller } 1545fe067e8aSDavid S. Miller 154612d50c46SKrishna Kumar static inline void tcp_push_pending_frames(struct sock *sk) 154712d50c46SKrishna Kumar { 154812d50c46SKrishna Kumar if (tcp_send_head(sk)) { 154912d50c46SKrishna Kumar struct tcp_sock *tp = tcp_sk(sk); 155012d50c46SKrishna Kumar 155112d50c46SKrishna Kumar __tcp_push_pending_frames(sk, tcp_current_mss(sk), tp->nonagle); 155212d50c46SKrishna Kumar } 155312d50c46SKrishna Kumar } 155412d50c46SKrishna Kumar 1555ecb97192SNeal Cardwell /* Start sequence of the skb just after the highest skb with SACKed 1556ecb97192SNeal Cardwell * bit, valid only if sacked_out > 0 or when the caller has ensured 1557ecb97192SNeal Cardwell * validity by itself. 1558a47e5a98SIlpo Järvinen */ 1559a47e5a98SIlpo Järvinen static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp) 1560a47e5a98SIlpo Järvinen { 1561a47e5a98SIlpo Järvinen if (!tp->sacked_out) 1562a47e5a98SIlpo Järvinen return tp->snd_una; 15636859d494SIlpo Järvinen 15646859d494SIlpo Järvinen if (tp->highest_sack == NULL) 15656859d494SIlpo Järvinen return tp->snd_nxt; 15666859d494SIlpo Järvinen 1567a47e5a98SIlpo Järvinen return TCP_SKB_CB(tp->highest_sack)->seq; 1568a47e5a98SIlpo Järvinen } 1569a47e5a98SIlpo Järvinen 15706859d494SIlpo Järvinen static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb) 15716859d494SIlpo Järvinen { 15726859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_skb_is_last(sk, skb) ? NULL : 15736859d494SIlpo Järvinen tcp_write_queue_next(sk, skb); 15746859d494SIlpo Järvinen } 15756859d494SIlpo Järvinen 15766859d494SIlpo Järvinen static inline struct sk_buff *tcp_highest_sack(struct sock *sk) 15776859d494SIlpo Järvinen { 15786859d494SIlpo Järvinen return tcp_sk(sk)->highest_sack; 15796859d494SIlpo Järvinen } 15806859d494SIlpo Järvinen 15816859d494SIlpo Järvinen static inline void tcp_highest_sack_reset(struct sock *sk) 15826859d494SIlpo Järvinen { 15836859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk); 15846859d494SIlpo Järvinen } 15856859d494SIlpo Järvinen 15866859d494SIlpo Järvinen /* Called when old skb is about to be deleted (to be combined with new skb) */ 15876859d494SIlpo Järvinen static inline void tcp_highest_sack_combine(struct sock *sk, 15886859d494SIlpo Järvinen struct sk_buff *old, 15896859d494SIlpo Järvinen struct sk_buff *new) 15906859d494SIlpo Järvinen { 15916859d494SIlpo Järvinen if (tcp_sk(sk)->sacked_out && (old == tcp_sk(sk)->highest_sack)) 15926859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = new; 15936859d494SIlpo Järvinen } 15946859d494SIlpo Järvinen 15955aa4b32fSAndreas Petlund /* Determines whether this is a thin stream (which may suffer from 15965aa4b32fSAndreas Petlund * increased latency). Used to trigger latency-reducing mechanisms. 15975aa4b32fSAndreas Petlund */ 1598a2a385d6SEric Dumazet static inline bool tcp_stream_is_thin(struct tcp_sock *tp) 15995aa4b32fSAndreas Petlund { 16005aa4b32fSAndreas Petlund return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp); 16015aa4b32fSAndreas Petlund } 16025aa4b32fSAndreas Petlund 16031da177e4SLinus Torvalds /* /proc */ 16041da177e4SLinus Torvalds enum tcp_seq_states { 16051da177e4SLinus Torvalds TCP_SEQ_STATE_LISTENING, 16061da177e4SLinus Torvalds TCP_SEQ_STATE_OPENREQ, 16071da177e4SLinus Torvalds TCP_SEQ_STATE_ESTABLISHED, 16081da177e4SLinus Torvalds }; 16091da177e4SLinus Torvalds 161073cb88ecSArjan van de Ven int tcp_seq_open(struct inode *inode, struct file *file); 161173cb88ecSArjan van de Ven 16121da177e4SLinus Torvalds struct tcp_seq_afinfo { 16131da177e4SLinus Torvalds char *name; 16141da177e4SLinus Torvalds sa_family_t family; 161573cb88ecSArjan van de Ven const struct file_operations *seq_fops; 16169427c4b3SDenis V. Lunev struct seq_operations seq_ops; 16171da177e4SLinus Torvalds }; 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds struct tcp_iter_state { 1620a4146b1bSDenis V. Lunev struct seq_net_private p; 16211da177e4SLinus Torvalds sa_family_t family; 16221da177e4SLinus Torvalds enum tcp_seq_states state; 16231da177e4SLinus Torvalds struct sock *syn_wait_sk; 1624a7cb5a49SEric W. Biederman int bucket, offset, sbucket, num; 1625a7cb5a49SEric W. Biederman kuid_t uid; 1626a8b690f9STom Herbert loff_t last_pos; 16271da177e4SLinus Torvalds }; 16281da177e4SLinus Torvalds 16295c9f3023SJoe Perches int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo); 16305c9f3023SJoe Perches void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo); 16311da177e4SLinus Torvalds 163220380731SArnaldo Carvalho de Melo extern struct request_sock_ops tcp_request_sock_ops; 1633c6aefafbSGlenn Griffin extern struct request_sock_ops tcp6_request_sock_ops; 163420380731SArnaldo Carvalho de Melo 16355c9f3023SJoe Perches void tcp_v4_destroy_sock(struct sock *sk); 163620380731SArnaldo Carvalho de Melo 163728be6e07SEric Dumazet struct sk_buff *tcp_gso_segment(struct sk_buff *skb, 1638c8f44affSMichał Mirosław netdev_features_t features); 16395c9f3023SJoe Perches struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb); 16405c9f3023SJoe Perches int tcp_gro_complete(struct sk_buff *skb); 164128850dc7SDaniel Borkmann 16425c9f3023SJoe Perches void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr); 1643f4c50d99SHerbert Xu 1644c9bee3b7SEric Dumazet static inline u32 tcp_notsent_lowat(const struct tcp_sock *tp) 1645c9bee3b7SEric Dumazet { 1646c9bee3b7SEric Dumazet return tp->notsent_lowat ?: sysctl_tcp_notsent_lowat; 1647c9bee3b7SEric Dumazet } 1648c9bee3b7SEric Dumazet 1649c9bee3b7SEric Dumazet static inline bool tcp_stream_memory_free(const struct sock *sk) 1650c9bee3b7SEric Dumazet { 1651c9bee3b7SEric Dumazet const struct tcp_sock *tp = tcp_sk(sk); 1652c9bee3b7SEric Dumazet u32 notsent_bytes = tp->write_seq - tp->snd_nxt; 1653c9bee3b7SEric Dumazet 1654c9bee3b7SEric Dumazet return notsent_bytes < tcp_notsent_lowat(tp); 1655c9bee3b7SEric Dumazet } 1656c9bee3b7SEric Dumazet 165720380731SArnaldo Carvalho de Melo #ifdef CONFIG_PROC_FS 16585c9f3023SJoe Perches int tcp4_proc_init(void); 16595c9f3023SJoe Perches void tcp4_proc_exit(void); 166020380731SArnaldo Carvalho de Melo #endif 166120380731SArnaldo Carvalho de Melo 16625db92c99SOctavian Purdila int tcp_rtx_synack(struct sock *sk, struct request_sock *req); 16631fb6f159SOctavian Purdila int tcp_conn_request(struct request_sock_ops *rsk_ops, 16641fb6f159SOctavian Purdila const struct tcp_request_sock_ops *af_ops, 16651fb6f159SOctavian Purdila struct sock *sk, struct sk_buff *skb); 16665db92c99SOctavian Purdila 1667cfb6eeb4SYOSHIFUJI Hideaki /* TCP af-specific functions */ 1668cfb6eeb4SYOSHIFUJI Hideaki struct tcp_sock_af_ops { 1669cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1670cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1671fd3a154aSEric Dumazet const struct sock *addr_sk); 1672cfb6eeb4SYOSHIFUJI Hideaki int (*calc_md5_hash)(char *location, 167339f8e58eSEric Dumazet const struct tcp_md5sig_key *md5, 1674318cf7aaSEric Dumazet const struct sock *sk, 1675318cf7aaSEric Dumazet const struct sk_buff *skb); 1676cfb6eeb4SYOSHIFUJI Hideaki int (*md5_parse)(struct sock *sk, 1677cfb6eeb4SYOSHIFUJI Hideaki char __user *optval, 1678cfb6eeb4SYOSHIFUJI Hideaki int optlen); 1679cfb6eeb4SYOSHIFUJI Hideaki #endif 1680cfb6eeb4SYOSHIFUJI Hideaki }; 1681cfb6eeb4SYOSHIFUJI Hideaki 1682cfb6eeb4SYOSHIFUJI Hideaki struct tcp_request_sock_ops { 16832aec4a29SOctavian Purdila u16 mss_clamp; 1684cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1685fd3a154aSEric Dumazet struct tcp_md5sig_key *(*req_md5_lookup)(struct sock *sk, 1686fd3a154aSEric Dumazet const struct sock *addr_sk); 1687e3afe7b7SJohn Dykstra int (*calc_md5_hash) (char *location, 168839f8e58eSEric Dumazet const struct tcp_md5sig_key *md5, 1689318cf7aaSEric Dumazet const struct sock *sk, 1690318cf7aaSEric Dumazet const struct sk_buff *skb); 1691cfb6eeb4SYOSHIFUJI Hideaki #endif 169216bea70aSOctavian Purdila void (*init_req)(struct request_sock *req, struct sock *sk, 169316bea70aSOctavian Purdila struct sk_buff *skb); 1694fb7b37a7SOctavian Purdila #ifdef CONFIG_SYN_COOKIES 1695fb7b37a7SOctavian Purdila __u32 (*cookie_init_seq)(struct sock *sk, const struct sk_buff *skb, 1696fb7b37a7SOctavian Purdila __u16 *mss); 1697fb7b37a7SOctavian Purdila #endif 1698d94e0417SOctavian Purdila struct dst_entry *(*route_req)(struct sock *sk, struct flowi *fl, 1699d94e0417SOctavian Purdila const struct request_sock *req, 1700d94e0417SOctavian Purdila bool *strict); 1701936b8bdbSOctavian Purdila __u32 (*init_seq)(const struct sk_buff *skb); 1702d6274bd8SOctavian Purdila int (*send_synack)(struct sock *sk, struct dst_entry *dst, 1703d6274bd8SOctavian Purdila struct flowi *fl, struct request_sock *req, 1704d6274bd8SOctavian Purdila u16 queue_mapping, struct tcp_fastopen_cookie *foc); 1705695da14eSOctavian Purdila void (*queue_hash_add)(struct sock *sk, struct request_sock *req, 1706695da14eSOctavian Purdila const unsigned long timeout); 1707cfb6eeb4SYOSHIFUJI Hideaki }; 1708cfb6eeb4SYOSHIFUJI Hideaki 1709fb7b37a7SOctavian Purdila #ifdef CONFIG_SYN_COOKIES 1710fb7b37a7SOctavian Purdila static inline __u32 cookie_init_sequence(const struct tcp_request_sock_ops *ops, 1711fb7b37a7SOctavian Purdila struct sock *sk, struct sk_buff *skb, 1712fb7b37a7SOctavian Purdila __u16 *mss) 1713fb7b37a7SOctavian Purdila { 1714fb7b37a7SOctavian Purdila return ops->cookie_init_seq(sk, skb, mss); 1715fb7b37a7SOctavian Purdila } 1716fb7b37a7SOctavian Purdila #else 1717fb7b37a7SOctavian Purdila static inline __u32 cookie_init_sequence(const struct tcp_request_sock_ops *ops, 1718fb7b37a7SOctavian Purdila struct sock *sk, struct sk_buff *skb, 1719fb7b37a7SOctavian Purdila __u16 *mss) 1720fb7b37a7SOctavian Purdila { 1721fb7b37a7SOctavian Purdila return 0; 1722fb7b37a7SOctavian Purdila } 1723fb7b37a7SOctavian Purdila #endif 1724fb7b37a7SOctavian Purdila 17255c9f3023SJoe Perches int tcpv4_offload_init(void); 172628850dc7SDaniel Borkmann 17275c9f3023SJoe Perches void tcp_v4_init(void); 17285c9f3023SJoe Perches void tcp_init(void); 172920380731SArnaldo Carvalho de Melo 1730e25f866fSCong Wang /* 1731e25f866fSCong Wang * Save and compile IPv4 options, return a pointer to it 1732e25f866fSCong Wang */ 1733e25f866fSCong Wang static inline struct ip_options_rcu *tcp_v4_save_options(struct sk_buff *skb) 1734e25f866fSCong Wang { 1735e25f866fSCong Wang const struct ip_options *opt = &TCP_SKB_CB(skb)->header.h4.opt; 1736e25f866fSCong Wang struct ip_options_rcu *dopt = NULL; 1737e25f866fSCong Wang 1738461b74c3SCong Wang if (opt->optlen) { 1739e25f866fSCong Wang int opt_size = sizeof(*dopt) + opt->optlen; 1740e25f866fSCong Wang 1741e25f866fSCong Wang dopt = kmalloc(opt_size, GFP_ATOMIC); 1742e25f866fSCong Wang if (dopt && __ip_options_echo(&dopt->opt, skb, opt)) { 1743e25f866fSCong Wang kfree(dopt); 1744e25f866fSCong Wang dopt = NULL; 1745e25f866fSCong Wang } 1746e25f866fSCong Wang } 1747e25f866fSCong Wang return dopt; 1748e25f866fSCong Wang } 1749e25f866fSCong Wang 175098781965SEric Dumazet /* locally generated TCP pure ACKs have skb->truesize == 2 175198781965SEric Dumazet * (check tcp_send_ack() in net/ipv4/tcp_output.c ) 175298781965SEric Dumazet * This is much faster than dissecting the packet to find out. 175398781965SEric Dumazet * (Think of GRE encapsulations, IPv4, IPv6, ...) 175498781965SEric Dumazet */ 175598781965SEric Dumazet static inline bool skb_is_tcp_pure_ack(const struct sk_buff *skb) 175698781965SEric Dumazet { 175798781965SEric Dumazet return skb->truesize == 2; 175898781965SEric Dumazet } 175998781965SEric Dumazet 176098781965SEric Dumazet static inline void skb_set_tcp_pure_ack(struct sk_buff *skb) 176198781965SEric Dumazet { 176298781965SEric Dumazet skb->truesize = 2; 176398781965SEric Dumazet } 176498781965SEric Dumazet 17651da177e4SLinus Torvalds #endif /* _TCP_H */ 1766