Return to work.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * File:       work.c
        !             3:  *
        !             4:  * Purpose:    Manage temporary pages of virtual memory.
        !             5:  *             Pages are allocated in virtually contiguous pairs to allow
        !             6:  *             for straddle operations in target code.
        !             7:  *
        !             8:  * $Log:       work.c,v $
        !             9:  * Revision 1.1  93/04/14  10:29:40  root
        !            10:  * r75
        !            11:  * 
        !            12:  */
        !            13: 
        !            14: /*
        !            15:  * ----------------------------------------------------------------------
        !            16:  * Includes.
        !            17:  */
        !            18: #include <sys/coherent.h>
        !            19: 
        !            20: /*
        !            21:  * ----------------------------------------------------------------------
        !            22:  * Definitions.
        !            23:  *     Constants.
        !            24:  *     Macros with argument lists.
        !            25:  *     Typedefs.
        !            26:  *     Enums.
        !            27:  */
        !            28: #define        START_WORK      0xFFFFA         /* Highest scratchpad click pair. */
        !            29: #define MAX_WORK_PAIRS 4               /* Max # in use at one time */
        !            30: 
        !            31: /*
        !            32:  * ----------------------------------------------------------------------
        !            33:  * Functions.
        !            34:  *     Import Functions.
        !            35:  *     Export Functions.
        !            36:  *     Local Functions.
        !            37:  */
        !            38: int    workAlloc();
        !            39: void   workFree();
        !            40: void   workPoolInit();
        !            41: 
        !            42: /*
        !            43:  * ----------------------------------------------------------------------
        !            44:  * Global Data.
        !            45:  *     Import Variables.
        !            46:  *     Export Variables.
        !            47:  *     Local Variables.
        !            48:  */
        !            49: static int     numWorkPairs;   /* Number of click pairs in use. */
        !            50: static int     maxWorkPairs;   /* For monitoring resource use. */
        !            51: 
        !            52: static int     workPool[MAX_WORK_PAIRS];
        !            53: 
        !            54: /*
        !            55:  * ----------------------------------------------------------------------
        !            56:  * Code.
        !            57:  */
        !            58: void
        !            59: workPoolInit()
        !            60: {
        !            61:        int i, w;
        !            62: 
        !            63:        for (i = 0, w = START_WORK; i < MAX_WORK_PAIRS; i++, w -= 2)
        !            64:                workPool[i] = w;
        !            65: }
        !            66: 
        !            67: /*
        !            68:  * Allocate a click pair of virtual space for temporary use.
        !            69:  * Panic if none available.
        !            70:  * Return value is a click number, e.g. 0xFFFFA, suitable for use as
        !            71:  * an index into ptable1_v[].  The return value plus one is also
        !            72:  * available for use as a virtual click number.
        !            73:  */
        !            74: int
        !            75: workAlloc()
        !            76: {
        !            77:        int s, ret;
        !            78: 
        !            79:        s = sphi();
        !            80:        if (numWorkPairs >= MAX_WORK_PAIRS)
        !            81:                panic("Work pair pool empty");
        !            82:        ret = workPool[numWorkPairs++];
        !            83:        spl(s);
        !            84: #if 0
        !            85:        if (numWorkPairs > maxWorkPairs) {
        !            86:                maxWorkPairs = numWorkPairs;
        !            87:                printf("Now using %d work pairs ", maxWorkPairs);
        !            88:        }
        !            89: #endif
        !            90:        return ret;
        !            91: }
        !            92: 
        !            93: /*
        !            94:  * Return a click pair of virtual space to the free pool.
        !            95:  */
        !            96: void
        !            97: workFree(w)
        !            98: int w;
        !            99: {
        !           100:        int s;
        !           101: 
        !           102:        if (w > START_WORK || w <= START_WORK - MAX_WORK_PAIRS)
        !           103:                panic("workFree(%x)", w);
        !           104:        s = sphi();
        !           105:        if (numWorkPairs == 0)
        !           106:                panic("Work pair pool exploded");
        !           107:        workPool[--numWorkPairs] = w;
        !           108:        spl(s);
        !           109: }

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