diff mbox series

[v3,10/10] ext4: make ext4_da_map_blocks() buffer_head unaware

Message ID 20240508061220.967970-11-yi.zhang@huaweicloud.com (mailing list archive)
State New, archived
Headers show
Series ext4: support adding multi-delalloc blocks | expand

Commit Message

Zhang Yi May 8, 2024, 6:12 a.m. UTC 
From: Zhang Yi <yi.zhang@huawei.com>

After calling the ext4_da_map_blocks(), a delalloc extent state could
be identified through the EXT4_MAP_DELAYED flag in map. So factor out
buffer_head related handles in ext4_da_map_blocks(), make this function
buffer_head unaware and becomes a common helper, and also update the
stale function commtents, preparing for the iomap da write path in the
future.

Signed-off-by: Zhang Yi <yi.zhang@huawei.com>
---
 fs/ext4/inode.c | 63 ++++++++++++++++++++++++-------------------------
 1 file changed, 31 insertions(+), 32 deletions(-)

Comments

Jan Kara May 12, 2024, 9:51 p.m. UTC | #1 
On Wed 08-05-24 14:12:20, Zhang Yi wrote:
> From: Zhang Yi <yi.zhang@huawei.com>
> 
> After calling the ext4_da_map_blocks(), a delalloc extent state could
> be identified through the EXT4_MAP_DELAYED flag in map. So factor out
> buffer_head related handles in ext4_da_map_blocks(), make this function
> buffer_head unaware and becomes a common helper, and also update the
> stale function commtents, preparing for the iomap da write path in the
> future.
> 
> Signed-off-by: Zhang Yi <yi.zhang@huawei.com>

Looks good to me. Feel free to add:

Reviewed-by: Jan Kara <jack@suse.cz>

								Honza

