2 * (C) 2001, 2002, 2003, 2004 Rusty Russell
4 * This code is licenced under the GPL.
6 #include <linux/proc_fs.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>
18 /* This protects CPUs going up and down... */
19 static DEFINE_MUTEX(cpu_add_remove_lock
);
20 static DEFINE_MUTEX(cpu_bitmask_lock
);
22 static __cpuinitdata
RAW_NOTIFIER_HEAD(cpu_chain
);
24 /* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
25 * Should always be manipulated under cpu_add_remove_lock
27 static int cpu_hotplug_disabled
;
29 #ifdef CONFIG_HOTPLUG_CPU
31 /* Crappy recursive lock-takers in cpufreq! Complain loudly about idiots */
32 static struct task_struct
*recursive
;
33 static int recursive_depth
;
35 void lock_cpu_hotplug(void)
37 struct task_struct
*tsk
= current
;
39 if (tsk
== recursive
) {
40 static int warnings
= 10;
42 printk(KERN_ERR
"Lukewarm IQ detected in hotplug locking\n");
49 mutex_lock(&cpu_bitmask_lock
);
52 EXPORT_SYMBOL_GPL(lock_cpu_hotplug
);
54 void unlock_cpu_hotplug(void)
56 WARN_ON(recursive
!= current
);
57 if (recursive_depth
) {
62 mutex_unlock(&cpu_bitmask_lock
);
64 EXPORT_SYMBOL_GPL(unlock_cpu_hotplug
);
66 #endif /* CONFIG_HOTPLUG_CPU */
68 /* Need to know about CPUs going up/down? */
69 int __cpuinit
register_cpu_notifier(struct notifier_block
*nb
)
72 mutex_lock(&cpu_add_remove_lock
);
73 ret
= raw_notifier_chain_register(&cpu_chain
, nb
);
74 mutex_unlock(&cpu_add_remove_lock
);
78 #ifdef CONFIG_HOTPLUG_CPU
80 EXPORT_SYMBOL(register_cpu_notifier
);
82 void unregister_cpu_notifier(struct notifier_block
*nb
)
84 mutex_lock(&cpu_add_remove_lock
);
85 raw_notifier_chain_unregister(&cpu_chain
, nb
);
86 mutex_unlock(&cpu_add_remove_lock
);
88 EXPORT_SYMBOL(unregister_cpu_notifier
);
90 static inline void check_for_tasks(int cpu
)
92 struct task_struct
*p
;
94 write_lock_irq(&tasklist_lock
);
96 if (task_cpu(p
) == cpu
&&
97 (!cputime_eq(p
->utime
, cputime_zero
) ||
98 !cputime_eq(p
->stime
, cputime_zero
)))
99 printk(KERN_WARNING
"Task %s (pid = %d) is on cpu %d\
100 (state = %ld, flags = %x) \n",
101 p
->comm
, p
->pid
, cpu
, p
->state
, p
->flags
);
103 write_unlock_irq(&tasklist_lock
);
106 /* Take this CPU down. */
107 static int take_cpu_down(void *unused
)
111 /* Ensure this CPU doesn't handle any more interrupts. */
112 err
= __cpu_disable();
116 /* Force idle task to run as soon as we yield: it should
117 immediately notice cpu is offline and die quickly. */
122 /* Requires cpu_add_remove_lock to be held */
123 static int _cpu_down(unsigned int cpu
)
125 int err
, nr_calls
= 0;
126 struct task_struct
*p
;
127 cpumask_t old_allowed
, tmp
;
128 void *hcpu
= (void *)(long)cpu
;
130 if (num_online_cpus() == 1)
133 if (!cpu_online(cpu
))
136 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_ACQUIRE
, hcpu
);
137 err
= __raw_notifier_call_chain(&cpu_chain
, CPU_DOWN_PREPARE
,
138 hcpu
, -1, &nr_calls
);
139 if (err
== NOTIFY_BAD
) {
140 __raw_notifier_call_chain(&cpu_chain
, CPU_DOWN_FAILED
, hcpu
,
142 printk("%s: attempt to take down CPU %u failed\n",
148 /* Ensure that we are not runnable on dying cpu */
149 old_allowed
= current
->cpus_allowed
;
152 set_cpus_allowed(current
, tmp
);
154 mutex_lock(&cpu_bitmask_lock
);
155 p
= __stop_machine_run(take_cpu_down
, NULL
, cpu
);
156 mutex_unlock(&cpu_bitmask_lock
);
158 if (IS_ERR(p
) || cpu_online(cpu
)) {
159 /* CPU didn't die: tell everyone. Can't complain. */
160 if (raw_notifier_call_chain(&cpu_chain
, CPU_DOWN_FAILED
,
171 /* Wait for it to sleep (leaving idle task). */
172 while (!idle_cpu(cpu
))
175 /* This actually kills the CPU. */
178 /* CPU is completely dead: tell everyone. Too late to complain. */
179 if (raw_notifier_call_chain(&cpu_chain
, CPU_DEAD
, hcpu
) == NOTIFY_BAD
)
182 check_for_tasks(cpu
);
185 err
= kthread_stop(p
);
187 set_cpus_allowed(current
, old_allowed
);
189 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_RELEASE
,
194 int cpu_down(unsigned int cpu
)
198 mutex_lock(&cpu_add_remove_lock
);
199 if (cpu_hotplug_disabled
)
202 err
= _cpu_down(cpu
);
204 mutex_unlock(&cpu_add_remove_lock
);
207 #endif /*CONFIG_HOTPLUG_CPU*/
209 /* Requires cpu_add_remove_lock to be held */
210 static int __cpuinit
_cpu_up(unsigned int cpu
)
212 int ret
, nr_calls
= 0;
213 void *hcpu
= (void *)(long)cpu
;
215 if (cpu_online(cpu
) || !cpu_present(cpu
))
218 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_ACQUIRE
, hcpu
);
219 ret
= __raw_notifier_call_chain(&cpu_chain
, CPU_UP_PREPARE
, hcpu
,
221 if (ret
== NOTIFY_BAD
) {
222 printk("%s: attempt to bring up CPU %u failed\n",
228 /* Arch-specific enabling code. */
229 mutex_lock(&cpu_bitmask_lock
);
231 mutex_unlock(&cpu_bitmask_lock
);
234 BUG_ON(!cpu_online(cpu
));
236 /* Now call notifier in preparation. */
237 raw_notifier_call_chain(&cpu_chain
, CPU_ONLINE
, hcpu
);
241 __raw_notifier_call_chain(&cpu_chain
,
242 CPU_UP_CANCELED
, hcpu
, nr_calls
, NULL
);
243 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_RELEASE
, hcpu
);
248 int __cpuinit
cpu_up(unsigned int cpu
)
252 mutex_lock(&cpu_add_remove_lock
);
253 if (cpu_hotplug_disabled
)
258 mutex_unlock(&cpu_add_remove_lock
);
262 #ifdef CONFIG_SUSPEND_SMP
263 /* Needed to prevent the microcode driver from requesting firmware in its CPU
264 * hotplug notifier during the suspend/resume.
266 int suspend_cpu_hotplug
;
267 EXPORT_SYMBOL(suspend_cpu_hotplug
);
269 static cpumask_t frozen_cpus
;
271 int disable_nonboot_cpus(void)
273 int cpu
, first_cpu
, error
= 0;
275 mutex_lock(&cpu_add_remove_lock
);
276 suspend_cpu_hotplug
= 1;
277 first_cpu
= first_cpu(cpu_online_map
);
278 /* We take down all of the non-boot CPUs in one shot to avoid races
279 * with the userspace trying to use the CPU hotplug at the same time
281 cpus_clear(frozen_cpus
);
282 printk("Disabling non-boot CPUs ...\n");
283 for_each_online_cpu(cpu
) {
284 if (cpu
== first_cpu
)
286 error
= _cpu_down(cpu
);
288 cpu_set(cpu
, frozen_cpus
);
289 printk("CPU%d is down\n", cpu
);
291 printk(KERN_ERR
"Error taking CPU%d down: %d\n",
297 BUG_ON(num_online_cpus() > 1);
298 /* Make sure the CPUs won't be enabled by someone else */
299 cpu_hotplug_disabled
= 1;
301 printk(KERN_ERR
"Non-boot CPUs are not disabled\n");
303 suspend_cpu_hotplug
= 0;
304 mutex_unlock(&cpu_add_remove_lock
);
308 void enable_nonboot_cpus(void)
312 /* Allow everyone to use the CPU hotplug again */
313 mutex_lock(&cpu_add_remove_lock
);
314 cpu_hotplug_disabled
= 0;
315 if (cpus_empty(frozen_cpus
))
318 suspend_cpu_hotplug
= 1;
319 printk("Enabling non-boot CPUs ...\n");
320 for_each_cpu_mask(cpu
, frozen_cpus
) {
321 error
= _cpu_up(cpu
);
323 printk("CPU%d is up\n", cpu
);
326 printk(KERN_WARNING
"Error taking CPU%d up: %d\n", cpu
, error
);
328 cpus_clear(frozen_cpus
);
329 suspend_cpu_hotplug
= 0;
331 mutex_unlock(&cpu_add_remove_lock
);
This page took 0.039246 seconds and 6 git commands to generate.