逐步分解#

1. 函数声明与参数

• 函数名为 checked_request2size，接受两个参数：size_t req 和 size_t *sz，其中 req 是用户请求的内存大小，sz 是指向调整后的内存大小的指针。

• __nonnull (1) 是一个 GCC 属性，用于告诉编译器 req 参数不能为 NULL，这在函数内部可以减少对 NULL 的检查，提高代码执行效率。

2. 检查请求大小是否溢出

• if (__glibc_unlikely (req > PTRDIFF_MAX)) 检查请求的内存大小是否超过了 PTRDIFF_MAX。

• 如果超过，说明请求的内存大小太大，可能会导致后续的计算溢出，因此函数返回 false，表示这个请求不能被处理。

3. 处理内存标记的情况

• if (__glibc_unlikely (mtag_enabled)) 检查内存标记是否被启用。

• 如果内存标记被启用，需要确保分配的内存块大小是根据内存标记的粒度大小（__MTAG_GRANULE_SIZE）对齐的。这是因为内存标记会占用额外的空间，如果空间不按粒度对齐，会导致内存地址错误。

• req = (req + (__MTAG_GRANULE_SIZE - 1)) & ~(size_t)(__MTAG_GRANULE_SIZE - 1); 这行代码的作用是将请求的内存大小向上调整到最近的 __MTAG_GRANULE_SIZE 的倍数。具体而言，它首先将请求的内存大小加上 __MTAG_GRANULE_SIZE - 1，然后通过按位与操作清除小于 __MTAG_GRANULE_SIZE 的位，从而得到对齐后的内存大小。

4. 调整内存大小

• *sz = request2size (req); 调用 request2size 函数将调整后的请求内存大小转换为实际可分配的内存块大小，并存储到 sz 指向的变量中。

• request2size 是一个宏，用于将请求的内存大小加上头信息大小（SIZE_SZ）和内存对齐要求（MALLOC_ALIGN_MASK），并确保最终的内存大小至少为 MINSIZE，同时是 MALLOC_ALIGNMENT 的倍数。

5. 返回结果

• 如果请求的内存大小未超过 PTRDIFF_MAX，且成功调整内存大小，函数返回 true，表示可以处理这个请求。

主要功能总结#

• 内存大小检查：确保用户请求的内存大小不会导致后续计算溢出。

• 内存对齐处理：根据内存标记的需求调整内存块大小，确保其满足对齐要求。

• 内存大小调整：将请求的内存大小转换为实际可分配的内存块大小。

总之，checked_request2size 函数的主要目的是确保用户请求的内存大小既安全又符合内存分配器的需求，在处理内存分配请求之前对其进行必要的检查和调整。

代码分解与解释#

1. 检查下一个chunk的prev_size字段是否与当前chunk的size字段一致

  c   if (chunksize (p) != prev_size (next_chunk (p)))       malloc_printerr ("corrupted size vs. prev_size");   

  - chunksize(p) 获取当前chunk p 的大小（不包括使用位）。
  - next_chunk(p) 计算并获取下一个相邻的chunk。
  - prev_size(next_chunk(p)) 获取下一个chunk的 prev_size 字段，该字段应该存储的是当前chunk的大小。
  - 如果这两个值不一致，说明内存块损坏或者数据结构被错误地修改了，此时调用 malloc_printerr 输出错误信息。

2. 检查当前chunk是否在双向链表中

  c   if (__builtin_expect (fd->bk != p || bk->fd != p, 0))       malloc_printerr ("corrupted double-linked list");   

  - p->fd 是当前chunk的“下一个chunk指针”，p->bk 是“前一个chunk指针”。
  - fd 和 bk 分别是 p->fd 和 p->bk 的别名。
  - 通过检查 fd->bk 是否等于 p，以及 bk->fd 是否等于 p，验证当前chunk是否正确地存在于一个双向链表中。
  - 如果 fd->bk != p 或 bk->fd != p，则表示内存块的双向链表连接被破坏，同样调用 malloc_printerr 输出错误信息。

3. 从双向链表中移除当前chunk

  c   fd->bk = bk;   bk->fd = fd;   

  - 将当前chunk p 的前一个chunk fd 的“下一个chunk指针”指向 p 的后一个chunk bk。
  - 将 p 的后一个chunk bk 的“前一个chunk指针”指向 p 的前一个chunk fd。u
  - 这样就完成了从双向链表中移除当前chunk p 的操作。  

