xen: execve's error paths don't pin the mm before unpinning
[sfrench/cifs-2.6.git] / arch / x86_64 / kernel / setup.c
1 /*
2  *  linux/arch/x86-64/kernel/setup.c
3  *
4  *  Copyright (C) 1995  Linus Torvalds
5  *
6  *  Nov 2001 Dave Jones <davej@suse.de>
7  *  Forked from i386 setup code.
8  */
9
10 /*
11  * This file handles the architecture-dependent parts of initialization
12  */
13
14 #include <linux/errno.h>
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/mm.h>
18 #include <linux/stddef.h>
19 #include <linux/unistd.h>
20 #include <linux/ptrace.h>
21 #include <linux/slab.h>
22 #include <linux/user.h>
23 #include <linux/a.out.h>
24 #include <linux/screen_info.h>
25 #include <linux/ioport.h>
26 #include <linux/delay.h>
27 #include <linux/init.h>
28 #include <linux/initrd.h>
29 #include <linux/highmem.h>
30 #include <linux/bootmem.h>
31 #include <linux/module.h>
32 #include <asm/processor.h>
33 #include <linux/console.h>
34 #include <linux/seq_file.h>
35 #include <linux/crash_dump.h>
36 #include <linux/root_dev.h>
37 #include <linux/pci.h>
38 #include <linux/acpi.h>
39 #include <linux/kallsyms.h>
40 #include <linux/edd.h>
41 #include <linux/mmzone.h>
42 #include <linux/kexec.h>
43 #include <linux/cpufreq.h>
44 #include <linux/dmi.h>
45 #include <linux/dma-mapping.h>
46 #include <linux/ctype.h>
47
48 #include <asm/mtrr.h>
49 #include <asm/uaccess.h>
50 #include <asm/system.h>
51 #include <asm/io.h>
52 #include <asm/smp.h>
53 #include <asm/msr.h>
54 #include <asm/desc.h>
55 #include <video/edid.h>
56 #include <asm/e820.h>
57 #include <asm/dma.h>
58 #include <asm/mpspec.h>
59 #include <asm/mmu_context.h>
60 #include <asm/bootsetup.h>
61 #include <asm/proto.h>
62 #include <asm/setup.h>
63 #include <asm/mach_apic.h>
64 #include <asm/numa.h>
65 #include <asm/sections.h>
66 #include <asm/dmi.h>
67
68 /*
69  * Machine setup..
70  */
71
72 struct cpuinfo_x86 boot_cpu_data __read_mostly;
73 EXPORT_SYMBOL(boot_cpu_data);
74
75 unsigned long mmu_cr4_features;
76
77 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
78 int bootloader_type;
79
80 unsigned long saved_video_mode;
81
82 int force_mwait __cpuinitdata;
83
84 /* 
85  * Early DMI memory
86  */
87 int dmi_alloc_index;
88 char dmi_alloc_data[DMI_MAX_DATA];
89
90 /*
91  * Setup options
92  */
93 struct screen_info screen_info;
94 EXPORT_SYMBOL(screen_info);
95 struct sys_desc_table_struct {
96         unsigned short length;
97         unsigned char table[0];
98 };
99
100 struct edid_info edid_info;
101 EXPORT_SYMBOL_GPL(edid_info);
102
103 extern int root_mountflags;
104
105 char __initdata command_line[COMMAND_LINE_SIZE];
106
107 struct resource standard_io_resources[] = {
108         { .name = "dma1", .start = 0x00, .end = 0x1f,
109                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
110         { .name = "pic1", .start = 0x20, .end = 0x21,
111                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
112         { .name = "timer0", .start = 0x40, .end = 0x43,
113                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
114         { .name = "timer1", .start = 0x50, .end = 0x53,
115                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
116         { .name = "keyboard", .start = 0x60, .end = 0x6f,
117                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
118         { .name = "dma page reg", .start = 0x80, .end = 0x8f,
119                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
120         { .name = "pic2", .start = 0xa0, .end = 0xa1,
121                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
122         { .name = "dma2", .start = 0xc0, .end = 0xdf,
123                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
124         { .name = "fpu", .start = 0xf0, .end = 0xff,
125                 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
126 };
127
128 #define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)
129
130 struct resource data_resource = {
131         .name = "Kernel data",
132         .start = 0,
133         .end = 0,
134         .flags = IORESOURCE_RAM,
135 };
136 struct resource code_resource = {
137         .name = "Kernel code",
138         .start = 0,
139         .end = 0,
140         .flags = IORESOURCE_RAM,
141 };
142
143 #ifdef CONFIG_PROC_VMCORE
144 /* elfcorehdr= specifies the location of elf core header
145  * stored by the crashed kernel. This option will be passed
146  * by kexec loader to the capture kernel.
147  */
148 static int __init setup_elfcorehdr(char *arg)
149 {
150         char *end;
151         if (!arg)
152                 return -EINVAL;
153         elfcorehdr_addr = memparse(arg, &end);
154         return end > arg ? 0 : -EINVAL;
155 }
156 early_param("elfcorehdr", setup_elfcorehdr);
157 #endif
158
159 #ifndef CONFIG_NUMA
160 static void __init
161 contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
162 {
163         unsigned long bootmap_size, bootmap;
164
165         bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
166         bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
167         if (bootmap == -1L)
168                 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
169         bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
170         e820_register_active_regions(0, start_pfn, end_pfn);
171         free_bootmem_with_active_regions(0, end_pfn);
172         reserve_bootmem(bootmap, bootmap_size);
173
174 #endif
175
176 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
177 struct edd edd;
178 #ifdef CONFIG_EDD_MODULE
179 EXPORT_SYMBOL(edd);
180 #endif
181 /**
182  * copy_edd() - Copy the BIOS EDD information
183  *              from boot_params into a safe place.
184  *
185  */
186 static inline void copy_edd(void)
187 {
188      memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
189      memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
190      edd.mbr_signature_nr = EDD_MBR_SIG_NR;
191      edd.edd_info_nr = EDD_NR;
192 }
193 #else
194 static inline void copy_edd(void)
195 {
196 }
197 #endif
198
199 #define EBDA_ADDR_POINTER 0x40E
200
201 unsigned __initdata ebda_addr;
202 unsigned __initdata ebda_size;
203
204 static void discover_ebda(void)
205 {
206         /*
207          * there is a real-mode segmented pointer pointing to the 
208          * 4K EBDA area at 0x40E
209          */
210         ebda_addr = *(unsigned short *)__va(EBDA_ADDR_POINTER);
211         ebda_addr <<= 4;
212
213         ebda_size = *(unsigned short *)__va(ebda_addr);
214
215         /* Round EBDA up to pages */
216         if (ebda_size == 0)
217                 ebda_size = 1;
218         ebda_size <<= 10;
219         ebda_size = round_up(ebda_size + (ebda_addr & ~PAGE_MASK), PAGE_SIZE);
220         if (ebda_size > 64*1024)
221                 ebda_size = 64*1024;
222 }
223
224 void __init setup_arch(char **cmdline_p)
225 {
226         printk(KERN_INFO "Command line: %s\n", boot_command_line);
227
228         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
229         screen_info = SCREEN_INFO;
230         edid_info = EDID_INFO;
231         saved_video_mode = SAVED_VIDEO_MODE;
232         bootloader_type = LOADER_TYPE;
233
234 #ifdef CONFIG_BLK_DEV_RAM
235         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
236         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
237         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
238 #endif
239         setup_memory_region();
240         copy_edd();
241
242         if (!MOUNT_ROOT_RDONLY)
243                 root_mountflags &= ~MS_RDONLY;
244         init_mm.start_code = (unsigned long) &_text;
245         init_mm.end_code = (unsigned long) &_etext;
246         init_mm.end_data = (unsigned long) &_edata;
247         init_mm.brk = (unsigned long) &_end;
248
249         code_resource.start = virt_to_phys(&_text);
250         code_resource.end = virt_to_phys(&_etext)-1;
251         data_resource.start = virt_to_phys(&_etext);
252         data_resource.end = virt_to_phys(&_edata)-1;
253
254         early_identify_cpu(&boot_cpu_data);
255
256         strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
257         *cmdline_p = command_line;
258
259         parse_early_param();
260
261         finish_e820_parsing();
262
263         e820_register_active_regions(0, 0, -1UL);
264         /*
265          * partially used pages are not usable - thus
266          * we are rounding upwards:
267          */
268         end_pfn = e820_end_of_ram();
269         num_physpages = end_pfn;
270
271         check_efer();
272
273         discover_ebda();
274
275         init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
276
277         dmi_scan_machine();
278
279 #ifdef CONFIG_ACPI
280         /*
281          * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
282          * Call this early for SRAT node setup.
283          */
284         acpi_boot_table_init();
285 #endif
286
287         /* How many end-of-memory variables you have, grandma! */
288         max_low_pfn = end_pfn;
289         max_pfn = end_pfn;
290         high_memory = (void *)__va(end_pfn * PAGE_SIZE - 1) + 1;
291
292         /* Remove active ranges so rediscovery with NUMA-awareness happens */
293         remove_all_active_ranges();
294
295 #ifdef CONFIG_ACPI_NUMA
296         /*
297          * Parse SRAT to discover nodes.
298          */
299         acpi_numa_init();
300 #endif
301
302 #ifdef CONFIG_NUMA
303         numa_initmem_init(0, end_pfn); 
304 #else
305         contig_initmem_init(0, end_pfn);
306 #endif
307
308         /* Reserve direct mapping */
309         reserve_bootmem_generic(table_start << PAGE_SHIFT, 
310                                 (table_end - table_start) << PAGE_SHIFT);
311
312         /* reserve kernel */
313         reserve_bootmem_generic(__pa_symbol(&_text),
314                                 __pa_symbol(&_end) - __pa_symbol(&_text));
315
316         /*
317          * reserve physical page 0 - it's a special BIOS page on many boxes,
318          * enabling clean reboots, SMP operation, laptop functions.
319          */
320         reserve_bootmem_generic(0, PAGE_SIZE);
321
322         /* reserve ebda region */
323         if (ebda_addr)
324                 reserve_bootmem_generic(ebda_addr, ebda_size);
325 #ifdef CONFIG_NUMA
326         /* reserve nodemap region */
327         if (nodemap_addr)
328                 reserve_bootmem_generic(nodemap_addr, nodemap_size);
329 #endif
330
331 #ifdef CONFIG_SMP
332         /* Reserve SMP trampoline */
333         reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, 2*PAGE_SIZE);
334 #endif
335
336 #ifdef CONFIG_ACPI_SLEEP
337        /*
338         * Reserve low memory region for sleep support.
339         */
340        acpi_reserve_bootmem();
341 #endif
342         /*
343          * Find and reserve possible boot-time SMP configuration:
344          */
345         find_smp_config();
346 #ifdef CONFIG_BLK_DEV_INITRD
347         if (LOADER_TYPE && INITRD_START) {
348                 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
349                         reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
350                         initrd_start = INITRD_START + PAGE_OFFSET;
351                         initrd_end = initrd_start+INITRD_SIZE;
352                 }
353                 else {
354                         printk(KERN_ERR "initrd extends beyond end of memory "
355                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
356                             (unsigned long)(INITRD_START + INITRD_SIZE),
357                             (unsigned long)(end_pfn << PAGE_SHIFT));
358                         initrd_start = 0;
359                 }
360         }
361 #endif
362 #ifdef CONFIG_KEXEC
363         if (crashk_res.start != crashk_res.end) {
364                 reserve_bootmem_generic(crashk_res.start,
365                         crashk_res.end - crashk_res.start + 1);
366         }
367 #endif
368
369         paging_init();
370
371 #ifdef CONFIG_PCI
372         early_quirks();
373 #endif
374
375         /*
376          * set this early, so we dont allocate cpu0
377          * if MADT list doesnt list BSP first
378          * mpparse.c/MP_processor_info() allocates logical cpu numbers.
379          */
380         cpu_set(0, cpu_present_map);
381 #ifdef CONFIG_ACPI
382         /*
383          * Read APIC and some other early information from ACPI tables.
384          */
385         acpi_boot_init();
386 #endif
387
388         init_cpu_to_node();
389
390         /*
391          * get boot-time SMP configuration:
392          */
393         if (smp_found_config)
394                 get_smp_config();
395         init_apic_mappings();
396
397         /*
398          * We trust e820 completely. No explicit ROM probing in memory.
399          */
400         e820_reserve_resources(); 
401         e820_mark_nosave_regions();
402
403         {
404         unsigned i;
405         /* request I/O space for devices used on all i[345]86 PCs */
406         for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
407                 request_resource(&ioport_resource, &standard_io_resources[i]);
408         }
409
410         e820_setup_gap();
411
412 #ifdef CONFIG_VT
413 #if defined(CONFIG_VGA_CONSOLE)
414         conswitchp = &vga_con;
415 #elif defined(CONFIG_DUMMY_CONSOLE)
416         conswitchp = &dummy_con;
417 #endif
418 #endif
419 }
420
421 static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
422 {
423         unsigned int *v;
424
425         if (c->extended_cpuid_level < 0x80000004)
426                 return 0;
427
428         v = (unsigned int *) c->x86_model_id;
429         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
430         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
431         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
432         c->x86_model_id[48] = 0;
433         return 1;
434 }
435
436
437 static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
438 {
439         unsigned int n, dummy, eax, ebx, ecx, edx;
440
441         n = c->extended_cpuid_level;
442
443         if (n >= 0x80000005) {
444                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
445                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
446                         edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
447                 c->x86_cache_size=(ecx>>24)+(edx>>24);
448                 /* On K8 L1 TLB is inclusive, so don't count it */
449                 c->x86_tlbsize = 0;
450         }
451
452         if (n >= 0x80000006) {
453                 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
454                 ecx = cpuid_ecx(0x80000006);
455                 c->x86_cache_size = ecx >> 16;
456                 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
457
458                 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
459                 c->x86_cache_size, ecx & 0xFF);
460         }
461
462         if (n >= 0x80000007)
463                 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power); 
464         if (n >= 0x80000008) {
465                 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy); 
466                 c->x86_virt_bits = (eax >> 8) & 0xff;
467                 c->x86_phys_bits = eax & 0xff;
468         }
469 }
470
471 #ifdef CONFIG_NUMA
472 static int nearby_node(int apicid)
473 {
474         int i;
475         for (i = apicid - 1; i >= 0; i--) {
476                 int node = apicid_to_node[i];
477                 if (node != NUMA_NO_NODE && node_online(node))
478                         return node;
479         }
480         for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
481                 int node = apicid_to_node[i];
482                 if (node != NUMA_NO_NODE && node_online(node))
483                         return node;
484         }
485         return first_node(node_online_map); /* Shouldn't happen */
486 }
487 #endif
488
489 /*
490  * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
491  * Assumes number of cores is a power of two.
492  */
493 static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
494 {
495 #ifdef CONFIG_SMP
496         unsigned bits;
497 #ifdef CONFIG_NUMA
498         int cpu = smp_processor_id();
499         int node = 0;
500         unsigned apicid = hard_smp_processor_id();
501 #endif
502         unsigned ecx = cpuid_ecx(0x80000008);
503
504         c->x86_max_cores = (ecx & 0xff) + 1;
505
506         /* CPU telling us the core id bits shift? */
507         bits = (ecx >> 12) & 0xF;
508
509         /* Otherwise recompute */
510         if (bits == 0) {
511                 while ((1 << bits) < c->x86_max_cores)
512                         bits++;
513         }
514
515         /* Low order bits define the core id (index of core in socket) */
516         c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
517         /* Convert the APIC ID into the socket ID */
518         c->phys_proc_id = phys_pkg_id(bits);
519
520 #ifdef CONFIG_NUMA
521         node = c->phys_proc_id;
522         if (apicid_to_node[apicid] != NUMA_NO_NODE)
523                 node = apicid_to_node[apicid];
524         if (!node_online(node)) {
525                 /* Two possibilities here:
526                    - The CPU is missing memory and no node was created.
527                    In that case try picking one from a nearby CPU
528                    - The APIC IDs differ from the HyperTransport node IDs
529                    which the K8 northbridge parsing fills in.
530                    Assume they are all increased by a constant offset,
531                    but in the same order as the HT nodeids.
532                    If that doesn't result in a usable node fall back to the
533                    path for the previous case.  */
534                 int ht_nodeid = apicid - (cpu_data[0].phys_proc_id << bits);
535                 if (ht_nodeid >= 0 &&
536                     apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
537                         node = apicid_to_node[ht_nodeid];
538                 /* Pick a nearby node */
539                 if (!node_online(node))
540                         node = nearby_node(apicid);
541         }
542         numa_set_node(cpu, node);
543
544         printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
545 #endif
546 #endif
547 }
548
549 #define ENABLE_C1E_MASK         0x18000000
550 #define CPUID_PROCESSOR_SIGNATURE       1
551 #define CPUID_XFAM              0x0ff00000
552 #define CPUID_XFAM_K8           0x00000000
553 #define CPUID_XFAM_10H          0x00100000
554 #define CPUID_XFAM_11H          0x00200000
555 #define CPUID_XMOD              0x000f0000
556 #define CPUID_XMOD_REV_F        0x00040000
557
558 /* AMD systems with C1E don't have a working lAPIC timer. Check for that. */
559 static __cpuinit int amd_apic_timer_broken(void)
560 {
561         u32 lo, hi;
562         u32 eax = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);
563         switch (eax & CPUID_XFAM) {
564         case CPUID_XFAM_K8:
565                 if ((eax & CPUID_XMOD) < CPUID_XMOD_REV_F)
566                         break;
567         case CPUID_XFAM_10H:
568         case CPUID_XFAM_11H:
569                 rdmsr(MSR_K8_ENABLE_C1E, lo, hi);
570                 if (lo & ENABLE_C1E_MASK)
571                         return 1;
572                 break;
573         default:
574                 /* err on the side of caution */
575                 return 1;
576         }
577         return 0;
578 }
579
580 static void __cpuinit init_amd(struct cpuinfo_x86 *c)
581 {
582         unsigned level;
583
584 #ifdef CONFIG_SMP
585         unsigned long value;
586
587         /*
588          * Disable TLB flush filter by setting HWCR.FFDIS on K8
589          * bit 6 of msr C001_0015
590          *
591          * Errata 63 for SH-B3 steppings
592          * Errata 122 for all steppings (F+ have it disabled by default)
593          */
594         if (c->x86 == 15) {
595                 rdmsrl(MSR_K8_HWCR, value);
596                 value |= 1 << 6;
597                 wrmsrl(MSR_K8_HWCR, value);
598         }
599 #endif
600
601         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
602            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
603         clear_bit(0*32+31, &c->x86_capability);
604         
605         /* On C+ stepping K8 rep microcode works well for copy/memset */
606         level = cpuid_eax(1);
607         if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
608                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
609         if (c->x86 == 0x10)
610                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
611
612         /* Enable workaround for FXSAVE leak */
613         if (c->x86 >= 6)
614                 set_bit(X86_FEATURE_FXSAVE_LEAK, &c->x86_capability);
615
616         level = get_model_name(c);
617         if (!level) {
618                 switch (c->x86) { 
619                 case 15:
620                         /* Should distinguish Models here, but this is only
621                            a fallback anyways. */
622                         strcpy(c->x86_model_id, "Hammer");
623                         break; 
624                 } 
625         } 
626         display_cacheinfo(c);
627
628         /* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
629         if (c->x86_power & (1<<8))
630                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
631
632         /* Multi core CPU? */
633         if (c->extended_cpuid_level >= 0x80000008)
634                 amd_detect_cmp(c);
635
636         if (c->extended_cpuid_level >= 0x80000006 &&
637                 (cpuid_edx(0x80000006) & 0xf000))
638                 num_cache_leaves = 4;
639         else
640                 num_cache_leaves = 3;
641
642         if (c->x86 == 0xf || c->x86 == 0x10 || c->x86 == 0x11)
643                 set_bit(X86_FEATURE_K8, &c->x86_capability);
644
645         /* RDTSC can be speculated around */
646         clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
647
648         /* Family 10 doesn't support C states in MWAIT so don't use it */
649         if (c->x86 == 0x10 && !force_mwait)
650                 clear_bit(X86_FEATURE_MWAIT, &c->x86_capability);
651
652         if (amd_apic_timer_broken())
653                 disable_apic_timer = 1;
654 }
655
656 static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
657 {
658 #ifdef CONFIG_SMP
659         u32     eax, ebx, ecx, edx;
660         int     index_msb, core_bits;
661
662         cpuid(1, &eax, &ebx, &ecx, &edx);
663
664
665         if (!cpu_has(c, X86_FEATURE_HT))
666                 return;
667         if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
668                 goto out;
669
670         smp_num_siblings = (ebx & 0xff0000) >> 16;
671
672         if (smp_num_siblings == 1) {
673                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
674         } else if (smp_num_siblings > 1 ) {
675
676                 if (smp_num_siblings > NR_CPUS) {
677                         printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
678                         smp_num_siblings = 1;
679                         return;
680                 }
681
682                 index_msb = get_count_order(smp_num_siblings);
683                 c->phys_proc_id = phys_pkg_id(index_msb);
684
685                 smp_num_siblings = smp_num_siblings / c->x86_max_cores;
686
687                 index_msb = get_count_order(smp_num_siblings) ;
688
689                 core_bits = get_count_order(c->x86_max_cores);
690
691                 c->cpu_core_id = phys_pkg_id(index_msb) &
692                                                ((1 << core_bits) - 1);
693         }
694 out:
695         if ((c->x86_max_cores * smp_num_siblings) > 1) {
696                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n", c->phys_proc_id);
697                 printk(KERN_INFO  "CPU: Processor Core ID: %d\n", c->cpu_core_id);
698         }
699
700 #endif
701 }
702
703 /*
704  * find out the number of processor cores on the die
705  */
706 static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
707 {
708         unsigned int eax, t;
709
710         if (c->cpuid_level < 4)
711                 return 1;
712
713         cpuid_count(4, 0, &eax, &t, &t, &t);
714
715         if (eax & 0x1f)
716                 return ((eax >> 26) + 1);
717         else
718                 return 1;
719 }
720
721 static void srat_detect_node(void)
722 {
723 #ifdef CONFIG_NUMA
724         unsigned node;
725         int cpu = smp_processor_id();
726         int apicid = hard_smp_processor_id();
727
728         /* Don't do the funky fallback heuristics the AMD version employs
729            for now. */
730         node = apicid_to_node[apicid];
731         if (node == NUMA_NO_NODE)
732                 node = first_node(node_online_map);
733         numa_set_node(cpu, node);
734
735         printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
736 #endif
737 }
738
739 static void __cpuinit init_intel(struct cpuinfo_x86 *c)
740 {
741         /* Cache sizes */
742         unsigned n;
743
744         init_intel_cacheinfo(c);
745         if (c->cpuid_level > 9 ) {
746                 unsigned eax = cpuid_eax(10);
747                 /* Check for version and the number of counters */
748                 if ((eax & 0xff) && (((eax>>8) & 0xff) > 1))
749                         set_bit(X86_FEATURE_ARCH_PERFMON, &c->x86_capability);
750         }
751
752         if (cpu_has_ds) {
753                 unsigned int l1, l2;
754                 rdmsr(MSR_IA32_MISC_ENABLE, l1, l2);
755                 if (!(l1 & (1<<11)))
756                         set_bit(X86_FEATURE_BTS, c->x86_capability);
757                 if (!(l1 & (1<<12)))
758                         set_bit(X86_FEATURE_PEBS, c->x86_capability);
759         }
760
761         n = c->extended_cpuid_level;
762         if (n >= 0x80000008) {
763                 unsigned eax = cpuid_eax(0x80000008);
764                 c->x86_virt_bits = (eax >> 8) & 0xff;
765                 c->x86_phys_bits = eax & 0xff;
766                 /* CPUID workaround for Intel 0F34 CPU */
767                 if (c->x86_vendor == X86_VENDOR_INTEL &&
768                     c->x86 == 0xF && c->x86_model == 0x3 &&
769                     c->x86_mask == 0x4)
770                         c->x86_phys_bits = 36;
771         }
772
773         if (c->x86 == 15)
774                 c->x86_cache_alignment = c->x86_clflush_size * 2;
775         if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
776             (c->x86 == 0x6 && c->x86_model >= 0x0e))
777                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
778         if (c->x86 == 6)
779                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
780         if (c->x86 == 15)
781                 set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
782         else
783                 clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
784         c->x86_max_cores = intel_num_cpu_cores(c);
785
786         srat_detect_node();
787 }
788
789 static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
790 {
791         char *v = c->x86_vendor_id;
792
793         if (!strcmp(v, "AuthenticAMD"))
794                 c->x86_vendor = X86_VENDOR_AMD;
795         else if (!strcmp(v, "GenuineIntel"))
796                 c->x86_vendor = X86_VENDOR_INTEL;
797         else
798                 c->x86_vendor = X86_VENDOR_UNKNOWN;
799 }
800
801 struct cpu_model_info {
802         int vendor;
803         int family;
804         char *model_names[16];
805 };
806
807 /* Do some early cpuid on the boot CPU to get some parameter that are
808    needed before check_bugs. Everything advanced is in identify_cpu
809    below. */
810 void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
811 {
812         u32 tfms;
813
814         c->loops_per_jiffy = loops_per_jiffy;
815         c->x86_cache_size = -1;
816         c->x86_vendor = X86_VENDOR_UNKNOWN;
817         c->x86_model = c->x86_mask = 0; /* So far unknown... */
818         c->x86_vendor_id[0] = '\0'; /* Unset */
819         c->x86_model_id[0] = '\0';  /* Unset */
820         c->x86_clflush_size = 64;
821         c->x86_cache_alignment = c->x86_clflush_size;
822         c->x86_max_cores = 1;
823         c->extended_cpuid_level = 0;
824         memset(&c->x86_capability, 0, sizeof c->x86_capability);
825
826         /* Get vendor name */
827         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
828               (unsigned int *)&c->x86_vendor_id[0],
829               (unsigned int *)&c->x86_vendor_id[8],
830               (unsigned int *)&c->x86_vendor_id[4]);
831                 
832         get_cpu_vendor(c);
833
834         /* Initialize the standard set of capabilities */
835         /* Note that the vendor-specific code below might override */
836
837         /* Intel-defined flags: level 0x00000001 */
838         if (c->cpuid_level >= 0x00000001) {
839                 __u32 misc;
840                 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
841                       &c->x86_capability[0]);
842                 c->x86 = (tfms >> 8) & 0xf;
843                 c->x86_model = (tfms >> 4) & 0xf;
844                 c->x86_mask = tfms & 0xf;
845                 if (c->x86 == 0xf)
846                         c->x86 += (tfms >> 20) & 0xff;
847                 if (c->x86 >= 0x6)
848                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
849                 if (c->x86_capability[0] & (1<<19)) 
850                         c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
851         } else {
852                 /* Have CPUID level 0 only - unheard of */
853                 c->x86 = 4;
854         }
855
856 #ifdef CONFIG_SMP
857         c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
858 #endif
859 }
860
861 /*
862  * This does the hard work of actually picking apart the CPU stuff...
863  */
864 void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
865 {
866         int i;
867         u32 xlvl;
868
869         early_identify_cpu(c);
870
871         /* AMD-defined flags: level 0x80000001 */
872         xlvl = cpuid_eax(0x80000000);
873         c->extended_cpuid_level = xlvl;
874         if ((xlvl & 0xffff0000) == 0x80000000) {
875                 if (xlvl >= 0x80000001) {
876                         c->x86_capability[1] = cpuid_edx(0x80000001);
877                         c->x86_capability[6] = cpuid_ecx(0x80000001);
878                 }
879                 if (xlvl >= 0x80000004)
880                         get_model_name(c); /* Default name */
881         }
882
883         /* Transmeta-defined flags: level 0x80860001 */
884         xlvl = cpuid_eax(0x80860000);
885         if ((xlvl & 0xffff0000) == 0x80860000) {
886                 /* Don't set x86_cpuid_level here for now to not confuse. */
887                 if (xlvl >= 0x80860001)
888                         c->x86_capability[2] = cpuid_edx(0x80860001);
889         }
890
891         init_scattered_cpuid_features(c);
892
893         c->apicid = phys_pkg_id(0);
894
895         /*
896          * Vendor-specific initialization.  In this section we
897          * canonicalize the feature flags, meaning if there are
898          * features a certain CPU supports which CPUID doesn't
899          * tell us, CPUID claiming incorrect flags, or other bugs,
900          * we handle them here.
901          *
902          * At the end of this section, c->x86_capability better
903          * indicate the features this CPU genuinely supports!
904          */
905         switch (c->x86_vendor) {
906         case X86_VENDOR_AMD:
907                 init_amd(c);
908                 break;
909
910         case X86_VENDOR_INTEL:
911                 init_intel(c);
912                 break;
913
914         case X86_VENDOR_UNKNOWN:
915         default:
916                 display_cacheinfo(c);
917                 break;
918         }
919
920         select_idle_routine(c);
921         detect_ht(c); 
922
923         /*
924          * On SMP, boot_cpu_data holds the common feature set between
925          * all CPUs; so make sure that we indicate which features are
926          * common between the CPUs.  The first time this routine gets
927          * executed, c == &boot_cpu_data.
928          */
929         if (c != &boot_cpu_data) {
930                 /* AND the already accumulated flags with these */
931                 for (i = 0 ; i < NCAPINTS ; i++)
932                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
933         }
934
935 #ifdef CONFIG_X86_MCE
936         mcheck_init(c);
937 #endif
938         if (c != &boot_cpu_data)
939                 mtrr_ap_init();
940 #ifdef CONFIG_NUMA
941         numa_add_cpu(smp_processor_id());
942 #endif
943 }
944  
945
946 void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
947 {
948         if (c->x86_model_id[0])
949                 printk("%s", c->x86_model_id);
950
951         if (c->x86_mask || c->cpuid_level >= 0) 
952                 printk(" stepping %02x\n", c->x86_mask);
953         else
954                 printk("\n");
955 }
956
957 /*
958  *      Get CPU information for use by the procfs.
959  */
960
961 static int show_cpuinfo(struct seq_file *m, void *v)
962 {
963         struct cpuinfo_x86 *c = v;
964
965         /* 
966          * These flag bits must match the definitions in <asm/cpufeature.h>.
967          * NULL means this bit is undefined or reserved; either way it doesn't
968          * have meaning as far as Linux is concerned.  Note that it's important
969          * to realize there is a difference between this table and CPUID -- if
970          * applications want to get the raw CPUID data, they should access
971          * /dev/cpu/<cpu_nr>/cpuid instead.
972          */
973         static char *x86_cap_flags[] = {
974                 /* Intel-defined */
975                 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
976                 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
977                 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
978                 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
979
980                 /* AMD-defined */
981                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
982                 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
983                 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
984                 NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
985                 "3dnowext", "3dnow",
986
987                 /* Transmeta-defined */
988                 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
989                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
990                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
991                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
992
993                 /* Other (Linux-defined) */
994                 "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr",
995                 NULL, NULL, NULL, NULL,
996                 "constant_tsc", "up", NULL, "arch_perfmon",
997                 "pebs", "bts", NULL, "sync_rdtsc",
998                 "rep_good", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
999                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1000
1001                 /* Intel-defined (#2) */
1002                 "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
1003                 "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
1004                 NULL, NULL, "dca", NULL, NULL, NULL, NULL, "popcnt",
1005                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1006
1007                 /* VIA/Cyrix/Centaur-defined */
1008                 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1009                 "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
1010                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1011                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1012
1013                 /* AMD-defined (#2) */
1014                 "lahf_lm", "cmp_legacy", "svm", "extapic", "cr8_legacy",
1015                 "altmovcr8", "abm", "sse4a",
1016                 "misalignsse", "3dnowprefetch",
1017                 "osvw", "ibs", NULL, NULL, NULL, NULL,
1018                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1019                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1020
1021                 /* Auxiliary (Linux-defined) */
1022                 "ida", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1023                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1024                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1025                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1026         };
1027         static char *x86_power_flags[] = { 
1028                 "ts",   /* temperature sensor */
1029                 "fid",  /* frequency id control */
1030                 "vid",  /* voltage id control */
1031                 "ttp",  /* thermal trip */
1032                 "tm",
1033                 "stc",
1034                 "100mhzsteps",
1035                 "hwpstate",
1036                 "",     /* tsc invariant mapped to constant_tsc */
1037                 /* nothing */
1038         };
1039
1040
1041 #ifdef CONFIG_SMP
1042         if (!cpu_online(c-cpu_data))
1043                 return 0;
1044 #endif
1045
1046         seq_printf(m,"processor\t: %u\n"
1047                      "vendor_id\t: %s\n"
1048                      "cpu family\t: %d\n"
1049                      "model\t\t: %d\n"
1050                      "model name\t: %s\n",
1051                      (unsigned)(c-cpu_data),
1052                      c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1053                      c->x86,
1054                      (int)c->x86_model,
1055                      c->x86_model_id[0] ? c->x86_model_id : "unknown");
1056         
1057         if (c->x86_mask || c->cpuid_level >= 0)
1058                 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1059         else
1060                 seq_printf(m, "stepping\t: unknown\n");
1061         
1062         if (cpu_has(c,X86_FEATURE_TSC)) {
1063                 unsigned int freq = cpufreq_quick_get((unsigned)(c-cpu_data));
1064                 if (!freq)
1065                         freq = cpu_khz;
1066                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1067                              freq / 1000, (freq % 1000));
1068         }
1069
1070         /* Cache size */
1071         if (c->x86_cache_size >= 0) 
1072                 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1073         
1074 #ifdef CONFIG_SMP
1075         if (smp_num_siblings * c->x86_max_cores > 1) {
1076                 int cpu = c - cpu_data;
1077                 seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
1078                 seq_printf(m, "siblings\t: %d\n", cpus_weight(cpu_core_map[cpu]));
1079                 seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
1080                 seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1081         }
1082 #endif  
1083
1084         seq_printf(m,
1085                 "fpu\t\t: yes\n"
1086                 "fpu_exception\t: yes\n"
1087                 "cpuid level\t: %d\n"
1088                 "wp\t\t: yes\n"
1089                 "flags\t\t:",
1090                    c->cpuid_level);
1091
1092         { 
1093                 int i; 
1094                 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1095                         if (cpu_has(c, i) && x86_cap_flags[i] != NULL)
1096                                 seq_printf(m, " %s", x86_cap_flags[i]);
1097         }
1098                 
1099         seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1100                    c->loops_per_jiffy/(500000/HZ),
1101                    (c->loops_per_jiffy/(5000/HZ)) % 100);
1102
1103         if (c->x86_tlbsize > 0) 
1104                 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1105         seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1106         seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1107
1108         seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n", 
1109                    c->x86_phys_bits, c->x86_virt_bits);
1110
1111         seq_printf(m, "power management:");
1112         {
1113                 unsigned i;
1114                 for (i = 0; i < 32; i++) 
1115                         if (c->x86_power & (1 << i)) {
1116                                 if (i < ARRAY_SIZE(x86_power_flags) &&
1117                                         x86_power_flags[i])
1118                                         seq_printf(m, "%s%s",
1119                                                 x86_power_flags[i][0]?" ":"",
1120                                                 x86_power_flags[i]);
1121                                 else
1122                                         seq_printf(m, " [%d]", i);
1123                         }
1124         }
1125
1126         seq_printf(m, "\n\n");
1127
1128         return 0;
1129 }
1130
1131 static void *c_start(struct seq_file *m, loff_t *pos)
1132 {
1133         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1134 }
1135
1136 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1137 {
1138         ++*pos;
1139         return c_start(m, pos);
1140 }
1141
1142 static void c_stop(struct seq_file *m, void *v)
1143 {
1144 }
1145
1146 struct seq_operations cpuinfo_op = {
1147         .start =c_start,
1148         .next = c_next,
1149         .stop = c_stop,
1150         .show = show_cpuinfo,
1151 };