Merge branch 'akpm' (Andrew's patch-bomb)

Merge patches from Andrew Morton:
 "A few misc things and very nearly all of the MM tree.  A tremendous
  amount of stuff (again), including a significant rbtree library
  rework."

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (160 commits)
  sparc64: Support transparent huge pages.
  mm: thp: Use more portable PMD clearing sequenece in zap_huge_pmd().
  mm: Add and use update_mmu_cache_pmd() in transparent huge page code.
  sparc64: Document PGD and PMD layout.
  sparc64: Eliminate PTE table memory wastage.
  sparc64: Halve the size of PTE tables
  sparc64: Only support 4MB huge pages and 8KB base pages.
  memory-hotplug: suppress "Trying to free nonexistent resource <XXXXXXXXXXXXXXXX-YYYYYYYYYYYYYYYY>" warning
  mm: memcg: clean up mm_match_cgroup() signature
  mm: document PageHuge somewhat
  mm: use %pK for /proc/vmallocinfo
  mm, thp: fix mlock statistics
  mm, thp: fix mapped pages avoiding unevictable list on mlock
  memory-hotplug: update memory block's state and notify userspace
  memory-hotplug: preparation to notify memory block's state at memory hot remove
  mm: avoid section mismatch warning for memblock_type_name
  make GFP_NOTRACK definition unconditional
  cma: decrease cc.nr_migratepages after reclaiming pagelist
  CMA: migrate mlocked pages
  kpageflags: fix wrong KPF_THP on non-huge compound pages
  ...

23 files changed, 44 insertions, 148 deletions

diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index dd6f7ee1e312..c2483e97beee 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -738,6 +738,7 @@ v9fs_cached_file_write(struct file *filp, const char __user * data,
 static const struct vm_operations_struct v9fs_file_vm_ops = {
         .fault = filemap_fault,
         .page_mkwrite = v9fs_vm_page_mkwrite,
+        .remap_pages = generic_file_remap_pages,
 };
 
 
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 28a64e769527..e800dec958c3 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1123,7 +1123,7 @@ static unsigned long vma_dump_size(struct vm_area_struct *vma,
         if (always_dump_vma(vma))
                 goto whole;
 
-        if (vma->vm_flags & VM_NODUMP)
+        if (vma->vm_flags & VM_DONTDUMP)
                 return 0;
 
         /* Hugetlb memory check */
@@ -1135,7 +1135,7 @@ static unsigned long vma_dump_size(struct vm_area_struct *vma,
         }
 
         /* Do not dump I/O mapped devices or special mappings */
-        if (vma->vm_flags & (VM_IO | VM_RESERVED))
+        if (vma->vm_flags & VM_IO)
                 return 0;
 
         /* By default, dump shared memory if mapped from an anonymous file. */
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index 08d812b32282..262db114ff01 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -1205,7 +1205,7 @@ static int maydump(struct vm_area_struct *vma, unsigned long mm_flags)
         int dump_ok;
 
         /* Do not dump I/O mapped devices or special mappings */
-        if (vma->vm_flags & (VM_IO | VM_RESERVED)) {
+        if (vma->vm_flags & VM_IO) {
                 kdcore("%08lx: %08lx: no (IO)", vma->vm_start, vma->vm_flags);
                 return 0;
         }
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 5caf285c6e4d..f6b40e86121b 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1599,6 +1599,7 @@ out:
 static const struct vm_operations_struct btrfs_file_vm_ops = {
         .fault          = filemap_fault,
         .page_mkwrite   = btrfs_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };
 
 static int btrfs_file_mmap(struct file  *filp, struct vm_area_struct *vma)
@@ -1610,7 +1611,6 @@ static int btrfs_file_mmap(struct file	*filp, struct vm_area_struct *vma)
 
         file_accessed(filp);
         vma->vm_ops = &btrfs_file_vm_ops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
 
         return 0;
 }
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 22b6e4583faa..6690269f5dde 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -1224,6 +1224,7 @@ out:
 static struct vm_operations_struct ceph_vmops = {
         .fault          = filemap_fault,
         .page_mkwrite   = ceph_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };
 
 int ceph_mmap(struct file *file, struct vm_area_struct *vma)
@@ -1234,6 +1235,5 @@ int ceph_mmap(struct file *file, struct vm_area_struct *vma)
                 return -ENOEXEC;
         file_accessed(file);
         vma->vm_ops = &ceph_vmops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
         return 0;
 }
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 7d7bbdc4c8e7..edb25b4bbb95 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -3003,6 +3003,7 @@ cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 static struct vm_operations_struct cifs_file_vm_ops = {
         .fault = filemap_fault,
         .page_mkwrite = cifs_page_mkwrite,
+        .remap_pages = generic_file_remap_pages,
 };
 
 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
diff --git a/fs/exec.c b/fs/exec.c
index 19f4fb80cd17..4f2bebc276c5 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -603,7 +603,7 @@ static int shift_arg_pages(struct vm_area_struct *vma, unsigned long shift)
          * process cleanup to remove whatever mess we made.
          */
         if (length != move_page_tables(vma, old_start,
-                                       vma, new_start, length))
+                                       vma, new_start, length, false))
                 return -ENOMEM;
 
         lru_add_drain();
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index ca6f07afe601..bf3966bccd34 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -207,6 +207,7 @@ ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
 static const struct vm_operations_struct ext4_file_vm_ops = {
         .fault          = filemap_fault,
         .page_mkwrite   = ext4_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };
 
 static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
