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