xref: /openbmc/linux/arch/x86/kernel/crash.c (revision d7a3d85e)
1 /*
2  * Architecture specific (i386/x86_64) functions for kexec based crash dumps.
3  *
4  * Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
5  *
6  * Copyright (C) IBM Corporation, 2004. All rights reserved.
7  * Copyright (C) Red Hat Inc., 2014. All rights reserved.
8  * Authors:
9  *      Vivek Goyal <vgoyal@redhat.com>
10  *
11  */
12 
13 #define pr_fmt(fmt)	"kexec: " fmt
14 
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <linux/smp.h>
18 #include <linux/reboot.h>
19 #include <linux/kexec.h>
20 #include <linux/delay.h>
21 #include <linux/elf.h>
22 #include <linux/elfcore.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 
26 #include <asm/processor.h>
27 #include <asm/hardirq.h>
28 #include <asm/nmi.h>
29 #include <asm/hw_irq.h>
30 #include <asm/apic.h>
31 #include <asm/io_apic.h>
32 #include <asm/hpet.h>
33 #include <linux/kdebug.h>
34 #include <asm/cpu.h>
35 #include <asm/reboot.h>
36 #include <asm/virtext.h>
37 
38 /* Alignment required for elf header segment */
39 #define ELF_CORE_HEADER_ALIGN   4096
40 
41 /* This primarily represents number of split ranges due to exclusion */
42 #define CRASH_MAX_RANGES	16
43 
44 struct crash_mem_range {
45 	u64 start, end;
46 };
47 
48 struct crash_mem {
49 	unsigned int nr_ranges;
50 	struct crash_mem_range ranges[CRASH_MAX_RANGES];
51 };
52 
53 /* Misc data about ram ranges needed to prepare elf headers */
54 struct crash_elf_data {
55 	struct kimage *image;
56 	/*
57 	 * Total number of ram ranges we have after various adjustments for
58 	 * GART, crash reserved region etc.
59 	 */
60 	unsigned int max_nr_ranges;
61 	unsigned long gart_start, gart_end;
62 
63 	/* Pointer to elf header */
64 	void *ehdr;
65 	/* Pointer to next phdr */
66 	void *bufp;
67 	struct crash_mem mem;
68 };
69 
70 /* Used while preparing memory map entries for second kernel */
71 struct crash_memmap_data {
72 	struct boot_params *params;
73 	/* Type of memory */
74 	unsigned int type;
75 };
76 
77 int in_crash_kexec;
78 
79 /*
80  * This is used to VMCLEAR all VMCSs loaded on the
81  * processor. And when loading kvm_intel module, the
82  * callback function pointer will be assigned.
83  *
84  * protected by rcu.
85  */
86 crash_vmclear_fn __rcu *crash_vmclear_loaded_vmcss = NULL;
87 EXPORT_SYMBOL_GPL(crash_vmclear_loaded_vmcss);
88 unsigned long crash_zero_bytes;
89 
90 static inline void cpu_crash_vmclear_loaded_vmcss(void)
91 {
92 	crash_vmclear_fn *do_vmclear_operation = NULL;
93 
94 	rcu_read_lock();
95 	do_vmclear_operation = rcu_dereference(crash_vmclear_loaded_vmcss);
96 	if (do_vmclear_operation)
97 		do_vmclear_operation();
98 	rcu_read_unlock();
99 }
100 
101 #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
102 
103 static void kdump_nmi_callback(int cpu, struct pt_regs *regs)
104 {
105 #ifdef CONFIG_X86_32
106 	struct pt_regs fixed_regs;
107 
108 	if (!user_mode(regs)) {
109 		crash_fixup_ss_esp(&fixed_regs, regs);
110 		regs = &fixed_regs;
111 	}
112 #endif
113 	crash_save_cpu(regs, cpu);
114 
115 	/*
116 	 * VMCLEAR VMCSs loaded on all cpus if needed.
117 	 */
118 	cpu_crash_vmclear_loaded_vmcss();
119 
120 	/* Disable VMX or SVM if needed.
121 	 *
122 	 * We need to disable virtualization on all CPUs.
123 	 * Having VMX or SVM enabled on any CPU may break rebooting
124 	 * after the kdump kernel has finished its task.
125 	 */
126 	cpu_emergency_vmxoff();
127 	cpu_emergency_svm_disable();
128 
129 	disable_local_APIC();
130 }
131 
132 static void kdump_nmi_shootdown_cpus(void)
133 {
134 	in_crash_kexec = 1;
135 	nmi_shootdown_cpus(kdump_nmi_callback);
136 
137 	disable_local_APIC();
138 }
139 
140 #else
141 static void kdump_nmi_shootdown_cpus(void)
142 {
143 	/* There are no cpus to shootdown */
144 }
145 #endif
146 
147 void native_machine_crash_shutdown(struct pt_regs *regs)
148 {
149 	/* This function is only called after the system
150 	 * has panicked or is otherwise in a critical state.
151 	 * The minimum amount of code to allow a kexec'd kernel
152 	 * to run successfully needs to happen here.
153 	 *
154 	 * In practice this means shooting down the other cpus in
155 	 * an SMP system.
156 	 */
157 	/* The kernel is broken so disable interrupts */
158 	local_irq_disable();
159 
160 	kdump_nmi_shootdown_cpus();
161 
162 	/*
163 	 * VMCLEAR VMCSs loaded on this cpu if needed.
164 	 */
165 	cpu_crash_vmclear_loaded_vmcss();
166 
167 	/* Booting kdump kernel with VMX or SVM enabled won't work,
168 	 * because (among other limitations) we can't disable paging
169 	 * with the virt flags.
170 	 */
171 	cpu_emergency_vmxoff();
172 	cpu_emergency_svm_disable();
173 
174 #ifdef CONFIG_X86_IO_APIC
175 	/* Prevent crash_kexec() from deadlocking on ioapic_lock. */
176 	ioapic_zap_locks();
177 	disable_IO_APIC();
178 #endif
179 	lapic_shutdown();
180 #ifdef CONFIG_HPET_TIMER
181 	hpet_disable();
182 #endif
183 	crash_save_cpu(regs, safe_smp_processor_id());
184 }
185 
186 #ifdef CONFIG_KEXEC_FILE
187 static int get_nr_ram_ranges_callback(unsigned long start_pfn,
188 				unsigned long nr_pfn, void *arg)
189 {
190 	int *nr_ranges = arg;
191 
192 	(*nr_ranges)++;
193 	return 0;
194 }
195 
196 static int get_gart_ranges_callback(u64 start, u64 end, void *arg)
197 {
198 	struct crash_elf_data *ced = arg;
199 
200 	ced->gart_start = start;
201 	ced->gart_end = end;
202 
203 	/* Not expecting more than 1 gart aperture */
204 	return 1;
205 }
206 
207 
208 /* Gather all the required information to prepare elf headers for ram regions */
209 static void fill_up_crash_elf_data(struct crash_elf_data *ced,
210 				   struct kimage *image)
211 {
212 	unsigned int nr_ranges = 0;
213 
214 	ced->image = image;
215 
216 	walk_system_ram_range(0, -1, &nr_ranges,
217 				get_nr_ram_ranges_callback);
218 
219 	ced->max_nr_ranges = nr_ranges;
220 
221 	/*
222 	 * We don't create ELF headers for GART aperture as an attempt
223 	 * to dump this memory in second kernel leads to hang/crash.
224 	 * If gart aperture is present, one needs to exclude that region
225 	 * and that could lead to need of extra phdr.
226 	 */
227 	walk_iomem_res("GART", IORESOURCE_MEM, 0, -1,
228 				ced, get_gart_ranges_callback);
229 
230 	/*
231 	 * If we have gart region, excluding that could potentially split
232 	 * a memory range, resulting in extra header. Account for  that.
233 	 */
234 	if (ced->gart_end)
235 		ced->max_nr_ranges++;
236 
237 	/* Exclusion of crash region could split memory ranges */
238 	ced->max_nr_ranges++;
239 
240 	/* If crashk_low_res is not 0, another range split possible */
241 	if (crashk_low_res.end)
242 		ced->max_nr_ranges++;
243 }
244 
245 static int exclude_mem_range(struct crash_mem *mem,
246 		unsigned long long mstart, unsigned long long mend)
247 {
248 	int i, j;
249 	unsigned long long start, end;
250 	struct crash_mem_range temp_range = {0, 0};
251 
252 	for (i = 0; i < mem->nr_ranges; i++) {
253 		start = mem->ranges[i].start;
254 		end = mem->ranges[i].end;
255 
256 		if (mstart > end || mend < start)
257 			continue;
258 
259 		/* Truncate any area outside of range */
260 		if (mstart < start)
261 			mstart = start;
262 		if (mend > end)
263 			mend = end;
264 
265 		/* Found completely overlapping range */
266 		if (mstart == start && mend == end) {
267 			mem->ranges[i].start = 0;
268 			mem->ranges[i].end = 0;
269 			if (i < mem->nr_ranges - 1) {
270 				/* Shift rest of the ranges to left */
271 				for (j = i; j < mem->nr_ranges - 1; j++) {
272 					mem->ranges[j].start =
273 						mem->ranges[j+1].start;
274 					mem->ranges[j].end =
275 							mem->ranges[j+1].end;
276 				}
277 			}
278 			mem->nr_ranges--;
279 			return 0;
280 		}
281 
282 		if (mstart > start && mend < end) {
283 			/* Split original range */
284 			mem->ranges[i].end = mstart - 1;
285 			temp_range.start = mend + 1;
286 			temp_range.end = end;
287 		} else if (mstart != start)
288 			mem->ranges[i].end = mstart - 1;
289 		else
290 			mem->ranges[i].start = mend + 1;
291 		break;
292 	}
293 
294 	/* If a split happend, add the split to array */
295 	if (!temp_range.end)
296 		return 0;
297 
298 	/* Split happened */
299 	if (i == CRASH_MAX_RANGES - 1) {
300 		pr_err("Too many crash ranges after split\n");
301 		return -ENOMEM;
302 	}
303 
304 	/* Location where new range should go */
305 	j = i + 1;
306 	if (j < mem->nr_ranges) {
307 		/* Move over all ranges one slot towards the end */
308 		for (i = mem->nr_ranges - 1; i >= j; i--)
309 			mem->ranges[i + 1] = mem->ranges[i];
310 	}
311 
312 	mem->ranges[j].start = temp_range.start;
313 	mem->ranges[j].end = temp_range.end;
314 	mem->nr_ranges++;
315 	return 0;
316 }
317 
318 /*
319  * Look for any unwanted ranges between mstart, mend and remove them. This
320  * might lead to split and split ranges are put in ced->mem.ranges[] array
321  */
322 static int elf_header_exclude_ranges(struct crash_elf_data *ced,
323 		unsigned long long mstart, unsigned long long mend)
324 {
325 	struct crash_mem *cmem = &ced->mem;
326 	int ret = 0;
327 
328 	memset(cmem->ranges, 0, sizeof(cmem->ranges));
329 
330 	cmem->ranges[0].start = mstart;
331 	cmem->ranges[0].end = mend;
332 	cmem->nr_ranges = 1;
333 
334 	/* Exclude crashkernel region */
335 	ret = exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
336 	if (ret)
337 		return ret;
338 
339 	if (crashk_low_res.end) {
340 		ret = exclude_mem_range(cmem, crashk_low_res.start, crashk_low_res.end);
341 		if (ret)
342 			return ret;
343 	}
344 
345 	/* Exclude GART region */
346 	if (ced->gart_end) {
347 		ret = exclude_mem_range(cmem, ced->gart_start, ced->gart_end);
348 		if (ret)
349 			return ret;
350 	}
351 
352 	return ret;
353 }
354 
355 static int prepare_elf64_ram_headers_callback(u64 start, u64 end, void *arg)
356 {
357 	struct crash_elf_data *ced = arg;
358 	Elf64_Ehdr *ehdr;
359 	Elf64_Phdr *phdr;
360 	unsigned long mstart, mend;
361 	struct kimage *image = ced->image;
362 	struct crash_mem *cmem;
363 	int ret, i;
364 
365 	ehdr = ced->ehdr;
366 
367 	/* Exclude unwanted mem ranges */
368 	ret = elf_header_exclude_ranges(ced, start, end);
369 	if (ret)
370 		return ret;
371 
372 	/* Go through all the ranges in ced->mem.ranges[] and prepare phdr */
373 	cmem = &ced->mem;
374 
375 	for (i = 0; i < cmem->nr_ranges; i++) {
376 		mstart = cmem->ranges[i].start;
377 		mend = cmem->ranges[i].end;
378 
379 		phdr = ced->bufp;
380 		ced->bufp += sizeof(Elf64_Phdr);
381 
382 		phdr->p_type = PT_LOAD;
383 		phdr->p_flags = PF_R|PF_W|PF_X;
384 		phdr->p_offset  = mstart;
385 
386 		/*
387 		 * If a range matches backup region, adjust offset to backup
388 		 * segment.
389 		 */
390 		if (mstart == image->arch.backup_src_start &&
391 		    (mend - mstart + 1) == image->arch.backup_src_sz)
392 			phdr->p_offset = image->arch.backup_load_addr;
393 
394 		phdr->p_paddr = mstart;
395 		phdr->p_vaddr = (unsigned long long) __va(mstart);
396 		phdr->p_filesz = phdr->p_memsz = mend - mstart + 1;
397 		phdr->p_align = 0;
398 		ehdr->e_phnum++;
399 		pr_debug("Crash PT_LOAD elf header. phdr=%p vaddr=0x%llx, paddr=0x%llx, sz=0x%llx e_phnum=%d p_offset=0x%llx\n",
400 			phdr, phdr->p_vaddr, phdr->p_paddr, phdr->p_filesz,
401 			ehdr->e_phnum, phdr->p_offset);
402 	}
403 
404 	return ret;
405 }
406 
407 static int prepare_elf64_headers(struct crash_elf_data *ced,
408 		void **addr, unsigned long *sz)
409 {
410 	Elf64_Ehdr *ehdr;
411 	Elf64_Phdr *phdr;
412 	unsigned long nr_cpus = num_possible_cpus(), nr_phdr, elf_sz;
413 	unsigned char *buf, *bufp;
414 	unsigned int cpu;
415 	unsigned long long notes_addr;
416 	int ret;
417 
418 	/* extra phdr for vmcoreinfo elf note */
419 	nr_phdr = nr_cpus + 1;
420 	nr_phdr += ced->max_nr_ranges;
421 
422 	/*
423 	 * kexec-tools creates an extra PT_LOAD phdr for kernel text mapping
424 	 * area on x86_64 (ffffffff80000000 - ffffffffa0000000).
425 	 * I think this is required by tools like gdb. So same physical
426 	 * memory will be mapped in two elf headers. One will contain kernel
427 	 * text virtual addresses and other will have __va(physical) addresses.
428 	 */
429 
430 	nr_phdr++;
431 	elf_sz = sizeof(Elf64_Ehdr) + nr_phdr * sizeof(Elf64_Phdr);
432 	elf_sz = ALIGN(elf_sz, ELF_CORE_HEADER_ALIGN);
433 
434 	buf = vzalloc(elf_sz);
435 	if (!buf)
436 		return -ENOMEM;
437 
438 	bufp = buf;
439 	ehdr = (Elf64_Ehdr *)bufp;
440 	bufp += sizeof(Elf64_Ehdr);
441 	memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
442 	ehdr->e_ident[EI_CLASS] = ELFCLASS64;
443 	ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
444 	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
445 	ehdr->e_ident[EI_OSABI] = ELF_OSABI;
446 	memset(ehdr->e_ident + EI_PAD, 0, EI_NIDENT - EI_PAD);
447 	ehdr->e_type = ET_CORE;
448 	ehdr->e_machine = ELF_ARCH;
449 	ehdr->e_version = EV_CURRENT;
450 	ehdr->e_phoff = sizeof(Elf64_Ehdr);
451 	ehdr->e_ehsize = sizeof(Elf64_Ehdr);
452 	ehdr->e_phentsize = sizeof(Elf64_Phdr);
453 
454 	/* Prepare one phdr of type PT_NOTE for each present cpu */
455 	for_each_present_cpu(cpu) {
456 		phdr = (Elf64_Phdr *)bufp;
457 		bufp += sizeof(Elf64_Phdr);
458 		phdr->p_type = PT_NOTE;
459 		notes_addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpu));
460 		phdr->p_offset = phdr->p_paddr = notes_addr;
461 		phdr->p_filesz = phdr->p_memsz = sizeof(note_buf_t);
462 		(ehdr->e_phnum)++;
463 	}
464 
465 	/* Prepare one PT_NOTE header for vmcoreinfo */
466 	phdr = (Elf64_Phdr *)bufp;
467 	bufp += sizeof(Elf64_Phdr);
468 	phdr->p_type = PT_NOTE;
469 	phdr->p_offset = phdr->p_paddr = paddr_vmcoreinfo_note();
470 	phdr->p_filesz = phdr->p_memsz = sizeof(vmcoreinfo_note);
471 	(ehdr->e_phnum)++;
472 
473 #ifdef CONFIG_X86_64
474 	/* Prepare PT_LOAD type program header for kernel text region */
475 	phdr = (Elf64_Phdr *)bufp;
476 	bufp += sizeof(Elf64_Phdr);
477 	phdr->p_type = PT_LOAD;
478 	phdr->p_flags = PF_R|PF_W|PF_X;
479 	phdr->p_vaddr = (Elf64_Addr)_text;
480 	phdr->p_filesz = phdr->p_memsz = _end - _text;
481 	phdr->p_offset = phdr->p_paddr = __pa_symbol(_text);
482 	(ehdr->e_phnum)++;
483 #endif
484 
485 	/* Prepare PT_LOAD headers for system ram chunks. */
486 	ced->ehdr = ehdr;
487 	ced->bufp = bufp;
488 	ret = walk_system_ram_res(0, -1, ced,
489 			prepare_elf64_ram_headers_callback);
490 	if (ret < 0)
491 		return ret;
492 
493 	*addr = buf;
494 	*sz = elf_sz;
495 	return 0;
496 }
497 
498 /* Prepare elf headers. Return addr and size */
499 static int prepare_elf_headers(struct kimage *image, void **addr,
500 					unsigned long *sz)
501 {
502 	struct crash_elf_data *ced;
503 	int ret;
504 
505 	ced = kzalloc(sizeof(*ced), GFP_KERNEL);
506 	if (!ced)
507 		return -ENOMEM;
508 
509 	fill_up_crash_elf_data(ced, image);
510 
511 	/* By default prepare 64bit headers */
512 	ret =  prepare_elf64_headers(ced, addr, sz);
513 	kfree(ced);
514 	return ret;
515 }
516 
517 static int add_e820_entry(struct boot_params *params, struct e820entry *entry)
518 {
519 	unsigned int nr_e820_entries;
520 
521 	nr_e820_entries = params->e820_entries;
522 	if (nr_e820_entries >= E820MAX)
523 		return 1;
524 
525 	memcpy(&params->e820_map[nr_e820_entries], entry,
526 			sizeof(struct e820entry));
527 	params->e820_entries++;
528 	return 0;
529 }
530 
531 static int memmap_entry_callback(u64 start, u64 end, void *arg)
532 {
533 	struct crash_memmap_data *cmd = arg;
534 	struct boot_params *params = cmd->params;
535 	struct e820entry ei;
536 
537 	ei.addr = start;
538 	ei.size = end - start + 1;
539 	ei.type = cmd->type;
540 	add_e820_entry(params, &ei);
541 
542 	return 0;
543 }
544 
545 static int memmap_exclude_ranges(struct kimage *image, struct crash_mem *cmem,
546 				 unsigned long long mstart,
547 				 unsigned long long mend)
548 {
549 	unsigned long start, end;
550 	int ret = 0;
551 
552 	cmem->ranges[0].start = mstart;
553 	cmem->ranges[0].end = mend;
554 	cmem->nr_ranges = 1;
555 
556 	/* Exclude Backup region */
557 	start = image->arch.backup_load_addr;
558 	end = start + image->arch.backup_src_sz - 1;
559 	ret = exclude_mem_range(cmem, start, end);
560 	if (ret)
561 		return ret;
562 
563 	/* Exclude elf header region */
564 	start = image->arch.elf_load_addr;
565 	end = start + image->arch.elf_headers_sz - 1;
566 	return exclude_mem_range(cmem, start, end);
567 }
568 
569 /* Prepare memory map for crash dump kernel */
570 int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
571 {
572 	int i, ret = 0;
573 	unsigned long flags;
574 	struct e820entry ei;
575 	struct crash_memmap_data cmd;
576 	struct crash_mem *cmem;
577 
578 	cmem = vzalloc(sizeof(struct crash_mem));
579 	if (!cmem)
580 		return -ENOMEM;
581 
582 	memset(&cmd, 0, sizeof(struct crash_memmap_data));
583 	cmd.params = params;
584 
585 	/* Add first 640K segment */
586 	ei.addr = image->arch.backup_src_start;
587 	ei.size = image->arch.backup_src_sz;
588 	ei.type = E820_RAM;
589 	add_e820_entry(params, &ei);
590 
591 	/* Add ACPI tables */
592 	cmd.type = E820_ACPI;
593 	flags = IORESOURCE_MEM | IORESOURCE_BUSY;
594 	walk_iomem_res("ACPI Tables", flags, 0, -1, &cmd,
595 		       memmap_entry_callback);
596 
597 	/* Add ACPI Non-volatile Storage */
598 	cmd.type = E820_NVS;
599 	walk_iomem_res("ACPI Non-volatile Storage", flags, 0, -1, &cmd,
600 			memmap_entry_callback);
601 
602 	/* Add crashk_low_res region */
603 	if (crashk_low_res.end) {
604 		ei.addr = crashk_low_res.start;
605 		ei.size = crashk_low_res.end - crashk_low_res.start + 1;
606 		ei.type = E820_RAM;
607 		add_e820_entry(params, &ei);
608 	}
609 
610 	/* Exclude some ranges from crashk_res and add rest to memmap */
611 	ret = memmap_exclude_ranges(image, cmem, crashk_res.start,
612 						crashk_res.end);
613 	if (ret)
614 		goto out;
615 
616 	for (i = 0; i < cmem->nr_ranges; i++) {
617 		ei.size = cmem->ranges[i].end - cmem->ranges[i].start + 1;
618 
619 		/* If entry is less than a page, skip it */
620 		if (ei.size < PAGE_SIZE)
621 			continue;
622 		ei.addr = cmem->ranges[i].start;
623 		ei.type = E820_RAM;
624 		add_e820_entry(params, &ei);
625 	}
626 
627 out:
628 	vfree(cmem);
629 	return ret;
630 }
631 
632 static int determine_backup_region(u64 start, u64 end, void *arg)
633 {
634 	struct kimage *image = arg;
635 
636 	image->arch.backup_src_start = start;
637 	image->arch.backup_src_sz = end - start + 1;
638 
639 	/* Expecting only one range for backup region */
640 	return 1;
641 }
642 
643 int crash_load_segments(struct kimage *image)
644 {
645 	unsigned long src_start, src_sz, elf_sz;
646 	void *elf_addr;
647 	int ret;
648 
649 	/*
650 	 * Determine and load a segment for backup area. First 640K RAM
651 	 * region is backup source
652 	 */
653 
654 	ret = walk_system_ram_res(KEXEC_BACKUP_SRC_START, KEXEC_BACKUP_SRC_END,
655 				image, determine_backup_region);
656 
657 	/* Zero or postive return values are ok */
658 	if (ret < 0)
659 		return ret;
660 
661 	src_start = image->arch.backup_src_start;
662 	src_sz = image->arch.backup_src_sz;
663 
664 	/* Add backup segment. */
665 	if (src_sz) {
666 		/*
667 		 * Ideally there is no source for backup segment. This is
668 		 * copied in purgatory after crash. Just add a zero filled
669 		 * segment for now to make sure checksum logic works fine.
670 		 */
671 		ret = kexec_add_buffer(image, (char *)&crash_zero_bytes,
672 				       sizeof(crash_zero_bytes), src_sz,
673 				       PAGE_SIZE, 0, -1, 0,
674 				       &image->arch.backup_load_addr);
675 		if (ret)
676 			return ret;
677 		pr_debug("Loaded backup region at 0x%lx backup_start=0x%lx memsz=0x%lx\n",
678 			 image->arch.backup_load_addr, src_start, src_sz);
679 	}
680 
681 	/* Prepare elf headers and add a segment */
682 	ret = prepare_elf_headers(image, &elf_addr, &elf_sz);
683 	if (ret)
684 		return ret;
685 
686 	image->arch.elf_headers = elf_addr;
687 	image->arch.elf_headers_sz = elf_sz;
688 
689 	ret = kexec_add_buffer(image, (char *)elf_addr, elf_sz, elf_sz,
690 			ELF_CORE_HEADER_ALIGN, 0, -1, 0,
691 			&image->arch.elf_load_addr);
692 	if (ret) {
693 		vfree((void *)image->arch.elf_headers);
694 		return ret;
695 	}
696 	pr_debug("Loaded ELF headers at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
697 		 image->arch.elf_load_addr, elf_sz, elf_sz);
698 
699 	return ret;
700 }
701 #endif /* CONFIG_KEXEC_FILE */
702