linux的内存开辟

内存开辟

谨以此文纪念过往的岁月。

内存的分配和管理在linux的内核中是一个巨头。在此仅记录个人理解，如有错误请指正。
1.kmalloc
在内存开辟中kmalloc的使用概率很高，在通常的内存开辟中均会使用该函数来开辟内存。但是分配的区域仍然保持原有的数据，一般需要清零。
函数原型：
void *kmalloc(size_t size ,int flags);
参数size很好理解，即是分配多大的内存，以字节为单位。flags也很明白，即是分配的标志，来控制kmalloc的行为。
flags一般常用的标志有GFP_KERNEL,GFP_ATOMIC,__GFP_DMA。简单说一下，GFP_KERNEL指由内核进程来执行的。使用这个flag时，函数会被阻塞，因为kmalloc允许当空闲页比较少的时候，会睡眠等待空闲页。而GFP_ATOMIC则不然，他会立即调用内核预留的一些空闲页，如果所有的预留都没有了，就会立即返回错误。
该标志一般用于中断处理中。kmalloc一般最下处理32或64字节，最大一般不超过128K。
kmalloc的源码如下
static __always_inline void *kmalloc(size_t size, gfp_t flags)
{
 if (__builtin_constant_p(size)) {   --检测size是否为常量
  if (size > PAGE_SIZE)             --如果开辟的空间大于1页的话，则会采用(void *)__get_free_pages(flags | __GFP_COMP, get_order(size));的办法开辟
   return kmalloc_large(size, flags);
  if (!(flags & SLUB_DMA)) {           --如果flags并没有被指定为__GFP_DMA，即是在DMA区开辟的话，则采用从已经创建了对象的高速缓存中分配
   struct kmem_cache *s = kmalloc_slab(size);   --这个则是查询适合大小的内存对象
   if (!s)
    return ZERO_SIZE_PTR;
   return kmem_cache_alloc(s, flags); --分配对应的内存对象
  }
 }
 return __kmalloc(size, flags);    --如果不是常量的话
}

void *__kmalloc(size_t size, gfp_t flags)  --  这个函数与上面的类似可以说几乎是一样的，不知道这样设计的含义
{
 struct kmem_cache *s;
 if (unlikely(size > PAGE_SIZE))
  return kmalloc_large(size, flags);
 s = get_slab(size, flags);

 if (unlikely(ZERO_OR_NULL_PTR(s)))  -- unlikely这个东西有没有是一样的，只不过说明大多数情况下条件是为否的。这个是用于编译加速的。这个是告诉编译器，这个条件大多数是否
  return s;

 return slab_alloc(s, flags, -1, _RET_IP_);  --kmem_cache_alloc的函数直接会调用这个函数。
}  
至于__get_free_pages和如何从后备高速缓存中开辟对象，这个在理解内存管理的时候再去理解。到此可以说对于小页的ARCH(即PAGE_SIZE=4K),kmalloc的size小于PAGE_SIZE时，会采用从已经创建好了的高速缓存中分配内存对象。如果size不是2^n的话，会多开辟内存，有时最多开辟两倍的内存，比如size=2^n+1时，最后开辟的内存会是2^(n+1),不过这种情况出现在size大于256时。为什么这么说呢？看下面的源码就可以理解了在kmalloc_slab函数中会调用kmalloc_index来查询size所对应的高速缓存对象。至于为什么会出现这种情况，以后在看内存预分配高速缓冲时再说。源码如下：
static __always_inline int kmalloc_index(size_t size)
{

 if (size <= KMALLOC_MIN_SIZE)
  return KMALLOC_SHIFT_LOW;

#if KMALLOC_MIN_SIZE <= 64     KMALLOC_MIN_SIZE在arm平台下为 8
 if (size > 64 && size <= 96)
  return 1;
 if (size > 128 && size <= 192)
  return 2;
#endif
 if (size <=          8) return 3;  
 if (size <=         16) return 4;
 if (size <=         32) return 5;
 if (size <=         64) return 6;
 if (size <=        128) return 7;     
 if (size <=        256) return 8;
 if (size <=        512) return 9;
 if (size <=       1024) return 10;
 if (size <=   2 * 1024) return 11;
 if (size <=   4 * 1024) return 12;
 --下面是为了支持大页的
 if (size <=   8 * 1024) return 13;
 if (size <=  16 * 1024) return 14;
 if (size <=  32 * 1024) return 15;
 if (size <=  64 * 1024) return 16;
 if (size <= 128 * 1024) return 17;
 if (size <= 256 * 1024) return 18;
 if (size <= 512 * 1024) return 19;
 if (size <= 1024 * 1024) return 20;
 if (size <=  2 * 1024 * 1024) return 21;
 return -1;
}
这这里主要是理解kmalloc时，size的大小与真实内核分配内存间的关系，以及对于不同的开辟不同的内存大小则采用不同的办法去开辟。对于大于PAGE_SIZE的size采用__get_free_pages开辟，而小于PAGE_SIZE的则采用从已经预创建好的高速缓存对象中开辟。

