]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - kernel/cpu.c
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
BLOCKING_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
) {
61 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
)
71 return blocking_notifier_chain_register(&cpu_chain
, nb
);
74 #ifdef CONFIG_HOTPLUG_CPU
76 EXPORT_SYMBOL(register_cpu_notifier
);
78 void unregister_cpu_notifier(struct notifier_block
*nb
)
80 blocking_notifier_chain_unregister(&cpu_chain
, nb
);
82 EXPORT_SYMBOL(unregister_cpu_notifier
);
84 static inline void check_for_tasks(int cpu
)
86 struct task_struct
*p
;
88 write_lock_irq(&tasklist_lock
);
90 if (task_cpu(p
) == cpu
&&
91 (!cputime_eq(p
->utime
, cputime_zero
) ||
92 !cputime_eq(p
->stime
, cputime_zero
)))
93 printk(KERN_WARNING
"Task %s (pid = %d) is on cpu %d\
94 (state = %ld, flags = %lx) \n",
95 p
->comm
, p
->pid
, cpu
, p
->state
, p
->flags
);
97 write_unlock_irq(&tasklist_lock
);
100 /* Take this CPU down. */
101 static int take_cpu_down(void *unused
)
105 /* Ensure this CPU doesn't handle any more interrupts. */
106 err
= __cpu_disable();
110 /* Force idle task to run as soon as we yield: it should
111 immediately notice cpu is offline and die quickly. */
116 /* Requires cpu_add_remove_lock to be held */
117 static int _cpu_down(unsigned int cpu
)
120 struct task_struct
*p
;
121 cpumask_t old_allowed
, tmp
;
123 if (num_online_cpus() == 1)
126 if (!cpu_online(cpu
))
129 err
= blocking_notifier_call_chain(&cpu_chain
, CPU_DOWN_PREPARE
,
131 if (err
== NOTIFY_BAD
) {
132 printk("%s: attempt to take down CPU %u failed\n",
137 /* Ensure that we are not runnable on dying cpu */
138 old_allowed
= current
->cpus_allowed
;
141 set_cpus_allowed(current
, tmp
);
143 mutex_lock(&cpu_bitmask_lock
);
144 p
= __stop_machine_run(take_cpu_down
, NULL
, cpu
);
145 mutex_unlock(&cpu_bitmask_lock
);
148 /* CPU didn't die: tell everyone. Can't complain. */
149 if (blocking_notifier_call_chain(&cpu_chain
, CPU_DOWN_FAILED
,
150 (void *)(long)cpu
) == NOTIFY_BAD
)
160 /* Wait for it to sleep (leaving idle task). */
161 while (!idle_cpu(cpu
))
164 /* This actually kills the CPU. */
167 /* Move it here so it can run. */
168 kthread_bind(p
, get_cpu());
171 /* CPU is completely dead: tell everyone. Too late to complain. */
172 if (blocking_notifier_call_chain(&cpu_chain
, CPU_DEAD
,
173 (void *)(long)cpu
) == NOTIFY_BAD
)
176 check_for_tasks(cpu
);
179 err
= kthread_stop(p
);
181 set_cpus_allowed(current
, old_allowed
);
185 int cpu_down(unsigned int cpu
)
189 mutex_lock(&cpu_add_remove_lock
);
190 if (cpu_hotplug_disabled
)
193 err
= _cpu_down(cpu
);
195 mutex_unlock(&cpu_add_remove_lock
);
198 #endif /*CONFIG_HOTPLUG_CPU*/
200 /* Requires cpu_add_remove_lock to be held */
201 static int __devinit
_cpu_up(unsigned int cpu
)
204 void *hcpu
= (void *)(long)cpu
;
206 if (cpu_online(cpu
) || !cpu_present(cpu
))
209 ret
= blocking_notifier_call_chain(&cpu_chain
, CPU_UP_PREPARE
, hcpu
);
210 if (ret
== NOTIFY_BAD
) {
211 printk("%s: attempt to bring up CPU %u failed\n",
217 /* Arch-specific enabling code. */
218 mutex_lock(&cpu_bitmask_lock
);
220 mutex_unlock(&cpu_bitmask_lock
);
223 BUG_ON(!cpu_online(cpu
));
225 /* Now call notifier in preparation. */
226 blocking_notifier_call_chain(&cpu_chain
, CPU_ONLINE
, hcpu
);
230 blocking_notifier_call_chain(&cpu_chain
,
231 CPU_UP_CANCELED
, hcpu
);
236 int __devinit
cpu_up(unsigned int cpu
)
240 mutex_lock(&cpu_add_remove_lock
);
241 if (cpu_hotplug_disabled
)
246 mutex_unlock(&cpu_add_remove_lock
);
250 #ifdef CONFIG_SUSPEND_SMP
251 static cpumask_t frozen_cpus
;
253 int disable_nonboot_cpus(void)
255 int cpu
, first_cpu
, error
;
257 mutex_lock(&cpu_add_remove_lock
);
258 first_cpu
= first_cpu(cpu_present_map
);
259 if (!cpu_online(first_cpu
)) {
260 error
= _cpu_up(first_cpu
);
262 printk(KERN_ERR
"Could not bring CPU%d up.\n",
267 error
= set_cpus_allowed(current
, cpumask_of_cpu(first_cpu
));
269 printk(KERN_ERR
"Could not run on CPU%d\n", first_cpu
);
272 /* We take down all of the non-boot CPUs in one shot to avoid races
273 * with the userspace trying to use the CPU hotplug at the same time
275 cpus_clear(frozen_cpus
);
276 printk("Disabling non-boot CPUs ...\n");
277 for_each_online_cpu(cpu
) {
278 if (cpu
== first_cpu
)
280 error
= _cpu_down(cpu
);
282 cpu_set(cpu
, frozen_cpus
);
283 printk("CPU%d is down\n", cpu
);
285 printk(KERN_ERR
"Error taking CPU%d down: %d\n",
291 BUG_ON(num_online_cpus() > 1);
292 /* Make sure the CPUs won't be enabled by someone else */
293 cpu_hotplug_disabled
= 1;
295 printk(KERN_ERR
"Non-boot CPUs are not disabled");
298 mutex_unlock(&cpu_add_remove_lock
);
302 void enable_nonboot_cpus(void)
306 /* Allow everyone to use the CPU hotplug again */
307 mutex_lock(&cpu_add_remove_lock
);
308 cpu_hotplug_disabled
= 0;
309 mutex_unlock(&cpu_add_remove_lock
);
311 printk("Enabling non-boot CPUs ...\n");
312 for_each_cpu_mask(cpu
, frozen_cpus
) {
315 printk("CPU%d is up\n", cpu
);
318 printk(KERN_WARNING
"Error taking CPU%d up: %d\n",
321 cpus_clear(frozen_cpus
);