Linux深入理解内存管理28

Linux深入理解内存管理28（基于Linux6.6）---vmalloc介绍

一、概述

1、vmalloc 概述

vmalloc 是 Linux 内核提供的内存分配函数之一，它用于在虚拟地址空间中分配连续的内存块。与 kmalloc 主要用于物理内存的分配不同，vmalloc 分配的内存并不要求物理内存是连续的，但它确保分配的虚拟地址空间是连续的。

简而言之，vmalloc 是一种适用于需要大块连续虚拟内存的场景，而不要求物理内存连续的内存分配机制。

2、vmalloc 与 kmalloc 的区别

1. 物理内存连续性：

   • kmalloc 分配的内存要求物理内存连续，通常用于一些小的、高速的内存需求。
   • vmalloc 分配的内存不要求物理内存连续，适用于大块内存的分配，例如需要映射大内存区域的情况。

2. 虚拟内存连续性：

   • kmalloc 分配的内存是连续的虚拟和物理内存。
   • vmalloc 分配的内存在虚拟地址空间中是连续的，但物理内存可能并不连续，内核会通过页面映射将其连贯起来。

3. 性能和效率：

   • kmalloc 使用较少的虚拟内存管理和页表映射操作，因此效率较高，适用于小块内存的高速分配。
   • vmalloc 需要进行更多的内存映射和管理，性能相对较低，通常用于大块内存的分配。

4. 内存大小：

   • kmalloc 通常用于小于几兆字节的内存分配（如几十 KB 或更少的内存）。
   • vmalloc 通常用于需要大于 kmalloc 能够分配的内存的场景，如分配数 MB 到数 GB 的内存。

3、vmalloc 的工作原理

1. 虚拟地址分配：

   • vmalloc 在内核的虚拟地址空间中分配连续的内存区域。这些虚拟地址是连续的，但可能对应的物理内存页并不连续。
   • 内核通过 vmalloc 获取虚拟地址空间，并为每个虚拟页分配一个物理内存页。

2. 内存映射：

   • 虽然 vmalloc 分配的虚拟内存是连续的，但物理内存页是分散的。内核通过内存映射（page table）将这些虚拟地址映射到物理内存上。每个虚拟页都对应着一个物理页。
   • 这种映射使用了内核中的页表，操作相对较复杂，因此 vmalloc 的性能比 kmalloc 要低。

3. 适用场景：

   • vmalloc 主要用于需要大块连续虚拟内存空间，但不要求物理内存连续的情况。例如，一些内核模块可能需要分配非常大的缓冲区，这时就可以使用 vmalloc 来实现。

4. 内存释放：

   • 与 kmalloc 一样，vmalloc 分配的内存也需要在不再使用时通过 vfree 进行释放。
   • vfree 函数会解除这些虚拟地址和物理地址之间的映射，并释放这些内存。

在Linux内核中对于物理上连续的分配方式，采用伙伴系统和slub分配器分配内存，但是知道物理上连续的映射是最好的分配方式，但并不总能成功地使用。在分配一大块内存时，可能竭尽全力也无法找到连续的内存块。针对这种情况内核提供了一种申请一片连续的虚拟地址空间，但不保证物理空间连续，也就是vmalloc接口。

• vmalloc的工作方式类似于kmalloc，只不过前者分配的内存虚拟地址连续，而物理地址则无需连续，因此不能用于dma缓冲区
• 通过vmalloc获得的页必须一个一个地进行映射，效率不高，因此不得已时才使用，同时vmalloc分配的一般是大块内存
• vmalloc分配的一般是高端内存，只有当内存不够的时候，才会分配低端内存

二、Vmalloc数据结构

struct vm_struct(vmalloc描述符)和struct vmap_area(记录在vmap_area_root中的vmalooc分配情况和vmap_area_list列表中)。内核在管理虚拟内存中的vmalloc区域时，必须跟踪哪些区域被使用，哪些是空闲的，为此定义了一个数据结构，将所有的部分保存在一个链表中。

include/linux/vmalloc.h

