Merge tag 'v4.3' into p/abusse/merge_upgrade
[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++;
199         cpu_maps_update_done();
200 }
201 EXPORT_SYMBOL_GPL(cpu_hotplug_disable);
202
203 void cpu_hotplug_enable(void)
204 {
205         cpu_maps_update_begin();
206         WARN_ON(--cpu_hotplug_disabled < 0);
207         cpu_maps_update_done();
208 }
209 EXPORT_SYMBOL_GPL(cpu_hotplug_enable);
210 #endif  /* CONFIG_HOTPLUG_CPU */
211
212 /* Need to know about CPUs going up/down? */
213 int register_cpu_notifier(struct notifier_block *nb)
214 {
215         int ret;
216         cpu_maps_update_begin();
217         ret = raw_notifier_chain_register(&cpu_chain, nb);
218         cpu_maps_update_done();
219         return ret;
220 }
221
222 int __register_cpu_notifier(struct notifier_block *nb)
223 {
224         return raw_notifier_chain_register(&cpu_chain, nb);
225 }
226
227 static int __cpu_notify(unsigned long val, void *v, int nr_to_call,
228                         int *nr_calls)
229 {
230         int ret;
231
232         ret = __raw_notifier_call_chain(&cpu_chain, val, v, nr_to_call,
233                                         nr_calls);
234
235         return notifier_to_errno(ret);
236 }
237
238 static int cpu_notify(unsigned long val, void *v)
239 {
240         return __cpu_notify(val, v, -1, NULL);
241 }
242
243 #ifdef CONFIG_HOTPLUG_CPU
244
245 static void cpu_notify_nofail(unsigned long val, void *v)
246 {
247         BUG_ON(cpu_notify(val, v));
248 }
249 EXPORT_SYMBOL(register_cpu_notifier);
250 EXPORT_SYMBOL(__register_cpu_notifier);
251
252 void unregister_cpu_notifier(struct notifier_block *nb)
253 {
254         cpu_maps_update_begin();
255         raw_notifier_chain_unregister(&cpu_chain, nb);
256         cpu_maps_update_done();
257 }
258 EXPORT_SYMBOL(unregister_cpu_notifier);
259
260 void __unregister_cpu_notifier(struct notifier_block *nb)
261 {
262         raw_notifier_chain_unregister(&cpu_chain, nb);
263 }
264 EXPORT_SYMBOL(__unregister_cpu_notifier);
265
266 /**
267  * clear_tasks_mm_cpumask - Safely clear tasks' mm_cpumask for a CPU
268  * @cpu: a CPU id
269  *
270  * This function walks all processes, finds a valid mm struct for each one and
271  * then clears a corresponding bit in mm's cpumask.  While this all sounds
272  * trivial, there are various non-obvious corner cases, which this function
273  * tries to solve in a safe manner.
274  *
275  * Also note that the function uses a somewhat relaxed locking scheme, so it may
276  * be called only for an already offlined CPU.
277  */
278 void clear_tasks_mm_cpumask(int cpu)
279 {
280         struct task_struct *p;
281
282         /*
283          * This function is called after the cpu is taken down and marked
284          * offline, so its not like new tasks will ever get this cpu set in
285          * their mm mask. -- Peter Zijlstra
286          * Thus, we may use rcu_read_lock() here, instead of grabbing
287          * full-fledged tasklist_lock.
288          */
289         WARN_ON(cpu_online(cpu));
290         rcu_read_lock();
291         for_each_process(p) {
292                 struct task_struct *t;
293
294                 /*
295                  * Main thread might exit, but other threads may still have
296                  * a valid mm. Find one.
297                  */
298                 t = find_lock_task_mm(p);
299                 if (!t)
300                         continue;
301                 cpumask_clear_cpu(cpu, mm_cpumask(t->mm));
302                 task_unlock(t);
303         }
304         rcu_read_unlock();
305 }
306
307 static inline void check_for_tasks(int dead_cpu)
308 {
309         struct task_struct *g, *p;
310
311         read_lock_irq(&tasklist_lock);
312         do_each_thread(g, p) {
313                 if (!p->on_rq)
314                         continue;
315                 /*
316                  * We do the check with unlocked task_rq(p)->lock.
317                  * Order the reading to do not warn about a task,
318                  * which was running on this cpu in the past, and
319                  * it's just been woken on another cpu.
320                  */
321                 rmb();
322                 if (task_cpu(p) != dead_cpu)
323                         continue;
324
325                 pr_warn("Task %s (pid=%d) is on cpu %d (state=%ld, flags=%x)\n",
326                         p->comm, task_pid_nr(p), dead_cpu, p->state, p->flags);
327         } while_each_thread(g, p);
328         read_unlock_irq(&tasklist_lock);
329 }
330
331 struct take_cpu_down_param {
332         unsigned long mod;
333         void *hcpu;
334 };
335
336 /* Take this CPU down. */
337 static int take_cpu_down(void *_param)
338 {
339         struct take_cpu_down_param *param = _param;
340         int err;
341
342         /* Ensure this CPU doesn't handle any more interrupts. */
343         err = __cpu_disable();
344         if (err < 0)
345                 return err;
346
347         cpu_notify(CPU_DYING | param->mod, param->hcpu);
348         /* Give up timekeeping duties */
349         tick_handover_do_timer();
350         /* Park the stopper thread */
351         kthread_park(current);
352         return 0;
353 }
354
355 /* Requires cpu_add_remove_lock to be held */
356 static int _cpu_down(unsigned int cpu, int tasks_frozen)
357 {
358         int err, nr_calls = 0;
359         void *hcpu = (void *)(long)cpu;
360         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
361         struct take_cpu_down_param tcd_param = {
362                 .mod = mod,
363                 .hcpu = hcpu,
364         };
365
366         if (num_online_cpus() == 1)
367                 return -EBUSY;
368
369         if (!cpu_online(cpu))
370                 return -EINVAL;
371
372         cpu_hotplug_begin();
373
374         err = __cpu_notify(CPU_DOWN_PREPARE | mod, hcpu, -1, &nr_calls);
375         if (err) {
376                 nr_calls--;
377                 __cpu_notify(CPU_DOWN_FAILED | mod, hcpu, nr_calls, NULL);
378                 pr_warn("%s: attempt to take down CPU %u failed\n",
379                         __func__, cpu);
380                 goto out_release;
381         }
382
383         /*
384          * By now we've cleared cpu_active_mask, wait for all preempt-disabled
385          * and RCU users of this state to go away such that all new such users
386          * will observe it.
387          *
388          * For CONFIG_PREEMPT we have preemptible RCU and its sync_rcu() might
389          * not imply sync_sched(), so wait for both.
390          *
391          * Do sync before park smpboot threads to take care the rcu boost case.
392          */
393         if (IS_ENABLED(CONFIG_PREEMPT))
394                 synchronize_rcu_mult(call_rcu, call_rcu_sched);
395         else
396                 synchronize_rcu();
397
398         smpboot_park_threads(cpu);
399
400         /*
401          * Prevent irq alloc/free while the dying cpu reorganizes the
402          * interrupt affinities.
403          */
404         irq_lock_sparse();
405
406         /*
407          * So now all preempt/rcu users must observe !cpu_active().
408          */
409         err = stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
410         if (err) {
411                 /* CPU didn't die: tell everyone.  Can't complain. */
412                 cpu_notify_nofail(CPU_DOWN_FAILED | mod, hcpu);
413                 irq_unlock_sparse();
414                 goto out_release;
415         }
416         BUG_ON(cpu_online(cpu));
417
418         /*
419          * The migration_call() CPU_DYING callback will have removed all
420          * runnable tasks from the cpu, there's only the idle task left now
421          * that the migration thread is done doing the stop_machine thing.
422          *
423          * Wait for the stop thread to go away.
424          */
425         while (!per_cpu(cpu_dead_idle, cpu))
426                 cpu_relax();
427         smp_mb(); /* Read from cpu_dead_idle before __cpu_die(). */
428         per_cpu(cpu_dead_idle, cpu) = false;
429
430         /* Interrupts are moved away from the dying cpu, reenable alloc/free */
431         irq_unlock_sparse();
432
433         hotplug_cpu__broadcast_tick_pull(cpu);
434         /* This actually kills the CPU. */
435         __cpu_die(cpu);
436
437         /* CPU is completely dead: tell everyone.  Too late to complain. */
438         tick_cleanup_dead_cpu(cpu);
439         cpu_notify_nofail(CPU_DEAD | mod, hcpu);
440
441         check_for_tasks(cpu);
442
443 out_release:
444         cpu_hotplug_done();
445         if (!err)
446                 cpu_notify_nofail(CPU_POST_DEAD | mod, hcpu);
447         return err;
448 }
449
450 int cpu_down(unsigned int cpu)
451 {
452         int err;
453
454         cpu_maps_update_begin();
455
456         if (cpu_hotplug_disabled) {
457                 err = -EBUSY;
458                 goto out;
459         }
460
461         err = _cpu_down(cpu, 0);
462
463 out:
464         cpu_maps_update_done();
465         return err;
466 }
467 EXPORT_SYMBOL(cpu_down);
468 #endif /*CONFIG_HOTPLUG_CPU*/
469
470 /*
471  * Unpark per-CPU smpboot kthreads at CPU-online time.
472  */
473 static int smpboot_thread_call(struct notifier_block *nfb,
474                                unsigned long action, void *hcpu)
475 {
476         int cpu = (long)hcpu;
477
478         switch (action & ~CPU_TASKS_FROZEN) {
479
480         case CPU_DOWN_FAILED:
481         case CPU_ONLINE:
482                 smpboot_unpark_threads(cpu);
483                 break;
484
485         default:
486                 break;
487         }
488
489         return NOTIFY_OK;
490 }
491
492 static struct notifier_block smpboot_thread_notifier = {
493         .notifier_call = smpboot_thread_call,
494         .priority = CPU_PRI_SMPBOOT,
495 };
496
497 void smpboot_thread_init(void)
498 {
499         register_cpu_notifier(&smpboot_thread_notifier);
500 }
501
502 /* Requires cpu_add_remove_lock to be held */
503 static int _cpu_up(unsigned int cpu, int tasks_frozen)
504 {
505         int ret, nr_calls = 0;
506         void *hcpu = (void *)(long)cpu;
507         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
508         struct task_struct *idle;
509
510         cpu_hotplug_begin();
511
512         if (cpu_online(cpu) || !cpu_present(cpu)) {
513                 ret = -EINVAL;
514                 goto out;
515         }
516
517         idle = idle_thread_get(cpu);
518         if (IS_ERR(idle)) {
519                 ret = PTR_ERR(idle);
520                 goto out;
521         }
522
523         ret = smpboot_create_threads(cpu);
524         if (ret)
525                 goto out;
526
527         ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls);
528         if (ret) {
529                 nr_calls--;
530                 pr_warn("%s: attempt to bring up CPU %u failed\n",
531                         __func__, cpu);
532                 goto out_notify;
533         }
534
535         /* Arch-specific enabling code. */
536         ret = __cpu_up(cpu, idle);
537
538         if (ret != 0)
539                 goto out_notify;
540         BUG_ON(!cpu_online(cpu));
541
542         /* Now call notifier in preparation. */
543         cpu_notify(CPU_ONLINE | mod, hcpu);
544
545 out_notify:
546         if (ret != 0)
547                 __cpu_notify(CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
548 out:
549         cpu_hotplug_done();
550
551         return ret;
552 }
553
554 int cpu_up(unsigned int cpu)
555 {
556         int err = 0;
557
558         if (!cpu_possible(cpu)) {
559                 pr_err("can't online cpu %d because it is not configured as may-hotadd at boot time\n",
560                        cpu);
561 #if defined(CONFIG_IA64)
562                 pr_err("please check additional_cpus= boot parameter\n");
563 #endif
564                 return -EINVAL;
565         }
566
567         err = try_online_node(cpu_to_node(cpu));
568         if (err)
569                 return err;
570
571         cpu_maps_update_begin();
572
573         if (cpu_hotplug_disabled) {
574                 err = -EBUSY;
575                 goto out;
576         }
577
578         err = _cpu_up(cpu, 0);
579
580 #ifdef CONFIG_MOD_SCHED
581         if(!err)
582                 fw_notify(FW_CPU_ONLINE,&cpu);
583 #endif
584
585 out:
586         cpu_maps_update_done();
587         return err;
588 }
589 EXPORT_SYMBOL_GPL(cpu_up);
590
591 #ifdef CONFIG_PM_SLEEP_SMP
592 static cpumask_var_t frozen_cpus;
593
594 int disable_nonboot_cpus(void)
595 {
596         int cpu, first_cpu, error = 0;
597
598         cpu_maps_update_begin();
599         first_cpu = cpumask_first(cpu_online_mask);
600         /*
601          * We take down all of the non-boot CPUs in one shot to avoid races
602          * with the userspace trying to use the CPU hotplug at the same time
603          */
604         cpumask_clear(frozen_cpus);
605
606         pr_info("Disabling non-boot CPUs ...\n");
607         for_each_online_cpu(cpu) {
608                 if (cpu == first_cpu)
609                         continue;
610                 trace_suspend_resume(TPS("CPU_OFF"), cpu, true);
611                 error = _cpu_down(cpu, 1);
612                 trace_suspend_resume(TPS("CPU_OFF"), cpu, false);
613                 if (!error)
614                         cpumask_set_cpu(cpu, frozen_cpus);
615                 else {
616                         pr_err("Error taking CPU%d down: %d\n", cpu, error);
617                         break;
618                 }
619         }
620
621         if (!error)
622                 BUG_ON(num_online_cpus() > 1);
623         else
624                 pr_err("Non-boot CPUs are not disabled\n");
625
626         /*
627          * Make sure the CPUs won't be enabled by someone else. We need to do
628          * this even in case of failure as all disable_nonboot_cpus() users are
629          * supposed to do enable_nonboot_cpus() on the failure path.
630          */
631         cpu_hotplug_disabled++;
632
633         cpu_maps_update_done();
634         return error;
635 }
636
637 void __weak arch_enable_nonboot_cpus_begin(void)
638 {
639 }
640
641 void __weak arch_enable_nonboot_cpus_end(void)
642 {
643 }
644
645 void enable_nonboot_cpus(void)
646 {
647         int cpu, error;
648
649         /* Allow everyone to use the CPU hotplug again */
650         cpu_maps_update_begin();
651         WARN_ON(--cpu_hotplug_disabled < 0);
652         if (cpumask_empty(frozen_cpus))
653                 goto out;
654
655         pr_info("Enabling non-boot CPUs ...\n");
656
657         arch_enable_nonboot_cpus_begin();
658
659         for_each_cpu(cpu, frozen_cpus) {
660                 trace_suspend_resume(TPS("CPU_ON"), cpu, true);
661                 error = _cpu_up(cpu, 1);
662                 trace_suspend_resume(TPS("CPU_ON"), cpu, false);
663                 if (!error) {
664                         pr_info("CPU%d is up\n", cpu);
665                         continue;
666                 }
667                 pr_warn("Error taking CPU%d up: %d\n", cpu, error);
668         }
669
670         arch_enable_nonboot_cpus_end();
671
672         cpumask_clear(frozen_cpus);
673 out:
674         cpu_maps_update_done();
675 }
676
677 static int __init alloc_frozen_cpus(void)
678 {
679         if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
680                 return -ENOMEM;
681         return 0;
682 }
683 core_initcall(alloc_frozen_cpus);
684
685 /*
686  * When callbacks for CPU hotplug notifications are being executed, we must
687  * ensure that the state of the system with respect to the tasks being frozen
688  * or not, as reported by the notification, remains unchanged *throughout the
689  * duration* of the execution of the callbacks.
690  * Hence we need to prevent the freezer from racing with regular CPU hotplug.
691  *
692  * This synchronization is implemented by mutually excluding regular CPU
693  * hotplug and Suspend/Hibernate call paths by hooking onto the Suspend/
694  * Hibernate notifications.
695  */
696 static int
697 cpu_hotplug_pm_callback(struct notifier_block *nb,
698                         unsigned long action, void *ptr)
699 {
700         switch (action) {
701
702         case PM_SUSPEND_PREPARE:
703         case PM_HIBERNATION_PREPARE:
704                 cpu_hotplug_disable();
705                 break;
706
707         case PM_POST_SUSPEND:
708         case PM_POST_HIBERNATION:
709                 cpu_hotplug_enable();
710                 break;
711
712         default:
713                 return NOTIFY_DONE;
714         }
715
716         return NOTIFY_OK;
717 }
718
719
720 static int __init cpu_hotplug_pm_sync_init(void)
721 {
722         /*
723          * cpu_hotplug_pm_callback has higher priority than x86
724          * bsp_pm_callback which depends on cpu_hotplug_pm_callback
725          * to disable cpu hotplug to avoid cpu hotplug race.
726          */
727         pm_notifier(cpu_hotplug_pm_callback, 0);
728         return 0;
729 }
730 core_initcall(cpu_hotplug_pm_sync_init);
731
732 #endif /* CONFIG_PM_SLEEP_SMP */
733
734 /**
735  * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers
736  * @cpu: cpu that just started
737  *
738  * This function calls the cpu_chain notifiers with CPU_STARTING.
739  * It must be called by the arch code on the new cpu, before the new cpu
740  * enables interrupts and before the "boot" cpu returns from __cpu_up().
741  */
742 void notify_cpu_starting(unsigned int cpu)
743 {
744         unsigned long val = CPU_STARTING;
745
746 #ifdef CONFIG_PM_SLEEP_SMP
747         if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
748                 val = CPU_STARTING_FROZEN;
749 #endif /* CONFIG_PM_SLEEP_SMP */
750         cpu_notify(val, (void *)(long)cpu);
751 }
752
753 #endif /* CONFIG_SMP */
754
755 /*
756  * cpu_bit_bitmap[] is a special, "compressed" data structure that
757  * represents all NR_CPUS bits binary values of 1<<nr.
758  *
759  * It is used by cpumask_of() to get a constant address to a CPU
760  * mask value that has a single bit set only.
761  */
762
763 /* cpu_bit_bitmap[0] is empty - so we can back into it */
764 #define MASK_DECLARE_1(x)       [x+1][0] = (1UL << (x))
765 #define MASK_DECLARE_2(x)       MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
766 #define MASK_DECLARE_4(x)       MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
767 #define MASK_DECLARE_8(x)       MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
768
769 const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
770
771         MASK_DECLARE_8(0),      MASK_DECLARE_8(8),
772         MASK_DECLARE_8(16),     MASK_DECLARE_8(24),
773 #if BITS_PER_LONG > 32
774         MASK_DECLARE_8(32),     MASK_DECLARE_8(40),
775         MASK_DECLARE_8(48),     MASK_DECLARE_8(56),
776 #endif
777 };
778 EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
779
780 const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
781 EXPORT_SYMBOL(cpu_all_bits);
782
783 #ifdef CONFIG_INIT_ALL_POSSIBLE
784 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
785         = CPU_BITS_ALL;
786 #else
787 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
788 #endif
789 const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
790 EXPORT_SYMBOL(cpu_possible_mask);
791
792 static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
793 const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
794 EXPORT_SYMBOL(cpu_online_mask);
795
796 static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
797 const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
798 EXPORT_SYMBOL(cpu_present_mask);
799
800 static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
801 const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
802 EXPORT_SYMBOL(cpu_active_mask);
803
804 void set_cpu_possible(unsigned int cpu, bool possible)
805 {
806         if (possible)
807                 cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
808         else
809                 cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
810 }
811
812 void set_cpu_present(unsigned int cpu, bool present)
813 {
814         if (present)
815                 cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
816         else
817                 cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
818 }
819
820 void set_cpu_online(unsigned int cpu, bool online)
821 {
822         if (online) {
823                 cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
824                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
825         } else {
826                 cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
827         }
828 }
829
830 void set_cpu_active(unsigned int cpu, bool active)
831 {
832         if (active)
833                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
834         else
835                 cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
836 }
837
838 void init_cpu_present(const struct cpumask *src)
839 {
840         cpumask_copy(to_cpumask(cpu_present_bits), src);
841 }
842
843 void init_cpu_possible(const struct cpumask *src)
844 {
845         cpumask_copy(to_cpumask(cpu_possible_bits), src);
846 }
847
848 void init_cpu_online(const struct cpumask *src)
849 {
850         cpumask_copy(to_cpumask(cpu_online_bits), src);
851 }