2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* linux/drivers/char/mem.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Added devfs support.
|
|
|
|
* Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu>
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 15:09:05 +00:00
|
|
|
* Shared /dev/zero mmapping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com>
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#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>
|
2005-06-25 21:58:23 +00:00
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/crash_dump.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/backing-dev.h>
|
2005-06-25 21:58:24 +00:00
|
|
|
#include <linux/bootmem.h>
|
2007-06-04 07:59:47 +00:00
|
|
|
#include <linux/splice.h>
|
2006-10-13 15:42:10 +00:00
|
|
|
#include <linux/pfn.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
#ifdef CONFIG_IA64
|
|
|
|
# include <linux/efi.h>
|
|
|
|
#endif
|
|
|
|
|
2009-12-15 01:58:07 +00:00
|
|
|
static inline unsigned long size_inside_page(unsigned long start,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
unsigned long sz;
|
|
|
|
|
|
|
|
if (-start & (PAGE_SIZE - 1))
|
|
|
|
sz = -start & (PAGE_SIZE - 1);
|
|
|
|
else
|
|
|
|
sz = PAGE_SIZE;
|
|
|
|
|
|
|
|
return min_t(unsigned long, sz, size);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Architectures vary in how they handle caching for addresses
|
|
|
|
* outside of main memory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static inline int uncached_access(struct file *file, unsigned long addr)
|
|
|
|
{
|
2008-03-19 00:00:20 +00:00
|
|
|
#if defined(CONFIG_IA64)
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2009-10-27 10:05:28 +00:00
|
|
|
* On ia64, we ignore O_DSYNC because we cannot tolerate memory attribute aliases.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
return !(efi_mem_attributes(addr) & EFI_MEMORY_WB);
|
2007-07-10 16:32:56 +00:00
|
|
|
#elif defined(CONFIG_MIPS)
|
|
|
|
{
|
|
|
|
extern int __uncached_access(struct file *file,
|
|
|
|
unsigned long addr);
|
|
|
|
|
|
|
|
return __uncached_access(file, addr);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* Accessing memory above the top the kernel knows about or through a file pointer
|
2009-10-27 10:05:28 +00:00
|
|
|
* that was marked O_DSYNC will be done non-cached.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-10-27 10:05:28 +00:00
|
|
|
if (file->f_flags & O_DSYNC)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
return addr >= __pa(high_memory);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
|
2006-03-26 09:37:05 +00:00
|
|
|
static inline int valid_phys_addr_range(unsigned long addr, size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-03-26 09:37:05 +00:00
|
|
|
if (addr + count > __pa(high_memory))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2006-01-08 09:04:13 +00:00
|
|
|
|
2006-07-10 11:45:27 +00:00
|
|
|
static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
|
2006-01-08 09:04:13 +00:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2008-07-17 22:26:59 +00:00
|
|
|
#ifdef CONFIG_STRICT_DEVMEM
|
2008-03-07 07:01:47 +00:00
|
|
|
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
|
2008-04-24 21:40:47 +00:00
|
|
|
{
|
2008-03-07 07:01:47 +00:00
|
|
|
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",
|
2008-04-24 21:40:47 +00:00
|
|
|
current->comm, from, to);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-03-07 07:01:47 +00:00
|
|
|
cursor += PAGE_SIZE;
|
|
|
|
pfn++;
|
2008-04-24 21:40:47 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#else
|
2008-03-07 07:01:47 +00:00
|
|
|
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
|
2008-04-24 21:40:47 +00:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-03-19 00:00:15 +00:00
|
|
|
void __attribute__((weak)) unxlate_dev_mem_ptr(unsigned long phys, void *addr)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
unsigned long p = *ppos;
|
|
|
|
ssize_t read, sz;
|
|
|
|
char *ptr;
|
|
|
|
|
2006-03-26 09:37:05 +00:00
|
|
|
if (!valid_phys_addr_range(p, count))
|
2005-04-16 22:20:36 +00:00
|
|
|
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 = PAGE_SIZE - p;
|
|
|
|
if (sz > count)
|
|
|
|
sz = count;
|
|
|
|
if (sz > 0) {
|
|
|
|
if (clear_user(buf, sz))
|
|
|
|
return -EFAULT;
|
|
|
|
buf += sz;
|
|
|
|
p += sz;
|
|
|
|
count -= sz;
|
|
|
|
read += sz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
while (count > 0) {
|
2009-12-15 01:58:07 +00:00
|
|
|
sz = size_inside_page(p, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-19 00:00:15 +00:00
|
|
|
if (!range_is_allowed(p >> PAGE_SHIFT, count))
|
|
|
|
return -EPERM;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2008-03-19 00:00:15 +00:00
|
|
|
if (!ptr)
|
|
|
|
return -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-19 00:00:15 +00:00
|
|
|
if (copy_to_user(buf, ptr, sz)) {
|
|
|
|
unxlate_dev_mem_ptr(p, ptr);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
2008-03-19 00:00:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unxlate_dev_mem_ptr(p, ptr);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
unsigned long p = *ppos;
|
|
|
|
ssize_t written, sz;
|
|
|
|
unsigned long copied;
|
|
|
|
void *ptr;
|
|
|
|
|
2006-03-26 09:37:05 +00:00
|
|
|
if (!valid_phys_addr_range(p, count))
|
2005-04-16 22:20:36 +00:00
|
|
|
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) {
|
|
|
|
unsigned long sz = PAGE_SIZE - p;
|
|
|
|
if (sz > count)
|
|
|
|
sz = count;
|
|
|
|
/* Hmm. Do something? */
|
|
|
|
buf += sz;
|
|
|
|
p += sz;
|
|
|
|
count -= sz;
|
|
|
|
written += sz;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
while (count > 0) {
|
2009-12-15 01:58:07 +00:00
|
|
|
sz = size_inside_page(p, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-19 00:00:15 +00:00
|
|
|
if (!range_is_allowed(p >> PAGE_SHIFT, sz))
|
|
|
|
return -EPERM;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2008-03-19 00:00:15 +00:00
|
|
|
if (!ptr) {
|
|
|
|
if (written)
|
|
|
|
break;
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
copied = copy_from_user(ptr, buf, sz);
|
|
|
|
if (copied) {
|
2006-03-25 11:07:31 +00:00
|
|
|
written += sz - copied;
|
2008-03-19 00:00:15 +00:00
|
|
|
unxlate_dev_mem_ptr(p, ptr);
|
2006-03-25 11:07:31 +00:00
|
|
|
if (written)
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
2008-03-19 00:00:15 +00:00
|
|
|
|
|
|
|
unxlate_dev_mem_ptr(p, ptr);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
buf += sz;
|
|
|
|
p += sz;
|
|
|
|
count -= sz;
|
|
|
|
written += sz;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ppos += written;
|
|
|
|
return written;
|
|
|
|
}
|
|
|
|
|
2008-03-19 00:00:20 +00:00
|
|
|
int __attribute__((weak)) phys_mem_access_prot_allowed(struct file *file,
|
|
|
|
unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-01-08 09:04:10 +00:00
|
|
|
#ifndef __HAVE_PHYS_MEM_ACCESS_PROT
|
|
|
|
static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
|
|
|
|
unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
|
|
|
#ifdef pgprot_noncached
|
|
|
|
unsigned long offset = pfn << PAGE_SHIFT;
|
|
|
|
|
|
|
|
if (uncached_access(file, offset))
|
|
|
|
return pgprot_noncached(vma_prot);
|
|
|
|
#endif
|
|
|
|
return vma_prot;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-09-27 08:50:16 +00:00
|
|
|
#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;
|
2007-04-17 05:53:16 +00:00
|
|
|
return pgoff << PAGE_SHIFT;
|
2006-09-27 08:50:16 +00: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;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define get_unmapped_area_mem NULL
|
|
|
|
|
|
|
|
static inline int private_mapping_ok(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-09-27 18:29:37 +00:00
|
|
|
static const struct vm_operations_struct mmap_mem_ops = {
|
2008-07-24 04:27:07 +00:00
|
|
|
#ifdef CONFIG_HAVE_IOREMAP_PROT
|
|
|
|
.access = generic_access_phys
|
|
|
|
#endif
|
2008-03-19 00:00:21 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int mmap_mem(struct file * file, struct vm_area_struct * vma)
|
|
|
|
{
|
2006-01-08 09:04:13 +00:00
|
|
|
size_t size = vma->vm_end - vma->vm_start;
|
|
|
|
|
2006-07-10 11:45:27 +00:00
|
|
|
if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))
|
2006-01-08 09:04:13 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-09-27 08:50:16 +00:00
|
|
|
if (!private_mapping_ok(vma))
|
|
|
|
return -ENOSYS;
|
|
|
|
|
2008-03-07 07:01:47 +00:00
|
|
|
if (!range_is_allowed(vma->vm_pgoff, size))
|
|
|
|
return -EPERM;
|
|
|
|
|
2008-03-19 00:00:20 +00:00
|
|
|
if (!phys_mem_access_prot_allowed(file, vma->vm_pgoff, size,
|
|
|
|
&vma->vm_page_prot))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-10-29 00:46:18 +00:00
|
|
|
vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
|
2006-01-08 09:04:13 +00:00
|
|
|
size,
|
2005-04-16 22:20:36 +00:00
|
|
|
vma->vm_page_prot);
|
|
|
|
|
2008-03-19 00:00:21 +00:00
|
|
|
vma->vm_ops = &mmap_mem_ops;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
|
|
|
|
if (remap_pfn_range(vma,
|
|
|
|
vma->vm_start,
|
|
|
|
vma->vm_pgoff,
|
2006-01-08 09:04:13 +00:00
|
|
|
size,
|
2008-03-19 00:00:21 +00:00
|
|
|
vma->vm_page_prot)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EAGAIN;
|
2008-03-19 00:00:21 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-29 07:58:34 +00:00
|
|
|
#ifdef CONFIG_DEVKMEM
|
2005-04-16 22:20:36 +00:00
|
|
|
static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
|
|
|
|
{
|
2005-08-13 21:22:59 +00:00
|
|
|
unsigned long pfn;
|
|
|
|
|
2007-01-22 16:53:24 +00:00
|
|
|
/* Turn a kernel-virtual address into a physical page frame */
|
|
|
|
pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT;
|
2005-08-13 21:22:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-08-13 21:22:59 +00:00
|
|
|
if (!pfn_valid(pfn))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
2005-08-13 21:22:59 +00:00
|
|
|
|
|
|
|
vma->vm_pgoff = pfn;
|
2005-04-16 22:20:36 +00:00
|
|
|
return mmap_mem(file, vma);
|
|
|
|
}
|
2008-04-29 07:58:34 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-25 21:58:23 +00:00
|
|
|
#ifdef CONFIG_CRASH_DUMP
|
|
|
|
/*
|
|
|
|
* Read memory corresponding to the old kernel.
|
|
|
|
*/
|
2005-06-25 21:58:24 +00:00
|
|
|
static ssize_t read_oldmem(struct file *file, char __user *buf,
|
2005-06-25 21:58:23 +00:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2005-06-25 21:58:24 +00:00
|
|
|
unsigned long pfn, offset;
|
|
|
|
size_t read = 0, csize;
|
|
|
|
int rc = 0;
|
2005-06-25 21:58:23 +00:00
|
|
|
|
2005-06-25 21:58:28 +00:00
|
|
|
while (count) {
|
2005-06-25 21:58:23 +00:00
|
|
|
pfn = *ppos / PAGE_SIZE;
|
2005-06-25 21:58:24 +00:00
|
|
|
if (pfn > saved_max_pfn)
|
|
|
|
return read;
|
2005-06-25 21:58:23 +00:00
|
|
|
|
2005-06-25 21:58:24 +00:00
|
|
|
offset = (unsigned long)(*ppos % PAGE_SIZE);
|
|
|
|
if (count > PAGE_SIZE - offset)
|
|
|
|
csize = PAGE_SIZE - offset;
|
|
|
|
else
|
|
|
|
csize = count;
|
2005-06-25 21:58:23 +00:00
|
|
|
|
2005-06-25 21:58:24 +00:00
|
|
|
rc = copy_oldmem_page(pfn, buf, csize, offset, 1);
|
|
|
|
if (rc < 0)
|
|
|
|
return rc;
|
2005-06-25 21:58:23 +00:00
|
|
|
buf += csize;
|
|
|
|
*ppos += csize;
|
|
|
|
read += csize;
|
|
|
|
count -= csize;
|
|
|
|
}
|
|
|
|
return read;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-29 07:58:34 +00:00
|
|
|
#ifdef CONFIG_DEVKMEM
|
2005-04-16 22:20:36 +00: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 */
|
|
|
|
|
|
|
|
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) {
|
|
|
|
size_t tmp = PAGE_SIZE - p;
|
|
|
|
if (tmp > low_count) tmp = low_count;
|
|
|
|
if (clear_user(buf, tmp))
|
|
|
|
return -EFAULT;
|
|
|
|
buf += tmp;
|
|
|
|
p += tmp;
|
|
|
|
read += tmp;
|
|
|
|
low_count -= tmp;
|
|
|
|
count -= tmp;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
while (low_count > 0) {
|
2009-12-15 01:58:07 +00:00
|
|
|
sz = size_inside_page(p, low_count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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) {
|
2009-12-15 01:58:07 +00:00
|
|
|
int len = size_inside_page(p, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
len = vread(kbuf, (char *)p, len);
|
|
|
|
if (!len)
|
|
|
|
break;
|
|
|
|
if (copy_to_user(buf, kbuf, len)) {
|
|
|
|
free_page((unsigned long)kbuf);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
count -= len;
|
|
|
|
buf += len;
|
|
|
|
read += len;
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
free_page((unsigned long)kbuf);
|
|
|
|
}
|
|
|
|
*ppos = p;
|
|
|
|
return read;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline ssize_t
|
|
|
|
do_write_kmem(void *p, unsigned long realp, 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 (realp < PAGE_SIZE) {
|
|
|
|
unsigned long sz = PAGE_SIZE - realp;
|
|
|
|
if (sz > count)
|
|
|
|
sz = count;
|
|
|
|
/* Hmm. Do something? */
|
|
|
|
buf += sz;
|
|
|
|
p += sz;
|
|
|
|
realp += sz;
|
|
|
|
count -= sz;
|
|
|
|
written += sz;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
while (count > 0) {
|
|
|
|
char *ptr;
|
|
|
|
|
2009-12-15 01:58:07 +00:00
|
|
|
sz = size_inside_page(realp, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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(p);
|
|
|
|
|
|
|
|
copied = copy_from_user(ptr, buf, sz);
|
|
|
|
if (copied) {
|
2006-03-25 11:07:31 +00:00
|
|
|
written += sz - copied;
|
|
|
|
if (written)
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
buf += sz;
|
|
|
|
p += sz;
|
|
|
|
realp += 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;
|
|
|
|
ssize_t written;
|
|
|
|
char * kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */
|
|
|
|
|
|
|
|
if (p < (unsigned long) high_memory) {
|
|
|
|
|
|
|
|
wrote = count;
|
|
|
|
if (count > (unsigned long) high_memory - p)
|
|
|
|
wrote = (unsigned long) high_memory - p;
|
|
|
|
|
|
|
|
written = do_write_kmem((void*)p, p, buf, wrote, ppos);
|
|
|
|
if (written != wrote)
|
|
|
|
return written;
|
|
|
|
wrote = written;
|
|
|
|
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) {
|
2009-12-15 01:58:07 +00:00
|
|
|
int len = size_inside_page(p, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-15 01:57:57 +00:00
|
|
|
written = copy_from_user(kbuf, buf, len);
|
|
|
|
if (written) {
|
|
|
|
if (wrote + virtr)
|
|
|
|
break;
|
|
|
|
free_page((unsigned long)kbuf);
|
|
|
|
return -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
len = vwrite(kbuf, (char *)p, len);
|
|
|
|
count -= len;
|
|
|
|
buf += len;
|
|
|
|
virtr += len;
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
free_page((unsigned long)kbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
*ppos = p;
|
|
|
|
return virtr + wrote;
|
|
|
|
}
|
2008-04-29 07:58:34 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-08 07:28:17 +00:00
|
|
|
#ifdef CONFIG_DEVPORT
|
2005-04-16 22:20:36 +00: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2006-03-25 11:07:31 +00:00
|
|
|
if (__get_user(c, tmp)) {
|
|
|
|
if (tmp > buf)
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
2006-03-25 11:07:31 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
outb(c,i);
|
|
|
|
i++;
|
|
|
|
tmp++;
|
|
|
|
}
|
|
|
|
*ppos = i;
|
|
|
|
return tmp-buf;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static ssize_t read_null(struct file * file, char __user * buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t write_null(struct file * file, const char __user * buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2006-04-26 12:40:08 +00:00
|
|
|
static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf,
|
|
|
|
struct splice_desc *sd)
|
|
|
|
{
|
|
|
|
return sd->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static ssize_t read_zero(struct file * file, char __user * buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
size_t written;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_WRITE, buf, count))
|
|
|
|
return -EFAULT;
|
|
|
|
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
written = 0;
|
|
|
|
while (count) {
|
|
|
|
unsigned long unwritten;
|
|
|
|
size_t chunk = count;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
if (chunk > PAGE_SIZE)
|
|
|
|
chunk = PAGE_SIZE; /* Just for latency reasons */
|
2009-09-23 22:57:09 +00:00
|
|
|
unwritten = __clear_user(buf, chunk);
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
written += chunk - unwritten;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (unwritten)
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
break;
|
2009-06-10 03:40:25 +00:00
|
|
|
if (signal_pending(current))
|
|
|
|
return written ? written : -ERESTARTSYS;
|
2005-04-16 22:20:36 +00:00
|
|
|
buf += chunk;
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
count -= chunk;
|
2005-04-16 22:20:36 +00:00
|
|
|
cond_resched();
|
|
|
|
}
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
return written ? written : -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mmap_zero(struct file * file, struct vm_area_struct * vma)
|
|
|
|
{
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
#ifndef CONFIG_MMU
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOSYS;
|
remove ZERO_PAGE
The commit b5810039a54e5babf428e9a1e89fc1940fabff11 contains the note
A last caveat: the ZERO_PAGE is now refcounted and managed with rmap
(and thus mapcounted and count towards shared rss). These writes to
the struct page could cause excessive cacheline bouncing on big
systems. There are a number of ways this could be addressed if it is
an issue.
And indeed this cacheline bouncing has shown up on large SGI systems.
There was a situation where an Altix system was essentially livelocked
tearing down ZERO_PAGE pagetables when an HPC app aborted during startup.
This situation can be avoided in userspace, but it does highlight the
potential scalability problem with refcounting ZERO_PAGE, and corner
cases where it can really hurt (we don't want the system to livelock!).
There are several broad ways to fix this problem:
1. add back some special casing to avoid refcounting ZERO_PAGE
2. per-node or per-cpu ZERO_PAGES
3. remove the ZERO_PAGE completely
I will argue for 3. The others should also fix the problem, but they
result in more complex code than does 3, with little or no real benefit
that I can see.
Why? Inserting a ZERO_PAGE for anonymous read faults appears to be a
false optimisation: if an application is performance critical, it would
not be doing many read faults of new memory, or at least it could be
expected to write to that memory soon afterwards. If cache or memory use
is critical, it should not be working with a significant number of
ZERO_PAGEs anyway (a more compact representation of zeroes should be
used).
As a sanity check -- mesuring on my desktop system, there are never many
mappings to the ZERO_PAGE (eg. 2 or 3), thus memory usage here should not
increase much without it.
When running a make -j4 kernel compile on my dual core system, there are
about 1,000 mappings to the ZERO_PAGE created per second, but about 1,000
ZERO_PAGE COW faults per second (less than 1 ZERO_PAGE mapping per second
is torn down without being COWed). So removing ZERO_PAGE will save 1,000
page faults per second when running kbuild, while keeping it only saves
less than 1 page clearing operation per second. 1 page clear is cheaper
than a thousand faults, presumably, so there isn't an obvious loss.
Neither the logical argument nor these basic tests give a guarantee of no
regressions. However, this is a reasonable opportunity to try to remove
the ZERO_PAGE from the pagefault path. If it is found to cause regressions,
we can reintroduce it and just avoid refcounting it.
The /dev/zero ZERO_PAGE usage and TLB tricks also get nuked. I don't see
much use to them except on benchmarks. All other users of ZERO_PAGE are
converted just to use ZERO_PAGE(0) for simplicity. We can look at
replacing them all and maybe ripping out ZERO_PAGE completely when we are
more satisfied with this solution.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus "snif" Torvalds <torvalds@linux-foundation.org>
2007-10-16 08:24:40 +00:00
|
|
|
#endif
|
|
|
|
if (vma->vm_flags & VM_SHARED)
|
|
|
|
return shmem_zero_setup(vma);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t write_full(struct file * file, const char __user * buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2006-12-08 10:36:55 +00:00
|
|
|
mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (orig) {
|
|
|
|
case 0:
|
|
|
|
file->f_pos = offset;
|
|
|
|
ret = file->f_pos;
|
|
|
|
force_successful_syscall_return();
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
file->f_pos += offset;
|
|
|
|
ret = file->f_pos;
|
|
|
|
force_successful_syscall_return();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2006-12-08 10:36:55 +00:00
|
|
|
mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int open_port(struct inode * inode, struct file * filp)
|
|
|
|
{
|
|
|
|
return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define zero_lseek null_lseek
|
|
|
|
#define full_lseek null_lseek
|
|
|
|
#define write_zero write_null
|
|
|
|
#define read_full read_zero
|
|
|
|
#define open_mem open_port
|
|
|
|
#define open_kmem open_mem
|
2005-06-25 21:58:23 +00:00
|
|
|
#define open_oldmem open_mem
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations mem_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.llseek = memory_lseek,
|
|
|
|
.read = read_mem,
|
|
|
|
.write = write_mem,
|
|
|
|
.mmap = mmap_mem,
|
|
|
|
.open = open_mem,
|
2006-09-27 08:50:16 +00:00
|
|
|
.get_unmapped_area = get_unmapped_area_mem,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-04-29 07:58:34 +00:00
|
|
|
#ifdef CONFIG_DEVKMEM
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations kmem_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.llseek = memory_lseek,
|
|
|
|
.read = read_kmem,
|
|
|
|
.write = write_kmem,
|
|
|
|
.mmap = mmap_kmem,
|
|
|
|
.open = open_kmem,
|
2006-09-27 08:50:16 +00:00
|
|
|
.get_unmapped_area = get_unmapped_area_mem,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2008-04-29 07:58:34 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations null_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.llseek = null_lseek,
|
|
|
|
.read = read_null,
|
|
|
|
.write = write_null,
|
2006-04-26 12:40:08 +00:00
|
|
|
.splice_write = splice_write_null,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-05-08 07:28:17 +00:00
|
|
|
#ifdef CONFIG_DEVPORT
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations port_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.llseek = memory_lseek,
|
|
|
|
.read = read_port,
|
|
|
|
.write = write_port,
|
|
|
|
.open = open_port,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations zero_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.llseek = zero_lseek,
|
|
|
|
.read = read_zero,
|
|
|
|
.write = write_zero,
|
|
|
|
.mmap = mmap_zero,
|
|
|
|
};
|
|
|
|
|
2006-09-27 08:50:16 +00:00
|
|
|
/*
|
|
|
|
* capabilities for /dev/zero
|
|
|
|
* - permits private mappings, "copies" are taken of the source of zeros
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct backing_dev_info zero_bdi = {
|
2009-06-12 12:45:52 +00:00
|
|
|
.name = "char/mem",
|
2005-04-16 22:20:36 +00:00
|
|
|
.capabilities = BDI_CAP_MAP_COPY,
|
|
|
|
};
|
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations full_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.llseek = full_lseek,
|
|
|
|
.read = read_full,
|
|
|
|
.write = write_full,
|
|
|
|
};
|
|
|
|
|
2005-06-25 21:58:23 +00:00
|
|
|
#ifdef CONFIG_CRASH_DUMP
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations oldmem_fops = {
|
2005-06-25 21:58:23 +00:00
|
|
|
.read = read_oldmem,
|
|
|
|
.open = open_oldmem,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static ssize_t kmsg_write(struct file * file, const char __user * buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char *tmp;
|
2006-01-08 09:02:43 +00:00
|
|
|
ssize_t ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
tmp = kmalloc(count + 1, GFP_KERNEL);
|
|
|
|
if (tmp == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
ret = -EFAULT;
|
|
|
|
if (!copy_from_user(tmp, buf, count)) {
|
|
|
|
tmp[count] = 0;
|
|
|
|
ret = printk("%s", tmp);
|
2006-01-08 09:02:43 +00:00
|
|
|
if (ret > count)
|
|
|
|
/* printk can add a prefix */
|
|
|
|
ret = count;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
kfree(tmp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations kmsg_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.write = kmsg_write,
|
|
|
|
};
|
|
|
|
|
2009-07-04 14:51:29 +00:00
|
|
|
static const struct memdev {
|
|
|
|
const char *name;
|
2009-09-18 21:01:12 +00:00
|
|
|
mode_t mode;
|
2009-07-04 14:51:29 +00:00
|
|
|
const struct file_operations *fops;
|
|
|
|
struct backing_dev_info *dev_info;
|
|
|
|
} devlist[] = {
|
2009-09-18 21:01:12 +00:00
|
|
|
[1] = { "mem", 0, &mem_fops, &directly_mappable_cdev_bdi },
|
2008-04-29 07:58:34 +00:00
|
|
|
#ifdef CONFIG_DEVKMEM
|
2009-09-18 21:01:12 +00:00
|
|
|
[2] = { "kmem", 0, &kmem_fops, &directly_mappable_cdev_bdi },
|
2008-04-29 07:58:34 +00:00
|
|
|
#endif
|
2009-09-18 21:01:12 +00:00
|
|
|
[3] = { "null", 0666, &null_fops, NULL },
|
2007-05-08 07:28:17 +00:00
|
|
|
#ifdef CONFIG_DEVPORT
|
2009-09-18 21:01:12 +00:00
|
|
|
[4] = { "port", 0, &port_fops, NULL },
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2009-09-18 21:01:12 +00:00
|
|
|
[5] = { "zero", 0666, &zero_fops, &zero_bdi },
|
|
|
|
[7] = { "full", 0666, &full_fops, NULL },
|
|
|
|
[8] = { "random", 0666, &random_fops, NULL },
|
|
|
|
[9] = { "urandom", 0666, &urandom_fops, NULL },
|
|
|
|
[11] = { "kmsg", 0, &kmsg_fops, NULL },
|
2005-06-25 21:58:23 +00:00
|
|
|
#ifdef CONFIG_CRASH_DUMP
|
2009-09-18 21:01:12 +00:00
|
|
|
[12] = { "oldmem", 0, &oldmem_fops, NULL },
|
2005-06-25 21:58:23 +00:00
|
|
|
#endif
|
2009-06-17 23:27:48 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int memory_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
2009-07-04 14:51:29 +00:00
|
|
|
int minor;
|
|
|
|
const struct memdev *dev;
|
2009-06-17 23:27:48 +00:00
|
|
|
|
2009-07-04 14:51:29 +00:00
|
|
|
minor = iminor(inode);
|
|
|
|
if (minor >= ARRAY_SIZE(devlist))
|
2009-10-09 18:31:02 +00:00
|
|
|
return -ENXIO;
|
2009-06-17 23:27:48 +00:00
|
|
|
|
2009-07-04 14:51:29 +00:00
|
|
|
dev = &devlist[minor];
|
|
|
|
if (!dev->fops)
|
2009-10-09 18:31:02 +00:00
|
|
|
return -ENXIO;
|
2009-06-17 23:27:48 +00:00
|
|
|
|
2009-07-04 14:51:29 +00:00
|
|
|
filp->f_op = dev->fops;
|
|
|
|
if (dev->dev_info)
|
|
|
|
filp->f_mapping->backing_dev_info = dev->dev_info;
|
2009-06-17 23:27:48 +00:00
|
|
|
|
2009-07-04 14:51:29 +00:00
|
|
|
if (dev->fops->open)
|
2009-10-09 18:31:02 +00:00
|
|
|
return dev->fops->open(inode, filp);
|
|
|
|
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations memory_fops = {
|
2009-07-04 14:51:29 +00:00
|
|
|
.open = memory_open,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2009-09-18 21:01:12 +00:00
|
|
|
static char *mem_devnode(struct device *dev, mode_t *mode)
|
|
|
|
{
|
|
|
|
if (mode && devlist[MINOR(dev->devt)].mode)
|
|
|
|
*mode = devlist[MINOR(dev->devt)].mode;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-03-23 17:53:09 +00:00
|
|
|
static struct class *mem_class;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int __init chr_dev_init(void)
|
|
|
|
{
|
2009-07-04 14:51:29 +00:00
|
|
|
int minor;
|
2007-10-17 06:25:46 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = bdi_init(&zero_bdi);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (register_chrdev(MEM_MAJOR,"mem",&memory_fops))
|
|
|
|
printk("unable to get major %d for memory devs\n", MEM_MAJOR);
|
|
|
|
|
2005-03-23 17:53:09 +00:00
|
|
|
mem_class = class_create(THIS_MODULE, "mem");
|
2009-09-18 21:01:12 +00:00
|
|
|
mem_class->devnode = mem_devnode;
|
2009-07-04 14:51:29 +00:00
|
|
|
for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
|
|
|
|
if (!devlist[minor].name)
|
|
|
|
continue;
|
|
|
|
device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor),
|
|
|
|
NULL, devlist[minor].name);
|
|
|
|
}
|
2006-07-26 00:13:31 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_initcall(chr_dev_init);
|