struct vm_struct {
	struct vm_struct	*next;
	void			*addr;
	unsigned long		size;
	unsigned long		flags;
	struct page		**pages;
#ifdef CONFIG_HAVE_ARCH_HUGE_VMALLOC
	unsigned int		page_order;
#endif
	unsigned int		nr_pages;
	phys_addr_t		phys_addr;
	const void		*caller;
};

 在创建一个新的虚拟内存区之前，必须要找到一个适合的位置。

include/linux/vmalloc.h

struct vmap_area {
	unsigned long va_start;
	unsigned long va_end;

	struct rb_node rb_node;         /* address sorted rbtree */
	struct list_head list;          /* address sorted list */

	/*
	 * The following two variables can be packed, because
	 * a vmap_area object can be either:
	 *    1) in "free" tree (root is free_vmap_area_root)
	 *    2) or "busy" tree (root is vmap_area_root)
	 */
	union {
		unsigned long subtree_max_size; /* in "free" tree */
		struct vm_struct *vm;           /* in "busy" tree */
	};
};

struct vmap_area用于描述一段虚拟地址的区域，从结构体中va_start/va_end也能看出来。同时该结构体会通过rb_node挂在红黑树上，通过list挂在链表上。
struct vmap_area中vm字段是struct vm_struct结构，用于管理虚拟地址和物理页之间的映射关系，可以将struct vm_struct构成一个链表，维护多段映射。

三、Vmalloc初始化

在系统初始化的时候，会通过mm_init初始化vmalloc，其初始化流程如下：

mm/vmalloc.c

void __init vmalloc_init(void)
{
	struct vmap_area *va;
	struct vm_struct *tmp;
	int i;

	/*
	 * Create the cache for vmap_area objects.
	 */
	vmap_area_cachep = KMEM_CACHE(vmap_area, SLAB_PANIC);

	for_each_possible_cpu(i) {---解析1
		struct vmap_block_queue *vbq;
		struct vfree_deferred *p;

		vbq = &per_cpu(vmap_block_queue, i);
		spin_lock_init(&vbq->lock);
		INIT_LIST_HEAD(&vbq->free);
		p = &per_cpu(vfree_deferred, i);
		init_llist_head(&p->list);
		INIT_WORK(&p->wq, free_work);
	}

	/* Import existing vmlist entries. */
	for (tmp = vmlist; tmp; tmp = tmp->next) {---解析2
		va = kmem_cache_zalloc(vmap_area_cachep, GFP_NOWAIT);
		if (WARN_ON_ONCE(!va))
			continue;

		va->va_start = (unsigned long)tmp->addr;
		va->va_end = va->va_start + tmp->size;
		va->vm = tmp;
		insert_vmap_area(va, &vmap_area_root, &vmap_area_list);
	}

	/*
	 * Now we can initialize a free vmap space.
	 */
	vmap_init_free_space();
	vmap_initialized = true;
}

1. 先遍历每CPU的vmap_block_queue和vfree_deferred变量并进行初始化。其中vmap_block_queue是非连续内存块队列管理结构，主要是队列以及对应的保护锁；而vfree_deferred是vmalloc的内存延迟释放管理，除了队列初始外，还创建了一个free_work()工作队列用于异步释放内存。
2. 接着将挂接在vmlist链表的各项__insert_vmap_area()输入到非连续内存块的管理中，而vmlist的初始化是通过iotable_init初始化(arm32)，最终所有的vmalloc的eara都会挂到vmap_area_list链表中。

四、Vmalloc分配

vmalloc为内核分配了一个连续的@size虚拟地址空间，然后调用__vmalloc_node()函数。

mm/vmalloc.c

void *vmalloc(unsigned long size)
{
	return __vmalloc_node(size, 1, GFP_KERNEL, NUMA_NO_NODE,
				__builtin_return_address(0));
}
EXPORT_SYMBOL(vmalloc);

__vmalloc_node请求节点为内核分配连续的虚拟内存。

对于内核，@node分配连续的虚拟内存，但是虚拟地址使用VMALLOC地址空间的空白空间映射虚拟地址[VMALLOC_START, VMALLOC_END]。

