内存管理[3]

 

    vmalloc()函数的工作方式类似于kmalloc()，只不过前者分配的内存虚拟地址是连续的，而物理地址则无需连续。这也是用户空间分配函数的工作方式：由malloc()返回的页在进程的虚拟地址空间内是连续的，但是，这并不保证它们在物理RAM中也连续。kmalloc()函数确保页在物理地址上是连续的（虚拟地址自然也是连续的）。vmalloc()函数只确保页在虚拟地址空间内是连续的。它通过分配非连续的物理内存块，再“修正”页表，把内存映射到逻辑地址空间的连续区域中，就能做到这一点。

   一般只有硬件设备需要得到物理地址连续的内存。在很多体系结构上，硬件设备存在于内存管理单元以外，它根本不理解什么是虚拟地址。因此，硬件设备用到的任何内存区都必须是物理上连续的块，而不仅仅是虚拟地址连续的块。而仅供软件使用的内存块（例如与进程相关的缓冲区）就可以使用只有虚拟地址连续的内存块。对内核而言，所有内存看起来都是逻辑上连续的。

   尽管紧急在某些情况下才需要物理上连续的内存块，但是，很多内核代码都用kmalloc()来获得内存，而不是vmalloc()。因为vmalloc()函数为了把物理上不连续的页转换为虚拟地址空间上连续的页，必须专门建立页表项。通过vmalloc()获得的页必须一个一个地进行映射，这就导致比直接内存映射大得多的TLB抖动。因此，vmalloc()只在不得已的时候才用，一般是为了获得大块内存时，如，当模块被动态的插入到内核中，就把模块装载到由vmalloc()分配的内存上。

   

1. 在<Vmalloc.c(mm)>
3. /**
4.  *  vmalloc  -  allocate virtually contiguous memory
5.  *  @size:      allocation size
6.  *  Allocate enough pages to cover @size from the page level
7.  *  allocator and map them into contiguous kernel virtual space.
8.  *
9.  *  For tight control over page level allocator and protection flags
10.  *  use __vmalloc() instead.
11.  */
12. void *vmalloc(unsigned long size)
13. {
14.     return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
15. }
17. void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
18. {
19.     return __vmalloc_node(size, gfp_mask, prot, -1);
20. }
22. /**
23.  *  __vmalloc_node  -  allocate virtually contiguous memory
24.  *  @size:      allocation size
25.  *  @gfp_mask:  flags for the page level allocator
26.  *  @prot:      protection mask for the allocated pages
27.  *  @node:      node to use for allocation or -1
28.  *
29.  *  Allocate enough pages to cover @size from the page level
30.  *  allocator with @gfp_mask flags.  Map them into contiguous
31.  *  kernel virtual space, using a pagetable protection of @prot.
32.  */
33. static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
34.                 int node)
35. {
36.     struct vm_struct *area;
38.     size = PAGE_ALIGN(size);
39.     if (!size || (size >> PAGE_SHIFT) > num_physpages)
40.         return NULL;
42.     area = get_vm_area_node(size, VM_ALLOC, node, gfp_mask);
43.     if (!area)
44.         return NULL;
46.     return __vmalloc_area_node(area, gfp_mask, prot, node);
47. }
49. struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
50.                 unsigned long start, unsigned long end)
51. {
52.     return __get_vm_area_node(size, flags, start, end, -1, GFP_KERNEL);
53. }
55. static struct vm_struct *__get_vm_area_node(unsigned long size, unsigned long flags,
56.                         unsigned long start, unsigned long end,
57.                         int node, gfp_t gfp_mask)
58. {
59.     struct vm_struct **p, *tmp, *area;
60.     unsigned long align = 1;
61.     unsigned long addr;
63.     BUG_ON(in_interrupt());
64.     if (flags & VM_IOREMAP) {
65.         int bit = fls(size);
67.         if (bit > IOREMAP_MAX_ORDER)
68.             bit = IOREMAP_MAX_ORDER;
69.         else if (bit < PAGE_SHIFT)
70.             bit = PAGE_SHIFT;
72.         align = 1ul << bit;
73.     }
74.     addr = ALIGN(start, align);
75.     size = PAGE_ALIGN(size);
76.     if (unlikely(!size))
77.         return NULL;
79.     area = kmalloc_node(sizeof(*area), gfp_mask & GFP_LEVEL_MASK, node);
80.     if (unlikely(!area))
81.         return NULL;
83.     /*
84.      * We always allocate a guard page.
85.      */
86.     size += PAGE_SIZE;
88.     write_lock(&vmlist_lock);
89.     for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {
90.         if ((unsigned long)tmp->addr < addr) {
91.             if((unsigned long)tmp->addr + tmp->size >= addr)
92.                 addr = ALIGN(tmp->size + 
93.                          (unsigned long)tmp->addr, align);
94.             continue;
95.         }
96.         if ((size + addr) < addr)
97.             goto out;
98.         if (size + addr <= (unsigned long)tmp->addr)
99.             goto found;
100.         addr = ALIGN(tmp->size + (unsigned long)tmp->addr, align);
101.         if (addr > end - size)
102.             goto out;
103.     }
105. found:
106.     area->next = *p;
107.     *p = area;
109.     area->flags = flags;
110.     area->addr = (void *)addr;
111.     area->size = size;
112.     area->pages = NULL;
113.     area->nr_pages = 0;
114.     area->phys_addr = 0;
115.     write_unlock(&vmlist_lock);
117.     return area;
119. out:
120.     write_unlock(&vmlist_lock);
121.     kfree(area);
122.     if (printk_ratelimit())
123.         printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size./n");
124.     return NULL;
125. }

   函数可能睡眠，因此不能在中断上下文进行调用，也不能在其他不允许阻塞情况下调用。

   要释放通过vmalloc()函数所获得的内存，使用下面的函数：

