home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / sys / dev / pk3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-03  |  2.4 KB  |  163 lines
  1. #include "../h/param.h"
  2. #include "../h/systm.h"
  3. #include "../h/conf.h"
  4. #include "../h/buf.h"
  5.  
  6. #define    XPRI    30
  7. #define    NBLOCKS    10
  8.  
  9. int    bwaiting, wcount;
  10. struct    buf *bufps[NBLOCKS];
  11. char    *nbase[NBLOCKS];    /* normal allocations */
  12. short    nmap[NBLOCKS];        /* 1 bit == 32 bytes */
  13.  
  14. char log[] ={0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4};
  15. #define    FULL    -1
  16. #define    LOCK    s = spl6()
  17. #define    UNLOCK    splx(s)
  18.  
  19. /*
  20.  * getepack: get empty packet
  21.  * with size specified by bitmask.
  22.  */
  23. char *
  24. getepack(bits)
  25. {
  26. register i;
  27. int    s, savbits;
  28. char    **base;
  29. short    *map;
  30.  
  31.     base = nbase; map = nmap;
  32.     savbits = bits;
  33.  
  34.     /*
  35.      * search for space
  36.      */
  37.     LOCK;
  38.     for(;;) {
  39.  
  40.         if (bits == FULL)
  41.             goto force;
  42.  
  43.         for(i=0; i<NBLOCKS; i++) {
  44.             register m;
  45.             register unsigned n;
  46.             register offset;
  47.  
  48.             m = map[i];
  49.             if (m==FULL || base[i]==NULL)
  50.                 continue;
  51.             if (bits == 1) {
  52.                 n = m;
  53.                 m |= m+1;
  54.                 n = m-n;
  55.                 for (offset=0; n > 16; n >>= 4) 
  56.                     offset += 4;
  57.                 offset += log[n];
  58.             } else {
  59.                 bits = savbits;
  60.                 for(n=17; --n; bits <<= 1)
  61.                     if ((m&bits)==0)
  62.                         goto found;
  63.                 continue;
  64.             found:
  65.                 offset = 16-n;
  66.                 m |= bits;
  67.             }
  68.             map[i] = m;
  69.             UNLOCK;
  70.             return(base[i] + 32*offset);
  71.         }
  72.         /*
  73.          * grab another block from the system
  74.          */
  75.     force:
  76.         for(i=0;i<NBLOCKS;i++) {
  77.             register struct buf *bp;
  78.  
  79.             if (bufps[i]!=NULL)
  80.                 continue;
  81.             bufps[i] = bp = geteblk();
  82.             bp->b_flags |= B_PACK;
  83.             bp->b_flags |= B_PBUSY;
  84.             map[i] = bits;
  85.             base[i] = bp->b_un.b_addr;
  86.             UNLOCK;
  87.             return(bp->b_un.b_addr);
  88.         }
  89.         /*
  90.          * sleep until something is released
  91.          */
  92.         bwaiting++;
  93.         wcount++;
  94.         sleep((caddr_t)&bwaiting, XPRI);
  95.         bwaiting--;
  96.     }
  97. }
  98.  
  99. /*
  100.  * freepack: release space beginning
  101.  * at address p with length specified
  102.  * by bits.
  103.  */
  104. freepack(p, bits)
  105. char *p;
  106. {
  107. register i, d, s;
  108. char    **base;
  109. short    *map;
  110.  
  111.     if (p==NULL)
  112.         return;
  113.     LOCK;
  114.     base = nbase; map = nmap;
  115.  
  116.     for(i=0;i<NBLOCKS;i++) {
  117.         d = p-base[i];
  118.         if (d>=0 && d<=512) 
  119.             goto found;
  120.     }
  121.     goto out;
  122. found:
  123.     d >>= 5;
  124.     d = (bits<<d);
  125.     map[i] &= ~d;
  126.     if (map[i]==0) {
  127.         register struct buf *bp;
  128.  
  129.         bp = bufps[i];
  130.         bp->b_flags &= ~B_PBUSY;
  131.         base[i] = NULL;
  132.         bufps[i] = NULL;
  133.         brelse(bp);
  134.     }
  135.     if (bwaiting)
  136.         wakeup((caddr_t)&bwaiting);
  137. out:
  138.     splx(s);
  139. }
  140.  
  141.  
  142.  
  143. /*
  144.  * integer to bitmap conversion
  145.  */
  146. dtom(d)
  147. register d;
  148. {
  149. register m;
  150.  
  151.     m = 1;
  152.     while (d>32) {
  153.         d -= 32;
  154.         m |= m+1;
  155.     }
  156.     return(m);
  157. }
  158.  
  159. #define NRECS    160
  160. int reclist[NRECS];
  161. int recbits[NRECS];
  162.  
  163.