linux高端内存管理之非连续内存区（分配和释放）

三里屯摇滚

linux高端内存管理之非连续内存区（分配和释放）

前面总结了非连续内存区域的内核描述，接着看看他的分配和释放。

一、非连续内存区的分配

不管是vmalloc()还是vmalloc_32()等系列的分配函数最后都会调用__vmalloc_node()函数实现，直接看这个函数的实现。

1. view plaincopy to clipboardprint? *  __vmalloc_node  -  allocate virtually contiguous memory  
   
2. *  @size:      allocation size  
   
3. *  @align:     desired alignment  
   
4. *  @gfp_mask:  flags for the page level allocator  
   
5. *  @prot:      protection mask for the allocated pages  
   
6. *  @node:      node to use for allocation or -1  
   
7. *  @caller:    caller's return address  
   
8. *  
   
9. *  Allocate enough pages to cover @size from the page level  
   
10. *  allocator with @gfp_mask flags.  Map them into contiguous  
    
11. *  kernel virtual space, using a pagetable protection of @prot.  
    
12. */  
    
13. static void *__vmalloc_node(unsigned long size, unsigned long align,  
    
14.                 gfp_t gfp_mask, pgprot_t prot,  
    
15.                 int node, void *caller)  
    
16. {  
    
17.     struct vm_struct *area;  
    
18.     void *addr;  
    
19.     unsigned long real_size = size;  
    
20.   
    
21.     size = PAGE_ALIGN(size);  
    
22.     if (!size || (size >> PAGE_SHIFT) > totalram_pages)  
    
23.         return NULL;  
    
24.     /*分配相关的结构并对其初始化，在前面介绍过了*/  
    
25.     area = __get_vm_area_node(size, align, VM_ALLOC, VMALLOC_START,  
    
26.                   VMALLOC_END, node, gfp_mask, caller);  
    
27.   
    
28.     if (!area)  
    
29.         return NULL;  
    
30.     /*分配物理空间，建立页表映射*/  
    
31.     addr = __vmalloc_area_node(area, gfp_mask, prot, node, caller);  
    
32.   
    
33.     /*
    
34.      * A ref_count = 3 is needed because the vm_struct and vmap_area
    
35.      * structures allocated in the __get_vm_area_node() function contain
    
36.      * references to the virtual address of the vmalloc'ed block.
    
37.      */  
    
38.      /*调试用*/  
    
39.     kmemleak_alloc(addr, real_size, 3, gfp_mask);  
    
40.   
    
41.     return addr;  
    
42. }  
    
43. *        __vmalloc_node  -  allocate virtually contiguous memory
    
44. *        @size:                allocation size
    
45. *        @align:                desired alignment
    
46. *        @gfp_mask:        flags for the page level allocator
    
47. *        @prot:                protection mask for the allocated pages
    
48. *        @node:                node to use for allocation or -1
    
49. *        @caller:        caller's return address
    
50. *
    
51. *        Allocate enough pages to cover @size from the page level
    
52. *        allocator with @gfp_mask flags.  Map them into contiguous
    
53. *        kernel virtual space, using a pagetable protection of @prot.
    
54. */
    
55. static void *__vmalloc_node(unsigned long size, unsigned long align,
    
56.                             gfp_t gfp_mask, pgprot_t prot,
    
57.                             int node, void *caller)
    
58. {
    
59.         struct vm_struct *area;
    
60.         void *addr;
    
61.         unsigned long real_size = size;
    
62. 
    
63.         size = PAGE_ALIGN(size);
    
64.         if (!size || (size >> PAGE_SHIFT) > totalram_pages)
    
65.                 return NULL;
    
66.         /*分配相关的结构并对其初始化，在前面介绍过了*/
    
67.         area = __get_vm_area_node(size, align, VM_ALLOC, VMALLOC_START,
    
68.                                   VMALLOC_END, node, gfp_mask, caller);
    
69. 
    
70.         if (!area)
    
71.                 return NULL;
    
72.         /*分配物理空间，建立页表映射*/
    
73.         addr = __vmalloc_area_node(area, gfp_mask, prot, node, caller);
    
74. 
    
75.         /*
    
76.          * A ref_count = 3 is needed because the vm_struct and vmap_area
    
77.          * structures allocated in the __get_vm_area_node() function contain
    
78.          * references to the virtual address of the vmalloc'ed block.
    
79.          */
    
80.          /*调试用*/
    
81.         kmemleak_alloc(addr, real_size, 3, gfp_mask);
    
82. 
    
83.         return addr;
    
84. }view plaincopy to clipboardprint?    struct page **pages;  
    
