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