/* *	fs/proc/vmcore.c Interface for accessing the crash * 				 dump from the system's previous life. * 	Heavily borrowed from fs/proc/kcore.c *	Created by: Hariprasad Nellitheertha (hari@in.ibm.com) *	Copyright (C) IBM Corporation, 2004. All rights reserved * */ #include <linux/mm.h>#include <linux/kcore.h>#include <linux/user.h>#include <linux/elf.h>#include <linux/elfcore.h>#include <linux/export.h>#include <linux/slab.h>#include <linux/highmem.h>#include <linux/printk.h>#include <linux/bootmem.h>#include <linux/init.h>#include <linux/crash_dump.h>#include <linux/list.h>#include <linux/vmalloc.h>#include <linux/pagemap.h>#include <asm/uaccess.h>#include <asm/io.h>#include "internal.h" /* List representing chunks of contiguous memory areas and their offsets in * vmcore file. */static LIST_HEAD(vmcore_list); /* Stores the pointer to the buffer containing kernel elf core headers. */static char *elfcorebuf;static size_t elfcorebuf_sz;static size_t elfcorebuf_sz_orig; static char *elfnotes_buf;static size_t elfnotes_sz; /* Total size of vmcore file. */static u64 vmcore_size; static struct proc_dir_entry *proc_vmcore = NULL; /* * Returns > 0 for RAM pages, 0 for non-RAM pages, < 0 on error * The called function has to take care of module refcounting. */static int (*oldmem_pfn_is_ram)(unsigned long pfn); int register_oldmem_pfn_is_ram(int (*fn)(unsigned long pfn)){	if (oldmem_pfn_is_ram)		return -EBUSY;	oldmem_pfn_is_ram = fn;	return 0;}EXPORT_SYMBOL_GPL(register_oldmem_pfn_is_ram); void unregister_oldmem_pfn_is_ram(void){	oldmem_pfn_is_ram = NULL;	wmb();}EXPORT_SYMBOL_GPL(unregister_oldmem_pfn_is_ram); static int pfn_is_ram(unsigned long pfn){	int (*fn)(unsigned long pfn);	/* pfn is ram unless fn() checks pagetype */	int ret = 1; 	/*	 * Ask hypervisor if the pfn is really ram.	 * A ballooned page contains no data and reading from such a page	 * will cause high load in the hypervisor.	 */	fn = oldmem_pfn_is_ram;	if (fn)		ret = fn(pfn); 	return ret;} /* Reads a page from the oldmem device from given offset. */static ssize_t read_from_oldmem(char *buf, size_t count,				u64 *ppos, int userbuf){	unsigned long pfn, offset;	size_t nr_bytes;	ssize_t read = 0, tmp; 	if (!count)		return 0; 	offset = (unsigned long)(*ppos % PAGE_SIZE);	pfn = (unsigned long)(*ppos / PAGE_SIZE); 	do {		if (count > (PAGE_SIZE - offset))			nr_bytes = PAGE_SIZE - offset;		else			nr_bytes = count; 		/* If pfn is not ram, return zeros for sparse dump files */		if (pfn_is_ram(pfn) == 0)			memset(buf, 0, nr_bytes);		else {			tmp = copy_oldmem_page(pfn, buf, nr_bytes,						offset, userbuf);			if (tmp < 0)				return tmp;		}		*ppos += nr_bytes;		count -= nr_bytes;		buf += nr_bytes;		read += nr_bytes;		++pfn;		offset = 0;	} while (count); 	return read;} /* * Architectures may override this function to allocate ELF header in 2nd kernel */int __weak elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size){	return 0;} /* * Architectures may override this function to free header */void __weak elfcorehdr_free(unsigned long long addr){} /* * Architectures may override this function to read from ELF header */ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos){	return read_from_oldmem(buf, count, ppos, 0);} /* * Architectures may override this function to read from notes sections */ssize_t __weak elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos){	return read_from_oldmem(buf, count, ppos, 0);} /* * Architectures may override this function to map oldmem */int __weak remap_oldmem_pfn_range(struct vm_area_struct *vma,				  unsigned long from, unsigned long pfn,				  unsigned long size, pgprot_t prot){	return remap_pfn_range(vma, from, pfn, size, prot);} /* * Copy to either kernel or user space */static int copy_to(void *target, void *src, size_t size, int userbuf){	if (userbuf) {		if (copy_to_user((char __user *) target, src, size))			return -EFAULT;	} else {		memcpy(target, src, size);	}	return 0;} /* Read from the ELF header and then the crash dump. On error, negative value is * returned otherwise number of bytes read are returned. */static ssize_t __read_vmcore(char *buffer, size_t buflen, loff_t *fpos,			     int userbuf){	ssize_t acc = 0, tmp;	size_t tsz;	u64 start;	struct vmcore *m = NULL; 	if (buflen == 0 || *fpos >= vmcore_size)		return 0; 	/* trim buflen to not go beyond EOF */	if (buflen > vmcore_size - *fpos)		buflen = vmcore_size - *fpos; 	/* Read ELF core header */	if (*fpos < elfcorebuf_sz) {		tsz = min(elfcorebuf_sz - (size_t)*fpos, buflen);		if (copy_to(buffer, elfcorebuf + *fpos, tsz, userbuf))			return -EFAULT;		buflen -= tsz;		*fpos += tsz;		buffer += tsz;		acc += tsz; 		/* leave now if filled buffer already */		if (buflen == 0)			return acc;	} 	/* Read Elf note segment */	if (*fpos < elfcorebuf_sz + elfnotes_sz) {		void *kaddr; 		tsz = min(elfcorebuf_sz + elfnotes_sz - (size_t)*fpos, buflen);		kaddr = elfnotes_buf + *fpos - elfcorebuf_sz;		if (copy_to(buffer, kaddr, tsz, userbuf))			return -EFAULT;		buflen -= tsz;		*fpos += tsz;		buffer += tsz;		acc += tsz; 		/* leave now if filled buffer already */		if (buflen == 0)			return acc;	} 	list_for_each_entry(m, &vmcore_list, list) {		if (*fpos < m->offset + m->size) {			tsz = min_t(size_t, m->offset + m->size - *fpos, buflen);			start = m->paddr + *fpos - m->offset;			tmp = read_from_oldmem(buffer, tsz, &start, userbuf);			if (tmp < 0)				return tmp;			buflen -= tsz;			*fpos += tsz;			buffer += tsz;			acc += tsz; 			/* leave now if filled buffer already */			if (buflen == 0)				return acc;		}	} 	return acc;} static ssize_t read_vmcore(struct file *file, char __user *buffer,			   size_t buflen, loff_t *fpos){	return __read_vmcore((__force char *) buffer, buflen, fpos, 1);} /* * The vmcore fault handler uses the page cache and fills data using the * standard __vmcore_read() function. * * On s390 the fault handler is used for memory regions that can't be mapped * directly with remap_pfn_range(). */static int mmap_vmcore_fault(struct vm_area_struct *vma, struct vm_fault *vmf){#ifdef CONFIG_S390	struct address_space *mapping = vma->vm_file->f_mapping;	pgoff_t index = vmf->pgoff;	struct page *page;	loff_t offset;	char *buf;	int rc; 	page = find_or_create_page(mapping, index, GFP_KERNEL);	if (!page)		return VM_FAULT_OOM;	if (!PageUptodate(page)) {		offset = (loff_t) index << PAGE_CACHE_SHIFT;		buf = __va((page_to_pfn(page) << PAGE_SHIFT));		rc = __read_vmcore(buf, PAGE_SIZE, &offset, 0);		if (rc < 0) {			unlock_page(page);			page_cache_release(page);			return (rc == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS;		}		SetPageUptodate(page);	}	unlock_page(page);	vmf->page = page;	return 0;#else	return VM_FAULT_SIGBUS;#endif} static const struct vm_operations_struct vmcore_mmap_ops = {	.fault = mmap_vmcore_fault,}; /** * alloc_elfnotes_buf - allocate buffer for ELF note segment in *                      vmalloc memory * * @notes_sz: size of buffer * * If CONFIG_MMU is defined, use vmalloc_user() to allow users to mmap * the buffer to user-space by means of remap_vmalloc_range(). * * If CONFIG_MMU is not defined, use vzalloc() since mmap_vmcore() is * disabled and there's no need to allow users to mmap the buffer. */static inline char *alloc_elfnotes_buf(size_t notes_sz){#ifdef CONFIG_MMU	return vmalloc_user(notes_sz);#else	return vzalloc(notes_sz);#endif} /* * Disable mmap_vmcore() if CONFIG_MMU is not defined. MMU is * essential for mmap_vmcore() in order to map physically * non-contiguous objects (ELF header, ELF note segment and memory * regions in the 1st kernel pointed to by PT_LOAD entries) into * virtually contiguous user-space in ELF layout. */#ifdef CONFIG_MMUstatic int mmap_vmcore(struct file *file, struct vm_area_struct *vma){	size_t size = vma->vm_end - vma->vm_start;	u64 start, end, len, tsz;	struct vmcore *m; 	start = (u64)vma->vm_pgoff << PAGE_SHIFT;	end = start + size; 	if (size > vmcore_size || end > vmcore_size)		return -EINVAL; 	if (vma->vm_flags & (VM_WRITE | VM_EXEC))		return -EPERM; 	vma->vm_flags &= ~(VM_MAYWRITE | VM_MAYEXEC);	vma->vm_flags |= VM_MIXEDMAP;	vma->vm_ops = &vmcore_mmap_ops; 	len = 0; 	if (start < elfcorebuf_sz) {		u64 pfn; 		tsz = min(elfcorebuf_sz - (size_t)start, size);		pfn = __pa(elfcorebuf + start) >> PAGE_SHIFT;		if (remap_pfn_range(vma, vma->vm_start, pfn, tsz,				    vma->vm_page_prot))			return -EAGAIN;		size -= tsz;		start += tsz;		len += tsz; 		if (size == 0)			return 0;	} 	if (start < elfcorebuf_sz + elfnotes_sz) {		void *kaddr; 		tsz = min(elfcorebuf_sz + elfnotes_sz - (size_t)start, size);		kaddr = elfnotes_buf + start - elfcorebuf_sz;		if (remap_vmalloc_range_partial(vma, vma->vm_start + len,						kaddr, tsz))			goto fail;		size -= tsz;		start += tsz;		len += tsz; 		if (size == 0)			return 0;	} 	list_for_each_entry(m, &vmcore_list, list) {		if (start < m->offset + m->size) {			u64 paddr = 0; 			tsz = min_t(size_t, m->offset + m->size - start, size);			paddr = m->paddr + start - m->offset;			if (remap_oldmem_pfn_range(vma, vma->vm_start + len,						   paddr >> PAGE_SHIFT, tsz,						   vma->vm_page_prot))				goto fail;			size -= tsz;			start += tsz;			len += tsz; 			if (size == 0)				return 0;		}	} 	return 0;fail:	do_munmap(vma->vm_mm, vma->vm_start, len);	return -EAGAIN;}#elsestatic int mmap_vmcore(struct file *file, struct vm_area_struct *vma){	return -ENOSYS;}#endif static const struct file_operations proc_vmcore_operations = {	.read		= read_vmcore,	.llseek		= default_llseek,	.mmap		= mmap_vmcore,}; static struct vmcore* __init get_new_element(void){	return kzalloc(sizeof(struct vmcore), GFP_KERNEL);} static u64 __init get_vmcore_size(size_t elfsz, size_t elfnotesegsz,				  struct list_head *vc_list){	u64 size;	struct vmcore *m; 	size = elfsz + elfnotesegsz;	list_for_each_entry(m, vc_list, list) {		size += m->size;	}	return size;} /** * update_note_header_size_elf64 - update p_memsz member of each PT_NOTE entry * * @ehdr_ptr: ELF header * * This function updates p_memsz member of each PT_NOTE entry in the * program header table pointed to by @ehdr_ptr to real size of ELF * note segment. */static int __init update_note_header_size_elf64(const Elf64_Ehdr *ehdr_ptr){	int i, rc=0;	Elf64_Phdr *phdr_ptr;	Elf64_Nhdr *nhdr_ptr; 	phdr_ptr = (Elf64_Phdr *)(ehdr_ptr + 1);	for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) {		void *notes_section;		u64 offset, max_sz, sz, real_sz = 0;		if (phdr_ptr->p_type != PT_NOTE)			continue;		max_sz = phdr_ptr->p_memsz;		offset = phdr_ptr->p_offset;		notes_section = kmalloc(max_sz, GFP_KERNEL);		if (!notes_section)			return -ENOMEM;		rc = elfcorehdr_read_notes(notes_section, max_sz, &offset);		if (rc < 0) {			kfree(notes_section);			return rc;		}		nhdr_ptr = notes_section;		while (real_sz < max_sz) {			if (nhdr_ptr->n_namesz == 0)				break;			sz = sizeof(Elf64_Nhdr) +				((nhdr_ptr->n_namesz + 3) & ~3) +				((nhdr_ptr->n_descsz + 3) & ~3);			real_sz += sz;			nhdr_ptr = (Elf64_Nhdr*)((char*)nhdr_ptr + sz);		}		kfree(notes_section);		phdr_ptr->p_memsz = real_sz;	} 	return 0;} /** * get_note_number_and_size_elf64 - get the number of PT_NOTE program * headers and sum of real size of their ELF note segment headers and * data. * * @ehdr_ptr: ELF header * @nr_ptnote: buffer for the number of PT_NOTE program headers * @sz_ptnote: buffer for size of unique PT_NOTE program header * * This function is used to merge multiple PT_NOTE program headers * into a unique single one. The resulting unique entry will have * @sz_ptnote in its phdr->p_mem. * * It is assumed that program headers with PT_NOTE type pointed to by

Lines 1–500 of 1107. Load more