git.oblomov.eu Git - linux-2.6/blob - arch/x86/kernel/smpboot_32.c

   1 /*
   2  *      x86 SMP booting functions
   3  *
   4  *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
   5  *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
   6  *
   7  *      Much of the core SMP work is based on previous work by Thomas Radke, to
   8  *      whom a great many thanks are extended.
   9  *
  10  *      Thanks to Intel for making available several different Pentium,
  11  *      Pentium Pro and Pentium-II/Xeon MP machines.
  12  *      Original development of Linux SMP code supported by Caldera.
  13  *
  14  *      This code is released under the GNU General Public License version 2 or
  15  *      later.
  16  *
  17  *      Fixes
  18  *              Felix Koop      :       NR_CPUS used properly
  19  *              Jose Renau      :       Handle single CPU case.
  20  *              Alan Cox        :       By repeated request 8) - Total BogoMIPS report.
  21  *              Greg Wright     :       Fix for kernel stacks panic.
  22  *              Erich Boleyn    :       MP v1.4 and additional changes.
  23  *      Matthias Sattler        :       Changes for 2.1 kernel map.
  24  *      Michel Lespinasse       :       Changes for 2.1 kernel map.
  25  *      Michael Chastain        :       Change trampoline.S to gnu as.
  26  *              Alan Cox        :       Dumb bug: 'B' step PPro's are fine
  27  *              Ingo Molnar     :       Added APIC timers, based on code
  28  *                                      from Jose Renau
  29  *              Ingo Molnar     :       various cleanups and rewrites
  30  *              Tigran Aivazian :       fixed "0.00 in /proc/uptime on SMP" bug.
  31  *      Maciej W. Rozycki       :       Bits for genuine 82489DX APICs
  32  *              Martin J. Bligh :       Added support for multi-quad systems
  33  *              Dave Jones      :       Report invalid combinations of Athlon CPUs.
  34 *               Rusty Russell   :       Hacked into shape for new "hotplug" boot process. */
  35
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38 #include <linux/kernel.h>
  39
  40 #include <linux/mm.h>
  41 #include <linux/sched.h>
  42 #include <linux/kernel_stat.h>
  43 #include <linux/bootmem.h>
  44 #include <linux/notifier.h>
  45 #include <linux/cpu.h>
  46 #include <linux/percpu.h>
  47 #include <linux/nmi.h>
  48
  49 #include <linux/delay.h>
  50 #include <linux/mc146818rtc.h>
  51 #include <asm/tlbflush.h>
  52 #include <asm/desc.h>
  53 #include <asm/arch_hooks.h>
  54 #include <asm/nmi.h>
  55
  56 #include <mach_apic.h>
  57 #include <mach_wakecpu.h>
  58 #include <smpboot_hooks.h>
  59 #include <asm/vmi.h>
  60 #include <asm/mtrr.h>
  61
  62 /* Set if we find a B stepping CPU */
  63 static int __cpuinitdata smp_b_stepping;
  64
  65 static cpumask_t smp_commenced_mask;
  66
  67 /* which logical CPU number maps to which CPU (physical APIC ID) */
  68 u16 x86_cpu_to_apicid_init[NR_CPUS] __initdata =
  69                         { [0 ... NR_CPUS-1] = BAD_APICID };
  70 void *x86_cpu_to_apicid_early_ptr;
  71 DEFINE_PER_CPU(u16, x86_cpu_to_apicid) = BAD_APICID;
  72 EXPORT_PER_CPU_SYMBOL(x86_cpu_to_apicid);
  73
  74 u8 apicid_2_node[MAX_APICID];
  75
  76 /*
  77  * Trampoline 80x86 program as an array.
  78  */
  79
  80 extern const unsigned char trampoline_data [];
  81 extern const unsigned char trampoline_end  [];
  82 static unsigned char *trampoline_base;
  83
  84 static void map_cpu_to_logical_apicid(void);
  85
  86 /* State of each CPU. */
  87 DEFINE_PER_CPU(int, cpu_state) = { 0 };
  88
  89 /*
  90  * Currently trivial. Write the real->protected mode
  91  * bootstrap into the page concerned. The caller
  92  * has made sure it's suitably aligned.
  93  */
  94
  95 static unsigned long __cpuinit setup_trampoline(void)
  96 {
  97         memcpy(trampoline_base, trampoline_data, trampoline_end - trampoline_data);
  98         return virt_to_phys(trampoline_base);
  99 }
 100
 101 /*
 102  * We are called very early to get the low memory for the
 103  * SMP bootup trampoline page.
 104  */
 105 void __init smp_alloc_memory(void)
 106 {
 107         trampoline_base = alloc_bootmem_low_pages(PAGE_SIZE);
 108         /*
 109          * Has to be in very low memory so we can execute
 110          * real-mode AP code.
 111          */
 112         if (__pa(trampoline_base) >= 0x9F000)
 113                 BUG();
 114 }
 115
 116 /*
 117  * The bootstrap kernel entry code has set these up. Save them for
 118  * a given CPU
 119  */
 120
 121 void __cpuinit smp_store_cpu_info(int id)
 122 {
 123         struct cpuinfo_x86 *c = &cpu_data(id);
 124
 125         *c = boot_cpu_data;
 126         c->cpu_index = id;
 127         if (id!=0)
 128                 identify_secondary_cpu(c);
 129         /*
 130          * Mask B, Pentium, but not Pentium MMX
 131          */
 132         if (c->x86_vendor == X86_VENDOR_INTEL &&
 133             c->x86 == 5 &&
 134             c->x86_mask >= 1 && c->x86_mask <= 4 &&
 135             c->x86_model <= 3)
 136                 /*
 137                  * Remember we have B step Pentia with bugs
 138                  */
 139                 smp_b_stepping = 1;
 140
 141         /*
 142          * Certain Athlons might work (for various values of 'work') in SMP
 143          * but they are not certified as MP capable.
 144          */
 145         if ((c->x86_vendor == X86_VENDOR_AMD) && (c->x86 == 6)) {
 146
 147                 if (num_possible_cpus() == 1)
 148                         goto valid_k7;
 149
 150                 /* Athlon 660/661 is valid. */
 151                 if ((c->x86_model==6) && ((c->x86_mask==0) || (c->x86_mask==1)))
 152                         goto valid_k7;
 153
 154                 /* Duron 670 is valid */
 155                 if ((c->x86_model==7) && (c->x86_mask==0))
 156                         goto valid_k7;
 157
 158                 /*
 159                  * Athlon 662, Duron 671, and Athlon >model 7 have capability bit.
 160                  * It's worth noting that the A5 stepping (662) of some Athlon XP's
 161                  * have the MP bit set.
 162                  * See http://www.heise.de/newsticker/data/jow-18.10.01-000 for more.
 163                  */
 164                 if (((c->x86_model==6) && (c->x86_mask>=2)) ||
 165                     ((c->x86_model==7) && (c->x86_mask>=1)) ||
 166                      (c->x86_model> 7))
 167                         if (cpu_has_mp)
 168                                 goto valid_k7;
 169
 170                 /* If we get here, it's not a certified SMP capable AMD system. */
 171                 add_taint(TAINT_UNSAFE_SMP);
 172         }
 173
 174 valid_k7:
 175         ;
 176 }
 177
 178 static atomic_t init_deasserted;
 179
 180 static void __cpuinit smp_callin(void)
 181 {
 182         int cpuid, phys_id;
 183         unsigned long timeout;
 184
 185         /*
 186          * If waken up by an INIT in an 82489DX configuration
 187          * we may get here before an INIT-deassert IPI reaches
 188          * our local APIC.  We have to wait for the IPI or we'll
 189          * lock up on an APIC access.
 190          */
 191         wait_for_init_deassert(&init_deasserted);
 192
 193         /*
 194          * (This works even if the APIC is not enabled.)
 195          */
 196         phys_id = GET_APIC_ID(apic_read(APIC_ID));
 197         cpuid = smp_processor_id();
 198         if (cpu_isset(cpuid, cpu_callin_map)) {
 199                 printk("huh, phys CPU#%d, CPU#%d already present??\n",
 200                                         phys_id, cpuid);
 201                 BUG();
 202         }
 203         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
 204
 205         /*
 206          * STARTUP IPIs are fragile beasts as they might sometimes
 207          * trigger some glue motherboard logic. Complete APIC bus
 208          * silence for 1 second, this overestimates the time the
 209          * boot CPU is spending to send the up to 2 STARTUP IPIs
 210          * by a factor of two. This should be enough.
 211          */
 212
 213         /*
 214          * Waiting 2s total for startup (udelay is not yet working)
 215          */
 216         timeout = jiffies + 2*HZ;
 217         while (time_before(jiffies, timeout)) {
 218                 /*
 219                  * Has the boot CPU finished it's STARTUP sequence?
 220                  */
 221                 if (cpu_isset(cpuid, cpu_callout_map))
 222                         break;
 223                 rep_nop();
 224         }
 225
 226         if (!time_before(jiffies, timeout)) {
 227                 printk("BUG: CPU%d started up but did not get a callout!\n",
 228                         cpuid);
 229                 BUG();
 230         }
 231
 232         /*
 233          * the boot CPU has finished the init stage and is spinning
 234          * on callin_map until we finish. We are free to set up this
 235          * CPU, first the APIC. (this is probably redundant on most
 236          * boards)
 237          */
 238
 239         Dprintk("CALLIN, before setup_local_APIC().\n");
 240         smp_callin_clear_local_apic();
 241         setup_local_APIC();
 242         map_cpu_to_logical_apicid();
 243
 244         /*
 245          * Get our bogomips.
 246          */
 247         calibrate_delay();
 248         Dprintk("Stack at about %p\n",&cpuid);
 249
 250         /*
 251          * Save our processor parameters
 252          */
 253         smp_store_cpu_info(cpuid);
 254
 255         /*
 256          * Allow the master to continue.
 257          */
 258         cpu_set(cpuid, cpu_callin_map);
 259 }
 260
 261 static int cpucount;
 262
 263 /*
 264  * Activate a secondary processor.
 265  */
 266 static void __cpuinit start_secondary(void *unused)
 267 {
 268         /*
 269          * Don't put *anything* before cpu_init(), SMP booting is too
 270          * fragile that we want to limit the things done here to the
 271          * most necessary things.
 272          */
 273 #ifdef CONFIG_VMI
 274         vmi_bringup();
 275 #endif
 276         cpu_init();
 277         preempt_disable();
 278         smp_callin();
 279         while (!cpu_isset(smp_processor_id(), smp_commenced_mask))
 280                 rep_nop();
 281         /*
 282          * Check TSC synchronization with the BP:
 283          */
 284         check_tsc_sync_target();
 285
 286         setup_secondary_clock();
 287         if (nmi_watchdog == NMI_IO_APIC) {
 288                 disable_8259A_irq(0);
 289                 enable_NMI_through_LVT0();
 290                 enable_8259A_irq(0);
 291         }
 292         /*
 293          * low-memory mappings have been cleared, flush them from
 294          * the local TLBs too.
 295          */
 296         local_flush_tlb();
 297
 298         /* This must be done before setting cpu_online_map */
 299         set_cpu_sibling_map(raw_smp_processor_id());
 300         wmb();
 301
 302         /*
 303          * We need to hold call_lock, so there is no inconsistency
 304          * between the time smp_call_function() determines number of
 305          * IPI recipients, and the time when the determination is made
 306          * for which cpus receive the IPI. Holding this
 307          * lock helps us to not include this cpu in a currently in progress
 308          * smp_call_function().
 309          */
 310         lock_ipi_call_lock();
 311         cpu_set(smp_processor_id(), cpu_online_map);
 312         unlock_ipi_call_lock();
 313         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
 314
 315         /* We can take interrupts now: we're officially "up". */
 316         local_irq_enable();
 317
 318         wmb();
 319         cpu_idle();
 320 }
 321
 322 /*
 323  * Everything has been set up for the secondary
 324  * CPUs - they just need to reload everything
 325  * from the task structure
 326  * This function must not return.
 327  */
 328 void __devinit initialize_secondary(void)
 329 {
 330         /*
 331          * We don't actually need to load the full TSS,
 332          * basically just the stack pointer and the ip.
 333          */
 334
 335         asm volatile(
 336                 "movl %0,%%esp\n\t"
 337                 "jmp *%1"
 338                 :
 339                 :"m" (current->thread.sp),"m" (current->thread.ip));
 340 }
 341
 342 /* Static state in head.S used to set up a CPU */
 343 extern struct {
 344         void * sp;
 345         unsigned short ss;
 346 } stack_start;
 347
 348 #ifdef CONFIG_NUMA
 349
 350 /* which logical CPUs are on which nodes */
 351 cpumask_t node_to_cpumask_map[MAX_NUMNODES] __read_mostly =
 352                                 { [0 ... MAX_NUMNODES-1] = CPU_MASK_NONE };
 353 EXPORT_SYMBOL(node_to_cpumask_map);
 354 /* which node each logical CPU is on */
 355 int cpu_to_node_map[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = 0 };
 356 EXPORT_SYMBOL(cpu_to_node_map);
 357
 358 /* set up a mapping between cpu and node. */
 359 static inline void map_cpu_to_node(int cpu, int node)
 360 {
 361         printk("Mapping cpu %d to node %d\n", cpu, node);
 362         cpu_set(cpu, node_to_cpumask_map[node]);
 363         cpu_to_node_map[cpu] = node;
 364 }
 365
 366 /* undo a mapping between cpu and node. */
 367 static inline void unmap_cpu_to_node(int cpu)
 368 {
 369         int node;
 370
 371         printk("Unmapping cpu %d from all nodes\n", cpu);
 372         for (node = 0; node < MAX_NUMNODES; node ++)
 373                 cpu_clear(cpu, node_to_cpumask_map[node]);
 374         cpu_to_node_map[cpu] = 0;
 375 }
 376 #else /* !CONFIG_NUMA */
 377
 378 #define map_cpu_to_node(cpu, node)      ({})
 379 #define unmap_cpu_to_node(cpu)  ({})
 380
 381 #endif /* CONFIG_NUMA */
 382
 383 u8 cpu_2_logical_apicid[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
 384
 385 static void map_cpu_to_logical_apicid(void)
 386 {
 387         int cpu = smp_processor_id();
 388         int apicid = logical_smp_processor_id();
 389         int node = apicid_to_node(apicid);
 390
 391         if (!node_online(node))
 392                 node = first_online_node;
 393
 394         cpu_2_logical_apicid[cpu] = apicid;
 395         map_cpu_to_node(cpu, node);
 396 }
 397
 398 static void unmap_cpu_to_logical_apicid(int cpu)
 399 {
 400         cpu_2_logical_apicid[cpu] = BAD_APICID;
 401         unmap_cpu_to_node(cpu);
 402 }
 403
 404 static inline void __inquire_remote_apic(int apicid)
 405 {
 406         int i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
 407         char *names[] = { "ID", "VERSION", "SPIV" };
 408         int timeout;
 409         unsigned long status;
 410
 411         printk("Inquiring remote APIC #%d...\n", apicid);
 412
 413         for (i = 0; i < ARRAY_SIZE(regs); i++) {
 414                 printk("... APIC #%d %s: ", apicid, names[i]);
 415
 416                 /*
 417                  * Wait for idle.
 418                  */
 419                 status = safe_apic_wait_icr_idle();
 420                 if (status)
 421                         printk("a previous APIC delivery may have failed\n");
 422
 423                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
 424                 apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);
 425
 426                 timeout = 0;
 427                 do {
 428                         udelay(100);
 429                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
 430                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
 431
 432                 switch (status) {
 433                 case APIC_ICR_RR_VALID:
 434                         status = apic_read(APIC_RRR);
 435                         printk("%lx\n", status);
 436                         break;
 437                 default:
 438                         printk("failed\n");
 439                 }
 440         }
 441 }
 442
 443 #ifdef WAKE_SECONDARY_VIA_NMI
 444 /*
 445  * Poke the other CPU in the eye via NMI to wake it up. Remember that the normal
 446  * INIT, INIT, STARTUP sequence will reset the chip hard for us, and this
 447  * won't ... remember to clear down the APIC, etc later.
 448  */
 449 static int __devinit
 450 wakeup_secondary_cpu(int logical_apicid, unsigned long start_eip)
 451 {
 452         unsigned long send_status, accept_status = 0;
 453         int maxlvt;
 454
 455         /* Target chip */
 456         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(logical_apicid));
 457
 458         /* Boot on the stack */
 459         /* Kick the second */
 460         apic_write_around(APIC_ICR, APIC_DM_NMI | APIC_DEST_LOGICAL);
 461
 462         Dprintk("Waiting for send to finish...\n");
 463         send_status = safe_apic_wait_icr_idle();
 464
 465         /*
 466          * Give the other CPU some time to accept the IPI.
 467          */
 468         udelay(200);
 469         /*
 470          * Due to the Pentium erratum 3AP.
 471          */
 472         maxlvt = lapic_get_maxlvt();
 473         if (maxlvt > 3) {
 474                 apic_read_around(APIC_SPIV);
 475                 apic_write(APIC_ESR, 0);
 476         }
 477         accept_status = (apic_read(APIC_ESR) & 0xEF);
 478         Dprintk("NMI sent.\n");
 479
 480         if (send_status)
 481                 printk("APIC never delivered???\n");
 482         if (accept_status)
 483                 printk("APIC delivery error (%lx).\n", accept_status);
 484
 485         return (send_status | accept_status);
 486 }
 487 #endif  /* WAKE_SECONDARY_VIA_NMI */
 488
 489 #ifdef WAKE_SECONDARY_VIA_INIT
 490 static int __devinit
 491 wakeup_secondary_cpu(int phys_apicid, unsigned long start_eip)
 492 {
 493         unsigned long send_status, accept_status = 0;
 494         int maxlvt, num_starts, j;
 495
 496         /*
 497          * Be paranoid about clearing APIC errors.
 498          */
 499         if (APIC_INTEGRATED(apic_version[phys_apicid])) {
 500                 apic_read_around(APIC_SPIV);
 501                 apic_write(APIC_ESR, 0);
 502                 apic_read(APIC_ESR);
 503         }
 504
 505         Dprintk("Asserting INIT.\n");
 506
 507         /*
 508          * Turn INIT on target chip
 509          */
 510         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 511
 512         /*
 513          * Send IPI
 514          */
 515         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
 516                                 | APIC_DM_INIT);
 517
 518         Dprintk("Waiting for send to finish...\n");
 519         send_status = safe_apic_wait_icr_idle();
 520
 521         mdelay(10);
 522
 523         Dprintk("Deasserting INIT.\n");
 524
 525         /* Target chip */
 526         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 527
 528         /* Send IPI */
 529         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
 530
 531         Dprintk("Waiting for send to finish...\n");
 532         send_status = safe_apic_wait_icr_idle();
 533
 534         atomic_set(&init_deasserted, 1);
 535
 536         /*
 537          * Should we send STARTUP IPIs ?
 538          *
 539          * Determine this based on the APIC version.
 540          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
 541          */
 542         if (APIC_INTEGRATED(apic_version[phys_apicid]))
 543                 num_starts = 2;
 544         else
 545                 num_starts = 0;
 546
 547         /*
 548          * Paravirt / VMI wants a startup IPI hook here to set up the
 549          * target processor state.
 550          */
 551         startup_ipi_hook(phys_apicid, (unsigned long) start_secondary,
 552                          (unsigned long) stack_start.sp);
 553
 554         /*
 555          * Run STARTUP IPI loop.
 556          */
 557         Dprintk("#startup loops: %d.\n", num_starts);
 558
 559         maxlvt = lapic_get_maxlvt();
 560
 561         for (j = 1; j <= num_starts; j++) {
 562                 Dprintk("Sending STARTUP #%d.\n",j);
 563                 apic_read_around(APIC_SPIV);
 564                 apic_write(APIC_ESR, 0);
 565                 apic_read(APIC_ESR);
 566                 Dprintk("After apic_write.\n");
 567
 568                 /*
 569                  * STARTUP IPI
 570                  */
 571
 572                 /* Target chip */
 573                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 574
 575                 /* Boot on the stack */
 576                 /* Kick the second */
 577                 apic_write_around(APIC_ICR, APIC_DM_STARTUP
 578                                         | (start_eip >> 12));
 579
 580                 /*
 581                  * Give the other CPU some time to accept the IPI.
 582                  */
 583                 udelay(300);
 584
 585                 Dprintk("Startup point 1.\n");
 586
 587                 Dprintk("Waiting for send to finish...\n");
 588                 send_status = safe_apic_wait_icr_idle();
 589
 590                 /*
 591                  * Give the other CPU some time to accept the IPI.
 592                  */
 593                 udelay(200);
 594                 /*
 595                  * Due to the Pentium erratum 3AP.
 596                  */
 597                 if (maxlvt > 3) {
 598                         apic_read_around(APIC_SPIV);
 599                         apic_write(APIC_ESR, 0);
 600                 }
 601                 accept_status = (apic_read(APIC_ESR) & 0xEF);
 602                 if (send_status || accept_status)
 603                         break;
 604         }
 605         Dprintk("After Startup.\n");
 606
 607         if (send_status)
 608                 printk("APIC never delivered???\n");
 609         if (accept_status)
 610                 printk("APIC delivery error (%lx).\n", accept_status);
 611
 612         return (send_status | accept_status);
 613 }
 614 #endif  /* WAKE_SECONDARY_VIA_INIT */
 615
 616 extern cpumask_t cpu_initialized;
 617 static inline int alloc_cpu_id(void)
 618 {
 619         cpumask_t       tmp_map;
 620         int cpu;
 621         cpus_complement(tmp_map, cpu_present_map);
 622         cpu = first_cpu(tmp_map);
 623         if (cpu >= NR_CPUS)
 624                 return -ENODEV;
 625         return cpu;
 626 }
 627
 628 #ifdef CONFIG_HOTPLUG_CPU
 629 static struct task_struct * __cpuinitdata cpu_idle_tasks[NR_CPUS];
 630 static inline struct task_struct * __cpuinit alloc_idle_task(int cpu)
 631 {
 632         struct task_struct *idle;
 633
 634         if ((idle = cpu_idle_tasks[cpu]) != NULL) {
 635                 /* initialize thread_struct.  we really want to avoid destroy
 636                  * idle tread
 637                  */
 638                 idle->thread.sp = (unsigned long)task_pt_regs(idle);
 639                 init_idle(idle, cpu);
 640                 return idle;
 641         }
 642         idle = fork_idle(cpu);
 643
 644         if (!IS_ERR(idle))
 645                 cpu_idle_tasks[cpu] = idle;
 646         return idle;
 647 }
 648 #else
 649 #define alloc_idle_task(cpu) fork_idle(cpu)
 650 #endif
 651
 652 static int __cpuinit do_boot_cpu(int apicid, int cpu)
 653 /*
 654  * NOTE - on most systems this is a PHYSICAL apic ID, but on multiquad
 655  * (ie clustered apic addressing mode), this is a LOGICAL apic ID.
 656  * Returns zero if CPU booted OK, else error code from wakeup_secondary_cpu.
 657  */
 658 {
 659         struct task_struct *idle;
 660         unsigned long boot_error;
 661         int timeout;
 662         unsigned long start_eip;
 663         unsigned short nmi_high = 0, nmi_low = 0;
 664
 665         /*
 666          * Save current MTRR state in case it was changed since early boot
 667          * (e.g. by the ACPI SMI) to initialize new CPUs with MTRRs in sync:
 668          */
 669         mtrr_save_state();
 670
 671         /*
 672          * We can't use kernel_thread since we must avoid to
 673          * reschedule the child.
 674          */
 675         idle = alloc_idle_task(cpu);
 676         if (IS_ERR(idle))
 677                 panic("failed fork for CPU %d", cpu);
 678
 679         init_gdt(cpu);
 680         per_cpu(current_task, cpu) = idle;
 681         early_gdt_descr.address = (unsigned long)get_cpu_gdt_table(cpu);
 682
 683         idle->thread.ip = (unsigned long) start_secondary;
 684         /* start_eip had better be page-aligned! */
 685         start_eip = setup_trampoline();
 686
 687         ++cpucount;
 688         alternatives_smp_switch(1);
 689
 690         /* So we see what's up   */
 691         printk("Booting processor %d/%d ip %lx\n", cpu, apicid, start_eip);
 692         /* Stack for startup_32 can be just as for start_secondary onwards */
 693         stack_start.sp = (void *) idle->thread.sp;
 694
 695         irq_ctx_init(cpu);
 696
 697         per_cpu(x86_cpu_to_apicid, cpu) = apicid;
 698         /*
 699          * This grunge runs the startup process for
 700          * the targeted processor.
 701          */
 702
 703         atomic_set(&init_deasserted, 0);
 704
 705         Dprintk("Setting warm reset code and vector.\n");
 706
 707         store_NMI_vector(&nmi_high, &nmi_low);
 708
 709         smpboot_setup_warm_reset_vector(start_eip);
 710
 711         /*
 712          * Starting actual IPI sequence...
 713          */
 714         boot_error = wakeup_secondary_cpu(apicid, start_eip);
 715
 716         if (!boot_error) {
 717                 /*
 718                  * allow APs to start initializing.
 719                  */
 720                 Dprintk("Before Callout %d.\n", cpu);
 721                 cpu_set(cpu, cpu_callout_map);
 722                 Dprintk("After Callout %d.\n", cpu);
 723
 724                 /*
 725                  * Wait 5s total for a response
 726                  */
 727                 for (timeout = 0; timeout < 50000; timeout++) {
 728                         if (cpu_isset(cpu, cpu_callin_map))
 729                                 break;  /* It has booted */
 730                         udelay(100);
 731                 }
 732
 733                 if (cpu_isset(cpu, cpu_callin_map)) {
 734                         /* number CPUs logically, starting from 1 (BSP is 0) */
 735                         Dprintk("OK.\n");
 736                         printk("CPU%d: ", cpu);
 737                         print_cpu_info(&cpu_data(cpu));
 738                         Dprintk("CPU has booted.\n");
 739                 } else {
 740                         boot_error= 1;
 741                         if (*((volatile unsigned char *)trampoline_base)
 742                                         == 0xA5)
 743                                 /* trampoline started but...? */
 744                                 printk("Stuck ??\n");
 745                         else
 746                                 /* trampoline code not run */
 747                                 printk("Not responding.\n");
 748                         inquire_remote_apic(apicid);
 749                 }
 750         }
 751
 752         if (boot_error) {
 753                 /* Try to put things back the way they were before ... */
 754                 unmap_cpu_to_logical_apicid(cpu);
 755                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
 756                 cpu_clear(cpu, cpu_initialized); /* was set by cpu_init() */
 757                 cpucount--;
 758         } else {
 759                 per_cpu(x86_cpu_to_apicid, cpu) = apicid;
 760                 cpu_set(cpu, cpu_present_map);
 761         }
 762
 763         /* mark "stuck" area as not stuck */
 764         *((volatile unsigned long *)trampoline_base) = 0;
 765
 766         return boot_error;
 767 }
 768
 769 #ifdef CONFIG_HOTPLUG_CPU
 770 void cpu_exit_clear(void)
 771 {
 772         int cpu = raw_smp_processor_id();
 773
 774         idle_task_exit();
 775
 776         cpucount --;
 777         cpu_uninit();
 778         irq_ctx_exit(cpu);
 779
 780         cpu_clear(cpu, cpu_callout_map);
 781         cpu_clear(cpu, cpu_callin_map);
 782
 783         cpu_clear(cpu, smp_commenced_mask);
 784         unmap_cpu_to_logical_apicid(cpu);
 785 }
 786
 787 struct warm_boot_cpu_info {
 788         struct completion *complete;
 789         struct work_struct task;
 790         int apicid;
 791         int cpu;
 792 };
 793
 794 static void __cpuinit do_warm_boot_cpu(struct work_struct *work)
 795 {
 796         struct warm_boot_cpu_info *info =
 797                 container_of(work, struct warm_boot_cpu_info, task);
 798         do_boot_cpu(info->apicid, info->cpu);
 799         complete(info->complete);
 800 }
 801
 802 static int __cpuinit __smp_prepare_cpu(int cpu)
 803 {
 804         DECLARE_COMPLETION_ONSTACK(done);
 805         struct warm_boot_cpu_info info;
 806         int     apicid, ret;
 807
 808         apicid = per_cpu(x86_cpu_to_apicid, cpu);
 809         if (apicid == BAD_APICID) {
 810                 ret = -ENODEV;
 811                 goto exit;
 812         }
 813
 814         info.complete = &done;
 815         info.apicid = apicid;
 816         info.cpu = cpu;
 817         INIT_WORK(&info.task, do_warm_boot_cpu);
 818
 819         /* init low mem mapping */
 820         clone_pgd_range(swapper_pg_dir, swapper_pg_dir + USER_PGD_PTRS,
 821                         min_t(unsigned long, KERNEL_PGD_PTRS, USER_PGD_PTRS));
 822         flush_tlb_all();
 823         schedule_work(&info.task);
 824         wait_for_completion(&done);
 825
 826         zap_low_mappings();
 827         ret = 0;
 828 exit:
 829         return ret;
 830 }
 831 #endif
 832
 833 /*
 834  * Cycle through the processors sending APIC IPIs to boot each.
 835  */
 836
 837 static int boot_cpu_logical_apicid;
 838 /* Where the IO area was mapped on multiquad, always 0 otherwise */
 839 void *xquad_portio;
 840 #ifdef CONFIG_X86_NUMAQ
 841 EXPORT_SYMBOL(xquad_portio);
 842 #endif
 843
 844 static void __init smp_boot_cpus(unsigned int max_cpus)
 845 {
 846         int apicid, cpu, bit, kicked;
 847         unsigned long bogosum = 0;
 848
 849         /*
 850          * Setup boot CPU information
 851          */
 852         smp_store_cpu_info(0); /* Final full version of the data */
 853         printk("CPU%d: ", 0);
 854         print_cpu_info(&cpu_data(0));
 855
 856         boot_cpu_physical_apicid = GET_APIC_ID(apic_read(APIC_ID));
 857         boot_cpu_logical_apicid = logical_smp_processor_id();
 858         per_cpu(x86_cpu_to_apicid, 0) = boot_cpu_physical_apicid;
 859
 860         current_thread_info()->cpu = 0;
 861
 862         set_cpu_sibling_map(0);
 863
 864         /*
 865          * If we couldn't find an SMP configuration at boot time,
 866          * get out of here now!
 867          */
 868         if (!smp_found_config && !acpi_lapic) {
 869                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
 870                 smpboot_clear_io_apic_irqs();
 871                 phys_cpu_present_map = physid_mask_of_physid(0);
 872                 if (APIC_init_uniprocessor())
 873                         printk(KERN_NOTICE "Local APIC not detected."
 874                                            " Using dummy APIC emulation.\n");
 875                 map_cpu_to_logical_apicid();
 876                 cpu_set(0, per_cpu(cpu_sibling_map, 0));
 877                 cpu_set(0, per_cpu(cpu_core_map, 0));
 878                 return;
 879         }
 880
 881         /*
 882          * Should not be necessary because the MP table should list the boot
 883          * CPU too, but we do it for the sake of robustness anyway.
 884          * Makes no sense to do this check in clustered apic mode, so skip it
 885          */
 886         if (!check_phys_apicid_present(boot_cpu_physical_apicid)) {
 887                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
 888                                 boot_cpu_physical_apicid);
 889                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
 890         }
 891
 892         /*
 893          * If we couldn't find a local APIC, then get out of here now!
 894          */
 895         if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid]) && !cpu_has_apic) {
 896                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
 897                         boot_cpu_physical_apicid);
 898                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
 899                 smpboot_clear_io_apic_irqs();
 900                 phys_cpu_present_map = physid_mask_of_physid(0);
 901                 map_cpu_to_logical_apicid();
 902                 cpu_set(0, per_cpu(cpu_sibling_map, 0));
 903                 cpu_set(0, per_cpu(cpu_core_map, 0));
 904                 return;
 905         }
 906
 907         verify_local_APIC();
 908
 909         /*
 910          * If SMP should be disabled, then really disable it!
 911          */
 912         if (!max_cpus) {
 913                 smp_found_config = 0;
 914                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
 915
 916                 if (nmi_watchdog == NMI_LOCAL_APIC) {
 917                         printk(KERN_INFO "activating minimal APIC for NMI watchdog use.\n");
 918                         connect_bsp_APIC();
 919                         setup_local_APIC();
 920                 }
 921                 smpboot_clear_io_apic_irqs();
 922                 phys_cpu_present_map = physid_mask_of_physid(0);
 923                 map_cpu_to_logical_apicid();
 924                 cpu_set(0, per_cpu(cpu_sibling_map, 0));
 925                 cpu_set(0, per_cpu(cpu_core_map, 0));
 926                 return;
 927         }
 928
 929         connect_bsp_APIC();
 930         setup_local_APIC();
 931         map_cpu_to_logical_apicid();
 932
 933
 934         setup_portio_remap();
 935
 936         /*
 937          * Scan the CPU present map and fire up the other CPUs via do_boot_cpu
 938          *
 939          * In clustered apic mode, phys_cpu_present_map is a constructed thus:
 940          * bits 0-3 are quad0, 4-7 are quad1, etc. A perverse twist on the
 941          * clustered apic ID.
 942          */
 943         Dprintk("CPU present map: %lx\n", physids_coerce(phys_cpu_present_map));
 944
 945         kicked = 1;
 946         for (bit = 0; kicked < NR_CPUS && bit < MAX_APICS; bit++) {
 947                 apicid = cpu_present_to_apicid(bit);
 948                 /*
 949                  * Don't even attempt to start the boot CPU!
 950                  */
 951                 if ((apicid == boot_cpu_apicid) || (apicid == BAD_APICID))
 952                         continue;
 953
 954                 if (!check_apicid_present(bit))
 955                         continue;
 956                 if (max_cpus <= cpucount+1)
 957                         continue;
 958
 959                 if (((cpu = alloc_cpu_id()) <= 0) || do_boot_cpu(apicid, cpu))
 960                         printk("CPU #%d not responding - cannot use it.\n",
 961                                                                 apicid);
 962                 else
 963                         ++kicked;
 964         }
 965
 966         /*
 967          * Cleanup possible dangling ends...
 968          */
 969         smpboot_restore_warm_reset_vector();
 970
 971         /*
 972          * Allow the user to impress friends.
 973          */
 974         Dprintk("Before bogomips.\n");
 975         for_each_possible_cpu(cpu)
 976                 if (cpu_isset(cpu, cpu_callout_map))
 977                         bogosum += cpu_data(cpu).loops_per_jiffy;
 978         printk(KERN_INFO
 979                 "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
 980                 cpucount+1,
 981                 bogosum/(500000/HZ),
 982                 (bogosum/(5000/HZ))%100);
 983
 984         Dprintk("Before bogocount - setting activated=1.\n");
 985
 986         if (smp_b_stepping)
 987                 printk(KERN_WARNING "WARNING: SMP operation may be unreliable with B stepping processors.\n");
 988
 989         /*
 990          * Don't taint if we are running SMP kernel on a single non-MP
 991          * approved Athlon
 992          */
 993         if (tainted & TAINT_UNSAFE_SMP) {
 994                 if (cpucount)
 995                         printk (KERN_INFO "WARNING: This combination of AMD processors is not suitable for SMP.\n");
 996                 else
 997                         tainted &= ~TAINT_UNSAFE_SMP;
 998         }
 999
