[PATCH 1/2] drm/sched: Fix drm_sched_entity_flush() return val

[PATCH 1/2] drm/sched: Fix drm_sched_entity_flush() return val

[Philipp Stanner]

The documentation of drm_sched_entity_flush() states that the function
shall - always - return the remaining timeout time in jiffies.

However, that is not what the function actually does; in one of its if
branches it simply returns the unchanged timeout value.

Furthermore, the used function wait_event_timeout() doesn't always
return the remaining timeout time.

Adjust the function so that it actually does what the documentation
states it shall do.

Cc: Christian König <christian.koenig@amd.com>
Signed-off-by: Philipp Stanner <pstanner@redhat.com>
---
@AMD:
You guys are the only ones who use the function's return code, so I
leave it completely up to you to decide what behavior you want.

But we should at least do something, because right now function
documentation and behavior do not match.

P.
---
 drivers/gpu/drm/scheduler/sched_entity.c | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c
index a75eede8bf8d..16b172aee453 100644
--- a/drivers/gpu/drm/scheduler/sched_entity.c
+++ b/drivers/gpu/drm/scheduler/sched_entity.c
@@ -278,7 +278,7 @@ static void drm_sched_entity_kill(struct drm_sched_entity *entity)
  * waiting, removes the entity from the runqueue and returns an error when the
  * process was killed.
  *
