glibc2.23堆源码解读

libc2.23

采用glibc2.23的源码，故没有libc2.32的Tcache。主要从_int_malloc以及_int_free两个函数进行解读。

Malloc

static void *
_int_malloc (mstate av, size_t bytes){//参数为指针av，与申请空间bytes
  INTERNAL_SIZE_T nb;               /* normalized request size */
  unsigned int idx;                 /* associated bin index */
  mbinptr bin;                      /* associated bin */

  mchunkptr victim;                 /* inspected/selected chunk */
  INTERNAL_SIZE_T size;             /* its size */
  int victim_index;                 /* its bin index */

  mchunkptr remainder;              /* remainder from a split */
  unsigned long remainder_size;     /* its size */

  unsigned int block;               /* bit map traverser */
  unsigned int bit;                 /* bit map traverser */
  unsigned int map;                 /* current word of binmap */

  mchunkptr fwd;                    /* misc temp for linking */
  mchunkptr bck;                    /* misc temp for linking */
//定义基础变量
  const char *errstr = NULL;

  /*
通过添加SIZE_SZ字节将请求大小转换为内部形式
开销加上可能更多，以获得必要的对齐和/或
要获得至少MINSIZE的大小，请使用最小的可分配
大小此外，checked_request2size陷阱（返回0）请求大小
这是如此之大，以至于当填充和
对齐的。
   */

  checked_request2size (bytes, nb);//检测bytes大小，并赋值到nb上.且经历request2size函数（该函数作用为附加上chunk头的bytes）
//此时nb为内核态的chunk大小
  /* There are no usable arenas.  Fall back to sysmalloc to get a chunk from
     mmap.  */
  if (__glibc_unlikely (av == NULL))//如果指针av为空，调用该函数
    {
      void *p = sysmalloc (nb, av);//调用内核函数申请空间
      if (p != NULL)
	alloc_perturb (p, bytes);//对内存进行初始化，内含memset函数
      return p;//返回指针p
    }

  /*
尺寸符合快速箱子的要求，首先检查相应的箱子。
即使av尚未初始化，此代码也可以安全执行，因此我们
可以不用检查就可以尝试，这样可以在快速路径上节省一些时间。
   */

  if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))//如果nb小于最大fastbin的maxsize话，则申请fast大小的chunk
    {
      idx = fastbin_index (nb);//读取nb所在链队的序号赋值到idx
      mfastbinptr *fb = &fastbin (av, idx);//取出fastbin链中的元素
      mchunkptr pp = *fb;//将指针fb封装成结构体
      do
        {
          victim = pp;//将pp赋值到victim
          if (victim == NULL)//如果为空跳出循环
            break;
        }
      while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
             != victim);//进行原子比较
      if (victim != 0)//通过原子比较
        {
          if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))//此时再次进行比较bytes是否与最开始的idx序列号相等
            {
              errstr = "malloc(): memory corruption (fast)";
            errout:
              malloc_printerr (check_action, errstr, chunk2mem (victim), av);//执行报错函数
              return NULL;//返回NULL
            }
          check_remalloced_chunk (av, victim, nb);//检查chunk
          void *p = chunk2mem (victim);//将大小转换为用户态大小的指针
          alloc_perturb (p, bytes);//对其进行初始化
          return p;//返回指针
        }
    }

  /*
如果有小请求，请检查常规垃圾箱。因为这些“小箱子”
每种尺寸保持一个，无需在箱子内搜索。
（对于大型请求，我们需要等待未排序的块被删除
经过处理以找到最合适的。但对于小的，适合是准确的
无论如何，我们现在可以检查一下，哪个更快。）
   */

  if (in_smallbin_range (nb))//判断大小nb是否存在于smallbin链的范围内
    {
      idx = smallbin_index (nb);//返回nb处于smallbin中的序列号
      bin = bin_at (av, idx);

      if ((victim = last (bin)) != bin)//判断bin的后继与bin是否相等
        {
          if (victim == 0) /* initialization check */   //不相等
            malloc_consolidate (av);//将fastbin中的空闲chunk合并整理到unsorted_bin中以及进行初始化堆的工作
          else
            {
              bck = victim->bk;
	if (__glibc_unlikely (bck->fd != victim))//如果此时发现与刚开始的bk后继不相等报错
                {
                  errstr = "malloc(): smallbin double linked list corrupted";
                  goto errout;//跳转到报错函数
                }
              set_inuse_bit_at_offset (victim, nb);//设置标记位
              bin->bk = bck;
              bck->fd = bin;//将victim从bin链中摘除掉，即返回给用户chunk

              if (av != &main_arena)//如果av不存在于main_arena中，设置标记位
                victim->size |= NON_MAIN_ARENA;
              check_malloced_chunk (av, victim, nb);//检测chunk
              void *p = chunk2mem (victim);//将指针转换位用户态指针
              alloc_perturb (p, bytes);//初始化chunk
              return p;//返回指针
            }
        }
    }

  /*
如果这是一个大请求，请在继续之前合并fastbins。
虽然之前杀掉所有的快速垃圾箱看起来有些过分
即使看到是否有可用空间，这也可以避免
通常与fastbins相关的碎片问题。
此外，在实践中，程序往往会有小规模或小规模的运行
请求量大，但混合请求的频率较低，因此不需要整合
在大多数程序中经常调用这些函数。以及
它在中经常被调用，否则会变得支离破碎。
  */

  else //进入largebin中
    {
      idx = largebin_index (nb);//判断nb处于largebin中的序列号
      if (have_fastchunks (av))//返回值为1，表示存在fastbin
        malloc_consolidate (av);//进行堆的consolidate，合并
    }

  /*
处理最近释放或剩余的块，仅当
它是完全合适的，或者，如果这是一个小请求，则该块是来自
最近的非精确拟合。将其他遍历的块放入
箱子。请注意，此步骤是任何例程中唯一需要块放在箱子里。
这里需要外部循环，因为我们可能直到
在malloc快结束的时候，我们本应该合并的，所以必须合并
执行此操作并重试。这种情况最多发生一次，而且只有在我们愿意的时候才会发生
否则需要扩展内存以满足“小”请求。
   */

  for (;; )//进入大循环
    {
      int iters = 0;
      while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))//存在unsorted_bin则进入循环
        {
          bck = victim->bk;
          if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
              || __builtin_expect (victim->size > av->system_mem, 0))
            malloc_printerr (check_action, "malloc(): memory corruption",
                             chunk2mem (victim), av);//进入报错函数
          size = chunksize (victim);//获取chunk大小

          /*
		如果是小请求，请尝试使用最后的余数（如果是
		只有未排序的存储箱中的块。这有助于促进地方性
		连续小请求的运行。这是唯一的
		最佳拟合的例外情况，仅在存在
		不适合一小块。        
	     */

          if (in_smallbin_range (nb) &&
              bck == unsorted_chunks (av) &&
              victim == av->last_remainder &&
              (unsigned long) (size) > (unsigned long) (nb + MINSIZE))//判断是否满足切割条件，切割last_remainder
            {
              /* 拆分并重新连接剩余部分 */
              remainder_size = size - nb;//修改remainder的size大小
              remainder = chunk_at_offset (victim, nb);//修改remainder的指针
              unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
              av->last_remainder = remainder;
              remainder->bk = remainder->fd = unsorted_chunks (av);
              if (!in_smallbin_range (remainder_size))//如果不在smallbin范围中，则执行以下语句
                {
                  remainder->fd_nextsize = NULL;
                  remainder->bk_nextsize = NULL;
                }

              set_head (victim, nb | PREV_INUSE |
                        (av != &main_arena ? NON_MAIN_ARENA : 0));//设置victim的标记位
              set_head (remainder, remainder_size | PREV_INUSE);//设置remainder标记位
              set_foot (remainder, remainder_size);//设置remainder的大小

              check_malloced_chunk (av, victim, nb);//检测chunk
              void *p = chunk2mem (victim);//转换为用户所使用的指针，隐藏头部信息
              alloc_perturb (p, bytes);//初始化chunk
              return p;//返回指针
            }

          /* 从未排序的列表中删除 */
          unsorted_chunks (av)->bk = bck;//修改unsorted_bin链中的节点
          bck->fd = unsorted_chunks (av);//即从unsorted_bin链中删除victim

          /* 如果完全合适，请立即服用，而不是装箱 */

          if (size == nb)//如果size与申请nb大小相等
            {
              set_inuse_bit_at_offset (victim, size);//设置使用inuse标志位
              if (av != &main_arena)//如果victim不存在main_arena中
                victim->size |= NON_MAIN_ARENA;//设置N标志位
              check_malloced_chunk (av, victim, nb);//检测chunk
              void *p = chunk2mem (victim);//转换为用户所使用的指针，隐藏头部信息
              alloc_perturb (p, bytes);//初始化chunk
              return p;//返回指针
            }

          /* 将块放入垃圾箱中 */

          if (in_smallbin_range (size))//如果处于smallbin链范围大小之中，则放入smallbin中
            {
              victim_index = smallbin_index (size);
              bck = bin_at (av, victim_index);
              fwd = bck->fd;
            }
          else//否则处于largebin链范围中，则放入largebin中
            {
              victim_index = largebin_index (size);
              bck = bin_at (av, victim_index);
              fwd = bck->fd;//为bck的前驱结点

              /* maintain large bins in sorted order */
              if (fwd != bck)//表明链表中存在不只一个chunk
                {
                  /* 或使用位速度比较 */
                  size |= PREV_INUSE;
                  /* 如果小于最小值，则旁路回路位于下方 */
                  assert ((bck->bk->size & NON_MAIN_ARENA) == 0);//判断N标记位是否为0，即判断chunk是否位于main_arena中
                  if ((unsigned long) (size) < (unsigned long) (bck->bk->size))//如果发现满足该条件，说明该chunk可直接填充到largebin中
                    {
                      fwd = bck;
                      bck = bck->bk;

                      victim->fd_nextsize = fwd->fd;
                      victim->bk_nextsize = fwd->fd->bk_nextsize;
                      fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
                    }
                  else//否则需要循环判断插入位置
                    {
                      assert ((fwd->size & NON_MAIN_ARENA) == 0);//判断chunk是否位于main_arena中
                      while ((unsigned long) size < fwd->size)//循环判断放入链表中位置
                        {
                          fwd = fwd->fd_nextsize;//判断victim应处于的位置
                          assert ((fwd->size & NON_MAIN_ARENA) == 0);//判断chunk是否位于main_arena中
                        }

                      if ((unsigned long) size == (unsigned long) fwd->size)//如果恰巧相等
                        /* 始终插入第二个位置  */
                        fwd = fwd->fd;
                      else
                        {
                          victim->fd_nextsize = fwd;
                          victim->bk_nextsize = fwd->bk_nextsize;
                          fwd->bk_nextsize = victim;
                          victim->bk_nextsize->fd_nextsize = victim;//进行拼接链表
                        }
                      bck = fwd->bk;
                    }
                }
              else//此时表明该链表中只存在一个chunk
                victim->fd_nextsize = victim->bk_nextsize = victim;//直接放入chunk即可
            }

          mark_bin (av, victim_index);
          victim->bk = bck;
          victim->fd = fwd;
          fwd->bk = victim;
          bck->fd = victim;//重新构造链表

