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