smpboot.c 36.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
 *	x86 SMP booting functions
 *
 *	(c) 1995 Alan Cox, Building #3 <alan@redhat.com>
 *	(c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
 *
 *	Much of the core SMP work is based on previous work by Thomas Radke, to
 *	whom a great many thanks are extended.
 *
 *	Thanks to Intel for making available several different Pentium,
 *	Pentium Pro and Pentium-II/Xeon MP machines.
 *	Original development of Linux SMP code supported by Caldera.
 *
 *	This code is released under the GNU General Public License version 2 or
 *	later.
 *
 *	Fixes
 *		Felix Koop	:	NR_CPUS used properly
 *		Jose Renau	:	Handle single CPU case.
 *		Alan Cox	:	By repeated request 8) - Total BogoMIPS report.
 *		Greg Wright	:	Fix for kernel stacks panic.
 *		Erich Boleyn	:	MP v1.4 and additional changes.
 *	Matthias Sattler	:	Changes for 2.1 kernel map.
 *	Michel Lespinasse	:	Changes for 2.1 kernel map.
 *	Michael Chastain	:	Change trampoline.S to gnu as.
 *		Alan Cox	:	Dumb bug: 'B' step PPro's are fine
 *		Ingo Molnar	:	Added APIC timers, based on code
 *					from Jose Renau
 *		Ingo Molnar	:	various cleanups and rewrites
 *		Tigran Aivazian	:	fixed "0.00 in /proc/uptime on SMP" bug.
 *	Maciej W. Rozycki	:	Bits for genuine 82489DX APICs
 *		Martin J. Bligh	: 	Added support for multi-quad systems
 *		Dave Jones	:	Report invalid combinations of Athlon CPUs.
*		Rusty Russell	:	Hacked into shape for new "hotplug" boot process. */

36
37
38
39
40

/* SMP boot always wants to use real time delay to allow sufficient time for
 * the APs to come online */
#define USE_REAL_TIME_DELAY

Linus Torvalds's avatar
Linus Torvalds committed
41
42
43
44
45
46
47
48
49
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>

#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/kernel_stat.h>
#include <linux/smp_lock.h>
#include <linux/bootmem.h>
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
50
51
52
#include <linux/notifier.h>
#include <linux/cpu.h>
#include <linux/percpu.h>
Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
57
58

#include <linux/delay.h>
#include <linux/mc146818rtc.h>
#include <asm/tlbflush.h>
#include <asm/desc.h>
#include <asm/arch_hooks.h>
59
#include <asm/nmi.h>
60
#include <asm/pda.h>
61
#include <asm/genapic.h>
Linus Torvalds's avatar
Linus Torvalds committed
62
63
64
65
66
67

#include <mach_apic.h>
#include <mach_wakecpu.h>
#include <smpboot_hooks.h>

/* Set if we find a B stepping CPU */
Li Shaohua's avatar
Li Shaohua committed
68
static int __devinitdata smp_b_stepping;
Linus Torvalds's avatar
Linus Torvalds committed
69
70
71

/* Number of siblings per CPU package */
int smp_num_siblings = 1;
72
#ifdef CONFIG_SMP
73
74
EXPORT_SYMBOL(smp_num_siblings);
#endif
75

76
77
78
/* Last level cache ID of each logical CPU */
int cpu_llc_id[NR_CPUS] __cpuinitdata = {[0 ... NR_CPUS-1] = BAD_APICID};

79
/* representing HT siblings of each logical CPU */
80
cpumask_t cpu_sibling_map[NR_CPUS] __read_mostly;
81
82
EXPORT_SYMBOL(cpu_sibling_map);

83
/* representing HT and core siblings of each logical CPU */
84
cpumask_t cpu_core_map[NR_CPUS] __read_mostly;
85
86
EXPORT_SYMBOL(cpu_core_map);

Linus Torvalds's avatar
Linus Torvalds committed
87
/* bitmap of online cpus */
88
cpumask_t cpu_online_map __read_mostly;
89
EXPORT_SYMBOL(cpu_online_map);
Linus Torvalds's avatar
Linus Torvalds committed
90
91
92

cpumask_t cpu_callin_map;
cpumask_t cpu_callout_map;
93
EXPORT_SYMBOL(cpu_callout_map);
94
95
cpumask_t cpu_possible_map;
EXPORT_SYMBOL(cpu_possible_map);
Linus Torvalds's avatar
Linus Torvalds committed
96
97
static cpumask_t smp_commenced_mask;

98
99
100
101
102
103
/* TSC's upper 32 bits can't be written in eariler CPU (before prescott), there
 * is no way to resync one AP against BP. TBD: for prescott and above, we
 * should use IA64's algorithm
 */
static int __devinitdata tsc_sync_disabled;

Linus Torvalds's avatar
Linus Torvalds committed
104
105
/* Per CPU bogomips and other parameters */
struct cpuinfo_x86 cpu_data[NR_CPUS] __cacheline_aligned;
106
EXPORT_SYMBOL(cpu_data);
Linus Torvalds's avatar
Linus Torvalds committed
107

108
u8 x86_cpu_to_apicid[NR_CPUS] __read_mostly =
Linus Torvalds's avatar
Linus Torvalds committed
109
110
111
			{ [0 ... NR_CPUS-1] = 0xff };
EXPORT_SYMBOL(x86_cpu_to_apicid);

112
113
u8 apicid_2_node[MAX_APICID];

Linus Torvalds's avatar
Linus Torvalds committed
114
115
116
117
118
119
120
121
122
123
124
/*
 * Trampoline 80x86 program as an array.
 */

extern unsigned char trampoline_data [];
extern unsigned char trampoline_end  [];
static unsigned char *trampoline_base;
static int trampoline_exec;

static void map_cpu_to_logical_apicid(void);

Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
125
126
127
/* State of each CPU. */
DEFINE_PER_CPU(int, cpu_state) = { 0 };

Linus Torvalds's avatar
Linus Torvalds committed
128
129
130
131
132
133
/*
 * Currently trivial. Write the real->protected mode
 * bootstrap into the page concerned. The caller
 * has made sure it's suitably aligned.
 */

Li Shaohua's avatar
Li Shaohua committed
134
static unsigned long __devinit setup_trampoline(void)
Linus Torvalds's avatar
Linus Torvalds committed
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
{
	memcpy(trampoline_base, trampoline_data, trampoline_end - trampoline_data);
	return virt_to_phys(trampoline_base);
}

/*
 * We are called very early to get the low memory for the
 * SMP bootup trampoline page.
 */
void __init smp_alloc_memory(void)
{
	trampoline_base = (void *) alloc_bootmem_low_pages(PAGE_SIZE);
	/*
	 * Has to be in very low memory so we can execute
	 * real-mode AP code.
	 */
	if (__pa(trampoline_base) >= 0x9F000)
		BUG();
	/*
	 * Make the SMP trampoline executable:
	 */
	trampoline_exec = set_kernel_exec((unsigned long)trampoline_base, 1);
}

/*
 * The bootstrap kernel entry code has set these up. Save them for
 * a given CPU
 */

