[PATCH] kdump: Accessing dump file in linear raw format (/dev/oldmem)

      Hariprasad Nellitheertha <hari@in.ibm.com>

This patch contains the code that enables us to access the previous kernel's
memory as /dev/oldmem.

Signed-off-by: Eric Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

2 files changed, 75 insertions, 0 deletions

diff --git a/Documentation/devices.txt b/Documentation/devices.txt
index bb67cf25010e..0f515175c72a 100644
--- a/Documentation/devices.txt
+++ b/Documentation/devices.txt
@@ -94,6 +94,7 @@ Your cooperation is appreciated.
                   9 = /dev/urandom      Faster, less secure random number gen.
                  10 = /dev/aio          Asyncronous I/O notification interface
                  11 = /dev/kmsg         Writes to this come out as printk's
+                 12 = /dev/oldmem       Access to crash dump from kexec kernel
   1 block       RAM disk
                   0 = /dev/ram0         First RAM disk
                   1 = /dev/ram1         Second RAM disk
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index e3085b22a365..01b3c17ca851 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -23,6 +23,8 @@
 #include <linux/devfs_fs_kernel.h>
 #include <linux/ptrace.h>
 #include <linux/device.h>
+#include <linux/highmem.h>
+#include <linux/crash_dump.h>
 #include <linux/backing-dev.h>
 
 #include <asm/uaccess.h>
@@ -273,6 +275,62 @@ static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
         return mmap_mem(file, vma);
 }
 
+#ifdef CONFIG_CRASH_DUMP
+/*
+ * Read memory corresponding to the old kernel.
+ * If we are reading from the reserved section, which is
+ * actually used by the current kernel, we just return zeroes.
+ * Or if we are reading from the first 640k, we return from the
+ * backed up area.
+ */
+static ssize_t read_oldmem(struct file * file, char * buf,
+                                size_t count, loff_t *ppos)
+{
+        unsigned long pfn;
+        unsigned backup_start, backup_end, relocate_start;
+        size_t read=0, csize;
+
+        backup_start = CRASH_BACKUP_BASE / PAGE_SIZE;
+        backup_end = backup_start + (CRASH_BACKUP_SIZE / PAGE_SIZE);
+        relocate_start = (CRASH_BACKUP_BASE + CRASH_BACKUP_SIZE) / PAGE_SIZE;
+
+        while(count) {
+                pfn = *ppos / PAGE_SIZE;
+
+                csize = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+
+                /* Perform translation (see comment above) */
+                if ((pfn >= backup_start) && (pfn < backup_end)) {
+                        if (clear_user(buf, csize)) {
+                                read = -EFAULT;
+                                goto done;
+                        }
+
+                        goto copy_done;
+                } else if (pfn < (CRASH_RELOCATE_SIZE / PAGE_SIZE))
+                        pfn += relocate_start;
+
+                if (pfn > saved_max_pfn) {
+                        read = 0;
+                        goto done;
+                }
+
+                if (copy_oldmem_page(pfn, buf, csize, 1)) {
+                        read = -EFAULT;
+                        goto done;
+                }
+
+copy_done:
+                buf += csize;
+                *ppos += csize;
+                read += csize;
+                count -= csize;
+        }
+done:
+        return read;
+}
+#endif
+
 extern long vread(char *buf, char *addr, unsigned long count);
 extern long vwrite(char *buf, char *addr, unsigned long count);
 
@@ -721,6 +779,7 @@ static int open_port(struct inode * inode, struct file * filp)
 #define read_full       read_zero
 #define open_mem        open_port
 #define open_kmem       open_mem
+#define open_oldmem     open_mem
 
 static struct file_operations mem_fops = {
         .llseek         = memory_lseek,
@@ -770,6 +829,13 @@ static struct file_operations full_fops = {
         .write          = write_full,
 };
 
+#ifdef CONFIG_CRASH_DUMP
+static struct file_operations oldmem_fops = {
+        .read   = read_oldmem,
+        .open   = open_oldmem,
+};
+#endif
+
 static ssize_t kmsg_write(struct file * file, const char __user * buf,
                           size_t count, loff_t *ppos)
 {
@@ -825,6 +891,11 @@ static int memory_open(struct inode * inode, struct file * filp)
                 case 11:
                         filp->f_op = &kmsg_fops;
                         break;
+#ifdef CONFIG_CRASH_DUMP
+                case 12:
+                        filp->f_op = &oldmem_fops;
+                        break;
+#endif
                 default:
                         return -ENXIO;
         }
@@ -854,6 +925,9 @@ static const struct {
         {8, "random",  S_IRUGO | S_IWUSR,           &random_fops},
         {9, "urandom", S_IRUGO | S_IWUSR,           &urandom_fops},
         {11,"kmsg",    S_IRUGO | S_IWUSR,           &kmsg_fops},
+#ifdef CONFIG_CRASH_DUMP
+        {12,"oldmem",    S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops},
+#endif
 };
 
 static struct class *mem_class;