Quelle  file.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * fs/f2fs/file.c
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *             http://www.samsung.com/
 */
#include <linux/fs.h>
#include <linux/f2fs_fs.h>
#include <linux/stat.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>
#include <linux/falloc.h>
#include <linux/types.h>
#include <linux/compat.h>
#include <linux/uaccess.h>
#include <linux/mount.h>
#include <linux/pagevec.h>
#include <linux/uio.h>
#include <linux/uuid.h>
#include <linux/file.h>
#include <linux/nls.h>
#include <linux/sched/signal.h>
#include <linux/fileattr.h>
#include <linux/fadvise.h>
#include <linux/iomap.h>

#include "f2fs.h"
#include "node.h"
#include "segment.h"
#include "xattr.h"
#include "acl.h"
#include "gc.h"
#include "iostat.h"
#include <trace/events/f2fs.h>
#include <uapi/linux/f2fs.h>

static void f2fs_zero_post_eof_page(struct inode *inode,
     loff_t new_size, bool lock)
{
 loff_t old_size = i_size_read(inode);

 if (old_size >= new_size)
  return;

 if (mapping_empty(inode->i_mapping))
  return;

 if (lock)
  filemap_invalidate_lock(inode->i_mapping);
 /* zero or drop pages only in range of [old_size, new_size] */
 truncate_inode_pages_range(inode->i_mapping, old_size, new_size);
 if (lock)
  filemap_invalidate_unlock(inode->i_mapping);
}

static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
{
 struct inode *inode = file_inode(vmf->vma->vm_file);
 vm_flags_t flags = vmf->vma->vm_flags;
 vm_fault_t ret;

 ret = filemap_fault(vmf);
 if (ret & VM_FAULT_LOCKED)
  f2fs_update_iostat(F2FS_I_SB(inode), inode,
     APP_MAPPED_READ_IO, F2FS_BLKSIZE);

 trace_f2fs_filemap_fault(inode, vmf->pgoff, flags, ret);

 return ret;
}

static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
{
 struct folio *folio = page_folio(vmf->page);
 struct inode *inode = file_inode(vmf->vma->vm_file);
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct dnode_of_data dn;
 bool need_alloc = !f2fs_is_pinned_file(inode);
 int err = 0;
 vm_fault_t ret;

 if (unlikely(IS_IMMUTABLE(inode)))
  return VM_FAULT_SIGBUS;

 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
  err = -EIO;
  goto out;
 }

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

 if (!f2fs_is_checkpoint_ready(sbi)) {
  err = -ENOSPC;
  goto out;
 }

 err = f2fs_convert_inline_inode(inode);
 if (err)
  goto out;

#ifdef CONFIG_F2FS_FS_COMPRESSION
 if (f2fs_compressed_file(inode)) {
  int ret = f2fs_is_compressed_cluster(inode, folio->index);

  if (ret < 0) {
   err = ret;
   goto out;
  } else if (ret) {
   need_alloc = false;
  }
 }
#endif
 /* should do out of any locked page */
 if (need_alloc)
  f2fs_balance_fs(sbi, true);

 sb_start_pagefault(inode->i_sb);

 f2fs_bug_on(sbi, f2fs_has_inline_data(inode));

 f2fs_zero_post_eof_page(inode, (folio->index + 1) << PAGE_SHIFT, true);

 file_update_time(vmf->vma->vm_file);
 filemap_invalidate_lock_shared(inode->i_mapping);

 folio_lock(folio);
 if (unlikely(folio->mapping != inode->i_mapping ||
   folio_pos(folio) > i_size_read(inode) ||
   !folio_test_uptodate(folio))) {
  folio_unlock(folio);
  err = -EFAULT;
  goto out_sem;
 }

 set_new_dnode(&dn, inode, NULL, NULL, 0);
 if (need_alloc) {
  /* block allocation */
  err = f2fs_get_block_locked(&dn, folio->index);
 } else {
  err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);
  f2fs_put_dnode(&dn);
  if (f2fs_is_pinned_file(inode) &&
      !__is_valid_data_blkaddr(dn.data_blkaddr))
   err = -EIO;
 }

 if (err) {
  folio_unlock(folio);
  goto out_sem;
 }

 f2fs_folio_wait_writeback(folio, DATA, false, true);

 /* wait for GCed page writeback via META_MAPPING */
 f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);

 /*
 * check to see if the page is mapped already (no holes)
 */
 if (folio_test_mappedtodisk(folio))
  goto out_sem;

 /* page is wholly or partially inside EOF */
 if (((loff_t)(folio->index + 1) << PAGE_SHIFT) >
      i_size_read(inode)) {
  loff_t offset;

  offset = i_size_read(inode) & ~PAGE_MASK;
  folio_zero_segment(folio, offset, folio_size(folio));
 }
 folio_mark_dirty(folio);

 f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE);
 f2fs_update_time(sbi, REQ_TIME);

out_sem:
 filemap_invalidate_unlock_shared(inode->i_mapping);

 sb_end_pagefault(inode->i_sb);
out:
 ret = vmf_fs_error(err);

 trace_f2fs_vm_page_mkwrite(inode, folio->index, vmf->vma->vm_flags, ret);
 return ret;
}

static const struct vm_operations_struct f2fs_file_vm_ops = {
 .fault  = f2fs_filemap_fault,
 .map_pages = filemap_map_pages,
 .page_mkwrite = f2fs_vm_page_mkwrite,
};

static int get_parent_ino(struct inode *inode, nid_t *pino)
{
 struct dentry *dentry;

 /*
 * Make sure to get the non-deleted alias.  The alias associated with
 * the open file descriptor being fsync()'ed may be deleted already.
 */
 dentry = d_find_alias(inode);
 if (!dentry)
  return 0;

 *pino = d_parent_ino(dentry);
 dput(dentry);
 return 1;
}

static inline enum cp_reason_type need_do_checkpoint(struct inode *inode)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 enum cp_reason_type cp_reason = CP_NO_NEEDED;

 if (!S_ISREG(inode->i_mode))
  cp_reason = CP_NON_REGULAR;
 else if (f2fs_compressed_file(inode))
  cp_reason = CP_COMPRESSED;
 else if (inode->i_nlink != 1)
  cp_reason = CP_HARDLINK;
 else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
  cp_reason = CP_SB_NEED_CP;
 else if (file_wrong_pino(inode))
  cp_reason = CP_WRONG_PINO;
 else if (!f2fs_space_for_roll_forward(sbi))
  cp_reason = CP_NO_SPC_ROLL;
 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
  cp_reason = CP_NODE_NEED_CP;
 else if (test_opt(sbi, FASTBOOT))
  cp_reason = CP_FASTBOOT_MODE;
 else if (F2FS_OPTION(sbi).active_logs == 2)
  cp_reason = CP_SPEC_LOG_NUM;
 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT &&
  f2fs_need_dentry_mark(sbi, inode->i_ino) &&
  f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino,
       TRANS_DIR_INO))
  cp_reason = CP_RECOVER_DIR;
 else if (f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino,
       XATTR_DIR_INO))
  cp_reason = CP_XATTR_DIR;

 return cp_reason;
}

static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
{
 struct folio *i = filemap_get_folio(NODE_MAPPING(sbi), ino);
 bool ret = false;
 /* But we need to avoid that there are some inode updates */
 if ((!IS_ERR(i) && folio_test_dirty(i)) ||
     f2fs_need_inode_block_update(sbi, ino))
  ret = true;
 f2fs_folio_put(i, false);
 return ret;
}

static void try_to_fix_pino(struct inode *inode)
{
 struct f2fs_inode_info *fi = F2FS_I(inode);
 nid_t pino;

 f2fs_down_write(&fi->i_sem);
 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
   get_parent_ino(inode, &pino)) {
  f2fs_i_pino_write(inode, pino);
  file_got_pino(inode);
 }
 f2fs_up_write(&fi->i_sem);
}

static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
      int datasync, bool atomic)
{
 struct inode *inode = file->f_mapping->host;
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 nid_t ino = inode->i_ino;
 int ret = 0;
 enum cp_reason_type cp_reason = 0;
 struct writeback_control wbc = {
  .sync_mode = WB_SYNC_ALL,
  .nr_to_write = LONG_MAX,
 };
 unsigned int seq_id = 0;

 if (unlikely(f2fs_readonly(inode->i_sb)))
  return 0;

 trace_f2fs_sync_file_enter(inode);

 if (S_ISDIR(inode->i_mode))
  goto go_write;

 /* if fdatasync is triggered, let's do in-place-update */
 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
  set_inode_flag(inode, FI_NEED_IPU);
 ret = file_write_and_wait_range(file, start, end);
 clear_inode_flag(inode, FI_NEED_IPU);

 if (ret || is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
  trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
  return ret;
 }

 /* if the inode is dirty, let's recover all the time */
 if (!f2fs_skip_inode_update(inode, datasync)) {
  f2fs_write_inode(inode, NULL);
  goto go_write;
 }

 /*
 * if there is no written data, don't waste time to write recovery info.
 */
 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
   !f2fs_exist_written_data(sbi, ino, APPEND_INO)) {

  /* it may call write_inode just prior to fsync */
  if (need_inode_page_update(sbi, ino))
   goto go_write;

  if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
    f2fs_exist_written_data(sbi, ino, UPDATE_INO))
   goto flush_out;
  goto out;
 } else {
  /*
 * for OPU case, during fsync(), node can be persisted before
 * data when lower device doesn't support write barrier, result
 * in data corruption after SPO.
 * So for strict fsync mode, force to use atomic write semantics
 * to keep write order in between data/node and last node to
 * avoid potential data corruption.
 */
  if (F2FS_OPTION(sbi).fsync_mode ==
    FSYNC_MODE_STRICT && !atomic)
   atomic = true;
 }
