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

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

On 09/10/2026 10:14, Arunpravin Paneer Selvam wrote:
> 
> 
> On 10/6/2026 3:27 PM, Matthew Auld wrote:
>> 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?
> You are right - merge-on-free reclaims contiguity just like the old on- 
> demand  __force_merge() , so that is not the cause and the layout is 
> effectively the same. The real change is where clear/dirty segregation 
> lives: it used to be an inline guard inside __alloc_range_bias() , but 
> the rework pulled it out into dirty_steer_window() , which only runs for 
> non-range allocations. So range (aperture) requests now go through 
> __alloc_range_bias()  with no clear/dirty guard at all - clear and dirty 
> allocations interleave and fragment the aperture until no large same- 
> class run survives for a 4K scanout pin (-> -ENOSPC). Restoring that 
> two-pass guard is the real fix.

Ahh, yeah that makes more sense now :)

> 
> I have accordingly moved the  Fixes:  tag onto that guard-restore patch, 
> and kept the range support in  __alloc_contig_try_harder() as a new 
> feature -  it still helps, but it is a safety-net fallback that should 
> land on top, not as the root-cause fix.
> 
> Regards,
> Arun.
>>
>>> 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
>>>>
>>>
>>
>