common.c 32.3 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

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

#include "cpu.h"

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

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

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

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

static const struct cpu_dev __cpuinitconst default_cpu = {
	.c_init		= default_init,
	.c_vendor	= "Unknown",
	.c_x86_vendor	= X86_VENDOR_UNKNOWN,
};

static const struct cpu_dev *this_cpu __cpuinitdata = &default_cpu;
88

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

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

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

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

160
#ifdef CONFIG_X86_32
161 162
static int cachesize_override __cpuinitdata = -1;
static int disable_x86_serial_nr __cpuinitdata = 1;
L
Linus Torvalds 已提交
163

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

191 192 193 194 195 196 197
	/*
	 * 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 已提交
198 199 200 201 202 203 204 205 206 207 208
	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"

209 210
		      : "=&r" (f1), "=&r" (f2)
		      : "ir" (flag));
211 212 213 214 215 216 217 218 219 220 221 222

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

/* Probe for the CPUID instruction */
static int __cpuinit have_cpuid_p(void)
{
	return flag_is_changeable_p(X86_EFLAGS_ID);
}

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

static int __init x86_serial_nr_setup(char *s)
{
	disable_x86_serial_nr = 0;
	return 1;
}
__setup("serialnumber", x86_serial_nr_setup);
247
#else
248 249 250 251
static inline int flag_is_changeable_p(u32 flag)
{
	return 1;
}
252 253 254 255 256
/* Probe for the CPUID instruction */
static inline int have_cpuid_p(void)
{
	return 1;
}
257 258 259
static inline void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
{
}
260
#endif
261

262
static int disable_smep __cpuinitdata;
263 264 265 266 267 268 269
static __init int setup_disable_smep(char *arg)
{
	disable_smep = 1;
	return 1;
}
__setup("nosmep", setup_disable_smep);

270
static __cpuinit void setup_smep(struct cpuinfo_x86 *c)
271 272 273 274 275 276 277 278 279 280
{
	if (cpu_has(c, X86_FEATURE_SMEP)) {
		if (unlikely(disable_smep)) {
			setup_clear_cpu_cap(X86_FEATURE_SMEP);
			clear_in_cr4(X86_CR4_SMEP);
		} else
			set_in_cr4(X86_CR4_SMEP);
	}
}

281 282 283 284 285 286 287 288 289
/*
 * 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 已提交
290

291 292 293 294 295 296 297 298 299 300 301
static const struct cpuid_dependent_feature __cpuinitconst
cpuid_dependent_features[] = {
	{ X86_FEATURE_MWAIT,		0x00000005 },
	{ X86_FEATURE_DCA,		0x00000009 },
	{ X86_FEATURE_XSAVE,		0x0000000d },
	{ 0, 0 }
};

static void __cpuinit filter_cpuid_features(struct cpuinfo_x86 *c, bool warn)
{
	const struct cpuid_dependent_feature *df;
302

303
	for (df = cpuid_dependent_features; df->feature; df++) {
I
Ingo Molnar 已提交
304 305 306

		if (!cpu_has(c, df->feature))
			continue;
307 308 309 310 311 312 313
		/*
		 * 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 已提交
314
		if (!((s32)df->level < 0 ?
315
		     (u32)df->level > (u32)c->extended_cpuid_level :
I
Ingo Molnar 已提交
316 317 318 319 320 321 322 323 324 325
		     (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);
326
	}
327
}
328

329 330 331
/*
 * Naming convention should be: <Name> [(<Codename>)]
 * This table only is used unless init_<vendor>() below doesn't set it;
I
Ingo Molnar 已提交
332 333
 * in particular, if CPUID levels 0x80000002..4 are supported, this
 * isn't used
334 335 336
 */

/* Look up CPU names by table lookup. */
337
static const char *__cpuinit table_lookup_model(struct cpuinfo_x86 *c)
338
{
339
	const struct cpu_model_info *info;
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356

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

357 358
__u32 cpu_caps_cleared[NCAPINTS] __cpuinitdata;
__u32 cpu_caps_set[NCAPINTS] __cpuinitdata;
359

360 361 362 363 364 365 366 367
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
368
	load_stack_canary_segment();
369 370
}

