1N/A/***********************************************************************
1N/A* *
1N/A* This software is part of the ast package *
1N/A* Copyright (c) 1985-2011 AT&T Intellectual Property *
1N/A* and is licensed under the *
1N/A* Common Public License, Version 1.0 *
1N/A* by AT&T Intellectual Property *
1N/A* *
1N/A* A copy of the License is available at *
1N/A* http://www.opensource.org/licenses/cpl1.0.txt *
1N/A* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
1N/A* *
1N/A* Information and Software Systems Research *
1N/A* AT&T Research *
1N/A* Florham Park NJ *
1N/A* *
1N/A* Glenn Fowler <gsf@research.att.com> *
1N/A* David Korn <dgk@research.att.com> *
1N/A* Phong Vo <kpv@research.att.com> *
1N/A* *
1N/A***********************************************************************/
1N/A#if defined(_UWIN) && defined(_BLD_ast)
1N/A
1N/Avoid _STUB_vmprivate(){}
1N/A
1N/A#else
1N/A
1N/A#include "vmhdr.h"
1N/A
1N/Astatic char* Version = "\n@(#)$Id: Vmalloc (AT&T Research) 2010-01-01 $\0\n";
1N/A
1N/A/* Private code used in the vmalloc library
1N/A**
1N/A** Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94.
1N/A*/
1N/A
1N/A/* Get more memory for a region */
1N/A#if __STD_C
1N/Astatic Block_t* vmextend(reg Vmalloc_t* vm, size_t size, Vmsearch_f searchf )
1N/A#else
1N/Astatic Block_t* vmextend(vm, size, searchf )
1N/Areg Vmalloc_t* vm; /* region to increase in size */
1N/Asize_t size; /* desired amount of space */
1N/AVmsearch_f searchf; /* tree search function */
1N/A#endif
1N/A{
1N/A reg size_t s;
1N/A reg Seg_t* seg;
1N/A reg Block_t *bp, *t;
1N/A reg Vmuchar_t* addr = (Vmuchar_t*)Version; /* shut compiler warning */
1N/A reg Vmdata_t* vd = vm->data;
1N/A reg Vmemory_f memoryf = vm->disc->memoryf;
1N/A reg Vmexcept_f exceptf = vm->disc->exceptf;
1N/A
1N/A GETPAGESIZE(_Vmpagesize);
1N/A
1N/A#if DEBUG /* trace all allocation calls through the heap */
1N/A if(!_Vmtrace && vm == Vmheap && (vd->mode&VM_TRUST) )
1N/A VMOPTIONS();
1N/A#endif
1N/A
1N/A if(vd->incr <= 0) /* this is just _Vmheap on the first call */
1N/A vd->incr = VMHEAPINCR;
1N/A
1N/A /* Get slightly more for administrative data */
1N/A s = size + sizeof(Seg_t) + sizeof(Block_t) + sizeof(Head_t) + 2*ALIGN;
1N/A if(s <= size) /* size was too large and we have wrapped around */
1N/A return NIL(Block_t*);
1N/A if((size = ROUND(s,vd->incr)) < s)
1N/A return NIL(Block_t*);
1N/A
1N/A /* increase the rounding factor to reduce # of future extensions */
1N/A if(size > 2*vd->incr && vm->disc->round < vd->incr)
1N/A vd->incr *= 2;
1N/A
1N/A /* see if we can extend the current segment */
1N/A if(!(seg = vd->seg) )
1N/A addr = NIL(Vmuchar_t*);
1N/A else
1N/A { if(!vd->wild || SEG(vd->wild) != seg)
1N/A s = 0;
1N/A else
1N/A { s = SIZE(vd->wild) + sizeof(Head_t);
1N/A if((s = (s/vd->incr)*vd->incr) == size)
1N/A size += vd->incr;
1N/A }
1N/A addr = (Vmuchar_t*)(*memoryf)(vm,seg->addr,seg->extent,
1N/A seg->extent+size-s,vm->disc);
1N/A if(!addr)
1N/A seg = NIL(Seg_t*);
1N/A else
1N/A { /**/ASSERT(addr == (Vmuchar_t*)seg->addr);
1N/A addr += seg->extent;
1N/A size -= s;
1N/A }
1N/A }
1N/A
1N/A while(!addr) /* try to get space */
1N/A { if((addr = (Vmuchar_t*)(*memoryf)(vm,NIL(Void_t*),0,size,vm->disc)) )
1N/A break;
1N/A
1N/A /* check with exception handler to see if we should continue */
1N/A if(!exceptf)
1N/A return NIL(Block_t*);
1N/A else
1N/A { int rv, lock;
1N/A lock = vd->mode&VM_LOCK;
1N/A vd->mode &= ~VM_LOCK;
1N/A rv = (*exceptf)(vm,VM_NOMEM,(Void_t*)size,vm->disc);
1N/A vd->mode |= lock;
1N/A if(rv <= 0)
1N/A { if(rv == 0)
1N/A vd->mode |= VM_AGAIN;
1N/A return NIL(Block_t*);
1N/A }
1N/A }
1N/A }
1N/A
1N/A if(seg)
1N/A { /* extending current segment */
1N/A bp = BLOCK(seg->baddr);
1N/A
1N/A if(vd->mode&(VM_MTBEST|VM_MTDEBUG|VM_MTPROFILE) )
1N/A { /**/ ASSERT((SIZE(bp)&~BITS) == 0);
1N/A /**/ ASSERT(SEG(bp) == seg);
1N/A if(!ISPFREE(SIZE(bp)) )
1N/A SIZE(bp) = size - sizeof(Head_t);
1N/A else
1N/A { /**/ ASSERT(searchf);
1N/A bp = LAST(bp);
1N/A if(bp == vd->wild)
1N/A vd->wild = NIL(Block_t*);
1N/A else REMOVE(vd,bp,INDEX(SIZE(bp)),t,(*searchf));
1N/A SIZE(bp) += size;
1N/A }
1N/A }
1N/A else
1N/A { if(seg->free)
1N/A { bp = seg->free;
1N/A seg->free = NIL(Block_t*);
1N/A SIZE(bp) += size;
1N/A }
1N/A else
1N/A { SEG(bp) = seg;
1N/A SIZE(bp) = size - sizeof(Head_t);
1N/A }
1N/A }
1N/A
1N/A seg->size += size;
1N/A seg->extent += size;
1N/A seg->baddr += size;
1N/A }
1N/A else
1N/A { /* creating a new segment */
1N/A reg Seg_t *sp, *lastsp;
1N/A
1N/A if((s = (size_t)(VLONG(addr)%ALIGN)) != 0)
1N/A addr += ALIGN-s;
1N/A
1N/A seg = (Seg_t*)addr;
1N/A seg->vmdt = vd;
1N/A seg->addr = (Void_t*)(addr - (s ? ALIGN-s : 0));
1N/A seg->extent = size;
1N/A seg->baddr = addr + size - (s ? 2*ALIGN : 0);
1N/A seg->free = NIL(Block_t*);
1N/A bp = SEGBLOCK(seg);
1N/A SEG(bp) = seg;
1N/A SIZE(bp) = seg->baddr - (Vmuchar_t*)bp - 2*sizeof(Head_t);
1N/A
1N/A /* NOTE: for Vmbest, Vmdebug and Vmprofile the region's segment list
1N/A is reversely ordered by addresses. This is so that we can easily
1N/A check for the wild block.
1N/A */
1N/A lastsp = NIL(Seg_t*);
1N/A sp = vd->seg;
1N/A if(vd->mode&(VM_MTBEST|VM_MTDEBUG|VM_MTPROFILE))
1N/A for(; sp; lastsp = sp, sp = sp->next)
1N/A if(seg->addr > sp->addr)
1N/A break;
1N/A seg->next = sp;
1N/A if(lastsp)
1N/A lastsp->next = seg;
1N/A else vd->seg = seg;
1N/A
1N/A seg->size = SIZE(bp);
1N/A }
1N/A
1N/A /* make a fake header for possible segmented memory */
1N/A t = NEXT(bp);
1N/A SEG(t) = seg;
1N/A SIZE(t) = BUSY;
1N/A
1N/A /* see if the wild block is still wild */
1N/A if((t = vd->wild) && (seg = SEG(t)) != vd->seg)
1N/A { CLRPFREE(SIZE(NEXT(t)));
1N/A if(vd->mode&(VM_MTBEST|VM_MTDEBUG|VM_MTPROFILE) )
1N/A { SIZE(t) |= BUSY|JUNK;
1N/A LINK(t) = CACHE(vd)[C_INDEX(SIZE(t))];
1N/A CACHE(vd)[C_INDEX(SIZE(t))] = t;
1N/A }
1N/A else seg->free = t;
1N/A
1N/A vd->wild = NIL(Block_t*);
1N/A }
1N/A
1N/A return bp;
1N/A}
1N/A
1N/A/* Truncate a segment if possible */
1N/A#if __STD_C
1N/Astatic ssize_t vmtruncate(Vmalloc_t* vm, Seg_t* seg, size_t size, int exact)
1N/A#else
1N/Astatic ssize_t vmtruncate(vm, seg, size, exact)
1N/AVmalloc_t* vm; /* containing region */
1N/ASeg_t* seg; /* the one to be truncated */
1N/Asize_t size; /* amount of free space */
1N/Aint exact;
1N/A#endif
1N/A{
1N/A reg Void_t* caddr;
1N/A reg Seg_t* last;
1N/A reg Vmdata_t* vd = vm->data;
1N/A reg Vmemory_f memoryf = vm->disc->memoryf;
1N/A
1N/A caddr = seg->addr;
1N/A
1N/A if(size < seg->size)
1N/A { reg ssize_t less;
1N/A
1N/A if(exact)
1N/A less = size;
1N/A else /* keep truncated amount to discipline requirements */
1N/A { if((less = vm->disc->round) <= 0)
1N/A less = _Vmpagesize;
1N/A less = (size/less)*less;
1N/A less = (less/vd->incr)*vd->incr;
1N/A if(less > 0 && size > (size_t)less && (size-(size_t)less) < sizeof(Block_t) )
1N/A less = (size_t)less <= vd->incr ? 0 : (size_t)less - vd->incr;
1N/A }
1N/A
1N/A if(less <= 0 ||
1N/A (*memoryf)(vm,caddr,seg->extent,seg->extent-less,vm->disc) != caddr)
1N/A return 0;
1N/A
1N/A seg->extent -= less;
1N/A seg->size -= less;
1N/A seg->baddr -= less;
1N/A SEG(BLOCK(seg->baddr)) = seg;
1N/A SIZE(BLOCK(seg->baddr)) = BUSY;
1N/A
1N/A return less;
1N/A }
1N/A else
1N/A { /* unlink segment from region */
1N/A if(seg == vd->seg)
1N/A { vd->seg = seg->next;
1N/A last = NIL(Seg_t*);
1N/A }
1N/A else
1N/A { for(last = vd->seg; last->next != seg; last = last->next)
1N/A ;
1N/A last->next = seg->next;
1N/A }
1N/A
1N/A /* now delete it */
1N/A if((*memoryf)(vm,caddr,seg->extent,0,vm->disc) == caddr)
1N/A return size;
1N/A
1N/A /* space reduction failed, reinsert segment */
1N/A if(last)
1N/A { seg->next = last->next;
1N/A last->next = seg;
1N/A }
1N/A else
1N/A { seg->next = vd->seg;
1N/A vd->seg = seg;
1N/A }
1N/A return 0;
1N/A }
1N/A}
1N/A
1N/A/* Externally visible names but local to library */
1N/AVmextern_t _Vmextern =
1N/A{ vmextend, /* _Vmextend */
1N/A vmtruncate, /* _Vmtruncate */
1N/A 0, /* _Vmpagesize */
1N/A NIL(char*(*)_ARG_((char*,const char*,int))), /* _Vmstrcpy */
1N/A NIL(char*(*)_ARG_((Vmulong_t,int))), /* _Vmitoa */
1N/A NIL(void(*)_ARG_((Vmalloc_t*,
1N/A Vmuchar_t*,Vmuchar_t*,size_t,size_t))), /* _Vmtrace */
1N/A NIL(void(*)_ARG_((Vmalloc_t*))) /* _Vmpfclose */
1N/A};
1N/A
1N/A#endif