tcp_timer.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: tcp_timer.c,v 1.82.4.1 2008/11/14 03:02:25 snj Exp $   */
    2 
    3 /*
    4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the project nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  */
   31 
   32 /*-
   33  * Copyright (c) 1997, 1998, 2001, 2005 The NetBSD Foundation, Inc.
   34  * All rights reserved.
   35  *
   36  * This code is derived from software contributed to The NetBSD Foundation
   37  * by Jason R. Thorpe and Kevin M. Lahey of the Numerical Aerospace Simulation
   38  * Facility, NASA Ames Research Center.
   39  * This code is derived from software contributed to The NetBSD Foundation
   40  * by Charles M. Hannum.
   41  *
   42  * Redistribution and use in source and binary forms, with or without
   43  * modification, are permitted provided that the following conditions
   44  * are met:
   45  * 1. Redistributions of source code must retain the above copyright
   46  *    notice, this list of conditions and the following disclaimer.
   47  * 2. Redistributions in binary form must reproduce the above copyright
   48  *    notice, this list of conditions and the following disclaimer in the
   49  *    documentation and/or other materials provided with the distribution.
   50  *
   51  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   52  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   53  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   54  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   55  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   56  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   57  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   58  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   59  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   60  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   61  * POSSIBILITY OF SUCH DAMAGE.
   62  */
   63 
   64 /*
   65  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
   66  *      The Regents of the University of California.  All rights reserved.
   67  *
   68  * Redistribution and use in source and binary forms, with or without
   69  * modification, are permitted provided that the following conditions
   70  * are met:
   71  * 1. Redistributions of source code must retain the above copyright
   72  *    notice, this list of conditions and the following disclaimer.
   73  * 2. Redistributions in binary form must reproduce the above copyright
   74  *    notice, this list of conditions and the following disclaimer in the
   75  *    documentation and/or other materials provided with the distribution.
   76  * 3. Neither the name of the University nor the names of its contributors
   77  *    may be used to endorse or promote products derived from this software
   78  *    without specific prior written permission.
   79  *
   80  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   81  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   82  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   83  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   84  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   85  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   86  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   87  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   88  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   89  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   90  * SUCH DAMAGE.
   91  *
   92  *      @(#)tcp_timer.c 8.2 (Berkeley) 5/24/95
   93  */
   94 
   95 #include <sys/cdefs.h>
   96 __KERNEL_RCSID(0, "$NetBSD: tcp_timer.c,v 1.82.4.1 2008/11/14 03:02:25 snj Exp $");
   97 
   98 #include "opt_inet.h"
   99 #include "opt_tcp_debug.h"
  100 
  101 #include <sys/param.h>
  102 #include <sys/systm.h>
  103 #include <sys/malloc.h>
  104 #include <sys/mbuf.h>
  105 #include <sys/socket.h>
  106 #include <sys/socketvar.h>
  107 #include <sys/protosw.h>
  108 #include <sys/errno.h>
  109 #include <sys/kernel.h>
  110 
  111 #include <net/if.h>
  112 #include <net/route.h>
  113 
  114 #include <netinet/in.h>
  115 #include <netinet/in_systm.h>
  116 #include <netinet/ip.h>
  117 #include <netinet/in_pcb.h>
  118 #include <netinet/ip_var.h>
  119 #include <netinet/ip_icmp.h>
  120 
  121 #ifdef INET6
  122 #ifndef INET
  123 #include <netinet/in.h>
  124 #endif
  125 #include <netinet/ip6.h>
  126 #include <netinet6/in6_pcb.h>
  127 #endif
  128 
  129 #include <netinet/tcp.h>
  130 #include <netinet/tcp_fsm.h>
  131 #include <netinet/tcp_seq.h>
  132 #include <netinet/tcp_timer.h>
  133 #include <netinet/tcp_var.h>
  134 #include <netinet/tcp_private.h>
  135 #include <netinet/tcp_congctl.h>
  136 #include <netinet/tcpip.h>
  137 #ifdef TCP_DEBUG
  138 #include <netinet/tcp_debug.h>
  139 #endif
  140 
  141 /*
  142  * Various tunable timer parameters.  These are initialized in tcp_init(),
  143  * unless they are patched.
  144  */
  145 u_int   tcp_keepinit = 0;
  146 u_int   tcp_keepidle = 0;
  147 u_int   tcp_keepintvl = 0;
  148 u_int   tcp_keepcnt = 0;                /* max idle probes */
  149 
  150 int     tcp_maxpersistidle = 0;         /* max idle time in persist */
  151 
  152 /*
  153  * Time to delay the ACK.  This is initialized in tcp_init(), unless
  154  * its patched.
  155  */
  156 int     tcp_delack_ticks = 0;
  157 
  158 void    tcp_timer_rexmt(void *);
  159 void    tcp_timer_persist(void *);
  160 void    tcp_timer_keep(void *);
  161 void    tcp_timer_2msl(void *);
  162 
  163 const tcp_timer_func_t tcp_timer_funcs[TCPT_NTIMERS] = {
  164         tcp_timer_rexmt,
  165         tcp_timer_persist,
  166         tcp_timer_keep,
  167         tcp_timer_2msl,
  168 };
  169 
  170 /*
  171  * Timer state initialization, called from tcp_init().
  172  */
  173 void
  174 tcp_timer_init(void)
  175 {
  176 
  177         if (tcp_keepinit == 0)
  178                 tcp_keepinit = TCPTV_KEEP_INIT;
  179 
  180         if (tcp_keepidle == 0)
  181                 tcp_keepidle = TCPTV_KEEP_IDLE;
  182 
  183         if (tcp_keepintvl == 0)
  184                 tcp_keepintvl = TCPTV_KEEPINTVL;
  185 
  186         if (tcp_keepcnt == 0)
  187                 tcp_keepcnt = TCPTV_KEEPCNT;
  188 
  189         if (tcp_maxpersistidle == 0)
  190                 tcp_maxpersistidle = TCPTV_KEEP_IDLE;
  191 
  192         if (tcp_delack_ticks == 0)
  193                 tcp_delack_ticks = TCP_DELACK_TICKS;
  194 }
  195 
  196 /*
  197  * Callout to process delayed ACKs for a TCPCB.
  198  */
  199 void
  200 tcp_delack(void *arg)
  201 {
  202         struct tcpcb *tp = arg;
  203 
  204         /*
  205          * If tcp_output() wasn't able to transmit the ACK
  206          * for whatever reason, it will restart the delayed
  207          * ACK callout.
  208          */
  209 
  210         mutex_enter(softnet_lock);
  211         if ((tp->t_flags & (TF_DEAD | TF_DELACK)) != TF_DELACK) {
  212                 mutex_exit(softnet_lock);
  213                 return;
  214         }
  215         if (!callout_expired(&tp->t_delack_ch)) {
  216                 mutex_exit(softnet_lock);
  217                 return;
  218         }
  219 
  220         tp->t_flags |= TF_ACKNOW;
  221         KERNEL_LOCK(1, NULL);
  222         (void) tcp_output(tp);
  223         KERNEL_UNLOCK_ONE(NULL);
  224         mutex_exit(softnet_lock);
  225 }
  226 
  227 /*
  228  * Tcp protocol timeout routine called every 500 ms.
  229  * Updates the timers in all active tcb's and
  230  * causes finite state machine actions if timers expire.
  231  */
  232 void
  233 tcp_slowtimo(void)
  234 {
  235 
  236         mutex_enter(softnet_lock);
  237         tcp_iss_seq += TCP_ISSINCR;                     /* increment iss */
  238         tcp_now++;                                      /* for timestamps */
  239         mutex_exit(softnet_lock);
  240 }
  241 
  242 /*
  243  * Cancel all timers for TCP tp.
  244  */
  245 void
  246 tcp_canceltimers(struct tcpcb *tp)
  247 {
  248         int i;
  249 
  250         for (i = 0; i < TCPT_NTIMERS; i++)
  251                 TCP_TIMER_DISARM(tp, i);
  252 }
  253 
  254 const int       tcp_backoff[TCP_MAXRXTSHIFT + 1] =
  255     { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
  256 
  257 const int       tcp_totbackoff = 511;   /* sum of tcp_backoff[] */
  258 
  259 /*
  260  * TCP timer processing.
  261  */
  262 
  263 void
  264 tcp_timer_rexmt(void *arg)
  265 {
  266         struct tcpcb *tp = arg;
  267         uint32_t rto;
  268 #ifdef TCP_DEBUG
  269         struct socket *so = NULL;
  270         short ostate;
  271 #endif
  272 
  273         mutex_enter(softnet_lock);
  274         if ((tp->t_flags & TF_DEAD) != 0) {
  275                 mutex_exit(softnet_lock);
  276                 return;
  277         }
  278         if (!callout_expired(&tp->t_timer[TCPT_REXMT])) {
  279                 mutex_exit(softnet_lock);
  280                 return;
  281         }
  282                 
  283         KERNEL_LOCK(1, NULL);
  284         if ((tp->t_flags & TF_PMTUD_PEND) && tp->t_inpcb &&
  285             SEQ_GEQ(tp->t_pmtud_th_seq, tp->snd_una) &&
  286             SEQ_LT(tp->t_pmtud_th_seq, (int)(tp->snd_una + tp->t_ourmss))) {
  287                 extern struct sockaddr_in icmpsrc;
  288                 struct icmp icmp;
  289 
  290                 tp->t_flags &= ~TF_PMTUD_PEND;
  291 
  292                 /* XXX create fake icmp message with relevant entries */
  293                 icmp.icmp_nextmtu = tp->t_pmtud_nextmtu;
  294                 icmp.icmp_ip.ip_len = tp->t_pmtud_ip_len;
  295                 icmp.icmp_ip.ip_hl = tp->t_pmtud_ip_hl;
  296                 icmpsrc.sin_addr = tp->t_inpcb->inp_faddr;
  297                 icmp_mtudisc(&icmp, icmpsrc.sin_addr);
  298 
  299                 /*
  300                  * Notify all connections to the same peer about
  301                  * new mss and trigger retransmit.
  302                  */
  303                 in_pcbnotifyall(&tcbtable, icmpsrc.sin_addr, EMSGSIZE,
  304                     tcp_mtudisc);
  305                 KERNEL_UNLOCK_ONE(NULL);
  306                 mutex_exit(softnet_lock);
  307                 return;
  308         }
  309 #ifdef TCP_DEBUG
  310 #ifdef INET
  311         if (tp->t_inpcb)
  312                 so = tp->t_inpcb->inp_socket;
  313 #endif
  314 #ifdef INET6
  315         if (tp->t_in6pcb)
  316                 so = tp->t_in6pcb->in6p_socket;
  317 #endif
  318         ostate = tp->t_state;
  319 #endif /* TCP_DEBUG */
  320 
  321         /*
  322          * Clear the SACK scoreboard, reset FACK estimate.
  323          */
  324         tcp_free_sackholes(tp);
  325         tp->snd_fack = tp->snd_una;
  326 
  327         /*
  328          * Retransmission timer went off.  Message has not
  329          * been acked within retransmit interval.  Back off
  330          * to a longer retransmit interval and retransmit one segment.
  331          */
  332 
  333         if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
  334                 tp->t_rxtshift = TCP_MAXRXTSHIFT;
  335                 TCP_STATINC(TCP_STAT_TIMEOUTDROP);
  336                 tp = tcp_drop(tp, tp->t_softerror ?
  337                     tp->t_softerror : ETIMEDOUT);
  338                 goto out;
  339         }
  340         TCP_STATINC(TCP_STAT_REXMTTIMEO);
  341         rto = TCP_REXMTVAL(tp);
  342         if (rto < tp->t_rttmin)
  343                 rto = tp->t_rttmin;
  344         TCPT_RANGESET(tp->t_rxtcur, rto * tcp_backoff[tp->t_rxtshift],
  345             tp->t_rttmin, TCPTV_REXMTMAX);
  346         TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
  347 
  348         /*
  349          * If we are losing and we are trying path MTU discovery,
  350          * try turning it off.  This will avoid black holes in
  351          * the network which suppress or fail to send "packet
  352          * too big" ICMP messages.  We should ideally do
  353          * lots more sophisticated searching to find the right
  354          * value here...
  355          */
  356         if (tp->t_mtudisc && tp->t_rxtshift > TCP_MAXRXTSHIFT / 6) {
  357                 TCP_STATINC(TCP_STAT_PMTUBLACKHOLE);
  358 
  359 #ifdef INET
  360                 /* try turning PMTUD off */
  361                 if (tp->t_inpcb)
  362                         tp->t_mtudisc = 0;
  363 #endif
  364 #ifdef INET6
  365                 /* try using IPv6 minimum MTU */
  366                 if (tp->t_in6pcb)
  367                         tp->t_mtudisc = 0;
  368 #endif
  369 
  370                 /* XXX: more sophisticated Black hole recovery code? */
  371         }
  372 
  373         /*
  374          * If losing, let the lower level know and try for
  375          * a better route.  Also, if we backed off this far,
  376          * our srtt estimate is probably bogus.  Clobber it
  377          * so we'll take the next rtt measurement as our srtt;
  378          * move the current srtt into rttvar to keep the current
  379          * retransmit times until then.
  380          */
  381         if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
  382 #ifdef INET
  383                 if (tp->t_inpcb)
  384                         in_losing(tp->t_inpcb);
  385 #endif
  386 #ifdef INET6
  387                 if (tp->t_in6pcb)
  388                         in6_losing(tp->t_in6pcb);
  389 #endif
  390                 tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
  391                 tp->t_srtt = 0;
  392         }
  393         tp->snd_nxt = tp->snd_una;
  394         tp->snd_high = tp->snd_max;
  395         /*
  396          * If timing a segment in this window, stop the timer.
  397          */
  398         tp->t_rtttime = 0;
  399         /*
  400          * Remember if we are retransmitting a SYN, because if
  401          * we do, set the initial congestion window must be set
  402          * to 1 segment.
  403          */
  404         if (tp->t_state == TCPS_SYN_SENT)
  405                 tp->t_flags |= TF_SYN_REXMT;
  406 
  407         /*
  408          * Adjust congestion control parameters.
  409          */
  410         tp->t_congctl->slow_retransmit(tp);
  411 
  412         (void) tcp_output(tp);
  413 
  414  out:
  415 #ifdef TCP_DEBUG
  416         if (tp && so->so_options & SO_DEBUG)
  417                 tcp_trace(TA_USER, ostate, tp, NULL,
  418                     PRU_SLOWTIMO | (TCPT_REXMT << 8));
  419 #endif
  420         KERNEL_UNLOCK_ONE(NULL);
  421         mutex_exit(softnet_lock);
  422 }
  423 
  424 void
  425 tcp_timer_persist(void *arg)
  426 {
  427         struct tcpcb *tp = arg;
  428         uint32_t rto;
  429 #ifdef TCP_DEBUG
  430         struct socket *so = NULL;
  431         short ostate;
  432 #endif
  433 
  434         mutex_enter(softnet_lock);
  435         if ((tp->t_flags & TF_DEAD) != 0) {
  436                 mutex_exit(softnet_lock);
  437                 return;
  438         }
  439         if (!callout_expired(&tp->t_timer[TCPT_PERSIST])) {
  440                 mutex_exit(softnet_lock);
  441                 return;
  442         }
  443 
  444         KERNEL_LOCK(1, NULL);
  445 #ifdef TCP_DEBUG
  446 #ifdef INET
  447         if (tp->t_inpcb)
  448                 so = tp->t_inpcb->inp_socket;
  449 #endif
  450 #ifdef INET6
  451         if (tp->t_in6pcb)
  452                 so = tp->t_in6pcb->in6p_socket;
  453 #endif
  454 
  455         ostate = tp->t_state;
  456 #endif /* TCP_DEBUG */
  457 
  458         /*
  459          * Persistance timer into zero window.
  460          * Force a byte to be output, if possible.
  461          */
  462 
  463         /*
  464          * Hack: if the peer is dead/unreachable, we do not
  465          * time out if the window is closed.  After a full
  466          * backoff, drop the connection if the idle time
  467          * (no responses to probes) reaches the maximum
  468          * backoff that we would use if retransmitting.
  469          */
  470         rto = TCP_REXMTVAL(tp);
  471         if (rto < tp->t_rttmin)
  472                 rto = tp->t_rttmin;
  473         if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
  474             ((tcp_now - tp->t_rcvtime) >= tcp_maxpersistidle ||
  475             (tcp_now - tp->t_rcvtime) >= rto * tcp_totbackoff)) {
  476                 TCP_STATINC(TCP_STAT_PERSISTDROPS);
  477                 tp = tcp_drop(tp, ETIMEDOUT);
  478                 goto out;
  479         }
  480         TCP_STATINC(TCP_STAT_PERSISTTIMEO);
  481         tcp_setpersist(tp);
  482         tp->t_force = 1;
  483         (void) tcp_output(tp);
  484         tp->t_force = 0;
  485 
  486  out:
  487 #ifdef TCP_DEBUG
  488         if (tp && so->so_options & SO_DEBUG)
  489                 tcp_trace(TA_USER, ostate, tp, NULL,
  490                     PRU_SLOWTIMO | (TCPT_PERSIST << 8));
  491 #endif
  492         KERNEL_UNLOCK_ONE(NULL);
  493         mutex_exit(softnet_lock);
  494 }
  495 
  496 void
  497 tcp_timer_keep(void *arg)
  498 {
  499         struct tcpcb *tp = arg;
  500         struct socket *so = NULL;       /* Quell compiler warning */
  501 #ifdef TCP_DEBUG
  502         short ostate;
  503 #endif
  504 
  505         mutex_enter(softnet_lock);
  506         if ((tp->t_flags & TF_DEAD) != 0) {
  507                 mutex_exit(softnet_lock);
  508                 return;
  509         }
  510         if (!callout_expired(&tp->t_timer[TCPT_KEEP])) {
  511                 mutex_exit(softnet_lock);
  512                 return;
  513         }
  514 
  515         KERNEL_LOCK(1, NULL);
  516 
  517 #ifdef TCP_DEBUG
  518         ostate = tp->t_state;
  519 #endif /* TCP_DEBUG */
  520 
  521         /*
  522          * Keep-alive timer went off; send something
  523          * or drop connection if idle for too long.
  524          */
  525 
  526         TCP_STATINC(TCP_STAT_KEEPTIMEO);
  527         if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
  528                 goto dropit;
  529 #ifdef INET
  530         if (tp->t_inpcb)
  531                 so = tp->t_inpcb->inp_socket;
  532 #endif
  533 #ifdef INET6
  534         if (tp->t_in6pcb)
  535                 so = tp->t_in6pcb->in6p_socket;
  536 #endif
  537         KASSERT(so != NULL);
  538         if (so->so_options & SO_KEEPALIVE &&
  539             tp->t_state <= TCPS_CLOSE_WAIT) {
  540                 if ((tp->t_maxidle > 0) &&
  541                     ((tcp_now - tp->t_rcvtime) >=
  542                      tp->t_keepidle + tp->t_maxidle))
  543                         goto dropit;
  544                 /*
  545                  * Send a packet designed to force a response
  546                  * if the peer is up and reachable:
  547                  * either an ACK if the connection is still alive,
  548                  * or an RST if the peer has closed the connection
  549                  * due to timeout or reboot.
  550                  * Using sequence number tp->snd_una-1
  551                  * causes the transmitted zero-length segment
  552                  * to lie outside the receive window;
  553                  * by the protocol spec, this requires the
  554                  * correspondent TCP to respond.
  555                  */
  556                 TCP_STATINC(TCP_STAT_KEEPPROBE);
  557                 if (tcp_compat_42) {
  558                         /*
  559                          * The keepalive packet must have nonzero
  560                          * length to get a 4.2 host to respond.
  561                          */
  562                         (void)tcp_respond(tp, tp->t_template,
  563                             (struct mbuf *)NULL, NULL, tp->rcv_nxt - 1,
  564                             tp->snd_una - 1, 0);
  565                 } else {
  566                         (void)tcp_respond(tp, tp->t_template,
  567                             (struct mbuf *)NULL, NULL, tp->rcv_nxt,
  568                             tp->snd_una - 1, 0);
  569                 }
  570                 TCP_TIMER_ARM(tp, TCPT_KEEP, tp->t_keepintvl);
  571         } else
  572                 TCP_TIMER_ARM(tp, TCPT_KEEP, tp->t_keepidle);
  573 
  574 #ifdef TCP_DEBUG
  575         if (tp && so->so_options & SO_DEBUG)
  576                 tcp_trace(TA_USER, ostate, tp, NULL,
  577                     PRU_SLOWTIMO | (TCPT_KEEP << 8));
  578 #endif
  579         KERNEL_UNLOCK_ONE(NULL);
  580         mutex_exit(softnet_lock);
  581         return;
  582 
  583  dropit:
  584         TCP_STATINC(TCP_STAT_KEEPDROPS);
  585         (void) tcp_drop(tp, ETIMEDOUT);
  586         KERNEL_UNLOCK_ONE(NULL);
  587         mutex_exit(softnet_lock);
  588 }
  589 
  590 void
  591 tcp_timer_2msl(void *arg)
  592 {
  593         struct tcpcb *tp = arg;
  594 #ifdef TCP_DEBUG
  595         struct socket *so = NULL;
  596         short ostate;
  597 #endif
  598 
  599         mutex_enter(softnet_lock);
  600         if ((tp->t_flags & TF_DEAD) != 0) {
  601                 mutex_exit(softnet_lock);
  602                 return;
  603         }
  604         if (!callout_expired(&tp->t_timer[TCPT_2MSL])) {
  605                 mutex_exit(softnet_lock);
  606                 return;
  607         }
  608 
  609         /*
  610          * 2 MSL timeout went off, clear the SACK scoreboard, reset
  611          * the FACK estimate.
  612          */
  613         KERNEL_LOCK(1, NULL);
  614         tcp_free_sackholes(tp);
  615         tp->snd_fack = tp->snd_una;
  616 
  617 #ifdef TCP_DEBUG
  618 #ifdef INET
  619         if (tp->t_inpcb)
  620                 so = tp->t_inpcb->inp_socket;
  621 #endif
  622 #ifdef INET6
  623         if (tp->t_in6pcb)
  624                 so = tp->t_in6pcb->in6p_socket;
  625 #endif
  626 
  627         ostate = tp->t_state;
  628 #endif /* TCP_DEBUG */
  629 
  630         /*
  631          * 2 MSL timeout in shutdown went off.  If we're closed but
  632          * still waiting for peer to close and connection has been idle
  633          * too long, or if 2MSL time is up from TIME_WAIT, delete connection
  634          * control block.  Otherwise, check again in a bit.
  635          */
  636         if (tp->t_state != TCPS_TIME_WAIT &&
  637             ((tp->t_maxidle == 0) ||
  638             ((tcp_now - tp->t_rcvtime) <= tp->t_maxidle)))
  639             TCP_TIMER_ARM(tp, TCPT_2MSL, tp->t_keepintvl);
  640         else
  641                 tp = tcp_close(tp);
  642 
  643 #ifdef TCP_DEBUG
  644         if (tp && so->so_options & SO_DEBUG)
  645                 tcp_trace(TA_USER, ostate, tp, NULL,
  646                     PRU_SLOWTIMO | (TCPT_2MSL << 8));
  647 #endif
  648         mutex_exit(softnet_lock);
  649         KERNEL_UNLOCK_ONE(NULL);
  650 }
Cache object: df9f78e3267efcb4b4b3fcde4a557d95
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netinet/tcp_timer.c

FreeBSD/Linux Kernel Cross Reference
sys/netinet/tcp_timer.c