4. 检查并处理大块内存的链表

  ```c
  if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
  {
    if (p->fd_nextsize->bk_nextsize != p
        || p->bk_nextsize->fd_nextsize != p)
      malloc_printerr (“corrupted double-linked list (not small)”);

    if (fd->fd_nextsize == NULL)
    {
      if (p->fd_nextsize == p)
        fd->fd_nextsize = fd->bk_nextsize = fd;
      else
      {
        fd->fd_nextsize = p->fd_nextsize;
        fd->bk_nextsize = p->bk_nextsize;
        p->fd_nextsize->bk_nextsize = fd;
        p->bk_nextsize->fd_nextsize = fd;
      }
    }
    else
    {
      p->fd_nextsize->bk_nextsize = p->bk_nextsize;
      p->bk_nextsize->fd_nextsize = p->fd_nextsize;
    }
  }
  ```

  - in_smallbin_range(chunksize_nomask(p)) 检查当前chunk是否属于小块内存的范围（如果chunk的大小包含使用位也不影响判断）。从
  - 如果chunk不是小块内存，而是大块内存，并且 p->fd_nextsize 不为NULL（这表示当前chunk在大块内存的链表中），则进行额外的检查和操作。
  - p->fd_nextsize->bk_nextsize != p 和 p->bk_nextsize->fd_nextsize != p 用于验证大块内存链表的完整性。）
  - 如果链表头 fd 的 fd_nextsize 为NULL，表示当前chunk就是大块内存链表的头，需要特殊处理以重新建立链表头。
  - 如果链表头不为NULL，则进行常规的出链表操作，将 p 的前后节点重新连接起来，移除 p。处

总结#

这段代码的主要功能是从一个双向链表中移除一个自由内存块。在移除之前，代码会进行一系列的检查，确保chunk的数据结构没有被破坏，从而保证内存管理的安全性和准确性。具体来说：  

• 验证当前chunk的 size 字段与下一个chunk的 prev_size 字段是否匹配。码
• 检查当前chunk是否正确地存在于一个双向链表中。p
• 如果chunk属于大块内存范围，还会额外检查大块内存链表的完整性，并进行相应的出链表操作。检
• 如果检查发现任何问题，代码会通过 malloc_printerr 输出错误信息，这有助于调试和检测内存损坏。

⚠️ 在unlink后，unlink的chunk的fd和bk并未发生改变。

逐步分解与详细解释#

总结#

malloc_state 结构体是 glibc 中用于管理内存分配器状态的核心数据结构。它负责存储当前可用的最大内存块（top）、最近一次小请求分割后剩余的内存块（last_remainder）、普通 bin（bins）和 fastbin（fas tbinsY）等信息。同时，malloc_state 结构体还支持多线程环境下的序列化访问，确保多个线程可以安全地使用同一个 arena。一

逐步分解与详细解释#

static void *  
sysmalloc_mmap (INTERNAL_SIZE_T nb, size_t pagesize, int extra_flags, mstate av)  

if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)  
   size = ALIGN_UP (nb + SIZE_SZ, pagesize);  
else  
   size = ALIGN_UP (nb + SIZE_SZ + MALLOC_ALIGN_MASK, pagesize);  

if ((unsigned long) (size) <= (unsigned long) (nb))  
   return MAP_FAILED;  

char *mm = (char *) MMAP (0, size, mtag_mmap_flags | PROT_READ | PROT_WRITE, extra_flags);  
if (mm == MAP_FAILED)  
   return mm;  

#ifdef MAP_HUGETLB  
if (!(extra_flags & MAP_HUGETLB))    
   madvise_thp (mm, size);  
#endif  

