linux高端内存管理之非连续内存区（描述）

三里屯摇滚

linux高端内存管理之非连续内存区（描述）

总结了高端内存区的固定内核映射区、临时内核映射与永久内核映射。但是对于高端内存中各个区间的布置我们任然不是很清楚，首先我们从整体上看看内核对高端内存的划分情况。

如果内存足够大（比如用户：内核线性空间=3:1，内核就只能访问线性空间的第4GB内容，如果物理内存超过1GB则视为足够大），内核线性空间无法同时映射所有内存。这就需要将内核线性空间分出一段不直接映射物理内存，而是作为窗口分时映射使用到的未映射的内存。

一、非连续内存区布局

Linux内核中对于非连续区间的开始：


view plaincopy to clipboardprint?#define VMALLOC_START   ((unsigned long)high_memory + VMALLOC_OFFSET)  
#define VMALLOC_START        ((unsigned long)high_memory + VMALLOC_OFFSET)view plaincopy to clipboardprint?#define VMALLOC_OFFSET  (8 * 1024 * 1024)  
#define VMALLOC_OFFSET        (8 * 1024 * 1024)对于变量high_memory变量：

1. view plaincopy to clipboardprint?void __init initmem_init(unsigned long start_pfn,  
   
2.                   unsigned long end_pfn)  
   
3. {  
   
4.     highstart_pfn = highend_pfn = max_pfn;  
   
5.     if (max_pfn > max_low_pfn)  
   
6.         highstart_pfn = max_low_pfn;  
   
7. ……  
   
8.     num_physpages = highend_pfn;  
   
9.     /*高端内存开始地址物理*/  
   
10.     high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;  
    
11. ……  
    
12. }   
    
13. void __init initmem_init(unsigned long start_pfn,
    
14.                                   unsigned long end_pfn)
    
15. {
    
16.         highstart_pfn = highend_pfn = max_pfn;
    
17.         if (max_pfn > max_low_pfn)
    
18.                 highstart_pfn = max_low_pfn;
    
19. ……
    
20.         num_physpages = highend_pfn;
    
21.         /*高端内存开始地址物理*/
    
22.         high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
    
23. ……
    
24. }  

复制代码

其中，变量max_low_pfn在highmem_pfn_init()函数中初始化为下面值

1. view plaincopy to clipboardprint?#define MAXMEM  (VMALLOC_END - PAGE_OFFSET - __VMALLOC_RESERVE)  
   
2. #define MAXMEM        (VMALLOC_END - PAGE_OFFSET - __VMALLOC_RESERVE)view plaincopy to clipboardprint?<p>unsigned int __VMALLOC_RESERVE = 128 << 20;</p>  
   
3. <p>unsigned int __VMALLOC_RESERVE = 128 << 20;</p>对于非连续区间的结束定义：
   
4. 
   
5. view plaincopy to clipboardprint?# define VMALLOC_END    (PKMAP_BASE - 2 * PAGE_SIZE)  
   
6. # define VMALLOC_END        (PKMAP_BASE - 2 * PAGE_SIZE)

复制代码

由上面的内核代码，画出内存布局细节图如下



由上面的布局可知128M+4M+4M+8K，然而直接映射区和连续内存之间空出来了8M的空间不能用，非连续空间和永久内核映射区之间也有8K的空间不可用，另外，内存顶端空出了4K不可用的。这样，高端内存能用的空间为128M+4M+4M+8K-4K-8M-8K=128M-4K大小的内存。

二、数据结构描述

虚拟内存区描述（对于vmlist链表）

1. view plaincopy to clipboardprint?struct vm_struct {  
   
2.     struct vm_struct    *next;  
   
3.     void            *addr;/*内存区的第一个内存单元的线性地址*/  
   
4.     unsigned long       size;  
   
5.     unsigned long       flags;/*类型*/  
   
6.     struct page     **pages;/*指向nr_pages数组的指针，该数组由指向页描述符的指针组成*/  
   
7.     unsigned int        nr_pages;/*内存区填充的页的个数*/  
   
8.     unsigned long       phys_addr;/*该字段设为0，除非内存已被创建来映射一个硬件设备的IO共享内存*/  
   
9.     void            *caller;  
   
10. };  
    
