arch/arm64/kernel/smp.c

   1 /*
   2  * SMP initialisation and IPI support
   3  * Based on arch/arm/kernel/smp.c
   4  *
   5  * Copyright (C) 2012 ARM Ltd.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <linux/acpi.h>
  21 #include <linux/delay.h>
  22 #include <linux/init.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/sched/mm.h>
  25 #include <linux/sched/hotplug.h>
  26 #include <linux/sched/task_stack.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/cache.h>
  29 #include <linux/profile.h>
  30 #include <linux/errno.h>
  31 #include <linux/mm.h>
  32 #include <linux/err.h>
  33 #include <linux/cpu.h>
  34 #include <linux/smp.h>
  35 #include <linux/seq_file.h>
  36 #include <linux/irq.h>
  37 #include <linux/percpu.h>
  38 #include <linux/clockchips.h>
  39 #include <linux/completion.h>
  40 #include <linux/of.h>
  41 #include <linux/irq_work.h>
  42 #include <linux/kexec.h>
  43
  44 #include <asm/alternative.h>
  45 #include <asm/atomic.h>
  46 #include <asm/cacheflush.h>
  47 #include <asm/cpu.h>
  48 #include <asm/cputype.h>
  49 #include <asm/cpu_ops.h>
  50 #include <asm/daifflags.h>
  51 #include <asm/mmu_context.h>
  52 #include <asm/numa.h>
  53 #include <asm/pgtable.h>
  54 #include <asm/pgalloc.h>
  55 #include <asm/processor.h>
  56 #include <asm/smp_plat.h>
  57 #include <asm/sections.h>
  58 #include <asm/tlbflush.h>
  59 #include <asm/ptrace.h>
  60 #include <asm/virt.h>
  61
  62 #define CREATE_TRACE_POINTS
  63 #include <trace/events/ipi.h>
  64
  65 DEFINE_PER_CPU_READ_MOSTLY(int, cpu_number);
  66 EXPORT_PER_CPU_SYMBOL(cpu_number);
  67
  68 /*
  69  * as from 2.5, kernels no longer have an init_tasks structure
  70  * so we need some other way of telling a new secondary core
  71  * where to place its SVC stack
  72  */
  73 struct secondary_data secondary_data;
  74 /* Number of CPUs which aren't online, but looping in kernel text. */
  75 int cpus_stuck_in_kernel;
  76
  77 enum ipi_msg_type {
  78         IPI_RESCHEDULE,
  79         IPI_CALL_FUNC,
  80         IPI_CPU_STOP,
  81         IPI_CPU_CRASH_STOP,
  82         IPI_TIMER,
  83         IPI_IRQ_WORK,
  84         IPI_WAKEUP
  85 };
  86
  87 #ifdef CONFIG_ARM64_VHE
  88
  89 /* Whether the boot CPU is running in HYP mode or not*/
  90 static bool boot_cpu_hyp_mode;
  91
  92 static inline void save_boot_cpu_run_el(void)
  93 {
  94         boot_cpu_hyp_mode = is_kernel_in_hyp_mode();
  95 }
  96
  97 static inline bool is_boot_cpu_in_hyp_mode(void)
  98 {
  99         return boot_cpu_hyp_mode;
 100 }
 101
 102 /*
 103  * Verify that a secondary CPU is running the kernel at the same
 104  * EL as that of the boot CPU.
 105  */
 106 void verify_cpu_run_el(void)
 107 {
 108         bool in_el2 = is_kernel_in_hyp_mode();
 109         bool boot_cpu_el2 = is_boot_cpu_in_hyp_mode();
 110
 111         if (in_el2 ^ boot_cpu_el2) {
 112                 pr_crit("CPU%d: mismatched Exception Level(EL%d) with boot CPU(EL%d)\n",
 113                                         smp_processor_id(),
 114                                         in_el2 ? 2 : 1,
 115                                         boot_cpu_el2 ? 2 : 1);
 116                 cpu_panic_kernel();
 117         }
 118 }
 119
 120 #else
 121 static inline void save_boot_cpu_run_el(void) {}
 122 #endif
 123
 124 #ifdef CONFIG_HOTPLUG_CPU
 125 static int op_cpu_kill(unsigned int cpu);
 126 #else
 127 static inline int op_cpu_kill(unsigned int cpu)
 128 {
 129         return -ENOSYS;
 130 }
 131 #endif
 132
 133
 134 /*
 135  * Boot a secondary CPU, and assign it the specified idle task.
 136  * This also gives us the initial stack to use for this CPU.
 137  */
 138 static int boot_secondary(unsigned int cpu, struct task_struct *idle)
 139 {
 140         if (cpu_ops[cpu]->cpu_boot)
 141                 return cpu_ops[cpu]->cpu_boot(cpu);
 142
 143         return -EOPNOTSUPP;
 144 }
 145
 146 static DECLARE_COMPLETION(cpu_running);
 147
 148 int __cpu_up(unsigned int cpu, struct task_struct *idle)
 149 {
 150         int ret;
 151         long status;
 152
 153         /*
 154          * We need to tell the secondary core where to find its stack and the
 155          * page tables.
 156          */
 157         secondary_data.task = idle;
 158         secondary_data.stack = task_stack_page(idle) + THREAD_SIZE;
 159         update_cpu_boot_status(CPU_MMU_OFF);
 160         __flush_dcache_area(&secondary_data, sizeof(secondary_data));
 161
 162         /*
 163          * Now bring the CPU into our world.
 164          */
 165         ret = boot_secondary(cpu, idle);
 166         if (ret == 0) {
 167                 /*
 168                  * CPU was successfully started, wait for it to come online or
 169                  * time out.
 170                  */
 171                 wait_for_completion_timeout(&cpu_running,
 172                                             msecs_to_jiffies(1000));
 173
 174                 if (!cpu_online(cpu)) {
 175                         pr_crit("CPU%u: failed to come online\n", cpu);
 176                         ret = -EIO;
 177                 }
 178         } else {
 179                 pr_err("CPU%u: failed to boot: %d\n", cpu, ret);
 180         }
 181
 182         secondary_data.task = NULL;
 183         secondary_data.stack = NULL;
 184         status = READ_ONCE(secondary_data.status);
 185         if (ret && status) {
 186
 187                 if (status == CPU_MMU_OFF)
 188                         status = READ_ONCE(__early_cpu_boot_status);
 189
 190                 switch (status) {
 191                 default:
 192                         pr_err("CPU%u: failed in unknown state : 0x%lx\n",
 193                                         cpu, status);
 194                         break;
 195                 case CPU_KILL_ME:
 196                         if (!op_cpu_kill(cpu)) {
 197                                 pr_crit("CPU%u: died during early boot\n", cpu);
 198                                 break;
 199                         }
 200                         /* Fall through */
 201                         pr_crit("CPU%u: may not have shut down cleanly\n", cpu);
 202                 case CPU_STUCK_IN_KERNEL:
 203                         pr_crit("CPU%u: is stuck in kernel\n", cpu);
 204                         cpus_stuck_in_kernel++;
 205                         break;
 206                 case CPU_PANIC_KERNEL:
 207                         panic("CPU%u detected unsupported configuration\n", cpu);
 208                 }
 209         }
 210
 211         return ret;
 212 }
 213
 214 /*
 215  * This is the secondary CPU boot entry.  We're using this CPUs
 216  * idle thread stack, but a set of temporary page tables.
 217  */
 218 asmlinkage void secondary_start_kernel(void)
 219 {
 220         u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;
 221         struct mm_struct *mm = &init_mm;
 222         unsigned int cpu;
 223
 224         cpu = task_cpu(current);
 225         set_my_cpu_offset(per_cpu_offset(cpu));
 226
 227         /*
 228          * All kernel threads share the same mm context; grab a
 229          * reference and switch to it.
 230          */
 231         mmgrab(mm);
 232         current->active_mm = mm;
 233
 234         /*
 235          * TTBR0 is only used for the identity mapping at this stage. Make it
 236          * point to zero page to avoid speculatively fetching new entries.
 237          */
 238         cpu_uninstall_idmap();
 239
 240         preempt_disable();
 241         trace_hardirqs_off();
 242
 243         /*
 244          * If the system has established the capabilities, make sure
 245          * this CPU ticks all of those. If it doesn't, the CPU will
 246          * fail to come online.
 247          */
 248         check_local_cpu_capabilities();
 249
 250         if (cpu_ops[cpu]->cpu_postboot)
 251                 cpu_ops[cpu]->cpu_postboot();
 252
 253         /*
 254          * Log the CPU info before it is marked online and might get read.
 255          */
 256         cpuinfo_store_cpu();
 257
 258         /*
 259          * Enable GIC and timers.
 260          */
 261         notify_cpu_starting(cpu);
 262
 263         store_cpu_topology(cpu);
 264
 265         /*
 266          * OK, now it's safe to let the boot CPU continue.  Wait for
 267          * the CPU migration code to notice that the CPU is online
 268          * before we continue.
 269          */
 270         pr_info("CPU%u: Booted secondary processor 0x%010lx [0x%08x]\n",
 271                                          cpu, (unsigned long)mpidr,
 272                                          read_cpuid_id());
 273         update_cpu_boot_status(CPU_BOOT_SUCCESS);
 274         set_cpu_online(cpu, true);
 275         complete(&cpu_running);
 276
 277         local_daif_restore(DAIF_PROCCTX);
 278
 279         /*
 280          * OK, it's off to the idle thread for us
 281          */
 282         cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
 283 }
 284
 285 #ifdef CONFIG_HOTPLUG_CPU
 286 static int op_cpu_disable(unsigned int cpu)
 287 {
 288         /*
 289          * If we don't have a cpu_die method, abort before we reach the point
 290          * of no return. CPU0 may not have an cpu_ops, so test for it.
 291          */
 292         if (!cpu_ops[cpu] || !cpu_ops[cpu]->cpu_die)
 293                 return -EOPNOTSUPP;
 294
 295         /*
 296          * We may need to abort a hot unplug for some other mechanism-specific
 297          * reason.
 298          */
 299         if (cpu_ops[cpu]->cpu_disable)
 300                 return cpu_ops[cpu]->cpu_disable(cpu);
 301
 302         return 0;
 303 }
 304
 305 /*
 306  * __cpu_disable runs on the processor to be shutdown.
 307  */
 308 int __cpu_disable(void)
 309 {
 310         unsigned int cpu = smp_processor_id();
 311         int ret;
 312
 313         ret = op_cpu_disable(cpu);
 314         if (ret)
 315                 return ret;
 316
 317         /*
 318          * Take this CPU offline.  Once we clear this, we can't return,
 319          * and we must not schedule until we're ready to give up the cpu.
 320          */
 321         set_cpu_online(cpu, false);
 322
 323         /*
 324          * OK - migrate IRQs away from this CPU
 325          */
 326         irq_migrate_all_off_this_cpu();
 327
 328         return 0;
 329 }
 330
 331 static int op_cpu_kill(unsigned int cpu)
 332 {
 333         /*
 334          * If we have no means of synchronising with the dying CPU, then assume
 335          * that it is really dead. We can only wait for an arbitrary length of
 336          * time and hope that it's dead, so let's skip the wait and just hope.
 337          */
 338         if (!cpu_ops[cpu]->cpu_kill)
 339                 return 0;
 340
 341         return cpu_ops[cpu]->cpu_kill(cpu);
 342 }
 343
 344 /*
 345  * called on the thread which is asking for a CPU to be shutdown -
 346  * waits until shutdown has completed, or it is timed out.
 347  */
 348 void __cpu_die(unsigned int cpu)
 349 {
 350         int err;
 351
 352         if (!cpu_wait_death(cpu, 5)) {
 353                 pr_crit("CPU%u: cpu didn't die\n", cpu);
 354                 return;
 355         }
 356         pr_notice("CPU%u: shutdown\n", cpu);
 357
 358         /*
 359          * Now that the dying CPU is beyond the point of no return w.r.t.
 360          * in-kernel synchronisation, try to get the firwmare to help us to
 361          * verify that it has really left the kernel before we consider
 362          * clobbering anything it might still be using.
 363          */
 364         err = op_cpu_kill(cpu);
 365         if (err)
 366                 pr_warn("CPU%d may not have shut down cleanly: %d\n",
 367                         cpu, err);
 368 }
 369
 370 /*
 371  * Called from the idle thread for the CPU which has been shutdown.
 372  *
 373  */
 374 void cpu_die(void)
 375 {
 376         unsigned int cpu = smp_processor_id();
 377
 378         idle_task_exit();
 379
 380         local_daif_mask();
 381
 382         /* Tell __cpu_die() that this CPU is now safe to dispose of */
 383         (void)cpu_report_death();
 384
 385         /*
 386          * Actually shutdown the CPU. This must never fail. The specific hotplug
 387          * mechanism must perform all required cache maintenance to ensure that
 388          * no dirty lines are lost in the process of shutting down the CPU.
 389          */
 390         cpu_ops[cpu]->cpu_die(cpu);
 391
 392         BUG();
 393 }
 394 #endif
 395
 396 /*
 397  * Kill the calling secondary CPU, early in bringup before it is turned
 398  * online.
 399  */
 400 void cpu_die_early(void)
 401 {
 402         int cpu = smp_processor_id();
 403
 404         pr_crit("CPU%d: will not boot\n", cpu);
 405
 406         /* Mark this CPU absent */
 407         set_cpu_present(cpu, 0);
 408
 409 #ifdef CONFIG_HOTPLUG_CPU
 410         update_cpu_boot_status(CPU_KILL_ME);
 411         /* Check if we can park ourselves */
 412         if (cpu_ops[cpu] && cpu_ops[cpu]->cpu_die)
 413                 cpu_ops[cpu]->cpu_die(cpu);
 414 #endif
 415         update_cpu_boot_status(CPU_STUCK_IN_KERNEL);
 416
 417         cpu_park_loop();
 418 }
 419
 420 static void __init hyp_mode_check(void)
 421 {
 422         if (is_hyp_mode_available())
 423                 pr_info("CPU: All CPU(s) started at EL2\n");
 424         else if (is_hyp_mode_mismatched())
 425                 WARN_TAINT(1, TAINT_CPU_OUT_OF_SPEC,
 426                            "CPU: CPUs started in inconsistent modes");
 427         else
 428                 pr_info("CPU: All CPU(s) started at EL1\n");
 429 }
 430
 431 void __init smp_cpus_done(unsigned int max_cpus)
 432 {
 433         pr_info("SMP: Total of %d processors activated.\n", num_online_cpus());
 434         setup_cpu_features();
 435         hyp_mode_check();
 436         apply_alternatives_all();
 437         mark_linear_text_alias_ro();
 438 }
 439
 440 void __init smp_prepare_boot_cpu(void)
 441 {
 442         set_my_cpu_offset(per_cpu_offset(smp_processor_id()));
 443         /*
 444          * Initialise the static keys early as they may be enabled by the
 445          * cpufeature code.
 446          */
 447         jump_label_init();
 448         cpuinfo_store_boot_cpu();
 449         save_boot_cpu_run_el();
 450         /*
 451          * Run the errata work around checks on the boot CPU, once we have
 452          * initialised the cpu feature infrastructure from
 453          * cpuinfo_store_boot_cpu() above.
 454          */
 455         update_cpu_errata_workarounds();
 456 }
 457
 458 static u64 __init of_get_cpu_mpidr(struct device_node *dn)
 459 {
 460         const __be32 *cell;
 461         u64 hwid;
 462
 463         /*
 464          * A cpu node with missing "reg" property is
 465          * considered invalid to build a cpu_logical_map
 466          * entry.
 467          */
 468         cell = of_get_property(dn, "reg", NULL);
 469         if (!cell) {
 470                 pr_err("%pOF: missing reg property\n", dn);
 471                 return INVALID_HWID;
 472         }
 473
 474         hwid = of_read_number(cell, of_n_addr_cells(dn));
 475         /*
 476          * Non affinity bits must be set to 0 in the DT
 477          */
 478         if (hwid & ~MPIDR_HWID_BITMASK) {
 479                 pr_err("%pOF: invalid reg property\n", dn);
 480                 return INVALID_HWID;
 481         }
 482         return hwid;
 483 }
 484
 485 /*
 486  * Duplicate MPIDRs are a recipe for disaster. Scan all initialized
 487  * entries and check for duplicates. If any is found just ignore the
 488  * cpu. cpu_logical_map was initialized to INVALID_HWID to avoid
 489  * matching valid MPIDR values.
 490  */
 491 static bool __init is_mpidr_duplicate(unsigned int cpu, u64 hwid)
 492 {
 493         unsigned int i;
 494
 495         for (i = 1; (i < cpu) && (i < NR_CPUS); i++)
 496                 if (cpu_logical_map(i) == hwid)
 497                         return true;
 498         return false;
 499 }
 500
 501 /*
 502  * Initialize cpu operations for a logical cpu and
 503  * set it in the possible mask on success
 504  */
 505 static int __init smp_cpu_setup(int cpu)
 506 {
 507         if (cpu_read_ops(cpu))
 508                 return -ENODEV;
 509
 510         if (cpu_ops[cpu]->cpu_init(cpu))
 511                 return -ENODEV;
 512
 513         set_cpu_possible(cpu, true);
 514
 515         return 0;
 516 }
 517
 518 static bool bootcpu_valid __initdata;
 519 static unsigned int cpu_count = 1;
 520
 521 #ifdef CONFIG_ACPI
 522 static struct acpi_madt_generic_interrupt cpu_madt_gicc[NR_CPUS];
 523
 524 struct acpi_madt_generic_interrupt *acpi_cpu_get_madt_gicc(int cpu)
 525 {
 526         return &cpu_madt_gicc[cpu];
 527 }
 528
 529 /*
 530  * acpi_map_gic_cpu_interface - parse processor MADT entry
 531  *
 532  * Carry out sanity checks on MADT processor entry and initialize
 533  * cpu_logical_map on success
 534  */
 535 static void __init
 536 acpi_map_gic_cpu_interface(struct acpi_madt_generic_interrupt *processor)
 537 {
 538         u64 hwid = processor->arm_mpidr;
 539
 540         if (!(processor->flags & ACPI_MADT_ENABLED)) {
 541                 pr_debug("skipping disabled CPU entry with 0x%llx MPIDR\n", hwid);
 542                 return;
 543         }
 544
 545         if (hwid & ~MPIDR_HWID_BITMASK || hwid == INVALID_HWID) {
 546                 pr_err("skipping CPU entry with invalid MPIDR 0x%llx\n", hwid);
 547                 return;
 548         }
 549
 550         if (is_mpidr_duplicate(cpu_count, hwid)) {
 551                 pr_err("duplicate CPU MPIDR 0x%llx in MADT\n", hwid);
 552                 return;
 553         }
 554
 555         /* Check if GICC structure of boot CPU is available in the MADT */
 556         if (cpu_logical_map(0) == hwid) {
 557                 if (bootcpu_valid) {
 558                         pr_err("duplicate boot CPU MPIDR: 0x%llx in MADT\n",
 559                                hwid);
 560                         return;
 561                 }
 562                 bootcpu_valid = true;
 563                 cpu_madt_gicc[0] = *processor;
 564                 early_map_cpu_to_node(0, acpi_numa_get_nid(0, hwid));
 565                 return;
 566         }
 567
 568         if (cpu_count >= NR_CPUS)
 569                 return;
 570
 571         /* map the logical cpu id to cpu MPIDR */
 572         cpu_logical_map(cpu_count) = hwid;
 573
 574         cpu_madt_gicc[cpu_count] = *processor;
 575
 576         /*
 577          * Set-up the ACPI parking protocol cpu entries
 578          * while initializing the cpu_logical_map to
 579          * avoid parsing MADT entries multiple times for
 580          * nothing (ie a valid cpu_logical_map entry should
 581          * contain a valid parking protocol data set to
 582          * initialize the cpu if the parking protocol is
 583          * the only available enable method).
 584          */
 585         acpi_set_mailbox_entry(cpu_count, processor);
 586
 587         early_map_cpu_to_node(cpu_count, acpi_numa_get_nid(cpu_count, hwid));
 588
 589         cpu_count++;
 590 }
 591
 592 static int __init
 593 acpi_parse_gic_cpu_interface(struct acpi_subtable_header *header,
 594                              const unsigned long end)
 595 {
 596         struct acpi_madt_generic_interrupt *processor;
 597
 598         processor = (struct acpi_madt_generic_interrupt *)header;
 599         if (BAD_MADT_GICC_ENTRY(processor, end))
 600                 return -EINVAL;
 601
 602         acpi_table_print_madt_entry(header);
 603
 604         acpi_map_gic_cpu_interface(processor);
 605
 606         return 0;
 607 }
 608 #else
 609 #define acpi_table_parse_madt(...)      do { } while (0)
 610 #endif
 611
 612 /*
 613  * Enumerate the possible CPU set from the device tree and build the
 614  * cpu logical map array containing MPIDR values related to logical
 615  * cpus. Assumes that cpu_logical_map(0) has already been initialized.
 616  */
 617 static void __init of_parse_and_init_cpus(void)
 618 {
 619         struct device_node *dn;
 620
 621         for_each_node_by_type(dn, "cpu") {
 622                 u64 hwid = of_get_cpu_mpidr(dn);
 623
 624                 if (hwid == INVALID_HWID)
 625                         goto next;
 626
 627                 if (is_mpidr_duplicate(cpu_count, hwid)) {
 628                         pr_err("%pOF: duplicate cpu reg properties in the DT\n",
 629                                 dn);
 630                         goto next;
 631                 }
 632
 633                 /*
 634                  * The numbering scheme requires that the boot CPU
 635                  * must be assigned logical id 0. Record it so that
 636                  * the logical map built from DT is validated and can
 637                  * be used.
 638                  */
 639                 if (hwid == cpu_logical_map(0)) {
 640                         if (bootcpu_valid) {
 641                                 pr_err("%pOF: duplicate boot cpu reg property in DT\n",
 642                                         dn);
 643                                 goto next;
 644                         }
 645
 646                         bootcpu_valid = true;
 647                         early_map_cpu_to_node(0, of_node_to_nid(dn));
 648
 649                         /*
 650                          * cpu_logical_map has already been
 651                          * initialized and the boot cpu doesn't need
 652                          * the enable-method so continue without
 653                          * incrementing cpu.
 654                          */
 655                         continue;
 656                 }
 657
 658                 if (cpu_count >= NR_CPUS)
 659                         goto next;
 660
 661                 pr_debug("cpu logical map 0x%llx\n", hwid);
 662                 cpu_logical_map(cpu_count) = hwid;
 663
 664                 early_map_cpu_to_node(cpu_count, of_node_to_nid(dn));
 665 next:
 666                 cpu_count++;
 667         }
 668 }
 669
 670 /*
 671  * Enumerate the possible CPU set from the device tree or ACPI and build the
 672  * cpu logical map array containing MPIDR values related to logical
 673  * cpus. Assumes that cpu_logical_map(0) has already been initialized.
 674  */
 675 void __init smp_init_cpus(void)
 676 {
 677         int i;
 678
 679         if (acpi_disabled)
 680                 of_parse_and_init_cpus();
 681         else
 682                 /*
 683                  * do a walk of MADT to determine how many CPUs
 684                  * we have including disabled CPUs, and get information
 685                  * we need for SMP init
 686                  */
 687                 acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT,
 688                                       acpi_parse_gic_cpu_interface, 0);
 689
 690         if (cpu_count > nr_cpu_ids)
 691                 pr_warn("Number of cores (%d) exceeds configured maximum of %u - clipping\n",
 692                         cpu_count, nr_cpu_ids);
 693
 694         if (!bootcpu_valid) {
 695                 pr_err("missing boot CPU MPIDR, not enabling secondaries\n");
 696                 return;
 697         }
 698
 699         /*
 700          * We need to set the cpu_logical_map entries before enabling
 701          * the cpus so that cpu processor description entries (DT cpu nodes
 702          * and ACPI MADT entries) can be retrieved by matching the cpu hwid
 703          * with entries in cpu_logical_map while initializing the cpus.
 704          * If the cpu set-up fails, invalidate the cpu_logical_map entry.
 705          */
 706         for (i = 1; i < nr_cpu_ids; i++) {
 707                 if (cpu_logical_map(i) != INVALID_HWID) {
 708                         if (smp_cpu_setup(i))
 709                                 cpu_logical_map(i) = INVALID_HWID;
 710                 }
 711         }
 712 }
 713
 714 void __init smp_prepare_cpus(unsigned int max_cpus)
 715 {
 716         int err;
 717         unsigned int cpu;
 718         unsigned int this_cpu;
 719
 720         init_cpu_topology();
 721
 722         this_cpu = smp_processor_id();
 723         store_cpu_topology(this_cpu);
 724         numa_store_cpu_info(this_cpu);
 725
 726         /*
 727          * If UP is mandated by "nosmp" (which implies "maxcpus=0"), don't set
 728          * secondary CPUs present.
 729          */
 730         if (max_cpus == 0)
 731                 return;
 732
 733         /*
 734          * Initialise the present map (which describes the set of CPUs
 735          * actually populated at the present time) and release the
 736          * secondaries from the bootloader.
 737          */
 738         for_each_possible_cpu(cpu) {
 739
 740                 per_cpu(cpu_number, cpu) = cpu;
 741
 742                 if (cpu == smp_processor_id())
 743                         continue;
 744
 745                 if (!cpu_ops[cpu])
 746                         continue;
 747
 748                 err = cpu_ops[cpu]->cpu_prepare(cpu);
 749                 if (err)
 750                         continue;
 751
 752                 set_cpu_present(cpu, true);
 753                 numa_store_cpu_info(cpu);
 754         }
 755 }
 756
 757 void (*__smp_cross_call)(const struct cpumask *, unsigned int);
 758
 759 void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned int))
 760 {
 761         __smp_cross_call = fn;
 762 }
 763
 764 static const char *ipi_types[NR_IPI] __tracepoint_string = {
 765 #define S(x,s)  [x] = s
 766         S(IPI_RESCHEDULE, "Rescheduling interrupts"),
 767         S(IPI_CALL_FUNC, "Function call interrupts"),
 768         S(IPI_CPU_STOP, "CPU stop interrupts"),
 769         S(IPI_CPU_CRASH_STOP, "CPU stop (for crash dump) interrupts"),
 770         S(IPI_TIMER, "Timer broadcast interrupts"),
 771         S(IPI_IRQ_WORK, "IRQ work interrupts"),
 772         S(IPI_WAKEUP, "CPU wake-up interrupts"),
 773 };
 774
 775 static void smp_cross_call(const struct cpumask *target, unsigned int ipinr)
 776 {
 777         trace_ipi_raise(target, ipi_types[ipinr]);
 778         __smp_cross_call(target, ipinr);
 779 }
 780
 781 void show_ipi_list(struct seq_file *p, int prec)
 782 {
 783         unsigned int cpu, i;
 784
 785         for (i = 0; i < NR_IPI; i++) {
 786                 seq_printf(p, "%*s%u:%s", prec - 1, "IPI", i,
 787                            prec >= 4 ? " " : "");
 788                 for_each_online_cpu(cpu)
 789                         seq_printf(p, "%10u ",
 790                                    __get_irq_stat(cpu, ipi_irqs[i]));
 791                 seq_printf(p, "      %s\n", ipi_types[i]);
 792         }
 793 }
 794
 795 u64 smp_irq_stat_cpu(unsigned int cpu)
 796 {
 797         u64 sum = 0;
 798         int i;
 799
 800         for (i = 0; i < NR_IPI; i++)
 801                 sum += __get_irq_stat(cpu, ipi_irqs[i]);
 802
 803         return sum;
 804 }
 805
 806 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 807 {
 808         smp_cross_call(mask, IPI_CALL_FUNC);
 809 }
 810
 811 void arch_send_call_function_single_ipi(int cpu)
 812 {
 813         smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC);
 814 }
 815
 816 #ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
 817 void arch_send_wakeup_ipi_mask(const struct cpumask *mask)
 818 {
 819         smp_cross_call(mask, IPI_WAKEUP);
 820 }
 821 #endif
 822
 823 #ifdef CONFIG_IRQ_WORK
 824 void arch_irq_work_raise(void)
 825 {
 826         if (__smp_cross_call)
 827                 smp_cross_call(cpumask_of(smp_processor_id()), IPI_IRQ_WORK);
 828 }
 829 #endif
 830
 831 /*
 832  * ipi_cpu_stop - handle IPI from smp_send_stop()
 833  */
 834 static void ipi_cpu_stop(unsigned int cpu)
 835 {
 836         set_cpu_online(cpu, false);
 837
 838         local_daif_mask();
 839
 840         while (1)
 841                 cpu_relax();
 842 }
 843
 844 #ifdef CONFIG_KEXEC_CORE
 845 static atomic_t waiting_for_crash_ipi = ATOMIC_INIT(0);
 846 #endif
 847
 848 static void ipi_cpu_crash_stop(unsigned int cpu, struct pt_regs *regs)
 849 {
 850 #ifdef CONFIG_KEXEC_CORE
 851         crash_save_cpu(regs, cpu);
 852
 853         atomic_dec(&waiting_for_crash_ipi);
 854
 855         local_irq_disable();
 856
 857 #ifdef CONFIG_HOTPLUG_CPU
 858         if (cpu_ops[cpu]->cpu_die)
 859                 cpu_ops[cpu]->cpu_die(cpu);
 860 #endif
 861
 862         /* just in case */
 863         cpu_park_loop();
 864 #endif
 865 }
 866
 867 /*
 868  * Main handler for inter-processor interrupts
 869  */
 870 void handle_IPI(int ipinr, struct pt_regs *regs)
 871 {
 872         unsigned int cpu = smp_processor_id();
 873         struct pt_regs *old_regs = set_irq_regs(regs);
 874
 875         if ((unsigned)ipinr < NR_IPI) {
 876                 trace_ipi_entry_rcuidle(ipi_types[ipinr]);
 877                 __inc_irq_stat(cpu, ipi_irqs[ipinr]);
 878         }
 879
 880         switch (ipinr) {
 881         case IPI_RESCHEDULE:
 882                 scheduler_ipi();
 883                 break;
 884
 885         case IPI_CALL_FUNC:
 886                 irq_enter();
 887                 generic_smp_call_function_interrupt();
 888                 irq_exit();
 889                 break;
 890
 891         case IPI_CPU_STOP:
 892                 irq_enter();
 893                 ipi_cpu_stop(cpu);
 894                 irq_exit();
 895                 break;
 896
 897         case IPI_CPU_CRASH_STOP:
 898                 if (IS_ENABLED(CONFIG_KEXEC_CORE)) {
 899                         irq_enter();
 900                         ipi_cpu_crash_stop(cpu, regs);
 901
 902                         unreachable();
 903                 }
 904                 break;
 905
 906 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 907         case IPI_TIMER:
 908                 irq_enter();
 909                 tick_receive_broadcast();
 910                 irq_exit();
 911                 break;
 912 #endif
 913
 914 #ifdef CONFIG_IRQ_WORK
 915         case IPI_IRQ_WORK:
 916                 irq_enter();
 917                 irq_work_run();
 918                 irq_exit();
 919                 break;
 920 #endif
 921
 922 #ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
 923         case IPI_WAKEUP:
 924                 WARN_ONCE(!acpi_parking_protocol_valid(cpu),
 925                           "CPU%u: Wake-up IPI outside the ACPI parking protocol\n",
 926                           cpu);
 927                 break;
 928 #endif
 929
 930         default:
 931                 pr_crit("CPU%u: Unknown IPI message 0x%x\n", cpu, ipinr);
 932                 break;
 933         }
 934
 935         if ((unsigned)ipinr < NR_IPI)
 936                 trace_ipi_exit_rcuidle(ipi_types[ipinr]);
 937         set_irq_regs(old_regs);
 938 }
 939
 940 void smp_send_reschedule(int cpu)
 941 {
 942         smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);
 943 }
 944
 945 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 946 void tick_broadcast(const struct cpumask *mask)
 947 {
 948         smp_cross_call(mask, IPI_TIMER);
 949 }
 950 #endif
 951
 952 void smp_send_stop(void)
 953 {
 954         unsigned long timeout;
 955
 956         if (num_online_cpus() > 1) {
 957                 cpumask_t mask;
 958
 959                 cpumask_copy(&mask, cpu_online_mask);
 960                 cpumask_clear_cpu(smp_processor_id(), &mask);
 961
 962                 if (system_state <= SYSTEM_RUNNING)
 963                         pr_crit("SMP: stopping secondary CPUs\n");
 964                 smp_cross_call(&mask, IPI_CPU_STOP);
 965         }
 966
 967         /* Wait up to one second for other CPUs to stop */
 968         timeout = USEC_PER_SEC;
 969         while (num_online_cpus() > 1 && timeout--)
 970                 udelay(1);
 971
 972         if (num_online_cpus() > 1)
 973                 pr_warning("SMP: failed to stop secondary CPUs %*pbl\n",
 974                            cpumask_pr_args(cpu_online_mask));
 975 }
 976
 977 #ifdef CONFIG_KEXEC_CORE
 978 void crash_smp_send_stop(void)
 979 {
 980         static int cpus_stopped;
 981         cpumask_t mask;
 982         unsigned long timeout;
 983
 984         /*
 985          * This function can be called twice in panic path, but obviously
 986          * we execute this only once.
 987          */
 988         if (cpus_stopped)
 989                 return;
 990
 991         cpus_stopped = 1;
 992
 993         if (num_online_cpus() == 1)
 994                 return;
 995
 996         cpumask_copy(&mask, cpu_online_mask);
 997         cpumask_clear_cpu(smp_processor_id(), &mask);
 998
 999         atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
1000
1001         pr_crit("SMP: stopping secondary CPUs\n");
1002         smp_cross_call(&mask, IPI_CPU_CRASH_STOP);
1003
1004         /* Wait up to one second for other CPUs to stop */
1005         timeout = USEC_PER_SEC;
1006         while ((atomic_read(&waiting_for_crash_ipi) > 0) && timeout--)
1007                 udelay(1);
1008
1009         if (atomic_read(&waiting_for_crash_ipi) > 0)
1010                 pr_warning("SMP: failed to stop secondary CPUs %*pbl\n",
1011                            cpumask_pr_args(&mask));
1012 }
1013
1014 bool smp_crash_stop_failed(void)
1015 {
1016         return (atomic_read(&waiting_for_crash_ipi) > 0);
1017 }
1018 #endif
1019
1020 /*
1021  * not supported here
1022  */
1023 int setup_profiling_timer(unsigned int multiplier)
1024 {
1025         return -EINVAL;
1026 }
1027
1028 static bool have_cpu_die(void)
1029 {
1030 #ifdef CONFIG_HOTPLUG_CPU
1031         int any_cpu = raw_smp_processor_id();
1032
1033         if (cpu_ops[any_cpu] && cpu_ops[any_cpu]->cpu_die)
1034                 return true;
1035 #endif
1036         return false;
1037 }
1038
1039 bool cpus_are_stuck_in_kernel(void)
1040 {
1041         bool smp_spin_tables = (num_possible_cpus() > 1 && !have_cpu_die());
1042
1043         return !!cpus_stuck_in_kernel || smp_spin_tables;
1044 }