/* *  linux/drivers/char/mem.c * *  Copyright (C) 1991, 1992  Linus Torvalds * *  Added devfs support. *    Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu> *  Shared /dev/zero mmapping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com> */ #include <linux/mm.h>#include <linux/miscdevice.h>#include <linux/slab.h>#include <linux/vmalloc.h>#include <linux/mman.h>#include <linux/random.h>#include <linux/init.h>#include <linux/raw.h>#include <linux/tty.h>#include <linux/capability.h>#include <linux/ptrace.h>#include <linux/device.h>#include <linux/highmem.h>#include <linux/backing-dev.h>#include <linux/bootmem.h>#include <linux/splice.h>#include <linux/pfn.h>#include <linux/export.h>#include <linux/io.h>#include <linux/aio.h> #include <asm/uaccess.h> #ifdef CONFIG_IA64# include <linux/efi.h>#endif #define DEVPORT_MINOR	4 static inline unsigned long size_inside_page(unsigned long start,					     unsigned long size){	unsigned long sz; 	sz = PAGE_SIZE - (start & (PAGE_SIZE - 1)); 	return min(sz, size);} #ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGEstatic inline int valid_phys_addr_range(phys_addr_t addr, size_t count){	return addr + count <= __pa(high_memory);} static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size){	return 1;}#endif #ifdef CONFIG_STRICT_DEVMEMstatic inline int range_is_allowed(unsigned long pfn, unsigned long size){	u64 from = ((u64)pfn) << PAGE_SHIFT;	u64 to = from + size;	u64 cursor = from; 	while (cursor < to) {		if (!devmem_is_allowed(pfn)) {			printk(KERN_INFO		"Program %s tried to access /dev/mem between %Lx->%Lx.\n",				current->comm, from, to);			return 0;		}		cursor += PAGE_SIZE;		pfn++;	}	return 1;}#elsestatic inline int range_is_allowed(unsigned long pfn, unsigned long size){	return 1;}#endif void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr){} /* * This funcion reads the *physical* memory. The f_pos points directly to the * memory location. */static ssize_t read_mem(struct file *file, char __user *buf,			size_t count, loff_t *ppos){	phys_addr_t p = *ppos;	ssize_t read, sz;	char *ptr; 	if (!valid_phys_addr_range(p, count))		return -EFAULT;	read = 0;#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED	/* we don't have page 0 mapped on sparc and m68k.. */	if (p < PAGE_SIZE) {		sz = size_inside_page(p, count);		if (sz > 0) {			if (clear_user(buf, sz))				return -EFAULT;			buf += sz;			p += sz;			count -= sz;			read += sz;		}	}#endif 	while (count > 0) {		unsigned long remaining; 		sz = size_inside_page(p, count); 		if (!range_is_allowed(p >> PAGE_SHIFT, count))			return -EPERM; 		/*		 * On ia64 if a page has been mapped somewhere as uncached, then		 * it must also be accessed uncached by the kernel or data		 * corruption may occur.		 */		ptr = xlate_dev_mem_ptr(p);		if (!ptr)			return -EFAULT; 		remaining = copy_to_user(buf, ptr, sz);		unxlate_dev_mem_ptr(p, ptr);		if (remaining)			return -EFAULT; 		buf += sz;		p += sz;		count -= sz;		read += sz;	} 	*ppos += read;	return read;} static ssize_t write_mem(struct file *file, const char __user *buf,			 size_t count, loff_t *ppos){	phys_addr_t p = *ppos;	ssize_t written, sz;	unsigned long copied;	void *ptr; 	if (!valid_phys_addr_range(p, count))		return -EFAULT; 	written = 0; #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED	/* we don't have page 0 mapped on sparc and m68k.. */	if (p < PAGE_SIZE) {		sz = size_inside_page(p, count);		/* Hmm. Do something? */		buf += sz;		p += sz;		count -= sz;		written += sz;	}#endif 	while (count > 0) {		sz = size_inside_page(p, count); 		if (!range_is_allowed(p >> PAGE_SHIFT, sz))			return -EPERM; 		/*		 * On ia64 if a page has been mapped somewhere as uncached, then		 * it must also be accessed uncached by the kernel or data		 * corruption may occur.		 */		ptr = xlate_dev_mem_ptr(p);		if (!ptr) {			if (written)				break;			return -EFAULT;		} 		copied = copy_from_user(ptr, buf, sz);		unxlate_dev_mem_ptr(p, ptr);		if (copied) {			written += sz - copied;			if (written)				break;			return -EFAULT;		} 		buf += sz;		p += sz;		count -= sz;		written += sz;	} 	*ppos += written;	return written;} int __weak phys_mem_access_prot_allowed(struct file *file,	unsigned long pfn, unsigned long size, pgprot_t *vma_prot){	return 1;} #ifndef __HAVE_PHYS_MEM_ACCESS_PROT /* * Architectures vary in how they handle caching for addresses * outside of main memory. * */#ifdef pgprot_noncachedstatic int uncached_access(struct file *file, phys_addr_t addr){#if defined(CONFIG_IA64)	/*	 * On ia64, we ignore O_DSYNC because we cannot tolerate memory	 * attribute aliases.	 */	return !(efi_mem_attributes(addr) & EFI_MEMORY_WB);#elif defined(CONFIG_MIPS)	{		extern int __uncached_access(struct file *file,					     unsigned long addr); 		return __uncached_access(file, addr);	}#else	/*	 * Accessing memory above the top the kernel knows about or through a	 * file pointer	 * that was marked O_DSYNC will be done non-cached.	 */	if (file->f_flags & O_DSYNC)		return 1;	return addr >= __pa(high_memory);#endif}#endif static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,				     unsigned long size, pgprot_t vma_prot){#ifdef pgprot_noncached	phys_addr_t offset = pfn << PAGE_SHIFT; 	if (uncached_access(file, offset))		return pgprot_noncached(vma_prot);#endif	return vma_prot;}#endif #ifndef CONFIG_MMUstatic unsigned long get_unmapped_area_mem(struct file *file,					   unsigned long addr,					   unsigned long len,					   unsigned long pgoff,					   unsigned long flags){	if (!valid_mmap_phys_addr_range(pgoff, len))		return (unsigned long) -EINVAL;	return pgoff << PAGE_SHIFT;} /* can't do an in-place private mapping if there's no MMU */static inline int private_mapping_ok(struct vm_area_struct *vma){	return vma->vm_flags & VM_MAYSHARE;}#else#define get_unmapped_area_mem	NULL static inline int private_mapping_ok(struct vm_area_struct *vma){	return 1;}#endif static const struct vm_operations_struct mmap_mem_ops = {#ifdef CONFIG_HAVE_IOREMAP_PROT	.access = generic_access_phys#endif}; static int mmap_mem(struct file *file, struct vm_area_struct *vma){	size_t size = vma->vm_end - vma->vm_start; 	if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))		return -EINVAL; 	if (!private_mapping_ok(vma))		return -ENOSYS; 	if (!range_is_allowed(vma->vm_pgoff, size))		return -EPERM; 	if (!phys_mem_access_prot_allowed(file, vma->vm_pgoff, size,						&vma->vm_page_prot))		return -EINVAL; 	vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,						 size,						 vma->vm_page_prot); 	vma->vm_ops = &mmap_mem_ops; 	/* Remap-pfn-range will mark the range VM_IO */	if (remap_pfn_range(vma,			    vma->vm_start,			    vma->vm_pgoff,			    size,			    vma->vm_page_prot)) {		return -EAGAIN;	}	return 0;} #ifdef CONFIG_DEVKMEMstatic int mmap_kmem(struct file *file, struct vm_area_struct *vma){	unsigned long pfn; 	/* Turn a kernel-virtual address into a physical page frame */	pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT; 	/*	 * RED-PEN: on some architectures there is more mapped memory than	 * available in mem_map which pfn_valid checks for. Perhaps should add a	 * new macro here.	 *	 * RED-PEN: vmalloc is not supported right now.	 */	if (!pfn_valid(pfn))		return -EIO; 	vma->vm_pgoff = pfn;	return mmap_mem(file, vma);}#endif #ifdef CONFIG_DEVKMEM/* * This function reads the *virtual* memory as seen by the kernel. */static ssize_t read_kmem(struct file *file, char __user *buf,			 size_t count, loff_t *ppos){	unsigned long p = *ppos;	ssize_t low_count, read, sz;	char *kbuf; /* k-addr because vread() takes vmlist_lock rwlock */	int err = 0; 	read = 0;	if (p < (unsigned long) high_memory) {		low_count = count;		if (count > (unsigned long)high_memory - p)			low_count = (unsigned long)high_memory - p; #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED		/* we don't have page 0 mapped on sparc and m68k.. */		if (p < PAGE_SIZE && low_count > 0) {			sz = size_inside_page(p, low_count);			if (clear_user(buf, sz))				return -EFAULT;			buf += sz;			p += sz;			read += sz;			low_count -= sz;			count -= sz;		}#endif		while (low_count > 0) {			sz = size_inside_page(p, low_count); 			/*			 * On ia64 if a page has been mapped somewhere as			 * uncached, then it must also be accessed uncached			 * by the kernel or data corruption may occur			 */			kbuf = xlate_dev_kmem_ptr((char *)p); 			if (copy_to_user(buf, kbuf, sz))				return -EFAULT;			buf += sz;			p += sz;			read += sz;			low_count -= sz;			count -= sz;		}	} 	if (count > 0) {		kbuf = (char *)__get_free_page(GFP_KERNEL);		if (!kbuf)			return -ENOMEM;		while (count > 0) {			sz = size_inside_page(p, count);			if (!is_vmalloc_or_module_addr((void *)p)) {				err = -ENXIO;				break;			}			sz = vread(kbuf, (char *)p, sz);			if (!sz)				break;			if (copy_to_user(buf, kbuf, sz)) {				err = -EFAULT;				break;			}			count -= sz;			buf += sz;			read += sz;			p += sz;		}		free_page((unsigned long)kbuf);	}	*ppos = p;	return read ? read : err;}  static ssize_t do_write_kmem(unsigned long p, const char __user *buf,				size_t count, loff_t *ppos){	ssize_t written, sz;	unsigned long copied; 	written = 0;#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED	/* we don't have page 0 mapped on sparc and m68k.. */	if (p < PAGE_SIZE) {		sz = size_inside_page(p, count);		/* Hmm. Do something? */		buf += sz;		p += sz;		count -= sz;		written += sz;	}#endif 	while (count > 0) {		char *ptr; 		sz = size_inside_page(p, count); 		/*		 * On ia64 if a page has been mapped somewhere as uncached, then		 * it must also be accessed uncached by the kernel or data		 * corruption may occur.		 */		ptr = xlate_dev_kmem_ptr((char *)p); 		copied = copy_from_user(ptr, buf, sz);		if (copied) {			written += sz - copied;			if (written)				break;			return -EFAULT;		}		buf += sz;		p += sz;		count -= sz;		written += sz;	} 	*ppos += written;	return written;} /* * This function writes to the *virtual* memory as seen by the kernel. */static ssize_t write_kmem(struct file *file, const char __user *buf,			  size_t count, loff_t *ppos){	unsigned long p = *ppos;	ssize_t wrote = 0;	ssize_t virtr = 0;	char *kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */	int err = 0; 	if (p < (unsigned long) high_memory) {		unsigned long to_write = min_t(unsigned long, count,

Lines 1–500 of 902. Load more