Skip to contentSkip to conversation

drm/sched: Fix teardown leaks with refcounting

RFC PATCH New Philipp Stanner 2 participants 2 messages Sep 3, 2024 – Sep 6, 2024

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/1 drm/sched: Fix teardown leaks with refcounting

The GPU scheduler currently does not ensure that its pending_list is empty before performing various other teardown tasks in drm_sched_fini().

If there are still jobs in the pending_list, this is problematic because after scheduler teardown, no one will call backend_ops.free_job() anymore. This would, consequently, result in memory leaks.

One way to solves this is to implement reference counting for struct drm_gpu_scheduler itself. Each job added to the pending_list takes a reference, each one removed drops a reference.

This approach would keep the scheduler running even after users have called drm_sched_fini(), and it would ultimately stop after the last job has been removed from pending_list.

Add reference counting to struct drm_gpu_scheduler. Move the teardown logic to __drm_sched_fini() and have drm_sched_fini() just also drop a reference.

---
Hi all,

since the scheduler has many stake holders, I want this solution discussed as an RFC first.

The advantage of this version would be that it does not block drm_sched_fini(), but the price paid for that is that the scheduler keeps running until all jobs are gone.

Cheers,
P.

---
 drivers/gpu/drm/scheduler/sched_main.c | 17 ++++++++++++++++-
 include/drm/gpu_scheduler.h            |  5 +++++
 2 files changed, 21 insertions(+), 1 deletion(-)
drivers/gpu/drm/scheduler/sched_main.c +16 -1
index 7e90c9f95611..62b453c8ed76 100644
@@ -99,6 +99,8 @@ int drm_sched_policy = DRM_SCHED_POLICY_FIFO;
 MODULE_PARM_DESC(sched_policy, "Specify the scheduling policy for entities on a run-queue, " __stringify(DRM_SCHED_POLICY_RR) " = Round Robin, " __stringify(DRM_SCHED_POLICY_FIFO) " = FIFO (default).");
 module_param_named(sched_policy, drm_sched_policy, int, 0444);
 
+static void __drm_sched_fini(struct kref *jobs_remaining);
+
 static u32 drm_sched_available_credits(struct drm_gpu_scheduler *sched)
 {
 	u32 credits;
@@ -540,6 +542,7 @@ static void drm_sched_job_begin(struct drm_sched_job *s_job)
 
 	spin_lock(&sched->job_list_lock);
 	list_add_tail(&s_job->list, &sched->pending_list);
+	kref_get(&sched->jobs_remaining);
 	drm_sched_start_timeout(sched);
 	spin_unlock(&sched->job_list_lock);
 }
@@ -564,6 +567,7 @@ static void drm_sched_job_timedout(struct work_struct *work)
 		 * is parked at which point it's safe.
 		 */
 		list_del_init(&job->list);
+		kref_put(&sched->jobs_remaining, __drm_sched_fini);
 		spin_unlock(&sched->job_list_lock);
 
 		status = job->sched->ops->timedout_job(job);
@@ -637,6 +641,7 @@ void drm_sched_stop(struct drm_gpu_scheduler *sched, struct drm_sched_job *bad)
 			 */
 			spin_lock(&sched->job_list_lock);
 			list_del_init(&s_job->list);
+			kref_put(&sched->jobs_remaining, __drm_sched_fini);
 			spin_unlock(&sched->job_list_lock);
 
 			/*
@@ -1084,6 +1089,7 @@ drm_sched_get_finished_job(struct drm_gpu_scheduler *sched)
 	if (job && dma_fence_is_signaled(&job->s_fence->finished)) {
 		/* remove job from pending_list */
 		list_del_init(&job->list);
+		kref_put(&sched->jobs_remaining, __drm_sched_fini);
 
 		/* cancel this job's TO timer */
 		cancel_delayed_work(&sched->work_tdr);
