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 | * Implementation of the Transmission Control Protocol(TCP). |
7 | * |
8 | * Authors: Ross Biro |
9 | * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> |
10 | * Mark Evans, <evansmp@uhura.aston.ac.uk> |
11 | * Corey Minyard <wf-rch!minyard@relay.EU.net> |
12 | * Florian La Roche, <flla@stud.uni-sb.de> |
13 | * Charles Hedrick, <hedrick@klinzhai.rutgers.edu> |
14 | * Linus Torvalds, <torvalds@cs.helsinki.fi> |
15 | * Alan Cox, <gw4pts@gw4pts.ampr.org> |
16 | * Matthew Dillon, <dillon@apollo.west.oic.com> |
17 | * Arnt Gulbrandsen, <agulbra@nvg.unit.no> |
18 | * Jorge Cwik, <jorge@laser.satlink.net> |
19 | */ |
20 | |
21 | #include <linux/module.h> |
22 | #include <linux/gfp.h> |
23 | #include <net/tcp.h> |
24 | |
25 | static u32 tcp_clamp_rto_to_user_timeout(const struct sock *sk) |
26 | { |
27 | struct inet_connection_sock *icsk = inet_csk(sk); |
28 | u32 elapsed, start_ts; |
29 | s32 remaining; |
30 | |
31 | start_ts = tcp_sk(sk)->retrans_stamp; |
32 | if (!icsk->icsk_user_timeout) |
33 | return icsk->icsk_rto; |
34 | elapsed = tcp_time_stamp(tcp_sk(sk)) - start_ts; |
35 | remaining = icsk->icsk_user_timeout - elapsed; |
36 | if (remaining <= 0) |
37 | return 1; /* user timeout has passed; fire ASAP */ |
38 | |
39 | return min_t(u32, icsk->icsk_rto, msecs_to_jiffies(remaining)); |
40 | } |
41 | |
42 | /** |
43 | * tcp_write_err() - close socket and save error info |
44 | * @sk: The socket the error has appeared on. |
45 | * |
46 | * Returns: Nothing (void) |
47 | */ |
48 | |
49 | static void tcp_write_err(struct sock *sk) |
50 | { |
51 | sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT; |
52 | sk->sk_error_report(sk); |
53 | |
54 | tcp_write_queue_purge(sk); |
55 | tcp_done(sk); |
56 | __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONTIMEOUT); |
57 | } |
58 | |
59 | /** |
60 | * tcp_out_of_resources() - Close socket if out of resources |
61 | * @sk: pointer to current socket |
62 | * @do_reset: send a last packet with reset flag |
63 | * |
64 | * Do not allow orphaned sockets to eat all our resources. |
65 | * This is direct violation of TCP specs, but it is required |
66 | * to prevent DoS attacks. It is called when a retransmission timeout |
67 | * or zero probe timeout occurs on orphaned socket. |
68 | * |
69 | * Also close if our net namespace is exiting; in that case there is no |
70 | * hope of ever communicating again since all netns interfaces are already |
71 | * down (or about to be down), and we need to release our dst references, |
72 | * which have been moved to the netns loopback interface, so the namespace |
73 | * can finish exiting. This condition is only possible if we are a kernel |
74 | * socket, as those do not hold references to the namespace. |
75 | * |
76 | * Criteria is still not confirmed experimentally and may change. |
77 | * We kill the socket, if: |
78 | * 1. If number of orphaned sockets exceeds an administratively configured |
79 | * limit. |
80 | * 2. If we have strong memory pressure. |
81 | * 3. If our net namespace is exiting. |
82 | */ |
83 | static int tcp_out_of_resources(struct sock *sk, bool do_reset) |
84 | { |
85 | struct tcp_sock *tp = tcp_sk(sk); |
86 | int shift = 0; |
87 | |
88 | /* If peer does not open window for long time, or did not transmit |
89 | * anything for long time, penalize it. */ |
90 | if ((s32)(tcp_jiffies32 - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset) |
91 | shift++; |
92 | |
93 | /* If some dubious ICMP arrived, penalize even more. */ |
94 | if (sk->sk_err_soft) |
95 | shift++; |
96 | |
97 | if (tcp_check_oom(sk, shift)) { |
98 | /* Catch exceptional cases, when connection requires reset. |
99 | * 1. Last segment was sent recently. */ |
100 | if ((s32)(tcp_jiffies32 - tp->lsndtime) <= TCP_TIMEWAIT_LEN || |
101 | /* 2. Window is closed. */ |
102 | (!tp->snd_wnd && !tp->packets_out)) |
103 | do_reset = true; |
104 | if (do_reset) |
105 | tcp_send_active_reset(sk, GFP_ATOMIC); |
106 | tcp_done(sk); |
107 | __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONMEMORY); |
108 | return 1; |
109 | } |
110 | |
111 | if (!check_net(sock_net(sk))) { |
112 | /* Not possible to send reset; just close */ |
113 | tcp_done(sk); |
114 | return 1; |
115 | } |
116 | |
117 | return 0; |
118 | } |
119 | |
120 | /** |
121 | * tcp_orphan_retries() - Returns maximal number of retries on an orphaned socket |
122 | * @sk: Pointer to the current socket. |
123 | * @alive: bool, socket alive state |
124 | */ |
125 | static int tcp_orphan_retries(struct sock *sk, bool alive) |
126 | { |
127 | int retries = sock_net(sk)->ipv4.sysctl_tcp_orphan_retries; /* May be zero. */ |
128 | |
129 | /* We know from an ICMP that something is wrong. */ |
130 | if (sk->sk_err_soft && !alive) |
131 | retries = 0; |
132 | |
133 | /* However, if socket sent something recently, select some safe |
134 | * number of retries. 8 corresponds to >100 seconds with minimal |
135 | * RTO of 200msec. */ |
136 | if (retries == 0 && alive) |
137 | retries = 8; |
138 | return retries; |
139 | } |
140 | |
141 | static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk) |
142 | { |
143 | const struct net *net = sock_net(sk); |
144 | int mss; |
145 | |
146 | /* Black hole detection */ |
147 | if (!net->ipv4.sysctl_tcp_mtu_probing) |
148 | return; |
149 | |
150 | if (!icsk->icsk_mtup.enabled) { |
151 | icsk->icsk_mtup.enabled = 1; |
152 | icsk->icsk_mtup.probe_timestamp = tcp_jiffies32; |
153 | } else { |
154 | mss = tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low) >> 1; |
155 | mss = min(net->ipv4.sysctl_tcp_base_mss, mss); |
156 | mss = max(mss, 68 - tcp_sk(sk)->tcp_header_len); |
157 | icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, mss); |
158 | } |
159 | tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); |
160 | } |
161 | |
162 | static unsigned int tcp_model_timeout(struct sock *sk, |
163 | unsigned int boundary, |
164 | unsigned int rto_base) |
165 | { |
166 | unsigned int linear_backoff_thresh, timeout; |
167 | |
168 | linear_backoff_thresh = ilog2(TCP_RTO_MAX / rto_base); |
169 | if (boundary <= linear_backoff_thresh) |
170 | timeout = ((2 << boundary) - 1) * rto_base; |
171 | else |
172 | timeout = ((2 << linear_backoff_thresh) - 1) * rto_base + |
173 | (boundary - linear_backoff_thresh) * TCP_RTO_MAX; |
174 | return jiffies_to_msecs(timeout); |
175 | } |
176 | /** |
177 | * retransmits_timed_out() - returns true if this connection has timed out |
178 | * @sk: The current socket |
179 | * @boundary: max number of retransmissions |
180 | * @timeout: A custom timeout value. |
181 | * If set to 0 the default timeout is calculated and used. |
182 | * Using TCP_RTO_MIN and the number of unsuccessful retransmits. |
183 | * |
184 | * The default "timeout" value this function can calculate and use |
185 | * is equivalent to the timeout of a TCP Connection |
186 | * after "boundary" unsuccessful, exponentially backed-off |
187 | * retransmissions with an initial RTO of TCP_RTO_MIN. |
188 | */ |
189 | static bool retransmits_timed_out(struct sock *sk, |
190 | unsigned int boundary, |
191 | unsigned int timeout) |
192 | { |
193 | unsigned int start_ts; |
194 | |
195 | if (!inet_csk(sk)->icsk_retransmits) |
196 | return false; |
197 | |
198 | start_ts = tcp_sk(sk)->retrans_stamp; |
199 | if (likely(timeout == 0)) |
200 | timeout = tcp_model_timeout(sk, boundary, TCP_RTO_MIN); |
201 | |
202 | return (s32)(tcp_time_stamp(tcp_sk(sk)) - start_ts - timeout) >= 0; |
203 | } |
204 | |
205 | /* A write timeout has occurred. Process the after effects. */ |
206 | static int tcp_write_timeout(struct sock *sk) |
207 | { |
208 | struct inet_connection_sock *icsk = inet_csk(sk); |
209 | struct tcp_sock *tp = tcp_sk(sk); |
210 | struct net *net = sock_net(sk); |
211 | bool expired, do_reset; |
212 | int retry_until; |
213 | |
214 | if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { |
215 | if (icsk->icsk_retransmits) { |
216 | dst_negative_advice(sk); |
217 | } else { |
218 | sk_rethink_txhash(sk); |
219 | } |
220 | retry_until = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_syn_retries; |
221 | expired = icsk->icsk_retransmits >= retry_until; |
222 | } else { |
223 | if (retransmits_timed_out(sk, net->ipv4.sysctl_tcp_retries1, 0)) { |
224 | /* Black hole detection */ |
225 | tcp_mtu_probing(icsk, sk); |
226 | |
227 | dst_negative_advice(sk); |
228 | } else { |
229 | sk_rethink_txhash(sk); |
230 | } |
231 | |
232 | retry_until = net->ipv4.sysctl_tcp_retries2; |
233 | if (sock_flag(sk, SOCK_DEAD)) { |
234 | const bool alive = icsk->icsk_rto < TCP_RTO_MAX; |
235 | |
236 | retry_until = tcp_orphan_retries(sk, alive); |
237 | do_reset = alive || |
238 | !retransmits_timed_out(sk, retry_until, 0); |
239 | |
240 | if (tcp_out_of_resources(sk, do_reset)) |
241 | return 1; |
242 | } |
243 | expired = retransmits_timed_out(sk, retry_until, |
244 | icsk->icsk_user_timeout); |
245 | } |
246 | tcp_fastopen_active_detect_blackhole(sk, expired); |
247 | |
248 | if (BPF_SOCK_OPS_TEST_FLAG(tp, BPF_SOCK_OPS_RTO_CB_FLAG)) |
249 | tcp_call_bpf_3arg(sk, BPF_SOCK_OPS_RTO_CB, |
250 | icsk->icsk_retransmits, |
251 | icsk->icsk_rto, (int)expired); |
252 | |
253 | if (expired) { |
254 | /* Has it gone just too far? */ |
255 | tcp_write_err(sk); |
256 | return 1; |
257 | } |
258 | |
259 | return 0; |
260 | } |
261 | |
262 | /* Called with BH disabled */ |
263 | void tcp_delack_timer_handler(struct sock *sk) |
264 | { |
265 | struct inet_connection_sock *icsk = inet_csk(sk); |
266 | |
267 | sk_mem_reclaim_partial(sk); |
268 | |
269 | if (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)) || |
270 | !(icsk->icsk_ack.pending & ICSK_ACK_TIMER)) |
271 | goto out; |
272 | |
273 | if (time_after(icsk->icsk_ack.timeout, jiffies)) { |
274 | sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout); |
275 | goto out; |
276 | } |
277 | icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER; |
278 | |
279 | if (inet_csk_ack_scheduled(sk)) { |
280 | if (!inet_csk_in_pingpong_mode(sk)) { |
281 | /* Delayed ACK missed: inflate ATO. */ |
282 | icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto); |
283 | } else { |
284 | /* Delayed ACK missed: leave pingpong mode and |
285 | * deflate ATO. |
286 | */ |
287 | inet_csk_exit_pingpong_mode(sk); |
288 | icsk->icsk_ack.ato = TCP_ATO_MIN; |
289 | } |
290 | tcp_mstamp_refresh(tcp_sk(sk)); |
291 | tcp_send_ack(sk); |
292 | __NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKS); |
293 | } |
294 | |
295 | out: |
296 | if (tcp_under_memory_pressure(sk)) |
297 | sk_mem_reclaim(sk); |
298 | } |
299 | |
300 | |
301 | /** |
302 | * tcp_delack_timer() - The TCP delayed ACK timeout handler |
303 | * @data: Pointer to the current socket. (gets casted to struct sock *) |
304 | * |
305 | * This function gets (indirectly) called when the kernel timer for a TCP packet |
306 | * of this socket expires. Calls tcp_delack_timer_handler() to do the actual work. |
307 | * |
308 | * Returns: Nothing (void) |
309 | */ |
310 | static void tcp_delack_timer(struct timer_list *t) |
311 | { |
312 | struct inet_connection_sock *icsk = |
313 | from_timer(icsk, t, icsk_delack_timer); |
314 | struct sock *sk = &icsk->icsk_inet.sk; |
315 | |
316 | bh_lock_sock(sk); |
317 | if (!sock_owned_by_user(sk)) { |
318 | tcp_delack_timer_handler(sk); |
319 | } else { |
320 | icsk->icsk_ack.blocked = 1; |
321 | __NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED); |
322 | /* deleguate our work to tcp_release_cb() */ |
323 | if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, &sk->sk_tsq_flags)) |
324 | sock_hold(sk); |
325 | } |
326 | bh_unlock_sock(sk); |
327 | sock_put(sk); |
328 | } |
329 | |
330 | static void tcp_probe_timer(struct sock *sk) |
331 | { |
332 | struct inet_connection_sock *icsk = inet_csk(sk); |
333 | struct sk_buff *skb = tcp_send_head(sk); |
334 | struct tcp_sock *tp = tcp_sk(sk); |
335 | int max_probes; |
336 | |
337 | if (tp->packets_out || !skb) { |
338 | icsk->icsk_probes_out = 0; |
339 | return; |
340 | } |
341 | |
342 | /* RFC 1122 4.2.2.17 requires the sender to stay open indefinitely as |
343 | * long as the receiver continues to respond probes. We support this by |
344 | * default and reset icsk_probes_out with incoming ACKs. But if the |
345 | * socket is orphaned or the user specifies TCP_USER_TIMEOUT, we |
346 | * kill the socket when the retry count and the time exceeds the |
347 | * corresponding system limit. We also implement similar policy when |
348 | * we use RTO to probe window in tcp_retransmit_timer(). |
349 | */ |
350 | if (icsk->icsk_user_timeout) { |
351 | u32 elapsed = tcp_model_timeout(sk, icsk->icsk_probes_out, |
352 | tcp_probe0_base(sk)); |
353 | |
354 | if (elapsed >= icsk->icsk_user_timeout) |
355 | goto abort; |
356 | } |
357 | |
358 | max_probes = sock_net(sk)->ipv4.sysctl_tcp_retries2; |
359 | if (sock_flag(sk, SOCK_DEAD)) { |
360 | const bool alive = inet_csk_rto_backoff(icsk, TCP_RTO_MAX) < TCP_RTO_MAX; |
361 | |
362 | max_probes = tcp_orphan_retries(sk, alive); |
363 | if (!alive && icsk->icsk_backoff >= max_probes) |
364 | goto abort; |
365 | if (tcp_out_of_resources(sk, true)) |
366 | return; |
367 | } |
368 | |
369 | if (icsk->icsk_probes_out >= max_probes) { |
370 | abort: tcp_write_err(sk); |
371 | } else { |
372 | /* Only send another probe if we didn't close things up. */ |
373 | tcp_send_probe0(sk); |
374 | } |
375 | } |
376 | |
377 | /* |
378 | * Timer for Fast Open socket to retransmit SYNACK. Note that the |
379 | * sk here is the child socket, not the parent (listener) socket. |
380 | */ |
381 | static void tcp_fastopen_synack_timer(struct sock *sk) |
382 | { |
383 | struct inet_connection_sock *icsk = inet_csk(sk); |
384 | int max_retries = icsk->icsk_syn_retries ? : |
385 | sock_net(sk)->ipv4.sysctl_tcp_synack_retries + 1; /* add one more retry for fastopen */ |
386 | struct tcp_sock *tp = tcp_sk(sk); |
387 | struct request_sock *req; |
388 | |
389 | req = tcp_sk(sk)->fastopen_rsk; |
390 | req->rsk_ops->syn_ack_timeout(req); |
391 | |
392 | if (req->num_timeout >= max_retries) { |
393 | tcp_write_err(sk); |
394 | return; |
395 | } |
396 | /* XXX (TFO) - Unlike regular SYN-ACK retransmit, we ignore error |
397 | * returned from rtx_syn_ack() to make it more persistent like |
398 | * regular retransmit because if the child socket has been accepted |
399 | * it's not good to give up too easily. |
400 | */ |
401 | inet_rtx_syn_ack(sk, req); |
402 | req->num_timeout++; |
403 | icsk->icsk_retransmits++; |
404 | if (!tp->retrans_stamp) |
405 | tp->retrans_stamp = tcp_time_stamp(tp); |
406 | inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, |
407 | TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX); |
408 | } |
409 | |
410 | |
411 | /** |
412 | * tcp_retransmit_timer() - The TCP retransmit timeout handler |
413 | * @sk: Pointer to the current socket. |
414 | * |
415 | * This function gets called when the kernel timer for a TCP packet |
416 | * of this socket expires. |
417 | * |
418 | * It handles retransmission, timer adjustment and other necesarry measures. |
419 | * |
420 | * Returns: Nothing (void) |
421 | */ |
422 | void tcp_retransmit_timer(struct sock *sk) |
423 | { |
424 | struct tcp_sock *tp = tcp_sk(sk); |
425 | struct net *net = sock_net(sk); |
426 | struct inet_connection_sock *icsk = inet_csk(sk); |
427 | |
428 | if (tp->fastopen_rsk) { |
429 | WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV && |
430 | sk->sk_state != TCP_FIN_WAIT1); |
431 | tcp_fastopen_synack_timer(sk); |
432 | /* Before we receive ACK to our SYN-ACK don't retransmit |
433 | * anything else (e.g., data or FIN segments). |
434 | */ |
435 | return; |
436 | } |
437 | if (!tp->packets_out || WARN_ON_ONCE(tcp_rtx_queue_empty(sk))) |
438 | return; |
439 | |
440 | tp->tlp_high_seq = 0; |
441 | |
442 | if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) && |
443 | !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) { |
444 | /* Receiver dastardly shrinks window. Our retransmits |
445 | * become zero probes, but we should not timeout this |
446 | * connection. If the socket is an orphan, time it out, |
447 | * we cannot allow such beasts to hang infinitely. |
448 | */ |
449 | struct inet_sock *inet = inet_sk(sk); |
450 | if (sk->sk_family == AF_INET) { |
451 | net_dbg_ratelimited("Peer %pI4:%u/%u unexpectedly shrunk window %u:%u (repaired)\n" , |
452 | &inet->inet_daddr, |
453 | ntohs(inet->inet_dport), |
454 | inet->inet_num, |
455 | tp->snd_una, tp->snd_nxt); |
456 | } |
457 | #if IS_ENABLED(CONFIG_IPV6) |
458 | else if (sk->sk_family == AF_INET6) { |
459 | net_dbg_ratelimited("Peer %pI6:%u/%u unexpectedly shrunk window %u:%u (repaired)\n" , |
460 | &sk->sk_v6_daddr, |
461 | ntohs(inet->inet_dport), |
462 | inet->inet_num, |
463 | tp->snd_una, tp->snd_nxt); |
464 | } |
465 | #endif |
466 | if (tcp_jiffies32 - tp->rcv_tstamp > TCP_RTO_MAX) { |
467 | tcp_write_err(sk); |
468 | goto out; |
469 | } |
470 | tcp_enter_loss(sk); |
471 | tcp_retransmit_skb(sk, tcp_rtx_queue_head(sk), 1); |
472 | __sk_dst_reset(sk); |
473 | goto out_reset_timer; |
474 | } |
475 | |
476 | __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPTIMEOUTS); |
477 | if (tcp_write_timeout(sk)) |
478 | goto out; |
479 | |
480 | if (icsk->icsk_retransmits == 0) { |
481 | int mib_idx = 0; |
482 | |
483 | if (icsk->icsk_ca_state == TCP_CA_Recovery) { |
484 | if (tcp_is_sack(tp)) |
485 | mib_idx = LINUX_MIB_TCPSACKRECOVERYFAIL; |
486 | else |
487 | mib_idx = LINUX_MIB_TCPRENORECOVERYFAIL; |
488 | } else if (icsk->icsk_ca_state == TCP_CA_Loss) { |
489 | mib_idx = LINUX_MIB_TCPLOSSFAILURES; |
490 | } else if ((icsk->icsk_ca_state == TCP_CA_Disorder) || |
491 | tp->sacked_out) { |
492 | if (tcp_is_sack(tp)) |
493 | mib_idx = LINUX_MIB_TCPSACKFAILURES; |
494 | else |
495 | mib_idx = LINUX_MIB_TCPRENOFAILURES; |
496 | } |
497 | if (mib_idx) |
498 | __NET_INC_STATS(sock_net(sk), mib_idx); |
499 | } |
500 | |
501 | tcp_enter_loss(sk); |
502 | |
503 | icsk->icsk_retransmits++; |
504 | if (tcp_retransmit_skb(sk, tcp_rtx_queue_head(sk), 1) > 0) { |
505 | /* Retransmission failed because of local congestion, |
506 | * Let senders fight for local resources conservatively. |
507 | */ |
508 | inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, |
509 | TCP_RESOURCE_PROBE_INTERVAL, |
510 | TCP_RTO_MAX); |
511 | goto out; |
512 | } |
513 | |
514 | /* Increase the timeout each time we retransmit. Note that |
515 | * we do not increase the rtt estimate. rto is initialized |
516 | * from rtt, but increases here. Jacobson (SIGCOMM 88) suggests |
517 | * that doubling rto each time is the least we can get away with. |
518 | * In KA9Q, Karn uses this for the first few times, and then |
519 | * goes to quadratic. netBSD doubles, but only goes up to *64, |
520 | * and clamps at 1 to 64 sec afterwards. Note that 120 sec is |
521 | * defined in the protocol as the maximum possible RTT. I guess |
522 | * we'll have to use something other than TCP to talk to the |
523 | * University of Mars. |
524 | * |
525 | * PAWS allows us longer timeouts and large windows, so once |
526 | * implemented ftp to mars will work nicely. We will have to fix |
527 | * the 120 second clamps though! |
528 | */ |
529 | icsk->icsk_backoff++; |
530 | |
531 | out_reset_timer: |
532 | /* If stream is thin, use linear timeouts. Since 'icsk_backoff' is |
533 | * used to reset timer, set to 0. Recalculate 'icsk_rto' as this |
534 | * might be increased if the stream oscillates between thin and thick, |
535 | * thus the old value might already be too high compared to the value |
536 | * set by 'tcp_set_rto' in tcp_input.c which resets the rto without |
537 | * backoff. Limit to TCP_THIN_LINEAR_RETRIES before initiating |
538 | * exponential backoff behaviour to avoid continue hammering |
539 | * linear-timeout retransmissions into a black hole |
540 | */ |
541 | if (sk->sk_state == TCP_ESTABLISHED && |
542 | (tp->thin_lto || net->ipv4.sysctl_tcp_thin_linear_timeouts) && |
543 | tcp_stream_is_thin(tp) && |
544 | icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) { |
545 | icsk->icsk_backoff = 0; |
546 | icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX); |
547 | } else { |
548 | /* Use normal (exponential) backoff */ |
549 | icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX); |
550 | } |
551 | inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, |
552 | tcp_clamp_rto_to_user_timeout(sk), TCP_RTO_MAX); |
553 | if (retransmits_timed_out(sk, net->ipv4.sysctl_tcp_retries1 + 1, 0)) |
554 | __sk_dst_reset(sk); |
555 | |
556 | out:; |
557 | } |
558 | |
559 | /* Called with bottom-half processing disabled. |
560 | Called by tcp_write_timer() */ |
561 | void tcp_write_timer_handler(struct sock *sk) |
562 | { |
563 | struct inet_connection_sock *icsk = inet_csk(sk); |
564 | int event; |
565 | |
566 | if (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)) || |
567 | !icsk->icsk_pending) |
568 | goto out; |
569 | |
570 | if (time_after(icsk->icsk_timeout, jiffies)) { |
571 | sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout); |
572 | goto out; |
573 | } |
574 | |
575 | tcp_mstamp_refresh(tcp_sk(sk)); |
576 | event = icsk->icsk_pending; |
577 | |
578 | switch (event) { |
579 | case ICSK_TIME_REO_TIMEOUT: |
580 | tcp_rack_reo_timeout(sk); |
581 | break; |
582 | case ICSK_TIME_LOSS_PROBE: |
583 | tcp_send_loss_probe(sk); |
584 | break; |
585 | case ICSK_TIME_RETRANS: |
586 | icsk->icsk_pending = 0; |
587 | tcp_retransmit_timer(sk); |
588 | break; |
589 | case ICSK_TIME_PROBE0: |
590 | icsk->icsk_pending = 0; |
591 | tcp_probe_timer(sk); |
592 | break; |
593 | } |
594 | |
595 | out: |
596 | sk_mem_reclaim(sk); |
597 | } |
598 | |
599 | static void tcp_write_timer(struct timer_list *t) |
600 | { |
601 | struct inet_connection_sock *icsk = |
602 | from_timer(icsk, t, icsk_retransmit_timer); |
603 | struct sock *sk = &icsk->icsk_inet.sk; |
604 | |
605 | bh_lock_sock(sk); |
606 | if (!sock_owned_by_user(sk)) { |
607 | tcp_write_timer_handler(sk); |
608 | } else { |
609 | /* delegate our work to tcp_release_cb() */ |
610 | if (!test_and_set_bit(TCP_WRITE_TIMER_DEFERRED, &sk->sk_tsq_flags)) |
611 | sock_hold(sk); |
612 | } |
613 | bh_unlock_sock(sk); |
614 | sock_put(sk); |
615 | } |
616 | |
617 | void tcp_syn_ack_timeout(const struct request_sock *req) |
618 | { |
619 | struct net *net = read_pnet(&inet_rsk(req)->ireq_net); |
620 | |
621 | __NET_INC_STATS(net, LINUX_MIB_TCPTIMEOUTS); |
622 | } |
623 | EXPORT_SYMBOL(tcp_syn_ack_timeout); |
624 | |
625 | void tcp_set_keepalive(struct sock *sk, int val) |
626 | { |
627 | if ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)) |
628 | return; |
629 | |
630 | if (val && !sock_flag(sk, SOCK_KEEPOPEN)) |
631 | inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk))); |
632 | else if (!val) |
633 | inet_csk_delete_keepalive_timer(sk); |
634 | } |
635 | EXPORT_SYMBOL_GPL(tcp_set_keepalive); |
636 | |
637 | |
638 | static void tcp_keepalive_timer (struct timer_list *t) |
639 | { |
640 | struct sock *sk = from_timer(sk, t, sk_timer); |
641 | struct inet_connection_sock *icsk = inet_csk(sk); |
642 | struct tcp_sock *tp = tcp_sk(sk); |
643 | u32 elapsed; |
644 | |
645 | /* Only process if socket is not in use. */ |
646 | bh_lock_sock(sk); |
647 | if (sock_owned_by_user(sk)) { |
648 | /* Try again later. */ |
649 | inet_csk_reset_keepalive_timer (sk, HZ/20); |
650 | goto out; |
651 | } |
652 | |
653 | if (sk->sk_state == TCP_LISTEN) { |
654 | pr_err("Hmm... keepalive on a LISTEN ???\n" ); |
655 | goto out; |
656 | } |
657 | |
658 | tcp_mstamp_refresh(tp); |
659 | if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) { |
660 | if (tp->linger2 >= 0) { |
661 | const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN; |
662 | |
663 | if (tmo > 0) { |
664 | tcp_time_wait(sk, TCP_FIN_WAIT2, tmo); |
665 | goto out; |
666 | } |
667 | } |
668 | tcp_send_active_reset(sk, GFP_ATOMIC); |
669 | goto death; |
670 | } |
671 | |
672 | if (!sock_flag(sk, SOCK_KEEPOPEN) || |
673 | ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT))) |
674 | goto out; |
675 | |
676 | elapsed = keepalive_time_when(tp); |
677 | |
678 | /* It is alive without keepalive 8) */ |
679 | if (tp->packets_out || !tcp_write_queue_empty(sk)) |
680 | goto resched; |
681 | |
682 | elapsed = keepalive_time_elapsed(tp); |
683 | |
684 | if (elapsed >= keepalive_time_when(tp)) { |
685 | /* If the TCP_USER_TIMEOUT option is enabled, use that |
686 | * to determine when to timeout instead. |
687 | */ |
688 | if ((icsk->icsk_user_timeout != 0 && |
689 | elapsed >= msecs_to_jiffies(icsk->icsk_user_timeout) && |
690 | icsk->icsk_probes_out > 0) || |
691 | (icsk->icsk_user_timeout == 0 && |
692 | icsk->icsk_probes_out >= keepalive_probes(tp))) { |
693 | tcp_send_active_reset(sk, GFP_ATOMIC); |
694 | tcp_write_err(sk); |
695 | goto out; |
696 | } |
697 | if (tcp_write_wakeup(sk, LINUX_MIB_TCPKEEPALIVE) <= 0) { |
698 | icsk->icsk_probes_out++; |
699 | elapsed = keepalive_intvl_when(tp); |
700 | } else { |
701 | /* If keepalive was lost due to local congestion, |
702 | * try harder. |
703 | */ |
704 | elapsed = TCP_RESOURCE_PROBE_INTERVAL; |
705 | } |
706 | } else { |
707 | /* It is tp->rcv_tstamp + keepalive_time_when(tp) */ |
708 | elapsed = keepalive_time_when(tp) - elapsed; |
709 | } |
710 | |
711 | sk_mem_reclaim(sk); |
712 | |
713 | resched: |
714 | inet_csk_reset_keepalive_timer (sk, elapsed); |
715 | goto out; |
716 | |
717 | death: |
718 | tcp_done(sk); |
719 | |
720 | out: |
721 | bh_unlock_sock(sk); |
722 | sock_put(sk); |
723 | } |
724 | |
725 | static enum hrtimer_restart tcp_compressed_ack_kick(struct hrtimer *timer) |
726 | { |
727 | struct tcp_sock *tp = container_of(timer, struct tcp_sock, compressed_ack_timer); |
728 | struct sock *sk = (struct sock *)tp; |
729 | |
730 | bh_lock_sock(sk); |
731 | if (!sock_owned_by_user(sk)) { |
732 | if (tp->compressed_ack > TCP_FASTRETRANS_THRESH) |
733 | tcp_send_ack(sk); |
734 | } else { |
735 | if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, |
736 | &sk->sk_tsq_flags)) |
737 | sock_hold(sk); |
738 | } |
739 | bh_unlock_sock(sk); |
740 | |
741 | sock_put(sk); |
742 | |
743 | return HRTIMER_NORESTART; |
744 | } |
745 | |
746 | void tcp_init_xmit_timers(struct sock *sk) |
747 | { |
748 | inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer, |
749 | &tcp_keepalive_timer); |
750 | hrtimer_init(&tcp_sk(sk)->pacing_timer, CLOCK_MONOTONIC, |
751 | HRTIMER_MODE_ABS_PINNED_SOFT); |
752 | tcp_sk(sk)->pacing_timer.function = tcp_pace_kick; |
753 | |
754 | hrtimer_init(&tcp_sk(sk)->compressed_ack_timer, CLOCK_MONOTONIC, |
755 | HRTIMER_MODE_REL_PINNED_SOFT); |
756 | tcp_sk(sk)->compressed_ack_timer.function = tcp_compressed_ack_kick; |
757 | } |
758 | |