【内存管理】CMA内存分配器（Contiguous Memory Allocator）

什么是CMA

参考这两篇博文，写得很好：

http://www.wowotech.net/memory_management/cma.html

https://www.cnblogs.com/LoyenWang/p/12182594.html

CMA的初始化创建

* 默认cma创建（dma_contiguous_default_area），两种方式：

1. 通过cmdline传递的参数"cma="，然后在kernel初始化阶段解析参数，并调用start_kernel()->setup_arch()->arm64_memblock_init()->dma_contiguous_reserve()完成创建（android中一般不通过cmdline传递）：

static phys_addr_t size_cmdline = -1;
static phys_addr_t base_cmdline;
static phys_addr_t limit_cmdline;
//解析cmdline传递的cma参数
static int __init early_cma(char *p)
{
	pr_debug("%s(%s)\n", __func__, p);
	size_cmdline = memparse(p, &p);
	if (*p != '@')
		return 0;
	base_cmdline = memparse(p + 1, &p);
	if (*p != '-') {
		limit_cmdline = base_cmdline + size_cmdline;
		return 0;
	}
	limit_cmdline = memparse(p + 1, &p);

	return 0;
}
early_param("cma", early_cma);

1. 通过dts中配置cma节点，属性中包含"shared-dma-pool"以及"linux,cma-default"，在kernel初始化阶段，通过调用start_kernel()->setup_arch()->arm64_memblock_init()->early_init_fdt_scan_reserved_mem()->fdt_init_reserved_mem()->__reserved_mem_init_node()完成对默认cma的创建和初始化：

static int __init __reserved_mem_init_node(struct reserved_mem *rmem)
{
	extern const struct of_device_id __reservedmem_of_table[];
	const struct of_device_id *i;
	//__reservedmem_of_table是初始化中的一个section段，通过RESERVEDMEM_OF_DECLARE定义的都会被链接到这个段中
	//参考：https://blog.csdn.net/rikeyone/article/details/79975138
	for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) {
		reservedmem_of_init_fn initfn = i->data;
		const char *compat = i->compatible;

		if (!of_flat_dt_is_compatible(rmem->fdt_node, compat))
			continue;

		if (initfn(rmem) == 0) {
			pr_info("initialized node %s, compatible id %s\n",
				rmem->name, compat);
			return 0;
		}
	}
	return -ENOENT;
}

//dma-contiguous.c文件中定义了该默认cma的创建回调。
//如果dts中没有配置，那该回调也不会执行。
//参考：https://blog.csdn.net/rikeyone/article/details/79975138
RESERVEDMEM_OF_DECLARE(cma, "shared-dma-pool", rmem_cma_setup);

1. 默认cma似乎在好些android平台上都没有创建。

*其他CMA区创建

• 其他CMA区域创建都应该类似默认cma一样，通过RESERVEDMEM_OF_DECLARE接口定义一个结构体变量在__reservedmem_of_table段中，开机启动时就会调用对应的initfn完成初始化，同时还需要在dts中配置对应的属性节点。

• 所有CMA的创建最终都会调用cma_init_reserved_mem()函数：

  1. 主要从cma全局数组cma_areas中分配一个cma实体并将传递过来的参数用于初始化该cam实体。
  2. 初始化参数包括，cma的name、起始页框号base_pfn，总共页数count，以及每个bit代表多少个页2^(order_per_bit)。
  3. 更新全局变量totalcma_pages，记录总的cma页面数量，在meminfo中CmaTotal就是这个值。

int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
				 unsigned int order_per_bit,
				 const char *name,
				 struct cma **res_cma)
{
	struct cma *cma;
	phys_addr_t alignment;

	/* Sanity checks */
    //判断cma数量是否已经满了，因为cma_areas数组指定了系统中总的cma数量，通过内核宏控制
	if (cma_area_count == ARRAY_SIZE(cma_areas)) {
		pr_err("Not enough slots for CMA reserved regions!\n");
		return -ENOSPC;
	}
    //判断该cma内存区间是否与reversed中的某个区间是交叉的？为什么要这样判断？
	if (!size || !memblock_is_region_reserved(base, size))
		return -EINVAL;

	/* ensure minimal alignment required by mm core */
    //对齐方式按pageblock，也就是1024页（4M）
	alignment = PAGE_SIZE <<
			max_t(unsigned long, MAX_ORDER - 1, pageblock_order);

	/* alignment should be aligned with order_per_bit */
    //判断对齐方式alignment本身的大小与单个bit表示的内存大小，是否对齐
	if (!IS_ALIGNED(alignment >> PAGE_SHIFT, 1 << order_per_bit))
		return -EINVAL;
    //判断base和size以aligment方式对齐后，得到的值是否还是原来的值，也就是判断base和size是否基于alignment对齐
	if (ALIGN(base, alignment) != base || ALIGN(size, alignment) != size)
		return -EINVAL;

