Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d6edff78 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'f2fs-for-4.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs 

Pull f2fs updates from Jaegeuk Kim:
 "In this round, we've added 1) superblock checksum feature, 2)
  implemented new mount option which we can disable/enable checkpoint to
  provide atomic updates of entire filesystem, 3) refactored quota
  operations to enhance its consistency along with checkpoint, 4) fixed
  subtle IO hang conditions and roll-forward recovery flow to resurrect
  any fsync'ed inode metadata.

  Enhancements:
   - add checksum to keep superblock contents more safe
   - add checkpoint=disable/enable to support A/B update of entire filesystem
   - use plug for readahead IO in readdir
   - add more IO counts to avoid block layer hacks

  Bug fixes:
   - prevent data corruption issue for hardware encryption
   - fix IO hang issues when GC is heavily triggered
   - add missing up_read in __write_node_page
   - recover inode metadata during roll-forward recovery flow
   - fix null pointer dereference issue in wrongly configured discard map

  There are some more sanity checks and minor bug fixes as well"

* tag 'f2fs-for-4.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (62 commits)
  f2fs: fix to keep project quota consistent
  f2fs: guarantee journalled quota data by checkpoint
  f2fs: cleanup dirty pages if recover failed
  f2fs: fix data corruption issue with hardware encryption
  f2fs: fix to recover inode->i_flags of inode block during POR
  f2fs: spread f2fs_set_inode_flags()
  f2fs: fix to spread clear_cold_data()
  Revert "f2fs: fix to clear PG_checked flag in set_page_dirty()"
  f2fs: account read IOs and use IO counts for is_idle
  f2fs: fix to account IO correctly for cgroup writeback
  f2fs: fix to account IO correctly
  f2fs: remove request_list check in is_idle()
  f2fs: allow to mount, if quota is failed
  f2fs: update REQ_TIME in f2fs_cross_rename()
  f2fs: do not update REQ_TIME in case of error conditions
  f2fs: remove unneeded disable_nat_bits()
  f2fs: remove unused sbi->trigger_ssr_threshold
  f2fs: shrink sbi->sb_lock coverage in set_file_temperature()
  f2fs: use rb_*_cached friends
  f2fs: fix to recover cold bit of inode block during POR
  ...
parents fe0142df 78130819

Documentation/ABI/testing/sysfs-fs-f2fs

+16 −1
Original line number Diff line number Diff line
@@ -121,7 +121,22 @@ What: /sys/fs/f2fs/<disk>/idle_interval 
Date:		January 2016

Contact:	"Jaegeuk Kim" <jaegeuk@kernel.org>

Description:

		 Controls the idle timing.

		 Controls the idle timing for all paths other than

		 discard and gc path.



What:		/sys/fs/f2fs/<disk>/discard_idle_interval

Date:		September 2018

Contact:	"Chao Yu" <yuchao0@huawei.com>

Contact:	"Sahitya Tummala" <stummala@codeaurora.org>

Description:

		 Controls the idle timing for discard path.



What:		/sys/fs/f2fs/<disk>/gc_idle_interval

Date:		September 2018

Contact:	"Chao Yu" <yuchao0@huawei.com>

Contact:	"Sahitya Tummala" <stummala@codeaurora.org>

Description:

		 Controls the idle timing for gc path.



What:		/sys/fs/f2fs/<disk>/iostat_enable

Date:		August 2017

Documentation/filesystems/f2fs.txt

+7 −1
Original line number Diff line number Diff line
@@ -172,9 +172,10 @@ fault_type=%d Support configuring fault injection type, should be 
                       FAULT_DIR_DEPTH		0x000000100

                       FAULT_EVICT_INODE	0x000000200

                       FAULT_TRUNCATE		0x000000400

                       FAULT_IO			0x000000800

                       FAULT_READ_IO		0x000000800

                       FAULT_CHECKPOINT		0x000001000

                       FAULT_DISCARD		0x000002000

                       FAULT_WRITE_IO		0x000004000

mode=%s                Control block allocation mode which supports "adaptive"

                       and "lfs". In "lfs" mode, there should be no random

                       writes towards main area.