I
Ingo Molnar 已提交
371 372 373 374
/*
 * Current gdt points %fs at the "master" per-cpu area: after this,
 * it's on the real one.
 */
375
void switch_to_new_gdt(int cpu)
376 377 378
{
	struct desc_ptr gdt_descr;

379
	gdt_descr.address = (long)get_cpu_gdt_table(cpu);
380 381
	gdt_descr.size = GDT_SIZE - 1;
	load_gdt(&gdt_descr);
382
	/* Reload the per-cpu base */
383 384

	load_percpu_segment(cpu);
385 386
}

387
static const struct cpu_dev *__cpuinitdata cpu_devs[X86_VENDOR_NUM] = {};
L
Linus Torvalds 已提交
388

389
static void __cpuinit get_model_name(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
390 391 392 393
{
	unsigned int *v;
	char *p, *q;

394
	if (c->extended_cpuid_level < 0x80000004)
395
		return;
L
Linus Torvalds 已提交
396

I
Ingo Molnar 已提交
397
	v = (unsigned int *)c->x86_model_id;
L
Linus Torvalds 已提交
398 399 400 401 402
	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 已提交
403 404 405 406
	/*
	 * Intel chips right-justify this string for some dumb reason;
	 * undo that brain damage:
	 */
L
Linus Torvalds 已提交
407
	p = q = &c->x86_model_id[0];
408
	while (*p == ' ')
409
		p++;
410
	if (p != q) {
411 412 413 414
		while (*p)
			*q++ = *p++;
		while (q <= &c->x86_model_id[48])
			*q++ = '\0';	/* Zero-pad the rest */
L
Linus Torvalds 已提交
415 416 417
	}
}

418
void __cpuinit cpu_detect_cache_sizes(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
419
{
420
	unsigned int n, dummy, ebx, ecx, edx, l2size;
L
Linus Torvalds 已提交
421

422
	n = c->extended_cpuid_level;
L
Linus Torvalds 已提交
423 424

	if (n >= 0x80000005) {
425 426
		cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
		c->x86_cache_size = (ecx>>24) + (edx>>24);
427 428 429 430
#ifdef CONFIG_X86_64
		/* On K8 L1 TLB is inclusive, so don't count it */
		c->x86_tlbsize = 0;
#endif
L
Linus Torvalds 已提交
431 432 433 434 435
	}

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

436
	cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
L
Linus Torvalds 已提交
437
	l2size = ecx >> 16;
438

439 440 441
#ifdef CONFIG_X86_64
	c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
#else
L
Linus Torvalds 已提交
442 443
	/* do processor-specific cache resizing */
	if (this_cpu->c_size_cache)
444
		l2size = this_cpu->c_size_cache(c, l2size);
L
Linus Torvalds 已提交
445 446 447 448 449

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

450
	if (l2size == 0)
L
Linus Torvalds 已提交
451
		return;		/* Again, no L2 cache is possible */
452
#endif
L
Linus Torvalds 已提交
453 454 455 456

	c->x86_cache_size = l2size;
}

457 458 459 460 461 462 463
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];

464 465 466 467 468 469 470 471
/*
 * 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;

472 473 474 475 476 477
void __cpuinit cpu_detect_tlb(struct cpuinfo_x86 *c)
{
	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" \
478 479
		"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n"	     \
		"tlb_flushall_shift is 0x%x\n",
480 481
		tlb_lli_4k[ENTRIES], tlb_lli_2m[ENTRIES],
		tlb_lli_4m[ENTRIES], tlb_lld_4k[ENTRIES],
482 483
		tlb_lld_2m[ENTRIES], tlb_lld_4m[ENTRIES],
		tlb_flushall_shift);
484 485
}

486
void __cpuinit detect_ht(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
487
{
488
#ifdef CONFIG_X86_HT
489 490
	u32 eax, ebx, ecx, edx;
	int index_msb, core_bits;
491
	static bool printed;
L
Linus Torvalds 已提交
492

493
	if (!cpu_has(c, X86_FEATURE_HT))
494
		return;
L
Linus Torvalds 已提交
495

496 497
	if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
		goto out;
L
Linus Torvalds 已提交
498

499 500
	if (cpu_has(c, X86_FEATURE_XTOPOLOGY))
		return;
L
Linus Torvalds 已提交
501

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

504 505 506
	smp_num_siblings = (ebx & 0xff0000) >> 16;

	if (smp_num_siblings == 1) {
507
		printk_once(KERN_INFO "CPU0: Hyper-Threading is disabled\n");
I
Ingo Molnar 已提交
508 509
		goto out;
	}
510

I
Ingo Molnar 已提交
511 512
	if (smp_num_siblings <= 1)
		goto out;
513

I
Ingo Molnar 已提交
514 515
	index_msb = get_count_order(smp_num_siblings);
	c->phys_proc_id = apic->phys_pkg_id(c->initial_apicid, index_msb);
516

I
Ingo Molnar 已提交
517
	smp_num_siblings = smp_num_siblings / c->x86_max_cores;
518

I
Ingo Molnar 已提交
519
	index_msb = get_count_order(smp_num_siblings);
520

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

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

526
out:
527
	if (!printed && (c->x86_max_cores * smp_num_siblings) > 1) {
528 529 530 531
		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);
532
		printed = 1;
533 534
	}
#endif
535
}
L
Linus Torvalds 已提交
536

537
static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
538 539
{
	char *v = c->x86_vendor_id;
I
Ingo Molnar 已提交
540
	int i;
L
Linus Torvalds 已提交
541 542

	for (i = 0; i < X86_VENDOR_NUM; i++) {
Y
Yinghai Lu 已提交
543 544 545 546 547 548
		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 已提交
549

Y
Yinghai Lu 已提交
550 551 552
			this_cpu = cpu_devs[i];
			c->x86_vendor = this_cpu->c_x86_vendor;
			return;
L
Linus Torvalds 已提交
553 554
		}
	}
Y
Yinghai Lu 已提交
555

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

560 561
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	this_cpu = &default_cpu;
L
Linus Torvalds 已提交
562 563
}

564
void __cpuinit cpu_detect(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
565 566
{
	/* Get vendor name */
567 568 569 570
	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 已提交
571 572

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

L
Linus Torvalds 已提交
577
		cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
578 579 580
		c->x86 = (tfms >> 8) & 0xf;
		c->x86_model = (tfms >> 4) & 0xf;
		c->x86_mask = tfms & 0xf;
I
Ingo Molnar 已提交
581

582
		if (c->x86 == 0xf)
L
Linus Torvalds 已提交
583
			c->x86 += (tfms >> 20) & 0xff;
584
		if (c->x86 >= 0x6)
585
			c->x86_model += ((tfms >> 16) & 0xf) << 4;
I
Ingo Molnar 已提交
586

H
Huang, Ying 已提交
587 588
		if (cap0 & (1<<19)) {
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
589
			c->x86_cache_alignment = c->x86_clflush_size;
H
Huang, Ying 已提交
590
		}
L
Linus Torvalds 已提交
591 592
	}
}
593

