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 TCP_DEBUG 1 221da177e4SLinus Torvalds #define FASTRETRANS_DEBUG 1 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #include <linux/list.h> 251da177e4SLinus Torvalds #include <linux/tcp.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/cache.h> 281da177e4SLinus Torvalds #include <linux/percpu.h> 29fb286bb2SHerbert Xu #include <linux/skbuff.h> 3097fc2f08SChris Leech #include <linux/dmaengine.h> 31cfb6eeb4SYOSHIFUJI Hideaki #include <linux/crypto.h> 32c6aefafbSGlenn Griffin #include <linux/cryptohash.h> 333f421baaSArnaldo Carvalho de Melo 343f421baaSArnaldo Carvalho de Melo #include <net/inet_connection_sock.h> 35295ff7edSArnaldo Carvalho de Melo #include <net/inet_timewait_sock.h> 3677d8bf9cSArnaldo Carvalho de Melo #include <net/inet_hashtables.h> 371da177e4SLinus Torvalds #include <net/checksum.h> 382e6599cbSArnaldo Carvalho de Melo #include <net/request_sock.h> 391da177e4SLinus Torvalds #include <net/sock.h> 401da177e4SLinus Torvalds #include <net/snmp.h> 411da177e4SLinus Torvalds #include <net/ip.h> 42c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h> 43bdf1ee5dSIlpo Järvinen #include <net/inet_ecn.h> 44c752f073SArnaldo Carvalho de Melo 451da177e4SLinus Torvalds #include <linux/seq_file.h> 461da177e4SLinus Torvalds 470f7ff927SArnaldo Carvalho de Melo extern struct inet_hashinfo tcp_hashinfo; 481da177e4SLinus Torvalds 49dd24c001SEric Dumazet extern struct percpu_counter tcp_orphan_count; 501da177e4SLinus Torvalds extern void tcp_time_wait(struct sock *sk, int state, int timeo); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #define MAX_TCP_HEADER (128 + MAX_HEADER) 5333ad798cSAdam Langley #define MAX_TCP_OPTION_SPACE 40 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds /* 561da177e4SLinus Torvalds * Never offer a window over 32767 without using window scaling. Some 571da177e4SLinus Torvalds * poor stacks do signed 16bit maths! 581da177e4SLinus Torvalds */ 591da177e4SLinus Torvalds #define MAX_TCP_WINDOW 32767U 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds /* Minimal accepted MSS. It is (60+60+8) - (20+20). */ 621da177e4SLinus Torvalds #define TCP_MIN_MSS 88U 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* Minimal RCV_MSS. */ 651da177e4SLinus Torvalds #define TCP_MIN_RCVMSS 536U 661da177e4SLinus Torvalds 675d424d5aSJohn Heffner /* The least MTU to use for probing */ 685d424d5aSJohn Heffner #define TCP_BASE_MSS 512 695d424d5aSJohn Heffner 701da177e4SLinus Torvalds /* After receiving this amount of duplicate ACKs fast retransmit starts. */ 711da177e4SLinus Torvalds #define TCP_FASTRETRANS_THRESH 3 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds /* Maximal reordering. */ 741da177e4SLinus Torvalds #define TCP_MAX_REORDERING 127 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds /* Maximal number of ACKs sent quickly to accelerate slow-start. */ 771da177e4SLinus Torvalds #define TCP_MAX_QUICKACKS 16U 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds /* urg_data states */ 801da177e4SLinus Torvalds #define TCP_URG_VALID 0x0100 811da177e4SLinus Torvalds #define TCP_URG_NOTYET 0x0200 821da177e4SLinus Torvalds #define TCP_URG_READ 0x0400 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds #define TCP_RETR1 3 /* 851da177e4SLinus Torvalds * This is how many retries it does before it 861da177e4SLinus Torvalds * tries to figure out if the gateway is 871da177e4SLinus Torvalds * down. Minimal RFC value is 3; it corresponds 881da177e4SLinus Torvalds * to ~3sec-8min depending on RTO. 891da177e4SLinus Torvalds */ 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds #define TCP_RETR2 15 /* 921da177e4SLinus Torvalds * This should take at least 931da177e4SLinus Torvalds * 90 minutes to time out. 941da177e4SLinus Torvalds * RFC1122 says that the limit is 100 sec. 951da177e4SLinus Torvalds * 15 is ~13-30min depending on RTO. 961da177e4SLinus Torvalds */ 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds #define TCP_SYN_RETRIES 5 /* number of times to retry active opening a 99caa20d9aSStephen Hemminger * connection: ~180sec is RFC minimum */ 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds #define TCP_SYNACK_RETRIES 5 /* number of times to retry passive opening a 102caa20d9aSStephen Hemminger * connection: ~180sec is RFC minimum */ 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds #define TCP_ORPHAN_RETRIES 7 /* number of times to retry on an orphaned 1061da177e4SLinus Torvalds * socket. 7 is ~50sec-16min. 1071da177e4SLinus Torvalds */ 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT 1111da177e4SLinus Torvalds * state, about 60 seconds */ 1121da177e4SLinus Torvalds #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN 1131da177e4SLinus Torvalds /* BSD style FIN_WAIT2 deadlock breaker. 1141da177e4SLinus Torvalds * It used to be 3min, new value is 60sec, 1151da177e4SLinus Torvalds * to combine FIN-WAIT-2 timeout with 1161da177e4SLinus Torvalds * TIME-WAIT timer. 1171da177e4SLinus Torvalds */ 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds #define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */ 1201da177e4SLinus Torvalds #if HZ >= 100 1211da177e4SLinus Torvalds #define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */ 1221da177e4SLinus Torvalds #define TCP_ATO_MIN ((unsigned)(HZ/25)) 1231da177e4SLinus Torvalds #else 1241da177e4SLinus Torvalds #define TCP_DELACK_MIN 4U 1251da177e4SLinus Torvalds #define TCP_ATO_MIN 4U 1261da177e4SLinus Torvalds #endif 1271da177e4SLinus Torvalds #define TCP_RTO_MAX ((unsigned)(120*HZ)) 1281da177e4SLinus Torvalds #define TCP_RTO_MIN ((unsigned)(HZ/5)) 1291da177e4SLinus Torvalds #define TCP_TIMEOUT_INIT ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value */ 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes 1321da177e4SLinus Torvalds * for local resources. 1331da177e4SLinus Torvalds */ 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds #define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */ 1361da177e4SLinus Torvalds #define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ 1371da177e4SLinus Torvalds #define TCP_KEEPALIVE_INTVL (75*HZ) 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds #define MAX_TCP_KEEPIDLE 32767 1401da177e4SLinus Torvalds #define MAX_TCP_KEEPINTVL 32767 1411da177e4SLinus Torvalds #define MAX_TCP_KEEPCNT 127 1421da177e4SLinus Torvalds #define MAX_TCP_SYNCNT 127 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds #define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */ 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24) 1471da177e4SLinus Torvalds #define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated 1481da177e4SLinus Torvalds * after this time. It should be equal 1491da177e4SLinus Torvalds * (or greater than) TCP_TIMEWAIT_LEN 1501da177e4SLinus Torvalds * to provide reliability equal to one 1511da177e4SLinus Torvalds * provided by timewait state. 1521da177e4SLinus Torvalds */ 1531da177e4SLinus Torvalds #define TCP_PAWS_WINDOW 1 /* Replay window for per-host 1541da177e4SLinus Torvalds * timestamps. It must be less than 1551da177e4SLinus Torvalds * minimal timewait lifetime. 1561da177e4SLinus Torvalds */ 1571da177e4SLinus Torvalds /* 1581da177e4SLinus Torvalds * TCP option 1591da177e4SLinus Torvalds */ 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds #define TCPOPT_NOP 1 /* Padding */ 1621da177e4SLinus Torvalds #define TCPOPT_EOL 0 /* End of options */ 1631da177e4SLinus Torvalds #define TCPOPT_MSS 2 /* Segment size negotiating */ 1641da177e4SLinus Torvalds #define TCPOPT_WINDOW 3 /* Window scaling */ 1651da177e4SLinus Torvalds #define TCPOPT_SACK_PERM 4 /* SACK Permitted */ 1661da177e4SLinus Torvalds #define TCPOPT_SACK 5 /* SACK Block */ 1671da177e4SLinus Torvalds #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ 168cfb6eeb4SYOSHIFUJI Hideaki #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ 1691da177e4SLinus Torvalds 1701da177e4SLinus Torvalds /* 1711da177e4SLinus Torvalds * TCP option lengths 1721da177e4SLinus Torvalds */ 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds #define TCPOLEN_MSS 4 1751da177e4SLinus Torvalds #define TCPOLEN_WINDOW 3 1761da177e4SLinus Torvalds #define TCPOLEN_SACK_PERM 2 1771da177e4SLinus Torvalds #define TCPOLEN_TIMESTAMP 10 178cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG 18 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds /* But this is what stacks really send out. */ 1811da177e4SLinus Torvalds #define TCPOLEN_TSTAMP_ALIGNED 12 1821da177e4SLinus Torvalds #define TCPOLEN_WSCALE_ALIGNED 4 1831da177e4SLinus Torvalds #define TCPOLEN_SACKPERM_ALIGNED 4 1841da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE 2 1851da177e4SLinus Torvalds #define TCPOLEN_SACK_BASE_ALIGNED 4 1861da177e4SLinus Torvalds #define TCPOLEN_SACK_PERBLOCK 8 187cfb6eeb4SYOSHIFUJI Hideaki #define TCPOLEN_MD5SIG_ALIGNED 20 18833ad798cSAdam Langley #define TCPOLEN_MSS_ALIGNED 4 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds /* Flags in tp->nonagle */ 1911da177e4SLinus Torvalds #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */ 1921da177e4SLinus Torvalds #define TCP_NAGLE_CORK 2 /* Socket is corked */ 193caa20d9aSStephen Hemminger #define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */ 1941da177e4SLinus Torvalds 195295ff7edSArnaldo Carvalho de Melo extern struct inet_timewait_death_row tcp_death_row; 196295ff7edSArnaldo Carvalho de Melo 1971da177e4SLinus Torvalds /* sysctl variables for tcp */ 1981da177e4SLinus Torvalds extern int sysctl_tcp_timestamps; 1991da177e4SLinus Torvalds extern int sysctl_tcp_window_scaling; 2001da177e4SLinus Torvalds extern int sysctl_tcp_sack; 2011da177e4SLinus Torvalds extern int sysctl_tcp_fin_timeout; 2021da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_time; 2031da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_probes; 2041da177e4SLinus Torvalds extern int sysctl_tcp_keepalive_intvl; 2051da177e4SLinus Torvalds extern int sysctl_tcp_syn_retries; 2061da177e4SLinus Torvalds extern int sysctl_tcp_synack_retries; 2071da177e4SLinus Torvalds extern int sysctl_tcp_retries1; 2081da177e4SLinus Torvalds extern int sysctl_tcp_retries2; 2091da177e4SLinus Torvalds extern int sysctl_tcp_orphan_retries; 2101da177e4SLinus Torvalds extern int sysctl_tcp_syncookies; 2111da177e4SLinus Torvalds extern int sysctl_tcp_retrans_collapse; 2121da177e4SLinus Torvalds extern int sysctl_tcp_stdurg; 2131da177e4SLinus Torvalds extern int sysctl_tcp_rfc1337; 2141da177e4SLinus Torvalds extern int sysctl_tcp_abort_on_overflow; 2151da177e4SLinus Torvalds extern int sysctl_tcp_max_orphans; 2161da177e4SLinus Torvalds extern int sysctl_tcp_fack; 2171da177e4SLinus Torvalds extern int sysctl_tcp_reordering; 2181da177e4SLinus Torvalds extern int sysctl_tcp_ecn; 2191da177e4SLinus Torvalds extern int sysctl_tcp_dsack; 2201da177e4SLinus Torvalds extern int sysctl_tcp_mem[3]; 2211da177e4SLinus Torvalds extern int sysctl_tcp_wmem[3]; 2221da177e4SLinus Torvalds extern int sysctl_tcp_rmem[3]; 2231da177e4SLinus Torvalds extern int sysctl_tcp_app_win; 2241da177e4SLinus Torvalds extern int sysctl_tcp_adv_win_scale; 2251da177e4SLinus Torvalds extern int sysctl_tcp_tw_reuse; 2261da177e4SLinus Torvalds extern int sysctl_tcp_frto; 2273cfe3baaSIlpo Järvinen extern int sysctl_tcp_frto_response; 2281da177e4SLinus Torvalds extern int sysctl_tcp_low_latency; 22995937825SChris Leech extern int sysctl_tcp_dma_copybreak; 2301da177e4SLinus Torvalds extern int sysctl_tcp_nometrics_save; 2311da177e4SLinus Torvalds extern int sysctl_tcp_moderate_rcvbuf; 2321da177e4SLinus Torvalds extern int sysctl_tcp_tso_win_divisor; 2339772efb9SStephen Hemminger extern int sysctl_tcp_abc; 2345d424d5aSJohn Heffner extern int sysctl_tcp_mtu_probing; 2355d424d5aSJohn Heffner extern int sysctl_tcp_base_mss; 23615d99e02SRick Jones extern int sysctl_tcp_workaround_signed_windows; 23735089bb2SDavid S. Miller extern int sysctl_tcp_slow_start_after_idle; 238886236c1SJohn Heffner extern int sysctl_tcp_max_ssthresh; 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds extern atomic_t tcp_memory_allocated; 2411748376bSEric Dumazet extern struct percpu_counter tcp_sockets_allocated; 2421da177e4SLinus Torvalds extern int tcp_memory_pressure; 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds /* 2451da177e4SLinus Torvalds * The next routines deal with comparing 32 bit unsigned ints 2461da177e4SLinus Torvalds * and worry about wraparound (automatic with unsigned arithmetic). 2471da177e4SLinus Torvalds */ 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds static inline int before(__u32 seq1, __u32 seq2) 2501da177e4SLinus Torvalds { 2510d630cc0SGerrit Renker return (__s32)(seq1-seq2) < 0; 2521da177e4SLinus Torvalds } 2539a036b9cSGerrit Renker #define after(seq2, seq1) before(seq1, seq2) 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* is s2<=s1<=s3 ? */ 2561da177e4SLinus Torvalds static inline int between(__u32 seq1, __u32 seq2, __u32 seq3) 2571da177e4SLinus Torvalds { 2581da177e4SLinus Torvalds return seq3 - seq2 >= seq1 - seq2; 2591da177e4SLinus Torvalds } 2601da177e4SLinus Torvalds 261e4fd5da3SPavel Emelianov static inline int tcp_too_many_orphans(struct sock *sk, int num) 262e4fd5da3SPavel Emelianov { 263e4fd5da3SPavel Emelianov return (num > sysctl_tcp_max_orphans) || 264e4fd5da3SPavel Emelianov (sk->sk_wmem_queued > SOCK_MIN_SNDBUF && 265e4fd5da3SPavel Emelianov atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2]); 266e4fd5da3SPavel Emelianov } 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds extern struct proto tcp_prot; 2691da177e4SLinus Torvalds 27057ef42d5SPavel Emelyanov #define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field) 27157ef42d5SPavel Emelyanov #define TCP_INC_STATS_BH(net, field) SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field) 27257ef42d5SPavel Emelyanov #define TCP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->mib.tcp_statistics, field) 27357ef42d5SPavel Emelyanov #define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val) 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds extern void tcp_v4_err(struct sk_buff *skb, u32); 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds extern void tcp_shutdown (struct sock *sk, int how); 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds extern int tcp_v4_rcv(struct sk_buff *skb); 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds extern int tcp_v4_remember_stamp(struct sock *sk); 2821da177e4SLinus Torvalds 2838feaf0c0SArnaldo Carvalho de Melo extern int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw); 2841da177e4SLinus Torvalds 2853516ffb0SDavid S. Miller extern int tcp_sendmsg(struct kiocb *iocb, struct socket *sock, 2861da177e4SLinus Torvalds struct msghdr *msg, size_t size); 2871da177e4SLinus Torvalds extern ssize_t tcp_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags); 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds extern int tcp_ioctl(struct sock *sk, 2901da177e4SLinus Torvalds int cmd, 2911da177e4SLinus Torvalds unsigned long arg); 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds extern int tcp_rcv_state_process(struct sock *sk, 2941da177e4SLinus Torvalds struct sk_buff *skb, 2951da177e4SLinus Torvalds struct tcphdr *th, 2961da177e4SLinus Torvalds unsigned len); 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds extern int tcp_rcv_established(struct sock *sk, 2991da177e4SLinus Torvalds struct sk_buff *skb, 3001da177e4SLinus Torvalds struct tcphdr *th, 3011da177e4SLinus Torvalds unsigned len); 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds extern void tcp_rcv_space_adjust(struct sock *sk); 3041da177e4SLinus Torvalds 3050e4b4992SChris Leech extern void tcp_cleanup_rbuf(struct sock *sk, int copied); 3060e4b4992SChris Leech 3076d6ee43eSArnaldo Carvalho de Melo extern int tcp_twsk_unique(struct sock *sk, 3086d6ee43eSArnaldo Carvalho de Melo struct sock *sktw, void *twp); 3096d6ee43eSArnaldo Carvalho de Melo 310cfb6eeb4SYOSHIFUJI Hideaki extern void tcp_twsk_destructor(struct sock *sk); 311cfb6eeb4SYOSHIFUJI Hideaki 3129c55e01cSJens Axboe extern ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos, 3139c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, unsigned int flags); 3149c55e01cSJens Axboe 315463c84b9SArnaldo Carvalho de Melo static inline void tcp_dec_quickack_mode(struct sock *sk, 316463c84b9SArnaldo Carvalho de Melo const unsigned int pkts) 3171da177e4SLinus Torvalds { 318463c84b9SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 319fc6415bcSDavid S. Miller 320463c84b9SArnaldo Carvalho de Melo if (icsk->icsk_ack.quick) { 321463c84b9SArnaldo Carvalho de Melo if (pkts >= icsk->icsk_ack.quick) { 322463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick = 0; 3231da177e4SLinus Torvalds /* Leaving quickack mode we deflate ATO. */ 324463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.ato = TCP_ATO_MIN; 325fc6415bcSDavid S. Miller } else 326463c84b9SArnaldo Carvalho de Melo icsk->icsk_ack.quick -= pkts; 3271da177e4SLinus Torvalds } 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds 330463c84b9SArnaldo Carvalho de Melo extern void tcp_enter_quickack_mode(struct sock *sk); 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds static inline void tcp_clear_options(struct tcp_options_received *rx_opt) 3331da177e4SLinus Torvalds { 3341da177e4SLinus Torvalds rx_opt->tstamp_ok = rx_opt->sack_ok = rx_opt->wscale_ok = rx_opt->snd_wscale = 0; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds 337bdf1ee5dSIlpo Järvinen #define TCP_ECN_OK 1 338bdf1ee5dSIlpo Järvinen #define TCP_ECN_QUEUE_CWR 2 339bdf1ee5dSIlpo Järvinen #define TCP_ECN_DEMAND_CWR 4 340bdf1ee5dSIlpo Järvinen 341bdf1ee5dSIlpo Järvinen static __inline__ void 342bdf1ee5dSIlpo Järvinen TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th) 343bdf1ee5dSIlpo Järvinen { 344bdf1ee5dSIlpo Järvinen if (sysctl_tcp_ecn && th->ece && th->cwr) 345bdf1ee5dSIlpo Järvinen inet_rsk(req)->ecn_ok = 1; 346bdf1ee5dSIlpo Järvinen } 347bdf1ee5dSIlpo Järvinen 3481da177e4SLinus Torvalds enum tcp_tw_status 3491da177e4SLinus Torvalds { 3501da177e4SLinus Torvalds TCP_TW_SUCCESS = 0, 3511da177e4SLinus Torvalds TCP_TW_RST = 1, 3521da177e4SLinus Torvalds TCP_TW_ACK = 2, 3531da177e4SLinus Torvalds TCP_TW_SYN = 3 3541da177e4SLinus Torvalds }; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds 3578feaf0c0SArnaldo Carvalho de Melo extern enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw, 3581da177e4SLinus Torvalds struct sk_buff *skb, 3598feaf0c0SArnaldo Carvalho de Melo const struct tcphdr *th); 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds extern struct sock * tcp_check_req(struct sock *sk,struct sk_buff *skb, 36260236fddSArnaldo Carvalho de Melo struct request_sock *req, 36360236fddSArnaldo Carvalho de Melo struct request_sock **prev); 3641da177e4SLinus Torvalds extern int tcp_child_process(struct sock *parent, 3651da177e4SLinus Torvalds struct sock *child, 3661da177e4SLinus Torvalds struct sk_buff *skb); 36746d0de4eSIlpo Järvinen extern int tcp_use_frto(struct sock *sk); 3681da177e4SLinus Torvalds extern void tcp_enter_frto(struct sock *sk); 3691da177e4SLinus Torvalds extern void tcp_enter_loss(struct sock *sk, int how); 3701da177e4SLinus Torvalds extern void tcp_clear_retrans(struct tcp_sock *tp); 3711da177e4SLinus Torvalds extern void tcp_update_metrics(struct sock *sk); 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds extern void tcp_close(struct sock *sk, 3741da177e4SLinus Torvalds long timeout); 3751da177e4SLinus Torvalds extern unsigned int tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait); 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds extern int tcp_getsockopt(struct sock *sk, int level, 3781da177e4SLinus Torvalds int optname, 3791da177e4SLinus Torvalds char __user *optval, 3801da177e4SLinus Torvalds int __user *optlen); 3811da177e4SLinus Torvalds extern int tcp_setsockopt(struct sock *sk, int level, 3821da177e4SLinus Torvalds int optname, char __user *optval, 3831da177e4SLinus Torvalds int optlen); 3843fdadf7dSDmitry Mishin extern int compat_tcp_getsockopt(struct sock *sk, 3853fdadf7dSDmitry Mishin int level, int optname, 3863fdadf7dSDmitry Mishin char __user *optval, int __user *optlen); 3873fdadf7dSDmitry Mishin extern int compat_tcp_setsockopt(struct sock *sk, 3883fdadf7dSDmitry Mishin int level, int optname, 3893fdadf7dSDmitry Mishin char __user *optval, int optlen); 3901da177e4SLinus Torvalds extern void tcp_set_keepalive(struct sock *sk, int val); 3911da177e4SLinus Torvalds extern int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, 3921da177e4SLinus Torvalds struct msghdr *msg, 3931da177e4SLinus Torvalds size_t len, int nonblock, 3941da177e4SLinus Torvalds int flags, int *addr_len); 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds extern void tcp_parse_options(struct sk_buff *skb, 3971da177e4SLinus Torvalds struct tcp_options_received *opt_rx, 3981da177e4SLinus Torvalds int estab); 3991da177e4SLinus Torvalds 4007d5d5525SYOSHIFUJI Hideaki extern u8 *tcp_parse_md5sig_option(struct tcphdr *th); 4017d5d5525SYOSHIFUJI Hideaki 4021da177e4SLinus Torvalds /* 4031da177e4SLinus Torvalds * TCP v4 functions exported for the inet6 API 4041da177e4SLinus Torvalds */ 4051da177e4SLinus Torvalds 4068292a17aSArnaldo Carvalho de Melo extern void tcp_v4_send_check(struct sock *sk, int len, 4071da177e4SLinus Torvalds struct sk_buff *skb); 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds extern int tcp_v4_conn_request(struct sock *sk, 4101da177e4SLinus Torvalds struct sk_buff *skb); 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds extern struct sock * tcp_create_openreq_child(struct sock *sk, 41360236fddSArnaldo Carvalho de Melo struct request_sock *req, 4141da177e4SLinus Torvalds struct sk_buff *skb); 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk, 4171da177e4SLinus Torvalds struct sk_buff *skb, 41860236fddSArnaldo Carvalho de Melo struct request_sock *req, 4191da177e4SLinus Torvalds struct dst_entry *dst); 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds extern int tcp_v4_do_rcv(struct sock *sk, 4221da177e4SLinus Torvalds struct sk_buff *skb); 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds extern int tcp_v4_connect(struct sock *sk, 4251da177e4SLinus Torvalds struct sockaddr *uaddr, 4261da177e4SLinus Torvalds int addr_len); 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds extern int tcp_connect(struct sock *sk); 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds extern struct sk_buff * tcp_make_synack(struct sock *sk, 4311da177e4SLinus Torvalds struct dst_entry *dst, 43260236fddSArnaldo Carvalho de Melo struct request_sock *req); 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds extern int tcp_disconnect(struct sock *sk, int flags); 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds /* From syncookies.c */ 4382051f11fSFlorian Westphal extern __u32 syncookie_secret[2][16-4+SHA_DIGEST_WORDS]; 4391da177e4SLinus Torvalds extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, 4401da177e4SLinus Torvalds struct ip_options *opt); 4411da177e4SLinus Torvalds extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, 4421da177e4SLinus Torvalds __u16 *mss); 4431da177e4SLinus Torvalds 4444dfc2817SFlorian Westphal extern __u32 cookie_init_timestamp(struct request_sock *req); 4454dfc2817SFlorian Westphal extern void cookie_check_timestamp(struct tcp_options_received *tcp_opt); 4464dfc2817SFlorian Westphal 447c6aefafbSGlenn Griffin /* From net/ipv6/syncookies.c */ 448c6aefafbSGlenn Griffin extern struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb); 449c6aefafbSGlenn Griffin extern __u32 cookie_v6_init_sequence(struct sock *sk, struct sk_buff *skb, 450c6aefafbSGlenn Griffin __u16 *mss); 451c6aefafbSGlenn Griffin 4521da177e4SLinus Torvalds /* tcp_output.c */ 4531da177e4SLinus Torvalds 4549e412ba7SIlpo Järvinen extern void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, 4559e412ba7SIlpo Järvinen int nonagle); 4569e412ba7SIlpo Järvinen extern int tcp_may_send_now(struct sock *sk); 4571da177e4SLinus Torvalds extern int tcp_retransmit_skb(struct sock *, struct sk_buff *); 4581da177e4SLinus Torvalds extern void tcp_xmit_retransmit_queue(struct sock *); 4591da177e4SLinus Torvalds extern void tcp_simple_retransmit(struct sock *); 4601da177e4SLinus Torvalds extern int tcp_trim_head(struct sock *, struct sk_buff *, u32); 4616475be16SDavid S. Miller extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int); 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds extern void tcp_send_probe0(struct sock *); 4641da177e4SLinus Torvalds extern void tcp_send_partial(struct sock *); 4651da177e4SLinus Torvalds extern int tcp_write_wakeup(struct sock *); 4661da177e4SLinus Torvalds extern void tcp_send_fin(struct sock *sk); 467dd0fc66fSAl Viro extern void tcp_send_active_reset(struct sock *sk, gfp_t priority); 4681da177e4SLinus Torvalds extern int tcp_send_synack(struct sock *); 469c1b4a7e6SDavid S. Miller extern void tcp_push_one(struct sock *, unsigned int mss_now); 4701da177e4SLinus Torvalds extern void tcp_send_ack(struct sock *sk); 4711da177e4SLinus Torvalds extern void tcp_send_delayed_ack(struct sock *sk); 4721da177e4SLinus Torvalds 473a762a980SDavid S. Miller /* tcp_input.c */ 474a762a980SDavid S. Miller extern void tcp_cwnd_application_limited(struct sock *sk); 475a762a980SDavid S. Miller 4761da177e4SLinus Torvalds /* tcp_timer.c */ 4771da177e4SLinus Torvalds extern void tcp_init_xmit_timers(struct sock *); 478463c84b9SArnaldo Carvalho de Melo static inline void tcp_clear_xmit_timers(struct sock *sk) 479463c84b9SArnaldo Carvalho de Melo { 480463c84b9SArnaldo Carvalho de Melo inet_csk_clear_xmit_timers(sk); 481463c84b9SArnaldo Carvalho de Melo } 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu); 484*0c54b85fSIlpo Järvinen extern unsigned int tcp_current_mss(struct sock *sk); 485*0c54b85fSIlpo Järvinen 486*0c54b85fSIlpo Järvinen /* Bound MSS / TSO packet size with the half of the window */ 487*0c54b85fSIlpo Järvinen static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize) 488*0c54b85fSIlpo Järvinen { 489*0c54b85fSIlpo Järvinen if (tp->max_window && pktsize > (tp->max_window >> 1)) 490*0c54b85fSIlpo Järvinen return max(tp->max_window >> 1, 68U - tp->tcp_header_len); 491*0c54b85fSIlpo Järvinen else 492*0c54b85fSIlpo Järvinen return pktsize; 493*0c54b85fSIlpo Järvinen } 4941da177e4SLinus Torvalds 49517b085eaSArnaldo Carvalho de Melo /* tcp.c */ 4961da177e4SLinus Torvalds extern void tcp_get_info(struct sock *, struct tcp_info *); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds /* Read 'sendfile()'-style from a TCP socket */ 4991da177e4SLinus Torvalds typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, 5001da177e4SLinus Torvalds unsigned int, size_t); 5011da177e4SLinus Torvalds extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, 5021da177e4SLinus Torvalds sk_read_actor_t recv_actor); 5031da177e4SLinus Torvalds 50440efc6faSStephen Hemminger extern void tcp_initialize_rcv_mss(struct sock *sk); 5051da177e4SLinus Torvalds 5065d424d5aSJohn Heffner extern int tcp_mtu_to_mss(struct sock *sk, int pmtu); 5075d424d5aSJohn Heffner extern int tcp_mss_to_mtu(struct sock *sk, int mss); 5085d424d5aSJohn Heffner extern void tcp_mtup_init(struct sock *sk); 5095d424d5aSJohn Heffner 51040efc6faSStephen Hemminger static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) 5111da177e4SLinus Torvalds { 5121da177e4SLinus Torvalds tp->pred_flags = htonl((tp->tcp_header_len << 26) | 5131da177e4SLinus Torvalds ntohl(TCP_FLAG_ACK) | 5141da177e4SLinus Torvalds snd_wnd); 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds 51740efc6faSStephen Hemminger static inline void tcp_fast_path_on(struct tcp_sock *tp) 5181da177e4SLinus Torvalds { 5191da177e4SLinus Torvalds __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale); 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5229e412ba7SIlpo Järvinen static inline void tcp_fast_path_check(struct sock *sk) 5231da177e4SLinus Torvalds { 5249e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 5259e412ba7SIlpo Järvinen 526b03efcfbSDavid S. Miller if (skb_queue_empty(&tp->out_of_order_queue) && 5271da177e4SLinus Torvalds tp->rcv_wnd && 5281da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf && 5291da177e4SLinus Torvalds !tp->urg_data) 5301da177e4SLinus Torvalds tcp_fast_path_on(tp); 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds /* Compute the actual receive window we are currently advertising. 5341da177e4SLinus Torvalds * Rcv_nxt can be after the window if our peer push more data 5351da177e4SLinus Torvalds * than the offered window. 5361da177e4SLinus Torvalds */ 53740efc6faSStephen Hemminger static inline u32 tcp_receive_window(const struct tcp_sock *tp) 5381da177e4SLinus Torvalds { 5391da177e4SLinus Torvalds s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds if (win < 0) 5421da177e4SLinus Torvalds win = 0; 5431da177e4SLinus Torvalds return (u32) win; 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds /* Choose a new window, without checks for shrinking, and without 5471da177e4SLinus Torvalds * scaling applied to the result. The caller does these things 5481da177e4SLinus Torvalds * if necessary. This is a "raw" window selection. 5491da177e4SLinus Torvalds */ 5501da177e4SLinus Torvalds extern u32 __tcp_select_window(struct sock *sk); 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds /* TCP timestamps are only 32-bits, this causes a slight 5531da177e4SLinus Torvalds * complication on 64-bit systems since we store a snapshot 55431f34269SStephen Hemminger * of jiffies in the buffer control blocks below. We decided 55531f34269SStephen Hemminger * to use only the low 32-bits of jiffies and hide the ugly 5561da177e4SLinus Torvalds * casts with the following macro. 5571da177e4SLinus Torvalds */ 5581da177e4SLinus Torvalds #define tcp_time_stamp ((__u32)(jiffies)) 5591da177e4SLinus Torvalds 560caa20d9aSStephen Hemminger /* This is what the send packet queuing engine uses to pass 5611da177e4SLinus Torvalds * TCP per-packet control information to the transmission 5621da177e4SLinus Torvalds * code. We also store the host-order sequence numbers in 5631da177e4SLinus Torvalds * here too. This is 36 bytes on 32-bit architectures, 5641da177e4SLinus Torvalds * 40 bytes on 64-bit machines, if this grows please adjust 5651da177e4SLinus Torvalds * skbuff.h:skbuff->cb[xxx] size appropriately. 5661da177e4SLinus Torvalds */ 5671da177e4SLinus Torvalds struct tcp_skb_cb { 5681da177e4SLinus Torvalds union { 5691da177e4SLinus Torvalds struct inet_skb_parm h4; 5701da177e4SLinus Torvalds #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) 5711da177e4SLinus Torvalds struct inet6_skb_parm h6; 5721da177e4SLinus Torvalds #endif 5731da177e4SLinus Torvalds } header; /* For incoming frames */ 5741da177e4SLinus Torvalds __u32 seq; /* Starting sequence number */ 5751da177e4SLinus Torvalds __u32 end_seq; /* SEQ + FIN + SYN + datalen */ 5761da177e4SLinus Torvalds __u32 when; /* used to compute rtt's */ 5771da177e4SLinus Torvalds __u8 flags; /* TCP header flags. */ 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds /* NOTE: These must match up to the flags byte in a 5801da177e4SLinus Torvalds * real TCP header. 5811da177e4SLinus Torvalds */ 5821da177e4SLinus Torvalds #define TCPCB_FLAG_FIN 0x01 5831da177e4SLinus Torvalds #define TCPCB_FLAG_SYN 0x02 5841da177e4SLinus Torvalds #define TCPCB_FLAG_RST 0x04 5851da177e4SLinus Torvalds #define TCPCB_FLAG_PSH 0x08 5861da177e4SLinus Torvalds #define TCPCB_FLAG_ACK 0x10 5871da177e4SLinus Torvalds #define TCPCB_FLAG_URG 0x20 5881da177e4SLinus Torvalds #define TCPCB_FLAG_ECE 0x40 5891da177e4SLinus Torvalds #define TCPCB_FLAG_CWR 0x80 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds __u8 sacked; /* State flags for SACK/FACK. */ 5921da177e4SLinus Torvalds #define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ 5931da177e4SLinus Torvalds #define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ 5941da177e4SLinus Torvalds #define TCPCB_LOST 0x04 /* SKB is lost */ 5951da177e4SLinus Torvalds #define TCPCB_TAGBITS 0x07 /* All tag bits */ 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds #define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */ 5981da177e4SLinus Torvalds #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS) 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds __u32 ack_seq; /* Sequence number ACK'd */ 6011da177e4SLinus Torvalds }; 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0])) 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds /* Due to TSO, an SKB can be composed of multiple actual 6061da177e4SLinus Torvalds * packets. To keep these tracked properly, we use this. 6071da177e4SLinus Torvalds */ 6081da177e4SLinus Torvalds static inline int tcp_skb_pcount(const struct sk_buff *skb) 6091da177e4SLinus Torvalds { 6107967168cSHerbert Xu return skb_shinfo(skb)->gso_segs; 6111da177e4SLinus Torvalds } 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds /* This is valid iff tcp_skb_pcount() > 1. */ 6141da177e4SLinus Torvalds static inline int tcp_skb_mss(const struct sk_buff *skb) 6151da177e4SLinus Torvalds { 6167967168cSHerbert Xu return skb_shinfo(skb)->gso_size; 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds 619af610b4cSIlpo Järvinen static inline void tcp_dec_pcount_approx_int(__u32 *count, const int decr) 6201da177e4SLinus Torvalds { 6211da177e4SLinus Torvalds if (*count) { 622af610b4cSIlpo Järvinen *count -= decr; 6231da177e4SLinus Torvalds if ((int)*count < 0) 6241da177e4SLinus Torvalds *count = 0; 6251da177e4SLinus Torvalds } 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 628af610b4cSIlpo Järvinen static inline void tcp_dec_pcount_approx(__u32 *count, 629af610b4cSIlpo Järvinen const struct sk_buff *skb) 630af610b4cSIlpo Järvinen { 631af610b4cSIlpo Järvinen tcp_dec_pcount_approx_int(count, tcp_skb_pcount(skb)); 632af610b4cSIlpo Järvinen } 633af610b4cSIlpo Järvinen 634317a76f9SStephen Hemminger /* Events passed to congestion control interface */ 635317a76f9SStephen Hemminger enum tcp_ca_event { 636317a76f9SStephen Hemminger CA_EVENT_TX_START, /* first transmit when no packets in flight */ 637317a76f9SStephen Hemminger CA_EVENT_CWND_RESTART, /* congestion window restart */ 638317a76f9SStephen Hemminger CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */ 639317a76f9SStephen Hemminger CA_EVENT_FRTO, /* fast recovery timeout */ 640317a76f9SStephen Hemminger CA_EVENT_LOSS, /* loss timeout */ 641317a76f9SStephen Hemminger CA_EVENT_FAST_ACK, /* in sequence ack */ 642317a76f9SStephen Hemminger CA_EVENT_SLOW_ACK, /* other ack */ 643317a76f9SStephen Hemminger }; 644317a76f9SStephen Hemminger 645317a76f9SStephen Hemminger /* 646317a76f9SStephen Hemminger * Interface for adding new TCP congestion control handlers 647317a76f9SStephen Hemminger */ 648317a76f9SStephen Hemminger #define TCP_CA_NAME_MAX 16 6493ff825b2SStephen Hemminger #define TCP_CA_MAX 128 6503ff825b2SStephen Hemminger #define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX) 6513ff825b2SStephen Hemminger 652164891aaSStephen Hemminger #define TCP_CONG_NON_RESTRICTED 0x1 653164891aaSStephen Hemminger #define TCP_CONG_RTT_STAMP 0x2 654164891aaSStephen Hemminger 655317a76f9SStephen Hemminger struct tcp_congestion_ops { 656317a76f9SStephen Hemminger struct list_head list; 657164891aaSStephen Hemminger unsigned long flags; 658317a76f9SStephen Hemminger 659317a76f9SStephen Hemminger /* initialize private data (optional) */ 6606687e988SArnaldo Carvalho de Melo void (*init)(struct sock *sk); 661317a76f9SStephen Hemminger /* cleanup private data (optional) */ 6626687e988SArnaldo Carvalho de Melo void (*release)(struct sock *sk); 663317a76f9SStephen Hemminger 664317a76f9SStephen Hemminger /* return slow start threshold (required) */ 6656687e988SArnaldo Carvalho de Melo u32 (*ssthresh)(struct sock *sk); 666317a76f9SStephen Hemminger /* lower bound for congestion window (optional) */ 66772dc5b92SStephen Hemminger u32 (*min_cwnd)(const struct sock *sk); 668317a76f9SStephen Hemminger /* do new cwnd calculation (required) */ 669c3a05c60SIlpo Järvinen void (*cong_avoid)(struct sock *sk, u32 ack, u32 in_flight); 670317a76f9SStephen Hemminger /* call before changing ca_state (optional) */ 6716687e988SArnaldo Carvalho de Melo void (*set_state)(struct sock *sk, u8 new_state); 672317a76f9SStephen Hemminger /* call when cwnd event occurs (optional) */ 6736687e988SArnaldo Carvalho de Melo void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev); 674317a76f9SStephen Hemminger /* new value of cwnd after loss (optional) */ 6756687e988SArnaldo Carvalho de Melo u32 (*undo_cwnd)(struct sock *sk); 676317a76f9SStephen Hemminger /* hook for packet ack accounting (optional) */ 67730cfd0baSStephen Hemminger void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us); 67873c1f4a0SArnaldo Carvalho de Melo /* get info for inet_diag (optional) */ 6796687e988SArnaldo Carvalho de Melo void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb); 680317a76f9SStephen Hemminger 681317a76f9SStephen Hemminger char name[TCP_CA_NAME_MAX]; 682317a76f9SStephen Hemminger struct module *owner; 683317a76f9SStephen Hemminger }; 684317a76f9SStephen Hemminger 685317a76f9SStephen Hemminger extern int tcp_register_congestion_control(struct tcp_congestion_ops *type); 686317a76f9SStephen Hemminger extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); 687317a76f9SStephen Hemminger 6886687e988SArnaldo Carvalho de Melo extern void tcp_init_congestion_control(struct sock *sk); 6896687e988SArnaldo Carvalho de Melo extern void tcp_cleanup_congestion_control(struct sock *sk); 690317a76f9SStephen Hemminger extern int tcp_set_default_congestion_control(const char *name); 691317a76f9SStephen Hemminger extern void tcp_get_default_congestion_control(char *name); 6923ff825b2SStephen Hemminger extern void tcp_get_available_congestion_control(char *buf, size_t len); 693ce7bc3bfSStephen Hemminger extern void tcp_get_allowed_congestion_control(char *buf, size_t len); 694ce7bc3bfSStephen Hemminger extern int tcp_set_allowed_congestion_control(char *allowed); 6956687e988SArnaldo Carvalho de Melo extern int tcp_set_congestion_control(struct sock *sk, const char *name); 69640efc6faSStephen Hemminger extern void tcp_slow_start(struct tcp_sock *tp); 697758ce5c8SIlpo Järvinen extern void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w); 698317a76f9SStephen Hemminger 6995f8ef48dSStephen Hemminger extern struct tcp_congestion_ops tcp_init_congestion_ops; 7006687e988SArnaldo Carvalho de Melo extern u32 tcp_reno_ssthresh(struct sock *sk); 701c3a05c60SIlpo Järvinen extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight); 70272dc5b92SStephen Hemminger extern u32 tcp_reno_min_cwnd(const struct sock *sk); 703a8acfbacSDavid S. Miller extern struct tcp_congestion_ops tcp_reno; 704317a76f9SStephen Hemminger 7056687e988SArnaldo Carvalho de Melo static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state) 706317a76f9SStephen Hemminger { 7076687e988SArnaldo Carvalho de Melo struct inet_connection_sock *icsk = inet_csk(sk); 7086687e988SArnaldo Carvalho de Melo 7096687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->set_state) 7106687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->set_state(sk, ca_state); 7116687e988SArnaldo Carvalho de Melo icsk->icsk_ca_state = ca_state; 712317a76f9SStephen Hemminger } 713317a76f9SStephen Hemminger 7146687e988SArnaldo Carvalho de Melo static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) 715317a76f9SStephen Hemminger { 7166687e988SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 7176687e988SArnaldo Carvalho de Melo 7186687e988SArnaldo Carvalho de Melo if (icsk->icsk_ca_ops->cwnd_event) 7196687e988SArnaldo Carvalho de Melo icsk->icsk_ca_ops->cwnd_event(sk, event); 720317a76f9SStephen Hemminger } 721317a76f9SStephen Hemminger 722e60402d0SIlpo Järvinen /* These functions determine how the current flow behaves in respect of SACK 723e60402d0SIlpo Järvinen * handling. SACK is negotiated with the peer, and therefore it can vary 724e60402d0SIlpo Järvinen * between different flows. 725e60402d0SIlpo Järvinen * 726e60402d0SIlpo Järvinen * tcp_is_sack - SACK enabled 727e60402d0SIlpo Järvinen * tcp_is_reno - No SACK 728e60402d0SIlpo Järvinen * tcp_is_fack - FACK enabled, implies SACK enabled 729e60402d0SIlpo Järvinen */ 730e60402d0SIlpo Järvinen static inline int tcp_is_sack(const struct tcp_sock *tp) 731e60402d0SIlpo Järvinen { 732e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok; 733e60402d0SIlpo Järvinen } 734e60402d0SIlpo Järvinen 735e60402d0SIlpo Järvinen static inline int tcp_is_reno(const struct tcp_sock *tp) 736e60402d0SIlpo Järvinen { 737e60402d0SIlpo Järvinen return !tcp_is_sack(tp); 738e60402d0SIlpo Järvinen } 739e60402d0SIlpo Järvinen 740e60402d0SIlpo Järvinen static inline int tcp_is_fack(const struct tcp_sock *tp) 741e60402d0SIlpo Järvinen { 742e60402d0SIlpo Järvinen return tp->rx_opt.sack_ok & 2; 743e60402d0SIlpo Järvinen } 744e60402d0SIlpo Järvinen 745e60402d0SIlpo Järvinen static inline void tcp_enable_fack(struct tcp_sock *tp) 746e60402d0SIlpo Järvinen { 747e60402d0SIlpo Järvinen tp->rx_opt.sack_ok |= 2; 748e60402d0SIlpo Järvinen } 749e60402d0SIlpo Järvinen 75083ae4088SIlpo Järvinen static inline unsigned int tcp_left_out(const struct tcp_sock *tp) 75183ae4088SIlpo Järvinen { 75283ae4088SIlpo Järvinen return tp->sacked_out + tp->lost_out; 75383ae4088SIlpo Järvinen } 75483ae4088SIlpo Järvinen 7551da177e4SLinus Torvalds /* This determines how many packets are "in the network" to the best 7561da177e4SLinus Torvalds * of our knowledge. In many cases it is conservative, but where 7571da177e4SLinus Torvalds * detailed information is available from the receiver (via SACK 7581da177e4SLinus Torvalds * blocks etc.) we can make more aggressive calculations. 7591da177e4SLinus Torvalds * 7601da177e4SLinus Torvalds * Use this for decisions involving congestion control, use just 7611da177e4SLinus Torvalds * tp->packets_out to determine if the send queue is empty or not. 7621da177e4SLinus Torvalds * 7631da177e4SLinus Torvalds * Read this equation as: 7641da177e4SLinus Torvalds * 7651da177e4SLinus Torvalds * "Packets sent once on transmission queue" MINUS 7661da177e4SLinus Torvalds * "Packets left network, but not honestly ACKed yet" PLUS 7671da177e4SLinus Torvalds * "Packets fast retransmitted" 7681da177e4SLinus Torvalds */ 76940efc6faSStephen Hemminger static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) 7701da177e4SLinus Torvalds { 77183ae4088SIlpo Järvinen return tp->packets_out - tcp_left_out(tp) + tp->retrans_out; 7721da177e4SLinus Torvalds } 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd. 7751da177e4SLinus Torvalds * The exception is rate halving phase, when cwnd is decreasing towards 7761da177e4SLinus Torvalds * ssthresh. 7771da177e4SLinus Torvalds */ 7786687e988SArnaldo Carvalho de Melo static inline __u32 tcp_current_ssthresh(const struct sock *sk) 7791da177e4SLinus Torvalds { 7806687e988SArnaldo Carvalho de Melo const struct tcp_sock *tp = tcp_sk(sk); 7816687e988SArnaldo Carvalho de Melo if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery)) 7821da177e4SLinus Torvalds return tp->snd_ssthresh; 7831da177e4SLinus Torvalds else 7841da177e4SLinus Torvalds return max(tp->snd_ssthresh, 7851da177e4SLinus Torvalds ((tp->snd_cwnd >> 1) + 7861da177e4SLinus Torvalds (tp->snd_cwnd >> 2))); 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds 789b9c4595bSIlpo Järvinen /* Use define here intentionally to get WARN_ON location shown at the caller */ 790b9c4595bSIlpo Järvinen #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out) 7911da177e4SLinus Torvalds 7923cfe3baaSIlpo Järvinen extern void tcp_enter_cwr(struct sock *sk, const int set_ssthresh); 7931da177e4SLinus Torvalds extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst); 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds /* Slow start with delack produces 3 packets of burst, so that 796dd9e0ddaSJohn Heffner * it is safe "de facto". This will be the default - same as 797dd9e0ddaSJohn Heffner * the default reordering threshold - but if reordering increases, 798dd9e0ddaSJohn Heffner * we must be able to allow cwnd to burst at least this much in order 799dd9e0ddaSJohn Heffner * to not pull it back when holes are filled. 8001da177e4SLinus Torvalds */ 8011da177e4SLinus Torvalds static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp) 8021da177e4SLinus Torvalds { 803dd9e0ddaSJohn Heffner return tp->reordering; 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds 80690840defSIlpo Järvinen /* Returns end sequence number of the receiver's advertised window */ 80790840defSIlpo Järvinen static inline u32 tcp_wnd_end(const struct tcp_sock *tp) 80890840defSIlpo Järvinen { 80990840defSIlpo Järvinen return tp->snd_una + tp->snd_wnd; 81090840defSIlpo Järvinen } 811cea14e0eSIlpo Järvinen extern int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight); 812f4805edeSStephen Hemminger 813c1bd24b7SChuck Lever static inline void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss, 8141da177e4SLinus Torvalds const struct sk_buff *skb) 8151da177e4SLinus Torvalds { 8161da177e4SLinus Torvalds if (skb->len < mss) 8171da177e4SLinus Torvalds tp->snd_sml = TCP_SKB_CB(skb)->end_seq; 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds 8209e412ba7SIlpo Järvinen static inline void tcp_check_probe_timer(struct sock *sk) 8211da177e4SLinus Torvalds { 8229e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 823463c84b9SArnaldo Carvalho de Melo const struct inet_connection_sock *icsk = inet_csk(sk); 8249e412ba7SIlpo Järvinen 825463c84b9SArnaldo Carvalho de Melo if (!tp->packets_out && !icsk->icsk_pending) 8263f421baaSArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0, 8273f421baaSArnaldo Carvalho de Melo icsk->icsk_rto, TCP_RTO_MAX); 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds 8309e412ba7SIlpo Järvinen static inline void tcp_push_pending_frames(struct sock *sk) 8311da177e4SLinus Torvalds { 8329e412ba7SIlpo Järvinen struct tcp_sock *tp = tcp_sk(sk); 8339e412ba7SIlpo Järvinen 834*0c54b85fSIlpo Järvinen __tcp_push_pending_frames(sk, tcp_current_mss(sk), tp->nonagle); 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds 837ee7537b6SHantzis Fotis static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq) 8381da177e4SLinus Torvalds { 8391da177e4SLinus Torvalds tp->snd_wl1 = seq; 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds 842ee7537b6SHantzis Fotis static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq) 8431da177e4SLinus Torvalds { 8441da177e4SLinus Torvalds tp->snd_wl1 = seq; 8451da177e4SLinus Torvalds } 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds /* 8481da177e4SLinus Torvalds * Calculate(/check) TCP checksum 8491da177e4SLinus Torvalds */ 850ba7808eaSFrederik Deweerdt static inline __sum16 tcp_v4_check(int len, __be32 saddr, 851ba7808eaSFrederik Deweerdt __be32 daddr, __wsum base) 8521da177e4SLinus Torvalds { 8531da177e4SLinus Torvalds return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds 856b51655b9SAl Viro static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb) 8571da177e4SLinus Torvalds { 858fb286bb2SHerbert Xu return __skb_checksum_complete(skb); 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 86140efc6faSStephen Hemminger static inline int tcp_checksum_complete(struct sk_buff *skb) 8621da177e4SLinus Torvalds { 86360476372SHerbert Xu return !skb_csum_unnecessary(skb) && 8641da177e4SLinus Torvalds __tcp_checksum_complete(skb); 8651da177e4SLinus Torvalds } 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds /* Prequeue for VJ style copy to user, combined with checksumming. */ 8681da177e4SLinus Torvalds 86940efc6faSStephen Hemminger static inline void tcp_prequeue_init(struct tcp_sock *tp) 8701da177e4SLinus Torvalds { 8711da177e4SLinus Torvalds tp->ucopy.task = NULL; 8721da177e4SLinus Torvalds tp->ucopy.len = 0; 8731da177e4SLinus Torvalds tp->ucopy.memory = 0; 8741da177e4SLinus Torvalds skb_queue_head_init(&tp->ucopy.prequeue); 87597fc2f08SChris Leech #ifdef CONFIG_NET_DMA 87697fc2f08SChris Leech tp->ucopy.dma_chan = NULL; 87797fc2f08SChris Leech tp->ucopy.wakeup = 0; 87897fc2f08SChris Leech tp->ucopy.pinned_list = NULL; 87997fc2f08SChris Leech tp->ucopy.dma_cookie = 0; 88097fc2f08SChris Leech #endif 8811da177e4SLinus Torvalds } 8821da177e4SLinus Torvalds 8831da177e4SLinus Torvalds /* Packet is added to VJ-style prequeue for processing in process 8841da177e4SLinus Torvalds * context, if a reader task is waiting. Apparently, this exciting 8851da177e4SLinus Torvalds * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93) 8861da177e4SLinus Torvalds * failed somewhere. Latency? Burstiness? Well, at least now we will 8871da177e4SLinus Torvalds * see, why it failed. 8)8) --ANK 8881da177e4SLinus Torvalds * 8891da177e4SLinus Torvalds * NOTE: is this not too big to inline? 8901da177e4SLinus Torvalds */ 89140efc6faSStephen Hemminger static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb) 8921da177e4SLinus Torvalds { 8931da177e4SLinus Torvalds struct tcp_sock *tp = tcp_sk(sk); 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds if (!sysctl_tcp_low_latency && tp->ucopy.task) { 8961da177e4SLinus Torvalds __skb_queue_tail(&tp->ucopy.prequeue, skb); 8971da177e4SLinus Torvalds tp->ucopy.memory += skb->truesize; 8981da177e4SLinus Torvalds if (tp->ucopy.memory > sk->sk_rcvbuf) { 8991da177e4SLinus Torvalds struct sk_buff *skb1; 9001da177e4SLinus Torvalds 9011da177e4SLinus Torvalds BUG_ON(sock_owned_by_user(sk)); 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) { 904c57943a1SPeter Zijlstra sk_backlog_rcv(sk, skb1); 905de0744afSPavel Emelyanov NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPREQUEUEDROPPED); 9061da177e4SLinus Torvalds } 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds tp->ucopy.memory = 0; 9091da177e4SLinus Torvalds } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) { 9101da177e4SLinus Torvalds wake_up_interruptible(sk->sk_sleep); 911463c84b9SArnaldo Carvalho de Melo if (!inet_csk_ack_scheduled(sk)) 912463c84b9SArnaldo Carvalho de Melo inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, 9133f421baaSArnaldo Carvalho de Melo (3 * TCP_RTO_MIN) / 4, 9143f421baaSArnaldo Carvalho de Melo TCP_RTO_MAX); 9151da177e4SLinus Torvalds } 9161da177e4SLinus Torvalds return 1; 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds return 0; 9191da177e4SLinus Torvalds } 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds #undef STATE_TRACE 9231da177e4SLinus Torvalds 9241da177e4SLinus Torvalds #ifdef STATE_TRACE 9251da177e4SLinus Torvalds static const char *statename[]={ 9261da177e4SLinus Torvalds "Unused","Established","Syn Sent","Syn Recv", 9271da177e4SLinus Torvalds "Fin Wait 1","Fin Wait 2","Time Wait", "Close", 9281da177e4SLinus Torvalds "Close Wait","Last ACK","Listen","Closing" 9291da177e4SLinus Torvalds }; 9301da177e4SLinus Torvalds #endif 931490d5046SIlpo Järvinen extern void tcp_set_state(struct sock *sk, int state); 9321da177e4SLinus Torvalds 9334ac02babSAndi Kleen extern void tcp_done(struct sock *sk); 9341da177e4SLinus Torvalds 93540efc6faSStephen Hemminger static inline void tcp_sack_reset(struct tcp_options_received *rx_opt) 9361da177e4SLinus Torvalds { 9371da177e4SLinus Torvalds rx_opt->dsack = 0; 9381da177e4SLinus Torvalds rx_opt->num_sacks = 0; 9391da177e4SLinus Torvalds } 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds /* Determine a window scaling and initial window to offer. */ 9421da177e4SLinus Torvalds extern void tcp_select_initial_window(int __space, __u32 mss, 9431da177e4SLinus Torvalds __u32 *rcv_wnd, __u32 *window_clamp, 9441da177e4SLinus Torvalds int wscale_ok, __u8 *rcv_wscale); 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds static inline int tcp_win_from_space(int space) 9471da177e4SLinus Torvalds { 9481da177e4SLinus Torvalds return sysctl_tcp_adv_win_scale<=0 ? 9491da177e4SLinus Torvalds (space>>(-sysctl_tcp_adv_win_scale)) : 9501da177e4SLinus Torvalds space - (space>>sysctl_tcp_adv_win_scale); 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds /* Note: caller must be prepared to deal with negative returns */ 9541da177e4SLinus Torvalds static inline int tcp_space(const struct sock *sk) 9551da177e4SLinus Torvalds { 9561da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf - 9571da177e4SLinus Torvalds atomic_read(&sk->sk_rmem_alloc)); 9581da177e4SLinus Torvalds } 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds static inline int tcp_full_space(const struct sock *sk) 9611da177e4SLinus Torvalds { 9621da177e4SLinus Torvalds return tcp_win_from_space(sk->sk_rcvbuf); 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds 96540efc6faSStephen Hemminger static inline void tcp_openreq_init(struct request_sock *req, 9661da177e4SLinus Torvalds struct tcp_options_received *rx_opt, 9671da177e4SLinus Torvalds struct sk_buff *skb) 9681da177e4SLinus Torvalds { 9692e6599cbSArnaldo Carvalho de Melo struct inet_request_sock *ireq = inet_rsk(req); 9702e6599cbSArnaldo Carvalho de Melo 9711da177e4SLinus Torvalds req->rcv_wnd = 0; /* So that tcp_send_synack() knows! */ 9724dfc2817SFlorian Westphal req->cookie_ts = 0; 9732e6599cbSArnaldo Carvalho de Melo tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq; 9741da177e4SLinus Torvalds req->mss = rx_opt->mss_clamp; 9751da177e4SLinus Torvalds req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0; 9762e6599cbSArnaldo Carvalho de Melo ireq->tstamp_ok = rx_opt->tstamp_ok; 9772e6599cbSArnaldo Carvalho de Melo ireq->sack_ok = rx_opt->sack_ok; 9782e6599cbSArnaldo Carvalho de Melo ireq->snd_wscale = rx_opt->snd_wscale; 9792e6599cbSArnaldo Carvalho de Melo ireq->wscale_ok = rx_opt->wscale_ok; 9802e6599cbSArnaldo Carvalho de Melo ireq->acked = 0; 9812e6599cbSArnaldo Carvalho de Melo ireq->ecn_ok = 0; 982aa8223c7SArnaldo Carvalho de Melo ireq->rmt_port = tcp_hdr(skb)->source; 983a3116ac5SKOVACS Krisztian ireq->loc_port = tcp_hdr(skb)->dest; 9841da177e4SLinus Torvalds } 9851da177e4SLinus Torvalds 9865c52ba17SPavel Emelyanov extern void tcp_enter_memory_pressure(struct sock *sk); 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds static inline int keepalive_intvl_when(const struct tcp_sock *tp) 9891da177e4SLinus Torvalds { 9901da177e4SLinus Torvalds return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl; 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds static inline int keepalive_time_when(const struct tcp_sock *tp) 9941da177e4SLinus Torvalds { 9951da177e4SLinus Torvalds return tp->keepalive_time ? : sysctl_tcp_keepalive_time; 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds 998463c84b9SArnaldo Carvalho de Melo static inline int tcp_fin_time(const struct sock *sk) 9991da177e4SLinus Torvalds { 1000463c84b9SArnaldo Carvalho de Melo int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout; 1001463c84b9SArnaldo Carvalho de Melo const int rto = inet_csk(sk)->icsk_rto; 10021da177e4SLinus Torvalds 1003463c84b9SArnaldo Carvalho de Melo if (fin_timeout < (rto << 2) - (rto >> 1)) 1004463c84b9SArnaldo Carvalho de Melo fin_timeout = (rto << 2) - (rto >> 1); 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds return fin_timeout; 10071da177e4SLinus Torvalds } 10081da177e4SLinus Torvalds 1009c887e6d2SIlpo Järvinen static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, 1010c887e6d2SIlpo Järvinen int paws_win) 10111da177e4SLinus Torvalds { 1012c887e6d2SIlpo Järvinen if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win) 1013c887e6d2SIlpo Järvinen return 1; 1014c887e6d2SIlpo Järvinen if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)) 1015c887e6d2SIlpo Järvinen return 1; 1016c887e6d2SIlpo Järvinen 10171da177e4SLinus Torvalds return 0; 1018c887e6d2SIlpo Järvinen } 1019c887e6d2SIlpo Järvinen 1020c887e6d2SIlpo Järvinen static inline int tcp_paws_reject(const struct tcp_options_received *rx_opt, 1021c887e6d2SIlpo Järvinen int rst) 1022c887e6d2SIlpo Järvinen { 1023c887e6d2SIlpo Järvinen if (tcp_paws_check(rx_opt, 0)) 10241da177e4SLinus Torvalds return 0; 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds /* RST segments are not recommended to carry timestamp, 10271da177e4SLinus Torvalds and, if they do, it is recommended to ignore PAWS because 10281da177e4SLinus Torvalds "their cleanup function should take precedence over timestamps." 10291da177e4SLinus Torvalds Certainly, it is mistake. It is necessary to understand the reasons 10301da177e4SLinus Torvalds of this constraint to relax it: if peer reboots, clock may go 10311da177e4SLinus Torvalds out-of-sync and half-open connections will not be reset. 10321da177e4SLinus Torvalds Actually, the problem would be not existing if all 10331da177e4SLinus Torvalds the implementations followed draft about maintaining clock 10341da177e4SLinus Torvalds via reboots. Linux-2.2 DOES NOT! 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds However, we can relax time bounds for RST segments to MSL. 10371da177e4SLinus Torvalds */ 10389d729f72SJames Morris if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL) 10391da177e4SLinus Torvalds return 0; 10401da177e4SLinus Torvalds return 1; 10411da177e4SLinus Torvalds } 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds #define TCP_CHECK_TIMER(sk) do { } while (0) 10441da177e4SLinus Torvalds 1045a9c19329SPavel Emelyanov static inline void tcp_mib_init(struct net *net) 10461da177e4SLinus Torvalds { 10471da177e4SLinus Torvalds /* See RFC 2012 */ 1048cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOALGORITHM, 1); 1049cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ); 1050cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ); 1051cf1100a7SPavel Emelyanov TCP_ADD_STATS_USER(net, TCP_MIB_MAXCONN, -1); 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 10546a438bbeSStephen Hemminger /* from STCP */ 1055ef9da47cSIlpo Järvinen static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp) 10560800f170SDavid S. Miller { 10576a438bbeSStephen Hemminger tp->lost_skb_hint = NULL; 10586a438bbeSStephen Hemminger tp->scoreboard_skb_hint = NULL; 1059ef9da47cSIlpo Järvinen } 1060ef9da47cSIlpo Järvinen 1061ef9da47cSIlpo Järvinen static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp) 1062ef9da47cSIlpo Järvinen { 1063ef9da47cSIlpo Järvinen tcp_clear_retrans_hints_partial(tp); 10646a438bbeSStephen Hemminger tp->retransmit_skb_hint = NULL; 1065b7689205SIlpo Järvinen } 1066b7689205SIlpo Järvinen 1067cfb6eeb4SYOSHIFUJI Hideaki /* MD5 Signature */ 1068cfb6eeb4SYOSHIFUJI Hideaki struct crypto_hash; 1069cfb6eeb4SYOSHIFUJI Hideaki 1070cfb6eeb4SYOSHIFUJI Hideaki /* - key database */ 1071cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key { 1072cfb6eeb4SYOSHIFUJI Hideaki u8 *key; 1073cfb6eeb4SYOSHIFUJI Hideaki u8 keylen; 1074cfb6eeb4SYOSHIFUJI Hideaki }; 1075cfb6eeb4SYOSHIFUJI Hideaki 1076cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_md5sig_key { 1077f8ab18d2SDavid S. Miller struct tcp_md5sig_key base; 1078cfb6eeb4SYOSHIFUJI Hideaki __be32 addr; 1079cfb6eeb4SYOSHIFUJI Hideaki }; 1080cfb6eeb4SYOSHIFUJI Hideaki 1081cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_md5sig_key { 1082f8ab18d2SDavid S. Miller struct tcp_md5sig_key base; 1083cfb6eeb4SYOSHIFUJI Hideaki #if 0 1084cfb6eeb4SYOSHIFUJI Hideaki u32 scope_id; /* XXX */ 1085cfb6eeb4SYOSHIFUJI Hideaki #endif 1086cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr addr; 1087cfb6eeb4SYOSHIFUJI Hideaki }; 1088cfb6eeb4SYOSHIFUJI Hideaki 1089cfb6eeb4SYOSHIFUJI Hideaki /* - sock block */ 1090cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_info { 1091cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_md5sig_key *keys4; 1092cfb6eeb4SYOSHIFUJI Hideaki #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 1093cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_md5sig_key *keys6; 1094cfb6eeb4SYOSHIFUJI Hideaki u32 entries6; 1095cfb6eeb4SYOSHIFUJI Hideaki u32 alloced6; 1096cfb6eeb4SYOSHIFUJI Hideaki #endif 1097cfb6eeb4SYOSHIFUJI Hideaki u32 entries4; 1098cfb6eeb4SYOSHIFUJI Hideaki u32 alloced4; 1099cfb6eeb4SYOSHIFUJI Hideaki }; 1100cfb6eeb4SYOSHIFUJI Hideaki 1101cfb6eeb4SYOSHIFUJI Hideaki /* - pseudo header */ 1102cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr { 1103cfb6eeb4SYOSHIFUJI Hideaki __be32 saddr; 1104cfb6eeb4SYOSHIFUJI Hideaki __be32 daddr; 1105cfb6eeb4SYOSHIFUJI Hideaki __u8 pad; 1106cfb6eeb4SYOSHIFUJI Hideaki __u8 protocol; 1107cfb6eeb4SYOSHIFUJI Hideaki __be16 len; 1108cfb6eeb4SYOSHIFUJI Hideaki }; 1109cfb6eeb4SYOSHIFUJI Hideaki 1110cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr { 1111cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr saddr; 1112cfb6eeb4SYOSHIFUJI Hideaki struct in6_addr daddr; 1113cfb6eeb4SYOSHIFUJI Hideaki __be32 len; 1114cfb6eeb4SYOSHIFUJI Hideaki __be32 protocol; /* including padding */ 1115cfb6eeb4SYOSHIFUJI Hideaki }; 1116cfb6eeb4SYOSHIFUJI Hideaki 1117cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block { 1118cfb6eeb4SYOSHIFUJI Hideaki struct tcp4_pseudohdr ip4; 1119cfb6eeb4SYOSHIFUJI Hideaki #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 1120cfb6eeb4SYOSHIFUJI Hideaki struct tcp6_pseudohdr ip6; 1121cfb6eeb4SYOSHIFUJI Hideaki #endif 1122cfb6eeb4SYOSHIFUJI Hideaki }; 1123cfb6eeb4SYOSHIFUJI Hideaki 1124cfb6eeb4SYOSHIFUJI Hideaki /* - pool: digest algorithm, hash description and scratch buffer */ 1125cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool { 1126cfb6eeb4SYOSHIFUJI Hideaki struct hash_desc md5_desc; 1127cfb6eeb4SYOSHIFUJI Hideaki union tcp_md5sum_block md5_blk; 1128cfb6eeb4SYOSHIFUJI Hideaki }; 1129cfb6eeb4SYOSHIFUJI Hideaki 1130cfb6eeb4SYOSHIFUJI Hideaki #define TCP_MD5SIG_MAXKEYS (~(u32)0) /* really?! */ 1131cfb6eeb4SYOSHIFUJI Hideaki 1132cfb6eeb4SYOSHIFUJI Hideaki /* - functions */ 113349a72dfbSAdam Langley extern int tcp_v4_md5_hash_skb(char *md5_hash, 1134cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *key, 1135cfb6eeb4SYOSHIFUJI Hideaki struct sock *sk, 1136cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req, 113749a72dfbSAdam Langley struct sk_buff *skb); 113849a72dfbSAdam Langley 1139cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk, 1140cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1141cfb6eeb4SYOSHIFUJI Hideaki 1142cfb6eeb4SYOSHIFUJI Hideaki extern int tcp_v4_md5_do_add(struct sock *sk, 1143cfb6eeb4SYOSHIFUJI Hideaki __be32 addr, 1144cfb6eeb4SYOSHIFUJI Hideaki u8 *newkey, 1145cfb6eeb4SYOSHIFUJI Hideaki u8 newkeylen); 1146cfb6eeb4SYOSHIFUJI Hideaki 1147cfb6eeb4SYOSHIFUJI Hideaki extern int tcp_v4_md5_do_del(struct sock *sk, 11488e5200f5SAl Viro __be32 addr); 1149cfb6eeb4SYOSHIFUJI Hideaki 11509501f972SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 11519501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_keylen ? \ 11529501f972SYOSHIFUJI Hideaki &(struct tcp_md5sig_key) { \ 11539501f972SYOSHIFUJI Hideaki .key = (twsk)->tw_md5_key, \ 11549501f972SYOSHIFUJI Hideaki .keylen = (twsk)->tw_md5_keylen, \ 11559501f972SYOSHIFUJI Hideaki } : NULL) 11569501f972SYOSHIFUJI Hideaki #else 11579501f972SYOSHIFUJI Hideaki #define tcp_twsk_md5_key(twsk) NULL 11589501f972SYOSHIFUJI Hideaki #endif 11599501f972SYOSHIFUJI Hideaki 1160cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_pool **tcp_alloc_md5sig_pool(void); 1161cfb6eeb4SYOSHIFUJI Hideaki extern void tcp_free_md5sig_pool(void); 1162cfb6eeb4SYOSHIFUJI Hideaki 1163cfb6eeb4SYOSHIFUJI Hideaki extern struct tcp_md5sig_pool *__tcp_get_md5sig_pool(int cpu); 1164cfb6eeb4SYOSHIFUJI Hideaki extern void __tcp_put_md5sig_pool(void); 116549a72dfbSAdam Langley extern int tcp_md5_hash_header(struct tcp_md5sig_pool *, struct tcphdr *); 116649a72dfbSAdam Langley extern int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, struct sk_buff *, 116749a72dfbSAdam Langley unsigned header_len); 116849a72dfbSAdam Langley extern int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, 116949a72dfbSAdam Langley struct tcp_md5sig_key *key); 1170cfb6eeb4SYOSHIFUJI Hideaki 1171cfb6eeb4SYOSHIFUJI Hideaki static inline 1172cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool *tcp_get_md5sig_pool(void) 1173cfb6eeb4SYOSHIFUJI Hideaki { 1174cfb6eeb4SYOSHIFUJI Hideaki int cpu = get_cpu(); 1175cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_pool *ret = __tcp_get_md5sig_pool(cpu); 1176cfb6eeb4SYOSHIFUJI Hideaki if (!ret) 1177cfb6eeb4SYOSHIFUJI Hideaki put_cpu(); 1178cfb6eeb4SYOSHIFUJI Hideaki return ret; 1179cfb6eeb4SYOSHIFUJI Hideaki } 1180cfb6eeb4SYOSHIFUJI Hideaki 1181cfb6eeb4SYOSHIFUJI Hideaki static inline void tcp_put_md5sig_pool(void) 1182cfb6eeb4SYOSHIFUJI Hideaki { 1183cfb6eeb4SYOSHIFUJI Hideaki __tcp_put_md5sig_pool(); 1184cfb6eeb4SYOSHIFUJI Hideaki put_cpu(); 1185cfb6eeb4SYOSHIFUJI Hideaki } 1186cfb6eeb4SYOSHIFUJI Hideaki 1187fe067e8aSDavid S. Miller /* write queue abstraction */ 1188fe067e8aSDavid S. Miller static inline void tcp_write_queue_purge(struct sock *sk) 1189fe067e8aSDavid S. Miller { 1190fe067e8aSDavid S. Miller struct sk_buff *skb; 1191fe067e8aSDavid S. Miller 1192fe067e8aSDavid S. Miller while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) 11933ab224beSHideo Aoki sk_wmem_free_skb(sk, skb); 11943ab224beSHideo Aoki sk_mem_reclaim(sk); 1195fe067e8aSDavid S. Miller } 1196fe067e8aSDavid S. Miller 1197fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_write_queue_head(struct sock *sk) 1198fe067e8aSDavid S. Miller { 1199cd07a8eaSDavid S. Miller return skb_peek(&sk->sk_write_queue); 1200fe067e8aSDavid S. Miller } 1201fe067e8aSDavid S. Miller 1202fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_write_queue_tail(struct sock *sk) 1203fe067e8aSDavid S. Miller { 1204cd07a8eaSDavid S. Miller return skb_peek_tail(&sk->sk_write_queue); 1205fe067e8aSDavid S. Miller } 1206fe067e8aSDavid S. Miller 1207fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_write_queue_next(struct sock *sk, struct sk_buff *skb) 1208fe067e8aSDavid S. Miller { 1209cd07a8eaSDavid S. Miller return skb_queue_next(&sk->sk_write_queue, skb); 1210fe067e8aSDavid S. Miller } 1211fe067e8aSDavid S. Miller 1212832d11c5SIlpo Järvinen static inline struct sk_buff *tcp_write_queue_prev(struct sock *sk, struct sk_buff *skb) 1213832d11c5SIlpo Järvinen { 1214832d11c5SIlpo Järvinen return skb_queue_prev(&sk->sk_write_queue, skb); 1215832d11c5SIlpo Järvinen } 1216832d11c5SIlpo Järvinen 1217fe067e8aSDavid S. Miller #define tcp_for_write_queue(skb, sk) \ 1218cd07a8eaSDavid S. Miller skb_queue_walk(&(sk)->sk_write_queue, skb) 1219fe067e8aSDavid S. Miller 1220fe067e8aSDavid S. Miller #define tcp_for_write_queue_from(skb, sk) \ 1221cd07a8eaSDavid S. Miller skb_queue_walk_from(&(sk)->sk_write_queue, skb) 1222fe067e8aSDavid S. Miller 1223234b6860SIlpo Järvinen #define tcp_for_write_queue_from_safe(skb, tmp, sk) \ 1224cd07a8eaSDavid S. Miller skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp) 1225234b6860SIlpo Järvinen 1226fe067e8aSDavid S. Miller static inline struct sk_buff *tcp_send_head(struct sock *sk) 1227fe067e8aSDavid S. Miller { 1228fe067e8aSDavid S. Miller return sk->sk_send_head; 1229fe067e8aSDavid S. Miller } 1230fe067e8aSDavid S. Miller 1231cd07a8eaSDavid S. Miller static inline bool tcp_skb_is_last(const struct sock *sk, 1232cd07a8eaSDavid S. Miller const struct sk_buff *skb) 1233cd07a8eaSDavid S. Miller { 1234cd07a8eaSDavid S. Miller return skb_queue_is_last(&sk->sk_write_queue, skb); 1235cd07a8eaSDavid S. Miller } 1236cd07a8eaSDavid S. Miller 1237fe067e8aSDavid S. Miller static inline void tcp_advance_send_head(struct sock *sk, struct sk_buff *skb) 1238fe067e8aSDavid S. Miller { 1239cd07a8eaSDavid S. Miller if (tcp_skb_is_last(sk, skb)) 1240fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1241cd07a8eaSDavid S. Miller else 1242cd07a8eaSDavid S. Miller sk->sk_send_head = tcp_write_queue_next(sk, skb); 1243fe067e8aSDavid S. Miller } 1244fe067e8aSDavid S. Miller 1245fe067e8aSDavid S. Miller static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked) 1246fe067e8aSDavid S. Miller { 1247fe067e8aSDavid S. Miller if (sk->sk_send_head == skb_unlinked) 1248fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1249fe067e8aSDavid S. Miller } 1250fe067e8aSDavid S. Miller 1251fe067e8aSDavid S. Miller static inline void tcp_init_send_head(struct sock *sk) 1252fe067e8aSDavid S. Miller { 1253fe067e8aSDavid S. Miller sk->sk_send_head = NULL; 1254fe067e8aSDavid S. Miller } 1255fe067e8aSDavid S. Miller 1256fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1257fe067e8aSDavid S. Miller { 1258fe067e8aSDavid S. Miller __skb_queue_tail(&sk->sk_write_queue, skb); 1259fe067e8aSDavid S. Miller } 1260fe067e8aSDavid S. Miller 1261fe067e8aSDavid S. Miller static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb) 1262fe067e8aSDavid S. Miller { 1263fe067e8aSDavid S. Miller __tcp_add_write_queue_tail(sk, skb); 1264fe067e8aSDavid S. Miller 1265fe067e8aSDavid S. Miller /* Queue it, remembering where we must start sending. */ 12666859d494SIlpo Järvinen if (sk->sk_send_head == NULL) { 1267fe067e8aSDavid S. Miller sk->sk_send_head = skb; 12686859d494SIlpo Järvinen 12696859d494SIlpo Järvinen if (tcp_sk(sk)->highest_sack == NULL) 12706859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = skb; 12716859d494SIlpo Järvinen } 1272fe067e8aSDavid S. Miller } 1273fe067e8aSDavid S. Miller 1274fe067e8aSDavid S. Miller static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb) 1275fe067e8aSDavid S. Miller { 1276fe067e8aSDavid S. Miller __skb_queue_head(&sk->sk_write_queue, skb); 1277fe067e8aSDavid S. Miller } 1278fe067e8aSDavid S. Miller 1279fe067e8aSDavid S. Miller /* Insert buff after skb on the write queue of sk. */ 1280fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_after(struct sk_buff *skb, 1281fe067e8aSDavid S. Miller struct sk_buff *buff, 1282fe067e8aSDavid S. Miller struct sock *sk) 1283fe067e8aSDavid S. Miller { 12847de6c033SGerrit Renker __skb_queue_after(&sk->sk_write_queue, skb, buff); 1285fe067e8aSDavid S. Miller } 1286fe067e8aSDavid S. Miller 128743f59c89SDavid S. Miller /* Insert new before skb on the write queue of sk. */ 1288fe067e8aSDavid S. Miller static inline void tcp_insert_write_queue_before(struct sk_buff *new, 1289fe067e8aSDavid S. Miller struct sk_buff *skb, 1290fe067e8aSDavid S. Miller struct sock *sk) 1291fe067e8aSDavid S. Miller { 129243f59c89SDavid S. Miller __skb_queue_before(&sk->sk_write_queue, skb, new); 12936e421410SIlpo Järvinen 12946e421410SIlpo Järvinen if (sk->sk_send_head == skb) 12956e421410SIlpo Järvinen sk->sk_send_head = new; 1296fe067e8aSDavid S. Miller } 1297fe067e8aSDavid S. Miller 1298fe067e8aSDavid S. Miller static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk) 1299fe067e8aSDavid S. Miller { 1300fe067e8aSDavid S. Miller __skb_unlink(skb, &sk->sk_write_queue); 1301fe067e8aSDavid S. Miller } 1302fe067e8aSDavid S. Miller 1303fe067e8aSDavid S. Miller static inline int tcp_write_queue_empty(struct sock *sk) 1304fe067e8aSDavid S. Miller { 1305fe067e8aSDavid S. Miller return skb_queue_empty(&sk->sk_write_queue); 1306fe067e8aSDavid S. Miller } 1307fe067e8aSDavid S. Miller 1308a47e5a98SIlpo Järvinen /* Start sequence of the highest skb with SACKed bit, valid only if 1309a47e5a98SIlpo Järvinen * sacked > 0 or when the caller has ensured validity by itself. 1310a47e5a98SIlpo Järvinen */ 1311a47e5a98SIlpo Järvinen static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp) 1312a47e5a98SIlpo Järvinen { 1313a47e5a98SIlpo Järvinen if (!tp->sacked_out) 1314a47e5a98SIlpo Järvinen return tp->snd_una; 13156859d494SIlpo Järvinen 13166859d494SIlpo Järvinen if (tp->highest_sack == NULL) 13176859d494SIlpo Järvinen return tp->snd_nxt; 13186859d494SIlpo Järvinen 1319a47e5a98SIlpo Järvinen return TCP_SKB_CB(tp->highest_sack)->seq; 1320a47e5a98SIlpo Järvinen } 1321a47e5a98SIlpo Järvinen 13226859d494SIlpo Järvinen static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb) 13236859d494SIlpo Järvinen { 13246859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_skb_is_last(sk, skb) ? NULL : 13256859d494SIlpo Järvinen tcp_write_queue_next(sk, skb); 13266859d494SIlpo Järvinen } 13276859d494SIlpo Järvinen 13286859d494SIlpo Järvinen static inline struct sk_buff *tcp_highest_sack(struct sock *sk) 13296859d494SIlpo Järvinen { 13306859d494SIlpo Järvinen return tcp_sk(sk)->highest_sack; 13316859d494SIlpo Järvinen } 13326859d494SIlpo Järvinen 13336859d494SIlpo Järvinen static inline void tcp_highest_sack_reset(struct sock *sk) 13346859d494SIlpo Järvinen { 13356859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk); 13366859d494SIlpo Järvinen } 13376859d494SIlpo Järvinen 13386859d494SIlpo Järvinen /* Called when old skb is about to be deleted (to be combined with new skb) */ 13396859d494SIlpo Järvinen static inline void tcp_highest_sack_combine(struct sock *sk, 13406859d494SIlpo Järvinen struct sk_buff *old, 13416859d494SIlpo Järvinen struct sk_buff *new) 13426859d494SIlpo Järvinen { 13436859d494SIlpo Järvinen if (tcp_sk(sk)->sacked_out && (old == tcp_sk(sk)->highest_sack)) 13446859d494SIlpo Järvinen tcp_sk(sk)->highest_sack = new; 13456859d494SIlpo Järvinen } 13466859d494SIlpo Järvinen 13471da177e4SLinus Torvalds /* /proc */ 13481da177e4SLinus Torvalds enum tcp_seq_states { 13491da177e4SLinus Torvalds TCP_SEQ_STATE_LISTENING, 13501da177e4SLinus Torvalds TCP_SEQ_STATE_OPENREQ, 13511da177e4SLinus Torvalds TCP_SEQ_STATE_ESTABLISHED, 13521da177e4SLinus Torvalds TCP_SEQ_STATE_TIME_WAIT, 13531da177e4SLinus Torvalds }; 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds struct tcp_seq_afinfo { 13561da177e4SLinus Torvalds char *name; 13571da177e4SLinus Torvalds sa_family_t family; 135868fcadd1SDenis V. Lunev struct file_operations seq_fops; 13599427c4b3SDenis V. Lunev struct seq_operations seq_ops; 13601da177e4SLinus Torvalds }; 13611da177e4SLinus Torvalds 13621da177e4SLinus Torvalds struct tcp_iter_state { 1363a4146b1bSDenis V. Lunev struct seq_net_private p; 13641da177e4SLinus Torvalds sa_family_t family; 13651da177e4SLinus Torvalds enum tcp_seq_states state; 13661da177e4SLinus Torvalds struct sock *syn_wait_sk; 13671da177e4SLinus Torvalds int bucket, sbucket, num, uid; 13681da177e4SLinus Torvalds }; 13691da177e4SLinus Torvalds 13706f8b13bcSDaniel Lezcano extern int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo); 13716f8b13bcSDaniel Lezcano extern void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo); 13721da177e4SLinus Torvalds 137320380731SArnaldo Carvalho de Melo extern struct request_sock_ops tcp_request_sock_ops; 1374c6aefafbSGlenn Griffin extern struct request_sock_ops tcp6_request_sock_ops; 137520380731SArnaldo Carvalho de Melo 13767d06b2e0SBrian Haley extern void tcp_v4_destroy_sock(struct sock *sk); 137720380731SArnaldo Carvalho de Melo 1378a430a43dSHerbert Xu extern int tcp_v4_gso_send_check(struct sk_buff *skb); 1379576a30ebSHerbert Xu extern struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features); 1380bf296b12SHerbert Xu extern struct sk_buff **tcp_gro_receive(struct sk_buff **head, 1381bf296b12SHerbert Xu struct sk_buff *skb); 1382bf296b12SHerbert Xu extern struct sk_buff **tcp4_gro_receive(struct sk_buff **head, 1383bf296b12SHerbert Xu struct sk_buff *skb); 1384bf296b12SHerbert Xu extern int tcp_gro_complete(struct sk_buff *skb); 1385bf296b12SHerbert Xu extern int tcp4_gro_complete(struct sk_buff *skb); 1386f4c50d99SHerbert Xu 138720380731SArnaldo Carvalho de Melo #ifdef CONFIG_PROC_FS 138820380731SArnaldo Carvalho de Melo extern int tcp4_proc_init(void); 138920380731SArnaldo Carvalho de Melo extern void tcp4_proc_exit(void); 139020380731SArnaldo Carvalho de Melo #endif 139120380731SArnaldo Carvalho de Melo 1392cfb6eeb4SYOSHIFUJI Hideaki /* TCP af-specific functions */ 1393cfb6eeb4SYOSHIFUJI Hideaki struct tcp_sock_af_ops { 1394cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1395cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1396cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk); 1397cfb6eeb4SYOSHIFUJI Hideaki int (*calc_md5_hash) (char *location, 1398cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *md5, 1399cfb6eeb4SYOSHIFUJI Hideaki struct sock *sk, 1400cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req, 140149a72dfbSAdam Langley struct sk_buff *skb); 1402cfb6eeb4SYOSHIFUJI Hideaki int (*md5_add) (struct sock *sk, 1403cfb6eeb4SYOSHIFUJI Hideaki struct sock *addr_sk, 1404cfb6eeb4SYOSHIFUJI Hideaki u8 *newkey, 1405cfb6eeb4SYOSHIFUJI Hideaki u8 len); 1406cfb6eeb4SYOSHIFUJI Hideaki int (*md5_parse) (struct sock *sk, 1407cfb6eeb4SYOSHIFUJI Hideaki char __user *optval, 1408cfb6eeb4SYOSHIFUJI Hideaki int optlen); 1409cfb6eeb4SYOSHIFUJI Hideaki #endif 1410cfb6eeb4SYOSHIFUJI Hideaki }; 1411cfb6eeb4SYOSHIFUJI Hideaki 1412cfb6eeb4SYOSHIFUJI Hideaki struct tcp_request_sock_ops { 1413cfb6eeb4SYOSHIFUJI Hideaki #ifdef CONFIG_TCP_MD5SIG 1414cfb6eeb4SYOSHIFUJI Hideaki struct tcp_md5sig_key *(*md5_lookup) (struct sock *sk, 1415cfb6eeb4SYOSHIFUJI Hideaki struct request_sock *req); 1416cfb6eeb4SYOSHIFUJI Hideaki #endif 1417cfb6eeb4SYOSHIFUJI Hideaki }; 1418cfb6eeb4SYOSHIFUJI Hideaki 14199b0f976fSDenis V. Lunev extern void tcp_v4_init(void); 142020380731SArnaldo Carvalho de Melo extern void tcp_init(void); 142120380731SArnaldo Carvalho de Melo 14221da177e4SLinus Torvalds #endif /* _TCP_H */ 1423