Return to malloc.c CVS log

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

Annotation of coherent/b/lib/libc/gen/old/malloc.c, revision 1.1.1.1

1.1       root        1: /* allocate and free routines
                      2:  * all blocks are allocated in multiples of 2
                      3:  * with the first word as the true length
                      4:  * the lo order bit is 1 if the block is free.
                      5:  * A word of zero marks the end of an arena and points
                      6:  * to the start of the next arena. Arenas point in a circle.
                      7:  */
                      8: 
                      9: #include <stdio.h>
                     10: #include <malloc.h>
                     11: 
                     12: struct mblock  *_a_scanp = NULL;       /* search starts here */
                     13: 
                     14: static unsigned depth = 0;             /* depth of malloc recursion */
                     15: 
                     16: static char msg[] = "Bad pointer in free.\n";
                     17: 
                     18: /* get a new arena from sbrk and hook it to the old */
                     19: 
                     20: static void
                     21: newarea( len)
                     22: register unsigned len;
                     23: {
                     24:        register struct mblock *newa, *newb, *prev;
                     25: 
                     26:        char *passbug = BADSBRK;        /* beat large model c bug */
                     27: 
                     28:        static struct mblock *_a_topar = NULL;
                     29: 
                     30:        unsigned cbrk = (unsigned)sbrk( 0);
                     31: 
                     32:        if( len > 65500L)
                     33:                return;
                     34:        len += sizeof(struct mblock);
                     35:        if( len < 512)
                     36:                if( cbrk < 65536L - 511)
                     37:                        len = 512;
                     38:                else
                     39:                        len = -cbrk;
                     40: #if Z8001
                     41:        else if( (unsigned long)cbrk+len > 65536L)
                     42:                newarea( - cbrk - sizeof( struct mblock));
                     43: #endif
                     44:        if( passbug == (newa = sbrk(len)))
                     45:                return;
                     46: 
                     47:        if(_a_topar == NULL)            /* first time through */
                     48:                _a_scanp = prev = newa;
                     49: 
                     50:        else if(_a_topar == newa) {     /* new over old */
                     51:                --newa;
                     52:                len += sizeof(struct mblock);
                     53:                prev = newa->uval.next;
                     54: 
                     55:        } else {                        /* discontigous arenas */
                     56:                newb = _a_topar;
                     57:                prev = (--newb)->uval.next;     /* save old ptr */
                     58:                newb->uval.next = newa;         /* old pts to new */
                     59:        }
                     60:        newa->blksize = (len - sizeof(struct mblock)) | FREE;
                     61:        newb = _a_topar = adr(newa) + len;
                     62:        (--newb)->blksize = 0;
                     63:        newb->uval.next = prev;
                     64:        return;
                     65: }
                     66: 
                     67: char *
                     68: malloc( size)
                     69: unsigned size;
                     70: {
                     71:        register struct mblock *ptr, *optr;
                     72:        register unsigned len, siz;
                     73: 
                     74:        siz = roundup(size + sizeof(unsigned), POW2);
                     75:        if(siz < size)
                     76:                return(NULL);
                     77:        optr = NULL;
                     78:        if((ptr = _a_scanp) != NULL) {
                     79:            do {
                     80:                if(isfree(len = ptr->blksize)) { /* free block */
                     81:                        if(optr != NULL) { /* consolidate free */
                     82:                                len = (optr->blksize += realsize(len));
                     83:                                ptr = optr;
                     84:                        }
                     85:                        optr = ptr;
                     86:                        if(len > siz) { /* got one big enough */
                     87:                                if((len -= siz)<LEASTFREE) /* close enough */
                     88:                                        ptr->blksize = realsize(ptr->blksize);
                     89:                                else {
                     90:                                        ptr->blksize = siz;
                     91:                                        _a_scanp = siz + adr(ptr);
                     92:                                        _a_scanp->blksize = len;
                     93:                                }
                     94:                                return(ptr->uval.usera);
                     95:                        }
                     96:                } else                  /* used block or area ptr */
                     97:                        optr = NULL;
                     98: 
                     99:                if(len)
                    100:                        ptr = realsize(len) + adr(ptr);
                    101:                else
                    102:                        ptr = ptr->uval.next;   /* new arena */
                    103:            } while(ptr != _a_scanp);
                    104:        }
                    105: 
                    106:        if(optr != NULL)
                    107:                _a_scanp = optr;
                    108: 
                    109:        /* no room in the arena or first time */
                    110:        if(++depth >= 2) {
                    111:                depth--;
                    112:                return(NULL);
                    113:        }
                    114:        newarea(siz);
                    115:        ptr = malloc(size);
                    116:        depth--;
                    117:        return(ptr);
                    118: }
                    119: 
                    120: /* free a block */
                    121: free(cp)
                    122: char *cp;
                    123: {
                    124:        register struct mblock *ap;
                    125: 
                    126:        ap = cp - sizeof(unsigned);
                    127:        if(!ap->blksize) {
                    128:                write(2, msg, strlen(msg));
                    129:                abort();
                    130:        }
                    131:        ap->blksize |= FREE;    /* mark free even if free */
                    132: }

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