594
void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c)
595 596
{
	u32 tfms, xlvl;
597
	u32 ebx;
598

599 600 601
	/* Intel-defined flags: level 0x00000001 */
	if (c->cpuid_level >= 0x00000001) {
		u32 capability, excap;
I
Ingo Molnar 已提交
602

603 604 605 606
		cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
		c->x86_capability[0] = capability;
		c->x86_capability[4] = excap;
	}
607

608 609 610 611 612 613
	/* Additional Intel-defined flags: level 0x00000007 */
	if (c->cpuid_level >= 0x00000007) {
		u32 eax, ebx, ecx, edx;

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

614
		c->x86_capability[9] = ebx;
615 616
	}

617 618 619
	/* AMD-defined flags: level 0x80000001 */
	xlvl = cpuid_eax(0x80000000);
	c->extended_cpuid_level = xlvl;
I
Ingo Molnar 已提交
620

621 622 623 624
	if ((xlvl & 0xffff0000) == 0x80000000) {
		if (xlvl >= 0x80000001) {
			c->x86_capability[1] = cpuid_edx(0x80000001);
			c->x86_capability[6] = cpuid_ecx(0x80000001);
625 626 627
		}
	}

628 629 630 631 632
	if (c->extended_cpuid_level >= 0x80000008) {
		u32 eax = cpuid_eax(0x80000008);

		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
633
	}
634 635 636
#ifdef CONFIG_X86_32
	else if (cpu_has(c, X86_FEATURE_PAE) || cpu_has(c, X86_FEATURE_PSE36))
		c->x86_phys_bits = 36;
637
#endif
638 639 640

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

642
	init_scattered_cpuid_features(c);
643
}
L
Linus Torvalds 已提交
644