mm/vmalloc.c

void *__vmalloc_node(unsigned long size, unsigned long align,
			    gfp_t gfp_mask, int node, const void *caller)
{
	return __vmalloc_node_range(size, align, VMALLOC_START, VMALLOC_END,
				gfp_mask, PAGE_KERNEL, 0, node, caller);
}

请求节点分配连续的虚拟内存，但虚拟地址使用指定范围内的空白空间映射虚拟地址。

mm/vmalloc.c

void *__vmalloc_node_range(unsigned long size, unsigned long align,
			unsigned long start, unsigned long end, gfp_t gfp_mask,
			pgprot_t prot, unsigned long vm_flags, int node,
			const void *caller)
{
	struct vm_struct *area;
	void *ret;
	kasan_vmalloc_flags_t kasan_flags = KASAN_VMALLOC_NONE;
	unsigned long real_size = size;
	unsigned long real_align = align;
	unsigned int shift = PAGE_SHIFT;

	if (WARN_ON_ONCE(!size))
		return NULL;

	if ((size >> PAGE_SHIFT) > totalram_pages()) {---解析1
		warn_alloc(gfp_mask, NULL,
			"vmalloc error: size %lu, exceeds total pages",
			real_size);
		return NULL;
	}

	if (vmap_allow_huge && (vm_flags & VM_ALLOW_HUGE_VMAP)) {
		unsigned long size_per_node;

		/*
		 * Try huge pages. Only try for PAGE_KERNEL allocations,
		 * others like modules don't yet expect huge pages in
		 * their allocations due to apply_to_page_range not
		 * supporting them.
		 */

		size_per_node = size;
		if (node == NUMA_NO_NODE)
			size_per_node /= num_online_nodes();
		if (arch_vmap_pmd_supported(prot) && size_per_node >= PMD_SIZE)
			shift = PMD_SHIFT;
		else
			shift = arch_vmap_pte_supported_shift(size_per_node);

		align = max(real_align, 1UL << shift);
		size = ALIGN(real_size, 1UL << shift);
	}

again:
	area = __get_vm_area_node(real_size, align, shift, VM_ALLOC |
				  VM_UNINITIALIZED | vm_flags, start, end, node,
				  gfp_mask, caller);---解析2
	if (!area) {
		bool nofail = gfp_mask & __GFP_NOFAIL;
		warn_alloc(gfp_mask, NULL,
			"vmalloc error: size %lu, vm_struct allocation failed%s",
			real_size, (nofail) ? ". Retrying." : "");
		if (nofail) {
			schedule_timeout_uninterruptible(1);
			goto again;
		}
		goto fail;
	}

	/*
	 * Prepare arguments for __vmalloc_area_node() and
	 * kasan_unpoison_vmalloc().
	 */
	if (pgprot_val(prot) == pgprot_val(PAGE_KERNEL)) {
		if (kasan_hw_tags_enabled()) {
			/*
			 * Modify protection bits to allow tagging.
			 * This must be done before mapping.
			 */
			prot = arch_vmap_pgprot_tagged(prot);

			/*
			 * Skip page_alloc poisoning and zeroing for physical
			 * pages backing VM_ALLOC mapping. Memory is instead
			 * poisoned and zeroed by kasan_unpoison_vmalloc().
			 */
			gfp_mask |= __GFP_SKIP_KASAN_UNPOISON | __GFP_SKIP_ZERO;
		}

		/* Take note that the mapping is PAGE_KERNEL. */
		kasan_flags |= KASAN_VMALLOC_PROT_NORMAL;
	}

	/* Allocate physical pages and map them into vmalloc space. */
	ret = __vmalloc_area_node(area, gfp_mask, prot, shift, node);---解析3
	if (!ret)
		goto fail;

	/*
	 * Mark the pages as accessible, now that they are mapped.
	 * The condition for setting KASAN_VMALLOC_INIT should complement the
	 * one in post_alloc_hook() with regards to the __GFP_SKIP_ZERO check
	 * to make sure that memory is initialized under the same conditions.
	 * Tag-based KASAN modes only assign tags to normal non-executable
	 * allocations, see __kasan_unpoison_vmalloc().
	 */
	kasan_flags |= KASAN_VMALLOC_VM_ALLOC;
	if (!want_init_on_free() && want_init_on_alloc(gfp_mask) &&
	    (gfp_mask & __GFP_SKIP_ZERO))
		kasan_flags |= KASAN_VMALLOC_INIT;
	/* KASAN_VMALLOC_PROT_NORMAL already set if required. */
	area->addr = kasan_unpoison_vmalloc(area->addr, real_size, kasan_flags);

	/*
	 * In this function, newly allocated vm_struct has VM_UNINITIALIZED
	 * flag. It means that vm_struct is not fully initialized.
	 * Now, it is fully initialized, so remove this flag here.
	 */
	clear_vm_uninitialized_flag(area);---解析4

	size = PAGE_ALIGN(size);
	if (!(vm_flags & VM_DEFER_KMEMLEAK))
		kmemleak_vmalloc(area, size, gfp_mask);

	return area->addr;

fail:
	if (shift > PAGE_SHIFT) {
		shift = PAGE_SHIFT;
		align = real_align;
		size = real_size;
		goto again;
	}

	return NULL;
}

