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