Y
Yinghai Lu 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
static void __cpuinit identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
{
#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
}

671 672 673 674 675 676 677 678 679
/*
 * 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.
 */
680
static void __init early_identify_cpu(struct cpuinfo_x86 *c)
681
{
682 683
#ifdef CONFIG_X86_64
	c->x86_clflush_size = 64;
684 685
	c->x86_phys_bits = 36;
	c->x86_virt_bits = 48;
686
#else
H
Huang, Ying 已提交
687
	c->x86_clflush_size = 32;
688 689
	c->x86_phys_bits = 32;
	c->x86_virt_bits = 32;
690
#endif
691
	c->x86_cache_alignment = c->x86_clflush_size;
692

693
	memset(&c->x86_capability, 0, sizeof c->x86_capability);
694
	c->extended_cpuid_level = 0;
695

Y
Yinghai Lu 已提交
696 697 698 699
	if (!have_cpuid_p())
		identify_cpu_without_cpuid(c);

	/* cyrix could have cpuid enabled via c_identify()*/
700 701 702 703 704
	if (!have_cpuid_p())
		return;

	cpu_detect(c);

705
	get_cpu_vendor(c);
706

707
	get_cpu_cap(c);
708

Y
Yinghai Lu 已提交
709 710
	if (this_cpu->c_early_init)
		this_cpu->c_early_init(c);
711

712
	c->cpu_index = 0;
713
	filter_cpuid_features(c, false);
714 715

	setup_smep(c);
B
Borislav Petkov 已提交
716 717 718

	if (this_cpu->c_bsp_init)
		this_cpu->c_bsp_init(c);
719 720
}

721 722
void __init early_cpu_init(void)
{
723
	const struct cpu_dev *const *cdev;
Y
Yinghai Lu 已提交
724 725
	int count = 0;

726
#ifdef CONFIG_PROCESSOR_SELECT
727
	printk(KERN_INFO "KERNEL supported cpus:\n");
728 729
#endif

Y
Yinghai Lu 已提交
730
	for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
731
		const struct cpu_dev *cpudev = *cdev;
732

Y
Yinghai Lu 已提交
733 734 735 736 737
		if (count >= X86_VENDOR_NUM)
			break;
		cpu_devs[count] = cpudev;
		count++;

738
#ifdef CONFIG_PROCESSOR_SELECT
739 740 741 742 743 744 745 746 747
		{
			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 已提交
748
		}
749
#endif
Y
Yinghai Lu 已提交
750
	}
751
	early_identify_cpu(&boot_cpu_data);
752
}
753

754
/*
B
Borislav Petkov 已提交
755 756 757 758 759
 * 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
760
 * unless we can find a reliable way to detect all the broken cases.
B
Borislav Petkov 已提交
761
 * Enable it explicitly on 64-bit for non-constant inputs of cpu_has().
762 763 764
 */
static void __cpuinit detect_nopl(struct cpuinfo_x86 *c)
{
B
Borislav Petkov 已提交
765
#ifdef CONFIG_X86_32
766
	clear_cpu_cap(c, X86_FEATURE_NOPL);
B
Borislav Petkov 已提交
767 768 769
#else
	set_cpu_cap(c, X86_FEATURE_NOPL);
#endif
770 771
}

