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