ext4: factor out checks from ext4_file_write_iter() (213bcd9c) · Commits · 戴 / test

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

Admin message