@@ -217,7 +218,6 @@ static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
                 return -ENOEXEC;
         file_accessed(file);
         vma->vm_ops = &ext4_file_vm_ops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
         return 0;
 }
 
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 8e1d7b9e4a33..401b6c6248ae 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -439,8 +439,7 @@ static void requeue_inode(struct inode *inode, struct bdi_writeback *wb,
  * setting I_SYNC flag and calling inode_sync_complete() to clear it.
  */
 static int
-__writeback_single_inode(struct inode *inode, struct bdi_writeback *wb,
-                         struct writeback_control *wbc)
+__writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
 {
         struct address_space *mapping = inode->i_mapping;
         long nr_to_write = wbc->nr_to_write;
@@ -527,7 +526,7 @@ writeback_single_inode(struct inode *inode, struct bdi_writeback *wb,
         inode->i_state |= I_SYNC;
         spin_unlock(&inode->i_lock);
 
-        ret = __writeback_single_inode(inode, wb, wbc);
+        ret = __writeback_single_inode(inode, wbc);
 
         spin_lock(&wb->list_lock);
         spin_lock(&inode->i_lock);
@@ -670,7 +669,7 @@ static long writeback_sb_inodes(struct super_block *sb,
                  * We use I_SYNC to pin the inode in memory. While it is set
                  * evict_inode() will wait so the inode cannot be freed.
                  */
-                __writeback_single_inode(inode, wb, &wbc);
+                __writeback_single_inode(inode, &wbc);
 
                 work->nr_pages -= write_chunk - wbc.nr_to_write;
                 wrote += write_chunk - wbc.nr_to_write;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index aba15f1b7ad2..78d2837bc940 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1379,6 +1379,7 @@ static const struct vm_operations_struct fuse_file_vm_ops = {
         .close          = fuse_vma_close,
         .fault          = filemap_fault,
         .page_mkwrite   = fuse_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };
 
 static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 30e21997a1a1..0def0504afc1 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -492,6 +492,7 @@ out:
 static const struct vm_operations_struct gfs2_vm_ops = {
         .fault = filemap_fault,
         .page_mkwrite = gfs2_page_mkwrite,
+        .remap_pages = generic_file_remap_pages,
 };
 
 /**
@@ -526,7 +527,6 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
                         return error;
         }
         vma->vm_ops = &gfs2_vm_ops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
 
         return 0;
 }
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 9460120a5170..c5bc355d8243 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -110,7 +110,7 @@ static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
          * way when do_mmap_pgoff unwinds (may be important on powerpc
          * and ia64).
          */
-        vma->vm_flags |= VM_HUGETLB | VM_RESERVED;
+        vma->vm_flags |= VM_HUGETLB | VM_DONTEXPAND | VM_DONTDUMP;
         vma->vm_ops = &hugetlb_vm_ops;
 
         if (vma->vm_pgoff & (~huge_page_mask(h) >> PAGE_SHIFT))
@@ -397,17 +397,16 @@ static void hugetlbfs_evict_inode(struct inode *inode)
 }
 
 static inline void
-hugetlb_vmtruncate_list(struct prio_tree_root *root, pgoff_t pgoff)
+hugetlb_vmtruncate_list(struct rb_root *root, pgoff_t pgoff)
 {
         struct vm_area_struct *vma;
-        struct prio_tree_iter iter;
 
-        vma_prio_tree_foreach(vma, &iter, root, pgoff, ULONG_MAX) {
+        vma_interval_tree_foreach(vma, root, pgoff, ULONG_MAX) {
                 unsigned long v_offset;
 
                 /*
                  * Can the expression below overflow on 32-bit arches?
-                 * No, because the prio_tree returns us only those vmas
+                 * No, because the interval tree returns us only those vmas
                  * which overlap the truncated area starting at pgoff,
                  * and no vma on a 32-bit arch can span beyond the 4GB.
                  */
@@ -432,7 +431,7 @@ static int hugetlb_vmtruncate(struct inode *inode, loff_t offset)
 
         i_size_write(inode, offset);
         mutex_lock(&mapping->i_mmap_mutex);
-        if (!prio_tree_empty(&mapping->i_mmap))
+        if (!RB_EMPTY_ROOT(&mapping->i_mmap))
                 hugetlb_vmtruncate_list(&mapping->i_mmap, pgoff);
         mutex_unlock(&mapping->i_mmap_mutex);
         truncate_hugepages(inode, offset);
diff --git a/fs/inode.c b/fs/inode.c
index ac8d904b3f16..b03c71957246 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -348,7 +348,7 @@ void address_space_init_once(struct address_space *mapping)
         mutex_init(&mapping->i_mmap_mutex);
         INIT_LIST_HEAD(&mapping->private_list);
         spin_lock_init(&mapping->private_lock);
-        INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
+        mapping->i_mmap = RB_ROOT;
         INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
 }
 EXPORT_SYMBOL(address_space_init_once);
diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index 1ea349fff68b..ae81b01e6fd7 100644
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -394,8 +394,11 @@ static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
 }
 
 /* Trivial function to remove the last node in the tree. Which by definition
-   has no right-hand -- so can be removed just by making its only child (if
-   any) take its place under its parent. */
+   has no right-hand child — so can be removed just by making its left-hand
+   child (if any) take its place under its parent. Since this is only done
+   when we're consuming the whole tree, there's no need to use rb_erase()
+   and let it worry about adjusting colours and balancing the tree. That
+   would just be a waste of time. */
 static void eat_last(struct rb_root *root, struct rb_node *node)
 {
         struct rb_node *parent = rb_parent(node);
@@ -412,12 +415,12 @@ static void eat_last(struct rb_root *root, struct rb_node *node)
                 link = &parent->rb_right;
 
         *link = node->rb_left;
-        /* Colour doesn't matter now. Only the parent pointer. */
         if (node->rb_left)
-                node->rb_left->rb_parent_color = node->rb_parent_color;
+                node->rb_left->__rb_parent_color = node->__rb_parent_color;
 }
 
-/* We put this in reverse order, so we can just use eat_last */
+/* We put the version tree in reverse order, so we can use the same eat_last()
+   function that we use to consume the tmpnode tree (tn_root). */
 static void ver_insert(struct rb_root *ver_root, struct jffs2_tmp_dnode_info *tn)
 {
         struct rb_node **link = &ver_root->rb_node;
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 6a7fcab7ecb3..f692be97676d 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -578,6 +578,7 @@ out:
 static const struct vm_operations_struct nfs_file_vm_ops = {
         .fault = filemap_fault,
         .page_mkwrite = nfs_vm_page_mkwrite,
+        .remap_pages = generic_file_remap_pages,
 };
 
 static int nfs_need_sync_write(struct file *filp, struct inode *inode)
diff --git a/fs/nilfs2/file.c b/fs/nilfs2/file.c
index 5b387a4c293e..16f35f7423c5 100644
--- a/fs/nilfs2/file.c
+++ b/fs/nilfs2/file.c
@@ -135,13 +135,13 @@ static int nilfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 static const struct vm_operations_struct nilfs_file_vm_ops = {
         .fault          = filemap_fault,
         .page_mkwrite   = nilfs_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };
 
 static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
         file_accessed(file);
         vma->vm_ops = &nilfs_file_vm_ops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
         return 0;
 }
 
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index d150372fd81d..47a87dda54ce 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -173,6 +173,7 @@ out:
 static const struct vm_operations_struct ocfs2_file_vm_ops = {
         .fault          = ocfs2_fault,
         .page_mkwrite   = ocfs2_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };
 
 int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
@@ -188,7 +189,6 @@ int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
         ocfs2_inode_unlock(file->f_dentry->d_inode, lock_level);
 out:
         vma->vm_ops = &ocfs2_file_vm_ops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
         return 0;
 }
 
diff --git a/fs/proc/base.c b/fs/proc/base.c
index d295af993677..ef5c84be66f9 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -873,111 +873,6 @@ static const struct file_operations proc_environ_operations = {
         .release        = mem_release,
 };
 
-static ssize_t oom_adjust_read(struct file *file, char __user *buf,
-                                size_t count, loff_t *ppos)
-{
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
-        char buffer[PROC_NUMBUF];
-        size_t len;
-        int oom_adjust = OOM_DISABLE;
-        unsigned long flags;
-
-        if (!task)
-                return -ESRCH;
-
-        if (lock_task_sighand(task, &flags)) {
-                oom_adjust = task->signal->oom_adj;
-                unlock_task_sighand(task, &flags);
-        }
-
-        put_task_struct(task);
-
-        len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
-
-        return simple_read_from_buffer(buf, count, ppos, buffer, len);
-}
-
-static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
-                                size_t count, loff_t *ppos)
-{
-        struct task_struct *task;
-        char buffer[PROC_NUMBUF];
-        int oom_adjust;
-        unsigned long flags;
-        int err;
-
-        memset(buffer, 0, sizeof(buffer));
-        if (count > sizeof(buffer) - 1)
-                count = sizeof(buffer) - 1;
-        if (copy_from_user(buffer, buf, count)) {
-                err = -EFAULT;
-                goto out;
-        }
-
-        err = kstrtoint(strstrip(buffer), 0, &oom_adjust);
-        if (err)
-                goto out;
-        if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) &&
-             oom_adjust != OOM_DISABLE) {
-                err = -EINVAL;
-                goto out;
-        }
-
-        task = get_proc_task(file->f_path.dentry->d_inode);
-        if (!task) {
-                err = -ESRCH;
-                goto out;
-        }
-
-        task_lock(task);
-        if (!task->mm) {
-                err = -EINVAL;
-                goto err_task_lock;
-        }
-
-        if (!lock_task_sighand(task, &flags)) {
-                err = -ESRCH;
-                goto err_task_lock;
-        }
-
-        if (oom_adjust < task->signal->oom_adj && !capable(CAP_SYS_RESOURCE)) {
-                err = -EACCES;
-                goto err_sighand;
-        }
-
-        /*
-         * Warn that /proc/pid/oom_adj is deprecated, see
-         * Documentation/feature-removal-schedule.txt.
-         */
-        printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
-                  current->comm, task_pid_nr(current), task_pid_nr(task),
-                  task_pid_nr(task));
-        task->signal->oom_adj = oom_adjust;
-        /*
-         * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
-         * value is always attainable.
-         */
-        if (task->signal->oom_adj == OOM_ADJUST_MAX)
-                task->signal->oom_score_adj = OOM_SCORE_ADJ_MAX;
-        else
-                task->signal->oom_score_adj = (oom_adjust * OOM_SCORE_ADJ_MAX) /
-                                                                -OOM_DISABLE;
-        trace_oom_score_adj_update(task);
-err_sighand:
-        unlock_task_sighand(task, &flags);
-err_task_lock:
-        task_unlock(task);
-        put_task_struct(task);
-out:
-        return err < 0 ? err : count;
-}
-
-static const struct file_operations proc_oom_adjust_operations = {
-        .read           = oom_adjust_read,
-        .write          = oom_adjust_write,
-        .llseek         = generic_file_llseek,
-};
-
 static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
                                         size_t count, loff_t *ppos)
 {
@@ -1051,15 +946,7 @@ static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
         if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
                 task->signal->oom_score_adj_min = oom_score_adj;
         trace_oom_score_adj_update(task);
-        /*
-         * Scale /proc/pid/oom_adj appropriately ensuring that OOM_DISABLE is
-         * always attainable.
-         */
-        if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
-                task->signal->oom_adj = OOM_DISABLE;
-        else
-                task->signal->oom_adj = (oom_score_adj * OOM_ADJUST_MAX) /
-                                                        OOM_SCORE_ADJ_MAX;
+
 err_sighand:
         unlock_task_sighand(task, &flags);
 err_task_lock:
@@ -2710,7 +2597,6 @@ static const struct pid_entry tgid_base_stuff[] = {
         REG("cgroup",  S_IRUGO, proc_cgroup_operations),
 #endif
         INF("oom_score",  S_IRUGO, proc_oom_score),
-        REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
         REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
@@ -3077,7 +2963,6 @@ static const struct pid_entry tid_base_stuff[] = {
         REG("cgroup",  S_IRUGO, proc_cgroup_operations),
 #endif
         INF("oom_score", S_IRUGO, proc_oom_score),
-        REG("oom_adj",   S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
         REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",  S_IWUSR|S_IRUGO, proc_loginuid_operations),
diff --git a/fs/proc/page.c b/fs/proc/page.c
index 7fcd0d60a968..b8730d9ebaee 100644
--- a/fs/proc/page.c
+++ b/fs/proc/page.c
@@ -115,7 +115,13 @@ u64 stable_page_flags(struct page *page)
                 u |= 1 << KPF_COMPOUND_TAIL;
         if (PageHuge(page))
                 u |= 1 << KPF_HUGE;
-        else if (PageTransCompound(page))
+        /*
+         * PageTransCompound can be true for non-huge compound pages (slab
+         * pages or pages allocated by drivers with __GFP_COMP) because it
+         * just checks PG_head/PG_tail, so we need to check PageLRU to make
+         * sure a given page is a thp, not a non-huge compound page.
+         */
+        else if (PageTransCompound(page) && PageLRU(compound_trans_head(page)))
                 u |= 1 << KPF_THP;
 
         /*
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index dcd56f84db7e..a781bdf06694 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -142,6 +142,7 @@ static int insert_entry(struct ctl_table_header *head, struct ctl_table *entry)
         }
 
         rb_link_node(node, parent, p);
+        rb_insert_color(node, &head->parent->root);
         return 0;
 }
 
@@ -168,10 +169,8 @@ static void init_header(struct ctl_table_header *head,
         head->node = node;
         if (node) {
                 struct ctl_table *entry;
-                for (entry = table; entry->procname; entry++, node++) {
-                        rb_init_node(&node->node);
+                for (entry = table; entry->procname; entry++, node++)
                         node->header = head;
-                }
         }
 }
 
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 4540b8f76f16..79827ce03e3b 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -54,7 +54,7 @@ void task_mem(struct seq_file *m, struct mm_struct *mm)
                 "VmPTE:\t%8lu kB\n"
                 "VmSwap:\t%8lu kB\n",
                 hiwater_vm << (PAGE_SHIFT-10),
-                (total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
+                total_vm << (PAGE_SHIFT-10),
                 mm->locked_vm << (PAGE_SHIFT-10),
                 mm->pinned_vm << (PAGE_SHIFT-10),
                 hiwater_rss << (PAGE_SHIFT-10),
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index ff48c5a85309..5bc77817f382 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1536,6 +1536,7 @@ out_unlock:
 static const struct vm_operations_struct ubifs_file_vm_ops = {
         .fault        = filemap_fault,
         .page_mkwrite = ubifs_vm_page_mkwrite,
+        .remap_pages = generic_file_remap_pages,
 };
 
 static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma)
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 1eaeb8be3aae..aa473fa640a2 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -940,7 +940,6 @@ xfs_file_mmap(
         struct vm_area_struct *vma)
 {
         vma->vm_ops = &xfs_file_vm_ops;
-        vma->vm_flags |= VM_CAN_NONLINEAR;
 
         file_accessed(filp);
         return 0;
@@ -1443,4 +1442,5 @@ const struct file_operations xfs_dir_file_operations = {
 static const struct vm_operations_struct xfs_file_vm_ops = {
         .fault          = filemap_fault,
         .page_mkwrite   = xfs_vm_page_mkwrite,
+        .remap_pages    = generic_file_remap_pages,
 };