diff options
Diffstat (limited to 'malloc/hooks.c')
| -rw-r--r-- | malloc/hooks.c | 648 |
1 files changed, 354 insertions, 294 deletions
diff --git a/malloc/hooks.c b/malloc/hooks.c index 1b80a74e28..00ee6bec8c 100644 --- a/malloc/hooks.c +++ b/malloc/hooks.c @@ -24,29 +24,29 @@ /* Hooks for debugging versions. The initial hooks just call the initialization routine, then do the normal work. */ -static void* -malloc_hook_ini(size_t sz, const void *caller) +static void * +malloc_hook_ini (size_t sz, const void *caller) { __malloc_hook = NULL; - ptmalloc_init(); - return __libc_malloc(sz); + ptmalloc_init (); + return __libc_malloc (sz); } -static void* -realloc_hook_ini(void* ptr, size_t sz, const void *caller) +static void * +realloc_hook_ini (void *ptr, size_t sz, const void *caller) { __malloc_hook = NULL; __realloc_hook = NULL; - ptmalloc_init(); - return __libc_realloc(ptr, sz); + ptmalloc_init (); + return __libc_realloc (ptr, sz); } -static void* -memalign_hook_ini(size_t alignment, size_t sz, const void *caller) +static void * +memalign_hook_ini (size_t alignment, size_t sz, const void *caller) { __memalign_hook = NULL; - ptmalloc_init(); - return __libc_memalign(alignment, sz); + ptmalloc_init (); + return __libc_memalign (alignment, sz); } /* Whether we are using malloc checking. */ @@ -71,10 +71,11 @@ static int disallow_malloc_check; void __malloc_check_init (void) { - if (disallow_malloc_check) { - disallow_malloc_check = 0; - return; - } + if (disallow_malloc_check) + { + disallow_malloc_check = 0; + return; + } using_malloc_checking = 1; __malloc_hook = malloc_check; __free_hook = free_check; @@ -87,7 +88,7 @@ __malloc_check_init (void) overruns. The goal here is to avoid obscure crashes due to invalid usage, unlike in the MALLOC_DEBUG code. */ -#define MAGICBYTE(p) ( ( ((size_t)p >> 3) ^ ((size_t)p >> 11)) & 0xFF ) +#define MAGICBYTE(p) ((((size_t) p >> 3) ^ ((size_t) p >> 11)) & 0xFF) /* Visualize the chunk as being partitioned into blocks of 256 bytes from the highest address of the chunk, downwards. The beginning of each block tells @@ -96,53 +97,58 @@ __malloc_check_init (void) must reach it with this iteration, otherwise we have witnessed a memory corruption. */ static size_t -malloc_check_get_size(mchunkptr p) +malloc_check_get_size (mchunkptr p) { size_t size; unsigned char c; - unsigned char magic = MAGICBYTE(p); + unsigned char magic = MAGICBYTE (p); - assert(using_malloc_checking == 1); + assert (using_malloc_checking == 1); - for (size = chunksize(p) - 1 + (chunk_is_mmapped(p) ? 0 : SIZE_SZ); - (c = ((unsigned char*)p)[size]) != magic; - size -= c) { - if(c<=0 || size<(c+2*SIZE_SZ)) { - malloc_printerr(check_action, "malloc_check_get_size: memory corruption", - chunk2mem(p)); - return 0; + for (size = chunksize (p) - 1 + (chunk_is_mmapped (p) ? 0 : SIZE_SZ); + (c = ((unsigned char *) p)[size]) != magic; + size -= c) + { + if (c <= 0 || size < (c + 2 * SIZE_SZ)) + { + malloc_printerr (check_action, "malloc_check_get_size: memory corruption", + chunk2mem (p)); + return 0; + } } - } /* chunk2mem size. */ - return size - 2*SIZE_SZ; + return size - 2 * SIZE_SZ; } /* Instrument a chunk with overrun detector byte(s) and convert it into a user pointer with requested size sz. */ -static void* +static void * internal_function -mem2mem_check(void *ptr, size_t sz) +mem2mem_check (void *ptr, size_t sz) { mchunkptr p; - unsigned char* m_ptr = ptr; + unsigned char *m_ptr = ptr; size_t i; if (!ptr) return ptr; - p = mem2chunk(ptr); - for(i = chunksize(p) - (chunk_is_mmapped(p) ? 2*SIZE_SZ+1 : SIZE_SZ+1); - i > sz; - i -= 0xFF) { - if(i-sz < 0x100) { - m_ptr[i] = (unsigned char)(i-sz); - break; + + p = mem2chunk (ptr); + for (i = chunksize (p) - (chunk_is_mmapped (p) ? 2 * SIZE_SZ + 1 : SIZE_SZ + 1); + i > sz; + i -= 0xFF) + { + if (i - sz < 0x100) + { + m_ptr[i] = (unsigned char) (i - sz); + break; + } + m_ptr[i] = 0xFF; } - m_ptr[i] = 0xFF; - } - m_ptr[sz] = MAGICBYTE(p); - return (void*)m_ptr; + m_ptr[sz] = MAGICBYTE (p); + return (void *) m_ptr; } /* Convert a pointer to be free()d or realloc()ed to a valid chunk @@ -150,53 +156,64 @@ mem2mem_check(void *ptr, size_t sz) static mchunkptr internal_function -mem2chunk_check(void* mem, unsigned char **magic_p) +mem2chunk_check (void *mem, unsigned char **magic_p) { mchunkptr p; INTERNAL_SIZE_T sz, c; unsigned char magic; - if(!aligned_OK(mem)) return NULL; - p = mem2chunk(mem); - if (!chunk_is_mmapped(p)) { - /* Must be a chunk in conventional heap memory. */ - int contig = contiguous(&main_arena); - sz = chunksize(p); - if((contig && - ((char*)p<mp_.sbrk_base || - ((char*)p + sz)>=(mp_.sbrk_base+main_arena.system_mem) )) || - sz<MINSIZE || sz&MALLOC_ALIGN_MASK || !inuse(p) || - ( !prev_inuse(p) && (p->prev_size&MALLOC_ALIGN_MASK || - (contig && (char*)prev_chunk(p)<mp_.sbrk_base) || - next_chunk(prev_chunk(p))!=p) )) - return NULL; - magic = MAGICBYTE(p); - for(sz += SIZE_SZ-1; (c = ((unsigned char*)p)[sz]) != magic; sz -= c) { - if(c<=0 || sz<(c+2*SIZE_SZ)) return NULL; + if (!aligned_OK (mem)) + return NULL; + + p = mem2chunk (mem); + if (!chunk_is_mmapped (p)) + { + /* Must be a chunk in conventional heap memory. */ + int contig = contiguous (&main_arena); + sz = chunksize (p); + if ((contig && + ((char *) p < mp_.sbrk_base || + ((char *) p + sz) >= (mp_.sbrk_base + main_arena.system_mem))) || + sz < MINSIZE || sz & MALLOC_ALIGN_MASK || !inuse (p) || + (!prev_inuse (p) && (p->prev_size & MALLOC_ALIGN_MASK || + (contig && (char *) prev_chunk (p) < mp_.sbrk_base) || + next_chunk (prev_chunk (p)) != p))) + return NULL; + + magic = MAGICBYTE (p); + for (sz += SIZE_SZ - 1; (c = ((unsigned char *) p)[sz]) != magic; sz -= c) + { + if (c <= 0 || sz < (c + 2 * SIZE_SZ)) + return NULL; + } } - } else { - unsigned long offset, page_mask = GLRO(dl_pagesize)-1; - - /* mmap()ed chunks have MALLOC_ALIGNMENT or higher power-of-two - alignment relative to the beginning of a page. Check this - first. */ - offset = (unsigned long)mem & page_mask; - if((offset!=MALLOC_ALIGNMENT && offset!=0 && offset!=0x10 && - offset!=0x20 && offset!=0x40 && offset!=0x80 && offset!=0x100 && - offset!=0x200 && offset!=0x400 && offset!=0x800 && offset!=0x1000 && - offset<0x2000) || - !chunk_is_mmapped(p) || (p->size & PREV_INUSE) || - ( (((unsigned long)p - p->prev_size) & page_mask) != 0 ) || - ( (sz = chunksize(p)), ((p->prev_size + sz) & page_mask) != 0 ) ) - return NULL; - magic = MAGICBYTE(p); - for(sz -= 1; (c = ((unsigned char*)p)[sz]) != magic; sz -= c) { - if(c<=0 || sz<(c+2*SIZE_SZ)) return NULL; + else + { + unsigned long offset, page_mask = GLRO (dl_pagesize) - 1; + + /* mmap()ed chunks have MALLOC_ALIGNMENT or higher power-of-two + alignment relative to the beginning of a page. Check this + first. */ + offset = (unsigned long) mem & page_mask; + if ((offset != MALLOC_ALIGNMENT && offset != 0 && offset != 0x10 && + offset != 0x20 && offset != 0x40 && offset != 0x80 && offset != 0x100 && + offset != 0x200 && offset != 0x400 && offset != 0x800 && offset != 0x1000 && + offset < 0x2000) || + !chunk_is_mmapped (p) || (p->size & PREV_INUSE) || + ((((unsigned long) p - p->prev_size) & page_mask) != 0) || + ((sz = chunksize (p)), ((p->prev_size + sz) & page_mask) != 0)) + return NULL; + + magic = MAGICBYTE (p); + for (sz -= 1; (c = ((unsigned char *) p)[sz]) != magic; sz -= c) + { + if (c <= 0 || sz < (c + 2 * SIZE_SZ)) + return NULL; + } } - } - ((unsigned char*)p)[sz] ^= 0xFF; + ((unsigned char *) p)[sz] ^= 0xFF; if (magic_p) - *magic_p = (unsigned char *)p + sz; + *magic_p = (unsigned char *) p + sz; return p; } @@ -205,32 +222,32 @@ mem2chunk_check(void* mem, unsigned char **magic_p) static int internal_function -top_check(void) +top_check (void) { - mchunkptr t = top(&main_arena); - char* brk, * new_brk; + 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))) + 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; + 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)) + 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; @@ -238,128 +255,148 @@ top_check(void) /* Call the `morecore' hook if necessary. */ void (*hook) (void) = atomic_forced_read (__after_morecore_hook); if (hook) - (*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); + top (&main_arena) = (mchunkptr) (brk + front_misalign); + set_head (top (&main_arena), (sbrk_size - front_misalign) | PREV_INUSE); return 0; } -static void* -malloc_check(size_t sz, const void *caller) +static void * +malloc_check (size_t sz, const void *caller) { void *victim; - if (sz+1 == 0) { - __set_errno (ENOMEM); - return NULL; - } + if (sz + 1 == 0) + { + __set_errno (ENOMEM); + return NULL; + } - (void)mutex_lock(&main_arena.mutex); - victim = (top_check() >= 0) ? _int_malloc(&main_arena, sz+1) : NULL; - (void)mutex_unlock(&main_arena.mutex); - return mem2mem_check(victim, sz); + (void) mutex_lock (&main_arena.mutex); + victim = (top_check () >= 0) ? _int_malloc (&main_arena, sz + 1) : NULL; + (void) mutex_unlock (&main_arena.mutex); + return mem2mem_check (victim, sz); } static void -free_check(void* mem, const void *caller) +free_check (void *mem, const void *caller) { mchunkptr p; - if(!mem) return; - (void)mutex_lock(&main_arena.mutex); - p = mem2chunk_check(mem, NULL); - if(!p) { - (void)mutex_unlock(&main_arena.mutex); - - malloc_printerr(check_action, "free(): invalid pointer", mem); + if (!mem) return; - } - if (chunk_is_mmapped(p)) { - (void)mutex_unlock(&main_arena.mutex); - munmap_chunk(p); - return; - } - _int_free(&main_arena, p, 1); - (void)mutex_unlock(&main_arena.mutex); + + (void) mutex_lock (&main_arena.mutex); + p = mem2chunk_check (mem, NULL); + if (!p) + { + (void) mutex_unlock (&main_arena.mutex); + + malloc_printerr (check_action, "free(): invalid pointer", mem); + return; + } + if (chunk_is_mmapped (p)) + { + (void) mutex_unlock (&main_arena.mutex); + munmap_chunk (p); + return; + } + _int_free (&main_arena, p, 1); + (void) mutex_unlock (&main_arena.mutex); } -static void* -realloc_check(void* oldmem, size_t bytes, const void *caller) +static void * +realloc_check (void *oldmem, size_t bytes, const void *caller) { INTERNAL_SIZE_T nb; - void* newmem = 0; + void *newmem = 0; unsigned char *magic_p; - if (bytes+1 == 0) { - __set_errno (ENOMEM); - return NULL; - } - if (oldmem == 0) return malloc_check(bytes, NULL); - if (bytes == 0) { - free_check (oldmem, NULL); - return NULL; - } - (void)mutex_lock(&main_arena.mutex); - const mchunkptr oldp = mem2chunk_check(oldmem, &magic_p); - (void)mutex_unlock(&main_arena.mutex); - if(!oldp) { - malloc_printerr(check_action, "realloc(): invalid pointer", oldmem); - return malloc_check(bytes, NULL); - } - const INTERNAL_SIZE_T oldsize = chunksize(oldp); - - checked_request2size(bytes+1, nb); - (void)mutex_lock(&main_arena.mutex); - - if (chunk_is_mmapped(oldp)) { + if (bytes + 1 == 0) + { + __set_errno (ENOMEM); + return NULL; + } + if (oldmem == 0) + return malloc_check (bytes, NULL); + + if (bytes == 0) + { + free_check (oldmem, NULL); + return NULL; + } + (void) mutex_lock (&main_arena.mutex); + const mchunkptr oldp = mem2chunk_check (oldmem, &magic_p); + (void) mutex_unlock (&main_arena.mutex); + if (!oldp) + { + malloc_printerr (check_action, "realloc(): invalid pointer", oldmem); + return malloc_check (bytes, NULL); + } + const INTERNAL_SIZE_T oldsize = chunksize (oldp); + + checked_request2size (bytes + 1, nb); + (void) mutex_lock (&main_arena.mutex); + + if (chunk_is_mmapped (oldp)) + { #if HAVE_MREMAP - mchunkptr newp = mremap_chunk(oldp, nb); - if(newp) - newmem = chunk2mem(newp); - else + mchunkptr newp = mremap_chunk (oldp, nb); + if (newp) + newmem = chunk2mem (newp); + else #endif - { - /* Note the extra SIZE_SZ overhead. */ - if(oldsize - SIZE_SZ >= nb) - newmem = oldmem; /* do nothing */ - else { - /* Must alloc, copy, free. */ - if (top_check() >= 0) - newmem = _int_malloc(&main_arena, bytes+1); - if (newmem) { - memcpy(newmem, oldmem, oldsize - 2*SIZE_SZ); - munmap_chunk(oldp); - } + { + /* Note the extra SIZE_SZ overhead. */ + if (oldsize - SIZE_SZ >= nb) + newmem = oldmem; /* do nothing */ + else + { + /* Must alloc, copy, free. */ + if (top_check () >= 0) + newmem = _int_malloc (&main_arena, bytes + 1); + if (newmem) + { + memcpy (newmem, oldmem, oldsize - 2 * SIZE_SZ); + munmap_chunk (oldp); + } + } } } - } else { - if (top_check() >= 0) { - INTERNAL_SIZE_T nb; - checked_request2size(bytes + 1, nb); - newmem = _int_realloc(&main_arena, oldp, oldsize, nb); + else + { + if (top_check () >= 0) + { + INTERNAL_SIZE_T nb; + checked_request2size (bytes + 1, nb); + newmem = _int_realloc (&main_arena, oldp, oldsize, nb); + } } - } /* mem2chunk_check changed the magic byte in the old chunk. If newmem is NULL, then the old chunk will still be used though, so we need to invert that change here. */ - if (newmem == NULL) *magic_p ^= 0xFF; + if (newmem == NULL) + *magic_p ^= 0xFF; - (void)mutex_unlock(&main_arena.mutex); + (void) mutex_unlock (&main_arena.mutex); - return mem2mem_check(newmem, bytes); + return mem2mem_check (newmem, bytes); } -static void* -memalign_check(size_t alignment, size_t bytes, const void *caller) +static void * +memalign_check (size_t alignment, size_t bytes, const void *caller) { - void* mem; + void *mem; + + if (alignment <= MALLOC_ALIGNMENT) + return malloc_check (bytes, NULL); - if (alignment <= MALLOC_ALIGNMENT) return malloc_check(bytes, NULL); - if (alignment < MINSIZE) alignment = MINSIZE; + if (alignment < MINSIZE) + alignment = MINSIZE; /* If the alignment is greater than SIZE_MAX / 2 + 1 it cannot be a power of 2 and will cause overflow in the check below. */ @@ -377,17 +414,19 @@ memalign_check(size_t alignment, size_t bytes, const void *caller) } /* Make sure alignment is power of 2. */ - if (!powerof2(alignment)) { - size_t a = MALLOC_ALIGNMENT * 2; - while (a < alignment) a <<= 1; - alignment = a; - } - - (void)mutex_lock(&main_arena.mutex); - mem = (top_check() >= 0) ? _int_memalign(&main_arena, alignment, bytes+1) : - NULL; - (void)mutex_unlock(&main_arena.mutex); - return mem2mem_check(mem, bytes); + if (!powerof2 (alignment)) + { + size_t a = MALLOC_ALIGNMENT * 2; + while (a < alignment) + a <<= 1; + alignment = a; + } + + (void) mutex_lock (&main_arena.mutex); + mem = (top_check () >= 0) ? _int_memalign (&main_arena, alignment, bytes + 1) : + NULL; + (void) mutex_unlock (&main_arena.mutex); + return mem2mem_check (mem, bytes); } @@ -408,59 +447,63 @@ memalign_check(size_t alignment, size_t bytes, const void *caller) then the hooks are reset to 0. */ #define MALLOC_STATE_MAGIC 0x444c4541l -#define MALLOC_STATE_VERSION (0*0x100l + 4l) /* major*0x100 + minor */ - -struct malloc_save_state { - long magic; - long version; - mbinptr av[NBINS * 2 + 2]; - char* sbrk_base; - int sbrked_mem_bytes; +#define MALLOC_STATE_VERSION (0 * 0x100l + 4l) /* major*0x100 + minor */ + +struct malloc_save_state +{ + long magic; + long version; + mbinptr av[NBINS * 2 + 2]; + char *sbrk_base; + int sbrked_mem_bytes; unsigned long trim_threshold; unsigned long top_pad; - unsigned int n_mmaps_max; + unsigned int n_mmaps_max; unsigned long mmap_threshold; - int check_action; + int check_action; unsigned long max_sbrked_mem; unsigned long max_total_mem; - unsigned int n_mmaps; - unsigned int max_n_mmaps; + unsigned int n_mmaps; + unsigned int max_n_mmaps; unsigned long mmapped_mem; unsigned long max_mmapped_mem; - int using_malloc_checking; + int using_malloc_checking; unsigned long max_fast; unsigned long arena_test; unsigned long arena_max; unsigned long narenas; }; -void* -__malloc_get_state(void) +void * +__malloc_get_state (void) { - struct malloc_save_state* ms; + struct malloc_save_state *ms; int i; mbinptr b; - ms = (struct malloc_save_state*)__libc_malloc(sizeof(*ms)); + ms = (struct malloc_save_state *) __libc_malloc (sizeof (*ms)); if (!ms) return 0; - (void)mutex_lock(&main_arena.mutex); - malloc_consolidate(&main_arena); + + (void) mutex_lock (&main_arena.mutex); + malloc_consolidate (&main_arena); ms->magic = MALLOC_STATE_MAGIC; ms->version = MALLOC_STATE_VERSION; ms->av[0] = 0; ms->av[1] = 0; /* used to be binblocks, now no longer used */ - ms->av[2] = top(&main_arena); + ms->av[2] = top (&main_arena); ms->av[3] = 0; /* used to be undefined */ - for(i=1; i<NBINS; i++) { - b = bin_at(&main_arena, i); - if(first(b) == b) - ms->av[2*i+2] = ms->av[2*i+3] = 0; /* empty bin */ - else { - ms->av[2*i+2] = first(b); - ms->av[2*i+3] = last(b); + for (i = 1; i < NBINS; i++) + { + b = bin_at (&main_arena, i); + if (first (b) == b) + ms->av[2 * i + 2] = ms->av[2 * i + 3] = 0; /* empty bin */ + else + { + ms->av[2 * i + 2] = first (b); + ms->av[2 * i + 3] = last (b); + } } - } ms->sbrk_base = mp_.sbrk_base; ms->sbrked_mem_bytes = main_arena.system_mem; ms->trim_threshold = mp_.trim_threshold; @@ -475,78 +518,92 @@ __malloc_get_state(void) ms->mmapped_mem = mp_.mmapped_mem; ms->max_mmapped_mem = mp_.max_mmapped_mem; ms->using_malloc_checking = using_malloc_checking; - ms->max_fast = get_max_fast(); + ms->max_fast = get_max_fast (); ms->arena_test = mp_.arena_test; ms->arena_max = mp_.arena_max; ms->narenas = narenas; - (void)mutex_unlock(&main_arena.mutex); - return (void*)ms; + (void) mutex_unlock (&main_arena.mutex); + return (void *) ms; } int -__malloc_set_state(void* msptr) +__malloc_set_state (void *msptr) { - struct malloc_save_state* ms = (struct malloc_save_state*)msptr; + struct malloc_save_state *ms = (struct malloc_save_state *) msptr; size_t i; mbinptr b; disallow_malloc_check = 1; - ptmalloc_init(); - if(ms->magic != MALLOC_STATE_MAGIC) return -1; + ptmalloc_init (); + if (ms->magic != MALLOC_STATE_MAGIC) + return -1; + /* Must fail if the major version is too high. */ - if((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl)) return -2; - (void)mutex_lock(&main_arena.mutex); + if ((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl)) + return -2; + + (void) mutex_lock (&main_arena.mutex); /* There are no fastchunks. */ - clear_fastchunks(&main_arena); + clear_fastchunks (&main_arena); if (ms->version >= 4) - set_max_fast(ms->max_fast); + set_max_fast (ms->max_fast); else - set_max_fast(64); /* 64 used to be the value we always used. */ - for (i=0; i<NFASTBINS; ++i) + set_max_fast (64); /* 64 used to be the value we always used. */ + for (i = 0; i < NFASTBINS; ++i) fastbin (&main_arena, i) = 0; - for (i=0; i<BINMAPSIZE; ++i) + for (i = 0; i < BINMAPSIZE; ++i) main_arena.binmap[i] = 0; - top(&main_arena) = ms->av[2]; + top (&main_arena) = ms->av[2]; main_arena.last_remainder = 0; - for(i=1; i<NBINS; i++) { - b = bin_at(&main_arena, i); - if(ms->av[2*i+2] == 0) { - assert(ms->av[2*i+3] == 0); - first(b) = last(b) = b; - } else { - if(ms->version >= 3 && - (i<NSMALLBINS || (largebin_index(chunksize(ms->av[2*i+2]))==i && - largebin_index(chunksize(ms->av[2*i+3]))==i))) { - first(b) = ms->av[2*i+2]; - last(b) = ms->av[2*i+3]; - /* Make sure the links to the bins within the heap are correct. */ - first(b)->bk = b; - last(b)->fd = b; - /* Set bit in binblocks. */ - mark_bin(&main_arena, i); - } else { - /* Oops, index computation from chunksize must have changed. - Link the whole list into unsorted_chunks. */ - first(b) = last(b) = b; - b = unsorted_chunks(&main_arena); - ms->av[2*i+2]->bk = b; - ms->av[2*i+3]->fd = b->fd; - b->fd->bk = ms->av[2*i+3]; - b->fd = ms->av[2*i+2]; - } + for (i = 1; i < NBINS; i++) + { + b = bin_at (&main_arena, i); + if (ms->av[2 * i + 2] == 0) + { + assert (ms->av[2 * i + 3] == 0); + first (b) = last (b) = b; + } + else + { + if (ms->version >= 3 && + (i < NSMALLBINS || (largebin_index (chunksize (ms->av[2 * i + 2])) == i && + largebin_index (chunksize (ms->av[2 * i + 3])) == i))) + { + first (b) = ms->av[2 * i + 2]; + last (b) = ms->av[2 * i + 3]; + /* Make sure the links to the bins within the heap are correct. */ + first (b)->bk = b; + last (b)->fd = b; + /* Set bit in binblocks. */ + mark_bin (&main_arena, i); + } + else + { + /* Oops, index computation from chunksize must have changed. + Link the whole list into unsorted_chunks. */ + first (b) = last (b) = b; + b = unsorted_chunks (&main_arena); + ms->av[2 * i + 2]->bk = b; + ms->av[2 * i + 3]->fd = b->fd; + b->fd->bk = ms->av[2 * i + 3]; + b->fd = ms->av[2 * i + 2]; + } + } } - } - if (ms->version < 3) { - /* Clear fd_nextsize and bk_nextsize fields. */ - b = unsorted_chunks(&main_arena)->fd; - while (b != unsorted_chunks(&main_arena)) { - if (!in_smallbin_range(chunksize(b))) { - b->fd_nextsize = NULL; - b->bk_nextsize = NULL; - } - b = b->fd; + if (ms->version < 3) + { + /* Clear fd_nextsize and bk_nextsize fields. */ + b = unsorted_chunks (&main_arena)->fd; + while (b != unsorted_chunks (&main_arena)) + { + if (!in_smallbin_range (chunksize (b))) + { + b->fd_nextsize = NULL; + b->bk_nextsize = NULL; + } + b = b->fd; + } } - } mp_.sbrk_base = ms->sbrk_base; main_arena.system_mem = ms->sbrked_mem_bytes; mp_.trim_threshold = ms->trim_threshold; @@ -560,28 +617,31 @@ __malloc_set_state(void* msptr) mp_.mmapped_mem = ms->mmapped_mem; mp_.max_mmapped_mem = ms->max_mmapped_mem; /* add version-dependent code here */ - if (ms->version >= 1) { - /* Check whether it is safe to enable malloc checking, or whether - it is necessary to disable it. */ - if (ms->using_malloc_checking && !using_malloc_checking && - !disallow_malloc_check) - __malloc_check_init (); - else if (!ms->using_malloc_checking && using_malloc_checking) { - __malloc_hook = NULL; - __free_hook = NULL; - __realloc_hook = NULL; - __memalign_hook = NULL; - using_malloc_checking = 0; + if (ms->version >= 1) + { + /* Check whether it is safe to enable malloc checking, or whether + it is necessary to disable it. */ + if (ms->using_malloc_checking && !using_malloc_checking && + !disallow_malloc_check) + __malloc_check_init (); + else if (!ms->using_malloc_checking && using_malloc_checking) + { + __malloc_hook = NULL; + __free_hook = NULL; + __realloc_hook = NULL; + __memalign_hook = NULL; + using_malloc_checking = 0; + } } - } - if (ms->version >= 4) { - mp_.arena_test = ms->arena_test; - mp_.arena_max = ms->arena_max; - narenas = ms->narenas; - } - check_malloc_state(&main_arena); - - (void)mutex_unlock(&main_arena.mutex); + if (ms->version >= 4) + { + mp_.arena_test = ms->arena_test; + mp_.arena_max = ms->arena_max; + narenas = ms->narenas; + } + check_malloc_state (&main_arena); + + (void) mutex_unlock (&main_arena.mutex); return 0; } |