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
  24 #include "f2fs.h"
  25 #include "node.h"
  26 #include "segment.h"
  27 #include "xattr.h"
  28 #include "acl.h"
  29 #include <trace/events/f2fs.h>
  30
  31 static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
  32                                                 struct vm_fault *vmf)
  33 {
  34         struct page *page = vmf->page;
  35         struct inode *inode = file_inode(vma->vm_file);
  36         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  37         struct dnode_of_data dn;
  38         int err;
  39
  40         f2fs_balance_fs(sbi);
  41
  42         sb_start_pagefault(inode->i_sb);
  43
  44         f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
  45
  46         /* block allocation */
  47         f2fs_lock_op(sbi);
  48         set_new_dnode(&dn, inode, NULL, NULL, 0);
  49         err = f2fs_reserve_block(&dn, page->index);
  50         if (err) {
  51                 f2fs_unlock_op(sbi);
  52                 goto out;
  53         }
  54         f2fs_put_dnode(&dn);
  55         f2fs_unlock_op(sbi);
  56
  57         file_update_time(vma->vm_file);
  58         lock_page(page);
  59         if (unlikely(page->mapping != inode->i_mapping ||
  60                         page_offset(page) > i_size_read(inode) ||
  61                         !PageUptodate(page))) {
  62                 unlock_page(page);
  63                 err = -EFAULT;
  64                 goto out;
  65         }
  66
  67         /*
  68          * check to see if the page is mapped already (no holes)
  69          */
  70         if (PageMappedToDisk(page))
  71                 goto mapped;
  72
  73         /* page is wholly or partially inside EOF */
  74         if (((page->index + 1) << PAGE_CACHE_SHIFT) > i_size_read(inode)) {
  75                 unsigned offset;
  76                 offset = i_size_read(inode) & ~PAGE_CACHE_MASK;
  77                 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
  78         }
  79         set_page_dirty(page);
  80         SetPageUptodate(page);
  81
  82         trace_f2fs_vm_page_mkwrite(page, DATA);
  83 mapped:
  84         /* fill the page */
  85         f2fs_wait_on_page_writeback(page, DATA);
  86 out:
  87         sb_end_pagefault(inode->i_sb);
  88         return block_page_mkwrite_return(err);
  89 }
  90
  91 static const struct vm_operations_struct f2fs_file_vm_ops = {
  92         .fault          = filemap_fault,
  93         .map_pages      = filemap_map_pages,
  94         .page_mkwrite   = f2fs_vm_page_mkwrite,
  95 };
  96
  97 static int get_parent_ino(struct inode *inode, nid_t *pino)
  98 {
  99         struct dentry *dentry;
 100
 101         inode = igrab(inode);
 102         dentry = d_find_any_alias(inode);
 103         iput(inode);
 104         if (!dentry)
 105                 return 0;
 106
 107         if (update_dent_inode(inode, &dentry->d_name)) {
 108                 dput(dentry);
 109                 return 0;
 110         }
 111
 112         *pino = parent_ino(dentry);
 113         dput(dentry);
 114         return 1;
 115 }
 116
 117 static inline bool need_do_checkpoint(struct inode *inode)
 118 {
 119         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 120         bool need_cp = false;
 121
 122         if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
 123                 need_cp = true;
 124         else if (file_wrong_pino(inode))
 125                 need_cp = true;
 126         else if (!space_for_roll_forward(sbi))
 127                 need_cp = true;
 128         else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
 129                 need_cp = true;
 130         else if (F2FS_I(inode)->xattr_ver == cur_cp_version(F2FS_CKPT(sbi)))
 131                 need_cp = true;
 132         else if (test_opt(sbi, FASTBOOT))
 133                 need_cp = true;
 134         else if (sbi->active_logs == 2)
 135                 need_cp = true;
 136
 137         return need_cp;
 138 }
 139
 140 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
 141 {
 142         struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
 143         bool ret = false;
 144         /* But we need to avoid that there are some inode updates */
 145         if ((i && PageDirty(i)) || need_inode_block_update(sbi, ino))
 146                 ret = true;
 147         f2fs_put_page(i, 0);
 148         return ret;
 149 }
 150
 151 static void try_to_fix_pino(struct inode *inode)
 152 {
 153         struct f2fs_inode_info *fi = F2FS_I(inode);
 154         nid_t pino;
 155
 156         down_write(&fi->i_sem);
 157         fi->xattr_ver = 0;
 158         if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
 159                         get_parent_ino(inode, &pino)) {
 160                 fi->i_pino = pino;
 161                 file_got_pino(inode);
 162                 up_write(&fi->i_sem);
 163
 164                 mark_inode_dirty_sync(inode);
 165                 f2fs_write_inode(inode, NULL);
 166         } else {
 167                 up_write(&fi->i_sem);
 168         }
 169 }
 170
 171 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 172 {
 173         struct inode *inode = file->f_mapping->host;
 174         struct f2fs_inode_info *fi = F2FS_I(inode);
 175         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 176         nid_t ino = inode->i_ino;
 177         int ret = 0;
 178         bool need_cp = false;
 179         struct writeback_control wbc = {
 180                 .sync_mode = WB_SYNC_ALL,
 181                 .nr_to_write = LONG_MAX,
 182                 .for_reclaim = 0,
 183         };
 184
 185         if (unlikely(f2fs_readonly(inode->i_sb)))
 186                 return 0;
 187
 188         trace_f2fs_sync_file_enter(inode);
 189
 190         /* if fdatasync is triggered, let's do in-place-update */
 191         if (get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
 192                 set_inode_flag(fi, FI_NEED_IPU);
 193         ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
 194         clear_inode_flag(fi, FI_NEED_IPU);
 195
 196         if (ret) {
 197                 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
 198                 return ret;
 199         }
 200
 201         /* if the inode is dirty, let's recover all the time */
 202         if (!datasync && is_inode_flag_set(fi, FI_DIRTY_INODE)) {
 203                 update_inode_page(inode);
 204                 goto go_write;
 205         }
 206
 207         /*
 208          * if there is no written data, don't waste time to write recovery info.
 209          */
 210         if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
 211                         !exist_written_data(sbi, ino, APPEND_INO)) {
 212
 213                 /* it may call write_inode just prior to fsync */
 214                 if (need_inode_page_update(sbi, ino))
 215                         goto go_write;
 216
 217                 if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
 218                                 exist_written_data(sbi, ino, UPDATE_INO))
 219                         goto flush_out;
 220                 goto out;
 221         }
 222 go_write:
 223         /* guarantee free sections for fsync */
 224         f2fs_balance_fs(sbi);
 225
 226         /*
 227          * Both of fdatasync() and fsync() are able to be recovered from
 228          * sudden-power-off.
 229          */
 230         down_read(&fi->i_sem);
 231         need_cp = need_do_checkpoint(inode);
 232         up_read(&fi->i_sem);
 233
 234         if (need_cp) {
 235                 /* all the dirty node pages should be flushed for POR */
 236                 ret = f2fs_sync_fs(inode->i_sb, 1);
 237
 238                 /*
 239                  * We've secured consistency through sync_fs. Following pino
 240                  * will be used only for fsynced inodes after checkpoint.
 241                  */
 242                 try_to_fix_pino(inode);
 243                 goto out;
 244         }
 245 sync_nodes:
 246         sync_node_pages(sbi, ino, &wbc);
 247
 248         if (need_inode_block_update(sbi, ino)) {
 249                 mark_inode_dirty_sync(inode);
 250                 f2fs_write_inode(inode, NULL);
 251                 goto sync_nodes;
 252         }
 253
 254         ret = wait_on_node_pages_writeback(sbi, ino);
 255         if (ret)
 256                 goto out;
 257
 258         /* once recovery info is written, don't need to tack this */
 259         remove_dirty_inode(sbi, ino, APPEND_INO);
 260         clear_inode_flag(fi, FI_APPEND_WRITE);
 261 flush_out:
 262         remove_dirty_inode(sbi, ino, UPDATE_INO);
 263         clear_inode_flag(fi, FI_UPDATE_WRITE);
 264         ret = f2fs_issue_flush(sbi);
 265 out:
 266         trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
 267         return ret;
 268 }
 269
 270 static pgoff_t __get_first_dirty_index(struct address_space *mapping,
 271                                                 pgoff_t pgofs, int whence)
 272 {
 273         struct pagevec pvec;
 274         int nr_pages;
 275
 276         if (whence != SEEK_DATA)
 277                 return 0;
 278
 279         /* find first dirty page index */
 280         pagevec_init(&pvec, 0);
 281         nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
 282                                         PAGECACHE_TAG_DIRTY, 1);
 283         pgofs = nr_pages ? pvec.pages[0]->index : LONG_MAX;
 284         pagevec_release(&pvec);
 285         return pgofs;
 286 }
 287
 288 static bool __found_offset(block_t blkaddr, pgoff_t dirty, pgoff_t pgofs,
 289                                                         int whence)
 290 {
 291         switch (whence) {
 292         case SEEK_DATA:
 293                 if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
 294                         (blkaddr != NEW_ADDR && blkaddr != NULL_ADDR))
 295                         return true;
 296                 break;
 297         case SEEK_HOLE:
 298                 if (blkaddr == NULL_ADDR)
 299                         return true;
 300                 break;
 301         }
 302         return false;
 303 }
 304
 305 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
 306 {
 307         struct inode *inode = file->f_mapping->host;
 308         loff_t maxbytes = inode->i_sb->s_maxbytes;
 309         struct dnode_of_data dn;
 310         pgoff_t pgofs, end_offset, dirty;
 311         loff_t data_ofs = offset;
 312         loff_t isize;
 313         int err = 0;
 314
 315         mutex_lock(&inode->i_mutex);
 316
 317         isize = i_size_read(inode);
 318         if (offset >= isize)
 319                 goto fail;
 320
 321         /* handle inline data case */
 322         if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
 323                 if (whence == SEEK_HOLE)
 324                         data_ofs = isize;
 325                 goto found;
 326         }
 327
 328         pgofs = (pgoff_t)(offset >> PAGE_CACHE_SHIFT);
 329
 330         dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
 331
 332         for (; data_ofs < isize; data_ofs = pgofs << PAGE_CACHE_SHIFT) {
 333                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 334                 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE_RA);
 335                 if (err && err != -ENOENT) {
 336                         goto fail;
 337                 } else if (err == -ENOENT) {
 338                         /* direct node does not exists */
 339                         if (whence == SEEK_DATA) {
 340                                 pgofs = PGOFS_OF_NEXT_DNODE(pgofs,
 341                                                         F2FS_I(inode));
 342                                 continue;
 343                         } else {
 344                                 goto found;
 345                         }
 346                 }
 347
 348                 end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 349
 350                 /* find data/hole in dnode block */
 351                 for (; dn.ofs_in_node < end_offset;
 352                                 dn.ofs_in_node++, pgofs++,
 353                                 data_ofs = pgofs << PAGE_CACHE_SHIFT) {
 354                         block_t blkaddr;
 355                         blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 356
 357                         if (__found_offset(blkaddr, dirty, pgofs, whence)) {
 358                                 f2fs_put_dnode(&dn);
 359                                 goto found;
 360                         }
 361                 }
 362                 f2fs_put_dnode(&dn);
 363         }
 364
 365         if (whence == SEEK_DATA)
 366                 goto fail;
 367 found:
 368         if (whence == SEEK_HOLE && data_ofs > isize)
 369                 data_ofs = isize;
 370         mutex_unlock(&inode->i_mutex);
 371         return vfs_setpos(file, data_ofs, maxbytes);
 372 fail:
 373         mutex_unlock(&inode->i_mutex);
 374         return -ENXIO;
 375 }
 376
 377 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
 378 {
 379         struct inode *inode = file->f_mapping->host;
 380         loff_t maxbytes = inode->i_sb->s_maxbytes;
 381
 382         switch (whence) {
 383         case SEEK_SET:
 384         case SEEK_CUR:
 385         case SEEK_END:
 386                 return generic_file_llseek_size(file, offset, whence,
 387                                                 maxbytes, i_size_read(inode));
 388         case SEEK_DATA:
 389         case SEEK_HOLE:
 390                 if (offset < 0)
 391                         return -ENXIO;
 392                 return f2fs_seek_block(file, offset, whence);
 393         }
 394
 395         return -EINVAL;
 396 }
 397
 398 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 399 {
 400         struct inode *inode = file_inode(file);
 401
 402         /* we don't need to use inline_data strictly */
 403         if (f2fs_has_inline_data(inode)) {
 404                 int err = f2fs_convert_inline_inode(inode);
 405                 if (err)
 406                         return err;
 407         }
 408
 409         file_accessed(file);
 410         vma->vm_ops = &f2fs_file_vm_ops;
 411         return 0;
 412 }
 413
 414 int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 415 {
 416         int nr_free = 0, ofs = dn->ofs_in_node;
 417         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 418         struct f2fs_node *raw_node;
 419         __le32 *addr;
 420
 421         raw_node = F2FS_NODE(dn->node_page);
 422         addr = blkaddr_in_node(raw_node) + ofs;
 423
 424         for (; count > 0; count--, addr++, dn->ofs_in_node++) {
 425                 block_t blkaddr = le32_to_cpu(*addr);
 426                 if (blkaddr == NULL_ADDR)
 427                         continue;
 428
 429                 update_extent_cache(NULL_ADDR, dn);
 430                 invalidate_blocks(sbi, blkaddr);
 431                 nr_free++;
 432         }
 433         if (nr_free) {
 434                 dec_valid_block_count(sbi, dn->inode, nr_free);
 435                 set_page_dirty(dn->node_page);
 436                 sync_inode_page(dn);
 437         }
 438         dn->ofs_in_node = ofs;
 439
 440         trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
 441                                          dn->ofs_in_node, nr_free);
 442         return nr_free;
 443 }
 444
 445 void truncate_data_blocks(struct dnode_of_data *dn)
 446 {
 447         truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
 448 }
 449
 450 static int truncate_partial_data_page(struct inode *inode, u64 from)
 451 {
 452         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
 453         struct page *page;
 454
 455         if (!offset)
 456                 return 0;
 457
 458         page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, false);
 459         if (IS_ERR(page))
 460                 return 0;
 461
 462         lock_page(page);
 463         if (unlikely(!PageUptodate(page) ||
 464                         page->mapping != inode->i_mapping))
 465                 goto out;
 466
 467         f2fs_wait_on_page_writeback(page, DATA);
 468         zero_user(page, offset, PAGE_CACHE_SIZE - offset);
 469         set_page_dirty(page);
 470 out:
 471         f2fs_put_page(page, 1);
 472         return 0;
 473 }
 474
 475 int truncate_blocks(struct inode *inode, u64 from, bool lock)
 476 {
 477         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 478         unsigned int blocksize = inode->i_sb->s_blocksize;
 479         struct dnode_of_data dn;
 480         pgoff_t free_from;
 481         int count = 0, err = 0;
 482         struct page *ipage;
 483
 484         trace_f2fs_truncate_blocks_enter(inode, from);
 485
 486         free_from = (pgoff_t)
 487                 ((from + blocksize - 1) >> (sbi->log_blocksize));
 488
 489         if (lock)
 490                 f2fs_lock_op(sbi);
 491
 492         ipage = get_node_page(sbi, inode->i_ino);
 493         if (IS_ERR(ipage)) {
 494                 err = PTR_ERR(ipage);
 495                 goto out;
 496         }
 497
 498         if (f2fs_has_inline_data(inode)) {
 499                 f2fs_put_page(ipage, 1);
 500                 goto out;
 501         }
 502
 503         set_new_dnode(&dn, inode, ipage, NULL, 0);
 504         err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE);
 505         if (err) {
 506                 if (err == -ENOENT)
 507                         goto free_next;
 508                 goto out;
 509         }
 510
 511         count = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 512
 513         count -= dn.ofs_in_node;
 514         f2fs_bug_on(sbi, count < 0);
 515
 516         if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
 517                 truncate_data_blocks_range(&dn, count);
 518                 free_from += count;
 519         }
 520
 521         f2fs_put_dnode(&dn);
 522 free_next:
 523         err = truncate_inode_blocks(inode, free_from);
 524 out:
 525         if (lock)
 526                 f2fs_unlock_op(sbi);
 527
 528         /* lastly zero out the first data page */
 529         if (!err)
 530                 err = truncate_partial_data_page(inode, from);
 531
 532         trace_f2fs_truncate_blocks_exit(inode, err);
 533         return err;
 534 }
 535
 536 void f2fs_truncate(struct inode *inode)
 537 {
 538         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 539                                 S_ISLNK(inode->i_mode)))
 540                 return;
 541
 542         trace_f2fs_truncate(inode);
 543
 544         /* we should check inline_data size */
 545         if (f2fs_has_inline_data(inode) && !f2fs_may_inline(inode)) {
 546                 if (f2fs_convert_inline_inode(inode))
 547                         return;
 548         }
 549
 550         if (!truncate_blocks(inode, i_size_read(inode), true)) {
 551                 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 552                 mark_inode_dirty(inode);
 553         }
 554 }
 555
 556 int f2fs_getattr(struct vfsmount *mnt,
 557                          struct dentry *dentry, struct kstat *stat)
 558 {
 559         struct inode *inode = dentry->d_inode;
 560         generic_fillattr(inode, stat);
 561         stat->blocks <<= 3;
 562         return 0;
 563 }
 564
 565 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 566 static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 567 {
 568         struct f2fs_inode_info *fi = F2FS_I(inode);
 569         unsigned int ia_valid = attr->ia_valid;
 570
 571         if (ia_valid & ATTR_UID)
 572                 inode->i_uid = attr->ia_uid;
 573         if (ia_valid & ATTR_GID)
 574                 inode->i_gid = attr->ia_gid;
 575         if (ia_valid & ATTR_ATIME)
 576                 inode->i_atime = timespec_trunc(attr->ia_atime,
 577                                                 inode->i_sb->s_time_gran);
 578         if (ia_valid & ATTR_MTIME)
 579                 inode->i_mtime = timespec_trunc(attr->ia_mtime,
 580                                                 inode->i_sb->s_time_gran);
 581         if (ia_valid & ATTR_CTIME)
 582                 inode->i_ctime = timespec_trunc(attr->ia_ctime,
 583                                                 inode->i_sb->s_time_gran);
 584         if (ia_valid & ATTR_MODE) {
 585                 umode_t mode = attr->ia_mode;
 586
 587                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
 588                         mode &= ~S_ISGID;
 589                 set_acl_inode(fi, mode);
 590         }
 591 }
 592 #else
 593 #define __setattr_copy setattr_copy
 594 #endif
 595
 596 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 597 {
 598         struct inode *inode = dentry->d_inode;
 599         struct f2fs_inode_info *fi = F2FS_I(inode);
 600         int err;
 601
 602         err = inode_change_ok(inode, attr);
 603         if (err)
 604                 return err;
 605
 606         if (attr->ia_valid & ATTR_SIZE) {
 607                 if (attr->ia_size != i_size_read(inode)) {
 608                         truncate_setsize(inode, attr->ia_size);
 609                         f2fs_truncate(inode);
 610                         f2fs_balance_fs(F2FS_I_SB(inode));
 611                 } else {
 612                         /*
 613                          * giving a chance to truncate blocks past EOF which
 614                          * are fallocated with FALLOC_FL_KEEP_SIZE.
 615                          */
 616                         f2fs_truncate(inode);
 617                 }
 618         }
 619
 620         __setattr_copy(inode, attr);
 621
 622         if (attr->ia_valid & ATTR_MODE) {
 623                 err = posix_acl_chmod(inode, get_inode_mode(inode));
 624                 if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
 625                         inode->i_mode = fi->i_acl_mode;
 626                         clear_inode_flag(fi, FI_ACL_MODE);
 627                 }
 628         }
 629
 630         mark_inode_dirty(inode);
 631         return err;
 632 }
 633
 634 const struct inode_operations f2fs_file_inode_operations = {
 635         .getattr        = f2fs_getattr,
 636         .setattr        = f2fs_setattr,
 637         .get_acl        = f2fs_get_acl,
 638         .set_acl        = f2fs_set_acl,
 639 #ifdef CONFIG_F2FS_FS_XATTR
 640         .setxattr       = generic_setxattr,
 641         .getxattr       = generic_getxattr,
 642         .listxattr      = f2fs_listxattr,
 643         .removexattr    = generic_removexattr,
 644 #endif
 645         .fiemap         = f2fs_fiemap,
 646 };
 647
 648 static void fill_zero(struct inode *inode, pgoff_t index,
 649                                         loff_t start, loff_t len)
 650 {
 651         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 652         struct page *page;
 653
 654         if (!len)
 655                 return;
 656
 657         f2fs_balance_fs(sbi);
 658
 659         f2fs_lock_op(sbi);
 660         page = get_new_data_page(inode, NULL, index, false);
 661         f2fs_unlock_op(sbi);
 662
 663         if (!IS_ERR(page)) {
 664                 f2fs_wait_on_page_writeback(page, DATA);
 665                 zero_user(page, start, len);
 666                 set_page_dirty(page);
 667                 f2fs_put_page(page, 1);
 668         }
 669 }
 670
 671 int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
 672 {
 673         pgoff_t index;
 674         int err;
 675
 676         for (index = pg_start; index < pg_end; index++) {
 677                 struct dnode_of_data dn;
 678
 679                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 680                 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
 681                 if (err) {
 682                         if (err == -ENOENT)
 683                                 continue;
 684                         return err;
 685                 }
 686
 687                 if (dn.data_blkaddr != NULL_ADDR)
 688                         truncate_data_blocks_range(&dn, 1);
 689                 f2fs_put_dnode(&dn);
 690         }
 691         return 0;
 692 }
 693
 694 static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
 695 {
 696         pgoff_t pg_start, pg_end;
 697         loff_t off_start, off_end;
 698         int ret = 0;
 699
 700         if (!S_ISREG(inode->i_mode))
 701                 return -EOPNOTSUPP;
 702
 703         /* skip punching hole beyond i_size */
 704         if (offset >= inode->i_size)
 705                 return ret;
 706
 707         if (f2fs_has_inline_data(inode)) {
 708                 ret = f2fs_convert_inline_inode(inode);
 709                 if (ret)
 710                         return ret;
 711         }
 712
 713         pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
 714         pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
 715
 716         off_start = offset & (PAGE_CACHE_SIZE - 1);
 717         off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
 718
 719         if (pg_start == pg_end) {
 720                 fill_zero(inode, pg_start, off_start,
 721                                                 off_end - off_start);
 722         } else {
 723                 if (off_start)
 724                         fill_zero(inode, pg_start++, off_start,
 725                                         PAGE_CACHE_SIZE - off_start);
 726                 if (off_end)
 727                         fill_zero(inode, pg_end, 0, off_end);
 728
 729                 if (pg_start < pg_end) {
 730                         struct address_space *mapping = inode->i_mapping;
 731                         loff_t blk_start, blk_end;
 732                         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 733
 734                         f2fs_balance_fs(sbi);
 735
 736                         blk_start = pg_start << PAGE_CACHE_SHIFT;
 737                         blk_end = pg_end << PAGE_CACHE_SHIFT;
 738                         truncate_inode_pages_range(mapping, blk_start,
 739                                         blk_end - 1);
 740
 741                         f2fs_lock_op(sbi);
 742                         ret = truncate_hole(inode, pg_start, pg_end);
 743                         f2fs_unlock_op(sbi);
 744                 }
 745         }
 746
 747         return ret;
 748 }
 749
 750 static int expand_inode_data(struct inode *inode, loff_t offset,
 751                                         loff_t len, int mode)
 752 {
 753         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 754         pgoff_t index, pg_start, pg_end;
 755         loff_t new_size = i_size_read(inode);
 756         loff_t off_start, off_end;
 757         int ret = 0;
 758
 759         f2fs_balance_fs(sbi);
 760
 761         ret = inode_newsize_ok(inode, (len + offset));
 762         if (ret)
 763                 return ret;
 764
 765         if (f2fs_has_inline_data(inode)) {
 766                 ret = f2fs_convert_inline_inode(inode);
 767                 if (ret)
 768                         return ret;
 769         }
 770
 771         pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
 772         pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
 773
 774         off_start = offset & (PAGE_CACHE_SIZE - 1);
 775         off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
 776
 777         f2fs_lock_op(sbi);
 778
 779         for (index = pg_start; index <= pg_end; index++) {
 780                 struct dnode_of_data dn;
 781
 782                 if (index == pg_end && !off_end)
 783                         goto noalloc;
 784
 785                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 786                 ret = f2fs_reserve_block(&dn, index);
 787                 if (ret)
 788                         break;
 789 noalloc:
 790                 if (pg_start == pg_end)
 791                         new_size = offset + len;
 792                 else if (index == pg_start && off_start)
 793                         new_size = (index + 1) << PAGE_CACHE_SHIFT;
 794                 else if (index == pg_end)
 795                         new_size = (index << PAGE_CACHE_SHIFT) + off_end;
 796                 else
 797                         new_size += PAGE_CACHE_SIZE;
 798         }
 799
 800         if (!(mode & FALLOC_FL_KEEP_SIZE) &&
 801                 i_size_read(inode) < new_size) {
 802                 i_size_write(inode, new_size);
 803                 mark_inode_dirty(inode);
 804                 update_inode_page(inode);
 805         }
 806         f2fs_unlock_op(sbi);
 807
 808         return ret;
 809 }
 810
 811 static long f2fs_fallocate(struct file *file, int mode,
 812                                 loff_t offset, loff_t len)
 813 {
 814         struct inode *inode = file_inode(file);
 815         long ret;
 816
 817         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
 818                 return -EOPNOTSUPP;
 819
 820         mutex_lock(&inode->i_mutex);
 821
 822         if (mode & FALLOC_FL_PUNCH_HOLE)
 823                 ret = punch_hole(inode, offset, len);
 824         else
 825                 ret = expand_inode_data(inode, offset, len, mode);
 826
 827         if (!ret) {
 828                 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 829                 mark_inode_dirty(inode);
 830         }
 831
 832         mutex_unlock(&inode->i_mutex);
 833
 834         trace_f2fs_fallocate(inode, mode, offset, len, ret);
 835         return ret;
 836 }
 837
 838 #define F2FS_REG_FLMASK         (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
 839 #define F2FS_OTHER_FLMASK       (FS_NODUMP_FL | FS_NOATIME_FL)
 840
 841 static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
 842 {
 843         if (S_ISDIR(mode))
 844                 return flags;
 845         else if (S_ISREG(mode))
 846                 return flags & F2FS_REG_FLMASK;
 847         else
 848                 return flags & F2FS_OTHER_FLMASK;
 849 }
 850
 851 static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
 852 {
 853         struct inode *inode = file_inode(filp);
 854         struct f2fs_inode_info *fi = F2FS_I(inode);
 855         unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
 856         return put_user(flags, (int __user *)arg);
 857 }
 858
 859 static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
 860 {
 861         struct inode *inode = file_inode(filp);
 862         struct f2fs_inode_info *fi = F2FS_I(inode);
 863         unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
 864         unsigned int oldflags;
 865         int ret;
 866
 867         ret = mnt_want_write_file(filp);
 868         if (ret)
 869                 return ret;
 870
 871         if (!inode_owner_or_capable(inode)) {
 872                 ret = -EACCES;
 873                 goto out;
 874         }
 875
 876         if (get_user(flags, (int __user *)arg)) {
 877                 ret = -EFAULT;
 878                 goto out;
 879         }
 880
 881         flags = f2fs_mask_flags(inode->i_mode, flags);
 882
 883         mutex_lock(&inode->i_mutex);
 884
 885         oldflags = fi->i_flags;
 886
 887         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
 888                 if (!capable(CAP_LINUX_IMMUTABLE)) {
 889                         mutex_unlock(&inode->i_mutex);
 890                         ret = -EPERM;
 891                         goto out;
 892                 }
 893         }
 894
 895         flags = flags & FS_FL_USER_MODIFIABLE;
 896         flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
 897         fi->i_flags = flags;
 898         mutex_unlock(&inode->i_mutex);
 899
 900         f2fs_set_inode_flags(inode);
 901         inode->i_ctime = CURRENT_TIME;
 902         mark_inode_dirty(inode);
 903 out:
 904         mnt_drop_write_file(filp);
 905         return ret;
 906 }
 907
 908 static int f2fs_ioc_start_atomic_write(struct file *filp)
 909 {
 910         struct inode *inode = file_inode(filp);
 911         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 912
 913         if (!inode_owner_or_capable(inode))
 914                 return -EACCES;
 915
 916         f2fs_balance_fs(sbi);
 917
 918         set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
 919
 920         return f2fs_convert_inline_inode(inode);
 921 }
 922
 923 static int f2fs_release_file(struct inode *inode, struct file *filp)
 924 {
 925         /* some remained atomic pages should discarded */
 926         if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
 927                 commit_inmem_pages(inode, true);
 928         return 0;
 929 }
 930
 931 static int f2fs_ioc_commit_atomic_write(struct file *filp)
 932 {
 933         struct inode *inode = file_inode(filp);
 934         int ret;
 935
 936         if (!inode_owner_or_capable(inode))
 937                 return -EACCES;
 938
 939         if (f2fs_is_volatile_file(inode))
 940                 return 0;
 941
 942         ret = mnt_want_write_file(filp);
 943         if (ret)
 944                 return ret;
 945
 946         if (f2fs_is_atomic_file(inode))
 947                 commit_inmem_pages(inode, false);
 948
 949         ret = f2fs_sync_file(filp, 0, LONG_MAX, 0);
 950         mnt_drop_write_file(filp);
 951         return ret;
 952 }
 953
 954 static int f2fs_ioc_start_volatile_write(struct file *filp)
 955 {
 956         struct inode *inode = file_inode(filp);
 957
 958         if (!inode_owner_or_capable(inode))
 959                 return -EACCES;
 960
 961         set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
 962
 963         return f2fs_convert_inline_inode(inode);
 964 }
 965
 966 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
 967 {
 968         struct inode *inode = file_inode(filp);
 969         struct super_block *sb = inode->i_sb;
 970         struct request_queue *q = bdev_get_queue(sb->s_bdev);
 971         struct fstrim_range range;
 972         int ret;
 973
 974         if (!capable(CAP_SYS_ADMIN))
 975                 return -EPERM;
 976
 977         if (!blk_queue_discard(q))
 978                 return -EOPNOTSUPP;
 979
 980         if (copy_from_user(&range, (struct fstrim_range __user *)arg,
 981                                 sizeof(range)))
 982                 return -EFAULT;
 983
 984         range.minlen = max((unsigned int)range.minlen,
 985                                 q->limits.discard_granularity);
 986         ret = f2fs_trim_fs(F2FS_SB(sb), &range);
 987         if (ret < 0)
 988                 return ret;
 989
 990         if (copy_to_user((struct fstrim_range __user *)arg, &range,
 991                                 sizeof(range)))
 992                 return -EFAULT;
 993         return 0;
 994 }
 995
 996 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 997 {
 998         switch (cmd) {
 999         case F2FS_IOC_GETFLAGS:
1000                 return f2fs_ioc_getflags(filp, arg);
1001         case F2FS_IOC_SETFLAGS:
1002                 return f2fs_ioc_setflags(filp, arg);
1003         case F2FS_IOC_START_ATOMIC_WRITE:
1004                 return f2fs_ioc_start_atomic_write(filp);
1005         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
1006                 return f2fs_ioc_commit_atomic_write(filp);
1007         case F2FS_IOC_START_VOLATILE_WRITE:
1008                 return f2fs_ioc_start_volatile_write(filp);
1009         case FITRIM:
1010                 return f2fs_ioc_fitrim(filp, arg);
1011         default:
1012                 return -ENOTTY;
1013         }
1014 }
1015
1016 #ifdef CONFIG_COMPAT
1017 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1018 {
1019         switch (cmd) {
1020         case F2FS_IOC32_GETFLAGS:
1021                 cmd = F2FS_IOC_GETFLAGS;
1022                 break;
1023         case F2FS_IOC32_SETFLAGS:
1024                 cmd = F2FS_IOC_SETFLAGS;
1025                 break;
1026         default:
1027                 return -ENOIOCTLCMD;
1028         }
1029         return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1030 }
1031 #endif
1032
1033 const struct file_operations f2fs_file_operations = {
1034         .llseek         = f2fs_llseek,
1035         .read           = new_sync_read,
1036         .write          = new_sync_write,
1037         .read_iter      = generic_file_read_iter,
1038         .write_iter     = generic_file_write_iter,
1039         .open           = generic_file_open,
1040         .release        = f2fs_release_file,
1041         .mmap           = f2fs_file_mmap,
1042         .fsync          = f2fs_sync_file,
1043         .fallocate      = f2fs_fallocate,
1044         .unlocked_ioctl = f2fs_ioctl,
1045 #ifdef CONFIG_COMPAT
1046         .compat_ioctl   = f2fs_compat_ioctl,
1047 #endif
1048         .splice_read    = generic_file_splice_read,
1049         .splice_write   = iter_file_splice_write,
1050 };