ext4: prevent parallel resizers by atomic bit ops (8f82f840) · Commits · e / devices / android_kernel_teracube_2e

fs/ext4/ext4.h

+6 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1127,7 +1127,8 @@ 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_resize_flags; /* Flags indicating if there
			is a resizer */
	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;
	@@ -2269,6 +2270,10 @@ static inline void set_bitmap_uptodate(struct buffer_head *bh)
	extern wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];		extern wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
	extern struct mutex ext4__aio_mutex[EXT4_WQ_HASH_SZ];		extern struct mutex ext4__aio_mutex[EXT4_WQ_HASH_SZ];

			#define EXT4_RESIZING 0
			extern int ext4_resize_begin(struct super_block *sb);
			extern void ext4_resize_end(struct super_block *sb);

	#endif /* __KERNEL__ */		#endif /* __KERNEL__ */

	#endif /* _EXT4_H */		#endif /* _EXT4_H */

fs/ext4/ioctl.c

+8 −4

Original line number	Original line	Diff line number	Diff line
	@@ -202,8 +202,9 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	struct super_block *sb = inode->i_sb;		struct super_block *sb = inode->i_sb;
	int err, err2=0;		int err, err2=0;

	if (!capable(CAP_SYS_RESOURCE))		err = ext4_resize_begin(sb);
	return -EPERM;		if (err)
			return err;

	if (get_user(n_blocks_count, (__u32 __user *)arg))		if (get_user(n_blocks_count, (__u32 __user *)arg))
	return -EFAULT;		return -EFAULT;
	@@ -221,6 +222,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	if (err == 0)		if (err == 0)
	err = err2;		err = err2;
	mnt_drop_write(filp->f_path.mnt);		mnt_drop_write(filp->f_path.mnt);
			ext4_resize_end(sb);

	return err;		return err;
	}		}
	@@ -271,8 +273,9 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	struct super_block *sb = inode->i_sb;		struct super_block *sb = inode->i_sb;
	int err, err2=0;		int err, err2=0;

	if (!capable(CAP_SYS_RESOURCE))		err = ext4_resize_begin(sb);
	return -EPERM;		if (err)
			return err;

	if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,		if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
	sizeof(input)))		sizeof(input)))
	@@ -291,6 +294,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	if (err == 0)		if (err == 0)
	err = err2;		err = err2;
	mnt_drop_write(filp->f_path.mnt);		mnt_drop_write(filp->f_path.mnt);
			ext4_resize_end(sb);

	return err;		return err;
	}		}

fs/ext4/resize.c

+21 −34

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,25 @@

	#include "ext4_jbd2.h"		#include "ext4_jbd2.h"

			int ext4_resize_begin(struct super_block *sb)
			{
			int ret = 0;

			if (!capable(CAP_SYS_RESOURCE))
			return -EPERM;

			if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags))
			ret = -EBUSY;

			return ret;
			}

			void ext4_resize_end(struct super_block *sb)
			{
			clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags);
			smp_mb__after_clear_bit();
			}

	#define outside(b, first, last) ((b) < (first) \|\| (b) >= (last))		#define outside(b, first, last) ((b) < (first) \|\| (b) >= (last))
	#define inside(b, first, last) ((b) >= (first) && (b) < (last))		#define inside(b, first, last) ((b) >= (first) && (b) < (last))

	@@ -181,11 +200,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);

	mutex_lock(&sbi->s_resize_lock);		BUG_ON(input->group != sbi->s_groups_count);
	if (input->group != sbi->s_groups_count) {
	err = -EBUSY;
	goto exit_journal;
	}

	if (IS_ERR(bh = bclean(handle, sb, input->block_bitmap))) {		if (IS_ERR(bh = bclean(handle, sb, input->block_bitmap))) {
	err = PTR_ERR(bh);		err = PTR_ERR(bh);
	@@ -285,7 +300,6 @@ static int setup_new_group_blocks(struct super_block *sb,
	brelse(bh);		brelse(bh);

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

	@@ -799,13 +813,6 @@ int ext4_group_add(struct super_block sb, struct ext4_new_group_data input)
	goto exit_put;		goto exit_put;
	}		}

	mutex_lock(&sbi->s_resize_lock);
	if (input->group != sbi->s_groups_count) {
	ext4_warning(sb, "multiple resizers run on filesystem!");
	err = -EBUSY;
	goto exit_journal;
	}

	if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh)))		if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh)))
	goto exit_journal;		goto exit_journal;

	@@ -829,7 +836,6 @@ 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.
	*		*
	* 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.
	@@ -886,13 +892,9 @@ 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 s_resize_lock
	* 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 s_resize_lock over the access
	* 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.
	*		*
	@@ -937,7 +939,6 @@ int ext4_group_add(struct super_block sb, struct ext4_new_group_data input)
	ext4_handle_dirty_super(handle, sb);		ext4_handle_dirty_super(handle, sb);

	exit_journal:		exit_journal:
	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) {
	@@ -972,9 +973,6 @@ int ext4_group_extend(struct super_block sb, struct ext4_super_block es,
	int err;		int err;
	ext4_group_t group;		ext4_group_t group;

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

	if (test_opt(sb, DEBUG))		if (test_opt(sb, DEBUG))
	@@ -995,7 +993,7 @@ int ext4_group_extend(struct super_block sb, struct ext4_super_block es,

	if (n_blocks_count < o_blocks_count) {		if (n_blocks_count < o_blocks_count) {
	ext4_warning(sb, "can't shrink FS - resize aborted");		ext4_warning(sb, "can't shrink FS - resize aborted");
	return -EBUSY;		return -EINVAL;
	}		}

	/* Handle the remaining blocks in the last group only. */		/* Handle the remaining blocks in the last group only. */
	@@ -1038,24 +1036,13 @@ int ext4_group_extend(struct super_block sb, struct ext4_super_block es,
	goto exit_put;		goto exit_put;
	}		}

	mutex_lock(&EXT4_SB(sb)->s_resize_lock);
	if (o_blocks_count != ext4_blocks_count(es)) {
	ext4_warning(sb, "multiple resizers run on filesystem!");
	mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
	ext4_journal_stop(handle);
	err = -EBUSY;
	goto exit_put;
	}

	if ((err = ext4_journal_get_write_access(handle,		if ((err = ext4_journal_get_write_access(handle,
	EXT4_SB(sb)->s_sbh))) {		EXT4_SB(sb)->s_sbh))) {
	ext4_warning(sb, "error %d on journal write access", err);		ext4_warning(sb, "error %d on journal write access", err);
	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);
	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 −1

Original line number	Original line	Diff line number	Diff line
	@@ -3500,7 +3500,7 @@ static int ext4_fill_super(struct super_block sb, void data, int silent)

	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);		sbi->s_resize_flags = 0;

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