mm: merge populate and nopage into fault (fixes nonlinear)

Nonlinear mappings are (AFAIKS) simply a virtual memory concept that encodes
the virtual address -> file offset differently from linear mappings.

->populate is a layering violation because the filesystem/pagecache code
should need to know anything about the virtual memory mapping.  The hitch here
is that the ->nopage handler didn't pass down enough information (ie.  pgoff).
 But it is more logical to pass pgoff rather than have the ->nopage function
calculate it itself anyway (because that's a similar layering violation).

Having the populate handler install the pte itself is likewise a nasty thing
to be doing.

This patch introduces a new fault handler that replaces ->nopage and
->populate and (later) ->nopfn.  Most of the old mechanism is still in place
so there is a lot of duplication and nice cleanups that can be removed if
everyone switches over.

The rationale for doing this in the first place is that nonlinear mappings are
subject to the pagefault vs invalidate/truncate race too, and it seemed stupid
to duplicate the synchronisation logic rather than just consolidate the two.

After this patch, MAP_NONBLOCK no longer sets up ptes for pages present in
pagecache.  Seems like a fringe functionality anyway.

NOPAGE_REFAULT is removed.  This should be implemented with ->fault, and no
users have hit mainline yet.

[akpm@linux-foundation.org: cleanup]
[randy.dunlap@oracle.com: doc. fixes for readahead]
[akpm@linux-foundation.org: build fix]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Cc: Mark Fasheh <mark.fasheh@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 72 insertions, 31 deletions

diff --git a/mm/fremap.c b/mm/fremap.c
index 4e3f53dd5fd4..01e51f01b84e 100644
--- a/mm/fremap.c
+++ b/mm/fremap.c
@@ -126,6 +126,25 @@ out:
         return err;
 }
 
+static int populate_range(struct mm_struct *mm, struct vm_area_struct *vma,
+                        unsigned long addr, unsigned long size, pgoff_t pgoff)
+{
+        int err;
+
+        do {
+                err = install_file_pte(mm, vma, addr, pgoff, vma->vm_page_prot);
+                if (err)
+                        return err;
+
+                size -= PAGE_SIZE;
+                addr += PAGE_SIZE;
+                pgoff++;
+        } while (size);
+
+        return 0;
+
+}
+
 /***
  * sys_remap_file_pages - remap arbitrary pages of a shared backing store
  *                        file within an existing vma.
@@ -183,41 +202,63 @@ asmlinkage long sys_remap_file_pages(unsigned long start, unsigned long size,
          * the single existing vma.  vm_private_data is used as a
          * swapout cursor in a VM_NONLINEAR vma.
          */
-        if (vma && (vma->vm_flags & VM_SHARED) &&
-                (!vma->vm_private_data || (vma->vm_flags & VM_NONLINEAR)) &&
-                vma->vm_ops && vma->vm_ops->populate &&
-                        end > start && start >= vma->vm_start &&
-                                end <= vma->vm_end) {
-
-                /* Must set VM_NONLINEAR before any pages are populated. */
-                if (pgoff != linear_page_index(vma, start) &&
-                    !(vma->vm_flags & VM_NONLINEAR)) {
-                        if (!has_write_lock) {
-                                up_read(&mm->mmap_sem);
-                                down_write(&mm->mmap_sem);
-                                has_write_lock = 1;
-                                goto retry;
+        if (!vma || !(vma->vm_flags & VM_SHARED))
+                goto out;
+
+        if (vma->vm_private_data && !(vma->vm_flags & VM_NONLINEAR))
+                goto out;
+
+        if ((!vma->vm_ops || !vma->vm_ops->populate) &&
+                                        !(vma->vm_flags & VM_CAN_NONLINEAR))
+                goto out;
+
+        if (end <= start || start < vma->vm_start || end > vma->vm_end)
+                goto out;
+
+        /* Must set VM_NONLINEAR before any pages are populated. */
+        if (!(vma->vm_flags & VM_NONLINEAR)) {
+                /* Don't need a nonlinear mapping, exit success */
+                if (pgoff == linear_page_index(vma, start)) {
+                        err = 0;
+                        goto out;
+                }
+
+                if (!has_write_lock) {
+                        up_read(&mm->mmap_sem);
+                        down_write(&mm->mmap_sem);
+                        has_write_lock = 1;
+                        goto retry;
+                }
+                mapping = vma->vm_file->f_mapping;
+                spin_lock(&mapping->i_mmap_lock);
+                flush_dcache_mmap_lock(mapping);
+                vma->vm_flags |= VM_NONLINEAR;
+                vma_prio_tree_remove(vma, &mapping->i_mmap);
+                vma_nonlinear_insert(vma, &mapping->i_mmap_nonlinear);
+                flush_dcache_mmap_unlock(mapping);
+                spin_unlock(&mapping->i_mmap_lock);
+        }
+
+        if (vma->vm_flags & VM_CAN_NONLINEAR) {
+                err = populate_range(mm, vma, start, size, pgoff);
+                if (!err && !(flags & MAP_NONBLOCK)) {
+                        if (unlikely(has_write_lock)) {
+                                downgrade_write(&mm->mmap_sem);
+                                has_write_lock = 0;
                         }
-                        mapping = vma->vm_file->f_mapping;
-                        spin_lock(&mapping->i_mmap_lock);
-                        flush_dcache_mmap_lock(mapping);
-                        vma->vm_flags |= VM_NONLINEAR;
-                        vma_prio_tree_remove(vma, &mapping->i_mmap);
-                        vma_nonlinear_insert(vma, &mapping->i_mmap_nonlinear);
-                        flush_dcache_mmap_unlock(mapping);
-                        spin_unlock(&mapping->i_mmap_lock);
+                        make_pages_present(start, start+size);
                 }
+        } else
+                err = vma->vm_ops->populate(vma, start, size, vma->vm_page_prot,
+                                                pgoff, flags & MAP_NONBLOCK);
 
-                err = vma->vm_ops->populate(vma, start, size,
-                                            vma->vm_page_prot,
-                                            pgoff, flags & MAP_NONBLOCK);
+        /*
+         * We can't clear VM_NONLINEAR because we'd have to do
+         * it after ->populate completes, and that would prevent
+         * downgrading the lock.  (Locks can't be upgraded).
+         */
 
-                /*
-                 * We can't clear VM_NONLINEAR because we'd have to do
-                 * it after ->populate completes, and that would prevent
-                 * downgrading the lock.  (Locks can't be upgraded).
-                 */
-        }
+out:
         if (likely(!has_write_lock))
                 up_read(&mm->mmap_sem);
         else