Lines Matching full:if
42 if (old_size >= new_size) in f2fs_zero_post_eof_page()
56 if (ret & VM_FAULT_LOCKED) in f2fs_filemap_fault()
75 if (unlikely(IS_IMMUTABLE(inode))) in f2fs_vm_page_mkwrite()
78 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) { in f2fs_vm_page_mkwrite()
83 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_vm_page_mkwrite()
88 if (!f2fs_is_checkpoint_ready(sbi)) { in f2fs_vm_page_mkwrite()
94 if (err) in f2fs_vm_page_mkwrite()
98 if (f2fs_compressed_file(inode)) { in f2fs_vm_page_mkwrite()
101 if (ret < 0) { in f2fs_vm_page_mkwrite()
104 } else if (ret) { in f2fs_vm_page_mkwrite()
110 if (need_alloc) in f2fs_vm_page_mkwrite()
125 if (unlikely(folio->mapping != inode->i_mapping || in f2fs_vm_page_mkwrite()
134 if (need_alloc) { in f2fs_vm_page_mkwrite()
140 if (f2fs_is_pinned_file(inode) && in f2fs_vm_page_mkwrite()
145 if (err) { in f2fs_vm_page_mkwrite()
156 * check to see if the page is mapped already (no holes) in f2fs_vm_page_mkwrite()
158 if (folio_test_mappedtodisk(folio)) in f2fs_vm_page_mkwrite()
162 if (((loff_t)(folio->index + 1) << PAGE_SHIFT) > in f2fs_vm_page_mkwrite()
200 if (!dentry) in get_parent_ino()
213 if (!S_ISREG(inode->i_mode)) in need_do_checkpoint()
215 else if (f2fs_compressed_file(inode)) in need_do_checkpoint()
217 else if (inode->i_nlink != 1) in need_do_checkpoint()
219 else if (is_sbi_flag_set(sbi, SBI_NEED_CP)) in need_do_checkpoint()
221 else if (file_wrong_pino(inode)) in need_do_checkpoint()
223 else if (!f2fs_space_for_roll_forward(sbi)) in need_do_checkpoint()
225 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) in need_do_checkpoint()
227 else if (test_opt(sbi, FASTBOOT)) in need_do_checkpoint()
229 else if (F2FS_OPTION(sbi).active_logs == 2) in need_do_checkpoint()
231 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT && in need_do_checkpoint()
236 else if (f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino, in need_do_checkpoint()
248 if ((!IS_ERR(i) && folio_test_dirty(i)) || in need_inode_page_update()
261 if (file_wrong_pino(inode) && inode->i_nlink == 1 && in try_to_fix_pino()
283 if (unlikely(f2fs_readonly(inode->i_sb))) in f2fs_do_sync_file()
288 if (S_ISDIR(inode->i_mode)) in f2fs_do_sync_file()
291 /* if fdatasync is triggered, let's do in-place-update */ in f2fs_do_sync_file()
292 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks) in f2fs_do_sync_file()
297 if (ret || is_sbi_flag_set(sbi, SBI_CP_DISABLED)) { in f2fs_do_sync_file()
302 /* if the inode is dirty, let's recover all the time */ in f2fs_do_sync_file()
303 if (!f2fs_skip_inode_update(inode, datasync)) { in f2fs_do_sync_file()
309 * if there is no written data, don't waste time to write recovery info. in f2fs_do_sync_file()
311 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) && in f2fs_do_sync_file()
315 if (need_inode_page_update(sbi, ino)) in f2fs_do_sync_file()
318 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) || in f2fs_do_sync_file()
331 if (F2FS_OPTION(sbi).fsync_mode == in f2fs_do_sync_file()
344 if (cp_reason) { in f2fs_do_sync_file()
361 if (ret) in f2fs_do_sync_file()
364 /* if cp_error was enabled, we should avoid infinite loop */ in f2fs_do_sync_file()
365 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_do_sync_file()
370 if (f2fs_need_inode_block_update(sbi, ino)) { in f2fs_do_sync_file()
377 * If it's atomic_write, it's just fine to keep write ordering. So in f2fs_do_sync_file()
379 * node chain which serializes node blocks. If one of node writes are in f2fs_do_sync_file()
384 if (!atomic) { in f2fs_do_sync_file()
386 if (ret) in f2fs_do_sync_file()
394 if (!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER) in f2fs_do_sync_file()
396 if (!ret) { in f2fs_do_sync_file()
409 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file))))) in f2fs_sync_file()
421 if (f2fs_compressed_file(inode)) { in __found_offset()
430 if (__is_valid_data_blkaddr(blkaddr)) in __found_offset()
432 if (blkaddr == NEW_ADDR && in __found_offset()
435 if (compressed_cluster) in __found_offset()
439 if (compressed_cluster) in __found_offset()
441 if (blkaddr == NULL_ADDR) in __found_offset()
461 if (offset >= isize) in f2fs_seek_block()
465 if (f2fs_has_inline_data(inode)) { in f2fs_seek_block()
466 if (whence == SEEK_HOLE) { in f2fs_seek_block()
469 } else if (whence == SEEK_DATA) { in f2fs_seek_block()
480 if (err && err != -ENOENT) { in f2fs_seek_block()
482 } else if (err == -ENOENT) { in f2fs_seek_block()
484 if (whence == SEEK_DATA) { in f2fs_seek_block()
502 if (__is_valid_data_blkaddr(blkaddr) && in f2fs_seek_block()
509 if (__found_offset(file->f_mapping, &dn, in f2fs_seek_block()
518 if (whence == SEEK_DATA) in f2fs_seek_block()
521 if (whence == SEEK_HOLE && data_ofs > isize) in f2fs_seek_block()
543 if (offset < 0) in f2fs_llseek()
555 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_file_mmap()
558 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_mmap()
579 if (opened) in finish_preallocate_blocks()
583 if (is_inode_flag_set(inode, FI_OPENED_FILE)) in finish_preallocate_blocks()
586 if (!file_should_truncate(inode)) in finish_preallocate_blocks()
597 if (ret) in finish_preallocate_blocks()
614 if (err) in f2fs_file_open()
617 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_open()
621 if (err) in f2fs_file_open()
628 if (err) in f2fs_file_open()
653 if (f2fs_compressed_file(dn->inode) && in f2fs_truncate_data_blocks_range()
655 if (compressed_cluster) in f2fs_truncate_data_blocks_range()
662 if (blkaddr == NULL_ADDR) in f2fs_truncate_data_blocks_range()
667 if (__is_valid_data_blkaddr(blkaddr)) { in f2fs_truncate_data_blocks_range()
668 if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE)) in f2fs_truncate_data_blocks_range()
670 if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr, in f2fs_truncate_data_blocks_range()
673 if (compressed_cluster) in f2fs_truncate_data_blocks_range()
677 if (blkstart + blklen == blkaddr) { in f2fs_truncate_data_blocks_range()
685 if (!released || blkaddr != COMPRESS_ADDR) in f2fs_truncate_data_blocks_range()
691 if (blklen) in f2fs_truncate_data_blocks_range()
698 if (blklen) in f2fs_truncate_data_blocks_range()
701 if (compressed_cluster) in f2fs_truncate_data_blocks_range()
704 if (nr_free) { in f2fs_truncate_data_blocks_range()
731 if (!offset && !cache_only) in truncate_partial_data_page()
734 if (cache_only) { in truncate_partial_data_page()
736 if (IS_ERR(folio)) in truncate_partial_data_page()
738 if (folio_test_uptodate(folio)) in truncate_partial_data_page()
745 if (IS_ERR(folio)) in truncate_partial_data_page()
753 if (!cache_only) in truncate_partial_data_page()
770 if (IS_DEVICE_ALIASING(inode) && from) { in f2fs_do_truncate_blocks()
777 if (free_from >= max_file_blocks(inode)) in f2fs_do_truncate_blocks()
780 if (lock) in f2fs_do_truncate_blocks()
784 if (IS_ERR(ifolio)) { in f2fs_do_truncate_blocks()
789 if (IS_DEVICE_ALIASING(inode)) { in f2fs_do_truncate_blocks()
802 if (f2fs_has_inline_data(inode)) { in f2fs_do_truncate_blocks()
811 if (err) { in f2fs_do_truncate_blocks()
812 if (err == -ENOENT) in f2fs_do_truncate_blocks()
822 if (dn.ofs_in_node || IS_INODE(&dn.node_folio->page)) { in f2fs_do_truncate_blocks()
831 if (lock) in f2fs_do_truncate_blocks()
835 if (!err) in f2fs_do_truncate_blocks()
852 if (f2fs_compressed_file(inode)) in f2fs_truncate_blocks()
858 if (err) in f2fs_truncate_blocks()
866 if (f2fs_compressed_file(inode) && !free_from in f2fs_truncate_blocks()
870 if (from != free_from) { in f2fs_truncate_blocks()
872 if (err) in f2fs_truncate_blocks()
884 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_truncate()
887 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || in f2fs_truncate()
893 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) in f2fs_truncate()
897 if (err) in f2fs_truncate()
901 if (!f2fs_may_inline_data(inode)) { in f2fs_truncate()
903 if (err) in f2fs_truncate()
908 if (err) in f2fs_truncate()
920 if (!fscrypt_dio_supported(inode)) in f2fs_force_buffered_io()
922 if (fsverity_active(inode)) in f2fs_force_buffered_io()
924 if (f2fs_compressed_file(inode)) in f2fs_force_buffered_io()
930 if (f2fs_has_inline_data(inode) && rw == READ) in f2fs_force_buffered_io()
933 /* disallow direct IO if any of devices has unaligned blksize */ in f2fs_force_buffered_io()
934 if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize) in f2fs_force_buffered_io()
940 if (f2fs_sb_has_blkzoned(sbi) && (rw == WRITE) && in f2fs_force_buffered_io()
943 if (is_sbi_flag_set(sbi, SBI_CP_DISABLED)) in f2fs_force_buffered_io()
957 if (f2fs_has_extra_attr(inode) && in f2fs_getattr()
966 * Return the DIO alignment restrictions if requested. We only return in f2fs_getattr()
968 * take a fair bit of work to get if the file wasn't opened recently. in f2fs_getattr()
973 if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->i_mode)) { in f2fs_getattr()
977 if (!f2fs_force_buffered_io(inode, WRITE)) { in f2fs_getattr()
984 if (flags & F2FS_COMPR_FL) in f2fs_getattr()
986 if (flags & F2FS_APPEND_FL) in f2fs_getattr()
988 if (IS_ENCRYPTED(inode)) in f2fs_getattr()
990 if (flags & F2FS_IMMUTABLE_FL) in f2fs_getattr()
992 if (flags & F2FS_NODUMP_FL) in f2fs_getattr()
994 if (IS_VERITY(inode)) in f2fs_getattr()
1007 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) || in f2fs_getattr()
1022 if (ia_valid & ATTR_ATIME) in __setattr_copy()
1024 if (ia_valid & ATTR_MTIME) in __setattr_copy()
1026 if (ia_valid & ATTR_CTIME) in __setattr_copy()
1028 if (ia_valid & ATTR_MODE) { in __setattr_copy()
1031 if (!in_group_or_capable(idmap, inode, i_gid_into_vfsgid(idmap, inode))) in __setattr_copy()
1047 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_setattr()
1050 if (unlikely(IS_IMMUTABLE(inode))) in f2fs_setattr()
1053 if (unlikely(IS_APPEND(inode) && in f2fs_setattr()
1058 if ((attr->ia_valid & ATTR_SIZE)) { in f2fs_setattr()
1059 if (!f2fs_is_compress_backend_ready(inode) || in f2fs_setattr()
1062 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) && in f2fs_setattr()
1069 if (err) in f2fs_setattr()
1073 if (err) in f2fs_setattr()
1077 if (err) in f2fs_setattr()
1080 if (is_quota_modification(idmap, inode, attr)) { in f2fs_setattr()
1082 if (err) in f2fs_setattr()
1085 if (i_uid_needs_update(idmap, attr, inode) || in f2fs_setattr()
1089 if (err) { in f2fs_setattr()
1105 if (attr->ia_valid & ATTR_SIZE) { in f2fs_setattr()
1108 if (attr->ia_size > MAX_INLINE_DATA(inode)) { in f2fs_setattr()
1114 if (err) in f2fs_setattr()
1122 if (attr->ia_size < old_size) in f2fs_setattr()
1128 if (attr->ia_size > old_size) in f2fs_setattr()
1132 if (attr->ia_size <= old_size) in f2fs_setattr()
1135 * do not trim all blocks after i_size if target size is in f2fs_setattr()
1140 if (err) in f2fs_setattr()
1151 if (attr->ia_valid & ATTR_MODE) { in f2fs_setattr()
1154 if (is_inode_flag_set(inode, FI_ACL_MODE)) { in f2fs_setattr()
1155 if (!err) in f2fs_setattr()
1187 if (!len) in fill_zero()
1196 if (IS_ERR(folio)) in fill_zero()
1216 if (err) { in f2fs_truncate_hole()
1217 if (err == -ENOENT) { in f2fs_truncate_hole()
1245 if (ret) in f2fs_punch_hole()
1258 if (pg_start == pg_end) { in f2fs_punch_hole()
1261 if (ret) in f2fs_punch_hole()
1264 if (off_start) { in f2fs_punch_hole()
1267 if (ret) in f2fs_punch_hole()
1270 if (off_end) { in f2fs_punch_hole()
1272 if (ret) in f2fs_punch_hole()
1276 if (pg_start < pg_end) { in f2fs_punch_hole()
1312 if (ret && ret != -ENOENT) { in __read_out_blkaddrs()
1314 } else if (ret == -ENOENT) { in __read_out_blkaddrs()
1315 if (dn.max_level == 0) in __read_out_blkaddrs()
1329 if (__is_valid_data_blkaddr(*blkaddr) && in __read_out_blkaddrs()
1336 if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) { in __read_out_blkaddrs()
1338 if (f2fs_lfs_mode(sbi)) { in __read_out_blkaddrs()
1352 if (len) in __read_out_blkaddrs()
1365 if (*do_replace == 0) in __roll_back_blkaddrs()
1370 if (ret) { in __roll_back_blkaddrs()
1390 if (blkaddr[i] == NULL_ADDR && !full) { in __clone_blkaddrs()
1395 if (do_replace[i] || blkaddr[i] == NULL_ADDR) { in __clone_blkaddrs()
1403 if (ret) in __clone_blkaddrs()
1407 if (ret) { in __clone_blkaddrs()
1419 if (do_replace[i]) { in __clone_blkaddrs()
1432 if (dst_inode->i_size < new_size) in __clone_blkaddrs()
1442 if (IS_ERR(fsrc)) in __clone_blkaddrs()
1446 if (IS_ERR(fdst)) { in __clone_blkaddrs()
1461 if (ret) in __clone_blkaddrs()
1484 if (!src_blkaddr) in __exchange_data_block()
1490 if (!do_replace) { in __exchange_data_block()
1497 if (ret) in __exchange_data_block()
1502 if (ret) in __exchange_data_block()
1553 if (offset + len >= i_size_read(inode)) in f2fs_collapse_range()
1557 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) in f2fs_collapse_range()
1561 if (ret) in f2fs_collapse_range()
1566 if (ret) in f2fs_collapse_range()
1570 if (ret) in f2fs_collapse_range()
1573 /* write out all moved pages, if possible */ in f2fs_collapse_range()
1581 if (!ret) in f2fs_collapse_range()
1596 if (f2fs_data_blkaddr(dn) == NULL_ADDR) in f2fs_do_zero_range()
1602 if (ret) in f2fs_do_zero_range()
1612 if (dn->data_blkaddr == NULL_ADDR) { in f2fs_do_zero_range()
1617 if (dn->data_blkaddr == NEW_ADDR) in f2fs_do_zero_range()
1620 if (!f2fs_is_valid_blkaddr(sbi, dn->data_blkaddr, in f2fs_do_zero_range()
1647 if (ret) in f2fs_zero_range()
1651 if (ret) in f2fs_zero_range()
1655 if (ret) in f2fs_zero_range()
1668 if (pg_start == pg_end) { in f2fs_zero_range()
1671 if (ret) in f2fs_zero_range()
1676 if (off_start) { in f2fs_zero_range()
1679 if (ret) in f2fs_zero_range()
1702 if (ret) { in f2fs_zero_range()
1721 if (ret) in f2fs_zero_range()
1729 if (off_end) { in f2fs_zero_range()
1731 if (ret) in f2fs_zero_range()
1739 if (new_size > i_size_read(inode)) { in f2fs_zero_range()
1740 if (mode & FALLOC_FL_KEEP_SIZE) in f2fs_zero_range()
1758 if (ret) in f2fs_insert_range()
1761 if (offset >= i_size_read(inode)) in f2fs_insert_range()
1765 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) in f2fs_insert_range()
1769 if (ret) in f2fs_insert_range()
1777 if (ret) in f2fs_insert_range()
1782 if (ret) in f2fs_insert_range()
1799 if (nr > delta) in f2fs_insert_range()
1812 if (ret) in f2fs_insert_range()
1815 /* write out all moved pages, if possible */ in f2fs_insert_range()
1821 if (!ret) in f2fs_insert_range()
1845 if (err) in f2fs_expand_inode_data()
1849 if (err) in f2fs_expand_inode_data()
1864 if (off_end) in f2fs_expand_inode_data()
1867 if (!map.m_len) in f2fs_expand_inode_data()
1870 if (f2fs_is_pinned_file(inode)) { in f2fs_expand_inode_data()
1878 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { in f2fs_expand_inode_data()
1879 if (has_not_enough_free_secs(sbi, 0, 0)) { in f2fs_expand_inode_data()
1890 if (has_not_enough_free_secs(sbi, 0, f2fs_sb_has_blkzoned(sbi) ? in f2fs_expand_inode_data()
1896 if (err && err != -ENODATA) { in f2fs_expand_inode_data()
1903 if (err) { in f2fs_expand_inode_data()
1917 if (!err && sec_len) in f2fs_expand_inode_data()
1926 if (err) { in f2fs_expand_inode_data()
1929 if (!expanded) in f2fs_expand_inode_data()
1941 if (new_size > i_size_read(inode)) { in f2fs_expand_inode_data()
1942 if (mode & FALLOC_FL_KEEP_SIZE) in f2fs_expand_inode_data()
1957 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_fallocate()
1959 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode))) in f2fs_fallocate()
1961 if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode)) in f2fs_fallocate()
1965 if (!S_ISREG(inode->i_mode)) in f2fs_fallocate()
1968 if (IS_ENCRYPTED(inode) && in f2fs_fallocate()
1972 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | in f2fs_fallocate()
1983 if ((f2fs_compressed_file(inode) || f2fs_is_pinned_file(inode)) && in f2fs_fallocate()
1991 if (ret) in f2fs_fallocate()
2000 if (mode & FALLOC_FL_PUNCH_HOLE) { in f2fs_fallocate()
2001 if (offset >= inode->i_size) in f2fs_fallocate()
2005 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) { in f2fs_fallocate()
2007 } else if (mode & FALLOC_FL_ZERO_RANGE) { in f2fs_fallocate()
2009 } else if (mode & FALLOC_FL_INSERT_RANGE) { in f2fs_fallocate()
2015 if (!ret) { in f2fs_fallocate()
2034 if (!(filp->f_mode & FMODE_WRITE) || in f2fs_release_file()
2050 * If the process doing a transaction is crashed, we should do in f2fs_file_flush()
2055 if (F2FS_I(inode)->atomic_write_task == current && in f2fs_file_flush()
2074 if (IS_NOQUOTA(inode)) in f2fs_setflags_common()
2077 if ((iflags ^ masked_flags) & F2FS_CASEFOLD_FL) { in f2fs_setflags_common()
2078 if (!f2fs_sb_has_casefold(F2FS_I_SB(inode))) in f2fs_setflags_common()
2080 if (!f2fs_empty_dir(inode)) in f2fs_setflags_common()
2084 if (iflags & (F2FS_COMPR_FL | F2FS_NOCOMP_FL)) { in f2fs_setflags_common()
2085 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_setflags_common()
2087 if ((iflags & F2FS_COMPR_FL) && (iflags & F2FS_NOCOMP_FL)) in f2fs_setflags_common()
2091 if ((iflags ^ masked_flags) & F2FS_COMPR_FL) { in f2fs_setflags_common()
2092 if (masked_flags & F2FS_COMPR_FL) { in f2fs_setflags_common()
2093 if (!f2fs_disable_compressed_file(inode)) in f2fs_setflags_common()
2098 if (err) in f2fs_setflags_common()
2102 if (!f2fs_may_compress(inode) || in f2fs_setflags_common()
2111 if (err) in f2fs_setflags_common()
2120 if (fi->i_flags & F2FS_PROJINHERIT_FL) in f2fs_setflags_common()
2196 if (iflags & f2fs_fsflags_map[i].iflag) in f2fs_iflags_to_fsflags()
2209 if (fsflags & f2fs_fsflags_map[i].fsflag) in f2fs_fsflags_to_iflags()
2231 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_start_atomic_write()
2234 if (!inode_owner_or_capable(idmap, inode)) in f2fs_ioc_start_atomic_write()
2237 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_start_atomic_write()
2240 if (filp->f_flags & O_DIRECT) in f2fs_ioc_start_atomic_write()
2244 if (ret) in f2fs_ioc_start_atomic_write()
2249 if (!f2fs_disable_compressed_file(inode) || in f2fs_ioc_start_atomic_write()
2255 if (f2fs_is_atomic_file(inode)) in f2fs_ioc_start_atomic_write()
2259 if (ret) in f2fs_ioc_start_atomic_write()
2269 if (get_dirty_pages(inode)) in f2fs_ioc_start_atomic_write()
2273 if (ret) in f2fs_ioc_start_atomic_write()
2276 /* Check if the inode already has a COW inode */ in f2fs_ioc_start_atomic_write()
2277 if (fi->cow_inode == NULL) { in f2fs_ioc_start_atomic_write()
2283 if (ret) in f2fs_ioc_start_atomic_write()
2298 if (ret) in f2fs_ioc_start_atomic_write()
2310 if (truncate) { in f2fs_ioc_start_atomic_write()
2321 if (ret) in f2fs_ioc_start_atomic_write()
2340 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_commit_atomic_write()
2343 if (!inode_owner_or_capable(idmap, inode)) in f2fs_ioc_commit_atomic_write()
2347 if (ret) in f2fs_ioc_commit_atomic_write()
2354 if (f2fs_is_atomic_file(inode)) { in f2fs_ioc_commit_atomic_write()
2356 if (!ret) in f2fs_ioc_commit_atomic_write()
2375 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_abort_atomic_write()
2378 if (!inode_owner_or_capable(idmap, inode)) in f2fs_ioc_abort_atomic_write()
2382 if (ret) in f2fs_ioc_abort_atomic_write()
2405 if (ret) in f2fs_do_shutdown()
2413 if (ret) { in f2fs_do_shutdown()
2414 if (ret == -EIO) in f2fs_do_shutdown()
2433 if (ret == -EIO) in f2fs_do_shutdown()
2441 if (readonly) in f2fs_do_shutdown()
2448 if (need_lock) in f2fs_do_shutdown()
2457 if (need_lock) in f2fs_do_shutdown()
2476 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_shutdown()
2479 if (get_user(in, (__u32 __user *)arg)) in f2fs_ioc_shutdown()
2482 if (in != F2FS_GOING_DOWN_FULLSYNC) { in f2fs_ioc_shutdown()
2484 if (ret) { in f2fs_ioc_shutdown()
2485 if (ret != -EROFS) in f2fs_ioc_shutdown()
2498 if (need_drop) in f2fs_ioc_shutdown()
2512 if (!S_ISREG(inode->i_mode)) in f2fs_keep_noreuse_range()
2515 if (offset >= max_bytes || len > max_bytes || in f2fs_keep_noreuse_range()
2523 if (f2fs_is_atomic_file(inode)) { in f2fs_keep_noreuse_range()
2529 /* let's remove the range, if len = 0 */ in f2fs_keep_noreuse_range()
2530 if (!len) { in f2fs_keep_noreuse_range()
2531 if (!list_empty(&F2FS_I(inode)->gdonate_list)) { in f2fs_keep_noreuse_range()
2534 if (is_inode_flag_set(inode, FI_DONATE_FINISHED)) in f2fs_keep_noreuse_range()
2541 if (list_empty(&F2FS_I(inode)->gdonate_list)) { in f2fs_keep_noreuse_range()
2566 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_fitrim()
2569 if (!f2fs_hw_support_discard(F2FS_SB(sb))) in f2fs_ioc_fitrim()
2572 if (copy_from_user(&range, (struct fstrim_range __user *)arg, in f2fs_ioc_fitrim()
2577 if (ret) in f2fs_ioc_fitrim()
2584 if (ret < 0) in f2fs_ioc_fitrim()
2587 if (copy_to_user((struct fstrim_range __user *)arg, &range, in f2fs_ioc_fitrim()
2599 if (u[i]) in uuid_is_nonzero()
2609 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode))) in f2fs_ioc_set_encryption_policy()
2619 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_policy()
2631 if (!f2fs_sb_has_encrypt(sbi)) in f2fs_ioc_get_encryption_pwsalt()
2635 if (err) in f2fs_ioc_get_encryption_pwsalt()
2640 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt)) in f2fs_ioc_get_encryption_pwsalt()
2647 if (err) { in f2fs_ioc_get_encryption_pwsalt()
2658 if (!err && copy_to_user((__u8 __user *)arg, encrypt_pw_salt, 16)) in f2fs_ioc_get_encryption_pwsalt()
2667 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_policy_ex()
2675 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_add_encryption_key()
2683 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_remove_encryption_key()
2692 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_remove_encryption_key_all_users()
2701 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_key_status()
2709 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_nonce()
2726 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_gc()
2729 if (get_user(sync, (__u32 __user *)arg)) in f2fs_ioc_gc()
2732 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_gc()
2736 if (ret) in f2fs_ioc_gc()
2739 if (!sync) { in f2fs_ioc_gc()
2740 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in f2fs_ioc_gc()
2769 if (!capable(CAP_SYS_ADMIN)) in __f2fs_ioc_gc_range()
2771 if (f2fs_readonly(sbi->sb)) in __f2fs_ioc_gc_range()
2775 if (end < range->start || range->start < MAIN_BLKADDR(sbi) || in __f2fs_ioc_gc_range()
2780 if (ret) in __f2fs_ioc_gc_range()
2784 if (!range->sync) { in __f2fs_ioc_gc_range()
2785 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in __f2fs_ioc_gc_range()
2796 if (ret) { in __f2fs_ioc_gc_range()
2797 if (ret == -EBUSY) in __f2fs_ioc_gc_range()
2802 if (range->start <= end) in __f2fs_ioc_gc_range()
2813 if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg, in f2fs_ioc_gc_range()
2825 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_write_checkpoint()
2828 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_write_checkpoint()
2831 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { in f2fs_ioc_write_checkpoint()
2837 if (ret) in f2fs_ioc_write_checkpoint()
2869 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) || in f2fs_defragment_range()
2875 /* if in-place-update policy is enabled, don't waste time here */ in f2fs_defragment_range()
2877 if (f2fs_should_update_inplace(inode, NULL)) { in f2fs_defragment_range()
2886 if (err) in f2fs_defragment_range()
2890 * lookup mapping info in extent cache, skip defragmenting if physical in f2fs_defragment_range()
2893 if (f2fs_lookup_read_extent_cache(inode, pg_start, &ei)) { in f2fs_defragment_range()
2894 if ((pgoff_t)ei.fofs + ei.len >= pg_end) in f2fs_defragment_range()
2902 * lookup mapping info in dnode page cache, skip defragmenting if all in f2fs_defragment_range()
2903 * physical block addresses are continuous even if there are hole(s) in f2fs_defragment_range()
2909 if (err) in f2fs_defragment_range()
2912 if (!(map.m_flags & F2FS_MAP_FLAGS)) { in f2fs_defragment_range()
2917 if (blk_end && blk_end != map.m_pblk) in f2fs_defragment_range()
2928 if (!fragmented) { in f2fs_defragment_range()
2940 if (has_not_enough_free_secs(sbi, 0, sec_num)) { in f2fs_defragment_range()
2956 if (err) in f2fs_defragment_range()
2959 if (!(map.m_flags & F2FS_MAP_FLAGS)) { in f2fs_defragment_range()
2972 if (IS_ERR(folio)) { in f2fs_defragment_range()
2990 if (map.m_lblk < pg_end && cnt < BLKS_PER_SEG(sbi)) in f2fs_defragment_range()
2996 if (err) in f2fs_defragment_range()
3005 if (!err) in f2fs_defragment_range()
3017 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_defragment()
3020 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_defragment()
3023 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_defragment()
3026 if (copy_from_user(&range, (struct f2fs_defragment __user *)arg, in f2fs_ioc_defragment()
3031 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1)) in f2fs_ioc_defragment()
3034 if (unlikely((range.start + range.len) >> PAGE_SHIFT > in f2fs_ioc_defragment()
3039 if (err) in f2fs_ioc_defragment()
3045 if (range.len) in f2fs_ioc_defragment()
3047 if (err < 0) in f2fs_ioc_defragment()
3050 if (copy_to_user((struct f2fs_defragment __user *)arg, &range, in f2fs_ioc_defragment()
3067 if (file_in->f_path.mnt != file_out->f_path.mnt || in f2fs_move_file_range()
3071 if (unlikely(f2fs_readonly(src->i_sb))) in f2fs_move_file_range()
3074 if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode)) in f2fs_move_file_range()
3077 if (IS_ENCRYPTED(src) || IS_ENCRYPTED(dst)) in f2fs_move_file_range()
3080 if (pos_out < 0 || pos_in < 0) in f2fs_move_file_range()
3083 if (src == dst) { in f2fs_move_file_range()
3084 if (pos_in == pos_out) in f2fs_move_file_range()
3086 if (pos_out > pos_in && pos_out < pos_in + len) in f2fs_move_file_range()
3091 if (src != dst) { in f2fs_move_file_range()
3093 if (!inode_trylock(dst)) in f2fs_move_file_range()
3097 if (f2fs_compressed_file(src) || f2fs_compressed_file(dst) || in f2fs_move_file_range()
3103 if (f2fs_is_atomic_file(src) || f2fs_is_atomic_file(dst)) { in f2fs_move_file_range()
3109 if (pos_in + len > src->i_size || pos_in + len < pos_in) in f2fs_move_file_range()
3111 if (len == 0) in f2fs_move_file_range()
3113 if (pos_in + len == src->i_size) in f2fs_move_file_range()
3115 if (len == 0) { in f2fs_move_file_range()
3121 if (pos_out + olen > dst->i_size) in f2fs_move_file_range()
3125 if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) || in f2fs_move_file_range()
3131 if (ret) in f2fs_move_file_range()
3135 if (ret) in f2fs_move_file_range()
3141 if (ret) in f2fs_move_file_range()
3146 if (ret) in f2fs_move_file_range()
3152 if (src != dst) { in f2fs_move_file_range()
3154 if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE])) in f2fs_move_file_range()
3163 if (!ret) { in f2fs_move_file_range()
3164 if (dst_max_i_size) in f2fs_move_file_range()
3166 else if (dst_osize != dst->i_size) in f2fs_move_file_range()
3171 if (src != dst) in f2fs_move_file_range()
3175 if (ret) in f2fs_move_file_range()
3180 if (src != dst) { in f2fs_move_file_range()
3187 if (src != dst) in f2fs_move_file_range()
3199 if (!(filp->f_mode & FMODE_READ) || in __f2fs_ioc_move_range()
3204 if (fd_empty(dst)) in __f2fs_ioc_move_range()
3207 if (!(fd_file(dst)->f_mode & FMODE_WRITE)) in __f2fs_ioc_move_range()
3211 if (err) in __f2fs_ioc_move_range()
3225 if (copy_from_user(&range, (struct f2fs_move_range __user *)arg, in f2fs_ioc_move_range()
3246 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_flush_device()
3249 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_flush_device()
3252 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) in f2fs_ioc_flush_device()
3255 if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg, in f2fs_ioc_flush_device()
3259 if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num || in f2fs_ioc_flush_device()
3267 if (ret) in f2fs_ioc_flush_device()
3270 if (range.dev_num != 0) in f2fs_ioc_flush_device()
3275 if (start_segno < dev_start_segno || start_segno >= dev_end_segno) in f2fs_ioc_flush_device()
3280 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in f2fs_ioc_flush_device()
3291 if (ret == -EAGAIN) in f2fs_ioc_flush_device()
3293 else if (ret < 0) in f2fs_ioc_flush_device()
3322 if (IS_ERR(transfer_to[PRJQUOTA])) in f2fs_transfer_project_quota()
3326 if (err) in f2fs_transfer_project_quota()
3340 if (!f2fs_sb_has_project_quota(sbi)) { in f2fs_ioc_setproject()
3341 if (projid != F2FS_DEF_PROJID) in f2fs_ioc_setproject()
3347 if (!f2fs_has_extra_attr(inode)) in f2fs_ioc_setproject()
3352 if (projid_eq(kprojid, fi->i_projid)) in f2fs_ioc_setproject()
3357 if (IS_NOQUOTA(inode)) in f2fs_ioc_setproject()
3360 if (!F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid)) in f2fs_ioc_setproject()
3364 if (err) in f2fs_ioc_setproject()
3369 if (err) in f2fs_ioc_setproject()
3387 if (projid != F2FS_DEF_PROJID) in f2fs_ioc_setproject()
3399 if (IS_ENCRYPTED(inode)) in f2fs_fileattr_get()
3401 if (IS_VERITY(inode)) in f2fs_fileattr_get()
3403 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) in f2fs_fileattr_get()
3405 if (is_inode_flag_set(inode, FI_PIN_FILE)) in f2fs_fileattr_get()
3410 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode))) in f2fs_fileattr_get()
3424 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_fileattr_set()
3426 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode))) in f2fs_fileattr_set()
3428 if (fsflags & ~F2FS_GETTABLE_FS_FL) in f2fs_fileattr_set()
3431 if (!fa->flags_valid) in f2fs_fileattr_set()
3435 if (f2fs_mask_flags(inode->i_mode, iflags) != iflags) in f2fs_fileattr_set()
3439 if (!err) in f2fs_fileattr_set()
3450 if (IS_DEVICE_ALIASING(inode)) in f2fs_pin_file_control()
3453 if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) { in f2fs_pin_file_control()
3461 if (inc) in f2fs_pin_file_control()
3474 if (get_user(pin, (__u32 __user *)arg)) in f2fs_ioc_set_pin_file()
3477 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_set_pin_file()
3480 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_set_pin_file()
3483 if (!pin && IS_DEVICE_ALIASING(inode)) in f2fs_ioc_set_pin_file()
3487 if (ret) in f2fs_ioc_set_pin_file()
3492 if (f2fs_is_atomic_file(inode)) { in f2fs_ioc_set_pin_file()
3497 if (!pin) { in f2fs_ioc_set_pin_file()
3501 } else if (f2fs_is_pinned_file(inode)) { in f2fs_ioc_set_pin_file()
3505 if (F2FS_HAS_BLOCKS(inode)) { in f2fs_ioc_set_pin_file()
3511 if (!f2fs_sb_has_blkzoned(sbi) && in f2fs_ioc_set_pin_file()
3517 if (f2fs_pin_file_control(inode, false)) { in f2fs_ioc_set_pin_file()
3523 if (ret) in f2fs_ioc_set_pin_file()
3526 if (!f2fs_disable_compressed_file(inode)) { in f2fs_ioc_set_pin_file()
3546 if (is_inode_flag_set(inode, FI_PIN_FILE)) in f2fs_ioc_get_pin_file()
3562 if (get_user(level, (__u32 __user *)arg)) in f2fs_ioc_io_prio()
3565 if (!S_ISREG(inode->i_mode) || level >= F2FS_IOPRIO_MAX) in f2fs_ioc_io_prio()
3582 if (is_inode_flag_set(inode, FI_NO_EXTENT)) in f2fs_precache_extents()
3599 if (err || !map.m_len) in f2fs_precache_extents()
3618 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_resize_fs()
3621 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_resize_fs()
3624 if (copy_from_user(&block_count, (void __user *)arg, in f2fs_ioc_resize_fs()
3637 if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) { in f2fs_ioc_enable_verity()
3649 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_measure_verity()
3657 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_read_verity_metadata()
3672 if (!vbuf) in f2fs_ioc_getfslabel()
3681 if (copy_to_user((char __user *)arg, vbuf, in f2fs_ioc_getfslabel()
3696 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_setfslabel()
3700 if (IS_ERR(vbuf)) in f2fs_ioc_setfslabel()
3704 if (err) in f2fs_ioc_setfslabel()
3727 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_get_compress_blocks()
3730 if (!f2fs_compressed_file(inode)) in f2fs_get_compress_blocks()
3745 if (ret < 0) in f2fs_ioc_get_compress_blocks()
3763 if (!__is_valid_data_blkaddr(blkaddr)) in release_compress_blocks()
3765 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr, in release_compress_blocks()
3776 if (i == 0) { in release_compress_blocks()
3777 if (blkaddr == COMPRESS_ADDR) in release_compress_blocks()
3783 if (__is_valid_data_blkaddr(blkaddr)) in release_compress_blocks()
3786 if (blkaddr != NEW_ADDR) in release_compress_blocks()
3814 if (!f2fs_sb_has_compression(sbi)) in f2fs_release_compress_blocks()
3817 if (f2fs_readonly(sbi->sb)) in f2fs_release_compress_blocks()
3821 if (ret) in f2fs_release_compress_blocks()
3829 if ((filp->f_mode & FMODE_WRITE && writecount != 1) || in f2fs_release_compress_blocks()
3835 if (!f2fs_compressed_file(inode) || in f2fs_release_compress_blocks()
3842 if (ret) in f2fs_release_compress_blocks()
3845 if (!atomic_read(&fi->i_compr_blocks)) { in f2fs_release_compress_blocks()
3867 if (ret) { in f2fs_release_compress_blocks()
3869 if (ret == -ENOENT) { in f2fs_release_compress_blocks()
3888 if (ret < 0) in f2fs_release_compress_blocks()
3898 if (released_blocks) in f2fs_release_compress_blocks()
3904 if (ret >= 0) { in f2fs_release_compress_blocks()
3906 } else if (released_blocks && in f2fs_release_compress_blocks()
3932 if (!__is_valid_data_blkaddr(blkaddr)) in reserve_compress_blocks()
3934 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr, in reserve_compress_blocks()
3949 if (i == 0) { in reserve_compress_blocks()
3950 if (blkaddr != COMPRESS_ADDR) { in reserve_compress_blocks()
3962 if (blkaddr == NEW_ADDR) { in reserve_compress_blocks()
3966 if (__is_valid_data_blkaddr(blkaddr)) { in reserve_compress_blocks()
3975 if (reserved && to_reserved == 1) { in reserve_compress_blocks()
3982 if (unlikely(ret)) in reserve_compress_blocks()
3986 if (f2fs_data_blkaddr(dn) == NULL_ADDR) in reserve_compress_blocks()
4009 if (!f2fs_sb_has_compression(sbi)) in f2fs_reserve_compress_blocks()
4012 if (f2fs_readonly(sbi->sb)) in f2fs_reserve_compress_blocks()
4016 if (ret) in f2fs_reserve_compress_blocks()
4023 if (!f2fs_compressed_file(inode) || in f2fs_reserve_compress_blocks()
4029 if (atomic_read(&fi->i_compr_blocks)) in f2fs_reserve_compress_blocks()
4045 if (ret) { in f2fs_reserve_compress_blocks()
4047 if (ret == -ENOENT) { in f2fs_reserve_compress_blocks()
4066 if (ret < 0) in f2fs_reserve_compress_blocks()
4075 if (!ret) { in f2fs_reserve_compress_blocks()
4081 if (reserved_blocks) in f2fs_reserve_compress_blocks()
4086 if (!ret) { in f2fs_reserve_compress_blocks()
4088 } else if (reserved_blocks && in f2fs_reserve_compress_blocks()
4109 if (flags & F2FS_TRIM_FILE_DISCARD) { in f2fs_secure_erase()
4110 if (bdev_max_secure_erase_sectors(bdev)) in f2fs_secure_erase()
4118 if (!ret && (flags & F2FS_TRIM_FILE_ZEROOUT)) { in f2fs_secure_erase()
4119 if (IS_ENCRYPTED(inode)) in f2fs_secure_erase()
4142 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_sec_trim_file()
4145 if (copy_from_user(&range, (struct f2fs_sectrim_range __user *)arg, in f2fs_sec_trim_file()
4149 if (range.flags == 0 || (range.flags & ~F2FS_TRIM_FILE_MASK) || in f2fs_sec_trim_file()
4153 if (((range.flags & F2FS_TRIM_FILE_DISCARD) && in f2fs_sec_trim_file()
4160 if (ret) in f2fs_sec_trim_file()
4164 if (f2fs_is_atomic_file(inode) || f2fs_compressed_file(inode) || in f2fs_sec_trim_file()
4170 if (range.len == 0) in f2fs_sec_trim_file()
4173 if (inode->i_size - range.start > range.len) { in f2fs_sec_trim_file()
4181 if (!IS_ALIGNED(range.start, F2FS_BLKSIZE) || in f2fs_sec_trim_file()
4191 if (ret) in f2fs_sec_trim_file()
4199 if (ret) in f2fs_sec_trim_file()
4212 if (ret) { in f2fs_sec_trim_file()
4213 if (ret == -ENOENT) { in f2fs_sec_trim_file()
4226 if (!__is_valid_data_blkaddr(blkaddr)) in f2fs_sec_trim_file()
4229 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, in f2fs_sec_trim_file()
4237 if (f2fs_is_multi_device(sbi)) { in f2fs_sec_trim_file()
4243 if (len) { in f2fs_sec_trim_file()
4244 if (prev_bdev == cur_bdev && in f2fs_sec_trim_file()
4252 if (ret) { in f2fs_sec_trim_file()
4261 if (!len) { in f2fs_sec_trim_file()
4271 if (fatal_signal_pending(current)) { in f2fs_sec_trim_file()
4278 if (len) in f2fs_sec_trim_file()
4297 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_ioc_get_compress_option()
4302 if (!f2fs_compressed_file(inode)) { in f2fs_ioc_get_compress_option()
4312 if (copy_to_user((struct f2fs_comp_option __user *)arg, &option, in f2fs_ioc_get_compress_option()
4327 if (!f2fs_sb_has_compression(sbi)) in f2fs_ioc_set_compress_option()
4330 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_set_compress_option()
4333 if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, in f2fs_ioc_set_compress_option()
4337 if (option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || in f2fs_ioc_set_compress_option()
4343 if (ret) in f2fs_ioc_set_compress_option()
4348 if (!f2fs_compressed_file(inode)) { in f2fs_ioc_set_compress_option()
4353 if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { in f2fs_ioc_set_compress_option()
4358 if (F2FS_HAS_BLOCKS(inode)) { in f2fs_ioc_set_compress_option()
4367 if (fi->i_compress_algorithm == COMPRESS_ZSTD) in f2fs_ioc_set_compress_option()
4372 if (option.algorithm == F2FS_OPTION(sbi).compress_algorithm && in f2fs_ioc_set_compress_option()
4377 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_ioc_set_compress_option()
4400 if (IS_ERR(folio)) { in redirty_blocks()
4434 if (!f2fs_sb_has_compression(sbi) || in f2fs_ioc_decompress_file()
4438 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_decompress_file()
4444 if (ret) in f2fs_ioc_decompress_file()
4448 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_ioc_decompress_file()
4453 if (!f2fs_compressed_file(inode) || in f2fs_ioc_decompress_file()
4460 if (ret) in f2fs_ioc_decompress_file()
4463 if (!atomic_read(&fi->i_compr_blocks)) in f2fs_ioc_decompress_file()
4472 if (!f2fs_is_compressed_cluster(inode, page_idx)) in f2fs_ioc_decompress_file()
4476 if (ret < 0) in f2fs_ioc_decompress_file()
4479 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) { in f2fs_ioc_decompress_file()
4481 if (ret < 0) in f2fs_ioc_decompress_file()
4486 if (fatal_signal_pending(current)) { in f2fs_ioc_decompress_file()
4492 if (!ret) in f2fs_ioc_decompress_file()
4496 if (ret) in f2fs_ioc_decompress_file()
4515 if (!f2fs_sb_has_compression(sbi) || in f2fs_ioc_compress_file()
4519 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_compress_file()
4525 if (ret) in f2fs_ioc_compress_file()
4529 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_ioc_compress_file()
4534 if (!f2fs_compressed_file(inode) || in f2fs_ioc_compress_file()
4541 if (ret) in f2fs_ioc_compress_file()
4552 if (f2fs_is_sparse_cluster(inode, page_idx)) in f2fs_ioc_compress_file()
4556 if (ret < 0) in f2fs_ioc_compress_file()
4559 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) { in f2fs_ioc_compress_file()
4561 if (ret < 0) in f2fs_ioc_compress_file()
4566 if (fatal_signal_pending(current)) { in f2fs_ioc_compress_file()
4572 if (!ret) in f2fs_ioc_compress_file()
4578 if (ret) in f2fs_ioc_compress_file()
4686 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) in f2fs_ioctl()
4688 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp)))) in f2fs_ioctl()
4695 * Return %true if the given read or write request should use direct I/O, or
4696 * %false if it should use buffered I/O.
4703 if (!(iocb->ki_flags & IOCB_DIRECT)) in f2fs_should_use_dio()
4706 if (f2fs_force_buffered_io(inode, iov_iter_rw(iter))) in f2fs_should_use_dio()
4721 if (!IS_ALIGNED(align, i_blocksize(inode)) && in f2fs_should_use_dio()
4734 if (error) in f2fs_dio_read_end_io()
4755 if (count == 0) in f2fs_dio_read_iter()
4760 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_dio_read_iter()
4761 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) { in f2fs_dio_read_iter()
4770 if (f2fs_is_atomic_file(inode)) { in f2fs_dio_read_iter()
4784 if (IS_ERR_OR_NULL(dio)) { in f2fs_dio_read_iter()
4786 if (ret != -EIOCBQUEUED) in f2fs_dio_read_iter()
4807 if (!buf) in f2fs_trace_rw_file_path()
4810 if (IS_ERR(path)) in f2fs_trace_rw_file_path()
4812 if (rw == WRITE) in f2fs_trace_rw_file_path()
4828 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_read_iter()
4831 if (trace_f2fs_dataread_start_enabled()) in f2fs_file_read_iter()
4835 /* In LFS mode, if there is inflight dio, wait for its completion */ in f2fs_file_read_iter()
4836 if (f2fs_lfs_mode(F2FS_I_SB(inode)) && in f2fs_file_read_iter()
4840 if (f2fs_should_use_dio(inode, iocb, to)) { in f2fs_file_read_iter()
4844 if (ret > 0) in f2fs_file_read_iter()
4848 if (trace_f2fs_dataread_end_enabled()) in f2fs_file_read_iter()
4861 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_splice_read()
4864 if (trace_f2fs_dataread_start_enabled()) in f2fs_file_splice_read()
4868 if (ret > 0) in f2fs_file_splice_read()
4872 if (trace_f2fs_dataread_end_enabled()) in f2fs_file_splice_read()
4884 if (IS_IMMUTABLE(inode)) in f2fs_write_checks()
4887 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) in f2fs_write_checks()
4891 if (count <= 0) in f2fs_write_checks()
4895 if (err) in f2fs_write_checks()
4905 * Preallocate blocks for a write request, if it is possible and helpful to do
4906 * so. Returns a positive number if blocks may have been preallocated, 0 if no
4907 * blocks were preallocated, or a negative errno value if something went
4908 * seriously wrong. Also sets FI_PREALLOCATED_ALL on the inode if *all* the
4922 /* If it will be an out-of-place direct write, don't bother. */ in f2fs_preallocate_blocks()
4923 if (dio && f2fs_lfs_mode(sbi)) in f2fs_preallocate_blocks()
4927 * buffered IO, if DIO meets any holes. in f2fs_preallocate_blocks()
4929 if (dio && i_size_read(inode) && in f2fs_preallocate_blocks()
4934 if (iocb->ki_flags & IOCB_NOWAIT) in f2fs_preallocate_blocks()
4937 /* If it will be a short write, don't bother. */ in f2fs_preallocate_blocks()
4938 if (fault_in_iov_iter_readable(iter, count)) in f2fs_preallocate_blocks()
4941 if (f2fs_has_inline_data(inode)) { in f2fs_preallocate_blocks()
4942 /* If the data will fit inline, don't bother. */ in f2fs_preallocate_blocks()
4943 if (pos + count <= MAX_INLINE_DATA(inode)) in f2fs_preallocate_blocks()
4946 if (ret) in f2fs_preallocate_blocks()
4953 if (map.m_len > map.m_lblk) in f2fs_preallocate_blocks()
4958 if (!IS_DEVICE_ALIASING(inode)) in f2fs_preallocate_blocks()
4960 if (dio) { in f2fs_preallocate_blocks()
4971 if (ret < 0 && !((ret == -ENOSPC || ret == -EDQUOT) && map.m_len > 0)) in f2fs_preallocate_blocks()
4973 if (ret == 0) in f2fs_preallocate_blocks()
4985 if (iocb->ki_flags & IOCB_NOWAIT) in f2fs_buffered_write_iter()
4990 if (ret > 0) { in f2fs_buffered_write_iter()
5003 if (error) in f2fs_dio_write_end_io()
5033 if (ret < 0) in f2fs_flush_buffered_write()
5056 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_dio_write_iter()
5058 if (f2fs_has_inline_data(inode) || in f2fs_dio_write_iter()
5064 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) { in f2fs_dio_write_iter()
5068 if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) { in f2fs_dio_write_iter()
5075 if (ret) in f2fs_dio_write_iter()
5079 if (do_opu) in f2fs_dio_write_iter()
5090 if (pos + count > inode->i_size) in f2fs_dio_write_iter()
5094 if (IS_ERR_OR_NULL(dio)) { in f2fs_dio_write_iter()
5096 if (ret == -ENOTBLK) in f2fs_dio_write_iter()
5098 if (ret != -EIOCBQUEUED) in f2fs_dio_write_iter()
5104 if (do_opu) in f2fs_dio_write_iter()
5108 if (ret < 0) in f2fs_dio_write_iter()
5110 if (pos + ret > inode->i_size) in f2fs_dio_write_iter()
5112 if (!do_opu) in f2fs_dio_write_iter()
5115 if (iov_iter_count(from)) { in f2fs_dio_write_iter()
5125 if (iov_iter_count(from)) in f2fs_dio_write_iter()
5127 if (ret2 < 0) in f2fs_dio_write_iter()
5134 if (ret2 > 0) { in f2fs_dio_write_iter()
5165 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) { in f2fs_file_write_iter()
5170 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_file_write_iter()
5175 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_file_write_iter()
5176 if (!inode_trylock(inode)) { in f2fs_file_write_iter()
5184 if (f2fs_is_pinned_file(inode) && in f2fs_file_write_iter()
5191 if (ret <= 0) in f2fs_file_write_iter()
5198 if (dio && f2fs_is_atomic_file(inode)) { in f2fs_file_write_iter()
5206 if (preallocated < 0) { in f2fs_file_write_iter()
5209 if (trace_f2fs_datawrite_start_enabled()) in f2fs_file_write_iter()
5218 if (trace_f2fs_datawrite_end_enabled()) in f2fs_file_write_iter()
5223 if (preallocated && i_size_read(inode) < target_size) { in f2fs_file_write_iter()
5226 if (!f2fs_truncate(inode)) in f2fs_file_write_iter()
5240 if (ret > 0 && may_need_sync) in f2fs_file_write_iter()
5243 /* If buffered IO was forced, flush and drop the data from in f2fs_file_write_iter()
5246 if (ret > 0 && !dio && (iocb->ki_flags & IOCB_DIRECT)) in f2fs_file_write_iter()
5262 if (advice == POSIX_FADV_SEQUENTIAL) { in f2fs_file_fadvise()
5263 if (S_ISFIFO(inode->i_mode)) in f2fs_file_fadvise()
5267 if (!mapping || len < 0) in f2fs_file_fadvise()
5277 } else if (advice == POSIX_FADV_WILLNEED && offset == 0) { in f2fs_file_fadvise()
5283 if (err) in f2fs_file_fadvise()
5286 if (advice == POSIX_FADV_DONTNEED && in f2fs_file_fadvise()
5290 else if (advice == POSIX_FADV_NOREUSE) in f2fs_file_fadvise()
5314 if (err) in f2fs_compat_ioc_gc_range()
5340 if (err) in f2fs_compat_ioc_move_range()
5348 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file))))) in f2fs_compat_ioctl()
5350 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(file)))) in f2fs_compat_ioctl()