内存管理[3]

原创 于 2008-12-29 16:06:00 发布 · 879 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#struct #工作 #null

本文介绍了vmalloc()函数的工作原理及其与kmalloc()的区别，vmalloc()可以分配虚拟地址连续但物理地址不连续的内存，并详细解释了vmalloc()的实现细节及如何通过vfree()释放内存。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

    vmalloc()函数的工作方式类似于kmalloc()，只不过前者分配的内存虚拟地址是连续的，而物理地址则无需连续。这也是用户空间分配函数的工作方式：由malloc()返回的页在进程的虚拟地址空间内是连续的，但是，这并不保证它们在物理RAM中也连续。kmalloc()函数确保页在物理地址上是连续的（虚拟地址自然也是连续的）。vmalloc()函数只确保页在虚拟地址空间内是连续的。它通过分配非连续的物理内存块，再“修正”页表，把内存映射到逻辑地址空间的连续区域中，就能做到这一点。

   一般只有硬件设备需要得到物理地址连续的内存。在很多体系结构上，硬件设备存在于内存管理单元以外，它根本不理解什么是虚拟地址。因此，硬件设备用到的任何内存区都必须是物理上连续的块，而不仅仅是虚拟地址连续的块。而仅供软件使用的内存块（例如与进程相关的缓冲区）就可以使用只有虚拟地址连续的内存块。对内核而言，所有内存看起来都是逻辑上连续的。

   尽管紧急在某些情况下才需要物理上连续的内存块，但是，很多内核代码都用kmalloc()来获得内存，而不是vmalloc()。因为vmalloc()函数为了把物理上不连续的页转换为虚拟地址空间上连续的页，必须专门建立页表项。通过vmalloc()获得的页必须一个一个地进行映射，这就导致比直接内存映射大得多的TLB抖动。因此，vmalloc()只在不得已的时候才用，一般是为了获得大块内存时，如，当模块被动态的插入到内核中，就把模块装载到由vmalloc()分配的内存上。

   

  1. 在<Vmalloc.c(mm)>
  3. /**
  4.  *  vmalloc  -  allocate virtually contiguous memory
  5.  *  @size:      allocation size
  6.  *  Allocate enough pages to cover @size from the page level
  7.  *  allocator and map them into contiguous kernel virtual space.
  8.  *
  9.  *  For tight control over page level allocator and protection flags
  10.  *  use __vmalloc() instead.
  11.  */
  12. void *vmalloc(unsigned long size)
  13. {
  14.     return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
  15. }
  17. void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
  18. {
  19.     return __vmalloc_node(size, gfp_mask, prot, -1);
  20. }
  22. /**
  23.  *  __vmalloc_node  -  allocate virtually contiguous memory
  24.  *  @size:      allocation size
  25.  *  @gfp_mask:  flags for the page level allocator
  26.  *  @prot:      protection mask for the allocated pages
  27.  *  @node:      node to use for allocation or -1
  28.  *
  29.  *  Allocate enough pages to cover @size from the page level
  30.  *  allocator with @gfp_mask flags.  Map them into contiguous
  31.  *  kernel virtual space, using a pagetable protection of @prot.
  32.  */
  33. static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
  34.                 int node)
  35. {
  36.     struct vm_struct *area;
  38.     size = PAGE_ALIGN(size);
  39.     if (!size || (size >> PAGE_SHIFT) > num_physpages)
  40.         return NULL;
  42.     area = get_vm_area_node(size, VM_ALLOC, node, gfp_mask);
  43.     if (!area)
  44.         return NULL;
  46.     return __vmalloc_area_node(area, gfp_mask, prot, node);
  47. }
  49. struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
  50.                 unsigned long start, unsigned long end)
  51. {
  52.     return __get_vm_area_node(size, flags, start, end, -1, GFP_KERNEL);
  53. }
  55. static struct vm_struct *__get_vm_area_node(unsigned long size, unsigned long flags,
  56.                         unsigned long start, unsigned long end,
  57.                         int node, gfp_t gfp_mask)
  58. {
  59.     struct vm_struct **p, *tmp, *area;
  60.     unsigned long align = 1;
  61.     unsigned long addr;
  63.     BUG_ON(in_interrupt());
  64.     if (flags & VM_IOREMAP) {
  65.         int bit = fls(size);
  67.         if (bit > IOREMAP_MAX_ORDER)
  68.             bit = IOREMAP_MAX_ORDER;
  69.         else if (bit < PAGE_SHIFT)
  70.             bit = PAGE_SHIFT;
  72.         align = 1ul << bit;
  73.     }
  74.     addr = ALIGN(start, align);
  75.     size = PAGE_ALIGN(size);
  76.     if (unlikely(!size))
  77.         return NULL;
  79.     area = kmalloc_node(sizeof(*area), gfp_mask & GFP_LEVEL_MASK, node);
  80.     if (unlikely(!area))
  81.         return NULL;
  83.     /*
  84.      * We always allocate a guard page.
  85.      */
  86.     size += PAGE_SIZE;
  88.     write_lock(&vmlist_lock);
  89.     for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {
  90.         if ((unsigned long)tmp->addr < addr) {
  91.             if((unsigned long)tmp->addr + tmp->size >= addr)
  92.                 addr = ALIGN(tmp->size + 
  93.                          (unsigned long)tmp->addr, align);
  94.             continue;
  95.         }
  96.         if ((size + addr) < addr)
  97.             goto out;
  98.         if (size + addr <= (unsigned long)tmp->addr)
  99.             goto found;
  100.         addr = ALIGN(tmp->size + (unsigned long)tmp->addr, align);
  101.         if (addr > end - size)
  102.             goto out;
  103.     }
  105. found:
  106.     area->next = *p;
  107.     *p = area;
  109.     area->flags = flags;
  110.     area->addr = (void *)addr;
  111.     area->size = size;
  112.     area->pages = NULL;
  113.     area->nr_pages = 0;
  114.     area->phys_addr = 0;
  115.     write_unlock(&vmlist_lock);
  117.     return area;
  119. out:
  120.     write_unlock(&vmlist_lock);
  121.     kfree(area);
  122.     if (printk_ratelimit())
  123.         printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size./n");
  124.     return NULL;
  125. }

   函数可能睡眠，因此不能在中断上下文进行调用，也不能在其他不允许阻塞情况下调用。

   要释放通过vmalloc()函数所获得的内存，使用下面的函数：

  2. /**
  3.  *  vfree  -  release memory allocated by vmalloc()
  4.  *  @addr:      memory base address
  5.  *
  6.  *  Free the virtually contiguous memory area starting at @addr, as
  7.  *  obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
  8.  *  NULL, no operation is performed.
  9.  *
  10.  *  Must not be called in interrupt context.
  11.  */
  12. void vfree(void *addr)
  13. {
  14.     BUG_ON(in_interrupt());
  15.     __vunmap(addr, 1);
  16. }
  18. void __vunmap(void *addr, int deallocate_pages)
  19. {
  20.     struct vm_struct *area;
  22.     if (!addr)
  23.         return;
  25.     if ((PAGE_SIZE-1) & (unsigned long)addr) {
  26.         printk(KERN_ERR "Trying to vfree() bad address (%p)/n", addr);
  27.         WARN_ON(1);
  28.         return;
  29.     }
  31.     area = remove_vm_area(addr);
  32.     if (unlikely(!area)) {
  33.         printk(KERN_ERR "Trying to vfree() nonexistent vm area (%p)/n",
  34.                 addr);
  35.         WARN_ON(1);
  36.         return;
  37.     }
  39.     debug_check_no_locks_freed(addr, area->size);
  41.     if (deallocate_pages) {
  42.         int i;
  44.         for (i = 0; i < area->nr_pages; i++) {
  45.             BUG_ON(!area->pages[i]);
  46.             __free_page(area->pages[i]);
  47.         }
  49.         if (area->flags & VM_VPAGES)
  50.             vfree(area->pages);
  51.         else
  52.             kfree(area->pages);
  53.     }
  55.     kfree(area);
  56.     return;
  57. }
  59. /**
  60.  *  remove_vm_area  -  find and remove a contingous kernel virtual area
  61.  *  @addr:      base address
  62.  *
  63.  *  Search for the kernel VM area starting at @addr, and remove it.
  64.  *  This function returns the found VM area, but using it is NOT safe
  65.  *  on SMP machines, except for its size or flags.
  66.  */
  67. struct vm_struct *remove_vm_area(void *addr)
  68. {
  69.     struct vm_struct *v;
  70.     write_lock(&vmlist_lock);
  71.     v = __remove_vm_area(addr);
  72.     write_unlock(&vmlist_lock);
  73.     return v;
  74. }
  76. /* Caller must hold vmlist_lock */
  77. static struct vm_struct *__remove_vm_area(void *addr)
  78. {
  79.     struct vm_struct **p, *tmp;
  81.     for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
  82.          if (tmp->addr == addr)
  83.              goto found;
  84.     }
  85.     return NULL;
  87. found:
  88.     unmap_vm_area(tmp);
  89.     *p = tmp->next;
  91.     /*
  92.      * Remove the guard page.
  93.      */
  94.     tmp->size -= PAGE_SIZE;
  95.     return tmp;
  96. }

   这个函数也可以睡眠，因此不能在中断上下文中调用。

qinzhonghello
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值