ext4: Replace lock/unlock_super() with an explicit lock for resizing (32ed5058) · Commits · e / devices / android_kernel_oneplus_sm8150

fs/ext4/ext4_sb.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -72,6 +72,7 @@ struct ext4_sb_info {
	struct journal_s *s_journal;		struct journal_s *s_journal;
	struct list_head s_orphan;		struct list_head s_orphan;
	struct mutex s_orphan_lock;		struct mutex s_orphan_lock;
			struct mutex s_resize_lock;
	unsigned long s_commit_interval;		unsigned long s_commit_interval;
	u32 s_max_batch_time;		u32 s_max_batch_time;
	u32 s_min_batch_time;		u32 s_min_batch_time;

fs/ext4/resize.c

+18 −17

Original line number	Original line	Diff line number	Diff line
	@@ -193,7 +193,7 @@ static int setup_new_group_blocks(struct super_block *sb,
	if (IS_ERR(handle))		if (IS_ERR(handle))
	return PTR_ERR(handle);		return PTR_ERR(handle);

	lock_super(sb);		mutex_lock(&sbi->s_resize_lock);
	if (input->group != sbi->s_groups_count) {		if (input->group != sbi->s_groups_count) {
	err = -EBUSY;		err = -EBUSY;
	goto exit_journal;		goto exit_journal;
	@@ -302,7 +302,7 @@ static int setup_new_group_blocks(struct super_block *sb,
	brelse(bh);		brelse(bh);

	exit_journal:		exit_journal:
	unlock_super(sb);		mutex_unlock(&sbi->s_resize_lock);
	if ((err2 = ext4_journal_stop(handle)) && !err)		if ((err2 = ext4_journal_stop(handle)) && !err)
	err = err2;		err = err2;

	@@ -643,11 +643,12 @@ static int reserve_backup_gdb(handle_t handle, struct inode inode,
	* important part is that the new block and inode counts are in the backup		* important part is that the new block and inode counts are in the backup
	* superblocks, and the location of the new group metadata in the GDT backups.		* superblocks, and the location of the new group metadata in the GDT backups.
	*		*
	* We do not need lock_super() for this, because these blocks are not		* We do not need take the s_resize_lock for this, because these
	* otherwise touched by the filesystem code when it is mounted. We don't		* blocks are not otherwise touched by the filesystem code when it is
	* need to worry about last changing from sbi->s_groups_count, because the		* mounted. We don't need to worry about last changing from
	* worst that can happen is that we do not copy the full number of backups		* sbi->s_groups_count, because the worst that can happen is that we
	* at this time. The resize which changed s_groups_count will backup again.		* do not copy the full number of backups at this time. The resize
			* which changed s_groups_count will backup again.
	*/		*/
	static void update_backups(struct super_block *sb,		static void update_backups(struct super_block *sb,
	int blk_off, char *data, int size)		int blk_off, char *data, int size)
	@@ -809,7 +810,7 @@ int ext4_group_add(struct super_block sb, struct ext4_new_group_data input)
	goto exit_put;		goto exit_put;
	}		}

	lock_super(sb);		mutex_lock(&sbi->s_resize_lock);
	if (input->group != sbi->s_groups_count) {		if (input->group != sbi->s_groups_count) {
	ext4_warning(sb, __func__,		ext4_warning(sb, __func__,
	"multiple resizers run on filesystem!");		"multiple resizers run on filesystem!");
	@@ -840,7 +841,7 @@ int ext4_group_add(struct super_block sb, struct ext4_new_group_data input)
	/*		/*
	* OK, now we've set up the new group. Time to make it active.		* OK, now we've set up the new group. Time to make it active.
	*		*
	* Current kernels don't lock all allocations via lock_super(),		* We do not lock all allocations via s_resize_lock
	* so we have to be safe wrt. concurrent accesses the group		* so we have to be safe wrt. concurrent accesses the group
	* data. So we need to be careful to set all of the relevant		* data. So we need to be careful to set all of the relevant
	* group descriptor data etc. before we enable the group.		* group descriptor data etc. before we enable the group.
	@@ -900,12 +901,12 @@ int ext4_group_add(struct super_block sb, struct ext4_new_group_data input)
	*		*
	* The precise rules we use are:		* The precise rules we use are:
	*		*
	* * Writers of s_groups_count must hold lock_super		* * Writers of s_groups_count must hold s_resize_lock
	* AND		* AND
	* * Writers must perform a smp_wmb() after updating all dependent		* * Writers must perform a smp_wmb() after updating all dependent
	* data and before modifying the groups count		* data and before modifying the groups count
	*		*
	* * Readers must hold lock_super() over the access		* * Readers must hold s_resize_lock over the access
	* OR		* OR
	* * Readers must perform an smp_rmb() after reading the groups count		* * Readers must perform an smp_rmb() after reading the groups count
	* and before reading any dependent data.		* and before reading any dependent data.
	@@ -948,7 +949,7 @@ int ext4_group_add(struct super_block sb, struct ext4_new_group_data input)
	sb->s_dirt = 1;		sb->s_dirt = 1;

	exit_journal:		exit_journal:
	unlock_super(sb);		mutex_unlock(&sbi->s_resize_lock);
	if ((err2 = ext4_journal_stop(handle)) && !err)		if ((err2 = ext4_journal_stop(handle)) && !err)
	err = err2;		err = err2;
	if (!err) {		if (!err) {
	@@ -986,7 +987,7 @@ int ext4_group_extend(struct super_block sb, struct ext4_super_block es,

	/* We don't need to worry about locking wrt other resizers just		/* We don't need to worry about locking wrt other resizers just
	* yet: we're going to revalidate es->s_blocks_count after		* yet: we're going to revalidate es->s_blocks_count after
	* taking lock_super() below. */		* taking the s_resize_lock below. */
	o_blocks_count = ext4_blocks_count(es);		o_blocks_count = ext4_blocks_count(es);
	o_groups_count = EXT4_SB(sb)->s_groups_count;		o_groups_count = EXT4_SB(sb)->s_groups_count;

	@@ -1056,11 +1057,11 @@ int ext4_group_extend(struct super_block sb, struct ext4_super_block es,
	goto exit_put;		goto exit_put;
	}		}

	lock_super(sb);		mutex_lock(&EXT4_SB(sb)->s_resize_lock);
	if (o_blocks_count != ext4_blocks_count(es)) {		if (o_blocks_count != ext4_blocks_count(es)) {
	ext4_warning(sb, __func__,		ext4_warning(sb, __func__,
	"multiple resizers run on filesystem!");		"multiple resizers run on filesystem!");
	unlock_super(sb);		mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
	ext4_journal_stop(handle);		ext4_journal_stop(handle);
	err = -EBUSY;		err = -EBUSY;
	goto exit_put;		goto exit_put;
	@@ -1070,14 +1071,14 @@ int ext4_group_extend(struct super_block sb, struct ext4_super_block es,
	EXT4_SB(sb)->s_sbh))) {		EXT4_SB(sb)->s_sbh))) {
	ext4_warning(sb, __func__,		ext4_warning(sb, __func__,
	"error %d on journal write access", err);		"error %d on journal write access", err);
	unlock_super(sb);		mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
	ext4_journal_stop(handle);		ext4_journal_stop(handle);
	goto exit_put;		goto exit_put;
	}		}
	ext4_blocks_count_set(es, o_blocks_count + add);		ext4_blocks_count_set(es, o_blocks_count + add);
	ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);		ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
	sb->s_dirt = 1;		sb->s_dirt = 1;
	unlock_super(sb);		mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
	ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,		ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
	o_blocks_count + add);		o_blocks_count + add);
	/* We add the blocks to the bitmap and set the group need init bit */		/* We add the blocks to the bitmap and set the group need init bit */

fs/ext4/super.c

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -2646,6 +2646,7 @@ static int ext4_fill_super(struct super_block sb, void data, int silent)
	#endif		#endif
	INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */		INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
	mutex_init(&sbi->s_orphan_lock);		mutex_init(&sbi->s_orphan_lock);
			mutex_init(&sbi->s_resize_lock);

	sb->s_root = NULL;		sb->s_root = NULL;