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

Commit 274c0e74 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull f2fs update from Jaegeuk Kim:
 "In this round, we've mainly focused on performance tuning and critical
  bug fixes occurred in low-end devices. Sheng Yong introduced
  lost_found feature to keep missing files during recovery instead of
  thrashing them. We're preparing coming fsverity implementation. And,
  we've got more features to communicate with users for better
  performance. In low-end devices, some memory-related issues were
  fixed, and subtle race condtions and corner cases were addressed as
  well.

  Enhancements:
   - large nat bitmaps for more free node ids
   - add three block allocation policies to pass down write hints given by user
   - expose extension list to user and introduce hot file extension
   - tune small devices seamlessly for low-end devices
   - set readdir_ra by default
   - give more resources under gc_urgent mode regarding to discard and cleaning
   - introduce fsync_mode to enforce posix or not
   - nowait aio support
   - add lost_found feature to keep dangling inodes
   - reserve bits for future fsverity feature
   - add test_dummy_encryption for FBE

  Bug fixes:
   - don't use highmem for dentry pages
   - align memory boundary for bitops
   - truncate preallocated blocks in write errors
   - guarantee i_times on fsync call
   - clear CP_TRIMMED_FLAG correctly
   - prevent node chain loop during recovery
   - avoid data race between atomic write and background cleaning
   - avoid unnecessary selinux violation warnings on resgid option
   - GFP_NOFS to avoid deadlock in quota and read paths
   - fix f2fs_skip_inode_update to allow i_size recovery

  In addition to the above, there are several minor bug fixes and clean-ups"

* tag 'f2fs-for-4.17' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (50 commits)
  f2fs: remain written times to update inode during fsync
  f2fs: make assignment of t->dentry_bitmap more readable
  f2fs: truncate preallocated blocks in error case
  f2fs: fix a wrong condition in f2fs_skip_inode_update
  f2fs: reserve bits for fs-verity
  f2fs: Add a segment type check in inplace write
  f2fs: no need to initialize zero value for GFP_F2FS_ZERO
  f2fs: don't track new nat entry in nat set
  f2fs: clean up with F2FS_BLK_ALIGN
  f2fs: check blkaddr more accuratly before issue a bio
  f2fs: Set GF_NOFS in read_cache_page_gfp while doing f2fs_quota_read
  f2fs: introduce a new mount option test_dummy_encryption
  f2fs: introduce F2FS_FEATURE_LOST_FOUND feature
  f2fs: release locks before return in f2fs_ioc_gc_range()
  f2fs: align memory boundary for bitops
  f2fs: remove unneeded set_cold_node()
  f2fs: add nowait aio support
  f2fs: wrap all options with f2fs_sb_info.mount_opt
  f2fs: Don't overwrite all types of node to keep node chain
  f2fs: introduce mount option for fsync mode
  ...
parents 052c220d 214c2461

Documentation/ABI/testing/sysfs-fs-f2fs

+11 −0
Original line number Diff line number Diff line
@@ -192,3 +192,14 @@ Date: November 2017 
Contact:	"Sheng Yong" <shengyong1@huawei.com>

Description:

		 Controls readahead inode block in readdir.



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

Date:		Feburary 2018

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

Description:

		 Used to control configure extension list:

		 - Query: cat /sys/fs/f2fs/<disk>/extension_list

		 - Add: echo '[h/c]extension' > /sys/fs/f2fs/<disk>/extension_list

		 - Del: echo '[h/c]!extension' > /sys/fs/f2fs/<disk>/extension_list

		 - [h] means add/del hot file extension

		 - [c] means add/del cold file extension

Documentation/filesystems/f2fs.txt

+77 −0
Original line number Diff line number Diff line
@@ -174,6 +174,23 @@ offgrpjquota Turn off group journelled quota. 
offprjjquota           Turn off project journelled quota.

quota                  Enable plain user disk quota accounting.

noquota                Disable all plain disk quota option.

whint_mode=%s          Control which write hints are passed down to block

                       layer. This supports "off", "user-based", and

                       "fs-based".  In "off" mode (default), f2fs does not pass

                       down hints. In "user-based" mode, f2fs tries to pass

                       down hints given by users. And in "fs-based" mode, f2fs

                       passes down hints with its policy.

