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的百分比，或者最小值,最大值.

229 int __init cma_declare_contiguous(phys_addr_t base,

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 这个函数.