772
static void __cpuinit generic_identify(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
773
{
Y
Yinghai Lu 已提交
774
	c->extended_cpuid_level = 0;
L
Linus Torvalds 已提交
775

776
	if (!have_cpuid_p())
Y
Yinghai Lu 已提交
777
		identify_cpu_without_cpuid(c);
778

Y
Yinghai Lu 已提交
779
	/* cyrix could have cpuid enabled via c_identify()*/
I
Ingo Molnar 已提交
780
	if (!have_cpuid_p())
Y
Yinghai Lu 已提交
781
		return;
L
Linus Torvalds 已提交
782

783
	cpu_detect(c);
L
Linus Torvalds 已提交
784

785
	get_cpu_vendor(c);
L
Linus Torvalds 已提交
786

787
	get_cpu_cap(c);
L
Linus Torvalds 已提交
788

789 790
	if (c->cpuid_level >= 0x00000001) {
		c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xFF;
791 792
#ifdef CONFIG_X86_32
# ifdef CONFIG_X86_HT
793
		c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
794
# else
795
		c->apicid = c->initial_apicid;
796 797 798
# endif
#endif
		c->phys_proc_id = c->initial_apicid;
799
	}
L
Linus Torvalds 已提交
800

801 802
	setup_smep(c);

803
	get_model_name(c); /* Default name */
L
Linus Torvalds 已提交
804

805
	detect_nopl(c);
L
Linus Torvalds 已提交
806 807 808 809 810
}

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

	generic_identify(c);

838
	if (this_cpu->c_identify)
L
Linus Torvalds 已提交
839 840
		this_cpu->c_identify(c);

841 842 843 844 845 846
	/* 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];
	}

847
#ifdef CONFIG_X86_64
848
	c->apicid = apic->phys_pkg_id(c->initial_apicid, 0);
849 850
#endif

L
Linus Torvalds 已提交
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
	/*
	 * 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);

	/*
I
Ingo Molnar 已提交
868 869
	 * The vendor-specific functions might have changed features.
	 * Now we do "generic changes."
L
Linus Torvalds 已提交
870 871
	 */

872 873 874
	/* Filter out anything that depends on CPUID levels we don't have */
	filter_cpuid_features(c, true);

L
Linus Torvalds 已提交
875
	/* If the model name is still unset, do table lookup. */
876
	if (!c->x86_model_id[0]) {
877
		const char *p;
L
Linus Torvalds 已提交
878
		p = table_lookup_model(c);
879
		if (p)
L
Linus Torvalds 已提交
880 881 882 883
			strcpy(c->x86_model_id, p);
		else
			/* Last resort... */
			sprintf(c->x86_model_id, "%02x/%02x",
884
				c->x86, c->x86_model);
L
Linus Torvalds 已提交
885 886
	}

887 888 889 890
#ifdef CONFIG_X86_64
	detect_ht(c);
#endif

891
	init_hypervisor(c);
892
	x86_init_rdrand(c);
893 894 895 896 897 898 899 900 901 902

	/*
	 * 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 已提交
903 904 905 906 907 908
	/*
	 * 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.
	 */
909
	if (c != &boot_cpu_data) {
L
Linus Torvalds 已提交
910
		/* AND the already accumulated flags with these */
911
		for (i = 0; i < NCAPINTS; i++)
L
Linus Torvalds 已提交
912 913 914 915
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
	}

	/* Init Machine Check Exception if available. */
916
	mcheck_cpu_init(c);
917 918

	select_idle_routine(c);
919

920
#ifdef CONFIG_NUMA
921 922
	numa_add_cpu(smp_processor_id());
#endif
923
}
S
Shaohua Li 已提交
924

925 926 927 928 929 930 931 932 933 934
#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

935 936 937
void __init identify_boot_cpu(void)
{
	identify_cpu(&boot_cpu_data);
938
	init_amd_e400_c1e_mask();
939
#ifdef CONFIG_X86_32
940
	sysenter_setup();
L
Li Shaohua 已提交
941
	enable_sep_cpu();
942 943
#else
	vgetcpu_set_mode();
944
#endif
945 946
	if (boot_cpu_data.cpuid_level >= 2)
		cpu_detect_tlb(&boot_cpu_data);
947
}
S
Shaohua Li 已提交
948

