Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 213bcd9c authored by Jan Kara's avatar Jan Kara Committed by Theodore Ts'o
Browse files

ext4: factor out checks from ext4_file_write_iter() 



Factor out checks of 'from' and whether we are overwriting out of
ext4_file_write_iter() so that the function is easier to follow.

Reviewed-by: default avatarRoss Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
Signed-off-by: default avatarTheodore Ts'o <tytso@mit.edu>
parent c48ae41b

fs/ext4/file.c

+50 −47
Original line number Diff line number Diff line
@@ -88,6 +88,51 @@ ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos) 
	return 0;

}



/* Is IO overwriting allocated and initialized blocks? */

static bool ext4_overwrite_io(struct inode *inode, loff_t pos, loff_t len)

{

	struct ext4_map_blocks map;

	unsigned int blkbits = inode->i_blkbits;

	int err, blklen;



	if (pos + len > i_size_read(inode))

		return false;



	map.m_lblk = pos >> blkbits;

	map.m_len = EXT4_MAX_BLOCKS(len, pos, blkbits);

	blklen = map.m_len;



	err = ext4_map_blocks(NULL, inode, &map, 0);

	/*

	 * 'err==len' means that all of the blocks have been preallocated,

	 * regardless of whether they have been initialized or not. To exclude

	 * unwritten extents, we need to check m_flags.

	 */

	return err == blklen && (map.m_flags & EXT4_MAP_MAPPED);

}



static ssize_t ext4_write_checks(struct kiocb *iocb, struct iov_iter *from)

{

	struct inode *inode = file_inode(iocb->ki_filp);

	ssize_t ret;



	ret = generic_write_checks(iocb, from);

	if (ret <= 0)

		return ret;

	/*

	 * If we have encountered a bitmap-format file, the size limit

	 * is smaller than s_maxbytes, which is for extent-mapped files.

	 */

	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {

		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);



		if (iocb->ki_pos >= sbi->s_bitmap_maxbytes)

			return -EFBIG;

		iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);

	}

	return iov_iter_count(from);

}



static ssize_t

ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)

{
@@ -98,7 +143,7 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 
	ssize_t ret;



	inode_lock(inode);

	ret = generic_write_checks(iocb, from);

	ret = ext4_write_checks(iocb, from);

	if (ret <= 0)

		goto out;
@@ -114,53 +159,11 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 
		ext4_unwritten_wait(inode);

	}



	/*

	 * If we have encountered a bitmap-format file, the size limit

	 * is smaller than s_maxbytes, which is for extent-mapped files.

	 */

	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {

		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);



		if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) {

			ret = -EFBIG;

			goto out;

		}

		iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);

	}



	iocb->private = &overwrite;

	if (o_direct) {

		size_t length = iov_iter_count(from);

		loff_t pos = iocb->ki_pos;



		/* check whether we do a DIO overwrite or not */

		if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&

		    pos + length <= i_size_read(inode)) {

			struct ext4_map_blocks map;

			unsigned int blkbits = inode->i_blkbits;

			int err, len;



			map.m_lblk = pos >> blkbits;

			map.m_len = EXT4_MAX_BLOCKS(length, pos, blkbits);

			len = map.m_len;



			err = ext4_map_blocks(NULL, inode, &map, 0);

			/*

			 * 'err==len' means that all of blocks has

			 * been preallocated no matter they are

			 * initialized or not.  For excluding

			 * unwritten extents, we need to check

			 * m_flags.  There are two conditions that

			 * indicate for initialized extents.  1) If we

			 * hit extent cache, EXT4_MAP_MAPPED flag is

			 * returned; 2) If we do a real lookup,

			 * non-flags are returned.  So we should check

			 * these two conditions.

			 */

			if (err == len && (map.m_flags & EXT4_MAP_MAPPED))

	/* Check whether we do a DIO overwrite or not */

	if (o_direct && ext4_should_dioread_nolock(inode) && !unaligned_aio &&

	    ext4_overwrite_io(inode, iocb->ki_pos, iov_iter_count(from)))

		overwrite = 1;

		}

	}



	ret = __generic_file_write_iter(iocb, from);

	inode_unlock(inode);