16 files changed, 253 insertions, 132 deletions

diff --git a/fs/proc/Kconfig b/fs/proc/Kconfig
index 15af6222f8a4..2183fcf41d59 100644
--- a/fs/proc/Kconfig
+++ b/fs/proc/Kconfig
@@ -31,6 +31,10 @@ config PROC_FS
 config PROC_KCORE
         bool "/proc/kcore support" if !ARM
         depends on PROC_FS && MMU
+        help
+          Provides a virtual ELF core file of the live kernel.  This can
+          be read with gdb and other ELF tools.  No modifications can be
+          made using this mechanism.
 
 config PROC_VMCORE
         bool "/proc/vmcore support"
diff --git a/fs/proc/array.c b/fs/proc/array.c
index cbd0f1b324b9..1bd2077187fd 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -183,6 +183,7 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
         seq_printf(m,
                 "State:\t%s\n"
                 "Tgid:\t%d\n"
+                "Ngid:\t%d\n"
                 "Pid:\t%d\n"
                 "PPid:\t%d\n"
                 "TracerPid:\t%d\n"
@@ -190,6 +191,7 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
                 "Gid:\t%d\t%d\t%d\t%d\n",
                 get_task_state(p),
                 task_tgid_nr_ns(p, ns),
+                task_numa_group_id(p),
                 pid_nr_ns(pid, ns),
                 ppid, tpid,
                 from_kuid_munged(user_ns, cred->uid),
diff --git a/fs/proc/consoles.c b/fs/proc/consoles.c
index b701eaa482bf..51942d5abcec 100644
--- a/fs/proc/consoles.c
+++ b/fs/proc/consoles.c
@@ -29,7 +29,6 @@ static int show_console_dev(struct seq_file *m, void *v)
         char flags[ARRAY_SIZE(con_flags) + 1];
         struct console *con = v;
         unsigned int a;
-        int len;
         dev_t dev = 0;
 
         if (con->device) {
@@ -47,11 +46,10 @@ static int show_console_dev(struct seq_file *m, void *v)
                         con_flags[a].name : ' ';
         flags[a] = 0;
 
-        seq_printf(m, "%s%d%n", con->name, con->index, &len);
-        len = 21 - len;
-        if (len < 1)
-                len = 1;
-        seq_printf(m, "%*c%c%c%c (%s)", len, ' ', con->read ? 'R' : '-',
+        seq_setwidth(m, 21 - 1);
+        seq_printf(m, "%s%d", con->name, con->index);
+        seq_pad(m, ' ');
+        seq_printf(m, "%c%c%c (%s)", con->read ? 'R' : '-',
                         con->write ? 'W' : '-', con->unblank ? 'U' : '-',
                         flags);
         if (dev)
diff --git a/fs/proc/fd.c b/fs/proc/fd.c
index 0ff80f9b930f..985ea881b5bc 100644
--- a/fs/proc/fd.c
+++ b/fs/proc/fd.c
@@ -286,7 +286,7 @@ int proc_fd_permission(struct inode *inode, int mask)
         int rv = generic_permission(inode, mask);
         if (rv == 0)
                 return 0;
-        if (task_pid(current) == proc_pid(inode))
+        if (task_tgid(current) == proc_pid(inode))
                 rv = 0;
         return rv;
 }
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 737e15615b04..cca93b6fb9a9 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -175,22 +175,6 @@ static const struct inode_operations proc_link_inode_operations = {
 };
 
 /*
- * As some entries in /proc are volatile, we want to 
- * get rid of unused dentries.  This could be made 
- * smarter: we could keep a "volatile" flag in the 
- * inode to indicate which ones to keep.
- */
-static int proc_delete_dentry(const struct dentry * dentry)
-{
-        return 1;
-}
-
-static const struct dentry_operations proc_dentry_operations =
-{
-        .d_delete       = proc_delete_dentry,
-};
-
-/*
  * Don't create negative dentries here, return -ENOENT by hand
  * instead.
  */
@@ -209,7 +193,7 @@ struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
                         inode = proc_get_inode(dir->i_sb, de);
                         if (!inode)
                                 return ERR_PTR(-ENOMEM);
-                        d_set_d_op(dentry, &proc_dentry_operations);
+                        d_set_d_op(dentry, &simple_dentry_operations);
                         d_add(dentry, inode);
                         return NULL;
                 }
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 073aea60cf8f..28955d4b7218 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -285,6 +285,28 @@ static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
         return rv;
 }
 
