kzalloc-vzalloc

kzalloc

#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/printk.h>

#define MY_PAGE_SIZE	(1UL << 12)
static void *virtual_addr_start;

void *my_zeroed_page(void)
{
	// return (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
	return kzalloc(MY_PAGE_SIZE, GFP_KERNEL);
}

static int __init my_demo_init(void)
{
	unsigned long long int phy_addr_start;
	virtual_addr_start = my_zeroed_page();
	if (!virtual_addr_start) {
		pr_err("%s, memory allocation failed\n", __func__);
		return -ENOMEM;
	}

	// 虚拟地址和物理地址的映射
	phy_addr_start = virt_to_phys(virtual_addr_start);
	pr_info("%s, virtual start addr 0x%x\n", __func__, virt_to_phys);
	pr_info("%s, phy start addr 0x%x\n", __func__, phy_addr_start);

	// 测试中间某个地址
	pr_info("%s, virtual addr 0x%x\n", __func__, virt_to_phys + MY_PAGE_SIZE/2);
	pr_info("%s, phy addr 0x%x\n", __func__, phy_addr_start + MY_PAGE_SIZE/2);

	// 测试结束地址
	pr_info("%s, virtual end addr 0x%x\n", __func__, virt_to_phys + MY_PAGE_SIZE);
	pr_info("%s, phy end addr 0x%x\n", __func__, phy_addr_start + MY_PAGE_SIZE);

	return 0;
}

static void my_demo_exit(void)
{
	// free_page(virtual_addr_start); // 此时形参是 unsigned long 类型
	if (!IS_ERR_OR_NULL(virtual_addr_start)) {
		kfree((void *)virtual_addr_start);
		virtual_addr_start= NULL;
		pr_info("%s, memory free success\n", __func__);
	} else {
		pr_err("%s, memory free failed\n", __func__);
	}
}

module_init(my_demo_init);
module_exit(my_demo_exit);

MODULE_LICENSE ("GPL");
MODULE_AUTHOR ("kiss1994");
MODULE_DESCRIPTION ("kmalloc and vmalloc");

[ 1584.935084] my_demo_init, virtual start addr 0xc06b5000
[ 1584.935089] my_demo_init, phy start addr 0x393cd000
[ 1584.935091] my_demo_init, virtual addr 0xc06b5800
[ 1584.935093] my_demo_init, phy addr 0x393cd800
[ 1584.935094] my_demo_init, virtual end addr 0xc06b6000
[ 1584.935096] my_demo_init, phy end addr 0x393ce000
[ 1601.537419] my_demo_exit, memory free success

地址确实是连续的

//==================================================================

vzalloc

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

#define MY_PAGE_SIZE	(1UL << 12)
static void *virtual_addr_start;

void *my_zeroed_page(void)
{
	return vzalloc(MY_PAGE_SIZE);
}

static int __init my_demo_init(void)
{
	unsigned long long int phy_addr_start;
	virtual_addr_start = my_zeroed_page();
	if (!virtual_addr_start) {
		pr_err("%s, memory allocation failed\n", __func__);
		return -ENOMEM;
	}

	// 虚拟地址和物理地址的映射
	phy_addr_start = virt_to_phys(virtual_addr_start);
	pr_info("%s, virtual start addr 0x%x\n", __func__, virt_to_phys);
	pr_info("%s, phy start addr 0x%x\n", __func__, phy_addr_start);

	// 测试中间某个地址
	pr_info("%s, virtual addr 0x%x\n", __func__, virt_to_phys + MY_PAGE_SIZE/2);
	pr_info("%s, phy addr 0x%x\n", __func__, phy_addr_start + MY_PAGE_SIZE/2);

	// 测试结束地址
	pr_info("%s, virtual end addr 0x%x\n", __func__, virt_to_phys + MY_PAGE_SIZE);
	pr_info("%s, phy end addr 0x%x\n", __func__, phy_addr_start + MY_PAGE_SIZE);

	return 0;
}

static void my_demo_exit(void)
{
	// free_page(virtual_addr_start); // 此时形参是 unsigned long 类型
	if (!IS_ERR_OR_NULL(virtual_addr_start)) {
		vfree((void *)virtual_addr_start);
		virtual_addr_start= NULL;
		pr_info("%s, memory free success\n", __func__);
	} else {
		pr_err("%s, memory free failed\n", __func__);
	}
}

module_init(my_demo_init);
module_exit(my_demo_exit);

MODULE_LICENSE ("GPL");
MODULE_AUTHOR ("kiss1994");
MODULE_DESCRIPTION ("kmalloc and vmalloc");

[ 2142.149619] my_demo_init, virtual start addr 0xc06ba000
[ 2142.149625] my_demo_init, phy start addr 0x2c5000
[ 2142.149627] my_demo_init, virtual addr 0xc06ba800
[ 2142.149628] my_demo_init, phy addr 0x2c5800
[ 2142.149630] my_demo_init, virtual end addr 0xc06bb000
[ 2142.149632] my_demo_init, phy end addr 0x2c6000

