arch/riscv/kernel/machine_kexec.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2019 FORTH-ICS/CARV
   4  *  Nick Kossifidis <mick@ics.forth.gr>
   5  */
   6
   7 #include <linux/kexec.h>
   8 #include <asm/kexec.h>          /* For riscv_kexec_* symbol defines */
   9 #include <linux/smp.h>          /* For smp_send_stop () */
  10 #include <asm/cacheflush.h>     /* For local_flush_icache_all() */
  11 #include <asm/barrier.h>        /* For smp_wmb() */
  12 #include <asm/page.h>           /* For PAGE_MASK */
  13 #include <linux/libfdt.h>       /* For fdt_check_header() */
  14 #include <asm/set_memory.h>     /* For set_memory_x() */
  15 #include <linux/compiler.h>     /* For unreachable() */
  16 #include <linux/cpu.h>          /* For cpu_down() */
  17 #include <linux/reboot.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/irq.h>
  20
  21 /*
  22  * machine_kexec_prepare - Initialize kexec
  23  *
  24  * This function is called from do_kexec_load, when the user has
  25  * provided us with an image to be loaded. Its goal is to validate
  26  * the image and prepare the control code buffer as needed.
  27  * Note that kimage_alloc_init has already been called and the
  28  * control buffer has already been allocated.
  29  */
  30 int
  31 machine_kexec_prepare(struct kimage *image)
  32 {
  33         struct kimage_arch *internal = &image->arch;
  34         struct fdt_header fdt = {0};
  35         void *control_code_buffer = NULL;
  36         unsigned int control_code_buffer_sz = 0;
  37         int i = 0;
  38
  39         /* Find the Flattened Device Tree and save its physical address */
  40         for (i = 0; i < image->nr_segments; i++) {
  41                 if (image->segment[i].memsz <= sizeof(fdt))
  42                         continue;
  43
  44                 if (image->file_mode)
  45                         memcpy(&fdt, image->segment[i].buf, sizeof(fdt));
  46                 else if (copy_from_user(&fdt, image->segment[i].buf, sizeof(fdt)))
  47                         continue;
  48
  49                 if (fdt_check_header(&fdt))
  50                         continue;
  51
  52                 internal->fdt_addr = (unsigned long) image->segment[i].mem;
  53                 break;
  54         }
  55
  56         if (!internal->fdt_addr) {
  57                 pr_err("Device tree not included in the provided image\n");
  58                 return -EINVAL;
  59         }
  60
  61         /* Copy the assembler code for relocation to the control page */
  62         if (image->type != KEXEC_TYPE_CRASH) {
  63                 control_code_buffer = page_address(image->control_code_page);
  64                 control_code_buffer_sz = page_size(image->control_code_page);
  65
  66                 if (unlikely(riscv_kexec_relocate_size > control_code_buffer_sz)) {
  67                         pr_err("Relocation code doesn't fit within a control page\n");
  68                         return -EINVAL;
  69                 }
  70
  71                 memcpy(control_code_buffer, riscv_kexec_relocate,
  72                         riscv_kexec_relocate_size);
  73
  74                 /* Mark the control page executable */
  75                 set_memory_x((unsigned long) control_code_buffer, 1);
  76         }
  77
  78         return 0;
  79 }
  80
  81
  82 /*
  83  * machine_kexec_cleanup - Cleanup any leftovers from
  84  *                         machine_kexec_prepare
  85  *
  86  * This function is called by kimage_free to handle any arch-specific
  87  * allocations done on machine_kexec_prepare. Since we didn't do any
  88  * allocations there, this is just an empty function. Note that the
  89  * control buffer is freed by kimage_free.
  90  */
  91 void
  92 machine_kexec_cleanup(struct kimage *image)
  93 {
  94 }
  95
  96
  97 /*
  98  * machine_shutdown - Prepare for a kexec reboot
  99  *
 100  * This function is called by kernel_kexec just before machine_kexec
 101  * below. Its goal is to prepare the rest of the system (the other
 102  * harts and possibly devices etc) for a kexec reboot.
 103  */
 104 void machine_shutdown(void)
 105 {
 106         /*
 107          * No more interrupts on this hart
 108          * until we are back up.
 109          */
 110         local_irq_disable();
 111
 112 #if defined(CONFIG_HOTPLUG_CPU)
 113         smp_shutdown_nonboot_cpus(smp_processor_id());
 114 #endif
 115 }
 116
 117 static void machine_kexec_mask_interrupts(void)
 118 {
 119         unsigned int i;
 120         struct irq_desc *desc;
 121
 122         for_each_irq_desc(i, desc) {
 123                 struct irq_chip *chip;
 124
 125                 chip = irq_desc_get_chip(desc);
 126                 if (!chip)
 127                         continue;
 128
 129                 if (chip->irq_eoi && irqd_irq_inprogress(&desc->irq_data))
 130                         chip->irq_eoi(&desc->irq_data);
 131
 132                 if (chip->irq_mask)
 133                         chip->irq_mask(&desc->irq_data);
 134
 135                 if (chip->irq_disable && !irqd_irq_disabled(&desc->irq_data))
 136                         chip->irq_disable(&desc->irq_data);
 137         }
 138 }
 139
 140 /*
 141  * machine_crash_shutdown - Prepare to kexec after a kernel crash
 142  *
 143  * This function is called by crash_kexec just before machine_kexec
 144  * and its goal is to shutdown non-crashing cpus and save registers.
 145  */
 146 void
 147 machine_crash_shutdown(struct pt_regs *regs)
 148 {
 149         local_irq_disable();
 150
 151         /* shutdown non-crashing cpus */
 152         crash_smp_send_stop();
 153
 154         crash_save_cpu(regs, smp_processor_id());
 155         machine_kexec_mask_interrupts();
 156
 157         pr_info("Starting crashdump kernel...\n");
 158 }
 159
 160 /*
 161  * machine_kexec - Jump to the loaded kimage
 162  *
 163  * This function is called by kernel_kexec which is called by the
 164  * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC,
 165  * or by crash_kernel which is called by the kernel's arch-specific
 166  * trap handler in case of a kernel panic. It's the final stage of
 167  * the kexec process where the pre-loaded kimage is ready to be
 168  * executed. We assume at this point that all other harts are
 169  * suspended and this hart will be the new boot hart.
 170  */
 171 void __noreturn
 172 machine_kexec(struct kimage *image)
 173 {
 174         struct kimage_arch *internal = &image->arch;
 175         unsigned long jump_addr = (unsigned long) image->start;
 176         unsigned long first_ind_entry = (unsigned long) &image->head;
 177         unsigned long this_cpu_id = __smp_processor_id();
 178         unsigned long this_hart_id = cpuid_to_hartid_map(this_cpu_id);
 179         unsigned long fdt_addr = internal->fdt_addr;
 180         void *control_code_buffer = page_address(image->control_code_page);
 181         riscv_kexec_method kexec_method = NULL;
 182
 183 #ifdef CONFIG_SMP
 184         WARN(smp_crash_stop_failed(),
 185                 "Some CPUs may be stale, kdump will be unreliable.\n");
 186 #endif
 187
 188         if (image->type != KEXEC_TYPE_CRASH)
 189                 kexec_method = control_code_buffer;
 190         else
 191                 kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate;
 192
 193         pr_notice("Will call new kernel at %08lx from hart id %lx\n",
 194                   jump_addr, this_hart_id);
 195         pr_notice("FDT image at %08lx\n", fdt_addr);
 196
 197         /* Make sure the relocation code is visible to the hart */
 198         local_flush_icache_all();
 199
 200         /* Jump to the relocation code */
 201         pr_notice("Bye...\n");
 202         kexec_method(first_ind_entry, jump_addr, fdt_addr,
 203                      this_hart_id, kernel_map.va_pa_offset);
 204         unreachable();
 205 }