arch/x86_64/kernel/smpboot.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  *      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
  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 BogoMIP 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  *      Andi Kleen              :       Changed for SMP boot into long mode.
  33  *              Rusty Russell   :       Hacked into shape for new "hotplug" boot process.
  34  *      Andi Kleen              :       Converted to new state machine.
  35  *                                      Various cleanups.
  36  *                                      Probably mostly hotplug CPU ready now.
  37  *      Ashok Raj                       : CPU hotplug support
  38  */
  39
  40
  41 #include <linux/config.h>
  42 #include <linux/init.h>
  43
  44 #include <linux/mm.h>
  45 #include <linux/kernel_stat.h>
  46 #include <linux/smp_lock.h>
  47 #include <linux/irq.h>
  48 #include <linux/bootmem.h>
  49 #include <linux/thread_info.h>
  50 #include <linux/module.h>
  51
  52 #include <linux/delay.h>
  53 #include <linux/mc146818rtc.h>
  54 #include <asm/mtrr.h>
  55 #include <asm/pgalloc.h>
  56 #include <asm/desc.h>
  57 #include <asm/kdebug.h>
  58 #include <asm/tlbflush.h>
  59 #include <asm/proto.h>
  60 #include <asm/nmi.h>
  61
  62 /* Number of siblings per CPU package */
  63 int smp_num_siblings = 1;
  64 /* Package ID of each logical CPU */
  65 u8 phys_proc_id[NR_CPUS] = { [0 ... NR_CPUS-1] = BAD_APICID };
  66 u8 cpu_core_id[NR_CPUS] = { [0 ... NR_CPUS-1] = BAD_APICID };
  67 EXPORT_SYMBOL(phys_proc_id);
  68 EXPORT_SYMBOL(cpu_core_id);
  69
  70 /* Bitmask of currently online CPUs */
  71 cpumask_t cpu_online_map;
  72
  73 EXPORT_SYMBOL(cpu_online_map);
  74
  75 /*
  76  * Private maps to synchronize booting between AP and BP.
  77  * Probably not needed anymore, but it makes for easier debugging. -AK
  78  */
  79 cpumask_t cpu_callin_map;
  80 cpumask_t cpu_callout_map;
  81
  82 cpumask_t cpu_possible_map;
  83 EXPORT_SYMBOL(cpu_possible_map);
  84
  85 /* Per CPU bogomips and other parameters */
  86 struct cpuinfo_x86 cpu_data[NR_CPUS] __cacheline_aligned;
  87
  88 /* Set when the idlers are all forked */
  89 int smp_threads_ready;
  90
  91 cpumask_t cpu_sibling_map[NR_CPUS] __cacheline_aligned;
  92 cpumask_t cpu_core_map[NR_CPUS] __cacheline_aligned;
  93 EXPORT_SYMBOL(cpu_core_map);
  94
  95 /*
  96  * Trampoline 80x86 program as an array.
  97  */
  98
  99 extern unsigned char trampoline_data[];
 100 extern unsigned char trampoline_end[];
 101
 102 /* State of each CPU */
 103 DEFINE_PER_CPU(int, cpu_state) = { 0 };
 104
 105 /*
 106  * Store all idle threads, this can be reused instead of creating
 107  * a new thread. Also avoids complicated thread destroy functionality
 108  * for idle threads.
 109  */
 110 struct task_struct *idle_thread_array[NR_CPUS] __cpuinitdata ;
 111
 112 #define get_idle_for_cpu(x)     (idle_thread_array[(x)])
 113 #define set_idle_for_cpu(x,p)   (idle_thread_array[(x)] = (p))
 114
 115 /*
 116  * cpu_possible_map should be static, it cannot change as cpu's
 117  * are onlined, or offlined. The reason is per-cpu data-structures
 118  * are allocated by some modules at init time, and dont expect to
 119  * do this dynamically on cpu arrival/departure.
 120  * cpu_present_map on the other hand can change dynamically.
 121  * In case when cpu_hotplug is not compiled, then we resort to current
 122  * behaviour, which is cpu_possible == cpu_present.
 123  * If cpu-hotplug is supported, then we need to preallocate for all
 124  * those NR_CPUS, hence cpu_possible_map represents entire NR_CPUS range.
 125  * - Ashok Raj
 126  */
 127 #ifdef CONFIG_HOTPLUG_CPU
 128 #define fixup_cpu_possible_map(x)       cpu_set((x), cpu_possible_map)
 129 #else
 130 #define fixup_cpu_possible_map(x)
 131 #endif
 132
 133 /*
 134  * Currently trivial. Write the real->protected mode
 135  * bootstrap into the page concerned. The caller
 136  * has made sure it's suitably aligned.
 137  */
 138
 139 static unsigned long __cpuinit setup_trampoline(void)
 140 {
 141         void *tramp = __va(SMP_TRAMPOLINE_BASE);
 142         memcpy(tramp, trampoline_data, trampoline_end - trampoline_data);
 143         return virt_to_phys(tramp);
 144 }
 145
 146 /*
 147  * The bootstrap kernel entry code has set these up. Save them for
 148  * a given CPU
 149  */
 150
 151 static void __cpuinit smp_store_cpu_info(int id)
 152 {
 153         struct cpuinfo_x86 *c = cpu_data + id;
 154
 155         *c = boot_cpu_data;
 156         identify_cpu(c);
 157         print_cpu_info(c);
 158 }
 159
 160 /*
 161  * New Funky TSC sync algorithm borrowed from IA64.
 162  * Main advantage is that it doesn't reset the TSCs fully and
 163  * in general looks more robust and it works better than my earlier
 164  * attempts. I believe it was written by David Mosberger. Some minor
 165  * adjustments for x86-64 by me -AK
 166  *
 167  * Original comment reproduced below.
 168  *
 169  * Synchronize TSC of the current (slave) CPU with the TSC of the
 170  * MASTER CPU (normally the time-keeper CPU).  We use a closed loop to
 171  * eliminate the possibility of unaccounted-for errors (such as
 172  * getting a machine check in the middle of a calibration step).  The
 173  * basic idea is for the slave to ask the master what itc value it has
 174  * and to read its own itc before and after the master responds.  Each
 175  * iteration gives us three timestamps:
 176  *
 177  *      slave           master
 178  *
 179  *      t0 ---\
 180  *             ---\
 181  *                 --->
 182  *                      tm
 183  *                 /---
 184  *             /---
 185  *      t1 <---
 186  *
 187  *
 188  * The goal is to adjust the slave's TSC such that tm falls exactly
 189  * half-way between t0 and t1.  If we achieve this, the clocks are
 190  * synchronized provided the interconnect between the slave and the
 191  * master is symmetric.  Even if the interconnect were asymmetric, we
 192  * would still know that the synchronization error is smaller than the
 193  * roundtrip latency (t0 - t1).
 194  *
 195  * When the interconnect is quiet and symmetric, this lets us
 196  * synchronize the TSC to within one or two cycles.  However, we can
 197  * only *guarantee* that the synchronization is accurate to within a
 198  * round-trip time, which is typically in the range of several hundred
 199  * cycles (e.g., ~500 cycles).  In practice, this means that the TSCs
 200  * are usually almost perfectly synchronized, but we shouldn't assume
 201  * that the accuracy is much better than half a micro second or so.
 202  *
 203  * [there are other errors like the latency of RDTSC and of the
 204  * WRMSR. These can also account to hundreds of cycles. So it's
 205  * probably worse. It claims 153 cycles error on a dual Opteron,
 206  * but I suspect the numbers are actually somewhat worse -AK]
 207  */
 208
 209 #define MASTER  0
 210 #define SLAVE   (SMP_CACHE_BYTES/8)
 211
 212 /* Intentionally don't use cpu_relax() while TSC synchronization
 213    because we don't want to go into funky power save modi or cause
 214    hypervisors to schedule us away.  Going to sleep would likely affect
 215    latency and low latency is the primary objective here. -AK */
 216 #define no_cpu_relax() barrier()
 217
 218 static __cpuinitdata DEFINE_SPINLOCK(tsc_sync_lock);
 219 static volatile __cpuinitdata unsigned long go[SLAVE + 1];
 220 static int notscsync __cpuinitdata;
 221
 222 #undef DEBUG_TSC_SYNC
 223
 224 #define NUM_ROUNDS      64      /* magic value */
 225 #define NUM_ITERS       5       /* likewise */
 226
 227 /* Callback on boot CPU */
 228 static __cpuinit void sync_master(void *arg)
 229 {
 230         unsigned long flags, i;
 231
 232         if (smp_processor_id() != 0)
 233                 return;
 234
 235         go[MASTER] = 0;
 236
 237         local_irq_save(flags);
 238         {
 239                 for (i = 0; i < NUM_ROUNDS*NUM_ITERS; ++i) {
 240                         while (!go[MASTER])
 241                                 no_cpu_relax();
 242                         go[MASTER] = 0;
 243                         rdtscll(go[SLAVE]);
 244                 }
 245         }
 246         local_irq_restore(flags);
 247 }
 248
 249 /*
 250  * Return the number of cycles by which our tsc differs from the tsc
 251  * on the master (time-keeper) CPU.  A positive number indicates our
 252  * tsc is ahead of the master, negative that it is behind.
 253  */
 254 static inline long
 255 get_delta(long *rt, long *master)
 256 {
 257         unsigned long best_t0 = 0, best_t1 = ~0UL, best_tm = 0;
 258         unsigned long tcenter, t0, t1, tm;
 259         int i;
 260
 261         for (i = 0; i < NUM_ITERS; ++i) {
 262                 rdtscll(t0);
 263                 go[MASTER] = 1;
 264                 while (!(tm = go[SLAVE]))
 265                         no_cpu_relax();
 266                 go[SLAVE] = 0;
 267                 rdtscll(t1);
 268
 269                 if (t1 - t0 < best_t1 - best_t0)
 270                         best_t0 = t0, best_t1 = t1, best_tm = tm;
 271         }
 272
 273         *rt = best_t1 - best_t0;
 274         *master = best_tm - best_t0;
 275
 276         /* average best_t0 and best_t1 without overflow: */
 277         tcenter = (best_t0/2 + best_t1/2);
 278         if (best_t0 % 2 + best_t1 % 2 == 2)
 279                 ++tcenter;
 280         return tcenter - best_tm;
 281 }
 282
 283 static __cpuinit void sync_tsc(void)
 284 {
 285         int i, done = 0;
 286         long delta, adj, adjust_latency = 0;
 287         unsigned long flags, rt, master_time_stamp, bound;
 288 #ifdef DEBUG_TSC_SYNC
 289         static struct syncdebug {
 290                 long rt;        /* roundtrip time */
 291                 long master;    /* master's timestamp */
 292                 long diff;      /* difference between midpoint and master's timestamp */
 293                 long lat;       /* estimate of tsc adjustment latency */
 294         } t[NUM_ROUNDS] __cpuinitdata;
 295 #endif
 296
 297         go[MASTER] = 1;
 298
 299         smp_call_function(sync_master, NULL, 1, 0);
 300
 301         while (go[MASTER])      /* wait for master to be ready */
 302                 no_cpu_relax();
 303
 304         spin_lock_irqsave(&tsc_sync_lock, flags);
 305         {
 306                 for (i = 0; i < NUM_ROUNDS; ++i) {
 307                         delta = get_delta(&rt, &master_time_stamp);
 308                         if (delta == 0) {
 309                                 done = 1;       /* let's lock on to this... */
 310                                 bound = rt;
 311                         }
 312
 313                         if (!done) {
 314                                 unsigned long t;
 315                                 if (i > 0) {
 316                                         adjust_latency += -delta;
 317                                         adj = -delta + adjust_latency/4;
 318                                 } else
 319                                         adj = -delta;
 320
 321                                 rdtscll(t);
 322                                 wrmsrl(MSR_IA32_TSC, t + adj);
 323                         }
 324 #ifdef DEBUG_TSC_SYNC
 325                         t[i].rt = rt;
 326                         t[i].master = master_time_stamp;
 327                         t[i].diff = delta;
 328                         t[i].lat = adjust_latency/4;
 329 #endif
 330                 }
 331         }
 332         spin_unlock_irqrestore(&tsc_sync_lock, flags);
 333
 334 #ifdef DEBUG_TSC_SYNC
 335         for (i = 0; i < NUM_ROUNDS; ++i)
 336                 printk("rt=%5ld master=%5ld diff=%5ld adjlat=%5ld\n",
 337                        t[i].rt, t[i].master, t[i].diff, t[i].lat);
 338 #endif
 339
 340         printk(KERN_INFO
 341                "CPU %d: synchronized TSC with CPU %u (last diff %ld cycles, "
 342                "maxerr %lu cycles)\n",
 343                smp_processor_id(), boot_cpu_id, delta, rt);
 344 }
 345
 346 static void __cpuinit tsc_sync_wait(void)
 347 {
 348         if (notscsync || !cpu_has_tsc)
 349                 return;
 350         printk(KERN_INFO "CPU %d: Syncing TSC to CPU %u.\n", smp_processor_id(),
 351                         boot_cpu_id);
 352         sync_tsc();
 353 }
 354
 355 static __init int notscsync_setup(char *s)
 356 {
 357         notscsync = 1;
 358         return 0;
 359 }
 360 __setup("notscsync", notscsync_setup);
 361
 362 static atomic_t init_deasserted __cpuinitdata;
 363
 364 /*
 365  * Report back to the Boot Processor.
 366  * Running on AP.
 367  */
 368 void __cpuinit smp_callin(void)
 369 {
 370         int cpuid, phys_id;
 371         unsigned long timeout;
 372
 373         /*
 374          * If waken up by an INIT in an 82489DX configuration
 375          * we may get here before an INIT-deassert IPI reaches
 376          * our local APIC.  We have to wait for the IPI or we'll
 377          * lock up on an APIC access.
 378          */
 379         while (!atomic_read(&init_deasserted))
 380                 cpu_relax();
 381
 382         /*
 383          * (This works even if the APIC is not enabled.)
 384          */
 385         phys_id = GET_APIC_ID(apic_read(APIC_ID));
 386         cpuid = smp_processor_id();
 387         if (cpu_isset(cpuid, cpu_callin_map)) {
 388                 panic("smp_callin: phys CPU#%d, CPU#%d already present??\n",
 389                                         phys_id, cpuid);
 390         }
 391         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
 392
 393         /*
 394          * STARTUP IPIs are fragile beasts as they might sometimes
 395          * trigger some glue motherboard logic. Complete APIC bus
 396          * silence for 1 second, this overestimates the time the
 397          * boot CPU is spending to send the up to 2 STARTUP IPIs
 398          * by a factor of two. This should be enough.
 399          */
 400
 401         /*
 402          * Waiting 2s total for startup (udelay is not yet working)
 403          */
 404         timeout = jiffies + 2*HZ;
 405         while (time_before(jiffies, timeout)) {
 406                 /*
 407                  * Has the boot CPU finished it's STARTUP sequence?
 408                  */
 409                 if (cpu_isset(cpuid, cpu_callout_map))
 410                         break;
 411                 cpu_relax();
 412         }
 413
 414         if (!time_before(jiffies, timeout)) {
 415                 panic("smp_callin: CPU%d started up but did not get a callout!\n",
 416                         cpuid);
 417         }
 418
 419         /*
 420          * the boot CPU has finished the init stage and is spinning
 421          * on callin_map until we finish. We are free to set up this
 422          * CPU, first the APIC. (this is probably redundant on most
 423          * boards)
 424          */
 425
 426         Dprintk("CALLIN, before setup_local_APIC().\n");
 427         setup_local_APIC();
 428
 429         /*
 430          * Get our bogomips.
 431          */
 432         calibrate_delay();
 433         Dprintk("Stack at about %p\n",&cpuid);
 434
 435         disable_APIC_timer();
 436
 437         /*
 438          * Save our processor parameters
 439          */
 440         smp_store_cpu_info(cpuid);
 441
 442         /*
 443          * Allow the master to continue.
 444          */
 445         cpu_set(cpuid, cpu_callin_map);
 446 }
 447
 448 static inline void set_cpu_sibling_map(int cpu)
 449 {
 450         int i;
 451
 452         if (smp_num_siblings > 1) {
 453                 for_each_cpu(i) {
 454                         if (cpu_core_id[cpu] == cpu_core_id[i]) {
 455                                 cpu_set(i, cpu_sibling_map[cpu]);
 456                                 cpu_set(cpu, cpu_sibling_map[i]);
 457                         }
 458                 }
 459         } else {
 460                 cpu_set(cpu, cpu_sibling_map[cpu]);
 461         }
 462
 463         if (current_cpu_data.x86_num_cores > 1) {
 464                 for_each_cpu(i) {
 465                         if (phys_proc_id[cpu] == phys_proc_id[i]) {
 466                                 cpu_set(i, cpu_core_map[cpu]);
 467                                 cpu_set(cpu, cpu_core_map[i]);
 468                         }
 469                 }
 470         } else {
 471                 cpu_core_map[cpu] = cpu_sibling_map[cpu];
 472         }
 473 }
 474
 475 /*
 476  * Setup code on secondary processor (after comming out of the trampoline)
 477  */
 478 void __cpuinit start_secondary(void)
 479 {
 480         /*
 481          * Dont put anything before smp_callin(), SMP
 482          * booting is too fragile that we want to limit the
 483          * things done here to the most necessary things.
 484          */
 485         cpu_init();
 486         smp_callin();
 487
 488         /* otherwise gcc will move up the smp_processor_id before the cpu_init */
 489         barrier();
 490
 491         Dprintk("cpu %d: setting up apic clock\n", smp_processor_id());
 492         setup_secondary_APIC_clock();
 493
 494         Dprintk("cpu %d: enabling apic timer\n", smp_processor_id());
 495
 496         if (nmi_watchdog == NMI_IO_APIC) {
 497                 disable_8259A_irq(0);
 498                 enable_NMI_through_LVT0(NULL);
 499                 enable_8259A_irq(0);
 500         }
 501
 502         enable_APIC_timer();
 503
 504         /*
 505          * The sibling maps must be set before turing the online map on for
 506          * this cpu
 507          */
 508         set_cpu_sibling_map(smp_processor_id());
 509
 510         /*
 511          * We need to hold call_lock, so there is no inconsistency
 512          * between the time smp_call_function() determines number of
 513          * IPI receipients, and the time when the determination is made
 514          * for which cpus receive the IPI in genapic_flat.c. Holding this
 515          * lock helps us to not include this cpu in a currently in progress
 516          * smp_call_function().
 517          */
 518         lock_ipi_call_lock();
 519
 520         /*
 521          * Allow the master to continue.
 522          */
 523         cpu_set(smp_processor_id(), cpu_online_map);
 524         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
 525         unlock_ipi_call_lock();
 526
 527         mb();
 528
 529         /* Wait for TSC sync to not schedule things before.
 530            We still process interrupts, which could see an inconsistent
 531            time in that window unfortunately. */
 532         tsc_sync_wait();
 533
 534         cpu_idle();
 535 }
 536
 537 extern volatile unsigned long init_rsp;
 538 extern void (*initial_code)(void);
 539
 540 #ifdef APIC_DEBUG
 541 static void inquire_remote_apic(int apicid)
 542 {
 543         unsigned i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
 544         char *names[] = { "ID", "VERSION", "SPIV" };
 545         int timeout, status;
 546
 547         printk(KERN_INFO "Inquiring remote APIC #%d...\n", apicid);
 548
 549         for (i = 0; i < sizeof(regs) / sizeof(*regs); i++) {
 550                 printk("... APIC #%d %s: ", apicid, names[i]);
 551
 552                 /*
 553                  * Wait for idle.
 554                  */
 555                 apic_wait_icr_idle();
 556
 557                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
 558                 apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);
 559
 560                 timeout = 0;
 561                 do {
 562                         udelay(100);
 563                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
 564                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
 565
 566                 switch (status) {
 567                 case APIC_ICR_RR_VALID:
 568                         status = apic_read(APIC_RRR);
 569                         printk("%08x\n", status);
 570                         break;
 571                 default:
 572                         printk("failed\n");
 573                 }
 574         }
 575 }
 576 #endif
 577
 578 /*
 579  * Kick the secondary to wake up.
 580  */
 581 static int __cpuinit wakeup_secondary_via_INIT(int phys_apicid, unsigned int start_rip)
 582 {
 583         unsigned long send_status = 0, accept_status = 0;
 584         int maxlvt, timeout, num_starts, j;
 585
 586         Dprintk("Asserting INIT.\n");
 587
 588         /*
 589          * Turn INIT on target chip
 590          */
 591         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 592
 593         /*
 594          * Send IPI
 595          */
 596         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
 597                                 | APIC_DM_INIT);
 598
 599         Dprintk("Waiting for send to finish...\n");
 600         timeout = 0;
 601         do {
 602                 Dprintk("+");
 603                 udelay(100);
 604                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 605         } while (send_status && (timeout++ < 1000));
 606
 607         mdelay(10);
 608
 609         Dprintk("Deasserting INIT.\n");
 610
 611         /* Target chip */
 612         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 613
 614         /* Send IPI */
 615         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
 616
 617         Dprintk("Waiting for send to finish...\n");
 618         timeout = 0;
 619         do {
 620                 Dprintk("+");
 621                 udelay(100);
 622                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 623         } while (send_status && (timeout++ < 1000));
 624
 625         atomic_set(&init_deasserted, 1);
 626
 627         /*
 628          * Should we send STARTUP IPIs ?
 629          *
 630          * Determine this based on the APIC version.
 631          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
 632          */
 633         if (APIC_INTEGRATED(apic_version[phys_apicid]))
 634                 num_starts = 2;
 635         else
 636                 num_starts = 0;
 637
 638         /*
 639          * Run STARTUP IPI loop.
 640          */
 641         Dprintk("#startup loops: %d.\n", num_starts);
 642
 643         maxlvt = get_maxlvt();
 644
 645         for (j = 1; j <= num_starts; j++) {
 646                 Dprintk("Sending STARTUP #%d.\n",j);
 647                 apic_read_around(APIC_SPIV);
 648                 apic_write(APIC_ESR, 0);
 649                 apic_read(APIC_ESR);
 650                 Dprintk("After apic_write.\n");
 651
 652                 /*
 653                  * STARTUP IPI
 654                  */
 655
 656                 /* Target chip */
 657                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
 658
 659                 /* Boot on the stack */
 660                 /* Kick the second */
 661                 apic_write_around(APIC_ICR, APIC_DM_STARTUP
 662                                         | (start_rip >> 12));
 663
 664                 /*
 665                  * Give the other CPU some time to accept the IPI.
 666                  */
 667                 udelay(300);
 668
 669                 Dprintk("Startup point 1.\n");
 670
 671                 Dprintk("Waiting for send to finish...\n");
 672                 timeout = 0;
 673                 do {
 674                         Dprintk("+");
 675                         udelay(100);
 676                         send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
 677                 } while (send_status && (timeout++ < 1000));
 678
 679                 /*
 680                  * Give the other CPU some time to accept the IPI.
 681                  */
 682                 udelay(200);
 683                 /*
 684                  * Due to the Pentium erratum 3AP.
 685                  */
 686                 if (maxlvt > 3) {
 687                         apic_read_around(APIC_SPIV);
 688                         apic_write(APIC_ESR, 0);
 689                 }
 690                 accept_status = (apic_read(APIC_ESR) & 0xEF);
 691                 if (send_status || accept_status)
 692                         break;
 693         }
 694         Dprintk("After Startup.\n");
 695
 696         if (send_status)
 697                 printk(KERN_ERR "APIC never delivered???\n");
 698         if (accept_status)
 699                 printk(KERN_ERR "APIC delivery error (%lx).\n", accept_status);
 700
 701         return (send_status | accept_status);
 702 }
 703
 704 struct create_idle {
 705         struct task_struct *idle;
 706         struct completion done;
 707         int cpu;
 708 };
 709
 710 void do_fork_idle(void *_c_idle)
 711 {
 712         struct create_idle *c_idle = _c_idle;
 713
 714         c_idle->idle = fork_idle(c_idle->cpu);
 715         complete(&c_idle->done);
 716 }
 717
 718 /*
 719  * Boot one CPU.
 720  */
 721 static int __cpuinit do_boot_cpu(int cpu, int apicid)
 722 {
 723         unsigned long boot_error;
 724         int timeout;
 725         unsigned long start_rip;
 726         struct create_idle c_idle = {
 727                 .cpu = cpu,
 728                 .done = COMPLETION_INITIALIZER(c_idle.done),
 729         };
 730         DECLARE_WORK(work, do_fork_idle, &c_idle);
 731
 732         c_idle.idle = get_idle_for_cpu(cpu);
 733
 734         if (c_idle.idle) {
 735                 c_idle.idle->thread.rsp = (unsigned long) (((struct pt_regs *)
 736                         (THREAD_SIZE + (unsigned long) c_idle.idle->thread_info)) - 1);
 737                 init_idle(c_idle.idle, cpu);
 738                 goto do_rest;
 739         }
 740
 741         /*
 742          * During cold boot process, keventd thread is not spun up yet.
 743          * When we do cpu hot-add, we create idle threads on the fly, we should
 744          * not acquire any attributes from the calling context. Hence the clean
 745          * way to create kernel_threads() is to do that from keventd().
 746          * We do the current_is_keventd() due to the fact that ACPI notifier
 747          * was also queuing to keventd() and when the caller is already running
 748          * in context of keventd(), we would end up with locking up the keventd
 749          * thread.
 750          */
 751         if (!keventd_up() || current_is_keventd())
 752                 work.func(work.data);
 753         else {
 754                 schedule_work(&work);
 755                 wait_for_completion(&c_idle.done);
 756         }
 757
 758         if (IS_ERR(c_idle.idle)) {
 759                 printk("failed fork for CPU %d\n", cpu);
 760                 return PTR_ERR(c_idle.idle);
 761         }
 762
 763         set_idle_for_cpu(cpu, c_idle.idle);
 764
 765 do_rest:
 766
 767         cpu_pda[cpu].pcurrent = c_idle.idle;
 768
 769         start_rip = setup_trampoline();
 770
 771         init_rsp = c_idle.idle->thread.rsp;
 772         per_cpu(init_tss,cpu).rsp0 = init_rsp;
 773         initial_code = start_secondary;
 774         clear_ti_thread_flag(c_idle.idle->thread_info, TIF_FORK);
 775
 776         printk(KERN_INFO "Booting processor %d/%d rip %lx rsp %lx\n", cpu, apicid,
 777                start_rip, init_rsp);
 778
 779         /*
 780          * This grunge runs the startup process for
 781          * the targeted processor.
 782          */
 783
 784         atomic_set(&init_deasserted, 0);
 785
 786         Dprintk("Setting warm reset code and vector.\n");
 787
 788         CMOS_WRITE(0xa, 0xf);
 789         local_flush_tlb();
 790         Dprintk("1.\n");
 791         *((volatile unsigned short *) phys_to_virt(0x469)) = start_rip >> 4;
 792         Dprintk("2.\n");
 793         *((volatile unsigned short *) phys_to_virt(0x467)) = start_rip & 0xf;
 794         Dprintk("3.\n");
 795
 796         /*
 797          * Be paranoid about clearing APIC errors.
 798          */
 799         if (APIC_INTEGRATED(apic_version[apicid])) {
 800                 apic_read_around(APIC_SPIV);
 801                 apic_write(APIC_ESR, 0);
 802                 apic_read(APIC_ESR);
 803         }
 804
 805         /*
 806          * Status is now clean
 807          */
 808         boot_error = 0;
 809
 810         /*
 811          * Starting actual IPI sequence...
 812          */
 813         boot_error = wakeup_secondary_via_INIT(apicid, start_rip);
 814
 815         if (!boot_error) {
 816                 /*
 817                  * allow APs to start initializing.
 818                  */
 819                 Dprintk("Before Callout %d.\n", cpu);
 820                 cpu_set(cpu, cpu_callout_map);
 821                 Dprintk("After Callout %d.\n", cpu);
 822
 823                 /*
 824                  * Wait 5s total for a response
 825                  */
 826                 for (timeout = 0; timeout < 50000; timeout++) {
 827                         if (cpu_isset(cpu, cpu_callin_map))
 828                                 break;  /* It has booted */
 829                         udelay(100);
 830                 }
 831
 832                 if (cpu_isset(cpu, cpu_callin_map)) {
 833                         /* number CPUs logically, starting from 1 (BSP is 0) */
 834                         Dprintk("CPU has booted.\n");
 835                 } else {
 836                         boot_error = 1;
 837                         if (*((volatile unsigned char *)phys_to_virt(SMP_TRAMPOLINE_BASE))
 838                                         == 0xA5)
 839                                 /* trampoline started but...? */
 840                                 printk("Stuck ??\n");
 841                         else
 842                                 /* trampoline code not run */
 843                                 printk("Not responding.\n");
 844 #ifdef APIC_DEBUG
 845                         inquire_remote_apic(apicid);
 846 #endif
 847                 }
 848         }
 849         if (boot_error) {
 850                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
 851                 clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
 852                 cpu_clear(cpu, cpu_present_map);
 853                 cpu_clear(cpu, cpu_possible_map);
 854                 x86_cpu_to_apicid[cpu] = BAD_APICID;
 855                 x86_cpu_to_log_apicid[cpu] = BAD_APICID;
 856                 return -EIO;
 857         }
 858
 859         return 0;
 860 }
 861
 862 cycles_t cacheflush_time;
 863 unsigned long cache_decay_ticks;
 864
 865 /*
 866  * Cleanup possible dangling ends...
 867  */
 868 static __cpuinit void smp_cleanup_boot(void)
 869 {
 870         /*
 871          * Paranoid:  Set warm reset code and vector here back
 872          * to default values.
 873          */
 874         CMOS_WRITE(0, 0xf);
 875
 876         /*
 877          * Reset trampoline flag
 878          */
 879         *((volatile int *) phys_to_virt(0x467)) = 0;
 880
 881 #ifndef CONFIG_HOTPLUG_CPU
 882         /*
 883          * Free pages reserved for SMP bootup.
 884          * When you add hotplug CPU support later remove this
 885          * Note there is more work to be done for later CPU bootup.
 886          */
 887
 888         free_page((unsigned long) __va(PAGE_SIZE));
 889         free_page((unsigned long) __va(SMP_TRAMPOLINE_BASE));
 890 #endif
 891 }
 892
 893 /*
 894  * Fall back to non SMP mode after errors.
 895  *
 896  * RED-PEN audit/test this more. I bet there is more state messed up here.
 897  */
 898 static __init void disable_smp(void)
 899 {
 900         cpu_present_map = cpumask_of_cpu(0);
 901         cpu_possible_map = cpumask_of_cpu(0);
 902         if (smp_found_config)
 903                 phys_cpu_present_map = physid_mask_of_physid(boot_cpu_id);
 904         else
 905                 phys_cpu_present_map = physid_mask_of_physid(0);
 906         cpu_set(0, cpu_sibling_map[0]);
 907         cpu_set(0, cpu_core_map[0]);
 908 }
 909
 910 /*
 911  * Handle user cpus=... parameter.
 912  */
 913 static __init void enforce_max_cpus(unsigned max_cpus)
 914 {
 915         int i, k;
 916         k = 0;
 917         for (i = 0; i < NR_CPUS; i++) {
 918                 if (!cpu_possible(i))
 919                         continue;
 920                 if (++k > max_cpus) {
 921                         cpu_clear(i, cpu_possible_map);
 922                         cpu_clear(i, cpu_present_map);
 923                 }
 924         }
 925 }
 926
 927 /*
 928  * Various sanity checks.
 929  */
 930 static int __init smp_sanity_check(unsigned max_cpus)
 931 {
 932         if (!physid_isset(hard_smp_processor_id(), phys_cpu_present_map)) {
 933                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
 934                        hard_smp_processor_id());
 935                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
 936         }
 937
 938         /*
 939          * If we couldn't find an SMP configuration at boot time,
 940          * get out of here now!
 941          */
 942         if (!smp_found_config) {
 943                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
 944                 disable_smp();
 945                 if (APIC_init_uniprocessor())
 946                         printk(KERN_NOTICE "Local APIC not detected."
 947                                            " Using dummy APIC emulation.\n");
 948                 return -1;
 949         }
 950
 951         /*
 952          * Should not be necessary because the MP table should list the boot
 953          * CPU too, but we do it for the sake of robustness anyway.
 954          */
 955         if (!physid_isset(boot_cpu_id, phys_cpu_present_map)) {
 956                 printk(KERN_NOTICE "weird, boot CPU (#%d) not listed by the BIOS.\n",
 957                                                                  boot_cpu_id);
 958                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
 959         }
 960
 961         /*
 962          * If we couldn't find a local APIC, then get out of here now!
 963          */
 964         if (APIC_INTEGRATED(apic_version[boot_cpu_id]) && !cpu_has_apic) {
 965                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
 966                         boot_cpu_id);
 967                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
 968                 nr_ioapics = 0;
 969                 return -1;
 970         }
 971
 972         /*
 973          * If SMP should be disabled, then really disable it!
 974          */
 975         if (!max_cpus) {
 976                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
 977                 nr_ioapics = 0;
 978                 return -1;
 979         }
 980
 981         return 0;
 982 }
 983
 984 /*
 985  * Prepare for SMP bootup.  The MP table or ACPI has been read
 986  * earlier.  Just do some sanity checking here and enable APIC mode.
 987  */
 988 void __init smp_prepare_cpus(unsigned int max_cpus)
 989 {
 990         int i;
 991
 992         nmi_watchdog_default();
 993         current_cpu_data = boot_cpu_data;
 994         current_thread_info()->cpu = 0;  /* needed? */
 995
 996         enforce_max_cpus(max_cpus);
 997
 998         /*
 999          * Fill in cpu_present_mask
1000          */
1001         for (i = 0; i < NR_CPUS; i++) {
1002                 int apicid = cpu_present_to_apicid(i);
1003                 if (physid_isset(apicid, phys_cpu_present_map)) {
1004                         cpu_set(i, cpu_present_map);
1005                         cpu_set(i, cpu_possible_map);
1006                 }
1007                 fixup_cpu_possible_map(i);
1008         }
1009
1010         if (smp_sanity_check(max_cpus) < 0) {
1011                 printk(KERN_INFO "SMP disabled\n");
1012                 disable_smp();
1013                 return;
1014         }
1015
1016
1017         /*
1018          * Switch from PIC to APIC mode.
1019          */
1020         connect_bsp_APIC();
1021         setup_local_APIC();
1022
1023         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_id) {
1024                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
1025                       GET_APIC_ID(apic_read(APIC_ID)), boot_cpu_id);
1026                 /* Or can we switch back to PIC here? */
1027         }
1028
1029         /*
1030          * Now start the IO-APICs
1031          */
1032         if (!skip_ioapic_setup && nr_ioapics)
1033                 setup_IO_APIC();
1034         else
1035                 nr_ioapics = 0;
1036
1037         /*
1038          * Set up local APIC timer on boot CPU.
1039          */
1040
1041         setup_boot_APIC_clock();
1042 }
1043
1044 /*
1045  * Early setup to make printk work.
1046  */
1047 void __init smp_prepare_boot_cpu(void)
1048 {
1049         int me = smp_processor_id();
1050         cpu_set(me, cpu_online_map);
1051         cpu_set(me, cpu_callout_map);
1052         cpu_set(0, cpu_sibling_map[0]);
1053         cpu_set(0, cpu_core_map[0]);
1054         per_cpu(cpu_state, me) = CPU_ONLINE;
1055 }
1056
1057 /*
1058  * Entry point to boot a CPU.
1059  */
1060 int __cpuinit __cpu_up(unsigned int cpu)
1061 {
1062         int err;
1063         int apicid = cpu_present_to_apicid(cpu);
1064
1065         WARN_ON(irqs_disabled());
1066
1067         Dprintk("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
1068
1069         if (apicid == BAD_APICID || apicid == boot_cpu_id ||
1070             !physid_isset(apicid, phys_cpu_present_map)) {
1071                 printk("__cpu_up: bad cpu %d\n", cpu);
1072                 return -EINVAL;
1073         }
1074
1075         /*
1076          * Already booted CPU?
1077          */
1078         if (cpu_isset(cpu, cpu_callin_map)) {
1079                 Dprintk("do_boot_cpu %d Already started\n", cpu);
1080                 return -ENOSYS;
1081         }
1082
1083         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1084         /* Boot it! */
1085         err = do_boot_cpu(cpu, apicid);
1086         if (err < 0) {
1087                 Dprintk("do_boot_cpu failed %d\n", err);
1088                 return err;
1089         }
1090
1091         /* Unleash the CPU! */
1092         Dprintk("waiting for cpu %d\n", cpu);
1093
1094         while (!cpu_isset(cpu, cpu_online_map))
1095                 cpu_relax();
1096         err = 0;
1097
1098         return err;
1099 }
1100
1101 /*
1102  * Finish the SMP boot.
1103  */
1104 void __init smp_cpus_done(unsigned int max_cpus)
1105 {
1106 #ifndef CONFIG_HOTPLUG_CPU
1107         zap_low_mappings();
1108 #endif
1109         smp_cleanup_boot();
1110
1111 #ifdef CONFIG_X86_IO_APIC
1112         setup_ioapic_dest();
1113 #endif
1114
1115         time_init_gtod();
1116
1117         check_nmi_watchdog();
1118 }
1119
1120 #ifdef CONFIG_HOTPLUG_CPU
1121
1122 static void remove_siblinginfo(int cpu)
1123 {
1124         int sibling;
1125
1126         for_each_cpu_mask(sibling, cpu_sibling_map[cpu])
1127                 cpu_clear(cpu, cpu_sibling_map[sibling]);
1128         for_each_cpu_mask(sibling, cpu_core_map[cpu])
1129                 cpu_clear(cpu, cpu_core_map[sibling]);
1130         cpus_clear(cpu_sibling_map[cpu]);
1131         cpus_clear(cpu_core_map[cpu]);
1132         phys_proc_id[cpu] = BAD_APICID;
1133         cpu_core_id[cpu] = BAD_APICID;
1134 }
1135
1136 void remove_cpu_from_maps(void)
1137 {
1138         int cpu = smp_processor_id();
1139
1140         cpu_clear(cpu, cpu_callout_map);
1141         cpu_clear(cpu, cpu_callin_map);
1142         clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
1143 }
1144
1145 int __cpu_disable(void)
1146 {
1147         int cpu = smp_processor_id();
1148
1149         /*
1150          * Perhaps use cpufreq to drop frequency, but that could go
1151          * into generic code.
1152          *
1153          * We won't take down the boot processor on i386 due to some
1154          * interrupts only being able to be serviced by the BSP.
1155          * Especially so if we're not using an IOAPIC   -zwane
1156          */
1157         if (cpu == 0)
1158                 return -EBUSY;
1159
1160         disable_APIC_timer();
1161
1162         /*
1163          * HACK:
1164          * Allow any queued timer interrupts to get serviced
1165          * This is only a temporary solution until we cleanup
1166          * fixup_irqs as we do for IA64.
1167          */
1168         local_irq_enable();
1169         mdelay(1);
1170
1171         local_irq_disable();
1172         remove_siblinginfo(cpu);
1173
1174         /* It's now safe to remove this processor from the online map */
1175         cpu_clear(cpu, cpu_online_map);
1176         remove_cpu_from_maps();
1177         fixup_irqs(cpu_online_map);
1178         return 0;
1179 }
1180
1181 void __cpu_die(unsigned int cpu)
1182 {
1183         /* We don't do anything here: idle task is faking death itself. */
1184         unsigned int i;
1185
1186         for (i = 0; i < 10; i++) {
1187                 /* They ack this in play_dead by setting CPU_DEAD */
1188                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1189                         printk ("CPU %d is now offline\n", cpu);
1190                         return;
1191                 }
1192                 current->state = TASK_UNINTERRUPTIBLE;
1193                 schedule_timeout(HZ/10);
1194         }
1195         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
1196 }
1197
1198 #else /* ... !CONFIG_HOTPLUG_CPU */
1199
1200 int __cpu_disable(void)
1201 {
1202         return -ENOSYS;
1203 }
1204
1205 void __cpu_die(unsigned int cpu)
1206 {
1207         /* We said "no" in __cpu_disable */
1208         BUG();
1209 }
1210 #endif /* CONFIG_HOTPLUG_CPU */