这里碰巧是连续的，可能是我的电脑内存不紧张，要么就是Linux对PAGE大小的内存申请做了优化

vmalloc 和 __vmalloc

Allocate enough pages to cover @size from the page level allocator with @gfp_mask flags.
Map them into contiguous kernel virtual space.
For tight control over page level allocator and protection flags use __vmalloc() instead.

两者区别：

void *vmalloc(unsigned long size)
{
	return __vmalloc_node(size, 1, GFP_KERNEL, NUMA_NO_NODE, __builtin_return_address(0));
}

void *__vmalloc(unsigned long size, gfp_t gfp_mask)
{
	return __vmalloc_node(size, 1, gfp_mask, NUMA_NO_NODE, __builtin_return_address(0));
}

参考博客中的区别

https://www.cnblogs.com/eleclsc/p/11531589.html
1).kmalloc/__get_free_pages申请的内存块都在物理内存映射区,即在(PAGE_OFFSET,HIGH_MEMORY)之间,
处理的都是物理地址,且保证在物理地址空间上是连续的;
二者返回的都是虚拟地址,如果需要得到正确的物理地址,需要使用virt_to_phys()进行转换;
但是,kmalloc和vmalloc都是以字节为单位进行申请,
而__get_free_pages()则是以页为单位进行申请;
2).vmalloc函数申请的内存块位于虚拟内存映射区,即在(VMALLOC_START,VMALLOC_END)之间,
处理的都是虚拟内存,且保证在虚拟地址空间上是连续的,但是在物理地址空间上不要求连续;
一般作为交换区、模块的内存使用;
3).kmalloc和vmalloc都是基于slab机制实现的,但是kmalloc的速度比vmalloc的速度快;
__get_free_pages是基于buddy机制实现的,速度也较快;
4).kmalloc用于小块内存的申请,通常,一次所能申请的内存块的大小在(32/64字节,128KB-16)之间;
而vmalloc可以用于分配大块内存的场合;
5).kmalloc申请的内存块在物理地址空间上是连续的,所以它申请的内存块可以直接用于DMA传输;
vmalloc申请的内存块在虚拟地址空间上连续,但是在物理地址空间上不要求连续,
所以它申请的内存块不能直接用于DMA传输;
6).kmalloc申请的内存块用kfree释放;vmalloc申请的内存块用vfree释放;
__get_free_pages申请的内存页用__free_pages释放;
7).kmalloc申请得到的地址称为内核逻辑地址,vmalloc申请得到的地址称为内核虚拟地址;

kernel中两者的结合

先用 kzalloc ，不行的话再用 __vmalloc

/* Trying kmalloc first, falling back to vmalloc.
 * GFP_NOIO, as this is called while drbd IO is "suspended",
 * and during resize or attach on diskless Primary,
 * we must not block on IO to ourselves.
 * Context is receiver thread or dmsetup. */
new_pages = kzalloc(bytes, GFP_NOIO | __GFP_NOWARN);
if (!new_pages) {
	new_pages = __vmalloc(bytes, GFP_NOIO | __GFP_ZERO);
	if (!new_pages)
		return NULL;
}

附录

常用的内存申请 gfp_mask 如下：

#define GFP_ATOMIC	(__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)
#define GFP_KERNEL	(__GFP_RECLAIM | __GFP_IO | __GFP_FS)
#define GFP_KERNEL_ACCOUNT (GFP_KERNEL | __GFP_ACCOUNT)
#define GFP_NOWAIT	(__GFP_KSWAPD_RECLAIM)
#define GFP_NOIO	(__GFP_RECLAIM)
#define GFP_NOFS	(__GFP_RECLAIM | __GFP_IO)
#define GFP_USER	(__GFP_RECLAIM | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
#define GFP_DMA		__GFP_DMA
#define GFP_DMA32	__GFP_DMA32
#define GFP_HIGHUSER	(GFP_USER | __GFP_HIGHMEM)
#define GFP_HIGHUSER_MOVABLE	(GFP_HIGHUSER | __GFP_MOVABLE | \
			 __GFP_SKIP_KASAN_POISON)
#define GFP_TRANSHUGE_LIGHT	((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
			 __GFP_NOMEMALLOC | __GFP_NOWARN) & ~__GFP_RECLAIM)
#define GFP_TRANSHUGE	(GFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM)

kcalloc

申请一个内存数组，这应该是方便指针的累进吧

/**
 * kcalloc - allocate memory for an array. The memory is set to zero.
 * @n: number of elements.
 * @size: element size.
 * @flags: the type of memory to allocate (see kmalloc).
 */
static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
{
	return kmalloc_array(n, size, flags | __GFP_ZERO);
}