linux中kmalloc和vmalloc的使用

kmalloc和get_free_page申请的内存位于物理内存映射区域，而且在物理上也是连续的，它们与真实的物理地址只有一个固定的偏移，因此存在较简单的转换关系，virt_to_phys()可以实现内核虚拟地址转化为物理地址：

#define __pa(x) ((unsigned long)(x)-PAGE_OFFSET)
   extern inline unsigned long virt_to_phys(volatile void * address)
   {
       　return __pa(address);
   }
上面转换过程是将虚拟地址减去3G（PAGE_OFFSET=0XC000000）。

与之对应的函数为phys_to_virt()，将内核物理地址转化为虚拟地址：
   #define __va(x) ((void *)((unsigned long)(x)+PAGE_OFFSET))
   extern inline void * phys_to_virt(unsigned long address)
   {
       　return __va(address);
   }
virt_to_phys()和phys_to_virt()都定义在include\asm-i386\io.h中。

再来看看kmalloc(),kmalloc‍()是内核中最常见的内存分配方式，它最终调用伙伴系统的__get_free_pages()函数分配，(也就是说，对于分配高端内存来说，不能用kmalloc函数来进行分配)。根据传递给这个函数的flags参数，决定这个函数的分配适合什么场合，如果标志是GFP_KERNEL则仅仅可以用于进程上下文中，如果标志GFP_ATOMIC则可以用于中断上下文或者持有锁的代码段中。
kmalloc返回的线形地址是直接映射的，而且用连续物理页满足分配请求，且内置了最大请求数（2**5=32页）。
     再来看看vmalloc()。vmalloc()函数为了把物理上不连续的页面转换为虚拟地址空间上连续的页，必须专门建立页表项。还有，通过vmalloc()获得的页必须一个一个的进行映射（因为它们物理上不是连续的），这就会导致比直接内存映射大得多的缓冲区刷新。因为这些原因，vmalloc()仅在绝对必要时才会使用——典型的就是为了获得大块内存时，例如，当模块被动态插入到内核中时，就把模块装载到由vmalloc()分配的内存上。
     总结一下：kmalloc()与kfree()对应，可以分配连续的物理内存
vmalloc()与vfree()对应，可以分配连续的虚拟内存，但是物理内存不一定连续，适用于分配大量内存
vmalloc()函数用起来比较简单：
char *buf;
buf = vmalloc（16*PAGE_SIZE）; /*获得16页*/
if（!buf）
   /*错误！不能分配内存*/
在使用完分配的内存之后，一定要释放它：
vfree（buf）；

