powerpc: Fix build errors STRICT_MM_TYPECHECKS
[pandora-kernel.git] / kernel / cpu.c
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/export.h>
14 #include <linux/kthread.h>
15 #include <linux/stop_machine.h>
16 #include <linux/mutex.h>
17 #include <linux/gfp.h>
18 #include <linux/suspend.h>
19
20 #ifdef CONFIG_SMP
21 /* Serializes the updates to cpu_online_mask, cpu_present_mask */
22 static DEFINE_MUTEX(cpu_add_remove_lock);
23
24 /*
25  * The following two API's must be used when attempting
26  * to serialize the updates to cpu_online_mask, cpu_present_mask.
27  */
28 void cpu_maps_update_begin(void)
29 {
30         mutex_lock(&cpu_add_remove_lock);
31 }
32
33 void cpu_maps_update_done(void)
34 {
35         mutex_unlock(&cpu_add_remove_lock);
36 }
37
38 static RAW_NOTIFIER_HEAD(cpu_chain);
39
40 /* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
41  * Should always be manipulated under cpu_add_remove_lock
42  */
43 static int cpu_hotplug_disabled;
44
45 #ifdef CONFIG_HOTPLUG_CPU
46
47 static struct {
48         struct task_struct *active_writer;
49         struct mutex lock; /* Synchronizes accesses to refcount, */
50         /*
51          * Also blocks the new readers during
52          * an ongoing cpu hotplug operation.
53          */
54         int refcount;
55 } cpu_hotplug = {
56         .active_writer = NULL,
57         .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock),
58         .refcount = 0,
59 };
60
61 void get_online_cpus(void)
62 {
63         might_sleep();
64         if (cpu_hotplug.active_writer == current)
65                 return;
66         mutex_lock(&cpu_hotplug.lock);
67         cpu_hotplug.refcount++;
68         mutex_unlock(&cpu_hotplug.lock);
69
70 }
71 EXPORT_SYMBOL_GPL(get_online_cpus);
72
73 void put_online_cpus(void)
74 {
75         if (cpu_hotplug.active_writer == current)
76                 return;
77         mutex_lock(&cpu_hotplug.lock);
78         if (!--cpu_hotplug.refcount && unlikely(cpu_hotplug.active_writer))
79                 wake_up_process(cpu_hotplug.active_writer);
80         mutex_unlock(&cpu_hotplug.lock);
81
82 }
83 EXPORT_SYMBOL_GPL(put_online_cpus);
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  */
107 static 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
121 static void cpu_hotplug_done(void)
122 {
123         cpu_hotplug.active_writer = NULL;
124         mutex_unlock(&cpu_hotplug.lock);
125 }
126
127 /*
128  * Wait for currently running CPU hotplug operations to complete (if any) and
129  * disable future CPU hotplug (from sysfs). The 'cpu_add_remove_lock' protects
130  * the 'cpu_hotplug_disabled' flag. The same lock is also acquired by the
131  * hotplug path before performing hotplug operations. So acquiring that lock
132  * guarantees mutual exclusion from any currently running hotplug operations.
133  */
134 void cpu_hotplug_disable(void)
135 {
136         cpu_maps_update_begin();
137         cpu_hotplug_disabled = 1;
138         cpu_maps_update_done();
139 }
140
141 void cpu_hotplug_enable(void)
142 {
143         cpu_maps_update_begin();
144         cpu_hotplug_disabled = 0;
145         cpu_maps_update_done();
146 }
147
148 #else /* #if CONFIG_HOTPLUG_CPU */
149 static void cpu_hotplug_begin(void) {}
150 static void cpu_hotplug_done(void) {}
151 #endif  /* #else #if CONFIG_HOTPLUG_CPU */
152
153 /* Need to know about CPUs going up/down? */
154 int __ref register_cpu_notifier(struct notifier_block *nb)
155 {
156         int ret;
157         cpu_maps_update_begin();
158         ret = raw_notifier_chain_register(&cpu_chain, nb);
159         cpu_maps_update_done();
160         return ret;
161 }
162
163 static int __cpu_notify(unsigned long val, void *v, int nr_to_call,
164                         int *nr_calls)
165 {
166         int ret;
167
168         ret = __raw_notifier_call_chain(&cpu_chain, val, v, nr_to_call,
169                                         nr_calls);
170
171         return notifier_to_errno(ret);
172 }
173
174 static int cpu_notify(unsigned long val, void *v)
175 {
176         return __cpu_notify(val, v, -1, NULL);
177 }
178
179 #ifdef CONFIG_HOTPLUG_CPU
180
181 static void cpu_notify_nofail(unsigned long val, void *v)
182 {
183         BUG_ON(cpu_notify(val, v));
184 }
185 EXPORT_SYMBOL(register_cpu_notifier);
186
187 void __ref unregister_cpu_notifier(struct notifier_block *nb)
188 {
189         cpu_maps_update_begin();
190         raw_notifier_chain_unregister(&cpu_chain, nb);
191         cpu_maps_update_done();
192 }
193 EXPORT_SYMBOL(unregister_cpu_notifier);
194
195 static inline void check_for_tasks(int cpu)
196 {
197         struct task_struct *p;
198
199         write_lock_irq(&tasklist_lock);
200         for_each_process(p) {
201                 if (task_cpu(p) == cpu && p->state == TASK_RUNNING &&
202                     (!cputime_eq(p->utime, cputime_zero) ||
203                      !cputime_eq(p->stime, cputime_zero)))
204                         printk(KERN_WARNING "Task %s (pid = %d) is on cpu %d "
205                                 "(state = %ld, flags = %x)\n",
206                                 p->comm, task_pid_nr(p), cpu,
207                                 p->state, p->flags);
208         }
209         write_unlock_irq(&tasklist_lock);
210 }
211
212 struct take_cpu_down_param {
213         unsigned long mod;
214         void *hcpu;
215 };
216
217 /* Take this CPU down. */
218 static int __ref take_cpu_down(void *_param)
219 {
220         struct take_cpu_down_param *param = _param;
221         int err;
222
223         /* Ensure this CPU doesn't handle any more interrupts. */
224         err = __cpu_disable();
225         if (err < 0)
226                 return err;
227
228         cpu_notify(CPU_DYING | param->mod, param->hcpu);
229         return 0;
230 }
231
232 /* Requires cpu_add_remove_lock to be held */
233 static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
234 {
235         int err, nr_calls = 0;
236         void *hcpu = (void *)(long)cpu;
237         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
238         struct take_cpu_down_param tcd_param = {
239                 .mod = mod,
240                 .hcpu = hcpu,
241         };
242
243         if (num_online_cpus() == 1)
244                 return -EBUSY;
245
246         if (!cpu_online(cpu))
247                 return -EINVAL;
248
249         cpu_hotplug_begin();
250
251         err = __cpu_notify(CPU_DOWN_PREPARE | mod, hcpu, -1, &nr_calls);
252         if (err) {
253                 nr_calls--;
254                 __cpu_notify(CPU_DOWN_FAILED | mod, hcpu, nr_calls, NULL);
255                 printk("%s: attempt to take down CPU %u failed\n",
256                                 __func__, cpu);
257                 goto out_release;
258         }
259
260         err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
261         if (err) {
262                 /* CPU didn't die: tell everyone.  Can't complain. */
263                 cpu_notify_nofail(CPU_DOWN_FAILED | mod, hcpu);
264
265                 goto out_release;
266         }
267         BUG_ON(cpu_online(cpu));
268
269         /*
270          * The migration_call() CPU_DYING callback will have removed all
271          * runnable tasks from the cpu, there's only the idle task left now
272          * that the migration thread is done doing the stop_machine thing.
273          *
274          * Wait for the stop thread to go away.
275          */
276         while (!idle_cpu(cpu))
277                 cpu_relax();
278
279         /* This actually kills the CPU. */
280         __cpu_die(cpu);
281
282         /* CPU is completely dead: tell everyone.  Too late to complain. */
283         cpu_notify_nofail(CPU_DEAD | mod, hcpu);
284
285         check_for_tasks(cpu);
286
287 out_release:
288         cpu_hotplug_done();
289         if (!err)
290                 cpu_notify_nofail(CPU_POST_DEAD | mod, hcpu);
291         return err;
292 }
293
294 int __ref cpu_down(unsigned int cpu)
295 {
296         int err;
297
298         cpu_maps_update_begin();
299
300         if (cpu_hotplug_disabled) {
301                 err = -EBUSY;
302                 goto out;
303         }
304
305         err = _cpu_down(cpu, 0);
306
307 out:
308         cpu_maps_update_done();
309         return err;
310 }
311 EXPORT_SYMBOL(cpu_down);
312 #endif /*CONFIG_HOTPLUG_CPU*/
313
314 /* Requires cpu_add_remove_lock to be held */
315 static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
316 {
317         int ret, nr_calls = 0;
318         void *hcpu = (void *)(long)cpu;
319         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
320
321         if (cpu_online(cpu) || !cpu_present(cpu))
322                 return -EINVAL;
323
324         cpu_hotplug_begin();
325         ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls);
326         if (ret) {
327                 nr_calls--;
328                 printk(KERN_WARNING "%s: attempt to bring up CPU %u failed\n",
329                                 __func__, cpu);
330                 goto out_notify;
331         }
332
333         /* Arch-specific enabling code. */
334         ret = __cpu_up(cpu);
335         if (ret != 0)
336                 goto out_notify;
337         BUG_ON(!cpu_online(cpu));
338
339         /* Now call notifier in preparation. */
340         cpu_notify(CPU_ONLINE | mod, hcpu);
341
342 out_notify:
343         if (ret != 0)
344                 __cpu_notify(CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
345         cpu_hotplug_done();
346
347         return ret;
348 }
349
350 int __cpuinit cpu_up(unsigned int cpu)
351 {
352         int err = 0;
353
354 #ifdef  CONFIG_MEMORY_HOTPLUG
355         int nid;
356         pg_data_t       *pgdat;
357 #endif
358
359         if (!cpu_possible(cpu)) {
360                 printk(KERN_ERR "can't online cpu %d because it is not "
361                         "configured as may-hotadd at boot time\n", cpu);
362 #if defined(CONFIG_IA64)
363                 printk(KERN_ERR "please check additional_cpus= boot "
364                                 "parameter\n");
365 #endif
366                 return -EINVAL;
367         }
368
369 #ifdef  CONFIG_MEMORY_HOTPLUG
370         nid = cpu_to_node(cpu);
371         if (!node_online(nid)) {
372                 err = mem_online_node(nid);
373                 if (err)
374                         return err;
375         }
376
377         pgdat = NODE_DATA(nid);
378         if (!pgdat) {
379                 printk(KERN_ERR
380                         "Can't online cpu %d due to NULL pgdat\n", cpu);
381                 return -ENOMEM;
382         }
383
384         if (pgdat->node_zonelists->_zonerefs->zone == NULL) {
385                 mutex_lock(&zonelists_mutex);
386                 build_all_zonelists(NULL);
387                 mutex_unlock(&zonelists_mutex);
388         }
389 #endif
390
391         cpu_maps_update_begin();
392
393         if (cpu_hotplug_disabled) {
394                 err = -EBUSY;
395                 goto out;
396         }
397
398         err = _cpu_up(cpu, 0);
399
400 out:
401         cpu_maps_update_done();
402         return err;
403 }
404
405 #ifdef CONFIG_PM_SLEEP_SMP
406 static cpumask_var_t frozen_cpus;
407
408 void __weak arch_disable_nonboot_cpus_begin(void)
409 {
410 }
411
412 void __weak arch_disable_nonboot_cpus_end(void)
413 {
414 }
415
416 int disable_nonboot_cpus(void)
417 {
418         int cpu, first_cpu, error = 0;
419
420         cpu_maps_update_begin();
421         first_cpu = cpumask_first(cpu_online_mask);
422         /*
423          * We take down all of the non-boot CPUs in one shot to avoid races
424          * with the userspace trying to use the CPU hotplug at the same time
425          */
426         cpumask_clear(frozen_cpus);
427         arch_disable_nonboot_cpus_begin();
428
429         printk("Disabling non-boot CPUs ...\n");
430         for_each_online_cpu(cpu) {
431                 if (cpu == first_cpu)
432                         continue;
433                 error = _cpu_down(cpu, 1);
434                 if (!error)
435                         cpumask_set_cpu(cpu, frozen_cpus);
436                 else {
437                         printk(KERN_ERR "Error taking CPU%d down: %d\n",
438                                 cpu, error);
439                         break;
440                 }
441         }
442
443         arch_disable_nonboot_cpus_end();
444
445         if (!error) {
446                 BUG_ON(num_online_cpus() > 1);
447                 /* Make sure the CPUs won't be enabled by someone else */
448                 cpu_hotplug_disabled = 1;
449         } else {
450                 printk(KERN_ERR "Non-boot CPUs are not disabled\n");
451         }
452         cpu_maps_update_done();
453         return error;
454 }
455
456 void __weak arch_enable_nonboot_cpus_begin(void)
457 {
458 }
459
460 void __weak arch_enable_nonboot_cpus_end(void)
461 {
462 }
463
464 void __ref enable_nonboot_cpus(void)
465 {
466         int cpu, error;
467
468         /* Allow everyone to use the CPU hotplug again */
469         cpu_maps_update_begin();
470         cpu_hotplug_disabled = 0;
471         if (cpumask_empty(frozen_cpus))
472                 goto out;
473
474         printk(KERN_INFO "Enabling non-boot CPUs ...\n");
475
476         arch_enable_nonboot_cpus_begin();
477
478         for_each_cpu(cpu, frozen_cpus) {
479                 error = _cpu_up(cpu, 1);
480                 if (!error) {
481                         printk(KERN_INFO "CPU%d is up\n", cpu);
482                         continue;
483                 }
484                 printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
485         }
486
487         arch_enable_nonboot_cpus_end();
488
489         cpumask_clear(frozen_cpus);
490 out:
491         cpu_maps_update_done();
492 }
493
494 static int alloc_frozen_cpus(void)
495 {
496         if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
497                 return -ENOMEM;
498         return 0;
499 }
500 core_initcall(alloc_frozen_cpus);
501
502 /*
503  * When callbacks for CPU hotplug notifications are being executed, we must
504  * ensure that the state of the system with respect to the tasks being frozen
505  * or not, as reported by the notification, remains unchanged *throughout the
506  * duration* of the execution of the callbacks.
507  * Hence we need to prevent the freezer from racing with regular CPU hotplug.
508  *
509  * This synchronization is implemented by mutually excluding regular CPU
510  * hotplug and Suspend/Hibernate call paths by hooking onto the Suspend/
511  * Hibernate notifications.
512  */
513 static int
514 cpu_hotplug_pm_callback(struct notifier_block *nb,
515                         unsigned long action, void *ptr)
516 {
517         switch (action) {
518
519         case PM_SUSPEND_PREPARE:
520         case PM_HIBERNATION_PREPARE:
521                 cpu_hotplug_disable();
522                 break;
523
524         case PM_POST_SUSPEND:
525         case PM_POST_HIBERNATION:
526                 cpu_hotplug_enable();
527                 break;
528
529         default:
530                 return NOTIFY_DONE;
531         }
532
533         return NOTIFY_OK;
534 }
535
536
537 int cpu_hotplug_pm_sync_init(void)
538 {
539         pm_notifier(cpu_hotplug_pm_callback, 0);
540         return 0;
541 }
542 core_initcall(cpu_hotplug_pm_sync_init);
543
544 #endif /* CONFIG_PM_SLEEP_SMP */
545
546 /**
547  * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers
548  * @cpu: cpu that just started
549  *
550  * This function calls the cpu_chain notifiers with CPU_STARTING.
551  * It must be called by the arch code on the new cpu, before the new cpu
552  * enables interrupts and before the "boot" cpu returns from __cpu_up().
553  */
554 void __cpuinit notify_cpu_starting(unsigned int cpu)
555 {
556         unsigned long val = CPU_STARTING;
557
558 #ifdef CONFIG_PM_SLEEP_SMP
559         if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
560                 val = CPU_STARTING_FROZEN;
561 #endif /* CONFIG_PM_SLEEP_SMP */
562         cpu_notify(val, (void *)(long)cpu);
563 }
564
565 #endif /* CONFIG_SMP */
566
567 /*
568  * cpu_bit_bitmap[] is a special, "compressed" data structure that
569  * represents all NR_CPUS bits binary values of 1<<nr.
570  *
571  * It is used by cpumask_of() to get a constant address to a CPU
572  * mask value that has a single bit set only.
573  */
574
575 /* cpu_bit_bitmap[0] is empty - so we can back into it */
576 #define MASK_DECLARE_1(x)       [x+1][0] = (1UL << (x))
577 #define MASK_DECLARE_2(x)       MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
578 #define MASK_DECLARE_4(x)       MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
579 #define MASK_DECLARE_8(x)       MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
580
581 const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
582
583         MASK_DECLARE_8(0),      MASK_DECLARE_8(8),
584         MASK_DECLARE_8(16),     MASK_DECLARE_8(24),
585 #if BITS_PER_LONG > 32
586         MASK_DECLARE_8(32),     MASK_DECLARE_8(40),
587         MASK_DECLARE_8(48),     MASK_DECLARE_8(56),
588 #endif
589 };
590 EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
591
592 const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
593 EXPORT_SYMBOL(cpu_all_bits);
594
595 #ifdef CONFIG_INIT_ALL_POSSIBLE
596 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
597         = CPU_BITS_ALL;
598 #else
599 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
600 #endif
601 const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
602 EXPORT_SYMBOL(cpu_possible_mask);
603
604 static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
605 const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
606 EXPORT_SYMBOL(cpu_online_mask);
607
608 static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
609 const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
610 EXPORT_SYMBOL(cpu_present_mask);
611
612 static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
613 const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
614 EXPORT_SYMBOL(cpu_active_mask);
615
616 void set_cpu_possible(unsigned int cpu, bool possible)
617 {
618         if (possible)
619                 cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
620         else
621                 cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
622 }
623
624 void set_cpu_present(unsigned int cpu, bool present)
625 {
626         if (present)
627                 cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
628         else
629                 cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
630 }
631
632 void set_cpu_online(unsigned int cpu, bool online)
633 {
634         if (online)
635                 cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
636         else
637                 cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
638 }
639
640 void set_cpu_active(unsigned int cpu, bool active)
641 {
642         if (active)
643                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
644         else
645                 cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
646 }
647
648 void init_cpu_present(const struct cpumask *src)
649 {
650         cpumask_copy(to_cpumask(cpu_present_bits), src);
651 }
652
653 void init_cpu_possible(const struct cpumask *src)
654 {
655         cpumask_copy(to_cpumask(cpu_possible_bits), src);
656 }
657
658 void init_cpu_online(const struct cpumask *src)
659 {
660         cpumask_copy(to_cpumask(cpu_online_bits), src);
661 }