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