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

Commit a9929dfd authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

Merge upstream-f2fs-stable-linux-4.9.y into android-4.9 



* origin/upstream-f2fs-stable-linux-4.9.y:
  f2fs: set pin_file under CAP_SYS_ADMIN
  f2fs: fix to avoid deadlock in f2fs_read_inline_dir()
  f2fs: fix to adapt small inline xattr space in __find_inline_xattr()
  f2fs: fix to do sanity check with inode.i_inline_xattr_size
  f2fs: give some messages for inline_xattr_size
  f2fs: don't trigger read IO for beyond EOF page
  f2fs: fix to add refcount once page is tagged PG_private
  f2fs: remove wrong comment in f2fs_invalidate_page()
  f2fs: fix to use kvfree instead of kzfree
  f2fs: print more parameters in trace_f2fs_map_blocks
  f2fs: trace f2fs_ioc_shutdown
  f2fs: fix to avoid deadlock of atomic file operations
  f2fs: fix to dirty inode for i_mode recovery
  f2fs: give random value to i_generation
  f2fs: no need to take page lock in readdir
  f2fs: fix to update iostat correctly in IPU path
  f2fs: fix encrypted page memory leak
  f2fs: make fault injection covering __submit_flush_wait()
  f2fs: fix to retry fill_super only if recovery failed
  f2fs: silence VM_WARN_ON_ONCE in mempool_alloc
  f2fs: correct spelling mistake
  f2fs: fix wrong #endif
  f2fs: don't clear CP_QUOTA_NEED_FSCK_FLAG
  f2fs: don't allow negative ->write_io_size_bits
  f2fs: fix to check inline_xattr_size boundary correctly
  Revert "f2fs: fix to avoid deadlock of atomic file operations"
  Revert "f2fs: fix to check inline_xattr_size boundary correctly"
  f2fs: do not use mutex lock in atomic context
  f2fs: fix potential data inconsistence of checkpoint
  f2fs: fix to avoid deadlock of atomic file operations
  f2fs: fix to check inline_xattr_size boundary correctly
  f2fs: jump to label 'free_node_inode' when failing from d_make_root()
  f2fs: fix to document inline_xattr_size option
  f2fs: fix to data block override node segment by mistake
  f2fs: fix typos in code comments
  f2fs: use xattr_prefix to wrap up
  f2fs: sync filesystem after roll-forward recovery
  fs: export evict_inodes
  f2fs: flush quota blocks after turnning it off
  f2fs: avoid null pointer exception in dcc_info
  f2fs: don't wake up too frequently, if there is lots of IOs
  f2fs: try to keep CP_TRIMMED_FLAG after successful umount
  f2fs: add quick mode of checkpoint=disable for QA
  f2fs: run discard jobs when put_super
  f2fs: fix to set sbi dirty correctly
  f2fs: UBSAN: set boolean value iostat_enable correctly
  f2fs: add brackets for macros
  f2fs: check if file namelen exceeds max value
  f2fs: fix to trigger fsck if dirent.name_len is zero
  f2fs: no need to check return value of debugfs_create functions
  f2fs: export FS_NOCOW_FL flag to user
  f2fs: check inject_rate validity during configuring
  f2fs: remove set but not used variable 'err'
  f2fs: fix compile warnings: 'struct *' declared inside parameter list
  f2fs: change error code to -ENOMEM from -EINVAL

Change-Id: I25bc1bcf41e7ddef513f180da52fe18a1ebe4245
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@google.com>
parents 572b9da3 67f94d75

Documentation/ABI/testing/sysfs-fs-f2fs

+7 −0
Original line number Diff line number Diff line
@@ -86,6 +86,13 @@ Description: 
		The unit size is one block, now only support configuring in range

		of [1, 512].



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

Date:          January 2019

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

Description:

		Set timeout to issue discard commands during umount.

		Default: 5 secs



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

Date:		January 2014

Contact:	"Jaegeuk Kim" <jaegeuk.kim@samsung.com>

Documentation/filesystems/f2fs.txt

+3 −0
Original line number Diff line number Diff line
@@ -125,6 +125,9 @@ active_logs=%u Support configuring the number of active logs. In the 
disable_ext_identify   Disable the extension list configured by mkfs, so f2fs

                       does not aware of cold files such as media files.

inline_xattr           Enable the inline xattrs feature.

