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
  




<think>我们正在讨论Linux内核内存分配函数kzalloc和kmalloc的区别及使用场景。首先,我们需要明确这两个函数的基本定义和功能。 kmalloc是Linux内核中用于分配连续物理内存的函数,其原型为:void*kmalloc(size_t size, gfp_tflags);它分配的内存是物理地址连续的,大小至少为指定的大小,并且分配后内存的内容是未初始化的(即可能包含随机数据)。kzalloc是kmalloc的一个变种,其原型为: void*kzalloc(size_tsize,gfp_t flags);它除了分配内存外,还会将分配的内存初始化为零。实际上,kzalloc相当于用kmalloc分配内存后,再调用memset将内存置零。因此,主要区别在于:1.初始化:kzalloc会将分配的内存初始化为0,而kmalloc不会。2.性能:由于kzalloc需要额外的清零操作,因此它比kmalloc稍慢。但在很多情况下,这种性能差异可以忽略不计,特别是当安全性要求较高时。使用场景:-当需要分配内存并确保其内容不被之前的数据污染时(例如,分配结构体内存,并且希望所有成员初始为0),应使用kzalloc。-如果分配的内存将立即被完全覆盖,或者不需要初始化,那么使用kmalloc更高效。另外,kzalloc实际上是使用kmalloc实现的,只是它使用了标志位__GFP_ZERO,该标志位要求分配的内存被清零。因此,我们也可以手动使用kmalloc并指定__GFP_ZERO标志来达到同样的效果。例如:使用kzalloc:ptr= kzalloc(size,GFP_KERNEL);等价于:ptr =kmalloc(size,GFP_KERNEL| __GFP_ZERO);但是,使用kzalloc更简洁,并且避免了手动设置标志位的麻烦。在驱动开发中,通常推荐使用kzalloc来分配结构体,因为这样可以避免未初始化成员带来的安全问题(例如,未初始化的指针可能导致内核崩溃)。而对于缓冲区等可能立即被覆盖的数据,可以使用kmalloc。另外,需要注意的是,这两个函数分配的内存都需要使用kfree来释放。下面我们通过一个简单的例子来说明:假设我们有一个结构体:struct my_struct{int a;char b;void*c;};如果我们使用kmalloc分配:structmy_struct*p= kmalloc(sizeof(struct my_struct),GFP_KERNEL);那么p指向的内存中,成员a、b和c的值都是未定义的。而使用kzallocstruct my_struct *p =kzalloc(sizeof(struct my_struct),GFP_KERNEL);则p->a为0,p->b为0,p->c为NULL。这样,在后续使用中,我们可以安全地检查p->c是否为NULL,而不会因为随机值导致误判。总结:-kzalloc=kmalloc+ memset(0)-需要初始化内存为零时用kzalloc,否则用kmalloc(并确保后续会覆盖或不需要初始化)在性能敏感的路径上,如果确定不需要清零,使用kmalloc可以避免不必要的清零开销。引用说明:[^1]:Linux内核源码中关于kmalloc和kzalloc的实现,以及内存分配标志的定义。[^2]:Linux设备驱动开发详解(书籍)中关于内存分配的建议。生成相关问题:根据这个主题,我们可以提出以下问题:1.kzalloc和kmalloc在内存分配失败时的行为是否相同?2.除了kzalloc和kmalloc,Linux内核还有哪些内存分配函数?3.在什么情况下必须使用kmalloc而不是kzalloc?4.如何选择kmalloc的标志(如GFP_KERNEL, GFP_ATOMIC)?5. kzalloc是否会导致额外的性能开销?在哪些场景下这种开销是值得的?注意:引用标识在回答中自然添加,如上述回答中已经添加了[^1]和[^2]。</think>### Linux内核中kzalloc与kmalloc的区别及使用场景 在Linux内核开发中,`kmalloc`和`kzalloc`都是动态内存分配函数,但存在关键差异: #### 1. **核心区别** - **`kmalloc`** 分配指定大小的内存块,**不初始化内存内容**(可能包含随机数据)。 函数原型:`void *kmalloc(size_t size, gfp_t flags);` 示例:`ptr = kmalloc(100, GFP_KERNEL);` - **`kzalloc`** 分配内存并**自动初始化为全零**(等效于`kmalloc + memset(0)`)。 函数原型:`void *kzalloc(size_t size, gfp_t flags);` 内部实现等价于:`kmalloc(size, flags | __GFP_ZERO);` #### 2. **性能对比** | 函数 | 初始化开销 | 速度 | 内存内容 | |----------|------------|------------|--------------| | `kmalloc` | 无 | ⚡ **更快** | 未初始化数据 | | `kzalloc` | 有清零操作 | 稍慢 | 全零 | #### 3. **典型使用场景** - **优先使用`kzalloc`当**: - 分配结构体或对象需默认零值(如`task_struct`) - 避免未初始化敏感数据(如加密密钥) - 简化代码(省去手动`memset`) ```c // 安全初始化结构体 struct device *dev = kzalloc(sizeof(*dev), GFP_KERNEL); ``` - **优先使用`kmalloc`当**: - 内存将立即被完全覆盖(如DMA缓冲区) - 性能关键路径(减少清零开销) - 分配大型非敏感缓冲区 ```c // 快速分配将被填充的缓冲区 char *buf = kmalloc(BUF_SIZE, GFP_ATOMIC); memcpy(buf, source_data, BUF_SIZE); ``` #### 4. **关键注意事项** 1. **释放方式相同**:两者均需用`kfree()`释放 2. **物理连续性**:均保证物理地址连续(适用于DMA) 3. **标志位兼容**:支持相同的`GFP_*`内存分配标志(如`GFP_KERNEL`/`GFP_ATOMIC`) 4. **大小限制**:最大分配尺寸通常为4MB(依赖`CONFIG_FRAG_ALLOC`) > **安全建议**:在驱动开发中优先使用`kzalloc`,可避免未初始化内存漏洞(如内核信息泄漏)[^1]。 --- ### 相关问题 1. `kzalloc`的零初始化在内核启动阶段是否会产生性能瓶颈? 2. 如何通过`kmalloc`手动实现等效于`kzalloc`的功能? 3. 什么场景下必须使用`GFP_ATOMIC`标志而非`GFP_KERNEL`? 4. `vmalloc`与`kmalloc`有何区别?何时应选择`vmalloc`? 5. Linux内核如何处理`kzalloc/kmalloc`的内存碎片问题? [^1]: Linux内核文档`memory-allocation.txt`强调零初始化对安全性的重要性。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值