common.c 32.4 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>
L
Linus Torvalds 已提交
8
#include <linux/delay.h>
9 10 11
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/kgdb.h>
L
Linus Torvalds 已提交
12
#include <linux/smp.h>
13 14 15
#include <linux/io.h>

#include <asm/stackprotector.h>
16
#include <asm/perf_event.h>
L
Linus Torvalds 已提交
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>
A
Alan Cox 已提交
23 24
#include <linux/topology.h>
#include <linux/cpumask.h>
25
#include <asm/pgtable.h>
A
Arun Sharma 已提交
26
#include <linux/atomic.h>
27 28 29 30 31
#include <asm/proto.h>
#include <asm/setup.h>
#include <asm/apic.h>
#include <asm/desc.h>
#include <asm/i387.h>
32
#include <asm/fpu-internal.h>
33
#include <asm/mtrr.h>
A
Alan Cox 已提交
34
#include <linux/numa.h>
35 36
#include <asm/asm.h>
#include <asm/cpu.h>
37
#include <asm/mce.h>
38
#include <asm/msr.h>
39
#include <asm/pat.h>
40 41
#include <asm/microcode.h>
#include <asm/microcode_intel.h>
42 43

#ifdef CONFIG_X86_LOCAL_APIC
T
Tejun Heo 已提交
44
#include <asm/uv/uv.h>
L
Linus Torvalds 已提交
45 46 47 48
#endif

#include "cpu.h"

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

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

B
Brian Gerst 已提交
57
/* correctly size the local cpu masks */
58
void __init setup_cpu_local_masks(void)
B
Brian Gerst 已提交
59 60 61 62 63 64 65
{
	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);
}

66
static void default_init(struct cpuinfo_x86 *c)
67 68
{
#ifdef CONFIG_X86_64
69
	cpu_detect_cache_sizes(c);
70 71 72 73 74 75 76 77 78 79 80 81 82
#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
}

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

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

B
Brian Gerst 已提交
91
DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
Y
Yinghai Lu 已提交
92
#ifdef CONFIG_X86_64
B
Brian Gerst 已提交
93 94 95 96 97
	/*
	 * 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
	 *
98
	 * TLS descriptors are currently at a different place compared to i386.
B
Brian Gerst 已提交
99 100
	 * Hopefully nobody expects them at a fixed place (Wine?)
	 */
A
Akinobu Mita 已提交
101 102 103 104 105 106
	[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),
Y
Yinghai Lu 已提交
107
#else
A
Akinobu Mita 已提交
108 109 110 111
	[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),
112 113 114 115 116
	/*
	 * 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.
	 */
117
	/* 32-bit code */
A
Akinobu Mita 已提交
118
	[GDT_ENTRY_PNPBIOS_CS32]	= GDT_ENTRY_INIT(0x409a, 0, 0xffff),
119
	/* 16-bit code */
A
Akinobu Mita 已提交
120
	[GDT_ENTRY_PNPBIOS_CS16]	= GDT_ENTRY_INIT(0x009a, 0, 0xffff),
121
	/* 16-bit data */
A
Akinobu Mita 已提交
122
	[GDT_ENTRY_PNPBIOS_DS]		= GDT_ENTRY_INIT(0x0092, 0, 0xffff),
123
	/* 16-bit data */
A
Akinobu Mita 已提交
124
	[GDT_ENTRY_PNPBIOS_TS1]		= GDT_ENTRY_INIT(0x0092, 0, 0),
125
	/* 16-bit data */
A
Akinobu Mita 已提交
126
	[GDT_ENTRY_PNPBIOS_TS2]		= GDT_ENTRY_INIT(0x0092, 0, 0),
127 128 129 130
	/*
	 * The APM segments have byte granularity and their bases
	 * are set at run time.  All have 64k limits.
	 */
131
	/* 32-bit code */
A
Akinobu Mita 已提交
132
	[GDT_ENTRY_APMBIOS_BASE]	= GDT_ENTRY_INIT(0x409a, 0, 0xffff),
133
	/* 16-bit code */
A
Akinobu Mita 已提交
134
	[GDT_ENTRY_APMBIOS_BASE+1]	= GDT_ENTRY_INIT(0x009a, 0, 0xffff),
135
	/* data */
136
	[GDT_ENTRY_APMBIOS_BASE+2]	= GDT_ENTRY_INIT(0x4092, 0, 0xffff),
137

A
Akinobu Mita 已提交
138 139
	[GDT_ENTRY_ESPFIX_SS]		= GDT_ENTRY_INIT(0xc092, 0, 0xfffff),
	[GDT_ENTRY_PERCPU]		= GDT_ENTRY_INIT(0xc092, 0, 0xfffff),
140
	GDT_STACK_CANARY_INIT
Y
Yinghai Lu 已提交
141
#endif
B
Brian Gerst 已提交
142
} };
143
EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);
144

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

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

162
#ifdef CONFIG_X86_32
163 164
static int cachesize_override = -1;
static int disable_x86_serial_nr = 1;
L
Linus Torvalds 已提交
165

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
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;

193 194 195 196 197 198 199
	/*
	 * 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.
	 */
I
Ingo Molnar 已提交
200 201 202 203 204 205 206 207 208 209 210
	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"

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

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

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

223
static void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
224
{
I
Ingo Molnar 已提交
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
	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);
241 242 243 244 245 246 247 248
}

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

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

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

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

