• ptmalloc源码分析 - realloc()函数的实现（11）

    目录

    一、步骤1-判断边界情况，realloc也可以执行malloc和free的功能

    二、步骤2-原chunk如果MMAP方式分配，申请新内存并拷贝实现

    三、步骤3-非MMAP方式分配，则_int_realloc进行合并/裁剪等实现

    1. _int_realloc函数：老chunk足够大，则裁剪

    2. _int_realloc函数：尝试从Top chunk上进行扩展

    3. _int_realloc函数：尝试合并nextchunk空间切割

    4. _int_realloc函数：调用_int_malloc函数分配新内存

    5. _int_realloc函数：裁剪返回Userchunk释放Remainder chunk

    四、步骤4-如果_int_realloc分配失败，则尝试__libc_malloc分配一次

    本章节主要讲解一下realloc()函数的实现。free函数的入口函数：__libc_realloc，该入口函数也在malloc.c的文件中。

    前几章我们讲解了malloc的实现和free的实现，基本了解了ptmalloc是如何来管理内存结构的。此章节主要讲一下realloc()函数。该函数意思就是重置一个内存的大小。基本有以下几个步骤来实现该函数逻辑：

    1. 步骤1：判断边界情况，realloc也可以执行malloc和free的功能
    2. 步骤2：原chunk如果MMAP方式分配，则新申请内存并拷贝方式实现
    3. 步骤3：非MMAP方式分配，则_int_realloc进行合并/裁剪等方式实现
    4. 步骤4：如果_int_realloc分配失败，则尝试__libc_malloc分配一次

    一、步骤1-判断边界情况，realloc也可以执行malloc和free的功能

    边界情况主要有两种：

    1. 如果bytes为0的情况，相当于执行一次free操作
    2. 如果老的指针为空的情况下，相当于执行一次malloc操作

    通过checked_request2size函数，检查bytes是否在分配合法区间内，并且将bytes进行对齐，最终得到对齐的nb大小的内存申请容量。

    1. /**
    2.  * 重新设置内存大小
    3.  */
    4. void *
    5. __libc_realloc (void *oldmem, size_t bytes)
    6. {
    7.   mstate ar_ptr;
    8.   INTERNAL_SIZE_T nb;    //字节对齐后需要分配的大小     /* padded request size */
    9.  
    10.   void *newp;      //返回新的chunk地址        /* chunk to return */
    11.  
    12.   void *(*hook) (void *, size_t, const void *) =
    13.     atomic_forced_read (__realloc_hook);
    14.   if (__builtin_expect (hook != NULL, 0))
    15.     return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
    16.  
    17.   //如果bytes==0 则相当于free，调用__libc_free函数
    18. #if REALLOC_ZERO_BYTES_FREES
    19.   if (bytes == 0 && oldmem != NULL)
    20.     {
    21.       __libc_free (oldmem); return 0;
    22.     }
    23. #endif
    24.  
    25.   /* realloc of null is supposed to be same as malloc */
    26.   /* 如果老的内存指针为空，则相当于重新分配一块内存，调用__libc_malloc函数 */
    27.   if (oldmem == 0)
    28.     return __libc_malloc (bytes);
    29.  
    30.   /* chunk corresponding to oldmem */
    31.   const mchunkptr oldp = mem2chunk (oldmem); //获取老的chunk指针地址
    32.   /* its size */
    33.   const INTERNAL_SIZE_T oldsize = chunksize (oldp); //获取来的chunk的size
    34.  
    35.   /* 判断chunk是否为MMAP分配方式 IS_MMAPPED*/
    36.   if (chunk_is_mmapped (oldp))
    37.     ar_ptr = NULL; //分配区NULL
    38.   else
    39.     {
    40.       MAYBE_INIT_TCACHE ();
    41.       ar_ptr = arena_for_chunk (oldp); //获取分配区
    42.     }
    43.  
    44.   /* Little security check which won't hurt performance: the allocator
    45.      never wrapps around at the end of the address space.  Therefore
    46.      we can exclude some size values which might appear here by
    47.      accident or by "design" from some intruder.  We need to bypass
    48.      this check for dumped fake mmap chunks from the old main arena
    49.      because the new malloc may provide additional alignment.  */
    50.   if ((__builtin_expect ((uintptr_t) oldp > (uintptr_t) -oldsize, 0)
    51.        || __builtin_expect (misaligned_chunk (oldp), 0))
    52.       && !DUMPED_MAIN_ARENA_CHUNK (oldp))
    53.       malloc_printerr ("realloc(): invalid pointer");
    54.  
    55.   //检查bytes是否在合法区间内，最大小于<2147483647
    56.   //并调用request2size函数，将bytes进行对齐，最终得到对齐的nb大小的内存申请容量
    57.   if (!checked_request2size (bytes, &nb)) //XXX
    58.     {
    59.       __set_errno (ENOMEM);
    60.       return NULL;
    61.     }

    二、步骤2-原chunk如果MMAP方式分配，申请新内存并拷贝实现

    这里有几个逻辑：

    1. 如果是伪造的主分区的MMAP的chunk，则通过__lib_malloc函数申请一块新内存，将老数据拷贝memcpy到新内存上，老内存不free
    2. 如果是标准MMAP的chunk，则通过__lib_malloc函数申请一块新内存，将老数据拷贝到新内存上，最后需要调用munmap_chunk销毁这个chunk
    3. 如果老的内存块数据减去一个SIZE_SZ，还能比新的对齐后的内存块大，则直接返回老内存，不需要做任何改变
    1.  //如果是MMAP的方式
    2.   if (chunk_is_mmapped (oldp))
    3.     {
    4.       /* If this is a faked mmapped chunk from the dumped main arena,
    5. 	 always make a copy (and do not free the old chunk).  */
    6. 	  //如果是伪造的主分区的一个MMAP的chunk
    7. 	  //重新申请一个内存块，并将老的内存块数据拷贝到新的内存块上
    8.       if (DUMPED_MAIN_ARENA_CHUNK (oldp))
    9. 	{
    10. 	  /* Must alloc, copy, free. */
    11. 	  void *newmem = __libc_malloc (bytes);
    12. 	  if (newmem == 0)
    13. 	    return NULL;
    14. 	  /* Copy as many bytes as are available from the old chunk
    15. 	     and fit into the new size.  NB: The overhead for faked
    16. 	     mmapped chunks is only SIZE_SZ, not 2 * SIZE_SZ as for
    17. 	     regular mmapped chunks.  */
    18. 	  if (bytes > oldsize - SIZE_SZ)
    19. 	    bytes = oldsize - SIZE_SZ;
    20. 	  memcpy (newmem, oldmem, bytes); //内存拷贝
    21. 	  return newmem;
    22. 	}
    23.  
    24.       void *newmem;
    25.  
    26. #if HAVE_MREMAP
    27.       newp = mremap_chunk (oldp, nb);
    28.       if (newp)
    29.         return chunk2mem (newp);
    30. #endif
    31.       /* Note the extra SIZE_SZ overhead. */
    32.       //如果老的内存块的size减去SIZE_SZ后，都比新申请的大，则什么都不做，返回老的指针
    33.       if (oldsize - SIZE_SZ >= nb)
    34.         return oldmem;                         /* do nothing */
    35.  
    36.       /* Must alloc, copy, free. */
    37.       newmem = __libc_malloc (bytes); //新申请内存
    38.       if (newmem == 0)
    39.         return 0;              /* propagate failure */
    40.  
    41.       memcpy (newmem, oldmem, oldsize - 2 * SIZE_SZ); //拷贝oldsize为chunk的大小，2 * SIZE_SZ存储chunk的结构
    42.       munmap_chunk (oldp); //MMAP分配的，调用munmap_chunk所以释放老的内存地址
    43.       return newmem;
    44.     }

    三、步骤3-非MMAP方式分配，则_int_realloc进行合并/裁剪等实现

    单线程情况下直接调用_int_realloc函数。

    多线程情况下需要加锁然后调用_int_realloc实现。

    1.  /* 单线程情况 */
    2.   if (SINGLE_THREAD_P)
    3.     {
    4.       newp = _int_realloc (ar_ptr, oldp, oldsize, nb); //直接调用_int_realloc核心函数
    5.       assert (!newp || chunk_is_mmapped (mem2chunk (newp)) ||
    6. 	      ar_ptr == arena_for_chunk (mem2chunk (newp)));
    7.  
    8.       return newp; //返回新的指针地址
    9.     }
    10.  
    11.   /* 多线程模式下，非MMAP分配方式 */
    12.   __libc_lock_lock (ar_ptr->mutex); //加锁
    13.  
    14.   newp = _int_realloc (ar_ptr, oldp, oldsize, nb); //调用_int_realloc核心函数
    15.  
    16.   __libc_lock_unlock (ar_ptr->mutex); //解锁
    17.   assert (!newp || chunk_is_mmapped (mem2chunk (newp)) ||
    18.           ar_ptr == arena_for_chunk (mem2chunk (newp)));

    1. _int_realloc函数：老chunk足够大，则裁剪

    老的chunk内存，大于新分配的，空间足够，则可以进行分割。将老的内存切割成2个chunk，一个返回给用户端，一个放入bins上进行管理。

    oldsize需要大于nb，nb是经过checked_request2size函数进行字节对齐的内存大小。

    1. /**
    2.  * realloc核心函数
    3.  */
    4. void*
    5. _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
    6. 	     INTERNAL_SIZE_T nb)
    7. {
    8.   mchunkptr        newp;            /* chunk to return */
    9.   INTERNAL_SIZE_T  newsize;         /* its size */
    10.   void*          newmem;          /* corresponding user mem */
    11.  
    12.   mchunkptr        next;            /* next contiguous chunk after oldp */
    13.  
    14.   mchunkptr        remainder;       /* extra space at end of newp */
    15.   unsigned long    remainder_size;  /* its size */
    16.  
    17.   /* oldmem size */
    18.   if (__builtin_expect (chunksize_nomask (oldp) <= 2 * SIZE_SZ, 0)
    19.       || __builtin_expect (oldsize >= av->system_mem, 0))
    20.     malloc_printerr ("realloc(): invalid old size");
    21.  
    22.   check_inuse_chunk (av, oldp); //检查使用状态
    23.  
    24.   /* All callers already filter out mmap'ed chunks.  */
    25.   assert (!chunk_is_mmapped (oldp));
    26.  
    27.   next = chunk_at_offset (oldp, oldsize); //获取下一个chunk
    28.   INTERNAL_SIZE_T nextsize = chunksize (next); //下一个chunk的size
    29.   if (__builtin_expect (chunksize_nomask (next) <= 2 * SIZE_SZ, 0)
    30.       || __builtin_expect (nextsize >= av->system_mem, 0))
    31.     malloc_printerr ("realloc(): invalid next size");
    32.  
    33.   //老的chunk内存，大于新分配的，空间足够，则可以进行分割
    34.   if ((unsigned long) (oldsize) >= (unsigned long) (nb))
    35.     {
    36.       /* already big enough; split below */
    37.       newp = oldp;
    38.       newsize = oldsize;
    39.     }

    2. _int_realloc函数：尝试从Top chunk上进行扩展

    如果 nextchunk 是Topchunk ，并且新的chunk大小大于申请的大小，则直接合并Topchunk进行切割。 

    调整av->top的值，设置Topchunk 标记物理相邻前一个chunk为使用中PREV_INUSE。

    1.   else
    2.     {
    3.       /* Try to expand forward into top */
    4. 	  /* 如果 nextchunk 是Topchunk ，并且新的chunk大小大于申请的大小，则直接合并Topchunk进行切割*/
    5.       if (next == av->top &&
    6.           (unsigned long) (newsize = oldsize + nextsize) >=
    7.           (unsigned long) (nb + MINSIZE))
    8.         {
    9.           set_head_size (oldp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0)); //设置头
    10.           av->top = chunk_at_offset (oldp, nb); //调整av->top的值
    11.           set_head (av->top, (newsize - nb) | PREV_INUSE); //设置Topchunk 标记物理相邻前一个chunk为使用中
    12.           check_inuse_chunk (av, oldp);
    13.           return chunk2mem (oldp); //chunk指针地址 转到 内存指针地址
    14.         }

    3. _int_realloc函数：尝试合并nextchunk空间切割

    如果nextchunk不是Top chunk ，并且next为空闲状态，则将nextchunk进行合并。合并完了之后，调用unlink_chunk，解除nextchunk的bins上的关系。

    1.       /* Try to expand forward into next chunk;  split off remainder below */
    2.       /* 如果nextchunk不是Top chunk ，并且next为空闲状态，则将nextchunk进行合并*/
    3.       else if (next != av->top &&
    4.                !inuse (next) &&
    5.                (unsigned long) (newsize = oldsize + nextsize) >=
    6.                (unsigned long) (nb))
    7.         {
    8.           newp = oldp;
    9.           unlink_chunk (av, next); //解除空闲chunk的bins上的关系
    10.         }

    4. _int_realloc函数：调用_int_malloc函数分配新内存

    首先调用_int_malloc函数，直接分配一个新的newmem。通过newmem，获取得到当前chunk的大小和chunk地址。如果新分配的正好是nextchunk，则直接合并到一起。如果不是，则释放老内存，拷贝就内存数据到新内存上。 

    1.       /* allocate, copy, free */
    2.       /* nextchunk为使用中，或其它情况 */
    3.       else
    4.         {
    5.           newmem = _int_malloc (av, nb - MALLOC_ALIGN_MASK); //调用_int_malloc新分配一块内存
    6.           if (newmem == 0)
    7.             return 0; /* propagate failure */
    8.  
    9.           newp = mem2chunk (newmem); //返回新的指针地址
    10.           newsize = chunksize (newp); //返回新的chunk的size
    11.  
    12.           /*
    13.              Avoid copy if newp is next chunk after oldp.
    14.            */
    15.           /* 如果新分配的物理地址是老chunk的下一个chunk */
    16.           if (newp == next)
    17.             {
    18.               newsize += oldsize; //调整size，合并nextchunk
    19.               newp = oldp;
    20.             }
    21.           else
    22.             {
    23. 	      memcpy (newmem, chunk2mem (oldp), oldsize - SIZE_SZ); //开始进行内存拷贝
    24.               _int_free (av, oldp, 1); //释放老内存
    25.               check_inuse_chunk (av, newp);
    26.               return chunk2mem (newp); //返回内存地址
    27.             }
    28.         }
    29.     }

    5. _int_realloc函数：裁剪返回Userchunk释放Remainder chunk

     老的内存块经过合并后，足够大，则需要进行裁剪操作。如果进行裁剪前，发现没有足够的空间了，则不裁剪了，设置一下nextchunk的标记位就行了；如果有足够空间，则裁剪出Remainder chunk，并通过_int_free函数，将裁剪出来的剩余chunk释放到bins上管理。

    1.   /* If possible, free extra space in old or extended chunk */
    2.  
    3.   assert ((unsigned long) (newsize) >= (unsigned long) (nb));
    4.  
    5.   /* 老的内存块经过合并后，足够大，则需要进行裁剪操作 */
    6.   remainder_size = newsize - nb; //裁剪剩余的内存
    7.  
    8.   /* 进行裁剪前，如果没有足够的空间了，则不裁剪了 */
    9.   if (remainder_size < MINSIZE)   /* not enough extra to split off */
    10.     {
    11.       set_head_size (newp, newsize | (av != &main_arena ? NON_MAIN_ARENA : 0));
    12.       set_inuse_bit_at_offset (newp, newsize); //下一个chunk标记前一个chunk使用中
    13.     }
    14.   else   /* split remainder */
    15.     {
    16.       remainder = chunk_at_offset (newp, nb); //获取裁剪的chunk
    17.       set_head_size (newp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
    18.       set_head (remainder, remainder_size | PREV_INUSE |
    19.                 (av != &main_arena ? NON_MAIN_ARENA : 0)); //设置裁剪chunk的状态
    20.       /* Mark remainder as inuse so free() won't complain */
    21.       set_inuse_bit_at_offset (remainder, remainder_size); //
    22.       _int_free (av, remainder, 1); //释放裁剪后的chunk
    23.     }
    24.  
    25.   check_inuse_chunk (av, newp);
    26.   return chunk2mem (newp); //返回内存
    27. }

    四、步骤4-如果_int_realloc分配失败，则尝试__libc_malloc分配一次

    如果调用_int_realloc失败，则尝试__libc_malloc，强制重新分配一次。

    1.   /* 分配失败 ，则调用__libc_malloc进行重试一次*/
    2.   if (newp == NULL)
    3.     {
    4.       /* Try harder to allocate memory in other arenas.  */
    5.       LIBC_PROBE (memory_realloc_retry, 2, bytes, oldmem);
    6.       newp = __libc_malloc (bytes);
    7.       /* 分配成功，调用memcpy拷贝数据， _int_free释放老的chunk*/
    8.       if (newp != NULL)
    9.         {
    10.           memcpy (newp, oldmem, oldsize - SIZE_SZ);
    11.           _int_free (ar_ptr, oldp, 0);
    12.         }
    13.     }
    14.  
    15.   return newp;
    16. }
    17. libc_hidden_def (__libc_realloc)

  • 相关阅读:
    nodejs文档（一）
    智慧综合体信息化智能化解决方案
    网络安全（黑客）自学
    【历史上的今天】8 月 19 日：大型计算机先驱和小型机之父诞生；中国雅虎邮箱成历史
    论文学习：Graph Data Augmentation for Graph Machine Learning: A Survey
    狂神说Java之 rabbitmq高级分布式事务
    20221206英语学习
    自媒体播放量越来越低，还有必要做吗？
    监控技术栈中的知识点
    Java攻略集合之泛型
  • 原文地址：https://blog.csdn.net/initphp/article/details/133323476