Lines Matching refs:inode
40 struct inode *inode = file_inode(vmf->vma->vm_file); in f2fs_filemap_fault() local
45 f2fs_update_iostat(F2FS_I_SB(inode), APP_MAPPED_READ_IO, in f2fs_filemap_fault()
48 trace_f2fs_filemap_fault(inode, vmf->pgoff, (unsigned long)ret); in f2fs_filemap_fault()
56 struct inode *inode = file_inode(vmf->vma->vm_file); in f2fs_vm_page_mkwrite() local
57 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_vm_page_mkwrite()
62 if (unlikely(IS_IMMUTABLE(inode))) in f2fs_vm_page_mkwrite()
65 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) in f2fs_vm_page_mkwrite()
78 err = f2fs_convert_inline_inode(inode); in f2fs_vm_page_mkwrite()
83 if (f2fs_compressed_file(inode)) { in f2fs_vm_page_mkwrite()
84 int ret = f2fs_is_compressed_cluster(inode, page->index); in f2fs_vm_page_mkwrite()
98 sb_start_pagefault(inode->i_sb); in f2fs_vm_page_mkwrite()
100 f2fs_bug_on(sbi, f2fs_has_inline_data(inode)); in f2fs_vm_page_mkwrite()
103 filemap_invalidate_lock_shared(inode->i_mapping); in f2fs_vm_page_mkwrite()
105 if (unlikely(page->mapping != inode->i_mapping || in f2fs_vm_page_mkwrite()
106 page_offset(page) > i_size_read(inode) || in f2fs_vm_page_mkwrite()
116 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_vm_page_mkwrite()
123 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_vm_page_mkwrite()
136 f2fs_wait_on_block_writeback(inode, dn.data_blkaddr); in f2fs_vm_page_mkwrite()
146 i_size_read(inode)) { in f2fs_vm_page_mkwrite()
149 offset = i_size_read(inode) & ~PAGE_MASK; in f2fs_vm_page_mkwrite()
161 filemap_invalidate_unlock_shared(inode->i_mapping); in f2fs_vm_page_mkwrite()
163 sb_end_pagefault(inode->i_sb); in f2fs_vm_page_mkwrite()
174 static int get_parent_ino(struct inode *inode, nid_t *pino) in get_parent_ino() argument
182 dentry = d_find_alias(inode); in get_parent_ino()
191 static inline enum cp_reason_type need_do_checkpoint(struct inode *inode) in need_do_checkpoint() argument
193 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in need_do_checkpoint()
196 if (!S_ISREG(inode->i_mode)) in need_do_checkpoint()
198 else if (f2fs_compressed_file(inode)) in need_do_checkpoint()
200 else if (inode->i_nlink != 1) in need_do_checkpoint()
204 else if (file_wrong_pino(inode)) in need_do_checkpoint()
208 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) in need_do_checkpoint()
215 f2fs_need_dentry_mark(sbi, inode->i_ino) && in need_do_checkpoint()
216 f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino, in need_do_checkpoint()
234 static void try_to_fix_pino(struct inode *inode) in try_to_fix_pino() argument
236 struct f2fs_inode_info *fi = F2FS_I(inode); in try_to_fix_pino()
240 if (file_wrong_pino(inode) && inode->i_nlink == 1 && in try_to_fix_pino()
241 get_parent_ino(inode, &pino)) { in try_to_fix_pino()
242 f2fs_i_pino_write(inode, pino); in try_to_fix_pino()
243 file_got_pino(inode); in try_to_fix_pino()
251 struct inode *inode = file->f_mapping->host; in f2fs_do_sync_file() local
252 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_do_sync_file()
253 nid_t ino = inode->i_ino; in f2fs_do_sync_file()
263 if (unlikely(f2fs_readonly(inode->i_sb))) in f2fs_do_sync_file()
266 trace_f2fs_sync_file_enter(inode); in f2fs_do_sync_file()
268 if (S_ISDIR(inode->i_mode)) in f2fs_do_sync_file()
272 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks) in f2fs_do_sync_file()
273 set_inode_flag(inode, FI_NEED_IPU); in f2fs_do_sync_file()
275 clear_inode_flag(inode, FI_NEED_IPU); in f2fs_do_sync_file()
278 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret); in f2fs_do_sync_file()
283 if (!f2fs_skip_inode_update(inode, datasync)) { in f2fs_do_sync_file()
284 f2fs_write_inode(inode, NULL); in f2fs_do_sync_file()
291 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) && in f2fs_do_sync_file()
298 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) || in f2fs_do_sync_file()
320 down_read(&F2FS_I(inode)->i_sem); in f2fs_do_sync_file()
321 cp_reason = need_do_checkpoint(inode); in f2fs_do_sync_file()
322 up_read(&F2FS_I(inode)->i_sem); in f2fs_do_sync_file()
326 ret = f2fs_sync_fs(inode->i_sb, 1); in f2fs_do_sync_file()
332 try_to_fix_pino(inode); in f2fs_do_sync_file()
333 clear_inode_flag(inode, FI_APPEND_WRITE); in f2fs_do_sync_file()
334 clear_inode_flag(inode, FI_UPDATE_WRITE); in f2fs_do_sync_file()
339 ret = f2fs_fsync_node_pages(sbi, inode, &wbc, atomic, &seq_id); in f2fs_do_sync_file()
351 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_do_sync_file()
352 f2fs_write_inode(inode, NULL); in f2fs_do_sync_file()
372 clear_inode_flag(inode, FI_APPEND_WRITE); in f2fs_do_sync_file()
375 ret = f2fs_issue_flush(sbi, inode->i_ino); in f2fs_do_sync_file()
378 clear_inode_flag(inode, FI_UPDATE_WRITE); in f2fs_do_sync_file()
383 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret); in f2fs_do_sync_file()
415 struct inode *inode = file->f_mapping->host; in f2fs_seek_block() local
416 loff_t maxbytes = inode->i_sb->s_maxbytes; in f2fs_seek_block()
423 inode_lock(inode); in f2fs_seek_block()
425 isize = i_size_read(inode); in f2fs_seek_block()
430 if (f2fs_has_inline_data(inode)) { in f2fs_seek_block()
443 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_seek_block()
457 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_seek_block()
468 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode), in f2fs_seek_block()
488 inode_unlock(inode); in f2fs_seek_block()
491 inode_unlock(inode); in f2fs_seek_block()
497 struct inode *inode = file->f_mapping->host; in f2fs_llseek() local
498 loff_t maxbytes = inode->i_sb->s_maxbytes; in f2fs_llseek()
500 if (f2fs_compressed_file(inode)) in f2fs_llseek()
501 maxbytes = max_file_blocks(inode) << F2FS_BLKSIZE_BITS; in f2fs_llseek()
508 maxbytes, i_size_read(inode)); in f2fs_llseek()
521 struct inode *inode = file_inode(file); in f2fs_file_mmap() local
523 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_file_mmap()
526 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_mmap()
531 set_inode_flag(inode, FI_MMAP_FILE); in f2fs_file_mmap()
535 static int f2fs_file_open(struct inode *inode, struct file *filp) in f2fs_file_open() argument
537 int err = fscrypt_file_open(inode, filp); in f2fs_file_open()
542 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_open()
545 err = fsverity_file_open(inode, filp); in f2fs_file_open()
551 return dquot_file_open(inode, filp); in f2fs_file_open()
556 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in f2fs_truncate_data_blocks_range()
563 int cluster_size = F2FS_I(dn->inode)->i_cluster_size; in f2fs_truncate_data_blocks_range()
564 bool released = !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks); in f2fs_truncate_data_blocks_range()
566 if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode)) in f2fs_truncate_data_blocks_range()
567 base = get_extra_isize(dn->inode); in f2fs_truncate_data_blocks_range()
576 if (f2fs_compressed_file(dn->inode) && in f2fs_truncate_data_blocks_range()
579 f2fs_i_compr_blocks_update(dn->inode, in f2fs_truncate_data_blocks_range()
600 clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN); in f2fs_truncate_data_blocks_range()
609 f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false); in f2fs_truncate_data_blocks_range()
618 dn->inode) + ofs; in f2fs_truncate_data_blocks_range()
620 dec_valid_block_count(sbi, dn->inode, nr_free); in f2fs_truncate_data_blocks_range()
625 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid, in f2fs_truncate_data_blocks_range()
631 f2fs_truncate_data_blocks_range(dn, ADDRS_PER_BLOCK(dn->inode)); in f2fs_truncate_data_blocks()
634 static int truncate_partial_data_page(struct inode *inode, u64 from, in truncate_partial_data_page() argument
639 struct address_space *mapping = inode->i_mapping; in truncate_partial_data_page()
653 page = f2fs_get_lock_data_page(inode, index, true); in truncate_partial_data_page()
661 f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode)); in truncate_partial_data_page()
668 int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock) in f2fs_do_truncate_blocks() argument
670 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_do_truncate_blocks()
677 trace_f2fs_truncate_blocks_enter(inode, from); in f2fs_do_truncate_blocks()
681 if (free_from >= max_file_blocks(inode)) in f2fs_do_truncate_blocks()
687 ipage = f2fs_get_node_page(sbi, inode->i_ino); in f2fs_do_truncate_blocks()
693 if (f2fs_has_inline_data(inode)) { in f2fs_do_truncate_blocks()
694 f2fs_truncate_inline_inode(inode, ipage, from); in f2fs_do_truncate_blocks()
700 set_new_dnode(&dn, inode, ipage, NULL, 0); in f2fs_do_truncate_blocks()
708 count = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_do_truncate_blocks()
720 err = f2fs_truncate_inode_blocks(inode, free_from); in f2fs_do_truncate_blocks()
727 err = truncate_partial_data_page(inode, from, truncate_page); in f2fs_do_truncate_blocks()
729 trace_f2fs_truncate_blocks_exit(inode, err); in f2fs_do_truncate_blocks()
733 int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock) in f2fs_truncate_blocks() argument
743 if (f2fs_compressed_file(inode)) in f2fs_truncate_blocks()
745 F2FS_I(inode)->i_cluster_size << PAGE_SHIFT); in f2fs_truncate_blocks()
748 err = f2fs_do_truncate_blocks(inode, free_from, lock); in f2fs_truncate_blocks()
757 if (f2fs_compressed_file(inode) && !free_from in f2fs_truncate_blocks()
758 && is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) in f2fs_truncate_blocks()
759 clear_inode_flag(inode, FI_COMPRESS_RELEASED); in f2fs_truncate_blocks()
762 err = f2fs_truncate_partial_cluster(inode, from, lock); in f2fs_truncate_blocks()
771 int f2fs_truncate(struct inode *inode) in f2fs_truncate() argument
775 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_truncate()
778 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || in f2fs_truncate()
779 S_ISLNK(inode->i_mode))) in f2fs_truncate()
782 trace_f2fs_truncate(inode); in f2fs_truncate()
784 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) { in f2fs_truncate()
785 f2fs_show_injection_info(F2FS_I_SB(inode), FAULT_TRUNCATE); in f2fs_truncate()
789 err = f2fs_dquot_initialize(inode); in f2fs_truncate()
794 if (!f2fs_may_inline_data(inode)) { in f2fs_truncate()
795 err = f2fs_convert_inline_inode(inode); in f2fs_truncate()
800 err = f2fs_truncate_blocks(inode, i_size_read(inode), true); in f2fs_truncate()
804 inode->i_mtime = inode->i_ctime = current_time(inode); in f2fs_truncate()
805 f2fs_mark_inode_dirty_sync(inode, false); in f2fs_truncate()
812 struct inode *inode = d_inode(path->dentry); in f2fs_getattr() local
813 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_getattr()
817 if (f2fs_has_extra_attr(inode) && in f2fs_getattr()
818 f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) && in f2fs_getattr()
830 if (IS_ENCRYPTED(inode)) in f2fs_getattr()
836 if (IS_VERITY(inode)) in f2fs_getattr()
846 generic_fillattr(&init_user_ns, inode, stat); in f2fs_getattr()
849 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) || in f2fs_getattr()
850 f2fs_has_inline_dentry(inode)) in f2fs_getattr()
858 struct inode *inode, const struct iattr *attr) in __setattr_copy() argument
863 inode->i_uid = attr->ia_uid; in __setattr_copy()
865 inode->i_gid = attr->ia_gid; in __setattr_copy()
867 inode->i_atime = attr->ia_atime; in __setattr_copy()
869 inode->i_mtime = attr->ia_mtime; in __setattr_copy()
871 inode->i_ctime = attr->ia_ctime; in __setattr_copy()
874 kgid_t kgid = i_gid_into_mnt(mnt_userns, inode); in __setattr_copy()
876 if (!in_group_p(kgid) && !capable_wrt_inode_uidgid(mnt_userns, inode, CAP_FSETID)) in __setattr_copy()
878 set_acl_inode(inode, mode); in __setattr_copy()
888 struct inode *inode = d_inode(dentry); in f2fs_setattr() local
891 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_setattr()
894 if (unlikely(IS_IMMUTABLE(inode))) in f2fs_setattr()
897 if (unlikely(IS_APPEND(inode) && in f2fs_setattr()
903 !f2fs_is_compress_backend_ready(inode)) in f2fs_setattr()
918 if (is_quota_modification(inode, attr)) { in f2fs_setattr()
919 err = f2fs_dquot_initialize(inode); in f2fs_setattr()
924 !uid_eq(attr->ia_uid, inode->i_uid)) || in f2fs_setattr()
926 !gid_eq(attr->ia_gid, inode->i_gid))) { in f2fs_setattr()
927 f2fs_lock_op(F2FS_I_SB(inode)); in f2fs_setattr()
928 err = dquot_transfer(inode, attr); in f2fs_setattr()
930 set_sbi_flag(F2FS_I_SB(inode), in f2fs_setattr()
932 f2fs_unlock_op(F2FS_I_SB(inode)); in f2fs_setattr()
940 inode->i_uid = attr->ia_uid; in f2fs_setattr()
942 inode->i_gid = attr->ia_gid; in f2fs_setattr()
943 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_setattr()
944 f2fs_unlock_op(F2FS_I_SB(inode)); in f2fs_setattr()
948 loff_t old_size = i_size_read(inode); in f2fs_setattr()
950 if (attr->ia_size > MAX_INLINE_DATA(inode)) { in f2fs_setattr()
955 err = f2fs_convert_inline_inode(inode); in f2fs_setattr()
960 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_setattr()
961 filemap_invalidate_lock(inode->i_mapping); in f2fs_setattr()
963 truncate_setsize(inode, attr->ia_size); in f2fs_setattr()
966 err = f2fs_truncate(inode); in f2fs_setattr()
971 filemap_invalidate_unlock(inode->i_mapping); in f2fs_setattr()
972 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_setattr()
976 spin_lock(&F2FS_I(inode)->i_size_lock); in f2fs_setattr()
977 inode->i_mtime = inode->i_ctime = current_time(inode); in f2fs_setattr()
978 F2FS_I(inode)->last_disk_size = i_size_read(inode); in f2fs_setattr()
979 spin_unlock(&F2FS_I(inode)->i_size_lock); in f2fs_setattr()
982 __setattr_copy(&init_user_ns, inode, attr); in f2fs_setattr()
985 err = posix_acl_chmod(&init_user_ns, inode, f2fs_get_inode_mode(inode)); in f2fs_setattr()
987 if (is_inode_flag_set(inode, FI_ACL_MODE)) { in f2fs_setattr()
989 inode->i_mode = F2FS_I(inode)->i_acl_mode; in f2fs_setattr()
990 clear_inode_flag(inode, FI_ACL_MODE); in f2fs_setattr()
995 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_setattr()
998 f2fs_balance_fs(F2FS_I_SB(inode), true); in f2fs_setattr()
1014 static int fill_zero(struct inode *inode, pgoff_t index, in fill_zero() argument
1017 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in fill_zero()
1026 page = f2fs_get_new_data_page(inode, NULL, index, false); in fill_zero()
1039 int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end) in f2fs_truncate_hole() argument
1047 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_truncate_hole()
1058 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_truncate_hole()
1061 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset); in f2fs_truncate_hole()
1071 static int punch_hole(struct inode *inode, loff_t offset, loff_t len) in punch_hole() argument
1077 ret = f2fs_convert_inline_inode(inode); in punch_hole()
1088 ret = fill_zero(inode, pg_start, off_start, in punch_hole()
1094 ret = fill_zero(inode, pg_start++, off_start, in punch_hole()
1100 ret = fill_zero(inode, pg_end, 0, off_end); in punch_hole()
1107 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in punch_hole()
1114 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in punch_hole()
1115 filemap_invalidate_lock(inode->i_mapping); in punch_hole()
1117 truncate_pagecache_range(inode, blk_start, blk_end - 1); in punch_hole()
1120 ret = f2fs_truncate_hole(inode, pg_start, pg_end); in punch_hole()
1123 filemap_invalidate_unlock(inode->i_mapping); in punch_hole()
1124 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in punch_hole()
1131 static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr, in __read_out_blkaddrs() argument
1134 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in __read_out_blkaddrs()
1139 set_new_dnode(&dn, inode, NULL, NULL, 0); in __read_out_blkaddrs()
1146 done = min((pgoff_t)ADDRS_PER_BLOCK(inode) - in __read_out_blkaddrs()
1153 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) - in __read_out_blkaddrs()
1186 static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr, in __roll_back_blkaddrs() argument
1189 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in __roll_back_blkaddrs()
1197 set_new_dnode(&dn, inode, NULL, NULL, 0); in __roll_back_blkaddrs()
1200 dec_valid_block_count(sbi, inode, 1); in __roll_back_blkaddrs()
1210 static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode, in __clone_blkaddrs()
1294 static int __exchange_data_block(struct inode *src_inode, in __exchange_data_block()
1295 struct inode *dst_inode, pgoff_t src, pgoff_t dst, in __exchange_data_block()
1346 static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len) in f2fs_do_collapse() argument
1348 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_do_collapse()
1349 pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); in f2fs_do_collapse()
1357 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_do_collapse()
1358 filemap_invalidate_lock(inode->i_mapping); in f2fs_do_collapse()
1361 f2fs_drop_extent_tree(inode); in f2fs_do_collapse()
1362 truncate_pagecache(inode, offset); in f2fs_do_collapse()
1363 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true); in f2fs_do_collapse()
1366 filemap_invalidate_unlock(inode->i_mapping); in f2fs_do_collapse()
1367 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_do_collapse()
1371 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len) in f2fs_collapse_range() argument
1376 if (offset + len >= i_size_read(inode)) in f2fs_collapse_range()
1383 ret = f2fs_convert_inline_inode(inode); in f2fs_collapse_range()
1388 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); in f2fs_collapse_range()
1392 ret = f2fs_do_collapse(inode, offset, len); in f2fs_collapse_range()
1397 filemap_invalidate_lock(inode->i_mapping); in f2fs_collapse_range()
1398 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX); in f2fs_collapse_range()
1399 truncate_pagecache(inode, offset); in f2fs_collapse_range()
1401 new_size = i_size_read(inode) - len; in f2fs_collapse_range()
1402 ret = f2fs_truncate_blocks(inode, new_size, true); in f2fs_collapse_range()
1403 filemap_invalidate_unlock(inode->i_mapping); in f2fs_collapse_range()
1405 f2fs_i_size_write(inode, new_size); in f2fs_collapse_range()
1412 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in f2fs_do_zero_range()
1451 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len, in f2fs_zero_range() argument
1454 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_zero_range()
1455 struct address_space *mapping = inode->i_mapping; in f2fs_zero_range()
1457 loff_t new_size = i_size_read(inode); in f2fs_zero_range()
1461 ret = inode_newsize_ok(inode, (len + offset)); in f2fs_zero_range()
1465 ret = f2fs_convert_inline_inode(inode); in f2fs_zero_range()
1480 ret = fill_zero(inode, pg_start, off_start, in f2fs_zero_range()
1488 ret = fill_zero(inode, pg_start++, off_start, in f2fs_zero_range()
1502 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_zero_range()
1505 truncate_pagecache_range(inode, in f2fs_zero_range()
1511 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_zero_range()
1516 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_zero_range()
1520 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_zero_range()
1528 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_zero_range()
1541 ret = fill_zero(inode, pg_end, 0, off_end); in f2fs_zero_range()
1550 if (new_size > i_size_read(inode)) { in f2fs_zero_range()
1552 file_set_keep_isize(inode); in f2fs_zero_range()
1554 f2fs_i_size_write(inode, new_size); in f2fs_zero_range()
1559 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len) in f2fs_insert_range() argument
1561 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_insert_range()
1562 struct address_space *mapping = inode->i_mapping; in f2fs_insert_range()
1567 new_size = i_size_read(inode) + len; in f2fs_insert_range()
1568 ret = inode_newsize_ok(inode, new_size); in f2fs_insert_range()
1572 if (offset >= i_size_read(inode)) in f2fs_insert_range()
1579 ret = f2fs_convert_inline_inode(inode); in f2fs_insert_range()
1586 ret = f2fs_truncate_blocks(inode, i_size_read(inode), true); in f2fs_insert_range()
1599 idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); in f2fs_insert_range()
1602 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_insert_range()
1604 truncate_pagecache(inode, offset); in f2fs_insert_range()
1613 f2fs_drop_extent_tree(inode); in f2fs_insert_range()
1615 ret = __exchange_data_block(inode, inode, idx, in f2fs_insert_range()
1620 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_insert_range()
1625 truncate_pagecache(inode, offset); in f2fs_insert_range()
1629 f2fs_i_size_write(inode, new_size); in f2fs_insert_range()
1633 static int expand_inode_data(struct inode *inode, loff_t offset, in expand_inode_data() argument
1636 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in expand_inode_data()
1641 loff_t new_size = i_size_read(inode); in expand_inode_data()
1646 err = inode_newsize_ok(inode, (len + offset)); in expand_inode_data()
1650 err = f2fs_convert_inline_inode(inode); in expand_inode_data()
1668 if (f2fs_is_pinned_file(inode)) { in expand_inode_data()
1689 err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO); in expand_inode_data()
1701 err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO); in expand_inode_data()
1720 if (new_size > i_size_read(inode)) { in expand_inode_data()
1722 file_set_keep_isize(inode); in expand_inode_data()
1724 f2fs_i_size_write(inode, new_size); in expand_inode_data()
1733 struct inode *inode = file_inode(file); in f2fs_fallocate() local
1736 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_fallocate()
1738 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode))) in f2fs_fallocate()
1740 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_fallocate()
1744 if (!S_ISREG(inode->i_mode)) in f2fs_fallocate()
1747 if (IS_ENCRYPTED(inode) && in f2fs_fallocate()
1751 if (f2fs_compressed_file(inode) && in f2fs_fallocate()
1761 inode_lock(inode); in f2fs_fallocate()
1764 if (offset >= inode->i_size) in f2fs_fallocate()
1767 ret = punch_hole(inode, offset, len); in f2fs_fallocate()
1769 ret = f2fs_collapse_range(inode, offset, len); in f2fs_fallocate()
1771 ret = f2fs_zero_range(inode, offset, len, mode); in f2fs_fallocate()
1773 ret = f2fs_insert_range(inode, offset, len); in f2fs_fallocate()
1775 ret = expand_inode_data(inode, offset, len, mode); in f2fs_fallocate()
1779 inode->i_mtime = inode->i_ctime = current_time(inode); in f2fs_fallocate()
1780 f2fs_mark_inode_dirty_sync(inode, false); in f2fs_fallocate()
1781 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_fallocate()
1785 inode_unlock(inode); in f2fs_fallocate()
1787 trace_f2fs_fallocate(inode, mode, offset, len, ret); in f2fs_fallocate()
1791 static int f2fs_release_file(struct inode *inode, struct file *filp) in f2fs_release_file() argument
1798 atomic_read(&inode->i_writecount) != 1) in f2fs_release_file()
1802 if (f2fs_is_atomic_file(inode)) in f2fs_release_file()
1803 f2fs_drop_inmem_pages(inode); in f2fs_release_file()
1804 if (f2fs_is_volatile_file(inode)) { in f2fs_release_file()
1805 set_inode_flag(inode, FI_DROP_CACHE); in f2fs_release_file()
1806 filemap_fdatawrite(inode->i_mapping); in f2fs_release_file()
1807 clear_inode_flag(inode, FI_DROP_CACHE); in f2fs_release_file()
1808 clear_inode_flag(inode, FI_VOLATILE_FILE); in f2fs_release_file()
1809 stat_dec_volatile_write(inode); in f2fs_release_file()
1816 struct inode *inode = file_inode(file); in f2fs_file_flush() local
1824 if (f2fs_is_atomic_file(inode) && in f2fs_file_flush()
1825 F2FS_I(inode)->inmem_task == current) in f2fs_file_flush()
1826 f2fs_drop_inmem_pages(inode); in f2fs_file_flush()
1830 static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask) in f2fs_setflags_common() argument
1832 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_setflags_common()
1839 if (IS_NOQUOTA(inode)) in f2fs_setflags_common()
1843 if (!f2fs_sb_has_casefold(F2FS_I_SB(inode))) in f2fs_setflags_common()
1845 if (!f2fs_empty_dir(inode)) in f2fs_setflags_common()
1850 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_setflags_common()
1858 if (!f2fs_disable_compressed_file(inode)) in f2fs_setflags_common()
1864 if (!f2fs_may_compress(inode)) in f2fs_setflags_common()
1866 if (S_ISREG(inode->i_mode) && inode->i_size) in f2fs_setflags_common()
1869 set_compress_context(inode); in f2fs_setflags_common()
1878 f2fs_bug_on(F2FS_I_SB(inode), (fi->i_flags & F2FS_COMPR_FL) && in f2fs_setflags_common()
1882 set_inode_flag(inode, FI_PROJ_INHERIT); in f2fs_setflags_common()
1884 clear_inode_flag(inode, FI_PROJ_INHERIT); in f2fs_setflags_common()
1886 inode->i_ctime = current_time(inode); in f2fs_setflags_common()
1887 f2fs_set_inode_flags(inode); in f2fs_setflags_common()
1888 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_setflags_common()
1978 struct inode *inode = file_inode(filp); in f2fs_ioc_getversion() local
1980 return put_user(inode->i_generation, (int __user *)arg); in f2fs_ioc_getversion()
1985 struct inode *inode = file_inode(filp); in f2fs_ioc_start_atomic_write() local
1986 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_ioc_start_atomic_write()
1987 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_start_atomic_write()
1990 if (!inode_owner_or_capable(&init_user_ns, inode)) in f2fs_ioc_start_atomic_write()
1993 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_start_atomic_write()
2003 inode_lock(inode); in f2fs_ioc_start_atomic_write()
2005 f2fs_disable_compressed_file(inode); in f2fs_ioc_start_atomic_write()
2007 if (f2fs_is_atomic_file(inode)) { in f2fs_ioc_start_atomic_write()
2008 if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST)) in f2fs_ioc_start_atomic_write()
2013 ret = f2fs_convert_inline_inode(inode); in f2fs_ioc_start_atomic_write()
2017 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_ioc_start_atomic_write()
2023 if (get_dirty_pages(inode)) in f2fs_ioc_start_atomic_write()
2024 f2fs_warn(F2FS_I_SB(inode), "Unexpected flush for atomic writes: ino=%lu, npages=%u", in f2fs_ioc_start_atomic_write()
2025 inode->i_ino, get_dirty_pages(inode)); in f2fs_ioc_start_atomic_write()
2026 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_ioc_start_atomic_write()
2028 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_ioc_start_atomic_write()
2039 set_inode_flag(inode, FI_ATOMIC_FILE); in f2fs_ioc_start_atomic_write()
2040 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST); in f2fs_ioc_start_atomic_write()
2041 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_ioc_start_atomic_write()
2043 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_start_atomic_write()
2044 F2FS_I(inode)->inmem_task = current; in f2fs_ioc_start_atomic_write()
2045 stat_update_max_atomic_write(inode); in f2fs_ioc_start_atomic_write()
2047 inode_unlock(inode); in f2fs_ioc_start_atomic_write()
2054 struct inode *inode = file_inode(filp); in f2fs_ioc_commit_atomic_write() local
2057 if (!inode_owner_or_capable(&init_user_ns, inode)) in f2fs_ioc_commit_atomic_write()
2064 f2fs_balance_fs(F2FS_I_SB(inode), true); in f2fs_ioc_commit_atomic_write()
2066 inode_lock(inode); in f2fs_ioc_commit_atomic_write()
2068 if (f2fs_is_volatile_file(inode)) { in f2fs_ioc_commit_atomic_write()
2073 if (f2fs_is_atomic_file(inode)) { in f2fs_ioc_commit_atomic_write()
2074 ret = f2fs_commit_inmem_pages(inode); in f2fs_ioc_commit_atomic_write()
2080 f2fs_drop_inmem_pages(inode); in f2fs_ioc_commit_atomic_write()
2085 if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST)) { in f2fs_ioc_commit_atomic_write()
2086 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST); in f2fs_ioc_commit_atomic_write()
2089 inode_unlock(inode); in f2fs_ioc_commit_atomic_write()
2096 struct inode *inode = file_inode(filp); in f2fs_ioc_start_volatile_write() local
2099 if (!inode_owner_or_capable(&init_user_ns, inode)) in f2fs_ioc_start_volatile_write()
2102 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_start_volatile_write()
2109 inode_lock(inode); in f2fs_ioc_start_volatile_write()
2111 if (f2fs_is_volatile_file(inode)) in f2fs_ioc_start_volatile_write()
2114 ret = f2fs_convert_inline_inode(inode); in f2fs_ioc_start_volatile_write()
2118 stat_inc_volatile_write(inode); in f2fs_ioc_start_volatile_write()
2119 stat_update_max_volatile_write(inode); in f2fs_ioc_start_volatile_write()
2121 set_inode_flag(inode, FI_VOLATILE_FILE); in f2fs_ioc_start_volatile_write()
2122 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_start_volatile_write()
2124 inode_unlock(inode); in f2fs_ioc_start_volatile_write()
2131 struct inode *inode = file_inode(filp); in f2fs_ioc_release_volatile_write() local
2134 if (!inode_owner_or_capable(&init_user_ns, inode)) in f2fs_ioc_release_volatile_write()
2141 inode_lock(inode); in f2fs_ioc_release_volatile_write()
2143 if (!f2fs_is_volatile_file(inode)) in f2fs_ioc_release_volatile_write()
2146 if (!f2fs_is_first_block_written(inode)) { in f2fs_ioc_release_volatile_write()
2147 ret = truncate_partial_data_page(inode, 0, true); in f2fs_ioc_release_volatile_write()
2151 ret = punch_hole(inode, 0, F2FS_BLKSIZE); in f2fs_ioc_release_volatile_write()
2153 inode_unlock(inode); in f2fs_ioc_release_volatile_write()
2160 struct inode *inode = file_inode(filp); in f2fs_ioc_abort_volatile_write() local
2163 if (!inode_owner_or_capable(&init_user_ns, inode)) in f2fs_ioc_abort_volatile_write()
2170 inode_lock(inode); in f2fs_ioc_abort_volatile_write()
2172 if (f2fs_is_atomic_file(inode)) in f2fs_ioc_abort_volatile_write()
2173 f2fs_drop_inmem_pages(inode); in f2fs_ioc_abort_volatile_write()
2174 if (f2fs_is_volatile_file(inode)) { in f2fs_ioc_abort_volatile_write()
2175 clear_inode_flag(inode, FI_VOLATILE_FILE); in f2fs_ioc_abort_volatile_write()
2176 stat_dec_volatile_write(inode); in f2fs_ioc_abort_volatile_write()
2180 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST); in f2fs_ioc_abort_volatile_write()
2182 inode_unlock(inode); in f2fs_ioc_abort_volatile_write()
2185 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_abort_volatile_write()
2191 struct inode *inode = file_inode(filp); in f2fs_ioc_shutdown() local
2192 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_shutdown()
2272 struct inode *inode = file_inode(filp); in f2fs_ioc_fitrim() local
2273 struct super_block *sb = inode->i_sb; in f2fs_ioc_fitrim()
2302 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_fitrim()
2318 struct inode *inode = file_inode(filp); in f2fs_ioc_set_encryption_policy() local
2320 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode))) in f2fs_ioc_set_encryption_policy()
2323 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_set_encryption_policy()
2337 struct inode *inode = file_inode(filp); in f2fs_ioc_get_encryption_pwsalt() local
2338 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_get_encryption_pwsalt()
2425 struct inode *inode = file_inode(filp); in f2fs_ioc_gc() local
2426 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_gc()
2515 struct inode *inode = file_inode(filp); in f2fs_ioc_write_checkpoint() local
2516 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_write_checkpoint()
2544 struct inode *inode = file_inode(filp); in f2fs_defragment_range() local
2557 if (f2fs_should_update_inplace(inode, NULL)) in f2fs_defragment_range()
2565 inode_lock(inode); in f2fs_defragment_range()
2568 err = filemap_write_and_wait_range(inode->i_mapping, range->start, in f2fs_defragment_range()
2577 if (f2fs_lookup_extent_cache(inode, pg_start, &ei)) { in f2fs_defragment_range()
2592 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT); in f2fs_defragment_range()
2639 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT); in f2fs_defragment_range()
2648 set_inode_flag(inode, FI_DO_DEFRAG); in f2fs_defragment_range()
2654 page = f2fs_get_lock_data_page(inode, idx, true); in f2fs_defragment_range()
2673 clear_inode_flag(inode, FI_DO_DEFRAG); in f2fs_defragment_range()
2675 err = filemap_fdatawrite(inode->i_mapping); in f2fs_defragment_range()
2680 clear_inode_flag(inode, FI_DO_DEFRAG); in f2fs_defragment_range()
2682 inode_unlock(inode); in f2fs_defragment_range()
2690 struct inode *inode = file_inode(filp); in f2fs_ioc_defragment() local
2691 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_defragment()
2698 if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode)) in f2fs_ioc_defragment()
2713 max_file_blocks(inode))) in f2fs_ioc_defragment()
2737 struct inode *src = file_inode(file_in); in f2fs_move_file_range()
2738 struct inode *dst = file_inode(file_out); in f2fs_move_file_range()
2893 struct inode *inode = file_inode(filp); in f2fs_ioc_flush_device() local
2894 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_flush_device()
2956 struct inode *inode = file_inode(filp); in f2fs_ioc_get_features() local
2957 u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature); in f2fs_ioc_get_features()
2966 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid) in f2fs_transfer_project_quota() argument
2969 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_transfer_project_quota()
2975 err = __dquot_transfer(inode, transfer_to); in f2fs_transfer_project_quota()
2983 static int f2fs_ioc_setproject(struct inode *inode, __u32 projid) in f2fs_ioc_setproject() argument
2985 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_ioc_setproject()
2986 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_setproject()
2998 if (!f2fs_has_extra_attr(inode)) in f2fs_ioc_setproject()
3003 if (projid_eq(kprojid, F2FS_I(inode)->i_projid)) in f2fs_ioc_setproject()
3008 if (IS_NOQUOTA(inode)) in f2fs_ioc_setproject()
3011 ipage = f2fs_get_node_page(sbi, inode->i_ino); in f2fs_ioc_setproject()
3023 err = f2fs_dquot_initialize(inode); in f2fs_ioc_setproject()
3028 err = f2fs_transfer_project_quota(inode, kprojid); in f2fs_ioc_setproject()
3032 F2FS_I(inode)->i_projid = kprojid; in f2fs_ioc_setproject()
3033 inode->i_ctime = current_time(inode); in f2fs_ioc_setproject()
3034 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_ioc_setproject()
3040 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid) in f2fs_transfer_project_quota() argument
3045 static int f2fs_ioc_setproject(struct inode *inode, __u32 projid) in f2fs_ioc_setproject() argument
3055 struct inode *inode = d_inode(dentry); in f2fs_fileattr_get() local
3056 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_fileattr_get()
3059 if (IS_ENCRYPTED(inode)) in f2fs_fileattr_get()
3061 if (IS_VERITY(inode)) in f2fs_fileattr_get()
3063 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) in f2fs_fileattr_get()
3065 if (is_inode_flag_set(inode, FI_PIN_FILE)) in f2fs_fileattr_get()
3070 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode))) in f2fs_fileattr_get()
3079 struct inode *inode = d_inode(dentry); in f2fs_fileattr_set() local
3084 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_fileattr_set()
3086 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode))) in f2fs_fileattr_set()
3095 if (f2fs_mask_flags(inode->i_mode, iflags) != iflags) in f2fs_fileattr_set()
3098 err = f2fs_setflags_common(inode, iflags, f2fs_fsflags_to_iflags(mask)); in f2fs_fileattr_set()
3100 err = f2fs_ioc_setproject(inode, fa->fsx_projid); in f2fs_fileattr_set()
3105 int f2fs_pin_file_control(struct inode *inode, bool inc) in f2fs_pin_file_control() argument
3107 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_pin_file_control()
3108 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_pin_file_control()
3112 f2fs_i_gc_failures_write(inode, in f2fs_pin_file_control()
3117 __func__, inode->i_ino, in f2fs_pin_file_control()
3119 clear_inode_flag(inode, FI_PIN_FILE); in f2fs_pin_file_control()
3127 struct inode *inode = file_inode(filp); in f2fs_ioc_set_pin_file() local
3134 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_set_pin_file()
3137 if (f2fs_readonly(F2FS_I_SB(inode)->sb)) in f2fs_ioc_set_pin_file()
3144 inode_lock(inode); in f2fs_ioc_set_pin_file()
3146 if (f2fs_should_update_outplace(inode, NULL)) { in f2fs_ioc_set_pin_file()
3152 clear_inode_flag(inode, FI_PIN_FILE); in f2fs_ioc_set_pin_file()
3153 f2fs_i_gc_failures_write(inode, 0); in f2fs_ioc_set_pin_file()
3157 if (f2fs_pin_file_control(inode, false)) { in f2fs_ioc_set_pin_file()
3162 ret = f2fs_convert_inline_inode(inode); in f2fs_ioc_set_pin_file()
3166 if (!f2fs_disable_compressed_file(inode)) { in f2fs_ioc_set_pin_file()
3171 set_inode_flag(inode, FI_PIN_FILE); in f2fs_ioc_set_pin_file()
3172 ret = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN]; in f2fs_ioc_set_pin_file()
3174 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_set_pin_file()
3176 inode_unlock(inode); in f2fs_ioc_set_pin_file()
3183 struct inode *inode = file_inode(filp); in f2fs_ioc_get_pin_file() local
3186 if (is_inode_flag_set(inode, FI_PIN_FILE)) in f2fs_ioc_get_pin_file()
3187 pin = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN]; in f2fs_ioc_get_pin_file()
3191 int f2fs_precache_extents(struct inode *inode) in f2fs_precache_extents() argument
3193 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_precache_extents()
3199 if (is_inode_flag_set(inode, FI_NO_EXTENT)) in f2fs_precache_extents()
3207 end = max_file_blocks(inode); in f2fs_precache_extents()
3213 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE); in f2fs_precache_extents()
3249 struct inode *inode = file_inode(filp); in f2fs_ioc_enable_verity() local
3251 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); in f2fs_ioc_enable_verity()
3253 if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) { in f2fs_ioc_enable_verity()
3254 f2fs_warn(F2FS_I_SB(inode), in f2fs_ioc_enable_verity()
3256 inode->i_ino); in f2fs_ioc_enable_verity()
3281 struct inode *inode = file_inode(filp); in f2fs_ioc_getfslabel() local
3282 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_getfslabel()
3307 struct inode *inode = file_inode(filp); in f2fs_ioc_setfslabel() local
3308 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_setfslabel()
3343 struct inode *inode = file_inode(filp); in f2fs_get_compress_blocks() local
3346 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_get_compress_blocks()
3349 if (!f2fs_compressed_file(inode)) in f2fs_get_compress_blocks()
3352 blocks = atomic_read(&F2FS_I(inode)->i_compr_blocks); in f2fs_get_compress_blocks()
3358 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in release_compress_blocks()
3360 int cluster_size = F2FS_I(dn->inode)->i_cluster_size; in release_compress_blocks()
3365 blkaddr = data_blkaddr(dn->inode, dn->node_page, in release_compress_blocks()
3398 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, false); in release_compress_blocks()
3399 dec_valid_block_count(sbi, dn->inode, in release_compress_blocks()
3412 struct inode *inode = file_inode(filp); in f2fs_release_compress_blocks() local
3413 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_release_compress_blocks()
3419 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_release_compress_blocks()
3422 if (!f2fs_compressed_file(inode)) in f2fs_release_compress_blocks()
3432 f2fs_balance_fs(F2FS_I_SB(inode), true); in f2fs_release_compress_blocks()
3434 inode_lock(inode); in f2fs_release_compress_blocks()
3436 writecount = atomic_read(&inode->i_writecount); in f2fs_release_compress_blocks()
3443 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) { in f2fs_release_compress_blocks()
3448 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_release_compress_blocks()
3452 set_inode_flag(inode, FI_COMPRESS_RELEASED); in f2fs_release_compress_blocks()
3453 inode->i_ctime = current_time(inode); in f2fs_release_compress_blocks()
3454 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_release_compress_blocks()
3456 if (!atomic_read(&F2FS_I(inode)->i_compr_blocks)) in f2fs_release_compress_blocks()
3459 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_release_compress_blocks()
3460 filemap_invalidate_lock(inode->i_mapping); in f2fs_release_compress_blocks()
3462 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); in f2fs_release_compress_blocks()
3468 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_release_compress_blocks()
3480 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_release_compress_blocks()
3482 count = round_up(count, F2FS_I(inode)->i_cluster_size); in f2fs_release_compress_blocks()
3495 filemap_invalidate_unlock(inode->i_mapping); in f2fs_release_compress_blocks()
3496 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_release_compress_blocks()
3498 inode_unlock(inode); in f2fs_release_compress_blocks()
3505 atomic_read(&F2FS_I(inode)->i_compr_blocks)) { in f2fs_release_compress_blocks()
3510 __func__, inode->i_ino, inode->i_blocks, in f2fs_release_compress_blocks()
3512 atomic_read(&F2FS_I(inode)->i_compr_blocks)); in f2fs_release_compress_blocks()
3520 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); in reserve_compress_blocks()
3522 int cluster_size = F2FS_I(dn->inode)->i_cluster_size; in reserve_compress_blocks()
3527 blkaddr = data_blkaddr(dn->inode, dn->node_page, in reserve_compress_blocks()
3562 ret = inc_valid_block_count(sbi, dn->inode, &reserved); in reserve_compress_blocks()
3569 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, true); in reserve_compress_blocks()
3581 struct inode *inode = file_inode(filp); in f2fs_reserve_compress_blocks() local
3582 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_reserve_compress_blocks()
3587 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_reserve_compress_blocks()
3590 if (!f2fs_compressed_file(inode)) in f2fs_reserve_compress_blocks()
3600 if (atomic_read(&F2FS_I(inode)->i_compr_blocks)) in f2fs_reserve_compress_blocks()
3603 f2fs_balance_fs(F2FS_I_SB(inode), true); in f2fs_reserve_compress_blocks()
3605 inode_lock(inode); in f2fs_reserve_compress_blocks()
3607 if (!is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) { in f2fs_reserve_compress_blocks()
3612 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_reserve_compress_blocks()
3613 filemap_invalidate_lock(inode->i_mapping); in f2fs_reserve_compress_blocks()
3615 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); in f2fs_reserve_compress_blocks()
3621 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_reserve_compress_blocks()
3633 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_reserve_compress_blocks()
3635 count = round_up(count, F2FS_I(inode)->i_cluster_size); in f2fs_reserve_compress_blocks()
3648 filemap_invalidate_unlock(inode->i_mapping); in f2fs_reserve_compress_blocks()
3649 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_reserve_compress_blocks()
3652 clear_inode_flag(inode, FI_COMPRESS_RELEASED); in f2fs_reserve_compress_blocks()
3653 inode->i_ctime = current_time(inode); in f2fs_reserve_compress_blocks()
3654 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_reserve_compress_blocks()
3657 inode_unlock(inode); in f2fs_reserve_compress_blocks()
3664 atomic_read(&F2FS_I(inode)->i_compr_blocks)) { in f2fs_reserve_compress_blocks()
3669 __func__, inode->i_ino, inode->i_blocks, in f2fs_reserve_compress_blocks()
3671 atomic_read(&F2FS_I(inode)->i_compr_blocks)); in f2fs_reserve_compress_blocks()
3677 static int f2fs_secure_erase(struct block_device *bdev, struct inode *inode, in f2fs_secure_erase() argument
3694 if (IS_ENCRYPTED(inode)) in f2fs_secure_erase()
3695 ret = fscrypt_zeroout_range(inode, off, block, len); in f2fs_secure_erase()
3706 struct inode *inode = file_inode(filp); in f2fs_sec_trim_file() local
3707 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_sec_trim_file()
3708 struct address_space *mapping = inode->i_mapping; in f2fs_sec_trim_file()
3725 !S_ISREG(inode->i_mode)) in f2fs_sec_trim_file()
3731 IS_ENCRYPTED(inode) && f2fs_is_multi_device(sbi))) in f2fs_sec_trim_file()
3735 inode_lock(inode); in f2fs_sec_trim_file()
3737 if (f2fs_is_atomic_file(inode) || f2fs_compressed_file(inode) || in f2fs_sec_trim_file()
3738 range.start >= inode->i_size) { in f2fs_sec_trim_file()
3746 if (inode->i_size - range.start > range.len) { in f2fs_sec_trim_file()
3750 sbi->sb->s_maxbytes : inode->i_size; in f2fs_sec_trim_file()
3763 ret = f2fs_convert_inline_inode(inode); in f2fs_sec_trim_file()
3767 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_sec_trim_file()
3783 set_new_dnode(&dn, inode, NULL, NULL, 0); in f2fs_sec_trim_file()
3793 end_offset = ADDRS_PER_PAGE(dn.node_page, inode); in f2fs_sec_trim_file()
3823 inode, prev_index, prev_block, in f2fs_sec_trim_file()
3852 ret = f2fs_secure_erase(prev_bdev, inode, prev_index, in f2fs_sec_trim_file()
3856 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_sec_trim_file()
3858 inode_unlock(inode); in f2fs_sec_trim_file()
3866 struct inode *inode = file_inode(filp); in f2fs_ioc_get_compress_option() local
3869 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_ioc_get_compress_option()
3872 inode_lock_shared(inode); in f2fs_ioc_get_compress_option()
3874 if (!f2fs_compressed_file(inode)) { in f2fs_ioc_get_compress_option()
3875 inode_unlock_shared(inode); in f2fs_ioc_get_compress_option()
3879 option.algorithm = F2FS_I(inode)->i_compress_algorithm; in f2fs_ioc_get_compress_option()
3880 option.log_cluster_size = F2FS_I(inode)->i_log_cluster_size; in f2fs_ioc_get_compress_option()
3882 inode_unlock_shared(inode); in f2fs_ioc_get_compress_option()
3893 struct inode *inode = file_inode(filp); in f2fs_ioc_set_compress_option() local
3894 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_set_compress_option()
3908 if (!f2fs_compressed_file(inode) || in f2fs_ioc_set_compress_option()
3915 inode_lock(inode); in f2fs_ioc_set_compress_option()
3917 if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { in f2fs_ioc_set_compress_option()
3922 if (inode->i_size != 0) { in f2fs_ioc_set_compress_option()
3927 F2FS_I(inode)->i_compress_algorithm = option.algorithm; in f2fs_ioc_set_compress_option()
3928 F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; in f2fs_ioc_set_compress_option()
3929 F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; in f2fs_ioc_set_compress_option()
3930 f2fs_mark_inode_dirty_sync(inode, true); in f2fs_ioc_set_compress_option()
3932 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_ioc_set_compress_option()
3936 inode_unlock(inode); in f2fs_ioc_set_compress_option()
3942 static int redirty_blocks(struct inode *inode, pgoff_t page_idx, int len) in redirty_blocks() argument
3944 DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, page_idx); in redirty_blocks()
3945 struct address_space *mapping = inode->i_mapping; in redirty_blocks()
3977 struct inode *inode = file_inode(filp); in f2fs_ioc_decompress_file() local
3978 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_decompress_file()
3979 struct f2fs_inode_info *fi = F2FS_I(inode); in f2fs_ioc_decompress_file()
3982 int cluster_size = F2FS_I(inode)->i_cluster_size; in f2fs_ioc_decompress_file()
3992 if (!f2fs_compressed_file(inode)) in f2fs_ioc_decompress_file()
3995 f2fs_balance_fs(F2FS_I_SB(inode), true); in f2fs_ioc_decompress_file()
3998 inode_lock(inode); in f2fs_ioc_decompress_file()
4000 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_ioc_decompress_file()
4005 if (f2fs_is_mmap_file(inode)) { in f2fs_ioc_decompress_file()
4010 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_ioc_decompress_file()
4017 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); in f2fs_ioc_decompress_file()
4023 ret = redirty_blocks(inode, page_idx, len); in f2fs_ioc_decompress_file()
4027 if (get_dirty_pages(inode) >= blk_per_seg) in f2fs_ioc_decompress_file()
4028 filemap_fdatawrite(inode->i_mapping); in f2fs_ioc_decompress_file()
4035 ret = filemap_write_and_wait_range(inode->i_mapping, 0, in f2fs_ioc_decompress_file()
4042 inode_unlock(inode); in f2fs_ioc_decompress_file()
4050 struct inode *inode = file_inode(filp); in f2fs_ioc_compress_file() local
4051 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); in f2fs_ioc_compress_file()
4054 int cluster_size = F2FS_I(inode)->i_cluster_size; in f2fs_ioc_compress_file()
4064 if (!f2fs_compressed_file(inode)) in f2fs_ioc_compress_file()
4067 f2fs_balance_fs(F2FS_I_SB(inode), true); in f2fs_ioc_compress_file()
4070 inode_lock(inode); in f2fs_ioc_compress_file()
4072 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_ioc_compress_file()
4077 if (f2fs_is_mmap_file(inode)) { in f2fs_ioc_compress_file()
4082 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); in f2fs_ioc_compress_file()
4086 set_inode_flag(inode, FI_ENABLE_COMPRESS); in f2fs_ioc_compress_file()
4088 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); in f2fs_ioc_compress_file()
4094 ret = redirty_blocks(inode, page_idx, len); in f2fs_ioc_compress_file()
4098 if (get_dirty_pages(inode) >= blk_per_seg) in f2fs_ioc_compress_file()
4099 filemap_fdatawrite(inode->i_mapping); in f2fs_ioc_compress_file()
4106 ret = filemap_write_and_wait_range(inode->i_mapping, 0, in f2fs_ioc_compress_file()
4109 clear_inode_flag(inode, FI_ENABLE_COMPRESS); in f2fs_ioc_compress_file()
4115 inode_unlock(inode); in f2fs_ioc_compress_file()
4224 struct inode *inode = file_inode(file); in f2fs_file_read_iter() local
4227 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_read_iter()
4233 f2fs_update_iostat(F2FS_I_SB(inode), APP_READ_IO, ret); in f2fs_file_read_iter()
4241 struct inode *inode = file_inode(file); in f2fs_file_write_iter() local
4244 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) { in f2fs_file_write_iter()
4249 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_file_write_iter()
4255 if (!inode_trylock(inode)) { in f2fs_file_write_iter()
4260 inode_lock(inode); in f2fs_file_write_iter()
4263 if (unlikely(IS_IMMUTABLE(inode))) { in f2fs_file_write_iter()
4268 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) { in f2fs_file_write_iter()
4280 set_inode_flag(inode, FI_NO_PREALLOC); in f2fs_file_write_iter()
4283 if (!f2fs_overwrite_io(inode, iocb->ki_pos, in f2fs_file_write_iter()
4285 f2fs_has_inline_data(inode) || in f2fs_file_write_iter()
4286 f2fs_force_buffered_io(inode, iocb, from)) { in f2fs_file_write_iter()
4287 clear_inode_flag(inode, FI_NO_PREALLOC); in f2fs_file_write_iter()
4288 inode_unlock(inode); in f2fs_file_write_iter()
4295 if (is_inode_flag_set(inode, FI_NO_PREALLOC)) in f2fs_file_write_iter()
4303 err = f2fs_convert_inline_inode(inode); in f2fs_file_write_iter()
4311 if (!f2fs_force_buffered_io(inode, iocb, from) && in f2fs_file_write_iter()
4312 f2fs_lfs_mode(F2FS_I_SB(inode))) in f2fs_file_write_iter()
4321 clear_inode_flag(inode, FI_NO_PREALLOC); in f2fs_file_write_iter()
4322 inode_unlock(inode); in f2fs_file_write_iter()
4328 clear_inode_flag(inode, FI_NO_PREALLOC); in f2fs_file_write_iter()
4331 if (preallocated && i_size_read(inode) < target_size) { in f2fs_file_write_iter()
4332 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_file_write_iter()
4333 filemap_invalidate_lock(inode->i_mapping); in f2fs_file_write_iter()
4334 f2fs_truncate(inode); in f2fs_file_write_iter()
4335 filemap_invalidate_unlock(inode->i_mapping); in f2fs_file_write_iter()
4336 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); in f2fs_file_write_iter()
4340 f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret); in f2fs_file_write_iter()
4343 inode_unlock(inode); in f2fs_file_write_iter()
4345 trace_f2fs_file_write_iter(inode, iocb->ki_pos, in f2fs_file_write_iter()
4355 struct inode *inode; in f2fs_file_fadvise() local
4360 inode = file_inode(filp); in f2fs_file_fadvise()
4361 if (S_ISFIFO(inode->i_mode)) in f2fs_file_fadvise()
4370 F2FS_I_SB(inode)->seq_file_ra_mul; in f2fs_file_fadvise()