279 280 281 282 283 284 285 286 287 288
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);

	if (cpu_has(c, X86_FEATURE_SMAP))
		set_in_cr4(X86_CR4_SMAP);
289 290
}

291 292 293 294 295 296 297 298 299
/*
 * 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;
};
I
Ingo Molnar 已提交
300

301
static const struct cpuid_dependent_feature
302 303 304 305 306 307 308
cpuid_dependent_features[] = {
	{ X86_FEATURE_MWAIT,		0x00000005 },
	{ X86_FEATURE_DCA,		0x00000009 },
	{ X86_FEATURE_XSAVE,		0x0000000d },
	{ 0, 0 }
};

309
static void filter_cpuid_features(struct cpuinfo_x86 *c, bool warn)
310 311
{
	const struct cpuid_dependent_feature *df;
312

313
	for (df = cpuid_dependent_features; df->feature; df++) {
I
Ingo Molnar 已提交
314 315 316

		if (!cpu_has(c, df->feature))
			continue;
317 318 319 320 321 322 323
		/*
		 * 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...
		 */
I
Ingo Molnar 已提交
324
		if (!((s32)df->level < 0 ?
325
		     (u32)df->level > (u32)c->extended_cpuid_level :
I
Ingo Molnar 已提交
326 327 328 329 330 331 332 333 334 335
		     (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);
336
	}
337
}
338

339 340 341
/*
 * Naming convention should be: <Name> [(<Codename>)]
 * This table only is used unless init_<vendor>() below doesn't set it;
I
Ingo Molnar 已提交
342 343
 * in particular, if CPUID levels 0x80000002..4 are supported, this
 * isn't used
344 345 346
 */

/* Look up CPU names by table lookup. */
347
static const char *table_lookup_model(struct cpuinfo_x86 *c)
348
{
349
	const struct cpu_model_info *info;
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366

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

	if (!this_cpu)
		return NULL;

	info = this_cpu->c_models;

	while (info && info->family) {
		if (info->family == c->x86)
			return info->model_names[c->x86_model];
		info++;
	}
	return NULL;		/* Not found */
}

367 368
__u32 cpu_caps_cleared[NCAPINTS];
__u32 cpu_caps_set[NCAPINTS];
369

370 371 372 373 374 375 376 377
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
378
	load_stack_canary_segment();
379 380
}

I
Ingo Molnar 已提交
381 382 383 384
/*
 * Current gdt points %fs at the "master" per-cpu area: after this,
 * it's on the real one.
 */
385
void switch_to_new_gdt(int cpu)
386 387 388
{
	struct desc_ptr gdt_descr;

389
	gdt_descr.address = (long)get_cpu_gdt_table(cpu);
390 391
	gdt_descr.size = GDT_SIZE - 1;
	load_gdt(&gdt_descr);
392
	/* Reload the per-cpu base */
393 394

	load_percpu_segment(cpu);
395 396
}

397
static const struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
L
Linus Torvalds 已提交
398

