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(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 | */ |
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(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 | */ |
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 | |