Li Shaohua's avatar
Li Shaohua committed
164
static void __devinit smp_store_cpu_info(int id)
Linus Torvalds's avatar
Linus Torvalds committed
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
{
	struct cpuinfo_x86 *c = cpu_data + id;

	*c = boot_cpu_data;
	if (id!=0)
		identify_cpu(c);
	/*
	 * Mask B, Pentium, but not Pentium MMX
	 */
	if (c->x86_vendor == X86_VENDOR_INTEL &&
	    c->x86 == 5 &&
	    c->x86_mask >= 1 && c->x86_mask <= 4 &&
	    c->x86_model <= 3)
		/*
		 * Remember we have B step Pentia with bugs
		 */
		smp_b_stepping = 1;

	/*
	 * Certain Athlons might work (for various values of 'work') in SMP
	 * but they are not certified as MP capable.
	 */
	if ((c->x86_vendor == X86_VENDOR_AMD) && (c->x86 == 6)) {

189
190
191
		if (num_possible_cpus() == 1)
			goto valid_k7;

Linus Torvalds's avatar
Linus Torvalds committed
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
		/* Athlon 660/661 is valid. */	
		if ((c->x86_model==6) && ((c->x86_mask==0) || (c->x86_mask==1)))
			goto valid_k7;

		/* Duron 670 is valid */
		if ((c->x86_model==7) && (c->x86_mask==0))
			goto valid_k7;

		/*
		 * Athlon 662, Duron 671, and Athlon >model 7 have capability bit.
		 * It's worth noting that the A5 stepping (662) of some Athlon XP's
		 * have the MP bit set.
		 * See http://www.heise.de/newsticker/data/jow-18.10.01-000 for more.
		 */
		if (((c->x86_model==6) && (c->x86_mask>=2)) ||
		    ((c->x86_model==7) && (c->x86_mask>=1)) ||
		     (c->x86_model> 7))
			if (cpu_has_mp)
				goto valid_k7;

		/* If we get here, it's not a certified SMP capable AMD system. */
213
		add_taint(TAINT_UNSAFE_SMP);
Linus Torvalds's avatar
Linus Torvalds committed
214
215
216
217
218
219
220
221
222
223
224
225
226
	}

valid_k7:
	;
}

/*
 * TSC synchronization.
 *
 * We first check whether all CPUs have their TSC's synchronized,
 * then we print a warning if not, and always resync.
 */

227
228
229
230
231
232
233
234
235
236
static struct {
	atomic_t start_flag;
	atomic_t count_start;
	atomic_t count_stop;
	unsigned long long values[NR_CPUS];
} tsc __initdata = {
	.start_flag = ATOMIC_INIT(0),
	.count_start = ATOMIC_INIT(0),
	.count_stop = ATOMIC_INIT(0),
};
Linus Torvalds's avatar
Linus Torvalds committed
237
238
239

#define NR_LOOPS 5

240
static void __init synchronize_tsc_bp(void)
Linus Torvalds's avatar
Linus Torvalds committed
241
242
243
244
245
{
	int i;
	unsigned long long t0;
	unsigned long long sum, avg;
	long long delta;
Andrew Morton's avatar
Andrew Morton committed
246
	unsigned int one_usec;
Linus Torvalds's avatar
Linus Torvalds committed
247
248
249
250
251
252
253
	int buggy = 0;

	printk(KERN_INFO "checking TSC synchronization across %u CPUs: ", num_booting_cpus());

	/* convert from kcyc/sec to cyc/usec */
	one_usec = cpu_khz / 1000;

254
	atomic_set(&tsc.start_flag, 1);
Linus Torvalds's avatar
Linus Torvalds committed
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
	wmb();

	/*
	 * We loop a few times to get a primed instruction cache,
	 * then the last pass is more or less synchronized and
	 * the BP and APs set their cycle counters to zero all at
	 * once. This reduces the chance of having random offsets
	 * between the processors, and guarantees that the maximum
	 * delay between the cycle counters is never bigger than
	 * the latency of information-passing (cachelines) between
	 * two CPUs.
	 */
	for (i = 0; i < NR_LOOPS; i++) {
		/*
		 * all APs synchronize but they loop on '== num_cpus'
		 */
271
		while (atomic_read(&tsc.count_start) != num_booting_cpus()-1)
Andreas Mohr's avatar
Andreas Mohr committed
272
			cpu_relax();
273
		atomic_set(&tsc.count_stop, 0);
Linus Torvalds's avatar
Linus Torvalds committed
274
275
276
277
		wmb();
		/*
		 * this lets the APs save their current TSC:
		 */
278
		atomic_inc(&tsc.count_start);
Linus Torvalds's avatar
Linus Torvalds committed
279

280
		rdtscll(tsc.values[smp_processor_id()]);
Linus Torvalds's avatar
Linus Torvalds committed
281
282
283
284
285
286
287
288
289
		/*
		 * We clear the TSC in the last loop:
		 */
		if (i == NR_LOOPS-1)
			write_tsc(0, 0);

		/*
		 * Wait for all APs to leave the synchronization point:
		 */
290
		while (atomic_read(&tsc.count_stop) != num_booting_cpus()-1)
Andreas Mohr's avatar
Andreas Mohr committed
291
			cpu_relax();
292
		atomic_set(&tsc.count_start, 0);
Linus Torvalds's avatar
Linus Torvalds committed
293
		wmb();
294
		atomic_inc(&tsc.count_stop);
Linus Torvalds's avatar
Linus Torvalds committed
295
296
297
298
299
	}

	sum = 0;
	for (i = 0; i < NR_CPUS; i++) {
		if (cpu_isset(i, cpu_callout_map)) {
300
			t0 = tsc.values[i];
Linus Torvalds's avatar
Linus Torvalds committed
301
302
303
304
305
306
307
308
309
			sum += t0;
		}
	}
	avg = sum;
	do_div(avg, num_booting_cpus());

	for (i = 0; i < NR_CPUS; i++) {
		if (!cpu_isset(i, cpu_callout_map))
			continue;
310
		delta = tsc.values[i] - avg;
Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
314
315
316
		if (delta < 0)
			delta = -delta;
		/*
		 * We report bigger than 2 microseconds clock differences.
		 */
		if (delta > 2*one_usec) {
317
318
			long long realdelta;

Linus Torvalds's avatar
Linus Torvalds committed
319
320
321
322
323
324
			if (!buggy) {
				buggy = 1;
				printk("\n");
			}
			realdelta = delta;
			do_div(realdelta, one_usec);
325
			if (tsc.values[i] < avg)
Linus Torvalds's avatar
Linus Torvalds committed
326
327
				realdelta = -realdelta;

328
329
			if (realdelta)
				printk(KERN_INFO "CPU#%d had %Ld usecs TSC "
330
					"skew, fixed it up.\n", i, realdelta);
Linus Torvalds's avatar
Linus Torvalds committed
331
332
333
334
335
336
		}
	}
	if (!buggy)
		printk("passed.\n");
}

