arch/x86/kernel/crash.c

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