+static unsigned long
+proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr,
+                           unsigned long len, unsigned long pgoff,
+                           unsigned long flags)
+{
+        struct proc_dir_entry *pde = PDE(file_inode(file));
+        unsigned long rv = -EIO;
+        unsigned long (*get_area)(struct file *, unsigned long, unsigned long,
+                                  unsigned long, unsigned long) = NULL;
+        if (use_pde(pde)) {
+#ifdef CONFIG_MMU
+                get_area = current->mm->get_unmapped_area;
+#endif
+                if (pde->proc_fops->get_unmapped_area)
+                        get_area = pde->proc_fops->get_unmapped_area;
+                if (get_area)
+                        rv = get_area(file, orig_addr, len, pgoff, flags);
+                unuse_pde(pde);
+        }
+        return rv;
+}
+
 static int proc_reg_open(struct inode *inode, struct file *file)
 {
         struct proc_dir_entry *pde = PDE(inode);
@@ -356,6 +378,7 @@ static const struct file_operations proc_reg_file_ops = {
         .compat_ioctl   = proc_reg_compat_ioctl,
 #endif
         .mmap           = proc_reg_mmap,
+        .get_unmapped_area = proc_reg_get_unmapped_area,
         .open           = proc_reg_open,
         .release        = proc_reg_release,
 };
@@ -368,6 +391,7 @@ static const struct file_operations proc_reg_file_ops_no_compat = {
         .poll           = proc_reg_poll,
         .unlocked_ioctl = proc_reg_unlocked_ioctl,
         .mmap           = proc_reg_mmap,
+        .get_unmapped_area = proc_reg_get_unmapped_area,
         .open           = proc_reg_open,
         .release        = proc_reg_release,
 };
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index 06ea155e1a59..5ed0e52d6aa0 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -255,8 +255,7 @@ static int kcore_update_ram(void)
         end_pfn = 0;
         for_each_node_state(nid, N_MEMORY) {
                 unsigned long node_end;
-                node_end  = NODE_DATA(nid)->node_start_pfn +
-                        NODE_DATA(nid)->node_spanned_pages;
+                node_end = node_end_pfn(nid);
                 if (end_pfn < node_end)
                         end_pfn = node_end;
         }
diff --git a/fs/proc/meminfo.c b/fs/proc/meminfo.c
index 5aa847a603c0..a77d2b299199 100644
--- a/fs/proc/meminfo.c
+++ b/fs/proc/meminfo.c
@@ -1,8 +1,8 @@
 #include <linux/fs.h>
-#include <linux/hugetlb.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/hugetlb.h>
 #include <linux/mman.h>
 #include <linux/mmzone.h>
 #include <linux/proc_fs.h>
@@ -24,7 +24,6 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
 {
         struct sysinfo i;
         unsigned long committed;
-        unsigned long allowed;
         struct vmalloc_info vmi;
         long cached;
         unsigned long pages[NR_LRU_LISTS];
@@ -37,8 +36,6 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
         si_meminfo(&i);
         si_swapinfo(&i);
         committed = percpu_counter_read_positive(&vm_committed_as);
-        allowed = ((totalram_pages - hugetlb_total_pages())
-                * sysctl_overcommit_ratio / 100) + total_swap_pages;
 
         cached = global_page_state(NR_FILE_PAGES) -
                         total_swapcache_pages() - i.bufferram;
@@ -132,13 +129,7 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 K(i.freeswap),
                 K(global_page_state(NR_FILE_DIRTY)),
                 K(global_page_state(NR_WRITEBACK)),
-#ifdef CONFIG_TRANSPARENT_HUGEPAGE
-                K(global_page_state(NR_ANON_PAGES)
-                  + global_page_state(NR_ANON_TRANSPARENT_HUGEPAGES) *
-                  HPAGE_PMD_NR),
-#else
                 K(global_page_state(NR_ANON_PAGES)),
-#endif
                 K(global_page_state(NR_FILE_MAPPED)),
                 K(global_page_state(NR_SHMEM)),
                 K(global_page_state(NR_SLAB_RECLAIMABLE) +
@@ -153,7 +144,7 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 K(global_page_state(NR_UNSTABLE_NFS)),
                 K(global_page_state(NR_BOUNCE)),
                 K(global_page_state(NR_WRITEBACK_TEMP)),
-                K(allowed),
+                K(vm_commit_limit()),
                 K(committed),
                 (unsigned long)VMALLOC_TOTAL >> 10,
                 vmi.used >> 10,
diff --git a/fs/proc/namespaces.c b/fs/proc/namespaces.c
index 49a7fff2e83a..9ae46b87470d 100644
--- a/fs/proc/namespaces.c
+++ b/fs/proc/namespaces.c
@@ -42,12 +42,6 @@ static const struct inode_operations ns_inode_operations = {
         .setattr        = proc_setattr,
 };
 
-static int ns_delete_dentry(const struct dentry *dentry)
-{
-        /* Don't cache namespace inodes when not in use */
-        return 1;
-}
-
 static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 {
         struct inode *inode = dentry->d_inode;
@@ -59,7 +53,7 @@ static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 
 const struct dentry_operations ns_dentry_operations =
 {
-        .d_delete       = ns_delete_dentry,
+        .d_delete       = always_delete_dentry,
         .d_dname        = ns_dname,
 };
 
diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
index ccfd99bd1c5a..5f9bc8a746c9 100644
--- a/fs/proc/nommu.c
+++ b/fs/proc/nommu.c
@@ -39,7 +39,7 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region)
         unsigned long ino = 0;
         struct file *file;
         dev_t dev = 0;
-        int flags, len;
+        int flags;
 
         flags = region->vm_flags;
         file = region->vm_file;
@@ -50,8 +50,9 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region)
                 ino = inode->i_ino;
         }
 
+        seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
         seq_printf(m,
-                   "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n",
+                   "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
                    region->vm_start,
                    region->vm_end,
                    flags & VM_READ ? 'r' : '-',
@@ -59,13 +60,10 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region)
                    flags & VM_EXEC ? 'x' : '-',
                    flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p',
                    ((loff_t)region->vm_pgoff) << PAGE_SHIFT,
-                   MAJOR(dev), MINOR(dev), ino, &len);
+                   MAJOR(dev), MINOR(dev), ino);
 
         if (file) {
-                len = 25 + sizeof(void *) * 6 - len;
-                if (len < 1)
-                        len = 1;
-                seq_printf(m, "%*c", len, ' ');
+                seq_pad(m, ' ');
                 seq_path(m, &file->f_path, "");
         }
 
