[PATCH] x86_64: Don't call enforce_max_cpus when hotplug is enabled
[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] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
66 u8 cpu_core_id[NR_CPUS] __read_mostly = { [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 __read_mostly;
72
73 EXPORT_SYMBOL(cpu_online_map);
74
75 /*
76  * Private maps to synchronize booting between AP and BP.
77  * Probably not needed anymore, but it makes for easier debugging. -AK
78  */
79 cpumask_t cpu_callin_map;
80 cpumask_t cpu_callout_map;
81
82 cpumask_t cpu_possible_map;
83 EXPORT_SYMBOL(cpu_possible_map);
84
85 /* Per CPU bogomips and other parameters */
86 struct cpuinfo_x86 cpu_data[NR_CPUS] __cacheline_aligned;
87
88 /* Set when the idlers are all forked */
89 int smp_threads_ready;
90
91 cpumask_t cpu_sibling_map[NR_CPUS] __read_mostly;
92 cpumask_t cpu_core_map[NR_CPUS] __read_mostly;
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         go[MASTER] = 0;
215
216         local_irq_save(flags);
217         {
218                 for (i = 0; i < NUM_ROUNDS*NUM_ITERS; ++i) {
219                         while (!go[MASTER])
220                                 no_cpu_relax();
221                         go[MASTER] = 0;
222                         rdtscll(go[SLAVE]);
223                 }
224         }
225         local_irq_restore(flags);
226 }
227
228 /*
229  * Return the number of cycles by which our tsc differs from the tsc
230  * on the master (time-keeper) CPU.  A positive number indicates our
231  * tsc is ahead of the master, negative that it is behind.
232  */
233 static inline long
234 get_delta(long *rt, long *master)
235 {
236         unsigned long best_t0 = 0, best_t1 = ~0UL, best_tm = 0;
237         unsigned long tcenter, t0, t1, tm;
238         int i;
239
240         for (i = 0; i < NUM_ITERS; ++i) {
241                 rdtscll(t0);
242                 go[MASTER] = 1;
243                 while (!(tm = go[SLAVE]))
244                         no_cpu_relax();
245                 go[SLAVE] = 0;
246                 rdtscll(t1);
247
248                 if (t1 - t0 < best_t1 - best_t0)
249                         best_t0 = t0, best_t1 = t1, best_tm = tm;
250         }
251
252         *rt = best_t1 - best_t0;
253         *master = best_tm - best_t0;
254
255         /* average best_t0 and best_t1 without overflow: */
256         tcenter = (best_t0/2 + best_t1/2);
257         if (best_t0 % 2 + best_t1 % 2 == 2)
258                 ++tcenter;
259         return tcenter - best_tm;
260 }
261
262 static __cpuinit void sync_tsc(unsigned int master)
263 {
264         int i, done = 0;
265         long delta, adj, adjust_latency = 0;
266         unsigned long flags, rt, master_time_stamp, bound;
267 #ifdef DEBUG_TSC_SYNC
268         static struct syncdebug {
269                 long rt;        /* roundtrip time */
270                 long master;    /* master's timestamp */
271                 long diff;      /* difference between midpoint and master's timestamp */
272                 long lat;       /* estimate of tsc adjustment latency */
273         } t[NUM_ROUNDS] __cpuinitdata;
274 #endif
275
276         printk(KERN_INFO "CPU %d: Syncing TSC to CPU %u.\n",
277                 smp_processor_id(), master);
278
279         go[MASTER] = 1;
280
281         /* It is dangerous to broadcast IPI as cpus are coming up,
282          * as they may not be ready to accept them.  So since
283          * we only need to send the ipi to the boot cpu direct
284          * the message, and avoid the race.
285          */
286         smp_call_function_single(master, sync_master, NULL, 1, 0);
287
288         while (go[MASTER])      /* wait for master to be ready */
289                 no_cpu_relax();
290
291         spin_lock_irqsave(&tsc_sync_lock, flags);
292         {
293                 for (i = 0; i < NUM_ROUNDS; ++i) {
294                         delta = get_delta(&rt, &master_time_stamp);
295                         if (delta == 0) {
296                                 done = 1;       /* let's lock on to this... */
297                                 bound = rt;
298                         }
299
300                         if (!done) {
301                                 unsigned long t;
302                                 if (i > 0) {
303                                         adjust_latency += -delta;
304                                         adj = -delta + adjust_latency/4;
305                                 } else
306                                         adj = -delta;
307
308                                 rdtscll(t);
309                                 wrmsrl(MSR_IA32_TSC, t + adj);
310                         }
311 #ifdef DEBUG_TSC_SYNC
312                         t[i].rt = rt;
313                         t[i].master = master_time_stamp;
314                         t[i].diff = delta;
315                         t[i].lat = adjust_latency/4;
316 #endif
317                 }
318         }
319         spin_unlock_irqrestore(&tsc_sync_lock, flags);
320
321 #ifdef DEBUG_TSC_SYNC
322         for (i = 0; i < NUM_ROUNDS; ++i)
323                 printk("rt=%5ld master=%5ld diff=%5ld adjlat=%5ld\n",
324                        t[i].rt, t[i].master, t[i].diff, t[i].lat);
325 #endif
326
327         printk(KERN_INFO
328                "CPU %d: synchronized TSC with CPU %u (last diff %ld cycles, "
329                "maxerr %lu cycles)\n",
330                smp_processor_id(), master, delta, rt);
331 }
332
333 static void __cpuinit tsc_sync_wait(void)
334 {
335         if (notscsync || !cpu_has_tsc)
336                 return;
337         sync_tsc(0);
338 }
339
340 static __init int notscsync_setup(char *s)
341 {
342         notscsync = 1;
343         return 0;
344 }
345 __setup("notscsync", notscsync_setup);
346
347 static atomic_t init_deasserted __cpuinitdata;
348
349 /*
350  * Report back to the Boot Processor.
351  * Running on AP.
352  */
353 void __cpuinit smp_callin(void)
354 {
355         int cpuid, phys_id;
356         unsigned long timeout;
357
358         /*
359          * If waken up by an INIT in an 82489DX configuration
360          * we may get here before an INIT-deassert IPI reaches
361          * our local APIC.  We have to wait for the IPI or we'll
362          * lock up on an APIC access.
363          */
364         while (!atomic_read(&init_deasserted))
365                 cpu_relax();
366
367         /*
368          * (This works even if the APIC is not enabled.)
369          */
370         phys_id = GET_APIC_ID(apic_read(APIC_ID));
371         cpuid = smp_processor_id();
372         if (cpu_isset(cpuid, cpu_callin_map)) {
373                 panic("smp_callin: phys CPU#%d, CPU#%d already present??\n",
374                                         phys_id, cpuid);
375         }
376         Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);
377
378         /*
379          * STARTUP IPIs are fragile beasts as they might sometimes
380          * trigger some glue motherboard logic. Complete APIC bus
381          * silence for 1 second, this overestimates the time the
382          * boot CPU is spending to send the up to 2 STARTUP IPIs
383          * by a factor of two. This should be enough.
384          */
385
386         /*
387          * Waiting 2s total for startup (udelay is not yet working)
388          */
389         timeout = jiffies + 2*HZ;
390         while (time_before(jiffies, timeout)) {
391                 /*
392                  * Has the boot CPU finished it's STARTUP sequence?
393                  */
394                 if (cpu_isset(cpuid, cpu_callout_map))
395                         break;
396                 cpu_relax();
397         }
398
399         if (!time_before(jiffies, timeout)) {
400                 panic("smp_callin: CPU%d started up but did not get a callout!\n",
401                         cpuid);
402         }
403
404         /*
405          * the boot CPU has finished the init stage and is spinning
406          * on callin_map until we finish. We are free to set up this
407          * CPU, first the APIC. (this is probably redundant on most
408          * boards)
409          */
410
411         Dprintk("CALLIN, before setup_local_APIC().\n");
412         setup_local_APIC();
413
414         /*
415          * Get our bogomips.
416          */
417         calibrate_delay();
418         Dprintk("Stack at about %p\n",&cpuid);
419
420         disable_APIC_timer();
421
422         /*
423          * Save our processor parameters
424          */
425         smp_store_cpu_info(cpuid);
426
427         /*
428          * Allow the master to continue.
429          */
430         cpu_set(cpuid, cpu_callin_map);
431 }
432
433 static inline void set_cpu_sibling_map(int cpu)
434 {
435         int i;
436
437         if (smp_num_siblings > 1) {
438                 for_each_cpu(i) {
439                         if (cpu_core_id[cpu] == cpu_core_id[i]) {
440                                 cpu_set(i, cpu_sibling_map[cpu]);
441                                 cpu_set(cpu, cpu_sibling_map[i]);
442                         }
443                 }
444         } else {
445                 cpu_set(cpu, cpu_sibling_map[cpu]);
446         }
447
448         if (current_cpu_data.x86_num_cores > 1) {
449                 for_each_cpu(i) {
450                         if (phys_proc_id[cpu] == phys_proc_id[i]) {
451                                 cpu_set(i, cpu_core_map[cpu]);
452                                 cpu_set(cpu, cpu_core_map[i]);
453                         }
454                 }
455         } else {
456                 cpu_core_map[cpu] = cpu_sibling_map[cpu];
457         }
458 }
459
460 /*
461  * Setup code on secondary processor (after comming out of the trampoline)
462  */
463 void __cpuinit start_secondary(void)
464 {
465         /*
466          * Dont put anything before smp_callin(), SMP
467          * booting is too fragile that we want to limit the
468          * things done here to the most necessary things.
469          */
470         cpu_init();
471         smp_callin();
472
473         /* otherwise gcc will move up the smp_processor_id before the cpu_init */
474         barrier();
475
476         Dprintk("cpu %d: setting up apic clock\n", smp_processor_id());         
477         setup_secondary_APIC_clock();
478
479         Dprintk("cpu %d: enabling apic timer\n", smp_processor_id());
480
481         if (nmi_watchdog == NMI_IO_APIC) {
482                 disable_8259A_irq(0);
483                 enable_NMI_through_LVT0(NULL);
484                 enable_8259A_irq(0);
485         }
486
487         enable_APIC_timer();
488
489         /*
490          * The sibling maps must be set before turing the online map on for
491          * this cpu
492          */
493         set_cpu_sibling_map(smp_processor_id());
494
495         /* 
496          * Wait for TSC sync to not schedule things before.
497          * We still process interrupts, which could see an inconsistent
498          * time in that window unfortunately. 
499          * Do this here because TSC sync has global unprotected state.
500          */
501         tsc_sync_wait();
502
503         /*
504          * We need to hold call_lock, so there is no inconsistency
505          * between the time smp_call_function() determines number of
506          * IPI receipients, and the time when the determination is made
507          * for which cpus receive the IPI in genapic_flat.c. Holding this
508          * lock helps us to not include this cpu in a currently in progress
509          * smp_call_function().
510          */
511         lock_ipi_call_lock();
512
513         /*
514          * Allow the master to continue.
515          */
516         cpu_set(smp_processor_id(), cpu_online_map);
517         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
518         unlock_ipi_call_lock();
519
520         cpu_idle();
521 }
522
523 extern volatile unsigned long init_rsp;
524 extern void (*initial_code)(void);
525
526 #ifdef APIC_DEBUG
527 static void inquire_remote_apic(int apicid)
528 {
529         unsigned i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
530         char *names[] = { "ID", "VERSION", "SPIV" };
531         int timeout, status;
532
533         printk(KERN_INFO "Inquiring remote APIC #%d...\n", apicid);
534
535         for (i = 0; i < sizeof(regs) / sizeof(*regs); i++) {
536                 printk("... APIC #%d %s: ", apicid, names[i]);
537
538                 /*
539                  * Wait for idle.
540                  */
541                 apic_wait_icr_idle();
542
543                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
544                 apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);
545
546                 timeout = 0;
547                 do {
548                         udelay(100);
549                         status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
550                 } while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);
551
552                 switch (status) {
553                 case APIC_ICR_RR_VALID:
554                         status = apic_read(APIC_RRR);
555                         printk("%08x\n", status);
556                         break;
557                 default:
558                         printk("failed\n");
559                 }
560         }
561 }
562 #endif
563
564 /*
565  * Kick the secondary to wake up.
566  */
567 static int __cpuinit wakeup_secondary_via_INIT(int phys_apicid, unsigned int start_rip)
568 {
569         unsigned long send_status = 0, accept_status = 0;
570         int maxlvt, timeout, num_starts, j;
571
572         Dprintk("Asserting INIT.\n");
573
574         /*
575          * Turn INIT on target chip
576          */
577         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
578
579         /*
580          * Send IPI
581          */
582         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
583                                 | APIC_DM_INIT);
584
585         Dprintk("Waiting for send to finish...\n");
586         timeout = 0;
587         do {
588                 Dprintk("+");
589                 udelay(100);
590                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
591         } while (send_status && (timeout++ < 1000));
592
593         mdelay(10);
594
595         Dprintk("Deasserting INIT.\n");
596
597         /* Target chip */
598         apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
599
600         /* Send IPI */
601         apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);
602
603         Dprintk("Waiting for send to finish...\n");
604         timeout = 0;
605         do {
606                 Dprintk("+");
607                 udelay(100);
608                 send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
609         } while (send_status && (timeout++ < 1000));
610
611         atomic_set(&init_deasserted, 1);
612
613         /*
614          * Should we send STARTUP IPIs ?
615          *
616          * Determine this based on the APIC version.
617          * If we don't have an integrated APIC, don't send the STARTUP IPIs.
618          */
619         if (APIC_INTEGRATED(apic_version[phys_apicid]))
620                 num_starts = 2;
621         else
622                 num_starts = 0;
623
624         /*
625          * Run STARTUP IPI loop.
626          */
627         Dprintk("#startup loops: %d.\n", num_starts);
628
629         maxlvt = get_maxlvt();
630
631         for (j = 1; j <= num_starts; j++) {
632                 Dprintk("Sending STARTUP #%d.\n",j);
633                 apic_read_around(APIC_SPIV);
634                 apic_write(APIC_ESR, 0);
635                 apic_read(APIC_ESR);
636                 Dprintk("After apic_write.\n");
637
638                 /*
639                  * STARTUP IPI
640                  */
641
642                 /* Target chip */
643                 apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));
644
645                 /* Boot on the stack */
646                 /* Kick the second */
647                 apic_write_around(APIC_ICR, APIC_DM_STARTUP
648                                         | (start_rip >> 12));
649
650                 /*
651                  * Give the other CPU some time to accept the IPI.
652                  */
653                 udelay(300);
654
655                 Dprintk("Startup point 1.\n");
656
657                 Dprintk("Waiting for send to finish...\n");
658                 timeout = 0;
659                 do {
660                         Dprintk("+");
661                         udelay(100);
662                         send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
663                 } while (send_status && (timeout++ < 1000));
664
665                 /*
666                  * Give the other CPU some time to accept the IPI.
667                  */
668                 udelay(200);
669                 /*
670                  * Due to the Pentium erratum 3AP.
671                  */
672                 if (maxlvt > 3) {
673                         apic_read_around(APIC_SPIV);
674                         apic_write(APIC_ESR, 0);
675                 }
676                 accept_status = (apic_read(APIC_ESR) & 0xEF);
677                 if (send_status || accept_status)
678                         break;
679         }
680         Dprintk("After Startup.\n");
681
682         if (send_status)
683                 printk(KERN_ERR "APIC never delivered???\n");
684         if (accept_status)
685                 printk(KERN_ERR "APIC delivery error (%lx).\n", accept_status);
686
687         return (send_status | accept_status);
688 }
689
690 struct create_idle {
691         struct task_struct *idle;
692         struct completion done;
693         int cpu;
694 };
695
696 void do_fork_idle(void *_c_idle)
697 {
698         struct create_idle *c_idle = _c_idle;
699
700         c_idle->idle = fork_idle(c_idle->cpu);
701         complete(&c_idle->done);
702 }
703
704 /*
705  * Boot one CPU.
706  */
707 static int __cpuinit do_boot_cpu(int cpu, int apicid)
708 {
709         unsigned long boot_error;
710         int timeout;
711         unsigned long start_rip;
712         struct create_idle c_idle = {
713                 .cpu = cpu,
714                 .done = COMPLETION_INITIALIZER(c_idle.done),
715         };
716         DECLARE_WORK(work, do_fork_idle, &c_idle);
717
718         c_idle.idle = get_idle_for_cpu(cpu);
719
720         if (c_idle.idle) {
721                 c_idle.idle->thread.rsp = (unsigned long) (((struct pt_regs *)
722                         (THREAD_SIZE + (unsigned long) c_idle.idle->thread_info)) - 1);
723                 init_idle(c_idle.idle, cpu);
724                 goto do_rest;
725         }
726
727         /*
728          * During cold boot process, keventd thread is not spun up yet.
729          * When we do cpu hot-add, we create idle threads on the fly, we should
730          * not acquire any attributes from the calling context. Hence the clean
731          * way to create kernel_threads() is to do that from keventd().
732          * We do the current_is_keventd() due to the fact that ACPI notifier
733          * was also queuing to keventd() and when the caller is already running
734          * in context of keventd(), we would end up with locking up the keventd
735          * thread.
736          */
737         if (!keventd_up() || current_is_keventd())
738                 work.func(work.data);
739         else {
740                 schedule_work(&work);
741                 wait_for_completion(&c_idle.done);
742         }
743
744         if (IS_ERR(c_idle.idle)) {
745                 printk("failed fork for CPU %d\n", cpu);
746                 return PTR_ERR(c_idle.idle);
747         }
748
749         set_idle_for_cpu(cpu, c_idle.idle);
750
751 do_rest:
752
753         cpu_pda[cpu].pcurrent = c_idle.idle;
754
755         start_rip = setup_trampoline();
756
757         init_rsp = c_idle.idle->thread.rsp;
758         per_cpu(init_tss,cpu).rsp0 = init_rsp;
759         initial_code = start_secondary;
760         clear_ti_thread_flag(c_idle.idle->thread_info, TIF_FORK);
761
762         printk(KERN_INFO "Booting processor %d/%d APIC 0x%x\n", cpu,
763                 cpus_weight(cpu_present_map),
764                 apicid);
765
766         /*
767          * This grunge runs the startup process for
768          * the targeted processor.
769          */
770
771         atomic_set(&init_deasserted, 0);
772
773         Dprintk("Setting warm reset code and vector.\n");
774
775         CMOS_WRITE(0xa, 0xf);
776         local_flush_tlb();
777         Dprintk("1.\n");
778         *((volatile unsigned short *) phys_to_virt(0x469)) = start_rip >> 4;
779         Dprintk("2.\n");
780         *((volatile unsigned short *) phys_to_virt(0x467)) = start_rip & 0xf;
781         Dprintk("3.\n");
782
783         /*
784          * Be paranoid about clearing APIC errors.
785          */
786         if (APIC_INTEGRATED(apic_version[apicid])) {
787                 apic_read_around(APIC_SPIV);
788                 apic_write(APIC_ESR, 0);
789                 apic_read(APIC_ESR);
790         }
791
792         /*
793          * Status is now clean
794          */
795         boot_error = 0;
796
797         /*
798          * Starting actual IPI sequence...
799          */
800         boot_error = wakeup_secondary_via_INIT(apicid, start_rip);
801
802         if (!boot_error) {
803                 /*
804                  * allow APs to start initializing.
805                  */
806                 Dprintk("Before Callout %d.\n", cpu);
807                 cpu_set(cpu, cpu_callout_map);
808                 Dprintk("After Callout %d.\n", cpu);
809
810                 /*
811                  * Wait 5s total for a response
812                  */
813                 for (timeout = 0; timeout < 50000; timeout++) {
814                         if (cpu_isset(cpu, cpu_callin_map))
815                                 break;  /* It has booted */
816                         udelay(100);
817                 }
818
819                 if (cpu_isset(cpu, cpu_callin_map)) {
820                         /* number CPUs logically, starting from 1 (BSP is 0) */
821                         Dprintk("CPU has booted.\n");
822                 } else {
823                         boot_error = 1;
824                         if (*((volatile unsigned char *)phys_to_virt(SMP_TRAMPOLINE_BASE))
825                                         == 0xA5)
826                                 /* trampoline started but...? */
827                                 printk("Stuck ??\n");
828                         else
829                                 /* trampoline code not run */
830                                 printk("Not responding.\n");
831 #ifdef APIC_DEBUG
832                         inquire_remote_apic(apicid);
833 #endif
834                 }
835         }
836         if (boot_error) {
837                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
838                 clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
839                 cpu_clear(cpu, cpu_present_map);
840                 cpu_clear(cpu, cpu_possible_map);
841                 x86_cpu_to_apicid[cpu] = BAD_APICID;
842                 x86_cpu_to_log_apicid[cpu] = BAD_APICID;
843                 return -EIO;
844         }
845
846         return 0;
847 }
848
849 cycles_t cacheflush_time;
850 unsigned long cache_decay_ticks;
851
852 /*
853  * Cleanup possible dangling ends...
854  */
855 static __cpuinit void smp_cleanup_boot(void)
856 {
857         /*
858          * Paranoid:  Set warm reset code and vector here back
859          * to default values.
860          */
861         CMOS_WRITE(0, 0xf);
862
863         /*
864          * Reset trampoline flag
865          */
866         *((volatile int *) phys_to_virt(0x467)) = 0;
867
868 #ifndef CONFIG_HOTPLUG_CPU
869         /*
870          * Free pages reserved for SMP bootup.
871          * When you add hotplug CPU support later remove this
872          * Note there is more work to be done for later CPU bootup.
873          */
874
875         free_page((unsigned long) __va(PAGE_SIZE));
876         free_page((unsigned long) __va(SMP_TRAMPOLINE_BASE));
877 #endif
878 }
879
880 /*
881  * Fall back to non SMP mode after errors.
882  *
883  * RED-PEN audit/test this more. I bet there is more state messed up here.
884  */
885 static __init void disable_smp(void)
886 {
887         cpu_present_map = cpumask_of_cpu(0);
888         cpu_possible_map = cpumask_of_cpu(0);
889         if (smp_found_config)
890                 phys_cpu_present_map = physid_mask_of_physid(boot_cpu_id);
891         else
892                 phys_cpu_present_map = physid_mask_of_physid(0);
893         cpu_set(0, cpu_sibling_map[0]);
894         cpu_set(0, cpu_core_map[0]);
895 }
896
897 #ifdef CONFIG_HOTPLUG_CPU
898 /*
899  * cpu_possible_map should be static, it cannot change as cpu's
900  * are onlined, or offlined. The reason is per-cpu data-structures
901  * are allocated by some modules at init time, and dont expect to
902  * do this dynamically on cpu arrival/departure.
903  * cpu_present_map on the other hand can change dynamically.
904  * In case when cpu_hotplug is not compiled, then we resort to current
905  * behaviour, which is cpu_possible == cpu_present.
906  * If cpu-hotplug is supported, then we need to preallocate for all
907  * those NR_CPUS, hence cpu_possible_map represents entire NR_CPUS range.
908  * - Ashok Raj
909  */
910 static void prefill_possible_map(void)
911 {
912         int i;
913         for (i = 0; i < NR_CPUS; i++)
914                 cpu_set(i, cpu_possible_map);
915 }
916 #endif
917
918 /*
919  * Various sanity checks.
920  */
921 static int __init smp_sanity_check(unsigned max_cpus)
922 {
923         if (!physid_isset(hard_smp_processor_id(), phys_cpu_present_map)) {
924                 printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
925                        hard_smp_processor_id());
926                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
927         }
928
929         /*
930          * If we couldn't find an SMP configuration at boot time,
931          * get out of here now!
932          */
933         if (!smp_found_config) {
934                 printk(KERN_NOTICE "SMP motherboard not detected.\n");
935                 disable_smp();
936                 if (APIC_init_uniprocessor())
937                         printk(KERN_NOTICE "Local APIC not detected."
938                                            " Using dummy APIC emulation.\n");
939                 return -1;
940         }
941
942         /*
943          * Should not be necessary because the MP table should list the boot
944          * CPU too, but we do it for the sake of robustness anyway.
945          */
946         if (!physid_isset(boot_cpu_id, phys_cpu_present_map)) {
947                 printk(KERN_NOTICE "weird, boot CPU (#%d) not listed by the BIOS.\n",
948                                                                  boot_cpu_id);
949                 physid_set(hard_smp_processor_id(), phys_cpu_present_map);
950         }
951
952         /*
953          * If we couldn't find a local APIC, then get out of here now!
954          */
955         if (APIC_INTEGRATED(apic_version[boot_cpu_id]) && !cpu_has_apic) {
956                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
957                         boot_cpu_id);
958                 printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
959                 nr_ioapics = 0;
960                 return -1;
961         }
962
963         /*
964          * If SMP should be disabled, then really disable it!
965          */
966         if (!max_cpus) {
967                 printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
968                 nr_ioapics = 0;
969                 return -1;
970         }
971
972         return 0;
973 }
974
975 /*
976  * Prepare for SMP bootup.  The MP table or ACPI has been read
977  * earlier.  Just do some sanity checking here and enable APIC mode.
978  */
979 void __init smp_prepare_cpus(unsigned int max_cpus)
980 {
981         nmi_watchdog_default();
982         current_cpu_data = boot_cpu_data;
983         current_thread_info()->cpu = 0;  /* needed? */
984
985 #ifdef CONFIG_HOTPLUG_CPU
986         prefill_possible_map();
987 #endif
988
989         if (smp_sanity_check(max_cpus) < 0) {
990                 printk(KERN_INFO "SMP disabled\n");
991                 disable_smp();
992                 return;
993         }
994
995
996         /*
997          * Switch from PIC to APIC mode.
998          */
999         connect_bsp_APIC();
1000         setup_local_APIC();
1001
1002         if (GET_APIC_ID(apic_read(APIC_ID)) != boot_cpu_id) {
1003                 panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
1004                       GET_APIC_ID(apic_read(APIC_ID)), boot_cpu_id);
1005                 /* Or can we switch back to PIC here? */
1006         }
1007
1008         /*
1009          * Now start the IO-APICs
1010          */
1011         if (!skip_ioapic_setup && nr_ioapics)
1012                 setup_IO_APIC();
1013         else
1014                 nr_ioapics = 0;
1015
1016         /*
1017          * Set up local APIC timer on boot CPU.
1018          */
1019
1020         setup_boot_APIC_clock();
1021 }
1022
1023 /*
1024  * Early setup to make printk work.
1025  */
1026 void __init smp_prepare_boot_cpu(void)
1027 {
1028         int me = smp_processor_id();
1029         cpu_set(me, cpu_online_map);
1030         cpu_set(me, cpu_callout_map);
1031         cpu_set(0, cpu_sibling_map[0]);
1032         cpu_set(0, cpu_core_map[0]);
1033         per_cpu(cpu_state, me) = CPU_ONLINE;
1034 }
1035
1036 /*
1037  * Entry point to boot a CPU.
1038  */
1039 int __cpuinit __cpu_up(unsigned int cpu)
1040 {
1041         int err;
1042         int apicid = cpu_present_to_apicid(cpu);
1043
1044         WARN_ON(irqs_disabled());
1045
1046         Dprintk("++++++++++++++++++++=_---CPU UP  %u\n", cpu);
1047
1048         if (apicid == BAD_APICID || apicid == boot_cpu_id ||
1049             !physid_isset(apicid, phys_cpu_present_map)) {
1050                 printk("__cpu_up: bad cpu %d\n", cpu);
1051                 return -EINVAL;
1052         }
1053
1054         /*
1055          * Already booted CPU?
1056          */
1057         if (cpu_isset(cpu, cpu_callin_map)) {
1058                 Dprintk("do_boot_cpu %d Already started\n", cpu);
1059                 return -ENOSYS;
1060         }
1061
1062         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
1063         /* Boot it! */
1064         err = do_boot_cpu(cpu, apicid);
1065         if (err < 0) {
1066                 Dprintk("do_boot_cpu failed %d\n", err);
1067                 return err;
1068         }
1069
1070         /* Unleash the CPU! */
1071         Dprintk("waiting for cpu %d\n", cpu);
1072
1073         while (!cpu_isset(cpu, cpu_online_map))
1074                 cpu_relax();
1075         err = 0;
1076
1077         return err;
1078 }
1079
1080 /*
1081  * Finish the SMP boot.
1082  */
1083 void __init smp_cpus_done(unsigned int max_cpus)
1084 {
1085 #ifndef CONFIG_HOTPLUG_CPU
1086         zap_low_mappings();
1087 #endif
1088         smp_cleanup_boot();
1089
1090 #ifdef CONFIG_X86_IO_APIC
1091         setup_ioapic_dest();
1092 #endif
1093
1094         time_init_gtod();
1095
1096         check_nmi_watchdog();
1097 }
1098
1099 #ifdef CONFIG_HOTPLUG_CPU
1100
1101 static void remove_siblinginfo(int cpu)
1102 {
1103         int sibling;
1104
1105         for_each_cpu_mask(sibling, cpu_sibling_map[cpu])
1106                 cpu_clear(cpu, cpu_sibling_map[sibling]);
1107         for_each_cpu_mask(sibling, cpu_core_map[cpu])
1108                 cpu_clear(cpu, cpu_core_map[sibling]);
1109         cpus_clear(cpu_sibling_map[cpu]);
1110         cpus_clear(cpu_core_map[cpu]);
1111         phys_proc_id[cpu] = BAD_APICID;
1112         cpu_core_id[cpu] = BAD_APICID;
1113 }
1114
1115 void remove_cpu_from_maps(void)
1116 {
1117         int cpu = smp_processor_id();
1118
1119         cpu_clear(cpu, cpu_callout_map);
1120         cpu_clear(cpu, cpu_callin_map);
1121         clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
1122 }
1123
1124 int __cpu_disable(void)
1125 {
1126         int cpu = smp_processor_id();
1127
1128         /*
1129          * Perhaps use cpufreq to drop frequency, but that could go
1130          * into generic code.
1131          *
1132          * We won't take down the boot processor on i386 due to some
1133          * interrupts only being able to be serviced by the BSP.
1134          * Especially so if we're not using an IOAPIC   -zwane
1135          */
1136         if (cpu == 0)
1137                 return -EBUSY;
1138
1139         disable_APIC_timer();
1140
1141         /*
1142          * HACK:
1143          * Allow any queued timer interrupts to get serviced
1144          * This is only a temporary solution until we cleanup
1145          * fixup_irqs as we do for IA64.
1146          */
1147         local_irq_enable();
1148         mdelay(1);
1149
1150         local_irq_disable();
1151         remove_siblinginfo(cpu);
1152
1153         /* It's now safe to remove this processor from the online map */
1154         cpu_clear(cpu, cpu_online_map);
1155         remove_cpu_from_maps();
1156         fixup_irqs(cpu_online_map);
1157         return 0;
1158 }
1159
1160 void __cpu_die(unsigned int cpu)
1161 {
1162         /* We don't do anything here: idle task is faking death itself. */
1163         unsigned int i;
1164
1165         for (i = 0; i < 10; i++) {
1166                 /* They ack this in play_dead by setting CPU_DEAD */
1167                 if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
1168                         printk ("CPU %d is now offline\n", cpu);
1169                         return;
1170                 }
1171                 msleep(100);
1172         }
1173         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
1174 }
1175
1176 #else /* ... !CONFIG_HOTPLUG_CPU */
1177
1178 int __cpu_disable(void)
1179 {
1180         return -ENOSYS;
1181 }
1182
1183 void __cpu_die(unsigned int cpu)
1184 {
1185         /* We said "no" in __cpu_disable */
1186         BUG();
1187 }
1188 #endif /* CONFIG_HOTPLUG_CPU */