go_write:
 /*
 * Both of fdatasync() and fsync() are able to be recovered from
 * sudden-power-off.
 */
 f2fs_down_read(&F2FS_I(inode)->i_sem);
 cp_reason = need_do_checkpoint(inode);
 f2fs_up_read(&F2FS_I(inode)->i_sem);

 if (cp_reason) {
  /* all the dirty node pages should be flushed for POR */
  ret = f2fs_sync_fs(inode->i_sb, 1);

  /*
 * We've secured consistency through sync_fs. Following pino
 * will be used only for fsynced inodes after checkpoint.
 */
  try_to_fix_pino(inode);
  clear_inode_flag(inode, FI_APPEND_WRITE);
  clear_inode_flag(inode, FI_UPDATE_WRITE);
  goto out;
 }
sync_nodes:
 atomic_inc(&sbi->wb_sync_req[NODE]);
 ret = f2fs_fsync_node_pages(sbi, inode, &wbc, atomic, &seq_id);
 atomic_dec(&sbi->wb_sync_req[NODE]);
 if (ret)
  goto out;

 /* if cp_error was enabled, we should avoid infinite loop */
 if (unlikely(f2fs_cp_error(sbi))) {
  ret = -EIO;
  goto out;
 }

 if (f2fs_need_inode_block_update(sbi, ino)) {
  f2fs_mark_inode_dirty_sync(inode, true);
  f2fs_write_inode(inode, NULL);
  goto sync_nodes;
 }

 /*
 * If it's atomic_write, it's just fine to keep write ordering. So
 * here we don't need to wait for node write completion, since we use
 * node chain which serializes node blocks. If one of node writes are
 * reordered, we can see simply broken chain, resulting in stopping
 * roll-forward recovery. It means we'll recover all or none node blocks
 * given fsync mark.
 */
 if (!atomic) {
  ret = f2fs_wait_on_node_pages_writeback(sbi, seq_id);
  if (ret)
   goto out;
 }

 /* once recovery info is written, don't need to tack this */
 f2fs_remove_ino_entry(sbi, ino, APPEND_INO);
 clear_inode_flag(inode, FI_APPEND_WRITE);
flush_out:
 if (!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER)
  ret = f2fs_issue_flush(sbi, inode->i_ino);
 if (!ret) {
  f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
  clear_inode_flag(inode, FI_UPDATE_WRITE);
  f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
 }
 f2fs_update_time(sbi, REQ_TIME);
out:
 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
 return ret;
}

int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
{
 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
  return -EIO;
 return f2fs_do_sync_file(file, start, end, datasync, false);
}

static bool __found_offset(struct address_space *mapping,
  struct dnode_of_data *dn, pgoff_t index, int whence)
{
 block_t blkaddr = f2fs_data_blkaddr(dn);
 struct inode *inode = mapping->host;
 bool compressed_cluster = false;

 if (f2fs_compressed_file(inode)) {
  block_t first_blkaddr = data_blkaddr(dn->inode, dn->node_folio,
      ALIGN_DOWN(dn->ofs_in_node, F2FS_I(inode)->i_cluster_size));

  compressed_cluster = first_blkaddr == COMPRESS_ADDR;
 }

 switch (whence) {
 case SEEK_DATA:
  if (__is_valid_data_blkaddr(blkaddr))
   return true;
  if (blkaddr == NEW_ADDR &&
      xa_get_mark(&mapping->i_pages, index, PAGECACHE_TAG_DIRTY))
   return true;
  if (compressed_cluster)
   return true;
  break;
 case SEEK_HOLE:
  if (compressed_cluster)
   return false;
  if (blkaddr == NULL_ADDR)
   return true;
  break;
 }
 return false;
}

static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
{
 struct inode *inode = file->f_mapping->host;
 loff_t maxbytes = F2FS_BLK_TO_BYTES(max_file_blocks(inode));
 struct dnode_of_data dn;
 pgoff_t pgofs, end_offset;
 loff_t data_ofs = offset;
 loff_t isize;
 int err = 0;

 inode_lock_shared(inode);

 isize = i_size_read(inode);
 if (offset >= isize)
  goto fail;

 /* handle inline data case */
 if (f2fs_has_inline_data(inode)) {
  if (whence == SEEK_HOLE) {
   data_ofs = isize;
   goto found;
  } else if (whence == SEEK_DATA) {
   data_ofs = offset;
   goto found;
  }
 }

 pgofs = (pgoff_t)(offset >> PAGE_SHIFT);

 for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
  set_new_dnode(&dn, inode, NULL, NULL, 0);
  err = f2fs_get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
  if (err && err != -ENOENT) {
   goto fail;
  } else if (err == -ENOENT) {
   /* direct node does not exists */
   if (whence == SEEK_DATA) {
    pgofs = f2fs_get_next_page_offset(&dn, pgofs);
    continue;
   } else {
    goto found;
   }
  }

  end_offset = ADDRS_PER_PAGE(dn.node_folio, inode);

  /* find data/hole in dnode block */
  for (; dn.ofs_in_node < end_offset;
    dn.ofs_in_node++, pgofs++,
    data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
   block_t blkaddr;

   blkaddr = f2fs_data_blkaddr(&dn);

   if (__is_valid_data_blkaddr(blkaddr) &&
    !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
     blkaddr, DATA_GENERIC_ENHANCE)) {
    f2fs_put_dnode(&dn);
    goto fail;
   }

   if (__found_offset(file->f_mapping, &dn,
       pgofs, whence)) {
    f2fs_put_dnode(&dn);
    goto found;
   }
  }
  f2fs_put_dnode(&dn);
 }

 if (whence == SEEK_DATA)
  goto fail;
found:
 if (whence == SEEK_HOLE && data_ofs > isize)
  data_ofs = isize;
 inode_unlock_shared(inode);
 return vfs_setpos(file, data_ofs, maxbytes);
fail:
 inode_unlock_shared(inode);
 return -ENXIO;
}

static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
{
 struct inode *inode = file->f_mapping->host;
 loff_t maxbytes = F2FS_BLK_TO_BYTES(max_file_blocks(inode));

 switch (whence) {
 case SEEK_SET:
 case SEEK_CUR:
 case SEEK_END:
  return generic_file_llseek_size(file, offset, whence,
      maxbytes, i_size_read(inode));
 case SEEK_DATA:
 case SEEK_HOLE:
  if (offset < 0)
   return -ENXIO;
  return f2fs_seek_block(file, offset, whence);
 }

 return -EINVAL;
}

static int f2fs_file_mmap_prepare(struct vm_area_desc *desc)
{
 struct file *file = desc->file;
 struct inode *inode = file_inode(file);

 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
  return -EIO;

 if (!f2fs_is_compress_backend_ready(inode))
  return -EOPNOTSUPP;

 file_accessed(file);
 desc->vm_ops = &f2fs_file_vm_ops;

 f2fs_down_read(&F2FS_I(inode)->i_sem);
 set_inode_flag(inode, FI_MMAP_FILE);
 f2fs_up_read(&F2FS_I(inode)->i_sem);

 return 0;
}

static int finish_preallocate_blocks(struct inode *inode)
{
 int ret = 0;
 bool opened;

 f2fs_down_read(&F2FS_I(inode)->i_sem);
 opened = is_inode_flag_set(inode, FI_OPENED_FILE);
 f2fs_up_read(&F2FS_I(inode)->i_sem);
 if (opened)
  return 0;

 inode_lock(inode);
 if (is_inode_flag_set(inode, FI_OPENED_FILE))
  goto out_unlock;

 if (!file_should_truncate(inode))
  goto out_update;

 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 filemap_invalidate_lock(inode->i_mapping);

 truncate_setsize(inode, i_size_read(inode));
 ret = f2fs_truncate(inode);

 filemap_invalidate_unlock(inode->i_mapping);
 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 if (ret)
  goto out_unlock;

 file_dont_truncate(inode);
out_update:
 f2fs_down_write(&F2FS_I(inode)->i_sem);
 set_inode_flag(inode, FI_OPENED_FILE);
 f2fs_up_write(&F2FS_I(inode)->i_sem);
out_unlock:
 inode_unlock(inode);
 return ret;
}

static int f2fs_file_open(struct inode *inode, struct file *filp)
{
 int err = fscrypt_file_open(inode, filp);

 if (err)
  return err;

 if (!f2fs_is_compress_backend_ready(inode))
  return -EOPNOTSUPP;

 err = fsverity_file_open(inode, filp);
 if (err)
  return err;

 filp->f_mode |= FMODE_NOWAIT;
 filp->f_mode |= FMODE_CAN_ODIRECT;

 err = dquot_file_open(inode, filp);
 if (err)
  return err;

 err = finish_preallocate_blocks(inode);
 if (!err)
  atomic_inc(&F2FS_I(inode)->open_count);
 return err;
}

