ext4: provide wrappers for transaction reservation calls (5fe2fe89) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/ext4/ext4_jbd2.c

+47 −11

Original line number	Diff line number	Diff line
		@@ -38,31 +38,43 @@ static void ext4_put_nojournal(handle_t *handle)
		/*
		* Wrappers for jbd2_journal_start/end.
		*/
		handle_t __ext4_journal_start_sb(struct super_block sb, unsigned int line,
		int type, int nblocks)
		static int ext4_journal_check_start(struct super_block *sb)
		{
		journal_t *journal;

		might_sleep();

		trace_ext4_journal_start(sb, nblocks, _RET_IP_);
		if (sb->s_flags & MS_RDONLY)
		return ERR_PTR(-EROFS);

		return -EROFS;
		WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);
		journal = EXT4_SB(sb)->s_journal;
		if (!journal)
		return ext4_get_nojournal();
		/*
		* Special case here: if the journal has aborted behind our
		* backs (eg. EIO in the commit thread), then we still need to
		* take the FS itself readonly cleanly.
		*/
		if (is_journal_aborted(journal)) {
		if (journal && is_journal_aborted(journal)) {
		ext4_abort(sb, "Detected aborted journal");
		return ERR_PTR(-EROFS);
		return -EROFS;
		}
		return 0;
		}
		return jbd2__journal_start(journal, nblocks, 0, GFP_NOFS, type, line);

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

		trace_ext4_journal_start(sb, blocks, rsv_blocks, _RET_IP_);
		err = ext4_journal_check_start(sb);
		if (err < 0)
		return ERR_PTR(err);

		journal = EXT4_SB(sb)->s_journal;
		if (!journal)
		return ext4_get_nojournal();
		return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS,
		type, line);
		}

		int __ext4_journal_stop(const char where, unsigned int line, handle_t handle)
		@@ -86,6 +98,30 @@ int __ext4_journal_stop(const char where, unsigned int line, handle_t handle)
		return err;
		}

		handle_t __ext4_journal_start_reserved(handle_t handle, unsigned int line,
		int type)
		{
		struct super_block *sb;
		int err;

		if (!ext4_handle_valid(handle))
		return ext4_get_nojournal();

		sb = handle->h_journal->j_private;
		trace_ext4_journal_start_reserved(sb, handle->h_buffer_credits,
		_RET_IP_);
		err = ext4_journal_check_start(sb);
		if (err < 0) {
		jbd2_journal_free_reserved(handle);
		return ERR_PTR(err);
		}

		err = jbd2_journal_start_reserved(handle, type, line);
		if (err < 0)
		return ERR_PTR(err);
		return handle;
		}

		void ext4_journal_abort_handle(const char *caller, unsigned int line,
		const char err_fn, struct buffer_head bh,
		handle_t *handle, int err)

fs/ext4/ext4_jbd2.h

+21 −5

Original line number	Diff line number	Diff line
		@@ -265,7 +265,7 @@ 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 nblocks);
		int type, int blocks, int rsv_blocks);
		int __ext4_journal_stop(const char where, unsigned int line, handle_t handle);

		#define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
		@@ -300,21 +300,37 @@ static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
		}

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

		#define ext4_journal_start(inode, type, nblocks) \
		__ext4_journal_start((inode), __LINE__, (type), (nblocks))
		__ext4_journal_start((inode), __LINE__, (type), (nblocks), 0)

		#define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks) \
		__ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks))

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

		#define ext4_journal_stop(handle) \
		__ext4_journal_stop(__func__, __LINE__, (handle))

		#define ext4_journal_start_reserve(handle, type) \
		__ext4_journal_start_reserved((handle), __LINE__, (type))

		handle_t __ext4_journal_start_reserved(handle_t handle, unsigned int line,
		int type);

		static inline void ext4_journal_free_reserved(handle_t *handle)
		{
		if (ext4_handle_valid(handle))
		jbd2_journal_free_reserved(handle);
		}

		static inline handle_t *ext4_journal_current_handle(void)
		{
		return journal_current_handle();

fs/ext4/ialloc.c

+2 −1

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

include/trace/events/ext4.h

+33 −8

Original line number	Diff line number	Diff line
		@@ -1640,25 +1640,50 @@ TRACE_EVENT(ext4_load_inode,
		);

		TRACE_EVENT(ext4_journal_start,
		TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
		TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
		unsigned long IP),

		TP_ARGS(sb, nblocks, IP),
		TP_ARGS(sb, blocks, rsv_blocks, IP),

		TP_STRUCT__entry(
		__field( dev_t, dev )
		__field(unsigned long, ip )
		__field( int, nblocks )
		__field( int, blocks )
		__field( int, rsv_blocks )
		),

		TP_fast_assign(
		__entry->dev = sb->s_dev;
		__entry->ip = IP;
		__entry->nblocks = nblocks;
		__entry->blocks = blocks;
		__entry->rsv_blocks = rsv_blocks;
		),

		TP_printk("dev %d,%d nblocks %d caller %pF",
		TP_printk("dev %d,%d blocks, %d rsv_blocks, %d caller %pF",
		MAJOR(__entry->dev), MINOR(__entry->dev),
		__entry->nblocks, (void *)__entry->ip)
		__entry->blocks, __entry->rsv_blocks, (void *)__entry->ip)
		);

		TRACE_EVENT(ext4_journal_start_reserved,
		TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),

		TP_ARGS(sb, blocks, IP),

		TP_STRUCT__entry(
		__field( dev_t, dev )
		__field(unsigned long, ip )
		__field( int, blocks )
		),

		TP_fast_assign(
		__entry->dev = sb->s_dev;
		__entry->ip = IP;
		__entry->blocks = blocks;
		),

		TP_printk("dev %d,%d blocks, %d caller %pF",
		MAJOR(__entry->dev), MINOR(__entry->dev),
		__entry->blocks, (void *)__entry->ip)
		);

		DECLARE_EVENT_CLASS(ext4__trim,