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 int ret; 125 126 chip = irq_desc_get_chip(desc); 127 if (!chip) 128 continue; 129 130 /* 131 * First try to remove the active state. If this 132 * fails, try to EOI the interrupt. 133 */ 134 ret = irq_set_irqchip_state(i, IRQCHIP_STATE_ACTIVE, false); 135 136 if (ret && irqd_irq_inprogress(&desc->irq_data) && 137 chip->irq_eoi) 138 chip->irq_eoi(&desc->irq_data); 139 140 if (chip->irq_mask) 141 chip->irq_mask(&desc->irq_data); 142 143 if (chip->irq_disable && !irqd_irq_disabled(&desc->irq_data)) 144 chip->irq_disable(&desc->irq_data); 145 } 146 } 147 148 /* 149 * machine_crash_shutdown - Prepare to kexec after a kernel crash 150 * 151 * This function is called by crash_kexec just before machine_kexec 152 * and its goal is to shutdown non-crashing cpus and save registers. 153 */ 154 void 155 machine_crash_shutdown(struct pt_regs *regs) 156 { 157 local_irq_disable(); 158 159 /* shutdown non-crashing cpus */ 160 crash_smp_send_stop(); 161 162 crash_save_cpu(regs, smp_processor_id()); 163 machine_kexec_mask_interrupts(); 164 165 pr_info("Starting crashdump kernel...\n"); 166 } 167 168 /* 169 * machine_kexec - Jump to the loaded kimage 170 * 171 * This function is called by kernel_kexec which is called by the 172 * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC, 173 * or by crash_kernel which is called by the kernel's arch-specific 174 * trap handler in case of a kernel panic. It's the final stage of 175 * the kexec process where the pre-loaded kimage is ready to be 176 * executed. We assume at this point that all other harts are 177 * suspended and this hart will be the new boot hart. 178 */ 179 void __noreturn 180 machine_kexec(struct kimage *image) 181 { 182 struct kimage_arch *internal = &image->arch; 183 unsigned long jump_addr = (unsigned long) image->start; 184 unsigned long first_ind_entry = (unsigned long) &image->head; 185 unsigned long this_cpu_id = __smp_processor_id(); 186 unsigned long this_hart_id = cpuid_to_hartid_map(this_cpu_id); 187 unsigned long fdt_addr = internal->fdt_addr; 188 void *control_code_buffer = page_address(image->control_code_page); 189 riscv_kexec_method kexec_method = NULL; 190 191 #ifdef CONFIG_SMP 192 WARN(smp_crash_stop_failed(), 193 "Some CPUs may be stale, kdump will be unreliable.\n"); 194 #endif 195 196 if (image->type != KEXEC_TYPE_CRASH) 197 kexec_method = control_code_buffer; 198 else 199 kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate; 200 201 pr_notice("Will call new kernel at %08lx from hart id %lx\n", 202 jump_addr, this_hart_id); 203 pr_notice("FDT image at %08lx\n", fdt_addr); 204 205 /* Make sure the relocation code is visible to the hart */ 206 local_flush_icache_all(); 207 208 /* Jump to the relocation code */ 209 pr_notice("Bye...\n"); 210 kexec_method(first_ind_entry, jump_addr, fdt_addr, 211 this_hart_id, kernel_map.va_pa_offset); 212 unreachable(); 213 } 214