void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 int nr_free = 0, ofs = dn->ofs_in_node, len = count;
 __le32 *addr;
 bool compressed_cluster = false;
 int cluster_index = 0, valid_blocks = 0;
 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
 bool released = !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks);
 block_t blkstart;
 int blklen = 0;

 addr = get_dnode_addr(dn->inode, dn->node_folio) + ofs;
 blkstart = le32_to_cpu(*addr);

 /* Assumption: truncation starts with cluster */
 for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) {
  block_t blkaddr = le32_to_cpu(*addr);

  if (f2fs_compressed_file(dn->inode) &&
     !(cluster_index & (cluster_size - 1))) {
   if (compressed_cluster)
    f2fs_i_compr_blocks_update(dn->inode,
       valid_blocks, false);
   compressed_cluster = (blkaddr == COMPRESS_ADDR);
   valid_blocks = 0;
  }

  if (blkaddr == NULL_ADDR)
   goto next;

  f2fs_set_data_blkaddr(dn, NULL_ADDR);

  if (__is_valid_data_blkaddr(blkaddr)) {
   if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE))
    goto next;
   if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr,
      DATA_GENERIC_ENHANCE))
    goto next;
   if (compressed_cluster)
    valid_blocks++;
  }

  if (blkstart + blklen == blkaddr) {
   blklen++;
  } else {
   f2fs_invalidate_blocks(sbi, blkstart, blklen);
   blkstart = blkaddr;
   blklen = 1;
  }

  if (!released || blkaddr != COMPRESS_ADDR)
   nr_free++;

  continue;

next:
  if (blklen)
   f2fs_invalidate_blocks(sbi, blkstart, blklen);

  blkstart = le32_to_cpu(*(addr + 1));
  blklen = 0;
 }

 if (blklen)
  f2fs_invalidate_blocks(sbi, blkstart, blklen);

 if (compressed_cluster)
  f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false);

 if (nr_free) {
  pgoff_t fofs;
  /*
 * once we invalidate valid blkaddr in range [ofs, ofs + count],
 * we will invalidate all blkaddr in the whole range.
 */
  fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_folio),
       dn->inode) + ofs;
  f2fs_update_read_extent_cache_range(dn, fofs, 0, len);
  f2fs_update_age_extent_cache_range(dn, fofs, len);
  dec_valid_block_count(sbi, dn->inode, nr_free);
 }
 dn->ofs_in_node = ofs;

 f2fs_update_time(sbi, REQ_TIME);
 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
      dn->ofs_in_node, nr_free);
}

static int truncate_partial_data_page(struct inode *inode, u64 from,
        bool cache_only)
{
 loff_t offset = from & (PAGE_SIZE - 1);
 pgoff_t index = from >> PAGE_SHIFT;
 struct address_space *mapping = inode->i_mapping;
 struct folio *folio;

 if (!offset && !cache_only)
  return 0;

 if (cache_only) {
  folio = filemap_lock_folio(mapping, index);
  if (IS_ERR(folio))
         return 0;
  if (folio_test_uptodate(folio))
   goto truncate_out;
  f2fs_folio_put(folio, true);
  return 0;
 }

 folio = f2fs_get_lock_data_folio(inode, index, true);
 if (IS_ERR(folio))
  return PTR_ERR(folio) == -ENOENT ? 0 : PTR_ERR(folio);
truncate_out:
 f2fs_folio_wait_writeback(folio, DATA, true, true);
 folio_zero_segment(folio, offset, folio_size(folio));

 /* An encrypted inode should have a key and truncate the last page. */
 f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode));
 if (!cache_only)
  folio_mark_dirty(folio);
 f2fs_folio_put(folio, true);
 return 0;
}

int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct dnode_of_data dn;
 pgoff_t free_from;
 int count = 0, err = 0;
 struct folio *ifolio;
 bool truncate_page = false;

 trace_f2fs_truncate_blocks_enter(inode, from);

 if (IS_DEVICE_ALIASING(inode) && from) {
  err = -EINVAL;
  goto out_err;
 }

 free_from = (pgoff_t)F2FS_BLK_ALIGN(from);

 if (free_from >= max_file_blocks(inode))
  goto free_partial;

 if (lock)
  f2fs_lock_op(sbi);

 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);
 if (IS_ERR(ifolio)) {
  err = PTR_ERR(ifolio);
  goto out;
 }

 if (IS_DEVICE_ALIASING(inode)) {
  struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
  struct extent_info ei = et->largest;

  f2fs_invalidate_blocks(sbi, ei.blk, ei.len);

  dec_valid_block_count(sbi, inode, ei.len);
  f2fs_update_time(sbi, REQ_TIME);

  f2fs_folio_put(ifolio, true);
  goto out;
 }

 if (f2fs_has_inline_data(inode)) {
  f2fs_truncate_inline_inode(inode, ifolio, from);
  f2fs_folio_put(ifolio, true);
  truncate_page = true;
  goto out;
 }

 set_new_dnode(&dn, inode, ifolio, NULL, 0);
 err = f2fs_get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
 if (err) {
  if (err == -ENOENT)
   goto free_next;
  goto out;
 }

 count = ADDRS_PER_PAGE(dn.node_folio, inode);

 count -= dn.ofs_in_node;
 f2fs_bug_on(sbi, count < 0);

 if (dn.ofs_in_node || IS_INODE(dn.node_folio)) {
  f2fs_truncate_data_blocks_range(&dn, count);
  free_from += count;
 }

 f2fs_put_dnode(&dn);
free_next:
 err = f2fs_truncate_inode_blocks(inode, free_from);
out:
 if (lock)
  f2fs_unlock_op(sbi);
free_partial:
 /* lastly zero out the first data page */
 if (!err)
  err = truncate_partial_data_page(inode, from, truncate_page);
out_err:
 trace_f2fs_truncate_blocks_exit(inode, err);
 return err;
}

int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
{
 u64 free_from = from;
 int err;

#ifdef CONFIG_F2FS_FS_COMPRESSION
 /*
 * for compressed file, only support cluster size
 * aligned truncation.
 */
 if (f2fs_compressed_file(inode))
  free_from = round_up(from,
    F2FS_I(inode)->i_cluster_size << PAGE_SHIFT);
#endif

 err = f2fs_do_truncate_blocks(inode, free_from, lock);
 if (err)
  return err;

#ifdef CONFIG_F2FS_FS_COMPRESSION
 /*
 * For compressed file, after release compress blocks, don't allow write
 * direct, but we should allow write direct after truncate to zero.
 */
 if (f2fs_compressed_file(inode) && !free_from
   && is_inode_flag_set(inode, FI_COMPRESS_RELEASED))
  clear_inode_flag(inode, FI_COMPRESS_RELEASED);

 if (from != free_from) {
  err = f2fs_truncate_partial_cluster(inode, from, lock);
  if (err)
   return err;
 }
#endif

 return 0;
}

int f2fs_truncate(struct inode *inode)
{
 int err;

 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
  return -EIO;

 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
    S_ISLNK(inode->i_mode)))
  return 0;

 trace_f2fs_truncate(inode);

 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE))
  return -EIO;

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

 /* we should check inline_data size */
 if (!f2fs_may_inline_data(inode)) {
  err = f2fs_convert_inline_inode(inode);
  if (err) {
   /*
 * Always truncate page #0 to avoid page cache
 * leak in evict() path.
 */
   truncate_inode_pages_range(inode->i_mapping,
     F2FS_BLK_TO_BYTES(0),
     F2FS_BLK_END_BYTES(0));
   return err;
  }
 }

 err = f2fs_truncate_blocks(inode, i_size_read(inode), true);
 if (err)
  return err;

 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
 f2fs_mark_inode_dirty_sync(inode, false);
 return 0;
}

static bool f2fs_force_buffered_io(struct inode *inode, int rw)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

 if (!fscrypt_dio_supported(inode))
  return true;
 if (fsverity_active(inode))
  return true;
 if (f2fs_compressed_file(inode))
  return true;
 /*
 * only force direct read to use buffered IO, for direct write,
 * it expects inline data conversion before committing IO.
 */
 if (f2fs_has_inline_data(inode) && rw == READ)
  return true;

 /* disallow direct IO if any of devices has unaligned blksize */
 if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize)
  return true;
 /*
 * for blkzoned device, fallback direct IO to buffered IO, so
 * all IOs can be serialized by log-structured write.
 */
 if (f2fs_sb_has_blkzoned(sbi) && (rw == WRITE) &&
     !f2fs_is_pinned_file(inode))
  return true;
 if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))
  return true;

 return false;
}

int f2fs_getattr(struct mnt_idmap *idmap, const struct path *path,
   struct kstat *stat, u32 request_mask, unsigned int query_flags)
{
 struct inode *inode = d_inode(path->dentry);
 struct f2fs_inode_info *fi = F2FS_I(inode);
 struct f2fs_inode *ri = NULL;
 unsigned int flags;

 if (f2fs_has_extra_attr(inode) &&
   f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
   F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
  stat->result_mask |= STATX_BTIME;
  stat->btime.tv_sec = fi->i_crtime.tv_sec;
  stat->btime.tv_nsec = fi->i_crtime.tv_nsec;
 }

