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