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