 /*
 * Return the DIO alignment restrictions if requested.  We only return
 * this information when requested, since on encrypted files it might
 * take a fair bit of work to get if the file wasn't opened recently.
 *
 * f2fs sometimes supports DIO reads but not DIO writes.  STATX_DIOALIGN
 * cannot represent that, so in that case we report no DIO support.
 */
 if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->i_mode)) {
  unsigned int bsize = i_blocksize(inode);

  stat->result_mask |= STATX_DIOALIGN;
  if (!f2fs_force_buffered_io(inode, WRITE)) {
   stat->dio_mem_align = bsize;
   stat->dio_offset_align = bsize;
  }
 }

 flags = fi->i_flags;
 if (flags & F2FS_COMPR_FL)
  stat->attributes |= STATX_ATTR_COMPRESSED;
 if (flags & F2FS_APPEND_FL)
  stat->attributes |= STATX_ATTR_APPEND;
 if (IS_ENCRYPTED(inode))
  stat->attributes |= STATX_ATTR_ENCRYPTED;
 if (flags & F2FS_IMMUTABLE_FL)
  stat->attributes |= STATX_ATTR_IMMUTABLE;
 if (flags & F2FS_NODUMP_FL)
  stat->attributes |= STATX_ATTR_NODUMP;
 if (IS_VERITY(inode))
  stat->attributes |= STATX_ATTR_VERITY;

 stat->attributes_mask |= (STATX_ATTR_COMPRESSED |
      STATX_ATTR_APPEND |
      STATX_ATTR_ENCRYPTED |
      STATX_ATTR_IMMUTABLE |
      STATX_ATTR_NODUMP |
      STATX_ATTR_VERITY);

 generic_fillattr(idmap, request_mask, inode, stat);

 /* we need to show initial sectors used for inline_data/dentries */
 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) ||
     f2fs_has_inline_dentry(inode))
  stat->blocks += (stat->size + 511) >> 9;

 return 0;
}

#ifdef CONFIG_F2FS_FS_POSIX_ACL
static void __setattr_copy(struct mnt_idmap *idmap,
      struct inode *inode, const struct iattr *attr)
{
 unsigned int ia_valid = attr->ia_valid;

 i_uid_update(idmap, attr, inode);
 i_gid_update(idmap, attr, inode);
 if (ia_valid & ATTR_ATIME)
  inode_set_atime_to_ts(inode, attr->ia_atime);
 if (ia_valid & ATTR_MTIME)
  inode_set_mtime_to_ts(inode, attr->ia_mtime);
 if (ia_valid & ATTR_CTIME)
  inode_set_ctime_to_ts(inode, attr->ia_ctime);
 if (ia_valid & ATTR_MODE) {
  umode_t mode = attr->ia_mode;

  if (!in_group_or_capable(idmap, inode, i_gid_into_vfsgid(idmap, inode)))
   mode &= ~S_ISGID;
  set_acl_inode(inode, mode);
 }
}
#else
#define __setattr_copy setattr_copy
#endif

int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
   struct iattr *attr)
{
 struct inode *inode = d_inode(dentry);
 struct f2fs_inode_info *fi = F2FS_I(inode);
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 int err;

 if (unlikely(f2fs_cp_error(sbi)))
  return -EIO;

 err = setattr_prepare(idmap, dentry, attr);
 if (err)
  return err;

 err = fscrypt_prepare_setattr(dentry, attr);
 if (err)
  return err;

 err = fsverity_prepare_setattr(dentry, attr);
 if (err)
  return err;

 if (unlikely(IS_IMMUTABLE(inode)))
  return -EPERM;

 if (unlikely(IS_APPEND(inode) &&
   (attr->ia_valid & (ATTR_MODE | ATTR_UID |
      ATTR_GID | ATTR_TIMES_SET))))
  return -EPERM;

 if ((attr->ia_valid & ATTR_SIZE)) {
  if (!f2fs_is_compress_backend_ready(inode) ||
    IS_DEVICE_ALIASING(inode))
   return -EOPNOTSUPP;
  if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
   !IS_ALIGNED(attr->ia_size,
   F2FS_BLK_TO_BYTES(fi->i_cluster_size)))
   return -EINVAL;
  /*
 * To prevent scattered pin block generation, we don't allow
 * smaller/equal size unaligned truncation for pinned file.
 * We only support overwrite IO to pinned file, so don't
 * care about larger size truncation.
 */
  if (f2fs_is_pinned_file(inode) &&
   attr->ia_size <= i_size_read(inode) &&
   !IS_ALIGNED(attr->ia_size,
   F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi))))
   return -EINVAL;
 }

 if (is_quota_modification(idmap, inode, attr)) {
  err = f2fs_dquot_initialize(inode);
  if (err)
   return err;
 }
 if (i_uid_needs_update(idmap, attr, inode) ||
     i_gid_needs_update(idmap, attr, inode)) {
  f2fs_lock_op(sbi);
  err = dquot_transfer(idmap, inode, attr);
  if (err) {
   set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
   f2fs_unlock_op(sbi);
   return err;
  }
  /*
 * update uid/gid under lock_op(), so that dquot and inode can
 * be updated atomically.
 */
  i_uid_update(idmap, attr, inode);
  i_gid_update(idmap, attr, inode);
  f2fs_mark_inode_dirty_sync(inode, true);
  f2fs_unlock_op(sbi);
 }

 if (attr->ia_valid & ATTR_SIZE) {
  loff_t old_size = i_size_read(inode);

  if (attr->ia_size > MAX_INLINE_DATA(inode)) {
   /*
 * should convert inline inode before i_size_write to
 * keep smaller than inline_data size with inline flag.
 */
   err = f2fs_convert_inline_inode(inode);
   if (err)
    return err;
  }

  /*
 * wait for inflight dio, blocks should be removed after
 * IO completion.
 */
  if (attr->ia_size < old_size)
   inode_dio_wait(inode);

  f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
  filemap_invalidate_lock(inode->i_mapping);

  if (attr->ia_size > old_size)
   f2fs_zero_post_eof_page(inode, attr->ia_size, false);
  truncate_setsize(inode, attr->ia_size);

  if (attr->ia_size <= old_size)
   err = f2fs_truncate(inode);
  /*
 * do not trim all blocks after i_size if target size is
 * larger than i_size.
 */
  filemap_invalidate_unlock(inode->i_mapping);
  f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
  if (err)
   return err;

  spin_lock(&fi->i_size_lock);
  inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
  fi->last_disk_size = i_size_read(inode);
  spin_unlock(&fi->i_size_lock);
 }

 __setattr_copy(idmap, inode, attr);

 if (attr->ia_valid & ATTR_MODE) {
  err = posix_acl_chmod(idmap, dentry, f2fs_get_inode_mode(inode));

  if (is_inode_flag_set(inode, FI_ACL_MODE)) {
   if (!err)
    inode->i_mode = fi->i_acl_mode;
   clear_inode_flag(inode, FI_ACL_MODE);
  }
 }

 /* file size may changed here */
 f2fs_mark_inode_dirty_sync(inode, true);

 /* inode change will produce dirty node pages flushed by checkpoint */
 f2fs_balance_fs(sbi, true);

 return err;
}

const struct inode_operations f2fs_file_inode_operations = {
 .getattr = f2fs_getattr,
 .setattr = f2fs_setattr,
 .get_inode_acl = f2fs_get_acl,
 .set_acl = f2fs_set_acl,
 .listxattr = f2fs_listxattr,
 .fiemap  = f2fs_fiemap,
 .fileattr_get = f2fs_fileattr_get,
 .fileattr_set = f2fs_fileattr_set,
};

static int fill_zero(struct inode *inode, pgoff_t index,
     loff_t start, loff_t len)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct folio *folio;

 if (!len)
  return 0;

 f2fs_balance_fs(sbi, true);

 f2fs_lock_op(sbi);
 folio = f2fs_get_new_data_folio(inode, NULL, index, false);
 f2fs_unlock_op(sbi);

 if (IS_ERR(folio))
  return PTR_ERR(folio);

 f2fs_folio_wait_writeback(folio, DATA, true, true);
 folio_zero_range(folio, start, len);
 folio_mark_dirty(folio);
 f2fs_folio_put(folio, true);
 return 0;
}

int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
{
 int err;

 while (pg_start < pg_end) {
  struct dnode_of_data dn;
  pgoff_t end_offset, count;

  set_new_dnode(&dn, inode, NULL, NULL, 0);
  err = f2fs_get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
  if (err) {
   if (err == -ENOENT) {
    pg_start = f2fs_get_next_page_offset(&dn,
        pg_start);
    continue;
   }
   return err;
  }

  end_offset = ADDRS_PER_PAGE(dn.node_folio, inode);
  count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);

  f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);

  f2fs_truncate_data_blocks_range(&dn, count);
  f2fs_put_dnode(&dn);

  pg_start += count;
 }
 return 0;
}

