vmalloc 原理剖析 virtualmalloc

在32位 linux 系统中，每个进程都有 4G 的虚拟地址空间，在这 4G 的虚拟地址空间中又分为用户内存空间（0~3G）和内核内存空间（3~4G）。

由于虚拟的内核内存空间只有 1G，因此从寻址上来讲，内核最多可以寻址 1G 的物理内存空间。但是现在的操作系统内存内存空间远远不止 1G，所以为了让内核能够选址所有的物理内存空间，操作系统又对 1G 的虚拟内核内存空间进行了又一步划分。

直接内存映射区范围为3GB ( PAGE_OFFSET ) ~ 3GB+896 MB（high_memory），直接内存映射区的特点就是物理地址与虚拟地址之间存在一个3G的固定的偏移量，也即是物理地址 = 虚拟地址 - 3GB。

其中 kmalloc 和 __get_free_pages 使用的虚拟地址范围与物理内存是一一对应的，也即是一个 PAGE_OFFSET 的偏移量。也就是说这 2 个函数申请的内存地址空间就是在直接内存映射区域，其区域为PAGE_OFFSET ~ high_memory 之间。因此他们的虚拟地址和物理地址都是连续的。正是由于他们的地址有个固定的偏移量，所以这两个函数不需要为该地址段修改页表，访问速度也是比较快的。

而 vmalloc 使用的虚拟地址空间范围在 VMALLOC_START ~VMALLOC_END 区间。每次使用vmalloc 申请一块内存时，都会从该区域中寻找一块未被使用的虚拟地址段，然后根据分配的虚拟地址来修改页表，完成虚拟地址到物理地址的映射。由于 vmalloc 最终要修改页表，因此从效率上来讲，没有 kmalloc 高，但是其可以申请一大块的物理内存，不过其物理地址空间不保证是连续的。

一般情况下，只有硬件设备才需要物理地址连续的内存，因为硬件设备往往存在于 MMU 之外，根本不了解虚拟地址；但为了性能上的考虑，内核中一般使用 kmalloc()，而只有在需要获得大块内存时才使用 vmalloc()，例如当模块被动态加载到内核当中时，就把模块装载到由 vmalloc() 分配 的内存上。

接下来分析下 vmalloc 实现原理。

vmalloc
|-> __vmalloc
|-> __vmalloc_node

vmalloc 最终调用 __vmalloc_node。

static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
int node)
{
struct vm_struct *area;
...

//寻找一块空闲虚拟内存区域，然后申请 vm_struct 结构用于记录使用的虚拟地址空间段以及使用使用的物理页
area = get_vm_area_node(size, VM_ALLOC, node, gfp_mask);

//为vm区分配非连续的内存区，以页为单位,同时修改页表完成虚拟地址到物理地址之间的映射
return __vmalloc_area_node(area, gfp_mask, prot, node);
}

其中 get_vm_area_node 最终会调用 __get_vm_area_node

static struct vm_struct *__get_vm_area_node(unsigned long size, unsigned long flags,
unsigned long start, unsigned long end,
int node, gfp_t gfp_mask)
{
struct vm_struct **p, *tmp, *area;
unsigned long align = 1;
unsigned long addr;

...

// 申请一个新的vm
area = kmalloc_node(sizeof(*area), gfp_mask & GFP_LEVEL_MASK, node);

/*
* We always allocate a guard page.
*/
//size要多算一个4k用于分隔
size += PAGE_SIZE;

write_lock(&vmlist_lock);
for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {
//寻找addr小于tmp->addr，作为新的vm的下个vm，否则就调整
if ((unsigned long)tmp->addr < addr) {
if((unsigned long)tmp->addr + tmp->size >= addr)
//addr 落在了tmp->addr 范围之内，进行addr为tmp->addr的末尾
addr = ALIGN(tmp->size + 
(unsigned long)tmp->addr, align);
continue;
}
if ((size + addr) < addr)
goto out;
//找到了新的vm区间，tmp作为新的vm的后继
if (size + addr <= (unsigned long)tmp->addr)
goto found;
addr = ALIGN(tmp->size + (unsigned long)tmp->addr, align);
//超出范围
if (addr > end - size)
goto out;
}

found:
area->next = *p;
*p = area; //插入链表

area->flags = flags;
area->addr = (void *)addr;
area->size = size;
area->pages = NULL;
area->nr_pages = 0;
area->phys_addr = 0;
write_unlock(&vmlist_lock);

return area;

out:
write_unlock(&vmlist_lock);
kfree(area);
if (printk_ratelimit())
printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size.\n");
return NULL;
}