399
static void get_model_name(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
400 401 402 403
{
	unsigned int *v;
	char *p, *q;

404
	if (c->extended_cpuid_level < 0x80000004)
405
		return;
L
Linus Torvalds 已提交
406

I
Ingo Molnar 已提交
407
	v = (unsigned int *)c->x86_model_id;
L
Linus Torvalds 已提交
408 409 410 411 412
	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;

I
Ingo Molnar 已提交
413 414 415 416
	/*
	 * Intel chips right-justify this string for some dumb reason;
	 * undo that brain damage:
	 */
L
Linus Torvalds 已提交
417
	p = q = &c->x86_model_id[0];
418
	while (*p == ' ')
419
		p++;
420
	if (p != q) {
421 422 423 424
		while (*p)
			*q++ = *p++;
		while (q <= &c->x86_model_id[48])
			*q++ = '\0';	/* Zero-pad the rest */
L
Linus Torvalds 已提交
425 426 427
	}
}

428
void cpu_detect_cache_sizes(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
429
{
430
	unsigned int n, dummy, ebx, ecx, edx, l2size;
L
Linus Torvalds 已提交
431

432
	n = c->extended_cpuid_level;
L
Linus Torvalds 已提交
433 434

	if (n >= 0x80000005) {
435 436
		cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
		c->x86_cache_size = (ecx>>24) + (edx>>24);
437 438 439 440
#ifdef CONFIG_X86_64
		/* On K8 L1 TLB is inclusive, so don't count it */
		c->x86_tlbsize = 0;
#endif
L
Linus Torvalds 已提交
441 442 443 444 445
	}

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

446
	cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
L
Linus Torvalds 已提交
447
	l2size = ecx >> 16;
448

449 450 451
#ifdef CONFIG_X86_64
	c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
#else
L
Linus Torvalds 已提交
452 453
	/* do processor-specific cache resizing */
	if (this_cpu->c_size_cache)
454
		l2size = this_cpu->c_size_cache(c, l2size);
L
Linus Torvalds 已提交
455 456 457 458 459

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

460
	if (l2size == 0)
L
Linus Torvalds 已提交
461
		return;		/* Again, no L2 cache is possible */
462
#endif
L
Linus Torvalds 已提交
463 464 465 466

	c->x86_cache_size = l2size;
}

467 468 469 470 471 472 473
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];

474 475 476 477 478 479 480 481
/*
 * 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;

482
void cpu_detect_tlb(struct cpuinfo_x86 *c)
483 484 485 486 487
{
	if (this_cpu->c_detect_tlb)
		this_cpu->c_detect_tlb(c);

	printk(KERN_INFO "Last level iTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \
488
		"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n"	     \
489
		"tlb_flushall_shift: %d\n",
490 491
		tlb_lli_4k[ENTRIES], tlb_lli_2m[ENTRIES],
		tlb_lli_4m[ENTRIES], tlb_lld_4k[ENTRIES],
492 493
		tlb_lld_2m[ENTRIES], tlb_lld_4m[ENTRIES],
		tlb_flushall_shift);
494 495
}

496
void detect_ht(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
497
{
498
#ifdef CONFIG_X86_HT
499 500
	u32 eax, ebx, ecx, edx;
	int index_msb, core_bits;
501
	static bool printed;
L
Linus Torvalds 已提交
502

503
	if (!cpu_has(c, X86_FEATURE_HT))
504
		return;
L
Linus Torvalds 已提交
505

506 507
	if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
		goto out;
L
Linus Torvalds 已提交
508

509 510
	if (cpu_has(c, X86_FEATURE_XTOPOLOGY))
		return;
L
Linus Torvalds 已提交
511

512
	cpuid(1, &eax, &ebx, &ecx, &edx);
L
Linus Torvalds 已提交
513

514 515 516
	smp_num_siblings = (ebx & 0xff0000) >> 16;

	if (smp_num_siblings == 1) {
517
		printk_once(KERN_INFO "CPU0: Hyper-Threading is disabled\n");
I
Ingo Molnar 已提交
518 519
		goto out;
	}
520

I
Ingo Molnar 已提交
521 522
	if (smp_num_siblings <= 1)
		goto out;
523

I
Ingo Molnar 已提交
524 525
	index_msb = get_count_order(smp_num_siblings);
	c->phys_proc_id = apic->phys_pkg_id(c->initial_apicid, index_msb);
526

I
Ingo Molnar 已提交
527
	smp_num_siblings = smp_num_siblings / c->x86_max_cores;
528

I
Ingo Molnar 已提交
529
	index_msb = get_count_order(smp_num_siblings);
530

I
Ingo Molnar 已提交
531
	core_bits = get_count_order(c->x86_max_cores);
532

I
Ingo Molnar 已提交
533 534
	c->cpu_core_id = apic->phys_pkg_id(c->initial_apicid, index_msb) &
				       ((1 << core_bits) - 1);
L
Linus Torvalds 已提交
535

536
out:
537
	if (!printed && (c->x86_max_cores * smp_num_siblings) > 1) {
538 539 540 541
		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);
542
		printed = 1;
543 544
	}
#endif
545
}
L
Linus Torvalds 已提交
546

547
static void get_cpu_vendor(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
548 549
{
	char *v = c->x86_vendor_id;
I
Ingo Molnar 已提交
550
	int i;
L
Linus Torvalds 已提交
551 552

	for (i = 0; i < X86_VENDOR_NUM; i++) {
Y
Yinghai Lu 已提交
553 554 555 556 557 558
		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]))) {
I
Ingo Molnar 已提交
559

Y
Yinghai Lu 已提交
560 561 562
			this_cpu = cpu_devs[i];
			c->x86_vendor = this_cpu->c_x86_vendor;
			return;
L
Linus Torvalds 已提交
563 564
		}
	}
Y
Yinghai Lu 已提交
565

566 567 568
	printk_once(KERN_ERR
			"CPU: vendor_id '%s' unknown, using generic init.\n" \
			"CPU: Your system may be unstable.\n", v);
Y
Yinghai Lu 已提交
569

570 571
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	this_cpu = &default_cpu;
L
Linus Torvalds 已提交
572 573
}

574
void cpu_detect(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
575 576
{
	/* Get vendor name */
577 578 579 580
	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]);
L
Linus Torvalds 已提交
581 582

	c->x86 = 4;
583
	/* Intel-defined flags: level 0x00000001 */
L
Linus Torvalds 已提交
584 585
	if (c->cpuid_level >= 0x00000001) {
		u32 junk, tfms, cap0, misc;
I
Ingo Molnar 已提交
586

L
Linus Torvalds 已提交
587
		cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
588 589 590
		c->x86 = (tfms >> 8) & 0xf;
		c->x86_model = (tfms >> 4) & 0xf;
		c->x86_mask = tfms & 0xf;
I
Ingo Molnar 已提交
591

592
		if (c->x86 == 0xf)
L
Linus Torvalds 已提交
593
			c->x86 += (tfms >> 20) & 0xff;
594
		if (c->x86 >= 0x6)
595
			c->x86_model += ((tfms >> 16) & 0xf) << 4;
I
Ingo Molnar 已提交
596

H
Huang, Ying 已提交
597 598
		if (cap0 & (1<<19)) {
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
599
			c->x86_cache_alignment = c->x86_clflush_size;
H
Huang, Ying 已提交
600
		}
L
Linus Torvalds 已提交
601 602
	}
}
603