1000         Dprintk("Boot done.\n");
1001
1002         /*
1003          * construct cpu_sibling_map, so that we can tell sibling CPUs
1004          * efficiently.
1005          */
1006         for_each_possible_cpu(cpu) {
1007                 cpus_clear(per_cpu(cpu_sibling_map, cpu));
1008                 cpus_clear(per_cpu(cpu_core_map, cpu));
1009         }
1010
1011         cpu_set(0, per_cpu(cpu_sibling_map, 0));
1012         cpu_set(0, per_cpu(cpu_core_map, 0));
1013
1014         smpboot_setup_io_apic();
1015
1016         setup_boot_clock();
1017 }
1018
1019 /* These are wrappers to interface to the new boot process.  Someone
1020    who understands all this stuff should rewrite it properly. --RR 15/Jul/02 */
1021 void __init native_smp_prepare_cpus(unsigned int max_cpus)
1022 {
1023         smp_commenced_mask = cpumask_of_cpu(0);
1024         cpu_callin_map = cpumask_of_cpu(0);
1025         mb();
1026         smp_boot_cpus(max_cpus);
1027 }
1028
1029 void __init native_smp_prepare_boot_cpu(void)
1030 {
1031         unsigned int cpu = smp_processor_id();
1032
1033         init_gdt(cpu);
1034         switch_to_new_gdt();
1035
1036         cpu_set(cpu, cpu_online_map);
1037         cpu_set(cpu, cpu_callout_map);
1038         cpu_set(cpu, cpu_present_map);
1039         cpu_set(cpu, cpu_possible_map);
1040         __get_cpu_var(cpu_state) = CPU_ONLINE;
1041 }
1042
1043 #ifdef CONFIG_HOTPLUG_CPU
1044 int __cpu_disable(void)
1045 {
1046         cpumask_t map = cpu_online_map;
1047         int cpu = smp_processor_id();
1048
1049         /*
1050          * Perhaps use cpufreq to drop frequency, but that could go
1051          * into generic code.
1052          *
1053          * We won't take down the boot processor on i386 due to some
1054          * interrupts only being able to be serviced by the BSP.
1055          * Especially so if we're not using an IOAPIC   -zwane
1056          */
1057         if (cpu == 0)
1058                 return -EBUSY;
1059         if (nmi_watchdog == NMI_LOCAL_APIC)
1060                 stop_apic_nmi_watchdog(NULL);
1061         clear_local_APIC();
1062         /* Allow any queued timer interrupts to get serviced */
1063         local_irq_enable();
1064         mdelay(1);
1065         local_irq_disable();
1066
1067         remove_siblinginfo(cpu);
1068
1069         cpu_clear(cpu, map);
1070         fixup_irqs(map);
1071         /* It's now safe to remove this processor from the online map */
1072         cpu_clear(cpu, cpu_online_map);
1073         return 0;
1074 }
1075
1076 void __cpu_die(unsigned int cpu)
1077 {
1078         /* We don't do anything here: idle task is faking death itself. */
1079         unsigned int i;
1080
1081         for (i = 0; i < 10; i++) {
1082                 /* They ack this in play_dead by setting CPU_DEAD */
1083                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1084                         printk ("CPU %d is now offline\n", cpu);
1085                         if (1 == num_online_cpus())
1086                                 alternatives_smp_switch(0);
1087                         return;
1088                 }
1089                 msleep(100);
1090         }
1091         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
1092 }
1093 #else /* ... !CONFIG_HOTPLUG_CPU */
1094 int __cpu_disable(void)
1095 {
1096         return -ENOSYS;
1097 }
1098
1099 void __cpu_die(unsigned int cpu)
1100 {
1101         /* We said "no" in __cpu_disable */
1102         BUG();
1103 }
1104 #endif /* CONFIG_HOTPLUG_CPU */
1105
1106 int __cpuinit native_cpu_up(unsigned int cpu)
1107 {
1108         unsigned long flags;
1109 #ifdef CONFIG_HOTPLUG_CPU
1110         int ret = 0;
1111
1112         /*
1113          * We do warm boot only on cpus that had booted earlier
1114          * Otherwise cold boot is all handled from smp_boot_cpus().
1115          * cpu_callin_map is set during AP kickstart process. Its reset
1116          * when a cpu is taken offline from cpu_exit_clear().
1117          */
1118         if (!cpu_isset(cpu, cpu_callin_map))
1119                 ret = __smp_prepare_cpu(cpu);
1120
1121         if (ret)
1122                 return -EIO;
1123 #endif
1124
1125         /* In case one didn't come up */
1126         if (!cpu_isset(cpu, cpu_callin_map)) {
1127                 printk(KERN_DEBUG "skipping cpu%d, didn't come online\n", cpu);
1128                 return -EIO;
1129         }
1130
1131         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1132         /* Unleash the CPU! */
1133         cpu_set(cpu, smp_commenced_mask);
1134
1135         /*
1136          * Check TSC synchronization with the AP (keep irqs disabled
1137          * while doing so):
1138          */
1139         local_irq_save(flags);
1140         check_tsc_sync_source(cpu);
1141         local_irq_restore(flags);
1142
1143         while (!cpu_isset(cpu, cpu_online_map)) {
1144                 cpu_relax();
1145                 touch_nmi_watchdog();
1146         }
1147
1148         return 0;
1149 }
1150
1151 void __init native_smp_cpus_done(unsigned int max_cpus)
1152 {
1153 #ifdef CONFIG_X86_IO_APIC
1154         setup_ioapic_dest();
1155 #endif
1156         zap_low_mappings();
1157 }
1158
1159 void __init smp_intr_init(void)
1160 {
1161         /*
1162          * IRQ0 must be given a fixed assignment and initialized,
1163          * because it's used before the IO-APIC is set up.
1164          */
1165         set_intr_gate(FIRST_DEVICE_VECTOR, interrupt[0]);
1166
1167         /*
1168          * The reschedule interrupt is a CPU-to-CPU reschedule-helper
1169          * IPI, driven by wakeup.
1170          */
1171         set_intr_gate(RESCHEDULE_VECTOR, reschedule_interrupt);
1172
1173         /* IPI for invalidation */
1174         set_intr_gate(INVALIDATE_TLB_VECTOR, invalidate_interrupt);
1175
1176         /* IPI for generic function call */
1177         set_intr_gate(CALL_FUNCTION_VECTOR, call_function_interrupt);
1178 }
1179
1180 /*
1181  * If the BIOS enumerates physical processors before logical,
1182  * maxcpus=N at enumeration-time can be used to disable HT.
1183  */
1184 static int __init parse_maxcpus(char *arg)
1185 {
1186         extern unsigned int maxcpus;
1187
1188         maxcpus = simple_strtoul(arg, NULL, 0);
1189         return 0;
1190 }
1191 early_param("maxcpus", parse_maxcpus);