static void *
_malloc_unlocked(size_t size)
{
size_t n;
TREE *tp, *sp;
size_t o_bit1;
COUNT(nmalloc);
ASSERT(WORDSIZE == ALIGN);
/* check for size that could overflow calculations */
if (size > MAX_MALLOC) {
errno = ENOMEM;
return (NULL);
}
/* make sure that size is 0 mod ALIGN */
ROUND(size);
/* see if the last free block can be used */
if (Lfree) {
sp = BLOCK(Lfree);
n = SIZE(sp);
CLRBITS01(n);
if (n == size) {
/*
* exact match, use it as is
*/
freeidx = (freeidx + FREESIZE - 1) &
FREEMASK; /* 1 back */
flist[freeidx] = Lfree = NULL;
return (DATA(sp));
} else if (size >= MINSIZE && n > size) {
/*
* got a big enough piece
*/
freeidx = (freeidx + FREESIZE - 1) &
FREEMASK; /* 1 back */
flist[freeidx] = Lfree = NULL;
o_bit1 = SIZE(sp) & BIT1;
SIZE(sp) = n;
goto leftover;
}
}
o_bit1 = 0;
/* perform free's of space since last malloc */
cleanfree(NULL);
/* small blocks */
if (size < MINSIZE)
return (_smalloc(size));
/* search for an elt of the right size */
sp = NULL;
n = 0;
if (Root) {
tp = Root;
for (;;) {
/* branch left */
if (SIZE(tp) >= size) {
if (n == 0 || n >= SIZE(tp)) {
sp = tp;
n = SIZE(tp);
}
if (LEFT(tp))
tp = LEFT(tp);
else
break;
} else { /* branch right */
if (RIGHT(tp))
tp = RIGHT(tp);
else
break;
}
}
if (sp) {
t_delete(sp);
} else if (tp != Root) {
/* make the searched-to element the root */
t_splay(tp);
Root = tp;
}
}
/* if found none fitted in the tree */
if (!sp) {
if (Bottom && size <= SIZE(Bottom)) {
sp = Bottom;
CLRBITS01(SIZE(sp));
} else if ((sp = _morecore(size)) == NULL) /* no more memory */
return (NULL);
}
/* tell the forward neighbor that we're busy */
CLRBIT1(SIZE(NEXT(sp)));
ASSERT(ISBIT0(SIZE(NEXT(sp))));
leftover:
/* if the leftover is enough for a new free piece */
if ((n = (SIZE(sp) - size)) >= MINSIZE + WORDSIZE) {
n -= WORDSIZE;
SIZE(sp) = size;
tp = NEXT(sp);
SIZE(tp) = n|BIT0;
realfree(DATA(tp));
} else if (BOTTOM(sp))
Bottom = NULL;
/* return the allocated space */
SIZE(sp) |= BIT0 | o_bit1;
return (DATA(sp));
}
void *
memalign(size_t align, size_t nbytes)
{
size_t reqsize; /* Num of bytes to get from malloc() */
TREE *p; /* Ptr returned from malloc() */
TREE *blk; /* For addressing fragment blocks */
size_t blksize; /* Current (shrinking) block size */
TREE *alignedp; /* Ptr to properly aligned boundary */
TREE *aligned_blk; /* The block to be returned */
size_t frag_size; /* size of fragments fore and aft */
size_t x;
if (!primary_link_map) {
errno = ENOTSUP;
return (NULL);
}
/*
* check for valid size and alignment parameters
* MAX_ALIGN check prevents overflow in later calculation.
*/
if (nbytes == 0 || _misaligned(align) || align == 0 ||
align > MAX_ALIGN) {
errno = EINVAL;
return (NULL);
}
/*
* Malloc enough memory to guarantee that the result can be
* aligned correctly. The worst case is when malloc returns
* a block so close to the next alignment boundary that a
* fragment of minimum size cannot be created. In order to
* make sure we can handle this, we need to force the
* alignment to be at least as large as the minimum frag size
* (MINSIZE + WORDSIZE).
*/
/* check for size that could overflow calculations */
if (nbytes > MAX_MALLOC) {
errno = ENOMEM;
return (NULL);
}
ROUND(nbytes);
if (nbytes < MINSIZE)
nbytes = MINSIZE;
ROUND(align);
while (align < MINSIZE + WORDSIZE)
align <<= 1;
reqsize = nbytes + align + (MINSIZE + WORDSIZE);
/* check for overflow */
if (reqsize < nbytes) {
errno = ENOMEM;
return (NULL);
}
p = (TREE *)malloc(reqsize);
if (p == (TREE *)NULL) {
/* malloc sets errno */
return (NULL);
}
(void) mutex_lock(&libc_malloc_lock);
/*
* get size of the entire block (overhead and all)
*/
blk = BLOCK(p); /* back up to get length word */
blksize = SIZE(blk);
CLRBITS01(blksize);
/*
* locate the proper alignment boundary within the block.
*/
x = (size_t)p;
if (x % align != 0)
x += align - (x % align);
alignedp = (TREE *)x;
aligned_blk = BLOCK(alignedp);
/*
* Check out the space to the left of the alignment
* boundary, and split off a fragment if necessary.
*/
frag_size = (size_t)aligned_blk - (size_t)blk;
if (frag_size != 0) {
/*
* Create a fragment to the left of the aligned block.
*/
if (frag_size < MINSIZE + WORDSIZE) {
/*
* Not enough space. So make the split
* at the other end of the alignment unit.
* We know this yields enough space, because
* we forced align >= MINSIZE + WORDSIZE above.
*/
frag_size += align;
aligned_blk = _nextblk(aligned_blk, align);
}
blksize -= frag_size;
SIZE(aligned_blk) = blksize | BIT0;
frag_size -= WORDSIZE;
SIZE(blk) = frag_size | BIT0 | ISBIT1(SIZE(blk));
_free_unlocked(DATA(blk));
}
/*
* Is there a (sufficiently large) fragment to the
* right of the aligned block?
*/
frag_size = blksize - nbytes;
if (frag_size >= MINSIZE + WORDSIZE) {
/*
* split and free a fragment on the right
*/
blksize = SIZE(aligned_blk);
SIZE(aligned_blk) = nbytes;
blk = NEXT(aligned_blk);
SETOLD01(SIZE(aligned_blk), blksize);
frag_size -= WORDSIZE;
SIZE(blk) = frag_size | BIT0;
_free_unlocked(DATA(blk));
}
(void) mutex_unlock(&libc_malloc_lock);
return (DATA(aligned_blk));
}
