1
2
3
4
5
6
7
8#include <linux/acpi.h>
9#include <linux/console.h>
10#include <linux/crash_dump.h>
11#include <linux/dma-map-ops.h>
12#include <linux/dmi.h>
13#include <linux/efi.h>
14#include <linux/init_ohci1394_dma.h>
15#include <linux/initrd.h>
16#include <linux/iscsi_ibft.h>
17#include <linux/memblock.h>
18#include <linux/panic_notifier.h>
19#include <linux/pci.h>
20#include <linux/root_dev.h>
21#include <linux/hugetlb.h>
22#include <linux/tboot.h>
23#include <linux/usb/xhci-dbgp.h>
24#include <linux/static_call.h>
25#include <linux/swiotlb.h>
26
27#include <uapi/linux/mount.h>
28
29#include <xen/xen.h>
30
31#include <asm/apic.h>
32#include <asm/numa.h>
33#include <asm/bios_ebda.h>
34#include <asm/bugs.h>
35#include <asm/cpu.h>
36#include <asm/efi.h>
37#include <asm/gart.h>
38#include <asm/hypervisor.h>
39#include <asm/io_apic.h>
40#include <asm/kasan.h>
41#include <asm/kaslr.h>
42#include <asm/mce.h>
43#include <asm/mtrr.h>
44#include <asm/realmode.h>
45#include <asm/olpc_ofw.h>
46#include <asm/pci-direct.h>
47#include <asm/prom.h>
48#include <asm/proto.h>
49#include <asm/thermal.h>
50#include <asm/unwind.h>
51#include <asm/vsyscall.h>
52#include <linux/vmalloc.h>
53
54
55
56
57
58
59
60
61unsigned long max_low_pfn_mapped;
62unsigned long max_pfn_mapped;
63
64#ifdef CONFIG_DMI
65RESERVE_BRK(dmi_alloc, 65536);
66#endif
67
68
69
70
71
72
73
74unsigned long _brk_start = (unsigned long)__brk_base;
75unsigned long _brk_end = (unsigned long)__brk_base;
76
77struct boot_params boot_params;
78
79
80
81
82
83
84
85static struct resource rodata_resource = {
86 .name = "Kernel rodata",
87 .start = 0,
88 .end = 0,
89 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
90};
91
92static struct resource data_resource = {
93 .name = "Kernel data",
94 .start = 0,
95 .end = 0,
96 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
97};
98
99static struct resource code_resource = {
100 .name = "Kernel code",
101 .start = 0,
102 .end = 0,
103 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
104};
105
106static struct resource bss_resource = {
107 .name = "Kernel bss",
108 .start = 0,
109 .end = 0,
110 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
111};
112
113
114#ifdef CONFIG_X86_32
115
116struct cpuinfo_x86 new_cpu_data;
117
118
119struct cpuinfo_x86 boot_cpu_data __read_mostly;
120EXPORT_SYMBOL(boot_cpu_data);
121
122unsigned int def_to_bigsmp;
123
124struct apm_info apm_info;
125EXPORT_SYMBOL(apm_info);
126
127#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
128 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
129struct ist_info ist_info;
130EXPORT_SYMBOL(ist_info);
131#else
132struct ist_info ist_info;
133#endif
134
135#else
136struct cpuinfo_x86 boot_cpu_data __read_mostly;
137EXPORT_SYMBOL(boot_cpu_data);
138#endif
139
140
141#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
142__visible unsigned long mmu_cr4_features __ro_after_init;
143#else
144__visible unsigned long mmu_cr4_features __ro_after_init = X86_CR4_PAE;
145#endif
146
147
148int bootloader_type, bootloader_version;
149
150
151
152
153struct screen_info screen_info;
154EXPORT_SYMBOL(screen_info);
155struct edid_info edid_info;
156EXPORT_SYMBOL_GPL(edid_info);
157
158extern int root_mountflags;
159
160unsigned long saved_video_mode;
161
162#define RAMDISK_IMAGE_START_MASK 0x07FF
163#define RAMDISK_PROMPT_FLAG 0x8000
164#define RAMDISK_LOAD_FLAG 0x4000
165
166static char __initdata command_line[COMMAND_LINE_SIZE];
167#ifdef CONFIG_CMDLINE_BOOL
168static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
169#endif
170
171#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
172struct edd edd;
173#ifdef CONFIG_EDD_MODULE
174EXPORT_SYMBOL(edd);
175#endif
176
177
178
179
180
181static inline void __init copy_edd(void)
182{
183 memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
184 sizeof(edd.mbr_signature));
185 memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
186 edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
187 edd.edd_info_nr = boot_params.eddbuf_entries;
188}
189#else
190static inline void __init copy_edd(void)
191{
192}
193#endif
194
195void * __init extend_brk(size_t size, size_t align)
196{
197 size_t mask = align - 1;
198 void *ret;
199
200 BUG_ON(_brk_start == 0);
201 BUG_ON(align & mask);
202
203 _brk_end = (_brk_end + mask) & ~mask;
204 BUG_ON((char *)(_brk_end + size) > __brk_limit);
205
206 ret = (void *)_brk_end;
207 _brk_end += size;
208
209 memset(ret, 0, size);
210
211 return ret;
212}
213
214#ifdef CONFIG_X86_32
215static void __init cleanup_highmap(void)
216{
217}
218#endif
219
220static void __init reserve_brk(void)
221{
222 if (_brk_end > _brk_start)
223 memblock_reserve(__pa_symbol(_brk_start),
224 _brk_end - _brk_start);
225
226
227
228 _brk_start = 0;
229}
230
231u64 relocated_ramdisk;
232
233#ifdef CONFIG_BLK_DEV_INITRD
234
235static u64 __init get_ramdisk_image(void)
236{
237 u64 ramdisk_image = boot_params.hdr.ramdisk_image;
238
239 ramdisk_image |= (u64)boot_params.ext_ramdisk_image << 32;
240
241 if (ramdisk_image == 0)
242 ramdisk_image = phys_initrd_start;
243
244 return ramdisk_image;
245}
246static u64 __init get_ramdisk_size(void)
247{
248 u64 ramdisk_size = boot_params.hdr.ramdisk_size;
249
250 ramdisk_size |= (u64)boot_params.ext_ramdisk_size << 32;
251
252 if (ramdisk_size == 0)
253 ramdisk_size = phys_initrd_size;
254
255 return ramdisk_size;
256}
257
258static void __init relocate_initrd(void)
259{
260
261 u64 ramdisk_image = get_ramdisk_image();
262 u64 ramdisk_size = get_ramdisk_size();
263 u64 area_size = PAGE_ALIGN(ramdisk_size);
264
265
266 relocated_ramdisk = memblock_phys_alloc_range(area_size, PAGE_SIZE, 0,
267 PFN_PHYS(max_pfn_mapped));
268 if (!relocated_ramdisk)
269 panic("Cannot find place for new RAMDISK of size %lld\n",
270 ramdisk_size);
271
272 initrd_start = relocated_ramdisk + PAGE_OFFSET;
273 initrd_end = initrd_start + ramdisk_size;
274 printk(KERN_INFO "Allocated new RAMDISK: [mem %#010llx-%#010llx]\n",
275 relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
276
277 copy_from_early_mem((void *)initrd_start, ramdisk_image, ramdisk_size);
278
279 printk(KERN_INFO "Move RAMDISK from [mem %#010llx-%#010llx] to"
280 " [mem %#010llx-%#010llx]\n",
281 ramdisk_image, ramdisk_image + ramdisk_size - 1,
282 relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
283}
284
285static void __init early_reserve_initrd(void)
286{
287
288 u64 ramdisk_image = get_ramdisk_image();
289 u64 ramdisk_size = get_ramdisk_size();
290 u64 ramdisk_end = PAGE_ALIGN(ramdisk_image + ramdisk_size);
291
292 if (!boot_params.hdr.type_of_loader ||
293 !ramdisk_image || !ramdisk_size)
294 return;
295
296 memblock_reserve(ramdisk_image, ramdisk_end - ramdisk_image);
297}
298
299static void __init reserve_initrd(void)
300{
301
302 u64 ramdisk_image = get_ramdisk_image();
303 u64 ramdisk_size = get_ramdisk_size();
304 u64 ramdisk_end = PAGE_ALIGN(ramdisk_image + ramdisk_size);
305
306 if (!boot_params.hdr.type_of_loader ||
307 !ramdisk_image || !ramdisk_size)
308 return;
309
310 initrd_start = 0;
311
312 printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
313 ramdisk_end - 1);
314
315 if (pfn_range_is_mapped(PFN_DOWN(ramdisk_image),
316 PFN_DOWN(ramdisk_end))) {
317
318 initrd_start = ramdisk_image + PAGE_OFFSET;
319 initrd_end = initrd_start + ramdisk_size;
320 return;
321 }
322
323 relocate_initrd();
324
325 memblock_free(ramdisk_image, ramdisk_end - ramdisk_image);
326}
327
328#else
329static void __init early_reserve_initrd(void)
330{
331}
332static void __init reserve_initrd(void)
333{
334}
335#endif
336
337static void __init parse_setup_data(void)
338{
339 struct setup_data *data;
340 u64 pa_data, pa_next;
341
342 pa_data = boot_params.hdr.setup_data;
343 while (pa_data) {
344 u32 data_len, data_type;
345
346 data = early_memremap(pa_data, sizeof(*data));
347 data_len = data->len + sizeof(struct setup_data);
348 data_type = data->type;
349 pa_next = data->next;
350 early_memunmap(data, sizeof(*data));
351
352 switch (data_type) {
353 case SETUP_E820_EXT:
354 e820__memory_setup_extended(pa_data, data_len);
355 break;
356 case SETUP_DTB:
357 add_dtb(pa_data);
358 break;
359 case SETUP_EFI:
360 parse_efi_setup(pa_data, data_len);
361 break;
362 default:
363 break;
364 }
365 pa_data = pa_next;
366 }
367}
368
369static void __init memblock_x86_reserve_range_setup_data(void)
370{
371 struct setup_data *data;
372 u64 pa_data;
373
374 pa_data = boot_params.hdr.setup_data;
375 while (pa_data) {
376 data = early_memremap(pa_data, sizeof(*data));
377 memblock_reserve(pa_data, sizeof(*data) + data->len);
378
379 if (data->type == SETUP_INDIRECT &&
380 ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT)
381 memblock_reserve(((struct setup_indirect *)data->data)->addr,
382 ((struct setup_indirect *)data->data)->len);
383
384 pa_data = data->next;
385 early_memunmap(data, sizeof(*data));
386 }
387}
388
389
390
391
392
393#ifdef CONFIG_KEXEC_CORE
394
395
396#define CRASH_ALIGN SZ_16M
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411#ifdef CONFIG_X86_32
412# define CRASH_ADDR_LOW_MAX SZ_512M
413# define CRASH_ADDR_HIGH_MAX SZ_512M
414#else
415# define CRASH_ADDR_LOW_MAX SZ_4G
416# define CRASH_ADDR_HIGH_MAX SZ_64T
417#endif
418
419static int __init reserve_crashkernel_low(void)
420{
421#ifdef CONFIG_X86_64
422 unsigned long long base, low_base = 0, low_size = 0;
423 unsigned long low_mem_limit;
424 int ret;
425
426 low_mem_limit = min(memblock_phys_mem_size(), CRASH_ADDR_LOW_MAX);
427
428
429 ret = parse_crashkernel_low(boot_command_line, low_mem_limit, &low_size, &base);
430 if (ret) {
431
432
433
434
435
436
437
438
439
440 low_size = max(swiotlb_size_or_default() + (8UL << 20), 256UL << 20);
441 } else {
442
443 if (!low_size)
444 return 0;
445 }
446
447 low_base = memblock_phys_alloc_range(low_size, CRASH_ALIGN, 0, CRASH_ADDR_LOW_MAX);
448 if (!low_base) {
449 pr_err("Cannot reserve %ldMB crashkernel low memory, please try smaller size.\n",
450 (unsigned long)(low_size >> 20));
451 return -ENOMEM;
452 }
453
454 pr_info("Reserving %ldMB of low memory at %ldMB for crashkernel (low RAM limit: %ldMB)\n",
455 (unsigned long)(low_size >> 20),
456 (unsigned long)(low_base >> 20),
457 (unsigned long)(low_mem_limit >> 20));
458
459 crashk_low_res.start = low_base;
460 crashk_low_res.end = low_base + low_size - 1;
461 insert_resource(&iomem_resource, &crashk_low_res);
462#endif
463 return 0;
464}
465
466static void __init reserve_crashkernel(void)
467{
468 unsigned long long crash_size, crash_base, total_mem;
469 bool high = false;
470 int ret;
471
472 total_mem = memblock_phys_mem_size();
473
474
475 ret = parse_crashkernel(boot_command_line, total_mem, &crash_size, &crash_base);
476 if (ret != 0 || crash_size <= 0) {
477
478 ret = parse_crashkernel_high(boot_command_line, total_mem,
479 &crash_size, &crash_base);
480 if (ret != 0 || crash_size <= 0)
481 return;
482 high = true;
483 }
484
485 if (xen_pv_domain()) {
486 pr_info("Ignoring crashkernel for a Xen PV domain\n");
487 return;
488 }
489
490
491 if (!crash_base) {
492
493
494
495
496
497
498
499
500 if (!high)
501 crash_base = memblock_phys_alloc_range(crash_size,
502 CRASH_ALIGN, CRASH_ALIGN,
503 CRASH_ADDR_LOW_MAX);
504 if (!crash_base)
505 crash_base = memblock_phys_alloc_range(crash_size,
506 CRASH_ALIGN, CRASH_ALIGN,
507 CRASH_ADDR_HIGH_MAX);
508 if (!crash_base) {
509 pr_info("crashkernel reservation failed - No suitable area found.\n");
510 return;
511 }
512 } else {
513 unsigned long long start;
514
515 start = memblock_phys_alloc_range(crash_size, SZ_1M, crash_base,
516 crash_base + crash_size);
517 if (start != crash_base) {
518 pr_info("crashkernel reservation failed - memory is in use.\n");
519 return;
520 }
521 }
522
523 if (crash_base >= (1ULL << 32) && reserve_crashkernel_low()) {
524 memblock_free(crash_base, crash_size);
525 return;
526 }
527
528 pr_info("Reserving %ldMB of memory at %ldMB for crashkernel (System RAM: %ldMB)\n",
529 (unsigned long)(crash_size >> 20),
530 (unsigned long)(crash_base >> 20),
531 (unsigned long)(total_mem >> 20));
532
533 crashk_res.start = crash_base;
534 crashk_res.end = crash_base + crash_size - 1;
535 insert_resource(&iomem_resource, &crashk_res);
536}
537#else
538static void __init reserve_crashkernel(void)
539{
540}
541#endif
542
543static struct resource standard_io_resources[] = {
544 { .name = "dma1", .start = 0x00, .end = 0x1f,
545 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
546 { .name = "pic1", .start = 0x20, .end = 0x21,
547 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
548 { .name = "timer0", .start = 0x40, .end = 0x43,
549 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
550 { .name = "timer1", .start = 0x50, .end = 0x53,
551 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
552 { .name = "keyboard", .start = 0x60, .end = 0x60,
553 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
554 { .name = "keyboard", .start = 0x64, .end = 0x64,
555 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
556 { .name = "dma page reg", .start = 0x80, .end = 0x8f,
557 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
558 { .name = "pic2", .start = 0xa0, .end = 0xa1,
559 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
560 { .name = "dma2", .start = 0xc0, .end = 0xdf,
561 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
562 { .name = "fpu", .start = 0xf0, .end = 0xff,
563 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
564};
565
566void __init reserve_standard_io_resources(void)
567{
568 int i;
569
570
571 for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
572 request_resource(&ioport_resource, &standard_io_resources[i]);
573
574}
575
576static bool __init snb_gfx_workaround_needed(void)
577{
578#ifdef CONFIG_PCI
579 int i;
580 u16 vendor, devid;
581 static const __initconst u16 snb_ids[] = {
582 0x0102,
583 0x0112,
584 0x0122,
585 0x0106,
586 0x0116,
587 0x0126,
588 0x010a,
589 };
590
591
592 if (!early_pci_allowed())
593 return false;
594
595 vendor = read_pci_config_16(0, 2, 0, PCI_VENDOR_ID);
596 if (vendor != 0x8086)
597 return false;
598
599 devid = read_pci_config_16(0, 2, 0, PCI_DEVICE_ID);
600 for (i = 0; i < ARRAY_SIZE(snb_ids); i++)
601 if (devid == snb_ids[i])
602 return true;
603#endif
604
605 return false;
606}
607
608
609
610
611
612static void __init trim_snb_memory(void)
613{
614 static const __initconst unsigned long bad_pages[] = {
615 0x20050000,
616 0x20110000,
617 0x20130000,
618 0x20138000,
619 0x40004000,
620 };
621 int i;
622
623 if (!snb_gfx_workaround_needed())
624 return;
625
626 printk(KERN_DEBUG "reserving inaccessible SNB gfx pages\n");
627
628
629
630
631
632
633
634
635
636
637
638
639 for (i = 0; i < ARRAY_SIZE(bad_pages); i++) {
640 if (memblock_reserve(bad_pages[i], PAGE_SIZE))
641 printk(KERN_WARNING "failed to reserve 0x%08lx\n",
642 bad_pages[i]);
643 }
644}
645
646static void __init trim_bios_range(void)
647{
648
649
650
651
652
653
654
655
656
657 e820__range_update(0, PAGE_SIZE, E820_TYPE_RAM, E820_TYPE_RESERVED);
658
659
660
661
662
663
664 e820__range_remove(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_TYPE_RAM, 1);
665
666 e820__update_table(e820_table);
667}
668
669
670static void __init e820_add_kernel_range(void)
671{
672 u64 start = __pa_symbol(_text);
673 u64 size = __pa_symbol(_end) - start;
674
675
676
677
678
679
680
681
682 if (e820__mapped_all(start, start + size, E820_TYPE_RAM))
683 return;
684
685 pr_warn(".text .data .bss are not marked as E820_TYPE_RAM!\n");
686 e820__range_remove(start, size, E820_TYPE_RAM, 0);
687 e820__range_add(start, size, E820_TYPE_RAM);
688}
689
690static void __init early_reserve_memory(void)
691{
692
693
694
695
696
697
698 memblock_reserve(__pa_symbol(_text),
699 (unsigned long)__end_of_kernel_reserve - (unsigned long)_text);
700
701
702
703
704
705
706
707
708
709
710
711
712 memblock_reserve(0, SZ_64K);
713
714 early_reserve_initrd();
715
716 if (efi_enabled(EFI_BOOT))
717 efi_memblock_x86_reserve_range();
718
719 memblock_x86_reserve_range_setup_data();
720
721 reserve_ibft_region();
722 reserve_bios_regions();
723 trim_snb_memory();
724}
725
726
727
728
729static int
730dump_kernel_offset(struct notifier_block *self, unsigned long v, void *p)
731{
732 if (kaslr_enabled()) {
733 pr_emerg("Kernel Offset: 0x%lx from 0x%lx (relocation range: 0x%lx-0x%lx)\n",
734 kaslr_offset(),
735 __START_KERNEL,
736 __START_KERNEL_map,
737 MODULES_VADDR-1);
738 } else {
739 pr_emerg("Kernel Offset: disabled\n");
740 }
741
742 return 0;
743}
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758void __init setup_arch(char **cmdline_p)
759{
760#ifdef CONFIG_X86_32
761 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
762
763
764
765
766
767 clone_pgd_range(swapper_pg_dir + KERNEL_PGD_BOUNDARY,
768 initial_page_table + KERNEL_PGD_BOUNDARY,
769 KERNEL_PGD_PTRS);
770
771 load_cr3(swapper_pg_dir);
772
773
774
775
776
777
778
779
780
781 __flush_tlb_all();
782#else
783 printk(KERN_INFO "Command line: %s\n", boot_command_line);
784 boot_cpu_data.x86_phys_bits = MAX_PHYSMEM_BITS;
785#endif
786
787
788
789
790
791 olpc_ofw_detect();
792
793 idt_setup_early_traps();
794 early_cpu_init();
795 jump_label_init();
796 static_call_init();
797 early_ioremap_init();
798
799 setup_olpc_ofw_pgd();
800
801 ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
802 screen_info = boot_params.screen_info;
803 edid_info = boot_params.edid_info;
804#ifdef CONFIG_X86_32
805 apm_info.bios = boot_params.apm_bios_info;
806 ist_info = boot_params.ist_info;
807#endif
808 saved_video_mode = boot_params.hdr.vid_mode;
809 bootloader_type = boot_params.hdr.type_of_loader;
810 if ((bootloader_type >> 4) == 0xe) {
811 bootloader_type &= 0xf;
812 bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4;
813 }
814 bootloader_version = bootloader_type & 0xf;
815 bootloader_version |= boot_params.hdr.ext_loader_ver << 4;
816
817#ifdef CONFIG_BLK_DEV_RAM
818 rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
819#endif
820#ifdef CONFIG_EFI
821 if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
822 EFI32_LOADER_SIGNATURE, 4)) {
823 set_bit(EFI_BOOT, &efi.flags);
824 } else if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
825 EFI64_LOADER_SIGNATURE, 4)) {
826 set_bit(EFI_BOOT, &efi.flags);
827 set_bit(EFI_64BIT, &efi.flags);
828 }
829#endif
830
831 x86_init.oem.arch_setup();
832
833
834
835
836
837
838
839
840
841
842
843
844
845 early_reserve_memory();
846
847 iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
848 e820__memory_setup();
849 parse_setup_data();
850
851 copy_edd();
852
853 if (!boot_params.hdr.root_flags)
854 root_mountflags &= ~MS_RDONLY;
855 setup_initial_init_mm(_text, _etext, _edata, (void *)_brk_end);
856
857 code_resource.start = __pa_symbol(_text);
858 code_resource.end = __pa_symbol(_etext)-1;
859 rodata_resource.start = __pa_symbol(__start_rodata);
860 rodata_resource.end = __pa_symbol(__end_rodata)-1;
861 data_resource.start = __pa_symbol(_sdata);
862 data_resource.end = __pa_symbol(_edata)-1;
863 bss_resource.start = __pa_symbol(__bss_start);
864 bss_resource.end = __pa_symbol(__bss_stop)-1;
865
866#ifdef CONFIG_CMDLINE_BOOL
867#ifdef CONFIG_CMDLINE_OVERRIDE
868 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
869#else
870 if (builtin_cmdline[0]) {
871
872 strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
873 strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
874 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
875 }
876#endif
877#endif
878
879 strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
880 *cmdline_p = command_line;
881
882
883
884
885
886
887
888
889 x86_configure_nx();
890
891 parse_early_param();
892
893#ifdef CONFIG_MEMORY_HOTPLUG
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913 if (movable_node_is_enabled())
914 memblock_set_bottom_up(true);
915#endif
916
917 x86_report_nx();
918
919 if (acpi_mps_check()) {
920#ifdef CONFIG_X86_LOCAL_APIC
921 disable_apic = 1;
922#endif
923 setup_clear_cpu_cap(X86_FEATURE_APIC);
924 }
925
926 e820__reserve_setup_data();
927 e820__finish_early_params();
928
929 if (efi_enabled(EFI_BOOT))
930 efi_init();
931
932 dmi_setup();
933
934
935
936
937
938 init_hypervisor_platform();
939
940 tsc_early_init();
941 x86_init.resources.probe_roms();
942
943
944 insert_resource(&iomem_resource, &code_resource);
945 insert_resource(&iomem_resource, &rodata_resource);
946 insert_resource(&iomem_resource, &data_resource);
947 insert_resource(&iomem_resource, &bss_resource);
948
949 e820_add_kernel_range();
950 trim_bios_range();
951#ifdef CONFIG_X86_32
952 if (ppro_with_ram_bug()) {
953 e820__range_update(0x70000000ULL, 0x40000ULL, E820_TYPE_RAM,
954 E820_TYPE_RESERVED);
955 e820__update_table(e820_table);
956 printk(KERN_INFO "fixed physical RAM map:\n");
957 e820__print_table("bad_ppro");
958 }
959#else
960 early_gart_iommu_check();
961#endif
962
963
964
965
966
967 max_pfn = e820__end_of_ram_pfn();
968
969
970 mtrr_bp_init();
971 if (mtrr_trim_uncached_memory(max_pfn))
972 max_pfn = e820__end_of_ram_pfn();
973
974 max_possible_pfn = max_pfn;
975
976
977
978
979
980
981 init_cache_modes();
982
983
984
985
986
987 kernel_randomize_memory();
988
989#ifdef CONFIG_X86_32
990
991 find_low_pfn_range();
992#else
993 check_x2apic();
994
995
996
997 if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
998 max_low_pfn = e820__end_of_low_ram_pfn();
999 else
1000 max_low_pfn = max_pfn;
1001
1002 high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
1003#endif
1004
1005
1006
1007
1008 find_smp_config();
1009
1010 early_alloc_pgt_buf();
1011
1012
1013
1014
1015
1016
1017 reserve_brk();
1018
1019 cleanup_highmap();
1020
1021 memblock_set_current_limit(ISA_END_ADDRESS);
1022 e820__memblock_setup();
1023
1024
1025
1026
1027
1028 sev_setup_arch();
1029
1030 efi_fake_memmap();
1031 efi_find_mirror();
1032 efi_esrt_init();
1033 efi_mokvar_table_init();
1034
1035
1036
1037
1038
1039 efi_reserve_boot_services();
1040
1041
1042 e820__memblock_alloc_reserved_mpc_new();
1043
1044#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
1045 setup_bios_corruption_check();
1046#endif
1047
1048#ifdef CONFIG_X86_32
1049 printk(KERN_DEBUG "initial memory mapped: [mem 0x00000000-%#010lx]\n",
1050 (max_pfn_mapped<<PAGE_SHIFT) - 1);
1051#endif
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067 reserve_real_mode();
1068
1069 init_mem_mapping();
1070
1071 idt_setup_early_pf();
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082 mmu_cr4_features = __read_cr4() & ~X86_CR4_PCIDE;
1083
1084 memblock_set_current_limit(get_max_mapped());
1085
1086
1087
1088
1089
1090#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
1091 if (init_ohci1394_dma_early)
1092 init_ohci1394_dma_on_all_controllers();
1093#endif
1094
1095 setup_log_buf(1);
1096
1097 if (efi_enabled(EFI_BOOT)) {
1098 switch (boot_params.secure_boot) {
1099 case efi_secureboot_mode_disabled:
1100 pr_info("Secure boot disabled\n");
1101 break;
1102 case efi_secureboot_mode_enabled:
1103 pr_info("Secure boot enabled\n");
1104 break;
1105 default:
1106 pr_info("Secure boot could not be determined\n");
1107 break;
1108 }
1109 }
1110
1111 reserve_initrd();
1112
1113 acpi_table_upgrade();
1114
1115 acpi_boot_table_init();
1116
1117 vsmp_init();
1118
1119 io_delay_init();
1120
1121 early_platform_quirks();
1122
1123 early_acpi_boot_init();
1124
1125 initmem_init();
1126 dma_contiguous_reserve(max_pfn_mapped << PAGE_SHIFT);
1127
1128 if (boot_cpu_has(X86_FEATURE_GBPAGES))
1129 hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
1130
1131
1132
1133
1134
1135 reserve_crashkernel();
1136
1137 memblock_find_dma_reserve();
1138
1139 if (!early_xdbc_setup_hardware())
1140 early_xdbc_register_console();
1141
1142 x86_init.paging.pagetable_init();
1143
1144 kasan_init();
1145
1146
1147
1148
1149
1150
1151
1152 sync_initial_page_table();
1153
1154 tboot_probe();
1155
1156 map_vsyscall();
1157
1158 generic_apic_probe();
1159
1160 early_quirks();
1161
1162
1163
1164
1165 acpi_boot_init();
1166 x86_dtb_init();
1167
1168
1169
1170
1171 get_smp_config();
1172
1173
1174
1175
1176
1177 init_apic_mappings();
1178
1179 prefill_possible_map();
1180
1181 init_cpu_to_node();
1182 init_gi_nodes();
1183
1184 io_apic_init_mappings();
1185
1186 x86_init.hyper.guest_late_init();
1187
1188 e820__reserve_resources();
1189 e820__register_nosave_regions(max_pfn);
1190
1191 x86_init.resources.reserve_resources();
1192
1193 e820__setup_pci_gap();
1194
1195#ifdef CONFIG_VT
1196#if defined(CONFIG_VGA_CONSOLE)
1197 if (!efi_enabled(EFI_BOOT) || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1198 conswitchp = &vga_con;
1199#endif
1200#endif
1201 x86_init.oem.banner();
1202
1203 x86_init.timers.wallclock_init();
1204
1205
1206
1207
1208
1209
1210
1211 therm_lvt_init();
1212
1213 mcheck_init();
1214
1215 register_refined_jiffies(CLOCK_TICK_RATE);
1216
1217#ifdef CONFIG_EFI
1218 if (efi_enabled(EFI_BOOT))
1219 efi_apply_memmap_quirks();
1220#endif
1221
1222 unwind_init();
1223}
1224
1225#ifdef CONFIG_X86_32
1226
1227static struct resource video_ram_resource = {
1228 .name = "Video RAM area",
1229 .start = 0xa0000,
1230 .end = 0xbffff,
1231 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
1232};
1233
1234void __init i386_reserve_resources(void)
1235{
1236 request_resource(&iomem_resource, &video_ram_resource);
1237 reserve_standard_io_resources();
1238}
1239
1240#endif
1241
1242static struct notifier_block kernel_offset_notifier = {
1243 .notifier_call = dump_kernel_offset
1244};
1245
1246static int __init register_kernel_offset_dumper(void)
1247{
1248 atomic_notifier_chain_register(&panic_notifier_list,
1249 &kernel_offset_notifier);
1250 return 0;
1251}
1252__initcall(register_kernel_offset_dumper);
1253