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/random.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         f2fs_balance_fs(sbi);
  44
  45         sb_start_pagefault(inode->i_sb);
  46
  47         f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
  48
  49         /* block allocation */
  50         f2fs_lock_op(sbi);
  51         set_new_dnode(&dn, inode, NULL, NULL, 0);
  52         err = f2fs_reserve_block(&dn, page->index);
  53         if (err) {
  54                 f2fs_unlock_op(sbi);
  55                 goto out;
  56         }
  57         f2fs_put_dnode(&dn);
  58         f2fs_unlock_op(sbi);
  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_CACHE_SHIFT) >
  78                                                 i_size_read(inode)) {
  79                 unsigned offset;
  80                 offset = i_size_read(inode) & ~PAGE_CACHE_MASK;
  81                 zero_user_segment(page, offset, PAGE_CACHE_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);
  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         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 (file_enc_name(inode) && need_dentry_mark(sbi, inode->i_ino))
 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                 fi->i_pino = pino;
 174                 file_got_pino(inode);
 175                 up_write(&fi->i_sem);
 176
 177                 mark_inode_dirty_sync(inode);
 178                 f2fs_write_inode(inode, NULL);
 179         } else {
 180                 up_write(&fi->i_sem);
 181         }
 182 }
 183
 184 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 185 {
 186         struct inode *inode = file->f_mapping->host;
 187         struct f2fs_inode_info *fi = F2FS_I(inode);
 188         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 189         nid_t ino = inode->i_ino;
 190         int ret = 0;
 191         bool need_cp = false;
 192         struct writeback_control wbc = {
 193                 .sync_mode = WB_SYNC_ALL,
 194                 .nr_to_write = LONG_MAX,
 195                 .for_reclaim = 0,
 196         };
 197
 198         if (unlikely(f2fs_readonly(inode->i_sb)))
 199                 return 0;
 200
 201         trace_f2fs_sync_file_enter(inode);
 202
 203         if (S_ISDIR(inode->i_mode))
 204                 goto go_write;
 205
 206         /* if fdatasync is triggered, let's do in-place-update */
 207         if (get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
 208                 set_inode_flag(fi, FI_NEED_IPU);
 209         ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
 210         clear_inode_flag(fi, FI_NEED_IPU);
 211
 212         if (ret) {
 213                 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
 214                 return ret;
 215         }
 216
 217         /* if the inode is dirty, let's recover all the time */
 218         if (!datasync) {
 219                 f2fs_write_inode(inode, NULL);
 220                 goto go_write;
 221         }
 222
 223         /*
 224          * if there is no written data, don't waste time to write recovery info.
 225          */
 226         if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
 227                         !exist_written_data(sbi, ino, APPEND_INO)) {
 228
 229                 /* it may call write_inode just prior to fsync */
 230                 if (need_inode_page_update(sbi, ino))
 231                         goto go_write;
 232
 233                 if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
 234                                 exist_written_data(sbi, ino, UPDATE_INO))
 235                         goto flush_out;
 236                 goto out;
 237         }
 238 go_write:
 239         /* guarantee free sections for fsync */
 240         f2fs_balance_fs(sbi);
 241
 242         /*
 243          * Both of fdatasync() and fsync() are able to be recovered from
 244          * sudden-power-off.
 245          */
 246         down_read(&fi->i_sem);
 247         need_cp = need_do_checkpoint(inode);
 248         up_read(&fi->i_sem);
 249
 250         if (need_cp) {
 251                 /* all the dirty node pages should be flushed for POR */
 252                 ret = f2fs_sync_fs(inode->i_sb, 1);
 253
 254                 /*
 255                  * We've secured consistency through sync_fs. Following pino
 256                  * will be used only for fsynced inodes after checkpoint.
 257                  */
 258                 try_to_fix_pino(inode);
 259                 clear_inode_flag(fi, FI_APPEND_WRITE);
 260                 clear_inode_flag(fi, FI_UPDATE_WRITE);
 261                 goto out;
 262         }
 263 sync_nodes:
 264         sync_node_pages(sbi, ino, &wbc);
 265
 266         /* if cp_error was enabled, we should avoid infinite loop */
 267         if (unlikely(f2fs_cp_error(sbi)))
 268                 goto out;
 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_dirty_inode(sbi, ino, APPEND_INO);
 282         clear_inode_flag(fi, FI_APPEND_WRITE);
 283 flush_out:
 284         remove_dirty_inode(sbi, ino, UPDATE_INO);
 285         clear_inode_flag(fi, FI_UPDATE_WRITE);
 286         ret = f2fs_issue_flush(sbi);
 287 out:
 288         trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
 289         f2fs_trace_ios(NULL, 1);
 290         return ret;
 291 }
 292
 293 static pgoff_t __get_first_dirty_index(struct address_space *mapping,
 294                                                 pgoff_t pgofs, int whence)
 295 {
 296         struct pagevec pvec;
 297         int nr_pages;
 298
 299         if (whence != SEEK_DATA)
 300                 return 0;
 301
 302         /* find first dirty page index */
 303         pagevec_init(&pvec, 0);
 304         nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
 305                                         PAGECACHE_TAG_DIRTY, 1);
 306         pgofs = nr_pages ? pvec.pages[0]->index : LONG_MAX;
 307         pagevec_release(&pvec);
 308         return pgofs;
 309 }
 310
 311 static bool __found_offset(struct f2fs_sb_info *sbi, block_t blkaddr,
 312                                 pgoff_t dirty, pgoff_t pgofs, int whence)
 313 {
 314         switch (whence) {
 315         case SEEK_DATA:
 316                 if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
 317                         is_valid_data_blkaddr(sbi, blkaddr))
 318                         return true;
 319                 break;
 320         case SEEK_HOLE:
 321                 if (blkaddr == NULL_ADDR)
 322                         return true;
 323                 break;
 324         }
 325         return false;
 326 }
 327
 328 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
 329 {
 330         struct inode *inode = file->f_mapping->host;
 331         loff_t maxbytes = inode->i_sb->s_maxbytes;
 332         struct dnode_of_data dn;
 333         pgoff_t pgofs, end_offset, dirty;
 334         loff_t data_ofs = offset;
 335         loff_t isize;
 336         int err = 0;
 337
 338         mutex_lock(&inode->i_mutex);
 339
 340         isize = i_size_read(inode);
 341         if (offset >= isize)
 342                 goto fail;
 343
 344         /* handle inline data case */
 345         if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
 346                 if (whence == SEEK_HOLE)
 347                         data_ofs = isize;
 348                 goto found;
 349         }
 350
 351         pgofs = (pgoff_t)(offset >> PAGE_CACHE_SHIFT);
 352
 353         dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
 354
 355         for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_CACHE_SHIFT) {
 356                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 357                 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE_RA);
 358                 if (err && err != -ENOENT) {
 359                         goto fail;
 360                 } else if (err == -ENOENT) {
 361                         /* direct node does not exists */
 362                         if (whence == SEEK_DATA) {
 363                                 pgofs = PGOFS_OF_NEXT_DNODE(pgofs,
 364                                                         F2FS_I(inode));
 365                                 continue;
 366                         } else {
 367                                 goto found;
 368                         }
 369                 }
 370
 371                 end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 372
 373                 /* find data/hole in dnode block */
 374                 for (; dn.ofs_in_node < end_offset;
 375                                 dn.ofs_in_node++, pgofs++,
 376                                 data_ofs = (loff_t)pgofs << PAGE_CACHE_SHIFT) {
 377                         block_t blkaddr;
 378                         blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 379
 380                         if (__is_valid_data_blkaddr(blkaddr) &&
 381                                 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
 382                                                 blkaddr, DATA_GENERIC)) {
 383                                 f2fs_put_dnode(&dn);
 384                                 goto fail;
 385                         }
 386
 387                         if (__found_offset(F2FS_I_SB(inode), blkaddr, dirty,
 388                                                         pgofs, whence)) {
 389                                 f2fs_put_dnode(&dn);
 390                                 goto found;
 391                         }
 392                 }
 393                 f2fs_put_dnode(&dn);
 394         }
 395
 396         if (whence == SEEK_DATA)
 397                 goto fail;
 398 found:
 399         if (whence == SEEK_HOLE && data_ofs > isize)
 400                 data_ofs = isize;
 401         mutex_unlock(&inode->i_mutex);
 402         return vfs_setpos(file, data_ofs, maxbytes);
 403 fail:
 404         mutex_unlock(&inode->i_mutex);
 405         return -ENXIO;
 406 }
 407
 408 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
 409 {
 410         struct inode *inode = file->f_mapping->host;
 411         loff_t maxbytes = inode->i_sb->s_maxbytes;
 412
 413         switch (whence) {
 414         case SEEK_SET:
 415         case SEEK_CUR:
 416         case SEEK_END:
 417                 return generic_file_llseek_size(file, offset, whence,
 418                                                 maxbytes, i_size_read(inode));
 419         case SEEK_DATA:
 420         case SEEK_HOLE:
 421                 if (offset < 0)
 422                         return -ENXIO;
 423                 return f2fs_seek_block(file, offset, whence);
 424         }
 425
 426         return -EINVAL;
 427 }
 428
 429 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 430 {
 431         struct inode *inode = file_inode(file);
 432
 433         if (f2fs_encrypted_inode(inode)) {
 434                 int err = f2fs_get_encryption_info(inode);
 435                 if (err)
 436                         return 0;
 437         }
 438
 439         /* we don't need to use inline_data strictly */
 440         if (f2fs_has_inline_data(inode)) {
 441                 int err = f2fs_convert_inline_inode(inode);
 442                 if (err)
 443                         return err;
 444         }
 445
 446         file_accessed(file);
 447         vma->vm_ops = &f2fs_file_vm_ops;
 448         return 0;
 449 }
 450
 451 static int f2fs_file_open(struct inode *inode, struct file *filp)
 452 {
 453         int ret = generic_file_open(inode, filp);
 454
 455         if (!ret && f2fs_encrypted_inode(inode)) {
 456                 ret = f2fs_get_encryption_info(inode);
 457                 if (ret)
 458                         ret = -EACCES;
 459         }
 460         return ret;
 461 }
 462
 463 int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 464 {
 465         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 466         struct f2fs_node *raw_node;
 467         int nr_free = 0, ofs = dn->ofs_in_node, len = count;
 468         __le32 *addr;
 469
 470         raw_node = F2FS_NODE(dn->node_page);
 471         addr = blkaddr_in_node(raw_node) + ofs;
 472
 473         for (; count > 0; count--, addr++, dn->ofs_in_node++) {
 474                 block_t blkaddr = le32_to_cpu(*addr);
 475                 if (blkaddr == NULL_ADDR)
 476                         continue;
 477
 478                 dn->data_blkaddr = NULL_ADDR;
 479                 set_data_blkaddr(dn);
 480
 481                 if (__is_valid_data_blkaddr(blkaddr) &&
 482                         !f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC))
 483                         continue;
 484
 485                 invalidate_blocks(sbi, blkaddr);
 486                 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
 487                         clear_inode_flag(F2FS_I(dn->inode),
 488                                                 FI_FIRST_BLOCK_WRITTEN);
 489                 nr_free++;
 490         }
 491
 492         if (nr_free) {
 493                 pgoff_t fofs;
 494                 /*
 495                  * once we invalidate valid blkaddr in range [ofs, ofs + count],
 496                  * we will invalidate all blkaddr in the whole range.
 497                  */
 498                 fofs = start_bidx_of_node(ofs_of_node(dn->node_page),
 499                                                 F2FS_I(dn->inode)) + ofs;
 500                 f2fs_update_extent_cache_range(dn, fofs, 0, len);
 501                 dec_valid_block_count(sbi, dn->inode, nr_free);
 502                 set_page_dirty(dn->node_page);
 503                 sync_inode_page(dn);
 504         }
 505         dn->ofs_in_node = ofs;
 506
 507         trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
 508                                          dn->ofs_in_node, nr_free);
 509         return nr_free;
 510 }
 511
 512 void truncate_data_blocks(struct dnode_of_data *dn)
 513 {
 514         truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
 515 }
 516
 517 static int truncate_partial_data_page(struct inode *inode, u64 from,
 518                                                                 bool cache_only)
 519 {
 520         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
 521         pgoff_t index = from >> PAGE_CACHE_SHIFT;
 522         struct address_space *mapping = inode->i_mapping;
 523         struct page *page;
 524
 525         if (!offset && !cache_only)
 526                 return 0;
 527
 528         if (cache_only) {
 529                 page = f2fs_grab_cache_page(mapping, index, false);
 530                 if (page && PageUptodate(page))
 531                         goto truncate_out;
 532                 f2fs_put_page(page, 1);
 533                 return 0;
 534         }
 535
 536         page = get_lock_data_page(inode, index, true);
 537         if (IS_ERR(page))
 538                 return 0;
 539 truncate_out:
 540         f2fs_wait_on_page_writeback(page, DATA);
 541         zero_user(page, offset, PAGE_CACHE_SIZE - offset);
 542         if (!cache_only || !f2fs_encrypted_inode(inode) || !S_ISREG(inode->i_mode))
 543                 set_page_dirty(page);
 544         f2fs_put_page(page, 1);
 545         return 0;
 546 }
 547
 548 int truncate_blocks(struct inode *inode, u64 from, bool lock)
 549 {
 550         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 551         unsigned int blocksize = inode->i_sb->s_blocksize;
 552         struct dnode_of_data dn;
 553         pgoff_t free_from;
 554         int count = 0, err = 0;
 555         struct page *ipage;
 556         bool truncate_page = false;
 557
 558         trace_f2fs_truncate_blocks_enter(inode, from);
 559
 560         free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1);
 561
 562         if (lock)
 563                 f2fs_lock_op(sbi);
 564
 565         ipage = get_node_page(sbi, inode->i_ino);
 566         if (IS_ERR(ipage)) {
 567                 err = PTR_ERR(ipage);
 568                 goto out;
 569         }
 570
 571         if (f2fs_has_inline_data(inode)) {
 572                 if (truncate_inline_inode(ipage, from))
 573                         set_page_dirty(ipage);
 574                 f2fs_put_page(ipage, 1);
 575                 truncate_page = true;
 576                 goto out;
 577         }
 578
 579         set_new_dnode(&dn, inode, ipage, NULL, 0);
 580         err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE);
 581         if (err) {
 582                 if (err == -ENOENT)
 583                         goto free_next;
 584                 goto out;
 585         }
 586
 587         count = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 588
 589         count -= dn.ofs_in_node;
 590         f2fs_bug_on(sbi, count < 0);
 591
 592         if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
 593                 truncate_data_blocks_range(&dn, count);
 594                 free_from += count;
 595         }
 596
 597         f2fs_put_dnode(&dn);
 598 free_next:
 599         err = truncate_inode_blocks(inode, free_from);
 600 out:
 601         if (lock)
 602                 f2fs_unlock_op(sbi);
 603
 604         /* lastly zero out the first data page */
 605         if (!err)
 606                 err = truncate_partial_data_page(inode, from, truncate_page);
 607
 608         trace_f2fs_truncate_blocks_exit(inode, err);
 609         return err;
 610 }
 611
 612 int f2fs_truncate(struct inode *inode, bool lock)
 613 {
 614         int err;
 615
 616         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 617                                 S_ISLNK(inode->i_mode)))
 618                 return 0;
 619
 620         trace_f2fs_truncate(inode);
 621
 622         /* we should check inline_data size */
 623         if (f2fs_has_inline_data(inode) && !f2fs_may_inline_data(inode)) {
 624                 err = f2fs_convert_inline_inode(inode);
 625                 if (err)
 626                         return err;
 627         }
 628
 629         err = truncate_blocks(inode, i_size_read(inode), lock);
 630         if (err)
 631                 return err;
 632
 633         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 634         mark_inode_dirty(inode);
 635         return 0;
 636 }
 637
 638 int f2fs_getattr(struct vfsmount *mnt,
 639                          struct dentry *dentry, struct kstat *stat)
 640 {
 641         struct inode *inode = d_inode(dentry);
 642         generic_fillattr(inode, stat);
 643         stat->blocks <<= 3;
 644         return 0;
 645 }
 646
 647 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 648 static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 649 {
 650         struct f2fs_inode_info *fi = F2FS_I(inode);
 651         unsigned int ia_valid = attr->ia_valid;
 652
 653         if (ia_valid & ATTR_UID)
 654                 inode->i_uid = attr->ia_uid;
 655         if (ia_valid & ATTR_GID)
 656                 inode->i_gid = attr->ia_gid;
 657         if (ia_valid & ATTR_ATIME)
 658                 inode->i_atime = timespec_trunc(attr->ia_atime,
 659                                                 inode->i_sb->s_time_gran);
 660         if (ia_valid & ATTR_MTIME)
 661                 inode->i_mtime = timespec_trunc(attr->ia_mtime,
 662                                                 inode->i_sb->s_time_gran);
 663         if (ia_valid & ATTR_CTIME)
 664                 inode->i_ctime = timespec_trunc(attr->ia_ctime,
 665                                                 inode->i_sb->s_time_gran);
 666         if (ia_valid & ATTR_MODE) {
 667                 umode_t mode = attr->ia_mode;
 668
 669                 if (!in_group_p(inode->i_gid) &&
 670                         !capable_wrt_inode_uidgid(inode, CAP_FSETID))
 671                         mode &= ~S_ISGID;
 672                 set_acl_inode(fi, mode);
 673         }
 674 }
 675 #else
 676 #define __setattr_copy setattr_copy
 677 #endif
 678
 679 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 680 {
 681         struct inode *inode = d_inode(dentry);
 682         struct f2fs_inode_info *fi = F2FS_I(inode);
 683         int err;
 684
 685         err = inode_change_ok(inode, attr);
 686         if (err)
 687                 return err;
 688
 689         if (attr->ia_valid & ATTR_SIZE) {
 690                 if (f2fs_encrypted_inode(inode) &&
 691                                 f2fs_get_encryption_info(inode))
 692                         return -EACCES;
 693
 694                 if (attr->ia_size <= i_size_read(inode)) {
 695                         truncate_setsize(inode, attr->ia_size);
 696                         err = f2fs_truncate(inode, true);
 697                         if (err)
 698                                 return err;
 699                         f2fs_balance_fs(F2FS_I_SB(inode));
 700                 } else {
 701                         /*
 702                          * do not trim all blocks after i_size if target size is
 703                          * larger than i_size.
 704                          */
 705                         truncate_setsize(inode, attr->ia_size);
 706                         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 707                 }
 708         }
 709
 710         __setattr_copy(inode, attr);
 711
 712         if (attr->ia_valid & ATTR_MODE) {
 713                 err = posix_acl_chmod(inode, get_inode_mode(inode));
 714                 if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
 715                         inode->i_mode = fi->i_acl_mode;
 716                         clear_inode_flag(fi, FI_ACL_MODE);
 717                 }
 718         }
 719
 720         mark_inode_dirty(inode);
 721         return err;
 722 }
 723
 724 const struct inode_operations f2fs_file_inode_operations = {
 725         .getattr        = f2fs_getattr,
 726         .setattr        = f2fs_setattr,
 727         .get_acl        = f2fs_get_acl,
 728         .set_acl        = f2fs_set_acl,
 729 #ifdef CONFIG_F2FS_FS_XATTR
 730         .setxattr       = generic_setxattr,
 731         .getxattr       = generic_getxattr,
 732         .listxattr      = f2fs_listxattr,
 733         .removexattr    = generic_removexattr,
 734 #endif
 735         .fiemap         = f2fs_fiemap,
 736 };
 737
 738 static int fill_zero(struct inode *inode, pgoff_t index,
 739                                         loff_t start, loff_t len)
 740 {
 741         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 742         struct page *page;
 743
 744         if (!len)
 745                 return 0;
 746
 747         f2fs_balance_fs(sbi);
 748
 749         f2fs_lock_op(sbi);
 750         page = get_new_data_page(inode, NULL, index, false);
 751         f2fs_unlock_op(sbi);
 752
 753         if (IS_ERR(page))
 754                 return PTR_ERR(page);
 755
 756         f2fs_wait_on_page_writeback(page, DATA);
 757         zero_user(page, start, len);
 758         set_page_dirty(page);
 759         f2fs_put_page(page, 1);
 760         return 0;
 761 }
 762
 763 int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
 764 {
 765         int err;
 766
 767         while (pg_start < pg_end) {
 768                 struct dnode_of_data dn;
 769                 pgoff_t end_offset, count;
 770
 771                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 772                 err = get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
 773                 if (err) {
 774                         if (err == -ENOENT) {
 775                                 pg_start++;
 776                                 continue;
 777                         }
 778                         return err;
 779                 }
 780
 781                 end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 782                 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
 783
 784                 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
 785
 786                 truncate_data_blocks_range(&dn, count);
 787                 f2fs_put_dnode(&dn);
 788
 789                 pg_start += count;
 790         }
 791         return 0;
 792 }
 793
 794 static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
 795 {
 796         pgoff_t pg_start, pg_end;
 797         loff_t off_start, off_end;
 798         int ret = 0;
 799
 800         if (f2fs_has_inline_data(inode)) {
 801                 ret = f2fs_convert_inline_inode(inode);
 802                 if (ret)
 803                         return ret;
 804         }
 805
 806         pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
 807         pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
 808
 809         off_start = offset & (PAGE_CACHE_SIZE - 1);
 810         off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
 811
 812         if (pg_start == pg_end) {
 813                 ret = fill_zero(inode, pg_start, off_start,
 814                                                 off_end - off_start);
 815                 if (ret)
 816                         return ret;
 817         } else {
 818                 if (off_start) {
 819                         ret = fill_zero(inode, pg_start++, off_start,
 820                                                 PAGE_CACHE_SIZE - off_start);
 821                         if (ret)
 822                                 return ret;
 823                 }
 824                 if (off_end) {
 825                         ret = fill_zero(inode, pg_end, 0, off_end);
 826                         if (ret)
 827                                 return ret;
 828                 }
 829
 830                 if (pg_start < pg_end) {
 831                         struct address_space *mapping = inode->i_mapping;
 832                         loff_t blk_start, blk_end;
 833                         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 834
 835                         f2fs_balance_fs(sbi);
 836
 837                         blk_start = (loff_t)pg_start << PAGE_CACHE_SHIFT;
 838                         blk_end = (loff_t)pg_end << PAGE_CACHE_SHIFT;
 839                         truncate_inode_pages_range(mapping, blk_start,
 840                                         blk_end - 1);
 841
 842                         f2fs_lock_op(sbi);
 843                         ret = truncate_hole(inode, pg_start, pg_end);
 844                         f2fs_unlock_op(sbi);
 845                 }
 846         }
 847
 848         return ret;
 849 }
 850
 851 static int __exchange_data_block(struct inode *inode, pgoff_t src,
 852                                         pgoff_t dst, bool full)
 853 {
 854         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 855         struct dnode_of_data dn;
 856         block_t new_addr;
 857         bool do_replace = false;
 858         int ret;
 859
 860         set_new_dnode(&dn, inode, NULL, NULL, 0);
 861         ret = get_dnode_of_data(&dn, src, LOOKUP_NODE_RA);
 862         if (ret && ret != -ENOENT) {
 863                 return ret;
 864         } else if (ret == -ENOENT) {
 865                 new_addr = NULL_ADDR;
 866         } else {
 867                 new_addr = dn.data_blkaddr;
 868                 if (!is_checkpointed_data(sbi, new_addr)) {
 869                         dn.data_blkaddr = NULL_ADDR;
 870                         /* do not invalidate this block address */
 871                         set_data_blkaddr(&dn);
 872                         f2fs_update_extent_cache(&dn);
 873                         do_replace = true;
 874                 }
 875                 f2fs_put_dnode(&dn);
 876         }
 877
 878         if (new_addr == NULL_ADDR)
 879                 return full ? truncate_hole(inode, dst, dst + 1) : 0;
 880
 881         if (do_replace) {
 882                 struct page *ipage = get_node_page(sbi, inode->i_ino);
 883                 struct node_info ni;
 884
 885                 if (IS_ERR(ipage)) {
 886                         ret = PTR_ERR(ipage);
 887                         goto err_out;
 888                 }
 889
 890                 set_new_dnode(&dn, inode, ipage, NULL, 0);
 891                 ret = f2fs_reserve_block(&dn, dst);
 892                 if (ret)
 893                         goto err_out;
 894
 895                 truncate_data_blocks_range(&dn, 1);
 896
 897                 get_node_info(sbi, dn.nid, &ni);
 898                 f2fs_replace_block(sbi, &dn, dn.data_blkaddr, new_addr,
 899                                 ni.version, true);
 900                 f2fs_put_dnode(&dn);
 901         } else {
 902                 struct page *psrc, *pdst;
 903
 904                 psrc = get_lock_data_page(inode, src, true);
 905                 if (IS_ERR(psrc))
 906                         return PTR_ERR(psrc);
 907                 pdst = get_new_data_page(inode, NULL, dst, false);
 908                 if (IS_ERR(pdst)) {
 909                         f2fs_put_page(psrc, 1);
 910                         return PTR_ERR(pdst);
 911                 }
 912                 f2fs_copy_page(psrc, pdst);
 913                 set_page_dirty(pdst);
 914                 f2fs_put_page(pdst, 1);
 915                 f2fs_put_page(psrc, 1);
 916
 917                 return truncate_hole(inode, src, src + 1);
 918         }
 919         return 0;
 920
 921 err_out:
 922         if (!get_dnode_of_data(&dn, src, LOOKUP_NODE)) {
 923                 dn.data_blkaddr = new_addr;
 924                 set_data_blkaddr(&dn);
 925                 f2fs_update_extent_cache(&dn);
 926                 f2fs_put_dnode(&dn);
 927         }
 928         return ret;
 929 }
 930
 931 static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end)
 932 {
 933         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 934         pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
 935         int ret = 0;
 936
 937         for (; end < nrpages; start++, end++) {
 938                 f2fs_balance_fs(sbi);
 939                 f2fs_lock_op(sbi);
 940                 ret = __exchange_data_block(inode, end, start, true);
 941                 f2fs_unlock_op(sbi);
 942                 if (ret)
 943                         break;
 944         }
 945         return ret;
 946 }
 947
 948 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
 949 {
 950         pgoff_t pg_start, pg_end;
 951         loff_t new_size;
 952         int ret;
 953
 954         if (offset + len >= i_size_read(inode))
 955                 return -EINVAL;
 956
 957         /* collapse range should be aligned to block size of f2fs. */
 958         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
 959                 return -EINVAL;
 960
 961         f2fs_balance_fs(F2FS_I_SB(inode));
 962
 963         if (f2fs_has_inline_data(inode)) {
 964                 ret = f2fs_convert_inline_inode(inode);
 965                 if (ret)
 966                         return ret;
 967         }
 968
 969         pg_start = offset >> PAGE_CACHE_SHIFT;
 970         pg_end = (offset + len) >> PAGE_CACHE_SHIFT;
 971
 972         /* write out all dirty pages from offset */
 973         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
 974         if (ret)
 975                 return ret;
 976
 977         truncate_pagecache(inode, offset);
 978
 979         ret = f2fs_do_collapse(inode, pg_start, pg_end);
 980         if (ret)
 981                 return ret;
 982
 983         /* write out all moved pages, if possible */
 984         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
 985         truncate_pagecache(inode, offset);
 986
 987         new_size = i_size_read(inode) - len;
 988         truncate_pagecache(inode, new_size);
 989
 990         ret = truncate_blocks(inode, new_size, true);
 991         if (!ret)
 992                 i_size_write(inode, new_size);
 993
 994         return ret;
 995 }
 996
 997 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
 998                                                                 int mode)
 999 {
1000         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1001         struct address_space *mapping = inode->i_mapping;
1002         pgoff_t index, pg_start, pg_end;
1003         loff_t new_size = i_size_read(inode);
1004         loff_t off_start, off_end;
1005         int ret = 0;
1006
1007         ret = inode_newsize_ok(inode, (len + offset));
1008         if (ret)
1009                 return ret;
1010
1011         f2fs_balance_fs(sbi);
1012
1013         if (f2fs_has_inline_data(inode)) {
1014                 ret = f2fs_convert_inline_inode(inode);
1015                 if (ret)
1016                         return ret;
1017         }
1018
1019         ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
1020         if (ret)
1021                 return ret;
1022
1023         truncate_pagecache_range(inode, offset, offset + len - 1);
1024
1025         pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
1026         pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
1027
1028         off_start = offset & (PAGE_CACHE_SIZE - 1);
1029         off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
1030
1031         if (pg_start == pg_end) {
1032                 ret = fill_zero(inode, pg_start, off_start,
1033                                                 off_end - off_start);
1034                 if (ret)
1035                         return ret;
1036
1037                 if (offset + len > new_size)
1038                         new_size = offset + len;
1039                 new_size = max_t(loff_t, new_size, offset + len);
1040         } else {
1041                 if (off_start) {
1042                         ret = fill_zero(inode, pg_start++, off_start,
1043                                                 PAGE_CACHE_SIZE - off_start);
1044                         if (ret)
1045                                 return ret;
1046
1047                         new_size = max_t(loff_t, new_size,
1048                                         (loff_t)pg_start << PAGE_CACHE_SHIFT);
1049                 }
1050
1051                 for (index = pg_start; index < pg_end; index++) {
1052                         struct dnode_of_data dn;
1053                         struct page *ipage;
1054
1055                         f2fs_lock_op(sbi);
1056
1057                         ipage = get_node_page(sbi, inode->i_ino);
1058                         if (IS_ERR(ipage)) {
1059                                 ret = PTR_ERR(ipage);
1060                                 f2fs_unlock_op(sbi);
1061                                 goto out;
1062                         }
1063
1064                         set_new_dnode(&dn, inode, ipage, NULL, 0);
1065                         ret = f2fs_reserve_block(&dn, index);
1066                         if (ret) {
1067                                 f2fs_unlock_op(sbi);
1068                                 goto out;
1069                         }
1070
1071                         if (dn.data_blkaddr != NEW_ADDR) {
1072                                 invalidate_blocks(sbi, dn.data_blkaddr);
1073
1074                                 dn.data_blkaddr = NEW_ADDR;
1075                                 set_data_blkaddr(&dn);
1076
1077                                 dn.data_blkaddr = NULL_ADDR;
1078                                 f2fs_update_extent_cache(&dn);
1079                         }
1080                         f2fs_put_dnode(&dn);
1081                         f2fs_unlock_op(sbi);
1082
1083                         new_size = max_t(loff_t, new_size,
1084                                 (loff_t)(index + 1) << PAGE_CACHE_SHIFT);
1085                 }
1086
1087                 if (off_end) {
1088                         ret = fill_zero(inode, pg_end, 0, off_end);
1089                         if (ret)
1090                                 goto out;
1091
1092                         new_size = max_t(loff_t, new_size, offset + len);
1093                 }
1094         }
1095
1096 out:
1097         if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) {
1098                 i_size_write(inode, new_size);
1099                 mark_inode_dirty(inode);
1100                 update_inode_page(inode);
1101         }
1102
1103         return ret;
1104 }
1105
1106 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1107 {
1108         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1109         pgoff_t pg_start, pg_end, delta, nrpages, idx;
1110         loff_t new_size;
1111         int ret = 0;
1112
1113         new_size = i_size_read(inode) + len;
1114         if (new_size > inode->i_sb->s_maxbytes)
1115                 return -EFBIG;
1116
1117         if (offset >= i_size_read(inode))
1118                 return -EINVAL;
1119
1120         /* insert range should be aligned to block size of f2fs. */
1121         if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1122                 return -EINVAL;
1123
1124         f2fs_balance_fs(sbi);
1125
1126         if (f2fs_has_inline_data(inode)) {
1127                 ret = f2fs_convert_inline_inode(inode);
1128                 if (ret)
1129                         return ret;
1130         }
1131
1132         ret = truncate_blocks(inode, i_size_read(inode), true);
1133         if (ret)
1134                 return ret;
1135
1136         /* write out all dirty pages from offset */
1137         ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1138         if (ret)
1139                 return ret;
1140
1141         truncate_pagecache(inode, offset);
1142
1143         pg_start = offset >> PAGE_CACHE_SHIFT;
1144         pg_end = (offset + len) >> PAGE_CACHE_SHIFT;
1145         delta = pg_end - pg_start;
1146         nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
1147
1148         for (idx = nrpages - 1; idx >= pg_start && idx != -1; idx--) {
1149                 f2fs_lock_op(sbi);
1150                 ret = __exchange_data_block(inode, idx, idx + delta, false);
1151                 f2fs_unlock_op(sbi);
1152                 if (ret)
1153                         break;
1154         }
1155
1156         /* write out all moved pages, if possible */
1157         filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1158         truncate_pagecache(inode, offset);
1159
1160         if (!ret)
1161                 i_size_write(inode, new_size);
1162         return ret;
1163 }
1164
1165 static int expand_inode_data(struct inode *inode, loff_t offset,
1166                                         loff_t len, int mode)
1167 {
1168         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1169         pgoff_t index, pg_start, pg_end;
1170         loff_t new_size = i_size_read(inode);
1171         loff_t off_start, off_end;
1172         int ret = 0;
1173
1174         f2fs_balance_fs(sbi);
1175
1176         ret = inode_newsize_ok(inode, (len + offset));
1177         if (ret)
1178                 return ret;
1179
1180         if (f2fs_has_inline_data(inode)) {
1181                 ret = f2fs_convert_inline_inode(inode);
1182                 if (ret)
1183                         return ret;
1184         }
1185
1186         pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
1187         pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
1188
1189         off_start = offset & (PAGE_CACHE_SIZE - 1);
1190         off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
1191
1192         f2fs_lock_op(sbi);
1193
1194         for (index = pg_start; index <= pg_end; index++) {
1195                 struct dnode_of_data dn;
1196
1197                 if (index == pg_end && !off_end)
1198                         goto noalloc;
1199
1200                 set_new_dnode(&dn, inode, NULL, NULL, 0);
1201                 ret = f2fs_reserve_block(&dn, index);
1202                 if (ret)
1203                         break;
1204 noalloc:
1205                 if (pg_start == pg_end)
1206                         new_size = offset + len;
1207                 else if (index == pg_start && off_start)
1208                         new_size = (loff_t)(index + 1) << PAGE_CACHE_SHIFT;
1209                 else if (index == pg_end)
1210                         new_size = ((loff_t)index << PAGE_CACHE_SHIFT) +
1211                                                                 off_end;
1212                 else
1213                         new_size += PAGE_CACHE_SIZE;
1214         }
1215
1216         if (!(mode & FALLOC_FL_KEEP_SIZE) &&
1217                 i_size_read(inode) < new_size) {
1218                 i_size_write(inode, new_size);
1219                 mark_inode_dirty(inode);
1220                 update_inode_page(inode);
1221         }
1222         f2fs_unlock_op(sbi);
1223
1224         return ret;
1225 }
1226
1227 static long f2fs_fallocate(struct file *file, int mode,
1228                                 loff_t offset, loff_t len)
1229 {
1230         struct inode *inode = file_inode(file);
1231         long ret = 0;
1232
1233         /* f2fs only support ->fallocate for regular file */
1234         if (!S_ISREG(inode->i_mode))
1235                 return -EINVAL;
1236
1237         if (f2fs_encrypted_inode(inode) &&
1238                 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
1239                 return -EOPNOTSUPP;
1240
1241         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1242                         FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
1243                         FALLOC_FL_INSERT_RANGE))
1244                 return -EOPNOTSUPP;
1245
1246         mutex_lock(&inode->i_mutex);
1247
1248         if (mode & FALLOC_FL_PUNCH_HOLE) {
1249                 if (offset >= inode->i_size)
1250                         goto out;
1251
1252                 ret = punch_hole(inode, offset, len);
1253         } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1254                 ret = f2fs_collapse_range(inode, offset, len);
1255         } else if (mode & FALLOC_FL_ZERO_RANGE) {
1256                 ret = f2fs_zero_range(inode, offset, len, mode);
1257         } else if (mode & FALLOC_FL_INSERT_RANGE) {
1258                 ret = f2fs_insert_range(inode, offset, len);
1259         } else {
1260                 ret = expand_inode_data(inode, offset, len, mode);
1261         }
1262
1263         if (!ret) {
1264                 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1265                 mark_inode_dirty(inode);
1266         }
1267
1268 out:
1269         mutex_unlock(&inode->i_mutex);
1270
1271         trace_f2fs_fallocate(inode, mode, offset, len, ret);
1272         return ret;
1273 }
1274
1275 static int f2fs_release_file(struct inode *inode, struct file *filp)
1276 {
1277         /* some remained atomic pages should discarded */
1278         if (f2fs_is_atomic_file(inode))
1279                 commit_inmem_pages(inode, true);
1280         if (f2fs_is_volatile_file(inode)) {
1281                 set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
1282                 filemap_fdatawrite(inode->i_mapping);
1283                 clear_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
1284         }
1285         return 0;
1286 }
1287
1288 #define F2FS_REG_FLMASK         (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
1289 #define F2FS_OTHER_FLMASK       (FS_NODUMP_FL | FS_NOATIME_FL)
1290
1291 static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
1292 {
1293         if (S_ISDIR(mode))
1294                 return flags;
1295         else if (S_ISREG(mode))
1296                 return flags & F2FS_REG_FLMASK;
1297         else
1298                 return flags & F2FS_OTHER_FLMASK;
1299 }
1300
1301 static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
1302 {
1303         struct inode *inode = file_inode(filp);
1304         struct f2fs_inode_info *fi = F2FS_I(inode);
1305         unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
1306         return put_user(flags, (int __user *)arg);
1307 }
1308
1309 static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1310 {
1311         struct inode *inode = file_inode(filp);
1312         struct f2fs_inode_info *fi = F2FS_I(inode);
1313         unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
1314         unsigned int oldflags;
1315         int ret;
1316
1317         ret = mnt_want_write_file(filp);
1318         if (ret)
1319                 return ret;
1320
1321         if (!inode_owner_or_capable(inode)) {
1322                 ret = -EACCES;
1323                 goto out;
1324         }
1325
1326         if (get_user(flags, (int __user *)arg)) {
1327                 ret = -EFAULT;
1328                 goto out;
1329         }
1330
1331         flags = f2fs_mask_flags(inode->i_mode, flags);
1332
1333         mutex_lock(&inode->i_mutex);
1334
1335         oldflags = fi->i_flags;
1336
1337         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
1338                 if (!capable(CAP_LINUX_IMMUTABLE)) {
1339                         mutex_unlock(&inode->i_mutex);
1340                         ret = -EPERM;
1341                         goto out;
1342                 }
1343         }
1344
1345         flags = flags & FS_FL_USER_MODIFIABLE;
1346         flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
1347         fi->i_flags = flags;
1348         mutex_unlock(&inode->i_mutex);
1349
1350         f2fs_set_inode_flags(inode);
1351         inode->i_ctime = CURRENT_TIME;
1352         mark_inode_dirty(inode);
1353 out:
1354         mnt_drop_write_file(filp);
1355         return ret;
1356 }
1357
1358 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
1359 {
1360         struct inode *inode = file_inode(filp);
1361
1362         return put_user(inode->i_generation, (int __user *)arg);
1363 }
1364
1365 static int f2fs_ioc_start_atomic_write(struct file *filp)
1366 {
1367         struct inode *inode = file_inode(filp);
1368         int ret;
1369
1370         if (!inode_owner_or_capable(inode))
1371                 return -EACCES;
1372
1373         f2fs_balance_fs(F2FS_I_SB(inode));
1374
1375         if (f2fs_is_atomic_file(inode))
1376                 return 0;
1377
1378         ret = f2fs_convert_inline_inode(inode);
1379         if (ret)
1380                 return ret;
1381
1382         set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
1383         return 0;
1384 }
1385
1386 static int f2fs_ioc_commit_atomic_write(struct file *filp)
1387 {
1388         struct inode *inode = file_inode(filp);
1389         int ret;
1390
1391         if (!inode_owner_or_capable(inode))
1392                 return -EACCES;
1393
1394         if (f2fs_is_volatile_file(inode))
1395                 return 0;
1396
1397         ret = mnt_want_write_file(filp);
1398         if (ret)
1399                 return ret;
1400
1401         if (f2fs_is_atomic_file(inode)) {
1402                 clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
1403                 ret = commit_inmem_pages(inode, false);
1404                 if (ret)
1405                         goto err_out;
1406         }
1407
1408         ret = f2fs_sync_file(filp, 0, LLONG_MAX, 0);
1409 err_out:
1410         mnt_drop_write_file(filp);
1411         return ret;
1412 }
1413
1414 static int f2fs_ioc_start_volatile_write(struct file *filp)
1415 {
1416         struct inode *inode = file_inode(filp);
1417         int ret;
1418
1419         if (!inode_owner_or_capable(inode))
1420                 return -EACCES;
1421
1422         if (f2fs_is_volatile_file(inode))
1423                 return 0;
1424
1425         ret = f2fs_convert_inline_inode(inode);
1426         if (ret)
1427                 return ret;
1428
1429         set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
1430         return 0;
1431 }
1432
1433 static int f2fs_ioc_release_volatile_write(struct file *filp)
1434 {
1435         struct inode *inode = file_inode(filp);
1436
1437         if (!inode_owner_or_capable(inode))
1438                 return -EACCES;
1439
1440         if (!f2fs_is_volatile_file(inode))
1441                 return 0;
1442
1443         if (!f2fs_is_first_block_written(inode))
1444                 return truncate_partial_data_page(inode, 0, true);
1445
1446         return punch_hole(inode, 0, F2FS_BLKSIZE);
1447 }
1448
1449 static int f2fs_ioc_abort_volatile_write(struct file *filp)
1450 {
1451         struct inode *inode = file_inode(filp);
1452         int ret;
1453
1454         if (!inode_owner_or_capable(inode))
1455                 return -EACCES;
1456
1457         ret = mnt_want_write_file(filp);
1458         if (ret)
1459                 return ret;
1460
1461         f2fs_balance_fs(F2FS_I_SB(inode));
1462
1463         clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
1464         clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
1465         commit_inmem_pages(inode, true);
1466
1467         mnt_drop_write_file(filp);
1468         return ret;
1469 }
1470
1471 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
1472 {
1473         struct inode *inode = file_inode(filp);
1474         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1475         struct super_block *sb = sbi->sb;
1476         __u32 in;
1477
1478         if (!capable(CAP_SYS_ADMIN))
1479                 return -EPERM;
1480
1481         if (get_user(in, (__u32 __user *)arg))
1482                 return -EFAULT;
1483
1484         switch (in) {
1485         case F2FS_GOING_DOWN_FULLSYNC:
1486                 sb = freeze_bdev(sb->s_bdev);
1487                 if (sb && !IS_ERR(sb)) {
1488                         f2fs_stop_checkpoint(sbi);
1489                         thaw_bdev(sb->s_bdev, sb);
1490                 }
1491                 break;
1492         case F2FS_GOING_DOWN_METASYNC:
1493                 /* do checkpoint only */
1494                 f2fs_sync_fs(sb, 1);
1495                 f2fs_stop_checkpoint(sbi);
1496                 break;
1497         case F2FS_GOING_DOWN_NOSYNC:
1498                 f2fs_stop_checkpoint(sbi);
1499                 break;
1500         case F2FS_GOING_DOWN_METAFLUSH:
1501                 sync_meta_pages(sbi, META, LONG_MAX);
1502                 f2fs_stop_checkpoint(sbi);
1503                 break;
1504         default:
1505                 return -EINVAL;
1506         }
1507         return 0;
1508 }
1509
1510 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
1511 {
1512         struct inode *inode = file_inode(filp);
1513         struct super_block *sb = inode->i_sb;
1514         struct request_queue *q = bdev_get_queue(sb->s_bdev);
1515         struct fstrim_range range;
1516         int ret;
1517
1518         if (!capable(CAP_SYS_ADMIN))
1519                 return -EPERM;
1520
1521         if (!blk_queue_discard(q))
1522                 return -EOPNOTSUPP;
1523
1524         if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1525                                 sizeof(range)))
1526                 return -EFAULT;
1527
1528         range.minlen = max((unsigned int)range.minlen,
1529                                 q->limits.discard_granularity);
1530         ret = f2fs_trim_fs(F2FS_SB(sb), &range);
1531         if (ret < 0)
1532                 return ret;
1533
1534         if (copy_to_user((struct fstrim_range __user *)arg, &range,
1535                                 sizeof(range)))
1536                 return -EFAULT;
1537         return 0;
1538 }
1539
1540 static bool uuid_is_nonzero(__u8 u[16])
1541 {
1542         int i;
1543
1544         for (i = 0; i < 16; i++)
1545                 if (u[i])
1546                         return true;
1547         return false;
1548 }
1549
1550 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
1551 {
1552 #ifdef CONFIG_F2FS_FS_ENCRYPTION
1553         struct f2fs_encryption_policy policy;
1554         struct inode *inode = file_inode(filp);
1555         int err;
1556
1557         if (copy_from_user(&policy, (struct f2fs_encryption_policy __user *)arg,
1558                                 sizeof(policy)))
1559                 return -EFAULT;
1560
1561         err = mnt_want_write_file(filp);
1562         if (err)
1563                 return err;
1564
1565         mutex_lock(&inode->i_mutex);
1566
1567         err = f2fs_process_policy(&policy, inode);
1568
1569         mutex_unlock(&inode->i_mutex);
1570
1571         mnt_drop_write_file(filp);
1572
1573         return err;
1574 #else
1575         return -EOPNOTSUPP;
1576 #endif
1577 }
1578
1579 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
1580 {
1581 #ifdef CONFIG_F2FS_FS_ENCRYPTION
1582         struct f2fs_encryption_policy policy;
1583         struct inode *inode = file_inode(filp);
1584         int err;
1585
1586         err = f2fs_get_policy(inode, &policy);
1587         if (err)
1588                 return err;
1589
1590         if (copy_to_user((struct f2fs_encryption_policy __user *)arg, &policy,
1591                                                         sizeof(policy)))
1592                 return -EFAULT;
1593         return 0;
1594 #else
1595         return -EOPNOTSUPP;
1596 #endif
1597 }
1598
1599 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
1600 {
1601         struct inode *inode = file_inode(filp);
1602         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1603         int err;
1604
1605         if (!f2fs_sb_has_crypto(inode->i_sb))
1606                 return -EOPNOTSUPP;
1607
1608         if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
1609                 goto got_it;
1610
1611         err = mnt_want_write_file(filp);
1612         if (err)
1613                 return err;
1614
1615         /* update superblock with uuid */
1616         generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
1617
1618         err = f2fs_commit_super(sbi, false);
1619
1620         mnt_drop_write_file(filp);
1621         if (err) {
1622                 /* undo new data */
1623                 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
1624                 return err;
1625         }
1626 got_it:
1627         if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
1628                                                                         16))
1629                 return -EFAULT;
1630         return 0;
1631 }
1632
1633 static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
1634 {
1635         struct inode *inode = file_inode(filp);
1636         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1637         __u32 sync;
1638
1639         if (!capable(CAP_SYS_ADMIN))
1640                 return -EPERM;
1641
1642         if (get_user(sync, (__u32 __user *)arg))
1643                 return -EFAULT;
1644
1645         if (f2fs_readonly(sbi->sb))
1646                 return -EROFS;
1647
1648         if (!sync) {
1649                 if (!mutex_trylock(&sbi->gc_mutex))
1650                         return -EBUSY;
1651         } else {
1652                 mutex_lock(&sbi->gc_mutex);
1653         }
1654
1655         return f2fs_gc(sbi, sync);
1656 }
1657
1658 static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg)
1659 {
1660         struct inode *inode = file_inode(filp);
1661         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1662         struct cp_control cpc;
1663
1664         if (!capable(CAP_SYS_ADMIN))
1665                 return -EPERM;
1666
1667         if (f2fs_readonly(sbi->sb))
1668                 return -EROFS;
1669
1670         cpc.reason = __get_cp_reason(sbi);
1671
1672         mutex_lock(&sbi->gc_mutex);
1673         write_checkpoint(sbi, &cpc);
1674         mutex_unlock(&sbi->gc_mutex);
1675
1676         return 0;
1677 }
1678
1679 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1680 {
1681         switch (cmd) {
1682         case F2FS_IOC_GETFLAGS:
1683                 return f2fs_ioc_getflags(filp, arg);
1684         case F2FS_IOC_SETFLAGS:
1685                 return f2fs_ioc_setflags(filp, arg);
1686         case F2FS_IOC_GETVERSION:
1687                 return f2fs_ioc_getversion(filp, arg);
1688         case F2FS_IOC_START_ATOMIC_WRITE:
1689                 return f2fs_ioc_start_atomic_write(filp);
1690         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
1691                 return f2fs_ioc_commit_atomic_write(filp);
1692         case F2FS_IOC_START_VOLATILE_WRITE:
1693                 return f2fs_ioc_start_volatile_write(filp);
1694         case F2FS_IOC_RELEASE_VOLATILE_WRITE:
1695                 return f2fs_ioc_release_volatile_write(filp);
1696         case F2FS_IOC_ABORT_VOLATILE_WRITE:
1697                 return f2fs_ioc_abort_volatile_write(filp);
1698         case F2FS_IOC_SHUTDOWN:
1699                 return f2fs_ioc_shutdown(filp, arg);
1700         case FITRIM:
1701                 return f2fs_ioc_fitrim(filp, arg);
1702         case F2FS_IOC_SET_ENCRYPTION_POLICY:
1703                 return f2fs_ioc_set_encryption_policy(filp, arg);
1704         case F2FS_IOC_GET_ENCRYPTION_POLICY:
1705                 return f2fs_ioc_get_encryption_policy(filp, arg);
1706         case F2FS_IOC_GET_ENCRYPTION_PWSALT:
1707                 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
1708         case F2FS_IOC_GARBAGE_COLLECT:
1709                 return f2fs_ioc_gc(filp, arg);
1710         case F2FS_IOC_WRITE_CHECKPOINT:
1711                 return f2fs_ioc_write_checkpoint(filp, arg);
1712         default:
1713                 return -ENOTTY;
1714         }
1715 }
1716
1717 static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1718 {
1719         struct inode *inode = file_inode(iocb->ki_filp);
1720
1721         if (f2fs_encrypted_inode(inode) &&
1722                                 !f2fs_has_encryption_key(inode) &&
1723                                 f2fs_get_encryption_info(inode))
1724                 return -EACCES;
1725
1726         return generic_file_write_iter(iocb, from);
1727 }
1728
1729 #ifdef CONFIG_COMPAT
1730 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1731 {
1732         switch (cmd) {
1733         case F2FS_IOC32_GETFLAGS:
1734                 cmd = F2FS_IOC_GETFLAGS;
1735                 break;
1736         case F2FS_IOC32_SETFLAGS:
1737                 cmd = F2FS_IOC_SETFLAGS;
1738                 break;
1739         default:
1740                 return -ENOIOCTLCMD;
1741         }
1742         return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1743 }
1744 #endif
1745
1746 const struct file_operations f2fs_file_operations = {
1747         .llseek         = f2fs_llseek,
1748         .read_iter      = generic_file_read_iter,
1749         .write_iter     = f2fs_file_write_iter,
1750         .open           = f2fs_file_open,
1751         .release        = f2fs_release_file,
1752         .mmap           = f2fs_file_mmap,
1753         .fsync          = f2fs_sync_file,
1754         .fallocate      = f2fs_fallocate,
1755         .unlocked_ioctl = f2fs_ioctl,
1756 #ifdef CONFIG_COMPAT
1757         .compat_ioctl   = f2fs_compat_ioctl,
1758 #endif
1759         .splice_read    = generic_file_splice_read,
1760         .splice_write   = iter_file_splice_write,
1761 };