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