@@ -1303,6 +1309,7 @@ int drm_sched_init(struct drm_gpu_scheduler *sched,
 	init_waitqueue_head(&sched->job_scheduled);
 	INIT_LIST_HEAD(&sched->pending_list);
 	spin_lock_init(&sched->job_list_lock);
+	kref_init(&sched->jobs_remaining);
 	atomic_set(&sched->credit_count, 0);
 	INIT_DELAYED_WORK(&sched->work_tdr, drm_sched_job_timedout);
 	INIT_WORK(&sched->work_run_job, drm_sched_run_job_work);
@@ -1334,11 +1341,14 @@ EXPORT_SYMBOL(drm_sched_init);
  *
  * Tears down and cleans up the scheduler.
  */
-void drm_sched_fini(struct drm_gpu_scheduler *sched)
+static void __drm_sched_fini(struct kref *jobs_remaining)
 {
+	struct drm_gpu_scheduler *sched;
 	struct drm_sched_entity *s_entity;
 	int i;
 
+	sched = container_of(jobs_remaining, struct drm_gpu_scheduler, jobs_remaining);
+
 	drm_sched_wqueue_stop(sched);
 
 	for (i = DRM_SCHED_PRIORITY_KERNEL; i < sched->num_rqs; i++) {
@@ -1368,6 +1378,11 @@ void drm_sched_fini(struct drm_gpu_scheduler *sched)
 	kfree(sched->sched_rq);
 	sched->sched_rq = NULL;
 }
+
+void drm_sched_fini(struct drm_gpu_scheduler *sched)
+{
+	kref_put(&sched->jobs_remaining, __drm_sched_fini);
+}
 EXPORT_SYMBOL(drm_sched_fini);
 
 /**
include/drm/gpu_scheduler.h +5 -0
index 5acc64954a88..b7fad8294861 100644
@@ -29,6 +29,7 @@
 #include <linux/completion.h>
 #include <linux/xarray.h>
 #include <linux/workqueue.h>
+#include <linux/kref.h>
 
 #define MAX_WAIT_SCHED_ENTITY_Q_EMPTY msecs_to_jiffies(1000)
 
@@ -495,6 +496,9 @@ struct drm_sched_backend_ops {
  *                 waits on this wait queue until all the scheduled jobs are
  *                 finished.
  * @job_id_count: used to assign unique id to the each job.
+ * @jobs_remaining: submitted jobs take a refcount of the scheduler to prevent it
+ *		    from terminating before the last job has been removed from
+ *		    @pending_list.
  * @submit_wq: workqueue used to queue @work_run_job and @work_free_job
  * @timeout_wq: workqueue used to queue @work_tdr
  * @work_run_job: work which calls run_job op of each scheduler.
@@ -525,6 +529,7 @@ struct drm_gpu_scheduler {
 	struct drm_sched_rq             **sched_rq;
 	wait_queue_head_t		job_scheduled;
 	atomic64_t			job_id_count;
+	struct kref			jobs_remaining;
 	struct workqueue_struct		*submit_wq;
 	struct workqueue_struct		*timeout_wq;
 	struct work_struct		work_run_job;
Signature · 1 line
2.46.0
#1 lore raw
kernel test robot noticed the following build warnings:

Hi Philipp,

[This is a private test report for your RFC patch.] kernel test robot noticed the following build warnings:

[auto build test WARNING on drm-misc/drm-misc-next]
[also build test WARNING on linus/master v6.11-rc6 next-20240906] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Philipp-Stanner/drm-sched-Fix-teardown-leaks-with-refcounting/20240903-174759
base:   git://anongit.freedesktop.org/drm/drm-misc drm-misc-next
patch link:    https://lore.kernel.org/r/20240903094531.29893-2-pstanner%40redhat.com
patch subject: [RFC PATCH] drm/sched: Fix teardown leaks with refcounting
config: i386-buildonly-randconfig-001-20240906 (https://download.01.org/0day-ci/archive/20240906/[email protected]/config)
compiler: clang version 18.1.5 (https://github.com/llvm/llvm-project 617a15a9eac96088ae5e9134248d8236e34b91b1)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240906/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All warnings (new ones prefixed by >>):

drivers/gpu/drm/scheduler/sched_main.c:407: warning: Function parameter or struct member 'result' not described in 'drm_sched_job_done'

>> drivers/gpu/drm/scheduler/sched_main.c:1336: warning: Function parameter or struct member 'jobs_remaining' not described in '__drm_sched_fini'
>> drivers/gpu/drm/scheduler/sched_main.c:1336: warning: expecting prototype for drm_sched_fini(). Prototype was for __drm_sched_fini() instead

vim +1336 drivers/gpu/drm/scheduler/sched_main.c

f49565982194d6 drivers/gpu/drm/amd/scheduler/gpu_scheduler.c Christian König 2015-08-20 1327

a72ce6f84109c1 drivers/gpu/drm/amd/scheduler/gpu_scheduler.c Jammy Zhou        2015-05-22  1328  /**
2d33948e4e00b5 drivers/gpu/drm/scheduler/gpu_scheduler.c     Nayan Deshmukh    2018-05-29  1329   * drm_sched_fini - Destroy a gpu scheduler
2d33948e4e00b5 drivers/gpu/drm/scheduler/gpu_scheduler.c     Nayan Deshmukh    2018-05-29  1330   *
2d33948e4e00b5 drivers/gpu/drm/scheduler/gpu_scheduler.c     Nayan Deshmukh    2018-05-29  1331   * @sched: scheduler instance
a72ce6f84109c1 drivers/gpu/drm/amd/scheduler/gpu_scheduler.c Jammy Zhou        2015-05-22  1332   *
2d33948e4e00b5 drivers/gpu/drm/scheduler/gpu_scheduler.c     Nayan Deshmukh    2018-05-29  1333   * Tears down and cleans up the scheduler.
a72ce6f84109c1 drivers/gpu/drm/amd/scheduler/gpu_scheduler.c Jammy Zhou        2015-05-22  1334   */
8f9b35110d847d drivers/gpu/drm/scheduler/sched_main.c        Philipp Stanner   2024-09-03  1335  static void __drm_sched_fini(struct kref *jobs_remaining)
a72ce6f84109c1 drivers/gpu/drm/amd/scheduler/gpu_scheduler.c Jammy Zhou        2015-05-22 @1336  {
8f9b35110d847d drivers/gpu/drm/scheduler/sched_main.c        Philipp Stanner   2024-09-03  1337  	struct drm_gpu_scheduler *sched;
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1338  	struct drm_sched_entity *s_entity;
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1339  	int i;
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1340  
8f9b35110d847d drivers/gpu/drm/scheduler/sched_main.c        Philipp Stanner   2024-09-03  1341  	sched = container_of(jobs_remaining, struct drm_gpu_scheduler, jobs_remaining);
8f9b35110d847d drivers/gpu/drm/scheduler/sched_main.c        Philipp Stanner   2024-09-03  1342  
a6149f03936993 drivers/gpu/drm/scheduler/sched_main.c        Matthew Brost     2023-10-30  1343  	drm_sched_wqueue_stop(sched);
faf6e1a87e0742 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2018-10-18  1344  
38f922a563aac3 drivers/gpu/drm/scheduler/sched_main.c        Luben Tuikov      2023-11-22  1345  	for (i = DRM_SCHED_PRIORITY_KERNEL; i < sched->num_rqs; i++) {
56e449603f0ac5 drivers/gpu/drm/scheduler/sched_main.c        Luben Tuikov      2023-10-14  1346  		struct drm_sched_rq *rq = sched->sched_rq[i];
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1347  
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1348  		spin_lock(&rq->lock);
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1349  		list_for_each_entry(s_entity, &rq->entities, list)
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1350  			/*
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1351  			 * Prevents reinsertion and marks job_queue as idle,
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1352  			 * it will removed from rq in drm_sched_entity_fini
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1353  			 * eventually
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1354  			 */
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1355  			s_entity->stopped = true;
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1356  		spin_unlock(&rq->lock);
56e449603f0ac5 drivers/gpu/drm/scheduler/sched_main.c        Luben Tuikov      2023-10-14  1357  		kfree(sched->sched_rq[i]);
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1358  	}
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1359  
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1360  	/* Wakeup everyone stuck in drm_sched_entity_flush for this scheduler */
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1361  	wake_up_all(&sched->job_scheduled);
c61cdbdbffc169 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-05-12  1362  
e582951baabba3 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-01-18  1363  	/* Confirm no work left behind accessing device structures */
e582951baabba3 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-01-18  1364  	cancel_delayed_work_sync(&sched->work_tdr);
e582951baabba3 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2021-01-18  1365  
a6149f03936993 drivers/gpu/drm/scheduler/sched_main.c        Matthew Brost     2023-10-30  1366  	if (sched->own_submit_wq)
a6149f03936993 drivers/gpu/drm/scheduler/sched_main.c        Matthew Brost     2023-10-30  1367  		destroy_workqueue(sched->submit_wq);
faf6e1a87e0742 drivers/gpu/drm/scheduler/sched_main.c        Andrey Grodzovsky 2018-10-18  1368  	sched->ready = false;
56e449603f0ac5 drivers/gpu/drm/scheduler/sched_main.c        Luben Tuikov      2023-10-14  1369  	kfree(sched->sched_rq);
56e449603f0ac5 drivers/gpu/drm/scheduler/sched_main.c        Luben Tuikov      2023-10-14  1370  	sched->sched_rq = NULL;
a72ce6f84109c1 drivers/gpu/drm/amd/scheduler/gpu_scheduler.c Jammy Zhou        2015-05-22  1371  }
8f9b35110d847d drivers/gpu/drm/scheduler/sched_main.c        Philipp Stanner   2024-09-03  1372  
Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki