projects/linux·blob v2.6.23 · refs

337 lines · 7.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/* This protects CPUs going up and down... */
19static DEFINE_MUTEX(cpu_add_remove_lock);
20static DEFINE_MUTEX(cpu_bitmask_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
29#ifdef CONFIG_HOTPLUG_CPU
30
31/* Crappy recursive lock-takers in cpufreq! Complain loudly about idiots */
32static struct task_struct *recursive;
33static int recursive_depth;
34
35void lock_cpu_hotplug(void)
36{
37 struct task_struct *tsk = current;
38
39 if (tsk == recursive) {
40 static int warnings = 10;
41 if (warnings) {
42 printk(KERN_ERR "Lukewarm IQ detected in hotplug locking\n");
43 WARN_ON(1);
44 warnings--;
45 }
46 recursive_depth++;
47 return;
48 }
49 mutex_lock(&cpu_bitmask_lock);
50 recursive = tsk;
51}
52EXPORT_SYMBOL_GPL(lock_cpu_hotplug);
53
54void unlock_cpu_hotplug(void)
55{
56 WARN_ON(recursive != current);
57 if (recursive_depth) {
58 recursive_depth--;
59 return;
60 }
61 recursive = NULL;
62 mutex_unlock(&cpu_bitmask_lock);
63}
64EXPORT_SYMBOL_GPL(unlock_cpu_hotplug);
65
66#endif /* CONFIG_HOTPLUG_CPU */
67
68/* Need to know about CPUs going up/down? */
69int __cpuinit register_cpu_notifier(struct notifier_block *nb)
70{
71 int ret;
72 mutex_lock(&cpu_add_remove_lock);
73 ret = raw_notifier_chain_register(&cpu_chain, nb);
74 mutex_unlock(&cpu_add_remove_lock);
75 return ret;
76}
77
78#ifdef CONFIG_HOTPLUG_CPU
79
80EXPORT_SYMBOL(register_cpu_notifier);
81
82void unregister_cpu_notifier(struct notifier_block *nb)
83{
84 mutex_lock(&cpu_add_remove_lock);
85 raw_notifier_chain_unregister(&cpu_chain, nb);
86 mutex_unlock(&cpu_add_remove_lock);
87}
88EXPORT_SYMBOL(unregister_cpu_notifier);
89
90static inline void check_for_tasks(int cpu)
91{
92 struct task_struct *p;
93
94 write_lock_irq(&tasklist_lock);
95 for_each_process(p) {
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);
102 }
103 write_unlock_irq(&tasklist_lock);
104}
105
106struct take_cpu_down_param {
107 unsigned long mod;
108 void *hcpu;
109};
110
111/* Take this CPU down. */
112static int take_cpu_down(void *_param)
113{
114 struct take_cpu_down_param *param = _param;
115 int err;
116
117 raw_notifier_call_chain(&cpu_chain, CPU_DYING | param->mod,
118 param->hcpu);
119 /* Ensure this CPU doesn't handle any more interrupts. */
120 err = __cpu_disable();
121 if (err < 0)
122 return err;
123
124 /* Force idle task to run as soon as we yield: it should
125 immediately notice cpu is offline and die quickly. */
126 sched_idle_next();
127 return 0;
128}
129
130/* Requires cpu_add_remove_lock to be held */
131static int _cpu_down(unsigned int cpu, int tasks_frozen)
132{
133 int err, nr_calls = 0;
134 struct task_struct *p;
135 cpumask_t old_allowed, tmp;
136 void *hcpu = (void *)(long)cpu;
137 unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
138 struct take_cpu_down_param tcd_param = {
139 .mod = mod,
140 .hcpu = hcpu,
141 };
142
143 if (num_online_cpus() == 1)
144 return -EBUSY;
145
146 if (!cpu_online(cpu))
147 return -EINVAL;
148
149 raw_notifier_call_chain(&cpu_chain, CPU_LOCK_ACQUIRE, hcpu);
150 err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
151 hcpu, -1, &nr_calls);
152 if (err == NOTIFY_BAD) {
153 __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
154 hcpu, nr_calls, NULL);
155 printk("%s: attempt to take down CPU %u failed\n",
156 __FUNCTION__, cpu);
157 err = -EINVAL;
158 goto out_release;
159 }
160
161 /* Ensure that we are not runnable on dying cpu */
162 old_allowed = current->cpus_allowed;
163 tmp = CPU_MASK_ALL;
164 cpu_clear(cpu, tmp);
165 set_cpus_allowed(current, tmp);
166
167 mutex_lock(&cpu_bitmask_lock);
168 p = __stop_machine_run(take_cpu_down, &tcd_param, cpu);
169 mutex_unlock(&cpu_bitmask_lock);
170
171 if (IS_ERR(p) || cpu_online(cpu)) {
172 /* CPU didn't die: tell everyone. Can't complain. */
173 if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
174 hcpu) == NOTIFY_BAD)
175 BUG();
176
177 if (IS_ERR(p)) {
178 err = PTR_ERR(p);
179 goto out_allowed;
180 }
181 goto out_thread;
182 }
183
184 /* Wait for it to sleep (leaving idle task). */
185 while (!idle_cpu(cpu))
186 yield();
187
188 /* This actually kills the CPU. */
189 __cpu_die(cpu);
190
191 /* CPU is completely dead: tell everyone. Too late to complain. */
192 if (raw_notifier_call_chain(&cpu_chain, CPU_DEAD | mod,
193 hcpu) == NOTIFY_BAD)
194 BUG();
195
196 check_for_tasks(cpu);
197
198out_thread:
199 err = kthread_stop(p);
200out_allowed:
201 set_cpus_allowed(current, old_allowed);
202out_release:
203 raw_notifier_call_chain(&cpu_chain, CPU_LOCK_RELEASE, hcpu);
204 return err;
205}
206
207int cpu_down(unsigned int cpu)
208{
209 int err = 0;
210
211 mutex_lock(&cpu_add_remove_lock);
212 if (cpu_hotplug_disabled)
213 err = -EBUSY;
214 else
215 err = _cpu_down(cpu, 0);
216
217 mutex_unlock(&cpu_add_remove_lock);
218 return err;
219}
220#endif /*CONFIG_HOTPLUG_CPU*/
221
222/* Requires cpu_add_remove_lock to be held */
223static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
224{
225 int ret, nr_calls = 0;
226 void *hcpu = (void *)(long)cpu;
227 unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
228
229 if (cpu_online(cpu) || !cpu_present(cpu))
230 return -EINVAL;
231
232 raw_notifier_call_chain(&cpu_chain, CPU_LOCK_ACQUIRE, hcpu);
233 ret = __raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE | mod, hcpu,
234 -1, &nr_calls);
235 if (ret == NOTIFY_BAD) {
236 printk("%s: attempt to bring up CPU %u failed\n",
237 __FUNCTION__, cpu);
238 ret = -EINVAL;
239 goto out_notify;
240 }
241
242 /* Arch-specific enabling code. */
243 mutex_lock(&cpu_bitmask_lock);
244 ret = __cpu_up(cpu);
245 mutex_unlock(&cpu_bitmask_lock);
246 if (ret != 0)
247 goto out_notify;
248 BUG_ON(!cpu_online(cpu));
249
250 /* Now call notifier in preparation. */
251 raw_notifier_call_chain(&cpu_chain, CPU_ONLINE | mod, hcpu);
252
253out_notify:
254 if (ret != 0)
255 __raw_notifier_call_chain(&cpu_chain,
256 CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
257 raw_notifier_call_chain(&cpu_chain, CPU_LOCK_RELEASE, hcpu);
258
259 return ret;
260}
261
262int __cpuinit cpu_up(unsigned int cpu)
263{
264 int err = 0;
265
266 mutex_lock(&cpu_add_remove_lock);
267 if (cpu_hotplug_disabled)
268 err = -EBUSY;
269 else
270 err = _cpu_up(cpu, 0);
271
272 mutex_unlock(&cpu_add_remove_lock);
273 return err;
274}
275
276#ifdef CONFIG_PM_SLEEP_SMP
277static cpumask_t frozen_cpus;
278
279int disable_nonboot_cpus(void)
280{
281 int cpu, first_cpu, error = 0;
282
283 mutex_lock(&cpu_add_remove_lock);
284 first_cpu = first_cpu(cpu_online_map);
285 /* We take down all of the non-boot CPUs in one shot to avoid races
286 * with the userspace trying to use the CPU hotplug at the same time
287 */
288 cpus_clear(frozen_cpus);
289 printk("Disabling non-boot CPUs ...\n");
290 for_each_online_cpu(cpu) {
291 if (cpu == first_cpu)
292 continue;
293 error = _cpu_down(cpu, 1);
294 if (!error) {
295 cpu_set(cpu, frozen_cpus);
296 printk("CPU%d is down\n", cpu);
297 } else {
298 printk(KERN_ERR "Error taking CPU%d down: %d\n",
299 cpu, error);
300 break;
301 }
302 }
303 if (!error) {
304 BUG_ON(num_online_cpus() > 1);
305 /* Make sure the CPUs won't be enabled by someone else */
306 cpu_hotplug_disabled = 1;
307 } else {
308 printk(KERN_ERR "Non-boot CPUs are not disabled\n");
309 }
310 mutex_unlock(&cpu_add_remove_lock);
311 return error;
312}
313
314void enable_nonboot_cpus(void)
315{
316 int cpu, error;
317
318 /* Allow everyone to use the CPU hotplug again */
319 mutex_lock(&cpu_add_remove_lock);
320 cpu_hotplug_disabled = 0;
321 if (cpus_empty(frozen_cpus))
322 goto out;
323
324 printk("Enabling non-boot CPUs ...\n");
325 for_each_cpu_mask(cpu, frozen_cpus) {
326 error = _cpu_up(cpu, 1);
327 if (!error) {
328 printk("CPU%d is up\n", cpu);
329 continue;
330 }
331 printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
332 }
333 cpus_clear(frozen_cpus);
334out:
335 mutex_unlock(&cpu_add_remove_lock);
336}
337#endif /* CONFIG_PM_SLEEP_SMP */