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