projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net/wan: use module_pci_driver
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / net / tcp.h
CommitLineData
1da177e4
LT		 1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Definitions for the TCP module.
7 *
8 * Version: @(#)tcp.h 1.0.5 05/23/93
9 *
02c30a84 10 * Authors: Ross Biro
1da177e4
LT		 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version
16 * 2 of the License, or (at your option) any later version.
17 */
18#ifndef _TCP_H
19#define _TCP_H
20
1da177e4
LT		 21#define FASTRETRANS_DEBUG 1
22
1da177e4
LT		 23#include <linux/list.h>
24#include <linux/tcp.h>
187f1882 25#include <linux/bug.h>
1da177e4
LT		 26#include <linux/slab.h>
27#include <linux/cache.h>
28#include <linux/percpu.h>
fb286bb2 29#include <linux/skbuff.h>
97fc2f08 30#include <linux/dmaengine.h>
cfb6eeb4 31#include <linux/crypto.h>
c6aefafb 32#include <linux/cryptohash.h>
435cf559 33#include <linux/kref.h>
3f421baa
ACM		 34
35#include <net/inet_connection_sock.h>
295ff7ed 36#include <net/inet_timewait_sock.h>
77d8bf9c 37#include <net/inet_hashtables.h>
1da177e4 38#include <net/checksum.h>
2e6599cb 39#include <net/request_sock.h>
1da177e4
LT		 40#include <net/sock.h>
41#include <net/snmp.h>
42#include <net/ip.h>
c752f073 43#include <net/tcp_states.h>
bdf1ee5d 44#include <net/inet_ecn.h>
0c266898 45#include <net/dst.h>
c752f073 46
1da177e4 47#include <linux/seq_file.h>
180d8cd9 48#include <linux/memcontrol.h>
1da177e4 49
6e04e021 50extern struct inet_hashinfo tcp_hashinfo;
1da177e4 51
dd24c001 52extern struct percpu_counter tcp_orphan_count;
1da177e4 53extern void tcp_time_wait(struct sock *sk, int state, int timeo);
1da177e4 54
1da177e4 55#define MAX_TCP_HEADER (128 + MAX_HEADER)
33ad798c 56#define MAX_TCP_OPTION_SPACE 40
1da177e4
LT		 57
58/*
59 * Never offer a window over 32767 without using window scaling. Some
60 * poor stacks do signed 16bit maths!
61 */
62#define MAX_TCP_WINDOW 32767U
63
356f0398
ND		 64/* Offer an initial receive window of 10 mss. */
65#define TCP_DEFAULT_INIT_RCVWND 10
66
1da177e4
LT		 67/* Minimal accepted MSS. It is (60+60+8) - (20+20). */
68#define TCP_MIN_MSS 88U
69
5d424d5a
JH		 70/* The least MTU to use for probing */
71#define TCP_BASE_MSS 512
72
1da177e4
LT		 73/* After receiving this amount of duplicate ACKs fast retransmit starts. */
74#define TCP_FASTRETRANS_THRESH 3
75
76/* Maximal reordering. */
77#define TCP_MAX_REORDERING 127
78
79/* Maximal number of ACKs sent quickly to accelerate slow-start. */
80#define TCP_MAX_QUICKACKS 16U
81
82/* urg_data states */
83#define TCP_URG_VALID 0x0100
84#define TCP_URG_NOTYET 0x0200
85#define TCP_URG_READ 0x0400
86
87#define TCP_RETR1 3 /*
88 * This is how many retries it does before it
89 * tries to figure out if the gateway is
90 * down. Minimal RFC value is 3; it corresponds
91 * to ~3sec-8min depending on RTO.
92 */
93
94#define TCP_RETR2 15 /*
95 * This should take at least
96 * 90 minutes to time out.
97 * RFC1122 says that the limit is 100 sec.
98 * 15 is ~13-30min depending on RTO.
99 */
100
101#define TCP_SYN_RETRIES 5 /* number of times to retry active opening a
caa20d9a 102 * connection: ~180sec is RFC minimum */
1da177e4
LT		 103
104#define TCP_SYNACK_RETRIES 5 /* number of times to retry passive opening a
caa20d9a 105 * connection: ~180sec is RFC minimum */
1da177e4 106
1da177e4
LT		 107#define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
108 * state, about 60 seconds */
109#define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN
110 /* BSD style FIN_WAIT2 deadlock breaker.
111 * It used to be 3min, new value is 60sec,
112 * to combine FIN-WAIT-2 timeout with
113 * TIME-WAIT timer.
114 */
115
116#define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */
117#if HZ >= 100
118#define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */
119#define TCP_ATO_MIN ((unsigned)(HZ/25))
120#else
121#define TCP_DELACK_MIN 4U
122#define TCP_ATO_MIN 4U
123#endif
124#define TCP_RTO_MAX ((unsigned)(120*HZ))
125#define TCP_RTO_MIN ((unsigned)(HZ/5))
9ad7c049
JC		 126#define TCP_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC2988bis initial RTO value */
127#define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value, now
128 * used as a fallback RTO for the
129 * initial data transmission if no
130 * valid RTT sample has been acquired,
131 * most likely due to retrans in 3WHS.
132 */
1da177e4
LT		 133
134#define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
135 * for local resources.
136 */
137
138#define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */
139#define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */
140#define TCP_KEEPALIVE_INTVL (75*HZ)
141
142#define MAX_TCP_KEEPIDLE 32767
143#define MAX_TCP_KEEPINTVL 32767
144#define MAX_TCP_KEEPCNT 127
145#define MAX_TCP_SYNCNT 127
146
147#define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */
1da177e4
LT		 148
149#define TCP_PAWS_24DAYS (60 * 60 * 24 * 24)
150#define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated
151 * after this time. It should be equal
152 * (or greater than) TCP_TIMEWAIT_LEN
153 * to provide reliability equal to one
154 * provided by timewait state.
155 */
156#define TCP_PAWS_WINDOW 1 /* Replay window for per-host
157 * timestamps. It must be less than
158 * minimal timewait lifetime.
159 */
1da177e4
LT		 160/*
161 * TCP option
162 */
163
164#define TCPOPT_NOP 1 /* Padding */
165#define TCPOPT_EOL 0 /* End of options */
166#define TCPOPT_MSS 2 /* Segment size negotiating */
167#define TCPOPT_WINDOW 3 /* Window scaling */
168#define TCPOPT_SACK_PERM 4 /* SACK Permitted */
169#define TCPOPT_SACK 5 /* SACK Block */
170#define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */
cfb6eeb4 171#define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */
435cf559 172#define TCPOPT_COOKIE 253 /* Cookie extension (experimental) */
1da177e4
LT		 173
174/*
175 * TCP option lengths
176 */
177
178#define TCPOLEN_MSS 4
179#define TCPOLEN_WINDOW 3
180#define TCPOLEN_SACK_PERM 2
181#define TCPOLEN_TIMESTAMP 10
cfb6eeb4 182#define TCPOLEN_MD5SIG 18
435cf559
WAS		 183#define TCPOLEN_COOKIE_BASE 2 /* Cookie-less header extension */
184#define TCPOLEN_COOKIE_PAIR 3 /* Cookie pair header extension */
185#define TCPOLEN_COOKIE_MIN (TCPOLEN_COOKIE_BASE+TCP_COOKIE_MIN)
186#define TCPOLEN_COOKIE_MAX (TCPOLEN_COOKIE_BASE+TCP_COOKIE_MAX)
1da177e4
LT		 187
188/* But this is what stacks really send out. */
189#define TCPOLEN_TSTAMP_ALIGNED 12
190#define TCPOLEN_WSCALE_ALIGNED 4
191#define TCPOLEN_SACKPERM_ALIGNED 4
192#define TCPOLEN_SACK_BASE 2
193#define TCPOLEN_SACK_BASE_ALIGNED 4
194#define TCPOLEN_SACK_PERBLOCK 8
cfb6eeb4 195#define TCPOLEN_MD5SIG_ALIGNED 20
33ad798c 196#define TCPOLEN_MSS_ALIGNED 4
1da177e4 197
1da177e4
LT		 198/* Flags in tp->nonagle */
199#define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */
200#define TCP_NAGLE_CORK 2 /* Socket is corked */
caa20d9a 201#define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */
1da177e4 202
36e31b0a
AP		 203/* TCP thin-stream limits */
204#define TCP_THIN_LINEAR_RETRIES 6 /* After 6 linear retries, do exp. backoff */
205
7eb38527 206/* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */
442b9635
DM		 207#define TCP_INIT_CWND 10
208
295ff7ed
ACM		 209extern struct inet_timewait_death_row tcp_death_row;
210
1da177e4 211/* sysctl variables for tcp */
1da177e4
LT		 212extern int sysctl_tcp_timestamps;
213extern int sysctl_tcp_window_scaling;
214extern int sysctl_tcp_sack;
215extern int sysctl_tcp_fin_timeout;
1da177e4
LT		 216extern int sysctl_tcp_keepalive_time;
217extern int sysctl_tcp_keepalive_probes;
218extern int sysctl_tcp_keepalive_intvl;
219extern int sysctl_tcp_syn_retries;
220extern int sysctl_tcp_synack_retries;
221extern int sysctl_tcp_retries1;
222extern int sysctl_tcp_retries2;
223extern int sysctl_tcp_orphan_retries;
224extern int sysctl_tcp_syncookies;
225extern int sysctl_tcp_retrans_collapse;
226extern int sysctl_tcp_stdurg;
227extern int sysctl_tcp_rfc1337;
228extern int sysctl_tcp_abort_on_overflow;
229extern int sysctl_tcp_max_orphans;
1da177e4
LT		 230extern int sysctl_tcp_fack;
231extern int sysctl_tcp_reordering;
232extern int sysctl_tcp_ecn;
233extern int sysctl_tcp_dsack;
1da177e4
LT		 234extern int sysctl_tcp_wmem[3];
235extern int sysctl_tcp_rmem[3];
236extern int sysctl_tcp_app_win;
237extern int sysctl_tcp_adv_win_scale;
238extern int sysctl_tcp_tw_reuse;
239extern int sysctl_tcp_frto;
3cfe3baa 240extern int sysctl_tcp_frto_response;
1da177e4 241extern int sysctl_tcp_low_latency;
95937825 242extern int sysctl_tcp_dma_copybreak;
1da177e4 243extern int sysctl_tcp_nometrics_save;
1da177e4
LT		 244extern int sysctl_tcp_moderate_rcvbuf;
245extern int sysctl_tcp_tso_win_divisor;
9772efb9 246extern int sysctl_tcp_abc;
5d424d5a
JH		 247extern int sysctl_tcp_mtu_probing;
248extern int sysctl_tcp_base_mss;
15d99e02 249extern int sysctl_tcp_workaround_signed_windows;
35089bb2 250extern int sysctl_tcp_slow_start_after_idle;
886236c1 251extern int sysctl_tcp_max_ssthresh;
519855c5 252extern int sysctl_tcp_cookie_size;
36e31b0a 253extern int sysctl_tcp_thin_linear_timeouts;
7e380175 254extern int sysctl_tcp_thin_dupack;
1da177e4 255
8d987e5c 256extern atomic_long_t tcp_memory_allocated;
1748376b 257extern struct percpu_counter tcp_sockets_allocated;
1da177e4
LT		 258extern int tcp_memory_pressure;
259
1da177e4
LT		 260/*
261 * The next routines deal with comparing 32 bit unsigned ints
262 * and worry about wraparound (automatic with unsigned arithmetic).
263 */
264
265static inline int before(__u32 seq1, __u32 seq2)
266{
0d630cc0 267 return (__s32)(seq1-seq2) < 0;
1da177e4 268}
9a036b9c 269#define after(seq2, seq1) before(seq1, seq2)
1da177e4
LT		 270
271/* is s2<=s1<=s3 ? */
272static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
273{
274 return seq3 - seq2 >= seq1 - seq2;
275}
276
efcdbf24
AS		 277static inline bool tcp_out_of_memory(struct sock *sk)
278{
279 if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
280 sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
281 return true;
282 return false;
283}
284
ad1af0fe 285static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
e4fd5da3 286{
ad1af0fe
DM		 287 struct percpu_counter *ocp = sk->sk_prot->orphan_count;
288 int orphans = percpu_counter_read_positive(ocp);
289
290 if (orphans << shift > sysctl_tcp_max_orphans) {
291 orphans = percpu_counter_sum_positive(ocp);
292 if (orphans << shift > sysctl_tcp_max_orphans)
293 return true;
294 }
ad1af0fe 295 return false;
e4fd5da3 296}
1da177e4 297
efcdbf24
AS		 298extern bool tcp_check_oom(struct sock *sk, int shift);
299
a0f82f64
FW		 300/* syncookies: remember time of last synqueue overflow */
301static inline void tcp_synq_overflow(struct sock *sk)
302{
303 tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies;
304}
305
306/* syncookies: no recent synqueue overflow on this listening socket? */
307static inline int tcp_synq_no_recent_overflow(const struct sock *sk)
308{
309 unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
9ad7c049 310 return time_after(jiffies, last_overflow + TCP_TIMEOUT_FALLBACK);
a0f82f64
FW		 311}
312
1da177e4
LT		 313extern struct proto tcp_prot;
314
57ef42d5
PE		 315#define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field)
316#define TCP_INC_STATS_BH(net, field) SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field)
317#define TCP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->mib.tcp_statistics, field)
318#define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val)
aa2ea058 319#define TCP_ADD_STATS(net, field, val) SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val)
1da177e4 320
4acb4190
GC		 321extern void tcp_init_mem(struct net *net);
322
53d3176b
CG		 323extern void tcp_v4_err(struct sk_buff *skb, u32);
324
325extern void tcp_shutdown (struct sock *sk, int how);
326
327extern int tcp_v4_rcv(struct sk_buff *skb);
328
3f419d2d 329extern struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it);
ccb7c410 330extern void *tcp_v4_tw_get_peer(struct sock *sk);
53d3176b 331extern int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
7ba42910
CG		 332extern int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
333 size_t size);
334extern int tcp_sendpage(struct sock *sk, struct page *page, int offset,
335 size_t size, int flags);
53d3176b
CG		 336extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
337extern int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
cf533ea5 338 const struct tcphdr *th, unsigned int len);
53d3176b 339extern int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
cf533ea5 340 const struct tcphdr *th, unsigned int len);
53d3176b
CG		 341extern void tcp_rcv_space_adjust(struct sock *sk);
342extern void tcp_cleanup_rbuf(struct sock *sk, int copied);
343extern int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp);
344extern void tcp_twsk_destructor(struct sock *sk);
345extern ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos,
346 struct pipe_inode_info *pipe, size_t len,
347 unsigned int flags);
9c55e01c 348
463c84b9
ACM		 349static inline void tcp_dec_quickack_mode(struct sock *sk,
350 const unsigned int pkts)
1da177e4 351{
463c84b9 352 struct inet_connection_sock *icsk = inet_csk(sk);
fc6415bc 353
463c84b9
ACM		 354 if (icsk->icsk_ack.quick) {
355 if (pkts >= icsk->icsk_ack.quick) {
356 icsk->icsk_ack.quick = 0;
fc6415bc 357 /* Leaving quickack mode we deflate ATO. */
463c84b9 358 icsk->icsk_ack.ato = TCP_ATO_MIN;
fc6415bc 359 } else
463c84b9 360 icsk->icsk_ack.quick -= pkts;
1da177e4
LT		 361 }
362}
363
bdf1ee5d
IJ		 364#define TCP_ECN_OK 1
365#define TCP_ECN_QUEUE_CWR 2
366#define TCP_ECN_DEMAND_CWR 4
7a269ffa 367#define TCP_ECN_SEEN 8
bdf1ee5d
IJ		 368
369static __inline__ void
370TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th)
371{
372 if (sysctl_tcp_ecn && th->ece && th->cwr)
373 inet_rsk(req)->ecn_ok = 1;
374}
375
fd2c3ef7 376enum tcp_tw_status {
1da177e4
LT		 377 TCP_TW_SUCCESS = 0,
378 TCP_TW_RST = 1,
379 TCP_TW_ACK = 2,
380 TCP_TW_SYN = 3
381};
382
383
53d3176b
CG		 384extern enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw,
385 struct sk_buff *skb,
386 const struct tcphdr *th);
387extern struct sock * tcp_check_req(struct sock *sk,struct sk_buff *skb,
388 struct request_sock *req,
389 struct request_sock **prev);
390extern int tcp_child_process(struct sock *parent, struct sock *child,
391 struct sk_buff *skb);
392extern int tcp_use_frto(struct sock *sk);
393extern void tcp_enter_frto(struct sock *sk);
394extern void tcp_enter_loss(struct sock *sk, int how);
395extern void tcp_clear_retrans(struct tcp_sock *tp);
396extern void tcp_update_metrics(struct sock *sk);
397extern void tcp_close(struct sock *sk, long timeout);
398extern unsigned int tcp_poll(struct file * file, struct socket *sock,
399 struct poll_table_struct *wait);
400extern int tcp_getsockopt(struct sock *sk, int level, int optname,
401 char __user *optval, int __user *optlen);
402extern int tcp_setsockopt(struct sock *sk, int level, int optname,
403 char __user *optval, unsigned int optlen);
404extern int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
405 char __user *optval, int __user *optlen);
406extern int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
407 char __user *optval, unsigned int optlen);
408extern void tcp_set_keepalive(struct sock *sk, int val);
409extern void tcp_syn_ack_timeout(struct sock *sk, struct request_sock *req);
410extern int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
411 size_t len, int nonblock, int flags, int *addr_len);
cf533ea5
ED		 412extern void tcp_parse_options(const struct sk_buff *skb,
413 struct tcp_options_received *opt_rx, const u8 **hvpp,
53d3176b 414 int estab);
cf533ea5 415extern const u8 *tcp_parse_md5sig_option(const struct tcphdr *th);
7d5d5525 416
1da177e4
LT		 417/*
418 * TCP v4 functions exported for the inet6 API
419 */
420
53d3176b
CG		 421extern void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb);
422extern int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb);
423extern struct sock * tcp_create_openreq_child(struct sock *sk,
424 struct request_sock *req,
1da177e4 425 struct sk_buff *skb);
53d3176b
CG		 426extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
427 struct request_sock *req,
428 struct dst_entry *dst);
429extern int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);
430extern int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr,
431 int addr_len);
432extern int tcp_connect(struct sock *sk);
433extern struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
434 struct request_sock *req,
435 struct request_values *rvp);
436extern int tcp_disconnect(struct sock *sk, int flags);
1da177e4 437
1da177e4 438
1da177e4 439/* From syncookies.c */
2051f11f 440extern __u32 syncookie_secret[2][16-4+SHA_DIGEST_WORDS];
1da177e4
LT		 441extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
442 struct ip_options *opt);
e05c82d3 443#ifdef CONFIG_SYN_COOKIES
1da177e4
LT		 444extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb,
445 __u16 *mss);
e05c82d3
ED		 446#else
447static inline __u32 cookie_v4_init_sequence(struct sock *sk,
448 struct sk_buff *skb,
449 __u16 *mss)
450{
451 return 0;
452}
453#endif
1da177e4 454
4dfc2817 455extern __u32 cookie_init_timestamp(struct request_sock *req);
172d69e6 456extern bool cookie_check_timestamp(struct tcp_options_received *opt, bool *);
4dfc2817 457
c6aefafb
GG		 458/* From net/ipv6/syncookies.c */
459extern struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb);
e05c82d3 460#ifdef CONFIG_SYN_COOKIES
cf533ea5 461extern __u32 cookie_v6_init_sequence(struct sock *sk, const struct sk_buff *skb,
c6aefafb 462 __u16 *mss);
e05c82d3
ED		 463#else
464static inline __u32 cookie_v6_init_sequence(struct sock *sk,
465 struct sk_buff *skb,
466 __u16 *mss)
467{
468 return 0;
469}
470#endif
1da177e4
LT		 471/* tcp_output.c */
472
9e412ba7
IJ		 473extern void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
474 int nonagle);
475extern int tcp_may_send_now(struct sock *sk);
1da177e4 476extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
f1ecd5d9 477extern void tcp_retransmit_timer(struct sock *sk);
1da177e4
LT		 478extern void tcp_xmit_retransmit_queue(struct sock *);
479extern void tcp_simple_retransmit(struct sock *);
480extern int tcp_trim_head(struct sock *, struct sk_buff *, u32);
6475be16 481extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int);
1da177e4
LT		 482
483extern void tcp_send_probe0(struct sock *);
484extern void tcp_send_partial(struct sock *);
53d3176b 485extern int tcp_write_wakeup(struct sock *);
1da177e4 486extern void tcp_send_fin(struct sock *sk);
dd0fc66f 487extern void tcp_send_active_reset(struct sock *sk, gfp_t priority);
53d3176b 488extern int tcp_send_synack(struct sock *);
946cedcc
ED		 489extern int tcp_syn_flood_action(struct sock *sk,
490 const struct sk_buff *skb,
491 const char *proto);
c1b4a7e6 492extern void tcp_push_one(struct sock *, unsigned int mss_now);
1da177e4
LT		 493extern void tcp_send_ack(struct sock *sk);
494extern void tcp_send_delayed_ack(struct sock *sk);
495
a762a980
DM		 496/* tcp_input.c */
497extern void tcp_cwnd_application_limited(struct sock *sk);
498
1da177e4
LT		 499/* tcp_timer.c */
500extern void tcp_init_xmit_timers(struct sock *);
463c84b9
ACM		 501static inline void tcp_clear_xmit_timers(struct sock *sk)
502{
503 inet_csk_clear_xmit_timers(sk);
504}
1da177e4 505
1da177e4 506extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
0c54b85f
IJ		 507extern unsigned int tcp_current_mss(struct sock *sk);
508
509/* Bound MSS / TSO packet size with the half of the window */
510static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)
511{
01f83d69
AK		 512 int cutoff;
513
514 /* When peer uses tiny windows, there is no use in packetizing
515 * to sub-MSS pieces for the sake of SWS or making sure there
516 * are enough packets in the pipe for fast recovery.
517 *
518 * On the other hand, for extremely large MSS devices, handling
519 * smaller than MSS windows in this way does make sense.
520 */
521 if (tp->max_window >= 512)
522 cutoff = (tp->max_window >> 1);
523 else
524 cutoff = tp->max_window;
525
526 if (cutoff && pktsize > cutoff)
527 return max_t(int, cutoff, 68U - tp->tcp_header_len);
0c54b85f
IJ		 528 else
529 return pktsize;
530}
1da177e4 531
17b085ea 532/* tcp.c */
cf533ea5 533extern void tcp_get_info(const struct sock *, struct tcp_info *);
1da177e4
LT		 534
535/* Read 'sendfile()'-style from a TCP socket */
536typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
537 unsigned int, size_t);
538extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
539 sk_read_actor_t recv_actor);
540
40efc6fa 541extern void tcp_initialize_rcv_mss(struct sock *sk);
1da177e4 542
cf533ea5
ED		 543extern int tcp_mtu_to_mss(const struct sock *sk, int pmtu);
544extern int tcp_mss_to_mtu(const struct sock *sk, int mss);
5d424d5a 545extern void tcp_mtup_init(struct sock *sk);
9ad7c049 546extern void tcp_valid_rtt_meas(struct sock *sk, u32 seq_rtt);
5d424d5a 547
f1ecd5d9
DL		 548static inline void tcp_bound_rto(const struct sock *sk)
549{
550 if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
551 inet_csk(sk)->icsk_rto = TCP_RTO_MAX;
552}
553
554static inline u32 __tcp_set_rto(const struct tcp_sock *tp)
555{
556 return (tp->srtt >> 3) + tp->rttvar;
557}
558
40efc6fa 559static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
1da177e4
LT		 560{
561 tp->pred_flags = htonl((tp->tcp_header_len << 26) |
562 ntohl(TCP_FLAG_ACK) |
563 snd_wnd);
564}
565
40efc6fa 566static inline void tcp_fast_path_on(struct tcp_sock *tp)
1da177e4
LT		 567{
568 __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
569}
570
9e412ba7 571static inline void tcp_fast_path_check(struct sock *sk)
1da177e4 572{
9e412ba7
IJ		 573 struct tcp_sock *tp = tcp_sk(sk);
574
b03efcfb 575 if (skb_queue_empty(&tp->out_of_order_queue) &&
1da177e4
LT		 576 tp->rcv_wnd &&
577 atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
578 !tp->urg_data)
579 tcp_fast_path_on(tp);
580}
581
0c266898
SS		 582/* Compute the actual rto_min value */
583static inline u32 tcp_rto_min(struct sock *sk)
584{
cf533ea5 585 const struct dst_entry *dst = __sk_dst_get(sk);
0c266898
SS		 586 u32 rto_min = TCP_RTO_MIN;
587
588 if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
589 rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);
590 return rto_min;
591}
592
1da177e4
LT		 593/* Compute the actual receive window we are currently advertising.
594 * Rcv_nxt can be after the window if our peer push more data
595 * than the offered window.
596 */
40efc6fa 597static inline u32 tcp_receive_window(const struct tcp_sock *tp)
1da177e4
LT		 598{
599 s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
600
601 if (win < 0)
602 win = 0;
603 return (u32) win;
604}
605
606/* Choose a new window, without checks for shrinking, and without
607 * scaling applied to the result. The caller does these things
608 * if necessary. This is a "raw" window selection.
609 */
53d3176b 610extern u32 __tcp_select_window(struct sock *sk);
1da177e4
LT		 611
612/* TCP timestamps are only 32-bits, this causes a slight
613 * complication on 64-bit systems since we store a snapshot
31f34269
SH		 614 * of jiffies in the buffer control blocks below. We decided
615 * to use only the low 32-bits of jiffies and hide the ugly
1da177e4
LT		 616 * casts with the following macro.
617 */
618#define tcp_time_stamp ((__u32)(jiffies))
619
a3433f35
CG		 620#define tcp_flag_byte(th) (((u_int8_t *)th)[13])
621
622#define TCPHDR_FIN 0x01
623#define TCPHDR_SYN 0x02
624#define TCPHDR_RST 0x04
625#define TCPHDR_PSH 0x08
626#define TCPHDR_ACK 0x10
627#define TCPHDR_URG 0x20
628#define TCPHDR_ECE 0x40
629#define TCPHDR_CWR 0x80
630
caa20d9a 631/* This is what the send packet queuing engine uses to pass
f86586fa
ED		 632 * TCP per-packet control information to the transmission code.
633 * We also store the host-order sequence numbers in here too.
634 * This is 44 bytes if IPV6 is enabled.
635 * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately.
1da177e4
LT		 636 */
637struct tcp_skb_cb {
638 union {
639 struct inet_skb_parm h4;
dfd56b8b 640#if IS_ENABLED(CONFIG_IPV6)
1da177e4
LT		 641 struct inet6_skb_parm h6;
642#endif
643 } header; /* For incoming frames */
644 __u32 seq; /* Starting sequence number */
645 __u32 end_seq; /* SEQ + FIN + SYN + datalen */
646 __u32 when; /* used to compute rtt's */
4de075e0 647 __u8 tcp_flags; /* TCP header flags. (tcp[13]) */
1da177e4
LT		 648 __u8 sacked; /* State flags for SACK/FACK. */
649#define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */
650#define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */
651#define TCPCB_LOST 0x04 /* SKB is lost */
652#define TCPCB_TAGBITS 0x07 /* All tag bits */
b82d1bb4
ED		 653 __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */
654 /* 1 byte hole */
1da177e4
LT		 655#define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */
656#define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
657
1da177e4
LT		 658 __u32 ack_seq; /* Sequence number ACK'd */
659};
660
661#define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0]))
662
1da177e4
LT		 663/* Due to TSO, an SKB can be composed of multiple actual
664 * packets. To keep these tracked properly, we use this.
665 */
666static inline int tcp_skb_pcount(const struct sk_buff *skb)
667{
7967168c 668 return skb_shinfo(skb)->gso_segs;
1da177e4
LT		 669}
670
671/* This is valid iff tcp_skb_pcount() > 1. */
672static inline int tcp_skb_mss(const struct sk_buff *skb)
673{
7967168c 674 return skb_shinfo(skb)->gso_size;
1da177e4
LT		 675}
676
317a76f9
SH		 677/* Events passed to congestion control interface */
678enum tcp_ca_event {
679 CA_EVENT_TX_START, /* first transmit when no packets in flight */
680 CA_EVENT_CWND_RESTART, /* congestion window restart */
681 CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */
682 CA_EVENT_FRTO, /* fast recovery timeout */
683 CA_EVENT_LOSS, /* loss timeout */
684 CA_EVENT_FAST_ACK, /* in sequence ack */
685 CA_EVENT_SLOW_ACK, /* other ack */
686};
687
688/*
689 * Interface for adding new TCP congestion control handlers
690 */
691#define TCP_CA_NAME_MAX 16
3ff825b2
SH		 692#define TCP_CA_MAX 128
693#define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX)
694
164891aa
SH		 695#define TCP_CONG_NON_RESTRICTED 0x1
696#define TCP_CONG_RTT_STAMP 0x2
697
317a76f9
SH		 698struct tcp_congestion_ops {
699 struct list_head list;
164891aa 700 unsigned long flags;
317a76f9
SH		 701
702 /* initialize private data (optional) */
6687e988 703 void (*init)(struct sock *sk);
317a76f9 704 /* cleanup private data (optional) */
6687e988 705 void (*release)(struct sock *sk);
317a76f9
SH		 706
707 /* return slow start threshold (required) */
6687e988 708 u32 (*ssthresh)(struct sock *sk);
317a76f9 709 /* lower bound for congestion window (optional) */
72dc5b92 710 u32 (*min_cwnd)(const struct sock *sk);
317a76f9 711 /* do new cwnd calculation (required) */
c3a05c60 712 void (*cong_avoid)(struct sock *sk, u32 ack, u32 in_flight);
317a76f9 713 /* call before changing ca_state (optional) */
6687e988 714 void (*set_state)(struct sock *sk, u8 new_state);
317a76f9 715 /* call when cwnd event occurs (optional) */
6687e988 716 void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);
317a76f9 717 /* new value of cwnd after loss (optional) */
6687e988 718 u32 (*undo_cwnd)(struct sock *sk);
317a76f9 719 /* hook for packet ack accounting (optional) */
30cfd0ba 720 void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us);
73c1f4a0 721 /* get info for inet_diag (optional) */
6687e988 722 void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);
317a76f9
SH		 723
724 char name[TCP_CA_NAME_MAX];
725 struct module *owner;
726};
727
728extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
729extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
730
6687e988
ACM		 731extern void tcp_init_congestion_control(struct sock *sk);
732extern void tcp_cleanup_congestion_control(struct sock *sk);
317a76f9
SH		 733extern int tcp_set_default_congestion_control(const char *name);
734extern void tcp_get_default_congestion_control(char *name);
3ff825b2 735extern void tcp_get_available_congestion_control(char *buf, size_t len);
ce7bc3bf
SH		 736extern void tcp_get_allowed_congestion_control(char *buf, size_t len);
737extern int tcp_set_allowed_congestion_control(char *allowed);
6687e988 738extern int tcp_set_congestion_control(struct sock *sk, const char *name);
40efc6fa 739extern void tcp_slow_start(struct tcp_sock *tp);
758ce5c8 740extern void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w);
317a76f9 741
5f8ef48d 742extern struct tcp_congestion_ops tcp_init_congestion_ops;
6687e988 743extern u32 tcp_reno_ssthresh(struct sock *sk);
c3a05c60 744extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight);
72dc5b92 745extern u32 tcp_reno_min_cwnd(const struct sock *sk);
a8acfbac 746extern struct tcp_congestion_ops tcp_reno;
317a76f9 747
6687e988 748static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)
317a76f9 749{
6687e988
ACM		 750 struct inet_connection_sock *icsk = inet_csk(sk);
751
752 if (icsk->icsk_ca_ops->set_state)
753 icsk->icsk_ca_ops->set_state(sk, ca_state);
754 icsk->icsk_ca_state = ca_state;
317a76f9
SH		 755}
756
6687e988 757static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
317a76f9 758{
6687e988
ACM		 759 const struct inet_connection_sock *icsk = inet_csk(sk);
760
761 if (icsk->icsk_ca_ops->cwnd_event)
762 icsk->icsk_ca_ops->cwnd_event(sk, event);
317a76f9
SH		 763}
764
e60402d0
IJ		 765/* These functions determine how the current flow behaves in respect of SACK
766 * handling. SACK is negotiated with the peer, and therefore it can vary
767 * between different flows.
768 *
769 * tcp_is_sack - SACK enabled
770 * tcp_is_reno - No SACK
771 * tcp_is_fack - FACK enabled, implies SACK enabled
772 */
773static inline int tcp_is_sack(const struct tcp_sock *tp)
774{
775 return tp->rx_opt.sack_ok;
776}
777
778static inline int tcp_is_reno(const struct tcp_sock *tp)
779{
780 return !tcp_is_sack(tp);
781}
782
783static inline int tcp_is_fack(const struct tcp_sock *tp)
784{
ab56222a 785 return tp->rx_opt.sack_ok & TCP_FACK_ENABLED;
e60402d0
IJ		 786}
787
788static inline void tcp_enable_fack(struct tcp_sock *tp)
789{
ab56222a 790 tp->rx_opt.sack_ok |= TCP_FACK_ENABLED;
e60402d0
IJ		 791}
792
83ae4088
IJ		 793static inline unsigned int tcp_left_out(const struct tcp_sock *tp)
794{
795 return tp->sacked_out + tp->lost_out;
796}
797
1da177e4
LT		 798/* This determines how many packets are "in the network" to the best
799 * of our knowledge. In many cases it is conservative, but where
800 * detailed information is available from the receiver (via SACK
801 * blocks etc.) we can make more aggressive calculations.
802 *
803 * Use this for decisions involving congestion control, use just
804 * tp->packets_out to determine if the send queue is empty or not.
805 *
806 * Read this equation as:
807 *
808 * "Packets sent once on transmission queue" MINUS
809 * "Packets left network, but not honestly ACKed yet" PLUS
810 * "Packets fast retransmitted"
811 */
40efc6fa 812static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
1da177e4 813{
83ae4088 814 return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;
1da177e4
LT		 815}
816
0b6a05c1
IJ		 817#define TCP_INFINITE_SSTHRESH 0x7fffffff
818
819static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp)
820{
821 return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH;
822}
823
1da177e4
LT		 824/* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
825 * The exception is rate halving phase, when cwnd is decreasing towards
826 * ssthresh.
827 */
6687e988 828static inline __u32 tcp_current_ssthresh(const struct sock *sk)
1da177e4 829{
6687e988 830 const struct tcp_sock *tp = tcp_sk(sk);
cf533ea5 831
6687e988 832 if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery))
1da177e4
LT		 833 return tp->snd_ssthresh;
834 else
835 return max(tp->snd_ssthresh,
836 ((tp->snd_cwnd >> 1) +
837 (tp->snd_cwnd >> 2)));
838}
839
b9c4595b
IJ		 840/* Use define here intentionally to get WARN_ON location shown at the caller */
841#define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out)
1da177e4 842
3cfe3baa 843extern void tcp_enter_cwr(struct sock *sk, const int set_ssthresh);
cf533ea5 844extern __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst);
1da177e4 845
6b5a5c0d
NC		 846/* The maximum number of MSS of available cwnd for which TSO defers
847 * sending if not using sysctl_tcp_tso_win_divisor.
848 */
849static inline __u32 tcp_max_tso_deferred_mss(const struct tcp_sock *tp)
850{
851 return 3;
852}
853
1da177e4 854/* Slow start with delack produces 3 packets of burst, so that
dd9e0dda
JH		 855 * it is safe "de facto". This will be the default - same as
856 * the default reordering threshold - but if reordering increases,
857 * we must be able to allow cwnd to burst at least this much in order
858 * to not pull it back when holes are filled.
1da177e4
LT		 859 */
860static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
861{
dd9e0dda 862 return tp->reordering;
1da177e4
LT		 863}
864
90840def
IJ		 865/* Returns end sequence number of the receiver's advertised window */
866static inline u32 tcp_wnd_end(const struct tcp_sock *tp)
867{
868 return tp->snd_una + tp->snd_wnd;
869}
cea14e0e 870extern int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight);
f4805ede 871
c1bd24b7 872static inline void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss,
40efc6fa 873 const struct sk_buff *skb)
1da177e4
LT		 874{
875 if (skb->len < mss)
876 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
877}
878
9e412ba7 879static inline void tcp_check_probe_timer(struct sock *sk)
1da177e4 880{
cf533ea5 881 const struct tcp_sock *tp = tcp_sk(sk);
463c84b9 882 const struct inet_connection_sock *icsk = inet_csk(sk);
9e412ba7 883
463c84b9 884 if (!tp->packets_out && !icsk->icsk_pending)
3f421baa
ACM		 885 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
886 icsk->icsk_rto, TCP_RTO_MAX);
1da177e4
LT		 887}
888
ee7537b6 889static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq)
1da177e4
LT		 890{
891 tp->snd_wl1 = seq;
892}
893
ee7537b6 894static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq)
1da177e4
LT		 895{
896 tp->snd_wl1 = seq;
897}
898
1da177e4
LT		 899/*
900 * Calculate(/check) TCP checksum
901 */
ba7808ea
FD		 902static inline __sum16 tcp_v4_check(int len, __be32 saddr,
903 __be32 daddr, __wsum base)
1da177e4
LT		 904{
905 return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
906}
907
b51655b9 908static inline __sum16 __tcp_checksum_complete(struct sk_buff *skb)
1da177e4 909{
fb286bb2 910 return __skb_checksum_complete(skb);
1da177e4
LT		 911}
912
40efc6fa 913static inline int tcp_checksum_complete(struct sk_buff *skb)
1da177e4 914{
60476372 915 return !skb_csum_unnecessary(skb) &&
1da177e4
LT		 916 __tcp_checksum_complete(skb);
917}
918
919/* Prequeue for VJ style copy to user, combined with checksumming. */
920
40efc6fa 921static inline void tcp_prequeue_init(struct tcp_sock *tp)
1da177e4
LT		 922{
923 tp->ucopy.task = NULL;
924 tp->ucopy.len = 0;
925 tp->ucopy.memory = 0;
926 skb_queue_head_init(&tp->ucopy.prequeue);
97fc2f08
CL		 927#ifdef CONFIG_NET_DMA
928 tp->ucopy.dma_chan = NULL;
929 tp->ucopy.wakeup = 0;
930 tp->ucopy.pinned_list = NULL;
931 tp->ucopy.dma_cookie = 0;
932#endif
1da177e4
LT		 933}
934
935/* Packet is added to VJ-style prequeue for processing in process
936 * context, if a reader task is waiting. Apparently, this exciting
937 * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
938 * failed somewhere. Latency? Burstiness? Well, at least now we will
939 * see, why it failed. 8)8) --ANK
940 *
941 * NOTE: is this not too big to inline?
942 */
40efc6fa 943static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
1da177e4
LT		 944{
945 struct tcp_sock *tp = tcp_sk(sk);
946
f5f8d86b
ED		 947 if (sysctl_tcp_low_latency || !tp->ucopy.task)
948 return 0;
949
950 __skb_queue_tail(&tp->ucopy.prequeue, skb);
951 tp->ucopy.memory += skb->truesize;
952 if (tp->ucopy.memory > sk->sk_rcvbuf) {
953 struct sk_buff *skb1;
954
955 BUG_ON(sock_owned_by_user(sk));
956
957 while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
958 sk_backlog_rcv(sk, skb1);
959 NET_INC_STATS_BH(sock_net(sk),
960 LINUX_MIB_TCPPREQUEUEDROPPED);
1da177e4 961 }
f5f8d86b
ED		 962
963 tp->ucopy.memory = 0;
964 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
aa395145 965 wake_up_interruptible_sync_poll(sk_sleep(sk),
7aedec2a 966 POLLIN | POLLRDNORM | POLLRDBAND);
f5f8d86b
ED		 967 if (!inet_csk_ack_scheduled(sk))
968 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
22f6dacd 969 (3 * tcp_rto_min(sk)) / 4,
f5f8d86b 970 TCP_RTO_MAX);
1da177e4 971 }
f5f8d86b 972 return 1;
1da177e4
LT		 973}
974
975
976#undef STATE_TRACE
977
978#ifdef STATE_TRACE
979static const char *statename[]={
980 "Unused","Established","Syn Sent","Syn Recv",
981 "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
982 "Close Wait","Last ACK","Listen","Closing"
983};
984#endif
490d5046 985extern void tcp_set_state(struct sock *sk, int state);
1da177e4 986
4ac02bab 987extern void tcp_done(struct sock *sk);
1da177e4 988
40efc6fa 989static inline void tcp_sack_reset(struct tcp_options_received *rx_opt)
1da177e4
LT		 990{
991 rx_opt->dsack = 0;
1da177e4
LT		 992 rx_opt->num_sacks = 0;
993}
994
1da177e4
LT		 995/* Determine a window scaling and initial window to offer. */
996extern void tcp_select_initial_window(int __space, __u32 mss,
997 __u32 *rcv_wnd, __u32 *window_clamp,
31d12926 998 int wscale_ok, __u8 *rcv_wscale,
999 __u32 init_rcv_wnd);
1da177e4
LT		 1000
1001static inline int tcp_win_from_space(int space)
1002{
1003 return sysctl_tcp_adv_win_scale<=0 ?
1004 (space>>(-sysctl_tcp_adv_win_scale)) :
1005 space - (space>>sysctl_tcp_adv_win_scale);
1006}
1007
1008/* Note: caller must be prepared to deal with negative returns */
1009static inline int tcp_space(const struct sock *sk)
1010{
1011 return tcp_win_from_space(sk->sk_rcvbuf -
1012 atomic_read(&sk->sk_rmem_alloc));
1013}
1014
1015static inline int tcp_full_space(const struct sock *sk)
1016{
1017 return tcp_win_from_space(sk->sk_rcvbuf);
1018}
1019
40efc6fa
SH		 1020static inline void tcp_openreq_init(struct request_sock *req,
1021 struct tcp_options_received *rx_opt,
1022 struct sk_buff *skb)
1da177e4 1023{
2e6599cb
ACM		 1024 struct inet_request_sock *ireq = inet_rsk(req);
1025
1da177e4 1026 req->rcv_wnd = 0; /* So that tcp_send_synack() knows! */
4dfc2817 1027 req->cookie_ts = 0;
2e6599cb 1028 tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
1da177e4
LT		 1029 req->mss = rx_opt->mss_clamp;
1030 req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
2e6599cb
ACM		 1031 ireq->tstamp_ok = rx_opt->tstamp_ok;
1032 ireq->sack_ok = rx_opt->sack_ok;
1033 ireq->snd_wscale = rx_opt->snd_wscale;
1034 ireq->wscale_ok = rx_opt->wscale_ok;
1035 ireq->acked = 0;
1036 ireq->ecn_ok = 0;
aa8223c7 1037 ireq->rmt_port = tcp_hdr(skb)->source;
a3116ac5 1038 ireq->loc_port = tcp_hdr(skb)->dest;
1da177e4
LT		 1039}
1040
5c52ba17 1041extern void tcp_enter_memory_pressure(struct sock *sk);
1da177e4 1042
1da177e4
LT		 1043static inline int keepalive_intvl_when(const struct tcp_sock *tp)
1044{
1045 return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
1046}
1047
1048static inline int keepalive_time_when(const struct tcp_sock *tp)
1049{
1050 return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
1051}
1052
df19a626
ED		 1053static inline int keepalive_probes(const struct tcp_sock *tp)
1054{
1055 return tp->keepalive_probes ? : sysctl_tcp_keepalive_probes;
1056}
1057
6c37e5de
FL		 1058static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp)
1059{
1060 const struct inet_connection_sock *icsk = &tp->inet_conn;
1061
1062 return min_t(u32, tcp_time_stamp - icsk->icsk_ack.lrcvtime,
1063 tcp_time_stamp - tp->rcv_tstamp);
1064}
1065
463c84b9 1066static inline int tcp_fin_time(const struct sock *sk)
1da177e4 1067{
463c84b9
ACM		 1068 int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout;
1069 const int rto = inet_csk(sk)->icsk_rto;
1da177e4 1070
463c84b9
ACM		 1071 if (fin_timeout < (rto << 2) - (rto >> 1))
1072 fin_timeout = (rto << 2) - (rto >> 1);
1da177e4
LT		 1073
1074 return fin_timeout;
1075}
1076
c887e6d2
IJ		 1077static inline int tcp_paws_check(const struct tcp_options_received *rx_opt,
1078 int paws_win)
1da177e4 1079{
c887e6d2
IJ		 1080 if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win)
1081 return 1;
1082 if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS))
1083 return 1;
bc2ce894
ED		 1084 /*
1085 * Some OSes send SYN and SYNACK messages with tsval=0 tsecr=0,
1086 * then following tcp messages have valid values. Ignore 0 value,
1087 * or else 'negative' tsval might forbid us to accept their packets.
1088 */
1089 if (!rx_opt->ts_recent)
1090 return 1;
c887e6d2
IJ		 1091 return 0;
1092}
1093
1094static inline int tcp_paws_reject(const struct tcp_options_received *rx_opt,
1095 int rst)
1096{
1097 if (tcp_paws_check(rx_opt, 0))
1da177e4
LT		 1098 return 0;
1099
1100 /* RST segments are not recommended to carry timestamp,
1101 and, if they do, it is recommended to ignore PAWS because
1102 "their cleanup function should take precedence over timestamps."
1103 Certainly, it is mistake. It is necessary to understand the reasons
1104 of this constraint to relax it: if peer reboots, clock may go
1105 out-of-sync and half-open connections will not be reset.
1106 Actually, the problem would be not existing if all
1107 the implementations followed draft about maintaining clock
1108 via reboots. Linux-2.2 DOES NOT!
1109
1110 However, we can relax time bounds for RST segments to MSL.
1111 */
9d729f72 1112 if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL)
1da177e4
LT		 1113 return 0;
1114 return 1;
1115}
1116
a9c19329 1117static inline void tcp_mib_init(struct net *net)
1da177e4
LT		 1118{
1119 /* See RFC 2012 */
cf1100a7
PE		 1120 TCP_ADD_STATS_USER(net, TCP_MIB_RTOALGORITHM, 1);
1121 TCP_ADD_STATS_USER(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
1122 TCP_ADD_STATS_USER(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
1123 TCP_ADD_STATS_USER(net, TCP_MIB_MAXCONN, -1);
1da177e4
LT		 1124}
1125
5af4ec23 1126/* from STCP */
ef9da47c 1127static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp)
0800f170 1128{
6a438bbe
SH		 1129 tp->lost_skb_hint = NULL;
1130 tp->scoreboard_skb_hint = NULL;
ef9da47c
IJ		 1131}
1132
1133static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp)
1134{
1135 tcp_clear_retrans_hints_partial(tp);
6a438bbe 1136 tp->retransmit_skb_hint = NULL;
b7689205
IJ		 1137}
1138
cfb6eeb4
YH		 1139/* MD5 Signature */
1140struct crypto_hash;
1141
a915da9b
ED		 1142union tcp_md5_addr {
1143 struct in_addr a4;
1144#if IS_ENABLED(CONFIG_IPV6)
1145 struct in6_addr a6;
1146#endif
1147};
1148
cfb6eeb4
YH		 1149/* - key database */
1150struct tcp_md5sig_key {
a915da9b 1151 struct hlist_node node;
cfb6eeb4 1152 u8 keylen;
a915da9b
ED		 1153 u8 family; /* AF_INET or AF_INET6 */
1154 union tcp_md5_addr addr;
1155 u8 key[TCP_MD5SIG_MAXKEYLEN];
1156 struct rcu_head rcu;
cfb6eeb4
YH		 1157};
1158
1159/* - sock block */
1160struct tcp_md5sig_info {
a915da9b 1161 struct hlist_head head;
a8afca03 1162 struct rcu_head rcu;
cfb6eeb4
YH		 1163};
1164
1165/* - pseudo header */
1166struct tcp4_pseudohdr {
1167 __be32 saddr;
1168 __be32 daddr;
1169 __u8 pad;
1170 __u8 protocol;
1171 __be16 len;
1172};
1173
1174struct tcp6_pseudohdr {
1175 struct in6_addr saddr;
1176 struct in6_addr daddr;
1177 __be32 len;
1178 __be32 protocol; /* including padding */
1179};
1180
1181union tcp_md5sum_block {
1182 struct tcp4_pseudohdr ip4;
dfd56b8b 1183#if IS_ENABLED(CONFIG_IPV6)
cfb6eeb4
YH		 1184 struct tcp6_pseudohdr ip6;
1185#endif
1186};
1187
1188/* - pool: digest algorithm, hash description and scratch buffer */
1189struct tcp_md5sig_pool {
1190 struct hash_desc md5_desc;
1191 union tcp_md5sum_block md5_blk;
1192};
1193
cfb6eeb4 1194/* - functions */
53d3176b 1195extern int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
318cf7aa
ED		 1196 const struct sock *sk,
1197 const struct request_sock *req,
1198 const struct sk_buff *skb);
a915da9b
ED		 1199extern int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
1200 int family, const u8 *newkey,
1201 u8 newkeylen, gfp_t gfp);
1202extern int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr,
1203 int family);
1204extern struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
1205 struct sock *addr_sk);
cfb6eeb4 1206
9501f972 1207#ifdef CONFIG_TCP_MD5SIG
a915da9b
ED		 1208extern struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
1209 const union tcp_md5_addr *addr, int family);
1210#define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_key)
9501f972 1211#else
a915da9b
ED		 1212static inline struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
1213 const union tcp_md5_addr *addr,
1214 int family)
1215{
1216 return NULL;
1217}
9501f972
YH		 1218#define tcp_twsk_md5_key(twsk) NULL
1219#endif
1220
765cf997 1221extern struct tcp_md5sig_pool __percpu *tcp_alloc_md5sig_pool(struct sock *);
53d3176b 1222extern void tcp_free_md5sig_pool(void);
cfb6eeb4 1223
35790c04 1224extern struct tcp_md5sig_pool *tcp_get_md5sig_pool(void);
53d3176b 1225extern void tcp_put_md5sig_pool(void);
35790c04 1226
ca35a0ef 1227extern int tcp_md5_hash_header(struct tcp_md5sig_pool *, const struct tcphdr *);
cf533ea5 1228extern int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *,
49a72dfb
AL		 1229 unsigned header_len);
1230extern int tcp_md5_hash_key(struct tcp_md5sig_pool *hp,
cf533ea5 1231 const struct tcp_md5sig_key *key);
cfb6eeb4 1232
fe067e8a
DM		 1233/* write queue abstraction */
1234static inline void tcp_write_queue_purge(struct sock *sk)
1235{
1236 struct sk_buff *skb;
1237
1238 while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL)
3ab224be
HA		 1239 sk_wmem_free_skb(sk, skb);
1240 sk_mem_reclaim(sk);
8818a9d8 1241 tcp_clear_all_retrans_hints(tcp_sk(sk));
fe067e8a
DM		 1242}
1243
cf533ea5 1244static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk)
fe067e8a 1245{
cd07a8ea 1246 return skb_peek(&sk->sk_write_queue);
fe067e8a
DM		 1247}
1248
cf533ea5 1249static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk)
fe067e8a 1250{
cd07a8ea 1251 return skb_peek_tail(&sk->sk_write_queue);
fe067e8a
DM		 1252}
1253
cf533ea5
ED		 1254static inline struct sk_buff *tcp_write_queue_next(const struct sock *sk,
1255 const struct sk_buff *skb)
fe067e8a 1256{
cd07a8ea 1257 return skb_queue_next(&sk->sk_write_queue, skb);
fe067e8a
DM		 1258}
1259
cf533ea5
ED		 1260static inline struct sk_buff *tcp_write_queue_prev(const struct sock *sk,
1261 const struct sk_buff *skb)
832d11c5
IJ		 1262{
1263 return skb_queue_prev(&sk->sk_write_queue, skb);
1264}
1265
fe067e8a 1266#define tcp_for_write_queue(skb, sk) \
cd07a8ea 1267 skb_queue_walk(&(sk)->sk_write_queue, skb)
fe067e8a
DM		 1268
1269#define tcp_for_write_queue_from(skb, sk) \
cd07a8ea 1270 skb_queue_walk_from(&(sk)->sk_write_queue, skb)
fe067e8a 1271
234b6860 1272#define tcp_for_write_queue_from_safe(skb, tmp, sk) \
cd07a8ea 1273 skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp)
234b6860 1274
cf533ea5 1275static inline struct sk_buff *tcp_send_head(const struct sock *sk)
fe067e8a
DM		 1276{
1277 return sk->sk_send_head;
1278}
1279
cd07a8ea
DM		 1280static inline bool tcp_skb_is_last(const struct sock *sk,
1281 const struct sk_buff *skb)
1282{
1283 return skb_queue_is_last(&sk->sk_write_queue, skb);
1284}
1285
cf533ea5 1286static inline void tcp_advance_send_head(struct sock *sk, const struct sk_buff *skb)
fe067e8a 1287{
cd07a8ea 1288 if (tcp_skb_is_last(sk, skb))
fe067e8a 1289 sk->sk_send_head = NULL;
cd07a8ea
DM		 1290 else
1291 sk->sk_send_head = tcp_write_queue_next(sk, skb);
fe067e8a
DM		 1292}
1293
1294static inline void tcp_check_send_head(struct sock *sk, struct sk_buff *skb_unlinked)
1295{
1296 if (sk->sk_send_head == skb_unlinked)
1297 sk->sk_send_head = NULL;
1298}
1299
1300static inline void tcp_init_send_head(struct sock *sk)
1301{
1302 sk->sk_send_head = NULL;
1303}
1304
1305static inline void __tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb)
1306{
1307 __skb_queue_tail(&sk->sk_write_queue, skb);
1308}
1309
1310static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb)
1311{
1312 __tcp_add_write_queue_tail(sk, skb);
1313
1314 /* Queue it, remembering where we must start sending. */
6859d494 1315 if (sk->sk_send_head == NULL) {
fe067e8a 1316 sk->sk_send_head = skb;
6859d494
IJ		 1317
1318 if (tcp_sk(sk)->highest_sack == NULL)
1319 tcp_sk(sk)->highest_sack = skb;
1320 }
fe067e8a
DM		 1321}
1322
1323static inline void __tcp_add_write_queue_head(struct sock *sk, struct sk_buff *skb)
1324{
1325 __skb_queue_head(&sk->sk_write_queue, skb);
1326}
1327
1328/* Insert buff after skb on the write queue of sk. */
1329static inline void tcp_insert_write_queue_after(struct sk_buff *skb,
1330 struct sk_buff *buff,
1331 struct sock *sk)
1332{
7de6c033 1333 __skb_queue_after(&sk->sk_write_queue, skb, buff);
fe067e8a
DM		 1334}
1335
43f59c89 1336/* Insert new before skb on the write queue of sk. */
fe067e8a
DM		 1337static inline void tcp_insert_write_queue_before(struct sk_buff *new,
1338 struct sk_buff *skb,
1339 struct sock *sk)
1340{
43f59c89 1341 __skb_queue_before(&sk->sk_write_queue, skb, new);