949 950 951 952
void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c)
{
	BUG_ON(c == &boot_cpu_data);
	identify_cpu(c);
953
#ifdef CONFIG_X86_32
954
	enable_sep_cpu();
955
#endif
956
	mtrr_ap_init();
L
Linus Torvalds 已提交
957 958
}

959
struct msr_range {
I
Ingo Molnar 已提交
960 961
	unsigned	min;
	unsigned	max;
962
};
L
Linus Torvalds 已提交
963

964
static const struct msr_range msr_range_array[] __cpuinitconst = {
965 966 967 968 969
	{ 0x00000000, 0x00000418},
	{ 0xc0000000, 0xc000040b},
	{ 0xc0010000, 0xc0010142},
	{ 0xc0011000, 0xc001103b},
};
L
Linus Torvalds 已提交
970

971
static void __cpuinit __print_cpu_msr(void)
972
{
I
Ingo Molnar 已提交
973
	unsigned index_min, index_max;
974 975 976 977 978 979 980
	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 已提交
981

982
		for (index = index_min; index < index_max; index++) {
983
			if (rdmsrl_safe(index, &val))
984 985
				continue;
			printk(KERN_INFO " MSR%08x: %016llx\n", index, val);
L
Linus Torvalds 已提交
986
		}
987 988
	}
}
989

990
static int show_msr __cpuinitdata;
I
Ingo Molnar 已提交
991

992 993 994
static __init int setup_show_msr(char *arg)
{
	int num;
995

996
	get_option(&arg, &num);
997

998 999 1000
	if (num > 0)
		show_msr = num;
	return 1;
L
Linus Torvalds 已提交
1001
}
1002
__setup("show_msr=", setup_show_msr);
L
Linus Torvalds 已提交
1003

A
Andi Kleen 已提交
1004 1005 1006 1007 1008 1009 1010
static __init int setup_noclflush(char *arg)
{
	setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
	return 1;
}
__setup("noclflush", setup_noclflush);

1011
void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
1012
{
1013
	const char *vendor = NULL;
L
Linus Torvalds 已提交
1014

I
Ingo Molnar 已提交
1015
	if (c->x86_vendor < X86_VENDOR_NUM) {
L
Linus Torvalds 已提交
1016
		vendor = this_cpu->c_vendor;
I
Ingo Molnar 已提交
1017 1018 1019 1020
	} else {
		if (c->cpuid_level >= 0)
			vendor = c->x86_vendor_id;
	}
L
Linus Torvalds 已提交
1021

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

1025 1026
	if (c->x86_model_id[0])
		printk(KERN_CONT "%s", c->x86_model_id);
L
Linus Torvalds 已提交
1027
	else
1028
		printk(KERN_CONT "%d86", c->x86);
L
Linus Torvalds 已提交
1029

1030
	if (c->x86_mask || c->cpuid_level >= 0)
1031
		printk(KERN_CONT " stepping %02x\n", c->x86_mask);
L
Linus Torvalds 已提交
1032
	else
1033
		printk(KERN_CONT "\n");
1034

1035
	print_cpu_msr(c);
1036 1037 1038 1039
}

void __cpuinit print_cpu_msr(struct cpuinfo_x86 *c)
{
1040
	if (c->cpu_index < show_msr)
1041
		__print_cpu_msr();
L
Linus Torvalds 已提交
1042 1043
}

1044 1045 1046
static __init int setup_disablecpuid(char *arg)
{
	int bit;
I
Ingo Molnar 已提交
1047

1048 1049 1050 1051
	if (get_option(&arg, &bit) && bit < NCAPINTS*32)
		setup_clear_cpu_cap(bit);
	else
		return 0;
I
Ingo Molnar 已提交
1052

1053 1054 1055 1056
	return 1;
}
__setup("clearcpuid=", setup_disablecpuid);

1057
#ifdef CONFIG_X86_64
1058
struct desc_ptr idt_descr = { NR_VECTORS * 16 - 1, (unsigned long) idt_table };
1059 1060
struct desc_ptr nmi_idt_descr = { NR_VECTORS * 16 - 1,
				    (unsigned long) nmi_idt_table };
1061

1062 1063
DEFINE_PER_CPU_FIRST(union irq_stack_union,
		     irq_stack_union) __aligned(PAGE_SIZE);