11. struct vm_struct {
    
12.         struct vm_struct        *next;
    
13.         void                        *addr;/*内存区的第一个内存单元的线性地址*/
    
14.         unsigned long                size;
    
15.         unsigned long                flags;/*类型*/
    
16.         struct page                **pages;/*指向nr_pages数组的指针，该数组由指向页描述符的指针组成*/
    
17.         unsigned int                nr_pages;/*内存区填充的页的个数*/
    
18.         unsigned long                phys_addr;/*该字段设为0，除非内存已被创建来映射一个硬件设备的IO共享内存*/
    
19.         void                        *caller;
    
20. };

复制代码

虚拟内存区描述（对于红黑树）

1. view plaincopy to clipboardprint?struct vmap_area {  
   
2.     unsigned long va_start;  
   
3.     unsigned long va_end;  
   
4.     unsigned long flags;  
   
5.     struct rb_node rb_node;     /* address sorted rbtree */  
   
6.     struct list_head list;      /* address sorted list */  
   
7.     struct list_head purge_list;    /* "lazy purge" list */  
   
8.     void *private;  
   
9.     struct rcu_head rcu_head;  
   
10. };  
    
11. struct vmap_area {
    
12.         unsigned long va_start;
    
13.         unsigned long va_end;
    
14.         unsigned long flags;
    
15.         struct rb_node rb_node;                /* address sorted rbtree */
    
16.         struct list_head list;                /* address sorted list */
    
17.         struct list_head purge_list;        /* "lazy purge" list */
    
18.         void *private;
    
19.         struct rcu_head rcu_head;
    
20. };

复制代码

内存区由next字段链接到一起，并且为了查找简单，他们以地址为次序。为了防止溢出，每个区域至少由一个页面隔离开。



三、创建非连续内存的线性区

vm_struct结构链接在一个链表中，链表的第一个元素的地址存放在vmlist变量中。当内核需要分配一块新的内存时，函数get_vm_area()分配结构体所需要的空间，然后将其插入到链表中。另外，该版本的内核中增加了红黑树的管理。函数get_vm_area()不仅要将其插入到vmlist链表中，还有将结构体vmap_area插入到vmap_area_root指定根的红黑树中。

get_vm_area()函数会调用__get_vm_area_node()函数

1. view plaincopy to clipboardprint?static struct vm_struct *__get_vm_area_node(unsigned long size,  
   
2.         unsigned long align, unsigned long flags, unsigned long start,  
   
3.         unsigned long end, int node, gfp_t gfp_mask, void *caller)  
   
4. {  
   
5.     static struct vmap_area *va;  
   
6.     struct vm_struct *area;  
   
7.   
   
8.     BUG_ON(in_interrupt());  
   
9.     if (flags & VM_IOREMAP) {  
   
10.         int bit = fls(size);  
    
11.   
    
12.         if (bit > IOREMAP_MAX_ORDER)  
    
13.             bit = IOREMAP_MAX_ORDER;  
    
14.         else if (bit < PAGE_SHIFT)  
    
15.             bit = PAGE_SHIFT;  
    
16.   
    
17.         align = 1ul << bit;  
    
18.     }  
    
19.   
    
20.     size = PAGE_ALIGN(size);  
    
21.     if (unlikely(!size))  
    
22.         return NULL;  
    
23.     /*分配vm_struct结构体内存空间*/  
    
24.     area = kzalloc_node(sizeof(*area), gfp_mask & GFP_RECLAIM_MASK, node);  
    
25.     if (unlikely(!area))  
    
26.         return NULL;  
    
27.   
    
28.     /*
    
29.      * We always allocate a guard page.
    
30.      */  
    
31.     size += PAGE_SIZE;/*为安全考虑，多一个页面*/  
    
32.     /*分配vmap_area结构体，并且将其插入到红黑树中*/  
    
33.     va = alloc_vmap_area(size, align, start, end, node, gfp_mask);  
    
34.     if (IS_ERR(va)) {  
    
35.         kfree(area);  
    
36.         return NULL;  
    
37.     }  
    
38.     /*插入vmlist链表*/  
    
39.     insert_vmalloc_vm(area, va, flags, caller);  
    
40.     return area;  
    
41. }  
    
