Bug: ttm_pool_mgr_init() does not check ttm_pool_type_init() return
value and does not free pool if returns error.

Fix: Move up shrinker_alloc(), check ttm_pool_type_init() return and free
pool types and shrinker if non-zero and return error.

Assisted-by: OpenCode:1.17.18-Big Pickle/DeepSeek V4 Flash
Assisted-by: claude.ai:Sonnet 5
Cc: <[email protected]> # 7.1.0
Fixes: 444e2a19d7fd ("ttm/pool: port to list_lru. (v2)")
Signed-off-by: Óscar Megía López <[email protected]>
---
 drivers/gpu/drm/ttm/ttm_pool.c | 100 ++++++++++++++++++++++++++++++---
 1 file changed, 92 insertions(+), 8 deletions(-)

diff --git a/drivers/gpu/drm/ttm/ttm_pool.c b/drivers/gpu/drm/ttm/ttm_pool.c
index 87c843f52736..74d8770f41d8 100644
--- a/drivers/gpu/drm/ttm/ttm_pool.c
+++ b/drivers/gpu/drm/ttm/ttm_pool.c
@@ -1421,6 +1421,54 @@ static inline u64 ttm_get_node_memory_size(int nid)
        return managed_pages * PAGE_SIZE;
 }
 
+static void ttm_pool_type_fini_and_list_lru_destroy(unsigned int nr)
+{
+       unsigned int i;
+
+       if (nr == 0)
+               return;
+
+       for (i = 0; i < nr; ++i) {
+               ttm_pool_type_fini(&global_write_combined[i]);
+               ttm_pool_type_fini(&global_uncached[i]);
+               ttm_pool_type_fini(&global_dma32_write_combined[i]);
+               ttm_pool_type_fini(&global_dma32_uncached[i]);
+       }
+
+       /* We removed the pool types from the LRU, but we need to also make sure
+        * that no shrinker is concurrently freeing pages from the pool.
+        */
+       ttm_pool_synchronize_shrinkers();
+
+       for (i = 0; i < nr; ++i) {
+               list_lru_destroy(&global_write_combined[i].pages);
+               list_lru_destroy(&global_uncached[i].pages);
+               list_lru_destroy(&global_dma32_write_combined[i].pages);
+               list_lru_destroy(&global_dma32_uncached[i].pages);
+       }
+
+}
+
+static void ttm_pool_type_fini_and_list_lru_destroy_partial(
+                               struct ttm_pool_type *types[], unsigned int n)
+{
+       unsigned int k;
+
+       if (n == 0)
+               return;
+
+       for (k = 0; k < n; ++k)
+               ttm_pool_type_fini(types[k]);
+
+       /* We removed the pool types from the LRU, but we need to also make sure
+        * that no shrinker is concurrently freeing pages from the pool.
+        */
+       ttm_pool_synchronize_shrinkers();
+
+       for (k = 0; k < n; ++k)
+               list_lru_destroy(&types[k]->pages);
+}
+
 /**
  * ttm_pool_mgr_init - Initialize globals
  *
@@ -1431,6 +1479,8 @@ static inline u64 ttm_get_node_memory_size(int nid)
 int ttm_pool_mgr_init(unsigned long num_pages)
 {
        unsigned int i;
+       int ret = 0;
+       struct ttm_pool_type *types_free[3];
 
        int nid;
        for_each_node(nid) {
@@ -1445,15 +1495,53 @@ int ttm_pool_mgr_init(unsigned long num_pages)
        spin_lock_init(&shrinker_lock);
        INIT_LIST_HEAD(&shrinker_list);
 
+       mm_shrinker = shrinker_alloc(SHRINKER_NUMA_AWARE, "drm-ttm_pool");
+       if (!mm_shrinker)
+               return -ENOMEM;
+
        for (i = 0; i < NR_PAGE_ORDERS; ++i) {
-               ttm_pool_type_init(&global_write_combined[i], NULL,
+               ret = ttm_pool_type_init(&global_write_combined[i], NULL,
                                   ttm_write_combined, i);
-               ttm_pool_type_init(&global_uncached[i], NULL, ttm_uncached, i);
+               if (ret) {
+                       ttm_pool_type_fini_and_list_lru_destroy(i);
+                       shrinker_free(mm_shrinker);
+                       return ret;
+               }
+
+               ret = ttm_pool_type_init(&global_uncached[i], NULL, 
ttm_uncached, i);
+               if (ret) {
+                       types_free[0] = &global_write_combined[i];
+                       
ttm_pool_type_fini_and_list_lru_destroy_partial(types_free, 1);
 
-               ttm_pool_type_init(&global_dma32_write_combined[i], NULL,
+                       ttm_pool_type_fini_and_list_lru_destroy(i);
+                       shrinker_free(mm_shrinker);
+                       return ret;
+               }
+
+               ret = ttm_pool_type_init(&global_dma32_write_combined[i], NULL,
                                   ttm_write_combined, i);
-               ttm_pool_type_init(&global_dma32_uncached[i], NULL,
+               if (ret) {
+                       types_free[0] = &global_write_combined[i];
+                       types_free[1] = &global_uncached[i];
+                       
ttm_pool_type_fini_and_list_lru_destroy_partial(types_free, 2);
+
+                       ttm_pool_type_fini_and_list_lru_destroy(i);
+                       shrinker_free(mm_shrinker);
+                       return ret;
+               }
+
+               ret = ttm_pool_type_init(&global_dma32_uncached[i], NULL,
                                   ttm_uncached, i);
+               if (ret) {
+                       types_free[0] = &global_write_combined[i];
+                       types_free[1] = &global_uncached[i];
+                       types_free[2] = &global_dma32_write_combined[i];
+                       
ttm_pool_type_fini_and_list_lru_destroy_partial(types_free, 3);
+
+                       ttm_pool_type_fini_and_list_lru_destroy(i);
+                       shrinker_free(mm_shrinker);
+                       return ret;
+               }
        }
 
 #ifdef CONFIG_DEBUG_FS
@@ -1467,10 +1555,6 @@ int ttm_pool_mgr_init(unsigned long num_pages)
 #endif
 #endif
 
-       mm_shrinker = shrinker_alloc(SHRINKER_NUMA_AWARE, "drm-ttm_pool");
-       if (!mm_shrinker)
-               return -ENOMEM;
-
        mm_shrinker->count_objects = ttm_pool_shrinker_count;
        mm_shrinker->scan_objects = ttm_pool_shrinker_scan;
        mm_shrinker->batch = TTM_SHRINKER_BATCH;
-- 
2.55.0

Reply via email to