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 */
30int
31machine_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(to: &fdt, from: image->segment[i].buf, n: sizeof(fdt)))
47 continue;
48
49 if (fdt_check_header(fdt: &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(page: 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(addr: (unsigned long) control_code_buffer, numpages: 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 */
91void
92machine_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 */
104void 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
117static 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(irq: i, which: IRQCHIP_STATE_ACTIVE, state: false);
135
136 if (ret && irqd_irq_inprogress(d: &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(d: &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 */
154void
155machine_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 */
179void __noreturn
180machine_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

source code of linux/arch/riscv/kernel/machine_kexec.c