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_filemap_fault(struct vm_fault *vmf) 37 { 38 struct inode *inode = file_inode(vmf->vma->vm_file); 39 int err; 40 41 down_read(&F2FS_I(inode)->i_mmap_sem); 42 err = filemap_fault(vmf); 43 up_read(&F2FS_I(inode)->i_mmap_sem); 44 45 return err; 46 } 47 48 static int f2fs_vm_page_mkwrite(struct vm_fault *vmf) 49 { 50 struct page *page = vmf->page; 51 struct inode *inode = file_inode(vmf->vma->vm_file); 52 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 53 struct dnode_of_data dn; 54 int err; 55 56 if (unlikely(f2fs_cp_error(sbi))) { 57 err = -EIO; 58 goto err; 59 } 60 61 sb_start_pagefault(inode->i_sb); 62 63 f2fs_bug_on(sbi, f2fs_has_inline_data(inode)); 64 65 /* block allocation */ 66 f2fs_lock_op(sbi); 67 set_new_dnode(&dn, inode, NULL, NULL, 0); 68 err = f2fs_reserve_block(&dn, page->index); 69 if (err) { 70 f2fs_unlock_op(sbi); 71 goto out; 72 } 73 f2fs_put_dnode(&dn); 74 f2fs_unlock_op(sbi); 75 76 f2fs_balance_fs(sbi, dn.node_changed); 77 78 file_update_time(vmf->vma->vm_file); 79 down_read(&F2FS_I(inode)->i_mmap_sem); 80 lock_page(page); 81 if (unlikely(page->mapping != inode->i_mapping || 82 page_offset(page) > i_size_read(inode) || 83 !PageUptodate(page))) { 84 unlock_page(page); 85 err = -EFAULT; 86 goto out_sem; 87 } 88 89 /* 90 * check to see if the page is mapped already (no holes) 91 */ 92 if (PageMappedToDisk(page)) 93 goto mapped; 94 95 /* page is wholly or partially inside EOF */ 96 if (((loff_t)(page->index + 1) << PAGE_SHIFT) > 97 i_size_read(inode)) { 98 unsigned offset; 99 offset = i_size_read(inode) & ~PAGE_MASK; 100 zero_user_segment(page, offset, PAGE_SIZE); 101 } 102 set_page_dirty(page); 103 if (!PageUptodate(page)) 104 SetPageUptodate(page); 105 106 f2fs_update_iostat(sbi, APP_MAPPED_IO, F2FS_BLKSIZE); 107 108 trace_f2fs_vm_page_mkwrite(page, DATA); 109 mapped: 110 /* fill the page */ 111 f2fs_wait_on_page_writeback(page, DATA, false); 112 113 /* wait for GCed encrypted page writeback */ 114 if (f2fs_encrypted_file(inode)) 115 f2fs_wait_on_block_writeback(sbi, dn.data_blkaddr); 116 117 out_sem: 118 up_read(&F2FS_I(inode)->i_mmap_sem); 119 out: 120 sb_end_pagefault(inode->i_sb); 121 f2fs_update_time(sbi, REQ_TIME); 122 err: 123 return block_page_mkwrite_return(err); 124 } 125 126 static const struct vm_operations_struct f2fs_file_vm_ops = { 127 .fault = f2fs_filemap_fault, 128 .map_pages = filemap_map_pages, 129 .page_mkwrite = f2fs_vm_page_mkwrite, 130 }; 131 132 static int get_parent_ino(struct inode *inode, nid_t *pino) 133 { 134 struct dentry *dentry; 135 136 inode = igrab(inode); 137 dentry = d_find_any_alias(inode); 138 iput(inode); 139 if (!dentry) 140 return 0; 141 142 *pino = parent_ino(dentry); 143 dput(dentry); 144 return 1; 145 } 146 147 static inline enum cp_reason_type need_do_checkpoint(struct inode *inode) 148 { 149 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 150 enum cp_reason_type cp_reason = CP_NO_NEEDED; 151 152 if (!S_ISREG(inode->i_mode)) 153 cp_reason = CP_NON_REGULAR; 154 else if (inode->i_nlink != 1) 155 cp_reason = CP_HARDLINK; 156 else if (is_sbi_flag_set(sbi, SBI_NEED_CP)) 157 cp_reason = CP_SB_NEED_CP; 158 else if (file_wrong_pino(inode)) 159 cp_reason = CP_WRONG_PINO; 160 else if (!space_for_roll_forward(sbi)) 161 cp_reason = CP_NO_SPC_ROLL; 162 else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) 163 cp_reason = CP_NODE_NEED_CP; 164 else if (test_opt(sbi, FASTBOOT)) 165 cp_reason = CP_FASTBOOT_MODE; 166 else if (sbi->active_logs == 2) 167 cp_reason = CP_SPEC_LOG_NUM; 168 else if (need_dentry_mark(sbi, inode->i_ino) && 169 exist_written_data(sbi, F2FS_I(inode)->i_pino, TRANS_DIR_INO)) 170 cp_reason = CP_RECOVER_DIR; 171 172 return cp_reason; 173 } 174 175 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino) 176 { 177 struct page *i = find_get_page(NODE_MAPPING(sbi), ino); 178 bool ret = false; 179 /* But we need to avoid that there are some inode updates */ 180 if ((i && PageDirty(i)) || need_inode_block_update(sbi, ino)) 181 ret = true; 182 f2fs_put_page(i, 0); 183 return ret; 184 } 185 186 static void try_to_fix_pino(struct inode *inode) 187 { 188 struct f2fs_inode_info *fi = F2FS_I(inode); 189 nid_t pino; 190 191 down_write(&fi->i_sem); 192 if (file_wrong_pino(inode) && inode->i_nlink == 1 && 193 get_parent_ino(inode, &pino)) { 194 f2fs_i_pino_write(inode, pino); 195 file_got_pino(inode); 196 } 197 up_write(&fi->i_sem); 198 } 199 200 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end, 201 int datasync, bool atomic) 202 { 203 struct inode *inode = file->f_mapping->host; 204 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 205 nid_t ino = inode->i_ino; 206 int ret = 0; 207 enum cp_reason_type cp_reason = 0; 208 struct writeback_control wbc = { 209 .sync_mode = WB_SYNC_ALL, 210 .nr_to_write = LONG_MAX, 211 .for_reclaim = 0, 212 }; 213 214 if (unlikely(f2fs_readonly(inode->i_sb))) 215 return 0; 216 217 trace_f2fs_sync_file_enter(inode); 218 219 /* if fdatasync is triggered, let's do in-place-update */ 220 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks) 221 set_inode_flag(inode, FI_NEED_IPU); 222 ret = file_write_and_wait_range(file, start, end); 223 clear_inode_flag(inode, FI_NEED_IPU); 224 225 if (ret) { 226 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret); 227 return ret; 228 } 229 230 /* if the inode is dirty, let's recover all the time */ 231 if (!f2fs_skip_inode_update(inode, datasync)) { 232 f2fs_write_inode(inode, NULL); 233 goto go_write; 234 } 235 236 /* 237 * if there is no written data, don't waste time to write recovery info. 238 */ 239 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) && 240 !exist_written_data(sbi, ino, APPEND_INO)) { 241 242 /* it may call write_inode just prior to fsync */ 243 if (need_inode_page_update(sbi, ino)) 244 goto go_write; 245 246 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) || 247 exist_written_data(sbi, ino, UPDATE_INO)) 248 goto flush_out; 249 goto out; 250 } 251 go_write: 252 /* 253 * Both of fdatasync() and fsync() are able to be recovered from 254 * sudden-power-off. 255 */ 256 down_read(&F2FS_I(inode)->i_sem); 257 cp_reason = need_do_checkpoint(inode); 258 up_read(&F2FS_I(inode)->i_sem); 259 260 if (cp_reason) { 261 /* all the dirty node pages should be flushed for POR */ 262 ret = f2fs_sync_fs(inode->i_sb, 1); 263 264 /* 265 * We've secured consistency through sync_fs. Following pino 266 * will be used only for fsynced inodes after checkpoint. 267 */ 268 try_to_fix_pino(inode); 269 clear_inode_flag(inode, FI_APPEND_WRITE); 270 clear_inode_flag(inode, FI_UPDATE_WRITE); 271 goto out; 272 } 273 sync_nodes: 274 ret = fsync_node_pages(sbi, inode, &wbc, atomic); 275 if (ret) 276 goto out; 277 278 /* if cp_error was enabled, we should avoid infinite loop */ 279 if (unlikely(f2fs_cp_error(sbi))) { 280 ret = -EIO; 281 goto out; 282 } 283 284 if (need_inode_block_update(sbi, ino)) { 285 f2fs_mark_inode_dirty_sync(inode, true); 286 f2fs_write_inode(inode, NULL); 287 goto sync_nodes; 288 } 289 290 /* 291 * If it's atomic_write, it's just fine to keep write ordering. So 292 * here we don't need to wait for node write completion, since we use 293 * node chain which serializes node blocks. If one of node writes are 294 * reordered, we can see simply broken chain, resulting in stopping 295 * roll-forward recovery. It means we'll recover all or none node blocks 296 * given fsync mark. 297 */ 298 if (!atomic) { 299 ret = wait_on_node_pages_writeback(sbi, ino); 300 if (ret) 301 goto out; 302 } 303 304 /* once recovery info is written, don't need to tack this */ 305 remove_ino_entry(sbi, ino, APPEND_INO); 306 clear_inode_flag(inode, FI_APPEND_WRITE); 307 flush_out: 308 if (!atomic) 309 ret = f2fs_issue_flush(sbi, inode->i_ino); 310 if (!ret) { 311 remove_ino_entry(sbi, ino, UPDATE_INO); 312 clear_inode_flag(inode, FI_UPDATE_WRITE); 313 remove_ino_entry(sbi, ino, FLUSH_INO); 314 } 315 f2fs_update_time(sbi, REQ_TIME); 316 out: 317 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret); 318 f2fs_trace_ios(NULL, 1); 319 return ret; 320 } 321 322 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) 323 { 324 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file))))) 325 return -EIO; 326 return f2fs_do_sync_file(file, start, end, datasync, false); 327 } 328 329 static pgoff_t __get_first_dirty_index(struct address_space *mapping, 330 pgoff_t pgofs, int whence) 331 { 332 struct page *page; 333 int nr_pages; 334 335 if (whence != SEEK_DATA) 336 return 0; 337 338 /* find first dirty page index */ 339 nr_pages = find_get_pages_tag(mapping, &pgofs, PAGECACHE_TAG_DIRTY, 340 1, &page); 341 if (!nr_pages) 342 return ULONG_MAX; 343 pgofs = page->index; 344 put_page(page); 345 return pgofs; 346 } 347 348 static bool __found_offset(block_t blkaddr, pgoff_t dirty, pgoff_t pgofs, 349 int whence) 350 { 351 switch (whence) { 352 case SEEK_DATA: 353 if ((blkaddr == NEW_ADDR && dirty == pgofs) || 354 (blkaddr != NEW_ADDR && blkaddr != NULL_ADDR)) 355 return true; 356 break; 357 case SEEK_HOLE: 358 if (blkaddr == NULL_ADDR) 359 return true; 360 break; 361 } 362 return false; 363 } 364 365 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence) 366 { 367 struct inode *inode = file->f_mapping->host; 368 loff_t maxbytes = inode->i_sb->s_maxbytes; 369 struct dnode_of_data dn; 370 pgoff_t pgofs, end_offset, dirty; 371 loff_t data_ofs = offset; 372 loff_t isize; 373 int err = 0; 374 375 inode_lock(inode); 376 377 isize = i_size_read(inode); 378 if (offset >= isize) 379 goto fail; 380 381 /* handle inline data case */ 382 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) { 383 if (whence == SEEK_HOLE) 384 data_ofs = isize; 385 goto found; 386 } 387 388 pgofs = (pgoff_t)(offset >> PAGE_SHIFT); 389 390 dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence); 391 392 for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) { 393 set_new_dnode(&dn, inode, NULL, NULL, 0); 394 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE); 395 if (err && err != -ENOENT) { 396 goto fail; 397 } else if (err == -ENOENT) { 398 /* direct node does not exists */ 399 if (whence == SEEK_DATA) { 400 pgofs = get_next_page_offset(&dn, pgofs); 401 continue; 402 } else { 403 goto found; 404 } 405 } 406 407 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); 408 409 /* find data/hole in dnode block */ 410 for (; dn.ofs_in_node < end_offset; 411 dn.ofs_in_node++, pgofs++, 412 data_ofs = (loff_t)pgofs << PAGE_SHIFT) { 413 block_t blkaddr; 414 blkaddr = datablock_addr(dn.inode, 415 dn.node_page, dn.ofs_in_node); 416 417 if (__found_offset(blkaddr, dirty, pgofs, whence)) { 418 f2fs_put_dnode(&dn); 419 goto found; 420 } 421 } 422 f2fs_put_dnode(&dn); 423 } 424 425 if (whence == SEEK_DATA) 426 goto fail; 427 found: 428 if (whence == SEEK_HOLE && data_ofs > isize) 429 data_ofs = isize; 430 inode_unlock(inode); 431 return vfs_setpos(file, data_ofs, maxbytes); 432 fail: 433 inode_unlock(inode); 434 return -ENXIO; 435 } 436 437 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence) 438 { 439 struct inode *inode = file->f_mapping->host; 440 loff_t maxbytes = inode->i_sb->s_maxbytes; 441 442 switch (whence) { 443 case SEEK_SET: 444 case SEEK_CUR: 445 case SEEK_END: 446 return generic_file_llseek_size(file, offset, whence, 447 maxbytes, i_size_read(inode)); 448 case SEEK_DATA: 449 case SEEK_HOLE: 450 if (offset < 0) 451 return -ENXIO; 452 return f2fs_seek_block(file, offset, whence); 453 } 454 455 return -EINVAL; 456 } 457 458 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma) 459 { 460 struct inode *inode = file_inode(file); 461 int err; 462 463 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) 464 return -EIO; 465 466 /* we don't need to use inline_data strictly */ 467 err = f2fs_convert_inline_inode(inode); 468 if (err) 469 return err; 470 471 file_accessed(file); 472 vma->vm_ops = &f2fs_file_vm_ops; 473 return 0; 474 } 475 476 static int f2fs_file_open(struct inode *inode, struct file *filp) 477 { 478 int err = fscrypt_file_open(inode, filp); 479 480 if (err) 481 return err; 482 return dquot_file_open(inode, filp); 483 } 484 485 void truncate_data_blocks_range(struct dnode_of_data *dn, int count) 486 { 487 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); 488 struct f2fs_node *raw_node; 489 int nr_free = 0, ofs = dn->ofs_in_node, len = count; 490 __le32 *addr; 491 int base = 0; 492 493 if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode)) 494 base = get_extra_isize(dn->inode); 495 496 raw_node = F2FS_NODE(dn->node_page); 497 addr = blkaddr_in_node(raw_node) + base + ofs; 498 499 for (; count > 0; count--, addr++, dn->ofs_in_node++) { 500 block_t blkaddr = le32_to_cpu(*addr); 501 if (blkaddr == NULL_ADDR) 502 continue; 503 504 dn->data_blkaddr = NULL_ADDR; 505 set_data_blkaddr(dn); 506 invalidate_blocks(sbi, blkaddr); 507 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page)) 508 clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN); 509 nr_free++; 510 } 511 512 if (nr_free) { 513 pgoff_t fofs; 514 /* 515 * once we invalidate valid blkaddr in range [ofs, ofs + count], 516 * we will invalidate all blkaddr in the whole range. 517 */ 518 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), 519 dn->inode) + ofs; 520 f2fs_update_extent_cache_range(dn, fofs, 0, len); 521 dec_valid_block_count(sbi, dn->inode, nr_free); 522 } 523 dn->ofs_in_node = ofs; 524 525 f2fs_update_time(sbi, REQ_TIME); 526 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid, 527 dn->ofs_in_node, nr_free); 528 } 529 530 void truncate_data_blocks(struct dnode_of_data *dn) 531 { 532 truncate_data_blocks_range(dn, ADDRS_PER_BLOCK); 533 } 534 535 static int truncate_partial_data_page(struct inode *inode, u64 from, 536 bool cache_only) 537 { 538 unsigned offset = from & (PAGE_SIZE - 1); 539 pgoff_t index = from >> PAGE_SHIFT; 540 struct address_space *mapping = inode->i_mapping; 541 struct page *page; 542 543 if (!offset && !cache_only) 544 return 0; 545 546 if (cache_only) { 547 page = find_lock_page(mapping, index); 548 if (page && PageUptodate(page)) 549 goto truncate_out; 550 f2fs_put_page(page, 1); 551 return 0; 552 } 553 554 page = get_lock_data_page(inode, index, true); 555 if (IS_ERR(page)) 556 return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page); 557 truncate_out: 558 f2fs_wait_on_page_writeback(page, DATA, true); 559 zero_user(page, offset, PAGE_SIZE - offset); 560 561 /* An encrypted inode should have a key and truncate the last page. */ 562 f2fs_bug_on(F2FS_I_SB(inode), cache_only && f2fs_encrypted_inode(inode)); 563 if (!cache_only) 564 set_page_dirty(page); 565 f2fs_put_page(page, 1); 566 return 0; 567 } 568 569 int truncate_blocks(struct inode *inode, u64 from, bool lock) 570 { 571 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 572 unsigned int blocksize = inode->i_sb->s_blocksize; 573 struct dnode_of_data dn; 574 pgoff_t free_from; 575 int count = 0, err = 0; 576 struct page *ipage; 577 bool truncate_page = false; 578 579 trace_f2fs_truncate_blocks_enter(inode, from); 580 581 free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1); 582 583 if (free_from >= sbi->max_file_blocks) 584 goto free_partial; 585 586 if (lock) 587 f2fs_lock_op(sbi); 588 589 ipage = get_node_page(sbi, inode->i_ino); 590 if (IS_ERR(ipage)) { 591 err = PTR_ERR(ipage); 592 goto out; 593 } 594 595 if (f2fs_has_inline_data(inode)) { 596 truncate_inline_inode(inode, ipage, from); 597 f2fs_put_page(ipage, 1); 598 truncate_page = true; 599 goto out; 600 } 601 602 set_new_dnode(&dn, inode, ipage, NULL, 0); 603 err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA); 604 if (err) { 605 if (err == -ENOENT) 606 goto free_next; 607 goto out; 608 } 609 610 count = ADDRS_PER_PAGE(dn.node_page, inode); 611 612 count -= dn.ofs_in_node; 613 f2fs_bug_on(sbi, count < 0); 614 615 if (dn.ofs_in_node || IS_INODE(dn.node_page)) { 616 truncate_data_blocks_range(&dn, count); 617 free_from += count; 618 } 619 620 f2fs_put_dnode(&dn); 621 free_next: 622 err = truncate_inode_blocks(inode, free_from); 623 out: 624 if (lock) 625 f2fs_unlock_op(sbi); 626 free_partial: 627 /* lastly zero out the first data page */ 628 if (!err) 629 err = truncate_partial_data_page(inode, from, truncate_page); 630 631 trace_f2fs_truncate_blocks_exit(inode, err); 632 return err; 633 } 634 635 int f2fs_truncate(struct inode *inode) 636 { 637 int err; 638 639 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) 640 return -EIO; 641 642 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 643 S_ISLNK(inode->i_mode))) 644 return 0; 645 646 trace_f2fs_truncate(inode); 647 648 #ifdef CONFIG_F2FS_FAULT_INJECTION 649 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) { 650 f2fs_show_injection_info(FAULT_TRUNCATE); 651 return -EIO; 652 } 653 #endif 654 /* we should check inline_data size */ 655 if (!f2fs_may_inline_data(inode)) { 656 err = f2fs_convert_inline_inode(inode); 657 if (err) 658 return err; 659 } 660 661 err = truncate_blocks(inode, i_size_read(inode), true); 662 if (err) 663 return err; 664 665 inode->i_mtime = inode->i_ctime = current_time(inode); 666 f2fs_mark_inode_dirty_sync(inode, false); 667 return 0; 668 } 669 670 int f2fs_getattr(const struct path *path, struct kstat *stat, 671 u32 request_mask, unsigned int query_flags) 672 { 673 struct inode *inode = d_inode(path->dentry); 674 struct f2fs_inode_info *fi = F2FS_I(inode); 675 struct f2fs_inode *ri; 676 unsigned int flags; 677 678 if (f2fs_has_extra_attr(inode) && 679 f2fs_sb_has_inode_crtime(inode->i_sb) && 680 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) { 681 stat->result_mask |= STATX_BTIME; 682 stat->btime.tv_sec = fi->i_crtime.tv_sec; 683 stat->btime.tv_nsec = fi->i_crtime.tv_nsec; 684 } 685 686 flags = fi->i_flags & (FS_FL_USER_VISIBLE | FS_PROJINHERIT_FL); 687 if (flags & FS_APPEND_FL) 688 stat->attributes |= STATX_ATTR_APPEND; 689 if (flags & FS_COMPR_FL) 690 stat->attributes |= STATX_ATTR_COMPRESSED; 691 if (f2fs_encrypted_inode(inode)) 692 stat->attributes |= STATX_ATTR_ENCRYPTED; 693 if (flags & FS_IMMUTABLE_FL) 694 stat->attributes |= STATX_ATTR_IMMUTABLE; 695 if (flags & FS_NODUMP_FL) 696 stat->attributes |= STATX_ATTR_NODUMP; 697 698 stat->attributes_mask |= (STATX_ATTR_APPEND | 699 STATX_ATTR_COMPRESSED | 700 STATX_ATTR_ENCRYPTED | 701 STATX_ATTR_IMMUTABLE | 702 STATX_ATTR_NODUMP); 703 704 generic_fillattr(inode, stat); 705 706 /* we need to show initial sectors used for inline_data/dentries */ 707 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) || 708 f2fs_has_inline_dentry(inode)) 709 stat->blocks += (stat->size + 511) >> 9; 710 711 return 0; 712 } 713 714 #ifdef CONFIG_F2FS_FS_POSIX_ACL 715 static void __setattr_copy(struct inode *inode, const struct iattr *attr) 716 { 717 unsigned int ia_valid = attr->ia_valid; 718 719 if (ia_valid & ATTR_UID) 720 inode->i_uid = attr->ia_uid; 721 if (ia_valid & ATTR_GID) 722 inode->i_gid = attr->ia_gid; 723 if (ia_valid & ATTR_ATIME) 724 inode->i_atime = timespec_trunc(attr->ia_atime, 725 inode->i_sb->s_time_gran); 726 if (ia_valid & ATTR_MTIME) 727 inode->i_mtime = timespec_trunc(attr->ia_mtime, 728 inode->i_sb->s_time_gran); 729 if (ia_valid & ATTR_CTIME) 730 inode->i_ctime = timespec_trunc(attr->ia_ctime, 731 inode->i_sb->s_time_gran); 732 if (ia_valid & ATTR_MODE) { 733 umode_t mode = attr->ia_mode; 734 735 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) 736 mode &= ~S_ISGID; 737 set_acl_inode(inode, mode); 738 } 739 } 740 #else 741 #define __setattr_copy setattr_copy 742 #endif 743 744 int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 745 { 746 struct inode *inode = d_inode(dentry); 747 int err; 748 bool size_changed = false; 749 750 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) 751 return -EIO; 752 753 err = setattr_prepare(dentry, attr); 754 if (err) 755 return err; 756 757 err = fscrypt_prepare_setattr(dentry, attr); 758 if (err) 759 return err; 760 761 if (is_quota_modification(inode, attr)) { 762 err = dquot_initialize(inode); 763 if (err) 764 return err; 765 } 766 if ((attr->ia_valid & ATTR_UID && 767 !uid_eq(attr->ia_uid, inode->i_uid)) || 768 (attr->ia_valid & ATTR_GID && 769 !gid_eq(attr->ia_gid, inode->i_gid))) { 770 err = dquot_transfer(inode, attr); 771 if (err) 772 return err; 773 } 774 775 if (attr->ia_valid & ATTR_SIZE) { 776 if (attr->ia_size <= i_size_read(inode)) { 777 down_write(&F2FS_I(inode)->i_mmap_sem); 778 truncate_setsize(inode, attr->ia_size); 779 err = f2fs_truncate(inode); 780 up_write(&F2FS_I(inode)->i_mmap_sem); 781 if (err) 782 return err; 783 } else { 784 /* 785 * do not trim all blocks after i_size if target size is 786 * larger than i_size. 787 */ 788 down_write(&F2FS_I(inode)->i_mmap_sem); 789 truncate_setsize(inode, attr->ia_size); 790 up_write(&F2FS_I(inode)->i_mmap_sem); 791 792 /* should convert inline inode here */ 793 if (!f2fs_may_inline_data(inode)) { 794 err = f2fs_convert_inline_inode(inode); 795 if (err) 796 return err; 797 } 798 inode->i_mtime = inode->i_ctime = current_time(inode); 799 } 800 801 down_write(&F2FS_I(inode)->i_sem); 802 F2FS_I(inode)->last_disk_size = i_size_read(inode); 803 up_write(&F2FS_I(inode)->i_sem); 804 805 size_changed = true; 806 } 807 808 __setattr_copy(inode, attr); 809 810 if (attr->ia_valid & ATTR_MODE) { 811 err = posix_acl_chmod(inode, get_inode_mode(inode)); 812 if (err || is_inode_flag_set(inode, FI_ACL_MODE)) { 813 inode->i_mode = F2FS_I(inode)->i_acl_mode; 814 clear_inode_flag(inode, FI_ACL_MODE); 815 } 816 } 817 818 /* file size may changed here */ 819 f2fs_mark_inode_dirty_sync(inode, size_changed); 820 821 /* inode change will produce dirty node pages flushed by checkpoint */ 822 f2fs_balance_fs(F2FS_I_SB(inode), true); 823 824 return err; 825 } 826 827 const struct inode_operations f2fs_file_inode_operations = { 828 .getattr = f2fs_getattr, 829 .setattr = f2fs_setattr, 830 .get_acl = f2fs_get_acl, 831 .set_acl = f2fs_set_acl, 832 #ifdef CONFIG_F2FS_FS_XATTR 833 .listxattr = f2fs_listxattr, 834 #endif 835 .fiemap = f2fs_fiemap, 836 }; 837 838 static int fill_zero(struct inode *inode, pgoff_t index, 839 loff_t start, loff_t len) 840 { 841 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 842 struct page *page; 843 844 if (!len) 845 return 0; 846 847 f2fs_balance_fs(sbi, true); 848 849 f2fs_lock_op(sbi); 850 page = get_new_data_page(inode, NULL, index, false); 851 f2fs_unlock_op(sbi); 852 853 if (IS_ERR(page)) 854 return PTR_ERR(page); 855 856 f2fs_wait_on_page_writeback(page, DATA, true); 857 zero_user(page, start, len); 858 set_page_dirty(page); 859 f2fs_put_page(page, 1); 860 return 0; 861 } 862 863 int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end) 864 { 865 int err; 866 867 while (pg_start < pg_end) { 868 struct dnode_of_data dn; 869 pgoff_t end_offset, count; 870 871 set_new_dnode(&dn, inode, NULL, NULL, 0); 872 err = get_dnode_of_data(&dn, pg_start, LOOKUP_NODE); 873 if (err) { 874 if (err == -ENOENT) { 875 pg_start = get_next_page_offset(&dn, pg_start); 876 continue; 877 } 878 return err; 879 } 880 881 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); 882 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start); 883 884 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset); 885 886 truncate_data_blocks_range(&dn, count); 887 f2fs_put_dnode(&dn); 888 889 pg_start += count; 890 } 891 return 0; 892 } 893 894 static int punch_hole(struct inode *inode, loff_t offset, loff_t len) 895 { 896 pgoff_t pg_start, pg_end; 897 loff_t off_start, off_end; 898 int ret; 899 900 ret = f2fs_convert_inline_inode(inode); 901 if (ret) 902 return ret; 903 904 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT; 905 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT; 906 907 off_start = offset & (PAGE_SIZE - 1); 908 off_end = (offset + len) & (PAGE_SIZE - 1); 909 910 if (pg_start == pg_end) { 911 ret = fill_zero(inode, pg_start, off_start, 912 off_end - off_start); 913 if (ret) 914 return ret; 915 } else { 916 if (off_start) { 917 ret = fill_zero(inode, pg_start++, off_start, 918 PAGE_SIZE - off_start); 919 if (ret) 920 return ret; 921 } 922 if (off_end) { 923 ret = fill_zero(inode, pg_end, 0, off_end); 924 if (ret) 925 return ret; 926 } 927 928 if (pg_start < pg_end) { 929 struct address_space *mapping = inode->i_mapping; 930 loff_t blk_start, blk_end; 931 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 932 933 f2fs_balance_fs(sbi, true); 934 935 blk_start = (loff_t)pg_start << PAGE_SHIFT; 936 blk_end = (loff_t)pg_end << PAGE_SHIFT; 937 down_write(&F2FS_I(inode)->i_mmap_sem); 938 truncate_inode_pages_range(mapping, blk_start, 939 blk_end - 1); 940 941 f2fs_lock_op(sbi); 942 ret = truncate_hole(inode, pg_start, pg_end); 943 f2fs_unlock_op(sbi); 944 up_write(&F2FS_I(inode)->i_mmap_sem); 945 } 946 } 947 948 return ret; 949 } 950 951 static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr, 952 int *do_replace, pgoff_t off, pgoff_t len) 953 { 954 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 955 struct dnode_of_data dn; 956 int ret, done, i; 957 958 next_dnode: 959 set_new_dnode(&dn, inode, NULL, NULL, 0); 960 ret = get_dnode_of_data(&dn, off, LOOKUP_NODE_RA); 961 if (ret && ret != -ENOENT) { 962 return ret; 963 } else if (ret == -ENOENT) { 964 if (dn.max_level == 0) 965 return -ENOENT; 966 done = min((pgoff_t)ADDRS_PER_BLOCK - dn.ofs_in_node, len); 967 blkaddr += done; 968 do_replace += done; 969 goto next; 970 } 971 972 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) - 973 dn.ofs_in_node, len); 974 for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) { 975 *blkaddr = datablock_addr(dn.inode, 976 dn.node_page, dn.ofs_in_node); 977 if (!is_checkpointed_data(sbi, *blkaddr)) { 978 979 if (test_opt(sbi, LFS)) { 980 f2fs_put_dnode(&dn); 981 return -ENOTSUPP; 982 } 983 984 /* do not invalidate this block address */ 985 f2fs_update_data_blkaddr(&dn, NULL_ADDR); 986 *do_replace = 1; 987 } 988 } 989 f2fs_put_dnode(&dn); 990 next: 991 len -= done; 992 off += done; 993 if (len) 994 goto next_dnode; 995 return 0; 996 } 997 998 static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr, 999 int *do_replace, pgoff_t off, int len) 1000 { 1001 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1002 struct dnode_of_data dn; 1003 int ret, i; 1004 1005 for (i = 0; i < len; i++, do_replace++, blkaddr++) { 1006 if (*do_replace == 0) 1007 continue; 1008 1009 set_new_dnode(&dn, inode, NULL, NULL, 0); 1010 ret = get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA); 1011 if (ret) { 1012 dec_valid_block_count(sbi, inode, 1); 1013 invalidate_blocks(sbi, *blkaddr); 1014 } else { 1015 f2fs_update_data_blkaddr(&dn, *blkaddr); 1016 } 1017 f2fs_put_dnode(&dn); 1018 } 1019 return 0; 1020 } 1021 1022 static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode, 1023 block_t *blkaddr, int *do_replace, 1024 pgoff_t src, pgoff_t dst, pgoff_t len, bool full) 1025 { 1026 struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode); 1027 pgoff_t i = 0; 1028 int ret; 1029 1030 while (i < len) { 1031 if (blkaddr[i] == NULL_ADDR && !full) { 1032 i++; 1033 continue; 1034 } 1035 1036 if (do_replace[i] || blkaddr[i] == NULL_ADDR) { 1037 struct dnode_of_data dn; 1038 struct node_info ni; 1039 size_t new_size; 1040 pgoff_t ilen; 1041 1042 set_new_dnode(&dn, dst_inode, NULL, NULL, 0); 1043 ret = get_dnode_of_data(&dn, dst + i, ALLOC_NODE); 1044 if (ret) 1045 return ret; 1046 1047 get_node_info(sbi, dn.nid, &ni); 1048 ilen = min((pgoff_t) 1049 ADDRS_PER_PAGE(dn.node_page, dst_inode) - 1050 dn.ofs_in_node, len - i); 1051 do { 1052 dn.data_blkaddr = datablock_addr(dn.inode, 1053 dn.node_page, dn.ofs_in_node); 1054 truncate_data_blocks_range(&dn, 1); 1055 1056 if (do_replace[i]) { 1057 f2fs_i_blocks_write(src_inode, 1058 1, false, false); 1059 f2fs_i_blocks_write(dst_inode, 1060 1, true, false); 1061 f2fs_replace_block(sbi, &dn, dn.data_blkaddr, 1062 blkaddr[i], ni.version, true, false); 1063 1064 do_replace[i] = 0; 1065 } 1066 dn.ofs_in_node++; 1067 i++; 1068 new_size = (dst + i) << PAGE_SHIFT; 1069 if (dst_inode->i_size < new_size) 1070 f2fs_i_size_write(dst_inode, new_size); 1071 } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR)); 1072 1073 f2fs_put_dnode(&dn); 1074 } else { 1075 struct page *psrc, *pdst; 1076 1077 psrc = get_lock_data_page(src_inode, src + i, true); 1078 if (IS_ERR(psrc)) 1079 return PTR_ERR(psrc); 1080 pdst = get_new_data_page(dst_inode, NULL, dst + i, 1081 true); 1082 if (IS_ERR(pdst)) { 1083 f2fs_put_page(psrc, 1); 1084 return PTR_ERR(pdst); 1085 } 1086 f2fs_copy_page(psrc, pdst); 1087 set_page_dirty(pdst); 1088 f2fs_put_page(pdst, 1); 1089 f2fs_put_page(psrc, 1); 1090 1091 ret = truncate_hole(src_inode, src + i, src + i + 1); 1092 if (ret) 1093 return ret; 1094 i++; 1095 } 1096 } 1097 return 0; 1098 } 1099 1100 static int __exchange_data_block(struct inode *src_inode, 1101 struct inode *dst_inode, pgoff_t src, pgoff_t dst, 1102 pgoff_t len, bool full) 1103 { 1104 block_t *src_blkaddr; 1105 int *do_replace; 1106 pgoff_t olen; 1107 int ret; 1108 1109 while (len) { 1110 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len); 1111 1112 src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode), 1113 sizeof(block_t) * olen, GFP_KERNEL); 1114 if (!src_blkaddr) 1115 return -ENOMEM; 1116 1117 do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode), 1118 sizeof(int) * olen, GFP_KERNEL); 1119 if (!do_replace) { 1120 kvfree(src_blkaddr); 1121 return -ENOMEM; 1122 } 1123 1124 ret = __read_out_blkaddrs(src_inode, src_blkaddr, 1125 do_replace, src, olen); 1126 if (ret) 1127 goto roll_back; 1128 1129 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr, 1130 do_replace, src, dst, olen, full); 1131 if (ret) 1132 goto roll_back; 1133 1134 src += olen; 1135 dst += olen; 1136 len -= olen; 1137 1138 kvfree(src_blkaddr); 1139 kvfree(do_replace); 1140 } 1141 return 0; 1142 1143 roll_back: 1144 __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, len); 1145 kvfree(src_blkaddr); 1146 kvfree(do_replace); 1147 return ret; 1148 } 1149 1150 static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end) 1151 { 1152 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1153 pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE; 1154 int ret; 1155 1156 f2fs_balance_fs(sbi, true); 1157 f2fs_lock_op(sbi); 1158 1159 f2fs_drop_extent_tree(inode); 1160 1161 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true); 1162 f2fs_unlock_op(sbi); 1163 return ret; 1164 } 1165 1166 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len) 1167 { 1168 pgoff_t pg_start, pg_end; 1169 loff_t new_size; 1170 int ret; 1171 1172 if (offset + len >= i_size_read(inode)) 1173 return -EINVAL; 1174 1175 /* collapse range should be aligned to block size of f2fs. */ 1176 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) 1177 return -EINVAL; 1178 1179 ret = f2fs_convert_inline_inode(inode); 1180 if (ret) 1181 return ret; 1182 1183 pg_start = offset >> PAGE_SHIFT; 1184 pg_end = (offset + len) >> PAGE_SHIFT; 1185 1186 /* avoid gc operation during block exchange */ 1187 down_write(&F2FS_I(inode)->dio_rwsem[WRITE]); 1188 1189 down_write(&F2FS_I(inode)->i_mmap_sem); 1190 /* write out all dirty pages from offset */ 1191 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); 1192 if (ret) 1193 goto out_unlock; 1194 1195 truncate_pagecache(inode, offset); 1196 1197 ret = f2fs_do_collapse(inode, pg_start, pg_end); 1198 if (ret) 1199 goto out_unlock; 1200 1201 /* write out all moved pages, if possible */ 1202 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); 1203 truncate_pagecache(inode, offset); 1204 1205 new_size = i_size_read(inode) - len; 1206 truncate_pagecache(inode, new_size); 1207 1208 ret = truncate_blocks(inode, new_size, true); 1209 if (!ret) 1210 f2fs_i_size_write(inode, new_size); 1211 out_unlock: 1212 up_write(&F2FS_I(inode)->i_mmap_sem); 1213 up_write(&F2FS_I(inode)->dio_rwsem[WRITE]); 1214 return ret; 1215 } 1216 1217 static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start, 1218 pgoff_t end) 1219 { 1220 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); 1221 pgoff_t index = start; 1222 unsigned int ofs_in_node = dn->ofs_in_node; 1223 blkcnt_t count = 0; 1224 int ret; 1225 1226 for (; index < end; index++, dn->ofs_in_node++) { 1227 if (datablock_addr(dn->inode, dn->node_page, 1228 dn->ofs_in_node) == NULL_ADDR) 1229 count++; 1230 } 1231 1232 dn->ofs_in_node = ofs_in_node; 1233 ret = reserve_new_blocks(dn, count); 1234 if (ret) 1235 return ret; 1236 1237 dn->ofs_in_node = ofs_in_node; 1238 for (index = start; index < end; index++, dn->ofs_in_node++) { 1239 dn->data_blkaddr = datablock_addr(dn->inode, 1240 dn->node_page, dn->ofs_in_node); 1241 /* 1242 * reserve_new_blocks will not guarantee entire block 1243 * allocation. 1244 */ 1245 if (dn->data_blkaddr == NULL_ADDR) { 1246 ret = -ENOSPC; 1247 break; 1248 } 1249 if (dn->data_blkaddr != NEW_ADDR) { 1250 invalidate_blocks(sbi, dn->data_blkaddr); 1251 dn->data_blkaddr = NEW_ADDR; 1252 set_data_blkaddr(dn); 1253 } 1254 } 1255 1256 f2fs_update_extent_cache_range(dn, start, 0, index - start); 1257 1258 return ret; 1259 } 1260 1261 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len, 1262 int mode) 1263 { 1264 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1265 struct address_space *mapping = inode->i_mapping; 1266 pgoff_t index, pg_start, pg_end; 1267 loff_t new_size = i_size_read(inode); 1268 loff_t off_start, off_end; 1269 int ret = 0; 1270 1271 ret = inode_newsize_ok(inode, (len + offset)); 1272 if (ret) 1273 return ret; 1274 1275 ret = f2fs_convert_inline_inode(inode); 1276 if (ret) 1277 return ret; 1278 1279 down_write(&F2FS_I(inode)->i_mmap_sem); 1280 ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1); 1281 if (ret) 1282 goto out_sem; 1283 1284 truncate_pagecache_range(inode, offset, offset + len - 1); 1285 1286 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT; 1287 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT; 1288 1289 off_start = offset & (PAGE_SIZE - 1); 1290 off_end = (offset + len) & (PAGE_SIZE - 1); 1291 1292 if (pg_start == pg_end) { 1293 ret = fill_zero(inode, pg_start, off_start, 1294 off_end - off_start); 1295 if (ret) 1296 goto out_sem; 1297 1298 new_size = max_t(loff_t, new_size, offset + len); 1299 } else { 1300 if (off_start) { 1301 ret = fill_zero(inode, pg_start++, off_start, 1302 PAGE_SIZE - off_start); 1303 if (ret) 1304 goto out_sem; 1305 1306 new_size = max_t(loff_t, new_size, 1307 (loff_t)pg_start << PAGE_SHIFT); 1308 } 1309 1310 for (index = pg_start; index < pg_end;) { 1311 struct dnode_of_data dn; 1312 unsigned int end_offset; 1313 pgoff_t end; 1314 1315 f2fs_lock_op(sbi); 1316 1317 set_new_dnode(&dn, inode, NULL, NULL, 0); 1318 ret = get_dnode_of_data(&dn, index, ALLOC_NODE); 1319 if (ret) { 1320 f2fs_unlock_op(sbi); 1321 goto out; 1322 } 1323 1324 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); 1325 end = min(pg_end, end_offset - dn.ofs_in_node + index); 1326 1327 ret = f2fs_do_zero_range(&dn, index, end); 1328 f2fs_put_dnode(&dn); 1329 f2fs_unlock_op(sbi); 1330 1331 f2fs_balance_fs(sbi, dn.node_changed); 1332 1333 if (ret) 1334 goto out; 1335 1336 index = end; 1337 new_size = max_t(loff_t, new_size, 1338 (loff_t)index << PAGE_SHIFT); 1339 } 1340 1341 if (off_end) { 1342 ret = fill_zero(inode, pg_end, 0, off_end); 1343 if (ret) 1344 goto out; 1345 1346 new_size = max_t(loff_t, new_size, offset + len); 1347 } 1348 } 1349 1350 out: 1351 if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) 1352 f2fs_i_size_write(inode, new_size); 1353 out_sem: 1354 up_write(&F2FS_I(inode)->i_mmap_sem); 1355 1356 return ret; 1357 } 1358 1359 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len) 1360 { 1361 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1362 pgoff_t nr, pg_start, pg_end, delta, idx; 1363 loff_t new_size; 1364 int ret = 0; 1365 1366 new_size = i_size_read(inode) + len; 1367 ret = inode_newsize_ok(inode, new_size); 1368 if (ret) 1369 return ret; 1370 1371 if (offset >= i_size_read(inode)) 1372 return -EINVAL; 1373 1374 /* insert range should be aligned to block size of f2fs. */ 1375 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) 1376 return -EINVAL; 1377 1378 ret = f2fs_convert_inline_inode(inode); 1379 if (ret) 1380 return ret; 1381 1382 f2fs_balance_fs(sbi, true); 1383 1384 /* avoid gc operation during block exchange */ 1385 down_write(&F2FS_I(inode)->dio_rwsem[WRITE]); 1386 1387 down_write(&F2FS_I(inode)->i_mmap_sem); 1388 ret = truncate_blocks(inode, i_size_read(inode), true); 1389 if (ret) 1390 goto out; 1391 1392 /* write out all dirty pages from offset */ 1393 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); 1394 if (ret) 1395 goto out; 1396 1397 truncate_pagecache(inode, offset); 1398 1399 pg_start = offset >> PAGE_SHIFT; 1400 pg_end = (offset + len) >> PAGE_SHIFT; 1401 delta = pg_end - pg_start; 1402 idx = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE; 1403 1404 while (!ret && idx > pg_start) { 1405 nr = idx - pg_start; 1406 if (nr > delta) 1407 nr = delta; 1408 idx -= nr; 1409 1410 f2fs_lock_op(sbi); 1411 f2fs_drop_extent_tree(inode); 1412 1413 ret = __exchange_data_block(inode, inode, idx, 1414 idx + delta, nr, false); 1415 f2fs_unlock_op(sbi); 1416 } 1417 1418 /* write out all moved pages, if possible */ 1419 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); 1420 truncate_pagecache(inode, offset); 1421 1422 if (!ret) 1423 f2fs_i_size_write(inode, new_size); 1424 out: 1425 up_write(&F2FS_I(inode)->i_mmap_sem); 1426 up_write(&F2FS_I(inode)->dio_rwsem[WRITE]); 1427 return ret; 1428 } 1429 1430 static int expand_inode_data(struct inode *inode, loff_t offset, 1431 loff_t len, int mode) 1432 { 1433 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1434 struct f2fs_map_blocks map = { .m_next_pgofs = NULL, 1435 .m_next_extent = NULL, .m_seg_type = NO_CHECK_TYPE }; 1436 pgoff_t pg_end; 1437 loff_t new_size = i_size_read(inode); 1438 loff_t off_end; 1439 int err; 1440 1441 err = inode_newsize_ok(inode, (len + offset)); 1442 if (err) 1443 return err; 1444 1445 err = f2fs_convert_inline_inode(inode); 1446 if (err) 1447 return err; 1448 1449 f2fs_balance_fs(sbi, true); 1450 1451 pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT; 1452 off_end = (offset + len) & (PAGE_SIZE - 1); 1453 1454 map.m_lblk = ((unsigned long long)offset) >> PAGE_SHIFT; 1455 map.m_len = pg_end - map.m_lblk; 1456 if (off_end) 1457 map.m_len++; 1458 1459 err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO); 1460 if (err) { 1461 pgoff_t last_off; 1462 1463 if (!map.m_len) 1464 return err; 1465 1466 last_off = map.m_lblk + map.m_len - 1; 1467 1468 /* update new size to the failed position */ 1469 new_size = (last_off == pg_end) ? offset + len: 1470 (loff_t)(last_off + 1) << PAGE_SHIFT; 1471 } else { 1472 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end; 1473 } 1474 1475 if (new_size > i_size_read(inode)) { 1476 if (mode & FALLOC_FL_KEEP_SIZE) 1477 file_set_keep_isize(inode); 1478 else 1479 f2fs_i_size_write(inode, new_size); 1480 } 1481 1482 return err; 1483 } 1484 1485 static long f2fs_fallocate(struct file *file, int mode, 1486 loff_t offset, loff_t len) 1487 { 1488 struct inode *inode = file_inode(file); 1489 long ret = 0; 1490 1491 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) 1492 return -EIO; 1493 1494 /* f2fs only support ->fallocate for regular file */ 1495 if (!S_ISREG(inode->i_mode)) 1496 return -EINVAL; 1497 1498 if (f2fs_encrypted_inode(inode) && 1499 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE))) 1500 return -EOPNOTSUPP; 1501 1502 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | 1503 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE | 1504 FALLOC_FL_INSERT_RANGE)) 1505 return -EOPNOTSUPP; 1506 1507 inode_lock(inode); 1508 1509 if (mode & FALLOC_FL_PUNCH_HOLE) { 1510 if (offset >= inode->i_size) 1511 goto out; 1512 1513 ret = punch_hole(inode, offset, len); 1514 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) { 1515 ret = f2fs_collapse_range(inode, offset, len); 1516 } else if (mode & FALLOC_FL_ZERO_RANGE) { 1517 ret = f2fs_zero_range(inode, offset, len, mode); 1518 } else if (mode & FALLOC_FL_INSERT_RANGE) { 1519 ret = f2fs_insert_range(inode, offset, len); 1520 } else { 1521 ret = expand_inode_data(inode, offset, len, mode); 1522 } 1523 1524 if (!ret) { 1525 inode->i_mtime = inode->i_ctime = current_time(inode); 1526 f2fs_mark_inode_dirty_sync(inode, false); 1527 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1528 } 1529 1530 out: 1531 inode_unlock(inode); 1532 1533 trace_f2fs_fallocate(inode, mode, offset, len, ret); 1534 return ret; 1535 } 1536 1537 static int f2fs_release_file(struct inode *inode, struct file *filp) 1538 { 1539 /* 1540 * f2fs_relase_file is called at every close calls. So we should 1541 * not drop any inmemory pages by close called by other process. 1542 */ 1543 if (!(filp->f_mode & FMODE_WRITE) || 1544 atomic_read(&inode->i_writecount) != 1) 1545 return 0; 1546 1547 /* some remained atomic pages should discarded */ 1548 if (f2fs_is_atomic_file(inode)) 1549 drop_inmem_pages(inode); 1550 if (f2fs_is_volatile_file(inode)) { 1551 clear_inode_flag(inode, FI_VOLATILE_FILE); 1552 stat_dec_volatile_write(inode); 1553 set_inode_flag(inode, FI_DROP_CACHE); 1554 filemap_fdatawrite(inode->i_mapping); 1555 clear_inode_flag(inode, FI_DROP_CACHE); 1556 } 1557 return 0; 1558 } 1559 1560 static int f2fs_file_flush(struct file *file, fl_owner_t id) 1561 { 1562 struct inode *inode = file_inode(file); 1563 1564 /* 1565 * If the process doing a transaction is crashed, we should do 1566 * roll-back. Otherwise, other reader/write can see corrupted database 1567 * until all the writers close its file. Since this should be done 1568 * before dropping file lock, it needs to do in ->flush. 1569 */ 1570 if (f2fs_is_atomic_file(inode) && 1571 F2FS_I(inode)->inmem_task == current) 1572 drop_inmem_pages(inode); 1573 return 0; 1574 } 1575 1576 static int f2fs_ioc_getflags(struct file *filp, unsigned long arg) 1577 { 1578 struct inode *inode = file_inode(filp); 1579 struct f2fs_inode_info *fi = F2FS_I(inode); 1580 unsigned int flags = fi->i_flags & 1581 (FS_FL_USER_VISIBLE | FS_PROJINHERIT_FL); 1582 return put_user(flags, (int __user *)arg); 1583 } 1584 1585 static int __f2fs_ioc_setflags(struct inode *inode, unsigned int flags) 1586 { 1587 struct f2fs_inode_info *fi = F2FS_I(inode); 1588 unsigned int oldflags; 1589 1590 /* Is it quota file? Do not allow user to mess with it */ 1591 if (IS_NOQUOTA(inode)) 1592 return -EPERM; 1593 1594 flags = f2fs_mask_flags(inode->i_mode, flags); 1595 1596 oldflags = fi->i_flags; 1597 1598 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) 1599 if (!capable(CAP_LINUX_IMMUTABLE)) 1600 return -EPERM; 1601 1602 flags = flags & (FS_FL_USER_MODIFIABLE | FS_PROJINHERIT_FL); 1603 flags |= oldflags & ~(FS_FL_USER_MODIFIABLE | FS_PROJINHERIT_FL); 1604 fi->i_flags = flags; 1605 1606 if (fi->i_flags & FS_PROJINHERIT_FL) 1607 set_inode_flag(inode, FI_PROJ_INHERIT); 1608 else 1609 clear_inode_flag(inode, FI_PROJ_INHERIT); 1610 1611 inode->i_ctime = current_time(inode); 1612 f2fs_set_inode_flags(inode); 1613 f2fs_mark_inode_dirty_sync(inode, false); 1614 return 0; 1615 } 1616 1617 static int f2fs_ioc_setflags(struct file *filp, unsigned long arg) 1618 { 1619 struct inode *inode = file_inode(filp); 1620 unsigned int flags; 1621 int ret; 1622 1623 if (!inode_owner_or_capable(inode)) 1624 return -EACCES; 1625 1626 if (get_user(flags, (int __user *)arg)) 1627 return -EFAULT; 1628 1629 ret = mnt_want_write_file(filp); 1630 if (ret) 1631 return ret; 1632 1633 inode_lock(inode); 1634 1635 ret = __f2fs_ioc_setflags(inode, flags); 1636 1637 inode_unlock(inode); 1638 mnt_drop_write_file(filp); 1639 return ret; 1640 } 1641 1642 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg) 1643 { 1644 struct inode *inode = file_inode(filp); 1645 1646 return put_user(inode->i_generation, (int __user *)arg); 1647 } 1648 1649 static int f2fs_ioc_start_atomic_write(struct file *filp) 1650 { 1651 struct inode *inode = file_inode(filp); 1652 int ret; 1653 1654 if (!inode_owner_or_capable(inode)) 1655 return -EACCES; 1656 1657 if (!S_ISREG(inode->i_mode)) 1658 return -EINVAL; 1659 1660 ret = mnt_want_write_file(filp); 1661 if (ret) 1662 return ret; 1663 1664 inode_lock(inode); 1665 1666 if (f2fs_is_atomic_file(inode)) 1667 goto out; 1668 1669 ret = f2fs_convert_inline_inode(inode); 1670 if (ret) 1671 goto out; 1672 1673 set_inode_flag(inode, FI_ATOMIC_FILE); 1674 set_inode_flag(inode, FI_HOT_DATA); 1675 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1676 1677 if (!get_dirty_pages(inode)) 1678 goto inc_stat; 1679 1680 f2fs_msg(F2FS_I_SB(inode)->sb, KERN_WARNING, 1681 "Unexpected flush for atomic writes: ino=%lu, npages=%u", 1682 inode->i_ino, get_dirty_pages(inode)); 1683 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); 1684 if (ret) { 1685 clear_inode_flag(inode, FI_ATOMIC_FILE); 1686 clear_inode_flag(inode, FI_HOT_DATA); 1687 goto out; 1688 } 1689 1690 inc_stat: 1691 F2FS_I(inode)->inmem_task = current; 1692 stat_inc_atomic_write(inode); 1693 stat_update_max_atomic_write(inode); 1694 out: 1695 inode_unlock(inode); 1696 mnt_drop_write_file(filp); 1697 return ret; 1698 } 1699 1700 static int f2fs_ioc_commit_atomic_write(struct file *filp) 1701 { 1702 struct inode *inode = file_inode(filp); 1703 int ret; 1704 1705 if (!inode_owner_or_capable(inode)) 1706 return -EACCES; 1707 1708 ret = mnt_want_write_file(filp); 1709 if (ret) 1710 return ret; 1711 1712 inode_lock(inode); 1713 1714 if (f2fs_is_volatile_file(inode)) 1715 goto err_out; 1716 1717 if (f2fs_is_atomic_file(inode)) { 1718 ret = commit_inmem_pages(inode); 1719 if (ret) 1720 goto err_out; 1721 1722 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true); 1723 if (!ret) { 1724 clear_inode_flag(inode, FI_ATOMIC_FILE); 1725 clear_inode_flag(inode, FI_HOT_DATA); 1726 stat_dec_atomic_write(inode); 1727 } 1728 } else { 1729 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false); 1730 } 1731 err_out: 1732 inode_unlock(inode); 1733 mnt_drop_write_file(filp); 1734 return ret; 1735 } 1736 1737 static int f2fs_ioc_start_volatile_write(struct file *filp) 1738 { 1739 struct inode *inode = file_inode(filp); 1740 int ret; 1741 1742 if (!inode_owner_or_capable(inode)) 1743 return -EACCES; 1744 1745 if (!S_ISREG(inode->i_mode)) 1746 return -EINVAL; 1747 1748 ret = mnt_want_write_file(filp); 1749 if (ret) 1750 return ret; 1751 1752 inode_lock(inode); 1753 1754 if (f2fs_is_volatile_file(inode)) 1755 goto out; 1756 1757 ret = f2fs_convert_inline_inode(inode); 1758 if (ret) 1759 goto out; 1760 1761 stat_inc_volatile_write(inode); 1762 stat_update_max_volatile_write(inode); 1763 1764 set_inode_flag(inode, FI_VOLATILE_FILE); 1765 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1766 out: 1767 inode_unlock(inode); 1768 mnt_drop_write_file(filp); 1769 return ret; 1770 } 1771 1772 static int f2fs_ioc_release_volatile_write(struct file *filp) 1773 { 1774 struct inode *inode = file_inode(filp); 1775 int ret; 1776 1777 if (!inode_owner_or_capable(inode)) 1778 return -EACCES; 1779 1780 ret = mnt_want_write_file(filp); 1781 if (ret) 1782 return ret; 1783 1784 inode_lock(inode); 1785 1786 if (!f2fs_is_volatile_file(inode)) 1787 goto out; 1788 1789 if (!f2fs_is_first_block_written(inode)) { 1790 ret = truncate_partial_data_page(inode, 0, true); 1791 goto out; 1792 } 1793 1794 ret = punch_hole(inode, 0, F2FS_BLKSIZE); 1795 out: 1796 inode_unlock(inode); 1797 mnt_drop_write_file(filp); 1798 return ret; 1799 } 1800 1801 static int f2fs_ioc_abort_volatile_write(struct file *filp) 1802 { 1803 struct inode *inode = file_inode(filp); 1804 int ret; 1805 1806 if (!inode_owner_or_capable(inode)) 1807 return -EACCES; 1808 1809 ret = mnt_want_write_file(filp); 1810 if (ret) 1811 return ret; 1812 1813 inode_lock(inode); 1814 1815 if (f2fs_is_atomic_file(inode)) 1816 drop_inmem_pages(inode); 1817 if (f2fs_is_volatile_file(inode)) { 1818 clear_inode_flag(inode, FI_VOLATILE_FILE); 1819 stat_dec_volatile_write(inode); 1820 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true); 1821 } 1822 1823 inode_unlock(inode); 1824 1825 mnt_drop_write_file(filp); 1826 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1827 return ret; 1828 } 1829 1830 static int f2fs_ioc_shutdown(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 struct super_block *sb = sbi->sb; 1835 __u32 in; 1836 int ret; 1837 1838 if (!capable(CAP_SYS_ADMIN)) 1839 return -EPERM; 1840 1841 if (get_user(in, (__u32 __user *)arg)) 1842 return -EFAULT; 1843 1844 ret = mnt_want_write_file(filp); 1845 if (ret) 1846 return ret; 1847 1848 switch (in) { 1849 case F2FS_GOING_DOWN_FULLSYNC: 1850 sb = freeze_bdev(sb->s_bdev); 1851 if (IS_ERR(sb)) { 1852 ret = PTR_ERR(sb); 1853 goto out; 1854 } 1855 if (sb) { 1856 f2fs_stop_checkpoint(sbi, false); 1857 thaw_bdev(sb->s_bdev, sb); 1858 } 1859 break; 1860 case F2FS_GOING_DOWN_METASYNC: 1861 /* do checkpoint only */ 1862 ret = f2fs_sync_fs(sb, 1); 1863 if (ret) 1864 goto out; 1865 f2fs_stop_checkpoint(sbi, false); 1866 break; 1867 case F2FS_GOING_DOWN_NOSYNC: 1868 f2fs_stop_checkpoint(sbi, false); 1869 break; 1870 case F2FS_GOING_DOWN_METAFLUSH: 1871 sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO); 1872 f2fs_stop_checkpoint(sbi, false); 1873 break; 1874 default: 1875 ret = -EINVAL; 1876 goto out; 1877 } 1878 1879 stop_gc_thread(sbi); 1880 stop_discard_thread(sbi); 1881 1882 drop_discard_cmd(sbi); 1883 clear_opt(sbi, DISCARD); 1884 1885 f2fs_update_time(sbi, REQ_TIME); 1886 out: 1887 mnt_drop_write_file(filp); 1888 return ret; 1889 } 1890 1891 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg) 1892 { 1893 struct inode *inode = file_inode(filp); 1894 struct super_block *sb = inode->i_sb; 1895 struct request_queue *q = bdev_get_queue(sb->s_bdev); 1896 struct fstrim_range range; 1897 int ret; 1898 1899 if (!capable(CAP_SYS_ADMIN)) 1900 return -EPERM; 1901 1902 if (!blk_queue_discard(q)) 1903 return -EOPNOTSUPP; 1904 1905 if (copy_from_user(&range, (struct fstrim_range __user *)arg, 1906 sizeof(range))) 1907 return -EFAULT; 1908 1909 ret = mnt_want_write_file(filp); 1910 if (ret) 1911 return ret; 1912 1913 range.minlen = max((unsigned int)range.minlen, 1914 q->limits.discard_granularity); 1915 ret = f2fs_trim_fs(F2FS_SB(sb), &range); 1916 mnt_drop_write_file(filp); 1917 if (ret < 0) 1918 return ret; 1919 1920 if (copy_to_user((struct fstrim_range __user *)arg, &range, 1921 sizeof(range))) 1922 return -EFAULT; 1923 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1924 return 0; 1925 } 1926 1927 static bool uuid_is_nonzero(__u8 u[16]) 1928 { 1929 int i; 1930 1931 for (i = 0; i < 16; i++) 1932 if (u[i]) 1933 return true; 1934 return false; 1935 } 1936 1937 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg) 1938 { 1939 struct inode *inode = file_inode(filp); 1940 1941 if (!f2fs_sb_has_crypto(inode->i_sb)) 1942 return -EOPNOTSUPP; 1943 1944 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1945 1946 return fscrypt_ioctl_set_policy(filp, (const void __user *)arg); 1947 } 1948 1949 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg) 1950 { 1951 if (!f2fs_sb_has_crypto(file_inode(filp)->i_sb)) 1952 return -EOPNOTSUPP; 1953 return fscrypt_ioctl_get_policy(filp, (void __user *)arg); 1954 } 1955 1956 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg) 1957 { 1958 struct inode *inode = file_inode(filp); 1959 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1960 int err; 1961 1962 if (!f2fs_sb_has_crypto(inode->i_sb)) 1963 return -EOPNOTSUPP; 1964 1965 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt)) 1966 goto got_it; 1967 1968 err = mnt_want_write_file(filp); 1969 if (err) 1970 return err; 1971 1972 /* update superblock with uuid */ 1973 generate_random_uuid(sbi->raw_super->encrypt_pw_salt); 1974 1975 err = f2fs_commit_super(sbi, false); 1976 if (err) { 1977 /* undo new data */ 1978 memset(sbi->raw_super->encrypt_pw_salt, 0, 16); 1979 mnt_drop_write_file(filp); 1980 return err; 1981 } 1982 mnt_drop_write_file(filp); 1983 got_it: 1984 if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt, 1985 16)) 1986 return -EFAULT; 1987 return 0; 1988 } 1989 1990 static int f2fs_ioc_gc(struct file *filp, unsigned long arg) 1991 { 1992 struct inode *inode = file_inode(filp); 1993 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1994 __u32 sync; 1995 int ret; 1996 1997 if (!capable(CAP_SYS_ADMIN)) 1998 return -EPERM; 1999 2000 if (get_user(sync, (__u32 __user *)arg)) 2001 return -EFAULT; 2002 2003 if (f2fs_readonly(sbi->sb)) 2004 return -EROFS; 2005 2006 ret = mnt_want_write_file(filp); 2007 if (ret) 2008 return ret; 2009 2010 if (!sync) { 2011 if (!mutex_trylock(&sbi->gc_mutex)) { 2012 ret = -EBUSY; 2013 goto out; 2014 } 2015 } else { 2016 mutex_lock(&sbi->gc_mutex); 2017 } 2018 2019 ret = f2fs_gc(sbi, sync, true, NULL_SEGNO); 2020 out: 2021 mnt_drop_write_file(filp); 2022 return ret; 2023 } 2024 2025 static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg) 2026 { 2027 struct inode *inode = file_inode(filp); 2028 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2029 struct f2fs_gc_range range; 2030 u64 end; 2031 int ret; 2032 2033 if (!capable(CAP_SYS_ADMIN)) 2034 return -EPERM; 2035 2036 if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg, 2037 sizeof(range))) 2038 return -EFAULT; 2039 2040 if (f2fs_readonly(sbi->sb)) 2041 return -EROFS; 2042 2043 ret = mnt_want_write_file(filp); 2044 if (ret) 2045 return ret; 2046 2047 end = range.start + range.len; 2048 if (range.start < MAIN_BLKADDR(sbi) || end >= MAX_BLKADDR(sbi)) 2049 return -EINVAL; 2050 do_more: 2051 if (!range.sync) { 2052 if (!mutex_trylock(&sbi->gc_mutex)) { 2053 ret = -EBUSY; 2054 goto out; 2055 } 2056 } else { 2057 mutex_lock(&sbi->gc_mutex); 2058 } 2059 2060 ret = f2fs_gc(sbi, range.sync, true, GET_SEGNO(sbi, range.start)); 2061 range.start += sbi->blocks_per_seg; 2062 if (range.start <= end) 2063 goto do_more; 2064 out: 2065 mnt_drop_write_file(filp); 2066 return ret; 2067 } 2068 2069 static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg) 2070 { 2071 struct inode *inode = file_inode(filp); 2072 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2073 int ret; 2074 2075 if (!capable(CAP_SYS_ADMIN)) 2076 return -EPERM; 2077 2078 if (f2fs_readonly(sbi->sb)) 2079 return -EROFS; 2080 2081 ret = mnt_want_write_file(filp); 2082 if (ret) 2083 return ret; 2084 2085 ret = f2fs_sync_fs(sbi->sb, 1); 2086 2087 mnt_drop_write_file(filp); 2088 return ret; 2089 } 2090 2091 static int f2fs_defragment_range(struct f2fs_sb_info *sbi, 2092 struct file *filp, 2093 struct f2fs_defragment *range) 2094 { 2095 struct inode *inode = file_inode(filp); 2096 struct f2fs_map_blocks map = { .m_next_extent = NULL, 2097 .m_seg_type = NO_CHECK_TYPE }; 2098 struct extent_info ei = {0,0,0}; 2099 pgoff_t pg_start, pg_end, next_pgofs; 2100 unsigned int blk_per_seg = sbi->blocks_per_seg; 2101 unsigned int total = 0, sec_num; 2102 block_t blk_end = 0; 2103 bool fragmented = false; 2104 int err; 2105 2106 /* if in-place-update policy is enabled, don't waste time here */ 2107 if (should_update_inplace(inode, NULL)) 2108 return -EINVAL; 2109 2110 pg_start = range->start >> PAGE_SHIFT; 2111 pg_end = (range->start + range->len) >> PAGE_SHIFT; 2112 2113 f2fs_balance_fs(sbi, true); 2114 2115 inode_lock(inode); 2116 2117 /* writeback all dirty pages in the range */ 2118 err = filemap_write_and_wait_range(inode->i_mapping, range->start, 2119 range->start + range->len - 1); 2120 if (err) 2121 goto out; 2122 2123 /* 2124 * lookup mapping info in extent cache, skip defragmenting if physical 2125 * block addresses are continuous. 2126 */ 2127 if (f2fs_lookup_extent_cache(inode, pg_start, &ei)) { 2128 if (ei.fofs + ei.len >= pg_end) 2129 goto out; 2130 } 2131 2132 map.m_lblk = pg_start; 2133 map.m_next_pgofs = &next_pgofs; 2134 2135 /* 2136 * lookup mapping info in dnode page cache, skip defragmenting if all 2137 * physical block addresses are continuous even if there are hole(s) 2138 * in logical blocks. 2139 */ 2140 while (map.m_lblk < pg_end) { 2141 map.m_len = pg_end - map.m_lblk; 2142 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT); 2143 if (err) 2144 goto out; 2145 2146 if (!(map.m_flags & F2FS_MAP_FLAGS)) { 2147 map.m_lblk = next_pgofs; 2148 continue; 2149 } 2150 2151 if (blk_end && blk_end != map.m_pblk) 2152 fragmented = true; 2153 2154 /* record total count of block that we're going to move */ 2155 total += map.m_len; 2156 2157 blk_end = map.m_pblk + map.m_len; 2158 2159 map.m_lblk += map.m_len; 2160 } 2161 2162 if (!fragmented) 2163 goto out; 2164 2165 sec_num = (total + BLKS_PER_SEC(sbi) - 1) / BLKS_PER_SEC(sbi); 2166 2167 /* 2168 * make sure there are enough free section for LFS allocation, this can 2169 * avoid defragment running in SSR mode when free section are allocated 2170 * intensively 2171 */ 2172 if (has_not_enough_free_secs(sbi, 0, sec_num)) { 2173 err = -EAGAIN; 2174 goto out; 2175 } 2176 2177 map.m_lblk = pg_start; 2178 map.m_len = pg_end - pg_start; 2179 total = 0; 2180 2181 while (map.m_lblk < pg_end) { 2182 pgoff_t idx; 2183 int cnt = 0; 2184 2185 do_map: 2186 map.m_len = pg_end - map.m_lblk; 2187 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT); 2188 if (err) 2189 goto clear_out; 2190 2191 if (!(map.m_flags & F2FS_MAP_FLAGS)) { 2192 map.m_lblk = next_pgofs; 2193 continue; 2194 } 2195 2196 set_inode_flag(inode, FI_DO_DEFRAG); 2197 2198 idx = map.m_lblk; 2199 while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) { 2200 struct page *page; 2201 2202 page = get_lock_data_page(inode, idx, true); 2203 if (IS_ERR(page)) { 2204 err = PTR_ERR(page); 2205 goto clear_out; 2206 } 2207 2208 set_page_dirty(page); 2209 f2fs_put_page(page, 1); 2210 2211 idx++; 2212 cnt++; 2213 total++; 2214 } 2215 2216 map.m_lblk = idx; 2217 2218 if (idx < pg_end && cnt < blk_per_seg) 2219 goto do_map; 2220 2221 clear_inode_flag(inode, FI_DO_DEFRAG); 2222 2223 err = filemap_fdatawrite(inode->i_mapping); 2224 if (err) 2225 goto out; 2226 } 2227 clear_out: 2228 clear_inode_flag(inode, FI_DO_DEFRAG); 2229 out: 2230 inode_unlock(inode); 2231 if (!err) 2232 range->len = (u64)total << PAGE_SHIFT; 2233 return err; 2234 } 2235 2236 static int f2fs_ioc_defragment(struct file *filp, unsigned long arg) 2237 { 2238 struct inode *inode = file_inode(filp); 2239 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2240 struct f2fs_defragment range; 2241 int err; 2242 2243 if (!capable(CAP_SYS_ADMIN)) 2244 return -EPERM; 2245 2246 if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode)) 2247 return -EINVAL; 2248 2249 if (f2fs_readonly(sbi->sb)) 2250 return -EROFS; 2251 2252 if (copy_from_user(&range, (struct f2fs_defragment __user *)arg, 2253 sizeof(range))) 2254 return -EFAULT; 2255 2256 /* verify alignment of offset & size */ 2257 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1)) 2258 return -EINVAL; 2259 2260 if (unlikely((range.start + range.len) >> PAGE_SHIFT > 2261 sbi->max_file_blocks)) 2262 return -EINVAL; 2263 2264 err = mnt_want_write_file(filp); 2265 if (err) 2266 return err; 2267 2268 err = f2fs_defragment_range(sbi, filp, &range); 2269 mnt_drop_write_file(filp); 2270 2271 f2fs_update_time(sbi, REQ_TIME); 2272 if (err < 0) 2273 return err; 2274 2275 if (copy_to_user((struct f2fs_defragment __user *)arg, &range, 2276 sizeof(range))) 2277 return -EFAULT; 2278 2279 return 0; 2280 } 2281 2282 static int f2fs_move_file_range(struct file *file_in, loff_t pos_in, 2283 struct file *file_out, loff_t pos_out, size_t len) 2284 { 2285 struct inode *src = file_inode(file_in); 2286 struct inode *dst = file_inode(file_out); 2287 struct f2fs_sb_info *sbi = F2FS_I_SB(src); 2288 size_t olen = len, dst_max_i_size = 0; 2289 size_t dst_osize; 2290 int ret; 2291 2292 if (file_in->f_path.mnt != file_out->f_path.mnt || 2293 src->i_sb != dst->i_sb) 2294 return -EXDEV; 2295 2296 if (unlikely(f2fs_readonly(src->i_sb))) 2297 return -EROFS; 2298 2299 if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode)) 2300 return -EINVAL; 2301 2302 if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst)) 2303 return -EOPNOTSUPP; 2304 2305 if (src == dst) { 2306 if (pos_in == pos_out) 2307 return 0; 2308 if (pos_out > pos_in && pos_out < pos_in + len) 2309 return -EINVAL; 2310 } 2311 2312 inode_lock(src); 2313 down_write(&F2FS_I(src)->dio_rwsem[WRITE]); 2314 if (src != dst) { 2315 ret = -EBUSY; 2316 if (!inode_trylock(dst)) 2317 goto out; 2318 if (!down_write_trylock(&F2FS_I(dst)->dio_rwsem[WRITE])) { 2319 inode_unlock(dst); 2320 goto out; 2321 } 2322 } 2323 2324 ret = -EINVAL; 2325 if (pos_in + len > src->i_size || pos_in + len < pos_in) 2326 goto out_unlock; 2327 if (len == 0) 2328 olen = len = src->i_size - pos_in; 2329 if (pos_in + len == src->i_size) 2330 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in; 2331 if (len == 0) { 2332 ret = 0; 2333 goto out_unlock; 2334 } 2335 2336 dst_osize = dst->i_size; 2337 if (pos_out + olen > dst->i_size) 2338 dst_max_i_size = pos_out + olen; 2339 2340 /* verify the end result is block aligned */ 2341 if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) || 2342 !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) || 2343 !IS_ALIGNED(pos_out, F2FS_BLKSIZE)) 2344 goto out_unlock; 2345 2346 ret = f2fs_convert_inline_inode(src); 2347 if (ret) 2348 goto out_unlock; 2349 2350 ret = f2fs_convert_inline_inode(dst); 2351 if (ret) 2352 goto out_unlock; 2353 2354 /* write out all dirty pages from offset */ 2355 ret = filemap_write_and_wait_range(src->i_mapping, 2356 pos_in, pos_in + len); 2357 if (ret) 2358 goto out_unlock; 2359 2360 ret = filemap_write_and_wait_range(dst->i_mapping, 2361 pos_out, pos_out + len); 2362 if (ret) 2363 goto out_unlock; 2364 2365 f2fs_balance_fs(sbi, true); 2366 f2fs_lock_op(sbi); 2367 ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS, 2368 pos_out >> F2FS_BLKSIZE_BITS, 2369 len >> F2FS_BLKSIZE_BITS, false); 2370 2371 if (!ret) { 2372 if (dst_max_i_size) 2373 f2fs_i_size_write(dst, dst_max_i_size); 2374 else if (dst_osize != dst->i_size) 2375 f2fs_i_size_write(dst, dst_osize); 2376 } 2377 f2fs_unlock_op(sbi); 2378 out_unlock: 2379 if (src != dst) { 2380 up_write(&F2FS_I(dst)->dio_rwsem[WRITE]); 2381 inode_unlock(dst); 2382 } 2383 out: 2384 up_write(&F2FS_I(src)->dio_rwsem[WRITE]); 2385 inode_unlock(src); 2386 return ret; 2387 } 2388 2389 static int f2fs_ioc_move_range(struct file *filp, unsigned long arg) 2390 { 2391 struct f2fs_move_range range; 2392 struct fd dst; 2393 int err; 2394 2395 if (!(filp->f_mode & FMODE_READ) || 2396 !(filp->f_mode & FMODE_WRITE)) 2397 return -EBADF; 2398 2399 if (copy_from_user(&range, (struct f2fs_move_range __user *)arg, 2400 sizeof(range))) 2401 return -EFAULT; 2402 2403 dst = fdget(range.dst_fd); 2404 if (!dst.file) 2405 return -EBADF; 2406 2407 if (!(dst.file->f_mode & FMODE_WRITE)) { 2408 err = -EBADF; 2409 goto err_out; 2410 } 2411 2412 err = mnt_want_write_file(filp); 2413 if (err) 2414 goto err_out; 2415 2416 err = f2fs_move_file_range(filp, range.pos_in, dst.file, 2417 range.pos_out, range.len); 2418 2419 mnt_drop_write_file(filp); 2420 if (err) 2421 goto err_out; 2422 2423 if (copy_to_user((struct f2fs_move_range __user *)arg, 2424 &range, sizeof(range))) 2425 err = -EFAULT; 2426 err_out: 2427 fdput(dst); 2428 return err; 2429 } 2430 2431 static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg) 2432 { 2433 struct inode *inode = file_inode(filp); 2434 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2435 struct sit_info *sm = SIT_I(sbi); 2436 unsigned int start_segno = 0, end_segno = 0; 2437 unsigned int dev_start_segno = 0, dev_end_segno = 0; 2438 struct f2fs_flush_device range; 2439 int ret; 2440 2441 if (!capable(CAP_SYS_ADMIN)) 2442 return -EPERM; 2443 2444 if (f2fs_readonly(sbi->sb)) 2445 return -EROFS; 2446 2447 if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg, 2448 sizeof(range))) 2449 return -EFAULT; 2450 2451 if (sbi->s_ndevs <= 1 || sbi->s_ndevs - 1 <= range.dev_num || 2452 sbi->segs_per_sec != 1) { 2453 f2fs_msg(sbi->sb, KERN_WARNING, 2454 "Can't flush %u in %d for segs_per_sec %u != 1\n", 2455 range.dev_num, sbi->s_ndevs, 2456 sbi->segs_per_sec); 2457 return -EINVAL; 2458 } 2459 2460 ret = mnt_want_write_file(filp); 2461 if (ret) 2462 return ret; 2463 2464 if (range.dev_num != 0) 2465 dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk); 2466 dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk); 2467 2468 start_segno = sm->last_victim[FLUSH_DEVICE]; 2469 if (start_segno < dev_start_segno || start_segno >= dev_end_segno) 2470 start_segno = dev_start_segno; 2471 end_segno = min(start_segno + range.segments, dev_end_segno); 2472 2473 while (start_segno < end_segno) { 2474 if (!mutex_trylock(&sbi->gc_mutex)) { 2475 ret = -EBUSY; 2476 goto out; 2477 } 2478 sm->last_victim[GC_CB] = end_segno + 1; 2479 sm->last_victim[GC_GREEDY] = end_segno + 1; 2480 sm->last_victim[ALLOC_NEXT] = end_segno + 1; 2481 ret = f2fs_gc(sbi, true, true, start_segno); 2482 if (ret == -EAGAIN) 2483 ret = 0; 2484 else if (ret < 0) 2485 break; 2486 start_segno++; 2487 } 2488 out: 2489 mnt_drop_write_file(filp); 2490 return ret; 2491 } 2492 2493 static int f2fs_ioc_get_features(struct file *filp, unsigned long arg) 2494 { 2495 struct inode *inode = file_inode(filp); 2496 u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature); 2497 2498 /* Must validate to set it with SQLite behavior in Android. */ 2499 sb_feature |= F2FS_FEATURE_ATOMIC_WRITE; 2500 2501 return put_user(sb_feature, (u32 __user *)arg); 2502 } 2503 2504 #ifdef CONFIG_QUOTA 2505 static int f2fs_ioc_setproject(struct file *filp, __u32 projid) 2506 { 2507 struct inode *inode = file_inode(filp); 2508 struct f2fs_inode_info *fi = F2FS_I(inode); 2509 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2510 struct super_block *sb = sbi->sb; 2511 struct dquot *transfer_to[MAXQUOTAS] = {}; 2512 struct page *ipage; 2513 kprojid_t kprojid; 2514 int err; 2515 2516 if (!f2fs_sb_has_project_quota(sb)) { 2517 if (projid != F2FS_DEF_PROJID) 2518 return -EOPNOTSUPP; 2519 else 2520 return 0; 2521 } 2522 2523 if (!f2fs_has_extra_attr(inode)) 2524 return -EOPNOTSUPP; 2525 2526 kprojid = make_kprojid(&init_user_ns, (projid_t)projid); 2527 2528 if (projid_eq(kprojid, F2FS_I(inode)->i_projid)) 2529 return 0; 2530 2531 err = mnt_want_write_file(filp); 2532 if (err) 2533 return err; 2534 2535 err = -EPERM; 2536 inode_lock(inode); 2537 2538 /* Is it quota file? Do not allow user to mess with it */ 2539 if (IS_NOQUOTA(inode)) 2540 goto out_unlock; 2541 2542 ipage = get_node_page(sbi, inode->i_ino); 2543 if (IS_ERR(ipage)) { 2544 err = PTR_ERR(ipage); 2545 goto out_unlock; 2546 } 2547 2548 if (!F2FS_FITS_IN_INODE(F2FS_INODE(ipage), fi->i_extra_isize, 2549 i_projid)) { 2550 err = -EOVERFLOW; 2551 f2fs_put_page(ipage, 1); 2552 goto out_unlock; 2553 } 2554 f2fs_put_page(ipage, 1); 2555 2556 dquot_initialize(inode); 2557 2558 transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid)); 2559 if (!IS_ERR(transfer_to[PRJQUOTA])) { 2560 err = __dquot_transfer(inode, transfer_to); 2561 dqput(transfer_to[PRJQUOTA]); 2562 if (err) 2563 goto out_dirty; 2564 } 2565 2566 F2FS_I(inode)->i_projid = kprojid; 2567 inode->i_ctime = current_time(inode); 2568 out_dirty: 2569 f2fs_mark_inode_dirty_sync(inode, true); 2570 out_unlock: 2571 inode_unlock(inode); 2572 mnt_drop_write_file(filp); 2573 return err; 2574 } 2575 #else 2576 static int f2fs_ioc_setproject(struct file *filp, __u32 projid) 2577 { 2578 if (projid != F2FS_DEF_PROJID) 2579 return -EOPNOTSUPP; 2580 return 0; 2581 } 2582 #endif 2583 2584 /* Transfer internal flags to xflags */ 2585 static inline __u32 f2fs_iflags_to_xflags(unsigned long iflags) 2586 { 2587 __u32 xflags = 0; 2588 2589 if (iflags & FS_SYNC_FL) 2590 xflags |= FS_XFLAG_SYNC; 2591 if (iflags & FS_IMMUTABLE_FL) 2592 xflags |= FS_XFLAG_IMMUTABLE; 2593 if (iflags & FS_APPEND_FL) 2594 xflags |= FS_XFLAG_APPEND; 2595 if (iflags & FS_NODUMP_FL) 2596 xflags |= FS_XFLAG_NODUMP; 2597 if (iflags & FS_NOATIME_FL) 2598 xflags |= FS_XFLAG_NOATIME; 2599 if (iflags & FS_PROJINHERIT_FL) 2600 xflags |= FS_XFLAG_PROJINHERIT; 2601 return xflags; 2602 } 2603 2604 #define F2FS_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \ 2605 FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \ 2606 FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT) 2607 2608 /* Flags we can manipulate with through EXT4_IOC_FSSETXATTR */ 2609 #define F2FS_FL_XFLAG_VISIBLE (FS_SYNC_FL | \ 2610 FS_IMMUTABLE_FL | \ 2611 FS_APPEND_FL | \ 2612 FS_NODUMP_FL | \ 2613 FS_NOATIME_FL | \ 2614 FS_PROJINHERIT_FL) 2615 2616 /* Transfer xflags flags to internal */ 2617 static inline unsigned long f2fs_xflags_to_iflags(__u32 xflags) 2618 { 2619 unsigned long iflags = 0; 2620 2621 if (xflags & FS_XFLAG_SYNC) 2622 iflags |= FS_SYNC_FL; 2623 if (xflags & FS_XFLAG_IMMUTABLE) 2624 iflags |= FS_IMMUTABLE_FL; 2625 if (xflags & FS_XFLAG_APPEND) 2626 iflags |= FS_APPEND_FL; 2627 if (xflags & FS_XFLAG_NODUMP) 2628 iflags |= FS_NODUMP_FL; 2629 if (xflags & FS_XFLAG_NOATIME) 2630 iflags |= FS_NOATIME_FL; 2631 if (xflags & FS_XFLAG_PROJINHERIT) 2632 iflags |= FS_PROJINHERIT_FL; 2633 2634 return iflags; 2635 } 2636 2637 static int f2fs_ioc_fsgetxattr(struct file *filp, unsigned long arg) 2638 { 2639 struct inode *inode = file_inode(filp); 2640 struct f2fs_inode_info *fi = F2FS_I(inode); 2641 struct fsxattr fa; 2642 2643 memset(&fa, 0, sizeof(struct fsxattr)); 2644 fa.fsx_xflags = f2fs_iflags_to_xflags(fi->i_flags & 2645 (FS_FL_USER_VISIBLE | FS_PROJINHERIT_FL)); 2646 2647 if (f2fs_sb_has_project_quota(inode->i_sb)) 2648 fa.fsx_projid = (__u32)from_kprojid(&init_user_ns, 2649 fi->i_projid); 2650 2651 if (copy_to_user((struct fsxattr __user *)arg, &fa, sizeof(fa))) 2652 return -EFAULT; 2653 return 0; 2654 } 2655 2656 static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg) 2657 { 2658 struct inode *inode = file_inode(filp); 2659 struct f2fs_inode_info *fi = F2FS_I(inode); 2660 struct fsxattr fa; 2661 unsigned int flags; 2662 int err; 2663 2664 if (copy_from_user(&fa, (struct fsxattr __user *)arg, sizeof(fa))) 2665 return -EFAULT; 2666 2667 /* Make sure caller has proper permission */ 2668 if (!inode_owner_or_capable(inode)) 2669 return -EACCES; 2670 2671 if (fa.fsx_xflags & ~F2FS_SUPPORTED_FS_XFLAGS) 2672 return -EOPNOTSUPP; 2673 2674 flags = f2fs_xflags_to_iflags(fa.fsx_xflags); 2675 if (f2fs_mask_flags(inode->i_mode, flags) != flags) 2676 return -EOPNOTSUPP; 2677 2678 err = mnt_want_write_file(filp); 2679 if (err) 2680 return err; 2681 2682 inode_lock(inode); 2683 flags = (fi->i_flags & ~F2FS_FL_XFLAG_VISIBLE) | 2684 (flags & F2FS_FL_XFLAG_VISIBLE); 2685 err = __f2fs_ioc_setflags(inode, flags); 2686 inode_unlock(inode); 2687 mnt_drop_write_file(filp); 2688 if (err) 2689 return err; 2690 2691 err = f2fs_ioc_setproject(filp, fa.fsx_projid); 2692 if (err) 2693 return err; 2694 2695 return 0; 2696 } 2697 2698 int f2fs_pin_file_control(struct inode *inode, bool inc) 2699 { 2700 struct f2fs_inode_info *fi = F2FS_I(inode); 2701 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2702 2703 /* Use i_gc_failures for normal file as a risk signal. */ 2704 if (inc) 2705 f2fs_i_gc_failures_write(inode, fi->i_gc_failures + 1); 2706 2707 if (fi->i_gc_failures > sbi->gc_pin_file_threshold) { 2708 f2fs_msg(sbi->sb, KERN_WARNING, 2709 "%s: Enable GC = ino %lx after %x GC trials\n", 2710 __func__, inode->i_ino, fi->i_gc_failures); 2711 clear_inode_flag(inode, FI_PIN_FILE); 2712 return -EAGAIN; 2713 } 2714 return 0; 2715 } 2716 2717 static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg) 2718 { 2719 struct inode *inode = file_inode(filp); 2720 __u32 pin; 2721 int ret = 0; 2722 2723 if (!inode_owner_or_capable(inode)) 2724 return -EACCES; 2725 2726 if (get_user(pin, (__u32 __user *)arg)) 2727 return -EFAULT; 2728 2729 if (!S_ISREG(inode->i_mode)) 2730 return -EINVAL; 2731 2732 if (f2fs_readonly(F2FS_I_SB(inode)->sb)) 2733 return -EROFS; 2734 2735 ret = mnt_want_write_file(filp); 2736 if (ret) 2737 return ret; 2738 2739 inode_lock(inode); 2740 2741 if (should_update_outplace(inode, NULL)) { 2742 ret = -EINVAL; 2743 goto out; 2744 } 2745 2746 if (!pin) { 2747 clear_inode_flag(inode, FI_PIN_FILE); 2748 F2FS_I(inode)->i_gc_failures = 1; 2749 goto done; 2750 } 2751 2752 if (f2fs_pin_file_control(inode, false)) { 2753 ret = -EAGAIN; 2754 goto out; 2755 } 2756 ret = f2fs_convert_inline_inode(inode); 2757 if (ret) 2758 goto out; 2759 2760 set_inode_flag(inode, FI_PIN_FILE); 2761 ret = F2FS_I(inode)->i_gc_failures; 2762 done: 2763 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 2764 out: 2765 inode_unlock(inode); 2766 mnt_drop_write_file(filp); 2767 return ret; 2768 } 2769 2770 static int f2fs_ioc_get_pin_file(struct file *filp, unsigned long arg) 2771 { 2772 struct inode *inode = file_inode(filp); 2773 __u32 pin = 0; 2774 2775 if (is_inode_flag_set(inode, FI_PIN_FILE)) 2776 pin = F2FS_I(inode)->i_gc_failures; 2777 return put_user(pin, (u32 __user *)arg); 2778 } 2779 2780 int f2fs_precache_extents(struct inode *inode) 2781 { 2782 struct f2fs_inode_info *fi = F2FS_I(inode); 2783 struct f2fs_map_blocks map; 2784 pgoff_t m_next_extent; 2785 loff_t end; 2786 int err; 2787 2788 if (is_inode_flag_set(inode, FI_NO_EXTENT)) 2789 return -EOPNOTSUPP; 2790 2791 map.m_lblk = 0; 2792 map.m_next_pgofs = NULL; 2793 map.m_next_extent = &m_next_extent; 2794 map.m_seg_type = NO_CHECK_TYPE; 2795 end = F2FS_I_SB(inode)->max_file_blocks; 2796 2797 while (map.m_lblk < end) { 2798 map.m_len = end - map.m_lblk; 2799 2800 down_write(&fi->dio_rwsem[WRITE]); 2801 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE); 2802 up_write(&fi->dio_rwsem[WRITE]); 2803 if (err) 2804 return err; 2805 2806 map.m_lblk = m_next_extent; 2807 } 2808 2809 return err; 2810 } 2811 2812 static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg) 2813 { 2814 return f2fs_precache_extents(file_inode(filp)); 2815 } 2816 2817 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 2818 { 2819 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) 2820 return -EIO; 2821 2822 switch (cmd) { 2823 case F2FS_IOC_GETFLAGS: 2824 return f2fs_ioc_getflags(filp, arg); 2825 case F2FS_IOC_SETFLAGS: 2826 return f2fs_ioc_setflags(filp, arg); 2827 case F2FS_IOC_GETVERSION: 2828 return f2fs_ioc_getversion(filp, arg); 2829 case F2FS_IOC_START_ATOMIC_WRITE: 2830 return f2fs_ioc_start_atomic_write(filp); 2831 case F2FS_IOC_COMMIT_ATOMIC_WRITE: 2832 return f2fs_ioc_commit_atomic_write(filp); 2833 case F2FS_IOC_START_VOLATILE_WRITE: 2834 return f2fs_ioc_start_volatile_write(filp); 2835 case F2FS_IOC_RELEASE_VOLATILE_WRITE: 2836 return f2fs_ioc_release_volatile_write(filp); 2837 case F2FS_IOC_ABORT_VOLATILE_WRITE: 2838 return f2fs_ioc_abort_volatile_write(filp); 2839 case F2FS_IOC_SHUTDOWN: 2840 return f2fs_ioc_shutdown(filp, arg); 2841 case FITRIM: 2842 return f2fs_ioc_fitrim(filp, arg); 2843 case F2FS_IOC_SET_ENCRYPTION_POLICY: 2844 return f2fs_ioc_set_encryption_policy(filp, arg); 2845 case F2FS_IOC_GET_ENCRYPTION_POLICY: 2846 return f2fs_ioc_get_encryption_policy(filp, arg); 2847 case F2FS_IOC_GET_ENCRYPTION_PWSALT: 2848 return f2fs_ioc_get_encryption_pwsalt(filp, arg); 2849 case F2FS_IOC_GARBAGE_COLLECT: 2850 return f2fs_ioc_gc(filp, arg); 2851 case F2FS_IOC_GARBAGE_COLLECT_RANGE: 2852 return f2fs_ioc_gc_range(filp, arg); 2853 case F2FS_IOC_WRITE_CHECKPOINT: 2854 return f2fs_ioc_write_checkpoint(filp, arg); 2855 case F2FS_IOC_DEFRAGMENT: 2856 return f2fs_ioc_defragment(filp, arg); 2857 case F2FS_IOC_MOVE_RANGE: 2858 return f2fs_ioc_move_range(filp, arg); 2859 case F2FS_IOC_FLUSH_DEVICE: 2860 return f2fs_ioc_flush_device(filp, arg); 2861 case F2FS_IOC_GET_FEATURES: 2862 return f2fs_ioc_get_features(filp, arg); 2863 case F2FS_IOC_FSGETXATTR: 2864 return f2fs_ioc_fsgetxattr(filp, arg); 2865 case F2FS_IOC_FSSETXATTR: 2866 return f2fs_ioc_fssetxattr(filp, arg); 2867 case F2FS_IOC_GET_PIN_FILE: 2868 return f2fs_ioc_get_pin_file(filp, arg); 2869 case F2FS_IOC_SET_PIN_FILE: 2870 return f2fs_ioc_set_pin_file(filp, arg); 2871 case F2FS_IOC_PRECACHE_EXTENTS: 2872 return f2fs_ioc_precache_extents(filp, arg); 2873 default: 2874 return -ENOTTY; 2875 } 2876 } 2877 2878 static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 2879 { 2880 struct file *file = iocb->ki_filp; 2881 struct inode *inode = file_inode(file); 2882 struct blk_plug plug; 2883 ssize_t ret; 2884 2885 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) 2886 return -EIO; 2887 2888 inode_lock(inode); 2889 ret = generic_write_checks(iocb, from); 2890 if (ret > 0) { 2891 int err; 2892 2893 if (iov_iter_fault_in_readable(from, iov_iter_count(from))) 2894 set_inode_flag(inode, FI_NO_PREALLOC); 2895 2896 err = f2fs_preallocate_blocks(iocb, from); 2897 if (err) { 2898 clear_inode_flag(inode, FI_NO_PREALLOC); 2899 inode_unlock(inode); 2900 return err; 2901 } 2902 blk_start_plug(&plug); 2903 ret = __generic_file_write_iter(iocb, from); 2904 blk_finish_plug(&plug); 2905 clear_inode_flag(inode, FI_NO_PREALLOC); 2906 2907 if (ret > 0) 2908 f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret); 2909 } 2910 inode_unlock(inode); 2911 2912 if (ret > 0) 2913 ret = generic_write_sync(iocb, ret); 2914 return ret; 2915 } 2916 2917 #ifdef CONFIG_COMPAT 2918 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2919 { 2920 switch (cmd) { 2921 case F2FS_IOC32_GETFLAGS: 2922 cmd = F2FS_IOC_GETFLAGS; 2923 break; 2924 case F2FS_IOC32_SETFLAGS: 2925 cmd = F2FS_IOC_SETFLAGS; 2926 break; 2927 case F2FS_IOC32_GETVERSION: 2928 cmd = F2FS_IOC_GETVERSION; 2929 break; 2930 case F2FS_IOC_START_ATOMIC_WRITE: 2931 case F2FS_IOC_COMMIT_ATOMIC_WRITE: 2932 case F2FS_IOC_START_VOLATILE_WRITE: 2933 case F2FS_IOC_RELEASE_VOLATILE_WRITE: 2934 case F2FS_IOC_ABORT_VOLATILE_WRITE: 2935 case F2FS_IOC_SHUTDOWN: 2936 case F2FS_IOC_SET_ENCRYPTION_POLICY: 2937 case F2FS_IOC_GET_ENCRYPTION_PWSALT: 2938 case F2FS_IOC_GET_ENCRYPTION_POLICY: 2939 case F2FS_IOC_GARBAGE_COLLECT: 2940 case F2FS_IOC_GARBAGE_COLLECT_RANGE: 2941 case F2FS_IOC_WRITE_CHECKPOINT: 2942 case F2FS_IOC_DEFRAGMENT: 2943 case F2FS_IOC_MOVE_RANGE: 2944 case F2FS_IOC_FLUSH_DEVICE: 2945 case F2FS_IOC_GET_FEATURES: 2946 case F2FS_IOC_FSGETXATTR: 2947 case F2FS_IOC_FSSETXATTR: 2948 case F2FS_IOC_GET_PIN_FILE: 2949 case F2FS_IOC_SET_PIN_FILE: 2950 case F2FS_IOC_PRECACHE_EXTENTS: 2951 break; 2952 default: 2953 return -ENOIOCTLCMD; 2954 } 2955 return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 2956 } 2957 #endif 2958 2959 const struct file_operations f2fs_file_operations = { 2960 .llseek = f2fs_llseek, 2961 .read_iter = generic_file_read_iter, 2962 .write_iter = f2fs_file_write_iter, 2963 .open = f2fs_file_open, 2964 .release = f2fs_release_file, 2965 .mmap = f2fs_file_mmap, 2966 .flush = f2fs_file_flush, 2967 .fsync = f2fs_sync_file, 2968 .fallocate = f2fs_fallocate, 2969 .unlocked_ioctl = f2fs_ioctl, 2970 #ifdef CONFIG_COMPAT 2971 .compat_ioctl = f2fs_compat_ioctl, 2972 #endif 2973 .splice_read = generic_file_splice_read, 2974 .splice_write = iter_file_splice_write, 2975 }; 2976