337
static void __init synchronize_tsc_ap(void)
Linus Torvalds's avatar
Linus Torvalds committed
338
339
340
341
342
343
344
345
{
	int i;

	/*
	 * Not every cpu is online at the time
	 * this gets called, so we first wait for the BP to
	 * finish SMP initialization:
	 */
346
	while (!atomic_read(&tsc.start_flag))
Andreas Mohr's avatar
Andreas Mohr committed
347
		cpu_relax();
Linus Torvalds's avatar
Linus Torvalds committed
348
349

	for (i = 0; i < NR_LOOPS; i++) {
350
351
		atomic_inc(&tsc.count_start);
		while (atomic_read(&tsc.count_start) != num_booting_cpus())
Andreas Mohr's avatar
Andreas Mohr committed
352
			cpu_relax();
Linus Torvalds's avatar
Linus Torvalds committed
353

354
		rdtscll(tsc.values[smp_processor_id()]);
Linus Torvalds's avatar
Linus Torvalds committed
355
356
357
		if (i == NR_LOOPS-1)
			write_tsc(0, 0);

358
359
		atomic_inc(&tsc.count_stop);
		while (atomic_read(&tsc.count_stop) != num_booting_cpus())
Andreas Mohr's avatar
Andreas Mohr committed
360
			cpu_relax();
Linus Torvalds's avatar
Linus Torvalds committed
361
362
363
364
365
366
367
368
	}
}
#undef NR_LOOPS

extern void calibrate_delay(void);

static atomic_t init_deasserted;

Li Shaohua's avatar
Li Shaohua committed
369
static void __devinit smp_callin(void)
Linus Torvalds's avatar
Linus Torvalds committed
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
{
	int cpuid, phys_id;
	unsigned long timeout;

	/*
	 * If waken up by an INIT in an 82489DX configuration
	 * we may get here before an INIT-deassert IPI reaches
	 * our local APIC.  We have to wait for the IPI or we'll
	 * lock up on an APIC access.
	 */
	wait_for_init_deassert(&init_deasserted);

	/*
	 * (This works even if the APIC is not enabled.)
	 */
	phys_id = GET_APIC_ID(apic_read(APIC_ID));
	cpuid = smp_processor_id();
	if (cpu_isset(cpuid, cpu_callin_map)) {
		printk("huh, phys CPU#%d, CPU#%d already present??\n",
					phys_id, cpuid);
		BUG();
	}
	Dprintk("CPU#%d (phys ID: %d) waiting for CALLOUT\n", cpuid, phys_id);

	/*
	 * STARTUP IPIs are fragile beasts as they might sometimes
	 * trigger some glue motherboard logic. Complete APIC bus
	 * silence for 1 second, this overestimates the time the
	 * boot CPU is spending to send the up to 2 STARTUP IPIs
	 * by a factor of two. This should be enough.
	 */

	/*
	 * Waiting 2s total for startup (udelay is not yet working)
	 */
	timeout = jiffies + 2*HZ;
	while (time_before(jiffies, timeout)) {
		/*
		 * Has the boot CPU finished it's STARTUP sequence?
		 */
		if (cpu_isset(cpuid, cpu_callout_map))
			break;
		rep_nop();
	}

	if (!time_before(jiffies, timeout)) {
		printk("BUG: CPU%d started up but did not get a callout!\n",
			cpuid);
		BUG();
	}

	/*
	 * the boot CPU has finished the init stage and is spinning
	 * on callin_map until we finish. We are free to set up this
	 * CPU, first the APIC. (this is probably redundant on most
	 * boards)
	 */

	Dprintk("CALLIN, before setup_local_APIC().\n");
	smp_callin_clear_local_apic();
	setup_local_APIC();
	map_cpu_to_logical_apicid();

	/*
	 * Get our bogomips.
	 */
	calibrate_delay();
	Dprintk("Stack at about %p\n",&cpuid);

	/*
	 * Save our processor parameters
	 */
 	smp_store_cpu_info(cpuid);

	disable_APIC_timer();

	/*
	 * Allow the master to continue.
	 */
	cpu_set(cpuid, cpu_callin_map);

	/*
	 *      Synchronize the TSC with the BP
	 */
454
	if (cpu_has_tsc && cpu_khz && !tsc_sync_disabled)
Linus Torvalds's avatar
Linus Torvalds committed
455
456
457
458
459
		synchronize_tsc_ap();
}

static int cpucount;

460
461
462
463
464
465
/* maps the cpu to the sched domain representing multi-core */
cpumask_t cpu_coregroup_map(int cpu)
{
	struct cpuinfo_x86 *c = cpu_data + cpu;
	/*
	 * For perf, we return last level cache shared map.
466
	 * And for power savings, we return cpu_core_map
467
	 */
468
469
470
471
	if (sched_mc_power_savings || sched_smt_power_savings)
		return cpu_core_map[cpu];
	else
		return c->llc_shared_map;
472
473
}

474
475
476
/* representing cpus for which sibling maps can be computed */
static cpumask_t cpu_sibling_setup_map;