- * Returns the remaining time in jiffies left from the input timeout
+ * Returns: 0 if the timeout ellapsed, the remaining time otherwise.
  */
 long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
 {
@@ -294,15 +294,24 @@ long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
 	 * The client will not queue more IBs during this fini, consume existing
 	 * queued IBs or discard them on SIGKILL
 	 */
-	if (current->flags & PF_EXITING) {
-		if (timeout)
-			ret = wait_event_timeout(
-					sched->job_scheduled,
-					drm_sched_entity_is_idle(entity),
-					timeout);
+	if (timeout != 0 && (current->flags & PF_EXITING)) {
+		ret = wait_event_timeout(sched->job_scheduled,
+				drm_sched_entity_is_idle(entity),
+				timeout);
+		/*
+		 * wait_event_timeout() returns 1 if it timed out but the
+		 * condition became true on timeout. We only care about whether
+		 * it timed out or not.
+		 */
+		if (ret == 1)
+			ret = 0;
 	} else {
 		wait_event_killable(sched->job_scheduled,
 				    drm_sched_entity_is_idle(entity));
+
+		ret -= (long)get_jiffies_64();
+		if (ret < 0)
+			ret = 0;
 	}
 
 	/* For killed process disable any more IBs enqueue right now */
-- 
2.47.0

[PATCH 2/2] drm/sched: Fix docu of drm_sched_entity_flush()

[Philipp Stanner]

drm_sched_entity_flush()'s documentation states that an error is being
returned when "the process was killed". That is not what the function
actually does.

Furthermore, it contains an inprecise statement about how the function
is part of a convenience wrapper.

Move that statement to drm_sched_entity_destroy().

Correct drm_sched_entity_flush()'s documentation.

Cc: Christian König <christian.koenig@amd.com>
Signed-off-by: Philipp Stanner <pstanner@redhat.com>
---
 drivers/gpu/drm/scheduler/sched_entity.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c
index 16b172aee453..7af7b448ad06 100644
--- a/drivers/gpu/drm/scheduler/sched_entity.c
+++ b/drivers/gpu/drm/scheduler/sched_entity.c
@@ -270,15 +270,12 @@ static void drm_sched_entity_kill(struct drm_sched_entity *entity)
 
 /**
  * drm_sched_entity_flush - Flush a context entity
- *
  * @entity: scheduler entity
- * @timeout: time to wait in for Q to become empty in jiffies.
- *
- * Splitting drm_sched_entity_fini() into two functions, The first one does the
- * waiting, removes the entity from the runqueue and returns an error when the
- * process was killed.
+ * @timeout: time to wait in jiffies
  *
  * Returns: 0 if the timeout ellapsed, the remaining time otherwise.
+
+ * Waits at most @timeout jiffies for the entity's job queue to become empty.
  */
 long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
 {
@@ -290,7 +287,7 @@ long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
 		return 0;
 
 	sched = entity->rq->sched;
-	/**
+	/*
 	 * The client will not queue more IBs during this fini, consume existing
 	 * queued IBs or discard them on SIGKILL
 	 */
@@ -359,8 +356,11 @@ EXPORT_SYMBOL(drm_sched_entity_fini);
  * drm_sched_entity_destroy - Destroy a context entity
  * @entity: scheduler entity
  *
- * Calls drm_sched_entity_flush() and drm_sched_entity_fini() as a
- * convenience wrapper.
+ * Convenience wrapper for entity teardown.
+ *
+ * Teardown of entities is split into two functions. The first one,
+ * drm_sched_entity_flush(), waits for the entity to become empty. The second
+ * one, drm_sched_entity_fini(), does the actual cleanup of the entity object.
  */
 void drm_sched_entity_destroy(struct drm_sched_entity *entity)
 {
-- 
2.47.0

Re: [PATCH 2/2] drm/sched: Fix docu of drm_sched_entity_flush()

[Christian König]

Am 19.11.24 um 14:41 schrieb Philipp Stanner:
> drm_sched_entity_flush()'s documentation states that an error is being
> returned when "the process was killed". That is not what the function
> actually does.
>
> Furthermore, it contains an inprecise statement about how the function
> is part of a convenience wrapper.
>
> Move that statement to drm_sched_entity_destroy().
>
> Correct drm_sched_entity_flush()'s documentation.
>
> Cc: Christian König <christian.koenig@amd.com>
> Signed-off-by: Philipp Stanner <pstanner@redhat.com>
> ---
>   drivers/gpu/drm/scheduler/sched_entity.c | 18 +++++++++---------
>   1 file changed, 9 insertions(+), 9 deletions(-)
>
> diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c
> index 16b172aee453..7af7b448ad06 100644
> --- a/drivers/gpu/drm/scheduler/sched_entity.c
> +++ b/drivers/gpu/drm/scheduler/sched_entity.c
> @@ -270,15 +270,12 @@ static void drm_sched_entity_kill(struct drm_sched_entity *entity)
>   
>   /**
>    * drm_sched_entity_flush - Flush a context entity
> - *
>    * @entity: scheduler entity
> - * @timeout: time to wait in for Q to become empty in jiffies.
> - *
> - * Splitting drm_sched_entity_fini() into two functions, The first one does the
> - * waiting, removes the entity from the runqueue and returns an error when the
> - * process was killed.
> + * @timeout: time to wait in jiffies
>    *
>    * Returns: 0 if the timeout ellapsed, the remaining time otherwise.
> +
> + * Waits at most @timeout jiffies for the entity's job queue to become empty.
>    */
>   long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
>   {
> @@ -290,7 +287,7 @@ long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
>   		return 0;
>   
>   	sched = entity->rq->sched;
> -	/**
> +	/*
>   	 * The client will not queue more IBs during this fini, consume existing
>   	 * queued IBs or discard them on SIGKILL

That comment is actually not correct either.

drm_sched_entity_flush() should be used from the file_operations->flush 
function and that one can be used even without destroying the entity.

So it is perfectly possible that more and more IBs are pumped into the 
entity while we wait for it to become idle.

Regards,
Christian.

>   	 */
> @@ -359,8 +356,11 @@ EXPORT_SYMBOL(drm_sched_entity_fini);
>    * drm_sched_entity_destroy - Destroy a context entity
>    * @entity: scheduler entity
>    *
> - * Calls drm_sched_entity_flush() and drm_sched_entity_fini() as a
> - * convenience wrapper.
> + * Convenience wrapper for entity teardown.
> + *
> + * Teardown of entities is split into two functions. The first one,
> + * drm_sched_entity_flush(), waits for the entity to become empty. The second
> + * one, drm_sched_entity_fini(), does the actual cleanup of the entity object.
>    */
>   void drm_sched_entity_destroy(struct drm_sched_entity *entity)
>   {

Re: [PATCH 2/2] drm/sched: Fix docu of drm_sched_entity_flush()

[Philipp Stanner]

On Tue, 2024-11-19 at 15:27 +0100, Christian König wrote:
> Am 19.11.24 um 14:41 schrieb Philipp Stanner:
> > drm_sched_entity_flush()'s documentation states that an error is
> > being
> > returned when "the process was killed". That is not what the
> > function
> > actually does.
> > 
> > Furthermore, it contains an inprecise statement about how the
> > function
> > is part of a convenience wrapper.
> > 
> > Move that statement to drm_sched_entity_destroy().
> > 
> > Correct drm_sched_entity_flush()'s documentation.
> > 
> > Cc: Christian König <christian.koenig@amd.com>
> > Signed-off-by: Philipp Stanner <pstanner@redhat.com>
> > ---
> >   drivers/gpu/drm/scheduler/sched_entity.c | 18 +++++++++---------
> >   1 file changed, 9 insertions(+), 9 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/scheduler/sched_entity.c
> > b/drivers/gpu/drm/scheduler/sched_entity.c
> > index 16b172aee453..7af7b448ad06 100644
> > --- a/drivers/gpu/drm/scheduler/sched_entity.c
> > +++ b/drivers/gpu/drm/scheduler/sched_entity.c
> > @@ -270,15 +270,12 @@ static void drm_sched_entity_kill(struct
> > drm_sched_entity *entity)
> >   
> >   /**
> >    * drm_sched_entity_flush - Flush a context entity
> > - *
> >    * @entity: scheduler entity
> > - * @timeout: time to wait in for Q to become empty in jiffies.
> > - *
> > - * Splitting drm_sched_entity_fini() into two functions, The first
> > one does the
> > - * waiting, removes the entity from the runqueue and returns an
> > error when the
> > - * process was killed.
> > + * @timeout: time to wait in jiffies
> >    *
> >    * Returns: 0 if the timeout ellapsed, the remaining time
> > otherwise.
> > +
> > + * Waits at most @timeout jiffies for the entity's job queue to
> > become empty.
> >    */
> >   long drm_sched_entity_flush(struct drm_sched_entity *entity, long
> > timeout)
> >   {
> > @@ -290,7 +287,7 @@ long drm_sched_entity_flush(struct
> > drm_sched_entity *entity, long timeout)
> >   		return 0;
> >   
> >   	sched = entity->rq->sched;
> > -	/**
> > +	/*
> >   	 * The client will not queue more IBs during this fini,
> > consume existing
> >   	 * queued IBs or discard them on SIGKILL
> 
> That comment is actually not correct either.
> 
> drm_sched_entity_flush() should be used from the file_operations-
> >flush 
> function and that one can be used even without destroying the entity.
> 
> So it is perfectly possible that more and more IBs are pumped into
> the 
> entity while we wait for it to become idle.

Which would just result in drm_sched_entity_flush() timing out and
effectively not having done anything, right?

I guess we could touch that topic again when writing some docu for
scheduler teardown.

Would it be the best to just remove the comment, what do you think?

P.

> 
> Regards,
> Christian.
> 
> >   	 */
> > @@ -359,8 +356,11 @@ EXPORT_SYMBOL(drm_sched_entity_fini);
> >    * drm_sched_entity_destroy - Destroy a context entity
> >    * @entity: scheduler entity
> >    *
> > - * Calls drm_sched_entity_flush() and drm_sched_entity_fini() as a
> > - * convenience wrapper.
> > + * Convenience wrapper for entity teardown.
> > + *
> > + * Teardown of entities is split into two functions. The first
> > one,
> > + * drm_sched_entity_flush(), waits for the entity to become empty.
> > The second
> > + * one, drm_sched_entity_fini(), does the actual cleanup of the
> > entity object.
> >    */
> >   void drm_sched_entity_destroy(struct drm_sched_entity *entity)
> >   {
> 

Re: [PATCH 2/2] drm/sched: Fix docu of drm_sched_entity_flush()

[kernel test robot]

Hi Philipp,

kernel test robot noticed the following build warnings:

[auto build test WARNING on drm-misc/drm-misc-next]
[also build test WARNING on v6.12 next-20241121]
[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-docu-of-drm_sched_entity_flush/20241121-125617
base:   git://anongit.freedesktop.org/drm/drm-misc drm-misc-next
patch link:    https://lore.kernel.org/r/20241119134122.21950-3-pstanner%40redhat.com
patch subject: [PATCH 2/2] drm/sched: Fix docu of drm_sched_entity_flush()
config: arc-randconfig-001-20241122 (https://download.01.org/0day-ci/archive/20241122/202411220432.6kkVBxah-lkp@intel.com/config)
compiler: arc-elf-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20241122/202411220432.6kkVBxah-lkp@intel.com/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 <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202411220432.6kkVBxah-lkp@intel.com/

All warnings (new ones prefixed by >>):

>> drivers/gpu/drm/scheduler/sched_entity.c:277: warning: bad line: 


vim +277 drivers/gpu/drm/scheduler/sched_entity.c

   270	
   271	/**
   272	 * drm_sched_entity_flush - Flush a context entity
   273	 * @entity: scheduler entity
   274	 * @timeout: time to wait in jiffies
   275	 *
   276	 * Returns: 0 if the timeout ellapsed, the remaining time otherwise.
 > 277	
   278	 * Waits at most @timeout jiffies for the entity's job queue to become empty.
   279	 */
   280	long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
   281	{
   282		struct drm_gpu_scheduler *sched;
   283		struct task_struct *last_user;
   284		long ret = timeout;
   285	
   286		if (!entity->rq)
   287			return 0;
   288	
   289		sched = entity->rq->sched;
   290		/*
   291		 * The client will not queue more IBs during this fini, consume existing
   292		 * queued IBs or discard them on SIGKILL
   293		 */
   294		if (timeout != 0 && (current->flags & PF_EXITING)) {
   295			ret = wait_event_timeout(sched->job_scheduled,
   296					drm_sched_entity_is_idle(entity),
   297					timeout);
   298			/*
   299			 * wait_event_timeout() returns 1 if it timed out but the
   300			 * condition became true on timeout. We only care about whether
   301			 * it timed out or not.
   302			 */
   303			if (ret == 1)
   304				ret = 0;
   305		} else {
   306			wait_event_killable(sched->job_scheduled,
   307					    drm_sched_entity_is_idle(entity));
   308	
   309			ret -= (long)get_jiffies_64();
   310			if (ret < 0)
   311				ret = 0;
   312		}
   313	
   314		/* For killed process disable any more IBs enqueue right now */
   315		last_user = cmpxchg(&entity->last_user, current->group_leader, NULL);
   316		if ((!last_user || last_user == current->group_leader) &&
   317		    (current->flags & PF_EXITING) && (current->exit_code == SIGKILL))
   318			drm_sched_entity_kill(entity);
   319	
   320		return ret;
   321	}
   322	EXPORT_SYMBOL(drm_sched_entity_flush);
   323	

-- 
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

Re: [PATCH 1/2] drm/sched: Fix drm_sched_entity_flush() return val

[Philipp Stanner]

On Tue, 2024-11-19 at 14:41 +0100, Philipp Stanner wrote:
> The documentation of drm_sched_entity_flush() states that the
> function
> shall - always - return the remaining timeout time in jiffies.
> 
> However, that is not what the function actually does; in one of its
> if
> branches it simply returns the unchanged timeout value.
> 
> Furthermore, the used function wait_event_timeout() doesn't always
> return the remaining timeout time.
> 
> Adjust the function so that it actually does what the documentation
> states it shall do.
> 
> Cc: Christian König <christian.koenig@amd.com>
> Signed-off-by: Philipp Stanner <pstanner@redhat.com>
> ---
> @AMD:
> You guys are the only ones who use the function's return code, so I
> leave it completely up to you to decide what behavior you want.
> 
> But we should at least do something, because right now function
> documentation and behavior do not match.
> 
> P.
> ---
>  drivers/gpu/drm/scheduler/sched_entity.c | 23 ++++++++++++++++------
> -
>  1 file changed, 16 insertions(+), 7 deletions(-)
> 
> diff --git a/drivers/gpu/drm/scheduler/sched_entity.c
> b/drivers/gpu/drm/scheduler/sched_entity.c
> index a75eede8bf8d..16b172aee453 100644
> --- a/drivers/gpu/drm/scheduler/sched_entity.c
> +++ b/drivers/gpu/drm/scheduler/sched_entity.c
> @@ -278,7 +278,7 @@ static void drm_sched_entity_kill(struct
> drm_sched_entity *entity)
>   * waiting, removes the entity from the runqueue and returns an
> error when the
>   * process was killed.
>   *
> - * Returns the remaining time in jiffies left from the input timeout
> + * Returns: 0 if the timeout ellapsed, the remaining time otherwise.
>   */
>  long drm_sched_entity_flush(struct drm_sched_entity *entity, long
> timeout)
>  {
> @@ -294,15 +294,24 @@ long drm_sched_entity_flush(struct
> drm_sched_entity *entity, long timeout)
>  	 * The client will not queue more IBs during this fini,
> consume existing
>  	 * queued IBs or discard them on SIGKILL
>  	 */
> -	if (current->flags & PF_EXITING) {
> -		if (timeout)
> -			ret = wait_event_timeout(
> -					sched->job_scheduled,
> -
> 					drm_sched_entity_is_idle(entity),
> -					timeout);
> +	if (timeout != 0 && (current->flags & PF_EXITING)) {
> +		ret = wait_event_timeout(sched->job_scheduled,
> +				drm_sched_entity_is_idle(entity),
> +				timeout);
> +		/*
> +		 * wait_event_timeout() returns 1 if it timed out
> but the
> +		 * condition became true on timeout. We only care
> about whether
> +		 * it timed out or not.
> +		 */
> +		if (ret == 1)
> +			ret = 0;
>  	} else {
>  		wait_event_killable(sched->job_scheduled,
>  				   
> drm_sched_entity_is_idle(entity));
> +
> +		ret -= (long)get_jiffies_64();

Ah, just recognized that this is probably nonsense – anyways, let's
discuss what we shall do here. I can fix it later.

P.

> +		if (ret < 0)
> +			ret = 0;
>  	}
>  
>  	/* For killed process disable any more IBs enqueue right now
> */