42. static struct vm_struct *__get_vm_area_node(unsigned long size,
    
43.                 unsigned long align, unsigned long flags, unsigned long start,
    
44.                 unsigned long end, int node, gfp_t gfp_mask, void *caller)
    
45. {
    
46.         static struct vmap_area *va;
    
47.         struct vm_struct *area;
    
48. 
    
49.         BUG_ON(in_interrupt());
    
50.         if (flags & VM_IOREMAP) {
    
51.                 int bit = fls(size);
    
52. 
    
53.                 if (bit > IOREMAP_MAX_ORDER)
    
54.                         bit = IOREMAP_MAX_ORDER;
    
55.                 else if (bit < PAGE_SHIFT)
    
56.                         bit = PAGE_SHIFT;
    
57. 
    
58.                 align = 1ul << bit;
    
59.         }
    
60. 
    
61.         size = PAGE_ALIGN(size);
    
62.         if (unlikely(!size))
    
63.                 return NULL;
    
64.         /*分配vm_struct结构体内存空间*/
    
65.         area = kzalloc_node(sizeof(*area), gfp_mask & GFP_RECLAIM_MASK, node);
    
66.         if (unlikely(!area))
    
67.                 return NULL;
    
68. 
    
69.         /*
    
70.          * We always allocate a guard page.
    
71.          */
    
72.         size += PAGE_SIZE;/*为安全考虑，多一个页面*/
    
73.         /*分配vmap_area结构体，并且将其插入到红黑树中*/
    
74.         va = alloc_vmap_area(size, align, start, end, node, gfp_mask);
    
75.         if (IS_ERR(va)) {
    
76.                 kfree(area);
    
77.                 return NULL;
    
78.         }
    
79.         /*插入vmlist链表*/
    
80.         insert_vmalloc_vm(area, va, flags, caller);
    
81.         return area;
    
82. }view plaincopy to clipboardprint?/*
    
83. * Allocate a region of KVA of the specified size and alignment, within the
    
84. * vstart and vend.
    
85. */  
    
86. static struct vmap_area *alloc_vmap_area(unsigned long size,  
    
87.                 unsigned long align,  
    
88.                 unsigned long vstart, unsigned long vend,  
    
89.                 int node, gfp_t gfp_mask)  
    
