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