arch/x86/kernel/crash.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Architecture specific (i386/x86_64) functions for kexec based crash dumps.
   4  *
   5  * Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
   6  *
   7  * Copyright (C) IBM Corporation, 2004. All rights reserved.
   8  * Copyright (C) Red Hat Inc., 2014. All rights reserved.
   9  * Authors:
  10  *      Vivek Goyal <vgoyal@redhat.com>
  11  *
  12  */
  13
  14 #define pr_fmt(fmt)     "kexec: " fmt
  15
  16 #include <linux/types.h>
  17 #include <linux/kernel.h>
  18 #include <linux/smp.h>
  19 #include <linux/reboot.h>
  20 #include <linux/kexec.h>
  21 #include <linux/delay.h>
  22 #include <linux/elf.h>
  23 #include <linux/elfcore.h>
  24 #include <linux/export.h>
  25 #include <linux/slab.h>
  26 #include <linux/vmalloc.h>
  27
  28 #include <asm/processor.h>
  29 #include <asm/hardirq.h>
  30 #include <asm/nmi.h>
  31 #include <asm/hw_irq.h>
  32 #include <asm/apic.h>
  33 #include <asm/e820/types.h>
  34 #include <asm/io_apic.h>
  35 #include <asm/hpet.h>
  36 #include <linux/kdebug.h>
  37 #include <asm/cpu.h>
  38 #include <asm/reboot.h>
  39 #include <asm/virtext.h>
  40 #include <asm/intel_pt.h>
  41 #include <asm/crash.h>
  42
  43 /* Used while preparing memory map entries for second kernel */
  44 struct crash_memmap_data {
  45         struct boot_params *params;
  46         /* Type of memory */
  47         unsigned int type;
  48 };
  49
  50 /*
  51  * This is used to VMCLEAR all VMCSs loaded on the
  52  * processor. And when loading kvm_intel module, the
  53  * callback function pointer will be assigned.
  54  *
  55  * protected by rcu.
  56  */
  57 crash_vmclear_fn __rcu *crash_vmclear_loaded_vmcss = NULL;
  58 EXPORT_SYMBOL_GPL(crash_vmclear_loaded_vmcss);
  59
  60 static inline void cpu_crash_vmclear_loaded_vmcss(void)
  61 {
  62         crash_vmclear_fn *do_vmclear_operation = NULL;
  63
  64         rcu_read_lock();
  65         do_vmclear_operation = rcu_dereference(crash_vmclear_loaded_vmcss);
  66         if (do_vmclear_operation)
  67                 do_vmclear_operation();
  68         rcu_read_unlock();
  69 }
  70
  71 #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
  72
  73 static void kdump_nmi_callback(int cpu, struct pt_regs *regs)
  74 {
  75 #ifdef CONFIG_X86_32
  76         struct pt_regs fixed_regs;
  77
  78         if (!user_mode(regs)) {
  79                 crash_fixup_ss_esp(&fixed_regs, regs);
  80                 regs = &fixed_regs;
  81         }
  82 #endif
  83         crash_save_cpu(regs, cpu);
  84
  85         /*
  86          * VMCLEAR VMCSs loaded on all cpus if needed.
  87          */
  88         cpu_crash_vmclear_loaded_vmcss();
  89
  90         /* Disable VMX or SVM if needed.
  91          *
  92          * We need to disable virtualization on all CPUs.
  93          * Having VMX or SVM enabled on any CPU may break rebooting
  94          * after the kdump kernel has finished its task.
  95          */
  96         cpu_emergency_vmxoff();
  97         cpu_emergency_svm_disable();
  98
  99         /*
 100          * Disable Intel PT to stop its logging
 101          */
 102         cpu_emergency_stop_pt();
 103
 104         disable_local_APIC();
 105 }
 106
 107 void kdump_nmi_shootdown_cpus(void)
 108 {
 109         nmi_shootdown_cpus(kdump_nmi_callback);
 110
 111         disable_local_APIC();
 112 }
 113
 114 /* Override the weak function in kernel/panic.c */
 115 void crash_smp_send_stop(void)
 116 {
 117         static int cpus_stopped;
 118
 119         if (cpus_stopped)
 120                 return;
 121
 122         if (smp_ops.crash_stop_other_cpus)
 123                 smp_ops.crash_stop_other_cpus();
 124         else
 125                 smp_send_stop();
 126
 127         cpus_stopped = 1;
 128 }
 129
 130 #else
 131 void crash_smp_send_stop(void)
 132 {
 133         /* There are no cpus to shootdown */
 134 }
 135 #endif
 136
 137 void native_machine_crash_shutdown(struct pt_regs *regs)
 138 {
 139         /* This function is only called after the system
 140          * has panicked or is otherwise in a critical state.
 141          * The minimum amount of code to allow a kexec'd kernel
 142          * to run successfully needs to happen here.
 143          *
 144          * In practice this means shooting down the other cpus in
 145          * an SMP system.
 146          */
 147         /* The kernel is broken so disable interrupts */
 148         local_irq_disable();
 149
 150         crash_smp_send_stop();
 151
 152         /*
 153          * VMCLEAR VMCSs loaded on this cpu if needed.
 154          */
 155         cpu_crash_vmclear_loaded_vmcss();
 156
 157         /* Booting kdump kernel with VMX or SVM enabled won't work,
 158          * because (among other limitations) we can't disable paging
 159          * with the virt flags.
 160          */
 161         cpu_emergency_vmxoff();
 162         cpu_emergency_svm_disable();
 163
 164         /*
 165          * Disable Intel PT to stop its logging
 166          */
 167         cpu_emergency_stop_pt();
 168
 169 #ifdef CONFIG_X86_IO_APIC
 170         /* Prevent crash_kexec() from deadlocking on ioapic_lock. */
 171         ioapic_zap_locks();
 172         clear_IO_APIC();
 173 #endif
 174         lapic_shutdown();
 175         restore_boot_irq_mode();
 176 #ifdef CONFIG_HPET_TIMER
 177         hpet_disable();
 178 #endif
 179         crash_save_cpu(regs, safe_smp_processor_id());
 180 }
 181
 182 #ifdef CONFIG_KEXEC_FILE
 183
 184 static unsigned long crash_zero_bytes;
 185
 186 static int get_nr_ram_ranges_callback(struct resource *res, void *arg)
 187 {
 188         unsigned int *nr_ranges = arg;
 189
 190         (*nr_ranges)++;
 191         return 0;
 192 }
 193
 194 /* Gather all the required information to prepare elf headers for ram regions */
 195 static struct crash_mem *fill_up_crash_elf_data(void)
 196 {
 197         unsigned int nr_ranges = 0;
 198         struct crash_mem *cmem;
 199
 200         walk_system_ram_res(0, -1, &nr_ranges,
 201                                 get_nr_ram_ranges_callback);
 202         if (!nr_ranges)
 203                 return NULL;
 204
 205         /*
 206          * Exclusion of crash region and/or crashk_low_res may cause
 207          * another range split. So add extra two slots here.
 208          */
 209         nr_ranges += 2;
 210         cmem = vzalloc(struct_size(cmem, ranges, nr_ranges));
 211         if (!cmem)
 212                 return NULL;
 213
 214         cmem->max_nr_ranges = nr_ranges;
 215         cmem->nr_ranges = 0;
 216
 217         return cmem;
 218 }
 219
 220 /*
 221  * Look for any unwanted ranges between mstart, mend and remove them. This
 222  * might lead to split and split ranges are put in cmem->ranges[] array
 223  */
 224 static int elf_header_exclude_ranges(struct crash_mem *cmem)
 225 {
 226         int ret = 0;
 227
 228         /* Exclude crashkernel region */
 229         ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
 230         if (ret)
 231                 return ret;
 232
 233         if (crashk_low_res.end) {
 234                 ret = crash_exclude_mem_range(cmem, crashk_low_res.start,
 235                                                         crashk_low_res.end);
 236                 if (ret)
 237                         return ret;
 238         }
 239
 240         return ret;
 241 }
 242
 243 static int prepare_elf64_ram_headers_callback(struct resource *res, void *arg)
 244 {
 245         struct crash_mem *cmem = arg;
 246
 247         cmem->ranges[cmem->nr_ranges].start = res->start;
 248         cmem->ranges[cmem->nr_ranges].end = res->end;
 249         cmem->nr_ranges++;
 250
 251         return 0;
 252 }
 253
 254 /* Prepare elf headers. Return addr and size */
 255 static int prepare_elf_headers(struct kimage *image, void **addr,
 256                                         unsigned long *sz)
 257 {
 258         struct crash_mem *cmem;
 259         Elf64_Ehdr *ehdr;
 260         Elf64_Phdr *phdr;
 261         int ret, i;
 262
 263         cmem = fill_up_crash_elf_data();
 264         if (!cmem)
 265                 return -ENOMEM;
 266
 267         ret = walk_system_ram_res(0, -1, cmem,
 268                                 prepare_elf64_ram_headers_callback);
 269         if (ret)
 270                 goto out;
 271
 272         /* Exclude unwanted mem ranges */
 273         ret = elf_header_exclude_ranges(cmem);
 274         if (ret)
 275                 goto out;
 276
 277         /* By default prepare 64bit headers */
 278         ret =  crash_prepare_elf64_headers(cmem,
 279                                 IS_ENABLED(CONFIG_X86_64), addr, sz);
 280         if (ret)
 281                 goto out;
 282
 283         /*
 284          * If a range matches backup region, adjust offset to backup
 285          * segment.
 286          */
 287         ehdr = (Elf64_Ehdr *)*addr;
 288         phdr = (Elf64_Phdr *)(ehdr + 1);
 289         for (i = 0; i < ehdr->e_phnum; phdr++, i++)
 290                 if (phdr->p_type == PT_LOAD &&
 291                                 phdr->p_paddr == image->arch.backup_src_start &&
 292                                 phdr->p_memsz == image->arch.backup_src_sz) {
 293                         phdr->p_offset = image->arch.backup_load_addr;
 294                         break;
 295                 }
 296 out:
 297         vfree(cmem);
 298         return ret;
 299 }
 300
 301 static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)
 302 {
 303         unsigned int nr_e820_entries;
 304
 305         nr_e820_entries = params->e820_entries;
 306         if (nr_e820_entries >= E820_MAX_ENTRIES_ZEROPAGE)
 307                 return 1;
 308
 309         memcpy(&params->e820_table[nr_e820_entries], entry,
 310                         sizeof(struct e820_entry));
 311         params->e820_entries++;
 312         return 0;
 313 }
 314
 315 static int memmap_entry_callback(struct resource *res, void *arg)
 316 {
 317         struct crash_memmap_data *cmd = arg;
 318         struct boot_params *params = cmd->params;
 319         struct e820_entry ei;
 320
 321         ei.addr = res->start;
 322         ei.size = resource_size(res);
 323         ei.type = cmd->type;
 324         add_e820_entry(params, &ei);
 325
 326         return 0;
 327 }
 328
 329 static int memmap_exclude_ranges(struct kimage *image, struct crash_mem *cmem,
 330                                  unsigned long long mstart,
 331                                  unsigned long long mend)
 332 {
 333         unsigned long start, end;
 334         int ret = 0;
 335
 336         cmem->ranges[0].start = mstart;
 337         cmem->ranges[0].end = mend;
 338         cmem->nr_ranges = 1;
 339
 340         /* Exclude Backup region */
 341         start = image->arch.backup_load_addr;
 342         end = start + image->arch.backup_src_sz - 1;
 343         ret = crash_exclude_mem_range(cmem, start, end);
 344         if (ret)
 345                 return ret;
 346
 347         /* Exclude elf header region */
 348         start = image->arch.elf_load_addr;
 349         end = start + image->arch.elf_headers_sz - 1;
 350         return crash_exclude_mem_range(cmem, start, end);
 351 }
 352
 353 /* Prepare memory map for crash dump kernel */
 354 int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
 355 {
 356         int i, ret = 0;
 357         unsigned long flags;
 358         struct e820_entry ei;
 359         struct crash_memmap_data cmd;
 360         struct crash_mem *cmem;
 361
 362         cmem = vzalloc(sizeof(struct crash_mem));
 363         if (!cmem)
 364                 return -ENOMEM;
 365
 366         memset(&cmd, 0, sizeof(struct crash_memmap_data));
 367         cmd.params = params;
 368
 369         /* Add first 640K segment */
 370         ei.addr = image->arch.backup_src_start;
 371         ei.size = image->arch.backup_src_sz;
 372         ei.type = E820_TYPE_RAM;
 373         add_e820_entry(params, &ei);
 374
 375         /* Add ACPI tables */
 376         cmd.type = E820_TYPE_ACPI;
 377         flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 378         walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd,
 379                        memmap_entry_callback);
 380
 381         /* Add ACPI Non-volatile Storage */
 382         cmd.type = E820_TYPE_NVS;
 383         walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd,
 384                         memmap_entry_callback);
 385
 386         /* Add crashk_low_res region */
 387         if (crashk_low_res.end) {
 388                 ei.addr = crashk_low_res.start;
 389                 ei.size = crashk_low_res.end - crashk_low_res.start + 1;
 390                 ei.type = E820_TYPE_RAM;
 391                 add_e820_entry(params, &ei);
 392         }
 393
 394         /* Exclude some ranges from crashk_res and add rest to memmap */
 395         ret = memmap_exclude_ranges(image, cmem, crashk_res.start,
 396                                                 crashk_res.end);
 397         if (ret)
 398                 goto out;
 399
 400         for (i = 0; i < cmem->nr_ranges; i++) {
 401                 ei.size = cmem->ranges[i].end - cmem->ranges[i].start + 1;
 402
 403                 /* If entry is less than a page, skip it */
 404                 if (ei.size < PAGE_SIZE)
 405                         continue;
 406                 ei.addr = cmem->ranges[i].start;
 407                 ei.type = E820_TYPE_RAM;
 408                 add_e820_entry(params, &ei);
 409         }
 410
 411 out:
 412         vfree(cmem);
 413         return ret;
 414 }
 415
 416 static int determine_backup_region(struct resource *res, void *arg)
 417 {
 418         struct kimage *image = arg;
 419
 420         image->arch.backup_src_start = res->start;
 421         image->arch.backup_src_sz = resource_size(res);
 422
 423         /* Expecting only one range for backup region */
 424         return 1;
 425 }
 426
 427 int crash_load_segments(struct kimage *image)
 428 {
 429         int ret;
 430         struct kexec_buf kbuf = { .image = image, .buf_min = 0,
 431                                   .buf_max = ULONG_MAX, .top_down = false };
 432
 433         /*
 434          * Determine and load a segment for backup area. First 640K RAM
 435          * region is backup source
 436          */
 437
 438         ret = walk_system_ram_res(KEXEC_BACKUP_SRC_START, KEXEC_BACKUP_SRC_END,
 439                                 image, determine_backup_region);
 440
 441         /* Zero or postive return values are ok */
 442         if (ret < 0)
 443                 return ret;
 444
 445         /* Add backup segment. */
 446         if (image->arch.backup_src_sz) {
 447                 kbuf.buffer = &crash_zero_bytes;
 448                 kbuf.bufsz = sizeof(crash_zero_bytes);
 449                 kbuf.memsz = image->arch.backup_src_sz;
 450                 kbuf.buf_align = PAGE_SIZE;
 451                 /*
 452                  * Ideally there is no source for backup segment. This is
 453                  * copied in purgatory after crash. Just add a zero filled
 454                  * segment for now to make sure checksum logic works fine.
 455                  */
 456                 ret = kexec_add_buffer(&kbuf);
 457                 if (ret)
 458                         return ret;
 459                 image->arch.backup_load_addr = kbuf.mem;
 460                 pr_debug("Loaded backup region at 0x%lx backup_start=0x%lx memsz=0x%lx\n",
 461                          image->arch.backup_load_addr,
 462                          image->arch.backup_src_start, kbuf.memsz);
 463         }
 464
 465         /* Prepare elf headers and add a segment */
 466         ret = prepare_elf_headers(image, &kbuf.buffer, &kbuf.bufsz);
 467         if (ret)
 468                 return ret;
 469
 470         image->arch.elf_headers = kbuf.buffer;
 471         image->arch.elf_headers_sz = kbuf.bufsz;
 472
 473         kbuf.memsz = kbuf.bufsz;
 474         kbuf.buf_align = ELF_CORE_HEADER_ALIGN;
 475         kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
 476         ret = kexec_add_buffer(&kbuf);
 477         if (ret) {
 478                 vfree((void *)image->arch.elf_headers);
 479                 return ret;
 480         }
 481         image->arch.elf_load_addr = kbuf.mem;
 482         pr_debug("Loaded ELF headers at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
 483                  image->arch.elf_load_addr, kbuf.bufsz, kbuf.bufsz);
 484
 485         return ret;
 486 }
 487 #endif /* CONFIG_KEXEC_FILE */