477
478
479
480
static inline void
set_cpu_sibling_map(int cpu)
{
	int i;
481
482
483
	struct cpuinfo_x86 *c = cpu_data;

	cpu_set(cpu, cpu_sibling_setup_map);
484
485

	if (smp_num_siblings > 1) {
486
		for_each_cpu_mask(i, cpu_sibling_setup_map) {
487
488
			if (c[cpu].phys_proc_id == c[i].phys_proc_id &&
			    c[cpu].cpu_core_id == c[i].cpu_core_id) {
489
490
				cpu_set(i, cpu_sibling_map[cpu]);
				cpu_set(cpu, cpu_sibling_map[i]);
491
492
				cpu_set(i, cpu_core_map[cpu]);
				cpu_set(cpu, cpu_core_map[i]);
493
494
				cpu_set(i, c[cpu].llc_shared_map);
				cpu_set(cpu, c[i].llc_shared_map);
495
496
497
498
499
500
			}
		}
	} else {
		cpu_set(cpu, cpu_sibling_map[cpu]);
	}

501
502
	cpu_set(cpu, c[cpu].llc_shared_map);

503
	if (current_cpu_data.x86_max_cores == 1) {
504
		cpu_core_map[cpu] = cpu_sibling_map[cpu];
505
506
507
508
509
		c[cpu].booted_cores = 1;
		return;
	}

	for_each_cpu_mask(i, cpu_sibling_setup_map) {
510
511
512
513
514
		if (cpu_llc_id[cpu] != BAD_APICID &&
		    cpu_llc_id[cpu] == cpu_llc_id[i]) {
			cpu_set(i, c[cpu].llc_shared_map);
			cpu_set(cpu, c[i].llc_shared_map);
		}
515
		if (c[cpu].phys_proc_id == c[i].phys_proc_id) {
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
			cpu_set(i, cpu_core_map[cpu]);
			cpu_set(cpu, cpu_core_map[i]);
			/*
			 *  Does this new cpu bringup a new core?
			 */
			if (cpus_weight(cpu_sibling_map[cpu]) == 1) {
				/*
				 * for each core in package, increment
				 * the booted_cores for this new cpu
				 */
				if (first_cpu(cpu_sibling_map[i]) == i)
					c[cpu].booted_cores++;
				/*
				 * increment the core count for all
				 * the other cpus in this package
				 */
				if (i != cpu)
					c[i].booted_cores++;
			} else if (i != cpu && !c[cpu].booted_cores)
				c[cpu].booted_cores = c[i].booted_cores;
		}
537
538
539
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
540
541
542
/*
 * Activate a secondary processor.
 */
Li Shaohua's avatar
Li Shaohua committed
543
static void __devinit start_secondary(void *unused)
Linus Torvalds's avatar
Linus Torvalds committed
544
545
{
	/*
546
	 * Don't put *anything* before secondary_cpu_init(), SMP
Linus Torvalds's avatar
Linus Torvalds committed
547
548
549
	 * booting is too fragile that we want to limit the
	 * things done here to the most necessary things.
	 */
550
	secondary_cpu_init();
551
	preempt_disable();
Linus Torvalds's avatar
Linus Torvalds committed
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
	smp_callin();
	while (!cpu_isset(smp_processor_id(), smp_commenced_mask))
		rep_nop();
	setup_secondary_APIC_clock();
	if (nmi_watchdog == NMI_IO_APIC) {
		disable_8259A_irq(0);
		enable_NMI_through_LVT0(NULL);
		enable_8259A_irq(0);
	}
	enable_APIC_timer();
	/*
	 * low-memory mappings have been cleared, flush them from
	 * the local TLBs too.
	 */
	local_flush_tlb();
Li Shaohua's avatar
Li Shaohua committed
567

568
569
570
571
	/* This must be done before setting cpu_online_map */
	set_cpu_sibling_map(raw_smp_processor_id());
	wmb();

Li Shaohua's avatar
Li Shaohua committed
572
573
574
575
576
577
578
579
580
	/*
	 * We need to hold call_lock, so there is no inconsistency
	 * between the time smp_call_function() determines number of
	 * IPI receipients, and the time when the determination is made
	 * for which cpus receive the IPI. Holding this
	 * lock helps us to not include this cpu in a currently in progress
	 * smp_call_function().
	 */
	lock_ipi_call_lock();
Linus Torvalds's avatar
Linus Torvalds committed
581
	cpu_set(smp_processor_id(), cpu_online_map);
Li Shaohua's avatar
Li Shaohua committed
582
	unlock_ipi_call_lock();
583
	per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
Linus Torvalds's avatar
Linus Torvalds committed
584
585
586
587
588
589
590
591
592
593
594
595
596
597

	/* We can take interrupts now: we're officially "up". */
	local_irq_enable();

	wmb();
	cpu_idle();
}

/*
 * Everything has been set up for the secondary
 * CPUs - they just need to reload everything
 * from the task structure
 * This function must not return.
 */
Li Shaohua's avatar
Li Shaohua committed
598
void __devinit initialize_secondary(void)
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
602
603
604
605
606
607
608
{
	/*
	 * We don't actually need to load the full TSS,
	 * basically just the stack pointer and the eip.
	 */

	asm volatile(
		"movl %0,%%esp\n\t"
		"jmp *%1"
		:
609
		:"m" (current->thread.esp),"m" (current->thread.eip));
Linus Torvalds's avatar
Linus Torvalds committed
610
611
}

612
/* Static state in head.S used to set up a CPU */
Linus Torvalds's avatar
Linus Torvalds committed
613
614
615
616
extern struct {
	void * esp;
	unsigned short ss;
} stack_start;
617
618
extern struct i386_pda *start_pda;
extern struct Xgt_desc_struct cpu_gdt_descr;
Linus Torvalds's avatar
Linus Torvalds committed
619
620
621
622

#ifdef CONFIG_NUMA

/* which logical CPUs are on which nodes */
623
cpumask_t node_2_cpu_mask[MAX_NUMNODES] __read_mostly =
Linus Torvalds's avatar
Linus Torvalds committed
624
				{ [0 ... MAX_NUMNODES-1] = CPU_MASK_NONE };
625
EXPORT_SYMBOL(node_2_cpu_mask);
Linus Torvalds's avatar
Linus Torvalds committed
626
/* which node each logical CPU is on */
627
int cpu_2_node[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = 0 };
Linus Torvalds's avatar
Linus Torvalds committed
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
EXPORT_SYMBOL(cpu_2_node);

/* set up a mapping between cpu and node. */
static inline void map_cpu_to_node(int cpu, int node)
{
	printk("Mapping cpu %d to node %d\n", cpu, node);
	cpu_set(cpu, node_2_cpu_mask[node]);
	cpu_2_node[cpu] = node;
}

/* undo a mapping between cpu and node. */
static inline void unmap_cpu_to_node(int cpu)
{
	int node;

	printk("Unmapping cpu %d from all nodes\n", cpu);
	for (node = 0; node < MAX_NUMNODES; node ++)
		cpu_clear(cpu, node_2_cpu_mask[node]);
	cpu_2_node[cpu] = 0;
}
#else /* !CONFIG_NUMA */

#define map_cpu_to_node(cpu, node)	({})
#define unmap_cpu_to_node(cpu)	({})

#endif /* CONFIG_NUMA */

655
u8 cpu_2_logical_apicid[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
Linus Torvalds's avatar
Linus Torvalds committed
656
657
658
659
660

static void map_cpu_to_logical_apicid(void)
{
	int cpu = smp_processor_id();
	int apicid = logical_smp_processor_id();
661
	int node = apicid_to_node(apicid);
662
663
664

	if (!node_online(node))
		node = first_online_node;
Linus Torvalds's avatar
Linus Torvalds committed
665
666

	cpu_2_logical_apicid[cpu] = apicid;
667
	map_cpu_to_node(cpu, node);
Linus Torvalds's avatar
Linus Torvalds committed
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
}

static void unmap_cpu_to_logical_apicid(int cpu)
{
	cpu_2_logical_apicid[cpu] = BAD_APICID;
	unmap_cpu_to_node(cpu);
}

#if APIC_DEBUG
static inline void __inquire_remote_apic(int apicid)
{
	int i, regs[] = { APIC_ID >> 4, APIC_LVR >> 4, APIC_SPIV >> 4 };
	char *names[] = { "ID", "VERSION", "SPIV" };
	int timeout, status;

	printk("Inquiring remote APIC #%d...\n", apicid);

685
	for (i = 0; i < ARRAY_SIZE(regs); i++) {
Linus Torvalds's avatar
Linus Torvalds committed
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
		printk("... APIC #%d %s: ", apicid, names[i]);

		/*
		 * Wait for idle.
		 */
		apic_wait_icr_idle();

		apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(apicid));
		apic_write_around(APIC_ICR, APIC_DM_REMRD | regs[i]);

		timeout = 0;
		do {
			udelay(100);
			status = apic_read(APIC_ICR) & APIC_ICR_RR_MASK;
		} while (status == APIC_ICR_RR_INPROG && timeout++ < 1000);

		switch (status) {
		case APIC_ICR_RR_VALID:
			status = apic_read(APIC_RRR);
			printk("%08x\n", status);
			break;
		default:
			printk("failed\n");
		}
	}
}
#endif

#ifdef WAKE_SECONDARY_VIA_NMI
/* 
 * Poke the other CPU in the eye via NMI to wake it up. Remember that the normal
 * INIT, INIT, STARTUP sequence will reset the chip hard for us, and this
 * won't ... remember to clear down the APIC, etc later.
 */
Li Shaohua's avatar
Li Shaohua committed
720
static int __devinit
Linus Torvalds's avatar
Linus Torvalds committed
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
wakeup_secondary_cpu(int logical_apicid, unsigned long start_eip)
{
	unsigned long send_status = 0, accept_status = 0;
	int timeout, maxlvt;

	/* Target chip */
	apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(logical_apicid));

	/* Boot on the stack */
	/* Kick the second */
	apic_write_around(APIC_ICR, APIC_DM_NMI | APIC_DEST_LOGICAL);

	Dprintk("Waiting for send to finish...\n");
	timeout = 0;
	do {
		Dprintk("+");
		udelay(100);
		send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
	} while (send_status && (timeout++ < 1000));

	/*
	 * Give the other CPU some time to accept the IPI.
	 */
	udelay(200);
	/*
	 * Due to the Pentium erratum 3AP.
	 */
	maxlvt = get_maxlvt();
	if (maxlvt > 3) {
		apic_read_around(APIC_SPIV);
		apic_write(APIC_ESR, 0);
	}
	accept_status = (apic_read(APIC_ESR) & 0xEF);
	Dprintk("NMI sent.\n");

	if (send_status)
		printk("APIC never delivered???\n");
	if (accept_status)
		printk("APIC delivery error (%lx).\n", accept_status);

	return (send_status | accept_status);
}
#endif	/* WAKE_SECONDARY_VIA_NMI */

#ifdef WAKE_SECONDARY_VIA_INIT
Li Shaohua's avatar
Li Shaohua committed
766
static int __devinit
Linus Torvalds's avatar
Linus Torvalds committed
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
wakeup_secondary_cpu(int phys_apicid, unsigned long start_eip)
{
	unsigned long send_status = 0, accept_status = 0;
	int maxlvt, timeout, num_starts, j;

	/*
	 * Be paranoid about clearing APIC errors.
	 */
	if (APIC_INTEGRATED(apic_version[phys_apicid])) {
		apic_read_around(APIC_SPIV);
		apic_write(APIC_ESR, 0);
		apic_read(APIC_ESR);
	}

	Dprintk("Asserting INIT.\n");

	/*
	 * Turn INIT on target chip
	 */
	apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));

	/*
	 * Send IPI
	 */
	apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_INT_ASSERT
				| APIC_DM_INIT);

	Dprintk("Waiting for send to finish...\n");
	timeout = 0;
	do {
		Dprintk("+");
		udelay(100);
		send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
	} while (send_status && (timeout++ < 1000));

	mdelay(10);

	Dprintk("Deasserting INIT.\n");

	/* Target chip */
	apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));

	/* Send IPI */
	apic_write_around(APIC_ICR, APIC_INT_LEVELTRIG | APIC_DM_INIT);

	Dprintk("Waiting for send to finish...\n");
	timeout = 0;
	do {
		Dprintk("+");
		udelay(100);
		send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
	} while (send_status && (timeout++ < 1000));

	atomic_set(&init_deasserted, 1);

	/*
	 * Should we send STARTUP IPIs ?
	 *
	 * Determine this based on the APIC version.
	 * If we don't have an integrated APIC, don't send the STARTUP IPIs.
	 */
	if (APIC_INTEGRATED(apic_version[phys_apicid]))
		num_starts = 2;
	else
		num_starts = 0;

	/*
	 * Run STARTUP IPI loop.
	 */
	Dprintk("#startup loops: %d.\n", num_starts);

	maxlvt = get_maxlvt();

	for (j = 1; j <= num_starts; j++) {
		Dprintk("Sending STARTUP #%d.\n",j);
		apic_read_around(APIC_SPIV);
		apic_write(APIC_ESR, 0);
		apic_read(APIC_ESR);
		Dprintk("After apic_write.\n");

		/*
		 * STARTUP IPI
		 */

		/* Target chip */
		apic_write_around(APIC_ICR2, SET_APIC_DEST_FIELD(phys_apicid));

		/* Boot on the stack */
		/* Kick the second */
		apic_write_around(APIC_ICR, APIC_DM_STARTUP
					| (start_eip >> 12));

		/*
		 * Give the other CPU some time to accept the IPI.
		 */
		udelay(300);

		Dprintk("Startup point 1.\n");

		Dprintk("Waiting for send to finish...\n");
		timeout = 0;
		do {
			Dprintk("+");
			udelay(100);
			send_status = apic_read(APIC_ICR) & APIC_ICR_BUSY;
		} while (send_status && (timeout++ < 1000));

		/*
		 * Give the other CPU some time to accept the IPI.
		 */
		udelay(200);
		/*
		 * Due to the Pentium erratum 3AP.
		 */
		if (maxlvt > 3) {
			apic_read_around(APIC_SPIV);
			apic_write(APIC_ESR, 0);
		}
		accept_status = (apic_read(APIC_ESR) & 0xEF);
		if (send_status || accept_status)
			break;
	}
	Dprintk("After Startup.\n");

	if (send_status)
		printk("APIC never delivered???\n");
	if (accept_status)
		printk("APIC delivery error (%lx).\n", accept_status);

	return (send_status | accept_status);
}
#endif	/* WAKE_SECONDARY_VIA_INIT */