2. /**
3.  *  vfree  -  release memory allocated by vmalloc()
4.  *  @addr:      memory base address
5.  *
6.  *  Free the virtually contiguous memory area starting at @addr, as
7.  *  obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
8.  *  NULL, no operation is performed.
9.  *
10.  *  Must not be called in interrupt context.
11.  */
12. void vfree(void *addr)
13. {
14.     BUG_ON(in_interrupt());
15.     __vunmap(addr, 1);
16. }
18. void __vunmap(void *addr, int deallocate_pages)
19. {
20.     struct vm_struct *area;
22.     if (!addr)
23.         return;
25.     if ((PAGE_SIZE-1) & (unsigned long)addr) {
26.         printk(KERN_ERR "Trying to vfree() bad address (%p)/n", addr);
27.         WARN_ON(1);
28.         return;
29.     }
31.     area = remove_vm_area(addr);
32.     if (unlikely(!area)) {
33.         printk(KERN_ERR "Trying to vfree() nonexistent vm area (%p)/n",
34.                 addr);
35.         WARN_ON(1);
36.         return;
37.     }
39.     debug_check_no_locks_freed(addr, area->size);
41.     if (deallocate_pages) {
42.         int i;
44.         for (i = 0; i < area->nr_pages; i++) {
45.             BUG_ON(!area->pages[i]);
46.             __free_page(area->pages[i]);
47.         }
49.         if (area->flags & VM_VPAGES)
50.             vfree(area->pages);
51.         else
52.             kfree(area->pages);
53.     }
55.     kfree(area);
56.     return;
57. }
59. /**
60.  *  remove_vm_area  -  find and remove a contingous kernel virtual area
61.  *  @addr:      base address
62.  *
63.  *  Search for the kernel VM area starting at @addr, and remove it.
64.  *  This function returns the found VM area, but using it is NOT safe
65.  *  on SMP machines, except for its size or flags.
66.  */
67. struct vm_struct *remove_vm_area(void *addr)
68. {
69.     struct vm_struct *v;
70.     write_lock(&vmlist_lock);
71.     v = __remove_vm_area(addr);
72.     write_unlock(&vmlist_lock);
73.     return v;
74. }
76. /* Caller must hold vmlist_lock */
77. static struct vm_struct *__remove_vm_area(void *addr)
78. {
79.     struct vm_struct **p, *tmp;
81.     for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
82.          if (tmp->addr == addr)
83.              goto found;
84.     }
85.     return NULL;
87. found:
88.     unmap_vm_area(tmp);
89.     *p = tmp->next;
91.     /*
92.      * Remove the guard page.
93.      */
94.     tmp->size -= PAGE_SIZE;
95.     return tmp;
96. }

   这个函数也可以睡眠，因此不能在中断上下文中调用。