LInux内核——CMA

struct cma {
    //起始物理地址对应的页帧号，相当于起始地址
    unsigned long   base_pfn;
    //当前CMA区域页的个数，也就内存总容量，页的默认大小4K
    unsigned long   count;
    //使用bitmap机制维护当前CMA区域内存的物理页，每个bit代表一定数量的物理页，至于代表多少物理页与order_per_bit有关
    unsigned long   *bitmap;
    //指明该CMA区域的bitmap中，每个bit代表的页数量为2^order值
    unsigned int order_per_bit; /* Order of pages represented by one bit */
    struct mutex    lock;
#ifdef CONFIG_CMA_DEBUGFS
    struct hlist_head mem_head;
    spinlock_t mem_head_lock;
#endif
    //当前CMA区域的描述名
    const char *name;
};

//存放各个CMA区域的cma信息的数组
extern struct cma cma_areas[MAX_CMA_AREAS];
//统计当前系统初始化的最大可用的cma区域数量
extern unsigned cma_area_count;

int __init cma_declare_contiguous(phys_addr_t base,
            phys_addr_t size, phys_addr_t limit,
            phys_addr_t alignment, unsigned int order_per_bit,
            bool fixed, const char *name, struct cma **res_cma)
{
  ...
  pr_info("Reserved %ld MiB at %pa\n", (unsigned long)size / SZ_1M,
    &base);
  return 0
}

void __init dma_contiguous_reserve(phys_addr_t limit)
{
    ...
    } else {
#ifdef CONFIG_CMA_SIZE_SEL_MBYTES
        selected_size = size_bytes;
#elif defined(CONFIG_CMA_SIZE_SEL_PERCENTAGE)
        selected_size = cma_early_percent_memory();
#elif defined(CONFIG_CMA_SIZE_SEL_MIN)
        selected_size = min(size_bytes, cma_early_percent_memory());
#elif defined(CONFIG_CMA_SIZE_SEL_MAX)
        selected_size = max(size_bytes, cma_early_percent_memory());
#endif
    }

    if (selected_size && !dma_contiguous_default_area) {
        pr_debug("%s: reserving %ld MiB for global area\n", __func__,
             (unsigned long)selected_size / SZ_1M);

        dma_contiguous_reserve_area(selected_size, selected_base,
                        selected_limit,
                        &dma_contiguous_default_area,
                        fixed);
    }
}

#ifdef CONFIG_CMA_SIZE_MBYTES
#define CMA_SIZE_MBYTES CONFIG_CMA_SIZE_MBYTES
#else
#define CMA_SIZE_MBYTES 0
#endif

/*
 * Default global CMA area size can be defined in kernel's .config.
 * This is useful mainly for distro maintainers to create a kernel
 * that works correctly for most supported systems.
 * The size can be set in bytes or as a percentage of the total memory
 * in the system.
 *
 * Users, who want to set the size of global CMA area for their system
 * should use cma= kernel parameter.
 */
static const phys_addr_t size_bytes = (phys_addr_t)CMA_SIZE_MBYTES * SZ_1M;

struct cma cma_areas[MAX_CMA_AREAS];
unsigned cma_area_count;

//MAX_CMA_AREAS定义：

/*
 * There is always at least global CMA area and a few optional
 * areas configured in kernel .config.
 */
#ifdef CONFIG_CMA_AREAS
#define MAX_CMA_AREAS   (1 + CONFIG_CMA_AREAS)

/**
 * cma_init_reserved_mem() - create custom contiguous area from reserved memory
 * @base: Base address of the reserved area
 * @size: Size of the reserved area (in bytes),
 * @order_per_bit: Order of pages represented by one bit on bitmap.
 * @name: The name of the area. If this parameter is NULL, the name of
 *        the area will be set to "cmaN", where N is a running counter of
 *        used areas.
 * @res_cma: Pointer to store the created cma region.
 *
 * This function creates custom contiguous area from already reserved memory.
 */
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)
{
  ...
  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;
  *res_cma = cma;
  cma_area_count++;
  totalcma_pages += (size / PAGE_SIZE);

  return 0;
}

