cma 源码分析
4 struct cma {
5 unsigned long base_pfn;6 unsigned long count;
7 unsigned long *bitmap;
8 unsigned int order_per_bit; /* Order of pages represented by one bit */
9 struct mutex lock;
10 #ifdef CONFIG_CMA_DEBUGFS
11 struct hlist_head mem_head;
12 spinlock_t mem_head_lock;
13 #endif
14 };
cma 用struct cma 来表示一个内存区域，可以同时support几个cma数组，
struct cma cma_areas[MAX_CMA_AREAS];MAX_CMA_AREAS 一般是在kernel的配置文件中指定.
arm_memblock_init->dma_contiguous_reserve->dma_contiguous_reserve_area->cma_declare_contiguous 来填充cma_area数组
但是原生的flow 只能提供一个cma。因此我们自己客制化的的时候一般会在arm_memblock_init里面调用几次dma_contiguous_reserve_area。来达到使用多个cma的目的.
其中
dma_contiguous_reserve 源码：
107 void __init dma_contiguous_reserve(phys_addr_t limit)
108 {
109 phys_addr_t selected_size = 0;
110 phys_addr_t selected_base = 0;
111 phys_addr_t selected_limit = limit;
112 bool fixed = false;
113
114 pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit);
115
116 if (size_cmdline != -1) {
117 selected_size = size_cmdline;
118 selected_base = base_cmdline;
119 selected_limit = min_not_zero(limit_cmdline, limit);
120 if (base_cmdline + size_cmdline == limit_cmdline)
121 fixed = true;
122 } else {
123 #ifdef CONFIG_CMA_SIZE_SEL_MBYTES
124 selected_size = size_bytes;
125 #elif defined(CONFIG_CMA_SIZE_SEL_PERCENTAGE)
126 selected_size = cma_early_percent_memory();
127 #elif defined(CONFIG_CMA_SIZE_SEL_MIN)
128 selected_size = min(size_bytes, cma_early_percent_memory());
129 #elif defined(CONFIG_CMA_SIZE_SEL_MAX)
130 selected_size = max(size_bytes, cma_early_percent_memory());
131 #endif
132 }
133
134 if (selected_size && !dma_contiguous_default_area) {
135 pr_debug("%s: reserving %ld MiB for global area\n", __func__,
136 (unsigned long)selected_size / SZ_1M);
137
138 dma_contiguous_reserve_area(selected_size, selected_base,
139 selected_limit,
140 &dma_contiguous_default_area,
141 fixed);
142 }
143 }
可以看到size 和 base 可以通过bootloader 传过来，也可以让kernel 自己reserved。其中kernel自己reserved的时候可以指定cma size 或者占用总memory的百分比，或者最小值,最大值.
230 phys_addr_t size, phys_addr_t limit,
231 phys_addr_t alignment, unsigned int order_per_bit,
232 bool fixed, struct cma **res_cma)
233 {
234 phys_addr_t memblock_end = memblock_end_of_DRAM();
235 phys_addr_t highmem_start;
236 int ret = 0;
237
238 #ifdef CONFIG_X86
239 /*
240 * high_memory isn't direct mapped memory so retrieving its physical
241 * address isn't appropriate. But it would be useful to check the
242 * physical address of the highmem boundary so it's justifiable to get
243 * the physical address from it. On x86 there is a validation check for
244 * this case, so the following workaround is needed to avoid it.
245 */
246 highmem_start = __pa_nodebug(high_memory);
247 #else
248 highmem_start = __pa(high_memory);
249 #endif
250 pr_debug("%s(size %pa, base %pa, limit %pa alignment %pa)\n",
251 __func__, &size, &base, &limit, &alignment);
252
253 if (cma_area_count == ARRAY_SIZE(cma_areas)) {
254 pr_err("Not enough slots for CMA reserved regions!\n");
255 return -ENOSPC;
256 }
257
258 if (!size)
259 return -EINVAL;
260
261 if (alignment && !is_power_of_2(alignment))
262 return -EINVAL;
263
264 /*
265 * Sanitise input arguments.
266 * Pages both ends in CMA area could be merged into adjacent unmovable
267 * migratetype page by page allocator's buddy algorithm. In the case,
268 * you couldn't get a contiguous memory, which is not what we want.
269 */
270 alignment = max(alignment, (phys_addr_t)PAGE_SIZE <<
271 max_t(unsigned long, MAX_ORDER - 1, pageblock_order));
272 base = ALIGN(base, alignment);
273 size = ALIGN(size, alignment);
274 limit &= ~(alignment - 1);
275
276 if (!base)
277 fixed = false;
278
279 /* size should be aligned with order_per_bit */
280 if (!IS_ALIGNED(size >> PAGE_SHIFT, 1 << order_per_bit))
281 return -EINVAL;
282
283 /*
284 * If allocating at a fixed base the request region must not cross the
285 * low/high memory boundary.
286 */
287 if (fixed && base < highmem_start && base + size > highmem_start) {
288 ret = -EINVAL;
289 pr_err("Region at %pa defined on low/high memory boundary (%pa)\n",
290 &base, &highmem_start);
291 goto err;
292 }
293
294 /*
295 * If the limit is unspecified or above the memblock end, its effective
296 * value will be the memblock end. Set it explicitly to simplify further
297 * checks.
298 */
299 if (limit == 0 || limit > memblock_end)
300 limit = memblock_end;
301
302 /* Reserve memory */
303 if (fixed) {
304 if (memblock_is_region_reserved(base, size) ||
305 memblock_reserve(base, size) < 0) {
306 ret = -EBUSY;
307 goto err;
308 }
309 } else {
310 phys_addr_t addr = 0;
311
312 /*
313 * All pages in the reserved area must come from the same zone.
314 * If the requested region crosses the low/high memory boundary,
315 * try allocating from high memory first and fall back to low
316 * memory in case of failure.
317 */
318 if (base < highmem_start && limit > highmem_start) {
319 addr = memblock_alloc_range(size, alignment,
320 highmem_start, limit,
321 MEMBLOCK_NONE);
322 limit = highmem_start;
323 }
324
325 if (!addr) {
326 addr = memblock_alloc_range(size, alignment, base,
327 limit,
328 MEMBLOCK_NONE);
329 if (!addr) {
330 ret = -ENOMEM;
331 goto err;
332 }
333 }
334
335 /*
336 * kmemleak scans/reads tracked objects for pointers to other
337 * objects but this address isn't mapped and accessible
338 */
339 kmemleak_ignore(phys_to_virt(addr));
340 base = addr;
341 }
342
343 ret = cma_init_reserved_mem(base, size, order_per_bit, res_cma);
344 if (ret)
345 goto err;
346
347 pr_info("Reserved %ld MiB at %pa\n", (unsigned long)size / SZ_1M,
348 &base);
349 return 0;
350
351 err:
352 pr_err("Failed to reserve %ld MiB\n", (unsigned long)size / SZ_1M);
353 return ret;
354 }
总重要是343行cma_init_reserved_mem来实际填充cma数组，200~203
169 int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
170 unsigned int order_per_bit,
171 struct cma **res_cma)
172 {
173 struct cma *cma;
174 phys_addr_t alignment;
175
176 /* Sanity checks */
177 if (cma_area_count == ARRAY_SIZE(cma_areas)) {
178 pr_err("Not enough slots for CMA reserved regions!\n");
179 return -ENOSPC;
180 }
181
182 if (!size || !memblock_is_region_reserved(base, size))
183 return -EINVAL;
184
185 /* ensure minimal alignment required by mm core */
186 alignment = PAGE_SIZE <<
187 max_t(unsigned long, MAX_ORDER - 1, pageblock_order);
188
189 /* alignment should be aligned with order_per_bit */
190 if (!IS_ALIGNED(alignment >> PAGE_SHIFT, 1 << order_per_bit))
191 return -EINVAL;
192
193 if (ALIGN(base, alignment) != base || ALIGN(size, alignment) != size)
194 return -EINVAL;
195
196 /*
197 * Each reserved area must be initialised later, when more kernel
198 * subsystems (like slab allocator) are available.
199 */
200 cma = &cma_areas[cma_area_count];
201 cma->base_pfn = PFN_DOWN(base);
202 cma->count = size >> PAGE_SHIFT;
203 cma->order_per_bit = order_per_bit;
204 *res_cma = cma;
205 cma_area_count++;
206 totalcma_pages += (size / PAGE_SIZE);
207
208 return 0;
209 }
kernel init的是时候会调用cma_init_reserved_areas，再调用cma_activate_area来实际激活这些内存区域其源码如下:
145 static int __init cma_init_reserved_areas(void)
146 {
147 int i;
148
149 for (i = 0; i < cma_area_count; i++) {
150 int ret = cma_activate_area(&cma_areas[i]);
151
152 if (ret)
153 return ret;
154 }
155
156 return 0;
157 }
158 core_initcall(cma_init_reserved_areas);
static int __init cma_activate_area(struct cma *cma)
98 {
99 int bitmap_size = BITS_TO_LONGS(cma_bitmap_maxno(cma)) * sizeof(long);
100 unsigned long base_pfn = cma->base_pfn, pfn = base_pfn;
101 unsigned i = cma->count >> pageblock_order;
102 struct zone *zone;
103
104 cma->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
105
106 if (!cma->bitmap)
107 return -ENOMEM;
108
109 WARN_ON_ONCE(!pfn_valid(pfn));
110 zone = page_zone(pfn_to_page(pfn));
111
112 do {
113 unsigned j;
114
115 base_pfn = pfn;
116 for (j = pageblock_nr_pages; j; --j, pfn++) {
117 WARN_ON_ONCE(!pfn_valid(pfn));
118 /*
119 * alloc_contig_range requires the pfn range
120 * specified to be in the same zone. Make this
121 * simple by forcing the entire CMA resv range
122 * to be in the same zone.
123 */
124 if (page_zone(pfn_to_page(pfn)) != zone)
125 goto err;
126 }
127 init_cma_reserved_pageblock(pfn_to_page(base_pfn));
128 } while (--i);
129
130 mutex_init(&cma->lock);
131
132 #ifdef CONFIG_CMA_DEBUGFS
133 INIT_HLIST_HEAD(&cma->mem_head);
134 spin_lock_init(&cma->mem_head_lock);
135 #endif
136
137 return 0;
138
139 err:
140 kfree(cma->bitmap);
141 cma->count = 0;
142 return -EINVAL;
143 }
继续调用init_cma_reserved_pageblock 来将这个page 设定成MIGRATE_CMA。
1570 #ifdef CONFIG_CMA
1571 /* Free whole pageblock and set its migration type to MIGRATE_CMA. */
1572 void __init init_cma_reserved_pageblock(struct page *page)
1573 {
1574 unsigned i = pageblock_nr_pages;
1575 struct page *p = page;
1576
1577 do {
1578 __ClearPageReserved(p);
1579 set_page_count(p, 0);
1580 } while (++p, --i);
1581
1582 set_pageblock_migratetype(page, MIGRATE_CMA);
1583
1584 if (pageblock_order >= MAX_ORDER) {
1585 i = pageblock_nr_pages;
1586 p = page;
1587 do {
1588 set_page_refcounted(p);
1589 __free_pages(p, MAX_ORDER - 1);
1590 p += MAX_ORDER_NR_PAGES;
1591 } while (i -= MAX_ORDER_NR_PAGES);
1592 } else {
1593 set_page_refcounted(page);
1594 __free_pages(page, pageblock_order);
1595 }
1596
1597 adjust_managed_page_count(page, pageblock_nr_pages);
1598 }
1599 #endif
cma的初始化到此为止，只要就是初始化cma_area 这个数据，并将这个数组表示的memory 设定为MIGRATE_CMA。这样当以后审定cma的时候，如果这部分memory 已经被占用，则将这部分memory 移除，从而空出memory 优先给cma使用.
使用的时候一般通过__dma_alloc_noncoherent ->__dma_alloc_coherent->dma_alloc_from_contiguous->cma_alloc 来申请。
365 struct page *cma_alloc(struct cma *cma, size_t count, unsigned int align)
366 {
367 unsigned long mask, offset;
368 unsigned long pfn = -1;
369 unsigned long start = 0;
370 unsigned long bitmap_maxno, bitmap_no, bitmap_count;
371 struct page *page = NULL;
372 int ret;
373
374 if (!cma || !cma->count)
375 return NULL;
376
377 pr_debug("%s(cma %p, count %zu, align %d)\n", __func__, (void *)cma,
378 count, align);
379
380 if (!count)
381 return NULL;
382
383 mask = cma_bitmap_aligned_mask(cma, align);
384 offset = cma_bitmap_aligned_offset(cma, align);
385 bitmap_maxno = cma_bitmap_maxno(cma);
386 bitmap_count = cma_bitmap_pages_to_bits(cma, count);
387
388 for (;;) {
389 mutex_lock(&cma->lock);
390 bitmap_no = bitmap_find_next_zero_area_off(cma->bitmap,
391 bitmap_maxno, start, bitmap_count, mask,
392 offset);
393 if (bitmap_no >= bitmap_maxno) {
394 mutex_unlock(&cma->lock);
395 break;
396 }
397 bitmap_set(cma->bitmap, bitmap_no, bitmap_count);
398 /*
399 * It's safe to drop the lock here. We've marked this region for
400 * our exclusive use. If the migration fails we will take the
401 * lock again and unmark it.
402 */
403 mutex_unlock(&cma->lock);
404
405 pfn = cma->base_pfn + (bitmap_no << cma->order_per_bit);
406 mutex_lock(&cma_mutex);
407 ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA);
408 mutex_unlock(&cma_mutex);
409 if (ret == 0) {
410 page = pfn_to_page(pfn);
411 break;
412 }
413
414 cma_clear_bitmap(cma, pfn, count);
415 if (ret != -EBUSY)
416 break;
417
418 pr_debug("%s(): memory range at %p is busy, retrying\n",
419 __func__, pfn_to_page(pfn));
420 /* try again with a bit different memory target */
421 start = bitmap_no + mask + 1;
422 }
423
424 trace_cma_alloc(pfn, page, count, align);
425
426 pr_debug("%s(): returned %p\n", __func__, page);
427 return page;
428 }
最重要的是407 行ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA);分配处于MIGRATE_CMA 类型下的pageblocks.
release 的case刚好和alloc相反，最终是调用到cma_release 这个函数.