內存釋放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源碼分析》