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

Commit 4c1fad64 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull f2fs updates from Jaegeuk Kim:
 "In this round, we've investigated how f2fs deals with errors given by
  our fault injection facility. With this, we could fix several corner
  cases. And, in order to improve the performance, we set inline_dentry
  by default and enhance the exisiting discard issue flow. In addition,
  we added f2fs_migrate_page for better memory management.

  Enhancements:
   - set inline_dentry by default
   - improve discard issue flow
   - add more fault injection cases in f2fs
   - allow block preallocation for encrypted files
   - introduce migrate_page callback function
   - avoid truncating the next direct node block at every checkpoint

  Bug fixes:
   - set page flag correctly between write_begin and write_end
   - missing error handling cases detected by fault injection
   - preallocate blocks regarding to 4KB alignement correctly
   - dentry and filename handling of encryption
   - lost xattrs of directories"

* tag 'for-f2fs-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (69 commits)
  f2fs: introduce update_ckpt_flags to clean up
  f2fs: don't submit irrelevant page
  f2fs: fix to commit bio cache after flushing node pages
  f2fs: introduce get_checkpoint_version for cleanup
  f2fs: remove dead variable
  f2fs: remove redundant io plug
  f2fs: support checkpoint error injection
  f2fs: fix to recover old fault injection config in ->remount_fs
  f2fs: do fault injection initialization in default_options
  f2fs: remove redundant value definition
  f2fs: support configuring fault injection per superblock
  f2fs: adjust display format of segment bit
  f2fs: remove dirty inode pages in error path
  f2fs: do not unnecessarily null-terminate encrypted symlink data
  f2fs: handle errors during recover_orphan_inodes
  f2fs: avoid gc in cp_error case
  f2fs: should put_page for summary page
  f2fs: assign return value in f2fs_gc
  f2fs: add customized migrate_page callback
  f2fs: introduce cp_lock to protect updating of ckpt_flags
  ...
parents 0fb3ca44 e4c5d848

Documentation/filesystems/f2fs.txt

+1 −0
Original line number Diff line number Diff line
@@ -131,6 +131,7 @@ inline_dentry Enable the inline dir feature: data in new created 
                       directory entries can be written into inode block. The

                       space of inode block which is used to store inline

                       dentries is limited to ~3.4k.

noinline_dentry        Diable the inline dentry feature.

flush_merge	       Merge concurrent cache_flush commands as much as possible

                       to eliminate redundant command issues. If the underlying

		       device handles the cache_flush command relatively slowly,

MAINTAINERS

+2 −3
Original line number Diff line number Diff line
@@ -5105,10 +5105,9 @@ F: include/linux/fscrypto.h 


F2FS FILE SYSTEM

M:	Jaegeuk Kim <jaegeuk@kernel.org>

M:	Changman Lee <cm224.lee@samsung.com>

R:	Chao Yu <yuchao0@huawei.com>

M:	Chao Yu <yuchao0@huawei.com>

L:	linux-f2fs-devel@lists.sourceforge.net

W:	http://en.wikipedia.org/wiki/F2FS

W:	https://f2fs.wiki.kernel.org/

T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git

S:	Maintained

F:	Documentation/filesystems/f2fs.txt

fs/f2fs/acl.c

+7 −5
Original line number Diff line number Diff line
@@ -109,14 +109,16 @@ static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size) 
	return ERR_PTR(-EINVAL);

}



static void *f2fs_acl_to_disk(const struct posix_acl *acl, size_t *size)

static void *f2fs_acl_to_disk(struct f2fs_sb_info *sbi,

				const struct posix_acl *acl, size_t *size)

{

	struct f2fs_acl_header *f2fs_acl;

	struct f2fs_acl_entry *entry;

	int i;



	f2fs_acl = f2fs_kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count *

			sizeof(struct f2fs_acl_entry), GFP_NOFS);

	f2fs_acl = f2fs_kmalloc(sbi, sizeof(struct f2fs_acl_header) +

			acl->a_count * sizeof(struct f2fs_acl_entry),

			GFP_NOFS);

	if (!f2fs_acl)

		return ERR_PTR(-ENOMEM);
