projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] PCI: fix for Toshiba ohci1394 quirk
[linux-2.6-block.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/config.h>
25#include <linux/list.h>
26#include <linux/tcp.h>
27#include <linux/slab.h>
28#include <linux/cache.h>
29#include <linux/percpu.h>
fb286bb2 30#include <linux/skbuff.h>
3f421baa
ACM		 31
32#include <net/inet_connection_sock.h>
295ff7ed 33#include <net/inet_timewait_sock.h>
77d8bf9c 34#include <net/inet_hashtables.h>
1da177e4 35#include <net/checksum.h>
2e6599cb 36#include <net/request_sock.h>
1da177e4
LT		 37#include <net/sock.h>
38#include <net/snmp.h>
39#include <net/ip.h>
c752f073
ACM		 40#include <net/tcp_states.h>
41
1da177e4
LT		 42#include <linux/seq_file.h>
43
6e04e021 44extern struct inet_hashinfo tcp_hashinfo;
1da177e4 45
1da177e4 46extern atomic_t tcp_orphan_count;
1da177e4 47extern void tcp_time_wait(struct sock *sk, int state, int timeo);
1da177e4 48
1da177e4
LT		 49#define MAX_TCP_HEADER (128 + MAX_HEADER)
50
51/*
52 * Never offer a window over 32767 without using window scaling. Some
53 * poor stacks do signed 16bit maths!
54 */
55#define MAX_TCP_WINDOW 32767U
56
57/* Minimal accepted MSS. It is (60+60+8) - (20+20). */
58#define TCP_MIN_MSS 88U
59
60/* Minimal RCV_MSS. */
61#define TCP_MIN_RCVMSS 536U
62
63/* After receiving this amount of duplicate ACKs fast retransmit starts. */
64#define TCP_FASTRETRANS_THRESH 3
65
66/* Maximal reordering. */
67#define TCP_MAX_REORDERING 127
68
69/* Maximal number of ACKs sent quickly to accelerate slow-start. */
70#define TCP_MAX_QUICKACKS 16U
71
72/* urg_data states */
73#define TCP_URG_VALID 0x0100
74#define TCP_URG_NOTYET 0x0200
75#define TCP_URG_READ 0x0400
76
77#define TCP_RETR1 3 /*
78 * This is how many retries it does before it
79 * tries to figure out if the gateway is
80 * down. Minimal RFC value is 3; it corresponds
81 * to ~3sec-8min depending on RTO.
82 */
83
84#define TCP_RETR2 15 /*
85 * This should take at least
86 * 90 minutes to time out.
87 * RFC1122 says that the limit is 100 sec.
88 * 15 is ~13-30min depending on RTO.
89 */
90
91#define TCP_SYN_RETRIES 5 /* number of times to retry active opening a
92 * connection: ~180sec is RFC minumum */
93
94#define TCP_SYNACK_RETRIES 5 /* number of times to retry passive opening a
95 * connection: ~180sec is RFC minumum */
96
97
98#define TCP_ORPHAN_RETRIES 7 /* number of times to retry on an orphaned
99 * socket. 7 is ~50sec-16min.
100 */
101
102
103#define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
104 * state, about 60 seconds */
105#define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN
106 /* BSD style FIN_WAIT2 deadlock breaker.
107 * It used to be 3min, new value is 60sec,
108 * to combine FIN-WAIT-2 timeout with
109 * TIME-WAIT timer.
110 */
111
112#define TCP_DELACK_MAX ((unsigned)(HZ/5)) /* maximal time to delay before sending an ACK */
113#if HZ >= 100
114#define TCP_DELACK_MIN ((unsigned)(HZ/25)) /* minimal time to delay before sending an ACK */
115#define TCP_ATO_MIN ((unsigned)(HZ/25))
116#else
117#define TCP_DELACK_MIN 4U
118#define TCP_ATO_MIN 4U
119#endif
120#define TCP_RTO_MAX ((unsigned)(120*HZ))
121#define TCP_RTO_MIN ((unsigned)(HZ/5))
122#define TCP_TIMEOUT_INIT ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value */
123
124#define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
125 * for local resources.
126 */
127
128#define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */
129#define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */
130#define TCP_KEEPALIVE_INTVL (75*HZ)
131
132#define MAX_TCP_KEEPIDLE 32767
133#define MAX_TCP_KEEPINTVL 32767
134#define MAX_TCP_KEEPCNT 127
135#define MAX_TCP_SYNCNT 127
136
137#define TCP_SYNQ_INTERVAL (HZ/5) /* Period of SYNACK timer */
138#define TCP_SYNQ_HSIZE 512 /* Size of SYNACK hash table */
139
140#define TCP_PAWS_24DAYS (60 * 60 * 24 * 24)
141#define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated
142 * after this time. It should be equal
143 * (or greater than) TCP_TIMEWAIT_LEN
144 * to provide reliability equal to one
145 * provided by timewait state.
146 */
147#define TCP_PAWS_WINDOW 1 /* Replay window for per-host
148 * timestamps. It must be less than
149 * minimal timewait lifetime.
150 */
1da177e4
LT		 151/*
152 * TCP option
153 */
154
155#define TCPOPT_NOP 1 /* Padding */
156#define TCPOPT_EOL 0 /* End of options */
157#define TCPOPT_MSS 2 /* Segment size negotiating */
158#define TCPOPT_WINDOW 3 /* Window scaling */
159#define TCPOPT_SACK_PERM 4 /* SACK Permitted */
160#define TCPOPT_SACK 5 /* SACK Block */
161#define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */
162
163/*
164 * TCP option lengths
165 */
166
167#define TCPOLEN_MSS 4
168#define TCPOLEN_WINDOW 3
169#define TCPOLEN_SACK_PERM 2
170#define TCPOLEN_TIMESTAMP 10
171
172/* But this is what stacks really send out. */
173#define TCPOLEN_TSTAMP_ALIGNED 12
174#define TCPOLEN_WSCALE_ALIGNED 4
175#define TCPOLEN_SACKPERM_ALIGNED 4
176#define TCPOLEN_SACK_BASE 2
177#define TCPOLEN_SACK_BASE_ALIGNED 4
178#define TCPOLEN_SACK_PERBLOCK 8
179
1da177e4
LT		 180/* Flags in tp->nonagle */
181#define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */
182#define TCP_NAGLE_CORK 2 /* Socket is corked */
183#define TCP_NAGLE_PUSH 4 /* Cork is overriden for already queued data */
184
295ff7ed
ACM		 185extern struct inet_timewait_death_row tcp_death_row;
186
1da177e4 187/* sysctl variables for tcp */
1da177e4
LT		 188extern int sysctl_tcp_timestamps;
189extern int sysctl_tcp_window_scaling;
190extern int sysctl_tcp_sack;
191extern int sysctl_tcp_fin_timeout;
1da177e4
LT		 192extern int sysctl_tcp_keepalive_time;
193extern int sysctl_tcp_keepalive_probes;
194extern int sysctl_tcp_keepalive_intvl;
195extern int sysctl_tcp_syn_retries;
196extern int sysctl_tcp_synack_retries;
197extern int sysctl_tcp_retries1;
198extern int sysctl_tcp_retries2;
199extern int sysctl_tcp_orphan_retries;
200extern int sysctl_tcp_syncookies;
201extern int sysctl_tcp_retrans_collapse;
202extern int sysctl_tcp_stdurg;
203extern int sysctl_tcp_rfc1337;
204extern int sysctl_tcp_abort_on_overflow;
205extern int sysctl_tcp_max_orphans;
1da177e4
LT		 206extern int sysctl_tcp_fack;
207extern int sysctl_tcp_reordering;
208extern int sysctl_tcp_ecn;
209extern int sysctl_tcp_dsack;
210extern int sysctl_tcp_mem[3];
211extern int sysctl_tcp_wmem[3];
212extern int sysctl_tcp_rmem[3];
213extern int sysctl_tcp_app_win;
214extern int sysctl_tcp_adv_win_scale;
215extern int sysctl_tcp_tw_reuse;
216extern int sysctl_tcp_frto;
217extern int sysctl_tcp_low_latency;
1da177e4 218extern int sysctl_tcp_nometrics_save;
1da177e4
LT		 219extern int sysctl_tcp_moderate_rcvbuf;
220extern int sysctl_tcp_tso_win_divisor;
221
222extern atomic_t tcp_memory_allocated;
223extern atomic_t tcp_sockets_allocated;
224extern int tcp_memory_pressure;
225
1da177e4
LT		 226/*
227 * Pointers to address related TCP functions
228 * (i.e. things that depend on the address family)
229 */
230
231struct tcp_func {
232 int (*queue_xmit) (struct sk_buff *skb,
233 int ipfragok);
234
235 void (*send_check) (struct sock *sk,
236 struct tcphdr *th,
237 int len,
238 struct sk_buff *skb);
239
240 int (*rebuild_header) (struct sock *sk);
241
242 int (*conn_request) (struct sock *sk,
243 struct sk_buff *skb);
244
245 struct sock * (*syn_recv_sock) (struct sock *sk,
246 struct sk_buff *skb,
60236fdd 247 struct request_sock *req,
1da177e4
LT		 248 struct dst_entry *dst);
249
250 int (*remember_stamp) (struct sock *sk);
251
252 __u16 net_header_len;
253
254 int (*setsockopt) (struct sock *sk,
255 int level,
256 int optname,
257 char __user *optval,
258 int optlen);
259
260 int (*getsockopt) (struct sock *sk,
261 int level,
262 int optname,
263 char __user *optval,
264 int __user *optlen);
265
266
267 void (*addr2sockaddr) (struct sock *sk,
268 struct sockaddr *);
269
270 int sockaddr_len;
271};
272
273/*
274 * The next routines deal with comparing 32 bit unsigned ints
275 * and worry about wraparound (automatic with unsigned arithmetic).
276 */
277
278static inline int before(__u32 seq1, __u32 seq2)
279{
280 return (__s32)(seq1-seq2) < 0;
281}
282
283static inline int after(__u32 seq1, __u32 seq2)
284{
285 return (__s32)(seq2-seq1) < 0;
286}
287
288
289/* is s2<=s1<=s3 ? */
290static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
291{
292 return seq3 - seq2 >= seq1 - seq2;
293}
294
295
296extern struct proto tcp_prot;
297
298DECLARE_SNMP_STAT(struct tcp_mib, tcp_statistics);
299#define TCP_INC_STATS(field) SNMP_INC_STATS(tcp_statistics, field)
300#define TCP_INC_STATS_BH(field) SNMP_INC_STATS_BH(tcp_statistics, field)
301#define TCP_INC_STATS_USER(field) SNMP_INC_STATS_USER(tcp_statistics, field)
302#define TCP_DEC_STATS(field) SNMP_DEC_STATS(tcp_statistics, field)
303#define TCP_ADD_STATS_BH(field, val) SNMP_ADD_STATS_BH(tcp_statistics, field, val)
304#define TCP_ADD_STATS_USER(field, val) SNMP_ADD_STATS_USER(tcp_statistics, field, val)
305
1da177e4
LT		 306extern void tcp_v4_err(struct sk_buff *skb, u32);
307
308extern void tcp_shutdown (struct sock *sk, int how);
309
310extern int tcp_v4_rcv(struct sk_buff *skb);
311
312extern int tcp_v4_remember_stamp(struct sock *sk);
313
8feaf0c0 314extern int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
1da177e4
LT		 315
316extern int tcp_sendmsg(struct kiocb *iocb, struct sock *sk,
317 struct msghdr *msg, size_t size);
318extern ssize_t tcp_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags);
319
320extern int tcp_ioctl(struct sock *sk,
321 int cmd,
322 unsigned long arg);
323
324extern int tcp_rcv_state_process(struct sock *sk,
325 struct sk_buff *skb,
326 struct tcphdr *th,
327 unsigned len);
328
329extern int tcp_rcv_established(struct sock *sk,
330 struct sk_buff *skb,
331 struct tcphdr *th,
332 unsigned len);
333
334extern void tcp_rcv_space_adjust(struct sock *sk);
335
463c84b9
ACM		 336static inline void tcp_dec_quickack_mode(struct sock *sk,
337 const unsigned int pkts)
1da177e4 338{
463c84b9 339 struct inet_connection_sock *icsk = inet_csk(sk);
fc6415bc 340
463c84b9
ACM		 341 if (icsk->icsk_ack.quick) {
342 if (pkts >= icsk->icsk_ack.quick) {
343 icsk->icsk_ack.quick = 0;
fc6415bc 344 /* Leaving quickack mode we deflate ATO. */
463c84b9 345 icsk->icsk_ack.ato = TCP_ATO_MIN;
fc6415bc 346 } else
463c84b9 347 icsk->icsk_ack.quick -= pkts;
1da177e4
LT		 348 }
349}
350
463c84b9 351extern void tcp_enter_quickack_mode(struct sock *sk);
1da177e4 352
1da177e4
LT		 353static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
354{
355 rx_opt->tstamp_ok = rx_opt->sack_ok = rx_opt->wscale_ok = rx_opt->snd_wscale = 0;
356}
357
358enum tcp_tw_status
359{
360 TCP_TW_SUCCESS = 0,
361 TCP_TW_RST = 1,
362 TCP_TW_ACK = 2,
363 TCP_TW_SYN = 3
364};
365
366
8feaf0c0 367extern enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw,
1da177e4 368 struct sk_buff *skb,
8feaf0c0 369 const struct tcphdr *th);
1da177e4
LT		 370
371extern struct sock * tcp_check_req(struct sock *sk,struct sk_buff *skb,
60236fdd
ACM		 372 struct request_sock *req,
373 struct request_sock **prev);
1da177e4
LT		 374extern int tcp_child_process(struct sock *parent,
375 struct sock *child,
376 struct sk_buff *skb);
377extern void tcp_enter_frto(struct sock *sk);
378extern void tcp_enter_loss(struct sock *sk, int how);
379extern void tcp_clear_retrans(struct tcp_sock *tp);
380extern void tcp_update_metrics(struct sock *sk);
381
382extern void tcp_close(struct sock *sk,
383 long timeout);
1da177e4
LT		 384extern unsigned int tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait);
385
386extern int tcp_getsockopt(struct sock *sk, int level,
387 int optname,
388 char __user *optval,
389 int __user *optlen);
390extern int tcp_setsockopt(struct sock *sk, int level,
391 int optname, char __user *optval,
392 int optlen);
393extern void tcp_set_keepalive(struct sock *sk, int val);
394extern int tcp_recvmsg(struct kiocb *iocb, struct sock *sk,
395 struct msghdr *msg,
396 size_t len, int nonblock,
397 int flags, int *addr_len);
398
1da177e4
LT		 399extern void tcp_parse_options(struct sk_buff *skb,
400 struct tcp_options_received *opt_rx,
401 int estab);
402
403/*
404 * TCP v4 functions exported for the inet6 API
405 */
406
1da177e4
LT		 407extern void tcp_v4_send_check(struct sock *sk,
408 struct tcphdr *th, int len,
409 struct sk_buff *skb);
410
411extern int tcp_v4_conn_request(struct sock *sk,
412 struct sk_buff *skb);
413
414extern struct sock * tcp_create_openreq_child(struct sock *sk,
60236fdd 415 struct request_sock *req,
1da177e4
LT		 416 struct sk_buff *skb);
417
418extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk,
419 struct sk_buff *skb,
60236fdd 420 struct request_sock *req,
1da177e4
LT		 421 struct dst_entry *dst);
422
423extern int tcp_v4_do_rcv(struct sock *sk,
424 struct sk_buff *skb);
425
426extern int tcp_v4_connect(struct sock *sk,
427 struct sockaddr *uaddr,
428 int addr_len);
429
430extern int tcp_connect(struct sock *sk);
431
432extern struct sk_buff * tcp_make_synack(struct sock *sk,
433 struct dst_entry *dst,
60236fdd 434 struct request_sock *req);
1da177e4
LT		 435
436extern int tcp_disconnect(struct sock *sk, int flags);
437
438extern void tcp_unhash(struct sock *sk);
439
440extern int tcp_v4_hash_connecting(struct sock *sk);
441
442
443/* From syncookies.c */
444extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
445 struct ip_options *opt);
446extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb,
447 __u16 *mss);
448
449/* tcp_output.c */
450
f6302d1d 451extern void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp,
a2e2a59c 452 unsigned int cur_mss, int nonagle);
f6302d1d 453extern int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp);
1da177e4
LT		 454extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
455extern void tcp_xmit_retransmit_queue(struct sock *);
456extern void tcp_simple_retransmit(struct sock *);
457extern int tcp_trim_head(struct sock *, struct sk_buff *, u32);
6475be16 458extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int);
1da177e4
LT		 459
460extern void tcp_send_probe0(struct sock *);
461extern void tcp_send_partial(struct sock *);
462extern int tcp_write_wakeup(struct sock *);
463extern void tcp_send_fin(struct sock *sk);
dd0fc66f 464extern void tcp_send_active_reset(struct sock *sk, gfp_t priority);
1da177e4 465extern int tcp_send_synack(struct sock *);
c1b4a7e6 466extern void tcp_push_one(struct sock *, unsigned int mss_now);
1da177e4
LT		 467extern void tcp_send_ack(struct sock *sk);
468extern void tcp_send_delayed_ack(struct sock *sk);
469
a762a980
DM		 470/* tcp_input.c */
471extern void tcp_cwnd_application_limited(struct sock *sk);
472
1da177e4
LT		 473/* tcp_timer.c */
474extern void tcp_init_xmit_timers(struct sock *);
463c84b9
ACM		 475static inline void tcp_clear_xmit_timers(struct sock *sk)
476{
477 inet_csk_clear_xmit_timers(sk);
478}
1da177e4 479
1da177e4
LT		 480extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
481extern unsigned int tcp_current_mss(struct sock *sk, int large);
482
17b085ea 483/* tcp.c */
1da177e4
LT		 484extern void tcp_get_info(struct sock *, struct tcp_info *);
485
486/* Read 'sendfile()'-style from a TCP socket */
487typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
488 unsigned int, size_t);
489extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
490 sk_read_actor_t recv_actor);
491
1da177e4
LT		 492/* Initialize RCV_MSS value.
493 * RCV_MSS is an our guess about MSS used by the peer.
494 * We haven't any direct information about the MSS.
495 * It's better to underestimate the RCV_MSS rather than overestimate.
496 * Overestimations make us ACKing less frequently than needed.
497 * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss().
498 */
499
500static inline void tcp_initialize_rcv_mss(struct sock *sk)
501{
502 struct tcp_sock *tp = tcp_sk(sk);
c1b4a7e6 503 unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);
1da177e4
LT		 504
505 hint = min(hint, tp->rcv_wnd/2);
506 hint = min(hint, TCP_MIN_RCVMSS);
507 hint = max(hint, TCP_MIN_MSS);
508
463c84b9 509 inet_csk(sk)->icsk_ack.rcv_mss = hint;
1da177e4
LT		 510}
511
512static __inline__ void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
513{
514 tp->pred_flags = htonl((tp->tcp_header_len << 26) |
515 ntohl(TCP_FLAG_ACK) |
516 snd_wnd);
517}
518
519static __inline__ void tcp_fast_path_on(struct tcp_sock *tp)
520{
521 __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
522}
523
524static inline void tcp_fast_path_check(struct sock *sk, struct tcp_sock *tp)
525{
b03efcfb 526 if (skb_queue_empty(&tp->out_of_order_queue) &&
1da177e4
LT		 527 tp->rcv_wnd &&
528 atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
529 !tp->urg_data)
530 tcp_fast_path_on(tp);
531}
532
533/* Compute the actual receive window we are currently advertising.
534 * Rcv_nxt can be after the window if our peer push more data
535 * than the offered window.
536 */
537static __inline__ u32 tcp_receive_window(const struct tcp_sock *tp)
538{
539 s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
540
541 if (win < 0)
542 win = 0;
543 return (u32) win;
544}
545
546/* Choose a new window, without checks for shrinking, and without
547 * scaling applied to the result. The caller does these things
548 * if necessary. This is a "raw" window selection.
549 */
550extern u32 __tcp_select_window(struct sock *sk);
551
552/* TCP timestamps are only 32-bits, this causes a slight
553 * complication on 64-bit systems since we store a snapshot
554 * of jiffies in the buffer control blocks below. We decidely
555 * only use of the low 32-bits of jiffies and hide the ugly
556 * casts with the following macro.
557 */
558#define tcp_time_stamp ((__u32)(jiffies))
559
560/* This is what the send packet queueing engine uses to pass
561 * TCP per-packet control information to the transmission
562 * code. We also store the host-order sequence numbers in
563 * here too. This is 36 bytes on 32-bit architectures,
564 * 40 bytes on 64-bit machines, if this grows please adjust
565 * skbuff.h:skbuff->cb[xxx] size appropriately.
566 */
567struct tcp_skb_cb {
568 union {
569 struct inet_skb_parm h4;
570#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
571 struct inet6_skb_parm h6;
572#endif
573 } header; /* For incoming frames */
574 __u32 seq; /* Starting sequence number */
575 __u32 end_seq; /* SEQ + FIN + SYN + datalen */
576 __u32 when; /* used to compute rtt's */
577 __u8 flags; /* TCP header flags. */
578
579 /* NOTE: These must match up to the flags byte in a
580 * real TCP header.
581 */
582#define TCPCB_FLAG_FIN 0x01
583#define TCPCB_FLAG_SYN 0x02
584#define TCPCB_FLAG_RST 0x04
585#define TCPCB_FLAG_PSH 0x08
586#define TCPCB_FLAG_ACK 0x10
587#define TCPCB_FLAG_URG 0x20
588#define TCPCB_FLAG_ECE 0x40
589#define TCPCB_FLAG_CWR 0x80
590
591 __u8 sacked; /* State flags for SACK/FACK. */
592#define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */
593#define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */
594#define TCPCB_LOST 0x04 /* SKB is lost */
595#define TCPCB_TAGBITS 0x07 /* All tag bits */
596
597#define TCPCB_EVER_RETRANS 0x80 /* Ever retransmitted frame */
598#define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
599
600#define TCPCB_URG 0x20 /* Urgent pointer advenced here */
601
602#define TCPCB_AT_TAIL (TCPCB_URG)
603
604 __u16 urg_ptr; /* Valid w/URG flags is set. */
605 __u32 ack_seq; /* Sequence number ACK'd */
606};
607
608#define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0]))
609
610#include <net/tcp_ecn.h>
611
612/* Due to TSO, an SKB can be composed of multiple actual
613 * packets. To keep these tracked properly, we use this.
614 */
615static inline int tcp_skb_pcount(const struct sk_buff *skb)
616{
617 return skb_shinfo(skb)->tso_segs;
618}
619
620/* This is valid iff tcp_skb_pcount() > 1. */
621static inline int tcp_skb_mss(const struct sk_buff *skb)
622{
623 return skb_shinfo(skb)->tso_size;
624}
625
626static inline void tcp_dec_pcount_approx(__u32 *count,
627 const struct sk_buff *skb)
628{
629 if (*count) {
630 *count -= tcp_skb_pcount(skb);
631 if ((int)*count < 0)
632 *count = 0;
633 }
634}
635
636static inline void tcp_packets_out_inc(struct sock *sk,
637 struct tcp_sock *tp,
638 const struct sk_buff *skb)
639{
640 int orig = tp->packets_out;
641
642 tp->packets_out += tcp_skb_pcount(skb);
643 if (!orig)
3f421baa
ACM		 644 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
645 inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
1da177e4
LT		 646}
647
648static inline void tcp_packets_out_dec(struct tcp_sock *tp,
649 const struct sk_buff *skb)
650{
651 tp->packets_out -= tcp_skb_pcount(skb);
652}
653
317a76f9
SH		 654/* Events passed to congestion control interface */
655enum tcp_ca_event {
656 CA_EVENT_TX_START, /* first transmit when no packets in flight */
657 CA_EVENT_CWND_RESTART, /* congestion window restart */
658 CA_EVENT_COMPLETE_CWR, /* end of congestion recovery */
659 CA_EVENT_FRTO, /* fast recovery timeout */
660 CA_EVENT_LOSS, /* loss timeout */
661 CA_EVENT_FAST_ACK, /* in sequence ack */
662 CA_EVENT_SLOW_ACK, /* other ack */
663};
664
665/*
666 * Interface for adding new TCP congestion control handlers
667 */
668#define TCP_CA_NAME_MAX 16
669struct tcp_congestion_ops {
670 struct list_head list;
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) */
6687e988 680 u32 (*min_cwnd)(struct sock *sk);
317a76f9 681 /* do new cwnd calculation (required) */
6687e988 682 void (*cong_avoid)(struct sock *sk, u32 ack,
317a76f9
SH		 683 u32 rtt, u32 in_flight, int good_ack);
684 /* round trip time sample per acked packet (optional) */
6687e988 685 void (*rtt_sample)(struct sock *sk, u32 usrtt);
317a76f9 686 /* call before changing ca_state (optional) */
6687e988 687 void (*set_state)(struct sock *sk, u8 new_state);
317a76f9 688 /* call when cwnd event occurs (optional) */
6687e988 689 void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);
317a76f9 690 /* new value of cwnd after loss (optional) */
6687e988 691 u32 (*undo_cwnd)(struct sock *sk);
317a76f9 692 /* hook for packet ack accounting (optional) */
6687e988 693 void (*pkts_acked)(struct sock *sk, u32 num_acked);
73c1f4a0 694 /* get info for inet_diag (optional) */
6687e988 695 void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);
317a76f9
SH		 696
697 char name[TCP_CA_NAME_MAX];
698 struct module *owner;
699};
700
701extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
702extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
703
6687e988
ACM		 704extern void tcp_init_congestion_control(struct sock *sk);
705extern void tcp_cleanup_congestion_control(struct sock *sk);
317a76f9
SH		 706extern int tcp_set_default_congestion_control(const char *name);
707extern void tcp_get_default_congestion_control(char *name);
6687e988 708extern int tcp_set_congestion_control(struct sock *sk, const char *name);
317a76f9 709
5f8ef48d 710extern struct tcp_congestion_ops tcp_init_congestion_ops;
6687e988
ACM		 711extern u32 tcp_reno_ssthresh(struct sock *sk);
712extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack,
317a76f9 713 u32 rtt, u32 in_flight, int flag);
6687e988 714extern u32 tcp_reno_min_cwnd(struct sock *sk);
a8acfbac 715extern struct tcp_congestion_ops tcp_reno;
317a76f9 716
6687e988 717static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)
317a76f9 718{
6687e988
ACM		 719 struct inet_connection_sock *icsk = inet_csk(sk);
720
721 if (icsk->icsk_ca_ops->set_state)
722 icsk->icsk_ca_ops->set_state(sk, ca_state);
723 icsk->icsk_ca_state = ca_state;
317a76f9
SH		 724}
725
6687e988 726static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
317a76f9 727{
6687e988
ACM		 728 const struct inet_connection_sock *icsk = inet_csk(sk);
729
730 if (icsk->icsk_ca_ops->cwnd_event)
731 icsk->icsk_ca_ops->cwnd_event(sk, event);
317a76f9
SH		 732}
733
1da177e4
LT		 734/* This determines how many packets are "in the network" to the best
735 * of our knowledge. In many cases it is conservative, but where
736 * detailed information is available from the receiver (via SACK
737 * blocks etc.) we can make more aggressive calculations.
738 *
739 * Use this for decisions involving congestion control, use just
740 * tp->packets_out to determine if the send queue is empty or not.
741 *
742 * Read this equation as:
743 *
744 * "Packets sent once on transmission queue" MINUS
745 * "Packets left network, but not honestly ACKed yet" PLUS
746 * "Packets fast retransmitted"
747 */
748static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
749{
750 return (tp->packets_out - tp->left_out + tp->retrans_out);
751}
752
1da177e4
LT		 753/* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
754 * The exception is rate halving phase, when cwnd is decreasing towards
755 * ssthresh.
756 */
6687e988 757static inline __u32 tcp_current_ssthresh(const struct sock *sk)
1da177e4 758{
6687e988
ACM		 759 const struct tcp_sock *tp = tcp_sk(sk);
760 if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery))
1da177e4
LT		 761 return tp->snd_ssthresh;
762 else
763 return max(tp->snd_ssthresh,
764 ((tp->snd_cwnd >> 1) +
765 (tp->snd_cwnd >> 2)));
766}
767
768static inline void tcp_sync_left_out(struct tcp_sock *tp)
769{
770 if (tp->rx_opt.sack_ok &&
771 (tp->sacked_out >= tp->packets_out - tp->lost_out))
772 tp->sacked_out = tp->packets_out - tp->lost_out;
773 tp->left_out = tp->sacked_out + tp->lost_out;
774}
775
d1b04c08 776/* Set slow start threshold and cwnd not falling to slow start */
6687e988 777static inline void __tcp_enter_cwr(struct sock *sk)
1da177e4 778{
6687e988
ACM		 779 const struct inet_connection_sock *icsk = inet_csk(sk);
780 struct tcp_sock *tp = tcp_sk(sk);
781
1da177e4 782 tp->undo_marker = 0;
6687e988 783 tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
1da177e4
LT		 784 tp->snd_cwnd = min(tp->snd_cwnd,
785 tcp_packets_in_flight(tp) + 1U);
786 tp->snd_cwnd_cnt = 0;
787 tp->high_seq = tp->snd_nxt;
788 tp->snd_cwnd_stamp = tcp_time_stamp;
789 TCP_ECN_queue_cwr(tp);
790}
791
6687e988 792static inline void tcp_enter_cwr(struct sock *sk)
1da177e4 793{
6687e988
ACM		 794 struct tcp_sock *tp = tcp_sk(sk);
795
1da177e4 796 tp->prior_ssthresh = 0;
6687e988
ACM		 797 if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
798 __tcp_enter_cwr(sk);
799 tcp_set_ca_state(sk, TCP_CA_CWR);
1da177e4
LT		 800 }
801}
802
803extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst);
804
805/* Slow start with delack produces 3 packets of burst, so that
806 * it is safe "de facto".
807 */
808static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
809{
810 return 3;
811}
812
1da177e4
LT		 813static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss,
814 const struct sk_buff *skb)
815{
816 if (skb->len < mss)
817 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
818}
819
1da177e4
LT		 820static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp)
821{
463c84b9
ACM		 822 const struct inet_connection_sock *icsk = inet_csk(sk);
823 if (!tp->packets_out && !icsk->icsk_pending)
3f421baa
ACM		 824 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
825 icsk->icsk_rto, TCP_RTO_MAX);
1da177e4
LT		 826}
827
1da177e4
LT		 828static __inline__ void tcp_push_pending_frames(struct sock *sk,
829 struct tcp_sock *tp)
830{
831 __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle);
832}
833
1da177e4
LT		 834static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq)
835{
836 tp->snd_wl1 = seq;
837}
838
839static __inline__ void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq)
840{
841 tp->snd_wl1 = seq;
842}
843
1da177e4
LT		 844/*
845 * Calculate(/check) TCP checksum
846 */
847static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len,
848 unsigned long saddr, unsigned long daddr,
849 unsigned long base)
850{
851 return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
852}
853
854static __inline__ int __tcp_checksum_complete(struct sk_buff *skb)
855{
fb286bb2 856 return __skb_checksum_complete(skb);
1da177e4
LT		 857}
858
859static __inline__ int tcp_checksum_complete(struct sk_buff *skb)
860{
861 return skb->ip_summed != CHECKSUM_UNNECESSARY &&
862 __tcp_checksum_complete(skb);
863}
864
865/* Prequeue for VJ style copy to user, combined with checksumming. */
866
867static __inline__ void tcp_prequeue_init(struct tcp_sock *tp)
868{
869 tp->ucopy.task = NULL;
870 tp->ucopy.len = 0;
871 tp->ucopy.memory = 0;
872 skb_queue_head_init(&tp->ucopy.prequeue);
873}
874
875/* Packet is added to VJ-style prequeue for processing in process
876 * context, if a reader task is waiting. Apparently, this exciting
877 * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
878 * failed somewhere. Latency? Burstiness? Well, at least now we will
879 * see, why it failed. 8)8) --ANK
880 *
881 * NOTE: is this not too big to inline?
882 */
883static __inline__ int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
884{
885 struct tcp_sock *tp = tcp_sk(sk);
886
887 if (!sysctl_tcp_low_latency && tp->ucopy.task) {
888 __skb_queue_tail(&tp->ucopy.prequeue, skb);
889 tp->ucopy.memory += skb->truesize;
890 if (tp->ucopy.memory > sk->sk_rcvbuf) {
891 struct sk_buff *skb1;
892
893 BUG_ON(sock_owned_by_user(sk));
894
895 while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
896 sk->sk_backlog_rcv(sk, skb1);
897 NET_INC_STATS_BH(LINUX_MIB_TCPPREQUEUEDROPPED);
898 }
899
900 tp->ucopy.memory = 0;
901 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
902 wake_up_interruptible(sk->sk_sleep);
463c84b9
ACM		 903 if (!inet_csk_ack_scheduled(sk))
904 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
3f421baa
ACM		 905 (3 * TCP_RTO_MIN) / 4,
906 TCP_RTO_MAX);
1da177e4
LT		 907 }
908 return 1;
909 }
910 return 0;
911}
912
913
914#undef STATE_TRACE
915
916#ifdef STATE_TRACE
917static const char *statename[]={
918 "Unused","Established","Syn Sent","Syn Recv",
919 "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
920 "Close Wait","Last ACK","Listen","Closing"
921};
922#endif
923
924static __inline__ void tcp_set_state(struct sock *sk, int state)
925{
926 int oldstate = sk->sk_state;
927
928 switch (state) {
929 case TCP_ESTABLISHED:
930 if (oldstate != TCP_ESTABLISHED)
931 TCP_INC_STATS(TCP_MIB_CURRESTAB);
932 break;
933
934 case TCP_CLOSE:
935 if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
936 TCP_INC_STATS(TCP_MIB_ESTABRESETS);
937
938 sk->sk_prot->unhash(sk);
463c84b9 939 if (inet_csk(sk)->icsk_bind_hash &&
1da177e4 940 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
2d8c4ce5 941 inet_put_port(&tcp_hashinfo, sk);
1da177e4
LT		 942 /* fall through */
943 default:
944 if (oldstate==TCP_ESTABLISHED)
945 TCP_DEC_STATS(TCP_MIB_CURRESTAB);
946 }
947
948 /* Change state AFTER socket is unhashed to avoid closed
949 * socket sitting in hash tables.
950 */
951 sk->sk_state = state;
952
953#ifdef STATE_TRACE
954 SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
955#endif
956}
957
958static __inline__ void tcp_done(struct sock *sk)
959{
960 tcp_set_state(sk, TCP_CLOSE);
961 tcp_clear_xmit_timers(sk);
962
963 sk->sk_shutdown = SHUTDOWN_MASK;
964
965 if (!sock_flag(sk, SOCK_DEAD))
966 sk->sk_state_change(sk);
967 else
0a5578cf 968 inet_csk_destroy_sock(sk);
1da177e4
LT		 969}
970
971static __inline__ void tcp_sack_reset(struct tcp_options_received *rx_opt)
972{
973 rx_opt->dsack = 0;
974 rx_opt->eff_sacks = 0;
975 rx_opt->num_sacks = 0;
976}
977
978static __inline__ void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp, __u32 tstamp)
979{
980 if (tp->rx_opt.tstamp_ok) {
981 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
982 (TCPOPT_NOP << 16) |
983 (TCPOPT_TIMESTAMP << 8) |
984 TCPOLEN_TIMESTAMP);
985 *ptr++ = htonl(tstamp);
986 *ptr++ = htonl(tp->rx_opt.ts_recent);
987 }
988 if (tp->rx_opt.eff_sacks) {
989 struct tcp_sack_block *sp = tp->rx_opt.dsack ? tp->duplicate_sack : tp->selective_acks;
990 int this_sack;
991
992 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
993 (TCPOPT_NOP << 16) |
994 (TCPOPT_SACK << 8) |
995 (TCPOLEN_SACK_BASE +
996 (tp->rx_opt.eff_sacks * TCPOLEN_SACK_PERBLOCK)));
997 for(this_sack = 0; this_sack < tp->rx_opt.eff_sacks; this_sack++) {
998 *ptr++ = htonl(sp[this_sack].start_seq);
999 *ptr++ = htonl(sp[this_sack].end_seq);
1000 }
1001 if (tp->rx_opt.dsack) {
1002 tp->rx_opt.dsack = 0;
1003 tp->rx_opt.eff_sacks--;
1004 }
1005 }
1006}
1007
1008/* Construct a tcp options header for a SYN or SYN_ACK packet.
1009 * If this is every changed make sure to change the definition of
1010 * MAX_SYN_SIZE to match the new maximum number of options that you
1011 * can generate.
1012 */
1013static inline void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack,
1014 int offer_wscale, int wscale, __u32 tstamp, __u32 ts_recent)
1015{
1016 /* We always get an MSS option.
1017 * The option bytes which will be seen in normal data
1018 * packets should timestamps be used, must be in the MSS
1019 * advertised. But we subtract them from tp->mss_cache so
1020 * that calculations in tcp_sendmsg are simpler etc.
1021 * So account for this fact here if necessary. If we
1022 * don't do this correctly, as a receiver we won't
1023 * recognize data packets as being full sized when we
1024 * should, and thus we won't abide by the delayed ACK
1025 * rules correctly.
1026 * SACKs don't matter, we never delay an ACK when we
1027 * have any of those going out.
1028 */
1029 *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss);
1030 if (ts) {
1031 if(sack)
1032 *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) |
1033 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1034 else
1035 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1036 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1037 *ptr++ = htonl(tstamp); /* TSVAL */
1038 *ptr++ = htonl(ts_recent); /* TSECR */
1039 } else if(sack)
1040 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1041 (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM);
1042 if (offer_wscale)
1043 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale));
1044}
1045
1046/* Determine a window scaling and initial window to offer. */
1047extern void tcp_select_initial_window(int __space, __u32 mss,
1048 __u32 *rcv_wnd, __u32 *window_clamp,
1049 int wscale_ok, __u8 *rcv_wscale);
1050
1051static inline int tcp_win_from_space(int space)
1052{
1053 return sysctl_tcp_adv_win_scale<=0 ?
1054 (space>>(-sysctl_tcp_adv_win_scale)) :
1055 space - (space>>sysctl_tcp_adv_win_scale);
1056}
1057
1058/* Note: caller must be prepared to deal with negative returns */
1059static inline int tcp_space(const struct sock *sk)
1060{
1061 return tcp_win_from_space(sk->sk_rcvbuf -
1062 atomic_read(&sk->sk_rmem_alloc));
1063}
1064
1065static inline int tcp_full_space(const struct sock *sk)
1066{
1067 return tcp_win_from_space(sk->sk_rcvbuf);
1068}
1069
60236fdd 1070static __inline__ void tcp_openreq_init(struct request_sock *req,
1da177e4
LT		 1071 struct tcp_options_received *rx_opt,
1072 struct sk_buff *skb)
1073{
2e6599cb
ACM		 1074 struct inet_request_sock *ireq = inet_rsk(req);
1075
1da177e4 1076 req->rcv_wnd = 0; /* So that tcp_send_synack() knows! */
2e6599cb 1077 tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
1da177e4
LT		 1078 req->mss = rx_opt->mss_clamp;
1079 req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
2e6599cb
ACM		 1080 ireq->tstamp_ok = rx_opt->tstamp_ok;
1081 ireq->sack_ok = rx_opt->sack_ok;
1082 ireq->snd_wscale = rx_opt->snd_wscale;
1083 ireq->wscale_ok = rx_opt->wscale_ok;
1084 ireq->acked = 0;
1085 ireq->ecn_ok = 0;
1086 ireq->rmt_port = skb->h.th->source;
1da177e4
LT		 1087}
1088
1089extern void tcp_enter_memory_pressure(void);
1090
1da177e4
LT		 1091static inline int keepalive_intvl_when(const struct tcp_sock *tp)
1092{
1093 return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
1094}
1095
1096static inline int keepalive_time_when(const struct tcp_sock *tp)
1097{
1098 return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
1099}
1100
463c84b9 1101static inline int tcp_fin_time(const struct sock *sk)
1da177e4 1102{
463c84b9
ACM		 1103 int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout;
1104 const int rto = inet_csk(sk)->icsk_rto;
1da177e4 1105
463c84b9
ACM		 1106 if (fin_timeout < (rto << 2) - (rto >> 1))
1107 fin_timeout = (rto << 2) - (rto >> 1);
1da177e4
LT		 1108
1109 return fin_timeout;
1110}
1111
1112static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, int rst)
1113{
1114 if ((s32)(rx_opt->rcv_tsval - rx_opt->ts_recent) >= 0)
1115 return 0;
1116 if (xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)
1117 return 0;
1118
1119 /* RST segments are not recommended to carry timestamp,
1120 and, if they do, it is recommended to ignore PAWS because
1121 "their cleanup function should take precedence over timestamps."
1122 Certainly, it is mistake. It is necessary to understand the reasons
1123 of this constraint to relax it: if peer reboots, clock may go
1124 out-of-sync and half-open connections will not be reset.
1125 Actually, the problem would be not existing if all
1126 the implementations followed draft about maintaining clock
1127 via reboots. Linux-2.2 DOES NOT!
1128
1129 However, we can relax time bounds for RST segments to MSL.
1130 */
1131 if (rst && xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL)
1132 return 0;
1133 return 1;
1134}
1135
1da177e4
LT		 1136#define TCP_CHECK_TIMER(sk) do { } while (0)
1137
1138static inline int tcp_use_frto(const struct sock *sk)
1139{
1140 const struct tcp_sock *tp = tcp_sk(sk);
1141
1142 /* F-RTO must be activated in sysctl and there must be some
1143 * unsent new data, and the advertised window should allow
1144 * sending it.
1145 */
1146 return (sysctl_tcp_frto && sk->sk_send_head &&
1147 !after(TCP_SKB_CB(sk->sk_send_head)->end_seq,
1148 tp->snd_una + tp->snd_wnd));
1149}
1150
1151static inline void tcp_mib_init(void)
1152{
1153 /* See RFC 2012 */
1154 TCP_ADD_STATS_USER(TCP_MIB_RTOALGORITHM, 1);
1155 TCP_ADD_STATS_USER(TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
1156 TCP_ADD_STATS_USER(TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
1157 TCP_ADD_STATS_USER(TCP_MIB_MAXCONN, -1);
1158}
1159
1160/* /proc */
1161enum tcp_seq_states {
1162 TCP_SEQ_STATE_LISTENING,
1163 TCP_SEQ_STATE_OPENREQ,
1164 TCP_SEQ_STATE_ESTABLISHED,
1165 TCP_SEQ_STATE_TIME_WAIT,
1166};
1167
1168struct tcp_seq_afinfo {
1169 struct module *owner;
1170 char *name;
1171 sa_family_t family;
1172 int (*seq_show) (struct seq_file *m, void *v);
1173 struct file_operations *seq_fops;
1174};
1175
1176struct tcp_iter_state {
1177 sa_family_t family;
1178 enum tcp_seq_states state;
1179 struct sock *syn_wait_sk;
1180 int bucket, sbucket, num, uid;
1181 struct seq_operations seq_ops;
1182};
1183
1184extern int tcp_proc_register(struct tcp_seq_afinfo *afinfo);
1185extern void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo);
1186
20380731
ACM		 1187extern struct request_sock_ops tcp_request_sock_ops;
1188
1189extern int tcp_v4_destroy_sock(struct sock *sk);
1190
1191#ifdef CONFIG_PROC_FS
1192extern int tcp4_proc_init(void);
1193extern void tcp4_proc_exit(void);
1194#endif
1195
1196extern void tcp_v4_init(struct net_proto_family *ops);
1197extern void tcp_init(void);
1198
1da177e4 1199#endif /* _TCP_H */
Linux 6.x block layer and io_uring tree(s)