fs/f2fs/file.c

   1 /*
   2  * fs/f2fs/file.c
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   5  *             http://www.samsung.com/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/fs.h>
  12 #include <linux/f2fs_fs.h>
  13 #include <linux/stat.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/writeback.h>
  16 #include <linux/blkdev.h>
  17 #include <linux/falloc.h>
  18 #include <linux/types.h>
  19 #include <linux/compat.h>
  20 #include <linux/uaccess.h>
  21 #include <linux/mount.h>
  22 #include <linux/pagevec.h>
  23 #include <linux/uio.h>
  24 #include <linux/uuid.h>
  25 #include <linux/file.h>
  26
  27 #include "f2fs.h"
  28 #include "node.h"
  29 #include "segment.h"
  30 #include "xattr.h"
  31 #include "acl.h"
  32 #include "gc.h"
  33 #include "trace.h"
  34 #include <trace/events/f2fs.h>
  35
  36 static int f2fs_vm_page_mkwrite(struct vm_fault *vmf)
  37 {
  38         struct page *page = vmf->page;
  39         struct inode *inode = file_inode(vmf->vma->vm_file);
  40         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  41         struct dnode_of_data dn;
  42         int err;
  43
  44         sb_start_pagefault(inode->i_sb);
  45
  46         f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
  47
  48         /* block allocation */
  49         f2fs_lock_op(sbi);
  50         set_new_dnode(&dn, inode, NULL, NULL, 0);
  51         err = f2fs_reserve_block(&dn, page->index);
  52         if (err) {
  53                 f2fs_unlock_op(sbi);
  54                 goto out;
  55         }
  56         f2fs_put_dnode(&dn);
  57         f2fs_unlock_op(sbi);
  58
  59         f2fs_balance_fs(sbi, dn.node_changed);
  60
  61         file_update_time(vmf->vma->vm_file);
  62         lock_page(page);
  63         if (unlikely(page->mapping != inode->i_mapping ||
  64                         page_offset(page) > i_size_read(inode) ||
  65                         !PageUptodate(page))) {
  66                 unlock_page(page);
  67                 err = -EFAULT;
  68                 goto out;
  69         }
  70
  71         /*
  72          * check to see if the page is mapped already (no holes)
  73          */
  74         if (PageMappedToDisk(page))
  75                 goto mapped;
  76
  77         /* page is wholly or partially inside EOF */
  78         if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
  79                                                 i_size_read(inode)) {
  80                 unsigned offset;
  81                 offset = i_size_read(inode) & ~PAGE_MASK;
  82                 zero_user_segment(page, offset, PAGE_SIZE);
  83         }
  84         set_page_dirty(page);
  85         if (!PageUptodate(page))
  86                 SetPageUptodate(page);
  87
  88         trace_f2fs_vm_page_mkwrite(page, DATA);
  89 mapped:
  90         /* fill the page */
  91         f2fs_wait_on_page_writeback(page, DATA, false);
  92
  93         /* wait for GCed encrypted page writeback */
  94         if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
  95                 f2fs_wait_on_encrypted_page_writeback(sbi, dn.data_blkaddr);
  96
  97 out:
  98         sb_end_pagefault(inode->i_sb);
  99         f2fs_update_time(sbi, REQ_TIME);
 100         return block_page_mkwrite_return(err);
 101 }
 102
 103 static const struct vm_operations_struct f2fs_file_vm_ops = {
 104         .fault          = filemap_fault,
 105         .map_pages      = filemap_map_pages,
 106         .page_mkwrite   = f2fs_vm_page_mkwrite,
 107 };
 108
 109 static int get_parent_ino(struct inode *inode, nid_t *pino)
 110 {
 111         struct dentry *dentry;
 112
 113         inode = igrab(inode);
 114         dentry = d_find_any_alias(inode);
 115         iput(inode);
 116         if (!dentry)
 117                 return 0;
 118
 119         *pino = parent_ino(dentry);
 120         dput(dentry);
 121         return 1;
 122 }
 123
 124 static inline bool need_do_checkpoint(struct inode *inode)
 125 {
 126         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 127         bool need_cp = false;
 128
 129         if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
 130                 need_cp = true;
 131         else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
 132                 need_cp = true;
 133         else if (file_wrong_pino(inode))
 134                 need_cp = true;
 135         else if (!space_for_roll_forward(sbi))
 136                 need_cp = true;
 137         else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
 138                 need_cp = true;
 139         else if (test_opt(sbi, FASTBOOT))
 140                 need_cp = true;
 141         else if (sbi->active_logs == 2)
 142                 need_cp = true;
 143
 144         return need_cp;
 145 }
 146
 147 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
 148 {
 149         struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
 150         bool ret = false;
 151         /* But we need to avoid that there are some inode updates */
 152         if ((i && PageDirty(i)) || need_inode_block_update(sbi, ino))
 153                 ret = true;
 154         f2fs_put_page(i, 0);
 155         return ret;
 156 }
 157
 158 static void try_to_fix_pino(struct inode *inode)
 159 {
 160         struct f2fs_inode_info *fi = F2FS_I(inode);
 161         nid_t pino;
 162
 163         down_write(&fi->i_sem);
 164         if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
 165                         get_parent_ino(inode, &pino)) {
 166                 f2fs_i_pino_write(inode, pino);
 167                 file_got_pino(inode);
 168         }
 169         up_write(&fi->i_sem);
 170 }
 171
 172 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
 173                                                 int datasync, bool atomic)
 174 {
 175         struct inode *inode = file->f_mapping->host;
 176         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 177         nid_t ino = inode->i_ino;
 178         int ret = 0;
 179         bool need_cp = false;
 180         struct writeback_control wbc = {
 181                 .sync_mode = WB_SYNC_ALL,
 182                 .nr_to_write = LONG_MAX,
 183                 .for_reclaim = 0,
 184         };
 185
 186         if (unlikely(f2fs_readonly(inode->i_sb)))
 187                 return 0;
 188
 189         trace_f2fs_sync_file_enter(inode);
 190
 191         /* if fdatasync is triggered, let's do in-place-update */
 192         if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
 193                 set_inode_flag(inode, FI_NEED_IPU);
 194         ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
 195         clear_inode_flag(inode, FI_NEED_IPU);
 196
 197         if (ret) {
 198                 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
 199                 return ret;
 200         }
 201
 202         /* if the inode is dirty, let's recover all the time */
 203         if (!f2fs_skip_inode_update(inode, datasync)) {
 204                 f2fs_write_inode(inode, NULL);
 205                 goto go_write;
 206         }
 207
 208         /*
 209          * if there is no written data, don't waste time to write recovery info.
 210          */
 211         if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
 212                         !exist_written_data(sbi, ino, APPEND_INO)) {
 213
 214                 /* it may call write_inode just prior to fsync */
 215                 if (need_inode_page_update(sbi, ino))
 216                         goto go_write;
 217
 218                 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
 219                                 exist_written_data(sbi, ino, UPDATE_INO))
 220                         goto flush_out;
 221                 goto out;
 222         }
 223 go_write:
 224         /*
 225          * Both of fdatasync() and fsync() are able to be recovered from
 226          * sudden-power-off.
 227          */
 228         down_read(&F2FS_I(inode)->i_sem);
 229         need_cp = need_do_checkpoint(inode);
 230         up_read(&F2FS_I(inode)->i_sem);
 231
 232         if (need_cp) {
 233                 /* all the dirty node pages should be flushed for POR */
 234                 ret = f2fs_sync_fs(inode->i_sb, 1);
 235
 236                 /*
 237                  * We've secured consistency through sync_fs. Following pino
 238                  * will be used only for fsynced inodes after checkpoint.
 239                  */
 240                 try_to_fix_pino(inode);
 241                 clear_inode_flag(inode, FI_APPEND_WRITE);
 242                 clear_inode_flag(inode, FI_UPDATE_WRITE);
 243                 goto out;
 244         }
 245 sync_nodes:
 246         ret = fsync_node_pages(sbi, inode, &wbc, atomic);
 247         if (ret)
 248                 goto out;
 249
 250         /* if cp_error was enabled, we should avoid infinite loop */
 251         if (unlikely(f2fs_cp_error(sbi))) {
 252                 ret = -EIO;
 253                 goto out;
 254         }
 255
 256         if (need_inode_block_update(sbi, ino)) {
 257                 f2fs_mark_inode_dirty_sync(inode, true);
 258                 f2fs_write_inode(inode, NULL);
 259                 goto sync_nodes;
 260         }
 261
 262         ret = wait_on_node_pages_writeback(sbi, ino);
 263         if (ret)
 264                 goto out;
 265
 266         /* once recovery info is written, don't need to tack this */
 267         remove_ino_entry(sbi, ino, APPEND_INO);
 268         clear_inode_flag(inode, FI_APPEND_WRITE);
 269 flush_out:
 270         remove_ino_entry(sbi, ino, UPDATE_INO);
 271         clear_inode_flag(inode, FI_UPDATE_WRITE);
 272         if (!atomic)
 273                 ret = f2fs_issue_flush(sbi);
 274         f2fs_update_time(sbi, REQ_TIME);
 275 out:
 276         trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
 277         f2fs_trace_ios(NULL, 1);
 278         return ret;
 279 }
 280
 281 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 282 {
 283         return f2fs_do_sync_file(file, start, end, datasync, false);
 284 }
 285
 286 static pgoff_t __get_first_dirty_index(struct address_space *mapping,
 287                                                 pgoff_t pgofs, int whence)
 288 {
 289         struct pagevec pvec;
 290         int nr_pages;
 291
 292         if (whence != SEEK_DATA)
 293                 return 0;
 294
 295         /* find first dirty page index */
 296         pagevec_init(&pvec, 0);
 297         nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
 298                                         PAGECACHE_TAG_DIRTY, 1);
 299         pgofs = nr_pages ? pvec.pages[0]->index : ULONG_MAX;
 300         pagevec_release(&pvec);
 301         return pgofs;
 302 }
 303
 304 static bool __found_offset(block_t blkaddr, pgoff_t dirty, pgoff_t pgofs,
 305                                                         int whence)
 306 {
 307         switch (whence) {
 308         case SEEK_DATA:
 309                 if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
 310                         (blkaddr != NEW_ADDR && blkaddr != NULL_ADDR))
 311                         return true;
 312                 break;
 313         case SEEK_HOLE:
 314                 if (blkaddr == NULL_ADDR)
 315                         return true;
 316                 break;
 317         }
 318         return false;
 319 }
 320
 321 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
 322 {
 323         struct inode *inode = file->f_mapping->host;
 324         loff_t maxbytes = inode->i_sb->s_maxbytes;
 325         struct dnode_of_data dn;
 326         pgoff_t pgofs, end_offset, dirty;
 327         loff_t data_ofs = offset;
 328         loff_t isize;
 329         int err = 0;
 330
 331         inode_lock(inode);
 332
 333         isize = i_size_read(inode);
 334         if (offset >= isize)
 335                 goto fail;
 336
 337         /* handle inline data case */
 338         if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
 339                 if (whence == SEEK_HOLE)
 340                         data_ofs = isize;
 341                 goto found;
 342         }
 343
 344         pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
 345
 346         dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
 347
 348         for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
 349                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 350                 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
 351                 if (err && err != -ENOENT) {
 352                         goto fail;
 353                 } else if (err == -ENOENT) {
 354                         /* direct node does not exists */
 355                         if (whence == SEEK_DATA) {
 356                                 pgofs = get_next_page_offset(&dn, pgofs);
 357                                 continue;
 358                         } else {
 359                                 goto found;
 360                         }
 361                 }
 362
 363                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
 364
 365                 /* find data/hole in dnode block */
 366                 for (; dn.ofs_in_node < end_offset;
 367                                 dn.ofs_in_node++, pgofs++,
 368                                 data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
 369                         block_t blkaddr;
 370                         blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 371
 372                         if (__found_offset(blkaddr, dirty, pgofs, whence)) {
 373                                 f2fs_put_dnode(&dn);
 374                                 goto found;
 375                         }
 376                 }
 377                 f2fs_put_dnode(&dn);
 378         }
 379
 380         if (whence == SEEK_DATA)
 381                 goto fail;
 382 found:
 383         if (whence == SEEK_HOLE && data_ofs > isize)
 384                 data_ofs = isize;
 385         inode_unlock(inode);
 386         return vfs_setpos(file, data_ofs, maxbytes);
 387 fail:
 388         inode_unlock(inode);
 389         return -ENXIO;
 390 }
 391
 392 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
 393 {
 394         struct inode *inode = file->f_mapping->host;
 395         loff_t maxbytes = inode->i_sb->s_maxbytes;
 396
 397         switch (whence) {
 398         case SEEK_SET:
 399         case SEEK_CUR:
 400         case SEEK_END:
 401                 return generic_file_llseek_size(file, offset, whence,
 402                                                 maxbytes, i_size_read(inode));
 403         case SEEK_DATA:
 404         case SEEK_HOLE:
 405                 if (offset < 0)
 406                         return -ENXIO;
 407                 return f2fs_seek_block(file, offset, whence);
 408         }
 409
 410         return -EINVAL;
 411 }
 412
 413 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 414 {
 415         struct inode *inode = file_inode(file);
 416         int err;
 417
 418         if (f2fs_encrypted_inode(inode)) {
 419                 err = fscrypt_get_encryption_info(inode);
 420                 if (err)
 421                         return 0;
 422                 if (!f2fs_encrypted_inode(inode))
 423                         return -ENOKEY;
 424         }
 425
 426         /* we don't need to use inline_data strictly */
 427         err = f2fs_convert_inline_inode(inode);
 428         if (err)
 429                 return err;
 430
 431         file_accessed(file);
 432         vma->vm_ops = &f2fs_file_vm_ops;
 433         return 0;
 434 }
 435
 436 static int f2fs_file_open(struct inode *inode, struct file *filp)
 437 {
 438         int ret = generic_file_open(inode, filp);
 439         struct dentry *dir;
 440
 441         if (!ret && f2fs_encrypted_inode(inode)) {
 442                 ret = fscrypt_get_encryption_info(inode);
 443                 if (ret)
 444                         return -EACCES;
 445                 if (!fscrypt_has_encryption_key(inode))
 446                         return -ENOKEY;
 447         }
 448         dir = dget_parent(file_dentry(filp));
 449         if (f2fs_encrypted_inode(d_inode(dir)) &&
 450                         !fscrypt_has_permitted_context(d_inode(dir), inode)) {
 451                 dput(dir);
 452                 return -EPERM;
 453         }
 454         dput(dir);
 455         return ret;
 456 }
 457
 458 int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 459 {
 460         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 461         struct f2fs_node *raw_node;
 462         int nr_free = 0, ofs = dn->ofs_in_node, len = count;
 463         __le32 *addr;
 464
 465         raw_node = F2FS_NODE(dn->node_page);
 466         addr = blkaddr_in_node(raw_node) + ofs;
 467
 468         for (; count > 0; count--, addr++, dn->ofs_in_node++) {
 469                 block_t blkaddr = le32_to_cpu(*addr);
 470                 if (blkaddr == NULL_ADDR)
 471                         continue;
 472
 473                 dn->data_blkaddr = NULL_ADDR;
 474                 set_data_blkaddr(dn);
 475                 invalidate_blocks(sbi, blkaddr);
 476                 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
 477                         clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
 478                 nr_free++;
 479         }
 480
 481         if (nr_free) {
 482                 pgoff_t fofs;
 483                 /*
 484                  * once we invalidate valid blkaddr in range [ofs, ofs + count],
 485                  * we will invalidate all blkaddr in the whole range.
 486                  */
 487                 fofs = start_bidx_of_node(ofs_of_node(dn->node_page),
 488                                                         dn->inode) + ofs;
 489                 f2fs_update_extent_cache_range(dn, fofs, 0, len);
 490                 dec_valid_block_count(sbi, dn->inode, nr_free);
 491         }
 492         dn->ofs_in_node = ofs;
 493
 494         f2fs_update_time(sbi, REQ_TIME);
 495         trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
 496                                          dn->ofs_in_node, nr_free);
 497         return nr_free;
 498 }
 499
 500 void truncate_data_blocks(struct dnode_of_data *dn)
 501 {
 502         truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
 503 }
 504
 505 static int truncate_partial_data_page(struct inode *inode, u64 from,
 506                                                                 bool cache_only)
 507 {
 508         unsigned offset = from & (PAGE_SIZE - 1);
 509         pgoff_t index = from >> PAGE_SHIFT;
 510         struct address_space *mapping = inode->i_mapping;
 511         struct page *page;
 512
 513         if (!offset && !cache_only)
 514                 return 0;
 515
 516         if (cache_only) {
 517                 page = find_lock_page(mapping, index);
 518                 if (page && PageUptodate(page))
 519                         goto truncate_out;
 520                 f2fs_put_page(page, 1);
 521                 return 0;
 522         }
 523
 524         page = get_lock_data_page(inode, index, true);
 525         if (IS_ERR(page))
 526                 return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
 527 truncate_out:
 528         f2fs_wait_on_page_writeback(page, DATA, true);
 529         zero_user(page, offset, PAGE_SIZE - offset);
 530         if (!cache_only || !f2fs_encrypted_inode(inode) ||
 531                                         !S_ISREG(inode->i_mode))
 532                 set_page_dirty(page);
 533         f2fs_put_page(page, 1);
 534         return 0;
 535 }
 536
 537 int truncate_blocks(struct inode *inode, u64 from, bool lock)
 538 {
 539         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 540         unsigned int blocksize = inode->i_sb->s_blocksize;
 541         struct dnode_of_data dn;
 542         pgoff_t free_from;
 543         int count = 0, err = 0;
 544         struct page *ipage;
 545         bool truncate_page = false;
 546
 547         trace_f2fs_truncate_blocks_enter(inode, from);
 548
 549         free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1);
 550
 551         if (free_from >= sbi->max_file_blocks)
 552                 goto free_partial;
 553
 554         if (lock)
 555                 f2fs_lock_op(sbi);
 556
 557         ipage = get_node_page(sbi, inode->i_ino);
 558         if (IS_ERR(ipage)) {
 559                 err = PTR_ERR(ipage);
 560                 goto out;
 561         }
 562
 563         if (f2fs_has_inline_data(inode)) {
 564                 truncate_inline_inode(inode, ipage, from);
 565                 f2fs_put_page(ipage, 1);
 566                 truncate_page = true;
 567                 goto out;
 568         }
 569
 570         set_new_dnode(&dn, inode, ipage, NULL, 0);
 571         err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
 572         if (err) {
 573                 if (err == -ENOENT)
 574                         goto free_next;
 575                 goto out;
 576         }
 577
 578         count = ADDRS_PER_PAGE(dn.node_page, inode);
 579
 580         count -= dn.ofs_in_node;
 581         f2fs_bug_on(sbi, count < 0);
 582
 583         if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
 584                 truncate_data_blocks_range(&dn, count);
 585                 free_from += count;
 586         }
 587
 588         f2fs_put_dnode(&dn);
 589 free_next:
 590         err = truncate_inode_blocks(inode, free_from);
 591 out:
 592         if (lock)
 593                 f2fs_unlock_op(sbi);
 594 free_partial:
 595         /* lastly zero out the first data page */
 596         if (!err)
 597                 err = truncate_partial_data_page(inode, from, truncate_page);
 598
 599         trace_f2fs_truncate_blocks_exit(inode, err);
 600         return err;
 601 }
 602
 603 int f2fs_truncate(struct inode *inode)
 604 {
 605         int err;
 606
 607         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 608                                 S_ISLNK(inode->i_mode)))
 609                 return 0;
 610
 611         trace_f2fs_truncate(inode);
 612
 613 #ifdef CONFIG_F2FS_FAULT_INJECTION
 614         if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
 615                 f2fs_show_injection_info(FAULT_TRUNCATE);
 616                 return -EIO;
 617         }
 618 #endif
 619         /* we should check inline_data size */
 620         if (!f2fs_may_inline_data(inode)) {
 621                 err = f2fs_convert_inline_inode(inode);
 622                 if (err)
 623                         return err;
 624         }
 625
 626         err = truncate_blocks(inode, i_size_read(inode), true);
 627         if (err)
 628                 return err;
 629
 630         inode->i_mtime = inode->i_ctime = current_time(inode);
 631         f2fs_mark_inode_dirty_sync(inode, false);
 632         return 0;
 633 }
 634
 635 int f2fs_getattr(const struct path *path, struct kstat *stat,
 636                  u32 request_mask, unsigned int query_flags)
 637 {
 638         struct inode *inode = d_inode(path->dentry);
 639         struct f2fs_inode_info *fi = F2FS_I(inode);
 640         unsigned int flags;
 641
 642         flags = fi->i_flags & FS_FL_USER_VISIBLE;
 643         if (flags & FS_APPEND_FL)
 644                 stat->attributes |= STATX_ATTR_APPEND;
 645         if (flags & FS_COMPR_FL)
 646                 stat->attributes |= STATX_ATTR_COMPRESSED;
 647         if (f2fs_encrypted_inode(inode))
 648                 stat->attributes |= STATX_ATTR_ENCRYPTED;
 649         if (flags & FS_IMMUTABLE_FL)
 650                 stat->attributes |= STATX_ATTR_IMMUTABLE;
 651         if (flags & FS_NODUMP_FL)
 652                 stat->attributes |= STATX_ATTR_NODUMP;
 653
 654         stat->attributes_mask |= (STATX_ATTR_APPEND |
 655                                   STATX_ATTR_COMPRESSED |
 656                                   STATX_ATTR_ENCRYPTED |
 657                                   STATX_ATTR_IMMUTABLE |
 658                                   STATX_ATTR_NODUMP);
 659
 660         generic_fillattr(inode, stat);
 661         stat->blocks <<= 3;
 662         return 0;
 663 }
 664
 665 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 666 static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 667 {
 668         unsigned int ia_valid = attr->ia_valid;
 669
 670         if (ia_valid & ATTR_UID)
 671                 inode->i_uid = attr->ia_uid;
 672         if (ia_valid & ATTR_GID)
 673                 inode->i_gid = attr->ia_gid;
 674         if (ia_valid & ATTR_ATIME)
 675                 inode->i_atime = timespec_trunc(attr->ia_atime,
 676                                                 inode->i_sb->s_time_gran);
 677         if (ia_valid & ATTR_MTIME)
 678                 inode->i_mtime = timespec_trunc(attr->ia_mtime,
 679                                                 inode->i_sb->s_time_gran);
 680         if (ia_valid & ATTR_CTIME)
 681                 inode->i_ctime = timespec_trunc(attr->ia_ctime,
 682                                                 inode->i_sb->s_time_gran);
 683         if (ia_valid & ATTR_MODE) {
 684                 umode_t mode = attr->ia_mode;
 685
 686                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
 687                         mode &= ~S_ISGID;
 688                 set_acl_inode(inode, mode);
 689         }
 690 }
 691 #else
 692 #define __setattr_copy setattr_copy
 693 #endif
 694
 695 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 696 {
 697         struct inode *inode = d_inode(dentry);
 698         int err;
 699         bool size_changed = false;
 700
 701         err = setattr_prepare(dentry, attr);
 702         if (err)
 703                 return err;
 704
 705         if (attr->ia_valid & ATTR_SIZE) {
 706                 if (f2fs_encrypted_inode(inode) &&
 707                                 fscrypt_get_encryption_info(inode))
 708                         return -EACCES;
 709
 710                 if (attr->ia_size <= i_size_read(inode)) {
 711                         truncate_setsize(inode, attr->ia_size);
 712                         err = f2fs_truncate(inode);
 713                         if (err)
 714                                 return err;
 715                 } else {
 716                         /*
 717                          * do not trim all blocks after i_size if target size is
 718                          * larger than i_size.
 719                          */
 720                         truncate_setsize(inode, attr->ia_size);
 721
 722                         /* should convert inline inode here */
 723                         if (!f2fs_may_inline_data(inode)) {
 724                                 err = f2fs_convert_inline_inode(inode);
 725                                 if (err)
 726                                         return err;
 727                         }
 728                         inode->i_mtime = inode->i_ctime = current_time(inode);
 729                 }
 730
 731                 size_changed = true;
 732         }
 733
 734         __setattr_copy(inode, attr);
 735
 736         if (attr->ia_valid & ATTR_MODE) {
 737                 err = posix_acl_chmod(inode, get_inode_mode(inode));
 738                 if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
 739                         inode->i_mode = F2FS_I(inode)->i_acl_mode;
 740                         clear_inode_flag(inode, FI_ACL_MODE);
 741                 }
 742         }
 743
 744         /* file size may changed here */
 745         f2fs_mark_inode_dirty_sync(inode, size_changed);
 746
 747         /* inode change will produce dirty node pages flushed by checkpoint */
 748         f2fs_balance_fs(F2FS_I_SB(inode), true);
 749
 750         return err;
 751 }
 752
 753 const struct inode_operations f2fs_file_inode_operations = {
 754         .getattr        = f2fs_getattr,
 755         .setattr        = f2fs_setattr,
 756         .get_acl        = f2fs_get_acl,
 757         .set_acl        = f2fs_set_acl,
 758 #ifdef CONFIG_F2FS_FS_XATTR
 759         .listxattr      = f2fs_listxattr,
 760 #endif
 761         .fiemap         = f2fs_fiemap,
 762 };
 763
 764 static int fill_zero(struct inode *inode, pgoff_t index,
 765                                         loff_t start, loff_t len)
 766 {
 767         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 768         struct page *page;
 769
 770         if (!len)
 771                 return 0;
 772
 773         f2fs_balance_fs(sbi, true);
 774
 775         f2fs_lock_op(sbi);
 776         page = get_new_data_page(inode, NULL, index, false);
 777         f2fs_unlock_op(sbi);
 778
 779         if (IS_ERR(page))
 780                 return PTR_ERR(page);
 781
 782         f2fs_wait_on_page_writeback(page, DATA, true);
 783         zero_user(page, start, len);
 784         set_page_dirty(page);
 785         f2fs_put_page(page, 1);
 786         return 0;
 787 }
 788
 789 int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
 790 {
 791         int err;
 792
 793         while (pg_start < pg_end) {
 794                 struct dnode_of_data dn;
 795                 pgoff_t end_offset, count;
 796
 797                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 798                 err = get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
 799                 if (err) {
 800                         if (err == -ENOENT) {
 801                                 pg_start++;
 802                                 continue;
 803                         }
 804                         return err;
 805                 }
 806
 807                 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
 808                 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
 809
 810                 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
 811
 812                 truncate_data_blocks_range(&dn, count);
 813                 f2fs_put_dnode(&dn);
 814
 815                 pg_start += count;
 816         }
 817         return 0;
 818 }
 819
 820 static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
 821 {
 822         pgoff_t pg_start, pg_end;
 823         loff_t off_start, off_end;
 824         int ret;
 825
 826         ret = f2fs_convert_inline_inode(inode);
 827         if (ret)
 828                 return ret;
 829
 830         pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
 831         pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
 832
 833         off_start = offset & (PAGE_SIZE - 1);
 834         off_end = (offset + len) & (PAGE_SIZE - 1);
 835
 836         if (pg_start == pg_end) {
 837                 ret = fill_zero(inode, pg_start, off_start,
 838                                                 off_end - off_start);
 839                 if (ret)
 840                         return ret;
 841         } else {
 842                 if (off_start) {
 843                         ret = fill_zero(inode, pg_start++, off_start,
 844                                                 PAGE_SIZE - off_start);
 845                         if (ret)
 846                                 return ret;
 847                 }
 848                 if (off_end) {
 849                         ret = fill_zero(inode, pg_end, 0, off_end);
 850                         if (ret)
 851                                 return ret;
 852                 }
 853
 854                 if (pg_start < pg_end) {
 855                         struct address_space *mapping = inode->i_mapping;
 856                         loff_t blk_start, blk_end;
 857                         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 858
 859                         f2fs_balance_fs(sbi, true);
 860
 861                         blk_start = (loff_t)pg_start << PAGE_SHIFT;
 862                         blk_end = (loff_t)pg_end << PAGE_SHIFT;
 863                         truncate_inode_pages_range(mapping, blk_start,
 864                                         blk_end - 1);
 865
 866                         f2fs_lock_op(sbi);
 867                         ret = truncate_hole(inode, pg_start, pg_end);
 868                         f2fs_unlock_op(sbi);
 869                 }
 870         }
 871
 872         return ret;
 873 }
 874
 875 static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
 876                                 int *do_replace, pgoff_t off, pgoff_t len)
 877 {
 878         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 879         struct dnode_of_data dn;
 880         int ret, done, i;
 881
 882 next_dnode:
 883         set_new_dnode(&dn, inode, NULL, NULL, 0);
 884         ret = get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
 885         if (ret && ret != -ENOENT) {
 886                 return ret;
 887         } else if (ret == -ENOENT) {
 888                 if (dn.max_level == 0)
 889                         return -ENOENT;
 890                 done = min((pgoff_t)ADDRS_PER_BLOCK - dn.ofs_in_node, len);
 891                 blkaddr += done;
 892                 do_replace += done;
 893                 goto next;
 894         }
 895
 896         done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
 897                                                         dn.ofs_in_node, len);
 898         for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
 899                 *blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 900                 if (!is_checkpointed_data(sbi, *blkaddr)) {
 901
 902                         if (test_opt(sbi, LFS)) {
 903                                 f2fs_put_dnode(&dn);
 904                                 return -ENOTSUPP;
 905                         }
 906
 907                         /* do not invalidate this block address */
 908                         f2fs_update_data_blkaddr(&dn, NULL_ADDR);
 909                         *do_replace = 1;
 910                 }
 911         }
 912         f2fs_put_dnode(&dn);
 913 next:
 914         len -= done;
 915         off += done;
 916         if (len)
 917                 goto next_dnode;
 918         return 0;
 919 }
 920
 921 static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
 922                                 int *do_replace, pgoff_t off, int len)
 923 {
 924         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 925         struct dnode_of_data dn;
 926         int ret, i;
 927
 928         for (i = 0; i < len; i++, do_replace++, blkaddr++) {
 929                 if (*do_replace == 0)
 930                         continue;
 931
 932                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 933                 ret = get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
 934                 if (ret) {
 935                         dec_valid_block_count(sbi, inode, 1);
 936                         invalidate_blocks(sbi, *blkaddr);
 937                 } else {
 938                         f2fs_update_data_blkaddr(&dn, *blkaddr);
 939                 }
 940                 f2fs_put_dnode(&dn);
 941         }
 942         return 0;
 943 }
 944
 945 static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
 946                         block_t *blkaddr, int *do_replace,
 947                         pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
 948 {
 949         struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
 950         pgoff_t i = 0;
 951         int ret;
 952
 953         while (i < len) {
 954                 if (blkaddr[i] == NULL_ADDR && !full) {
 955                         i++;
 956                         continue;
 957                 }
 958
 959                 if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
 960                         struct dnode_of_data dn;
 961                         struct node_info ni;
 962                         size_t new_size;
 963                         pgoff_t ilen;
 964
 965                         set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
 966                         ret = get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
 967                         if (ret)
 968                                 return ret;
 969
 970                         get_node_info(sbi, dn.nid, &ni);
 971                         ilen = min((pgoff_t)
 972                                 ADDRS_PER_PAGE(dn.node_page, dst_inode) -
 973                                                 dn.ofs_in_node, len - i);
 974                         do {
 975                                 dn.data_blkaddr = datablock_addr(dn.node_page,
 976                                                                 dn.ofs_in_node);
 977                                 truncate_data_blocks_range(&dn, 1);
 978
 979                                 if (do_replace[i]) {
 980                                         f2fs_i_blocks_write(src_inode,
 981                                                                 1, false);
 982                                         f2fs_i_blocks_write(dst_inode,
 983                                                                 1, true);
 984                                         f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
 985                                         blkaddr[i], ni.version, true, false);
 986
 987                                         do_replace[i] = 0;
 988                                 }
 989                                 dn.ofs_in_node++;
 990                                 i++;
 991                                 new_size = (dst + i) << PAGE_SHIFT;
 992                                 if (dst_inode->i_size < new_size)
 993                                         f2fs_i_size_write(dst_inode, new_size);
 994                         } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));
 995
 996                         f2fs_put_dnode(&dn);
 997                 } else {
 998                         struct page *psrc, *pdst;
 999
1000                         psrc = get_lock_data_page(src_inode, src + i, true);
1001                         if (IS_ERR(psrc))
1002                                 return PTR_ERR(psrc);
1003                         pdst = get_new_data_page(dst_inode, NULL, dst + i,
1004                                                                 true);
1005                         if (IS_ERR(pdst)) {
1006                                 f2fs_put_page(psrc, 1);
1007                                 return PTR_ERR(pdst);
1008                         }
1009                         f2fs_copy_page(psrc, pdst);
1010                         set_page_dirty(pdst);
1011                         f2fs_put_page(pdst, 1);
1012                         f2fs_put_page(psrc, 1);
1013
1014                         ret = truncate_hole(src_inode, src + i, src + i + 1);
1015                         if (ret)
1016                                 return ret;
1017                         i++;
1018                 }
1019         }
1020         return 0;
1021 }
1022
1023 static int __exchange_data_block(struct inode *src_inode,
1024                         struct inode *dst_inode, pgoff_t src, pgoff_t dst,
1025                         pgoff_t len, bool full)
1026 {
1027         block_t *src_blkaddr;
1028         int *do_replace;
1029         pgoff_t olen;
1030         int ret;
1031
1032         while (len) {
1033                 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len);
1034
1035                 src_blkaddr = f2fs_kvzalloc(sizeof(block_t) * olen, GFP_KERNEL);
1036                 if (!src_blkaddr)
1037                         return -ENOMEM;
1038
1039                 do_replace = f2fs_kvzalloc(sizeof(int) * olen, GFP_KERNEL);
1040                 if (!do_replace) {
1041                         kvfree(src_blkaddr);
1042                         return -ENOMEM;
1043                 }
1044
1045                 ret = __read_out_blkaddrs(src_inode, src_blkaddr,
1046                                         do_replace, src, olen);
1047                 if (ret)
1048                         goto roll_back;
1049
1050                 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
1051                                         do_replace, src, dst, olen, full);
1052                 if (ret)
1053                         goto roll_back;
1054
1055                 src += olen;
1056                 dst += olen;
1057                 len -= olen;
1058
1059                 kvfree(src_blkaddr);
1060                 kvfree(do_replace);
1061         }
1062         return 0;
1063
1064 roll_back:
1065         __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, len);
1066         kvfree(src_blkaddr);
1067         kvfree(do_replace);
1068         return ret;
1069 }
1070
1071 static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end)
1072 {
1073         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1074         pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
1075         int ret;
1076
1077         f2fs_balance_fs(sbi, true);
1078         f2fs_lock_op(sbi);
1079
1080         f2fs_drop_extent_tree(inode);
1081
1082         ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1083         f2fs_unlock_op(sbi);
1084         return ret;
1085 }
1086
1087 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1088 {
1089         pgoff_t pg_start, pg_end;
1090         loff_t new_size;
1091         int ret;
1092
1093         if (offset + len >= i_size_read(inode))
1094                 return -EINVAL;
1095
1096         /* collapse range should be aligned to block size of f2fs. */
1097         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1098                 return -EINVAL;
1099
1100         ret = f2fs_convert_inline_inode(inode);
1101         if (ret)
1102                 return ret;
1103
1104         pg_start = offset >> PAGE_SHIFT;
1105         pg_end = (offset + len) >> PAGE_SHIFT;
1106
1107         /* write out all dirty pages from offset */
1108         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1109         if (ret)
1110                 return ret;
1111
1112         truncate_pagecache(inode, offset);
1113
1114         ret = f2fs_do_collapse(inode, pg_start, pg_end);
1115         if (ret)
1116                 return ret;
1117
1118         /* write out all moved pages, if possible */
1119         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1120         truncate_pagecache(inode, offset);
1121
1122         new_size = i_size_read(inode) - len;
1123         truncate_pagecache(inode, new_size);
1124
1125         ret = truncate_blocks(inode, new_size, true);
1126         if (!ret)
1127                 f2fs_i_size_write(inode, new_size);
1128
1129         return ret;
1130 }
1131
1132 static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
1133                                                                 pgoff_t end)
1134 {
1135         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
1136         pgoff_t index = start;
1137         unsigned int ofs_in_node = dn->ofs_in_node;
1138         blkcnt_t count = 0;
1139         int ret;
1140
1141         for (; index < end; index++, dn->ofs_in_node++) {
1142                 if (datablock_addr(dn->node_page, dn->ofs_in_node) == NULL_ADDR)
1143                         count++;
1144         }
1145
1146         dn->ofs_in_node = ofs_in_node;
1147         ret = reserve_new_blocks(dn, count);
1148         if (ret)
1149                 return ret;
1150
1151         dn->ofs_in_node = ofs_in_node;
1152         for (index = start; index < end; index++, dn->ofs_in_node++) {
1153                 dn->data_blkaddr =
1154                                 datablock_addr(dn->node_page, dn->ofs_in_node);
1155                 /*
1156                  * reserve_new_blocks will not guarantee entire block
1157                  * allocation.
1158                  */
1159                 if (dn->data_blkaddr == NULL_ADDR) {
1160                         ret = -ENOSPC;
1161                         break;
1162                 }
1163                 if (dn->data_blkaddr != NEW_ADDR) {
1164                         invalidate_blocks(sbi, dn->data_blkaddr);
1165                         dn->data_blkaddr = NEW_ADDR;
1166                         set_data_blkaddr(dn);
1167                 }
1168         }
1169
1170         f2fs_update_extent_cache_range(dn, start, 0, index - start);
1171
1172         return ret;
1173 }
1174
1175 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
1176                                                                 int mode)
1177 {
1178         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1179         struct address_space *mapping = inode->i_mapping;
1180         pgoff_t index, pg_start, pg_end;
1181         loff_t new_size = i_size_read(inode);
1182         loff_t off_start, off_end;
1183         int ret = 0;
1184
1185         ret = inode_newsize_ok(inode, (len + offset));
1186         if (ret)
1187                 return ret;
1188
1189         ret = f2fs_convert_inline_inode(inode);
1190         if (ret)
1191                 return ret;
1192
1193         ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
1194         if (ret)
1195                 return ret;
1196
1197         truncate_pagecache_range(inode, offset, offset + len - 1);
1198
1199         pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1200         pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1201
1202         off_start = offset & (PAGE_SIZE - 1);
1203         off_end = (offset + len) & (PAGE_SIZE - 1);
1204
1205         if (pg_start == pg_end) {
1206                 ret = fill_zero(inode, pg_start, off_start,
1207                                                 off_end - off_start);
1208                 if (ret)
1209                         return ret;
1210
1211                 new_size = max_t(loff_t, new_size, offset + len);
1212         } else {
1213                 if (off_start) {
1214                         ret = fill_zero(inode, pg_start++, off_start,
1215                                                 PAGE_SIZE - off_start);
1216                         if (ret)
1217                                 return ret;
1218
1219                         new_size = max_t(loff_t, new_size,
1220                                         (loff_t)pg_start << PAGE_SHIFT);
1221                 }
1222
1223                 for (index = pg_start; index < pg_end;) {
1224                         struct dnode_of_data dn;
1225                         unsigned int end_offset;
1226                         pgoff_t end;
1227
1228                         f2fs_lock_op(sbi);
1229
1230                         set_new_dnode(&dn, inode, NULL, NULL, 0);
1231                         ret = get_dnode_of_data(&dn, index, ALLOC_NODE);
1232                         if (ret) {
1233                                 f2fs_unlock_op(sbi);
1234                                 goto out;
1235                         }
1236
1237                         end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1238                         end = min(pg_end, end_offset - dn.ofs_in_node + index);
1239
1240                         ret = f2fs_do_zero_range(&dn, index, end);
1241                         f2fs_put_dnode(&dn);
1242                         f2fs_unlock_op(sbi);
1243
1244                         f2fs_balance_fs(sbi, dn.node_changed);
1245
1246                         if (ret)
1247                                 goto out;
1248
1249                         index = end;
1250                         new_size = max_t(loff_t, new_size,
1251                                         (loff_t)index << PAGE_SHIFT);
1252                 }
1253
1254                 if (off_end) {
1255                         ret = fill_zero(inode, pg_end, 0, off_end);
1256                         if (ret)
1257                                 goto out;
1258
1259                         new_size = max_t(loff_t, new_size, offset + len);
1260                 }
1261         }
1262
1263 out:
1264         if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
1265                 f2fs_i_size_write(inode, new_size);
1266
1267         return ret;
1268 }
1269
1270 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1271 {
1272         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1273         pgoff_t nr, pg_start, pg_end, delta, idx;
1274         loff_t new_size;
1275         int ret = 0;
1276
1277         new_size = i_size_read(inode) + len;
1278         ret = inode_newsize_ok(inode, new_size);
1279         if (ret)
1280                 return ret;
1281
1282         if (offset >= i_size_read(inode))
1283                 return -EINVAL;
1284
1285         /* insert range should be aligned to block size of f2fs. */
1286         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1287                 return -EINVAL;
1288
1289         ret = f2fs_convert_inline_inode(inode);
1290         if (ret)
1291                 return ret;
1292
1293         f2fs_balance_fs(sbi, true);
1294
1295         ret = truncate_blocks(inode, i_size_read(inode), true);
1296         if (ret)
1297                 return ret;
1298
1299         /* write out all dirty pages from offset */
1300         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1301         if (ret)
1302                 return ret;
1303
1304         truncate_pagecache(inode, offset);
1305
1306         pg_start = offset >> PAGE_SHIFT;
1307         pg_end = (offset + len) >> PAGE_SHIFT;
1308         delta = pg_end - pg_start;
1309         idx = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
1310
1311         while (!ret && idx > pg_start) {
1312                 nr = idx - pg_start;
1313                 if (nr > delta)
1314                         nr = delta;
1315                 idx -= nr;
1316
1317                 f2fs_lock_op(sbi);
1318                 f2fs_drop_extent_tree(inode);
1319
1320                 ret = __exchange_data_block(inode, inode, idx,
1321                                         idx + delta, nr, false);
1322                 f2fs_unlock_op(sbi);
1323         }
1324
1325         /* write out all moved pages, if possible */
1326         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1327         truncate_pagecache(inode, offset);
1328
1329         if (!ret)
1330                 f2fs_i_size_write(inode, new_size);
1331         return ret;
1332 }
1333
1334 static int expand_inode_data(struct inode *inode, loff_t offset,
1335                                         loff_t len, int mode)
1336 {
1337         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1338         struct f2fs_map_blocks map = { .m_next_pgofs = NULL };
1339         pgoff_t pg_end;
1340         loff_t new_size = i_size_read(inode);
1341         loff_t off_end;
1342         int err;
1343
1344         err = inode_newsize_ok(inode, (len + offset));
1345         if (err)
1346                 return err;
1347
1348         err = f2fs_convert_inline_inode(inode);
1349         if (err)
1350                 return err;
1351
1352         f2fs_balance_fs(sbi, true);
1353
1354         pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
1355         off_end = (offset + len) & (PAGE_SIZE - 1);
1356
1357         map.m_lblk = ((unsigned long long)offset) >> PAGE_SHIFT;
1358         map.m_len = pg_end - map.m_lblk;
1359         if (off_end)
1360                 map.m_len++;
1361
1362         err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
1363         if (err) {
1364                 pgoff_t last_off;
1365
1366                 if (!map.m_len)
1367                         return err;
1368
1369                 last_off = map.m_lblk + map.m_len - 1;
1370
1371                 /* update new size to the failed position */
1372                 new_size = (last_off == pg_end) ? offset + len:
1373                                         (loff_t)(last_off + 1) << PAGE_SHIFT;
1374         } else {
1375                 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
1376         }
1377
1378         if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
1379                 f2fs_i_size_write(inode, new_size);
1380
1381         return err;
1382 }
1383
1384 static long f2fs_fallocate(struct file *file, int mode,
1385                                 loff_t offset, loff_t len)
1386 {
1387         struct inode *inode = file_inode(file);
1388         long ret = 0;
1389
1390         /* f2fs only support ->fallocate for regular file */
1391         if (!S_ISREG(inode->i_mode))
1392                 return -EINVAL;
1393
1394         if (f2fs_encrypted_inode(inode) &&
1395                 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
1396                 return -EOPNOTSUPP;
1397
1398         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1399                         FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
1400                         FALLOC_FL_INSERT_RANGE))
1401                 return -EOPNOTSUPP;
1402
1403         inode_lock(inode);
1404
1405         if (mode & FALLOC_FL_PUNCH_HOLE) {
1406                 if (offset >= inode->i_size)
1407                         goto out;
1408
1409                 ret = punch_hole(inode, offset, len);
1410         } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1411                 ret = f2fs_collapse_range(inode, offset, len);
1412         } else if (mode & FALLOC_FL_ZERO_RANGE) {
1413                 ret = f2fs_zero_range(inode, offset, len, mode);
1414         } else if (mode & FALLOC_FL_INSERT_RANGE) {
1415                 ret = f2fs_insert_range(inode, offset, len);
1416         } else {
1417                 ret = expand_inode_data(inode, offset, len, mode);
1418         }
1419
1420         if (!ret) {
1421                 inode->i_mtime = inode->i_ctime = current_time(inode);
1422                 f2fs_mark_inode_dirty_sync(inode, false);
1423                 if (mode & FALLOC_FL_KEEP_SIZE)
1424                         file_set_keep_isize(inode);
1425                 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1426         }
1427
1428 out:
1429         inode_unlock(inode);
1430
1431         trace_f2fs_fallocate(inode, mode, offset, len, ret);
1432         return ret;
1433 }
1434
1435 static int f2fs_release_file(struct inode *inode, struct file *filp)
1436 {
1437         /*
1438          * f2fs_relase_file is called at every close calls. So we should
1439          * not drop any inmemory pages by close called by other process.
1440          */
1441         if (!(filp->f_mode & FMODE_WRITE) ||
1442                         atomic_read(&inode->i_writecount) != 1)
1443                 return 0;
1444
1445         /* some remained atomic pages should discarded */
1446         if (f2fs_is_atomic_file(inode))
1447                 drop_inmem_pages(inode);
1448         if (f2fs_is_volatile_file(inode)) {
1449                 clear_inode_flag(inode, FI_VOLATILE_FILE);
1450                 stat_dec_volatile_write(inode);
1451                 set_inode_flag(inode, FI_DROP_CACHE);
1452                 filemap_fdatawrite(inode->i_mapping);
1453                 clear_inode_flag(inode, FI_DROP_CACHE);
1454         }
1455         return 0;
1456 }
1457
1458 #define F2FS_REG_FLMASK         (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
1459 #define F2FS_OTHER_FLMASK       (FS_NODUMP_FL | FS_NOATIME_FL)
1460
1461 static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
1462 {
1463         if (S_ISDIR(mode))
1464                 return flags;
1465         else if (S_ISREG(mode))
1466                 return flags & F2FS_REG_FLMASK;
1467         else
1468                 return flags & F2FS_OTHER_FLMASK;
1469 }
1470
1471 static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
1472 {
1473         struct inode *inode = file_inode(filp);
1474         struct f2fs_inode_info *fi = F2FS_I(inode);
1475         unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
1476         return put_user(flags, (int __user *)arg);
1477 }
1478
1479 static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1480 {
1481         struct inode *inode = file_inode(filp);
1482         struct f2fs_inode_info *fi = F2FS_I(inode);
1483         unsigned int flags;
1484         unsigned int oldflags;
1485         int ret;
1486
1487         if (!inode_owner_or_capable(inode))
1488                 return -EACCES;
1489
1490         if (get_user(flags, (int __user *)arg))
1491                 return -EFAULT;
1492
1493         ret = mnt_want_write_file(filp);
1494         if (ret)
1495                 return ret;
1496
1497         inode_lock(inode);
1498
1499         flags = f2fs_mask_flags(inode->i_mode, flags);
1500
1501         oldflags = fi->i_flags;
1502
1503         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
1504                 if (!capable(CAP_LINUX_IMMUTABLE)) {
1505                         inode_unlock(inode);
1506                         ret = -EPERM;
1507                         goto out;
1508                 }
1509         }
1510
1511         flags = flags & FS_FL_USER_MODIFIABLE;
1512         flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
1513         fi->i_flags = flags;
1514
1515         inode->i_ctime = current_time(inode);
1516         f2fs_set_inode_flags(inode);
1517         f2fs_mark_inode_dirty_sync(inode, false);
1518
1519         inode_unlock(inode);
1520 out:
1521         mnt_drop_write_file(filp);
1522         return ret;
1523 }
1524
1525 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
1526 {
1527         struct inode *inode = file_inode(filp);
1528
1529         return put_user(inode->i_generation, (int __user *)arg);
1530 }
1531
1532 static int f2fs_ioc_start_atomic_write(struct file *filp)
1533 {
1534         struct inode *inode = file_inode(filp);
1535         int ret;
1536
1537         if (!inode_owner_or_capable(inode))
1538                 return -EACCES;
1539
1540         if (!S_ISREG(inode->i_mode))
1541                 return -EINVAL;
1542
1543         ret = mnt_want_write_file(filp);
1544         if (ret)
1545                 return ret;
1546
1547         inode_lock(inode);
1548
1549         if (f2fs_is_atomic_file(inode))
1550                 goto out;
1551
1552         ret = f2fs_convert_inline_inode(inode);
1553         if (ret)
1554                 goto out;
1555
1556         set_inode_flag(inode, FI_ATOMIC_FILE);
1557         set_inode_flag(inode, FI_HOT_DATA);
1558         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1559
1560         if (!get_dirty_pages(inode))
1561                 goto inc_stat;
1562
1563         f2fs_msg(F2FS_I_SB(inode)->sb, KERN_WARNING,
1564                 "Unexpected flush for atomic writes: ino=%lu, npages=%u",
1565                                         inode->i_ino, get_dirty_pages(inode));
1566         ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
1567         if (ret) {
1568                 clear_inode_flag(inode, FI_ATOMIC_FILE);
1569                 goto out;
1570         }
1571
1572 inc_stat:
1573         stat_inc_atomic_write(inode);
1574         stat_update_max_atomic_write(inode);
1575 out:
1576         inode_unlock(inode);
1577         mnt_drop_write_file(filp);
1578         return ret;
1579 }
1580
1581 static int f2fs_ioc_commit_atomic_write(struct file *filp)
1582 {
1583         struct inode *inode = file_inode(filp);
1584         int ret;
1585
1586         if (!inode_owner_or_capable(inode))
1587                 return -EACCES;
1588
1589         ret = mnt_want_write_file(filp);
1590         if (ret)
1591                 return ret;
1592
1593         inode_lock(inode);
1594
1595         if (f2fs_is_volatile_file(inode))
1596                 goto err_out;
1597
1598         if (f2fs_is_atomic_file(inode)) {
1599                 ret = commit_inmem_pages(inode);
1600                 if (ret)
1601                         goto err_out;
1602
1603                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1604                 if (!ret) {
1605                         clear_inode_flag(inode, FI_ATOMIC_FILE);
1606                         stat_dec_atomic_write(inode);
1607                 }
1608         } else {
1609                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1610         }
1611 err_out:
1612         inode_unlock(inode);
1613         mnt_drop_write_file(filp);
1614         return ret;
1615 }
1616
1617 static int f2fs_ioc_start_volatile_write(struct file *filp)
1618 {
1619         struct inode *inode = file_inode(filp);
1620         int ret;
1621
1622         if (!inode_owner_or_capable(inode))
1623                 return -EACCES;
1624
1625         if (!S_ISREG(inode->i_mode))
1626                 return -EINVAL;
1627
1628         ret = mnt_want_write_file(filp);
1629         if (ret)
1630                 return ret;
1631
1632         inode_lock(inode);
1633
1634         if (f2fs_is_volatile_file(inode))
1635                 goto out;
1636
1637         ret = f2fs_convert_inline_inode(inode);
1638         if (ret)
1639                 goto out;
1640
1641         stat_inc_volatile_write(inode);
1642         stat_update_max_volatile_write(inode);
1643
1644         set_inode_flag(inode, FI_VOLATILE_FILE);
1645         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1646 out:
1647         inode_unlock(inode);
1648         mnt_drop_write_file(filp);
1649         return ret;
1650 }
1651
1652 static int f2fs_ioc_release_volatile_write(struct file *filp)
1653 {
1654         struct inode *inode = file_inode(filp);
1655         int ret;
1656
1657         if (!inode_owner_or_capable(inode))
1658                 return -EACCES;
1659
1660         ret = mnt_want_write_file(filp);
1661         if (ret)
1662                 return ret;
1663
1664         inode_lock(inode);
1665
1666         if (!f2fs_is_volatile_file(inode))
1667                 goto out;
1668
1669         if (!f2fs_is_first_block_written(inode)) {
1670                 ret = truncate_partial_data_page(inode, 0, true);
1671                 goto out;
1672         }
1673
1674         ret = punch_hole(inode, 0, F2FS_BLKSIZE);
1675 out:
1676         inode_unlock(inode);
1677         mnt_drop_write_file(filp);
1678         return ret;
1679 }
1680
1681 static int f2fs_ioc_abort_volatile_write(struct file *filp)
1682 {
1683         struct inode *inode = file_inode(filp);
1684         int ret;
1685
1686         if (!inode_owner_or_capable(inode))
1687                 return -EACCES;
1688
1689         ret = mnt_want_write_file(filp);
1690         if (ret)
1691                 return ret;
1692
1693         inode_lock(inode);
1694
1695         if (f2fs_is_atomic_file(inode))
1696                 drop_inmem_pages(inode);
1697         if (f2fs_is_volatile_file(inode)) {
1698                 clear_inode_flag(inode, FI_VOLATILE_FILE);
1699                 stat_dec_volatile_write(inode);
1700                 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1701         }
1702
1703         inode_unlock(inode);
1704
1705         mnt_drop_write_file(filp);
1706         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1707         return ret;
1708 }
1709
1710 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
1711 {
1712         struct inode *inode = file_inode(filp);
1713         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1714         struct super_block *sb = sbi->sb;
1715         __u32 in;
1716         int ret;
1717
1718         if (!capable(CAP_SYS_ADMIN))
1719                 return -EPERM;
1720
1721         if (get_user(in, (__u32 __user *)arg))
1722                 return -EFAULT;
1723
1724         ret = mnt_want_write_file(filp);
1725         if (ret)
1726                 return ret;
1727
1728         switch (in) {
1729         case F2FS_GOING_DOWN_FULLSYNC:
1730                 sb = freeze_bdev(sb->s_bdev);
1731                 if (sb && !IS_ERR(sb)) {
1732                         f2fs_stop_checkpoint(sbi, false);
1733                         thaw_bdev(sb->s_bdev, sb);
1734                 }
1735                 break;
1736         case F2FS_GOING_DOWN_METASYNC:
1737                 /* do checkpoint only */
1738                 f2fs_sync_fs(sb, 1);
1739                 f2fs_stop_checkpoint(sbi, false);
1740                 break;
1741         case F2FS_GOING_DOWN_NOSYNC:
1742                 f2fs_stop_checkpoint(sbi, false);
1743                 break;
1744         case F2FS_GOING_DOWN_METAFLUSH:
1745                 sync_meta_pages(sbi, META, LONG_MAX);
1746                 f2fs_stop_checkpoint(sbi, false);
1747                 break;
1748         default:
1749                 ret = -EINVAL;
1750                 goto out;
1751         }
1752         f2fs_update_time(sbi, REQ_TIME);
1753 out:
1754         mnt_drop_write_file(filp);
1755         return ret;
1756 }
1757
1758 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
1759 {
1760         struct inode *inode = file_inode(filp);
1761         struct super_block *sb = inode->i_sb;
1762         struct request_queue *q = bdev_get_queue(sb->s_bdev);
1763         struct fstrim_range range;
1764         int ret;
1765
1766         if (!capable(CAP_SYS_ADMIN))
1767                 return -EPERM;
1768
1769         if (!blk_queue_discard(q))
1770                 return -EOPNOTSUPP;
1771
1772         if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1773                                 sizeof(range)))
1774                 return -EFAULT;
1775
1776         ret = mnt_want_write_file(filp);
1777         if (ret)
1778                 return ret;
1779
1780         range.minlen = max((unsigned int)range.minlen,
1781                                 q->limits.discard_granularity);
1782         ret = f2fs_trim_fs(F2FS_SB(sb), &range);
1783         mnt_drop_write_file(filp);
1784         if (ret < 0)
1785                 return ret;
1786
1787         if (copy_to_user((struct fstrim_range __user *)arg, &range,
1788                                 sizeof(range)))
1789                 return -EFAULT;
1790         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1791         return 0;
1792 }
1793
1794 static bool uuid_is_nonzero(__u8 u[16])
1795 {
1796         int i;
1797
1798         for (i = 0; i < 16; i++)
1799                 if (u[i])
1800                         return true;
1801         return false;
1802 }
1803
1804 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
1805 {
1806         struct inode *inode = file_inode(filp);
1807
1808         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1809
1810         return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
1811 }
1812
1813 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
1814 {
1815         return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
1816 }
1817
1818 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
1819 {
1820         struct inode *inode = file_inode(filp);
1821         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1822         int err;
1823
1824         if (!f2fs_sb_has_crypto(inode->i_sb))
1825                 return -EOPNOTSUPP;
1826
1827         if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
1828                 goto got_it;
1829
1830         err = mnt_want_write_file(filp);
1831         if (err)
1832                 return err;
1833
1834         /* update superblock with uuid */
1835         generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
1836
1837         err = f2fs_commit_super(sbi, false);
1838         if (err) {
1839                 /* undo new data */
1840                 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
1841                 mnt_drop_write_file(filp);
1842                 return err;
1843         }
1844         mnt_drop_write_file(filp);
1845 got_it:
1846         if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
1847                                                                         16))
1848                 return -EFAULT;
1849         return 0;
1850 }
1851
1852 static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
1853 {
1854         struct inode *inode = file_inode(filp);
1855         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1856         __u32 sync;
1857         int ret;
1858
1859         if (!capable(CAP_SYS_ADMIN))
1860                 return -EPERM;
1861
1862         if (get_user(sync, (__u32 __user *)arg))
1863                 return -EFAULT;
1864
1865         if (f2fs_readonly(sbi->sb))
1866                 return -EROFS;
1867
1868         ret = mnt_want_write_file(filp);
1869         if (ret)
1870                 return ret;
1871
1872         if (!sync) {
1873                 if (!mutex_trylock(&sbi->gc_mutex)) {
1874                         ret = -EBUSY;
1875                         goto out;
1876                 }
1877         } else {
1878                 mutex_lock(&sbi->gc_mutex);
1879         }
1880
1881         ret = f2fs_gc(sbi, sync, true, NULL_SEGNO);
1882 out:
1883         mnt_drop_write_file(filp);
1884         return ret;
1885 }
1886
1887 static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg)
1888 {
1889         struct inode *inode = file_inode(filp);
1890         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1891         int ret;
1892
1893         if (!capable(CAP_SYS_ADMIN))
1894                 return -EPERM;
1895
1896         if (f2fs_readonly(sbi->sb))
1897                 return -EROFS;
1898
1899         ret = mnt_want_write_file(filp);
1900         if (ret)
1901                 return ret;
1902
1903         ret = f2fs_sync_fs(sbi->sb, 1);
1904
1905         mnt_drop_write_file(filp);
1906         return ret;
1907 }
1908
1909 static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
1910                                         struct file *filp,
1911                                         struct f2fs_defragment *range)
1912 {
1913         struct inode *inode = file_inode(filp);
1914         struct f2fs_map_blocks map = { .m_next_pgofs = NULL };
1915         struct extent_info ei = {0,0,0};
1916         pgoff_t pg_start, pg_end;
1917         unsigned int blk_per_seg = sbi->blocks_per_seg;
1918         unsigned int total = 0, sec_num;
1919         block_t blk_end = 0;
1920         bool fragmented = false;
1921         int err;
1922
1923         /* if in-place-update policy is enabled, don't waste time here */
1924         if (need_inplace_update_policy(inode, NULL))
1925                 return -EINVAL;
1926
1927         pg_start = range->start >> PAGE_SHIFT;
1928         pg_end = (range->start + range->len) >> PAGE_SHIFT;
1929
1930         f2fs_balance_fs(sbi, true);
1931
1932         inode_lock(inode);
1933
1934         /* writeback all dirty pages in the range */
1935         err = filemap_write_and_wait_range(inode->i_mapping, range->start,
1936                                                 range->start + range->len - 1);
1937         if (err)
1938                 goto out;
1939
1940         /*
1941          * lookup mapping info in extent cache, skip defragmenting if physical
1942          * block addresses are continuous.
1943          */
1944         if (f2fs_lookup_extent_cache(inode, pg_start, &ei)) {
1945                 if (ei.fofs + ei.len >= pg_end)
1946                         goto out;
1947         }
1948
1949         map.m_lblk = pg_start;
1950
1951         /*
1952          * lookup mapping info in dnode page cache, skip defragmenting if all
1953          * physical block addresses are continuous even if there are hole(s)
1954          * in logical blocks.
1955          */
1956         while (map.m_lblk < pg_end) {
1957                 map.m_len = pg_end - map.m_lblk;
1958                 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_READ);
1959                 if (err)
1960                         goto out;
1961
1962                 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
1963                         map.m_lblk++;
1964                         continue;
1965                 }
1966
1967                 if (blk_end && blk_end != map.m_pblk) {
1968                         fragmented = true;
1969                         break;
1970                 }
1971                 blk_end = map.m_pblk + map.m_len;
1972
1973                 map.m_lblk += map.m_len;
1974         }
1975
1976         if (!fragmented)
1977                 goto out;
1978
1979         map.m_lblk = pg_start;
1980         map.m_len = pg_end - pg_start;
1981
1982         sec_num = (map.m_len + BLKS_PER_SEC(sbi) - 1) / BLKS_PER_SEC(sbi);
1983
1984         /*
1985          * make sure there are enough free section for LFS allocation, this can
1986          * avoid defragment running in SSR mode when free section are allocated
1987          * intensively
1988          */
1989         if (has_not_enough_free_secs(sbi, 0, sec_num)) {
1990                 err = -EAGAIN;
1991                 goto out;
1992         }
1993
1994         while (map.m_lblk < pg_end) {
1995                 pgoff_t idx;
1996                 int cnt = 0;
1997
1998 do_map:
1999                 map.m_len = pg_end - map.m_lblk;
2000                 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_READ);
2001                 if (err)
2002                         goto clear_out;
2003
2004                 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2005                         map.m_lblk++;
2006                         continue;
2007                 }
2008
2009                 set_inode_flag(inode, FI_DO_DEFRAG);
2010
2011                 idx = map.m_lblk;
2012                 while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
2013                         struct page *page;
2014
2015                         page = get_lock_data_page(inode, idx, true);
2016                         if (IS_ERR(page)) {
2017                                 err = PTR_ERR(page);
2018                                 goto clear_out;
2019                         }
2020
2021                         set_page_dirty(page);
2022                         f2fs_put_page(page, 1);
2023
2024                         idx++;
2025                         cnt++;
2026                         total++;
2027                 }
2028
2029                 map.m_lblk = idx;
2030
2031                 if (idx < pg_end && cnt < blk_per_seg)
2032                         goto do_map;
2033
2034                 clear_inode_flag(inode, FI_DO_DEFRAG);
2035
2036                 err = filemap_fdatawrite(inode->i_mapping);
2037                 if (err)
2038                         goto out;
2039         }
2040 clear_out:
2041         clear_inode_flag(inode, FI_DO_DEFRAG);
2042 out:
2043         inode_unlock(inode);
2044         if (!err)
2045                 range->len = (u64)total << PAGE_SHIFT;
2046         return err;
2047 }
2048
2049 static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
2050 {
2051         struct inode *inode = file_inode(filp);
2052         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2053         struct f2fs_defragment range;
2054         int err;
2055
2056         if (!capable(CAP_SYS_ADMIN))
2057                 return -EPERM;
2058
2059         if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode))
2060                 return -EINVAL;
2061
2062         if (f2fs_readonly(sbi->sb))
2063                 return -EROFS;
2064
2065         if (copy_from_user(&range, (struct f2fs_defragment __user *)arg,
2066                                                         sizeof(range)))
2067                 return -EFAULT;
2068
2069         /* verify alignment of offset & size */
2070         if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2071                 return -EINVAL;
2072
2073         if (unlikely((range.start + range.len) >> PAGE_SHIFT >
2074                                         sbi->max_file_blocks))
2075                 return -EINVAL;
2076
2077         err = mnt_want_write_file(filp);
2078         if (err)
2079                 return err;
2080
2081         err = f2fs_defragment_range(sbi, filp, &range);
2082         mnt_drop_write_file(filp);
2083
2084         f2fs_update_time(sbi, REQ_TIME);
2085         if (err < 0)
2086                 return err;
2087
2088         if (copy_to_user((struct f2fs_defragment __user *)arg, &range,
2089                                                         sizeof(range)))
2090                 return -EFAULT;
2091
2092         return 0;
2093 }
2094
2095 static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2096                         struct file *file_out, loff_t pos_out, size_t len)
2097 {
2098         struct inode *src = file_inode(file_in);
2099         struct inode *dst = file_inode(file_out);
2100         struct f2fs_sb_info *sbi = F2FS_I_SB(src);
2101         size_t olen = len, dst_max_i_size = 0;
2102         size_t dst_osize;
2103         int ret;
2104
2105         if (file_in->f_path.mnt != file_out->f_path.mnt ||
2106                                 src->i_sb != dst->i_sb)
2107                 return -EXDEV;
2108
2109         if (unlikely(f2fs_readonly(src->i_sb)))
2110                 return -EROFS;
2111
2112         if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))
2113                 return -EINVAL;
2114
2115         if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst))
2116                 return -EOPNOTSUPP;
2117
2118         if (src == dst) {
2119                 if (pos_in == pos_out)
2120                         return 0;
2121                 if (pos_out > pos_in && pos_out < pos_in + len)
2122                         return -EINVAL;
2123         }
2124
2125         inode_lock(src);
2126         if (src != dst) {
2127                 if (!inode_trylock(dst)) {
2128                         ret = -EBUSY;
2129                         goto out;
2130                 }
2131         }
2132
2133         ret = -EINVAL;
2134         if (pos_in + len > src->i_size || pos_in + len < pos_in)
2135                 goto out_unlock;
2136         if (len == 0)
2137                 olen = len = src->i_size - pos_in;
2138         if (pos_in + len == src->i_size)
2139                 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
2140         if (len == 0) {
2141                 ret = 0;
2142                 goto out_unlock;
2143         }
2144
2145         dst_osize = dst->i_size;
2146         if (pos_out + olen > dst->i_size)
2147                 dst_max_i_size = pos_out + olen;
2148
2149         /* verify the end result is block aligned */
2150         if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
2151                         !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
2152                         !IS_ALIGNED(pos_out, F2FS_BLKSIZE))
2153                 goto out_unlock;
2154
2155         ret = f2fs_convert_inline_inode(src);
2156         if (ret)
2157                 goto out_unlock;
2158
2159         ret = f2fs_convert_inline_inode(dst);
2160         if (ret)
2161                 goto out_unlock;
2162
2163         /* write out all dirty pages from offset */
2164         ret = filemap_write_and_wait_range(src->i_mapping,
2165                                         pos_in, pos_in + len);
2166         if (ret)
2167                 goto out_unlock;
2168
2169         ret = filemap_write_and_wait_range(dst->i_mapping,
2170                                         pos_out, pos_out + len);
2171         if (ret)
2172                 goto out_unlock;
2173
2174         f2fs_balance_fs(sbi, true);
2175         f2fs_lock_op(sbi);
2176         ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2177                                 pos_out >> F2FS_BLKSIZE_BITS,
2178                                 len >> F2FS_BLKSIZE_BITS, false);
2179
2180         if (!ret) {
2181                 if (dst_max_i_size)
2182                         f2fs_i_size_write(dst, dst_max_i_size);
2183                 else if (dst_osize != dst->i_size)
2184                         f2fs_i_size_write(dst, dst_osize);
2185         }
2186         f2fs_unlock_op(sbi);
2187 out_unlock:
2188         if (src != dst)
2189                 inode_unlock(dst);
2190 out:
2191         inode_unlock(src);
2192         return ret;
2193 }
2194
2195 static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
2196 {
2197         struct f2fs_move_range range;
2198         struct fd dst;
2199         int err;
2200
2201         if (!(filp->f_mode & FMODE_READ) ||
2202                         !(filp->f_mode & FMODE_WRITE))
2203                 return -EBADF;
2204
2205         if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
2206                                                         sizeof(range)))
2207                 return -EFAULT;
2208
2209         dst = fdget(range.dst_fd);
2210         if (!dst.file)
2211                 return -EBADF;
2212
2213         if (!(dst.file->f_mode & FMODE_WRITE)) {
2214                 err = -EBADF;
2215                 goto err_out;
2216         }
2217
2218         err = mnt_want_write_file(filp);
2219         if (err)
2220                 goto err_out;
2221
2222         err = f2fs_move_file_range(filp, range.pos_in, dst.file,
2223                                         range.pos_out, range.len);
2224
2225         mnt_drop_write_file(filp);
2226         if (err)
2227                 goto err_out;
2228
2229         if (copy_to_user((struct f2fs_move_range __user *)arg,
2230                                                 &range, sizeof(range)))
2231                 err = -EFAULT;
2232 err_out:
2233         fdput(dst);
2234         return err;
2235 }
2236
2237 static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
2238 {
2239         struct inode *inode = file_inode(filp);
2240         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2241         struct sit_info *sm = SIT_I(sbi);
2242         unsigned int start_segno = 0, end_segno = 0;
2243         unsigned int dev_start_segno = 0, dev_end_segno = 0;
2244         struct f2fs_flush_device range;
2245         int ret;
2246
2247         if (!capable(CAP_SYS_ADMIN))
2248                 return -EPERM;
2249
2250         if (f2fs_readonly(sbi->sb))
2251                 return -EROFS;
2252
2253         if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
2254                                                         sizeof(range)))
2255                 return -EFAULT;
2256
2257         if (sbi->s_ndevs <= 1 || sbi->s_ndevs - 1 <= range.dev_num ||
2258                         sbi->segs_per_sec != 1) {
2259                 f2fs_msg(sbi->sb, KERN_WARNING,
2260                         "Can't flush %u in %d for segs_per_sec %u != 1\n",
2261                                 range.dev_num, sbi->s_ndevs,
2262                                 sbi->segs_per_sec);
2263                 return -EINVAL;
2264         }
2265
2266         ret = mnt_want_write_file(filp);
2267         if (ret)
2268                 return ret;
2269
2270         if (range.dev_num != 0)
2271                 dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk);
2272         dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
2273
2274         start_segno = sm->last_victim[FLUSH_DEVICE];
2275         if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
2276                 start_segno = dev_start_segno;
2277         end_segno = min(start_segno + range.segments, dev_end_segno);
2278
2279         while (start_segno < end_segno) {
2280                 if (!mutex_trylock(&sbi->gc_mutex)) {
2281                         ret = -EBUSY;
2282                         goto out;
2283                 }
2284                 sm->last_victim[GC_CB] = end_segno + 1;
2285                 sm->last_victim[GC_GREEDY] = end_segno + 1;
2286                 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
2287                 ret = f2fs_gc(sbi, true, true, start_segno);
2288                 if (ret == -EAGAIN)
2289                         ret = 0;
2290                 else if (ret < 0)
2291                         break;
2292                 start_segno++;
2293         }
2294 out:
2295         mnt_drop_write_file(filp);
2296         return ret;
2297 }
2298
2299
2300 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
2301 {
2302         switch (cmd) {
2303         case F2FS_IOC_GETFLAGS:
2304                 return f2fs_ioc_getflags(filp, arg);
2305         case F2FS_IOC_SETFLAGS:
2306                 return f2fs_ioc_setflags(filp, arg);
2307         case F2FS_IOC_GETVERSION:
2308                 return f2fs_ioc_getversion(filp, arg);
2309         case F2FS_IOC_START_ATOMIC_WRITE:
2310                 return f2fs_ioc_start_atomic_write(filp);
2311         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
2312                 return f2fs_ioc_commit_atomic_write(filp);
2313         case F2FS_IOC_START_VOLATILE_WRITE:
2314                 return f2fs_ioc_start_volatile_write(filp);
2315         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
2316                 return f2fs_ioc_release_volatile_write(filp);
2317         case F2FS_IOC_ABORT_VOLATILE_WRITE:
2318                 return f2fs_ioc_abort_volatile_write(filp);
2319         case F2FS_IOC_SHUTDOWN:
2320                 return f2fs_ioc_shutdown(filp, arg);
2321         case FITRIM:
2322                 return f2fs_ioc_fitrim(filp, arg);
2323         case F2FS_IOC_SET_ENCRYPTION_POLICY:
2324                 return f2fs_ioc_set_encryption_policy(filp, arg);
2325         case F2FS_IOC_GET_ENCRYPTION_POLICY:
2326                 return f2fs_ioc_get_encryption_policy(filp, arg);
2327         case F2FS_IOC_GET_ENCRYPTION_PWSALT:
2328                 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
2329         case F2FS_IOC_GARBAGE_COLLECT:
2330                 return f2fs_ioc_gc(filp, arg);
2331         case F2FS_IOC_WRITE_CHECKPOINT:
2332                 return f2fs_ioc_write_checkpoint(filp, arg);
2333         case F2FS_IOC_DEFRAGMENT:
2334                 return f2fs_ioc_defragment(filp, arg);
2335         case F2FS_IOC_MOVE_RANGE:
2336                 return f2fs_ioc_move_range(filp, arg);
2337         case F2FS_IOC_FLUSH_DEVICE:
2338                 return f2fs_ioc_flush_device(filp, arg);
2339         default:
2340                 return -ENOTTY;
2341         }
2342 }
2343
2344 static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
2345 {
2346         struct file *file = iocb->ki_filp;
2347         struct inode *inode = file_inode(file);
2348         struct blk_plug plug;
2349         ssize_t ret;
2350
2351         if (f2fs_encrypted_inode(inode) &&
2352                                 !fscrypt_has_encryption_key(inode) &&
2353                                 fscrypt_get_encryption_info(inode))
2354                 return -EACCES;
2355
2356         inode_lock(inode);
2357         ret = generic_write_checks(iocb, from);
2358         if (ret > 0) {
2359                 int err;
2360
2361                 if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
2362                         set_inode_flag(inode, FI_NO_PREALLOC);
2363
2364                 err = f2fs_preallocate_blocks(iocb, from);
2365                 if (err) {
2366                         inode_unlock(inode);
2367                         return err;
2368                 }
2369                 blk_start_plug(&plug);
2370                 ret = __generic_file_write_iter(iocb, from);
2371                 blk_finish_plug(&plug);
2372                 clear_inode_flag(inode, FI_NO_PREALLOC);
2373         }
2374         inode_unlock(inode);
2375
2376         if (ret > 0)
2377                 ret = generic_write_sync(iocb, ret);
2378         return ret;
2379 }
2380
2381 #ifdef CONFIG_COMPAT
2382 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2383 {
2384         switch (cmd) {
2385         case F2FS_IOC32_GETFLAGS:
2386                 cmd = F2FS_IOC_GETFLAGS;
2387                 break;
2388         case F2FS_IOC32_SETFLAGS:
2389                 cmd = F2FS_IOC_SETFLAGS;
2390                 break;
2391         case F2FS_IOC32_GETVERSION:
2392                 cmd = F2FS_IOC_GETVERSION;
2393                 break;
2394         case F2FS_IOC_START_ATOMIC_WRITE:
2395         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
2396         case F2FS_IOC_START_VOLATILE_WRITE:
2397         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
2398         case F2FS_IOC_ABORT_VOLATILE_WRITE:
2399         case F2FS_IOC_SHUTDOWN:
2400         case F2FS_IOC_SET_ENCRYPTION_POLICY:
2401         case F2FS_IOC_GET_ENCRYPTION_PWSALT:
2402         case F2FS_IOC_GET_ENCRYPTION_POLICY:
2403         case F2FS_IOC_GARBAGE_COLLECT:
2404         case F2FS_IOC_WRITE_CHECKPOINT:
2405         case F2FS_IOC_DEFRAGMENT:
2406         case F2FS_IOC_MOVE_RANGE:
2407         case F2FS_IOC_FLUSH_DEVICE:
2408                 break;
2409         default:
2410                 return -ENOIOCTLCMD;
2411         }
2412         return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
2413 }
2414 #endif
2415
2416 const struct file_operations f2fs_file_operations = {
2417         .llseek         = f2fs_llseek,
2418         .read_iter      = generic_file_read_iter,
2419         .write_iter     = f2fs_file_write_iter,
2420         .open           = f2fs_file_open,
2421         .release        = f2fs_release_file,
2422         .mmap           = f2fs_file_mmap,
2423         .fsync          = f2fs_sync_file,
2424         .fallocate      = f2fs_fallocate,
2425         .unlocked_ioctl = f2fs_ioctl,
2426 #ifdef CONFIG_COMPAT
2427         .compat_ioctl   = f2fs_compat_ioctl,
2428 #endif
2429         .splice_read    = generic_file_splice_read,
2430         .splice_write   = iter_file_splice_write,
2431 };