Revert "f2fs: refactor resize_fs to avoid meta updates in progress" (9bbb9189) · Commits · e / devices / android_kernel_xiaomi_nabu

fs/f2fs/checkpoint.c

+2 −4

Original line number	Diff line number	Diff line
		@@ -1559,7 +1559,6 @@ int f2fs_write_checkpoint(struct f2fs_sb_info sbi, struct cp_control cpc)
		return 0;
		f2fs_warn(sbi, "Start checkpoint disabled!");
		}
		if (cpc->reason != CP_RESIZE)
		mutex_lock(&sbi->cp_mutex);

		if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
		@@ -1629,7 +1628,6 @@ int f2fs_write_checkpoint(struct f2fs_sb_info sbi, struct cp_control cpc)
		f2fs_update_time(sbi, CP_TIME);
		trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
		out:
		if (cpc->reason != CP_RESIZE)
		mutex_unlock(&sbi->cp_mutex);
		return err;
		}

fs/f2fs/f2fs.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -194,7 +194,6 @@ enum {
		#define CP_DISCARD 0x00000010
		#define CP_TRIMMED 0x00000020
		#define CP_PAUSE 0x00000040
		#define CP_RESIZE 0x00000080

		#define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
		#define DEF_MAX_DISCARD_REQUEST 8 /* issue 8 discards per round */
		@@ -1428,6 +1427,7 @@ struct f2fs_sb_info {
		unsigned int segs_per_sec; /* segments per section */
		unsigned int secs_per_zone; /* sections per zone */
		unsigned int total_sections; /* total section count */
		struct mutex resize_mutex; /* for resize exclusion */
		unsigned int total_node_count; /* total node block count */
		unsigned int total_valid_node_count; /* valid node block count */
		loff_t max_file_blocks; /* max block index of file */

fs/f2fs/file.c

+4 −1

Original line number	Diff line number	Diff line
		@@ -3307,6 +3307,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg)
		{
		struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
		__u64 block_count;
		int ret;

		if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
		@@ -3318,7 +3319,9 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg)
		sizeof(block_count)))
		return -EFAULT;

		return f2fs_resize_fs(sbi, block_count);
		ret = f2fs_resize_fs(sbi, block_count);

		return ret;
		}

		static int f2fs_ioc_enable_verity(struct file *filp, unsigned long arg)

fs/f2fs/gc.c

+49 −68