85.     unsigned int nr_pages, array_size, i;  
    
86.     /*需要减去一个页面，因为在分配结构的时候指定了多一个页面*/  
    
87.     nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;  
    
88.     /*页面指针所占空间大小*/  
    
89.     array_size = (nr_pages * sizeof(struct page *));  
    
90.   
    
91.     area->nr_pages = nr_pages;  
    
92.     /* Please note that the recursion is strictly bounded. */  
    
93.     if (array_size > PAGE_SIZE) {/*如果页面指针空间大于一个页面时，这个空间用非连续内存分配*/   
    
94.         pages = __vmalloc_node(array_size, 1, gfp_mask | __GFP_ZERO,  
    
95.                 PAGE_KERNEL, node, caller);  
    
96.         area->flags |= VM_VPAGES;  
    
97.     } else {/*如果页面指针空间所占大小小于一个页面时，用slab机制分配这个空间*/  
    
98.         pages = kmalloc_node(array_size,  
    
99.                 (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO,  
    
100.                 node);  
     
101.     }  
     
102.     /*初始化area结构*/  
     
103.     area->pages = pages;  
     
104.     area->caller = caller;  
     
105.     if (!area->pages) {  
     
106.         remove_vm_area(area->addr);  
     
107.         kfree(area);  
     
108.         return NULL;  
     
109.     }  
     
110.     /*对每个页面调用分配函数分配物理空间，
     
111.     也就是每次分配一个页面*/  
     
112.     for (i = 0; i < area->nr_pages; i++) {  
     
113.         struct page *page;  
     
114.   
     
115.         if (node < 0)/*分配物理页面空间*/  
     
116.             page = alloc_page(gfp_mask);  
     
117.         else  
     
118.             page = alloc_pages_node(node, gfp_mask, 0);  
     
119.   
     
120.         if (unlikely(!page)) {  
     
121.             /* Successfully allocated i pages, free them in __vunmap() */  
     
122.             area->nr_pages = i;  
     
123.             goto fail;  
     
124.         }  
     
125.         area->pages[i] = page;/*初始化area中page数组*/  
     
126.     }  
     
127.     /*因为非连续区间没有建立页表机制，在这里需要建立他*/  
     
128.     if (map_vm_area(area, prot, &pages))  
     
129.         goto fail;  
     
130.     return area->addr;/*返回线性地址*/  
     
131.   
     
132. fail:  
     
133.     vfree(area->addr);  
     
134.     return NULL;  
     
135. }  
     
136.         struct page **pages;
     
137.         unsigned int nr_pages, array_size, i;
     
138.         /*需要减去一个页面，因为在分配结构的时候指定了多一个页面*/
     
139.         nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
     
140.         /*页面指针所占空间大小*/
     
141.         array_size = (nr_pages * sizeof(struct page *));
     
142. 
     
143.         area->nr_pages = nr_pages;
     
144.         /* Please note that the recursion is strictly bounded. */
     
145.         if (array_size > PAGE_SIZE) {/*如果页面指针空间大于一个页面时，这个空间用非连续内存分配*/
     
146.                 pages = __vmalloc_node(array_size, 1, gfp_mask | __GFP_ZERO,
     
147.                                 PAGE_KERNEL, node, caller);
     
148.                 area->flags |= VM_VPAGES;
     
149.         } else {/*如果页面指针空间所占大小小于一个页面时，用slab机制分配这个空间*/
     
150.                 pages = kmalloc_node(array_size,
     
151.                                 (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO,
     
152.                                 node);
     
153.         }
     
154.         /*初始化area结构*/
     
155.         area->pages = pages;
     
156.         area->caller = caller;
     
157.         if (!area->pages) {
     
158.                 remove_vm_area(area->addr);
     
159.                 kfree(area);
     
160.                 return NULL;
     
161.         }
     
162.         /*对每个页面调用分配函数分配物理空间，
     
163.         也就是每次分配一个页面*/
     
164.         for (i = 0; i < area->nr_pages; i++) {
     
165.                 struct page *page;
     
166. 
     
167.                 if (node < 0)/*分配物理页面空间*/
     
168.                         page = alloc_page(gfp_mask);
     
169.                 else
     
170.                         page = alloc_pages_node(node, gfp_mask, 0);
     
171. 
     
172.                 if (unlikely(!page)) {
     
173.                         /* Successfully allocated i pages, free them in __vunmap() */
     
174.                         area->nr_pages = i;
     
175.                         goto fail;
     
176.                 }
     
177.                 area->pages[i] = page;/*初始化area中page数组*/
     
178.         }
     
179.         /*因为非连续区间没有建立页表机制，在这里需要建立他*/
     
180.         if (map_vm_area(area, prot, &pages))
     
181.                 goto fail;
     
182.         return area->addr;/*返回线性地址*/
     
183. 
     
184. fail:
     
185.         vfree(area->addr);
     
186.         return NULL;
     
187. }

