ext4: split IOMAP_WRITE branch in ext4_iomap_begin() into helper (f063db5e) · Commits · 戴 / test

fs/ext4/inode.c

+61 −52

Original line number	Diff line number	Diff line
		@@ -3493,6 +3493,63 @@ static void ext4_set_iomap(struct inode inode, struct iomap iomap,
		}
		}

		static int ext4_iomap_alloc(struct inode inode, struct ext4_map_blocks map,
		unsigned int flags)
		{
		handle_t *handle;
		u8 blkbits = inode->i_blkbits;
		int ret, dio_credits, retries = 0;

		/*
		* Trim the mapping request to the maximum value that we can map at
		* once for direct I/O.
		*/
		if (map->m_len > DIO_MAX_BLOCKS)
		map->m_len = DIO_MAX_BLOCKS;
		dio_credits = ext4_chunk_trans_blocks(inode, map->m_len);

		retry:
		/*
		* Either we allocate blocks and then don't get an unwritten extent, so
		* in that case we have reserved enough credits. Or, the blocks are
		* already allocated and unwritten. In that case, the extent conversion
		* fits into the credits as well.
		*/
		handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, dio_credits);
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		ret = ext4_map_blocks(handle, inode, map, EXT4_GET_BLOCKS_CREATE_ZERO);
		if (ret < 0)
		goto journal_stop;

		/*
		* If we've allocated blocks beyond EOF, we need to ensure that they're
		* truncated if we crash before updating the inode size metadata within
		* ext4_iomap_end(). For faults, we don't need to do that (and cannot
		* due to orphan list operations needing an inode_lock()). If we happen
		* to instantiate blocks beyond EOF, it is because we race with a
		* truncate operation, which already has added the inode onto the
		* orphan list.
		*/
		if (!(flags & IOMAP_FAULT) && map->m_lblk + map->m_len >
		(i_size_read(inode) + (1 << blkbits) - 1) >> blkbits) {
		int err;

		err = ext4_orphan_add(handle, inode);
		if (err < 0)
		ret = err;
		}

		journal_stop:
		ext4_journal_stop(handle);
		if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;

		return ret;
		}


		static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
		unsigned flags, struct iomap iomap, struct iomap srcmap)
		{
		@@ -3553,61 +3610,13 @@ static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
		}
		}
		} else if (flags & IOMAP_WRITE) {
		int dio_credits;
		handle_t *handle;
		int retries = 0;

		/* Trim mapping request to maximum we can map at once for DIO */
		if (map.m_len > DIO_MAX_BLOCKS)
		map.m_len = DIO_MAX_BLOCKS;
		dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
		retry:
		/*
		* Either we allocate blocks and then we don't get unwritten
		* extent so we have reserved enough credits, or the blocks
		* are already allocated and unwritten and in that case
		* extent conversion fits in the credits as well.
		*/
		handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
		dio_credits);
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		ret = ext4_map_blocks(handle, inode, &map,
		EXT4_GET_BLOCKS_CREATE_ZERO);
		if (ret < 0) {
		ext4_journal_stop(handle);
		if (ret == -ENOSPC &&
		ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
		return ret;
		}

		/*
		* If we added blocks beyond i_size, we need to make sure they
		* will get truncated if we crash before updating i_size in
		* ext4_iomap_end(). For faults we don't need to do that (and
		* even cannot because for orphan list operations inode_lock is
		* required) - if we happen to instantiate block beyond i_size,
		* it is because we race with truncate which has already added
		* the inode to the orphan list.
		*/
		if (!(flags & IOMAP_FAULT) && first_block + map.m_len >
		(i_size_read(inode) + (1 << blkbits) - 1) >> blkbits) {
		int err;

		err = ext4_orphan_add(handle, inode);
		if (err < 0) {
		ext4_journal_stop(handle);
		return err;
		}
		}
		ext4_journal_stop(handle);
		ret = ext4_iomap_alloc(inode, &map, flags);
		} else {
		ret = ext4_map_blocks(NULL, inode, &map, 0);
		}

		if (ret < 0)
		return ret;
		}

		ext4_set_iomap(inode, iomap, &map, offset, length);
		if (delalloc && iomap->type == IOMAP_HOLE)

Admin message