noinline_xattr         Disable the inline xattrs feature.

inline_xattr_size=%u   Support configuring inline xattr size, it depends on

		       flexible inline xattr feature.

inline_data            Enable the inline data feature: New created small(<~3.4k)

                       files can be written into inode block.

inline_dentry          Enable the inline dir feature: data in new created

fs/f2fs/checkpoint.c

+14 −6
Original line number Diff line number Diff line
@@ -306,8 +306,9 @@ static int f2fs_write_meta_pages(struct address_space *mapping, 
		goto skip_write;



	/* collect a number of dirty meta pages and write together */

	if (wbc->for_kupdate ||

		get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META))

	if (wbc->sync_mode != WB_SYNC_ALL &&

			get_pages(sbi, F2FS_DIRTY_META) <

					nr_pages_to_skip(sbi, META))

		goto skip_write;



	/* if locked failed, cp will flush dirty pages instead */
@@ -405,7 +406,7 @@ static int f2fs_set_meta_page_dirty(struct page *page) 
	if (!PageDirty(page)) {

		__set_page_dirty_nobuffers(page);

		inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);

		SetPagePrivate(page);

		f2fs_set_page_private(page, 0);

		f2fs_trace_pid(page);

		return 1;

	}
@@ -956,7 +957,7 @@ void f2fs_update_dirty_page(struct inode *inode, struct page *page) 
	inode_inc_dirty_pages(inode);

	spin_unlock(&sbi->inode_lock[type]);



	SetPagePrivate(page);

	f2fs_set_page_private(page, 0);

	f2fs_trace_pid(page);

}
@@ -1259,10 +1260,17 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	else

		__clear_ckpt_flags(ckpt, CP_DISABLED_FLAG);



	if (is_sbi_flag_set(sbi, SBI_CP_DISABLED_QUICK))

		__set_ckpt_flags(ckpt, CP_DISABLED_QUICK_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_DISABLED_QUICK_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);

	/*

	 * TODO: we count on fsck.f2fs to clear this flag until we figure out

	 * missing cases which clear it incorrectly.

	 */



	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR))

		__set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);

fs/f2fs/data.c

+28 −31
Original line number Diff line number Diff line
@@ -306,9 +306,10 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi, 
		for (; start < F2FS_IO_SIZE(sbi); start++) {

			struct page *page =

				mempool_alloc(sbi->write_io_dummy,

					GFP_NOIO | __GFP_ZERO | __GFP_NOFAIL);

					      GFP_NOIO | __GFP_NOFAIL);

			f2fs_bug_on(sbi, !page);



			zero_user_segment(page, 0, PAGE_SIZE);

			SetPagePrivate(page);

			set_page_private(page, (unsigned long)DUMMY_WRITTEN_PAGE);

			lock_page(page);
@@ -1583,6 +1584,9 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
		if (last_block > last_block_in_file)

			last_block = last_block_in_file;



		/* just zeroing out page which is beyond EOF */

		if (block_in_file >= last_block)

			goto zero_out;

		/*

		 * Map blocks using the previous result first.

		 */
@@ -1595,16 +1599,11 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
		 * Then do more f2fs_map_blocks() calls until we are

		 * done with this page.

		 */

		map.m_flags = 0;



		if (block_in_file < last_block) {

		map.m_lblk = block_in_file;

		map.m_len = last_block - block_in_file;



			if (f2fs_map_blocks(inode, &map, 0,

						F2FS_GET_BLOCK_DEFAULT))

		if (f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT))

			goto set_error_page;

		}

got_it:

		if ((map.m_flags & F2FS_MAP_MAPPED)) {

			block_nr = map.m_pblk + block_in_file - map.m_lblk;
@@ -1619,6 +1618,7 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
								DATA_GENERIC))

				goto set_error_page;

		} else {

zero_out:

			zero_user_segment(page, 0, PAGE_SIZE);

			if (!PageUptodate(page))

				SetPageUptodate(page);
@@ -1893,8 +1893,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio) 
		if (fio->need_lock == LOCK_REQ)

			f2fs_unlock_op(fio->sbi);

		err = f2fs_inplace_write_data(fio);

		if (err && PageWriteback(page))

		if (err) {

			if (f2fs_encrypted_file(inode))

				fscrypt_pullback_bio_page(&fio->encrypted_page,

									true);

			if (PageWriteback(page))

				end_page_writeback(page);

		}

		trace_f2fs_do_write_data_page(fio->page, IPU);

		set_inode_flag(inode, FI_UPDATE_WRITE);

		return err;
