f2fs: add lookup_mode mount option

For casefolded directories, f2fs may fall back to a linear search if
a hash-based lookup fails. This can cause severe performance
regressions.

While this behavior can be controlled by userspace tools (e.g. mkfs,
fsck) by setting an on-disk flag, a kernel-level solution is needed
to guarantee the lookup behavior regardless of the on-disk state.

This commit introduces the 'lookup_mode' mount option to provide this
kernel-side control.

The option accepts three values:
- perf: (Default) Enforces a hash-only lookup. The linear fallback
  is always disabled.
- compat: Enables the linear search fallback for compatibility with
  directory entries from older kernels.
- auto: Determines the mode based on the on-disk flag, preserving the
  userspace-based behavior.

Signed-off-by: Daniel Lee <chullee@google.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst
index e5bb89452aff29fea8e0a752f2a01cc835d27b99..5cad369ceb920a95de3f8a500f394b99fddd17aa 100644 (file)
--- a/Documentation/filesystems/f2fs.rst
+++ b/Documentation/filesystems/f2fs.rst
@@ -370,6 +370,25 @@ errors=%s           Specify f2fs behavior on critical errors. This supports modes:
                         ====================== =============== =============== ========
 nat_bits                Enable nat_bits feature to enhance full/empty nat blocks access,
                         by default it's disabled.
+lookup_mode=%s          Control the directory lookup behavior for casefolded
+                        directories. This option has no effect on directories
+                        that do not have the casefold feature enabled.
+
+                        ================== ========================================
+                        Value              Description
+                        ================== ========================================
+                        perf               (Default) Enforces a hash-only lookup.
+                                           The linear search fallback is always
+                                           disabled, ignoring the on-disk flag.
+                        compat             Enables the linear search fallback for
+                                           compatibility with directory entries
+                                           created by older kernel that used a
+                                           different case-folding algorithm.
+                                           This mode ignores the on-disk flag.
+                        auto               F2FS determines the mode based on the
+                                           on-disk `SB_ENC_NO_COMPAT_FALLBACK_FL`
+                                           flag.
+                        ================== ========================================
 ======================== ============================================================
 
 Debugfs Entries

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index fffd7749d6d1ec416e65229e3e8b4e3581651c4f..48f4f98afb0138aefabaa10608961812165e2312 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -16,6 +16,21 @@
 #include "xattr.h"
 #include <trace/events/f2fs.h>
 
+static inline bool f2fs_should_fallback_to_linear(struct inode *dir)
+{
+       struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+
+       switch (F2FS_OPTION(sbi).lookup_mode) {
+       case LOOKUP_PERF:
+               return false;
+       case LOOKUP_COMPAT:
+               return true;
+       case LOOKUP_AUTO:
+               return !sb_no_casefold_compat_fallback(sbi->sb);
+       }
+       return false;
+}
+
 #if IS_ENABLED(CONFIG_UNICODE)
 extern struct kmem_cache *f2fs_cf_name_slab;
 #endif
@@ -366,7 +381,7 @@ start_find_entry:
 
 out:
 #if IS_ENABLED(CONFIG_UNICODE)