alloc_mode=%s          Adjust block allocation policy, which supports "reuse"

                       and "default".

fsync_mode=%s          Control the policy of fsync. Currently supports "posix"

                       and "strict". In "posix" mode, which is default, fsync

                       will follow POSIX semantics and does a light operation

                       to improve the filesystem performance. In "strict" mode,

                       fsync will be heavy and behaves in line with xfs, ext4

                       and btrfs, where xfstest generic/342 will pass, but the

                       performance will regress.

test_dummy_encryption  Enable dummy encryption, which provides a fake fscrypt

                       context. The fake fscrypt context is used by xfstests.



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

DEBUGFS ENTRIES
@@ -611,3 +628,63 @@ algorithm. 
In order to identify whether the data in the victim segment are valid or not,

F2FS manages a bitmap. Each bit represents the validity of a block, and the

bitmap is composed of a bit stream covering whole blocks in main area.



Write-hint Policy

-----------------



1) whint_mode=off. F2FS only passes down WRITE_LIFE_NOT_SET.



2) whint_mode=user-based. F2FS tries to pass down hints given by

users.



User                  F2FS                     Block

----                  ----                     -----

                      META                     WRITE_LIFE_NOT_SET

                      HOT_NODE                 "

                      WARM_NODE                "

                      COLD_NODE                "

*ioctl(COLD)          COLD_DATA                WRITE_LIFE_EXTREME

*extension list       "                        "



-- buffered io

WRITE_LIFE_EXTREME    COLD_DATA                WRITE_LIFE_EXTREME

WRITE_LIFE_SHORT      HOT_DATA                 WRITE_LIFE_SHORT

WRITE_LIFE_NOT_SET    WARM_DATA                WRITE_LIFE_NOT_SET

WRITE_LIFE_NONE       "                        "

WRITE_LIFE_MEDIUM     "                        "

WRITE_LIFE_LONG       "                        "



-- direct io

WRITE_LIFE_EXTREME    COLD_DATA                WRITE_LIFE_EXTREME

WRITE_LIFE_SHORT      HOT_DATA                 WRITE_LIFE_SHORT

WRITE_LIFE_NOT_SET    WARM_DATA                WRITE_LIFE_NOT_SET

WRITE_LIFE_NONE       "                        WRITE_LIFE_NONE

WRITE_LIFE_MEDIUM     "                        WRITE_LIFE_MEDIUM

WRITE_LIFE_LONG       "                        WRITE_LIFE_LONG



3) whint_mode=fs-based. F2FS passes down hints with its policy.



User                  F2FS                     Block

----                  ----                     -----

                      META                     WRITE_LIFE_MEDIUM;

                      HOT_NODE                 WRITE_LIFE_NOT_SET

                      WARM_NODE                "

                      COLD_NODE                WRITE_LIFE_NONE

ioctl(COLD)           COLD_DATA                WRITE_LIFE_EXTREME

extension list        "                        "



-- buffered io

WRITE_LIFE_EXTREME    COLD_DATA                WRITE_LIFE_EXTREME

WRITE_LIFE_SHORT      HOT_DATA                 WRITE_LIFE_SHORT

WRITE_LIFE_NOT_SET    WARM_DATA                WRITE_LIFE_LONG

WRITE_LIFE_NONE       "                        "

WRITE_LIFE_MEDIUM     "                        "

WRITE_LIFE_LONG       "                        "



-- direct io

WRITE_LIFE_EXTREME    COLD_DATA                WRITE_LIFE_EXTREME

WRITE_LIFE_SHORT      HOT_DATA                 WRITE_LIFE_SHORT

WRITE_LIFE_NOT_SET    WARM_DATA                WRITE_LIFE_NOT_SET

WRITE_LIFE_NONE       "                        WRITE_LIFE_NONE

WRITE_LIFE_MEDIUM     "                        WRITE_LIFE_MEDIUM

WRITE_LIFE_LONG       "                        WRITE_LIFE_LONG

fs/f2fs/checkpoint.c

