projects/linux·blob v2.6.33-rc7 · refs

568 lines · 13.5 KiB

1/* CPU control.
2 * (C) 2001, 2002, 2003, 2004 Rusty Russell
3 *
4 * This code is licenced under the GPL.
5 */
6#include <linux/proc_fs.h>
7#include <linux/smp.h>
8#include <linux/init.h>
9#include <linux/notifier.h>
10#include <linux/sched.h>
11#include <linux/unistd.h>
12#include <linux/cpu.h>
13#include <linux/module.h>
14#include <linux/kthread.h>
15#include <linux/stop_machine.h>
16#include <linux/mutex.h>
17
18#ifdef CONFIG_SMP
19/* Serializes the updates to cpu_online_mask, cpu_present_mask */
20static DEFINE_MUTEX(cpu_add_remove_lock);
21
22static __cpuinitdata RAW_NOTIFIER_HEAD(cpu_chain);
23
24/* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
25 * Should always be manipulated under cpu_add_remove_lock
26 */
27static int cpu_hotplug_disabled;
28
29static struct {
30 struct task_struct *active_writer;
31 struct mutex lock; /* Synchronizes accesses to refcount, */
32 /*
33 * Also blocks the new readers during
34 * an ongoing cpu hotplug operation.
35 */
36 int refcount;
37} cpu_hotplug = {
38 .active_writer = NULL,
39 .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock),
40 .refcount = 0,
41};
42
43#ifdef CONFIG_HOTPLUG_CPU
44
45void get_online_cpus(void)
46{
47 might_sleep();
48 if (cpu_hotplug.active_writer == current)
49 return;
50 mutex_lock(&cpu_hotplug.lock);
51 cpu_hotplug.refcount++;
52 mutex_unlock(&cpu_hotplug.lock);
53
54}
55EXPORT_SYMBOL_GPL(get_online_cpus);
56
57void put_online_cpus(void)
58{
59 if (cpu_hotplug.active_writer == current)
60 return;
61 mutex_lock(&cpu_hotplug.lock);
62 if (!--cpu_hotplug.refcount && unlikely(cpu_hotplug.active_writer))
63 wake_up_process(cpu_hotplug.active_writer);
64 mutex_unlock(&cpu_hotplug.lock);
65
66}
67EXPORT_SYMBOL_GPL(put_online_cpus);
68
69#endif /* CONFIG_HOTPLUG_CPU */
70
71/*
72 * The following two API's must be used when attempting
73 * to serialize the updates to cpu_online_mask, cpu_present_mask.
74 */
75void cpu_maps_update_begin(void)
76{
77 mutex_lock(&cpu_add_remove_lock);
78}
79
80void cpu_maps_update_done(void)
81{
82 mutex_unlock(&cpu_add_remove_lock);
83}
84
85/*
86 * This ensures that the hotplug operation can begin only when the
87 * refcount goes to zero.
88 *
89 * Note that during a cpu-hotplug operation, the new readers, if any,
90 * will be blocked by the cpu_hotplug.lock
91 *
92 * Since cpu_hotplug_begin() is always called after invoking
93 * cpu_maps_update_begin(), we can be sure that only one writer is active.
94 *
95 * Note that theoretically, there is a possibility of a livelock:
96 * - Refcount goes to zero, last reader wakes up the sleeping
97 * writer.
98 * - Last reader unlocks the cpu_hotplug.lock.
99 * - A new reader arrives at this moment, bumps up the refcount.
100 * - The writer acquires the cpu_hotplug.lock finds the refcount
101 * non zero and goes to sleep again.
102 *
103 * However, this is very difficult to achieve in practice since
104 * get_online_cpus() not an api which is called all that often.
105 *
106 */
107static void cpu_hotplug_begin(void)
108{
109 cpu_hotplug.active_writer = current;
110
111 for (;;) {
112 mutex_lock(&cpu_hotplug.lock);
113 if (likely(!cpu_hotplug.refcount))
114 break;
115 __set_current_state(TASK_UNINTERRUPTIBLE);
116 mutex_unlock(&cpu_hotplug.lock);
117 schedule();
118 }
119}
120
121static void cpu_hotplug_done(void)
122{
123 cpu_hotplug.active_writer = NULL;
124 mutex_unlock(&cpu_hotplug.lock);
125}
126/* Need to know about CPUs going up/down? */
127int __ref register_cpu_notifier(struct notifier_block *nb)
128{
129 int ret;
130 cpu_maps_update_begin();
131 ret = raw_notifier_chain_register(&cpu_chain, nb);
132 cpu_maps_update_done();
133 return ret;
134}
135
136#ifdef CONFIG_HOTPLUG_CPU
137
138EXPORT_SYMBOL(register_cpu_notifier);
139
140void __ref unregister_cpu_notifier(struct notifier_block *nb)
141{
142 cpu_maps_update_begin();
143 raw_notifier_chain_unregister(&cpu_chain, nb);
144 cpu_maps_update_done();
145}
146EXPORT_SYMBOL(unregister_cpu_notifier);
147
148static inline void check_for_tasks(int cpu)
149{
150 struct task_struct *p;
151
152 write_lock_irq(&tasklist_lock);
153 for_each_process(p) {
154 if (task_cpu(p) == cpu && p->state == TASK_RUNNING &&
155 (!cputime_eq(p->utime, cputime_zero) ||
156 !cputime_eq(p->stime, cputime_zero)))
157 printk(KERN_WARNING "Task %s (pid = %d) is on cpu %d "
158 "(state = %ld, flags = %x)\n",
159 p->comm, task_pid_nr(p), cpu,
160 p->state, p->flags);
161 }
162 write_unlock_irq(&tasklist_lock);
163}
164
165struct take_cpu_down_param {
166 unsigned long mod;
167 void *hcpu;
168};
169
170/* Take this CPU down. */
171static int __ref take_cpu_down(void *_param)
172{
173 struct take_cpu_down_param *param = _param;
174 int err;
175
176 /* Ensure this CPU doesn't handle any more interrupts. */
177 err = __cpu_disable();
178 if (err < 0)
179 return err;
180
181 raw_notifier_call_chain(&cpu_chain, CPU_DYING | param->mod,
182 param->hcpu);
183
184 /* Force idle task to run as soon as we yield: it should
185 immediately notice cpu is offline and die quickly. */
186 sched_idle_next();
187 return 0;
188}
189
190/* Requires cpu_add_remove_lock to be held */
191static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
192{
193 int err, nr_calls = 0;
194 cpumask_var_t old_allowed;
195 void *hcpu = (void *)(long)cpu;
196 unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
197 struct take_cpu_down_param tcd_param = {
198 .mod = mod,
199 .hcpu = hcpu,
200 };
201
202 if (num_online_cpus() == 1)
203 return -EBUSY;
204
205 if (!cpu_online(cpu))
206 return -EINVAL;
207
208 if (!alloc_cpumask_var(&old_allowed, GFP_KERNEL))
209 return -ENOMEM;
210
211 cpu_hotplug_begin();
212 set_cpu_active(cpu, false);
213 err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
214 hcpu, -1, &nr_calls);
215 if (err == NOTIFY_BAD) {
216 set_cpu_active(cpu, true);
217
218 nr_calls--;
219 __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
220 hcpu, nr_calls, NULL);
221 printk("%s: attempt to take down CPU %u failed\n",
222 __func__, cpu);
223 err = -EINVAL;
224 goto out_release;
225 }
226
227 /* Ensure that we are not runnable on dying cpu */
228 cpumask_copy(old_allowed, &current->cpus_allowed);
229 set_cpus_allowed_ptr(current, cpu_active_mask);
230
231 err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
232 if (err) {
233 set_cpu_active(cpu, true);
234 /* CPU didn't die: tell everyone. Can't complain. */
235 if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
236 hcpu) == NOTIFY_BAD)
237 BUG();
238
239 goto out_allowed;
240 }
241 BUG_ON(cpu_online(cpu));
242
243 /* Wait for it to sleep (leaving idle task). */
244 while (!idle_cpu(cpu))
245 yield();
246
247 /* This actually kills the CPU. */
248 __cpu_die(cpu);
249
250 /* CPU is completely dead: tell everyone. Too late to complain. */
251 if (raw_notifier_call_chain(&cpu_chain, CPU_DEAD | mod,
252 hcpu) == NOTIFY_BAD)
253 BUG();
254
255 check_for_tasks(cpu);
256
257out_allowed:
258 set_cpus_allowed_ptr(current, old_allowed);
259out_release:
260 cpu_hotplug_done();
261 if (!err) {
262 if (raw_notifier_call_chain(&cpu_chain, CPU_POST_DEAD | mod,
263 hcpu) == NOTIFY_BAD)
264 BUG();
265 }
266 free_cpumask_var(old_allowed);
267 return err;
268}
269
270int __ref cpu_down(unsigned int cpu)
271{
272 int err;
273
274 err = stop_machine_create();
275 if (err)
276 return err;
277 cpu_maps_update_begin();
278
279 if (cpu_hotplug_disabled) {
280 err = -EBUSY;
281 goto out;
282 }
283
284 err = _cpu_down(cpu, 0);
285
286out:
287 cpu_maps_update_done();
288 stop_machine_destroy();
289 return err;
290}
291EXPORT_SYMBOL(cpu_down);
292#endif /*CONFIG_HOTPLUG_CPU*/
293
294/* Requires cpu_add_remove_lock to be held */
295static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
296{
297 int ret, nr_calls = 0;
298 void *hcpu = (void *)(long)cpu;
299 unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
300
301 if (cpu_online(cpu) || !cpu_present(cpu))
302 return -EINVAL;
303
304 cpu_hotplug_begin();
305 ret = __raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE | mod, hcpu,
306 -1, &nr_calls);
307 if (ret == NOTIFY_BAD) {
308 nr_calls--;
309 printk("%s: attempt to bring up CPU %u failed\n",
310 __func__, cpu);
311 ret = -EINVAL;
312 goto out_notify;
313 }
314
315 /* Arch-specific enabling code. */
316 ret = __cpu_up(cpu);
317 if (ret != 0)
318 goto out_notify;
319 BUG_ON(!cpu_online(cpu));
320
321 set_cpu_active(cpu, true);
322
323 /* Now call notifier in preparation. */
324 raw_notifier_call_chain(&cpu_chain, CPU_ONLINE | mod, hcpu);
325
326out_notify:
327 if (ret != 0)
328 __raw_notifier_call_chain(&cpu_chain,
329 CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
330 cpu_hotplug_done();
331
332 return ret;
333}
334
335int __cpuinit cpu_up(unsigned int cpu)
336{
337 int err = 0;
338 if (!cpu_possible(cpu)) {
339 printk(KERN_ERR "can't online cpu %d because it is not "
340 "configured as may-hotadd at boot time\n", cpu);
341#if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
342 printk(KERN_ERR "please check additional_cpus= boot "
343 "parameter\n");
344#endif
345 return -EINVAL;
346 }
347
348 cpu_maps_update_begin();
349
350 if (cpu_hotplug_disabled) {
351 err = -EBUSY;
352 goto out;
353 }
354
355 err = _cpu_up(cpu, 0);
356
357out:
358 cpu_maps_update_done();
359 return err;
360}
361
362#ifdef CONFIG_PM_SLEEP_SMP
363static cpumask_var_t frozen_cpus;
364
365int disable_nonboot_cpus(void)
366{
367 int cpu, first_cpu, error;
368
369 error = stop_machine_create();
370 if (error)
371 return error;
372 cpu_maps_update_begin();
373 first_cpu = cpumask_first(cpu_online_mask);
374 /*
375 * We take down all of the non-boot CPUs in one shot to avoid races
376 * with the userspace trying to use the CPU hotplug at the same time
377 */
378 cpumask_clear(frozen_cpus);
379
380 printk("Disabling non-boot CPUs ...\n");
381 for_each_online_cpu(cpu) {
382 if (cpu == first_cpu)
383 continue;
384 error = _cpu_down(cpu, 1);
385 if (!error)
386 cpumask_set_cpu(cpu, frozen_cpus);
387 else {
388 printk(KERN_ERR "Error taking CPU%d down: %d\n",
389 cpu, error);
390 break;
391 }
392 }
393
394 if (!error) {
395 BUG_ON(num_online_cpus() > 1);
396 /* Make sure the CPUs won't be enabled by someone else */
397 cpu_hotplug_disabled = 1;
398 } else {
399 printk(KERN_ERR "Non-boot CPUs are not disabled\n");
400 }
401 cpu_maps_update_done();
402 stop_machine_destroy();
403 return error;
404}
405
406void __weak arch_enable_nonboot_cpus_begin(void)
407{
408}
409
410void __weak arch_enable_nonboot_cpus_end(void)
411{
412}
413
414void __ref enable_nonboot_cpus(void)
415{
416 int cpu, error;
417
418 /* Allow everyone to use the CPU hotplug again */
419 cpu_maps_update_begin();
420 cpu_hotplug_disabled = 0;
421 if (cpumask_empty(frozen_cpus))
422 goto out;
423
424 printk("Enabling non-boot CPUs ...\n");
425
426 arch_enable_nonboot_cpus_begin();
427
428 for_each_cpu(cpu, frozen_cpus) {
429 error = _cpu_up(cpu, 1);
430 if (!error) {
431 printk("CPU%d is up\n", cpu);
432 continue;
433 }
434 printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
435 }
436
437 arch_enable_nonboot_cpus_end();
438
439 cpumask_clear(frozen_cpus);
440out:
441 cpu_maps_update_done();
442}
443
444static int alloc_frozen_cpus(void)
445{
446 if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
447 return -ENOMEM;
448 return 0;
449}
450core_initcall(alloc_frozen_cpus);
451#endif /* CONFIG_PM_SLEEP_SMP */
452
453/**
454 * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers
455 * @cpu: cpu that just started
456 *
457 * This function calls the cpu_chain notifiers with CPU_STARTING.
458 * It must be called by the arch code on the new cpu, before the new cpu
459 * enables interrupts and before the "boot" cpu returns from __cpu_up().
460 */
461void __cpuinit notify_cpu_starting(unsigned int cpu)
462{
463 unsigned long val = CPU_STARTING;
464
465#ifdef CONFIG_PM_SLEEP_SMP
466 if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
467 val = CPU_STARTING_FROZEN;
468#endif /* CONFIG_PM_SLEEP_SMP */
469 raw_notifier_call_chain(&cpu_chain, val, (void *)(long)cpu);
470}
471
472#endif /* CONFIG_SMP */
473
474/*
475 * cpu_bit_bitmap[] is a special, "compressed" data structure that
476 * represents all NR_CPUS bits binary values of 1<<nr.
477 *
478 * It is used by cpumask_of() to get a constant address to a CPU
479 * mask value that has a single bit set only.
480 */
481
482/* cpu_bit_bitmap[0] is empty - so we can back into it */
483#define MASK_DECLARE_1(x) [x+1][0] = 1UL << (x)
484#define MASK_DECLARE_2(x) MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
485#define MASK_DECLARE_4(x) MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
486#define MASK_DECLARE_8(x) MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
487
488const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
489
490 MASK_DECLARE_8(0), MASK_DECLARE_8(8),
491 MASK_DECLARE_8(16), MASK_DECLARE_8(24),
492#if BITS_PER_LONG > 32
493 MASK_DECLARE_8(32), MASK_DECLARE_8(40),
494 MASK_DECLARE_8(48), MASK_DECLARE_8(56),
495#endif
496};
497EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
498
499const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
500EXPORT_SYMBOL(cpu_all_bits);
501
502#ifdef CONFIG_INIT_ALL_POSSIBLE
503static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
504 = CPU_BITS_ALL;
505#else
506static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
507#endif
508const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
509EXPORT_SYMBOL(cpu_possible_mask);
510
511static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
512const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
513EXPORT_SYMBOL(cpu_online_mask);
514
515static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
516const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
517EXPORT_SYMBOL(cpu_present_mask);
518
519static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
520const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
521EXPORT_SYMBOL(cpu_active_mask);
522
523void set_cpu_possible(unsigned int cpu, bool possible)
524{
525 if (possible)
526 cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
527 else
528 cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
529}
530
531void set_cpu_present(unsigned int cpu, bool present)
532{
533 if (present)
534 cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
535 else
536 cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
537}
538
539void set_cpu_online(unsigned int cpu, bool online)
540{
541 if (online)
542 cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
543 else
544 cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
545}
546
547void set_cpu_active(unsigned int cpu, bool active)
548{
549 if (active)
550 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
551 else
552 cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
553}
554
555void init_cpu_present(const struct cpumask *src)
556{
557 cpumask_copy(to_cpumask(cpu_present_bits), src);
558}
559
560void init_cpu_possible(const struct cpumask *src)
561{
562 cpumask_copy(to_cpumask(cpu_possible_bits), src);
563}
564
565void init_cpu_online(const struct cpumask *src)
566{
567 cpumask_copy(to_cpumask(cpu_online_bits), src);
568}