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