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