Return to kern_softint.c CVS log

Up to [Research Unix] / researchv9 / sys / sun3

Annotation of researchv9/sys/sun3/kern_softint.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)kern_softint.c 1.1 86/02/03 Copyr 1985 Sun Micro";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1985 by Sun Microsystems, Inc.
        !             7:  */
        !             8: #include "../h/types.h"
        !             9: 
        !            10: /*
        !            11:  * Handle software interrupts through 'softcall' mechanism
        !            12:  */
        !            13: 
        !            14: typedef int (*func_t)();
        !            15: 
        !            16: #define NSOFTCALLS     50
        !            17: 
        !            18: struct softcall {
        !            19:        func_t  sc_func;                /* function to call */
        !            20:        caddr_t sc_arg;                 /* arg to pass to func */
        !            21:        struct softcall *sc_next;       /* next in list */
        !            22: } softcalls[NSOFTCALLS];
        !            23: 
        !            24: struct softcall *softhead, *softtail, *softfree;
        !            25: 
        !            26: /*
        !            27:  * Call function func with argument arg
        !            28:  * at some later time at software interrupt priority
        !            29:  */
        !            30: softcall(func, arg)
        !            31:        register func_t func;
        !            32:        register caddr_t arg;
        !            33: {
        !            34:        register struct softcall *sc;
        !            35:        static int first = 1;
        !            36:        int s;
        !            37: 
        !            38:        s = spl6();
        !            39:        if (first) {
        !            40:                for (sc = softcalls; sc < &softcalls[NSOFTCALLS]; sc++) {
        !            41:                        sc->sc_next = softfree;
        !            42:                        softfree = sc;
        !            43:                }
        !            44:                first = 0;
        !            45:        }
        !            46:        /* coalesce identical softcalls */
        !            47:        for (sc = softhead; sc != 0; sc = sc->sc_next)
        !            48:                if (sc->sc_func == func && sc->sc_arg == arg)
        !            49:                        goto out;
        !            50:        if ((sc = softfree) == 0)
        !            51:                panic("too many softcalls");
        !            52:        softfree = sc->sc_next;
        !            53:        sc->sc_func = func;
        !            54:        sc->sc_arg = arg;
        !            55:        sc->sc_next = 0;
        !            56:        if (softhead) {
        !            57:                softtail->sc_next = sc;
        !            58:                softtail = sc;
        !            59:        } else {
        !            60:                softhead = softtail = sc;
        !            61:                siron();
        !            62:        }
        !            63: out:
        !            64:        (void) splx(s);
        !            65: }
        !            66: 
        !            67: /*
        !            68:  * Called to process software interrupts
        !            69:  * take one off queue, call it, repeat
        !            70:  * Note queue may change during call
        !            71:  */
        !            72: softint()
        !            73: {
        !            74:        register func_t func;
        !            75:        register caddr_t arg;
        !            76:        register struct softcall *sc;
        !            77:        int s;
        !            78: 
        !            79:        for (;;) {
        !            80:                s = spl6();
        !            81:                if (sc = softhead) {
        !            82:                        func = sc->sc_func;
        !            83:                        arg = sc->sc_arg;
        !            84:                        softhead = sc->sc_next;
        !            85:                        sc->sc_next = softfree;
        !            86:                        softfree = sc;
        !            87:                }
        !            88:                (void) splx(s);
        !            89:                if (sc == 0)
        !            90:                        return;
        !            91:                (*func)(arg);
        !            92:        }
        !            93: }

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