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
  19 /*
  20  * kexec_image_info - Print received image details
  21  */
  22 static void
  23 kexec_image_info(const struct kimage *image)
  24 {
  25         unsigned long i;
  26
  27         pr_debug("Kexec image info:\n");
  28         pr_debug("\ttype:        %d\n", image->type);
  29         pr_debug("\tstart:       %lx\n", image->start);
  30         pr_debug("\thead:        %lx\n", image->head);
  31         pr_debug("\tnr_segments: %lu\n", image->nr_segments);
  32
  33         for (i = 0; i < image->nr_segments; i++) {
  34                 pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
  35                         image->segment[i].mem,
  36                         image->segment[i].mem + image->segment[i].memsz);
  37                 pr_debug("\t\t0x%lx bytes, %lu pages\n",
  38                         (unsigned long) image->segment[i].memsz,
  39                         (unsigned long) image->segment[i].memsz /  PAGE_SIZE);
  40         }
  41 }
  42
  43 /*
  44  * machine_kexec_prepare - Initialize kexec
  45  *
  46  * This function is called from do_kexec_load, when the user has
  47  * provided us with an image to be loaded. Its goal is to validate
  48  * the image and prepare the control code buffer as needed.
  49  * Note that kimage_alloc_init has already been called and the
  50  * control buffer has already been allocated.
  51  */
  52 int
  53 machine_kexec_prepare(struct kimage *image)
  54 {
  55         struct kimage_arch *internal = &image->arch;
  56         struct fdt_header fdt = {0};
  57         void *control_code_buffer = NULL;
  58         unsigned int control_code_buffer_sz = 0;
  59         int i = 0;
  60
  61         kexec_image_info(image);
  62
  63         /* Find the Flattened Device Tree and save its physical address */
  64         for (i = 0; i < image->nr_segments; i++) {
  65                 if (image->segment[i].memsz <= sizeof(fdt))
  66                         continue;
  67
  68                 if (image->file_mode)
  69                         memcpy(&fdt, image->segment[i].buf, sizeof(fdt));
  70                 else if (copy_from_user(&fdt, image->segment[i].buf, sizeof(fdt)))
  71                         continue;
  72
  73                 if (fdt_check_header(&fdt))
  74                         continue;
  75
  76                 internal->fdt_addr = (unsigned long) image->segment[i].mem;
  77                 break;
  78         }
  79
  80         if (!internal->fdt_addr) {
  81                 pr_err("Device tree not included in the provided image\n");
  82                 return -EINVAL;
  83         }
  84
  85         /* Copy the assembler code for relocation to the control page */
  86         if (image->type != KEXEC_TYPE_CRASH) {
  87                 control_code_buffer = page_address(image->control_code_page);
  88                 control_code_buffer_sz = page_size(image->control_code_page);
  89
  90                 if (unlikely(riscv_kexec_relocate_size > control_code_buffer_sz)) {
  91                         pr_err("Relocation code doesn't fit within a control page\n");
  92                         return -EINVAL;
  93                 }
  94
  95                 memcpy(control_code_buffer, riscv_kexec_relocate,
  96                         riscv_kexec_relocate_size);
  97
  98                 /* Mark the control page executable */
  99                 set_memory_x((unsigned long) control_code_buffer, 1);
 100         }
 101
 102         return 0;
 103 }
 104
 105
 106 /*
 107  * machine_kexec_cleanup - Cleanup any leftovers from
 108  *                         machine_kexec_prepare
 109  *
 110  * This function is called by kimage_free to handle any arch-specific
 111  * allocations done on machine_kexec_prepare. Since we didn't do any
 112  * allocations there, this is just an empty function. Note that the
 113  * control buffer is freed by kimage_free.
 114  */
 115 void
 116 machine_kexec_cleanup(struct kimage *image)
 117 {
 118 }
 119
 120
 121 /*
 122  * machine_shutdown - Prepare for a kexec reboot
 123  *
 124  * This function is called by kernel_kexec just before machine_kexec
 125  * below. Its goal is to prepare the rest of the system (the other
 126  * harts and possibly devices etc) for a kexec reboot.
 127  */
 128 void machine_shutdown(void)
 129 {
 130         /*
 131          * No more interrupts on this hart
 132          * until we are back up.
 133          */
 134         local_irq_disable();
 135
 136 #if defined(CONFIG_HOTPLUG_CPU)
 137         smp_shutdown_nonboot_cpus(smp_processor_id());
 138 #endif
 139 }
 140
 141 /*
 142  * machine_crash_shutdown - Prepare to kexec after a kernel crash
 143  *
 144  * This function is called by crash_kexec just before machine_kexec
 145  * below and its goal is similar to machine_shutdown, but in case of
 146  * a kernel crash. Since we don't handle such cases yet, this function
 147  * is empty.
 148  */
 149 void
 150 machine_crash_shutdown(struct pt_regs *regs)
 151 {
 152         crash_save_cpu(regs, smp_processor_id());
 153         machine_shutdown();
 154         pr_info("Starting crashdump kernel...\n");
 155 }
 156
 157 /*
 158  * machine_kexec - Jump to the loaded kimage
 159  *
 160  * This function is called by kernel_kexec which is called by the
 161  * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC,
 162  * or by crash_kernel which is called by the kernel's arch-specific
 163  * trap handler in case of a kernel panic. It's the final stage of
 164  * the kexec process where the pre-loaded kimage is ready to be
 165  * executed. We assume at this point that all other harts are
 166  * suspended and this hart will be the new boot hart.
 167  */
 168 void __noreturn
 169 machine_kexec(struct kimage *image)
 170 {
 171         struct kimage_arch *internal = &image->arch;
 172         unsigned long jump_addr = (unsigned long) image->start;
 173         unsigned long first_ind_entry = (unsigned long) &image->head;
 174         unsigned long this_cpu_id = __smp_processor_id();
 175         unsigned long this_hart_id = cpuid_to_hartid_map(this_cpu_id);
 176         unsigned long fdt_addr = internal->fdt_addr;
 177         void *control_code_buffer = page_address(image->control_code_page);
 178         riscv_kexec_method kexec_method = NULL;
 179
 180         if (image->type != KEXEC_TYPE_CRASH)
 181                 kexec_method = control_code_buffer;
 182         else
 183                 kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate;
 184
 185         pr_notice("Will call new kernel at %08lx from hart id %lx\n",
 186                   jump_addr, this_hart_id);
 187         pr_notice("FDT image at %08lx\n", fdt_addr);
 188
 189         /* Make sure the relocation code is visible to the hart */
 190         local_flush_icache_all();
 191
 192         /* Jump to the relocation code */
 193         pr_notice("Bye...\n");
 194         kexec_method(first_ind_entry, jump_addr, fdt_addr,
 195                      this_hart_id, kernel_map.va_pa_offset);
 196         unreachable();
 197 }