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 #include <linux/nls.h>
  24 #include <linux/sched/signal.h>
  25 #include <linux/fileattr.h>
  26 #include <linux/fadvise.h>
  27 #include <linux/iomap.h>
  28
  29 #include "f2fs.h"
  30 #include "node.h"
  31 #include "segment.h"
  32 #include "xattr.h"
  33 #include "acl.h"
  34 #include "gc.h"
  35 #include "iostat.h"
  36 #include <trace/events/f2fs.h>
  37 #include <uapi/linux/f2fs.h>
  38
  39 static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
  40 {
  41         struct inode *inode = file_inode(vmf->vma->vm_file);
  42         vm_flags_t flags = vmf->vma->vm_flags;
  43         vm_fault_t ret;
  44
  45         ret = filemap_fault(vmf);
  46         if (ret & VM_FAULT_LOCKED)
  47                 f2fs_update_iostat(F2FS_I_SB(inode), inode,
  48                                         APP_MAPPED_READ_IO, F2FS_BLKSIZE);
  49
  50         trace_f2fs_filemap_fault(inode, vmf->pgoff, flags, ret);
  51
  52         return ret;
  53 }
  54
  55 static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
  56 {
  57         struct page *page = vmf->page;
  58         struct inode *inode = file_inode(vmf->vma->vm_file);
  59         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  60         struct dnode_of_data dn;
  61         bool need_alloc = true;
  62         int err = 0;
  63         vm_fault_t ret;
  64
  65         if (unlikely(IS_IMMUTABLE(inode)))
  66                 return VM_FAULT_SIGBUS;
  67
  68         if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
  69                 err = -EIO;
  70                 goto out;
  71         }
  72
  73         if (unlikely(f2fs_cp_error(sbi))) {
  74                 err = -EIO;
  75                 goto out;
  76         }
  77
  78         if (!f2fs_is_checkpoint_ready(sbi)) {
  79                 err = -ENOSPC;
  80                 goto out;
  81         }
  82
  83         err = f2fs_convert_inline_inode(inode);
  84         if (err)
  85                 goto out;
  86
  87 #ifdef CONFIG_F2FS_FS_COMPRESSION
  88         if (f2fs_compressed_file(inode)) {
  89                 int ret = f2fs_is_compressed_cluster(inode, page->index);
  90
  91                 if (ret < 0) {
  92                         err = ret;
  93                         goto out;
  94                 } else if (ret) {
  95                         need_alloc = false;
  96                 }
  97         }
  98 #endif
  99         /* should do out of any locked page */
 100         if (need_alloc)
 101                 f2fs_balance_fs(sbi, true);
 102
 103         sb_start_pagefault(inode->i_sb);
 104
 105         f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
 106
 107         file_update_time(vmf->vma->vm_file);
 108         filemap_invalidate_lock_shared(inode->i_mapping);
 109         lock_page(page);
 110         if (unlikely(page->mapping != inode->i_mapping ||
 111                         page_offset(page) > i_size_read(inode) ||
 112                         !PageUptodate(page))) {
 113                 unlock_page(page);
 114                 err = -EFAULT;
 115                 goto out_sem;
 116         }
 117
 118         if (need_alloc) {
 119                 /* block allocation */
 120                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 121                 err = f2fs_get_block_locked(&dn, page->index);
 122         }
 123
 124 #ifdef CONFIG_F2FS_FS_COMPRESSION
 125         if (!need_alloc) {
 126                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 127                 err = f2fs_get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
 128                 f2fs_put_dnode(&dn);
 129         }
 130 #endif
 131         if (err) {
 132                 unlock_page(page);
 133                 goto out_sem;
 134         }
 135
 136         f2fs_wait_on_page_writeback(page, DATA, false, true);
 137
 138         /* wait for GCed page writeback via META_MAPPING */
 139         f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
 140
 141         /*
 142          * check to see if the page is mapped already (no holes)
 143          */
 144         if (PageMappedToDisk(page))
 145                 goto out_sem;
 146
 147         /* page is wholly or partially inside EOF */
 148         if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
 149                                                 i_size_read(inode)) {
 150                 loff_t offset;
 151
 152                 offset = i_size_read(inode) & ~PAGE_MASK;
 153                 zero_user_segment(page, offset, PAGE_SIZE);
 154         }
 155         set_page_dirty(page);
 156
 157         f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE);
 158         f2fs_update_time(sbi, REQ_TIME);
 159
 160 out_sem:
 161         filemap_invalidate_unlock_shared(inode->i_mapping);
 162
 163         sb_end_pagefault(inode->i_sb);
 164 out:
 165         ret = vmf_fs_error(err);
 166
 167         trace_f2fs_vm_page_mkwrite(inode, page->index, vmf->vma->vm_flags, ret);
 168         return ret;
 169 }
 170
 171 static const struct vm_operations_struct f2fs_file_vm_ops = {
 172         .fault          = f2fs_filemap_fault,
 173         .map_pages      = filemap_map_pages,
 174         .page_mkwrite   = f2fs_vm_page_mkwrite,
 175 };
 176
 177 static int get_parent_ino(struct inode *inode, nid_t *pino)
 178 {
 179         struct dentry *dentry;
 180
 181         /*
 182          * Make sure to get the non-deleted alias.  The alias associated with
 183          * the open file descriptor being fsync()'ed may be deleted already.
 184          */
 185         dentry = d_find_alias(inode);
 186         if (!dentry)
 187                 return 0;
 188
 189         *pino = parent_ino(dentry);
 190         dput(dentry);
 191         return 1;
 192 }
 193
 194 static inline enum cp_reason_type need_do_checkpoint(struct inode *inode)
 195 {
 196         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 197         enum cp_reason_type cp_reason = CP_NO_NEEDED;
 198
 199         if (!S_ISREG(inode->i_mode))
 200                 cp_reason = CP_NON_REGULAR;
 201         else if (f2fs_compressed_file(inode))
 202                 cp_reason = CP_COMPRESSED;
 203         else if (inode->i_nlink != 1)
 204                 cp_reason = CP_HARDLINK;
 205         else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
 206                 cp_reason = CP_SB_NEED_CP;
 207         else if (file_wrong_pino(inode))
 208                 cp_reason = CP_WRONG_PINO;
 209         else if (!f2fs_space_for_roll_forward(sbi))
 210                 cp_reason = CP_NO_SPC_ROLL;
 211         else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
 212                 cp_reason = CP_NODE_NEED_CP;
 213         else if (test_opt(sbi, FASTBOOT))
 214                 cp_reason = CP_FASTBOOT_MODE;
 215         else if (F2FS_OPTION(sbi).active_logs == 2)
 216                 cp_reason = CP_SPEC_LOG_NUM;
 217         else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT &&
 218                 f2fs_need_dentry_mark(sbi, inode->i_ino) &&
 219                 f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino,
 220                                                         TRANS_DIR_INO))
 221                 cp_reason = CP_RECOVER_DIR;
 222
 223         return cp_reason;
 224 }
 225
 226 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
 227 {
 228         struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
 229         bool ret = false;
 230         /* But we need to avoid that there are some inode updates */
 231         if ((i && PageDirty(i)) || f2fs_need_inode_block_update(sbi, ino))
 232                 ret = true;
 233         f2fs_put_page(i, 0);
 234         return ret;
 235 }
 236
 237 static void try_to_fix_pino(struct inode *inode)
 238 {
 239         struct f2fs_inode_info *fi = F2FS_I(inode);
 240         nid_t pino;
 241
 242         f2fs_down_write(&fi->i_sem);
 243         if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
 244                         get_parent_ino(inode, &pino)) {
 245                 f2fs_i_pino_write(inode, pino);
 246                 file_got_pino(inode);
 247         }
 248         f2fs_up_write(&fi->i_sem);
 249 }
 250
 251 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
 252                                                 int datasync, bool atomic)
 253 {
 254         struct inode *inode = file->f_mapping->host;
 255         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 256         nid_t ino = inode->i_ino;
 257         int ret = 0;
 258         enum cp_reason_type cp_reason = 0;
 259         struct writeback_control wbc = {
 260                 .sync_mode = WB_SYNC_ALL,
 261                 .nr_to_write = LONG_MAX,
 262                 .for_reclaim = 0,
 263         };
 264         unsigned int seq_id = 0;
 265
 266         if (unlikely(f2fs_readonly(inode->i_sb)))
 267                 return 0;
 268
 269         trace_f2fs_sync_file_enter(inode);
 270
 271         if (S_ISDIR(inode->i_mode))
 272                 goto go_write;
 273
 274         /* if fdatasync is triggered, let's do in-place-update */
 275         if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
 276                 set_inode_flag(inode, FI_NEED_IPU);
 277         ret = file_write_and_wait_range(file, start, end);
 278         clear_inode_flag(inode, FI_NEED_IPU);
 279
 280         if (ret || is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
 281                 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
 282                 return ret;
 283         }
 284
 285         /* if the inode is dirty, let's recover all the time */
 286         if (!f2fs_skip_inode_update(inode, datasync)) {
 287                 f2fs_write_inode(inode, NULL);
 288                 goto go_write;
 289         }
 290
 291         /*
 292          * if there is no written data, don't waste time to write recovery info.
 293          */
 294         if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
 295                         !f2fs_exist_written_data(sbi, ino, APPEND_INO)) {
 296
 297                 /* it may call write_inode just prior to fsync */
 298                 if (need_inode_page_update(sbi, ino))
 299                         goto go_write;
 300
 301                 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
 302                                 f2fs_exist_written_data(sbi, ino, UPDATE_INO))
 303                         goto flush_out;
 304                 goto out;
 305         } else {
 306                 /*
 307                  * for OPU case, during fsync(), node can be persisted before
 308                  * data when lower device doesn't support write barrier, result
 309                  * in data corruption after SPO.
 310                  * So for strict fsync mode, force to use atomic write semantics
 311                  * to keep write order in between data/node and last node to
 312                  * avoid potential data corruption.
 313                  */
 314                 if (F2FS_OPTION(sbi).fsync_mode ==
 315                                 FSYNC_MODE_STRICT && !atomic)
 316                         atomic = true;
 317         }
 318 go_write:
 319         /*
 320          * Both of fdatasync() and fsync() are able to be recovered from
 321          * sudden-power-off.
 322          */
 323         f2fs_down_read(&F2FS_I(inode)->i_sem);
 324         cp_reason = need_do_checkpoint(inode);
 325         f2fs_up_read(&F2FS_I(inode)->i_sem);
 326
 327         if (cp_reason) {
 328                 /* all the dirty node pages should be flushed for POR */
 329                 ret = f2fs_sync_fs(inode->i_sb, 1);
 330
 331                 /*
 332                  * We've secured consistency through sync_fs. Following pino
 333                  * will be used only for fsynced inodes after checkpoint.
 334                  */
 335                 try_to_fix_pino(inode);
 336                 clear_inode_flag(inode, FI_APPEND_WRITE);
 337                 clear_inode_flag(inode, FI_UPDATE_WRITE);
 338                 goto out;
 339         }
 340 sync_nodes:
 341         atomic_inc(&sbi->wb_sync_req[NODE]);
 342         ret = f2fs_fsync_node_pages(sbi, inode, &wbc, atomic, &seq_id);
 343         atomic_dec(&sbi->wb_sync_req[NODE]);
 344         if (ret)
 345                 goto out;
 346
 347         /* if cp_error was enabled, we should avoid infinite loop */
 348         if (unlikely(f2fs_cp_error(sbi))) {
 349                 ret = -EIO;
 350                 goto out;
 351         }
 352
 353         if (f2fs_need_inode_block_update(sbi, ino)) {
 354                 f2fs_mark_inode_dirty_sync(inode, true);
 355                 f2fs_write_inode(inode, NULL);
 356                 goto sync_nodes;
 357         }
 358
 359         /*
 360          * If it's atomic_write, it's just fine to keep write ordering. So
 361          * here we don't need to wait for node write completion, since we use
 362          * node chain which serializes node blocks. If one of node writes are
 363          * reordered, we can see simply broken chain, resulting in stopping
 364          * roll-forward recovery. It means we'll recover all or none node blocks
 365          * given fsync mark.
 366          */
 367         if (!atomic) {
 368                 ret = f2fs_wait_on_node_pages_writeback(sbi, seq_id);
 369                 if (ret)
 370                         goto out;
 371         }
 372
 373         /* once recovery info is written, don't need to tack this */
 374         f2fs_remove_ino_entry(sbi, ino, APPEND_INO);
 375         clear_inode_flag(inode, FI_APPEND_WRITE);
 376 flush_out:
 377         if ((!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER) ||
 378             (atomic && !test_opt(sbi, NOBARRIER) && f2fs_sb_has_blkzoned(sbi)))
 379                 ret = f2fs_issue_flush(sbi, inode->i_ino);
 380         if (!ret) {
 381                 f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
 382                 clear_inode_flag(inode, FI_UPDATE_WRITE);
 383                 f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
 384         }
 385         f2fs_update_time(sbi, REQ_TIME);
 386 out:
 387         trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
 388         return ret;
 389 }
 390
 391 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 392 {
 393         if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
 394                 return -EIO;
 395         return f2fs_do_sync_file(file, start, end, datasync, false);
 396 }
 397
 398 static bool __found_offset(struct address_space *mapping,
 399                 struct dnode_of_data *dn, pgoff_t index, int whence)
 400 {
 401         block_t blkaddr = f2fs_data_blkaddr(dn);
 402         struct inode *inode = mapping->host;
 403         bool compressed_cluster = false;
 404
 405         if (f2fs_compressed_file(inode)) {
 406                 block_t first_blkaddr = data_blkaddr(dn->inode, dn->node_page,
 407                     ALIGN_DOWN(dn->ofs_in_node, F2FS_I(inode)->i_cluster_size));
 408
 409                 compressed_cluster = first_blkaddr == COMPRESS_ADDR;
 410         }
 411
 412         switch (whence) {
 413         case SEEK_DATA:
 414                 if (__is_valid_data_blkaddr(blkaddr))
 415                         return true;
 416                 if (blkaddr == NEW_ADDR &&
 417                     xa_get_mark(&mapping->i_pages, index, PAGECACHE_TAG_DIRTY))
 418                         return true;
 419                 if (compressed_cluster)
 420                         return true;
 421                 break;
 422         case SEEK_HOLE:
 423                 if (compressed_cluster)
 424                         return false;
 425                 if (blkaddr == NULL_ADDR)
 426                         return true;
 427                 break;
 428         }
 429         return false;
 430 }
 431
 432 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
 433 {
 434         struct inode *inode = file->f_mapping->host;
 435         loff_t maxbytes = inode->i_sb->s_maxbytes;
 436         struct dnode_of_data dn;
 437         pgoff_t pgofs, end_offset;
 438         loff_t data_ofs = offset;
 439         loff_t isize;
 440         int err = 0;
 441
 442         inode_lock_shared(inode);
 443
 444         isize = i_size_read(inode);
 445         if (offset >= isize)
 446                 goto fail;
 447
 448         /* handle inline data case */
 449         if (f2fs_has_inline_data(inode)) {
 450                 if (whence == SEEK_HOLE) {
 451                         data_ofs = isize;
 452                         goto found;
 453                 } else if (whence == SEEK_DATA) {
 454                         data_ofs = offset;
 455                         goto found;
 456                 }
 457         }
 458
 459         pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
 460
 461         for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
 462                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 463                 err = f2fs_get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
 464                 if (err && err != -ENOENT) {
 465                         goto fail;
 466                 } else if (err == -ENOENT) {
 467                         /* direct node does not exists */
 468                         if (whence == SEEK_DATA) {
 469                                 pgofs = f2fs_get_next_page_offset(&dn, pgofs);
 470                                 continue;
 471                         } else {
 472                                 goto found;
 473                         }
 474                 }
 475
 476                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
 477
 478                 /* find data/hole in dnode block */
 479                 for (; dn.ofs_in_node < end_offset;
 480                                 dn.ofs_in_node++, pgofs++,
 481                                 data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
 482                         block_t blkaddr;
 483
 484                         blkaddr = f2fs_data_blkaddr(&dn);
 485
 486                         if (__is_valid_data_blkaddr(blkaddr) &&
 487                                 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
 488                                         blkaddr, DATA_GENERIC_ENHANCE)) {
 489                                 f2fs_put_dnode(&dn);
 490                                 goto fail;
 491                         }
 492
 493                         if (__found_offset(file->f_mapping, &dn,
 494                                                         pgofs, whence)) {
 495                                 f2fs_put_dnode(&dn);
 496                                 goto found;
 497                         }
 498                 }
 499                 f2fs_put_dnode(&dn);
 500         }
 501
 502         if (whence == SEEK_DATA)
 503                 goto fail;
 504 found:
 505         if (whence == SEEK_HOLE && data_ofs > isize)
 506                 data_ofs = isize;
 507         inode_unlock_shared(inode);
 508         return vfs_setpos(file, data_ofs, maxbytes);
 509 fail:
 510         inode_unlock_shared(inode);
 511         return -ENXIO;
 512 }
 513
 514 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
 515 {
 516         struct inode *inode = file->f_mapping->host;
 517         loff_t maxbytes = inode->i_sb->s_maxbytes;
 518
 519         if (f2fs_compressed_file(inode))
 520                 maxbytes = max_file_blocks(inode) << F2FS_BLKSIZE_BITS;
 521
 522         switch (whence) {
 523         case SEEK_SET:
 524         case SEEK_CUR:
 525         case SEEK_END:
 526                 return generic_file_llseek_size(file, offset, whence,
 527                                                 maxbytes, i_size_read(inode));
 528         case SEEK_DATA:
 529         case SEEK_HOLE:
 530                 if (offset < 0)
 531                         return -ENXIO;
 532                 return f2fs_seek_block(file, offset, whence);
 533         }
 534
 535         return -EINVAL;
 536 }
 537
 538 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 539 {
 540         struct inode *inode = file_inode(file);
 541
 542         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
 543                 return -EIO;
 544
 545         if (!f2fs_is_compress_backend_ready(inode))
 546                 return -EOPNOTSUPP;
 547
 548         file_accessed(file);
 549         vma->vm_ops = &f2fs_file_vm_ops;
 550
 551         f2fs_down_read(&F2FS_I(inode)->i_sem);
 552         set_inode_flag(inode, FI_MMAP_FILE);
 553         f2fs_up_read(&F2FS_I(inode)->i_sem);
 554
 555         return 0;
 556 }
 557
 558 static int f2fs_file_open(struct inode *inode, struct file *filp)
 559 {
 560         int err = fscrypt_file_open(inode, filp);
 561
 562         if (err)
 563                 return err;
 564
 565         if (!f2fs_is_compress_backend_ready(inode))
 566                 return -EOPNOTSUPP;
 567
 568         err = fsverity_file_open(inode, filp);
 569         if (err)
 570                 return err;
 571
 572         filp->f_mode |= FMODE_NOWAIT | FMODE_BUF_RASYNC;
 573         filp->f_mode |= FMODE_CAN_ODIRECT;
 574
 575         return dquot_file_open(inode, filp);
 576 }
 577
 578 void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 579 {
 580         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 581         int nr_free = 0, ofs = dn->ofs_in_node, len = count;
 582         __le32 *addr;
 583         bool compressed_cluster = false;
 584         int cluster_index = 0, valid_blocks = 0;
 585         int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
 586         bool released = !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks);
 587
 588         addr = get_dnode_addr(dn->inode, dn->node_page) + ofs;
 589
 590         /* Assumption: truncation starts with cluster */
 591         for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) {
 592                 block_t blkaddr = le32_to_cpu(*addr);
 593
 594                 if (f2fs_compressed_file(dn->inode) &&
 595                                         !(cluster_index & (cluster_size - 1))) {
 596                         if (compressed_cluster)
 597                                 f2fs_i_compr_blocks_update(dn->inode,
 598                                                         valid_blocks, false);
 599                         compressed_cluster = (blkaddr == COMPRESS_ADDR);
 600                         valid_blocks = 0;
 601                 }
 602
 603                 if (blkaddr == NULL_ADDR)
 604                         continue;
 605
 606                 f2fs_set_data_blkaddr(dn, NULL_ADDR);
 607
 608                 if (__is_valid_data_blkaddr(blkaddr)) {
 609                         if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE))
 610                                 continue;
 611                         if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr,
 612                                                 DATA_GENERIC_ENHANCE))
 613                                 continue;
 614                         if (compressed_cluster)
 615                                 valid_blocks++;
 616                 }
 617
 618                 f2fs_invalidate_blocks(sbi, blkaddr);
 619
 620                 if (!released || blkaddr != COMPRESS_ADDR)
 621                         nr_free++;
 622         }
 623
 624         if (compressed_cluster)
 625                 f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false);
 626
 627         if (nr_free) {
 628                 pgoff_t fofs;
 629                 /*
 630                  * once we invalidate valid blkaddr in range [ofs, ofs + count],
 631                  * we will invalidate all blkaddr in the whole range.
 632                  */
 633                 fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page),
 634                                                         dn->inode) + ofs;
 635                 f2fs_update_read_extent_cache_range(dn, fofs, 0, len);
 636                 f2fs_update_age_extent_cache_range(dn, fofs, len);
 637                 dec_valid_block_count(sbi, dn->inode, nr_free);
 638         }
 639         dn->ofs_in_node = ofs;
 640
 641         f2fs_update_time(sbi, REQ_TIME);
 642         trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
 643                                          dn->ofs_in_node, nr_free);
 644 }
 645
 646 static int truncate_partial_data_page(struct inode *inode, u64 from,
 647                                                                 bool cache_only)
 648 {
 649         loff_t offset = from & (PAGE_SIZE - 1);
 650         pgoff_t index = from >> PAGE_SHIFT;
 651         struct address_space *mapping = inode->i_mapping;
 652         struct page *page;
 653
 654         if (!offset && !cache_only)
 655                 return 0;
 656
 657         if (cache_only) {
 658                 page = find_lock_page(mapping, index);
 659                 if (page && PageUptodate(page))
 660                         goto truncate_out;
 661                 f2fs_put_page(page, 1);
 662                 return 0;
 663         }
 664
 665         page = f2fs_get_lock_data_page(inode, index, true);
 666         if (IS_ERR(page))
 667                 return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
 668 truncate_out:
 669         f2fs_wait_on_page_writeback(page, DATA, true, true);
 670         zero_user(page, offset, PAGE_SIZE - offset);
 671
 672         /* An encrypted inode should have a key and truncate the last page. */
 673         f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode));
 674         if (!cache_only)
 675                 set_page_dirty(page);
 676         f2fs_put_page(page, 1);
 677         return 0;
 678 }
 679
 680 int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
 681 {
 682         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 683         struct dnode_of_data dn;
 684         pgoff_t free_from;
 685         int count = 0, err = 0;
 686         struct page *ipage;
 687         bool truncate_page = false;
 688
 689         trace_f2fs_truncate_blocks_enter(inode, from);
 690
 691         free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
 692
 693         if (free_from >= max_file_blocks(inode))
 694                 goto free_partial;
 695
 696         if (lock)
 697                 f2fs_lock_op(sbi);
 698
 699         ipage = f2fs_get_node_page(sbi, inode->i_ino);
 700         if (IS_ERR(ipage)) {
 701                 err = PTR_ERR(ipage);
 702                 goto out;
 703         }
 704
 705         if (f2fs_has_inline_data(inode)) {
 706                 f2fs_truncate_inline_inode(inode, ipage, from);
 707                 f2fs_put_page(ipage, 1);
 708                 truncate_page = true;
 709                 goto out;
 710         }
 711
 712         set_new_dnode(&dn, inode, ipage, NULL, 0);
 713         err = f2fs_get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
 714         if (err) {
 715                 if (err == -ENOENT)
 716                         goto free_next;
 717                 goto out;
 718         }
 719
 720         count = ADDRS_PER_PAGE(dn.node_page, inode);
 721
 722         count -= dn.ofs_in_node;
 723         f2fs_bug_on(sbi, count < 0);
 724
 725         if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
 726                 f2fs_truncate_data_blocks_range(&dn, count);
 727                 free_from += count;
 728         }
 729
 730         f2fs_put_dnode(&dn);
 731 free_next:
 732         err = f2fs_truncate_inode_blocks(inode, free_from);
 733 out:
 734         if (lock)
 735                 f2fs_unlock_op(sbi);
 736 free_partial:
 737         /* lastly zero out the first data page */
 738         if (!err)
 739                 err = truncate_partial_data_page(inode, from, truncate_page);
 740
 741         trace_f2fs_truncate_blocks_exit(inode, err);
 742         return err;
 743 }
 744
 745 int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
 746 {
 747         u64 free_from = from;
 748         int err;
 749
 750 #ifdef CONFIG_F2FS_FS_COMPRESSION
 751         /*
 752          * for compressed file, only support cluster size
 753          * aligned truncation.
 754          */
 755         if (f2fs_compressed_file(inode))
 756                 free_from = round_up(from,
 757                                 F2FS_I(inode)->i_cluster_size << PAGE_SHIFT);
 758 #endif
 759
 760         err = f2fs_do_truncate_blocks(inode, free_from, lock);
 761         if (err)
 762                 return err;
 763
 764 #ifdef CONFIG_F2FS_FS_COMPRESSION
 765         /*
 766          * For compressed file, after release compress blocks, don't allow write
 767          * direct, but we should allow write direct after truncate to zero.
 768          */
 769         if (f2fs_compressed_file(inode) && !free_from
 770                         && is_inode_flag_set(inode, FI_COMPRESS_RELEASED))
 771                 clear_inode_flag(inode, FI_COMPRESS_RELEASED);
 772
 773         if (from != free_from) {
 774                 err = f2fs_truncate_partial_cluster(inode, from, lock);
 775                 if (err)
 776                         return err;
 777         }
 778 #endif
 779
 780         return 0;
 781 }
 782
 783 int f2fs_truncate(struct inode *inode)
 784 {
 785         int err;
 786
 787         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
 788                 return -EIO;
 789
 790         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 791                                 S_ISLNK(inode->i_mode)))
 792                 return 0;
 793
 794         trace_f2fs_truncate(inode);
 795
 796         if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE))
 797                 return -EIO;
 798
 799         err = f2fs_dquot_initialize(inode);
 800         if (err)
 801                 return err;
 802
 803         /* we should check inline_data size */
 804         if (!f2fs_may_inline_data(inode)) {
 805                 err = f2fs_convert_inline_inode(inode);
 806                 if (err)
 807                         return err;
 808         }
 809
 810         err = f2fs_truncate_blocks(inode, i_size_read(inode), true);
 811         if (err)
 812                 return err;
 813
 814         inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
 815         f2fs_mark_inode_dirty_sync(inode, false);
 816         return 0;
 817 }
 818
 819 static bool f2fs_force_buffered_io(struct inode *inode, int rw)
 820 {
 821         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 822
 823         if (!fscrypt_dio_supported(inode))
 824                 return true;
 825         if (fsverity_active(inode))
 826                 return true;
 827         if (f2fs_compressed_file(inode))
 828                 return true;
 829
 830         /* disallow direct IO if any of devices has unaligned blksize */
 831         if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize)
 832                 return true;
 833         /*
 834          * for blkzoned device, fallback direct IO to buffered IO, so
 835          * all IOs can be serialized by log-structured write.
 836          */
 837         if (f2fs_sb_has_blkzoned(sbi) && (rw == WRITE))
 838                 return true;
 839         if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))
 840                 return true;
 841
 842         return false;
 843 }
 844
 845 int f2fs_getattr(struct mnt_idmap *idmap, const struct path *path,
 846                  struct kstat *stat, u32 request_mask, unsigned int query_flags)
 847 {
 848         struct inode *inode = d_inode(path->dentry);
 849         struct f2fs_inode_info *fi = F2FS_I(inode);
 850         struct f2fs_inode *ri = NULL;
 851         unsigned int flags;
 852
 853         if (f2fs_has_extra_attr(inode) &&
 854                         f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
 855                         F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
 856                 stat->result_mask |= STATX_BTIME;
 857                 stat->btime.tv_sec = fi->i_crtime.tv_sec;
 858                 stat->btime.tv_nsec = fi->i_crtime.tv_nsec;
 859         }
 860
 861         /*
 862          * Return the DIO alignment restrictions if requested.  We only return
 863          * this information when requested, since on encrypted files it might
 864          * take a fair bit of work to get if the file wasn't opened recently.
 865          *
 866          * f2fs sometimes supports DIO reads but not DIO writes.  STATX_DIOALIGN
 867          * cannot represent that, so in that case we report no DIO support.
 868          */
 869         if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->i_mode)) {
 870                 unsigned int bsize = i_blocksize(inode);
 871
 872                 stat->result_mask |= STATX_DIOALIGN;
 873                 if (!f2fs_force_buffered_io(inode, WRITE)) {
 874                         stat->dio_mem_align = bsize;
 875                         stat->dio_offset_align = bsize;
 876                 }
 877         }
 878
 879         flags = fi->i_flags;
 880         if (flags & F2FS_COMPR_FL)
 881                 stat->attributes |= STATX_ATTR_COMPRESSED;
 882         if (flags & F2FS_APPEND_FL)
 883                 stat->attributes |= STATX_ATTR_APPEND;
 884         if (IS_ENCRYPTED(inode))
 885                 stat->attributes |= STATX_ATTR_ENCRYPTED;
 886         if (flags & F2FS_IMMUTABLE_FL)
 887                 stat->attributes |= STATX_ATTR_IMMUTABLE;
 888         if (flags & F2FS_NODUMP_FL)
 889                 stat->attributes |= STATX_ATTR_NODUMP;
 890         if (IS_VERITY(inode))
 891                 stat->attributes |= STATX_ATTR_VERITY;
 892
 893         stat->attributes_mask |= (STATX_ATTR_COMPRESSED |
 894                                   STATX_ATTR_APPEND |
 895                                   STATX_ATTR_ENCRYPTED |
 896                                   STATX_ATTR_IMMUTABLE |
 897                                   STATX_ATTR_NODUMP |
 898                                   STATX_ATTR_VERITY);
 899
 900         generic_fillattr(idmap, request_mask, inode, stat);
 901
 902         /* we need to show initial sectors used for inline_data/dentries */
 903         if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) ||
 904                                         f2fs_has_inline_dentry(inode))
 905                 stat->blocks += (stat->size + 511) >> 9;
 906
 907         return 0;
 908 }
 909
 910 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 911 static void __setattr_copy(struct mnt_idmap *idmap,
 912                            struct inode *inode, const struct iattr *attr)
 913 {
 914         unsigned int ia_valid = attr->ia_valid;
 915
 916         i_uid_update(idmap, attr, inode);
 917         i_gid_update(idmap, attr, inode);
 918         if (ia_valid & ATTR_ATIME)
 919                 inode_set_atime_to_ts(inode, attr->ia_atime);
 920         if (ia_valid & ATTR_MTIME)
 921                 inode_set_mtime_to_ts(inode, attr->ia_mtime);
 922         if (ia_valid & ATTR_CTIME)
 923                 inode_set_ctime_to_ts(inode, attr->ia_ctime);
 924         if (ia_valid & ATTR_MODE) {
 925                 umode_t mode = attr->ia_mode;
 926                 vfsgid_t vfsgid = i_gid_into_vfsgid(idmap, inode);
 927
 928                 if (!vfsgid_in_group_p(vfsgid) &&
 929                     !capable_wrt_inode_uidgid(idmap, inode, CAP_FSETID))
 930                         mode &= ~S_ISGID;
 931                 set_acl_inode(inode, mode);
 932         }
 933 }
 934 #else
 935 #define __setattr_copy setattr_copy
 936 #endif
 937
 938 int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
 939                  struct iattr *attr)
 940 {
 941         struct inode *inode = d_inode(dentry);
 942         int err;
 943
 944         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
 945                 return -EIO;
 946
 947         if (unlikely(IS_IMMUTABLE(inode)))
 948                 return -EPERM;
 949
 950         if (unlikely(IS_APPEND(inode) &&
 951                         (attr->ia_valid & (ATTR_MODE | ATTR_UID |
 952                                   ATTR_GID | ATTR_TIMES_SET))))
 953                 return -EPERM;
 954
 955         if ((attr->ia_valid & ATTR_SIZE) &&
 956                 !f2fs_is_compress_backend_ready(inode))
 957                 return -EOPNOTSUPP;
 958
 959         err = setattr_prepare(idmap, dentry, attr);
 960         if (err)
 961                 return err;
 962
 963         err = fscrypt_prepare_setattr(dentry, attr);
 964         if (err)
 965                 return err;
 966
 967         err = fsverity_prepare_setattr(dentry, attr);
 968         if (err)
 969                 return err;
 970
 971         if (is_quota_modification(idmap, inode, attr)) {
 972                 err = f2fs_dquot_initialize(inode);
 973                 if (err)
 974                         return err;
 975         }
 976         if (i_uid_needs_update(idmap, attr, inode) ||
 977             i_gid_needs_update(idmap, attr, inode)) {
 978                 f2fs_lock_op(F2FS_I_SB(inode));
 979                 err = dquot_transfer(idmap, inode, attr);
 980                 if (err) {
 981                         set_sbi_flag(F2FS_I_SB(inode),
 982                                         SBI_QUOTA_NEED_REPAIR);
 983                         f2fs_unlock_op(F2FS_I_SB(inode));
 984                         return err;
 985                 }
 986                 /*
 987                  * update uid/gid under lock_op(), so that dquot and inode can
 988                  * be updated atomically.
 989                  */
 990                 i_uid_update(idmap, attr, inode);
 991                 i_gid_update(idmap, attr, inode);
 992                 f2fs_mark_inode_dirty_sync(inode, true);
 993                 f2fs_unlock_op(F2FS_I_SB(inode));
 994         }
 995
 996         if (attr->ia_valid & ATTR_SIZE) {
 997                 loff_t old_size = i_size_read(inode);
 998
 999                 if (attr->ia_size > MAX_INLINE_DATA(inode)) {
1000                         /*
1001                          * should convert inline inode before i_size_write to
1002                          * keep smaller than inline_data size with inline flag.
1003                          */
1004                         err = f2fs_convert_inline_inode(inode);
1005                         if (err)
1006                                 return err;
1007                 }
1008
1009                 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1010                 filemap_invalidate_lock(inode->i_mapping);
1011
1012                 truncate_setsize(inode, attr->ia_size);
1013
1014                 if (attr->ia_size <= old_size)
1015                         err = f2fs_truncate(inode);
1016                 /*
1017                  * do not trim all blocks after i_size if target size is
1018                  * larger than i_size.
1019                  */
1020                 filemap_invalidate_unlock(inode->i_mapping);
1021                 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1022                 if (err)
1023                         return err;
1024
1025                 spin_lock(&F2FS_I(inode)->i_size_lock);
1026                 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
1027                 F2FS_I(inode)->last_disk_size = i_size_read(inode);
1028                 spin_unlock(&F2FS_I(inode)->i_size_lock);
1029         }
1030
1031         __setattr_copy(idmap, inode, attr);
1032
1033         if (attr->ia_valid & ATTR_MODE) {
1034                 err = posix_acl_chmod(idmap, dentry, f2fs_get_inode_mode(inode));
1035
1036                 if (is_inode_flag_set(inode, FI_ACL_MODE)) {
1037                         if (!err)
1038                                 inode->i_mode = F2FS_I(inode)->i_acl_mode;
1039                         clear_inode_flag(inode, FI_ACL_MODE);
1040                 }
1041         }
1042
1043         /* file size may changed here */
1044         f2fs_mark_inode_dirty_sync(inode, true);
1045
1046         /* inode change will produce dirty node pages flushed by checkpoint */
1047         f2fs_balance_fs(F2FS_I_SB(inode), true);
1048
1049         return err;
1050 }
1051
1052 const struct inode_operations f2fs_file_inode_operations = {
1053         .getattr        = f2fs_getattr,
1054         .setattr        = f2fs_setattr,
1055         .get_inode_acl  = f2fs_get_acl,
1056         .set_acl        = f2fs_set_acl,
1057         .listxattr      = f2fs_listxattr,
1058         .fiemap         = f2fs_fiemap,
1059         .fileattr_get   = f2fs_fileattr_get,
1060         .fileattr_set   = f2fs_fileattr_set,
1061 };
1062
1063 static int fill_zero(struct inode *inode, pgoff_t index,
1064                                         loff_t start, loff_t len)
1065 {
1066         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1067         struct page *page;
1068
1069         if (!len)
1070                 return 0;
1071
1072         f2fs_balance_fs(sbi, true);
1073
1074         f2fs_lock_op(sbi);
1075         page = f2fs_get_new_data_page(inode, NULL, index, false);
1076         f2fs_unlock_op(sbi);
1077
1078         if (IS_ERR(page))
1079                 return PTR_ERR(page);
1080
1081         f2fs_wait_on_page_writeback(page, DATA, true, true);
1082         zero_user(page, start, len);
1083         set_page_dirty(page);
1084         f2fs_put_page(page, 1);
1085         return 0;
1086 }
1087
1088 int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
1089 {
1090         int err;
1091
1092         while (pg_start < pg_end) {
1093                 struct dnode_of_data dn;
1094                 pgoff_t end_offset, count;
1095
1096                 set_new_dnode(&dn, inode, NULL, NULL, 0);
1097                 err = f2fs_get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
1098                 if (err) {
1099                         if (err == -ENOENT) {
1100                                 pg_start = f2fs_get_next_page_offset(&dn,
1101                                                                 pg_start);
1102                                 continue;
1103                         }
1104                         return err;
1105                 }
1106
1107                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1108                 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
1109
1110                 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
1111
1112                 f2fs_truncate_data_blocks_range(&dn, count);
1113                 f2fs_put_dnode(&dn);
1114
1115                 pg_start += count;
1116         }
1117         return 0;
1118 }
1119
1120 static int f2fs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
1121 {
1122         pgoff_t pg_start, pg_end;
1123         loff_t off_start, off_end;
1124         int ret;
1125
1126         ret = f2fs_convert_inline_inode(inode);
1127         if (ret)
1128                 return ret;
1129
1130         pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1131         pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1132
1133         off_start = offset & (PAGE_SIZE - 1);
1134         off_end = (offset + len) & (PAGE_SIZE - 1);
1135
1136         if (pg_start == pg_end) {
1137                 ret = fill_zero(inode, pg_start, off_start,
1138                                                 off_end - off_start);
1139                 if (ret)
1140                         return ret;
1141         } else {
1142                 if (off_start) {
1143                         ret = fill_zero(inode, pg_start++, off_start,
1144                                                 PAGE_SIZE - off_start);
1145                         if (ret)
1146                                 return ret;
1147                 }
1148                 if (off_end) {
1149                         ret = fill_zero(inode, pg_end, 0, off_end);
1150                         if (ret)
1151                                 return ret;
1152                 }
1153
1154                 if (pg_start < pg_end) {
1155                         loff_t blk_start, blk_end;
1156                         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1157
1158                         f2fs_balance_fs(sbi, true);
1159
1160                         blk_start = (loff_t)pg_start << PAGE_SHIFT;
1161                         blk_end = (loff_t)pg_end << PAGE_SHIFT;
1162
1163                         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1164                         filemap_invalidate_lock(inode->i_mapping);
1165
1166                         truncate_pagecache_range(inode, blk_start, blk_end - 1);
1167
1168                         f2fs_lock_op(sbi);
1169                         ret = f2fs_truncate_hole(inode, pg_start, pg_end);
1170                         f2fs_unlock_op(sbi);
1171
1172                         filemap_invalidate_unlock(inode->i_mapping);
1173                         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1174                 }
1175         }
1176
1177         return ret;
1178 }
1179
1180 static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
1181                                 int *do_replace, pgoff_t off, pgoff_t len)
1182 {
1183         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1184         struct dnode_of_data dn;
1185         int ret, done, i;
1186
1187 next_dnode:
1188         set_new_dnode(&dn, inode, NULL, NULL, 0);
1189         ret = f2fs_get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
1190         if (ret && ret != -ENOENT) {
1191                 return ret;
1192         } else if (ret == -ENOENT) {
1193                 if (dn.max_level == 0)
1194                         return -ENOENT;
1195                 done = min((pgoff_t)ADDRS_PER_BLOCK(inode) -
1196                                                 dn.ofs_in_node, len);
1197                 blkaddr += done;
1198                 do_replace += done;
1199                 goto next;
1200         }
1201
1202         done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
1203                                                         dn.ofs_in_node, len);
1204         for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
1205                 *blkaddr = f2fs_data_blkaddr(&dn);
1206
1207                 if (__is_valid_data_blkaddr(*blkaddr) &&
1208                         !f2fs_is_valid_blkaddr(sbi, *blkaddr,
1209                                         DATA_GENERIC_ENHANCE)) {
1210                         f2fs_put_dnode(&dn);
1211                         return -EFSCORRUPTED;
1212                 }
1213
1214                 if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) {
1215
1216                         if (f2fs_lfs_mode(sbi)) {
1217                                 f2fs_put_dnode(&dn);
1218                                 return -EOPNOTSUPP;
1219                         }
1220
1221                         /* do not invalidate this block address */
1222                         f2fs_update_data_blkaddr(&dn, NULL_ADDR);
1223                         *do_replace = 1;
1224                 }
1225         }
1226         f2fs_put_dnode(&dn);
1227 next:
1228         len -= done;
1229         off += done;
1230         if (len)
1231                 goto next_dnode;
1232         return 0;
1233 }
1234
1235 static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
1236                                 int *do_replace, pgoff_t off, int len)
1237 {
1238         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1239         struct dnode_of_data dn;
1240         int ret, i;
1241
1242         for (i = 0; i < len; i++, do_replace++, blkaddr++) {
1243                 if (*do_replace == 0)
1244                         continue;
1245
1246                 set_new_dnode(&dn, inode, NULL, NULL, 0);
1247                 ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
1248                 if (ret) {
1249                         dec_valid_block_count(sbi, inode, 1);
1250                         f2fs_invalidate_blocks(sbi, *blkaddr);
1251                 } else {
1252                         f2fs_update_data_blkaddr(&dn, *blkaddr);
1253                 }
1254                 f2fs_put_dnode(&dn);
1255         }
1256         return 0;
1257 }
1258
1259 static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
1260                         block_t *blkaddr, int *do_replace,
1261                         pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
1262 {
1263         struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
1264         pgoff_t i = 0;
1265         int ret;
1266
1267         while (i < len) {
1268                 if (blkaddr[i] == NULL_ADDR && !full) {
1269                         i++;
1270                         continue;
1271                 }
1272
1273                 if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
1274                         struct dnode_of_data dn;
1275                         struct node_info ni;
1276                         size_t new_size;
1277                         pgoff_t ilen;
1278
1279                         set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
1280                         ret = f2fs_get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
1281                         if (ret)
1282                                 return ret;
1283
1284                         ret = f2fs_get_node_info(sbi, dn.nid, &ni, false);
1285                         if (ret) {
1286                                 f2fs_put_dnode(&dn);
1287                                 return ret;
1288                         }
1289
1290                         ilen = min((pgoff_t)
1291                                 ADDRS_PER_PAGE(dn.node_page, dst_inode) -
1292                                                 dn.ofs_in_node, len - i);
1293                         do {
1294                                 dn.data_blkaddr = f2fs_data_blkaddr(&dn);
1295                                 f2fs_truncate_data_blocks_range(&dn, 1);
1296
1297                                 if (do_replace[i]) {
1298                                         f2fs_i_blocks_write(src_inode,
1299                                                         1, false, false);
1300                                         f2fs_i_blocks_write(dst_inode,
1301                                                         1, true, false);
1302                                         f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
1303                                         blkaddr[i], ni.version, true, false);
1304
1305                                         do_replace[i] = 0;
1306                                 }
1307                                 dn.ofs_in_node++;
1308                                 i++;
1309                                 new_size = (loff_t)(dst + i) << PAGE_SHIFT;
1310                                 if (dst_inode->i_size < new_size)
1311                                         f2fs_i_size_write(dst_inode, new_size);
1312                         } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));
1313
1314                         f2fs_put_dnode(&dn);
1315                 } else {
1316                         struct page *psrc, *pdst;
1317
1318                         psrc = f2fs_get_lock_data_page(src_inode,
1319                                                         src + i, true);
1320                         if (IS_ERR(psrc))
1321                                 return PTR_ERR(psrc);
1322                         pdst = f2fs_get_new_data_page(dst_inode, NULL, dst + i,
1323                                                                 true);
1324                         if (IS_ERR(pdst)) {
1325                                 f2fs_put_page(psrc, 1);
1326                                 return PTR_ERR(pdst);
1327                         }
1328                         memcpy_page(pdst, 0, psrc, 0, PAGE_SIZE);
1329                         set_page_dirty(pdst);
1330                         set_page_private_gcing(pdst);
1331                         f2fs_put_page(pdst, 1);
1332                         f2fs_put_page(psrc, 1);
1333
1334                         ret = f2fs_truncate_hole(src_inode,
1335                                                 src + i, src + i + 1);
1336                         if (ret)
1337                                 return ret;
1338                         i++;
1339                 }
1340         }
1341         return 0;
1342 }
1343
1344 static int __exchange_data_block(struct inode *src_inode,
1345                         struct inode *dst_inode, pgoff_t src, pgoff_t dst,
1346                         pgoff_t len, bool full)
1347 {
1348         block_t *src_blkaddr;
1349         int *do_replace;
1350         pgoff_t olen;
1351         int ret;
1352
1353         while (len) {
1354                 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK(src_inode), len);
1355
1356                 src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode),
1357                                         array_size(olen, sizeof(block_t)),
1358                                         GFP_NOFS);
1359                 if (!src_blkaddr)
1360                         return -ENOMEM;
1361
1362                 do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode),
1363                                         array_size(olen, sizeof(int)),
1364                                         GFP_NOFS);
1365                 if (!do_replace) {
1366                         kvfree(src_blkaddr);
1367                         return -ENOMEM;
1368                 }
1369
1370                 ret = __read_out_blkaddrs(src_inode, src_blkaddr,
1371                                         do_replace, src, olen);
1372                 if (ret)
1373                         goto roll_back;
1374
1375                 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
1376                                         do_replace, src, dst, olen, full);
1377                 if (ret)
1378                         goto roll_back;
1379
1380                 src += olen;
1381                 dst += olen;
1382                 len -= olen;
1383
1384                 kvfree(src_blkaddr);
1385                 kvfree(do_replace);
1386         }
1387         return 0;
1388
1389 roll_back:
1390         __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, olen);
1391         kvfree(src_blkaddr);
1392         kvfree(do_replace);
1393         return ret;
1394 }
1395
1396 static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
1397 {
1398         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1399         pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1400         pgoff_t start = offset >> PAGE_SHIFT;
1401         pgoff_t end = (offset + len) >> PAGE_SHIFT;
1402         int ret;
1403
1404         f2fs_balance_fs(sbi, true);
1405
1406         /* avoid gc operation during block exchange */
1407         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1408         filemap_invalidate_lock(inode->i_mapping);
1409
1410         f2fs_lock_op(sbi);
1411         f2fs_drop_extent_tree(inode);
1412         truncate_pagecache(inode, offset);
1413         ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1414         f2fs_unlock_op(sbi);
1415
1416         filemap_invalidate_unlock(inode->i_mapping);
1417         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1418         return ret;
1419 }
1420
1421 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1422 {
1423         loff_t new_size;
1424         int ret;
1425
1426         if (offset + len >= i_size_read(inode))
1427                 return -EINVAL;
1428
1429         /* collapse range should be aligned to block size of f2fs. */
1430         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1431                 return -EINVAL;
1432
1433         ret = f2fs_convert_inline_inode(inode);
1434         if (ret)
1435                 return ret;
1436
1437         /* write out all dirty pages from offset */
1438         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1439         if (ret)
1440                 return ret;
1441
1442         ret = f2fs_do_collapse(inode, offset, len);
1443         if (ret)
1444                 return ret;
1445
1446         /* write out all moved pages, if possible */
1447         filemap_invalidate_lock(inode->i_mapping);
1448         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1449         truncate_pagecache(inode, offset);
1450
1451         new_size = i_size_read(inode) - len;
1452         ret = f2fs_truncate_blocks(inode, new_size, true);
1453         filemap_invalidate_unlock(inode->i_mapping);
1454         if (!ret)
1455                 f2fs_i_size_write(inode, new_size);
1456         return ret;
1457 }
1458
1459 static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
1460                                                                 pgoff_t end)
1461 {
1462         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
1463         pgoff_t index = start;
1464         unsigned int ofs_in_node = dn->ofs_in_node;
1465         blkcnt_t count = 0;
1466         int ret;
1467
1468         for (; index < end; index++, dn->ofs_in_node++) {
1469                 if (f2fs_data_blkaddr(dn) == NULL_ADDR)
1470                         count++;
1471         }
1472
1473         dn->ofs_in_node = ofs_in_node;
1474         ret = f2fs_reserve_new_blocks(dn, count);
1475         if (ret)
1476                 return ret;
1477
1478         dn->ofs_in_node = ofs_in_node;
1479         for (index = start; index < end; index++, dn->ofs_in_node++) {
1480                 dn->data_blkaddr = f2fs_data_blkaddr(dn);
1481                 /*
1482                  * f2fs_reserve_new_blocks will not guarantee entire block
1483                  * allocation.
1484                  */
1485                 if (dn->data_blkaddr == NULL_ADDR) {
1486                         ret = -ENOSPC;
1487                         break;
1488                 }
1489
1490                 if (dn->data_blkaddr == NEW_ADDR)
1491                         continue;
1492
1493                 if (!f2fs_is_valid_blkaddr(sbi, dn->data_blkaddr,
1494                                         DATA_GENERIC_ENHANCE)) {
1495                         ret = -EFSCORRUPTED;
1496                         break;
1497                 }
1498
1499                 f2fs_invalidate_blocks(sbi, dn->data_blkaddr);
1500                 f2fs_set_data_blkaddr(dn, NEW_ADDR);
1501         }
1502
1503         f2fs_update_read_extent_cache_range(dn, start, 0, index - start);
1504         f2fs_update_age_extent_cache_range(dn, start, index - start);
1505
1506         return ret;
1507 }
1508
1509 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
1510                                                                 int mode)
1511 {
1512         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1513         struct address_space *mapping = inode->i_mapping;
1514         pgoff_t index, pg_start, pg_end;
1515         loff_t new_size = i_size_read(inode);
1516         loff_t off_start, off_end;
1517         int ret = 0;
1518
1519         ret = inode_newsize_ok(inode, (len + offset));
1520         if (ret)
1521                 return ret;
1522
1523         ret = f2fs_convert_inline_inode(inode);
1524         if (ret)
1525                 return ret;
1526
1527         ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
1528         if (ret)
1529                 return ret;
1530
1531         pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1532         pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1533
1534         off_start = offset & (PAGE_SIZE - 1);
1535         off_end = (offset + len) & (PAGE_SIZE - 1);
1536
1537         if (pg_start == pg_end) {
1538                 ret = fill_zero(inode, pg_start, off_start,
1539                                                 off_end - off_start);
1540                 if (ret)
1541                         return ret;
1542
1543                 new_size = max_t(loff_t, new_size, offset + len);
1544         } else {
1545                 if (off_start) {
1546                         ret = fill_zero(inode, pg_start++, off_start,
1547                                                 PAGE_SIZE - off_start);
1548                         if (ret)
1549                                 return ret;
1550
1551                         new_size = max_t(loff_t, new_size,
1552                                         (loff_t)pg_start << PAGE_SHIFT);
1553                 }
1554
1555                 for (index = pg_start; index < pg_end;) {
1556                         struct dnode_of_data dn;
1557                         unsigned int end_offset;
1558                         pgoff_t end;
1559
1560                         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1561                         filemap_invalidate_lock(mapping);
1562
1563                         truncate_pagecache_range(inode,
1564                                 (loff_t)index << PAGE_SHIFT,
1565                                 ((loff_t)pg_end << PAGE_SHIFT) - 1);
1566
1567                         f2fs_lock_op(sbi);
1568
1569                         set_new_dnode(&dn, inode, NULL, NULL, 0);
1570                         ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
1571                         if (ret) {
1572                                 f2fs_unlock_op(sbi);
1573                                 filemap_invalidate_unlock(mapping);
1574                                 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1575                                 goto out;
1576                         }
1577
1578                         end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1579                         end = min(pg_end, end_offset - dn.ofs_in_node + index);
1580
1581                         ret = f2fs_do_zero_range(&dn, index, end);
1582                         f2fs_put_dnode(&dn);
1583
1584                         f2fs_unlock_op(sbi);
1585                         filemap_invalidate_unlock(mapping);
1586                         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1587
1588                         f2fs_balance_fs(sbi, dn.node_changed);
1589
1590                         if (ret)
1591                                 goto out;
1592
1593                         index = end;
1594                         new_size = max_t(loff_t, new_size,
1595                                         (loff_t)index << PAGE_SHIFT);
1596                 }
1597
1598                 if (off_end) {
1599                         ret = fill_zero(inode, pg_end, 0, off_end);
1600                         if (ret)
1601                                 goto out;
1602
1603                         new_size = max_t(loff_t, new_size, offset + len);
1604                 }
1605         }
1606
1607 out:
1608         if (new_size > i_size_read(inode)) {
1609                 if (mode & FALLOC_FL_KEEP_SIZE)
1610                         file_set_keep_isize(inode);
1611                 else
1612                         f2fs_i_size_write(inode, new_size);
1613         }
1614         return ret;
1615 }
1616
1617 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1618 {
1619         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1620         struct address_space *mapping = inode->i_mapping;
1621         pgoff_t nr, pg_start, pg_end, delta, idx;
1622         loff_t new_size;
1623         int ret = 0;
1624
1625         new_size = i_size_read(inode) + len;
1626         ret = inode_newsize_ok(inode, new_size);
1627         if (ret)
1628                 return ret;
1629
1630         if (offset >= i_size_read(inode))
1631                 return -EINVAL;
1632
1633         /* insert range should be aligned to block size of f2fs. */
1634         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1635                 return -EINVAL;
1636
1637         ret = f2fs_convert_inline_inode(inode);
1638         if (ret)
1639                 return ret;
1640
1641         f2fs_balance_fs(sbi, true);
1642
1643         filemap_invalidate_lock(mapping);
1644         ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);
1645         filemap_invalidate_unlock(mapping);
1646         if (ret)
1647                 return ret;
1648
1649         /* write out all dirty pages from offset */
1650         ret = filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
1651         if (ret)
1652                 return ret;
1653
1654         pg_start = offset >> PAGE_SHIFT;
1655         pg_end = (offset + len) >> PAGE_SHIFT;
1656         delta = pg_end - pg_start;
1657         idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1658
1659         /* avoid gc operation during block exchange */
1660         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1661         filemap_invalidate_lock(mapping);
1662         truncate_pagecache(inode, offset);
1663
1664         while (!ret && idx > pg_start) {
1665                 nr = idx - pg_start;
1666                 if (nr > delta)
1667                         nr = delta;
1668                 idx -= nr;
1669
1670                 f2fs_lock_op(sbi);
1671                 f2fs_drop_extent_tree(inode);
1672
1673                 ret = __exchange_data_block(inode, inode, idx,
1674                                         idx + delta, nr, false);
1675                 f2fs_unlock_op(sbi);
1676         }
1677         filemap_invalidate_unlock(mapping);
1678         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1679         if (ret)
1680                 return ret;
1681
1682         /* write out all moved pages, if possible */
1683         filemap_invalidate_lock(mapping);
1684         ret = filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
1685         truncate_pagecache(inode, offset);
1686         filemap_invalidate_unlock(mapping);
1687
1688         if (!ret)
1689                 f2fs_i_size_write(inode, new_size);
1690         return ret;
1691 }
1692
1693 static int f2fs_expand_inode_data(struct inode *inode, loff_t offset,
1694                                         loff_t len, int mode)
1695 {
1696         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1697         struct f2fs_map_blocks map = { .m_next_pgofs = NULL,
1698                         .m_next_extent = NULL, .m_seg_type = NO_CHECK_TYPE,
1699                         .m_may_create = true };
1700         struct f2fs_gc_control gc_control = { .victim_segno = NULL_SEGNO,
1701                         .init_gc_type = FG_GC,
1702                         .should_migrate_blocks = false,
1703                         .err_gc_skipped = true,
1704                         .nr_free_secs = 0 };
1705         pgoff_t pg_start, pg_end;
1706         loff_t new_size;
1707         loff_t off_end;
1708         block_t expanded = 0;
1709         int err;
1710
1711         err = inode_newsize_ok(inode, (len + offset));
1712         if (err)
1713                 return err;
1714
1715         err = f2fs_convert_inline_inode(inode);
1716         if (err)
1717                 return err;
1718
1719         f2fs_balance_fs(sbi, true);
1720
1721         pg_start = ((unsigned long long)offset) >> PAGE_SHIFT;
1722         pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
1723         off_end = (offset + len) & (PAGE_SIZE - 1);
1724
1725         map.m_lblk = pg_start;
1726         map.m_len = pg_end - pg_start;
1727         if (off_end)
1728                 map.m_len++;
1729
1730         if (!map.m_len)
1731                 return 0;
1732
1733         if (f2fs_is_pinned_file(inode)) {
1734                 block_t sec_blks = CAP_BLKS_PER_SEC(sbi);
1735                 block_t sec_len = roundup(map.m_len, sec_blks);
1736
1737                 map.m_len = sec_blks;
1738 next_alloc:
1739                 if (has_not_enough_free_secs(sbi, 0,
1740                         GET_SEC_FROM_SEG(sbi, overprovision_segments(sbi)))) {
1741                         f2fs_down_write(&sbi->gc_lock);
1742                         stat_inc_gc_call_count(sbi, FOREGROUND);
1743                         err = f2fs_gc(sbi, &gc_control);
1744                         if (err && err != -ENODATA)
1745                                 goto out_err;
1746                 }
1747
1748                 f2fs_down_write(&sbi->pin_sem);
1749
1750                 err = f2fs_allocate_pinning_section(sbi);
1751                 if (err) {
1752                         f2fs_up_write(&sbi->pin_sem);
1753                         goto out_err;
1754                 }
1755
1756                 map.m_seg_type = CURSEG_COLD_DATA_PINNED;
1757                 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_DIO);
1758                 file_dont_truncate(inode);
1759
1760                 f2fs_up_write(&sbi->pin_sem);
1761
1762                 expanded += map.m_len;
1763                 sec_len -= map.m_len;
1764                 map.m_lblk += map.m_len;
1765                 if (!err && sec_len)
1766                         goto next_alloc;
1767
1768                 map.m_len = expanded;
1769         } else {
1770                 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
1771                 expanded = map.m_len;
1772         }
1773 out_err:
1774         if (err) {
1775                 pgoff_t last_off;
1776
1777                 if (!expanded)
1778                         return err;
1779
1780                 last_off = pg_start + expanded - 1;
1781
1782                 /* update new size to the failed position */
1783                 new_size = (last_off == pg_end) ? offset + len :
1784                                         (loff_t)(last_off + 1) << PAGE_SHIFT;
1785         } else {
1786                 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
1787         }
1788
1789         if (new_size > i_size_read(inode)) {
1790                 if (mode & FALLOC_FL_KEEP_SIZE)
1791                         file_set_keep_isize(inode);
1792                 else
1793                         f2fs_i_size_write(inode, new_size);
1794         }
1795
1796         return err;
1797 }
1798
1799 static long f2fs_fallocate(struct file *file, int mode,
1800                                 loff_t offset, loff_t len)
1801 {
1802         struct inode *inode = file_inode(file);
1803         long ret = 0;
1804
1805         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
1806                 return -EIO;
1807         if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
1808                 return -ENOSPC;
1809         if (!f2fs_is_compress_backend_ready(inode))
1810                 return -EOPNOTSUPP;
1811
1812         /* f2fs only support ->fallocate for regular file */
1813         if (!S_ISREG(inode->i_mode))
1814                 return -EINVAL;
1815
1816         if (IS_ENCRYPTED(inode) &&
1817                 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
1818                 return -EOPNOTSUPP;
1819
1820         /*
1821          * Pinned file should not support partial truncation since the block
1822          * can be used by applications.
1823          */
1824         if ((f2fs_compressed_file(inode) || f2fs_is_pinned_file(inode)) &&
1825                 (mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_COLLAPSE_RANGE |
1826                         FALLOC_FL_ZERO_RANGE | FALLOC_FL_INSERT_RANGE)))
1827                 return -EOPNOTSUPP;
1828
1829         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1830                         FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
1831                         FALLOC_FL_INSERT_RANGE))
1832                 return -EOPNOTSUPP;
1833
1834         inode_lock(inode);
1835
1836         ret = file_modified(file);
1837         if (ret)
1838                 goto out;
1839
1840         if (mode & FALLOC_FL_PUNCH_HOLE) {
1841                 if (offset >= inode->i_size)
1842                         goto out;
1843
1844                 ret = f2fs_punch_hole(inode, offset, len);
1845         } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1846                 ret = f2fs_collapse_range(inode, offset, len);
1847         } else if (mode & FALLOC_FL_ZERO_RANGE) {
1848                 ret = f2fs_zero_range(inode, offset, len, mode);
1849         } else if (mode & FALLOC_FL_INSERT_RANGE) {
1850                 ret = f2fs_insert_range(inode, offset, len);
1851         } else {
1852                 ret = f2fs_expand_inode_data(inode, offset, len, mode);
1853         }
1854
1855         if (!ret) {
1856                 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
1857                 f2fs_mark_inode_dirty_sync(inode, false);
1858                 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1859         }
1860
1861 out:
1862         inode_unlock(inode);
1863
1864         trace_f2fs_fallocate(inode, mode, offset, len, ret);
1865         return ret;
1866 }
1867
1868 static int f2fs_release_file(struct inode *inode, struct file *filp)
1869 {
1870         /*
1871          * f2fs_release_file is called at every close calls. So we should
1872          * not drop any inmemory pages by close called by other process.
1873          */
1874         if (!(filp->f_mode & FMODE_WRITE) ||
1875                         atomic_read(&inode->i_writecount) != 1)
1876                 return 0;
1877
1878         inode_lock(inode);
1879         f2fs_abort_atomic_write(inode, true);
1880         inode_unlock(inode);
1881
1882         return 0;
1883 }
1884
1885 static int f2fs_file_flush(struct file *file, fl_owner_t id)
1886 {
1887         struct inode *inode = file_inode(file);
1888
1889         /*
1890          * If the process doing a transaction is crashed, we should do
1891          * roll-back. Otherwise, other reader/write can see corrupted database
1892          * until all the writers close its file. Since this should be done
1893          * before dropping file lock, it needs to do in ->flush.
1894          */
1895         if (F2FS_I(inode)->atomic_write_task == current &&
1896                                 (current->flags & PF_EXITING)) {
1897                 inode_lock(inode);
1898                 f2fs_abort_atomic_write(inode, true);
1899                 inode_unlock(inode);
1900         }
1901
1902         return 0;
1903 }
1904
1905 static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)
1906 {
1907         struct f2fs_inode_info *fi = F2FS_I(inode);
1908         u32 masked_flags = fi->i_flags & mask;
1909
1910         /* mask can be shrunk by flags_valid selector */
1911         iflags &= mask;
1912
1913         /* Is it quota file? Do not allow user to mess with it */
1914         if (IS_NOQUOTA(inode))
1915                 return -EPERM;
1916
1917         if ((iflags ^ masked_flags) & F2FS_CASEFOLD_FL) {
1918                 if (!f2fs_sb_has_casefold(F2FS_I_SB(inode)))
1919                         return -EOPNOTSUPP;
1920                 if (!f2fs_empty_dir(inode))
1921                         return -ENOTEMPTY;
1922         }
1923
1924         if (iflags & (F2FS_COMPR_FL | F2FS_NOCOMP_FL)) {
1925                 if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
1926                         return -EOPNOTSUPP;
1927                 if ((iflags & F2FS_COMPR_FL) && (iflags & F2FS_NOCOMP_FL))
1928                         return -EINVAL;
1929         }
1930
1931         if ((iflags ^ masked_flags) & F2FS_COMPR_FL) {
1932                 if (masked_flags & F2FS_COMPR_FL) {
1933                         if (!f2fs_disable_compressed_file(inode))
1934                                 return -EINVAL;
1935                 } else {
1936                         /* try to convert inline_data to support compression */
1937                         int err = f2fs_convert_inline_inode(inode);
1938                         if (err)
1939                                 return err;
1940
1941                         f2fs_down_write(&F2FS_I(inode)->i_sem);
1942                         if (!f2fs_may_compress(inode) ||
1943                                         (S_ISREG(inode->i_mode) &&
1944                                         F2FS_HAS_BLOCKS(inode))) {
1945                                 f2fs_up_write(&F2FS_I(inode)->i_sem);
1946                                 return -EINVAL;
1947                         }
1948                         err = set_compress_context(inode);
1949                         f2fs_up_write(&F2FS_I(inode)->i_sem);
1950
1951                         if (err)
1952                                 return err;
1953                 }
1954         }
1955
1956         fi->i_flags = iflags | (fi->i_flags & ~mask);
1957         f2fs_bug_on(F2FS_I_SB(inode), (fi->i_flags & F2FS_COMPR_FL) &&
1958                                         (fi->i_flags & F2FS_NOCOMP_FL));
1959
1960         if (fi->i_flags & F2FS_PROJINHERIT_FL)
1961                 set_inode_flag(inode, FI_PROJ_INHERIT);
1962         else
1963                 clear_inode_flag(inode, FI_PROJ_INHERIT);
1964
1965         inode_set_ctime_current(inode);
1966         f2fs_set_inode_flags(inode);
1967         f2fs_mark_inode_dirty_sync(inode, true);
1968         return 0;
1969 }
1970
1971 /* FS_IOC_[GS]ETFLAGS and FS_IOC_FS[GS]ETXATTR support */
1972
1973 /*
1974  * To make a new on-disk f2fs i_flag gettable via FS_IOC_GETFLAGS, add an entry
1975  * for it to f2fs_fsflags_map[], and add its FS_*_FL equivalent to
1976  * F2FS_GETTABLE_FS_FL.  To also make it settable via FS_IOC_SETFLAGS, also add
1977  * its FS_*_FL equivalent to F2FS_SETTABLE_FS_FL.
1978  *
1979  * Translating flags to fsx_flags value used by FS_IOC_FSGETXATTR and
1980  * FS_IOC_FSSETXATTR is done by the VFS.
1981  */
1982
1983 static const struct {
1984         u32 iflag;
1985         u32 fsflag;
1986 } f2fs_fsflags_map[] = {
1987         { F2FS_COMPR_FL,        FS_COMPR_FL },
1988         { F2FS_SYNC_FL,         FS_SYNC_FL },
1989         { F2FS_IMMUTABLE_FL,    FS_IMMUTABLE_FL },
1990         { F2FS_APPEND_FL,       FS_APPEND_FL },
1991         { F2FS_NODUMP_FL,       FS_NODUMP_FL },
1992         { F2FS_NOATIME_FL,      FS_NOATIME_FL },
1993         { F2FS_NOCOMP_FL,       FS_NOCOMP_FL },
1994         { F2FS_INDEX_FL,        FS_INDEX_FL },
1995         { F2FS_DIRSYNC_FL,      FS_DIRSYNC_FL },
1996         { F2FS_PROJINHERIT_FL,  FS_PROJINHERIT_FL },
1997         { F2FS_CASEFOLD_FL,     FS_CASEFOLD_FL },
1998 };
1999
2000 #define F2FS_GETTABLE_FS_FL (           \
2001                 FS_COMPR_FL |           \
2002                 FS_SYNC_FL |            \
2003                 FS_IMMUTABLE_FL |       \
2004                 FS_APPEND_FL |          \
2005                 FS_NODUMP_FL |          \
2006                 FS_NOATIME_FL |         \
2007                 FS_NOCOMP_FL |          \
2008                 FS_INDEX_FL |           \
2009                 FS_DIRSYNC_FL |         \
2010                 FS_PROJINHERIT_FL |     \
2011                 FS_ENCRYPT_FL |         \
2012                 FS_INLINE_DATA_FL |     \
2013                 FS_NOCOW_FL |           \
2014                 FS_VERITY_FL |          \
2015                 FS_CASEFOLD_FL)
2016
2017 #define F2FS_SETTABLE_FS_FL (           \
2018                 FS_COMPR_FL |           \
2019                 FS_SYNC_FL |            \
2020                 FS_IMMUTABLE_FL |       \
2021                 FS_APPEND_FL |          \
2022                 FS_NODUMP_FL |          \
2023                 FS_NOATIME_FL |         \
2024                 FS_NOCOMP_FL |          \
2025                 FS_DIRSYNC_FL |         \
2026                 FS_PROJINHERIT_FL |     \
2027                 FS_CASEFOLD_FL)
2028
2029 /* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
2030 static inline u32 f2fs_iflags_to_fsflags(u32 iflags)
2031 {
2032         u32 fsflags = 0;
2033         int i;
2034
2035         for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
2036                 if (iflags & f2fs_fsflags_map[i].iflag)
2037                         fsflags |= f2fs_fsflags_map[i].fsflag;
2038
2039         return fsflags;
2040 }
2041
2042 /* Convert FS_IOC_{GET,SET}FLAGS flags to f2fs on-disk i_flags */
2043 static inline u32 f2fs_fsflags_to_iflags(u32 fsflags)
2044 {
2045         u32 iflags = 0;
2046         int i;
2047
2048         for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
2049                 if (fsflags & f2fs_fsflags_map[i].fsflag)
2050                         iflags |= f2fs_fsflags_map[i].iflag;
2051
2052         return iflags;
2053 }
2054
2055 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
2056 {
2057         struct inode *inode = file_inode(filp);
2058
2059         return put_user(inode->i_generation, (int __user *)arg);
2060 }
2061
2062 static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
2063 {
2064         struct inode *inode = file_inode(filp);
2065         struct mnt_idmap *idmap = file_mnt_idmap(filp);
2066         struct f2fs_inode_info *fi = F2FS_I(inode);
2067         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2068         struct inode *pinode;
2069         loff_t isize;
2070         int ret;
2071
2072         if (!inode_owner_or_capable(idmap, inode))
2073                 return -EACCES;
2074
2075         if (!S_ISREG(inode->i_mode))
2076                 return -EINVAL;
2077
2078         if (filp->f_flags & O_DIRECT)
2079                 return -EINVAL;
2080
2081         ret = mnt_want_write_file(filp);
2082         if (ret)
2083                 return ret;
2084
2085         inode_lock(inode);
2086
2087         if (!f2fs_disable_compressed_file(inode) ||
2088                         f2fs_is_pinned_file(inode)) {
2089                 ret = -EINVAL;
2090                 goto out;
2091         }
2092
2093         if (f2fs_is_atomic_file(inode))
2094                 goto out;
2095
2096         ret = f2fs_convert_inline_inode(inode);
2097         if (ret)
2098                 goto out;
2099
2100         f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
2101
2102         /*
2103          * Should wait end_io to count F2FS_WB_CP_DATA correctly by
2104          * f2fs_is_atomic_file.
2105          */
2106         if (get_dirty_pages(inode))
2107                 f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2108                           inode->i_ino, get_dirty_pages(inode));
2109         ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
2110         if (ret) {
2111                 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2112                 goto out;
2113         }
2114
2115         /* Check if the inode already has a COW inode */
2116         if (fi->cow_inode == NULL) {
2117                 /* Create a COW inode for atomic write */
2118                 pinode = f2fs_iget(inode->i_sb, fi->i_pino);
2119                 if (IS_ERR(pinode)) {
2120                         f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2121                         ret = PTR_ERR(pinode);
2122                         goto out;
2123                 }
2124
2125                 ret = f2fs_get_tmpfile(idmap, pinode, &fi->cow_inode);
2126                 iput(pinode);
2127                 if (ret) {
2128                         f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2129                         goto out;
2130                 }
2131
2132                 set_inode_flag(fi->cow_inode, FI_COW_FILE);
2133                 clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
2134         } else {
2135                 /* Reuse the already created COW inode */
2136                 ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
2137                 if (ret) {
2138                         f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2139                         goto out;
2140                 }
2141         }
2142
2143         f2fs_write_inode(inode, NULL);
2144
2145         stat_inc_atomic_inode(inode);
2146
2147         set_inode_flag(inode, FI_ATOMIC_FILE);
2148
2149         isize = i_size_read(inode);
2150         fi->original_i_size = isize;
2151         if (truncate) {
2152                 set_inode_flag(inode, FI_ATOMIC_REPLACE);
2153                 truncate_inode_pages_final(inode->i_mapping);
2154                 f2fs_i_size_write(inode, 0);
2155                 isize = 0;
2156         }
2157         f2fs_i_size_write(fi->cow_inode, isize);
2158
2159         f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2160
2161         f2fs_update_time(sbi, REQ_TIME);
2162         fi->atomic_write_task = current;
2163         stat_update_max_atomic_write(inode);
2164         fi->atomic_write_cnt = 0;
2165 out:
2166         inode_unlock(inode);
2167         mnt_drop_write_file(filp);
2168         return ret;
2169 }
2170
2171 static int f2fs_ioc_commit_atomic_write(struct file *filp)
2172 {
2173         struct inode *inode = file_inode(filp);
2174         struct mnt_idmap *idmap = file_mnt_idmap(filp);
2175         int ret;
2176
2177         if (!inode_owner_or_capable(idmap, inode))
2178                 return -EACCES;
2179
2180         ret = mnt_want_write_file(filp);
2181         if (ret)
2182                 return ret;
2183
2184         f2fs_balance_fs(F2FS_I_SB(inode), true);
2185
2186         inode_lock(inode);
2187
2188         if (f2fs_is_atomic_file(inode)) {
2189                 ret = f2fs_commit_atomic_write(inode);
2190                 if (!ret)
2191                         ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
2192
2193                 f2fs_abort_atomic_write(inode, ret);
2194         } else {
2195                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
2196         }
2197
2198         inode_unlock(inode);
2199         mnt_drop_write_file(filp);
2200         return ret;
2201 }
2202
2203 static int f2fs_ioc_abort_atomic_write(struct file *filp)
2204 {
2205         struct inode *inode = file_inode(filp);
2206         struct mnt_idmap *idmap = file_mnt_idmap(filp);
2207         int ret;
2208
2209         if (!inode_owner_or_capable(idmap, inode))
2210                 return -EACCES;
2211
2212         ret = mnt_want_write_file(filp);
2213         if (ret)
2214                 return ret;
2215
2216         inode_lock(inode);
2217
2218         f2fs_abort_atomic_write(inode, true);
2219
2220         inode_unlock(inode);
2221
2222         mnt_drop_write_file(filp);
2223         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2224         return ret;
2225 }
2226
2227 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
2228 {
2229         struct inode *inode = file_inode(filp);
2230         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2231         struct super_block *sb = sbi->sb;
2232         __u32 in;
2233         int ret = 0;
2234
2235         if (!capable(CAP_SYS_ADMIN))
2236                 return -EPERM;
2237
2238         if (get_user(in, (__u32 __user *)arg))
2239                 return -EFAULT;
2240
2241         if (in != F2FS_GOING_DOWN_FULLSYNC) {
2242                 ret = mnt_want_write_file(filp);
2243                 if (ret) {
2244                         if (ret == -EROFS) {
2245                                 ret = 0;
2246                                 f2fs_stop_checkpoint(sbi, false,
2247                                                 STOP_CP_REASON_SHUTDOWN);
2248                                 trace_f2fs_shutdown(sbi, in, ret);
2249                         }
2250                         return ret;
2251                 }
2252         }
2253
2254         switch (in) {
2255         case F2FS_GOING_DOWN_FULLSYNC:
2256                 ret = bdev_freeze(sb->s_bdev);
2257                 if (ret)
2258                         goto out;
2259                 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2260                 bdev_thaw(sb->s_bdev);
2261                 break;
2262         case F2FS_GOING_DOWN_METASYNC:
2263                 /* do checkpoint only */
2264                 ret = f2fs_sync_fs(sb, 1);
2265                 if (ret) {
2266                         if (ret == -EIO)
2267                                 ret = 0;
2268                         goto out;
2269                 }
2270                 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2271                 break;
2272         case F2FS_GOING_DOWN_NOSYNC:
2273                 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2274                 break;
2275         case F2FS_GOING_DOWN_METAFLUSH:
2276                 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO);
2277                 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2278                 break;
2279         case F2FS_GOING_DOWN_NEED_FSCK:
2280                 set_sbi_flag(sbi, SBI_NEED_FSCK);
2281                 set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
2282                 set_sbi_flag(sbi, SBI_IS_DIRTY);
2283                 /* do checkpoint only */
2284                 ret = f2fs_sync_fs(sb, 1);
2285                 if (ret == -EIO)
2286                         ret = 0;
2287                 goto out;
2288         default:
2289                 ret = -EINVAL;
2290                 goto out;
2291         }
2292
2293         f2fs_stop_gc_thread(sbi);
2294         f2fs_stop_discard_thread(sbi);
2295
2296         f2fs_drop_discard_cmd(sbi);
2297         clear_opt(sbi, DISCARD);
2298
2299         f2fs_update_time(sbi, REQ_TIME);
2300 out:
2301         if (in != F2FS_GOING_DOWN_FULLSYNC)
2302                 mnt_drop_write_file(filp);
2303
2304         trace_f2fs_shutdown(sbi, in, ret);
2305
2306         return ret;
2307 }
2308
2309 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
2310 {
2311         struct inode *inode = file_inode(filp);
2312         struct super_block *sb = inode->i_sb;
2313         struct fstrim_range range;
2314         int ret;
2315
2316         if (!capable(CAP_SYS_ADMIN))
2317                 return -EPERM;
2318
2319         if (!f2fs_hw_support_discard(F2FS_SB(sb)))
2320                 return -EOPNOTSUPP;
2321
2322         if (copy_from_user(&range, (struct fstrim_range __user *)arg,
2323                                 sizeof(range)))
2324                 return -EFAULT;
2325
2326         ret = mnt_want_write_file(filp);
2327         if (ret)
2328                 return ret;
2329
2330         range.minlen = max((unsigned int)range.minlen,
2331                            bdev_discard_granularity(sb->s_bdev));
2332         ret = f2fs_trim_fs(F2FS_SB(sb), &range);
2333         mnt_drop_write_file(filp);
2334         if (ret < 0)
2335                 return ret;
2336
2337         if (copy_to_user((struct fstrim_range __user *)arg, &range,
2338                                 sizeof(range)))
2339                 return -EFAULT;
2340         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2341         return 0;
2342 }
2343
2344 static bool uuid_is_nonzero(__u8 u[16])
2345 {
2346         int i;
2347
2348         for (i = 0; i < 16; i++)
2349                 if (u[i])
2350                         return true;
2351         return false;
2352 }
2353
2354 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
2355 {
2356         struct inode *inode = file_inode(filp);
2357
2358         if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode)))
2359                 return -EOPNOTSUPP;
2360
2361         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2362
2363         return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
2364 }
2365
2366 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
2367 {
2368         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2369                 return -EOPNOTSUPP;
2370         return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
2371 }
2372
2373 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
2374 {
2375         struct inode *inode = file_inode(filp);
2376         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2377         u8 encrypt_pw_salt[16];
2378         int err;
2379
2380         if (!f2fs_sb_has_encrypt(sbi))
2381                 return -EOPNOTSUPP;
2382
2383         err = mnt_want_write_file(filp);
2384         if (err)
2385                 return err;
2386
2387         f2fs_down_write(&sbi->sb_lock);
2388
2389         if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
2390                 goto got_it;
2391
2392         /* update superblock with uuid */
2393         generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
2394
2395         err = f2fs_commit_super(sbi, false);
2396         if (err) {
2397                 /* undo new data */
2398                 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
2399                 goto out_err;
2400         }
2401 got_it:
2402         memcpy(encrypt_pw_salt, sbi->raw_super->encrypt_pw_salt, 16);
2403 out_err:
2404         f2fs_up_write(&sbi->sb_lock);
2405         mnt_drop_write_file(filp);
2406
2407         if (!err && copy_to_user((__u8 __user *)arg, encrypt_pw_salt, 16))
2408                 err = -EFAULT;
2409
2410         return err;
2411 }
2412
2413 static int f2fs_ioc_get_encryption_policy_ex(struct file *filp,
2414                                              unsigned long arg)
2415 {
2416         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2417                 return -EOPNOTSUPP;
2418
2419         return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg);
2420 }
2421
2422 static int f2fs_ioc_add_encryption_key(struct file *filp, unsigned long arg)
2423 {
2424         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2425                 return -EOPNOTSUPP;
2426
2427         return fscrypt_ioctl_add_key(filp, (void __user *)arg);
2428 }
2429
2430 static int f2fs_ioc_remove_encryption_key(struct file *filp, unsigned long arg)
2431 {
2432         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2433                 return -EOPNOTSUPP;
2434
2435         return fscrypt_ioctl_remove_key(filp, (void __user *)arg);
2436 }
2437
2438 static int f2fs_ioc_remove_encryption_key_all_users(struct file *filp,
2439                                                     unsigned long arg)
2440 {
2441         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2442                 return -EOPNOTSUPP;
2443
2444         return fscrypt_ioctl_remove_key_all_users(filp, (void __user *)arg);
2445 }
2446
2447 static int f2fs_ioc_get_encryption_key_status(struct file *filp,
2448                                               unsigned long arg)
2449 {
2450         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2451                 return -EOPNOTSUPP;
2452
2453         return fscrypt_ioctl_get_key_status(filp, (void __user *)arg);
2454 }
2455
2456 static int f2fs_ioc_get_encryption_nonce(struct file *filp, unsigned long arg)
2457 {
2458         if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2459                 return -EOPNOTSUPP;
2460
2461         return fscrypt_ioctl_get_nonce(filp, (void __user *)arg);
2462 }
2463
2464 static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
2465 {
2466         struct inode *inode = file_inode(filp);
2467         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2468         struct f2fs_gc_control gc_control = { .victim_segno = NULL_SEGNO,
2469                         .no_bg_gc = false,
2470                         .should_migrate_blocks = false,
2471                         .nr_free_secs = 0 };
2472         __u32 sync;
2473         int ret;
2474
2475         if (!capable(CAP_SYS_ADMIN))
2476                 return -EPERM;
2477
2478         if (get_user(sync, (__u32 __user *)arg))
2479                 return -EFAULT;
2480
2481         if (f2fs_readonly(sbi->sb))
2482                 return -EROFS;
2483
2484         ret = mnt_want_write_file(filp);
2485         if (ret)
2486                 return ret;
2487
2488         if (!sync) {
2489                 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2490                         ret = -EBUSY;
2491                         goto out;
2492                 }
2493         } else {
2494                 f2fs_down_write(&sbi->gc_lock);
2495         }
2496
2497         gc_control.init_gc_type = sync ? FG_GC : BG_GC;
2498         gc_control.err_gc_skipped = sync;
2499         stat_inc_gc_call_count(sbi, FOREGROUND);
2500         ret = f2fs_gc(sbi, &gc_control);
2501 out:
2502         mnt_drop_write_file(filp);
2503         return ret;
2504 }
2505
2506 static int __f2fs_ioc_gc_range(struct file *filp, struct f2fs_gc_range *range)
2507 {
2508         struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
2509         struct f2fs_gc_control gc_control = {
2510                         .init_gc_type = range->sync ? FG_GC : BG_GC,
2511                         .no_bg_gc = false,
2512                         .should_migrate_blocks = false,
2513                         .err_gc_skipped = range->sync,
2514                         .nr_free_secs = 0 };
2515         u64 end;
2516         int ret;
2517
2518         if (!capable(CAP_SYS_ADMIN))
2519                 return -EPERM;
2520         if (f2fs_readonly(sbi->sb))
2521                 return -EROFS;
2522
2523         end = range->start + range->len;
2524         if (end < range->start || range->start < MAIN_BLKADDR(sbi) ||
2525                                         end >= MAX_BLKADDR(sbi))
2526                 return -EINVAL;
2527
2528         ret = mnt_want_write_file(filp);
2529         if (ret)
2530                 return ret;
2531
2532 do_more:
2533         if (!range->sync) {
2534                 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2535                         ret = -EBUSY;
2536                         goto out;
2537                 }
2538         } else {
2539                 f2fs_down_write(&sbi->gc_lock);
2540         }
2541
2542         gc_control.victim_segno = GET_SEGNO(sbi, range->start);
2543         stat_inc_gc_call_count(sbi, FOREGROUND);
2544         ret = f2fs_gc(sbi, &gc_control);
2545         if (ret) {
2546                 if (ret == -EBUSY)
2547                         ret = -EAGAIN;
2548                 goto out;
2549         }
2550         range->start += CAP_BLKS_PER_SEC(sbi);
2551         if (range->start <= end)
2552                 goto do_more;
2553 out:
2554         mnt_drop_write_file(filp);
2555         return ret;
2556 }
2557
2558 static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg)
2559 {
2560         struct f2fs_gc_range range;
2561
2562         if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg,
2563                                                         sizeof(range)))
2564                 return -EFAULT;
2565         return __f2fs_ioc_gc_range(filp, &range);
2566 }
2567
2568 static int f2fs_ioc_write_checkpoint(struct file *filp)
2569 {
2570         struct inode *inode = file_inode(filp);
2571         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2572         int ret;
2573
2574         if (!capable(CAP_SYS_ADMIN))
2575                 return -EPERM;
2576
2577         if (f2fs_readonly(sbi->sb))
2578                 return -EROFS;
2579
2580         if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
2581                 f2fs_info(sbi, "Skipping Checkpoint. Checkpoints currently disabled.");
2582                 return -EINVAL;
2583         }
2584
2585         ret = mnt_want_write_file(filp);
2586         if (ret)
2587                 return ret;
2588
2589         ret = f2fs_sync_fs(sbi->sb, 1);
2590
2591         mnt_drop_write_file(filp);
2592         return ret;
2593 }
2594
2595 static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
2596                                         struct file *filp,
2597                                         struct f2fs_defragment *range)
2598 {
2599         struct inode *inode = file_inode(filp);
2600         struct f2fs_map_blocks map = { .m_next_extent = NULL,
2601                                         .m_seg_type = NO_CHECK_TYPE,
2602                                         .m_may_create = false };
2603         struct extent_info ei = {};
2604         pgoff_t pg_start, pg_end, next_pgofs;
2605         unsigned int total = 0, sec_num;
2606         block_t blk_end = 0;
2607         bool fragmented = false;
2608         int err;
2609
2610         pg_start = range->start >> PAGE_SHIFT;
2611         pg_end = (range->start + range->len) >> PAGE_SHIFT;
2612
2613         f2fs_balance_fs(sbi, true);
2614
2615         inode_lock(inode);
2616
2617         if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
2618                 err = -EINVAL;
2619                 goto unlock_out;
2620         }
2621
2622         /* if in-place-update policy is enabled, don't waste time here */
2623         set_inode_flag(inode, FI_OPU_WRITE);
2624         if (f2fs_should_update_inplace(inode, NULL)) {
2625                 err = -EINVAL;
2626                 goto out;
2627         }
2628
2629         /* writeback all dirty pages in the range */
2630         err = filemap_write_and_wait_range(inode->i_mapping, range->start,
2631                                                 range->start + range->len - 1);
2632         if (err)
2633                 goto out;
2634
2635         /*
2636          * lookup mapping info in extent cache, skip defragmenting if physical
2637          * block addresses are continuous.
2638          */
2639         if (f2fs_lookup_read_extent_cache(inode, pg_start, &ei)) {
2640                 if (ei.fofs + ei.len >= pg_end)
2641                         goto out;
2642         }
2643
2644         map.m_lblk = pg_start;
2645         map.m_next_pgofs = &next_pgofs;
2646
2647         /*
2648          * lookup mapping info in dnode page cache, skip defragmenting if all
2649          * physical block addresses are continuous even if there are hole(s)
2650          * in logical blocks.
2651          */
2652         while (map.m_lblk < pg_end) {
2653                 map.m_len = pg_end - map.m_lblk;
2654                 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
2655                 if (err)
2656                         goto out;
2657
2658                 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2659                         map.m_lblk = next_pgofs;
2660                         continue;
2661                 }
2662
2663                 if (blk_end && blk_end != map.m_pblk)
2664                         fragmented = true;
2665
2666                 /* record total count of block that we're going to move */
2667                 total += map.m_len;
2668
2669                 blk_end = map.m_pblk + map.m_len;
2670
2671                 map.m_lblk += map.m_len;
2672         }
2673
2674         if (!fragmented) {
2675                 total = 0;
2676                 goto out;
2677         }
2678
2679         sec_num = DIV_ROUND_UP(total, CAP_BLKS_PER_SEC(sbi));
2680
2681         /*
2682          * make sure there are enough free section for LFS allocation, this can
2683          * avoid defragment running in SSR mode when free section are allocated
2684          * intensively
2685          */
2686         if (has_not_enough_free_secs(sbi, 0, sec_num)) {
2687                 err = -EAGAIN;
2688                 goto out;
2689         }
2690
2691         map.m_lblk = pg_start;
2692         map.m_len = pg_end - pg_start;
2693         total = 0;
2694
2695         while (map.m_lblk < pg_end) {
2696                 pgoff_t idx;
2697                 int cnt = 0;
2698
2699 do_map:
2700                 map.m_len = pg_end - map.m_lblk;
2701                 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
2702                 if (err)
2703                         goto clear_out;
2704
2705                 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2706                         map.m_lblk = next_pgofs;
2707                         goto check;
2708                 }
2709
2710                 set_inode_flag(inode, FI_SKIP_WRITES);
2711
2712                 idx = map.m_lblk;
2713                 while (idx < map.m_lblk + map.m_len &&
2714                                                 cnt < BLKS_PER_SEG(sbi)) {
2715                         struct page *page;
2716
2717                         page = f2fs_get_lock_data_page(inode, idx, true);
2718                         if (IS_ERR(page)) {
2719                                 err = PTR_ERR(page);
2720                                 goto clear_out;
2721                         }
2722
2723                         set_page_dirty(page);
2724                         set_page_private_gcing(page);
2725                         f2fs_put_page(page, 1);
2726
2727                         idx++;
2728                         cnt++;
2729                         total++;
2730                 }
2731
2732                 map.m_lblk = idx;
2733 check:
2734                 if (map.m_lblk < pg_end && cnt < BLKS_PER_SEG(sbi))
2735                         goto do_map;
2736
2737                 clear_inode_flag(inode, FI_SKIP_WRITES);
2738
2739                 err = filemap_fdatawrite(inode->i_mapping);
2740                 if (err)
2741                         goto out;
2742         }
2743 clear_out:
2744         clear_inode_flag(inode, FI_SKIP_WRITES);
2745 out:
2746         clear_inode_flag(inode, FI_OPU_WRITE);
2747 unlock_out:
2748         inode_unlock(inode);
2749         if (!err)
2750                 range->len = (u64)total << PAGE_SHIFT;
2751         return err;
2752 }
2753
2754 static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
2755 {
2756         struct inode *inode = file_inode(filp);
2757         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2758         struct f2fs_defragment range;
2759         int err;
2760
2761         if (!capable(CAP_SYS_ADMIN))
2762                 return -EPERM;
2763
2764         if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode))
2765                 return -EINVAL;
2766
2767         if (f2fs_readonly(sbi->sb))
2768                 return -EROFS;
2769
2770         if (copy_from_user(&range, (struct f2fs_defragment __user *)arg,
2771                                                         sizeof(range)))
2772                 return -EFAULT;
2773
2774         /* verify alignment of offset & size */
2775         if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2776                 return -EINVAL;
2777
2778         if (unlikely((range.start + range.len) >> PAGE_SHIFT >
2779                                         max_file_blocks(inode)))
2780                 return -EINVAL;
2781
2782         err = mnt_want_write_file(filp);
2783         if (err)
2784                 return err;
2785
2786         err = f2fs_defragment_range(sbi, filp, &range);
2787         mnt_drop_write_file(filp);
2788
2789         f2fs_update_time(sbi, REQ_TIME);
2790         if (err < 0)
2791                 return err;
2792
2793         if (copy_to_user((struct f2fs_defragment __user *)arg, &range,
2794                                                         sizeof(range)))
2795                 return -EFAULT;
2796
2797         return 0;
2798 }
2799
2800 static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2801                         struct file *file_out, loff_t pos_out, size_t len)
2802 {
2803         struct inode *src = file_inode(file_in);
2804         struct inode *dst = file_inode(file_out);
2805         struct f2fs_sb_info *sbi = F2FS_I_SB(src);
2806         size_t olen = len, dst_max_i_size = 0;
2807         size_t dst_osize;
2808         int ret;
2809
2810         if (file_in->f_path.mnt != file_out->f_path.mnt ||
2811                                 src->i_sb != dst->i_sb)
2812                 return -EXDEV;
2813
2814         if (unlikely(f2fs_readonly(src->i_sb)))
2815                 return -EROFS;
2816
2817         if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))
2818                 return -EINVAL;
2819
2820         if (IS_ENCRYPTED(src) || IS_ENCRYPTED(dst))
2821                 return -EOPNOTSUPP;
2822
2823         if (pos_out < 0 || pos_in < 0)
2824                 return -EINVAL;
2825
2826         if (src == dst) {
2827                 if (pos_in == pos_out)
2828                         return 0;
2829                 if (pos_out > pos_in && pos_out < pos_in + len)
2830                         return -EINVAL;
2831         }
2832
2833         inode_lock(src);
2834         if (src != dst) {
2835                 ret = -EBUSY;
2836                 if (!inode_trylock(dst))
2837                         goto out;
2838         }
2839
2840         if (f2fs_compressed_file(src) || f2fs_compressed_file(dst)) {
2841                 ret = -EOPNOTSUPP;
2842                 goto out_unlock;
2843         }
2844
2845         ret = -EINVAL;
2846         if (pos_in + len > src->i_size || pos_in + len < pos_in)
2847                 goto out_unlock;
2848         if (len == 0)
2849                 olen = len = src->i_size - pos_in;
2850         if (pos_in + len == src->i_size)
2851                 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
2852         if (len == 0) {
2853                 ret = 0;
2854                 goto out_unlock;
2855         }
2856
2857         dst_osize = dst->i_size;
2858         if (pos_out + olen > dst->i_size)
2859                 dst_max_i_size = pos_out + olen;
2860
2861         /* verify the end result is block aligned */
2862         if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
2863                         !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
2864                         !IS_ALIGNED(pos_out, F2FS_BLKSIZE))
2865                 goto out_unlock;
2866
2867         ret = f2fs_convert_inline_inode(src);
2868         if (ret)
2869                 goto out_unlock;
2870
2871         ret = f2fs_convert_inline_inode(dst);
2872         if (ret)
2873                 goto out_unlock;
2874
2875         /* write out all dirty pages from offset */
2876         ret = filemap_write_and_wait_range(src->i_mapping,
2877                                         pos_in, pos_in + len);
2878         if (ret)
2879                 goto out_unlock;
2880
2881         ret = filemap_write_and_wait_range(dst->i_mapping,
2882                                         pos_out, pos_out + len);
2883         if (ret)
2884                 goto out_unlock;
2885
2886         f2fs_balance_fs(sbi, true);
2887
2888         f2fs_down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2889         if (src != dst) {
2890                 ret = -EBUSY;
2891                 if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
2892                         goto out_src;
2893         }
2894
2895         f2fs_lock_op(sbi);
2896         ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2897                                 pos_out >> F2FS_BLKSIZE_BITS,
2898                                 len >> F2FS_BLKSIZE_BITS, false);
2899
2900         if (!ret) {
2901                 if (dst_max_i_size)
2902                         f2fs_i_size_write(dst, dst_max_i_size);
2903                 else if (dst_osize != dst->i_size)
2904                         f2fs_i_size_write(dst, dst_osize);
2905         }
2906         f2fs_unlock_op(sbi);
2907
2908         if (src != dst)
2909                 f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
2910 out_src:
2911         f2fs_up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2912         if (ret)
2913                 goto out_unlock;
2914
2915         inode_set_mtime_to_ts(src, inode_set_ctime_current(src));
2916         f2fs_mark_inode_dirty_sync(src, false);
2917         if (src != dst) {
2918                 inode_set_mtime_to_ts(dst, inode_set_ctime_current(dst));
2919                 f2fs_mark_inode_dirty_sync(dst, false);
2920         }
2921         f2fs_update_time(sbi, REQ_TIME);
2922
2923 out_unlock:
2924         if (src != dst)
2925                 inode_unlock(dst);
2926 out:
2927         inode_unlock(src);
2928         return ret;
2929 }
2930
2931 static int __f2fs_ioc_move_range(struct file *filp,
2932                                 struct f2fs_move_range *range)
2933 {
2934         struct fd dst;
2935         int err;
2936
2937         if (!(filp->f_mode & FMODE_READ) ||
2938                         !(filp->f_mode & FMODE_WRITE))
2939                 return -EBADF;
2940
2941         dst = fdget(range->dst_fd);
2942         if (!dst.file)
2943                 return -EBADF;
2944
2945         if (!(dst.file->f_mode & FMODE_WRITE)) {
2946                 err = -EBADF;
2947                 goto err_out;
2948         }
2949
2950         err = mnt_want_write_file(filp);
2951         if (err)
2952                 goto err_out;
2953
2954         err = f2fs_move_file_range(filp, range->pos_in, dst.file,
2955                                         range->pos_out, range->len);
2956
2957         mnt_drop_write_file(filp);
2958 err_out:
2959         fdput(dst);
2960         return err;
2961 }
2962
2963 static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
2964 {
2965         struct f2fs_move_range range;
2966
2967         if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
2968                                                         sizeof(range)))
2969                 return -EFAULT;
2970         return __f2fs_ioc_move_range(filp, &range);
2971 }
2972
2973 static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
2974 {
2975         struct inode *inode = file_inode(filp);
2976         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2977         struct sit_info *sm = SIT_I(sbi);
2978         unsigned int start_segno = 0, end_segno = 0;
2979         unsigned int dev_start_segno = 0, dev_end_segno = 0;
2980         struct f2fs_flush_device range;
2981         struct f2fs_gc_control gc_control = {
2982                         .init_gc_type = FG_GC,
2983                         .should_migrate_blocks = true,
2984                         .err_gc_skipped = true,
2985                         .nr_free_secs = 0 };
2986         int ret;
2987
2988         if (!capable(CAP_SYS_ADMIN))
2989                 return -EPERM;
2990
2991         if (f2fs_readonly(sbi->sb))
2992                 return -EROFS;
2993
2994         if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
2995                 return -EINVAL;
2996
2997         if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
2998                                                         sizeof(range)))
2999                 return -EFAULT;
3000
3001         if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num ||
3002                         __is_large_section(sbi)) {
3003                 f2fs_warn(sbi, "Can't flush %u in %d for SEGS_PER_SEC %u != 1",
3004                           range.dev_num, sbi->s_ndevs, SEGS_PER_SEC(sbi));
3005                 return -EINVAL;
3006         }
3007
3008         ret = mnt_want_write_file(filp);
3009         if (ret)
3010                 return ret;
3011
3012         if (range.dev_num != 0)
3013                 dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk);
3014         dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
3015
3016         start_segno = sm->last_victim[FLUSH_DEVICE];
3017         if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
3018                 start_segno = dev_start_segno;
3019         end_segno = min(start_segno + range.segments, dev_end_segno);
3020
3021         while (start_segno < end_segno) {
3022                 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
3023                         ret = -EBUSY;
3024                         goto out;
3025                 }
3026                 sm->last_victim[GC_CB] = end_segno + 1;
3027                 sm->last_victim[GC_GREEDY] = end_segno + 1;
3028                 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
3029
3030                 gc_control.victim_segno = start_segno;
3031                 stat_inc_gc_call_count(sbi, FOREGROUND);
3032                 ret = f2fs_gc(sbi, &gc_control);
3033                 if (ret == -EAGAIN)
3034                         ret = 0;
3035                 else if (ret < 0)
3036                         break;
3037                 start_segno++;
3038         }
3039 out:
3040         mnt_drop_write_file(filp);
3041         return ret;
3042 }
3043
3044 static int f2fs_ioc_get_features(struct file *filp, unsigned long arg)
3045 {
3046         struct inode *inode = file_inode(filp);
3047         u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature);
3048
3049         /* Must validate to set it with SQLite behavior in Android. */
3050         sb_feature |= F2FS_FEATURE_ATOMIC_WRITE;
3051
3052         return put_user(sb_feature, (u32 __user *)arg);
3053 }
3054
3055 #ifdef CONFIG_QUOTA
3056 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid)
3057 {
3058         struct dquot *transfer_to[MAXQUOTAS] = {};
3059         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3060         struct super_block *sb = sbi->sb;
3061         int err;
3062
3063         transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
3064         if (IS_ERR(transfer_to[PRJQUOTA]))
3065                 return PTR_ERR(transfer_to[PRJQUOTA]);
3066
3067         err = __dquot_transfer(inode, transfer_to);
3068         if (err)
3069                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3070         dqput(transfer_to[PRJQUOTA]);
3071         return err;
3072 }
3073
3074 static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
3075 {
3076         struct f2fs_inode_info *fi = F2FS_I(inode);
3077         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3078         struct f2fs_inode *ri = NULL;
3079         kprojid_t kprojid;
3080         int err;
3081
3082         if (!f2fs_sb_has_project_quota(sbi)) {
3083                 if (projid != F2FS_DEF_PROJID)
3084                         return -EOPNOTSUPP;
3085                 else
3086                         return 0;
3087         }
3088
3089         if (!f2fs_has_extra_attr(inode))
3090                 return -EOPNOTSUPP;
3091
3092         kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
3093
3094         if (projid_eq(kprojid, fi->i_projid))
3095                 return 0;
3096
3097         err = -EPERM;
3098         /* Is it quota file? Do not allow user to mess with it */
3099         if (IS_NOQUOTA(inode))
3100                 return err;
3101
3102         if (!F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid))
3103                 return -EOVERFLOW;
3104
3105         err = f2fs_dquot_initialize(inode);
3106         if (err)
3107                 return err;
3108
3109         f2fs_lock_op(sbi);
3110         err = f2fs_transfer_project_quota(inode, kprojid);
3111         if (err)
3112                 goto out_unlock;
3113
3114         fi->i_projid = kprojid;
3115         inode_set_ctime_current(inode);
3116         f2fs_mark_inode_dirty_sync(inode, true);
3117 out_unlock:
3118         f2fs_unlock_op(sbi);
3119         return err;
3120 }
3121 #else
3122 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid)
3123 {
3124         return 0;
3125 }
3126
3127 static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
3128 {
3129         if (projid != F2FS_DEF_PROJID)
3130                 return -EOPNOTSUPP;
3131         return 0;
3132 }
3133 #endif
3134
3135 int f2fs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
3136 {
3137         struct inode *inode = d_inode(dentry);
3138         struct f2fs_inode_info *fi = F2FS_I(inode);
3139         u32 fsflags = f2fs_iflags_to_fsflags(fi->i_flags);
3140
3141         if (IS_ENCRYPTED(inode))
3142                 fsflags |= FS_ENCRYPT_FL;
3143         if (IS_VERITY(inode))
3144                 fsflags |= FS_VERITY_FL;
3145         if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode))
3146                 fsflags |= FS_INLINE_DATA_FL;
3147         if (is_inode_flag_set(inode, FI_PIN_FILE))
3148                 fsflags |= FS_NOCOW_FL;
3149
3150         fileattr_fill_flags(fa, fsflags & F2FS_GETTABLE_FS_FL);
3151
3152         if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)))
3153                 fa->fsx_projid = from_kprojid(&init_user_ns, fi->i_projid);
3154
3155         return 0;
3156 }
3157
3158 int f2fs_fileattr_set(struct mnt_idmap *idmap,
3159                       struct dentry *dentry, struct fileattr *fa)
3160 {
3161         struct inode *inode = d_inode(dentry);
3162         u32 fsflags = fa->flags, mask = F2FS_SETTABLE_FS_FL;
3163         u32 iflags;
3164         int err;
3165
3166         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
3167                 return -EIO;
3168         if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
3169                 return -ENOSPC;
3170         if (fsflags & ~F2FS_GETTABLE_FS_FL)
3171                 return -EOPNOTSUPP;
3172         fsflags &= F2FS_SETTABLE_FS_FL;
3173         if (!fa->flags_valid)
3174                 mask &= FS_COMMON_FL;
3175
3176         iflags = f2fs_fsflags_to_iflags(fsflags);
3177         if (f2fs_mask_flags(inode->i_mode, iflags) != iflags)
3178                 return -EOPNOTSUPP;
3179
3180         err = f2fs_setflags_common(inode, iflags, f2fs_fsflags_to_iflags(mask));
3181         if (!err)
3182                 err = f2fs_ioc_setproject(inode, fa->fsx_projid);
3183
3184         return err;
3185 }
3186
3187 int f2fs_pin_file_control(struct inode *inode, bool inc)
3188 {
3189         struct f2fs_inode_info *fi = F2FS_I(inode);
3190         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3191
3192         /* Use i_gc_failures for normal file as a risk signal. */
3193         if (inc)
3194                 f2fs_i_gc_failures_write(inode,
3195                                 fi->i_gc_failures[GC_FAILURE_PIN] + 1);
3196
3197         if (fi->i_gc_failures[GC_FAILURE_PIN] > sbi->gc_pin_file_threshold) {
3198                 f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
3199                           __func__, inode->i_ino,
3200                           fi->i_gc_failures[GC_FAILURE_PIN]);
3201                 clear_inode_flag(inode, FI_PIN_FILE);
3202                 return -EAGAIN;
3203         }
3204         return 0;
3205 }
3206
3207 static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
3208 {
3209         struct inode *inode = file_inode(filp);
3210         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3211         __u32 pin;
3212         int ret = 0;
3213
3214         if (get_user(pin, (__u32 __user *)arg))
3215                 return -EFAULT;
3216
3217         if (!S_ISREG(inode->i_mode))
3218                 return -EINVAL;
3219
3220         if (f2fs_readonly(sbi->sb))
3221                 return -EROFS;
3222
3223         ret = mnt_want_write_file(filp);
3224         if (ret)
3225                 return ret;
3226
3227         inode_lock(inode);
3228
3229         if (!pin) {
3230                 clear_inode_flag(inode, FI_PIN_FILE);
3231                 f2fs_i_gc_failures_write(inode, 0);
3232                 goto done;
3233         } else if (f2fs_is_pinned_file(inode)) {
3234                 goto done;
3235         }
3236
3237         if (f2fs_sb_has_blkzoned(sbi) && F2FS_HAS_BLOCKS(inode)) {
3238                 ret = -EFBIG;
3239                 goto out;
3240         }
3241
3242         /* Let's allow file pinning on zoned device. */
3243         if (!f2fs_sb_has_blkzoned(sbi) &&
3244             f2fs_should_update_outplace(inode, NULL)) {
3245                 ret = -EINVAL;
3246                 goto out;
3247         }
3248
3249         if (f2fs_pin_file_control(inode, false)) {
3250                 ret = -EAGAIN;
3251                 goto out;
3252         }
3253
3254         ret = f2fs_convert_inline_inode(inode);
3255         if (ret)
3256                 goto out;
3257
3258         if (!f2fs_disable_compressed_file(inode)) {
3259                 ret = -EOPNOTSUPP;
3260                 goto out;
3261         }
3262
3263         set_inode_flag(inode, FI_PIN_FILE);
3264         ret = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN];
3265 done:
3266         f2fs_update_time(sbi, REQ_TIME);
3267 out:
3268         inode_unlock(inode);
3269         mnt_drop_write_file(filp);
3270         return ret;
3271 }
3272
3273 static int f2fs_ioc_get_pin_file(struct file *filp, unsigned long arg)
3274 {
3275         struct inode *inode = file_inode(filp);
3276         __u32 pin = 0;
3277
3278         if (is_inode_flag_set(inode, FI_PIN_FILE))
3279                 pin = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN];
3280         return put_user(pin, (u32 __user *)arg);
3281 }
3282
3283 int f2fs_precache_extents(struct inode *inode)
3284 {
3285         struct f2fs_inode_info *fi = F2FS_I(inode);
3286         struct f2fs_map_blocks map;
3287         pgoff_t m_next_extent;
3288         loff_t end;
3289         int err;
3290
3291         if (is_inode_flag_set(inode, FI_NO_EXTENT))
3292                 return -EOPNOTSUPP;
3293
3294         map.m_lblk = 0;
3295         map.m_pblk = 0;
3296         map.m_next_pgofs = NULL;
3297         map.m_next_extent = &m_next_extent;
3298         map.m_seg_type = NO_CHECK_TYPE;
3299         map.m_may_create = false;
3300         end = F2FS_BLK_ALIGN(i_size_read(inode));
3301
3302         while (map.m_lblk < end) {
3303                 map.m_len = end - map.m_lblk;
3304
3305                 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
3306                 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRECACHE);
3307                 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
3308                 if (err || !map.m_len)
3309                         return err;
3310
3311                 map.m_lblk = m_next_extent;
3312         }
3313
3314         return 0;
3315 }
3316
3317 static int f2fs_ioc_precache_extents(struct file *filp)
3318 {
3319         return f2fs_precache_extents(file_inode(filp));
3320 }
3321
3322 static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg)
3323 {
3324         struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
3325         __u64 block_count;
3326
3327         if (!capable(CAP_SYS_ADMIN))
3328                 return -EPERM;
3329
3330         if (f2fs_readonly(sbi->sb))
3331                 return -EROFS;
3332
3333         if (copy_from_user(&block_count, (void __user *)arg,
3334                            sizeof(block_count)))
3335                 return -EFAULT;
3336
3337         return f2fs_resize_fs(filp, block_count);
3338 }
3339
3340 static int f2fs_ioc_enable_verity(struct file *filp, unsigned long arg)
3341 {
3342         struct inode *inode = file_inode(filp);
3343
3344         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
3345
3346         if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) {
3347                 f2fs_warn(F2FS_I_SB(inode),
3348                           "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem",
3349                           inode->i_ino);
3350                 return -EOPNOTSUPP;
3351         }
3352
3353         return fsverity_ioctl_enable(filp, (const void __user *)arg);
3354 }
3355
3356 static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg)
3357 {
3358         if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3359                 return -EOPNOTSUPP;
3360
3361         return fsverity_ioctl_measure(filp, (void __user *)arg);
3362 }
3363
3364 static int f2fs_ioc_read_verity_metadata(struct file *filp, unsigned long arg)
3365 {
3366         if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3367                 return -EOPNOTSUPP;
3368
3369         return fsverity_ioctl_read_metadata(filp, (const void __user *)arg);
3370 }
3371
3372 static int f2fs_ioc_getfslabel(struct file *filp, unsigned long arg)
3373 {
3374         struct inode *inode = file_inode(filp);
3375         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3376         char *vbuf;
3377         int count;
3378         int err = 0;
3379
3380         vbuf = f2fs_kzalloc(sbi, MAX_VOLUME_NAME, GFP_KERNEL);
3381         if (!vbuf)
3382                 return -ENOMEM;
3383
3384         f2fs_down_read(&sbi->sb_lock);
3385         count = utf16s_to_utf8s(sbi->raw_super->volume_name,
3386                         ARRAY_SIZE(sbi->raw_super->volume_name),
3387                         UTF16_LITTLE_ENDIAN, vbuf, MAX_VOLUME_NAME);
3388         f2fs_up_read(&sbi->sb_lock);
3389
3390         if (copy_to_user((char __user *)arg, vbuf,
3391                                 min(FSLABEL_MAX, count)))
3392                 err = -EFAULT;
3393
3394         kfree(vbuf);
3395         return err;
3396 }
3397
3398 static int f2fs_ioc_setfslabel(struct file *filp, unsigned long arg)
3399 {
3400         struct inode *inode = file_inode(filp);
3401         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3402         char *vbuf;
3403         int err = 0;
3404
3405         if (!capable(CAP_SYS_ADMIN))
3406                 return -EPERM;
3407
3408         vbuf = strndup_user((const char __user *)arg, FSLABEL_MAX);
3409         if (IS_ERR(vbuf))
3410                 return PTR_ERR(vbuf);
3411
3412         err = mnt_want_write_file(filp);
3413         if (err)
3414                 goto out;
3415
3416         f2fs_down_write(&sbi->sb_lock);
3417
3418         memset(sbi->raw_super->volume_name, 0,
3419                         sizeof(sbi->raw_super->volume_name));
3420         utf8s_to_utf16s(vbuf, strlen(vbuf), UTF16_LITTLE_ENDIAN,
3421                         sbi->raw_super->volume_name,
3422                         ARRAY_SIZE(sbi->raw_super->volume_name));
3423
3424         err = f2fs_commit_super(sbi, false);
3425
3426         f2fs_up_write(&sbi->sb_lock);
3427
3428         mnt_drop_write_file(filp);
3429 out:
3430         kfree(vbuf);
3431         return err;
3432 }
3433
3434 static int f2fs_get_compress_blocks(struct inode *inode, __u64 *blocks)
3435 {
3436         if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
3437                 return -EOPNOTSUPP;
3438
3439         if (!f2fs_compressed_file(inode))
3440                 return -EINVAL;
3441
3442         *blocks = atomic_read(&F2FS_I(inode)->i_compr_blocks);
3443
3444         return 0;
3445 }
3446
3447 static int f2fs_ioc_get_compress_blocks(struct file *filp, unsigned long arg)
3448 {
3449         struct inode *inode = file_inode(filp);
3450         __u64 blocks;
3451         int ret;
3452
3453         ret = f2fs_get_compress_blocks(inode, &blocks);
3454         if (ret < 0)
3455                 return ret;
3456
3457         return put_user(blocks, (u64 __user *)arg);
3458 }
3459
3460 static int release_compress_blocks(struct dnode_of_data *dn, pgoff_t count)
3461 {
3462         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
3463         unsigned int released_blocks = 0;
3464         int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
3465         block_t blkaddr;
3466         int i;
3467
3468         for (i = 0; i < count; i++) {
3469                 blkaddr = data_blkaddr(dn->inode, dn->node_page,
3470                                                 dn->ofs_in_node + i);
3471
3472                 if (!__is_valid_data_blkaddr(blkaddr))
3473                         continue;
3474                 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr,
3475                                         DATA_GENERIC_ENHANCE)))
3476                         return -EFSCORRUPTED;
3477         }
3478
3479         while (count) {
3480                 int compr_blocks = 0;
3481
3482                 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) {
3483                         blkaddr = f2fs_data_blkaddr(dn);
3484
3485                         if (i == 0) {
3486                                 if (blkaddr == COMPRESS_ADDR)
3487                                         continue;
3488                                 dn->ofs_in_node += cluster_size;
3489                                 goto next;
3490                         }
3491
3492                         if (__is_valid_data_blkaddr(blkaddr))
3493                                 compr_blocks++;
3494
3495                         if (blkaddr != NEW_ADDR)
3496                                 continue;
3497
3498                         f2fs_set_data_blkaddr(dn, NULL_ADDR);
3499                 }
3500
3501                 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, false);
3502                 dec_valid_block_count(sbi, dn->inode,
3503                                         cluster_size - compr_blocks);
3504
3505                 released_blocks += cluster_size - compr_blocks;
3506 next:
3507                 count -= cluster_size;
3508         }
3509
3510         return released_blocks;
3511 }
3512
3513 static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
3514 {
3515         struct inode *inode = file_inode(filp);
3516         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3517         pgoff_t page_idx = 0, last_idx;
3518         unsigned int released_blocks = 0;
3519         int ret;
3520         int writecount;
3521
3522         if (!f2fs_sb_has_compression(sbi))
3523                 return -EOPNOTSUPP;
3524
3525         if (!f2fs_compressed_file(inode))
3526                 return -EINVAL;
3527
3528         if (f2fs_readonly(sbi->sb))
3529                 return -EROFS;
3530
3531         ret = mnt_want_write_file(filp);
3532         if (ret)
3533                 return ret;
3534
3535         f2fs_balance_fs(sbi, true);
3536
3537         inode_lock(inode);
3538
3539         writecount = atomic_read(&inode->i_writecount);
3540         if ((filp->f_mode & FMODE_WRITE && writecount != 1) ||
3541                         (!(filp->f_mode & FMODE_WRITE) && writecount)) {
3542                 ret = -EBUSY;
3543                 goto out;
3544         }
3545
3546         if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
3547                 ret = -EINVAL;
3548                 goto out;
3549         }
3550
3551         ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
3552         if (ret)
3553                 goto out;
3554
3555         if (!atomic_read(&F2FS_I(inode)->i_compr_blocks)) {
3556                 ret = -EPERM;
3557                 goto out;
3558         }
3559
3560         set_inode_flag(inode, FI_COMPRESS_RELEASED);
3561         inode_set_ctime_current(inode);
3562         f2fs_mark_inode_dirty_sync(inode, true);
3563
3564         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3565         filemap_invalidate_lock(inode->i_mapping);
3566
3567         last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3568
3569         while (page_idx < last_idx) {
3570                 struct dnode_of_data dn;
3571                 pgoff_t end_offset, count;
3572
3573                 set_new_dnode(&dn, inode, NULL, NULL, 0);
3574                 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
3575                 if (ret) {
3576                         if (ret == -ENOENT) {
3577                                 page_idx = f2fs_get_next_page_offset(&dn,
3578                                                                 page_idx);
3579                                 ret = 0;
3580                                 continue;
3581                         }
3582                         break;
3583                 }
3584
3585                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
3586                 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3587                 count = round_up(count, F2FS_I(inode)->i_cluster_size);
3588
3589                 ret = release_compress_blocks(&dn, count);
3590
3591                 f2fs_put_dnode(&dn);
3592
3593                 if (ret < 0)
3594                         break;
3595
3596                 page_idx += count;
3597                 released_blocks += ret;
3598         }
3599
3600         filemap_invalidate_unlock(inode->i_mapping);
3601         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3602 out:
3603         inode_unlock(inode);
3604
3605         mnt_drop_write_file(filp);
3606
3607         if (ret >= 0) {
3608                 ret = put_user(released_blocks, (u64 __user *)arg);
3609         } else if (released_blocks &&
3610                         atomic_read(&F2FS_I(inode)->i_compr_blocks)) {
3611                 set_sbi_flag(sbi, SBI_NEED_FSCK);
3612                 f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
3613                         "iblocks=%llu, released=%u, compr_blocks=%u, "
3614                         "run fsck to fix.",
3615                         __func__, inode->i_ino, inode->i_blocks,
3616                         released_blocks,
3617                         atomic_read(&F2FS_I(inode)->i_compr_blocks));
3618         }
3619
3620         return ret;
3621 }
3622
3623 static int reserve_compress_blocks(struct dnode_of_data *dn, pgoff_t count,
3624                 unsigned int *reserved_blocks)
3625 {
3626         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
3627         int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
3628         block_t blkaddr;
3629         int i;
3630
3631         for (i = 0; i < count; i++) {
3632                 blkaddr = data_blkaddr(dn->inode, dn->node_page,
3633                                                 dn->ofs_in_node + i);
3634
3635                 if (!__is_valid_data_blkaddr(blkaddr))
3636                         continue;
3637                 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr,
3638                                         DATA_GENERIC_ENHANCE)))
3639                         return -EFSCORRUPTED;
3640         }
3641
3642         while (count) {
3643                 int compr_blocks = 0;
3644                 blkcnt_t reserved;
3645                 int ret;
3646
3647                 for (i = 0; i < cluster_size; i++) {
3648                         blkaddr = data_blkaddr(dn->inode, dn->node_page,
3649                                                 dn->ofs_in_node + i);
3650
3651                         if (i == 0) {
3652                                 if (blkaddr != COMPRESS_ADDR) {
3653                                         dn->ofs_in_node += cluster_size;
3654                                         goto next;
3655                                 }
3656                                 continue;
3657                         }
3658
3659                         /*
3660                          * compressed cluster was not released due to it
3661                          * fails in release_compress_blocks(), so NEW_ADDR
3662                          * is a possible case.
3663                          */
3664                         if (blkaddr == NEW_ADDR ||
3665                                 __is_valid_data_blkaddr(blkaddr)) {
3666                                 compr_blocks++;
3667                                 continue;
3668                         }
3669                 }
3670
3671                 reserved = cluster_size - compr_blocks;
3672
3673                 /* for the case all blocks in cluster were reserved */
3674                 if (reserved == 1)
3675                         goto next;
3676
3677                 ret = inc_valid_block_count(sbi, dn->inode, &reserved, false);
3678                 if (unlikely(ret))
3679                         return ret;
3680
3681                 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) {
3682                         if (f2fs_data_blkaddr(dn) == NULL_ADDR)
3683                                 f2fs_set_data_blkaddr(dn, NEW_ADDR);
3684                 }
3685
3686                 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, true);
3687
3688                 *reserved_blocks += reserved;
3689 next:
3690                 count -= cluster_size;
3691         }
3692
3693         return 0;
3694 }
3695
3696 static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
3697 {
3698         struct inode *inode = file_inode(filp);
3699         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3700         pgoff_t page_idx = 0, last_idx;
3701         unsigned int reserved_blocks = 0;
3702         int ret;
3703
3704         if (!f2fs_sb_has_compression(sbi))
3705                 return -EOPNOTSUPP;
3706
3707         if (!f2fs_compressed_file(inode))
3708                 return -EINVAL;
3709
3710         if (f2fs_readonly(sbi->sb))
3711                 return -EROFS;
3712
3713         ret = mnt_want_write_file(filp);
3714         if (ret)
3715                 return ret;
3716
3717         f2fs_balance_fs(sbi, true);
3718
3719         inode_lock(inode);
3720
3721         if (!is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
3722                 ret = -EINVAL;
3723                 goto unlock_inode;
3724         }
3725
3726         if (atomic_read(&F2FS_I(inode)->i_compr_blocks))
3727                 goto unlock_inode;
3728
3729         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3730         filemap_invalidate_lock(inode->i_mapping);
3731
3732         last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3733
3734         while (page_idx < last_idx) {
3735                 struct dnode_of_data dn;
3736                 pgoff_t end_offset, count;
3737
3738                 set_new_dnode(&dn, inode, NULL, NULL, 0);
3739                 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
3740                 if (ret) {
3741                         if (ret == -ENOENT) {
3742                                 page_idx = f2fs_get_next_page_offset(&dn,
3743                                                                 page_idx);
3744                                 ret = 0;
3745                                 continue;
3746                         }
3747                         break;
3748                 }
3749
3750                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
3751                 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3752                 count = round_up(count, F2FS_I(inode)->i_cluster_size);
3753
3754                 ret = reserve_compress_blocks(&dn, count, &reserved_blocks);
3755
3756                 f2fs_put_dnode(&dn);
3757
3758                 if (ret < 0)
3759                         break;
3760
3761                 page_idx += count;
3762         }
3763
3764         filemap_invalidate_unlock(inode->i_mapping);
3765         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3766
3767         if (!ret) {
3768                 clear_inode_flag(inode, FI_COMPRESS_RELEASED);
3769                 inode_set_ctime_current(inode);
3770                 f2fs_mark_inode_dirty_sync(inode, true);
3771         }
3772 unlock_inode:
3773         inode_unlock(inode);
3774         mnt_drop_write_file(filp);
3775
3776         if (!ret) {
3777                 ret = put_user(reserved_blocks, (u64 __user *)arg);
3778         } else if (reserved_blocks &&
3779                         atomic_read(&F2FS_I(inode)->i_compr_blocks)) {
3780                 set_sbi_flag(sbi, SBI_NEED_FSCK);
3781                 f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
3782                         "iblocks=%llu, reserved=%u, compr_blocks=%u, "
3783                         "run fsck to fix.",
3784                         __func__, inode->i_ino, inode->i_blocks,
3785                         reserved_blocks,
3786                         atomic_read(&F2FS_I(inode)->i_compr_blocks));
3787         }
3788
3789         return ret;
3790 }
3791
3792 static int f2fs_secure_erase(struct block_device *bdev, struct inode *inode,
3793                 pgoff_t off, block_t block, block_t len, u32 flags)
3794 {
3795         sector_t sector = SECTOR_FROM_BLOCK(block);
3796         sector_t nr_sects = SECTOR_FROM_BLOCK(len);
3797         int ret = 0;
3798
3799         if (flags & F2FS_TRIM_FILE_DISCARD) {
3800                 if (bdev_max_secure_erase_sectors(bdev))
3801                         ret = blkdev_issue_secure_erase(bdev, sector, nr_sects,
3802                                         GFP_NOFS);
3803                 else
3804                         ret = blkdev_issue_discard(bdev, sector, nr_sects,
3805                                         GFP_NOFS);
3806         }
3807
3808         if (!ret && (flags & F2FS_TRIM_FILE_ZEROOUT)) {
3809                 if (IS_ENCRYPTED(inode))
3810                         ret = fscrypt_zeroout_range(inode, off, block, len);
3811                 else
3812                         ret = blkdev_issue_zeroout(bdev, sector, nr_sects,
3813                                         GFP_NOFS, 0);
3814         }
3815
3816         return ret;
3817 }
3818
3819 static int f2fs_sec_trim_file(struct file *filp, unsigned long arg)
3820 {
3821         struct inode *inode = file_inode(filp);
3822         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3823         struct address_space *mapping = inode->i_mapping;
3824         struct block_device *prev_bdev = NULL;
3825         struct f2fs_sectrim_range range;
3826         pgoff_t index, pg_end, prev_index = 0;
3827         block_t prev_block = 0, len = 0;
3828         loff_t end_addr;
3829         bool to_end = false;
3830         int ret = 0;
3831
3832         if (!(filp->f_mode & FMODE_WRITE))
3833                 return -EBADF;
3834
3835         if (copy_from_user(&range, (struct f2fs_sectrim_range __user *)arg,
3836                                 sizeof(range)))
3837                 return -EFAULT;
3838
3839         if (range.flags == 0 || (range.flags & ~F2FS_TRIM_FILE_MASK) ||
3840                         !S_ISREG(inode->i_mode))
3841                 return -EINVAL;
3842
3843         if (((range.flags & F2FS_TRIM_FILE_DISCARD) &&
3844                         !f2fs_hw_support_discard(sbi)) ||
3845                         ((range.flags & F2FS_TRIM_FILE_ZEROOUT) &&
3846                          IS_ENCRYPTED(inode) && f2fs_is_multi_device(sbi)))
3847                 return -EOPNOTSUPP;
3848
3849         file_start_write(filp);
3850         inode_lock(inode);
3851
3852         if (f2fs_is_atomic_file(inode) || f2fs_compressed_file(inode) ||
3853                         range.start >= inode->i_size) {
3854                 ret = -EINVAL;
3855                 goto err;
3856         }
3857
3858         if (range.len == 0)
3859                 goto err;
3860
3861         if (inode->i_size - range.start > range.len) {
3862                 end_addr = range.start + range.len;
3863         } else {
3864                 end_addr = range.len == (u64)-1 ?
3865                         sbi->sb->s_maxbytes : inode->i_size;
3866                 to_end = true;
3867         }
3868
3869         if (!IS_ALIGNED(range.start, F2FS_BLKSIZE) ||
3870                         (!to_end && !IS_ALIGNED(end_addr, F2FS_BLKSIZE))) {
3871                 ret = -EINVAL;
3872                 goto err;
3873         }
3874
3875         index = F2FS_BYTES_TO_BLK(range.start);
3876         pg_end = DIV_ROUND_UP(end_addr, F2FS_BLKSIZE);
3877
3878         ret = f2fs_convert_inline_inode(inode);
3879         if (ret)
3880                 goto err;
3881
3882         f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3883         filemap_invalidate_lock(mapping);
3884
3885         ret = filemap_write_and_wait_range(mapping, range.start,
3886                         to_end ? LLONG_MAX : end_addr - 1);
3887         if (ret)
3888                 goto out;
3889
3890         truncate_inode_pages_range(mapping, range.start,
3891                         to_end ? -1 : end_addr - 1);
3892
3893         while (index < pg_end) {
3894                 struct dnode_of_data dn;
3895                 pgoff_t end_offset, count;
3896                 int i;
3897
3898                 set_new_dnode(&dn, inode, NULL, NULL, 0);
3899                 ret = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
3900                 if (ret) {
3901                         if (ret == -ENOENT) {
3902                                 index = f2fs_get_next_page_offset(&dn, index);
3903                                 continue;
3904                         }
3905                         goto out;
3906                 }
3907
3908                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
3909                 count = min(end_offset - dn.ofs_in_node, pg_end - index);
3910                 for (i = 0; i < count; i++, index++, dn.ofs_in_node++) {
3911                         struct block_device *cur_bdev;
3912                         block_t blkaddr = f2fs_data_blkaddr(&dn);
3913
3914                         if (!__is_valid_data_blkaddr(blkaddr))
3915                                 continue;
3916
3917                         if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
3918                                                 DATA_GENERIC_ENHANCE)) {
3919                                 ret = -EFSCORRUPTED;
3920                                 f2fs_put_dnode(&dn);
3921                                 goto out;
3922                         }
3923
3924                         cur_bdev = f2fs_target_device(sbi, blkaddr, NULL);
3925                         if (f2fs_is_multi_device(sbi)) {
3926                                 int di = f2fs_target_device_index(sbi, blkaddr);
3927
3928                                 blkaddr -= FDEV(di).start_blk;
3929                         }
3930
3931                         if (len) {
3932                                 if (prev_bdev == cur_bdev &&
3933                                                 index == prev_index + len &&
3934                                                 blkaddr == prev_block + len) {
3935                                         len++;
3936                                 } else {
3937                                         ret = f2fs_secure_erase(prev_bdev,
3938                                                 inode, prev_index, prev_block,
3939                                                 len, range.flags);
3940                                         if (ret) {
3941                                                 f2fs_put_dnode(&dn);
3942                                                 goto out;
3943                                         }
3944
3945                                         len = 0;
3946                                 }
3947                         }
3948
3949                         if (!len) {
3950                                 prev_bdev = cur_bdev;
3951                                 prev_index = index;
3952                                 prev_block = blkaddr;
3953                                 len = 1;
3954                         }
3955                 }
3956
3957                 f2fs_put_dnode(&dn);
3958
3959                 if (fatal_signal_pending(current)) {
3960                         ret = -EINTR;
3961                         goto out;
3962                 }
3963                 cond_resched();
3964         }
3965
3966         if (len)
3967                 ret = f2fs_secure_erase(prev_bdev, inode, prev_index,
3968                                 prev_block, len, range.flags);
3969 out:
3970         filemap_invalidate_unlock(mapping);
3971         f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3972 err:
3973         inode_unlock(inode);
3974         file_end_write(filp);
3975
3976         return ret;
3977 }
3978
3979 static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg)
3980 {
3981         struct inode *inode = file_inode(filp);
3982         struct f2fs_comp_option option;
3983
3984         if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
3985                 return -EOPNOTSUPP;
3986
3987         inode_lock_shared(inode);
3988
3989         if (!f2fs_compressed_file(inode)) {
3990                 inode_unlock_shared(inode);
3991                 return -ENODATA;
3992         }
3993
3994         option.algorithm = F2FS_I(inode)->i_compress_algorithm;
3995         option.log_cluster_size = F2FS_I(inode)->i_log_cluster_size;
3996
3997         inode_unlock_shared(inode);
3998
3999         if (copy_to_user((struct f2fs_comp_option __user *)arg, &option,
4000                                 sizeof(option)))
4001                 return -EFAULT;
4002
4003         return 0;
4004 }
4005
4006 static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg)
4007 {
4008         struct inode *inode = file_inode(filp);
4009         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4010         struct f2fs_comp_option option;
4011         int ret = 0;
4012
4013         if (!f2fs_sb_has_compression(sbi))
4014                 return -EOPNOTSUPP;
4015
4016         if (!(filp->f_mode & FMODE_WRITE))
4017                 return -EBADF;
4018
4019         if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg,
4020                                 sizeof(option)))
4021                 return -EFAULT;
4022
4023         if (option.log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
4024                 option.log_cluster_size > MAX_COMPRESS_LOG_SIZE ||
4025                 option.algorithm >= COMPRESS_MAX)
4026                 return -EINVAL;
4027
4028         file_start_write(filp);
4029         inode_lock(inode);
4030
4031         f2fs_down_write(&F2FS_I(inode)->i_sem);
4032         if (!f2fs_compressed_file(inode)) {
4033                 ret = -EINVAL;
4034                 goto out;
4035         }
4036
4037         if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) {
4038                 ret = -EBUSY;
4039                 goto out;
4040         }
4041
4042         if (F2FS_HAS_BLOCKS(inode)) {
4043                 ret = -EFBIG;
4044                 goto out;
4045         }
4046
4047         F2FS_I(inode)->i_compress_algorithm = option.algorithm;
4048         F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size;
4049         F2FS_I(inode)->i_cluster_size = BIT(option.log_cluster_size);
4050         /* Set default level */
4051         if (F2FS_I(inode)->i_compress_algorithm == COMPRESS_ZSTD)
4052                 F2FS_I(inode)->i_compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
4053         else
4054                 F2FS_I(inode)->i_compress_level = 0;
4055         /* Adjust mount option level */
4056         if (option.algorithm == F2FS_OPTION(sbi).compress_algorithm &&
4057             F2FS_OPTION(sbi).compress_level)
4058                 F2FS_I(inode)->i_compress_level = F2FS_OPTION(sbi).compress_level;
4059         f2fs_mark_inode_dirty_sync(inode, true);
4060
4061         if (!f2fs_is_compress_backend_ready(inode))
4062                 f2fs_warn(sbi, "compression algorithm is successfully set, "
4063                         "but current kernel doesn't support this algorithm.");
4064 out:
4065         f2fs_up_write(&F2FS_I(inode)->i_sem);
4066         inode_unlock(inode);
4067         file_end_write(filp);
4068
4069         return ret;
4070 }
4071
4072 static int redirty_blocks(struct inode *inode, pgoff_t page_idx, int len)
4073 {
4074         DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, page_idx);
4075         struct address_space *mapping = inode->i_mapping;
4076         struct page *page;
4077         pgoff_t redirty_idx = page_idx;
4078         int i, page_len = 0, ret = 0;
4079
4080         page_cache_ra_unbounded(&ractl, len, 0);
4081
4082         for (i = 0; i < len; i++, page_idx++) {
4083                 page = read_cache_page(mapping, page_idx, NULL, NULL);
4084                 if (IS_ERR(page)) {
4085                         ret = PTR_ERR(page);
4086                         break;
4087                 }
4088                 page_len++;
4089         }
4090
4091         for (i = 0; i < page_len; i++, redirty_idx++) {
4092                 page = find_lock_page(mapping, redirty_idx);
4093
4094                 /* It will never fail, when page has pinned above */
4095                 f2fs_bug_on(F2FS_I_SB(inode), !page);
4096
4097                 set_page_dirty(page);
4098                 set_page_private_gcing(page);
4099                 f2fs_put_page(page, 1);
4100                 f2fs_put_page(page, 0);
4101         }
4102
4103         return ret;
4104 }
4105
4106 static int f2fs_ioc_decompress_file(struct file *filp)
4107 {
4108         struct inode *inode = file_inode(filp);
4109         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4110         struct f2fs_inode_info *fi = F2FS_I(inode);
4111         pgoff_t page_idx = 0, last_idx;
4112         int cluster_size = fi->i_cluster_size;
4113         int count, ret;
4114
4115         if (!f2fs_sb_has_compression(sbi) ||
4116                         F2FS_OPTION(sbi).compress_mode != COMPR_MODE_USER)
4117                 return -EOPNOTSUPP;
4118
4119         if (!(filp->f_mode & FMODE_WRITE))
4120                 return -EBADF;
4121
4122         if (!f2fs_compressed_file(inode))
4123                 return -EINVAL;
4124
4125         f2fs_balance_fs(sbi, true);
4126
4127         file_start_write(filp);
4128         inode_lock(inode);
4129
4130         if (!f2fs_is_compress_backend_ready(inode)) {
4131                 ret = -EOPNOTSUPP;
4132                 goto out;
4133         }
4134
4135         if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
4136                 ret = -EINVAL;
4137                 goto out;
4138         }
4139
4140         ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
4141         if (ret)
4142                 goto out;
4143
4144         if (!atomic_read(&fi->i_compr_blocks))
4145                 goto out;
4146
4147         last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
4148
4149         count = last_idx - page_idx;
4150         while (count && count >= cluster_size) {
4151                 ret = redirty_blocks(inode, page_idx, cluster_size);
4152                 if (ret < 0)
4153                         break;
4154
4155                 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) {
4156                         ret = filemap_fdatawrite(inode->i_mapping);
4157                         if (ret < 0)
4158                                 break;
4159                 }
4160
4161                 count -= cluster_size;
4162                 page_idx += cluster_size;
4163
4164                 cond_resched();
4165                 if (fatal_signal_pending(current)) {
4166                         ret = -EINTR;
4167                         break;
4168                 }
4169         }
4170
4171         if (!ret)
4172                 ret = filemap_write_and_wait_range(inode->i_mapping, 0,
4173                                                         LLONG_MAX);
4174
4175         if (ret)
4176                 f2fs_warn(sbi, "%s: The file might be partially decompressed (errno=%d). Please delete the file.",
4177                           __func__, ret);
4178 out:
4179         inode_unlock(inode);
4180         file_end_write(filp);
4181
4182         return ret;
4183 }
4184
4185 static int f2fs_ioc_compress_file(struct file *filp)
4186 {
4187         struct inode *inode = file_inode(filp);
4188         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4189         pgoff_t page_idx = 0, last_idx;
4190         int cluster_size = F2FS_I(inode)->i_cluster_size;
4191         int count, ret;
4192
4193         if (!f2fs_sb_has_compression(sbi) ||
4194                         F2FS_OPTION(sbi).compress_mode != COMPR_MODE_USER)
4195                 return -EOPNOTSUPP;
4196
4197         if (!(filp->f_mode & FMODE_WRITE))
4198                 return -EBADF;
4199
4200         if (!f2fs_compressed_file(inode))
4201                 return -EINVAL;
4202
4203         f2fs_balance_fs(sbi, true);
4204
4205         file_start_write(filp);
4206         inode_lock(inode);
4207
4208         if (!f2fs_is_compress_backend_ready(inode)) {
4209                 ret = -EOPNOTSUPP;
4210                 goto out;
4211         }
4212
4213         if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
4214                 ret = -EINVAL;
4215                 goto out;
4216         }
4217
4218         ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
4219         if (ret)
4220                 goto out;
4221
4222         set_inode_flag(inode, FI_ENABLE_COMPRESS);
4223
4224         last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
4225
4226         count = last_idx - page_idx;
4227         while (count && count >= cluster_size) {
4228                 ret = redirty_blocks(inode, page_idx, cluster_size);
4229                 if (ret < 0)
4230                         break;
4231
4232                 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) {
4233                         ret = filemap_fdatawrite(inode->i_mapping);
4234                         if (ret < 0)
4235                                 break;
4236                 }
4237
4238                 count -= cluster_size;
4239                 page_idx += cluster_size;
4240
4241                 cond_resched();
4242                 if (fatal_signal_pending(current)) {
4243                         ret = -EINTR;
4244                         break;
4245                 }
4246         }
4247
4248         if (!ret)
4249                 ret = filemap_write_and_wait_range(inode->i_mapping, 0,
4250                                                         LLONG_MAX);
4251
4252         clear_inode_flag(inode, FI_ENABLE_COMPRESS);
4253
4254         if (ret)
4255                 f2fs_warn(sbi, "%s: The file might be partially compressed (errno=%d). Please delete the file.",
4256                           __func__, ret);
4257 out:
4258         inode_unlock(inode);
4259         file_end_write(filp);
4260
4261         return ret;
4262 }
4263
4264 static long __f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
4265 {
4266         switch (cmd) {
4267         case FS_IOC_GETVERSION:
4268                 return f2fs_ioc_getversion(filp, arg);
4269         case F2FS_IOC_START_ATOMIC_WRITE:
4270                 return f2fs_ioc_start_atomic_write(filp, false);
4271         case F2FS_IOC_START_ATOMIC_REPLACE:
4272                 return f2fs_ioc_start_atomic_write(filp, true);
4273         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
4274                 return f2fs_ioc_commit_atomic_write(filp);
4275         case F2FS_IOC_ABORT_ATOMIC_WRITE:
4276                 return f2fs_ioc_abort_atomic_write(filp);
4277         case F2FS_IOC_START_VOLATILE_WRITE:
4278         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
4279                 return -EOPNOTSUPP;
4280         case F2FS_IOC_SHUTDOWN:
4281                 return f2fs_ioc_shutdown(filp, arg);
4282         case FITRIM:
4283                 return f2fs_ioc_fitrim(filp, arg);
4284         case FS_IOC_SET_ENCRYPTION_POLICY:
4285                 return f2fs_ioc_set_encryption_policy(filp, arg);
4286         case FS_IOC_GET_ENCRYPTION_POLICY:
4287                 return f2fs_ioc_get_encryption_policy(filp, arg);
4288         case FS_IOC_GET_ENCRYPTION_PWSALT:
4289                 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
4290         case FS_IOC_GET_ENCRYPTION_POLICY_EX:
4291                 return f2fs_ioc_get_encryption_policy_ex(filp, arg);
4292         case FS_IOC_ADD_ENCRYPTION_KEY:
4293                 return f2fs_ioc_add_encryption_key(filp, arg);
4294         case FS_IOC_REMOVE_ENCRYPTION_KEY:
4295                 return f2fs_ioc_remove_encryption_key(filp, arg);
4296         case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
4297                 return f2fs_ioc_remove_encryption_key_all_users(filp, arg);
4298         case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
4299                 return f2fs_ioc_get_encryption_key_status(filp, arg);
4300         case FS_IOC_GET_ENCRYPTION_NONCE:
4301                 return f2fs_ioc_get_encryption_nonce(filp, arg);
4302         case F2FS_IOC_GARBAGE_COLLECT:
4303                 return f2fs_ioc_gc(filp, arg);
4304         case F2FS_IOC_GARBAGE_COLLECT_RANGE:
4305                 return f2fs_ioc_gc_range(filp, arg);
4306         case F2FS_IOC_WRITE_CHECKPOINT:
4307                 return f2fs_ioc_write_checkpoint(filp);
4308         case F2FS_IOC_DEFRAGMENT:
4309                 return f2fs_ioc_defragment(filp, arg);
4310         case F2FS_IOC_MOVE_RANGE:
4311                 return f2fs_ioc_move_range(filp, arg);
4312         case F2FS_IOC_FLUSH_DEVICE:
4313                 return f2fs_ioc_flush_device(filp, arg);
4314         case F2FS_IOC_GET_FEATURES:
4315                 return f2fs_ioc_get_features(filp, arg);
4316         case F2FS_IOC_GET_PIN_FILE:
4317                 return f2fs_ioc_get_pin_file(filp, arg);
4318         case F2FS_IOC_SET_PIN_FILE:
4319                 return f2fs_ioc_set_pin_file(filp, arg);
4320         case F2FS_IOC_PRECACHE_EXTENTS:
4321                 return f2fs_ioc_precache_extents(filp);
4322         case F2FS_IOC_RESIZE_FS:
4323                 return f2fs_ioc_resize_fs(filp, arg);
4324         case FS_IOC_ENABLE_VERITY:
4325                 return f2fs_ioc_enable_verity(filp, arg);
4326         case FS_IOC_MEASURE_VERITY:
4327                 return f2fs_ioc_measure_verity(filp, arg);
4328         case FS_IOC_READ_VERITY_METADATA:
4329                 return f2fs_ioc_read_verity_metadata(filp, arg);
4330         case FS_IOC_GETFSLABEL:
4331                 return f2fs_ioc_getfslabel(filp, arg);
4332         case FS_IOC_SETFSLABEL:
4333                 return f2fs_ioc_setfslabel(filp, arg);
4334         case F2FS_IOC_GET_COMPRESS_BLOCKS:
4335                 return f2fs_ioc_get_compress_blocks(filp, arg);
4336         case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
4337                 return f2fs_release_compress_blocks(filp, arg);
4338         case F2FS_IOC_RESERVE_COMPRESS_BLOCKS:
4339                 return f2fs_reserve_compress_blocks(filp, arg);
4340         case F2FS_IOC_SEC_TRIM_FILE:
4341                 return f2fs_sec_trim_file(filp, arg);
4342         case F2FS_IOC_GET_COMPRESS_OPTION:
4343                 return f2fs_ioc_get_compress_option(filp, arg);
4344         case F2FS_IOC_SET_COMPRESS_OPTION:
4345                 return f2fs_ioc_set_compress_option(filp, arg);
4346         case F2FS_IOC_DECOMPRESS_FILE:
4347                 return f2fs_ioc_decompress_file(filp);
4348         case F2FS_IOC_COMPRESS_FILE:
4349                 return f2fs_ioc_compress_file(filp);
4350         default:
4351                 return -ENOTTY;
4352         }
4353 }
4354
4355 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
4356 {
4357         if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
4358                 return -EIO;
4359         if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp))))
4360                 return -ENOSPC;
4361
4362         return __f2fs_ioctl(filp, cmd, arg);
4363 }
4364
4365 /*
4366  * Return %true if the given read or write request should use direct I/O, or
4367  * %false if it should use buffered I/O.
4368  */
4369 static bool f2fs_should_use_dio(struct inode *inode, struct kiocb *iocb,
4370                                 struct iov_iter *iter)
4371 {
4372         unsigned int align;
4373
4374         if (!(iocb->ki_flags & IOCB_DIRECT))
4375                 return false;
4376
4377         if (f2fs_force_buffered_io(inode, iov_iter_rw(iter)))
4378                 return false;
4379
4380         /*
4381          * Direct I/O not aligned to the disk's logical_block_size will be
4382          * attempted, but will fail with -EINVAL.
4383          *
4384          * f2fs additionally requires that direct I/O be aligned to the
4385          * filesystem block size, which is often a stricter requirement.
4386          * However, f2fs traditionally falls back to buffered I/O on requests
4387          * that are logical_block_size-aligned but not fs-block aligned.
4388          *
4389          * The below logic implements this behavior.
4390          */
4391         align = iocb->ki_pos | iov_iter_alignment(iter);
4392         if (!IS_ALIGNED(align, i_blocksize(inode)) &&
4393             IS_ALIGNED(align, bdev_logical_block_size(inode->i_sb->s_bdev)))
4394                 return false;
4395
4396         return true;
4397 }
4398
4399 static int f2fs_dio_read_end_io(struct kiocb *iocb, ssize_t size, int error,
4400                                 unsigned int flags)
4401 {
4402         struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(iocb->ki_filp));
4403
4404         dec_page_count(sbi, F2FS_DIO_READ);
4405         if (error)
4406                 return error;
4407         f2fs_update_iostat(sbi, NULL, APP_DIRECT_READ_IO, size);
4408         return 0;
4409 }
4410
4411 static const struct iomap_dio_ops f2fs_iomap_dio_read_ops = {
4412         .end_io = f2fs_dio_read_end_io,
4413 };
4414
4415 static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
4416 {
4417         struct file *file = iocb->ki_filp;
4418         struct inode *inode = file_inode(file);
4419         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4420         struct f2fs_inode_info *fi = F2FS_I(inode);
4421         const loff_t pos = iocb->ki_pos;
4422         const size_t count = iov_iter_count(to);
4423         struct iomap_dio *dio;
4424         ssize_t ret;
4425
4426         if (count == 0)
4427                 return 0; /* skip atime update */
4428
4429         trace_f2fs_direct_IO_enter(inode, iocb, count, READ);
4430
4431         if (iocb->ki_flags & IOCB_NOWAIT) {
4432                 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
4433                         ret = -EAGAIN;
4434                         goto out;
4435                 }
4436         } else {
4437                 f2fs_down_read(&fi->i_gc_rwsem[READ]);
4438         }
4439
4440         /*
4441          * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4442          * the higher-level function iomap_dio_rw() in order to ensure that the
4443          * F2FS_DIO_READ counter will be decremented correctly in all cases.
4444          */
4445         inc_page_count(sbi, F2FS_DIO_READ);
4446         dio = __iomap_dio_rw(iocb, to, &f2fs_iomap_ops,
4447                              &f2fs_iomap_dio_read_ops, 0, NULL, 0);
4448         if (IS_ERR_OR_NULL(dio)) {
4449                 ret = PTR_ERR_OR_ZERO(dio);
4450                 if (ret != -EIOCBQUEUED)
4451                         dec_page_count(sbi, F2FS_DIO_READ);
4452         } else {
4453                 ret = iomap_dio_complete(dio);
4454         }
4455
4456         f2fs_up_read(&fi->i_gc_rwsem[READ]);
4457
4458         file_accessed(file);
4459 out:
4460         trace_f2fs_direct_IO_exit(inode, pos, count, READ, ret);
4461         return ret;
4462 }
4463
4464 static void f2fs_trace_rw_file_path(struct file *file, loff_t pos, size_t count,
4465                                     int rw)
4466 {
4467         struct inode *inode = file_inode(file);
4468         char *buf, *path;
4469
4470         buf = f2fs_getname(F2FS_I_SB(inode));
4471         if (!buf)
4472                 return;
4473         path = dentry_path_raw(file_dentry(file), buf, PATH_MAX);
4474         if (IS_ERR(path))
4475                 goto free_buf;
4476         if (rw == WRITE)
4477                 trace_f2fs_datawrite_start(inode, pos, count,
4478                                 current->pid, path, current->comm);
4479         else
4480                 trace_f2fs_dataread_start(inode, pos, count,
4481                                 current->pid, path, current->comm);
4482 free_buf:
4483         f2fs_putname(buf);
4484 }
4485
4486 static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
4487 {
4488         struct inode *inode = file_inode(iocb->ki_filp);
4489         const loff_t pos = iocb->ki_pos;
4490         ssize_t ret;
4491
4492         if (!f2fs_is_compress_backend_ready(inode))
4493                 return -EOPNOTSUPP;
4494
4495         if (trace_f2fs_dataread_start_enabled())
4496                 f2fs_trace_rw_file_path(iocb->ki_filp, iocb->ki_pos,
4497                                         iov_iter_count(to), READ);
4498
4499         if (f2fs_should_use_dio(inode, iocb, to)) {
4500                 ret = f2fs_dio_read_iter(iocb, to);
4501         } else {
4502                 ret = filemap_read(iocb, to, 0);
4503                 if (ret > 0)
4504                         f2fs_update_iostat(F2FS_I_SB(inode), inode,
4505                                                 APP_BUFFERED_READ_IO, ret);
4506         }
4507         if (trace_f2fs_dataread_end_enabled())
4508                 trace_f2fs_dataread_end(inode, pos, ret);
4509         return ret;
4510 }
4511
4512 static ssize_t f2fs_file_splice_read(struct file *in, loff_t *ppos,
4513                                      struct pipe_inode_info *pipe,
4514                                      size_t len, unsigned int flags)
4515 {
4516         struct inode *inode = file_inode(in);
4517         const loff_t pos = *ppos;
4518         ssize_t ret;
4519
4520         if (!f2fs_is_compress_backend_ready(inode))
4521                 return -EOPNOTSUPP;
4522
4523         if (trace_f2fs_dataread_start_enabled())
4524                 f2fs_trace_rw_file_path(in, pos, len, READ);
4525
4526         ret = filemap_splice_read(in, ppos, pipe, len, flags);
4527         if (ret > 0)
4528                 f2fs_update_iostat(F2FS_I_SB(inode), inode,
4529                                    APP_BUFFERED_READ_IO, ret);
4530
4531         if (trace_f2fs_dataread_end_enabled())
4532                 trace_f2fs_dataread_end(inode, pos, ret);
4533         return ret;
4534 }
4535
4536 static ssize_t f2fs_write_checks(struct kiocb *iocb, struct iov_iter *from)
4537 {
4538         struct file *file = iocb->ki_filp;
4539         struct inode *inode = file_inode(file);
4540         ssize_t count;
4541         int err;
4542
4543         if (IS_IMMUTABLE(inode))
4544                 return -EPERM;
4545
4546         if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED))
4547                 return -EPERM;
4548
4549         count = generic_write_checks(iocb, from);
4550         if (count <= 0)
4551                 return count;
4552
4553         err = file_modified(file);
4554         if (err)
4555                 return err;
4556         return count;
4557 }
4558
4559 /*
4560  * Preallocate blocks for a write request, if it is possible and helpful to do
4561  * so.  Returns a positive number if blocks may have been preallocated, 0 if no
4562  * blocks were preallocated, or a negative errno value if something went
4563  * seriously wrong.  Also sets FI_PREALLOCATED_ALL on the inode if *all* the
4564  * requested blocks (not just some of them) have been allocated.
4565  */
4566 static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
4567                                    bool dio)
4568 {
4569         struct inode *inode = file_inode(iocb->ki_filp);
4570         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4571         const loff_t pos = iocb->ki_pos;
4572         const size_t count = iov_iter_count(iter);
4573         struct f2fs_map_blocks map = {};
4574         int flag;
4575         int ret;
4576
4577         /* If it will be an out-of-place direct write, don't bother. */
4578         if (dio && f2fs_lfs_mode(sbi))
4579                 return 0;
4580         /*
4581          * Don't preallocate holes aligned to DIO_SKIP_HOLES which turns into
4582          * buffered IO, if DIO meets any holes.
4583          */
4584         if (dio && i_size_read(inode) &&
4585                 (F2FS_BYTES_TO_BLK(pos) < F2FS_BLK_ALIGN(i_size_read(inode))))
4586                 return 0;
4587
4588         /* No-wait I/O can't allocate blocks. */
4589         if (iocb->ki_flags & IOCB_NOWAIT)
4590                 return 0;
4591
4592         /* If it will be a short write, don't bother. */
4593         if (fault_in_iov_iter_readable(iter, count))
4594                 return 0;
4595
4596         if (f2fs_has_inline_data(inode)) {
4597                 /* If the data will fit inline, don't bother. */
4598                 if (pos + count <= MAX_INLINE_DATA(inode))
4599                         return 0;
4600                 ret = f2fs_convert_inline_inode(inode);
4601                 if (ret)
4602                         return ret;
4603         }
4604
4605         /* Do not preallocate blocks that will be written partially in 4KB. */
4606         map.m_lblk = F2FS_BLK_ALIGN(pos);
4607         map.m_len = F2FS_BYTES_TO_BLK(pos + count);
4608         if (map.m_len > map.m_lblk)
4609                 map.m_len -= map.m_lblk;
4610         else
4611                 return 0;
4612
4613         map.m_may_create = true;
4614         if (dio) {
4615                 map.m_seg_type = f2fs_rw_hint_to_seg_type(inode->i_write_hint);
4616                 flag = F2FS_GET_BLOCK_PRE_DIO;
4617         } else {
4618                 map.m_seg_type = NO_CHECK_TYPE;
4619                 flag = F2FS_GET_BLOCK_PRE_AIO;
4620         }
4621
4622         ret = f2fs_map_blocks(inode, &map, flag);
4623         /* -ENOSPC|-EDQUOT are fine to report the number of allocated blocks. */
4624         if (ret < 0 && !((ret == -ENOSPC || ret == -EDQUOT) && map.m_len > 0))
4625                 return ret;
4626         if (ret == 0)
4627                 set_inode_flag(inode, FI_PREALLOCATED_ALL);
4628         return map.m_len;
4629 }
4630
4631 static ssize_t f2fs_buffered_write_iter(struct kiocb *iocb,
4632                                         struct iov_iter *from)
4633 {
4634         struct file *file = iocb->ki_filp;
4635         struct inode *inode = file_inode(file);
4636         ssize_t ret;
4637
4638         if (iocb->ki_flags & IOCB_NOWAIT)
4639                 return -EOPNOTSUPP;
4640
4641         ret = generic_perform_write(iocb, from);
4642
4643         if (ret > 0) {
4644                 f2fs_update_iostat(F2FS_I_SB(inode), inode,
4645                                                 APP_BUFFERED_IO, ret);
4646         }
4647         return ret;
4648 }
4649
4650 static int f2fs_dio_write_end_io(struct kiocb *iocb, ssize_t size, int error,
4651                                  unsigned int flags)
4652 {
4653         struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(iocb->ki_filp));
4654
4655         dec_page_count(sbi, F2FS_DIO_WRITE);
4656         if (error)
4657                 return error;
4658         f2fs_update_time(sbi, REQ_TIME);
4659         f2fs_update_iostat(sbi, NULL, APP_DIRECT_IO, size);
4660         return 0;
4661 }
4662
4663 static const struct iomap_dio_ops f2fs_iomap_dio_write_ops = {
4664         .end_io = f2fs_dio_write_end_io,
4665 };
4666
4667 static void f2fs_flush_buffered_write(struct address_space *mapping,
4668                                       loff_t start_pos, loff_t end_pos)
4669 {
4670         int ret;
4671
4672         ret = filemap_write_and_wait_range(mapping, start_pos, end_pos);
4673         if (ret < 0)
4674                 return;
4675         invalidate_mapping_pages(mapping,
4676                                  start_pos >> PAGE_SHIFT,
4677                                  end_pos >> PAGE_SHIFT);
4678 }
4679
4680 static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,
4681                                    bool *may_need_sync)
4682 {
4683         struct file *file = iocb->ki_filp;
4684         struct inode *inode = file_inode(file);
4685         struct f2fs_inode_info *fi = F2FS_I(inode);
4686         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4687         const bool do_opu = f2fs_lfs_mode(sbi);
4688         const loff_t pos = iocb->ki_pos;
4689         const ssize_t count = iov_iter_count(from);
4690         unsigned int dio_flags;
4691         struct iomap_dio *dio;
4692         ssize_t ret;
4693
4694         trace_f2fs_direct_IO_enter(inode, iocb, count, WRITE);
4695
4696         if (iocb->ki_flags & IOCB_NOWAIT) {
4697                 /* f2fs_convert_inline_inode() and block allocation can block */
4698                 if (f2fs_has_inline_data(inode) ||
4699                     !f2fs_overwrite_io(inode, pos, count)) {
4700                         ret = -EAGAIN;
4701                         goto out;
4702                 }
4703
4704                 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) {
4705                         ret = -EAGAIN;
4706                         goto out;
4707                 }
4708                 if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
4709                         f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
4710                         ret = -EAGAIN;
4711                         goto out;
4712                 }
4713         } else {
4714                 ret = f2fs_convert_inline_inode(inode);
4715                 if (ret)
4716                         goto out;
4717
4718                 f2fs_down_read(&fi->i_gc_rwsem[WRITE]);
4719                 if (do_opu)
4720                         f2fs_down_read(&fi->i_gc_rwsem[READ]);
4721         }
4722
4723         /*
4724          * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4725          * the higher-level function iomap_dio_rw() in order to ensure that the
4726          * F2FS_DIO_WRITE counter will be decremented correctly in all cases.
4727          */
4728         inc_page_count(sbi, F2FS_DIO_WRITE);
4729         dio_flags = 0;
4730         if (pos + count > inode->i_size)
4731                 dio_flags |= IOMAP_DIO_FORCE_WAIT;
4732         dio = __iomap_dio_rw(iocb, from, &f2fs_iomap_ops,
4733                              &f2fs_iomap_dio_write_ops, dio_flags, NULL, 0);
4734         if (IS_ERR_OR_NULL(dio)) {
4735                 ret = PTR_ERR_OR_ZERO(dio);
4736                 if (ret == -ENOTBLK)
4737                         ret = 0;
4738                 if (ret != -EIOCBQUEUED)
4739                         dec_page_count(sbi, F2FS_DIO_WRITE);
4740         } else {
4741                 ret = iomap_dio_complete(dio);
4742         }
4743
4744         if (do_opu)
4745                 f2fs_up_read(&fi->i_gc_rwsem[READ]);
4746         f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
4747
4748         if (ret < 0)
4749                 goto out;
4750         if (pos + ret > inode->i_size)
4751                 f2fs_i_size_write(inode, pos + ret);
4752         if (!do_opu)
4753                 set_inode_flag(inode, FI_UPDATE_WRITE);
4754
4755         if (iov_iter_count(from)) {
4756                 ssize_t ret2;
4757                 loff_t bufio_start_pos = iocb->ki_pos;
4758
4759                 /*
4760                  * The direct write was partial, so we need to fall back to a
4761                  * buffered write for the remainder.
4762                  */
4763
4764                 ret2 = f2fs_buffered_write_iter(iocb, from);
4765                 if (iov_iter_count(from))
4766                         f2fs_write_failed(inode, iocb->ki_pos);
4767                 if (ret2 < 0)
4768                         goto out;
4769
4770                 /*
4771                  * Ensure that the pagecache pages are written to disk and
4772                  * invalidated to preserve the expected O_DIRECT semantics.
4773                  */
4774                 if (ret2 > 0) {
4775                         loff_t bufio_end_pos = bufio_start_pos + ret2 - 1;
4776
4777                         ret += ret2;
4778
4779                         f2fs_flush_buffered_write(file->f_mapping,
4780                                                   bufio_start_pos,
4781                                                   bufio_end_pos);
4782                 }
4783         } else {
4784                 /* iomap_dio_rw() already handled the generic_write_sync(). */
4785                 *may_need_sync = false;
4786         }
4787 out:
4788         trace_f2fs_direct_IO_exit(inode, pos, count, WRITE, ret);
4789         return ret;
4790 }
4791
4792 static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
4793 {
4794         struct inode *inode = file_inode(iocb->ki_filp);
4795         const loff_t orig_pos = iocb->ki_pos;
4796         const size_t orig_count = iov_iter_count(from);
4797         loff_t target_size;
4798         bool dio;
4799         bool may_need_sync = true;
4800         int preallocated;
4801         ssize_t ret;
4802
4803         if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
4804                 ret = -EIO;
4805                 goto out;
4806         }
4807
4808         if (!f2fs_is_compress_backend_ready(inode)) {
4809                 ret = -EOPNOTSUPP;
4810                 goto out;
4811         }
4812
4813         if (iocb->ki_flags & IOCB_NOWAIT) {
4814                 if (!inode_trylock(inode)) {
4815                         ret = -EAGAIN;
4816                         goto out;
4817                 }
4818         } else {
4819                 inode_lock(inode);
4820         }
4821
4822         ret = f2fs_write_checks(iocb, from);
4823         if (ret <= 0)
4824                 goto out_unlock;
4825
4826         /* Determine whether we will do a direct write or a buffered write. */
4827         dio = f2fs_should_use_dio(inode, iocb, from);
4828
4829         /* Possibly preallocate the blocks for the write. */
4830         target_size = iocb->ki_pos + iov_iter_count(from);
4831         preallocated = f2fs_preallocate_blocks(iocb, from, dio);
4832         if (preallocated < 0) {
4833                 ret = preallocated;
4834         } else {
4835                 if (trace_f2fs_datawrite_start_enabled())
4836                         f2fs_trace_rw_file_path(iocb->ki_filp, iocb->ki_pos,
4837                                                 orig_count, WRITE);
4838
4839                 /* Do the actual write. */
4840                 ret = dio ?
4841                         f2fs_dio_write_iter(iocb, from, &may_need_sync) :
4842                         f2fs_buffered_write_iter(iocb, from);
4843
4844                 if (trace_f2fs_datawrite_end_enabled())
4845                         trace_f2fs_datawrite_end(inode, orig_pos, ret);
4846         }
4847
4848         /* Don't leave any preallocated blocks around past i_size. */
4849         if (preallocated && i_size_read(inode) < target_size) {
4850                 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4851                 filemap_invalidate_lock(inode->i_mapping);
4852                 if (!f2fs_truncate(inode))
4853                         file_dont_truncate(inode);
4854                 filemap_invalidate_unlock(inode->i_mapping);
4855                 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4856         } else {
4857                 file_dont_truncate(inode);
4858         }
4859
4860         clear_inode_flag(inode, FI_PREALLOCATED_ALL);
4861 out_unlock:
4862         inode_unlock(inode);
4863 out:
4864         trace_f2fs_file_write_iter(inode, orig_pos, orig_count, ret);
4865
4866         if (ret > 0 && may_need_sync)
4867                 ret = generic_write_sync(iocb, ret);
4868
4869         /* If buffered IO was forced, flush and drop the data from
4870          * the page cache to preserve O_DIRECT semantics
4871          */
4872         if (ret > 0 && !dio && (iocb->ki_flags & IOCB_DIRECT))
4873                 f2fs_flush_buffered_write(iocb->ki_filp->f_mapping,
4874                                           orig_pos,
4875                                           orig_pos + ret - 1);
4876
4877         return ret;
4878 }
4879
4880 static int f2fs_file_fadvise(struct file *filp, loff_t offset, loff_t len,
4881                 int advice)
4882 {
4883         struct address_space *mapping;
4884         struct backing_dev_info *bdi;
4885         struct inode *inode = file_inode(filp);
4886         int err;
4887
4888         if (advice == POSIX_FADV_SEQUENTIAL) {
4889                 if (S_ISFIFO(inode->i_mode))
4890                         return -ESPIPE;
4891
4892                 mapping = filp->f_mapping;
4893                 if (!mapping || len < 0)
4894                         return -EINVAL;
4895
4896                 bdi = inode_to_bdi(mapping->host);
4897                 filp->f_ra.ra_pages = bdi->ra_pages *
4898                         F2FS_I_SB(inode)->seq_file_ra_mul;
4899                 spin_lock(&filp->f_lock);
4900                 filp->f_mode &= ~FMODE_RANDOM;
4901                 spin_unlock(&filp->f_lock);
4902                 return 0;
4903         } else if (advice == POSIX_FADV_WILLNEED && offset == 0) {
4904                 /* Load extent cache at the first readahead. */
4905                 f2fs_precache_extents(inode);
4906         }
4907
4908         err = generic_fadvise(filp, offset, len, advice);
4909         if (!err && advice == POSIX_FADV_DONTNEED &&
4910                 test_opt(F2FS_I_SB(inode), COMPRESS_CACHE) &&
4911                 f2fs_compressed_file(inode))
4912                 f2fs_invalidate_compress_pages(F2FS_I_SB(inode), inode->i_ino);
4913
4914         return err;
4915 }
4916
4917 #ifdef CONFIG_COMPAT
4918 struct compat_f2fs_gc_range {
4919         u32 sync;
4920         compat_u64 start;
4921         compat_u64 len;
4922 };
4923 #define F2FS_IOC32_GARBAGE_COLLECT_RANGE        _IOW(F2FS_IOCTL_MAGIC, 11,\
4924                                                 struct compat_f2fs_gc_range)
4925
4926 static int f2fs_compat_ioc_gc_range(struct file *file, unsigned long arg)
4927 {
4928         struct compat_f2fs_gc_range __user *urange;
4929         struct f2fs_gc_range range;
4930         int err;
4931
4932         urange = compat_ptr(arg);
4933         err = get_user(range.sync, &urange->sync);
4934         err |= get_user(range.start, &urange->start);
4935         err |= get_user(range.len, &urange->len);
4936         if (err)
4937                 return -EFAULT;
4938
4939         return __f2fs_ioc_gc_range(file, &range);
4940 }
4941
4942 struct compat_f2fs_move_range {
4943         u32 dst_fd;
4944         compat_u64 pos_in;
4945         compat_u64 pos_out;
4946         compat_u64 len;
4947 };
4948 #define F2FS_IOC32_MOVE_RANGE           _IOWR(F2FS_IOCTL_MAGIC, 9,      \
4949                                         struct compat_f2fs_move_range)
4950
4951 static int f2fs_compat_ioc_move_range(struct file *file, unsigned long arg)
4952 {
4953         struct compat_f2fs_move_range __user *urange;
4954         struct f2fs_move_range range;
4955         int err;
4956
4957         urange = compat_ptr(arg);
4958         err = get_user(range.dst_fd, &urange->dst_fd);
4959         err |= get_user(range.pos_in, &urange->pos_in);
4960         err |= get_user(range.pos_out, &urange->pos_out);
4961         err |= get_user(range.len, &urange->len);
4962         if (err)
4963                 return -EFAULT;
4964
4965         return __f2fs_ioc_move_range(file, &range);
4966 }
4967
4968 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
4969 {
4970         if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
4971                 return -EIO;
4972         if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(file))))
4973                 return -ENOSPC;
4974
4975         switch (cmd) {
4976         case FS_IOC32_GETVERSION:
4977                 cmd = FS_IOC_GETVERSION;
4978                 break;
4979         case F2FS_IOC32_GARBAGE_COLLECT_RANGE:
4980                 return f2fs_compat_ioc_gc_range(file, arg);
4981         case F2FS_IOC32_MOVE_RANGE:
4982                 return f2fs_compat_ioc_move_range(file, arg);
4983         case F2FS_IOC_START_ATOMIC_WRITE:
4984         case F2FS_IOC_START_ATOMIC_REPLACE:
4985         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
4986         case F2FS_IOC_START_VOLATILE_WRITE:
4987         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
4988         case F2FS_IOC_ABORT_ATOMIC_WRITE:
4989         case F2FS_IOC_SHUTDOWN:
4990         case FITRIM:
4991         case FS_IOC_SET_ENCRYPTION_POLICY:
4992         case FS_IOC_GET_ENCRYPTION_PWSALT:
4993         case FS_IOC_GET_ENCRYPTION_POLICY:
4994         case FS_IOC_GET_ENCRYPTION_POLICY_EX:
4995         case FS_IOC_ADD_ENCRYPTION_KEY:
4996         case FS_IOC_REMOVE_ENCRYPTION_KEY:
4997         case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
4998         case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
4999         case FS_IOC_GET_ENCRYPTION_NONCE:
5000         case F2FS_IOC_GARBAGE_COLLECT:
5001         case F2FS_IOC_WRITE_CHECKPOINT:
5002         case F2FS_IOC_DEFRAGMENT:
5003         case F2FS_IOC_FLUSH_DEVICE:
5004         case F2FS_IOC_GET_FEATURES:
5005         case F2FS_IOC_GET_PIN_FILE:
5006         case F2FS_IOC_SET_PIN_FILE:
5007         case F2FS_IOC_PRECACHE_EXTENTS:
5008         case F2FS_IOC_RESIZE_FS:
5009         case FS_IOC_ENABLE_VERITY:
5010         case FS_IOC_MEASURE_VERITY:
5011         case FS_IOC_READ_VERITY_METADATA:
5012         case FS_IOC_GETFSLABEL:
5013         case FS_IOC_SETFSLABEL:
5014         case F2FS_IOC_GET_COMPRESS_BLOCKS:
5015         case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
5016         case F2FS_IOC_RESERVE_COMPRESS_BLOCKS:
5017         case F2FS_IOC_SEC_TRIM_FILE:
5018         case F2FS_IOC_GET_COMPRESS_OPTION:
5019         case F2FS_IOC_SET_COMPRESS_OPTION:
5020         case F2FS_IOC_DECOMPRESS_FILE:
5021         case F2FS_IOC_COMPRESS_FILE:
5022                 break;
5023         default:
5024                 return -ENOIOCTLCMD;
5025         }
5026         return __f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
5027 }
5028 #endif
5029
5030 const struct file_operations f2fs_file_operations = {
5031         .llseek         = f2fs_llseek,
5032         .read_iter      = f2fs_file_read_iter,
5033         .write_iter     = f2fs_file_write_iter,
5034         .iopoll         = iocb_bio_iopoll,
5035         .open           = f2fs_file_open,
5036         .release        = f2fs_release_file,
5037         .mmap           = f2fs_file_mmap,
5038         .flush          = f2fs_file_flush,
5039         .fsync          = f2fs_sync_file,
5040         .fallocate      = f2fs_fallocate,
5041         .unlocked_ioctl = f2fs_ioctl,
5042 #ifdef CONFIG_COMPAT
5043         .compat_ioctl   = f2fs_compat_ioctl,
5044 #endif
5045         .splice_read    = f2fs_file_splice_read,
5046         .splice_write   = iter_file_splice_write,
5047         .fadvise        = f2fs_file_fadvise,
5048 };