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