linux内存管理之非连续物理地址分配(vmalloc

时间:2021-08-01 17:40:55

前面我们已经分析了linux如何利用伙伴系统,slab分配器分配内存,用这些方法得到的内存在物理地址上都是连续的,然而,有些时候,每次请求内存时,系统都分配物理地址连续的内存块是不合适的,可以利用小块内存“连接”成大块可使用的内存.这在操作系统设计中也被称为 “内存拼接”,显然,内存拼接在需要较大内存,而内存访问相比之下不是很频繁的情况下是比较有效的.

  在linux内核中用来管理内存拼接的接口是vmalloc/vfree.用vmalloc分配得到的内存在线性地址是平滑的,但是物理地址上是非连续的.

  一:准备知识:

  Linux用vm_struct结构来表示vmalloc使用的线性地址.vmalloc所使用的线性地址区间为: VMALLOC_START VMALLOC_END.借用<<Understanding.the.Linux.Kernel.3rd>>中的一副插图,如下示:

  从上图中我们可以看到每一个vmalloc_area用4KB隔开,这样做是为了很容易就能捕捉到越界访问,因为中间是一个 “空洞”.

  二:相关的数据结构

  下面来分析一下vmalloc area的数据结构:

  struct vm_struct {

  void          *addr;             //虚拟地址

  unsigned long      size;         //vm的大小

  unsigned long      flags;        //vm的标志

  struct page        **pages;      //vm所映射的page

  unsigned int       nr_pages;     //page个数

  unsigned long      phys_addr;    //对应的起始物理地址

  struct vm_struct   *next;        //下一个vm.用来形成链表

  }

  全局变量vmlist用来管理vm构成的链表

  全局变量vmlist用于访问vmlist所使用的信号量

  对于vm_struct有两个常用的操作: get_vm_area/remove_vm_area

  get_vm_area:用来分配一个合适大小的vm结构,分配成功之后,将其链入到vmlist中,代码在 mm/vmalloc.c中.如下示:

  //size为vm的大小

  struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)

  {

  //在VMALLOC_START与VMALLOC_END找到一段合适的空间

  return __get_vm_area(size, flags, VMALLOC_START, VMALLOC_END);

  }

  //参数说明:

  //start:起始地址 end:结束地址 size 空间大小

  struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,

  unsigned long start, unsigned long end)

  {

  struct vm_struct **p, *tmp, *area;

  unsigned long align = 1;

  unsigned long addr;

  //如果指定了VM_IOREMAP.则调整对齐因子

  if (flags & VM_IOREMAP) {

  int bit = fls(size);

  if (bit > IOREMAP_MAX_ORDER)

  bit = IOREMAP_MAX_ORDER;

  else if (bit < PAGE_SHIFT)

  bit = PAGE_SHIFT;

  align = 1ul << bit;

  }

  //将起始地址按照对齐因子对齐

  addr = ALIGN(start, align);

  //分配一个vm_struct结构空间

  area = kmalloc(sizeof(*area), GFP_KERNEL);

  if (unlikely(!area))

  return NULL;

  //PAGE_SIZE:在i32中为4KB,即上面所说的间隔空洞

  size += PAGE_SIZE;

  if (unlikely(!size)) {

  kfree (area);

  return NULL;

  }

  write_lock(&vmlist_lock);

  //遍历vmlist:找到合适大小的末使用空间

  for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {

  //若起始地址落在某一个vm区间,则调整起始地址为vm区间的末尾

  if ((unsigned long)tmp->addr < addr) {

  if((unsigned long)tmp->addr + tmp->size >= addr)

  addr = ALIGN(tmp->size +

  (unsigned long)tmp->addr, align);

  continue;

  }

  //size+addr < addr ?除非size == 0

  if ((size + addr) < addr)

  goto out;

  //中间的空隙可以容纳下size大小的vm.说明已经找到了这样的一个vm

  if (size + addr <= (unsigned long)tmp->addr)

  goto found;

  //调整起始地址为vm的结束地址

  addr = ALIGN(tmp->size + (unsigned long)tmp->addr, align);

  //如果超出了范围

  if (addr > end - size)

  goto out;

  }

  found:

  //找到了合适大小的空间,将area->addr赋值为addr,然后链入vmlist中

  area->next = *p;

  *p = area;

  area->flags = flags;

  area->addr = (void *)addr;

  area->size = size;

  area->pages = NULL;

  area->nr_pages = 0;

  area->phys_addr = 0;

  write_unlock(&vmlist_lock);

  return area;

  out:

  //没有找到合适大小的空间,出错返回

  write_unlock(&vmlist_lock);

  kfree(area);

  if (printk_ratelimit())

  printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size.n");

  return NULL;

  }

 

