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