LXR linux/arch/riscv/kernel/machine

   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 */
  22static void
  23kexec_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 */
  52int
  53machine_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 (copy_from_user(&fdt, image->segment[i].buf, sizeof(fdt)))
  69                        continue;
  70
  71                if (fdt_check_header(&fdt))
  72                        continue;
  73
  74                internal->fdt_addr = (unsigned long) image->segment[i].mem;
  75                break;
  76        }
  77
  78        if (!internal->fdt_addr) {
  79                pr_err("Device tree not included in the provided image\n");
  80                return -EINVAL;
  81        }
  82
  83        /* Copy the assembler code for relocation to the control page */
  84        if (image->type != KEXEC_TYPE_CRASH) {
  85                control_code_buffer = page_address(image->control_code_page);
  86                control_code_buffer_sz = page_size(image->control_code_page);
  87
  88                if (unlikely(riscv_kexec_relocate_size > control_code_buffer_sz)) {
  89                        pr_err("Relocation code doesn't fit within a control page\n");
  90                        return -EINVAL;
  91                }
  92
  93                memcpy(control_code_buffer, riscv_kexec_relocate,
  94                        riscv_kexec_relocate_size);
  95
  96                /* Mark the control page executable */
  97                set_memory_x((unsigned long) control_code_buffer, 1);
  98        }
  99
 100        return 0;
 101}
 102
 103
 104/*
 105 * machine_kexec_cleanup - Cleanup any leftovers from
 106 *                         machine_kexec_prepare
 107 *
 108 * This function is called by kimage_free to handle any arch-specific
 109 * allocations done on machine_kexec_prepare. Since we didn't do any
 110 * allocations there, this is just an empty function. Note that the
 111 * control buffer is freed by kimage_free.
 112 */
 113void
 114machine_kexec_cleanup(struct kimage *image)
 115{
 116}
 117
 118
 119/*
 120 * machine_shutdown - Prepare for a kexec reboot
 121 *
 122 * This function is called by kernel_kexec just before machine_kexec
 123 * below. Its goal is to prepare the rest of the system (the other
 124 * harts and possibly devices etc) for a kexec reboot.
 125 */
 126void machine_shutdown(void)
 127{
 128        /*
 129         * No more interrupts on this hart
 130         * until we are back up.
 131         */
 132        local_irq_disable();
 133
 134#if defined(CONFIG_HOTPLUG_CPU)
 135        smp_shutdown_nonboot_cpus(smp_processor_id());
 136#endif
 137}
 138
 139/*
 140 * machine_crash_shutdown - Prepare to kexec after a kernel crash
 141 *
 142 * This function is called by crash_kexec just before machine_kexec
 143 * below and its goal is similar to machine_shutdown, but in case of
 144 * a kernel crash. Since we don't handle such cases yet, this function
 145 * is empty.
 146 */
 147void
 148machine_crash_shutdown(struct pt_regs *regs)
 149{
 150        crash_save_cpu(regs, smp_processor_id());
 151        machine_shutdown();
 152        pr_info("Starting crashdump kernel...\n");
 153}
 154
 155/*
 156 * machine_kexec - Jump to the loaded kimage
 157 *
 158 * This function is called by kernel_kexec which is called by the
 159 * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC,
 160 * or by crash_kernel which is called by the kernel's arch-specific
 161 * trap handler in case of a kernel panic. It's the final stage of
 162 * the kexec process where the pre-loaded kimage is ready to be
 163 * executed. We assume at this point that all other harts are
 164 * suspended and this hart will be the new boot hart.
 165 */
 166void __noreturn
 167machine_kexec(struct kimage *image)
 168{
 169        struct kimage_arch *internal = &image->arch;
 170        unsigned long jump_addr = (unsigned long) image->start;
 171        unsigned long first_ind_entry = (unsigned long) &image->head;
 172        unsigned long this_hart_id = raw_smp_processor_id();
 173        unsigned long fdt_addr = internal->fdt_addr;
 174        void *control_code_buffer = page_address(image->control_code_page);
 175        riscv_kexec_method kexec_method = NULL;
 176
 177        if (image->type != KEXEC_TYPE_CRASH)
 178                kexec_method = control_code_buffer;
 179        else
 180                kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate;
 181
 182        pr_notice("Will call new kernel at %08lx from hart id %lx\n",
 183                  jump_addr, this_hart_id);
 184        pr_notice("FDT image at %08lx\n", fdt_addr);
 185
 186        /* Make sure the relocation code is visible to the hart */
 187        local_flush_icache_all();
 188
 189        /* Jump to the relocation code */
 190        pr_notice("Bye...\n");
 191        kexec_method(first_ind_entry, jump_addr, fdt_addr,
 192                     this_hart_id, kernel_map.va_pa_offset);
 193        unreachable();
 194}
 195