+66 −35
Original line number Diff line number Diff line
@@ -68,6 +68,7 @@ static struct page *__get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index, 
		.old_blkaddr = index,

		.new_blkaddr = index,

		.encrypted_page = NULL,

		.is_meta = is_meta,

	};



	if (unlikely(!is_meta))
@@ -162,6 +163,7 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, 
		.op_flags = sync ? (REQ_META | REQ_PRIO) : REQ_RAHEAD,

		.encrypted_page = NULL,

		.in_list = false,

		.is_meta = (type != META_POR),

	};

	struct blk_plug plug;
@@ -569,13 +571,8 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 
	struct node_info ni;

	int err = acquire_orphan_inode(sbi);



	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;

	}

	if (err)

		goto err_out;



	__add_ino_entry(sbi, ino, 0, ORPHAN_INO);
@@ -589,6 +586,11 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 
		return PTR_ERR(inode);

	}



	err = dquot_initialize(inode);

	if (err)

		goto err_out;



	dquot_initialize(inode);

	clear_nlink(inode);



	/* truncate all the data during iput */
@@ -598,14 +600,18 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 


	/* 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) by kernel, retry mount.",

				__func__, ino);

		return -EIO;

		err = -EIO;

		goto err_out;

	}

	__remove_ino_entry(sbi, ino, ORPHAN_INO);

	return 0;



err_out:

	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;

}



int recover_orphan_inodes(struct f2fs_sb_info *sbi)
@@ -1136,6 +1142,8 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	if (cpc->reason & CP_TRIMMED)

		__set_ckpt_flags(ckpt, CP_TRIMMED_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_TRIMMED_FLAG);



	if (cpc->reason & CP_UMOUNT)

		__set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
@@ -1162,6 +1170,39 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	spin_unlock_irqrestore(&sbi->cp_lock, flags);

}



static void commit_checkpoint(struct f2fs_sb_info *sbi,

	void *src, block_t blk_addr)

{

	struct writeback_control wbc = {

		.for_reclaim = 0,

	};



	/*

	 * pagevec_lookup_tag and lock_page again will take

	 * some extra time. Therefore, update_meta_pages and

	 * sync_meta_pages are combined in this function.

	 */

	struct page *page = grab_meta_page(sbi, blk_addr);

	int err;



	memcpy(page_address(page), src, PAGE_SIZE);

	set_page_dirty(page);



	f2fs_wait_on_page_writeback(page, META, true);

	f2fs_bug_on(sbi, PageWriteback(page));

	if (unlikely(!clear_page_dirty_for_io(page)))

		f2fs_bug_on(sbi, 1);



	/* writeout cp pack 2 page */

	err = __f2fs_write_meta_page(page, &wbc, FS_CP_META_IO);

	f2fs_bug_on(sbi, err);



	f2fs_put_page(page, 0);



	/* submit checkpoint (with barrier if NOBARRIER is not set) */

	f2fs_submit_merged_write(sbi, META_FLUSH);

}



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

{

	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
@@ -1264,16 +1305,6 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
		}

	}



	/* need to wait for end_io results */

	wait_on_all_pages_writeback(sbi);

	if (unlikely(f2fs_cp_error(sbi)))

		return -EIO;



	/* flush all device cache */

	err = f2fs_flush_device_cache(sbi);

	if (err)

		return err;



	/* write out checkpoint buffer at block 0 */

	update_meta_page(sbi, ckpt, start_blk++);
@@ -1301,26 +1332,26 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
		start_blk += NR_CURSEG_NODE_TYPE;

	}



	/* writeout checkpoint block */

	update_meta_page(sbi, ckpt, start_blk);

	/* update user_block_counts */

	sbi->last_valid_block_count = sbi->total_valid_block_count;

	percpu_counter_set(&sbi->alloc_valid_block_count, 0);



	/* Here, we have one bio having CP pack except cp pack 2 page */

	sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);



	/* wait for previous submitted node/meta pages writeback */

	/* wait for previous submitted meta pages writeback */

	wait_on_all_pages_writeback(sbi);



	if (unlikely(f2fs_cp_error(sbi)))

		return -EIO;



	filemap_fdatawait_range(NODE_MAPPING(sbi), 0, LLONG_MAX);

	filemap_fdatawait_range(META_MAPPING(sbi), 0, LLONG_MAX);



	/* update user_block_counts */

	sbi->last_valid_block_count = sbi->total_valid_block_count;

	percpu_counter_set(&sbi->alloc_valid_block_count, 0);



	/* Here, we only have one bio having CP pack */

	sync_meta_pages(sbi, META_FLUSH, LONG_MAX, FS_CP_META_IO);

	/* flush all device cache */

	err = f2fs_flush_device_cache(sbi);

	if (err)

		return err;



	/* wait for previous submitted meta pages writeback */

	/* barrier and flush checkpoint cp pack 2 page if it can */

	commit_checkpoint(sbi, ckpt, start_blk);

	wait_on_all_pages_writeback(sbi);



	release_ino_entry(sbi, false);

