Merge ext4 changes in ext4_file_write() into for-next (a8324754) · Commits · e / devices / android_kernel_fairphone_FP3

fs/ext4/ext4.h

+11 −13

Original line number	Diff line number	Diff line
		@@ -158,7 +158,6 @@ struct ext4_allocation_request {
		#define EXT4_MAP_MAPPED (1 << BH_Mapped)
		#define EXT4_MAP_UNWRITTEN (1 << BH_Unwritten)
		#define EXT4_MAP_BOUNDARY (1 << BH_Boundary)
		#define EXT4_MAP_UNINIT (1 << BH_Uninit)
		/* Sometimes (in the bigalloc case, from ext4_da_get_block_prep) the caller of
		* ext4_map_blocks wants to know whether or not the underlying cluster has
		* already been accounted for. EXT4_MAP_FROM_CLUSTER conveys to the caller that
		@@ -169,7 +168,7 @@ struct ext4_allocation_request {
		#define EXT4_MAP_FROM_CLUSTER (1 << BH_AllocFromCluster)
		#define EXT4_MAP_FLAGS (EXT4_MAP_NEW \| EXT4_MAP_MAPPED \|\
		EXT4_MAP_UNWRITTEN \| EXT4_MAP_BOUNDARY \|\
		EXT4_MAP_UNINIT \| EXT4_MAP_FROM_CLUSTER)
		EXT4_MAP_FROM_CLUSTER)

		struct ext4_map_blocks {
		ext4_fsblk_t m_pblk;
		@@ -184,7 +183,7 @@ struct ext4_map_blocks {
		#define EXT4_IO_END_UNWRITTEN 0x0001

		/*
		* For converting uninitialized extents on a work queue. 'handle' is used for
		* For converting unwritten extents on a work queue. 'handle' is used for
		* buffered writeback.
		*/
		typedef struct ext4_io_end {
		@@ -537,26 +536,26 @@ enum {
		/*
		* Flags used by ext4_map_blocks()
		*/
		/* Allocate any needed blocks and/or convert an unitialized
		/* Allocate any needed blocks and/or convert an unwritten
		extent to be an initialized ext4 */
		#define EXT4_GET_BLOCKS_CREATE 0x0001
		/* Request the creation of an unitialized extent */
		#define EXT4_GET_BLOCKS_UNINIT_EXT 0x0002
		#define EXT4_GET_BLOCKS_CREATE_UNINIT_EXT (EXT4_GET_BLOCKS_UNINIT_EXT\|\
		/* Request the creation of an unwritten extent */
		#define EXT4_GET_BLOCKS_UNWRIT_EXT 0x0002
		#define EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT (EXT4_GET_BLOCKS_UNWRIT_EXT\|\
		EXT4_GET_BLOCKS_CREATE)
		/* Caller is from the delayed allocation writeout path
		* finally doing the actual allocation of delayed blocks */
		#define EXT4_GET_BLOCKS_DELALLOC_RESERVE 0x0004
		/* caller is from the direct IO path, request to creation of an
		unitialized extents if not allocated, split the uninitialized
		unwritten extents if not allocated, split the unwritten
		extent if blocks has been preallocated already*/
		#define EXT4_GET_BLOCKS_PRE_IO 0x0008
		#define EXT4_GET_BLOCKS_CONVERT 0x0010
		#define EXT4_GET_BLOCKS_IO_CREATE_EXT (EXT4_GET_BLOCKS_PRE_IO\|\
		EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)
		EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
		/* Convert extent to initialized after IO complete */
		#define EXT4_GET_BLOCKS_IO_CONVERT_EXT (EXT4_GET_BLOCKS_CONVERT\|\
		EXT4_GET_BLOCKS_CREATE_UNINIT_EXT)
		EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
		/* Eventual metadata allocation (due to growing extent tree)
		* should not fail, so try to use reserved blocks for that.*/
		#define EXT4_GET_BLOCKS_METADATA_NOFAIL 0x0020
		@@ -2783,10 +2782,9 @@ extern int ext4_mmp_csum_verify(struct super_block *sb,
		* See EXT4_MAP_... to see where this is used.
		*/
		enum ext4_state_bits {
		BH_Uninit /* blocks are allocated but uninitialized on disk */
		= BH_JBDPrivateStart,
		BH_AllocFromCluster, /* allocated blocks were part of already
		BH_AllocFromCluster /* allocated blocks were part of already
		* allocated cluster. */
		= BH_JBDPrivateStart
		};

		/*

fs/ext4/ext4_extents.h

+11 −11

Original line number	Diff line number	Diff line
		@@ -137,21 +137,21 @@ struct ext4_ext_path {
		* EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an
		* initialized extent. This is 2^15 and not (2^16 - 1), since we use the
		* MSB of ee_len field in the extent datastructure to signify if this
		* particular extent is an initialized extent or an uninitialized (i.e.
		* particular extent is an initialized extent or an unwritten (i.e.
		* preallocated).
		* EXT_UNINIT_MAX_LEN is the maximum number of blocks we can have in an
		* uninitialized extent.
		* EXT_UNWRITTEN_MAX_LEN is the maximum number of blocks we can have in an
		* unwritten extent.
		* If ee_len is <= 0x8000, it is an initialized extent. Otherwise, it is an
		* uninitialized one. In other words, if MSB of ee_len is set, it is an
		* uninitialized extent with only one special scenario when ee_len = 0x8000.
		* In this case we can not have an uninitialized extent of zero length and
		* unwritten one. In other words, if MSB of ee_len is set, it is an
		* unwritten extent with only one special scenario when ee_len = 0x8000.
		* In this case we can not have an unwritten extent of zero length and
		* thus we make it as a special case of initialized extent with 0x8000 length.
		* This way we get better extent-to-group alignment for initialized extents.
		* Hence, the maximum number of blocks we can have in an initialized
		* extent is 2^15 (32768) and in an uninitialized extent is 2^15-1 (32767).
		* extent is 2^15 (32768) and in an unwritten extent is 2^15-1 (32767).
		*/
		#define EXT_INIT_MAX_LEN (1UL << 15)
		#define EXT_UNINIT_MAX_LEN (EXT_INIT_MAX_LEN - 1)
		#define EXT_UNWRITTEN_MAX_LEN (EXT_INIT_MAX_LEN - 1)


		#define EXT_FIRST_EXTENT(__hdr__) \
		@@ -187,14 +187,14 @@ static inline unsigned short ext_depth(struct inode *inode)
		return le16_to_cpu(ext_inode_hdr(inode)->eh_depth);
		}

		static inline void ext4_ext_mark_uninitialized(struct ext4_extent *ext)
		static inline void ext4_ext_mark_unwritten(struct ext4_extent *ext)
		{
		/* We can not have an uninitialized extent of zero length! */
		/* We can not have an unwritten extent of zero length! */
		BUG_ON((le16_to_cpu(ext->ee_len) & ~EXT_INIT_MAX_LEN) == 0);
		ext->ee_len \|= cpu_to_le16(EXT_INIT_MAX_LEN);
		}

		static inline int ext4_ext_is_uninitialized(struct ext4_extent *ext)
		static inline int ext4_ext_is_unwritten(struct ext4_extent *ext)
		{
		/* Extent with ee_len of 0x8000 is treated as an initialized extent */
		return (le16_to_cpu(ext->ee_len) > EXT_INIT_MAX_LEN);

fs/ext4/extents.c

+109 −113

File changed.

Preview size limit exceeded, changes collapsed.

fs/ext4/extents_status.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -433,7 +433,7 @@ static void ext4_es_insert_extent_ext_check(struct inode *inode,
		ee_start = ext4_ext_pblock(ex);
		ee_len = ext4_ext_get_actual_len(ex);

		ee_status = ext4_ext_is_uninitialized(ex) ? 1 : 0;
		ee_status = ext4_ext_is_unwritten(ex) ? 1 : 0;
		es_status = ext4_es_is_unwritten(es) ? 1 : 0;

		/*

fs/ext4/file.c

+75 −75

Original line number	Diff line number	Diff line
		@@ -92,36 +92,65 @@ ext4_unaligned_aio(struct inode inode, const struct iovec iov,
		}

		static ssize_t
		ext4_file_dio_write(struct kiocb iocb, const struct iovec iov,
		ext4_file_write(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		{
		struct file *file = iocb->ki_filp;
		struct inode *inode = file->f_mapping->host;
		struct inode *inode = file_inode(iocb->ki_filp);
		struct mutex *aio_mutex = NULL;
		struct blk_plug plug;
		int unaligned_aio = 0;
		ssize_t ret;
		int o_direct = file->f_flags & O_DIRECT;
		int overwrite = 0;
		size_t length = iov_length(iov, nr_segs);
		ssize_t ret;

		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
		!is_sync_kiocb(iocb))
		unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
		BUG_ON(iocb->ki_pos != pos);

		/* Unaligned direct AIO must be serialized; see comment above */
		if (unaligned_aio) {
		mutex_lock(ext4_aio_mutex(inode));
		/*
		* Unaligned direct AIO must be serialized; see comment above
		* In the case of O_APPEND, assume that we must always serialize
		*/
		if (o_direct &&
		ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
		!is_sync_kiocb(iocb) &&
		(file->f_flags & O_APPEND \|\|
		ext4_unaligned_aio(inode, iov, nr_segs, pos))) {
		aio_mutex = ext4_aio_mutex(inode);
		mutex_lock(aio_mutex);
		ext4_unwritten_wait(inode);
		}

		BUG_ON(iocb->ki_pos != pos);

		mutex_lock(&inode->i_mutex);
		if (file->f_flags & O_APPEND)
		iocb->ki_pos = pos = i_size_read(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 ((pos > sbi->s_bitmap_maxbytes) \|\|
		(pos == sbi->s_bitmap_maxbytes && length > 0)) {
		mutex_unlock(&inode->i_mutex);
		ret = -EFBIG;
		goto errout;
		}

		if (pos + length > sbi->s_bitmap_maxbytes) {
		nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
		sbi->s_bitmap_maxbytes - pos);
		}
		}

		if (o_direct) {
		blk_start_plug(&plug);

		iocb->private = &overwrite;

		/* check whether we do a DIO overwrite or not */
		if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
		if (ext4_should_dioread_nolock(inode) && !aio_mutex &&
		!file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
		struct ext4_map_blocks map;
		unsigned int blkbits = inode->i_blkbits;
		@@ -134,17 +163,21 @@ ext4_file_dio_write(struct kiocb iocb, const struct iovec iov,

		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
		* uninitialized 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.
		* '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))
		overwrite = 1;
		}
		}

		ret = __generic_file_aio_write(iocb, iov, nr_segs);
		mutex_unlock(&inode->i_mutex);
		@@ -156,45 +189,12 @@ ext4_file_dio_write(struct kiocb iocb, const struct iovec iov,
		if (err < 0)
		ret = err;
		}
		if (o_direct)
		blk_finish_plug(&plug);

		if (unaligned_aio)
		mutex_unlock(ext4_aio_mutex(inode));

		return ret;
		}

		static ssize_t
		ext4_file_write(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		{
		struct inode *inode = file_inode(iocb->ki_filp);
		ssize_t 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);
		size_t length = iov_length(iov, nr_segs);

		if ((pos > sbi->s_bitmap_maxbytes \|\|
		(pos == sbi->s_bitmap_maxbytes && length > 0)))
		return -EFBIG;

		if (pos + length > sbi->s_bitmap_maxbytes) {
		nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
		sbi->s_bitmap_maxbytes - pos);
		}
		}

		if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
		ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
		else
		ret = generic_file_aio_write(iocb, iov, nr_segs, pos);

		errout:
		if (aio_mutex)
		mutex_unlock(aio_mutex);
		return ret;
		}