#define MAX_ITERS       10000
          if (++iters >= MAX_ITERS)
            break;
        }

      /*
		如果请求较大，请扫描中的当前bin块
		按顺序排序以找到适合的最小值。为此使用跳过列表。
       */

      if (!in_smallbin_range (nb))//如果nb不存在smallbin范围中
        {
          bin = bin_at (av, idx);

          /* 如果空块或最大块太小，则跳过扫描 */
          if ((victim = first (bin)) != bin &&
              (unsigned long) (victim->size) >= (unsigned long) (nb))//判断是否为largebin范围中
            {
              victim = victim->bk_nextsize;
              while (((unsigned long) (size = chunksize (victim)) <
                      (unsigned long) (nb)))//循环寻找合适的chunk
                victim = victim->bk_nextsize;

              /* 避免删除大小的第一个条目，以便跳过
			列表不必重新路由.  */
              if (victim != last (bin) && victim->size == victim->fd->size)//判断是否前一个结点的size与申请空间相等
                victim = victim->fd;

              remainder_size = size - nb;
              unlink (av, victim, bck, fwd);//进行合并

              /* 耗尽 */
              if (remainder_size < MINSIZE)//如果小于MINSIZE
                {
                  set_inuse_bit_at_offset (victim, size);//设置inuse标记位
                  if (av != &main_arena)//判断是否位于main_arena中
                    victim->size |= NON_MAIN_ARENA;
                }
              /* 分裂 */
              else
                {
                  remainder = chunk_at_offset (victim, nb);
                  /* 我们不能假定未排序的列表为空，因此
				必须在此处执行完整的插入.  */
                  bck = unsorted_chunks (av);//取出unsorted_bin链
                  fwd = bck->fd;
	  if (__glibc_unlikely (fwd->bk != bck))//判断是否完整
                    {
                      errstr = "malloc(): corrupted unsorted chunks";
                      goto errout;
                    }
                  remainder->bk = bck;
                  remainder->fd = fwd;
                  bck->fd = remainder;
                  fwd->bk = remainder;//重新放置结点到unsorted_bin链中
                  if (!in_smallbin_range (remainder_size))//如果处于smallbin范围中
                    {
                      remainder->fd_nextsize = NULL;
                      remainder->bk_nextsize = NULL;
                    }
                  set_head (victim, nb | PREV_INUSE |
                            (av != &main_arena ? NON_MAIN_ARENA : 0));//设置victim的头部信息
                  set_head (remainder, remainder_size | PREV_INUSE);//设置remainder的头部信息
                  set_foot (remainder, remainder_size);//设置remainder的prev_size
                }
              check_malloced_chunk (av, victim, nb);//检测chunk
              void *p = chunk2mem (victim);//转换为用户chunk
              alloc_perturb (p, bytes);//初始化chunk
              return p;//返回指针
            }
        }

      /*
从下一个最大的垃圾箱开始，通过扫描垃圾箱来搜索一个垃圾块
箱子此搜索严格按照最佳匹配进行；i、 e.最小的
（领带的使用量大约是最近最少的）大块
选择合适的。
位图避免了检查大多数块是否为非空。
在预热阶段跳过所有箱子的特殊情况
当还没有返回块时，它的速度比看起来的要快。
       */

      ++idx;
      bin = bin_at (av, idx);
      block = idx2block (idx);//计算出该 bin 在 binmap 对应的 bit 属于哪个 block
      map = av->binmap[block];
      bit = idx2bit (idx);

      for (;; )
        {
          /* 如果该块中没有更多的设置位，则跳过该块的其余部分.  */
          if (bit > map || bit == 0)
            {
              do
                {
                  if (++block >= BINMAPSIZE) /* 垃圾桶外 */
                    goto use_top;
                }
              while ((map = av->binmap[block]) == 0);

              bin = bin_at (av, (block << BINMAPSHIFT));
              bit = 1;
            }

          /* 使用设定的位前进到料仓。一定有. */
          while ((bit & map) == 0)
            {
              bin = next_bin (bin);
              bit <<= 1;
              assert (bit != 0);
            }

          /* 检查垃圾箱。它可能是非空的 */
          victim = last (bin);

          /*  如果出现假警报（空箱子），请清除该位. */
          if (victim == bin)
            {
              av->binmap[block] = map &= ~bit; /* Write through */
              bin = next_bin (bin);
              bit <<= 1;
            }

          else
            {
              size = chunksize (victim);

              /*  我们知道这个箱子里的第一块足够大，可以使用. */
              assert ((unsigned long) (size) >= (unsigned long) (nb));//判断size是否大于申请空间

              remainder_size = size - nb;

              /* unlink */
              unlink (av, victim, bck, fwd);//进行合并

              /* Exhaust */
              if (remainder_size < MINSIZE)
                {
                  set_inuse_bit_at_offset (victim, size);//设置inuse标记位
                  if (av != &main_arena)//判断chunk是否位于main_arena中
                    victim->size |= NON_MAIN_ARENA;//设置N标记位
                }

              /* Split */
              else
                {
                  remainder = chunk_at_offset (victim, nb);

                  /* 我们不能假定未排序的列表为空，因此
				必须在此处执行完整的插入.  */
                  bck = unsorted_chunks (av);
                  fwd = bck->fd;
	  if (__glibc_unlikely (fwd->bk != bck))
                    {
                      errstr = "malloc(): corrupted unsorted chunks 2";
                      goto errout;
                    }
                  remainder->bk = bck;
                  remainder->fd = fwd;
                  bck->fd = remainder;
                  fwd->bk = remainder;//重新排布结点

                  /* advertise as last remainder */
                  if (in_smallbin_range (nb))//如果nb满足smallbin范围之中
                    av->last_remainder = remainder;//将last_remainder重新指向remainder
                  if (!in_smallbin_range (remainder_size))//如果剩余部分不在smallbin范围中，将nextsize设置为NULL
                    {
                      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);//检测chunk
              void *p = chunk2mem (victim);
              alloc_perturb (p, bytes);//初始化chunk
              return p;//返回指针
            }
        }

    use_top://top chunk
      /*
		如果足够大，将内存末尾的块分割开
		（在av->top中保持）。请注意，这符合最佳拟合
		搜索规则。实际上，av->top被视为更大（因此
		因为它可以
		根据需要扩展到尽可能大（直到系统
		限制）

		我们要求av->top始终存在（即大小>=
		MINSIZE）在初始化之后，如果不是这样
		被当前请求耗尽后，它将被补充。（主要
		确保它存在的原因是我们可能需要MINSIZE空间
		在sysmalloc中放置围栏柱。）
		我们要求av->top始终存在（即大小>=
		MINSIZE）在初始化之后，如果不是这样
		被当前请求耗尽后，它将被补充。（主要
		确保它存在的原因是我们可能需要MINSIZE空间
		在sysmalloc中放置围栏柱。）
       */

      victim = av->top;
      size = chunksize (victim);

      if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))//判断是否满足申请空间大小，如果满足则进行切割
        {
          remainder_size = size - nb;
          remainder = chunk_at_offset (victim, nb);//重新定义remainder
          av->top = remainder;//top更新
          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);//检测chunk
          void *p = chunk2mem (victim);
          alloc_perturb (p, bytes);//初始化chunk
          return p;//返回指针
        }

      /* 当我们使用原子操作来释放快速块时，我们可以得到
		这里适用于所有块大小.  */
      else if (have_fastchunks (av))//存在fastbin
        {
          malloc_consolidate (av);//进行合并
          /* restore original bin index */
          if (in_smallbin_range (nb))
            idx = smallbin_index (nb);
          else
            idx = largebin_index (nb);
        }

      /*
         否则，继电器将处理系统相关的情况
       */
      else
        {
          void *p = sysmalloc (nb, av);
          if (p != NULL)
            alloc_perturb (p, bytes);
          return p;
        }
    }
}