-       if (!sb_no_casefold_compat_fallback(dir->i_sb) &&
+       if (f2fs_should_fallback_to_linear(dir) &&
                IS_CASEFOLDED(dir) && !de && use_hash) {
                use_hash = false;
                goto start_find_entry;

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 6b66db642e0981d9b4e20fdd612fb22308e547a8..36d6a6803916180b20f5c301ee1dd60af68ce873 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -212,6 +212,7 @@ struct f2fs_mount_info {
        int compress_mode;                      /* compression mode */
        unsigned char extensions[COMPRESS_EXT_NUM][F2FS_EXTENSION_LEN]; /* extensions */
        unsigned char noextensions[COMPRESS_EXT_NUM][F2FS_EXTENSION_LEN]; /* extensions */
+       unsigned int lookup_mode;
 };
 
 #define F2FS_FEATURE_ENCRYPT                   0x00000001
@@ -1475,6 +1476,12 @@ enum {
        TOTAL_CALL = FOREGROUND,
 };
 
+enum f2fs_lookup_mode {
+       LOOKUP_PERF,
+       LOOKUP_COMPAT,
+       LOOKUP_AUTO,
+};
+
 static inline int f2fs_test_bit(unsigned int nr, char *addr);
 static inline void f2fs_set_bit(unsigned int nr, char *addr);
 static inline void f2fs_clear_bit(unsigned int nr, char *addr);

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index e16c4e2830c298fc41fc8c12595504888f7b5591..0638ae9816ac438de4cd726abe9b0500384a0c57 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -181,6 +181,7 @@ enum {
        Opt_nat_bits,
        Opt_jqfmt,
        Opt_checkpoint,
+       Opt_lookup_mode,
        Opt_err,
 };
 
@@ -244,6 +245,13 @@ static const struct constant_table f2fs_param_errors[] = {
        {}
 };
 
+static const struct constant_table f2fs_param_lookup_mode[] = {
+       {"perf",        LOOKUP_PERF},
+       {"compat",      LOOKUP_COMPAT},
+       {"auto",        LOOKUP_AUTO},
+       {}
+};
+
 static const struct fs_parameter_spec f2fs_param_specs[] = {
        fsparam_enum("background_gc", Opt_gc_background, f2fs_param_background_gc),
        fsparam_flag("disable_roll_forward", Opt_disable_roll_forward),
@@ -300,6 +308,7 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
        fsparam_enum("memory", Opt_memory_mode, f2fs_param_memory_mode),
        fsparam_flag("age_extent_cache", Opt_age_extent_cache),
        fsparam_enum("errors", Opt_errors, f2fs_param_errors),
+       fsparam_enum("lookup_mode", Opt_lookup_mode, f2fs_param_lookup_mode),
        {}
 };
 
@@ -336,6 +345,7 @@ static match_table_t f2fs_checkpoint_tokens = {
 #define F2FS_SPEC_discard_unit                 (1 << 21)
 #define F2FS_SPEC_memory_mode                  (1 << 22)
 #define F2FS_SPEC_errors                       (1 << 23)
+#define F2FS_SPEC_lookup_mode                  (1 << 24)
 
 struct f2fs_fs_context {
        struct f2fs_mount_info info;
@@ -1143,6 +1153,10 @@ static int f2fs_parse_param(struct fs_context *fc, struct fs_parameter *param)
        case Opt_nat_bits:
                ctx_set_opt(ctx, F2FS_MOUNT_NAT_BITS);
                break;
+       case Opt_lookup_mode:
+               F2FS_CTX_INFO(ctx).lookup_mode = result.uint_32;
+               ctx->spec_mask |= F2FS_SPEC_lookup_mode;
+               break;
        }
        return 0;
 }
@@ -1652,6 +1666,8 @@ static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
                F2FS_OPTION(sbi).memory_mode = F2FS_CTX_INFO(ctx).memory_mode;
        if (ctx->spec_mask & F2FS_SPEC_errors)
                F2FS_OPTION(sbi).errors = F2FS_CTX_INFO(ctx).errors;
+       if (ctx->spec_mask & F2FS_SPEC_lookup_mode)
+               F2FS_OPTION(sbi).lookup_mode = F2FS_CTX_INFO(ctx).lookup_mode;
 
        f2fs_apply_compression(fc, sb);
        f2fs_apply_test_dummy_encryption(fc, sb);
@@ -2416,6 +2432,13 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
        if (test_opt(sbi, NAT_BITS))
                seq_puts(seq, ",nat_bits");
 
+       if (F2FS_OPTION(sbi).lookup_mode == LOOKUP_PERF)
+               seq_show_option(seq, "lookup_mode", "perf");
+       else if (F2FS_OPTION(sbi).lookup_mode == LOOKUP_COMPAT)
+               seq_show_option(seq, "lookup_mode", "compat");
+       else if (F2FS_OPTION(sbi).lookup_mode == LOOKUP_AUTO)
+               seq_show_option(seq, "lookup_mode", "auto");
+
        return 0;
 }
 
@@ -2480,6 +2503,8 @@ static void default_options(struct f2fs_sb_info *sbi, bool remount)
 #endif
 
        f2fs_build_fault_attr(sbi, 0, 0, FAULT_ALL);
+
+       F2FS_OPTION(sbi).lookup_mode = LOOKUP_PERF;
 }
 
 #ifdef CONFIG_QUOTA