内存释放free
Public_fREe()
void public_fREe(Void_t* mem)
{
mstate ar_ptr; mchunkptr p;
/* chunk corresponding to mem */
void (*hook) (__malloc_ptr_t, __const __malloc_ptr_t)
= force_reg (__free_hook);
if (__builtin_expect (hook != NULL, 0))
{
(*hook)(mem, RETURN_ADDRESS (0));
return;
}
如果存在__free_hook,执行hook函数。
if (mem == 0)
/* free(0) has no effect */
return;
p = mem2chunk(mem);
free NULL指针直接返回，然后根据内存指针获得chunk的指针。
#if HAVE_MMAP
if (chunk_is_mmapped(p))
/* release mmapped memory. */
{
/* see if the dynamic brk/mmap threshold needs adjusting */
if (!mp_.no_dyn_threshold
&& p->size > mp_.mmap_threshold
&& p->size <= DEFAULT_MMAP_THRESHOLD_MAX)
{
mp_.mmap_threshold = chunksize (p);
mp_.trim_threshold = 2 * mp_.mmap_threshold;
}
munmap_chunk(p);
return;
}
#endif
如果当前free的chunk是通过mmap()分配的，调用munmap_chunk()函数unmap本chunk。 munmap_chunk()函数调用 munmap()函数释放mmap()分配的内存块。同时查看是否开启了mmap分配阈值动态调整机制，默认是开启的，如果当前free的chunk的大小大于设置的mmap分配阈值，小于mmap分配阈值的最大值，将当前chunk的大小赋值给mmap分配阈值，并修改mmap收缩阈值为mmap分配阈值的2倍。默认情况下mmap分配阈值与mmap收缩阈值相等，都为128KB。
ar_ptr = arena_for_chunk(p);
根据chunk指针获得分配区的指针。
#ifdef ATOMIC_FASTBINS
_int_free(ar_ptr, p, 0);
如果开启了ATOMIC_FASTBINS优化，不需要对分配区加锁，调用_int_free()函数执行实际的释放工作。
#else
#if THREAD_STATS
if(!mutex_trylock(&ar_ptr->mutex))
++(ar_ptr->stat_lock_direct);
else
{
(void)mutex_lock(&ar_ptr->mutex);
++(ar_ptr->stat_lock_wait);
}
#else
(void)mutex_lock(&ar_ptr->mutex);
#endif
_int_free(ar_ptr, p);
(void)mutex_unlock(&ar_ptr->mutex);
#endif
}
如果没有开启了ATOMIC_FASTBINS优化，或去分配区的锁，调用_int_free()函数执行实际的释放工作，然后对分配区解锁。
_int_free()
static void
#ifdef ATOMIC_FASTBINS
_int_free(mstate av, mchunkptr p, int have_lock)
#else
_int_free(mstate av, mchunkptr p)
#endif
{
INTERNAL_SIZE_T size; /* its size */
mfastbinptr* fb; /* associated fastbin */
mchunkptr nextchunk; /* next contiguous chunk */
INTERNAL_SIZE_T nextsize; /* its size */
int nextinuse; /* true if nextchunk is used */
INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
mchunkptr bck; /* misc temp for linking */
mchunkptr fwd; /* misc temp for linking */
const char *errstr = NULL;
#ifdef ATOMIC_FASTBINS
int locked = 0;
#endif
size = chunksize(p);
获取需要释放的chunk的大小。
if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
|| __builtin_expect (misaligned_chunk (p), 0))
{
errstr = "free(): invalid pointer";
errout:
#ifdef ATOMIC_FASTBINS
if (! have_lock && locked)
(void)mutex_unlock(&av->mutex);
#endif
malloc_printerr (check_action, errstr, chunk2mem(p));
return;
}
/* We know that each chunk is at least MINSIZE bytes in size. */
if (__builtin_expect (size < MINSIZE, 0))
{
errstr = "free(): invalid size";
goto errout;
}
check_inuse_chunk(av, p);
上面的代码用于安全检查，chunk的指针地址不能溢出，chunk的大小必须是按是按 2*SIZE_SZ 对齐的且大于等于MINSIZE。
/*
If eligible, place chunk on a fastbin so it can be found
and used quickly in malloc.
*/
if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
#if TRIM_FASTBINS
/*
If TRIM_FASTBINS set, don't place chunks
bordering top into fastbins
*/
&& (chunk_at_offset(p, size) != av->top)
#endif)
{
if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize (chunk_at_offset (p, size))
>= av->system_mem, 0))
{
#ifdef ATOMIC_FASTBINS
/* We might not have a lock at this point and concurrent modifications
of system_mem might have let to a false positive. Redo the test
after getting the lock. */
if (have_lock
|| ({ assert (locked == 0);
mutex_lock(&av->mutex);
locked = 1;
chunk_at_offset (p, size)->size <= 2 * SIZE_SZ
|| chunksize (chunk_at_offset (p, size)) >= av->system_mem;
}))
#endif
{
errstr = "free(): invalid next size (fast)";
goto errout;
}
#ifdef ATOMIC_FASTBINS
if (! have_lock)
{
(void)mutex_unlock(&av->mutex);
locked = 0;
}
#endif
}
如果当前free的chunk属于fast bins，查看下一个相邻的chunk的大小是否小于等于2*SIZE_SZ，下一个相邻chunk的大小是否大于分配区所分配的内存总量，如果是，报错。
if (__builtin_expect (perturb_byte, 0))
free_perturb (chunk2mem(p), size - SIZE_SZ);
set_fastchunks(av);
unsigned int idx = fastbin_index(size);
fb = &fastbin (av, idx)；
设置当前分配区的fast bin flag，表示当前分配区的fast bins中已有空闲chunk。然后根据当前free的chunk大小获取所属的fast bin。
#ifdef ATOMIC_FASTBINS
mchunkptr fd;
mchunkptr old = *fb;
unsigned int old_idx = ~0u;
do
{
/* Another simple check: make sure the top of the bin is not the
record we are going to add (i.e., double free). */
if (__builtin_expect (old == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
if (old != NULL)
old_idx = fastbin_index(chunksize(old));
p->fd = fd = old;
}while ((old = catomic_compare_and_exchange_val_rel (fb, p, fd)) != fd);
if (fd != NULL && __builtin_expect (old_idx != idx, 0))
{
errstr = "invalid fastbin entry (free)";
goto errout;
}
如果开启了ATOMIC_FASTBINS优化，使用lock-free技术实现fast bin的单向链表插入操作。
#else
if (__builtin_expect (*fb == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
if (*fb != NULL
&& __builtin_expect (fastbin_index(chunksize(*fb)) != idx, 0))
{
errstr = "invalid fastbin entry (free)";
goto errout;
}
p->fd = *fb; *fb = p
#endif
}
如果没有开启了ATOMIC_FASTBINS优化，将free的chunk加入fast bin的单向链表中， 修改过链表表头为当前free的chunk。同时需要校验是否为double free错误，即free的chunk不能是表头的chunk。同时校验表头不为NULL情况下，保证表头chunk的所属的fast bin与当前free的chunk所属的fast bin相同。
else if (!chunk_is_mmapped(p))
{
#ifdef ATOMIC_FASTBINS
if (! have_lock)
{
# if THREAD_STATS
if(!mutex_trylock(&av->mutex))
++(av->stat_lock_direct);
else
{
(void)mutex_lock(&av->mutex);
++(av->stat_lock_wait);
}
# else
(void)mutex_lock(&av->mutex);
# endif
locked = 1;
}
#endif
如果当前 free 的 chunk 不是通过 mmap()分配的，并且当前还没有获得分配区的锁，获取分配区的锁。
nextchunk = chunk_at_offset(p, size);
获取当前 free 的 chunk 的下一个相邻的 chunk。
if (__builtin_expect (p == av->top, 0))
{
errstr = "double free or corruption (top)";
goto errout;
}
/* Or whether the next chunk is beyond the boundaries of the arena. */
if (__builtin_expect (contiguous (av)
&& (char *) nextchunk
>= ((char *) av->top + chunksize(av->top)), 0))
{
errstr = "double free or corruption (out)";
goto errout;
}
/* Or whether the block is actually not marked used. */
if (__builtin_expect (!prev_inuse(nextchunk), 0))
{
errstr = "double free or corruption (!prev)";
goto errout;
}
安全检查，当前 free 的 chunk 不能为 top chunk，因为 top chunk 为空闲 chunk，如果再次 free 就可能为double free 错误了。如果当前 free 的 chunk 是通过 sbrk()分配的，并且下一个相邻的 chunk 的地址已经超过了 top chunk 的结束地址，超过了当前分配区的结束地址，报错。如果当前 free 的 chunk 的下一个相邻 chunk
的 size 中标志位没有标识当前 free chunk 为 inuse 状态，可能为 double free 错误。
nextsize = chunksize(nextchunk);
if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (nextsize >= av->system_mem, 0))
{
errstr = "free(): invalid next size (normal)";
goto errout;
}
if (__builtin_expect (perturb_byte, 0))
free_perturb (chunk2mem(p), size - SIZE_SZ);
计算当前 free 的 chunk 的下一个相邻 chunk 的大小，该大小如果小于等于 2*SIZE_SZ 或是大于了分配区所分配区的内存总量，报错。
/* consolidate backward */
if (!prev_inuse(p))
{
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(p, bck, fwd);
}
如果当前 free 的 chunk 的前一个相邻 chunk 为空闲状态，与前一个空闲 chunk 合并。计算合并后的 chunk 大小，并将前一个相邻空闲 chunk 从空闲 chunk 链表中删除。
if (nextchunk != av->top)
{
/* get and clear inuse bit */
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
如果与当前 free 的 chunk 相邻的下一个 chunk 不是分配区的 top chunk，查看与当前 chunk 相邻的下一个 chunk 是否处于 inuse 状态。
/* consolidate forward */
if (!nextinuse)
{
unlink(nextchunk, bck, fwd);
size += nextsize;
}
else
clear_inuse_bit_at_offset(nextchunk, 0)；
如果与当前 free 的 chunk 相邻的下一个 chunk 处于 inuse 状态，清除当前 chunk 的 inuse 状态，则当前 chunk 空闲了。否则，将相邻的下一个空闲 chunk 从空闲链表中删除，并计算当前 chunk 与下一个 chunk 合并后的 chunk 大小。
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__builtin_expect (fwd->bk != bck, 0))
{
errstr = "free(): corrupted unsorted chunks";
goto errout;
}
p->fd = fwd;
p->bk = bck;
if (!in_smallbin_range(size))
{
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}
bck->fd = p;
fwd->bk = p;
将合并后的 chunk 加入 unsorted bin 的双向循环链表中。如果合并后的 chunk 属于 large bins，将 chunk 的 fd_nextsize 和 bk_nextsize 设置为 NULL。
set_head(p, size | PREV_INUSE);
set_foot(p, size);
设置合并后的空闲 chunk 大小，并标识前一个 chunk 处于 inuse 状态，因为必须保证不能有两个相邻的 chunk 都处于空闲状态。然后将合并后的 chunk 加入 unsorted bin 的双向循环链表中。最后设置合并后的空闲 chunk 的 foot，chunk 空闲时必须设置 foot，该 foot 处于下一个 chunk 的 prev_size 中，只有 chunk 空闲是 foot 才是有效的。
check_free_chunk(av, p);
}
/*
If the chunk borders the current high end of memory,
consolidate into top
*/
else
{
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
check_chunk(av, p);
}
如果当前 free 的 chunk 下一个相邻的 chunk 为 top chunk，则将当前 chunk 合并入 top chunk，修改 top chunk 的大小。
if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD)
{
if (have_fastchunks(av))
malloc_consolidate(av);
如果合并后的 chunk 大小大于 64KB，并且 fast bins 中存在空闲 chunk，调用 malloc_consolidate()函数合并 fast bins 中的空闲 chunk 到 unsorted bin 中。
if (av == &main_arena)
{
#ifndef MORECORE_CANNOT_TRIM
if ((unsigned long)(chunksize(av->top)) >=
(unsigned long)(mp_.trim_threshold))
sYSTRIm(mp_.top_pad, av);
#endif
如果当前分配区为主分配区，并且top chunk的大小大于heap的收缩阈值，调用sYSTRIm() 函数首先 heap。
else
{
/* Always try heap_trim(), even if the top chunk is not
large, because the correspo nding heap might go away. */
heap_info *heap = heap_for_ptr(top(av));
assert(heap->ar_ptr == av);
heap_trim(heap, mp_.top_pad);
}
}
如果为非主分配区，调用 heap_trim()函数收缩非主分配区的 sub_heap。
#ifdef ATOMIC_FASTBINS
if (! have_lock)
{
assert (locked);
(void)mutex_unlock(&av->mutex);
}
}
#endif
如果开启了 ATOMIC_FASTBINS 优化并获得分配区的锁，则对分配区解锁。
else
{
#if HAVE_MMAP
munmap_chunk (p);
#endif
}
}
如果当前 free 的 chunk 是通过 mmap()分配的，调用 munma_chunk()释放内存。
check
1.释放chunk的时候，chunk必须按2size_sz对齐，chunk1的大小必须大于等于MINSIZE且指针地址不能溢出。
2.释放fast bin的时候，chunk必须大于2SIZE_SZ且小于分配区所分配的内存总量。
3.释放fast bin时，检查当前free的chunk是否是fast bin中的链表头（double free），以及当前free的chunk的size要与相应的fast bin一致。
4.释放chunk的时候，chunk不能为top chunk，next chunk的地址不能超过当前分配区结束的地址，以及next chunk中chunk的inuse标志位需置1。
5.当前 free 的 chunk 的下一个相邻 chunk 的大小需要大于 2*SIZE_SZ 且小于分配区所分配区的内存总量。
6.释放的chunk通过unlink脱链，注意unlink的检查。
7.将free掉的chunk放入unsorted bin中时，有unsorted_chunks(av)->fd->bk == unsorted_chunks(av)的检查。
总结
free大致步骤：
1.判断是否有_free_hook，有则执行hook函数。
2.判断是否是mmap chunk，是则调用munmap_chunk释放（同时可能做调整阈值操作），否则调用_int_free()。
3.判断是否是fast bin，是则插入fast bin链表中（inuse值不置0）。
4.如果不是mmap chunk，判断相邻chunk是否为空闲，是就合并（top chunk除外），将合并后的chunk插入unsorted bin链表中。
5.如果跟top chunk相邻，则合并入top chunk。
6.依据heap的情况可能执行合并fast bin、收缩阈值以及收缩sub_heap等操作。
7.判断是否还存在mmap chunk，是则调用munmap_chunk释放。
二次分析后总结
1.有_free_hook运行_free_hook，没有则通过用户指针-2获得chunk的指针。
2.如果内存是通过mmap()分配的，调用munmap_chunk()函数unmap chunk，同时动态调整阈值。
3.通过size位获得chunk的大小，size的大小必须是按 2SIZE_SZ 对齐并且大于等于MINSIZE的。
4.如果size在fastbin范围内，通过chunk的size得到nextchunk的指针，并通过nextchunk的size域判断nextchunk的size不能小于等于2SIZE_SZ，不能大于等于分配区所分配的内存总量。
5.根据chunk的size获得fastbin对应的idx，根据idx获得fastbin对应的表头，这里要保证free的chunk不能是fastbin表头的chunk，同时保证表头chunk对应的idx与free chunk对应的idx相同。这时就将free chunk插入到表头，通过fd指针链接原来的表头chunk。
6.如果chunk不是mmap分配的，通过size获得nextchunk的指针，这里保证free chunk不能是top chunk，nextchunk不能超过当前分配区的地址，并且nextchunk中的prev_size位不能为0。
7.通过nextchunk的size位获得nextchunk的大小，保证nextchunk的大小在2*SIZE_SZ和分配区所分配的内存总量之间。
8.通过prev_size位判断前一个chunk为空闲，则合并，通过prev_size获得新的chunk的指针，并将前一个chunk从空闲链表中脱链。
9.通过下下个chunk的inuse位判断nextchunk是否处于空闲状态，如果处于是使用状态，则将nextchunk里的inuse置0，即表明当前chunk空闲，如果nextchunk处于空闲状态，且nextchunk不是topchunk，则将nextchunk脱链，合并到chunk中。
10.将chunk加入到unsortedbin双向循环链表的头部，并设置对应指针，注意这里在chunk加入之前必须保证unsorted bin成环的。
11.设置合并后的空闲chunk大小，并标识前一个chunk处于inuse状态，再设置设置合并后的空闲chunk的foot。
12.如果nextchunk为top chunk，合并到top chunk中，并修改相应的size和标志位
13.依据heap的情况可能执行合并fast bin、收缩阈值以及收缩sub_heap等操作。
内容来源
《glibc内存管理ptmalloc源码分析》