static int f2fs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
{
 pgoff_t pg_start, pg_end;
 loff_t off_start, off_end;
 int ret;

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

 f2fs_zero_post_eof_page(inode, offset + len, true);

 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;

 off_start = offset & (PAGE_SIZE - 1);
 off_end = (offset + len) & (PAGE_SIZE - 1);

 if (pg_start == pg_end) {
  ret = fill_zero(inode, pg_start, off_start,
      off_end - off_start);
  if (ret)
   return ret;
 } else {
  if (off_start) {
   ret = fill_zero(inode, pg_start++, off_start,
      PAGE_SIZE - off_start);
   if (ret)
    return ret;
  }
  if (off_end) {
   ret = fill_zero(inode, pg_end, 0, off_end);
   if (ret)
    return ret;
  }

  if (pg_start < pg_end) {
   loff_t blk_start, blk_end;
   struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

   f2fs_balance_fs(sbi, true);

   blk_start = (loff_t)pg_start << PAGE_SHIFT;
   blk_end = (loff_t)pg_end << PAGE_SHIFT;

   f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
   filemap_invalidate_lock(inode->i_mapping);

   truncate_pagecache_range(inode, blk_start, blk_end - 1);

   f2fs_lock_op(sbi);
   ret = f2fs_truncate_hole(inode, pg_start, pg_end);
   f2fs_unlock_op(sbi);

   filemap_invalidate_unlock(inode->i_mapping);
   f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
  }
 }

 return ret;
}

static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
    int *do_replace, pgoff_t off, pgoff_t len)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct dnode_of_data dn;
 int ret, done, i;

next_dnode:
 set_new_dnode(&dn, inode, NULL, NULL, 0);
 ret = f2fs_get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
 if (ret && ret != -ENOENT) {
  return ret;
 } else if (ret == -ENOENT) {
  if (dn.max_level == 0)
   return -ENOENT;
  done = min((pgoff_t)ADDRS_PER_BLOCK(inode) -
      dn.ofs_in_node, len);
  blkaddr += done;
  do_replace += done;
  goto next;
 }

 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_folio, inode) -
       dn.ofs_in_node, len);
 for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
  *blkaddr = f2fs_data_blkaddr(&dn);

  if (__is_valid_data_blkaddr(*blkaddr) &&
   !f2fs_is_valid_blkaddr(sbi, *blkaddr,
     DATA_GENERIC_ENHANCE)) {
   f2fs_put_dnode(&dn);
   return -EFSCORRUPTED;
  }

  if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) {

   if (f2fs_lfs_mode(sbi)) {
    f2fs_put_dnode(&dn);
    return -EOPNOTSUPP;
   }

   /* do not invalidate this block address */
   f2fs_update_data_blkaddr(&dn, NULL_ADDR);
   *do_replace = 1;
  }
 }
 f2fs_put_dnode(&dn);
next:
 len -= done;
 off += done;
 if (len)
  goto next_dnode;
 return 0;
}

static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
    int *do_replace, pgoff_t off, int len)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct dnode_of_data dn;
 int ret, i;

 for (i = 0; i < len; i++, do_replace++, blkaddr++) {
  if (*do_replace == 0)
   continue;

  set_new_dnode(&dn, inode, NULL, NULL, 0);
  ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
  if (ret) {
   dec_valid_block_count(sbi, inode, 1);
   f2fs_invalidate_blocks(sbi, *blkaddr, 1);
  } else {
   f2fs_update_data_blkaddr(&dn, *blkaddr);
  }
  f2fs_put_dnode(&dn);
 }
 return 0;
}

static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
   block_t *blkaddr, int *do_replace,
   pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
 pgoff_t i = 0;
 int ret;

 while (i < len) {
  if (blkaddr[i] == NULL_ADDR && !full) {
   i++;
   continue;
  }

  if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
   struct dnode_of_data dn;
   struct node_info ni;
   size_t new_size;
   pgoff_t ilen;

   set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
   ret = f2fs_get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
   if (ret)
    return ret;

   ret = f2fs_get_node_info(sbi, dn.nid, &ni, false);
   if (ret) {
    f2fs_put_dnode(&dn);
    return ret;
   }

   ilen = min((pgoff_t)
    ADDRS_PER_PAGE(dn.node_folio, dst_inode) -
      dn.ofs_in_node, len - i);
   do {
    dn.data_blkaddr = f2fs_data_blkaddr(&dn);
    f2fs_truncate_data_blocks_range(&dn, 1);

    if (do_replace[i]) {
     f2fs_i_blocks_write(src_inode,
       1, false, false);
     f2fs_i_blocks_write(dst_inode,
       1, true, false);
     f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
     blkaddr[i], ni.version, true, false);

     do_replace[i] = 0;
    }
    dn.ofs_in_node++;
    i++;
    new_size = (loff_t)(dst + i) << PAGE_SHIFT;
    if (dst_inode->i_size < new_size)
     f2fs_i_size_write(dst_inode, new_size);
   } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));

   f2fs_put_dnode(&dn);
  } else {
   struct folio *fsrc, *fdst;

   fsrc = f2fs_get_lock_data_folio(src_inode,
       src + i, true);
   if (IS_ERR(fsrc))
    return PTR_ERR(fsrc);
   fdst = f2fs_get_new_data_folio(dst_inode, NULL, dst + i,
        true);
   if (IS_ERR(fdst)) {
    f2fs_folio_put(fsrc, true);
    return PTR_ERR(fdst);
   }

   f2fs_folio_wait_writeback(fdst, DATA, true, true);

   memcpy_folio(fdst, 0, fsrc, 0, PAGE_SIZE);
   folio_mark_dirty(fdst);
   folio_set_f2fs_gcing(fdst);
   f2fs_folio_put(fdst, true);
   f2fs_folio_put(fsrc, true);

   ret = f2fs_truncate_hole(src_inode,
      src + i, src + i + 1);
   if (ret)
    return ret;
   i++;
  }
 }
 return 0;
}

static int __exchange_data_block(struct inode *src_inode,
   struct inode *dst_inode, pgoff_t src, pgoff_t dst,
   pgoff_t len, bool full)
{
 block_t *src_blkaddr;
 int *do_replace;
 pgoff_t olen;
 int ret;

 while (len) {
  olen = min((pgoff_t)4 * ADDRS_PER_BLOCK(src_inode), len);

  src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode),
     array_size(olen, sizeof(block_t)),
     GFP_NOFS);
  if (!src_blkaddr)
   return -ENOMEM;

  do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode),
     array_size(olen, sizeof(int)),
     GFP_NOFS);
  if (!do_replace) {
   kvfree(src_blkaddr);
   return -ENOMEM;
  }

  ret = __read_out_blkaddrs(src_inode, src_blkaddr,
     do_replace, src, olen);
  if (ret)
   goto roll_back;

  ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
     do_replace, src, dst, olen, full);
  if (ret)
   goto roll_back;

  src += olen;
  dst += olen;
  len -= olen;

  kvfree(src_blkaddr);
  kvfree(do_replace);
 }
 return 0;

roll_back:
 __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, olen);
 kvfree(src_blkaddr);
 kvfree(do_replace);
 return ret;
}

static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
 pgoff_t start = offset >> PAGE_SHIFT;
 pgoff_t end = (offset + len) >> PAGE_SHIFT;
 int ret;

 f2fs_balance_fs(sbi, true);

 /* avoid gc operation during block exchange */
 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 filemap_invalidate_lock(inode->i_mapping);

 f2fs_zero_post_eof_page(inode, offset + len, false);

 f2fs_lock_op(sbi);
 f2fs_drop_extent_tree(inode);
 truncate_pagecache(inode, offset);
 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
 f2fs_unlock_op(sbi);

 filemap_invalidate_unlock(inode->i_mapping);
 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 return ret;
}

static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
{
 loff_t new_size;
 int ret;

 if (offset + len >= i_size_read(inode))
  return -EINVAL;

 /* collapse range should be aligned to block size of f2fs. */
 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
  return -EINVAL;

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

 /* write out all dirty pages from offset */
 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
 if (ret)
  return ret;

 ret = f2fs_do_collapse(inode, offset, len);
 if (ret)
  return ret;

 /* write out all moved pages, if possible */
 filemap_invalidate_lock(inode->i_mapping);
 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
 truncate_pagecache(inode, offset);

 new_size = i_size_read(inode) - len;
 ret = f2fs_truncate_blocks(inode, new_size, true);
 filemap_invalidate_unlock(inode->i_mapping);
 if (!ret)
  f2fs_i_size_write(inode, new_size);
 return ret;
}

static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
        pgoff_t end)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 pgoff_t index = start;
 unsigned int ofs_in_node = dn->ofs_in_node;
 blkcnt_t count = 0;
 int ret;

 for (; index < end; index++, dn->ofs_in_node++) {
  if (f2fs_data_blkaddr(dn) == NULL_ADDR)
   count++;
 }

 dn->ofs_in_node = ofs_in_node;
 ret = f2fs_reserve_new_blocks(dn, count);
 if (ret)
  return ret;

 dn->ofs_in_node = ofs_in_node;
 for (index = start; index < end; index++, dn->ofs_in_node++) {
  dn->data_blkaddr = f2fs_data_blkaddr(dn);
  /*
 * f2fs_reserve_new_blocks will not guarantee entire block
 * allocation.
 */
  if (dn->data_blkaddr == NULL_ADDR) {
   ret = -ENOSPC;
   break;
  }

  if (dn->data_blkaddr == NEW_ADDR)
   continue;

  if (!f2fs_is_valid_blkaddr(sbi, dn->data_blkaddr,
     DATA_GENERIC_ENHANCE)) {
   ret = -EFSCORRUPTED;
   break;
  }

  f2fs_invalidate_blocks(sbi, dn->data_blkaddr, 1);
  f2fs_set_data_blkaddr(dn, NEW_ADDR);
 }

 f2fs_update_read_extent_cache_range(dn, start, 0, index - start);
 f2fs_update_age_extent_cache_range(dn, start, index - start);

 return ret;
}