1. 检查size正确性，不能为0且不能大于totalram_pages，totalram_pages是bootmem分配器移交给伙伴系统的物理内存页数总和，则通过故障标签返回null。
2. 请求虚拟地址范围内找到一个可以包含请求大小的空位置，并使用该虚拟地址配置vmap_area和vm_struct信息，然后将其返回，其最终是分配一个vm_struct结构，获取对应长度(注意额外加一页)高端连续地址，最终插入vmlist链表，也就是向内核请求一个空间大小相匹配的虚拟地址空间，返回管理信息结构vm_struct。
3. alloc_vmap_area作用就是根据所要申请的高端地址的长度size(注意这里的size已经是加上一页隔离带的size)，在vmalloc区找到一个合适的区间并把起始虚拟地址和结尾地址通知给内核。
4. 标示内存空间初始化，最后调用kmemleak_alloc()进行内存分配泄漏调测，并将虚拟地址返回。

操作流程比较简单，下面是整个流程图如下：

__vmalloc_node_range是vmalloc的核心函数，其主要是完成找到符合大小的空闲vmalloc区域，其代码流程如下 ：

mm/vmalloc.c

static struct vm_struct *__get_vm_area_node(unsigned long size,
		unsigned long align, unsigned long shift, unsigned long flags,
		unsigned long start, unsigned long end, int node,
		gfp_t gfp_mask, const void *caller)
{
	struct vmap_area *va;
	struct vm_struct *area;
	unsigned long requested_size = size;

	BUG_ON(in_interrupt()); //vmalloc不能中在中断中被调用
	size = ALIGN(size, 1ul << shift); //页对齐操作
	if (unlikely(!size))
		return NULL;

	if (flags & VM_IOREMAP)
		align = 1ul << clamp_t(int, get_count_order_long(size),
				       PAGE_SHIFT, IOREMAP_MAX_ORDER);

	area = kzalloc_node(sizeof(*area), gfp_mask & GFP_RECLAIM_MASK, node); //分配一个struct vm_struct来描述vmalloc区域
	if (unlikely(!area))
		return NULL;

	if (!(flags & VM_NO_GUARD)) //加一页作为安全区间
		size += PAGE_SIZE;

	va = alloc_vmap_area(size, align, start, end, node, gfp_mask); //申请一个vmap_area并将其插入vmap_area_root中
	if (IS_ERR(va)) {
		kfree(area);
		return NULL;
	}

	setup_vmalloc_vm(area, va, flags, caller); //填充vmalloc描述符vm_struct area

	/*
	 * Mark pages for non-VM_ALLOC mappings as accessible. Do it now as a
	 * best-effort approach, as they can be mapped outside of vmalloc code.
	 * For VM_ALLOC mappings, the pages are marked as accessible after
	 * getting mapped in __vmalloc_node_range().
	 * With hardware tag-based KASAN, marking is skipped for
	 * non-VM_ALLOC mappings, see __kasan_unpoison_vmalloc().
	 */
	if (!(flags & VM_ALLOC))
		area->addr = kasan_unpoison_vmalloc(area->addr, requested_size,
						    KASAN_VMALLOC_PROT_NORMAL);

	return area;
}