90. {  
    
91.     struct vmap_area *va;  
    
92.     struct rb_node *n;  
    
93.     unsigned long addr;  
    
94.     int purged = 0;  
    
95.   
    
96.     BUG_ON(!size);  
    
97.     BUG_ON(size & ~PAGE_MASK);  
    
98.     /*分配vmap_area结构*/  
    
99.     va = kmalloc_node(sizeof(struct vmap_area),  
    
100.             gfp_mask & GFP_RECLAIM_MASK, node);  
     
101.     if (unlikely(!va))  
     
102.         return ERR_PTR(-ENOMEM);  
     
103.   
     
104. retry:  
     
105.     addr = ALIGN(vstart, align);  
     
106.   
     
107.     spin_lock(&vmap_area_lock);  
     
108.     if (addr + size - 1 < addr)  
     
109.         goto overflow;  
     
110.   
     
111.     /* XXX: could have a last_hole cache */  
     
112.     n = vmap_area_root.rb_node;  
     
113.     if (n) {  
     
114.         struct vmap_area *first = NULL;  
     
115.   
     
116.         do {  
     
117.             struct vmap_area *tmp;  
     
118.             tmp = rb_entry(n, struct vmap_area, rb_node);  
     
119.             if (tmp->va_end >= addr) {  
     
120.                 if (!first && tmp->va_start < addr + size)  
     
121.                     first = tmp;  
     
122.                 n = n->rb_left;  
     
123.             } else {  
     
124.                 first = tmp;  
     
125.                 n = n->rb_right;  
     
126.             }  
     
127.         } while (n);  
     
128.   
     
129.         if (!first)/*为最左的孩子，也就是比现有的都小*/  
     
130.             goto found;  
     
131.   
     
132.         if (first->va_end < addr) {  
     
133.             n = rb_next(&first->rb_node);  
     
134.             if (n)  
     
135.                 first = rb_entry(n, struct vmap_area, rb_node);  
     
136.             else/*next为空*/  
     
137.                 goto found;/*为找到的节点的下一个，也就是比找到的大*/  
     
138.         }  
     
139.         /*当上面没有满足要求时，重新配置addr，也就是起始
     
140.         地址*/  
     
141.         while (addr + size > first->va_start && addr + size <= vend) {  
     
142.             addr = ALIGN(first->va_end + PAGE_SIZE, align);/*重新配置起始地址*/  
     
143.             if (addr + size - 1 < addr)  
     
144.                 goto overflow;  
     
145.   
     
146.             n = rb_next(&first->rb_node);  
     
147.             if (n)  
     
148.                 first = rb_entry(n, struct vmap_area, rb_node);  
     
149.             else  
     
150.                 goto found;/*此时应该插入到找到的节点的右边*/  
     
151.         }  
     
152.     }  
     
153. found:  
     
154.     if (addr + size > vend) {  
     
155. overflow:  
     
156.         spin_unlock(&vmap_area_lock);  
     
157.         if (!purged) {  
     
158.             purge_vmap_area_lazy();  
     
159.             purged = 1;  
     
160.             goto retry;  
     
161.         }  
     
162.         if (printk_ratelimit())  
     
163.             printk(KERN_WARNING  
     
164.                 "vmap allocation for size %lu failed: "  
     
165.                 "use vmalloc=<size> to increase size.\n", size);  
     
166.         kfree(va);  
     
167.         return ERR_PTR(-EBUSY);  
     
168.     }  
     
169.   
     
170.     BUG_ON(addr & (align-1));  
     
171.     /*初始化va*/  
     
172.     va->va_start = addr;  
     
173.     va->va_end = addr + size;  
     
174.     va->flags = 0;  
     
175.     /*插入到红黑树*/  
     
176.     __insert_vmap_area(va);  
     
177.     spin_unlock(&vmap_area_lock);  
     
178.   
     
179.     return va;  
     
180. }  
     
181. /*
     
182. * Allocate a region of KVA of the specified size and alignment, within the
     
183. * vstart and vend.
     
184. */
     
185. static struct vmap_area *alloc_vmap_area(unsigned long size,
     
186.                                 unsigned long align,
     
187.                                 unsigned long vstart, unsigned long vend,
     
188.                                 int node, gfp_t gfp_mask)
     
