arch/arm64/kernel/smp.c

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