Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Common SMP CPU bringup/teardown functions
4 : : */
5 : : #include <linux/cpu.h>
6 : : #include <linux/err.h>
7 : : #include <linux/smp.h>
8 : : #include <linux/delay.h>
9 : : #include <linux/init.h>
10 : : #include <linux/list.h>
11 : : #include <linux/slab.h>
12 : : #include <linux/sched.h>
13 : : #include <linux/sched/task.h>
14 : : #include <linux/export.h>
15 : : #include <linux/percpu.h>
16 : : #include <linux/kthread.h>
17 : : #include <linux/smpboot.h>
18 : :
19 : : #include "smpboot.h"
20 : :
21 : : #ifdef CONFIG_SMP
22 : :
23 : : #ifdef CONFIG_GENERIC_SMP_IDLE_THREAD
24 : : /*
25 : : * For the hotplug case we keep the task structs around and reuse
26 : : * them.
27 : : */
28 : : static DEFINE_PER_CPU(struct task_struct *, idle_threads);
29 : :
30 : 0 : struct task_struct *idle_thread_get(unsigned int cpu)
31 : : {
32 : 0 : struct task_struct *tsk = per_cpu(idle_threads, cpu);
33 : :
34 [ # # ]: 0 : if (!tsk)
35 : : return ERR_PTR(-ENOMEM);
36 : 0 : init_idle(tsk, cpu);
37 : 0 : return tsk;
38 : : }
39 : :
40 : 13 : void __init idle_thread_set_boot_cpu(void)
41 : : {
42 : 13 : per_cpu(idle_threads, smp_processor_id()) = current;
43 : 13 : }
44 : :
45 : : /**
46 : : * idle_init - Initialize the idle thread for a cpu
47 : : * @cpu: The cpu for which the idle thread should be initialized
48 : : *
49 : : * Creates the thread if it does not exist.
50 : : */
51 : 0 : static inline void idle_init(unsigned int cpu)
52 : : {
53 : 0 : struct task_struct *tsk = per_cpu(idle_threads, cpu);
54 : :
55 [ # # ]: 0 : if (!tsk) {
56 : 0 : tsk = fork_idle(cpu);
57 [ # # ]: 0 : if (IS_ERR(tsk))
58 : 0 : pr_err("SMP: fork_idle() failed for CPU %u\n", cpu);
59 : : else
60 : 0 : per_cpu(idle_threads, cpu) = tsk;
61 : : }
62 : 0 : }
63 : :
64 : : /**
65 : : * idle_threads_init - Initialize idle threads for all cpus
66 : : */
67 : 13 : void __init idle_threads_init(void)
68 : : {
69 : 13 : unsigned int cpu, boot_cpu;
70 : :
71 : 13 : boot_cpu = smp_processor_id();
72 : :
73 [ + + ]: 26 : for_each_possible_cpu(cpu) {
74 [ - + ]: 13 : if (cpu != boot_cpu)
75 : 0 : idle_init(cpu);
76 : : }
77 : 13 : }
78 : : #endif
79 : :
80 : : #endif /* #ifdef CONFIG_SMP */
81 : :
82 : : static LIST_HEAD(hotplug_threads);
83 : : static DEFINE_MUTEX(smpboot_threads_lock);
84 : :
85 : : struct smpboot_thread_data {
86 : : unsigned int cpu;
87 : : unsigned int status;
88 : : struct smp_hotplug_thread *ht;
89 : : };
90 : :
91 : : enum {
92 : : HP_THREAD_NONE = 0,
93 : : HP_THREAD_ACTIVE,
94 : : HP_THREAD_PARKED,
95 : : };
96 : :
97 : : /**
98 : : * smpboot_thread_fn - percpu hotplug thread loop function
99 : : * @data: thread data pointer
100 : : *
101 : : * Checks for thread stop and park conditions. Calls the necessary
102 : : * setup, cleanup, park and unpark functions for the registered
103 : : * thread.
104 : : *
105 : : * Returns 1 when the thread should exit, 0 otherwise.
106 : : */
107 : 39 : static int smpboot_thread_fn(void *data)
108 : : {
109 : 39 : struct smpboot_thread_data *td = data;
110 : 39 : struct smp_hotplug_thread *ht = td->ht;
111 : :
112 : 28181 : while (1) {
113 : 28181 : set_current_state(TASK_INTERRUPTIBLE);
114 : 28181 : preempt_disable();
115 [ - + ]: 28181 : if (kthread_should_stop()) {
116 : 0 : __set_current_state(TASK_RUNNING);
117 : 0 : preempt_enable();
118 : : /* cleanup must mirror setup */
119 [ # # # # ]: 0 : if (ht->cleanup && td->status != HP_THREAD_NONE)
120 : 0 : ht->cleanup(td->cpu, cpu_online(td->cpu));
121 : 0 : kfree(td);
122 : 0 : return 0;
123 : : }
124 : :
125 [ - + ]: 28181 : if (kthread_should_park()) {
126 : 0 : __set_current_state(TASK_RUNNING);
127 : 0 : preempt_enable();
128 [ # # # # ]: 0 : if (ht->park && td->status == HP_THREAD_ACTIVE) {
129 [ # # ]: 0 : BUG_ON(td->cpu != smp_processor_id());
130 : 0 : ht->park(td->cpu);
131 : 0 : td->status = HP_THREAD_PARKED;
132 : : }
133 : 0 : kthread_parkme();
134 : : /* We might have been woken for stop */
135 : 0 : continue;
136 : : }
137 : :
138 [ - + ]: 28181 : BUG_ON(td->cpu != smp_processor_id());
139 : :
140 : : /* Check for state change setup */
141 [ + - + ]: 28181 : switch (td->status) {
142 : : case HP_THREAD_NONE:
143 : 39 : __set_current_state(TASK_RUNNING);
144 : 39 : preempt_enable();
145 [ - + ]: 39 : if (ht->setup)
146 : 0 : ht->setup(td->cpu);
147 : 39 : td->status = HP_THREAD_ACTIVE;
148 : 39 : continue;
149 : :
150 : : case HP_THREAD_PARKED:
151 : 0 : __set_current_state(TASK_RUNNING);
152 : 0 : preempt_enable();
153 [ # # ]: 0 : if (ht->unpark)
154 : 0 : ht->unpark(td->cpu);
155 : 0 : td->status = HP_THREAD_ACTIVE;
156 : 0 : continue;
157 : : }
158 : :
159 [ + + ]: 28142 : if (!ht->thread_should_run(td->cpu)) {
160 : 12197 : preempt_enable_no_resched();
161 : 12197 : schedule();
162 : : } else {
163 : 15945 : __set_current_state(TASK_RUNNING);
164 : 15945 : preempt_enable();
165 : 15945 : ht->thread_fn(td->cpu);
166 : : }
167 : : }
168 : : }
169 : :
170 : : static int
171 : 39 : __smpboot_create_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
172 : : {
173 : 39 : struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
174 : 39 : struct smpboot_thread_data *td;
175 : :
176 [ + - ]: 39 : if (tsk)
177 : : return 0;
178 : :
179 : 39 : td = kzalloc_node(sizeof(*td), GFP_KERNEL, cpu_to_node(cpu));
180 [ + - ]: 39 : if (!td)
181 : : return -ENOMEM;
182 : 39 : td->cpu = cpu;
183 : 39 : td->ht = ht;
184 : :
185 : 39 : tsk = kthread_create_on_cpu(smpboot_thread_fn, td, cpu,
186 : : ht->thread_comm);
187 [ - + ]: 39 : if (IS_ERR(tsk)) {
188 : 0 : kfree(td);
189 : 0 : return PTR_ERR(tsk);
190 : : }
191 : : /*
192 : : * Park the thread so that it could start right on the CPU
193 : : * when it is available.
194 : : */
195 : 39 : kthread_park(tsk);
196 : 39 : get_task_struct(tsk);
197 : 39 : *per_cpu_ptr(ht->store, cpu) = tsk;
198 [ + + ]: 39 : if (ht->create) {
199 : : /*
200 : : * Make sure that the task has actually scheduled out
201 : : * into park position, before calling the create
202 : : * callback. At least the migration thread callback
203 : : * requires that the task is off the runqueue.
204 : : */
205 [ - + ]: 26 : if (!wait_task_inactive(tsk, TASK_PARKED))
206 : 0 : WARN_ON(1);
207 : : else
208 : 26 : ht->create(cpu);
209 : : }
210 : : return 0;
211 : : }
212 : :
213 : 0 : int smpboot_create_threads(unsigned int cpu)
214 : : {
215 : 0 : struct smp_hotplug_thread *cur;
216 : 0 : int ret = 0;
217 : :
218 : 0 : mutex_lock(&smpboot_threads_lock);
219 [ # # ]: 0 : list_for_each_entry(cur, &hotplug_threads, list) {
220 : 0 : ret = __smpboot_create_thread(cur, cpu);
221 [ # # ]: 0 : if (ret)
222 : : break;
223 : : }
224 : 0 : mutex_unlock(&smpboot_threads_lock);
225 : 0 : return ret;
226 : : }
227 : :
228 : 39 : static void smpboot_unpark_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
229 : : {
230 : 39 : struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
231 : :
232 : 39 : if (!ht->selfparking)
233 : 13 : kthread_unpark(tsk);
234 : : }
235 : :
236 : 0 : int smpboot_unpark_threads(unsigned int cpu)
237 : : {
238 : 0 : struct smp_hotplug_thread *cur;
239 : :
240 : 0 : mutex_lock(&smpboot_threads_lock);
241 [ # # ]: 0 : list_for_each_entry(cur, &hotplug_threads, list)
242 [ # # ]: 0 : smpboot_unpark_thread(cur, cpu);
243 : 0 : mutex_unlock(&smpboot_threads_lock);
244 : 0 : return 0;
245 : : }
246 : :
247 : 0 : static void smpboot_park_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
248 : : {
249 : 0 : struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
250 : :
251 [ # # ]: 0 : if (tsk && !ht->selfparking)
252 : 0 : kthread_park(tsk);
253 : : }
254 : :
255 : 0 : int smpboot_park_threads(unsigned int cpu)
256 : : {
257 : 0 : struct smp_hotplug_thread *cur;
258 : :
259 : 0 : mutex_lock(&smpboot_threads_lock);
260 [ # # ]: 0 : list_for_each_entry_reverse(cur, &hotplug_threads, list)
261 [ # # ]: 0 : smpboot_park_thread(cur, cpu);
262 : 0 : mutex_unlock(&smpboot_threads_lock);
263 : 0 : return 0;
264 : : }
265 : :
266 : : static void smpboot_destroy_threads(struct smp_hotplug_thread *ht)
267 : : {
268 : : unsigned int cpu;
269 : :
270 : : /* We need to destroy also the parked threads of offline cpus */
271 : : for_each_possible_cpu(cpu) {
272 : : struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
273 : :
274 : : if (tsk) {
275 : : kthread_stop(tsk);
276 : : put_task_struct(tsk);
277 : : *per_cpu_ptr(ht->store, cpu) = NULL;
278 : : }
279 : : }
280 : : }
281 : :
282 : : /**
283 : : * smpboot_register_percpu_thread - Register a per_cpu thread related
284 : : * to hotplug
285 : : * @plug_thread: Hotplug thread descriptor
286 : : *
287 : : * Creates and starts the threads on all online cpus.
288 : : */
289 : 39 : int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread)
290 : : {
291 : 39 : unsigned int cpu;
292 : 39 : int ret = 0;
293 : :
294 : 39 : get_online_cpus();
295 : 39 : mutex_lock(&smpboot_threads_lock);
296 [ + + ]: 117 : for_each_online_cpu(cpu) {
297 : 39 : ret = __smpboot_create_thread(plug_thread, cpu);
298 [ - + ]: 39 : if (ret) {
299 : 0 : smpboot_destroy_threads(plug_thread);
300 : 0 : goto out;
301 : : }
302 [ + + ]: 39 : smpboot_unpark_thread(plug_thread, cpu);
303 : : }
304 : 39 : list_add(&plug_thread->list, &hotplug_threads);
305 : 39 : out:
306 : 39 : mutex_unlock(&smpboot_threads_lock);
307 : 39 : put_online_cpus();
308 : 39 : return ret;
309 : : }
310 : : EXPORT_SYMBOL_GPL(smpboot_register_percpu_thread);
311 : :
312 : : /**
313 : : * smpboot_unregister_percpu_thread - Unregister a per_cpu thread related to hotplug
314 : : * @plug_thread: Hotplug thread descriptor
315 : : *
316 : : * Stops all threads on all possible cpus.
317 : : */
318 : 0 : void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread)
319 : : {
320 : 0 : get_online_cpus();
321 : 0 : mutex_lock(&smpboot_threads_lock);
322 : 0 : list_del(&plug_thread->list);
323 : 0 : smpboot_destroy_threads(plug_thread);
324 : 0 : mutex_unlock(&smpboot_threads_lock);
325 : 0 : put_online_cpus();
326 : 0 : }
327 : : EXPORT_SYMBOL_GPL(smpboot_unregister_percpu_thread);
328 : :
329 : : static DEFINE_PER_CPU(atomic_t, cpu_hotplug_state) = ATOMIC_INIT(CPU_POST_DEAD);
330 : :
331 : : /*
332 : : * Called to poll specified CPU's state, for example, when waiting for
333 : : * a CPU to come online.
334 : : */
335 : 0 : int cpu_report_state(int cpu)
336 : : {
337 : 0 : return atomic_read(&per_cpu(cpu_hotplug_state, cpu));
338 : : }
339 : :
340 : : /*
341 : : * If CPU has died properly, set its state to CPU_UP_PREPARE and
342 : : * return success. Otherwise, return -EBUSY if the CPU died after
343 : : * cpu_wait_death() timed out. And yet otherwise again, return -EAGAIN
344 : : * if cpu_wait_death() timed out and the CPU still hasn't gotten around
345 : : * to dying. In the latter two cases, the CPU might not be set up
346 : : * properly, but it is up to the arch-specific code to decide.
347 : : * Finally, -EIO indicates an unanticipated problem.
348 : : *
349 : : * Note that it is permissible to omit this call entirely, as is
350 : : * done in architectures that do no CPU-hotplug error checking.
351 : : */
352 : 0 : int cpu_check_up_prepare(int cpu)
353 : : {
354 : 0 : if (!IS_ENABLED(CONFIG_HOTPLUG_CPU)) {
355 : : atomic_set(&per_cpu(cpu_hotplug_state, cpu), CPU_UP_PREPARE);
356 : : return 0;
357 : : }
358 : :
359 [ # # # # ]: 0 : switch (atomic_read(&per_cpu(cpu_hotplug_state, cpu))) {
360 : :
361 : 0 : case CPU_POST_DEAD:
362 : :
363 : : /* The CPU died properly, so just start it up again. */
364 : 0 : atomic_set(&per_cpu(cpu_hotplug_state, cpu), CPU_UP_PREPARE);
365 : 0 : return 0;
366 : :
367 : : case CPU_DEAD_FROZEN:
368 : :
369 : : /*
370 : : * Timeout during CPU death, so let caller know.
371 : : * The outgoing CPU completed its processing, but after
372 : : * cpu_wait_death() timed out and reported the error. The
373 : : * caller is free to proceed, in which case the state
374 : : * will be reset properly by cpu_set_state_online().
375 : : * Proceeding despite this -EBUSY return makes sense
376 : : * for systems where the outgoing CPUs take themselves
377 : : * offline, with no post-death manipulation required from
378 : : * a surviving CPU.
379 : : */
380 : : return -EBUSY;
381 : :
382 : 0 : case CPU_BROKEN:
383 : :
384 : : /*
385 : : * The most likely reason we got here is that there was
386 : : * a timeout during CPU death, and the outgoing CPU never
387 : : * did complete its processing. This could happen on
388 : : * a virtualized system if the outgoing VCPU gets preempted
389 : : * for more than five seconds, and the user attempts to
390 : : * immediately online that same CPU. Trying again later
391 : : * might return -EBUSY above, hence -EAGAIN.
392 : : */
393 : 0 : return -EAGAIN;
394 : :
395 : 0 : default:
396 : :
397 : : /* Should not happen. Famous last words. */
398 : 0 : return -EIO;
399 : : }
400 : : }
401 : :
402 : : /*
403 : : * Mark the specified CPU online.
404 : : *
405 : : * Note that it is permissible to omit this call entirely, as is
406 : : * done in architectures that do no CPU-hotplug error checking.
407 : : */
408 : 13 : void cpu_set_state_online(int cpu)
409 : : {
410 : 13 : (void)atomic_xchg(&per_cpu(cpu_hotplug_state, cpu), CPU_ONLINE);
411 : 13 : }
412 : :
413 : : #ifdef CONFIG_HOTPLUG_CPU
414 : :
415 : : /*
416 : : * Wait for the specified CPU to exit the idle loop and die.
417 : : */
418 : 0 : bool cpu_wait_death(unsigned int cpu, int seconds)
419 : : {
420 : 0 : int jf_left = seconds * HZ;
421 : 0 : int oldstate;
422 : 0 : bool ret = true;
423 : 0 : int sleep_jf = 1;
424 : :
425 : 0 : might_sleep();
426 : :
427 : : /* The outgoing CPU will normally get done quite quickly. */
428 [ # # ]: 0 : if (atomic_read(&per_cpu(cpu_hotplug_state, cpu)) == CPU_DEAD)
429 : 0 : goto update_state;
430 : 0 : udelay(5);
431 : :
432 : : /* But if the outgoing CPU dawdles, wait increasingly long times. */
433 [ # # ]: 0 : while (atomic_read(&per_cpu(cpu_hotplug_state, cpu)) != CPU_DEAD) {
434 : 0 : schedule_timeout_uninterruptible(sleep_jf);
435 : 0 : jf_left -= sleep_jf;
436 [ # # ]: 0 : if (jf_left <= 0)
437 : : break;
438 : 0 : sleep_jf = DIV_ROUND_UP(sleep_jf * 11, 10);
439 : : }
440 : 0 : update_state:
441 : 0 : oldstate = atomic_read(&per_cpu(cpu_hotplug_state, cpu));
442 [ # # ]: 0 : if (oldstate == CPU_DEAD) {
443 : : /* Outgoing CPU died normally, update state. */
444 : 0 : smp_mb(); /* atomic_read() before update. */
445 : 0 : atomic_set(&per_cpu(cpu_hotplug_state, cpu), CPU_POST_DEAD);
446 : : } else {
447 : : /* Outgoing CPU still hasn't died, set state accordingly. */
448 [ # # ]: 0 : if (atomic_cmpxchg(&per_cpu(cpu_hotplug_state, cpu),
449 : : oldstate, CPU_BROKEN) != oldstate)
450 : 0 : goto update_state;
451 : : ret = false;
452 : : }
453 : 0 : return ret;
454 : : }
455 : :
456 : : /*
457 : : * Called by the outgoing CPU to report its successful death. Return
458 : : * false if this report follows the surviving CPU's timing out.
459 : : *
460 : : * A separate "CPU_DEAD_FROZEN" is used when the surviving CPU
461 : : * timed out. This approach allows architectures to omit calls to
462 : : * cpu_check_up_prepare() and cpu_set_state_online() without defeating
463 : : * the next cpu_wait_death()'s polling loop.
464 : : */
465 : 0 : bool cpu_report_death(void)
466 : : {
467 : 0 : int oldstate;
468 : 0 : int newstate;
469 : 0 : int cpu = smp_processor_id();
470 : :
471 : 0 : do {
472 : 0 : oldstate = atomic_read(&per_cpu(cpu_hotplug_state, cpu));
473 [ # # ]: 0 : if (oldstate != CPU_BROKEN)
474 : : newstate = CPU_DEAD;
475 : : else
476 : 0 : newstate = CPU_DEAD_FROZEN;
477 : 0 : } while (atomic_cmpxchg(&per_cpu(cpu_hotplug_state, cpu),
478 [ # # ]: 0 : oldstate, newstate) != oldstate);
479 : 0 : return newstate == CPU_DEAD;
480 : : }
481 : :
482 : : #endif /* #ifdef CONFIG_HOTPLUG_CPU */
|
