common.c 33.7 KB
Newer Older
1
#include <linux/bootmem.h>
2
#include <linux/linkage.h>
3
#include <linux/bitops.h>
4
#include <linux/kernel.h>
5
#include <linux/module.h>
6
7
#include <linux/percpu.h>
#include <linux/string.h>
Linus Torvalds's avatar
Linus Torvalds committed
8
#include <linux/delay.h>
9
10
11
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/kgdb.h>
Linus Torvalds's avatar
Linus Torvalds committed
12
#include <linux/smp.h>
13
14
15
#include <linux/io.h>

#include <asm/stackprotector.h>
16
#include <asm/perf_event.h>
Linus Torvalds's avatar
Linus Torvalds committed
17
#include <asm/mmu_context.h>
18
#include <asm/archrandom.h>
19
20
#include <asm/hypervisor.h>
#include <asm/processor.h>
21
#include <asm/debugreg.h>
22
#include <asm/sections.h>
23
#include <asm/vsyscall.h>
24
25
#include <linux/topology.h>
#include <linux/cpumask.h>
26
#include <asm/pgtable.h>
Arun Sharma's avatar
Arun Sharma committed
27
#include <linux/atomic.h>
28
29
30
31
32
#include <asm/proto.h>
#include <asm/setup.h>
#include <asm/apic.h>
#include <asm/desc.h>
#include <asm/i387.h>
33
#include <asm/fpu-internal.h>
34
#include <asm/mtrr.h>
35
#include <linux/numa.h>
36
37
#include <asm/asm.h>
#include <asm/cpu.h>
38
#include <asm/mce.h>
39
#include <asm/msr.h>
40
#include <asm/pat.h>
41
42
#include <asm/microcode.h>
#include <asm/microcode_intel.h>
43
44

#ifdef CONFIG_X86_LOCAL_APIC
Tejun Heo's avatar
Tejun Heo committed
45
#include <asm/uv/uv.h>
Linus Torvalds's avatar
Linus Torvalds committed
46
47
48
49
#endif

#include "cpu.h"

50
51
/* all of these masks are initialized in setup_cpu_local_masks() */
cpumask_var_t cpu_initialized_mask;
52
53
cpumask_var_t cpu_callout_mask;
cpumask_var_t cpu_callin_mask;
54
55
56
57

/* representing cpus for which sibling maps can be computed */
cpumask_var_t cpu_sibling_setup_mask;

58
/* correctly size the local cpu masks */
59
void __init setup_cpu_local_masks(void)
60
61
62
63
64
65
66
{
	alloc_bootmem_cpumask_var(&cpu_initialized_mask);
	alloc_bootmem_cpumask_var(&cpu_callin_mask);
	alloc_bootmem_cpumask_var(&cpu_callout_mask);
	alloc_bootmem_cpumask_var(&cpu_sibling_setup_mask);
}

67
static void default_init(struct cpuinfo_x86 *c)
68
69
{
#ifdef CONFIG_X86_64
70
	cpu_detect_cache_sizes(c);
71
72
73
74
75
76
77
78
79
80
81
82
83
#else
	/* Not much we can do here... */
	/* Check if at least it has cpuid */
	if (c->cpuid_level == -1) {
		/* No cpuid. It must be an ancient CPU */
		if (c->x86 == 4)
			strcpy(c->x86_model_id, "486");
		else if (c->x86 == 3)
			strcpy(c->x86_model_id, "386");
	}
#endif
}

84
static const struct cpu_dev default_cpu = {
85
86
87
88
89
	.c_init		= default_init,
	.c_vendor	= "Unknown",
	.c_x86_vendor	= X86_VENDOR_UNKNOWN,
};

90
static const struct cpu_dev *this_cpu = &default_cpu;
91

92
DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
Yinghai Lu's avatar
Yinghai Lu committed
93
#ifdef CONFIG_X86_64
94
95
96
97
98
	/*
	 * We need valid kernel segments for data and code in long mode too
	 * IRET will check the segment types  kkeil 2000/10/28
	 * Also sysret mandates a special GDT layout
	 *
99
	 * TLS descriptors are currently at a different place compared to i386.
100
101
	 * Hopefully nobody expects them at a fixed place (Wine?)
	 */
Akinobu Mita's avatar
Akinobu Mita committed
102
103
104
105
106
107
	[GDT_ENTRY_KERNEL32_CS]		= GDT_ENTRY_INIT(0xc09b, 0, 0xfffff),
	[GDT_ENTRY_KERNEL_CS]		= GDT_ENTRY_INIT(0xa09b, 0, 0xfffff),
	[GDT_ENTRY_KERNEL_DS]		= GDT_ENTRY_INIT(0xc093, 0, 0xfffff),
	[GDT_ENTRY_DEFAULT_USER32_CS]	= GDT_ENTRY_INIT(0xc0fb, 0, 0xfffff),
	[GDT_ENTRY_DEFAULT_USER_DS]	= GDT_ENTRY_INIT(0xc0f3, 0, 0xfffff),
	[GDT_ENTRY_DEFAULT_USER_CS]	= GDT_ENTRY_INIT(0xa0fb, 0, 0xfffff),
Yinghai Lu's avatar
Yinghai Lu committed
108
#else
Akinobu Mita's avatar
Akinobu Mita committed
109
110
111
112
	[GDT_ENTRY_KERNEL_CS]		= GDT_ENTRY_INIT(0xc09a, 0, 0xfffff),
	[GDT_ENTRY_KERNEL_DS]		= GDT_ENTRY_INIT(0xc092, 0, 0xfffff),
	[GDT_ENTRY_DEFAULT_USER_CS]	= GDT_ENTRY_INIT(0xc0fa, 0, 0xfffff),
	[GDT_ENTRY_DEFAULT_USER_DS]	= GDT_ENTRY_INIT(0xc0f2, 0, 0xfffff),