extern cpumask_t cpu_initialized;
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
static inline int alloc_cpu_id(void)
{
	cpumask_t	tmp_map;
	int cpu;
	cpus_complement(tmp_map, cpu_present_map);
	cpu = first_cpu(tmp_map);
	if (cpu >= NR_CPUS)
		return -ENODEV;
	return cpu;
}

#ifdef CONFIG_HOTPLUG_CPU
static struct task_struct * __devinitdata cpu_idle_tasks[NR_CPUS];
static inline struct task_struct * alloc_idle_task(int cpu)
{
	struct task_struct *idle;

	if ((idle = cpu_idle_tasks[cpu]) != NULL) {
		/* initialize thread_struct.  we really want to avoid destroy
		 * idle tread
		 */
922
		idle->thread.esp = (unsigned long)task_pt_regs(idle);
923
924
925
926
927
928
929
930
931
932
933
934
		init_idle(idle, cpu);
		return idle;
	}
	idle = fork_idle(cpu);

	if (!IS_ERR(idle))
		cpu_idle_tasks[cpu] = idle;
	return idle;
}
#else
#define alloc_idle_task(cpu) fork_idle(cpu)
#endif
Linus Torvalds's avatar
Linus Torvalds committed
935

936
static int __devinit do_boot_cpu(int apicid, int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
937
938
939
940
941
942
943
944
/*
 * NOTE - on most systems this is a PHYSICAL apic ID, but on multiquad
 * (ie clustered apic addressing mode), this is a LOGICAL apic ID.
 * Returns zero if CPU booted OK, else error code from wakeup_secondary_cpu.
 */
{
	struct task_struct *idle;
	unsigned long boot_error;
945
	int timeout;
Linus Torvalds's avatar
Linus Torvalds committed
946
947
948
949
950
951
952
	unsigned long start_eip;
	unsigned short nmi_high = 0, nmi_low = 0;

	/*
	 * We can't use kernel_thread since we must avoid to
	 * reschedule the child.
	 */
953
	idle = alloc_idle_task(cpu);
Linus Torvalds's avatar
Linus Torvalds committed
954
955
	if (IS_ERR(idle))
		panic("failed fork for CPU %d", cpu);
956
957
958
959
960
961
962
963
964

	/* Pre-allocate and initialize the CPU's GDT and PDA so it
	   doesn't have to do any memory allocation during the
	   delicate CPU-bringup phase. */
	if (!init_gdt(cpu, idle)) {
		printk(KERN_INFO "Couldn't allocate GDT/PDA for CPU %d\n", cpu);
		return -1;	/* ? */
	}

Linus Torvalds's avatar
Linus Torvalds committed
965
966
967
968
	idle->thread.eip = (unsigned long) start_secondary;
	/* start_eip had better be page-aligned! */
	start_eip = setup_trampoline();

969
970
971
	++cpucount;
	alternatives_smp_switch(1);

Linus Torvalds's avatar
Linus Torvalds committed
972
973
974
975
976
	/* So we see what's up   */
	printk("Booting processor %d/%d eip %lx\n", cpu, apicid, start_eip);
	/* Stack for startup_32 can be just as for start_secondary onwards */
	stack_start.esp = (void *) idle->thread.esp;

977
978
979
	start_pda = cpu_pda(cpu);
	cpu_gdt_descr = per_cpu(cpu_gdt_descr, cpu);

Linus Torvalds's avatar
Linus Torvalds committed
980
981
	irq_ctx_init(cpu);

982
	x86_cpu_to_apicid[cpu] = apicid;
Linus Torvalds's avatar
Linus Torvalds committed
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
	/*
	 * This grunge runs the startup process for
	 * the targeted processor.
	 */

	atomic_set(&init_deasserted, 0);

	Dprintk("Setting warm reset code and vector.\n");

	store_NMI_vector(&nmi_high, &nmi_low);

	smpboot_setup_warm_reset_vector(start_eip);

	/*
	 * Starting actual IPI sequence...
	 */
	boot_error = wakeup_secondary_cpu(apicid, start_eip);

	if (!boot_error) {
		/*
		 * allow APs to start initializing.
		 */
		Dprintk("Before Callout %d.\n", cpu);
		cpu_set(cpu, cpu_callout_map);
		Dprintk("After Callout %d.\n", cpu);

		/*
		 * Wait 5s total for a response
		 */
		for (timeout = 0; timeout < 50000; timeout++) {
			if (cpu_isset(cpu, cpu_callin_map))
				break;	/* It has booted */
			udelay(100);
		}

		if (cpu_isset(cpu, cpu_callin_map)) {
			/* number CPUs logically, starting from 1 (BSP is 0) */
			Dprintk("OK.\n");
			printk("CPU%d: ", cpu);
			print_cpu_info(&cpu_data[cpu]);
			Dprintk("CPU has booted.\n");
		} else {
			boot_error= 1;
			if (*((volatile unsigned char *)trampoline_base)
					== 0xA5)
				/* trampoline started but...? */
				printk("Stuck ??\n");
			else
				/* trampoline code not run */
				printk("Not responding.\n");
			inquire_remote_apic(apicid);
		}
	}
1036

Linus Torvalds's avatar
Linus Torvalds committed
1037
1038
1039
1040
1041
1042
	if (boot_error) {
		/* Try to put things back the way they were before ... */
		unmap_cpu_to_logical_apicid(cpu);
		cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
		cpu_clear(cpu, cpu_initialized); /* was set by cpu_init() */
		cpucount--;
1043
1044
1045
	} else {
		x86_cpu_to_apicid[cpu] = apicid;
		cpu_set(cpu, cpu_present_map);
Linus Torvalds's avatar
Linus Torvalds committed
1046
1047
1048
1049
1050
1051
1052
1053
	}

	/* mark "stuck" area as not stuck */
	*((volatile unsigned long *)trampoline_base) = 0;

	return boot_error;
}

1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
#ifdef CONFIG_HOTPLUG_CPU
void cpu_exit_clear(void)
{
	int cpu = raw_smp_processor_id();

	idle_task_exit();

	cpucount --;
	cpu_uninit();
	irq_ctx_exit(cpu);

	cpu_clear(cpu, cpu_callout_map);
	cpu_clear(cpu, cpu_callin_map);

	cpu_clear(cpu, smp_commenced_mask);
	unmap_cpu_to_logical_apicid(cpu);
}

struct warm_boot_cpu_info {
	struct completion *complete;
David Howells's avatar
David Howells committed
1074
	struct work_struct task;
1075
1076
1077
1078
	int apicid;
	int cpu;
};

David Howells's avatar
David Howells committed
1079
static void __cpuinit do_warm_boot_cpu(struct work_struct *work)
1080
{
David Howells's avatar
David Howells committed
1081
1082
	struct warm_boot_cpu_info *info =
		container_of(work, struct warm_boot_cpu_info, task);
1083
1084
1085
1086
	do_boot_cpu(info->apicid, info->cpu);
	complete(info->complete);
}

1087
static int __cpuinit __smp_prepare_cpu(int cpu)
1088
{
1089
	DECLARE_COMPLETION_ONSTACK(done);
1090
1091
	struct warm_boot_cpu_info info;
	int	apicid, ret;
1092
	struct Xgt_desc_struct *cpu_gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
1093
1094
1095
1096
1097
1098
1099

	apicid = x86_cpu_to_apicid[cpu];
	if (apicid == BAD_APICID) {
		ret = -ENODEV;
		goto exit;
	}

1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
	/*
	 * the CPU isn't initialized at boot time, allocate gdt table here.
	 * cpu_init will initialize it
	 */
	if (!cpu_gdt_descr->address) {
		cpu_gdt_descr->address = get_zeroed_page(GFP_KERNEL);
		if (!cpu_gdt_descr->address)
			printk(KERN_CRIT "CPU%d failed to allocate GDT\n", cpu);
			ret = -ENOMEM;
			goto exit;
	}

1112
1113
1114
	info.complete = &done;
	info.apicid = apicid;
	info.cpu = cpu;
David Howells's avatar
David Howells committed
1115
	INIT_WORK(&info.task, do_warm_boot_cpu);
1116
1117
1118
1119

	tsc_sync_disabled = 1;

	/* init low mem mapping */
1120
	clone_pgd_range(swapper_pg_dir, swapper_pg_dir + USER_PGD_PTRS,
1121
			min_t(unsigned long, KERNEL_PGD_PTRS, USER_PGD_PTRS));
1122
	flush_tlb_all();
David Howells's avatar
David Howells committed
1123
	schedule_work(&info.task);
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
	wait_for_completion(&done);

	tsc_sync_disabled = 0;
	zap_low_mappings();
	ret = 0;
exit:
	return ret;
}
#endif

1134
static void smp_tune_scheduling(void)
Linus Torvalds's avatar
Linus Torvalds committed
1135
1136
1137
{
	unsigned long cachesize;       /* kB   */

1138
	if (cpu_khz) {
Linus Torvalds's avatar
Linus Torvalds committed
1139
		cachesize = boot_cpu_data.x86_cache_size;
1140
1141
1142

		if (cachesize > 0)
			max_cache_size = cachesize * 1024;
Linus Torvalds's avatar
Linus Torvalds committed
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
	}
}

/*
 * Cycle through the processors sending APIC IPIs to boot each.
 */

static int boot_cpu_logical_apicid;
/* Where the IO area was mapped on multiquad, always 0 otherwise */
void *xquad_portio;
1153
1154
1155
#ifdef CONFIG_X86_NUMAQ
EXPORT_SYMBOL(xquad_portio);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168

static void __init smp_boot_cpus(unsigned int max_cpus)
{
	int apicid, cpu, bit, kicked;
	unsigned long bogosum = 0;

	/*
	 * Setup boot CPU information
	 */
	smp_store_cpu_info(0); /* Final full version of the data */
	printk("CPU%d: ", 0);
	print_cpu_info(&cpu_data[0]);

1169
	boot_cpu_physical_apicid = GET_APIC_ID(apic_read(APIC_ID));
Linus Torvalds's avatar
Linus Torvalds committed
1170
1171
1172
1173
1174
1175
	boot_cpu_logical_apicid = logical_smp_processor_id();
	x86_cpu_to_apicid[0] = boot_cpu_physical_apicid;

	current_thread_info()->cpu = 0;
	smp_tune_scheduling();

1176
	set_cpu_sibling_map(0);
1177

Linus Torvalds's avatar
Linus Torvalds committed
1178
1179
1180
1181
1182
1183
	/*
	 * If we couldn't find an SMP configuration at boot time,
	 * get out of here now!
	 */
	if (!smp_found_config && !acpi_lapic) {
		printk(KERN_NOTICE "SMP motherboard not detected.\n");
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
		smpboot_clear_io_apic_irqs();
		phys_cpu_present_map = physid_mask_of_physid(0);
		if (APIC_init_uniprocessor())
			printk(KERN_NOTICE "Local APIC not detected."
					   " Using dummy APIC emulation.\n");
		map_cpu_to_logical_apicid();
		cpu_set(0, cpu_sibling_map[0]);
		cpu_set(0, cpu_core_map[0]);
		return;
	}

	/*
	 * Should not be necessary because the MP table should list the boot
	 * CPU too, but we do it for the sake of robustness anyway.
	 * Makes no sense to do this check in clustered apic mode, so skip it
	 */
	if (!check_phys_apicid_present(boot_cpu_physical_apicid)) {
		printk("weird, boot CPU (#%d) not listed by the BIOS.\n",
				boot_cpu_physical_apicid);
		physid_set(hard_smp_processor_id(), phys_cpu_present_map);
	}

	/*
	 * If we couldn't find a local APIC, then get out of here now!
	 */
	if (APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid]) && !cpu_has_apic) {
		printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
			boot_cpu_physical_apicid);
		printk(KERN_ERR "... forcing use of dummy APIC emulation. (tell your hw vendor)\n");
		smpboot_clear_io_apic_irqs();
		phys_cpu_present_map = physid_mask_of_physid(0);
		cpu_set(0, cpu_sibling_map[0]);
		cpu_set(0, cpu_core_map[0]);