static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
        int mode)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct address_space *mapping = inode->i_mapping;
 pgoff_t index, pg_start, pg_end;
 loff_t new_size = i_size_read(inode);
 loff_t off_start, off_end;
 int ret = 0;

 ret = inode_newsize_ok(inode, (len + offset));
 if (ret)
  return ret;

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

 ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
 if (ret)
  return ret;

 f2fs_zero_post_eof_page(inode, offset + len, true);

 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;

 off_start = offset & (PAGE_SIZE - 1);
 off_end = (offset + len) & (PAGE_SIZE - 1);

 if (pg_start == pg_end) {
  ret = fill_zero(inode, pg_start, off_start,
      off_end - off_start);
  if (ret)
   return ret;

  new_size = max_t(loff_t, new_size, offset + len);
 } else {
  if (off_start) {
   ret = fill_zero(inode, pg_start++, off_start,
      PAGE_SIZE - off_start);
   if (ret)
    return ret;

   new_size = max_t(loff_t, new_size,
     (loff_t)pg_start << PAGE_SHIFT);
  }

  for (index = pg_start; index < pg_end;) {
   struct dnode_of_data dn;
   unsigned int end_offset;
   pgoff_t end;

   f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
   filemap_invalidate_lock(mapping);

   truncate_pagecache_range(inode,
    (loff_t)index << PAGE_SHIFT,
    ((loff_t)pg_end << PAGE_SHIFT) - 1);

   f2fs_lock_op(sbi);

   set_new_dnode(&dn, inode, NULL, NULL, 0);
   ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
   if (ret) {
    f2fs_unlock_op(sbi);
    filemap_invalidate_unlock(mapping);
    f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
    goto out;
   }

   end_offset = ADDRS_PER_PAGE(dn.node_folio, inode);
   end = min(pg_end, end_offset - dn.ofs_in_node + index);

   ret = f2fs_do_zero_range(&dn, index, end);
   f2fs_put_dnode(&dn);

   f2fs_unlock_op(sbi);
   filemap_invalidate_unlock(mapping);
   f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);

   f2fs_balance_fs(sbi, dn.node_changed);

   if (ret)
    goto out;

   index = end;
   new_size = max_t(loff_t, new_size,
     (loff_t)index << PAGE_SHIFT);
  }

  if (off_end) {
   ret = fill_zero(inode, pg_end, 0, off_end);
   if (ret)
    goto out;

   new_size = max_t(loff_t, new_size, offset + len);
  }
 }

out:
 if (new_size > i_size_read(inode)) {
  if (mode & FALLOC_FL_KEEP_SIZE)
   file_set_keep_isize(inode);
  else
   f2fs_i_size_write(inode, new_size);
 }
 return ret;
}

static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct address_space *mapping = inode->i_mapping;
 pgoff_t nr, pg_start, pg_end, delta, idx;
 loff_t new_size;
 int ret = 0;

 new_size = i_size_read(inode) + len;
 ret = inode_newsize_ok(inode, new_size);
 if (ret)
  return ret;

 if (offset >= i_size_read(inode))
  return -EINVAL;

 /* insert range should be aligned to block size of f2fs. */
 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
  return -EINVAL;

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

 f2fs_balance_fs(sbi, true);

 filemap_invalidate_lock(mapping);
 ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);
 filemap_invalidate_unlock(mapping);
 if (ret)
  return ret;

 /* write out all dirty pages from offset */
 ret = filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
 if (ret)
  return ret;

 pg_start = offset >> PAGE_SHIFT;
 pg_end = (offset + len) >> PAGE_SHIFT;
 delta = pg_end - pg_start;
 idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

 /* avoid gc operation during block exchange */
 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 filemap_invalidate_lock(mapping);

 f2fs_zero_post_eof_page(inode, offset + len, false);
 truncate_pagecache(inode, offset);

 while (!ret && idx > pg_start) {
  nr = idx - pg_start;
  if (nr > delta)
   nr = delta;
  idx -= nr;

  f2fs_lock_op(sbi);
  f2fs_drop_extent_tree(inode);

  ret = __exchange_data_block(inode, inode, idx,
     idx + delta, nr, false);
  f2fs_unlock_op(sbi);
 }
 filemap_invalidate_unlock(mapping);
 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 if (ret)
  return ret;

 /* write out all moved pages, if possible */
 filemap_invalidate_lock(mapping);
 ret = filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
 truncate_pagecache(inode, offset);
 filemap_invalidate_unlock(mapping);

 if (!ret)
  f2fs_i_size_write(inode, new_size);
 return ret;
}

static int f2fs_expand_inode_data(struct inode *inode, loff_t offset,
     loff_t len, int mode)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 struct f2fs_map_blocks map = { .m_next_pgofs = NULL,
   .m_next_extent = NULL, .m_seg_type = NO_CHECK_TYPE,
   .m_may_create = true };
 struct f2fs_gc_control gc_control = { .victim_segno = NULL_SEGNO,
   .init_gc_type = FG_GC,
   .should_migrate_blocks = false,
   .err_gc_skipped = true,
   .nr_free_secs = 0 };
 pgoff_t pg_start, pg_end;
 loff_t new_size;
 loff_t off_end;
 block_t expanded = 0;
 int err;

 err = inode_newsize_ok(inode, (len + offset));
 if (err)
  return err;

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

 f2fs_zero_post_eof_page(inode, offset + len, true);

 f2fs_balance_fs(sbi, true);

 pg_start = ((unsigned long long)offset) >> PAGE_SHIFT;
 pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
 off_end = (offset + len) & (PAGE_SIZE - 1);

 map.m_lblk = pg_start;
 map.m_len = pg_end - pg_start;
 if (off_end)
  map.m_len++;

 if (!map.m_len)
  return 0;

 if (f2fs_is_pinned_file(inode)) {
  block_t sec_blks = CAP_BLKS_PER_SEC(sbi);
  block_t sec_len = roundup(map.m_len, sec_blks);

  map.m_len = sec_blks;
next_alloc:
  f2fs_down_write(&sbi->pin_sem);

  if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
   if (has_not_enough_free_secs(sbi, 0, 0)) {
    f2fs_up_write(&sbi->pin_sem);
    err = -ENOSPC;
    f2fs_warn_ratelimited(sbi,
     "ino:%lu, start:%lu, end:%lu, need to trigger GC to "
     "reclaim enough free segment when checkpoint is enabled",
     inode->i_ino, pg_start, pg_end);
    goto out_err;
   }
  }

  if (has_not_enough_free_secs(sbi, 0,
    sbi->reserved_pin_section)) {
   f2fs_down_write(&sbi->gc_lock);
   stat_inc_gc_call_count(sbi, FOREGROUND);
   err = f2fs_gc(sbi, &gc_control);
   if (err && err != -ENODATA) {
    f2fs_up_write(&sbi->pin_sem);
    goto out_err;
   }
  }

  err = f2fs_allocate_pinning_section(sbi);
  if (err) {
   f2fs_up_write(&sbi->pin_sem);
   goto out_err;
  }

  map.m_seg_type = CURSEG_COLD_DATA_PINNED;
  err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_DIO);
  file_dont_truncate(inode);

  f2fs_up_write(&sbi->pin_sem);

  expanded += map.m_len;
  sec_len -= map.m_len;
  map.m_lblk += map.m_len;
  if (!err && sec_len)
   goto next_alloc;

  map.m_len = expanded;
 } else {
  err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
  expanded = map.m_len;
 }
out_err:
 if (err) {
  pgoff_t last_off;

  if (!expanded)
   return err;

  last_off = pg_start + expanded - 1;

  /* update new size to the failed position */
  new_size = (last_off == pg_end) ? offset + len :
     (loff_t)(last_off + 1) << PAGE_SHIFT;
 } else {
  new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
 }

 if (new_size > i_size_read(inode)) {
  if (mode & FALLOC_FL_KEEP_SIZE)
   file_set_keep_isize(inode);
  else
   f2fs_i_size_write(inode, new_size);
 }

 return err;
}

static long f2fs_fallocate(struct file *file, int mode,
    loff_t offset, loff_t len)
{
 struct inode *inode = file_inode(file);
 long ret = 0;

 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
  return -EIO;
 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
  return -ENOSPC;
 if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
  return -EOPNOTSUPP;

 /* f2fs only support ->fallocate for regular file */
 if (!S_ISREG(inode->i_mode))
  return -EINVAL;

 if (IS_ENCRYPTED(inode) &&
  (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
  return -EOPNOTSUPP;

 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
   FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
   FALLOC_FL_INSERT_RANGE))
  return -EOPNOTSUPP;

 inode_lock(inode);

 /*
 * Pinned file should not support partial truncation since the block
 * can be used by applications.
 */
 if ((f2fs_compressed_file(inode) || f2fs_is_pinned_file(inode)) &&
  (mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_COLLAPSE_RANGE |
   FALLOC_FL_ZERO_RANGE | FALLOC_FL_INSERT_RANGE))) {
  ret = -EOPNOTSUPP;
  goto out;
 }

 ret = file_modified(file);
 if (ret)
  goto out;

 /*
 * wait for inflight dio, blocks should be removed after IO
 * completion.
 */
 inode_dio_wait(inode);

 if (mode & FALLOC_FL_PUNCH_HOLE) {
  if (offset >= inode->i_size)
   goto out;

  ret = f2fs_punch_hole(inode, offset, len);
 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
  ret = f2fs_collapse_range(inode, offset, len);
 } else if (mode & FALLOC_FL_ZERO_RANGE) {
  ret = f2fs_zero_range(inode, offset, len, mode);
 } else if (mode & FALLOC_FL_INSERT_RANGE) {
  ret = f2fs_insert_range(inode, offset, len);
 } else {
  ret = f2fs_expand_inode_data(inode, offset, len, mode);
 }

 if (!ret) {
  inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
  f2fs_mark_inode_dirty_sync(inode, false);
  f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
 }

