kcore: fix vread/vwrite to be aware of holes
authorKAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Tue, 22 Sep 2009 00:02:34 +0000 (17:02 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 22 Sep 2009 14:17:34 +0000 (07:17 -0700)
vread/vwrite access vmalloc area without checking there is a page or not.
In most case, this works well.

In old ages, the caller of get_vm_ara() is only IOREMAP and there is no
memory hole within vm_struct's [addr...addr + size - PAGE_SIZE] (
-PAGE_SIZE is for a guard page.)

After per-cpu-alloc patch, it uses get_vm_area() for reserve continuous
virtual address but remap _later_.  There tend to be a hole in valid
vmalloc area in vm_struct lists.  Then, skip the hole (not mapped page) is
necessary.  This patch updates vread/vwrite() for avoiding memory hole.

Routines which access vmalloc area without knowing for which addr is used
are
  - /proc/kcore
  - /dev/kmem

kcore checks IOREMAP, /dev/kmem doesn't.  After this patch, IOREMAP is
checked and /dev/kmem will avoid to read/write it.  Fixes to /proc/kcore
will be in the next patch in series.

Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: WANG Cong <xiyou.wangcong@gmail.com>
Cc: Mike Smith <scgtrp@gmail.com>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
mm/vmalloc.c

index c4071fa8e12a6b72628a5bb3a0d33ba2e2febce9..9216b2555d07d1e5148992b578d489e66fc762e7 100644 (file)
@@ -25,7 +25,7 @@
 #include <linux/rcupdate.h>
 #include <linux/pfn.h>
 #include <linux/kmemleak.h>
-
+#include <linux/highmem.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
 #include <asm/tlbflush.h>
@@ -1643,10 +1643,120 @@ void *vmalloc_32_user(unsigned long size)
 }
 EXPORT_SYMBOL(vmalloc_32_user);
 
+/*
+ * small helper routine , copy contents to buf from addr.
+ * If the page is not present, fill zero.
+ */
+
+static int aligned_vread(char *buf, char *addr, unsigned long count)
+{
+       struct page *p;
+       int copied = 0;
+
+       while (count) {
+               unsigned long offset, length;
+
+               offset = (unsigned long)addr & ~PAGE_MASK;
+               length = PAGE_SIZE - offset;
+               if (length > count)
+                       length = count;
+               p = vmalloc_to_page(addr);
+               /*
+                * To do safe access to this _mapped_ area, we need
+                * lock. But adding lock here means that we need to add
+                * overhead of vmalloc()/vfree() calles for this _debug_
+                * interface, rarely used. Instead of that, we'll use
+                * kmap() and get small overhead in this access function.
+                */
+               if (p) {
+                       /*
+                        * we can expect USER0 is not used (see vread/vwrite's
+                        * function description)
+                        */
+                       void *map = kmap_atomic(p, KM_USER0);
+                       memcpy(buf, map + offset, length);
+                       kunmap_atomic(map, KM_USER0);
+               } else
+                       memset(buf, 0, length);
+
+               addr += length;
+               buf += length;
+               copied += length;
+               count -= length;
+       }
+       return copied;
+}
+
+static int aligned_vwrite(char *buf, char *addr, unsigned long count)
+{
+       struct page *p;
+       int copied = 0;
+
+       while (count) {
+               unsigned long offset, length;
+
+               offset = (unsigned long)addr & ~PAGE_MASK;
+               length = PAGE_SIZE - offset;
+               if (length > count)
+                       length = count;
+               p = vmalloc_to_page(addr);
+               /*
+                * To do safe access to this _mapped_ area, we need
+                * lock. But adding lock here means that we need to add
+                * overhead of vmalloc()/vfree() calles for this _debug_
+                * interface, rarely used. Instead of that, we'll use
+                * kmap() and get small overhead in this access function.
+                */
+               if (p) {
+                       /*
+                        * we can expect USER0 is not used (see vread/vwrite's
+                        * function description)
+                        */
+                       void *map = kmap_atomic(p, KM_USER0);
+                       memcpy(map + offset, buf, length);
+                       kunmap_atomic(map, KM_USER0);
+               }
+               addr += length;
+               buf += length;
+               copied += length;
+               count -= length;
+       }
+       return copied;
+}
+
+/**
+ *     vread() -  read vmalloc area in a safe way.
+ *     @buf:           buffer for reading data
+ *     @addr:          vm address.
+ *     @count:         number of bytes to be read.
+ *
+ *     Returns # of bytes which addr and buf should be increased.
+ *     (same number to @count). Returns 0 if [addr...addr+count) doesn't
+ *     includes any intersect with alive vmalloc area.
+ *
+ *     This function checks that addr is a valid vmalloc'ed area, and
+ *     copy data from that area to a given buffer. If the given memory range
+ *     of [addr...addr+count) includes some valid address, data is copied to
+ *     proper area of @buf. If there are memory holes, they'll be zero-filled.
+ *     IOREMAP area is treated as memory hole and no copy is done.
+ *
+ *     If [addr...addr+count) doesn't includes any intersects with alive
+ *     vm_struct area, returns 0.
+ *     @buf should be kernel's buffer. Because this function uses KM_USER0,
+ *     the caller should guarantee KM_USER0 is not used.
+ *
+ *     Note: In usual ops, vread() is never necessary because the caller
+ *     should know vmalloc() area is valid and can use memcpy().
+ *     This is for routines which have to access vmalloc area without
+ *     any informaion, as /dev/kmem.
+ *
+ */
+
 long vread(char *buf, char *addr, unsigned long count)
 {
        struct vm_struct *tmp;
        char *vaddr, *buf_start = buf;
+       unsigned long buflen = count;
        unsigned long n;
 
        /* Don't allow overflow */
@@ -1654,7 +1764,7 @@ long vread(char *buf, char *addr, unsigned long count)
                count = -(unsigned long) addr;
 
        read_lock(&vmlist_lock);
-       for (tmp = vmlist; tmp; tmp = tmp->next) {
+       for (tmp = vmlist; count && tmp; tmp = tmp->next) {
                vaddr = (char *) tmp->addr;
                if (addr >= vaddr + tmp->size - PAGE_SIZE)
                        continue;
@@ -1667,32 +1777,72 @@ long vread(char *buf, char *addr, unsigned long count)
                        count--;
                }
                n = vaddr + tmp->size - PAGE_SIZE - addr;
-               do {
-                       if (count == 0)
-                               goto finished;
-                       *buf = *addr;
-                       buf++;
-                       addr++;
-                       count--;
-               } while (--n > 0);
+               if (n > count)
+                       n = count;
+               if (!(tmp->flags & VM_IOREMAP))
+                       aligned_vread(buf, addr, n);
+               else /* IOREMAP area is treated as memory hole */
+                       memset(buf, 0, n);
+               buf += n;
+               addr += n;
+               count -= n;
        }
 finished:
        read_unlock(&vmlist_lock);
-       return buf - buf_start;
+
+       if (buf == buf_start)
+               return 0;
+       /* zero-fill memory holes */
+       if (buf != buf_start + buflen)
+               memset(buf, 0, buflen - (buf - buf_start));
+
+       return buflen;
 }
 