这段代码不是很复杂,在此不详细分析了.

  remove_vm_area用来将相应的vm从vmlist中断开,使其表示的空间可以被利用

  //addr:对应vm的超始地址

  struct vm_struct *remove_vm_area(void *addr)

  {

  struct vm_struct **p, *tmp;

  write_lock(&vmlist_lock);

  //遍历vmlist.找到超始地址为addr的vm

  for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {

  if (tmp->addr == addr)

  goto found;

  }

  write_unlock(&vmlist_lock);

  return NULL;

  found:

  //断开tmp所对应的映射关系

  unmap_vm_area(tmp);

  //找到了这个vm,将其从vmlist上断开

  *p = tmp->next;

  write_unlock(&vmlist_lock);

  return tmp;

  }

  unmap_vm_area用来断开vm所在线性地址所对应的映射关系.它的代码如下:

  void unmap_vm_area(struct vm_struct *area)

  {

  //vm所对应的起始线性地址

  unsigned long address = (unsigned long) area->addr;

  //vm所对应的结束线性地址

  unsigned long end = (address + area->size);

  pgd_t *dir;

  //起始地址所在的内核页目录项

  dir = pgd_offset_k(address);

  flush_cache_vunmap(address, end);

  do {

  //断开地址所对应的pmd映射

  unmap_area_pmd(dir, address, end - address);

  //运行到这里的时候,已经断开了一个页目录所表示的线性地址,而每个页目录表示的线性地址//大小为PGDIR_SIZE

  address = (address + PGDIR_SIZE) & PGDIR_MASK;

  dir++;

  } while (address && (address < end));

  //当到达末尾时结束循环

  flush_tlb_kernel_range((unsigned long) area->addr, end);

  }

  //断开线性地址区间所在的pmd的映射

  static void unmap_area_pmd(pgd_t *dir, unsigned long address,

  unsigned long size)

  {

  unsigned long end;

  pmd_t *pmd;

  if (pgd_none(*dir))

  return;

  if (pgd_bad(*dir)) {

  pgd_ERROR(*dir);

  pgd_clear(dir);

  return;

  }

  pmd = pmd_offset(dir, address);

  address &= ~PGDIR_MASK;

  end = address + size;

  if (end > PGDIR_SIZE)

  end = PGDIR_SIZE;

  do {

  //断开线性地址所在的pte的映射关系

  unmap_area_pte(pmd, address, end - address);

  address = (address + PMD_SIZE) & PMD_MASK;

  pmd++;

  } while (address < end);

  }

  static void unmap_area_pte(pmd_t *pmd, unsigned long address,

  unsigned long size)

  {

  unsigned long end;

  pte_t *pte;

  if (pmd_none(*pmd))

  return;

  if (pmd_bad(*pmd)) {

  pmd_ERROR(*pmd);

  pmd_clear(pmd);

  return;

  }

  pte = pte_offset_kernel(pmd, address);

  address &= ~PMD_MASK;

  end = address + size;

  if (end > PMD_SIZE)

  end = PMD_SIZE;

  do {

  pte_t page;

  //清除pte的对应映射关系

  page = ptep_get_and_clear(pte);

  address += PAGE_SIZE;

  pte++;

  if (pte_none(page))

  continue;

  if (pte_present(page))

  continue;

  printk(KERN_CRIT "Whee.. Swapped out page in kernel page tablen");

  } while (address < end);

  }

  经过这几个过程之后,实际上,它只是找到线性地址所对应的pte,然后断开pte的映射.值得注意的是:为了效率起见,这里只是断开了pte的映射,即只是将pte置为none,表示pte末映射内存.并末断开pmd和pgd的映射

 

三:vmalloc的实现:

  void *vmalloc(unsigned long size)

  {

  return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);

  }

  实际上调用__vmalloc:

  void *__vmalloc(unsigned long size, int gfp_mask, pgprot_t prot)

  {

  struct vm_struct *area;

  struct page **pages;

  unsigned int nr_pages, array_size, i;

  //使请求的大小与页框对齐

  size = PAGE_ALIGN(size);

  //有效性检查

  if (!size || (size >> PAGE_SHIFT) > num_physpages)

  return NULL;

  //取得一个有效的VM,这个函数我们在前面已经详细的分析过了

  area = get_vm_area(size, VM_ALLOC);

  if (!area)

  return NULL;

  //所要映射的页面总数

  nr_pages = size >> PAGE_SHIFT;

  //页面描述符所占的空间

  array_size = (nr_pages * sizeof(struct page *));

  area->nr_pages = nr_pages;

  area->pages = pages = kmalloc(array_size, (gfp_mask & ~__GFP_HIGHMEM));

  //如果空间分配失败

  if (!area->pages) {

  remove_vm_area(area->addr);

  kfree(area);

  return NULL;

  }

  memset(area->pages, 0, array_size);

  //为每一个页面分配空间

  for (i = 0; i < area->nr_pages; i++) {

  area->pages[i] = alloc_page(gfp_mask);

  if (unlikely(!area->pages[i])) {

  /* Successfully allocated i pages, free them in __vunmap() */

  area->nr_pages = i;

  goto fail;

  }

  }

  //为所分配的页面建立映射关系

  if (map_vm_area(area, prot, &pages))

  goto fail;

  return area->addr;

  fail:

  vfree(area->addr);

  return NULL;

  }

  map_vm_area为所分配的内存建立映射关系,它的程序流程与unmap_vm_area差不多,都是从pgd找到pte,如果同样的映射关系不存在,则新建之.(如:pgd对应的pmd不存在,则新建pmd项,使pgd指向建好的pmd.同理,如果pmd所映射的pte项不存在,则新建pte,然后建立映射),然后将pte映射到相应的页表.代码如下:

  int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page ***pages)

  {

  unsigned long address = (unsigned long) area->addr;

  unsigned long end = address + (area->size-PAGE_SIZE);

  pgd_t *dir;

  int err = 0;

  //vm 起始地址所在的页目录

  dir = pgd_offset_k(address);

  spin_lock(&init_mm.page_table_lock);

  do {

  pmd_t *pmd = pmd_alloc(&init_mm, dir, address);

  if (!pmd) {

  err = -ENOMEM;

  break;

  }

  //轮到pmd了 ^_^

  if (map_area_pmd(pmd, address, end - address, prot, pages)) {

  err = -ENOMEM;

  break;

  }

  address = (address + PGDIR_SIZE) & PGDIR_MASK;

  dir++;

  } while (address && (address < end));

  spin_unlock(&init_mm.page_table_lock);

  flush_cache_vmap((unsigned long) area->addr, end);

  return err;

  }

 

