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