189. {
     
190.         struct vmap_area *va;
     
191.         struct rb_node *n;
     
192.         unsigned long addr;
     
193.         int purged = 0;
     
194. 
     
195.         BUG_ON(!size);
     
196.         BUG_ON(size & ~PAGE_MASK);
     
197.         /*分配vmap_area结构*/
     
198.         va = kmalloc_node(sizeof(struct vmap_area),
     
199.                         gfp_mask & GFP_RECLAIM_MASK, node);
     
200.         if (unlikely(!va))
     
201.                 return ERR_PTR(-ENOMEM);
     
202. 
     
203. retry:
     
204.         addr = ALIGN(vstart, align);
     
205. 
     
206.         spin_lock(&vmap_area_lock);
     
207.         if (addr + size - 1 < addr)
     
208.                 goto overflow;
     
209. 
     
210.         /* XXX: could have a last_hole cache */
     
211.         n = vmap_area_root.rb_node;
     
212.         if (n) {
     
213.                 struct vmap_area *first = NULL;
     
214. 
     
215.                 do {
     
216.                         struct vmap_area *tmp;
     
217.                         tmp = rb_entry(n, struct vmap_area, rb_node);
     
218.                         if (tmp->va_end >= addr) {
     
219.                                 if (!first && tmp->va_start < addr + size)
     
220.                                         first = tmp;
     
221.                                 n = n->rb_left;
     
222.                         } else {
     
223.                                 first = tmp;
     
224.                                 n = n->rb_right;
     
225.                         }
     
226.                 } while (n);
     
227. 
     
228.                 if (!first)/*为最左的孩子，也就是比现有的都小*/
     
229.                         goto found;
     
230. 
     
231.                 if (first->va_end < addr) {
     
232.                         n = rb_next(&first->rb_node);
     
233.                         if (n)
     
234.                                 first = rb_entry(n, struct vmap_area, rb_node);
     
235.                         else/*next为空*/
     
236.                                 goto found;/*为找到的节点的下一个，也就是比找到的大*/
     
237.                 }
     
238.                 /*当上面没有满足要求时，重新配置addr，也就是起始
     
239.                 地址*/
     
240.                 while (addr + size > first->va_start && addr + size <= vend) {
     
241.                         addr = ALIGN(first->va_end + PAGE_SIZE, align);/*重新配置起始地址*/
     
242.                         if (addr + size - 1 < addr)
     
243.                                 goto overflow;
     
244. 
     
245.                         n = rb_next(&first->rb_node);
     
246.                         if (n)
     
247.                                 first = rb_entry(n, struct vmap_area, rb_node);
     
248.                         else
     
249.                                 goto found;/*此时应该插入到找到的节点的右边*/
     
250.                 }
     
251.         }
     
252. found:
     
253.         if (addr + size > vend) {
     
254. overflow:
     
255.                 spin_unlock(&vmap_area_lock);
     
256.                 if (!purged) {
     
257.                         purge_vmap_area_lazy();
     
258.                         purged = 1;
     
259.                         goto retry;
     
260.                 }
     
261.                 if (printk_ratelimit())
     
262.                         printk(KERN_WARNING
     
263.                                 "vmap allocation for size %lu failed: "
     
264.                                 "use vmalloc=<size> to increase size.\n", size);
     
265.                 kfree(va);
     
266.                 return ERR_PTR(-EBUSY);
     
267.         }
     
268. 
     
269.         BUG_ON(addr & (align-1));
     
270.         /*初始化va*/
     
271.         va->va_start = addr;
     
272.         va->va_end = addr + size;
     
273.         va->flags = 0;
     
274.         /*插入到红黑树*/
     
275.         __insert_vmap_area(va);
     
276.         spin_unlock(&vmap_area_lock);
     
277. 
     
278.         return va;
     
279. }view plaincopy to clipboardprint?static void insert_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,  
     
280.                   unsigned long flags, void *caller)  
     
281. {  
     
282.     struct vm_struct *tmp, **p;  
     
283.     /*初始化vm*/  
     
284.     vm->flags = flags;  
     
285.     vm->addr = (void *)va->va_start;  
     
286.     vm->size = va->va_end - va->va_start;  
     
287.     vm->caller = caller;  
     
288.     va->private = vm;  
     
289.     va->flags |= VM_VM_AREA;  
     
290.   
     
291.     write_lock(&vmlist_lock);  
     
292.     /*寻找插入位置*/  
     
293.     for (p = &vmlist; (tmp = *p) != NULL; p = &tmp->next) {  
     
294.         if (tmp->addr >= vm->addr)  
     
295.             break;  
     
296.     }  
     
297.     /*插入工作*/  
     
298.     vm->next = *p;  
     
299.     *p = vm;  
     
300.     write_unlock(&vmlist_lock);  
     
301. }  
     
302. static void insert_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,
     
303.                               unsigned long flags, void *caller)
     
304. {
     
305.         struct vm_struct *tmp, **p;
     
306.         /*初始化vm*/
     
307.         vm->flags = flags;
     
308.         vm->addr = (void *)va->va_start;
     
309.         vm->size = va->va_end - va->va_start;
     
310.         vm->caller = caller;
     
311.         va->private = vm;
     
312.         va->flags |= VM_VM_AREA;
     
313. 
     
314.         write_lock(&vmlist_lock);
     
315.         /*寻找插入位置*/
     
316.         for (p = &vmlist; (tmp = *p) != NULL; p = &tmp->next) {
     
317.                 if (tmp->addr >= vm->addr)
     
318.                         break;
     
319.         }
     
320.         /*插入工作*/
     
321.         vm->next = *p;
     
322.         *p = vm;
     
323.         write_unlock(&vmlist_lock);
     
324. }

复制代码

初步总结了高端内存非连续区的管理框架，后面将总结他的分配和释放工作。

梦境照进现实

谢谢分享