static int map_area_pmd(pmd_t *pmd, unsigned long address,

  unsigned long size, pgprot_t prot,

  struct page ***pages)

  {

  unsigned long base, end;

  base = address & PGDIR_MASK;

  address &= ~PGDIR_MASK;

  end = address + size;

  if (end > PGDIR_SIZE)

  end = PGDIR_SIZE;

  do {

  pte_t * pte = pte_alloc_kernel(&init_mm, pmd, base + address);

  if (!pte)

  return -ENOMEM;

  //轮到pte了 ^_^

  if (map_area_pte(pte, address, end - address, prot, pages))

  return -ENOMEM;

  address = (address + PMD_SIZE) & PMD_MASK;

  pmd++;

  } while (address < end);

  return 0;

  }

  //为页表页建立映射关系

  static int map_area_pte(pte_t *pte, unsigned long address,

  unsigned long size, pgprot_t prot,

  struct page ***pages)

  {

  unsigned long end;

  address &= ~PMD_MASK;

  end = address + size;

  if (end > PMD_SIZE)

  end = PMD_SIZE;

  do {

  struct page *page = **pages;

  WARN_ON(!pte_none(*pte));

  if (!page)

  return -ENOMEM;

  //具体的映射在这里了 ^_^

  set_pte(pte, mk_pte(page, prot));

  address += PAGE_SIZE;

  pte++;

  (*pages)++;

  } while (address < end);

  return 0;

  }

  只要理解了断开映射的过程,这段代码是很好理解的.

  总而言之:linux在建立映射的时候,从pgd 到pte相应的建立映射关系,最后将pte映射到分配得到的物理内存.而在断开映射的时候,linux内核从pgd找到pte,然后将pte置为none,表示pte末建立映射关系.

  四:vfree的实现:

  代码如下:

  void vfree(void *addr)

  {

  BUG_ON(in_interrupt());

  __vunmap(addr, 1);

  }

  跟踪至__vunmap:

  void __vunmap(void *addr, int deallocate_pages)

  {

  struct vm_struct *area;

  //参数有效性检查

  if (!addr)

  return;

  //判断addr是否是按页框对齐的

  if ((PAGE_SIZE-1) & (unsigned long)addr) {

  printk(KERN_ERR "Trying to vfree() bad address (%p)n", addr);

  WARN_ON(1);

  return;

  }

  //remove_vm_area:这个函数我们在之前已经分析过了 ^_^

  area = remove_vm_area(addr);

  if (unlikely(!area)) {

  //没有找到起始地址为addr的vm.则无效,退出

  printk(KERN_ERR "Trying to vfree() nonexistent vm area (%p)n",

  addr);

  WARN_ON(1);

  return;

  }

  if (deallocate_pages) {

  int i;

  for (i = 0; i < area->nr_pages; i++) {

  if (unlikely(!area->pages[i]))

  BUG();

  //释放请求获得的页面

  __free_page(area->pages[i]);

  }

  //释放分配的page 描述符

  kfree(area->pages);

  }

  //释放内核的vm 描述符

  kfree(area);

  return;

  }

  五:总结

  经过上面的分析,我们可以看到,vmalloc分配内存的过程是十分低效的,不仅要从伙伴系统中取内存而且要建立映射关系,显然,用vmalloc分配较小的内存是不合算的。此外。有个问题值得思考一下:为什么用__get_free_page不需要建立映射关系,而vmalloc就需要呢?

  其实,不管使用何种方式。线性地址到物理地址的转换最终都要经过硬件的页式管理去完成。所不同的是__get_free_page返回的线性地址是属于(PAGE_OFFSET,HIGH_MEMORY)之间的,这段线性地址在内核初始化的时候就完成了映射。而vmalloc使用的线性地址是属于(VMALLOC_START VMALLOC_END)之间的,也就是说属于一个临时映射区,所以必须为其建立映射关系。