__vmalloc_area_node则进行实际的页面分配，并建立页表映射，更新页表cache，其代码流程如下：

mm/vmalloc.c

static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
				 pgprot_t prot, unsigned int page_shift,
				 int node)
{
	const gfp_t nested_gfp = (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO;//添加__GFP_ZERO，仅保留与页数相关的标志
	bool nofail = gfp_mask & __GFP_NOFAIL;//将__GFP_NOWARN添加到gfp_mask
	unsigned long addr = (unsigned long)area->addr;
	unsigned long size = get_vm_area_size(area);
	unsigned long array_size;
	unsigned int nr_small_pages = size >> PAGE_SHIFT;//申请多少pages
	unsigned int page_order;
	unsigned int flags;
	int ret;

	array_size = (unsigned long)nr_small_pages * sizeof(struct page *);//需要多大的存放page指针的空间
	gfp_mask |= __GFP_NOWARN;
	if (!(gfp_mask & (GFP_DMA | GFP_DMA32)))
		gfp_mask |= __GFP_HIGHMEM;

	/* Please note that the recursion is strictly bounded. */
	if (array_size > PAGE_SIZE) {// 这里默认page_size 为4k 即4096
		area->pages = __vmalloc_node(array_size, 1, nested_gfp, node,
					area->caller); //小于一页，则直接利用slab机制申请物理空间地址给pages
	} else {
		area->pages = kmalloc_node(array_size, nested_gfp, node);
	}

	if (!area->pages) {
		warn_alloc(gfp_mask, NULL,
			"vmalloc error: size %lu, failed to allocated page array size %lu",
			nr_small_pages * PAGE_SIZE, array_size);
		free_vm_area(area);
		return NULL;
	}

	set_vm_area_page_order(area, page_shift - PAGE_SHIFT);
	page_order = vm_area_page_order(area);

	area->nr_pages = vm_area_alloc_pages(gfp_mask | __GFP_NOWARN,
		node, page_order, nr_small_pages, area->pages);

	atomic_long_add(area->nr_pages, &nr_vmalloc_pages);
	if (gfp_mask & __GFP_ACCOUNT) {
		int i;

		for (i = 0; i < area->nr_pages; i++)//每次申请一个page利用alloc_page直接申请物理页面
			mod_memcg_page_state(area->pages[i], MEMCG_VMALLOC, 1);
	}

	/*
	 * If not enough pages were obtained to accomplish an
	 * allocation request, free them via __vfree() if any.
	 */
	if (area->nr_pages != nr_small_pages) {
		warn_alloc(gfp_mask, NULL,
			"vmalloc error: size %lu, page order %u, failed to allocate pages",
			area->nr_pages * PAGE_SIZE, page_order);
		goto fail;
	}

	/*
	 * page tables allocations ignore external gfp mask, enforce it
	 * by the scope API
	 */
	if ((gfp_mask & (__GFP_FS | __GFP_IO)) == __GFP_IO)
		flags = memalloc_nofs_save();
	else if ((gfp_mask & (__GFP_FS | __GFP_IO)) == 0)
		flags = memalloc_noio_save();

	do {
		ret = vmap_pages_range(addr, addr + size, prot, area->pages,
			page_shift);
		if (nofail && (ret < 0))
			schedule_timeout_uninterruptible(1);
	} while (nofail && (ret < 0));

	if ((gfp_mask & (__GFP_FS | __GFP_IO)) == __GFP_IO)
		memalloc_nofs_restore(flags);
	else if ((gfp_mask & (__GFP_FS | __GFP_IO)) == 0)
		memalloc_noio_restore(flags);

	if (ret < 0) {
		warn_alloc(gfp_mask, NULL,
			"vmalloc error: size %lu, failed to map pages",
			area->nr_pages * PAGE_SIZE);
		goto fail;
	}

	return area->addr;

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

__vmalloc_area_node()已经分配了所需的物理页框，但是这些分散的页框并没有映射到area所代表的那个连续vmalloc区中。map_vm_area()将完成映射工作，它依次修改内核使用的页表项，将pages数组中的每个页框分别映射到连续的vmalloc区中。其整个流程如下：

• 1.通过__get_vm_area_node()函数查找一个足够大的空间的虚拟地址段，然后再通过kmalloc分配一个新的vm_struct结构体
• 2.计算当前分配的内存大小需要占用多少个page，然后通过kmalloc分配一组struct page指针数组，再通过调用buddy allocator接口alloc_page()每次获取一个物理页框填入到vm_struct中的struct page* 数则
• 3.分配PMD，PTE更新内核页表，返回映射后的虚拟地址。

此次，vmalloc在虚拟内存空间给出一块连续的内存区，实质上，这片连续的虚拟内存在物理内存中并不一定连续，所以vmalloc申请的虚拟内存和物理内存之间也就没有简单的换算关系，正因如此，vmalloc()通常用于分配远大于__get_free_pages()的内存空间，它的实现需要建立新的页表，此外还会调用使用GFP_KERN的kmalloc，一定不要在中断处理函数，tasklet和内核定时器等非进程上下文中使用vmalloc。

五、其他分配

除了vmalloc之外，还有其他可以创建虚拟连续映射。

• vmalloc_32分配适用于32位地址的内存区域。该函数会保证物理pages是从ZONE_NORMAL中进行分配并且要求当前设备是32位的，其工作方式与vmalloc相同
• vmap使用一个page数组作为七点，来创建虚拟连续内存区。与vmalloc相比，该函数所用的物理内存位置不是隐式分配的，而需要先行分配好，作为参数传递。

介绍下vmap的流程，vmap函数完成的工作是，在vmalloc虚拟地址空间中找到一个空闲区域，然后将page页面数组对应的物理内存映射到该区域，最终返回映射的虚拟起始地址。

mm/vmalloc.c

void *vmap(struct page **pages, unsigned int count,
	   unsigned long flags, pgprot_t prot)
{
	struct vm_struct *area;
	unsigned long addr;
	unsigned long size;		/* In bytes */

	might_sleep();---解析1

	/*
	 * Your top guard is someone else's bottom guard. Not having a top
	 * guard compromises someone else's mappings too.
	 */
	if (WARN_ON_ONCE(flags & VM_NO_GUARD))
		flags &= ~VM_NO_GUARD;

	if (count > totalram_pages())
		return NULL;

	size = (unsigned long)count << PAGE_SHIFT;---解析2
	area = get_vm_area_caller(size, flags, __builtin_return_address(0));
	if (!area)
		return NULL;

	addr = (unsigned long)area->addr;
	if (vmap_pages_range(addr, addr + size, pgprot_nx(prot),---解析3
				pages, PAGE_SHIFT) < 0) {
		vunmap(area->addr);
		return NULL;
	}

	if (flags & VM_MAP_PUT_PAGES) {
		area->pages = pages;
		area->nr_pages = count;
	}
	return area->addr;
}
EXPORT_SYMBOL(vmap);

• 1.如果有任务紧急请求重新安排作为抢占点，则它将休眠；如果请求的页数比所有内存页数多，则放弃处理并返回null。
• 2.VM分配配置vmap_area和vm_struct信息。失败时，将返回null。
• 3.vmap_pages_range尝试映射具有vm_struct信息的页面，如果不成功，则在取消后返回null，如果成功，就返回映射的虚拟地址空间的起始地址。

其整个代码流程如下：

下图通过在vmap虚拟地址空间中找到空白空间来显示请求的物理页面的映射 ：

六、释放内存

有两个函数用于向内核释放内存，这两个函数都最终归结到vunmap。

• vfree用于释放vmalloc和vmalloc_32分配的区域。
• vunmap用于释放由vmap和Ioremap创建的映射。

释放由vmalloc（）分配和映射的连续虚拟地址内存。当通过中断处理程序调用时，映射的连续虚拟地址内存无法立即释放，因此在将工作队列中注册的free_work（）函数添加到每个CPU vfree_deferred中以进行延迟处理后，对其进行调度。

mm/vmalloc.c

void vfree(const void *addr)
{
	BUG_ON(in_nmi());

	kmemleak_free(addr);

	might_sleep_if(!in_interrupt());

	if (!addr)
		return;

	__vfree(addr);
}
EXPORT_SYMBOL(vfree);

static void __vfree(const void *addr)
{
	if (unlikely(in_interrupt()))
		__vfree_deferred(addr);
	else
		__vunmap(addr, 1);
}

vmap（）函数取消映射到vmalloc地址空间的虚拟地址区域的映射。但是，物理页面不会被释放。

mm/vmalloc.c

void vunmap(const void *addr)
{
	BUG_ON(in_interrupt());
	might_sleep();
	if (addr)
		__vunmap(addr, 0);
}

vunmap执行的是跟vmap相反的过程：从vmap_area_root/vmap_area_list中查找vmap_area区域，取消页表映射，再从vmap_area_root/vmap_area_list中删除掉vmap_area，页面返还给伙伴系统等。由于映射关系有改动，因此还需要进行TLB的刷新，频繁的TLB刷新会降低性能，因此将其延迟进行处理，因此称为lazy tlb。
mm/vmalloc.c

static void __vunmap(const void *addr, int deallocate_pages)
{
	struct vm_struct *area;

	if (!addr)
		return;

	if (WARN(!PAGE_ALIGNED(addr), "Trying to vfree() bad address (%p)\n",
			addr))
		return;

	area = find_vm_area(addr);
	if (unlikely(!area)) {
		WARN(1, KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
				addr);
		return;
	}

	debug_check_no_locks_freed(area->addr, get_vm_area_size(area));
	debug_check_no_obj_freed(area->addr, get_vm_area_size(area));

	kasan_poison_vmalloc(area->addr, get_vm_area_size(area));

	vm_remove_mappings(area, deallocate_pages);

	if (deallocate_pages) {
		int i;

		for (i = 0; i < area->nr_pages; i++) {
			struct page *page = area->pages[i];

			BUG_ON(!page);
			mod_memcg_page_state(page, MEMCG_VMALLOC, -1);
			/*
			 * High-order allocs for huge vmallocs are split, so
			 * can be freed as an array of order-0 allocations
			 */
			__free_pages(page, 0);
			cond_resched();
		}
		atomic_long_sub(area->nr_pages, &nr_vmalloc_pages);

		kvfree(area->pages);
	}

	kfree(area);
}

addr表示要释放的区域的起始地址，deallocate_pages指定了是否将与该区域相关的物理内存页返回给伙伴系统。其代码流程如下图：

七、总结

对于物理内存不连续，虚拟内存连续的内存申请的方式，vmalloc和vmap的操作，大部分的逻辑操作是一样的，比如从VMALLOC_START ~ VMALLOC_END区域之间查找并分配vmap_area， 比如对虚拟地址和物理页框进行映射关系的建立。

不同之处，在于vmap建立映射时，page是函数传入进来的，而vmalloc是通过调用alloc_page接口向Buddy System申请分配的。

清楚vmalloc和kmalloc的差异，kmalloc会根据申请的大小来选择基于slub分配器或者基于Buddy System来申请连续的物理内存。而vmalloc则是通过alloc_page申请order = 0的页面，再映射到连续的虚拟空间中，物理地址不连续，此外vmalloc可以休眠，不应在中断处理程序中使用。
与vmalloc相比，kmalloc使用ZONE_DMA和ZONE_NORMAL空间，性能更快，缺点是连续物理内存空间的分配容易带来碎片问题，让碎片的管理变得困难，结合前面学习的伙伴系统和slab分配方式，总结如下：