本文共 7332 字，大约阅读时间需要 24 分钟。

/** * cma_alloc() - allocate pages from contiguous area * @cma:   Contiguous memory region for which the allocation is performed. * @count: Requested number of pages. * @align: Requested alignment of pages (in PAGE_SIZE order). * * This function allocates part of contiguous memory on specific * contiguous memory area. */struct page *cma_alloc(struct cma *cma, size_t count, unsigned int align){ 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;  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);  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;  }  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);   pfn = cma->base_pfn + (bitmap_no << cma->order_per_bit);  mutex_lock(&cma_mutex);  ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA);  mutex_unlock(&cma_mutex);  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);  pr_debug("%s(): returned %p\n", __func__, page); return page;}

/** * alloc_contig_range() -- tries to allocate given range of pages * @start: start PFN to allocate * @end: one-past-the-last PFN to allocate * @migratetype: migratetype of the underlaying pageblocks (either *   #MIGRATE_MOVABLE or #MIGRATE_CMA).  All pageblocks *   in range must have the same migratetype and it must *   be either of the two. * * The PFN range does not have to be pageblock or MAX_ORDER_NR_PAGES * aligned, however it's the caller's responsibility to guarantee that * we are the only thread that changes migrate type of pageblocks the * pages fall in. * * The PFN range must belong to a single zone. * * Returns zero on success or negative error code.  On success all * pages which PFN is in [start, end) are allocated for the caller and * need to be freed with free_contig_range(). */int alloc_contig_range(unsigned long start, unsigned long end,         unsigned migratetype){ unsigned long outer_start, outer_end; unsigned int order; int ret = 0;  struct compact_control cc = {  .nr_migratepages = 0,  .order = -1,  .zone = page_zone(pfn_to_page(start)),  .mode = MIGRATE_SYNC,  .ignore_skip_hint = true, }; INIT_LIST_HEAD(&cc.migratepages);  /*  * 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),           pfn_max_align_up(end), migratetype,           false); if (ret)  return ret;  /*  * In case of -EBUSY, we'd like to know which page causes problem.  * So, just fall through. We will check it in test_pages_isolated().  */ ret = __alloc_contig_migrate_range(&cc, start, end); if (ret && ret != -EBUSY)  goto done;  /*  * 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(); drain_all_pages(cc.zone);  order = 0; outer_start = start; while (!PageBuddy(pfn_to_page(outer_start))) {  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)) {  pr_info("%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); 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),    pfn_max_align_up(end), migratetype); return ret;}   释放CMA内存： /** * cma_release() - release allocated pages * @cma:   Contiguous memory region for which the allocation is performed. * @pages: Allocated pages. * @count: Number of allocated pages. * * This function releases memory allocated by alloc_cma(). * It returns false when provided pages do not belong to contiguous area and * true otherwise. */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);  free_contig_range(pfn, count); cma_clear_bitmap(cma, pfn, count); trace_cma_release(pfn, pages, count);  return true;}  

转载地址：http://jzhti.baihongyu.com/