+/**
+ *     vwrite() -  write vmalloc area in a safe way.
+ *     @buf:           buffer for source data
+ *     @addr:          vm address.
+ *     @count:         number of bytes to be read.
+ *
+ *     Returns # of bytes which addr and buf should be incresed.
+ *     (same number to @count).
+ *     If [addr...addr+count) doesn't includes any intersect with valid
+ *     vmalloc area, returns 0.
+ *
+ *     This function checks that addr is a valid vmalloc'ed area, and
+ *     copy data from a buffer to the given addr. If specified range of
+ *     [addr...addr+count) includes some valid address, data is copied from
+ *     proper area of @buf. If there are memory holes, no copy to hole.
+ *     IOREMAP area is treated as memory hole and no copy is done.
+ *
+ *     If [addr...addr+count) doesn't includes any intersects with alive
+ *     vm_struct area, returns 0.
+ *     @buf should be kernel's buffer. Because this function uses KM_USER0,
+ *     the caller should guarantee KM_USER0 is not used.
+ *
+ *     Note: In usual ops, vwrite() is never necessary because the caller
+ *     should know vmalloc() area is valid and can use memcpy().
+ *     This is for routines which have to access vmalloc area without
+ *     any informaion, as /dev/kmem.
+ *
+ *     The caller should guarantee KM_USER1 is not used.
+ */
+
 long vwrite(char *buf, char *addr, unsigned long count)
 {
        struct vm_struct *tmp;
-       char *vaddr, *buf_start = buf;
-       unsigned long n;
+       char *vaddr;
+       unsigned long n, buflen;
+       int copied = 0;
 
        /* Don't allow overflow */
        if ((unsigned long) addr + count < count)
                count = -(unsigned long) addr;
+       buflen = count;
 
        read_lock(&vmlist_lock);
-       for (tmp = vmlist; tmp; tmp = tmp->next) {
+       for (tmp = vmlist; count && tmp; tmp = tmp->next) {
                vaddr = (char *) tmp->addr;
                if (addr >= vaddr + tmp->size - PAGE_SIZE)
                        continue;
@@ -1704,18 +1854,21 @@ long vwrite(char *buf, char *addr, unsigned long count)
                        count--;
                }
                n = vaddr + tmp->size - PAGE_SIZE - addr;
-               do {
-                       if (count == 0)
-                               goto finished;
-                       *addr = *buf;
-                       buf++;
-                       addr++;
-                       count--;
-               } while (--n > 0);
+               if (n > count)
+                       n = count;
+               if (!(tmp->flags & VM_IOREMAP)) {
+                       aligned_vwrite(buf, addr, n);
+                       copied++;
+               }
+               buf += n;
+               addr += n;
+               count -= n;
        }
 finished:
        read_unlock(&vmlist_lock);
-       return buf - buf_start;
+       if (!copied)
+               return 0;
+       return buflen;
 }
 
 /**