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 int sysctl_tcp_thin_linear_timeouts __read_mostly; 26 27 static void tcp_write_err(struct sock *sk) 28 { 29 sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT; 30 sk->sk_error_report(sk); 31 32 tcp_done(sk); 33 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONTIMEOUT); 34 } 35 36 /* Do not allow orphaned sockets to eat all our resources. 37 * This is direct violation of TCP specs, but it is required 38 * to prevent DoS attacks. It is called when a retransmission timeout 39 * or zero probe timeout occurs on orphaned socket. 40 * 41 * Criteria is still not confirmed experimentally and may change. 42 * We kill the socket, if: 43 * 1. If number of orphaned sockets exceeds an administratively configured 44 * limit. 45 * 2. If we have strong memory pressure. 46 */ 47 static int tcp_out_of_resources(struct sock *sk, bool do_reset) 48 { 49 struct tcp_sock *tp = tcp_sk(sk); 50 int shift = 0; 51 52 /* If peer does not open window for long time, or did not transmit 53 * anything for long time, penalize it. */ 54 if ((s32)(tcp_time_stamp - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset) 55 shift++; 56 57 /* If some dubious ICMP arrived, penalize even more. */ 58 if (sk->sk_err_soft) 59 shift++; 60 61 if (tcp_check_oom(sk, shift)) { 62 /* Catch exceptional cases, when connection requires reset. 63 * 1. Last segment was sent recently. */ 64 if ((s32)(tcp_time_stamp - tp->lsndtime) <= TCP_TIMEWAIT_LEN || 65 /* 2. Window is closed. */ 66 (!tp->snd_wnd && !tp->packets_out)) 67 do_reset = true; 68 if (do_reset) 69 tcp_send_active_reset(sk, GFP_ATOMIC); 70 tcp_done(sk); 71 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONMEMORY); 72 return 1; 73 } 74 return 0; 75 } 76 77 /* Calculate maximal number or retries on an orphaned socket. */ 78 static int tcp_orphan_retries(struct sock *sk, bool alive) 79 { 80 int retries = sock_net(sk)->ipv4.sysctl_tcp_orphan_retries; /* May be zero. */ 81 82 /* We know from an ICMP that something is wrong. */ 83 if (sk->sk_err_soft && !alive) 84 retries = 0; 85 86 /* However, if socket sent something recently, select some safe 87 * number of retries. 8 corresponds to >100 seconds with minimal 88 * RTO of 200msec. */ 89 if (retries == 0 && alive) 90 retries = 8; 91 return retries; 92 } 93 94 static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk) 95 { 96 struct net *net = sock_net(sk); 97 98 /* Black hole detection */ 99 if (net->ipv4.sysctl_tcp_mtu_probing) { 100 if (!icsk->icsk_mtup.enabled) { 101 icsk->icsk_mtup.enabled = 1; 102 icsk->icsk_mtup.probe_timestamp = tcp_time_stamp; 103 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); 104 } else { 105 struct net *net = sock_net(sk); 106 struct tcp_sock *tp = tcp_sk(sk); 107 int mss; 108 109 mss = tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low) >> 1; 110 mss = min(net->ipv4.sysctl_tcp_base_mss, mss); 111 mss = max(mss, 68 - tp->tcp_header_len); 112 icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, mss); 113 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); 114 } 115 } 116 } 117 118 /* This function calculates a "timeout" which is equivalent to the timeout of a 119 * TCP connection after "boundary" unsuccessful, exponentially backed-off 120 * retransmissions with an initial RTO of TCP_RTO_MIN or TCP_TIMEOUT_INIT if 121 * syn_set flag is set. 122 */ 123 static bool retransmits_timed_out(struct sock *sk, 124 unsigned int boundary, 125 unsigned int timeout, 126 bool syn_set) 127 { 128 unsigned int linear_backoff_thresh, start_ts; 129 unsigned int rto_base = syn_set ? TCP_TIMEOUT_INIT : TCP_RTO_MIN; 130 131 if (!inet_csk(sk)->icsk_retransmits) 132 return false; 133 134 start_ts = tcp_sk(sk)->retrans_stamp; 135 if (unlikely(!start_ts)) 136 start_ts = tcp_skb_timestamp(tcp_write_queue_head(sk)); 137 138 if (likely(timeout == 0)) { 139 linear_backoff_thresh = ilog2(TCP_RTO_MAX/rto_base); 140 141 if (boundary <= linear_backoff_thresh) 142 timeout = ((2 << boundary) - 1) * rto_base; 143 else 144 timeout = ((2 << linear_backoff_thresh) - 1) * rto_base + 145 (boundary - linear_backoff_thresh) * TCP_RTO_MAX; 146 } 147 return (tcp_time_stamp - start_ts) >= timeout; 148 } 149 150 /* A write timeout has occurred. Process the after effects. */ 151 static int tcp_write_timeout(struct sock *sk) 152 { 153 struct inet_connection_sock *icsk = inet_csk(sk); 154 struct tcp_sock *tp = tcp_sk(sk); 155 struct net *net = sock_net(sk); 156 int retry_until; 157 bool do_reset, syn_set = false; 158 159 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { 160 if (icsk->icsk_retransmits) { 161 dst_negative_advice(sk); 162 if (tp->syn_fastopen || tp->syn_data) 163 tcp_fastopen_cache_set(sk, 0, NULL, true, 0); 164 if (tp->syn_data && icsk->icsk_retransmits == 1) 165 NET_INC_STATS_BH(sock_net(sk), 166 LINUX_MIB_TCPFASTOPENACTIVEFAIL); 167 } 168 retry_until = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_syn_retries; 169 syn_set = true; 170 } else { 171 if (retransmits_timed_out(sk, net->ipv4.sysctl_tcp_retries1, 0, 0)) { 172 /* Some middle-boxes may black-hole Fast Open _after_ 173 * the handshake. Therefore we conservatively disable 174 * Fast Open on this path on recurring timeouts with 175 * few or zero bytes acked after Fast Open. 176 */ 177 if (tp->syn_data_acked && 178 tp->bytes_acked <= tp->rx_opt.mss_clamp) { 179 tcp_fastopen_cache_set(sk, 0, NULL, true, 0); 180 if (icsk->icsk_retransmits == net->ipv4.sysctl_tcp_retries1) 181 NET_INC_STATS_BH(sock_net(sk), 182 LINUX_MIB_TCPFASTOPENACTIVEFAIL); 183 } 184 /* Black hole detection */ 185 tcp_mtu_probing(icsk, sk); 186 187 dst_negative_advice(sk); 188 } 189 190 retry_until = net->ipv4.sysctl_tcp_retries2; 191 if (sock_flag(sk, SOCK_DEAD)) { 192 const bool alive = icsk->icsk_rto < TCP_RTO_MAX; 193 194 retry_until = tcp_orphan_retries(sk, alive); 195 do_reset = alive || 196 !retransmits_timed_out(sk, retry_until, 0, 0); 197 198 if (tcp_out_of_resources(sk, do_reset)) 199 return 1; 200 } 201 } 202 203 if (retransmits_timed_out(sk, retry_until, 204 syn_set ? 0 : icsk->icsk_user_timeout, syn_set)) { 205 /* Has it gone just too far? */ 206 tcp_write_err(sk); 207 return 1; 208 } 209 return 0; 210 } 211 212 void tcp_delack_timer_handler(struct sock *sk) 213 { 214 struct tcp_sock *tp = tcp_sk(sk); 215 struct inet_connection_sock *icsk = inet_csk(sk); 216 217 sk_mem_reclaim_partial(sk); 218 219 if (sk->sk_state == TCP_CLOSE || !(icsk->icsk_ack.pending & ICSK_ACK_TIMER)) 220 goto out; 221 222 if (time_after(icsk->icsk_ack.timeout, jiffies)) { 223 sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout); 224 goto out; 225 } 226 icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER; 227 228 if (!skb_queue_empty(&tp->ucopy.prequeue)) { 229 struct sk_buff *skb; 230 231 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSCHEDULERFAILED); 232 233 while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) 234 sk_backlog_rcv(sk, skb); 235 236 tp->ucopy.memory = 0; 237 } 238 239 if (inet_csk_ack_scheduled(sk)) { 240 if (!icsk->icsk_ack.pingpong) { 241 /* Delayed ACK missed: inflate ATO. */ 242 icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto); 243 } else { 244 /* Delayed ACK missed: leave pingpong mode and 245 * deflate ATO. 246 */ 247 icsk->icsk_ack.pingpong = 0; 248 icsk->icsk_ack.ato = TCP_ATO_MIN; 249 } 250 tcp_send_ack(sk); 251 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKS); 252 } 253 254 out: 255 if (tcp_under_memory_pressure(sk)) 256 sk_mem_reclaim(sk); 257 } 258 259 static void tcp_delack_timer(unsigned long data) 260 { 261 struct sock *sk = (struct sock *)data; 262 263 bh_lock_sock(sk); 264 if (!sock_owned_by_user(sk)) { 265 tcp_delack_timer_handler(sk); 266 } else { 267 inet_csk(sk)->icsk_ack.blocked = 1; 268 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED); 269 /* deleguate our work to tcp_release_cb() */ 270 if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, &tcp_sk(sk)->tsq_flags)) 271 sock_hold(sk); 272 } 273 bh_unlock_sock(sk); 274 sock_put(sk); 275 } 276 277 static void tcp_probe_timer(struct sock *sk) 278 { 279 struct inet_connection_sock *icsk = inet_csk(sk); 280 struct tcp_sock *tp = tcp_sk(sk); 281 int max_probes; 282 u32 start_ts; 283 284 if (tp->packets_out || !tcp_send_head(sk)) { 285 icsk->icsk_probes_out = 0; 286 return; 287 } 288 289 /* RFC 1122 4.2.2.17 requires the sender to stay open indefinitely as 290 * long as the receiver continues to respond probes. We support this by 291 * default and reset icsk_probes_out with incoming ACKs. But if the 292 * socket is orphaned or the user specifies TCP_USER_TIMEOUT, we 293 * kill the socket when the retry count and the time exceeds the 294 * corresponding system limit. We also implement similar policy when 295 * we use RTO to probe window in tcp_retransmit_timer(). 296 */ 297 start_ts = tcp_skb_timestamp(tcp_send_head(sk)); 298 if (!start_ts) 299 skb_mstamp_get(&tcp_send_head(sk)->skb_mstamp); 300 else if (icsk->icsk_user_timeout && 301 (s32)(tcp_time_stamp - start_ts) > icsk->icsk_user_timeout) 302 goto abort; 303 304 max_probes = sock_net(sk)->ipv4.sysctl_tcp_retries2; 305 if (sock_flag(sk, SOCK_DEAD)) { 306 const bool alive = inet_csk_rto_backoff(icsk, TCP_RTO_MAX) < TCP_RTO_MAX; 307 308 max_probes = tcp_orphan_retries(sk, alive); 309 if (!alive && icsk->icsk_backoff >= max_probes) 310 goto abort; 311 if (tcp_out_of_resources(sk, true)) 312 return; 313 } 314 315 if (icsk->icsk_probes_out > max_probes) { 316 abort: tcp_write_err(sk); 317 } else { 318 /* Only send another probe if we didn't close things up. */ 319 tcp_send_probe0(sk); 320 } 321 } 322 323 /* 324 * Timer for Fast Open socket to retransmit SYNACK. Note that the 325 * sk here is the child socket, not the parent (listener) socket. 326 */ 327 static void tcp_fastopen_synack_timer(struct sock *sk) 328 { 329 struct inet_connection_sock *icsk = inet_csk(sk); 330 int max_retries = icsk->icsk_syn_retries ? : 331 sock_net(sk)->ipv4.sysctl_tcp_synack_retries + 1; /* add one more retry for fastopen */ 332 struct request_sock *req; 333 334 req = tcp_sk(sk)->fastopen_rsk; 335 req->rsk_ops->syn_ack_timeout(req); 336 337 if (req->num_timeout >= max_retries) { 338 tcp_write_err(sk); 339 return; 340 } 341 /* XXX (TFO) - Unlike regular SYN-ACK retransmit, we ignore error 342 * returned from rtx_syn_ack() to make it more persistent like 343 * regular retransmit because if the child socket has been accepted 344 * it's not good to give up too easily. 345 */ 346 inet_rtx_syn_ack(sk, req); 347 req->num_timeout++; 348 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, 349 TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX); 350 } 351 352 /* 353 * The TCP retransmit timer. 354 */ 355 356 void tcp_retransmit_timer(struct sock *sk) 357 { 358 struct tcp_sock *tp = tcp_sk(sk); 359 struct net *net = sock_net(sk); 360 struct inet_connection_sock *icsk = inet_csk(sk); 361 362 if (tp->fastopen_rsk) { 363 WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV && 364 sk->sk_state != TCP_FIN_WAIT1); 365 tcp_fastopen_synack_timer(sk); 366 /* Before we receive ACK to our SYN-ACK don't retransmit 367 * anything else (e.g., data or FIN segments). 368 */ 369 return; 370 } 371 if (!tp->packets_out) 372 goto out; 373 374 WARN_ON(tcp_write_queue_empty(sk)); 375 376 tp->tlp_high_seq = 0; 377 378 if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) && 379 !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) { 380 /* Receiver dastardly shrinks window. Our retransmits 381 * become zero probes, but we should not timeout this 382 * connection. If the socket is an orphan, time it out, 383 * we cannot allow such beasts to hang infinitely. 384 */ 385 struct inet_sock *inet = inet_sk(sk); 386 if (sk->sk_family == AF_INET) { 387 net_dbg_ratelimited("Peer %pI4:%u/%u unexpectedly shrunk window %u:%u (repaired)\n", 388 &inet->inet_daddr, 389 ntohs(inet->inet_dport), 390 inet->inet_num, 391 tp->snd_una, tp->snd_nxt); 392 } 393 #if IS_ENABLED(CONFIG_IPV6) 394 else if (sk->sk_family == AF_INET6) { 395 net_dbg_ratelimited("Peer %pI6:%u/%u unexpectedly shrunk window %u:%u (repaired)\n", 396 &sk->sk_v6_daddr, 397 ntohs(inet->inet_dport), 398 inet->inet_num, 399 tp->snd_una, tp->snd_nxt); 400 } 401 #endif 402 if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) { 403 tcp_write_err(sk); 404 goto out; 405 } 406 tcp_enter_loss(sk); 407 tcp_retransmit_skb(sk, tcp_write_queue_head(sk)); 408 __sk_dst_reset(sk); 409 goto out_reset_timer; 410 } 411 412 if (tcp_write_timeout(sk)) 413 goto out; 414 415 if (icsk->icsk_retransmits == 0) { 416 int mib_idx; 417 418 if (icsk->icsk_ca_state == TCP_CA_Recovery) { 419 if (tcp_is_sack(tp)) 420 mib_idx = LINUX_MIB_TCPSACKRECOVERYFAIL; 421 else 422 mib_idx = LINUX_MIB_TCPRENORECOVERYFAIL; 423 } else if (icsk->icsk_ca_state == TCP_CA_Loss) { 424 mib_idx = LINUX_MIB_TCPLOSSFAILURES; 425 } else if ((icsk->icsk_ca_state == TCP_CA_Disorder) || 426 tp->sacked_out) { 427 if (tcp_is_sack(tp)) 428 mib_idx = LINUX_MIB_TCPSACKFAILURES; 429 else 430 mib_idx = LINUX_MIB_TCPRENOFAILURES; 431 } else { 432 mib_idx = LINUX_MIB_TCPTIMEOUTS; 433 } 434 NET_INC_STATS_BH(sock_net(sk), mib_idx); 435 } 436 437 tcp_enter_loss(sk); 438 439 if (tcp_retransmit_skb(sk, tcp_write_queue_head(sk)) > 0) { 440 /* Retransmission failed because of local congestion, 441 * do not backoff. 442 */ 443 if (!icsk->icsk_retransmits) 444 icsk->icsk_retransmits = 1; 445 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, 446 min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL), 447 TCP_RTO_MAX); 448 goto out; 449 } 450 451 /* Increase the timeout each time we retransmit. Note that 452 * we do not increase the rtt estimate. rto is initialized 453 * from rtt, but increases here. Jacobson (SIGCOMM 88) suggests 454 * that doubling rto each time is the least we can get away with. 455 * In KA9Q, Karn uses this for the first few times, and then 456 * goes to quadratic. netBSD doubles, but only goes up to *64, 457 * and clamps at 1 to 64 sec afterwards. Note that 120 sec is 458 * defined in the protocol as the maximum possible RTT. I guess 459 * we'll have to use something other than TCP to talk to the 460 * University of Mars. 461 * 462 * PAWS allows us longer timeouts and large windows, so once 463 * implemented ftp to mars will work nicely. We will have to fix 464 * the 120 second clamps though! 465 */ 466 icsk->icsk_backoff++; 467 icsk->icsk_retransmits++; 468 469 out_reset_timer: 470 /* If stream is thin, use linear timeouts. Since 'icsk_backoff' is 471 * used to reset timer, set to 0. Recalculate 'icsk_rto' as this 472 * might be increased if the stream oscillates between thin and thick, 473 * thus the old value might already be too high compared to the value 474 * set by 'tcp_set_rto' in tcp_input.c which resets the rto without 475 * backoff. Limit to TCP_THIN_LINEAR_RETRIES before initiating 476 * exponential backoff behaviour to avoid continue hammering 477 * linear-timeout retransmissions into a black hole 478 */ 479 if (sk->sk_state == TCP_ESTABLISHED && 480 (tp->thin_lto || sysctl_tcp_thin_linear_timeouts) && 481 tcp_stream_is_thin(tp) && 482 icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) { 483 icsk->icsk_backoff = 0; 484 icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX); 485 } else { 486 /* Use normal (exponential) backoff */ 487 icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX); 488 } 489 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX); 490 if (retransmits_timed_out(sk, net->ipv4.sysctl_tcp_retries1 + 1, 0, 0)) 491 __sk_dst_reset(sk); 492 493 out:; 494 } 495 496 void tcp_write_timer_handler(struct sock *sk) 497 { 498 struct inet_connection_sock *icsk = inet_csk(sk); 499 int event; 500 501 if (sk->sk_state == TCP_CLOSE || !icsk->icsk_pending) 502 goto out; 503 504 if (time_after(icsk->icsk_timeout, jiffies)) { 505 sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout); 506 goto out; 507 } 508 509 event = icsk->icsk_pending; 510 511 switch (event) { 512 case ICSK_TIME_EARLY_RETRANS: 513 tcp_resume_early_retransmit(sk); 514 break; 515 case ICSK_TIME_LOSS_PROBE: 516 tcp_send_loss_probe(sk); 517 break; 518 case ICSK_TIME_RETRANS: 519 icsk->icsk_pending = 0; 520 tcp_retransmit_timer(sk); 521 break; 522 case ICSK_TIME_PROBE0: 523 icsk->icsk_pending = 0; 524 tcp_probe_timer(sk); 525 break; 526 } 527 528 out: 529 sk_mem_reclaim(sk); 530 } 531 532 static void tcp_write_timer(unsigned long data) 533 { 534 struct sock *sk = (struct sock *)data; 535 536 bh_lock_sock(sk); 537 if (!sock_owned_by_user(sk)) { 538 tcp_write_timer_handler(sk); 539 } else { 540 /* deleguate our work to tcp_release_cb() */ 541 if (!test_and_set_bit(TCP_WRITE_TIMER_DEFERRED, &tcp_sk(sk)->tsq_flags)) 542 sock_hold(sk); 543 } 544 bh_unlock_sock(sk); 545 sock_put(sk); 546 } 547 548 void tcp_syn_ack_timeout(const struct request_sock *req) 549 { 550 struct net *net = read_pnet(&inet_rsk(req)->ireq_net); 551 552 NET_INC_STATS_BH(net, LINUX_MIB_TCPTIMEOUTS); 553 } 554 EXPORT_SYMBOL(tcp_syn_ack_timeout); 555 556 void tcp_set_keepalive(struct sock *sk, int val) 557 { 558 if ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)) 559 return; 560 561 if (val && !sock_flag(sk, SOCK_KEEPOPEN)) 562 inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk))); 563 else if (!val) 564 inet_csk_delete_keepalive_timer(sk); 565 } 566 567 568 static void tcp_keepalive_timer (unsigned long data) 569 { 570 struct sock *sk = (struct sock *) data; 571 struct inet_connection_sock *icsk = inet_csk(sk); 572 struct tcp_sock *tp = tcp_sk(sk); 573 u32 elapsed; 574 575 /* Only process if socket is not in use. */ 576 bh_lock_sock(sk); 577 if (sock_owned_by_user(sk)) { 578 /* Try again later. */ 579 inet_csk_reset_keepalive_timer (sk, HZ/20); 580 goto out; 581 } 582 583 if (sk->sk_state == TCP_LISTEN) { 584 pr_err("Hmm... keepalive on a LISTEN ???\n"); 585 goto out; 586 } 587 588 if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) { 589 if (tp->linger2 >= 0) { 590 const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN; 591 592 if (tmo > 0) { 593 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo); 594 goto out; 595 } 596 } 597 tcp_send_active_reset(sk, GFP_ATOMIC); 598 goto death; 599 } 600 601 if (!sock_flag(sk, SOCK_KEEPOPEN) || sk->sk_state == TCP_CLOSE) 602 goto out; 603 604 elapsed = keepalive_time_when(tp); 605 606 /* It is alive without keepalive 8) */ 607 if (tp->packets_out || tcp_send_head(sk)) 608 goto resched; 609 610 elapsed = keepalive_time_elapsed(tp); 611 612 if (elapsed >= keepalive_time_when(tp)) { 613 /* If the TCP_USER_TIMEOUT option is enabled, use that 614 * to determine when to timeout instead. 615 */ 616 if ((icsk->icsk_user_timeout != 0 && 617 elapsed >= icsk->icsk_user_timeout && 618 icsk->icsk_probes_out > 0) || 619 (icsk->icsk_user_timeout == 0 && 620 icsk->icsk_probes_out >= keepalive_probes(tp))) { 621 tcp_send_active_reset(sk, GFP_ATOMIC); 622 tcp_write_err(sk); 623 goto out; 624 } 625 if (tcp_write_wakeup(sk, LINUX_MIB_TCPKEEPALIVE) <= 0) { 626 icsk->icsk_probes_out++; 627 elapsed = keepalive_intvl_when(tp); 628 } else { 629 /* If keepalive was lost due to local congestion, 630 * try harder. 631 */ 632 elapsed = TCP_RESOURCE_PROBE_INTERVAL; 633 } 634 } else { 635 /* It is tp->rcv_tstamp + keepalive_time_when(tp) */ 636 elapsed = keepalive_time_when(tp) - elapsed; 637 } 638 639 sk_mem_reclaim(sk); 640 641 resched: 642 inet_csk_reset_keepalive_timer (sk, elapsed); 643 goto out; 644 645 death: 646 tcp_done(sk); 647 648 out: 649 bh_unlock_sock(sk); 650 sock_put(sk); 651 } 652 653 void tcp_init_xmit_timers(struct sock *sk) 654 { 655 inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer, 656 &tcp_keepalive_timer); 657 } 658