sched: Fix spelling in comments

}

/*

 * We are going deep-idle (irqs are disabled):

 * We are going deep-idle (IRQs are disabled):

 */

notrace void sched_clock_idle_sleep_event(void)

{

	/*

	 * Since irq_time is only updated on {soft,}irq_exit, we might run into

	 * this case when a previous update_rq_clock() happened inside a

	 * {soft,}irq region.

	 * {soft,}IRQ region.

	 *

	 * When this happens, we stop ->clock_task and only update the

	 * prev_irq_time stamp to account for the part that fit, so that a next

	 * update will consume the rest. This ensures ->clock_task is

	 * monotonic.

	 *

	 * It does however cause some slight miss-attribution of {soft,}irq

	 * It does however cause some slight miss-attribution of {soft,}IRQ

	 * time, a more accurate solution would be to update the irq_time using

	 * the current rq->clock timestamp, except that would require using

	 * atomic ops.

/*

 * Called to set the hrtick timer state.

 *

 * called with rq->lock held and irqs disabled

 * called with rq->lock held and IRQs disabled

 */

void hrtick_start(struct rq *rq, u64 delay)

{

/*

 * Called to set the hrtick timer state.

 *

 * called with rq->lock held and irqs disabled

 * called with rq->lock held and IRQs disabled

 */

void hrtick_start(struct rq *rq, u64 delay)

{

#endif	/* CONFIG_SCHED_HRTICK */

/*

 * cmpxchg based fetch_or, macro so it works for different integer types

 * try_cmpxchg based fetch_or() macro so it works for different integer types:

 */

#define fetch_or(ptr, mask)						\

	({								\

	 * nohz functions that would need to follow TIF_NR_POLLING

	 * clearing:

	 *

	 * - On most archs, a simple fetch_or on ti::flags with a

	 * - On most architectures, a simple fetch_or on ti::flags with a

	 *   "0" value would be enough to know if an IPI needs to be sent.

	 *

	 * - x86 needs to perform a last need_resched() check between

		return;

	/*

	 * Violates locking rules! see comment in __do_set_cpus_allowed().

	 * Violates locking rules! See comment in __do_set_cpus_allowed().

	 */

	__do_set_cpus_allowed(p, &ac);

}

}

/*

 * migration_cpu_stop - this will be executed by a highprio stopper thread

 * migration_cpu_stop - this will be executed by a high-prio stopper thread

 * and performs thread migration by bumping thread off CPU then

 * 'pushing' onto another runqueue.

 */

	 * it is possible for select_idle_siblings() to stack a number

	 * of tasks on this CPU during that window.

	 *

	 * It is ok to clear ttwu_pending when another task pending.

	 * We will receive IPI after local irq enabled and then enqueue it.

	 * It is OK to clear ttwu_pending when another task pending.

	 * We will receive IPI after local IRQ enabled and then enqueue it.

	 * Since now nr_running > 0, idle_cpu() will always get correct result.

	 */

	WRITE_ONCE(rq->ttwu_pending, 0);

 *

 * The context switch have flipped the stack from under us and restored the

 * local variables which were saved when this task called schedule() in the

 * past. prev == current is still correct but we need to recalculate this_rq

 * past. 'prev == current' is still correct but we need to recalculate this_rq

 * because prev may have moved to another CPU.

 */

static struct rq *finish_task_switch(struct task_struct *prev)

	/*

	 * 64-bit doesn't need locks to atomically read a 64-bit value.

	 * So we have a optimization chance when the task's delta_exec is 0.

	 * Reading ->on_cpu is racy, but this is ok.

	 * Reading ->on_cpu is racy, but this is OK.

	 *

	 * If we race with it leaving CPU, we'll take a lock. So we're correct.

	 * If we race with it entering CPU, unaccounted time is 0. This is

{

	/*

	 * As this skips calling sched_submit_work(), which the idle task does

	 * regardless because that function is a nop when the task is in a

	 * regardless because that function is a NOP when the task is in a

	 * TASK_RUNNING state, make sure this isn't used someplace that the

	 * current task can be in any other state. Note, idle is always in the

	 * TASK_RUNNING state.

/*

 * This is the entry point to schedule() from kernel preemption

 * off of irq context.

 * Note, that this is called and return with irqs disabled. This will

 * protect us against recursive calling from irq.

 * off of IRQ context.

 * Note, that this is called and return with IRQs disabled. This will

 * protect us against recursive calling from IRQ contexts.

 */

asmlinkage __visible void __sched preempt_schedule_irq(void)

{

		goto out_unlock;

	/*

	 * Idle task boosting is a nono in general. There is one

	 * Idle task boosting is a no-no in general. There is one

	 * exception, when PREEMPT_RT and NOHZ is active:

	 *

	 * The idle task calls get_next_timer_interrupt() and holds

PREEMPT_MODEL_ACCESSOR(voluntary);

PREEMPT_MODEL_ACCESSOR(full);

#else /* !CONFIG_PREEMPT_DYNAMIC */

#else /* !CONFIG_PREEMPT_DYNAMIC: */

static inline void preempt_dynamic_init(void) { }

#endif /* #ifdef CONFIG_PREEMPT_DYNAMIC */

#endif /* CONFIG_PREEMPT_DYNAMIC */

int io_schedule_prepare(void)

{

	 * Specifically, we rely on ttwu to no longer target this CPU, see

	 * ttwu_queue_cond() and is_cpu_allowed().

	 *

	 * Do sync before park smpboot threads to take care the rcu boost case.

	 * Do sync before park smpboot threads to take care the RCU boost case.

	 */

	synchronize_rcu();

 * Since this CPU is going 'away' for a while, fold any nr_active delta we

 * might have. Called from the CPU stopper task after ensuring that the

 * stopper is the last running task on the CPU, so nr_active count is

 * stable. We need to take the teardown thread which is calling this into

 * stable. We need to take the tear-down thread which is calling this into

 * account, so we hand in adjust = 1 to the load calculation.

 *

 * Also see the comment "Global load-average calculations".

		/*

		 * How much CPU bandwidth does root_task_group get?

		 *

		 * In case of task-groups formed thr' the cgroup filesystem, it

		 * In case of task-groups formed through the cgroup filesystem, it

		 * gets 100% of the CPU resources in the system. This overall

		 * system CPU resource is divided among the tasks of

		 * root_task_group and its child task-groups in a fair manner,

#if defined(CONFIG_KGDB_KDB)

/*

 * These functions are only useful for kdb.

 * These functions are only useful for KDB.

 *

 * They can only be called when the whole system has been

 * stopped - every CPU needs to be quiescent, and no scheduling

	online_fair_sched_group(tg);

}

/* rcu callback to free various structures associated with a task group */

/* RCU callback to free various structures associated with a task group */

static void sched_unregister_group_rcu(struct rcu_head *rhp)

{

	/* Now it should be safe to free those cfs_rqs: */

};

/*

 * Inverse (2^32/x) values of the sched_prio_to_weight[] array, precalculated.

 * Inverse (2^32/x) values of the sched_prio_to_weight[] array, pre-calculated.

 *

 * In cases where the weight does not change often, we can use the

 * precalculated inverse to speed up arithmetics by turning divisions

 * pre-calculated inverse to speed up arithmetics by turning divisions

 * into multiplications:

 */

const u32 sched_prio_to_wmult[40] = {

	/*

	 * Move the src cid if the dst cid is unset. This keeps id

	 * allocation closest to 0 in cases where few threads migrate around

	 * many cpus.

	 * many CPUs.

	 *

	 * If destination cid is already set, we may have to just clear

	 * the src cid to ensure compactness in frequent migrations

	 * scenarios.

	 *

	 * It is not useful to clear the src cid when the number of threads is

	 * greater or equal to the number of allowed cpus, because user-space

	 * greater or equal to the number of allowed CPUs, because user-space

	 * can expect that the number of allowed cids can reach the number of

	 * allowed cpus.

	 * allowed CPUs.

	 */

	dst_pcpu_cid = per_cpu_ptr(mm->pcpu_cid, cpu_of(dst_rq));

	dst_cid = READ_ONCE(dst_pcpu_cid->cid);

			continue;

		/*

		 * Note: this will account forceidle to the current cpu, even

		 * Note: this will account forceidle to the current CPU, even

		 * if it comes from our SMT sibling.

		 */

		__account_forceidle_time(p, delta);

 * They are only modified in vtime_account, on corresponding CPU

 * with interrupts disabled. So, writes are safe.

 * They are read and saved off onto struct rq in update_rq_clock().

 * This may result in other CPU reading this CPU's irq time and can

 * This may result in other CPU reading this CPU's IRQ time and can

 * race with irq/vtime_account on this CPU. We would either get old

 * or new value with a side effect of accounting a slice of irq time to wrong

 * task when irq is in progress while we read rq->clock. That is a worthy

 * compromise in place of having locks on each irq in account_system_time.

 * or new value with a side effect of accounting a slice of IRQ time to wrong

 * task when IRQ is in progress while we read rq->clock. That is a worthy

 * compromise in place of having locks on each IRQ in account_system_time.

 */

DEFINE_PER_CPU(struct irqtime, cpu_irqtime);

}

/*

 * Account how much elapsed time was spent in steal, irq, or softirq time.

 * Account how much elapsed time was spent in steal, IRQ, or softirq time.

 */

static inline u64 account_other_time(u64 max)

{

 * Check for hardirq is done both for system and user time as there is

 * no timer going off while we are on hardirq and hence we may never get an

 * opportunity to update it solely in system time.

 * p->stime and friends are only updated on system time and not on irq

 * p->stime and friends are only updated on system time and not on IRQ

 * softirq as those do not count in task exec_runtime any more.

 */

static void irqtime_account_process_tick(struct task_struct *p, int user_tick,

	/*

	 * When returning from idle, many ticks can get accounted at

	 * once, including some ticks of steal, irq, and softirq time.

	 * once, including some ticks of steal, IRQ, and softirq time.

	 * Subtract those ticks from the amount of time accounted to

	 * idle, or potentially user or system time. Due to rounding,

	 * other time can exceed ticks occasionally.

 * is detected, the runtime and deadline need to be updated.

 *

 * If the task has an implicit deadline, i.e., deadline == period, the Original

 * CBS is applied. the runtime is replenished and a new absolute deadline is

 * CBS is applied. The runtime is replenished and a new absolute deadline is

 * set, as in the previous cases.

 *

 * However, the Original CBS does not work properly for tasks with

 * Since rq->dl.running_bw and rq->dl.this_bw contain utilizations multiplied

 * by 2^BW_SHIFT, the result has to be shifted right by BW_SHIFT.

 * Since rq->dl.bw_ratio contains 1 / Umax multiplied by 2^RATIO_SHIFT, dl_bw

 * is multiped by rq->dl.bw_ratio and shifted right by RATIO_SHIFT.

 * is multiplied by rq->dl.bw_ratio and shifted right by RATIO_SHIFT.

 * Since delta is a 64 bit variable, to have an overflow its value should be

 * larger than 2^(64 - 20 - 8), which is more than 64 seconds. So, overflow is

 * not an issue here.

		src_rq = cpu_rq(cpu);

		/*

		 * It looks racy, abd it is! However, as in sched_rt.c,

		 * It looks racy, and it is! However, as in sched_rt.c,

		 * we are fine with this.

		 */

		if (this_rq->dl.dl_nr_running &&