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