sched/core: Call __schedule() from do_idle() without enabling preemption
authorSteven Rostedt (VMware) <>
Fri, 14 Apr 2017 12:48:09 +0000 (08:48 -0400)
committerIngo Molnar <>
Mon, 15 May 2017 08:09:12 +0000 (10:09 +0200)
I finally got around to creating trampolines for dynamically allocated
ftrace_ops with using synchronize_rcu_tasks(). For users of the ftrace
function hook callbacks, like perf, that allocate the ftrace_ops
descriptor via kmalloc() and friends, ftrace was not able to optimize
the functions being traced to use a trampoline because they would also
need to be allocated dynamically. The problem is that they cannot be
freed when CONFIG_PREEMPT is set, as there's no way to tell if a task
was preempted on the trampoline. That was before Paul McKenney
implemented synchronize_rcu_tasks() that would make sure all tasks
(except idle) have scheduled out or have entered user space.

While testing this, I triggered this bug:

 BUG: unable to handle kernel paging request at ffffffffa0230077
 RIP: 0010:0xffffffffa0230077
 Call Trace:

What happened was that the idle task was preempted on the trampoline.
As synchronize_rcu_tasks() ignores the idle thread, there's nothing
that lets ftrace know that the idle task was preempted on a trampoline.

The idle task shouldn't need to ever enable preemption. The idle task
is simply a loop that calls schedule or places the cpu into idle mode.
In fact, having preemption enabled is inefficient, because it can
happen when idle is just about to call schedule anyway, which would
cause schedule to be called twice. Once for when the interrupt came in
and was returning back to normal context, and then again in the normal
path that the idle loop is running in, which would be pointless, as it
had already scheduled.

The only reason schedule_preempt_disable() enables preemption is to be
able to call sched_submit_work(), which requires preemption enabled. As
this is a nop when the task is in the RUNNING state, and idle is always
in the running state, there's no reason that idle needs to enable
preemption. But that means it cannot use schedule_preempt_disable() as
other callers of that function require calling sched_submit_work().

Adding a new function local to kernel/sched/ that allows idle to call
the scheduler without enabling preemption, fixes the
synchronize_rcu_tasks() issue, as well as removes the pointless spurious
schedule calls caused by interrupts happening in the brief window where
preemption is enabled just before it calls schedule.

Reviewed: Thomas Gleixner <>
Signed-off-by: Steven Rostedt (VMware) <>
Signed-off-by: Peter Zijlstra (Intel) <>
Acked-by: Paul E. McKenney <>
Cc: Andrew Morton <>
Cc: Linus Torvalds <>
Cc: Peter Zijlstra <>
Cc: Thomas Gleixner <>
Signed-off-by: Ingo Molnar <>

index 759f4bd52cd6b3724b858d41f57ff305a3747c8b..803c3bc274c4660bb672c2522331db967883aee4 100644 (file)
@@ -3502,6 +3502,31 @@ asmlinkage __visible void __sched schedule(void)
+ * synchronize_rcu_tasks() makes sure that no task is stuck in preempted
+ * state (have scheduled out non-voluntarily) by making sure that all
+ * tasks have either left the run queue or have gone into user space.
+ * As idle tasks do not do either, they must not ever be preempted
+ * (schedule out non-voluntarily).
+ *
+ * schedule_idle() is similar to schedule_preempt_disable() except that it
+ * never enables preemption because it does not call sched_submit_work().
+ */
+void __sched schedule_idle(void)
+       /*
+        * 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
+        * 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.
+        */
+       WARN_ON_ONCE(current->state);
+       do {
+               __schedule(false);
+       } while (need_resched());
 asmlinkage __visible void __sched schedule_user(void)
index 2a25a9ec2c6e5806ad8528717c5b372d750dcf9e..ef63adce0c9cf98eecd9a6896e16d804c6bc1759 100644 (file)
@@ -265,7 +265,7 @@ static void do_idle(void)
-       schedule_preempt_disabled();
+       schedule_idle();
        if (unlikely(klp_patch_pending(current)))
index 7808ab05059991a2dad05bf073f1fee539f0fbbd..6dda2aab731e04c5e1f88272f180f44df22e907a 100644 (file)
@@ -1467,6 +1467,8 @@ static inline struct cpuidle_state *idle_get_state(struct rq *rq)
+extern void schedule_idle(void);
 extern void sysrq_sched_debug_show(void);
 extern void sched_init_granularity(void);
 extern void update_max_interval(void);