fs/f2fs/data.c

+64 −21
Original line number Diff line number Diff line
@@ -175,15 +175,22 @@ static bool __same_bdev(struct f2fs_sb_info *sbi, 
 */

static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,

				struct writeback_control *wbc,

				int npages, bool is_read)

				int npages, bool is_read,

				enum page_type type, enum temp_type temp)

{

	struct bio *bio;



	bio = f2fs_bio_alloc(sbi, npages, true);



	f2fs_target_device(sbi, blk_addr, bio);

	bio->bi_end_io = is_read ? f2fs_read_end_io : f2fs_write_end_io;

	bio->bi_private = is_read ? NULL : sbi;

	if (is_read) {

		bio->bi_end_io = f2fs_read_end_io;

		bio->bi_private = NULL;

	} else {

		bio->bi_end_io = f2fs_write_end_io;

		bio->bi_private = sbi;

		bio->bi_write_hint = io_type_to_rw_hint(sbi, type, temp);

	}

	if (wbc)

		wbc_init_bio(wbc, bio);
@@ -196,13 +203,12 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi, 
	if (!is_read_io(bio_op(bio))) {

		unsigned int start;



		if (f2fs_sb_mounted_blkzoned(sbi->sb) &&

			current->plug && (type == DATA || type == NODE))

			blk_finish_plug(current->plug);



		if (type != DATA && type != NODE)

			goto submit_io;



		if (f2fs_sb_has_blkzoned(sbi->sb) && current->plug)

			blk_finish_plug(current->plug);



		start = bio->bi_iter.bi_size >> F2FS_BLKSIZE_BITS;

		start %= F2FS_IO_SIZE(sbi);
@@ -377,12 +383,13 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) 
	struct page *page = fio->encrypted_page ?

			fio->encrypted_page : fio->page;



	verify_block_addr(fio, fio->new_blkaddr);

	trace_f2fs_submit_page_bio(page, fio);

	f2fs_trace_ios(fio, 0);



	/* Allocate a new bio */

	bio = __bio_alloc(fio->sbi, fio->new_blkaddr, fio->io_wbc,

				1, is_read_io(fio->op));

				1, is_read_io(fio->op), fio->type, fio->temp);



	if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {

		bio_put(bio);
@@ -422,8 +429,8 @@ int f2fs_submit_page_write(struct f2fs_io_info *fio) 
	}



	if (fio->old_blkaddr != NEW_ADDR)

		verify_block_addr(sbi, fio->old_blkaddr);

	verify_block_addr(sbi, fio->new_blkaddr);

		verify_block_addr(fio, fio->old_blkaddr);

	verify_block_addr(fio, fio->new_blkaddr);



	bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;
@@ -445,7 +452,8 @@ int f2fs_submit_page_write(struct f2fs_io_info *fio) 
			goto out_fail;

		}

		io->bio = __bio_alloc(sbi, fio->new_blkaddr, fio->io_wbc,

						BIO_MAX_PAGES, false);

						BIO_MAX_PAGES, false,

						fio->type, fio->temp);

		io->fio = *fio;

	}
@@ -832,13 +840,6 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type) 
	return 0;

}



static inline bool __force_buffered_io(struct inode *inode, int rw)

{

	return (f2fs_encrypted_file(inode) ||

			(rw == WRITE && test_opt(F2FS_I_SB(inode), LFS)) ||

			F2FS_I_SB(inode)->s_ndevs);

}



int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)

