blob: 415ee47ac1c55f24c7d58a8327b089c6925c34a3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 * Implementation of the Transmission Control Protocol(TCP).
7 *
8 * Version: $Id: tcp_timer.c,v 1.88 2002/02/01 22:01:04 davem Exp $
9 *
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
13 * Corey Minyard <wf-rch!minyard@relay.EU.net>
14 * Florian La Roche, <flla@stud.uni-sb.de>
15 * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
16 * Linus Torvalds, <torvalds@cs.helsinki.fi>
17 * Alan Cox, <gw4pts@gw4pts.ampr.org>
18 * Matthew Dillon, <dillon@apollo.west.oic.com>
19 * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
20 * Jorge Cwik, <jorge@laser.satlink.net>
21 */
22
23#include <linux/module.h>
24#include <net/tcp.h>
25
26int sysctl_tcp_syn_retries = TCP_SYN_RETRIES;
27int sysctl_tcp_synack_retries = TCP_SYNACK_RETRIES;
28int sysctl_tcp_keepalive_time = TCP_KEEPALIVE_TIME;
29int sysctl_tcp_keepalive_probes = TCP_KEEPALIVE_PROBES;
30int sysctl_tcp_keepalive_intvl = TCP_KEEPALIVE_INTVL;
31int sysctl_tcp_retries1 = TCP_RETR1;
32int sysctl_tcp_retries2 = TCP_RETR2;
33int sysctl_tcp_orphan_retries;
34
35static void tcp_write_timer(unsigned long);
36static void tcp_delack_timer(unsigned long);
37static void tcp_keepalive_timer (unsigned long data);
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039void tcp_init_xmit_timers(struct sock *sk)
40{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -070041 inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer,
42 &tcp_keepalive_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043}
44
Arnaldo Carvalho de Melo3f421ba2005-08-09 20:11:08 -070045EXPORT_SYMBOL(tcp_init_xmit_timers);
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static void tcp_write_err(struct sock *sk)
48{
49 sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
50 sk->sk_error_report(sk);
51
52 tcp_done(sk);
53 NET_INC_STATS_BH(LINUX_MIB_TCPABORTONTIMEOUT);
54}
55
56/* Do not allow orphaned sockets to eat all our resources.
57 * This is direct violation of TCP specs, but it is required
58 * to prevent DoS attacks. It is called when a retransmission timeout
59 * or zero probe timeout occurs on orphaned socket.
60 *
61 * Criterium is still not confirmed experimentally and may change.
62 * We kill the socket, if:
63 * 1. If number of orphaned sockets exceeds an administratively configured
64 * limit.
65 * 2. If we have strong memory pressure.
66 */
67static int tcp_out_of_resources(struct sock *sk, int do_reset)
68{
69 struct tcp_sock *tp = tcp_sk(sk);
70 int orphans = atomic_read(&tcp_orphan_count);
71
72 /* If peer does not open window for long time, or did not transmit
73 * anything for long time, penalize it. */
74 if ((s32)(tcp_time_stamp - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset)
75 orphans <<= 1;
76
77 /* If some dubious ICMP arrived, penalize even more. */
78 if (sk->sk_err_soft)
79 orphans <<= 1;
80
81 if (orphans >= sysctl_tcp_max_orphans ||
82 (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
83 atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2])) {
84 if (net_ratelimit())
85 printk(KERN_INFO "Out of socket memory\n");
86
87 /* Catch exceptional cases, when connection requires reset.
88 * 1. Last segment was sent recently. */
89 if ((s32)(tcp_time_stamp - tp->lsndtime) <= TCP_TIMEWAIT_LEN ||
90 /* 2. Window is closed. */
91 (!tp->snd_wnd && !tp->packets_out))
92 do_reset = 1;
93 if (do_reset)
94 tcp_send_active_reset(sk, GFP_ATOMIC);
95 tcp_done(sk);
96 NET_INC_STATS_BH(LINUX_MIB_TCPABORTONMEMORY);
97 return 1;
98 }
99 return 0;
100}
101
102/* Calculate maximal number or retries on an orphaned socket. */
103static int tcp_orphan_retries(struct sock *sk, int alive)
104{
105 int retries = sysctl_tcp_orphan_retries; /* May be zero. */
106
107 /* We know from an ICMP that something is wrong. */
108 if (sk->sk_err_soft && !alive)
109 retries = 0;
110
111 /* However, if socket sent something recently, select some safe
112 * number of retries. 8 corresponds to >100 seconds with minimal
113 * RTO of 200msec. */
114 if (retries == 0 && alive)
115 retries = 8;
116 return retries;
117}
118
119/* A write timeout has occurred. Process the after effects. */
120static int tcp_write_timeout(struct sock *sk)
121{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700122 const struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 int retry_until;
124
125 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700126 if (icsk->icsk_retransmits)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 dst_negative_advice(&sk->sk_dst_cache);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700128 retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 } else {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700130 if (icsk->icsk_retransmits >= sysctl_tcp_retries1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 /* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu black
132 hole detection. :-(
133
134 It is place to make it. It is not made. I do not want
135 to make it. It is disguisting. It does not work in any
136 case. Let me to cite the same draft, which requires for
137 us to implement this:
138
139 "The one security concern raised by this memo is that ICMP black holes
140 are often caused by over-zealous security administrators who block
141 all ICMP messages. It is vitally important that those who design and
142 deploy security systems understand the impact of strict filtering on
143 upper-layer protocols. The safest web site in the world is worthless
144 if most TCP implementations cannot transfer data from it. It would
145 be far nicer to have all of the black holes fixed rather than fixing
146 all of the TCP implementations."
147
148 Golden words :-).
149 */
150
151 dst_negative_advice(&sk->sk_dst_cache);
152 }
153
154 retry_until = sysctl_tcp_retries2;
155 if (sock_flag(sk, SOCK_DEAD)) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700156 const int alive = (icsk->icsk_rto < TCP_RTO_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 retry_until = tcp_orphan_retries(sk, alive);
159
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700160 if (tcp_out_of_resources(sk, alive || icsk->icsk_retransmits < retry_until))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 return 1;
162 }
163 }
164
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700165 if (icsk->icsk_retransmits >= retry_until) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 /* Has it gone just too far? */
167 tcp_write_err(sk);
168 return 1;
169 }
170 return 0;
171}
172
173static void tcp_delack_timer(unsigned long data)
174{
175 struct sock *sk = (struct sock*)data;
176 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700177 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 bh_lock_sock(sk);
180 if (sock_owned_by_user(sk)) {
181 /* Try again later. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700182 icsk->icsk_ack.blocked = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700184 sk_reset_timer(sk, &icsk->icsk_delack_timer, jiffies + TCP_DELACK_MIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 goto out_unlock;
186 }
187
188 sk_stream_mem_reclaim(sk);
189
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700190 if (sk->sk_state == TCP_CLOSE || !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 goto out;
192
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700193 if (time_after(icsk->icsk_ack.timeout, jiffies)) {
194 sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 goto out;
196 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700197 icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
David S. Millerb03efcf2005-07-08 14:57:23 -0700199 if (!skb_queue_empty(&tp->ucopy.prequeue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 struct sk_buff *skb;
201
David S. Millerb03efcf2005-07-08 14:57:23 -0700202 NET_INC_STATS_BH(LINUX_MIB_TCPSCHEDULERFAILED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
204 while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
205 sk->sk_backlog_rcv(sk, skb);
206
207 tp->ucopy.memory = 0;
208 }
209
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700210 if (inet_csk_ack_scheduled(sk)) {
211 if (!icsk->icsk_ack.pingpong) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 /* Delayed ACK missed: inflate ATO. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700213 icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 } else {
215 /* Delayed ACK missed: leave pingpong mode and
216 * deflate ATO.
217 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700218 icsk->icsk_ack.pingpong = 0;
219 icsk->icsk_ack.ato = TCP_ATO_MIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 }
221 tcp_send_ack(sk);
222 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
223 }
224 TCP_CHECK_TIMER(sk);
225
226out:
227 if (tcp_memory_pressure)
228 sk_stream_mem_reclaim(sk);
229out_unlock:
230 bh_unlock_sock(sk);
231 sock_put(sk);
232}
233
234static void tcp_probe_timer(struct sock *sk)
235{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300236 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 struct tcp_sock *tp = tcp_sk(sk);
238 int max_probes;
239
240 if (tp->packets_out || !sk->sk_send_head) {
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300241 icsk->icsk_probes_out = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return;
243 }
244
245 /* *WARNING* RFC 1122 forbids this
246 *
247 * It doesn't AFAIK, because we kill the retransmit timer -AK
248 *
249 * FIXME: We ought not to do it, Solaris 2.5 actually has fixing
250 * this behaviour in Solaris down as a bug fix. [AC]
251 *
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300252 * Let me to explain. icsk_probes_out is zeroed by incoming ACKs
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 * even if they advertise zero window. Hence, connection is killed only
254 * if we received no ACKs for normal connection timeout. It is not killed
255 * only because window stays zero for some time, window may be zero
256 * until armageddon and even later. We are in full accordance
257 * with RFCs, only probe timer combines both retransmission timeout
258 * and probe timeout in one bottle. --ANK
259 */
260 max_probes = sysctl_tcp_retries2;
261
262 if (sock_flag(sk, SOCK_DEAD)) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700263 const int alive = ((icsk->icsk_rto << icsk->icsk_backoff) < TCP_RTO_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 max_probes = tcp_orphan_retries(sk, alive);
266
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300267 if (tcp_out_of_resources(sk, alive || icsk->icsk_probes_out <= max_probes))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return;
269 }
270
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300271 if (icsk->icsk_probes_out > max_probes) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 tcp_write_err(sk);
273 } else {
274 /* Only send another probe if we didn't close things up. */
275 tcp_send_probe0(sk);
276 }
277}
278
279/*
280 * The TCP retransmit timer.
281 */
282
283static void tcp_retransmit_timer(struct sock *sk)
284{
285 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700286 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 if (!tp->packets_out)
289 goto out;
290
291 BUG_TRAP(!skb_queue_empty(&sk->sk_write_queue));
292
293 if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) &&
294 !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) {
295 /* Receiver dastardly shrinks window. Our retransmits
296 * become zero probes, but we should not timeout this
297 * connection. If the socket is an orphan, time it out,
298 * we cannot allow such beasts to hang infinitely.
299 */
300#ifdef TCP_DEBUG
301 if (net_ratelimit()) {
302 struct inet_sock *inet = inet_sk(sk);
303 printk(KERN_DEBUG "TCP: Treason uncloaked! Peer %u.%u.%u.%u:%u/%u shrinks window %u:%u. Repaired.\n",
304 NIPQUAD(inet->daddr), htons(inet->dport),
305 inet->num, tp->snd_una, tp->snd_nxt);
306 }
307#endif
308 if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) {
309 tcp_write_err(sk);
310 goto out;
311 }
312 tcp_enter_loss(sk, 0);
313 tcp_retransmit_skb(sk, skb_peek(&sk->sk_write_queue));
314 __sk_dst_reset(sk);
315 goto out_reset_timer;
316 }
317
318 if (tcp_write_timeout(sk))
319 goto out;
320
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700321 if (icsk->icsk_retransmits == 0) {
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300322 if (icsk->icsk_ca_state == TCP_CA_Disorder ||
323 icsk->icsk_ca_state == TCP_CA_Recovery) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (tp->rx_opt.sack_ok) {
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300325 if (icsk->icsk_ca_state == TCP_CA_Recovery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 NET_INC_STATS_BH(LINUX_MIB_TCPSACKRECOVERYFAIL);
327 else
328 NET_INC_STATS_BH(LINUX_MIB_TCPSACKFAILURES);
329 } else {
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300330 if (icsk->icsk_ca_state == TCP_CA_Recovery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 NET_INC_STATS_BH(LINUX_MIB_TCPRENORECOVERYFAIL);
332 else
333 NET_INC_STATS_BH(LINUX_MIB_TCPRENOFAILURES);
334 }
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300335 } else if (icsk->icsk_ca_state == TCP_CA_Loss) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 NET_INC_STATS_BH(LINUX_MIB_TCPLOSSFAILURES);
337 } else {
338 NET_INC_STATS_BH(LINUX_MIB_TCPTIMEOUTS);
339 }
340 }
341
342 if (tcp_use_frto(sk)) {
343 tcp_enter_frto(sk);
344 } else {
345 tcp_enter_loss(sk, 0);
346 }
347
348 if (tcp_retransmit_skb(sk, skb_peek(&sk->sk_write_queue)) > 0) {
349 /* Retransmission failed because of local congestion,
350 * do not backoff.
351 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700352 if (!icsk->icsk_retransmits)
353 icsk->icsk_retransmits = 1;
354 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
Arnaldo Carvalho de Melo3f421ba2005-08-09 20:11:08 -0700355 min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL),
356 TCP_RTO_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 goto out;
358 }
359
360 /* Increase the timeout each time we retransmit. Note that
361 * we do not increase the rtt estimate. rto is initialized
362 * from rtt, but increases here. Jacobson (SIGCOMM 88) suggests
363 * that doubling rto each time is the least we can get away with.
364 * In KA9Q, Karn uses this for the first few times, and then
365 * goes to quadratic. netBSD doubles, but only goes up to *64,
366 * and clamps at 1 to 64 sec afterwards. Note that 120 sec is
367 * defined in the protocol as the maximum possible RTT. I guess
368 * we'll have to use something other than TCP to talk to the
369 * University of Mars.
370 *
371 * PAWS allows us longer timeouts and large windows, so once
372 * implemented ftp to mars will work nicely. We will have to fix
373 * the 120 second clamps though!
374 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700375 icsk->icsk_backoff++;
376 icsk->icsk_retransmits++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378out_reset_timer:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700379 icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX);
Arnaldo Carvalho de Melo3f421ba2005-08-09 20:11:08 -0700380 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700381 if (icsk->icsk_retransmits > sysctl_tcp_retries1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 __sk_dst_reset(sk);
383
384out:;
385}
386
387static void tcp_write_timer(unsigned long data)
388{
389 struct sock *sk = (struct sock*)data;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700390 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 int event;
392
393 bh_lock_sock(sk);
394 if (sock_owned_by_user(sk)) {
395 /* Try again later */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700396 sk_reset_timer(sk, &icsk->icsk_retransmit_timer, jiffies + (HZ / 20));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 goto out_unlock;
398 }
399
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700400 if (sk->sk_state == TCP_CLOSE || !icsk->icsk_pending)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 goto out;
402
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700403 if (time_after(icsk->icsk_timeout, jiffies)) {
404 sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 goto out;
406 }
407
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700408 event = icsk->icsk_pending;
409 icsk->icsk_pending = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 switch (event) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700412 case ICSK_TIME_RETRANS:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 tcp_retransmit_timer(sk);
414 break;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700415 case ICSK_TIME_PROBE0:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 tcp_probe_timer(sk);
417 break;
418 }
419 TCP_CHECK_TIMER(sk);
420
421out:
422 sk_stream_mem_reclaim(sk);
423out_unlock:
424 bh_unlock_sock(sk);
425 sock_put(sk);
426}
427
Arnaldo Carvalho de Melo295f7322005-08-09 20:11:56 -0700428/*
429 * Timer for listening sockets
430 */
431
432static void tcp_synack_timer(struct sock *sk)
433{
Arnaldo Carvalho de Meloa019d6f2005-08-09 20:15:09 -0700434 inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,
435 TCP_TIMEOUT_INIT, TCP_RTO_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436}
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438void tcp_set_keepalive(struct sock *sk, int val)
439{
440 if ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))
441 return;
442
443 if (val && !sock_flag(sk, SOCK_KEEPOPEN))
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700444 inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 else if (!val)
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700446 inet_csk_delete_keepalive_timer(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447}
448
449
450static void tcp_keepalive_timer (unsigned long data)
451{
452 struct sock *sk = (struct sock *) data;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300453 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 struct tcp_sock *tp = tcp_sk(sk);
455 __u32 elapsed;
456
457 /* Only process if socket is not in use. */
458 bh_lock_sock(sk);
459 if (sock_owned_by_user(sk)) {
460 /* Try again later. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700461 inet_csk_reset_keepalive_timer (sk, HZ/20);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 goto out;
463 }
464
465 if (sk->sk_state == TCP_LISTEN) {
466 tcp_synack_timer(sk);
467 goto out;
468 }
469
470 if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {
471 if (tp->linger2 >= 0) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700472 const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474 if (tmo > 0) {
475 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
476 goto out;
477 }
478 }
479 tcp_send_active_reset(sk, GFP_ATOMIC);
480 goto death;
481 }
482
483 if (!sock_flag(sk, SOCK_KEEPOPEN) || sk->sk_state == TCP_CLOSE)
484 goto out;
485
486 elapsed = keepalive_time_when(tp);
487
488 /* It is alive without keepalive 8) */
489 if (tp->packets_out || sk->sk_send_head)
490 goto resched;
491
492 elapsed = tcp_time_stamp - tp->rcv_tstamp;
493
494 if (elapsed >= keepalive_time_when(tp)) {
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300495 if ((!tp->keepalive_probes && icsk->icsk_probes_out >= sysctl_tcp_keepalive_probes) ||
496 (tp->keepalive_probes && icsk->icsk_probes_out >= tp->keepalive_probes)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 tcp_send_active_reset(sk, GFP_ATOMIC);
498 tcp_write_err(sk);
499 goto out;
500 }
501 if (tcp_write_wakeup(sk) <= 0) {
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300502 icsk->icsk_probes_out++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 elapsed = keepalive_intvl_when(tp);
504 } else {
505 /* If keepalive was lost due to local congestion,
506 * try harder.
507 */
508 elapsed = TCP_RESOURCE_PROBE_INTERVAL;
509 }
510 } else {
511 /* It is tp->rcv_tstamp + keepalive_time_when(tp) */
512 elapsed = keepalive_time_when(tp) - elapsed;
513 }
514
515 TCP_CHECK_TIMER(sk);
516 sk_stream_mem_reclaim(sk);
517
518resched:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700519 inet_csk_reset_keepalive_timer (sk, elapsed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 goto out;
521
522death:
523 tcp_done(sk);
524
525out:
526 bh_unlock_sock(sk);
527 sock_put(sk);
528}