/* ------------------------- __malloc_trim -------------------------
__malloc_trim is an inverse of sorts to __malloc_alloc. It gives memory
back to the system (via negative arguments to sbrk) if there is unused
memory at the `high' end of the malloc pool. It is called automatically by
free() when top space exceeds the trim threshold. It is also called by the
public malloc_trim routine. It returns 1 if it actually released any
memory, else 0.
*/
static int __malloc_trim(size_t pad, mstate av)
{
long top_size; /* Amount of top-most memory */
long extra; /* Amount to release */
long released; /* Amount actually released */
char* current_brk; /* address returned by pre-check sbrk call */
char* new_brk; /* address returned by post-check sbrk call */
size_t pagesz;
pagesz = av->pagesize;
top_size = chunksize(av->top);
/* Release in pagesize units, keeping at least one page */
extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
if (extra > 0) {
/*
Only proceed if end of memory is where we last set it.
This avoids problems if there were foreign sbrk calls.
*/
current_brk = (char*)(MORECORE(0));
if (current_brk == (char*)(av->top) + top_size) {
/*
Attempt to release memory. We ignore MORECORE return value,
and instead call again to find out where new end of memory is.
This avoids problems if first call releases less than we asked,
of if failure somehow altered brk value. (We could still
encounter problems if it altered brk in some very bad way,
but the only thing we can do is adjust anyway, which will cause
some downstream failure.)
*/
MORECORE(-extra);
new_brk = (char*)(MORECORE(0));
if (new_brk != (char*)MORECORE_FAILURE) {
released = (long)(current_brk - new_brk);
if (released != 0) {
/* Success. Adjust top. */
av->sbrked_mem -= released;
set_head(av->top, (top_size - released) | PREV_INUSE);
check_malloc_state();
return 1;
}
}
}
}
return 0;
}
static int
internal_function
top_check(void)
{
mchunkptr t = top(&main_arena);
char* brk, * new_brk;
INTERNAL_SIZE_T front_misalign, sbrk_size;
unsigned long pagesz = GLRO(dl_pagesize);
if (t == initial_top(&main_arena) ||
(!chunk_is_mmapped(t) &&
chunksize(t)>=MINSIZE &&
prev_inuse(t) &&
(!contiguous(&main_arena) ||
(char*)t + chunksize(t) == mp_.sbrk_base + main_arena.system_mem)))
return 0;
malloc_printerr (check_action, "malloc: top chunk is corrupt", t);
/* Try to set up a new top chunk. */
brk = MORECORE(0);
front_misalign = (unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK;
if (front_misalign > 0)
front_misalign = MALLOC_ALIGNMENT - front_misalign;
sbrk_size = front_misalign + mp_.top_pad + MINSIZE;
sbrk_size += pagesz - ((unsigned long)(brk + sbrk_size) & (pagesz - 1));
new_brk = (char*)(MORECORE (sbrk_size));
if (new_brk == (char*)(MORECORE_FAILURE))
{
__set_errno (ENOMEM);
return -1;
}
/* Call the `morecore' hook if necessary. */
void (*hook) (void) = force_reg (__after_morecore_hook);
if (hook)
(*hook) ();
main_arena.system_mem = (new_brk - mp_.sbrk_base) + sbrk_size;
top(&main_arena) = (mchunkptr)(brk + front_misalign);
set_head(top(&main_arena), (sbrk_size - front_misalign) | PREV_INUSE);
return 0;
}
int munmap(void *start, int length)
{
#ifndef ONLY_MSPACES
if( (cur_heap_pos - length) < HEAP_START)
{
return -1;
}
else
{
cur_heap_pos -= length;
return 0;
}
#else
if (MORECORE(-length) == ((void *)-1) )
return -1;
else
return 0;
#endif
}
/*
*
* This function is called by the dlmalloc.c module with
* following parameters:
* start = 0
* prot = PROT_READ | PROT_WRITE
* flags = MMAP_ANONYMOUS | MMAP_PRIVATE
* fd = -1
* offset = 0
*
* length is the only relevant (variable) parameter and it
* specifies the requested memory size.
*/
void *mmap(void *start, int length,
int prot, int flags, int fd, int offset)
{
#ifndef ONLY_MSPACES
if(length == 0)
{
cur_heap_pos = (void *) HEAP_START;
}
if ( (cur_heap_pos + length) <= (void *) HEAP_END )
{
void *heap_pos = cur_heap_pos;
cur_heap_pos += length;
return heap_pos;
} else {
//errno = ENOMEM;
return (void *)-1;
}
return (void *) -1;
#else
return MORECORE(length);
#endif
}
