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 */
 24static void
 25kexec_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 */
 54int
 55machine_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 */
117void
118machine_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 */
130void 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
143static 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 */
180void
181machine_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 */
205void __noreturn
206machine_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}