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