Merge tag 'f2fs-for-6.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeu...

Pull f2fs updates from Jaegeuk Kim:
 "In this series, there are several major improvements such as folio
  conversion by Matthew, speed-up of block truncation, and caching more
  dentry pages.

  In addition, we implemented a linear dentry search to address recent
  unicode regression, and figured out some false alarms that we could
  get rid of.

  Enhancements:
   - foilio conversion in various IO paths
   - optimize f2fs_truncate_data_blocks_range()
   - cache more dentry pages
   - remove unnecessary blk_finish_plug
   - procfs: show mtime in segment_bits

  Bug fixes:
   - introduce linear search for dentries
   - don't call block truncation for aliased file
   - fix using wrong 'submitted' value in f2fs_write_cache_pages
   - fix to do sanity check correctly on i_inline_xattr_size
   - avoid trying to get invalid block address
   - fix inconsistent dirty state of atomic file"

* tag 'f2fs-for-6.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (32 commits)
  f2fs: fix inconsistent dirty state of atomic file
  f2fs: fix to avoid changing 'check only' behaior of recovery
  f2fs: Clean up the loop outside of f2fs_invalidate_blocks()
  f2fs: procfs: show mtime in segment_bits
  f2fs: fix to avoid return invalid mtime from f2fs_get_section_mtime()
  f2fs: Fix format specifier in sanity_check_inode()
  f2fs: avoid trying to get invalid block address
  f2fs: fix to do sanity check correctly on i_inline_xattr_size
  f2fs: remove blk_finish_plug
  f2fs: Optimize f2fs_truncate_data_blocks_range()
  f2fs: fix using wrong 'submitted' value in f2fs_write_cache_pages
  f2fs: add parameter @len to f2fs_invalidate_blocks()
  f2fs: update_sit_entry_for_release() supports consecutive blocks.
  f2fs: introduce update_sit_entry_for_release/alloc()
  f2fs: don't call block truncation for aliased file
  f2fs: Introduce linear search for dentries
  f2fs: add parameter @len to f2fs_invalidate_internal_cache()
  f2fs: expand f2fs_invalidate_compress_page() to f2fs_invalidate_compress_pages_range()
  f2fs: ensure that node info flags are always initialized
  f2fs: The GC triggered by ioctl also needs to mark the segno as victim
  ...

diff --combined fs/f2fs/data.c
index a9eddd782dbce39c28e607152d8641078a575c39,008ecd8fd386a13090068405c4fe6a085883c883..de4da6d9cd93a7d7e73a470909578697b6e7ca11
--- 1/fs/f2fs/data.c
--- 2/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@@ -70,9 -70,9 +70,9 @@@ bool f2fs_is_cp_guaranteed(struct page 
        return false;
  }
  
