Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Architecture specific (i386/x86_64) functions for kexec based crash dumps.
4 : : *
5 : : * Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
6 : : *
7 : : * Copyright (C) IBM Corporation, 2004. All rights reserved.
8 : : * Copyright (C) Red Hat Inc., 2014. All rights reserved.
9 : : * Authors:
10 : : * Vivek Goyal <vgoyal@redhat.com>
11 : : *
12 : : */
13 : :
14 : : #define pr_fmt(fmt) "kexec: " fmt
15 : :
16 : : #include <linux/types.h>
17 : : #include <linux/kernel.h>
18 : : #include <linux/smp.h>
19 : : #include <linux/reboot.h>
20 : : #include <linux/kexec.h>
21 : : #include <linux/delay.h>
22 : : #include <linux/elf.h>
23 : : #include <linux/elfcore.h>
24 : : #include <linux/export.h>
25 : : #include <linux/slab.h>
26 : : #include <linux/vmalloc.h>
27 : : #include <linux/memblock.h>
28 : :
29 : : #include <asm/processor.h>
30 : : #include <asm/hardirq.h>
31 : : #include <asm/nmi.h>
32 : : #include <asm/hw_irq.h>
33 : : #include <asm/apic.h>
34 : : #include <asm/e820/types.h>
35 : : #include <asm/io_apic.h>
36 : : #include <asm/hpet.h>
37 : : #include <linux/kdebug.h>
38 : : #include <asm/cpu.h>
39 : : #include <asm/reboot.h>
40 : : #include <asm/virtext.h>
41 : : #include <asm/intel_pt.h>
42 : : #include <asm/crash.h>
43 : : #include <asm/cmdline.h>
44 : :
45 : : /* Used while preparing memory map entries for second kernel */
46 : : struct crash_memmap_data {
47 : : struct boot_params *params;
48 : : /* Type of memory */
49 : : unsigned int type;
50 : : };
51 : :
52 : : /*
53 : : * This is used to VMCLEAR all VMCSs loaded on the
54 : : * processor. And when loading kvm_intel module, the
55 : : * callback function pointer will be assigned.
56 : : *
57 : : * protected by rcu.
58 : : */
59 : : crash_vmclear_fn __rcu *crash_vmclear_loaded_vmcss = NULL;
60 : : EXPORT_SYMBOL_GPL(crash_vmclear_loaded_vmcss);
61 : :
62 : 0 : static inline void cpu_crash_vmclear_loaded_vmcss(void)
63 : : {
64 : 0 : crash_vmclear_fn *do_vmclear_operation = NULL;
65 : :
66 : 0 : rcu_read_lock();
67 [ # # # # ]: 0 : do_vmclear_operation = rcu_dereference(crash_vmclear_loaded_vmcss);
68 [ # # # # ]: 0 : if (do_vmclear_operation)
69 : 0 : do_vmclear_operation();
70 : 0 : rcu_read_unlock();
71 : : }
72 : :
73 : : /*
74 : : * When the crashkernel option is specified, only use the low
75 : : * 1M for the real mode trampoline.
76 : : */
77 : 28 : void __init crash_reserve_low_1M(void)
78 : : {
79 [ - + ]: 28 : if (cmdline_find_option(boot_command_line, "crashkernel", NULL, 0) < 0)
80 : : return;
81 : :
82 : 0 : memblock_reserve(0, 1<<20);
83 : 0 : pr_info("Reserving the low 1M of memory for crashkernel\n");
84 : : }
85 : :
86 : : #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
87 : :
88 : 0 : static void kdump_nmi_callback(int cpu, struct pt_regs *regs)
89 : : {
90 : 0 : crash_save_cpu(regs, cpu);
91 : :
92 : : /*
93 : : * VMCLEAR VMCSs loaded on all cpus if needed.
94 : : */
95 : 0 : cpu_crash_vmclear_loaded_vmcss();
96 : :
97 : : /* Disable VMX or SVM if needed.
98 : : *
99 : : * We need to disable virtualization on all CPUs.
100 : : * Having VMX or SVM enabled on any CPU may break rebooting
101 : : * after the kdump kernel has finished its task.
102 : : */
103 : 0 : cpu_emergency_vmxoff();
104 : 0 : cpu_emergency_svm_disable();
105 : :
106 : : /*
107 : : * Disable Intel PT to stop its logging
108 : : */
109 : 0 : cpu_emergency_stop_pt();
110 : :
111 : 0 : disable_local_APIC();
112 : 0 : }
113 : :
114 : 0 : void kdump_nmi_shootdown_cpus(void)
115 : : {
116 : 0 : nmi_shootdown_cpus(kdump_nmi_callback);
117 : :
118 : 0 : disable_local_APIC();
119 : 0 : }
120 : :
121 : : /* Override the weak function in kernel/panic.c */
122 : 0 : void crash_smp_send_stop(void)
123 : : {
124 : 0 : static int cpus_stopped;
125 : :
126 [ # # ]: 0 : if (cpus_stopped)
127 : : return;
128 : :
129 [ # # # # ]: 0 : if (smp_ops.crash_stop_other_cpus)
130 : 0 : smp_ops.crash_stop_other_cpus();
131 : : else
132 : 0 : smp_send_stop();
133 : :
134 : 0 : cpus_stopped = 1;
135 : : }
136 : :
137 : : #else
138 : : void crash_smp_send_stop(void)
139 : : {
140 : : /* There are no cpus to shootdown */
141 : : }
142 : : #endif
143 : :
144 : 0 : void native_machine_crash_shutdown(struct pt_regs *regs)
145 : : {
146 : : /* This function is only called after the system
147 : : * has panicked or is otherwise in a critical state.
148 : : * The minimum amount of code to allow a kexec'd kernel
149 : : * to run successfully needs to happen here.
150 : : *
151 : : * In practice this means shooting down the other cpus in
152 : : * an SMP system.
153 : : */
154 : : /* The kernel is broken so disable interrupts */
155 : 0 : local_irq_disable();
156 : :
157 [ # # ]: 0 : crash_smp_send_stop();
158 : :
159 : : /*
160 : : * VMCLEAR VMCSs loaded on this cpu if needed.
161 : : */
162 : 0 : cpu_crash_vmclear_loaded_vmcss();
163 : :
164 : : /* Booting kdump kernel with VMX or SVM enabled won't work,
165 : : * because (among other limitations) we can't disable paging
166 : : * with the virt flags.
167 : : */
168 : 0 : cpu_emergency_vmxoff();
169 : 0 : cpu_emergency_svm_disable();
170 : :
171 : : /*
172 : : * Disable Intel PT to stop its logging
173 : : */
174 : 0 : cpu_emergency_stop_pt();
175 : :
176 : : #ifdef CONFIG_X86_IO_APIC
177 : : /* Prevent crash_kexec() from deadlocking on ioapic_lock. */
178 : 0 : ioapic_zap_locks();
179 : 0 : clear_IO_APIC();
180 : : #endif
181 : 0 : lapic_shutdown();
182 : 0 : restore_boot_irq_mode();
183 : : #ifdef CONFIG_HPET_TIMER
184 : 0 : hpet_disable();
185 : : #endif
186 : 0 : crash_save_cpu(regs, safe_smp_processor_id());
187 : 0 : }
188 : :
189 : : #ifdef CONFIG_KEXEC_FILE
190 : :
191 : : static int get_nr_ram_ranges_callback(struct resource *res, void *arg)
192 : : {
193 : : unsigned int *nr_ranges = arg;
194 : :
195 : : (*nr_ranges)++;
196 : : return 0;
197 : : }
198 : :
199 : : /* Gather all the required information to prepare elf headers for ram regions */
200 : : static struct crash_mem *fill_up_crash_elf_data(void)
201 : : {
202 : : unsigned int nr_ranges = 0;
203 : : struct crash_mem *cmem;
204 : :
205 : : walk_system_ram_res(0, -1, &nr_ranges, get_nr_ram_ranges_callback);
206 : : if (!nr_ranges)
207 : : return NULL;
208 : :
209 : : /*
210 : : * Exclusion of crash region and/or crashk_low_res may cause
211 : : * another range split. So add extra two slots here.
212 : : */
213 : : nr_ranges += 2;
214 : : cmem = vzalloc(struct_size(cmem, ranges, nr_ranges));
215 : : if (!cmem)
216 : : return NULL;
217 : :
218 : : cmem->max_nr_ranges = nr_ranges;
219 : : cmem->nr_ranges = 0;
220 : :
221 : : return cmem;
222 : : }
223 : :
224 : : /*
225 : : * Look for any unwanted ranges between mstart, mend and remove them. This
226 : : * might lead to split and split ranges are put in cmem->ranges[] array
227 : : */
228 : : static int elf_header_exclude_ranges(struct crash_mem *cmem)
229 : : {
230 : : int ret = 0;
231 : :
232 : : /* Exclude the low 1M because it is always reserved */
233 : : ret = crash_exclude_mem_range(cmem, 0, 1<<20);
234 : : if (ret)
235 : : return ret;
236 : :
237 : : /* Exclude crashkernel region */
238 : : ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
239 : : if (ret)
240 : : return ret;
241 : :
242 : : if (crashk_low_res.end)
243 : : ret = crash_exclude_mem_range(cmem, crashk_low_res.start,
244 : : crashk_low_res.end);
245 : :
246 : : return ret;
247 : : }
248 : :
249 : : static int prepare_elf64_ram_headers_callback(struct resource *res, void *arg)
250 : : {
251 : : struct crash_mem *cmem = arg;
252 : :
253 : : cmem->ranges[cmem->nr_ranges].start = res->start;
254 : : cmem->ranges[cmem->nr_ranges].end = res->end;
255 : : cmem->nr_ranges++;
256 : :
257 : : return 0;
258 : : }
259 : :
260 : : /* Prepare elf headers. Return addr and size */
261 : : static int prepare_elf_headers(struct kimage *image, void **addr,
262 : : unsigned long *sz)
263 : : {
264 : : struct crash_mem *cmem;
265 : : int ret;
266 : :
267 : : cmem = fill_up_crash_elf_data();
268 : : if (!cmem)
269 : : return -ENOMEM;
270 : :
271 : : ret = walk_system_ram_res(0, -1, cmem, prepare_elf64_ram_headers_callback);
272 : : if (ret)
273 : : goto out;
274 : :
275 : : /* Exclude unwanted mem ranges */
276 : : ret = elf_header_exclude_ranges(cmem);
277 : : if (ret)
278 : : goto out;
279 : :
280 : : /* By default prepare 64bit headers */
281 : : ret = crash_prepare_elf64_headers(cmem, IS_ENABLED(CONFIG_X86_64), addr, sz);
282 : :
283 : : out:
284 : : vfree(cmem);
285 : : return ret;
286 : : }
287 : :
288 : : static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)
289 : : {
290 : : unsigned int nr_e820_entries;
291 : :
292 : : nr_e820_entries = params->e820_entries;
293 : : if (nr_e820_entries >= E820_MAX_ENTRIES_ZEROPAGE)
294 : : return 1;
295 : :
296 : : memcpy(¶ms->e820_table[nr_e820_entries], entry, sizeof(struct e820_entry));
297 : : params->e820_entries++;
298 : : return 0;
299 : : }
300 : :
301 : : static int memmap_entry_callback(struct resource *res, void *arg)
302 : : {
303 : : struct crash_memmap_data *cmd = arg;
304 : : struct boot_params *params = cmd->params;
305 : : struct e820_entry ei;
306 : :
307 : : ei.addr = res->start;
308 : : ei.size = resource_size(res);
309 : : ei.type = cmd->type;
310 : : add_e820_entry(params, &ei);
311 : :
312 : : return 0;
313 : : }
314 : :
315 : : static int memmap_exclude_ranges(struct kimage *image, struct crash_mem *cmem,
316 : : unsigned long long mstart,
317 : : unsigned long long mend)
318 : : {
319 : : unsigned long start, end;
320 : :
321 : : cmem->ranges[0].start = mstart;
322 : : cmem->ranges[0].end = mend;
323 : : cmem->nr_ranges = 1;
324 : :
325 : : /* Exclude elf header region */
326 : : start = image->arch.elf_load_addr;
327 : : end = start + image->arch.elf_headers_sz - 1;
328 : : return crash_exclude_mem_range(cmem, start, end);
329 : : }
330 : :
331 : : /* Prepare memory map for crash dump kernel */
332 : : int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
333 : : {
334 : : int i, ret = 0;
335 : : unsigned long flags;
336 : : struct e820_entry ei;
337 : : struct crash_memmap_data cmd;
338 : : struct crash_mem *cmem;
339 : :
340 : : cmem = vzalloc(sizeof(struct crash_mem));
341 : : if (!cmem)
342 : : return -ENOMEM;
343 : :
344 : : memset(&cmd, 0, sizeof(struct crash_memmap_data));
345 : : cmd.params = params;
346 : :
347 : : /* Add the low 1M */
348 : : cmd.type = E820_TYPE_RAM;
349 : : flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
350 : : walk_iomem_res_desc(IORES_DESC_NONE, flags, 0, (1<<20)-1, &cmd,
351 : : memmap_entry_callback);
352 : :
353 : : /* Add ACPI tables */
354 : : cmd.type = E820_TYPE_ACPI;
355 : : flags = IORESOURCE_MEM | IORESOURCE_BUSY;
356 : : walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd,
357 : : memmap_entry_callback);
358 : :
359 : : /* Add ACPI Non-volatile Storage */
360 : : cmd.type = E820_TYPE_NVS;
361 : : walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd,
362 : : memmap_entry_callback);
363 : :
364 : : /* Add e820 reserved ranges */
365 : : cmd.type = E820_TYPE_RESERVED;
366 : : flags = IORESOURCE_MEM;
367 : : walk_iomem_res_desc(IORES_DESC_RESERVED, flags, 0, -1, &cmd,
368 : : memmap_entry_callback);
369 : :
370 : : /* Add crashk_low_res region */
371 : : if (crashk_low_res.end) {
372 : : ei.addr = crashk_low_res.start;
373 : : ei.size = resource_size(&crashk_low_res);
374 : : ei.type = E820_TYPE_RAM;
375 : : add_e820_entry(params, &ei);
376 : : }
377 : :
378 : : /* Exclude some ranges from crashk_res and add rest to memmap */
379 : : ret = memmap_exclude_ranges(image, cmem, crashk_res.start, crashk_res.end);
380 : : if (ret)
381 : : goto out;
382 : :
383 : : for (i = 0; i < cmem->nr_ranges; i++) {
384 : : ei.size = cmem->ranges[i].end - cmem->ranges[i].start + 1;
385 : :
386 : : /* If entry is less than a page, skip it */
387 : : if (ei.size < PAGE_SIZE)
388 : : continue;
389 : : ei.addr = cmem->ranges[i].start;
390 : : ei.type = E820_TYPE_RAM;
391 : : add_e820_entry(params, &ei);
392 : : }
393 : :
394 : : out:
395 : : vfree(cmem);
396 : : return ret;
397 : : }
398 : :
399 : : int crash_load_segments(struct kimage *image)
400 : : {
401 : : int ret;
402 : : struct kexec_buf kbuf = { .image = image, .buf_min = 0,
403 : : .buf_max = ULONG_MAX, .top_down = false };
404 : :
405 : : /* Prepare elf headers and add a segment */
406 : : ret = prepare_elf_headers(image, &kbuf.buffer, &kbuf.bufsz);
407 : : if (ret)
408 : : return ret;
409 : :
410 : : image->arch.elf_headers = kbuf.buffer;
411 : : image->arch.elf_headers_sz = kbuf.bufsz;
412 : :
413 : : kbuf.memsz = kbuf.bufsz;
414 : : kbuf.buf_align = ELF_CORE_HEADER_ALIGN;
415 : : kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
416 : : ret = kexec_add_buffer(&kbuf);
417 : : if (ret) {
418 : : vfree((void *)image->arch.elf_headers);
419 : : return ret;
420 : : }
421 : : image->arch.elf_load_addr = kbuf.mem;
422 : : pr_debug("Loaded ELF headers at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
423 : : image->arch.elf_load_addr, kbuf.bufsz, kbuf.bufsz);
424 : :
425 : : return ret;
426 : : }
427 : : #endif /* CONFIG_KEXEC_FILE */
|