Free

static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
  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;
  int locked = 0;

  size = chunksize (p);//获取p指针大小

  /* 不会影响性能的少量安全检查：
	分配器从不在地址空间的末尾进行打包。
	因此，我们可以排除一些可能出现的大小值
	这里是偶然的，或者是某个入侵者的“设计”.  */
  if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
      || __builtin_expect (misaligned_chunk (p), 0))
    {
      errstr = "free(): invalid pointer";
    errout:
      if (!have_lock && locked)
        (void) mutex_unlock (&av->mutex);
      malloc_printerr (check_action, errstr, chunk2mem (p), av);
      return;
    }
  /* 我们知道每个块的大小至少为MINSIZE字节或一个
	MALLOC_对齐的倍数.  */
  if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
    {
      errstr = "free(): invalid size";
      goto errout;
    }

  check_inuse_chunk(av, p);

  /*
    如果符合条件，请将区块放在fastbin上，以便可以找到它
	并在malloc中快速使用.
  */

  if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())

#if TRIM_FASTBINS
      /*
	如果设置了TRIM_FASTBINS，则不要放置块
	将顶部与快速垃圾箱相连
      */
      && (chunk_at_offset(p, size) != av->top)//判断大小是否位于fastbin范围之中，并且与top_chunk不相邻