out:
 inode_unlock(inode);

 trace_f2fs_fallocate(inode, mode, offset, len, ret);
 return ret;
}

static int f2fs_release_file(struct inode *inode, struct file *filp)
{
 if (atomic_dec_and_test(&F2FS_I(inode)->open_count))
  f2fs_remove_donate_inode(inode);

 /*
 * f2fs_release_file is called at every close calls. So we should
 * not drop any inmemory pages by close called by other process.
 */
 if (!(filp->f_mode & FMODE_WRITE) ||
   atomic_read(&inode->i_writecount) != 1)
  return 0;

 inode_lock(inode);
 f2fs_abort_atomic_write(inode, true);
 inode_unlock(inode);

 return 0;
}

static int f2fs_file_flush(struct file *file, fl_owner_t id)
{
 struct inode *inode = file_inode(file);

 /*
 * If the process doing a transaction is crashed, we should do
 * roll-back. Otherwise, other reader/write can see corrupted database
 * until all the writers close its file. Since this should be done
 * before dropping file lock, it needs to do in ->flush.
 */
 if (F2FS_I(inode)->atomic_write_task == current &&
    (current->flags & PF_EXITING)) {
  inode_lock(inode);
  f2fs_abort_atomic_write(inode, true);
  inode_unlock(inode);
 }

 return 0;
}

static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)
{
 struct f2fs_inode_info *fi = F2FS_I(inode);
 u32 masked_flags = fi->i_flags & mask;

 /* mask can be shrunk by flags_valid selector */
 iflags &= mask;

 /* Is it quota file? Do not allow user to mess with it */
 if (IS_NOQUOTA(inode))
  return -EPERM;

 if ((iflags ^ masked_flags) & F2FS_CASEFOLD_FL) {
  if (!f2fs_sb_has_casefold(F2FS_I_SB(inode)))
   return -EOPNOTSUPP;
  if (!f2fs_empty_dir(inode))
   return -ENOTEMPTY;
 }

 if (iflags & (F2FS_COMPR_FL | F2FS_NOCOMP_FL)) {
  if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
   return -EOPNOTSUPP;
  if ((iflags & F2FS_COMPR_FL) && (iflags & F2FS_NOCOMP_FL))
   return -EINVAL;
 }

 if ((iflags ^ masked_flags) & F2FS_COMPR_FL) {
  if (masked_flags & F2FS_COMPR_FL) {
   if (!f2fs_disable_compressed_file(inode))
    return -EINVAL;
  } else {
   /* try to convert inline_data to support compression */
   int err = f2fs_convert_inline_inode(inode);
   if (err)
    return err;

   f2fs_down_write(&fi->i_sem);
   if (!f2fs_may_compress(inode) ||
     (S_ISREG(inode->i_mode) &&
     F2FS_HAS_BLOCKS(inode))) {
    f2fs_up_write(&fi->i_sem);
    return -EINVAL;
   }
   err = set_compress_context(inode);
   f2fs_up_write(&fi->i_sem);

   if (err)
    return err;
  }
 }

 fi->i_flags = iflags | (fi->i_flags & ~mask);
 f2fs_bug_on(F2FS_I_SB(inode), (fi->i_flags & F2FS_COMPR_FL) &&
     (fi->i_flags & F2FS_NOCOMP_FL));

 if (fi->i_flags & F2FS_PROJINHERIT_FL)
  set_inode_flag(inode, FI_PROJ_INHERIT);
 else
  clear_inode_flag(inode, FI_PROJ_INHERIT);

 inode_set_ctime_current(inode);
 f2fs_set_inode_flags(inode);
 f2fs_mark_inode_dirty_sync(inode, true);
 return 0;
}

/* FS_IOC_[GS]ETFLAGS and FS_IOC_FS[GS]ETXATTR support */

/*
 * To make a new on-disk f2fs i_flag gettable via FS_IOC_GETFLAGS, add an entry
 * for it to f2fs_fsflags_map[], and add its FS_*_FL equivalent to
 * F2FS_GETTABLE_FS_FL.  To also make it settable via FS_IOC_SETFLAGS, also add
 * its FS_*_FL equivalent to F2FS_SETTABLE_FS_FL.
 *
 * Translating flags to fsx_flags value used by FS_IOC_FSGETXATTR and
 * FS_IOC_FSSETXATTR is done by the VFS.
 */

static const struct {
 u32 iflag;
 u32 fsflag;
} f2fs_fsflags_map[] = {
 { F2FS_COMPR_FL, FS_COMPR_FL },
 { F2FS_SYNC_FL,  FS_SYNC_FL },
 { F2FS_IMMUTABLE_FL, FS_IMMUTABLE_FL },
 { F2FS_APPEND_FL, FS_APPEND_FL },
 { F2FS_NODUMP_FL, FS_NODUMP_FL },
 { F2FS_NOATIME_FL, FS_NOATIME_FL },
 { F2FS_NOCOMP_FL, FS_NOCOMP_FL },
 { F2FS_INDEX_FL, FS_INDEX_FL },
 { F2FS_DIRSYNC_FL, FS_DIRSYNC_FL },
 { F2FS_PROJINHERIT_FL, FS_PROJINHERIT_FL },
 { F2FS_CASEFOLD_FL, FS_CASEFOLD_FL },
};

#define F2FS_GETTABLE_FS_FL (  \
  FS_COMPR_FL |  \
  FS_SYNC_FL |  \
  FS_IMMUTABLE_FL | \
  FS_APPEND_FL |  \
  FS_NODUMP_FL |  \
  FS_NOATIME_FL |  \
  FS_NOCOMP_FL |  \
  FS_INDEX_FL |  \
  FS_DIRSYNC_FL |  \
  FS_PROJINHERIT_FL | \
  FS_ENCRYPT_FL |  \
  FS_INLINE_DATA_FL | \
  FS_NOCOW_FL |  \
  FS_VERITY_FL |  \
  FS_CASEFOLD_FL)

#define F2FS_SETTABLE_FS_FL (  \
  FS_COMPR_FL |  \
  FS_SYNC_FL |  \
  FS_IMMUTABLE_FL | \
  FS_APPEND_FL |  \
  FS_NODUMP_FL |  \
  FS_NOATIME_FL |  \
  FS_NOCOMP_FL |  \
  FS_DIRSYNC_FL |  \
  FS_PROJINHERIT_FL | \
  FS_CASEFOLD_FL)

/* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
static inline u32 f2fs_iflags_to_fsflags(u32 iflags)
{
 u32 fsflags = 0;
 int i;

 for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
  if (iflags & f2fs_fsflags_map[i].iflag)
   fsflags |= f2fs_fsflags_map[i].fsflag;

 return fsflags;
}

/* Convert FS_IOC_{GET,SET}FLAGS flags to f2fs on-disk i_flags */
static inline u32 f2fs_fsflags_to_iflags(u32 fsflags)
{
 u32 iflags = 0;
 int i;

 for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
  if (fsflags & f2fs_fsflags_map[i].fsflag)
   iflags |= f2fs_fsflags_map[i].iflag;

 return iflags;
}

static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
{
 struct inode *inode = file_inode(filp);

 return put_user(inode->i_generation, (int __user *)arg);
}

static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
{
 struct inode *inode = file_inode(filp);
 struct mnt_idmap *idmap = file_mnt_idmap(filp);
 struct f2fs_inode_info *fi = F2FS_I(inode);
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 loff_t isize;
 int ret;

 if (!(filp->f_mode & FMODE_WRITE))
  return -EBADF;

 if (!inode_owner_or_capable(idmap, inode))
  return -EACCES;

 if (!S_ISREG(inode->i_mode))
  return -EINVAL;

 if (filp->f_flags & O_DIRECT)
  return -EINVAL;

 ret = mnt_want_write_file(filp);
 if (ret)
  return ret;

 inode_lock(inode);

 if (!f2fs_disable_compressed_file(inode) ||
   f2fs_is_pinned_file(inode)) {
  ret = -EINVAL;
  goto out;
 }

 if (f2fs_is_atomic_file(inode))
  goto out;

 ret = f2fs_convert_inline_inode(inode);
 if (ret)
  goto out;

 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
 f2fs_down_write(&fi->i_gc_rwsem[READ]);

 /*
 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
 * f2fs_is_atomic_file.
 */
 if (get_dirty_pages(inode))
  f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%lu, npages=%u",
     inode->i_ino, get_dirty_pages(inode));
 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
 if (ret)
  goto out_unlock;

 /* Check if the inode already has a COW inode */
 if (fi->cow_inode == NULL) {
  /* Create a COW inode for atomic write */
  struct dentry *dentry = file_dentry(filp);
  struct inode *dir = d_inode(dentry->d_parent);

  ret = f2fs_get_tmpfile(idmap, dir, &fi->cow_inode);
  if (ret)
   goto out_unlock;

  set_inode_flag(fi->cow_inode, FI_COW_FILE);
  clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);

  /* Set the COW inode's atomic_inode to the atomic inode */
  F2FS_I(fi->cow_inode)->atomic_inode = inode;
 } else {
  /* Reuse the already created COW inode */
  f2fs_bug_on(sbi, get_dirty_pages(fi->cow_inode));

  invalidate_mapping_pages(fi->cow_inode->i_mapping, 0, -1);

  ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
  if (ret)
   goto out_unlock;
 }

 f2fs_write_inode(inode, NULL);

 stat_inc_atomic_inode(inode);

 set_inode_flag(inode, FI_ATOMIC_FILE);

 isize = i_size_read(inode);
 fi->original_i_size = isize;
 if (truncate) {
  set_inode_flag(inode, FI_ATOMIC_REPLACE);
  truncate_inode_pages_final(inode->i_mapping);
  f2fs_i_size_write(inode, 0);
  isize = 0;
 }
 f2fs_i_size_write(fi->cow_inode, isize);

