arch/x86/kernel/setup.c

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