kzalloc 函数详解(转载)

用kzalloc申请内存的时候， 效果等同于先是用 kmalloc() 申请空间 , 而后用 memset() 来初始化 ,全部申请的元素都被初始化为 0.

 

/**
 * kzalloc - allocate memory. The memory is set to zero.
 * @size: how many bytes of memory are required.
 * @flags: the type of memory to allocate (see kmalloc).
 */
static inline void *kzalloc(size_t size, gfp_t flags)
{
    return kmalloc(size, flags | __GFP_ZERO);
}

kzalloc 函数是带参数调用kmalloc函数，添加的参数是或了标志位__GFP_ZERO，

 void *__kmalloc(size_t size, gfp_t flags)
 {
     struct kmem_cache *s;
     void *ret;

     if (unlikely(size > SLUB_MAX_SIZE))
         return kmalloc_large(size, flags);

     s = get_slab(size, flags);

     if (unlikely(ZERO_OR_NULL_PTR(s)))
         return s;

     ret = slab_alloc(s, flags, -1, _RET_IP_);

     trace_kmalloc(_RET_IP_, ret, size, s->size, flags);

     return ret;
 }

这个函数调用trace_kmalloc，flags参数不变，继续往里面能够看到

 

 

 static __always_inline void *slab_alloc(struct kmem_cache *s,
         gfp_t gfpflags, int node, unsigned long addr)
 {
     void **object;
     struct kmem_cache_cpu *c;
     unsigned long flags;
     unsigned int objsize;

     gfpflags &= gfp_allowed_mask;

     lockdep_trace_alloc(gfpflags);
     might_sleep_if(gfpflags & __GFP_WAIT);

     if (should_failslab(s->objsize, gfpflags))
         return NULL;

     local_irq_save(flags);
     c = get_cpu_slab(s, smp_processor_id());
     objsize = c->objsize;
     if (unlikely(!c->freelist || !node_match(c, node)))

         object = __slab_alloc(s, gfpflags, node, addr, c);

     else {
         object = c->freelist;
         c->freelist = object[c->offset];
         stat(c, ALLOC_FASTPATH);
     }
     local_irq_restore(flags);

     if (unlikely((gfpflags & __GFP_ZERO) && object))
         memset(object, 0, objsize);

     kmemcheck_slab_alloc(s, gfpflags, object, c->objsize);
     kmemleak_alloc_recursive(object, objsize, 1, s->flags, gfpflags);

     return object;
 }

这里主要判断两个标志，WAIT和ZERO，和本文有关的关键代码就是

 

if (unlikely((gfpflags & __GFP_ZERO) && object))
memset(object, 0, objsize);

到此，这个函数区别于kmalloc的地方就清楚了

kmalloc 函数详解

 

#include <linux/slab.h> void *kmalloc(size_t size, int flags);

 

给 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 读是有用的, 此时在处理器缓冲中出现是无用的.

__GFP_NOWARN

这个不多用到的标志阻止内核来发出警告(使用 printk ), 当一个分配没法知足.

__GFP_HIGH

这个标志标识了一个高优先级请求, 它被容许来消耗甚至被内核保留给紧急情况的最后的内存页.

__GFP_REPEAT

__GFP_NOFAIL

__GFP_NORETRY

这些标志修改分配器如何动做, 当它有困难知足一个分配. __GFP_REPEAT 意思是" 更尽力些尝试" 经过重复尝试 -- 可是分配可能仍然失败. __GFP_NOFAIL 标志告诉分配器不要失败; 它尽最大努力来知足要求. 使用 __GFP_NOFAIL 是强烈不推荐的; 可能从不会有有效的理由在一个设备驱动中使用它. 最后, __GFP_NORETRY 告知分配器当即放弃若是得不到请求的内存.

kmalloc 可以分配的内存块的大小有一个上限. 这个限制随着体系和内核配置选项而变化. 若是你的代码是要彻底可移植, 它不能期望能够分配任何大于 128 KB. 若是你须要多于几个 KB

这方面的缘由：

kmalloc并不直接从分页机制中得到空闲页面而是从slab页面分配器那儿得到须要的页面，slab的实现代码限制了最大分配的大小为128k，即 131072bytes,理论上你能够经过更改slab.c中的 cache_sizes数组中的最大值使得kmalloc能够得到更大的页面数，不知道有没有甚么副效应或者没有必要这样作，由于获取较大内存的方法有很 多，想必128k是经验总结后的合适值。

alloc_page( )能够分配的最大连续页面是4K

 static inline struct page * alloc_pages(unsigned int gfp_mask, unsigned int order) 
{ 
/* 

 * Gets optimized away by the compiler.   */   if (order >= MAX_ORDER)   return NULL;   return _alloc_pages(gfp_mask, order);   }  alloc_pages最大分配页面数为512个，则可用内存数最大为2^9*4K=2M