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