sched: Remove __ARCH_WANT_INTERRUPTS_ON_CTXSW (f3e94786) · Commits · 戴 / test

Documentation/scheduler/sched-arch.txt

+0 −10

Original line number	Diff line number	Diff line
		@@ -17,16 +17,6 @@ you must `#define __ARCH_WANT_UNLOCKED_CTXSW` in a header file
		Unlocked context switches introduce only a very minor performance
		penalty to the core scheduler implementation in the CONFIG_SMP case.

		2. Interrupt status
		By default, the switch_to arch function is called with interrupts
		disabled. Interrupts may be enabled over the call if it is likely to
		introduce a significant interrupt latency by adding the line
		`#define __ARCH_WANT_INTERRUPTS_ON_CTXSW` in the same place as for
		unlocked context switches. This define also implies
		`__ARCH_WANT_UNLOCKED_CTXSW`. See arch/arm/include/asm/system.h for an
		example.


		CPU idle
		========
		Your cpu_idle routines need to obey the following rules:

include/linux/sched.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -678,11 +678,6 @@ struct signal_struct {
		* (notably. ptrace) */
		};

		/* Context switch must be unlocked if interrupts are to be enabled */
		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		# define __ARCH_WANT_UNLOCKED_CTXSW
		#endif

		/*
		* Bits in flags field of signal_struct.
		*/

kernel/fork.c

+0 −4

Original line number	Diff line number	Diff line
		@@ -1280,11 +1280,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
		#endif
		#ifdef CONFIG_TRACE_IRQFLAGS
		p->irq_events = 0;
		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		p->hardirqs_enabled = 1;
		#else
		p->hardirqs_enabled = 0;
		#endif
		p->hardirq_enable_ip = 0;
		p->hardirq_enable_event = 0;
		p->hardirq_disable_ip = _THIS_IP_;

kernel/sched/core.c

+1 −39

Original line number	Diff line number	Diff line
		@@ -1361,25 +1361,6 @@ static void ttwu_queue_remote(struct task_struct *p, int cpu)
		smp_send_reschedule(cpu);
		}

		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		static int ttwu_activate_remote(struct task_struct *p, int wake_flags)
		{
		struct rq *rq;
		int ret = 0;

		rq = __task_rq_lock(p);
		if (p->on_cpu) {
		ttwu_activate(rq, p, ENQUEUE_WAKEUP);
		ttwu_do_wakeup(rq, p, wake_flags);
		ret = 1;
		}
		__task_rq_unlock(rq);

		return ret;

		}
		#endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */

		bool cpus_share_cache(int this_cpu, int that_cpu)
		{
		return per_cpu(sd_llc_id, this_cpu) == per_cpu(sd_llc_id, that_cpu);
		@@ -1440,21 +1421,8 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
		* If the owning (remote) cpu is still in the middle of schedule() with
		* this task as prev, wait until its done referencing the task.
		*/
		while (p->on_cpu) {
		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		/*
		* In case the architecture enables interrupts in
		* context_switch(), we cannot busy wait, since that
		* would lead to deadlocks when an interrupt hits and
		* tries to wake up @prev. So bail and do a complete
		* remote wakeup.
		*/
		if (ttwu_activate_remote(p, wake_flags))
		goto stat;
		#else
		while (p->on_cpu)
		cpu_relax();
		#endif
		}
		/*
		* Pairs with the smp_wmb() in finish_lock_switch().
		*/
		@@ -1798,13 +1766,7 @@ static void finish_task_switch(struct rq rq, struct task_struct prev)
		prev_state = prev->state;
		account_switch_vtime(prev);
		finish_arch_switch(prev);
		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		local_irq_disable();
		#endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
		perf_event_task_sched_in(prev, current);
		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		local_irq_enable();
		#endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
		finish_lock_switch(rq, prev);
		finish_arch_post_lock_switch();

kernel/sched/rt.c

+0 −5

Original line number	Diff line number	Diff line
		@@ -1632,11 +1632,6 @@ static int push_rt_task(struct rq *rq)
		if (!next_task)
		return 0;

		#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
		if (unlikely(task_running(rq, next_task)))
		return 0;
		#endif

		retry:
		if (unlikely(next_task == rq->curr)) {
		WARN_ON(1);

Admin message