Return to brk.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / sys

Annotation of coherent/b/lib/libc/sys/brk.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <sys/types.h>
                      3: #include <errno.h>
                      4: 
                      5: extern char *_brk();
                      6: 
                      7: #if Z8001
                      8: paddr_t
                      9: vtop(cp)
                     10: register unsigned long cp;
                     11: {
                     12:        register unsigned int offs = cp;
                     13: 
                     14:        cp >>= 8;
                     15:        cp &= 0x7F0000L;
                     16:        return(cp | offs);
                     17: }
                     18: 
                     19: char *
                     20: ptov(p)
                     21: register unsigned long p;
                     22: {
                     23:        register unsigned int offs = p;
                     24: 
                     25:        p <<=8;
                     26:        p &= 0x7F000000L;
                     27:        return(p | offs);
                     28: }
                     29: #else
                     30: #define vtop(A) ((paddr_t)(A))
                     31: #define ptov(A) ((char *)(A))
                     32: #endif
                     33: 
                     34: #if IAPX86
                     35: static char    *minbrk = NULL;         /* must init at run time */
                     36: static char    *actbrk = NULL;
                     37: static char    *reqbrk = NULL;
                     38: #else
                     39: extern char    end[];                  /* end of loaded private data */
                     40: static char    *minbrk = end;          /* can't brk before end */
                     41: static char    *actbrk = end;          /* actual end of private data */
                     42: static char    *reqbrk = end;          /* requested (virtual) end of p.d. */
                     43: #endif
                     44: 
                     45: int
                     46: brk(newbrk)
                     47: register char *newbrk;
                     48: {
                     49:        register char *abrk;
                     50: 
                     51:        errno = 0;
                     52:        newbrk += (int)newbrk & 1;
                     53: #if IAPX86
                     54:        if (minbrk == NULL)
                     55:                minbrk = actbrk = reqbrk = _brk(NULL);
                     56: #endif
                     57:        if (newbrk < minbrk) {
                     58:                errno = EINVAL;
                     59:                return(-1);
                     60:        }
                     61:        abrk = _brk(newbrk);
                     62:        if (errno)
                     63:                return(-1);
                     64:        if (abrk < newbrk) {
                     65:                errno = ENOMEM;
                     66:                return(-1);
                     67:        }
                     68:        reqbrk = newbrk;
                     69:        actbrk = abrk;
                     70:        return(0);
                     71: }
                     72: 
                     73: char *
                     74: sbrk(incr)
                     75: register unsigned int incr;
                     76: {
                     77:        register paddr_t rbrk;
                     78: 
                     79: #if IAPX86
                     80:        if (minbrk == NULL)
                     81:                minbrk = actbrk = reqbrk = _brk(NULL);
                     82: #endif
                     83:        incr += incr & 1;
                     84:        rbrk = vtop(reqbrk);
                     85:        if (rbrk + incr <= vtop(actbrk)) {
                     86:                reqbrk = ptov(rbrk + incr);
                     87:                return(ptov(rbrk));
                     88:        }
                     89: #if Z8001
                     90:        if ((rbrk+incr ^ rbrk) > 65536L  &&  (int)rbrk+incr) {
                     91:                rbrk += 65536L;
                     92:                rbrk &= 0xFFFF0000L;
                     93:                reqbrk = ptov(rbrk);
                     94:        }
                     95: #endif
                     96:        if (brk(ptov(rbrk + incr)))
                     97:                return((char *)-1);
                     98:        return(ptov(rbrk));
                     99: }

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