![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_timer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to tp_timer.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 root 1: /***********************************************************
2: Copyright IBM Corporation 1987
3:
4: All Rights Reserved
5:
6: Permission to use, copy, modify, and distribute this software and its
7: documentation for any purpose and without fee is hereby granted,
8: provided that the above copyright notice appear in all copies and that
9: both that copyright notice and this permission notice appear in
10: supporting documentation, and that the name of IBM not be
11: used in advertising or publicity pertaining to distribution of the
12: software without specific, written prior permission.
13:
14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
20: SOFTWARE.
21:
22: ******************************************************************/
23:
24: /*
25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
26: */
27: /*
28: * ARGO TP
29: *
30: * $Header: tp_timer.c,v 5.2 88/11/18 17:29:07 nhall Exp $
31: * $Source: /usr/argo/sys/netiso/RCS/tp_timer.c,v $
32: * @(#)tp_timer.c 7.3 (Berkeley) 8/29/89 *
33: *
34: * Contains all the timer code.
35: * There are two sources of calls to these routines:
36: * the clock, and tp.trans. (ok, and tp_pcb.c calls it at init time)
37: *
38: * Timers come in two flavors - those that generally get
39: * cancelled (tp_ctimeout, tp_cuntimeout)
40: * and those that either usually expire (tp_etimeout,
41: * tp_euntimeout, tp_slowtimo) or may require more than one instance
42: * of the timer active at a time.
43: *
44: * The C timers are stored in the tp_ref structure. Their "going off"
45: * is manifested by a driver event of the TM_xxx form.
46: *
47: * The E timers are handled like the generic kernel callouts.
48: * Their "going off" is manifested by a function call w/ 3 arguments.
49: */
50:
51: #ifndef lint
52: static char *rcsid = "$Header: tp_timer.c,v 5.2 88/11/18 17:29:07 nhall Exp $";
53: #endif lint
54:
55: #include "param.h"
56: #include "types.h"
57: #include "time.h"
58: #include "malloc.h"
59:
60: #include "tp_param.h"
61: #include "tp_timer.h"
62: #include "tp_stat.h"
63: #include "tp_pcb.h"
64: #include "tp_tpdu.h"
65: #include "argo_debug.h"
66: #include "tp_trace.h"
67: #include "tp_seq.h"
68:
69: static struct Ecallout *TP_callfree;
70: static struct Ecallout TP_callout[N_TPREF*2];
71:
72: extern int tp_maxrefopen; /* highest ref # of an open tp connection */
73:
74: /*
75: * CALLED FROM:
76: * at autoconfig time from tp_init()
77: * a combo of event, state, predicate
78: * FUNCTION and ARGUMENTS:
79: * initialize data structures for the timers
80: */
81: void
82: tp_timerinit()
83: {
84: register int i;
85: /*
86: * Initialize callouts
87: */
88: TP_callfree = TP_callout;
89: for (i = 1; i < N_TPREF*2; i++)
90: TP_callout[i-1].c_next = &TP_callout[i];
91:
92: bzero( (caddr_t)tp_ref, N_TPREF * sizeof(struct tp_ref) );
93:
94: /* hate to do this but we really don't want zero to be a legit ref */
95: tp_maxrefopen = 1;
96: tp_ref[0].tpr_state = REF_FROZEN; /* white lie -- no ref timer, don't
97: * want this one to be allocated- ever
98: * unless, of course, you make refs and address instead of an
99: * index - then 0 can be allocated
100: */
101:
102: }
103:
104: /********************** e timers *************************/
105:
106: /*
107: * CALLED FROM:
108: * tp_slowtimo() every 1/2 second, for each open reference
109: * FUNCTION and ARGUMENTS:
110: * (refp) indicates a reference structure that is in use.
111: * This ref structure may contain active E-type timers.
112: * Update the timers and if any expire, create an event and
113: * call the driver.
114: */
115: static void
116: tp_Eclock(refp)
117: struct tp_ref *refp; /* the reference structure */
118: {
119: register struct Ecallout *p1; /* to drift through the list of callouts */
120: struct tp_event E; /* event to pass to tp_driver() */
121: int tp_driver(); /* drives the FSM */
122:
123: /*
124: * Update real-time timeout queue.
125: * At front of queue are some number of events which are ``due''.
126: * The time to these is <= 0 and if negative represents the
127: * number of ticks which have passed since it was supposed to happen.
128: * The rest of the q elements (times > 0) are events yet to happen,
129: * where the time for each is given as a delta from the previous.
130: * Decrementing just the first of these serves to decrement the time
131: * to all events.
132: *
133: * This version, which calls the driver directly, doesn't pass
134: * along the ticks - may want to add the ticks if there's any use
135: * for them.
136: */
137: IncStat(ts_Eticks);
138: p1 = refp->tpr_calltodo.c_next;
139: while (p1) {
140: if (--p1->c_time > 0)
141: break;
142: if (p1->c_time == 0)
143: break;
144: p1 = p1->c_next;
145: }
146:
147: for (;;) {
148: struct tp_pcb *tpcb;
149: if ((p1 = refp->tpr_calltodo.c_next) == 0 || p1->c_time > 0) {
150: break;
151: }
152: refp->tpr_calltodo.c_next = p1->c_next;
153: p1->c_next = TP_callfree;
154:
155: #ifndef lint
156: E.ev_number = p1->c_func;
157: E.ATTR(TM_data_retrans).e_low = (SeqNum) p1->c_arg1;
158: E.ATTR(TM_data_retrans).e_high = (SeqNum) p1->c_arg2;
159: E.ATTR(TM_data_retrans).e_retrans = p1->c_arg3;
160: #endif lint
161: IFDEBUG(D_TIMER)
162: printf("E expired! event 0x%x (0x%x,0x%x), pcb 0x%x ref %d\n",
163: p1->c_func, p1->c_arg1, p1->c_arg2, refp->tpr_pcb,
164: refp-tp_ref);
165: ENDDEBUG
166:
167: TP_callfree = p1;
168: IncStat(ts_Eexpired);
169: (void) tp_driver( tpcb = refp->tpr_pcb, &E);
170: if (p1->c_func == TM_reference && tpcb->tp_state == TP_CLOSED)
171: free((caddr_t)tpcb, M_PCB); /* XXX wart; where else to do it? */
172: }
173: }
174:
175: /*
176: * CALLED FROM:
177: * tp.trans all over
178: * FUNCTION and ARGUMENTS:
179: * Set an E type timer. (refp) is the ref structure.
180: * Causes fun(arg1,arg2,arg3) to be called after time t.
181: */
182: void
183: tp_etimeout(refp, fun, arg1, arg2, arg3, ticks)
184: struct tp_ref *refp;
185: int fun; /* function to be called */
186: u_int arg1, arg2;
187: int arg3;
188: register int ticks;
189: {
190: register struct Ecallout *p1, *p2, *pnew;
191: /* p1 and p2 drift through the list of timeout callout structures,
192: * pnew points to the newly created callout structure
193: */
194:
195: IFDEBUG(D_TIMER)
196: printf("etimeout pcb 0x%x state 0x%x\n", refp->tpr_pcb,
197: refp->tpr_pcb->tp_state);
198: ENDDEBUG
199: IFTRACE(D_TIMER)
200: tptrace(TPPTmisc, "tp_etimeout ref refstate tks Etick", refp-tp_ref,
201: refp->tpr_state, ticks, tp_stat.ts_Eticks);
202: ENDTRACE
203:
204: IncStat(ts_Eset);
205: if (ticks == 0)
206: ticks = 1;
207: pnew = TP_callfree;
208: if (pnew == (struct Ecallout *)0)
209: panic("tp timeout table overflow");
210: TP_callfree = pnew->c_next;
211: pnew->c_arg1 = arg1;
212: pnew->c_arg2 = arg2;
213: pnew->c_arg3 = arg3;
214: pnew->c_func = fun;
215: for (p1 = &(refp->tpr_calltodo);
216: (p2 = p1->c_next) && p2->c_time < ticks; p1 = p2)
217: if (p2->c_time > 0)
218: ticks -= p2->c_time;
219: p1->c_next = pnew;
220: pnew->c_next = p2;
221: pnew->c_time = ticks;
222: if (p2)
223: p2->c_time -= ticks;
224: }
225:
226: /*
227: * CALLED FROM:
228: * tp.trans all over
229: * FUNCTION and ARGUMENTS:
230: * Cancel all occurrences of E-timer function (fun) for reference (refp)
231: */
232: void
233: tp_euntimeout(refp, fun)
234: struct tp_ref *refp;
235: int fun;
236: {
237: register struct Ecallout *p1, *p2; /* ptrs to drift through the list */
238:
239: IFTRACE(D_TIMER)
240: tptrace(TPPTmisc, "tp_euntimeout ref", refp-tp_ref, 0, 0, 0);
241: ENDTRACE
242:
243: p1 = &refp->tpr_calltodo;
244: while ( (p2 = p1->c_next) != 0) {
245: if (p2->c_func == fun) {
246: if (p2->c_next && p2->c_time > 0)
247: p2->c_next->c_time += p2->c_time;
248: p1->c_next = p2->c_next;
249: p2->c_next = TP_callfree;
250: TP_callfree = p2;
251: IncStat(ts_Ecan_act);
252: continue;
253: }
254: p1 = p2;
255: }
256: }
257:
258: /*
259: * CALLED FROM:
260: * tp.trans, when an incoming ACK causes things to be dropped
261: * from the retransmission queue, and we want their associated
262: * timers to be cancelled.
263: * FUNCTION and ARGUMENTS:
264: * cancel all occurrences of function (fun) where (arg2) < (seq)
265: */
266: void
267: tp_euntimeout_lss(refp, fun, seq)
268: struct tp_ref *refp;
269: int fun;
270: SeqNum seq;
271: {
272: register struct Ecallout *p1, *p2;
273:
274: IFTRACE(D_TIMER)
275: tptrace(TPPTmisc, "tp_euntimeoutLSS ref", refp-tp_ref, seq, 0, 0);
276: ENDTRACE
277:
278: p1 = &refp->tpr_calltodo;
279: while ( (p2 = p1->c_next) != 0) {
280: if ((p2->c_func == fun) && SEQ_LT(refp->tpr_pcb, p2->c_arg2, seq)) {
281: if (p2->c_next && p2->c_time > 0)
282: p2->c_next->c_time += p2->c_time;
283: p1->c_next = p2->c_next;
284: p2->c_next = TP_callfree;
285: TP_callfree = p2;
286: IncStat(ts_Ecan_act);
287: continue;
288: }
289: p1 = p2;
290: }
291: }
292:
293: /**************** c timers **********************
294: *
295: * These are not chained together; they sit
296: * in the tp_ref structure. they are the kind that
297: * are typically cancelled so it's faster not to
298: * mess with the chains
299: */
300:
301: /*
302: * CALLED FROM:
303: * the clock, every 500 ms
304: * FUNCTION and ARGUMENTS:
305: * Look for open references with active timers.
306: * If they exist, call the appropriate timer routines to update
307: * the timers and possibly generate events.
308: * (The E timers are done in other procedures; the C timers are
309: * updated here, and events for them are generated here.)
310: */
311: ProtoHook
312: tp_slowtimo()
313: {
314: register int r,t;
315: struct Ccallout *cp;
316: struct tp_ref *rp = tp_ref;
317: struct tp_event E;
318: int s = splnet();
319:
320: /* check only open reference structures */
321: IncStat(ts_Cticks);
322: rp++; /* tp_ref[0] is never used */
323: for( r=1 ; (r <= tp_maxrefopen) ; r++,rp++ ) {
324: if (rp->tpr_state < REF_OPEN)
325: continue;
326:
327: /* check the C-type timers */
328: cp = rp->tpr_callout;
329: for (t=0 ; t < N_CTIMERS; t++,cp++) {
330: if( cp->c_active ) {
331: if( --cp->c_time <= 0 ) {
332: cp->c_active = FALSE;
333: E.ev_number = t;
334: IFDEBUG(D_TIMER)
335: printf("C expired! type 0x%x\n", t);
336: ENDDEBUG
337: IncStat(ts_Cexpired);
338: tp_driver( rp->tpr_pcb, &E);
339: }
340: }
341: }
342: /* now update the list */
343: tp_Eclock(rp);
344: }
345: splx(s);
346: return 0;
347: }
348:
349: /*
350: * CALLED FROM:
351: * tp.trans, tp_emit()
352: * FUNCTION and ARGUMENTS:
353: * Set a C type timer of type (which) to go off after (ticks) time.
354: */
355: void
356: tp_ctimeout(refp, which, ticks)
357: register struct tp_ref *refp;
358: int which, ticks;
359: {
360: register struct Ccallout *cp = &(refp->tpr_callout[which]);
361:
362: IFTRACE(D_TIMER)
363: tptrace(TPPTmisc, "tp_ctimeout ref which tpcb active",
364: (int)(refp - tp_ref), which, refp->tpr_pcb, cp->c_active);
365: ENDTRACE
366: if(cp->c_active)
367: IncStat(ts_Ccan_act);
368: IncStat(ts_Cset);
369: cp->c_time = ticks;
370: cp->c_active = TRUE;
371: }
372:
373: /*
374: * CALLED FROM:
375: * tp.trans
376: * FUNCTION and ARGUMENTS:
377: * Version of tp_ctimeout that resets the C-type time if the
378: * parameter (ticks) is > the current value of the timer.
379: */
380: void
381: tp_ctimeout_MIN(refp, which, ticks)
382: register struct tp_ref *refp;
383: int which, ticks;
384: {
385: register struct Ccallout *cp = &(refp->tpr_callout[which]);
386:
387: IFTRACE(D_TIMER)
388: tptrace(TPPTmisc, "tp_ctimeout_MIN ref which tpcb active",
389: (int)(refp - tp_ref), which, refp->tpr_pcb, cp->c_active);
390: ENDTRACE
391: if(cp->c_active)
392: IncStat(ts_Ccan_act);
393: IncStat(ts_Cset);
394: if( cp->c_active )
395: cp->c_time = MIN(ticks, cp->c_time);
396: else {
397: cp->c_time = ticks;
398: cp->c_active = TRUE;
399: }
400: }
401:
402: /*
403: * CALLED FROM:
404: * tp.trans
405: * FUNCTION and ARGUMENTS:
406: * Cancel the (which) timer in the ref structure indicated by (refp).
407: */
408: void
409: tp_cuntimeout(refp, which)
410: int which;
411: register struct tp_ref *refp;
412: {
413: register struct Ccallout *cp;
414:
415: cp = &(refp->tpr_callout[which]);
416:
417: IFDEBUG(D_TIMER)
418: printf("tp_cuntimeout(0x%x, %d) active %d\n", refp, which, cp->c_active);
419: ENDDEBUG
420:
421: IFTRACE(D_TIMER)
422: tptrace(TPPTmisc, "tp_cuntimeout ref which, active", refp-tp_ref,
423: which, cp->c_active, 0);
424: ENDTRACE
425:
426: if(cp->c_active)
427: IncStat(ts_Ccan_act);
428: else
429: IncStat(ts_Ccan_inact);
430: cp->c_active = FALSE;
431: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.