feff73986181b22dd5661387160691bf2b93a8ab
[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         /* And allows lockless put_online_cpus(). */
72         atomic_t puts_pending;
73
74 #ifdef CONFIG_DEBUG_LOCK_ALLOC
75         struct lockdep_map dep_map;
76 #endif
77 } cpu_hotplug = {
78         .active_writer = NULL,
79         .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock),
80         .refcount = 0,
81 #ifdef CONFIG_DEBUG_LOCK_ALLOC
82         .dep_map = {.name = "cpu_hotplug.lock" },
83 #endif
84 };
85
86 /* Lockdep annotations for get/put_online_cpus() and cpu_hotplug_begin/end() */
87 #define cpuhp_lock_acquire_read() lock_map_acquire_read(&cpu_hotplug.dep_map)
88 #define cpuhp_lock_acquire_tryread() \
89                                   lock_map_acquire_tryread(&cpu_hotplug.dep_map)
90 #define cpuhp_lock_acquire()      lock_map_acquire(&cpu_hotplug.dep_map)
91 #define cpuhp_lock_release()      lock_map_release(&cpu_hotplug.dep_map)
92
93 void get_online_cpus(void)
94 {
95         might_sleep();
96         if (cpu_hotplug.active_writer == current)
97                 return;
98         cpuhp_lock_acquire_read();
99         mutex_lock(&cpu_hotplug.lock);
100         cpu_hotplug.refcount++;
101         mutex_unlock(&cpu_hotplug.lock);
102 }
103 EXPORT_SYMBOL_GPL(get_online_cpus);
104
105 bool try_get_online_cpus(void)
106 {
107         if (cpu_hotplug.active_writer == current)
108                 return true;
109         if (!mutex_trylock(&cpu_hotplug.lock))
110                 return false;
111         cpuhp_lock_acquire_tryread();
112         cpu_hotplug.refcount++;
113         mutex_unlock(&cpu_hotplug.lock);
114         return true;
115 }
116 EXPORT_SYMBOL_GPL(try_get_online_cpus);
117
118 void put_online_cpus(void)
119 {
120         if (cpu_hotplug.active_writer == current)
121                 return;
122         if (!mutex_trylock(&cpu_hotplug.lock)) {
123                 atomic_inc(&cpu_hotplug.puts_pending);
124                 cpuhp_lock_release();
125                 return;
126         }
127
128         if (WARN_ON(!cpu_hotplug.refcount))
129                 cpu_hotplug.refcount++; /* try to fix things up */
130
131         if (!--cpu_hotplug.refcount && unlikely(cpu_hotplug.active_writer))
132                 wake_up_process(cpu_hotplug.active_writer);
133         mutex_unlock(&cpu_hotplug.lock);
134         cpuhp_lock_release();
135
136 }
137 EXPORT_SYMBOL_GPL(put_online_cpus);
138
139 /*
140  * This ensures that the hotplug operation can begin only when the
141  * refcount goes to zero.
142  *
143  * Note that during a cpu-hotplug operation, the new readers, if any,
144  * will be blocked by the cpu_hotplug.lock
145  *
146  * Since cpu_hotplug_begin() is always called after invoking
147  * cpu_maps_update_begin(), we can be sure that only one writer is active.
148  *
149  * Note that theoretically, there is a possibility of a livelock:
150  * - Refcount goes to zero, last reader wakes up the sleeping
151  *   writer.
152  * - Last reader unlocks the cpu_hotplug.lock.
153  * - A new reader arrives at this moment, bumps up the refcount.
154  * - The writer acquires the cpu_hotplug.lock finds the refcount
155  *   non zero and goes to sleep again.
156  *
157  * However, this is very difficult to achieve in practice since
158  * get_online_cpus() not an api which is called all that often.
159  *
160  */
161 void cpu_hotplug_begin(void)
162 {
163         cpu_hotplug.active_writer = current;
164
165         cpuhp_lock_acquire();
166         for (;;) {
167                 mutex_lock(&cpu_hotplug.lock);
168                 if (atomic_read(&cpu_hotplug.puts_pending)) {
169                         int delta;
170
171                         delta = atomic_xchg(&cpu_hotplug.puts_pending, 0);
172                         cpu_hotplug.refcount -= delta;
173                 }
174                 if (likely(!cpu_hotplug.refcount))
175                         break;
176                 __set_current_state(TASK_UNINTERRUPTIBLE);
177                 mutex_unlock(&cpu_hotplug.lock);
178                 schedule();
179         }
180 }
181
182 void cpu_hotplug_done(void)
183 {
184         cpu_hotplug.active_writer = NULL;
185         mutex_unlock(&cpu_hotplug.lock);
186         cpuhp_lock_release();
187 }
188
189 /*
190  * Wait for currently running CPU hotplug operations to complete (if any) and
191  * disable future CPU hotplug (from sysfs). The 'cpu_add_remove_lock' protects
192  * the 'cpu_hotplug_disabled' flag. The same lock is also acquired by the
193  * hotplug path before performing hotplug operations. So acquiring that lock
194  * guarantees mutual exclusion from any currently running hotplug operations.
195  */
196 void cpu_hotplug_disable(void)
197 {
198         cpu_maps_update_begin();
199         cpu_hotplug_disabled = 1;
200         cpu_maps_update_done();
201 }
202
203 void cpu_hotplug_enable(void)
204 {
205         cpu_maps_update_begin();
206         cpu_hotplug_disabled = 0;
207         cpu_maps_update_done();
208 }
209
210 #endif  /* CONFIG_HOTPLUG_CPU */
211
212 /* Need to know about CPUs going up/down? */
213 int __ref 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 __ref __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 __ref 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 __ref __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 __ref 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         /* Park the stopper thread */
349         kthread_park(current);
350         return 0;
351 }
352
353 /* Requires cpu_add_remove_lock to be held */
354 static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
355 {
356         int err, nr_calls = 0;
357         void *hcpu = (void *)(long)cpu;
358         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
359         struct take_cpu_down_param tcd_param = {
360                 .mod = mod,
361                 .hcpu = hcpu,
362         };
363
364         if (num_online_cpus() == 1)
365                 return -EBUSY;
366
367         if (!cpu_online(cpu))
368                 return -EINVAL;
369
370         cpu_hotplug_begin();
371
372         err = __cpu_notify(CPU_DOWN_PREPARE | mod, hcpu, -1, &nr_calls);
373         if (err) {
374                 nr_calls--;
375                 __cpu_notify(CPU_DOWN_FAILED | mod, hcpu, nr_calls, NULL);
376                 pr_warn("%s: attempt to take down CPU %u failed\n",
377                         __func__, cpu);
378                 goto out_release;
379         }
380
381         /*
382          * By now we've cleared cpu_active_mask, wait for all preempt-disabled
383          * and RCU users of this state to go away such that all new such users
384          * will observe it.
385          *
386          * For CONFIG_PREEMPT we have preemptible RCU and its sync_rcu() might
387          * not imply sync_sched(), so explicitly call both.
388          *
389          * Do sync before park smpboot threads to take care the rcu boost case.
390          */
391 #ifdef CONFIG_PREEMPT
392         synchronize_sched();
393 #endif
394         synchronize_rcu();
395
396         smpboot_park_threads(cpu);
397
398         /*
399          * So now all preempt/rcu users must observe !cpu_active().
400          */
401
402         err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
403         if (err) {
404                 /* CPU didn't die: tell everyone.  Can't complain. */
405                 smpboot_unpark_threads(cpu);
406                 cpu_notify_nofail(CPU_DOWN_FAILED | mod, hcpu);
407                 goto out_release;
408         }
409         BUG_ON(cpu_online(cpu));
410
411         /*
412          * The migration_call() CPU_DYING callback will have removed all
413          * runnable tasks from the cpu, there's only the idle task left now
414          * that the migration thread is done doing the stop_machine thing.
415          *
416          * Wait for the stop thread to go away.
417          */
418         while (!idle_cpu(cpu))
419                 cpu_relax();
420
421         /* This actually kills the CPU. */
422         __cpu_die(cpu);
423
424         /* CPU is completely dead: tell everyone.  Too late to complain. */
425         cpu_notify_nofail(CPU_DEAD | mod, hcpu);
426
427         check_for_tasks(cpu);
428
429 out_release:
430         cpu_hotplug_done();
431         if (!err)
432                 cpu_notify_nofail(CPU_POST_DEAD | mod, hcpu);
433         return err;
434 }
435
436 int __ref cpu_down(unsigned int cpu)
437 {
438         int err;
439
440         cpu_maps_update_begin();
441
442         if (cpu_hotplug_disabled) {
443                 err = -EBUSY;
444                 goto out;
445         }
446
447         err = _cpu_down(cpu, 0);
448
449 out:
450         cpu_maps_update_done();
451         return err;
452 }
453 EXPORT_SYMBOL(cpu_down);
454 #endif /*CONFIG_HOTPLUG_CPU*/
455
456 /* Requires cpu_add_remove_lock to be held */
457 static int _cpu_up(unsigned int cpu, int tasks_frozen)
458 {
459         int ret, nr_calls = 0;
460         void *hcpu = (void *)(long)cpu;
461         unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
462         struct task_struct *idle;
463
464         cpu_hotplug_begin();
465
466         if (cpu_online(cpu) || !cpu_present(cpu)) {
467                 ret = -EINVAL;
468                 goto out;
469         }
470
471         idle = idle_thread_get(cpu);
472         if (IS_ERR(idle)) {
473                 ret = PTR_ERR(idle);
474                 goto out;
475         }
476
477         ret = smpboot_create_threads(cpu);
478         if (ret)
479                 goto out;
480
481         ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls);
482         if (ret) {
483                 nr_calls--;
484                 pr_warn("%s: attempt to bring up CPU %u failed\n",
485                         __func__, cpu);
486                 goto out_notify;
487         }
488
489         /* Arch-specific enabling code. */
490         ret = __cpu_up(cpu, idle);
491         if (ret != 0)
492                 goto out_notify;
493         BUG_ON(!cpu_online(cpu));
494
495         /* Wake the per cpu threads */
496         smpboot_unpark_threads(cpu);
497
498         /* Now call notifier in preparation. */
499         cpu_notify(CPU_ONLINE | mod, hcpu);
500
501 out_notify:
502         if (ret != 0)
503                 __cpu_notify(CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
504 out:
505         cpu_hotplug_done();
506
507         return ret;
508 }
509
510 int cpu_up(unsigned int cpu)
511 {
512         int err = 0;
513
514         if (!cpu_possible(cpu)) {
515                 pr_err("can't online cpu %d because it is not configured as may-hotadd at boot time\n",
516                        cpu);
517 #if defined(CONFIG_IA64)
518                 pr_err("please check additional_cpus= boot parameter\n");
519 #endif
520                 return -EINVAL;
521         }
522
523         err = try_online_node(cpu_to_node(cpu));
524         if (err)
525                 return err;
526
527         cpu_maps_update_begin();
528
529         if (cpu_hotplug_disabled) {
530                 err = -EBUSY;
531                 goto out;
532         }
533
534         err = _cpu_up(cpu, 0);
535
536 #ifdef CONFIG_MOD_SCHED
537         if(!err)
538                 fw_notify(FW_CPU_ONLINE,&cpu);
539 #endif
540
541 out:
542         cpu_maps_update_done();
543         return err;
544 }
545 EXPORT_SYMBOL_GPL(cpu_up);
546
547 #ifdef CONFIG_PM_SLEEP_SMP
548 static cpumask_var_t frozen_cpus;
549
550 int disable_nonboot_cpus(void)
551 {
552         int cpu, first_cpu, error = 0;
553
554         cpu_maps_update_begin();
555         first_cpu = cpumask_first(cpu_online_mask);
556         /*
557          * We take down all of the non-boot CPUs in one shot to avoid races
558          * with the userspace trying to use the CPU hotplug at the same time
559          */
560         cpumask_clear(frozen_cpus);
561
562         pr_info("Disabling non-boot CPUs ...\n");
563         for_each_online_cpu(cpu) {
564                 if (cpu == first_cpu)
565                         continue;
566                 trace_suspend_resume(TPS("CPU_OFF"), cpu, true);
567                 error = _cpu_down(cpu, 1);
568                 trace_suspend_resume(TPS("CPU_OFF"), cpu, false);
569                 if (!error)
570                         cpumask_set_cpu(cpu, frozen_cpus);
571                 else {
572                         pr_err("Error taking CPU%d down: %d\n", cpu, error);
573                         break;
574                 }
575         }
576
577         if (!error) {
578                 BUG_ON(num_online_cpus() > 1);
579                 /* Make sure the CPUs won't be enabled by someone else */
580                 cpu_hotplug_disabled = 1;
581         } else {
582                 pr_err("Non-boot CPUs are not disabled\n");
583         }
584         cpu_maps_update_done();
585         return error;
586 }
587
588 void __weak arch_enable_nonboot_cpus_begin(void)
589 {
590 }
591
592 void __weak arch_enable_nonboot_cpus_end(void)
593 {
594 }
595
596 void __ref enable_nonboot_cpus(void)
597 {
598         int cpu, error;
599
600         /* Allow everyone to use the CPU hotplug again */
601         cpu_maps_update_begin();
602         cpu_hotplug_disabled = 0;
603         if (cpumask_empty(frozen_cpus))
604                 goto out;
605
606         pr_info("Enabling non-boot CPUs ...\n");
607
608         arch_enable_nonboot_cpus_begin();
609
610         for_each_cpu(cpu, frozen_cpus) {
611                 trace_suspend_resume(TPS("CPU_ON"), cpu, true);
612                 error = _cpu_up(cpu, 1);
613                 trace_suspend_resume(TPS("CPU_ON"), cpu, false);
614                 if (!error) {
615                         pr_info("CPU%d is up\n", cpu);
616                         continue;
617                 }
618                 pr_warn("Error taking CPU%d up: %d\n", cpu, error);
619         }
620
621         arch_enable_nonboot_cpus_end();
622
623         cpumask_clear(frozen_cpus);
624 out:
625         cpu_maps_update_done();
626 }
627
628 static int __init alloc_frozen_cpus(void)
629 {
630         if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
631                 return -ENOMEM;
632         return 0;
633 }
634 core_initcall(alloc_frozen_cpus);
635
636 /*
637  * When callbacks for CPU hotplug notifications are being executed, we must
638  * ensure that the state of the system with respect to the tasks being frozen
639  * or not, as reported by the notification, remains unchanged *throughout the
640  * duration* of the execution of the callbacks.
641  * Hence we need to prevent the freezer from racing with regular CPU hotplug.
642  *
643  * This synchronization is implemented by mutually excluding regular CPU
644  * hotplug and Suspend/Hibernate call paths by hooking onto the Suspend/
645  * Hibernate notifications.
646  */
647 static int
648 cpu_hotplug_pm_callback(struct notifier_block *nb,
649                         unsigned long action, void *ptr)
650 {
651         switch (action) {
652
653         case PM_SUSPEND_PREPARE:
654         case PM_HIBERNATION_PREPARE:
655                 cpu_hotplug_disable();
656                 break;
657
658         case PM_POST_SUSPEND:
659         case PM_POST_HIBERNATION:
660                 cpu_hotplug_enable();
661                 break;
662
663         default:
664                 return NOTIFY_DONE;
665         }
666
667         return NOTIFY_OK;
668 }
669
670
671 static int __init cpu_hotplug_pm_sync_init(void)
672 {
673         /*
674          * cpu_hotplug_pm_callback has higher priority than x86
675          * bsp_pm_callback which depends on cpu_hotplug_pm_callback
676          * to disable cpu hotplug to avoid cpu hotplug race.
677          */
678         pm_notifier(cpu_hotplug_pm_callback, 0);
679         return 0;
680 }
681 core_initcall(cpu_hotplug_pm_sync_init);
682
683 #endif /* CONFIG_PM_SLEEP_SMP */
684
685 /**
686  * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers
687  * @cpu: cpu that just started
688  *
689  * This function calls the cpu_chain notifiers with CPU_STARTING.
690  * It must be called by the arch code on the new cpu, before the new cpu
691  * enables interrupts and before the "boot" cpu returns from __cpu_up().
692  */
693 void notify_cpu_starting(unsigned int cpu)
694 {
695         unsigned long val = CPU_STARTING;
696
697 #ifdef CONFIG_PM_SLEEP_SMP
698         if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
699                 val = CPU_STARTING_FROZEN;
700 #endif /* CONFIG_PM_SLEEP_SMP */
701         cpu_notify(val, (void *)(long)cpu);
702 }
703
704 #endif /* CONFIG_SMP */
705
706 /*
707  * cpu_bit_bitmap[] is a special, "compressed" data structure that
708  * represents all NR_CPUS bits binary values of 1<<nr.
709  *
710  * It is used by cpumask_of() to get a constant address to a CPU
711  * mask value that has a single bit set only.
712  */
713
714 /* cpu_bit_bitmap[0] is empty - so we can back into it */
715 #define MASK_DECLARE_1(x)       [x+1][0] = (1UL << (x))
716 #define MASK_DECLARE_2(x)       MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
717 #define MASK_DECLARE_4(x)       MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
718 #define MASK_DECLARE_8(x)       MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
719
720 const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
721
722         MASK_DECLARE_8(0),      MASK_DECLARE_8(8),
723         MASK_DECLARE_8(16),     MASK_DECLARE_8(24),
724 #if BITS_PER_LONG > 32
725         MASK_DECLARE_8(32),     MASK_DECLARE_8(40),
726         MASK_DECLARE_8(48),     MASK_DECLARE_8(56),
727 #endif
728 };
729 EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
730
731 const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
732 EXPORT_SYMBOL(cpu_all_bits);
733
734 #ifdef CONFIG_INIT_ALL_POSSIBLE
735 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
736         = CPU_BITS_ALL;
737 #else
738 static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
739 #endif
740 const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
741 EXPORT_SYMBOL(cpu_possible_mask);
742
743 static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
744 const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
745 EXPORT_SYMBOL(cpu_online_mask);
746
747 static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
748 const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
749 EXPORT_SYMBOL(cpu_present_mask);
750
751 static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
752 const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
753 EXPORT_SYMBOL(cpu_active_mask);
754
755 void set_cpu_possible(unsigned int cpu, bool possible)
756 {
757         if (possible)
758                 cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
759         else
760                 cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
761 }
762
763 void set_cpu_present(unsigned int cpu, bool present)
764 {
765         if (present)
766                 cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
767         else
768                 cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
769 }
770
771 void set_cpu_online(unsigned int cpu, bool online)
772 {
773         if (online) {
774                 cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
775                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
776         } else {
777                 cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
778         }
779 }
780
781 void set_cpu_active(unsigned int cpu, bool active)
782 {
783         if (active)
784                 cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
785         else
786                 cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
787 }
788
789 void init_cpu_present(const struct cpumask *src)
790 {
791         cpumask_copy(to_cpumask(cpu_present_bits), src);
792 }
793
794 void init_cpu_possible(const struct cpumask *src)
795 {
796         cpumask_copy(to_cpumask(cpu_possible_bits), src);
797 }
798
799 void init_cpu_online(const struct cpumask *src)
800 {
801         cpumask_copy(to_cpumask(cpu_online_bits), src);
802 }