604
void get_cpu_cap(struct cpuinfo_x86 *c)
605 606
{
	u32 tfms, xlvl;
607
	u32 ebx;
608

609 610 611
	/* Intel-defined flags: level 0x00000001 */
	if (c->cpuid_level >= 0x00000001) {
		u32 capability, excap;
I
Ingo Molnar 已提交
612

613 614 615 616
		cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
		c->x86_capability[0] = capability;
		c->x86_capability[4] = excap;
	}
617

618 619 620 621 622 623
	/* Additional Intel-defined flags: level 0x00000007 */
	if (c->cpuid_level >= 0x00000007) {
		u32 eax, ebx, ecx, edx;

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

624
		c->x86_capability[9] = ebx;
625 626
	}

627 628 629
	/* AMD-defined flags: level 0x80000001 */
	xlvl = cpuid_eax(0x80000000);
	c->extended_cpuid_level = xlvl;
I
Ingo Molnar 已提交
630

631 632 633 634
	if ((xlvl & 0xffff0000) == 0x80000000) {
		if (xlvl >= 0x80000001) {
			c->x86_capability[1] = cpuid_edx(0x80000001);
			c->x86_capability[6] = cpuid_ecx(0x80000001);
635 636 637
		}
	}

638 639 640 641 642
	if (c->extended_cpuid_level >= 0x80000008) {
		u32 eax = cpuid_eax(0x80000008);

		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
643
	}
644 645 646
#ifdef CONFIG_X86_32
	else if (cpu_has(c, X86_FEATURE_PAE) || cpu_has(c, X86_FEATURE_PSE36))
		c->x86_phys_bits = 36;
647
#endif
648 649 650

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

652
	init_scattered_cpuid_features(c);
653
}
L
Linus Torvalds 已提交
654

655
static void identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
Y
Yinghai Lu 已提交
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
{
#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
}

681 682 683 684 685 686 687 688 689
/*
 * 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.
 */
690
static void __init early_identify_cpu(struct cpuinfo_x86 *c)
691
{
692 693
#ifdef CONFIG_X86_64
	c->x86_clflush_size = 64;
694 695
	c->x86_phys_bits = 36;
	c->x86_virt_bits = 48;
696
#else
H
Huang, Ying 已提交
697
	c->x86_clflush_size = 32;
698 699
	c->x86_phys_bits = 32;
	c->x86_virt_bits = 32;
700
#endif
701
	c->x86_cache_alignment = c->x86_clflush_size;
702

703
	memset(&c->x86_capability, 0, sizeof c->x86_capability);
704
	c->extended_cpuid_level = 0;
705

Y
Yinghai Lu 已提交
706 707 708 709
	if (!have_cpuid_p())
		identify_cpu_without_cpuid(c);

	/* cyrix could have cpuid enabled via c_identify()*/
710 711 712 713
	if (!have_cpuid_p())
		return;

	cpu_detect(c);
714 715
	get_cpu_vendor(c);
	get_cpu_cap(c);
716
	fpu_detect(c);
717

Y
Yinghai Lu 已提交
718 719
	if (this_cpu->c_early_init)
		this_cpu->c_early_init(c);
720

721
	c->cpu_index = 0;
722
	filter_cpuid_features(c, false);
723

B
Borislav Petkov 已提交
724 725
	if (this_cpu->c_bsp_init)
		this_cpu->c_bsp_init(c);
726 727

	setup_force_cpu_cap(X86_FEATURE_ALWAYS);
728 729
}

730 731
void __init early_cpu_init(void)
{
732
	const struct cpu_dev *const *cdev;
Y
Yinghai Lu 已提交
733 734
	int count = 0;

735
#ifdef CONFIG_PROCESSOR_SELECT
736
	printk(KERN_INFO "KERNEL supported cpus:\n");
737 738
#endif

Y
Yinghai Lu 已提交
739
	for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
740
		const struct cpu_dev *cpudev = *cdev;
741

Y
Yinghai Lu 已提交
742 743 744 745 746
		if (count >= X86_VENDOR_NUM)
			break;
		cpu_devs[count] = cpudev;
		count++;

747
#ifdef CONFIG_PROCESSOR_SELECT
748 749 750 751 752 753 754 755 756
		{
			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]);
			}
Y
Yinghai Lu 已提交
757
		}
758
#endif
Y
Yinghai Lu 已提交
759
	}
760
	early_identify_cpu(&boot_cpu_data);
761
}
762

763
/*
B
Borislav Petkov 已提交
764 765 766 767 768
 * 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
769
 * unless we can find a reliable way to detect all the broken cases.
B
Borislav Petkov 已提交
770
 * Enable it explicitly on 64-bit for non-constant inputs of cpu_has().
771
 */
772
static void detect_nopl(struct cpuinfo_x86 *c)
773
{
B
Borislav Petkov 已提交
774
#ifdef CONFIG_X86_32
775
	clear_cpu_cap(c, X86_FEATURE_NOPL);
B
Borislav Petkov 已提交
776 777 778
#else
	set_cpu_cap(c, X86_FEATURE_NOPL);
#endif
779 780
}