@@ -175,7 +177,7 @@ static struct posix_acl *__f2fs_get_acl(struct inode *inode, int type, 


	retval = f2fs_getxattr(inode, name_index, "", NULL, 0, dpage);

	if (retval > 0) {

		value = f2fs_kmalloc(retval, GFP_F2FS_ZERO);

		value = f2fs_kmalloc(F2FS_I_SB(inode), retval, GFP_F2FS_ZERO);

		if (!value)

			return ERR_PTR(-ENOMEM);

		retval = f2fs_getxattr(inode, name_index, "", value,
@@ -230,7 +232,7 @@ static int __f2fs_set_acl(struct inode *inode, int type, 
	}



	if (acl) {

		value = f2fs_acl_to_disk(acl, &size);

		value = f2fs_acl_to_disk(F2FS_I_SB(inode), acl, &size);

		if (IS_ERR(value)) {

			clear_inode_flag(inode, FI_ACL_MODE);

			return (int)PTR_ERR(value);

fs/f2fs/acl.h

+0 −1
Original line number Diff line number Diff line
@@ -41,7 +41,6 @@ extern int f2fs_set_acl(struct inode *, struct posix_acl *, int); 
extern int f2fs_init_acl(struct inode *, struct inode *, struct page *,

							struct page *);

#else

#define f2fs_check_acl	NULL

#define f2fs_get_acl	NULL

#define f2fs_set_acl	NULL

fs/f2fs/checkpoint.c

+132 −73
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ struct kmem_cache *inode_entry_slab; 


void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)

{

	set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);

	set_ckpt_flags(sbi, CP_ERROR_FLAG);

	sbi->sb->s_flags |= MS_RDONLY;

	if (!end_io)

		f2fs_flush_merged_bios(sbi);
@@ -267,7 +267,6 @@ static int f2fs_write_meta_pages(struct address_space *mapping, 
				struct writeback_control *wbc)

{

	struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);

	struct blk_plug plug;

	long diff, written;



	/* collect a number of dirty meta pages and write together */
@@ -280,9 +279,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping, 
	/* if mounting is failed, skip writing node pages */

	mutex_lock(&sbi->cp_mutex);

	diff = nr_pages_to_write(sbi, META, wbc);

	blk_start_plug(&plug);

	written = sync_meta_pages(sbi, META, wbc->nr_to_write);

	blk_finish_plug(&plug);

	mutex_unlock(&sbi->cp_mutex);

	wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);

	return 0;
@@ -388,6 +385,9 @@ const struct address_space_operations f2fs_meta_aops = { 
	.set_page_dirty	= f2fs_set_meta_page_dirty,

	.invalidatepage = f2fs_invalidate_page,

	.releasepage	= f2fs_release_page,

#ifdef CONFIG_MIGRATION

	.migratepage    = f2fs_migrate_page,

#endif

};



static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
@@ -491,7 +491,7 @@ int acquire_orphan_inode(struct f2fs_sb_info *sbi) 
	spin_lock(&im->ino_lock);



#ifdef CONFIG_F2FS_FAULT_INJECTION

	if (time_to_inject(FAULT_ORPHAN)) {

	if (time_to_inject(sbi, FAULT_ORPHAN)) {

		spin_unlock(&im->ino_lock);

		return -ENOSPC;

	}
@@ -531,8 +531,20 @@ void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 
static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)

{

	struct inode *inode;

	struct node_info ni;

	int err = acquire_orphan_inode(sbi);



	inode = f2fs_iget(sbi->sb, ino);

	if (err) {

		set_sbi_flag(sbi, SBI_NEED_FSCK);

		f2fs_msg(sbi->sb, KERN_WARNING,

				"%s: orphan failed (ino=%x), run fsck to fix.",

				__func__, ino);

		return err;

	}



	__add_ino_entry(sbi, ino, ORPHAN_INO);



	inode = f2fs_iget_retry(sbi->sb, ino);

	if (IS_ERR(inode)) {

		/*

		 * there should be a bug that we can't find the entry
@@ -546,6 +558,18 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 


	/* truncate all the data during iput */

	iput(inode);



	get_node_info(sbi, ino, &ni);



	/* ENOMEM was fully retried in f2fs_evict_inode. */

	if (ni.blk_addr != NULL_ADDR) {

		set_sbi_flag(sbi, SBI_NEED_FSCK);

		f2fs_msg(sbi->sb, KERN_WARNING,

			"%s: orphan failed (ino=%x), run fsck to fix.",

				__func__, ino);

		return -EIO;

	}

	__remove_ino_entry(sbi, ino, ORPHAN_INO);

	return 0;

}
@@ -554,7 +578,7 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi) 
	block_t start_blk, orphan_blocks, i, j;

	int err;



	if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))

	if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))

		return 0;



	start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