复制代码

其中map_vm_area()建立页表映射机制的实现就是依次对pgd、pud、pmd、pte的设置。

二、非连续内存区的释放

调用vfree()函数实现

1. view plaincopy to clipboardprint?/**
   
2. *  vfree  -  release memory allocated by vmalloc()
   
3. *  @addr:      memory base address
   
4. *
   
5. *  Free the virtually continuous memory area starting at @addr, as
   
6. *  obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
   
7. *  NULL, no operation is performed.
   
8. *
   
9. *  Must not be called in interrupt context.
   
10. */  
    
11. void vfree(const void *addr)  
    
12. {  
    
13.     BUG_ON(in_interrupt());  
    
14.     /*调试用*/  
    
15.     kmemleak_free(addr);  
    
16.     /*释放工作*/  
    
17.     __vunmap(addr, 1);  
    
18. }  
    
19. /**
    
20. *        vfree  -  release memory allocated by vmalloc()
    
21. *        @addr:                memory base address
    
22. *
    
23. *        Free the virtually continuous memory area starting at @addr, as
    
24. *        obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
    
25. *        NULL, no operation is performed.
    
26. *
    
27. *        Must not be called in interrupt context.
    
28. */
    
29. void vfree(const void *addr)
    
30. {
    
31.         BUG_ON(in_interrupt());
    
32.         /*调试用*/
    
33.         kmemleak_free(addr);
    
34.         /*释放工作*/
    
35.         __vunmap(addr, 1);
    
36. }view plaincopy to clipboardprint?static void __vunmap(const void *addr, int deallocate_pages)  
    
37. {  
    
38.     struct vm_struct *area;  
    
39.   
    
40.     if (!addr)  
    
41.         return;  
    
42.   
    
43.     if ((PAGE_SIZE-1) & (unsigned long)addr) {  
    
44.         WARN(1, KERN_ERR "Trying to vfree() bad address (%p)\n", addr);  
    
45.         return;  
    
46.     }  
    
47.     /*从vlist链表和红黑树中移除指定地址的线性区间*/  
    
48.     area = remove_vm_area(addr);  
    
49.     if (unlikely(!area)) {  
    
50.         WARN(1, KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",  
    
51.                 addr);  
    
52.         return;  
    
53.     }  
    
54.   
    
55.     debug_check_no_locks_freed(addr, area->size);  
    
56.     debug_check_no_obj_freed(addr, area->size);  
    
57.   
    
58.     if (deallocate_pages) {  
    
59.         int i;  
    
60.   
    
61.         for (i = 0; i < area->nr_pages; i++) {/*每次释放一个页面*/  
    
62.             struct page *page = area->pages[i];  
    
63.   
    
64.             BUG_ON(!page);  
    
65.             __free_page(page);  
    
66.         }  
    
67.   
    
68.         if (area->flags & VM_VPAGES)/*在创建非连续区间时，如果页面
    
69.             指针所占的空间大于一个页面时，从非连续内存区间
    
70.             中分配。所以这里也就从相应的释放*/  
    
71.             vfree(area->pages);  
    
72.         else  
    
73.             kfree(area->pages);/*从slab中释放*/  
    
74.     }  
    
75.   
    
76.     kfree(area);/*释放area*/  
    
77.     return;  
    
78. }  
    
79. static void __vunmap(const void *addr, int deallocate_pages)
    