{

	struct inode *inode = file_inode(iocb->ki_filp);
@@ -870,7 +871,7 @@ int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from) 


	if (direct_io) {

		map.m_seg_type = rw_hint_to_seg_type(iocb->ki_hint);

		flag = __force_buffered_io(inode, WRITE) ?

		flag = f2fs_force_buffered_io(inode, WRITE) ?

					F2FS_GET_BLOCK_PRE_AIO :

					F2FS_GET_BLOCK_PRE_DIO;

		goto map_blocks;
@@ -1114,6 +1115,31 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
	return err;

}



bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len)

{

	struct f2fs_map_blocks map;

	block_t last_lblk;

	int err;



	if (pos + len > i_size_read(inode))

		return false;



	map.m_lblk = F2FS_BYTES_TO_BLK(pos);

	map.m_next_pgofs = NULL;

	map.m_next_extent = NULL;

	map.m_seg_type = NO_CHECK_TYPE;

	last_lblk = F2FS_BLK_ALIGN(pos + len);



	while (map.m_lblk < last_lblk) {

		map.m_len = last_lblk - map.m_lblk;

		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);

		if (err || map.m_len == 0)

			return false;

		map.m_lblk += map.m_len;

	}

	return true;

}



static int __get_data_block(struct inode *inode, sector_t iblock,

			struct buffer_head *bh, int create, int flag,

			pgoff_t *next_pgofs, int seg_type)
@@ -2287,25 +2313,41 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) 
{

	struct address_space *mapping = iocb->ki_filp->f_mapping;

	struct inode *inode = mapping->host;

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	size_t count = iov_iter_count(iter);

	loff_t offset = iocb->ki_pos;

	int rw = iov_iter_rw(iter);

	int err;

	enum rw_hint hint = iocb->ki_hint;

	int whint_mode = F2FS_OPTION(sbi).whint_mode;



	err = check_direct_IO(inode, iter, offset);

	if (err)

		return err;



	if (__force_buffered_io(inode, rw))

	if (f2fs_force_buffered_io(inode, rw))

		return 0;



	trace_f2fs_direct_IO_enter(inode, offset, count, rw);



	if (rw == WRITE && whint_mode == WHINT_MODE_OFF)

		iocb->ki_hint = WRITE_LIFE_NOT_SET;



	if (!down_read_trylock(&F2FS_I(inode)->dio_rwsem[rw])) {

		if (iocb->ki_flags & IOCB_NOWAIT) {

			iocb->ki_hint = hint;

			err = -EAGAIN;

			goto out;

		}

		down_read(&F2FS_I(inode)->dio_rwsem[rw]);

	}



	err = blockdev_direct_IO(iocb, inode, iter, get_data_block_dio);

	up_read(&F2FS_I(inode)->dio_rwsem[rw]);



	if (rw == WRITE) {

		if (whint_mode == WHINT_MODE_OFF)

			iocb->ki_hint = hint;

		if (err > 0) {

			f2fs_update_iostat(F2FS_I_SB(inode), APP_DIRECT_IO,

									err);
@@ -2315,6 +2357,7 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) 
		}

	}



out:

	trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);



	return err;

fs/f2fs/dir.c

+10 −22
Original line number Diff line number Diff line
@@ -94,14 +94,12 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, 
	struct f2fs_dir_entry *de;

	struct f2fs_dentry_ptr d;



	dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);

	dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);



	make_dentry_ptr_block(NULL, &d, dentry_blk);

	de = find_target_dentry(fname, namehash, max_slots, &d);

	if (de)

		*res_page = dentry_page;

	else

		kunmap(dentry_page);



	return de;

}
@@ -287,7 +285,6 @@ ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr, 
	de = f2fs_find_entry(dir, qstr, page);

	if (de) {

		res = le32_to_cpu(de->ino);

		f2fs_dentry_kunmap(dir, *page);

		f2fs_put_page(*page, 0);

	}
@@ -302,7 +299,6 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, 
	f2fs_wait_on_page_writeback(page, type, true);

	de->ino = cpu_to_le32(inode->i_ino);

	set_de_type(de, inode->i_mode);

	f2fs_dentry_kunmap(dir, page);

	set_page_dirty(page);



	dir->i_mtime = dir->i_ctime = current_time(dir);
