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