Commit 8262fe9a authored by Zhang Yi's avatar Zhang Yi Committed by Theodore Ts'o
Browse files

ext4: make ext4_da_map_blocks() buffer_head unaware 



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: default avatarZhang Yi <yi.zhang@huawei.com>
Reviewed-by: default avatarJan Kara <jack@suse.cz>
Link: https://patch.msgid.link/20240517124005.347221-11-yi.zhang@huaweicloud.com


Signed-off-by: default avatarTheodore Ts'o <tytso@mit.edu>
parent 1850d76c

fs/ext4/inode.c

+31 −32
Original line number Diff line number Diff line
@@ -1749,36 +1749,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.

 */

static int ext4_da_map_blocks(struct inode *inode, struct ext4_map_blocks *map,

			      struct buffer_head *bh)

 * 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 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;
@@ -1788,10 +1784,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;

		}
@@ -1806,7 +1800,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;

	}



	/*
@@ -1820,7 +1814,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);
@@ -1832,10 +1826,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);
@@ -1845,18 +1837,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;

}
@@ -1876,11 +1864,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;
@@ -1889,10 +1881,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);