@@ -350,13 +346,11 @@ static int make_empty_dir(struct inode *inode, 
	if (IS_ERR(dentry_page))

		return PTR_ERR(dentry_page);



	dentry_blk = kmap_atomic(dentry_page);

	dentry_blk = page_address(dentry_page);



	make_dentry_ptr_block(NULL, &d, dentry_blk);

	do_make_empty_dir(inode, parent, &d);



	kunmap_atomic(dentry_blk);



	set_page_dirty(dentry_page);

	f2fs_put_page(dentry_page, 1);

	return 0;
@@ -367,6 +361,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 
			struct page *dpage)

{

	struct page *page;

	int dummy_encrypt = DUMMY_ENCRYPTION_ENABLED(F2FS_I_SB(dir));

	int err;



	if (is_inode_flag_set(inode, FI_NEW_INODE)) {
@@ -393,7 +388,8 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 
		if (err)

			goto put_error;



		if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {

		if ((f2fs_encrypted_inode(dir) || dummy_encrypt) &&

					f2fs_may_encrypt(inode)) {

			err = fscrypt_inherit_context(dir, inode, page, false);

			if (err)

				goto put_error;
@@ -402,8 +398,6 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 
		page = get_node_page(F2FS_I_SB(dir), inode->i_ino);

		if (IS_ERR(page))

			return page;



		set_cold_node(inode, page);

	}



	if (new_name) {
@@ -547,13 +541,12 @@ int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name, 
		if (IS_ERR(dentry_page))

			return PTR_ERR(dentry_page);



		dentry_blk = kmap(dentry_page);

		dentry_blk = page_address(dentry_page);

		bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,

						slots, NR_DENTRY_IN_BLOCK);

		if (bit_pos < NR_DENTRY_IN_BLOCK)

			goto add_dentry;



		kunmap(dentry_page);

		f2fs_put_page(dentry_page, 1);

	}
@@ -588,7 +581,6 @@ int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name, 
	if (inode)

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



	kunmap(dentry_page);

	f2fs_put_page(dentry_page, 1);



	return err;
@@ -642,7 +634,6 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, 
		F2FS_I(dir)->task = NULL;

	}

	if (de) {

		f2fs_dentry_kunmap(dir, page);

		f2fs_put_page(page, 0);

		err = -EEXIST;

	} else if (IS_ERR(page)) {
@@ -713,6 +704,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 


	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);



	if (F2FS_OPTION(F2FS_I_SB(dir)).fsync_mode == FSYNC_MODE_STRICT)

		add_ino_entry(F2FS_I_SB(dir), dir->i_ino, TRANS_DIR_INO);



	if (f2fs_has_inline_dentry(dir))
@@ -730,7 +722,6 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
	bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,

			NR_DENTRY_IN_BLOCK,

			0);

	kunmap(page); /* kunmap - pair of f2fs_find_entry */

	set_page_dirty(page);



	dir->i_ctime = dir->i_mtime = current_time(dir);
@@ -775,7 +766,7 @@ bool f2fs_empty_dir(struct inode *dir) 
				return false;

		}



		dentry_blk = kmap_atomic(dentry_page);

		dentry_blk = page_address(dentry_page);

		if (bidx == 0)

			bit_pos = 2;

		else
@@ -783,7 +774,6 @@ bool f2fs_empty_dir(struct inode *dir) 
		bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,

						NR_DENTRY_IN_BLOCK,

						bit_pos);

		kunmap_atomic(dentry_blk);



		f2fs_put_page(dentry_page, 1);
@@ -901,19 +891,17 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx) 
			}

		}



		dentry_blk = kmap(dentry_page);

		dentry_blk = page_address(dentry_page);



		make_dentry_ptr_block(inode, &d, dentry_blk);



		err = f2fs_fill_dentries(ctx, &d,

				n * NR_DENTRY_IN_BLOCK, &fstr);

		if (err) {

			kunmap(dentry_page);

			f2fs_put_page(dentry_page, 1);

			break;

		}



		kunmap(dentry_page);

		f2fs_put_page(dentry_page, 1);

	}

out_free: