Return to alarm.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / boot / pc

Annotation of lucent/sys/src/boot/pc/alarm.c, revision 1.1

1.1     ! root        1: #include       "u.h"
        !             2: #include       "lib.h"
        !             3: #include       "mem.h"
        !             4: #include       "dat.h"
        !             5: #include       "fns.h"
        !             6: #include       "io.h"
        !             7: #define        nelem(x)        (sizeof(x)/sizeof((x)[0]))
        !             8: #define        MAXALARM        10
        !             9: 
        !            10: Alarm  alarmtab[MAXALARM];
        !            11: 
        !            12: /*
        !            13:  * Insert new into list after where
        !            14:  */
        !            15: void
        !            16: insert(List **head, List *where, List *new)
        !            17: {
        !            18:        if(where == 0){
        !            19:                new->next = *head;
        !            20:                *head = new;
        !            21:        }else{
        !            22:                new->next = where->next;
        !            23:                where->next = new;
        !            24:        }
        !            25:                
        !            26: }
        !            27: 
        !            28: /*
        !            29:  * Delete old from list.  where->next is known to be old.
        !            30:  */
        !            31: void
        !            32: delete(List **head, List *where, List *old)
        !            33: {
        !            34:        if(where == 0){
        !            35:                *head = old->next;
        !            36:                return;
        !            37:        }
        !            38:        where->next = old->next;
        !            39: }
        !            40: 
        !            41: Alarm*
        !            42: newalarm(void)
        !            43: {
        !            44:        int i;
        !            45:        Alarm *a;
        !            46: 
        !            47:        for(i=0,a=alarmtab; i < nelem(alarmtab); i++,a++)
        !            48:                if(a->busy==0 && a->f==0){
        !            49:                        a->f = 0;
        !            50:                        a->arg = 0;
        !            51:                        a->busy = 1;
        !            52:                        return a;
        !            53:                }
        !            54:        panic("newalarm");
        !            55:        return 0;       /* not reached */
        !            56: }
        !            57: 
        !            58: Alarm*
        !            59: alarm(int ms, void (*f)(Alarm*), void *arg)
        !            60: {
        !            61:        Alarm *a, *w, *pw;
        !            62:        ulong s;
        !            63: 
        !            64:        if(ms < 0)
        !            65:                ms = 0;
        !            66:        s = splhi();
        !            67:        a = newalarm();
        !            68:        a->dt = MS2TK(ms);
        !            69:        a->f = f;
        !            70:        a->arg = arg;
        !            71:        pw = 0;
        !            72:        for(w=m->alarm; w; pw=w, w=w->next){
        !            73:                if(w->dt <= a->dt){
        !            74:                        a->dt -= w->dt;
        !            75:                        continue;
        !            76:                }
        !            77:                w->dt -= a->dt;
        !            78:                break;
        !            79:        }
        !            80:        insert(&m->alarm, pw, a);
        !            81:        splx(s);
        !            82:        return a;
        !            83: }
        !            84: 
        !            85: void
        !            86: cancel(Alarm *a)
        !            87: {
        !            88:        a->f = 0;
        !            89: }
        !            90: 
        !            91: void
        !            92: alarminit(void)
        !            93: {
        !            94: }
        !            95: 
        !            96: #define NA 10          /* alarms per clock tick */
        !            97: void
        !            98: checkalarms(void)
        !            99: {
        !           100:        int i, n, s;
        !           101:        Alarm *a;
        !           102:        void (*f)(void*);
        !           103:        Alarm *alist[NA];
        !           104: 
        !           105:        s = splhi();
        !           106:        a = m->alarm;
        !           107:        if(a){
        !           108:                for(n=0; a && a->dt<=0 && n<NA; n++){
        !           109:                        alist[n] = a;
        !           110:                        delete(&m->alarm, 0, a);
        !           111:                        a = m->alarm;
        !           112:                }
        !           113:                if(a)
        !           114:                        a->dt--;
        !           115: 
        !           116:                for(i = 0; i < n; i++){
        !           117:                        f = alist[i]->f;        /* avoid race with cancel */
        !           118:                        if(f)
        !           119:                                (*f)(alist[i]);
        !           120:                        alist[i]->busy = 0;
        !           121:                }
        !           122:        }
        !           123:        splx(s);
        !           124: }

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