转让malloc()该功能后，发生了什么事内核？附malloc()和free()实现源

特此声明：在本文中，引用另一篇文章和帖子，结合的概括的理解malloc()函数的实现机制。

我们常常会在C程序中调用malloc()函数动态分配一块连续的内存空间并使用它们。那么，这些用户空间发生的事会引发内核空间什么样的反应呢？

malloc()是一个API，这个函数在库中封装了系统调用brk。因此假设调用malloc，那么首先会引发brk系统调用运行的过程。

brk()在内核中相应的系统调用服务例程为SYSCALL_DEFINE1(brk,
unsigned long, brk)。參数brk用来指定heap段新的结束地址。也就是又一次指定mm_struct结构中的brk字段。

brk系统调用服务例程首先会确定heap段的起始地址min_brk。然后再检查资源的限制问题。接着，将新老heap地址分别依照页大小对齐，对齐后的地址分别存储在newbrk和okdbrk中。

brk()系统调用本身既能够缩小堆大小。又能够扩大堆大小。缩小堆这个功能是通过调用do_munmap()完毕的。假设要扩大堆的大小。那么必须先通过find_vma_intersection()检查扩大以后的堆是否与已经存在的某个虚拟内存重合，怎样重合则直接退出。否则，调用do_brk()进行接下来扩大堆的各种工作。

<span style="font-size:18px;">SYSCALL_DEFINE1(brk, unsigned long, brk)
{
        unsigned long rlim, retval;
        unsigned long newbrk, oldbrk;
        struct mm_struct *mm = current->mm;
        unsigned long min_brk;

        down_write(&mm->mmap_sem);

#ifdef CONFIG_COMPAT_BRK
        min_brk = mm->end_code;
#else
        min_brk = mm->start_brk;
#endif
        if (brk < min_brk)
                goto out;

        rlim = rlimit(RLIMIT_DATA);
        if (rlim < RLIM_INFINITY && (brk - mm->start_brk) +
                        (mm->end_data - mm->start_data) > rlim)

        newbrk = PAGE_ALIGN(brk);
        oldbrk = PAGE_ALIGN(mm->brk);
        if (oldbrk == newbrk)
                goto set_brk;
        if (brk brk) {
                if (!do_munmap(mm, newbrk, oldbrk-newbrk))
                        goto set_brk;
                goto out;
        }

        if (find_vma_intersection(mm, oldbrk, newbrk+PAGE_SIZE))
                goto out;

        if (do_brk(oldbrk, newbrk-oldbrk) != oldbrk)
                goto out;
set_brk:
        mm->brk = brk;
out:
        retval = mm->brk;
        up_write(&mm->mmap_sem);
        return retval;
}</span>

brk系统调用服务例程最后将返回堆的新结束地址。

用户进程调用malloc()会使得内核调用brk系统调用服务例程。由于malloc总是动态的分配内存空间，因此该服务例程此时会进入第二条运行路径中，即扩大堆。do_brk()主要完毕下面工作：

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）。整个缺页异常的处理过程很复杂，我们这里仅仅关注与malloc()有关的那一条运行路径。

当CPU产生一个异常时，将会跳转到异常处理的整个处理流程中。对于缺页异常，CPU将跳转到page_fault异常处理程序中。

异常处理程序会调用do_page_fault()函数，该函数通过读取CR2寄存器获得引起缺页的线性地址。通过各种条件推断以便确定一个合适的方案来处理这个异常。

do_page_fault()函数：

该函数通过各种条件来检測当前发生异常的情况，但至少do_page_fault()会区分出引发缺页的两种情况：由编程错误引发异常，以及由进程地址空间中还未分配物理内存的线性地址引发。

对于后一种情况，通常还分为用户空间所引发的缺页异常和内核空间引发的缺页异常。

内核引发的异常是由vmalloc()产生的，它仅仅用于内核空间内存的分配。

显然，我们这里须要关注的是用户空间所引发的异常情况。这部分工作从do_page_fault()中的good_area标号处開始运行，主要通过handle_mm_fault()完毕。

<span style="font-size:18px;">dotraplinkage void __kprobes do_page_fault(struct pt_regs *regs, unsigned long error_code)
{
…… ……
good_area:
        write = error_code & PF_WRITE;

        if (unlikely(access_error(error_code, write, vma))) {
                bad_area_access_error(regs, error_code, address);
                return;
        }
        fault = handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0);
}</span>

handle_mm_fault()函数：

该函数的主要功能是为引发缺页的进程分配一个物理页框，它先确定与引发缺页的线性地址相应的各级页文件夹项是否存在，怎样不存在则分进行分配。详细怎样分配这个页框是通过调用handle_pte_fault()完毕的。

<span style="font-size:18px;">int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long address, unsigned int flags)
{
        pgd_t *pgd;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
        …… ……
        pgd = pgd_offset(mm, address);
        pud = pud_alloc(mm, pgd, address);
        if (!pud)
                return VM_FAULT_OOM;
        pmd = pmd_alloc(mm, pud, address);
        if (!pmd)
                return VM_FAULT_OOM;
        pte = pte_alloc_map(mm, pmd, address);
        if (!pte)
                return VM_FAULT_OOM;
          return handle_pte_fault(mm, vma, address, pte, pmd, flags);
}</span>

handle_pte_fault()函数：

该函数依据页表项pte所描写叙述的物理页框是否在物理内存中，分为两大类：

请求调页：被訪问的页框不再主存中，那么此时必须分配一个页框。