	/*
	 * Each reserved area must be initialised later, when more kernel
	 * subsystems (like slab allocator) are available.
	 */
	 //1. memblock是系统最初的内存管理器，分为memory type和reserved type，CMA最开始就属于reserved type
	 //2. 运行到这里，就表示memblock已经建立，并且buddy还没建立，CMA在buddy前建立OK
	 //3. CMA建立OK后，接着memblock中的memory type会释放给buddy，reserved type则不会
	 //4. CMA作为特殊的reserved type，最终通过系统初始化调用cma_init_reserved_areas，将内存归还给buddy

    //从cma_areas数组中分配一个cma对象
	cma = &cma_areas[cma_area_count];
	if (name) {
		cma->name = name;
	} else {
		cma->name = kasprintf(GFP_KERNEL, "cma%d\n", cma_area_count);
		if (!cma->name)
			return -ENOMEM;
	}

	cma->base_pfn = PFN_DOWN(base); //起始页号
	cma->count = size >> PAGE_SHIFT; //总共页面数
	cma->order_per_bit = order_per_bit; //一个bit代表的阶数
	*res_cma = cma;
	cma_area_count++;
	totalcma_pages += (size / PAGE_SIZE); //totalcma_pages记录总的cma页面数量，在meminfo中CmaTotal就是这个值

	return 0;
}

到这里，只是完成对cma内存的保留和初始化，cma区最终还需要释放给buddy。

CMA区域释放给buddy

• 释放也是在kernel初始化过程中，会比cma的创建稍晚一些，是通过cma_init_reserved_areas接口完成的所有cma的初始化并将内存返还给buddy。

  • core_initcall(cma_init_reserved_areas)定义在kernel的init段中，通过start_kernel()->rest_init()创建内核线程kernel_init->kernel_init_freeable()->do_basic_setup()->do_initcalls()完成对各个init level的初始化。core init属于level1。

• cma_init_reserved_areas()函数，遍历当前cma全局数组中已经分配的cma实体，通过调用cma_activate_area函数完成激活初始化，同时将内存释放给buddy：

static int __init cma_init_reserved_areas(void)
{
	int i;

	for (i = 0; i < cma_area_count; i++) {
		int ret = cma_activate_area(&cma_areas[i]);

		if (ret)
			return ret;
	}

	return 0;
}
core_initcall(cma_init_reserved_areas);

• cma_activate_area()函数：
  
  以pageblock为单位，设置migrate type为MIGRATE_CMA，然后将其整个pageblock包含的页全部释放给buddy，并更新整个系统的可用内存总数

static int __init cma_activate_area(struct cma *cma)
{
	int bitmap_size = BITS_TO_LONGS(cma_bitmap_maxno(cma)) * sizeof(long);
	unsigned long base_pfn = cma->base_pfn, pfn = base_pfn;
    //i代表有多少个page block，一般一个pageblock是1024页
	unsigned i = cma->count >> pageblock_order;
	struct zone *zone;

    //cma也是通过bitmap来管理，每个bit代表多大，由order_per_bit决定。
    //默认的cma的order_per_bit为0，一个bit代表2^0个page。
    //分配bitmap
	cma->bitmap = kzalloc(bitmap_size, GFP_KERNEL);

	if (!cma->bitmap)
		return -ENOMEM;

	WARN_ON_ONCE(!pfn_valid(pfn));
	zone = page_zone(pfn_to_page(pfn));

    //以pageblock遍历，
	do {
		unsigned j;

        //记录当前pageblock的起始页
		base_pfn = pfn;
        //判断当前pageblock中的所有页面是否满足要求：合法的页号、都在同一个zone中
		for (j = pageblock_nr_pages; j; --j, pfn++) {
			WARN_ON_ONCE(!pfn_valid(pfn));
			/*
			 * alloc_contig_range requires the pfn range
			 * specified to be in the same zone. Make this
			 * simple by forcing the entire CMA resv range
			 * to be in the same zone.
			 */
			if (page_zone(pfn_to_page(pfn)) != zone)
				goto not_in_zone;
		}
        //将当前pageblock初始化并释放给buddy
		init_cma_reserved_pageblock(pfn_to_page(base_pfn));
	} while (--i);

	mutex_init(&cma->lock);

#ifdef CONFIG_CMA_DEBUGFS
	INIT_HLIST_HEAD(&cma->mem_head);
	spin_lock_init(&cma->mem_head_lock);
#endif

	return 0;

not_in_zone:
	pr_err("CMA area %s could not be activated\n", cma->name);
	kfree(cma->bitmap);
	cma->count = 0;
	return -EINVAL;
}

• cma_activate_area()->init_cma_reserved_pageblock()函数设置pageblock类型并释放内存给buddy：