INTERNAL_SIZE_T front_misalign;  
if (MALLOC_ALIGNMENT == CHUNK_HDR_SZ)  
   {  
     assert (((INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK) == 0);  
     front_misalign = 0;  
   }  
else  
   front_misalign = (INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK;  

if (front_misalign > 0)    
   {  
     ptrdiff_t correction = MALLOC_ALIGNMENT - front_misalign;  
     p = (mchunkptr) (mm + correction);  
     set_prev_size (p, correction);  
     set_head (p, (size - correction) | IS_MMAPPED);  
   }  
else  
   {  
     p = (mchunkptr) mm;  
     set_prev_size (p, 0);  
     set_head (p, size | IS_MMAPPED);  
   }  

int new = atomic_exchange_and_add (&mp_.n_mmaps, 1) + 1;  
atomic_max (&mp_.max_n_mmaps, new);  
  
unsigned long sum;  
sum = atomic_exchange_and_add (&mp_.mmapped_mem, size) + size;  
atomic_max (&mp_.max_mmapped_mem, sum);  

check_chunk (av, p);  

return chunk2mem (p);  

总结#

__int_malloc的原型#

static void * _int_malloc (mstate av, size_t bytes)

• mstate av：malloc所分配内存所在的arena
• size_t bytes：malloc所分配内存的大小

变量申请#

INTERNAL_SIZE_T nb; /* 标准化请求大小 */
unsigned int idx; /* associated bin index */
mbinptr bin; /* 关联的 bin 索引 */

mchunkptr victim; /* 检查/选定的块 */
INTERNAL_SIZE_T size; /* 选定块的大小 */
int victim_index; /* 选定块的bin的索引 */

mchunkptr remainder; /* 分割后的剩余部分 */
unsigned long remainder_size; /* 剩余部分大小 */

unsigned int block; /* 位图遍历器 */
unsigned int bit; /* 位图遍历器 */
unsigned int map; /* current word of binmap */

mchunkptr fwd; /* 链接用，前一个块 */
mchunkptr bck; /* 连接用，后一个块 */

前置检查#

• 检查请求大小是否合理#

if (!checked_request2size (bytes, &nb))
{
	__set_errno (ENOMEM);
	return NULL;
}

checked_request2size(bytes, &nb)：这是一个函数调用，用于将用户请求分配的内存大小bytes转换为内部使用的形式nb。这个转换包括增加一些必要的开销（例如，SIZE_SZ字节的开销用于存储块的大小信息）以及确保请求大小已经对齐到必要的边界（例如，为了满足内存对齐要求，请求的大小可能会被向上调整）。此外，这个函数还会检查请求的大小是否合理，即不会因为增加开销和对齐而导致内存请求大小溢出。如果请求的大小不合理，函数将返回false。

• 检查arena是否可用#

if (__glibc_unlikely (av == NULL))
	{
		void *p = sysmalloc (nb, av);
		if (p != NULL)
	alloc_perturb (p, bytes);
		return p;
	}

如果没有可用的arena，av == NULL，那么退回到sysmalloc去mmap一个chunk，进行打乱后返回这个块的指针。

alloc_perturb函数的目的是为了在分配的内存块中写入一些特定的值，以帮助在调试过程中检测到使用未初始化内存的情况。这个操作通常被称为“内存打乱”或“内存污染”，其目的是确保分配的内存块不会包含残留的旧数据，从而帮助开发者更早地发现潜在的错误。

Fastbin部分#

Fastbins[idx=0,hold_size=00-0x18,size=0x20] 
Fastbins[idx=1,hold_size=0x19-0x28,size=0x30] 
Fastbins[idx=2,hold_size=0x29-0x38,size=0x40] 
Fastbins[idx=3,hold_size=0x39-0x48,size=0x50] 
Fastbins[idx=4,hold_size=0x49-0x58,size=0x60] 
Fastbins[idx=5,hold_size=0x59-0x68,size=0x70] 
Fastbins[idx=6,hold_size=0x69-0x78,size=0x80]

#define REMOVE_FB(fb, victim, pp)    \
do   \
	{    \
		victim = pp;    \
		if (victim == NULL);    \
break;    \
		pp = REVEAL_PTR(victim -> fd);    \
		if (__glibc_unlikely (pp != NULL && misaligned_chunk (pp)))    \
malloc_printerr("malloc(): unaligned fastbin chunk detected");     \
	}     \
while ((pp = catomic_compare_and_exchange_val_acq (fb, pp, victim))     \
	!= victim);    \  

if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
		{
	//得到对应fb的下标
		idx = fastbin_index(nb);
	//得到对应fb链表的头指针
		mfastbinptr *fb = &fastbin (av, idx);
	//遍历用指针
		mchunkptr pp;
	//选中的chunk
		victim = *fb
		//如果victim可用，进行移除操作
		if (victim != NULL)
	{
		//检查是否对齐
		if (__glibc_unlikely ( misaligned_chunk(victim)))
			malloc_printerr ("malloc(): unaligned fastbin chunk detected 2");
		//单线程时正确管理
		if (SINGLE_THREAD_P)
			*fb = REVEAL_PTR (victim -> fd);
		else
			REMOVE_FB(fb , pp, victim);
		//取出内存后，对内存进行二次检查
		if (__glibc_likely (victim != NULL))
			{
			size_t victim_idx = fastbin_index (chunksize (victim));
			//如果victim_idx与检查的idx不一致，说明内存损坏，直接报错
			if (__builtin_expect (victim_idx != idx, 0))
		malloc_printerr ("malloc(): memory corruption (fast)");
			check_remalloced_chunk (av, victim, nb);
			void *p = chunk2mem (victim);
			alloc_perturb (p, bytes);
			return p;
			}
	}
		}

SmallBin部分#

• Smallbin介绍#

Small Bin中chunk大小的计算如下

chunk_size = 2 * SIZE_SZ * index

• Smallbin相关#

if (in_small_bin_range (nb))
	{
		//获取 small bin的
		idx = smallbin_index (nb);
		//获取bin中chunk的指针
		bin = bin_at(av, idx);
		//考察链表中最后一个bin，如果相等，则该bin为空
		//如果不为空，进行以下操作
		if ((victim = last (bin)) != bin)
			{
			//获取倒数第二个chunk
			bck = victim -> bk;
	if (__glibc_unlikely (bck -> fd != victim))//检查链表是否完整，是否被伪造
		malloc_printerr ("malloc(): smallbin double linked list corrupted");
			//设置victim对应的inuse位，表示取出了该chunk
			set_inuse_bit_at_offset (victim, nb);
			//取出最后一个chunk
			bin -> bk = bck;
			bin -> fd = bin;
			//非mainarena标志设置
			if (av != &main_arena)
		set_non_main_arena (victim);
			check_malloced_chunk (av, victim, nb);
			void *p = chunk2mem (victim);
			alloc_perturb (p, bytes);
			return p;
			}
	}

首先判断请求的内存大小是否属于smallbin的范围，如果是，则找到对应的小bin，并从中取出最后一个可用的内存块作为分配的内存块。然后，代码会检查该内存块的完整性，并将其从链表中移除。最后，代码会设置分配的内存块的使用位，并验证内存块的正确性。

Not Fast Or Small?#

如果用户申请的大小Fastbin和Smallbin都不满足，程序就会考虑Largebin。但并没有直接去遍历Largebin，而是先利用malloc_consolidate处理Fastbin中的所有chunk，能够合并的合并放入unsortedbin，不能合并的直接放进去，然后在大循环中处理unsortedbin的部分。

为什么不直接从相应的 bin 中取出 large chunk 呢？这是 ptmalloc 的机制，它会在分配 large chunk 之前对堆中碎片 chunk 进行合并，以便减少堆中的碎片

else
	{
	idx = largebin_index(nb);
	if (atomic_load_relaxed (&av -> have_fastchunks))
		malloc_consolidate(av);
	}

遍历Unsorted Bin#

程序执行到这里说明用户申请的chunk大小Fastbin和Smallbin都不满足，在整理了内存碎片后，程序进入这个大循环。

• 按照FIFO的顺序逐个遍历unsortedbin中的chunk

  • 如果是small request，考虑是否满足需求，如果是，则返回该chunk
  • 如果不是，就放入相应大小的bin中

• 尝试从largebin中分配用户所需的内存

• Unsorted Bin遍历 - 前置检查#

for (;;)
	{
		int iters = 0;
	//如果UnsortedBin不为空，进入while循环
		while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
			{
				bck = victim -> bk; //victim为unsortedbin最后一个chunk，bck为倒数第二
				size = chunksize (victim); //victim的大小
				mchunkptr next = chunk_at_offset (victim, size); //获取下一个chunk
				//接下来是判断获取的chunk是否满足要求
				if (__glibc_unlikely (size <= CHUNK_HDR_SZ)
					|| __glibc_unlikely (size > av->system_mem))
				//检查当前chunk的大小是否有效
				//检查当前chunk的大小是否小于或等于chunk头的大小
				//检查当前chunk的大小是否大于arena
				malloc_printerr ("malloc(): invalid size (unsorted)");
				if (__glibc_unlikely (chunksize_nomask (next) < CHUNK_HDR_SZ)
					|| __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
				//检查next chunk的大小（去除mask后）是否小于chunk头的大小。
				//检查next chunk的大小（去除mask后）是否大于arena总的系统内存大小。
				malloc_printerr ("malloc(): invalid next size (unsorted)");
				if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
				//获取next chunk的前一个chunk的大小，并去除SIZE_BITS
				//检查next chunk的前一个chunk的大小是否与当前chunk的大小匹配。
				malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");
				if (__glibc_unlikely (bck->fd != victim)
					|| __glibc_unlikely (victim->fd != unsorted_chunks (av)))
				//检查当前chunk的前一个chunk的fd字段是否指向当前chunk。
				//检查当前chunk的fd字段是否指向unsorted bin的头。
				malloc_printerr ("malloc(): unsorted double linked list corrupted");
				if (__glibc_unlikely (prev_inuse (next)))
				//检查next chunk的前一个chunk是否被标记为已使用
				malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");
			}
	}

• Unsorted Bin遍历 - Small Request#

if (in_smallbin_range (nb) && //用户申请的大小命中smallbin
	bck == unsorted_chunks (av) && //检查victim是unsortedbin中的一个chunk
	victim == av -> last_remainder && //检查当前内存块是否是最近分配内存块的剩余
	//检查victim是否可以被分割
	(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
	{
		//计算分割后的大小
		remainder_size = size - nb;
		//分割small request chunk
		remainder = chunk_at_offset (victim, nb);
		//将分割出来的块纳入链表
		unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
		//更新last remainder
		av->last_remainder = remainder;
		//维护remainder的链表
		remainder->bk = remainder->fd = unsorted_chunks (av);
		//如果分割后的remainder不在smallbin中，则维护其在largebin的链表
		if (!in_smallbin_range (remainder_size))
			{
				remainder -> fd_nextsize = NULL;
				remainder -> bk_nextsize = NULL;
			}
		//设置chuck header
		set_head (victim, nb | PREV_INUSE |
				(av != &main_areana ? NON_MAIN_ARENA : 0));
		set_head (remainder, remainder_size | PREV_INUSE);
		set_foot (remainder, remainder_size)

		check_malloced_chunk (av, victim, nb);
		void *p = chunk2mem (victim);
		alloc_perturb (p, bytes);
		return p;
	}

• Unsorted Bin遍历 - 初始取出#

//检查链表完整性
if (__glibc_unlikely (bck->fd != victim))
	malloc_printerr ("malloc(): corrupted unsorted chunks 3");
//移除victim
unsorted_chunk (av) -> bk = bck; 
bck -> fd = unsorted_chunk ; 

• Unsorted Bin遍历 - Exact Fit#

//恰好合适的情况，直接取出
if (size == nb)
	{
		set_inuse_bit_at_offset (victim, size);
		if (av != &main_arena)
	set_non_main_arena (victim);
		check_malloced_chunk (av, victim, nb);
		void *p = chunk2mem (victim);
		alloc_perturb (p, bytes);
		return p;
	}

• Unsorted Bin遍历 - Place Chunk In Bin#

//取用的chunk命中smallbin范围时
if (in_smallbin_range (size))
	{
		victim_index = smallbin_index (size);
		bck = bin_at (av, victim_index);
		fwd = bck->fd;
	}

//否则，在Largebin
else
	{
		//放入Large Bin中
		victim_index = largebin_index (size);
		bck = bin_at (av, victim_index);
		fwd = bck->fd;
		//如果LargeBin不为空
		if (fwd != bck)
			{
				//加速比较，应该不仅仅有这个考虑，因为链表里的 chunk 都会设置该位。
				size |= PREV_INUSE;
				//bck->bk 存储着相应 large bin 中最小的chunk。
				//如果遍历的chunk比当前最小的chunk还要小，直接插入尾部
				//判断是否在main_arena
				assert (chunk_main_arena (bck->bk));
				if ((unsigned long) (size)
			< (unsigned long) chunksize_nomask (bck->bk))
				{
					//令fwd指向largebin头部
					fwd = bck;
					//令 bck 指向 largin bin 尾部 chunk
					bck = bck -> bk;

					//插入victim到链表尾部
					victim->fd_nextsize = fwd->fd;
					victim->bk_nextsize = fwd->fd->bk_nextsize;
					fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
				}
				else //当前要插入的 victim 的大小大于最小的 chunk
				{
					assert (chunk_main_arena (fwd));
					//从链表头部开始找到不比 victim 大的 chunk
					while ((unsigned long) size < chunksize_nomask (fwd))
					{
						fwd = fwd->fd_nextsize;
					assert (chunk_main_arena (fwd));
					}

					if ((unsigned long) size  //如果找到了一个和 victim 一样大的 chunk，
					//那就直接将 chunk 插入到该chunk的后面，并不修改 nextsize 指针。
				== (unsigned long) chunksize_nomask (fwd))
					fwd = fwd->fd;
					else //如果找到的chunk和当前victim大小不一样
					{
						//那么就需要构造 nextsize 双向链表了
						victim->fd_nextsize = fwd;
						victim->bk_nextsize = fwd->bk_nextsize;
						//检查双向链表完整性
						if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
							malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
						fwd->bk_nextsize = victim;
						victim->bk_nextsize->fd_nextsize = victim;
					}
					bck = fwd->bk;
					if (bck->fd != fwd) //检查bck和fwd是否匹配
						malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
						
				}
			}
		else  //如果空的话，直接简单使得 fd_nextsize 与 bk_nextsize 构成一个双向链表即可。
			victim->fd_nextsize = victim->bk_nextsize = victim;
	}

• Unsorted Bin遍历 - 最终取出#

//构成bck <-> victim <-> fwd
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;

Large Chunk部分#

如果请求的 chunk 在 large chunk 范围内，就在对应的 bin 中从小到大进行扫描，找到第一个合适的。

//如果请求的chunk在large chunk部分，则进入判断
if (!in_smallbin_range(nb))
	{
		bin = bin_at (av, idx)
		// 如果对应的 bin 为空或者其中的chunk最大的也很小，那就跳过
		// first(bin)=bin->fd 表示当前链表中最大的chunk
		if ((victim = first (bin)) != bin //这行代码检查链表是否为空
	&& (unsigned long) chunksize_nomask (victim)
		>= (unsigned long) (nb)) // 这行代码检查链表中第一个内存块的大小是否大于或等于请求的内存大小
			{
				victim = victim -> bk_nextsize;
				//反向遍历链表，直到找到第一个不小于所需chunk大小的chunk
				while (((unsigned long) (size = chunksize (victim)) <
					(unsigned long) (nb)))
				victim = victim->bk_nextsize;
				//如果最终取到的chunk不是该bin中的最后一个chunk，并且该chunk与其前面的chunk
				//的大小相同，那么我们就取其前面的chunk，这样可以避免调整bk_nextsize,fd_nextsize
				//链表。因为大小相同的chunk只有一个会被串在nextsize链上。
				if (victim != last (bin)
				&& chunksize_nomask (victim)
				== chunksize_nomask (victim->fd))
					victim = victim->fd;

				remainder_size = size - nb;
				//取出
				unlink_chunk (av, victim);
				// 剩余不足以当作一个chunk
				// 直接使用整个victim，不进行分割
				if (remainder_size < MINSIZE)
					set_inuse_bit_at_offset (victim, size);
					if (av != &main_arena)
				set_non_main_arena (victim);
				//分割的情况
				else
					{
						//获取剩余的指针
						remainder = chunk_at_offset (victim, nb);
						//插入unsortedbin
						bck = unsorted_chunks (av);
						fwd = bck->fd;
						// 判断 unsorted bin 是否被破坏。
					if (__glibc_unlikely (fwd->bk != bck))
						malloc_printerr ("malloc(): corrupted unsorted chunks");
						remainder->bk = bck;
						remainder->fd = fwd;
						bck->fd = remainder;
						fwd->bk = remainder;
						// LargeChunk的情况
						if (!in_smallbin_range (remainder_size))
							{
								remainder->fd_nextsize = NULL;
								remainder->bk_nextsize = NULL;
							}
						set_head (victim, nb | PREV_INUSE |
							(av != &main_arena ? NON_MAIN_ARENA : 0));
						set_head (remainder, remainder_size | PREV_INUSE);
						set_foot (remainder, remainder_size);
					}
				check_malloced_chunk (av, victim, nb);
				void *p = chunk2mem (victim);
				alloc_perturb (p, bytes);
				return p;
			}
	}

• 寻找较大chunk#

++idx; 
bin = bin_at(av, idx);//获取对应的bin
block = idx2block(idx);//Binmap按block管理，每个block为一个int，共32个bit，可以表示32个bin中是否有空闲chunk存在
map = av->binmap[block];
bit = idx2bit (idx);

  

for (;; )

找到一个合适的map

//如果bit>map，则表示该 map 中没有比当前所需要chunk大的空闲块
//如果bit为0，那么说明，上面idx2bit带入的参数为0。
if (bit > map || bit == 0)
	{
		do
			{
			//寻找下一个block，直到其对应的map不为0。如果已经不存在的话，那就只能使用top chunk了
				if (++block >= BINMAPSIZE)
					goto use_top;
			}
		while ((map = av->binmap[block]) == 0);
		bin = bin_at (av, (block << BINMAPSHIFT));
		bit = 1;
	}

找到合适的bin

// 从当前map的最小的bin一直找，直到找到合适的bin。 
// 这里是一定存在的 
while ((bit & map) == 0) 
	{ 
		bin = next_bin(bin); 
		bit <<= 1; 
		assert(bit != 0); 
	}

检查并取出chunk

victim = last (bin);
if (victim == bin)
	{
		av->binmap[block] = map &= ~bit; /* Write through */
		bin = next_bin (bin);
		bit <<= 1;
	}
else
	{
		size = chunksize (victim);
		/* We know the first chunk in this bin is big enough to use. */
		assert ((unsigned long) (size) >= (unsigned long) (nb));

		remainder_size = size - nb;

		unlink_chunk (av, victim);

		/* Exhaust */
		if (remainder_size < MINSIZE)
			{
				set_inuse_bit_at_offset (victim, size);
				if (av != &main_arena)
			set_non_main_arena (victim);
			}

		else
			{
				remainder = chunk_at_offset (victim, nb);

				bck = unsorted_chunks (av);

				fwd = bck->fd;

		if (__glibc_unlikely (fwd->bk != bck))

			malloc_printerr ("malloc(): corrupted unsorted chunks 2");

				remainder->bk = bck;

				remainder->fd = fwd;

				bck->fd = remainder;

				fwd->bk = remainder;

  

/* advertise as last remainder */

				if (in_smallbin_range (nb))

					av->last_remainder = remainder;

				if (!in_smallbin_range (remainder_size))
					{
						remainder->fd_nextsize = NULL;
						remainder->bk_nextsize = NULL;
					}
				set_head (victim, nb | PREV_INUSE |
				(av != &main_arena ? NON_MAIN_ARENA : 0));
				set_head (remainder, remainder_size | PREV_INUSE);
				set_foot (remainder, remainder_size);
			}
		check_malloced_chunk (av, victim, nb);
		void *p = chunk2mem (victim);
		alloc_perturb (p, bytes);
		return p;
	}

使用 Top Chunk#

如果所有的 bin 中的 chunk 都没有办法直接满足要求（即不合并），或者说都没有空闲的 chunk。那么我们就只能使用 top chunk 了。

use_top:
	//获取当前的topchunk计算大小
	victim = av->top;
	size = chunksize(victim);
	//检查内存是否正确
	if (__glibc_unlikely (size > av->system_mem))
		malloc_printerr ("malloc(): corrupted top size");
	//如果分割后top chunk 大小仍然满足 chunk 的最小大小，那么就可以直接进行分割。
	if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
		{
			//计算剩余大小
			remainder_size = size -nb;
			//获取剩余指针
			remainder = chunk_at_offset(victim, nb);
			//更新top指针
			av->top = remainder;
			set_head (victim, nb | PREV_INUSE |
			(av != &main_arena ? NON_MAIN_ARENA : 0));
			set_head (remainder, remainder_size | PREV_INUSE);

			check_malloced_chunk (av, victim, nb);
			void *p = chunk2mem (victim);
			alloc_perturb(p, bytes);
			return p;
		}
	//清理内存碎片
	else if (atomic_load_relaxed (&av->have_fastchunks))
		{
			malloc_consolidate (av);
			if (in_smallbin_range (nb))
				idx = smallbin_index (nb);
			else
				idx = largebin_index (nb);
		}
	//堆内存不够时，sysmalloc申请到libc上
	else
		{
			void *p = sysmalloc (nb , av);
			if(p != NULL)
				alloc_perturb (p, bytes);
			return p;
		}