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 | 12 ++++--------
 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(+), 16 deletions(-)

diff --git a/drivers/gpu/drm/scheduler/sched_entity.c 
b/drivers/gpu/drm/scheduler/sched_entity.c
index 6ff455373067..af6cb79c8a53 100644
--- a/drivers/gpu/drm/scheduler/sched_entity.c
+++ b/drivers/gpu/drm/scheduler/sched_entity.c
@@ -174,7 +174,6 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
        spin_lock_init(&entity->lock);
        spsc_queue_init(&entity->job_queue);
 
-       atomic_set(&entity->fence_seq, 0);
        entity->fence_context = dma_fence_context_alloc(2);
 
        return 0;
@@ -596,21 +595,21 @@ void drm_sched_entity_select_rq(struct drm_sched_entity 
*entity)
        struct drm_gpu_scheduler *sched;
        struct drm_sched_rq *rq;
 
+       lockdep_assert_held(&entity->lock);
+
        /* queue non-empty, stay on the same engine */
        if (spsc_queue_count(&entity->job_queue))
                return;
 
-       spin_lock(&entity->lock);
-
        /* 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;
@@ -622,9 +621,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 d0d34c523615..164a48637d56 100644
--- a/drivers/gpu/drm/scheduler/sched_main.c
+++ b/drivers/gpu/drm/scheduler/sched_main.c
@@ -646,6 +646,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;
 
@@ -653,7 +656,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 2069b3584591..81604b082259 100644
--- a/include/drm/gpu_scheduler.h
+++ b/include/drm/gpu_scheduler.h
@@ -101,7 +101,7 @@ struct drm_sched_entity {
         *
         * Lock protecting the 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.
+        * @num_sched_list), @rr_ts, @stopped and @fence_seq.
         */
        spinlock_t                      lock;
 
@@ -184,11 +184,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