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