> ---
>  fs/ext4/inode.c | 63 ++++++++++++++++++++++++-------------------------
>  1 file changed, 31 insertions(+), 32 deletions(-)
> 
> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> index c56386d1b10d..1dba5337382a 100644
> --- a/fs/ext4/inode.c
> +++ b/fs/ext4/inode.c
> @@ -1745,36 +1745,32 @@ static int ext4_insert_delayed_blocks(struct inode *inode, ext4_lblk_t lblk,
>  }
>  
>  /*
> - * This function is grabs code from the very beginning of
> - * ext4_map_blocks, but assumes that the caller is from delayed write
> - * time. This function looks up the requested blocks and sets the
> - * buffer delay bit under the protection of i_data_sem.
> + * Looks up the requested blocks and sets the delalloc extent map.
> + * First try to look up for the extent entry that contains the requested
> + * blocks in the extent status tree without i_data_sem, then try to look
> + * up for the ondisk extent mapping with i_data_sem in read mode,
> + * finally hold i_data_sem in write mode, looks up again and add a
> + * delalloc extent entry if it still couldn't find any extent. Pass out
> + * the mapped extent through @map and return 0 on success.
>   */
> -static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
> -			      struct buffer_head *bh)
> +static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map)
>  {
>  	struct extent_status es;
>  	int retval;
> -	sector_t invalid_block = ~((sector_t) 0xffff);
>  #ifdef ES_AGGRESSIVE_TEST
>  	struct ext4_map_blocks orig_map;
>  
>  	memcpy(&orig_map, map, sizeof(*map));
>  #endif
>  
> -	if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
> -		invalid_block = ~0;
> -
>  	map->m_flags = 0;
>  	ext_debug(inode, "max_blocks %u, logical block %lu\n", map->m_len,
>  		  (unsigned long) map->m_lblk);
>  
>  	/* Lookup extent status tree firstly */
>  	if (ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
> -		retval = es.es_len - (map->m_lblk - es.es_lblk);
> -		if (retval > map->m_len)
> -			retval = map->m_len;
> -		map->m_len = retval;
> +		map->m_len = min_t(unsigned int, map->m_len,
> +				   es.es_len - (map->m_lblk - es.es_lblk));
>  
>  		if (ext4_es_is_hole(&es))
>  			goto add_delayed;
> @@ -1784,10 +1780,8 @@ static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
>  		 * Delayed extent could be allocated by fallocate.
>  		 * So we need to check it.
>  		 */
> -		if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) {
> -			map_bh(bh, inode->i_sb, invalid_block);
> -			set_buffer_new(bh);
> -			set_buffer_delay(bh);
> +		if (ext4_es_is_delonly(&es)) {
> +			map->m_flags |= EXT4_MAP_DELAYED;
>  			return 0;
>  		}
>  
> @@ -1802,7 +1796,7 @@ static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
>  #ifdef ES_AGGRESSIVE_TEST
>  		ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0);
>  #endif
> -		return retval;
> +		return 0;
>  	}
>  
>  	/*
> @@ -1816,7 +1810,7 @@ static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
>  		retval = ext4_map_query_blocks(NULL, inode, map);
>  	up_read(&EXT4_I(inode)->i_data_sem);
>  	if (retval)
> -		return retval;
> +		return retval < 0 ? retval : 0;
>  
>  add_delayed:
>  	down_write(&EXT4_I(inode)->i_data_sem);
> @@ -1828,10 +1822,8 @@ static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
>  	 * the extent status tree.
>  	 */
>  	if (ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
> -		retval = es.es_len - (map->m_lblk - es.es_lblk);
> -		if (retval > map->m_len)
> -			retval = map->m_len;
> -		map->m_len = retval;
> +		map->m_len = min_t(unsigned int, map->m_len,
> +				   es.es_len - (map->m_lblk - es.es_lblk));
>  
>  		if (!ext4_es_is_hole(&es)) {
>  			up_write(&EXT4_I(inode)->i_data_sem);
> @@ -1841,18 +1833,14 @@ static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
>  		retval = ext4_map_query_blocks(NULL, inode, map);
>  		if (retval) {
>  			up_write(&EXT4_I(inode)->i_data_sem);
> -			return retval;
> +			return retval < 0 ? retval : 0;
>  		}
>  	}
>  
> +	map->m_flags |= EXT4_MAP_DELAYED;
>  	retval = ext4_insert_delayed_blocks(inode, map->m_lblk, map->m_len);
>  	up_write(&EXT4_I(inode)->i_data_sem);
> -	if (retval)
> -		return retval;
>  
> -	map_bh(bh, inode->i_sb, invalid_block);
> -	set_buffer_new(bh);
> -	set_buffer_delay(bh);
>  	return retval;
>  }
>  
> @@ -1872,11 +1860,15 @@ int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
>  			   struct buffer_head *bh, int create)
>  {
>  	struct ext4_map_blocks map;
> +	sector_t invalid_block = ~((sector_t) 0xffff);
>  	int ret = 0;
>  
>  	BUG_ON(create == 0);
>  	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);
>  
> +	if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
> +		invalid_block = ~0;
> +
>  	map.m_lblk = iblock;
>  	map.m_len = 1;
>  
> @@ -1885,10 +1877,17 @@ int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
>  	 * preallocated blocks are unmapped but should treated
>  	 * the same as allocated blocks.
>  	 */
> -	ret = ext4_da_map_blocks(inode, &map, bh);
> -	if (ret <= 0)
> +	ret = ext4_da_map_blocks(inode, &map);
> +	if (ret < 0)
>  		return ret;
>  
> +	if (map.m_flags & EXT4_MAP_DELAYED) {
> +		map_bh(bh, inode->i_sb, invalid_block);
> +		set_buffer_new(bh);
> +		set_buffer_delay(bh);
> +		return 0;
> +	}
> +
>  	map_bh(bh, inode->i_sb, map.m_pblk);
>  	ext4_update_bh_state(bh, map.m_flags);
>  
> -- 
> 2.39.2
>
diff mbox series

Patch

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index c56386d1b10d..1dba5337382a 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1745,36 +1745,32 @@  static int ext4_insert_delayed_blocks(struct inode *inode, ext4_lblk_t lblk,
 }
 
 /*
- * This function is grabs code from the very beginning of
- * ext4_map_blocks, but assumes that the caller is from delayed write
- * time. This function looks up the requested blocks and sets the
- * buffer delay bit under the protection of i_data_sem.
+ * Looks up the requested blocks and sets the delalloc extent map.
+ * First try to look up for the extent entry that contains the requested
+ * blocks in the extent status tree without i_data_sem, then try to look
+ * up for the ondisk extent mapping with i_data_sem in read mode,
+ * finally hold i_data_sem in write mode, looks up again and add a
+ * delalloc extent entry if it still couldn't find any extent. Pass out
+ * the mapped extent through @map and return 0 on success.
  */
