sched: Add locking comments to sched_class methods

'Document' the locking context the various sched_class methods are
called under.

Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Juri Lelli <juri.lelli@redhat.com>
Acked-by: Tejun Heo <tj@kernel.org>
Acked-by: Vincent Guittot <vincent.guittot@linaro.org>

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index e932439ae6dabe32cfdfb968c4bb7f563c20d0d9..8c55740b1e062e1ec3a6c2217b880821b2c134ae 100644 (file)
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -583,8 +583,8 @@ EXPORT_SYMBOL(__trace_set_current_state);
  *
  * p->on_rq <- { 0, 1 = TASK_ON_RQ_QUEUED, 2 = TASK_ON_RQ_MIGRATING }:
  *
- *   is set by activate_task() and cleared by deactivate_task(), under
- *   rq->lock. Non-zero indicates the task is runnable, the special
+ *   is set by activate_task() and cleared by deactivate_task()/block_task(),
+ *   under rq->lock. Non-zero indicates the task is runnable, the special
  *   ON_RQ_MIGRATING state is used for migration without holding both
  *   rq->locks. It indicates task_cpu() is not stable, see task_rq_lock().
  *
@@ -4162,7 +4162,7 @@ int try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
                 * __schedule().  See the comment for smp_mb__after_spinlock().
                 *
                 * Form a control-dep-acquire with p->on_rq == 0 above, to ensure
-                * schedule()'s deactivate_task() has 'happened' and p will no longer
+                * schedule()'s block_task() has 'happened' and p will no longer
                 * care about it's own p->state. See the comment in __schedule().
                 */
                smp_acquire__after_ctrl_dep();

diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index ea2ea8fd6505172b72912ae90606d6f40441d417..346214503452c26597d5954b97521418f3500e27 100644 (file)
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -2345,8 +2345,7 @@ extern const u32          sched_prio_to_wmult[40];
 /*
  * {de,en}queue flags:
  *
- * DEQUEUE_SLEEP  - task is no longer runnable
- * ENQUEUE_WAKEUP - task just became runnable
+ * SLEEP/WAKEUP - task is no-longer/just-became runnable
  *
  * SAVE/RESTORE - an otherwise spurious dequeue/enqueue, done to ensure tasks
  *                are in a known state which allows modification. Such pairs
@@ -2359,11 +2358,18 @@ extern const u32                sched_prio_to_wmult[40];
  *
  * MIGRATION - p->on_rq == TASK_ON_RQ_MIGRATING (used for DEADLINE)
  *
+ * DELAYED - de/re-queue a sched_delayed task
+ *
+ * CLASS - going to update p->sched_class; makes sched_change call the
+ *         various switch methods.
+ *
  * ENQUEUE_HEAD      - place at front of runqueue (tail if not specified)
  * ENQUEUE_REPLENISH - CBS (replenish runtime and postpone deadline)
  * ENQUEUE_MIGRATED  - the task was migrated during wakeup
  * ENQUEUE_RQ_SELECTED - ->select_task_rq() was called
  *
+ * XXX SAVE/RESTORE in combination with CLASS doesn't really make sense, but
+ * SCHED_DEADLINE seems to rely on this for now.
  */
 
 #define DEQUEUE_SLEEP          0x0001 /* Matches ENQUEUE_WAKEUP */