781
static void generic_identify(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
782
{
Y
Yinghai Lu 已提交
783
	c->extended_cpuid_level = 0;
L
Linus Torvalds 已提交
784

785
	if (!have_cpuid_p())
Y
Yinghai Lu 已提交
786
		identify_cpu_without_cpuid(c);
787

Y
Yinghai Lu 已提交
788
	/* cyrix could have cpuid enabled via c_identify()*/
I
Ingo Molnar 已提交
789
	if (!have_cpuid_p())
Y
Yinghai Lu 已提交
790
		return;
L
Linus Torvalds 已提交
791

792
	cpu_detect(c);
L
Linus Torvalds 已提交
793

794
	get_cpu_vendor(c);
L
Linus Torvalds 已提交
795

796
	get_cpu_cap(c);
L
Linus Torvalds 已提交
797

798 799
	if (c->cpuid_level >= 0x00000001) {
		c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xFF;
800 801
#ifdef CONFIG_X86_32
# ifdef CONFIG_X86_HT
802
		c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
803
# else
804
		c->apicid = c->initial_apicid;
805 806 807
# endif
#endif
		c->phys_proc_id = c->initial_apicid;
808
	}
L
Linus Torvalds 已提交
809

810
	get_model_name(c); /* Default name */
L
Linus Torvalds 已提交
811

812
	detect_nopl(c);
L
Linus Torvalds 已提交
813 814 815 816 817
}

/*
 * This does the hard work of actually picking apart the CPU stuff...
 */
818
static void identify_cpu(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
819 820 821 822 823 824 825 826 827
{
	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 */
828
	c->x86_max_cores = 1;
829
	c->x86_coreid_bits = 0;
830
#ifdef CONFIG_X86_64
831
	c->x86_clflush_size = 64;
832 833
	c->x86_phys_bits = 36;
	c->x86_virt_bits = 48;
834 835
#else
	c->cpuid_level = -1;	/* CPUID not detected */
836
	c->x86_clflush_size = 32;
837 838
	c->x86_phys_bits = 32;
	c->x86_virt_bits = 32;
839 840
#endif
	c->x86_cache_alignment = c->x86_clflush_size;
L
Linus Torvalds 已提交
841 842 843 844
	memset(&c->x86_capability, 0, sizeof c->x86_capability);

	generic_identify(c);

845
	if (this_cpu->c_identify)
L
Linus Torvalds 已提交
846 847
		this_cpu->c_identify(c);

848 849 850 851 852 853
	/* 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];
	}

854
#ifdef CONFIG_X86_64
855
	c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
856 857
#endif

L
Linus Torvalds 已提交
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
	/*
	 * 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);

874 875 876 877
	/* Set up SMEP/SMAP */
	setup_smep(c);
	setup_smap(c);

L
Linus Torvalds 已提交
878
	/*
I
Ingo Molnar 已提交
879 880
	 * The vendor-specific functions might have changed features.
	 * Now we do "generic changes."
L
Linus Torvalds 已提交
881 882
	 */

883 884 885
	/* Filter out anything that depends on CPUID levels we don't have */
	filter_cpuid_features(c, true);

L
Linus Torvalds 已提交
886
	/* If the model name is still unset, do table lookup. */
887
	if (!c->x86_model_id[0]) {
888
		const char *p;
L
Linus Torvalds 已提交
889
		p = table_lookup_model(c);
890
		if (p)
L
Linus Torvalds 已提交
891 892 893 894
			strcpy(c->x86_model_id, p);
		else
			/* Last resort... */
			sprintf(c->x86_model_id, "%02x/%02x",
895
				c->x86, c->x86_model);
L
Linus Torvalds 已提交
896 897
	}

898 899 900 901
#ifdef CONFIG_X86_64
	detect_ht(c);
#endif

902
	init_hypervisor(c);
903
	x86_init_rdrand(c);
904 905 906 907 908 909 910 911 912 913

	/*
	 * 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];
	}

L
Linus Torvalds 已提交
914 915 916 917 918 919
	/*
	 * 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.
	 */
920
	if (c != &boot_cpu_data) {
L
Linus Torvalds 已提交
921
		/* AND the already accumulated flags with these */
922
		for (i = 0; i < NCAPINTS; i++)
L
Linus Torvalds 已提交
923
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
924 925 926 927

		/* OR, i.e. replicate the bug flags */
		for (i = NCAPINTS; i < NCAPINTS + NBUGINTS; i++)
			c->x86_capability[i] |= boot_cpu_data.x86_capability[i];
L
Linus Torvalds 已提交
928 929 930
	}

	/* Init Machine Check Exception if available. */
931
	mcheck_cpu_init(c);
932 933

	select_idle_routine(c);
934

935
#ifdef CONFIG_NUMA
936 937
	numa_add_cpu(smp_processor_id());
#endif
938
}
S
Shaohua Li 已提交
939

940 941 942 943 944 945 946 947 948 949
#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;
}
#endif

950 951 952
void __init identify_boot_cpu(void)
{
	identify_cpu(&boot_cpu_data);
953
	init_amd_e400_c1e_mask();
954
#ifdef CONFIG_X86_32
955
	sysenter_setup();
L
Li Shaohua 已提交
956
	enable_sep_cpu();
957 958
#else
	vgetcpu_set_mode();
959
#endif
960
	cpu_detect_tlb(&boot_cpu_data);
961
}
S
Shaohua Li 已提交
962

963
void identify_secondary_cpu(struct cpuinfo_x86 *c)
964 965 966
{
	BUG_ON(c == &boot_cpu_data);
	identify_cpu(c);
967
#ifdef CONFIG_X86_32
968
	enable_sep_cpu();
969
#endif
970
	mtrr_ap_init();
L
Linus Torvalds 已提交
971 972
}

973
struct msr_range {
I
Ingo Molnar 已提交
974 975
	unsigned	min;
	unsigned	max;
976
};
L
Linus Torvalds 已提交
977

978
static const struct msr_range msr_range_array[] = {
979 980 981 982 983
	{ 0x00000000, 0x00000418},
	{ 0xc0000000, 0xc000040b},
	{ 0xc0010000, 0xc0010142},
	{ 0xc0011000, 0xc001103b},
};
L
Linus Torvalds 已提交
984

985
static void __print_cpu_msr(void)
986
{
I
Ingo Molnar 已提交
987
	unsigned index_min, index_max;
988 989 990 991 992 993 994
	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;
I
Ingo Molnar 已提交
995

996
		for (index = index_min; index < index_max; index++) {
997
			if (rdmsrl_safe(index, &val))
998 999
				continue;
			printk(KERN_INFO " MSR%08x: %016llx\n", index, val);
L
Linus Torvalds 已提交
1000
		}
1001 1002
	}
}
1003

