Merge branch 'jk/jbd2-revoke-overflow' (a6d40408) · Commits · EulixOS / Software / Kernel

fs/ext4/ext4.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -2609,7 +2609,6 @@ extern int ext4_can_truncate(struct inode *inode);
		extern int ext4_truncate(struct inode *);
		extern int ext4_break_layouts(struct inode *);
		extern int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length);
		extern int ext4_truncate_restart_trans(handle_t , struct inode , int nblocks);
		extern void ext4_set_inode_flags(struct inode *);
		extern int ext4_alloc_da_blocks(struct inode *inode);
		extern void ext4_set_aops(struct inode *inode);
		@@ -3303,6 +3302,10 @@ extern int ext4_swap_extents(handle_t handle, struct inode inode1,
		ext4_lblk_t lblk2, ext4_lblk_t count,
		int mark_unwritten,int *err);
		extern int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu);
		extern int ext4_datasem_ensure_credits(handle_t handle, struct inode inode,
		int check_cred, int restart_cred,
		int revoke_cred);


		/* move_extent.c */
		extern void ext4_double_down_write_data_sem(struct inode *first,

fs/ext4/ext4_jbd2.c

+24 −8

Original line number	Diff line number	Diff line
		@@ -65,12 +65,14 @@ static int ext4_journal_check_start(struct super_block *sb)
		}

		handle_t __ext4_journal_start_sb(struct super_block sb, unsigned int line,
		int type, int blocks, int rsv_blocks)
		int type, int blocks, int rsv_blocks,
		int revoke_creds)
		{
		journal_t *journal;
		int err;

		trace_ext4_journal_start(sb, blocks, rsv_blocks, _RET_IP_);
		trace_ext4_journal_start(sb, blocks, rsv_blocks, revoke_creds,
		_RET_IP_);
		err = ext4_journal_check_start(sb);
		if (err < 0)
		return ERR_PTR(err);
		@@ -78,8 +80,8 @@ handle_t __ext4_journal_start_sb(struct super_block sb, unsigned int line,
		journal = EXT4_SB(sb)->s_journal;
		if (!journal)
		return ext4_get_nojournal();
		return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS,
		type, line);
		return jbd2__journal_start(journal, blocks, rsv_blocks, revoke_creds,
		GFP_NOFS, type, line);
		}

		int __ext4_journal_stop(const char where, unsigned int line, handle_t handle)
		@@ -119,8 +121,8 @@ handle_t __ext4_journal_start_reserved(handle_t handle, unsigned int line,
		return ext4_get_nojournal();

		sb = handle->h_journal->j_private;
		trace_ext4_journal_start_reserved(sb, handle->h_buffer_credits,
		_RET_IP_);
		trace_ext4_journal_start_reserved(sb,
		jbd2_handle_buffer_credits(handle), _RET_IP_);
		err = ext4_journal_check_start(sb);
		if (err < 0) {
		jbd2_journal_free_reserved(handle);
		@@ -133,6 +135,19 @@ handle_t __ext4_journal_start_reserved(handle_t handle, unsigned int line,
		return handle;
		}

		int __ext4_journal_ensure_credits(handle_t *handle, int check_cred,
		int extend_cred, int revoke_cred)
		{
		if (!ext4_handle_valid(handle))
		return 0;
		if (jbd2_handle_buffer_credits(handle) >= check_cred &&
		handle->h_revoke_credits >= revoke_cred)
		return 0;
		extend_cred = max(0, extend_cred - jbd2_handle_buffer_credits(handle));
		revoke_cred = max(0, revoke_cred - handle->h_revoke_credits);
		return ext4_journal_extend(handle, extend_cred, revoke_cred);
		}

		static void ext4_journal_abort_handle(const char *caller, unsigned int line,
		const char *err_fn,
		struct buffer_head *bh,
		@@ -278,7 +293,7 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
		handle->h_type,
		handle->h_line_no,
		handle->h_requested_credits,
		handle->h_buffer_credits, err);
		jbd2_handle_buffer_credits(handle), err);
		return err;
		}
		ext4_error_inode(inode, where, line,
		@@ -289,7 +304,8 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
		handle->h_type,
		handle->h_line_no,
		handle->h_requested_credits,
		handle->h_buffer_credits, err);
		jbd2_handle_buffer_credits(handle),
		err);
		}
		} else {
		if (inode)

fs/ext4/ext4_jbd2.h

+91 −15

Original line number	Diff line number	Diff line
		@@ -261,7 +261,8 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
		__ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))

		handle_t __ext4_journal_start_sb(struct super_block sb, unsigned int line,
		int type, int blocks, int rsv_blocks);
		int type, int blocks, int rsv_blocks,
		int revoke_creds);
		int __ext4_journal_stop(const char where, unsigned int line, handle_t handle);

		#define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
		@@ -288,28 +289,41 @@ static inline int ext4_handle_is_aborted(handle_t *handle)
		return 0;
		}

		static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
		static inline int ext4_free_metadata_revoke_credits(struct super_block *sb,
		int blocks)
		{
		if (ext4_handle_valid(handle) && handle->h_buffer_credits < needed)
		return 0;
		return 1;
		/* Freeing each metadata block can result in freeing one cluster */
		return blocks * EXT4_SB(sb)->s_cluster_ratio;
		}

		static inline int ext4_trans_default_revoke_credits(struct super_block *sb)
		{
		return ext4_free_metadata_revoke_credits(sb, 8);
		}

		#define ext4_journal_start_sb(sb, type, nblocks) \
		__ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0)
		__ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0, \
		ext4_trans_default_revoke_credits(sb))

		#define ext4_journal_start(inode, type, nblocks) \
		__ext4_journal_start((inode), __LINE__, (type), (nblocks), 0)
		__ext4_journal_start((inode), __LINE__, (type), (nblocks), 0, \
		ext4_trans_default_revoke_credits((inode)->i_sb))

		#define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks)\
		__ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks))
		__ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks),\
		ext4_trans_default_revoke_credits((inode)->i_sb))

		#define ext4_journal_start_with_revoke(inode, type, blocks, revoke_creds) \
		__ext4_journal_start((inode), __LINE__, (type), (blocks), 0, \
		(revoke_creds))

		static inline handle_t __ext4_journal_start(struct inode inode,
		unsigned int line, int type,
		int blocks, int rsv_blocks)
		int blocks, int rsv_blocks,
		int revoke_creds)
		{
		return __ext4_journal_start_sb(inode->i_sb, line, type, blocks,
		rsv_blocks);
		rsv_blocks, revoke_creds);
		}

		#define ext4_journal_stop(handle) \
		@@ -332,20 +346,68 @@ static inline handle_t *ext4_journal_current_handle(void)
		return journal_current_handle();
		}

		static inline int ext4_journal_extend(handle_t *handle, int nblocks)
		static inline int ext4_journal_extend(handle_t *handle, int nblocks, int revoke)
		{
		if (ext4_handle_valid(handle))
		return jbd2_journal_extend(handle, nblocks);
		return jbd2_journal_extend(handle, nblocks, revoke);
		return 0;
		}

		static inline int ext4_journal_restart(handle_t *handle, int nblocks)
		static inline int ext4_journal_restart(handle_t *handle, int nblocks,
		int revoke)
		{
		if (ext4_handle_valid(handle))
		return jbd2_journal_restart(handle, nblocks);
		return jbd2__journal_restart(handle, nblocks, revoke, GFP_NOFS);
		return 0;
		}

		int __ext4_journal_ensure_credits(handle_t *handle, int check_cred,
		int extend_cred, int revoke_cred);


		/*
		* Ensure @handle has at least @check_creds credits available. If not,
		* transaction will be extended or restarted to contain at least @extend_cred
		* credits. Before restarting transaction @fn is executed to allow for cleanup
		* before the transaction is restarted.
		*
		* The return value is < 0 in case of error, 0 in case the handle has enough
		* credits or transaction extension succeeded, 1 in case transaction had to be
		* restarted.
		*/
		#define ext4_journal_ensure_credits_fn(handle, check_cred, extend_cred, \
		revoke_cred, fn) \
		({ \
		__label__ __ensure_end; \
		int err = __ext4_journal_ensure_credits((handle), (check_cred), \
		(extend_cred), (revoke_cred)); \
		\
		if (err <= 0) \
		goto __ensure_end; \
		err = (fn); \
		if (err < 0) \
		goto __ensure_end; \
		err = ext4_journal_restart((handle), (extend_cred), (revoke_cred)); \
		if (err == 0) \
		err = 1; \
		__ensure_end: \
		err; \
		})

		/*
		* Ensure given handle has at least requested amount of credits available,
		* possibly restarting transaction if needed. We also make sure the transaction
		* has space for at least ext4_trans_default_revoke_credits(sb) revoke records
		* as freeing one or two blocks is very common pattern and requesting this is
		* very cheap.
		*/
		static inline int ext4_journal_ensure_credits(handle_t *handle, int credits,
		int revoke_creds)
		{
		return ext4_journal_ensure_credits_fn(handle, credits, credits,
		revoke_creds, 0);
		}

		static inline int ext4_journal_blocks_per_page(struct inode *inode)
		{
		if (EXT4_JOURNAL(inode) != NULL)
		@@ -407,6 +469,7 @@ static inline int ext4_inode_journal_mode(struct inode *inode)
		return EXT4_INODE_WRITEBACK_DATA_MODE; /* writeback */
		/* We do not support data journalling with delayed allocation */
		if (!S_ISREG(inode->i_mode) \|\|
		ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE) \|\|
		test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA \|\|
		(ext4_test_inode_flag(inode, EXT4_INODE_JOURNAL_DATA) &&
		!test_opt(inode->i_sb, DELALLOC))) {
		@@ -437,6 +500,19 @@ static inline int ext4_should_writeback_data(struct inode *inode)
		return ext4_inode_journal_mode(inode) & EXT4_INODE_WRITEBACK_DATA_MODE;
		}

		static inline int ext4_free_data_revoke_credits(struct inode *inode, int blocks)
		{
		if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
		return 0;
		if (!ext4_should_journal_data(inode))
		return 0;
		/*
		* Data blocks in one extent are contiguous, just account for partial
		* clusters at extent boundaries
		*/
		return blocks + 2*(EXT4_SB(inode->i_sb)->s_cluster_ratio - 1);
		}

		/*
		* This function controls whether or not we should try to go down the
		* dioread_nolock code paths, which makes it safe to avoid taking

fs/ext4/extents.c

+57 −32

Original line number	Diff line number	Diff line
		@@ -100,29 +100,41 @@ static int ext4_split_extent_at(handle_t *handle,
		static int ext4_find_delayed_extent(struct inode *inode,
		struct extent_status *newes);

		static int ext4_ext_truncate_extend_restart(handle_t *handle,
		struct inode *inode,
		int needed)
		static int ext4_ext_trunc_restart_fn(struct inode inode, int dropped)
		{
		int err;

		if (!ext4_handle_valid(handle))
		return 0;
		if (handle->h_buffer_credits >= needed)
		/*
		* Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
		* moment, get_block can be called only for blocks inside i_size since
		* page cache has been already dropped and writes are blocked by
		* i_mutex. So we can safely drop the i_data_sem here.
		*/
		BUG_ON(EXT4_JOURNAL(inode) == NULL);
		ext4_discard_preallocations(inode);
		up_write(&EXT4_I(inode)->i_data_sem);
		*dropped = 1;
		return 0;
		}

		/*
		* If we need to extend the journal get a few extra blocks
		* while we're at it for efficiency's sake.
		* Make sure 'handle' has at least 'check_cred' credits. If not, restart
		* transaction with 'restart_cred' credits. The function drops i_data_sem
		* when restarting transaction and gets it after transaction is restarted.
		*
		* The function returns 0 on success, 1 if transaction had to be restarted,
		* and < 0 in case of fatal error.
		*/
		needed += 3;
		err = ext4_journal_extend(handle, needed - handle->h_buffer_credits);
		if (err <= 0)
		return err;
		err = ext4_truncate_restart_trans(handle, inode, needed);
		if (err == 0)
		err = -EAGAIN;
		int ext4_datasem_ensure_credits(handle_t handle, struct inode inode,
		int check_cred, int restart_cred,
		int revoke_cred)
		{
		int ret;
		int dropped = 0;

		return err;
		ret = ext4_journal_ensure_credits_fn(handle, check_cred, restart_cred,
		revoke_cred, ext4_ext_trunc_restart_fn(inode, &dropped));
		if (dropped)
		down_write(&EXT4_I(inode)->i_data_sem);
		return ret;
		}

		/*
		@@ -1840,7 +1852,8 @@ static void ext4_ext_try_to_merge_up(handle_t *handle,
		* group descriptor to release the extent tree block. If we
		* can't get the journal credits, give up.
		*/
		if (ext4_journal_extend(handle, 2))
		if (ext4_journal_extend(handle, 2,
		ext4_free_metadata_revoke_credits(inode->i_sb, 1)))
		return;

		/*
		@@ -2727,7 +2740,7 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
		{
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
		int err = 0, correct_index = 0;
		int depth = ext_depth(inode), credits;
		int depth = ext_depth(inode), credits, revoke_credits;
		struct ext4_extent_header *eh;
		ext4_lblk_t a, b;
		unsigned num;
		@@ -2819,10 +2832,23 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
		credits += (ext_depth(inode)) + 1;
		}
		credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
		/*
		* We may end up freeing some index blocks and data from the
		* punched range. Note that partial clusters are accounted for
		* by ext4_free_data_revoke_credits().
		*/
		revoke_credits =
		ext4_free_metadata_revoke_credits(inode->i_sb,
		ext_depth(inode)) +
		ext4_free_data_revoke_credits(inode, b - a + 1);

		err = ext4_ext_truncate_extend_restart(handle, inode, credits);
		if (err)
		err = ext4_datasem_ensure_credits(handle, inode, credits,
		credits, revoke_credits);
		if (err) {
		if (err > 0)
		err = -EAGAIN;
		goto out;
		}

		err = ext4_ext_get_access(handle, inode, path + depth);
		if (err)
		@@ -2948,7 +2974,9 @@ int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
		ext_debug("truncate since %u to %u\n", start, end);

		/* probably first extent we're gonna free will be last in block */
		handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, depth + 1);
		handle = ext4_journal_start_with_revoke(inode, EXT4_HT_TRUNCATE,
		depth + 1,
		ext4_free_metadata_revoke_credits(inode->i_sb, depth));
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		@@ -5225,13 +5253,10 @@ ext4_access_path(handle_t handle, struct inode inode,
		* descriptor) for each block group; assume two block
		* groups
		*/
		if (handle->h_buffer_credits < 7) {
		credits = ext4_writepage_trans_blocks(inode);
		err = ext4_ext_truncate_extend_restart(handle, inode, credits);
		/* EAGAIN is success */
		if (err && err != -EAGAIN)
		err = ext4_datasem_ensure_credits(handle, inode, 7, credits, 0);
		if (err < 0)
		return err;
		}

		err = ext4_ext_get_access(handle, inode, path);
		return err;

fs/ext4/ialloc.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -927,7 +927,7 @@ struct inode __ext4_new_inode(handle_t handle, struct inode *dir,
		BUG_ON(nblocks <= 0);
		handle = __ext4_journal_start_sb(dir->i_sb, line_no,
		handle_type, nblocks,
		0);
		0, 0);
		if (IS_ERR(handle)) {
		err = PTR_ERR(handle);
		ext4_std_error(sb, err);