2 * fs/proc/vmcore.c Interface for accessing the crash
3 * dump from the system's previous life.
4 * Heavily borrowed from fs/proc/kcore.c
5 * Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
6 * Copyright (C) IBM Corporation, 2004. All rights reserved
11 #include <linux/kcore.h>
12 #include <linux/user.h>
13 #include <linux/elf.h>
14 #include <linux/elfcore.h>
15 #include <linux/export.h>
16 #include <linux/slab.h>
17 #include <linux/highmem.h>
18 #include <linux/printk.h>
19 #include <linux/bootmem.h>
20 #include <linux/init.h>
21 #include <linux/crash_dump.h>
22 #include <linux/list.h>
23 #include <linux/vmalloc.h>
24 #include <linux/pagemap.h>
25 #include <asm/uaccess.h>
29 /* List representing chunks of contiguous memory areas and their offsets in
32 static LIST_HEAD(vmcore_list
);
34 /* Stores the pointer to the buffer containing kernel elf core headers. */
35 static char *elfcorebuf
;
36 static size_t elfcorebuf_sz
;
37 static size_t elfcorebuf_sz_orig
;
39 static char *elfnotes_buf
;
40 static size_t elfnotes_sz
;
42 /* Total size of vmcore file. */
43 static u64 vmcore_size
;
45 static struct proc_dir_entry
*proc_vmcore
= NULL
;
48 * Returns > 0 for RAM pages, 0 for non-RAM pages, < 0 on error
49 * The called function has to take care of module refcounting.
51 static int (*oldmem_pfn_is_ram
)(unsigned long pfn
);
53 int register_oldmem_pfn_is_ram(int (*fn
)(unsigned long pfn
))
55 if (oldmem_pfn_is_ram
)
57 oldmem_pfn_is_ram
= fn
;
60 EXPORT_SYMBOL_GPL(register_oldmem_pfn_is_ram
);
62 void unregister_oldmem_pfn_is_ram(void)
64 oldmem_pfn_is_ram
= NULL
;
67 EXPORT_SYMBOL_GPL(unregister_oldmem_pfn_is_ram
);
69 static int pfn_is_ram(unsigned long pfn
)
71 int (*fn
)(unsigned long pfn
);
72 /* pfn is ram unless fn() checks pagetype */
76 * Ask hypervisor if the pfn is really ram.
77 * A ballooned page contains no data and reading from such a page
78 * will cause high load in the hypervisor.
80 fn
= oldmem_pfn_is_ram
;
87 /* Reads a page from the oldmem device from given offset. */
88 static ssize_t
read_from_oldmem(char *buf
, size_t count
,
89 u64
*ppos
, int userbuf
)
91 unsigned long pfn
, offset
;
93 ssize_t read
= 0, tmp
;
98 offset
= (unsigned long)(*ppos
% PAGE_SIZE
);
99 pfn
= (unsigned long)(*ppos
/ PAGE_SIZE
);
102 if (count
> (PAGE_SIZE
- offset
))
103 nr_bytes
= PAGE_SIZE
- offset
;
107 /* If pfn is not ram, return zeros for sparse dump files */
108 if (pfn_is_ram(pfn
) == 0)
109 memset(buf
, 0, nr_bytes
);
111 tmp
= copy_oldmem_page(pfn
, buf
, nr_bytes
,
128 * Architectures may override this function to allocate ELF header in 2nd kernel
130 int __weak
elfcorehdr_alloc(unsigned long long *addr
, unsigned long long *size
)
136 * Architectures may override this function to free header
138 void __weak
elfcorehdr_free(unsigned long long addr
)
142 * Architectures may override this function to read from ELF header
144 ssize_t __weak
elfcorehdr_read(char *buf
, size_t count
, u64
*ppos
)
146 return read_from_oldmem(buf
, count
, ppos
, 0);
150 * Architectures may override this function to read from notes sections
152 ssize_t __weak
elfcorehdr_read_notes(char *buf
, size_t count
, u64
*ppos
)
154 return read_from_oldmem(buf
, count
, ppos
, 0);
158 * Architectures may override this function to map oldmem
160 int __weak
remap_oldmem_pfn_range(struct vm_area_struct
*vma
,
161 unsigned long from
, unsigned long pfn
,
162 unsigned long size
, pgprot_t prot
)
164 return remap_pfn_range(vma
, from
, pfn
, size
, prot
);
168 * Copy to either kernel or user space
170 static int copy_to(void *target
, void *src
, size_t size
, int userbuf
)
173 if (copy_to_user((char __user
*) target
, src
, size
))
176 memcpy(target
, src
, size
);
181 /* Read from the ELF header and then the crash dump. On error, negative value is
182 * returned otherwise number of bytes read are returned.
184 static ssize_t
__read_vmcore(char *buffer
, size_t buflen
, loff_t
*fpos
,
187 ssize_t acc
= 0, tmp
;
190 struct vmcore
*m
= NULL
;
192 if (buflen
== 0 || *fpos
>= vmcore_size
)
195 /* trim buflen to not go beyond EOF */
196 if (buflen
> vmcore_size
- *fpos
)
197 buflen
= vmcore_size
- *fpos
;
199 /* Read ELF core header */
200 if (*fpos
< elfcorebuf_sz
) {
201 tsz
= min(elfcorebuf_sz
- (size_t)*fpos
, buflen
);
202 if (copy_to(buffer
, elfcorebuf
+ *fpos
, tsz
, userbuf
))
209 /* leave now if filled buffer already */
214 /* Read Elf note segment */
215 if (*fpos
< elfcorebuf_sz
+ elfnotes_sz
) {
218 tsz
= min(elfcorebuf_sz
+ elfnotes_sz
- (size_t)*fpos
, buflen
);
219 kaddr
= elfnotes_buf
+ *fpos
- elfcorebuf_sz
;
220 if (copy_to(buffer
, kaddr
, tsz
, userbuf
))
227 /* leave now if filled buffer already */
232 list_for_each_entry(m
, &vmcore_list
, list
) {
233 if (*fpos
< m
->offset
+ m
->size
) {
234 tsz
= min_t(size_t, m
->offset
+ m
->size
- *fpos
, buflen
);
235 start
= m
->paddr
+ *fpos
- m
->offset
;
236 tmp
= read_from_oldmem(buffer
, tsz
, &start
, userbuf
);
244 /* leave now if filled buffer already */
253 static ssize_t
read_vmcore(struct file
*file
, char __user
*buffer
,
254 size_t buflen
, loff_t
*fpos
)
256 return __read_vmcore((__force
char *) buffer
, buflen
, fpos
, 1);
260 * The vmcore fault handler uses the page cache and fills data using the
261 * standard __vmcore_read() function.
263 * On s390 the fault handler is used for memory regions that can't be mapped
264 * directly with remap_pfn_range().
266 static int mmap_vmcore_fault(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
269 struct address_space
*mapping
= vma
->vm_file
->f_mapping
;
270 pgoff_t index
= vmf
->pgoff
;
276 page
= find_or_create_page(mapping
, index
, GFP_KERNEL
);
279 if (!PageUptodate(page
)) {
280 offset
= (loff_t
) index
<< PAGE_CACHE_SHIFT
;
281 buf
= __va((page_to_pfn(page
) << PAGE_SHIFT
));
282 rc
= __read_vmcore(buf
, PAGE_SIZE
, &offset
, 0);
285 page_cache_release(page
);
286 return (rc
== -ENOMEM
) ? VM_FAULT_OOM
: VM_FAULT_SIGBUS
;
288 SetPageUptodate(page
);
294 return VM_FAULT_SIGBUS
;
298 static const struct vm_operations_struct vmcore_mmap_ops
= {
299 .fault
= mmap_vmcore_fault
,
303 * alloc_elfnotes_buf - allocate buffer for ELF note segment in
306 * @notes_sz: size of buffer
308 * If CONFIG_MMU is defined, use vmalloc_user() to allow users to mmap
309 * the buffer to user-space by means of remap_vmalloc_range().
311 * If CONFIG_MMU is not defined, use vzalloc() since mmap_vmcore() is
312 * disabled and there's no need to allow users to mmap the buffer.
314 static inline char *alloc_elfnotes_buf(size_t notes_sz
)
317 return vmalloc_user(notes_sz
);
319 return vzalloc(notes_sz
);
324 * Disable mmap_vmcore() if CONFIG_MMU is not defined. MMU is
325 * essential for mmap_vmcore() in order to map physically
326 * non-contiguous objects (ELF header, ELF note segment and memory
327 * regions in the 1st kernel pointed to by PT_LOAD entries) into
328 * virtually contiguous user-space in ELF layout.
331 static int mmap_vmcore(struct file
*file
, struct vm_area_struct
*vma
)
333 size_t size
= vma
->vm_end
- vma
->vm_start
;
334 u64 start
, end
, len
, tsz
;
337 start
= (u64
)vma
->vm_pgoff
<< PAGE_SHIFT
;
340 if (size
> vmcore_size
|| end
> vmcore_size
)
343 if (vma
->vm_flags
& (VM_WRITE
| VM_EXEC
))
346 vma
->vm_flags
&= ~(VM_MAYWRITE
| VM_MAYEXEC
);
347 vma
->vm_flags
|= VM_MIXEDMAP
;
348 vma
->vm_ops
= &vmcore_mmap_ops
;
352 if (start
< elfcorebuf_sz
) {
355 tsz
= min(elfcorebuf_sz
- (size_t)start
, size
);
356 pfn
= __pa(elfcorebuf
+ start
) >> PAGE_SHIFT
;
357 if (remap_pfn_range(vma
, vma
->vm_start
, pfn
, tsz
,
368 if (start
< elfcorebuf_sz
+ elfnotes_sz
) {
371 tsz
= min(elfcorebuf_sz
+ elfnotes_sz
- (size_t)start
, size
);
372 kaddr
= elfnotes_buf
+ start
- elfcorebuf_sz
;
373 if (remap_vmalloc_range_partial(vma
, vma
->vm_start
+ len
,
384 list_for_each_entry(m
, &vmcore_list
, list
) {
385 if (start
< m
->offset
+ m
->size
) {
388 tsz
= min_t(size_t, m
->offset
+ m
->size
- start
, size
);
389 paddr
= m
->paddr
+ start
- m
->offset
;
390 if (remap_oldmem_pfn_range(vma
, vma
->vm_start
+ len
,
391 paddr
>> PAGE_SHIFT
, tsz
,
405 do_munmap(vma
->vm_mm
, vma
->vm_start
, len
);
409 static int mmap_vmcore(struct file
*file
, struct vm_area_struct
*vma
)
415 static const struct file_operations proc_vmcore_operations
= {
417 .llseek
= default_llseek
,
421 static struct vmcore
* __init
get_new_element(void)
423 return kzalloc(sizeof(struct vmcore
), GFP_KERNEL
);
426 static u64 __init
get_vmcore_size(size_t elfsz
, size_t elfnotesegsz
,
427 struct list_head
*vc_list
)
432 size
= elfsz
+ elfnotesegsz
;
433 list_for_each_entry(m
, vc_list
, list
) {
440 * update_note_header_size_elf64 - update p_memsz member of each PT_NOTE entry
442 * @ehdr_ptr: ELF header
444 * This function updates p_memsz member of each PT_NOTE entry in the
445 * program header table pointed to by @ehdr_ptr to real size of ELF
448 static int __init
update_note_header_size_elf64(const Elf64_Ehdr
*ehdr_ptr
)
451 Elf64_Phdr
*phdr_ptr
;
452 Elf64_Nhdr
*nhdr_ptr
;
454 phdr_ptr
= (Elf64_Phdr
*)(ehdr_ptr
+ 1);
455 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
457 u64 offset
, max_sz
, sz
, real_sz
= 0;
458 if (phdr_ptr
->p_type
!= PT_NOTE
)
460 max_sz
= phdr_ptr
->p_memsz
;
461 offset
= phdr_ptr
->p_offset
;
462 notes_section
= kmalloc(max_sz
, GFP_KERNEL
);
465 rc
= elfcorehdr_read_notes(notes_section
, max_sz
, &offset
);
467 kfree(notes_section
);
470 nhdr_ptr
= notes_section
;
471 while (nhdr_ptr
->n_namesz
!= 0) {
472 sz
= sizeof(Elf64_Nhdr
) +
473 ((nhdr_ptr
->n_namesz
+ 3) & ~3) +
474 ((nhdr_ptr
->n_descsz
+ 3) & ~3);
475 if ((real_sz
+ sz
) > max_sz
) {
476 pr_warn("Warning: Exceeded p_memsz, dropping PT_NOTE entry n_namesz=0x%x, n_descsz=0x%x\n",
477 nhdr_ptr
->n_namesz
, nhdr_ptr
->n_descsz
);
481 nhdr_ptr
= (Elf64_Nhdr
*)((char*)nhdr_ptr
+ sz
);
483 kfree(notes_section
);
484 phdr_ptr
->p_memsz
= real_sz
;
486 pr_warn("Warning: Zero PT_NOTE entries found\n");
495 * get_note_number_and_size_elf64 - get the number of PT_NOTE program
496 * headers and sum of real size of their ELF note segment headers and
499 * @ehdr_ptr: ELF header
500 * @nr_ptnote: buffer for the number of PT_NOTE program headers
501 * @sz_ptnote: buffer for size of unique PT_NOTE program header
503 * This function is used to merge multiple PT_NOTE program headers
504 * into a unique single one. The resulting unique entry will have
505 * @sz_ptnote in its phdr->p_mem.
507 * It is assumed that program headers with PT_NOTE type pointed to by
508 * @ehdr_ptr has already been updated by update_note_header_size_elf64
509 * and each of PT_NOTE program headers has actual ELF note segment
510 * size in its p_memsz member.
512 static int __init
get_note_number_and_size_elf64(const Elf64_Ehdr
*ehdr_ptr
,
513 int *nr_ptnote
, u64
*sz_ptnote
)
516 Elf64_Phdr
*phdr_ptr
;
518 *nr_ptnote
= *sz_ptnote
= 0;
520 phdr_ptr
= (Elf64_Phdr
*)(ehdr_ptr
+ 1);
521 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
522 if (phdr_ptr
->p_type
!= PT_NOTE
)
525 *sz_ptnote
+= phdr_ptr
->p_memsz
;
532 * copy_notes_elf64 - copy ELF note segments in a given buffer
534 * @ehdr_ptr: ELF header
535 * @notes_buf: buffer into which ELF note segments are copied
537 * This function is used to copy ELF note segment in the 1st kernel
538 * into the buffer @notes_buf in the 2nd kernel. It is assumed that
539 * size of the buffer @notes_buf is equal to or larger than sum of the
540 * real ELF note segment headers and data.
542 * It is assumed that program headers with PT_NOTE type pointed to by
543 * @ehdr_ptr has already been updated by update_note_header_size_elf64
544 * and each of PT_NOTE program headers has actual ELF note segment
545 * size in its p_memsz member.
547 static int __init
copy_notes_elf64(const Elf64_Ehdr
*ehdr_ptr
, char *notes_buf
)
550 Elf64_Phdr
*phdr_ptr
;
552 phdr_ptr
= (Elf64_Phdr
*)(ehdr_ptr
+ 1);
554 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
556 if (phdr_ptr
->p_type
!= PT_NOTE
)
558 offset
= phdr_ptr
->p_offset
;
559 rc
= elfcorehdr_read_notes(notes_buf
, phdr_ptr
->p_memsz
,
563 notes_buf
+= phdr_ptr
->p_memsz
;
569 /* Merges all the PT_NOTE headers into one. */
570 static int __init
merge_note_headers_elf64(char *elfptr
, size_t *elfsz
,
571 char **notes_buf
, size_t *notes_sz
)
573 int i
, nr_ptnote
=0, rc
=0;
575 Elf64_Ehdr
*ehdr_ptr
;
577 u64 phdr_sz
= 0, note_off
;
579 ehdr_ptr
= (Elf64_Ehdr
*)elfptr
;
581 rc
= update_note_header_size_elf64(ehdr_ptr
);
585 rc
= get_note_number_and_size_elf64(ehdr_ptr
, &nr_ptnote
, &phdr_sz
);
589 *notes_sz
= roundup(phdr_sz
, PAGE_SIZE
);
590 *notes_buf
= alloc_elfnotes_buf(*notes_sz
);
594 rc
= copy_notes_elf64(ehdr_ptr
, *notes_buf
);
598 /* Prepare merged PT_NOTE program header. */
599 phdr
.p_type
= PT_NOTE
;
601 note_off
= sizeof(Elf64_Ehdr
) +
602 (ehdr_ptr
->e_phnum
- nr_ptnote
+1) * sizeof(Elf64_Phdr
);
603 phdr
.p_offset
= roundup(note_off
, PAGE_SIZE
);
604 phdr
.p_vaddr
= phdr
.p_paddr
= 0;
605 phdr
.p_filesz
= phdr
.p_memsz
= phdr_sz
;
608 /* Add merged PT_NOTE program header*/
609 tmp
= elfptr
+ sizeof(Elf64_Ehdr
);
610 memcpy(tmp
, &phdr
, sizeof(phdr
));
613 /* Remove unwanted PT_NOTE program headers. */
614 i
= (nr_ptnote
- 1) * sizeof(Elf64_Phdr
);
616 memmove(tmp
, tmp
+i
, ((*elfsz
)-sizeof(Elf64_Ehdr
)-sizeof(Elf64_Phdr
)));
617 memset(elfptr
+ *elfsz
, 0, i
);
618 *elfsz
= roundup(*elfsz
, PAGE_SIZE
);
620 /* Modify e_phnum to reflect merged headers. */
621 ehdr_ptr
->e_phnum
= ehdr_ptr
->e_phnum
- nr_ptnote
+ 1;
627 * update_note_header_size_elf32 - update p_memsz member of each PT_NOTE entry
629 * @ehdr_ptr: ELF header
631 * This function updates p_memsz member of each PT_NOTE entry in the
632 * program header table pointed to by @ehdr_ptr to real size of ELF
635 static int __init
update_note_header_size_elf32(const Elf32_Ehdr
*ehdr_ptr
)
638 Elf32_Phdr
*phdr_ptr
;
639 Elf32_Nhdr
*nhdr_ptr
;
641 phdr_ptr
= (Elf32_Phdr
*)(ehdr_ptr
+ 1);
642 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
644 u64 offset
, max_sz
, sz
, real_sz
= 0;
645 if (phdr_ptr
->p_type
!= PT_NOTE
)
647 max_sz
= phdr_ptr
->p_memsz
;
648 offset
= phdr_ptr
->p_offset
;
649 notes_section
= kmalloc(max_sz
, GFP_KERNEL
);
652 rc
= elfcorehdr_read_notes(notes_section
, max_sz
, &offset
);
654 kfree(notes_section
);
657 nhdr_ptr
= notes_section
;
658 while (nhdr_ptr
->n_namesz
!= 0) {
659 sz
= sizeof(Elf32_Nhdr
) +
660 ((nhdr_ptr
->n_namesz
+ 3) & ~3) +
661 ((nhdr_ptr
->n_descsz
+ 3) & ~3);
662 if ((real_sz
+ sz
) > max_sz
) {
663 pr_warn("Warning: Exceeded p_memsz, dropping PT_NOTE entry n_namesz=0x%x, n_descsz=0x%x\n",
664 nhdr_ptr
->n_namesz
, nhdr_ptr
->n_descsz
);
668 nhdr_ptr
= (Elf32_Nhdr
*)((char*)nhdr_ptr
+ sz
);
670 kfree(notes_section
);
671 phdr_ptr
->p_memsz
= real_sz
;
673 pr_warn("Warning: Zero PT_NOTE entries found\n");
682 * get_note_number_and_size_elf32 - get the number of PT_NOTE program
683 * headers and sum of real size of their ELF note segment headers and
686 * @ehdr_ptr: ELF header
687 * @nr_ptnote: buffer for the number of PT_NOTE program headers
688 * @sz_ptnote: buffer for size of unique PT_NOTE program header
690 * This function is used to merge multiple PT_NOTE program headers
691 * into a unique single one. The resulting unique entry will have
692 * @sz_ptnote in its phdr->p_mem.
694 * It is assumed that program headers with PT_NOTE type pointed to by
695 * @ehdr_ptr has already been updated by update_note_header_size_elf32
696 * and each of PT_NOTE program headers has actual ELF note segment
697 * size in its p_memsz member.
699 static int __init
get_note_number_and_size_elf32(const Elf32_Ehdr
*ehdr_ptr
,
700 int *nr_ptnote
, u64
*sz_ptnote
)
703 Elf32_Phdr
*phdr_ptr
;
705 *nr_ptnote
= *sz_ptnote
= 0;
707 phdr_ptr
= (Elf32_Phdr
*)(ehdr_ptr
+ 1);
708 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
709 if (phdr_ptr
->p_type
!= PT_NOTE
)
712 *sz_ptnote
+= phdr_ptr
->p_memsz
;
719 * copy_notes_elf32 - copy ELF note segments in a given buffer
721 * @ehdr_ptr: ELF header
722 * @notes_buf: buffer into which ELF note segments are copied
724 * This function is used to copy ELF note segment in the 1st kernel
725 * into the buffer @notes_buf in the 2nd kernel. It is assumed that
726 * size of the buffer @notes_buf is equal to or larger than sum of the
727 * real ELF note segment headers and data.
729 * It is assumed that program headers with PT_NOTE type pointed to by
730 * @ehdr_ptr has already been updated by update_note_header_size_elf32
731 * and each of PT_NOTE program headers has actual ELF note segment
732 * size in its p_memsz member.
734 static int __init
copy_notes_elf32(const Elf32_Ehdr
*ehdr_ptr
, char *notes_buf
)
737 Elf32_Phdr
*phdr_ptr
;
739 phdr_ptr
= (Elf32_Phdr
*)(ehdr_ptr
+ 1);
741 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
743 if (phdr_ptr
->p_type
!= PT_NOTE
)
745 offset
= phdr_ptr
->p_offset
;
746 rc
= elfcorehdr_read_notes(notes_buf
, phdr_ptr
->p_memsz
,
750 notes_buf
+= phdr_ptr
->p_memsz
;
756 /* Merges all the PT_NOTE headers into one. */
757 static int __init
merge_note_headers_elf32(char *elfptr
, size_t *elfsz
,
758 char **notes_buf
, size_t *notes_sz
)
760 int i
, nr_ptnote
=0, rc
=0;
762 Elf32_Ehdr
*ehdr_ptr
;
764 u64 phdr_sz
= 0, note_off
;
766 ehdr_ptr
= (Elf32_Ehdr
*)elfptr
;
768 rc
= update_note_header_size_elf32(ehdr_ptr
);
772 rc
= get_note_number_and_size_elf32(ehdr_ptr
, &nr_ptnote
, &phdr_sz
);
776 *notes_sz
= roundup(phdr_sz
, PAGE_SIZE
);
777 *notes_buf
= alloc_elfnotes_buf(*notes_sz
);
781 rc
= copy_notes_elf32(ehdr_ptr
, *notes_buf
);
785 /* Prepare merged PT_NOTE program header. */
786 phdr
.p_type
= PT_NOTE
;
788 note_off
= sizeof(Elf32_Ehdr
) +
789 (ehdr_ptr
->e_phnum
- nr_ptnote
+1) * sizeof(Elf32_Phdr
);
790 phdr
.p_offset
= roundup(note_off
, PAGE_SIZE
);
791 phdr
.p_vaddr
= phdr
.p_paddr
= 0;
792 phdr
.p_filesz
= phdr
.p_memsz
= phdr_sz
;
795 /* Add merged PT_NOTE program header*/
796 tmp
= elfptr
+ sizeof(Elf32_Ehdr
);
797 memcpy(tmp
, &phdr
, sizeof(phdr
));
800 /* Remove unwanted PT_NOTE program headers. */
801 i
= (nr_ptnote
- 1) * sizeof(Elf32_Phdr
);
803 memmove(tmp
, tmp
+i
, ((*elfsz
)-sizeof(Elf32_Ehdr
)-sizeof(Elf32_Phdr
)));
804 memset(elfptr
+ *elfsz
, 0, i
);
805 *elfsz
= roundup(*elfsz
, PAGE_SIZE
);
807 /* Modify e_phnum to reflect merged headers. */
808 ehdr_ptr
->e_phnum
= ehdr_ptr
->e_phnum
- nr_ptnote
+ 1;
813 /* Add memory chunks represented by program headers to vmcore list. Also update
814 * the new offset fields of exported program headers. */
815 static int __init
process_ptload_program_headers_elf64(char *elfptr
,
818 struct list_head
*vc_list
)
821 Elf64_Ehdr
*ehdr_ptr
;
822 Elf64_Phdr
*phdr_ptr
;
826 ehdr_ptr
= (Elf64_Ehdr
*)elfptr
;
827 phdr_ptr
= (Elf64_Phdr
*)(elfptr
+ sizeof(Elf64_Ehdr
)); /* PT_NOTE hdr */
829 /* Skip Elf header, program headers and Elf note segment. */
830 vmcore_off
= elfsz
+ elfnotes_sz
;
832 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
833 u64 paddr
, start
, end
, size
;
835 if (phdr_ptr
->p_type
!= PT_LOAD
)
838 paddr
= phdr_ptr
->p_offset
;
839 start
= rounddown(paddr
, PAGE_SIZE
);
840 end
= roundup(paddr
+ phdr_ptr
->p_memsz
, PAGE_SIZE
);
843 /* Add this contiguous chunk of memory to vmcore list.*/
844 new = get_new_element();
849 list_add_tail(&new->list
, vc_list
);
851 /* Update the program header offset. */
852 phdr_ptr
->p_offset
= vmcore_off
+ (paddr
- start
);
853 vmcore_off
= vmcore_off
+ size
;
858 static int __init
process_ptload_program_headers_elf32(char *elfptr
,
861 struct list_head
*vc_list
)
864 Elf32_Ehdr
*ehdr_ptr
;
865 Elf32_Phdr
*phdr_ptr
;
869 ehdr_ptr
= (Elf32_Ehdr
*)elfptr
;
870 phdr_ptr
= (Elf32_Phdr
*)(elfptr
+ sizeof(Elf32_Ehdr
)); /* PT_NOTE hdr */
872 /* Skip Elf header, program headers and Elf note segment. */
873 vmcore_off
= elfsz
+ elfnotes_sz
;
875 for (i
= 0; i
< ehdr_ptr
->e_phnum
; i
++, phdr_ptr
++) {
876 u64 paddr
, start
, end
, size
;
878 if (phdr_ptr
->p_type
!= PT_LOAD
)
881 paddr
= phdr_ptr
->p_offset
;
882 start
= rounddown(paddr
, PAGE_SIZE
);
883 end
= roundup(paddr
+ phdr_ptr
->p_memsz
, PAGE_SIZE
);
886 /* Add this contiguous chunk of memory to vmcore list.*/
887 new = get_new_element();
892 list_add_tail(&new->list
, vc_list
);
894 /* Update the program header offset */
895 phdr_ptr
->p_offset
= vmcore_off
+ (paddr
- start
);
896 vmcore_off
= vmcore_off
+ size
;
901 /* Sets offset fields of vmcore elements. */
902 static void __init
set_vmcore_list_offsets(size_t elfsz
, size_t elfnotes_sz
,
903 struct list_head
*vc_list
)
908 /* Skip Elf header, program headers and Elf note segment. */
909 vmcore_off
= elfsz
+ elfnotes_sz
;
911 list_for_each_entry(m
, vc_list
, list
) {
912 m
->offset
= vmcore_off
;
913 vmcore_off
+= m
->size
;
917 static void free_elfcorebuf(void)
919 free_pages((unsigned long)elfcorebuf
, get_order(elfcorebuf_sz_orig
));
925 static int __init
parse_crash_elf64_headers(void)
931 addr
= elfcorehdr_addr
;
933 /* Read Elf header */
934 rc
= elfcorehdr_read((char *)&ehdr
, sizeof(Elf64_Ehdr
), &addr
);
938 /* Do some basic Verification. */
939 if (memcmp(ehdr
.e_ident
, ELFMAG
, SELFMAG
) != 0 ||
940 (ehdr
.e_type
!= ET_CORE
) ||
941 !vmcore_elf64_check_arch(&ehdr
) ||
942 ehdr
.e_ident
[EI_CLASS
] != ELFCLASS64
||
943 ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
||
944 ehdr
.e_version
!= EV_CURRENT
||
945 ehdr
.e_ehsize
!= sizeof(Elf64_Ehdr
) ||
946 ehdr
.e_phentsize
!= sizeof(Elf64_Phdr
) ||
948 pr_warn("Warning: Core image elf header is not sane\n");
952 /* Read in all elf headers. */
953 elfcorebuf_sz_orig
= sizeof(Elf64_Ehdr
) +
954 ehdr
.e_phnum
* sizeof(Elf64_Phdr
);
955 elfcorebuf_sz
= elfcorebuf_sz_orig
;
956 elfcorebuf
= (void *)__get_free_pages(GFP_KERNEL
| __GFP_ZERO
,
957 get_order(elfcorebuf_sz_orig
));
960 addr
= elfcorehdr_addr
;
961 rc
= elfcorehdr_read(elfcorebuf
, elfcorebuf_sz_orig
, &addr
);
965 /* Merge all PT_NOTE headers into one. */
966 rc
= merge_note_headers_elf64(elfcorebuf
, &elfcorebuf_sz
,
967 &elfnotes_buf
, &elfnotes_sz
);
970 rc
= process_ptload_program_headers_elf64(elfcorebuf
, elfcorebuf_sz
,
971 elfnotes_sz
, &vmcore_list
);
974 set_vmcore_list_offsets(elfcorebuf_sz
, elfnotes_sz
, &vmcore_list
);
981 static int __init
parse_crash_elf32_headers(void)
987 addr
= elfcorehdr_addr
;
989 /* Read Elf header */
990 rc
= elfcorehdr_read((char *)&ehdr
, sizeof(Elf32_Ehdr
), &addr
);
994 /* Do some basic Verification. */
995 if (memcmp(ehdr
.e_ident
, ELFMAG
, SELFMAG
) != 0 ||
996 (ehdr
.e_type
!= ET_CORE
) ||
997 !elf_check_arch(&ehdr
) ||
998 ehdr
.e_ident
[EI_CLASS
] != ELFCLASS32
||
999 ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
||
1000 ehdr
.e_version
!= EV_CURRENT
||
1001 ehdr
.e_ehsize
!= sizeof(Elf32_Ehdr
) ||
1002 ehdr
.e_phentsize
!= sizeof(Elf32_Phdr
) ||
1003 ehdr
.e_phnum
== 0) {
1004 pr_warn("Warning: Core image elf header is not sane\n");
1008 /* Read in all elf headers. */
1009 elfcorebuf_sz_orig
= sizeof(Elf32_Ehdr
) + ehdr
.e_phnum
* sizeof(Elf32_Phdr
);
1010 elfcorebuf_sz
= elfcorebuf_sz_orig
;
1011 elfcorebuf
= (void *)__get_free_pages(GFP_KERNEL
| __GFP_ZERO
,
1012 get_order(elfcorebuf_sz_orig
));
1015 addr
= elfcorehdr_addr
;
1016 rc
= elfcorehdr_read(elfcorebuf
, elfcorebuf_sz_orig
, &addr
);
1020 /* Merge all PT_NOTE headers into one. */
1021 rc
= merge_note_headers_elf32(elfcorebuf
, &elfcorebuf_sz
,
1022 &elfnotes_buf
, &elfnotes_sz
);
1025 rc
= process_ptload_program_headers_elf32(elfcorebuf
, elfcorebuf_sz
,
1026 elfnotes_sz
, &vmcore_list
);
1029 set_vmcore_list_offsets(elfcorebuf_sz
, elfnotes_sz
, &vmcore_list
);
1036 static int __init
parse_crash_elf_headers(void)
1038 unsigned char e_ident
[EI_NIDENT
];
1042 addr
= elfcorehdr_addr
;
1043 rc
= elfcorehdr_read(e_ident
, EI_NIDENT
, &addr
);
1046 if (memcmp(e_ident
, ELFMAG
, SELFMAG
) != 0) {
1047 pr_warn("Warning: Core image elf header not found\n");
1051 if (e_ident
[EI_CLASS
] == ELFCLASS64
) {
1052 rc
= parse_crash_elf64_headers();
1055 } else if (e_ident
[EI_CLASS
] == ELFCLASS32
) {
1056 rc
= parse_crash_elf32_headers();
1060 pr_warn("Warning: Core image elf header is not sane\n");
1064 /* Determine vmcore size. */
1065 vmcore_size
= get_vmcore_size(elfcorebuf_sz
, elfnotes_sz
,
1071 /* Init function for vmcore module. */
1072 static int __init
vmcore_init(void)
1076 /* Allow architectures to allocate ELF header in 2nd kernel */
1077 rc
= elfcorehdr_alloc(&elfcorehdr_addr
, &elfcorehdr_size
);
1081 * If elfcorehdr= has been passed in cmdline or created in 2nd kernel,
1082 * then capture the dump.
1084 if (!(is_vmcore_usable()))
1086 rc
= parse_crash_elf_headers();
1088 pr_warn("Kdump: vmcore not initialized\n");
1091 elfcorehdr_free(elfcorehdr_addr
);
1092 elfcorehdr_addr
= ELFCORE_ADDR_ERR
;
1094 proc_vmcore
= proc_create("vmcore", S_IRUSR
, NULL
, &proc_vmcore_operations
);
1096 proc_vmcore
->size
= vmcore_size
;
1099 fs_initcall(vmcore_init
);
1101 /* Cleanup function for vmcore module. */
1102 void vmcore_cleanup(void)
1104 struct list_head
*pos
, *next
;
1107 proc_remove(proc_vmcore
);
1111 /* clear the vmcore list. */
1112 list_for_each_safe(pos
, next
, &vmcore_list
) {
1115 m
= list_entry(pos
, struct vmcore
, list
);
1121 EXPORT_SYMBOL_GPL(vmcore_cleanup
);