Blame view
kernel/stop_machine.c
17.2 KB
6ff3f917e treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
1142d8102 cpu_stop: impleme... |
2 3 4 5 6 7 8 |
/* * kernel/stop_machine.c * * Copyright (C) 2008, 2005 IBM Corporation. * Copyright (C) 2008, 2005 Rusty Russell rusty@rustcorp.com.au * Copyright (C) 2010 SUSE Linux Products GmbH * Copyright (C) 2010 Tejun Heo <tj@kernel.org> |
e5582ca21 [PATCH] stop_mach... |
9 |
*/ |
b1fc58333 stop_machine: Avo... |
10 |
#include <linux/compiler.h> |
1142d8102 cpu_stop: impleme... |
11 |
#include <linux/completion.h> |
1da177e4c Linux-2.6.12-rc2 |
12 |
#include <linux/cpu.h> |
1142d8102 cpu_stop: impleme... |
13 |
#include <linux/init.h> |
ee527cd3a Use stop_machine_... |
14 |
#include <linux/kthread.h> |
9984de1a5 kernel: Map most ... |
15 |
#include <linux/export.h> |
1142d8102 cpu_stop: impleme... |
16 |
#include <linux/percpu.h> |
ee527cd3a Use stop_machine_... |
17 18 |
#include <linux/sched.h> #include <linux/stop_machine.h> |
a12bb4447 stop_machine() no... |
19 |
#include <linux/interrupt.h> |
1142d8102 cpu_stop: impleme... |
20 |
#include <linux/kallsyms.h> |
14e568e78 stop_machine: Use... |
21 |
#include <linux/smpboot.h> |
60063497a atomic: use <linu... |
22 |
#include <linux/atomic.h> |
ce4f06dcb stop_machine: Tou... |
23 |
#include <linux/nmi.h> |
0b26351b9 stop_machine, sch... |
24 |
#include <linux/sched/wake_q.h> |
1142d8102 cpu_stop: impleme... |
25 26 27 28 29 30 31 |
/* * Structure to determine completion condition and record errors. May * be shared by works on different cpus. */ struct cpu_stop_done { atomic_t nr_todo; /* nr left to execute */ |
1142d8102 cpu_stop: impleme... |
32 33 34 35 36 37 |
int ret; /* collected return value */ struct completion completion; /* fired if nr_todo reaches 0 */ }; /* the actual stopper, one per every possible cpu, enabled on online cpus */ struct cpu_stopper { |
02cb7aa92 stop_machine: Mov... |
38 |
struct task_struct *thread; |
de5b55c1d stop_machine: Use... |
39 |
raw_spinlock_t lock; |
878ae1274 stop_machine: str... |
40 |
bool enabled; /* is this stopper enabled? */ |
1142d8102 cpu_stop: impleme... |
41 |
struct list_head works; /* list of pending works */ |
02cb7aa92 stop_machine: Mov... |
42 43 |
struct cpu_stop_work stop_work; /* for stop_cpus */ |
1142d8102 cpu_stop: impleme... |
44 45 46 |
}; static DEFINE_PER_CPU(struct cpu_stopper, cpu_stopper); |
f445027e4 stop_machine: mak... |
47 |
static bool stop_machine_initialized = false; |
1142d8102 cpu_stop: impleme... |
48 |
|
e62539704 stop_machine: Rem... |
49 50 51 |
/* static data for stop_cpus */ static DEFINE_MUTEX(stop_cpus_mutex); static bool stop_cpus_in_progress; |
7053ea1a3 stop_machine: Fix... |
52 |
|
1142d8102 cpu_stop: impleme... |
53 54 55 56 57 58 59 60 |
static void cpu_stop_init_done(struct cpu_stop_done *done, unsigned int nr_todo) { memset(done, 0, sizeof(*done)); atomic_set(&done->nr_todo, nr_todo); init_completion(&done->completion); } /* signal completion unless @done is NULL */ |
6fa3b826b stop_machine: Kil... |
61 |
static void cpu_stop_signal_done(struct cpu_stop_done *done) |
1142d8102 cpu_stop: impleme... |
62 |
{ |
dd2e3121e stop_machine: Shi... |
63 64 |
if (atomic_dec_and_test(&done->nr_todo)) complete(&done->completion); |
1142d8102 cpu_stop: impleme... |
65 |
} |
5caa1c089 stop_machine: Int... |
66 |
static void __cpu_stop_queue_work(struct cpu_stopper *stopper, |
0b26351b9 stop_machine, sch... |
67 68 |
struct cpu_stop_work *work, struct wake_q_head *wakeq) |
5caa1c089 stop_machine: Int... |
69 70 |
{ list_add_tail(&work->list, &stopper->works); |
0b26351b9 stop_machine, sch... |
71 |
wake_q_add(wakeq, stopper->thread); |
5caa1c089 stop_machine: Int... |
72 |
} |
1142d8102 cpu_stop: impleme... |
73 |
/* queue @work to @stopper. if offline, @work is completed immediately */ |
1b034bd98 stop_machine: Mak... |
74 |
static bool cpu_stop_queue_work(unsigned int cpu, struct cpu_stop_work *work) |
1142d8102 cpu_stop: impleme... |
75 |
{ |
860a0ffaa stop_machine: Sto... |
76 |
struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); |
0b26351b9 stop_machine, sch... |
77 |
DEFINE_WAKE_Q(wakeq); |
1142d8102 cpu_stop: impleme... |
78 |
unsigned long flags; |
1b034bd98 stop_machine: Mak... |
79 |
bool enabled; |
1142d8102 cpu_stop: impleme... |
80 |
|
cfd355145 stop_machine: Ato... |
81 |
preempt_disable(); |
de5b55c1d stop_machine: Use... |
82 |
raw_spin_lock_irqsave(&stopper->lock, flags); |
1b034bd98 stop_machine: Mak... |
83 84 |
enabled = stopper->enabled; if (enabled) |
0b26351b9 stop_machine, sch... |
85 |
__cpu_stop_queue_work(stopper, work, &wakeq); |
dd2e3121e stop_machine: Shi... |
86 |
else if (work->done) |
6fa3b826b stop_machine: Kil... |
87 |
cpu_stop_signal_done(work->done); |
de5b55c1d stop_machine: Use... |
88 |
raw_spin_unlock_irqrestore(&stopper->lock, flags); |
1b034bd98 stop_machine: Mak... |
89 |
|
0b26351b9 stop_machine, sch... |
90 |
wake_up_q(&wakeq); |
cfd355145 stop_machine: Ato... |
91 |
preempt_enable(); |
0b26351b9 stop_machine, sch... |
92 |
|
1b034bd98 stop_machine: Mak... |
93 |
return enabled; |
1142d8102 cpu_stop: impleme... |
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 |
} /** * stop_one_cpu - stop a cpu * @cpu: cpu to stop * @fn: function to execute * @arg: argument to @fn * * Execute @fn(@arg) on @cpu. @fn is run in a process context with * the highest priority preempting any task on the cpu and * monopolizing it. This function returns after the execution is * complete. * * This function doesn't guarantee @cpu stays online till @fn * completes. If @cpu goes down in the middle, execution may happen * partially or fully on different cpus. @fn should either be ready * for that or the caller should ensure that @cpu stays online until * this function completes. * * CONTEXT: * Might sleep. * * RETURNS: * -ENOENT if @fn(@arg) was not executed because @cpu was offline; * otherwise, the return value of @fn. */ int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg) { struct cpu_stop_done done; struct cpu_stop_work work = { .fn = fn, .arg = arg, .done = &done }; cpu_stop_init_done(&done, 1); |
958c5f848 stop_machine: Cha... |
126 127 |
if (!cpu_stop_queue_work(cpu, &work)) return -ENOENT; |
bf89a3047 stop_machine: Avo... |
128 129 130 131 132 |
/* * In case @cpu == smp_proccessor_id() we can avoid a sleep+wakeup * cycle by doing a preemption: */ cond_resched(); |
1142d8102 cpu_stop: impleme... |
133 |
wait_for_completion(&done.completion); |
958c5f848 stop_machine: Cha... |
134 |
return done.ret; |
1142d8102 cpu_stop: impleme... |
135 |
} |
1be0bd77c stop_machine: Int... |
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 |
/* This controls the threads on each CPU. */ enum multi_stop_state { /* Dummy starting state for thread. */ MULTI_STOP_NONE, /* Awaiting everyone to be scheduled. */ MULTI_STOP_PREPARE, /* Disable interrupts. */ MULTI_STOP_DISABLE_IRQ, /* Run the function */ MULTI_STOP_RUN, /* Exit */ MULTI_STOP_EXIT, }; struct multi_stop_data { |
9a301f22f stop_machine: Use... |
151 |
cpu_stop_fn_t fn; |
1be0bd77c stop_machine: Int... |
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
void *data; /* Like num_online_cpus(), but hotplug cpu uses us, so we need this. */ unsigned int num_threads; const struct cpumask *active_cpus; enum multi_stop_state state; atomic_t thread_ack; }; static void set_state(struct multi_stop_data *msdata, enum multi_stop_state newstate) { /* Reset ack counter. */ atomic_set(&msdata->thread_ack, msdata->num_threads); smp_wmb(); |
b1fc58333 stop_machine: Avo... |
167 |
WRITE_ONCE(msdata->state, newstate); |
1be0bd77c stop_machine: Int... |
168 169 170 171 172 173 174 175 |
} /* Last one to ack a state moves to the next state. */ static void ack_state(struct multi_stop_data *msdata) { if (atomic_dec_and_test(&msdata->thread_ack)) set_state(msdata, msdata->state + 1); } |
4ecf0a43e processor: get ri... |
176 177 178 179 |
void __weak stop_machine_yield(const struct cpumask *cpumask) { cpu_relax(); } |
1be0bd77c stop_machine: Int... |
180 181 182 183 |
/* This is the cpu_stop function which stops the CPU. */ static int multi_cpu_stop(void *data) { struct multi_stop_data *msdata = data; |
b1fc58333 stop_machine: Avo... |
184 |
enum multi_stop_state newstate, curstate = MULTI_STOP_NONE; |
1be0bd77c stop_machine: Int... |
185 |
int cpu = smp_processor_id(), err = 0; |
38f2c691a s390: improve wai... |
186 |
const struct cpumask *cpumask; |
1be0bd77c stop_machine: Int... |
187 188 189 190 191 192 193 194 |
unsigned long flags; bool is_active; /* * When called from stop_machine_from_inactive_cpu(), irq might * already be disabled. Save the state and restore it on exit. */ local_save_flags(flags); |
38f2c691a s390: improve wai... |
195 196 197 198 199 200 201 |
if (!msdata->active_cpus) { cpumask = cpu_online_mask; is_active = cpu == cpumask_first(cpumask); } else { cpumask = msdata->active_cpus; is_active = cpumask_test_cpu(cpu, cpumask); } |
1be0bd77c stop_machine: Int... |
202 203 204 205 |
/* Simple state machine */ do { /* Chill out and ensure we re-read multi_stop_state. */ |
4ecf0a43e processor: get ri... |
206 |
stop_machine_yield(cpumask); |
b1fc58333 stop_machine: Avo... |
207 208 209 |
newstate = READ_ONCE(msdata->state); if (newstate != curstate) { curstate = newstate; |
1be0bd77c stop_machine: Int... |
210 211 212 213 214 215 216 217 218 219 220 221 222 |
switch (curstate) { case MULTI_STOP_DISABLE_IRQ: local_irq_disable(); hard_irq_disable(); break; case MULTI_STOP_RUN: if (is_active) err = msdata->fn(msdata->data); break; default: break; } ack_state(msdata); |
ce4f06dcb stop_machine: Tou... |
223 224 225 226 227 228 229 |
} else if (curstate > MULTI_STOP_PREPARE) { /* * At this stage all other CPUs we depend on must spin * in the same loop. Any reason for hard-lockup should * be detected and reported on their side. */ touch_nmi_watchdog(); |
1be0bd77c stop_machine: Int... |
230 |
} |
366237e7b stop_machine: Pro... |
231 |
rcu_momentary_dyntick_idle(); |
1be0bd77c stop_machine: Int... |
232 233 234 235 236 |
} while (curstate != MULTI_STOP_EXIT); local_irq_restore(flags); return err; } |
5caa1c089 stop_machine: Int... |
237 238 239 |
static int cpu_stop_queue_two_works(int cpu1, struct cpu_stop_work *work1, int cpu2, struct cpu_stop_work *work2) { |
d8bc85358 stop_machine: Cha... |
240 241 |
struct cpu_stopper *stopper1 = per_cpu_ptr(&cpu_stopper, cpu1); struct cpu_stopper *stopper2 = per_cpu_ptr(&cpu_stopper, cpu2); |
0b26351b9 stop_machine, sch... |
242 |
DEFINE_WAKE_Q(wakeq); |
d8bc85358 stop_machine: Cha... |
243 |
int err; |
b80a2bfce stop_machine: Ref... |
244 |
|
e62539704 stop_machine: Rem... |
245 |
retry: |
b80a2bfce stop_machine: Ref... |
246 247 248 249 250 251 252 253 |
/* * The waking up of stopper threads has to happen in the same * scheduling context as the queueing. Otherwise, there is a * possibility of one of the above stoppers being woken up by another * CPU, and preempting us. This will cause us to not wake up the other * stopper forever. */ preempt_disable(); |
de5b55c1d stop_machine: Use... |
254 255 |
raw_spin_lock_irq(&stopper1->lock); raw_spin_lock_nested(&stopper2->lock, SINGLE_DEPTH_NESTING); |
d8bc85358 stop_machine: Cha... |
256 |
|
b80a2bfce stop_machine: Ref... |
257 258 |
if (!stopper1->enabled || !stopper2->enabled) { err = -ENOENT; |
d8bc85358 stop_machine: Cha... |
259 |
goto unlock; |
b80a2bfce stop_machine: Ref... |
260 |
} |
e62539704 stop_machine: Rem... |
261 262 263 264 265 266 267 268 269 270 |
/* * Ensure that if we race with __stop_cpus() the stoppers won't get * queued up in reverse order leading to system deadlock. * * We can't miss stop_cpus_in_progress if queue_stop_cpus_work() has * queued a work on cpu1 but not on cpu2, we hold both locks. * * It can be falsely true but it is safe to spin until it is cleared, * queue_stop_cpus_work() does everything under preempt_disable(). */ |
b80a2bfce stop_machine: Ref... |
271 272 273 274 |
if (unlikely(stop_cpus_in_progress)) { err = -EDEADLK; goto unlock; } |
d8bc85358 stop_machine: Cha... |
275 276 |
err = 0; |
0b26351b9 stop_machine, sch... |
277 278 |
__cpu_stop_queue_work(stopper1, work1, &wakeq); __cpu_stop_queue_work(stopper2, work2, &wakeq); |
b80a2bfce stop_machine: Ref... |
279 |
|
d8bc85358 stop_machine: Cha... |
280 |
unlock: |
de5b55c1d stop_machine: Use... |
281 282 |
raw_spin_unlock(&stopper2->lock); raw_spin_unlock_irq(&stopper1->lock); |
5caa1c089 stop_machine: Int... |
283 |
|
e62539704 stop_machine: Rem... |
284 |
if (unlikely(err == -EDEADLK)) { |
b80a2bfce stop_machine: Ref... |
285 |
preempt_enable(); |
e62539704 stop_machine: Rem... |
286 287 |
while (stop_cpus_in_progress) cpu_relax(); |
b80a2bfce stop_machine: Ref... |
288 |
|
e62539704 stop_machine: Rem... |
289 290 |
goto retry; } |
0b26351b9 stop_machine, sch... |
291 |
|
b80a2bfce stop_machine: Ref... |
292 293 |
wake_up_q(&wakeq); preempt_enable(); |
0b26351b9 stop_machine, sch... |
294 |
|
d8bc85358 stop_machine: Cha... |
295 |
return err; |
5caa1c089 stop_machine: Int... |
296 |
} |
1be0bd77c stop_machine: Int... |
297 298 299 300 301 302 303 304 305 306 307 308 309 |
/** * stop_two_cpus - stops two cpus * @cpu1: the cpu to stop * @cpu2: the other cpu to stop * @fn: function to execute * @arg: argument to @fn * * Stops both the current and specified CPU and runs @fn on one of them. * * returns when both are completed. */ int stop_two_cpus(unsigned int cpu1, unsigned int cpu2, cpu_stop_fn_t fn, void *arg) { |
1be0bd77c stop_machine: Int... |
310 311 |
struct cpu_stop_done done; struct cpu_stop_work work1, work2; |
6acce3ef8 sched: Remove get... |
312 |
struct multi_stop_data msdata; |
6acce3ef8 sched: Remove get... |
313 |
msdata = (struct multi_stop_data){ |
1be0bd77c stop_machine: Int... |
314 315 316 317 318 319 320 321 322 323 324 |
.fn = fn, .data = arg, .num_threads = 2, .active_cpus = cpumask_of(cpu1), }; work1 = work2 = (struct cpu_stop_work){ .fn = multi_cpu_stop, .arg = &msdata, .done = &done }; |
1be0bd77c stop_machine: Int... |
325 326 |
cpu_stop_init_done(&done, 2); set_state(&msdata, MULTI_STOP_PREPARE); |
5caa1c089 stop_machine: Int... |
327 328 |
if (cpu1 > cpu2) swap(cpu1, cpu2); |
6a1900515 stop_machine: Don... |
329 |
if (cpu_stop_queue_two_works(cpu1, &work1, cpu2, &work2)) |
5caa1c089 stop_machine: Int... |
330 |
return -ENOENT; |
1be0bd77c stop_machine: Int... |
331 332 |
wait_for_completion(&done.completion); |
6a1900515 stop_machine: Don... |
333 |
return done.ret; |
1be0bd77c stop_machine: Int... |
334 |
} |
1142d8102 cpu_stop: impleme... |
335 336 337 338 339 |
/** * stop_one_cpu_nowait - stop a cpu but don't wait for completion * @cpu: cpu to stop * @fn: function to execute * @arg: argument to @fn |
cf2500406 kernel/stop_machi... |
340 |
* @work_buf: pointer to cpu_stop_work structure |
1142d8102 cpu_stop: impleme... |
341 342 343 344 345 346 347 |
* * Similar to stop_one_cpu() but doesn't wait for completion. The * caller is responsible for ensuring @work_buf is currently unused * and will remain untouched until stopper starts executing @fn. * * CONTEXT: * Don't care. |
1b034bd98 stop_machine: Mak... |
348 349 350 351 |
* * RETURNS: * true if cpu_stop_work was queued successfully and @fn will be called, * false otherwise. |
1142d8102 cpu_stop: impleme... |
352 |
*/ |
1b034bd98 stop_machine: Mak... |
353 |
bool stop_one_cpu_nowait(unsigned int cpu, cpu_stop_fn_t fn, void *arg, |
1142d8102 cpu_stop: impleme... |
354 355 356 |
struct cpu_stop_work *work_buf) { *work_buf = (struct cpu_stop_work){ .fn = fn, .arg = arg, }; |
1b034bd98 stop_machine: Mak... |
357 |
return cpu_stop_queue_work(cpu, work_buf); |
1142d8102 cpu_stop: impleme... |
358 |
} |
4aff1ca69 stop_machine: Cha... |
359 |
static bool queue_stop_cpus_work(const struct cpumask *cpumask, |
fd7355ba1 stop_machine: reo... |
360 361 |
cpu_stop_fn_t fn, void *arg, struct cpu_stop_done *done) |
1142d8102 cpu_stop: impleme... |
362 363 |
{ struct cpu_stop_work *work; |
1142d8102 cpu_stop: impleme... |
364 |
unsigned int cpu; |
4aff1ca69 stop_machine: Cha... |
365 |
bool queued = false; |
1142d8102 cpu_stop: impleme... |
366 |
|
1142d8102 cpu_stop: impleme... |
367 368 369 370 371 |
/* * Disable preemption while queueing to avoid getting * preempted by a stopper which might wait for other stoppers * to enter @fn which can lead to deadlock. */ |
e62539704 stop_machine: Rem... |
372 373 |
preempt_disable(); stop_cpus_in_progress = true; |
99d84bf8c stop_machine: Fix... |
374 |
barrier(); |
b377c2a08 stop_machine: Don... |
375 376 377 378 379 |
for_each_cpu(cpu, cpumask) { work = &per_cpu(cpu_stopper.stop_work, cpu); work->fn = fn; work->arg = arg; work->done = done; |
4aff1ca69 stop_machine: Cha... |
380 381 |
if (cpu_stop_queue_work(cpu, work)) queued = true; |
b377c2a08 stop_machine: Don... |
382 |
} |
99d84bf8c stop_machine: Fix... |
383 |
barrier(); |
e62539704 stop_machine: Rem... |
384 385 |
stop_cpus_in_progress = false; preempt_enable(); |
4aff1ca69 stop_machine: Cha... |
386 387 |
return queued; |
fd7355ba1 stop_machine: reo... |
388 |
} |
1142d8102 cpu_stop: impleme... |
389 |
|
fd7355ba1 stop_machine: reo... |
390 391 392 393 394 395 |
static int __stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) { struct cpu_stop_done done; cpu_stop_init_done(&done, cpumask_weight(cpumask)); |
4aff1ca69 stop_machine: Cha... |
396 397 |
if (!queue_stop_cpus_work(cpumask, fn, arg, &done)) return -ENOENT; |
1142d8102 cpu_stop: impleme... |
398 |
wait_for_completion(&done.completion); |
4aff1ca69 stop_machine: Cha... |
399 |
return done.ret; |
1142d8102 cpu_stop: impleme... |
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 |
} /** * stop_cpus - stop multiple cpus * @cpumask: cpus to stop * @fn: function to execute * @arg: argument to @fn * * Execute @fn(@arg) on online cpus in @cpumask. On each target cpu, * @fn is run in a process context with the highest priority * preempting any task on the cpu and monopolizing it. This function * returns after all executions are complete. * * This function doesn't guarantee the cpus in @cpumask stay online * till @fn completes. If some cpus go down in the middle, execution * on the cpu may happen partially or fully on different cpus. @fn * should either be ready for that or the caller should ensure that * the cpus stay online until this function completes. * * All stop_cpus() calls are serialized making it safe for @fn to wait * for all cpus to start executing it. * * CONTEXT: * Might sleep. * * RETURNS: * -ENOENT if @fn(@arg) was not executed at all because all cpus in * @cpumask were offline; otherwise, 0 if all executions of @fn * returned 0, any non zero return value if any returned non zero. */ |
35f4cd96f stop_machine: Mak... |
430 |
static int stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) |
1142d8102 cpu_stop: impleme... |
431 432 433 434 435 436 437 438 439 |
{ int ret; /* static works are used, process one request at a time */ mutex_lock(&stop_cpus_mutex); ret = __stop_cpus(cpumask, fn, arg); mutex_unlock(&stop_cpus_mutex); return ret; } |
14e568e78 stop_machine: Use... |
440 441 442 443 444 |
static int cpu_stop_should_run(unsigned int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); unsigned long flags; int run; |
de5b55c1d stop_machine: Use... |
445 |
raw_spin_lock_irqsave(&stopper->lock, flags); |
14e568e78 stop_machine: Use... |
446 |
run = !list_empty(&stopper->works); |
de5b55c1d stop_machine: Use... |
447 |
raw_spin_unlock_irqrestore(&stopper->lock, flags); |
14e568e78 stop_machine: Use... |
448 449 450 451 |
return run; } static void cpu_stopper_thread(unsigned int cpu) |
1142d8102 cpu_stop: impleme... |
452 |
{ |
14e568e78 stop_machine: Use... |
453 |
struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); |
1142d8102 cpu_stop: impleme... |
454 |
struct cpu_stop_work *work; |
1142d8102 cpu_stop: impleme... |
455 456 |
repeat: |
1142d8102 cpu_stop: impleme... |
457 |
work = NULL; |
de5b55c1d stop_machine: Use... |
458 |
raw_spin_lock_irq(&stopper->lock); |
1142d8102 cpu_stop: impleme... |
459 460 461 462 463 |
if (!list_empty(&stopper->works)) { work = list_first_entry(&stopper->works, struct cpu_stop_work, list); list_del_init(&work->list); } |
de5b55c1d stop_machine: Use... |
464 |
raw_spin_unlock_irq(&stopper->lock); |
1142d8102 cpu_stop: impleme... |
465 466 467 468 469 |
if (work) { cpu_stop_fn_t fn = work->fn; void *arg = work->arg; struct cpu_stop_done *done = work->done; |
accaf6ea3 stop_machine: Cle... |
470 |
int ret; |
1142d8102 cpu_stop: impleme... |
471 |
|
accaf6ea3 stop_machine: Cle... |
472 473 |
/* cpu stop callbacks must not sleep, make in_atomic() == T */ preempt_count_inc(); |
1142d8102 cpu_stop: impleme... |
474 |
ret = fn(arg); |
dd2e3121e stop_machine: Shi... |
475 476 477 478 479 |
if (done) { if (ret) done->ret = ret; cpu_stop_signal_done(done); } |
accaf6ea3 stop_machine: Cle... |
480 |
preempt_count_dec(); |
1142d8102 cpu_stop: impleme... |
481 |
WARN_ONCE(preempt_count(), |
d75f773c8 treewide: Switch ... |
482 483 |
"cpu_stop: %ps(%p) leaked preempt count ", fn, arg); |
14e568e78 stop_machine: Use... |
484 485 |
goto repeat; } |
1142d8102 cpu_stop: impleme... |
486 |
} |
233e7f267 stop_machine: Ens... |
487 488 489 490 491 492 493 494 495 496 497 |
void stop_machine_park(int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); /* * Lockless. cpu_stopper_thread() will take stopper->lock and flush * the pending works before it parks, until then it is fine to queue * the new works. */ stopper->enabled = false; kthread_park(stopper->thread); } |
34f971f6f sched: Create spe... |
498 |
extern void sched_set_stop_task(int cpu, struct task_struct *stop); |
14e568e78 stop_machine: Use... |
499 500 |
static void cpu_stop_create(unsigned int cpu) { |
02cb7aa92 stop_machine: Mov... |
501 |
sched_set_stop_task(cpu, per_cpu(cpu_stopper.thread, cpu)); |
14e568e78 stop_machine: Use... |
502 503 504 |
} static void cpu_stop_park(unsigned int cpu) |
1142d8102 cpu_stop: impleme... |
505 |
{ |
1142d8102 cpu_stop: impleme... |
506 |
struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); |
1142d8102 cpu_stop: impleme... |
507 |
|
233e7f267 stop_machine: Ens... |
508 |
WARN_ON(!list_empty(&stopper->works)); |
14e568e78 stop_machine: Use... |
509 |
} |
1142d8102 cpu_stop: impleme... |
510 |
|
c00166d87 stop_machine: Kil... |
511 512 513 |
void stop_machine_unpark(int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); |
f0cf16cbd stop_machine: Kil... |
514 |
stopper->enabled = true; |
c00166d87 stop_machine: Kil... |
515 516 |
kthread_unpark(stopper->thread); } |
14e568e78 stop_machine: Use... |
517 |
static struct smp_hotplug_thread cpu_stop_threads = { |
02cb7aa92 stop_machine: Mov... |
518 |
.store = &cpu_stopper.thread, |
14e568e78 stop_machine: Use... |
519 520 521 522 |
.thread_should_run = cpu_stop_should_run, .thread_fn = cpu_stopper_thread, .thread_comm = "migration/%u", .create = cpu_stop_create, |
14e568e78 stop_machine: Use... |
523 |
.park = cpu_stop_park, |
14e568e78 stop_machine: Use... |
524 |
.selfparking = true, |
1142d8102 cpu_stop: impleme... |
525 526 527 528 |
}; static int __init cpu_stop_init(void) { |
1142d8102 cpu_stop: impleme... |
529 |
unsigned int cpu; |
1142d8102 cpu_stop: impleme... |
530 531 532 |
for_each_possible_cpu(cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); |
de5b55c1d stop_machine: Use... |
533 |
raw_spin_lock_init(&stopper->lock); |
1142d8102 cpu_stop: impleme... |
534 535 |
INIT_LIST_HEAD(&stopper->works); } |
14e568e78 stop_machine: Use... |
536 |
BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); |
c00166d87 stop_machine: Kil... |
537 |
stop_machine_unpark(raw_smp_processor_id()); |
f445027e4 stop_machine: mak... |
538 |
stop_machine_initialized = true; |
1142d8102 cpu_stop: impleme... |
539 540 541 |
return 0; } early_initcall(cpu_stop_init); |
1da177e4c Linux-2.6.12-rc2 |
542 |
|
fe5595c07 stop_machine: Pro... |
543 544 |
int stop_machine_cpuslocked(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus) |
1da177e4c Linux-2.6.12-rc2 |
545 |
{ |
1be0bd77c stop_machine: Int... |
546 547 548 549 550 551 |
struct multi_stop_data msdata = { .fn = fn, .data = data, .num_threads = num_online_cpus(), .active_cpus = cpus, }; |
3fc1f1e27 stop_machine: rei... |
552 |
|
fe5595c07 stop_machine: Pro... |
553 |
lockdep_assert_cpus_held(); |
f445027e4 stop_machine: mak... |
554 555 556 557 558 559 560 561 |
if (!stop_machine_initialized) { /* * Handle the case where stop_machine() is called * early in boot before stop_machine() has been * initialized. */ unsigned long flags; int ret; |
1be0bd77c stop_machine: Int... |
562 |
WARN_ON_ONCE(msdata.num_threads != 1); |
f445027e4 stop_machine: mak... |
563 564 565 566 567 568 569 570 |
local_irq_save(flags); hard_irq_disable(); ret = (*fn)(data); local_irq_restore(flags); return ret; } |
3fc1f1e27 stop_machine: rei... |
571 |
/* Set the initial state and stop all online cpus. */ |
1be0bd77c stop_machine: Int... |
572 573 |
set_state(&msdata, MULTI_STOP_PREPARE); return stop_cpus(cpu_online_mask, multi_cpu_stop, &msdata); |
1da177e4c Linux-2.6.12-rc2 |
574 |
} |
9a301f22f stop_machine: Use... |
575 |
int stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus) |
1da177e4c Linux-2.6.12-rc2 |
576 |
{ |
1da177e4c Linux-2.6.12-rc2 |
577 578 579 |
int ret; /* No CPUs can come up or down during this. */ |
fe5595c07 stop_machine: Pro... |
580 581 582 |
cpus_read_lock(); ret = stop_machine_cpuslocked(fn, data, cpus); cpus_read_unlock(); |
1da177e4c Linux-2.6.12-rc2 |
583 584 |
return ret; } |
eeec4fad9 stop_machine(): s... |
585 |
EXPORT_SYMBOL_GPL(stop_machine); |
bbf1bb3ee cpu_stop: add dum... |
586 |
|
f740e6cd0 stop_machine: imp... |
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 |
/** * stop_machine_from_inactive_cpu - stop_machine() from inactive CPU * @fn: the function to run * @data: the data ptr for the @fn() * @cpus: the cpus to run the @fn() on (NULL = any online cpu) * * This is identical to stop_machine() but can be called from a CPU which * is not active. The local CPU is in the process of hotplug (so no other * CPU hotplug can start) and not marked active and doesn't have enough * context to sleep. * * This function provides stop_machine() functionality for such state by * using busy-wait for synchronization and executing @fn directly for local * CPU. * * CONTEXT: * Local CPU is inactive. Temporarily stops all active CPUs. * * RETURNS: * 0 if all executions of @fn returned 0, any non zero return value if any * returned non zero. */ |
9a301f22f stop_machine: Use... |
609 |
int stop_machine_from_inactive_cpu(cpu_stop_fn_t fn, void *data, |
f740e6cd0 stop_machine: imp... |
610 611 |
const struct cpumask *cpus) { |
1be0bd77c stop_machine: Int... |
612 |
struct multi_stop_data msdata = { .fn = fn, .data = data, |
f740e6cd0 stop_machine: imp... |
613 614 615 616 617 618 |
.active_cpus = cpus }; struct cpu_stop_done done; int ret; /* Local CPU must be inactive and CPU hotplug in progress. */ BUG_ON(cpu_active(raw_smp_processor_id())); |
1be0bd77c stop_machine: Int... |
619 |
msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ |
f740e6cd0 stop_machine: imp... |
620 621 622 623 624 625 |
/* No proper task established and can't sleep - busy wait for lock. */ while (!mutex_trylock(&stop_cpus_mutex)) cpu_relax(); /* Schedule work on other CPUs and execute directly for local CPU */ |
1be0bd77c stop_machine: Int... |
626 |
set_state(&msdata, MULTI_STOP_PREPARE); |
f740e6cd0 stop_machine: imp... |
627 |
cpu_stop_init_done(&done, num_active_cpus()); |
1be0bd77c stop_machine: Int... |
628 |
queue_stop_cpus_work(cpu_active_mask, multi_cpu_stop, &msdata, |
f740e6cd0 stop_machine: imp... |
629 |
&done); |
1be0bd77c stop_machine: Int... |
630 |
ret = multi_cpu_stop(&msdata); |
f740e6cd0 stop_machine: imp... |
631 632 633 634 635 636 637 638 |
/* Busy wait for completion. */ while (!completion_done(&done.completion)) cpu_relax(); mutex_unlock(&stop_cpus_mutex); return ret ?: done.ret; } |