@@ -2409,14 +2415,50 @@ struct sched_class {
        int uclamp_enabled;
 #endif
 
+       /*
+        * move_queued_task/activate_task/enqueue_task: rq->lock
+        * ttwu_do_activate/activate_task/enqueue_task: rq->lock
+        * wake_up_new_task/activate_task/enqueue_task: task_rq_lock
+        * ttwu_runnable/enqueue_task: task_rq_lock
+        * proxy_task_current: rq->lock
+        * sched_change_end
+        */
        void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
+       /*
+        * move_queued_task/deactivate_task/dequeue_task: rq->lock
+        * __schedule/block_task/dequeue_task: rq->lock
+        * proxy_task_current: rq->lock
+        * wait_task_inactive: task_rq_lock
+        * sched_change_begin
+        */
        bool (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
+
+       /*
+        * do_sched_yield: rq->lock
+        */
        void (*yield_task)   (struct rq *rq);
+       /*
+        * yield_to: rq->lock (double)
+        */
        bool (*yield_to_task)(struct rq *rq, struct task_struct *p);
 
+       /*
+        * move_queued_task: rq->lock
+        * __migrate_swap_task: rq->lock
+        * ttwu_do_activate: rq->lock
+        * ttwu_runnable: task_rq_lock
+        * wake_up_new_task: task_rq_lock
+        */
        void (*wakeup_preempt)(struct rq *rq, struct task_struct *p, int flags);
 
+       /*
+        * schedule/pick_next_task/prev_balance: rq->lock
+        */
        int (*balance)(struct rq *rq, struct task_struct *prev, struct rq_flags *rf);
+
+       /*
+        * schedule/pick_next_task: rq->lock
+        */
        struct task_struct *(*pick_task)(struct rq *rq);
        /*
         * Optional! When implemented pick_next_task() should be equivalent to:
@@ -2429,48 +2471,102 @@ struct sched_class {
         */
        struct task_struct *(*pick_next_task)(struct rq *rq, struct task_struct *prev);
 
+       /*
+        * sched_change:
+        * __schedule: rq->lock
+        */
        void (*put_prev_task)(struct rq *rq, struct task_struct *p, struct task_struct *next);
        void (*set_next_task)(struct rq *rq, struct task_struct *p, bool first);
 
+       /*
+        * select_task_rq: p->pi_lock
+        * sched_exec: p->pi_lock
+        */
        int  (*select_task_rq)(struct task_struct *p, int task_cpu, int flags);
 
+       /*
+        * set_task_cpu: p->pi_lock || rq->lock (ttwu like)
+        */
        void (*migrate_task_rq)(struct task_struct *p, int new_cpu);
 
+       /*
+        * ttwu_do_activate: rq->lock
+        * wake_up_new_task: task_rq_lock
+        */
        void (*task_woken)(struct rq *this_rq, struct task_struct *task);
 
+       /*
+        * do_set_cpus_allowed: task_rq_lock + sched_change
+        */
        void (*set_cpus_allowed)(struct task_struct *p, struct affinity_context *ctx);
 
+       /*
+        * sched_set_rq_{on,off}line: rq->lock
+        */
        void (*rq_online)(struct rq *rq);
        void (*rq_offline)(struct rq *rq);
 
+       /*
+        * push_cpu_stop: p->pi_lock && rq->lock
+        */
        struct rq *(*find_lock_rq)(struct task_struct *p, struct rq *rq);
 
+       /*
+        * hrtick: rq->lock
+        * sched_tick: rq->lock
+        * sched_tick_remote: rq->lock
+        */
        void (*task_tick)(struct rq *rq, struct task_struct *p, int queued);
+       /*
+        * sched_cgroup_fork: p->pi_lock
+        */
        void (*task_fork)(struct task_struct *p);
+       /*
+        * finish_task_switch: no locks
+        */
        void (*task_dead)(struct task_struct *p);
 
+       /*
+        * sched_change
+        */
        void (*switching_from)(struct rq *this_rq, struct task_struct *task);
        void (*switched_from) (struct rq *this_rq, struct task_struct *task);
        void (*switching_to)  (struct rq *this_rq, struct task_struct *task);
        void (*switched_to)   (struct rq *this_rq, struct task_struct *task);
-
-       void (*reweight_task)(struct rq *this_rq, struct task_struct *task,
-                             const struct load_weight *lw);
-
        u64  (*get_prio)     (struct rq *this_rq, struct task_struct *task);
        void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
                              u64 oldprio);
 
+       /*
+        * set_load_weight: task_rq_lock + sched_change
+        * __setscheduler_parms: task_rq_lock + sched_change
+        */
+       void (*reweight_task)(struct rq *this_rq, struct task_struct *task,
+                             const struct load_weight *lw);
+
+       /*
+        * sched_rr_get_interval: task_rq_lock
+        */
        unsigned int (*get_rr_interval)(struct rq *rq,
                                        struct task_struct *task);
 
+       /*
+        * task_sched_runtime: task_rq_lock
+        */
        void (*update_curr)(struct rq *rq);
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
+       /*
+        * sched_change_group: task_rq_lock + sched_change
+        */
        void (*task_change_group)(struct task_struct *p);
 #endif
 
 #ifdef CONFIG_SCHED_CORE
+       /*
+        * pick_next_task: rq->lock
+        * try_steal_cookie: rq->lock (double)
+        */
        int (*task_is_throttled)(struct task_struct *p, int cpu);
 #endif
 };