I
Ingo Molnar 已提交
1064

1065 1066 1067 1068 1069 1070 1071
/*
 * 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);
1072

1073 1074 1075 1076
DEFINE_PER_CPU(unsigned long, kernel_stack) =
	(unsigned long)&init_thread_union - KERNEL_STACK_OFFSET + THREAD_SIZE;
EXPORT_PER_CPU_SYMBOL(kernel_stack);

1077 1078 1079
DEFINE_PER_CPU(char *, irq_stack_ptr) =
	init_per_cpu_var(irq_stack_union.irq_stack) + IRQ_STACK_SIZE - 64;

1080
DEFINE_PER_CPU(unsigned int, irq_count) = -1;
1081

1082 1083
DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);

I
Ingo Molnar 已提交
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
/*
 * 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
};

1095
static DEFINE_PER_CPU_PAGE_ALIGNED(char, exception_stacks
1096
	[(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ]);
1097 1098 1099

/* May not be marked __init: used by software suspend */
void syscall_init(void)
L
Linus Torvalds 已提交
1100
{
1101 1102 1103 1104 1105 1106 1107 1108
	/*
	 * 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);
1109

1110 1111 1112
#ifdef CONFIG_IA32_EMULATION
	syscall32_cpu_init();
#endif
1113

1114 1115
	/* Flags to clear on syscall */
	wrmsrl(MSR_SYSCALL_MASK,
1116 1117
	       X86_EFLAGS_TF|X86_EFLAGS_DF|X86_EFLAGS_IF|
	       X86_EFLAGS_IOPL|X86_EFLAGS_AC);
L
Linus Torvalds 已提交
1118
}
1119

1120 1121 1122 1123 1124 1125 1126 1127
unsigned long kernel_eflags;

/*
 * 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);

1128
static DEFINE_PER_CPU(unsigned long, debug_stack_addr);
1129
DEFINE_PER_CPU(int, debug_stack_usage);
1130 1131 1132

int is_debug_stack(unsigned long addr)
{
1133 1134 1135
	return __get_cpu_var(debug_stack_usage) ||
		(addr <= __get_cpu_var(debug_stack_addr) &&
		 addr > (__get_cpu_var(debug_stack_addr) - DEBUG_STKSZ));
1136 1137
}

1138 1139
static DEFINE_PER_CPU(u32, debug_stack_use_ctr);

1140 1141
void debug_stack_set_zero(void)
{
1142
	this_cpu_inc(debug_stack_use_ctr);
1143 1144 1145 1146 1147
	load_idt((const struct desc_ptr *)&nmi_idt_descr);
}

void debug_stack_reset(void)
{
1148 1149 1150 1151
	if (WARN_ON(!this_cpu_read(debug_stack_use_ctr)))
		return;
	if (this_cpu_dec_return(debug_stack_use_ctr) == 0)
		load_idt((const struct desc_ptr *)&idt_descr);
1152 1153
}

I
Ingo Molnar 已提交
1154
#else	/* CONFIG_X86_64 */
1155

1156 1157
DEFINE_PER_CPU(struct task_struct *, current_task) = &init_task;
EXPORT_PER_CPU_SYMBOL(current_task);
1158
DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);
1159

1160
#ifdef CONFIG_CC_STACKPROTECTOR
1161
DEFINE_PER_CPU_ALIGNED(struct stack_canary, stack_canary);
1162
#endif
1163

1164
/* Make sure %fs and %gs are initialized properly in idle threads */
A
Adrian Bunk 已提交
1165
struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
1166 1167
{
	memset(regs, 0, sizeof(struct pt_regs));
1168
	regs->fs = __KERNEL_PERCPU;
1169
	regs->gs = __KERNEL_STACK_CANARY;
I
Ingo Molnar 已提交
1170

1171 1172
	return regs;
}
I
Ingo Molnar 已提交
1173
#endif	/* CONFIG_X86_64 */
1174

1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
/*
 * 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);
	}
}
1190

1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
#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 */

1205 1206 1207 1208 1209
/*
 * 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.
1210
 * A lot of state is already set up in PDA init for 64 bit
1211
 */
