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 b1158b3..9ff732b 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -1301,9 +1301,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;
@@ -1319,21 +1319,91 @@ 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
_______________________________________________
xfs mailing list
xfs@xxxxxxxxxxx
http://oss.sgi.com/mailman/listinfo/xfs