Linus Torvalds's avatar
Linus Torvalds committed
1217
1218
1219
		return;
	}

1220
1221
	verify_local_APIC();

Linus Torvalds's avatar
Linus Torvalds committed
1222
1223
1224
	/*
	 * If SMP should be disabled, then really disable it!
	 */
1225
1226
1227
1228
1229
1230
1231
	if (!max_cpus) {
		smp_found_config = 0;
		printk(KERN_INFO "SMP mode deactivated, forcing use of dummy APIC emulation.\n");
		smpboot_clear_io_apic_irqs();
		phys_cpu_present_map = physid_mask_of_physid(0);
		cpu_set(0, cpu_sibling_map[0]);
		cpu_set(0, cpu_core_map[0]);
Linus Torvalds's avatar
Linus Torvalds committed
1232
1233
1234
		return;
	}

1235
1236
1237
1238
1239
	connect_bsp_APIC();
	setup_local_APIC();
	map_cpu_to_logical_apicid();


Linus Torvalds's avatar
Linus Torvalds committed
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
	setup_portio_remap();

	/*
	 * Scan the CPU present map and fire up the other CPUs via do_boot_cpu
	 *
	 * In clustered apic mode, phys_cpu_present_map is a constructed thus:
	 * bits 0-3 are quad0, 4-7 are quad1, etc. A perverse twist on the 
	 * clustered apic ID.
	 */
	Dprintk("CPU present map: %lx\n", physids_coerce(phys_cpu_present_map));

	kicked = 1;
	for (bit = 0; kicked < NR_CPUS && bit < MAX_APICS; bit++) {
		apicid = cpu_present_to_apicid(bit);
		/*
		 * Don't even attempt to start the boot CPU!
		 */
		if ((apicid == boot_cpu_apicid) || (apicid == BAD_APICID))
			continue;

		if (!check_apicid_present(bit))
			continue;
		if (max_cpus <= cpucount+1)
			continue;

1265
		if (((cpu = alloc_cpu_id()) <= 0) || do_boot_cpu(apicid, cpu))
Linus Torvalds's avatar
Linus Torvalds committed
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
			printk("CPU #%d not responding - cannot use it.\n",
								apicid);
		else
			++kicked;
	}

	/*
	 * Cleanup possible dangling ends...
	 */
	smpboot_restore_warm_reset_vector();

	/*
	 * Allow the user to impress friends.
	 */
	Dprintk("Before bogomips.\n");
	for (cpu = 0; cpu < NR_CPUS; cpu++)
		if (cpu_isset(cpu, cpu_callout_map))
			bogosum += cpu_data[cpu].loops_per_jiffy;
	printk(KERN_INFO
		"Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
		cpucount+1,
		bogosum/(500000/HZ),
		(bogosum/(5000/HZ))%100);
	
	Dprintk("Before bogocount - setting activated=1.\n");

	if (smp_b_stepping)
		printk(KERN_WARNING "WARNING: SMP operation may be unreliable with B stepping processors.\n");

	/*
	 * Don't taint if we are running SMP kernel on a single non-MP
	 * approved Athlon
	 */
	if (tainted & TAINT_UNSAFE_SMP) {
		if (cpucount)
			printk (KERN_INFO "WARNING: This combination of AMD processors is not suitable for SMP.\n");
		else
			tainted &= ~TAINT_UNSAFE_SMP;
	}

	Dprintk("Boot done.\n");

	/*
	 * construct cpu_sibling_map[], so that we can tell sibling CPUs
	 * efficiently.
	 */
