sched: Add locking comments to sched_class methods

 *

 * 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().

 *

		 * __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();

/*

 * {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

 *

 * 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 */

	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:

	 */

	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

};