Original line number	Diff line number	Diff line
		@@ -13,7 +13,6 @@
		#include <linux/kthread.h>
		#include <linux/delay.h>
		#include <linux/freezer.h>
		#include <linux/sched/signal.h>

		#include "f2fs.h"
		#include "node.h"
		@@ -1406,29 +1405,12 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)
		GET_SEGNO(sbi, FDEV(0).end_blk) + 1;
		}

		static int free_segment_range(struct f2fs_sb_info *sbi,
		unsigned int secs, bool gc_only)
		static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,
		unsigned int end)
		{
		unsigned int segno, next_inuse, start, end;
		struct cp_control cpc = { CP_RESIZE, 0, 0, 0 };
		int gc_mode, gc_type;
		int err = 0;
		int type;

		/* Force block allocation for GC */
		MAIN_SECS(sbi) -= secs;
		start = MAIN_SECS(sbi) * sbi->segs_per_sec;
		end = MAIN_SEGS(sbi) - 1;

		mutex_lock(&DIRTY_I(sbi)->seglist_lock);
		for (gc_mode = 0; gc_mode < MAX_GC_POLICY; gc_mode++)
		if (SIT_I(sbi)->last_victim[gc_mode] >= start)
		SIT_I(sbi)->last_victim[gc_mode] = 0;

		for (gc_type = BG_GC; gc_type <= FG_GC; gc_type++)
		if (sbi->next_victim_seg[gc_type] >= start)
		sbi->next_victim_seg[gc_type] = NULL_SEGNO;
		mutex_unlock(&DIRTY_I(sbi)->seglist_lock);
		unsigned int segno, next_inuse;
		int err = 0;

		/* Move out cursegs from the target range */
		for (type = CURSEG_HOT_DATA; type < NR_CURSEG_TYPE; type++)
		@@ -1441,24 +1423,18 @@ static int free_segment_range(struct f2fs_sb_info *sbi,
		.iroot = RADIX_TREE_INIT(GFP_NOFS),
		};

		down_write(&sbi->gc_lock);
		do_garbage_collect(sbi, segno, &gc_list, FG_GC);
		up_write(&sbi->gc_lock);
		put_gc_inode(&gc_list);

		if (!gc_only && get_valid_blocks(sbi, segno, true)) {
		err = -EAGAIN;
		goto out;
		}
		if (fatal_signal_pending(current)) {
		err = -ERESTARTSYS;
		goto out;
		}
		if (get_valid_blocks(sbi, segno, true))
		return -EAGAIN;
		}
		if (gc_only)
		goto out;

		err = f2fs_write_checkpoint(sbi, &cpc);
		err = f2fs_sync_fs(sbi->sb, 1);
		if (err)
		goto out;
		return err;

		next_inuse = find_next_inuse(FREE_I(sbi), end + 1, start);
		if (next_inuse <= end) {
		@@ -1466,8 +1442,6 @@ static int free_segment_range(struct f2fs_sb_info *sbi,
		next_inuse);
		f2fs_bug_on(sbi, 1);
		}
		out:
		MAIN_SECS(sbi) += secs;
		return err;
		}

		@@ -1513,7 +1487,6 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)

		SM_I(sbi)->segment_count = (int)SM_I(sbi)->segment_count + segs;
		MAIN_SEGS(sbi) = (int)MAIN_SEGS(sbi) + segs;
		MAIN_SECS(sbi) += secs;
		FREE_I(sbi)->free_sections = (int)FREE_I(sbi)->free_sections + secs;
		FREE_I(sbi)->free_segments = (int)FREE_I(sbi)->free_segments + segs;
		F2FS_CKPT(sbi)->user_block_count = cpu_to_le64(user_block_count + blks);
		@@ -1535,8 +1508,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
		int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)
		{
		__u64 old_block_count, shrunk_blocks;
		struct cp_control cpc = { CP_RESIZE, 0, 0, 0 };
		unsigned int secs;
		int gc_mode, gc_type;
		int err = 0;
		__u32 rem;

		@@ -1571,27 +1544,10 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)
		return -EINVAL;
		}

		freeze_bdev(sbi->sb->s_bdev);

		shrunk_blocks = old_block_count - block_count;
		secs = div_u64(shrunk_blocks, BLKS_PER_SEC(sbi));

		/* stop other GC */
		if (!down_write_trylock(&sbi->gc_lock))
		return -EAGAIN;

		/* stop CP to protect MAIN_SEC in free_segment_range */
		f2fs_lock_op(sbi);
		err = free_segment_range(sbi, secs, true);
		f2fs_unlock_op(sbi);
		up_write(&sbi->gc_lock);
		if (err)
		return err;

		set_sbi_flag(sbi, SBI_IS_RESIZEFS);

		freeze_super(sbi->sb);
		down_write(&sbi->gc_lock);
		mutex_lock(&sbi->cp_mutex);

		spin_lock(&sbi->stat_lock);
		if (shrunk_blocks + valid_user_blocks(sbi) +
		sbi->current_reserved_blocks + sbi->unusable_block_count +
		@@ -1600,44 +1556,69 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)
		else
		sbi->user_block_count -= shrunk_blocks;
		spin_unlock(&sbi->stat_lock);
		if (err)
		goto out_err;
		if (err) {
		thaw_bdev(sbi->sb->s_bdev, sbi->sb);
		return err;
		}

		mutex_lock(&sbi->resize_mutex);
		set_sbi_flag(sbi, SBI_IS_RESIZEFS);

		mutex_lock(&DIRTY_I(sbi)->seglist_lock);

		MAIN_SECS(sbi) -= secs;

		for (gc_mode = 0; gc_mode < MAX_GC_POLICY; gc_mode++)
		if (SIT_I(sbi)->last_victim[gc_mode] >=
		MAIN_SECS(sbi) * sbi->segs_per_sec)
		SIT_I(sbi)->last_victim[gc_mode] = 0;

		for (gc_type = BG_GC; gc_type <= FG_GC; gc_type++)
		if (sbi->next_victim_seg[gc_type] >=
		MAIN_SECS(sbi) * sbi->segs_per_sec)
		sbi->next_victim_seg[gc_type] = NULL_SEGNO;

		err = free_segment_range(sbi, secs, false);
		mutex_unlock(&DIRTY_I(sbi)->seglist_lock);

		err = free_segment_range(sbi, MAIN_SECS(sbi) * sbi->segs_per_sec,
		MAIN_SEGS(sbi) - 1);
		if (err)
		goto recover_out;
		goto out;

		update_sb_metadata(sbi, -secs);

		err = f2fs_commit_super(sbi, false);
		if (err) {
		update_sb_metadata(sbi, secs);
		goto recover_out;
		goto out;
		}

		mutex_lock(&sbi->cp_mutex);
		update_fs_metadata(sbi, -secs);
		clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
		set_sbi_flag(sbi, SBI_IS_DIRTY);
		mutex_unlock(&sbi->cp_mutex);

		err = f2fs_write_checkpoint(sbi, &cpc);
		err = f2fs_sync_fs(sbi->sb, 1);
		if (err) {
		mutex_lock(&sbi->cp_mutex);
		update_fs_metadata(sbi, secs);
		mutex_unlock(&sbi->cp_mutex);
		update_sb_metadata(sbi, secs);
		f2fs_commit_super(sbi, false);
		}
		recover_out:
		out:
		if (err) {
		set_sbi_flag(sbi, SBI_NEED_FSCK);
		f2fs_err(sbi, "resize_fs failed, should run fsck to repair!");

		MAIN_SECS(sbi) += secs;
		spin_lock(&sbi->stat_lock);
		sbi->user_block_count += shrunk_blocks;
		spin_unlock(&sbi->stat_lock);
		}
		out_err:
		mutex_unlock(&sbi->cp_mutex);
		up_write(&sbi->gc_lock);
		thaw_super(sbi->sb);
		clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
		mutex_unlock(&sbi->resize_mutex);
		thaw_bdev(sbi->sb->s_bdev, sbi->sb);
		return err;
		}

fs/f2fs/super.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -3441,6 +3441,7 @@ static int f2fs_fill_super(struct super_block sb, void data, int silent)
		init_rwsem(&sbi->gc_lock);
		mutex_init(&sbi->writepages);
		mutex_init(&sbi->cp_mutex);
		mutex_init(&sbi->resize_mutex);
		init_rwsem(&sbi->node_write);
		init_rwsem(&sbi->node_change);