1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 1995 Linus Torvalds
4 *
5 * This file contains the setup_arch() code, which handles the architecture-dependent
6 * parts of early kernel initialization.
7 */
8#include <linux/acpi.h>
9#include <linux/console.h>
10#include <linux/cpu.h>
11#include <linux/crash_dump.h>
12#include <linux/dma-map-ops.h>
13#include <linux/efi.h>
14#include <linux/hugetlb.h>
15#include <linux/ima.h>
16#include <linux/init_ohci1394_dma.h>
17#include <linux/initrd.h>
18#include <linux/iscsi_ibft.h>
19#include <linux/memblock.h>
20#include <linux/panic_notifier.h>
21#include <linux/pci.h>
22#include <linux/random.h>
23#include <linux/root_dev.h>
24#include <linux/static_call.h>
25#include <linux/swiotlb.h>
26#include <linux/tboot.h>
27#include <linux/usb/xhci-dbgp.h>
28#include <linux/vmalloc.h>
29
30#include <uapi/linux/mount.h>
31
32#include <xen/xen.h>
33
34#include <asm/apic.h>
35#include <asm/bios_ebda.h>
36#include <asm/bugs.h>
37#include <asm/cacheinfo.h>
38#include <asm/coco.h>
39#include <asm/cpu.h>
40#include <asm/efi.h>
41#include <asm/gart.h>
42#include <asm/hypervisor.h>
43#include <asm/io_apic.h>
44#include <asm/kasan.h>
45#include <asm/kaslr.h>
46#include <asm/mce.h>
47#include <asm/memtype.h>
48#include <asm/mtrr.h>
49#include <asm/nmi.h>
50#include <asm/numa.h>
51#include <asm/olpc_ofw.h>
52#include <asm/pci-direct.h>
53#include <asm/prom.h>
54#include <asm/proto.h>
55#include <asm/realmode.h>
56#include <asm/thermal.h>
57#include <asm/unwind.h>
58#include <asm/vsyscall.h>
59
60/*
61 * max_low_pfn_mapped: highest directly mapped pfn < 4 GB
62 * max_pfn_mapped: highest directly mapped pfn > 4 GB
63 *
64 * The direct mapping only covers E820_TYPE_RAM regions, so the ranges and gaps are
65 * represented by pfn_mapped[].
66 */
67unsigned long max_low_pfn_mapped;
68unsigned long max_pfn_mapped;
69
70#ifdef CONFIG_DMI
71RESERVE_BRK(dmi_alloc, 65536);
72#endif
73
74
75unsigned long _brk_start = (unsigned long)__brk_base;
76unsigned long _brk_end = (unsigned long)__brk_base;
77
78struct boot_params boot_params;
79
80/*
81 * These are the four main kernel memory regions, we put them into
82 * the resource tree so that kdump tools and other debugging tools
83 * recover it:
84 */
85
86static struct resource rodata_resource = {
87 .name = "Kernel rodata",
88 .start = 0,
89 .end = 0,
90 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
91};
92
93static struct resource data_resource = {
94 .name = "Kernel data",
95 .start = 0,
96 .end = 0,
97 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
98};
99
100static struct resource code_resource = {
101 .name = "Kernel code",
102 .start = 0,
103 .end = 0,
104 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
105};
106
107static struct resource bss_resource = {
108 .name = "Kernel bss",
109 .start = 0,
110 .end = 0,
111 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
112};
113
114
115#ifdef CONFIG_X86_32
116/* CPU data as detected by the assembly code in head_32.S */
117struct cpuinfo_x86 new_cpu_data;
118
119struct apm_info apm_info;
120EXPORT_SYMBOL(apm_info);
121
122#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
123 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
124struct ist_info ist_info;
125EXPORT_SYMBOL(ist_info);
126#else
127struct ist_info ist_info;
128#endif
129
130#endif
131
132struct cpuinfo_x86 boot_cpu_data __read_mostly;
133EXPORT_SYMBOL(boot_cpu_data);
134SYM_PIC_ALIAS(boot_cpu_data);
135
136#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
137__visible unsigned long mmu_cr4_features __ro_after_init;
138#else
139__visible unsigned long mmu_cr4_features __ro_after_init = X86_CR4_PAE;
140#endif
141
142#ifdef CONFIG_IMA
143static phys_addr_t ima_kexec_buffer_phys;
144static size_t ima_kexec_buffer_size;
145#endif
146
147/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
148int bootloader_type, bootloader_version;
149
150static const struct ctl_table x86_sysctl_table[] = {
151 {
152 .procname = "unknown_nmi_panic",
153 .data = &unknown_nmi_panic,
154 .maxlen = sizeof(int),
155 .mode = 0644,
156 .proc_handler = proc_dointvec,
157 },
158 {
159 .procname = "panic_on_unrecovered_nmi",
160 .data = &panic_on_unrecovered_nmi,
161 .maxlen = sizeof(int),
162 .mode = 0644,
163 .proc_handler = proc_dointvec,
164 },
165 {
166 .procname = "panic_on_io_nmi",
167 .data = &panic_on_io_nmi,
168 .maxlen = sizeof(int),
169 .mode = 0644,
170 .proc_handler = proc_dointvec,
171 },
172 {
173 .procname = "bootloader_type",
174 .data = &bootloader_type,
175 .maxlen = sizeof(int),
176 .mode = 0444,
177 .proc_handler = proc_dointvec,
178 },
179 {
180 .procname = "bootloader_version",
181 .data = &bootloader_version,
182 .maxlen = sizeof(int),
183 .mode = 0444,
184 .proc_handler = proc_dointvec,
185 },
186 {
187 .procname = "io_delay_type",
188 .data = &io_delay_type,
189 .maxlen = sizeof(int),
190 .mode = 0644,
191 .proc_handler = proc_dointvec,
192 },
193#if defined(CONFIG_ACPI_SLEEP)
194 {
195 .procname = "acpi_video_flags",
196 .data = &acpi_realmode_flags,
197 .maxlen = sizeof(unsigned long),
198 .mode = 0644,
199 .proc_handler = proc_doulongvec_minmax,
200 },
201#endif
202};
203
204static int __init init_x86_sysctl(void)
205{
206 register_sysctl_init("kernel", x86_sysctl_table);
207 return 0;
208}
209arch_initcall(init_x86_sysctl);
210
211/*
212 * Setup options
213 */
214struct screen_info screen_info;
215EXPORT_SYMBOL(screen_info);
216#if defined(CONFIG_FIRMWARE_EDID)
217struct edid_info edid_info;
218EXPORT_SYMBOL_GPL(edid_info);
219#endif
220
221extern int root_mountflags;
222
223unsigned long saved_video_mode;
224
225#define RAMDISK_IMAGE_START_MASK 0x07FF
226#define RAMDISK_PROMPT_FLAG 0x8000
227#define RAMDISK_LOAD_FLAG 0x4000
228
229static char __initdata command_line[COMMAND_LINE_SIZE];
230#ifdef CONFIG_CMDLINE_BOOL
231char builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
232bool builtin_cmdline_added __ro_after_init;
233#endif
234
235#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
236struct edd edd;
237#ifdef CONFIG_EDD_MODULE
238EXPORT_SYMBOL(edd);
239#endif
240/**
241 * copy_edd() - Copy the BIOS EDD information
242 * from boot_params into a safe place.
243 *
244 */
245static inline void __init copy_edd(void)
246{
247 memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
248 sizeof(edd.mbr_signature));
249 memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
250 edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
251 edd.edd_info_nr = boot_params.eddbuf_entries;
252}
253#else
254static inline void __init copy_edd(void)
255{
256}
257#endif
258
259void * __init extend_brk(size_t size, size_t align)
260{
261 size_t mask = align - 1;
262 void *ret;
263
264 BUG_ON(_brk_start == 0);
265 BUG_ON(align & mask);
266
267 _brk_end = (_brk_end + mask) & ~mask;
268 BUG_ON((char *)(_brk_end + size) > __brk_limit);
269
270 ret = (void *)_brk_end;
271 _brk_end += size;
272
273 memset(s: ret, c: 0, n: size);
274
275 return ret;
276}
277
278#ifdef CONFIG_X86_32
279static void __init cleanup_highmap(void)
280{
281}
282#endif
283
284static void __init reserve_brk(void)
285{
286 if (_brk_end > _brk_start)
287 memblock_reserve_kern(__pa_symbol(_brk_start),
288 size: _brk_end - _brk_start);
289
290 /* Mark brk area as locked down and no longer taking any
291 new allocations */
292 _brk_start = 0;
293}
294
295#ifdef CONFIG_BLK_DEV_INITRD
296
297static u64 __init get_ramdisk_image(void)
298{
299 u64 ramdisk_image = boot_params.hdr.ramdisk_image;
300
301 ramdisk_image |= (u64)boot_params.ext_ramdisk_image << 32;
302
303 if (ramdisk_image == 0)
304 ramdisk_image = phys_initrd_start;
305
306 return ramdisk_image;
307}
308static u64 __init get_ramdisk_size(void)
309{
310 u64 ramdisk_size = boot_params.hdr.ramdisk_size;
311
312 ramdisk_size |= (u64)boot_params.ext_ramdisk_size << 32;
313
314 if (ramdisk_size == 0)
315 ramdisk_size = phys_initrd_size;
316
317 return ramdisk_size;
318}
319
320static void __init relocate_initrd(void)
321{
322 /* Assume only end is not page aligned */
323 u64 ramdisk_image = get_ramdisk_image();
324 u64 ramdisk_size = get_ramdisk_size();
325 u64 area_size = PAGE_ALIGN(ramdisk_size);
326 int ret = 0;
327
328 /* We need to move the initrd down into directly mapped mem */
329 u64 relocated_ramdisk = memblock_phys_alloc_range(size: area_size, PAGE_SIZE, start: 0,
330 PFN_PHYS(max_pfn_mapped));
331 if (!relocated_ramdisk)
332 panic(fmt: "Cannot find place for new RAMDISK of size %lld\n",
333 ramdisk_size);
334
335 initrd_start = relocated_ramdisk + PAGE_OFFSET;
336 initrd_end = initrd_start + ramdisk_size;
337 printk(KERN_INFO "Allocated new RAMDISK: [mem %#010llx-%#010llx]\n",
338 relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
339
340 ret = copy_from_early_mem(dest: (void *)initrd_start, src: ramdisk_image, size: ramdisk_size);
341 if (ret)
342 panic(fmt: "Copy RAMDISK failed\n");
343
344 printk(KERN_INFO "Move RAMDISK from [mem %#010llx-%#010llx] to"
345 " [mem %#010llx-%#010llx]\n",
346 ramdisk_image, ramdisk_image + ramdisk_size - 1,
347 relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
348}
349
350static void __init early_reserve_initrd(void)
351{
352 /* Assume only end is not page aligned */
353 u64 ramdisk_image = get_ramdisk_image();
354 u64 ramdisk_size = get_ramdisk_size();
355 u64 ramdisk_end = PAGE_ALIGN(ramdisk_image + ramdisk_size);
356
357 if (!boot_params.hdr.type_of_loader ||
358 !ramdisk_image || !ramdisk_size)
359 return; /* No initrd provided by bootloader */
360
361 memblock_reserve_kern(base: ramdisk_image, size: ramdisk_end - ramdisk_image);
362}
363
364static void __init reserve_initrd(void)
365{
366 /* Assume only end is not page aligned */
367 u64 ramdisk_image = get_ramdisk_image();
368 u64 ramdisk_size = get_ramdisk_size();
369 u64 ramdisk_end = PAGE_ALIGN(ramdisk_image + ramdisk_size);
370
371 if (!boot_params.hdr.type_of_loader ||
372 !ramdisk_image || !ramdisk_size)
373 return; /* No initrd provided by bootloader */
374
375 initrd_start = 0;
376
377 printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
378 ramdisk_end - 1);
379
380 if (pfn_range_is_mapped(PFN_DOWN(ramdisk_image),
381 PFN_DOWN(ramdisk_end))) {
382 /* All are mapped, easy case */
383 initrd_start = ramdisk_image + PAGE_OFFSET;
384 initrd_end = initrd_start + ramdisk_size;
385 return;
386 }
387
388 relocate_initrd();
389
390 memblock_phys_free(base: ramdisk_image, size: ramdisk_end - ramdisk_image);
391}
392
393#else
394static void __init early_reserve_initrd(void)
395{
396}
397static void __init reserve_initrd(void)
398{
399}
400#endif /* CONFIG_BLK_DEV_INITRD */
401
402static void __init add_early_ima_buffer(u64 phys_addr)
403{
404#ifdef CONFIG_IMA
405 struct ima_setup_data *data;
406
407 data = early_memremap(phys_addr + sizeof(struct setup_data), sizeof(*data));
408 if (!data) {
409 pr_warn("setup: failed to memremap ima_setup_data entry\n");
410 return;
411 }
412
413 if (data->size) {
414 memblock_reserve_kern(data->addr, data->size);
415 ima_kexec_buffer_phys = data->addr;
416 ima_kexec_buffer_size = data->size;
417 }
418
419 early_memunmap(data, sizeof(*data));
420#else
421 pr_warn("Passed IMA kexec data, but CONFIG_IMA not set. Ignoring.\n");
422#endif
423}
424
425#if defined(CONFIG_HAVE_IMA_KEXEC) && !defined(CONFIG_OF_FLATTREE)
426int __init ima_free_kexec_buffer(void)
427{
428 if (!ima_kexec_buffer_size)
429 return -ENOENT;
430
431 memblock_free_late(ima_kexec_buffer_phys,
432 ima_kexec_buffer_size);
433
434 ima_kexec_buffer_phys = 0;
435 ima_kexec_buffer_size = 0;
436
437 return 0;
438}
439
440int __init ima_get_kexec_buffer(void **addr, size_t *size)
441{
442 if (!ima_kexec_buffer_size)
443 return -ENOENT;
444
445 *addr = __va(ima_kexec_buffer_phys);
446 *size = ima_kexec_buffer_size;
447
448 return 0;
449}
450#endif
451
452static void __init add_kho(u64 phys_addr, u32 data_len)
453{
454 struct kho_data *kho;
455 u64 addr = phys_addr + sizeof(struct setup_data);
456 u64 size = data_len - sizeof(struct setup_data);
457
458 if (!IS_ENABLED(CONFIG_KEXEC_HANDOVER)) {
459 pr_warn("Passed KHO data, but CONFIG_KEXEC_HANDOVER not set. Ignoring.\n");
460 return;
461 }
462
463 kho = early_memremap(phys_addr: addr, size);
464 if (!kho) {
465 pr_warn("setup: failed to memremap kho data (0x%llx, 0x%llx)\n",
466 addr, size);
467 return;
468 }
469
470 kho_populate(fdt_phys: kho->fdt_addr, fdt_len: kho->fdt_size, scratch_phys: kho->scratch_addr, scratch_len: kho->scratch_size);
471
472 early_memunmap(addr: kho, size);
473}
474
475static void __init parse_setup_data(void)
476{
477 struct setup_data *data;
478 u64 pa_data, pa_next;
479
480 pa_data = boot_params.hdr.setup_data;
481 while (pa_data) {
482 u32 data_len, data_type;
483
484 data = early_memremap(phys_addr: pa_data, size: sizeof(*data));
485 data_len = data->len + sizeof(struct setup_data);
486 data_type = data->type;
487 pa_next = data->next;
488 early_memunmap(addr: data, size: sizeof(*data));
489
490 switch (data_type) {
491 case SETUP_E820_EXT:
492 e820__memory_setup_extended(phys_addr: pa_data, data_len);
493 break;
494 case SETUP_DTB:
495 add_dtb(data: pa_data);
496 break;
497 case SETUP_EFI:
498 parse_efi_setup(phys_addr: pa_data, data_len);
499 break;
500 case SETUP_IMA:
501 add_early_ima_buffer(phys_addr: pa_data);
502 break;
503 case SETUP_KEXEC_KHO:
504 add_kho(phys_addr: pa_data, data_len);
505 break;
506 case SETUP_RNG_SEED:
507 data = early_memremap(phys_addr: pa_data, size: data_len);
508 add_bootloader_randomness(buf: data->data, len: data->len);
509 /* Zero seed for forward secrecy. */
510 memzero_explicit(s: data->data, count: data->len);
511 /* Zero length in case we find ourselves back here by accident. */
512 memzero_explicit(s: &data->len, count: sizeof(data->len));
513 early_memunmap(addr: data, size: data_len);
514 break;
515 default:
516 break;
517 }
518 pa_data = pa_next;
519 }
520}
521
522/*
523 * Translate the fields of 'struct boot_param' into global variables
524 * representing these parameters.
525 */
526static void __init parse_boot_params(void)
527{
528 ROOT_DEV = old_decode_dev(val: boot_params.hdr.root_dev);
529 screen_info = boot_params.screen_info;
530#if defined(CONFIG_FIRMWARE_EDID)
531 edid_info = boot_params.edid_info;
532#endif
533#ifdef CONFIG_X86_32
534 apm_info.bios = boot_params.apm_bios_info;
535 ist_info = boot_params.ist_info;
536#endif
537 saved_video_mode = boot_params.hdr.vid_mode;
538 bootloader_type = boot_params.hdr.type_of_loader;
539 if ((bootloader_type >> 4) == 0xe) {
540 bootloader_type &= 0xf;
541 bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4;
542 }
543 bootloader_version = bootloader_type & 0xf;
544 bootloader_version |= boot_params.hdr.ext_loader_ver << 4;
545
546#ifdef CONFIG_BLK_DEV_RAM
547 rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
548#endif
549#ifdef CONFIG_EFI
550 if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
551 EFI32_LOADER_SIGNATURE, 4)) {
552 set_bit(EFI_BOOT, addr: &efi.flags);
553 } else if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
554 EFI64_LOADER_SIGNATURE, 4)) {
555 set_bit(EFI_BOOT, addr: &efi.flags);
556 set_bit(EFI_64BIT, addr: &efi.flags);
557 }
558#endif
559
560 if (!boot_params.hdr.root_flags)
561 root_mountflags &= ~MS_RDONLY;
562}
563
564static void __init memblock_x86_reserve_range_setup_data(void)
565{
566 struct setup_indirect *indirect;
567 struct setup_data *data;
568 u64 pa_data, pa_next;
569 u32 len;
570
571 pa_data = boot_params.hdr.setup_data;
572 while (pa_data) {
573 data = early_memremap(phys_addr: pa_data, size: sizeof(*data));
574 if (!data) {
575 pr_warn("setup: failed to memremap setup_data entry\n");
576 return;
577 }
578
579 len = sizeof(*data);
580 pa_next = data->next;
581
582 memblock_reserve_kern(base: pa_data, size: sizeof(*data) + data->len);
583
584 if (data->type == SETUP_INDIRECT) {
585 len += data->len;
586 early_memunmap(addr: data, size: sizeof(*data));
587 data = early_memremap(phys_addr: pa_data, size: len);
588 if (!data) {
589 pr_warn("setup: failed to memremap indirect setup_data\n");
590 return;
591 }
592
593 indirect = (struct setup_indirect *)data->data;
594
595 if (indirect->type != SETUP_INDIRECT)
596 memblock_reserve_kern(base: indirect->addr, size: indirect->len);
597 }
598
599 pa_data = pa_next;
600 early_memunmap(addr: data, size: len);
601 }
602}
603
604static void __init arch_reserve_crashkernel(void)
605{
606 unsigned long long crash_base, crash_size, low_size = 0, cma_size = 0;
607 bool high = false;
608 int ret;
609
610 if (!IS_ENABLED(CONFIG_CRASH_RESERVE))
611 return;
612
613 ret = parse_crashkernel(cmdline: boot_command_line, system_ram: memblock_phys_mem_size(),
614 crash_size: &crash_size, crash_base: &crash_base,
615 low_size: &low_size, cma_size: &cma_size, high: &high);
616 if (ret)
617 return;
618
619 if (xen_pv_domain()) {
620 pr_info("Ignoring crashkernel for a Xen PV domain\n");
621 return;
622 }
623
624 reserve_crashkernel_generic(crash_size, crash_base, crash_low_size: low_size, high);
625 reserve_crashkernel_cma(cma_size);
626}
627
628static struct resource standard_io_resources[] = {
629 { .name = "dma1", .start = 0x00, .end = 0x1f,
630 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
631 { .name = "pic1", .start = 0x20, .end = 0x21,
632 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
633 { .name = "timer0", .start = 0x40, .end = 0x43,
634 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
635 { .name = "timer1", .start = 0x50, .end = 0x53,
636 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
637 { .name = "keyboard", .start = 0x60, .end = 0x60,
638 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
639 { .name = "keyboard", .start = 0x64, .end = 0x64,
640 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
641 { .name = "dma page reg", .start = 0x80, .end = 0x8f,
642 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
643 { .name = "pic2", .start = 0xa0, .end = 0xa1,
644 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
645 { .name = "dma2", .start = 0xc0, .end = 0xdf,
646 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
647 { .name = "fpu", .start = 0xf0, .end = 0xff,
648 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
649};
650
651void __init reserve_standard_io_resources(void)
652{
653 int i;
654
655 /* request I/O space for devices used on all i[345]86 PCs */
656 for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
657 request_resource(root: &ioport_resource, new: &standard_io_resources[i]);
658
659}
660
661static void __init setup_kernel_resources(void)
662{
663 code_resource.start = __pa_symbol(_text);
664 code_resource.end = __pa_symbol(_etext)-1;
665 rodata_resource.start = __pa_symbol(__start_rodata);
666 rodata_resource.end = __pa_symbol(__end_rodata)-1;
667 data_resource.start = __pa_symbol(_sdata);
668 data_resource.end = __pa_symbol(_edata)-1;
669 bss_resource.start = __pa_symbol(__bss_start);
670 bss_resource.end = __pa_symbol(__bss_stop)-1;
671
672 insert_resource(parent: &iomem_resource, new: &code_resource);
673 insert_resource(parent: &iomem_resource, new: &rodata_resource);
674 insert_resource(parent: &iomem_resource, new: &data_resource);
675 insert_resource(parent: &iomem_resource, new: &bss_resource);
676}
677
678static bool __init snb_gfx_workaround_needed(void)
679{
680#ifdef CONFIG_PCI
681 int i;
682 u16 vendor, devid;
683 static const __initconst u16 snb_ids[] = {
684 0x0102,
685 0x0112,
686 0x0122,
687 0x0106,
688 0x0116,
689 0x0126,
690 0x010a,
691 };
692
693 /* Assume no if something weird is going on with PCI */
694 if (!early_pci_allowed())
695 return false;
696
697 vendor = read_pci_config_16(bus: 0, slot: 2, func: 0, PCI_VENDOR_ID);
698 if (vendor != 0x8086)
699 return false;
700
701 devid = read_pci_config_16(bus: 0, slot: 2, func: 0, PCI_DEVICE_ID);
702 for (i = 0; i < ARRAY_SIZE(snb_ids); i++)
703 if (devid == snb_ids[i])
704 return true;
705#endif
706
707 return false;
708}
709
710/*
711 * Sandy Bridge graphics has trouble with certain ranges, exclude
712 * them from allocation.
713 */
714static void __init trim_snb_memory(void)
715{
716 static const __initconst unsigned long bad_pages[] = {
717 0x20050000,
718 0x20110000,
719 0x20130000,
720 0x20138000,
721 0x40004000,
722 };
723 int i;
724
725 if (!snb_gfx_workaround_needed())
726 return;
727
728 printk(KERN_DEBUG "reserving inaccessible SNB gfx pages\n");
729
730 /*
731 * SandyBridge integrated graphics devices have a bug that prevents
732 * them from accessing certain memory ranges, namely anything below
733 * 1M and in the pages listed in bad_pages[] above.
734 *
735 * To avoid these pages being ever accessed by SNB gfx devices reserve
736 * bad_pages that have not already been reserved at boot time.
737 * All memory below the 1 MB mark is anyway reserved later during
738 * setup_arch(), so there is no need to reserve it here.
739 */
740
741 for (i = 0; i < ARRAY_SIZE(bad_pages); i++) {
742 if (memblock_reserve(base: bad_pages[i], PAGE_SIZE))
743 printk(KERN_WARNING "failed to reserve 0x%08lx\n",
744 bad_pages[i]);
745 }
746}
747
748static void __init trim_bios_range(void)
749{
750 /*
751 * A special case is the first 4Kb of memory;
752 * This is a BIOS owned area, not kernel ram, but generally
753 * not listed as such in the E820 table.
754 *
755 * This typically reserves additional memory (64KiB by default)
756 * since some BIOSes are known to corrupt low memory. See the
757 * Kconfig help text for X86_RESERVE_LOW.
758 */
759 e820__range_update(start: 0, PAGE_SIZE, old_type: E820_TYPE_RAM, new_type: E820_TYPE_RESERVED);
760
761 /*
762 * special case: Some BIOSes report the PC BIOS
763 * area (640Kb -> 1Mb) as RAM even though it is not.
764 * take them out.
765 */
766 e820__range_remove(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, old_type: E820_TYPE_RAM, check_type: 1);
767
768 e820__update_table(table: e820_table);
769}
770
771/* called before trim_bios_range() to spare extra sanitize */
772static void __init e820_add_kernel_range(void)
773{
774 u64 start = __pa_symbol(_text);
775 u64 size = __pa_symbol(_end) - start;
776
777 /*
778 * Complain if .text .data and .bss are not marked as E820_TYPE_RAM and
779 * attempt to fix it by adding the range. We may have a confused BIOS,
780 * or the user may have used memmap=exactmap or memmap=xxM$yyM to
781 * exclude kernel range. If we really are running on top non-RAM,
782 * we will crash later anyways.
783 */
784 if (e820__mapped_all(start, end: start + size, type: E820_TYPE_RAM))
785 return;
786
787 pr_warn(".text .data .bss are not marked as E820_TYPE_RAM!\n");
788 e820__range_remove(start, size, old_type: E820_TYPE_RAM, check_type: 0);
789 e820__range_add(start, size, type: E820_TYPE_RAM);
790}
791
792static void __init early_reserve_memory(void)
793{
794 /*
795 * Reserve the memory occupied by the kernel between _text and
796 * __end_of_kernel_reserve symbols. Any kernel sections after the
797 * __end_of_kernel_reserve symbol must be explicitly reserved with a
798 * separate memblock_reserve() or they will be discarded.
799 */
800 memblock_reserve_kern(__pa_symbol(_text),
801 size: (unsigned long)__end_of_kernel_reserve - (unsigned long)_text);
802
803 /*
804 * The first 4Kb of memory is a BIOS owned area, but generally it is
805 * not listed as such in the E820 table.
806 *
807 * Reserve the first 64K of memory since some BIOSes are known to
808 * corrupt low memory. After the real mode trampoline is allocated the
809 * rest of the memory below 640k is reserved.
810 *
811 * In addition, make sure page 0 is always reserved because on
812 * systems with L1TF its contents can be leaked to user processes.
813 */
814 memblock_reserve(base: 0, SZ_64K);
815
816 early_reserve_initrd();
817
818 memblock_x86_reserve_range_setup_data();
819
820 reserve_bios_regions();
821 trim_snb_memory();
822}
823
824/*
825 * Dump out kernel offset information on panic.
826 */
827static int
828dump_kernel_offset(struct notifier_block *self, unsigned long v, void *p)
829{
830 if (kaslr_enabled()) {
831 pr_emerg("Kernel Offset: 0x%lx from 0x%lx (relocation range: 0x%lx-0x%lx)\n",
832 kaslr_offset(),
833 __START_KERNEL,
834 __START_KERNEL_map,
835 MODULES_VADDR-1);
836 } else {
837 pr_emerg("Kernel Offset: disabled\n");
838 }
839
840 return 0;
841}
842
843void x86_configure_nx(void)
844{
845 if (boot_cpu_has(X86_FEATURE_NX))
846 __supported_pte_mask |= _PAGE_NX;
847 else
848 __supported_pte_mask &= ~_PAGE_NX;
849}
850
851static void __init x86_report_nx(void)
852{
853 if (!boot_cpu_has(X86_FEATURE_NX)) {
854 printk(KERN_NOTICE "Notice: NX (Execute Disable) protection "
855 "missing in CPU!\n");
856 } else {
857#if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
858 printk(KERN_INFO "NX (Execute Disable) protection: active\n");
859#else
860 /* 32bit non-PAE kernel, NX cannot be used */
861 printk(KERN_NOTICE "Notice: NX (Execute Disable) protection "
862 "cannot be enabled: non-PAE kernel!\n");
863#endif
864 }
865}
866
867/*
868 * Determine if we were loaded by an EFI loader. If so, then we have also been
869 * passed the efi memmap, systab, etc., so we should use these data structures
870 * for initialization. Note, the efi init code path is determined by the
871 * global efi_enabled. This allows the same kernel image to be used on existing
872 * systems (with a traditional BIOS) as well as on EFI systems.
873 */
874/*
875 * setup_arch - architecture-specific boot-time initializations
876 *
877 * Note: On x86_64, fixmaps are ready for use even before this is called.
878 */
879
880void __init setup_arch(char **cmdline_p)
881{
882#ifdef CONFIG_X86_32
883 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
884
885 /*
886 * copy kernel address range established so far and switch
887 * to the proper swapper page table
888 */
889 clone_pgd_range(swapper_pg_dir + KERNEL_PGD_BOUNDARY,
890 initial_page_table + KERNEL_PGD_BOUNDARY,
891 KERNEL_PGD_PTRS);
892
893 load_cr3(swapper_pg_dir);
894 /*
895 * Note: Quark X1000 CPUs advertise PGE incorrectly and require
896 * a cr3 based tlb flush, so the following __flush_tlb_all()
897 * will not flush anything because the CPU quirk which clears
898 * X86_FEATURE_PGE has not been invoked yet. Though due to the
899 * load_cr3() above the TLB has been flushed already. The
900 * quirk is invoked before subsequent calls to __flush_tlb_all()
901 * so proper operation is guaranteed.
902 */
903 __flush_tlb_all();
904#else
905 printk(KERN_INFO "Command line: %s\n", boot_command_line);
906 boot_cpu_data.x86_phys_bits = MAX_PHYSMEM_BITS;
907#endif
908
909#ifdef CONFIG_CMDLINE_BOOL
910#ifdef CONFIG_CMDLINE_OVERRIDE
911 strscpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
912#else
913 if (builtin_cmdline[0]) {
914 /* append boot loader cmdline to builtin */
915 strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
916 strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
917 strscpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
918 }
919#endif
920 builtin_cmdline_added = true;
921#endif
922
923 strscpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
924 *cmdline_p = command_line;
925
926 /*
927 * If we have OLPC OFW, we might end up relocating the fixmap due to
928 * reserve_top(), so do this before touching the ioremap area.
929 */
930 olpc_ofw_detect();
931
932 idt_setup_early_traps();
933 early_cpu_init();
934 jump_label_init();
935 static_call_init();
936 early_ioremap_init();
937
938 setup_olpc_ofw_pgd();
939
940 parse_boot_params();
941
942 x86_init.oem.arch_setup();
943
944 /*
945 * Do some memory reservations *before* memory is added to memblock, so
946 * memblock allocations won't overwrite it.
947 *
948 * After this point, everything still needed from the boot loader or
949 * firmware or kernel text should be early reserved or marked not RAM in
950 * e820. All other memory is free game.
951 *
952 * This call needs to happen before e820__memory_setup() which calls the
953 * xen_memory_setup() on Xen dom0 which relies on the fact that those
954 * early reservations have happened already.
955 */
956 early_reserve_memory();
957
958 iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
959 e820__memory_setup();
960 parse_setup_data();
961
962 copy_edd();
963
964 setup_initial_init_mm(start_code: _text, end_code: _etext, end_data: _edata, brk: (void *)_brk_end);
965
966 /*
967 * x86_configure_nx() is called before parse_early_param() to detect
968 * whether hardware doesn't support NX (so that the early EHCI debug
969 * console setup can safely call set_fixmap()).
970 */
971 x86_configure_nx();
972
973 parse_early_param();
974
975 if (efi_enabled(EFI_BOOT))
976 efi_memblock_x86_reserve_range();
977
978 x86_report_nx();
979
980 apic_setup_apic_calls();
981
982 if (acpi_mps_check()) {
983#ifdef CONFIG_X86_LOCAL_APIC
984 apic_is_disabled = true;
985#endif
986 setup_clear_cpu_cap(X86_FEATURE_APIC);
987 }
988
989 e820__finish_early_params();
990
991 if (efi_enabled(EFI_BOOT))
992 efi_init();
993
994 reserve_ibft_region();
995 x86_init.resources.dmi_setup();
996
997 /*
998 * VMware detection requires dmi to be available, so this
999 * needs to be done after dmi_setup(), for the boot CPU.
1000 * For some guest types (Xen PV, SEV-SNP, TDX) it is required to be
1001 * called before cache_bp_init() for setting up MTRR state.
1002 */
1003 init_hypervisor_platform();
1004
1005 tsc_early_init();
1006 x86_init.resources.probe_roms();
1007
1008 /*
1009 * Add resources for kernel text and data to the iomem_resource.
1010 * Do it after parse_early_param, so it can be debugged.
1011 */
1012 setup_kernel_resources();
1013
1014 e820_add_kernel_range();
1015 trim_bios_range();
1016#ifdef CONFIG_X86_32
1017 if (ppro_with_ram_bug()) {
1018 e820__range_update(0x70000000ULL, 0x40000ULL, E820_TYPE_RAM,
1019 E820_TYPE_RESERVED);
1020 e820__update_table(e820_table);
1021 printk(KERN_INFO "fixed physical RAM map:\n");
1022 e820__print_table("bad_ppro");
1023 }
1024#else
1025 early_gart_iommu_check();
1026#endif
1027
1028 /*
1029 * partially used pages are not usable - thus
1030 * we are rounding upwards:
1031 */
1032 max_pfn = e820__end_of_ram_pfn();
1033
1034 /* update e820 for memory not covered by WB MTRRs */
1035 cache_bp_init();
1036 if (mtrr_trim_uncached_memory(end_pfn: max_pfn))
1037 max_pfn = e820__end_of_ram_pfn();
1038
1039 max_possible_pfn = max_pfn;
1040
1041 /*
1042 * Define random base addresses for memory sections after max_pfn is
1043 * defined and before each memory section base is used.
1044 */
1045 kernel_randomize_memory();
1046
1047#ifdef CONFIG_X86_32
1048 /* max_low_pfn get updated here */
1049 find_low_pfn_range();
1050#else
1051 check_x2apic();
1052
1053 /* How many end-of-memory variables you have, grandma! */
1054 /* need this before calling reserve_initrd */
1055 if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
1056 max_low_pfn = e820__end_of_low_ram_pfn();
1057 else
1058 max_low_pfn = max_pfn;
1059#endif
1060
1061 /* Find and reserve MPTABLE area */
1062 x86_init.mpparse.find_mptable();
1063
1064 early_alloc_pgt_buf();
1065
1066 /*
1067 * Need to conclude brk, before e820__memblock_setup()
1068 * it could use memblock_find_in_range, could overlap with
1069 * brk area.
1070 */
1071 reserve_brk();
1072
1073 cleanup_highmap();
1074
1075 e820__memblock_setup();
1076
1077 /*
1078 * Needs to run after memblock setup because it needs the physical
1079 * memory size.
1080 */
1081 mem_encrypt_setup_arch();
1082 cc_random_init();
1083
1084 efi_find_mirror();
1085 efi_esrt_init();
1086 efi_mokvar_table_init();
1087
1088 /*
1089 * The EFI specification says that boot service code won't be
1090 * called after ExitBootServices(). This is, in fact, a lie.
1091 */
1092 efi_reserve_boot_services();
1093
1094 /* preallocate 4k for mptable mpc */
1095 e820__memblock_alloc_reserved_mpc_new();
1096
1097#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
1098 setup_bios_corruption_check();
1099#endif
1100
1101#ifdef CONFIG_X86_32
1102 printk(KERN_DEBUG "initial memory mapped: [mem 0x00000000-%#010lx]\n",
1103 (max_pfn_mapped<<PAGE_SHIFT) - 1);
1104#endif
1105
1106 /*
1107 * Find free memory for the real mode trampoline and place it there. If
1108 * there is not enough free memory under 1M, on EFI-enabled systems
1109 * there will be additional attempt to reclaim the memory for the real
1110 * mode trampoline at efi_free_boot_services().
1111 *
1112 * Unconditionally reserve the entire first 1M of RAM because BIOSes
1113 * are known to corrupt low memory and several hundred kilobytes are not
1114 * worth complex detection what memory gets clobbered. Windows does the
1115 * same thing for very similar reasons.
1116 *
1117 * Moreover, on machines with SandyBridge graphics or in setups that use
1118 * crashkernel the entire 1M is reserved anyway.
1119 *
1120 * Note the host kernel TDX also requires the first 1MB being reserved.
1121 */
1122 x86_platform.realmode_reserve();
1123
1124 init_mem_mapping();
1125
1126 /*
1127 * init_mem_mapping() relies on the early IDT page fault handling.
1128 * Now either enable FRED or install the real page fault handler
1129 * for 64-bit in the IDT.
1130 */
1131 cpu_init_replace_early_idt();
1132
1133 /*
1134 * Update mmu_cr4_features (and, indirectly, trampoline_cr4_features)
1135 * with the current CR4 value. This may not be necessary, but
1136 * auditing all the early-boot CR4 manipulation would be needed to
1137 * rule it out.
1138 *
1139 * Mask off features that don't work outside long mode (just
1140 * PCIDE for now).
1141 */
1142 mmu_cr4_features = __read_cr4() & ~X86_CR4_PCIDE;
1143
1144 memblock_set_current_limit(limit: get_max_mapped());
1145
1146 /*
1147 * NOTE: On x86-32, only from this point on, fixmaps are ready for use.
1148 */
1149
1150#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
1151 if (init_ohci1394_dma_early)
1152 init_ohci1394_dma_on_all_controllers();
1153#endif
1154 /* Allocate bigger log buffer */
1155 setup_log_buf(1);
1156
1157 if (efi_enabled(EFI_BOOT)) {
1158 switch (boot_params.secure_boot) {
1159 case efi_secureboot_mode_disabled:
1160 pr_info("Secure boot disabled\n");
1161 break;
1162 case efi_secureboot_mode_enabled:
1163 pr_info("Secure boot enabled\n");
1164 break;
1165 default:
1166 pr_info("Secure boot could not be determined\n");
1167 break;
1168 }
1169 }
1170
1171 reserve_initrd();
1172
1173 acpi_table_upgrade();
1174 /* Look for ACPI tables and reserve memory occupied by them. */
1175 acpi_boot_table_init();
1176
1177 vsmp_init();
1178
1179 io_delay_init();
1180
1181 early_platform_quirks();
1182
1183 /* Some platforms need the APIC registered for NUMA configuration */
1184 early_acpi_boot_init();
1185 x86_init.mpparse.early_parse_smp_cfg();
1186
1187 x86_flattree_get_config();
1188
1189 initmem_init();
1190 dma_contiguous_reserve(limit: max_pfn_mapped << PAGE_SHIFT);
1191
1192 if (boot_cpu_has(X86_FEATURE_GBPAGES)) {
1193 hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
1194 hugetlb_bootmem_alloc();
1195 }
1196
1197 /*
1198 * Reserve memory for crash kernel after SRAT is parsed so that it
1199 * won't consume hotpluggable memory.
1200 */
1201 arch_reserve_crashkernel();
1202
1203 if (!early_xdbc_setup_hardware())
1204 early_xdbc_register_console();
1205
1206 x86_init.paging.pagetable_init();
1207
1208 kasan_init();
1209
1210 /*
1211 * Sync back kernel address range.
1212 *
1213 * FIXME: Can the later sync in setup_cpu_entry_areas() replace
1214 * this call?
1215 */
1216 sync_initial_page_table();
1217
1218 tboot_probe();
1219
1220 map_vsyscall();
1221
1222 x86_32_probe_apic();
1223
1224 early_quirks();
1225
1226 topology_apply_cmdline_limits_early();
1227
1228 /*
1229 * Parse SMP configuration. Try ACPI first and then the platform
1230 * specific parser.
1231 */
1232 acpi_boot_init();
1233 x86_init.mpparse.parse_smp_cfg();
1234
1235 /* Last opportunity to detect and map the local APIC */
1236 init_apic_mappings();
1237
1238 topology_init_possible_cpus();
1239
1240 init_cpu_to_node();
1241 init_gi_nodes();
1242
1243 io_apic_init_mappings();
1244
1245 x86_init.hyper.guest_late_init();
1246
1247 e820__reserve_resources();
1248 e820__register_nosave_regions(limit_pfn: max_pfn);
1249
1250 x86_init.resources.reserve_resources();
1251
1252 e820__setup_pci_gap();
1253
1254#ifdef CONFIG_VT
1255#if defined(CONFIG_VGA_CONSOLE)
1256 if (!efi_enabled(EFI_BOOT) || (efi_mem_type(phys_addr: 0xa0000) != EFI_CONVENTIONAL_MEMORY))
1257 vgacon_register_screen(si: &screen_info);
1258#endif
1259#endif
1260 x86_init.oem.banner();
1261
1262 x86_init.timers.wallclock_init();
1263
1264 /*
1265 * This needs to run before setup_local_APIC() which soft-disables the
1266 * local APIC temporarily and that masks the thermal LVT interrupt,
1267 * leading to softlockups on machines which have configured SMI
1268 * interrupt delivery.
1269 */
1270 therm_lvt_init();
1271
1272 mcheck_init();
1273
1274 register_refined_jiffies(CLOCK_TICK_RATE);
1275
1276#ifdef CONFIG_EFI
1277 if (efi_enabled(EFI_BOOT))
1278 efi_apply_memmap_quirks();
1279#endif
1280
1281 unwind_init();
1282}
1283
1284#ifdef CONFIG_X86_32
1285
1286static struct resource video_ram_resource = {
1287 .name = "Video RAM area",
1288 .start = 0xa0000,
1289 .end = 0xbffff,
1290 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
1291};
1292
1293void __init i386_reserve_resources(void)
1294{
1295 request_resource(&iomem_resource, &video_ram_resource);
1296 reserve_standard_io_resources();
1297}
1298
1299#endif /* CONFIG_X86_32 */
1300
1301static struct notifier_block kernel_offset_notifier = {
1302 .notifier_call = dump_kernel_offset
1303};
1304
1305static int __init register_kernel_offset_dumper(void)
1306{
1307 atomic_notifier_chain_register(nh: &panic_notifier_list,
1308 nb: &kernel_offset_notifier);
1309 return 0;
1310}
1311__initcall(register_kernel_offset_dumper);
1312
1313#ifdef CONFIG_HOTPLUG_CPU
1314bool arch_cpu_is_hotpluggable(int cpu)
1315{
1316 return cpu > 0;
1317}
1318#endif /* CONFIG_HOTPLUG_CPU */
1319