arch/x86/kernel/smpboot.c

   1  /*
   2  *      x86 SMP booting functions
   3  *
   4  *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
   5  *      (c) 1998, 1999, 2000, 2009 Ingo Molnar <mingo@redhat.com>
   6  *      Copyright 2001 Andi Kleen, SuSE Labs.
   7  *
   8  *      Much of the core SMP work is based on previous work by Thomas Radke, to
   9  *      whom a great many thanks are extended.
  10  *
  11  *      Thanks to Intel for making available several different Pentium,
  12  *      Pentium Pro and Pentium-II/Xeon MP machines.
  13  *      Original development of Linux SMP code supported by Caldera.
  14  *
  15  *      This code is released under the GNU General Public License version 2 or
  16  *      later.
  17  *
  18  *      Fixes
  19  *              Felix Koop      :       NR_CPUS used properly
  20  *              Jose Renau      :       Handle single CPU case.
  21  *              Alan Cox        :       By repeated request 8) - Total BogoMIPS report.
  22  *              Greg Wright     :       Fix for kernel stacks panic.
  23  *              Erich Boleyn    :       MP v1.4 and additional changes.
  24  *      Matthias Sattler        :       Changes for 2.1 kernel map.
  25  *      Michel Lespinasse       :       Changes for 2.1 kernel map.
  26  *      Michael Chastain        :       Change trampoline.S to gnu as.
  27  *              Alan Cox        :       Dumb bug: 'B' step PPro's are fine
  28  *              Ingo Molnar     :       Added APIC timers, based on code
  29  *                                      from Jose Renau
  30  *              Ingo Molnar     :       various cleanups and rewrites
  31  *              Tigran Aivazian :       fixed "0.00 in /proc/uptime on SMP" bug.
  32  *      Maciej W. Rozycki       :       Bits for genuine 82489DX APICs
  33  *      Andi Kleen              :       Changed for SMP boot into long mode.
  34  *              Martin J. Bligh :       Added support for multi-quad systems
  35  *              Dave Jones      :       Report invalid combinations of Athlon CPUs.
  36  *              Rusty Russell   :       Hacked into shape for new "hotplug" boot process.
  37  *      Andi Kleen              :       Converted to new state machine.
  38  *      Ashok Raj               :       CPU hotplug support
  39  *      Glauber Costa           :       i386 and x86_64 integration
  40  */
  41
  42 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  43
  44 #include <linux/init.h>
  45 #include <linux/smp.h>
  46 #include <linux/module.h>
  47 #include <linux/sched.h>
  48 #include <linux/percpu.h>
  49 #include <linux/bootmem.h>
  50 #include <linux/err.h>
  51 #include <linux/nmi.h>
  52 #include <linux/tboot.h>
  53 #include <linux/stackprotector.h>
  54 #include <linux/gfp.h>
  55 #include <linux/cpuidle.h>
  56
  57 #include <asm/acpi.h>
  58 #include <asm/desc.h>
  59 #include <asm/nmi.h>
  60 #include <asm/irq.h>
  61 #include <asm/idle.h>
  62 #include <asm/realmode.h>
  63 #include <asm/cpu.h>
  64 #include <asm/numa.h>
  65 #include <asm/pgtable.h>
  66 #include <asm/tlbflush.h>
  67 #include <asm/mtrr.h>
  68 #include <asm/mwait.h>
  69 #include <asm/apic.h>
  70 #include <asm/io_apic.h>
  71 #include <asm/i387.h>
  72 #include <asm/fpu-internal.h>
  73 #include <asm/setup.h>
  74 #include <asm/uv/uv.h>
  75 #include <linux/mc146818rtc.h>
  76 #include <asm/smpboot_hooks.h>
  77 #include <asm/i8259.h>
  78 #include <asm/realmode.h>
  79 #include <asm/misc.h>
  80
  81 /* State of each CPU */
  82 DEFINE_PER_CPU(int, cpu_state) = { 0 };
  83
  84 /* Number of siblings per CPU package */
  85 int smp_num_siblings = 1;
  86 EXPORT_SYMBOL(smp_num_siblings);
  87
  88 /* Last level cache ID of each logical CPU */
  89 DEFINE_PER_CPU_READ_MOSTLY(u16, cpu_llc_id) = BAD_APICID;
  90
  91 /* representing HT siblings of each logical CPU */
  92 DEFINE_PER_CPU_READ_MOSTLY(cpumask_var_t, cpu_sibling_map);
  93 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
  94
  95 /* representing HT and core siblings of each logical CPU */
  96 DEFINE_PER_CPU_READ_MOSTLY(cpumask_var_t, cpu_core_map);
  97 EXPORT_PER_CPU_SYMBOL(cpu_core_map);
  98
  99 DEFINE_PER_CPU_READ_MOSTLY(cpumask_var_t, cpu_llc_shared_map);
 100
 101 /* Per CPU bogomips and other parameters */
 102 DEFINE_PER_CPU_SHARED_ALIGNED(struct cpuinfo_x86, cpu_info);
 103 EXPORT_PER_CPU_SYMBOL(cpu_info);
 104
 105 atomic_t init_deasserted;
 106
 107 /*
 108  * Report back to the Boot Processor during boot time or to the caller processor
 109  * during CPU online.
 110  */
 111 static void smp_callin(void)
 112 {
 113         int cpuid, phys_id;
 114         unsigned long timeout;
 115
 116         /*
 117          * If waken up by an INIT in an 82489DX configuration
 118          * we may get here before an INIT-deassert IPI reaches
 119          * our local APIC.  We have to wait for the IPI or we'll
 120          * lock up on an APIC access.
 121          *
 122          * Since CPU0 is not wakened up by INIT, it doesn't wait for the IPI.
 123          */
 124         cpuid = smp_processor_id();
 125         if (apic->wait_for_init_deassert && cpuid)
 126                 while (!atomic_read(&init_deasserted))
 127                         cpu_relax();
 128
 129         /*
 130          * (This works even if the APIC is not enabled.)
 131          */
 132         phys_id = read_apic_id();
 133         if (cpumask_test_cpu(cpuid, cpu_callin_mask)) {
 134                 panic("%s: phys CPU#%d, CPU#%d already present??\n", __func__,
 135                                         phys_id, cpuid);
 136         }
 137         pr_debug("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
 138
 139         /*
 140          * STARTUP IPIs are fragile beasts as they might sometimes
 141          * trigger some glue motherboard logic. Complete APIC bus
 142          * silence for 1 second, this overestimates the time the
 143          * boot CPU is spending to send the up to 2 STARTUP IPIs
 144          * by a factor of two. This should be enough.
 145          */
 146
 147         /*
 148          * Waiting 2s total for startup (udelay is not yet working)
 149          */
 150         timeout = jiffies + 2*HZ;
 151         while (time_before(jiffies, timeout)) {
 152                 /*
 153                  * Has the boot CPU finished it's STARTUP sequence?
 154                  */
 155                 if (cpumask_test_cpu(cpuid, cpu_callout_mask))
 156                         break;
 157                 cpu_relax();
 158         }
 159
 160         if (!time_before(jiffies, timeout)) {
 161                 panic("%s: CPU%d started up but did not get a callout!\n",
 162                       __func__, cpuid);
 163         }
 164
 165         /*
 166          * the boot CPU has finished the init stage and is spinning
 167          * on callin_map until we finish. We are free to set up this
 168          * CPU, first the APIC. (this is probably redundant on most
 169          * boards)
 170          */
 171         setup_local_APIC();
 172         end_local_APIC_setup();
 173
 174         /*
 175          * Need to setup vector mappings before we enable interrupts.
 176          */
 177         setup_vector_irq(smp_processor_id());
 178
 179         /*
 180          * Save our processor parameters. Note: this information
 181          * is needed for clock calibration.
 182          */
 183         smp_store_cpu_info(cpuid);
 184
 185         /*
 186          * Get our bogomips.
 187          * Update loops_per_jiffy in cpu_data. Previous call to
 188          * smp_store_cpu_info() stored a value that is close but not as
 189          * accurate as the value just calculated.
 190          */
 191         calibrate_delay();
 192         cpu_data(cpuid).loops_per_jiffy = loops_per_jiffy;
 193         pr_debug("Stack at about %p\n", &cpuid);
 194
 195         /*
 196          * This must be done before setting cpu_online_mask
 197          * or calling notify_cpu_starting.
 198          */
 199         set_cpu_sibling_map(raw_smp_processor_id());
 200         wmb();
 201
 202         notify_cpu_starting(cpuid);
 203
 204         /*
 205          * Allow the master to continue.
 206          */
 207         cpumask_set_cpu(cpuid, cpu_callin_mask);
 208 }
 209
 210 static int cpu0_logical_apicid;
 211 static int enable_start_cpu0;
 212 /*
 213  * Activate a secondary processor.
 214  */
 215 static void notrace start_secondary(void *unused)
 216 {
 217         /*
 218          * Don't put *anything* before cpu_init(), SMP booting is too
 219          * fragile that we want to limit the things done here to the
 220          * most necessary things.
 221          */
 222         cpu_init();
 223         x86_cpuinit.early_percpu_clock_init();
 224         preempt_disable();
 225         smp_callin();
 226
 227         enable_start_cpu0 = 0;
 228
 229 #ifdef CONFIG_X86_32
 230         /* switch away from the initial page table */
 231         load_cr3(swapper_pg_dir);
 232         __flush_tlb_all();
 233 #endif
 234
 235         /* otherwise gcc will move up smp_processor_id before the cpu_init */
 236         barrier();
 237         /*
 238          * Check TSC synchronization with the BP:
 239          */
 240         check_tsc_sync_target();
 241
 242         /*
 243          * Enable the espfix hack for this CPU
 244          */
 245 #ifdef CONFIG_X86_ESPFIX64
 246         init_espfix_ap();
 247 #endif
 248
 249         /*
 250          * We need to hold vector_lock so there the set of online cpus
 251          * does not change while we are assigning vectors to cpus.  Holding
 252          * this lock ensures we don't half assign or remove an irq from a cpu.
 253          */
 254         lock_vector_lock();
 255         set_cpu_online(smp_processor_id(), true);
 256         unlock_vector_lock();
 257         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
 258         x86_platform.nmi_init();
 259
 260         /* enable local interrupts */
 261         local_irq_enable();
 262
 263         /* to prevent fake stack check failure in clock setup */
 264         boot_init_stack_canary();
 265
 266         x86_cpuinit.setup_percpu_clockev();
 267
 268         wmb();
 269         cpu_startup_entry(CPUHP_ONLINE);
 270 }
 271
 272 void __init smp_store_boot_cpu_info(void)
 273 {
 274         int id = 0; /* CPU 0 */
 275         struct cpuinfo_x86 *c = &cpu_data(id);
 276
 277         *c = boot_cpu_data;
 278         c->cpu_index = id;
 279 }
 280
 281 /*
 282  * The bootstrap kernel entry code has set these up. Save them for
 283  * a given CPU
 284  */
 285 void smp_store_cpu_info(int id)
 286 {
 287         struct cpuinfo_x86 *c = &cpu_data(id);
 288
 289         *c = boot_cpu_data;
 290         c->cpu_index = id;
 291         /*
 292          * During boot time, CPU0 has this setup already. Save the info when
 293          * bringing up AP or offlined CPU0.
 294          */
 295         identify_secondary_cpu(c);
 296 }
 297
 298 static bool
 299 topology_same_node(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o)
 300 {
 301         int cpu1 = c->cpu_index, cpu2 = o->cpu_index;
 302
 303         return (cpu_to_node(cpu1) == cpu_to_node(cpu2));
 304 }
 305
 306 static bool
 307 topology_sane(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o, const char *name)
 308 {
 309         int cpu1 = c->cpu_index, cpu2 = o->cpu_index;
 310
 311         return !WARN_ONCE(!topology_same_node(c, o),
 312                 "sched: CPU #%d's %s-sibling CPU #%d is not on the same node! "
 313                 "[node: %d != %d]. Ignoring dependency.\n",
 314                 cpu1, name, cpu2, cpu_to_node(cpu1), cpu_to_node(cpu2));
 315 }
 316
 317 #define link_mask(_m, c1, c2)                                           \
 318 do {                                                                    \
 319         cpumask_set_cpu((c1), cpu_##_m##_mask(c2));                     \
 320         cpumask_set_cpu((c2), cpu_##_m##_mask(c1));                     \
 321 } while (0)
 322
 323 static bool match_smt(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o)
 324 {
 325         if (cpu_has_topoext) {
 326                 int cpu1 = c->cpu_index, cpu2 = o->cpu_index;
 327
 328                 if (c->phys_proc_id == o->phys_proc_id &&
 329                     per_cpu(cpu_llc_id, cpu1) == per_cpu(cpu_llc_id, cpu2) &&
 330                     c->compute_unit_id == o->compute_unit_id)
 331                         return topology_sane(c, o, "smt");
 332
 333         } else if (c->phys_proc_id == o->phys_proc_id &&
 334                    c->cpu_core_id == o->cpu_core_id) {
 335                 return topology_sane(c, o, "smt");
 336         }
 337
 338         return false;
 339 }
 340
 341 static bool match_llc(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o)
 342 {
 343         int cpu1 = c->cpu_index, cpu2 = o->cpu_index;
 344
 345         if (per_cpu(cpu_llc_id, cpu1) != BAD_APICID &&
 346             per_cpu(cpu_llc_id, cpu1) == per_cpu(cpu_llc_id, cpu2))
 347                 return topology_sane(c, o, "llc");
 348
 349         return false;
 350 }
 351
 352 /*
 353  * Unlike the other levels, we do not enforce keeping a
 354  * multicore group inside a NUMA node.  If this happens, we will
 355  * discard the MC level of the topology later.
 356  */
 357 static bool match_die(struct cpuinfo_x86 *c, struct cpuinfo_x86 *o)
 358 {
 359         if (c->phys_proc_id == o->phys_proc_id)
 360                 return true;
 361         return false;
 362 }
 363
 364 static struct sched_domain_topology_level numa_inside_package_topology[] = {
 365 #ifdef CONFIG_SCHED_SMT
 366         { cpu_smt_mask, cpu_smt_flags, SD_INIT_NAME(SMT) },
 367 #endif
 368 #ifdef CONFIG_SCHED_MC
 369         { cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
 370 #endif
 371         { NULL, },
 372 };
 373 /*
 374  * set_sched_topology() sets the topology internal to a CPU.  The
 375  * NUMA topologies are layered on top of it to build the full
 376  * system topology.
 377  *
 378  * If NUMA nodes are observed to occur within a CPU package, this
 379  * function should be called.  It forces the sched domain code to
 380  * only use the SMT level for the CPU portion of the topology.
 381  * This essentially falls back to relying on NUMA information
 382  * from the SRAT table to describe the entire system topology
 383  * (except for hyperthreads).
 384  */
 385 static void primarily_use_numa_for_topology(void)
 386 {
 387         set_sched_topology(numa_inside_package_topology);
 388 }
 389
 390 void set_cpu_sibling_map(int cpu)
 391 {
 392         bool has_smt = smp_num_siblings > 1;
 393         bool has_mp = has_smt || boot_cpu_data.x86_max_cores > 1;
 394         struct cpuinfo_x86 *c = &cpu_data(cpu);
 395         struct cpuinfo_x86 *o;
 396         int i;
 397
 398         cpumask_set_cpu(cpu, cpu_sibling_setup_mask);
 399
 400         if (!has_mp) {
 401                 cpumask_set_cpu(cpu, cpu_sibling_mask(cpu));
 402                 cpumask_set_cpu(cpu, cpu_llc_shared_mask(cpu));
 403                 cpumask_set_cpu(cpu, cpu_core_mask(cpu));
 404                 c->booted_cores = 1;
 405                 return;
 406         }
 407
 408         for_each_cpu(i, cpu_sibling_setup_mask) {
 409                 o = &cpu_data(i);
 410
 411                 if ((i == cpu) || (has_smt && match_smt(c, o)))
 412                         link_mask(sibling, cpu, i);
 413
 414                 if ((i == cpu) || (has_mp && match_llc(c, o)))
 415                         link_mask(llc_shared, cpu, i);
 416
 417         }
 418
 419         /*
 420          * This needs a separate iteration over the cpus because we rely on all
 421          * cpu_sibling_mask links to be set-up.
 422          */
 423         for_each_cpu(i, cpu_sibling_setup_mask) {
 424                 o = &cpu_data(i);
 425
 426                 if ((i == cpu) || (has_mp && match_die(c, o))) {
 427                         link_mask(core, cpu, i);
 428
 429                         /*
 430                          *  Does this new cpu bringup a new core?
 431                          */
 432                         if (cpumask_weight(cpu_sibling_mask(cpu)) == 1) {
 433                                 /*
 434                                  * for each core in package, increment
 435                                  * the booted_cores for this new cpu
 436                                  */
 437                                 if (cpumask_first(cpu_sibling_mask(i)) == i)
 438                                         c->booted_cores++;
 439                                 /*
 440                                  * increment the core count for all
 441                                  * the other cpus in this package
 442                                  */
 443                                 if (i != cpu)
 444                                         cpu_data(i).booted_cores++;
 445                         } else if (i != cpu && !c->booted_cores)
 446                                 c->booted_cores = cpu_data(i).booted_cores;
 447                 }
 448                 if (match_die(c, o) && !topology_same_node(c, o))
 449                         primarily_use_numa_for_topology();
 450         }
 451 }
 452
 453 /* maps the cpu to the sched domain representing multi-core */
 454 const struct cpumask *cpu_coregroup_mask(int cpu)
 455 {
 456         return cpu_llc_shared_mask(cpu);
 457 }
 458
 459 static void impress_friends(void)
 460 {
 461         int cpu;
 462         unsigned long bogosum = 0;
 463         /*
 464          * Allow the user to impress friends.
 465          */
 466         pr_debug("Before bogomips\n");
 467         for_each_possible_cpu(cpu)
 468                 if (cpumask_test_cpu(cpu, cpu_callout_mask))
 469                         bogosum += cpu_data(cpu).loops_per_jiffy;
 470         pr_info("Total of %d processors activated (%lu.%02lu BogoMIPS)\n",
 471                 num_online_cpus(),
 472                 bogosum/(500000/HZ),
 473                 (bogosum/(5000/HZ))%100);
 474
 475         pr_debug("Before bogocount - setting activated=1\n");
 476 }
 477
 478 void __inquire_remote_apic(int apicid)
 479 {
 480         unsigned i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
 481         const char * const names[] = { "ID", "VERSION", "SPIV" };
 482         int timeout;
 483         u32 status;
 484
 485         pr_info("Inquiring remote APIC 0x%x...\n", apicid);
 486
 487         for (i = 0; i < ARRAY_SIZE(regs); i++) {
 488                 pr_info("... APIC 0x%x %s: ", apicid, names[i]);
 489
 490                 /*
 491                  * Wait for idle.
 492                  */
 493                 status = safe_apic_wait_icr_idle();
 494                 if (status)
 495                         pr_cont("a previous APIC delivery may have failed\n");
 496
 497                 apic_icr_write(APIC_DM_REMRD | regs[i], apicid);
 498
 499                 timeout = 0;
 500                 do {
 501                         udelay(100);
 502                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
 503                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
 504
 505                 switch (status) {
 506                 case APIC_ICR_RR_VALID:
 507                         status = apic_read(APIC_RRR);
 508                         pr_cont("%08x\n", status);
 509                         break;
 510                 default:
 511                         pr_cont("failed\n");
 512                 }
 513         }
 514 }
 515
 516 /*
 517  * Poke the other CPU in the eye via NMI to wake it up. Remember that the normal
 518  * INIT, INIT, STARTUP sequence will reset the chip hard for us, and this
 519  * won't ... remember to clear down the APIC, etc later.
 520  */
 521 int
 522 wakeup_secondary_cpu_via_nmi(int apicid, unsigned long start_eip)
 523 {
 524         unsigned long send_status, accept_status = 0;
 525         int maxlvt;
 526
 527         /* Target chip */
 528         /* Boot on the stack */
 529         /* Kick the second */
 530         apic_icr_write(APIC_DM_NMI | apic->dest_logical, apicid);
 531
 532         pr_debug("Waiting for send to finish...\n");
 533         send_status = safe_apic_wait_icr_idle();
 534
 535         /*
 536          * Give the other CPU some time to accept the IPI.
 537          */
 538         udelay(200);
 539         if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid])) {
 540                 maxlvt = lapic_get_maxlvt();
 541                 if (maxlvt > 3)                 /* Due to the Pentium erratum 3AP.  */
 542                         apic_write(APIC_ESR, 0);
 543                 accept_status = (apic_read(APIC_ESR) & 0xEF);
 544         }
 545         pr_debug("NMI sent\n");
 546
 547         if (send_status)
 548                 pr_err("APIC never delivered???\n");
 549         if (accept_status)
 550                 pr_err("APIC delivery error (%lx)\n", accept_status);
 551
 552         return (send_status | accept_status);
 553 }
 554
 555 static int
 556 wakeup_secondary_cpu_via_init(int phys_apicid, unsigned long start_eip)
 557 {
 558         unsigned long send_status, accept_status = 0;
 559         int maxlvt, num_starts, j;
 560
 561         maxlvt = lapic_get_maxlvt();
 562
 563         /*
 564          * Be paranoid about clearing APIC errors.
 565          */
 566         if (APIC_INTEGRATED(apic_version[phys_apicid])) {
 567                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP.  */
 568                         apic_write(APIC_ESR, 0);
 569                 apic_read(APIC_ESR);
 570         }
 571
 572         pr_debug("Asserting INIT\n");
 573
 574         /*
 575          * Turn INIT on target chip
 576          */
 577         /*
 578          * Send IPI
 579          */
 580         apic_icr_write(APIC_INT_LEVELTRIG | APIC_INT_ASSERT | APIC_DM_INIT,
 581                        phys_apicid);
 582
 583         pr_debug("Waiting for send to finish...\n");
 584         send_status = safe_apic_wait_icr_idle();
 585
 586         mdelay(10);
 587
 588         pr_debug("Deasserting INIT\n");
 589
 590         /* Target chip */
 591         /* Send IPI */
 592         apic_icr_write(APIC_INT_LEVELTRIG | APIC_DM_INIT, phys_apicid);
 593
 594         pr_debug("Waiting for send to finish...\n");
 595         send_status = safe_apic_wait_icr_idle();
 596
 597         mb();
 598         atomic_set(&init_deasserted, 1);
 599
 600         /*
 601          * Should we send STARTUP IPIs ?
 602          *
 603          * Determine this based on the APIC version.
 604          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
 605          */
 606         if (APIC_INTEGRATED(apic_version[phys_apicid]))
 607                 num_starts = 2;
 608         else
 609                 num_starts = 0;
 610
 611         /*
 612          * Paravirt / VMI wants a startup IPI hook here to set up the
 613          * target processor state.
 614          */
 615         startup_ipi_hook(phys_apicid, (unsigned long) start_secondary,
 616                          stack_start);
 617
 618         /*
 619          * Run STARTUP IPI loop.
 620          */
 621         pr_debug("#startup loops: %d\n", num_starts);
 622
 623         for (j = 1; j <= num_starts; j++) {
 624                 pr_debug("Sending STARTUP #%d\n", j);
 625                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP.  */
 626                         apic_write(APIC_ESR, 0);
 627                 apic_read(APIC_ESR);
 628                 pr_debug("After apic_write\n");
 629
 630                 /*
 631                  * STARTUP IPI
 632                  */
 633
 634                 /* Target chip */
 635                 /* Boot on the stack */
 636                 /* Kick the second */
 637                 apic_icr_write(APIC_DM_STARTUP | (start_eip >> 12),
 638                                phys_apicid);
 639
 640                 /*
 641                  * Give the other CPU some time to accept the IPI.
 642                  */
 643                 udelay(300);
 644
 645                 pr_debug("Startup point 1\n");
 646
 647                 pr_debug("Waiting for send to finish...\n");
 648                 send_status = safe_apic_wait_icr_idle();
 649
 650                 /*
 651                  * Give the other CPU some time to accept the IPI.
 652                  */
 653                 udelay(200);
 654                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP.  */
 655                         apic_write(APIC_ESR, 0);
 656                 accept_status = (apic_read(APIC_ESR) & 0xEF);
 657                 if (send_status || accept_status)
 658                         break;
 659         }
 660         pr_debug("After Startup\n");
 661
 662         if (send_status)
 663                 pr_err("APIC never delivered???\n");
 664         if (accept_status)
 665                 pr_err("APIC delivery error (%lx)\n", accept_status);
 666
 667         return (send_status | accept_status);
 668 }
 669
 670 void smp_announce(void)
 671 {
 672         int num_nodes = num_online_nodes();
 673
 674         printk(KERN_INFO "x86: Booted up %d node%s, %d CPUs\n",
 675                num_nodes, (num_nodes > 1 ? "s" : ""), num_online_cpus());
 676 }
 677
 678 /* reduce the number of lines printed when booting a large cpu count system */
 679 static void announce_cpu(int cpu, int apicid)
 680 {
 681         static int current_node = -1;
 682         int node = early_cpu_to_node(cpu);
 683         static int width, node_width;
 684
 685         if (!width)
 686                 width = num_digits(num_possible_cpus()) + 1; /* + '#' sign */
 687
 688         if (!node_width)
 689                 node_width = num_digits(num_possible_nodes()) + 1; /* + '#' */
 690
 691         if (cpu == 1)
 692                 printk(KERN_INFO "x86: Booting SMP configuration:\n");
 693
 694         if (system_state == SYSTEM_BOOTING) {
 695                 if (node != current_node) {
 696                         if (current_node > (-1))
 697                                 pr_cont("\n");
 698                         current_node = node;
 699
 700                         printk(KERN_INFO ".... node %*s#%d, CPUs:  ",
 701                                node_width - num_digits(node), " ", node);
 702                 }
 703
 704                 /* Add padding for the BSP */
 705                 if (cpu == 1)
 706                         pr_cont("%*s", width + 1, " ");
 707
 708                 pr_cont("%*s#%d", width - num_digits(cpu), " ", cpu);
 709
 710         } else
 711                 pr_info("Booting Node %d Processor %d APIC 0x%x\n",
 712                         node, cpu, apicid);
 713 }
 714
 715 static int wakeup_cpu0_nmi(unsigned int cmd, struct pt_regs *regs)
 716 {
 717         int cpu;
 718
 719         cpu = smp_processor_id();
 720         if (cpu == 0 && !cpu_online(cpu) && enable_start_cpu0)
 721                 return NMI_HANDLED;
 722
 723         return NMI_DONE;
 724 }
 725
 726 /*
 727  * Wake up AP by INIT, INIT, STARTUP sequence.
 728  *
 729  * Instead of waiting for STARTUP after INITs, BSP will execute the BIOS
 730  * boot-strap code which is not a desired behavior for waking up BSP. To
 731  * void the boot-strap code, wake up CPU0 by NMI instead.
 732  *
 733  * This works to wake up soft offlined CPU0 only. If CPU0 is hard offlined
 734  * (i.e. physically hot removed and then hot added), NMI won't wake it up.
 735  * We'll change this code in the future to wake up hard offlined CPU0 if
 736  * real platform and request are available.
 737  */
 738 static int
 739 wakeup_cpu_via_init_nmi(int cpu, unsigned long start_ip, int apicid,
 740                int *cpu0_nmi_registered)
 741 {
 742         int id;
 743         int boot_error;
 744
 745         preempt_disable();
 746
 747         /*
 748          * Wake up AP by INIT, INIT, STARTUP sequence.
 749          */
 750         if (cpu) {
 751                 boot_error = wakeup_secondary_cpu_via_init(apicid, start_ip);
 752                 goto out;
 753         }
 754
 755         /*
 756          * Wake up BSP by nmi.
 757          *
 758          * Register a NMI handler to help wake up CPU0.
 759          */
 760         boot_error = register_nmi_handler(NMI_LOCAL,
 761                                           wakeup_cpu0_nmi, 0, "wake_cpu0");
 762
 763         if (!boot_error) {
 764                 enable_start_cpu0 = 1;
 765                 *cpu0_nmi_registered = 1;
 766                 if (apic->dest_logical == APIC_DEST_LOGICAL)
 767                         id = cpu0_logical_apicid;
 768                 else
 769                         id = apicid;
 770                 boot_error = wakeup_secondary_cpu_via_nmi(id, start_ip);
 771         }
 772
 773 out:
 774         preempt_enable();
 775
 776         return boot_error;
 777 }
 778
 779 /*
 780  * NOTE - on most systems this is a PHYSICAL apic ID, but on multiquad
 781  * (ie clustered apic addressing mode), this is a LOGICAL apic ID.
 782  * Returns zero if CPU booted OK, else error code from
 783  * ->wakeup_secondary_cpu.
 784  */
 785 static int do_boot_cpu(int apicid, int cpu, struct task_struct *idle)
 786 {
 787         volatile u32 *trampoline_status =
 788                 (volatile u32 *) __va(real_mode_header->trampoline_status);
 789         /* start_ip had better be page-aligned! */
 790         unsigned long start_ip = real_mode_header->trampoline_start;
 791
 792         unsigned long boot_error = 0;
 793         int timeout;
 794         int cpu0_nmi_registered = 0;
 795
 796         /* Just in case we booted with a single CPU. */
 797         alternatives_enable_smp();
 798
 799         idle->thread.sp = (unsigned long) (((struct pt_regs *)
 800                           (THREAD_SIZE +  task_stack_page(idle))) - 1);
 801         per_cpu(current_task, cpu) = idle;
 802
 803 #ifdef CONFIG_X86_32
 804         /* Stack for startup_32 can be just as for start_secondary onwards */
 805         irq_ctx_init(cpu);
 806 #else
 807         clear_tsk_thread_flag(idle, TIF_FORK);
 808         initial_gs = per_cpu_offset(cpu);
 809 #endif
 810         per_cpu(kernel_stack, cpu) =
 811                 (unsigned long)task_stack_page(idle) -
 812                 KERNEL_STACK_OFFSET + THREAD_SIZE;
 813         early_gdt_descr.address = (unsigned long)get_cpu_gdt_table(cpu);
 814         initial_code = (unsigned long)start_secondary;
 815         stack_start  = idle->thread.sp;
 816
 817         /* So we see what's up */
 818         announce_cpu(cpu, apicid);
 819
 820         /*
 821          * This grunge runs the startup process for
 822          * the targeted processor.
 823          */
 824
 825         atomic_set(&init_deasserted, 0);
 826
 827         if (get_uv_system_type() != UV_NON_UNIQUE_APIC) {
 828
 829                 pr_debug("Setting warm reset code and vector.\n");
 830
 831                 smpboot_setup_warm_reset_vector(start_ip);
 832                 /*
 833                  * Be paranoid about clearing APIC errors.
 834                 */
 835                 if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid])) {
 836                         apic_write(APIC_ESR, 0);
 837                         apic_read(APIC_ESR);
 838                 }
 839         }
 840
 841         /*
 842          * Wake up a CPU in difference cases:
 843          * - Use the method in the APIC driver if it's defined
 844          * Otherwise,
 845          * - Use an INIT boot APIC message for APs or NMI for BSP.
 846          */
 847         if (apic->wakeup_secondary_cpu)
 848                 boot_error = apic->wakeup_secondary_cpu(apicid, start_ip);
 849         else
 850                 boot_error = wakeup_cpu_via_init_nmi(cpu, start_ip, apicid,
 851                                                      &cpu0_nmi_registered);
 852
 853         if (!boot_error) {
 854                 /*
 855                  * allow APs to start initializing.
 856                  */
 857                 pr_debug("Before Callout %d\n", cpu);
 858                 cpumask_set_cpu(cpu, cpu_callout_mask);
 859                 pr_debug("After Callout %d\n", cpu);
 860
 861                 /*
 862                  * Wait 5s total for a response
 863                  */
 864                 for (timeout = 0; timeout < 50000; timeout++) {
 865                         if (cpumask_test_cpu(cpu, cpu_callin_mask))
 866                                 break;  /* It has booted */
 867                         udelay(100);
 868                         /*
 869                          * Allow other tasks to run while we wait for the
 870                          * AP to come online. This also gives a chance
 871                          * for the MTRR work(triggered by the AP coming online)
 872                          * to be completed in the stop machine context.
 873                          */
 874                         schedule();
 875                 }
 876
 877                 if (cpumask_test_cpu(cpu, cpu_callin_mask)) {
 878                         print_cpu_msr(&cpu_data(cpu));
 879                         pr_debug("CPU%d: has booted.\n", cpu);
 880                 } else {
 881                         boot_error = 1;
 882                         if (*trampoline_status == 0xA5A5A5A5)
 883                                 /* trampoline started but...? */
 884                                 pr_err("CPU%d: Stuck ??\n", cpu);
 885                         else
 886                                 /* trampoline code not run */
 887                                 pr_err("CPU%d: Not responding\n", cpu);
 888                         if (apic->inquire_remote_apic)
 889                                 apic->inquire_remote_apic(apicid);
 890                 }
 891         }
 892
 893         if (boot_error) {
 894                 /* Try to put things back the way they were before ... */
 895                 numa_remove_cpu(cpu); /* was set by numa_add_cpu */
 896
 897                 /* was set by do_boot_cpu() */
 898                 cpumask_clear_cpu(cpu, cpu_callout_mask);
 899
 900                 /* was set by cpu_init() */
 901                 cpumask_clear_cpu(cpu, cpu_initialized_mask);
 902         }
 903
 904         /* mark "stuck" area as not stuck */
 905         *trampoline_status = 0;
 906
 907         if (get_uv_system_type() != UV_NON_UNIQUE_APIC) {
 908                 /*
 909                  * Cleanup possible dangling ends...
 910                  */
 911                 smpboot_restore_warm_reset_vector();
 912         }
 913         /*
 914          * Clean up the nmi handler. Do this after the callin and callout sync
 915          * to avoid impact of possible long unregister time.
 916          */
 917         if (cpu0_nmi_registered)
 918                 unregister_nmi_handler(NMI_LOCAL, "wake_cpu0");
 919
 920         return boot_error;
 921 }
 922
 923 int native_cpu_up(unsigned int cpu, struct task_struct *tidle)
 924 {
 925         int apicid = apic->cpu_present_to_apicid(cpu);
 926         unsigned long flags;
 927         int err;
 928
 929         WARN_ON(irqs_disabled());
 930
 931         pr_debug("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
 932
 933         if (apicid == BAD_APICID ||
 934             !physid_isset(apicid, phys_cpu_present_map) ||
 935             !apic->apic_id_valid(apicid)) {
 936                 pr_err("%s: bad cpu %d\n", __func__, cpu);
 937                 return -EINVAL;
 938         }
 939
 940         /*
 941          * Already booted CPU?
 942          */
 943         if (cpumask_test_cpu(cpu, cpu_callin_mask)) {
 944                 pr_debug("do_boot_cpu %d Already started\n", cpu);
 945                 return -ENOSYS;
 946         }
 947
 948         /*
 949          * Save current MTRR state in case it was changed since early boot
 950          * (e.g. by the ACPI SMI) to initialize new CPUs with MTRRs in sync:
 951          */
 952         mtrr_save_state();
 953
 954         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
 955
 956         /* the FPU context is blank, nobody can own it */
 957         __cpu_disable_lazy_restore(cpu);
 958
 959         err = do_boot_cpu(apicid, cpu, tidle);
 960         if (err) {
 961                 pr_err("do_boot_cpu failed(%d) to wakeup CPU#%u\n", err, cpu);
 962                 return -EIO;
 963         }
 964
 965         /*
 966          * Check TSC synchronization with the AP (keep irqs disabled
 967          * while doing so):
 968          */
 969         local_irq_save(flags);
 970         check_tsc_sync_source(cpu);
 971         local_irq_restore(flags);
 972
 973         while (!cpu_online(cpu)) {
 974                 cpu_relax();
 975                 touch_nmi_watchdog();
 976         }
 977
 978         return 0;
 979 }
 980
 981 /**
 982  * arch_disable_smp_support() - disables SMP support for x86 at runtime
 983  */
 984 void arch_disable_smp_support(void)
 985 {
 986         disable_ioapic_support();
 987 }
 988
 989 /*
 990  * Fall back to non SMP mode after errors.
 991  *
 992  * RED-PEN audit/test this more. I bet there is more state messed up here.
 993  */
 994 static __init void disable_smp(void)
 995 {
 996         init_cpu_present(cpumask_of(0));
 997         init_cpu_possible(cpumask_of(0));
 998         smpboot_clear_io_apic_irqs();
 999
1000         if (smp_found_config)
1001                 physid_set_mask_of_physid(boot_cpu_physical_apicid, &phys_cpu_present_map);
1002         else
1003                 physid_set_mask_of_physid(0, &phys_cpu_present_map);
1004         cpumask_set_cpu(0, cpu_sibling_mask(0));
1005         cpumask_set_cpu(0, cpu_core_mask(0));
1006 }
1007
1008 /*
1009  * Various sanity checks.
1010  */
1011 static int __init smp_sanity_check(unsigned max_cpus)
1012 {
1013         preempt_disable();
1014
1015 #if !defined(CONFIG_X86_BIGSMP) && defined(CONFIG_X86_32)
1016         if (def_to_bigsmp && nr_cpu_ids > 8) {
1017                 unsigned int cpu;
1018                 unsigned nr;
1019
1020                 pr_warn("More than 8 CPUs detected - skipping them\n"
1021                         "Use CONFIG_X86_BIGSMP\n");
1022
1023                 nr = 0;
1024                 for_each_present_cpu(cpu) {
1025                         if (nr >= 8)
1026                                 set_cpu_present(cpu, false);
1027                         nr++;
1028                 }
1029
1030                 nr = 0;
1031                 for_each_possible_cpu(cpu) {
1032                         if (nr >= 8)
1033                                 set_cpu_possible(cpu, false);
1034                         nr++;
1035                 }
1036
1037                 nr_cpu_ids = 8;
1038         }
1039 #endif
1040
1041         if (!physid_isset(hard_smp_processor_id(), phys_cpu_present_map)) {
1042                 pr_warn("weird, boot CPU (#%d) not listed by the BIOS\n",
1043                         hard_smp_processor_id());
1044
1045                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
1046         }
1047
1048         /*
1049          * If we couldn't find an SMP configuration at boot time,
1050          * get out of here now!
1051          */
1052         if (!smp_found_config && !acpi_lapic) {
1053                 preempt_enable();
1054                 pr_notice("SMP motherboard not detected\n");
1055                 disable_smp();
1056                 if (APIC_init_uniprocessor())
1057                         pr_notice("Local APIC not detected. Using dummy APIC emulation.\n");
1058                 return -1;
1059         }
1060
1061         /*
1062          * Should not be necessary because the MP table should list the boot
1063          * CPU too, but we do it for the sake of robustness anyway.
1064          */
1065         if (!apic->check_phys_apicid_present(boot_cpu_physical_apicid)) {
1066                 pr_notice("weird, boot CPU (#%d) not listed by the BIOS\n",
1067                           boot_cpu_physical_apicid);
1068                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
1069         }
1070         preempt_enable();
1071
1072         /*
1073          * If we couldn't find a local APIC, then get out of here now!
1074          */
1075         if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid]) &&
1076             !cpu_has_apic) {
1077                 if (!disable_apic) {
1078                         pr_err("BIOS bug, local APIC #%d not detected!...\n",
1079                                 boot_cpu_physical_apicid);
1080                         pr_err("... forcing use of dummy APIC emulation (tell your hw vendor)\n");
1081                 }
1082                 smpboot_clear_io_apic();
1083                 disable_ioapic_support();
1084                 return -1;
1085         }
1086
1087         verify_local_APIC();
1088
1089         /*
1090          * If SMP should be disabled, then really disable it!
1091          */
1092         if (!max_cpus) {
1093                 pr_info("SMP mode deactivated\n");
1094                 smpboot_clear_io_apic();
1095
1096                 connect_bsp_APIC();
1097                 setup_local_APIC();
1098                 bsp_end_local_APIC_setup();
1099                 return -1;
1100         }
1101
1102         return 0;
1103 }
1104
1105 static void __init smp_cpu_index_default(void)
1106 {
1107         int i;
1108         struct cpuinfo_x86 *c;
1109
1110         for_each_possible_cpu(i) {
1111                 c = &cpu_data(i);
1112                 /* mark all to hotplug */
1113                 c->cpu_index = nr_cpu_ids;
1114         }
1115 }
1116
1117 /*
1118  * Prepare for SMP bootup.  The MP table or ACPI has been read
1119  * earlier.  Just do some sanity checking here and enable APIC mode.
1120  */
1121 void __init native_smp_prepare_cpus(unsigned int max_cpus)
1122 {
1123         unsigned int i;
1124
1125         preempt_disable();
1126         smp_cpu_index_default();
1127
1128         /*
1129          * Setup boot CPU information
1130          */
1131         smp_store_boot_cpu_info(); /* Final full version of the data */
1132         cpumask_copy(cpu_callin_mask, cpumask_of(0));
1133         mb();
1134
1135         current_thread_info()->cpu = 0;  /* needed? */
1136         for_each_possible_cpu(i) {
1137                 zalloc_cpumask_var(&per_cpu(cpu_sibling_map, i), GFP_KERNEL);
1138                 zalloc_cpumask_var(&per_cpu(cpu_core_map, i), GFP_KERNEL);
1139                 zalloc_cpumask_var(&per_cpu(cpu_llc_shared_map, i), GFP_KERNEL);
1140         }
1141         set_cpu_sibling_map(0);
1142
1143
1144         if (smp_sanity_check(max_cpus) < 0) {
1145                 pr_info("SMP disabled\n");
1146                 disable_smp();
1147                 goto out;
1148         }
1149
1150         default_setup_apic_routing();
1151
1152         preempt_disable();
1153         if (read_apic_id() != boot_cpu_physical_apicid) {
1154                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
1155                      read_apic_id(), boot_cpu_physical_apicid);
1156                 /* Or can we switch back to PIC here? */
1157         }
1158         preempt_enable();
1159
1160         connect_bsp_APIC();
1161
1162         /*
1163          * Switch from PIC to APIC mode.
1164          */
1165         setup_local_APIC();
1166
1167         if (x2apic_mode)
1168                 cpu0_logical_apicid = apic_read(APIC_LDR);
1169         else
1170                 cpu0_logical_apicid = GET_APIC_LOGICAL_ID(apic_read(APIC_LDR));
1171
1172         /*
1173          * Enable IO APIC before setting up error vector
1174          */
1175         if (!skip_ioapic_setup && nr_ioapics)
1176                 enable_IO_APIC();
1177
1178         bsp_end_local_APIC_setup();
1179         smpboot_setup_io_apic();
1180         /*
1181          * Set up local APIC timer on boot CPU.
1182          */
1183
1184         pr_info("CPU%d: ", 0);
1185         print_cpu_info(&cpu_data(0));
1186         x86_init.timers.setup_percpu_clockev();
1187
1188         if (is_uv_system())
1189                 uv_system_init();
1190
1191         set_mtrr_aps_delayed_init();
1192 out:
1193         preempt_enable();
1194 }
1195
1196 void arch_enable_nonboot_cpus_begin(void)
1197 {
1198         set_mtrr_aps_delayed_init();
1199 }
1200
1201 void arch_enable_nonboot_cpus_end(void)
1202 {
1203         mtrr_aps_init();
1204 }
1205
1206 /*
1207  * Early setup to make printk work.
1208  */
1209 void __init native_smp_prepare_boot_cpu(void)
1210 {
1211         int me = smp_processor_id();
1212         switch_to_new_gdt(me);
1213         /* already set me in cpu_online_mask in boot_cpu_init() */
1214         cpumask_set_cpu(me, cpu_callout_mask);
1215         per_cpu(cpu_state, me) = CPU_ONLINE;
1216 }
1217
1218 void __init native_smp_cpus_done(unsigned int max_cpus)
1219 {
1220         pr_debug("Boot done\n");
1221
1222         nmi_selftest();
1223         impress_friends();
1224 #ifdef CONFIG_X86_IO_APIC
1225         setup_ioapic_dest();
1226 #endif
1227         mtrr_aps_init();
1228 }
1229
1230 static int __initdata setup_possible_cpus = -1;
1231 static int __init _setup_possible_cpus(char *str)
1232 {
1233         get_option(&str, &setup_possible_cpus);
1234         return 0;
1235 }
1236 early_param("possible_cpus", _setup_possible_cpus);
1237
1238
1239 /*
1240  * cpu_possible_mask should be static, it cannot change as cpu's
1241  * are onlined, or offlined. The reason is per-cpu data-structures
1242  * are allocated by some modules at init time, and dont expect to
1243  * do this dynamically on cpu arrival/departure.
1244  * cpu_present_mask on the other hand can change dynamically.
1245  * In case when cpu_hotplug is not compiled, then we resort to current
1246  * behaviour, which is cpu_possible == cpu_present.
1247  * - Ashok Raj
1248  *
1249  * Three ways to find out the number of additional hotplug CPUs:
1250  * - If the BIOS specified disabled CPUs in ACPI/mptables use that.
1251  * - The user can overwrite it with possible_cpus=NUM
1252  * - Otherwise don't reserve additional CPUs.
1253  * We do this because additional CPUs waste a lot of memory.
1254  * -AK
1255  */
1256 __init void prefill_possible_map(void)
1257 {
1258         int i, possible;
1259
1260         /* no processor from mptable or madt */
1261         if (!num_processors)
1262                 num_processors = 1;
1263
1264         i = setup_max_cpus ?: 1;
1265         if (setup_possible_cpus == -1) {
1266                 possible = num_processors;
1267 #ifdef CONFIG_HOTPLUG_CPU
1268                 if (setup_max_cpus)
1269                         possible += disabled_cpus;
1270 #else
1271                 if (possible > i)
1272                         possible = i;
1273 #endif
1274         } else
1275                 possible = setup_possible_cpus;
1276
1277         total_cpus = max_t(int, possible, num_processors + disabled_cpus);
1278
1279         /* nr_cpu_ids could be reduced via nr_cpus= */
1280         if (possible > nr_cpu_ids) {
1281                 pr_warn("%d Processors exceeds NR_CPUS limit of %d\n",
1282                         possible, nr_cpu_ids);
1283                 possible = nr_cpu_ids;
1284         }
1285
1286 #ifdef CONFIG_HOTPLUG_CPU
1287         if (!setup_max_cpus)
1288 #endif
1289         if (possible > i) {
1290                 pr_warn("%d Processors exceeds max_cpus limit of %u\n",
1291                         possible, setup_max_cpus);
1292                 possible = i;
1293         }
1294
1295         pr_info("Allowing %d CPUs, %d hotplug CPUs\n",
1296                 possible, max_t(int, possible - num_processors, 0));
1297
1298         for (i = 0; i < possible; i++)
1299                 set_cpu_possible(i, true);
1300         for (; i < NR_CPUS; i++)
1301                 set_cpu_possible(i, false);
1302
1303         nr_cpu_ids = possible;
1304 }
1305
1306 #ifdef CONFIG_HOTPLUG_CPU
1307
1308 static void remove_siblinginfo(int cpu)
1309 {
1310         int sibling;
1311         struct cpuinfo_x86 *c = &cpu_data(cpu);
1312
1313         for_each_cpu(sibling, cpu_core_mask(cpu)) {
1314                 cpumask_clear_cpu(cpu, cpu_core_mask(sibling));
1315                 /*/
1316                  * last thread sibling in this cpu core going down
1317                  */
1318                 if (cpumask_weight(cpu_sibling_mask(cpu)) == 1)
1319                         cpu_data(sibling).booted_cores--;
1320         }
1321
1322         for_each_cpu(sibling, cpu_sibling_mask(cpu))
1323                 cpumask_clear_cpu(cpu, cpu_sibling_mask(sibling));
1324         for_each_cpu(sibling, cpu_llc_shared_mask(cpu))
1325                 cpumask_clear_cpu(cpu, cpu_llc_shared_mask(sibling));
1326         cpumask_clear(cpu_llc_shared_mask(cpu));
1327         cpumask_clear(cpu_sibling_mask(cpu));
1328         cpumask_clear(cpu_core_mask(cpu));
1329         c->phys_proc_id = 0;
1330         c->cpu_core_id = 0;
1331         cpumask_clear_cpu(cpu, cpu_sibling_setup_mask);
1332 }
1333
1334 static void __ref remove_cpu_from_maps(int cpu)
1335 {
1336         set_cpu_online(cpu, false);
1337         cpumask_clear_cpu(cpu, cpu_callout_mask);
1338         cpumask_clear_cpu(cpu, cpu_callin_mask);
1339         /* was set by cpu_init() */
1340         cpumask_clear_cpu(cpu, cpu_initialized_mask);
1341         numa_remove_cpu(cpu);
1342 }
1343
1344 void cpu_disable_common(void)
1345 {
1346         int cpu = smp_processor_id();
1347
1348         remove_siblinginfo(cpu);
1349
1350         /* It's now safe to remove this processor from the online map */
1351         lock_vector_lock();
1352         remove_cpu_from_maps(cpu);
1353         unlock_vector_lock();
1354         fixup_irqs();
1355 }
1356
1357 int native_cpu_disable(void)
1358 {
1359         int ret;
1360
1361         ret = check_irq_vectors_for_cpu_disable();
1362         if (ret)
1363                 return ret;
1364
1365         clear_local_APIC();
1366
1367         cpu_disable_common();
1368         return 0;
1369 }
1370
1371 void native_cpu_die(unsigned int cpu)
1372 {
1373         /* We don't do anything here: idle task is faking death itself. */
1374         unsigned int i;
1375
1376         for (i = 0; i < 10; i++) {
1377                 /* They ack this in play_dead by setting CPU_DEAD */
1378                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1379                         if (system_state == SYSTEM_RUNNING)
1380                                 pr_info("CPU %u is now offline\n", cpu);
1381                         return;
1382                 }
1383                 msleep(100);
1384         }
1385         pr_err("CPU %u didn't die...\n", cpu);
1386 }
1387
1388 void play_dead_common(void)
1389 {
1390         idle_task_exit();
1391         reset_lazy_tlbstate();
1392         amd_e400_remove_cpu(raw_smp_processor_id());
1393
1394         mb();
1395         /* Ack it */
1396         __this_cpu_write(cpu_state, CPU_DEAD);
1397
1398         /*
1399          * With physical CPU hotplug, we should halt the cpu
1400          */
1401         local_irq_disable();
1402 }
1403
1404 static bool wakeup_cpu0(void)
1405 {
1406         if (smp_processor_id() == 0 && enable_start_cpu0)
1407                 return true;
1408
1409         return false;
1410 }
1411
1412 /*
1413  * We need to flush the caches before going to sleep, lest we have
1414  * dirty data in our caches when we come back up.
1415  */
1416 static inline void mwait_play_dead(void)
1417 {
1418         unsigned int eax, ebx, ecx, edx;
1419         unsigned int highest_cstate = 0;
1420         unsigned int highest_subcstate = 0;
1421         void *mwait_ptr;
1422         int i;
1423
1424         if (!this_cpu_has(X86_FEATURE_MWAIT))
1425                 return;
1426         if (!this_cpu_has(X86_FEATURE_CLFLUSH))
1427                 return;
1428         if (__this_cpu_read(cpu_info.cpuid_level) < CPUID_MWAIT_LEAF)
1429                 return;
1430
1431         eax = CPUID_MWAIT_LEAF;
1432         ecx = 0;
1433         native_cpuid(&eax, &ebx, &ecx, &edx);
1434
1435         /*
1436          * eax will be 0 if EDX enumeration is not valid.
1437          * Initialized below to cstate, sub_cstate value when EDX is valid.
1438          */
1439         if (!(ecx & CPUID5_ECX_EXTENSIONS_SUPPORTED)) {
1440                 eax = 0;
1441         } else {
1442                 edx >>= MWAIT_SUBSTATE_SIZE;
1443                 for (i = 0; i < 7 && edx; i++, edx >>= MWAIT_SUBSTATE_SIZE) {
1444                         if (edx & MWAIT_SUBSTATE_MASK) {
1445                                 highest_cstate = i;
1446                                 highest_subcstate = edx & MWAIT_SUBSTATE_MASK;
1447                         }
1448                 }
1449                 eax = (highest_cstate << MWAIT_SUBSTATE_SIZE) |
1450                         (highest_subcstate - 1);
1451         }
1452
1453         /*
1454          * This should be a memory location in a cache line which is
1455          * unlikely to be touched by other processors.  The actual
1456          * content is immaterial as it is not actually modified in any way.
1457          */
1458         mwait_ptr = &current_thread_info()->flags;
1459
1460         wbinvd();
1461
1462         while (1) {
1463                 /*
1464                  * The CLFLUSH is a workaround for erratum AAI65 for
1465                  * the Xeon 7400 series.  It's not clear it is actually
1466                  * needed, but it should be harmless in either case.
1467                  * The WBINVD is insufficient due to the spurious-wakeup
1468                  * case where we return around the loop.
1469                  */
1470                 mb();
1471                 clflush(mwait_ptr);
1472                 mb();
1473                 __monitor(mwait_ptr, 0, 0);
1474                 mb();
1475                 __mwait(eax, 0);
1476                 /*
1477                  * If NMI wants to wake up CPU0, start CPU0.
1478                  */
1479                 if (wakeup_cpu0())
1480                         start_cpu0();
1481         }
1482 }
1483
1484 static inline void hlt_play_dead(void)
1485 {
1486         if (__this_cpu_read(cpu_info.x86) >= 4)
1487                 wbinvd();
1488
1489         while (1) {
1490                 native_halt();
1491                 /*
1492                  * If NMI wants to wake up CPU0, start CPU0.
1493                  */
1494                 if (wakeup_cpu0())
1495                         start_cpu0();
1496         }
1497 }
1498
1499 void native_play_dead(void)
1500 {
1501         play_dead_common();
1502         tboot_shutdown(TB_SHUTDOWN_WFS);
1503
1504         mwait_play_dead();      /* Only returns on failure */
1505         if (cpuidle_play_dead())
1506                 hlt_play_dead();
1507 }
1508
1509 #else /* ... !CONFIG_HOTPLUG_CPU */
1510 int native_cpu_disable(void)
1511 {
1512         return -ENOSYS;
1513 }
1514
1515 void native_cpu_die(unsigned int cpu)
1516 {
1517         /* We said "no" in __cpu_disable */
1518         BUG();
1519 }
1520
1521 void native_play_dead(void)
1522 {
1523         BUG();
1524 }
1525
1526 #endif