mm: kill vma flag VM_CAN_NONLINEAR

[karo-tx-linux.git] / fs / xfs / xfs_file.c

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 3f9107431dfb3502ef8de0c2e1c3120fb00d4afe..aa473fa640a2dd16f56ae76abfb72c1f204ba43b 100644 (file)
--- 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;
@@ -1289,9 +1288,9 @@ xfs_seek_hole(
        struct xfs_inode        *ip = XFS_I(inode);
        struct xfs_mount        *mp = ip->i_mount;
        loff_t                  uninitialized_var(offset);
-       loff_t                  holeoff;
        xfs_fsize_t             isize;
        xfs_fileoff_t           fsbno;
+       xfs_filblks_t           end;
        uint                    lock;
        int                     error;
 
@@ -1307,21 +1306,77 @@ xfs_seek_hole(
        }
 
        fsbno = XFS_B_TO_FSBT(mp, start);
-       error = xfs_bmap_first_unused(NULL, ip, 1, &fsbno, XFS_DATA_FORK);
-       if (error)
-               goto out_unlock;
+       end = XFS_B_TO_FSB(mp, isize);
+
+       for (;;) {
+               struct xfs_bmbt_irec    map[2];
+               int                     nmap = 2;
+               unsigned int            i;
+
+               error = xfs_bmapi_read(ip, fsbno, end - fsbno, map, &nmap,
+                                      XFS_BMAPI_ENTIRE);
+               if (error)
+                       goto out_unlock;
+
+               /* No extents at given offset, must be beyond EOF */
+               if (nmap == 0) {
+                       error = ENXIO;
+                       goto out_unlock;
+               }
+
+               for (i = 0; i < nmap; i++) {
+                       offset = max_t(loff_t, start,
+                                      XFS_FSB_TO_B(mp, map[i].br_startoff));
+
+                       /* Landed in a hole */
+                       if (map[i].br_startblock == HOLESTARTBLOCK)
+                               goto out;
+
+                       /*
+                        * Landed in an unwritten extent, try to search hole
+                        * from page cache.
+                        */
+                       if (map[i].br_state == XFS_EXT_UNWRITTEN) {
+                               if (xfs_find_get_desired_pgoff(inode, &map[i],
+                                                       HOLE_OFF, &offset))
+                                       goto out;
+                       }
+               }
 
-       holeoff = XFS_FSB_TO_B(mp, fsbno);
-       if (holeoff <= start)
-               offset = start;
-       else {
                /*
-                * xfs_bmap_first_unused() could return a value bigger than
-                * isize if there are no more holes past the supplied offset.
+                * map[0] contains data or its unwritten but contains
+                * data in page cache, probably means that we are
+                * reading after EOF.  We should fix offset to point
+                * to the end of the file(i.e., there is an implicit
+                * hole at the end of any file).
                 */
-               offset = min_t(loff_t, holeoff, isize);
+               if (nmap == 1) {
+                       offset = isize;
+                       break;
+               }
+
+               ASSERT(i > 1);
+
+               /*
+                * Both mappings contains data, proceed to the next round of
+                * search if the current reading offset not beyond or hit EOF.
+                */
+               fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
+               start = XFS_FSB_TO_B(mp, fsbno);
+               if (start >= isize) {
+                       offset = isize;
+                       break;
+               }
        }
 
+out:
+       /*
+        * At this point, we must have found a hole.  However, the returned
+        * offset may be bigger than the file size as it may be aligned to
+        * page boundary for unwritten extents, we need to deal with this
+        * situation in particular.
+        */
+       offset = min_t(loff_t, offset, isize);
        if (offset != file->f_pos)
                file->f_pos = offset;
 
@@ -1387,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,
 };