@@ -211,6 +212,11 @@ fsync_mode=%s Control the policy of fsync. Currently supports "posix", 
                       non-atomic files likewise "nobarrier" mount option.

test_dummy_encryption  Enable dummy encryption, which provides a fake fscrypt

                       context. The fake fscrypt context is used by xfstests.

checkpoint=%s          Set to "disable" to turn off checkpointing. Set to "enable"

                       to reenable checkpointing. Is enabled by default. While

                       disabled, any unmounting or unexpected shutdowns will cause

                       the filesystem contents to appear as they did when the

                       filesystem was mounted with that option.



================================================================================

DEBUGFS ENTRIES

fs/f2fs/acl.c

+8 −4
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * fs/f2fs/acl.c

 *
@@ -7,10 +8,6 @@ 
 * Portions of this code from linux/fs/ext2/acl.c

 *

 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#include <linux/f2fs_fs.h>

#include "f2fs.h"
@@ -53,6 +50,9 @@ static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size) 
	struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1);

	const char *end = value + size;



	if (size < sizeof(struct f2fs_acl_header))

		return ERR_PTR(-EINVAL);



	if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION))

		return ERR_PTR(-EINVAL);
@@ -394,12 +394,16 @@ int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage, 
		error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,

				       ipage);

		posix_acl_release(default_acl);

	} else {

		inode->i_default_acl = NULL;

	}

	if (acl) {

		if (!error)

			error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl,

					       ipage);

		posix_acl_release(acl);

	} else {

		inode->i_acl = NULL;

	}



	return error;

fs/f2fs/acl.h

+1 −4
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * fs/f2fs/acl.h

 *
@@ -7,10 +8,6 @@ 
 * Portions of this code from linux/fs/ext2/acl.h

 *

 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#ifndef __F2FS_ACL_H__

#define __F2FS_ACL_H__

fs/f2fs/checkpoint.c

+79 −15
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * fs/f2fs/checkpoint.c

 *

 * Copyright (c) 2012 Samsung Electronics Co., Ltd.

 *             http://www.samsung.com/

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#include <linux/fs.h>

#include <linux/bio.h>
@@ -122,11 +119,8 @@ struct page *f2fs_get_meta_page_nofail(struct f2fs_sb_info *sbi, pgoff_t index) 
		if (PTR_ERR(page) == -EIO &&

				++count <= DEFAULT_RETRY_IO_COUNT)

			goto retry;



		f2fs_stop_checkpoint(sbi, false);

		f2fs_bug_on(sbi, 1);

	}



	return page;

}
@@ -282,8 +276,7 @@ static int __f2fs_write_meta_page(struct page *page, 
	dec_page_count(sbi, F2FS_DIRTY_META);



	if (wbc->for_reclaim)

		f2fs_submit_merged_write_cond(sbi, page->mapping->host,

						0, page->index, META);

		f2fs_submit_merged_write_cond(sbi, NULL, page, 0, META);



	unlock_page(page);
@@ -696,6 +689,8 @@ int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi) 
	/* clear Orphan Flag */

	clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG);

out:

	set_sbi_flag(sbi, SBI_IS_RECOVERED);



#ifdef CONFIG_QUOTA

	/* Turn quotas off */

	if (quota_enabled)
@@ -1084,6 +1079,21 @@ static void __prepare_cp_block(struct f2fs_sb_info *sbi) 
	ckpt->next_free_nid = cpu_to_le32(last_nid);

}



static bool __need_flush_quota(struct f2fs_sb_info *sbi)

{

	if (!is_journalled_quota(sbi))

		return false;

	if (is_sbi_flag_set(sbi, SBI_QUOTA_SKIP_FLUSH))

		return false;

	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR))

		return false;

	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_FLUSH))

		return true;

	if (get_pages(sbi, F2FS_DIRTY_QDATA))

		return true;

	return false;

}



/*

 * Freeze all the FS-operations for checkpoint.

 */
@@ -1095,12 +1105,36 @@ static int block_operations(struct f2fs_sb_info *sbi) 
		.for_reclaim = 0,

	};

	struct blk_plug plug;

	int err = 0;

	int err = 0, cnt = 0;



	blk_start_plug(&plug);



