Return to tcptimer.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/tcptimer.c, revision 1.1.1.1

1.1       root        1: #include       "u.h"
                      2: #include       "../port/lib.h"
                      3: #include       "mem.h"
                      4: #include       "dat.h"
                      5: #include       "fns.h"
                      6: #include       "../port/error.h"
                      7: #include       "arp.h"
                      8: #include       "../port/ipdat.h"
                      9: 
                     10: static Timer   *timers;        /* List of active timers */
                     11: static QLock   tl;             /* Protect timer list */
                     12: static Rendez  Tcpack;
                     13: Rendez tcpflowr;
                     14: 
                     15: static void
                     16: deltimer(Timer *t)
                     17: {
                     18:        if(timers == t)
                     19:                timers = t->next;
                     20: 
                     21:        if(t->next)
                     22:                t->next->prev = t->prev;
                     23: 
                     24:        if(t->prev)
                     25:                t->prev->next = t->next;
                     26: }
                     27: 
                     28: /*
                     29:  * Poke each tcp connection to recompute window size and
                     30:  * acknowledgement timer
                     31:  */
                     32: 
                     33: void
                     34: tcpflow(void *x)
                     35: {
                     36:        Ipifc *ifc;
                     37:        Ipconv *cp, **p, **etab;
                     38: 
                     39:        ifc = x;
                     40:        etab = &ifc->conv[Nipconv];
                     41: 
                     42:        for(;;) {
                     43:                sleep(&tcpflowr, return0, 0);
                     44: 
                     45:                for(p = ifc->conv; p < etab; p++) {
                     46:                        cp = *p;
                     47:                        if(cp == 0)
                     48:                                break;
                     49:                        if(cp->readq && cp->ref != 0 && !QFULL(cp->readq->next)) {
                     50:                                tcprcvwin(cp);
                     51:                                tcpacktimer(cp);
                     52:                        }
                     53:                }
                     54:        }
                     55: }
                     56: 
                     57: void
                     58: tcpackproc(void *junk)
                     59: {
                     60:        Timer *t, *tp, *timeo;
                     61: 
                     62:        USED(junk);
                     63:        for(;;) {
                     64:                timeo = 0;
                     65: 
                     66:                qlock(&tl);
                     67:                for(t = timers;t != 0; t = tp) {
                     68:                        tp = t->next;
                     69:                        if(t->state == TimerON) {
                     70:                                t->count--;
                     71:                                if(t->count == 0) {
                     72:                                        deltimer(t);
                     73:                                        t->state = TimerDONE;
                     74:                                        t->next = timeo;
                     75:                                        timeo = t;
                     76:                                }
                     77:                        }
                     78:                }
                     79:                qunlock(&tl);
                     80: 
                     81:                for(;;) {
                     82:                        t = timeo;
                     83:                        if(t == 0)
                     84:                                break;
                     85: 
                     86:                        timeo = t->next;
                     87:                        if(t->state == TimerDONE)
                     88:                        if(t->func)
                     89:                                (*t->func)(t->arg);
                     90:                }
                     91:                tsleep(&Tcpack, return0, 0, MSPTICK);
                     92:        }
                     93: }
                     94: 
                     95: void
                     96: tcpgo(Timer *t)
                     97: {
                     98:        if(t == 0 || t->start == 0)
                     99:                return;
                    100: 
                    101:        qlock(&tl);
                    102:        t->count = t->start;
                    103:        if(t->state != TimerON) {
                    104:                t->state = TimerON;
                    105:                t->prev = 0;
                    106:                t->next = timers;
                    107:                if(t->next)
                    108:                        t->next->prev = t;
                    109:                timers = t;
                    110:        }
                    111:        qunlock(&tl);
                    112: }
                    113: 
                    114: void
                    115: tcphalt(Timer *t)
                    116: {
                    117:        if(t == 0)
                    118:                return;
                    119: 
                    120:        qlock(&tl);
                    121:        if(t->state == TimerON)
                    122:                deltimer(t);
                    123:        t->state = TimerOFF;
                    124:        qunlock(&tl);
                    125: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.