fs/f2fs/file.c

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