113
114
115
116
117
	/*
	 * Segments used for calling PnP BIOS have byte granularity.
	 * They code segments and data segments have fixed 64k limits,
	 * the transfer segment sizes are set at run time.
	 */
118
	/* 32-bit code */
Akinobu Mita's avatar
Akinobu Mita committed
119
	[GDT_ENTRY_PNPBIOS_CS32]	= GDT_ENTRY_INIT(0x409a, 0, 0xffff),
120
	/* 16-bit code */
Akinobu Mita's avatar
Akinobu Mita committed
121
	[GDT_ENTRY_PNPBIOS_CS16]	= GDT_ENTRY_INIT(0x009a, 0, 0xffff),
122
	/* 16-bit data */
Akinobu Mita's avatar
Akinobu Mita committed
123
	[GDT_ENTRY_PNPBIOS_DS]		= GDT_ENTRY_INIT(0x0092, 0, 0xffff),
124
	/* 16-bit data */
Akinobu Mita's avatar
Akinobu Mita committed
125
	[GDT_ENTRY_PNPBIOS_TS1]		= GDT_ENTRY_INIT(0x0092, 0, 0),
126
	/* 16-bit data */
Akinobu Mita's avatar
Akinobu Mita committed
127
	[GDT_ENTRY_PNPBIOS_TS2]		= GDT_ENTRY_INIT(0x0092, 0, 0),
128
129
130
131
	/*
	 * The APM segments have byte granularity and their bases
	 * are set at run time.  All have 64k limits.
	 */
132
	/* 32-bit code */
Akinobu Mita's avatar
Akinobu Mita committed
133
	[GDT_ENTRY_APMBIOS_BASE]	= GDT_ENTRY_INIT(0x409a, 0, 0xffff),
134
	/* 16-bit code */
Akinobu Mita's avatar
Akinobu Mita committed
135
	[GDT_ENTRY_APMBIOS_BASE+1]	= GDT_ENTRY_INIT(0x009a, 0, 0xffff),
136
	/* data */
137
	[GDT_ENTRY_APMBIOS_BASE+2]	= GDT_ENTRY_INIT(0x4092, 0, 0xffff),
138

Akinobu Mita's avatar
Akinobu Mita committed
139
140
	[GDT_ENTRY_ESPFIX_SS]		= GDT_ENTRY_INIT(0xc092, 0, 0xfffff),
	[GDT_ENTRY_PERCPU]		= GDT_ENTRY_INIT(0xc092, 0, 0xfffff),
141
	GDT_STACK_CANARY_INIT
Yinghai Lu's avatar
Yinghai Lu committed
142
#endif
143
} };
144
EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);
145

146
147
148
static int __init x86_xsave_setup(char *s)
{
	setup_clear_cpu_cap(X86_FEATURE_XSAVE);
149
	setup_clear_cpu_cap(X86_FEATURE_XSAVEOPT);
150
151
	setup_clear_cpu_cap(X86_FEATURE_AVX);
	setup_clear_cpu_cap(X86_FEATURE_AVX2);
152
153
154
155
	return 1;
}
__setup("noxsave", x86_xsave_setup);

156
157
158
159
160
161
162
static int __init x86_xsaveopt_setup(char *s)
{
	setup_clear_cpu_cap(X86_FEATURE_XSAVEOPT);
	return 1;
}
__setup("noxsaveopt", x86_xsaveopt_setup);

163
#ifdef CONFIG_X86_32
164
165
static int cachesize_override = -1;
static int disable_x86_serial_nr = 1;
Linus Torvalds's avatar
Linus Torvalds committed
166

167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
static int __init cachesize_setup(char *str)
{
	get_option(&str, &cachesize_override);
	return 1;
}
__setup("cachesize=", cachesize_setup);

static int __init x86_fxsr_setup(char *s)
{
	setup_clear_cpu_cap(X86_FEATURE_FXSR);
	setup_clear_cpu_cap(X86_FEATURE_XMM);
	return 1;
}
__setup("nofxsr", x86_fxsr_setup);

static int __init x86_sep_setup(char *s)
{
	setup_clear_cpu_cap(X86_FEATURE_SEP);
	return 1;
}
__setup("nosep", x86_sep_setup);

/* Standard macro to see if a specific flag is changeable */
static inline int flag_is_changeable_p(u32 flag)
{
	u32 f1, f2;

194
195
196
197
198
199
200
	/*
	 * Cyrix and IDT cpus allow disabling of CPUID
	 * so the code below may return different results
	 * when it is executed before and after enabling
	 * the CPUID. Add "volatile" to not allow gcc to
	 * optimize the subsequent calls to this function.
	 */
Ingo Molnar's avatar
Ingo Molnar committed
201
202
203
204
205
206
207
208
209
210
211
	asm volatile ("pushfl		\n\t"
		      "pushfl		\n\t"
		      "popl %0		\n\t"
		      "movl %0, %1	\n\t"
		      "xorl %2, %0	\n\t"
		      "pushl %0		\n\t"
		      "popfl		\n\t"
		      "pushfl		\n\t"
		      "popl %0		\n\t"
		      "popfl		\n\t"

212
213
		      : "=&r" (f1), "=&r" (f2)
		      : "ir" (flag));
214
215
216
217
218

	return ((f1^f2) & flag) != 0;
}

