[PATCH] only verify the allocation bitmap if CONFIG_IOMMU_DEBUG is on
[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         setup_local_APIC();
1094
1095         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_id) {
1096                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
1097                       GET_APIC_ID(apic_read(APIC_ID)), boot_cpu_id);
1098                 /* Or can we switch back to PIC here? */
1099         }
1100
1101         /*
1102          * Now start the IO-APICs
1103          */
1104         if (!skip_ioapic_setup && nr_ioapics)
1105                 setup_IO_APIC();
1106         else
1107                 nr_ioapics = 0;
1108
1109         /*
1110          * Set up local APIC timer on boot CPU.
1111          */
1112
1113         setup_boot_APIC_clock();
1114 }
1115
1116 /*
1117  * Early setup to make printk work.
1118  */
1119 void __init smp_prepare_boot_cpu(void)
1120 {
1121         int me = smp_processor_id();
1122         cpu_set(me, cpu_online_map);
1123         cpu_set(me, cpu_callout_map);
1124         per_cpu(cpu_state, me) = CPU_ONLINE;
1125 }
1126
1127 /*
1128  * Entry point to boot a CPU.
1129  */
1130 int __cpuinit __cpu_up(unsigned int cpu)
1131 {
1132         int err;
1133         int apicid = cpu_present_to_apicid(cpu);
1134
1135         WARN_ON(irqs_disabled());
1136
1137         Dprintk("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
1138
1139         if (apicid == BAD_APICID || apicid == boot_cpu_id ||
1140             !physid_isset(apicid, phys_cpu_present_map)) {
1141                 printk("__cpu_up: bad cpu %d\n", cpu);
1142                 return -EINVAL;
1143         }
1144
1145         /*
1146          * Already booted CPU?
1147          */
1148         if (cpu_isset(cpu, cpu_callin_map)) {
1149                 Dprintk("do_boot_cpu %d Already started\n", cpu);
1150                 return -ENOSYS;
1151         }
1152
1153         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1154         /* Boot it! */
1155         err = do_boot_cpu(cpu, apicid);
1156         if (err < 0) {
1157                 Dprintk("do_boot_cpu failed %d\n", err);
1158                 return err;
1159         }
1160
1161         /* Unleash the CPU! */
1162         Dprintk("waiting for cpu %d\n", cpu);
1163
1164         while (!cpu_isset(cpu, cpu_online_map))
1165                 cpu_relax();
1166         err = 0;
1167
1168         return err;
1169 }
1170
1171 /*
1172  * Finish the SMP boot.
1173  */
1174 void __init smp_cpus_done(unsigned int max_cpus)
1175 {
1176         smp_cleanup_boot();
1177         setup_ioapic_dest();
1178         check_nmi_watchdog();
1179         time_init_gtod();
1180 }
1181
1182 #ifdef CONFIG_HOTPLUG_CPU
1183
1184 static void remove_siblinginfo(int cpu)
1185 {
1186         int sibling;
1187         struct cpuinfo_x86 *c = cpu_data;
1188
1189         for_each_cpu_mask(sibling, cpu_core_map[cpu]) {
1190                 cpu_clear(cpu, cpu_core_map[sibling]);
1191                 /*
1192                  * last thread sibling in this cpu core going down
1193                  */
1194                 if (cpus_weight(cpu_sibling_map[cpu]) == 1)
1195                         c[sibling].booted_cores--;
1196         }
1197                         
1198         for_each_cpu_mask(sibling, cpu_sibling_map[cpu])
1199                 cpu_clear(cpu, cpu_sibling_map[sibling]);
1200         cpus_clear(cpu_sibling_map[cpu]);
1201         cpus_clear(cpu_core_map[cpu]);
1202         c[cpu].phys_proc_id = 0;
1203         c[cpu].cpu_core_id = 0;
1204         cpu_clear(cpu, cpu_sibling_setup_map);
1205 }
1206
1207 void remove_cpu_from_maps(void)
1208 {
1209         int cpu = smp_processor_id();
1210
1211         cpu_clear(cpu, cpu_callout_map);
1212         cpu_clear(cpu, cpu_callin_map);
1213         clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
1214         clear_node_cpumask(cpu);
1215 }
1216
1217 int __cpu_disable(void)
1218 {
1219         int cpu = smp_processor_id();
1220
1221         /*
1222          * Perhaps use cpufreq to drop frequency, but that could go
1223          * into generic code.
1224          *
1225          * We won't take down the boot processor on i386 due to some
1226          * interrupts only being able to be serviced by the BSP.
1227          * Especially so if we're not using an IOAPIC   -zwane
1228          */
1229         if (cpu == 0)
1230                 return -EBUSY;
1231
1232         if (nmi_watchdog == NMI_LOCAL_APIC)
1233                 stop_apic_nmi_watchdog(NULL);
1234         clear_local_APIC();
1235
1236         /*
1237          * HACK:
1238          * Allow any queued timer interrupts to get serviced
1239          * This is only a temporary solution until we cleanup
1240          * fixup_irqs as we do for IA64.
1241          */
1242         local_irq_enable();
1243         mdelay(1);
1244
1245         local_irq_disable();
1246         remove_siblinginfo(cpu);
1247
1248         /* It's now safe to remove this processor from the online map */
1249         cpu_clear(cpu, cpu_online_map);
1250         remove_cpu_from_maps();
1251         fixup_irqs(cpu_online_map);
1252         return 0;
1253 }
1254
1255 void __cpu_die(unsigned int cpu)
1256 {
1257         /* We don't do anything here: idle task is faking death itself. */
1258         unsigned int i;
1259
1260         for (i = 0; i < 10; i++) {
1261                 /* They ack this in play_dead by setting CPU_DEAD */
1262                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1263                         printk ("CPU %d is now offline\n", cpu);
1264                         if (1 == num_online_cpus())
1265                                 alternatives_smp_switch(0);
1266                         return;
1267                 }
1268                 msleep(100);
1269         }
1270         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
1271 }
1272
1273 static __init int setup_additional_cpus(char *s)
1274 {
1275         return s && get_option(&s, &additional_cpus) ? 0 : -EINVAL;
1276 }
1277 early_param("additional_cpus", setup_additional_cpus);
1278
1279 #else /* ... !CONFIG_HOTPLUG_CPU */
1280
1281 int __cpu_disable(void)
1282 {
1283         return -ENOSYS;
1284 }
1285
1286 void __cpu_die(unsigned int cpu)
1287 {
1288         /* We said "no" in __cpu_disable */
1289         BUG();
1290 }
1291 #endif /* CONFIG_HOTPLUG_CPU */