Re: [PATCH v2] gpu/buddy: add range-restricted contiguous allocation fallback

[Matthew Auld <matthew.auld@intel.com>]

On 05/10/2026 15:14, Arunpravin Paneer Selvam wrote:
> 
> 
> On 10/1/2026 11:58 PM, Matthew Auld wrote:
>> On 30/09/2026 07:21, Arunpravin Paneer Selvam wrote:
>>> From: Arunpravin Paneer Selvam <Arunpravin.PaneerSelvam@amd.com>
>>>
>>> A range + contiguous allocation (e.g. a scanout FB confined to the
>>> CPU-visible VRAM aperture) rounds its size up to a power of two and
>>> requires a naturally aligned free block of that size; on a fragmented
>>> aperture no such aligned block may exist even though enough contiguous
>>> space is free, so the allocation fails with -ENOSPC.
>>>
>>> The non-range contiguous path already recovers from this via
>>> __alloc_contig_try_harder(), which stitches an exact-size span from
>>> smaller adjacent blocks, but that fallback was unreachable once
>>> GPU_BUDDY_RANGE_ALLOCATION was set. Give __alloc_contig_try_harder()
>>> a [range_start, range_end) window and route the range + contiguous
>>> case through it: each candidate placement is confined to the window
>>> and aligned to min_block_size. Non-range callers pass [0, mm->size),
>>> where the guards are no-ops, so the existing behaviour is unchanged.
>>> A KUnit regression test covers the fragmentation pattern.
>>>
>>> Resolves the igt@kms_plane@plane-panning-bottom-right@pipe-a/pipe-b
>>> regression.
>>>
>>> v2:
>>>   - Drop the split-undo patch; the range-bias search always descends to
>>>     an exact-order block or fails the split (already handled), so the
>>>     extra undo was redundant. (Matthew)
>>>   - Verified this fallback alone fixes the kms_plane regression.
>>>
>>> Fixes: 1ad5e807f716 ("gpu/buddy: replace dual-tree/force_merge with 
>>> decoupled dirty tracker")
>>
>> Patch looks more like totally new functionally/feature, so the fixes 
>> here is maybe unexpected? Did something in that fixes commit change 
>> something such that the try_harder is now needed, but that needs some 
>> expansion with bias + contig? Do we know exactly what changed here?
> That commit removed __force_merge(), which previously helped recover 
> larger contiguous allocations on demand. As a result, some range- 

__force_merge() got nuked, but IIRC I think that was essentially because 
we now "force merge" on free, so shouldn't we get the ~same result? Or 
is the fact that we force_merge() on every free giving a different 
layout of pages, and with some very some specific allocation pattern 
that difference subtly results in -ENOSPC, somehow?

> restricted contiguous allocation requests
> that used to succeed now fail with -ENOSPC (the kms_plane regression). 
> This patch restores that capability through the try_harder() stitching 
> logic, so the Fixes: tag reflects a
> regression introduced by that commit rather than new functionality.
>>
>>> Assisted-by: Claude:claude-opus-4-8
>>
>> Assisted-by: LLM
>>
>>> Cc: Matthew Auld <matthew.auld@intel.com>
>>> Cc: Christian König <christian.koenig@amd.com>
>>> Signed-off-by: Arunpravin Paneer Selvam 
>>> <Arunpravin.PaneerSelvam@amd.com>
>>> ---
>>>   drivers/gpu/buddy.c                | 88 ++++++++++++++++--------------
>>>   drivers/gpu/tests/gpu_buddy_test.c | 83 ++++++++++++++++++++++++++--
>>>   2 files changed, 126 insertions(+), 45 deletions(-)
>>>
>>> diff --git a/drivers/gpu/buddy.c b/drivers/gpu/buddy.c
>>> index 2f2aaadafe35..5265e1f6a318 100644
>>> --- a/drivers/gpu/buddy.c
>>> +++ b/drivers/gpu/buddy.c
>>> @@ -1685,26 +1685,14 @@ static int __gpu_buddy_alloc_range(struct 
>>> gpu_buddy *mm,
>>>                    blocks, total_allocated_on_err);
>>>   }
>>>   -static int __alloc_contig_aligned_retry(struct gpu_buddy *mm,
>>> -                    u64 unaligned_offset,
>>> -                    u64 size,
>>> -                    u64 min_block_size,
>>> -                    unsigned long flags,
>>> -                    struct list_head *blocks)
>>> -{
>>> -    u64 aligned_offset = round_down(unaligned_offset, min_block_size);
>>> -
>>> -    return __gpu_buddy_alloc_range(mm, aligned_offset, size, flags,
>>> -                       NULL, blocks);
>>> -}
>>> -
>>>   static int __alloc_contig_try_harder(struct gpu_buddy *mm,
>>> +                     u64 range_start, u64 range_end,
>>>                        u64 size,
>>>                        u64 min_block_size,
>>>                        unsigned long flags,
>>>                        struct list_head *blocks)
>>>   {
>>> -    u64 rhs_offset, lhs_offset, filled;
>>> +    u64 rhs_offset, lhs_offset, filled, aligned;
>>>       struct gpu_buddy_block *block;
>>>       struct rb_root *root;
>>>       struct rb_node *iter;
>>> @@ -1734,20 +1722,24 @@ static int __alloc_contig_try_harder(struct 
>>> gpu_buddy *mm,
>>>                              flags, &filled, blocks);
>>>           if (err && err != -ENOSPC)
>>>               return err;
>>> -        if (!err && IS_ALIGNED(rhs_offset, min_block_size))
>>> +        if (!err && IS_ALIGNED(rhs_offset, min_block_size) &&
>>> +            rhs_offset >= range_start && rhs_offset + size <= 
>>> range_end)
>>>               return 0;
>>>           if (!err) {
>>>               /* Allocate the unaligned RHS offset using round_down */
>>>               gpu_buddy_free_list_internal(mm, blocks);
>>> -            err = __alloc_contig_aligned_retry(mm, rhs_offset,
>>> -                               size,
>>> -                               min_block_size,
>>> -                               flags, blocks);
>>> -            if (!err)
>>> -                return 0;
>>> -            if (err != -ENOSPC) {
>>> -                gpu_buddy_free_list_internal(mm, blocks);
>>> -                return err;
>>> +
>>> +            aligned = round_down(rhs_offset, min_block_size);
>>> +            if (aligned >= range_start &&
>>> +                aligned + size <= range_end) {
>>> +                err = __gpu_buddy_alloc_range(mm, aligned, size,
>>> +                                  flags, NULL, blocks);
>>
>> Did you consider doing a bias-range for [start, end] using 
>> min_block_size and using what it returns as the starting point, 
>> extending left/right? If that fails advance start and try again? Maybe 
>> what you have here is much better for the case you have in mind?
> I took a closer look at the alloc_range_bias approach. My understanding 
> is that this would repeatedly bias within [start, end], use the returned 
> min_block_size block as a starting point, and then extend left/right to 
> build the requested run.
> While that should work, every failed attempt may require splitting 
> higher-order blocks to obtain a min_block_size block, followed by a 
> free/merge back when the extension fails.
> The free-tree descent evaluates the available starting points through a 
> tree walk without any splitting or allocation just for enumeration, so I 
> kept that approach.
> Please let me know if there is a case where alloc_range_bias would 
> provide an advantage over the free-tree descent.
> 
> While evaluating it, I found two issues in the current try_harder() 
> implementation:
> 
> 1. It only searches free_tree[size_order]. This is insufficient when 
> min_block_size < size. For example, for a 128 KiB allocation (order-5) 
> with min_block_size = 4 KiB, free_tree[5] may be empty
> while two adjacent order-4 (64 KiB) blocks covering [64 KiB, 128 KiB] 
> and [128 KiB, 192 KiB] are free. These blocks still form a valid 
> order-5-sized contiguous run, but they can never appear in
> free_tree[5] because they are not mergeable buddies. As a result, a 
> search that only considers free_tree[5] will never find this placement. 
> v3 addresses this by walking the free tree from the
> requested size order down to min_order, while reusing the existing 
> extend/stitch logic and min_block_size alignment checks unchanged.
> 
> 2. The search is not restricted to the requested range. v3 confines the 
> walk to [range_start, range_end], skipping candidates at or above 
> range_end and stopping once the walk falls below range_start.
> This ensures that range-constrained allocations only consider free 
> blocks within the requested window and avoids performing allocation/free 
> attempts on blocks outside the specified range.
> For non-range callers, the effective window remains [0, mm->size], so 
> the behavior is unchanged.
> 
> Regards,
> Arun.
>>
>>> +                if (!err)
>>> +                    return 0;
>>> +                if (err != -ENOSPC) {
>>> +                    gpu_buddy_free_list_internal(mm, blocks);
>>> +                    return err;
>>> +                }
>>>               }
>>>               goto next;
>>>           }
>>> @@ -1759,15 +1751,17 @@ static int __alloc_contig_try_harder(struct 
>>> gpu_buddy *mm,
>>>             /* Allocate the unaligned LHS offset using round_down */
>>>           gpu_buddy_free_list_internal(mm, blocks);
>>> -        err = __alloc_contig_aligned_retry(mm, lhs_offset,
>>> -                           size,
>>> -                           min_block_size,
>>> -                           flags, blocks);
>>> -        if (!err)
>>> -            return 0;
>>> -        if (err != -ENOSPC) {
>>> -            gpu_buddy_free_list_internal(mm, blocks);
>>> -            return err;
>>> +
>>> +        aligned = round_down(lhs_offset, min_block_size);
>>> +        if (aligned >= range_start && aligned + size <= range_end) {
>>> +            err = __gpu_buddy_alloc_range(mm, aligned, size,
>>> +                              flags, NULL, blocks);
>>> +            if (!err)
>>> +                return 0;
>>> +            if (err != -ENOSPC) {
>>> +                gpu_buddy_free_list_internal(mm, blocks);
>>> +                return err;
>>> +            }
>>>           }
>>>   next:
>>>           gpu_buddy_free_list_internal(mm, blocks);
>>> @@ -2021,11 +2015,18 @@ int gpu_buddy_alloc_blocks(struct gpu_buddy *mm,
>>>       min_order = ilog2(min_block_size) - ilog2(mm->chunk_size);
>>>         if (order > mm->max_order || size > mm->size) {
>>> -        if ((flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION) &&
>>> -            !(flags & GPU_BUDDY_RANGE_ALLOCATION))
>>> -            return __alloc_contig_try_harder(mm, original_size,
>>> +        if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION) {
>>> +            u64 range_start, range_end;
>>> +
>>> +            range_start = (flags & GPU_BUDDY_RANGE_ALLOCATION) ? 
>>> start : 0;
>>> +            range_end = (flags & GPU_BUDDY_RANGE_ALLOCATION) ? end : 
>>> mm->size;
>>> +
>>> +            return __alloc_contig_try_harder(mm, range_start,
>>> +                             range_end,
>>> +                             original_size,
>>>                                original_min_size,
>>>                                flags, blocks);
>>> +        }
>>>             return -EINVAL;
>>>       }
>>> @@ -2058,9 +2059,14 @@ int gpu_buddy_alloc_blocks(struct gpu_buddy *mm,
>>>                * Try contiguous block allocation through
>>>                * try harder method.
>>>                */
>>> -            if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION &&
>>> -                !(flags & GPU_BUDDY_RANGE_ALLOCATION)) {
>>> -                err = __alloc_contig_try_harder(mm,
>>> +            if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION) {
>>> +                u64 range_start, range_end;
>>> +
>>> +                range_start = (flags & GPU_BUDDY_RANGE_ALLOCATION) ? 
>>> start : 0;
>>> +                range_end = (flags & GPU_BUDDY_RANGE_ALLOCATION) ? 
>>> end : mm->size;
>>> +
>>> +                err = __alloc_contig_try_harder(mm, range_start,
>>> +                                range_end,
>>>                                   original_size,
>>>                                   original_min_size,
>>>                                   flags,
>>> @@ -2068,9 +2074,9 @@ int gpu_buddy_alloc_blocks(struct gpu_buddy *mm,
>>>                   if (!err)
>>>                       return 0;
>>>                   if (err != -ENOSPC)
>>> -                    return err;
>>> -                goto err_free;
>>> +                    goto err_free;
>>>               }
>>> +
>>>               err = -ENOSPC;
>>>               goto err_free;
>>>           } while (1);
>>> diff --git a/drivers/gpu/tests/gpu_buddy_test.c b/drivers/gpu/tests/ 
>>> gpu_buddy_test.c
>>> index b75d32ca6ca0..2c445870b808 100644
>>> --- a/drivers/gpu/tests/gpu_buddy_test.c
>>> +++ b/drivers/gpu/tests/gpu_buddy_test.c
>>> @@ -1251,6 +1251,77 @@ static void 
>>> gpu_test_buddy_alloc_contiguous(struct kunit *test)
>>>       gpu_buddy_fini(&mm);
>>>   }
>>>   +static void gpu_test_buddy_alloc_range_contiguous(struct kunit *test)
>>> +{
>>> +    const unsigned long ps = SZ_4K, mm_size = 16 * ps;
>>> +    const unsigned long range_end = 8 * ps;
>>> +    struct gpu_buddy_block *block, *prev;
>>> +    LIST_HEAD(allocated);
>>> +    struct gpu_buddy mm;
>>> +    LIST_HEAD(pin_lo);
>>> +    LIST_HEAD(pin_hi);
>>> +    u64 total;
>>> +
>>> +    KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps),
>>> +                   "buddy_init failed\n");
>>> +
>>> +    /*
>>> +     * Idea is to confine the test to the sub-range [0, 32K), which 
>>> a 12K
>>> +     * contiguous request (rounded up to 16K) splits into two naturally
>>> +     * aligned 16K slots: [0, 16K) and [16K, 32K). We pin the first 
>>> 4K page
>>> +     * of each slot ([0, 4K) and [16K, 20K)) so that neither aligned 
>>> slot
>>> +     * can satisfy the rounded-up 16K allocation, yet the freed 
>>> remainder
>>> +     * still leaves a contiguous 12K hole at offset 4K, which is 
>>> page-aligned
>>> +     * but not 16K-aligned. A 12K contiguous+range allocation must 
>>> therefore
>>> +     * fall back to stitching that span instead of returning -ENOSPC.
>>> +     */
>>> +    KUNIT_ASSERT_FALSE_MSG(test,
>>> +                   gpu_buddy_alloc_blocks(&mm, 0, ps, ps, ps,
>>> +                              &pin_lo, 0),
>>> +                   "failed to pin low page\n");
>>> +    KUNIT_ASSERT_FALSE_MSG(test,
>>> +                   gpu_buddy_alloc_blocks(&mm, 4 * ps, 5 * ps, ps,
>>> +                              ps, &pin_hi, 0),
>>> +                   "failed to pin high page\n");
>>> +
>>> +    /* No aligned 16K block is free; the range-aware fallback must 
>>> stitch
>>> +     * the unaligned [ps, 4*ps) hole instead of returning -ENOSPC.
>>> +     */
>>> +    KUNIT_ASSERT_FALSE_MSG(test,
>>> +                   gpu_buddy_alloc_blocks(&mm, 0, range_end, 3 * ps,
>>> +                              ps, &allocated,
>>> +                              GPU_BUDDY_CONTIGUOUS_ALLOCATION |
>>> +                              GPU_BUDDY_RANGE_ALLOCATION),
>>> +                   "range-restricted contiguous alloc failed\n");
>>> +
>>> +    /* The result must be exactly 3*ps, contiguous, and inside the 
>>> range. */
>>> +    total = 0;
>>> +    prev = NULL;
>>> +    list_for_each_entry(block, &allocated, link) {
>>> +        u64 offset = gpu_buddy_block_offset(block);
>>> +        u64 bsize = gpu_buddy_block_size(&mm, block);
>>> +
>>> +        KUNIT_EXPECT_TRUE_MSG(test, offset + bsize <= range_end,
>>> +                      "block [%llx, %llx) outside range\n",
>>> +                      offset, offset + bsize);
>>> +        if (prev)
>>> +            KUNIT_EXPECT_EQ_MSG(test,
>>> +                        gpu_buddy_block_offset(prev) +
>>> +                        gpu_buddy_block_size(&mm, prev),
>>> +                        offset,
>>> +                        "block at %llx not contiguous\n",
>>> +                        offset);
>>> +        prev = block;
>>> +        total += bsize;
>>> +    }
>>> +    KUNIT_EXPECT_EQ(test, total, 3 * ps);
>>> +
>>> +    gpu_buddy_free_list(&mm, &allocated, 0);
>>> +    gpu_buddy_free_list(&mm, &pin_lo, 0);
>>> +    gpu_buddy_free_list(&mm, &pin_hi, 0);
>>> +    gpu_buddy_fini(&mm);
>>> +}
>>> +
>>>   static void gpu_test_buddy_alloc_pathological(struct kunit *test)
>>>   {
>>>       u64 mm_size, size, start = 0;
>>> @@ -1534,10 +1605,13 @@ static void 
>>> gpu_test_buddy_alloc_exceeds_max_order(struct kunit *test)
>>>                        GPU_BUDDY_RANGE_ALLOCATION);
>>>       KUNIT_EXPECT_EQ(test, err, -EINVAL);
>>>   -    /* CONTIGUOUS + RANGE should return -EINVAL (no try_harder for 
>>> RANGE) */
>>> -    err = gpu_buddy_alloc_blocks(&mm, 0, mm_size, size, SZ_4K, &blocks,
>>> -                     GPU_BUDDY_CONTIGUOUS_ALLOCATION | 
>>> GPU_BUDDY_RANGE_ALLOCATION);
>>> -    KUNIT_EXPECT_EQ(test, err, -EINVAL);
>>> +    /* CONTIGUOUS + RANGE should succeed via the range-aware 
>>> try_harder */
>>> +    KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, 
>>> mm_size, size,
>>> +                                SZ_4K, &blocks,
>>> +                                GPU_BUDDY_CONTIGUOUS_ALLOCATION |
>>> +                                GPU_BUDDY_RANGE_ALLOCATION),
>>> +                   "range contiguous alloc hit an error 
>>> size=%llu\n", size);
>>> +    gpu_buddy_free_list(&mm, &blocks, 0);
>>>         gpu_buddy_fini(&mm);
>>>   }
>>> @@ -1603,6 +1677,7 @@ static struct kunit_case gpu_buddy_tests[] = {
>>>       KUNIT_CASE(gpu_test_buddy_alloc_pessimistic),
>>>       KUNIT_CASE(gpu_test_buddy_alloc_pathological),
>>>       KUNIT_CASE(gpu_test_buddy_alloc_contiguous),
>>> +    KUNIT_CASE(gpu_test_buddy_alloc_range_contiguous),
>>>       KUNIT_CASE(gpu_test_buddy_alloc_clear),
>>>       KUNIT_CASE(gpu_test_buddy_alloc_range),
>>>       KUNIT_CASE(gpu_test_buddy_alloc_range_bias),
>>>
>>> base-commit: 744f262401cc2e1f3827496c72a47e072d31a852
>>
>