/* Probe for the CPUID instruction */
219
int have_cpuid_p(void)
220
221
222
223
{
	return flag_is_changeable_p(X86_EFLAGS_ID);
}

224
static void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
225
{
Ingo Molnar's avatar
Ingo Molnar committed
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
	unsigned long lo, hi;

	if (!cpu_has(c, X86_FEATURE_PN) || !disable_x86_serial_nr)
		return;

	/* Disable processor serial number: */

	rdmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
	lo |= 0x200000;
	wrmsr(MSR_IA32_BBL_CR_CTL, lo, hi);

	printk(KERN_NOTICE "CPU serial number disabled.\n");
	clear_cpu_cap(c, X86_FEATURE_PN);

	/* Disabling the serial number may affect the cpuid level */
	c->cpuid_level = cpuid_eax(0);
242
243
244
245
246
247
248
249
}

static int __init x86_serial_nr_setup(char *s)
{
	disable_x86_serial_nr = 0;
	return 1;
}
__setup("serialnumber", x86_serial_nr_setup);
250
#else
251
252
253
254
255
256
257
static inline int flag_is_changeable_p(u32 flag)
{
	return 1;
}
static inline void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
{
}
258
#endif
259

260
261
static __init int setup_disable_smep(char *arg)
{
262
	setup_clear_cpu_cap(X86_FEATURE_SMEP);
263
264
265
266
	return 1;
}
__setup("nosmep", setup_disable_smep);

267
static __always_inline void setup_smep(struct cpuinfo_x86 *c)
268
{
269
270
	if (cpu_has(c, X86_FEATURE_SMEP))
		set_in_cr4(X86_CR4_SMEP);
271
272
}

273
274
static __init int setup_disable_smap(char *arg)
{
275
	setup_clear_cpu_cap(X86_FEATURE_SMAP);
276
277
278
279
	return 1;
}
__setup("nosmap", setup_disable_smap);

280
281
282
283
284
285
286
287
static __always_inline void setup_smap(struct cpuinfo_x86 *c)
{
	unsigned long eflags;

	/* This should have been cleared long ago */
	raw_local_save_flags(eflags);
	BUG_ON(eflags & X86_EFLAGS_AC);

288
289
	if (cpu_has(c, X86_FEATURE_SMAP)) {
#ifdef CONFIG_X86_SMAP
290
		set_in_cr4(X86_CR4_SMAP);
291
292
293
294
#else
		clear_in_cr4(X86_CR4_SMAP);
#endif
	}
295
296
}

297
298
299
300
301
302
303
304
305
/*
 * Some CPU features depend on higher CPUID levels, which may not always
 * be available due to CPUID level capping or broken virtualization
 * software.  Add those features to this table to auto-disable them.
 */
struct cpuid_dependent_feature {
	u32 feature;
	u32 level;
};
Ingo Molnar's avatar
Ingo Molnar committed
306

307
static const struct cpuid_dependent_feature
308
309
310
311
312
313
314
cpuid_dependent_features[] = {
	{ X86_FEATURE_MWAIT,		0x00000005 },
	{ X86_FEATURE_DCA,		0x00000009 },
	{ X86_FEATURE_XSAVE,		0x0000000d },
	{ 0, 0 }
};

315
static void filter_cpuid_features(struct cpuinfo_x86 *c, bool warn)
316
317
{
	const struct cpuid_dependent_feature *df;
318

319
	for (df = cpuid_dependent_features; df->feature; df++) {
Ingo Molnar's avatar
Ingo Molnar committed
320
321
322

		if (!cpu_has(c, df->feature))
			continue;
323
324
325
326
327
328
329
		/*
		 * Note: cpuid_level is set to -1 if unavailable, but
		 * extended_extended_level is set to 0 if unavailable
		 * and the legitimate extended levels are all negative
		 * when signed; hence the weird messing around with
		 * signs here...
		 */
Ingo Molnar's avatar
Ingo Molnar committed
330
		if (!((s32)df->level < 0 ?
331
		     (u32)df->level > (u32)c->extended_cpuid_level :
Ingo Molnar's avatar
Ingo Molnar committed
332
333
334
335
336
337
338
339
340
341
		     (s32)df->level > (s32)c->cpuid_level))
			continue;

		clear_cpu_cap(c, df->feature);
		if (!warn)
			continue;

		printk(KERN_WARNING
		       "CPU: CPU feature %s disabled, no CPUID level 0x%x\n",
				x86_cap_flags[df->feature], df->level);
342
	}
343
}
344

345
346
347
/*
 * Naming convention should be: <Name> [(<Codename>)]
 * This table only is used unless init_<vendor>() below doesn't set it;
Ingo Molnar's avatar
Ingo Molnar committed
348
349
 * in particular, if CPUID levels 0x80000002..4 are supported, this
 * isn't used
350
351
352
 */

/* Look up CPU names by table lookup. */
353
static const char *table_lookup_model(struct cpuinfo_x86 *c)
354
{
355
356
#ifdef CONFIG_X86_32
	const struct legacy_cpu_model_info *info;
357
358
359
360
361
362
363

	if (c->x86_model >= 16)
		return NULL;	/* Range check */

	if (!this_cpu)
		return NULL;

364
	info = this_cpu->legacy_models;
365

366
	while (info->family) {
367
368
369
370
		if (info->family == c->x86)
			return info->model_names[c->x86_model];
		info++;
	}
371
#endif
372
373
374
	return NULL;		/* Not found */
}

375
376
__u32 cpu_caps_cleared[NCAPINTS];
__u32 cpu_caps_set[NCAPINTS];
377

