[PATCH v5 4/4]xfs: xfs_seek_hole() refinements with lookup hole offset from page cache.

[Jeff Liu <jeff.liu@xxxxxxxxxx>]

Search possbile hole offset for given range from page cache for unwritten and 
delayed-allocation extents.

Signed-off-by: Jie Liu <jeff.liu@xxxxxxxxxx>
Reviewed-by: Mark Tinguely <tinguely@xxxxxxx>
Reviewed-by: Christoph Hellwig <hch@xxxxxx>
Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>

---
 fs/xfs/xfs_file.c |   90 +++++++++++++++++++++++++++++++++++++++++++++++------
 1 files changed, 80 insertions(+), 10 deletions(-)

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 15acd4d..1b83549 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -1296,9 +1296,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;
 
@@ -1314,20 +1314,90 @@ 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;
+
+               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;
+               }
 
-       holeoff = XFS_FSB_TO_B(mp, fsbno);
-       if (holeoff <= start)
                offset = start;
-       else {
+               /* Landed in a hole, return */
+               if (map[0].br_startblock == HOLESTARTBLOCK)
+                       break;
+               else {
+                       /*
+                        * Landed in an unwritten extent, try to lookup page
+                        * cache to find holes.
+                        */
+                       if (map[0].br_state == XFS_EXT_UNWRITTEN ||
+                           isnullstartblock(map[0].br_startblock)) {
+                               /* Probing page cache start from offset */
+                               if (xfs_find_get_desired_pgoff(inode, &map[0],
+                                                       HOLE_OFF, &offset))
+                                       break;
+                       }
+
+                       /*
+                        * map[0] is unwritten and there is no hole past
+                        * offset, probably means that we are reading after
+                        * EOF.  Hence, 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).
+                        */
+                       if (nmap == 1) {
+                               offset = isize;
+                               break;
+                       }
+
+                       /* We have two mappings, proceed to check map[1] */
+                       offset = XFS_FSB_TO_B(mp, map[1].br_startoff);
+                       if (map[1].br_startblock == HOLESTARTBLOCK)
+                               break;
+                       else {
+                               /*
+                                * map[1] is also an unwritten extent, try
+                                * to lookup hole from the page cache again.
+                                */
+                               if (map[1].br_state == XFS_EXT_UNWRITTEN ||
+                                   isnullstartblock(map[1].br_startblock)) {
+                                       if (xfs_find_get_desired_pgoff(inode,
+                                               &map[1], HOLE_OFF, &offset))
+                                               break;
+                               }
+                       }
+               }
+
                /*
-                * xfs_bmap_first_unused() could return a value bigger than
-                * isize if there are no more holes past the supplied offset.
+                * Both mappings contains data, proceed to the next round of
+                * search if the current reading offset not beyond or hit EOF.
                 */
-               offset = min_t(loff_t, holeoff, isize);
+               fsbno = map[1].br_startoff + map[1].br_blockcount;
+               start = XFS_FSB_TO_B(mp, fsbno);
+               if (start >= isize) {
+                       offset = isize;
+                       break;
+               }
        }
+
+       /*
+        * Come to here, we must have found a hole.  However, the returned
+        * offset might be greater than the file size as it might be fixed
+        * to block buffer unit boundary at page cache lookup procedure for
+        * unwritten and delayed-allocation 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;
-- 
1.7.4.1