以上完成 vm_struct 的创建及初始化，接下来申请物理页。

在 vm_struct 中记录着虚拟地址，以及物理内存的页框信息。

struct vm_struct {
/* keep next,addr,size together to speedup lookups */
struct vm_struct *next; //指向下一个结构指针
void *addr; //内存区虚拟地址的起始地址
unsigned long size;//内存区大小加4k(内存区之间的安全区大小)
unsigned long flags; //非连续内存区映射的内存的类型
struct page **pages; //指向nr_pages数组的指针，该数组由指向页描述符的指针组成
unsigned int nr_pages;//内存区填充的页的个数
unsigned long phys_addr;//该字段设置为0，除非内存已被创建来映射一个硬件设备的I/O共享内存
};

在 VMALLOC_START ~VMALLOC_END 区间申请的虚拟地址段，都是通过一个个 vm_struct 链表进行记录，所以每次通过 vmalloc 申请内存时，都会遍历 vm_struct 链表来进行查找未被使用的虚拟地址空间。

__vmalloc_area_node 用来分配物理内存，该内存区不保证连续性。

//为vm区分配非连续的内存区，以页为单位
void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
pgprot_t prot, int node)
{
struct page **pages;
unsigned int nr_pages, array_size, i;

//计算内存区占用的页面数
nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
array_size = (nr_pages * sizeof(struct page *));

area->nr_pages = nr_pages;
/* Please note that the recursion is strictly bounded. */
//若数组超过一页，则专门为这个数组占用的空间分配一个vm区
if (array_size > PAGE_SIZE) {
pages = __vmalloc_node(array_size, gfp_mask, PAGE_KERNEL, node);
area->flags |= VM_VPAGES;
} else {
pages = kmalloc_node(array_size,(gfp_mask & ~(__GFP_HIGHMEM | __GFP_ZERO)),node);
}
area->pages = pages;
//没有分配到内存，移除vm
if (!area->pages) {
...
}
memset(area->pages, 0, array_size);

/*为vm区占用的页分配页面(非连续，以页为单位分配)，一共占用了nr_pages 个页*/
for (i = 0; i < area->nr_pages; i++) {
if (node < 0)
area->pages[i] = alloc_page(gfp_mask);
else
area->pages[i] = alloc_pages_node(node, gfp_mask, 0);
if (unlikely(!area->pages[i])) {
/* Successfully allocated i pages, free them in __vunmap() */
area->nr_pages = i;
goto fail;
}
}
//建立线性地址到物理地址之间的映射
if (map_vm_area(area, prot, &pages))
goto fail;
return area->addr;

fail:
vfree(area->addr);
return NULL;
}

该函数为 vm 区分配页面，该页面已数组的形式保存于 vm_struct 中进行记录，同时把修改页表，完成虚拟地址到物理地址之间的映射。

从上面可知，vmalloc 申请内存时，同时也修改页表，通过vmalloc获得的页必须一个个地进行映射，因为它们物理上是不连续的，这就会导致比直接内存映射大得多的 TLB 抖动。

而在用户态进程调用 malloc 时并未修改页表，而是在用户进程访问时通过缺页异常中断后再分配相应的物理内存。

通过上述分析总结 vmalloc 流程如下：

1、在 VMALLOC_START ~VMALLOC_END 区间寻找一块未被使用的虚拟地址空间段，然后使用 vm_struct 进行记录。

2、申请所需要的物理页，这些物理页记录在 vm_struct 中。

3、对申请的每个物理页，在页表中完成虚拟地址到物理地址的映射，同时刷新页表缓存。