fs/f2fs/file.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fs/f2fs/file.c
   4  *
   5  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   6  *             http://www.samsung.com/
   7  */
   8 #include <linux/fs.h>
   9 #include <linux/f2fs_fs.h>
  10 #include <linux/stat.h>
  11 #include <linux/buffer_head.h>
  12 #include <linux/writeback.h>
  13 #include <linux/blkdev.h>
  14 #include <linux/falloc.h>
  15 #include <linux/types.h>
  16 #include <linux/compat.h>
  17 #include <linux/uaccess.h>
  18 #include <linux/mount.h>
  19 #include <linux/pagevec.h>
  20 #include <linux/uio.h>
  21 #include <linux/uuid.h>
  22 #include <linux/file.h>
  23
  24 #include "f2fs.h"
  25 #include "node.h"
  26 #include "segment.h"
  27 #include "xattr.h"
  28 #include "acl.h"
  29 #include "gc.h"
  30 #include "trace.h"
  31 #include <trace/events/f2fs.h>
  32
  33 static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
  34 {
  35         struct inode *inode = file_inode(vmf->vma->vm_file);
  36         vm_fault_t ret;
  37
  38         down_read(&F2FS_I(inode)->i_mmap_sem);
  39         ret = filemap_fault(vmf);
  40         up_read(&F2FS_I(inode)->i_mmap_sem);
  41
  42         trace_f2fs_filemap_fault(inode, vmf->pgoff, (unsigned long)ret);
  43
  44         return ret;
  45 }
  46
  47 static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
  48 {
  49         struct page *page = vmf->page;
  50         struct inode *inode = file_inode(vmf->vma->vm_file);
  51         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  52         struct dnode_of_data dn = { .node_changed = false };
  53         int err;
  54
  55         if (unlikely(f2fs_cp_error(sbi))) {
  56                 err = -EIO;
  57                 goto err;
  58         }
  59
  60         sb_start_pagefault(inode->i_sb);
  61
  62         f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
  63
  64         file_update_time(vmf->vma->vm_file);
  65         down_read(&F2FS_I(inode)->i_mmap_sem);
  66         lock_page(page);
  67         if (unlikely(page->mapping != inode->i_mapping ||
  68                         page_offset(page) > i_size_read(inode) ||
  69                         !PageUptodate(page))) {
  70                 unlock_page(page);
  71                 err = -EFAULT;
  72                 goto out_sem;
  73         }
  74
  75         /* block allocation */
  76         __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true);
  77         set_new_dnode(&dn, inode, NULL, NULL, 0);
  78         err = f2fs_get_block(&dn, page->index);
  79         f2fs_put_dnode(&dn);
  80         __do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false);
  81         if (err) {
  82                 unlock_page(page);
  83                 goto out_sem;
  84         }
  85
  86         /* fill the page */
  87         f2fs_wait_on_page_writeback(page, DATA, false, true);
  88
  89         /* wait for GCed page writeback via META_MAPPING */
  90         f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
  91
  92         /*
  93          * check to see if the page is mapped already (no holes)
  94          */
  95         if (PageMappedToDisk(page))
  96                 goto out_sem;
  97
  98         /* page is wholly or partially inside EOF */
  99         if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
 100                                                 i_size_read(inode)) {
 101                 loff_t offset;
 102
 103                 offset = i_size_read(inode) & ~PAGE_MASK;
 104                 zero_user_segment(page, offset, PAGE_SIZE);
 105         }
 106         set_page_dirty(page);
 107         if (!PageUptodate(page))
 108                 SetPageUptodate(page);
 109
 110         f2fs_update_iostat(sbi, APP_MAPPED_IO, F2FS_BLKSIZE);
 111         f2fs_update_time(sbi, REQ_TIME);
 112
 113         trace_f2fs_vm_page_mkwrite(page, DATA);
 114 out_sem:
 115         up_read(&F2FS_I(inode)->i_mmap_sem);
 116
 117         f2fs_balance_fs(sbi, dn.node_changed);
 118
 119         sb_end_pagefault(inode->i_sb);
 120 err:
 121         return block_page_mkwrite_return(err);
 122 }
 123
 124 static const struct vm_operations_struct f2fs_file_vm_ops = {
 125         .fault          = f2fs_filemap_fault,
 126         .map_pages      = filemap_map_pages,
 127         .page_mkwrite   = f2fs_vm_page_mkwrite,
 128 };
 129
 130 static int get_parent_ino(struct inode *inode, nid_t *pino)
 131 {
 132         struct dentry *dentry;
 133
 134         inode = igrab(inode);
 135         dentry = d_find_any_alias(inode);
 136         iput(inode);
 137         if (!dentry)
 138                 return 0;
 139
 140         *pino = parent_ino(dentry);
 141         dput(dentry);
 142         return 1;
 143 }
 144
 145 static inline enum cp_reason_type need_do_checkpoint(struct inode *inode)
 146 {
 147         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 148         enum cp_reason_type cp_reason = CP_NO_NEEDED;
 149
 150         if (!S_ISREG(inode->i_mode))
 151                 cp_reason = CP_NON_REGULAR;
 152         else if (inode->i_nlink != 1)
 153                 cp_reason = CP_HARDLINK;
 154         else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
 155                 cp_reason = CP_SB_NEED_CP;
 156         else if (file_wrong_pino(inode))
 157                 cp_reason = CP_WRONG_PINO;
 158         else if (!f2fs_space_for_roll_forward(sbi))
 159                 cp_reason = CP_NO_SPC_ROLL;
 160         else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
 161                 cp_reason = CP_NODE_NEED_CP;
 162         else if (test_opt(sbi, FASTBOOT))
 163                 cp_reason = CP_FASTBOOT_MODE;
 164         else if (F2FS_OPTION(sbi).active_logs == 2)
 165                 cp_reason = CP_SPEC_LOG_NUM;
 166         else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT &&
 167                 f2fs_need_dentry_mark(sbi, inode->i_ino) &&
 168                 f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino,
 169                                                         TRANS_DIR_INO))
 170                 cp_reason = CP_RECOVER_DIR;
 171
 172         return cp_reason;
 173 }
 174
 175 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
 176 {
 177         struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
 178         bool ret = false;
 179         /* But we need to avoid that there are some inode updates */
 180         if ((i && PageDirty(i)) || f2fs_need_inode_block_update(sbi, ino))
 181                 ret = true;
 182         f2fs_put_page(i, 0);
 183         return ret;
 184 }
 185
 186 static void try_to_fix_pino(struct inode *inode)
 187 {
 188         struct f2fs_inode_info *fi = F2FS_I(inode);
 189         nid_t pino;
 190
 191         down_write(&fi->i_sem);
 192         if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
 193                         get_parent_ino(inode, &pino)) {
 194                 f2fs_i_pino_write(inode, pino);
 195                 file_got_pino(inode);
 196         }
 197         up_write(&fi->i_sem);
 198 }
 199
 200 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
 201                                                 int datasync, bool atomic)
 202 {
 203         struct inode *inode = file->f_mapping->host;
 204         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 205         nid_t ino = inode->i_ino;
 206         int ret = 0;
 207         enum cp_reason_type cp_reason = 0;
 208         struct writeback_control wbc = {
 209                 .sync_mode = WB_SYNC_ALL,
 210                 .nr_to_write = LONG_MAX,
 211                 .for_reclaim = 0,
 212         };
 213         unsigned int seq_id = 0;
 214
 215         if (unlikely(f2fs_readonly(inode->i_sb) ||
 216                                 is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
 217                 return 0;
 218
 219         trace_f2fs_sync_file_enter(inode);
 220
 221         if (S_ISDIR(inode->i_mode))
 222                 goto go_write;
 223
 224         /* if fdatasync is triggered, let's do in-place-update */
 225         if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
 226                 set_inode_flag(inode, FI_NEED_IPU);
 227         ret = file_write_and_wait_range(file, start, end);
 228         clear_inode_flag(inode, FI_NEED_IPU);
 229
 230         if (ret) {
 231                 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
 232                 return ret;
 233         }
 234
 235         /* if the inode is dirty, let's recover all the time */
 236         if (!f2fs_skip_inode_update(inode, datasync)) {
 237                 f2fs_write_inode(inode, NULL);
 238                 goto go_write;
 239         }
 240
 241         /*
 242          * if there is no written data, don't waste time to write recovery info.
 243          */
 244         if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
 245                         !f2fs_exist_written_data(sbi, ino, APPEND_INO)) {
 246
 247                 /* it may call write_inode just prior to fsync */
 248                 if (need_inode_page_update(sbi, ino))
 249                         goto go_write;
 250
 251                 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
 252                                 f2fs_exist_written_data(sbi, ino, UPDATE_INO))
 253                         goto flush_out;
 254                 goto out;
 255         }
 256 go_write:
 257         /*
 258          * Both of fdatasync() and fsync() are able to be recovered from
 259          * sudden-power-off.
 260          */
 261         down_read(&F2FS_I(inode)->i_sem);
 262         cp_reason = need_do_checkpoint(inode);
 263         up_read(&F2FS_I(inode)->i_sem);
 264
 265         if (cp_reason) {
 266                 /* all the dirty node pages should be flushed for POR */
 267                 ret = f2fs_sync_fs(inode->i_sb, 1);
 268
 269                 /*
 270                  * We've secured consistency through sync_fs. Following pino
 271                  * will be used only for fsynced inodes after checkpoint.
 272                  */
 273                 try_to_fix_pino(inode);
 274                 clear_inode_flag(inode, FI_APPEND_WRITE);
 275                 clear_inode_flag(inode, FI_UPDATE_WRITE);
 276                 goto out;
 277         }
 278 sync_nodes:
 279         atomic_inc(&sbi->wb_sync_req[NODE]);
 280         ret = f2fs_fsync_node_pages(sbi, inode, &wbc, atomic, &seq_id);
 281         atomic_dec(&sbi->wb_sync_req[NODE]);
 282         if (ret)
 283                 goto out;
 284
 285         /* if cp_error was enabled, we should avoid infinite loop */
 286         if (unlikely(f2fs_cp_error(sbi))) {
 287                 ret = -EIO;
 288                 goto out;
 289         }
 290
 291         if (f2fs_need_inode_block_update(sbi, ino)) {
 292                 f2fs_mark_inode_dirty_sync(inode, true);
 293                 f2fs_write_inode(inode, NULL);
 294                 goto sync_nodes;
 295         }
 296
 297         /*
 298          * If it's atomic_write, it's just fine to keep write ordering. So
 299          * here we don't need to wait for node write completion, since we use
 300          * node chain which serializes node blocks. If one of node writes are
 301          * reordered, we can see simply broken chain, resulting in stopping
 302          * roll-forward recovery. It means we'll recover all or none node blocks
 303          * given fsync mark.
 304          */
 305         if (!atomic) {
 306                 ret = f2fs_wait_on_node_pages_writeback(sbi, seq_id);
 307                 if (ret)
 308                         goto out;
 309         }
 310
 311         /* once recovery info is written, don't need to tack this */
 312         f2fs_remove_ino_entry(sbi, ino, APPEND_INO);
 313         clear_inode_flag(inode, FI_APPEND_WRITE);
 314 flush_out:
 315         if (!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER)
 316                 ret = f2fs_issue_flush(sbi, inode->i_ino);
 317         if (!ret) {
 318                 f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
 319                 clear_inode_flag(inode, FI_UPDATE_WRITE);
 320                 f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
 321         }
 322         f2fs_update_time(sbi, REQ_TIME);
 323 out:
 324         trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
 325         f2fs_trace_ios(NULL, 1);
 326         return ret;
 327 }
 328
 329 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 330 {
 331         if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
 332                 return -EIO;
 333         return f2fs_do_sync_file(file, start, end, datasync, false);
 334 }
 335
 336 static pgoff_t __get_first_dirty_index(struct address_space *mapping,
 337                                                 pgoff_t pgofs, int whence)
 338 {
 339         struct page *page;
 340         int nr_pages;
 341
 342         if (whence != SEEK_DATA)
 343                 return 0;
 344
 345         /* find first dirty page index */
 346         nr_pages = find_get_pages_tag(mapping, &pgofs, PAGECACHE_TAG_DIRTY,
 347                                       1, &page);
 348         if (!nr_pages)
 349                 return ULONG_MAX;
 350         pgofs = page->index;
 351         put_page(page);
 352         return pgofs;
 353 }
 354
 355 static bool __found_offset(struct f2fs_sb_info *sbi, block_t blkaddr,
 356                                 pgoff_t dirty, pgoff_t pgofs, int whence)
 357 {
 358         switch (whence) {
 359         case SEEK_DATA:
 360                 if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
 361                         __is_valid_data_blkaddr(blkaddr))
 362                         return true;
 363                 break;
 364         case SEEK_HOLE:
 365                 if (blkaddr == NULL_ADDR)
 366                         return true;
 367                 break;
 368         }
 369         return false;
 370 }
 371
 372 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
 373 {
 374         struct inode *inode = file->f_mapping->host;
 375         loff_t maxbytes = inode->i_sb->s_maxbytes;
 376         struct dnode_of_data dn;
 377         pgoff_t pgofs, end_offset, dirty;
 378         loff_t data_ofs = offset;
 379         loff_t isize;
 380         int err = 0;
 381
 382         inode_lock(inode);
 383
 384         isize = i_size_read(inode);
 385         if (offset >= isize)
 386                 goto fail;
 387
 388         /* handle inline data case */
 389         if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
 390                 if (whence == SEEK_HOLE)
 391                         data_ofs = isize;
 392                 goto found;
 393         }
 394
 395         pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
 396
 397         dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
 398
 399         for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
 400                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 401                 err = f2fs_get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
 402                 if (err && err != -ENOENT) {
 403                         goto fail;
 404                 } else if (err == -ENOENT) {
 405                         /* direct node does not exists */
 406                         if (whence == SEEK_DATA) {
 407                                 pgofs = f2fs_get_next_page_offset(&dn, pgofs);
 408                                 continue;
 409                         } else {
 410                                 goto found;
 411                         }
 412                 }
 413
 414                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
 415
 416                 /* find data/hole in dnode block */
 417                 for (; dn.ofs_in_node < end_offset;
 418                                 dn.ofs_in_node++, pgofs++,
 419                                 data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
 420                         block_t blkaddr;
 421
 422                         blkaddr = datablock_addr(dn.inode,
 423                                         dn.node_page, dn.ofs_in_node);
 424
 425                         if (__is_valid_data_blkaddr(blkaddr) &&
 426                                 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
 427                                         blkaddr, DATA_GENERIC_ENHANCE)) {
 428                                 f2fs_put_dnode(&dn);
 429                                 goto fail;
 430                         }
 431
 432                         if (__found_offset(F2FS_I_SB(inode), blkaddr, dirty,
 433                                                         pgofs, whence)) {
 434                                 f2fs_put_dnode(&dn);
 435                                 goto found;
 436                         }
 437                 }
 438                 f2fs_put_dnode(&dn);
 439         }
 440
 441         if (whence == SEEK_DATA)
 442                 goto fail;
 443 found:
 444         if (whence == SEEK_HOLE && data_ofs > isize)
 445                 data_ofs = isize;
 446         inode_unlock(inode);
 447         return vfs_setpos(file, data_ofs, maxbytes);
 448 fail:
 449         inode_unlock(inode);
 450         return -ENXIO;
 451 }
 452
 453 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
 454 {
 455         struct inode *inode = file->f_mapping->host;
 456         loff_t maxbytes = inode->i_sb->s_maxbytes;
 457
 458         switch (whence) {
 459         case SEEK_SET:
 460         case SEEK_CUR:
 461         case SEEK_END:
 462                 return generic_file_llseek_size(file, offset, whence,
 463                                                 maxbytes, i_size_read(inode));
 464         case SEEK_DATA:
 465         case SEEK_HOLE:
 466                 if (offset < 0)
 467                         return -ENXIO;
 468                 return f2fs_seek_block(file, offset, whence);
 469         }
 470
 471         return -EINVAL;
 472 }
 473
 474 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 475 {
 476         struct inode *inode = file_inode(file);
 477         int err;
 478
 479         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
 480                 return -EIO;
 481
 482         /* we don't need to use inline_data strictly */
 483         err = f2fs_convert_inline_inode(inode);
 484         if (err)
 485                 return err;
 486
 487         file_accessed(file);
 488         vma->vm_ops = &f2fs_file_vm_ops;
 489         return 0;
 490 }
 491
 492 static int f2fs_file_open(struct inode *inode, struct file *filp)
 493 {
 494         int err = fscrypt_file_open(inode, filp);
 495
 496         if (err)
 497                 return err;
 498
 499         err = fsverity_file_open(inode, filp);
 500         if (err)
 501                 return err;
 502
 503         filp->f_mode |= FMODE_NOWAIT;
 504
 505         return dquot_file_open(inode, filp);
 506 }
 507
 508 void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 509 {
 510         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 511         struct f2fs_node *raw_node;
 512         int nr_free = 0, ofs = dn->ofs_in_node, len = count;
 513         __le32 *addr;
 514         int base = 0;
 515
 516         if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
 517                 base = get_extra_isize(dn->inode);
 518
 519         raw_node = F2FS_NODE(dn->node_page);
 520         addr = blkaddr_in_node(raw_node) + base + ofs;
 521
 522         for (; count > 0; count--, addr++, dn->ofs_in_node++) {
 523                 block_t blkaddr = le32_to_cpu(*addr);
 524
 525                 if (blkaddr == NULL_ADDR)
 526                         continue;
 527
 528                 dn->data_blkaddr = NULL_ADDR;
 529                 f2fs_set_data_blkaddr(dn);
 530
 531                 if (__is_valid_data_blkaddr(blkaddr) &&
 532                         !f2fs_is_valid_blkaddr(sbi, blkaddr,
 533                                         DATA_GENERIC_ENHANCE))
 534                         continue;
 535
 536                 f2fs_invalidate_blocks(sbi, blkaddr);
 537                 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
 538                         clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
 539                 nr_free++;
 540         }
 541
 542         if (nr_free) {
 543                 pgoff_t fofs;
 544                 /*
 545                  * once we invalidate valid blkaddr in range [ofs, ofs + count],
 546                  * we will invalidate all blkaddr in the whole range.
 547                  */
 548                 fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page),
 549                                                         dn->inode) + ofs;
 550                 f2fs_update_extent_cache_range(dn, fofs, 0, len);
 551                 dec_valid_block_count(sbi, dn->inode, nr_free);
 552         }
 553         dn->ofs_in_node = ofs;
 554
 555         f2fs_update_time(sbi, REQ_TIME);
 556         trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
 557                                          dn->ofs_in_node, nr_free);
 558 }
 559
 560 void f2fs_truncate_data_blocks(struct dnode_of_data *dn)
 561 {
 562         f2fs_truncate_data_blocks_range(dn, ADDRS_PER_BLOCK(dn->inode));
 563 }
 564
 565 static int truncate_partial_data_page(struct inode *inode, u64 from,
 566                                                                 bool cache_only)
 567 {
 568         loff_t offset = from & (PAGE_SIZE - 1);
 569         pgoff_t index = from >> PAGE_SHIFT;
 570         struct address_space *mapping = inode->i_mapping;
 571         struct page *page;
 572
 573         if (!offset && !cache_only)
 574                 return 0;
 575
 576         if (cache_only) {
 577                 page = find_lock_page(mapping, index);
 578                 if (page && PageUptodate(page))
 579                         goto truncate_out;
 580                 f2fs_put_page(page, 1);
 581                 return 0;
 582         }
 583
 584         page = f2fs_get_lock_data_page(inode, index, true);
 585         if (IS_ERR(page))
 586                 return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
 587 truncate_out:
 588         f2fs_wait_on_page_writeback(page, DATA, true, true);
 589         zero_user(page, offset, PAGE_SIZE - offset);
 590
 591         /* An encrypted inode should have a key and truncate the last page. */
 592         f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode));
 593         if (!cache_only)
 594                 set_page_dirty(page);
 595         f2fs_put_page(page, 1);
 596         return 0;
 597 }
 598
 599 int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
 600 {
 601         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 602         struct dnode_of_data dn;
 603         pgoff_t free_from;
 604         int count = 0, err = 0;
 605         struct page *ipage;
 606         bool truncate_page = false;
 607
 608         trace_f2fs_truncate_blocks_enter(inode, from);
 609
 610         free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
 611
 612         if (free_from >= sbi->max_file_blocks)
 613                 goto free_partial;
 614
 615         if (lock)
 616                 f2fs_lock_op(sbi);
 617
 618         ipage = f2fs_get_node_page(sbi, inode->i_ino);
 619         if (IS_ERR(ipage)) {
 620                 err = PTR_ERR(ipage);
 621                 goto out;
 622         }
 623
 624         if (f2fs_has_inline_data(inode)) {
 625                 f2fs_truncate_inline_inode(inode, ipage, from);
 626                 f2fs_put_page(ipage, 1);
 627                 truncate_page = true;
 628                 goto out;
 629         }
 630
 631         set_new_dnode(&dn, inode, ipage, NULL, 0);
 632         err = f2fs_get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
 633         if (err) {
 634                 if (err == -ENOENT)
 635                         goto free_next;
 636                 goto out;
 637         }
 638
 639         count = ADDRS_PER_PAGE(dn.node_page, inode);
 640
 641         count -= dn.ofs_in_node;
 642         f2fs_bug_on(sbi, count < 0);
 643
 644         if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
 645                 f2fs_truncate_data_blocks_range(&dn, count);
 646                 free_from += count;
 647         }
 648
 649         f2fs_put_dnode(&dn);
 650 free_next:
 651         err = f2fs_truncate_inode_blocks(inode, free_from);
 652 out:
 653         if (lock)
 654                 f2fs_unlock_op(sbi);
 655 free_partial:
 656         /* lastly zero out the first data page */
 657         if (!err)
 658                 err = truncate_partial_data_page(inode, from, truncate_page);
 659
 660         trace_f2fs_truncate_blocks_exit(inode, err);
 661         return err;
 662 }
 663
 664 int f2fs_truncate(struct inode *inode)
 665 {
 666         int err;
 667
 668         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
 669                 return -EIO;
 670
 671         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 672                                 S_ISLNK(inode->i_mode)))
 673                 return 0;
 674
 675         trace_f2fs_truncate(inode);
 676
 677         if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
 678                 f2fs_show_injection_info(FAULT_TRUNCATE);
 679                 return -EIO;
 680         }
 681
 682         /* we should check inline_data size */
 683         if (!f2fs_may_inline_data(inode)) {
 684                 err = f2fs_convert_inline_inode(inode);
 685                 if (err)
 686                         return err;
 687         }
 688
 689         err = f2fs_truncate_blocks(inode, i_size_read(inode), true);
 690         if (err)
 691                 return err;
 692
 693         inode->i_mtime = inode->i_ctime = current_time(inode);
 694         f2fs_mark_inode_dirty_sync(inode, false);
 695         return 0;
 696 }
 697
 698 int f2fs_getattr(const struct path *path, struct kstat *stat,
 699                  u32 request_mask, unsigned int query_flags)
 700 {
 701         struct inode *inode = d_inode(path->dentry);
 702         struct f2fs_inode_info *fi = F2FS_I(inode);
 703         struct f2fs_inode *ri;
 704         unsigned int flags;
 705
 706         if (f2fs_has_extra_attr(inode) &&
 707                         f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
 708                         F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
 709                 stat->result_mask |= STATX_BTIME;
 710                 stat->btime.tv_sec = fi->i_crtime.tv_sec;
 711                 stat->btime.tv_nsec = fi->i_crtime.tv_nsec;
 712         }
 713
 714         flags = fi->i_flags;
 715         if (flags & F2FS_APPEND_FL)
 716                 stat->attributes |= STATX_ATTR_APPEND;
 717         if (IS_ENCRYPTED(inode))
 718                 stat->attributes |= STATX_ATTR_ENCRYPTED;
 719         if (flags & F2FS_IMMUTABLE_FL)
 720                 stat->attributes |= STATX_ATTR_IMMUTABLE;
 721         if (flags & F2FS_NODUMP_FL)
 722                 stat->attributes |= STATX_ATTR_NODUMP;
 723
 724         stat->attributes_mask |= (STATX_ATTR_APPEND |
 725                                   STATX_ATTR_ENCRYPTED |
 726                                   STATX_ATTR_IMMUTABLE |
 727                                   STATX_ATTR_NODUMP);
 728
 729         generic_fillattr(inode, stat);
 730
 731         /* we need to show initial sectors used for inline_data/dentries */
 732         if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) ||
 733                                         f2fs_has_inline_dentry(inode))
 734                 stat->blocks += (stat->size + 511) >> 9;
 735
 736         return 0;
 737 }
 738
 739 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 740 static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 741 {
 742         unsigned int ia_valid = attr->ia_valid;
 743
 744         if (ia_valid & ATTR_UID)
 745                 inode->i_uid = attr->ia_uid;
 746         if (ia_valid & ATTR_GID)
 747                 inode->i_gid = attr->ia_gid;
 748         if (ia_valid & ATTR_ATIME) {
 749                 inode->i_atime = timestamp_truncate(attr->ia_atime,
 750                                                   inode);
 751         }
 752         if (ia_valid & ATTR_MTIME) {
 753                 inode->i_mtime = timestamp_truncate(attr->ia_mtime,
 754                                                   inode);
 755         }
 756         if (ia_valid & ATTR_CTIME) {
 757                 inode->i_ctime = timestamp_truncate(attr->ia_ctime,
 758                                                   inode);
 759         }
 760         if (ia_valid & ATTR_MODE) {
 761                 umode_t mode = attr->ia_mode;
 762
 763                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
 764                         mode &= ~S_ISGID;
 765                 set_acl_inode(inode, mode);
 766         }
 767 }
 768 #else
 769 #define __setattr_copy setattr_copy
 770 #endif
 771
 772 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 773 {
 774         struct inode *inode = d_inode(dentry);
 775         int err;
 776
 777         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
 778                 return -EIO;
 779
 780         err = setattr_prepare(dentry, attr);
 781         if (err)
 782                 return err;
 783
 784         err = fscrypt_prepare_setattr(dentry, attr);
 785         if (err)
 786                 return err;
 787
 788         err = fsverity_prepare_setattr(dentry, attr);
 789         if (err)
 790                 return err;
 791
 792         if (is_quota_modification(inode, attr)) {
 793                 err = dquot_initialize(inode);
 794                 if (err)
 795                         return err;
 796         }
 797         if ((attr->ia_valid & ATTR_UID &&
 798                 !uid_eq(attr->ia_uid, inode->i_uid)) ||
 799                 (attr->ia_valid & ATTR_GID &&
 800                 !gid_eq(attr->ia_gid, inode->i_gid))) {
 801                 f2fs_lock_op(F2FS_I_SB(inode));
 802                 err = dquot_transfer(inode, attr);
 803                 if (err) {
 804                         set_sbi_flag(F2FS_I_SB(inode),
 805                                         SBI_QUOTA_NEED_REPAIR);
 806                         f2fs_unlock_op(F2FS_I_SB(inode));
 807                         return err;
 808                 }
 809                 /*
 810                  * update uid/gid under lock_op(), so that dquot and inode can
 811                  * be updated atomically.
 812                  */
 813                 if (attr->ia_valid & ATTR_UID)
 814                         inode->i_uid = attr->ia_uid;
 815                 if (attr->ia_valid & ATTR_GID)
 816                         inode->i_gid = attr->ia_gid;
 817                 f2fs_mark_inode_dirty_sync(inode, true);
 818                 f2fs_unlock_op(F2FS_I_SB(inode));
 819         }
 820
 821         if (attr->ia_valid & ATTR_SIZE) {
 822                 bool to_smaller = (attr->ia_size <= i_size_read(inode));
 823
 824                 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 825                 down_write(&F2FS_I(inode)->i_mmap_sem);
 826
 827                 truncate_setsize(inode, attr->ia_size);
 828
 829                 if (to_smaller)
 830                         err = f2fs_truncate(inode);
 831                 /*
 832                  * do not trim all blocks after i_size if target size is
 833                  * larger than i_size.
 834                  */
 835                 up_write(&F2FS_I(inode)->i_mmap_sem);
 836                 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 837
 838                 if (err)
 839                         return err;
 840
 841                 if (!to_smaller) {
 842                         /* should convert inline inode here */
 843                         if (!f2fs_may_inline_data(inode)) {
 844                                 err = f2fs_convert_inline_inode(inode);
 845                                 if (err)
 846                                         return err;
 847                         }
 848                         inode->i_mtime = inode->i_ctime = current_time(inode);
 849                 }
 850
 851                 down_write(&F2FS_I(inode)->i_sem);
 852                 F2FS_I(inode)->last_disk_size = i_size_read(inode);
 853                 up_write(&F2FS_I(inode)->i_sem);
 854         }
 855
 856         __setattr_copy(inode, attr);
 857
 858         if (attr->ia_valid & ATTR_MODE) {
 859                 err = posix_acl_chmod(inode, f2fs_get_inode_mode(inode));
 860                 if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
 861                         inode->i_mode = F2FS_I(inode)->i_acl_mode;
 862                         clear_inode_flag(inode, FI_ACL_MODE);
 863                 }
 864         }
 865
 866         /* file size may changed here */
 867         f2fs_mark_inode_dirty_sync(inode, true);
 868
 869         /* inode change will produce dirty node pages flushed by checkpoint */
 870         f2fs_balance_fs(F2FS_I_SB(inode), true);
 871
 872         return err;
 873 }
 874
 875 const struct inode_operations f2fs_file_inode_operations = {
 876         .getattr        = f2fs_getattr,
 877         .setattr        = f2fs_setattr,
 878         .get_acl        = f2fs_get_acl,
 879         .set_acl        = f2fs_set_acl,
 880 #ifdef CONFIG_F2FS_FS_XATTR
 881         .listxattr      = f2fs_listxattr,
 882 #endif
 883         .fiemap         = f2fs_fiemap,
 884 };
 885
 886 static int fill_zero(struct inode *inode, pgoff_t index,
 887                                         loff_t start, loff_t len)
 888 {
 889         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 890         struct page *page;
 891
 892         if (!len)
 893                 return 0;
 894
 895         f2fs_balance_fs(sbi, true);
 896
 897         f2fs_lock_op(sbi);
 898         page = f2fs_get_new_data_page(inode, NULL, index, false);
 899         f2fs_unlock_op(sbi);
 900
 901         if (IS_ERR(page))
 902                 return PTR_ERR(page);
 903
 904         f2fs_wait_on_page_writeback(page, DATA, true, true);
 905         zero_user(page, start, len);
 906         set_page_dirty(page);
 907         f2fs_put_page(page, 1);
 908         return 0;
 909 }
 910
 911 int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
 912 {
 913         int err;
 914
 915         while (pg_start < pg_end) {
 916                 struct dnode_of_data dn;
 917                 pgoff_t end_offset, count;
 918
 919                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 920                 err = f2fs_get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
 921                 if (err) {
 922                         if (err == -ENOENT) {
 923                                 pg_start = f2fs_get_next_page_offset(&dn,
 924                                                                 pg_start);
 925                                 continue;
 926                         }
 927                         return err;
 928                 }
 929
 930                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
 931                 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
 932
 933                 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
 934
 935                 f2fs_truncate_data_blocks_range(&dn, count);
 936                 f2fs_put_dnode(&dn);
 937
 938                 pg_start += count;
 939         }
 940         return 0;
 941 }
 942
 943 static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
 944 {
 945         pgoff_t pg_start, pg_end;
 946         loff_t off_start, off_end;
 947         int ret;
 948
 949         ret = f2fs_convert_inline_inode(inode);
 950         if (ret)
 951                 return ret;
 952
 953         pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
 954         pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
 955
 956         off_start = offset & (PAGE_SIZE - 1);
 957         off_end = (offset + len) & (PAGE_SIZE - 1);
 958
 959         if (pg_start == pg_end) {
 960                 ret = fill_zero(inode, pg_start, off_start,
 961                                                 off_end - off_start);
 962                 if (ret)
 963                         return ret;
 964         } else {
 965                 if (off_start) {
 966                         ret = fill_zero(inode, pg_start++, off_start,
 967                                                 PAGE_SIZE - off_start);
 968                         if (ret)
 969                                 return ret;
 970                 }
 971                 if (off_end) {
 972                         ret = fill_zero(inode, pg_end, 0, off_end);
 973                         if (ret)
 974                                 return ret;
 975                 }
 976
 977                 if (pg_start < pg_end) {
 978                         struct address_space *mapping = inode->i_mapping;
 979                         loff_t blk_start, blk_end;
 980                         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 981
 982                         f2fs_balance_fs(sbi, true);
 983
 984                         blk_start = (loff_t)pg_start << PAGE_SHIFT;
 985                         blk_end = (loff_t)pg_end << PAGE_SHIFT;
 986
 987                         down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 988                         down_write(&F2FS_I(inode)->i_mmap_sem);
 989
 990                         truncate_inode_pages_range(mapping, blk_start,
 991                                         blk_end - 1);
 992
 993                         f2fs_lock_op(sbi);
 994                         ret = f2fs_truncate_hole(inode, pg_start, pg_end);
 995                         f2fs_unlock_op(sbi);
 996
 997                         up_write(&F2FS_I(inode)->i_mmap_sem);
 998                         up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 999                 }
1000         }
1001
1002         return ret;
1003 }
1004
1005 static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
1006                                 int *do_replace, pgoff_t off, pgoff_t len)
1007 {
1008         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1009         struct dnode_of_data dn;
1010         int ret, done, i;
1011
1012 next_dnode:
1013         set_new_dnode(&dn, inode, NULL, NULL, 0);
1014         ret = f2fs_get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
1015         if (ret && ret != -ENOENT) {
1016                 return ret;
1017         } else if (ret == -ENOENT) {
1018                 if (dn.max_level == 0)
1019                         return -ENOENT;
1020                 done = min((pgoff_t)ADDRS_PER_BLOCK(inode) - dn.ofs_in_node,
1021                                                                         len);
1022                 blkaddr += done;
1023                 do_replace += done;
1024                 goto next;
1025         }
1026
1027         done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
1028                                                         dn.ofs_in_node, len);
1029         for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
1030                 *blkaddr = datablock_addr(dn.inode,
1031                                         dn.node_page, dn.ofs_in_node);
1032
1033                 if (__is_valid_data_blkaddr(*blkaddr) &&
1034                         !f2fs_is_valid_blkaddr(sbi, *blkaddr,
1035                                         DATA_GENERIC_ENHANCE)) {
1036                         f2fs_put_dnode(&dn);
1037                         return -EFSCORRUPTED;
1038                 }
1039
1040                 if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) {
1041
1042                         if (test_opt(sbi, LFS)) {
1043                                 f2fs_put_dnode(&dn);
1044                                 return -ENOTSUPP;
1045                         }
1046
1047                         /* do not invalidate this block address */
1048                         f2fs_update_data_blkaddr(&dn, NULL_ADDR);
1049                         *do_replace = 1;
1050                 }
1051         }
1052         f2fs_put_dnode(&dn);
1053 next:
1054         len -= done;
1055         off += done;
1056         if (len)
1057                 goto next_dnode;
1058         return 0;
1059 }
1060
1061 static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
1062                                 int *do_replace, pgoff_t off, int len)
1063 {
1064         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1065         struct dnode_of_data dn;
1066         int ret, i;
1067
1068         for (i = 0; i < len; i++, do_replace++, blkaddr++) {
1069                 if (*do_replace == 0)
1070                         continue;
1071
1072                 set_new_dnode(&dn, inode, NULL, NULL, 0);
1073                 ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
1074                 if (ret) {
1075                         dec_valid_block_count(sbi, inode, 1);
1076                         f2fs_invalidate_blocks(sbi, *blkaddr);
1077                 } else {
1078                         f2fs_update_data_blkaddr(&dn, *blkaddr);
1079                 }
1080                 f2fs_put_dnode(&dn);
1081         }
1082         return 0;
1083 }
1084
1085 static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
1086                         block_t *blkaddr, int *do_replace,
1087                         pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
1088 {
1089         struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
1090         pgoff_t i = 0;
1091         int ret;
1092
1093         while (i < len) {
1094                 if (blkaddr[i] == NULL_ADDR && !full) {
1095                         i++;
1096                         continue;
1097                 }
1098
1099                 if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
1100                         struct dnode_of_data dn;
1101                         struct node_info ni;
1102                         size_t new_size;
1103                         pgoff_t ilen;
1104
1105                         set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
1106                         ret = f2fs_get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
1107                         if (ret)
1108                                 return ret;
1109
1110                         ret = f2fs_get_node_info(sbi, dn.nid, &ni);
1111                         if (ret) {
1112                                 f2fs_put_dnode(&dn);
1113                                 return ret;
1114                         }
1115
1116                         ilen = min((pgoff_t)
1117                                 ADDRS_PER_PAGE(dn.node_page, dst_inode) -
1118                                                 dn.ofs_in_node, len - i);
1119                         do {
1120                                 dn.data_blkaddr = datablock_addr(dn.inode,
1121                                                 dn.node_page, dn.ofs_in_node);
1122                                 f2fs_truncate_data_blocks_range(&dn, 1);
1123
1124                                 if (do_replace[i]) {
1125                                         f2fs_i_blocks_write(src_inode,
1126                                                         1, false, false);
1127                                         f2fs_i_blocks_write(dst_inode,
1128                                                         1, true, false);
1129                                         f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
1130                                         blkaddr[i], ni.version, true, false);
1131
1132                                         do_replace[i] = 0;
1133                                 }
1134                                 dn.ofs_in_node++;
1135                                 i++;
1136                                 new_size = (dst + i) << PAGE_SHIFT;
1137                                 if (dst_inode->i_size < new_size)
1138                                         f2fs_i_size_write(dst_inode, new_size);
1139                         } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));
1140
1141                         f2fs_put_dnode(&dn);
1142                 } else {
1143                         struct page *psrc, *pdst;
1144
1145                         psrc = f2fs_get_lock_data_page(src_inode,
1146                                                         src + i, true);
1147                         if (IS_ERR(psrc))
1148                                 return PTR_ERR(psrc);
1149                         pdst = f2fs_get_new_data_page(dst_inode, NULL, dst + i,
1150                                                                 true);
1151                         if (IS_ERR(pdst)) {
1152                                 f2fs_put_page(psrc, 1);
1153                                 return PTR_ERR(pdst);
1154                         }
1155                         f2fs_copy_page(psrc, pdst);
1156                         set_page_dirty(pdst);
1157                         f2fs_put_page(pdst, 1);
1158                         f2fs_put_page(psrc, 1);
1159
1160                         ret = f2fs_truncate_hole(src_inode,
1161                                                 src + i, src + i + 1);
1162                         if (ret)
1163                                 return ret;
1164                         i++;
1165                 }
1166         }
1167         return 0;
1168 }
1169
1170 static int __exchange_data_block(struct inode *src_inode,
1171                         struct inode *dst_inode, pgoff_t src, pgoff_t dst,
1172                         pgoff_t len, bool full)
1173 {
1174         block_t *src_blkaddr;
1175         int *do_replace;
1176         pgoff_t olen;
1177         int ret;
1178
1179         while (len) {
1180                 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK(src_inode), len);
1181
1182                 src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode),
1183                                         array_size(olen, sizeof(block_t)),
1184                                         GFP_KERNEL);
1185                 if (!src_blkaddr)
1186                         return -ENOMEM;
1187
1188                 do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode),
1189                                         array_size(olen, sizeof(int)),
1190                                         GFP_KERNEL);
1191                 if (!do_replace) {
1192                         kvfree(src_blkaddr);
1193                         return -ENOMEM;
1194                 }
1195
1196                 ret = __read_out_blkaddrs(src_inode, src_blkaddr,
1197                                         do_replace, src, olen);
1198                 if (ret)
1199                         goto roll_back;
1200
1201                 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
1202                                         do_replace, src, dst, olen, full);
1203                 if (ret)
1204                         goto roll_back;
1205
1206                 src += olen;
1207                 dst += olen;
1208                 len -= olen;
1209
1210                 kvfree(src_blkaddr);
1211                 kvfree(do_replace);
1212         }
1213         return 0;
1214
1215 roll_back:
1216         __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, olen);
1217         kvfree(src_blkaddr);
1218         kvfree(do_replace);
1219         return ret;
1220 }
1221
1222 static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
1223 {
1224         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1225         pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1226         pgoff_t start = offset >> PAGE_SHIFT;
1227         pgoff_t end = (offset + len) >> PAGE_SHIFT;
1228         int ret;
1229
1230         f2fs_balance_fs(sbi, true);
1231
1232         /* avoid gc operation during block exchange */
1233         down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1234         down_write(&F2FS_I(inode)->i_mmap_sem);
1235
1236         f2fs_lock_op(sbi);
1237         f2fs_drop_extent_tree(inode);
1238         truncate_pagecache(inode, offset);
1239         ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1240         f2fs_unlock_op(sbi);
1241
1242         up_write(&F2FS_I(inode)->i_mmap_sem);
1243         up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1244         return ret;
1245 }
1246
1247 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1248 {
1249         loff_t new_size;
1250         int ret;
1251
1252         if (offset + len >= i_size_read(inode))
1253                 return -EINVAL;
1254
1255         /* collapse range should be aligned to block size of f2fs. */
1256         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1257                 return -EINVAL;
1258
1259         ret = f2fs_convert_inline_inode(inode);
1260         if (ret)
1261                 return ret;
1262
1263         /* write out all dirty pages from offset */
1264         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1265         if (ret)
1266                 return ret;
1267
1268         ret = f2fs_do_collapse(inode, offset, len);
1269         if (ret)
1270                 return ret;
1271
1272         /* write out all moved pages, if possible */
1273         down_write(&F2FS_I(inode)->i_mmap_sem);
1274         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1275         truncate_pagecache(inode, offset);
1276
1277         new_size = i_size_read(inode) - len;
1278         truncate_pagecache(inode, new_size);
1279
1280         ret = f2fs_truncate_blocks(inode, new_size, true);
1281         up_write(&F2FS_I(inode)->i_mmap_sem);
1282         if (!ret)
1283                 f2fs_i_size_write(inode, new_size);
1284         return ret;
1285 }
1286
1287 static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
1288                                                                 pgoff_t end)
1289 {
1290         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
1291         pgoff_t index = start;
1292         unsigned int ofs_in_node = dn->ofs_in_node;
1293         blkcnt_t count = 0;
1294         int ret;
1295
1296         for (; index < end; index++, dn->ofs_in_node++) {
1297                 if (datablock_addr(dn->inode, dn->node_page,
1298                                         dn->ofs_in_node) == NULL_ADDR)
1299                         count++;
1300         }
1301
1302         dn->ofs_in_node = ofs_in_node;
1303         ret = f2fs_reserve_new_blocks(dn, count);
1304         if (ret)
1305                 return ret;
1306
1307         dn->ofs_in_node = ofs_in_node;
1308         for (index = start; index < end; index++, dn->ofs_in_node++) {
1309                 dn->data_blkaddr = datablock_addr(dn->inode,
1310                                         dn->node_page, dn->ofs_in_node);
1311                 /*
1312                  * f2fs_reserve_new_blocks will not guarantee entire block
1313                  * allocation.
1314                  */
1315                 if (dn->data_blkaddr == NULL_ADDR) {
1316                         ret = -ENOSPC;
1317                         break;
1318                 }
1319                 if (dn->data_blkaddr != NEW_ADDR) {
1320                         f2fs_invalidate_blocks(sbi, dn->data_blkaddr);
1321                         dn->data_blkaddr = NEW_ADDR;
1322                         f2fs_set_data_blkaddr(dn);
1323                 }
1324         }
1325
1326         f2fs_update_extent_cache_range(dn, start, 0, index - start);
1327
1328         return ret;
1329 }
1330
1331 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
1332                                                                 int mode)
1333 {
1334         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1335         struct address_space *mapping = inode->i_mapping;
1336         pgoff_t index, pg_start, pg_end;
1337         loff_t new_size = i_size_read(inode);
1338         loff_t off_start, off_end;
1339         int ret = 0;
1340
1341         ret = inode_newsize_ok(inode, (len + offset));
1342         if (ret)
1343                 return ret;
1344
1345         ret = f2fs_convert_inline_inode(inode);
1346         if (ret)
1347                 return ret;
1348
1349         ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
1350         if (ret)
1351                 return ret;
1352
1353         pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1354         pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1355
1356         off_start = offset & (PAGE_SIZE - 1);
1357         off_end = (offset + len) & (PAGE_SIZE - 1);
1358
1359         if (pg_start == pg_end) {
1360                 ret = fill_zero(inode, pg_start, off_start,
1361                                                 off_end - off_start);
1362                 if (ret)
1363                         return ret;
1364
1365                 new_size = max_t(loff_t, new_size, offset + len);
1366         } else {
1367                 if (off_start) {
1368                         ret = fill_zero(inode, pg_start++, off_start,
1369                                                 PAGE_SIZE - off_start);
1370                         if (ret)
1371                                 return ret;
1372
1373                         new_size = max_t(loff_t, new_size,
1374                                         (loff_t)pg_start << PAGE_SHIFT);
1375                 }
1376
1377                 for (index = pg_start; index < pg_end;) {
1378                         struct dnode_of_data dn;
1379                         unsigned int end_offset;
1380                         pgoff_t end;
1381
1382                         down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1383                         down_write(&F2FS_I(inode)->i_mmap_sem);
1384
1385                         truncate_pagecache_range(inode,
1386                                 (loff_t)index << PAGE_SHIFT,
1387                                 ((loff_t)pg_end << PAGE_SHIFT) - 1);
1388
1389                         f2fs_lock_op(sbi);
1390
1391                         set_new_dnode(&dn, inode, NULL, NULL, 0);
1392                         ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
1393                         if (ret) {
1394                                 f2fs_unlock_op(sbi);
1395                                 up_write(&F2FS_I(inode)->i_mmap_sem);
1396                                 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1397                                 goto out;
1398                         }
1399
1400                         end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1401                         end = min(pg_end, end_offset - dn.ofs_in_node + index);
1402
1403                         ret = f2fs_do_zero_range(&dn, index, end);
1404                         f2fs_put_dnode(&dn);
1405
1406                         f2fs_unlock_op(sbi);
1407                         up_write(&F2FS_I(inode)->i_mmap_sem);
1408                         up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1409
1410                         f2fs_balance_fs(sbi, dn.node_changed);
1411
1412                         if (ret)
1413                                 goto out;
1414
1415                         index = end;
1416                         new_size = max_t(loff_t, new_size,
1417                                         (loff_t)index << PAGE_SHIFT);
1418                 }
1419
1420                 if (off_end) {
1421                         ret = fill_zero(inode, pg_end, 0, off_end);
1422                         if (ret)
1423                                 goto out;
1424
1425                         new_size = max_t(loff_t, new_size, offset + len);
1426                 }
1427         }
1428
1429 out:
1430         if (new_size > i_size_read(inode)) {
1431                 if (mode & FALLOC_FL_KEEP_SIZE)
1432                         file_set_keep_isize(inode);
1433                 else
1434                         f2fs_i_size_write(inode, new_size);
1435         }
1436         return ret;
1437 }
1438
1439 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1440 {
1441         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1442         pgoff_t nr, pg_start, pg_end, delta, idx;
1443         loff_t new_size;
1444         int ret = 0;
1445
1446         new_size = i_size_read(inode) + len;
1447         ret = inode_newsize_ok(inode, new_size);
1448         if (ret)
1449                 return ret;
1450
1451         if (offset >= i_size_read(inode))
1452                 return -EINVAL;
1453
1454         /* insert range should be aligned to block size of f2fs. */
1455         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1456                 return -EINVAL;
1457
1458         ret = f2fs_convert_inline_inode(inode);
1459         if (ret)
1460                 return ret;
1461
1462         f2fs_balance_fs(sbi, true);
1463
1464         down_write(&F2FS_I(inode)->i_mmap_sem);
1465         ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);
1466         up_write(&F2FS_I(inode)->i_mmap_sem);
1467         if (ret)
1468                 return ret;
1469
1470         /* write out all dirty pages from offset */
1471         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1472         if (ret)
1473                 return ret;
1474
1475         pg_start = offset >> PAGE_SHIFT;
1476         pg_end = (offset + len) >> PAGE_SHIFT;
1477         delta = pg_end - pg_start;
1478         idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1479
1480         /* avoid gc operation during block exchange */
1481         down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1482         down_write(&F2FS_I(inode)->i_mmap_sem);
1483         truncate_pagecache(inode, offset);
1484
1485         while (!ret && idx > pg_start) {
1486                 nr = idx - pg_start;
1487                 if (nr > delta)
1488                         nr = delta;
1489                 idx -= nr;
1490
1491                 f2fs_lock_op(sbi);
1492                 f2fs_drop_extent_tree(inode);
1493
1494                 ret = __exchange_data_block(inode, inode, idx,
1495                                         idx + delta, nr, false);
1496                 f2fs_unlock_op(sbi);
1497         }
1498         up_write(&F2FS_I(inode)->i_mmap_sem);
1499         up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1500
1501         /* write out all moved pages, if possible */
1502         down_write(&F2FS_I(inode)->i_mmap_sem);
1503         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1504         truncate_pagecache(inode, offset);
1505         up_write(&F2FS_I(inode)->i_mmap_sem);
1506
1507         if (!ret)
1508                 f2fs_i_size_write(inode, new_size);
1509         return ret;
1510 }
1511
1512 static int expand_inode_data(struct inode *inode, loff_t offset,
1513                                         loff_t len, int mode)
1514 {
1515         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1516         struct f2fs_map_blocks map = { .m_next_pgofs = NULL,
1517                         .m_next_extent = NULL, .m_seg_type = NO_CHECK_TYPE,
1518                         .m_may_create = true };
1519         pgoff_t pg_end;
1520         loff_t new_size = i_size_read(inode);
1521         loff_t off_end;
1522         int err;
1523
1524         err = inode_newsize_ok(inode, (len + offset));
1525         if (err)
1526                 return err;
1527
1528         err = f2fs_convert_inline_inode(inode);
1529         if (err)
1530                 return err;
1531
1532         f2fs_balance_fs(sbi, true);
1533
1534         pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
1535         off_end = (offset + len) & (PAGE_SIZE - 1);
1536
1537         map.m_lblk = ((unsigned long long)offset) >> PAGE_SHIFT;
1538         map.m_len = pg_end - map.m_lblk;
1539         if (off_end)
1540                 map.m_len++;
1541
1542         if (f2fs_is_pinned_file(inode))
1543                 map.m_seg_type = CURSEG_COLD_DATA;
1544
1545         err = f2fs_map_blocks(inode, &map, 1, (f2fs_is_pinned_file(inode) ?
1546                                                 F2FS_GET_BLOCK_PRE_DIO :
1547                                                 F2FS_GET_BLOCK_PRE_AIO));
1548         if (err) {
1549                 pgoff_t last_off;
1550
1551                 if (!map.m_len)
1552                         return err;
1553
1554                 last_off = map.m_lblk + map.m_len - 1;
1555
1556                 /* update new size to the failed position */
1557                 new_size = (last_off == pg_end) ? offset + len :
1558                                         (loff_t)(last_off + 1) << PAGE_SHIFT;
1559         } else {
1560                 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
1561         }
1562
1563         if (new_size > i_size_read(inode)) {
1564                 if (mode & FALLOC_FL_KEEP_SIZE)
1565                         file_set_keep_isize(inode);
1566                 else
1567                         f2fs_i_size_write(inode, new_size);
1568         }
1569
1570         return err;
1571 }
1572
1573 static long f2fs_fallocate(struct file *file, int mode,
1574                                 loff_t offset, loff_t len)
1575 {
1576         struct inode *inode = file_inode(file);
1577         long ret = 0;
1578
1579         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
1580                 return -EIO;
1581
1582         /* f2fs only support ->fallocate for regular file */
1583         if (!S_ISREG(inode->i_mode))
1584                 return -EINVAL;
1585
1586         if (IS_ENCRYPTED(inode) &&
1587                 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
1588                 return -EOPNOTSUPP;
1589
1590         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1591                         FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
1592                         FALLOC_FL_INSERT_RANGE))
1593                 return -EOPNOTSUPP;
1594
1595         inode_lock(inode);
1596
1597         if (mode & FALLOC_FL_PUNCH_HOLE) {
1598                 if (offset >= inode->i_size)
1599                         goto out;
1600
1601                 ret = punch_hole(inode, offset, len);
1602         } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1603                 ret = f2fs_collapse_range(inode, offset, len);
1604         } else if (mode & FALLOC_FL_ZERO_RANGE) {
1605                 ret = f2fs_zero_range(inode, offset, len, mode);
1606         } else if (mode & FALLOC_FL_INSERT_RANGE) {
1607                 ret = f2fs_insert_range(inode, offset, len);
1608         } else {
1609                 ret = expand_inode_data(inode, offset, len, mode);
1610         }
1611
1612         if (!ret) {
1613                 inode->i_mtime = inode->i_ctime = current_time(inode);
1614                 f2fs_mark_inode_dirty_sync(inode, false);
1615                 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1616         }
1617
1618 out:
1619         inode_unlock(inode);
1620
1621         trace_f2fs_fallocate(inode, mode, offset, len, ret);
1622         return ret;
1623 }
1624
1625 static int f2fs_release_file(struct inode *inode, struct file *filp)
1626 {
1627         /*
1628          * f2fs_relase_file is called at every close calls. So we should
1629          * not drop any inmemory pages by close called by other process.
1630          */
1631         if (!(filp->f_mode & FMODE_WRITE) ||
1632                         atomic_read(&inode->i_writecount) != 1)
1633                 return 0;
1634
1635         /* some remained atomic pages should discarded */
1636         if (f2fs_is_atomic_file(inode))
1637                 f2fs_drop_inmem_pages(inode);
1638         if (f2fs_is_volatile_file(inode)) {
1639                 set_inode_flag(inode, FI_DROP_CACHE);
1640                 filemap_fdatawrite(inode->i_mapping);
1641                 clear_inode_flag(inode, FI_DROP_CACHE);
1642                 clear_inode_flag(inode, FI_VOLATILE_FILE);
1643                 stat_dec_volatile_write(inode);
1644         }
1645         return 0;
1646 }
1647
1648 static int f2fs_file_flush(struct file *file, fl_owner_t id)
1649 {
1650         struct inode *inode = file_inode(file);
1651
1652         /*
1653          * If the process doing a transaction is crashed, we should do
1654          * roll-back. Otherwise, other reader/write can see corrupted database
1655          * until all the writers close its file. Since this should be done
1656          * before dropping file lock, it needs to do in ->flush.
1657          */
1658         if (f2fs_is_atomic_file(inode) &&
1659                         F2FS_I(inode)->inmem_task == current)
1660                 f2fs_drop_inmem_pages(inode);
1661         return 0;
1662 }
1663
1664 static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)
1665 {
1666         struct f2fs_inode_info *fi = F2FS_I(inode);
1667
1668         /* Is it quota file? Do not allow user to mess with it */
1669         if (IS_NOQUOTA(inode))
1670                 return -EPERM;
1671
1672         fi->i_flags = iflags | (fi->i_flags & ~mask);
1673
1674         if (fi->i_flags & F2FS_PROJINHERIT_FL)
1675                 set_inode_flag(inode, FI_PROJ_INHERIT);
1676         else
1677                 clear_inode_flag(inode, FI_PROJ_INHERIT);
1678
1679         inode->i_ctime = current_time(inode);
1680         f2fs_set_inode_flags(inode);
1681         f2fs_mark_inode_dirty_sync(inode, true);
1682         return 0;
1683 }
1684
1685 /* FS_IOC_GETFLAGS and FS_IOC_SETFLAGS support */
1686
1687 /*
1688  * To make a new on-disk f2fs i_flag gettable via FS_IOC_GETFLAGS, add an entry
1689  * for it to f2fs_fsflags_map[], and add its FS_*_FL equivalent to
1690  * F2FS_GETTABLE_FS_FL.  To also make it settable via FS_IOC_SETFLAGS, also add
1691  * its FS_*_FL equivalent to F2FS_SETTABLE_FS_FL.
1692  */
1693
1694 static const struct {
1695         u32 iflag;
1696         u32 fsflag;
1697 } f2fs_fsflags_map[] = {
1698         { F2FS_SYNC_FL,         FS_SYNC_FL },
1699         { F2FS_IMMUTABLE_FL,    FS_IMMUTABLE_FL },
1700         { F2FS_APPEND_FL,       FS_APPEND_FL },
1701         { F2FS_NODUMP_FL,       FS_NODUMP_FL },
1702         { F2FS_NOATIME_FL,      FS_NOATIME_FL },
1703         { F2FS_INDEX_FL,        FS_INDEX_FL },
1704         { F2FS_DIRSYNC_FL,      FS_DIRSYNC_FL },
1705         { F2FS_PROJINHERIT_FL,  FS_PROJINHERIT_FL },
1706 };
1707
1708 #define F2FS_GETTABLE_FS_FL (           \
1709                 FS_SYNC_FL |            \
1710                 FS_IMMUTABLE_FL |       \
1711                 FS_APPEND_FL |          \
1712                 FS_NODUMP_FL |          \
1713                 FS_NOATIME_FL |         \
1714                 FS_INDEX_FL |           \
1715                 FS_DIRSYNC_FL |         \
1716                 FS_PROJINHERIT_FL |     \
1717                 FS_ENCRYPT_FL |         \
1718                 FS_INLINE_DATA_FL |     \
1719                 FS_NOCOW_FL |           \
1720                 FS_VERITY_FL)
1721
1722 #define F2FS_SETTABLE_FS_FL (           \
1723                 FS_SYNC_FL |            \
1724                 FS_IMMUTABLE_FL |       \
1725                 FS_APPEND_FL |          \
1726                 FS_NODUMP_FL |          \
1727                 FS_NOATIME_FL |         \
1728                 FS_DIRSYNC_FL |         \
1729                 FS_PROJINHERIT_FL)
1730
1731 /* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
1732 static inline u32 f2fs_iflags_to_fsflags(u32 iflags)
1733 {
1734         u32 fsflags = 0;
1735         int i;
1736
1737         for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
1738                 if (iflags & f2fs_fsflags_map[i].iflag)
1739                         fsflags |= f2fs_fsflags_map[i].fsflag;
1740
1741         return fsflags;
1742 }
1743
1744 /* Convert FS_IOC_{GET,SET}FLAGS flags to f2fs on-disk i_flags */
1745 static inline u32 f2fs_fsflags_to_iflags(u32 fsflags)
1746 {
1747         u32 iflags = 0;
1748         int i;
1749
1750         for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
1751                 if (fsflags & f2fs_fsflags_map[i].fsflag)
1752                         iflags |= f2fs_fsflags_map[i].iflag;
1753
1754         return iflags;
1755 }
1756
1757 static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
1758 {
1759         struct inode *inode = file_inode(filp);
1760         struct f2fs_inode_info *fi = F2FS_I(inode);
1761         u32 fsflags = f2fs_iflags_to_fsflags(fi->i_flags);
1762
1763         if (IS_ENCRYPTED(inode))
1764                 fsflags |= FS_ENCRYPT_FL;
1765         if (IS_VERITY(inode))
1766                 fsflags |= FS_VERITY_FL;
1767         if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode))
1768                 fsflags |= FS_INLINE_DATA_FL;
1769         if (is_inode_flag_set(inode, FI_PIN_FILE))
1770                 fsflags |= FS_NOCOW_FL;
1771
1772         fsflags &= F2FS_GETTABLE_FS_FL;
1773
1774         return put_user(fsflags, (int __user *)arg);
1775 }
1776
1777 static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1778 {
1779         struct inode *inode = file_inode(filp);
1780         struct f2fs_inode_info *fi = F2FS_I(inode);
1781         u32 fsflags, old_fsflags;
1782         u32 iflags;
1783         int ret;
1784
1785         if (!inode_owner_or_capable(inode))
1786                 return -EACCES;
1787
1788         if (get_user(fsflags, (int __user *)arg))
1789                 return -EFAULT;
1790
1791         if (fsflags & ~F2FS_GETTABLE_FS_FL)
1792                 return -EOPNOTSUPP;
1793         fsflags &= F2FS_SETTABLE_FS_FL;
1794
1795         iflags = f2fs_fsflags_to_iflags(fsflags);
1796         if (f2fs_mask_flags(inode->i_mode, iflags) != iflags)
1797                 return -EOPNOTSUPP;
1798
1799         ret = mnt_want_write_file(filp);
1800         if (ret)
1801                 return ret;
1802
1803         inode_lock(inode);
1804
1805         old_fsflags = f2fs_iflags_to_fsflags(fi->i_flags);
1806         ret = vfs_ioc_setflags_prepare(inode, old_fsflags, fsflags);
1807         if (ret)
1808                 goto out;
1809
1810         ret = f2fs_setflags_common(inode, iflags,
1811                         f2fs_fsflags_to_iflags(F2FS_SETTABLE_FS_FL));
1812 out:
1813         inode_unlock(inode);
1814         mnt_drop_write_file(filp);
1815         return ret;
1816 }
1817
1818 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
1819 {
1820         struct inode *inode = file_inode(filp);
1821
1822         return put_user(inode->i_generation, (int __user *)arg);
1823 }
1824
1825 static int f2fs_ioc_start_atomic_write(struct file *filp)
1826 {
1827         struct inode *inode = file_inode(filp);
1828         int ret;
1829
1830         if (!inode_owner_or_capable(inode))
1831                 return -EACCES;
1832
1833         if (!S_ISREG(inode->i_mode))
1834                 return -EINVAL;
1835
1836         ret = mnt_want_write_file(filp);
1837         if (ret)
1838                 return ret;
1839
1840         inode_lock(inode);
1841
1842         if (f2fs_is_atomic_file(inode)) {
1843                 if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST))
1844                         ret = -EINVAL;
1845                 goto out;
1846         }
1847
1848         ret = f2fs_convert_inline_inode(inode);
1849         if (ret)
1850                 goto out;
1851
1852         down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1853
1854         /*
1855          * Should wait end_io to count F2FS_WB_CP_DATA correctly by
1856          * f2fs_is_atomic_file.
1857          */
1858         if (get_dirty_pages(inode))
1859                 f2fs_warn(F2FS_I_SB(inode), "Unexpected flush for atomic writes: ino=%lu, npages=%u",
1860                           inode->i_ino, get_dirty_pages(inode));
1861         ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
1862         if (ret) {
1863                 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1864                 goto out;
1865         }
1866
1867         set_inode_flag(inode, FI_ATOMIC_FILE);
1868         clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
1869         up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1870
1871         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1872         F2FS_I(inode)->inmem_task = current;
1873         stat_inc_atomic_write(inode);
1874         stat_update_max_atomic_write(inode);
1875 out:
1876         inode_unlock(inode);
1877         mnt_drop_write_file(filp);
1878         return ret;
1879 }
1880
1881 static int f2fs_ioc_commit_atomic_write(struct file *filp)
1882 {
1883         struct inode *inode = file_inode(filp);
1884         int ret;
1885
1886         if (!inode_owner_or_capable(inode))
1887                 return -EACCES;
1888
1889         ret = mnt_want_write_file(filp);
1890         if (ret)
1891                 return ret;
1892
1893         f2fs_balance_fs(F2FS_I_SB(inode), true);
1894
1895         inode_lock(inode);
1896
1897         if (f2fs_is_volatile_file(inode)) {
1898                 ret = -EINVAL;
1899                 goto err_out;
1900         }
1901
1902         if (f2fs_is_atomic_file(inode)) {
1903                 ret = f2fs_commit_inmem_pages(inode);
1904                 if (ret)
1905                         goto err_out;
1906
1907                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1908                 if (!ret) {
1909                         clear_inode_flag(inode, FI_ATOMIC_FILE);
1910                         F2FS_I(inode)->i_gc_failures[GC_FAILURE_ATOMIC] = 0;
1911                         stat_dec_atomic_write(inode);
1912                 }
1913         } else {
1914                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
1915         }
1916 err_out:
1917         if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST)) {
1918                 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
1919                 ret = -EINVAL;
1920         }
1921         inode_unlock(inode);
1922         mnt_drop_write_file(filp);
1923         return ret;
1924 }
1925
1926 static int f2fs_ioc_start_volatile_write(struct file *filp)
1927 {
1928         struct inode *inode = file_inode(filp);
1929         int ret;
1930
1931         if (!inode_owner_or_capable(inode))
1932                 return -EACCES;
1933
1934         if (!S_ISREG(inode->i_mode))
1935                 return -EINVAL;
1936
1937         ret = mnt_want_write_file(filp);
1938         if (ret)
1939                 return ret;
1940
1941         inode_lock(inode);
1942
1943         if (f2fs_is_volatile_file(inode))
1944                 goto out;
1945
1946         ret = f2fs_convert_inline_inode(inode);
1947         if (ret)
1948                 goto out;
1949
1950         stat_inc_volatile_write(inode);
1951         stat_update_max_volatile_write(inode);
1952
1953         set_inode_flag(inode, FI_VOLATILE_FILE);
1954         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1955 out:
1956         inode_unlock(inode);
1957         mnt_drop_write_file(filp);
1958         return ret;
1959 }
1960
1961 static int f2fs_ioc_release_volatile_write(struct file *filp)
1962 {
1963         struct inode *inode = file_inode(filp);
1964         int ret;
1965
1966         if (!inode_owner_or_capable(inode))
1967                 return -EACCES;
1968
1969         ret = mnt_want_write_file(filp);
1970         if (ret)
1971                 return ret;
1972
1973         inode_lock(inode);
1974
1975         if (!f2fs_is_volatile_file(inode))
1976                 goto out;
1977
1978         if (!f2fs_is_first_block_written(inode)) {
1979                 ret = truncate_partial_data_page(inode, 0, true);
1980                 goto out;
1981         }
1982
1983         ret = punch_hole(inode, 0, F2FS_BLKSIZE);
1984 out:
1985         inode_unlock(inode);
1986         mnt_drop_write_file(filp);
1987         return ret;
1988 }
1989
1990 static int f2fs_ioc_abort_volatile_write(struct file *filp)
1991 {
1992         struct inode *inode = file_inode(filp);
1993         int ret;
1994
1995         if (!inode_owner_or_capable(inode))
1996                 return -EACCES;
1997
1998         ret = mnt_want_write_file(filp);
1999         if (ret)
2000                 return ret;
2001
2002         inode_lock(inode);
2003
2004         if (f2fs_is_atomic_file(inode))
2005                 f2fs_drop_inmem_pages(inode);
2006         if (f2fs_is_volatile_file(inode)) {
2007                 clear_inode_flag(inode, FI_VOLATILE_FILE);
2008                 stat_dec_volatile_write(inode);
2009                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
2010         }
2011
2012         clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
2013
2014         inode_unlock(inode);
2015
2016         mnt_drop_write_file(filp);
2017         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2018         return ret;
2019 }
2020
2021 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
2022 {
2023         struct inode *inode = file_inode(filp);
2024         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2025         struct super_block *sb = sbi->sb;
2026         __u32 in;
2027         int ret = 0;
2028
2029         if (!capable(CAP_SYS_ADMIN))
2030                 return -EPERM;
2031
2032         if (get_user(in, (__u32 __user *)arg))
2033                 return -EFAULT;
2034
2035         if (in != F2FS_GOING_DOWN_FULLSYNC) {
2036                 ret = mnt_want_write_file(filp);
2037                 if (ret)
2038                         return ret;
2039         }
2040
2041         switch (in) {
2042         case F2FS_GOING_DOWN_FULLSYNC:
2043                 sb = freeze_bdev(sb->s_bdev);
2044                 if (IS_ERR(sb)) {
2045                         ret = PTR_ERR(sb);
2046                         goto out;
2047                 }
2048                 if (sb) {
2049                         f2fs_stop_checkpoint(sbi, false);
2050                         set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
2051                         thaw_bdev(sb->s_bdev, sb);
2052                 }
2053                 break;
2054         case F2FS_GOING_DOWN_METASYNC:
2055                 /* do checkpoint only */
2056                 ret = f2fs_sync_fs(sb, 1);
2057                 if (ret)
2058                         goto out;
2059                 f2fs_stop_checkpoint(sbi, false);
2060                 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
2061                 break;
2062         case F2FS_GOING_DOWN_NOSYNC:
2063                 f2fs_stop_checkpoint(sbi, false);
2064                 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
2065                 break;
2066         case F2FS_GOING_DOWN_METAFLUSH:
2067                 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO);
2068                 f2fs_stop_checkpoint(sbi, false);
2069                 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
2070                 break;
2071         case F2FS_GOING_DOWN_NEED_FSCK:
2072                 set_sbi_flag(sbi, SBI_NEED_FSCK);
2073                 set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
2074                 set_sbi_flag(sbi, SBI_IS_DIRTY);
2075                 /* do checkpoint only */
2076                 ret = f2fs_sync_fs(sb, 1);
2077                 goto out;
2078         default:
2079                 ret = -EINVAL;
2080                 goto out;
2081         }
2082
2083         f2fs_stop_gc_thread(sbi);
2084         f2fs_stop_discard_thread(sbi);
2085
2086         f2fs_drop_discard_cmd(sbi);
2087         clear_opt(sbi, DISCARD);
2088
2089         f2fs_update_time(sbi, REQ_TIME);
2090 out:
2091         if (in != F2FS_GOING_DOWN_FULLSYNC)
2092                 mnt_drop_write_file(filp);
2093
2094         trace_f2fs_shutdown(sbi, in, ret);
2095
2096         return ret;
2097 }
2098
2099 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
2100 {
2101         struct inode *inode = file_inode(filp);
2102         struct super_block *sb = inode->i_sb;
2103         struct request_queue *q = bdev_get_queue(sb->s_bdev);
2104         struct fstrim_range range;
2105         int ret;
2106
2107         if (!capable(CAP_SYS_ADMIN))
2108                 return -EPERM;
2109
2110         if (!f2fs_hw_support_discard(F2FS_SB(sb)))
2111                 return -EOPNOTSUPP;
2112
2113         if (copy_from_user(&range, (struct fstrim_range __user *)arg,
2114                                 sizeof(range)))
2115                 return -EFAULT;
2116
2117         ret = mnt_want_write_file(filp);
2118         if (ret)
2119                 return ret;
2120
2121         range.minlen = max((unsigned int)range.minlen,
2122                                 q->limits.discard_granularity);
2123         ret = f2fs_trim_fs(F2FS_SB(sb), &range);
2124         mnt_drop_write_file(filp);
2125         if (ret < 0)
2126                 return ret;
2127
2128         if (copy_to_user((struct fstrim_range __user *)arg, &range,
2129                                 sizeof(range)))
2130                 return -EFAULT;
2131         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2132         return 0;
2133 }
2134
2135 static bool uuid_is_nonzero(__u8 u[16])
2136 {
2137         int i;
2138
2139         for (i = 0; i < 16; i++)
2140                 if (u[i])
2141                         return true;
2142         return false;
2143 }
2144
2145 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
2146 {
2147         struct inode *inode = file_inode(filp);
2148
2149         if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode)))
2150                 return -EOPNOTSUPP;
2151
2152         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2153
2154         return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
2155 }
2156
2157 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
2158 {
2159         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2160                 return -EOPNOTSUPP;
2161         return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
2162 }
2163
2164 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
2165 {
2166         struct inode *inode = file_inode(filp);
2167         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2168         int err;
2169
2170         if (!f2fs_sb_has_encrypt(sbi))
2171                 return -EOPNOTSUPP;
2172
2173         err = mnt_want_write_file(filp);
2174         if (err)
2175                 return err;
2176
2177         down_write(&sbi->sb_lock);
2178
2179         if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
2180                 goto got_it;
2181
2182         /* update superblock with uuid */
2183         generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
2184
2185         err = f2fs_commit_super(sbi, false);
2186         if (err) {
2187                 /* undo new data */
2188                 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
2189                 goto out_err;
2190         }
2191 got_it:
2192         if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
2193                                                                         16))
2194                 err = -EFAULT;
2195 out_err:
2196         up_write(&sbi->sb_lock);
2197         mnt_drop_write_file(filp);
2198         return err;
2199 }
2200
2201 static int f2fs_ioc_get_encryption_policy_ex(struct file *filp,
2202                                              unsigned long arg)
2203 {
2204         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2205                 return -EOPNOTSUPP;
2206
2207         return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg);
2208 }
2209
2210 static int f2fs_ioc_add_encryption_key(struct file *filp, unsigned long arg)
2211 {
2212         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2213                 return -EOPNOTSUPP;
2214
2215         return fscrypt_ioctl_add_key(filp, (void __user *)arg);
2216 }
2217
2218 static int f2fs_ioc_remove_encryption_key(struct file *filp, unsigned long arg)
2219 {
2220         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2221                 return -EOPNOTSUPP;
2222
2223         return fscrypt_ioctl_remove_key(filp, (void __user *)arg);
2224 }
2225
2226 static int f2fs_ioc_remove_encryption_key_all_users(struct file *filp,
2227                                                     unsigned long arg)
2228 {
2229         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2230                 return -EOPNOTSUPP;
2231
2232         return fscrypt_ioctl_remove_key_all_users(filp, (void __user *)arg);
2233 }
2234
2235 static int f2fs_ioc_get_encryption_key_status(struct file *filp,
2236                                               unsigned long arg)
2237 {
2238         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2239                 return -EOPNOTSUPP;
2240
2241         return fscrypt_ioctl_get_key_status(filp, (void __user *)arg);
2242 }
2243
2244 static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
2245 {
2246         struct inode *inode = file_inode(filp);
2247         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2248         __u32 sync;
2249         int ret;
2250
2251         if (!capable(CAP_SYS_ADMIN))
2252                 return -EPERM;
2253
2254         if (get_user(sync, (__u32 __user *)arg))
2255                 return -EFAULT;
2256
2257         if (f2fs_readonly(sbi->sb))
2258                 return -EROFS;
2259
2260         ret = mnt_want_write_file(filp);
2261         if (ret)
2262                 return ret;
2263
2264         if (!sync) {
2265                 if (!mutex_trylock(&sbi->gc_mutex)) {
2266                         ret = -EBUSY;
2267                         goto out;
2268                 }
2269         } else {
2270                 mutex_lock(&sbi->gc_mutex);
2271         }
2272
2273         ret = f2fs_gc(sbi, sync, true, NULL_SEGNO);
2274 out:
2275         mnt_drop_write_file(filp);
2276         return ret;
2277 }
2278
2279 static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg)
2280 {
2281         struct inode *inode = file_inode(filp);
2282         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2283         struct f2fs_gc_range range;
2284         u64 end;
2285         int ret;
2286
2287         if (!capable(CAP_SYS_ADMIN))
2288                 return -EPERM;
2289
2290         if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg,
2291                                                         sizeof(range)))
2292                 return -EFAULT;
2293
2294         if (f2fs_readonly(sbi->sb))
2295                 return -EROFS;
2296
2297         end = range.start + range.len;
2298         if (range.start < MAIN_BLKADDR(sbi) || end >= MAX_BLKADDR(sbi)) {
2299                 return -EINVAL;
2300         }
2301
2302         ret = mnt_want_write_file(filp);
2303         if (ret)
2304                 return ret;
2305
2306 do_more:
2307         if (!range.sync) {
2308                 if (!mutex_trylock(&sbi->gc_mutex)) {
2309                         ret = -EBUSY;
2310                         goto out;
2311                 }
2312         } else {
2313                 mutex_lock(&sbi->gc_mutex);
2314         }
2315
2316         ret = f2fs_gc(sbi, range.sync, true, GET_SEGNO(sbi, range.start));
2317         range.start += BLKS_PER_SEC(sbi);
2318         if (range.start <= end)
2319                 goto do_more;
2320 out:
2321         mnt_drop_write_file(filp);
2322         return ret;
2323 }
2324
2325 static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg)
2326 {
2327         struct inode *inode = file_inode(filp);
2328         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2329         int ret;
2330
2331         if (!capable(CAP_SYS_ADMIN))
2332                 return -EPERM;
2333
2334         if (f2fs_readonly(sbi->sb))
2335                 return -EROFS;
2336
2337         if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
2338                 f2fs_info(sbi, "Skipping Checkpoint. Checkpoints currently disabled.");
2339                 return -EINVAL;
2340         }
2341
2342         ret = mnt_want_write_file(filp);
2343         if (ret)
2344                 return ret;
2345
2346         ret = f2fs_sync_fs(sbi->sb, 1);
2347
2348         mnt_drop_write_file(filp);
2349         return ret;
2350 }
2351
2352 static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
2353                                         struct file *filp,
2354                                         struct f2fs_defragment *range)
2355 {
2356         struct inode *inode = file_inode(filp);
2357         struct f2fs_map_blocks map = { .m_next_extent = NULL,
2358                                         .m_seg_type = NO_CHECK_TYPE ,
2359                                         .m_may_create = false };
2360         struct extent_info ei = {0, 0, 0};
2361         pgoff_t pg_start, pg_end, next_pgofs;
2362         unsigned int blk_per_seg = sbi->blocks_per_seg;
2363         unsigned int total = 0, sec_num;
2364         block_t blk_end = 0;
2365         bool fragmented = false;
2366         int err;
2367
2368         /* if in-place-update policy is enabled, don't waste time here */
2369         if (f2fs_should_update_inplace(inode, NULL))
2370                 return -EINVAL;
2371
2372         pg_start = range->start >> PAGE_SHIFT;
2373         pg_end = (range->start + range->len) >> PAGE_SHIFT;
2374
2375         f2fs_balance_fs(sbi, true);
2376
2377         inode_lock(inode);
2378
2379         /* writeback all dirty pages in the range */
2380         err = filemap_write_and_wait_range(inode->i_mapping, range->start,
2381                                                 range->start + range->len - 1);
2382         if (err)
2383                 goto out;
2384
2385         /*
2386          * lookup mapping info in extent cache, skip defragmenting if physical
2387          * block addresses are continuous.
2388          */
2389         if (f2fs_lookup_extent_cache(inode, pg_start, &ei)) {
2390                 if (ei.fofs + ei.len >= pg_end)
2391                         goto out;
2392         }
2393
2394         map.m_lblk = pg_start;
2395         map.m_next_pgofs = &next_pgofs;
2396
2397         /*
2398          * lookup mapping info in dnode page cache, skip defragmenting if all
2399          * physical block addresses are continuous even if there are hole(s)
2400          * in logical blocks.
2401          */
2402         while (map.m_lblk < pg_end) {
2403                 map.m_len = pg_end - map.m_lblk;
2404                 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
2405                 if (err)
2406                         goto out;
2407
2408                 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2409                         map.m_lblk = next_pgofs;
2410                         continue;
2411                 }
2412
2413                 if (blk_end && blk_end != map.m_pblk)
2414                         fragmented = true;
2415
2416                 /* record total count of block that we're going to move */
2417                 total += map.m_len;
2418
2419                 blk_end = map.m_pblk + map.m_len;
2420
2421                 map.m_lblk += map.m_len;
2422         }
2423
2424         if (!fragmented)
2425                 goto out;
2426
2427         sec_num = DIV_ROUND_UP(total, BLKS_PER_SEC(sbi));
2428
2429         /*
2430          * make sure there are enough free section for LFS allocation, this can
2431          * avoid defragment running in SSR mode when free section are allocated
2432          * intensively
2433          */
2434         if (has_not_enough_free_secs(sbi, 0, sec_num)) {
2435                 err = -EAGAIN;
2436                 goto out;
2437         }
2438
2439         map.m_lblk = pg_start;
2440         map.m_len = pg_end - pg_start;
2441         total = 0;
2442
2443         while (map.m_lblk < pg_end) {
2444                 pgoff_t idx;
2445                 int cnt = 0;
2446
2447 do_map:
2448                 map.m_len = pg_end - map.m_lblk;
2449                 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
2450                 if (err)
2451                         goto clear_out;
2452
2453                 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2454                         map.m_lblk = next_pgofs;
2455                         continue;
2456                 }
2457
2458                 set_inode_flag(inode, FI_DO_DEFRAG);
2459
2460                 idx = map.m_lblk;
2461                 while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
2462                         struct page *page;
2463
2464                         page = f2fs_get_lock_data_page(inode, idx, true);
2465                         if (IS_ERR(page)) {
2466                                 err = PTR_ERR(page);
2467                                 goto clear_out;
2468                         }
2469
2470                         set_page_dirty(page);
2471                         f2fs_put_page(page, 1);
2472
2473                         idx++;
2474                         cnt++;
2475                         total++;
2476                 }
2477
2478                 map.m_lblk = idx;
2479
2480                 if (idx < pg_end && cnt < blk_per_seg)
2481                         goto do_map;
2482
2483                 clear_inode_flag(inode, FI_DO_DEFRAG);
2484
2485                 err = filemap_fdatawrite(inode->i_mapping);
2486                 if (err)
2487                         goto out;
2488         }
2489 clear_out:
2490         clear_inode_flag(inode, FI_DO_DEFRAG);
2491 out:
2492         inode_unlock(inode);
2493         if (!err)
2494                 range->len = (u64)total << PAGE_SHIFT;
2495         return err;
2496 }
2497
2498 static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
2499 {
2500         struct inode *inode = file_inode(filp);
2501         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2502         struct f2fs_defragment range;
2503         int err;
2504
2505         if (!capable(CAP_SYS_ADMIN))
2506                 return -EPERM;
2507
2508         if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode))
2509                 return -EINVAL;
2510
2511         if (f2fs_readonly(sbi->sb))
2512                 return -EROFS;
2513
2514         if (copy_from_user(&range, (struct f2fs_defragment __user *)arg,
2515                                                         sizeof(range)))
2516                 return -EFAULT;
2517
2518         /* verify alignment of offset & size */
2519         if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2520                 return -EINVAL;
2521
2522         if (unlikely((range.start + range.len) >> PAGE_SHIFT >
2523                                         sbi->max_file_blocks))
2524                 return -EINVAL;
2525
2526         err = mnt_want_write_file(filp);
2527         if (err)
2528                 return err;
2529
2530         err = f2fs_defragment_range(sbi, filp, &range);
2531         mnt_drop_write_file(filp);
2532
2533         f2fs_update_time(sbi, REQ_TIME);
2534         if (err < 0)
2535                 return err;
2536
2537         if (copy_to_user((struct f2fs_defragment __user *)arg, &range,
2538                                                         sizeof(range)))
2539                 return -EFAULT;
2540
2541         return 0;
2542 }
2543
2544 static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2545                         struct file *file_out, loff_t pos_out, size_t len)
2546 {
2547         struct inode *src = file_inode(file_in);
2548         struct inode *dst = file_inode(file_out);
2549         struct f2fs_sb_info *sbi = F2FS_I_SB(src);
2550         size_t olen = len, dst_max_i_size = 0;
2551         size_t dst_osize;
2552         int ret;
2553
2554         if (file_in->f_path.mnt != file_out->f_path.mnt ||
2555                                 src->i_sb != dst->i_sb)
2556                 return -EXDEV;
2557
2558         if (unlikely(f2fs_readonly(src->i_sb)))
2559                 return -EROFS;
2560
2561         if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))
2562                 return -EINVAL;
2563
2564         if (IS_ENCRYPTED(src) || IS_ENCRYPTED(dst))
2565                 return -EOPNOTSUPP;
2566
2567         if (src == dst) {
2568                 if (pos_in == pos_out)
2569                         return 0;
2570                 if (pos_out > pos_in && pos_out < pos_in + len)
2571                         return -EINVAL;
2572         }
2573
2574         inode_lock(src);
2575         if (src != dst) {
2576                 ret = -EBUSY;
2577                 if (!inode_trylock(dst))
2578                         goto out;
2579         }
2580
2581         ret = -EINVAL;
2582         if (pos_in + len > src->i_size || pos_in + len < pos_in)
2583                 goto out_unlock;
2584         if (len == 0)
2585                 olen = len = src->i_size - pos_in;
2586         if (pos_in + len == src->i_size)
2587                 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
2588         if (len == 0) {
2589                 ret = 0;
2590                 goto out_unlock;
2591         }
2592
2593         dst_osize = dst->i_size;
2594         if (pos_out + olen > dst->i_size)
2595                 dst_max_i_size = pos_out + olen;
2596
2597         /* verify the end result is block aligned */
2598         if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
2599                         !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
2600                         !IS_ALIGNED(pos_out, F2FS_BLKSIZE))
2601                 goto out_unlock;
2602
2603         ret = f2fs_convert_inline_inode(src);
2604         if (ret)
2605                 goto out_unlock;
2606
2607         ret = f2fs_convert_inline_inode(dst);
2608         if (ret)
2609                 goto out_unlock;
2610
2611         /* write out all dirty pages from offset */
2612         ret = filemap_write_and_wait_range(src->i_mapping,
2613                                         pos_in, pos_in + len);
2614         if (ret)
2615                 goto out_unlock;
2616
2617         ret = filemap_write_and_wait_range(dst->i_mapping,
2618                                         pos_out, pos_out + len);
2619         if (ret)
2620                 goto out_unlock;
2621
2622         f2fs_balance_fs(sbi, true);
2623
2624         down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2625         if (src != dst) {
2626                 ret = -EBUSY;
2627                 if (!down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
2628                         goto out_src;
2629         }
2630
2631         f2fs_lock_op(sbi);
2632         ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2633                                 pos_out >> F2FS_BLKSIZE_BITS,
2634                                 len >> F2FS_BLKSIZE_BITS, false);
2635
2636         if (!ret) {
2637                 if (dst_max_i_size)
2638                         f2fs_i_size_write(dst, dst_max_i_size);
2639                 else if (dst_osize != dst->i_size)
2640                         f2fs_i_size_write(dst, dst_osize);
2641         }
2642         f2fs_unlock_op(sbi);
2643
2644         if (src != dst)
2645                 up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
2646 out_src:
2647         up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2648 out_unlock:
2649         if (src != dst)
2650                 inode_unlock(dst);
2651 out:
2652         inode_unlock(src);
2653         return ret;
2654 }
2655
2656 static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
2657 {
2658         struct f2fs_move_range range;
2659         struct fd dst;
2660         int err;
2661
2662         if (!(filp->f_mode & FMODE_READ) ||
2663                         !(filp->f_mode & FMODE_WRITE))
2664                 return -EBADF;
2665
2666         if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
2667                                                         sizeof(range)))
2668                 return -EFAULT;
2669
2670         dst = fdget(range.dst_fd);
2671         if (!dst.file)
2672                 return -EBADF;
2673
2674         if (!(dst.file->f_mode & FMODE_WRITE)) {
2675                 err = -EBADF;
2676                 goto err_out;
2677         }
2678
2679         err = mnt_want_write_file(filp);
2680         if (err)
2681                 goto err_out;
2682
2683         err = f2fs_move_file_range(filp, range.pos_in, dst.file,
2684                                         range.pos_out, range.len);
2685
2686         mnt_drop_write_file(filp);
2687         if (err)
2688                 goto err_out;
2689
2690         if (copy_to_user((struct f2fs_move_range __user *)arg,
2691                                                 &range, sizeof(range)))
2692                 err = -EFAULT;
2693 err_out:
2694         fdput(dst);
2695         return err;
2696 }
2697
2698 static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
2699 {
2700         struct inode *inode = file_inode(filp);
2701         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2702         struct sit_info *sm = SIT_I(sbi);
2703         unsigned int start_segno = 0, end_segno = 0;
2704         unsigned int dev_start_segno = 0, dev_end_segno = 0;
2705         struct f2fs_flush_device range;
2706         int ret;
2707
2708         if (!capable(CAP_SYS_ADMIN))
2709                 return -EPERM;
2710
2711         if (f2fs_readonly(sbi->sb))
2712                 return -EROFS;
2713
2714         if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
2715                 return -EINVAL;
2716
2717         if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
2718                                                         sizeof(range)))
2719                 return -EFAULT;
2720
2721         if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num ||
2722                         __is_large_section(sbi)) {
2723                 f2fs_warn(sbi, "Can't flush %u in %d for segs_per_sec %u != 1",
2724                           range.dev_num, sbi->s_ndevs, sbi->segs_per_sec);
2725                 return -EINVAL;
2726         }
2727
2728         ret = mnt_want_write_file(filp);
2729         if (ret)
2730                 return ret;
2731
2732         if (range.dev_num != 0)
2733                 dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk);
2734         dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
2735
2736         start_segno = sm->last_victim[FLUSH_DEVICE];
2737         if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
2738                 start_segno = dev_start_segno;
2739         end_segno = min(start_segno + range.segments, dev_end_segno);
2740
2741         while (start_segno < end_segno) {
2742                 if (!mutex_trylock(&sbi->gc_mutex)) {
2743                         ret = -EBUSY;
2744                         goto out;
2745                 }
2746                 sm->last_victim[GC_CB] = end_segno + 1;
2747                 sm->last_victim[GC_GREEDY] = end_segno + 1;
2748                 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
2749                 ret = f2fs_gc(sbi, true, true, start_segno);
2750                 if (ret == -EAGAIN)
2751                         ret = 0;
2752                 else if (ret < 0)
2753                         break;
2754                 start_segno++;
2755         }
2756 out:
2757         mnt_drop_write_file(filp);
2758         return ret;
2759 }
2760
2761 static int f2fs_ioc_get_features(struct file *filp, unsigned long arg)
2762 {
2763         struct inode *inode = file_inode(filp);
2764         u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature);
2765
2766         /* Must validate to set it with SQLite behavior in Android. */
2767         sb_feature |= F2FS_FEATURE_ATOMIC_WRITE;
2768
2769         return put_user(sb_feature, (u32 __user *)arg);
2770 }
2771
2772 #ifdef CONFIG_QUOTA
2773 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid)
2774 {
2775         struct dquot *transfer_to[MAXQUOTAS] = {};
2776         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2777         struct super_block *sb = sbi->sb;
2778         int err = 0;
2779
2780         transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
2781         if (!IS_ERR(transfer_to[PRJQUOTA])) {
2782                 err = __dquot_transfer(inode, transfer_to);
2783                 if (err)
2784                         set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2785                 dqput(transfer_to[PRJQUOTA]);
2786         }
2787         return err;
2788 }
2789
2790 static int f2fs_ioc_setproject(struct file *filp, __u32 projid)
2791 {
2792         struct inode *inode = file_inode(filp);
2793         struct f2fs_inode_info *fi = F2FS_I(inode);
2794         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2795         struct page *ipage;
2796         kprojid_t kprojid;
2797         int err;
2798
2799         if (!f2fs_sb_has_project_quota(sbi)) {
2800                 if (projid != F2FS_DEF_PROJID)
2801                         return -EOPNOTSUPP;
2802                 else
2803                         return 0;
2804         }
2805
2806         if (!f2fs_has_extra_attr(inode))
2807                 return -EOPNOTSUPP;
2808
2809         kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
2810
2811         if (projid_eq(kprojid, F2FS_I(inode)->i_projid))
2812                 return 0;
2813
2814         err = -EPERM;
2815         /* Is it quota file? Do not allow user to mess with it */
2816         if (IS_NOQUOTA(inode))
2817                 return err;
2818
2819         ipage = f2fs_get_node_page(sbi, inode->i_ino);
2820         if (IS_ERR(ipage))
2821                 return PTR_ERR(ipage);
2822
2823         if (!F2FS_FITS_IN_INODE(F2FS_INODE(ipage), fi->i_extra_isize,
2824                                                                 i_projid)) {
2825                 err = -EOVERFLOW;
2826                 f2fs_put_page(ipage, 1);
2827                 return err;
2828         }
2829         f2fs_put_page(ipage, 1);
2830
2831         err = dquot_initialize(inode);
2832         if (err)
2833                 return err;
2834
2835         f2fs_lock_op(sbi);
2836         err = f2fs_transfer_project_quota(inode, kprojid);
2837         if (err)
2838                 goto out_unlock;
2839
2840         F2FS_I(inode)->i_projid = kprojid;
2841         inode->i_ctime = current_time(inode);
2842         f2fs_mark_inode_dirty_sync(inode, true);
2843 out_unlock:
2844         f2fs_unlock_op(sbi);
2845         return err;
2846 }
2847 #else
2848 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid)
2849 {
2850         return 0;
2851 }
2852
2853 static int f2fs_ioc_setproject(struct file *filp, __u32 projid)
2854 {
2855         if (projid != F2FS_DEF_PROJID)
2856                 return -EOPNOTSUPP;
2857         return 0;
2858 }
2859 #endif
2860
2861 /* FS_IOC_FSGETXATTR and FS_IOC_FSSETXATTR support */
2862
2863 /*
2864  * To make a new on-disk f2fs i_flag gettable via FS_IOC_FSGETXATTR and settable
2865  * via FS_IOC_FSSETXATTR, add an entry for it to f2fs_xflags_map[], and add its
2866  * FS_XFLAG_* equivalent to F2FS_SUPPORTED_XFLAGS.
2867  */
2868
2869 static const struct {
2870         u32 iflag;
2871         u32 xflag;
2872 } f2fs_xflags_map[] = {
2873         { F2FS_SYNC_FL,         FS_XFLAG_SYNC },
2874         { F2FS_IMMUTABLE_FL,    FS_XFLAG_IMMUTABLE },
2875         { F2FS_APPEND_FL,       FS_XFLAG_APPEND },
2876         { F2FS_NODUMP_FL,       FS_XFLAG_NODUMP },
2877         { F2FS_NOATIME_FL,      FS_XFLAG_NOATIME },
2878         { F2FS_PROJINHERIT_FL,  FS_XFLAG_PROJINHERIT },
2879 };
2880
2881 #define F2FS_SUPPORTED_XFLAGS (         \
2882                 FS_XFLAG_SYNC |         \
2883                 FS_XFLAG_IMMUTABLE |    \
2884                 FS_XFLAG_APPEND |       \
2885                 FS_XFLAG_NODUMP |       \
2886                 FS_XFLAG_NOATIME |      \
2887                 FS_XFLAG_PROJINHERIT)
2888
2889 /* Convert f2fs on-disk i_flags to FS_IOC_FS{GET,SET}XATTR flags */
2890 static inline u32 f2fs_iflags_to_xflags(u32 iflags)
2891 {
2892         u32 xflags = 0;
2893         int i;
2894
2895         for (i = 0; i < ARRAY_SIZE(f2fs_xflags_map); i++)
2896                 if (iflags & f2fs_xflags_map[i].iflag)
2897                         xflags |= f2fs_xflags_map[i].xflag;
2898
2899         return xflags;
2900 }
2901
2902 /* Convert FS_IOC_FS{GET,SET}XATTR flags to f2fs on-disk i_flags */
2903 static inline u32 f2fs_xflags_to_iflags(u32 xflags)
2904 {
2905         u32 iflags = 0;
2906         int i;
2907
2908         for (i = 0; i < ARRAY_SIZE(f2fs_xflags_map); i++)
2909                 if (xflags & f2fs_xflags_map[i].xflag)
2910                         iflags |= f2fs_xflags_map[i].iflag;
2911
2912         return iflags;
2913 }
2914
2915 static void f2fs_fill_fsxattr(struct inode *inode, struct fsxattr *fa)
2916 {
2917         struct f2fs_inode_info *fi = F2FS_I(inode);
2918
2919         simple_fill_fsxattr(fa, f2fs_iflags_to_xflags(fi->i_flags));
2920
2921         if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)))
2922                 fa->fsx_projid = from_kprojid(&init_user_ns, fi->i_projid);
2923 }
2924
2925 static int f2fs_ioc_fsgetxattr(struct file *filp, unsigned long arg)
2926 {
2927         struct inode *inode = file_inode(filp);
2928         struct fsxattr fa;
2929
2930         f2fs_fill_fsxattr(inode, &fa);
2931
2932         if (copy_to_user((struct fsxattr __user *)arg, &fa, sizeof(fa)))
2933                 return -EFAULT;
2934         return 0;
2935 }
2936
2937 static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg)
2938 {
2939         struct inode *inode = file_inode(filp);
2940         struct fsxattr fa, old_fa;
2941         u32 iflags;
2942         int err;
2943
2944         if (copy_from_user(&fa, (struct fsxattr __user *)arg, sizeof(fa)))
2945                 return -EFAULT;
2946
2947         /* Make sure caller has proper permission */
2948         if (!inode_owner_or_capable(inode))
2949                 return -EACCES;
2950
2951         if (fa.fsx_xflags & ~F2FS_SUPPORTED_XFLAGS)
2952                 return -EOPNOTSUPP;
2953
2954         iflags = f2fs_xflags_to_iflags(fa.fsx_xflags);
2955         if (f2fs_mask_flags(inode->i_mode, iflags) != iflags)
2956                 return -EOPNOTSUPP;
2957
2958         err = mnt_want_write_file(filp);
2959         if (err)
2960                 return err;
2961
2962         inode_lock(inode);
2963
2964         f2fs_fill_fsxattr(inode, &old_fa);
2965         err = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);
2966         if (err)
2967                 goto out;
2968
2969         err = f2fs_setflags_common(inode, iflags,
2970                         f2fs_xflags_to_iflags(F2FS_SUPPORTED_XFLAGS));
2971         if (err)
2972                 goto out;
2973
2974         err = f2fs_ioc_setproject(filp, fa.fsx_projid);
2975 out:
2976         inode_unlock(inode);
2977         mnt_drop_write_file(filp);
2978         return err;
2979 }
2980
2981 int f2fs_pin_file_control(struct inode *inode, bool inc)
2982 {
2983         struct f2fs_inode_info *fi = F2FS_I(inode);
2984         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2985
2986         /* Use i_gc_failures for normal file as a risk signal. */
2987         if (inc)
2988                 f2fs_i_gc_failures_write(inode,
2989                                 fi->i_gc_failures[GC_FAILURE_PIN] + 1);
2990
2991         if (fi->i_gc_failures[GC_FAILURE_PIN] > sbi->gc_pin_file_threshold) {
2992                 f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
2993                           __func__, inode->i_ino,
2994                           fi->i_gc_failures[GC_FAILURE_PIN]);
2995                 clear_inode_flag(inode, FI_PIN_FILE);
2996                 return -EAGAIN;
2997         }
2998         return 0;
2999 }
3000
3001 static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
3002 {
3003         struct inode *inode = file_inode(filp);
3004         __u32 pin;
3005         int ret = 0;
3006
3007         if (get_user(pin, (__u32 __user *)arg))
3008                 return -EFAULT;
3009
3010         if (!S_ISREG(inode->i_mode))
3011                 return -EINVAL;
3012
3013         if (f2fs_readonly(F2FS_I_SB(inode)->sb))
3014                 return -EROFS;
3015
3016         ret = mnt_want_write_file(filp);
3017         if (ret)
3018                 return ret;
3019
3020         inode_lock(inode);
3021
3022         if (f2fs_should_update_outplace(inode, NULL)) {
3023                 ret = -EINVAL;
3024                 goto out;
3025         }
3026
3027         if (!pin) {
3028                 clear_inode_flag(inode, FI_PIN_FILE);
3029                 f2fs_i_gc_failures_write(inode, 0);
3030                 goto done;
3031         }
3032
3033         if (f2fs_pin_file_control(inode, false)) {
3034                 ret = -EAGAIN;
3035                 goto out;
3036         }
3037         ret = f2fs_convert_inline_inode(inode);
3038         if (ret)
3039                 goto out;
3040
3041         set_inode_flag(inode, FI_PIN_FILE);
3042         ret = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN];
3043 done:
3044         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
3045 out:
3046         inode_unlock(inode);
3047         mnt_drop_write_file(filp);
3048         return ret;
3049 }
3050
3051 static int f2fs_ioc_get_pin_file(struct file *filp, unsigned long arg)
3052 {
3053         struct inode *inode = file_inode(filp);
3054         __u32 pin = 0;
3055
3056         if (is_inode_flag_set(inode, FI_PIN_FILE))
3057                 pin = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN];
3058         return put_user(pin, (u32 __user *)arg);
3059 }
3060
3061 int f2fs_precache_extents(struct inode *inode)
3062 {
3063         struct f2fs_inode_info *fi = F2FS_I(inode);
3064         struct f2fs_map_blocks map;
3065         pgoff_t m_next_extent;
3066         loff_t end;
3067         int err;
3068
3069         if (is_inode_flag_set(inode, FI_NO_EXTENT))
3070                 return -EOPNOTSUPP;
3071
3072         map.m_lblk = 0;
3073         map.m_next_pgofs = NULL;
3074         map.m_next_extent = &m_next_extent;
3075         map.m_seg_type = NO_CHECK_TYPE;
3076         map.m_may_create = false;
3077         end = F2FS_I_SB(inode)->max_file_blocks;
3078
3079         while (map.m_lblk < end) {
3080                 map.m_len = end - map.m_lblk;
3081
3082                 down_write(&fi->i_gc_rwsem[WRITE]);
3083                 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
3084                 up_write(&fi->i_gc_rwsem[WRITE]);
3085                 if (err)
3086                         return err;
3087
3088                 map.m_lblk = m_next_extent;
3089         }
3090
3091         return err;
3092 }
3093
3094 static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
3095 {
3096         return f2fs_precache_extents(file_inode(filp));
3097 }
3098
3099 static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg)
3100 {
3101         struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
3102         __u64 block_count;
3103         int ret;
3104
3105         if (!capable(CAP_SYS_ADMIN))
3106                 return -EPERM;
3107
3108         if (f2fs_readonly(sbi->sb))
3109                 return -EROFS;
3110
3111         if (copy_from_user(&block_count, (void __user *)arg,
3112                            sizeof(block_count)))
3113                 return -EFAULT;
3114
3115         ret = f2fs_resize_fs(sbi, block_count);
3116
3117         return ret;
3118 }
3119
3120 static int f2fs_ioc_enable_verity(struct file *filp, unsigned long arg)
3121 {
3122         struct inode *inode = file_inode(filp);
3123
3124         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
3125
3126         if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) {
3127                 f2fs_warn(F2FS_I_SB(inode),
3128                           "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem.\n",
3129                           inode->i_ino);
3130                 return -EOPNOTSUPP;
3131         }
3132
3133         return fsverity_ioctl_enable(filp, (const void __user *)arg);
3134 }
3135
3136 static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg)
3137 {
3138         if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3139                 return -EOPNOTSUPP;
3140
3141         return fsverity_ioctl_measure(filp, (void __user *)arg);
3142 }
3143
3144 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
3145 {
3146         if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
3147                 return -EIO;
3148
3149         switch (cmd) {
3150         case F2FS_IOC_GETFLAGS:
3151                 return f2fs_ioc_getflags(filp, arg);
3152         case F2FS_IOC_SETFLAGS:
3153                 return f2fs_ioc_setflags(filp, arg);
3154         case F2FS_IOC_GETVERSION:
3155                 return f2fs_ioc_getversion(filp, arg);
3156         case F2FS_IOC_START_ATOMIC_WRITE:
3157                 return f2fs_ioc_start_atomic_write(filp);
3158         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
3159                 return f2fs_ioc_commit_atomic_write(filp);
3160         case F2FS_IOC_START_VOLATILE_WRITE:
3161                 return f2fs_ioc_start_volatile_write(filp);
3162         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
3163                 return f2fs_ioc_release_volatile_write(filp);
3164         case F2FS_IOC_ABORT_VOLATILE_WRITE:
3165                 return f2fs_ioc_abort_volatile_write(filp);
3166         case F2FS_IOC_SHUTDOWN:
3167                 return f2fs_ioc_shutdown(filp, arg);
3168         case FITRIM:
3169                 return f2fs_ioc_fitrim(filp, arg);
3170         case F2FS_IOC_SET_ENCRYPTION_POLICY:
3171                 return f2fs_ioc_set_encryption_policy(filp, arg);
3172         case F2FS_IOC_GET_ENCRYPTION_POLICY:
3173                 return f2fs_ioc_get_encryption_policy(filp, arg);
3174         case F2FS_IOC_GET_ENCRYPTION_PWSALT:
3175                 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
3176         case FS_IOC_GET_ENCRYPTION_POLICY_EX:
3177                 return f2fs_ioc_get_encryption_policy_ex(filp, arg);
3178         case FS_IOC_ADD_ENCRYPTION_KEY:
3179                 return f2fs_ioc_add_encryption_key(filp, arg);
3180         case FS_IOC_REMOVE_ENCRYPTION_KEY:
3181                 return f2fs_ioc_remove_encryption_key(filp, arg);
3182         case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
3183                 return f2fs_ioc_remove_encryption_key_all_users(filp, arg);
3184         case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
3185                 return f2fs_ioc_get_encryption_key_status(filp, arg);
3186         case F2FS_IOC_GARBAGE_COLLECT:
3187                 return f2fs_ioc_gc(filp, arg);
3188         case F2FS_IOC_GARBAGE_COLLECT_RANGE:
3189                 return f2fs_ioc_gc_range(filp, arg);
3190         case F2FS_IOC_WRITE_CHECKPOINT:
3191                 return f2fs_ioc_write_checkpoint(filp, arg);
3192         case F2FS_IOC_DEFRAGMENT:
3193                 return f2fs_ioc_defragment(filp, arg);
3194         case F2FS_IOC_MOVE_RANGE:
3195                 return f2fs_ioc_move_range(filp, arg);
3196         case F2FS_IOC_FLUSH_DEVICE:
3197                 return f2fs_ioc_flush_device(filp, arg);
3198         case F2FS_IOC_GET_FEATURES:
3199                 return f2fs_ioc_get_features(filp, arg);
3200         case F2FS_IOC_FSGETXATTR:
3201                 return f2fs_ioc_fsgetxattr(filp, arg);
3202         case F2FS_IOC_FSSETXATTR:
3203                 return f2fs_ioc_fssetxattr(filp, arg);
3204         case F2FS_IOC_GET_PIN_FILE:
3205                 return f2fs_ioc_get_pin_file(filp, arg);
3206         case F2FS_IOC_SET_PIN_FILE:
3207                 return f2fs_ioc_set_pin_file(filp, arg);
3208         case F2FS_IOC_PRECACHE_EXTENTS:
3209                 return f2fs_ioc_precache_extents(filp, arg);
3210         case F2FS_IOC_RESIZE_FS:
3211                 return f2fs_ioc_resize_fs(filp, arg);
3212         case FS_IOC_ENABLE_VERITY:
3213                 return f2fs_ioc_enable_verity(filp, arg);
3214         case FS_IOC_MEASURE_VERITY:
3215                 return f2fs_ioc_measure_verity(filp, arg);
3216         default:
3217                 return -ENOTTY;
3218         }
3219 }
3220
3221 static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
3222 {
3223         struct file *file = iocb->ki_filp;
3224         struct inode *inode = file_inode(file);
3225         ssize_t ret;
3226
3227         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
3228                 ret = -EIO;
3229                 goto out;
3230         }
3231
3232         if ((iocb->ki_flags & IOCB_NOWAIT) && !(iocb->ki_flags & IOCB_DIRECT)) {
3233                 ret = -EINVAL;
3234                 goto out;
3235         }
3236
3237         if (!inode_trylock(inode)) {
3238                 if (iocb->ki_flags & IOCB_NOWAIT) {
3239                         ret = -EAGAIN;
3240                         goto out;
3241                 }
3242                 inode_lock(inode);
3243         }
3244
3245         ret = generic_write_checks(iocb, from);
3246         if (ret > 0) {
3247                 bool preallocated = false;
3248                 size_t target_size = 0;
3249                 int err;
3250
3251                 if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
3252                         set_inode_flag(inode, FI_NO_PREALLOC);
3253
3254                 if ((iocb->ki_flags & IOCB_NOWAIT)) {
3255                         if (!f2fs_overwrite_io(inode, iocb->ki_pos,
3256                                                 iov_iter_count(from)) ||
3257                                 f2fs_has_inline_data(inode) ||
3258                                 f2fs_force_buffered_io(inode, iocb, from)) {
3259                                 clear_inode_flag(inode, FI_NO_PREALLOC);
3260                                 inode_unlock(inode);
3261                                 ret = -EAGAIN;
3262                                 goto out;
3263                         }
3264                 } else {
3265                         preallocated = true;
3266                         target_size = iocb->ki_pos + iov_iter_count(from);
3267
3268                         err = f2fs_preallocate_blocks(iocb, from);
3269                         if (err) {
3270                                 clear_inode_flag(inode, FI_NO_PREALLOC);
3271                                 inode_unlock(inode);
3272                                 ret = err;
3273                                 goto out;
3274                         }
3275                 }
3276                 ret = __generic_file_write_iter(iocb, from);
3277                 clear_inode_flag(inode, FI_NO_PREALLOC);
3278
3279                 /* if we couldn't write data, we should deallocate blocks. */
3280                 if (preallocated && i_size_read(inode) < target_size)
3281                         f2fs_truncate(inode);
3282
3283                 if (ret > 0)
3284                         f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret);
3285         }
3286         inode_unlock(inode);
3287 out:
3288         trace_f2fs_file_write_iter(inode, iocb->ki_pos,
3289                                         iov_iter_count(from), ret);
3290         if (ret > 0)
3291                 ret = generic_write_sync(iocb, ret);
3292         return ret;
3293 }
3294
3295 #ifdef CONFIG_COMPAT
3296 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3297 {
3298         switch (cmd) {
3299         case F2FS_IOC32_GETFLAGS:
3300                 cmd = F2FS_IOC_GETFLAGS;
3301                 break;
3302         case F2FS_IOC32_SETFLAGS:
3303                 cmd = F2FS_IOC_SETFLAGS;
3304                 break;
3305         case F2FS_IOC32_GETVERSION:
3306                 cmd = F2FS_IOC_GETVERSION;
3307                 break;
3308         case F2FS_IOC_START_ATOMIC_WRITE:
3309         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
3310         case F2FS_IOC_START_VOLATILE_WRITE:
3311         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
3312         case F2FS_IOC_ABORT_VOLATILE_WRITE:
3313         case F2FS_IOC_SHUTDOWN:
3314         case F2FS_IOC_SET_ENCRYPTION_POLICY:
3315         case F2FS_IOC_GET_ENCRYPTION_PWSALT:
3316         case F2FS_IOC_GET_ENCRYPTION_POLICY:
3317         case FS_IOC_GET_ENCRYPTION_POLICY_EX:
3318         case FS_IOC_ADD_ENCRYPTION_KEY:
3319         case FS_IOC_REMOVE_ENCRYPTION_KEY:
3320         case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
3321         case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
3322         case F2FS_IOC_GARBAGE_COLLECT:
3323         case F2FS_IOC_GARBAGE_COLLECT_RANGE:
3324         case F2FS_IOC_WRITE_CHECKPOINT:
3325         case F2FS_IOC_DEFRAGMENT:
3326         case F2FS_IOC_MOVE_RANGE:
3327         case F2FS_IOC_FLUSH_DEVICE:
3328         case F2FS_IOC_GET_FEATURES:
3329         case F2FS_IOC_FSGETXATTR:
3330         case F2FS_IOC_FSSETXATTR:
3331         case F2FS_IOC_GET_PIN_FILE:
3332         case F2FS_IOC_SET_PIN_FILE:
3333         case F2FS_IOC_PRECACHE_EXTENTS:
3334         case F2FS_IOC_RESIZE_FS:
3335         case FS_IOC_ENABLE_VERITY:
3336         case FS_IOC_MEASURE_VERITY:
3337                 break;
3338         default:
3339                 return -ENOIOCTLCMD;
3340         }
3341         return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
3342 }
3343 #endif
3344
3345 const struct file_operations f2fs_file_operations = {
3346         .llseek         = f2fs_llseek,
3347         .read_iter      = generic_file_read_iter,
3348         .write_iter     = f2fs_file_write_iter,
3349         .open           = f2fs_file_open,
3350         .release        = f2fs_release_file,
3351         .mmap           = f2fs_file_mmap,
3352         .flush          = f2fs_file_flush,
3353         .fsync          = f2fs_sync_file,
3354         .fallocate      = f2fs_fallocate,
3355         .unlocked_ioctl = f2fs_ioctl,
3356 #ifdef CONFIG_COMPAT
3357         .compat_ioctl   = f2fs_compat_ioctl,
3358 #endif
3359         .splice_read    = generic_file_splice_read,
3360         .splice_write   = iter_file_splice_write,
3361 };