// SPDX-License-Identifier: GPL-2.0

  /*

   * fs/f2fs/data.c
   *
   * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   *             http://www.samsung.com/

   */
  #include <linux/fs.h>
  #include <linux/f2fs_fs.h>
  #include <linux/buffer_head.h>
  #include <linux/mpage.h>
  #include <linux/writeback.h>
  #include <linux/backing-dev.h>

  #include <linux/pagevec.h>

  #include <linux/blkdev.h>
  #include <linux/bio.h>

  #include <linux/swap.h>

  #include <linux/prefetch.h>

  #include <linux/uio.h>

  #include <linux/cleancache.h>

  #include <linux/sched/signal.h>

  
  #include "f2fs.h"
  #include "node.h"
  #include "segment.h"

  #include "trace.h"

  #include <trace/events/f2fs.h>

  #define NUM_PREALLOC_POST_READ_CTXS	128
  
  static struct kmem_cache *bio_post_read_ctx_cache;

  static struct kmem_cache *bio_entry_slab;

  static mempool_t *bio_post_read_ctx_pool;

  static bool __is_cp_guaranteed(struct page *page)
  {
  	struct address_space *mapping = page->mapping;
  	struct inode *inode;
  	struct f2fs_sb_info *sbi;
  
  	if (!mapping)
  		return false;
  
  	inode = mapping->host;
  	sbi = F2FS_I_SB(inode);
  
  	if (inode->i_ino == F2FS_META_INO(sbi) ||
  			inode->i_ino ==  F2FS_NODE_INO(sbi) ||
  			S_ISDIR(inode->i_mode) ||

  			(S_ISREG(inode->i_mode) &&

  			(f2fs_is_atomic_file(inode) || IS_NOQUOTA(inode))) ||

  			is_cold_data(page))
  		return true;
  	return false;
  }

  static enum count_type __read_io_type(struct page *page)
  {

  	struct address_space *mapping = page_file_mapping(page);

  
  	if (mapping) {
  		struct inode *inode = mapping->host;
  		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  
  		if (inode->i_ino == F2FS_META_INO(sbi))
  			return F2FS_RD_META;
  
  		if (inode->i_ino == F2FS_NODE_INO(sbi))
  			return F2FS_RD_NODE;
  	}
  	return F2FS_RD_DATA;
  }

  /* postprocessing steps for read bios */
  enum bio_post_read_step {
  	STEP_INITIAL = 0,
  	STEP_DECRYPT,

  	STEP_VERITY,

  };
  
  struct bio_post_read_ctx {
  	struct bio *bio;
  	struct work_struct work;
  	unsigned int cur_step;
  	unsigned int enabled_steps;
  };
  
  static void __read_end_io(struct bio *bio)

  {

  	struct page *page;
  	struct bio_vec *bv;

  	struct bvec_iter_all iter_all;

  	bio_for_each_segment_all(bv, bio, iter_all) {

  		page = bv->bv_page;
  
  		/* PG_error was set if any post_read step failed */
  		if (bio->bi_status || PageError(page)) {
  			ClearPageUptodate(page);

  			/* will re-read again later */
  			ClearPageError(page);

  		} else {
  			SetPageUptodate(page);
  		}

  		dec_page_count(F2FS_P_SB(page), __read_io_type(page));

  		unlock_page(page);
  	}
  	if (bio->bi_private)
  		mempool_free(bio->bi_private, bio_post_read_ctx_pool);
  	bio_put(bio);
  }
  
  static void bio_post_read_processing(struct bio_post_read_ctx *ctx);
  
  static void decrypt_work(struct work_struct *work)
  {
  	struct bio_post_read_ctx *ctx =
  		container_of(work, struct bio_post_read_ctx, work);
  
  	fscrypt_decrypt_bio(ctx->bio);
  
  	bio_post_read_processing(ctx);
  }

  static void verity_work(struct work_struct *work)
  {
  	struct bio_post_read_ctx *ctx =
  		container_of(work, struct bio_post_read_ctx, work);
  
  	fsverity_verify_bio(ctx->bio);
  
  	bio_post_read_processing(ctx);
  }

  static void bio_post_read_processing(struct bio_post_read_ctx *ctx)
  {

  	/*
  	 * We use different work queues for decryption and for verity because
  	 * verity may require reading metadata pages that need decryption, and
  	 * we shouldn't recurse to the same workqueue.
  	 */

  	switch (++ctx->cur_step) {
  	case STEP_DECRYPT:
  		if (ctx->enabled_steps & (1 << STEP_DECRYPT)) {
  			INIT_WORK(&ctx->work, decrypt_work);
  			fscrypt_enqueue_decrypt_work(&ctx->work);
  			return;
  		}
  		ctx->cur_step++;
  		/* fall-through */

  	case STEP_VERITY:
  		if (ctx->enabled_steps & (1 << STEP_VERITY)) {
  			INIT_WORK(&ctx->work, verity_work);
  			fsverity_enqueue_verify_work(&ctx->work);
  			return;
  		}
  		ctx->cur_step++;
  		/* fall-through */

  	default:
  		__read_end_io(ctx->bio);
  	}
  }
  
  static bool f2fs_bio_post_read_required(struct bio *bio)
  {
  	return bio->bi_private && !bio->bi_status;
  }
  
  static void f2fs_read_end_io(struct bio *bio)
  {

  	struct f2fs_sb_info *sbi = F2FS_P_SB(bio_first_page_all(bio));
  
  	if (time_to_inject(sbi, FAULT_READ_IO)) {
  		f2fs_show_injection_info(sbi, FAULT_READ_IO);

  		bio->bi_status = BLK_STS_IOERR;

  	}

  	if (f2fs_bio_post_read_required(bio)) {
  		struct bio_post_read_ctx *ctx = bio->bi_private;

  		ctx->cur_step = STEP_INITIAL;
  		bio_post_read_processing(ctx);
  		return;

  	}

  
  	__read_end_io(bio);

  }

  static void f2fs_write_end_io(struct bio *bio)

  {

  	struct f2fs_sb_info *sbi = bio->bi_private;

  	struct bio_vec *bvec;

  	struct bvec_iter_all iter_all;

  	if (time_to_inject(sbi, FAULT_WRITE_IO)) {

  		f2fs_show_injection_info(sbi, FAULT_WRITE_IO);

  		bio->bi_status = BLK_STS_IOERR;
  	}

  	bio_for_each_segment_all(bvec, bio, iter_all) {

  		struct page *page = bvec->bv_page;

  		enum count_type type = WB_DATA_TYPE(page);

  		if (IS_DUMMY_WRITTEN_PAGE(page)) {
  			set_page_private(page, (unsigned long)NULL);
  			ClearPagePrivate(page);
  			unlock_page(page);
  			mempool_free(page, sbi->write_io_dummy);

  			if (unlikely(bio->bi_status))

  				f2fs_stop_checkpoint(sbi, true);
  			continue;
  		}

  		fscrypt_finalize_bounce_page(&page);

  		if (unlikely(bio->bi_status)) {

  			mapping_set_error(page->mapping, -EIO);

  			if (type == F2FS_WB_CP_DATA)
  				f2fs_stop_checkpoint(sbi, true);

  		}

  
  		f2fs_bug_on(sbi, page->mapping == NODE_MAPPING(sbi) &&
  					page->index != nid_of_node(page));

  		dec_page_count(sbi, type);

  		if (f2fs_in_warm_node_list(sbi, page))
  			f2fs_del_fsync_node_entry(sbi, page);

  		clear_cold_data(page);

  		end_page_writeback(page);

  	}

  	if (!get_pages(sbi, F2FS_WB_CP_DATA) &&

  				wq_has_sleeper(&sbi->cp_wait))

  		wake_up(&sbi->cp_wait);
  
  	bio_put(bio);
  }

  /*

   * Return true, if pre_bio's bdev is same as its target device.
   */
  struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
  				block_t blk_addr, struct bio *bio)
  {
  	struct block_device *bdev = sbi->sb->s_bdev;
  	int i;

  	if (f2fs_is_multi_device(sbi)) {
  		for (i = 0; i < sbi->s_ndevs; i++) {
  			if (FDEV(i).start_blk <= blk_addr &&
  			    FDEV(i).end_blk >= blk_addr) {
  				blk_addr -= FDEV(i).start_blk;
  				bdev = FDEV(i).bdev;
  				break;
  			}

  		}
  	}
  	if (bio) {

  		bio_set_dev(bio, bdev);

  		bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);
  	}
  	return bdev;
  }
  
  int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr)
  {
  	int i;

  	if (!f2fs_is_multi_device(sbi))
  		return 0;

  	for (i = 0; i < sbi->s_ndevs; i++)
  		if (FDEV(i).start_blk <= blkaddr && FDEV(i).end_blk >= blkaddr)
  			return i;
  	return 0;
  }
  
  static bool __same_bdev(struct f2fs_sb_info *sbi,
  				block_t blk_addr, struct bio *bio)
  {

  	struct block_device *b = f2fs_target_device(sbi, blk_addr, NULL);
  	return bio->bi_disk == b->bd_disk && bio->bi_partno == b->bd_partno;

  }
  
  /*

   * Low-level block read/write IO operations.
   */

  static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages)

  {

  	struct f2fs_sb_info *sbi = fio->sbi;

  	struct bio *bio;

  	bio = f2fs_bio_alloc(sbi, npages, true);

  	f2fs_target_device(sbi, fio->new_blkaddr, bio);
  	if (is_read_io(fio->op)) {

  		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 = f2fs_io_type_to_rw_hint(sbi,
  						fio->type, fio->temp);

  	}

  	if (fio->io_wbc)
  		wbc_init_bio(fio->io_wbc, bio);

  
  	return bio;
  }

  static inline void __submit_bio(struct f2fs_sb_info *sbi,
  				struct bio *bio, enum page_type type)

  {

  	if (!is_read_io(bio_op(bio))) {

  		unsigned int start;

  		if (type != DATA && type != NODE)
  			goto submit_io;

  		if (test_opt(sbi, LFS) && current->plug)

  			blk_finish_plug(current->plug);

  		if (F2FS_IO_ALIGNED(sbi))
  			goto submit_io;

  		start = bio->bi_iter.bi_size >> F2FS_BLKSIZE_BITS;
  		start %= F2FS_IO_SIZE(sbi);
  
  		if (start == 0)
  			goto submit_io;
  
  		/* fill dummy pages */
  		for (; start < F2FS_IO_SIZE(sbi); start++) {
  			struct page *page =
  				mempool_alloc(sbi->write_io_dummy,

  					      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);
  			if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE)
  				f2fs_bug_on(sbi, 1);
  		}
  		/*
  		 * In the NODE case, we lose next block address chain. So, we
  		 * need to do checkpoint in f2fs_sync_file.
  		 */
  		if (type == NODE)
  			set_sbi_flag(sbi, SBI_NEED_CP);

  	}

  submit_io:

  	if (is_read_io(bio_op(bio)))
  		trace_f2fs_submit_read_bio(sbi->sb, type, bio);
  	else
  		trace_f2fs_submit_write_bio(sbi->sb, type, bio);

  	submit_bio(bio);

  }

  static void __submit_merged_bio(struct f2fs_bio_info *io)

  {

  	struct f2fs_io_info *fio = &io->fio;

  
  	if (!io->bio)
  		return;

  	bio_set_op_attrs(io->bio, fio->op, fio->op_flags);

  	if (is_read_io(fio->op))

  		trace_f2fs_prepare_read_bio(io->sbi->sb, fio->type, io->bio);

  	else

  		trace_f2fs_prepare_write_bio(io->sbi->sb, fio->type, io->bio);

  	__submit_bio(io->sbi, io->bio, fio->type);

  	io->bio = NULL;
  }

  static bool __has_merged_page(struct bio *bio, struct inode *inode,

  						struct page *page, nid_t ino)

  {

  	struct bio_vec *bvec;
  	struct page *target;

  	struct bvec_iter_all iter_all;

  	if (!bio)

  		return false;

  	if (!inode && !page && !ino)

  		return true;

  	bio_for_each_segment_all(bvec, bio, iter_all) {

  		target = bvec->bv_page;
  		if (fscrypt_is_bounce_page(target))
  			target = fscrypt_pagecache_page(target);

  		if (inode && inode == target->mapping->host)
  			return true;

  		if (page && page == target)
  			return true;

  		if (ino && ino == ino_of_node(target))

  			return true;

  	}

  	return false;
  }

  static void __f2fs_submit_merged_write(struct f2fs_sb_info *sbi,

  				enum page_type type, enum temp_type temp)

  {
  	enum page_type btype = PAGE_TYPE_OF_BIO(type);

  	struct f2fs_bio_info *io = sbi->write_io[btype] + temp;

  	down_write(&io->io_rwsem);

  
  	/* change META to META_FLUSH in the checkpoint procedure */
  	if (type >= META_FLUSH) {
  		io->fio.type = META_FLUSH;

  		io->fio.op = REQ_OP_WRITE;

  		io->fio.op_flags = REQ_META | REQ_PRIO | REQ_SYNC;

  		if (!test_opt(sbi, NOBARRIER))

  			io->fio.op_flags |= REQ_PREFLUSH | REQ_FUA;

  	}
  	__submit_merged_bio(io);

  	up_write(&io->io_rwsem);

  }

  static void __submit_merged_write_cond(struct f2fs_sb_info *sbi,

  				struct inode *inode, struct page *page,
  				nid_t ino, enum page_type type, bool force)

  {

  	enum temp_type temp;

  	bool ret = true;

  
  	for (temp = HOT; temp < NR_TEMP_TYPE; temp++) {

  		if (!force)	{
  			enum page_type btype = PAGE_TYPE_OF_BIO(type);
  			struct f2fs_bio_info *io = sbi->write_io[btype] + temp;

  			down_read(&io->io_rwsem);

  			ret = __has_merged_page(io->bio, inode, page, ino);

  			up_read(&io->io_rwsem);
  		}
  		if (ret)
  			__f2fs_submit_merged_write(sbi, type, temp);

  
  		/* TODO: use HOT temp only for meta pages now. */
  		if (type >= META)
  			break;
  	}

  }

  void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type)

  {

  	__submit_merged_write_cond(sbi, NULL, NULL, 0, type, true);

  }

  void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,

  				struct inode *inode, struct page *page,
  				nid_t ino, enum page_type type)

  {

  	__submit_merged_write_cond(sbi, inode, page, ino, type, false);

  }

  void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi)

  {

  	f2fs_submit_merged_write(sbi, DATA);
  	f2fs_submit_merged_write(sbi, NODE);
  	f2fs_submit_merged_write(sbi, META);

  }

  /*
   * Fill the locked page with data located in the block address.

   * A caller needs to unlock the page on failure.

   */

  int f2fs_submit_page_bio(struct f2fs_io_info *fio)

  {

  	struct bio *bio;

  	struct page *page = fio->encrypted_page ?
  			fio->encrypted_page : fio->page;

  	if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,

  			fio->is_por ? META_POR : (__is_meta_io(fio) ?
  			META_GENERIC : DATA_GENERIC_ENHANCE)))

  		return -EFSCORRUPTED;

  	trace_f2fs_submit_page_bio(page, fio);

  	f2fs_trace_ios(fio, 0);

  
  	/* Allocate a new bio */

  	bio = __bio_alloc(fio, 1);

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

  		bio_put(bio);

  		return -EFAULT;
  	}

  
  	if (fio->io_wbc && !is_read_io(fio->op))

  		wbc_account_cgroup_owner(fio->io_wbc, page, PAGE_SIZE);

  	bio_set_op_attrs(bio, fio->op, fio->op_flags);

  	inc_page_count(fio->sbi, is_read_io(fio->op) ?
  			__read_io_type(page): WB_DATA_TYPE(fio->page));

  
  	__submit_bio(fio->sbi, bio, fio->type);

  	return 0;
  }

  static bool page_is_mergeable(struct f2fs_sb_info *sbi, struct bio *bio,
  				block_t last_blkaddr, block_t cur_blkaddr)
  {
  	if (last_blkaddr + 1 != cur_blkaddr)
  		return false;
  	return __same_bdev(sbi, cur_blkaddr, bio);
  }
  
  static bool io_type_is_mergeable(struct f2fs_bio_info *io,
  						struct f2fs_io_info *fio)
  {
  	if (io->fio.op != fio->op)
  		return false;
  	return io->fio.op_flags == fio->op_flags;
  }
  
  static bool io_is_mergeable(struct f2fs_sb_info *sbi, struct bio *bio,
  					struct f2fs_bio_info *io,
  					struct f2fs_io_info *fio,
  					block_t last_blkaddr,
  					block_t cur_blkaddr)
  {

  	if (F2FS_IO_ALIGNED(sbi) && (fio->type == DATA || fio->type == NODE)) {
  		unsigned int filled_blocks =
  				F2FS_BYTES_TO_BLK(bio->bi_iter.bi_size);
  		unsigned int io_size = F2FS_IO_SIZE(sbi);
  		unsigned int left_vecs = bio->bi_max_vecs - bio->bi_vcnt;
  
  		/* IOs in bio is aligned and left space of vectors is not enough */
  		if (!(filled_blocks % io_size) && left_vecs < io_size)
  			return false;
  	}

  	if (!page_is_mergeable(sbi, bio, last_blkaddr, cur_blkaddr))
  		return false;
  	return io_type_is_mergeable(io, fio);
  }

  static void add_bio_entry(struct f2fs_sb_info *sbi, struct bio *bio,
  				struct page *page, enum temp_type temp)
  {
  	struct f2fs_bio_info *io = sbi->write_io[DATA] + temp;
  	struct bio_entry *be;
  
  	be = f2fs_kmem_cache_alloc(bio_entry_slab, GFP_NOFS);
  	be->bio = bio;
  	bio_get(bio);
  
  	if (bio_add_page(bio, page, PAGE_SIZE, 0) != PAGE_SIZE)
  		f2fs_bug_on(sbi, 1);
  
  	down_write(&io->bio_list_lock);
  	list_add_tail(&be->list, &io->bio_list);
  	up_write(&io->bio_list_lock);
  }
  
  static void del_bio_entry(struct bio_entry *be)
  {
  	list_del(&be->list);
  	kmem_cache_free(bio_entry_slab, be);
  }
  
  static int add_ipu_page(struct f2fs_sb_info *sbi, struct bio **bio,
  							struct page *page)
  {
  	enum temp_type temp;
  	bool found = false;
  	int ret = -EAGAIN;
  
  	for (temp = HOT; temp < NR_TEMP_TYPE && !found; temp++) {
  		struct f2fs_bio_info *io = sbi->write_io[DATA] + temp;
  		struct list_head *head = &io->bio_list;
  		struct bio_entry *be;
  
  		down_write(&io->bio_list_lock);
  		list_for_each_entry(be, head, list) {
  			if (be->bio != *bio)
  				continue;
  
  			found = true;
  
  			if (bio_add_page(*bio, page, PAGE_SIZE, 0) == PAGE_SIZE) {
  				ret = 0;
  				break;
  			}
  
  			/* bio is full */
  			del_bio_entry(be);
  			__submit_bio(sbi, *bio, DATA);
  			break;
  		}
  		up_write(&io->bio_list_lock);
  	}
  
  	if (ret) {
  		bio_put(*bio);
  		*bio = NULL;
  	}
  
  	return ret;
  }
  
  void f2fs_submit_merged_ipu_write(struct f2fs_sb_info *sbi,
  					struct bio **bio, struct page *page)
  {
  	enum temp_type temp;
  	bool found = false;
  	struct bio *target = bio ? *bio : NULL;
  
  	for (temp = HOT; temp < NR_TEMP_TYPE && !found; temp++) {
  		struct f2fs_bio_info *io = sbi->write_io[DATA] + temp;
  		struct list_head *head = &io->bio_list;
  		struct bio_entry *be;
  
  		if (list_empty(head))
  			continue;
  
  		down_read(&io->bio_list_lock);
  		list_for_each_entry(be, head, list) {
  			if (target)
  				found = (target == be->bio);
  			else
  				found = __has_merged_page(be->bio, NULL,
  								page, 0);
  			if (found)
  				break;
  		}
  		up_read(&io->bio_list_lock);
  
  		if (!found)
  			continue;
  
  		found = false;
  
  		down_write(&io->bio_list_lock);
  		list_for_each_entry(be, head, list) {
  			if (target)
  				found = (target == be->bio);
  			else
  				found = __has_merged_page(be->bio, NULL,
  								page, 0);
  			if (found) {
  				target = be->bio;
  				del_bio_entry(be);
  				break;
  			}
  		}
  		up_write(&io->bio_list_lock);
  	}
  
  	if (found)
  		__submit_bio(sbi, target, DATA);
  	if (bio && *bio) {
  		bio_put(*bio);
  		*bio = NULL;
  	}
  }

  int f2fs_merge_page_bio(struct f2fs_io_info *fio)
  {
  	struct bio *bio = *fio->bio;
  	struct page *page = fio->encrypted_page ?
  			fio->encrypted_page : fio->page;
  
  	if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
  			__is_meta_io(fio) ? META_GENERIC : DATA_GENERIC))

  		return -EFSCORRUPTED;

  
  	trace_f2fs_submit_page_bio(page, fio);
  	f2fs_trace_ios(fio, 0);

  	if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block,

  						fio->new_blkaddr))
  		f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL);

  alloc_new:
  	if (!bio) {

  		bio = __bio_alloc(fio, BIO_MAX_PAGES);

  		bio_set_op_attrs(bio, fio->op, fio->op_flags);

  		add_bio_entry(fio->sbi, bio, page, fio->temp);
  	} else {
  		if (add_ipu_page(fio->sbi, &bio, page))
  			goto alloc_new;

  	}
  
  	if (fio->io_wbc)

  		wbc_account_cgroup_owner(fio->io_wbc, page, PAGE_SIZE);

  
  	inc_page_count(fio->sbi, WB_DATA_TYPE(page));
  
  	*fio->last_block = fio->new_blkaddr;
  	*fio->bio = bio;
  
  	return 0;
  }

  void f2fs_submit_page_write(struct f2fs_io_info *fio)

  {

  	struct f2fs_sb_info *sbi = fio->sbi;

  	enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);

  	struct f2fs_bio_info *io = sbi->write_io[btype] + fio->temp;

  	struct page *bio_page;

  	f2fs_bug_on(sbi, is_read_io(fio->op));

  	down_write(&io->io_rwsem);
  next:
  	if (fio->in_list) {
  		spin_lock(&io->io_lock);
  		if (list_empty(&io->io_list)) {
  			spin_unlock(&io->io_lock);

  			goto out;

  		}
  		fio = list_first_entry(&io->io_list,
  						struct f2fs_io_info, list);
  		list_del(&fio->list);
  		spin_unlock(&io->io_lock);
  	}

  	verify_fio_blkaddr(fio);

  	bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;

  	/* set submitted = true as a return value */
  	fio->submitted = true;

  	inc_page_count(sbi, WB_DATA_TYPE(bio_page));

  	if (io->bio && !io_is_mergeable(sbi, io->bio, io, fio,
  			io->last_block_in_bio, fio->new_blkaddr))

  		__submit_merged_bio(io);

  alloc_new:
  	if (io->bio == NULL) {

  		if (F2FS_IO_ALIGNED(sbi) &&
  				(fio->type == DATA || fio->type == NODE) &&

  				fio->new_blkaddr & F2FS_IO_SIZE_MASK(sbi)) {

  			dec_page_count(sbi, WB_DATA_TYPE(bio_page));

  			fio->retry = true;
  			goto skip;

  		}

  		io->bio = __bio_alloc(fio, BIO_MAX_PAGES);

  		io->fio = *fio;

  	}

  	if (bio_add_page(io->bio, bio_page, PAGE_SIZE, 0) < PAGE_SIZE) {

  		__submit_merged_bio(io);

  		goto alloc_new;
  	}

  	if (fio->io_wbc)

  		wbc_account_cgroup_owner(fio->io_wbc, bio_page, PAGE_SIZE);

  	io->last_block_in_bio = fio->new_blkaddr;

  	f2fs_trace_ios(fio, 0);

  
  	trace_f2fs_submit_page_write(fio->page, fio);

  skip:

  	if (fio->in_list)
  		goto next;

  out:

  	if (is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN) ||

  				!f2fs_is_checkpoint_ready(sbi))

  		__submit_merged_bio(io);

  	up_write(&io->io_rwsem);

  }

  static inline bool f2fs_need_verity(const struct inode *inode, pgoff_t idx)
  {
  	return fsverity_active(inode) &&
  	       idx < DIV_ROUND_UP(inode->i_size, PAGE_SIZE);
  }

  static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,

  				      unsigned nr_pages, unsigned op_flag,
  				      pgoff_t first_idx)

  {
  	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

  	struct bio *bio;

  	struct bio_post_read_ctx *ctx;
  	unsigned int post_read_steps = 0;

  	bio = f2fs_bio_alloc(sbi, min_t(int, nr_pages, BIO_MAX_PAGES), false);

  	if (!bio)

  		return ERR_PTR(-ENOMEM);

  	f2fs_target_device(sbi, blkaddr, bio);
  	bio->bi_end_io = f2fs_read_end_io;

  	bio_set_op_attrs(bio, REQ_OP_READ, op_flag);

  	if (f2fs_encrypted_file(inode))
  		post_read_steps |= 1 << STEP_DECRYPT;

  
  	if (f2fs_need_verity(inode, first_idx))
  		post_read_steps |= 1 << STEP_VERITY;

  	if (post_read_steps) {
  		ctx = mempool_alloc(bio_post_read_ctx_pool, GFP_NOFS);
  		if (!ctx) {
  			bio_put(bio);
  			return ERR_PTR(-ENOMEM);
  		}
  		ctx->bio = bio;
  		ctx->enabled_steps = post_read_steps;
  		bio->bi_private = ctx;

  	}

  	return bio;
  }
  
  /* This can handle encryption stuffs */
  static int f2fs_submit_page_read(struct inode *inode, struct page *page,
  							block_t blkaddr)
  {

  	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  	struct bio *bio;

  	bio = f2fs_grab_read_bio(inode, blkaddr, 1, 0, page->index);

  	if (IS_ERR(bio))
  		return PTR_ERR(bio);

  	/* wait for GCed page writeback via META_MAPPING */
  	f2fs_wait_on_block_writeback(inode, blkaddr);

  	if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
  		bio_put(bio);
  		return -EFAULT;
  	}

  	ClearPageError(page);

  	inc_page_count(sbi, F2FS_RD_DATA);
  	__submit_bio(sbi, bio, DATA);

  	return 0;
  }

  static void __set_data_blkaddr(struct dnode_of_data *dn)
  {
  	struct f2fs_node *rn = F2FS_NODE(dn->node_page);
  	__le32 *addr_array;

  	int base = 0;
  
  	if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
  		base = get_extra_isize(dn->inode);

  
  	/* Get physical address of data block */
  	addr_array = blkaddr_in_node(rn);

  	addr_array[base + dn->ofs_in_node] = cpu_to_le32(dn->data_blkaddr);

  }

  /*

   * Lock ordering for the change of data block address:
   * ->data_page
   *  ->node_page
   *    update block addresses in the node page
   */

  void f2fs_set_data_blkaddr(struct dnode_of_data *dn)

  {

  	f2fs_wait_on_page_writeback(dn->node_page, NODE, true, true);

  	__set_data_blkaddr(dn);
  	if (set_page_dirty(dn->node_page))

  		dn->node_changed = true;

  }

  void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr)
  {
  	dn->data_blkaddr = blkaddr;

  	f2fs_set_data_blkaddr(dn);

  	f2fs_update_extent_cache(dn);
  }

  /* dn->ofs_in_node will be returned with up-to-date last block pointer */

  int f2fs_reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count)

  {

  	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);

  	int err;

  	if (!count)
  		return 0;

  	if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))

  		return -EPERM;

  	if (unlikely((err = inc_valid_block_count(sbi, dn->inode, &count))))
  		return err;

  	trace_f2fs_reserve_new_blocks(dn->inode, dn->nid,
  						dn->ofs_in_node, count);

  	f2fs_wait_on_page_writeback(dn->node_page, NODE, true, true);

  
  	for (; count > 0; dn->ofs_in_node++) {

  		block_t blkaddr = datablock_addr(dn->inode,
  					dn->node_page, dn->ofs_in_node);

  		if (blkaddr == NULL_ADDR) {
  			dn->data_blkaddr = NEW_ADDR;
  			__set_data_blkaddr(dn);
  			count--;
  		}
  	}
  
  	if (set_page_dirty(dn->node_page))
  		dn->node_changed = true;

  	return 0;
  }

  /* Should keep dn->ofs_in_node unchanged */

  int f2fs_reserve_new_block(struct dnode_of_data *dn)

  {
  	unsigned int ofs_in_node = dn->ofs_in_node;
  	int ret;

  	ret = f2fs_reserve_new_blocks(dn, 1);

  	dn->ofs_in_node = ofs_in_node;
  	return ret;
  }

  int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
  {
  	bool need_put = dn->inode_page ? false : true;
  	int err;

  	err = f2fs_get_dnode_of_data(dn, index, ALLOC_NODE);

  	if (err)
  		return err;

  	if (dn->data_blkaddr == NULL_ADDR)

  		err = f2fs_reserve_new_block(dn);

  	if (err || need_put)

  		f2fs_put_dnode(dn);
  	return err;
  }

  int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index)

  {

  	struct extent_info ei  = {0,0,0};

  	struct inode *inode = dn->inode;

  	if (f2fs_lookup_extent_cache(inode, index, &ei)) {
  		dn->data_blkaddr = ei.blk + index - ei.fofs;
  		return 0;

  	}

  	return f2fs_reserve_block(dn, index);

  }

  struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,

  						int op_flags, bool for_write)

  {

  	struct address_space *mapping = inode->i_mapping;
  	struct dnode_of_data dn;
  	struct page *page;

  	struct extent_info ei = {0,0,0};

  	int err;

  	page = f2fs_grab_cache_page(mapping, index, for_write);

  	if (!page)
  		return ERR_PTR(-ENOMEM);

  	if (f2fs_lookup_extent_cache(inode, index, &ei)) {
  		dn.data_blkaddr = ei.blk + index - ei.fofs;

  		if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), dn.data_blkaddr,
  						DATA_GENERIC_ENHANCE_READ)) {

  			err = -EFSCORRUPTED;

  			goto put_err;
  		}

  		goto got_it;
  	}

  	set_new_dnode(&dn, inode, NULL, NULL, 0);

  	err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);

  	if (err)
  		goto put_err;

  	f2fs_put_dnode(&dn);

  	if (unlikely(dn.data_blkaddr == NULL_ADDR)) {

  		err = -ENOENT;
  		goto put_err;

  	}

  	if (dn.data_blkaddr != NEW_ADDR &&
  			!f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
  						dn.data_blkaddr,
  						DATA_GENERIC_ENHANCE)) {

  		err = -EFSCORRUPTED;

  		goto put_err;
  	}

  got_it:

  	if (PageUptodate(page)) {
  		unlock_page(page);

  		return page;

  	}

  	/*
  	 * A new dentry page is allocated but not able to be written, since its
  	 * new inode page couldn't be allocated due to -ENOSPC.
  	 * In such the case, its blkaddr can be remained as NEW_ADDR.

  	 * see, f2fs_add_link -> f2fs_get_new_data_page ->
  	 * f2fs_init_inode_metadata.

  	 */
  	if (dn.data_blkaddr == NEW_ADDR) {

  		zero_user_segment(page, 0, PAGE_SIZE);

  		if (!PageUptodate(page))
  			SetPageUptodate(page);

  		unlock_page(page);

  		return page;
  	}

  	err = f2fs_submit_page_read(inode, page, dn.data_blkaddr);

  	if (err)

  		goto put_err;

  	return page;

  
  put_err:
  	f2fs_put_page(page, 1);
  	return ERR_PTR(err);

  }

  struct page *f2fs_find_data_page(struct inode *inode, pgoff_t index)

  {
  	struct address_space *mapping = inode->i_mapping;
  	struct page *page;
  
  	page = find_get_page(mapping, index);
  	if (page && PageUptodate(page))
  		return page;
  	f2fs_put_page(page, 0);

  	page = f2fs_get_read_data_page(inode, index, 0, false);

  	if (IS_ERR(page))
  		return page;
  
  	if (PageUptodate(page))
  		return page;
  
  	wait_on_page_locked(page);
  	if (unlikely(!PageUptodate(page))) {
  		f2fs_put_page(page, 0);
  		return ERR_PTR(-EIO);
  	}
  	return page;
  }
  
  /*
   * If it tries to access a hole, return an error.
   * Because, the callers, functions in dir.c and GC, should be able to know
   * whether this page exists or not.
   */

  struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,

  							bool for_write)

  {
  	struct address_space *mapping = inode->i_mapping;
  	struct page *page;
  repeat:

  	page = f2fs_get_read_data_page(inode, index, 0, for_write);

  	if (IS_ERR(page))
  		return page;

  	/* wait for read completion */

  	lock_page(page);

  	if (unlikely(page->mapping != mapping)) {

  		f2fs_put_page(page, 1);
  		goto repeat;

  	}

  	if (unlikely(!PageUptodate(page))) {
  		f2fs_put_page(page, 1);
  		return ERR_PTR(-EIO);
  	}

  	return page;
  }

  /*

   * Caller ensures that this data page is never allocated.
   * A new zero-filled data page is allocated in the page cache.

   *

   * Also, caller should grab and release a rwsem by calling f2fs_lock_op() and
   * f2fs_unlock_op().

   * Note that, ipage is set only by make_empty_dir, and if any error occur,
   * ipage should be released by this function.

   */

  struct page *f2fs_get_new_data_page(struct inode *inode,

  		struct page *ipage, pgoff_t index, bool new_i_size)

  {

  	struct address_space *mapping = inode->i_mapping;
  	struct page *page;
  	struct dnode_of_data dn;
  	int err;

  	page = f2fs_grab_cache_page(mapping, index, true);

  	if (!page) {
  		/*
  		 * before exiting, we should make sure ipage will be released
  		 * if any error occur.
  		 */
  		f2fs_put_page(ipage, 1);

  		return ERR_PTR(-ENOMEM);

  	}

  	set_new_dnode(&dn, inode, ipage, NULL, 0);

  	err = f2fs_reserve_block(&dn, index);

  	if (err) {
  		f2fs_put_page(page, 1);

  		return ERR_PTR(err);

  	}

  	if (!ipage)
  		f2fs_put_dnode(&dn);

  
  	if (PageUptodate(page))

  		goto got_it;

  
  	if (dn.data_blkaddr == NEW_ADDR) {

  		zero_user_segment(page, 0, PAGE_SIZE);

  		if (!PageUptodate(page))
  			SetPageUptodate(page);

  	} else {

  		f2fs_put_page(page, 1);

  		/* if ipage exists, blkaddr should be NEW_ADDR */
  		f2fs_bug_on(F2FS_I_SB(inode), ipage);

  		page = f2fs_get_lock_data_page(inode, index, true);

  		if (IS_ERR(page))

  			return page;

  	}

  got_it:

  	if (new_i_size && i_size_read(inode) <

  				((loff_t)(index + 1) << PAGE_SHIFT))

  		f2fs_i_size_write(inode, ((loff_t)(index + 1) << PAGE_SHIFT));

  	return page;
  }

  static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)

  {

  	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);

  	struct f2fs_summary sum;

  	struct node_info ni;

  	block_t old_blkaddr;

  	blkcnt_t count = 1;

  	int err;

  	if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))

  		return -EPERM;

  	err = f2fs_get_node_info(sbi, dn->nid, &ni);
  	if (err)
  		return err;

  	dn->data_blkaddr = datablock_addr(dn->inode,
  				dn->node_page, dn->ofs_in_node);

  	if (dn->data_blkaddr != NULL_ADDR)

  		goto alloc;

  	if (unlikely((err = inc_valid_block_count(sbi, dn->inode, &count))))
  		return err;

  alloc:

  	set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);

  	old_blkaddr = dn->data_blkaddr;
  	f2fs_allocate_data_block(sbi, NULL, old_blkaddr, &dn->data_blkaddr,

  					&sum, seg_type, NULL, false);

  	if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
  		invalidate_mapping_pages(META_MAPPING(sbi),
  					old_blkaddr, old_blkaddr);

  	f2fs_update_data_blkaddr(dn, dn->data_blkaddr);

  	/*
  	 * i_size will be updated by direct_IO. Otherwise, we'll get stale
  	 * data from unwritten block via dio_read.
  	 */

  	return 0;
  }

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

  {

  	struct inode *inode = file_inode(iocb->ki_filp);

  	struct f2fs_map_blocks map;

  	int flag;

  	int err = 0;

  	bool direct_io = iocb->ki_flags & IOCB_DIRECT;

  	/* convert inline data for Direct I/O*/

  	if (direct_io) {

  		err = f2fs_convert_inline_inode(inode);
  		if (err)
  			return err;
  	}

  	if (direct_io && allow_outplace_dio(inode, iocb, from))
  		return 0;

  	if (is_inode_flag_set(inode, FI_NO_PREALLOC))
  		return 0;

  	map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);

  	map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));
  	if (map.m_len > map.m_lblk)
  		map.m_len -= map.m_lblk;
  	else
  		map.m_len = 0;

  	map.m_next_pgofs = NULL;

  	map.m_next_extent = NULL;

  	map.m_seg_type = NO_CHECK_TYPE;

  	map.m_may_create = true;

  	if (direct_io) {

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

  		flag = f2fs_force_buffered_io(inode, iocb, from) ?

  					F2FS_GET_BLOCK_PRE_AIO :
  					F2FS_GET_BLOCK_PRE_DIO;
  		goto map_blocks;

  	}

  	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA(inode)) {

  		err = f2fs_convert_inline_inode(inode);
  		if (err)
  			return err;

  	}

  	if (f2fs_has_inline_data(inode))

  		return err;

  
  	flag = F2FS_GET_BLOCK_PRE_AIO;
  
  map_blocks:
  	err = f2fs_map_blocks(inode, &map, 1, flag);
  	if (map.m_len > 0 && err == -ENOSPC) {
  		if (!direct_io)
  			set_inode_flag(inode, FI_NO_PREALLOC);
  		err = 0;

  	}

  	return err;

  }

  void __do_map_lock(struct f2fs_sb_info *sbi, int flag, bool lock)

  {
  	if (flag == F2FS_GET_BLOCK_PRE_AIO) {
  		if (lock)
  			down_read(&sbi->node_change);
  		else
  			up_read(&sbi->node_change);
  	} else {
  		if (lock)
  			f2fs_lock_op(sbi);
  		else
  			f2fs_unlock_op(sbi);
  	}
  }

  /*

   * f2fs_map_blocks() now supported readahead/bmap/rw direct_IO with
   * f2fs_map_blocks structure.

   * If original data blocks are allocated, then give them to blockdev.
   * Otherwise,
   *     a. preallocate requested block addresses
   *     b. do not use extent cache for better performance
   *     c. give the block addresses to blockdev

   */

  int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,

  						int create, int flag)

  {

  	unsigned int maxblocks = map->m_len;

  	struct dnode_of_data dn;

  	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

  	int mode = map->m_may_create ? ALLOC_NODE : LOOKUP_NODE;

  	pgoff_t pgofs, end_offset, end;

  	int err = 0, ofs = 1;

  	unsigned int ofs_in_node, last_ofs_in_node;
  	blkcnt_t prealloc;

  	struct extent_info ei = {0,0,0};

  	block_t blkaddr;

  	unsigned int start_pgofs;

  	if (!maxblocks)
  		return 0;

  	map->m_len = 0;
  	map->m_flags = 0;
  
  	/* it only supports block size == page size */
  	pgofs =	(pgoff_t)map->m_lblk;

  	end = pgofs + maxblocks;

  	if (!create && f2fs_lookup_extent_cache(inode, pgofs, &ei)) {

  		if (test_opt(sbi, LFS) && flag == F2FS_GET_BLOCK_DIO &&
  							map->m_may_create)
  			goto next_dnode;

  		map->m_pblk = ei.blk + pgofs - ei.fofs;
  		map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
  		map->m_flags = F2FS_MAP_MAPPED;

  		if (map->m_next_extent)
  			*map->m_next_extent = pgofs + map->m_len;

  
  		/* for hardware encryption, but to avoid potential issue in future */
  		if (flag == F2FS_GET_BLOCK_DIO)
  			f2fs_wait_on_block_writeback_range(inode,
  						map->m_pblk, map->m_len);

  		goto out;

  	}

  next_dnode:

  	if (map->m_may_create)

  		__do_map_lock(sbi, flag, true);

  
  	/* When reading holes, we need its node page */
  	set_new_dnode(&dn, inode, NULL, NULL, 0);

  	err = f2fs_get_dnode_of_data(&dn, pgofs, mode);

  	if (err) {

  		if (flag == F2FS_GET_BLOCK_BMAP)
  			map->m_pblk = 0;

  		if (err == -ENOENT) {

  			err = 0;

  			if (map->m_next_pgofs)
  				*map->m_next_pgofs =

  					f2fs_get_next_page_offset(&dn, pgofs);

  			if (map->m_next_extent)
  				*map->m_next_extent =

  					f2fs_get_next_page_offset(&dn, pgofs);

  		}

  		goto unlock_out;

  	}

  	start_pgofs = pgofs;

  	prealloc = 0;

  	last_ofs_in_node = ofs_in_node = dn.ofs_in_node;

  	end_offset = ADDRS_PER_PAGE(dn.node_page, inode);

  
  next_block:

  	blkaddr = datablock_addr(dn.inode, dn.node_page, dn.ofs_in_node);

  	if (__is_valid_data_blkaddr(blkaddr) &&

  		!f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC_ENHANCE)) {

  		err = -EFSCORRUPTED;

  		goto sync_out;
  	}

  	if (__is_valid_data_blkaddr(blkaddr)) {

  		/* use out-place-update for driect IO under LFS mode */

  		if (test_opt(sbi, LFS) && flag == F2FS_GET_BLOCK_DIO &&
  							map->m_may_create) {

  			err = __allocate_data_block(&dn, map->m_seg_type);

  			if (err)
  				goto sync_out;
  			blkaddr = dn.data_blkaddr;
  			set_inode_flag(inode, FI_APPEND_WRITE);

  		}
  	} else {

  		if (create) {

  			if (unlikely(f2fs_cp_error(sbi))) {
  				err = -EIO;

  				goto sync_out;

  			}

  			if (flag == F2FS_GET_BLOCK_PRE_AIO) {

  				if (blkaddr == NULL_ADDR) {
  					prealloc++;
  					last_ofs_in_node = dn.ofs_in_node;
  				}

  			} else {

  				WARN_ON(flag != F2FS_GET_BLOCK_PRE_DIO &&
  					flag != F2FS_GET_BLOCK_DIO);

  				err = __allocate_data_block(&dn,
  							map->m_seg_type);

  				if (!err)

  					set_inode_flag(inode, FI_APPEND_WRITE);

  			}

  			if (err)

  				goto sync_out;

  			map->m_flags |= F2FS_MAP_NEW;

  			blkaddr = dn.data_blkaddr;

  		} else {

  			if (flag == F2FS_GET_BLOCK_BMAP) {
  				map->m_pblk = 0;
  				goto sync_out;
  			}

  			if (flag == F2FS_GET_BLOCK_PRECACHE)
  				goto sync_out;

  			if (flag == F2FS_GET_BLOCK_FIEMAP &&
  						blkaddr == NULL_ADDR) {
  				if (map->m_next_pgofs)
  					*map->m_next_pgofs = pgofs + 1;

  				goto sync_out;

  			}

  			if (flag != F2FS_GET_BLOCK_FIEMAP) {
  				/* for defragment case */
  				if (map->m_next_pgofs)
  					*map->m_next_pgofs = pgofs + 1;

  				goto sync_out;

  			}

  		}

  	}

  	if (flag == F2FS_GET_BLOCK_PRE_AIO)
  		goto skip;

  	if (map->m_len == 0) {
  		/* preallocated unwritten block should be mapped for fiemap. */
  		if (blkaddr == NEW_ADDR)
  			map->m_flags |= F2FS_MAP_UNWRITTEN;
  		map->m_flags |= F2FS_MAP_MAPPED;
  
  		map->m_pblk = blkaddr;
  		map->m_len = 1;
  	} else if ((map->m_pblk != NEW_ADDR &&
  			blkaddr == (map->m_pblk + ofs)) ||

  			(map->m_pblk == NEW_ADDR && blkaddr == NEW_ADDR) ||

  			flag == F2FS_GET_BLOCK_PRE_DIO) {

  		ofs++;
  		map->m_len++;
  	} else {
  		goto sync_out;
  	}

  skip:

  	dn.ofs_in_node++;
  	pgofs++;

  	/* preallocate blocks in batch for one dnode page */
  	if (flag == F2FS_GET_BLOCK_PRE_AIO &&
  			(pgofs == end || dn.ofs_in_node == end_offset)) {

  		dn.ofs_in_node = ofs_in_node;

  		err = f2fs_reserve_new_blocks(&dn, prealloc);

  		if (err)
  			goto sync_out;

  		map->m_len += dn.ofs_in_node - ofs_in_node;
  		if (prealloc && dn.ofs_in_node != last_ofs_in_node + 1) {
  			err = -ENOSPC;
  			goto sync_out;

  		}

  		dn.ofs_in_node = end_offset;
  	}
  
  	if (pgofs >= end)
  		goto sync_out;
  	else if (dn.ofs_in_node < end_offset)
  		goto next_block;

  	if (flag == F2FS_GET_BLOCK_PRECACHE) {
  		if (map->m_flags & F2FS_MAP_MAPPED) {
  			unsigned int ofs = start_pgofs - map->m_lblk;
  
  			f2fs_update_extent_cache_range(&dn,
  				start_pgofs, map->m_pblk + ofs,
  				map->m_len - ofs);
  		}
  	}

  	f2fs_put_dnode(&dn);

  	if (map->m_may_create) {

  		__do_map_lock(sbi, flag, false);

  		f2fs_balance_fs(sbi, dn.node_changed);

  	}

  	goto next_dnode;

  sync_out:

  
  	/* for hardware encryption, but to avoid potential issue in future */
  	if (flag == F2FS_GET_BLOCK_DIO && map->m_flags & F2FS_MAP_MAPPED)
  		f2fs_wait_on_block_writeback_range(inode,
  						map->m_pblk, map->m_len);

  	if (flag == F2FS_GET_BLOCK_PRECACHE) {
  		if (map->m_flags & F2FS_MAP_MAPPED) {
  			unsigned int ofs = start_pgofs - map->m_lblk;
  
  			f2fs_update_extent_cache_range(&dn,
  				start_pgofs, map->m_pblk + ofs,
  				map->m_len - ofs);
  		}
  		if (map->m_next_extent)
  			*map->m_next_extent = pgofs + 1;
  	}

  	f2fs_put_dnode(&dn);

  unlock_out:

  	if (map->m_may_create) {

  		__do_map_lock(sbi, flag, false);