Chinaunix

标题: linux高端内存管理之非连续内存区（描述） [打印本页]
作者: 三里屯摇滚    时间: 2012-01-06 16:27
标题: 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>对于非连续区间的结束定义：

  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;

  49.         BUG_ON(in_interrupt());
  50.         if (flags & VM_IOREMAP) {
  51.                 int bit = fls(size);

  53.                 if (bit > IOREMAP_MAX_ORDER)
  54.                         bit = IOREMAP_MAX_ORDER;
  55.                 else if (bit < PAGE_SHIFT)
  56.                         bit = PAGE_SHIFT;

  58.                 align = 1ul << bit;
  59.         }

  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;

  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;

  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);

  203. retry:
  204.         addr = ALIGN(vstart, align);

  206.         spin_lock(&vmap_area_lock);
  207.         if (addr + size - 1 < addr)
  208.                 goto overflow;

  210.         /* XXX: could have a last_hole cache */
  211.         n = vmap_area_root.rb_node;
  212.         if (n) {
  213.                 struct vmap_area *first = NULL;

  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);

  228.                 if (!first)/*为最左的孩子，也就是比现有的都小*/
  229.                         goto found;

  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;

  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.         }

  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);

  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;

  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. }
复制代码
初步总结了高端内存非连续区的管理框架，后面将总结他的分配和释放工作。

作者: 梦境照进现实    时间: 2012-01-06 16:28
谢谢分享



欢迎光临 Chinaunix (http://bbs.chinaunix.net/) Powered by Discuz! X3.2