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