- static enum count_type __read_io_type(struct page *page)
+ static enum count_type __read_io_type(struct folio *folio)
  {
-       struct address_space *mapping = page_file_mapping(page);
+       struct address_space *mapping = folio->mapping;
  
        if (mapping) {
                struct inode *inode = mapping->host;
@@@ -136,27 -136,22 +136,22 @@@ struct bio_post_read_ctx 
   */
  static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
  {
-       struct bio_vec *bv;
-       struct bvec_iter_all iter_all;
+       struct folio_iter fi;
        struct bio_post_read_ctx *ctx = bio->bi_private;
  
-       bio_for_each_segment_all(bv, bio, iter_all) {
-               struct page *page = bv->bv_page;
+       bio_for_each_folio_all(fi, bio) {
+               struct folio *folio = fi.folio;
  
-               if (f2fs_is_compressed_page(page)) {
+               if (f2fs_is_compressed_page(&folio->page)) {
                        if (ctx && !ctx->decompression_attempted)
-                               f2fs_end_read_compressed_page(page, true, 0,
+                               f2fs_end_read_compressed_page(&folio->page, true, 0,
                                                        in_task);
-                       f2fs_put_page_dic(page, in_task);
+                       f2fs_put_page_dic(&folio->page, in_task);
                        continue;
                }
  
-               if (bio->bi_status)
-                       ClearPageUptodate(page);
-               else
-                       SetPageUptodate(page);
-               dec_page_count(F2FS_P_SB(page), __read_io_type(page));
-               unlock_page(page);
+               dec_page_count(F2FS_F_SB(folio), __read_io_type(folio));
+               folio_end_read(folio, bio->bi_status == 0);
        }
  
        if (ctx)
@@@ -516,10 -511,6 +511,6 @@@ static void f2fs_submit_write_bio(struc
                                  enum page_type type)
  {
        WARN_ON_ONCE(is_read_io(bio_op(bio)));
- 
-       if (f2fs_lfs_mode(sbi) && current->plug && PAGE_TYPE_ON_MAIN(type))
-               blk_finish_plug(current->plug);
- 
        trace_f2fs_submit_write_bio(sbi->sb, type, bio);
        iostat_update_submit_ctx(bio, type);
        submit_bio(bio);
@@@ -689,33 -680,29 +680,29 @@@ void f2fs_flush_merged_writes(struct f2
  int f2fs_submit_page_bio(struct f2fs_io_info *fio)
  {
        struct bio *bio;
-       struct page *page = fio->encrypted_page ?
-                       fio->encrypted_page : fio->page;
+       struct folio *fio_folio = page_folio(fio->page);
+       struct folio *data_folio = fio->encrypted_page ?
+                       page_folio(fio->encrypted_page) : fio_folio;
  
        if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
                        fio->is_por ? META_POR : (__is_meta_io(fio) ?
                        META_GENERIC : DATA_GENERIC_ENHANCE)))
                return -EFSCORRUPTED;
  
-       trace_f2fs_submit_page_bio(page, fio);
+       trace_f2fs_submit_folio_bio(data_folio, fio);
  
        /* Allocate a new bio */
        bio = __bio_alloc(fio, 1);
  
-       f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,
-                       page_folio(fio->page)->index, fio, GFP_NOIO);
- 
-       if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
-               bio_put(bio);
-               return -EFAULT;
-       }
+       f2fs_set_bio_crypt_ctx(bio, fio_folio->mapping->host,
+                       fio_folio->index, fio, GFP_NOIO);
+       bio_add_folio_nofail(bio, data_folio, folio_size(data_folio), 0);
  
        if (fio->io_wbc && !is_read_io(fio->op))
-               wbc_account_cgroup_owner(fio->io_wbc, page_folio(fio->page),
-                                        PAGE_SIZE);
+               wbc_account_cgroup_owner(fio->io_wbc, fio_folio, PAGE_SIZE);
  
        inc_page_count(fio->sbi, is_read_io(fio->op) ?
-                       __read_io_type(page) : WB_DATA_TYPE(fio->page, false));
+                       __read_io_type(data_folio) : WB_DATA_TYPE(fio->page, false));
  
        if (is_read_io(bio_op(bio)))
                f2fs_submit_read_bio(fio->sbi, bio, fio->type);
@@@ -894,7 -881,7 +881,7 @@@ int f2fs_merge_page_bio(struct f2fs_io_
                        __is_meta_io(fio) ? META_GENERIC : DATA_GENERIC))
                return -EFSCORRUPTED;
  
-       trace_f2fs_submit_page_bio(page, fio);
+       trace_f2fs_submit_folio_bio(page_folio(page), fio);
  
        if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block,
                                                fio->new_blkaddr))
@@@ -1018,7 -1005,7 +1005,7 @@@ alloc_new
  
        io->last_block_in_bio = fio->new_blkaddr;
  
-       trace_f2fs_submit_page_write(fio->page, fio);
+       trace_f2fs_submit_folio_write(page_folio(fio->page), fio);
  #ifdef CONFIG_BLK_DEV_ZONED
        if (f2fs_sb_has_blkzoned(sbi) && btype < META &&
                        is_end_zone_blkaddr(sbi, fio->new_blkaddr)) {
@@@ -1289,7 -1276,7 +1276,7 @@@ struct page *f2fs_find_data_page(struc
        struct address_space *mapping = inode->i_mapping;
        struct page *page;
  
-       page = find_get_page(mapping, index);
+       page = find_get_page_flags(mapping, index, FGP_ACCESSED);
        if (page && PageUptodate(page))
                return page;
        f2fs_put_page(page, 0);
@@@ -1423,7 -1410,7 +1410,7 @@@ static int __allocate_data_block(struc
                return err;
  
        if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
-               f2fs_invalidate_internal_cache(sbi, old_blkaddr);
+               f2fs_invalidate_internal_cache(sbi, old_blkaddr, 1);
  
        f2fs_update_data_blkaddr(dn, dn->data_blkaddr);
        return 0;
@@@ -2464,7 -2451,7 +2451,7 @@@ next_page
  
  static int f2fs_read_data_folio(struct file *file, struct folio *folio)
  {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        int ret = -EAGAIN;
  
        trace_f2fs_readpage(folio, DATA);
@@@ -3163,6 -3150,7 +3150,7 @@@ continue_unlock
                                continue;
                        }
  #endif
+                       submitted = 0;
                        ret = f2fs_write_single_data_page(folio,
                                        &submitted, &bio, &last_block,
                                        wbc, io_type, 0, true);
@@@ -4043,6 -4031,7 +4031,6 @@@ retry
                cur_lblock = 1; /* force Empty message */
        sis->max = cur_lblock;
        sis->pages = cur_lblock - 1;
 -      sis->highest_bit = cur_lblock - 1;
  out:
        if (not_aligned)
                f2fs_warn(sbi, "Swapfile (%u) is not align to section: 1) creat(), 2) ioctl(F2FS_IOC_SET_PIN_FILE), 3) fallocate(%lu * N)",

diff --combined fs/f2fs/f2fs.h
index fd7e9cb6f89394b67da7013f63b7411f0fb0d9ae,4bfe162eefd36abca58768518ff804b1a28a1c0c..1afa7be16e7da58d0019fdb75abf4bdb266d1485
--- 1/fs/f2fs/f2fs.h
--- 2/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@@ -24,6 -24,7 +24,6 @@@
  #include <linux/quotaops.h>
  #include <linux/part_stat.h>
  #include <linux/rw_hint.h>
 -#include <crypto/hash.h>
  
  #include <linux/fscrypt.h>
  #include <linux/fsverity.h>
@@@ -1767,6 -1768,9 +1767,6 @@@ struct f2fs_sb_info 
        u64 sectors_written_start;
        u64 kbytes_written;
  
 -      /* Reference to checksum algorithm driver via cryptoapi */
 -      struct crypto_shash *s_chksum_driver;
 -
        /* Precomputed FS UUID checksum for seeding other checksums */
        __u32 s_chksum_seed;
  
@@@ -1944,7 -1948,21 +1944,7 @@@ static inline unsigned int f2fs_time_to
  static inline u32 __f2fs_crc32(struct f2fs_sb_info *sbi, u32 crc,
                              const void *address, unsigned int length)
  {
 -      struct {
 -              struct shash_desc shash;
 -              char ctx[4];
 -      } desc;
 -      int err;
 -
 -      BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver) != sizeof(desc.ctx));
 -
 -      desc.shash.tfm = sbi->s_chksum_driver;
 -      *(u32 *)desc.ctx = crc;
 -
 -      err = crypto_shash_update(&desc.shash, address, length);
 -      BUG_ON(err);
 -
 -      return *(u32 *)desc.ctx;
 +      return crc32(crc, address, length);
  }
  
  static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,
@@@ -1985,9 -2003,14 +1985,14 @@@ static inline struct f2fs_sb_info *F2FS
        return F2FS_I_SB(mapping->host);
  }
  
+ static inline struct f2fs_sb_info *F2FS_F_SB(struct folio *folio)
+ {
+       return F2FS_M_SB(folio->mapping);
+ }
+ 
  static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
  {
-       return F2FS_M_SB(page_file_mapping(page));
+       return F2FS_F_SB(page_folio(page));
  }
  
  static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
@@@ -3565,7 -3588,8 +3570,8 @@@ int f2fs_prepare_lookup(struct inode *d
                        struct f2fs_filename *fname);
  void f2fs_free_filename(struct f2fs_filename *fname);
  struct f2fs_dir_entry *f2fs_find_target_dentry(const struct f2fs_dentry_ptr *d,
-                       const struct f2fs_filename *fname, int *max_slots);
+                       const struct f2fs_filename *fname, int *max_slots,
+                       bool use_hash);
  int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
                        unsigned int start_pos, struct fscrypt_str *fstr);
  void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