-static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
-			      struct buffer_head *bh)
+static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map)
 {
 	struct extent_status es;
 	int retval;
-	sector_t invalid_block = ~((sector_t) 0xffff);
 #ifdef ES_AGGRESSIVE_TEST
 	struct ext4_map_blocks orig_map;
 
 	memcpy(&orig_map, map, sizeof(*map));
 #endif
 
-	if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
-		invalid_block = ~0;
-
 	map->m_flags = 0;
 	ext_debug(inode, "max_blocks %u, logical block %lu\n", map->m_len,
 		  (unsigned long) map->m_lblk);
 
 	/* Lookup extent status tree firstly */
 	if (ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
-		retval = es.es_len - (map->m_lblk - es.es_lblk);
-		if (retval > map->m_len)
-			retval = map->m_len;
-		map->m_len = retval;
+		map->m_len = min_t(unsigned int, map->m_len,
+				   es.es_len - (map->m_lblk - es.es_lblk));
 
 		if (ext4_es_is_hole(&es))
 			goto add_delayed;
@@ -1784,10 +1780,8 @@  static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
 		 * Delayed extent could be allocated by fallocate.
 		 * So we need to check it.
 		 */
-		if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) {
-			map_bh(bh, inode->i_sb, invalid_block);
-			set_buffer_new(bh);
-			set_buffer_delay(bh);
+		if (ext4_es_is_delonly(&es)) {
+			map->m_flags |= EXT4_MAP_DELAYED;
 			return 0;
 		}
 
@@ -1802,7 +1796,7 @@  static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
 #ifdef ES_AGGRESSIVE_TEST
 		ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0);
 #endif
-		return retval;
+		return 0;
 	}
 
 	/*
@@ -1816,7 +1810,7 @@  static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
 		retval = ext4_map_query_blocks(NULL, inode, map);
 	up_read(&EXT4_I(inode)->i_data_sem);
 	if (retval)
-		return retval;
+		return retval < 0 ? retval : 0;
 
 add_delayed:
 	down_write(&EXT4_I(inode)->i_data_sem);
@@ -1828,10 +1822,8 @@  static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
 	 * the extent status tree.
 	 */
 	if (ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
-		retval = es.es_len - (map->m_lblk - es.es_lblk);
-		if (retval > map->m_len)
-			retval = map->m_len;
-		map->m_len = retval;
+		map->m_len = min_t(unsigned int, map->m_len,
+				   es.es_len - (map->m_lblk - es.es_lblk));
 
 		if (!ext4_es_is_hole(&es)) {
 			up_write(&EXT4_I(inode)->i_data_sem);
@@ -1841,18 +1833,14 @@  static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,
 		retval = ext4_map_query_blocks(NULL, inode, map);
 		if (retval) {
 			up_write(&EXT4_I(inode)->i_data_sem);
-			return retval;
+			return retval < 0 ? retval : 0;
 		}
 	}
 
+	map->m_flags |= EXT4_MAP_DELAYED;
 	retval = ext4_insert_delayed_blocks(inode, map->m_lblk, map->m_len);
 	up_write(&EXT4_I(inode)->i_data_sem);
-	if (retval)
-		return retval;
 
-	map_bh(bh, inode->i_sb, invalid_block);
-	set_buffer_new(bh);
-	set_buffer_delay(bh);
 	return retval;
 }
 
@@ -1872,11 +1860,15 @@  int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
 			   struct buffer_head *bh, int create)
 {
 	struct ext4_map_blocks map;
+	sector_t invalid_block = ~((sector_t) 0xffff);
 	int ret = 0;
 
 	BUG_ON(create == 0);
 	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);
 
+	if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
+		invalid_block = ~0;
+
 	map.m_lblk = iblock;
 	map.m_len = 1;
 
@@ -1885,10 +1877,17 @@  int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
 	 * preallocated blocks are unmapped but should treated
 	 * the same as allocated blocks.
 	 */
-	ret = ext4_da_map_blocks(inode, &map, bh);
-	if (ret <= 0)
+	ret = ext4_da_map_blocks(inode, &map);
+	if (ret < 0)
 		return ret;
 
+	if (map.m_flags & EXT4_MAP_DELAYED) {
+		map_bh(bh, inode->i_sb, invalid_block);
+		set_buffer_new(bh);
+		set_buffer_delay(bh);
+		return 0;
+	}
+
 	map_bh(bh, inode->i_sb, map.m_pblk);
 	ext4_update_bh_state(bh, map.m_flags);