Blame view
kernel/sched/idle.c
8.61 KB
cf37b6b48
|
1 2 3 4 |
/* * Generic entry point for the idle threads */ #include <linux/sched.h> |
4c822698c
|
5 |
#include <linux/sched/idle.h> |
cf37b6b48
|
6 7 |
#include <linux/cpu.h> #include <linux/cpuidle.h> |
8df3e07e7
|
8 |
#include <linux/cpuhotplug.h> |
cf37b6b48
|
9 10 11 |
#include <linux/tick.h> #include <linux/mm.h> #include <linux/stackprotector.h> |
381063133
|
12 |
#include <linux/suspend.h> |
d83a7cb37
|
13 |
#include <linux/livepatch.h> |
cf37b6b48
|
14 15 16 17 |
#include <asm/tlb.h> #include <trace/events/power.h> |
e3baac47f
|
18 |
#include "sched.h" |
6727ad9e2
|
19 20 |
/* Linker adds these: start and end of __cpuidle functions */ extern char __cpuidle_text_start[], __cpuidle_text_end[]; |
faad38492
|
21 22 23 24 25 26 27 28 |
/** * sched_idle_set_state - Record idle state for the current CPU. * @idle_state: State to record. */ void sched_idle_set_state(struct cpuidle_state *idle_state) { idle_set_state(this_rq(), idle_state); } |
cf37b6b48
|
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
static int __read_mostly cpu_idle_force_poll; void cpu_idle_poll_ctrl(bool enable) { if (enable) { cpu_idle_force_poll++; } else { cpu_idle_force_poll--; WARN_ON_ONCE(cpu_idle_force_poll < 0); } } #ifdef CONFIG_GENERIC_IDLE_POLL_SETUP static int __init cpu_idle_poll_setup(char *__unused) { cpu_idle_force_poll = 1; return 1; } __setup("nohlt", cpu_idle_poll_setup); static int __init cpu_idle_nopoll_setup(char *__unused) { cpu_idle_force_poll = 0; return 1; } __setup("hlt", cpu_idle_nopoll_setup); #endif |
6727ad9e2
|
56 |
static noinline int __cpuidle cpu_idle_poll(void) |
cf37b6b48
|
57 58 59 60 |
{ rcu_idle_enter(); trace_cpu_idle_rcuidle(0, smp_processor_id()); local_irq_enable(); |
9babcd792
|
61 |
stop_critical_timings(); |
ff6f2d29b
|
62 63 |
while (!tif_need_resched() && (cpu_idle_force_poll || tick_check_broadcast_expired())) |
cf37b6b48
|
64 |
cpu_relax(); |
9babcd792
|
65 |
start_critical_timings(); |
cf37b6b48
|
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); rcu_idle_exit(); return 1; } /* Weak implementations for optional arch specific functions */ void __weak arch_cpu_idle_prepare(void) { } void __weak arch_cpu_idle_enter(void) { } void __weak arch_cpu_idle_exit(void) { } void __weak arch_cpu_idle_dead(void) { } void __weak arch_cpu_idle(void) { cpu_idle_force_poll = 1; local_irq_enable(); } |
827a5aefc
|
81 82 83 84 85 |
/** * default_idle_call - Default CPU idle routine. * * To use when the cpuidle framework cannot be used. */ |
6727ad9e2
|
86 |
void __cpuidle default_idle_call(void) |
82f663277
|
87 |
{ |
63caae848
|
88 |
if (current_clr_polling_and_test()) { |
82f663277
|
89 |
local_irq_enable(); |
63caae848
|
90 91 |
} else { stop_critical_timings(); |
82f663277
|
92 |
arch_cpu_idle(); |
63caae848
|
93 94 |
start_critical_timings(); } |
82f663277
|
95 |
} |
bcf6ad8a4
|
96 97 98 |
static int call_cpuidle(struct cpuidle_driver *drv, struct cpuidle_device *dev, int next_state) { |
bcf6ad8a4
|
99 100 101 102 103 104 105 106 107 |
/* * The idle task must be scheduled, it is pointless to go to idle, just * update no idle residency and return. */ if (current_clr_polling_and_test()) { dev->last_residency = 0; local_irq_enable(); return -EBUSY; } |
bcf6ad8a4
|
108 109 110 111 112 |
/* * Enter the idle state previously returned by the governor decision. * This function will block until an interrupt occurs and will take * care of re-enabling the local interrupts */ |
827a5aefc
|
113 |
return cpuidle_enter(drv, dev, next_state); |
bcf6ad8a4
|
114 |
} |
30cdd69e2
|
115 116 117 118 |
/** * cpuidle_idle_call - the main idle function * * NOTE: no locks or semaphores should be used here |
82c65d60d
|
119 120 121 122 |
* * On archs that support TIF_POLLING_NRFLAG, is called with polling * set, and it returns with polling set. If it ever stops polling, it * must clear the polling bit. |
30cdd69e2
|
123 |
*/ |
08c373e51
|
124 |
static void cpuidle_idle_call(void) |
30cdd69e2
|
125 |
{ |
9bd616e3d
|
126 |
struct cpuidle_device *dev = cpuidle_get_device(); |
30cdd69e2
|
127 |
struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); |
37352273a
|
128 |
int next_state, entered_state; |
30cdd69e2
|
129 |
|
a1d028bd6
|
130 131 |
/* * Check if the idle task must be rescheduled. If it is the |
c444117f0
|
132 |
* case, exit the function after re-enabling the local irq. |
a1d028bd6
|
133 |
*/ |
c444117f0
|
134 |
if (need_resched()) { |
8ca3c6424
|
135 |
local_irq_enable(); |
08c373e51
|
136 |
return; |
8ca3c6424
|
137 |
} |
a1d028bd6
|
138 |
/* |
a1d028bd6
|
139 140 141 142 |
* Tell the RCU framework we are entering an idle section, * so no more rcu read side critical sections and one more * step to the grace period */ |
c8cc7d4de
|
143 |
rcu_idle_enter(); |
82f663277
|
144 145 146 147 |
if (cpuidle_not_available(drv, dev)) { default_idle_call(); goto exit_idle; } |
ef2b22ac5
|
148 |
|
a1d028bd6
|
149 |
/* |
f02f4f9d8
|
150 |
* Suspend-to-idle ("s2idle") is a system state in which all user space |
381063133
|
151 152 153 154 155 156 157 |
* has been frozen, all I/O devices have been suspended and the only * activity happens here and in iterrupts (if any). In that case bypass * the cpuidle governor and go stratight for the deepest idle state * available. Possibly also suspend the local tick and the entire * timekeeping to prevent timer interrupts from kicking us out of idle * until a proper wakeup interrupt happens. */ |
bb8313b60
|
158 |
|
f02f4f9d8
|
159 160 |
if (idle_should_enter_s2idle() || dev->use_deepest_state) { if (idle_should_enter_s2idle()) { |
28ba086ed
|
161 |
entered_state = cpuidle_enter_s2idle(drv, dev); |
bb8313b60
|
162 163 164 165 |
if (entered_state > 0) { local_irq_enable(); goto exit_idle; } |
ef2b22ac5
|
166 |
} |
ef2b22ac5
|
167 |
next_state = cpuidle_find_deepest_state(drv, dev); |
bcf6ad8a4
|
168 |
call_cpuidle(drv, dev, next_state); |
ef2b22ac5
|
169 |
} else { |
ef2b22ac5
|
170 171 172 173 |
/* * Ask the cpuidle framework to choose a convenient idle state. */ next_state = cpuidle_select(drv, dev); |
bcf6ad8a4
|
174 175 176 177 |
entered_state = call_cpuidle(drv, dev, next_state); /* * Give the governor an opportunity to reflect on the outcome */ |
ef2b22ac5
|
178 |
cpuidle_reflect(dev, entered_state); |
bcf6ad8a4
|
179 |
} |
37352273a
|
180 181 |
exit_idle: |
8ca3c6424
|
182 |
__current_set_polling(); |
30cdd69e2
|
183 |
|
a1d028bd6
|
184 |
/* |
37352273a
|
185 |
* It is up to the idle functions to reenable local interrupts |
a1d028bd6
|
186 |
*/ |
c8cc7d4de
|
187 188 189 190 |
if (WARN_ON_ONCE(irqs_disabled())) local_irq_enable(); rcu_idle_exit(); |
30cdd69e2
|
191 |
} |
30cdd69e2
|
192 |
|
cf37b6b48
|
193 194 |
/* * Generic idle loop implementation |
82c65d60d
|
195 196 |
* * Called with polling cleared. |
cf37b6b48
|
197 |
*/ |
c1de45ca8
|
198 |
static void do_idle(void) |
cf37b6b48
|
199 |
{ |
c1de45ca8
|
200 201 202 203 204 205 206 207 |
/* * If the arch has a polling bit, we maintain an invariant: * * Our polling bit is clear if we're not scheduled (i.e. if rq->curr != * rq->idle). This means that, if rq->idle has the polling bit set, * then setting need_resched is guaranteed to cause the CPU to * reschedule. */ |
cf37b6b48
|
208 |
|
c1de45ca8
|
209 |
__current_set_polling(); |
ebfa4c02f
|
210 |
quiet_vmstat(); |
c1de45ca8
|
211 |
tick_nohz_idle_enter(); |
cf37b6b48
|
212 |
|
c1de45ca8
|
213 214 215 |
while (!need_resched()) { check_pgt_cache(); rmb(); |
cf37b6b48
|
216 |
|
c1de45ca8
|
217 218 219 |
if (cpu_is_offline(smp_processor_id())) { cpuhp_report_idle_dead(); arch_cpu_idle_dead(); |
cf37b6b48
|
220 |
} |
06d50c65b
|
221 |
|
c1de45ca8
|
222 223 |
local_irq_disable(); arch_cpu_idle_enter(); |
82c65d60d
|
224 225 |
/* |
c1de45ca8
|
226 227 228 229 |
* In poll mode we reenable interrupts and spin. Also if we * detected in the wakeup from idle path that the tick * broadcast device expired for us, we don't want to go deep * idle as we know that the IPI is going to arrive right away. |
82c65d60d
|
230 |
*/ |
c1de45ca8
|
231 232 233 234 235 |
if (cpu_idle_force_poll || tick_check_broadcast_expired()) cpu_idle_poll(); else cpuidle_idle_call(); arch_cpu_idle_exit(); |
cf37b6b48
|
236 |
} |
c1de45ca8
|
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 |
/* * Since we fell out of the loop above, we know TIF_NEED_RESCHED must * be set, propagate it into PREEMPT_NEED_RESCHED. * * This is required because for polling idle loops we will not have had * an IPI to fold the state for us. */ preempt_set_need_resched(); tick_nohz_idle_exit(); __current_clr_polling(); /* * We promise to call sched_ttwu_pending() and reschedule if * need_resched() is set while polling is set. That means that clearing * polling needs to be visible before doing these things. */ smp_mb__after_atomic(); sched_ttwu_pending(); |
8663effb2
|
257 |
schedule_idle(); |
d83a7cb37
|
258 259 260 |
if (unlikely(klp_patch_pending(current))) klp_update_patch_state(current); |
cf37b6b48
|
261 |
} |
6727ad9e2
|
262 263 264 265 266 |
bool cpu_in_idle(unsigned long pc) { return pc >= (unsigned long)__cpuidle_text_start && pc < (unsigned long)__cpuidle_text_end; } |
c1de45ca8
|
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 |
struct idle_timer { struct hrtimer timer; int done; }; static enum hrtimer_restart idle_inject_timer_fn(struct hrtimer *timer) { struct idle_timer *it = container_of(timer, struct idle_timer, timer); WRITE_ONCE(it->done, 1); set_tsk_need_resched(current); return HRTIMER_NORESTART; } void play_idle(unsigned long duration_ms) { struct idle_timer it; /* * Only FIFO tasks can disable the tick since they don't need the forced * preemption. */ WARN_ON_ONCE(current->policy != SCHED_FIFO); WARN_ON_ONCE(current->nr_cpus_allowed != 1); WARN_ON_ONCE(!(current->flags & PF_KTHREAD)); WARN_ON_ONCE(!(current->flags & PF_NO_SETAFFINITY)); WARN_ON_ONCE(!duration_ms); rcu_sleep_check(); preempt_disable(); current->flags |= PF_IDLE; cpuidle_use_deepest_state(true); it.done = 0; hrtimer_init_on_stack(&it.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); it.timer.function = idle_inject_timer_fn; hrtimer_start(&it.timer, ms_to_ktime(duration_ms), HRTIMER_MODE_REL_PINNED); while (!READ_ONCE(it.done)) do_idle(); cpuidle_use_deepest_state(false); current->flags &= ~PF_IDLE; preempt_fold_need_resched(); preempt_enable(); } EXPORT_SYMBOL_GPL(play_idle); |
cf37b6b48
|
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 |
void cpu_startup_entry(enum cpuhp_state state) { /* * This #ifdef needs to die, but it's too late in the cycle to * make this generic (arm and sh have never invoked the canary * init for the non boot cpus!). Will be fixed in 3.11 */ #ifdef CONFIG_X86 /* * If we're the non-boot CPU, nothing set the stack canary up * for us. The boot CPU already has it initialized but no harm * in doing it again. This is a good place for updating it, as * we wont ever return from this function (so the invalid * canaries already on the stack wont ever trigger). */ boot_init_stack_canary(); #endif |
cf37b6b48
|
333 |
arch_cpu_idle_prepare(); |
8df3e07e7
|
334 |
cpuhp_online_idle(state); |
c1de45ca8
|
335 336 |
while (1) do_idle(); |
cf37b6b48
|
337 |
} |