2.vmalloc
vmalloc分配的内存在虚拟空间是连续的，而在物理空间可能是不连续的。适用于开辟大块连续的，仅仅在软件中存在，用于缓冲的内存。vmalloc需要查询内核虚拟空间、的空闲节点，在空闲区域内创建页表。其所消耗的资源远比kmalloc多。所以不适合适用vmalloc去开辟小的内存，这种情况下，效率会很低。至于vmalloc如何去开辟内存空间以及创建新的页表，还是来看源码的实现。在这里不怎么考虑标志符的影响，先考虑一般情况下的vmalloc的实现 vmalloc函数实现在vmalloc.c中vmalloc->__vmalloc_node,__vmalloc_node除去检测的代码，其主要功能就是调用下面的两个函数。
static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,int node, void *caller)
{
 struct vm_struct *area;
 area = __get_vm_area_node(size, VM_ALLOC, VMALLOC_START, VMALLOC_END,node, gfp_mask, caller);
 
--- #define VMALLOC_OFFSET  (8*1024*1024)
---  #define VMALLOC_START  (((unsigned long)high_memory + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))   查询的虚拟地址主要是从高地址开始查询，不过
     arm平台high_memory为0。
---  VMALLOC_END  0xE0000000
 return __vmalloc_area_node(area, gfp_mask, prot, node, caller);
}

__get_vm_area_node主要是查询内核虚拟空间中的空闲节点，从start到end之间查找一个空闲的vm块
static struct vm_struct *__get_vm_area_node(unsigned long size,unsigned long flags, unsigned long start, unsigned long end,int node, gfp_t gfp_mask, void *caller)
{
 static struct vmap_area *va;
 struct vm_struct *area;
 struct vm_struct *tmp, **p;
 unsigned long align = 1;

 size = PAGE_ALIGN(size);
 area = kmalloc_node(sizeof(*area), gfp_mask & GFP_RECLAIM_MASK, node);   --开辟内存
 --需要多开辟一段信息页
 size += PAGE_SIZE;

 va = alloc_vmap_area(size, align, start, end, node, gfp_mask);  --根据从内核虚拟空间中查询出一段大小大于size的虚拟内存空间。这个是怎么实现的会在理解虚拟内存的时候去理解。这儿就略过。
  --将对虚拟空间块的描述赋值 vm_struct
 area->flags = flags;
 area->addr = (void *)va->va_start;
 area->size = size;
 area->pages = NULL;
 area->nr_pages = 0;
 area->phys_addr = 0;
 area->caller = caller;
 va->private = area;
 va->flags |= VM_VM_AREA;