写时复制：被訪问的页存在，可是该页是仅仅读的。内核须要对该页进行写操作，此时内核将这个已存在的仅仅读页中的数据拷贝到一个新的页框中。

用户进程訪问由malloc()分配的内存空间属于第一种情况。对于请求调页。handle_pte_fault()仍然将其细分为三种情况：

1.假设页表项确实为空（pte_none(entry)），那么必须分配页框。

假设当前进程实现了vma操作函数集合中的fault钩子函数，那么这样的情况属于基于文件的内存映射。它调用do_linear_fault()进行分配物理页框。

否则。内核将调用针对匿名映射分配物理页框的函数do_anonymous_page()。

2.假设检測出该页表项为非线性映射（pte_file(entry)），则调用do_nonlinear_fault()分配物理页。

3.假设页框事先被分配，可是此刻已经由主存换出到了外存。则调用do_swap_page()完毕页框分配。

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

<span style="font-size:18px;">static inline int handle_pte_fault(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long address, pte_t *pte, pmd_t *pmd, unsigned int flags)
{
        …… ……
        if (!pte_present(entry)) {
                if (pte_none(entry)) {
                        if (vma->vm_ops) {
                                if (likely(vma->vm_ops->fault))
                                        return do_linear_fault(mm, vma, address,
                                                pte, pmd, flags, entry);
                        }
                        return do_anonymous_page(mm, vma, address,
                                                 pte, pmd, flags);
                }
                if (pte_file(entry))
                        return do_nonlinear_fault(mm, vma, address,
                                        pte, pmd, flags, entry);
                return do_swap_page(mm, vma, address,
                                        pte, pmd, flags, entry);
        }
…… ……
}</span>

do_anonymous_page()函数：

此时，缺页异常处理程序最终要为当前进程分配物理页框了。它通过alloc_zeroed_user_highpage_movable()来完毕这个过程。

我们层层拨开这个函数的外衣，发现它最终调用了alloc_pages()。

<span style="font-size:18px;">static int do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma,
                unsigned long address, pte_t *page_table, pmd_t *pmd,
                unsigned int flags)
{
…… ……
        if (unlikely(anon_vma_prepare(vma)))
                goto oom;
        page = alloc_zeroed_user_highpage_movable(vma, address);
        if (!page)
                goto oom;
…… ……
}</span>

经过这样一个复杂的过程，用户进程所訪问的线性地址最终相应到了一块物理内存。

    以下附上我自觉得比較完好的malloc()和free()函数源码：

<span style="font-size:18px;">#include <unistd.h>
#include <stdlib.h>
//块首
union header
{
	struct{
		union header *next;//指向下一空暇快的指针
		unsigned int size;//空暇块的大小
	}s;
	long x;//对齐
};
typedef union header Header;

#define NALLOC 1024;//请求的最小单位数，每页大小为1KB
static Header* moreSys(unsigned int num);//向系统申请一块内存
void* userMalloc(unsigned int nbytes);//从用户管理区申请内存
void userFree(void *ap);//释放内存，放入到用户管理区

static Header base;//定义空暇链表头
static Header *free_list = NULL;//空暇链表的起始查询指针

void* userMalloc(unsigned int nbytes)
{
	Header *p;
	Header *prev;
	unsigned int unitNum;
	//将申请的字节数nbytes转换成unitNum个块首单位，多计算一个作为管理块首
	unitNum = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
	if ((prev = free_list) == NULL)//假设无空暇链表，定义空暇链表
	{
		base.s.next = free_list = prev = &base;
		base.s.size = 1;
	}
	for (p = prev->s.next; ; p = p->s.next, prev = p)
	{
		if (p->s.size >= unitNum)//空暇块足够大
		{
			if (p->s.size <= (unitNum + 1))
			{
				prev->s.next = p->s.next;
			}
			else//偏大，切出须要的一块
			{
				p->s.size = unitNum;
				p += p->s.size;
				p->s.size = unitNum;
		    }
			free_list = prev;
			return (void *)(p+1);
		}
		if (p == free_list)
		{
			if ((p = moreSys(unitNum)) == NULL)//无合适块。向系统申请
			{
				return NULL;
			}
		}
	}
}

static Header* moreSys(unsigned int num)
{
	char *cp;
	Header *up;

	if(num < NALLOC)
		num = NALLOC;//向系统申请的最小量
	cp = sbrk(num * sizeof(Header));
	if (cp == (char *)-1)
	{
		return NULL;//无空暇页面。返回空地址
	}
	up = (Header *)cp;
	up->s.size = num;
	userFree(up + 1);
	return free_list;
}</span>

<span style="font-size:18px;">//回收内存到空暇链上
void Free(void *ap)
{
Header *bp, *p;
bp = (Header *)ap - 1;	 //指向块首

for(p = free_list; !(bp>p && bp<p->s.next); p = p->s.next)	//按地址定位空暇块在链表
//中的位置
if(p>=p->s.next && (bp>p || bp<p->s.next))
break;	 //空暇块在两端
if(bp + bp->s.size == p->s.next) {	 //看空暇块是否与已有的块相邻，相邻就合并
bp->s.size += p->s.next->s.size;
bp->s.next = p->s.next->s.next;
}
else
bp->s.next = p->s.next;

if(p + p->s.size == bp) {
p->s.size += bp->s.size;
p->s.next = bp->s.next;
}
else
p->s.next = bp;

free_list = p;
}</span>

版权声明：本文博主原创文章，博客，未经同意，不得转载。