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 /* Move it here so it can run. */
179 kthread_bind(p
, get_cpu());
182 /* CPU is completely dead: tell everyone. Too late to complain. */
183 if (raw_notifier_call_chain(&cpu_chain
, CPU_DEAD
, hcpu
) == NOTIFY_BAD
)
186 check_for_tasks(cpu
);
189 err
= kthread_stop(p
);
191 set_cpus_allowed(current
, old_allowed
);
193 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_RELEASE
,
198 int cpu_down(unsigned int cpu
)
202 mutex_lock(&cpu_add_remove_lock
);
203 if (cpu_hotplug_disabled
)
206 err
= _cpu_down(cpu
);
208 mutex_unlock(&cpu_add_remove_lock
);
211 #endif /*CONFIG_HOTPLUG_CPU*/
213 /* Requires cpu_add_remove_lock to be held */
214 static int __cpuinit
_cpu_up(unsigned int cpu
)
216 int ret
, nr_calls
= 0;
217 void *hcpu
= (void *)(long)cpu
;
219 if (cpu_online(cpu
) || !cpu_present(cpu
))
222 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_ACQUIRE
, hcpu
);
223 ret
= __raw_notifier_call_chain(&cpu_chain
, CPU_UP_PREPARE
, hcpu
,
225 if (ret
== NOTIFY_BAD
) {
226 printk("%s: attempt to bring up CPU %u failed\n",
232 /* Arch-specific enabling code. */
233 mutex_lock(&cpu_bitmask_lock
);
235 mutex_unlock(&cpu_bitmask_lock
);
238 BUG_ON(!cpu_online(cpu
));
240 /* Now call notifier in preparation. */
241 raw_notifier_call_chain(&cpu_chain
, CPU_ONLINE
, hcpu
);
245 __raw_notifier_call_chain(&cpu_chain
,
246 CPU_UP_CANCELED
, hcpu
, nr_calls
, NULL
);
247 raw_notifier_call_chain(&cpu_chain
, CPU_LOCK_RELEASE
, hcpu
);
252 int __cpuinit
cpu_up(unsigned int cpu
)
256 mutex_lock(&cpu_add_remove_lock
);
257 if (cpu_hotplug_disabled
)
262 mutex_unlock(&cpu_add_remove_lock
);
266 #ifdef CONFIG_SUSPEND_SMP
267 /* Needed to prevent the microcode driver from requesting firmware in its CPU
268 * hotplug notifier during the suspend/resume.
270 int suspend_cpu_hotplug
;
271 EXPORT_SYMBOL(suspend_cpu_hotplug
);
273 static cpumask_t frozen_cpus
;
275 int disable_nonboot_cpus(void)
277 int cpu
, first_cpu
, error
= 0;
279 mutex_lock(&cpu_add_remove_lock
);
280 suspend_cpu_hotplug
= 1;
281 first_cpu
= first_cpu(cpu_online_map
);
282 /* We take down all of the non-boot CPUs in one shot to avoid races
283 * with the userspace trying to use the CPU hotplug at the same time
285 cpus_clear(frozen_cpus
);
286 printk("Disabling non-boot CPUs ...\n");
287 for_each_online_cpu(cpu
) {
288 if (cpu
== first_cpu
)
290 error
= _cpu_down(cpu
);
292 cpu_set(cpu
, frozen_cpus
);
293 printk("CPU%d is down\n", cpu
);
295 printk(KERN_ERR
"Error taking CPU%d down: %d\n",
301 BUG_ON(num_online_cpus() > 1);
302 /* Make sure the CPUs won't be enabled by someone else */
303 cpu_hotplug_disabled
= 1;
305 printk(KERN_ERR
"Non-boot CPUs are not disabled\n");
307 suspend_cpu_hotplug
= 0;
308 mutex_unlock(&cpu_add_remove_lock
);
312 void enable_nonboot_cpus(void)
316 /* Allow everyone to use the CPU hotplug again */
317 mutex_lock(&cpu_add_remove_lock
);
318 cpu_hotplug_disabled
= 0;
319 if (cpus_empty(frozen_cpus
))
322 suspend_cpu_hotplug
= 1;
323 printk("Enabling non-boot CPUs ...\n");
324 for_each_cpu_mask(cpu
, frozen_cpus
) {
325 error
= _cpu_up(cpu
);
327 printk("CPU%d is up\n", cpu
);
330 printk(KERN_WARNING
"Error taking CPU%d up: %d\n", cpu
, error
);
332 cpus_clear(frozen_cpus
);
333 suspend_cpu_hotplug
= 0;
335 mutex_unlock(&cpu_add_remove_lock
);
This page took 0.037064 seconds and 6 git commands to generate.