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