malloc实现过程

前言

最近重温深入理解计算机系统，看到了malloc的实现，malloc主要涉及到两个系统调用brk和mmap.废话不多说直接上源码，一切尽在源码之中。
brk系统调用的入口函数为sys_brk()

sys_brk系统调用源码

SYSCALL_DEFINE1(brk, unsigned long, brk)
{
    unsigned long retval;
    unsigned long newbrk, oldbrk, origbrk;
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *next;
    unsigned long min_brk;
    bool populate;
    bool downgraded = false;
    LIST_HEAD(uf);

    if (down_write_killable(&mm->mmap_sem))
        return -EINTR;

    origbrk = mm->brk;

#ifdef CONFIG_COMPAT_BRK
    /*
     * CONFIG_COMPAT_BRK can still be overridden by setting
     * randomize_va_space to 2, which will still cause mm->start_brk
     * to be arbitrarily shifted
     */
    if (current->brk_randomized)
        min_brk = mm->start_brk;
    else
        min_brk = mm->end_data;
#else
    min_brk = mm->start_brk;
#endif
    if (brk < min_brk)
        goto out;

    /*
     * Check against rlimit here. If this check is done later after the test
     * of oldbrk with newbrk then it can escape the test and let the data
     * segment grow beyond its set limit the in case where the limit is
     * not page aligned -Ram Gupta
     */
    if (check_data_rlimit(rlimit(RLIMIT_DATA), brk, mm->start_brk,
                  mm->end_data, mm->start_data))
        goto out;

    newbrk = PAGE_ALIGN(brk);
    oldbrk = PAGE_ALIGN(mm->brk);
    if (oldbrk == newbrk) {
        mm->brk = brk;
        goto success;
    }

    /*
     * Always allow shrinking brk.
     * __do_munmap() may downgrade mmap_sem to read.
     */
    if (brk <= mm->brk) {
        int ret;

        /*
         * mm->brk must to be protected by write mmap_sem so update it
         * before downgrading mmap_sem. When __do_munmap() fails,
         * mm->brk will be restored from origbrk.
         */
        mm->brk = brk;
        ret = __do_munmap(mm, newbrk, oldbrk-newbrk, &uf, true);
        if (ret < 0) {
            mm->brk = origbrk;
            goto out;
        } else if (ret == 1) {
            downgraded = true;
        }
        goto success;
    }

    /* Check against existing mmap mappings. */
    next = find_vma(mm, oldbrk);
    if (next && newbrk + PAGE_SIZE > vm_start_gap(next))
        goto out;

    /* Ok, looks good - let it rip. */
    if (do_brk_flags(oldbrk, newbrk-oldbrk, 0, &uf) < 0)
        goto out;
    mm->brk = brk;

success:
    populate = newbrk > oldbrk && (mm->def_flags & VM_LOCKED) != 0;
    if (downgraded)
        up_read(&mm->mmap_sem);
    else
        up_write(&mm->mmap_sem);
    userfaultfd_unmap_complete(mm, &uf);
    if (populate)
        mm_populate(oldbrk, newbrk - oldbrk);
    return brk;

out:
    retval = origbrk;
    up_write(&mm->mmap_sem);
    return retval;
  }

我们知道，堆是从低地址向高地址增长的，sys_brk 函数的参数brk是新的堆顶位置，而当前的mm->brk是原来堆顶的位置。
brk系统调用服务例程首先会确定heap段的起始地址min_brk，然后再检查资源的限制问题。接着，将新老heap地址分别按照页大小对齐，对齐后的地址分别存储与new_brk和old_brk中。如果两者相同，说明这次增加的堆的量很小，还在一个页，不需要另行分配，直接跳转至set_brk,设置mm->brk为新的brk就可以。
如果发现新旧堆顶不在一个页里面，这将麻烦了，说明要进行跨页分配。如果发现新堆顶小于旧堆顶，这说明不是新分配内存，而是释放内存了，释放的还不小，至少释放了一页，于是调用do_munmap来将这些页的内存映射去掉。
如果堆要扩大，就要调用find_vma,我们知道vm_area_struct通过vm_rb将这个区域放在红黑树上，这个函数将在红黑树上查找。找到原堆顶所在的vm_area_struct的下一个vm_area_struct,看当前的堆顶和下一个vm_area_struct之间还能不能分配一个完整的页。如果不能，只好直接退出返回，内存空间都被占满。
如果还有空间就调用do_brk进一步分配堆空间，从旧堆顶开始，分配计算出新旧堆顶之间的页数。

do_brk源码

