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