Release 4.7 drivers/char/mem.c

Directory: drivers/char
/*
 *  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/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>

#include <linux/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);
}

Contributors
Person Tokens Prop Commits CommitProp
fengguang wu fengguang wu 42 100.00% 2 100.00%
Total 42 100.00% 2 100.00%

#ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE


static inline int valid_phys_addr_range(phys_addr_t addr, size_t count)
{
	return addr + count <= __pa(high_memory);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 17 73.91% 1 25.00%
bjorn helgaas bjorn helgaas 3 13.04% 1 25.00%
changli gao changli gao 2 8.70% 1 25.00%
cyril chemparathy cyril chemparathy 1 4.35% 1 25.00%
Total 23 100.00% 4 100.00%



static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
{
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
bjorn helgaas bjorn helgaas 16 94.12% 1 50.00%
lennert buytenhek lennert buytenhek 1 5.88% 1 50.00%
Total 17 100.00% 2 100.00%

#endif

#ifdef CONFIG_STRICT_DEVMEM


static 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;
}
Contributors
Person Tokens Prop Commits CommitProp
arjan van de ven arjan van de ven 55 65.48% 1 50.00%
venkatesh pallipadi venkatesh pallipadi 29 34.52% 1 50.00%
Total 84 100.00% 2 100.00%

#else


static inline int range_is_allowed(unsigned long pfn, unsigned long size)
{
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
arjan van de ven arjan van de ven 16 88.89% 1 50.00%
venkatesh pallipadi venkatesh pallipadi 2 11.11% 1 50.00%
Total 18 100.00% 2 100.00%

#endif

#ifndef unxlate_dev_mem_ptr

#define unxlate_dev_mem_ptr unxlate_dev_mem_ptr


void __weak unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
{
}
Contributors
Person Tokens Prop Commits CommitProp
venkatesh pallipadi venkatesh pallipadi 6 50.00% 1 33.33%
andrew morton andrew morton 5 41.67% 1 33.33%
thierry reding thierry reding 1 8.33% 1 33.33%
Total 12 100.00% 3 100.00%

#endif

/*
 * 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;
	void *ptr;

	if (p != *ppos)
		return 0;

	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;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 111 48.26% 10 43.48%
jes sorensen jes sorensen 42 18.26% 1 4.35%
venkatesh pallipadi venkatesh pallipadi 25 10.87% 2 8.70%
fengguang wu fengguang wu 18 7.83% 3 13.04%
arjan van de ven arjan van de ven 12 5.22% 1 4.35%
petr tesarik petr tesarik 10 4.35% 1 4.35%
andrew morton andrew morton 9 3.91% 2 8.70%
cyril chemparathy cyril chemparathy 1 0.43% 1 4.35%
al viro al viro 1 0.43% 1 4.35%
thierry reding thierry reding 1 0.43% 1 4.35%
Total 230 100.00% 23 100.00%



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 (p != *ppos)
		return -EFBIG;

	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;
}

Contributors
Person Tokens Prop Commits CommitProp
jes sorensen jes sorensen 113 48.71% 1 5.00%
pre-git pre-git 40 17.24% 7 35.00%
venkatesh pallipadi venkatesh pallipadi 25 10.78% 2 10.00%
fengguang wu fengguang wu 15 6.47% 3 15.00%
arjan van de ven arjan van de ven 14 6.03% 1 5.00%
petr tesarik petr tesarik 11 4.74% 1 5.00%
andrew morton andrew morton 9 3.88% 2 10.00%
jan beulich jan beulich 3 1.29% 1 5.00%
al viro al viro 1 0.43% 1 5.00%
cyril chemparathy cyril chemparathy 1 0.43% 1 5.00%
Total 232 100.00% 20 100.00%



int __weak phys_mem_access_prot_allowed(struct file *file,
	unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
{
	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
venkatesh pallipadi venkatesh pallipadi 17 65.38% 1 50.00%
andrew morton andrew morton 9 34.62% 1 50.00%
Total 26 100.00% 2 100.00%

#ifndef __HAVE_PHYS_MEM_ACCESS_PROT

/*
 * Architectures vary in how they handle caching for addresses
 * outside of main memory.
 *
 */