diff --git a/fs/proc/proc_devtree.c b/fs/proc/proc_devtree.c
index 106a83570630..70779b2fc209 100644
--- a/fs/proc/proc_devtree.c
+++ b/fs/proc/proc_devtree.c
@@ -14,16 +14,13 @@
 #include <linux/of.h>
 #include <linux/export.h>
 #include <linux/slab.h>
-#include <asm/prom.h>
 #include <asm/uaccess.h>
 #include "internal.h"
 
 static inline void set_node_proc_entry(struct device_node *np,
                                        struct proc_dir_entry *de)
 {
-#ifdef HAVE_ARCH_DEVTREE_FIXUPS
         np->pde = de;
-#endif
 }
 
 static struct proc_dir_entry *proc_device_tree;
diff --git a/fs/proc/root.c b/fs/proc/root.c
index e0a790da726d..87dbcbef7fe4 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -110,7 +110,11 @@ static struct dentry *proc_mount(struct file_system_type *fs_type,
                 ns = task_active_pid_ns(current);
                 options = data;
 
-                if (!current_user_ns()->may_mount_proc)
+                if (!capable(CAP_SYS_ADMIN) && !fs_fully_visible(fs_type))
+                        return ERR_PTR(-EPERM);
+
+                /* Does the mounter have privilege over the pid namespace? */
+                if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN))
                         return ERR_PTR(-EPERM);
         }
 
diff --git a/fs/proc/self.c b/fs/proc/self.c
index 6b6a993b5c25..ffeb202ec942 100644
--- a/fs/proc/self.c
+++ b/fs/proc/self.c
@@ -36,18 +36,10 @@ static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
         return NULL;
 }
 
-static void proc_self_put_link(struct dentry *dentry, struct nameidata *nd,
-                                void *cookie)
-{
-        char *s = nd_get_link(nd);
-        if (!IS_ERR(s))
-                kfree(s);
-}
-
 static const struct inode_operations proc_self_inode_operations = {
         .readlink       = proc_self_readlink,
         .follow_link    = proc_self_follow_link,
-        .put_link       = proc_self_put_link,
+        .put_link       = kfree_put_link,
 };
 
 static unsigned self_inum;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 107d026f5d6e..fb52b548080d 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -62,7 +62,8 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
                 total_rss << (PAGE_SHIFT-10),
                 data << (PAGE_SHIFT-10),
                 mm->stack_vm << (PAGE_SHIFT-10), text, lib,
-                (PTRS_PER_PTE*sizeof(pte_t)*mm->nr_ptes) >> 10,
+                (PTRS_PER_PTE * sizeof(pte_t) *
+                 atomic_long_read(&mm->nr_ptes)) >> 10,
                 swap << (PAGE_SHIFT-10));
 }
 
@@ -83,14 +84,6 @@ unsigned long task_statm(struct mm_struct *mm,
         return mm->total_vm;
 }
 
-static void pad_len_spaces(struct seq_file *m, int len)
-{
-        len = 25 + sizeof(void*) * 6 - len;
-        if (len < 1)
-                len = 1;
-        seq_printf(m, "%*c", len, ' ');
-}
-
 #ifdef CONFIG_NUMA
 /*
  * These functions are for numa_maps but called in generic **maps seq_file
@@ -268,7 +261,6 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
         unsigned long long pgoff = 0;
         unsigned long start, end;
         dev_t dev = 0;
-        int len;
         const char *name = NULL;
 
         if (file) {
@@ -286,7 +278,8 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
         if (stack_guard_page_end(vma, end))
                 end -= PAGE_SIZE;
 
-        seq_printf(m, "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n",
+        seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
+        seq_printf(m, "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
                         start,
                         end,
                         flags & VM_READ ? 'r' : '-',
@@ -294,14 +287,14 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
                         flags & VM_EXEC ? 'x' : '-',
                         flags & VM_MAYSHARE ? 's' : 'p',
                         pgoff,
-                        MAJOR(dev), MINOR(dev), ino, &len);
+                        MAJOR(dev), MINOR(dev), ino);
 
         /*
          * Print the dentry name for named mappings, and a
          * special [heap] marker for the heap:
          */
         if (file) {
-                pad_len_spaces(m, len);
+                seq_pad(m, ' ');
                 seq_path(m, &file->f_path, "\n");
                 goto done;
         }
