timer.c

An implementation of the TCP/IP protocol suite for the LINUX operating system. INET is implemented u

  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  *              TIMER - implementation of software timers.
  7  *
  8  * Version:     @(#)timer.c     1.0.7   05/25/93
  9  *
 10  * Authors:     Ross Biro, <[e-mail]>
 11  *              Fred N. van Kempen, <[e-mail]>
 12  *              Corey Minyard <wf-rch![e-mail]>
 13  *              Fred Baumgarten, <[e-mail]>
 14  *              Florian La Roche, <[e-mail]>
 15  *
 16  * Fixes:
 17  *              Alan Cox        :       To avoid destroying a wait queue as we use it
 18  *                                      we defer destruction until the destroy timer goes
 19  *                                      off.
 20  *              Alan Cox        :       Destroy socket doesnt write a status value to the
 21  *                                      socket buffer _AFTER_ freeing it! Also sock ensures
 22  *                                      the socket will get removed BEFORE this is called
 23  *                                      otherwise if the timer TIME_DESTROY occurs inside
 24  *                                      of inet_bh() with this socket being handled it goes
 25  *                                      BOOM! Have to stop timer going off if inet_bh is
 26  *                                      active or the destroy causes crashes.
 27  *
 28  *              This program is free software; you can redistribute it and/or
 29  *              modify it under the terms of the GNU General Public License
 30  *              as published by the Free Software Foundation; either version
 31  *              2 of the License, or (at your option) any later version.
 32  */
 33 
 34 #include <linux/types.h>
 35 #include <linux/errno.h>
 36 #include <linux/socket.h>
 37 #include <linux/in.h>
 38 #include <linux/kernel.h>
 39 #include <linux/sched.h>
 40 #include <linux/timer.h>
 41 #include <asm/system.h>
 42 #include <linux/interrupt.h>
 43 #include "inet.h"
 44 #include "dev.h"
 45 #include "ip.h"
 46 #include "protocol.h"
 47 #include "tcp.h"
 48 #include "skbuff.h"
 49 #include "sock.h"
 50 #include "arp.h"
 51 
 52 void
 53 delete_timer (struct sock *t)
 54 {
 55   unsigned long flags;
 56 
 57   save_flags (flags);
 58   cli();
 59 
 60   t->timeout = 0;
 61   del_timer (&t->timer);
 62 
 63   restore_flags (flags);
 64 }
 65 
 66 void
 67 reset_timer (struct sock *t, int timeout, unsigned long len)
 68 {
 69   delete_timer (t);
 70 
 71   if (timeout != -1)
 72     t->timeout = timeout;
 73 
 74 #if 1
 75   /* FIXME: ??? */
 76   if ((int) len < 0)    /* prevent close to infinite timers. THEY _DO_ */
 77         len = 3;        /* happen (negative values ?) - don't ask me why ! -FB */
 78 #endif
 79   t->timer.expires = len;
 80   add_timer (&t->timer);
 81 }
 82 
 83 
 84 /*
 85  * Now we will only be called whenever we need to do
 86  * something, but we must be sure to process all of the
 87  * sockets that need it.
 88  */
 89 void
 90 net_timer (unsigned long data)
 91 {
 92   struct sock *sk = (struct sock*)data;
 93   int why = sk->timeout;
 94   /* timeout is overwritten by 'delete_timer' and 'reset_timer' */
 95 
 96   if (sk->inuse || in_inet_bh()) {
 97     sk->timer.expires = 10;
 98     add_timer(&sk->timer);
 99     return;
100   }
101   sk->inuse = 1;
102 
103   DPRINTF ((DBG_TMR, "net_timer: found sk=%X why = %d\n", sk, why));
104   if (sk->wfront && 
105       before(sk->window_seq, sk->wfront->h.seq) &&
106       sk->send_head == NULL &&
107       sk->ack_backlog == 0 &&
108       sk->state != TCP_TIME_WAIT)
109     reset_timer(sk, TIME_PROBE0, sk->rto);
110   else if (sk->keepopen)
111     reset_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
112 
113   /* Always see if we need to send an ack. */
114   if (sk->ack_backlog) {
115     sk->prot->read_wakeup (sk);
116     if (! sk->dead)
117       wake_up_interruptible (sk->sleep);
118   }
119 
120   /* Now we need to figure out why the socket was on the timer. */
121   switch (why) {
122     case TIME_DONE:
123         if (! sk->dead || sk->state != TCP_CLOSE) {
124           printk ("non dead socket in time_done\n");
125           release_sock (sk);
126           break;
127         }
128         destroy_sock (sk);
129         break;
130     case TIME_DESTROY:
131         /* We've waited for a while for all the memory associated with
132          * the socket to be freed.  We need to print an error message.
133          */
134         if(sk->wmem_alloc!=0 || sk->rmem_alloc!=0)
135         {
136                 DPRINTF ((DBG_TMR, "possible memory leak.  sk = %X\n", sk));
137                 sk->wmem_alloc++;       /* So it DOESNT go away */
138                 destroy_sock (sk);
139                 sk->wmem_alloc--;       /* Might now have hit 0 - fall through and do it again if so */
140                 sk->inuse = 0;  /* This will be ok, the destroy won't totally work */
141         }
142         if(sk->wmem_alloc==0 && sk->rmem_alloc==0)
143                 destroy_sock(sk);       /* Socket gone, DONT update sk->inuse! */
144         break;
145     case TIME_CLOSE:
146         /* We've waited long enough, close the socket. */
147         sk->state = TCP_CLOSE;
148         delete_timer (sk);
149         /* Kill the ARP entry in case the hardware has changed. */
150         arp_destroy_maybe (sk->daddr);
151         if (!sk->dead)
152           wake_up_interruptible (sk->sleep);
153         sk->shutdown = SHUTDOWN_MASK;
154         reset_timer (sk, TIME_DESTROY, TCP_DONE_TIME);
155         release_sock (sk);
156         break;
157     case TIME_PROBE0:
158         tcp_send_probe0(sk);
159         release_sock (sk);
160         break;
161     case TIME_WRITE:    /* try to retransmit. */
162         /* It could be we got here because we needed to send an ack.
163          * So we need to check for that.
164          */
165         if (sk->send_head) {
166           if (jiffies < (sk->send_head->when + sk->rto)) {
167             reset_timer (sk, TIME_WRITE, 
168                          (sk->send_head->when + sk->rto - jiffies));
169             release_sock (sk);
170             break;
171           }
172           /* printk("timer: seq %d retrans %d out %d cong %d\n", sk->send_head->h.seq,
173              sk->retransmits, sk->packets_out, sk->cong_window); */
174           DPRINTF ((DBG_TMR, "retransmitting.\n"));
175           sk->prot->retransmit (sk, 0);
176           if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
177             || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) {
178             DPRINTF ((DBG_TMR, "timer.c TIME_WRITE time-out 1\n"));
179             arp_destroy_maybe (sk->daddr);
180             ip_route_check (sk->daddr);
181           }
182           if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) {
183             DPRINTF ((DBG_TMR, "timer.c TIME_WRITE time-out 2\n"));
184             sk->err = ETIMEDOUT;
185             if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2
186               || sk->state == TCP_LAST_ACK) {
187               sk->state = TCP_TIME_WAIT;
188               reset_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
189             } else {
190               sk->prot->close (sk, 1);
191               break;
192             }
193           }
194         }
195         release_sock (sk);
196         break;
197     case TIME_KEEPOPEN:
198         /* Send something to keep the connection open. */
199         if (sk->prot->write_wakeup)
200           sk->prot->write_wakeup (sk);
201         sk->retransmits++;
202         if (sk->shutdown == SHUTDOWN_MASK) {
203           sk->prot->close (sk, 1);
204           sk->state = TCP_CLOSE;
205         }
206 
207         if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
208           || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) {
209           DPRINTF ((DBG_TMR, "timer.c TIME_KEEPOPEN time-out 1\n"));
210           arp_destroy_maybe (sk->daddr);
211           ip_route_check (sk->daddr);
212           release_sock (sk);
213           break;
214         }
215         if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) {
216           DPRINTF ((DBG_TMR, "timer.c TIME_KEEPOPEN time-out 2\n"));
217           arp_destroy_maybe (sk->daddr);
218           sk->err = ETIMEDOUT;
219           if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2) {
220             sk->state = TCP_TIME_WAIT;
221             if (!sk->dead)
222               wake_up_interruptible (sk->sleep);
223             release_sock (sk);
224           } else {
225             sk->prot->close (sk, 1);
226           }
227           break;
228         }
229         release_sock (sk);
230         break;
231     default:
232         printk ("net timer expired - reason unknown, sk=%08X\n", (int)sk);
233         release_sock (sk);
234         break;
235   }
236 }
237 
238