1312
	for (cpu = 0; cpu < NR_CPUS; cpu++) {
Linus Torvalds's avatar
Linus Torvalds committed
1313
		cpus_clear(cpu_sibling_map[cpu]);
1314
1315
		cpus_clear(cpu_core_map[cpu]);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1316

1317
1318
	cpu_set(0, cpu_sibling_map[0]);
	cpu_set(0, cpu_core_map[0]);
Linus Torvalds's avatar
Linus Torvalds committed
1319

1320
1321
1322
1323
	smpboot_setup_io_apic();

	setup_boot_APIC_clock();

Linus Torvalds's avatar
Linus Torvalds committed
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
	/*
	 * Synchronize the TSC with the AP
	 */
	if (cpu_has_tsc && cpucount && cpu_khz)
		synchronize_tsc_bp();
}

/* These are wrappers to interface to the new boot process.  Someone
   who understands all this stuff should rewrite it properly. --RR 15/Jul/02 */
void __init smp_prepare_cpus(unsigned int max_cpus)
{
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1335
1336
1337
	smp_commenced_mask = cpumask_of_cpu(0);
	cpu_callin_map = cpumask_of_cpu(0);
	mb();
Linus Torvalds's avatar
Linus Torvalds committed
1338
1339
1340
1341
1342
1343
1344
	smp_boot_cpus(max_cpus);
}