void __init init_cma_reserved_pageblock(struct page *page)
{
	unsigned i = pageblock_nr_pages;
	struct page *p = page;

	do {
        //清除页描述flag中的PG_Reserved标志位
		__ClearPageReserved(p);
        //设置page->_refcount = 0
		set_page_count(p, 0);
	} while (++p, --i);
    //设置pageblock的迁移类型为MIGRATE_CMA
	set_pageblock_migratetype(page, MIGRATE_CMA);

	if (pageblock_order >= MAX_ORDER) {
		i = pageblock_nr_pages;
		p = page;
		do {
			set_page_refcounted(p);
			__free_pages(p, MAX_ORDER - 1);
			p += MAX_ORDER_NR_PAGES;
		} while (i -= MAX_ORDER_NR_PAGES);
	} else {
        //设置page->_refcount = 1
		set_page_refcounted(page);
        //释放pages到buddy中，以pageblock释放，order为10
		__free_pages(page, pageblock_order);
	}
    //调整对应zone中的managed_pages可管理页面数，即加上一个pageblock数量
    //调整总的内存数量totalram_pages，即加上一个pageblock数量
	adjust_managed_page_count(page, pageblock_nr_pages);
}

CMA的分配

• CMA分配通过统一接口cma_alloc函数，会从bitmap中先查找满足要求的连续bit，然后通过alloc_contig_range实现分配，成功后的页面会从buddy总摘出来：

struct page *cma_alloc(struct cma *cma, size_t count, unsigned int align,
		       gfp_t gfp_mask)
{
	unsigned long mask, offset;
	unsigned long pfn = -1;
	unsigned long start = 0;
	unsigned long bitmap_maxno, bitmap_no, bitmap_count;
	struct page *page = NULL;
	int ret = -ENOMEM;

	if (!cma || !cma->count)
		return NULL;

	pr_debug("%s(cma %p, count %zu, align %d)\n", __func__, (void *)cma,
		 count, align);

	if (!count)
		return NULL;

	mask = cma_bitmap_aligned_mask(cma, align);
	offset = cma_bitmap_aligned_offset(cma, align);
	bitmap_maxno = cma_bitmap_maxno(cma);
	bitmap_count = cma_bitmap_pages_to_bits(cma, count);

	if (bitmap_count > bitmap_maxno)
		return NULL;

	for (;;) {
		mutex_lock(&cma->lock);
        //1. 从cma->bitmap中查找连续bitmap_count个为0的bit
		bitmap_no = bitmap_find_next_zero_area_off(cma->bitmap,
				bitmap_maxno, start, bitmap_count, mask,
				offset);
		if (bitmap_no >= bitmap_maxno) {
			mutex_unlock(&cma->lock);
			break;
		}
        //2. 将查找到的连续bit设置为1，表示内存被分配占用
		bitmap_set(cma->bitmap, bitmap_no, bitmap_count);
		/*
		 * It's safe to drop the lock here. We've marked this region for
		 * our exclusive use. If the migration fails we will take the
		 * lock again and unmark it.
		 */
		mutex_unlock(&cma->lock);
        //3. 计算分配的起始页的页号
		pfn = cma->base_pfn + (bitmap_no << cma->order_per_bit);
		mutex_lock(&cma_mutex);
        //4. 分配从起始页开始的连续count个页，分配的migrate type为CMA类型
		ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA,
					 gfp_mask);
		mutex_unlock(&cma_mutex);
        //5. 分配成功，就返回起始page
		if (ret == 0) {
			page = pfn_to_page(pfn);
			break;
		}

		cma_clear_bitmap(cma, pfn, count);
		if (ret != -EBUSY)
			break;

		pr_debug("%s(): memory range at %p is busy, retrying\n",
			 __func__, pfn_to_page(pfn));
		/* try again with a bit different memory target */
		start = bitmap_no + mask + 1;
	}

	trace_cma_alloc(pfn, page, count, align);

	if (ret && !(gfp_mask & __GFP_NOWARN)) {
		pr_info("%s: alloc failed, req-size: %zu pages, ret: %d\n",
			__func__, count, ret);
		cma_debug_show_areas(cma);
	}

	pr_debug("%s(): returned %p\n", __func__, page);
	return page;
}

CMA的释放

• 释放操作也很清晰，通过cma_release函数实现，会将页面释放回buddy系统，并将cma的bitmap相应bit清零：

bool cma_release(struct cma *cma, const struct page *pages, unsigned int count)
{
	unsigned long pfn;

	if (!cma || !pages)
		return false;

	pr_debug("%s(page %p)\n", __func__, (void *)pages);

	pfn = page_to_pfn(pages);

	if (pfn < cma->base_pfn || pfn >= cma->base_pfn + cma->count)
		return false;

	VM_BUG_ON(pfn + count > cma->base_pfn + cma->count);
	//释放回buddy
	free_contig_range(pfn, count);
	//清零bit位，表示对应cma内存可用
	cma_clear_bitmap(cma, pfn, count);
	trace_cma_release(pfn, pages, count);

	return true;
}

CMA与buddy

后续补充