Re: [PATCH v2] gpu/buddy: bail out of try_harder when alignment cannot be honoured

Fri, 03 Jul 2026 06:41:14 -0700 



On 7/3/2026 6:05 AM, John Olender wrote:

On 7/2/26 6:48 AM, Matthew Auld wrote:

On 29/06/2026 08:43, Arunpravin Paneer Selvam wrote:

The try_harder contiguous fallback could return a range whose start
offset did not match the caller's min_block_size. When a candidate's
start is misaligned, realign it: free the misaligned run and reallocate
exactly @size at the next lower min_block_size boundary. This keeps the
returned size unchanged with no surplus to trim, and rejects the request
only when no aligned candidate fits.

v2: align misaligned candidates down to min_block_size instead of
      bailing out, for both the RHS and LHS paths (Matthew).

Suggested-by: Christian König <[email protected]>
Fixes: 0a1844bf0b53 ("drm/buddy: Improve contiguous memory allocation")
Cc: Matthew Auld <[email protected]>
Cc: Christian König <[email protected]>
Cc: Timur Kristóf <[email protected]>
Cc: John Olender <[email protected]>
Cc: [email protected]
Signed-off-by: Arunpravin Paneer Selvam <[email protected]>

Reviewed-by: Matthew Auld <[email protected]>


I haven't hit any issues with this revision during testing.

Thanks for testing.

Regards,
Arun.


Thanks,
John


---
   drivers/gpu/buddy.c | 63 +++++++++++++++++++++++++++++++--------------
   1 file changed, 44 insertions(+), 19 deletions(-)

diff --git a/drivers/gpu/buddy.c b/drivers/gpu/buddy.c
index dc81fe0301ce..3c73ae87f3c5 100644
--- a/drivers/gpu/buddy.c
+++ b/drivers/gpu/buddy.c
@@ -1118,22 +1118,30 @@ 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,
+                    struct list_head *blocks)
+{
+    u64 aligned_offset = round_down(unaligned_offset, min_block_size);
+
+    return __gpu_buddy_alloc_range(mm, aligned_offset, size, NULL, blocks);
+}
+
   static int __alloc_contig_try_harder(struct gpu_buddy *mm,
                        u64 size,
                        u64 min_block_size,
                        struct list_head *blocks)
   {
-    u64 rhs_offset, lhs_offset, lhs_size, filled;
+    u64 rhs_offset, lhs_offset, filled;
       struct gpu_buddy_block *block;
       unsigned int tree, order;
-    LIST_HEAD(blocks_lhs);
-    unsigned long pages;
       u64 modify_size;
       int err;
         modify_size = rounddown_pow_of_two(size);
-    pages = modify_size >> ilog2(mm->chunk_size);
-    order = fls(pages) - 1;
+    order = ilog2(modify_size) - ilog2(mm->chunk_size);
       if (order == 0)
           return -ENOSPC;
   @@ -1149,31 +1157,48 @@ static int __alloc_contig_try_harder(struct 
gpu_buddy *mm,
           while (iter) {
               block = rbtree_get_free_block(iter);
   -            /* Allocate blocks traversing RHS */
               rhs_offset = gpu_buddy_block_offset(block);
+
+            /* Allocate blocks traversing RHS */
               err =  __gpu_buddy_alloc_range(mm, rhs_offset, size,
                                  &filled, blocks);
-            if (!err || err != -ENOSPC)
+            if (err && err != -ENOSPC)
                   return err;
+            if (!err && IS_ALIGNED(rhs_offset, min_block_size))
+                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,
+                                   blocks);
+                if (!err)
+                    return 0;
+                if (err != -ENOSPC) {
+                    gpu_buddy_free_list_internal(mm, blocks);
+                    return err;
+                }
+                goto next;
+            }
   -            lhs_size = max((size - filled), min_block_size);
-            if (!IS_ALIGNED(lhs_size, min_block_size))
-                lhs_size = round_up(lhs_size, min_block_size);
+            if (size - filled > rhs_offset)
+                goto next;
   -            /* Allocate blocks traversing LHS */
-            lhs_offset = gpu_buddy_block_offset(block) - lhs_size;
-            err =  __gpu_buddy_alloc_range(mm, lhs_offset, lhs_size,
-                               NULL, &blocks_lhs);
-            if (!err) {
-                list_splice(&blocks_lhs, blocks);
+            lhs_offset = rhs_offset - (size - filled);
+
+            /* 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, blocks);
+            if (!err)
                   return 0;
-            } else if (err != -ENOSPC) {
+            if (err != -ENOSPC) {
                   gpu_buddy_free_list_internal(mm, blocks);
                   return err;
               }
-            /* Free blocks for the next iteration */
+next:
               gpu_buddy_free_list_internal(mm, blocks);
-
               iter = rb_prev(iter);
           }
       }

base-commit: 6648301c5bb2ef23f0fb15bcb01d21ff66f36799
























					Reply via email to