projects/linux·blob v2.6.31-rc8 · refs

564 lines · 13.8 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 &&
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 err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
213 hcpu, -1, &nr_calls);
214 if (err == NOTIFY_BAD) {
215 nr_calls--;
216 __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
217 hcpu, nr_calls, NULL);
218 printk("%s: attempt to take down CPU %u failed\n",
219 __func__, cpu);
220 err = -EINVAL;
221 goto out_release;
222 }
223
224 /* Ensure that we are not runnable on dying cpu */
225 cpumask_copy(old_allowed, &current->cpus_allowed);
226 set_cpus_allowed_ptr(current,
227 cpumask_of(cpumask_any_but(cpu_online_mask, cpu)));
228
229 err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
230 if (err) {
231 /* CPU didn't die: tell everyone. Can't complain. */
232 if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
233 hcpu) == NOTIFY_BAD)
234 BUG();
235
236 goto out_allowed;
237 }
238 BUG_ON(cpu_online(cpu));
239
240 /* Wait for it to sleep (leaving idle task). */
241 while (!idle_cpu(cpu))
242 yield();
243
244 /* This actually kills the CPU. */
245 __cpu_die(cpu);
246
247 /* CPU is completely dead: tell everyone. Too late to complain. */
248 if (raw_notifier_call_chain(&cpu_chain, CPU_DEAD | mod,
249 hcpu) == NOTIFY_BAD)
250 BUG();
251
252 check_for_tasks(cpu);
253
254out_allowed:
255 set_cpus_allowed_ptr(current, old_allowed);
256out_release:
257 cpu_hotplug_done();
258 if (!err) {
259 if (raw_notifier_call_chain(&cpu_chain, CPU_POST_DEAD | mod,
260 hcpu) == NOTIFY_BAD)
261 BUG();
262 }
263 free_cpumask_var(old_allowed);
264 return err;
265}
266
267int __ref cpu_down(unsigned int cpu)
268{
269 int err;
270
271 err = stop_machine_create();
272 if (err)
273 return err;
274 cpu_maps_update_begin();
275
276 if (cpu_hotplug_disabled) {
277 err = -EBUSY;
278 goto out;
279 }
280
281 set_cpu_active(cpu, false);
282
283 /*
284 * Make sure the all cpus did the reschedule and are not
285 * using stale version of the cpu_active_mask.
286 * This is not strictly necessary becuase stop_machine()
287 * that we run down the line already provides the required
288 * synchronization. But it's really a side effect and we do not
289 * want to depend on the innards of the stop_machine here.
290 */
291 synchronize_sched();
292
293 err = _cpu_down(cpu, 0);
294
295 if (cpu_online(cpu))
296 set_cpu_active(cpu, true);
297
298out:
299 cpu_maps_update_done();
300 stop_machine_destroy();
301 return err;
302}
303EXPORT_SYMBOL(cpu_down);
304#endif /*CONFIG_HOTPLUG_CPU*/
305
306/* Requires cpu_add_remove_lock to be held */
307static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
308{
309 int ret, nr_calls = 0;
310 void *hcpu = (void *)(long)cpu;
311 unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
312
313 if (cpu_online(cpu) || !cpu_present(cpu))
314 return -EINVAL;
315
316 cpu_hotplug_begin();
317 ret = __raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE | mod, hcpu,
318 -1, &nr_calls);
319 if (ret == NOTIFY_BAD) {
320 nr_calls--;
321 printk("%s: attempt to bring up CPU %u failed\n",
322 __func__, cpu);
323 ret = -EINVAL;
324 goto out_notify;
325 }
326
327 /* Arch-specific enabling code. */
328 ret = __cpu_up(cpu);
329 if (ret != 0)
330 goto out_notify;
331 BUG_ON(!cpu_online(cpu));
332
333 set_cpu_active(cpu, true);
334
335 /* Now call notifier in preparation. */
336 raw_notifier_call_chain(&cpu_chain, CPU_ONLINE | mod, hcpu);
337
338out_notify:
339 if (ret != 0)
340 __raw_notifier_call_chain(&cpu_chain,
341 CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
342 cpu_hotplug_done();
343
344 return ret;
345}
346
347int __cpuinit cpu_up(unsigned int cpu)
348{
349 int err = 0;
350 if (!cpu_possible(cpu)) {
351 printk(KERN_ERR "can't online cpu %d because it is not "
352 "configured as may-hotadd at boot time\n", cpu);
353#if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
354 printk(KERN_ERR "please check additional_cpus= boot "
355 "parameter\n");
356#endif
357 return -EINVAL;
358 }
359
360 cpu_maps_update_begin();
361
362 if (cpu_hotplug_disabled) {
363 err = -EBUSY;
364 goto out;
365 }
366
367 err = _cpu_up(cpu, 0);
368
369out:
370 cpu_maps_update_done();
371 return err;
372}
373
374#ifdef CONFIG_PM_SLEEP_SMP
375static cpumask_var_t frozen_cpus;
376
377int disable_nonboot_cpus(void)
378{
379 int cpu, first_cpu, error;
380
381 error = stop_machine_create();
382 if (error)
383 return error;
384 cpu_maps_update_begin();
385 first_cpu = cpumask_first(cpu_online_mask);
386 /* We take down all of the non-boot CPUs in one shot to avoid races
387 * with the userspace trying to use the CPU hotplug at the same time
388 */
389 cpumask_clear(frozen_cpus);
390 printk("Disabling non-boot CPUs ...\n");
391 for_each_online_cpu(cpu) {
392 if (cpu == first_cpu)
393 continue;
394 error = _cpu_down(cpu, 1);
395 if (!error) {
396 cpumask_set_cpu(cpu, frozen_cpus);
397 printk("CPU%d is down\n", cpu);
398 } else {
399 printk(KERN_ERR "Error taking CPU%d down: %d\n",
400 cpu, error);
401 break;
402 }
403 }
404 if (!error) {
405 BUG_ON(num_online_cpus() > 1);
406 /* Make sure the CPUs won't be enabled by someone else */
407 cpu_hotplug_disabled = 1;
408 } else {
409 printk(KERN_ERR "Non-boot CPUs are not disabled\n");
410 }
411 cpu_maps_update_done();
412 stop_machine_destroy();
413 return error;
414}
415
416void __ref enable_nonboot_cpus(void)
417{
418 int cpu, error;
419
420 /* Allow everyone to use the CPU hotplug again */
421 cpu_maps_update_begin();
422 cpu_hotplug_disabled = 0;
423 if (cpumask_empty(frozen_cpus))
424 goto out;
425
426 printk("Enabling non-boot CPUs ...\n");
427 for_each_cpu(cpu, frozen_cpus) {
428 error = _cpu_up(cpu, 1);
429 if (!error) {
430 printk("CPU%d is up\n", cpu);
431 continue;
432 }
433 printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
434 }
435 cpumask_clear(frozen_cpus);
436out:
437 cpu_maps_update_done();
438}
439
440static int alloc_frozen_cpus(void)
441{
442 if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
443 return -ENOMEM;
444 return 0;
445}
446core_initcall(alloc_frozen_cpus);
447#endif /* CONFIG_PM_SLEEP_SMP */
448
449/**
450 * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers
451 * @cpu: cpu that just started
452 *
453 * This function calls the cpu_chain notifiers with CPU_STARTING.
454 * It must be called by the arch code on the new cpu, before the new cpu
455 * enables interrupts and before the "boot" cpu returns from __cpu_up().
456 */
457void __cpuinit notify_cpu_starting(unsigned int cpu)
458{
459 unsigned long val = CPU_STARTING;
460
461#ifdef CONFIG_PM_SLEEP_SMP
462 if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
463 val = CPU_STARTING_FROZEN;
464#endif /* CONFIG_PM_SLEEP_SMP */
465 raw_notifier_call_chain(&cpu_chain, val, (void *)(long)cpu);
466}
467
468#endif /* CONFIG_SMP */
469
470/*
471 * cpu_bit_bitmap[] is a special, "compressed" data structure that
472 * represents all NR_CPUS bits binary values of 1<<nr.
473 *
474 * It is used by cpumask_of() to get a constant address to a CPU
475 * mask value that has a single bit set only.
476 */
477
478/* cpu_bit_bitmap[0] is empty - so we can back into it */
479#define MASK_DECLARE_1(x) [x+1][0] = 1UL << (x)
480#define MASK_DECLARE_2(x) MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
481#define MASK_DECLARE_4(x) MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
482#define MASK_DECLARE_8(x) MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
483
484const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
485
486 MASK_DECLARE_8(0), MASK_DECLARE_8(8),
487 MASK_DECLARE_8(16), MASK_DECLARE_8(24),
488#if BITS_PER_LONG > 32
489 MASK_DECLARE_8(32), MASK_DECLARE_8(40),
490 MASK_DECLARE_8(48), MASK_DECLARE_8(56),
491#endif
492};
493EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
494
495const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
496EXPORT_SYMBOL(cpu_all_bits);
497
498#ifdef CONFIG_INIT_ALL_POSSIBLE
499static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
500 = CPU_BITS_ALL;
501#else
502static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
503#endif
504const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
505EXPORT_SYMBOL(cpu_possible_mask);
506
507static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
508const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
509EXPORT_SYMBOL(cpu_online_mask);
510
511static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
512const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
513EXPORT_SYMBOL(cpu_present_mask);
514
515static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
516const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
517EXPORT_SYMBOL(cpu_active_mask);
518
519void set_cpu_possible(unsigned int cpu, bool possible)
520{
521 if (possible)
522 cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
523 else
524 cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
525}
526
527void set_cpu_present(unsigned int cpu, bool present)
528{
529 if (present)
530 cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
531 else
532 cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
533}
534
535void set_cpu_online(unsigned int cpu, bool online)
536{
537 if (online)
538 cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
539 else
540 cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
541}
542
543void set_cpu_active(unsigned int cpu, bool active)
544{
545 if (active)
546 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
547 else
548 cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
549}
550
551void init_cpu_present(const struct cpumask *src)
552{
553 cpumask_copy(to_cpumask(cpu_present_bits), src);
554}
555
556void init_cpu_possible(const struct cpumask *src)
557{
558 cpumask_copy(to_cpumask(cpu_possible_bits), src);
559}
560
561void init_cpu_online(const struct cpumask *src)
562{
563 cpumask_copy(to_cpumask(cpu_online_bits), src);
564}