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/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 }