@@ -578,7 +602,7 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi) 
		f2fs_put_page(page, 1);

	}

	/* clear Orphan Flag */

	clear_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG);

	clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG);

	return 0;

}
@@ -639,45 +663,55 @@ static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk) 
	}

}



static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,

				block_t cp_addr, unsigned long long *version)

static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr,

		struct f2fs_checkpoint **cp_block, struct page **cp_page,

		unsigned long long *version)

{

	struct page *cp_page_1, *cp_page_2 = NULL;

	unsigned long blk_size = sbi->blocksize;

	struct f2fs_checkpoint *cp_block;

	unsigned long long cur_version = 0, pre_version = 0;

	size_t crc_offset;

	size_t crc_offset = 0;

	__u32 crc = 0;



	/* Read the 1st cp block in this CP pack */

	cp_page_1 = get_meta_page(sbi, cp_addr);

	*cp_page = get_meta_page(sbi, cp_addr);

	*cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);



	/* get the version number */

	cp_block = (struct f2fs_checkpoint *)page_address(cp_page_1);

	crc_offset = le32_to_cpu(cp_block->checksum_offset);

	if (crc_offset >= blk_size)

		goto invalid_cp1;

	crc_offset = le32_to_cpu((*cp_block)->checksum_offset);

	if (crc_offset >= blk_size) {

		f2fs_msg(sbi->sb, KERN_WARNING,

			"invalid crc_offset: %zu", crc_offset);

		return -EINVAL;

	}



	crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset)));

	if (!f2fs_crc_valid(sbi, crc, cp_block, crc_offset))

		goto invalid_cp1;

	crc = le32_to_cpu(*((__le32 *)((unsigned char *)*cp_block

							+ crc_offset)));

	if (!f2fs_crc_valid(sbi, crc, *cp_block, crc_offset)) {

		f2fs_msg(sbi->sb, KERN_WARNING, "invalid crc value");

		return -EINVAL;

	}



	pre_version = cur_cp_version(cp_block);

	*version = cur_cp_version(*cp_block);

	return 0;

}



	/* Read the 2nd cp block in this CP pack */

	cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;

	cp_page_2 = get_meta_page(sbi, cp_addr);

static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,

				block_t cp_addr, unsigned long long *version)

{

	struct page *cp_page_1 = NULL, *cp_page_2 = NULL;

	struct f2fs_checkpoint *cp_block = NULL;

	unsigned long long cur_version = 0, pre_version = 0;

	int err;



	cp_block = (struct f2fs_checkpoint *)page_address(cp_page_2);

	crc_offset = le32_to_cpu(cp_block->checksum_offset);

	if (crc_offset >= blk_size)

		goto invalid_cp2;

	err = get_checkpoint_version(sbi, cp_addr, &cp_block,

					&cp_page_1, version);

	if (err)

		goto invalid_cp1;

	pre_version = *version;



	crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset)));

	if (!f2fs_crc_valid(sbi, crc, cp_block, crc_offset))

	cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;

	err = get_checkpoint_version(sbi, cp_addr, &cp_block,

					&cp_page_2, version);

	if (err)

		goto invalid_cp2;



	cur_version = cur_cp_version(cp_block);

	cur_version = *version;



	if (cur_version == pre_version) {

		*version = cur_version;
@@ -972,10 +1006,40 @@ static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi) 
	finish_wait(&sbi->cp_wait, &wait);

}



static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)

{

	unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;

	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);



	spin_lock(&sbi->cp_lock);



	if (cpc->reason == CP_UMOUNT)

		__set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);



	if (cpc->reason == CP_FASTBOOT)

		__set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);



	if (orphan_num)

		__set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);



	if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))

		__set_ckpt_flags(ckpt, CP_FSCK_FLAG);



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

	__set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);



	spin_unlock(&sbi->cp_lock);

}



