~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/crash_dump.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp