7 files changed, 53 insertions, 52 deletions

diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
index 26c888890c24..ce90032c010e 100644
--- a/fs/gfs2/ops_address.c
+++ b/fs/gfs2/ops_address.c
@@ -251,7 +251,7 @@ static int gfs2_readpage(struct file *file, struct page *page)
                 if (file) {
                         gf = file->private_data;
                         if (test_bit(GFF_EXLOCK, &gf->f_flags))
-                                /* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
+                                /* gfs2_sharewrite_fault has grabbed the ip->i_gl already */
                                 goto skip_lock;
                 }
                 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/ops_file.c
index bad0b24cb773..581ac11b2656 100644
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/ops_file.c
@@ -364,7 +364,7 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
         else
                 vma->vm_ops = &gfs2_vm_ops_private;
 
-        vma->vm_flags |= VM_CAN_INVALIDATE;
+        vma->vm_flags |= VM_CAN_INVALIDATE|VM_CAN_NONLINEAR;
 
         gfs2_glock_dq_uninit(&i_gh);
 
diff --git a/fs/gfs2/ops_vm.c b/fs/gfs2/ops_vm.c
index d5a98cbfebdc..e9fe6eb74e75 100644
--- a/fs/gfs2/ops_vm.c
+++ b/fs/gfs2/ops_vm.c
@@ -27,13 +27,13 @@
 #include "trans.h"
 #include "util.h"
 
-static struct page *gfs2_private_nopage(struct vm_area_struct *area,
-                                        unsigned long address, int *type)
+static struct page *gfs2_private_fault(struct vm_area_struct *vma,
+                                        struct fault_data *fdata)
 {
-        struct gfs2_inode *ip = GFS2_I(area->vm_file->f_mapping->host);
+        struct gfs2_inode *ip = GFS2_I(vma->vm_file->f_mapping->host);
 
         set_bit(GIF_PAGED, &ip->i_flags);
-        return filemap_nopage(area, address, type);
+        return filemap_fault(vma, fdata);
 }
 
 static int alloc_page_backing(struct gfs2_inode *ip, struct page *page)
@@ -104,16 +104,14 @@ out:
         return error;
 }
 