@@ -333,7 +326,7 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
                                 name = "[stack]";
                         } else {
                                 /* Thread stack in /proc/PID/maps */
-                                pad_len_spaces(m, len);
+                                seq_pad(m, ' ');
                                 seq_printf(m, "[stack:%d]", tid);
                         }
                 }
@@ -341,7 +334,7 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
 
 done:
         if (name) {
-                pad_len_spaces(m, len);
+                seq_pad(m, ' ');
                 seq_puts(m, name);
         }
         seq_putc(m, '\n');
@@ -505,9 +498,9 @@ static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
         pte_t *pte;
         spinlock_t *ptl;
 
-        if (pmd_trans_huge_lock(pmd, vma) == 1) {
+        if (pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
                 smaps_pte_entry(*(pte_t *)pmd, addr, HPAGE_PMD_SIZE, walk);
-                spin_unlock(&walk->mm->page_table_lock);
+                spin_unlock(ptl);
                 mss->anonymous_thp += HPAGE_PMD_SIZE;
                 return 0;
         }
@@ -561,6 +554,9 @@ static void show_smap_vma_flags(struct seq_file *m, struct vm_area_struct *vma)
                 [ilog2(VM_NONLINEAR)]   = "nl",
                 [ilog2(VM_ARCH_1)]      = "ar",
                 [ilog2(VM_DONTDUMP)]    = "dd",
+#ifdef CONFIG_MEM_SOFT_DIRTY
+                [ilog2(VM_SOFTDIRTY)]   = "sd",
+#endif
                 [ilog2(VM_MIXEDMAP)]    = "mm",
                 [ilog2(VM_HUGEPAGE)]    = "hg",
                 [ilog2(VM_NOHUGEPAGE)]  = "nh",
@@ -740,6 +736,9 @@ static inline void clear_soft_dirty(struct vm_area_struct *vma,
                 ptent = pte_file_clear_soft_dirty(ptent);
         }
 
+        if (vma->vm_flags & VM_SOFTDIRTY)
+                vma->vm_flags &= ~VM_SOFTDIRTY;
+
         set_pte_at(vma->vm_mm, addr, pte, ptent);
 #endif
 }
