[PATCH] x86_64: Use msleep in smpboot.c
[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/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 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 #ifndef CONFIG_HOTPLUG_CPU
865         /*
866          * Free pages reserved for SMP bootup.
867          * When you add hotplug CPU support later remove this
868          * Note there is more work to be done for later CPU bootup.
869          */
870
871         free_page((unsigned long) __va(PAGE_SIZE));
872         free_page((unsigned long) __va(SMP_TRAMPOLINE_BASE));
873 #endif
874 }
875
876 /*
877  * Fall back to non SMP mode after errors.
878  *
879  * RED-PEN audit/test this more. I bet there is more state messed up here.
880  */
881 static __init void disable_smp(void)
882 {
883         cpu_present_map = cpumask_of_cpu(0);
884         cpu_possible_map = cpumask_of_cpu(0);
885         if (smp_found_config)
886                 phys_cpu_present_map = physid_mask_of_physid(boot_cpu_id);
887         else
888                 phys_cpu_present_map = physid_mask_of_physid(0);
889         cpu_set(0, cpu_sibling_map[0]);
890         cpu_set(0, cpu_core_map[0]);
891 }
892
893 /*
894  * Handle user cpus=... parameter.
895  */
896 static __init void enforce_max_cpus(unsigned max_cpus)
897 {
898         int i, k;
899         k = 0;
900         for (i = 0; i < NR_CPUS; i++) {
901                 if (!cpu_possible(i))
902                         continue;
903                 if (++k > max_cpus) {
904                         cpu_clear(i, cpu_possible_map);
905                         cpu_clear(i, cpu_present_map);
906                 }
907         }
908 }
909
910 #ifdef CONFIG_HOTPLUG_CPU
911 /*
912  * cpu_possible_map should be static, it cannot change as cpu's
913  * are onlined, or offlined. The reason is per-cpu data-structures
914  * are allocated by some modules at init time, and dont expect to
915  * do this dynamically on cpu arrival/departure.
916  * cpu_present_map on the other hand can change dynamically.
917  * In case when cpu_hotplug is not compiled, then we resort to current
918  * behaviour, which is cpu_possible == cpu_present.
919  * If cpu-hotplug is supported, then we need to preallocate for all
920  * those NR_CPUS, hence cpu_possible_map represents entire NR_CPUS range.
921  * - Ashok Raj
922  */
923 static void prefill_possible_map(void)
924 {
925         int i;
926         for (i = 0; i < NR_CPUS; i++)
927                 cpu_set(i, cpu_possible_map);
928 }
929 #endif
930
931 /*
932  * Various sanity checks.
933  */
934 static int __init smp_sanity_check(unsigned max_cpus)
935 {
936         if (!physid_isset(hard_smp_processor_id(), phys_cpu_present_map)) {
937                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
938                        hard_smp_processor_id());
939                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
940         }
941
942         /*
943          * If we couldn't find an SMP configuration at boot time,
944          * get out of here now!
945          */
946         if (!smp_found_config) {
947                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
948                 disable_smp();
949                 if (APIC_init_uniprocessor())
950                         printk(KERN_NOTICE "Local APIC not detected."
951                                            " Using dummy APIC emulation.\n");
952                 return -1;
953         }
954
955         /*
956          * Should not be necessary because the MP table should list the boot
957          * CPU too, but we do it for the sake of robustness anyway.
958          */
959         if (!physid_isset(boot_cpu_id, phys_cpu_present_map)) {
960                 printk(KERN_NOTICE "weird, boot CPU (#%d) not listed by the BIOS.\n",
961                                                                  boot_cpu_id);
962                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
963         }
964
965         /*
966          * If we couldn't find a local APIC, then get out of here now!
967          */
968         if (APIC_INTEGRATED(apic_version[boot_cpu_id]) && !cpu_has_apic) {
969                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
970                         boot_cpu_id);
971                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
972                 nr_ioapics = 0;
973                 return -1;
974         }
975
976         /*
977          * If SMP should be disabled, then really disable it!
978          */
979         if (!max_cpus) {
980                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
981                 nr_ioapics = 0;
982                 return -1;
983         }
984
985         return 0;
986 }
987
988 /*
989  * Prepare for SMP bootup.  The MP table or ACPI has been read
990  * earlier.  Just do some sanity checking here and enable APIC mode.
991  */
992 void __init smp_prepare_cpus(unsigned int max_cpus)
993 {
994         nmi_watchdog_default();
995         current_cpu_data = boot_cpu_data;
996         current_thread_info()->cpu = 0;  /* needed? */
997
998         enforce_max_cpus(max_cpus);
999
1000 #ifdef CONFIG_HOTPLUG_CPU
1001         prefill_possible_map();
1002 #endif
1003
1004         if (smp_sanity_check(max_cpus) < 0) {
1005                 printk(KERN_INFO "SMP disabled\n");
1006                 disable_smp();
1007                 return;
1008         }
1009
1010
1011         /*
1012          * Switch from PIC to APIC mode.
1013          */
1014         connect_bsp_APIC();
1015         setup_local_APIC();
1016
1017         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_id) {
1018                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
1019                       GET_APIC_ID(apic_read(APIC_ID)), boot_cpu_id);
1020                 /* Or can we switch back to PIC here? */
1021         }
1022
1023         /*
1024          * Now start the IO-APICs
1025          */
1026         if (!skip_ioapic_setup && nr_ioapics)
1027                 setup_IO_APIC();
1028         else
1029                 nr_ioapics = 0;
1030
1031         /*
1032          * Set up local APIC timer on boot CPU.
1033          */
1034
1035         setup_boot_APIC_clock();
1036 }
1037
1038 /*
1039  * Early setup to make printk work.
1040  */
1041 void __init smp_prepare_boot_cpu(void)
1042 {
1043         int me = smp_processor_id();
1044         cpu_set(me, cpu_online_map);
1045         cpu_set(me, cpu_callout_map);
1046         cpu_set(0, cpu_sibling_map[0]);
1047         cpu_set(0, cpu_core_map[0]);
1048         per_cpu(cpu_state, me) = CPU_ONLINE;
1049 }
1050
1051 /*
1052  * Entry point to boot a CPU.
1053  */
1054 int __cpuinit __cpu_up(unsigned int cpu)
1055 {
1056         int err;
1057         int apicid = cpu_present_to_apicid(cpu);
1058
1059         WARN_ON(irqs_disabled());
1060
1061         Dprintk("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
1062
1063         if (apicid == BAD_APICID || apicid == boot_cpu_id ||
1064             !physid_isset(apicid, phys_cpu_present_map)) {
1065                 printk("__cpu_up: bad cpu %d\n", cpu);
1066                 return -EINVAL;
1067         }
1068
1069         /*
1070          * Already booted CPU?
1071          */
1072         if (cpu_isset(cpu, cpu_callin_map)) {
1073                 Dprintk("do_boot_cpu %d Already started\n", cpu);
1074                 return -ENOSYS;
1075         }
1076
1077         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1078         /* Boot it! */
1079         err = do_boot_cpu(cpu, apicid);
1080         if (err < 0) {
1081                 Dprintk("do_boot_cpu failed %d\n", err);
1082                 return err;
1083         }
1084
1085         /* Unleash the CPU! */
1086         Dprintk("waiting for cpu %d\n", cpu);
1087
1088         while (!cpu_isset(cpu, cpu_online_map))
1089                 cpu_relax();
1090         err = 0;
1091
1092         return err;
1093 }
1094
1095 /*
1096  * Finish the SMP boot.
1097  */
1098 void __init smp_cpus_done(unsigned int max_cpus)
1099 {
1100 #ifndef CONFIG_HOTPLUG_CPU
1101         zap_low_mappings();
1102 #endif
1103         smp_cleanup_boot();
1104
1105 #ifdef CONFIG_X86_IO_APIC
1106         setup_ioapic_dest();
1107 #endif
1108
1109         time_init_gtod();
1110
1111         check_nmi_watchdog();
1112 }
1113
1114 #ifdef CONFIG_HOTPLUG_CPU
1115
1116 static void remove_siblinginfo(int cpu)
1117 {
1118         int sibling;
1119
1120         for_each_cpu_mask(sibling, cpu_sibling_map[cpu])
1121                 cpu_clear(cpu, cpu_sibling_map[sibling]);
1122         for_each_cpu_mask(sibling, cpu_core_map[cpu])
1123                 cpu_clear(cpu, cpu_core_map[sibling]);
1124         cpus_clear(cpu_sibling_map[cpu]);
1125         cpus_clear(cpu_core_map[cpu]);
1126         phys_proc_id[cpu] = BAD_APICID;
1127         cpu_core_id[cpu] = BAD_APICID;
1128 }
1129
1130 void remove_cpu_from_maps(void)
1131 {
1132         int cpu = smp_processor_id();
1133
1134         cpu_clear(cpu, cpu_callout_map);
1135         cpu_clear(cpu, cpu_callin_map);
1136         clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
1137 }
1138
1139 int __cpu_disable(void)
1140 {
1141         int cpu = smp_processor_id();
1142
1143         /*
1144          * Perhaps use cpufreq to drop frequency, but that could go
1145          * into generic code.
1146          *
1147          * We won't take down the boot processor on i386 due to some
1148          * interrupts only being able to be serviced by the BSP.
1149          * Especially so if we're not using an IOAPIC   -zwane
1150          */
1151         if (cpu == 0)
1152                 return -EBUSY;
1153
1154         disable_APIC_timer();
1155
1156         /*
1157          * HACK:
1158          * Allow any queued timer interrupts to get serviced
1159          * This is only a temporary solution until we cleanup
1160          * fixup_irqs as we do for IA64.
1161          */
1162         local_irq_enable();
1163         mdelay(1);
1164
1165         local_irq_disable();
1166         remove_siblinginfo(cpu);
1167
1168         /* It's now safe to remove this processor from the online map */
1169         cpu_clear(cpu, cpu_online_map);
1170         remove_cpu_from_maps();
1171         fixup_irqs(cpu_online_map);
1172         return 0;
1173 }
1174
1175 void __cpu_die(unsigned int cpu)
1176 {
1177         /* We don't do anything here: idle task is faking death itself. */
1178         unsigned int i;
1179
1180         for (i = 0; i < 10; i++) {
1181                 /* They ack this in play_dead by setting CPU_DEAD */
1182                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1183                         printk ("CPU %d is now offline\n", cpu);
1184                         return;
1185                 }
1186                 msleep(100);
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 */