Return to work.c CVS log

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

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

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