#ifdef pgprot_noncached


static 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
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 85 98.84% 1 50.00%
cyril chemparathy cyril chemparathy 1 1.16% 1 50.00%
Total 86 100.00% 2 100.00%

#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;
}
Contributors
Person Tokens Prop Commits CommitProp
bjorn helgaas bjorn helgaas 51 98.08% 1 50.00%
cyril chemparathy cyril chemparathy 1 1.92% 1 50.00%
Total 52 100.00% 2 100.00%

#endif

#ifndef CONFIG_MMU


static 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;
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 49 96.08% 1 50.00%
benjamin herrenschmidt benjamin herrenschmidt 2 3.92% 1 50.00%
Total 51 100.00% 2 100.00%

/* permit direct mmap, for read, write or exec */


static unsigned memory_mmap_capabilities(struct file *file)
{
	return NOMMU_MAP_DIRECT |
		NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC;
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



static unsigned zero_mmap_capabilities(struct file *file)
{
	return NOMMU_MAP_COPY;
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%

/* 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;
}
Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%

#else



static inline int private_mapping_ok(struct vm_area_struct *vma)
{
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%

#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;
}

Contributors
Person Tokens Prop Commits CommitProp
venkatesh pallipadi venkatesh pallipadi 48 31.79% 3 21.43%
pre-git pre-git 37 24.50% 4 28.57%
bjorn helgaas bjorn helgaas 29 19.21% 1 7.14%
benjamin herrenschmidt benjamin herrenschmidt 15 9.93% 1 7.14%
david howells david howells 12 7.95% 1 7.14%
linus torvalds linus torvalds 6 3.97% 2 14.29%
roland dreier roland dreier 3 1.99% 1 7.14%
konstantin khlebnikov konstantin khlebnikov 1 0.66% 1 7.14%
Total 151 100.00% 14 100.00%



static 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);
}

Contributors
Person Tokens Prop Commits CommitProp
andi kleen andi kleen 43 67.19% 1 25.00%
linus torvalds linus torvalds 20 31.25% 2 50.00%
andrew morton andrew morton 1 1.56% 1 25.00%
Total 64 100.00% 4 100.00%

/*
 * 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((void *)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;
}


Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 225 63.38% 7 43.75%
jes sorensen jes sorensen 44 12.39% 1 6.25%
kamezawa hiroyuki kamezawa hiroyuki 33 9.30% 1 6.25%
fengguang wu fengguang wu 31 8.73% 3 18.75%
hirofumi ogawa hirofumi ogawa 15 4.23% 1 6.25%
linus torvalds linus torvalds 5 1.41% 1 6.25%
thierry reding thierry reding 1 0.28% 1 6.25%
al viro al viro 1 0.28% 1 6.25%
Total 355 100.00% 16 100.00%



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) {
		void *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((void *)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;
}

Contributors
Person Tokens Prop Commits CommitProp
jes sorensen jes sorensen 146 88.48% 1 14.29%
fengguang wu fengguang wu 13 7.88% 3 42.86%
jan beulich jan beulich 3 1.82% 1 14.29%
thierry reding thierry reding 2 1.21% 1 14.29%
andrew morton andrew morton 1 0.61% 1 14.29%
Total 165 100.00% 7 100.00%

/*
 * 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,
					       (unsigned long)high_memory - p);
		wrote = do_write_kmem(p, buf, to_write, ppos);
		if (wrote != to_write)
			return wrote;
		p += wrote;
		buf += wrote;
		count -= wrote;
	}

	if (count > 0) {
		kbuf = (char *)__get_free_page(GFP_KERNEL);
		if (!kbuf)
			return wrote ? wrote : -ENOMEM;
		while (count > 0) {
			unsigned long sz = size_inside_page(p, count);
			unsigned long n;

			if (!is_vmalloc_or_module_addr((void *)p)) {
				err = -ENXIO;
				break;
			}
			n = copy_from_user(kbuf, buf, sz);
			if (n) {
				err = -EFAULT;
				break;
			}
			vwrite(kbuf, (char *)p, sz);
			count -= sz;
			buf += sz;
			virtr += sz;
			p += sz;
		}
		free_page((unsigned long)kbuf);
	}

	*ppos = p;
	return virtr + wrote ? : err;
}

Contributors
Person Tokens Prop Commits CommitProp
dave jones dave jones 125 48.26% 1 9.09%
pre-git pre-git 51 19.69% 4 36.36%
fengguang wu fengguang wu 35 13.51% 2 18.18%
kamezawa hiroyuki kamezawa hiroyuki 32 12.36% 1 9.09%
andrew morton andrew morton 14 5.41% 1 9.09%
al viro al viro 1 0.39% 1 9.09%
jes sorensen jes sorensen 1 0.39% 1 9.09%
Total 259 100.00% 11 100.00%



static ssize_t read_port(struct file *file, char __user *buf,
			 size_t count, loff_t *ppos)
{
	unsigned long i = *ppos;
	char __user *tmp = buf;

	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;
	while (count-- > 0 && i < 65536) {
		if (__put_user(inb(i), tmp) < 0)
			return -EFAULT;
		i++;
		tmp++;
	}
	*ppos = i;
	return tmp-buf;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 96 96.00% 4 66.67%
al viro al viro 2 2.00% 1 16.67%
jesper juhl jesper juhl 2 2.00% 1 16.67%
Total 100 100.00% 6 100.00%



static ssize_t write_port(struct file *file, const char __user *buf,
			  size_t count, loff_t *ppos)
{
	unsigned long i = *ppos;
	const char __user *tmp = buf;

	if (!access_ok(VERIFY_READ, buf, count))
		return -EFAULT;
	while (count-- > 0 && i < 65536) {
		char c;

		if (__get_user(c, tmp)) {
			if (tmp > buf)
				break;
			return -EFAULT;
		}
		outb(c, i);
		i++;
		tmp++;
	}
	*ppos = i;
	return tmp-buf;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 103 88.79% 6 66.67%
jan beulich jan beulich 9 7.76% 1 11.11%
al viro al viro 2 1.72% 1 11.11%
jesper juhl jesper juhl 2 1.72% 1 11.11%
Total 116 100.00% 9 100.00%



static ssize_t read_null(struct file *file, char __user *buf,
			 size_t count, loff_t *ppos)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 25 96.15% 2 66.67%
al viro al viro 1 3.85% 1 33.33%
Total 26 100.00% 3 100.00%



static ssize_t write_null(struct file *file, const char __user *buf,
			  size_t count, loff_t *ppos)
{
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 26 96.30% 3 75.00%
al viro al viro 1 3.70% 1 25.00%
Total 27 100.00% 4 100.00%



static ssize_t read_iter_null(struct kiocb *iocb, struct iov_iter *to)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
zach brown zach brown 16 84.21% 1 50.00%
al viro al viro 3 15.79% 1 50.00%
Total 19 100.00% 2 100.00%



static ssize_t write_iter_null(struct kiocb *iocb, struct iov_iter *from)
{
	size_t count = iov_iter_count(from);
	iov_iter_advance(from, count);
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
zach brown zach brown 17 50.00% 1 50.00%
al viro al viro 17 50.00% 1 50.00%
Total 34 100.00% 2 100.00%



static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf,
			struct splice_desc *sd)
{
	return sd->len;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static ssize_t splice_write_null(struct pipe_inode_info *pipe, struct file *out,
				 loff_t *ppos, size_t len, unsigned int flags)
{
	return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_null);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



static ssize_t read_iter_zero(struct kiocb *iocb, struct iov_iter *iter)
{
	size_t written = 0;

	while (iov_iter_count(iter)) {
		size_t chunk = iov_iter_count(iter), n;

		if (chunk > PAGE_SIZE)
			chunk = PAGE_SIZE;	/* Just for latency reasons */
		n = iov_iter_zero(chunk, iter);
		if (!n && iov_iter_count(iter))
			return written ? written : -EFAULT;
		written += n;
		if (signal_pending(current))
			return written ? written : -ERESTARTSYS;
		cond_resched();
	}
	return written;
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 39 37.86% 1 12.50%
pre-git pre-git 33 32.04% 4 50.00%
nick piggin nick piggin 13 12.62% 1 12.50%
salman qazi salman qazi 12 11.65% 1 12.50%
zach brown zach brown 6 5.83% 1 12.50%
Total 103 100.00% 8 100.00%



static int mmap_zero(struct file *file, struct vm_area_struct *vma)
{
#ifndef CONFIG_MMU
	return -ENOSYS;
#endif
	if (vma->vm_flags & VM_SHARED)
		return shmem_zero_setup(vma);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 29 69.05% 6 75.00%
nick piggin nick piggin 10 23.81% 1 12.50%
christoph hellwig christoph hellwig 3 7.14% 1 12.50%
Total 42 100.00% 8 100.00%



static ssize_t write_full(struct file *file, const char __user *buf,
			  size_t count, loff_t *ppos)
{
	return -ENOSPC;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 27 96.43% 3 75.00%
al viro al viro 1 3.57% 1 25.00%
Total 28 100.00% 4 100.00%

/*
 * Special lseek() function for /dev/null and /dev/zero.  Most notably, you
 * can fopen() both devices with "a" now.  This was previously impossible.
 * -- SRB.
 */


static loff_t null_lseek(struct file *file, loff_t offset, int orig)
{
	return file->f_pos = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 24 100.00% 2 100.00%
Total 24 100.00% 2 100.00%

/*
 * The memory devices use the full 32/64 bits of the offset, and so we cannot
 * check against negative addresses: they are ok. The return value is weird,
 * though, in that case (0).
 *
 * also note that seeking relative to the "end of file" isn't supported:
 * it has no meaning, so it returns -EINVAL.
 */


static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
{
	loff_t ret;

	inode_lock(file_inode(file));
	switch (orig) {
	case SEEK_CUR:
		offset += file->f_pos;
	case SEEK_SET:
		/* to avoid userland mistaking f_pos=-9 as -EBADF=-9 */
		if ((unsigned long long)offset >= -MAX_ERRNO) {
			ret = -EOVERFLOW;
			break;
		}
		file->f_pos = offset;
		ret = file->f_pos;
		force_successful_syscall_return();
		break;
	default:
		ret = -EINVAL;
	}
	inode_unlock(file_inode(file));
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 42 42.00% 4 36.36%
fengguang wu fengguang wu 23 23.00% 1 9.09%
robert love robert love 14 14.00% 1 9.09%
andrew morton andrew morton 10 10.00% 2 18.18%
al viro al viro 8 8.00% 2 18.18%
andrzej hajda andrzej hajda 3 3.00% 1 9.09%
Total 100 100.00% 11 100.00%



static int open_port(struct inode *inode, struct file *filp)
{
	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%


#define zero_lseek	null_lseek

#define full_lseek      null_lseek

#define write_zero	write_null

#define write_iter_zero	write_iter_null

#define open_mem	open_port

#define open_kmem	open_mem


static const struct file_operations __maybe_unused mem_fops = {
	.llseek		= memory_lseek,
	.read		= read_mem,
	.write		= write_mem,
	.mmap		= mmap_mem,
	.open		= open_mem,
#ifndef CONFIG_MMU
	.get_unmapped_area = get_unmapped_area_mem,
	.mmap_capabilities = memory_mmap_capabilities,
#endif
};


static const struct file_operations __maybe_unused kmem_fops = {
	.llseek		= memory_lseek,
	.read		= read_kmem,
	.write		= write_kmem,
	.mmap		= mmap_kmem,
	.open		= open_kmem,
#ifndef CONFIG_MMU
	.get_unmapped_area = get_unmapped_area_mem,
	.mmap_capabilities = memory_mmap_capabilities,
#endif
};


static const struct file_operations null_fops = {
	.llseek		= null_lseek,
	.read		= read_null,
	.write		= write_null,
	.read_iter	= read_iter_null,
	.write_iter	= write_iter_null,
	.splice_write	= splice_write_null,
};


static const struct file_operations __maybe_unused port_fops = {
	.llseek		= memory_lseek,
	.read		= read_port,
	.write		= write_port,
	.open		= open_port,
};


static const struct file_operations zero_fops = {
	.llseek		= zero_lseek,
	.write		= write_zero,
	.read_iter	= read_iter_zero,
	.write_iter	= write_iter_zero,
	.mmap		= mmap_zero,
#ifndef CONFIG_MMU
	.mmap_capabilities = zero_mmap_capabilities,
#endif
};


static const struct file_operations full_fops = {
	.llseek		= full_lseek,
	.read_iter	= read_iter_zero,
	.write		= write_full,
};


static const struct memdev {
	
const char *name;
	
umode_t mode;
	
const struct file_operations *fops;
	
fmode_t fmode;
} 
devlist[] = {
#ifdef CONFIG_DEVMEM
	 [1] = { "mem", 0, &mem_fops, FMODE_UNSIGNED_OFFSET },
#endif
#ifdef CONFIG_DEVKMEM
	 [2] = { "kmem", 0, &kmem_fops, FMODE_UNSIGNED_OFFSET },
#endif
	 [3] = { "null", 0666, &null_fops, 0 },
#ifdef CONFIG_DEVPORT
	 [4] = { "port", 0, &port_fops, 0 },
#endif
	 [5] = { "zero", 0666, &zero_fops, 0 },
	 [7] = { "full", 0666, &full_fops, 0 },
	 [8] = { "random", 0666, &random_fops, 0 },
	 [9] = { "urandom", 0666, &urandom_fops, 0 },
#ifdef CONFIG_PRINTK
	[11] = { "kmsg", 0644, &kmsg_fops, 0 },
#endif
};



static int memory_open(struct inode *inode, struct file *filp)
{
	int minor;
	const struct memdev *dev;

	minor = iminor(inode);
	if (minor >= ARRAY_SIZE(devlist))
		return -ENXIO;

	dev = &devlist[minor];
	if (!dev->fops)
		return -ENXIO;

	filp->f_op = dev->fops;
	filp->f_mode |= dev->fmode;

	if (dev->fops->open)
		return dev->fops->open(inode, filp);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
adriano dos santos fernandes adriano dos santos fernandes 49 47.57% 1 20.00%
kay sievers kay sievers 35 33.98% 1 20.00%
frederic weisbecker frederic weisbecker 11 10.68% 1 20.00%
kamezawa hiroyuki kamezawa hiroyuki 5 4.85% 1 20.00%
christoph hellwig christoph hellwig 3 2.91% 1 20.00%
Total 103 100.00% 5 100.00%


static const struct file_operations memory_fops = {
	.open = memory_open,
	.llseek = noop_llseek,
};



static char *mem_devnode(struct device *dev, umode_t *mode)
{
	if (mode && devlist[MINOR(dev->devt)].mode)
		*mode = devlist[MINOR(dev->devt)].mode;
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
kay sievers kay sievers 49 98.00% 1 50.00%
al viro al viro 1 2.00% 1 50.00%
Total 50 100.00% 2 100.00%


static struct class *mem_class;



static int __init chr_dev_init(void)
{
	int minor;

	if (register_chrdev(MEM_MAJOR, "mem", &memory_fops))
		printk("unable to get major %d for memory devs\n", MEM_MAJOR);

	mem_class = class_create(THIS_MODULE, "mem");
	if (IS_ERR(mem_class))
		return PTR_ERR(mem_class);

	mem_class->devnode = mem_devnode;
	for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
		if (!devlist[minor].name)
			continue;

		/*
                 * Create /dev/port?
                 */
		if ((minor == DEVPORT_MINOR) && !arch_has_dev_port())
			continue;

		device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor),
			      NULL, devlist[minor].name);
	}

	return tty_init();
}

Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 31 24.03% 5 33.33%
andrew morton andrew morton 29 22.48% 1 6.67%
kay sievers kay sievers 25 19.38% 2 13.33%
pre-git pre-git 15 11.63% 3 20.00%
anton blanchard anton blanchard 13 10.08% 1 6.67%
haren myneni haren myneni 13 10.08% 1 6.67%
david howells david howells 2 1.55% 1 6.67%
hans grob hans grob 1 0.78% 1 6.67%
Total 129 100.00% 15 100.00%


fs_initcall(chr_dev_init);
Overall Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 1146 32.37% 44 30.34%
jes sorensen jes sorensen 346 9.77% 1 0.69%
andrew morton andrew morton 213 6.02% 8 5.52%
fengguang wu fengguang wu 177 5.00% 6 4.14%
kay sievers kay sievers 171 4.83% 4 2.76%
venkatesh pallipadi venkatesh pallipadi 160 4.52% 4 2.76%
dave jones dave jones 125 3.53% 1 0.69%
david howells david howells 125 3.53% 4 2.76%
arjan van de ven arjan van de ven 113 3.19% 4 2.76%
bjorn helgaas bjorn helgaas 104 2.94% 3 2.07%
al viro al viro 93 2.63% 6 4.14%
christoph hellwig christoph hellwig 86 2.43% 3 2.07%
jens axboe jens axboe 79 2.23% 3 2.07%
adriano dos santos fernandes adriano dos santos fernandes 71 2.01% 1 0.69%
kamezawa hiroyuki kamezawa hiroyuki 70 1.98% 2 1.38%
zach brown zach brown 53 1.50% 1 0.69%
art haas art haas 45 1.27% 1 0.69%
andi kleen andi kleen 43 1.21% 1 0.69%
linus torvalds linus torvalds 43 1.21% 9 6.21%
greg kroah-hartman greg kroah-hartman 40 1.13% 5 3.45%
nick piggin nick piggin 23 0.65% 1 0.69%
petr tesarik petr tesarik 21 0.59% 1 0.69%
haren myneni haren myneni 18 0.51% 1 0.69%
benjamin herrenschmidt benjamin herrenschmidt 17 0.48% 2 1.38%
hirofumi ogawa hirofumi ogawa 15 0.42% 1 0.69%
jan beulich jan beulich 15 0.42% 1 0.69%
thierry reding thierry reding 14 0.40% 1 0.69%
robert love robert love 14 0.40% 1 0.69%
anton blanchard anton blanchard 13 0.37% 1 0.69%
salman qazi salman qazi 12 0.34% 1 0.69%
frederic weisbecker frederic weisbecker 11 0.31% 1 0.69%
rob ward rob ward 9 0.25% 4 2.76%
rik van riel rik van riel 9 0.25% 1 0.69%
vivek goyal vivek goyal 5 0.14% 1 0.69%
arnd bergmann arnd bergmann 5 0.14% 1 0.69%
cyril chemparathy cyril chemparathy 5 0.14% 1 0.69%
jesper juhl jesper juhl 4 0.11% 1 0.69%
roland dreier roland dreier 3 0.08% 1 0.69%
paul gortmaker paul gortmaker 3 0.08% 1 0.69%
andrzej hajda andrzej hajda 3 0.08% 1 0.69%
russell king russell king 3 0.08% 1 0.69%
ingo molnar ingo molnar 3 0.08% 1 0.69%
kent overstreet kent overstreet 2 0.06% 1 0.69%
changli gao changli gao 2 0.06% 1 0.69%
jin dongming jin dongming 2 0.06% 1 0.69%
geert uytterhoeven geert uytterhoeven 2 0.06% 1 0.69%
alexey dobriyan alexey dobriyan 1 0.03% 1 0.69%
konstantin khlebnikov konstantin khlebnikov 1 0.03% 1 0.69%
hans grob hans grob 1 0.03% 1 0.69%
lennert buytenhek lennert buytenhek 1 0.03% 1 0.69%
Total 3540 100.00% 145 100.00%
  Directory: drivers/char

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
fengguang wu	fengguang wu	42	100.00%	2	100.00%
	Total	42	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/char/mem.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
