2 * fs/proc/kcore.c kernel ELF core dumper
4 * Modelled on fs/exec.c:aout_core_dump()
5 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
6 * ELF version written by David Howells <David.Howells@nexor.co.uk>
7 * Modified and incorporated into 2.3.x by Tigran Aivazian <tigran@veritas.com>
8 * Support to dump vmalloc'd areas (ELF only), Tigran Aivazian <tigran@veritas.com>
9 * Safe accesses to vmalloc/direct-mapped discontiguous areas, Kanoj Sarcar <kanoj@sgi.com>
13 #include <linux/proc_fs.h>
14 #include <linux/kcore.h>
15 #include <linux/user.h>
16 #include <linux/capability.h>
17 #include <linux/elf.h>
18 #include <linux/elfcore.h>
19 #include <linux/notifier.h>
20 #include <linux/vmalloc.h>
21 #include <linux/highmem.h>
22 #include <linux/printk.h>
23 #include <linux/bootmem.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
28 #include <linux/list.h>
29 #include <linux/ioport.h>
30 #include <linux/memory.h>
31 #include <linux/sched/task.h>
32 #include <asm/sections.h>
35 #define CORE_STR "CORE"
37 #ifndef ELF_CORE_EFLAGS
38 #define ELF_CORE_EFLAGS 0
41 static struct proc_dir_entry
*proc_root_kcore
;
44 #ifndef kc_vaddr_to_offset
45 #define kc_vaddr_to_offset(v) ((v) - PAGE_OFFSET)
47 #ifndef kc_offset_to_vaddr
48 #define kc_offset_to_vaddr(o) ((o) + PAGE_OFFSET)
51 /* An ELF note in memory */
60 static LIST_HEAD(kclist_head
);
61 static DEFINE_RWLOCK(kclist_lock
);
62 static int kcore_need_update
= 1;
65 kclist_add(struct kcore_list
*new, void *addr
, size_t size
, int type
)
67 new->addr
= (unsigned long)addr
;
71 write_lock(&kclist_lock
);
72 list_add_tail(&new->list
, &kclist_head
);
73 write_unlock(&kclist_lock
);
76 static size_t get_kcore_size(int *nphdr
, size_t *elf_buflen
)
81 *nphdr
= 1; /* PT_NOTE */
84 list_for_each_entry(m
, &kclist_head
, list
) {
85 try = kc_vaddr_to_offset((size_t)m
->addr
+ m
->size
);
90 *elf_buflen
= sizeof(struct elfhdr
) +
91 (*nphdr
+ 2)*sizeof(struct elf_phdr
) +
92 3 * ((sizeof(struct elf_note
)) +
93 roundup(sizeof(CORE_STR
), 4)) +
94 roundup(sizeof(struct elf_prstatus
), 4) +
95 roundup(sizeof(struct elf_prpsinfo
), 4) +
96 roundup(arch_task_struct_size
, 4);
97 *elf_buflen
= PAGE_ALIGN(*elf_buflen
);
98 return size
+ *elf_buflen
;
101 static void free_kclist_ents(struct list_head
*head
)
103 struct kcore_list
*tmp
, *pos
;
105 list_for_each_entry_safe(pos
, tmp
, head
, list
) {
106 list_del(&pos
->list
);
111 * Replace all KCORE_RAM/KCORE_VMEMMAP information with passed list.
113 static void __kcore_update_ram(struct list_head
*list
)
117 struct kcore_list
*tmp
, *pos
;
120 write_lock(&kclist_lock
);
121 if (kcore_need_update
) {
122 list_for_each_entry_safe(pos
, tmp
, &kclist_head
, list
) {
123 if (pos
->type
== KCORE_RAM
124 || pos
->type
== KCORE_VMEMMAP
)
125 list_move(&pos
->list
, &garbage
);
127 list_splice_tail(list
, &kclist_head
);
129 list_splice(list
, &garbage
);
130 kcore_need_update
= 0;
131 proc_root_kcore
->size
= get_kcore_size(&nphdr
, &size
);
132 write_unlock(&kclist_lock
);
134 free_kclist_ents(&garbage
);
138 #ifdef CONFIG_HIGHMEM
140 * If no highmem, we can assume [0...max_low_pfn) continuous range of memory
141 * because memory hole is not as big as !HIGHMEM case.
142 * (HIGHMEM is special because part of memory is _invisible_ from the kernel.)
144 static int kcore_update_ram(void)
147 struct kcore_list
*ent
;
150 ent
= kmalloc(sizeof(*ent
), GFP_KERNEL
);
153 ent
->addr
= (unsigned long)__va(0);
154 ent
->size
= max_low_pfn
<< PAGE_SHIFT
;
155 ent
->type
= KCORE_RAM
;
156 list_add(&ent
->list
, &head
);
157 __kcore_update_ram(&head
);
161 #else /* !CONFIG_HIGHMEM */
163 #ifdef CONFIG_SPARSEMEM_VMEMMAP
164 /* calculate vmemmap's address from given system ram pfn and register it */
166 get_sparsemem_vmemmap_info(struct kcore_list
*ent
, struct list_head
*head
)
168 unsigned long pfn
= __pa(ent
->addr
) >> PAGE_SHIFT
;
169 unsigned long nr_pages
= ent
->size
>> PAGE_SHIFT
;
170 unsigned long start
, end
;
171 struct kcore_list
*vmm
, *tmp
;
174 start
= ((unsigned long)pfn_to_page(pfn
)) & PAGE_MASK
;
175 end
= ((unsigned long)pfn_to_page(pfn
+ nr_pages
)) - 1;
176 end
= PAGE_ALIGN(end
);
177 /* overlap check (because we have to align page */
178 list_for_each_entry(tmp
, head
, list
) {
179 if (tmp
->type
!= KCORE_VMEMMAP
)
181 if (start
< tmp
->addr
+ tmp
->size
)
186 vmm
= kmalloc(sizeof(*vmm
), GFP_KERNEL
);
190 vmm
->size
= end
- start
;
191 vmm
->type
= KCORE_VMEMMAP
;
192 list_add_tail(&vmm
->list
, head
);
199 get_sparsemem_vmemmap_info(struct kcore_list
*ent
, struct list_head
*head
)
207 kclist_add_private(unsigned long pfn
, unsigned long nr_pages
, void *arg
)
209 struct list_head
*head
= (struct list_head
*)arg
;
210 struct kcore_list
*ent
;
212 ent
= kmalloc(sizeof(*ent
), GFP_KERNEL
);
215 ent
->addr
= (unsigned long)__va((pfn
<< PAGE_SHIFT
));
216 ent
->size
= nr_pages
<< PAGE_SHIFT
;
218 /* Sanity check: Can happen in 32bit arch...maybe */
219 if (ent
->addr
< (unsigned long) __va(0))
222 /* cut not-mapped area. ....from ppc-32 code. */
223 if (ULONG_MAX
- ent
->addr
< ent
->size
)
224 ent
->size
= ULONG_MAX
- ent
->addr
;
226 /* cut when vmalloc() area is higher than direct-map area */
227 if (VMALLOC_START
> (unsigned long)__va(0)) {
228 if (ent
->addr
> VMALLOC_START
)
230 if (VMALLOC_START
- ent
->addr
< ent
->size
)
231 ent
->size
= VMALLOC_START
- ent
->addr
;
234 ent
->type
= KCORE_RAM
;
235 list_add_tail(&ent
->list
, head
);
237 if (!get_sparsemem_vmemmap_info(ent
, head
)) {
238 list_del(&ent
->list
);
248 static int kcore_update_ram(void)
251 unsigned long end_pfn
;
254 /* Not inialized....update now */
255 /* find out "max pfn" */
257 for_each_node_state(nid
, N_MEMORY
) {
258 unsigned long node_end
;
259 node_end
= node_end_pfn(nid
);
260 if (end_pfn
< node_end
)
263 /* scan 0 to max_pfn */
264 ret
= walk_system_ram_range(0, end_pfn
, &head
, kclist_add_private
);
266 free_kclist_ents(&head
);
269 __kcore_update_ram(&head
);
272 #endif /* CONFIG_HIGHMEM */
274 /*****************************************************************************/
276 * determine size of ELF note
278 static int notesize(struct memelfnote
*en
)
282 sz
= sizeof(struct elf_note
);
283 sz
+= roundup((strlen(en
->name
) + 1), 4);
284 sz
+= roundup(en
->datasz
, 4);
287 } /* end notesize() */
289 /*****************************************************************************/
291 * store a note in the header buffer
293 static char *storenote(struct memelfnote
*men
, char *bufp
)
297 #define DUMP_WRITE(addr,nr) do { memcpy(bufp,addr,nr); bufp += nr; } while(0)
299 en
.n_namesz
= strlen(men
->name
) + 1;
300 en
.n_descsz
= men
->datasz
;
301 en
.n_type
= men
->type
;
303 DUMP_WRITE(&en
, sizeof(en
));
304 DUMP_WRITE(men
->name
, en
.n_namesz
);
306 /* XXX - cast from long long to long to avoid need for libgcc.a */
307 bufp
= (char*) roundup((unsigned long)bufp
,4);
308 DUMP_WRITE(men
->data
, men
->datasz
);
309 bufp
= (char*) roundup((unsigned long)bufp
,4);
314 } /* end storenote() */
317 * store an ELF coredump header in the supplied buffer
318 * nphdr is the number of elf_phdr to insert
320 static void elf_kcore_store_hdr(char *bufp
, int nphdr
, int dataoff
)
322 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
323 struct elf_prpsinfo prpsinfo
; /* NT_PRPSINFO */
324 struct elf_phdr
*nhdr
, *phdr
;
326 struct memelfnote notes
[3];
328 struct kcore_list
*m
;
330 /* setup ELF header */
331 elf
= (struct elfhdr
*) bufp
;
332 bufp
+= sizeof(struct elfhdr
);
333 offset
+= sizeof(struct elfhdr
);
334 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
335 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
336 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
337 elf
->e_ident
[EI_VERSION
]= EV_CURRENT
;
338 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
339 memset(elf
->e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
340 elf
->e_type
= ET_CORE
;
341 elf
->e_machine
= ELF_ARCH
;
342 elf
->e_version
= EV_CURRENT
;
344 elf
->e_phoff
= sizeof(struct elfhdr
);
346 elf
->e_flags
= ELF_CORE_EFLAGS
;
347 elf
->e_ehsize
= sizeof(struct elfhdr
);
348 elf
->e_phentsize
= sizeof(struct elf_phdr
);
349 elf
->e_phnum
= nphdr
;
354 /* setup ELF PT_NOTE program header */
355 nhdr
= (struct elf_phdr
*) bufp
;
356 bufp
+= sizeof(struct elf_phdr
);
357 offset
+= sizeof(struct elf_phdr
);
358 nhdr
->p_type
= PT_NOTE
;
367 /* setup ELF PT_LOAD program header for every area */
368 list_for_each_entry(m
, &kclist_head
, list
) {
369 phdr
= (struct elf_phdr
*) bufp
;
370 bufp
+= sizeof(struct elf_phdr
);
371 offset
+= sizeof(struct elf_phdr
);
373 phdr
->p_type
= PT_LOAD
;
374 phdr
->p_flags
= PF_R
|PF_W
|PF_X
;
375 phdr
->p_offset
= kc_vaddr_to_offset(m
->addr
) + dataoff
;
376 phdr
->p_vaddr
= (size_t)m
->addr
;
377 if (m
->type
== KCORE_RAM
|| m
->type
== KCORE_TEXT
)
378 phdr
->p_paddr
= __pa(m
->addr
);
380 phdr
->p_paddr
= (elf_addr_t
)-1;
381 phdr
->p_filesz
= phdr
->p_memsz
= m
->size
;
382 phdr
->p_align
= PAGE_SIZE
;
386 * Set up the notes in similar form to SVR4 core dumps made
387 * with info from their /proc.
389 nhdr
->p_offset
= offset
;
391 /* set up the process status */
392 notes
[0].name
= CORE_STR
;
393 notes
[0].type
= NT_PRSTATUS
;
394 notes
[0].datasz
= sizeof(struct elf_prstatus
);
395 notes
[0].data
= &prstatus
;
397 memset(&prstatus
, 0, sizeof(struct elf_prstatus
));
399 nhdr
->p_filesz
= notesize(¬es
[0]);
400 bufp
= storenote(¬es
[0], bufp
);
402 /* set up the process info */
403 notes
[1].name
= CORE_STR
;
404 notes
[1].type
= NT_PRPSINFO
;
405 notes
[1].datasz
= sizeof(struct elf_prpsinfo
);
406 notes
[1].data
= &prpsinfo
;
408 memset(&prpsinfo
, 0, sizeof(struct elf_prpsinfo
));
409 prpsinfo
.pr_state
= 0;
410 prpsinfo
.pr_sname
= 'R';
411 prpsinfo
.pr_zomb
= 0;
413 strcpy(prpsinfo
.pr_fname
, "vmlinux");
414 strlcpy(prpsinfo
.pr_psargs
, saved_command_line
, sizeof(prpsinfo
.pr_psargs
));
416 nhdr
->p_filesz
+= notesize(¬es
[1]);
417 bufp
= storenote(¬es
[1], bufp
);
419 /* set up the task structure */
420 notes
[2].name
= CORE_STR
;
421 notes
[2].type
= NT_TASKSTRUCT
;
422 notes
[2].datasz
= arch_task_struct_size
;
423 notes
[2].data
= current
;
425 nhdr
->p_filesz
+= notesize(¬es
[2]);
426 bufp
= storenote(¬es
[2], bufp
);
428 } /* end elf_kcore_store_hdr() */
430 /*****************************************************************************/
432 * read from the ELF header and then kernel memory
435 read_kcore(struct file
*file
, char __user
*buffer
, size_t buflen
, loff_t
*fpos
)
437 char *buf
= file
->private_data
;
444 read_lock(&kclist_lock
);
445 size
= get_kcore_size(&nphdr
, &elf_buflen
);
447 if (buflen
== 0 || *fpos
>= size
) {
448 read_unlock(&kclist_lock
);
452 /* trim buflen to not go beyond EOF */
453 if (buflen
> size
- *fpos
)
454 buflen
= size
- *fpos
;
456 /* construct an ELF core header if we'll need some of it */
457 if (*fpos
< elf_buflen
) {
460 tsz
= elf_buflen
- *fpos
;
463 elf_buf
= kzalloc(elf_buflen
, GFP_ATOMIC
);
465 read_unlock(&kclist_lock
);
468 elf_kcore_store_hdr(elf_buf
, nphdr
, elf_buflen
);
469 read_unlock(&kclist_lock
);
470 if (copy_to_user(buffer
, elf_buf
+ *fpos
, tsz
)) {
480 /* leave now if filled buffer already */
484 read_unlock(&kclist_lock
);
487 * Check to see if our file offset matches with any of
488 * the addresses in the elf_phdr on our list.
490 start
= kc_offset_to_vaddr(*fpos
- elf_buflen
);
491 if ((tsz
= (PAGE_SIZE
- (start
& ~PAGE_MASK
))) > buflen
)
495 struct kcore_list
*m
;
497 read_lock(&kclist_lock
);
498 list_for_each_entry(m
, &kclist_head
, list
) {
499 if (start
>= m
->addr
&& start
< (m
->addr
+m
->size
))
502 read_unlock(&kclist_lock
);
504 if (&m
->list
== &kclist_head
) {
505 if (clear_user(buffer
, tsz
))
507 } else if (is_vmalloc_or_module_addr((void *)start
)) {
508 vread(buf
, (char *)start
, tsz
);
509 /* we have to zero-fill user buffer even if no read */
510 if (copy_to_user(buffer
, buf
, tsz
))
513 if (kern_addr_valid(start
)) {
517 * Using bounce buffer to bypass the
518 * hardened user copy kernel text checks.
520 memcpy(buf
, (char *) start
, tsz
);
521 n
= copy_to_user(buffer
, buf
, tsz
);
523 * We cannot distinguish between fault on source
524 * and fault on destination. When this happens
525 * we clear too and hope it will trigger the
529 if (clear_user(buffer
+ tsz
- n
,
534 if (clear_user(buffer
, tsz
))
543 tsz
= (buflen
> PAGE_SIZE
? PAGE_SIZE
: buflen
);
550 static int open_kcore(struct inode
*inode
, struct file
*filp
)
552 if (!capable(CAP_SYS_RAWIO
))
555 filp
->private_data
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
556 if (!filp
->private_data
)
559 if (kcore_need_update
)
561 if (i_size_read(inode
) != proc_root_kcore
->size
) {
563 i_size_write(inode
, proc_root_kcore
->size
);
569 static int release_kcore(struct inode
*inode
, struct file
*file
)
571 kfree(file
->private_data
);
575 static const struct file_operations proc_kcore_operations
= {
578 .release
= release_kcore
,
579 .llseek
= default_llseek
,
582 /* just remember that we have to update kcore */
583 static int __meminit
kcore_callback(struct notifier_block
*self
,
584 unsigned long action
, void *arg
)
589 write_lock(&kclist_lock
);
590 kcore_need_update
= 1;
591 write_unlock(&kclist_lock
);
596 static struct notifier_block kcore_callback_nb __meminitdata
= {
597 .notifier_call
= kcore_callback
,
601 static struct kcore_list kcore_vmalloc
;
603 #ifdef CONFIG_ARCH_PROC_KCORE_TEXT
604 static struct kcore_list kcore_text
;
606 * If defined, special segment is used for mapping kernel text instead of
607 * direct-map area. We need to create special TEXT section.
609 static void __init
proc_kcore_text_init(void)
611 kclist_add(&kcore_text
, _text
, _end
- _text
, KCORE_TEXT
);
614 static void __init
proc_kcore_text_init(void)
619 #if defined(CONFIG_MODULES) && defined(MODULES_VADDR)
621 * MODULES_VADDR has no intersection with VMALLOC_ADDR.
623 struct kcore_list kcore_modules
;
624 static void __init
add_modules_range(void)
626 if (MODULES_VADDR
!= VMALLOC_START
&& MODULES_END
!= VMALLOC_END
) {
627 kclist_add(&kcore_modules
, (void *)MODULES_VADDR
,
628 MODULES_END
- MODULES_VADDR
, KCORE_VMALLOC
);
632 static void __init
add_modules_range(void)
637 static int __init
proc_kcore_init(void)
639 proc_root_kcore
= proc_create("kcore", S_IRUSR
, NULL
,
640 &proc_kcore_operations
);
641 if (!proc_root_kcore
) {
642 pr_err("couldn't create /proc/kcore\n");
643 return 0; /* Always returns 0. */
645 /* Store text area if it's special */
646 proc_kcore_text_init();
647 /* Store vmalloc area */
648 kclist_add(&kcore_vmalloc
, (void *)VMALLOC_START
,
649 VMALLOC_END
- VMALLOC_START
, KCORE_VMALLOC
);
651 /* Store direct-map area from physical memory map */
653 register_hotmemory_notifier(&kcore_callback_nb
);
657 fs_initcall(proc_kcore_init
);