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

Commit 0567d2f4 authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

Merge 4.20-rc1-4.19 into android-4.19 



* origin/upstream-f2fs-stable-linux-4.19.y:
  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
  f2fs: submit cached bio to avoid endless PageWriteback
  f2fs: checkpoint disabling
  f2fs: clear PageError on the read path
  f2fs: allow out-place-update for direct IO in LFS mode
  f2fs: refactor ->page_mkwrite() flow
  Revert: "f2fs: check last page index in cached bio to decide submission"
  f2fs: support superblock checksum
  f2fs: add to account skip count of background GC
  f2fs: add to account meta IO
  f2fs: keep lazytime on remount
  f2fs: fix missing up_read
  f2fs: return correct errno in f2fs_gc
  f2fs: avoid f2fs_bug_on if f2fs_get_meta_page_nofail got EIO
  f2fs: mark inode dirty explicitly in recover_inode()
  f2fs: fix to recover inode's crtime during POR
  f2fs: fix to recover inode's i_gc_failures during POR
  f2fs: fix to recover inode's i_flags during POR
  f2fs: fix to recover inode's project id during POR
  f2fs: update i_size after DIO completion
  f2fs: report ENOENT correctly in f2fs_rename
  f2fs: fix remount problem of option io_bits
  f2fs: fix to recover inode's uid/gid during POR
  f2fs: avoid infinite loop in f2fs_alloc_nid
  f2fs: add new idle interval timing for discard and gc paths
  f2fs: split IO error injection according to RW
  f2fs: add SPDX license identifiers
  f2fs: surround fault_injection related option parsing using CONFIG_F2FS_FAULT_INJECTION
  f2fs: fix setattr project check upon fssetxattr ioctl
  f2fs: avoid sleeping under spin_lock
  f2fs: plug readahead IO in readdir()
  f2fs: fix to do sanity check with current segment number
  f2fs: fix memory leak of percpu counter in fill_super()
  f2fs: fix memory leak of write_io in fill_super()
  f2fs: cache NULL when both default_acl and acl are NULL
  f2fs: fix to flush all dirty inodes recovered in readonly fs
  f2fs: report error if quota off error during umount
  f2fs: submit bio after shutdown
  f2fs: avoid wrong decrypted data from disk
  Revert "f2fs: use printk_ratelimited for f2fs_msg"
  f2fs: fix unnecessary periodic wakeup of discard thread when dev is busy
  f2fs: fix to avoid NULL pointer dereference on se->discard_map
  f2fs: add additional sanity check in f2fs_acl_from_disk()

Change-Id: I1361fa847523fa7202c865dd00a9284a5815bd57
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@google.com>
parents 6f76e794 08b3d450

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

+77 −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);
@@ -1086,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.

 */
@@ -1097,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);
@@ -1110,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;

	}



	/*
@@ -1119,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);
@@ -1126,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:
@@ -1217,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);
@@ -1424,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);



	/*
@@ -1448,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) &&
@@ -1499,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() */
@@ -1508,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);