Address a FIXME against struct drm_sched_entity->fence_seq which
documented this field does not need to be atomic_t.

Indeed now that most of the flow is guarded with entity->lock we can pull
out the lock a step up, to drm_sched_job_arm(), which also simplifies
drm_sched_entity_select_rq() and convert the field to a standard unsigned
long.

Signed-off-by: Tvrtko Ursulin <[email protected]>
Cc: Christian König <[email protected]>
Cc: Danilo Krummrich <[email protected]>
Cc: Matthew Brost <[email protected]>
Cc: Philipp Stanner <[email protected]>
---
 drivers/gpu/drm/scheduler/sched_entity.c | 13 ++++---------
 drivers/gpu/drm/scheduler/sched_fence.c  |  6 ++++--
 drivers/gpu/drm/scheduler/sched_main.c   |  7 ++++++-
 include/drm/gpu_scheduler.h              |  7 ++-----
 4 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/drivers/gpu/drm/scheduler/sched_entity.c 
b/drivers/gpu/drm/scheduler/sched_entity.c
index 9fb5affaab87..63f52d1a8c74 100644
--- a/drivers/gpu/drm/scheduler/sched_entity.c
+++ b/drivers/gpu/drm/scheduler/sched_entity.c
@@ -168,8 +168,6 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
 
        spin_lock_init(&entity->lock);
        INIT_LIST_HEAD(&entity->job_queue);
-
-       atomic_set(&entity->fence_seq, 0);
        entity->fence_context = dma_fence_context_alloc(2);
 
        return 0;
@@ -620,21 +618,21 @@ void drm_sched_entity_select_rq(struct drm_sched_entity 
*entity)
        struct drm_gpu_scheduler *sched;
        struct drm_sched_rq *rq;
 
-       spin_lock(&entity->lock);
+       lockdep_assert_held(&entity->lock);
 
        /* queue non-empty, stay on the same engine */
        if (entity->job_credits)
-               goto out;
+               return;
 
        /* Cannot submit to stopped entity anyway so bail out early. */
        if (entity->stopped)
-               goto out;
+               return;
 
        fence = entity->last_scheduled;
 
        /* stay on the same engine if the previous job hasn't finished */
        if (fence && !dma_fence_is_signaled(fence))
-               goto out;
+               return;
 
        if (entity->num_sched_list == 1)
                sched = entity->sched;
@@ -646,9 +644,6 @@ void drm_sched_entity_select_rq(struct drm_sched_entity 
*entity)
                drm_sched_rq_remove_entity(entity->rq, entity);
                entity->rq = rq;
        }
-
-out:
-       spin_unlock(&entity->lock);
 }
 
 /**
diff --git a/drivers/gpu/drm/scheduler/sched_fence.c 
b/drivers/gpu/drm/scheduler/sched_fence.c
index b7a4cb921234..b4c336ff0179 100644
--- a/drivers/gpu/drm/scheduler/sched_fence.c
+++ b/drivers/gpu/drm/scheduler/sched_fence.c
@@ -224,10 +224,12 @@ struct drm_sched_fence *drm_sched_fence_alloc(void *owner,
 void drm_sched_fence_init(struct drm_sched_fence *fence,
                          struct drm_sched_entity *entity)
 {
-       unsigned seq;
+       unsigned long seq;
+
+       lockdep_assert_held(&entity->lock);
 
        fence->sched = entity->rq->sched;
-       seq = atomic_inc_return(&entity->fence_seq);
+       seq = ++entity->fence_seq;
        dma_fence_init(&fence->scheduled, &drm_sched_fence_ops_scheduled,
                       &fence->lock, entity->fence_context, seq);
        dma_fence_init(&fence->finished, &drm_sched_fence_ops_finished,
diff --git a/drivers/gpu/drm/scheduler/sched_main.c 
b/drivers/gpu/drm/scheduler/sched_main.c
index 85dc570a4816..61f3f1e8520d 100644
--- a/drivers/gpu/drm/scheduler/sched_main.c
+++ b/drivers/gpu/drm/scheduler/sched_main.c
@@ -607,6 +607,9 @@ void drm_sched_job_arm(struct drm_sched_job *job)
        struct drm_sched_entity *entity = job->entity;
 
        BUG_ON(!entity);
+
+       spin_lock(&entity->lock);
+
        drm_sched_entity_select_rq(entity);
        sched = entity->rq->sched;
 
@@ -614,7 +617,9 @@ void drm_sched_job_arm(struct drm_sched_job *job)
        job->s_priority = entity->priority;
        job->entity_stats = drm_sched_entity_stats_get(entity->stats);
 
-       drm_sched_fence_init(job->s_fence, job->entity);
+       drm_sched_fence_init(job->s_fence, entity);
+
+       spin_unlock(&entity->lock);
 }
 EXPORT_SYMBOL(drm_sched_job_arm);
 
diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h
index 0cffb47f151b..6a98eb9f0b4b 100644
--- a/include/drm/gpu_scheduler.h
+++ b/include/drm/gpu_scheduler.h
@@ -99,7 +99,7 @@ struct drm_sched_entity {
         *
         * Lock protecting the @job_queue, run-queue (@rq) to which this entity
         * belongs, @priority, @last_scheduled and the list of schedulers
-        * (@sched_list, @num_sched_list), @rr_ts and @stopped.
+        * (@sched_list, @num_sched_list), @rr_ts, @stopped and @fence_seq.
         */
        spinlock_t                      lock;
 
@@ -200,11 +200,8 @@ struct drm_sched_entity {
         *
         * A linearly increasing seqno incremented with each new
         * &drm_sched_fence which is part of the entity.
-        *
-        * FIXME: Callers of drm_sched_job_arm() need to ensure correct locking,
-        * this doesn't need to be atomic.
         */
-       atomic_t                        fence_seq;
+       unsigned long                   fence_seq;
 
        /**
         * @fence_context:
-- 
2.56.0

Reply via email to