out_unlock:
 f2fs_up_write(&fi->i_gc_rwsem[READ]);
 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 if (ret)
  goto out;

 f2fs_update_time(sbi, REQ_TIME);
 fi->atomic_write_task = current;
 stat_update_max_atomic_write(inode);
 fi->atomic_write_cnt = 0;
out:
 inode_unlock(inode);
 mnt_drop_write_file(filp);
 return ret;
}

static int f2fs_ioc_commit_atomic_write(struct file *filp)
{
 struct inode *inode = file_inode(filp);
 struct mnt_idmap *idmap = file_mnt_idmap(filp);
 int ret;

 if (!(filp->f_mode & FMODE_WRITE))
  return -EBADF;

 if (!inode_owner_or_capable(idmap, inode))
  return -EACCES;

 ret = mnt_want_write_file(filp);
 if (ret)
  return ret;

 f2fs_balance_fs(F2FS_I_SB(inode), true);

 inode_lock(inode);

 if (f2fs_is_atomic_file(inode)) {
  ret = f2fs_commit_atomic_write(inode);
  if (!ret)
   ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);

  f2fs_abort_atomic_write(inode, ret);
 } else {
  ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
 }

 inode_unlock(inode);
 mnt_drop_write_file(filp);
 return ret;
}

static int f2fs_ioc_abort_atomic_write(struct file *filp)
{
 struct inode *inode = file_inode(filp);
 struct mnt_idmap *idmap = file_mnt_idmap(filp);
 int ret;

 if (!(filp->f_mode & FMODE_WRITE))
  return -EBADF;

 if (!inode_owner_or_capable(idmap, inode))
  return -EACCES;

 ret = mnt_want_write_file(filp);
 if (ret)
  return ret;

 inode_lock(inode);

 f2fs_abort_atomic_write(inode, true);

 inode_unlock(inode);

 mnt_drop_write_file(filp);
 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
 return ret;
}

int f2fs_do_shutdown(struct f2fs_sb_info *sbi, unsigned int flag,
      bool readonly, bool need_lock)
{
 struct super_block *sb = sbi->sb;
 int ret = 0;

 switch (flag) {
 case F2FS_GOING_DOWN_FULLSYNC:
  ret = bdev_freeze(sb->s_bdev);
  if (ret)
   goto out;
  f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
  bdev_thaw(sb->s_bdev);
  break;
 case F2FS_GOING_DOWN_METASYNC:
  /* do checkpoint only */
  ret = f2fs_sync_fs(sb, 1);
  if (ret) {
   if (ret == -EIO)
    ret = 0;
   goto out;
  }
  f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
  break;
 case F2FS_GOING_DOWN_NOSYNC:
  f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
  break;
 case F2FS_GOING_DOWN_METAFLUSH:
  f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO);
  f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
  break;
 case F2FS_GOING_DOWN_NEED_FSCK:
  set_sbi_flag(sbi, SBI_NEED_FSCK);
  set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
  set_sbi_flag(sbi, SBI_IS_DIRTY);
  /* do checkpoint only */
  ret = f2fs_sync_fs(sb, 1);
  if (ret == -EIO)
   ret = 0;
  goto out;
 default:
  ret = -EINVAL;
  goto out;
 }

 if (readonly)
  goto out;

 /*
 * grab sb->s_umount to avoid racing w/ remount() and other shutdown
 * paths.
 */
 if (need_lock)
  down_write(&sbi->sb->s_umount);

 f2fs_stop_gc_thread(sbi);
 f2fs_stop_discard_thread(sbi);

 f2fs_drop_discard_cmd(sbi);
 clear_opt(sbi, DISCARD);

 if (need_lock)
  up_write(&sbi->sb->s_umount);

 f2fs_update_time(sbi, REQ_TIME);
out:

 trace_f2fs_shutdown(sbi, flag, ret);

 return ret;
}

static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
{
 struct inode *inode = file_inode(filp);
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 __u32 in;
 int ret;
 bool need_drop = false, readonly = false;

 if (!capable(CAP_SYS_ADMIN))
  return -EPERM;

 if (get_user(in, (__u32 __user *)arg))
  return -EFAULT;

 if (in != F2FS_GOING_DOWN_FULLSYNC) {
  ret = mnt_want_write_file(filp);
  if (ret) {
   if (ret != -EROFS)
    return ret;

   /* fallback to nosync shutdown for readonly fs */
   in = F2FS_GOING_DOWN_NOSYNC;
   readonly = true;
  } else {
   need_drop = true;
  }
 }

 ret = f2fs_do_shutdown(sbi, in, readonly, true);

 if (need_drop)
  mnt_drop_write_file(filp);

 return ret;
}

static int f2fs_keep_noreuse_range(struct inode *inode,
    loff_t offset, loff_t len)
{
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 u64 max_bytes = F2FS_BLK_TO_BYTES(max_file_blocks(inode));
 u64 start, end;
 int ret = 0;

 if (!S_ISREG(inode->i_mode))
  return 0;

 if (offset >= max_bytes || len > max_bytes ||
     (offset + len) > max_bytes)
  return 0;

 start = offset >> PAGE_SHIFT;
 end = DIV_ROUND_UP(offset + len, PAGE_SIZE);

 inode_lock(inode);
 if (f2fs_is_atomic_file(inode)) {
  inode_unlock(inode);
  return 0;
 }

 spin_lock(&sbi->inode_lock[DONATE_INODE]);
 /* let's remove the range, if len = 0 */
 if (!len) {
  if (!list_empty(&F2FS_I(inode)->gdonate_list)) {
   list_del_init(&F2FS_I(inode)->gdonate_list);
   sbi->donate_files--;
   if (is_inode_flag_set(inode, FI_DONATE_FINISHED))
    ret = -EALREADY;
   else
    set_inode_flag(inode, FI_DONATE_FINISHED);
  } else
   ret = -ENOENT;
 } else {
  if (list_empty(&F2FS_I(inode)->gdonate_list)) {
   list_add_tail(&F2FS_I(inode)->gdonate_list,
     &sbi->inode_list[DONATE_INODE]);
   sbi->donate_files++;
  } else {
   list_move_tail(&F2FS_I(inode)->gdonate_list,
     &sbi->inode_list[DONATE_INODE]);
  }
  F2FS_I(inode)->donate_start = start;
  F2FS_I(inode)->donate_end = end - 1;
  clear_inode_flag(inode, FI_DONATE_FINISHED);
 }
 spin_unlock(&sbi->inode_lock[DONATE_INODE]);
 inode_unlock(inode);

 return ret;
}

static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
{
 struct inode *inode = file_inode(filp);
 struct super_block *sb = inode->i_sb;
 struct fstrim_range range;
 int ret;

 if (!capable(CAP_SYS_ADMIN))
  return -EPERM;

 if (!f2fs_hw_support_discard(F2FS_SB(sb)))
  return -EOPNOTSUPP;

 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
    sizeof(range)))
  return -EFAULT;

 ret = mnt_want_write_file(filp);
 if (ret)
  return ret;

 range.minlen = max((unsigned int)range.minlen,
      bdev_discard_granularity(sb->s_bdev));
 ret = f2fs_trim_fs(F2FS_SB(sb), &range);
 mnt_drop_write_file(filp);
 if (ret < 0)
  return ret;

 if (copy_to_user((struct fstrim_range __user *)arg, &range,
    sizeof(range)))
  return -EFAULT;
 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
 return 0;
}

static bool uuid_is_nonzero(__u8 u[16])
{
 int i;

 for (i = 0; i < 16; i++)
  if (u[i])
   return true;
 return false;
}

static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
{
 struct inode *inode = file_inode(filp);
 int ret;

 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode)))
  return -EOPNOTSUPP;

 ret = fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
 return ret;
}

static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
{
 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
  return -EOPNOTSUPP;
 return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
}

static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
{
 struct inode *inode = file_inode(filp);
 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 u8 encrypt_pw_salt[16];
 int err;

 if (!f2fs_sb_has_encrypt(sbi))
  return -EOPNOTSUPP;

 err = mnt_want_write_file(filp);
--> --------------------

--> maximum size reached

--> --------------------