-static struct page *gfs2_sharewrite_nopage(struct vm_area_struct *area,
-                                           unsigned long address, int *type)
+static struct page *gfs2_sharewrite_fault(struct vm_area_struct *vma,
+                                                struct fault_data *fdata)
 {
-        struct file *file = area->vm_file;
+        struct file *file = vma->vm_file;
         struct gfs2_file *gf = file->private_data;
         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
         struct gfs2_holder i_gh;
         struct page *result = NULL;
-        unsigned long index = ((address - area->vm_start) >> PAGE_CACHE_SHIFT) +
-                              area->vm_pgoff;
         int alloc_required;
         int error;
 
@@ -124,23 +122,27 @@ static struct page *gfs2_sharewrite_nopage(struct vm_area_struct *area,
         set_bit(GIF_PAGED, &ip->i_flags);
         set_bit(GIF_SW_PAGED, &ip->i_flags);
 
-        error = gfs2_write_alloc_required(ip, (u64)index << PAGE_CACHE_SHIFT,
-                                          PAGE_CACHE_SIZE, &alloc_required);
-        if (error)
+        error = gfs2_write_alloc_required(ip,
+                                        (u64)fdata->pgoff << PAGE_CACHE_SHIFT,
+                                        PAGE_CACHE_SIZE, &alloc_required);
+        if (error) {
+                fdata->type = VM_FAULT_OOM; /* XXX: are these right? */
                 goto out;
+        }
 
         set_bit(GFF_EXLOCK, &gf->f_flags);
-        result = filemap_nopage(area, address, type);
+        result = filemap_fault(vma, fdata);
         clear_bit(GFF_EXLOCK, &gf->f_flags);
-        if (!result || result == NOPAGE_OOM)
+        if (!result)
                 goto out;
 
         if (alloc_required) {
                 error = alloc_page_backing(ip, result);
                 if (error) {
-                        if (area->vm_flags & VM_CAN_INVALIDATE)
+                        if (vma->vm_flags & VM_CAN_INVALIDATE)
                                 unlock_page(result);
                         page_cache_release(result);
+                        fdata->type = VM_FAULT_OOM;
                         result = NULL;
                         goto out;
                 }
@@ -154,10 +156,10 @@ out:
 }
 
 struct vm_operations_struct gfs2_vm_ops_private = {
-        .nopage = gfs2_private_nopage,
+        .fault = gfs2_private_fault,
 };
 
 struct vm_operations_struct gfs2_vm_ops_sharewrite = {
-        .nopage = gfs2_sharewrite_nopage,
+        .fault = gfs2_sharewrite_fault,
 };
 
diff --git a/fs/ncpfs/mmap.c b/fs/ncpfs/mmap.c
index 5416673418b8..af48b792ca04 100644
--- a/fs/ncpfs/mmap.c
+++ b/fs/ncpfs/mmap.c
@@ -25,8 +25,8 @@
 /*
  * Fill in the supplied page for mmap
  */
-static struct page* ncp_file_mmap_nopage(struct vm_area_struct *area,
-                                     unsigned long address, int *type)
+static struct page* ncp_file_mmap_fault(struct vm_area_struct *area,
+                                                struct fault_data *fdata)
 {
         struct file *file = area->vm_file;
         struct dentry *dentry = file->f_path.dentry;
@@ -40,15 +40,17 @@ static struct page* ncp_file_mmap_nopage(struct vm_area_struct *area,
 
         page = alloc_page(GFP_HIGHUSER); /* ncpfs has nothing against high pages
                    as long as recvmsg and memset works on it */
-        if (!page)
-                return page;
+        if (!page) {
+                fdata->type = VM_FAULT_OOM;
+                return NULL;
+        }
         pg_addr = kmap(page);
-        address &= PAGE_MASK;
-        pos = address - area->vm_start + (area->vm_pgoff << PAGE_SHIFT);
+        pos = fdata->pgoff << PAGE_SHIFT;
 
         count = PAGE_SIZE;
-        if (address + PAGE_SIZE > area->vm_end) {
-                count = area->vm_end - address;
+        if (fdata->address + PAGE_SIZE > area->vm_end) {
+                WARN_ON(1); /* shouldn't happen? */
+                count = area->vm_end - fdata->address;
         }
         /* what we can read in one go */
         bufsize = NCP_SERVER(inode)->buffer_size;
@@ -91,15 +93,14 @@ static struct page* ncp_file_mmap_nopage(struct vm_area_struct *area,
          * fetches from the network, here the analogue of disk.
          * -- wli
          */
-        if (type)
-                *type = VM_FAULT_MAJOR;
+        fdata->type = VM_FAULT_MAJOR;
         count_vm_event(PGMAJFAULT);
         return page;
 }
 
 static struct vm_operations_struct ncp_file_mmap =
 {
-        .nopage = ncp_file_mmap_nopage,
+        .fault = ncp_file_mmap_fault,
 };
 
 
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 84bf6e79de23..460d440310f2 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -232,7 +232,7 @@ static int ocfs2_readpage(struct file *file, struct page *page)
          * might now be discovering a truncate that hit on another node.
          * block_read_full_page->get_block freaks out if it is asked to read
          * beyond the end of a file, so we check here.  Callers
-         * (generic_file_read, fault->nopage) are clever enough to check i_size
+         * (generic_file_read, vm_ops->fault) are clever enough to check i_size
          * and notice that the page they just read isn't needed.
          *
          * XXX sys_readahead() seems to get that wrong?
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index 904f39ff5340..cd75508b1c8a 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -60,24 +60,23 @@ static inline int ocfs2_vm_op_unblock_sigs(sigset_t *oldset)
         return sigprocmask(SIG_SETMASK, oldset, NULL);
 }
 
-static struct page *ocfs2_nopage(struct vm_area_struct * area,
-                                 unsigned long address,
-                                 int *type)
+static struct page *ocfs2_fault(struct vm_area_struct *area,
+                                                struct fault_data *fdata)
 {
-        struct page *page = NOPAGE_SIGBUS;
+        struct page *page = NULL;
         sigset_t blocked, oldset;
         int ret;
 
-        mlog_entry("(area=%p, address=%lu, type=%p)\n", area, address,
-                   type);
+        mlog_entry("(area=%p, page offset=%lu)\n", area, fdata->pgoff);
 
         ret = ocfs2_vm_op_block_sigs(&blocked, &oldset);
         if (ret < 0) {
+                fdata->type = VM_FAULT_SIGBUS;
                 mlog_errno(ret);
                 goto out;
         }
 
-        page = filemap_nopage(area, address, type);
+        page = filemap_fault(area, fdata);
 
         ret = ocfs2_vm_op_unblock_sigs(&oldset);
         if (ret < 0)
@@ -209,7 +208,7 @@ out:
 }
 
 static struct vm_operations_struct ocfs2_file_vm_ops = {
-        .nopage         = ocfs2_nopage,
+        .fault          = ocfs2_fault,
         .page_mkwrite   = ocfs2_page_mkwrite,
 };
 
@@ -226,7 +225,7 @@ int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
         ocfs2_meta_unlock(file->f_dentry->d_inode, lock_level);
 out:
         vma->vm_ops = &ocfs2_file_vm_ops;
-        vma->vm_flags |= VM_CAN_INVALIDATE;
+        vma->vm_flags |= VM_CAN_INVALIDATE | VM_CAN_NONLINEAR;
         return 0;
 }
 
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 92b2f225712f..f12e80a69c68 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -213,18 +213,19 @@ xfs_file_fsync(
 
 #ifdef CONFIG_XFS_DMAPI
 STATIC struct page *
-xfs_vm_nopage(
-        struct vm_area_struct   *area,
-        unsigned long           address,
-        int                     *type)
+xfs_vm_fault(
+        struct vm_area_struct   *vma,
+        struct fault_data       *fdata)
 {
-        struct inode    *inode = area->vm_file->f_path.dentry->d_inode;
+        struct inode    *inode = vma->vm_file->f_path.dentry->d_inode;
         bhv_vnode_t     *vp = vn_from_inode(inode);
 
         ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
-        if (XFS_SEND_MMAP(XFS_VFSTOM(vp->v_vfsp), area, 0))
+        if (XFS_SEND_MMAP(XFS_VFSTOM(vp->v_vfsp), vma, 0)) {
+                fdata->type = VM_FAULT_SIGBUS;
                 return NULL;
-        return filemap_nopage(area, address, type);
+        }
+        return filemap_fault(vma, fdata);
 }
 #endif /* CONFIG_XFS_DMAPI */
 
@@ -310,7 +311,7 @@ xfs_file_mmap(
         struct vm_area_struct *vma)
 {
         vma->vm_ops = &xfs_file_vm_ops;
-        vma->vm_flags |= VM_CAN_INVALIDATE;
+        vma->vm_flags |= VM_CAN_INVALIDATE | VM_CAN_NONLINEAR;
 
 #ifdef CONFIG_XFS_DMAPI
         if (vn_from_inode(filp->f_path.dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI)
@@ -465,14 +466,12 @@ const struct file_operations xfs_dir_file_operations = {
 };
 
 static struct vm_operations_struct xfs_file_vm_ops = {
-        .nopage         = filemap_nopage,
-        .populate       = filemap_populate,
+        .fault          = filemap_fault,
 };
 
 #ifdef CONFIG_XFS_DMAPI
 static struct vm_operations_struct xfs_dmapi_file_vm_ops = {
-        .nopage         = xfs_vm_nopage,
-        .populate       = filemap_populate,
+        .fault          = xfs_vm_fault,
 #ifdef HAVE_VMOP_MPROTECT
         .mprotect       = xfs_vm_mprotect,
 #endif