static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)

{

	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

	struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);

	struct f2fs_nm_info *nm_i = NM_I(sbi);

	unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;

	nid_t last_nid = nm_i->next_scan_nid;
@@ -984,19 +1048,10 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	__u32 crc32 = 0;

	int i;

	int cp_payload_blks = __cp_payload(sbi);

	block_t discard_blk = NEXT_FREE_BLKADDR(sbi, curseg);

	bool invalidate = false;

	struct super_block *sb = sbi->sb;

	struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);

	u64 kbytes_written;



	/*

	 * This avoids to conduct wrong roll-forward operations and uses

	 * metapages, so should be called prior to sync_meta_pages below.

	 */

	if (!test_opt(sbi, LFS) && discard_next_dnode(sbi, discard_blk))

		invalidate = true;



	/* Flush all the NAT/SIT pages */

	while (get_pages(sbi, F2FS_DIRTY_META)) {

		sync_meta_pages(sbi, META, LONG_MAX);
@@ -1036,10 +1091,12 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	/* 2 cp  + n data seg summary + orphan inode blocks */

	data_sum_blocks = npages_for_summary_flush(sbi, false);

	spin_lock(&sbi->cp_lock);

	if (data_sum_blocks < NR_CURSEG_DATA_TYPE)

		set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);

		__set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);

	else

		clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);

		__clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);

	spin_unlock(&sbi->cp_lock);



	orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num);

	ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
@@ -1054,23 +1111,8 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
				cp_payload_blks + data_sum_blocks +

				orphan_blocks);



	if (cpc->reason == CP_UMOUNT)

		set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);

	else

		clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);



	if (cpc->reason == CP_FASTBOOT)

		set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);

	else

		clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);



	if (orphan_num)

		set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);

	else

		clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);



	if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))

		set_ckpt_flags(ckpt, CP_FSCK_FLAG);

	/* update ckpt flag for checkpoint */

	update_ckpt_flags(sbi, cpc);



	/* update SIT/NAT bitmap */

	get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
@@ -1137,14 +1179,6 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	/* wait for previous submitted meta pages writeback */

	wait_on_all_pages_writeback(sbi);



	/*

	 * invalidate meta page which is used temporarily for zeroing out

	 * block at the end of warm node chain.

	 */

	if (invalidate)

		invalidate_mapping_pages(META_MAPPING(sbi), discard_blk,

								discard_blk);



	release_ino_entry(sbi, false);



	if (unlikely(f2fs_cp_error(sbi)))
@@ -1152,6 +1186,17 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	clear_prefree_segments(sbi, cpc);

	clear_sbi_flag(sbi, SBI_IS_DIRTY);

	clear_sbi_flag(sbi, SBI_NEED_CP);



	/*

	 * redirty superblock if metadata like node page or inode cache is

	 * updated during writing checkpoint.

	 */

	if (get_pages(sbi, F2FS_DIRTY_NODES) ||

			get_pages(sbi, F2FS_DIRTY_IMETA))

		set_sbi_flag(sbi, SBI_IS_DIRTY);



	f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS));



	return 0;

}
@@ -1190,6 +1235,18 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	f2fs_flush_merged_bios(sbi);



	/* this is the case of multiple fstrims without any changes */

	if (cpc->reason == CP_DISCARD && !is_sbi_flag_set(sbi, SBI_IS_DIRTY)) {

		f2fs_bug_on(sbi, NM_I(sbi)->dirty_nat_cnt);

		f2fs_bug_on(sbi, SIT_I(sbi)->dirty_sentries);

		f2fs_bug_on(sbi, prefree_segments(sbi));

		flush_sit_entries(sbi, cpc);

		clear_prefree_segments(sbi, cpc);

		f2fs_wait_all_discard_bio(sbi);

		unblock_operations(sbi);

		goto out;

	}



	/*

	 * update checkpoint pack index

	 * Increase the version number so that
@@ -1205,6 +1262,8 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	/* unlock all the fs_lock[] in do_checkpoint() */

	err = do_checkpoint(sbi, cpc);



	f2fs_wait_all_discard_bio(sbi);



	unblock_operations(sbi);

	stat_inc_cp_count(sbi->stat_info);