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