retry_flush_dents:

retry_flush_quotas:

	if (__need_flush_quota(sbi)) {

		int locked;



		if (++cnt > DEFAULT_RETRY_QUOTA_FLUSH_COUNT) {

			set_sbi_flag(sbi, SBI_QUOTA_SKIP_FLUSH);

			f2fs_lock_all(sbi);

			goto retry_flush_dents;

		}

		clear_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);



		/* only failed during mount/umount/freeze/quotactl */

		locked = down_read_trylock(&sbi->sb->s_umount);

		f2fs_quota_sync(sbi->sb, -1);

		if (locked)

			up_read(&sbi->sb->s_umount);

	}



	f2fs_lock_all(sbi);

	if (__need_flush_quota(sbi)) {

		f2fs_unlock_all(sbi);

		cond_resched();

		goto retry_flush_quotas;

	}



retry_flush_dents:

	/* write all the dirty dentry pages */

	if (get_pages(sbi, F2FS_DIRTY_DENTS)) {

		f2fs_unlock_all(sbi);
@@ -1108,7 +1142,7 @@ static int block_operations(struct f2fs_sb_info *sbi) 
		if (err)

			goto out;

		cond_resched();

		goto retry_flush_dents;

		goto retry_flush_quotas;

	}



	/*
@@ -1117,6 +1151,12 @@ static int block_operations(struct f2fs_sb_info *sbi) 
	 */

	down_write(&sbi->node_change);



	if (__need_flush_quota(sbi)) {

		up_write(&sbi->node_change);

		f2fs_unlock_all(sbi);

		goto retry_flush_quotas;

	}



	if (get_pages(sbi, F2FS_DIRTY_IMETA)) {

		up_write(&sbi->node_change);

		f2fs_unlock_all(sbi);
@@ -1124,7 +1164,7 @@ static int block_operations(struct f2fs_sb_info *sbi) 
		if (err)

			goto out;

		cond_resched();

		goto retry_flush_dents;

		goto retry_flush_quotas;

	}



retry_flush_nodes:
@@ -1215,6 +1255,19 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))

		__set_ckpt_flags(ckpt, CP_FSCK_FLAG);



	if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))

		__set_ckpt_flags(ckpt, CP_DISABLED_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_DISABLED_FLAG);



	if (is_sbi_flag_set(sbi, SBI_QUOTA_SKIP_FLUSH))

		__set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);



	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR))

		__set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);



	/* set this flag to activate crc|cp_ver for recovery */

	__set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);

	__clear_ckpt_flags(ckpt, CP_NOCRC_RECOVERY_FLAG);
@@ -1422,6 +1475,8 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	clear_sbi_flag(sbi, SBI_IS_DIRTY);

	clear_sbi_flag(sbi, SBI_NEED_CP);

	clear_sbi_flag(sbi, SBI_QUOTA_SKIP_FLUSH);

	sbi->unusable_block_count = 0;

	__set_cp_next_pack(sbi);



	/*
@@ -1446,6 +1501,12 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	unsigned long long ckpt_ver;

	int err = 0;



	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {

		if (cpc->reason != CP_PAUSE)

			return 0;

		f2fs_msg(sbi->sb, KERN_WARNING,

				"Start checkpoint disabled!");

	}

	mutex_lock(&sbi->cp_mutex);



	if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
@@ -1497,7 +1558,10 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);



	/* write cached NAT/SIT entries to NAT/SIT area */

	f2fs_flush_nat_entries(sbi, cpc);

	err = f2fs_flush_nat_entries(sbi, cpc);

	if (err)

		goto stop;



	f2fs_flush_sit_entries(sbi, cpc);



	/* unlock all the fs_lock[] in do_checkpoint() */
@@ -1506,7 +1570,7 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
		f2fs_release_discard_addrs(sbi);

	else

		f2fs_clear_prefree_segments(sbi, cpc);



stop:

	unblock_operations(sbi);

	stat_inc_cp_count(sbi->stat_info);