378
379
380
381
382
383
384
385
void load_percpu_segment(int cpu)
{
#ifdef CONFIG_X86_32
	loadsegment(fs, __KERNEL_PERCPU);
#else
	loadsegment(gs, 0);
	wrmsrl(MSR_GS_BASE, (unsigned long)per_cpu(irq_stack_union.gs_base, cpu));
#endif
386
	load_stack_canary_segment();
387
388
}

Ingo Molnar's avatar
Ingo Molnar committed
389
390
391
392
/*
 * Current gdt points %fs at the "master" per-cpu area: after this,
 * it's on the real one.
 */
393
void switch_to_new_gdt(int cpu)
394
395
396
{
	struct desc_ptr gdt_descr;

397
	gdt_descr.address = (long)get_cpu_gdt_table(cpu);
398
399
	gdt_descr.size = GDT_SIZE - 1;
	load_gdt(&gdt_descr);
400
	/* Reload the per-cpu base */
401
402

	load_percpu_segment(cpu);
403
404
}

405
static const struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
Linus Torvalds's avatar
Linus Torvalds committed
406

407
static void get_model_name(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
408
409
410
411
{
	unsigned int *v;
	char *p, *q;

412
	if (c->extended_cpuid_level < 0x80000004)
413
		return;
Linus Torvalds's avatar
Linus Torvalds committed
414

Ingo Molnar's avatar
Ingo Molnar committed
415
	v = (unsigned int *)c->x86_model_id;
Linus Torvalds's avatar
Linus Torvalds committed
416
417
418
419
420
	cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
	cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
	cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
	c->x86_model_id[48] = 0;

Ingo Molnar's avatar
Ingo Molnar committed
421
422
423
424
	/*
	 * Intel chips right-justify this string for some dumb reason;
	 * undo that brain damage:
	 */
Linus Torvalds's avatar
Linus Torvalds committed
425
	p = q = &c->x86_model_id[0];
426
	while (*p == ' ')
427
		p++;
428
	if (p != q) {
429
430
431
432
		while (*p)
			*q++ = *p++;
		while (q <= &c->x86_model_id[48])
			*q++ = '\0';	/* Zero-pad the rest */
Linus Torvalds's avatar
Linus Torvalds committed
433
434
435
	}
}

436
void cpu_detect_cache_sizes(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
437
{
438
	unsigned int n, dummy, ebx, ecx, edx, l2size;
Linus Torvalds's avatar
Linus Torvalds committed
439

440
	n = c->extended_cpuid_level;
Linus Torvalds's avatar
Linus Torvalds committed
441
442

	if (n >= 0x80000005) {
443
444
		cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
		c->x86_cache_size = (ecx>>24) + (edx>>24);
445
446
447
448
#ifdef CONFIG_X86_64
		/* On K8 L1 TLB is inclusive, so don't count it */
		c->x86_tlbsize = 0;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
449
450
451
452
453
	}

	if (n < 0x80000006)	/* Some chips just has a large L1. */
		return;

454
	cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
Linus Torvalds's avatar
Linus Torvalds committed
455
	l2size = ecx >> 16;
456

457
458
459
#ifdef CONFIG_X86_64
	c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
#else
Linus Torvalds's avatar
Linus Torvalds committed
460
	/* do processor-specific cache resizing */
461
462
	if (this_cpu->legacy_cache_size)
		l2size = this_cpu->legacy_cache_size(c, l2size);
Linus Torvalds's avatar
Linus Torvalds committed
463
464
465
466
467

	/* Allow user to override all this if necessary. */
	if (cachesize_override != -1)
		l2size = cachesize_override;

468
	if (l2size == 0)
Linus Torvalds's avatar
Linus Torvalds committed
469
		return;		/* Again, no L2 cache is possible */
470
#endif
Linus Torvalds's avatar
Linus Torvalds committed
471
472
473
474

	c->x86_cache_size = l2size;
}

475
476
477
478
479
480
u16 __read_mostly tlb_lli_4k[NR_INFO];
u16 __read_mostly tlb_lli_2m[NR_INFO];
u16 __read_mostly tlb_lli_4m[NR_INFO];
u16 __read_mostly tlb_lld_4k[NR_INFO];
u16 __read_mostly tlb_lld_2m[NR_INFO];
u16 __read_mostly tlb_lld_4m[NR_INFO];
481
u16 __read_mostly tlb_lld_1g[NR_INFO];
482

483
484
485
486
487
488
489
490
/*
 * tlb_flushall_shift shows the balance point in replacing cr3 write
 * with multiple 'invlpg'. It will do this replacement when
 *   flush_tlb_lines <= active_lines/2^tlb_flushall_shift.
 * If tlb_flushall_shift is -1, means the replacement will be disabled.
 */
s8  __read_mostly tlb_flushall_shift = -1;

491
void cpu_detect_tlb(struct cpuinfo_x86 *c)
492
493
494
495
{
	if (this_cpu->c_detect_tlb)
		this_cpu->c_detect_tlb(c);

496
497
	printk(KERN_INFO "Last level iTLB entries: 4KB %d, 2MB %d, 4MB %d\n"
		"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d, 1GB %d\n"
498
		"tlb_flushall_shift: %d\n",
499
500
		tlb_lli_4k[ENTRIES], tlb_lli_2m[ENTRIES],
		tlb_lli_4m[ENTRIES], tlb_lld_4k[ENTRIES],
501
		tlb_lld_2m[ENTRIES], tlb_lld_4m[ENTRIES],
502
		tlb_lld_1g[ENTRIES], tlb_flushall_shift);
503
504
}

505
void detect_ht(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
506
{
507
#ifdef CONFIG_X86_HT
508
509
	u32 eax, ebx, ecx, edx;
	int index_msb, core_bits;
510
	static bool printed;
Linus Torvalds's avatar
Linus Torvalds committed
511

512
	if (!cpu_has(c, X86_FEATURE_HT))
513
		return;
Linus Torvalds's avatar
Linus Torvalds committed
514

515
516
	if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
517

518
519
	if (cpu_has(c, X86_FEATURE_XTOPOLOGY))
		return;
Linus Torvalds's avatar
Linus Torvalds committed
520

521
	cpuid(1, &eax, &ebx, &ecx, &edx);
Linus Torvalds's avatar
Linus Torvalds committed
522

523
524
525
	smp_num_siblings = (ebx & 0xff0000) >> 16;

	if (smp_num_siblings == 1) {
526
		printk_once(KERN_INFO "CPU0: Hyper-Threading is disabled\n");
Ingo Molnar's avatar
Ingo Molnar committed
527
528
		goto out;
	}
529

Ingo Molnar's avatar
Ingo Molnar committed
530
531
	if (smp_num_siblings <= 1)
		goto out;
532

Ingo Molnar's avatar
Ingo Molnar committed
533
534
	index_msb = get_count_order(smp_num_siblings);
	c->phys_proc_id = apic->phys_pkg_id(c->initial_apicid, index_msb);
535

Ingo Molnar's avatar
Ingo Molnar committed
536
	smp_num_siblings = smp_num_siblings / c->x86_max_cores;
537

Ingo Molnar's avatar
Ingo Molnar committed
538
	index_msb = get_count_order(smp_num_siblings);
539

Ingo Molnar's avatar
Ingo Molnar committed
540
	core_bits = get_count_order(c->x86_max_cores);
541

Ingo Molnar's avatar
Ingo Molnar committed
542
543
	c->cpu_core_id = apic->phys_pkg_id(c->initial_apicid, index_msb) &
				       ((1 << core_bits) - 1);
Linus Torvalds's avatar
Linus Torvalds committed
544

545
out:
546
	if (!printed && (c->x86_max_cores * smp_num_siblings) > 1) {
547
548
549
550
		printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
		       c->phys_proc_id);
		printk(KERN_INFO  "CPU: Processor Core ID: %d\n",
		       c->cpu_core_id);
551
		printed = 1;
552
553
	}
#endif
554
}
Linus Torvalds's avatar
Linus Torvalds committed
555

556
static void get_cpu_vendor(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
557
558
{
	char *v = c->x86_vendor_id;
Ingo Molnar's avatar
Ingo Molnar committed
559
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
560
561

	for (i = 0; i < X86_VENDOR_NUM; i++) {
Yinghai Lu's avatar
Yinghai Lu committed
562
563
564
565
566
567
		if (!cpu_devs[i])
			break;

		if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
		    (cpu_devs[i]->c_ident[1] &&
		     !strcmp(v, cpu_devs[i]->c_ident[1]))) {
Ingo Molnar's avatar
Ingo Molnar committed
568

Yinghai Lu's avatar
Yinghai Lu committed
569
570
571
			this_cpu = cpu_devs[i];
			c->x86_vendor = this_cpu->c_x86_vendor;
			return;
Linus Torvalds's avatar
Linus Torvalds committed
572
573
		}
	}
Yinghai Lu's avatar
Yinghai Lu committed
574

575
576
577
	printk_once(KERN_ERR
			"CPU: vendor_id '%s' unknown, using generic init.\n" \
			"CPU: Your system may be unstable.\n", v);
Yinghai Lu's avatar
Yinghai Lu committed
578

579
580
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	this_cpu = &default_cpu;
Linus Torvalds's avatar
Linus Torvalds committed
581
582
}

583
void cpu_detect(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
584
585
{
	/* Get vendor name */
586
587
588
589
	cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
	      (unsigned int *)&c->x86_vendor_id[0],
	      (unsigned int *)&c->x86_vendor_id[8],
	      (unsigned int *)&c->x86_vendor_id[4]);
Linus Torvalds's avatar
Linus Torvalds committed
590
591

	c->x86 = 4;
592
	/* Intel-defined flags: level 0x00000001 */
Linus Torvalds's avatar
Linus Torvalds committed
593
594
	if (c->cpuid_level >= 0x00000001) {
		u32 junk, tfms, cap0, misc;
Ingo Molnar's avatar
Ingo Molnar committed
595

Linus Torvalds's avatar
Linus Torvalds committed
596
		cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
597
598
599
		c->x86 = (tfms >> 8) & 0xf;
		c->x86_model = (tfms >> 4) & 0xf;
		c->x86_mask = tfms & 0xf;
Ingo Molnar's avatar
Ingo Molnar committed
600

601
		if (c->x86 == 0xf)
Linus Torvalds's avatar
Linus Torvalds committed
602
			c->x86 += (tfms >> 20) & 0xff;
603
		if (c->x86 >= 0x6)
604
			c->x86_model += ((tfms >> 16) & 0xf) << 4;
Ingo Molnar's avatar
Ingo Molnar committed
605

606
607
		if (cap0 & (1<<19)) {
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
608
			c->x86_cache_alignment = c->x86_clflush_size;
609
		}
Linus Torvalds's avatar
Linus Torvalds committed
610
611
	}
}
612

613
void get_cpu_cap(struct cpuinfo_x86 *c)
614
615
{
	u32 tfms, xlvl;
616
	u32 ebx;
617

618
619
620
	/* Intel-defined flags: level 0x00000001 */
	if (c->cpuid_level >= 0x00000001) {
		u32 capability, excap;
Ingo Molnar's avatar
Ingo Molnar committed
621

622
623
624
625
		cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
		c->x86_capability[0] = capability;
		c->x86_capability[4] = excap;
	}
626

627
628
629
630
631
632
	/* Additional Intel-defined flags: level 0x00000007 */
	if (c->cpuid_level >= 0x00000007) {
		u32 eax, ebx, ecx, edx;

		cpuid_count(0x00000007, 0, &eax, &ebx, &ecx, &edx);

633
		c->x86_capability[9] = ebx;
634
635
	}

636
637
638
	/* AMD-defined flags: level 0x80000001 */
	xlvl = cpuid_eax(0x80000000);
	c->extended_cpuid_level = xlvl;
Ingo Molnar's avatar
Ingo Molnar committed
639

640
641
642
643
	if ((xlvl & 0xffff0000) == 0x80000000) {
		if (xlvl >= 0x80000001) {
			c->x86_capability[1] = cpuid_edx(0x80000001);
			c->x86_capability[6] = cpuid_ecx(0x80000001);
644
645
646
		}
	}

647
648
649
650
651
	if (c->extended_cpuid_level >= 0x80000008) {
		u32 eax = cpuid_eax(0x80000008);

		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
652
	}
653
654
655
#ifdef CONFIG_X86_32
	else if (cpu_has(c, X86_FEATURE_PAE) || cpu_has(c, X86_FEATURE_PSE36))
		c->x86_phys_bits = 36;
656
#endif
657
658
659

	if (c->extended_cpuid_level >= 0x80000007)
		c->x86_power = cpuid_edx(0x80000007);
660

661
	init_scattered_cpuid_features(c);
662
}
Linus Torvalds's avatar
Linus Torvalds committed
663

664
static void identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
{
#ifdef CONFIG_X86_32
	int i;

	/*
	 * First of all, decide if this is a 486 or higher
	 * It's a 486 if we can modify the AC flag
	 */
	if (flag_is_changeable_p(X86_EFLAGS_AC))
		c->x86 = 4;
	else
		c->x86 = 3;

	for (i = 0; i < X86_VENDOR_NUM; i++)
		if (cpu_devs[i] && cpu_devs[i]->c_identify) {
			c->x86_vendor_id[0] = 0;
			cpu_devs[i]->c_identify(c);
			if (c->x86_vendor_id[0]) {
				get_cpu_vendor(c);
				break;
			}
		}
#endif
}

690
691
692
693
694
695
696
697
698
/*
 * Do minimum CPU detection early.
 * Fields really needed: vendor, cpuid_level, family, model, mask,
 * cache alignment.
 * The others are not touched to avoid unwanted side effects.
 *
 * WARNING: this function is only called on the BP.  Don't add code here
 * that is supposed to run on all CPUs.
 */
699
static void __init early_identify_cpu(struct cpuinfo_x86 *c)
700
{
701
702
#ifdef CONFIG_X86_64
	c->x86_clflush_size = 64;
703
704
	c->x86_phys_bits = 36;
	c->x86_virt_bits = 48;
705
#else
706
	c->x86_clflush_size = 32;
707
708
	c->x86_phys_bits = 32;
	c->x86_virt_bits = 32;
709
#endif
710
	c->x86_cache_alignment = c->x86_clflush_size;
711

712
	memset(&c->x86_capability, 0, sizeof c->x86_capability);
713
	c->extended_cpuid_level = 0;
714

715
716
717
718
	if (!have_cpuid_p())
		identify_cpu_without_cpuid(c);

	/* cyrix could have cpuid enabled via c_identify()*/
719
720
721
722
	if (!have_cpuid_p())
		return;

	cpu_detect(c);
723
724
	get_cpu_vendor(c);
	get_cpu_cap(c);
725
	fpu_detect(c);
726

Yinghai Lu's avatar
Yinghai Lu committed
727
728
	if (this_cpu->c_early_init)
		this_cpu->c_early_init(c);
729

730
	c->cpu_index = 0;
731
	filter_cpuid_features(c, false);
732

733
734
	if (this_cpu->c_bsp_init)
		this_cpu->c_bsp_init(c);
735
736

	setup_force_cpu_cap(X86_FEATURE_ALWAYS);
737
738
}

739
740
void __init early_cpu_init(void)
{
741
	const struct cpu_dev *const *cdev;
Yinghai Lu's avatar
Yinghai Lu committed
742
743
	int count = 0;

744
#ifdef CONFIG_PROCESSOR_SELECT
745
	printk(KERN_INFO "KERNEL supported cpus:\n");
746
747
#endif

Yinghai Lu's avatar
Yinghai Lu committed
748
	for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
749
		const struct cpu_dev *cpudev = *cdev;
750

Yinghai Lu's avatar
Yinghai Lu committed
751
752
753
754
755
		if (count >= X86_VENDOR_NUM)
			break;
		cpu_devs[count] = cpudev;
		count++;

756
#ifdef CONFIG_PROCESSOR_SELECT
757
758
759
760
761
762
763
764
765
		{
			unsigned int j;

			for (j = 0; j < 2; j++) {
				if (!cpudev->c_ident[j])
					continue;
				printk(KERN_INFO "  %s %s\n", cpudev->c_vendor,
					cpudev->c_ident[j]);
			}
Yinghai Lu's avatar
Yinghai Lu committed
766
		}
767
#endif
Yinghai Lu's avatar
Yinghai Lu committed
768
	}
769
	early_identify_cpu(&boot_cpu_data);
770
}
771

772
/*
773
774
775
776
777
 * The NOPL instruction is supposed to exist on all CPUs of family >= 6;
 * unfortunately, that's not true in practice because of early VIA
 * chips and (more importantly) broken virtualizers that are not easy
 * to detect. In the latter case it doesn't even *fail* reliably, so
 * probing for it doesn't even work. Disable it completely on 32-bit
778
 * unless we can find a reliable way to detect all the broken cases.
779
 * Enable it explicitly on 64-bit for non-constant inputs of cpu_has().
780
 */
781
static void detect_nopl(struct cpuinfo_x86 *c)
782
{
783
#ifdef CONFIG_X86_32
784
	clear_cpu_cap(c, X86_FEATURE_NOPL);
785
786
787
#else
	set_cpu_cap(c, X86_FEATURE_NOPL);
#endif
788
789
}

790
static void generic_identify(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
791
{
792
	c->extended_cpuid_level = 0;
Linus Torvalds's avatar
Linus Torvalds committed
793

794
	if (!have_cpuid_p())
795
		identify_cpu_without_cpuid(c);
796

797
	/* cyrix could have cpuid enabled via c_identify()*/
Ingo Molnar's avatar
Ingo Molnar committed
798
	if (!have_cpuid_p())
799
		return;
Linus Torvalds's avatar
Linus Torvalds committed
800

801
	cpu_detect(c);
Linus Torvalds's avatar
Linus Torvalds committed
802

803
	get_cpu_vendor(c);
Linus Torvalds's avatar
Linus Torvalds committed
804

805
	get_cpu_cap(c);
Linus Torvalds's avatar
Linus Torvalds committed
806

807
808
	if (c->cpuid_level >= 0x00000001) {
		c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xFF;
809
810
#ifdef CONFIG_X86_32
# ifdef CONFIG_X86_HT
811
		c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
812
# else
813
		c->apicid = c->initial_apicid;
814
815
816
# endif
#endif
		c->phys_proc_id = c->initial_apicid;
817
	}
Linus Torvalds's avatar
Linus Torvalds committed
818

819
	get_model_name(c); /* Default name */
Linus Torvalds's avatar
Linus Torvalds committed
820

821
	detect_nopl(c);
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
825
826
}

/*
 * This does the hard work of actually picking apart the CPU stuff...
 */
827
static void identify_cpu(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830
831
832
833
834
835
836
{
	int i;

	c->loops_per_jiffy = loops_per_jiffy;
	c->x86_cache_size = -1;
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	c->x86_model = c->x86_mask = 0;	/* So far unknown... */
	c->x86_vendor_id[0] = '\0'; /* Unset */
	c->x86_model_id[0] = '\0';  /* Unset */
837
	c->x86_max_cores = 1;
838
	c->x86_coreid_bits = 0;
839
#ifdef CONFIG_X86_64
840
	c->x86_clflush_size = 64;
841
842
	c->x86_phys_bits = 36;
	c->x86_virt_bits = 48;
843
844
#else
	c->cpuid_level = -1;	/* CPUID not detected */
845
	c->x86_clflush_size = 32;
846
847
	c->x86_phys_bits = 32;
	c->x86_virt_bits = 32;
848
849
#endif
	c->x86_cache_alignment = c->x86_clflush_size;
Linus Torvalds's avatar
Linus Torvalds committed
850
851
852
853
	memset(&c->x86_capability, 0, sizeof c->x86_capability);

	generic_identify(c);

854
	if (this_cpu->c_identify)
Linus Torvalds's avatar
Linus Torvalds committed
855
856
		this_cpu->c_identify(c);

857
858
859
860
861
862
	/* Clear/Set all flags overriden by options, after probe */
	for (i = 0; i < NCAPINTS; i++) {
		c->x86_capability[i] &= ~cpu_caps_cleared[i];
		c->x86_capability[i] |= cpu_caps_set[i];
	}

863
#ifdef CONFIG_X86_64
864
	c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
865
866
#endif

Linus Torvalds's avatar
Linus Torvalds committed
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
	/*
	 * Vendor-specific initialization.  In this section we
	 * canonicalize the feature flags, meaning if there are
	 * features a certain CPU supports which CPUID doesn't
	 * tell us, CPUID claiming incorrect flags, or other bugs,
	 * we handle them here.
	 *
	 * At the end of this section, c->x86_capability better
	 * indicate the features this CPU genuinely supports!
	 */
	if (this_cpu->c_init)
		this_cpu->c_init(c);

	/* Disable the PN if appropriate */
	squash_the_stupid_serial_number(c);

883
884
885
886
	/* Set up SMEP/SMAP */
	setup_smep(c);
	setup_smap(c);

Linus Torvalds's avatar
Linus Torvalds committed
887
	/*
Ingo Molnar's avatar
Ingo Molnar committed
888
889
	 * The vendor-specific functions might have changed features.
	 * Now we do "generic changes."
Linus Torvalds's avatar
Linus Torvalds committed
890
891
	 */

892
893
894
	/* Filter out anything that depends on CPUID levels we don't have */
	filter_cpuid_features(c, true);

Linus Torvalds's avatar
Linus Torvalds committed
895
	/* If the model name is still unset, do table lookup. */
896
	if (!c->x86_model_id[0]) {
897
		const char *p;
Linus Torvalds's avatar
Linus Torvalds committed
898
		p = table_lookup_model(c);
899
		if (p)
Linus Torvalds's avatar
Linus Torvalds committed
900
901
902
903
			strcpy(c->x86_model_id, p);
		else
			/* Last resort... */
			sprintf(c->x86_model_id, "%02x/%02x",
904
				c->x86, c->x86_model);
Linus Torvalds's avatar
Linus Torvalds committed
905
906
	}

907
908
909
910
#ifdef CONFIG_X86_64
	detect_ht(c);
#endif

911
	init_hypervisor(c);
912
	x86_init_rdrand(c);
913
914
915
916
917
918
919
920
921
922

	/*
	 * Clear/Set all flags overriden by options, need do it
	 * before following smp all cpus cap AND.
	 */
	for (i = 0; i < NCAPINTS; i++) {
		c->x86_capability[i] &= ~cpu_caps_cleared[i];
		c->x86_capability[i] |= cpu_caps_set[i];
	}

Linus Torvalds's avatar
Linus Torvalds committed
923
924
925
926
927
928
	/*
	 * On SMP, boot_cpu_data holds the common feature set between
	 * all CPUs; so make sure that we indicate which features are
	 * common between the CPUs.  The first time this routine gets
	 * executed, c == &boot_cpu_data.
	 */
929
	if (c != &boot_cpu_data) {
Linus Torvalds's avatar
Linus Torvalds committed
930
		/* AND the already accumulated flags with these */
931
		for (i = 0; i < NCAPINTS; i++)
Linus Torvalds's avatar
Linus Torvalds committed
932
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
933
934
935
936

		/* OR, i.e. replicate the bug flags */
		for (i = NCAPINTS; i < NCAPINTS + NBUGINTS; i++)
			c->x86_capability[i] |= boot_cpu_data.x86_capability[i];
Linus Torvalds's avatar
Linus Torvalds committed
937
938
939
	}

	/* Init Machine Check Exception if available. */
940
	mcheck_cpu_init(c);
941
942

	select_idle_routine(c);
943

944
#ifdef CONFIG_NUMA
945
946
	numa_add_cpu(smp_processor_id());
#endif
947
}
Shaohua Li's avatar
Shaohua Li committed
948

949
950
951
952
953
954
955
956
#ifdef CONFIG_X86_64
static void vgetcpu_set_mode(void)
{
	if (cpu_has(&boot_cpu_data, X86_FEATURE_RDTSCP))
		vgetcpu_mode = VGETCPU_RDTSCP;
	else
		vgetcpu_mode = VGETCPU_LSL;
}
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988

/* May not be __init: called during resume */
static void syscall32_cpu_init(void)
{
	/* Load these always in case some future AMD CPU supports
	   SYSENTER from compat mode too. */
	wrmsrl_safe(MSR_IA32_SYSENTER_CS, (u64)__KERNEL_CS);
	wrmsrl_safe(MSR_IA32_SYSENTER_ESP, 0ULL);
	wrmsrl_safe(MSR_IA32_SYSENTER_EIP, (u64)ia32_sysenter_target);

	wrmsrl(MSR_CSTAR, ia32_cstar_target);
}
#endif

#ifdef CONFIG_X86_32
void enable_sep_cpu(void)
{
	int cpu = get_cpu();
	struct tss_struct *tss = &per_cpu(init_tss, cpu);

	if (!boot_cpu_has(X86_FEATURE_SEP)) {
		put_cpu();
		return;
	}

	tss->x86_tss.ss1 = __KERNEL_CS;
	tss->x86_tss.sp1 = sizeof(struct tss_struct) + (unsigned long) tss;
	wrmsr(MSR_IA32_SYSENTER_CS, __KERNEL_CS, 0);
	wrmsr(MSR_IA32_SYSENTER_ESP, tss->x86_tss.sp1, 0);
	wrmsr(MSR_IA32_SYSENTER_EIP, (unsigned long) ia32_sysenter_target, 0);
	put_cpu();
}
989
990
#endif

991
992
993
void __init identify_boot_cpu(void)
{
	identify_cpu(&boot_cpu_data);
994
	init_amd_e400_c1e_mask();
995
#ifdef CONFIG_X86_32
996
	sysenter_setup();
Li Shaohua's avatar
Li Shaohua committed
997
	enable_sep_cpu();
998
999
#else
	vgetcpu_set_mode();
1000
#endif
1001
	cpu_detect_tlb(&boot_cpu_data);
1002
}
1003

1004
void identify_secondary_cpu(struct cpuinfo_x86 *c)
1005
1006
1007
{
	BUG_ON(c == &boot_cpu_data);
	identify_cpu(c);
1008
#ifdef CONFIG_X86_32
1009
	enable_sep_cpu();
1010
#endif
1011
	mtrr_ap_init();
Linus Torvalds's avatar
Linus Torvalds committed
1012
1013
}

1014
struct msr_range {
Ingo Molnar's avatar
Ingo Molnar committed
1015
1016
	unsigned	min;
	unsigned	max;
1017
};
Linus Torvalds's avatar
Linus Torvalds committed
1018

1019
static const struct msr_range msr_range_array[] = {
1020
1021
1022
1023
1024
	{ 0x00000000, 0x00000418},
	{ 0xc0000000, 0xc000040b},
	{ 0xc0010000, 0xc0010142},
	{ 0xc0011000, 0xc001103b},
};
Linus Torvalds's avatar
Linus Torvalds committed
1025

1026
static void __print_cpu_msr(void)
1027
{
Ingo Molnar's avatar
Ingo Molnar committed
1028
	unsigned index_min, index_max;
1029
1030
1031
1032
1033
1034
1035
	unsigned index;
	u64 val;
	int i;

	for (i = 0; i < ARRAY_SIZE(msr_range_array); i++) {
		index_min = msr_range_array[i].min;
		index_max = msr_range_array[i].max;
Ingo Molnar's avatar
Ingo Molnar committed
1036

1037
		for (index = index_min; index < index_max; index++) {
1038
			if (rdmsrl_safe(index, &val))