1004
static int show_msr;
I
Ingo Molnar 已提交
1005

1006 1007 1008
static __init int setup_show_msr(char *arg)
{
	int num;
1009

1010
	get_option(&arg, &num);
1011

1012 1013 1014
	if (num > 0)
		show_msr = num;
	return 1;
L
Linus Torvalds 已提交
1015
}
1016
__setup("show_msr=", setup_show_msr);
L
Linus Torvalds 已提交
1017

A
Andi Kleen 已提交
1018 1019 1020 1021 1022 1023 1024
static __init int setup_noclflush(char *arg)
{
	setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
	return 1;
}
__setup("noclflush", setup_noclflush);

1025
void print_cpu_info(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
1026
{
1027
	const char *vendor = NULL;
L
Linus Torvalds 已提交
1028

I
Ingo Molnar 已提交
1029
	if (c->x86_vendor < X86_VENDOR_NUM) {
L
Linus Torvalds 已提交
1030
		vendor = this_cpu->c_vendor;
I
Ingo Molnar 已提交
1031 1032 1033 1034
	} else {
		if (c->cpuid_level >= 0)
			vendor = c->x86_vendor_id;
	}
L
Linus Torvalds 已提交
1035

1036
	if (vendor && !strstr(c->x86_model_id, vendor))
1037
		printk(KERN_CONT "%s ", vendor);
L
Linus Torvalds 已提交
1038

1039
	if (c->x86_model_id[0])
1040
		printk(KERN_CONT "%s", strim(c->x86_model_id));
L
Linus Torvalds 已提交
1041
	else
1042
		printk(KERN_CONT "%d86", c->x86);
L
Linus Torvalds 已提交
1043

1044 1045
	printk(KERN_CONT " (fam: %02x, model: %02x", c->x86, c->x86_model);

1046
	if (c->x86_mask || c->cpuid_level >= 0)
1047
		printk(KERN_CONT ", stepping: %02x)\n", c->x86_mask);
L
Linus Torvalds 已提交
1048
	else
1049
		printk(KERN_CONT ")\n");
1050

1051
	print_cpu_msr(c);
1052 1053
}

1054
void print_cpu_msr(struct cpuinfo_x86 *c)
1055
{
1056
	if (c->cpu_index < show_msr)
1057
		__print_cpu_msr();
L
Linus Torvalds 已提交
1058 1059
}

1060 1061 1062
static __init int setup_disablecpuid(char *arg)
{
	int bit;
I
Ingo Molnar 已提交
1063

1064 1065 1066 1067
	if (get_option(&arg, &bit) && bit < NCAPINTS*32)
		setup_clear_cpu_cap(bit);
	else
		return 0;
I
Ingo Molnar 已提交
1068

1069 1070 1071 1072
	return 1;
}
__setup("clearcpuid=", setup_disablecpuid);

1073
#ifdef CONFIG_X86_64
1074
struct desc_ptr idt_descr = { NR_VECTORS * 16 - 1, (unsigned long) idt_table };
1075 1076
struct desc_ptr debug_idt_descr = { NR_VECTORS * 16 - 1,
				    (unsigned long) debug_idt_table };
1077

1078 1079
DEFINE_PER_CPU_FIRST(union irq_stack_union,
		     irq_stack_union) __aligned(PAGE_SIZE);
I
Ingo Molnar 已提交
1080

1081 1082 1083 1084 1085 1086 1087
/*
 * The following four percpu variables are hot.  Align current_task to
 * cacheline size such that all four fall in the same cacheline.
 */
DEFINE_PER_CPU(struct task_struct *, current_task) ____cacheline_aligned =
	&init_task;
EXPORT_PER_CPU_SYMBOL(current_task);
1088

1089 1090 1091 1092
DEFINE_PER_CPU(unsigned long, kernel_stack) =
	(unsigned long)&init_thread_union - KERNEL_STACK_OFFSET + THREAD_SIZE;
EXPORT_PER_CPU_SYMBOL(kernel_stack);

1093 1094 1095
DEFINE_PER_CPU(char *, irq_stack_ptr) =
	init_per_cpu_var(irq_stack_union.irq_stack) + IRQ_STACK_SIZE - 64;

1096
DEFINE_PER_CPU(unsigned int, irq_count) = -1;
1097

1098 1099
DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);

I
Ingo Molnar 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
/*
 * Special IST stacks which the CPU switches to when it calls
 * an IST-marked descriptor entry. Up to 7 stacks (hardware
 * limit), all of them are 4K, except the debug stack which
 * is 8K.
 */
