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 #include <linux/memblock.h>
  28
  29 #include <asm/processor.h>
  30 #include <asm/hardirq.h>
  31 #include <asm/nmi.h>
  32 #include <asm/hw_irq.h>
  33 #include <asm/apic.h>
  34 #include <asm/e820/types.h>
  35 #include <asm/io_apic.h>
  36 #include <asm/hpet.h>
  37 #include <linux/kdebug.h>
  38 #include <asm/cpu.h>
  39 #include <asm/reboot.h>
  40 #include <asm/virtext.h>
  41 #include <asm/intel_pt.h>
  42 #include <asm/crash.h>
  43 #include <asm/cmdline.h>
  44
  45 /* Used while preparing memory map entries for second kernel */
  46 struct crash_memmap_data {
  47         struct boot_params *params;
  48         /* Type of memory */
  49         unsigned int type;
  50 };
  51
  52 /*
  53  * This is used to VMCLEAR all VMCSs loaded on the
  54  * processor. And when loading kvm_intel module, the
  55  * callback function pointer will be assigned.
  56  *
  57  * protected by rcu.
  58  */
  59 crash_vmclear_fn __rcu *crash_vmclear_loaded_vmcss = NULL;
  60 EXPORT_SYMBOL_GPL(crash_vmclear_loaded_vmcss);
  61
  62 static inline void cpu_crash_vmclear_loaded_vmcss(void)
  63 {
  64         crash_vmclear_fn *do_vmclear_operation = NULL;
  65
  66         rcu_read_lock();
  67         do_vmclear_operation = rcu_dereference(crash_vmclear_loaded_vmcss);
  68         if (do_vmclear_operation)
  69                 do_vmclear_operation();
  70         rcu_read_unlock();
  71 }
  72
  73 /*
  74  * When the crashkernel option is specified, only use the low
  75  * 1M for the real mode trampoline.
  76  */
  77 void __init crash_reserve_low_1M(void)
  78 {
  79         if (cmdline_find_option(boot_command_line, "crashkernel", NULL, 0) < 0)
  80                 return;
  81
  82         memblock_reserve(0, 1<<20);
  83         pr_info("Reserving the low 1M of memory for crashkernel\n");
  84 }
  85
  86 #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
  87
  88 static void kdump_nmi_callback(int cpu, struct pt_regs *regs)
  89 {
  90         crash_save_cpu(regs, cpu);
  91
  92         /*
  93          * VMCLEAR VMCSs loaded on all cpus if needed.
  94          */
  95         cpu_crash_vmclear_loaded_vmcss();
  96
  97         /* Disable VMX or SVM if needed.
  98          *
  99          * We need to disable virtualization on all CPUs.
 100          * Having VMX or SVM enabled on any CPU may break rebooting
 101          * after the kdump kernel has finished its task.
 102          */
 103         cpu_emergency_vmxoff();
 104         cpu_emergency_svm_disable();
 105
 106         /*
 107          * Disable Intel PT to stop its logging
 108          */
 109         cpu_emergency_stop_pt();
 110
 111         disable_local_APIC();
 112 }
 113
 114 void kdump_nmi_shootdown_cpus(void)
 115 {
 116         nmi_shootdown_cpus(kdump_nmi_callback);
 117
 118         disable_local_APIC();
 119 }
 120
 121 /* Override the weak function in kernel/panic.c */
 122 void crash_smp_send_stop(void)
 123 {
 124         static int cpus_stopped;
 125
 126         if (cpus_stopped)
 127                 return;
 128
 129         if (smp_ops.crash_stop_other_cpus)
 130                 smp_ops.crash_stop_other_cpus();
 131         else
 132                 smp_send_stop();
 133
 134         cpus_stopped = 1;
 135 }
 136
 137 #else
 138 void crash_smp_send_stop(void)
 139 {
 140         /* There are no cpus to shootdown */
 141 }
 142 #endif
 143
 144 void native_machine_crash_shutdown(struct pt_regs *regs)
 145 {
 146         /* This function is only called after the system
 147          * has panicked or is otherwise in a critical state.
 148          * The minimum amount of code to allow a kexec'd kernel
 149          * to run successfully needs to happen here.
 150          *
 151          * In practice this means shooting down the other cpus in
 152          * an SMP system.
 153          */
 154         /* The kernel is broken so disable interrupts */
 155         local_irq_disable();
 156
 157         crash_smp_send_stop();
 158
 159         /*
 160          * VMCLEAR VMCSs loaded on this cpu if needed.
 161          */
 162         cpu_crash_vmclear_loaded_vmcss();
 163
 164         /* Booting kdump kernel with VMX or SVM enabled won't work,
 165          * because (among other limitations) we can't disable paging
 166          * with the virt flags.
 167          */
 168         cpu_emergency_vmxoff();
 169         cpu_emergency_svm_disable();
 170
 171         /*
 172          * Disable Intel PT to stop its logging
 173          */
 174         cpu_emergency_stop_pt();
 175
 176 #ifdef CONFIG_X86_IO_APIC
 177         /* Prevent crash_kexec() from deadlocking on ioapic_lock. */
 178         ioapic_zap_locks();
 179         clear_IO_APIC();
 180 #endif
 181         lapic_shutdown();
 182         restore_boot_irq_mode();
 183 #ifdef CONFIG_HPET_TIMER
 184         hpet_disable();
 185 #endif
 186         crash_save_cpu(regs, safe_smp_processor_id());
 187 }
 188
 189 #ifdef CONFIG_KEXEC_FILE
 190
 191 static int get_nr_ram_ranges_callback(struct resource *res, void *arg)
 192 {
 193         unsigned int *nr_ranges = arg;
 194
 195         (*nr_ranges)++;
 196         return 0;
 197 }
 198
 199 /* Gather all the required information to prepare elf headers for ram regions */
 200 static struct crash_mem *fill_up_crash_elf_data(void)
 201 {
 202         unsigned int nr_ranges = 0;
 203         struct crash_mem *cmem;
 204
 205         walk_system_ram_res(0, -1, &nr_ranges, get_nr_ram_ranges_callback);
 206         if (!nr_ranges)
 207                 return NULL;
 208
 209         /*
 210          * Exclusion of crash region and/or crashk_low_res may cause
 211          * another range split. So add extra two slots here.
 212          */
 213         nr_ranges += 2;
 214         cmem = vzalloc(struct_size(cmem, ranges, nr_ranges));
 215         if (!cmem)
 216                 return NULL;
 217
 218         cmem->max_nr_ranges = nr_ranges;
 219         cmem->nr_ranges = 0;
 220
 221         return cmem;
 222 }
 223
 224 /*
 225  * Look for any unwanted ranges between mstart, mend and remove them. This
 226  * might lead to split and split ranges are put in cmem->ranges[] array
 227  */
 228 static int elf_header_exclude_ranges(struct crash_mem *cmem)
 229 {
 230         int ret = 0;
 231
 232         /* Exclude the low 1M because it is always reserved */
 233         ret = crash_exclude_mem_range(cmem, 0, 1<<20);
 234         if (ret)
 235                 return ret;
 236
 237         /* Exclude crashkernel region */
 238         ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
 239         if (ret)
 240                 return ret;
 241
 242         if (crashk_low_res.end)
 243                 ret = crash_exclude_mem_range(cmem, crashk_low_res.start,
 244                                               crashk_low_res.end);
 245
 246         return ret;
 247 }
 248
 249 static int prepare_elf64_ram_headers_callback(struct resource *res, void *arg)
 250 {
 251         struct crash_mem *cmem = arg;
 252
 253         cmem->ranges[cmem->nr_ranges].start = res->start;
 254         cmem->ranges[cmem->nr_ranges].end = res->end;
 255         cmem->nr_ranges++;
 256
 257         return 0;
 258 }
 259
 260 /* Prepare elf headers. Return addr and size */
 261 static int prepare_elf_headers(struct kimage *image, void **addr,
 262                                         unsigned long *sz)
 263 {
 264         struct crash_mem *cmem;
 265         int ret;
 266
 267         cmem = fill_up_crash_elf_data();
 268         if (!cmem)
 269                 return -ENOMEM;
 270
 271         ret = walk_system_ram_res(0, -1, cmem, prepare_elf64_ram_headers_callback);
 272         if (ret)
 273                 goto out;
 274
 275         /* Exclude unwanted mem ranges */
 276         ret = elf_header_exclude_ranges(cmem);
 277         if (ret)
 278                 goto out;
 279
 280         /* By default prepare 64bit headers */
 281         ret =  crash_prepare_elf64_headers(cmem, IS_ENABLED(CONFIG_X86_64), addr, sz);
 282
 283 out:
 284         vfree(cmem);
 285         return ret;
 286 }
 287
 288 static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)
 289 {
 290         unsigned int nr_e820_entries;
 291
 292         nr_e820_entries = params->e820_entries;
 293         if (nr_e820_entries >= E820_MAX_ENTRIES_ZEROPAGE)
 294                 return 1;
 295
 296         memcpy(&params->e820_table[nr_e820_entries], entry, sizeof(struct e820_entry));
 297         params->e820_entries++;
 298         return 0;
 299 }
 300
 301 static int memmap_entry_callback(struct resource *res, void *arg)
 302 {
 303         struct crash_memmap_data *cmd = arg;
 304         struct boot_params *params = cmd->params;
 305         struct e820_entry ei;
 306
 307         ei.addr = res->start;
 308         ei.size = resource_size(res);
 309         ei.type = cmd->type;
 310         add_e820_entry(params, &ei);
 311
 312         return 0;
 313 }
 314
 315 static int memmap_exclude_ranges(struct kimage *image, struct crash_mem *cmem,
 316                                  unsigned long long mstart,
 317                                  unsigned long long mend)
 318 {
 319         unsigned long start, end;
 320
 321         cmem->ranges[0].start = mstart;
 322         cmem->ranges[0].end = mend;
 323         cmem->nr_ranges = 1;
 324
 325         /* Exclude elf header region */
 326         start = image->arch.elf_load_addr;
 327         end = start + image->arch.elf_headers_sz - 1;
 328         return crash_exclude_mem_range(cmem, start, end);
 329 }
 330
 331 /* Prepare memory map for crash dump kernel */
 332 int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
 333 {
 334         int i, ret = 0;
 335         unsigned long flags;
 336         struct e820_entry ei;
 337         struct crash_memmap_data cmd;
 338         struct crash_mem *cmem;
 339
 340         cmem = vzalloc(sizeof(struct crash_mem));
 341         if (!cmem)
 342                 return -ENOMEM;
 343
 344         memset(&cmd, 0, sizeof(struct crash_memmap_data));
 345         cmd.params = params;
 346
 347         /* Add the low 1M */
 348         cmd.type = E820_TYPE_RAM;
 349         flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 350         walk_iomem_res_desc(IORES_DESC_NONE, flags, 0, (1<<20)-1, &cmd,
 351                             memmap_entry_callback);
 352
 353         /* Add ACPI tables */
 354         cmd.type = E820_TYPE_ACPI;
 355         flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 356         walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd,
 357                             memmap_entry_callback);
 358
 359         /* Add ACPI Non-volatile Storage */
 360         cmd.type = E820_TYPE_NVS;
 361         walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd,
 362                             memmap_entry_callback);
 363
 364         /* Add e820 reserved ranges */
 365         cmd.type = E820_TYPE_RESERVED;
 366         flags = IORESOURCE_MEM;
 367         walk_iomem_res_desc(IORES_DESC_RESERVED, flags, 0, -1, &cmd,
 368                             memmap_entry_callback);
 369
 370         /* Add crashk_low_res region */
 371         if (crashk_low_res.end) {
 372                 ei.addr = crashk_low_res.start;
 373                 ei.size = resource_size(&crashk_low_res);
 374                 ei.type = E820_TYPE_RAM;
 375                 add_e820_entry(params, &ei);
 376         }
 377
 378         /* Exclude some ranges from crashk_res and add rest to memmap */
 379         ret = memmap_exclude_ranges(image, cmem, crashk_res.start, crashk_res.end);
 380         if (ret)
 381                 goto out;
 382
 383         for (i = 0; i < cmem->nr_ranges; i++) {
 384                 ei.size = cmem->ranges[i].end - cmem->ranges[i].start + 1;
 385
 386                 /* If entry is less than a page, skip it */
 387                 if (ei.size < PAGE_SIZE)
 388                         continue;
 389                 ei.addr = cmem->ranges[i].start;
 390                 ei.type = E820_TYPE_RAM;
 391                 add_e820_entry(params, &ei);
 392         }
 393
 394 out:
 395         vfree(cmem);
 396         return ret;
 397 }
 398
 399 int crash_load_segments(struct kimage *image)
 400 {
 401         int ret;
 402         struct kexec_buf kbuf = { .image = image, .buf_min = 0,
 403                                   .buf_max = ULONG_MAX, .top_down = false };
 404
 405         /* Prepare elf headers and add a segment */
 406         ret = prepare_elf_headers(image, &kbuf.buffer, &kbuf.bufsz);
 407         if (ret)
 408                 return ret;
 409
 410         image->arch.elf_headers = kbuf.buffer;
 411         image->arch.elf_headers_sz = kbuf.bufsz;
 412
 413         kbuf.memsz = kbuf.bufsz;
 414         kbuf.buf_align = ELF_CORE_HEADER_ALIGN;
 415         kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
 416         ret = kexec_add_buffer(&kbuf);
 417         if (ret) {
 418                 vfree((void *)image->arch.elf_headers);
 419                 return ret;
 420         }
 421         image->arch.elf_load_addr = kbuf.mem;
 422         pr_debug("Loaded ELF headers at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
 423                  image->arch.elf_load_addr, kbuf.bufsz, kbuf.bufsz);
 424
 425         return ret;
 426 }
 427 #endif /* CONFIG_KEXEC_FILE */