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