s390/kernel/crash_dump.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * S390 kdump implementation
0004  *
0005  * Copyright IBM Corp. 2011
0006  * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
0007  */
0008
0009 #include <linux/crash_dump.h>
0010 #include <asm/lowcore.h>
0011 #include <linux/kernel.h>
0012 #include <linux/init.h>
0013 #include <linux/mm.h>
0014 #include <linux/gfp.h>
0015 #include <linux/slab.h>
0016 #include <linux/memblock.h>
0017 #include <linux/elf.h>
0018 #include <linux/uio.h>
0019 #include <asm/asm-offsets.h>
0020 #include <asm/os_info.h>
0021 #include <asm/elf.h>
0022 #include <asm/ipl.h>
0023 #include <asm/sclp.h>
0024
0025 #define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
0026 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
0027 #define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
0028
0029 static struct memblock_region oldmem_region;
0030
0031 static struct memblock_type oldmem_type = {
0032     .cnt = 1,
0033     .max = 1,
0034     .total_size = 0,
0035     .regions = &oldmem_region,
0036     .name = "oldmem",
0037 };
0038
0039 struct save_area {
0040     struct list_head list;
0041     u64 psw[2];
0042     u64 ctrs[16];
0043     u64 gprs[16];
0044     u32 acrs[16];
0045     u64 fprs[16];
0046     u32 fpc;
0047     u32 prefix;
0048     u64 todpreg;
0049     u64 timer;
0050     u64 todcmp;
0051     u64 vxrs_low[16];
0052     __vector128 vxrs_high[16];
0053 };
0054
0055 static LIST_HEAD(dump_save_areas);
0056 static DEFINE_MUTEX(memcpy_real_mutex);
0057 static char memcpy_real_buf[PAGE_SIZE];
0058
0059 /*
0060  * Allocate a save area
0061  */
0062 struct save_area * __init save_area_alloc(bool is_boot_cpu)
0063 {
0064     struct save_area *sa;
0065
0066     sa = memblock_alloc(sizeof(*sa), 8);
0067     if (!sa)
0068         return NULL;
0069
0070     if (is_boot_cpu)
0071         list_add(&sa->list, &dump_save_areas);
0072     else
0073         list_add_tail(&sa->list, &dump_save_areas);
0074     return sa;
0075 }
0076
0077 /*
0078  * Return the address of the save area for the boot CPU
0079  */
0080 struct save_area * __init save_area_boot_cpu(void)
0081 {
0082     return list_first_entry_or_null(&dump_save_areas, struct save_area, list);
0083 }
0084
0085 /*
0086  * Copy CPU registers into the save area
0087  */
0088 void __init save_area_add_regs(struct save_area *sa, void *regs)
0089 {
0090     struct lowcore *lc;
0091
0092     lc = (struct lowcore *)(regs - __LC_FPREGS_SAVE_AREA);
0093     memcpy(&sa->psw, &lc->psw_save_area, sizeof(sa->psw));
0094     memcpy(&sa->ctrs, &lc->cregs_save_area, sizeof(sa->ctrs));
0095     memcpy(&sa->gprs, &lc->gpregs_save_area, sizeof(sa->gprs));
0096     memcpy(&sa->acrs, &lc->access_regs_save_area, sizeof(sa->acrs));
0097     memcpy(&sa->fprs, &lc->floating_pt_save_area, sizeof(sa->fprs));
0098     memcpy(&sa->fpc, &lc->fpt_creg_save_area, sizeof(sa->fpc));
0099     memcpy(&sa->prefix, &lc->prefixreg_save_area, sizeof(sa->prefix));
0100     memcpy(&sa->todpreg, &lc->tod_progreg_save_area, sizeof(sa->todpreg));
0101     memcpy(&sa->timer, &lc->cpu_timer_save_area, sizeof(sa->timer));
0102     memcpy(&sa->todcmp, &lc->clock_comp_save_area, sizeof(sa->todcmp));
0103 }
0104
0105 /*
0106  * Copy vector registers into the save area
0107  */
0108 void __init save_area_add_vxrs(struct save_area *sa, __vector128 *vxrs)
0109 {
0110     int i;
0111
0112     /* Copy lower halves of vector registers 0-15 */
0113     for (i = 0; i < 16; i++)
0114         memcpy(&sa->vxrs_low[i], &vxrs[i].u[2], 8);
0115     /* Copy vector registers 16-31 */
0116     memcpy(sa->vxrs_high, vxrs + 16, 16 * sizeof(__vector128));
0117 }
0118
0119 static size_t copy_to_iter_real(struct iov_iter *iter, unsigned long src, size_t count)
0120 {
0121     size_t len, copied, res = 0;
0122
0123     mutex_lock(&memcpy_real_mutex);
0124     while (count) {
0125         len = min(PAGE_SIZE, count);
0126         if (memcpy_real(memcpy_real_buf, src, len))
0127             break;
0128         copied = copy_to_iter(memcpy_real_buf, len, iter);
0129         count -= copied;
0130         src += copied;
0131         res += copied;
0132         if (copied < len)
0133             break;
0134     }
0135     mutex_unlock(&memcpy_real_mutex);
0136     return res;
0137 }
0138
0139 size_t copy_oldmem_iter(struct iov_iter *iter, unsigned long src, size_t count)
0140 {
0141     size_t len, copied, res = 0;
0142
0143     while (count) {
0144         if (!oldmem_data.start && src < sclp.hsa_size) {
0145             /* Copy from zfcp/nvme dump HSA area */
0146             len = min(count, sclp.hsa_size - src);
0147             copied = memcpy_hsa_iter(iter, src, len);
0148         } else {
0149             /* Check for swapped kdump oldmem areas */
0150             if (oldmem_data.start && src - oldmem_data.start < oldmem_data.size) {
0151                 src -= oldmem_data.start;
0152                 len = min(count, oldmem_data.size - src);
0153             } else if (oldmem_data.start && src < oldmem_data.size) {
0154                 len = min(count, oldmem_data.size - src);
0155                 src += oldmem_data.start;
0156             } else {
0157                 len = count;
0158             }
0159             copied = copy_to_iter_real(iter, src, len);
0160         }
0161         count -= copied;
0162         src += copied;
0163         res += copied;
0164         if (copied < len)
0165             break;
0166     }
0167     return res;
0168 }
0169
0170 /*
0171  * Copy one page from "oldmem"
0172  */
0173 ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn, size_t csize,
0174              unsigned long offset)
0175 {
0176     unsigned long src;
0177
0178     src = pfn_to_phys(pfn) + offset;
0179     return copy_oldmem_iter(iter, src, csize);
0180 }
0181
0182 /*
0183  * Remap "oldmem" for kdump
0184  *
0185  * For the kdump reserved memory this functions performs a swap operation:
0186  * [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
0187  */
0188 static int remap_oldmem_pfn_range_kdump(struct vm_area_struct *vma,
0189                     unsigned long from, unsigned long pfn,
0190                     unsigned long size, pgprot_t prot)
0191 {
0192     unsigned long size_old;
0193     int rc;
0194
0195     if (pfn < oldmem_data.size >> PAGE_SHIFT) {
0196         size_old = min(size, oldmem_data.size - (pfn << PAGE_SHIFT));
0197         rc = remap_pfn_range(vma, from,
0198                      pfn + (oldmem_data.start >> PAGE_SHIFT),
0199                      size_old, prot);
0200         if (rc || size == size_old)
0201             return rc;
0202         size -= size_old;
0203         from += size_old;
0204         pfn += size_old >> PAGE_SHIFT;
0205     }
0206     return remap_pfn_range(vma, from, pfn, size, prot);
0207 }
0208
0209 /*
0210  * Remap "oldmem" for zfcp/nvme dump
0211  *
0212  * We only map available memory above HSA size. Memory below HSA size
0213  * is read on demand using the copy_oldmem_page() function.
0214  */
0215 static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct *vma,
0216                        unsigned long from,
0217                        unsigned long pfn,
0218                        unsigned long size, pgprot_t prot)
0219 {
0220     unsigned long hsa_end = sclp.hsa_size;
0221     unsigned long size_hsa;
0222
0223     if (pfn < hsa_end >> PAGE_SHIFT) {
0224         size_hsa = min(size, hsa_end - (pfn << PAGE_SHIFT));
0225         if (size == size_hsa)
0226             return 0;
0227         size -= size_hsa;
0228         from += size_hsa;
0229         pfn += size_hsa >> PAGE_SHIFT;
0230     }
0231     return remap_pfn_range(vma, from, pfn, size, prot);
0232 }
0233
0234 /*
0235  * Remap "oldmem" for kdump or zfcp/nvme dump
0236  */
0237 int remap_oldmem_pfn_range(struct vm_area_struct *vma, unsigned long from,
0238                unsigned long pfn, unsigned long size, pgprot_t prot)
0239 {
0240     if (oldmem_data.start)
0241         return remap_oldmem_pfn_range_kdump(vma, from, pfn, size, prot);
0242     else
0243         return remap_oldmem_pfn_range_zfcpdump(vma, from, pfn, size,
0244                                prot);
0245 }
0246
0247 static const char *nt_name(Elf64_Word type)
0248 {
0249     const char *name = "LINUX";
0250
0251     if (type == NT_PRPSINFO || type == NT_PRSTATUS || type == NT_PRFPREG)
0252         name = KEXEC_CORE_NOTE_NAME;
0253     return name;
0254 }
0255
0256 /*
0257  * Initialize ELF note
0258  */
0259 static void *nt_init_name(void *buf, Elf64_Word type, void *desc, int d_len,
0260               const char *name)
0261 {
0262     Elf64_Nhdr *note;
0263     u64 len;
0264
0265     note = (Elf64_Nhdr *)buf;
0266     note->n_namesz = strlen(name) + 1;
0267     note->n_descsz = d_len;
0268     note->n_type = type;
0269     len = sizeof(Elf64_Nhdr);
0270
0271     memcpy(buf + len, name, note->n_namesz);
0272     len = roundup(len + note->n_namesz, 4);
0273
0274     memcpy(buf + len, desc, note->n_descsz);
0275     len = roundup(len + note->n_descsz, 4);
0276
0277     return PTR_ADD(buf, len);
0278 }
0279
0280 static inline void *nt_init(void *buf, Elf64_Word type, void *desc, int d_len)
0281 {
0282     return nt_init_name(buf, type, desc, d_len, nt_name(type));
0283 }
0284
0285 /*
0286  * Calculate the size of ELF note
0287  */
0288 static size_t nt_size_name(int d_len, const char *name)
0289 {
0290     size_t size;
0291
0292     size = sizeof(Elf64_Nhdr);
0293     size += roundup(strlen(name) + 1, 4);
0294     size += roundup(d_len, 4);
0295
0296     return size;
0297 }
0298
0299 static inline size_t nt_size(Elf64_Word type, int d_len)
0300 {
0301     return nt_size_name(d_len, nt_name(type));
0302 }
0303
0304 /*
0305  * Fill ELF notes for one CPU with save area registers
0306  */
0307 static void *fill_cpu_elf_notes(void *ptr, int cpu, struct save_area *sa)
0308 {
0309     struct elf_prstatus nt_prstatus;
0310     elf_fpregset_t nt_fpregset;
0311
0312     /* Prepare prstatus note */
0313     memset(&nt_prstatus, 0, sizeof(nt_prstatus));
0314     memcpy(&nt_prstatus.pr_reg.gprs, sa->gprs, sizeof(sa->gprs));
0315     memcpy(&nt_prstatus.pr_reg.psw, sa->psw, sizeof(sa->psw));
0316     memcpy(&nt_prstatus.pr_reg.acrs, sa->acrs, sizeof(sa->acrs));
0317     nt_prstatus.common.pr_pid = cpu;
0318     /* Prepare fpregset (floating point) note */
0319     memset(&nt_fpregset, 0, sizeof(nt_fpregset));
0320     memcpy(&nt_fpregset.fpc, &sa->fpc, sizeof(sa->fpc));
0321     memcpy(&nt_fpregset.fprs, &sa->fprs, sizeof(sa->fprs));
0322     /* Create ELF notes for the CPU */
0323     ptr = nt_init(ptr, NT_PRSTATUS, &nt_prstatus, sizeof(nt_prstatus));
0324     ptr = nt_init(ptr, NT_PRFPREG, &nt_fpregset, sizeof(nt_fpregset));
0325     ptr = nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer));
0326     ptr = nt_init(ptr, NT_S390_TODCMP, &sa->todcmp, sizeof(sa->todcmp));
0327     ptr = nt_init(ptr, NT_S390_TODPREG, &sa->todpreg, sizeof(sa->todpreg));
0328     ptr = nt_init(ptr, NT_S390_CTRS, &sa->ctrs, sizeof(sa->ctrs));
0329     ptr = nt_init(ptr, NT_S390_PREFIX, &sa->prefix, sizeof(sa->prefix));
0330     if (MACHINE_HAS_VX) {
0331         ptr = nt_init(ptr, NT_S390_VXRS_HIGH,
0332                   &sa->vxrs_high, sizeof(sa->vxrs_high));
0333         ptr = nt_init(ptr, NT_S390_VXRS_LOW,
0334                   &sa->vxrs_low, sizeof(sa->vxrs_low));
0335     }
0336     return ptr;
0337 }
0338
0339 /*
0340  * Calculate size of ELF notes per cpu
0341  */
0342 static size_t get_cpu_elf_notes_size(void)
0343 {
0344     struct save_area *sa = NULL;
0345     size_t size;
0346
0347     size =  nt_size(NT_PRSTATUS, sizeof(struct elf_prstatus));
0348     size +=  nt_size(NT_PRFPREG, sizeof(elf_fpregset_t));
0349     size +=  nt_size(NT_S390_TIMER, sizeof(sa->timer));
0350     size +=  nt_size(NT_S390_TODCMP, sizeof(sa->todcmp));
0351     size +=  nt_size(NT_S390_TODPREG, sizeof(sa->todpreg));
0352     size +=  nt_size(NT_S390_CTRS, sizeof(sa->ctrs));
0353     size +=  nt_size(NT_S390_PREFIX, sizeof(sa->prefix));
0354     if (MACHINE_HAS_VX) {
0355         size += nt_size(NT_S390_VXRS_HIGH, sizeof(sa->vxrs_high));
0356         size += nt_size(NT_S390_VXRS_LOW, sizeof(sa->vxrs_low));
0357     }
0358
0359     return size;
0360 }
0361
0362 /*
0363  * Initialize prpsinfo note (new kernel)
0364  */
0365 static void *nt_prpsinfo(void *ptr)
0366 {
0367     struct elf_prpsinfo prpsinfo;
0368
0369     memset(&prpsinfo, 0, sizeof(prpsinfo));
0370     prpsinfo.pr_sname = 'R';
0371     strcpy(prpsinfo.pr_fname, "vmlinux");
0372     return nt_init(ptr, NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo));
0373 }
0374
0375 /*
0376  * Get vmcoreinfo using lowcore->vmcore_info (new kernel)
0377  */
0378 static void *get_vmcoreinfo_old(unsigned long *size)
0379 {
0380     char nt_name[11], *vmcoreinfo;
0381     unsigned long addr;
0382     Elf64_Nhdr note;
0383
0384     if (copy_oldmem_kernel(&addr, __LC_VMCORE_INFO, sizeof(addr)))
0385         return NULL;
0386     memset(nt_name, 0, sizeof(nt_name));
0387     if (copy_oldmem_kernel(&note, addr, sizeof(note)))
0388         return NULL;
0389     if (copy_oldmem_kernel(nt_name, addr + sizeof(note),
0390                    sizeof(nt_name) - 1))
0391         return NULL;
0392     if (strcmp(nt_name, VMCOREINFO_NOTE_NAME) != 0)
0393         return NULL;
0394     vmcoreinfo = kzalloc(note.n_descsz, GFP_KERNEL);
0395     if (!vmcoreinfo)
0396         return NULL;
0397     if (copy_oldmem_kernel(vmcoreinfo, addr + 24, note.n_descsz)) {
0398         kfree(vmcoreinfo);
0399         return NULL;
0400     }
0401     *size = note.n_descsz;
0402     return vmcoreinfo;
0403 }
0404
0405 /*
0406  * Initialize vmcoreinfo note (new kernel)
0407  */
0408 static void *nt_vmcoreinfo(void *ptr)
0409 {
0410     const char *name = VMCOREINFO_NOTE_NAME;
0411     unsigned long size;
0412     void *vmcoreinfo;
0413
0414     vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
0415     if (vmcoreinfo)
0416         return nt_init_name(ptr, 0, vmcoreinfo, size, name);
0417
0418     vmcoreinfo = get_vmcoreinfo_old(&size);
0419     if (!vmcoreinfo)
0420         return ptr;
0421     ptr = nt_init_name(ptr, 0, vmcoreinfo, size, name);
0422     kfree(vmcoreinfo);
0423     return ptr;
0424 }
0425
0426 static size_t nt_vmcoreinfo_size(void)
0427 {
0428     const char *name = VMCOREINFO_NOTE_NAME;
0429     unsigned long size;
0430     void *vmcoreinfo;
0431
0432     vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
0433     if (vmcoreinfo)
0434         return nt_size_name(size, name);
0435
0436     vmcoreinfo = get_vmcoreinfo_old(&size);
0437     if (!vmcoreinfo)
0438         return 0;
0439
0440     kfree(vmcoreinfo);
0441     return nt_size_name(size, name);
0442 }
0443
0444 /*
0445  * Initialize final note (needed for /proc/vmcore code)
0446  */
0447 static void *nt_final(void *ptr)
0448 {
0449     Elf64_Nhdr *note;
0450
0451     note = (Elf64_Nhdr *) ptr;
0452     note->n_namesz = 0;
0453     note->n_descsz = 0;
0454     note->n_type = 0;
0455     return PTR_ADD(ptr, sizeof(Elf64_Nhdr));
0456 }
0457
0458 /*
0459  * Initialize ELF header (new kernel)
0460  */
0461 static void *ehdr_init(Elf64_Ehdr *ehdr, int mem_chunk_cnt)
0462 {
0463     memset(ehdr, 0, sizeof(*ehdr));
0464     memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
0465     ehdr->e_ident[EI_CLASS] = ELFCLASS64;
0466     ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
0467     ehdr->e_ident[EI_VERSION] = EV_CURRENT;
0468     memset(ehdr->e_ident + EI_PAD, 0, EI_NIDENT - EI_PAD);
0469     ehdr->e_type = ET_CORE;
0470     ehdr->e_machine = EM_S390;
0471     ehdr->e_version = EV_CURRENT;
0472     ehdr->e_phoff = sizeof(Elf64_Ehdr);
0473     ehdr->e_ehsize = sizeof(Elf64_Ehdr);
0474     ehdr->e_phentsize = sizeof(Elf64_Phdr);
0475     ehdr->e_phnum = mem_chunk_cnt + 1;
0476     return ehdr + 1;
0477 }
0478
0479 /*
0480  * Return CPU count for ELF header (new kernel)
0481  */
0482 static int get_cpu_cnt(void)
0483 {
0484     struct save_area *sa;
0485     int cpus = 0;
0486
0487     list_for_each_entry(sa, &dump_save_areas, list)
0488         if (sa->prefix != 0)
0489             cpus++;
0490     return cpus;
0491 }
0492
0493 /*
0494  * Return memory chunk count for ELF header (new kernel)
0495  */
0496 static int get_mem_chunk_cnt(void)
0497 {
0498     int cnt = 0;
0499     u64 idx;
0500
0501     for_each_physmem_range(idx, &oldmem_type, NULL, NULL)
0502         cnt++;
0503     return cnt;
0504 }
0505
0506 /*
0507  * Initialize ELF loads (new kernel)
0508  */
0509 static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
0510 {
0511     phys_addr_t start, end;
0512     u64 idx;
0513
0514     for_each_physmem_range(idx, &oldmem_type, &start, &end) {
0515         phdr->p_filesz = end - start;
0516         phdr->p_type = PT_LOAD;
0517         phdr->p_offset = start;
0518         phdr->p_vaddr = start;
0519         phdr->p_paddr = start;
0520         phdr->p_memsz = end - start;
0521         phdr->p_flags = PF_R | PF_W | PF_X;
0522         phdr->p_align = PAGE_SIZE;
0523         phdr++;
0524     }
0525 }
0526
0527 /*
0528  * Initialize notes (new kernel)
0529  */
0530 static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
0531 {
0532     struct save_area *sa;
0533     void *ptr_start = ptr;
0534     int cpu;
0535
0536     ptr = nt_prpsinfo(ptr);
0537
0538     cpu = 1;
0539     list_for_each_entry(sa, &dump_save_areas, list)
0540         if (sa->prefix != 0)
0541             ptr = fill_cpu_elf_notes(ptr, cpu++, sa);
0542     ptr = nt_vmcoreinfo(ptr);
0543     ptr = nt_final(ptr);
0544     memset(phdr, 0, sizeof(*phdr));
0545     phdr->p_type = PT_NOTE;
0546     phdr->p_offset = notes_offset;
0547     phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
0548     phdr->p_memsz = phdr->p_filesz;
0549     return ptr;
0550 }
0551
0552 static size_t get_elfcorehdr_size(int mem_chunk_cnt)
0553 {
0554     size_t size;
0555
0556     size = sizeof(Elf64_Ehdr);
0557     /* PT_NOTES */
0558     size += sizeof(Elf64_Phdr);
0559     /* nt_prpsinfo */
0560     size += nt_size(NT_PRPSINFO, sizeof(struct elf_prpsinfo));
0561     /* regsets */
0562     size += get_cpu_cnt() * get_cpu_elf_notes_size();
0563     /* nt_vmcoreinfo */
0564     size += nt_vmcoreinfo_size();
0565     /* nt_final */
0566     size += sizeof(Elf64_Nhdr);
0567     /* PT_LOADS */
0568     size += mem_chunk_cnt * sizeof(Elf64_Phdr);
0569
0570     return size;
0571 }
0572
0573 /*
0574  * Create ELF core header (new kernel)
0575  */
0576 int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
0577 {
0578     Elf64_Phdr *phdr_notes, *phdr_loads;
0579     int mem_chunk_cnt;
0580     void *ptr, *hdr;
0581     u32 alloc_size;
0582     u64 hdr_off;
0583
0584     /* If we are not in kdump or zfcp/nvme dump mode return */
0585     if (!oldmem_data.start && !is_ipl_type_dump())
0586         return 0;
0587     /* If we cannot get HSA size for zfcp/nvme dump return error */
0588     if (is_ipl_type_dump() && !sclp.hsa_size)
0589         return -ENODEV;
0590
0591     /* For kdump, exclude previous crashkernel memory */
0592     if (oldmem_data.start) {
0593         oldmem_region.base = oldmem_data.start;
0594         oldmem_region.size = oldmem_data.size;
0595         oldmem_type.total_size = oldmem_data.size;
0596     }
0597
0598     mem_chunk_cnt = get_mem_chunk_cnt();
0599
0600     alloc_size = get_elfcorehdr_size(mem_chunk_cnt);
0601
0602     hdr = kzalloc(alloc_size, GFP_KERNEL);
0603
0604     /* Without elfcorehdr /proc/vmcore cannot be created. Thus creating
0605      * a dump with this crash kernel will fail. Panic now to allow other
0606      * dump mechanisms to take over.
0607      */
0608     if (!hdr)
0609         panic("s390 kdump allocating elfcorehdr failed");
0610
0611     /* Init elf header */
0612     ptr = ehdr_init(hdr, mem_chunk_cnt);
0613     /* Init program headers */
0614     phdr_notes = ptr;
0615     ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr));
0616     phdr_loads = ptr;
0617     ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
0618     /* Init notes */
0619     hdr_off = PTR_DIFF(ptr, hdr);
0620     ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
0621     /* Init loads */
0622     hdr_off = PTR_DIFF(ptr, hdr);
0623     loads_init(phdr_loads, hdr_off);
0624     *addr = (unsigned long long) hdr;
0625     *size = (unsigned long long) hdr_off;
0626     BUG_ON(elfcorehdr_size > alloc_size);
0627     return 0;
0628 }
0629
0630 /*
0631  * Free ELF core header (new kernel)
0632  */
0633 void elfcorehdr_free(unsigned long long addr)
0634 {
0635     kfree((void *)(unsigned long)addr);
0636 }
0637
0638 /*
0639  * Read from ELF header
0640  */
0641 ssize_t elfcorehdr_read(char *buf, size_t count, u64 *ppos)
0642 {
0643     void *src = (void *)(unsigned long)*ppos;
0644
0645     memcpy(buf, src, count);
0646     *ppos += count;
0647     return count;
0648 }
0649
0650 /*
0651  * Read from ELF notes data
0652  */
0653 ssize_t elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos)
0654 {
0655     void *src = (void *)(unsigned long)*ppos;
0656
0657     memcpy(buf, src, count);
0658     *ppos += count;
0659     return count;
0660 }