void __devinit smp_prepare_boot_cpu(void)
{
	cpu_set(smp_processor_id(), cpu_online_map);
	cpu_set(smp_processor_id(), cpu_callout_map);
1345
	cpu_set(smp_processor_id(), cpu_present_map);
1346
	cpu_set(smp_processor_id(), cpu_possible_map);
1347
	per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
Linus Torvalds's avatar
Linus Torvalds committed
1348
1349
}

Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1350
#ifdef CONFIG_HOTPLUG_CPU
1351
1352
static void
remove_siblinginfo(int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
1353
{
1354
	int sibling;
1355
	struct cpuinfo_x86 *c = cpu_data;
1356

1357
1358
1359
1360
1361
1362
1363
1364
1365
	for_each_cpu_mask(sibling, cpu_core_map[cpu]) {
		cpu_clear(cpu, cpu_core_map[sibling]);
		/*
		 * last thread sibling in this cpu core going down
		 */
		if (cpus_weight(cpu_sibling_map[cpu]) == 1)
			c[sibling].booted_cores--;
	}
			
1366
1367
1368
1369
	for_each_cpu_mask(sibling, cpu_sibling_map[cpu])
		cpu_clear(cpu, cpu_sibling_map[sibling]);
	cpus_clear(cpu_sibling_map[cpu]);
	cpus_clear(cpu_core_map[cpu]);
1370
1371
	c[cpu].phys_proc_id = 0;
	c[cpu].cpu_core_id = 0;
1372
	cpu_clear(cpu, cpu_sibling_setup_map);
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
}

int __cpu_disable(void)
{
	cpumask_t map = cpu_online_map;
	int cpu = smp_processor_id();

	/*
	 * Perhaps use cpufreq to drop frequency, but that could go
	 * into generic code.
 	 *
	 * We won't take down the boot processor on i386 due to some
	 * interrupts only being able to be serviced by the BSP.
	 * Especially so if we're not using an IOAPIC	-zwane
	 */
	if (cpu == 0)
		return -EBUSY;
1390
1391
	if (nmi_watchdog == NMI_LOCAL_APIC)
		stop_apic_nmi_watchdog(NULL);
1392
	clear_local_APIC();
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1393
1394
1395
1396
1397
	/* Allow any queued timer interrupts to get serviced */
	local_irq_enable();
	mdelay(1);
	local_irq_disable();

1398
1399
	remove_siblinginfo(cpu);

Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
	cpu_clear(cpu, map);
	fixup_irqs(map);
	/* It's now safe to remove this processor from the online map */
	cpu_clear(cpu, cpu_online_map);
	return 0;
}

void __cpu_die(unsigned int cpu)
{
	/* We don't do anything here: idle task is faking death itself. */
	unsigned int i;

	for (i = 0; i < 10; i++) {
		/* They ack this in play_dead by setting CPU_DEAD */
1414
1415
		if (per_cpu(cpu_state, cpu) == CPU_DEAD) {
			printk ("CPU %d is now offline\n", cpu);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
1416
1417
			if (1 == num_online_cpus())
				alternatives_smp_switch(0);
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1418
			return;
1419
		}
1420
		msleep(100);
Linus Torvalds's avatar
Linus Torvalds committed
1421
	}
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1422
1423
1424
1425
1426
1427
1428
 	printk(KERN_ERR "CPU %u didn't die...\n", cpu);
}
#else /* ... !CONFIG_HOTPLUG_CPU */
int __cpu_disable(void)
{
	return -ENOSYS;
}
Linus Torvalds's avatar
Linus Torvalds committed
1429

Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1430
1431
1432
1433
1434
1435
1436
1437
1438
void __cpu_die(unsigned int cpu)
{
	/* We said "no" in __cpu_disable */
	BUG();
}
#endif /* CONFIG_HOTPLUG_CPU */

int __devinit __cpu_up(unsigned int cpu)
{
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
#ifdef CONFIG_HOTPLUG_CPU
	int ret=0;

	/*
	 * We do warm boot only on cpus that had booted earlier
	 * Otherwise cold boot is all handled from smp_boot_cpus().
	 * cpu_callin_map is set during AP kickstart process. Its reset
	 * when a cpu is taken offline from cpu_exit_clear().
	 */
	if (!cpu_isset(cpu, cpu_callin_map))
		ret = __smp_prepare_cpu(cpu);

	if (ret)
		return -EIO;
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1455
1456
	/* In case one didn't come up */
	if (!cpu_isset(cpu, cpu_callin_map)) {
Zwane Mwaikambo's avatar
Zwane Mwaikambo committed
1457
		printk(KERN_DEBUG "skipping cpu%d, didn't come online\n", cpu);
Linus Torvalds's avatar
Linus Torvalds committed
1458
1459
1460
1461
1462
		local_irq_enable();
		return -EIO;
	}

	local_irq_enable();
1463
	per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
Linus Torvalds's avatar
Linus Torvalds committed
1464
1465
1466
	/* Unleash the CPU! */
	cpu_set(cpu, smp_commenced_mask);
	while (!cpu_isset(cpu, cpu_online_map))
Andreas Mohr's avatar
Andreas Mohr committed
1467
		cpu_relax();
1468
1469
1470
1471
1472
1473

#ifdef CONFIG_X86_GENERICARCH
	if (num_online_cpus() > 8 && genapic == &apic_default)
		panic("Default flat APIC routing can't be used with > 8 cpus\n");
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1474
1475
1476
1477
1478
1479
1480
1481
1482
	return 0;
}

void __init smp_cpus_done(unsigned int max_cpus)
{
#ifdef CONFIG_X86_IO_APIC
	setup_ioapic_dest();
#endif
	zap_low_mappings();
1483
#ifndef CONFIG_HOTPLUG_CPU
Linus Torvalds's avatar
Linus Torvalds committed
1484
1485
1486
1487
	/*
	 * Disable executability of the SMP trampoline:
	 */
	set_kernel_exec((unsigned long)trampoline_base, trampoline_exec);
1488
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
}

void __init smp_intr_init(void)
{
	/*
	 * IRQ0 must be given a fixed assignment and initialized,
	 * because it's used before the IO-APIC is set up.
	 */
	set_intr_gate(FIRST_DEVICE_VECTOR, interrupt[0]);

	/*
	 * The reschedule interrupt is a CPU-to-CPU reschedule-helper
	 * IPI, driven by wakeup.
	 */
	set_intr_gate(RESCHEDULE_VECTOR, reschedule_interrupt);

	/* IPI for invalidation */
	set_intr_gate(INVALIDATE_TLB_VECTOR, invalidate_interrupt);

	/* IPI for generic function call */
	set_intr_gate(CALL_FUNCTION_VECTOR, call_function_interrupt);
}
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523

/*
 * If the BIOS enumerates physical processors before logical,
 * maxcpus=N at enumeration-time can be used to disable HT.
 */
static int __init parse_maxcpus(char *arg)
{
	extern unsigned int maxcpus;

	maxcpus = simple_strtoul(arg, NULL, 0);
	return 0;
}
early_param("maxcpus", parse_maxcpus);