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