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