Merge branch 'upstream-fixes' into upstream
[linux-2.6] / net / dccp / timer.c
1 /*
2  *  net/dccp/timer.c
3  * 
4  *  An implementation of the DCCP protocol
5  *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License
9  *      as published by the Free Software Foundation; either version
10  *      2 of the License, or (at your option) any later version.
11  */
12
13 #include <linux/dccp.h>
14 #include <linux/skbuff.h>
15
16 #include "dccp.h"
17
18 static void dccp_write_timer(unsigned long data);
19 static void dccp_keepalive_timer(unsigned long data);
20 static void dccp_delack_timer(unsigned long data);
21
22 void dccp_init_xmit_timers(struct sock *sk)
23 {
24         inet_csk_init_xmit_timers(sk, &dccp_write_timer, &dccp_delack_timer,
25                                   &dccp_keepalive_timer);
26 }
27
28 static void dccp_write_err(struct sock *sk)
29 {
30         sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
31         sk->sk_error_report(sk);
32
33         dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
34         dccp_done(sk);
35         DCCP_INC_STATS_BH(DCCP_MIB_ABORTONTIMEOUT);
36 }
37
38 /* A write timeout has occurred. Process the after effects. */
39 static int dccp_write_timeout(struct sock *sk)
40 {
41         const struct inet_connection_sock *icsk = inet_csk(sk);
42         int retry_until;
43
44         if (sk->sk_state == DCCP_REQUESTING || sk->sk_state == DCCP_PARTOPEN) {
45                 if (icsk->icsk_retransmits != 0)
46                         dst_negative_advice(&sk->sk_dst_cache);
47                 retry_until = icsk->icsk_syn_retries ? :
48                             /* FIXME! */ 3 /* FIXME! sysctl_tcp_syn_retries */;
49         } else {
50                 if (icsk->icsk_retransmits >=
51                      /* FIXME! sysctl_tcp_retries1 */ 5 /* FIXME! */) {
52                         /* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu
53                            black hole detection. :-(
54
55                            It is place to make it. It is not made. I do not want
56                            to make it. It is disguisting. It does not work in any
57                            case. Let me to cite the same draft, which requires for
58                            us to implement this:
59
60    "The one security concern raised by this memo is that ICMP black holes
61    are often caused by over-zealous security administrators who block
62    all ICMP messages.  It is vitally important that those who design and
63    deploy security systems understand the impact of strict filtering on
64    upper-layer protocols.  The safest web site in the world is worthless
65    if most TCP implementations cannot transfer data from it.  It would
66    be far nicer to have all of the black holes fixed rather than fixing
67    all of the TCP implementations."
68
69                            Golden words :-).
70                    */
71
72                         dst_negative_advice(&sk->sk_dst_cache);
73                 }
74
75                 retry_until = /* FIXME! */ 15 /* FIXME! sysctl_tcp_retries2 */;
76                 /*
77                  * FIXME: see tcp_write_timout and tcp_out_of_resources
78                  */
79         }
80
81         if (icsk->icsk_retransmits >= retry_until) {
82                 /* Has it gone just too far? */
83                 dccp_write_err(sk);
84                 return 1;
85         }
86         return 0;
87 }
88
89 /* This is the same as tcp_delack_timer, sans prequeue & mem_reclaim stuff */
90 static void dccp_delack_timer(unsigned long data)
91 {
92         struct sock *sk = (struct sock *)data;
93         struct inet_connection_sock *icsk = inet_csk(sk);
94
95         bh_lock_sock(sk);
96         if (sock_owned_by_user(sk)) {
97                 /* Try again later. */
98                 icsk->icsk_ack.blocked = 1;
99                 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
100                 sk_reset_timer(sk, &icsk->icsk_delack_timer,
101                                jiffies + TCP_DELACK_MIN);
102                 goto out;
103         }
104
105         if (sk->sk_state == DCCP_CLOSED ||
106             !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
107                 goto out;
108         if (time_after(icsk->icsk_ack.timeout, jiffies)) {
109                 sk_reset_timer(sk, &icsk->icsk_delack_timer,
110                                icsk->icsk_ack.timeout);
111                 goto out;
112         }
113
114         icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
115
116         if (inet_csk_ack_scheduled(sk)) {
117                 if (!icsk->icsk_ack.pingpong) {
118                         /* Delayed ACK missed: inflate ATO. */
119                         icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1,
120                                                  icsk->icsk_rto);
121                 } else {
122                         /* Delayed ACK missed: leave pingpong mode and
123                          * deflate ATO.
124                          */
125                         icsk->icsk_ack.pingpong = 0;
126                         icsk->icsk_ack.ato = TCP_ATO_MIN;
127                 }
128                 dccp_send_ack(sk);
129                 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
130         }
131 out:
132         bh_unlock_sock(sk);
133         sock_put(sk);
134 }
135
136 /*
137  *      The DCCP retransmit timer.
138  */
139 static void dccp_retransmit_timer(struct sock *sk)
140 {
141         struct inet_connection_sock *icsk = inet_csk(sk);
142
143         /* retransmit timer is used for feature negotiation throughout
144          * connection.  In this case, no packet is re-transmitted, but rather an
145          * ack is generated and pending changes are splaced into its options.
146          */
147         if (sk->sk_send_head == NULL) {
148                 dccp_pr_debug("feat negotiation retransmit timeout %p\n", sk);
149                 if (sk->sk_state == DCCP_OPEN)
150                         dccp_send_ack(sk);
151                 goto backoff;
152         }
153
154         /*
155          * sk->sk_send_head has to have one skb with
156          * DCCP_SKB_CB(skb)->dccpd_type set to one of the retransmittable DCCP
157          * packet types (REQUEST, RESPONSE, the ACK in the 3way handshake
158          * (PARTOPEN timer), etc).
159          */
160         BUG_TRAP(sk->sk_send_head != NULL);
161
162         /* 
163          * More than than 4MSL (8 minutes) has passed, a RESET(aborted) was
164          * sent, no need to retransmit, this sock is dead.
165          */
166         if (dccp_write_timeout(sk))
167                 goto out;
168
169         /*
170          * We want to know the number of packets retransmitted, not the
171          * total number of retransmissions of clones of original packets.
172          */
173         if (icsk->icsk_retransmits == 0)
174                 DCCP_INC_STATS_BH(DCCP_MIB_TIMEOUTS);
175
176         if (dccp_retransmit_skb(sk, sk->sk_send_head) < 0) {
177                 /*
178                  * Retransmission failed because of local congestion,
179                  * do not backoff.
180                  */
181                 if (icsk->icsk_retransmits == 0)
182                         icsk->icsk_retransmits = 1;
183                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
184                                           min(icsk->icsk_rto,
185                                               TCP_RESOURCE_PROBE_INTERVAL),
186                                           DCCP_RTO_MAX);
187                 goto out;
188         }
189
190 backoff:
191         icsk->icsk_backoff++;
192         icsk->icsk_retransmits++;
193
194         icsk->icsk_rto = min(icsk->icsk_rto << 1, DCCP_RTO_MAX);
195         inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto,
196                                   DCCP_RTO_MAX);
197         if (icsk->icsk_retransmits > 3 /* FIXME: sysctl_dccp_retries1 */)
198                 __sk_dst_reset(sk);
199 out:;
200 }
201
202 static void dccp_write_timer(unsigned long data)
203 {
204         struct sock *sk = (struct sock *)data;
205         struct inet_connection_sock *icsk = inet_csk(sk);
206         int event = 0;
207
208         bh_lock_sock(sk);
209         if (sock_owned_by_user(sk)) {
210                 /* Try again later */
211                 sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
212                                jiffies + (HZ / 20));
213                 goto out;
214         }
215
216         if (sk->sk_state == DCCP_CLOSED || !icsk->icsk_pending)
217                 goto out;
218
219         if (time_after(icsk->icsk_timeout, jiffies)) {
220                 sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
221                                icsk->icsk_timeout);
222                 goto out;
223         }
224
225         event = icsk->icsk_pending;
226         icsk->icsk_pending = 0;
227
228         switch (event) {
229         case ICSK_TIME_RETRANS:
230                 dccp_retransmit_timer(sk);
231                 break;
232         }
233 out:
234         bh_unlock_sock(sk);
235         sock_put(sk);
236 }
237
238 /*
239  *      Timer for listening sockets
240  */
241 static void dccp_response_timer(struct sock *sk)
242 {
243         inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL, DCCP_TIMEOUT_INIT,
244                                    DCCP_RTO_MAX);
245 }
246
247 static void dccp_keepalive_timer(unsigned long data)
248 {
249         struct sock *sk = (struct sock *)data;
250
251         /* Only process if socket is not in use. */
252         bh_lock_sock(sk);
253         if (sock_owned_by_user(sk)) {
254                 /* Try again later. */ 
255                 inet_csk_reset_keepalive_timer(sk, HZ / 20);
256                 goto out;
257         }
258
259         if (sk->sk_state == DCCP_LISTEN) {
260                 dccp_response_timer(sk);
261                 goto out;
262         }
263 out:
264         bh_unlock_sock(sk);
265         sock_put(sk);
266 }