#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))
      {
	/* 在这一点上，我们可能没有锁和并发修改
	系统的内存可能会出现假阳性。重做测试
	拿到锁后.  */
	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;
	      }))
	  {
	    errstr = "free(): invalid next size (fast)";
	    goto errout;
	  }
	if (! have_lock)
	  {
	    (void)mutex_unlock(&av->mutex);
	    locked = 0;
	  }
      }

    free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);

    set_fastchunks(av);
    unsigned int idx = fastbin_index(size);
    fb = &fastbin (av, idx);

    /* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
    mchunkptr old = *fb, old2;
    unsigned int old_idx = ~0u;
    do
      {
	/* Check that the top of the bin is not the record we are going to add
	   (i.e., double free).  */
	if (__builtin_expect (old == p, 0))//判断是否存在double free
	  {
	    errstr = "double free or corruption (fasttop)";
	    goto errout;
	  }
	/* 检查顶部fastbin区块的大小是否与
	我们正在添加的块的大小。我们可以取消对旧版本的引用
	除非我们有锁，否则它可能已经被锁上了
	解除分配。有关实际检查，请参见下面的旧_IDX的使用.  */
	if (have_lock && old != NULL)//此时将p插入fastbin链中
	  old_idx = fastbin_index(chunksize(old));
	p->fd = old2 = old;
      }
    while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2)) != old2);

    if (have_lock && old != NULL && __builtin_expect (old_idx != idx, 0))
      {
	errstr = "invalid fastbin entry (free)";
	goto errout;
      }
  }

  /*
    在其他未映射的块到达时合并它们.
  */

  else if (!chunk_is_mmapped(p)) {
    if (! have_lock) {
      (void)mutex_lock(&av->mutex);
      locked = 1;
    }

    nextchunk = chunk_at_offset(p, size);

    /* 轻量测试：检查块是否已经是顶部块.  */
    if (__glibc_unlikely (p == av->top))
      {
	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 (__glibc_unlikely (!prev_inuse(nextchunk)))
      {
	errstr = "double free or corruption (!prev)";
	goto errout;
      }

    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;
      }

    free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);

    /* consolidate backward */
    if (!prev_inuse(p)) {//如果物理前一块chunk没有被使用，则进行合并
      prevsize = p->prev_size;
      size += prevsize;
      p = chunk_at_offset(p, -((long) prevsize));
      unlink(av, p, bck, fwd);//进行合并
    }

    if (nextchunk != av->top) {//如果下一块不为top_chunk，则进行判断是否可以向后合并
      /* get and clear inuse bit */
      nextinuse = inuse_bit_at_offset(nextchunk, nextsize);

      /* consolidate forward */
      if (!nextinuse) {//判断下一个是否使用，如果没有被使用，进行合并
	unlink(av, nextchunk, bck, fwd);//机械能Unlink
	size += nextsize;
      } else
	clear_inuse_bit_at_offset(nextchunk, 0);//清除标记位

      /*
	将区块放入未排序区块列表中。块是
	在完成后才放入常规垃圾箱
	被给予一次在malloc中使用的机会.
      */

      bck = unsorted_chunks(av);//获取unsorted_bin链
      fwd = bck->fd;
      if (__glibc_unlikely (fwd->bk != bck))
	{
	  errstr = "free(): corrupted unsorted chunks";
	  goto errout;
	}
      p->fd = fwd;
      p->bk = bck;
      if (!in_smallbin_range(size))//判断其是否不存在于smallbin链范围之中
	{
	  p->fd_nextsize = NULL;
	  p->bk_nextsize = NULL;
	}
      bck->fd = p;
      fwd->bk = p;//重新排布链表

      set_head(p, size | PREV_INUSE);
      set_foot(p, size);

      check_free_chunk(av, p);
    }

    /*
      如果区块与当前高端内存相邻，
	  合并到顶部
    */

    else {//否则合并到top_chunk中
      size += nextsize;
      set_head(p, size | PREV_INUSE);//设置标记位
      av->top = p;//更新top_chunk
      check_chunk(av, p);
    }

    /*
      如果释放较大的空间，则可能会合并周围的
	大块。然后，如果未使用的最高内存总量超过trim
	阈值，要求malloc_trim减小顶部.

    除非max_fast为0，否则我们不知道是否存在fastbins
	接近顶部，所以我们无法确定阈值
	已到达，除非合并fastbins。但是我们
	不想在每个免费的基础上进行整合。作为妥协,，
	如果FASTBIN\u合并\u阈值，则执行合并
	到达.
    */

    if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
      if (have_fastchunks(av))//存在fastbin链
	malloc_consolidate(av);//进行对fastbin进行合并

      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
      } else {
	/* 始终尝试heap_trim（），即使顶部块不是
		较大，因为相应的堆可能会消失.  */
	heap_info *heap = heap_for_ptr(top(av));

	assert(heap->ar_ptr == av);
	heap_trim(heap, mp_.top_pad);
      }
    }

    if (! have_lock) {
      assert (locked);
      (void)mutex_unlock(&av->mutex);
    }
  }
  /*
    如果区块是通过mmap分配的，则通过munmap（）释放.
  */

  else {
    munmap_chunk (p);
  }
}