arch/s390/kernel/crash_dump.c

   1 /*
   2  * S390 kdump implementation
   3  *
   4  * Copyright IBM Corp. 2011
   5  * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
   6  */
   7
   8 #include <linux/crash_dump.h>
   9 #include <asm/lowcore.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/gfp.h>
  13 #include <linux/slab.h>
  14 #include <linux/bootmem.h>
  15 #include <linux/elf.h>
  16 #include <linux/memblock.h>
  17 #include <asm/os_info.h>
  18 #include <asm/elf.h>
  19 #include <asm/ipl.h>
  20 #include <asm/sclp.h>
  21
  22 #define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
  23 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
  24 #define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
  25
  26 static struct memblock_region oldmem_region;
  27
  28 static struct memblock_type oldmem_type = {
  29         .cnt = 1,
  30         .max = 1,
  31         .total_size = 0,
  32         .regions = &oldmem_region,
  33 };
  34
  35 #define for_each_dump_mem_range(i, nid, p_start, p_end, p_nid)          \
  36         for (i = 0, __next_mem_range(&i, nid, MEMBLOCK_NONE,            \
  37                                      &memblock.physmem,                 \
  38                                      &oldmem_type, p_start,             \
  39                                      p_end, p_nid);                     \
  40              i != (u64)ULLONG_MAX;                                      \
  41              __next_mem_range(&i, nid, MEMBLOCK_NONE, &memblock.physmem,\
  42                               &oldmem_type,                             \
  43                               p_start, p_end, p_nid))
  44
  45 struct dump_save_areas dump_save_areas;
  46
  47 /*
  48  * Allocate and add a save area for a CPU
  49  */
  50 struct save_area_ext *dump_save_area_create(int cpu)
  51 {
  52         struct save_area_ext **save_areas, *save_area;
  53
  54         save_area = kmalloc(sizeof(*save_area), GFP_KERNEL);
  55         if (!save_area)
  56                 return NULL;
  57         if (cpu + 1 > dump_save_areas.count) {
  58                 dump_save_areas.count = cpu + 1;
  59                 save_areas = krealloc(dump_save_areas.areas,
  60                                       dump_save_areas.count * sizeof(void *),
  61                                       GFP_KERNEL | __GFP_ZERO);
  62                 if (!save_areas) {
  63                         kfree(save_area);
  64                         return NULL;
  65                 }
  66                 dump_save_areas.areas = save_areas;
  67         }
  68         dump_save_areas.areas[cpu] = save_area;
  69         return save_area;
  70 }
  71
  72 /*
  73  * Return physical address for virtual address
  74  */
  75 static inline void *load_real_addr(void *addr)
  76 {
  77         unsigned long real_addr;
  78
  79         asm volatile(
  80                    "    lra     %0,0(%1)\n"
  81                    "    jz      0f\n"
  82                    "    la      %0,0\n"
  83                    "0:"
  84                    : "=a" (real_addr) : "a" (addr) : "cc");
  85         return (void *)real_addr;
  86 }
  87
  88 /*
  89  * Copy real to virtual or real memory
  90  */
  91 static int copy_from_realmem(void *dest, void *src, size_t count)
  92 {
  93         unsigned long size;
  94
  95         if (!count)
  96                 return 0;
  97         if (!is_vmalloc_or_module_addr(dest))
  98                 return memcpy_real(dest, src, count);
  99         do {
 100                 size = min(count, PAGE_SIZE - (__pa(dest) & ~PAGE_MASK));
 101                 if (memcpy_real(load_real_addr(dest), src, size))
 102                         return -EFAULT;
 103                 count -= size;
 104                 dest += size;
 105                 src += size;
 106         } while (count);
 107         return 0;
 108 }
 109
 110 /*
 111  * Pointer to ELF header in new kernel
 112  */
 113 static void *elfcorehdr_newmem;
 114
 115 /*
 116  * Copy one page from zfcpdump "oldmem"
 117  *
 118  * For pages below HSA size memory from the HSA is copied. Otherwise
 119  * real memory copy is used.
 120  */
 121 static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
 122                                          unsigned long src, int userbuf)
 123 {
 124         int rc;
 125
 126         if (src < sclp.hsa_size) {
 127                 rc = memcpy_hsa(buf, src, csize, userbuf);
 128         } else {
 129                 if (userbuf)
 130                         rc = copy_to_user_real((void __force __user *) buf,
 131                                                (void *) src, csize);
 132                 else
 133                         rc = memcpy_real(buf, (void *) src, csize);
 134         }
 135         return rc ? rc : csize;
 136 }
 137
 138 /*
 139  * Copy one page from kdump "oldmem"
 140  *
 141  * For the kdump reserved memory this functions performs a swap operation:
 142  *  - [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE] is mapped to [0 - OLDMEM_SIZE].
 143  *  - [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
 144  */
 145 static ssize_t copy_oldmem_page_kdump(char *buf, size_t csize,
 146                                       unsigned long src, int userbuf)
 147
 148 {
 149         int rc;
 150
 151         if (src < OLDMEM_SIZE)
 152                 src += OLDMEM_BASE;
 153         else if (src > OLDMEM_BASE &&
 154                  src < OLDMEM_BASE + OLDMEM_SIZE)
 155                 src -= OLDMEM_BASE;
 156         if (userbuf)
 157                 rc = copy_to_user_real((void __force __user *) buf,
 158                                        (void *) src, csize);
 159         else
 160                 rc = copy_from_realmem(buf, (void *) src, csize);
 161         return (rc == 0) ? rc : csize;
 162 }
 163
 164 /*
 165  * Copy one page from "oldmem"
 166  */
 167 ssize_t copy_oldmem_page(unsigned long pfn, char *buf, size_t csize,
 168                          unsigned long offset, int userbuf)
 169 {
 170         unsigned long src;
 171
 172         if (!csize)
 173                 return 0;
 174         src = (pfn << PAGE_SHIFT) + offset;
 175         if (OLDMEM_BASE)
 176                 return copy_oldmem_page_kdump(buf, csize, src, userbuf);
 177         else
 178                 return copy_oldmem_page_zfcpdump(buf, csize, src, userbuf);
 179 }
 180
 181 /*
 182  * Remap "oldmem" for kdump
 183  *
 184  * For the kdump reserved memory this functions performs a swap operation:
 185  * [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
 186  */
 187 static int remap_oldmem_pfn_range_kdump(struct vm_area_struct *vma,
 188                                         unsigned long from, unsigned long pfn,
 189                                         unsigned long size, pgprot_t prot)
 190 {
 191         unsigned long size_old;
 192         int rc;
 193
 194         if (pfn < OLDMEM_SIZE >> PAGE_SHIFT) {
 195                 size_old = min(size, OLDMEM_SIZE - (pfn << PAGE_SHIFT));
 196                 rc = remap_pfn_range(vma, from,
 197                                      pfn + (OLDMEM_BASE >> PAGE_SHIFT),
 198                                      size_old, prot);
 199                 if (rc || size == size_old)
 200                         return rc;
 201                 size -= size_old;
 202                 from += size_old;
 203                 pfn += size_old >> PAGE_SHIFT;
 204         }
 205         return remap_pfn_range(vma, from, pfn, size, prot);
 206 }
 207
 208 /*
 209  * Remap "oldmem" for zfcpdump
 210  *
 211  * We only map available memory above HSA size. Memory below HSA size
 212  * is read on demand using the copy_oldmem_page() function.
 213  */
 214 static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct *vma,
 215                                            unsigned long from,
 216                                            unsigned long pfn,
 217                                            unsigned long size, pgprot_t prot)
 218 {
 219         unsigned long hsa_end = sclp.hsa_size;
 220         unsigned long size_hsa;
 221
 222         if (pfn < hsa_end >> PAGE_SHIFT) {
 223                 size_hsa = min(size, hsa_end - (pfn << PAGE_SHIFT));
 224                 if (size == size_hsa)
 225                         return 0;
 226                 size -= size_hsa;
 227                 from += size_hsa;
 228                 pfn += size_hsa >> PAGE_SHIFT;
 229         }
 230         return remap_pfn_range(vma, from, pfn, size, prot);
 231 }
 232
 233 /*
 234  * Remap "oldmem" for kdump or zfcpdump
 235  */
 236 int remap_oldmem_pfn_range(struct vm_area_struct *vma, unsigned long from,
 237                            unsigned long pfn, unsigned long size, pgprot_t prot)
 238 {
 239         if (OLDMEM_BASE)
 240                 return remap_oldmem_pfn_range_kdump(vma, from, pfn, size, prot);
 241         else
 242                 return remap_oldmem_pfn_range_zfcpdump(vma, from, pfn, size,
 243                                                        prot);
 244 }
 245
 246 /*
 247  * Copy memory from old kernel
 248  */
 249 int copy_from_oldmem(void *dest, void *src, size_t count)
 250 {
 251         unsigned long copied = 0;
 252         int rc;
 253
 254         if (OLDMEM_BASE) {
 255                 if ((unsigned long) src < OLDMEM_SIZE) {
 256                         copied = min(count, OLDMEM_SIZE - (unsigned long) src);
 257                         rc = copy_from_realmem(dest, src + OLDMEM_BASE, copied);
 258                         if (rc)
 259                                 return rc;
 260                 }
 261         } else {
 262                 unsigned long hsa_end = sclp.hsa_size;
 263                 if ((unsigned long) src < hsa_end) {
 264                         copied = min(count, hsa_end - (unsigned long) src);
 265                         rc = memcpy_hsa(dest, (unsigned long) src, copied, 0);
 266                         if (rc)
 267                                 return rc;
 268                 }
 269         }
 270         return copy_from_realmem(dest + copied, src + copied, count - copied);
 271 }
 272
 273 /*
 274  * Alloc memory and panic in case of ENOMEM
 275  */
 276 static void *kzalloc_panic(int len)
 277 {
 278         void *rc;
 279
 280         rc = kzalloc(len, GFP_KERNEL);
 281         if (!rc)
 282                 panic("s390 kdump kzalloc (%d) failed", len);
 283         return rc;
 284 }
 285
 286 /*
 287  * Initialize ELF note
 288  */
 289 static void *nt_init(void *buf, Elf64_Word type, void *desc, int d_len,
 290                      const char *name)
 291 {
 292         Elf64_Nhdr *note;
 293         u64 len;
 294
 295         note = (Elf64_Nhdr *)buf;
 296         note->n_namesz = strlen(name) + 1;
 297         note->n_descsz = d_len;
 298         note->n_type = type;
 299         len = sizeof(Elf64_Nhdr);
 300
 301         memcpy(buf + len, name, note->n_namesz);
 302         len = roundup(len + note->n_namesz, 4);
 303
 304         memcpy(buf + len, desc, note->n_descsz);
 305         len = roundup(len + note->n_descsz, 4);
 306
 307         return PTR_ADD(buf, len);
 308 }
 309
 310 /*
 311  * Initialize prstatus note
 312  */
 313 static void *nt_prstatus(void *ptr, struct save_area *sa)
 314 {
 315         struct elf_prstatus nt_prstatus;
 316         static int cpu_nr = 1;
 317
 318         memset(&nt_prstatus, 0, sizeof(nt_prstatus));
 319         memcpy(&nt_prstatus.pr_reg.gprs, sa->gp_regs, sizeof(sa->gp_regs));
 320         memcpy(&nt_prstatus.pr_reg.psw, sa->psw, sizeof(sa->psw));
 321         memcpy(&nt_prstatus.pr_reg.acrs, sa->acc_regs, sizeof(sa->acc_regs));
 322         nt_prstatus.pr_pid = cpu_nr;
 323         cpu_nr++;
 324
 325         return nt_init(ptr, NT_PRSTATUS, &nt_prstatus, sizeof(nt_prstatus),
 326                          "CORE");
 327 }
 328
 329 /*
 330  * Initialize fpregset (floating point) note
 331  */
 332 static void *nt_fpregset(void *ptr, struct save_area *sa)
 333 {
 334         elf_fpregset_t nt_fpregset;
 335
 336         memset(&nt_fpregset, 0, sizeof(nt_fpregset));
 337         memcpy(&nt_fpregset.fpc, &sa->fp_ctrl_reg, sizeof(sa->fp_ctrl_reg));
 338         memcpy(&nt_fpregset.fprs, &sa->fp_regs, sizeof(sa->fp_regs));
 339
 340         return nt_init(ptr, NT_PRFPREG, &nt_fpregset, sizeof(nt_fpregset),
 341                        "CORE");
 342 }
 343
 344 /*
 345  * Initialize timer note
 346  */
 347 static void *nt_s390_timer(void *ptr, struct save_area *sa)
 348 {
 349         return nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer),
 350                          KEXEC_CORE_NOTE_NAME);
 351 }
 352
 353 /*
 354  * Initialize TOD clock comparator note
 355  */
 356 static void *nt_s390_tod_cmp(void *ptr, struct save_area *sa)
 357 {
 358         return nt_init(ptr, NT_S390_TODCMP, &sa->clk_cmp,
 359                        sizeof(sa->clk_cmp), KEXEC_CORE_NOTE_NAME);
 360 }
 361
 362 /*
 363  * Initialize TOD programmable register note
 364  */
 365 static void *nt_s390_tod_preg(void *ptr, struct save_area *sa)
 366 {
 367         return nt_init(ptr, NT_S390_TODPREG, &sa->tod_reg,
 368                        sizeof(sa->tod_reg), KEXEC_CORE_NOTE_NAME);
 369 }
 370
 371 /*
 372  * Initialize control register note
 373  */
 374 static void *nt_s390_ctrs(void *ptr, struct save_area *sa)
 375 {
 376         return nt_init(ptr, NT_S390_CTRS, &sa->ctrl_regs,
 377                        sizeof(sa->ctrl_regs), KEXEC_CORE_NOTE_NAME);
 378 }
 379
 380 /*
 381  * Initialize prefix register note
 382  */
 383 static void *nt_s390_prefix(void *ptr, struct save_area *sa)
 384 {
 385         return nt_init(ptr, NT_S390_PREFIX, &sa->pref_reg,
 386                          sizeof(sa->pref_reg), KEXEC_CORE_NOTE_NAME);
 387 }
 388
 389 /*
 390  * Initialize vxrs high note (full 128 bit VX registers 16-31)
 391  */
 392 static void *nt_s390_vx_high(void *ptr, __vector128 *vx_regs)
 393 {
 394         return nt_init(ptr, NT_S390_VXRS_HIGH, &vx_regs[16],
 395                        16 * sizeof(__vector128), KEXEC_CORE_NOTE_NAME);
 396 }
 397
 398 /*
 399  * Initialize vxrs low note (lower halves of VX registers 0-15)
 400  */
 401 static void *nt_s390_vx_low(void *ptr, __vector128 *vx_regs)
 402 {
 403         Elf64_Nhdr *note;
 404         u64 len;
 405         int i;
 406
 407         note = (Elf64_Nhdr *)ptr;
 408         note->n_namesz = strlen(KEXEC_CORE_NOTE_NAME) + 1;
 409         note->n_descsz = 16 * 8;
 410         note->n_type = NT_S390_VXRS_LOW;
 411         len = sizeof(Elf64_Nhdr);
 412
 413         memcpy(ptr + len, KEXEC_CORE_NOTE_NAME, note->n_namesz);
 414         len = roundup(len + note->n_namesz, 4);
 415
 416         ptr += len;
 417         /* Copy lower halves of SIMD registers 0-15 */
 418         for (i = 0; i < 16; i++) {
 419                 memcpy(ptr, &vx_regs[i], 8);
 420                 ptr += 8;
 421         }
 422         return ptr;
 423 }
 424
 425 /*
 426  * Fill ELF notes for one CPU with save area registers
 427  */
 428 void *fill_cpu_elf_notes(void *ptr, struct save_area *sa, __vector128 *vx_regs)
 429 {
 430         ptr = nt_prstatus(ptr, sa);
 431         ptr = nt_fpregset(ptr, sa);
 432         ptr = nt_s390_timer(ptr, sa);
 433         ptr = nt_s390_tod_cmp(ptr, sa);
 434         ptr = nt_s390_tod_preg(ptr, sa);
 435         ptr = nt_s390_ctrs(ptr, sa);
 436         ptr = nt_s390_prefix(ptr, sa);
 437         if (MACHINE_HAS_VX && vx_regs) {
 438                 ptr = nt_s390_vx_low(ptr, vx_regs);
 439                 ptr = nt_s390_vx_high(ptr, vx_regs);
 440         }
 441         return ptr;
 442 }
 443
 444 /*
 445  * Initialize prpsinfo note (new kernel)
 446  */
 447 static void *nt_prpsinfo(void *ptr)
 448 {
 449         struct elf_prpsinfo prpsinfo;
 450
 451         memset(&prpsinfo, 0, sizeof(prpsinfo));
 452         prpsinfo.pr_sname = 'R';
 453         strcpy(prpsinfo.pr_fname, "vmlinux");
 454         return nt_init(ptr, NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo),
 455                        KEXEC_CORE_NOTE_NAME);
 456 }
 457
 458 /*
 459  * Get vmcoreinfo using lowcore->vmcore_info (new kernel)
 460  */
 461 static void *get_vmcoreinfo_old(unsigned long *size)
 462 {
 463         char nt_name[11], *vmcoreinfo;
 464         Elf64_Nhdr note;
 465         void *addr;
 466
 467         if (copy_from_oldmem(&addr, &S390_lowcore.vmcore_info, sizeof(addr)))
 468                 return NULL;
 469         memset(nt_name, 0, sizeof(nt_name));
 470         if (copy_from_oldmem(&note, addr, sizeof(note)))
 471                 return NULL;
 472         if (copy_from_oldmem(nt_name, addr + sizeof(note), sizeof(nt_name) - 1))
 473                 return NULL;
 474         if (strcmp(nt_name, "VMCOREINFO") != 0)
 475                 return NULL;
 476         vmcoreinfo = kzalloc_panic(note.n_descsz);
 477         if (copy_from_oldmem(vmcoreinfo, addr + 24, note.n_descsz))
 478                 return NULL;
 479         *size = note.n_descsz;
 480         return vmcoreinfo;
 481 }
 482
 483 /*
 484  * Initialize vmcoreinfo note (new kernel)
 485  */
 486 static void *nt_vmcoreinfo(void *ptr)
 487 {
 488         unsigned long size;
 489         void *vmcoreinfo;
 490
 491         vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
 492         if (!vmcoreinfo)
 493                 vmcoreinfo = get_vmcoreinfo_old(&size);
 494         if (!vmcoreinfo)
 495                 return ptr;
 496         return nt_init(ptr, 0, vmcoreinfo, size, "VMCOREINFO");
 497 }
 498
 499 /*
 500  * Initialize ELF header (new kernel)
 501  */
 502 static void *ehdr_init(Elf64_Ehdr *ehdr, int mem_chunk_cnt)
 503 {
 504         memset(ehdr, 0, sizeof(*ehdr));
 505         memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
 506         ehdr->e_ident[EI_CLASS] = ELFCLASS64;
 507         ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
 508         ehdr->e_ident[EI_VERSION] = EV_CURRENT;
 509         memset(ehdr->e_ident + EI_PAD, 0, EI_NIDENT - EI_PAD);
 510         ehdr->e_type = ET_CORE;
 511         ehdr->e_machine = EM_S390;
 512         ehdr->e_version = EV_CURRENT;
 513         ehdr->e_phoff = sizeof(Elf64_Ehdr);
 514         ehdr->e_ehsize = sizeof(Elf64_Ehdr);
 515         ehdr->e_phentsize = sizeof(Elf64_Phdr);
 516         ehdr->e_phnum = mem_chunk_cnt + 1;
 517         return ehdr + 1;
 518 }
 519
 520 /*
 521  * Return CPU count for ELF header (new kernel)
 522  */
 523 static int get_cpu_cnt(void)
 524 {
 525         int i, cpus = 0;
 526
 527         for (i = 0; i < dump_save_areas.count; i++) {
 528                 if (dump_save_areas.areas[i]->sa.pref_reg == 0)
 529                         continue;
 530                 cpus++;
 531         }
 532         return cpus;
 533 }
 534
 535 /*
 536  * Return memory chunk count for ELF header (new kernel)
 537  */
 538 static int get_mem_chunk_cnt(void)
 539 {
 540         int cnt = 0;
 541         u64 idx;
 542
 543         for_each_dump_mem_range(idx, NUMA_NO_NODE, NULL, NULL, NULL)
 544                 cnt++;
 545         return cnt;
 546 }
 547
 548 /*
 549  * Initialize ELF loads (new kernel)
 550  */
 551 static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
 552 {
 553         phys_addr_t start, end;
 554         u64 idx;
 555
 556         for_each_dump_mem_range(idx, NUMA_NO_NODE, &start, &end, NULL) {
 557                 phdr->p_filesz = end - start;
 558                 phdr->p_type = PT_LOAD;
 559                 phdr->p_offset = start;
 560                 phdr->p_vaddr = start;
 561                 phdr->p_paddr = start;
 562                 phdr->p_memsz = end - start;
 563                 phdr->p_flags = PF_R | PF_W | PF_X;
 564                 phdr->p_align = PAGE_SIZE;
 565                 phdr++;
 566         }
 567 }
 568
 569 /*
 570  * Initialize notes (new kernel)
 571  */
 572 static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
 573 {
 574         struct save_area_ext *sa_ext;
 575         void *ptr_start = ptr;
 576         int i;
 577
 578         ptr = nt_prpsinfo(ptr);
 579
 580         for (i = 0; i < dump_save_areas.count; i++) {
 581                 sa_ext = dump_save_areas.areas[i];
 582                 if (sa_ext->sa.pref_reg == 0)
 583                         continue;
 584                 ptr = fill_cpu_elf_notes(ptr, &sa_ext->sa, sa_ext->vx_regs);
 585         }
 586         ptr = nt_vmcoreinfo(ptr);
 587         memset(phdr, 0, sizeof(*phdr));
 588         phdr->p_type = PT_NOTE;
 589         phdr->p_offset = notes_offset;
 590         phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
 591         phdr->p_memsz = phdr->p_filesz;
 592         return ptr;
 593 }
 594
 595 /*
 596  * Create ELF core header (new kernel)
 597  */
 598 int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
 599 {
 600         Elf64_Phdr *phdr_notes, *phdr_loads;
 601         int mem_chunk_cnt;
 602         void *ptr, *hdr;
 603         u32 alloc_size;
 604         u64 hdr_off;
 605
 606         /* If we are not in kdump or zfcpdump mode return */
 607         if (!OLDMEM_BASE && ipl_info.type != IPL_TYPE_FCP_DUMP)
 608                 return 0;
 609         /* If elfcorehdr= has been passed via cmdline, we use that one */
 610         if (elfcorehdr_addr != ELFCORE_ADDR_MAX)
 611                 return 0;
 612         /* If we cannot get HSA size for zfcpdump return error */
 613         if (ipl_info.type == IPL_TYPE_FCP_DUMP && !sclp.hsa_size)
 614                 return -ENODEV;
 615
 616         /* For kdump, exclude previous crashkernel memory */
 617         if (OLDMEM_BASE) {
 618                 oldmem_region.base = OLDMEM_BASE;
 619                 oldmem_region.size = OLDMEM_SIZE;
 620                 oldmem_type.total_size = OLDMEM_SIZE;
 621         }
 622
 623         mem_chunk_cnt = get_mem_chunk_cnt();
 624
 625         alloc_size = 0x1000 + get_cpu_cnt() * 0x4a0 +
 626                 mem_chunk_cnt * sizeof(Elf64_Phdr);
 627         hdr = kzalloc_panic(alloc_size);
 628         /* Init elf header */
 629         ptr = ehdr_init(hdr, mem_chunk_cnt);
 630         /* Init program headers */
 631         phdr_notes = ptr;
 632         ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr));
 633         phdr_loads = ptr;
 634         ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
 635         /* Init notes */
 636         hdr_off = PTR_DIFF(ptr, hdr);
 637         ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
 638         /* Init loads */
 639         hdr_off = PTR_DIFF(ptr, hdr);
 640         loads_init(phdr_loads, hdr_off);
 641         *addr = (unsigned long long) hdr;
 642         elfcorehdr_newmem = hdr;
 643         *size = (unsigned long long) hdr_off;
 644         BUG_ON(elfcorehdr_size > alloc_size);
 645         return 0;
 646 }
 647
 648 /*
 649  * Free ELF core header (new kernel)
 650  */
 651 void elfcorehdr_free(unsigned long long addr)
 652 {
 653         if (!elfcorehdr_newmem)
 654                 return;
 655         kfree((void *)(unsigned long)addr);
 656 }
 657
 658 /*
 659  * Read from ELF header
 660  */
 661 ssize_t elfcorehdr_read(char *buf, size_t count, u64 *ppos)
 662 {
 663         void *src = (void *)(unsigned long)*ppos;
 664
 665         src = elfcorehdr_newmem ? src : src - OLDMEM_BASE;
 666         memcpy(buf, src, count);
 667         *ppos += count;
 668         return count;
 669 }
 670
 671 /*
 672  * Read from ELF notes data
 673  */
 674 ssize_t elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos)
 675 {
 676         void *src = (void *)(unsigned long)*ppos;
 677         int rc;
 678
 679         if (elfcorehdr_newmem) {
 680                 memcpy(buf, src, count);
 681         } else {
 682                 rc = copy_from_oldmem(buf, src, count);
 683                 if (rc)
 684                         return rc;
 685         }
 686         *ppos += count;
 687         return count;
 688 }