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