01a2c66bf018744a50978fca2d0d25740a113080
[projects/modsched/linux.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/oom.h>
14 #include <linux/rcupdate.h>
15 #include <linux/export.h>
16 #include <linux/bug.h>
17 #include <linux/kthread.h>
18 #include <linux/stop_machine.h>
19 #include <linux/mutex.h>
20 #include <linux/gfp.h>
21 #include <linux/suspend.h>
22 #include <linux/lockdep.h>
23 #include <linux/tick.h>
24 #include <linux/irq.h>
25 #include <trace/events/power.h>
26
27 #ifdef CONFIG_MOD_SCHED
28     #include <fw_comm.h>
29 #endif
30
31 #include "smpboot.h"
32
33 #ifdef CONFIG_SMP
34 /* Serializes the updates to cpu_online_mask, cpu_present_mask */
35 static DEFINE_MUTEX(cpu_add_remove_lock);
36
37 /*
38  * The following two APIs (cpu_maps_update_begin/done) must be used when
39  * attempting to serialize the updates to cpu_online_mask & cpu_present_mask.
40  * The APIs cpu_notifier_register_begin/done() must be used to protect CPU
41  * hotplug callback (un)registration performed using __register_cpu_notifier()
42  * or __unregister_cpu_notifier().
43  */
44 void cpu_maps_update_begin(void)
45 {
46         mutex_lock(&cpu_add_remove_lock);
47 }
48 EXPORT_SYMBOL(cpu_notifier_register_begin);
49
50 void cpu_maps_update_done(void)
51 {
52         mutex_unlock(&cpu_add_remove_lock);
53 }
54 EXPORT_SYMBOL(cpu_notifier_register_done);
55
56 static RAW_NOTIFIER_HEAD(cpu_chain);
57
58 /* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
59  * Should always be manipulated under cpu_add_remove_lock
60  */
61 static int cpu_hotplug_disabled;
62
63 #ifdef CONFIG_HOTPLUG_CPU
64
65 static struct {
66         struct task_struct *active_writer;
67         /* wait queue to wake up the active_writer */
68         wait_queue_head_t wq;
69         /* verifies that no writer will get active while readers are active */
70         struct mutex lock;
71         /*
72          * Also blocks the new readers during
73          * an ongoing cpu hotplug operation.
74          */
75         atomic_t refcount;
76
77 #ifdef CONFIG_DEBUG_LOCK_ALLOC
78         struct lockdep_map dep_map;
79 #endif
80 } cpu_hotplug = {
81         .active_writer = NULL,
82         .wq = __WAIT_QUEUE_HEAD_INITIALIZER(cpu_hotplug.wq),
83         .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock),
84 #ifdef CONFIG_DEBUG_LOCK_ALLOC
85         .dep_map = {.name = "cpu_hotplug.lock" },
86 #endif
87 };
88
89 /* Lockdep annotations for get/put_online_cpus() and cpu_hotplug_begin/end() */
90 #define cpuhp_lock_acquire_read() lock_map_acquire_read(&cpu_hotplug.dep_map)
91 #define cpuhp_lock_acquire_tryread() \
92                                   lock_map_acquire_tryread(&cpu_hotplug.dep_map)
93 #define cpuhp_lock_acquire()      lock_map_acquire(&cpu_hotplug.dep_map)
94 #define cpuhp_lock_release()      lock_map_release(&cpu_hotplug.dep_map)
95
96
97 void get_online_cpus(void)
98 {
99         might_sleep();
100         if (cpu_hotplug.active_writer == current)
101                 return;
102         cpuhp_lock_acquire_read();
103         mutex_lock(&cpu_hotplug.lock);
104         atomic_inc(&cpu_hotplug.refcount);
105         mutex_unlock(&cpu_hotplug.lock);
106 }
107 EXPORT_SYMBOL_GPL(get_online_cpus);
108
109 bool try_get_online_cpus(void)
110 {
111         if (cpu_hotplug.active_writer == current)
112                 return true;
113         if (!mutex_trylock(&cpu_hotplug.lock))
114                 return false;
115         cpuhp_lock_acquire_tryread();
116         atomic_inc(&cpu_hotplug.refcount);
117         mutex_unlock(&cpu_hotplug.lock);
118         return true;
119 }
120 EXPORT_SYMBOL_GPL(try_get_online_cpus);
121
122 void put_online_cpus(void)
123 {
124         int refcount;
125
126         if (cpu_hotplug.active_writer == current)
127                 return;
128
129         refcount = atomic_dec_return(&cpu_hotplug.refcount);
130         if (WARN_ON(refcount < 0)) /* try to fix things up */
131                 atomic_inc(&cpu_hotplug.refcount);
132
133         if (refcount <= 0 && waitqueue_active(&cpu_hotplug.wq))
134                 wake_up(&cpu_hotplug.wq);
135
136         cpuhp_lock_release();
137
138 }
139 EXPORT_SYMBOL_GPL(put_online_cpus);
140
141 /*
142  * This ensures that the hotplug operation can begin only when the
143  * refcount goes to zero.
144  *
145  * Note that during a cpu-hotplug operation, the new readers, if any,
146  * will be blocked by the cpu_hotplug.lock
147  *
148  * Since cpu_hotplug_begin() is always called after invoking
149  * cpu_maps_update_begin(), we can be sure that only one writer is active.
150  *
151  * Note that theoretically, there is a possibility of a livelock:
152  * - Refcount goes to zero, last reader wakes up the sleeping
153  *   writer.
154  * - Last reader unlocks the cpu_hotplug.lock.
155  * - A new reader arrives at this moment, bumps up the refcount.
156  * - The writer acquires the cpu_hotplug.lock finds the refcount
157  *   non zero and goes to sleep again.
158  *
159  * However, this is very difficult to achieve in practice since
160  * get_online_cpus() not an api which is called all that often.
161  *
162  */
163 void cpu_hotplug_begin(void)
164 {
165         DEFINE_WAIT(wait);
166
167         cpu_hotplug.active_writer = current;
168         cpuhp_lock_acquire();
169
170         for (;;) {
171                 mutex_lock(&cpu_hotplug.lock);
172                 prepare_to_wait(&cpu_hotplug.wq, &wait, TASK_UNINTERRUPTIBLE);
173                 if (likely(!atomic_read(&cpu_hotplug.refcount)))
174                                 break;
175                 mutex_unlock(&cpu_hotplug.lock);
176                 schedule();
177         }
178         finish_wait(&cpu_hotplug.wq, &wait);
179 }
180
181 void cpu_hotplug_done(void)
182 {
183         cpu_hotplug.active_writer = NULL;
184         mutex_unlock(&cpu_hotplug.lock);
185         cpuhp_lock_release();
186 }
187
188 /*
189  * Wait for currently running CPU hotplug operations to complete (if any) and
190  * disable future CPU hotplug (from sysfs). The 'cpu_add_remove_lock' protects
191  * the 'cpu_hotplug_disabled' flag. The same lock is also acquired by the
192  * hotplug path before performing hotplug operations. So acquiring that lock
193  * guarantees mutual exclusion from any currently running hotplug operations.
194  */
195 void cpu_hotplug_disable(void)
196 {
197         cpu_maps_update_begin();
198         cpu_hotplug_disabled = 1;
199         cpu_maps_update_done();
200 }
201
202 void cpu_hotplug_enable(void)
203 {
204         cpu_maps_update_begin();
205         cpu_hotplug_disabled = 0;
206         cpu_maps_update_done();
207 }
208
209 #endif  /* CONFIG_HOTPLUG_CPU */
210
211 /* Need to know about CPUs going up/down? */
212 int __ref register_cpu_notifier(struct notifier_block *nb)
213 {
214         int ret;
215         cpu_maps_update_begin();
216         ret = raw_notifier_chain_register(&cpu_chain, nb);
217         cpu_maps_update_done();
218         return ret;
219 }
220
221 int __ref __register_cpu_notifier(struct notifier_block *nb)
222 {
223         return raw_notifier_chain_register(&cpu_chain, nb);
224 }
225
226 static int __cpu_notify(unsigned long val, void *v, int nr_to_call,
227                         int *nr_calls)
228 {
229         int ret;
230
231         ret = __raw_notifier_call_chain(&cpu_chain, val, v, nr_to_call,
232                                         nr_calls);
233
234         return notifier_to_errno(ret);
235 }
236
237 static int cpu_notify(unsigned long val, void *v)
238 {
239         return __cpu_notify(val, v, -1, NULL);
240 }
241
242 #ifdef CONFIG_HOTPLUG_CPU
243
244 static void cpu_notify_nofail(unsigned long val, void *v)
245 {
246         BUG_ON(cpu_notify(val, v));
247 }
248 EXPORT_SYMBOL(register_cpu_notifier);
249 EXPORT_SYMBOL(__register_cpu_notifier);
250
251 void __ref unregister_cpu_notifier(struct notifier_block *nb)
252 {
253         cpu_maps_update_begin();
254         raw_notifier_chain_unregister(&cpu_chain, nb);
255         cpu_maps_update_done();
256 }
257 EXPORT_SYMBOL(unregister_cpu_notifier);
258
259 void __ref __unregister_cpu_notifier(struct notifier_block *nb)
260 {
261         raw_notifier_chain_unregister(&cpu_chain, nb);
262 }
263 EXPORT_SYMBOL(__unregister_cpu_notifier);
264
265 /**
266  * clear_tasks_mm_cpumask - Safely clear tasks' mm_cpumask for a CPU
267  * @cpu: a CPU id
268  *
269  * This function walks all processes, finds a valid mm struct for each one and
270  * then clears a corresponding bit in mm's cpumask.  While this all sounds
271  * trivial, there are various non-obvious corner cases, which this function
272  * tries to solve in a safe manner.
273  *
274  * Also note that the function uses a somewhat relaxed locking scheme, so it may
275  * be called only for an already offlined CPU.
276  */
277 void clear_tasks_mm_cpumask(int cpu)
278 {
279         struct task_struct *p;
280
281         /*
282          * This function is called after the cpu is taken down and marked
283          * offline, so its not like new tasks will ever get this cpu set in
284          * their mm mask. -- Peter Zijlstra
285          * Thus, we may use rcu_read_lock() here, instead of grabbing
286          * full-fledged tasklist_lock.
287          */
288         WARN_ON(cpu_online(cpu));
289         rcu_read_lock();
290         for_each_process(p) {
291                 struct task_struct *t;
292
293                 /*
294                  * Main thread might exit, but other threads may still have
295                  * a valid mm. Find one.
296                  */
297                 t = find_lock_task_mm(p);
298                 if (!t)
299                         continue;
300                 cpumask_clear_cpu(cpu, mm_cpumask(t->mm));
301                 task_unlock(t);
302         }
303         rcu_read_unlock();
304 }
305
306 static inline void check_for_tasks(int dead_cpu)
307 {
308         struct task_struct *g, *p;
309
310         read_lock_irq(&tasklist_lock);
311         do_each_thread(g, p) {
312                 if (!p->on_rq)
313                         continue;
314                 /*
315                  * We do the check with unlocked task_rq(p)->lock.
316                  * Order the reading to do not warn about a task,
317                  * which was running on this cpu in the past, and
318                  * it's just been woken on another cpu.
319                  */
320                 rmb();
321                 if (task_cpu(p) != dead_cpu)
322                         continue;
323
324                 pr_warn("Task %s (pid=%d) is on cpu %d (state=%ld, flags=%x)\n",
325                         p->comm, task_pid_nr(p), dead_cpu, p->state, p->flags);
326         } while_each_thread(g, p);
327         read_unlock_irq(&tasklist_lock);
328 }
329
330 struct take_cpu_down_param {
331         unsigned long mod;
332         void *hcpu;
333 };
334
335 /* Take this CPU down. */
336 static int __ref take_cpu_down(void *_param)
337 {
338         struct take_cpu_down_param *param = _param;
339         int err;
340
341         /* Ensure this CPU doesn't handle any more interrupts. */
342         err = __cpu_disable();
343         if (err < 0)
344                 return err;
345
346         cpu_notify(CPU_DYING | param->mod, param->hcpu);
347         /* Give up timekeeping duties */
348         tick_handover_do_timer();
349         /* Park the stopper thread */
350         kthread_park(current);
351         return 0;
352 }
353
354 /* Requires cpu_add_remove_lock to be held */
355 static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
356 {
357         int err, nr_calls = 0;
358         void *hcpu = (void *)(long)cpu;
359         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
360         struct take_cpu_down_param tcd_param = {
361                 .mod = mod,
362                 .hcpu = hcpu,
363         };
364
365         if (num_online_cpus() == 1)
366                 return -EBUSY;
367
368         if (!cpu_online(cpu))
369                 return -EINVAL;
370
371         cpu_hotplug_begin();
372
373         err = __cpu_notify(CPU_DOWN_PREPARE | mod, hcpu, -1, &nr_calls);
374         if (err) {
375                 nr_calls--;
376                 __cpu_notify(CPU_DOWN_FAILED | mod, hcpu, nr_calls, NULL);
377                 pr_warn("%s: attempt to take down CPU %u failed\n",
378                         __func__, cpu);
379                 goto out_release;
380         }
381
382         /*
383          * By now we've cleared cpu_active_mask, wait for all preempt-disabled
384          * and RCU users of this state to go away such that all new such users
385          * will observe it.
386          *
387          * For CONFIG_PREEMPT we have preemptible RCU and its sync_rcu() might
388          * not imply sync_sched(), so explicitly call both.
389          *
390          * Do sync before park smpboot threads to take care the rcu boost case.
391          */
392 #ifdef CONFIG_PREEMPT
393         synchronize_sched();
394 #endif
395         synchronize_rcu();
396
397         smpboot_park_threads(cpu);
398
399         /*
400          * Prevent irq alloc/free while the dying cpu reorganizes the
401          * interrupt affinities.
402          */
403         irq_lock_sparse();
404
405         /*
406          * So now all preempt/rcu users must observe !cpu_active().
407          */
408         err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
409         if (err) {
410                 /* CPU didn't die: tell everyone.  Can't complain. */
411                 cpu_notify_nofail(CPU_DOWN_FAILED | mod, hcpu);
412                 irq_unlock_sparse();
413                 goto out_release;
414         }
415         BUG_ON(cpu_online(cpu));
416
417         /*
418          * The migration_call() CPU_DYING callback will have removed all
419          * runnable tasks from the cpu, there's only the idle task left now
420          * that the migration thread is done doing the stop_machine thing.
421          *
422          * Wait for the stop thread to go away.
423          */
424         while (!per_cpu(cpu_dead_idle, cpu))
425                 cpu_relax();
426         smp_mb(); /* Read from cpu_dead_idle before __cpu_die(). */
427         per_cpu(cpu_dead_idle, cpu) = false;
428
429         /* Interrupts are moved away from the dying cpu, reenable alloc/free */
430         irq_unlock_sparse();
431
432         hotplug_cpu__broadcast_tick_pull(cpu);
433         /* This actually kills the CPU. */
434         __cpu_die(cpu);
435
436         /* CPU is completely dead: tell everyone.  Too late to complain. */
437         tick_cleanup_dead_cpu(cpu);
438         cpu_notify_nofail(CPU_DEAD | mod, hcpu);
439
440         check_for_tasks(cpu);
441
442 out_release:
443         cpu_hotplug_done();
444         if (!err)
445                 cpu_notify_nofail(CPU_POST_DEAD | mod, hcpu);
446         return err;
447 }
448
449 int __ref cpu_down(unsigned int cpu)
450 {
451         int err;
452
453         cpu_maps_update_begin();
454
455         if (cpu_hotplug_disabled) {
456                 err = -EBUSY;
457                 goto out;
458         }
459
460         err = _cpu_down(cpu, 0);
461
462 out:
463         cpu_maps_update_done();
464         return err;
465 }
466 EXPORT_SYMBOL(cpu_down);
467 #endif /*CONFIG_HOTPLUG_CPU*/
468
469 /*
470  * Unpark per-CPU smpboot kthreads at CPU-online time.
471  */
472 static int smpboot_thread_call(struct notifier_block *nfb,
473                                unsigned long action, void *hcpu)
474 {
475         int cpu = (long)hcpu;
476
477         switch (action & ~CPU_TASKS_FROZEN) {
478
479         case CPU_DOWN_FAILED:
480         case CPU_ONLINE:
481                 smpboot_unpark_threads(cpu);
482                 break;
483
484         default:
485                 break;
486         }
487
488         return NOTIFY_OK;
489 }
490
491 static struct notifier_block smpboot_thread_notifier = {
492         .notifier_call = smpboot_thread_call,
493         .priority = CPU_PRI_SMPBOOT,
494 };
495
496 void smpboot_thread_init(void)
497 {
498         register_cpu_notifier(&smpboot_thread_notifier);
499 }
500
501 /* Requires cpu_add_remove_lock to be held */
502 static int _cpu_up(unsigned int cpu, int tasks_frozen)
503 {
504         int ret, nr_calls = 0;
505         void *hcpu = (void *)(long)cpu;
506         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
507         struct task_struct *idle;
508
509         cpu_hotplug_begin();
510
511         if (cpu_online(cpu) || !cpu_present(cpu)) {
512                 ret = -EINVAL;
513                 goto out;
514         }
515
516         idle = idle_thread_get(cpu);
517         if (IS_ERR(idle)) {
518                 ret = PTR_ERR(idle);
519                 goto out;
520         }
521
522         ret = smpboot_create_threads(cpu);
523         if (ret)
524                 goto out;
525
526         ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls);
527         if (ret) {
528                 nr_calls--;
529                 pr_warn("%s: attempt to bring up CPU %u failed\n",
530                         __func__, cpu);
531                 goto out_notify;
532         }
533
534         /* Arch-specific enabling code. */
535         ret = __cpu_up(cpu, idle);
536
537         if (ret != 0)
538                 goto out_notify;
539         BUG_ON(!cpu_online(cpu));
540
541         /* Now call notifier in preparation. */
542         cpu_notify(CPU_ONLINE | mod, hcpu);
543
544 out_notify:
545         if (ret != 0)
546                 __cpu_notify(CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
547 out:
548         cpu_hotplug_done();
549
550         return ret;
551 }
552
553 int cpu_up(unsigned int cpu)
554 {
555         int err = 0;
556
557         if (!cpu_possible(cpu)) {
558                 pr_err("can't online cpu %d because it is not configured as may-hotadd at boot time\n",
559                        cpu);
560 #if defined(CONFIG_IA64)
561                 pr_err("please check additional_cpus= boot parameter\n");
562 #endif
563                 return -EINVAL;
564         }
565
566         err = try_online_node(cpu_to_node(cpu));
567         if (err)
568                 return err;
569
570         cpu_maps_update_begin();
571
572         if (cpu_hotplug_disabled) {
573                 err = -EBUSY;
574                 goto out;
575         }
576
577         err = _cpu_up(cpu, 0);
578
579 #ifdef CONFIG_MOD_SCHED
580         if(!err)
581                 fw_notify(FW_CPU_ONLINE,&cpu);
582 #endif
583
584 out:
585         cpu_maps_update_done();
586         return err;
587 }
588 EXPORT_SYMBOL_GPL(cpu_up);
589
590 #ifdef CONFIG_PM_SLEEP_SMP
591 static cpumask_var_t frozen_cpus;
592
593 int disable_nonboot_cpus(void)
594 {
595         int cpu, first_cpu, error = 0;
596
597         cpu_maps_update_begin();
598         first_cpu = cpumask_first(cpu_online_mask);
599         /*
600          * We take down all of the non-boot CPUs in one shot to avoid races
601          * with the userspace trying to use the CPU hotplug at the same time
602          */
603         cpumask_clear(frozen_cpus);
604
605         pr_info("Disabling non-boot CPUs ...\n");
606         for_each_online_cpu(cpu) {
607                 if (cpu == first_cpu)
608                         continue;
609                 trace_suspend_resume(TPS("CPU_OFF"), cpu, true);
610                 error = _cpu_down(cpu, 1);
611                 trace_suspend_resume(TPS("CPU_OFF"), cpu, false);
612                 if (!error)
613                         cpumask_set_cpu(cpu, frozen_cpus);
614                 else {
615                         pr_err("Error taking CPU%d down: %d\n", cpu, error);
616                         break;
617                 }
618         }
619
620         if (!error) {
621                 BUG_ON(num_online_cpus() > 1);
622                 /* Make sure the CPUs won't be enabled by someone else */
623                 cpu_hotplug_disabled = 1;
624         } else {
625                 pr_err("Non-boot CPUs are not disabled\n");
626         }
627         cpu_maps_update_done();
628         return error;
629 }
630
631 void __weak arch_enable_nonboot_cpus_begin(void)
632 {
633 }
634
635 void __weak arch_enable_nonboot_cpus_end(void)
636 {
637 }
638
639 void __ref enable_nonboot_cpus(void)
640 {
641         int cpu, error;
642
643         /* Allow everyone to use the CPU hotplug again */
644         cpu_maps_update_begin();
645         cpu_hotplug_disabled = 0;
646         if (cpumask_empty(frozen_cpus))
647                 goto out;
648
649         pr_info("Enabling non-boot CPUs ...\n");
650
651         arch_enable_nonboot_cpus_begin();
652
653         for_each_cpu(cpu, frozen_cpus) {
654                 trace_suspend_resume(TPS("CPU_ON"), cpu, true);
655                 error = _cpu_up(cpu, 1);
656                 trace_suspend_resume(TPS("CPU_ON"), cpu, false);
657                 if (!error) {
658                         pr_info("CPU%d is up\n", cpu);
659                         continue;
660                 }
661                 pr_warn("Error taking CPU%d up: %d\n", cpu, error);
662         }
663
664         arch_enable_nonboot_cpus_end();
665
666         cpumask_clear(frozen_cpus);
667 out:
668         cpu_maps_update_done();
669 }
670
671 static int __init alloc_frozen_cpus(void)
672 {
673         if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
674                 return -ENOMEM;
675         return 0;
676 }
677 core_initcall(alloc_frozen_cpus);
678
679 /*
680  * When callbacks for CPU hotplug notifications are being executed, we must
681  * ensure that the state of the system with respect to the tasks being frozen
682  * or not, as reported by the notification, remains unchanged *throughout the
683  * duration* of the execution of the callbacks.
684  * Hence we need to prevent the freezer from racing with regular CPU hotplug.
685  *
686  * This synchronization is implemented by mutually excluding regular CPU
687  * hotplug and Suspend/Hibernate call paths by hooking onto the Suspend/
688  * Hibernate notifications.
689  */
690 static int
691 cpu_hotplug_pm_callback(struct notifier_block *nb,
692                         unsigned long action, void *ptr)
693 {
694         switch (action) {
695
696         case PM_SUSPEND_PREPARE:
697         case PM_HIBERNATION_PREPARE:
698                 cpu_hotplug_disable();
699                 break;
700
701         case PM_POST_SUSPEND:
702         case PM_POST_HIBERNATION:
703                 cpu_hotplug_enable();
704                 break;
705
706         default:
707                 return NOTIFY_DONE;
708         }
709
710         return NOTIFY_OK;
711 }
712
713
714 static int __init cpu_hotplug_pm_sync_init(void)
715 {
716         /*
717          * cpu_hotplug_pm_callback has higher priority than x86
718          * bsp_pm_callback which depends on cpu_hotplug_pm_callback
719          * to disable cpu hotplug to avoid cpu hotplug race.
720          */
721         pm_notifier(cpu_hotplug_pm_callback, 0);
722         return 0;
723 }
724 core_initcall(cpu_hotplug_pm_sync_init);
725
726 #endif /* CONFIG_PM_SLEEP_SMP */
727
728 /**
729  * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers
730  * @cpu: cpu that just started
731  *
732  * This function calls the cpu_chain notifiers with CPU_STARTING.
733  * It must be called by the arch code on the new cpu, before the new cpu
734  * enables interrupts and before the "boot" cpu returns from __cpu_up().
735  */
736 void notify_cpu_starting(unsigned int cpu)
737 {
738         unsigned long val = CPU_STARTING;
739
740 #ifdef CONFIG_PM_SLEEP_SMP
741         if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
742                 val = CPU_STARTING_FROZEN;
743 #endif /* CONFIG_PM_SLEEP_SMP */
744         cpu_notify(val, (void *)(long)cpu);
745 }
746
747 #endif /* CONFIG_SMP */
748
749 /*
750  * cpu_bit_bitmap[] is a special, "compressed" data structure that
751  * represents all NR_CPUS bits binary values of 1<<nr.
752  *
753  * It is used by cpumask_of() to get a constant address to a CPU
754  * mask value that has a single bit set only.
755  */
756
757 /* cpu_bit_bitmap[0] is empty - so we can back into it */
758 #define MASK_DECLARE_1(x)       [x+1][0] = (1UL << (x))
759 #define MASK_DECLARE_2(x)       MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
760 #define MASK_DECLARE_4(x)       MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
761 #define MASK_DECLARE_8(x)       MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
762
763 const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
764
765         MASK_DECLARE_8(0),      MASK_DECLARE_8(8),
766         MASK_DECLARE_8(16),     MASK_DECLARE_8(24),
767 #if BITS_PER_LONG > 32
768         MASK_DECLARE_8(32),     MASK_DECLARE_8(40),
769         MASK_DECLARE_8(48),     MASK_DECLARE_8(56),
770 #endif
771 };
772 EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
773
774 const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
775 EXPORT_SYMBOL(cpu_all_bits);
776
777 #ifdef CONFIG_INIT_ALL_POSSIBLE
778 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
779         = CPU_BITS_ALL;
780 #else
781 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
782 #endif
783 const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
784 EXPORT_SYMBOL(cpu_possible_mask);
785
786 static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
787 const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
788 EXPORT_SYMBOL(cpu_online_mask);
789
790 static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
791 const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
792 EXPORT_SYMBOL(cpu_present_mask);
793
794 static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
795 const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
796 EXPORT_SYMBOL(cpu_active_mask);
797
798 void set_cpu_possible(unsigned int cpu, bool possible)
799 {
800         if (possible)
801                 cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
802         else
803                 cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
804 }
805
806 void set_cpu_present(unsigned int cpu, bool present)
807 {
808         if (present)
809                 cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
810         else
811                 cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
812 }
813
814 void set_cpu_online(unsigned int cpu, bool online)
815 {
816         if (online) {
817                 cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
818                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
819         } else {
820                 cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
821         }
822 }
823
824 void set_cpu_active(unsigned int cpu, bool active)
825 {
826         if (active)
827                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
828         else
829                 cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
830 }
831
832 void init_cpu_present(const struct cpumask *src)
833 {
834         cpumask_copy(to_cpumask(cpu_present_bits), src);
835 }
836
837 void init_cpu_possible(const struct cpumask *src)
838 {
839         cpumask_copy(to_cpumask(cpu_possible_bits), src);
840 }
841
842 void init_cpu_online(const struct cpumask *src)
843 {
844         cpumask_copy(to_cpumask(cpu_online_bits), src);
845 }