int alloc_contig_range(unsigned long start, unsigned long end,
               unsigned migratetype, gfp_t gfp_mask)
{
	...
	/*
	 * What we do here is we mark all pageblocks in range as
	 * MIGRATE_ISOLATE.  Because pageblock and max order pages may
	 * have different sizes, and due to the way page allocator
	 * work, we align the range to biggest of the two pages so
	 * that page allocator won't try to merge buddies from
	 * different pageblocks and change MIGRATE_ISOLATE to some
	 * other migration type.
	 *
	 * Once the pageblocks are marked as MIGRATE_ISOLATE, we
	 * migrate the pages from an unaligned range (ie. pages that
	 * we are interested in).  This will put all the pages in
	 * range back to page allocator as MIGRATE_ISOLATE.
	 *
	 * When this is done, we take the pages in range from page
	 * allocator removing them from the buddy system.  This way
	 * page allocator will never consider using them.
	 *
	 * This lets us mark the pageblocks back as
	 * MIGRATE_CMA/MIGRATE_MOVABLE so that free pages in the
	 * aligned range but not in the unaligned, original range are
	 * put back to page allocator so that buddy can use them.
	 */

	ret = start_isolate_page_range(pfn_max_align_down(start),           -----<1>
	                   pfn_max_align_up(end), migratetype, 0);
	if (ret < 0)
	    return ret;

	/*
	 * In case of -EBUSY, we'd like to know which page causes problem.
	 * So, just fall through. test_pages_isolated() has a tracepoint
	 * which will report the busy page.
	 *
	 * It is possible that busy pages could become available before
	 * the call to test_pages_isolated, and the range will actually be
	 * allocated.  So, if we fall through be sure to clear ret so that
	 * -EBUSY is not accidentally used or returned to caller.
	 */
	ret = __alloc_contig_migrate_range(&cc, start, end);                 -----<2>
	if (ret && ret != -EBUSY)
	    goto done;
	ret =0;

	/*
	 * Pages from [start, end) are within a MAX_ORDER_NR_PAGES
	 * aligned blocks that are marked as MIGRATE_ISOLATE.  What's
	 * more, all pages in [start, end) are free in page allocator.
	 * What we are going to do is to allocate all pages from
	 * [start, end) (that is remove them from page allocator).
	 *
	 * The only problem is that pages at the beginning and at the
	 * end of interesting range may be not aligned with pages that
	 * page allocator holds, ie. they can be part of higher order
	 * pages.  Because of this, we reserve the bigger range and
	 * once this is done free the pages we are not interested in.
	 *
	 * We don't have to hold zone->lock here because the pages are
	 * isolated thus they won't get removed from buddy.
	 */

	lru_add_drain_all();                                                -----<3>

	order = 0;
	outer_start = start;
	while (!PageBuddy(pfn_to_page(outer_start))) {                      -----<4>
	    if (++order >= MAX_ORDER) {
	        outer_start = start;
	        break;
	    }
	    outer_start &= ~0UL << order;
	}

	if (outer_start != start) {
	    order = page_order(pfn_to_page(outer_start));

	    /*
	     * outer_start page could be small order buddy page and
	     * it doesn't include start page. Adjust outer_start
	     * in this case to report failed page properly
	     * on tracepoint in test_pages_isolated()
	     */
	    if (outer_start + (1UL << order) <= start)
	        outer_start = start;
	}

	/* Make sure the range is really isolated. */
	if (test_pages_isolated(outer_start, end, false)) {                 -----<5>
	    pr_info_ratelimited("%s: [%lx, %lx) PFNs busy\n",
	        __func__, outer_start, end);
	    ret = -EBUSY;
	    goto done;
	}

	/* Grab isolated pages from freelists. */
	outer_end = isolate_freepages_range(&cc, outer_start, end);         -----<6>
	if (!outer_end) {
	    ret = -EBUSY;
	    goto done;
	}

	/* Free head and tail (if any) */
	if (start != outer_start)
	    free_contig_range(outer_start, start - outer_start);
	if (end != outer_end)
	    free_contig_range(end, outer_end - end);

done:
    undo_isolate_page_range(pfn_max_align_down(start),                -----<7>
                pfn_max_align_up(end), migratetype);
    return ret;
}