fs/f2fs/file.c

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