Return to defer.c CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / i386

Annotation of coherent/b/kernel/i386/defer.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * File:       defer.c
        !             3:  *
        !             4:  * Purpose:    Handle deferring of functions and subsequent execution.
        !             5:  *
        !             6:  * $Log:       defer.c,v $
        !             7:  * Revision 1.9  93/06/14  13:42:38  bin
        !             8:  * Hal: kernel 78 update
        !             9:  * 
        !            10:  * Revision 1.1  92/11/09  17:08:40  root
        !            11:  * Just before adding vio segs.
        !            12:  * 
        !            13:  */
        !            14: 
        !            15: /*
        !            16:  * ----------------------------------------------------------------------
        !            17:  * Includes.
        !            18:  */
        !            19: 
        !            20: /*
        !            21:  * ----------------------------------------------------------------------
        !            22:  * Definitions.
        !            23:  *     Constants.
        !            24:  *     Macros with argument lists.
        !            25:  *     Typedefs.
        !            26:  *     Enums.
        !            27:  */
        !            28: #define        DEFLIM  128     /* maximum number of deferred functions */
        !            29: 
        !            30: /*
        !            31:  * ----------------------------------------------------------------------
        !            32:  * Functions.
        !            33:  *     Import Functions.
        !            34:  *     Export Functions.
        !            35:  *     Local Functions.
        !            36:  */
        !            37: void defer();
        !            38: void defend();
        !            39: 
        !            40: /*
        !            41:  * ----------------------------------------------------------------------
        !            42:  * Global Data.
        !            43:  *     Import Variables.
        !            44:  *     Export Variables.
        !            45:  *     Local Variables.
        !            46:  */
        !            47: static void (*defunc[DEFLIM])();
        !            48: static int defarg[DEFLIM];
        !            49: static int defqix, defqox, defcnt;
        !            50: 
        !            51: /*
        !            52:  * ----------------------------------------------------------------------
        !            53:  * Code.
        !            54:  */
        !            55: 
        !            56: /*
        !            57:  * defer()
        !            58:  *
        !            59:  *     Defer a function [usually from interrupt level].
        !            60:  *     The deferred function takes a single int-sized arg.
        !            61:  */
        !            62: #define DEFDBG 1
        !            63: #if DEFDBG
        !            64: static int deftag[DEFLIM];
        !            65: 
        !            66: void
        !            67: defer0(f,a,t)
        !            68: void (*f)();
        !            69: int a;
        !            70: int t;
        !            71: {
        !            72:        int s=sphi();
        !            73: 
        !            74:        if (defcnt < DEFLIM) {          /* is there room in defer queue? */
        !            75:                defunc[defqix] = f;
        !            76:                defarg[defqix] = a;
        !            77:                deftag[defqix] = t;
        !            78:                if (++defqix >= DEFLIM)
        !            79:                        defqix = 0;
        !            80:                defcnt++;
        !            81:        } else {
        !            82:                static foo;
        !            83:                int *r=(int *)(&f);
        !            84:                int tmpqox = defqox+DEFLIM-16;
        !            85: 
        !            86:                if (foo++ == 0) {
        !            87:                        printf("\nDefer overflow r=%x t =%x f=%x a=%x ",
        !            88:                          *(r-1), t, f, a);
        !            89:                        do {
        !            90:                                tmpqox = (tmpqox+1) % DEFLIM;
        !            91:                                printf("\nt=%x f=%x a=%x ox=%d ",
        !            92:                                  deftag[tmpqox], defunc[tmpqox],
        !            93:                                  defarg[tmpqox], tmpqox);
        !            94:                        } while (tmpqox != defqox);
        !            95:                }
        !            96:        }
        !            97:        spl(s);
        !            98: }
        !            99: 
        !           100: void
        !           101: defer(f,a)
        !           102: void (*f)();
        !           103: int a;
        !           104: {
        !           105:        defer0(f, a, 0);
        !           106: }
        !           107: #else
        !           108: void
        !           109: defer(f,a)
        !           110: void (*f)();
        !           111: int a;
        !           112: {
        !           113:        int s=sphi();
        !           114: 
        !           115:        if (defcnt < DEFLIM) {          /* is there room in defer queue? */
        !           116:                defunc[defqix] = f;
        !           117:                defarg[defqix] = a;
        !           118:                if (++defqix >= DEFLIM)
        !           119:                        defqix = 0;
        !           120:                defcnt++;
        !           121:        } else {
        !           122:                static foo;
        !           123:                int *r=(int *)(&f);
        !           124:                if (foo++ < 4)
        !           125:                        printf("\nDefer overflow r=%x f=%x a=%x ", *(r-1), f, a);
        !           126:        }
        !           127:        spl(s);
        !           128: }
        !           129: #endif
        !           130: 
        !           131: /*
        !           132:  * defend()
        !           133:  *
        !           134:  *     Evaluate all deferred functions.
        !           135:  *     Should be called periodically by busy-wait device drivers.
        !           136:  */
        !           137: void
        !           138: defend()
        !           139: {
        !           140:        while (defcnt) {
        !           141:                (*defunc[defqox])(defarg[defqox]); 
        !           142:                if (++defqox >= DEFLIM)
        !           143:                        defqox = 0;
        !           144:                defcnt--;
        !           145:        }
        !           146: }

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