Re: [PATCH RFC v3 08/35] mm: cma: Introduce cma_alloc_range()

Anshuman Khandual
2024-01-30T05:20:32Z

On 1/25/24 22:12, Alexandru Elisei wrote:
> Today, cma_alloc() is used to allocate a contiguous memory region. The
> function allows the caller to specify the number of pages to allocate, but
> not the starting address. cma_alloc() will walk over the entire CMA region
> trying to allocate the first available range of the specified size.
>
> Introduce cma_alloc_range(), which makes CMA more versatile by allowing the
> caller to specify a particular range in the CMA region, defined by the
> start pfn and the size.
>
> arm64 will make use of this function when tag storage management will be
> implemented: cma_alloc_range() will be used to reserve the tag storage
> associated with a tagged page.

Basically, you would like to pass on a preferred start address and the
allocation could just fail if a contig range is not available from such
a starting address ?

Then why not just change cma_alloc() to take a new argument 'start_pfn'.
Why create a new but almost similar allocator ?

But then I am wondering why this could not be done in the arm64 platform
code itself operating on a CMA area reserved just for tag storage. Unless
this new allocator has other usage beyond MTE, this could be implemented
in the platform itself.

>
> Signed-off-by: Alexandru Elisei <alexandru.elisei@arm.com>
> ---
>
> Changes since rfc v2:
>
> * New patch.
>
> include/linux/cma.h | 2 +
> include/trace/events/cma.h | 59 ++++++++++++++++++++++++++
> mm/cma.c | 86 ++++++++++++++++++++++++++++++++++++++
> 3 files changed, 147 insertions(+)
>
> diff --git a/include/linux/cma.h b/include/linux/cma.h
> index 63873b93deaa..e32559da6942 100644
> --- a/include/linux/cma.h
> +++ b/include/linux/cma.h
> @@ -50,6 +50,8 @@ extern int cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
> struct cma **res_cma);
> extern struct page *cma_alloc(struct cma *cma, unsigned long count, unsigned int align,
> bool no_warn);
> +extern int cma_alloc_range(struct cma *cma, unsigned long start, unsigned long count,
> + unsigned tries, gfp_t gfp);
> extern bool cma_pages_valid(struct cma *cma, const struct page *pages, unsigned long count);
> extern bool cma_release(struct cma *cma, const struct page *pages, unsigned long count);
>
> diff --git a/include/trace/events/cma.h b/include/trace/events/cma.h
> index 25103e67737c..a89af313a572 100644
> --- a/include/trace/events/cma.h
> +++ b/include/trace/events/cma.h
> @@ -36,6 +36,65 @@ TRACE_EVENT(cma_release,
> __entry->count)
> );
>
> +TRACE_EVENT(cma_alloc_range_start,
> +
> + TP_PROTO(const char *name, unsigned long start, unsigned long count,
> + unsigned tries),
> +
> + TP_ARGS(name, start, count, tries),
> +
> + TP_STRUCT__entry(
> + __string(name, name)
> + __field(unsigned long, start)
> + __field(unsigned long, count)
> + __field(unsigned, tries)
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, name);
> + __entry->start = start;
> + __entry->count = count;
> + __entry->tries = tries;
> + ),
> +
> + TP_printk("name=%s start=%lx count=%lu tries=%u",
> + __get_str(name),
> + __entry->start,
> + __entry->count,
> + __entry->tries)
> +);
> +
> +TRACE_EVENT(cma_alloc_range_finish,
> +
> + TP_PROTO(const char *name, unsigned long start, unsigned long count,
> + unsigned attempts, int err),
> +
> + TP_ARGS(name, start, count, attempts, err),
> +
> + TP_STRUCT__entry(
> + __string(name, name)
> + __field(unsigned long, start)
> + __field(unsigned long, count)
> + __field(unsigned, attempts)
> + __field(int, err)
> + ),
> +
> + TP_fast_assign(
> + __assign_str(name, name);
> + __entry->start = start;
> + __entry->count = count;
> + __entry->attempts = attempts;
> + __entry->err = err;
> + ),
> +
> + TP_printk("name=%s start=%lx count=%lu attempts=%u err=%d",
> + __get_str(name),
> + __entry->start,
> + __entry->count,
> + __entry->attempts,
> + __entry->err)
> +);
> +
> TRACE_EVENT(cma_alloc_start,
>
> TP_PROTO(const char *name, unsigned long count, unsigned int align),
> diff --git a/mm/cma.c b/mm/cma.c
> index 543bb6b3be8e..4a0f68b9443b 100644
> --- a/mm/cma.c
> +++ b/mm/cma.c
> @@ -416,6 +416,92 @@ static void cma_debug_show_areas(struct cma *cma)
> static inline void cma_debug_show_areas(struct cma *cma) { }
> #endif
>
> +/**
> + * cma_alloc_range() - allocate pages in a specific range
> + * @cma: Contiguous memory region for which the allocation is performed.
> + * @start: Starting pfn of the allocation.
> + * @count: Requested number of pages
> + * @tries: Number of tries if the range is busy
> + * @no_warn: Avoid printing message about failed allocation
> + *
> + * This function allocates part of contiguous memory from a specific contiguous
> + * memory area, from the specified starting address. The 'start' pfn and the the
> + * 'count' number of pages must be aligned to the CMA bitmap order per bit.
> + */
> +int cma_alloc_range(struct cma *cma, unsigned long start, unsigned long count,
> + unsigned tries, gfp_t gfp)
> +{
> + unsigned long bitmap_maxno, bitmap_no, bitmap_start, bitmap_count;
> + unsigned long i = 0;
> + struct page *page;
> + int err = -EINVAL;
> +
> + if (!cma || !cma->count || !cma->bitmap)
> + goto out_stats;
> +
> + trace_cma_alloc_range_start(cma->name, start, count, tries);
> +
> + if (!count || start < cma->base_pfn ||
> + start + count > cma->base_pfn + cma->count)
> + goto out_stats;
> +
> + if (!IS_ALIGNED(start | count, 1 << cma->order_per_bit))
> + goto out_stats;
> +
> + bitmap_start = (start - cma->base_pfn) >> cma->order_per_bit;
> + bitmap_maxno = cma_bitmap_maxno(cma);
> + bitmap_count = cma_bitmap_pages_to_bits(cma, count);
> +
> + spin_lock_irq(&cma->lock);
> + bitmap_no = bitmap_find_next_zero_area(cma->bitmap, bitmap_maxno,
> + bitmap_start, bitmap_count, 0);
> + if (bitmap_no != bitmap_start) {
> + spin_unlock_irq(&cma->lock);
> + err = -EEXIST;
> + goto out_stats;
> + }
> + bitmap_set(cma->bitmap, bitmap_start, bitmap_count);
> + spin_unlock_irq(&cma->lock);
> +
> + for (i = 0; i < tries; i++) {
> + mutex_lock(&cma_mutex);
> + err = alloc_contig_range(start, start + count, MIGRATE_CMA, gfp);
> + mutex_unlock(&cma_mutex);
> +
> + if (err != -EBUSY)
> + break;
> + }
> +
> + if (err) {
> + cma_clear_bitmap(cma, start, count);
> + } else {
> + page = pfn_to_page(start);
> +
> + /*
> + * CMA can allocate multiple page blocks, which results in
> + * different blocks being marked with different tags. Reset the
> + * tags to ignore those page blocks.
> + */
> + for (i = 0; i < count; i++)
> + page_kasan_tag_reset(nth_page(page, i));
> + }
> +
> +out_stats:
> + trace_cma_alloc_range_finish(cma->name, start, count, i, err);
> +
> + if (err) {
> + count_vm_events(CMA_ALLOC_FAIL, count);
> + if (cma)
> + cma_sysfs_account_fail_pages(cma, count);
> + } else {
> + count_vm_events(CMA_ALLOC_SUCCESS, count);
> + cma_sysfs_account_success_pages(cma, count);
> + }
> +
> + return err;
> +}
> +
> +
> /**
> * cma_alloc() - allocate pages from contiguous area
> * @cma: Contiguous memory region for which the allocation is performed.