static int do_brk(unsigned long addr, unsigned long len, struct list_head *uf)
{
	return do_brk_flags(addr, len, 0, uf);
}
static int do_brk_flags(unsigned long addr, unsigned long len, unsigned long flags, struct list_head *uf)
{
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *vma, *prev;
    struct rb_node **rb_link, *rb_parent;
    pgoff_t pgoff = addr >> PAGE_SHIFT;
    int error;

    /* Until we need other flags, refuse anything except VM_EXEC. */
    if ((flags & (~VM_EXEC)) != 0)
        return -EINVAL;
    flags |= VM_DATA_DEFAULT_FLAGS | VM_ACCOUNT | mm->def_flags;

    error = get_unmapped_area(NULL, addr, len, 0, MAP_FIXED);
    if (offset_in_page(error))
        return error;

    error = mlock_future_check(mm, mm->def_flags, len);
    if (error)
        return error;

    /*
     * mm->mmap_sem is required to protect against another thread
     * changing the mappings in case we sleep.
     */
    verify_mm_writelocked(mm);

    /*
     * Clear old maps.  this also does some error checking for us
     */
    while (find_vma_links(mm, addr, addr + len, &prev, &rb_link,
                  &rb_parent)) {
        if (do_munmap(mm, addr, len, uf))
            return -ENOMEM;
    }

    /* Check against address space limits *after* clearing old maps... */
    if (!may_expand_vm(mm, flags, len >> PAGE_SHIFT))
        return -ENOMEM;

    if (mm->map_count > sysctl_max_map_count)
        return -ENOMEM;

    if (security_vm_enough_memory_mm(mm, len >> PAGE_SHIFT))
        return -ENOMEM;

    /* Can we just expand an old private anonymous mapping? */
    vma = vma_merge(mm, prev, addr, addr + len, flags,
            NULL, NULL, pgoff, NULL, NULL_VM_UFFD_CTX);
    if (vma)
        goto out;

    /*
     * create a vma struct for an anonymous mapping
     */
    vma = vm_area_alloc(mm);
    if (!vma) {
        vm_unacct_memory(len >> PAGE_SHIFT);
        return -ENOMEM;
    }

    vma_set_anonymous(vma);
    vma->vm_start = addr;
    vma->vm_end = addr + len;
    vma->vm_pgoff = pgoff;
    vma->vm_flags = flags;
    vma->vm_page_prot = vm_get_page_prot(flags);
    vma_link(mm, vma, prev, rb_link, rb_parent);
out:
    perf_event_mmap(vma);
    mm->total_vm += len >> PAGE_SHIFT;
    mm->data_vm += len >> PAGE_SHIFT;
    if (flags & VM_LOCKED)
        mm->locked_vm += (len >> PAGE_SHIFT);
    vma->vm_flags |= VM_SOFTDIRTY;
    return 0;

}

1.通过get_unmapped_area()在当前进程的地址空间中查找一个符合len大小的线性区间，并且该线性区间的必须在addr地址之后。如果找到了这个空闲的线性区间，则返回该区间的起始地址，否则返回错误代码-ENOMEM；
2.通过find_vma_prepare()在当前进程所有线性区组成的红黑树中依次遍历每个vma，以确定上一步找到的新区间之前的线性区对象的位置。如果addr位于某个现存的vma中，则调用do_munmap()删除这个线性区。如果删除成功则继续查找，否则返回错误代码。
3.目前已经找到了一个合适大小的空闲线性区，接下来通过vma_merge()去试着将当前的线性区与临近的线性区进行合并。如果合并成功，那么该函数将返回prev这个线性区的vm_area_struct结构指针，同时结束do_brk()。否则，继续分配新的线性区。
4.接下来通过kmem_cache_zalloc()在特定的slab高速缓存vm_area_cachep中为这个线性区分配vm_area_struct结构的描述符。
5.初始化vma结构中的各个字段。
6.更新mm_struct结构中的vm_total字段，它用来同级当前进程所拥有的vma数量。
7.如果当前vma设置了VM_LOCKED字段，那么通过mlock_vma_pages_range()立即为这个线性区分配物理页框。否则，do_brk()结束。
可以看到，do_brk()主要是为当前进程分配一个新的线性区，在没有设置VM_LOCKED标志的情况下，它不会立刻为该线性区分配物理页框，而是通过vma一直将分配物理内存的工作进行延迟，直至发生缺页异常。

缺页异常处理

经过上面的过程，malloc返回了线性地址，如果此时用户进程访问了这个线性地址，那么就会发生缺页异常（Page Fault)，该异常处理程序会调用do_page_fault函数。

do_page_fault()
由编程错误引发异常，以及由进程地址空间中还未分配物理内存的线性地址引发。对于后一种情况，通常还分为用户空间所引发的缺页异常和内核空间引发的缺页异常。
内核引发的异常是由vmalloc产生的，它只用于内核空间内存分配。显然，我们关注的是用户态空间引发的异常，主要由handle_mm_fault完成处理。

handle_mm_fault()
该函数主要功能是为引发缺页的进程分配一个物理页框，它先确定引发缺页的线性地址对应的各级页目录项是否存在，如果不存在则进行分配，具体分配页框通过调用handle_pte_fault完成。

handle_pte_fault()
该函数根据页表项pte所描述的物理页框是否在物理内存中，分为两大类：
请求调页：被请求的页框不在主存中，那么此时必须分配一个页框。
写时复制：被访问的页存在，但是该页是只读的，内存需要对该页进行写操作，此时内核将这个已存在的只读页中的数据复制到一个新的页框中。
malloc引发的异常属于第一种，对于请求雕也，handle_pte_fault()仍然将其细分为三种情况：

• 如果页表项确实为空（pte_none(entry)），那么必须分配页框。如果当前进程实现了vma操作函数集合中的fault钩子函数，那么这种情况属于基于文件的内存映射，它调用do_linear_fault()进行分配物理页框。否则，内核将调用针对匿名映射分配物理页框的函数do_anonymous_page()。
• 如果检测出该页表项为非线性映射（pte_file(entry)），则调用do_nonlinear_fault()分配物理页。
• 如果页框事先被分配，但是此刻已经由主存换出到了外存，则调用do_swap_page()完成页框分配。

由malloc分配的内存将会调用do_anonymous_page()分配物理页框。

do_anonymous_page()

最终还是通过alloc_pages来分配物理页框，就这样用户进程所访问的线性地址终于获得了一块物理内存。