static const unsigned int exception_stack_sizes[N_EXCEPTION_STACKS] = {
	  [0 ... N_EXCEPTION_STACKS - 1]	= EXCEPTION_STKSZ,
	  [DEBUG_STACK - 1]			= DEBUG_STKSZ
};

1111
static DEFINE_PER_CPU_PAGE_ALIGNED(char, exception_stacks
1112
	[(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ]);
1113 1114 1115

/* May not be marked __init: used by software suspend */
void syscall_init(void)
L
Linus Torvalds 已提交
1116
{
1117 1118 1119 1120 1121 1122 1123 1124
	/*
	 * LSTAR and STAR live in a bit strange symbiosis.
	 * They both write to the same internal register. STAR allows to
	 * set CS/DS but only a 32bit target. LSTAR sets the 64bit rip.
	 */
	wrmsrl(MSR_STAR,  ((u64)__USER32_CS)<<48  | ((u64)__KERNEL_CS)<<32);
	wrmsrl(MSR_LSTAR, system_call);
	wrmsrl(MSR_CSTAR, ignore_sysret);
1125

1126 1127 1128
#ifdef CONFIG_IA32_EMULATION
	syscall32_cpu_init();
#endif
1129

1130 1131
	/* Flags to clear on syscall */
	wrmsrl(MSR_SYSCALL_MASK,
1132 1133
	       X86_EFLAGS_TF|X86_EFLAGS_DF|X86_EFLAGS_IF|
	       X86_EFLAGS_IOPL|X86_EFLAGS_AC);
L
Linus Torvalds 已提交
1134
}
1135

1136 1137 1138 1139 1140 1141
/*
 * Copies of the original ist values from the tss are only accessed during
 * debugging, no special alignment required.
 */
DEFINE_PER_CPU(struct orig_ist, orig_ist);

1142
static DEFINE_PER_CPU(unsigned long, debug_stack_addr);
1143
DEFINE_PER_CPU(int, debug_stack_usage);
1144 1145 1146

int is_debug_stack(unsigned long addr)
{
1147 1148 1149
	return __get_cpu_var(debug_stack_usage) ||
		(addr <= __get_cpu_var(debug_stack_addr) &&
		 addr > (__get_cpu_var(debug_stack_addr) - DEBUG_STKSZ));
1150 1151
}

1152
DEFINE_PER_CPU(u32, debug_idt_ctr);
1153

1154 1155
void debug_stack_set_zero(void)
{
1156 1157
	this_cpu_inc(debug_idt_ctr);
	load_current_idt();
1158 1159 1160 1161
}

void debug_stack_reset(void)
{
1162
	if (WARN_ON(!this_cpu_read(debug_idt_ctr)))
1163
		return;
1164 1165
	if (this_cpu_dec_return(debug_idt_ctr) == 0)
		load_current_idt();
1166 1167
}

I
Ingo Molnar 已提交
1168
#else	/* CONFIG_X86_64 */
1169

1170 1171
DEFINE_PER_CPU(struct task_struct *, current_task) = &init_task;
EXPORT_PER_CPU_SYMBOL(current_task);
1172
DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);
1173

1174
#ifdef CONFIG_CC_STACKPROTECTOR
1175
DEFINE_PER_CPU_ALIGNED(struct stack_canary, stack_canary);
1176
#endif
1177

I
Ingo Molnar 已提交
1178
#endif	/* CONFIG_X86_64 */
1179

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
/*
 * Clear all 6 debug registers:
 */
static void clear_all_debug_regs(void)
{
	int i;

	for (i = 0; i < 8; i++) {
		/* Ignore db4, db5 */
		if ((i == 4) || (i == 5))
			continue;

		set_debugreg(0, i);
	}
}
1195

1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
#ifdef CONFIG_KGDB
/*
 * Restore debug regs if using kgdbwait and you have a kernel debugger
 * connection established.
 */
static void dbg_restore_debug_regs(void)
{
	if (unlikely(kgdb_connected && arch_kgdb_ops.correct_hw_break))
		arch_kgdb_ops.correct_hw_break();
}
#else /* ! CONFIG_KGDB */
#define dbg_restore_debug_regs()
#endif /* ! CONFIG_KGDB */

1210 1211 1212 1213 1214
/*
 * cpu_init() initializes state that is per-CPU. Some data is already
 * initialized (naturally) in the bootstrap process, such as the GDT
 * and IDT. We reload them nevertheless, this function acts as a
 * 'CPU state barrier', nothing should get across.
1215
 * A lot of state is already set up in PDA init for 64 bit
1216
 */
1217
#ifdef CONFIG_X86_64
I
Ingo Molnar 已提交
1218

1219
void cpu_init(void)
1220
{
1221
	struct orig_ist *oist;
1222
	struct task_struct *me;
I
Ingo Molnar 已提交
1223 1224 1225
	struct tss_struct *t;
	unsigned long v;
	int cpu;
1226 1227
	int i;

1228 1229 1230 1231 1232 1233
	/*
	 * Load microcode on this cpu if a valid microcode is available.
	 * This is early microcode loading procedure.
	 */
	load_ucode_ap();

I
Ingo Molnar 已提交
1234 1235
	cpu = stack_smp_processor_id();
	t = &per_cpu(init_tss, cpu);
1236
	oist = &per_cpu(orig_ist, cpu);
I
Ingo Molnar 已提交
1237

1238
#ifdef CONFIG_NUMA
1239
	if (this_cpu_read(numa_node) == 0 &&
1240 1241
	    early_cpu_to_node(cpu) != NUMA_NO_NODE)
		set_numa_node(early_cpu_to_node(cpu));
1242
#endif
1243 1244 1245

	me = current;

1246
	if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask))