@@@ -3700,7 -3724,8 +3706,8 @@@ int f2fs_issue_flush(struct f2fs_sb_inf
  int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi);
  int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
  void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
- void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
+ void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr,
+                                               unsigned int len);
  bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
  int f2fs_start_discard_thread(struct f2fs_sb_info *sbi);
  void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);
@@@ -4201,7 -4226,8 +4208,8 @@@ int f2fs_write_inline_data(struct inod
  int f2fs_recover_inline_data(struct inode *inode, struct page *npage);
  struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
                                        const struct f2fs_filename *fname,
-                                       struct page **res_page);
+                                       struct page **res_page,
+                                       bool use_hash);
  int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
                        struct page *ipage);
  int f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname,
@@@ -4368,7 -4394,8 +4376,8 @@@ void f2fs_destroy_page_array_cache(stru
  int __init f2fs_init_compress_cache(void);
  void f2fs_destroy_compress_cache(void);
  struct address_space *COMPRESS_MAPPING(struct f2fs_sb_info *sbi);
- void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi, block_t blkaddr);
+ void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,
+                                       block_t blkaddr, unsigned int len);
  void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
                                                nid_t ino, block_t blkaddr);
  bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
@@@ -4423,8 -4450,8 +4432,8 @@@ static inline int f2fs_init_page_array_
  static inline void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi) { }
  static inline int __init f2fs_init_compress_cache(void) { return 0; }
  static inline void f2fs_destroy_compress_cache(void) { }
- static inline void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi,
-                               block_t blkaddr) { }
+ static inline void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,
+                               block_t blkaddr, unsigned int len) { }
  static inline void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi,
                                struct page *page, nid_t ino, block_t blkaddr) { }
  static inline bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi,
@@@ -4740,10 -4767,10 +4749,10 @@@ static inline void f2fs_truncate_meta_i
  }
  
  static inline void f2fs_invalidate_internal_cache(struct f2fs_sb_info *sbi,
-                                                               block_t blkaddr)
+                                               block_t blkaddr, unsigned int len)
  {
-       f2fs_truncate_meta_inode_pages(sbi, blkaddr, 1);
-       f2fs_invalidate_compress_page(sbi, blkaddr);
+       f2fs_truncate_meta_inode_pages(sbi, blkaddr, len);
+       f2fs_invalidate_compress_pages_range(sbi, blkaddr, len);
  }
  
  #define EFSBADCRC     EBADMSG         /* Bad CRC detected */