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 /* Override the weak function in kernel/panic.c */ 142 void crash_smp_send_stop(void) 143 { 144 static int cpus_stopped; 145 146 /* 147 * This function can be called twice in panic path, but obviously 148 * we execute this only once. 149 */ 150 if (cpus_stopped) 151 return; 152 153 smp_send_stop(); 154 cpus_stopped = 1; 155 } 156 157 /* 158 * machine_crash_shutdown - Prepare to kexec after a kernel crash 159 * 160 * This function is called by crash_kexec just before machine_kexec 161 * and its goal is to shutdown non-crashing cpus and save registers. 162 */ 163 void 164 machine_crash_shutdown(struct pt_regs *regs) 165 { 166 local_irq_disable(); 167 168 /* shutdown non-crashing cpus */ 169 crash_smp_send_stop(); 170 171 crash_save_cpu(regs, smp_processor_id()); 172 pr_info("Starting crashdump kernel...\n"); 173 } 174 175 /* 176 * machine_kexec - Jump to the loaded kimage 177 * 178 * This function is called by kernel_kexec which is called by the 179 * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC, 180 * or by crash_kernel which is called by the kernel's arch-specific 181 * trap handler in case of a kernel panic. It's the final stage of 182 * the kexec process where the pre-loaded kimage is ready to be 183 * executed. We assume at this point that all other harts are 184 * suspended and this hart will be the new boot hart. 185 */ 186 void __noreturn 187 machine_kexec(struct kimage *image) 188 { 189 struct kimage_arch *internal = &image->arch; 190 unsigned long jump_addr = (unsigned long) image->start; 191 unsigned long first_ind_entry = (unsigned long) &image->head; 192 unsigned long this_cpu_id = __smp_processor_id(); 193 unsigned long this_hart_id = cpuid_to_hartid_map(this_cpu_id); 194 unsigned long fdt_addr = internal->fdt_addr; 195 void *control_code_buffer = page_address(image->control_code_page); 196 riscv_kexec_method kexec_method = NULL; 197 198 if (image->type != KEXEC_TYPE_CRASH) 199 kexec_method = control_code_buffer; 200 else 201 kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate; 202 203 pr_notice("Will call new kernel at %08lx from hart id %lx\n", 204 jump_addr, this_hart_id); 205 pr_notice("FDT image at %08lx\n", fdt_addr); 206 207 /* Make sure the relocation code is visible to the hart */ 208 local_flush_icache_all(); 209 210 /* Jump to the relocation code */ 211 pr_notice("Bye...\n"); 212 kexec_method(first_ind_entry, jump_addr, fdt_addr, 213 this_hart_id, kernel_map.va_pa_offset); 214 unreachable(); 215 } 216