kernel 3.10代码分析--vmalloc(非连续内存页分配)

sky

1、为什么需要vmalloc
在分配内存时，总是希望能分配到连续的物理内存页，愿望是美好的，但系统中可能没有太多的连续内存可用(比如内存碎片严重时)，此时就需要一种非连续内存的分配方式。于是乎，就产生了vmalloc，vmalloc用于分配不连续的物理内存页，但将其映射到内核虚拟地址空间中后，其虚拟地址是连续的，使用vmalloc分配内存有三个特点：
1）物理内存不一定连续
2）返回的虚拟内存是连续的。
3）优先分配高端内存，所以vmalloc也是在内核态使用高端内存的最主要的方式。
在用户态，应用程序直接看到的是虚拟地址空间，物理内存和虚拟内存间通过页表映射，用户太分配的内存在虚拟地址空间中总是连续的，而物理内存是否连续不必关心，所以这对用户态来说其实没啥影响(除了会稍影响性能和占用TLB)。

2、基本原理(针对IA32)
内核虚拟地址空间中，有一段专门的区间用于vmalloc，称之vmalloc区，位于线性映射区之后，准确的说是从892M+8M(VMALLOC_START)到VMALLOC_END之间，其中892M是线性映射区，用于线性映射低端内存，之后的8M是安全间隙，用于区间隔离，防止越界。
vmalloc区中包含一个个独立的子区域，每个子区域用于一次独立映射，各个子区域间通过一个内存页进行隔离，防止不正确的内存访问操作。内核中管理vmalloc区中的子区域，使用了vm_struct数据结构



    /*
      * vmalloc区域中的子内存区，ioremap也使用了该区域
      * 所有的vm_struct组成一个链表，管理着vmalloc区域
      * 中已经建立的各个子区域，该链表头保存于
      * 全局变量vmlist中。
      */
    struct vm_struct {
        struct vm_struct    *next;
        //该内存区在虚拟地址空间中的起始地址
        void            *addr;
        // 该内存区的大小
        unsigned long        size;
        /*
         * 与该内存区关联的标志集合，用于指定内存
         * 区域类型，可选值有3:
         * VM_ALLOC指定由vmalloc产生的子区域
         * VM_MAP表示将现存pages集合映射到连续的虚拟
         地址空间中。
         * VM_IOREMAP表示将IO内存映射到vmalloc区域中。
         */
        unsigned long        flags;
        /*
          * 指向page指针的数组，每个数组成员表示一个
          * 映射到虚拟地址空间中的物理内存页的实例。
         */
        struct page        **pages;
        // pages数组项的数目，即该内存区对应的物理内存页数
        unsigned int        nr_pages;
        /*
         * ioremap时使用，用来保存该区域映射的物理
         * 内存地址，在通常的vmalloc流程中不使用该
         * 字段，因为vmalloc流程中会分配物理内存，并
         * 通过修改内核页表来实现虚拟地址到物理
         * 地址见的映射。
        */
        phys_addr_t        phys_addr;
        const void        *caller;
    };

vmalloc基本流程如下：
vmalloc()
-->__vmalloc()
     -->__vmalloc_node()
          -->__vmalloc_node_range()
               -->get_vm_area_node()     //从vmalloc区中获取空闲的子区域
               -->__vmalloc_area_node() //使用alloc_page分配物理内存，并修改页表，进行映射。

3、代码分析
__vmalloc_node_range:



    // vmalloc主处理函数
    void *__vmalloc_node_range(unsigned long size, unsigned long align,
                unsigned long start, unsigned long end, gfp_t gfp_mask,
                pgprot_t prot, int node, const void *caller)
    {
        //vmalloc区域中的子内存区
        struct vm_struct *area;
        void *addr;
        unsigned long real_size = size;

        // 分配内存区大小进行页对齐
        size = PAGE_ALIGN(size);
        if (!size || (size >> PAGE_SHIFT) > totalram_pages)
            goto fail;

        /*
         * 从vmalloc区中的子区域链表vmlist(全局变量)中
         * 获取空闲的子区域vm_struct。
         */
        
        area = __get_vm_area_node(size, align, VM_ALLOC | VM_UNLIST,
                     start, end, node, gfp_mask, caller);
        if (!area)
            goto fail;

        /*
         * 分配物理内存，并通过修改内核页表建立物理地址和虚拟
         * 地址间的映射，返回值为vmalloc区的虚拟地址
         */
        addr = __vmalloc_area_node(area, gfp_mask, prot, node, caller);
        if (!addr)
            return NULL;

        /*
         * In this function, newly allocated vm_struct has VM_UNLIST flag.
         * It means that vm_struct is not fully initialized.
         * Now, it is fully initialized, so remove this flag here.
         */
        clear_vm_unlist(area);

        /*
         * A ref_count = 3 is needed because the vm_struct and vmap_area
         * structures allocated in the __get_vm_area_node() function contain
         * references to the virtual address of the vmalloc'ed block.
         */
        kmemleak_alloc(addr, real_size, 3, gfp_mask);

        return addr;

    fail:
        warn_alloc_failed(gfp_mask, 0,
                 "vmalloc: allocation failure: %lu bytes\n",
                 real_size);
        return NULL;
    }

__vmalloc_area_node:



    static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
                     pgprot_t prot, int node, const void *caller)
    {
        const int order = 0;
        struct page **pages;
        unsigned int nr_pages, array_size, i;
        gfp_t nested_gfp = (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO;

        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. */
        if (array_size > PAGE_SIZE) {
            /*
             * 如果区域大小大于1页，则进行迭代，注意
             * 此处传入的内存分配标记中有__GFP_HIGHMEM，
             * 表示优先从高端内存中分配，这也是vmalloc
             * 的用处所在。
             */
            pages = __vmalloc_node(array_size, 1, nested_gfp|__GFP_HIGHMEM,
                    PAGE_KERNEL, node, caller);
            area->flags |= VM_VPAGES;
        // 迭代直到分配的区域大小小于1页，则使用kmalloc分配
        } else {
            pages = kmalloc_node(array_size, nested_gfp, node);
        }
        area->pages = pages;
        area->caller = caller;
        if (!area->pages) {
            remove_vm_area(area->addr);
            kfree(area);
            return NULL;
        }

        // 对于整页，逐页进行分配
        for (i = 0; i < area->nr_pages; i++) {
            struct page *page;
            gfp_t tmp_mask = gfp_mask | __GFP_NOWARN;

            if (node < 0)
                // 分配实际的物理页
                page = alloc_page(tmp_mask);
            else
                page = alloc_pages_node(node, tmp_mask, order);

            if (unlikely(!page)) {
                /* Successfully allocated i pages, free them in __vunmap() */
                area->nr_pages = i;
                goto fail;
            }
            // 将分配的page填入vm_struct结构中
            area->pages[i] = page;
        }

        /*
         * 将新分配的区域进行映射，即修改内核页表
         * (进程页表在page fault中更新)，建立虚拟地址到
         * 物理地址间的映射。
         */
        if (map_vm_area(area, prot, &pages))
            goto fail;
        return area->addr;

    fail:
        warn_alloc_failed(gfp_mask, order,
                 "vmalloc: allocation failure, allocated %ld of %ld bytes\n",
                 (area->nr_pages*PAGE_SIZE), area->size);
        vfree(area->addr);
        return NULL;
    }