![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /* timer.c */
2 /*
3 Copyright (C) 1992 Ross Biro
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 1, or (at your option)
8 any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
19 The Author may be reached as bir7@leland.stanford.edu or
20 C/O Department of Mathematics; Stanford University; Stanford, CA 94305
21 */
22
23 /* $Id: timer.c,v 0.8.4.5 1992/12/12 19:25:04 bir7 Exp $ */
24 /* $Log: timer.c,v $
25 * Revision 0.8.4.5 1992/12/12 19:25:04 bir7
26 * cleaned up Log messages.
27 *
28 * Revision 0.8.4.4 1992/12/12 01:50:49 bir7
29 * Fixed timeouts.
30 *
31 * Revision 0.8.4.3 1992/12/06 23:29:59 bir7
32 * Fixed bugs in timeout.
33 *
34 * Revision 0.8.4.2 1992/11/10 10:38:48 bir7
35 * Change free_s to kfree_s and accidently changed free_skb to kfree_skb.
36 *
37 * Revision 0.8.4.1 1992/11/10 00:17:18 bir7
38 * version change only.
39 *
40 * Revision 0.8.3.2 1992/11/10 00:14:47 bir7
41 * Changed malloc to kmalloc and added Id and Log
42 * */
43
44 #include <linux/types.h>
45 #include <linux/errno.h>
46 #include <linux/socket.h>
47 #include <netinet/in.h>
48 #include <linux/kernel.h>
49 #include <linux/sched.h>
50 #include <linux/timer.h>
51 #include <asm/system.h>
52 #include "timer.h"
53 #include "ip.h"
54 #include "tcp.h"
55 #include "sock.h"
56 #include "arp.h"
57
58 #undef TIMER_DEBUG
59
60 #ifdef PRINTK
61 #undef PRINTK
62 #endif
63
64
65 #ifdef TIMER_DEBUG
66 #define PRINTK printk
67 #else
68 #define PRINTK dummy_routine
69 #endif
70
71 static struct timer *timer_base=NULL;
72 unsigned long seq_offset;
73
74 void
75 delete_timer (struct timer *t)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
76 {
77 struct timer *tm;
78 PRINTK ("delete_timer (t=%X)\n",t);
79 if (timer_base == NULL || t == NULL) return;
80 cli();
81 if (t == timer_base)
82 {
83 timer_base = t->next;
84 if (timer_base != NULL)
85 {
86 timer_table[NET_TIMER].expires = timer_base->when;
87 timer_active |= 1 << NET_TIMER;
88 }
89 else
90 {
91 timer_active &= ~(1 << NET_TIMER);
92 }
93 sti();
94 return;
95 }
96 for (tm = timer_base;tm->next != NULL ;tm=tm->next)
97 {
98 if (tm->next == t)
99 {
100 tm->next = t->next;
101 sti();
102 return;
103 }
104 }
105 sti();
106 }
107
108
109 void
110 reset_timer (struct timer *t)
/* ![[previous]](../icons/left.png)
*/
111 {
112 struct timer *tm;
113
114 delete_timer (t);
115 t->when = timer_seq + t->len;
116 PRINTK ("reset_timer (t=%X) when = %d jiffies = %d\n",t, t->when, jiffies);
117 if (t == NULL)
118 {
119 printk ("*** reset timer NULL timer\n");
120 __asm__ ("\t int $3\n"::);
121 }
122 /* first see if it goes at the beginning. */
123 cli();
124 if (timer_base == NULL)
125 {
126 t->next = NULL;
127 timer_base = t;
128 timer_table[NET_TIMER].expires = t->when;
129 timer_active |= 1 << NET_TIMER;
130 sti();
131 return;
132 }
133 if (before (t->when, timer_base->when))
134 {
135 t->next = timer_base;
136 timer_base = t;
137 timer_table[NET_TIMER].expires = t->when;
138 timer_active |= 1 << NET_TIMER;
139 sti();
140 return;
141 }
142 for (tm = timer_base; ; tm=tm->next)
143 {
144 if (tm->next == NULL || before (t->when,tm->next->when))
145 {
146 t->next = tm->next;
147 tm->next = t;
148 sti();
149 return;
150 }
151 }
152 }
153
154 void
155 net_timer (void)
/* ![[last]](../icons/n_last.png)
*/
156 {
157 volatile struct sock *sk;
158
159 /* now we will only be called whenever we need to do something, but
160 we must be sure to process all of the sockets that need it. */
161
162 while (timer_base != NULL && after (timer_seq+1 ,timer_base->when))
163 {
164 int why;
165 sk = timer_base->sk;
166 cli();
167 if (sk->inuse)
168 {
169 sti();
170 break;
171 }
172 sk->inuse = 1;
173 sti();
174 why = sk->timeout;
175
176 PRINTK ("net_timer: found sk=%X why = %d\n",sk, why);
177
178 if (sk->keepopen)
179 {
180 sk->time_wait.len = TCP_TIMEOUT_LEN;
181 sk->timeout = TIME_KEEPOPEN;
182 reset_timer (timer_base);
183 }
184 else
185 {
186 sk->timeout = 0;
187 delete_timer(timer_base);
188 }
189
190 /* always see if we need to send an ack. */
191 if (sk->ack_backlog)
192 {
193 sk->prot->read_wakeup(sk);
194 if (!sk->dead) wake_up (sk->sleep);
195 }
196
197 /* now we need to figure out why the socket was on the timer. */
198 switch (why)
199 {
200
201 case TIME_DONE:
202 if (!sk->dead || sk->state != TCP_CLOSE)
203 {
204 printk ("non dead socket in time_done\n");
205 release_sock (sk);
206 break;
207 }
208 destroy_sock (sk);
209 break;
210
211 case TIME_DESTROY: /* we've waited for a while for all
212 the memory assosiated with the
213 socket to be freed. We need to
214 print an error message. */
215 PRINTK ("possible memory leak. sk = %X\n", sk);
216 print_sk (sk);
217 reset_timer ((struct timer *)&sk->time_wait);
218 sk->inuse = 0;
219 break;
220
221 case TIME_CLOSE: /* we've waited long enough, close the
222 socket. */
223
224 sk->state = TCP_CLOSE;
225 delete_timer ((struct timer *)&sk->time_wait);
226 /* kill the arp entry
227 in case the hardware has changed. */
228 arp_destroy (sk->daddr);
229 if (!sk->dead)
230 wake_up (sk->sleep);
231 release_sock(sk);
232 break;
233
234 case TIME_WRITE: /* try to retransmit. */
235 if (sk->send_head != NULL)
236 {
237 PRINTK ("retransmitting.\n");
238 sk->prot->retransmit (sk, 0);
239
240 if (sk->retransmits > TCP_RETR1)
241 {
242 PRINTK ("timer.c TIME_WRITE time-out 1\n");
243 arp_destroy (sk->daddr);
244 ip_route_check (sk->daddr);
245 }
246
247 if (sk->retransmits > TCP_RETR2)
248 {
249 PRINTK ("timer.c TIME_WRITE time-out 2\n");
250 sk->err = ETIMEDOUT;
251 if (sk->state == TCP_FIN_WAIT1 ||
252 sk->state == TCP_FIN_WAIT2 ||
253 sk->state == TCP_LAST_ACK)
254 {
255 sk->state = TCP_TIME_WAIT;
256 sk->timeout = TIME_CLOSE;
257 sk->time_wait.len = TCP_TIMEWAIT_LEN;
258 reset_timer ((struct timer *)&sk->time_wait);
259 release_sock(sk);
260 break;
261 }
262 else /* sk->state == ... */
263 {
264 sk->prot->close (sk,1);
265 break;
266 }
267 }
268 release_sock (sk);
269 break;
270 }
271
272 /* if we have stuff which hasn't been written because the
273 window is too small, fall throught to TIME_KEEPOPEN */
274 if (sk->wfront == NULL && sk->send_tmp == NULL)
275 {
276 release_sock (sk);
277 break;
278 }
279
280 /* this basically assumes tcp here. */
281 /* exponential fall back. */
282 /* The rtt should quickly get back to normal once
283 we start sending packets again. */
284
285 sk->rtt *= 2;
286 sk->time_wait.len = sk->rtt;
287 sk->timeout = TIME_WRITE;
288 if (sk->prot->write_wakeup != NULL)
289 sk->prot->write_wakeup(sk);
290
291 reset_timer ((struct timer *)&sk->time_wait);
292 release_sock (sk);
293 break;
294
295 case TIME_KEEPOPEN: /* send something to keep the
296 connection open. */
297
298 if (sk->prot->write_wakeup != NULL)
299 sk->prot->write_wakeup(sk);
300 sk->retransmits ++;
301 if (sk->retransmits > TCP_RETR1)
302 {
303 PRINTK ("timer.c TIME_KEEPOPEN time-out 1\n");
304 arp_destroy (sk->daddr);
305 ip_route_check (sk->daddr);
306 release_sock (sk);
307 break;
308 }
309 if (sk->retransmits > TCP_RETR2)
310 {
311 PRINTK ("timer.c TIME_KEEPOPEN time-out 2\n");
312 arp_destroy (sk->daddr);
313 sk->err = ETIMEDOUT;
314 if (sk->state == TCP_FIN_WAIT1 ||
315 sk->state == TCP_FIN_WAIT2)
316 {
317 sk->state = TCP_TIME_WAIT;
318 if (!sk->dead)
319 wake_up (sk->sleep);
320 release_sock(sk);
321 }
322 else /* sk->state == */
323 {
324 sk->prot->close (sk, 1);
325 }
326 break;
327 }
328 release_sock (sk);
329 break;
330
331 default:
332 release_sock(sk);
333 break;
334 } /* switch */
335 } /* while (timer_base != ... */
336
337 /* Now we need to reset the timer. */
338 if (timer_base != NULL)
339 {
340 timer_table[NET_TIMER].expires = timer_base->when;
341 timer_active |= 1 << NET_TIMER;
342 }
343 }
344
345
![[bottom]](../icons/n_bottom.png){kind=icon}
*/