@@ -938,6 +937,8 @@ static void pte_to_pagemap_entry(pagemap_entry_t *pme, struct pagemapread *pm,
                 frame = pte_pfn(pte);
                 flags = PM_PRESENT;
                 page = vm_normal_page(vma, addr, pte);
+                if (pte_soft_dirty(pte))
+                        flags2 |= __PM_SOFT_DIRTY;
         } else if (is_swap_pte(pte)) {
                 swp_entry_t entry;
                 if (pte_swp_soft_dirty(pte))
@@ -949,13 +950,15 @@ static void pte_to_pagemap_entry(pagemap_entry_t *pme, struct pagemapread *pm,
                 if (is_migration_entry(entry))
                         page = migration_entry_to_page(entry);
         } else {
-                *pme = make_pme(PM_NOT_PRESENT(pm->v2));
+                if (vma->vm_flags & VM_SOFTDIRTY)
+                        flags2 |= __PM_SOFT_DIRTY;
+                *pme = make_pme(PM_NOT_PRESENT(pm->v2) | PM_STATUS2(pm->v2, flags2));
                 return;
         }
 
         if (page && !PageAnon(page))
                 flags |= PM_FILE;
-        if (pte_soft_dirty(pte))
+        if ((vma->vm_flags & VM_SOFTDIRTY))
                 flags2 |= __PM_SOFT_DIRTY;
 
         *pme = make_pme(PM_PFRAME(frame) | PM_STATUS2(pm->v2, flags2) | flags);
@@ -974,7 +977,7 @@ static void thp_pmd_to_pagemap_entry(pagemap_entry_t *pme, struct pagemapread *p
                 *pme = make_pme(PM_PFRAME(pmd_pfn(pmd) + offset)
                                 | PM_STATUS2(pm->v2, pmd_flags2) | PM_PRESENT);
         else
-                *pme = make_pme(PM_NOT_PRESENT(pm->v2));
+                *pme = make_pme(PM_NOT_PRESENT(pm->v2) | PM_STATUS2(pm->v2, pmd_flags2));
 }
 #else
 static inline void thp_pmd_to_pagemap_entry(pagemap_entry_t *pme, struct pagemapread *pm,
@@ -988,16 +991,21 @@ static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
 {
         struct vm_area_struct *vma;
         struct pagemapread *pm = walk->private;
+        spinlock_t *ptl;
         pte_t *pte;
         int err = 0;
         pagemap_entry_t pme = make_pme(PM_NOT_PRESENT(pm->v2));
 
         /* find the first VMA at or above 'addr' */
         vma = find_vma(walk->mm, addr);
-        if (vma && pmd_trans_huge_lock(pmd, vma) == 1) {
+        if (vma && pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
                 int pmd_flags2;
 
-                pmd_flags2 = (pmd_soft_dirty(*pmd) ? __PM_SOFT_DIRTY : 0);
+                if ((vma->vm_flags & VM_SOFTDIRTY) || pmd_soft_dirty(*pmd))
+                        pmd_flags2 = __PM_SOFT_DIRTY;
+                else
+                        pmd_flags2 = 0;
+
                 for (; addr != end; addr += PAGE_SIZE) {
                         unsigned long offset;
 
@@ -1008,19 +1016,24 @@ static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
                         if (err)
                                 break;
                 }
-                spin_unlock(&walk->mm->page_table_lock);
+                spin_unlock(ptl);
                 return err;
         }
 
         if (pmd_trans_unstable(pmd))
                 return 0;
         for (; addr != end; addr += PAGE_SIZE) {
+                int flags2;
 
                 /* check to see if we've left 'vma' behind
                  * and need a new, higher one */
                 if (vma && (addr >= vma->vm_end)) {
                         vma = find_vma(walk->mm, addr);
-                        pme = make_pme(PM_NOT_PRESENT(pm->v2));
+                        if (vma && (vma->vm_flags & VM_SOFTDIRTY))
+                                flags2 = __PM_SOFT_DIRTY;
+                        else
+                                flags2 = 0;
+                        pme = make_pme(PM_NOT_PRESENT(pm->v2) | PM_STATUS2(pm->v2, flags2));
                 }
 
                 /* check that 'vma' actually covers this address,
@@ -1044,13 +1057,15 @@ static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
 
 #ifdef CONFIG_HUGETLB_PAGE
 static void huge_pte_to_pagemap_entry(pagemap_entry_t *pme, struct pagemapread *pm,
-                                        pte_t pte, int offset)
+                                        pte_t pte, int offset, int flags2)
 {
         if (pte_present(pte))
-                *pme = make_pme(PM_PFRAME(pte_pfn(pte) + offset)
-                                | PM_STATUS2(pm->v2, 0) | PM_PRESENT);
+                *pme = make_pme(PM_PFRAME(pte_pfn(pte) + offset)        |
+                                PM_STATUS2(pm->v2, flags2)              |
+                                PM_PRESENT);
         else
-                *pme = make_pme(PM_NOT_PRESENT(pm->v2));
+                *pme = make_pme(PM_NOT_PRESENT(pm->v2)                  |
+                                PM_STATUS2(pm->v2, flags2));
 }
 
 /* This function walks within one hugetlb entry in the single call */
@@ -1059,12 +1074,22 @@ static int pagemap_hugetlb_range(pte_t *pte, unsigned long hmask,
                                  struct mm_walk *walk)
 {
         struct pagemapread *pm = walk->private;
+        struct vm_area_struct *vma;
         int err = 0;
+        int flags2;
         pagemap_entry_t pme;
 
+        vma = find_vma(walk->mm, addr);
+        WARN_ON_ONCE(!vma);
+
+        if (vma && (vma->vm_flags & VM_SOFTDIRTY))
+                flags2 = __PM_SOFT_DIRTY;
+        else
+                flags2 = 0;
+
         for (; addr != end; addr += PAGE_SIZE) {
                 int offset = (addr & ~hmask) >> PAGE_SHIFT;
-                huge_pte_to_pagemap_entry(&pme, pm, *pte, offset);
+                huge_pte_to_pagemap_entry(&pme, pm, *pte, offset, flags2);
                 err = add_to_pagemap(addr, &pme, pm);
                 if (err)
                         return err;
@@ -1293,7 +1318,7 @@ static int gather_pte_stats(pmd_t *pmd, unsigned long addr,
 
         md = walk->private;
 
-        if (pmd_trans_huge_lock(pmd, md->vma) == 1) {
+        if (pmd_trans_huge_lock(pmd, md->vma, &ptl) == 1) {
                 pte_t huge_pte = *(pte_t *)pmd;
                 struct page *page;
 
@@ -1301,7 +1326,7 @@ static int gather_pte_stats(pmd_t *pmd, unsigned long addr,
                 if (page)
                         gather_stats(page, md, pte_dirty(huge_pte),
                                      HPAGE_PMD_SIZE/PAGE_SIZE);
-                spin_unlock(&walk->mm->page_table_lock);
+                spin_unlock(ptl);
                 return 0;
         }
 
@@ -1359,8 +1384,8 @@ static int show_numa_map(struct seq_file *m, void *v, int is_pid)
         struct mm_struct *mm = vma->vm_mm;
         struct mm_walk walk = {};
         struct mempolicy *pol;
-        int n;
-        char buffer[50];
+        char buffer[64];
+        int nid;
 
         if (!mm)
                 return 0;
@@ -1430,9 +1455,9 @@ static int show_numa_map(struct seq_file *m, void *v, int is_pid)
         if (md->writeback)
                 seq_printf(m, " writeback=%lu", md->writeback);
 
-        for_each_node_state(n, N_MEMORY)
-                if (md->node[n])
-                        seq_printf(m, " N%d=%lu", n, md->node[n]);
+        for_each_node_state(nid, N_MEMORY)
+                if (md->node[nid])
+                        seq_printf(m, " N%d=%lu", nid, md->node[nid]);
 out:
         seq_putc(m, '\n');
 
diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
index 56123a6f462e..678455d2d683 100644
--- a/fs/proc/task_nommu.c
+++ b/fs/proc/task_nommu.c
@@ -123,14 +123,6 @@ unsigned long task_statm(struct mm_struct *mm,
         return size;
 }
 
-static void pad_len_spaces(struct seq_file *m, int len)
-{
-        len = 25 + sizeof(void*) * 6 - len;
-        if (len < 1)
-                len = 1;
-        seq_printf(m, "%*c", len, ' ');
-}
-
 /*
  * display a single VMA to a sequenced file
  */
@@ -142,7 +134,7 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
         unsigned long ino = 0;
         struct file *file;
         dev_t dev = 0;
-        int flags, len;
+        int flags;
         unsigned long long pgoff = 0;
 
         flags = vma->vm_flags;
@@ -155,8 +147,9 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
                 pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
         }
 
+        seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
         seq_printf(m,
-                   "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n",
+                   "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
                    vma->vm_start,
                    vma->vm_end,
                    flags & VM_READ ? 'r' : '-',
@@ -164,16 +157,16 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
                    flags & VM_EXEC ? 'x' : '-',
                    flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p',
                    pgoff,
-                   MAJOR(dev), MINOR(dev), ino, &len);
+                   MAJOR(dev), MINOR(dev), ino);
 
         if (file) {
-                pad_len_spaces(m, len);
+                seq_pad(m, ' ');
                 seq_path(m, &file->f_path, "");
         } else if (mm) {
                 pid_t tid = vm_is_stack(priv->task, vma, is_pid);
 
                 if (tid != 0) {
-                        pad_len_spaces(m, len);
+                        seq_pad(m, ' ');
                         /*
                          * Thread stack in /proc/PID/task/TID/maps or
                          * the main process stack.
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index a1a16eb97c7b..9100d6959886 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -21,6 +21,7 @@
 #include <linux/crash_dump.h>
 #include <linux/list.h>
 #include <linux/vmalloc.h>
+#include <linux/pagemap.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include "internal.h"
@@ -123,11 +124,65 @@ static ssize_t read_from_oldmem(char *buf, size_t count,
         return read;
 }
 
+/*
+ * Architectures may override this function to allocate ELF header in 2nd kernel
+ */
+int __weak elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
+{
+        return 0;
+}
+
+/*
+ * Architectures may override this function to free header
+ */
+void __weak elfcorehdr_free(unsigned long long addr)
+{}
+
+/*
+ * Architectures may override this function to read from ELF header
+ */
+ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos)
+{
+        return read_from_oldmem(buf, count, ppos, 0);
+}
+
+/*
+ * Architectures may override this function to read from notes sections
+ */
+ssize_t __weak elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos)
+{
+        return read_from_oldmem(buf, count, ppos, 0);
+}
+
+/*
+ * Architectures may override this function to map oldmem
+ */
+int __weak remap_oldmem_pfn_range(struct vm_area_struct *vma,
+                                  unsigned long from, unsigned long pfn,
+                                  unsigned long size, pgprot_t prot)
+{
+        return remap_pfn_range(vma, from, pfn, size, prot);
+}
+
+/*
+ * Copy to either kernel or user space
+ */
+static int copy_to(void *target, void *src, size_t size, int userbuf)
+{
+        if (userbuf) {
+                if (copy_to_user((char __user *) target, src, size))
+                        return -EFAULT;
+        } else {
+                memcpy(target, src, size);
+        }
+        return 0;
+}
+
 /* Read from the ELF header and then the crash dump. On error, negative value is
  * returned otherwise number of bytes read are returned.
  */
-static ssize_t read_vmcore(struct file *file, char __user *buffer,
-                                size_t buflen, loff_t *fpos)
+static ssize_t __read_vmcore(char *buffer, size_t buflen, loff_t *fpos,
+                             int userbuf)
 {
         ssize_t acc = 0, tmp;
         size_t tsz;
@@ -144,7 +199,7 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer,
         /* Read ELF core header */
         if (*fpos < elfcorebuf_sz) {
                 tsz = min(elfcorebuf_sz - (size_t)*fpos, buflen);
-                if (copy_to_user(buffer, elfcorebuf + *fpos, tsz))
+                if (copy_to(buffer, elfcorebuf + *fpos, tsz, userbuf))
                         return -EFAULT;
                 buflen -= tsz;
                 *fpos += tsz;
@@ -162,7 +217,7 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer,
 
                 tsz = min(elfcorebuf_sz + elfnotes_sz - (size_t)*fpos, buflen);
                 kaddr = elfnotes_buf + *fpos - elfcorebuf_sz;
-                if (copy_to_user(buffer, kaddr, tsz))
+                if (copy_to(buffer, kaddr, tsz, userbuf))
                         return -EFAULT;
                 buflen -= tsz;
                 *fpos += tsz;
@@ -178,7 +233,7 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer,
                 if (*fpos < m->offset + m->size) {
                         tsz = min_t(size_t, m->offset + m->size - *fpos, buflen);
                         start = m->paddr + *fpos - m->offset;
-                        tmp = read_from_oldmem(buffer, tsz, &start, 1);
+                        tmp = read_from_oldmem(buffer, tsz, &start, userbuf);
                         if (tmp < 0)
                                 return tmp;
                         buflen -= tsz;
@@ -195,6 +250,55 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer,
         return acc;
 }
 
+static ssize_t read_vmcore(struct file *file, char __user *buffer,
+                           size_t buflen, loff_t *fpos)
+{
+        return __read_vmcore((__force char *) buffer, buflen, fpos, 1);
+}
+
+/*
+ * The vmcore fault handler uses the page cache and fills data using the
+ * standard __vmcore_read() function.
+ *
+ * On s390 the fault handler is used for memory regions that can't be mapped
+ * directly with remap_pfn_range().
+ */
+static int mmap_vmcore_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+#ifdef CONFIG_S390
+        struct address_space *mapping = vma->vm_file->f_mapping;
+        pgoff_t index = vmf->pgoff;
+        struct page *page;
+        loff_t offset;
+        char *buf;
+        int rc;
+
+        page = find_or_create_page(mapping, index, GFP_KERNEL);
+        if (!page)
+                return VM_FAULT_OOM;
+        if (!PageUptodate(page)) {
+                offset = (loff_t) index << PAGE_CACHE_SHIFT;
+                buf = __va((page_to_pfn(page) << PAGE_SHIFT));
+                rc = __read_vmcore(buf, PAGE_SIZE, &offset, 0);
+                if (rc < 0) {
+                        unlock_page(page);
+                        page_cache_release(page);
+                        return (rc == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS;
+                }
+                SetPageUptodate(page);
+        }
+        unlock_page(page);
+        vmf->page = page;
+        return 0;
+#else
+        return VM_FAULT_SIGBUS;
+#endif
+}
+
+static const struct vm_operations_struct vmcore_mmap_ops = {
+        .fault = mmap_vmcore_fault,
+};
+
 /**
  * alloc_elfnotes_buf - allocate buffer for ELF note segment in
  *                      vmalloc memory
@@ -223,7 +327,7 @@ static inline char *alloc_elfnotes_buf(size_t notes_sz)
  * regions in the 1st kernel pointed to by PT_LOAD entries) into
  * virtually contiguous user-space in ELF layout.
  */
-#if defined(CONFIG_MMU) && !defined(CONFIG_S390)
+#ifdef CONFIG_MMU
 static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 {
         size_t size = vma->vm_end - vma->vm_start;
@@ -241,6 +345,7 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
         vma->vm_flags &= ~(VM_MAYWRITE | VM_MAYEXEC);
         vma->vm_flags |= VM_MIXEDMAP;
+        vma->vm_ops = &vmcore_mmap_ops;
 
         len = 0;
 
@@ -282,9 +387,9 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
                         tsz = min_t(size_t, m->offset + m->size - start, size);
                         paddr = m->paddr + start - m->offset;
-                        if (remap_pfn_range(vma, vma->vm_start + len,
-                                            paddr >> PAGE_SHIFT, tsz,
-                                            vma->vm_page_prot))
+                        if (remap_oldmem_pfn_range(vma, vma->vm_start + len,
+                                                   paddr >> PAGE_SHIFT, tsz,
+                                                   vma->vm_page_prot))
                                 goto fail;
                         size -= tsz;
                         start += tsz;
@@ -357,7 +462,7 @@ static int __init update_note_header_size_elf64(const Elf64_Ehdr *ehdr_ptr)
                 notes_section = kmalloc(max_sz, GFP_KERNEL);
                 if (!notes_section)
                         return -ENOMEM;
-                rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+                rc = elfcorehdr_read_notes(notes_section, max_sz, &offset);
                 if (rc < 0) {
                         kfree(notes_section);
                         return rc;
@@ -444,7 +549,8 @@ static int __init copy_notes_elf64(const Elf64_Ehdr *ehdr_ptr, char *notes_buf)
                 if (phdr_ptr->p_type != PT_NOTE)
                         continue;
                 offset = phdr_ptr->p_offset;
-                rc = read_from_oldmem(notes_buf, phdr_ptr->p_memsz, &offset, 0);
+                rc = elfcorehdr_read_notes(notes_buf, phdr_ptr->p_memsz,
+                                           &offset);
                 if (rc < 0)
                         return rc;
                 notes_buf += phdr_ptr->p_memsz;
@@ -536,7 +642,7 @@ static int __init update_note_header_size_elf32(const Elf32_Ehdr *ehdr_ptr)
                 notes_section = kmalloc(max_sz, GFP_KERNEL);
                 if (!notes_section)
                         return -ENOMEM;
-                rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+                rc = elfcorehdr_read_notes(notes_section, max_sz, &offset);
                 if (rc < 0) {
                         kfree(notes_section);
                         return rc;
@@ -623,7 +729,8 @@ static int __init copy_notes_elf32(const Elf32_Ehdr *ehdr_ptr, char *notes_buf)
                 if (phdr_ptr->p_type != PT_NOTE)
                         continue;
                 offset = phdr_ptr->p_offset;
-                rc = read_from_oldmem(notes_buf, phdr_ptr->p_memsz, &offset, 0);
+                rc = elfcorehdr_read_notes(notes_buf, phdr_ptr->p_memsz,
+                                           &offset);
                 if (rc < 0)
                         return rc;
                 notes_buf += phdr_ptr->p_memsz;
@@ -810,7 +917,7 @@ static int __init parse_crash_elf64_headers(void)
         addr = elfcorehdr_addr;
 
         /* Read Elf header */
-        rc = read_from_oldmem((char*)&ehdr, sizeof(Elf64_Ehdr), &addr, 0);
+        rc = elfcorehdr_read((char *)&ehdr, sizeof(Elf64_Ehdr), &addr);
         if (rc < 0)
                 return rc;
 
@@ -837,7 +944,7 @@ static int __init parse_crash_elf64_headers(void)
         if (!elfcorebuf)
                 return -ENOMEM;
         addr = elfcorehdr_addr;
-        rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz_orig, &addr, 0);
+        rc = elfcorehdr_read(elfcorebuf, elfcorebuf_sz_orig, &addr);
         if (rc < 0)
                 goto fail;
 
@@ -866,7 +973,7 @@ static int __init parse_crash_elf32_headers(void)
         addr = elfcorehdr_addr;
 
         /* Read Elf header */
-        rc = read_from_oldmem((char*)&ehdr, sizeof(Elf32_Ehdr), &addr, 0);
+        rc = elfcorehdr_read((char *)&ehdr, sizeof(Elf32_Ehdr), &addr);
         if (rc < 0)
                 return rc;
 
@@ -892,7 +999,7 @@ static int __init parse_crash_elf32_headers(void)
         if (!elfcorebuf)
                 return -ENOMEM;
         addr = elfcorehdr_addr;
-        rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz_orig, &addr, 0);
+        rc = elfcorehdr_read(elfcorebuf, elfcorebuf_sz_orig, &addr);
         if (rc < 0)
                 goto fail;
 
@@ -919,7 +1026,7 @@ static int __init parse_crash_elf_headers(void)
         int rc=0;
 
         addr = elfcorehdr_addr;
-        rc = read_from_oldmem(e_ident, EI_NIDENT, &addr, 0);
+        rc = elfcorehdr_read(e_ident, EI_NIDENT, &addr);
         if (rc < 0)
                 return rc;
         if (memcmp(e_ident, ELFMAG, SELFMAG) != 0) {
@@ -952,7 +1059,14 @@ static int __init vmcore_init(void)
 {
         int rc = 0;
 
-        /* If elfcorehdr= has been passed in cmdline, then capture the dump.*/
+        /* Allow architectures to allocate ELF header in 2nd kernel */
+        rc = elfcorehdr_alloc(&elfcorehdr_addr, &elfcorehdr_size);
+        if (rc)
+                return rc;
+        /*
+         * If elfcorehdr= has been passed in cmdline or created in 2nd kernel,
+         * then capture the dump.
+         */
         if (!(is_vmcore_usable()))
                 return rc;
         rc = parse_crash_elf_headers();
@@ -960,6 +1074,8 @@ static int __init vmcore_init(void)
                 pr_warn("Kdump: vmcore not initialized\n");
                 return rc;
         }
+        elfcorehdr_free(elfcorehdr_addr);
+        elfcorehdr_addr = ELFCORE_ADDR_ERR;
 
         proc_vmcore = proc_create("vmcore", S_IRUSR, NULL, &proc_vmcore_operations);
         if (proc_vmcore)