Lines Matching full:if
43 if (old_size >= new_size) in f2fs_zero_post_eof_page()
46 if (mapping_empty(inode->i_mapping)) in f2fs_zero_post_eof_page()
49 if (lock) in f2fs_zero_post_eof_page()
53 if (lock) in f2fs_zero_post_eof_page()
64 if (ret & VM_FAULT_LOCKED) in f2fs_filemap_fault()
83 if (unlikely(IS_IMMUTABLE(inode))) in f2fs_vm_page_mkwrite()
86 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) { in f2fs_vm_page_mkwrite()
91 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_vm_page_mkwrite()
96 if (!f2fs_is_checkpoint_ready(sbi)) { in f2fs_vm_page_mkwrite()
102 if (err) in f2fs_vm_page_mkwrite()
106 if (f2fs_compressed_file(inode)) { in f2fs_vm_page_mkwrite()
109 if (ret < 0) { in f2fs_vm_page_mkwrite()
112 } else if (ret) { in f2fs_vm_page_mkwrite()
118 if (need_alloc) in f2fs_vm_page_mkwrite()
131 if (unlikely(folio->mapping != inode->i_mapping || in f2fs_vm_page_mkwrite()
140 if (need_alloc) { in f2fs_vm_page_mkwrite()
146 if (f2fs_is_pinned_file(inode) && in f2fs_vm_page_mkwrite()
151 if (err) { in f2fs_vm_page_mkwrite()
162 * check to see if the page is mapped already (no holes) in f2fs_vm_page_mkwrite()
164 if (folio_test_mappedtodisk(folio)) in f2fs_vm_page_mkwrite()
168 if (((loff_t)(folio->index + 1) << PAGE_SHIFT) > in f2fs_vm_page_mkwrite()
206 if (!dentry) in get_parent_ino()
219 if (!S_ISREG(inode->i_mode)) in need_do_checkpoint()
221 else if (f2fs_compressed_file(inode)) in need_do_checkpoint()
223 else if (inode->i_nlink != 1) in need_do_checkpoint()
225 else if (is_sbi_flag_set(sbi, SBI_NEED_CP)) in need_do_checkpoint()
227 else if (file_wrong_pino(inode)) in need_do_checkpoint()
229 else if (!f2fs_space_for_roll_forward(sbi)) in need_do_checkpoint()
231 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) in need_do_checkpoint()
233 else if (test_opt(sbi, FASTBOOT)) in need_do_checkpoint()
235 else if (F2FS_OPTION(sbi).active_logs == 2) in need_do_checkpoint()
237 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT && in need_do_checkpoint()
242 else if (f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino, in need_do_checkpoint()
254 if ((!IS_ERR(i) && folio_test_dirty(i)) || in need_inode_page_update()
267 if (file_wrong_pino(inode) && inode->i_nlink == 1 && in try_to_fix_pino()
289 if (unlikely(f2fs_readonly(inode->i_sb))) in f2fs_do_sync_file()
294 if (S_ISDIR(inode->i_mode)) in f2fs_do_sync_file()
297 /* if fdatasync is triggered, let's do in-place-update */ in f2fs_do_sync_file()
298 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks) in f2fs_do_sync_file()
303 if (ret || is_sbi_flag_set(sbi, SBI_CP_DISABLED)) { in f2fs_do_sync_file()
308 /* if the inode is dirty, let's recover all the time */ in f2fs_do_sync_file()
309 if (!f2fs_skip_inode_update(inode, datasync)) { in f2fs_do_sync_file()
315 * if there is no written data, don't waste time to write recovery info. in f2fs_do_sync_file()
317 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) && in f2fs_do_sync_file()
321 if (need_inode_page_update(sbi, ino)) in f2fs_do_sync_file()
324 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) || in f2fs_do_sync_file()
337 if (F2FS_OPTION(sbi).fsync_mode == in f2fs_do_sync_file()
350 if (cp_reason) { in f2fs_do_sync_file()
367 if (ret) in f2fs_do_sync_file()
370 /* if cp_error was enabled, we should avoid infinite loop */ in f2fs_do_sync_file()
371 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_do_sync_file()
376 if (f2fs_need_inode_block_update(sbi, ino)) { in f2fs_do_sync_file()
383 * If it's atomic_write, it's just fine to keep write ordering. So in f2fs_do_sync_file()
385 * node chain which serializes node blocks. If one of node writes are in f2fs_do_sync_file()
390 if (!atomic) { in f2fs_do_sync_file()
392 if (ret) in f2fs_do_sync_file()
400 if (!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER) in f2fs_do_sync_file()
402 if (!ret) { in f2fs_do_sync_file()
415 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file))))) in f2fs_sync_file()
427 if (f2fs_compressed_file(inode)) { in __found_offset()
436 if (__is_valid_data_blkaddr(blkaddr)) in __found_offset()
438 if (blkaddr == NEW_ADDR && in __found_offset()
441 if (compressed_cluster) in __found_offset()
445 if (compressed_cluster) in __found_offset()
447 if (blkaddr == NULL_ADDR) in __found_offset()
467 if (offset >= isize) in f2fs_seek_block()
471 if (f2fs_has_inline_data(inode)) { in f2fs_seek_block()
472 if (whence == SEEK_HOLE) { in f2fs_seek_block()
475 } else if (whence == SEEK_DATA) { in f2fs_seek_block()
486 if (err && err != -ENOENT) { in f2fs_seek_block()
488 } else if (err == -ENOENT) { in f2fs_seek_block()
490 if (whence == SEEK_DATA) { in f2fs_seek_block()
508 if (__is_valid_data_blkaddr(blkaddr) && in f2fs_seek_block()
515 if (__found_offset(file->f_mapping, &dn, in f2fs_seek_block()
524 if (whence == SEEK_DATA) in f2fs_seek_block()
527 if (whence == SEEK_HOLE && data_ofs > isize) in f2fs_seek_block()
549 if (offset < 0) in f2fs_llseek()
562 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_file_mmap_prepare()
565 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_mmap_prepare()
586 if (opened) in finish_preallocate_blocks()
590 if (is_inode_flag_set(inode, FI_OPENED_FILE)) in finish_preallocate_blocks()
593 if (!file_should_truncate(inode)) in finish_preallocate_blocks()
604 if (ret) in finish_preallocate_blocks()
621 if (err) in f2fs_file_open()
624 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_open()
628 if (err) in f2fs_file_open()
635 if (err) in f2fs_file_open()
639 if (!err) in f2fs_file_open()
663 if (f2fs_compressed_file(dn->inode) && in f2fs_truncate_data_blocks_range()
665 if (compressed_cluster) in f2fs_truncate_data_blocks_range()
672 if (blkaddr == NULL_ADDR) in f2fs_truncate_data_blocks_range()
677 if (__is_valid_data_blkaddr(blkaddr)) { in f2fs_truncate_data_blocks_range()
678 if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE)) in f2fs_truncate_data_blocks_range()
680 if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr, in f2fs_truncate_data_blocks_range()
683 if (compressed_cluster) in f2fs_truncate_data_blocks_range()
687 if (blkstart + blklen == blkaddr) { in f2fs_truncate_data_blocks_range()
695 if (!released || blkaddr != COMPRESS_ADDR) in f2fs_truncate_data_blocks_range()
701 if (blklen) in f2fs_truncate_data_blocks_range()
708 if (blklen) in f2fs_truncate_data_blocks_range()
711 if (compressed_cluster) in f2fs_truncate_data_blocks_range()
714 if (nr_free) { in f2fs_truncate_data_blocks_range()
741 if (!offset && !cache_only) in truncate_partial_data_page()
744 if (cache_only) { in truncate_partial_data_page()
746 if (IS_ERR(folio)) in truncate_partial_data_page()
748 if (folio_test_uptodate(folio)) in truncate_partial_data_page()
755 if (IS_ERR(folio)) in truncate_partial_data_page()
763 if (!cache_only) in truncate_partial_data_page()
780 if (IS_DEVICE_ALIASING(inode) && from) { in f2fs_do_truncate_blocks()
787 if (free_from >= max_file_blocks(inode)) in f2fs_do_truncate_blocks()
790 if (lock) in f2fs_do_truncate_blocks()
794 if (IS_ERR(ifolio)) { in f2fs_do_truncate_blocks()
799 if (IS_DEVICE_ALIASING(inode)) { in f2fs_do_truncate_blocks()
812 if (f2fs_has_inline_data(inode)) { in f2fs_do_truncate_blocks()
821 if (err) { in f2fs_do_truncate_blocks()
822 if (err == -ENOENT) in f2fs_do_truncate_blocks()
832 if (dn.ofs_in_node || IS_INODE(dn.node_folio)) { in f2fs_do_truncate_blocks()
841 if (lock) in f2fs_do_truncate_blocks()
845 if (!err) in f2fs_do_truncate_blocks()
862 if (f2fs_compressed_file(inode)) in f2fs_truncate_blocks()
868 if (err) in f2fs_truncate_blocks()
876 if (f2fs_compressed_file(inode) && !free_from in f2fs_truncate_blocks()
880 if (from != free_from) { in f2fs_truncate_blocks()
882 if (err) in f2fs_truncate_blocks()
894 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_truncate()
897 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || in f2fs_truncate()
903 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) in f2fs_truncate()
907 if (err) in f2fs_truncate()
911 if (!f2fs_may_inline_data(inode)) { in f2fs_truncate()
913 if (err) { in f2fs_truncate()
926 if (err) in f2fs_truncate()
938 if (!fscrypt_dio_supported(inode)) in f2fs_force_buffered_io()
940 if (fsverity_active(inode)) in f2fs_force_buffered_io()
942 if (f2fs_compressed_file(inode)) in f2fs_force_buffered_io()
948 if (f2fs_has_inline_data(inode) && rw == READ) in f2fs_force_buffered_io()
951 /* disallow direct IO if any of devices has unaligned blksize */ in f2fs_force_buffered_io()
952 if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize) in f2fs_force_buffered_io()
958 if (f2fs_sb_has_blkzoned(sbi) && (rw == WRITE) && in f2fs_force_buffered_io()
961 if (is_sbi_flag_set(sbi, SBI_CP_DISABLED)) in f2fs_force_buffered_io()
975 if (f2fs_has_extra_attr(inode) && in f2fs_getattr()
984 * Return the DIO alignment restrictions if requested. We only return in f2fs_getattr()
986 * take a fair bit of work to get if the file wasn't opened recently. in f2fs_getattr()
991 if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->i_mode)) { in f2fs_getattr()
995 if (!f2fs_force_buffered_io(inode, WRITE)) { in f2fs_getattr()
1002 if (flags & F2FS_COMPR_FL) in f2fs_getattr()
1004 if (flags & F2FS_APPEND_FL) in f2fs_getattr()
1006 if (IS_ENCRYPTED(inode)) in f2fs_getattr()
1008 if (flags & F2FS_IMMUTABLE_FL) in f2fs_getattr()
1010 if (flags & F2FS_NODUMP_FL) in f2fs_getattr()
1012 if (IS_VERITY(inode)) in f2fs_getattr()
1025 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) || in f2fs_getattr()
1040 if (ia_valid & ATTR_ATIME) in __setattr_copy()
1042 if (ia_valid & ATTR_MTIME) in __setattr_copy()
1044 if (ia_valid & ATTR_CTIME) in __setattr_copy()
1046 if (ia_valid & ATTR_MODE) { in __setattr_copy()
1049 if (!in_group_or_capable(idmap, inode, i_gid_into_vfsgid(idmap, inode))) in __setattr_copy()
1066 if (unlikely(f2fs_cp_error(sbi))) in f2fs_setattr()
1070 if (err) in f2fs_setattr()
1074 if (err) in f2fs_setattr()
1078 if (err) in f2fs_setattr()
1081 if (unlikely(IS_IMMUTABLE(inode))) in f2fs_setattr()
1084 if (unlikely(IS_APPEND(inode) && in f2fs_setattr()
1089 if ((attr->ia_valid & ATTR_SIZE)) { in f2fs_setattr()
1090 if (!f2fs_is_compress_backend_ready(inode) || in f2fs_setattr()
1093 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) && in f2fs_setattr()
1103 if (f2fs_is_pinned_file(inode) && in f2fs_setattr()
1110 if (is_quota_modification(idmap, inode, attr)) { in f2fs_setattr()
1112 if (err) in f2fs_setattr()
1115 if (i_uid_needs_update(idmap, attr, inode) || in f2fs_setattr()
1119 if (err) { in f2fs_setattr()
1134 if (attr->ia_valid & ATTR_SIZE) { in f2fs_setattr()
1137 if (attr->ia_size > MAX_INLINE_DATA(inode)) { in f2fs_setattr()
1143 if (err) in f2fs_setattr()
1151 if (attr->ia_size < old_size) in f2fs_setattr()
1157 if (attr->ia_size > old_size) in f2fs_setattr()
1161 if (attr->ia_size <= old_size) in f2fs_setattr()
1164 * do not trim all blocks after i_size if target size is in f2fs_setattr()
1169 if (err) in f2fs_setattr()
1180 if (attr->ia_valid & ATTR_MODE) { in f2fs_setattr()
1183 if (is_inode_flag_set(inode, FI_ACL_MODE)) { in f2fs_setattr()
1184 if (!err) in f2fs_setattr()
1216 if (!len) in fill_zero()
1225 if (IS_ERR(folio)) in fill_zero()
1245 if (err) { in f2fs_truncate_hole()
1246 if (err == -ENOENT) { in f2fs_truncate_hole()
1274 if (ret) in f2fs_punch_hole()
1285 if (pg_start == pg_end) { in f2fs_punch_hole()
1288 if (ret) in f2fs_punch_hole()
1291 if (off_start) { in f2fs_punch_hole()
1294 if (ret) in f2fs_punch_hole()
1297 if (off_end) { in f2fs_punch_hole()
1299 if (ret) in f2fs_punch_hole()
1303 if (pg_start < pg_end) { in f2fs_punch_hole()
1339 if (ret && ret != -ENOENT) { in __read_out_blkaddrs()
1341 } else if (ret == -ENOENT) { in __read_out_blkaddrs()
1342 if (dn.max_level == 0) in __read_out_blkaddrs()
1356 if (__is_valid_data_blkaddr(*blkaddr) && in __read_out_blkaddrs()
1363 if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) { in __read_out_blkaddrs()
1365 if (f2fs_lfs_mode(sbi)) { in __read_out_blkaddrs()
1379 if (len) in __read_out_blkaddrs()
1392 if (*do_replace == 0) in __roll_back_blkaddrs()
1397 if (ret) { in __roll_back_blkaddrs()
1417 if (blkaddr[i] == NULL_ADDR && !full) { in __clone_blkaddrs()
1422 if (do_replace[i] || blkaddr[i] == NULL_ADDR) { in __clone_blkaddrs()
1430 if (ret) in __clone_blkaddrs()
1434 if (ret) { in __clone_blkaddrs()
1446 if (do_replace[i]) { in __clone_blkaddrs()
1459 if (dst_inode->i_size < new_size) in __clone_blkaddrs()
1469 if (IS_ERR(fsrc)) in __clone_blkaddrs()
1473 if (IS_ERR(fdst)) { in __clone_blkaddrs()
1488 if (ret) in __clone_blkaddrs()
1511 if (!src_blkaddr) in __exchange_data_block()
1517 if (!do_replace) { in __exchange_data_block()
1524 if (ret) in __exchange_data_block()
1529 if (ret) in __exchange_data_block()
1580 if (offset + len >= i_size_read(inode)) in f2fs_collapse_range()
1584 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) in f2fs_collapse_range()
1588 if (ret) in f2fs_collapse_range()
1593 if (ret) in f2fs_collapse_range()
1597 if (ret) in f2fs_collapse_range()
1600 /* write out all moved pages, if possible */ in f2fs_collapse_range()
1608 if (!ret) in f2fs_collapse_range()
1623 if (f2fs_data_blkaddr(dn) == NULL_ADDR) in f2fs_do_zero_range()
1629 if (ret) in f2fs_do_zero_range()
1639 if (dn->data_blkaddr == NULL_ADDR) { in f2fs_do_zero_range()
1644 if (dn->data_blkaddr == NEW_ADDR) in f2fs_do_zero_range()
1647 if (!f2fs_is_valid_blkaddr(sbi, dn->data_blkaddr, in f2fs_do_zero_range()
1674 if (ret) in f2fs_zero_range()
1678 if (ret) in f2fs_zero_range()
1682 if (ret) in f2fs_zero_range()
1693 if (pg_start == pg_end) { in f2fs_zero_range()
1696 if (ret) in f2fs_zero_range()
1701 if (off_start) { in f2fs_zero_range()
1704 if (ret) in f2fs_zero_range()
1727 if (ret) { in f2fs_zero_range()
1746 if (ret) in f2fs_zero_range()
1754 if (off_end) { in f2fs_zero_range()
1756 if (ret) in f2fs_zero_range()
1764 if (new_size > i_size_read(inode)) { in f2fs_zero_range()
1765 if (mode & FALLOC_FL_KEEP_SIZE) in f2fs_zero_range()
1783 if (ret) in f2fs_insert_range()
1786 if (offset >= i_size_read(inode)) in f2fs_insert_range()
1790 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1)) in f2fs_insert_range()
1794 if (ret) in f2fs_insert_range()
1802 if (ret) in f2fs_insert_range()
1807 if (ret) in f2fs_insert_range()
1824 if (nr > delta) in f2fs_insert_range()
1837 if (ret) in f2fs_insert_range()
1840 /* write out all moved pages, if possible */ in f2fs_insert_range()
1846 if (!ret) in f2fs_insert_range()
1870 if (err) in f2fs_expand_inode_data()
1874 if (err) in f2fs_expand_inode_data()
1887 if (off_end) in f2fs_expand_inode_data()
1890 if (!map.m_len) in f2fs_expand_inode_data()
1893 if (f2fs_is_pinned_file(inode)) { in f2fs_expand_inode_data()
1901 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { in f2fs_expand_inode_data()
1902 if (has_not_enough_free_secs(sbi, 0, 0)) { in f2fs_expand_inode_data()
1913 if (has_not_enough_free_secs(sbi, 0, in f2fs_expand_inode_data()
1918 if (err && err != -ENODATA) { in f2fs_expand_inode_data()
1925 if (err) { in f2fs_expand_inode_data()
1939 if (!err && sec_len) in f2fs_expand_inode_data()
1948 if (err) { in f2fs_expand_inode_data()
1951 if (!expanded) in f2fs_expand_inode_data()
1963 if (new_size > i_size_read(inode)) { in f2fs_expand_inode_data()
1964 if (mode & FALLOC_FL_KEEP_SIZE) in f2fs_expand_inode_data()
1979 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_fallocate()
1981 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode))) in f2fs_fallocate()
1983 if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode)) in f2fs_fallocate()
1987 if (!S_ISREG(inode->i_mode)) in f2fs_fallocate()
1990 if (IS_ENCRYPTED(inode) && in f2fs_fallocate()
1994 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | in f2fs_fallocate()
2005 if ((f2fs_compressed_file(inode) || f2fs_is_pinned_file(inode)) && in f2fs_fallocate()
2013 if (ret) in f2fs_fallocate()
2022 if (mode & FALLOC_FL_PUNCH_HOLE) { in f2fs_fallocate()
2023 if (offset >= inode->i_size) in f2fs_fallocate()
2027 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) { in f2fs_fallocate()
2029 } else if (mode & FALLOC_FL_ZERO_RANGE) { in f2fs_fallocate()
2031 } else if (mode & FALLOC_FL_INSERT_RANGE) { in f2fs_fallocate()
2037 if (!ret) { in f2fs_fallocate()
2052 if (atomic_dec_and_test(&F2FS_I(inode)->open_count)) in f2fs_release_file()
2059 if (!(filp->f_mode & FMODE_WRITE) || in f2fs_release_file()
2075 * If the process doing a transaction is crashed, we should do in f2fs_file_flush()
2080 if (F2FS_I(inode)->atomic_write_task == current && in f2fs_file_flush()
2099 if (IS_NOQUOTA(inode)) in f2fs_setflags_common()
2102 if ((iflags ^ masked_flags) & F2FS_CASEFOLD_FL) { in f2fs_setflags_common()
2103 if (!f2fs_sb_has_casefold(F2FS_I_SB(inode))) in f2fs_setflags_common()
2105 if (!f2fs_empty_dir(inode)) in f2fs_setflags_common()
2109 if (iflags & (F2FS_COMPR_FL | F2FS_NOCOMP_FL)) { in f2fs_setflags_common()
2110 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_setflags_common()
2112 if ((iflags & F2FS_COMPR_FL) && (iflags & F2FS_NOCOMP_FL)) in f2fs_setflags_common()
2116 if ((iflags ^ masked_flags) & F2FS_COMPR_FL) { in f2fs_setflags_common()
2117 if (masked_flags & F2FS_COMPR_FL) { in f2fs_setflags_common()
2118 if (!f2fs_disable_compressed_file(inode)) in f2fs_setflags_common()
2123 if (err) in f2fs_setflags_common()
2127 if (!f2fs_may_compress(inode) || in f2fs_setflags_common()
2136 if (err) in f2fs_setflags_common()
2145 if (fi->i_flags & F2FS_PROJINHERIT_FL) in f2fs_setflags_common()
2221 if (iflags & f2fs_fsflags_map[i].iflag) in f2fs_iflags_to_fsflags()
2234 if (fsflags & f2fs_fsflags_map[i].fsflag) in f2fs_fsflags_to_iflags()
2256 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_start_atomic_write()
2259 if (!inode_owner_or_capable(idmap, inode)) in f2fs_ioc_start_atomic_write()
2262 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_start_atomic_write()
2265 if (filp->f_flags & O_DIRECT) in f2fs_ioc_start_atomic_write()
2269 if (ret) in f2fs_ioc_start_atomic_write()
2274 if (!f2fs_disable_compressed_file(inode) || in f2fs_ioc_start_atomic_write()
2280 if (f2fs_is_atomic_file(inode)) in f2fs_ioc_start_atomic_write()
2284 if (ret) in f2fs_ioc_start_atomic_write()
2294 if (get_dirty_pages(inode)) in f2fs_ioc_start_atomic_write()
2298 if (ret) in f2fs_ioc_start_atomic_write()
2301 /* Check if the inode already has a COW inode */ in f2fs_ioc_start_atomic_write()
2302 if (fi->cow_inode == NULL) { in f2fs_ioc_start_atomic_write()
2308 if (ret) in f2fs_ioc_start_atomic_write()
2323 if (ret) in f2fs_ioc_start_atomic_write()
2335 if (truncate) { in f2fs_ioc_start_atomic_write()
2346 if (ret) in f2fs_ioc_start_atomic_write()
2365 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_commit_atomic_write()
2368 if (!inode_owner_or_capable(idmap, inode)) in f2fs_ioc_commit_atomic_write()
2372 if (ret) in f2fs_ioc_commit_atomic_write()
2379 if (f2fs_is_atomic_file(inode)) { in f2fs_ioc_commit_atomic_write()
2381 if (!ret) in f2fs_ioc_commit_atomic_write()
2400 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_abort_atomic_write()
2403 if (!inode_owner_or_capable(idmap, inode)) in f2fs_ioc_abort_atomic_write()
2407 if (ret) in f2fs_ioc_abort_atomic_write()
2430 if (ret) in f2fs_do_shutdown()
2438 if (ret) { in f2fs_do_shutdown()
2439 if (ret == -EIO) in f2fs_do_shutdown()
2458 if (ret == -EIO) in f2fs_do_shutdown()
2466 if (readonly) in f2fs_do_shutdown()
2473 if (need_lock) in f2fs_do_shutdown()
2482 if (need_lock) in f2fs_do_shutdown()
2501 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_shutdown()
2504 if (get_user(in, (__u32 __user *)arg)) in f2fs_ioc_shutdown()
2507 if (in != F2FS_GOING_DOWN_FULLSYNC) { in f2fs_ioc_shutdown()
2509 if (ret) { in f2fs_ioc_shutdown()
2510 if (ret != -EROFS) in f2fs_ioc_shutdown()
2523 if (need_drop) in f2fs_ioc_shutdown()
2537 if (!S_ISREG(inode->i_mode)) in f2fs_keep_noreuse_range()
2540 if (offset >= max_bytes || len > max_bytes || in f2fs_keep_noreuse_range()
2548 if (f2fs_is_atomic_file(inode)) { in f2fs_keep_noreuse_range()
2554 /* let's remove the range, if len = 0 */ in f2fs_keep_noreuse_range()
2555 if (!len) { in f2fs_keep_noreuse_range()
2556 if (!list_empty(&F2FS_I(inode)->gdonate_list)) { in f2fs_keep_noreuse_range()
2559 if (is_inode_flag_set(inode, FI_DONATE_FINISHED)) in f2fs_keep_noreuse_range()
2566 if (list_empty(&F2FS_I(inode)->gdonate_list)) { in f2fs_keep_noreuse_range()
2591 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_fitrim()
2594 if (!f2fs_hw_support_discard(F2FS_SB(sb))) in f2fs_ioc_fitrim()
2597 if (copy_from_user(&range, (struct fstrim_range __user *)arg, in f2fs_ioc_fitrim()
2602 if (ret) in f2fs_ioc_fitrim()
2609 if (ret < 0) in f2fs_ioc_fitrim()
2612 if (copy_to_user((struct fstrim_range __user *)arg, &range, in f2fs_ioc_fitrim()
2624 if (u[i]) in uuid_is_nonzero()
2634 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode))) in f2fs_ioc_set_encryption_policy()
2644 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_policy()
2656 if (!f2fs_sb_has_encrypt(sbi)) in f2fs_ioc_get_encryption_pwsalt()
2660 if (err) in f2fs_ioc_get_encryption_pwsalt()
2665 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt)) in f2fs_ioc_get_encryption_pwsalt()
2672 if (err) { in f2fs_ioc_get_encryption_pwsalt()
2683 if (!err && copy_to_user((__u8 __user *)arg, encrypt_pw_salt, 16)) in f2fs_ioc_get_encryption_pwsalt()
2692 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_policy_ex()
2700 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_add_encryption_key()
2708 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_remove_encryption_key()
2717 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_remove_encryption_key_all_users()
2726 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_key_status()
2734 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_get_encryption_nonce()
2751 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_gc()
2754 if (get_user(sync, (__u32 __user *)arg)) in f2fs_ioc_gc()
2757 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_gc()
2761 if (ret) in f2fs_ioc_gc()
2764 if (!sync) { in f2fs_ioc_gc()
2765 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in f2fs_ioc_gc()
2794 if (!capable(CAP_SYS_ADMIN)) in __f2fs_ioc_gc_range()
2796 if (f2fs_readonly(sbi->sb)) in __f2fs_ioc_gc_range()
2800 if (end < range->start || range->start < MAIN_BLKADDR(sbi) || in __f2fs_ioc_gc_range()
2805 if (ret) in __f2fs_ioc_gc_range()
2809 if (!range->sync) { in __f2fs_ioc_gc_range()
2810 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in __f2fs_ioc_gc_range()
2821 if (ret) { in __f2fs_ioc_gc_range()
2822 if (ret == -EBUSY) in __f2fs_ioc_gc_range()
2827 if (range->start <= end) in __f2fs_ioc_gc_range()
2838 if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg, in f2fs_ioc_gc_range()
2850 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_write_checkpoint()
2853 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_write_checkpoint()
2856 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) { in f2fs_ioc_write_checkpoint()
2862 if (ret) in f2fs_ioc_write_checkpoint()
2894 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) || in f2fs_defragment_range()
2900 /* if in-place-update policy is enabled, don't waste time here */ in f2fs_defragment_range()
2902 if (f2fs_should_update_inplace(inode, NULL)) { in f2fs_defragment_range()
2911 if (err) in f2fs_defragment_range()
2915 * lookup mapping info in extent cache, skip defragmenting if physical in f2fs_defragment_range()
2918 if (f2fs_lookup_read_extent_cache(inode, pg_start, &ei)) { in f2fs_defragment_range()
2919 if ((pgoff_t)ei.fofs + ei.len >= pg_end) in f2fs_defragment_range()
2927 * lookup mapping info in dnode page cache, skip defragmenting if all in f2fs_defragment_range()
2928 * physical block addresses are continuous even if there are hole(s) in f2fs_defragment_range()
2934 if (err) in f2fs_defragment_range()
2937 if (!(map.m_flags & F2FS_MAP_FLAGS)) { in f2fs_defragment_range()
2942 if (blk_end && blk_end != map.m_pblk) in f2fs_defragment_range()
2953 if (!fragmented) { in f2fs_defragment_range()
2965 if (has_not_enough_free_secs(sbi, 0, sec_num)) { in f2fs_defragment_range()
2981 if (err) in f2fs_defragment_range()
2984 if (!(map.m_flags & F2FS_MAP_FLAGS)) { in f2fs_defragment_range()
2997 if (IS_ERR(folio)) { in f2fs_defragment_range()
3015 if (map.m_lblk < pg_end && cnt < BLKS_PER_SEG(sbi)) in f2fs_defragment_range()
3021 if (err) in f2fs_defragment_range()
3030 if (!err) in f2fs_defragment_range()
3042 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_defragment()
3045 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_defragment()
3048 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_defragment()
3051 if (copy_from_user(&range, (struct f2fs_defragment __user *)arg, in f2fs_ioc_defragment()
3056 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1)) in f2fs_ioc_defragment()
3059 if (unlikely((range.start + range.len) >> PAGE_SHIFT > in f2fs_ioc_defragment()
3064 if (err) in f2fs_ioc_defragment()
3070 if (range.len) in f2fs_ioc_defragment()
3072 if (err < 0) in f2fs_ioc_defragment()
3075 if (copy_to_user((struct f2fs_defragment __user *)arg, &range, in f2fs_ioc_defragment()
3092 if (file_in->f_path.mnt != file_out->f_path.mnt || in f2fs_move_file_range()
3096 if (unlikely(f2fs_readonly(src->i_sb))) in f2fs_move_file_range()
3099 if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode)) in f2fs_move_file_range()
3102 if (IS_ENCRYPTED(src) || IS_ENCRYPTED(dst)) in f2fs_move_file_range()
3105 if (pos_out < 0 || pos_in < 0) in f2fs_move_file_range()
3108 if (src == dst) { in f2fs_move_file_range()
3109 if (pos_in == pos_out) in f2fs_move_file_range()
3111 if (pos_out > pos_in && pos_out < pos_in + len) in f2fs_move_file_range()
3116 if (src != dst) { in f2fs_move_file_range()
3118 if (!inode_trylock(dst)) in f2fs_move_file_range()
3122 if (f2fs_compressed_file(src) || f2fs_compressed_file(dst) || in f2fs_move_file_range()
3128 if (f2fs_is_atomic_file(src) || f2fs_is_atomic_file(dst)) { in f2fs_move_file_range()
3134 if (pos_in + len > src->i_size || pos_in + len < pos_in) in f2fs_move_file_range()
3136 if (len == 0) in f2fs_move_file_range()
3138 if (pos_in + len == src->i_size) in f2fs_move_file_range()
3140 if (len == 0) { in f2fs_move_file_range()
3146 if (pos_out + olen > dst->i_size) in f2fs_move_file_range()
3150 if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) || in f2fs_move_file_range()
3156 if (ret) in f2fs_move_file_range()
3160 if (ret) in f2fs_move_file_range()
3166 if (ret) in f2fs_move_file_range()
3171 if (ret) in f2fs_move_file_range()
3177 if (src != dst) { in f2fs_move_file_range()
3179 if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE])) in f2fs_move_file_range()
3188 if (!ret) { in f2fs_move_file_range()
3189 if (dst_max_i_size) in f2fs_move_file_range()
3191 else if (dst_osize != dst->i_size) in f2fs_move_file_range()
3196 if (src != dst) in f2fs_move_file_range()
3200 if (ret) in f2fs_move_file_range()
3205 if (src != dst) { in f2fs_move_file_range()
3212 if (src != dst) in f2fs_move_file_range()
3224 if (!(filp->f_mode & FMODE_READ) || in __f2fs_ioc_move_range()
3229 if (fd_empty(dst)) in __f2fs_ioc_move_range()
3232 if (!(fd_file(dst)->f_mode & FMODE_WRITE)) in __f2fs_ioc_move_range()
3236 if (err) in __f2fs_ioc_move_range()
3250 if (copy_from_user(&range, (struct f2fs_move_range __user *)arg, in f2fs_ioc_move_range()
3271 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_flush_device()
3274 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_flush_device()
3277 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) in f2fs_ioc_flush_device()
3280 if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg, in f2fs_ioc_flush_device()
3284 if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num || in f2fs_ioc_flush_device()
3292 if (ret) in f2fs_ioc_flush_device()
3295 if (range.dev_num != 0) in f2fs_ioc_flush_device()
3300 if (start_segno < dev_start_segno || start_segno >= dev_end_segno) in f2fs_ioc_flush_device()
3305 if (!f2fs_down_write_trylock(&sbi->gc_lock)) { in f2fs_ioc_flush_device()
3316 if (ret == -EAGAIN) in f2fs_ioc_flush_device()
3318 else if (ret < 0) in f2fs_ioc_flush_device()
3347 if (IS_ERR(transfer_to[PRJQUOTA])) in f2fs_transfer_project_quota()
3351 if (err) in f2fs_transfer_project_quota()
3365 if (!f2fs_sb_has_project_quota(sbi)) { in f2fs_ioc_setproject()
3366 if (projid != F2FS_DEF_PROJID) in f2fs_ioc_setproject()
3372 if (!f2fs_has_extra_attr(inode)) in f2fs_ioc_setproject()
3377 if (projid_eq(kprojid, fi->i_projid)) in f2fs_ioc_setproject()
3382 if (IS_NOQUOTA(inode)) in f2fs_ioc_setproject()
3385 if (!F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid)) in f2fs_ioc_setproject()
3389 if (err) in f2fs_ioc_setproject()
3394 if (err) in f2fs_ioc_setproject()
3412 if (projid != F2FS_DEF_PROJID) in f2fs_ioc_setproject()
3424 if (IS_ENCRYPTED(inode)) in f2fs_fileattr_get()
3426 if (IS_VERITY(inode)) in f2fs_fileattr_get()
3428 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) in f2fs_fileattr_get()
3430 if (is_inode_flag_set(inode, FI_PIN_FILE)) in f2fs_fileattr_get()
3435 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode))) in f2fs_fileattr_get()
3449 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) in f2fs_fileattr_set()
3451 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode))) in f2fs_fileattr_set()
3453 if (fsflags & ~F2FS_GETTABLE_FS_FL) in f2fs_fileattr_set()
3456 if (!fa->flags_valid) in f2fs_fileattr_set()
3460 if (f2fs_mask_flags(inode->i_mode, iflags) != iflags) in f2fs_fileattr_set()
3464 if (!err) in f2fs_fileattr_set()
3475 if (IS_DEVICE_ALIASING(inode)) in f2fs_pin_file_control()
3478 if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) { in f2fs_pin_file_control()
3486 if (inc) in f2fs_pin_file_control()
3499 if (get_user(pin, (__u32 __user *)arg)) in f2fs_ioc_set_pin_file()
3502 if (!S_ISREG(inode->i_mode)) in f2fs_ioc_set_pin_file()
3505 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_set_pin_file()
3508 if (!pin && IS_DEVICE_ALIASING(inode)) in f2fs_ioc_set_pin_file()
3512 if (ret) in f2fs_ioc_set_pin_file()
3517 if (f2fs_is_atomic_file(inode)) { in f2fs_ioc_set_pin_file()
3522 if (!pin) { in f2fs_ioc_set_pin_file()
3526 } else if (f2fs_is_pinned_file(inode)) { in f2fs_ioc_set_pin_file()
3530 if (F2FS_HAS_BLOCKS(inode)) { in f2fs_ioc_set_pin_file()
3536 if (!f2fs_sb_has_blkzoned(sbi) && in f2fs_ioc_set_pin_file()
3542 if (f2fs_pin_file_control(inode, false)) { in f2fs_ioc_set_pin_file()
3548 if (ret) in f2fs_ioc_set_pin_file()
3551 if (!f2fs_disable_compressed_file(inode)) { in f2fs_ioc_set_pin_file()
3571 if (is_inode_flag_set(inode, FI_PIN_FILE)) in f2fs_ioc_get_pin_file()
3587 if (get_user(level, (__u32 __user *)arg)) in f2fs_ioc_io_prio()
3590 if (!S_ISREG(inode->i_mode) || level >= F2FS_IOPRIO_MAX) in f2fs_ioc_io_prio()
3607 if (is_inode_flag_set(inode, FI_NO_EXTENT)) in f2fs_precache_extents()
3624 if (err || !map.m_len) in f2fs_precache_extents()
3643 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_resize_fs()
3646 if (f2fs_readonly(sbi->sb)) in f2fs_ioc_resize_fs()
3649 if (copy_from_user(&block_count, (void __user *)arg, in f2fs_ioc_resize_fs()
3662 if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) { in f2fs_ioc_enable_verity()
3674 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_measure_verity()
3682 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp)))) in f2fs_ioc_read_verity_metadata()
3697 if (!vbuf) in f2fs_ioc_getfslabel()
3706 if (copy_to_user((char __user *)arg, vbuf, in f2fs_ioc_getfslabel()
3721 if (!capable(CAP_SYS_ADMIN)) in f2fs_ioc_setfslabel()
3725 if (IS_ERR(vbuf)) in f2fs_ioc_setfslabel()
3729 if (err) in f2fs_ioc_setfslabel()
3752 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_get_compress_blocks()
3755 if (!f2fs_compressed_file(inode)) in f2fs_get_compress_blocks()
3770 if (ret < 0) in f2fs_ioc_get_compress_blocks()
3788 if (!__is_valid_data_blkaddr(blkaddr)) in release_compress_blocks()
3790 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr, in release_compress_blocks()
3801 if (i == 0) { in release_compress_blocks()
3802 if (blkaddr == COMPRESS_ADDR) in release_compress_blocks()
3808 if (__is_valid_data_blkaddr(blkaddr)) in release_compress_blocks()
3811 if (blkaddr != NEW_ADDR) in release_compress_blocks()
3839 if (!f2fs_sb_has_compression(sbi)) in f2fs_release_compress_blocks()
3842 if (f2fs_readonly(sbi->sb)) in f2fs_release_compress_blocks()
3846 if (ret) in f2fs_release_compress_blocks()
3854 if ((filp->f_mode & FMODE_WRITE && writecount != 1) || in f2fs_release_compress_blocks()
3860 if (!f2fs_compressed_file(inode) || in f2fs_release_compress_blocks()
3867 if (ret) in f2fs_release_compress_blocks()
3870 if (!atomic_read(&fi->i_compr_blocks)) { in f2fs_release_compress_blocks()
3892 if (ret) { in f2fs_release_compress_blocks()
3894 if (ret == -ENOENT) { in f2fs_release_compress_blocks()
3913 if (ret < 0) in f2fs_release_compress_blocks()
3923 if (released_blocks) in f2fs_release_compress_blocks()
3929 if (ret >= 0) { in f2fs_release_compress_blocks()
3931 } else if (released_blocks && in f2fs_release_compress_blocks()
3957 if (!__is_valid_data_blkaddr(blkaddr)) in reserve_compress_blocks()
3959 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr, in reserve_compress_blocks()
3974 if (i == 0) { in reserve_compress_blocks()
3975 if (blkaddr != COMPRESS_ADDR) { in reserve_compress_blocks()
3987 if (blkaddr == NEW_ADDR) { in reserve_compress_blocks()
3991 if (__is_valid_data_blkaddr(blkaddr)) { in reserve_compress_blocks()
4000 if (reserved && to_reserved == 1) { in reserve_compress_blocks()
4007 if (unlikely(ret)) in reserve_compress_blocks()
4011 if (f2fs_data_blkaddr(dn) == NULL_ADDR) in reserve_compress_blocks()
4034 if (!f2fs_sb_has_compression(sbi)) in f2fs_reserve_compress_blocks()
4037 if (f2fs_readonly(sbi->sb)) in f2fs_reserve_compress_blocks()
4041 if (ret) in f2fs_reserve_compress_blocks()
4048 if (!f2fs_compressed_file(inode) || in f2fs_reserve_compress_blocks()
4054 if (atomic_read(&fi->i_compr_blocks)) in f2fs_reserve_compress_blocks()
4070 if (ret) { in f2fs_reserve_compress_blocks()
4072 if (ret == -ENOENT) { in f2fs_reserve_compress_blocks()
4091 if (ret < 0) in f2fs_reserve_compress_blocks()
4100 if (!ret) { in f2fs_reserve_compress_blocks()
4106 if (reserved_blocks) in f2fs_reserve_compress_blocks()
4111 if (!ret) { in f2fs_reserve_compress_blocks()
4113 } else if (reserved_blocks && in f2fs_reserve_compress_blocks()
4134 if (flags & F2FS_TRIM_FILE_DISCARD) { in f2fs_secure_erase()
4135 if (bdev_max_secure_erase_sectors(bdev)) in f2fs_secure_erase()
4143 if (!ret && (flags & F2FS_TRIM_FILE_ZEROOUT)) { in f2fs_secure_erase()
4144 if (IS_ENCRYPTED(inode)) in f2fs_secure_erase()
4167 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_sec_trim_file()
4170 if (copy_from_user(&range, (struct f2fs_sectrim_range __user *)arg, in f2fs_sec_trim_file()
4174 if (range.flags == 0 || (range.flags & ~F2FS_TRIM_FILE_MASK) || in f2fs_sec_trim_file()
4178 if (((range.flags & F2FS_TRIM_FILE_DISCARD) && in f2fs_sec_trim_file()
4185 if (ret) in f2fs_sec_trim_file()
4189 if (f2fs_is_atomic_file(inode) || f2fs_compressed_file(inode) || in f2fs_sec_trim_file()
4195 if (range.len == 0) in f2fs_sec_trim_file()
4198 if (inode->i_size - range.start > range.len) { in f2fs_sec_trim_file()
4206 if (!IS_ALIGNED(range.start, F2FS_BLKSIZE) || in f2fs_sec_trim_file()
4216 if (ret) in f2fs_sec_trim_file()
4224 if (ret) in f2fs_sec_trim_file()
4237 if (ret) { in f2fs_sec_trim_file()
4238 if (ret == -ENOENT) { in f2fs_sec_trim_file()
4251 if (!__is_valid_data_blkaddr(blkaddr)) in f2fs_sec_trim_file()
4254 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, in f2fs_sec_trim_file()
4262 if (f2fs_is_multi_device(sbi)) { in f2fs_sec_trim_file()
4268 if (len) { in f2fs_sec_trim_file()
4269 if (prev_bdev == cur_bdev && in f2fs_sec_trim_file()
4277 if (ret) { in f2fs_sec_trim_file()
4286 if (!len) { in f2fs_sec_trim_file()
4296 if (fatal_signal_pending(current)) { in f2fs_sec_trim_file()
4303 if (len) in f2fs_sec_trim_file()
4322 if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) in f2fs_ioc_get_compress_option()
4327 if (!f2fs_compressed_file(inode)) { in f2fs_ioc_get_compress_option()
4337 if (copy_to_user((struct f2fs_comp_option __user *)arg, &option, in f2fs_ioc_get_compress_option()
4352 if (!f2fs_sb_has_compression(sbi)) in f2fs_ioc_set_compress_option()
4355 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_set_compress_option()
4358 if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, in f2fs_ioc_set_compress_option()
4362 if (option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || in f2fs_ioc_set_compress_option()
4368 if (ret) in f2fs_ioc_set_compress_option()
4373 if (!f2fs_compressed_file(inode)) { in f2fs_ioc_set_compress_option()
4378 if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { in f2fs_ioc_set_compress_option()
4383 if (F2FS_HAS_BLOCKS(inode)) { in f2fs_ioc_set_compress_option()
4392 if (fi->i_compress_algorithm == COMPRESS_ZSTD) in f2fs_ioc_set_compress_option()
4397 if (option.algorithm == F2FS_OPTION(sbi).compress_algorithm && in f2fs_ioc_set_compress_option()
4402 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_ioc_set_compress_option()
4425 if (IS_ERR(folio)) { in redirty_blocks()
4459 if (!f2fs_sb_has_compression(sbi) || in f2fs_ioc_decompress_file()
4463 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_decompress_file()
4469 if (ret) in f2fs_ioc_decompress_file()
4473 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_ioc_decompress_file()
4478 if (!f2fs_compressed_file(inode) || in f2fs_ioc_decompress_file()
4485 if (ret) in f2fs_ioc_decompress_file()
4488 if (!atomic_read(&fi->i_compr_blocks)) in f2fs_ioc_decompress_file()
4497 if (!f2fs_is_compressed_cluster(inode, page_idx)) in f2fs_ioc_decompress_file()
4501 if (ret < 0) in f2fs_ioc_decompress_file()
4504 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) { in f2fs_ioc_decompress_file()
4506 if (ret < 0) in f2fs_ioc_decompress_file()
4511 if (fatal_signal_pending(current)) { in f2fs_ioc_decompress_file()
4517 if (!ret) in f2fs_ioc_decompress_file()
4521 if (ret) in f2fs_ioc_decompress_file()
4540 if (!f2fs_sb_has_compression(sbi) || in f2fs_ioc_compress_file()
4544 if (!(filp->f_mode & FMODE_WRITE)) in f2fs_ioc_compress_file()
4550 if (ret) in f2fs_ioc_compress_file()
4554 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_ioc_compress_file()
4559 if (!f2fs_compressed_file(inode) || in f2fs_ioc_compress_file()
4566 if (ret) in f2fs_ioc_compress_file()
4577 if (f2fs_is_sparse_cluster(inode, page_idx)) in f2fs_ioc_compress_file()
4581 if (ret < 0) in f2fs_ioc_compress_file()
4584 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) { in f2fs_ioc_compress_file()
4586 if (ret < 0) in f2fs_ioc_compress_file()
4591 if (fatal_signal_pending(current)) { in f2fs_ioc_compress_file()
4597 if (!ret) in f2fs_ioc_compress_file()
4603 if (ret) in f2fs_ioc_compress_file()
4711 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) in f2fs_ioctl()
4713 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp)))) in f2fs_ioctl()
4720 * Return %true if the given read or write request should use direct I/O, or
4721 * %false if it should use buffered I/O.
4728 if (!(iocb->ki_flags & IOCB_DIRECT)) in f2fs_should_use_dio()
4731 if (f2fs_force_buffered_io(inode, iov_iter_rw(iter))) in f2fs_should_use_dio()
4746 if (!IS_ALIGNED(align, i_blocksize(inode)) && in f2fs_should_use_dio()
4759 if (error) in f2fs_dio_read_end_io()
4780 if (count == 0) in f2fs_dio_read_iter()
4785 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_dio_read_iter()
4786 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) { in f2fs_dio_read_iter()
4795 if (f2fs_is_atomic_file(inode)) { in f2fs_dio_read_iter()
4809 if (IS_ERR_OR_NULL(dio)) { in f2fs_dio_read_iter()
4811 if (ret != -EIOCBQUEUED) in f2fs_dio_read_iter()
4832 if (!buf) in f2fs_trace_rw_file_path()
4835 if (IS_ERR(path)) in f2fs_trace_rw_file_path()
4837 if (rw == WRITE) in f2fs_trace_rw_file_path()
4854 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_read_iter()
4857 if (trace_f2fs_dataread_start_enabled()) in f2fs_file_read_iter()
4863 /* In LFS mode, if there is inflight dio, wait for its completion */ in f2fs_file_read_iter()
4864 if (f2fs_lfs_mode(F2FS_I_SB(inode)) && in f2fs_file_read_iter()
4869 if (dio) { in f2fs_file_read_iter()
4873 if (ret > 0) in f2fs_file_read_iter()
4889 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_file_splice_read()
4892 if (trace_f2fs_dataread_start_enabled()) in f2fs_file_splice_read()
4896 if (ret > 0) in f2fs_file_splice_read()
4911 if (IS_IMMUTABLE(inode)) in f2fs_write_checks()
4914 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) in f2fs_write_checks()
4918 if (count <= 0) in f2fs_write_checks()
4922 if (err) in f2fs_write_checks()
4931 * Preallocate blocks for a write request, if it is possible and helpful to do
4932 * so. Returns a positive number if blocks may have been preallocated, 0 if no
4933 * blocks were preallocated, or a negative errno value if something went
4934 * seriously wrong. Also sets FI_PREALLOCATED_ALL on the inode if *all* the
4948 /* If it will be an out-of-place direct write, don't bother. */ in f2fs_preallocate_blocks()
4949 if (dio && f2fs_lfs_mode(sbi)) in f2fs_preallocate_blocks()
4953 * buffered IO, if DIO meets any holes. in f2fs_preallocate_blocks()
4955 if (dio && i_size_read(inode) && in f2fs_preallocate_blocks()
4960 if (iocb->ki_flags & IOCB_NOWAIT) in f2fs_preallocate_blocks()
4963 /* If it will be a short write, don't bother. */ in f2fs_preallocate_blocks()
4964 if (fault_in_iov_iter_readable(iter, count)) in f2fs_preallocate_blocks()
4967 if (f2fs_has_inline_data(inode)) { in f2fs_preallocate_blocks()
4968 /* If the data will fit inline, don't bother. */ in f2fs_preallocate_blocks()
4969 if (pos + count <= MAX_INLINE_DATA(inode)) in f2fs_preallocate_blocks()
4972 if (ret) in f2fs_preallocate_blocks()
4979 if (map.m_len > map.m_lblk) in f2fs_preallocate_blocks()
4984 if (!IS_DEVICE_ALIASING(inode)) in f2fs_preallocate_blocks()
4986 if (dio) { in f2fs_preallocate_blocks()
4997 if (ret < 0 && !((ret == -ENOSPC || ret == -EDQUOT) && map.m_len > 0)) in f2fs_preallocate_blocks()
4999 if (ret == 0) in f2fs_preallocate_blocks()
5011 if (iocb->ki_flags & IOCB_NOWAIT) in f2fs_buffered_write_iter()
5016 if (ret > 0) { in f2fs_buffered_write_iter()
5029 if (error) in f2fs_dio_write_end_io()
5059 if (ret < 0) in f2fs_flush_buffered_write()
5082 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_dio_write_iter()
5084 if (f2fs_has_inline_data(inode) || in f2fs_dio_write_iter()
5090 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) { in f2fs_dio_write_iter()
5094 if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) { in f2fs_dio_write_iter()
5101 if (ret) in f2fs_dio_write_iter()
5105 if (do_opu) in f2fs_dio_write_iter()
5116 if (pos + count > inode->i_size) in f2fs_dio_write_iter()
5120 if (IS_ERR_OR_NULL(dio)) { in f2fs_dio_write_iter()
5122 if (ret == -ENOTBLK) in f2fs_dio_write_iter()
5124 if (ret != -EIOCBQUEUED) in f2fs_dio_write_iter()
5130 if (do_opu) in f2fs_dio_write_iter()
5134 if (ret < 0) in f2fs_dio_write_iter()
5136 if (pos + ret > inode->i_size) in f2fs_dio_write_iter()
5138 if (!do_opu) in f2fs_dio_write_iter()
5141 if (iov_iter_count(from)) { in f2fs_dio_write_iter()
5151 if (iov_iter_count(from)) in f2fs_dio_write_iter()
5153 if (ret2 < 0) in f2fs_dio_write_iter()
5160 if (ret2 > 0) { in f2fs_dio_write_iter()
5191 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) { in f2fs_file_write_iter()
5196 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_file_write_iter()
5201 if (iocb->ki_flags & IOCB_NOWAIT) { in f2fs_file_write_iter()
5202 if (!inode_trylock(inode)) { in f2fs_file_write_iter()
5210 if (f2fs_is_pinned_file(inode) && in f2fs_file_write_iter()
5217 if (ret <= 0) in f2fs_file_write_iter()
5224 if (dio && f2fs_is_atomic_file(inode)) { in f2fs_file_write_iter()
5232 if (preallocated < 0) { in f2fs_file_write_iter()
5235 if (trace_f2fs_datawrite_start_enabled()) in f2fs_file_write_iter()
5248 if (preallocated && i_size_read(inode) < target_size) { in f2fs_file_write_iter()
5251 if (!f2fs_truncate(inode)) in f2fs_file_write_iter()
5265 if (ret > 0 && may_need_sync) in f2fs_file_write_iter()
5268 /* If buffered IO was forced, flush and drop the data from in f2fs_file_write_iter()
5271 if (ret > 0 && !dio && (iocb->ki_flags & IOCB_DIRECT)) in f2fs_file_write_iter()
5287 if (advice == POSIX_FADV_SEQUENTIAL) { in f2fs_file_fadvise()
5288 if (S_ISFIFO(inode->i_mode)) in f2fs_file_fadvise()
5292 if (!mapping || len < 0) in f2fs_file_fadvise()
5302 } else if (advice == POSIX_FADV_WILLNEED && offset == 0) { in f2fs_file_fadvise()
5308 if (err) in f2fs_file_fadvise()
5311 if (advice == POSIX_FADV_DONTNEED && in f2fs_file_fadvise()
5315 else if (advice == POSIX_FADV_NOREUSE) in f2fs_file_fadvise()
5339 if (err) in f2fs_compat_ioc_gc_range()
5365 if (err) in f2fs_compat_ioc_move_range()
5373 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file))))) in f2fs_compat_ioctl()
5375 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(file)))) in f2fs_compat_ioctl()