1247 1248
		panic("CPU#%d already initialized!\n", cpu);

1249
	pr_debug("Initializing CPU#%d\n", cpu);
1250 1251 1252 1253 1254 1255 1256 1257

	clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);

	/*
	 * Initialize the per-CPU GDT with the boot GDT,
	 * and set up the GDT descriptor:
	 */

1258
	switch_to_new_gdt(cpu);
1259 1260
	loadsegment(fs, 0);

1261
	load_current_idt();
1262 1263 1264 1265 1266 1267 1268 1269

	memset(me->thread.tls_array, 0, GDT_ENTRY_TLS_ENTRIES * 8);
	syscall_init();

	wrmsrl(MSR_FS_BASE, 0);
	wrmsrl(MSR_KERNEL_GS_BASE, 0);
	barrier();

1270
	x86_configure_nx();
1271
	enable_x2apic();
1272 1273 1274 1275

	/*
	 * set up and load the per-CPU TSS
	 */
1276
	if (!oist->ist[0]) {
1277
		char *estacks = per_cpu(exception_stacks, cpu);
I
Ingo Molnar 已提交
1278

1279
		for (v = 0; v < N_EXCEPTION_STACKS; v++) {
I
Ingo Molnar 已提交
1280
			estacks += exception_stack_sizes[v];
1281
			oist->ist[v] = t->x86_tss.ist[v] =
1282
					(unsigned long)estacks;
1283 1284
			if (v == DEBUG_STACK-1)
				per_cpu(debug_stack_addr, cpu) = (unsigned long)estacks;
1285 1286 1287 1288
		}
	}

	t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);
I
Ingo Molnar 已提交
1289

1290 1291 1292 1293 1294 1295 1296 1297 1298
	/*
	 * <= is required because the CPU will access up to
	 * 8 bits beyond the end of the IO permission bitmap.
	 */
	for (i = 0; i <= IO_BITMAP_LONGS; i++)
		t->io_bitmap[i] = ~0UL;

	atomic_inc(&init_mm.mm_count);
	me->active_mm = &init_mm;
S
Stoyan Gaydarov 已提交
1299
	BUG_ON(me->mm);
1300 1301 1302 1303 1304 1305 1306
	enter_lazy_tlb(&init_mm, me);

	load_sp0(t, &current->thread);
	set_tss_desc(cpu, t);
	load_TR_desc();
	load_LDT(&init_mm.context);

1307 1308
	clear_all_debug_regs();
	dbg_restore_debug_regs();
1309 1310 1311 1312 1313 1314 1315 1316 1317

	fpu_init();

	if (is_uv_system())
		uv_cpu_init();
}

#else

1318
void cpu_init(void)
1319
{
1320 1321
	int cpu = smp_processor_id();
	struct task_struct *curr = current;
1322
	struct tss_struct *t = &per_cpu(init_tss, cpu);
1323
	struct thread_struct *thread = &curr->thread;
1324

1325 1326
	show_ucode_info_early();

1327
	if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) {
1328
		printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
1329 1330
		for (;;)
			local_irq_enable();
1331 1332 1333 1334 1335 1336 1337
	}

	printk(KERN_INFO "Initializing CPU#%d\n", cpu);

	if (cpu_has_vme || cpu_has_tsc || cpu_has_de)
		clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);

1338
	load_current_idt();
1339
	switch_to_new_gdt(cpu);
L
Linus Torvalds 已提交
1340 1341 1342 1343 1344

	/*
	 * Set up and load the per-CPU TSS and LDT
	 */
	atomic_inc(&init_mm.mm_count);
1345
	curr->active_mm = &init_mm;
S
Stoyan Gaydarov 已提交
1346
	BUG_ON(curr->mm);
1347
	enter_lazy_tlb(&init_mm, curr);
L
Linus Torvalds 已提交
1348

1349
	load_sp0(t, thread);
1350
	set_tss_desc(cpu, t);
L
Linus Torvalds 已提交
1351 1352 1353
	load_TR_desc();
	load_LDT(&init_mm.context);

1354 1355
	t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);

1356
#ifdef CONFIG_DOUBLEFAULT
L
Linus Torvalds 已提交
1357 1358
	/* Set up doublefault TSS pointer in the GDT */
	__set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
1359
#endif
L
Linus Torvalds 已提交
1360

1361
	clear_all_debug_regs();
1362
	dbg_restore_debug_regs();
L
Linus Torvalds 已提交
1363

1364
	fpu_init();
L
Linus Torvalds 已提交
1365
}
1366
#endif
1367 1368 1369 1370 1371 1372 1373 1374

#ifdef CONFIG_X86_DEBUG_STATIC_CPU_HAS
void warn_pre_alternatives(void)
{
	WARN(1, "You're using static_cpu_has before alternatives have run!\n");
}
EXPORT_SYMBOL_GPL(warn_pre_alternatives);
#endif
1375 1376 1377 1378 1379 1380

inline bool __static_cpu_has_safe(u16 bit)
{
	return boot_cpu_has(bit);
}
EXPORT_SYMBOL_GPL(__static_cpu_has_safe);