给 kmalloc 的第一个参数是要分配的块的大小. 第 2 个参数, 分配标志, 非常有趣, 因为它以几个方式控制 kmalloc 的行为.
最一般使用的标志, GFP_KERNEL, 意思是这个分配((内部最终通过调用 __get_free_pages 来进行, 它是 GFP_ 前缀的来源) 代表运行在内核空间的进程而进行的. 换句话说, 这意味着调用函数是代表一个进程在执行一个系统调用. 使用 GFP_KENRL 意味着 kmalloc 能够使当前进程在少内存的情况下睡眠来等待一页. 一个使用 GFP_KERNEL 来分配内存的函数必须, 因此, 是可重入的并且不能在原子上下文中运行. 当当前进程睡眠, 内核采取正确的动作来定位一些空闲内存, 或者通过刷新缓存到磁盘或者交换出去一个用户进程的内存.
GFP_KERNEL 不一直是使用的正确分配标志; 有时 kmalloc 从一个进程的上下文的外部调用. 例如, 这类的调用可能发生在中断处理, tasklet, 和内核定时器中. 在这个情况下, 当前进程不应当被置为睡眠, 并且驱动应当使用一个 GFP_ATOMIC 标志来代替. 内核正常地试图保持一些空闲页以便来满足原子的分配. 当使用 GFP_ATOMIC 时, kmalloc 能够使用甚至最后一个空闲页. 如果这最后一个空闲页不存在, 但是, 分配失败.
其他用来代替或者增添 GFP_KERNEL 和 GFP_ATOMIC 的标志, 尽管它们 2 个涵盖大部分设备驱动的需要. 所有的标志定义在 <linux/gfp.h>, 并且每个标志用一个双下划线做前缀, 例如 __GFP_DMA. 另外, 有符号代表常常使用的标志组合; 这些缺乏前缀并且有时被称为分配优先级. 后者包括:
GFP_ATOMIC
用来从中断处理和进程上下文之外的其他代码中分配内存. 从不睡眠.
GFP_KERNEL
内核内存的正常分配. 可能睡眠.
GFP_USER
用来为用户空间页来分配内存; 它可能睡眠.
GFP_HIGHUSER
如同 GFP_USER, 但是从高端内存分配, 如果有. 高端内存在下一个子节描述.
GFP_NOIO
GFP_NOFS
这个标志功能如同 GFP_KERNEL, 但是它们增加限制到内核能做的来满足请求. 一个 GFP_NOFS 分配不允许进行任何文件系统调用, 而 GFP_NOIO 根本不允许任何 I/O 初始化. 它们主要地用在文件系统和虚拟内存代码, 那里允许一个分配睡眠, 但是递归的文件系统调用会是一个坏注意.
上面列出的这些分配标志可以是下列标志的相或来作为参数, 这些标志改变这些分配如何进行:
__GFP_DMA
这个标志要求分配在能够 DMA 的内存区. 确切的含义是平台依赖的并且在下面章节来解释.
__GFP_HIGHMEM
这个标志指示分配的内存可以位于高端内存.
__GFP_COLD
正常地, 内存分配器尽力返回"缓冲热"的页 -- 可能在处理器缓冲中找到的页. 相反, 这个标志请求一个"冷"页, 它在一段时间没被使用. 它对分配页作 DMA 读是有用的, 此时在处理器缓冲中出现是无用的. 一个完整的对如何分配 DMA 缓存的讨论看"直接内存存取"一节在第 1 章.
__GFP_NOWARN
这个很少用到的标志阻止内核来发出警告(使用 printk ), 当一个分配无法满足.
__GFP_HIGH
这个标志标识了一个高优先级请求, 它被允许来消耗甚至被内核保留给紧急状况的最后的内存页.
__GFP_REPEAT
__GFP_NOFAIL
__GFP_NORETRY
这些标志修改分配器如何动作, 当它有困难满足一个分配. __GFP_REPEAT 意思是" 更尽力些尝试" 通过重复尝试 -- 但是分配可能仍然失败. __GFP_NOFAIL 标志告诉分配器不要失败; 它尽最大努力来满足要求. 使用 __GFP_NOFAIL 是强烈不推荐的; 可能从不会有有效的理由在一个设备驱动中使用它. 最后, __GFP_NORETRY 告知分配器立即放弃如果得不到请求的内存.
kmalloc 能够分配的内存块的大小有一个上限. 这个限制随着体系和内核配置选项而变化. 如果你的代码是要完全可移植, 它不能指望可以分配任何大于 128 KB. 如果你需要多于几个 KB, 但是, 有个比 kmalloc 更好的方法来获得内存, 我们在本章后面描述.
这方面的原因：
kmalloc并不直接从分页机制中获得空闲页面而是从slab页面分配器那儿获得需要的页面，slab的实现代码限制了最大分配的大小为 128k，即131072bytes,理论上你可以通过更改slab.c中的 cache_sizes数组中的最大值使得kmalloc可以获得更大的页面数，不知道有没有甚么副效应或者没有必要这样做，因为获取较大内存的方法有很 多，想必128k是经验总结后的合适值。
alloc_page( )可以分配的最大连续页面是4M吧。MAX_ORDER =10
46 static inline struct page * alloc_pages(unsigned int gfp_mask, unsigned int order) 
47 { 
48 /* 
49 * Gets optimized away by the compiler. 
50 */ 
51 if (order >= MAX_ORDER) 
52 return NULL; 
53 return _alloc_pages(gfp_mask, order); 
54 } 


alloc_pages最大分配页面数为512个，则可用内存数最大为2^9*4K=2M 

测试程序如下：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <linux/highmem.h>


MODULE_LICENSE("GPL");
MODULE_AUTHOR("www.enjoylinux.cn");
MODULE_DESCRIPTION("Memory alloc test Module");
MODULE_ALIAS("malloc module");


unsigned char *pagemem;
unsigned char *pagezmem;
unsigned char *pagesmem;
unsigned char *kmallocmem;
unsigned char *vmallocmem;
#ifdef HMEMTST
struct page *allocpage;
unsigned char *kmapmem;
#endif


int __init alloc_init(void)
{
pagemem = (unsigned char*)__get_free_page(GFP_KERNEL);
printk("<1>get_free_page: pagemem va addr=%p  "
            "\tpa addr=%lx\n", pagemem, __pa(pagemem));
pagesmem = (unsigned char*)__get_free_pages(GFP_KERNEL, 3);
printk("<1>get_free_pages: pagesmem va addr=%p"
            "\tpa addr=%lx\n", pagesmem, __pa(pagesmem));
    pagezmem = (unsigned char*)get_zeroed_page(GFP_KERNEL);
printk("<1>get_zeroed_page: pagezmem va addr=%p"
            "\tpa addr=%lx\n", pagezmem, __pa(pagezmem));


  kmallocmem = (unsigned char*)kmalloc(100, GFP_KERNEL);
    memset(kmallocmem, 0, 100);
strcpy(kmallocmem, "<<< --- Kmalloc Mem OK! --- >>>");
  printk("<1>kmalloc: kmallocmem va addr=%p  "
            "\tpa addr=%lx\n", kmallocmem, __pa(kmallocmem));
  printk("<1>kmalloc: kmallocmem say %s\n", kmallocmem);


vmallocmem = (unsigned char*)vmalloc(1000000);
printk("<1>vmalloc: vmallocmem va addr=%p\n", vmallocmem);
#ifdef HMEMTST   
    allocpage = alloc_pages(__GFP_HIGHMEM|GFP_KERNEL, 0);
    if (!PageHighMem(allocpage))
        printk("<1> it's not highmem\n");
printk("<1>page_address: va addr=%p\n", (unsigned char*)page_address(allocpage));
    kmapmem = (unsigned char*)kmap(allocpage);
printk("<1>kmap: kmapmem va addr=%p\n", kmapmem);    
    kunmap(allocpage);    
    kmapmem = (unsigned char*)kmap_atomic(allocpage, 0);
printk("<1>kmap_atomic: kmapmem va addr=%p\n", kmapmem);    
    kunmap_atomic(allocpage, 0);  
#endif
return 0;
}
void __exit alloc_exit(void)
{
free_page((int)pagemem);
free_page((int)pagezmem);
free_pages((int)pagesmem, 3);
kfree(kmallocmem);
    vfree(vmallocmem);
#ifdef HMEMTST    
    __free_pages(allocpage, 0);
#endif
printk("<1><<< --- Module Exit! --->>>\n");
}


module_init(alloc_init);
module_exit(alloc_exit);