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