@@ -2345,7 +2350,8 @@ static void f2fs_write_failed(struct address_space *mapping, loff_t to) 
		down_write(&F2FS_I(inode)->i_mmap_sem);



		truncate_pagecache(inode, i_size);

		f2fs_truncate_blocks(inode, i_size, true, true);

		if (!IS_NOQUOTA(inode))

			f2fs_truncate_blocks(inode, i_size, true);



		up_write(&F2FS_I(inode)->i_mmap_sem);

		up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -2626,14 +2632,11 @@ static void f2fs_dio_submit_bio(struct bio *bio, struct inode *inode, 
{

	struct f2fs_private_dio *dio;

	bool write = (bio_op(bio) == REQ_OP_WRITE);

	int err;



	dio = f2fs_kzalloc(F2FS_I_SB(inode),

			sizeof(struct f2fs_private_dio), GFP_NOFS);

	if (!dio) {

		err = -ENOMEM;

	if (!dio)

		goto out;

	}



	dio->inode = inode;

	dio->orig_end_io = bio->bi_end_io;
@@ -2779,12 +2782,10 @@ void f2fs_invalidate_page(struct page *page, unsigned int offset, 


	clear_cold_data(page);



	/* This is atomic written page, keep Private */

	if (IS_ATOMIC_WRITTEN_PAGE(page))

		return f2fs_drop_inmem_page(inode, page);



	set_page_private(page, 0);

	ClearPagePrivate(page);

	f2fs_clear_page_private(page);

}



int f2fs_release_page(struct page *page, gfp_t wait)
@@ -2798,8 +2799,7 @@ int f2fs_release_page(struct page *page, gfp_t wait) 
		return 0;



	clear_cold_data(page);

	set_page_private(page, 0);

	ClearPagePrivate(page);

	f2fs_clear_page_private(page);

	return 1;

}
@@ -2867,12 +2867,8 @@ int f2fs_migrate_page(struct address_space *mapping, 
			return -EAGAIN;

	}



	/*

	 * A reference is expected if PagePrivate set when move mapping,

	 * however F2FS breaks this for maintaining dirty page counts when

	 * truncating pages. So here adjusting the 'extra_count' make it work.

	 */

	extra_count = (atomic_written ? 1 : 0) - page_has_private(page);

	/* one extra reference was held for atomic_write page */

	extra_count = atomic_written ? 1 : 0;

	rc = migrate_page_move_mapping(mapping, newpage,

				page, NULL, mode, extra_count);

	if (rc != MIGRATEPAGE_SUCCESS) {
@@ -2893,9 +2889,10 @@ int f2fs_migrate_page(struct address_space *mapping, 
		get_page(newpage);

	}



	if (PagePrivate(page))

		SetPagePrivate(newpage);

	set_page_private(newpage, page_private(page));

	if (PagePrivate(page)) {

		f2fs_set_page_private(newpage, page_private(page));

		f2fs_clear_page_private(page);

	}



	migrate_page_copy(newpage, page);

fs/f2fs/debug.c

+3 −17
Original line number Diff line number Diff line
@@ -522,30 +522,16 @@ void f2fs_destroy_stats(struct f2fs_sb_info *sbi) 
	kvfree(si);

}



int __init f2fs_create_root_stats(void)

void __init f2fs_create_root_stats(void)

{

	struct dentry *file;



	f2fs_debugfs_root = debugfs_create_dir("f2fs", NULL);

	if (!f2fs_debugfs_root)

		return -ENOMEM;



	file = debugfs_create_file("status", S_IRUGO, f2fs_debugfs_root,

			NULL, &stat_fops);

	if (!file) {

		debugfs_remove(f2fs_debugfs_root);

		f2fs_debugfs_root = NULL;

		return -ENOMEM;

	}



	return 0;

	debugfs_create_file("status", S_IRUGO, f2fs_debugfs_root, NULL,

			    &stat_fops);

}



void f2fs_destroy_root_stats(void)

{

	if (!f2fs_debugfs_root)

		return;



	debugfs_remove_recursive(f2fs_debugfs_root);

	f2fs_debugfs_root = NULL;

}