drm/ttm/pool: Fix ttm_pool_alloc error path

From Thomas Hellstrom
d2151c5d9dbe3f8fec4cae5f4784edce3ced3a7e in linux-6.1.y/6.1.28
379989e7cbdc7aa7496a00ee286ec146c7599cf0 in mainline linux

diff --git a/sys/dev/pci/drm/ttm/ttm_pool.c b/sys/dev/pci/drm/ttm/ttm_pool.c
index 799112b..8ed9fe8 100644 (file)
--- a/sys/dev/pci/drm/ttm/ttm_pool.c
+++ b/sys/dev/pci/drm/ttm/ttm_pool.c
@@ -510,6 +510,43 @@ static int ttm_pool_page_allocated(struct ttm_pool *pool, unsigned int order,
        return 0;
 }
 
+/**
+ * ttm_pool_free_range() - Free a range of TTM pages
+ * @pool: The pool used for allocating.
+ * @tt: The struct ttm_tt holding the page pointers.
+ * @caching: The page caching mode used by the range.
+ * @start_page: index for first page to free.
+ * @end_page: index for last page to free + 1.
+ *
+ * During allocation the ttm_tt page-vector may be populated with ranges of
+ * pages with different attributes if allocation hit an error without being
+ * able to completely fulfill the allocation. This function can be used
+ * to free these individual ranges.
+ */
+static void ttm_pool_free_range(struct ttm_pool *pool, struct ttm_tt *tt,
+                               enum ttm_caching caching,
+                               pgoff_t start_page, pgoff_t end_page)
+{
+       struct vm_page **pages = tt->pages;
+       unsigned int order;
+       pgoff_t i, nr;
+
+       for (i = start_page; i < end_page; i += nr, pages += nr) {
+               struct ttm_pool_type *pt = NULL;
+
+               order = tt->orders[i];
+               nr = (1UL << order);
+               if (tt->dma_address)
+                       ttm_pool_unmap(pool, tt->dma_address[i], nr);
+
+               pt = ttm_pool_select_type(pool, caching, order);
+               if (pt)
+                       ttm_pool_type_give(pt, *pages);
+               else
+                       ttm_pool_free_page(pool, caching, order, *pages);
+       }
+}
+
 /**
  * ttm_pool_alloc - Fill a ttm_tt object
  *
@@ -525,15 +562,17 @@ static int ttm_pool_page_allocated(struct ttm_pool *pool, unsigned int order,
 int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt,
                   struct ttm_operation_ctx *ctx)
 {
-       unsigned long num_pages = tt->num_pages;
+       pgoff_t num_pages = tt->num_pages;
        dma_addr_t *dma_addr = tt->dma_address;
        struct vm_page **caching = tt->pages;
        struct vm_page **pages = tt->pages;
-       unsigned long *orders = tt->orders;
+       enum ttm_caching page_caching;
        gfp_t gfp_flags = GFP_USER;
-       unsigned int i, order;
+       pgoff_t caching_divide;
+       unsigned int order;
        struct vm_page *p;
        int r;
+       unsigned long *orders = tt->orders;
 
        WARN_ON(!num_pages || ttm_tt_is_populated(tt));
 #ifdef __linux__
@@ -556,6 +595,7 @@ int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt,
             order = min_t(unsigned int, order, __fls(num_pages))) {
                struct ttm_pool_type *pt;
 
+               page_caching = tt->caching;
                pt = ttm_pool_select_type(pool, tt->caching, order);
                p = pt ? ttm_pool_type_take(pt) : NULL;
                if (p) {
@@ -564,6 +604,7 @@ int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt,
                        if (r)
                                goto error_free_page;
 
+                       caching = pages;
                        do {
                                r = ttm_pool_page_allocated(pool, order, p,
                                                            &dma_addr,
@@ -572,14 +613,15 @@ int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt,
                                if (r)
                                        goto error_free_page;
 
+                               caching = pages;
                                if (num_pages < (1 << order))
                                        break;
 
                                p = ttm_pool_type_take(pt);
                        } while (p);
-                       caching = pages;
                }
 
+               page_caching = ttm_cached;
                while (num_pages >= (1 << order) &&
                       (p = ttm_pool_alloc_page(pool, gfp_flags, order, tt->dmat))) {
 
@@ -588,6 +630,7 @@ int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt,
                                                           tt->caching);
                                if (r)
                                        goto error_free_page;
+                               caching = pages;
                        }
                        r = ttm_pool_page_allocated(pool, order, p, &dma_addr,
                                                    &num_pages, &pages, &orders);
@@ -614,15 +657,13 @@ int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt,
        return 0;
 
 error_free_page:
-       ttm_pool_free_page(pool, tt->caching, order, p);
+       ttm_pool_free_page(pool, page_caching, order, p);
 
 error_free_all:
        num_pages = tt->num_pages - num_pages;
-       for (i = 0; i < num_pages; ) {
-               order = tt->orders[i];
-               ttm_pool_free_page(pool, tt->caching, order, tt->pages[i]);
-               i += 1 << order;
-       }
+       caching_divide = caching - tt->pages;
+       ttm_pool_free_range(pool, tt, tt->caching, 0, caching_divide);
+       ttm_pool_free_range(pool, tt, ttm_cached, caching_divide, num_pages);
 
        return r;
 }
@@ -638,26 +679,7 @@ EXPORT_SYMBOL(ttm_pool_alloc);
  */
 void ttm_pool_free(struct ttm_pool *pool, struct ttm_tt *tt)
 {
-       unsigned int i;
-
-       for (i = 0; i < tt->num_pages; ) {
-               unsigned int order, num_pages;
-               struct ttm_pool_type *pt;
-
-               order = tt->orders[i];
-               num_pages = 1ULL << order;
-               if (tt->dma_address)
-                       ttm_pool_unmap(pool, tt->dma_address[i], num_pages);
-
-               pt = ttm_pool_select_type(pool, tt->caching, order);
-               if (pt)
-                       ttm_pool_type_give(pt, tt->pages[i]);
-               else
-                       ttm_pool_free_page(pool, tt->caching, order,
-                                          tt->pages[i]);
-
-               i += num_pages;
-       }
+       ttm_pool_free_range(pool, tt, tt->caching, 0, tt->num_pages);
 
        while (atomic_long_read(&allocated_pages) > page_pool_size)
                ttm_pool_shrink();