 write_lock(&vmlist_lock);
 for (p = &vmlist; (tmp = *p) != NULL; p = &tmp->next) {
  if (tmp->addr >= area->addr)
   break;
 }
 area->next = *p;    --将该vm块添加到链表
 *p = area;
 write_unlock(&vmlist_lock);
 return area;
}
__get_vm_area_node从内核空间查询到大小满足size，一般是大于size的，并且地址连续的一个vm块，并且对vm_struct进行赋值。而在__vmalloc_area_node中则是将上面查找的vm_struct的内存进行创建新页。在上面函数中只是查询到一段连续的内存，并没有将内存分页，创建新的页链表
static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,pgprot_t prot, int node, void *caller)
{
 struct page **pages;
 unsigned int nr_pages, array_size, i;

 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) {       --如果所需要存储页的信息超过了4K,则需要对页信息指针进行二级处理。因为在查询内核空间时，仅多开辟一页的内存用于存储页信息，如果页信息超过了一页，则需要重新去内核虚拟内存中开辟一个新页来查询，这其实是一个嵌套，使用二级页目录。
  pages = __vmalloc_node(array_size, gfp_mask | __GFP_ZERO,PAGE_KERNEL, node, caller);
  area->flags |= VM_VPAGES;
 } else {
  pages = kmalloc_node(array_size,(gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO,node);       --否则则直接开辟空间，在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;
  if (node < 0)
   page = alloc_page(gfp_mask);
  else
   page = alloc_pages_node(node, gfp_mask, 0);  --这儿就是在node节点中创建新页。不过这儿的node应该不是0
  area->pages[i] = page;
 }
 return area->addr;
}
到此vmalloc就开辟出新的虚拟并连续的内存。vmalloc其实是在内核虚拟空间中找出满足size的内存节点，然后在该节点中创建新的页表。这也是为什么在开辟小的内存时采用vmalloc是不划算的。而且vmalloc对于物理内存而言并没有什么意义，因为在物理内存中，vmalloc开辟的内存并不连续。其主要是对软件有意义。

3.__get_free_pages
在上面也提到__get_free_pages,该函数会在kmalloc开辟空间大于PAGE_SIZE时调用。
__get_free_pages ->alloc_pages ->alloc_pages_node->__alloc_pages->__alloc_pages_internal 经过七拐八拐的最终会分配新页这个函数，这个函数是zone区分配器的核心。
__alloc_pages_internal这个函数以后再了解内存管理时，再好好理解，现在很难。
4.kmem_cache_create与kmem_cache_alloc
这两个函数是组合起来一起用，kmem_cache_create用于创建一个高速缓冲对象，而kmem_cache_alloc用于分配高速缓冲对象内存。这个一般用于需要频繁开辟和注销同一种结构的对象，这个也是用于加速。
5.dma_alloc_coherent
这个函数分配缓冲区并且重新映射。分配的内存可以用于DMA的传输。
6. alloc_bootmem
有时候某些内核模块需要开辟较大的内存如几M的内存空间，如果在内存管理建立后去开辟容易流于失败，通常会在引导程序时提前开辟，这样会跳过内核的内存管理，对内存管理而言，这样的空间是不可见的。这样会减少留给操作系统的RAM。这段内存也需要自己去管理。这个我喜欢！！
7. ioremap
ioremap这个函数不能是一个真正的内存分配，不过他也是一个内存分配，为什么这么说呢？因为ioremap的内存可以将内存管理系统看不见的硬件内存映射到虚拟内存中，说他是内存分配，因为他是分配纯虚拟空间。说他不是，因为他不分配真实的物理空间，他是一种映射。
例如：现在物理内存128M，但是在传替给内核参数时却是 “mem = 124M”，那对用linux系统而言，真实的内存就是124M那还有的4M就无法使用了。这个时候就可以采用ioremap的办法，将在流离在外的4M给弄来，ioremap(0x7C00000,0x400000);这样就可以将那4M给映射到内存中，不过这个还是需要自己去管理的。

 

以上就是一些内存分配的常用的机制。至于具体的实现办法以后再学习内存管理机制的时候，在去看看。