1212
#ifdef CONFIG_X86_64
I
Ingo Molnar 已提交
1213

1214 1215
void __cpuinit cpu_init(void)
{
1216
	struct orig_ist *oist;
1217
	struct task_struct *me;
I
Ingo Molnar 已提交
1218 1219 1220
	struct tss_struct *t;
	unsigned long v;
	int cpu;
1221 1222
	int i;

I
Ingo Molnar 已提交
1223 1224
	cpu = stack_smp_processor_id();
	t = &per_cpu(init_tss, cpu);
1225
	oist = &per_cpu(orig_ist, cpu);
I
Ingo Molnar 已提交
1226

1227
#ifdef CONFIG_NUMA
1228
	if (cpu != 0 && this_cpu_read(numa_node) == 0 &&
1229 1230
	    early_cpu_to_node(cpu) != NUMA_NO_NODE)
		set_numa_node(early_cpu_to_node(cpu));
1231
#endif
1232 1233 1234

	me = current;

1235
	if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask))
1236 1237
		panic("CPU#%d already initialized!\n", cpu);

1238
	pr_debug("Initializing CPU#%d\n", cpu);
1239 1240 1241 1242 1243 1244 1245 1246

	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:
	 */

1247
	switch_to_new_gdt(cpu);
1248 1249
	loadsegment(fs, 0);

1250 1251 1252 1253 1254 1255 1256 1257 1258
	load_idt((const struct desc_ptr *)&idt_descr);

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

1259
	x86_configure_nx();
Y
Yinghai Lu 已提交
1260
	if (cpu != 0)
1261 1262 1263 1264 1265
		enable_x2apic();

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

1269
		for (v = 0; v < N_EXCEPTION_STACKS; v++) {
I
Ingo Molnar 已提交
1270
			estacks += exception_stack_sizes[v];
1271
			oist->ist[v] = t->x86_tss.ist[v] =
1272
					(unsigned long)estacks;
1273 1274
			if (v == DEBUG_STACK-1)
				per_cpu(debug_stack_addr, cpu) = (unsigned long)estacks;
1275 1276 1277 1278
		}
	}

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

1280 1281 1282 1283 1284 1285 1286 1287 1288
	/*
	 * <= 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 已提交
1289
	BUG_ON(me->mm);
1290 1291 1292 1293 1294 1295 1296
	enter_lazy_tlb(&init_mm, me);

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

1297 1298
	clear_all_debug_regs();
	dbg_restore_debug_regs();
1299 1300

	fpu_init();
1301
	xsave_init();
1302 1303 1304 1305 1306 1307 1308 1309 1310

	raw_local_save_flags(kernel_eflags);

	if (is_uv_system())
		uv_cpu_init();
}

#else

1311
void __cpuinit cpu_init(void)
1312
{
1313 1314
	int cpu = smp_processor_id();
	struct task_struct *curr = current;
1315
	struct tss_struct *t = &per_cpu(init_tss, cpu);
1316
	struct thread_struct *thread = &curr->thread;
1317

1318
	if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) {
1319
		printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
1320 1321
		for (;;)
			local_irq_enable();
1322 1323 1324 1325 1326 1327 1328
	}

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

1329
	load_idt(&idt_descr);
1330
	switch_to_new_gdt(cpu);
L
Linus Torvalds 已提交
1331 1332 1333 1334 1335

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

1340
	load_sp0(t, thread);
1341
	set_tss_desc(cpu, t);
L
Linus Torvalds 已提交
1342 1343 1344
	load_TR_desc();
	load_LDT(&init_mm.context);

1345 1346
	t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);

1347
#ifdef CONFIG_DOUBLEFAULT
L
Linus Torvalds 已提交
1348 1349
	/* Set up doublefault TSS pointer in the GDT */
	__set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
1350
#endif
L
Linus Torvalds 已提交
1351

1352
	clear_all_debug_regs();
1353
	dbg_restore_debug_regs();
L
Linus Torvalds 已提交
1354

1355
	fpu_init();
1356
	xsave_init();
L
Linus Torvalds 已提交
1357
}
1358
#endif