Lines Matching full:if
56 if (fscrypt_is_bounce_folio(folio)) in f2fs_is_cp_guaranteed()
62 if (inode->i_ino == F2FS_META_INO(sbi) || in f2fs_is_cp_guaranteed()
67 if ((S_ISREG(inode->i_mode) && IS_NOQUOTA(inode)) || in f2fs_is_cp_guaranteed()
77 if (mapping) { in __read_io_type()
81 if (inode->i_ino == F2FS_META_INO(sbi)) in __read_io_type()
84 if (inode->i_ino == F2FS_NODE_INO(sbi)) in __read_io_type()
126 * This marks pages up-to-date only if there was no error in the bio (I/O error,
133 * with failed=true if an error occurred before it would have normally gotten
145 if (f2fs_is_compressed_page(folio)) { in f2fs_finish_read_bio()
146 if (ctx && !ctx->decompression_attempted) in f2fs_finish_read_bio()
157 if (ctx) in f2fs_finish_read_bio()
183 if (may_have_compressed_pages) { in f2fs_verify_bio()
189 if (!f2fs_is_compressed_page(folio) && in f2fs_verify_bio()
203 * If the bio's data needs to be verified with fs-verity, then enqueue the
215 if (ctx && (ctx->enabled_steps & STEP_VERITY)) { in f2fs_verify_and_finish_bio()
242 if (f2fs_is_compressed_page(folio)) in f2fs_handle_step_decompress()
254 * Optimization: if all the bio's pages are compressed, then scheduling in f2fs_handle_step_decompress()
258 if (all_compressed) in f2fs_handle_step_decompress()
268 if ((ctx->enabled_steps & STEP_DECRYPT) && !fscrypt_decrypt_bio(bio)) { in f2fs_post_read_work()
273 if (ctx->enabled_steps & STEP_DECOMPRESS) in f2fs_post_read_work()
288 if (time_to_inject(sbi, FAULT_READ_IO)) in f2fs_read_end_io()
291 if (bio->bi_status != BLK_STS_OK) { in f2fs_read_end_io()
296 if (ctx) { in f2fs_read_end_io()
301 * If we have only decompression step between decompression and in f2fs_read_end_io()
304 if (enabled_steps == STEP_DECOMPRESS && in f2fs_read_end_io()
307 } else if (enabled_steps) { in f2fs_read_end_io()
325 if (time_to_inject(sbi, FAULT_WRITE_IO)) in f2fs_write_end_io()
332 if (fscrypt_is_bounce_folio(folio)) { in f2fs_write_end_io()
340 if (f2fs_is_compressed_page(folio)) { in f2fs_write_end_io()
348 if (unlikely(bio->bi_status != BLK_STS_OK)) { in f2fs_write_end_io()
350 if (type == F2FS_WB_CP_DATA) in f2fs_write_end_io()
359 if (f2fs_in_warm_node_list(sbi, folio)) in f2fs_write_end_io()
364 if (!get_pages(sbi, F2FS_WB_CP_DATA) && in f2fs_write_end_io()
388 if (f2fs_is_multi_device(sbi)) { in f2fs_target_device()
390 if (FDEV(i).start_blk <= blk_addr && in f2fs_target_device()
399 if (sector) in f2fs_target_device()
408 if (!f2fs_is_multi_device(sbi)) in f2fs_target_device_index()
412 if (FDEV(i).start_blk <= blkaddr && FDEV(i).end_blk >= blkaddr) in f2fs_target_device_index()
423 if (fio->op != REQ_OP_WRITE) in f2fs_io_flags()
425 if (fio->type == DATA) in f2fs_io_flags()
427 else if (fio->type == NODE) in f2fs_io_flags()
441 if (BIT(fio->temp) & meta_flag) in f2fs_io_flags()
443 if (BIT(fio->temp) & fua_flag) in f2fs_io_flags()
446 if (fio->type == DATA && in f2fs_io_flags()
465 if (is_read_io(fio->op)) { in __bio_alloc()
476 if (fio->io_wbc) in __bio_alloc()
491 if (!fio || !fio->encrypted_page) in f2fs_set_bio_crypt_ctx()
503 if (fio && fio->encrypted_page) in f2fs_crypt_mergeable_bio()
532 if (!io->bio) in __submit_merged_bio()
535 if (is_read_io(fio->op)) { in __submit_merged_bio()
550 if (!bio) in __has_merged_page()
553 if (!inode && !folio && !ino) in __has_merged_page()
559 if (fscrypt_is_bounce_folio(target)) { in __has_merged_page()
561 if (IS_ERR(target)) in __has_merged_page()
564 if (f2fs_is_compressed_page(target)) { in __has_merged_page()
566 if (IS_ERR(target)) in __has_merged_page()
570 if (inode && inode == target->mapping->host) in __has_merged_page()
572 if (folio && folio == target) in __has_merged_page()
574 if (ino && ino == ino_of_node(target)) in __has_merged_page()
592 if (!sbi->write_io[i]) in f2fs_init_write_merge_io()
625 if (!io->bio) in __f2fs_submit_merged_write()
629 if (type >= META_FLUSH) { in __f2fs_submit_merged_write()
632 if (!test_opt(sbi, NOBARRIER)) in __f2fs_submit_merged_write()
648 if (!force) { in __submit_merged_write_cond()
656 if (ret) in __submit_merged_write_cond()
660 if (type >= META) in __submit_merged_write_cond()
695 if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr, in f2fs_submit_page_bio()
709 if (fio->io_wbc && !is_read_io(fio->op)) in f2fs_submit_page_bio()
715 if (is_read_io(bio_op(bio))) in f2fs_submit_page_bio()
725 if (unlikely(sbi->max_io_bytes && in page_is_mergeable()
728 if (last_blkaddr + 1 != cur_blkaddr) in page_is_mergeable()
738 if (io->fio.op != fio->op) in io_type_is_mergeable()
749 if (!page_is_mergeable(sbi, bio, last_blkaddr, cur_blkaddr)) in io_is_mergeable()
764 if (bio_add_page(bio, page, PAGE_SIZE, 0) != PAGE_SIZE) in add_bio_entry()
794 if (be->bio != *bio) in add_ipu_page()
802 if (f2fs_crypt_mergeable_bio(*bio, in add_ipu_page()
819 if (ret) { in add_ipu_page()
841 if (list_empty(head)) in f2fs_submit_merged_ipu_write()
846 if (target) in f2fs_submit_merged_ipu_write()
851 if (found) in f2fs_submit_merged_ipu_write()
856 if (!found) in f2fs_submit_merged_ipu_write()
863 if (target) in f2fs_submit_merged_ipu_write()
868 if (found) { in f2fs_submit_merged_ipu_write()
877 if (found) in f2fs_submit_merged_ipu_write()
879 if (bio && *bio) { in f2fs_submit_merged_ipu_write()
892 if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr, in f2fs_merge_page_bio()
898 if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block, in f2fs_merge_page_bio()
902 if (!bio) { in f2fs_merge_page_bio()
909 if (add_ipu_page(fio, &bio, &data_folio->page)) in f2fs_merge_page_bio()
913 if (fio->io_wbc) in f2fs_merge_page_bio()
930 if (f2fs_is_multi_device(sbi)) { in is_end_zone_blkaddr()
932 if (blkaddr < FDEV(devi).start_blk || in is_end_zone_blkaddr()
959 if (f2fs_sb_has_blkzoned(sbi) && btype < META && io->zone_pending_bio) { in f2fs_submit_page_write()
967 if (fio->in_list) { in f2fs_submit_page_write()
969 if (list_empty(&io->io_list)) { in f2fs_submit_page_write()
981 if (fio->encrypted_page) in f2fs_submit_page_write()
983 else if (fio->compressed_page) in f2fs_submit_page_write()
994 if (io->bio && in f2fs_submit_page_write()
1001 if (io->bio == NULL) { in f2fs_submit_page_write()
1008 if (!bio_add_folio(io->bio, bio_folio, folio_size(bio_folio), 0)) { in f2fs_submit_page_write()
1013 if (fio->io_wbc) in f2fs_submit_page_write()
1021 if (f2fs_sb_has_blkzoned(sbi) && btype < META && in f2fs_submit_page_write()
1032 if (fio->in_list) in f2fs_submit_page_write()
1035 if (is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN) || in f2fs_submit_page_write()
1059 if (fscrypt_inode_uses_fs_layer_crypto(inode)) in f2fs_grab_read_bio()
1062 if (f2fs_need_verity(inode, first_idx)) in f2fs_grab_read_bio()
1068 * bio_post_read_ctx if the file is compressed, but the caller is in f2fs_grab_read_bio()
1069 * responsible for enabling STEP_DECOMPRESS if it's actually needed. in f2fs_grab_read_bio()
1072 if (post_read_steps || f2fs_compressed_file(inode)) { in f2fs_grab_read_bio()
1101 if (!bio_add_folio(bio, folio, PAGE_SIZE, 0)) in f2fs_submit_page_read()
1127 if (folio_mark_dirty(dn->node_folio)) in f2fs_set_data_blkaddr()
1143 if (!count) in f2fs_reserve_new_blocks()
1146 if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC))) in f2fs_reserve_new_blocks()
1149 if (unlikely(err)) in f2fs_reserve_new_blocks()
1160 if (blkaddr == NULL_ADDR) { in f2fs_reserve_new_blocks()
1166 if (folio_mark_dirty(dn->node_folio)) in f2fs_reserve_new_blocks()
1188 if (err) in f2fs_reserve_block()
1191 if (dn->data_blkaddr == NULL_ADDR) in f2fs_reserve_block()
1193 if (err || need_put) in f2fs_reserve_block()
1207 if (IS_ERR(folio)) in f2fs_get_read_data_folio()
1210 if (f2fs_lookup_read_extent_cache_block(inode, index, in f2fs_get_read_data_folio()
1212 if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), dn.data_blkaddr, in f2fs_get_read_data_folio()
1222 if (err) { in f2fs_get_read_data_folio()
1223 if (err == -ENOENT && next_pgofs) in f2fs_get_read_data_folio()
1229 if (unlikely(dn.data_blkaddr == NULL_ADDR)) { in f2fs_get_read_data_folio()
1231 if (next_pgofs) in f2fs_get_read_data_folio()
1235 if (dn.data_blkaddr != NEW_ADDR && in f2fs_get_read_data_folio()
1243 if (folio_test_uptodate(folio)) { in f2fs_get_read_data_folio()
1255 if (dn.data_blkaddr == NEW_ADDR) { in f2fs_get_read_data_folio()
1257 if (!folio_test_uptodate(folio)) in f2fs_get_read_data_folio()
1279 if (IS_ERR(folio)) in f2fs_find_data_folio()
1281 if (folio_test_uptodate(folio)) in f2fs_find_data_folio()
1287 if (IS_ERR(folio)) in f2fs_find_data_folio()
1290 if (folio_test_uptodate(folio)) in f2fs_find_data_folio()
1294 if (unlikely(!folio_test_uptodate(folio))) { in f2fs_find_data_folio()
1302 * If it tries to access a hole, return an error.
1313 if (IS_ERR(folio)) in f2fs_get_lock_data_folio()
1318 if (unlikely(folio->mapping != mapping || !folio_test_uptodate(folio))) { in f2fs_get_lock_data_folio()
1331 * Note that, ifolio is set only by make_empty_dir, and if any error occur,
1343 if (IS_ERR(folio)) { in f2fs_get_new_data_folio()
1346 * if any error occur. in f2fs_get_new_data_folio()
1354 if (err) { in f2fs_get_new_data_folio()
1358 if (!ifolio) in f2fs_get_new_data_folio()
1361 if (folio_test_uptodate(folio)) in f2fs_get_new_data_folio()
1364 if (dn.data_blkaddr == NEW_ADDR) { in f2fs_get_new_data_folio()
1366 if (!folio_test_uptodate(folio)) in f2fs_get_new_data_folio()
1371 /* if ifolio exists, blkaddr should be NEW_ADDR */ in f2fs_get_new_data_folio()
1374 if (IS_ERR(folio)) in f2fs_get_new_data_folio()
1378 if (new_i_size && i_size_read(inode) < in f2fs_get_new_data_folio()
1393 if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC))) in __allocate_data_block()
1397 if (err) in __allocate_data_block()
1401 if (dn->data_blkaddr == NULL_ADDR) { in __allocate_data_block()
1403 if (unlikely(err)) in __allocate_data_block()
1411 if (err) in __allocate_data_block()
1414 if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO) in __allocate_data_block()
1423 if (flag == F2FS_GET_BLOCK_PRE_AIO) in f2fs_map_lock()
1431 if (flag == F2FS_GET_BLOCK_PRE_AIO) in f2fs_map_unlock()
1443 if (!f2fs_lookup_read_extent_cache_block(dn->inode, index, in f2fs_get_block_locked()
1462 if (map->m_may_create && in f2fs_map_no_dnode()
1466 if (map->m_next_pgofs) in f2fs_map_no_dnode()
1468 if (map->m_next_extent) in f2fs_map_no_dnode()
1481 if (!f2fs_lookup_read_extent_cache(inode, pgoff, &ei)) in f2fs_map_blocks_cached()
1487 if (map->m_next_extent) in f2fs_map_blocks_cached()
1491 if (flag == F2FS_GET_BLOCK_DIO) in f2fs_map_blocks_cached()
1495 if (f2fs_allow_multi_device_dio(sbi, flag)) { in f2fs_map_blocks_cached()
1513 if (map->m_multidev_dio && map->m_bdev != FDEV(bidx).bdev) in map_is_mergeable()
1515 if (map->m_pblk != NEW_ADDR && blkaddr == (map->m_pblk + ofs)) in map_is_mergeable()
1517 if (map->m_pblk == NEW_ADDR && blkaddr == NEW_ADDR) in map_is_mergeable()
1519 if (flag == F2FS_GET_BLOCK_PRE_DIO) in map_is_mergeable()
1521 if (flag == F2FS_GET_BLOCK_DIO && in map_is_mergeable()
1548 if (!maxblocks) in f2fs_map_blocks()
1554 if (!map->m_may_create && f2fs_map_blocks_cached(inode, map, flag)) in f2fs_map_blocks()
1568 if (flag == F2FS_GET_BLOCK_PRECACHE) in f2fs_map_blocks()
1572 if (map->m_may_create) { in f2fs_map_blocks()
1573 if (f2fs_lfs_mode(sbi)) in f2fs_map_blocks()
1581 if (err) { in f2fs_map_blocks()
1582 if (flag == F2FS_GET_BLOCK_BMAP) in f2fs_map_blocks()
1584 if (err == -ENOENT) in f2fs_map_blocks()
1597 if (!is_hole && in f2fs_map_blocks()
1604 if (map->m_may_create && (is_hole || in f2fs_map_blocks()
1607 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_map_blocks()
1614 if (blkaddr == NULL_ADDR) { in f2fs_map_blocks()
1622 if (err) in f2fs_map_blocks()
1624 if (flag == F2FS_GET_BLOCK_PRE_DIO) in f2fs_map_blocks()
1635 if (is_hole) in f2fs_map_blocks()
1637 } else if (is_hole) { in f2fs_map_blocks()
1638 if (f2fs_compressed_file(inode) && in f2fs_map_blocks()
1653 if (blkaddr == NULL_ADDR) { in f2fs_map_blocks()
1654 if (map->m_next_pgofs) in f2fs_map_blocks()
1660 if (map->m_next_pgofs) in f2fs_map_blocks()
1665 if (map->m_next_pgofs) in f2fs_map_blocks()
1671 if (flag == F2FS_GET_BLOCK_PRE_AIO) in f2fs_map_blocks()
1674 if (map->m_multidev_dio) in f2fs_map_blocks()
1677 if (map->m_len == 0) { in f2fs_map_blocks()
1679 if (blkaddr == NEW_ADDR) in f2fs_map_blocks()
1682 if (!(flag == F2FS_GET_BLOCK_DIO && is_hole && !map->m_may_create)) in f2fs_map_blocks()
1688 if (map->m_multidev_dio) in f2fs_map_blocks()
1691 if (lfs_dio_write) in f2fs_map_blocks()
1693 } else if (map_is_mergeable(sbi, map, blkaddr, flag, bidx, ofs)) { in f2fs_map_blocks()
1697 if (lfs_dio_write && !f2fs_is_pinned_file(inode)) in f2fs_map_blocks()
1707 if (flag == F2FS_GET_BLOCK_PRE_AIO && in f2fs_map_blocks()
1712 if (err) in f2fs_map_blocks()
1716 if (prealloc && dn.ofs_in_node != last_ofs_in_node + 1) { in f2fs_map_blocks()
1723 if (pgofs >= end) in f2fs_map_blocks()
1725 else if (dn.ofs_in_node < end_offset) in f2fs_map_blocks()
1728 if (flag == F2FS_GET_BLOCK_PRECACHE) { in f2fs_map_blocks()
1729 if (map->m_flags & F2FS_MAP_MAPPED) { in f2fs_map_blocks()
1740 if (map->m_may_create) { in f2fs_map_blocks()
1748 if (flag == F2FS_GET_BLOCK_DIO && map->m_flags & F2FS_MAP_MAPPED) { in f2fs_map_blocks()
1756 if (map->m_multidev_dio) { in f2fs_map_blocks()
1764 if (map->m_may_create) in f2fs_map_blocks()
1773 if (flag == F2FS_GET_BLOCK_PRECACHE) { in f2fs_map_blocks()
1774 if (map->m_flags & F2FS_MAP_MAPPED) { in f2fs_map_blocks()
1777 if (map->m_len > ofs) in f2fs_map_blocks()
1782 if (map->m_next_extent) in f2fs_map_blocks()
1787 if (map->m_may_create) { in f2fs_map_blocks()
1802 if (pos + len > i_size_read(inode)) in f2fs_overwrite_io()
1815 if (err || map.m_len == 0) in f2fs_overwrite_io()
1832 if (f2fs_has_inline_xattr(inode)) { in f2fs_xattr_fiemap()
1837 if (IS_ERR(folio)) in f2fs_xattr_fiemap()
1841 if (err) { in f2fs_xattr_fiemap()
1858 if (!xnid) in f2fs_xattr_fiemap()
1863 if (err) in f2fs_xattr_fiemap()
1867 if (xnid) { in f2fs_xattr_fiemap()
1871 if (IS_ERR(folio)) in f2fs_xattr_fiemap()
1875 if (err) { in f2fs_xattr_fiemap()
1888 if (phys) { in f2fs_xattr_fiemap()
1910 if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) { in f2fs_fiemap()
1912 if (ret) in f2fs_fiemap()
1917 if (ret) in f2fs_fiemap()
1923 if (start > maxbytes) { in f2fs_fiemap()
1928 if (len > maxbytes || (maxbytes - len) < start) in f2fs_fiemap()
1931 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) { in f2fs_fiemap()
1936 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) { in f2fs_fiemap()
1938 if (ret != -EAGAIN) in f2fs_fiemap()
1954 if (compr_cluster) { in f2fs_fiemap()
1960 if (ret) in f2fs_fiemap()
1964 if (!compr_cluster && !(map.m_flags & F2FS_MAP_FLAGS)) { in f2fs_fiemap()
1967 if (F2FS_BLK_TO_BYTES(start_blk) < maxbytes) in f2fs_fiemap()
1977 if (!compr_cluster && (map.m_flags & F2FS_MAP_MAPPED) && in f2fs_fiemap()
1986 if (compr_cluster && ((map.m_flags & F2FS_MAP_DELALLOC) || in f2fs_fiemap()
1992 if (size) { in f2fs_fiemap()
1994 if (IS_ENCRYPTED(inode)) in f2fs_fiemap()
2000 if (ret) in f2fs_fiemap()
2005 if (start_blk > last_blk) in f2fs_fiemap()
2009 if (map.m_pblk == COMPRESS_ADDR) { in f2fs_fiemap()
2012 } else if (compr_appended) { in f2fs_fiemap()
2025 if (compr_cluster) { in f2fs_fiemap()
2028 if (count_in_cluster == cluster_size) { in f2fs_fiemap()
2032 } else if (map.m_flags & F2FS_MAP_DELALLOC) { in f2fs_fiemap()
2041 if (fatal_signal_pending(current)) in f2fs_fiemap()
2046 if (ret == 1) in f2fs_fiemap()
2055 if (IS_ENABLED(CONFIG_FS_VERITY) && IS_VERITY(inode)) in f2fs_readpage_limit()
2086 if (last_block > last_block_in_file) in f2fs_read_single_page()
2090 if (block_in_file >= last_block) in f2fs_read_single_page()
2095 if ((map->m_flags & F2FS_MAP_MAPPED) && in f2fs_read_single_page()
2108 if (ret) in f2fs_read_single_page()
2111 if ((map->m_flags & F2FS_MAP_MAPPED)) { in f2fs_read_single_page()
2115 if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), block_nr, in f2fs_read_single_page()
2123 if (f2fs_need_verity(inode, index) && in f2fs_read_single_page()
2128 if (!folio_test_uptodate(folio)) in f2fs_read_single_page()
2138 if (bio && (!page_is_mergeable(F2FS_I_SB(inode), bio, in f2fs_read_single_page()
2145 if (bio == NULL) in f2fs_read_single_page()
2151 * If the page is under writeback, we need to wait for in f2fs_read_single_page()
2156 if (!bio_add_folio(bio, folio, blocksize, 0)) in f2fs_read_single_page()
2186 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_read_multi_pages()
2202 if (!page) in f2fs_read_multi_pages()
2206 if ((sector_t)folio->index >= last_block_in_file) { in f2fs_read_multi_pages()
2208 if (!folio_test_uptodate(folio)) in f2fs_read_multi_pages()
2210 } else if (!folio_test_uptodate(folio)) { in f2fs_read_multi_pages()
2214 if (for_write) in f2fs_read_multi_pages()
2221 if (f2fs_cluster_is_empty(cc)) in f2fs_read_multi_pages()
2224 if (f2fs_lookup_read_extent_cache(inode, start_idx, &ei)) in f2fs_read_multi_pages()
2227 if (!from_dnode) in f2fs_read_multi_pages()
2232 if (ret) in f2fs_read_multi_pages()
2245 if (!__is_valid_data_blkaddr(blkaddr)) in f2fs_read_multi_pages()
2248 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC)) { in f2fs_read_multi_pages()
2254 if (!from_dnode && i >= ei.c_len) in f2fs_read_multi_pages()
2259 if (cc->nr_cpages == 0) { in f2fs_read_multi_pages()
2265 if (IS_ERR(dic)) { in f2fs_read_multi_pages()
2281 if (f2fs_load_compressed_folio(sbi, folio, blkaddr)) { in f2fs_read_multi_pages()
2282 if (atomic_dec_and_test(&dic->remaining_pages)) { in f2fs_read_multi_pages()
2289 if (bio && (!page_is_mergeable(sbi, bio, in f2fs_read_multi_pages()
2297 if (!bio) in f2fs_read_multi_pages()
2302 if (!bio_add_folio(bio, folio, blocksize, 0)) in f2fs_read_multi_pages()
2314 if (from_dnode) in f2fs_read_multi_pages()
2321 if (from_dnode) in f2fs_read_multi_pages()
2325 if (cc->rpages[i]) { in f2fs_read_multi_pages()
2364 if (f2fs_compressed_file(inode)) { in f2fs_mpage_readpages()
2381 if (rac) { in f2fs_mpage_readpages()
2389 if (!f2fs_compressed_file(inode)) in f2fs_mpage_readpages()
2393 if (!f2fs_cluster_can_merge_page(&cc, index)) { in f2fs_mpage_readpages()
2399 if (ret) in f2fs_mpage_readpages()
2402 if (cc.cluster_idx == NULL_CLUSTER) { in f2fs_mpage_readpages()
2403 if (nc_cluster_idx == index >> cc.log_cluster_size) in f2fs_mpage_readpages()
2407 if (ret < 0) in f2fs_mpage_readpages()
2409 else if (!ret) { in f2fs_mpage_readpages()
2418 if (ret) in f2fs_mpage_readpages()
2429 if (ret) { in f2fs_mpage_readpages()
2441 if (f2fs_compressed_file(inode)) { in f2fs_mpage_readpages()
2443 if (nr_pages == 1 && !f2fs_cluster_is_empty(&cc)) { in f2fs_mpage_readpages()
2453 if (bio) in f2fs_mpage_readpages()
2465 if (!f2fs_is_compress_backend_ready(inode)) { in f2fs_read_data_folio()
2470 /* If the file has inline data, try to read it directly */ in f2fs_read_data_folio()
2471 if (f2fs_has_inline_data(inode)) in f2fs_read_data_folio()
2473 if (ret == -EAGAIN) in f2fs_read_data_folio()
2484 if (!f2fs_is_compress_backend_ready(inode)) in f2fs_readahead()
2487 /* If the file has inline data, skip readahead */ in f2fs_readahead()
2488 if (f2fs_has_inline_data(inode)) in f2fs_readahead()
2501 if (!f2fs_encrypted_file(inode)) in f2fs_encrypt_one_page()
2506 if (fscrypt_inode_uses_inline_crypto(inode)) in f2fs_encrypt_one_page()
2512 if (IS_ERR(fio->encrypted_page)) { in f2fs_encrypt_one_page()
2514 if (PTR_ERR(fio->encrypted_page) == -ENOMEM) { in f2fs_encrypt_one_page()
2524 if (!IS_ERR(mfolio)) { in f2fs_encrypt_one_page()
2525 if (folio_test_uptodate(mfolio)) in f2fs_encrypt_one_page()
2538 if (IS_F2FS_IPU_HONOR_OPU_WRITE(sbi) && in check_inplace_update_policy()
2541 if (IS_F2FS_IPU_FORCE(sbi)) in check_inplace_update_policy()
2543 if (IS_F2FS_IPU_SSR(sbi) && f2fs_need_SSR(sbi)) in check_inplace_update_policy()
2545 if (IS_F2FS_IPU_UTIL(sbi) && utilization(sbi) > SM_I(sbi)->min_ipu_util) in check_inplace_update_policy()
2547 if (IS_F2FS_IPU_SSR_UTIL(sbi) && f2fs_need_SSR(sbi) && in check_inplace_update_policy()
2554 if (IS_F2FS_IPU_ASYNC(sbi) && fio && fio->op == REQ_OP_WRITE && in check_inplace_update_policy()
2559 if (IS_F2FS_IPU_FSYNC(sbi) && is_inode_flag_set(inode, FI_NEED_IPU)) in check_inplace_update_policy()
2562 if (unlikely(fio && is_sbi_flag_set(sbi, SBI_CP_DISABLED) && in check_inplace_update_policy()
2572 if (is_inode_flag_set(inode, FI_ALIGNED_WRITE)) in f2fs_should_update_inplace()
2575 if (f2fs_is_pinned_file(inode)) in f2fs_should_update_inplace()
2578 /* if this is cold file, we should overwrite to avoid fragmentation */ in f2fs_should_update_inplace()
2579 if (file_is_cold(inode) && !is_inode_flag_set(inode, FI_OPU_WRITE)) in f2fs_should_update_inplace()
2590 if (f2fs_is_pinned_file(inode)) in f2fs_should_update_outplace()
2592 if (fio && is_sbi_flag_set(sbi, SBI_NEED_FSCK)) in f2fs_should_update_outplace()
2594 if (f2fs_lfs_mode(sbi)) in f2fs_should_update_outplace()
2596 if (S_ISDIR(inode->i_mode)) in f2fs_should_update_outplace()
2598 if (IS_NOQUOTA(inode)) in f2fs_should_update_outplace()
2600 if (f2fs_used_in_atomic_write(inode)) in f2fs_should_update_outplace()
2603 if (f2fs_compressed_file(inode) && in f2fs_should_update_outplace()
2609 if (is_inode_flag_set(inode, FI_ALIGNED_WRITE)) in f2fs_should_update_outplace()
2612 if (is_inode_flag_set(inode, FI_OPU_WRITE)) in f2fs_should_update_outplace()
2615 if (fio) { in f2fs_should_update_outplace()
2616 if (page_private_gcing(fio->page)) in f2fs_should_update_outplace()
2618 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) && in f2fs_should_update_outplace()
2629 if (f2fs_should_update_outplace(inode, fio)) in need_inplace_update()
2648 if (atomic_commit) in f2fs_do_write_data_page()
2653 if (need_inplace_update(fio) && in f2fs_do_write_data_page()
2656 if (!f2fs_is_valid_blkaddr(fio->sbi, fio->old_blkaddr, in f2fs_do_write_data_page()
2666 if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi)) in f2fs_do_write_data_page()
2670 if (err) in f2fs_do_write_data_page()
2676 if (fio->old_blkaddr == NULL_ADDR) { in f2fs_do_write_data_page()
2682 if (__is_valid_data_blkaddr(fio->old_blkaddr) && in f2fs_do_write_data_page()
2690 if (fio->meta_gc) in f2fs_do_write_data_page()
2694 * If current allocation needs SSR, in f2fs_do_write_data_page()
2697 if (ipu_force || in f2fs_do_write_data_page()
2701 if (err) in f2fs_do_write_data_page()
2706 if (fio->need_lock == LOCK_REQ) in f2fs_do_write_data_page()
2709 if (err) { in f2fs_do_write_data_page()
2710 if (fscrypt_inode_uses_fs_layer_crypto(inode)) in f2fs_do_write_data_page()
2720 if (fio->need_lock == LOCK_RETRY) { in f2fs_do_write_data_page()
2721 if (!f2fs_trylock_op(fio->sbi)) { in f2fs_do_write_data_page()
2729 if (err) in f2fs_do_write_data_page()
2735 if (err) in f2fs_do_write_data_page()
2740 if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR) in f2fs_do_write_data_page()
2747 if (atomic_commit) in f2fs_do_write_data_page()
2752 if (fio->need_lock == LOCK_REQ) in f2fs_do_write_data_page()
2797 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_write_single_data_page()
2803 if (S_ISDIR(inode->i_mode) && in f2fs_write_single_data_page()
2808 if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) in f2fs_write_single_data_page()
2813 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) in f2fs_write_single_data_page()
2816 if (folio->index < end_index || in f2fs_write_single_data_page()
2822 * If the offset is out-of-range of file size, in f2fs_write_single_data_page()
2826 if ((folio->index >= end_index + 1) || !offset) in f2fs_write_single_data_page()
2832 if (S_ISDIR(inode->i_mode) || quota_inode) { in f2fs_write_single_data_page()
2838 if (quota_inode) in f2fs_write_single_data_page()
2844 if (quota_inode) in f2fs_write_single_data_page()
2852 if (f2fs_has_inline_data(inode)) { in f2fs_write_single_data_page()
2854 if (!err) in f2fs_write_single_data_page()
2858 if (err == -EAGAIN) { in f2fs_write_single_data_page()
2860 if (err == -EAGAIN) { in f2fs_write_single_data_page()
2867 if (err) { in f2fs_write_single_data_page()
2871 if (F2FS_I(inode)->last_disk_size < psize) in f2fs_write_single_data_page()
2877 if (err && err != -ENOENT) in f2fs_write_single_data_page()
2882 if (err) { in f2fs_write_single_data_page()
2887 if (!S_ISDIR(inode->i_mode) && !IS_NOQUOTA(inode) && in f2fs_write_single_data_page()
2891 if (unlikely(f2fs_cp_error(sbi))) { in f2fs_write_single_data_page()
2893 if (bio && *bio) in f2fs_write_single_data_page()
2898 if (submitted) in f2fs_write_single_data_page()
2912 if (!err) in f2fs_write_single_data_page()
2964 if (f2fs_compressed_file(inode) && in f2fs_write_cache_pages()
2974 if (get_dirty_pages(mapping->host) <= in f2fs_write_cache_pages()
2980 if (wbc->range_cyclic) { in f2fs_write_cache_pages()
2986 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) in f2fs_write_cache_pages()
2992 if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) in f2fs_write_cache_pages()
3000 if (nr_folios == 0) { in f2fs_write_cache_pages()
3001 if (nr_pages) in f2fs_write_cache_pages()
3014 if (++nr_pages == max_pages) { in f2fs_write_cache_pages()
3019 if (++idx < p) in f2fs_write_cache_pages()
3032 if (f2fs_compressed_file(inode)) { in f2fs_write_cache_pages()
3038 if (ret) { in f2fs_write_cache_pages()
3043 if (!f2fs_cluster_can_merge_page(&cc, in f2fs_write_cache_pages()
3047 if (!ret) in f2fs_write_cache_pages()
3052 if (unlikely(f2fs_cp_error(sbi))) in f2fs_write_cache_pages()
3055 if (!f2fs_cluster_is_empty(&cc)) in f2fs_write_cache_pages()
3058 if (f2fs_all_cluster_page_ready(&cc, in f2fs_write_cache_pages()
3065 if (ret2 < 0) { in f2fs_write_cache_pages()
3069 } else if (ret2 && in f2fs_write_cache_pages()
3081 if (atomic_read(&sbi->wb_sync_req[DATA]) && in f2fs_write_cache_pages()
3093 if (unlikely(folio->mapping != mapping)) { in f2fs_write_cache_pages()
3099 if (!folio_test_dirty(folio)) { in f2fs_write_cache_pages()
3104 if (folio_test_writeback(folio)) { in f2fs_write_cache_pages()
3105 if (wbc->sync_mode == WB_SYNC_NONE) in f2fs_write_cache_pages()
3110 if (!folio_clear_dirty_for_io(folio)) in f2fs_write_cache_pages()
3114 if (f2fs_compressed_file(inode)) { in f2fs_write_cache_pages()
3130 if (unlikely(ret)) { in f2fs_write_cache_pages()
3135 if (ret == 1) { in f2fs_write_cache_pages()
3138 } else if (ret == -EAGAIN) { in f2fs_write_cache_pages()
3140 if (wbc->sync_mode == WB_SYNC_ALL) { in f2fs_write_cache_pages()
3152 if (wbc->nr_to_write <= 0 && in f2fs_write_cache_pages()
3158 if (need_readd) in f2fs_write_cache_pages()
3166 if (f2fs_compressed_file(inode) && !f2fs_cluster_is_empty(&cc)) { in f2fs_write_cache_pages()
3170 if (ret) { in f2fs_write_cache_pages()
3175 if (f2fs_compressed_file(inode)) in f2fs_write_cache_pages()
3178 if (retry) { in f2fs_write_cache_pages()
3183 if (wbc->range_cyclic && !done) in f2fs_write_cache_pages()
3185 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) in f2fs_write_cache_pages()
3188 if (nwritten) in f2fs_write_cache_pages()
3192 if (bio) in f2fs_write_cache_pages()
3196 if (pages != pages_local) in f2fs_write_cache_pages()
3207 if (F2FS_I(inode)->wb_task) in __should_serialize_io()
3210 if (!S_ISREG(inode->i_mode)) in __should_serialize_io()
3212 if (IS_NOQUOTA(inode)) in __should_serialize_io()
3215 if (f2fs_need_compress_data(inode)) in __should_serialize_io()
3217 if (wbc->sync_mode != WB_SYNC_ALL) in __should_serialize_io()
3219 if (get_dirty_pages(inode) >= SM_I(F2FS_I_SB(inode))->min_seq_blocks) in __should_serialize_io()
3234 /* skip writing if there is no dirty page in this inode */ in __f2fs_write_data_pages()
3235 if (!get_dirty_pages(inode) && wbc->sync_mode == WB_SYNC_NONE) in __f2fs_write_data_pages()
3239 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) in __f2fs_write_data_pages()
3242 if ((S_ISDIR(inode->i_mode) || IS_NOQUOTA(inode)) && in __f2fs_write_data_pages()
3249 if (is_inode_flag_set(inode, FI_SKIP_WRITES)) in __f2fs_write_data_pages()
3255 if (wbc->sync_mode == WB_SYNC_ALL) in __f2fs_write_data_pages()
3257 else if (atomic_read(&sbi->wb_sync_req[DATA])) { in __f2fs_write_data_pages()
3259 if (current->plug) in __f2fs_write_data_pages()
3264 if (__should_serialize_io(inode, wbc)) { in __f2fs_write_data_pages()
3273 if (locked) in __f2fs_write_data_pages()
3276 if (wbc->sync_mode == WB_SYNC_ALL) in __f2fs_write_data_pages()
3279 * if some pages were truncated, we cannot guarantee its mapping->host in __f2fs_write_data_pages()
3306 if (IS_NOQUOTA(inode)) in f2fs_write_failed()
3310 if (to > i_size && !f2fs_verity_in_progress(inode)) { in f2fs_write_failed()
3335 * If a whole page is being written and we already preallocated all the in prepare_write_begin()
3338 if (len == PAGE_SIZE && is_inode_flag_set(inode, FI_PREALLOCATED_ALL)) in prepare_write_begin()
3342 if (f2fs_has_inline_data(inode)) { in prepare_write_begin()
3343 if (pos + len > MAX_INLINE_DATA(inode)) in prepare_write_begin()
3347 } else if ((pos & PAGE_MASK) >= i_size_read(inode)) { in prepare_write_begin()
3355 if (IS_ERR(ifolio)) { in prepare_write_begin()
3362 if (f2fs_has_inline_data(inode)) { in prepare_write_begin()
3363 if (pos + len <= MAX_INLINE_DATA(inode)) { in prepare_write_begin()
3366 if (inode->i_nlink) in prepare_write_begin()
3371 if (err || dn.data_blkaddr != NULL_ADDR) in prepare_write_begin()
3375 if (!f2fs_lookup_read_extent_cache_block(inode, index, in prepare_write_begin()
3377 if (IS_DEVICE_ALIASING(inode)) { in prepare_write_begin()
3382 if (locked) { in prepare_write_begin()
3389 if (!err && dn.data_blkaddr != NULL_ADDR) in prepare_write_begin()
3398 if (!err) { in prepare_write_begin()
3405 if (locked) in prepare_write_begin()
3418 if (IS_ERR(ifolio)) in __find_data_block()
3423 if (!f2fs_lookup_read_extent_cache_block(inode, index, in __find_data_block()
3427 if (err) { in __find_data_block()
3448 if (IS_ERR(ifolio)) { in __reserve_data_block()
3454 if (!f2fs_lookup_read_extent_cache_block(dn.inode, index, in __reserve_data_block()
3477 /* If pos is beyond the end of file, reserve a new block in COW inode */ in prepare_atomic_write_begin()
3478 if ((pos & PAGE_MASK) >= i_size_read(inode)) in prepare_atomic_write_begin()
3483 if (err) { in prepare_atomic_write_begin()
3485 } else if (*blk_addr != NULL_ADDR) { in prepare_atomic_write_begin()
3490 if (is_inode_flag_set(inode, FI_ATOMIC_REPLACE)) in prepare_atomic_write_begin()
3495 if (err) in prepare_atomic_write_begin()
3501 if (err) in prepare_atomic_write_begin()
3505 if (ori_blk_addr != NULL_ADDR) in prepare_atomic_write_begin()
3526 if (!f2fs_is_checkpoint_ready(sbi)) { in f2fs_write_begin()
3536 if (index != 0) { in f2fs_write_begin()
3538 if (err) in f2fs_write_begin()
3543 if (f2fs_compressed_file(inode)) { in f2fs_write_begin()
3549 if (len == PAGE_SIZE && !(f2fs_is_atomic_file(inode))) in f2fs_write_begin()
3554 if (ret < 0) { in f2fs_write_begin()
3557 } else if (ret) { in f2fs_write_begin()
3571 if (IS_ERR(folio)) { in f2fs_write_begin()
3580 if (f2fs_is_atomic_file(inode)) in f2fs_write_begin()
3586 if (err) in f2fs_write_begin()
3589 if (need_balance && !IS_NOQUOTA(inode) && in f2fs_write_begin()
3594 if (folio->mapping != mapping) { in f2fs_write_begin()
3604 if (len == folio_size(folio) || folio_test_uptodate(folio)) in f2fs_write_begin()
3607 if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode) && in f2fs_write_begin()
3613 if (blkaddr == NEW_ADDR) { in f2fs_write_begin()
3617 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, in f2fs_write_begin()
3627 if (unlikely(folio->mapping != mapping)) { in f2fs_write_begin()
3632 if (unlikely(!folio_test_uptodate(folio))) { in f2fs_write_begin()
3661 if (!folio_test_uptodate(folio)) { in f2fs_write_end()
3662 if (unlikely(copied != len)) in f2fs_write_end()
3670 if (f2fs_compressed_file(inode) && fsdata) { in f2fs_write_end()
3674 if (pos + copied > i_size_read(inode) && in f2fs_write_end()
3681 if (!copied) in f2fs_write_end()
3686 if (f2fs_is_atomic_file(inode)) in f2fs_write_end()
3689 if (pos + copied > i_size_read(inode) && in f2fs_write_end()
3692 if (f2fs_is_atomic_file(inode)) in f2fs_write_end()
3708 if (inode->i_ino >= F2FS_ROOT_INO(sbi) && in f2fs_invalidate_folio()
3712 if (folio_test_dirty(folio)) { in f2fs_invalidate_folio()
3713 if (inode->i_ino == F2FS_META_INO(sbi)) { in f2fs_invalidate_folio()
3715 } else if (inode->i_ino == F2FS_NODE_INO(sbi)) { in f2fs_invalidate_folio()
3727 /* If this is dirty folio, keep private data */ in f2fs_release_folio()
3728 if (folio_test_dirty(folio)) in f2fs_release_folio()
3742 if (!folio_test_uptodate(folio)) in f2fs_dirty_data_folio()
3746 if (filemap_dirty_folio(mapping, folio)) { in f2fs_dirty_data_folio()
3765 if (ret) in f2fs_bmap_compress()
3768 if (dn.data_blkaddr != COMPRESS_ADDR) { in f2fs_bmap_compress()
3771 if (!__is_valid_data_blkaddr(blknr)) in f2fs_bmap_compress()
3788 if (f2fs_has_inline_data(inode)) in f2fs_bmap()
3792 if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) in f2fs_bmap()
3796 if (unlikely(block >= max_file_blocks(inode))) in f2fs_bmap()
3799 if (f2fs_compressed_file(inode)) { in f2fs_bmap()
3810 if (!f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_BMAP)) in f2fs_bmap()
3830 if (!blkcnt) in f2fs_migrate_blocks()
3847 if (ret) { in f2fs_migrate_blocks()
3859 if (IS_ERR(folio)) { in f2fs_migrate_blocks()
3875 if (ret) in f2fs_migrate_blocks()
3928 if (ret) in check_swap_activate()
3932 if (!(map.m_flags & F2FS_MAP_FLAGS)) { in check_swap_activate()
3941 if ((pblock - SM_I(sbi)->main_blkaddr) % blks_per_sec || in check_swap_activate()
3949 if (cur_lblock + nr_pblocks > sis->max) in check_swap_activate()
3953 if (!nr_pblocks) { in check_swap_activate()
3960 if (ret) { in check_swap_activate()
3961 if (ret == -ENOENT) in check_swap_activate()
3966 if (!last_extent) in check_swap_activate()
3970 if (cur_lblock + nr_pblocks >= sis->max) in check_swap_activate()
3973 if (cur_lblock) { /* exclude the header page */ in check_swap_activate()
3974 if (pblock < lowest_pblock) in check_swap_activate()
3976 if (pblock + nr_pblocks - 1 > highest_pblock) in check_swap_activate()
3984 if (ret < 0) in check_swap_activate()
3991 if (cur_lblock == 0) in check_swap_activate()
3996 if (not_aligned) in check_swap_activate()
4009 if (!S_ISREG(inode->i_mode)) in f2fs_swap_activate()
4012 if (f2fs_readonly(sbi->sb)) in f2fs_swap_activate()
4015 if (f2fs_lfs_mode(sbi) && !f2fs_sb_has_blkzoned(sbi)) { in f2fs_swap_activate()
4021 if (ret) in f2fs_swap_activate()
4024 if (!f2fs_disable_compressed_file(inode)) in f2fs_swap_activate()
4028 if (ret < 0) in f2fs_swap_activate()
4034 if (ret < 0) in f2fs_swap_activate()
4093 if (!bio_post_read_ctx_cache) in f2fs_init_post_read_processing()
4098 if (!bio_post_read_ctx_pool) in f2fs_init_post_read_processing()
4116 if (!f2fs_sb_has_encrypt(sbi) && in f2fs_init_post_read_wq()
4129 if (sbi->post_read_wq) in f2fs_destroy_post_read_wq()
4158 if (flags & IOMAP_WRITE && iomap->private) { in f2fs_iomap_begin()
4164 * If the blocks being overwritten are already allocated, in f2fs_iomap_begin()
4167 if ((flags & IOMAP_WRITE) && in f2fs_iomap_begin()
4172 if (err) in f2fs_iomap_begin()
4188 if (WARN_ON_ONCE(map.m_pblk == COMPRESS_ADDR)) in f2fs_iomap_begin()
4191 if (map.m_flags & F2FS_MAP_MAPPED) { in f2fs_iomap_begin()
4192 if (WARN_ON_ONCE(map.m_pblk == NEW_ADDR)) in f2fs_iomap_begin()
4201 if (flags & IOMAP_WRITE && map.m_last_pblk) in f2fs_iomap_begin()
4204 if (flags & IOMAP_WRITE) in f2fs_iomap_begin()
4207 if (map.m_pblk == NULL_ADDR) { in f2fs_iomap_begin()
4211 } else if (map.m_pblk == NEW_ADDR) { in f2fs_iomap_begin()
4220 if (map.m_flags & F2FS_MAP_NEW) in f2fs_iomap_begin()
4222 if ((inode_state_read_once(inode) & I_DIRTY_DATASYNC) || in f2fs_iomap_begin()