80. {
    
81.         struct vm_struct *area;
    
82. 
    
83.         if (!addr)
    
84.                 return;
    
85. 
    
86.         if ((PAGE_SIZE-1) & (unsigned long)addr) {
    
87.                 WARN(1, KERN_ERR "Trying to vfree() bad address (%p)\n", addr);
    
88.                 return;
    
89.         }
    
90.         /*从vlist链表和红黑树中移除指定地址的线性区间*/
    
91.         area = remove_vm_area(addr);
    
92.         if (unlikely(!area)) {
    
93.                 WARN(1, KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
    
94.                                 addr);
    
95.                 return;
    
96.         }
    
97. 
    
98.         debug_check_no_locks_freed(addr, area->size);
    
99.         debug_check_no_obj_freed(addr, area->size);
    
100. 
     
101.         if (deallocate_pages) {
     
102.                 int i;
     
103. 
     
104.                 for (i = 0; i < area->nr_pages; i++) {/*每次释放一个页面*/
     
105.                         struct page *page = area->pages[i];
     
106. 
     
107.                         BUG_ON(!page);
     
108.                         __free_page(page);
     
109.                 }
     
110. 
     
111.                 if (area->flags & VM_VPAGES)/*在创建非连续区间时，如果页面
     
112.                         指针所占的空间大于一个页面时，从非连续内存区间
     
113.                         中分配。所以这里也就从相应的释放*/
     
114.                         vfree(area->pages);
     
115.                 else
     
116.                         kfree(area->pages);/*从slab中释放*/
     
117.         }
     
118. 
     
119.         kfree(area);/*释放area*/
     
120.         return;
     
121. }view plaincopy to clipboardprint?/**
     
122. *  remove_vm_area  -  find and remove a continuous kernel virtual area
     
123. *  @addr:      base address
     
124. *
     
125. *  Search for the kernel VM area starting at @addr, and remove it.
     
126. *  This function returns the found VM area, but using it is NOT safe
     
127. *  on SMP machines, except for its size or flags.
     
128. */  
     
129. struct vm_struct *remove_vm_area(const void *addr)  
     
130. {  
     
131.     struct vmap_area *va;  
     
132.     /*从红黑树种查找而不是链表，为了效率起见*/  
     
133.     va = find_vmap_area((unsigned long)addr);  
     
134.     if (va && va->flags & VM_VM_AREA) {  
     
135.         struct vm_struct *vm = va->private;  
     
136.         struct vm_struct *tmp, **p;  
     
137.         /*
     
138.          * remove from list and disallow access to this vm_struct
     
139.          * before unmap. (address range confliction is maintained by
     
140.          * vmap.)
     
141.          */  
     
142.         write_lock(&vmlist_lock);  
     
143.         /*从链表中找到，然后删除*/  
     
144.         for (p = &vmlist; (tmp = *p) != vm; p = &tmp->next)  
     
145.             ;  
     
146.         *p = tmp->next;  
     
147.         write_unlock(&vmlist_lock);  
     
148.         /*调试用*/  
     
149.         vmap_debug_free_range(va->va_start, va->va_end);  
     
150.         /*从红黑树中删除*/  
     
151.         free_unmap_vmap_area(va);  
     
152.         vm->size -= PAGE_SIZE;  
     
153.   
     
154.         return vm;  
     
155.     }  
     
156.     return NULL;  
     
157. }  
     
158. /**
     
159. *        remove_vm_area  -  find and remove a continuous kernel virtual area
     
160. *        @addr:                base address
     
161. *
     
162. *        Search for the kernel VM area starting at @addr, and remove it.
     
163. *        This function returns the found VM area, but using it is NOT safe
     
164. *        on SMP machines, except for its size or flags.
     
165. */
     
166. struct vm_struct *remove_vm_area(const void *addr)
     
167. {
     
168.         struct vmap_area *va;
     
169.         /*从红黑树种查找而不是链表，为了效率起见*/
     
170.         va = find_vmap_area((unsigned long)addr);
     
171.         if (va && va->flags & VM_VM_AREA) {
     
172.                 struct vm_struct *vm = va->private;
     
173.                 struct vm_struct *tmp, **p;
     
174.                 /*
     
175.                  * remove from list and disallow access to this vm_struct
     
176.                  * before unmap. (address range confliction is maintained by
     
177.                  * vmap.)
     
178.                  */
     
179.                 write_lock(&vmlist_lock);
     
180.                 /*从链表中找到，然后删除*/
     
181.                 for (p = &vmlist; (tmp = *p) != vm; p = &tmp->next)
     
182.                         ;
     
183.                 *p = tmp->next;
     
184.                 write_unlock(&vmlist_lock);
     
185.                 /*调试用*/
     
186.                 vmap_debug_free_range(va->va_start, va->va_end);
     
187.                 /*从红黑树中删除*/
     
188.                 free_unmap_vmap_area(va);
     
189.                 vm->size -= PAGE_SIZE;
     
190. 
     
191.                 return vm;
     
192.         }
     
193.         return NULL;
     
194. }

复制代码

总结：linux高端内存非连续区的整体描述以及其分配和释放基本就总结完了。总结的只是一个大概的原理框架，不过根据这个框架对细节的了解应该不难。另外，其中涉及到伙伴系统、slab机制等部分需要再做分析和总结

梦境照进现实

谢谢分享