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