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

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

[Jeff Liu]

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

Signed-off-by: Jie Liu <jeff.liu@oracle.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

---
 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

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Jeff Liu]

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

Signed-off-by: Jie Liu <jeff.liu@oracle.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

---
 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@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Mark Tinguely]

On 07/26/12 10:32, Jeff Liu wrote:
> Search possbile hole offset for given range from page cache for
> unwritten and delayed-allocation extents.
>
> Signed-off-by: Jie Liu<jeff.liu@oracle.com>

Same comments about the comments that I made in xfs_seek_data().

Reviewed-by: Mark Tinguely <tinguely@sgi.com>

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Dave Chinner]

On Thu, Jul 26, 2012 at 04:56:22PM +0800, Jeff Liu wrote:
> Search possbile hole offset for given range from page cache for unwritten and delayed-allocation extents.
> 
> Signed-off-by: Jie Liu <jeff.liu@oracle.com>
> Reviewed-by: Mark Tinguely <tinguely@sgi.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> Reviewed-by: Dave Chinner <dchinner@redhat.com>
> 
> ---
>  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.
> +			 */

Laned in a data extent is more correct here.

> +			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;
> +			}

Same logic changes as previous patch:

		if (map[0].br_startblock == HOLESTARTBLOCK)
			break;
		else if (map[0].br_state == XFS_EXT_UNWRITTEN) {
			ASSERT(!isnullstartblock(map[0].br_startblock));

			/* Probing page cache start from offset */
			if (xfs_find_get_desired_pgoff(inode, &map[0],
						HOLE_OFF, &offset))
				break;
		} else {
			.....

>  		/*
> -		 * 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;
> +		}

And that check can move to the start of the loop, too.

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs

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

[Jie Liu]

[-- Attachment #1.1: Type: text/plain, Size: 3328 bytes --]

On 07/31/12 08:13, Dave Chinner wrote:
> On Thu, Jul 26, 2012 at 04:56:22PM +0800, Jeff Liu wrote:
>> Search possbile hole offset for given range from page cache for unwritten and delayed-allocation extents.
>>
>> Signed-off-by: Jie Liu <jeff.liu@oracle.com>
>> Reviewed-by: Mark Tinguely <tinguely@sgi.com>
>> Reviewed-by: Christoph Hellwig <hch@lst.de>
>> Reviewed-by: Dave Chinner <dchinner@redhat.com>
>>
>> ---
>>   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.
>> +			 */
> Laned in a data extent is more correct here.
>
>> +			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;
>> +			}
> Same logic changes as previous patch:
>
> 		if (map[0].br_startblock == HOLESTARTBLOCK)
> 			break;
> 		else if (map[0].br_state == XFS_EXT_UNWRITTEN) {
> 			ASSERT(!isnullstartblock(map[0].br_startblock));
>
> 			/* Probing page cache start from offset */
> 			if (xfs_find_get_desired_pgoff(inode, &map[0],
> 						HOLE_OFF, &offset))
> 				break;
> 		} else {
> 			.....
>
>>   		/*
>> -		 * 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;
>> +		}
> And that check can move to the start of the loop, too.
Thanks for a comprehensive review, I'll fix them according to your comments.

Thanks,
-Jeff
//
>
> Cheers,
>
> Dave.


[-- Attachment #1.2: Type: text/html, Size: 4201 bytes --]

[-- Attachment #2: Type: text/plain, Size: 121 bytes --]

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs